/*

 * 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 "ndmjob.h"

#ifndef NDMOS_OPTION_NO_CONTROL_AGENT

int

build_job (void)

{

	struct ndm_job_param *	job = &the_job;

	int			i, rc, n_err;

	char			errbuf[100];

	NDMOS_MACRO_ZEROFILL(job);

	args_to_job ();

	ndma_job_auto_adjust (job);

	if (o_rules)

		apply_rules (job, o_rules);

	i = n_err = 0;

	do {

		rc = ndma_job_audit (job, errbuf, i);

		if (rc > n_err || rc < 0) {

			ndmjob_log (0, "error: %s", errbuf);

		}

		n_err = rc;

	} while (i++ < n_err);

	if (n_err) {

		error_byebye ("can't proceed");

		/* no return */

	}

	return 0;

}

int

args_to_job (void)

{

	struct ndm_job_param *	job = &the_job;

	int			i;

	switch (the_mode) {

	case NDM_JOB_OP_QUERY_AGENTS:

	case NDM_JOB_OP_INIT_LABELS:

	case NDM_JOB_OP_LIST_LABELS:

	case NDM_JOB_OP_REMEDY_ROBOT:

	case NDM_JOB_OP_TEST_TAPE:

	case NDM_JOB_OP_TEST_MOVER:

	case NDM_JOB_OP_TEST_DATA:

	case NDM_JOB_OP_REWIND_TAPE:

	case NDM_JOB_OP_EJECT_TAPE:

	case NDM_JOB_OP_MOVE_TAPE:

	case NDM_JOB_OP_IMPORT_TAPE:

	case NDM_JOB_OP_EXPORT_TAPE:

	case NDM_JOB_OP_LOAD_TAPE:

	case NDM_JOB_OP_UNLOAD_TAPE:

	case NDM_JOB_OP_INIT_ELEM_STATUS:

		break;

	case NDM_JOB_OP_BACKUP:

		args_to_job_backup_env();

		break;

	case NDM_JOB_OP_TOC:

		args_to_job_recover_env();

		args_to_job_recover_nlist();

		if (J_index_file) {

			jndex_doit();

			jndex_merge_environment();

		}

		break;

	case NDM_JOB_OP_EXTRACT:

		args_to_job_recover_env();

		args_to_job_recover_nlist();

		jndex_doit();

		jndex_merge_environment();

		break;

	case 'D':		/* -o daemon */

		return 0;

	default:

		printf ("mode -%c not implemented yet\n", the_mode);

		break;

	}

	job->operation = the_mode;

	/* DATA agent */

	job->data_agent  = D_data_agent;

	job->bu_type = B_bu_type;

	for (i = 0; i < nn_E_environment; i++)

		job->env_tab.env[i] = E_environment[i];

	job->env_tab.n_env = nn_E_environment;

	if (the_mode == NDM_JOB_OP_EXTRACT || the_mode == NDM_JOB_OP_TOC) {

	        for (i = 0; (i < n_file_arg) && (i < NDM_MAX_NLIST); i++) {

			job->nlist_tab.nlist[i] = nlist[i];

			job->nlist_tab.nlist_new[i] = nlist_new[i];

			job->nlist_tab.n_nlist = i + 1;

		}

	}

	job->index_log.deliver = ndmjob_ixlog_deliver;

	/* TAPE agent */

	job->tape_agent  = T_tape_agent;

	job->tape_device = f_tape_device;

	job->record_size = b_bsize * 512;

	job->tape_timeout = o_tape_timeout;

	job->use_eject = o_use_eject;

	job->tape_target = o_tape_scsi;

	job->tape_tcp = o_tape_tcp;

	/* ROBOT agent */

	job->robot_agent = R_robot_agent;

	job->robot_target = r_robot_target;

	job->robot_timeout = o_robot_timeout;

	if (o_tape_addr >= 0) {

		job->drive_addr = o_tape_addr;

		job->drive_addr_given = 1;

	}

	if (o_from_addr >= 0) {

		job->from_addr = o_from_addr;

		job->from_addr_given = 1;

	}

	if (o_to_addr >= 0) {

		job->to_addr = o_to_addr;

		job->to_addr_given = 1;

	}

	if (ROBOT_GIVEN())

		job->have_robot = 1;

	/* media */

	for (i = 0; i < n_m_media; i++)

		job->media_tab.media[i] = m_media[i];

	job->media_tab.n_media = n_m_media;

	return 0;

}

int

args_to_job_backup_env (void)

{

	int		n_env = n_E_environment;

	int		i;

	if (C_chdir) {

		E_environment[n_env].name = "FILESYSTEM";

		E_environment[n_env].value = C_chdir;

		n_env++;

	}

	E_environment[n_env].name = "HIST";

	E_environment[n_env].value = I_index_file ? "y" : "n";

	n_env++;

	E_environment[n_env].name = "TYPE";

	E_environment[n_env].value = B_bu_type;

	n_env++;

	if (U_user) {

		E_environment[n_env].name = "USER";

		E_environment[n_env].value = U_user;

		n_env++;

	}

	for (i = 0; (i < n_e_exclude_pattern) && (n_env < NDM_MAX_ENV-2); i++) {

		E_environment[n_env].name = "EXCLUDE";

		E_environment[n_env].value = e_exclude_pattern[i];

		n_env++;

	}

	for (i = 0; (i < n_file_arg) && (n_env < NDM_MAX_ENV-1); i++) {

		E_environment[n_env].name = "FILES";

		E_environment[n_env].value = file_arg[i];

		n_env++;

	}

	if (o_rules) {

		E_environment[n_env].name = "RULES";

		E_environment[n_env].value = o_rules;

	}

	nn_E_environment = n_env;

	return n_env;

}

int

args_to_job_recover_env (void)

{

	int		n_env = n_E_environment;

	int		i;

	if (C_chdir) {

		E_environment[n_env].name = "PREFIX";

		E_environment[n_env].value = C_chdir;

		n_env++;

	}

	E_environment[n_env].name = "HIST";

	E_environment[n_env].value = I_index_file ? "y" : "n";

	n_env++;

	E_environment[n_env].name = "TYPE";

	E_environment[n_env].value = B_bu_type;

	n_env++;

	if (U_user) {

		E_environment[n_env].name = "USER";

		E_environment[n_env].value = U_user;

		n_env++;

	}

	for (i = 0; i < n_e_exclude_pattern; i++) {

		E_environment[n_env].name = "EXCLUDE";

		E_environment[n_env].value = e_exclude_pattern[i];

		n_env++;

	}

	if (o_rules) {

		E_environment[n_env].name = "RULES";

		E_environment[n_env].value = o_rules;

	}

	nn_E_environment = n_env;

	/* file_arg[]s are done in nlist[] */

	jndex_merge_environment ();

	return nn_E_environment;

}

void

normalize_name (char *name)

{

	char *		p = name;

	while (*p) {

		if (*p == '/' && p[1] == '/') {

			strcpy (p, p+1);

			continue;

		}

		if (p[0] == '/' && p[1] == '.' && (p[2] == '/' || p[2] == 0)) {

			strcpy (p, p+2);

			continue;

		}

		p++;

	}

}

int

args_to_job_recover_nlist (void)

{

	int		not_found = 0;

	int		i, prefix_len, len;

	char *		dest;

	if (C_chdir) {

		prefix_len = strlen (C_chdir) + 2;

	} else {

		prefix_len = 0;

	}

	for (i = 0; (i < n_file_arg) && (i < NDM_MAX_NLIST); i++) {

	    if (file_arg_new[i]) {

		len = strlen (file_arg_new[i]) + prefix_len + 1;

		dest = NDMOS_API_MALLOC (len);

		*dest = 0;

		if (C_chdir) {

			strcpy (dest, C_chdir);

		}

		if (file_arg_new[i][0] != '/') {

			strcat (dest, "/");

		}

		strcat (dest, file_arg_new[i]);

		normalize_name (file_arg_new[i]);

		normalize_name (file_arg[i]);

		normalize_name (dest);

		nlist[i].original_path = file_arg[i];

		nlist[i].destination_path = dest;

	    } else {

		len = strlen (file_arg[i]) + prefix_len + 1;

		dest = NDMOS_API_MALLOC (len);

		*dest = 0;

		if (C_chdir) {

			strcpy (dest, C_chdir);

		}

		if (file_arg[i][0] != '/') {

			strcat (dest, "/");

		}

		strcat (dest, file_arg[i]);

		normalize_name (file_arg[i]);

		normalize_name (dest);

		nlist[i].original_path = file_arg[i];

		nlist[i].destination_path = dest;

	    }

	}

	return not_found;	/* should ALWAYS be 0 */

}

/*

 * Index files are sequentially searched. They can be VERY big.

 * There is a credible effort for efficiency here.

 * Probably lots and lots and lots of room for improvement.

 */

FILE *		jndex_open (void);

int

jndex_doit (void)

{

	FILE *		fp;

	int		rc;

	fp = jndex_open();

	if (!fp) {

		/* error messages already given */

		return -1;

	}

	ndmjob_log (1, "Processing input index (-J%s)", J_index_file);

	if (n_file_arg > 0) {

		rc = ndmfhdb_add_fh_info_to_nlist (fp, nlist, n_file_arg);

		if (rc < 0) {

			/* toast one way or another */

		}

	}

	jndex_fetch_post_backup_data_env(fp);

	jndex_fetch_post_backup_media(fp);

	jndex_tattle();

	if (jndex_audit_not_found ()) {

		ndmjob_log (1,

			"Warning: Missing index entries, valid file name(s)?");

	}

	jndex_merge_media ();

	fclose(fp);

	return 0;

}

FILE *

jndex_open (void)

{

	char		buf[256];

	FILE *		fp;

	if (!J_index_file) {

		/* Hmmm. */

		ndmjob_log (1, "Warning: No -J input index?");

		return 0;

	}

	ndmjob_log (1, "Reading input index (-I%s)", J_index_file);

	fp = fopen(J_index_file, "r");

	if (!fp) {

		perror (J_index_file);

		error_byebye ("Can not open -J%s input index", J_index_file);

		/* no return */

	}

	if (fgets (buf, sizeof buf, fp) == NULL) {

		fclose (fp);

		error_byebye ("Failed read 1st line of -J%s", J_index_file);

		/* no return */

	}

	if (strcmp (buf, "##ndmjob -I\n") != 0) {

		fclose (fp);

		error_byebye ("Bad 1st line in -J%s", J_index_file);

		/* no return */

	}

	if (fgets (buf, sizeof buf, fp) == NULL) {

		fclose (fp);

		error_byebye ("Failed read 2nd line of -J%s", J_index_file);

		/* no return */

	}

	if (strcmp (buf, "##ndmjob -J\n") != 0) {

		fclose (fp);

		error_byebye ("Bad 2nd line in -J%s", J_index_file);

		/* no return */

	}

	ndmjob_log (2, "Opened index (-J%s)", J_index_file);

	return fp;

}

int

jndex_tattle (void)

{

	char		buf[100];

	int		i;

	for (i = 0; i < n_ji_media; i++) {

		struct ndmmedia *	me = &ji_media[i];

		ndmmedia_to_str (me, buf);

		ndmjob_log (3, "ji me[%d] %s", i, buf);

	}

	for (i = 0; i < n_ji_environment; i++) {

		ndmp9_pval *		pv = &ji_environment[i];

		ndmjob_log (3, "ji env[%d] %s=%s", i, pv->name, pv->value);

	}

	for (i = 0; (i < n_file_arg) && (i < NDM_MAX_NLIST); i++) {

		if (nlist[i].fh_info.valid) {

			ndmjob_log (3, "ji fil[%d] fi=%lld %s",

				i, nlist[i].fh_info.value, file_arg[i]);

		} else {

			ndmjob_log (3, "ji fil[%d] not-found %s",

				i, file_arg[i]);

		}

	}

	return 0;

}

int

jndex_merge_media (void)

{

	struct ndmmedia *	me;

	struct ndmmedia *	jme;

	int			i, j;

	for (j = 0; j < n_ji_media; j++) {

		jme = &ji_media[j];

		if (! jme->valid_label)

			continue;	/* can't match it up */

		for (i = 0; i < n_m_media; i++) {

			me = &m_media[i];

			if (! me->valid_label)

				continue;	/* can't match it up */

			if (strcmp (jme->label, me->label) != 0)

				continue;

			if (!jme->valid_slot &&  me->valid_slot) {

				jme->slot_addr = me->slot_addr;

				jme->valid_slot = 1;

			}

		}

	}

	for (i = 0; i < n_ji_media; i++) {

		m_media[i] = ji_media[i];

	}

	n_m_media = i;

	ndmjob_log (3, "After merging input -J index with -m entries");

	for (i = 0; i < n_m_media; i++) {

		char		buf[40];

		me = &m_media[i];

		ndmmedia_to_str (me, buf);

		ndmjob_log (3, "%d: -m %s", i+1, buf);

	}

	return 0;

}

int

jndex_audit_not_found (void)

{

	int		i;

	int		not_found = 0;

	for (i = 0; (i < n_file_arg) && (i < NDM_MAX_NLIST); i++) {

		if (!nlist[i].fh_info.valid) {

			ndmjob_log (0, "No index entry for %s", file_arg[i]);

			not_found++;

		}

	}

	return not_found;

}

int

jndex_merge_environment (void)

{

	int		i;

	for (i = 0; i < n_ji_environment; i++) {

		if (strcmp(ji_environment[i].name, "FILESYSTEM") != 0 &&

		    strcmp(ji_environment[i].name, "PREFIX") != 0 &&

		    strcmp(ji_environment[i].name, "HIST") != 0 &&

		    strcmp(ji_environment[i].name, "TYPE") != 0) {

			E_environment[nn_E_environment++] = ji_environment[i];

		}

	}

	return 0;

}

int

jndex_fetch_post_backup_data_env (FILE *fp)

{

	int		rc;

	char		buf[512];

	char *		p;

	char *		q;

	rc = ndmbstf_first (fp, "DE ", buf, sizeof buf);

	if (rc <= 0) {

		return rc;	/* error or not found */

	}

	/* DE HIST=Yes */

	while (buf[0] == 'D' && buf[1] == 'E' && buf[2] == ' ') {

		if (n_ji_environment >= NDM_MAX_ENV) {

			goto overflow;

		}

		p = &buf[2];

		while (*p == ' ') p++;

		if (!strchr (p, '=')) {

			goto malformed;

		}

		p = NDMOS_API_STRDUP (p);

		q = strchr (p, '=');

		if (!q) {

			goto malformed;

		}

		*q++ = 0;

		ji_environment[n_ji_environment].name = p;

		ji_environment[n_ji_environment].value = q;

		n_ji_environment++;

		rc = ndmbstf_getline (fp, buf, sizeof buf);

		if (rc <= 0) {

			break;

		}

		continue;

  malformed:

		ndmjob_log (1, "Malformed in -J%s: %s", J_index_file, buf);

		continue;

  overflow:

		ndmjob_log (1, "Overflow in -J%s: %s", J_index_file, buf);

	}

	return 0;

}

int

jndex_fetch_post_backup_media (FILE *fp)

{

	int		rc;

	char		buf[512];

	rc = ndmbstf_first (fp, "CM ", buf, sizeof buf);

	if (rc <= 0) {

		return rc;	/* error or not found */

	}

	/* CM 01 T103/10850K */

	while (buf[0] == 'C' && buf[1] == 'M' && buf[2] == ' ') {

		struct ndmmedia *	me;

		if (n_ji_media >= NDM_MAX_MEDIA) {

			goto overflow;

		}

		me = &ji_media[n_ji_media];

		if (ndmmedia_from_str (me, &buf[6])) {

			goto malformed;

		}

		n_ji_media++;

		rc = ndmbstf_getline (fp, buf, sizeof buf);

		if (rc <= 0) {

			break;

		}

		continue;

  malformed:

		ndmjob_log (1, "Malformed in -J%s: %s", J_index_file, buf);

		continue;

  overflow:

		ndmjob_log (1, "Overflow in -J%s: %s", J_index_file, buf);

	}

	return 0;

}

#endif /* !NDMOS_OPTION_NO_CONTROL_AGENT */