/*

 * 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) 2007, 2010, Oracle and/or its affiliates. All rights reserved.

 */

#include <fcntl.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <ctype.h>

#include <errno.h>

#include <pthread.h>

#include <sys/param.h>

#include <sys/stat.h>

#include <sys/types.h>

#include <dirent.h>

#include <sys/wait.h>

#include <crypt.h>

#include <unistd.h>

#include <time.h>

#include <libgen.h>

#include <netdb.h>

#include <locale.h>

#include <wait.h>

#include <sys/systeminfo.h>

#include "td_lib.h"

#include "cl_database_parms.h"

#include "admldb.h"

#include "orchestrator_private.h"

#include "ict_api.h"

#include <transfermod.h>

#include <ls_api.h>

#define	EMPTY_STR	""

#define	UN(string) ((string) ? (string) : "")

#define	STATE_FILE	"/etc/.sysIDtool.state"

#define	PKG_PATH	"/usr/bin/pkg"

#define	MAXDEVSIZE	100

struct icba {

	om_install_type_t	install_type;

	pid_t			pid;

	om_callback_t		cb;

};

struct transfer_callback {

	char		*target;

	char		*hostname;

	char		*uname;

	char		*lname;

	char		*upasswd;

	char		*rpasswd;

	nvlist_t	**transfer_attr;

	uint_t		transfer_attr_num;

	om_callback_t	cb;

};

struct ti_callback {

	nvlist_t *target_attrs;

};

/*

 * Global Variables

 */

static	boolean_t	install_test = B_FALSE;

static	char		*state_file_path = NULL;

om_install_type_t	install_type;

static	char		*def_locale;

boolean_t		create_swap_and_dump = B_FALSE;

boolean_t		create_swap_slice = B_FALSE;

static	pthread_t	ti_thread;

static	int		ti_ret;

static	om_breakpoint_t	om_breakpoint = OM_no_breakpoint;

int32_t requested_swap_size = -1;

int32_t requested_dump_size = -1;

/*

 * l_zfs_shared_fs_num is the local representation of ZFS_SHARED_FS_NUM

 * l_zfs_shared_fs_num is initially set to ZFS_SHARED_FS_NUM - 1 and

 * if the user wants to create user account and is running interactive

 * installer, the value will be increased by one to count in home directory

 * ZFS dataset.

 */

static	int		l_zfs_shared_fs_num = ZFS_SHARED_FS_NUM - 1;

static om_callback_t	om_cb;

static char		zfs_device[MAXDEVSIZE];

static char		swap_device[MAXDEVSIZE];

static char		*zfs_fs_names[ZFS_FS_NUM] = {"/"};

static char		zfs_shared_user_login[MAXPATHLEN] = "";

static char		*zfs_shared_fs_names[ZFS_SHARED_FS_NUM] =

	{"/export", "/export/home", zfs_shared_user_login};

static image_info_t	image_info = {B_FALSE, 4096, 1.0, "off"};

extern	char		**environ;

/*

 * local functions

 */

static char 	*find_state_file();

static void	remove_component(char *path);

static void 	set_system_state(void);

static int	trav_link(char **path);

static void 	write_sysid_state(sys_config *sysconfigp);

static void	notify_error_status(int status);

static void	notify_install_complete();

static int	call_transfer_module(

    nvlist_t		**transfer_attr,

    uint_t		transfer_attr_num,

    char		*target_dir,

    char		*hostname,

    char		*uname,

    char		*lname,

    char		*upasswd,

    char		*rpasswd,

    om_callback_t	cb);

static int	run_install_finish_script(

    char		*target_dir,

    char		*uname,

    char		*lname,

    char		*upasswd,

    char		*rpasswd);

static void	setup_etc_vfstab_for_swap(char *target);

static int	reset_zfs_mount_property(char *target, int transfer_mode);

static void	activate_be(char *be_name);

static void	handle_TM_callback(const int percent, const char *message);

static int	prepare_zfs_root_pool_attrs(nvlist_t **attrs, char *disk_name,

    uint8_t slice_id);

static int	prepare_zfs_volume_attrs(nvlist_t **attrs,

    uint64_t available_disk_space, boolean_t create_min_swap_only);

static int	prepare_be_attrs(nvlist_t **attrs);

static int	obtain_image_info(image_info_t *info);

static char	*get_dataset_property(char *dataset_name, char *property);

static uint64_t	get_available_disk_space(void);

static uint64_t get_recommended_size_for_software(void);

static uint32_t	get_mem_size(void);

static void	log_bld_info(char *, char *);

static uint64_t	calc_swap_size(uint64_t available_swap_space);

static uint64_t	calc_dump_size(uint64_t available_dump_space);

void 		*do_transfer(void *arg);

void		*do_ti(void *args);

/*

 * om_unmount_target_be

 * Unmounts target boot environment using be_unmount() API. Only non-shared

 * datasets are handled here.

 *

 * Input:	none

 * Output:	none

 *

 * Return:	OM_SUCCESS, if BE was successfully unmounted

 *		OM_FAILURE, if BE couldn't be unmounted for some reason

 */

int

om_unmount_target_be(void)

{

	nvlist_t	*be_attrs;

	int		ret;

	/*

	 * Populate nv list holding BE attributes

	 */

	if (nvlist_alloc(&be_attrs, NV_UNIQUE_NAME, 0) != 0) {

		om_log_print("Couldn't create nv list for be_unmount().\n");

		return (OM_FAILURE);

	}

	if (nvlist_add_string(be_attrs, BE_ATTR_ORIG_BE_NAME,

	    INIT_BE_NAME) != 0) {

		om_log_print("Couldn't add BE name to nv list.\n");

		nvlist_free(be_attrs);

		return (OM_FAILURE);

	}

	if ((ret = be_unmount(be_attrs)) != BE_SUCCESS) {

		om_log_print("Couldn't unmount target BE,"

		    " be_unmount() failed with return code %d\n", ret);

		nvlist_free(be_attrs);

		return (OM_FAILURE);

	}

	nvlist_free(be_attrs);

	return (OM_SUCCESS);

}

/*

 * om_perform_install

 * This function, called primarily from the GUI Installer or the Automated

 * Installer (AI), will setup configuration and call install/upgrade

 * function(s).

 *

 * Input:	nvlist_t *uchoices - The user choices will be provided as

 *		name-value pairs

 *		void *cb - callback function to inform the Installer about

 *		the progress.

 * Output:	None

 * Return:	OM_SUCCESS, if the install program started succcessfully

 *		OM_FAILURE, if the there is a failure

 * Notes:	The user selected configuration is passed from the Installer

 *		in the form of name-value pairs

 *		The current values passed are:

 *		install_type - uint8_t (initial_install/upgrade)

 *		disk name - String (only for initial_install- example c0d0)

 *		upgrade target - String (only for upgrade - example c0d0s0)

 *		list of locales to be installed - String

 *		default locale - String

 *		user name - String - The name of the user account to be created

 *		user password - String - user password

 *		root password - String - root password

 *

 *              The Installer optionally also specifies the transfer mode

 *              desired (IPS or CPIO) in the form of name-value pairs.

 */

int

om_perform_install(nvlist_t *uchoices, om_callback_t cb)

{

	char		*name;

	char		*lname = EMPTY_STR;

	char		*rpasswd = OM_DEFAULT_ROOT_PASSWORD;

	char		*hostname = EMPTY_STR;

	char		*uname = EMPTY_STR;

	char		*upasswd = OM_DEFAULT_USER_PASSWORD;

	int		status = OM_SUCCESS;

	nvlist_t	*target_attrs = NULL, **transfer_attr;

	uint_t		transfer_attr_num;

	uint8_t		type;

	char		*ti_test = getenv("TI_SLIM_TEST");

	char		*nv_string;

	int		ret = 0;

	if (uchoices == NULL) {

		om_set_error(OM_BAD_INPUT);

	}

	if (!ti_test) {

	/*

	 * Get the install_type

	 */

	if (nvlist_lookup_uint8(uchoices,

	    OM_ATTR_INSTALL_TYPE, &type) != 0) {

		om_set_error(OM_NO_INSTALL_TYPE);

		return (OM_FAILURE);

	}

	/*

	 * Supports only initial_install and upgrade

	 */

	if (type != OM_INITIAL_INSTALL) {

		om_set_error(OM_BAD_INSTALL_TYPE);

		return (OM_FAILURE);

	}

	install_type = type;

	/*

	 * Special value for testing

	 */

	if (nvlist_lookup_boolean_value(uchoices,

	    OM_ATTR_INSTALL_TEST, (boolean_t *)&install_test) != 0) {

		install_test = B_FALSE;

	}

	}

	/*

	 * Now process initial install

	 * Get the disk name - Install target

	 */

	if (nvlist_lookup_string(uchoices, OM_ATTR_DISK_NAME, &name) != 0) {

		om_set_error(OM_NO_INSTALL_TARGET);

		return (OM_FAILURE);

	}

	if (!is_diskname_valid(name)) {

		om_set_error(OM_BAD_INSTALL_TARGET);

		return (OM_FAILURE);

	}

	/*

	 * For initial install, set up the following things.

	 * 1. Timezone

	 * 2. default locale

	 * 3. Root Password

	 * 4. User Name

	 * 5. User password

	 * 6. Host/nodename

	 */

	if (!ti_test) {

	/*

	 * Get the default locale. Save it off for later. We don't

	 * set the system default locale until after the installation

	 * has completed. XXX will Slim have this set from GUI?

	 */

	if (nvlist_lookup_string(uchoices,

	    OM_ATTR_DEFAULT_LOCALE, &def_locale) != 0) {

		/*

		 * Default locale is not passed, so don't set it

		 * Log the information and continue

		 */

		om_debug_print(OM_DBGLVL_WARN, "OM_ATTR_DEFAULT_LOCALE not set,"

		    "default locale is null\n");

		om_log_print("Default locale is NULL\n");

		def_locale = NULL;

	} else {

		om_debug_print(OM_DBGLVL_INFO, "Default locale specified: %s\n",

		    def_locale);

	}

	/*

	 * In case of automated installation (AI), user and root accounts

	 * are configured on installed system at the first boot

	 * by svc:/system/install/config SMF service. Thus for AI scenario,

	 * just skip dealing with this kind of configuration in the installer.

	 */

	if (!om_is_automated_installation()) {

		/*

		 * Get the root password

		 */

		if (nvlist_lookup_string(uchoices,

		    OM_ATTR_ROOT_PASSWORD, &nv_string) != 0) {

			/*

			 * Root password is not passed, so don't set it,

			 * just log the information.

			 */

			om_debug_print(OM_DBGLVL_WARN, "OM_ATTR_ROOT_PASSWORD "

			    " not set, set the default root password\n");

			om_log_print("Root password not specified, set to "

			    " default\n");

		} else {

			rpasswd = nv_string;

			om_debug_print(OM_DBGLVL_INFO, "Got root passwd\n");

		}

		/*

		 * Get the user name,if set, which is different than the login

		 * name.

		 */

		if (nvlist_lookup_string(uchoices,

		    OM_ATTR_USER_NAME, &nv_string) != 0) {

			/*

			 * User name is not passed, so don't set it

			 * Log the information and continue

			 */

			om_debug_print(OM_DBGLVL_WARN, "OM_ATTR_USER_NAME "

			    "not set, User name not available\n");

			om_log_print("User name not specified\n");

		} else {

			uname = nv_string;

			om_debug_print(OM_DBGLVL_INFO, "User name set to "

			    "%s\n", uname);

		}

		if (nvlist_lookup_string(uchoices, OM_ATTR_LOGIN_NAME,

		    &nv_string) != 0) {

			/*

			 * No login name, don't worry about getting passwd info.

			 * Log this data and move on.

			 */

			om_debug_print(OM_DBGLVL_WARN,

			    "OM_ATTR_LOGIN_NAME not set,"

			    "User login name not available\n");

			om_log_print("User login name not specified\n");

		} else {

			lname = nv_string;

			/*

			 * User account will be created - count in shared ZFS

			 * dataset which will be created for user's

			 * home directory

			 */

			l_zfs_shared_fs_num++;

			/*

			 * we got the user name.

			 * Get the password

			 */

			om_debug_print(OM_DBGLVL_INFO, "User login name set to "

			    "%s\n", lname);

			(void) snprintf(zfs_shared_user_login,

			    sizeof (zfs_shared_user_login),

			    "/export/home/%s", lname);

			om_debug_print(OM_DBGLVL_INFO, "zfs shared user login "

			    "set to %s\n", zfs_shared_user_login);

			if (nvlist_lookup_string(uchoices,

			    OM_ATTR_USER_PASSWORD, &nv_string) == 0) {

				upasswd = nv_string;

				/*

				 * Got user name and password

				 */

				om_debug_print(OM_DBGLVL_INFO,

				    "Got user password\n");

			}

		}

	}

	if (nvlist_lookup_string(uchoices, OM_ATTR_HOST_NAME,

	    &nv_string) != 0) {

		/*

		 * User has cleared default host name for some reason.

		 * NWAM will use dhcp so a dhcp address will become

		 * the host/nodename.

		 */

		om_debug_print(OM_DBGLVL_WARN, "OM_ATTR_HOST_NAME "

		    "not set,"

		    "User probably cleared default host name\n");

	} else {

		hostname = nv_string;

		/*

		 * Hostname will be set in function call_transfer_module

		 * using ICT ict_set_host_node_name

		 */

		om_debug_print(OM_DBGLVL_INFO, "Hostname will be to %s\n",

		    hostname);

	}

	/* Get requested swap size if specified */

	if (nvlist_lookup_int32(uchoices,

	    OM_ATTR_SWAP_SIZE, &requested_swap_size) != 0) {

		requested_swap_size = -1;

		om_debug_print(OM_DBGLVL_INFO, "Swap size not requested.\n");

	} else {

		om_debug_print(OM_DBGLVL_INFO,

		    "Requested swap size : %ld.\n", requested_swap_size);

	}

	/* Get requested dump device size if specified */

	if (nvlist_lookup_int32(uchoices,

	    OM_ATTR_DUMP_SIZE, &requested_dump_size) != 0) {

		requested_dump_size = -1;

		om_debug_print(OM_DBGLVL_INFO, "Dump size not requested.\n");

	} else {

		om_debug_print(OM_DBGLVL_INFO,

		    "Requested dump size : %ld.\n", requested_dump_size);

	}

	/*

	 * The .sysIDtool.state file needs to be written before the

	 * install completes. Update the state here for install.

	 */

	set_system_state();

	/*

	 * Setup install targets. Set the global orchestrator callback

	 * value for use later. Ick.. this is ugly, but for now, until

	 * TI is finalized we need a way to translate the TI->OM

	 * callbacks.

	 *

	 */

	}

	if (cb) {

		om_cb = cb;

	}

	if (nvlist_alloc(&target_attrs, TI_TARGET_NVLIST_TYPE, 0) != 0) {

		om_log_print("Could not create target list.\n");

		return (OM_NO_SPACE);

	}

#ifndef	__sparc

	/*

	 * Set fdisk configuration attributes

	 */

	if (om_set_fdisk_target_attrs(target_attrs, name) != 0) {

		om_log_print("Couldn't set fdisk attributes.\n");

		nvlist_free(target_attrs);

		return (OM_FAILURE);

	}

	om_log_print("Set fdisk attrs\n");