/*

 * 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 <fcntl.h>

#include <libintl.h>

#include <stdio.h>

#include <errno.h>

#include <stdlib.h>

#include <strings.h>

#include <unistd.h>

#include <locale.h>

#include <sys/param.h>

#include <sys/types.h>

#include <sys/wait.h>

#include "auto_install.h"

static PyObject *manifest_serv_obj;

static char *manifest_filename;

/*

 * Function to execute shell commands in a thread-safe manner. Output from

 * stdout is captured in install log file.

 *

 * Parameters:

 *	cmd - the command to execute

 *

 * Return:

 *	-1 if popen() failed, otherwise exit code returned by command

 *

 * Status:

 *	private

 */

static int

ai_exec_cmd(char *cmd)

{

	FILE	*p;

	char	buf[MAX_SHELLCMD_LEN];

	auto_debug_print(AUTO_DBGLVL_INFO, "exec cmd: %s\n", cmd);

	if ((p = popen(cmd, "r")) == NULL) {

		auto_debug_print(AUTO_DBGLVL_ERR,

		    "Could not execute following command: %s.\n", cmd);

		return (-1);

	}

	/*

	 * capture stdout for debugging purposes

	 */

	while (fgets(buf, sizeof (buf), p) != NULL)

		auto_debug_print(AUTO_DBGLVL_ERR, " %s", buf);

	return (WEXITSTATUS(pclose(p)));

}

/*

 * Dump errors found during syntactic validation of AI manifest -

 *

 *

 * Returns

 * 	-1  - failed to dump syntactic errors

 *	>=0 - exit code from xmllint(1M)

 */

static int

dump_ai_manifest_errors(char *manifest, char *schema)

{

	char	*cmd;

	size_t	cmd_ln;

	int	ret;

	if (cmd == NULL) {

		auto_debug_print(AUTO_DBGLVL_ERR, "malloc() failed\n");

		return (-1);

	}

	ret = ai_exec_cmd(cmd);

	/*

	 * The validation is expected to fail - command returns

	 * with non-zero exit code - log the exit code.

	 *

	 */

	auto_debug_print(AUTO_DBGLVL_ERR,

	    "xmllint(1M) returned with exit code %d\n", ret);

	free(cmd);

	return (ret);

}

/*

 * Create the manifest data image in memory.  (Does not validate it.)

 *

 * Import the manifest into an in-memory tree

 * that can subsequently be queried for the various

 * attributes. A handle to the in-memory tree is stored

 * as a ManifestServ object pointed to by manifest_serv_obj.

 *

 * The manifest filename is saved for later use, in manifest_filename.

 *

 * Note that this function must be called before anything else which

 * references manifest_serv_obj or manifest_filename in this module.

 *

 * Returns

 * 	AUTO_VALID_MANIFEST if it's a valid manifest

 * 	AUTO_INVALID_MANIFEST if it's an invalid manifest

 */

int

ai_create_manifest_image(char *filename)

{

	/*

	 * If the manifest_serv_obj is set it means that

	 * the manifest has already been validated and

	 * a server object created for it

	 */

	if (manifest_serv_obj != NULL)

		return (AUTO_VALID_MANIFEST);

	manifest_filename = NULL;

	manifest_serv_obj = ai_create_manifestserv(filename);

	if (manifest_serv_obj != NULL) {

		manifest_filename = strdup(filename);

		return (AUTO_VALID_MANIFEST);

	}

	auto_log_print(gettext("Failure to create manifest data in memory.\n"));

	return (AUTO_INVALID_MANIFEST);

}

/*

 * Validate the manifest syntactically as well as

 * semantically.

 *

 * As part of the validation process, fill in the

 * defaults for the attributes that aren't specified.

 *

 * Returns

 * 	AUTO_VALID_MANIFEST if it's a valid manifest

 * 	AUTO_INVALID_MANIFEST if it's an invalid manifest

 */

int

ai_setup_manifest_image()

{

	if (ai_setup_manifestserv(manifest_serv_obj) == AUTO_INSTALL_SUCCESS) {

		return (AUTO_VALID_MANIFEST);

	}

	/*

	 * if the validation process failed, capture output of syntactic

	 * validation in log file

	 */

	auto_log_print(gettext("Syntactic validation of the manifest failed "

	    "with following errors\n"));

	if (dump_ai_manifest_errors(

	    manifest_filename, AI_MANIFEST_SCHEMA) == -1) {

		auto_log_print(gettext("Failed to obtain result of syntactic "

		    "validation\n"));

	}

	return (AUTO_INVALID_MANIFEST);

}

void

ai_teardown_manifest_state()

{

	if (manifest_serv_obj != NULL)

		(void) ai_destroy_manifestserv(manifest_serv_obj);

}

char **

ai_get_manifest_values(char *path, int *len)

{

	if (manifest_serv_obj == NULL) {

		auto_debug_print(AUTO_DBGLVL_INFO, "manifestserv must be "

		    "initialized before values can be retrieved\n");

		return (NULL);

	}

	return (ai_lookup_manifest_values(manifest_serv_obj, path, len));

}

/*

 * Free memory allocated by ai_get_manifest_values().

 */

void

ai_free_manifest_values(char **value_list)

{

	ai_free_manifest_value_list(value_list);

}

/*

 * ai_get_manifest_element_value() - return value given xml element

 */

char *

ai_get_manifest_element_value(char *element)

{

	int len = 0;

	char **value;

	char *evalue;

	value = ai_get_manifest_values(element, &len);

	/*

	 * Return the value and free the pointer

	 */

	if (len > 0) {

		evalue = *value;

		free(value);

		return (evalue);

	}

	return (NULL);

}

/*

 * get_manifest_element_array() - return list of values given xml element

 */

static char **

get_manifest_element_array(char *element)

{

	int len = 0;

	char **value;

	value = ai_get_manifest_values(element, &len);

	if (len > 0)

		return (value);

	return (NULL);

}

/*

 * Retrieve the target disk information

 *

 * If illegal values, return AUTO_INSTALL_FAILURE

 * else return AUTO_INSTALL_SUCCESS

 */

int

ai_get_manifest_disk_info(auto_disk_info *adi)

{

	char *p;

	p = ai_get_manifest_element_value(AIM_TARGET_DEVICE_NAME);

	if (p != NULL)

		(void) strncpy(adi->diskname, p, sizeof (adi->diskname));

	p = ai_get_manifest_element_value(AIM_TARGET_DEVICE_TYPE);

	if (p != NULL)

		(void) strncpy(adi->disktype, p, sizeof (adi->disktype));

	p = ai_get_manifest_element_value(AIM_TARGET_DEVICE_VENDOR);

	if (p != NULL)

		(void) strncpy(adi->diskvendor, p, sizeof (adi->diskvendor));

	p = ai_get_manifest_element_value(AIM_TARGET_DEVICE_SELECT_VOLUME_NAME);

	if (p != NULL)

		(void) strlcpy(adi->diskvolname, p, sizeof (adi->diskvolname));

	p = ai_get_manifest_element_value(AIM_TARGET_DEVICE_SELECT_DEVICE_ID);

	if (p != NULL)

		(void) strlcpy(adi->diskdevid, p, sizeof (adi->diskdevid));

	p = ai_get_manifest_element_value(AIM_TARGET_DEVICE_SELECT_DEVICE_PATH);

	if (p != NULL)

		(void) strlcpy(adi->diskdevicepath, p,

		    sizeof (adi->diskdevicepath));

	p = ai_get_manifest_element_value(AIM_TARGET_DEVICE_SIZE);

	p = ai_get_manifest_element_value(

	    AIM_TARGET_DEVICE_USE_SOLARIS_PARTITION);

	if (p != NULL) {

#ifdef	__sparc

		auto_log_print("Warning: ignoring manifest element "

#else

#endif

	}

	p = ai_get_manifest_element_value(

	    AIM_TARGET_DEVICE_INSTALL_SLICE_NUMBER);

	if (p != NULL) {

		int install_slice_number;

		if (sscanf(p, "%d", &install_slice_number) > 0)

			adi->install_slice_number =

			    (uint8_t)install_slice_number;

	}

	/*

	 * iSCSI target information

	 */

	p = ai_get_manifest_element_value(AIM_TARGET_DEVICE_ISCSI_TARGET_NAME);

	if (p != NULL)

		(void) strncpy(adi->diskiscsi.name, p,

		    sizeof (adi->diskiscsi.name));

	p = ai_get_manifest_element_value(AIM_TARGET_DEVICE_ISCSI_TARGET_IP);

	if (p != NULL)

		(void) strncpy(adi->diskiscsi.ip, p,

		    sizeof (adi->diskiscsi.ip));

	p = ai_get_manifest_element_value(AIM_TARGET_DEVICE_ISCSI_TARGET_LUN);

	if (p != NULL)

		(void) strncpy(adi->diskiscsi.lun, p,

		    sizeof (adi->diskiscsi.lun));

	p = ai_get_manifest_element_value(AIM_TARGET_DEVICE_ISCSI_TARGET_PORT);

	if (p != NULL)