# BEGIN_ICS_COPYRIGHT8 ****************************************

# 

# Copyright (c) 2015, Intel Corporation

# 

# Redistribution and use in source and binary forms, with or without

# modification, are permitted provided that the following conditions are met:

# 

#     * Redistributions of source code must retain the above copyright notice,

#       this list of conditions and the following disclaimer.

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

#     * Neither the name of Intel Corporation nor the names of its contributors

#       may be used to endorse or promote products derived from this software

#       without specific prior written permission.

# 

# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT OWNER 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.

# 

# END_ICS_COPYRIGHT8   ****************************************

# [ICS VERSION STRING: unknown]

# assumptions:

#	slot numbers are alphanumeric: A-Za-z0-9 (actually are numeric in <=3.1)

#	card types are alphanumeric with dot, dash, underscore: A-Za-z0-9._-

#	versions are alphanumeric with dot, dash, underscore: A-Za-z0-9._-

# This is an expect (tcl) library of procedures to aid testing

# These functions provide support for chassis operations

# against a test target chassis

## tcl procedures to support testing:

## =============================================

global os_type

proc get_chassis_sftp_status { slot {wait_done 1 }} {

##

## get_chassis_sftp_status

## -------------------------

## return the exit status of the last sftp executed against the given slot

##

## Usage:

##	get_chassis_sftp_status slot [wait_done]

## Arguments:

##	slot - slot number to get status for

##	wait_done - if status is "In Progress", loop until changes to another value

## Returns:

##	"success"

##	"skipped" - transfer unnecessary

##	"invalid" - invalid firmware image for card type

##	"inprogress" - transfer still in progress, but wait_done not set

##	"error" - other errors or timeouts

##	-code error on failure

## Additional Information:

##	The global timeout is changed by this routine

	global spawn_id expect_out spawn_out timeout

	global expecting

	while { 1 } {

		send_chassis_cmd "showLastScpRetCode $slot"

		set out [expect_list 60 { "Code: [0-9]+:" } { "usage" "Invalid" "Error" "Failed" "roblem" "roblem" "not found"} ]

		regexp {[0-9]+} $out ret

		expect_chassis_prompt 60

		if { $ret == 0 } {

			return "success"

		} elseif { $ret == 1 } {

			# unneeded

			return "skipped"

		} elseif { $ret == 2 } {

			# wrong card type

			return "invalid"

		} elseif { $ret == 3 } {

			if { ! $wait_done } {

				# transfer in progress internal to chassis

				return "inprogress"

			}

			# can be a few minutes, so lets be a little patient

			sleep 20

		} else {

			# other errors

			return "error"

		}

	}

}

proc check_chassis_capability { capability } {

##

## check_chassis_capability

## -------------------------

## return level of support for the given capability by the current chassis

##

## Usage:

##	check_chassis_capability capability

## Arguments:

##	capability - the capability name to check

## Returns:

##	0 - capability not supported

##	>0 - version of capability supported

##	-code error on failure

## Additional Information:

##	The global timeout is changed by this routine

	global spawn_id expect_out spawn_out timeout

	global expecting

	send_chassis_cmd "showCapability -key $capability"

	# the [:space:] bounds the + so we get all the data on the line

	set out [expect_list 60 "{$capability: \[0-9A-Za-z\]+\[\[:space:\]\]}" { "usage" "Invalid" "Error" "Failed" "roblem" "not found"} ]

	expect_chassis_prompt 60

	#log_message "out=$out"

	# throw away the \r\n, there may be trailing spaces, TCL lists will ignore

	regexp {: ([A-Za-z0-9]+)[[:space:]]} $out line ret

	#log_message "ret=$ret"

	if { [ string equal -nocase "$ret" "unavailable" ] } {

		set ret 0

	}

	return "$ret"

}

proc get_chassis_slots { { card_type "" } } {

##

## get_chassis_type_slots

## -------------------------

## return the list of slots in the given chassis of the given card type

## if no card type is specified, a list of all slots in the chassis is returned

##

## Usage:

##	get_chassis_type_slots [card_type]

## Arguments:

##	card_type - card type, default is "" (eg. all slots)

## Returns:

##	list of slots in chassis

##	-code error on failure

## Additional Information:

##	The global timeout is changed by this routine

	global spawn_id expect_out spawn_out timeout

	global expecting

	if { ! [ string equal "$card_type" "" ] } {

		send_chassis_cmd "chassisQuery -ignoreInvalidType -type $card_type"

	} else {

		send_chassis_cmd "chassisQuery"

	}

	# this could return no slots, in which case "none" is output

	# The \r\n is needed to bound the + so we get all the data on the line

	set out [expect_list 60 "{slot\[s\]*: \[0-9A-Za-z \]+\[\r\n\]}" { "usage" "Error" "Failed" "roblem" "not found"} ]

	expect_chassis_prompt 60

	#log_message "out=$out"

	# The \r\n is needed to bound the + so we get all the data on the line

	# there may be trailing spaces, TCL lists will ignore

	regexp {: ([0-9A-Za-z ]+)[\r\n]+} $out line ret

	#log_message "ret=$ret"

	if { [ regexp -nocase "none" "$ret" ] } {

		set ret ""

	}

	return "$ret"

}

proc list_esm_security_files { } {

##

## list_esm_security_files

## -------------------------

## return the list of FM security files in the given chassis

##

## Usage:

##	list_esm_security_files

## Arguments:

##	none

## Returns:

##	list of .pem files in chassis

##	-code error on failure

## Additional Information:

##	The global timeout is changed by this routine

	global spawn_id expect_out spawn_out timeout

	global expecting

	send_chassis_cmd "smListSecurityFiles -showSingleLine"

	# this could return no *.pem files, in which case "none" is output

	# The \r\n is needed to bound the + so we get all the data on the line

    set out [expect_list 60 "{files: \[0-9A-Za-z._ \]+\[\r\n\]}" { "usage" "Error" "Failed" "roblem" "not found"} ]

	expect_chassis_prompt 60

	#log_message "out=$out"

	# The \r\n is needed to bound the + so we get all the data on the line

	# there may be trailing spaces, TCL lists will ignore

    regexp {: ([0-9A-Za-z._ ]+)[\r\n]+} $out line ret

	#log_message "ret=$ret"

	if { [ regexp -nocase "none" "$ret" ] } {

		set ret ""

	}

	return "$ret"

}

proc get_chassis_card_type { slot } {

##

## get_chassis_card_type

## -------------------------

## return the card type of the given slot in the given chassis

##

## Usage:

##	get_chassis_card_type slot

## Arguments:

##	slot - slot to query

## Returns:

##	card type of given slot

##	-code error on failure

## Additional Information:

##	The global timeout is changed by this routine

	# DONE

	global spawn_id expect_out spawn_out timeout

	global expecting

	send_chassis_cmd "chassisQuery -showType $slot"

	# require trailing whitespace to anchor end of string

	set out [expect_list 60 "{type: \[a-zA-Z0-9._-\]+\[\[:space:\]\]+}" { "usage" "Invalid" "Error" "Failed" "roblem" "not found"} ]

	# just get the card type field

	regexp {: ([a-zA-Z0-9._-]+)[[:space:]]+} $out line ret

	expect_chassis_prompt 60

	return "$ret"

}

proc is_management_card_type { card_type } {

##

## is_management_card_type

## -------------------------

## is the given card_type a management card for the current chassis

##

## Usage:

##	is_management_card_type card_type

## Arguments:

##	card_type - card type to test

## Returns:

##	0-> this card type is not the management card type for this chassis

##	1-> this card type is the management card type for this chassis

##	-code error on failure

## Additional Information:

##	The global timeout is changed by this routine

##

## Our best way to do this is to query slot 0 for its card type.  Slot 0

## is always the management card

    	set my_slot [ get_this_slot_number ]

	return [string equal [ get_chassis_card_type $my_slot] "$card_type" ]

}

proc get_this_slot_number { } {

##

## get_this_slot_number

## -------------------------

## return the slot number of the management card we are logged into

##

## Usage:

##	get_this_slot_number

## Arguments:

## Returns:

##	slot number

##	-code error on failure

## Additional Information:

##	The global timeout is changed by this routine

	global spawn_id expect_out spawn_out timeout

	global expecting

	send_chassis_cmd "chassisQuery -master"

	# this could return no slots, in which case "none" is output

	# The \r\n is needed to bound the + so we get all the data on the line

	set out [expect_list 60 "{master: \[0-9A-Za-z \]+\[\r\n\]}" { "usage" "Error" "Failed" "roblem" "not found"} ]

	expect_chassis_prompt 60

	#log_message "out=$out"

	# The \r\n is needed to bound the + so we get all the data on the line

	# there may be trailing spaces, TCL lists will ignore

	regexp {: ([0-9A-Za-z ]+)[\r\n]+} $out line ret

	#log_message "ret=$ret"

	if { [ regexp -nocase "none" "$ret" ] } {

		set ret ""

	}

	return "$ret"

}

proc get_chassis_active_firmware_version { slot } {

##

## get_chassis_active_firmware_version

## -------------------------

## return the presently running firmware_version of the given slot

## in the given chassis

##

## Usage:

##	get_chassis_active_firmware_version slot

## Arguments:

##	slot - slot to query

## Returns:

##	firmware version of given slot

##	-code error on failure

## Additional Information:

##	The global timeout is changed by this routine

	global spawn_id expect_out spawn_out timeout

	global expecting

	send_chassis_cmd "fwVersion $slot"

 	# echo of command

	set out [expect_list 60 { "fwVersion" "Firmware Version: [a-zA-Z0-9.]+[[:space:]]" } { "usage" "Invalid" "Error" "Failed" "roblem" "not found"} ]

	regexp {: ([a-zA-Z0-9._-]+)[[:space:]]} $out line ret

	expect_chassis_prompt 60

	return "$ret"

}

proc get_file_firmware_version { fw_file } {

##

## get_file_firmware_version

## -------------------------

## return the firmware version of the given local file

##

## Usage:

##	get_file_firmware_version fw_file

## Arguments:

##	fw_file - local pathname of file

## Returns:

##	firmware version of given file

##	-code error on failure

## Additional Information:

##	The global timeout is changed by this routine

	log_message "opafirmware --showVersion $fw_file\n"

	set fw_version [exec /usr/sbin/opafirmware --showVersion $fw_file]

	log_message "Version: $fw_version\n"

	return "$fw_version"

}

proc get_file_firmware_type { fw_file } {

##

## get_file_firmware_type

## -------------------------

## return the firmware type of the given local file

##

## Usage:

##	get_file_firmware_type fw_file

## Arguments:

##	fw_file - local pathname of file

## Returns:

##	firmware card type of given file

##	-code error on failure

## Additional Information:

##	The global timeout is changed by this routine

	log_message "opafirmware --showType $fw_file"

	set card_type [exec /usr/sbin/opafirmware --showType $fw_file]

	log_message "Card Type: $card_type\n"

	return "$card_type"

}

proc get_chassis_firmware_version { slot {location "act"} } {

##

## get_chassis_firmware_version

## -------------------------

## return the firmware version of the given slot in the chassis

##

## Usage:

##	get_chassis_firmware_version slot [alternate]

## Arguments:

##	slot - slot to query

##	location - location to query

##		"pri" -> primary

##		"alt" -> alternate

##		"act" -> active (running) (default)

## Returns:

##	firmware version of given slot

##	-code error on failure

## Additional Information:

##	The global timeout is changed by this routine

	global spawn_id expect_out spawn_out timeout

	global expecting

	if { [string equal "$location" "act"] } {

		return [get_chassis_active_firmware_version $slot]

	}

	if { [string equal "$location" "alt"] } {

		#set cmd "bootQuery $slot -showVersion -alternate"

		set cmd "bootQuery $slot -alternate"

	} else {

		#set cmd "bootQuery $slot -showVersion"

		set cmd "bootQuery $slot"

	}

	send_chassis_cmd "$cmd"

	set out [expect_list 60 "{version: \[a-zA-Z0-9._-\]+\[\[:space:\]\]}" { "usage" "Invalid" "Error" "Failed" "roblem" "not found"} ]

	regexp {: ([a-zA-Z0-9._-]+)[[:space:]]} $out line ret

	expect_chassis_prompt 60

	return "$ret"

}

proc select_chassis_firmware_version { slot fw_version } {

##

## select_chassis_firmware_version

## -------------------------

## select the given firmware version for the given slot in the chassis

##

## Usage:

##	select_chassis_firmware_version slot fw_version

## Arguments:

##	slot - slot to act on

##	fw_version - firmware version to select

## Returns:

##	0 -> success

##	-code error on failure

## Additional Information:

##	The global timeout is changed by this routine

	global spawn_id expect_out spawn_out timeout

	global expecting

	chassis_cmd 60 0 "bootSelect $slot -version $fw_version"

	return 0

}

proc sftp_chassis_firmware { chassis fw_file {select 0} {slot "all"} } {

##

## sftp_chassis_firmware

## -------------------------

## push the given firmware file to the specified slots in the

## given chassis.

##

## Usage:

##	sftp_chassis_firmware chassis fw_file [select [slot]]

## Arguments:

##	chassis - IP address/name of chassis to sftp to

##	fw_file - local pathname of file to push

##	select - should image be selected (0->no (default), 1->yes)

##	slot - slot to push to, default is "all" of given card type

## Returns:

##	0 -> success

##	-code error on failure

## Additional Information:

##	The global timeout is changed by this routine

	global spawn_id expect_out spawn_out timeout

	global expecting

	if { $select } {

		set nopt ""

	} else {

		set nopt "n"

	}

	# Create a basename for the firmware on the server

	set base [ exec basename $fw_file ]

	if { [ string equal "$slot" "all" ] } {

		chassis_sftp_cmd "sftp admin@\\\[$chassis\\\]:" "put $fw_file A$nopt:/firmware/$base"

	} else {

		chassis_sftp_cmd "sftp admin@\\\[$chassis\\\]:" "put $fw_file $nopt$slot:/firmware/$base"

	}

}

proc push_chassis_firmware { chassis fw_file fw_version card_type {action "push"} { slots "all" } } {

##

## push_chassis_firmware

## -------------------------

## push the given firmware file to the specified slots in the

## given chassis.

##

## Usage:

##	push_chassis_firmware chassis fw_file fw_version card_type [action [slots]]

## Arguments:

##	chassis - IP address/name of chassis to sftp and telnet to

##	fw_file - local pathname of file to push

##	fw_version - firmware version of fw_file

##	card_type - card type of fw_file

##	action - action after pushing firmware:

##			push   - do not reboot, do not change as primary

##					is already primary, no change

##			select - select as primary, but do not reboot

##			run    - select as primary and reboot to activate firmware

##	slots - list of slot numbers to push to, default is "all" of given card type

## Returns:

##	0 -> success

##	-code error on failure

## Additional Information:

##	The global timeout is changed by this routine

##

##  Any slots which are not of a card type which matches that

##	of the firmware file, are quietly skipped.  This allows multi-file

##  push to work with a slot list.

##

##	If the sftp fails for some slots but succeeds for others.  The failed slots

##	are logged and an exception will be thrown, however the good slots

##	are processed to completion [except for the reboot] (if possible)

##  so that they are not left in an odd state

	global spawn_id expect_out spawn_out timeout

	global expecting

	# caller has already done this

	#set fw_version [get_file_firmware_version $fw_file]

	#set card_type [get_file_firmware_type $fw_file]

	# variables:

	#	select - do we want to select the image as primary

	#	active - do we want to select the image as primary and activate it

	if { [ string equal "$action" "push"] } {

		set select 0

		set active 0

	} elseif { [string equal "$action" "select"] } {

		set select 1

		set active 0

	} elseif { [string equal "$action" "run"] } {

		set select 1

		set active 1

	} else {

		fail_test "Invalid firmware push action: $action"

	}

	log_message "\nTest: Seeing if $chassis present running firmware supports firmware push ...\n"

	target_chassis_admin_sh $chassis

	if { [ catch { set cap [check_chassis_capability "fwPush"] } res ] != 0

	     || $cap < 1 } {

		fail_test "Chassis $chassis present running firmware does not support fwPush:\n$res"

	}

	log_message "\nTest: Getting Slot list from $chassis ...\n"

	if { [string equal "$slots" "all"] } {

		# push to all slots of matching card type

		set push_slots [get_chassis_slots $card_type]

		set num_slots [llength $push_slots]

		#set push_all 0

		set push_all 1

	} else {

		# push to a specific set of slots

		set push_slots "$slots"

		set push_all 0

	}

	set num_slots [llength $push_slots]

	if { $num_slots == 0 } {

		target_chassis_admin_sh_exit

		skip_case "No cards of type $card_type"

		return 0

	}

	set is_mgmt [ is_management_card_type $card_type]

	set use_rebootall 0

	if { $is_mgmt } {

		if { [ catch { set cap [check_chassis_capability "redundantMgmtCapable"] } res ] == 0

	     && $cap >= 1 } {

		 	set use_rebootall 1

		}

	}

	log_message "\nTest: Getting present installed firmware from $chassis ...\n"

	# first get present firmware versions for each of the slots

	set act_fw_versions ""

	set pri_fw_versions ""

	set alt_fw_versions ""

	set card_types ""

	foreach slot $push_slots {

		lappend card_types [get_chassis_card_type $slot]

		lappend act_fw_versions [get_chassis_firmware_version $slot "act"]

		lappend pri_fw_versions [get_chassis_firmware_version $slot "pri"]

		lappend alt_fw_versions [get_chassis_firmware_version $slot "alt"]

	}

	target_chassis_admin_sh_exit

	# DEBUG

	#log_message "push_slots: $push_slots"

	#log_message "num_slots: $num_slots"

	#log_message "card_types: $card_types"

	#log_message "act_fw_versions: $act_fw_versions"

	#log_message "pri_fw_versions: $pri_fw_versions"

	#log_message "alt_fw_versions: $alt_fw_versions"

	#log_message "is_mgmt: $is_mgmt"

	log_message "\nTest: Determining operations needed to upgrade to $fw_file for $chassis ..."

	# now check that card types match and determine if we need to push firmware

	set need_push ""

	set need_select ""

	set need_reboot ""

	set have_card 0

	for { set i 0 } { $i < $num_slots } { incr i } {

		set slot [lindex $push_slots $i]

		if { ! [ string equal "$card_type" [lindex $card_types $i] ] } {

			# if this happens card type is inconsistent with original

			# query for slots of given card type (hot swap during update?)

			# or user has explicitly specified slots and picked one of

			# wrong card type

			# quiety ignore this slot

			lappend need_push 0

			lappend need_select 0

			lappend need_reboot 0

			log_message "Test: Skipping slot $slot: is of type [lindex $card_types $i], $fw_file is for $card_type"

			continue

		}

		set have_card 1

		set in_pri [ string equal "$fw_version" [lindex $pri_fw_versions $i] ]

		set in_alt [ string equal "$fw_version" [lindex $alt_fw_versions $i] ]

		set booted [string equal "$fw_version" [lindex $act_fw_versions $i]]

		if { ! $in_pri && ! $in_alt } {

			# firmware is not in slot, need to push and possibly select/reboot

			lappend need_push 1

			set s $select

			log_message "Test: Will need to push firmware to slot $slot"

		} else {

			# firmware is in one of the images

			#set push_all 0

			lappend need_push 0

			# only need to select if not already the primary image

			set s [ expr $select && ! $in_pri]

			log_message "Test: Do Not need to push firmware to slot $slot"

		}

		#  could be running something not on chassis but matching pushed version

		# only need to reboot if not the active image

		set a [ expr $active && ! $booted]

		lappend need_select $s

		lappend need_reboot $a

		if { $s && $a } {

			log_message "Test: Need to select firmware and reboot slot $slot\n"

		} elseif { $a } {

			log_message "Test: Firmware already selected, Need to reboot slot $slot\n"

		} elseif { $s } {

			log_message "Test: Firmware already booted, but need to select firmware for slot $slot\n"

		} else {

			log_message "Test: No need to select firmware nor reboot slot $slot\n"

		}

	}

	# only need do a step if applicable to at least 1 slot

	set do_push [ expr [lsearch -exact $need_push 1] != -1 ]

	set do_select [ expr [lsearch -exact $need_select 1] != -1 ]

	set do_reboot [ expr [lsearch -exact $need_reboot 1] != -1 ]

	# DEBUG

	#log_message "push_all: $push_all"

	#log_message "do_push: $do_push"

	#log_message "do_select: $do_select"

	#log_message "do_reboot: $do_reboot"

	#log_message "need_push: $need_push"

	#log_message "need_select: $need_select"

	#log_message "need_reboot: $need_reboot"

	if { ! ( $do_push || $do_select || $do_reboot ) } {

		# we are done, everything is already the way we want it

		if { $have_card } {

			skip_case "No action required"

		} else {

			skip_case "No selected slots of type $card_type"

		}

		return 0

	}

	set fail 0

	set pushed 0

	set sftp_failures ""

	set sftp_statuses ""

	if { $do_push && $push_all } {

		# push to all applicable slots at once

		log_message "Test: sftp $fw_file to all applicable slots\n"

		sftp_chassis_firmware $chassis $fw_file $select "all"

		# will check status of sftp operations for slots we care about below

		log_message "\nTest: Verifying firmware was pushed to $chassis ...\n"

		target_chassis_admin_sh $chassis

	}

	for { set i 0 } { $i < $num_slots } { incr i } {

		set slot [lindex $push_slots $i]

		if { $do_push && ( $push_all || [lindex $need_push $i] ) } {

			if { ! $push_all } {

				# push one slot at a time

				log_message "\nTest: sftp $fw_file to slot $slot\n"

				sftp_chassis_firmware $chassis $fw_file $select $slot

				target_chassis_admin_sh $chassis

			}

			# check status, must do immediately after sftp

			set status [get_chassis_sftp_status $slot 1]

			if { [ string equal "$status" "success" ] || [ string equal "$status"  "skipped" ] } {

				set pushed 1

				lappend sftp_failures 0

				lappend sftp_statuses "$status"

			} else {

				log_message "\nFAILURE: Failed to sftp firmware to chassis $chassis slot $slot\n"

				set fail 1

				lappend sftp_failures 1

				lappend sftp_statuses "$status"

			}

			if { ! $push_all } {

				target_chassis_admin_sh_exit

			}

		} else {

			# we never sftp'ed to this slot

			lappend sftp_failures 0

			lappend sftp_statuses "skipped"

		}

	}

	# make sure we are logged in for operations below

	if { ! ( $do_push && $push_all ) } {

		target_chassis_admin_sh $chassis

	}

	# DEBUG

	#log_message "pushed: $pushed"

	#log_message "sftp_statuses: $sftp_statuses"

	#log_message "sftp_failures: $sftp_failures"

	#log_message "fail: $fail"

	if { $pushed } {

		# we pushed firmware to some or all of the requested slots

		# now check firmware versions

		for { set i 0 } { $i < $num_slots } { incr i } {

			set slot [lindex $push_slots $i]

			if { [lindex $sftp_failures $i] } {

				# it failed, no further checks necessary

				continue

			}

			if { ! $push_all && ! [lindex $need_push $i] } {

				# we never sftp'ed to this slot

				continue

			}

			# if we get here, status was success or skipped

			# check what is in the slot after the sftp

			set pri_fw_version [get_chassis_firmware_version $slot "pri"]

			set alt_fw_version [get_chassis_firmware_version $slot "alt"]

			set in_pri [ string equal "$fw_version" "$pri_fw_version" ]

			set in_alt [ string equal "$fw_version" "$alt_fw_version" ]

			if { $push_all && ! [lindex $need_push $i] } {

				# sftp should have skipped this slot

				if { ! [ string equal [lindex $sftp_statuses $i] "skipped" ] } {

					set sftp_failures [lreplace $sftp_failures $i $i 1]

					set fail 1

					log_message "\nFAILURE: Unexpected sftp transfer for chassis $chassis slot $slot\n"

				} elseif { ! $in_pri && ! $in_alt } {

					# the version disappeared

					set sftp_failures [lreplace $sftp_failures $i $i 1]

					set fail 1

					log_message "\nFAILURE: Unexpected removal of $fw_version for chassis $chassis slot $slot\n"

				} elseif { $select && ! $in_pri } {

					# the primary changed?

					# we can recover

					log_message "\nWARNING: Unexpected change of primary for chassis $chassis slot $slot\n"

					set need_select [lreplace $need_select $i $i 1]

					set do_select 1

				}

				continue

			}

			# if we get here, we needed to push to this slot

			# hence the slot should not have been skipped

			if { ! [ string equal [lindex $sftp_statuses $i] "success" ] } {

				# it was skipped for no reason

				set sftp_failures [lreplace $sftp_failures $i $i 1]

				set fail 1

				log_message "\nFAILURE: Unexpected skip of sftp transfer for chassis $chassis slot $slot\n"

			} elseif { ! $in_pri && ! $in_alt } {

				# the version never appeared

				set sftp_failures [lreplace $sftp_failures $i $i 1]

				set fail 1

				log_message "\nFAILURE: $fw_version did not transfer to chassis $chassis slot $slot\n"

			} elseif { $select && ! $in_pri } {

				# the image is there but was not selected

				# we can recover

				log_message "\nWARNING: sftp transfered to wrong image for chassis $chassis slot $slot\n"

				set need_select [lreplace $need_select $i $i 1]

				set do_select 1

			}

		}

	}

	# DEBUG

	#log_message "sftp_failures: $sftp_failures"

	#log_message "do_select: $do_select"

	#log_message "need_select: $need_select"

	if { $do_select } {

		# now select the firmware as primary for the necessary slots

		for { set i 0 } { $i < $num_slots } { incr i } {

			if { [lindex $sftp_failures $i] } {

				# it failed, no further ops necessary

				continue

			}

			if { ! [lindex $need_select $i] } {

				# does not need select

				continue

			}

			set slot [lindex $push_slots $i]

			select_chassis_firmware_version $slot $fw_version

		}

	}

	# if any of the above failed, do not activate or reboot it could

	# make things worse

	if { $fail } {

		fail_test "Unable to sftp firmware to requested slots in $chassis"

	}

	# DEBUG

	#log_message "do_reboot: $do_reboot"

	#log_message "need_reboot: $need_reboot"

	#log_message "is_mgmt: $is_mgmt"

	# now activate the firmware for the necessary slots

	if { $do_reboot} {

		if { $is_mgmt } {

			# we can't tell which slot is the active mgmt slot, so just reboot

			# the whole chassis

			if { $use_rebootall } {

				chassis_cmd_reboot_all

			} else {

				send_chassis_cmd "reboot now"

				expect_list 60 { "Goodbye" }

			}

			# may not be able to send logout command, so just get out of dodge

			ignore_rest

			chassis_wait_reboot_done $chassis

			return 0

		} else {

			for { set i 0 } { $i < $num_slots } { incr i } {

				if { [lindex $need_reboot $i] } {

					set slot [lindex $push_slots $i]

					chassis_cmd 60 0 "resetCard $slot now"

				}

			}

			# TBD - is there a way to poll via CLI if card has finished reboot?

			# allow 60 seconds for it to come fully on line

			sleep 60

		}

	}

	target_chassis_admin_sh_exit

	return 0

}

proc test_case_push_chassis_firmware { chassis fw_file fw_version card_type {action "push"} { slots "all" } } {

##

## test_case_push_chassis_firmware

## -------------------------

## test case to push the given firmware file to the specified slots in the

## given chassis.

##

## Usage:

##	test_case_push_chassis_firmware chassis fw_file fw_version card_type [action [slots]]

## Arguments:

##	chassis - IP address/name of chassis to sftp and telnet to

##	fw_file - local pathname of file to push

##	fw_version - firmware version of fw_file

##	card_type - card type of fw_file

##	action - action after pushing firmware:

##			push - do not reboot, do not change as primary

##					is already primary, no change

##			select - select as primary, but do not reboot

##			run - select as primary and reboot to activate firmware

##	slots - list of slot numbers to push to, default is "all" of given card type

## Returns:

##	0 -> success