/*
 * Copyright (c) 1998,1999,2000
 *	Traakan, Inc., Los Altos, CA
 *	All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice unmodified, this list of conditions, and the following
 *    disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

/*
 * Project:  NDMJOB
 * Ident:    $Id: $
 *
 * Description:
 *
 */


#include "ndmagents.h"

#ifndef NDMOS_OPTION_NO_CONTROL_AGENT


/*
 * DATA Agent calls
 ****************************************************************
 */

int
ndmca_data_get_state (struct ndm_session *sess)
{
	struct ndmconn *	conn = sess->plumb.data;
	struct ndm_control_agent *ca = sess->control_acb;
	struct ndmp9_data_get_state_reply *state = &ca->data_state;
	int			rc;

	NDMC_WITH_VOID_REQUEST(ndmp9_data_get_state, NDMP9VER)
		rc = NDMC_CALL(conn);
		if (rc) {
			NDMOS_MACRO_ZEROFILL (state);
			ca->data_state.state = -1;
		} else {
			*state = *reply;
		}
	NDMC_ENDWITH

	return rc;
}

int
ndmca_data_listen (struct ndm_session *sess)
{
	struct ndmconn *	conn = sess->plumb.data;
	struct ndm_control_agent *ca = sess->control_acb;
	int			rc;

	NDMC_WITH(ndmp9_data_listen, NDMP9VER)
		if (sess->plumb.tape == sess->plumb.data) {
			request->addr_type = NDMP9_ADDR_LOCAL;
		} else {
			request->addr_type = NDMP9_ADDR_TCP;
		}
		rc = NDMC_CALL(conn);
		if (rc) return rc;

		if (request->addr_type
		 != reply->data_connection_addr.addr_type) {
			ndmalogf (sess, 0, 0,
				"DATA_LISTEN addr_type mismatch");
			return -1;
		}

		ca->data_addr = reply->data_connection_addr;
	NDMC_ENDWITH

	return 0;
}

int
ndmca_data_connect (struct ndm_session *sess)
{
	struct ndmconn *	conn = sess->plumb.data;
	struct ndm_control_agent *ca = sess->control_acb;
	int			rc;
	ndmp9_addr		addr;

	if (ca->job.tape_tcp) {
		char *host;
		char *port;
		struct sockaddr_in sin;

		host = ca->job.tape_tcp;
		port = strchr(ca->job.tape_tcp, ':');
		if (!port) {
		    return 1;
		}
		*port++ = '\0';
		rc = ndmhost_lookup(host, &sin);
		addr.addr_type = NDMP9_ADDR_TCP;
		addr.ndmp9_addr_u.tcp_addr.ip_addr = ntohl(sin.sin_addr.s_addr);
		addr.ndmp9_addr_u.tcp_addr.port = atoi(port);
	} else {
		addr = ca->mover_addr;
	}

	NDMC_WITH(ndmp9_data_connect, NDMP9VER)
		request->addr = addr;
		rc = NDMC_CALL(conn);
	NDMC_ENDWITH

	return rc;
}

int
ndmca_data_start_backup (struct ndm_session *sess)
{
	struct ndmconn *	conn = sess->plumb.data;
	struct ndm_control_agent *ca = sess->control_acb;
	unsigned		n_env;
	ndmp9_pval *		env;
	ndmp9_addr		addr;
	int			rc;

	if (conn->protocol_version > 2) {
	    if (ca->swap_connect) {
		if ( (rc = ndmca_mover_connect (sess)) != 0) {
			return rc;
		}
	    } else {
		if ( (rc = ndmca_data_connect (sess)) != 0) {
			return rc;
		}
	    }
	    addr.addr_type = NDMP9_ADDR_AS_CONNECTED;
	} else {
		addr = ca->mover_addr;
	}

	env = ndma_enumerate_env_list(&ca->job.env_tab);
	if (!env) {
		ndmalogf (sess, 0, 0,
			"Failed allocating enumerate buffer");
		return -1;
	}
	n_env = ca->job.env_tab.n_env;
	NDMC_WITH(ndmp9_data_start_backup, NDMP9VER)
		request->addr = addr;
		request->bu_type = ca->job.bu_type;
		request->env.env_len = n_env;
		request->env.env_val = env;

		rc = NDMC_CALL(conn);
	NDMC_ENDWITH

	return rc;
}

int
ndmca_data_start_recover (struct ndm_session *sess)
{
	struct ndmconn *	conn = sess->plumb.data;
	struct ndm_control_agent *ca = sess->control_acb;
	unsigned		n_env;
	ndmp9_pval *		env;
	unsigned		n_nlist;
	ndmp9_name *		nlist;
	ndmp9_addr		addr;
	int			rc;

	if (conn->protocol_version > 2) {
	    if (ca->swap_connect) {
		if ( (rc = ndmca_mover_connect (sess)) != 0) {
			return rc;
		}
	    } else {
		if ( (rc = ndmca_data_connect (sess)) != 0) {
			return rc;
		}
	    }
	    addr.addr_type = NDMP9_ADDR_AS_CONNECTED;
	} else {
		addr = ca->mover_addr;
	}

	env = ndma_enumerate_env_list(&ca->job.env_tab);
	if (!env) {
		ndmalogf (sess, 0, 0,
			"Failed allocating enumerate buffer");
		return -1;
	}
	n_env = ca->job.env_tab.n_env;
	nlist = ndma_enumerate_nlist(&ca->job.nlist_tab);
	n_nlist = ca->job.nlist_tab.n_nlist;
	NDMC_WITH(ndmp9_data_start_recover, NDMP9VER)
		request->addr = addr;
		request->bu_type = ca->job.bu_type;
		request->env.env_len = n_env;
		request->env.env_val = env;
		request->nlist.nlist_len = n_nlist;
		request->nlist.nlist_val = nlist;

		rc = NDMC_CALL(conn);
	NDMC_ENDWITH

	return rc;
}

int
ndmca_data_start_recover_filehist (struct ndm_session *sess)
{
	struct ndmconn *	conn = sess->plumb.data;
	struct ndm_control_agent *ca = sess->control_acb;
	unsigned		n_env;
	ndmp9_pval *		env;
	unsigned		n_nlist;
	ndmp9_name *		nlist;
	ndmp9_addr		addr;
	int			rc;

	if (conn->protocol_version > 2) {
	    if (ca->swap_connect) {
		if ( (rc = ndmca_mover_connect (sess)) != 0) {
			return rc;
		}
	    } else {
		if ( (rc = ndmca_data_connect (sess)) != 0) {
			return rc;
		}
	    }
		addr.addr_type = NDMP9_ADDR_AS_CONNECTED;
	} else {
		addr = ca->mover_addr;
	}

	env = ndma_enumerate_env_list(&ca->job.env_tab);
	if (!env) {
		ndmalogf (sess, 0, 0,
			"Failed allocating enumerate buffer");
		return -1;
	}
	n_env = ca->job.env_tab.n_env;
	nlist = ndma_enumerate_nlist(&ca->job.nlist_tab);
	n_nlist = ca->job.nlist_tab.n_nlist;
	NDMC_WITH(ndmp9_data_start_recover_filehist, NDMP9VER)
		request->addr = addr;
		request->bu_type = ca->job.bu_type;
		request->env.env_len = n_env;
		request->env.env_val = env;
		request->nlist.nlist_len = n_nlist;
		request->nlist.nlist_val = nlist;

		rc = NDMC_CALL(conn);
	NDMC_ENDWITH

	return rc;
}

int
ndmca_data_abort (struct ndm_session *sess)
{
	struct ndmconn *	conn = sess->plumb.data;
	int			rc;

	NDMC_WITH_VOID_REQUEST(ndmp9_data_abort, NDMP9VER)
		rc = NDMC_CALL(conn);
	NDMC_ENDWITH

	return rc;
}

int
ndmca_data_get_env (struct ndm_session *sess)
{
	struct ndmconn *	conn = sess->plumb.data;
	struct ndm_control_agent *ca = sess->control_acb;
	int			rc;
	unsigned int		i;

	NDMC_WITH_VOID_REQUEST(ndmp9_data_get_env, NDMP9VER)
		rc = NDMC_CALL(conn);
		if (rc) return rc;

		for (i = 0; i < reply->env.env_len; i++) {
			ndma_store_env_list (&ca->job.result_env_tab, &reply->env.env_val[i]);
		}

		NDMC_FREE_REPLY();
	NDMC_ENDWITH

	return rc;
}

int
ndmca_data_stop (struct ndm_session *sess)
{
	struct ndmconn *	conn = sess->plumb.data;
	int			rc;

	NDMC_WITH_VOID_REQUEST(ndmp9_data_stop, NDMP9VER)
		rc = NDMC_CALL(conn);
	NDMC_ENDWITH

	return rc;
}





/*
 * TAPE Agent calls -- TAPE
 ****************************************************************
 */

int
ndmca_tape_open (struct ndm_session *sess)
{
	struct ndmconn *	conn = sess->plumb.tape;
	struct ndm_control_agent *ca = sess->control_acb;
	int			rc;

	NDMC_WITH (ndmp9_tape_open, NDMP9VER)
		request->device = ca->job.tape_device;
		request->mode = ca->tape_mode;
		rc = NDMC_CALL(conn);
		ca->tape_state.error = reply->error;
	NDMC_ENDWITH

	return rc;
}

int
ndmca_tape_close (struct ndm_session *sess)
{
	struct ndmconn *	conn = sess->plumb.tape;
	int			rc;

	NDMC_WITH_VOID_REQUEST(ndmp9_tape_close, NDMP9VER)
		rc = NDMC_CALL(conn);
	NDMC_ENDWITH

	return rc;
}

int
ndmca_tape_get_state (struct ndm_session *sess)
{
	struct ndmconn *	conn = sess->plumb.tape;
	struct ndm_control_agent *ca = sess->control_acb;
	struct ndmp9_tape_get_state_reply *state = &ca->tape_state;
	int			rc;

	NDMC_WITH_VOID_REQUEST(ndmp9_tape_get_state, NDMP9VER)
		rc = NDMC_CALL(conn);
		if (rc) {
			NDMOS_MACRO_ZEROFILL (state);
			/* tape_state.state = -1; */
			state->error = reply->error;
		} else {
			*state = *reply;
		}
	NDMC_ENDWITH

	return rc;
}

int
ndmca_tape_get_state_no_tattle (struct ndm_session *sess)
{
	struct ndmconn *	conn = sess->plumb.tape;
	struct ndm_control_agent *ca = sess->control_acb;
	struct ndmp9_tape_get_state_reply *state = &ca->tape_state;
	int			rc;

	NDMC_WITH_VOID_REQUEST(ndmp9_tape_get_state, NDMP9VER)
		rc = ndma_call_no_tattle (conn, xa);
		if (rc) {
			NDMOS_MACRO_ZEROFILL (state);
			/* tape_state.state = -1; */
		} else {
			*state = *reply;
		}
		if (rc < 0
		 ||  (reply->error != NDMP9_DEV_NOT_OPEN_ERR
		   && reply->error != NDMP9_NO_ERR))
			ndma_tattle (sess->plumb.tape, xa, rc);
	NDMC_ENDWITH

	return rc;
}

int
ndmca_tape_mtio (struct ndm_session *sess,
  ndmp9_tape_mtio_op op, uint32_t count, uint32_t *resid)
{
	struct ndmconn *	conn = sess->plumb.tape;
	int			rc;

	NDMC_WITH(ndmp9_tape_mtio, NDMP9VER)
		request->tape_op = op;
		request->count = count;

		rc = NDMC_CALL(conn);
		if (!rc) {
			if (resid) {
				*resid = reply->resid_count;
			} else if (reply->resid_count != 0) {
				return -1;
			}
		}
	NDMC_ENDWITH

	return rc;
}

int
ndmca_tape_write (struct ndm_session *sess, char *buf, unsigned count)
{
	struct ndmconn *	conn = sess->plumb.tape;
	int			rc;

	NDMC_WITH(ndmp9_tape_write, NDMP9VER)
		request->data_out.data_out_len = count;
		request->data_out.data_out_val = buf;
		rc = NDMC_CALL(conn);
		if (rc == 0) {
			if (reply->count != count)
				rc = -1;
		}
	NDMC_ENDWITH

	return rc;
}

int
ndmca_tape_read (struct ndm_session *sess, char *buf, unsigned count)
{
	struct ndmconn *	conn = sess->plumb.tape;
	int			rc;

	NDMC_WITH(ndmp9_tape_read, NDMP9VER)
		request->count = count;
		rc = NDMC_CALL(conn);
		if (rc == 0) {
			if (reply->data_in.data_in_len == count) {
				bcopy (reply->data_in.data_in_val,
							buf, count);
			} else {
				rc = -1;
			}
		}
		NDMC_FREE_REPLY();
	NDMC_ENDWITH

	return rc;
}


int
ndmca_tape_read_partial (struct ndm_session *sess, char *buf, unsigned count, int *read_count)
{
	struct ndmconn *	conn = sess->plumb.tape;
	int			rc;

	NDMC_WITH(ndmp9_tape_read, NDMP9VER)
		request->count = count;
		rc = NDMC_CALL(conn);
		if (rc == 0) {
			*read_count = reply->data_in.data_in_len;
			bcopy (reply->data_in.data_in_val, buf, *read_count);
		} else {
			rc = reply->error;
		}
		NDMC_FREE_REPLY();
	NDMC_ENDWITH

	return rc;
}


/*
 * TAPE Agent calls -- MOVER
 ****************************************************************
 */

int
ndmca_mover_get_state (struct ndm_session *sess)
{
	struct ndmconn *	conn = sess->plumb.tape;
	struct ndm_control_agent *ca = sess->control_acb;
	struct ndmp9_mover_get_state_reply *state = &ca->mover_state;
	int			rc;

	NDMC_WITH_VOID_REQUEST(ndmp9_mover_get_state, NDMP9VER)
		rc = NDMC_CALL(conn);
		if (rc) {
			NDMOS_MACRO_ZEROFILL (state);
			ca->mover_state.state = -1;
		} else {
			*state = *reply;
		}
	NDMC_ENDWITH

	return rc;
}

int
ndmca_mover_listen (struct ndm_session *sess)
{
	struct ndmconn *	conn = sess->plumb.tape;
	struct ndm_control_agent *ca = sess->control_acb;
	int			rc;

	NDMC_WITH(ndmp9_mover_listen, NDMP9VER)
		request->mode = ca->mover_mode;

		if (sess->plumb.tape == sess->plumb.data) {
			request->addr_type = NDMP9_ADDR_LOCAL;
		} else {
			request->addr_type = NDMP9_ADDR_TCP;
		}
		rc = NDMC_CALL(conn);
		if (rc) return rc;

		if (request->addr_type
		 != reply->data_connection_addr.addr_type) {
			ndmalogf (sess, 0, 0,
				"MOVER_LISTEN addr_type mismatch");
			return -1;
		}

		ca->mover_addr = reply->data_connection_addr;
	NDMC_ENDWITH

	return 0;
}

int
ndmca_mover_connect (struct ndm_session *sess)
{
	struct ndmconn *	conn = sess->plumb.tape;
	struct ndm_control_agent *ca = sess->control_acb;
	int			rc;

	NDMC_WITH(ndmp9_mover_connect, NDMP9VER)
		request->mode = ca->mover_mode;
		request->addr = ca->data_addr;
		rc = NDMC_CALL(conn);
	NDMC_ENDWITH

	return rc;
}

int
ndmca_mover_continue (struct ndm_session *sess)
{
	struct ndmconn *	conn = sess->plumb.tape;
	int			rc;

	NDMC_WITH_VOID_REQUEST(ndmp9_mover_continue, NDMP9VER)
		rc = NDMC_CALL(conn);
	NDMC_ENDWITH

	return rc;
}

int
ndmca_mover_abort (struct ndm_session *sess)
{
	struct ndmconn *	conn = sess->plumb.tape;
	int			rc;

	NDMC_WITH_VOID_REQUEST(ndmp9_mover_abort, NDMP9VER)
		rc = NDMC_CALL(conn);
	NDMC_ENDWITH

	return rc;
}

int
ndmca_mover_stop (struct ndm_session *sess)
{
	struct ndmconn *	conn = sess->plumb.tape;
	int			rc;

	NDMC_WITH_VOID_REQUEST(ndmp9_mover_stop, NDMP9VER)
		rc = NDMC_CALL(conn);
	NDMC_ENDWITH

	return rc;
}

int
ndmca_connect_close (struct ndm_session *sess)
{
	struct ndmconn *	conn = sess->plumb.tape;
	int			rc;

	NDMC_WITH_NO_REPLY(ndmp9_connect_close, NDMP9VER)
		rc = NDMC_CALL(conn);
	NDMC_ENDWITH

	return rc;
}

int
ndmca_mover_set_window (struct ndm_session *sess,
  uint64_t offset, uint64_t length)
{
	struct ndmconn *	conn = sess->plumb.tape;
	int			rc;

	NDMC_WITH(ndmp9_mover_set_window, NDMP9VER)
		request->offset = offset;
		request->length = length;
		rc = NDMC_CALL(conn);
	NDMC_ENDWITH

	return rc;
}

int
ndmca_mover_read (struct ndm_session *sess,
  uint64_t offset, uint64_t length)
{
	struct ndmconn *	conn = sess->plumb.tape;
	int			rc;

	NDMC_WITH(ndmp9_mover_read, NDMP9VER)
		request->offset = offset;
		request->length = length;
		rc = NDMC_CALL(conn);
	NDMC_ENDWITH

	return rc;
}

int
ndmca_mover_close (struct ndm_session *sess)
{
	struct ndmconn *	conn = sess->plumb.tape;
	int			rc;

	NDMC_WITH_VOID_REQUEST(ndmp9_mover_close, NDMP9VER)
		rc = NDMC_CALL(conn);
	NDMC_ENDWITH

	return rc;
}

int
ndmca_mover_set_record_size (struct ndm_session *sess)
{
	struct ndmconn *	conn = sess->plumb.tape;
	struct ndm_control_agent *ca = sess->control_acb;
	int			rc;

	NDMC_WITH(ndmp9_mover_set_record_size, NDMP9VER)
		request->record_size = ca->job.record_size;
		rc = NDMC_CALL(conn);
	NDMC_ENDWITH

	return rc;
}
#endif /* !NDMOS_OPTION_NO_CONTROL_AGENT */