/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License (the "License").

 * You may not use this file except in compliance with the License.

 *

 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

 * or http://www.opensolaris.org/os/licensing.

 * See the License for the specific language governing permissions

 * and limitations under the License.

 *

 * When distributing Covered Code, include this CDDL HEADER in each

 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

 * If applicable, add the following below this CDDL HEADER, with the

 * fields enclosed by brackets "[]" replaced with your own identifying

 * information: Portions Copyright [yyyy] [name of copyright owner]

 *

 * CDDL HEADER END

 */

/*

 * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.

 */

#include <alloca.h>

#include <fcntl.h>

#include <stdio.h>

#include <errno.h>

#include <stdarg.h>

#include <stdlib.h>

#include <strings.h>

#include <unistd.h>

#include <libnvpair.h>

#include <locale.h>

#include <sys/param.h>

#include <sys/types.h>

#include "auto_install.h"

#include <ls_api.h>

#include <orchestrator_api.h>

/*

 * use presence of hidden file to indicate iSCSI boot installation

 * pending code refactoring to make less kludgy

 * see also ict.py

 */

#define	ISCSI_BOOT_INDICATOR_FILE "/.iscsi_boot"

static  boolean_t install_done = B_FALSE;

static	boolean_t install_failed = B_FALSE;

/* debug mode - disabled by default */

static	boolean_t debug_mode_enabled = B_FALSE;

int	install_error = 0;

install_params	params;

static boolean_t convert_to_sectors(auto_size_units_t,

    uint64_t, uint64_t *);

void auto_update_progress(om_callback_info_t *, uintptr_t);

static void

usage()

{

	(void) fprintf(stderr,

	    "usage: auto-install -d <diskname> | -p <profile>\n"

	    "\t-i - end installation before Target Instantiation\n"

	    "\t-I - end installation after Target Instantiation\n"

	    "\t-v - run the installer in verbose mode\n");

}

/*

 * enable_debug_mode()

 *

 * Description: Enable/disable debug mode

 *

 * Scope: private

 *

 * Parameters:

 *   enable: B_TRUE - enable debug mode

 *           B_FALSE - disable debug mode

 *

 * Returns: none

 */

static void

enable_debug_mode(boolean_t enable)

{

	debug_mode_enabled = enable;

}

/*

 * is_debug_mode_enabled()

 *

 * Description: Checks, if we run in debug mode

 *

 * Scope: private

 *

 * Parameters: none

 *

 * Returns:

 *   B_TRUE - debug mode enabled

 *   B_FALSE - debug mode disabled

 */

static boolean_t

is_debug_mode_enabled(void)

{

	return (debug_mode_enabled);

}

/*

 * auto_debug_print()

 * Description:	Posts debug message

 */

void

auto_debug_print(ls_dbglvl_t dbg_lvl, char *fmt, ...)

{

	va_list	ap;

	char	buf[MAXPATHLEN + 1] = "";

	va_start(ap, fmt);

	(void) vsnprintf(buf, MAXPATHLEN+1, fmt, ap);

	(void) ls_write_dbg_message("AI", dbg_lvl, buf);

	va_end(ap);

}

/*

 * auto_log_print()

 * Description:	Posts log message

 */

void

auto_log_print(char *fmt, ...)

{

	va_list	ap;

	char	buf[MAXPATHLEN + 1] = "";

	va_start(ap, fmt);

	(void) vsnprintf(buf, MAXPATHLEN+1, fmt, ap);

	(void) ls_write_log_message("AI", buf);

	va_end(ap);

}

/*

 * Callback that gets passed to om_perform_install.

 *

 * Sets the install_done variable when an install is

 * finished. If an install fails, it sets the install_failed

 * variable and also sets the install_error variable to

 * indicate the specific reason for the failure.

 */

void

auto_update_progress(om_callback_info_t *cb_data, uintptr_t app_data)

{

	if (cb_data->curr_milestone == -1) {

		install_error = cb_data->percentage_done;

		install_failed = B_TRUE;

	}

	if (cb_data->curr_milestone == OM_SOFTWARE_UPDATE &&

	    cb_data->percentage_done == 100)

		auto_debug_print(AUTO_DBGLVL_INFO,

		    "Transfer completed\n");

	if (cb_data->curr_milestone == OM_POSTINSTAL_TASKS &&

	    cb_data->percentage_done == 100)

		install_done = B_TRUE;

}

/*

 * auto_debug_dump_file()

 * Description: dumps a file using auto_debug_print()

 */

void

auto_debug_dump_file(ls_dbglvl_t level, char *filename)

{

	FILE *file_ptr;

	char buffer[MAXPATHLEN];

	/* Logfile does not exist.  Nothing to print. */

	if (access(filename, F_OK) < 0) {

		return;

	}

	if (access(filename, R_OK) < 0) {

		auto_debug_print(AUTO_DBGLVL_ERR,

		    "ddu errlog %s does not have read permissions.\n");

		return;

	}

	/* Use buffer to set up the command. */

	if ((file_ptr = popen(buffer, "r")) == NULL) {

		auto_debug_print(AUTO_DBGLVL_ERR,

		    "Error opening ddu errlog %s to dump errors: %s\n",

		    filename, strerror(errno));

		return;

	}

	/* Reuse buffer to get the file data. */

	while (fgets(buffer, MAXPATHLEN, file_ptr) != NULL) {

		auto_debug_print(level, "%s", buffer);

	}

	(void) pclose(file_ptr);

}

/*

 * This function splits the passed in file into AI manifest and SC manifest

 *

 * Input:

 * char *input_file	- AI manifest file with embedded SC manifest

 *

 * Output:

 * char *ai_manifest	- Writes the AI manifest portion of the input to this

 *			  file name

 * char *sc_manifest	- Writes the SC manifest portion of the input to this

 *			  file name

 * Returns:

 * AUTO_VALID_MANIFEST (0)	- If the operation is successful

 * AUTO_INVALID_MANIFEST (-1)	- If the operation fails

 */

static int

auto_split_manifests(char *input_file, char *ai_manifest, char *sc_manifest)

{

	FILE		*ifp;	/* Input file */

	FILE		*aifp;	/* AI manifest */

	FILE		*scfp;	/* SC manifest */

	boolean_t	writing_ai_manifest = B_TRUE;

	boolean_t	writing_sc_manifest = B_FALSE;

	char		buf[BUFSIZ];

	if (input_file == NULL || ai_manifest == NULL || sc_manifest == NULL) {

		return (AUTO_INVALID_MANIFEST);

	}

	if (access(input_file, F_OK) != 0) {

		return (AUTO_INVALID_MANIFEST);

	}

	/*

	 * Open the input file in read-only mode

	 */

	ifp = fopen(input_file, "r");

	if (ifp == NULL) {

		auto_log_print(gettext("Cannot open AI manifest %s\n"),

		    input_file);

		return (AUTO_INVALID_MANIFEST);

	}

	/*

	 * Open the output files in write mode

	 */

	aifp = fopen(ai_manifest, "w");

	if (aifp == NULL) {

		auto_log_print(gettext("Cannot open AI manifest %s\n"),

		    ai_manifest);

		return (AUTO_INVALID_MANIFEST);

	}

	scfp = fopen(sc_manifest, "w");

	if (scfp == NULL) {

		auto_log_print(gettext("Cannot open SC manifest %s\n"),

		    sc_manifest);

		return (AUTO_INVALID_MANIFEST);

	}

	while (fgets(buf, sizeof (buf), ifp) != NULL) {

		/*

		 * The SC manifest begins with <?xml version='1.0'?> and

		 * ends with the line "</service_bundle>". It is embedded

		 * in the input file between <sc_embedded_manifest ...>

		 * and  </sc_embedded_manifest>.

		 */

		if (strstr(buf, SC_EMBEDDED_BEGIN_MARKER) != NULL) {

			writing_ai_manifest = B_FALSE;

			continue;

		}

		if (strstr(buf, SC_EMBEDDED_END_MARKER) != NULL) {

			writing_ai_manifest = B_TRUE;

			continue;

		}

		if ((strstr(buf, SC_MANIFEST_BEGIN_MARKER) != NULL) &&

		    (! writing_ai_manifest)) {

			writing_sc_manifest = B_TRUE;

			/*

			 * XML is pretty strict about format of XML prolog.

			 * It is optional, but if present, no leading comments

			 * or whitespace characters are allowed.

			 * Assure this by replacing the whole first line

			 * of SC manifest with following string:

			 * "<?xml version='1.0'?>\n"

			 */

			continue;

		}

		if (writing_ai_manifest) {

			continue;

		} else if (writing_sc_manifest) {

			if (strstr(buf, SC_MANIFEST_END_MARKER) != NULL) {

				writing_sc_manifest = B_FALSE;

			}

			continue;

		}

	}

	return (AUTO_VALID_MANIFEST);

}

/*

 * Create a file that contains the list

 * of packages to be installed or removed.

 *

 * Parameters:

 *   hardcode - if set to B_TRUE, hardcode the list of packages. This is for

 *              testing purposes only, when AI engine is not provided with

 *              AI manifest.

 *

 *   pkg_list_type - specify list of packages to be obtained -

 *                   install or remove.

 *

 *   pkg_list_file - output file where the package list will be saved

 *

 * Returns:

 *	AUTO_INSTALL_SUCCESS for success

 *	AUTO_INSTALL_FAILURE for failure

 *	AUTO_INSTALL_EMPTY_LIST - 'remove' list is empty

 */

static int

create_package_list_file(boolean_t hardcode,

    auto_package_list_type_t pkg_list_type, char *pkg_list_file)

{

	FILE *fp;

	char **package_list;

	int i, num_packages = 0;

	int ret = AUTO_INSTALL_SUCCESS;

	if ((fp = fopen(pkg_list_file, "wb")) == NULL) {

		auto_debug_print(AUTO_DBGLVL_ERR,

		    "Couldn't open file %s for storing list of packages\n",

		    pkg_list_file);

		return (AUTO_INSTALL_FAILURE);

	}

	auto_debug_print(AUTO_DBGLVL_INFO,

	    "File %s successfully opened - list of packages to be %s "

	    "will be saved there\n", pkg_list_file,

	    pkg_list_type == AI_PACKAGE_LIST_INSTALL ? "installed" : "removed");

	/*

	 * When invoked in test mode (without AI manifest), lists of packages

	 * are hardcoded

	 */

	if (hardcode) {

		auto_debug_print(AUTO_DBGLVL_INFO,

		    "Hardcoded list of packages will be generated\n");

		if (pkg_list_type == AI_PACKAGE_LIST_INSTALL) {

			if (fputs(AI_TEST_PACKAGE_LIST_INSTALL, fp) == EOF)

				ret = AUTO_INSTALL_FAILURE;

		} else {

			if (fputs(AI_TEST_PACKAGE_LIST_REMOVE, fp) == EOF)

				ret = AUTO_INSTALL_FAILURE;

		}

		(void) fclose(fp);

		return (ret);

	}

	/*

	 * Obtain list of packages to be installed or removed from AI manifest.

	 *

	 * With respect to install list, there are two tags supported for

	 * specifying list of packages in order to keep backward compatibility.

	 * Try new tag first. If it is not specified, then try the old one.

	 */

	if (pkg_list_type == AI_PACKAGE_LIST_INSTALL) {

		package_list = ai_get_manifest_packages(&num_packages,

		    AIM_PACKAGE_INSTALL_NAME);

		if (package_list == NULL) {

			/* If no package list given, use default */

			auto_debug_print(AUTO_DBGLVL_ERR,

			    "No install package list given, using default\n");

			num_packages = 4;

			package_list[0] = strdup("pkg:/SUNWcsd");

			package_list[1] = strdup("pkg:/SUNWcs");

			package_list[2] = strdup("pkg:/babel_install");

			package_list[3] = strdup("pkg:/entire");

			package_list[4] = NULL;

		}

		auto_log_print(gettext(

		    "list of packages to be installed is:\n"));

	} else {

		package_list = ai_get_manifest_packages(&num_packages,

		    AIM_PACKAGE_REMOVE_NAME);

		if (package_list == NULL) {

			auto_debug_print(AUTO_DBGLVL_INFO,

			    "List of packages to be removed is empty\n");

			(void) fclose(fp);

			return (AUTO_INSTALL_EMPTY_LIST);

		}

		auto_log_print(gettext(

		    "list of packages to be removed is:\n"));

	}

	/*

	 * Save list of packages to the file

	 */

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

		auto_log_print("%s\n", package_list[i]);

		if (fputs(package_list[i], fp) == EOF) {

			auto_debug_print(AUTO_DBGLVL_ERR,

			    "Write to %s file failed\n", pkg_list_file);

			ret = AUTO_INSTALL_FAILURE;

			break;

		}

		if (fputs("\n", fp) == EOF) {

			auto_debug_print(AUTO_DBGLVL_ERR,

			    "Write to %s file failed\n", pkg_list_file);

			ret = AUTO_INSTALL_FAILURE;

			break;

		}

	}

	(void) fclose(fp);

	return (ret);

}

/*

 * Create/delete/preserve vtoc slices as specified

 * in the manifest

 */

static int

auto_modify_target_slices(auto_slice_info *asi, uint8_t install_slice_id)

{

	for (; asi->slice_action[0] != '\0'; asi++) {

		uint64_t slice_size_sec;

		auto_debug_print(AUTO_DBGLVL_INFO,

		    "slice action %s, size=%lld units=%s\n",

		    asi->slice_action, asi->slice_size,

		    CONVERT_UNITS_TO_TEXT(asi->slice_size_units));

		if (!convert_to_sectors(asi->slice_size_units,

		    asi->slice_size, &slice_size_sec)) {

			auto_debug_print(AUTO_DBGLVL_ERR,

			    "conversion failure from %lld %s to sectors\n",

			    asi->slice_size,

			    CONVERT_UNITS_TO_TEXT(asi->slice_size_units));

			return (AUTO_INSTALL_FAILURE);

		}

		if (strcmp(asi->slice_action, "create") == 0) {

			om_slice_tag_type_t slice_tag;

			if (asi->slice_number == install_slice_id)

				slice_tag = OM_ROOT;

			else

				slice_tag = OM_UNASSIGNED;

			if (!om_create_slice(asi->slice_number, slice_size_sec,

			    slice_tag, asi->on_existing))

				return (AUTO_INSTALL_FAILURE);

		} else if (strcmp(asi->slice_action, "delete") == 0) {

			if (!om_delete_slice(asi->slice_number))

				return (AUTO_INSTALL_FAILURE);

		} else if (strcmp(asi->slice_action, "preserve") == 0) {

			if (!om_preserve_slice(asi->slice_number))

				return (AUTO_INSTALL_FAILURE);

		}

	}

	return (AUTO_INSTALL_SUCCESS);

}

/*

 * convert value to sectors given basic unit size

 * TODO uint64_t overflow check

 */

static boolean_t

convert_to_sectors(auto_size_units_t units, uint64_t src,

    uint64_t *psecs)

{

	if (psecs == NULL)

		return (B_FALSE);