#!/bin/ksh

#

# 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.

#

# Description:

#       It contains common functions used by create-client and

#	setup-tftp-links, which is used by when the user issues

#	installadm create-service.

#

# Files potentially changed on server:

# /etc/inetd.conf - to turn on tftpboot daemon

# /etc/vfstab - Entry added to mount the image as a lofs device

# /tftpboot/menu.lst - menu.lst file corresponding to the service/client

AWK=/bin/awk

GREP=/bin/grep

IFCONFIG=/usr/sbin/ifconfig

MV=/bin/mv

SED=/usr/bin/sed

SVCCFG=/usr/sbin/svccfg

VERSION="Solaris"

HTTP_PORT=5555

SPARC_IMAGE="sparc_image"

X86_IMAGE="x86_image"

DOT_RELEASE=".release"

DOT_IMAGE_INFO=".image_info"

GRUB_TITLE_KEYWORD="GRUB_TITLE"

GRUB_MIN_MEM64="GRUB_MIN_MEM64"

GRUB_DO_SAFE_DEFAULT="GRUB_DO_SAFE_DEFAULT"

CGIBIN_WANBOOTCGI="cgi-bin/wanboot-cgi"

NETBOOTDIR="/etc/netboot"

WANBOOT_CONF_FILE="wanboot.conf"

SPARC_INSTALL_CONF="install.conf"

WANBOOT_CONF_SPEC="${NETBOOTDIR}/${WANBOOT_CONF_FILE}"

SMF_INST_SERVER="svc:/system/install/server:default"

AIWEBSERVER="aiwebserver"

SERVICE_ADDRESS_UNKNOWN="unknown"

#

# get_host_ip

#

# Purpose : Use getent(1M) to get the IP address for the given host name 

#	    or IP.  NOTE: this function will return the first entry

#	    returned from getent(1M) in cases were multiple entries

#	    are yielded.

#

# Arguments : 

#	$1 - Hostname or IP address.

#

# Returns IP address

#

get_host_ip()

{

	hname=$1

	if [ -z "$hname" ]; then

		return

	fi

	HOST_IP=`getent hosts ${hname} | head -1 | nawk '{ print $1 }'`

	echo "$HOST_IP"

}

#

# get_server_ip

#

# Purpose : Get the IP address of the machine where this program is running.

#

# Arguments : 

#	None

#

# Returns IP address of the current host.

#

get_server_ip()

{

	SERVER=`uname -n`

	SERVER_IP=`get_host_ip $SERVER`

	echo "$SERVER_IP"

}

#

# get_ip_netmask

#

# Purpose : Get the netmask set for the given IP address on the current host.

#           Assumes IP address is currently set on an interface.

#

# Arguments :

#	$1 - IP address

#

# Returns netmask in hexidecimal notation (e.g. ffffff00)

#

get_ip_netmask()

{

	ipaddr=$1

	if [ -z "$ipaddr" ]; then

		return

	fi

	$IFCONFIG -a | grep broadcast | awk '{print $2, $4}' | \

		while read t_ipaddr t_netmask ; do

			if [ "$t_ipaddr" = "$ipaddr" ]; then

				echo "$t_netmask"

				break

			fi

		done

}

#

# get_network

#

# Purpose : Determine the network number given an IP addres and the netmask.

#

# Arguments :

#	$1 - IP address

#	$2 - netmask in hexidecimal notation (e.g. ffffff00)

#

# Returns network number

#

get_network()

{

	if [ $# -ne 2 ]; then

		return

	fi

NETWORK=`echo | nawk -v ipaddr=$1 -v netmask=$2 '

function bitwise_and(x, y) {

	# This function ands together the lower four bits of the two decimal

	# values passed in, and returns the result as a decimal value.

        a[4] = x % 2;

        x -= a[4];

        a[3] = x % 4;

        x -= a[3]

        a[2] = x % 8;

        x -= a[2];

        a[1] = x;

        b[4] = y % 2;

        y -= b[4];

        b[3] = y % 4;

        y -= b[3]

        b[2] = y % 8;

        y -= b[2];

        b[1] = y;

        for (j = 1; j <= 4; j++)

                if (a[j] != 0 && b[j] != 0)

                        ans[j] = 1;

                else

                        ans[j] = 0;

        return(8*ans[1] + 4*ans[2] + 2*ans[3] + ans[4]);

}

BEGIN {

        ip=ipaddr

        netm=netmask

        # set up the associative array for mapping hexidecimal numbers

        # to decimal fields.

        hex_to_dec["0"]=0

        hex_to_dec["1"]=1

        hex_to_dec["2"]=2

        hex_to_dec["3"]=3

        hex_to_dec["4"]=4

        hex_to_dec["5"]=5

        hex_to_dec["6"]=6

        hex_to_dec["7"]=7

        hex_to_dec["8"]=8

        hex_to_dec["9"]=9

        hex_to_dec["a"]=10

        hex_to_dec["b"]=11

        hex_to_dec["c"]=12

        hex_to_dec["d"]=13

        hex_to_dec["e"]=14

        hex_to_dec["f"]=15

        hex_to_dec["A"]=10

        hex_to_dec["B"]=11

        hex_to_dec["C"]=12

        hex_to_dec["D"]=13

        hex_to_dec["E"]=14

        hex_to_dec["F"]=15

        # split the netmask into an array of 8 4-bit numbers

        for (i = 1; i <= 8; i++)

                nm[i]=hex_to_dec[substr(netm, i, 1)]

        # split the ipaddr into its four decimal fields

        split(ip, df, ".")

        # now, for each decimal field, split the 8-bit number into its

        # high and low 4-bit fields, and do a bit-wise AND of those

        # fields with the corresponding fields from the netmask.

        for (i = 1; i <= 4; i++) {

                lo=df[i] % 16;

                hi=(df[i] - lo)/16;

                res_hi[i] = bitwise_and(hi, nm[2*i - 1])

                res_lo[i] = bitwise_and(lo, nm[2*i])

        }

        printf("%d.%d.%d.%d",

            res_hi[1]*16 + res_lo[1],

            res_hi[2]*16 + res_lo[2],

            res_hi[3]*16 + res_lo[3],

            res_hi[4]*16 + res_lo[4]);

}'`

echo "$NETWORK"

}

#

# get_image_type

#

# Purpose : Determine if image is sparc or x86

#

# Arguments : 

#	$1 - path to image

#

# Returns: "sparc_image" or "x86_image"

#

get_image_type()

{

	image_path=$1

	if [ -d ${image_path}/platform/sun4v ]; then

		image_type="${SPARC_IMAGE}"

	elif [ -d ${image_path}/platform/i86pc ]; then

		image_type="${X86_IMAGE}"

	else 

		exit 1

	fi

	echo "$image_type"

}

#

# clean_entry

#

# Purpose : Cleanup the /tftpboot files corresponding the entry

#	    we are trying to create for this service/ethernet address

#

# Arguments : 

#	$1 - client or server

#	$2 - Boot File Name

#

clean_entry()

{

	type=$1

	bname=$2

	# See if there's a cleanup file corresponding to the passed 

	# boot file 

	#

	if [ "X${bname}" != "X" -a \

	    -f "${Bootdir}/rm.${bname}" ] ; then

        	CLEAN=${Bootdir}/rm.${bname}

	fi

	# If a cleanup file exists, source it

	#

	if [ -f ${CLEAN} ]; then

		if [ "${type}" = "client" ]; then

		    echo "Cleaning up preexisting install client \"${bname}\""

		fi

		. ${CLEAN}

	fi

	rm -f ${CLEAN}

}

#

# get_grub_title

#

# Purpose: Get the line used in the title line of the grub menu.

#	   If the <image>/.image_info file contains the GRUB_TITLE line

#	   specifying the grub title to be used, the string will be returned.

#	   Otherwise, use the first line of the <image>/.release file as the 

#	   title of the grub menu. If the <image>/.release file does not

#	   exist, return the value of $DEFAULT_GRUB_TITLE. 

#

# Arguments: 

#	$1 - path to image

#

# Returns: String specified with the GRUB_TITLE keyward in <image>/.image_info

#	file.  If no GRUB_TITLE is specified or if <image>/.image_info

#	does not exist, the first line of the <image>/.release file will

#	be returned.  If <image>/.release file is not found, the value of

#	$DEFAULT_GRUB_TITLE will be returned.

#

get_grub_title()

{

	grub_title=""

	image_info_path=$1/${DOT_IMAGE_INFO}

	if [ -f ${image_info_path} ] ; then

		while read line ; do

			if [[ "${line}" == ~(E)^${GRUB_TITLE_KEYWORD}=.* ]]

			then

				grub_title="${line#*=}" 

			fi

		done < ${image_info_path}

	fi

	if [ "X${grub_title}" == "X" ] ; then

		releasepath=$1/${DOT_RELEASE}

		if [ -f ${releasepath} ]; then

			grub_title=`head -1 ${releasepath}`

		else

			grub_title=$DEFAULT_GRUB_TITLE

		fi

	fi

	echo "$grub_title"

}

#

# get_grub_min_mem64

#

# Purpose: Get minimum memory required to boot network AI in 64 bit mode.

#	   GRUB menu.lst is then populated with 'min_mem64' option accordingly.

#	   If that parameter can't be obtained, return 1536 (1,5GB) for backward

#	   compatibility.

#

# Arguments: 

#	$1 - path to image

#

# Returns: String specified with the GRUB_MIN_MEM64 keyword

#	in <image>/.image_info file. If no GRUB_MIN_MEM64 is specified or if

#	<image>/.image_info does not exist, return 1536 (1,5GB).

#

get_grub_min_mem64()

{

	grub_min_mem64=""

	image_info_path=$1/${DOT_IMAGE_INFO}

	if [ -f ${image_info_path} ] ; then

		while read line ; do

			if [[ "${line}" == ~(E)^${GRUB_MIN_MEM64}=.* ]]

			then

				grub_min_mem64="${line#*=}"

			fi

		done < ${image_info_path}

	fi

	if [ -z "$grub_min_mem64" ] ; then

		grub_min_mem64="1536"

	fi

	echo "$grub_min_mem64"

}

#

# get_grub_do_safe_default

#

# Purpose: Get flag from the image indicating whether or not the grub menu

#	   should be created with a safe default entry (i.e. a default entry

#	   that does not start an automated install.)

#

# Arguments:

#	$1 - path to image

#

# Returns:

#	true - if GRUB_DO_SAFE_DEFAULT is set to true in the

#	       <image>/.image_info file.

#	false - otherwise

#

get_grub_do_safe_default()

{

	grub_do_safe_default=""

	image_info_path=$1/${DOT_IMAGE_INFO}

	if [ -f ${image_info_path} ] ; then

                while read line ; do

                        if [[ "${line}" == ~(E)^${GRUB_DO_SAFE_DEFAULT}=.* ]]

                        then

                                grub_do_safe_default="${line#*=}"

                        fi

                done < ${image_info_path}

        fi

	if [ -z "$grub_do_safe_default" -o \

	    "$grub_do_safe_default" != "true" ] ; then

		grub_do_safe_default="false"

	fi

	echo "$grub_do_safe_default"

}

#

# get_service_address

#

# Purpose: Get the service location (machine ip and port nuber)

#          for given service name. Common service database is

#          looked up for this information.

#          

#

# Arguments: 

#	$1 - service name

#

# Returns: service address in format <machine_ip>:<port_number>

#          if service not found in database, "unknown" is returned

#

#

get_service_address()

{

	#

	# Search for the txt_record in the AI service's SMF properties.

	# The data is stored as a property of the AI service's property group.

	#

	# ...

	# txt_record=aiwebserver=<machine_hostname>:<machine_port>

	# ...

	#

	srv_location=`$SVCCFG -s $SMF_INST_SERVER listprop \

	    AI$1/txt_record`

	srv_location="${srv_location#*=}"

	# if location of service can't be obtained, return with "unknown"

	if [ -z "$srv_location" ] ; then

		echo "$SERVICE_ADDRESS_UNKNOWN"

		return 0

	fi

	srv_address_hostname=`echo "$srv_location" | cut -f 1 -d ":"`

	srv_address_ip=`get_host_ip "$srv_address_hostname"`

	srv_address_port=`echo "$srv_location" | cut -f 2 -d ":"`

	# if port or IP can't be determined, return with "unknown"

	if [ -n "$srv_address_ip" -a -n "$srv_address_port" ] ; then

		echo "$srv_address_ip:$srv_address_port"

	else

		echo "$SERVICE_ADDRESS_UNKNOWN"

	fi

	return 0

}

#

# create_menu_lst_file

#

# Purpose : Create the menu.lst file so that the x86 client can get the

#	    information about the netimage and download the necessary files.

#	    It also adds location of the kernel, boot_archive and other options.

#

# Arguments : 

#	None, but it is expected that:

#		$Menufile is set to the correct file.

#		$IMAGE_PATH is set to the absolute path of the image.

#		$SERVICE_NAME is set to the service name.

#		$SERVICE_ADDRESS is set to the location of given service.

#		$IMAGE_IP is set to the IP of the server hosting the image.

#		$BARGLIST is set to the comma separated list of boot properties

#

create_menu_lst_file()

{

	# temporary files used to create separate entries

	#

	tmpent1="/tmp/ent1.$$"

	tmpent2="/tmp/ent2.$$"

	# create the menu.lst.<bootfile> file

	#

	tmpmenu=${Menufile}.$$

	printf "default=0\n" > ${tmpmenu}

	printf "timeout=30\n" >> ${tmpmenu}

	# get min_mem64 entry

	min_mem64=`get_grub_min_mem64 "$IMAGE_PATH"`