File Coverage

blib/lib/Control/CLI/AvayaData.pm

Criterion	Covered	Total	%
statement	29	1852	1.5
branch	12	1634	0.7
condition	1	464	0.2
subroutine	6	61	9.8
pod	47	47	100.0
total	95	4058	2.3

package Control::CLI::AvayaData;

use strict;
use warnings;
use Exporter qw( import );
use Carp;
use Control::CLI qw( :all );

my $Package = __PACKAGE__;
our $VERSION = '2.04';
our @ISA = qw(Control::CLI);
our %EXPORT_TAGS = (
		use	=> [qw(useTelnet useSsh useSerial useIPv6)],
		prompt	=> [qw(promptClear promptHide promptCredential)],
		args	=> [qw(parseMethodArgs suppressMethodArgs)],
		coderef	=> [qw(validCodeRef callCodeRef)],
		_rest	=> [qw(passphraseRequired parse_errmode stripLastLine poll)],
	);
push @{$EXPORT_TAGS{all}}, @{$EXPORT_TAGS{$_}} foreach keys %EXPORT_TAGS;
Exporter::export_ok_tags('all');

########################################### Global Class Variables ###########################################

my %LoginPatterns = ( # Patterns to check for during device login (Telnet/Serial) and initial connection to CLI
	bell		=>	"\x07",
	banner		=>	'Enter Ctrl-Y to begin',
	menu		=>	'Use arrow keys to highlight option, press  or  to select option',
	submenu		=>	'Press Ctrl-R to return to previous menu.  Press Ctrl-C to return to Main Menu',
	username	=>	'Enter Username: ',
	password	=>	"Enter Password: \e[?", # Should match only on the initial password prompt and not subsequent ones where * are printed
	lastlogin	=>	'Failed retries since last login:',
	localfail	=>	'Incorrect',
	radiusfail	=>	'Access Denied from RADIUS',
	radiustimeout1	=>	'no response from RADIUS servers',
	radiustimeout2	=>	'No reply from RADIUS server',
	srbanner	=>	"\((?:Secure Router|VSP4K)",
	xlrbanner	=>	"\x0d************************************\n",
	ersbanner	=>	"\x0d* Ethernet Routing Switch",
	passportbanner	=>	"\x0d* Passport 8",
	pp1600banner	=>	"\x0d* Passport 16", # The 6 ensures this does not trigger on old Accelar 1x00
	vspbanner	=>	"All Rights Reserved.\n\x0dVirtual Services Platform",
	consoleLogMsg1	=>	"connected via console port", #On serial port: GlobalRouter SW INFO user rwa connected via console port
	consoleLogMsg2	=>	"Blocked unauthorized ACLI access",
	more1		=>	'----More (q=Quit, space/return=Continue)----',
	more2		=>	'--More--',
	wlan9100banner	=>	'Avaya Wi-Fi Access Point',
);
my %Prm = ( # Hash containing list of named parameters returned by attributes
	bstk	=>	'BaystackERS',
	pers	=>	'PassportERS',
	xlr	=>	'Accelar',
	sr	=>	'SecureRouter',
	trpz	=>	'WLAN2300',
	xirrus	=>	'WLAN9100',
	generic	=>	'generic',
);
my %Attribute = (
	Global		=> [
			'family_type',
			'is_nncli',
			'is_acli',
			'model',
			'sw_version',
			'fw_version',
			'slots',
			'ports',
			'sysname',
			'base_mac',
			'baudrate',
			'max_baud',
			],

	$Prm{pers}	=> [
			'is_voss',
			'is_apls',
			'apls_box_type',
			'brand_name',
			'is_master_cpu',
			'is_dual_cpu',
			'cpu_slot',
			'is_ha',
			'stp_mode',
			'oob_ip',
			'oob_virt_ip',
			'oob_standby_ip',
			'is_oob_connected',
			],

	$Prm{bstk}	=> [
			'unit_number',
			'base_unit',
			'switch_mode',
			'stack_size',
			'stp_mode',
			'mgmt_vlan',
			'mgmt_ip',
			'oob_ip',
			'is_oob_connected',
			],

	$Prm{xlr}	=> [
			'is_master_cpu',
			'is_dual_cpu',
			],
);

my @InitPromptOrder = ("$Prm{pers}_cli", "$Prm{pers}_nncli", $Prm{bstk}, 'generic');
my %InitPrompt = ( # Initial prompt pattern expected at login
	$Prm{bstk}		=>	'\x0d?([^\n\x0d\x0a]{1,50}?)()(?:\((.+?)\))?[>#]$',
	"$Prm{pers}_cli"	=>	'\x0d?([^\n\x0d\x0a]+):([1356])((?:\/[\w\d\.-]+)*)[>#] $',
	"$Prm{pers}_nncli"	=>	'\x0d?([^\n\x0d\x0a]+):([12356])(?:\((.+?)\))?[>#]$',
	$Prm{xlr}		=>	'\x0d?([^\n\x0d\x0a]+?)()((?:\/[\w\d-]+)*)[>#] $',
	$Prm{sr}		=>	'\x0d? *\x0d([^\n\x0d\x0a]+?)()((?:\/[\w\d\s-]+(?: \(\d+\/\d+\))?)*)# $',
	$Prm{trpz}		=>	'([^\n\x0d\x0a]+)[>#] $',
	$Prm{xirrus}		=>	'(?:\x10\x00)?([^\n\x0d\x0a]+?)()(?:\((.+?)\))?# $',
	$Prm{generic}		=>	'[^\n\x0d\x0a]*[\?\$%#>]\s?$',
);
my %Prompt = ( # Prompt pattern templates; SWITCHNAME gets replaced with actual switch prompt during login
	$Prm{bstk}		=>	'SWITCHNAME(?:\((.+?)\))?[>#]$',
	"$Prm{pers}_cli"	=>	'SWITCHNAME:[1356]((?:\/[\w\d\.-]+)*)[>#] $',
	"$Prm{pers}_nncli"	=>	'SWITCHNAME:[12356](?:\((.+?)\))?[>#]$',
	$Prm{xlr}		=>	'SWITCHNAME((?:\/[\w\d-]+)*)[>#] $',
	$Prm{sr}		=>	'\x0d? *\x0dSWITCHNAME((?:\/[\w\d\s-]+(?: \(\d+\/\d+\))?)*)# $',
	$Prm{trpz}		=>	'SWITCHNAME[>#] $',
	$Prm{xirrus}		=>	'(?:\x10\x00)?SWITCHNAME(?:\((.+?)\))?# $',
	$Prm{generic}		=>	'[^\n\x0d\x0a]*[\?\$%#>]\s?$',
);
my $LastPromptClense = '^(?:\x0d? *\x0d|\x10\x00)'; # When capturing lastprompt, SecureRouter and Xirrus sometimes precede the prompt with these characters

my %MorePrompt = ( # The following characters are automatically backslashed in more_prompt(): ().
	$Prm{bstk}		=>	'----More (q=Quit, space/return=Continue)----',
	"$Prm{pers}_cli"	=>	'\n\x0d?--More-- (q = quit) ',
	"$Prm{pers}_nncli"	=>	'\n\x0d?--More-- (q = quit) |--More--',
	$Prm{xlr}		=>	'--More-- (q = quit) ',
	$Prm{sr}		=>	'Press any key to continue (q : quit) :\x00|Press any key to continue (q : quit \| enter : next line) :\x00',
	$Prm{trpz}		=>	'press any key to continue, q to quit.',
	$Prm{xirrus}		=>	'--MORE--\x10?',
	$Prm{generic}		=>	'----More (q=Quit, space/return=Continue)----|--More-- (q = quit) |Press any key to continue (q : quit) :\x00|press any key to continue, q to quit.|--MORE--',
);
my %MorePromptDelay = ( # Only when a possible more prompt can be matched as subset of other more prompt patterns; for these an extra silent read is required
	$Prm{bstk}		=>	undef,
	"$Prm{pers}_cli"	=>	undef,
	"$Prm{pers}_nncli"	=>	'--More--',
	$Prm{xlr}		=>	undef,
	$Prm{sr}		=>	undef,
	$Prm{trpz}		=>	undef,
	$Prm{xirrus}		=>	undef,
	$Prm{generic}		=>	'--More--',
);
our %ErrorPatterns = ( # Patterns which indicated the last command sent generated a syntax error on the host device
	$Prm{bstk}		=>	'^('
					. '\s+\^\n.+'
					. '|% Invalid input detected at \'\^\' marker\.'
					. '|% Cannot modify settings'
					. '|% Bad (?:port|unit) number\.'
					. '|% MLT \d+ does not exist or it is not enabled'
					. '|% No such VLAN'
					. '|% Bad VLAN list format\.'
					. '|% View name does not exist'		# snmp-server user admin read-view root write-view root notify-view root
					. '|% Partial configuration of \'.+?\' already exists\.'	# same as above
					. '|% View already exists, you must first delete it\.'	# snmp-server view root 1
					. '|% User \w+ does not exist'		# no snmp-server user admindes
					. '|% User \'.+?\' already exists'	# snmp-server user admin md5 passwdvbn read-view root write-view root notify-view root
					. '|% Password length must be in range:' # username add rwa role-name RW password // rwa // rwa (with password security)
					. '|% Bad format, use forms:'		# vlan members add 71 1/6-1/7 (1/6-7 is correct)
				. ')',
	$Prm{pers}		=>	'^('
					. '\x07?\s+\^\n.+'
					. '|% Invalid input detected at \'\^\' marker\.'
					. '|.+? not found in path .+'
					. '|(?:parameter|object) .+? is out of range'
					. '|\x07?Error ?: .+'
					. '|Unable to .+'
					. '|% Not allowed on secondary cpu\.'
					. '|% Incomplete command\.'
					. '|% Vrf "[^"]+" does not exist'
					. '| ERROR: copy failed \(code:0x[\da-fA-F]+\)'
					. '|Save config to file [^ ]+ failed\.'
					. '|% Vlan \d+ does not exist'
					. '|Command not allowed MSTP RSTP mode\.'			# On MSTP switch : vlan create 101 type port 1
					. '|% Permission denied\.'					# TACACS commands not allowed
					. '|% Only (?:gigabit|fast) ethernet ports allowed'		# config interface gig on fastEth port or vice-versa
					. '|There are \d+ releases already on system. Please remove 1 to proceed'
					. '|can\'t \w+ ".+?" 0x\d+'					# delete /flash/.ssh -y : can't remove "/flash/.ssh" 0x300042
					. '|".+?" is ambiguous in path /'				# AccDist3:5#% do
					. '|Password change aborted\.'	# Creating snmpv3 usm user with enh-secure-mode and password does not meet complexity requirements
					. '|Invalid password. Authentication failed'			# username teamnoc level ro // invalid-old-pwd // ...
					. '|Passwords do not match. Password change aborted'		# username teamnoc level ro // valid-old-pwd // newpwd // diffpwd
					. '|Error: Prefix List ".+?" not found'				# no ip prefix-list ""
				. ')',
	$Prm{xlr}		=>	'^('
					. '.+? not found'
					. '|(?:parameter|object) .+? is out of range'
				. ')',
	$Prm{sr}		=>	'^('
					. '\s+\^\n.+'
					. '|Error : Command .+? does not exist'
					. '|Config is locked by some other user'
				. ')',
	$Prm{trpz}		=>	'^('
					. '\s+\^\n.+'
					. '|Unrecognized command:.+'
					. '|Unrecognized command in this mode:.+'
				. ')',
	$Prm{xirrus}		=>	'^('
					. '\s+\^\n.+'
				. ')',
);
our $CmdConfirmPrompt = '[\(\[] *(?:[yY](?:es)? *(?:[\\\/]|or) *[nN]o?|[nN]o? *(?:[\\\/]|or) *[yY](?:es)?) *[\)\]] *[?:] *$'; # Y/N prompt
our $CmdInitiatedPrompt = '[?:=][ \t]*$'; # Prompt for additional user info
our $WakeConsole = "\n"; # Sequence to send when connecting to console to wake device

my $LoginReadAttempts = 10;		# Number of read attempts for readwait() method used in login()
my $CmdPromptReadAttempts = 5;		# Number of read attempts for readwait() method used in poll_cmd()
my $ReadwaitTimer = 100;		# Timer to use when calling readwait()
my $CmdTimeoutRatio = 0.1;		# In cmd() if read times out, a 2nd read is attempted with timeout * this ratio

my $Space = " ";
my $CTRL_C = "\cC";
my $CTRL_U = "\cU";
my $CTRL_X = "\cX";
my $CTRL_Y = "\cY";
my $CTRL_Z = "\cZ";

my %Default = ( # Hash of default object seetings which can be modified on a per object basis
	morePaging		=>	0,	# For --more-- prompt, number of pages accepted before sending q to quit
						# 0 = accept all pages; 1 = send q after 1st page, i.e. only 1 page; etc
	progressDots		=>	0,	# After how many bytes received, an activity dot is printed; 0 = disabled
	return_result		=>	0,	# Whether cmd methods return true/false result or output of command
	cmd_confirm_prompt	=>	$CmdConfirmPrompt,
	cmd_initiated_prompt	=>	$CmdInitiatedPrompt,
	cmd_feed_timeout	=>	10,	# Command requests for data, we have none, after X times we give up
	wake_console		=>	$WakeConsole,
);

our @ConstructorArgs = ( @Control::CLI::ConstructorArgs, 'return_result', 'more_prompt', 'more_paging', 'debug_file',
			'cmd_confirm_prompt', 'cmd_initiated_prompt', 'cmd_feed_timeout', 'console', 'wake_console',
			);

# Debug levels can be set using the debug() method or via debug argument to new() constructor
# Debug levels defined:
# 	0	: No debugging
# 	bit 1	: Control::CLI - Debugging activated for polling methods + readwait() + Win32/Device::SerialPort constructor $quiet flag reset
# 	bit 2	: Control::CLI - Debugging is activated on underlying Net::SSH2 and Win32::SerialPort / Device::SerialPort
# 	bit 4	: Control::CLI::AvayaData - Basic debugging
# 	bit 8	: Control::CLI::AvayaData - Extended debugging of login() & cmd() methods


############################################# Constructors/Destructors #######################################

sub new {
	my $pkgsub = "${Package}::new";
	my $invocant = shift;
	my $class = ref($invocant) || $invocant;
	my (%args, %cliArgs);
	my $debugLevel = $Default{debug};
	if (@_ == 1) { # Method invoked with just the connection type argument
		$cliArgs{use} = shift;
	}
	else {
		%args = parseMethodArgs($pkgsub, \@_, \@ConstructorArgs);
		my @suppressArgs = ('prompt', 'return_result', 'more_prompt', 'more_paging', 'cmd_confirm_prompt',
				'cmd_initiated_prompt', 'cmd_feed_timeout', 'console', 'wake_console', 'debug_file');
		%cliArgs = suppressMethodArgs(\@_, \@suppressArgs);
	}
	my $self = $class->SUPER::new(%cliArgs) or return;
	$self->{$Package} = {
		# Lower Case ones can be set by user; Upper case ones are set internaly in the class
		morePaging		=>	$Default{morePaging},
		progressDots		=>	$Default{progressDots},
		prompt			=>	undef,
		prompt_qr		=>	undef,
		morePrompt		=>	undef,
		morePrompt_qr		=>	undef,
		morePromptDelay_qr	=>	undef,
		last_cmd_success	=>	undef,
		last_cmd_errmsg		=>	undef,
		return_result		=>	$Default{return_result},
		cmd_confirm_prompt	=>	$Default{cmd_confirm_prompt},
		cmd_confirm_prompt_qr	=>	qr/$Default{cmd_confirm_prompt}/,
		cmd_initiated_prompt	=>	$Default{cmd_initiated_prompt},
		cmd_initiated_prompt_qr	=>	qr/$Default{cmd_initiated_prompt}/,
		cmd_feed_timeout	=>	$Default{cmd_feed_timeout},
		console			=>	undef,
		wake_console		=>	$Default{wake_console},
		PROMPTTYPE		=>	undef,
		ENABLEPWD		=>	undef,
		ORIGBAUDRATE		=>	undef,
		ATTRIB			=>	undef,
		ATTRIBFLAG		=>	undef,
		CONFIGCONTEXT		=>	'',
		DEBUGLOGFH		=>	undef,
	};
	foreach my $arg (keys %args) { # Accepted arguments on constructor
		if    ($arg eq 'prompt')			{ $self->prompt($args{$arg}) }
		elsif ($arg eq 'return_result')			{ $self->return_result($args{$arg}) }
		elsif ($arg eq 'more_prompt')			{ $self->more_prompt($args{$arg}) }
		elsif ($arg eq 'more_paging')			{ $self->more_paging($args{$arg}) }
		elsif ($arg eq 'cmd_confirm_prompt')		{ $self->cmd_confirm_prompt($args{$arg}) }
		elsif ($arg eq 'cmd_initiated_prompt')		{ $self->cmd_initiated_prompt($args{$arg}) }
		elsif ($arg eq 'cmd_feed_timeout')		{ $self->cmd_feed_timeout($args{$arg}) }
		elsif ($arg eq 'console')			{ $self->console($args{$arg}) }
		elsif ($arg eq 'wake_console')			{ $self->wake_console($args{$arg}) }
		elsif ($arg eq 'debug_file')			{ $self->debug_file($args{$arg}) }
	}
	return $self;
}


# sub DESTROY {} # We don't need to override Control::CLI's destroy method


############################################### Object methods ###############################################

sub connect { # All the steps necessary to connect to a CLI session on an Avaya Networking device
	my $pkgsub = "${Package}::connect";
	my $self = shift;
	my %args;
	if (@_ == 1) { # Method invoked in the shorthand form
		$args{host} = shift;
		if ($args{host} =~ /^(.+?)\s+(\d+)$/) {
			($args{host}, $args{port}) = ($1, $2);
		}
	}
	else {
		my @validArgs = ('host', 'port', 'username', 'password', 'publickey', 'privatekey', 'passphrase',
				 'prompt_credentials', 'baudrate', 'parity', 'databits', 'stopbits', 'handshake',
				 'errmode', 'connection_timeout', 'timeout', 'read_attempts', 'wake_console',
				 'return_reference', 'blocking', 'data_with_error', 'terminal_type', 'window_size',
				 'callback', 'forcebaud', 'atomic_connect');
		%args = parseMethodArgs($pkgsub, \@_, \@validArgs);
	}

	# Initialize the base POLL structure
	$self->poll_struct( # $methodName, $codeRef, $blocking, $timeout, $errmode, $outputType, $outputRequested, $returnReference, $returnList
				$pkgsub,
				__PACKAGE__->can('connect_poll'),
				defined $args{blocking} ? $args{blocking} : $self->{blocking},
				defined $args{connection_timeout} ? $args{connection_timeout} : $self->{connection_timeout},
				defined $args{errmode} ? parse_errmode($pkgsub, $args{errmode}) : undef,
				1,
				wantarray,
				defined $args{return_reference} ? $args{return_reference} : $self->{return_reference},
				undef,	# n/a
			);
	$self->{POLL}{$pkgsub} = { # Populate structure with method arguments/storage
		# Set method argument keys
		host			=>	$args{host},
		port			=>	$args{port},
		username		=>	$args{username},
		password		=>	$args{password},
		publickey		=>	$args{publickey},
		privatekey		=>	$args{privatekey},
		passphrase		=>	$args{passphrase},
		baudrate		=>	$args{baudrate},
		parity			=>	$args{parity},
		databits		=>	$args{databits},
		stopbits		=>	$args{stopbits},
		handshake		=>	$args{handshake},
		prompt_credentials	=>	defined $args{prompt_credentials} ? $args{prompt_credentials} : $self->{prompt_credentials},
		terminal_type		=>	$args{terminal_type},
		window_size		=>	$args{window_size},
		callback		=>	$args{callback},
		forcebaud		=>	$args{forcebaud},
		atomic_connect		=>	$args{atomic_connect},
		login_timeout		=>	defined $args{timeout} ? $args{timeout} : $self->{timeout},
		read_attempts		=>	defined $args{read_attempts} ? $args{read_attempts} : $LoginReadAttempts,
		data_with_error		=>	defined $args{data_with_error} ? $args{data_with_error} : $self->{data_with_error},
		wake_console		=>	defined $args{wake_console} ? $args{wake_console} : $self->{$Package}{wake_console},
		# Declare method storage keys which will be used
		stage			=>	$self->{LOGINSTAGE} ? 1 : 0,
	};
	if (!$self->{LOGINSTAGE} && $self->{TYPE} ne 'SERIAL' && useIPv6 && defined $args{blocking} && !$args{blocking}) {
		carp "$pkgsub: IO::Socket::IP is required for non-blocking connect";
	}
	local $self->{POLLING} = 1; # True until we come out of this polling-capable method
	local $self->{errmode} = $self->{POLL}{errmode} if defined $self->{POLL}{errmode};
	return __PACKAGE__->can('poll_connect')->($self, $pkgsub); # Do not call a sub-classed version
}


sub connect_poll { # Poll status of connection (non-blocking mode)
	my $pkgsub = "${Package}::connect_poll";
	my $self = shift;
	carp "$pkgsub: No arguments expected" if @_; # No arguments expected

	unless (defined $self->{POLL} && $self->{POLL}{coderef} == __PACKAGE__->can('connect_poll')) {
		return $self->error("$pkgsub: Method connect() needs to be called first with blocking false");
	}
	$self->{POLL}{output_requested} = wantarray; # This might change at every call
	local $self->{POLLING} = 1; # True until we come out of this polling-capable method
	local $self->{errmode} = $self->{POLL}{errmode} if defined $self->{POLL}{errmode};

	# If already completed (1) or we got an error (undef) from previous call (errmsg is already set) then we go no further
	return $self->poll_return($self->{POLL}{complete}) unless defined $self->{POLL}{complete} && $self->{POLL}{complete} == 0;

	# We get here only if we are not complete: $self->{POLL}{complete} == 0
	return __PACKAGE__->can('poll_connect')->($self, $pkgsub); # Do not call a sub-classed version
}


sub disconnect { # Perform check on restoring buadrate on device before doing Control::CLI's disconnect
	my $self = shift;
	$self->_restoreDeviceBaudrate if $self->connection_type eq 'SERIAL';
	return $self->SUPER::disconnect(@_);
}


sub login { # Handles steps necessary to get to CLI session, including menu, banner and Telnet/Serial login
	my $pkgsub = "${Package}::login";
	my $self =shift;
	my @validArgs = ('username', 'password', 'prompt_credentials', 'timeout', 'errmode', 'return_reference',
			 'read_attempts', 'wake_console', 'blocking', 'data_with_error');
	my %args = parseMethodArgs($pkgsub, \@_, \@validArgs);

	# Initialize the base POLL structure
	$self->poll_struct( # $methodName, $codeRef, $blocking, $timeout, $errmode, $outputType, $outputRequested, $returnReference, $returnList
				$pkgsub,
				__PACKAGE__->can('login_poll'),
				defined $args{blocking} ? $args{blocking} : $self->{blocking},
				defined $args{timeout} ? $args{timeout} : $self->{timeout},
				defined $args{errmode} ? parse_errmode($pkgsub, $args{errmode}) : undef,
				1,
				wantarray,
				defined $args{return_reference} ? $args{return_reference} : $self->{return_reference},
				undef,	# n/a
			);
	$self->{POLL}{$pkgsub} = { # Populate structure with method arguments/storage
		# Set method argument keys
		username		=>	$args{username},
		password		=>	$args{password},
		prompt_credentials	=>	defined $args{prompt_credentials} ? $args{prompt_credentials} : $self->{prompt_credentials},
		read_attempts		=>	defined $args{read_attempts} ? $args{read_attempts} : $LoginReadAttempts,
		data_with_error		=>	defined $args{data_with_error} ? $args{data_with_error} : $self->{data_with_error},
		wake_console		=>	defined $args{wake_console} ? $args{wake_console} : $self->{$Package}{wake_console},
		# Declare method storage keys which will be used
		stage			=>	0,
		login_attempted		=>	undef,
		password_sent		=>	undef,
		login_error		=>	'',
		family_type		=>	undef,
		cpu_slot		=>	undef,
		detectionFromPrompt	=>	undef,
	};
	local $self->{POLLING} = 1; # True until we come out of this polling-capable method
	local $self->{errmode} = $self->{POLL}{errmode} if defined $self->{POLL}{errmode};
	return __PACKAGE__->can('poll_login')->($self, $pkgsub); # Do not call a sub-classed version
}


sub login_poll { # Poll status of login (non-blocking mode)
	my $pkgsub = "${Package}::login_poll";
	my $self = shift;
	carp "$pkgsub: No arguments expected" if @_; # No arguments expected

	unless (defined $self->{POLL} && $self->{POLL}{coderef} == __PACKAGE__->can('login_poll')) {
		return $self->error("$pkgsub: Method login() needs to be called first with blocking false");
	}
	$self->{POLL}{output_requested} = wantarray; # This might change at every call
	local $self->{POLLING} = 1; # True until we come out of this polling-capable method
	local $self->{errmode} = $self->{POLL}{errmode} if defined $self->{POLL}{errmode};

	# If already completed (1) or we got an error (undef) from previous call (errmsg is already set) then we go no further
	return $self->poll_return($self->{POLL}{complete}) unless defined $self->{POLL}{complete} && $self->{POLL}{complete} == 0;

	# We get here only if we are not complete: $self->{POLL}{complete} == 0
	return __PACKAGE__->can('poll_login')->($self, $pkgsub); # Do not call a sub-classed version
}


sub cmd { # Sends a CLI command to host and returns result or output data
	my $pkgsub = "${Package}::cmd";
	my $self = shift;
	my %args;
	if (@_ == 1) { # Method invoked with just the command argument
		$args{command} = shift;
	}
	else {
		my @validArgs = ('command', 'prompt', 'reset_prompt', 'more_prompt', 'cmd_confirm_prompt', 'more_pages',
				 'timeout', 'errmode', 'return_reference', 'return_result', 'progress_dots', 'blocking', 'poll_syntax');
		%args = parseMethodArgs($pkgsub, \@_, \@validArgs);
	}
	$args{command} = '' unless defined $args{command};

	# Initialize the base POLL structure
	$self->poll_struct( # $methodName, $codeRef, $blocking, $timeout, $errmode, $outputType, $outputRequested, $returnReference, $returnList
				$pkgsub,
				__PACKAGE__->can('cmd_poll'),
				defined $args{blocking} ? $args{blocking} : $self->{blocking},
				defined $args{timeout} ? $args{timeout} : $self->{timeout},
				defined $args{errmode} ? parse_errmode($pkgsub, $args{errmode}) : undef,
				(defined $args{return_result} ? $args{return_result} : $self->{$Package}{return_result}) ? 2 : 1,
				undef, # This is set below
				defined $args{return_reference} ? $args{return_reference} : $self->{return_reference},
				undef,	# n/a
			);
	$self->{POLL}{$pkgsub} = { # Populate structure with method arguments/storage
		# Set method argument keys
		command			=>	$args{command},
		prompt			=>	defined $args{prompt} ? $args{prompt} : $self->{$Package}{prompt_qr},
		more_prompt		=>	defined $args{more_prompt} ? $args{more_prompt} : $self->{$Package}{morePrompt_qr},
		more_prompt_delay	=>	defined $args{more_prompt} ? undef : $self->{$Package}{morePromptDelay_qr},
		more_pages		=>	defined $args{more_pages} ? $args{more_pages} : $self->{$Package}{morePaging},
		reset_prompt		=>	$args{reset_prompt} && defined $self->{$Package}{PROMPTTYPE},
		yn_prompt		=>	defined $args{cmd_confirm_prompt} ? $args{cmd_confirm_prompt} : $self->{$Package}{cmd_confirm_prompt_qr},
		cmd_prompt		=>	undef,
		feed_data		=>	undef,
		progress_dots		=>	defined $args{progress_dots} ? $args{progress_dots} : $self->{$Package}{progressDots},
		# Declare method storage keys which will be used
		stage			=>	0,
		lastLine		=>	'',
		outputNewline		=>	'',
		progress		=>	undef,
		alreadyCmdTimeout	=>	0,
		ynPromptCount		=>	undef,
		cmdPromptCount		=>	undef,
		cmdEchoRemoved		=>	0,
		lastPromptEchoedCmd	=>	undef,
		cache_timeout		=>	$self->{POLL}{timeout},
	};
	$self->{POLL}{output_requested} = !$args{poll_syntax} || wantarray; # Always true in legacy syntax and in poll_syntax if wantarray
	local $self->{POLLING} = 1; # True until we come out of this polling-capable method
	local $self->{errmode} = $self->{POLL}{errmode} if defined $self->{POLL}{errmode};

	my ($ok, $output) = $self->poll_cmd($pkgsub);
	# We have a different syntax for scalar output in blocking and non-blocking modes
	if ($args{poll_syntax}) { # New syntax
		return wantarray ? ($ok, $output) : $ok;
	}
	else { # Old syntax
		return wantarray ? ($ok, $output) : $output;
	}
}


sub cmd_prompted { # Sends a CLI command to host, feed additional data and return any output
	my $pkgsub = "${Package}::cmd_prompted";
	my $pollsub = "${Package}::cmd";
	my $self = shift;
	my ($cmd, @feedData, $errmode, $reset_prompt, $pollSyntax);
	my $morePages = $self->{$Package}{morePaging};
	my $progressDots = $self->{$Package}{progressDots};
	my $timeout = $self->{timeout};
	my $blocking = $self->{blocking};
	my $returnRef = $self->{return_reference};
	my $returnRes = $self->{$Package}{return_result};
	my $prompt = $self->{$Package}{prompt_qr};
	my $morePrompt = $self->{$Package}{morePrompt_qr};
	my $morePromptDelay = $self->{$Package}{morePromptDelay_qr};
	my $cmdPrompt = $self->{$Package}{cmd_initiated_prompt_qr};
	if (lc($_[0]) ne 'command' && lc($_[0]) ne 'poll_syntax') { # No command or poll_syntax argument, assume list form
		$cmd = shift;
		@feedData = @_;
	}
	else { # Method invoked with multiple arguments form
		my @validArgs = ('command', 'feed', 'feed_list', 'prompt', 'reset_prompt', 'more_prompt', 'cmd_initiated_prompt', 'more_pages',
				 'timeout', 'errmode', 'return_reference', 'return_result', 'progress_dots', 'blocking', 'poll_syntax');
		my @args = parseMethodArgs($pkgsub, \@_, \@validArgs);
		for (my $i = 0; $i < $#args; $i += 2) {
			$cmd = $args[$i + 1] if $args[$i] eq 'command';
			push @feedData, $args[$i + 1] if $args[$i] eq 'feed';
			push @feedData, @{$args[$i + 1]} if $args[$i] eq 'feed_list' && ref($args[$i + 1]) eq "ARRAY";
			$prompt = $args[$i + 1] if $args[$i] eq 'prompt';
			$morePages = $args[$i + 1] if $args[$i] eq 'more_pages';
			$timeout = $args[$i + 1] if $args[$i] eq 'timeout';
			$blocking = $args[$i + 1] if $args[$i] eq 'blocking';
			$returnRef = $args[$i + 1] if $args[$i] eq 'return_reference';
			$returnRes = $args[$i + 1] if $args[$i] eq 'return_result';
			$reset_prompt = $args[$i + 1] if $args[$i] eq 'reset_prompt';
			($morePrompt, $morePromptDelay) = ($args[$i + 1], undef) if $args[$i] eq 'more_prompt';
			$progressDots = $args[$i + 1] if $args[$i] eq 'progress_dots';
			$cmdPrompt = $args[$i + 1] if $args[$i] eq 'cmd_initiated_prompt';
			$errmode = parse_errmode($pkgsub, $args[$i + 1]) if $args[$i] eq 'errmode';
			$pollSyntax = $args[$i + 1] if $args[$i] eq 'poll_syntax';
		}
	}
	$cmd = '' unless defined $cmd;

	# Initialize the base POLL structure
	$self->poll_struct( # $methodName, $codeRef, $blocking, $timeout, $errmode, $outputType, $outputRequested, $returnReference, $returnList
				$pollsub,
				__PACKAGE__->can('cmd_poll'),
				$blocking,
				$timeout,
				$errmode,
				$returnRes ? 2 : 1,
				$blocking || wantarray, # Always true in blocking mode; if wantarray otherwise
				$returnRef,
				undef,	# n/a
			);
	$self->{POLL}{$pollsub} = { # Populate structure with method arguments/storage
		# Set method argument keys
		command			=>	$cmd,
		prompt			=>	$prompt,
		more_prompt		=>	$morePrompt,
		more_prompt_delay	=>	$morePromptDelay,
		more_pages		=>	$morePages,
		reset_prompt		=>	$reset_prompt && defined $self->{$Package}{PROMPTTYPE},
		yn_prompt		=>	undef,
		cmd_prompt		=>	$cmdPrompt,
		feed_data		=>	\@feedData,
		progress_dots		=>	$progressDots,
		# Declare method storage keys which will be used
		stage			=>	0,
		lastLine		=>	'',
		outputNewline		=>	'',
		progress		=>	undef,
		alreadyCmdTimeout	=>	0,
		ynPromptCount		=>	undef,
		cmdPromptCount		=>	undef,
		cmdEchoRemoved		=>	0,
		lastPromptEchoedCmd	=>	undef,
		cache_timeout		=>	$self->{POLL}{timeout},
	};
	$self->{POLL}{output_requested} = !$pollSyntax || wantarray; # Always true in legacy syntax and in poll_syntax if wantarray
	local $self->{POLLING} = 1; # True until we come out of this polling-capable method
	local $self->{errmode} = $self->{POLL}{errmode} if defined $self->{POLL}{errmode};

	my ($ok, $output) = __PACKAGE__->can('poll_cmd')->($self, $pkgsub); # Do not call a sub-classed version
	# We have a different syntax for scalar output in blocking and non-blocking modes
	if ($pollSyntax) { # New syntax
		return wantarray ? ($ok, $output) : $ok;
	}
	else { # Old syntax
		return wantarray ? ($ok, $output) : $output;
	}
}


sub cmd_poll { # Poll status of cmd (non-blocking mode)
	my $pkgsub = "${Package}::cmd_poll";
	my $self = shift;
	carp "$pkgsub: No arguments expected" if @_; # No arguments expected

	unless (defined $self->{POLL} && $self->{POLL}{coderef} == __PACKAGE__->can('cmd_poll')) {
		return $self->error("$pkgsub: Method cmd() needs to be called first with blocking false");
	}
	$self->{POLL}{output_requested} = wantarray; # This might change at every call
	local $self->{POLLING} = 1; # True until we come out of this polling-capable method
	local $self->{errmode} = $self->{POLL}{errmode} if defined $self->{POLL}{errmode};

	# If already completed (1) or we got an error (undef) from previous call (errmsg is already set) then we go no further
	return $self->poll_return($self->{POLL}{complete}) unless defined $self->{POLL}{complete} && $self->{POLL}{complete} == 0;

	# We get here only if we are not complete: $self->{POLL}{complete} == 0
	return __PACKAGE__->can('poll_cmd')->($self, $pkgsub); # Do not call a sub-classed version
}


sub attribute { # Read attributes for host device
	my $pkgsub = "${Package}::attribute";
	my $self = shift;
	my %args;
	if (@_ == 1) { # Method invoked with just the command argument
		$args{attribute} = shift;
	}
	else {
		my @validArgs = ('attribute', 'reload', 'blocking', 'timeout', 'errmode', 'poll_syntax');
		%args = parseMethodArgs($pkgsub, \@_, \@validArgs);
	}

	# Initialize the base POLL structure
	$self->poll_struct( # $methodName, $codeRef, $blocking, $timeout, $errmode, $outputType, $outputRequested, $returnReference, $returnList
				$pkgsub,
				__PACKAGE__->can('attribute_poll'),
				defined $args{blocking} ? $args{blocking} : $self->{blocking},
				defined $args{timeout} ? $args{timeout} : $self->{timeout},
				defined $args{errmode} ? parse_errmode($pkgsub, $args{errmode}) : undef,
				2,
				undef, # This is set below
				0,
				undef,	# n/a
			);
	$self->{POLL}{$pkgsub} = { # Populate structure with method arguments/storage
		# Set method argument keys
		attribute		=>	$args{attribute},
		reload			=>	$args{reload},
		# Declare method storage keys which will be used
		stage			=>	0,
		debugMsg		=>	0,
	};
	$self->{POLL}{output_requested} = !$args{poll_syntax} || wantarray; # Always true in legacy syntax and in poll_syntax if wantarray
	local $self->{POLLING} = 1; # True until we come out of this polling-capable method
	local $self->{errmode} = $self->{POLL}{errmode} if defined $self->{POLL}{errmode};

	my ($ok, $attribute) = __PACKAGE__->can('poll_attribute')->($self, $pkgsub); # Do not call a sub-classed version
	# We have a different syntax for scalar output in blocking and non-blocking modes
	if ($args{poll_syntax}) { # New syntax
		return wantarray ? ($ok, $attribute) : $ok;
	}
	else { # Old syntax
		return wantarray ? ($ok, $attribute) : $attribute;
	}
}


sub attribute_poll { # Poll status of attribute (non-blocking mode)
	my $pkgsub = "${Package}::attribute_poll";
	my $self = shift;
	carp "$pkgsub: No arguments expected" if @_; # No arguments expected

	unless (defined $self->{POLL} && $self->{POLL}{coderef} == __PACKAGE__->can('attribute_poll')) {
		return $self->error("$pkgsub: Method attribute() needs to be called first with blocking false");
	}
	$self->{POLL}{output_requested} = wantarray; # This might change at every call
	local $self->{POLLING} = 1; # True until we come out of this polling-capable method
	local $self->{errmode} = $self->{POLL}{errmode} if defined $self->{POLL}{errmode};

	# If already completed (1) or we got an error (undef) from previous call (errmsg is already set) then we go no further
	return $self->poll_return($self->{POLL}{complete}) unless defined $self->{POLL}{complete} && $self->{POLL}{complete} == 0;

	# We get here only if we are not complete: $self->{POLL}{complete} == 0
	return __PACKAGE__->can('poll_attribute')->($self, $pkgsub); # Do not call a sub-classed version
}


sub change_baudrate { # Change baud rate on device and on current connection, if serial
	my $pkgsub = "${Package}::change_baudrate";
	my $self = shift;
	my (%args);
	if (@_ == 1) { # Method invoked with just the command argument
		$args{baudrate} = shift;
	}
	else {
		my @validArgs = ('baudrate', 'parity', 'databits', 'stopbits', 'handshake', 'forcebaud',
				 'timeout', 'errmode', 'local_side_only', 'blocking', 'poll_syntax');
		%args = parseMethodArgs($pkgsub, \@_, \@validArgs);
	}

	# Initialize the base POLL structure
	$self->poll_struct( # $methodName, $codeRef, $blocking, $timeout, $errmode, $outputType, $outputRequested, $returnReference, $returnList
				$pkgsub,
				__PACKAGE__->can('change_baudrate_poll'),
				defined $args{blocking} ? $args{blocking} : $self->{blocking},
				defined $args{timeout} ? $args{timeout} : $self->{timeout},
				defined $args{errmode} ? parse_errmode($pkgsub, $args{errmode}) : undef,
				2,
				undef, # This is set below
				0,
				undef,	# n/a
			);
	$self->{POLL}{$pkgsub} = { # Populate structure with method arguments/storage
		# Set method argument keys
		baudrate		=>	$args{baudrate},
		parity			=>	$args{parity},
		databits		=>	$args{databits},
		stopbits		=>	$args{stopbits},
		handshake		=>	$args{handshake},
		forcebaud		=>	$args{forcebaud},
		local_side_only		=>	$args{local_side_only},
		# Declare method storage keys which will be used
		stage			=>	0,
		userExec		=>	undef,
		privExec		=>	undef,
		maxMode			=>	$args{baudrate} eq 'max' ? 1:0,
	};
	$self->{POLL}{output_requested} = !$args{poll_syntax} || wantarray; # Always true in legacy syntax and in poll_syntax if wantarray
	local $self->{POLLING} = 1; # True until we come out of this polling-capable method
	local $self->{errmode} = $self->{POLL}{errmode} if defined $self->{POLL}{errmode};

	my ($ok, $baudrate) = __PACKAGE__->can('poll_change_baudrate')->($self, $pkgsub); # Do not call a sub-classed version
	# We have a different syntax for scalar output in blocking and non-blocking modes
	if ($args{poll_syntax}) { # New syntax
		return wantarray ? ($ok, $baudrate) : $ok;
	}
	else { # Old syntax
		return wantarray ? ($ok, $baudrate) : $baudrate;
	}
}


sub change_baudrate_poll { # Poll status of change_baudrate (non-blocking mode)
	my $pkgsub = "${Package}::change_baudrate_poll";
	my $self = shift;
	carp "$pkgsub: No arguments expected" if @_; # No arguments expected

	unless (defined $self->{POLL} && $self->{POLL}{coderef} == __PACKAGE__->can('change_baudrate_poll')) {
		return $self->error("$pkgsub: Method change_baudrate() needs to be called first with blocking false");
	}
	$self->{POLL}{output_requested} = wantarray; # This might change at every call
	local $self->{POLLING} = 1; # True until we come out of this polling-capable method
	local $self->{errmode} = $self->{POLL}{errmode} if defined $self->{POLL}{errmode};

	# If already completed (1) or we got an error (undef) from previous call (errmsg is already set) then we go no further
	return $self->poll_return($self->{POLL}{complete}) unless defined $self->{POLL}{complete} && $self->{POLL}{complete} == 0;

	# We get here only if we are not complete: $self->{POLL}{complete} == 0
	return __PACKAGE__->can('poll_change_baudrate')->($self, $pkgsub); # Do not call a sub-classed version
}


sub enable { # Enter PrivExec mode (handle enable password for WLAN2300)
	my $pkgsub = "${Package}::enable";
	my $self = shift;
	my %args;
	if (@_ == 1) { # Method invoked with just the command argument
		$args{password} = shift;
	}
	else {
		my @validArgs = ('password', 'prompt_credentials', 'timeout', 'errmode', 'blocking');
		%args = parseMethodArgs($pkgsub, \@_, \@validArgs);
	}

	# Initialize the base POLL structure
	$self->poll_struct( # $methodName, $codeRef, $blocking, $timeout, $errmode, $outputType, $outputRequested, $returnReference, $returnList
				$pkgsub,
				__PACKAGE__->can('enable_poll'),
				defined $args{blocking} ? $args{blocking} : $self->{blocking},
				defined $args{timeout} ? $args{timeout} : $self->{timeout},
				defined $args{errmode} ? parse_errmode($pkgsub, $args{errmode}) : undef,
				0,	# no output
				0,	# no output
				undef,	# n/a
				undef,	# n/a
			);
	$self->{POLL}{$pkgsub} = { # Populate structure with method arguments/storage
		# Set method argument keys
		enable_password		=>	defined $args{password} ? $args{password} : $self->{$Package}{ENABLEPWD},
		prompt_credentials	=>	defined $args{prompt_credentials} ? $args{prompt_credentials} : $self->{prompt_credentials},
		# Declare method storage keys which will be used
		stage			=>	0,
		login_attempted		=>	undef,
		password_sent		=>	undef,
		login_failed		=>	undef,
	};
	local $self->{POLLING} = 1; # True until we come out of this polling-capable method
	local $self->{errmode} = $self->{POLL}{errmode} if defined $self->{POLL}{errmode};
	return __PACKAGE__->can('poll_enable')->($self, $pkgsub); # Do not call a sub-classed version
}


sub enable_poll { # Poll status of enable (non-blocking mode)
	my $pkgsub = "${Package}::enable_poll";
	my $self = shift;
	carp "$pkgsub: No arguments expected" if @_; # No arguments expected

	unless (defined $self->{POLL} && $self->{POLL}{coderef} == __PACKAGE__->can('enable_poll')) {
		return $self->error("$pkgsub: Method enable() needs to be called first with blocking false");
	}
	local $self->{POLLING} = 1; # True until we come out of this polling-capable method
	local $self->{errmode} = $self->{POLL}{errmode} if defined $self->{POLL}{errmode};

	# If already completed (1) or we got an error (undef) from previous call (errmsg is already set) then we go no further
	return $self->poll_return($self->{POLL}{complete}) unless defined $self->{POLL}{complete} && $self->{POLL}{complete} == 0;

	# We get here only if we are not complete: $self->{POLL}{complete} == 0
	return __PACKAGE__->can('poll_enable')->($self, $pkgsub); # Do not call a sub-classed version
}


sub device_more_paging { # Enable/Disable more paging on host device
	my $pkgsub = "${Package}::device_more_paging";
	my $self = shift;
	my (%args, $familyType);
	if (@_ == 1) { # Method invoked with just the command argument
		$args{enable} = shift;
	}
	else {
		my @validArgs = ('enable', 'timeout', 'errmode', 'blocking');
		%args = parseMethodArgs($pkgsub, \@_, \@validArgs);
	}

	# Initialize the base POLL structure
	$self->poll_struct( # $methodName, $codeRef, $blocking, $timeout, $errmode, $outputType, $outputRequested, $returnReference, $returnList
				$pkgsub,
				__PACKAGE__->can('device_more_paging_poll'),
				defined $args{blocking} ? $args{blocking} : $self->{blocking},
				defined $args{timeout} ? $args{timeout} : $self->{timeout},
				defined $args{errmode} ? parse_errmode($pkgsub, $args{errmode}) : undef,
				0,	# no output
				0,	# no output
				undef,	# n/a
				undef,	# n/a
			);
	$self->{POLL}{$pkgsub} = { # Populate structure with method arguments/storage
		# Set method argument keys
		enable			=>	$args{enable},
		# Declare method storage keys which will be used
		stage			=>	0,
		cmdString		=>	undef,
	};
	local $self->{POLLING} = 1; # True until we come out of this polling-capable method
	local $self->{errmode} = $self->{POLL}{errmode} if defined $self->{POLL}{errmode};
	return __PACKAGE__->can('poll_device_more_paging')->($self, $pkgsub); # Do not call a sub-classed version
}


sub device_more_paging_poll { # Poll status of device_more_paging (non-blocking mode)
	my $pkgsub = "${Package}::device_more_paging_poll";
	my $self = shift;
	carp "$pkgsub: No arguments expected" if @_; # No arguments expected

	unless (defined $self->{POLL} && $self->{POLL}{coderef} == __PACKAGE__->can('device_more_paging_poll')) {
		return $self->error("$pkgsub: Method device_more_paging() needs to be called first with blocking false");
	}
	local $self->{POLLING} = 1; # True until we come out of this polling-capable method
	local $self->{errmode} = $self->{POLL}{errmode} if defined $self->{POLL}{errmode};

	# If already completed (1) or we got an error (undef) from previous call (errmsg is already set) then we go no further
	return $self->poll_return($self->{POLL}{complete}) unless defined $self->{POLL}{complete} && $self->{POLL}{complete} == 0;

	# We get here only if we are not complete: $self->{POLL}{complete} == 0
	return __PACKAGE__->can('poll_device_more_paging')->($self, $pkgsub); # Do not call a sub-classed version
}


sub device_peer_cpu { # Connect to peer CPU on ERS8x00 / VSP9000
	my $pkgsub = "${Package}::device_peer_cpu";
	my $self = shift;
	my $familyType;
	my @validArgs = ('username', 'password', 'prompt_credentials', 'timeout', 'errmode', 'blocking');
	my %args = parseMethodArgs($pkgsub, \@_, \@validArgs);

	# Initialize the base POLL structure
	$self->poll_struct( # $methodName, $codeRef, $blocking, $timeout, $errmode, $outputType, $outputRequested, $returnReference, $returnList
				$pkgsub,
				__PACKAGE__->can('device_peer_cpu_poll'),
				defined $args{blocking} ? $args{blocking} : $self->{blocking},
				defined $args{timeout} ? $args{timeout} : $self->{timeout},
				defined $args{errmode} ? parse_errmode($pkgsub, $args{errmode}) : undef,
				0,	# no output
				0,	# no output
				undef,	# n/a
				undef,	# n/a
			);
	$self->{POLL}{$pkgsub} = { # Populate structure with method arguments/storage
		# Set method argument keys
		username		=>	defined $args{username} ? $args{username} : $self->username,
		password		=>	defined $args{password} ? $args{password} : $self->password,
		prompt_credentials	=>	defined $args{prompt_credentials} ? $args{prompt_credentials} : $self->{prompt_credentials},
		# Declare method storage keys which will be used
		stage			=>	0,
	};
	local $self->{POLLING} = 1; # True until we come out of this polling-capable method
	local $self->{errmode} = $self->{POLL}{errmode} if defined $self->{POLL}{errmode};
	return __PACKAGE__->can('poll_device_peer_cpu')->($self, $pkgsub); # Do not call a sub-classed version
}


sub device_peer_cpu_poll { # Poll status of device_peer_cpu (non-blocking mode)
	my $pkgsub = "${Package}::device_peer_cpu_poll";
	my $self = shift;
	carp "$pkgsub: No arguments expected" if @_; # No arguments expected

	unless (defined $self->{POLL} && $self->{POLL}{coderef} == __PACKAGE__->can('device_peer_cpu_poll')) {
		return $self->error("$pkgsub: Method device_peer_cpu() needs to be called first with blocking false");
	}
	local $self->{POLLING} = 1; # True until we come out of this polling-capable method
	local $self->{errmode} = $self->{POLL}{errmode} if defined $self->{POLL}{errmode};

	# If already completed (1) or we got an error (undef) from previous call (errmsg is already set) then we go no further
	return $self->poll_return($self->{POLL}{complete}) unless defined $self->{POLL}{complete} && $self->{POLL}{complete} == 0;

	# We get here only if we are not complete: $self->{POLL}{complete} == 0
	return __PACKAGE__->can('poll_device_peer_cpu')->($self, $pkgsub); # Do not call a sub-classed version
}


sub debug_file { # Set debug output file
	my ($self, $fh) = @_;
	my $pkgsub = "${Package}::debug_file";

	unless (defined $fh) { # No input = return current filehandle
		return $self->{$Package}{DEBUGLOGFH};
	}
	unless (ref $fh or length $fh) { # Empty input = stop logging
		$self->{$Package}{DEBUGLOGFH} = undef;
		return;
	}
	if (!ref($fh) && !defined(fileno $fh)) { # Open a new filehandle if input is a filename
		my $logfile = $fh;
		$fh = IO::Handle->new;
		open($fh, '>', "$logfile") or return $self->error("$pkgsub: Unable to open output log file: $!");
	}
	$fh->autoflush();
	$self->{$Package}{DEBUGLOGFH} = $fh;
	return $fh;
}


#################################### Methods to set/read Object variables ####################################

sub flush_credentials { # Clear the stored username, password, passphrases, and enable password, if any
	my $self = shift;
	$self->SUPER::flush_credentials;
	$self->{$Package}{ENABLEPWD} = undef;
	return 1;
}


sub prompt { # Read/Set object prompt
	my ($self, $newSetting) = @_;
	my $currentSetting = $self->{$Package}{prompt};
	if (defined $newSetting) {
		$self->debugMsg(4, "\nPrompt Regex set to:\n$newSetting\n");
		$self->{$Package}{prompt} = $newSetting;
		$self->{$Package}{prompt_qr} = qr/$newSetting/;
	}
	return $currentSetting;
}


sub more_prompt { # Read/Set object more prompt
	my ($self, $newSetting, $delayPrompt) = @_;
	my $currentSetting = $self->{$Package}{morePrompt};
	if (defined $newSetting) {
		$newSetting =~ s/([\(\)\.])/\\$1/g;
		$self->debugMsg(4, "More Prompt Regex set to:\n$newSetting\n");
		$self->{$Package}{morePrompt} = $newSetting;
		$self->{$Package}{morePrompt_qr} = $newSetting ? qr/$newSetting/ : undef;
		$self->{$Package}{morePromptDelay_qr} = $delayPrompt ? qr/$delayPrompt/ : undef;
	}
	return $currentSetting;
}


sub more_paging { # Set the number of pages to read in the resence of --more-- prompts from host
	my ($self, $newSetting) = @_;
	my $currentSetting = $self->{$Package}{morePaging};
	$self->{$Package}{morePaging} = $newSetting if defined $newSetting;
	return $currentSetting;
}


sub progress_dots { # Enable/disable activity dots
	my ($self, $newSetting) = @_;
	my $currentSetting = $self->{$Package}{progressDots};
	$self->{$Package}{progressDots} = $newSetting if defined $newSetting;
	return $currentSetting;
}


sub return_result { # Set/read return_result mode
	my ($self, $newSetting) = @_;
	my $currentSetting = $self->{$Package}{return_result};
	$self->{$Package}{return_result} = $newSetting if defined $newSetting;
	return $currentSetting;
}


sub cmd_confirm_prompt { # Read/Set object cmd_confirm_prompt prompt
	my ($self, $newSetting) = @_;
	my $currentSetting = $self->{$Package}{cmd_confirm_prompt};
	if (defined $newSetting) {
		$self->{$Package}{cmd_confirm_prompt} = $newSetting;
		$self->{$Package}{cmd_confirm_prompt_qr} = qr/$newSetting/;
	}
	return $currentSetting;
}


sub cmd_initiated_prompt { # Read/Set object cmd_initiated_prompt prompt
	my ($self, $newSetting) = @_;
	my $currentSetting = $self->{$Package}{cmd_initiated_prompt};
	if (defined $newSetting) {
		$self->{$Package}{cmd_initiated_prompt} = $newSetting;
		$self->{$Package}{cmd_initiated_prompt_qr} = qr/$newSetting/;
	}
	return $currentSetting;
}


sub cmd_feed_timeout { # Read/Set object value of cmd_feed_timeout
	my ($self, $newSetting) = @_;
	my $currentSetting = $self->{$Package}{cmd_feed_timeout};
	$self->{$Package}{cmd_feed_timeout} = $newSetting if defined $newSetting;
	return $currentSetting;
}


sub console { # Read/Set value of console
	my ($self, $newSetting) = @_;
	my $currentSetting = $self->{$Package}{console};
	$self->{$Package}{console} = $newSetting if defined $newSetting;
	return $currentSetting;
}


sub wake_console { # Read/Set object value of wake_console
	my ($self, $newSetting) = @_;
	my $currentSetting = $self->{$Package}{wake_console};
	$self->{$Package}{wake_console} = $newSetting if defined $newSetting;
	return $currentSetting;
}


sub last_cmd_success { # Return the result of the last command sent via cmd methods
	my ($self, $newSetting) = @_;
	my $currentSetting = $self->{$Package}{last_cmd_success};
	$self->{$Package}{last_cmd_success} = $newSetting if defined $newSetting;
	return $currentSetting;
}


sub last_cmd_errmsg { # Set/read the last generated error message from host
	my ($self, $newSetting) = @_;
	my $currentSetting = $self->{$Package}{last_cmd_errmsg};
	$self->{$Package}{last_cmd_errmsg} = $newSetting if defined $newSetting;
	return $currentSetting;
}


################################# Methods to read read-only Object variables #################################

sub config_context { # Return the configuration context contained in the last prompt
	my $self = shift;
	return $self->{$Package}{CONFIGCONTEXT};
}


sub enable_password { # Read the enable password (WLAN2300)
	my $self = shift;
	return $self->{$Package}{ENABLEPWD};
}


#################################### Private poll methods for sub classes ####################################

sub poll_connect { # Internal method to connect to host and perform login (used for both blocking & non-blocking modes)
	my $self = shift;
	my $pkgsub = shift;
	my $pollsub = "${Package}::connect";

	unless ($self->{POLLING}) { # Sanity check
		my (undef, $fileName, $lineNumber) = caller;
		croak "$pollsub (called from $fileName line $lineNumber) can only be used within polled methods";
	}

	unless (defined $self->{POLL}{$pollsub}) { # Only applicable if called from another method already in polling mode
		my @validArgs = ('host', 'port', 'username', 'password', 'publickey', 'privatekey', 'passphrase',
				 'prompt_credentials', 'baudrate', 'parity', 'databits', 'stopbits', 'handshake',
				 'errmode', 'connection_timeout', 'login_timeout', 'read_attempts', 'wake_console',
				 'data_with_error', 'terminal_type', 'window_size', 'callback', 'forcebaud',
				 'atomic_connect');
		my %args = parseMethodArgs($pkgsub, \@_, \@validArgs, 1);
		if (@_ && !%args) { # Legacy syntax
			($args{host}, $args{port}, $args{username}, $args{password}, $args{publickey}, $args{privatekey},
			 $args{passphrase}, $args{baudrate}, $args{parity}, $args{databits}, $args{stopbits},
			 $args{handshake}, $args{prompt_credentials}, $args{read_attempts}, $args{wake_console},
			 $args{connection_timeout}, $args{login_timeout}, $args{errmode}) = @_;
		}
		# In which case we need to setup the poll structure for them here (the main poll structure remains unchanged)
		$self->{POLL}{$pollsub} = { # Populate structure with method arguments/storage
			# Set method argument keys
			host			=>	$args{host},
			port			=>	$args{port},
			username		=>	defined $args{username} ? $args{username} : $self->{USERNAME},
			password		=>	defined $args{password} ? $args{password} : $self->{PASSWORD},
			publickey		=>	$args{publickey},
			privatekey		=>	$args{privatekey},
			passphrase		=>	defined $args{passphrase} ? $args{passphrase} : $self->{PASSPHRASE},
			baudrate		=>	$args{baudrate},
			parity			=>	$args{parity},
			databits		=>	$args{databits},
			stopbits		=>	$args{stopbits},
			handshake		=>	$args{handshake},
			prompt_credentials	=>	defined $args{prompt_credentials} ? $args{prompt_credentials} : $self->{prompt_credentials},
			terminal_type		=>	$args{terminal_type},
			window_size		=>	$args{window_size},
			callback		=>	$args{callback},
			forcebaud		=>	$args{forcebaud},
			atomic_connect		=>	$args{atomic_connect},
			login_timeout		=>	defined $args{login_timeout} ? $args{login_timeout} : $self->{timeout},
			read_attempts		=>	defined $args{read_attempts} ? $args{read_attempts} : $LoginReadAttempts,
			data_with_error		=>	defined $args{data_with_error} ? $args{data_with_error} : $self->{data_with_error},
			wake_console		=>	defined $args{wake_console} ? $args{wake_console} : $self->{$Package}{wake_console},
			# Declare method storage keys which will be used
			stage			=>	$self->{LOGINSTAGE} ? 1 : 0,
			# Declare keys to be set if method called from another polled method
			errmode			=>	$args{errmode},
		};
		# Cache poll structure keys which this method will use
		$self->poll_struct_cache($pollsub, $args{connection_timeout});
	}
	my $connect = $self->{POLL}{$pollsub};
	local $self->{errmode} = $connect->{errmode} if defined $connect->{errmode};

	if ($connect->{stage} < 1) { # Connect stage
		my $ok = $self->SUPER::poll_connect($pkgsub,
			Host			=> $connect->{host},
			Port			=> $connect->{port},
			Username		=> $connect->{username},
			Password		=> $connect->{password},
			PublicKey		=> $connect->{publickey},
			PrivateKey		=> $connect->{privatekey},
			Passphrase		=> $connect->{passphrase},
			BaudRate		=> $connect->{baudrate},
			ForceBaud		=> $connect->{forcebaud},
			Parity			=> $connect->{parity},
			DataBits		=> $connect->{databits},
			StopBits		=> $connect->{stopbits},
			Handshake		=> $connect->{handshake},
			Prompt_credentials	=> $connect->{prompt_credentials},
			Terminal_type		=> $connect->{terminal_type},
			Window_size		=> $connect->{window_size},
			Callback		=> $connect->{callback},
			Atomic_connect		=> $connect->{atomic_connect},
		);
		return $self->poll_return($ok) unless $ok; # Come out if error (if errmode='return'), or if nothing to read in non-blocking mode
		# Unless console already set, set it now; will determine whether or not wake_console is sent upon login
		$self->console(	 $self->connection_type eq 'SERIAL' ||
				($self->connection_type eq 'TELNET' && $self->port != 23) ||
				($self->connection_type eq 'SSH'    && $self->port != 22) ) unless defined $self->console;
		$connect->{stage}++; # Ensure we don't come back here in non-blocking mode
	}

	# Login stage
	my ($ok, $outRef) = $self->poll_login($pkgsub,
			Username		=> $connect->{username},
			Password		=> $connect->{password},
			Read_attempts		=> $connect->{read_attempts},
			Wake_console		=> $connect->{wake_console},
			Prompt_credentials	=> $connect->{prompt_credentials},
			Data_with_error		=> $connect->{data_with_error},
			Timeout			=> $connect->{login_timeout},
	);
	$self->{POLL}{output_buffer} = $$outRef if $ok;
	return $self->poll_return($ok);
}


sub poll_login { # Method to handle login for poll methods (used for both blocking & non-blocking modes)
	my $self = shift;
	my $pkgsub = shift;
	my $pollsub = "${Package}::login";

	unless ($self->{POLLING}) { # Sanity check
		my (undef, $fileName, $lineNumber) = caller;
		croak "$pollsub (called from $fileName line $lineNumber) can only be used within polled methods";
	}

	unless (defined $self->{POLL}{$pollsub}) { # Only applicable if called from another method already in polling mode
		my @validArgs = ('username', 'password', 'prompt_credentials', 'timeout', 'errmode', 'read_attempts', 'wake_console', 'data_with_error');
		my %args = parseMethodArgs($pkgsub, \@_, \@validArgs, 1);
		if (@_ && !%args) { # Legacy syntax
			($args{username}, $args{password}, $args{read_attempts}, $args{wake_console},
			 $args{prompt_credentials}, $args{data_with_error}, $args{timeout}, $args{errmode}) = @_;
		}
		# In which case we need to setup the poll structure for them here (the main poll structure remains unchanged)
		$self->{POLL}{$pollsub} = { # Populate structure with method arguments/storage
			# Set method argument keys
			username		=>	defined $args{username} ? $args{username} : $self->{USERNAME},
			password		=>	defined $args{password} ? $args{password} : $self->{PASSWORD},
			read_attempts		=>	defined $args{read_attempts} ? $args{read_attempts} : $LoginReadAttempts,
			data_with_error		=>	defined $args{data_with_error} ? $args{data_with_error} : $self->{data_with_error},
			wake_console		=>	defined $args{wake_console} ? $args{wake_console} : $self->{$Package}{wake_console},
			prompt_credentials	=>	defined $args{prompt_credentials} ? $args{prompt_credentials} : $self->{prompt_credentials},
			# Declare method storage keys which will be used
			stage			=>	0,
			login_attempted		=>	undef,
			password_sent		=>	undef,
			login_error		=>	'',
			family_type		=>	undef,
			cpu_slot		=>	undef,
			detectionFromPrompt	=>	undef,
			# Declare keys to be set if method called from another polled method
			errmode			=>	$args{errmode},
		};
		# Cache poll structure keys which this method will use
		$self->poll_struct_cache($pollsub, $args{timeout});
	}
	my $login = $self->{POLL}{$pollsub};
	local $self->{errmode} = $login->{errmode} if defined $login->{errmode};
	return $self->poll_return($self->error("$pkgsub: No connection to login to")) if $self->eof;

	my $usernamePrompt = $self->username_prompt;
	my $passwordPrompt = $self->password_prompt;

	if ($login->{stage} < 1) { # Initial loginstage & setup - do only once
		$login->{stage}++; # Ensure we don't come back here in non-blocking mode
		if ($self->{LOGINSTAGE}) {
			$login->{family_type} = $self->{$Package}{ATTRIB}{'family_type'}; # Might be already set from previous login attempt
		}
		else {	# Flush all attributes, as we assume we are connecting to a new device
			$self->{$Package}{ATTRIB} = undef;
			$self->{$Package}{ATTRIBFLAG} = undef;
		}
		# Handle resuming previous login attempt
		if ($self->{LOGINSTAGE} eq 'username' && $login->{username}) { # Resume login from where it was left
			$self->print(line => $login->{username}, errmode => 'return')
				or return $self->poll_return($self->error("$pkgsub: Unable to send username // ".$self->errmsg));
			$self->{LOGINSTAGE} = '';
			$login->{login_attempted} = 1;
		}
		elsif ($self->{LOGINSTAGE} eq 'password' && $login->{password}) { # Resume login from where it was left
			$self->print(line => $login->{password}, errmode => 'return')
				or return $self->poll_return($self->error("$pkgsub: Unable to send password // ".$self->errmsg));
			$self->{LOGINSTAGE} = '';
			$login->{login_attempted} = 1;
		}
		elsif ($self->console && $login->{wake_console}) {
			$self->debugMsg(8,"\nlogin() Sending wake_console sequence >$login->{wake_console}<\n");
			$self->put(string => $login->{wake_console}, errmode => 'return') # Bring connection into life
				or return $self->poll_return($self->error("$pkgsub: Unable to send bring alive character sequence // ".$self->errmsg));
		}
	}
	if ($login->{stage} < 2) { # Main login loop
		my ($pattern, $patdepth, $deepest);
		my ($promptType, $capturedPrompt, $switchName, $cliType, $configContext);
		LOGINLOOP: while (1) {
			# Wait until we have read in all available data
			my $ok = $self->poll_readwait($pkgsub, 1, $login->{read_attempts}, $ReadwaitTimer, $login->{login_error}.'Failed reading login prompt', $login->{data_with_error});
			return $self->poll_return($ok) unless $ok; # Come out if error (if errmode='return'), or if nothing to read in non-blocking mode

			$self->debugMsg(8,"\nlogin() Connection input to process:\n>", \$self->{POLL}{read_buffer}, "<\n");
			$self->{POLL}{output_buffer} .= $self->{POLL}{read_buffer}; # This buffer preserves all the output, in case it is requested
			$self->{POLL}{local_buffer} = $self->{POLL}{read_buffer} =~ /\n/ ? '' : stripLastLine(\$self->{POLL}{local_buffer}); # Flush or keep lastline
			$self->{POLL}{local_buffer} .= $self->{POLL}{read_buffer};  # If read was single line, this buffer appends it to lastline from previous read

			# Pattern matching; try and detect patterns, and record their depth in the input stream
			$pattern = '';
			$deepest = -1;
			foreach my $key (keys %LoginPatterns) {
				if (($patdepth = rindex($self->{POLL}{read_buffer}, $LoginPatterns{$key})) >= 0) { # We have a match
					$self->debugMsg(8,"\nlogin() Matched pattern $key @ depth $patdepth\n");
					unless ($login->{family_type}) { # Only if family type not already detected
						# If a banner is seen, try and extract attributes from it also
						if ($key eq 'banner' || $key eq 'menu' || $key eq 'submenu') {
							$login->{family_type} = $Prm{bstk};
							$self->debugMsg(8,"login() Detected family_type = $login->{family_type}\n");
							$self->_setAttrib('family_type', $login->{family_type});
							$self->_setAttrib('is_nncli', 1);
							if ($key eq 'banner') {
								$self->{POLL}{read_buffer} =~ /\*\*\* ((?:[^\*\n]+?) (?:Switch|Controller|Platform) (?:WC)?\d+.*?)\s+/ &&
									$self->_setModelAttrib($1);
								$self->{POLL}{read_buffer} =~ /FW:([\d\.]+)\s+SW:v([\d\.]+)/ && do {
									$self->_setAttrib('fw_version', $1);
									$self->_setAttrib('sw_version', $2);
								};
							}
						}
						elsif ($key eq 'srbanner') {
							$login->{family_type} = $Prm{sr};
							$self->debugMsg(8,"login() Detected family_type = $login->{family_type}\n");
							$self->_setAttrib('family_type', $login->{family_type});
							$self->_setAttrib('is_nncli', 1);
							$self->{POLL}{read_buffer} =~ /\((Secure Router \d+)\)/ && $self->_setModelAttrib($1);
							$self->{POLL}{read_buffer} =~ /Version: (.+)/ && $self->_setAttrib('sw_version', $1);
						}
						elsif ($key eq 'xlrbanner') {
							$login->{family_type} = $Prm{xlr};
							$self->debugMsg(8,"login() Detected family_type = $login->{family_type}\n");
							$self->_setAttrib('family_type', $login->{family_type});
							$self->_setAttrib('is_nncli', 0);
							$self->{POLL}{read_buffer} =~ /\* Software Release (?i:v|REL)?(.+?) / && $self->_setAttrib('sw_version', $1);
						}
						elsif ($key eq 'ersbanner' || $key eq 'passportbanner' || $key eq 'pp1600banner') {
							$login->{family_type} = $Prm{pers};
							$self->debugMsg(8,"login() Detected family_type = $login->{family_type}\n");
							$self->_setAttrib('family_type', $login->{family_type});
							$self->_setAttrib('is_nncli', 0);
							$self->{POLL}{read_buffer} =~ /\* Software Release (?i:v|REL)?(.+?) / && $self->_setAttrib('sw_version', $1);
						}
						elsif ($key eq 'vspbanner') {
							$login->{family_type} = $Prm{pers};
							$self->debugMsg(8,"login() Detected family_type = $login->{family_type}\n");
							$self->_setAttrib('family_type', $login->{family_type});
							$self->_setAttrib('is_nncli', 1);
							$self->{POLL}{read_buffer} =~ /Software Release Build (.+?) / && $self->_setAttrib('sw_version', $1);
						}
						elsif ($key eq 'wlan9100banner') {
							$login->{family_type} = $Prm{xirrus};
							$self->debugMsg(8,"login() Detected family_type = $login->{family_type}\n");
							$self->_setAttrib('family_type', $login->{family_type});
							$self->_setAttrib('is_nncli', 1);
							$self->{POLL}{read_buffer} =~ /AvayaOS Version (.+?) / && $self->_setAttrib('sw_version', $1);
						}
					}
					if ($patdepth > $deepest) { # We have a deeper match, we keep it
						($pattern, $deepest) = ($key, $patdepth);
					}
				}
			}
			$self->debugMsg(8,"\nlogin() Retaining pattern: $pattern\n") if $deepest > -1;

			# Now try and match other prompts expected to be seen at the very end of received input stream
			if ($self->{POLL}{read_buffer} =~ /$usernamePrompt/) { # Handle Modular login prompt
				$self->debugMsg(8,"\nlogin() Matched Login prompt\n\n");
				$pattern = 'username';
			}
			elsif ($self->{POLL}{read_buffer} =~ /$passwordPrompt/) { # Handle Modular password prompt
				$self->debugMsg(8,"\nlogin() Matched Password prompt\n\n");
				$pattern = 'password';
			}

			# Now handle any pattern matches we had above
			if ($pattern eq 'banner' || $pattern eq 'bell') { # We got the banner, send a CTRL-Y to get in
				$self->debugMsg(8,"\nlogin() Processing Stackable Banner\n\n");
				$self->put(string => $CTRL_Y, errmode => 'return')
					or return $self->poll_return($self->error("$pkgsub: Unable to send CTRL-Y sequence // ".$self->errmsg));
				next;
			}
			elsif ($pattern eq 'menu') { # We got the menu, send a 'c' and get into CLI
				$self->debugMsg(8,"\nlogin() Processing Stackable Menu\n\n");
				$self->put(string => 'c', errmode => 'return')
					or return $self->poll_return($self->error("$pkgsub: Unable to select 'Command Line Interface...' // ".$self->errmsg));
				next;
			}
			elsif ($pattern eq 'submenu') { # We are in a sub-menu page, send a 'CTRL_C' to get to main menu page
				$self->debugMsg(8,"\nlogin() Processing Stackable Sub-Menu page\n\n");
				$self->put(string => $CTRL_C, errmode => 'return')
					or return $self->poll_return($self->error("$pkgsub: Unable to go back to main menu page // ".$self->errmsg));
				next;
			}
			elsif ($pattern =~ /^more\d$/) { # We are connecting on the console port, and we are in the midst of more-paged output
				$self->debugMsg(8,"\nlogin() Quitting residual more-paged output for serial port access\n");
				$self->put(string => 'q', errmode => 'return')
					or return $self->poll_return($self->error("$pkgsub: Unable to quit more-paged output found after serial connect // ".$self->errmsg));
				next;
			}
			elsif ($pattern =~ /^consoleLogMsg\d$/) { # We are connecting on the console port, and this log message is spoiling our 1st prompt
				$self->debugMsg(8,"\nlogin() Sending extra carriage return after password for serial port access\n");
				# On Modular VSPs Console port, immediately after login you get log message :SW INFO user rwa connected via console port
				# As this message is appended to the very 1st prompt, we are not able to lock on that initial prompt
				# So we feed an extra carriage return so that we can lock on a fresh new prompt
				$self->print(errmode => 'return')
					or return $self->poll_return($self->error("$pkgsub: Unable to get new prompt after console log message // ".$self->errmsg));
				next;
			}
			elsif ($pattern eq 'lastlogin') { # Last login splash screen; skip it with RETURN key
				# This screen appears on ERS4800 release 5.8
				$self->debugMsg(8,"\nlogin() Processing Last Login screen\n\n");
				$self->print(errmode => 'return')
					or return $self->poll_return($self->error("$pkgsub: Unable to send Carriage Return // ".$self->errmsg));
				next;
			}
			elsif ($pattern eq 'username') { # Handle login prompt
				$self->debugMsg(8,"\nlogin() Processing Login/Username prompt\n\n");
				if ($login->{login_attempted}) {
					$self->{LOGINSTAGE} = 'username';
					return $self->poll_return($self->error("$pkgsub: Incorrect Username or Password"));
				}
				unless ($login->{username}) {
					if ($self->{TYPE} eq 'SSH') { # If an SSH connection, we already have the username
						$login->{username} = $self->{USERNAME};
					}
					else {
						unless ($login->{prompt_credentials}) {
							$self->{LOGINSTAGE} = 'username';
							return $self->poll_return($self->error("$pkgsub: Username required"));
						}
						$login->{username} = promptCredential($login->{prompt_credentials}, 'Clear', 'Username');
					}
				}
				$self->print(line => $login->{username}, errmode => 'return')
					or return $self->poll_return($self->error("$pkgsub: Unable to send username // ".$self->errmsg));
				$self->{LOGINSTAGE} = '';
				$login->{login_attempted} = 1;
				next;
			}
			elsif ($pattern eq 'password') { # Handle password prompt
				$self->debugMsg(8,"\nlogin() Processing Password prompt\n\n");
				if ($login->{password_sent}) {
					$self->{LOGINSTAGE} = 'password';
					return $self->poll_return($self->error("$pkgsub: Incorrect Username or Password"));
				}
				unless ($login->{password}) {
					unless ($login->{prompt_credentials}) {
						$self->{LOGINSTAGE} = 'password';
						return $self->poll_return($self->error("$pkgsub: Password required"));
					}
					$login->{password} = promptCredential($login->{prompt_credentials}, 'Hide', 'Password');
				}
				$self->print(line => $login->{password}, errmode => 'return')
					or return $self->poll_return($self->error("$pkgsub: Unable to send password // ".$self->errmsg));
				$self->{LOGINSTAGE} = '';
				$login->{password_sent} = 1;
				next;
			}
			elsif ($pattern eq 'localfail') { # Login failure
				return $self->poll_return($self->error("$pkgsub: Incorrect Username or Password"));
			}
			elsif ($pattern eq 'radiusfail') { # Radius Login failure
				return $self->poll_return($self->error("$pkgsub: Switch got access denied from RADIUS"));
			}
			elsif ($pattern =~ /^radiustimeout\d$/) { # Radius timeout
				$login->{login_error} = "Switch got no response from RADIUS servers\n";
				next; # In this case don't error, as radius falback might still get us in
			}

			# Then try and match CLI prompts; this is the only exit point of the loop
			if ($login->{family_type}) { # A family type was already detected from banner
				if ($login->{family_type} eq $Prm{pers}) {
					foreach my $type ('cli', 'nncli') {
						$promptType = "$login->{family_type}_$type";
						if ($self->{POLL}{local_buffer} =~ /($InitPrompt{$promptType})/) {
							($capturedPrompt, $switchName, $login->{cpu_slot}, $configContext) = ($1, $2, $3, $4);
							$cliType = $type;
							last;
						}
					}
				}
				else {
					if ($self->{POLL}{local_buffer} =~ /($InitPrompt{$login->{family_type}})/) {
						($capturedPrompt, $switchName, $configContext) = ($1, $2, $4);
						$promptType = $login->{family_type};
					}
				}
			}
			else { # A family type has not been detected yet; try and detect from received prompt
				foreach my $key (@InitPromptOrder) {
					if ($self->{POLL}{local_buffer} =~ /($InitPrompt{$key})/) {
						($capturedPrompt, $switchName, $login->{cpu_slot}, $configContext) = ($1, $2, $3, $4);
						$promptType = $key;
						($login->{family_type} = $key) =~ s/_(\w+)$//;
						$cliType = $1;
						$login->{detectionFromPrompt} = 1;
						last;
					}
				}
			}
			if ($capturedPrompt) { # We have a prompt, we can exit loop
				$self->debugMsg(8,"\nlogin() Got CLI prompt for family type $login->{family_type} !\n");
				$self->_setDevicePrompts($promptType, $switchName);
				$capturedPrompt =~ s/^\x0d//; # Remove initial carriage return if there
				$capturedPrompt =~ s/\x0d$//; # Remove trailing carriage return if there (possible if we match on not the last prompt, as we do /m matching above
				($self->{LASTPROMPT} = $capturedPrompt) =~ s/$LastPromptClense//o;
				$self->{$Package}{CONFIGCONTEXT} = $configContext;
				$self->{$Package}{PROMPTTYPE} = $promptType;
				$self->debugMsg(4,"login() Prompt type = $self->{$Package}{PROMPTTYPE}\n");

				$self->_setAttrib('cpu_slot', $login->{cpu_slot}) if $login->{family_type} eq $Prm{pers};
				if ($login->{detectionFromPrompt}) {
					if ($login->{family_type} eq $Prm{bstk} || (defined $cliType && $cliType eq 'nncli')) {
						$self->_setAttrib('is_nncli', 1);
					}
					else {
						$self->_setAttrib('is_nncli', 0);
					}
				}
				last LOGINLOOP;
			}
		}
		if ($login->{family_type} eq $Prm{generic} || ($login->{detectionFromPrompt} && $self->{LASTPROMPT} !~ /^@/) ) { # Can't tell, need extended discovery
			$login->{stage}++; # Move to next section in non-blocking mode
		}
		else {
			$login->{stage} += 2; # Move to section after next
		}
		return $self->poll_return(0) unless $self->{POLL}{blocking};
	}
	if ($login->{stage} < 3) { # Extended discovery
		my ($ok, $familyType) = $self->discoverDevice($pkgsub);
		return $self->poll_return($ok) unless $ok; # Come out if error or if not done yet in non-blocking mode
		$login->{family_type} = $familyType;
		if ($login->{family_type} eq $Prm{generic} && ($self->{errmode} eq 'croak' || $self->{errmode} eq 'die')) {
			carp "\n$pkgsub Warning! Device type not detected; using $Prm{generic}\n";
		}
		$login->{stage} += 2; # Move to final section
	}
	if ($login->{stage} < 4) { # Family type was detected, not just from the prompt (though we do rely on prompt alone for Standby CPUs on PassportERS)
		if ($login->{family_type} eq $Prm{pers} || $login->{family_type} eq $Prm{xlr}) {
			$self->_setAttrib('is_master_cpu', $self->{LASTPROMPT} =~ /^@/ ? 0 : 1);
			$self->_setAttrib('is_dual_cpu', 1) if $self->{LASTPROMPT} =~ /^@/;
		}
		$self->_setAttrib('family_type', $login->{family_type}) if $login->{detectionFromPrompt};
	}

	# Store credentials if these were used
	($self->{USERNAME}, $self->{PASSWORD}) = ($login->{username}, $login->{password}) if $login->{login_attempted};
	return $self->poll_return(1);
}


sub poll_cmd { # Method to handle cmd for poll methods (used for both blocking & non-blocking modes)
	my $self = shift;
	my $pkgsub = shift;
	my $pollsub = "${Package}::cmd";

	unless ($self->{POLLING}) { # Sanity check
		my (undef, $fileName, $lineNumber) = caller;
		croak "$pollsub (called from $fileName line $lineNumber) can only be used within polled methods";
	}

	unless (defined $self->{POLL}{$pollsub}) { # Only applicable if called from another method already in polling mode
		my @validArgs = ('command', 'feed_list', 'prompt', 'reset_prompt', 'more_prompt', 'cmd_confirm_prompt',
				  'cmd_initiated_prompt', 'more_pages', 'timeout', 'errmode', 'progress_dots');
		my %args = parseMethodArgs($pkgsub, \@_, \@validArgs, 1);
		if (@_ && !%args) { # Legacy syntax
			($args{command}, $args{more_pages}, $args{prompt}, $args{reset_prompt}, $args{timeout}, $args{errmode},
			 $args{feed_list}, $args{cmd_confirm_prompt}, $args{cmd_initiated_prompt}) = @_;
		}
		$args{feed_list} = [$args{feed_list}] if defined $args{feed_list} && !ref($args{feed_list}) eq "ARRAY";	# We want it as an array reference
		# In which case we need to setup the poll structure for them here (the main poll structure remains unchanged)
		$self->{POLL}{$pollsub} = { # Populate structure with method arguments/storage
			# Set method argument keys
			command			=>	$args{command},
			prompt			=>	defined $args{prompt} ? $args{prompt} : $self->{$Package}{prompt_qr},
			more_prompt		=>	defined $args{more_prompt} ? $args{more_prompt} : $self->{$Package}{morePrompt_qr},
			more_prompt_delay	=>	defined $args{more_prompt} ? undef : $self->{$Package}{morePromptDelay_qr},
			more_pages		=>	defined $args{more_pages} ? $args{more_pages} : $self->{$Package}{morePaging},
			reset_prompt		=>	$args{reset_prompt} && defined $self->{$Package}{PROMPTTYPE},
			yn_prompt		=>	defined $args{cmd_confirm_prompt} ? $args{cmd_confirm_prompt} : $self->{$Package}{cmd_confirm_prompt_qr},
			cmd_prompt		=>	defined $args{cmd_initiated_prompt} ? $args{cmd_initiated_prompt} : $self->{$Package}{cmd_initiated_prompt_qr},
			feed_data		=>	$args{feed_list},
			progress_dots		=>	defined $args{progress_dots} ? $args{progress_dots} : $self->{$Package}{progressDots},
			# Declare method storage keys which will be used
			stage			=>	0,
			lastLine		=>	'',
			outputNewline		=>	'',
			progress		=>	undef,
			alreadyCmdTimeout	=>	0,
			ynPromptCount		=>	undef,
			cmdPromptCount		=>	undef,
			cmdEchoRemoved		=>	0,
			lastPromptEchoedCmd	=>	undef,
			cache_timeout		=>	defined $args{timeout} ? $args{timeout} : $self->{POLL}{timeout},
			# Declare keys to be set if method called from another polled method
			errmode			=>	$args{errmode},
		};
		# Cache poll structure keys which this method will use
		$self->poll_struct_cache($pollsub, $args{timeout});
	}

	my $cmd = $self->{POLL}{$pollsub};
	local $self->{errmode} = $cmd->{errmode} if defined $cmd->{errmode};
	return $self->poll_return($self->error("$pkgsub: No connection to send cmd to")) if $self->eof;
	$cmd->{prompt} = $InitPrompt{$self->{$Package}{PROMPTTYPE}} if $cmd->{reset_prompt};
	my $familyType = $self->{$Package}{ATTRIB}{'family_type'} || '';
	my $newLineLastLine = 0;

	if ($cmd->{stage} < 1) { # Send command - do only once
		$cmd->{stage}++; # Ensure we don't come back here in non-blocking mode
		if (defined $cmd->{command}) {
			my $command = $cmd->{command};
			# In NNCLI mode, if command ends with ?, append CTRL-X otherwise partial command will appear after next prompt
			if ($command =~ /\?\s*$/ && $self->{$Package}{ATTRIB}{'is_nncli'}) {
				if ($familyType eq $Prm{sr}) { $command .= $CTRL_U }
				else { $command .= $CTRL_X }
			}
			# Flush any unread data which might be pending
			$self->read(blocking => 0);
			# Send the command
			$self->debugMsg(8,"\ncmd() Sending command:>", \$command, "<\n");
			$self->print(line => $command, errmode => 'return')
				or return $self->poll_return($self->error("$pkgsub: Unable to send CLI command: $command // ".$self->errmsg));
		}
	}
	CMDLOOP: while (1) {
		# READ in data
		if ($cmd->{stage} == 1) { # Normal data read
			my $ok = $self->poll_read($pkgsub); # We always come back even in case of error
			return $self->poll_return($ok) if defined $ok && $ok == 0; # Come out only in case of non-blocking not ready
			unless (defined $ok) { # We catch timeout event here
				if ($cmd->{alreadyCmdTimeout} || !length $familyType || $familyType eq $Prm{generic}) {
					return $self->poll_return($self->error("$pkgsub: Failed after sending command // ".$self->errmsg));
				}
				$self->debugMsg(4, "\ncmd() Initial cmd timeout; attempting reset_prompt\n");
				$self->print(errmode => 'return') # Send a carriage return and we have a 2nd try at catching prompt
					or return $self->poll_return($self->error("$pkgsub: Unable to send Carriage Return // ".$self->errmsg));
				$self->{POLL}{timeout} = $cmd->{cache_timeout} * $CmdTimeoutRatio; # Re-arm timeout
				$cmd->{prompt} = $InitPrompt{$self->{$Package}{PROMPTTYPE}};
				$cmd->{alreadyCmdTimeout} = 1; # Ensures that at next timeout we generate the error mode action (so cannot loop)
				$cmd->{reset_prompt} = 1;
				return $self->poll_return(0) unless $self->{POLL}{blocking};
				next CMDLOOP;
			}
		}
		elsif ($cmd->{stage} == 2) { # cmd_prompt / Wait if more data coming
			my $ok = $self->poll_readwait($pkgsub, 0, $CmdPromptReadAttempts, $ReadwaitTimer, "Cmd_prompt; unable to check for more data");
			return $self->poll_return($ok) unless $ok; # Come out if error (if errmode='return'), or if nothing to read in non-blocking mode
			$cmd->{stage} = 1; # Whatever the outcome below, we will revert to normal data reads
			unless (length $self->{POLL}{read_buffer}) { # No more data => no false trigger
				$self->debugMsg(8,"\ncmd() Detected CMD embedded prompt");
				my $feed;
				if ($feed = shift(@{$cmd->{feed_data}})) {
					$self->debugMsg(8,"cmd()  - Have data to feed:>", \$feed, "<\n");
				}
				else {
					if (++$cmd->{cmdPromptCount} > $self->{$Package}{cmd_feed_timeout}) {
						return $self->poll_return($self->error("$pkgsub: Command embedded prompt timeout"));
					}
					$feed = '';
					$self->debugMsg(8,"cmd()  - No data to feed!\n");
				}
				$self->print(line => $feed, errmode => 'return')
					or return $self->poll_return($self->error("$pkgsub: Unable to feed data at cmd prompt // ".$self->errmsg));

				return $self->poll_return(0) unless $self->{POLL}{blocking};
				next CMDLOOP;
			}
		}
		else { # Stage = 3 ; more prompt delay / 1 non-blocking read to ascertain if partial more prompt can be processed or not
			my $ok = $self->poll_readwait($pkgsub, 0, 1, $ReadwaitTimer, "Delayed More prompt; unable to check for more data");
			return $self->poll_return($ok) unless $ok; # Come out if error (if errmode='return'), or if nothing to read in non-blocking mode
			$cmd->{stage} = 1; # We immediately revert to normal data reads
		}

		# Process data
		if ($cmd->{progress_dots}) { # Print dots for progress
			_printDot() unless defined $cmd->{progress};
			if ( ( $cmd->{progress} += length($self->{POLL}{read_buffer}) ) > $cmd->{progress_dots}) {
				_printDot();
				$cmd->{progress} -= $cmd->{progress_dots};
			}
		}

		unless ($cmd->{cmdEchoRemoved}) { # If the echoed cmd was not yet removed
			$self->{POLL}{local_buffer} .= $self->{POLL}{read_buffer};	# Append to local_buffer
			if ($self->{POLL}{local_buffer} =~ s/(^.*\n)//) { # if we can remove it now
				$self->debugMsg(8,"\ncmd() Stripped echoed command\n");
				$cmd->{lastPromptEchoedCmd} = $self->{LASTPROMPT} . $1;
				$cmd->{lastPromptEchoedCmd} =~ s/\x10?\x00//g if $familyType eq $Prm{xirrus};	# WLAN9100 in telnet
				$cmd->{cmdEchoRemoved} = 1;
				$self->{POLL}{read_buffer} = $self->{POLL}{local_buffer};	# Re-prime read_buffer so that we fall through below with what's left
				$self->{POLL}{local_buffer} = '';				# Empty local_buffer so that we fall through below
				next CMDLOOP unless length $self->{POLL}{read_buffer};		# If we have remaining data, fall through, else do next cycle
			}
			else { # if we can't then no point processing patterns below
				next CMDLOOP;	# Do next read
			}
		}
		# If we get here, it means that the echo-ed cmd has been removed
		# read_buffer will either hold remaining output after removing echoed cmd
		# or it will hold the most recent data read

		my $output = $cmd->{lastLine}.$self->{POLL}{read_buffer};	# New output appended to previous lastLine
		$self->{POLL}{output_buffer} .= $cmd->{outputNewline};		# Re-add newLine if had been withheld

		if (length $output) { # Clean up patterns
			$output =~ s/^(?:\x08 \x08)*//;					# Remove backspace chars following a more prompt, if any
			$output =~ s/^\x0d *\x00\x0d//	if $familyType eq $Prm{sr};	# Remove Secure Router CR+spaces+0+CR sequence following more prompt
			if ($familyType eq $Prm{xirrus}) {
				$output =~ s/\x10?\x00//g; 				# Remove weird chars that WLAN9100 peppers output with, with telnet only,
											# ...in some case even not at beginning of line..
				$output =~ s/^ ?\x0d *\x0d//;				# Remove WLAN9100 CR+spaces+CR sequence following more prompt
											# .. with telnet, the WLAN9100 echoes back the space which was sent to page
			}
			# Note, order of these matches is important
			$output =~ s/^\x0d+//mg;					# Remove spurious CarriageReturns at beginning of line, a BPS/470 special
			$output =~ s/\x0d+$//mg;					# Remove spurious CarriageReturns at end of each line, 5500, 4500...
		}
		$cmd->{lastLine} = stripLastLine(\$output);			# We strip a new lastLine from it

		# Here we either hold data in $output or in $cmd->{lastLine} or both
		$self->debugMsg(8,"\ncmd() Output to process:\n>", \$output, "<\n") if length $output;
		$self->debugMsg(8,"\ncmd() Lastline stripped:\n>", \$cmd->{lastLine}, "<\n") if length $cmd->{lastLine};

		if (length $output) { # Append output now
			$self->{POLL}{local_buffer} .= $output;			# Append to local_buffer
			$self->{POLL}{output_buffer} .= $output;		# Append to output_buffer as well
		}

		# Since some more prompt pattern matches can include an initial \n newline which needs removing, we need lastLine to hold that \n
		if (length $cmd->{lastLine} && $self->{POLL}{local_buffer} =~ s/\n\n$/\n/) { 	# If output had x2 trailing newlines, strip last ...
			$cmd->{lastLine} = "\n" . $cmd->{lastLine}; 	# ... and pre-pend it to lastLine
			$cmd->{outputNewline} = chop $self->{POLL}{output_buffer};	# And chop & store \n from output_buffer
			$newLineLastLine = 1;				# and remember it
			$self->debugMsg(8,"\ncmd() Lastline adjusted:\n>", \$cmd->{lastLine}, "<\n");
		}
		else {
			$cmd->{outputNewline} = '';			# Clear it
			$newLineLastLine = 0;				# Clear it
		}

		next CMDLOOP unless length $cmd->{lastLine};

		if ($cmd->{lastLine} =~ s/($cmd->{prompt})//) {
			my ($cap1, $cap2, $cap3) = ($1, $2, $3); # We need to store these in temporary variables
			($self->{LASTPROMPT} = $cap1) =~ s/$LastPromptClense//o; # Remove initial carriage return if there
			$self->_setDevicePrompts($self->{$Package}{PROMPTTYPE}, $cap2) if $cmd->{reset_prompt};
			$self->{$Package}{CONFIGCONTEXT} = $cmd->{reset_prompt} ? $cap3 : $cap2;
			unless ($newLineLastLine && !length $cmd->{lastLine}) { # Only if we did not gobble the \n ...
				$self->{POLL}{output_buffer} .= $cmd->{outputNewline}; # ... re-add to output its final \n
			}
			$self->debugMsg(8,"\ncmd() prompt detected; cmd complete!\n");
			last CMDLOOP;
		}
		if ($cmd->{more_prompt_delay} && !$cmd->{morePromptDelayed} && $cmd->{lastLine} =~ /(?:$cmd->{more_prompt_delay})$/) { # We have a more prompt which requires a delay
			$self->debugMsg(8,"\ncmd() more prompt delay pattern detected; forcing 1 cycle readwait\n");
			$cmd->{stage} = 3; # Force a 1 cycle readwait at next cycle
			$cmd->{morePromptDelayed} = 1;	# Make sure we don't come back here at next cycle
			return $self->poll_return(0) unless $self->{POLL}{blocking};
			next CMDLOOP;
		}
		if ($cmd->{more_prompt} && $cmd->{lastLine} =~ s/(?:$cmd->{more_prompt})$//) { # We have a more prompt
			$cmd->{morePromptDelayed} = 0;	# Reset this flag
			if (length $cmd->{lastLine}) { # We did not gobble the \n
				$self->{POLL}{local_buffer} .= $cmd->{lastLine}; # Re-add it now
				$cmd->{lastLine} = '';	# And clear lastLine, otherwise it will compromise pattern to delete more prompt del char sequence
				$self->{POLL}{output_buffer} .= $cmd->{outputNewline} if $newLineLastLine;
			}
			$cmd->{outputNewline} = '' if $newLineLastLine; # Either way (\n gobbled or not) we clear it
			if ($cmd->{more_pages} == 0 || $cmd->{more_pages}-- > 1) { # We get the next page
				$self->debugMsg(8,"\ncmd() More prompt detected; feeding 'SPACE'\n");
				$self->put(string => $Space, errmode => 'return')
					or return $self->poll_return($self->error("$pkgsub: Unable to page at more prompt // ".$self->errmsg));
			}
			else { # We quit here
				$self->debugMsg(8,"\ncmd() More prompt detected; feeding 'Q'\n");
				$self->put(string => 'q', errmode => 'return')
					or return $self->poll_return($self->error("$pkgsub: Unable to quit more prompt // ".$self->errmsg));
			}
			return $self->poll_return(0) unless $self->{POLL}{blocking};
			next CMDLOOP;
		}
		if ($cmd->{yn_prompt} && $cmd->{lastLine} =~ /$cmd->{yn_prompt}/) { # We have a Y/N prompt
			if (++$cmd->{ynPromptCount} > $self->{$Package}{cmd_feed_timeout}) {
				return $self->poll_return($self->error("$pkgsub: Y/N confirm prompt timeout"));
			}
			$self->debugMsg(8,"\ncmd() Y/N prompt detected; feeding 'Y'\n");
			$self->print(line => 'y', errmode => 'return')
				or return $self->poll_return($self->error("$pkgsub: Unable to confirm at Y/N prompt // ".$self->errmsg));
			return $self->poll_return(0) unless $self->{POLL}{blocking};
			next CMDLOOP;
		}
		if ($cmd->{cmd_prompt} && $cmd->{lastLine} =~ /$cmd->{cmd_prompt}/) { # We have a prompt for additional input
			# But, this pattern risks matching against transient data; so check if more data coming
			$self->debugMsg(8,"\ncmd() cmd-prompt detected; forcing readwait\n");
			$cmd->{stage} = 2; # Force a readwait at next cycle
			return $self->poll_return(0) unless $self->{POLL}{blocking};
			next CMDLOOP;
		}

		# Having lastLine with \n newline can screw up cleanup patterns above, so after above prompt matching we have it removed here
		$self->{POLL}{local_buffer} .= "\n" if $cmd->{lastLine} =~ s/^\n//; # If it's there we take it off
	}# CMDLOOP
	$self->{POLL}{output_result} = $self->_determineOutcome(\$self->{POLL}{local_buffer}, $cmd->{lastPromptEchoedCmd});
	return $self->poll_return(1);
}


sub poll_attribute { # Method to handle attribute for poll methods (used for both blocking & non-blocking modes)
	my $self = shift;
	my $pkgsub = shift;
	my $pollsub = "${Package}::attribute";

	unless ($self->{POLLING}) { # Sanity check
		my (undef, $fileName, $lineNumber) = caller;
		croak "$pollsub (called from $fileName line $lineNumber) can only be used within polled methods";
	}

	unless (defined $self->{POLL}{$pollsub}) { # Only applicable if called from another method already in polling mode
		my @validArgs = ('attribute', 'reload', 'timeout', 'errmode');
		my %args = parseMethodArgs($pkgsub, \@_, \@validArgs, 1);
		if (@_ && !%args) { # Legacy syntax
			($args{attribute}, $args{reload}, $args{timeout}, $args{errmode}) = @_;
		}
		# In which case we need to setup the poll structure for them here (the main poll structure remains unchanged)
		$self->{POLL}{$pollsub} = { # Populate structure with method arguments/storage
			# Set method argument keys
			attribute		=>	$args{attribute},
			reload			=>	$args{reload},
			# Declare method storage keys which will be used
			stage			=>	0,
			debugMsg		=>	0,
			# Declare keys to be set if method called from another polled method
			errmode			=>	$args{errmode},
		};
		# Cache poll structure keys which this method will use
		$self->poll_struct_cache($pollsub, $args{timeout});
	}
	my $attrib = $self->{POLL}{$pollsub};
	local $self->{errmode} = $attrib->{errmode} if defined $attrib->{errmode};
	return $self->poll_return($self->error("$pkgsub: No connection for attributes")) if $self->eof;
	my $familyType = $self->{$Package}{ATTRIB}{'family_type'} || '';

	if ($attrib->{stage} < 1) { # 1st stage
		return $self->poll_return($self->error("$pkgsub: No attribute provided")) unless defined $attrib->{attribute};
		return $self->poll_return(1) unless $familyType; # Value returned is undef

		$attrib->{stage} += 2; # Assume no login() required and that we move directly to 3rd stage
		if ($attrib->{reload}) { # Force reload, either via forced login() or resetting ATTRIBFLAG
			if ($attrib->{attribute} eq 'family_type' || $attrib->{attribute} eq 'is_nncli' || $attrib->{attribute} eq 'is_acli'
			 || $attrib->{attribute} eq 'is_master_cpu' || $attrib->{attribute} eq 'cpu_slot') {
				$self->print or return $self->poll_return($self->error("$pkgsub: Unable to refresh device connection"));
				$attrib->{stage}--; # Move to 2nd stage
			}
			else {
				$self->{$Package}{ATTRIBFLAG}{$attrib->{attribute}} = undef;
			}
		}
	}

	if ($attrib->{stage} < 2) { # 2nd stage - wait for login to complete
		my $ok = $self->poll_login($pkgsub);
		return $self->poll_return($ok) unless $ok;
		$attrib->{stage}++; # Move to 3rd stage
	}

	if ($attrib->{stage} < 3) { # 3rd stage
		# If the attribute is set already, return it at once and quit
		if (defined $self->{$Package}{ATTRIBFLAG}{$attrib->{attribute}}) {
			$self->{POLL}{output_result} = $self->{$Package}{ATTRIB}{$attrib->{attribute}};
			return $self->poll_return(1);
		}
		# Go no further if generic family type
		return $self->poll_return(1) if $familyType eq $Prm{generic}; # Value returned is undef
		$attrib->{stage}++; # Move to next stage
	}

	# Otherwise go set the attribute
	if ($familyType eq $Prm{pers}) {
		$attrib->{attribute} eq 'is_ha' && do {
			unless ($attrib->{debugMsg}) {
				$self->debugMsg(4,"Seeking attribute $attrib->{attribute} value by issuing command: show ha-state\n");
				$attrib->{debugMsg} = 1;
			}
			my ($ok, $outref) = $self->cmdPrivExec($pkgsub, 'show ha-state', 'show ha-state');
			return $self->poll_return($ok) unless $ok; # Come out if error or if not done yet in non-blocking mode
			if ($$outref =~ /Current CPU State : Disabled State./) {
				$self->_setAttrib('is_ha', 0);
			}
			elsif ($$outref =~ /Current CPU State/) {
				$self->_setAttrib('is_ha', 1);
			}
			else { # For example on ERS8300 or ERS1600
				$self->_setAttrib('is_ha', undef);
			}
			$self->{POLL}{output_result} = $self->{$Package}{ATTRIB}{$attrib->{attribute}};
			return $self->poll_return(1);
		};
		$attrib->{attribute} eq 'sw_version' && do {
			unless ($attrib->{debugMsg}) {
				$self->debugMsg(4,"Seeking attribute $attrib->{attribute} value by issuing command: show sys sw / show sys software\n");
				$attrib->{debugMsg} = 1;
			}
			my ($ok, $outref) = $self->cmdPrivExec($pkgsub, 'show sys sw', 'show sys software');
			return $self->poll_return($ok) unless $ok; # Come out if error or if not done yet in non-blocking mode
			$$outref =~ /Version : Build (?i:v|REL)?(.+?) / && $self->_setAttrib('sw_version', $1);
			$self->{POLL}{output_result} = $self->{$Package}{ATTRIB}{$attrib->{attribute}};
			return $self->poll_return(1);
		};
		$attrib->{attribute} eq 'fw_version' && do {
			if ($attrib->{stage} < 4) { # 4th stage
				unless ($attrib->{debugMsg}) {
					$self->debugMsg(4,"Seeking attribute $attrib->{attribute} value by issuing command: show bootconfig info / show boot config general\n");
					$attrib->{debugMsg} = 1;
				}
				my ($ok, $outref) = $self->cmdPrivExec($pkgsub, 'show bootconfig info', 'show boot config general');
				return $self->poll_return($ok) unless $ok; # Come out if error or if not done yet in non-blocking mode
				if ($$outref =~ /Version:\s+(?i:v|REL)?(.+)/) {
					$self->_setAttrib('fw_version', $1);
					$self->{POLL}{output_result} = $self->{$Package}{ATTRIB}{$attrib->{attribute}};
					return $self->poll_return(1);
				}
				else {
					$attrib->{stage}++; # Move to next stage
					$attrib->{debugMsg} = 0;
				}
			}
			unless ($attrib->{debugMsg}) {
				$self->debugMsg(4,"Seeking attribute $attrib->{attribute} value by issuing command: show bootconfig info / show boot config info\n");
				$attrib->{debugMsg} = 1;
			}
			my ($ok, $outref) = $self->cmdPrivExec($pkgsub, 'show bootconfig info', 'show boot config info'); # On 8300 it's 'show boot config info'
			return $self->poll_return($ok) unless $ok; # Come out if error or if not done yet in non-blocking mode
			if ($$outref =~ /Version:\s+(?i:v|REL)?(.+)/) {
				$self->_setAttrib('fw_version', $1);
			}
			else { # VSP9000 has no fw_version (when command executed on standby CPU)
				$self->_setAttrib('fw_version', undef);
			}
			$self->{POLL}{output_result} = $self->{$Package}{ATTRIB}{$attrib->{attribute}};
			return $self->poll_return(1);
		};
		$attrib->{attribute} eq 'stp_mode' && do {
			unless ($attrib->{debugMsg}) {
				$self->debugMsg(4,"Seeking attribute $attrib->{attribute} value by issuing command: show bootconfig flags / show boot flags\n");
				$attrib->{debugMsg} = 1;
			}
			my ($ok, $outref) = $self->cmdPrivExec($pkgsub, 'show bootconfig flags', 'show boot config flags');
			return $self->poll_return($ok) unless $ok; # Come out if error or if not done yet in non-blocking mode
			if ($$outref =~ /flags spanning-tree-mode (mstp|rstp)/) {
				$self->_setAttrib('stp_mode', $1);
			}
			else {
				$self->_setAttrib('stp_mode', 'stpg');
			}
			$self->{POLL}{output_result} = $self->{$Package}{ATTRIB}{$attrib->{attribute}};
			return $self->poll_return(1);
		};
		$attrib->{attribute} eq 'baudrate' && do {
			unless ($attrib->{debugMsg}) {
				$self->debugMsg(4,"Seeking attribute $attrib->{attribute} value by issuing command: show bootconfig sio / show boot config sio\n");
				$attrib->{debugMsg} = 1;
			}
			my ($ok, $outref) = $self->cmdPrivExec($pkgsub, 'show bootconfig sio', 'show boot config sio', 1);
			return $self->poll_return($ok) unless $ok; # Come out if error or if not done yet in non-blocking mode
			if ($$outref =~ /sio (?:console )?baud (\d+)/) { # On VSP/8600 it's "sio console baud 9600"; on 8300/1600 "sio baud 9600"
				$self->_setAttrib('baudrate', $1);
			}
			$self->{POLL}{output_result} = $self->{$Package}{ATTRIB}{$attrib->{attribute}};
			return $self->poll_return(1);
		};
		$attrib->{attribute} eq 'max_baud' && do {
			if ($attrib->{stage} < 4) { # 4th stage
				unless ($attrib->{debugMsg}) {
					$self->debugMsg(4,"Seeking attribute $attrib->{attribute} value by issuing command: config bootconfig sio console baud ? / boot config sio console baud ?\n");
					$attrib->{debugMsg} = 1;
				}
				my ($ok, $outref) = $self->cmdConfig($pkgsub, 'config bootconfig sio console baud ?', "boot config sio console baud ?$CTRL_C", 1);
				return $self->poll_return($ok) unless $ok; # Come out if error or if not done yet in non-blocking mode
				# VSP9k		:   <9600 - 115200>  Baud rate {9600 | 19200 | 38400 | 57600 | 115200}
				# 8600acli	:   <1200-115200>  Rate
				# 8600ppcli	:           = what rate {1200..115200}
				if ($$outref =~ /(?:-|\.\.)\s?(\d+)[>}]/) {
					$self->_setAttrib('max_baud', $1);
					$self->{POLL}{output_result} = $self->{$Package}{ATTRIB}{$attrib->{attribute}};
					return $self->poll_return(1);
				}
				else {
					$attrib->{stage}++; # Move to next stage
					$attrib->{debugMsg} = 0;
				}
			}
			unless ($attrib->{debugMsg}) {
				$self->debugMsg(4,"Seeking attribute $attrib->{attribute} value by issuing command: config bootconfig sio baud ? / boot config sio baud ?\n");
				$attrib->{debugMsg} = 1;
			}
			my ($ok, $outref) = $self->cmdConfig($pkgsub, 'config bootconfig sio baud ?', "boot config sio baud ?$CTRL_C", 1);
			return $self->poll_return($ok) unless $ok; # Come out if error or if not done yet in non-blocking mode
			# 8300nncli	:   <1200-115200>  rate
			# 8300ppcli	:           = what rate {2400|4800|9600|19200|38400|57600|115200} IN {1200..115200}
			# 1600		:           = what rate {1200..115200}
			if ($$outref =~ /(?:-|\.\.)\s?(\d+)[>}]/) {
				$self->_setAttrib('max_baud', $1);
			}
			$self->{POLL}{output_result} = $self->{$Package}{ATTRIB}{$attrib->{attribute}};
			return $self->poll_return(1);
		};
		if ($self->{$Package}{ATTRIB}{'is_master_cpu'}) { # On Master CPU
			($attrib->{attribute} eq 'is_dual_cpu' || $attrib->{attribute} eq 'base_mac') && do {
				unless ($attrib->{debugMsg}) {
					$self->debugMsg(4,"Seeking attribute $attrib->{attribute} value by issuing command: show sys info / show sys-info (4 pages)\n");
					$attrib->{debugMsg} = 1;
				}
				my ($ok, $outref) = $self->cmdPrivExec($pkgsub, 'show sys info', 'show sys-info', 4);
				return $self->poll_return($ok) unless $ok; # Come out if error or if not done yet in non-blocking mode
				$$outref =~ /SysDescr\s+: (.+?) \(/g && do {
					my $model = $1; # Record it, we need to set the model type after is_apls
					if ($$outref =~ / BoxType: (.+)/gc) { # APLS boxes show a boxtype on same line
						$self->_setBoxTypeAttrib($1);
						$self->_setAttrib('is_apls', 1);
						$self->_setModelAttrib($model); # Must be set after is_apls so that is_voss gets set as well
					}
					else {
						$self->_setAttrib('apls_box_type', undef);
						$self->_setAttrib('is_apls', 0);
						$self->_setModelAttrib($model);
					}
				};
				$$outref =~ /SysName\s+: (.+)/g && $self->_setAttrib('sysname', $1);
				if ($self->{$Package}{ATTRIB}{'is_voss'}) {
					if ($$outref =~ /BrandName:?\s+: (.+)/gc) { # On VOSS VSPs we read it
						(my $brandname = $1) =~ s/, Inc\.$//; # Remove 'Inc.'
						$self->_setAttrib('brand_name', $brandname);
					}
					else { # VSP9000 case, it is_voss, but reports no BrandName, so we set it..
						$self->_setAttrib('brand_name', 'Avaya');
					}
				}
				else { # Non-VOSS PassportERS
					$self->_setAttrib('brand_name', undef);
				}
				$$outref =~ /BaseMacAddr\s+: (.+)/g && $self->_setBaseMacAttrib($1);
				if ($$outref =~ /CP.+ dormant /		# 8600 & VSP9000
				 || ($$outref =~ /\s1\s+\d{4}\S{2}\s+1\s+CPU\s+(?:\d+\s+){4}/ &&
				     $$outref =~ /\s2\s+\d{4}\S{2}\s+1\s+CPU\s+(?:\d+\s+){4}/)	# VSP8600 just check for presence of slot1&2
				  ) {
					$self->_setAttrib('is_dual_cpu', 1);
				}
				else {
					$self->_setAttrib('is_dual_cpu', 0);
				}
				# Attributes below are beyond demanded pages of output, but we still check them in case more paging was disabled
				$$outref =~ /Virtual IP\s+: (.+)/g && $self->_setAttrib('oob_virt_ip', $1);
				$self->{POLL}{output_result} = $self->{$Package}{ATTRIB}{$attrib->{attribute}};
				return $self->poll_return(1);
			};
			($attrib->{attribute} eq 'model' || $attrib->{attribute} eq 'sysname' || $attrib->{attribute} eq 'is_apls' || $attrib->{attribute} eq 'is_voss' ||
			 $attrib->{attribute} eq 'apls_box_type' || $attrib->{attribute} eq 'brand_name' || # Any new attributes added here, need to be added on exit to this if block below
			 (!$self->{$Package}{ATTRIBFLAG}{'model'} && ($attrib->{attribute} eq 'slots' || $attrib->{attribute} eq 'ports')) || # We need 'model' attrib for port/slot ones
			 (!$self->{$Package}{ATTRIBFLAG}{'is_voss'} && $attrib->{attribute} =~ /^(?:is_)?oob_/) # We need 'is_voss' attrib for oob ones
			) && do {
				unless ($attrib->{debugMsg}) {
					$self->debugMsg(4,"Seeking attribute $attrib->{attribute} value by issuing command: show sys info / show sys-info (1 page)\n");
					$attrib->{debugMsg} = 1;
				}
				my ($ok, $outref) = $self->cmdPrivExec($pkgsub, 'show sys info', 'show sys-info', 1);
				return $self->poll_return($ok) unless $ok; # Come out if error or if not done yet in non-blocking mode
				$$outref =~ /SysDescr\s+: (.+?) \(/g && do {
					my $model = $1; # Record it, we need to set the model type after is_apls
					if ($$outref =~ / BoxType: (.+)/gc) { # APLS boxes show a boxtype on same line
						$self->_setBoxTypeAttrib($1);
						$self->_setAttrib('is_apls', 1);
						$self->_setModelAttrib($model); # Must be set after is_apls so that is_voss gets set as well
					}
					else {
						$self->_setAttrib('apls_box_type', undef);
						$self->_setAttrib('is_apls', 0);
						$self->_setModelAttrib($model);
					}
				};
				$$outref =~ /SysName\s+: (.+)/g && $self->_setAttrib('sysname', $1);
				if ($self->{$Package}{ATTRIB}{'is_voss'}) {
					if ($$outref =~ /BrandName:?\s+: (.+)/gc) { # On VOSS VSPs we read it
						(my $brandname = $1) =~ s/, Inc\.$//; # Remove 'Inc.'
						$self->_setAttrib('brand_name', $brandname);
					}
					else { # VSP9000 case, it is_voss, but reports no BrandName, so we set it..
						$self->_setAttrib('brand_name', 'Avaya');
					}
				}
				else { # Non-VOSS PassportERS
					$self->_setAttrib('brand_name', undef);
				}
				$$outref =~ /BaseMacAddr\s+: (.+)/g && $self->_setBaseMacAttrib($1); # Might not match on 8600 as on page 2
				# Attributes below are beyond demanded pages of output, but we still check them in case more paging was disabled
				if ($$outref =~ /CP.+ dormant /		# 8600 & VSP9000
				 || ($$outref =~ /\s1\s+\d{4}\S{2}\s+1\s+CPU\s+(?:\d+\s+){4}/ &&
				     $$outref =~ /\s2\s+\d{4}\S{2}\s+1\s+CPU\s+(?:\d+\s+){4}/)	# VSP8600 just check for presence of slot1&2
				  ) {
					$self->_setAttrib('is_dual_cpu', 1);
				}
				elsif ($$outref =~ /System Error Info :/) { # Output which follows Card Info, i.e. the output was there but no CP dormant matched
					$self->_setAttrib('is_dual_cpu', 0);
				}
				$$outref =~ /Virtual IP\s+: (.+)/g && $self->_setAttrib('oob_virt_ip', $1);
				if ($attrib->{attribute} eq 'model' || $attrib->{attribute} eq 'sysname' || $attrib->{attribute} eq 'is_apls' || $attrib->{attribute} eq 'is_voss' ||
				    $attrib->{attribute} eq 'apls_box_type' || $attrib->{attribute} eq 'brand_name') { # Needs to match the same listed on beginning of if block above
					$self->{POLL}{output_result} = $self->{$Package}{ATTRIB}{$attrib->{attribute}};
					return $self->poll_return(1);
				}
				else { # If an attribute that just needed 'model', fall through to appropriate section below
					$attrib->{debugMsg} = 0;
				}
			};
			($attrib->{attribute} eq 'slots' || $attrib->{attribute} eq 'ports') && do {
				if ($self->{$Package}{ATTRIB}{'is_nncli'} && $self->{$Package}{ATTRIB}{'model'} =~ /(?:Passport|ERS)-8[36]\d\d/) { # 8300/8600 NNCLI case
					if ($attrib->{stage} < 4) { # 4th stage
						unless ($attrib->{debugMsg}) {
							$self->debugMsg(4,"Seeking attribute $attrib->{attribute} value by issuing command: show interfaces fastEthernet name\n");
							$attrib->{debugMsg} = 1;
						}
						my ($ok, $outref) = $self->cmdPrivExec($pkgsub, undef, 'show interfaces fastEthernet name');
						return $self->poll_return($ok) unless $ok; # Come out if error or if not done yet in non-blocking mode
						$self->_setSlotPortAttrib($outref);
						$attrib->{stage}++; # Move to next stage
						$attrib->{debugMsg} = 0;
					}
					unless ($attrib->{debugMsg}) {
						$self->debugMsg(4,"Seeking attribute $attrib->{attribute} value by issuing command: show interfaces gigabitEthernet name\n");
						$attrib->{debugMsg} = 1;
					}
					my ($ok, $outref) = $self->cmdPrivExec($pkgsub, undef, 'show interfaces gigabitEthernet name');
					return $self->poll_return($ok) unless $ok; # Come out if error or if not done yet in non-blocking mode
					$self->_setSlotPortAttrib($outref);
					$self->{POLL}{output_result} = $self->{$Package}{ATTRIB}{$attrib->{attribute}};
					return $self->poll_return(1);
				}
				else { # All other cases: 8300/8600/8800 PPCLI, 8800 NNCLI, VSP
					unless ($attrib->{debugMsg}) {
						$self->debugMsg(4,"Seeking attribute $attrib->{attribute} value by issuing command: show port info\n");
						$attrib->{debugMsg} = 1;
					}
					my ($ok, $outref) = $self->cmdPrivExec($pkgsub, 'show ports info name', 'show interfaces gigabitEthernet high-secure');
					return $self->poll_return($ok) unless $ok; # Come out if error or if not done yet in non-blocking mode
					$self->_setSlotPortAttrib($outref);
					$self->{POLL}{output_result} = $self->{$Package}{ATTRIB}{$attrib->{attribute}};
					return $self->poll_return(1);
				}
			};
			$attrib->{attribute} =~ /^(?:is_)?oob_/ && do {
				if ($self->{$Package}{ATTRIB}{'is_voss'}) { # VSP based PassportERS (VOSS)
					unless ($attrib->{debugMsg}) {
						$self->debugMsg(4,"Seeking attribute $attrib->{attribute} value by issuing command: show ip interface vrf MgmtRouter\n");
						$attrib->{debugMsg} = 1;
					}
					my ($ok, $outref) = $self->cmdPrivExec($pkgsub, undef, 'show ip interface vrf MgmtRouter');
					return $self->poll_return($ok) unless $ok; # Come out if error or if not done yet in non-blocking mode
					my ($ip1, $ip2, $ipv);
					$ip1 = $1 if $$outref =~ /Portmgmt\s+ ([\d\.]+)/g;
					$ip1 = $1 if $$outref =~ /Port1\/1\s+ ([\d\.]+)/g;
					$ipv = $1 if $$outref =~ /MgmtVirtIp\s+ ([\d\.]+)/g;
					$ip2 = $1 if $$outref =~ /Port2\/1\s+ ([\d\.]+)/g;
					$ip2 = $1 if $$outref =~ /Portmgmt2\s+ ([\d\.]+)/g;
					if ($self->{$Package}{ATTRIB}{'cpu_slot'} == 1) { # Could be any VSP: 9k, 8k, 4k
						$self->_setAttrib('oob_ip', $ip1);
						$self->_setAttrib('oob_standby_ip', $ip2);
						$self->_setAttrib('oob_virt_ip', $ipv);
					}
					else { # cpu slot = 2 only on VSP9000
						$self->_setAttrib('oob_ip', $ip2);
						$self->_setAttrib('oob_standby_ip', $ip1);
						$self->_setAttrib('oob_virt_ip', $ipv);
					}
					$self->_setAttrib('is_oob_connected', defined $self->socket &&
						( (defined $self->{$Package}{ATTRIB}{'oob_ip'} && $self->socket->peerhost eq $self->{$Package}{ATTRIB}{'oob_ip'}) ||
						  (defined $self->{$Package}{ATTRIB}{'oob_virt_ip'} && $self->socket->peerhost eq $self->{$Package}{ATTRIB}{'oob_virt_ip'}) ) ?
						1 : 0 );
					$self->{POLL}{output_result} = $self->{$Package}{ATTRIB}{$attrib->{attribute}};
					return $self->poll_return(1);
				}
				else { # ERS based PassportERS
					if ($attrib->{stage} < 4) { # 4th stage
						unless ($attrib->{debugMsg}) {
							$self->debugMsg(4,"Seeking attribute $attrib->{attribute} value by issuing command: show sys info / show sys-info\n");
							$attrib->{debugMsg} = 1;
						}
						my ($ok, $outref) = $self->cmdPrivExec($pkgsub, 'show sys info', 'show sys-info');
						return $self->poll_return($ok) unless $ok; # Come out if error or if not done yet in non-blocking mode
						# No need to set Model, Sysname and BaseMAC as we only get here if Model is set
						if ($$outref =~ /CP.+ dormant /		# 8600 & VSP9000
						 || ($$outref =~ /\s1\s+\d{4}\S{2}\s+1\s+CPU\s+(?:\d+\s+){4}/ &&
						     $$outref =~ /\s2\s+\d{4}\S{2}\s+1\s+CPU\s+(?:\d+\s+){4}/)	# VSP8600 just check for presence of slot1&2
						  ) {
							$self->_setAttrib('is_dual_cpu', 1);
						}
						else {
							$self->_setAttrib('is_dual_cpu', 0);
						}
						if ($$outref =~ /Virtual IP\s+: (.+)/g) {
							$self->_setAttrib('oob_virt_ip', $1);
						}
						else { # Not set
							$self->_setAttrib('oob_virt_ip', undef);
						}
						$attrib->{stage}++; # Move to next stage
						$attrib->{debugMsg} = 0;
					}
					unless ($attrib->{debugMsg}) {
						$self->debugMsg(4,"Seeking attribute $attrib->{attribute} value by issuing command: show bootconfig config / show boot config running-config\n");
						$attrib->{debugMsg} = 1;
					}
					my ($ok, $outref) = $self->cmdPrivExec($pkgsub, 'show bootconfig config', 'show boot config running-config');
					return $self->poll_return($ok) unless $ok; # Come out if error or if not done yet in non-blocking mode
					my ($ip1, $ip2);
					$ip1 = $1 if $$outref =~ /^net mgmt ip ([\d\.]+)\/[\d\.]+ *(?:cpu-slot [35])?$/m;
					$ip2 = $1 if $$outref =~ /^net mgmt ip ([\d\.]+)\/[\d\.]+ cpu-slot 6$/m;
					if ($self->{$Package}{ATTRIB}{'cpu_slot'} < 5) {
						$self->_setAttrib('oob_ip', $ip1);
						$self->_setAttrib('oob_standby_ip', undef);
					}
					elsif ($self->{$Package}{ATTRIB}{'cpu_slot'} == 5) {
						$self->_setAttrib('oob_ip', $ip1);
						$self->_setAttrib('oob_standby_ip', $self->{$Package}{ATTRIB}{'is_dual_cpu'} ? $ip2 : undef);
					}
					else { # cpu slot = 6
						$self->_setAttrib('oob_ip', $ip2);
						$self->_setAttrib('oob_standby_ip', $self->{$Package}{ATTRIB}{'is_dual_cpu'} ? $ip1 : undef);
					}
					$self->_setAttrib('is_oob_connected', defined $self->socket &&
						( (defined $self->{$Package}{ATTRIB}{'oob_ip'} && $self->socket->peerhost eq $self->{$Package}{ATTRIB}{'oob_ip'}) ||
						  (defined $self->{$Package}{ATTRIB}{'oob_virt_ip'} && $self->socket->peerhost eq $self->{$Package}{ATTRIB}{'oob_virt_ip'}) ) ?
						1 : 0 );
					$self->{POLL}{output_result} = $self->{$Package}{ATTRIB}{$attrib->{attribute}};
					return $self->poll_return(1);
				}
			};
		}
		else { # On standby CPU
			($attrib->{attribute} eq 'is_apls') && do { # APLS is never dual_cpu
				$self->_setAttrib('is_apls', 0);
				$self->{POLL}{output_result} = $self->{$Package}{ATTRIB}{$attrib->{attribute}};
				return $self->poll_return(1);
			};
			($attrib->{attribute} eq 'is_voss') && do {
				unless ($attrib->{debugMsg}) {
					$self->debugMsg(4,"Seeking attribute $attrib->{attribute} value by issuing command: cd /\n");
					$attrib->{debugMsg} = 1;
				}
				my ($ok, $outref) = $self->cmdPrivExec($pkgsub, 'cd /', 'cd /');
				return $self->poll_return($ok) unless $ok; # Come out if error or if not done yet in non-blocking mode
				if ($$outref =~ /Only devices \/intflash/) {
					$self->_setAttrib('is_voss', 1);
				}
				else {
					$self->_setAttrib('is_voss', 0);
				}
				$self->{POLL}{output_result} = $self->{$Package}{ATTRIB}{$attrib->{attribute}};
				return $self->poll_return(1);
			};
		}
	}
	elsif ($familyType eq $Prm{bstk}) {
		($attrib->{attribute} eq 'fw_version' || $attrib->{attribute} eq 'sw_version' || $attrib->{attribute} eq 'switch_mode' ||
		 $attrib->{attribute} eq 'unit_number' || $attrib->{attribute} eq 'base_unit' || $attrib->{attribute} eq 'stack_size' ||
		 $attrib->{attribute} eq 'model' || $attrib->{attribute} eq 'sysname' || $attrib->{attribute} eq 'base_mac') && do {
			unless ($attrib->{debugMsg}) {
				$self->debugMsg(4,"Seeking attribute $attrib->{attribute} value by issuing command: show sys-info\n");
				$attrib->{debugMsg} = 1;
			}
			my ($ok, $outref) = $self->cmdPrivExec($pkgsub, undef, 'show sys-info');
			return $self->poll_return($ok) unless $ok; # Come out if error or if not done yet in non-blocking mode
			if ($$outref =~ /Operation Mode:\s+(Switch)/g) {
				$self->_setAttrib('switch_mode', $1);
				$self->_setAttrib('unit_number', undef);
				$self->_setAttrib('stack_size', undef);
				$self->_setAttrib('base_unit', undef);
			}
			elsif ($$outref =~ /Operation Mode:\s+(Stack), Unit # (\d)/g) {
				$self->_setAttrib('switch_mode', $1);
				$self->_setAttrib('unit_number', $2);
				$$outref =~ /Size Of Stack:         (\d)/gc; # Use /gc modifier to maintain position at every match
				$self->_setAttrib('stack_size', $1);
				$$outref =~ /Base Unit:             (\d)/gc; # With /gc modifiers, fileds have to be matched in the right order
				$self->_setAttrib('base_unit', $1);
			}
			$$outref =~ /MAC Address:\s+(.+)/gc && $self->_setBaseMacAttrib($1);
			$$outref =~ /sysDescr:\s+(.+?)(?:\n|\s{4})/gc && # Match up to end of line, or 4 or more spaces (old baystacks append FW/SW version here)
				$self->_setModelAttrib($1);
			$$outref =~ /FW:([\d\.]+)\s+SW:v([\d\.]+)/gc && do {
				$self->_setAttrib('fw_version', $1);
				$self->_setAttrib('sw_version', $2);
			};
			$$outref =~ /sysName: +(\S+)/gc && $self->_setAttrib('sysname', $1); # \S avoids match when field is blank
			$self->{POLL}{output_result} = $self->{$Package}{ATTRIB}{$attrib->{attribute}};
			return $self->poll_return(1);
		};
		($attrib->{attribute} eq 'slots' || $attrib->{attribute} eq 'ports') && do {
			unless ($attrib->{debugMsg}) {
				$self->debugMsg(4,"Seeking attribute $attrib->{attribute} value by issuing command: show interfaces\n");
				$attrib->{debugMsg} = 1;
			}
			my ($ok, $outref) = $self->cmdPrivExec($pkgsub, undef, 'show interfaces');
			return $self->poll_return($ok) unless $ok; # Come out if error or if not done yet in non-blocking mode
			$self->_setSlotPortAttrib($outref);
			$self->{POLL}{output_result} = $self->{$Package}{ATTRIB}{$attrib->{attribute}};
			return $self->poll_return(1);
		};
		$attrib->{attribute} eq 'stp_mode' && do {
			unless ($attrib->{debugMsg}) {
				$self->debugMsg(4,"Seeking attribute $attrib->{attribute} value by issuing command: show spanning-tree mode\n");
				$attrib->{debugMsg} = 1;
			}
			my ($ok, $outref) = $self->cmdPrivExec($pkgsub, undef, 'show spanning-tree mode');
			return $self->poll_return($ok) unless $ok; # Come out if error or if not done yet in non-blocking mode
			if ($$outref =~ /Current STP Operation Mode: (STPG|MSTP|RSTP)/) {
				$self->_setAttrib('stp_mode', lc($1));
			}
			else { # Older stackables will not know the command and only support stpg
				$self->_setAttrib('stp_mode', 'stpg');
			}
			$self->{POLL}{output_result} = $self->{$Package}{ATTRIB}{$attrib->{attribute}};
			return $self->poll_return(1);
		};
		$attrib->{attribute} eq 'mgmt_vlan' && do {
			unless ($attrib->{debugMsg}) {
				$self->debugMsg(4,"Seeking attribute $attrib->{attribute} value by issuing command: show vlan mgmt\n");
				$attrib->{debugMsg} = 1;
			}
			my ($ok, $outref) = $self->cmdPrivExec($pkgsub, undef, 'show vlan mgmt');
			return $self->poll_return($ok) unless $ok; # Come out if error or if not done yet in non-blocking mode
			$$outref =~ /Management VLAN: (\d+)/ && $self->_setAttrib('mgmt_vlan', $1);
			$self->{POLL}{output_result} = $self->{$Package}{ATTRIB}{$attrib->{attribute}};
			return $self->poll_return(1);
		};
		($attrib->{attribute} eq 'mgmt_ip' || $attrib->{attribute} eq 'oob_ip' || $attrib->{attribute} eq 'is_oob_connected') && do {
			unless ($attrib->{debugMsg}) {
				$self->debugMsg(4,"Seeking attribute $attrib->{attribute} value by issuing command: show ip\n");
				$attrib->{debugMsg} = 1;
			}
			my ($ok, $outref) = $self->cmdPrivExec($pkgsub, undef, 'show ip');
			return $self->poll_return($ok) unless $ok; # Come out if error or if not done yet in non-blocking mode
			$$outref =~ /(?:Switch|Stack) IP Address:\s+[\d\.]+\s+([\d\.]+)\s+[\d\.]+/g && $self->_setAttrib('mgmt_ip', $1);
			if ($$outref =~ /Mgmt (?:Switch|Stack) IP Address:\s+[\d\.]+\s+([\d\.]+)\s/g) {
				$self->_setAttrib('oob_ip', $1);
			}
			else { # No OOB port on this device
				$self->_setAttrib('oob_ip', undef);
			}
			$self->_setAttrib('is_oob_connected', defined $self->socket &&
				(defined $self->{$Package}{ATTRIB}{'oob_ip'} && $self->socket->peerhost eq $self->{$Package}{ATTRIB}{'oob_ip'}) ?
				1 : 0 );
			$self->{POLL}{output_result} = $self->{$Package}{ATTRIB}{$attrib->{attribute}};
			return $self->poll_return(1);
		};
		$attrib->{attribute} eq 'baudrate' && do {
			unless ($attrib->{debugMsg}) {
				$self->debugMsg(4,"Seeking attribute $attrib->{attribute} value by issuing command: show terminal\n");
				$attrib->{debugMsg} = 1;
			}
			my ($ok, $outref) = $self->poll_cmd($pkgsub, 'show terminal'); # Don't need to be in privExec for this
			return $self->poll_return($ok) unless $ok; # Come out if error or if not done yet in non-blocking mode
			if ($$outref =~ /Terminal speed: (\d+)/) {
				$self->_setAttrib('baudrate', $1);
			}
			$self->{POLL}{output_result} = $self->{$Package}{ATTRIB}{$attrib->{attribute}};
			return $self->poll_return(1);
		};
		$attrib->{attribute} eq 'max_baud' && do {
			unless ($attrib->{debugMsg}) {
				$self->debugMsg(4,"Seeking attribute $attrib->{attribute} value by issuing command: terminal speed ?\n");
				$attrib->{debugMsg} = 1;
			}
			my ($ok, $outref) = $self->poll_cmd($pkgsub, "terminal speed ?$CTRL_C"); # Don't need to be in privExec for this
			return $self->poll_return($ok) unless $ok; # Come out if error or if not done yet in non-blocking mode
			my $baudRate;
			while ($$outref =~ /^  (\d+)\s*$/mg) {
				$baudRate = $1 if !defined $baudRate || $1 > $baudRate;
			}
			$self->_setAttrib('max_baud', $baudRate);
			$self->{POLL}{output_result} = $self->{$Package}{ATTRIB}{$attrib->{attribute}};
			return $self->poll_return(1);
		};
	}
	elsif ($familyType eq $Prm{sr}) {
		$attrib->{attribute} eq 'model' && do {
			unless ($attrib->{debugMsg}) {
				$self->debugMsg(4,"Seeking attribute $attrib->{attribute} value by issuing command: show chassis\n");
				$attrib->{debugMsg} = 1;
			}
			my ($ok, $outref) = $self->poll_cmd($pkgsub, 'show chassis');
			return $self->poll_return($ok) unless $ok; # Come out if error or if not done yet in non-blocking mode
			$$outref =~ /Chassis Model: (.+)/ && $self->_setModelAttrib($1);
			$self->{POLL}{output_result} = $self->{$Package}{ATTRIB}{$attrib->{attribute}};
			return $self->poll_return(1);
		};
		($attrib->{attribute} eq 'fw_version' || $attrib->{attribute} eq 'sw_version') && do {
			unless ($attrib->{debugMsg}) {
				$self->debugMsg(4,"Seeking attribute $attrib->{attribute} value by issuing command: show version\n");
				$attrib->{debugMsg} = 1;
			}
			my ($ok, $outref) = $self->poll_cmd($pkgsub, 'show version');
			return $self->poll_return($ok) unless $ok; # Come out if error or if not done yet in non-blocking mode
			$$outref =~ /Runtime: (.+)/g && $self->_setAttrib('sw_version', $1);
			$$outref =~ /Boot: (.+?) / && $self->_setAttrib('fw_version', $1);
			$self->{POLL}{output_result} = $self->{$Package}{ATTRIB}{$attrib->{attribute}};
			return $self->poll_return(1);
		};
		($attrib->{attribute} eq 'slots' || $attrib->{attribute} eq 'ports') && do {
			if ($attrib->{stage} < 4) { # 4th stage
				unless ($attrib->{debugMsg}) {
					$self->debugMsg(4,"Seeking attribute $attrib->{attribute} value by issuing command: show interface ethernets\n");
					$attrib->{debugMsg} = 1;
				}
				my ($ok, $outref) = $self->poll_cmd($pkgsub, 'show interface ethernets');
				return $self->poll_return($ok) unless $ok; # Come out if error or if not done yet in non-blocking mode
				$self->_setSlotPortAttrib($outref);
				$attrib->{stage}++; # Move to next stage
				$attrib->{debugMsg} = 0;
			}
			unless ($attrib->{debugMsg}) {
				$self->debugMsg(4,"Seeking attribute $attrib->{attribute} value by issuing command: show module configuration all\n");
				$attrib->{debugMsg} = 1;
			}
			my ($ok, $outref) = $self->poll_cmd($pkgsub, 'show module configuration all');
			return $self->poll_return($ok) unless $ok; # Come out if error or if not done yet in non-blocking mode
			$self->_setSlotPortAttrib($outref);
			$self->{POLL}{output_result} = $self->{$Package}{ATTRIB}{$attrib->{attribute}};
			return $self->poll_return(1);
		};
		$attrib->{attribute} eq 'sysname' && do {
			unless ($attrib->{debugMsg}) {
				$self->debugMsg(4,"Seeking attribute $attrib->{attribute} value by issuing command: show hostname\n");
				$attrib->{debugMsg} = 1;
			}
			my ($ok, $outref) = $self->poll_cmd($pkgsub, 'show hostname');
			return $self->poll_return($ok) unless $ok; # Come out if error or if not done yet in non-blocking mode
			$$outref =~ /HostName: (.+)/g && $self->_setAttrib('sysname', $1);
			$self->{POLL}{output_result} = $self->{$Package}{ATTRIB}{$attrib->{attribute}};
			return $self->poll_return(1);
		};
		$attrib->{attribute} eq 'base_mac' && do {
			unless ($attrib->{debugMsg}) {
				$self->debugMsg(4,"Seeking attribute $attrib->{attribute} value by issuing command: show system configuration\n");
				$attrib->{debugMsg} = 1;
			}
			my ($ok, $outref) = $self->poll_cmd($pkgsub, 'show system configuration', 1);
			return $self->poll_return($ok) unless $ok; # Come out if error or if not done yet in non-blocking mode
			$$outref =~ /Mac Address\s+0x(.+)/g && $self->_setBaseMacAttrib($1);
			$self->{POLL}{output_result} = $self->{$Package}{ATTRIB}{$attrib->{attribute}};
			return $self->poll_return(1);
		};
	}
	elsif ($familyType eq $Prm{trpz}) {
		($attrib->{attribute} eq 'model' || $attrib->{attribute} eq 'sysname' || $attrib->{attribute} eq 'base_mac') && do {
			unless ($attrib->{debugMsg}) {
				$self->debugMsg(4,"Seeking attribute $attrib->{attribute} value by issuing command: show system\n");
				$attrib->{debugMsg} = 1;
			}
			my ($ok, $outref) = $self->poll_cmd($pkgsub, 'show system');
			return $self->poll_return($ok) unless $ok; # Come out if error or if not done yet in non-blocking mode
			$$outref =~ /Product Name:\s+(.+)/g && $self->_setModelAttrib($1);
			$$outref =~ /System Name:\s+(.+)/g && $self->_setAttrib('sysname', $1);
			$$outref =~ /System MAC:\s+(.+)/g && $self->_setBaseMacAttrib($1);
			$self->{POLL}{output_result} = $self->{$Package}{ATTRIB}{$attrib->{attribute}};
			return $self->poll_return(1);
		};
		($attrib->{attribute} eq 'fw_version' || $attrib->{attribute} eq 'sw_version') && do {
			unless ($attrib->{debugMsg}) {
				$self->debugMsg(4,"Seeking attribute $attrib->{attribute} value by issuing command: show version\n");
				$attrib->{debugMsg} = 1;
			}
			my ($ok, $outref) = $self->poll_cmd($pkgsub, 'show version');
			return $self->poll_return($ok) unless $ok; # Come out if error or if not done yet in non-blocking mode
			$$outref =~ /Version: (.+?) REL/g && $self->_setAttrib('sw_version', $1);
			$$outref =~ /BootLoader:\s+(.+)/ && $self->_setAttrib('fw_version', $1);
			$self->{POLL}{output_result} = $self->{$Package}{ATTRIB}{$attrib->{attribute}};
			return $self->poll_return(1);
		};
		($attrib->{attribute} eq 'slots' || $attrib->{attribute} eq 'ports') && do {
			unless ($attrib->{debugMsg}) {
				$self->debugMsg(4,"Seeking attribute $attrib->{attribute} value by issuing command: show port status\n");
				$attrib->{debugMsg} = 1;
			}
			my ($ok, $outref) = $self->poll_cmd($pkgsub, 'show port status');
			return $self->poll_return($ok) unless $ok; # Come out if error or if not done yet in non-blocking mode
			$self->_setSlotPortAttrib($outref);
			$self->{POLL}{output_result} = $self->{$Package}{ATTRIB}{$attrib->{attribute}};
			return $self->poll_return(1);
		};
	}
	elsif ($familyType eq $Prm{xlr}) {
		($attrib->{attribute} eq 'model' || $attrib->{attribute} eq 'fw_version' || $attrib->{attribute} eq 'sw_version')&& do {
			unless ($attrib->{debugMsg}) {
				$self->debugMsg(4,"Seeking attribute $attrib->{attribute} value by issuing command: show config\n");
				$attrib->{debugMsg} = 1;
			}
			my ($ok, $outref) = $self->poll_cmd($pkgsub, 'show config', 1);
			return $self->poll_return($ok) unless $ok; # Come out if error or if not done yet in non-blocking mode
			$$outref =~ /# box type\s+: (.+)/g && $self->_setModelAttrib($1);
			$$outref =~ /# boot monitor version\s+: v?(.+)/g && $self->_setAttrib('fw_version', $1);
			$$outref =~ /# software version\s+: v?(.+)/g && $self->_setAttrib('sw_version', $1);
			$self->{POLL}{output_result} = $self->{$Package}{ATTRIB}{$attrib->{attribute}};
			return $self->poll_return(1);
		};
		($attrib->{attribute} eq 'is_dual_cpu' || $attrib->{attribute} eq 'sysname') && do {
			unless ($attrib->{debugMsg}) {
				$self->debugMsg(4,"Seeking attribute $attrib->{attribute} value by issuing command: show sys info\n");
				$attrib->{debugMsg} = 1;
			}
			my ($ok, $outref) = $self->poll_cmd($pkgsub, 'show sys info', 3);
			return $self->poll_return($ok) unless $ok; # Come out if error or if not done yet in non-blocking mode
			$$outref =~ /SysDescr\s+: (.+?) \(/g && $self->_setModelAttrib($1);
			$$outref =~ /SysName\s+: (.+)/g && $self->_setAttrib('sysname', $1);
			if ($$outref =~ /CPU.+ dormant /) {
				$self->_setAttrib('is_dual_cpu', 1);
			}
			else {
				$self->_setAttrib('is_dual_cpu', 0);
			}
			$self->{POLL}{output_result} = $self->{$Package}{ATTRIB}{$attrib->{attribute}};
			return $self->poll_return(1);
		};
		($attrib->{attribute} eq 'slots' || $attrib->{attribute} eq 'ports') && do {
			unless ($attrib->{debugMsg}) {
	 			$self->debugMsg(4,"Seeking attribute $attrib->{attribute} value by issuing command: show ports info arp\n");
				$attrib->{debugMsg} = 1;
			}
			my ($ok, $outref) = $self->poll_cmd($pkgsub, 'show ports info arp');
			return $self->poll_return($ok) unless $ok; # Come out if error or if not done yet in non-blocking mode
			$self->_setSlotPortAttrib($outref);
			$self->{POLL}{output_result} = $self->{$Package}{ATTRIB}{$attrib->{attribute}};
			return $self->poll_return(1);
		};
	}
	elsif ($familyType eq $Prm{xirrus}) {
		($attrib->{attribute} eq 'model' || $attrib->{attribute} eq 'base_mac' ||
		 $attrib->{attribute} eq 'fw_version' || $attrib->{attribute} eq 'sw_version')&& do {
			unless ($attrib->{debugMsg}) {
				$self->debugMsg(4,"Seeking attribute $attrib->{attribute} value by issuing command: show system-info\n");
				$attrib->{debugMsg} = 1;
			}
			my ($ok, $outref) = $self->poll_cmd($pkgsub, 'show system-info');
			return $self->poll_return($ok) unless $ok; # Come out if error or if not done yet in non-blocking mode
			$$outref =~ /Model: (.+?),/g && $self->_setModelAttrib($1);
			$$outref =~ /IAPs\s+(.+?)-/g && $self->_setBaseMacAttrib($1);
			$$outref =~ /Boot Loader\s+(.+?) \(.+?\), Build: (.+)/g && $self->_setAttrib('fw_version', "$1-$2");
			$$outref =~ /System Software\s+(.+?) \(.+?\), Build: (.+)/g && $self->_setAttrib('sw_version', "$1-$2");
			$self->{POLL}{output_result} = $self->{$Package}{ATTRIB}{$attrib->{attribute}};
			return $self->poll_return(1);
		};
		($attrib->{attribute} eq 'sysname') && do {
			unless ($attrib->{debugMsg}) {
				$self->debugMsg(4,"Seeking attribute $attrib->{attribute} value by issuing command: show contact-info\n");
				$attrib->{debugMsg} = 1;
			}
			my ($ok, $outref) = $self->poll_cmd($pkgsub, 'show contact-info');
			return $self->poll_return($ok) unless $ok; # Come out if error or if not done yet in non-blocking mode
			$$outref =~ /Access Point Hostname\s*(.+)/g && $self->_setAttrib('sysname', $1);
			$self->{POLL}{output_result} = $self->{$Package}{ATTRIB}{$attrib->{attribute}};
			return $self->poll_return(1);
		};
		($attrib->{attribute} eq 'slots' || $attrib->{attribute} eq 'ports') && do {
			unless ($attrib->{debugMsg}) {
	 			$self->debugMsg(4,"Seeking attribute $attrib->{attribute} value by issuing command: show ethernet\n");
				$attrib->{debugMsg} = 1;
			}
			my ($ok, $outref) = $self->poll_cmd($pkgsub, 'show ethernet');
			return $self->poll_return($ok) unless $ok; # Come out if error or if not done yet in non-blocking mode
			$self->_setSlotPortAttrib($outref);
			$self->{POLL}{output_result} = $self->{$Package}{ATTRIB}{$attrib->{attribute}};
			return $self->poll_return(1);
		};
	}
	return $self->poll_return(1); # Undefined output_result for unrecognized attributes
}


sub poll_change_baudrate { # Method to handle change_baudrate for poll methods (used for both blocking & non-blocking modes)
	my $self = shift;
	my $pkgsub = shift;
	my $pollsub = "${Package}::change_baudrate";

	unless ($self->{POLLING}) { # Sanity check
		my (undef, $fileName, $lineNumber) = caller;
		croak "$pollsub (called from $fileName line $lineNumber) can only be used within polled methods";
	}

	unless (defined $self->{POLL}{$pollsub}) { # Only applicable if called from another method already in polling mode
		my @validArgs = ('baudrate', 'timeout', 'errmode', 'forcebaud');
		my %args = parseMethodArgs($pkgsub, \@_, \@validArgs, 1);
		if (@_ && !%args) { # Legacy syntax
			($args{baudrate}, $args{timeout}, $args{errmode}) = @_;
		}
		# In which case we need to setup the poll structure for them here (the main poll structure remains unchanged)
		$self->{POLL}{$pollsub} = { # Populate structure with method arguments/storage
			# Set method argument keys
			baudrate		=>	$args{baudrate},
			parity			=>	undef,
			databits		=>	undef,
			stopbits		=>	undef,
			handshake		=>	undef,
			forcebaud		=>	$args{forcebaud},
			local_side_only		=>	0, # For that functionality, just call Control::CLI's poll_change_baudrate
			# Declare method storage keys which will be used
			stage			=>	0,
			userExec		=>	undef,
			privExec		=>	undef,
			maxMode			=>	$args{baudrate} eq 'max' ? 1:0,
			# Declare keys to be set if method called from another polled method
			errmode			=>	$args{errmode},
		};
		# Cache poll structure keys which this method will use
		$self->poll_struct_cache($pollsub, $args{timeout});
	}
	my $changeBaud = $self->{POLL}{$pollsub};
	local $self->{errmode} = $changeBaud->{errmode} if defined $changeBaud->{errmode};
	my $familyType = $self->{$Package}{ATTRIB}{'family_type'} || '';

	if ($changeBaud->{local_side_only}) { # Same functionality as Control::CLI::change_baudrate()
		my $ok = $self->SUPER::poll_change_baudrate($pkgsub,
			BaudRate	=> $changeBaud->{baudrate},
			Parity		=> $changeBaud->{parity},
			DataBits	=> $changeBaud->{databits},
			StopBits	=> $changeBaud->{stopbits},
			Handshake	=> $changeBaud->{handshake},
			ForceBaud	=> $changeBaud->{forcebaud},
		);
		return $self->poll_return($ok); # Come out if error (if errmode='return'), or if nothing to read in non-blocking mode, or completed
	}

	if ($changeBaud->{stage} < 1) { # 1st stage
		unless ($self->connection_type eq 'SERIAL') {
			return $self->poll_return($self->error("$pkgsub: Cannot change baudrate on Telnet/SSH"));
		}
		unless (defined $self->baudrate) { # If no active connection come out
			return $self->poll_return($self->error("$pkgsub: No serial connection established yet"));
		}
		unless (defined $changeBaud->{baudrate}) {
			return $self->poll_return($self->error("$pkgsub: No baudrate specified!"));
		}
		unless ($familyType) {
			return $self->poll_return($self->error("$pkgsub: Family type of remote device is not detected"));
		}
		$changeBaud->{stage}++; # Move to 2nd stage
	}

	if ($changeBaud->{stage} < 2) { # 2nd stage
		unless (defined $self->{$Package}{ATTRIB}{'baudrate'}) { # Make sure this attribute is set
			my $ok = $self->poll_attribute($pkgsub, 'baudrate');
			return $self->poll_return($ok) unless $ok;
		}
		unless (defined $self->{$Package}{ATTRIB}{'baudrate'}) {
			return $self->poll_return($self->error("$pkgsub: Baudrate cannot be changed on device")) unless $changeBaud->{maxMode};
			$self->debugMsg(4,"ChangeBaudrate: baudrate attrib undefined - maxMode return success\n");
			$self->{POLL}{output_result} = $changeBaud->{baudrate};
			return $self->poll_return(1);	# Can't maximize baudrate, but no error in maxMode
		}
		unless (defined $self->{$Package}{ATTRIB}{'max_baud'}) { # Make sure this attribute is set
			my $ok = $self->poll_attribute($pkgsub, 'max_baud');
			return $self->poll_return($ok) unless $ok;
		}
		if ($changeBaud->{maxMode} && !defined $self->{$Package}{ATTRIB}{'max_baud'}) {
			$self->debugMsg(4,"ChangeBaudrate: max_baud attrib undefined - maxMode return success\n");
			$self->{POLL}{output_result} = $changeBaud->{baudrate};
			return $self->poll_return(1);	# Can't maximize baudrate, but no error in maxMode
		}
		$changeBaud->{baudrate} = $self->{$Package}{ATTRIB}{'max_baud'} if $changeBaud->{maxMode};

		if ($changeBaud->{baudrate} == $self->baudrate) { # Desired baudrate is already set
			$self->{POLL}{output_result} = $changeBaud->{baudrate};
			return $self->poll_return(1);
		}

		# Now, depending on family type of connected device, ensure we change the baud rate on the device first
		if ($familyType eq $Prm{generic}) {
			return $self->poll_return($self->error("$pkgsub: Unable to complete on $Prm{generic} family_type device"));
		}
		elsif ($familyType eq $Prm{bstk}) {
			unless ($changeBaud->{baudrate} == 9600 || $changeBaud->{baudrate} == 19200 || $changeBaud->{baudrate} == 38400) {
				return $self->poll_return($self->error("$pkgsub: Supported baud rates for $Prm{bstk} = 9600, 19200, 38400"));
			}
		}
		elsif ($familyType eq $Prm{pers}) {
			unless ($changeBaud->{baudrate} == 9600 || $changeBaud->{baudrate} == 19200 || $changeBaud->{baudrate} == 38400 ||
				$changeBaud->{baudrate} == 57600 || $changeBaud->{baudrate} == 115200) {
				return $self->poll_return($self->error("$pkgsub: Supported baud rates for $Prm{pers} = 9600, 19200, 38400, 57600, 115200"));
			}
		}
		else { # Other Avaya family types not supported
			return $self->poll_return($self->error("$pkgsub: Only supported on $Prm{pers} and $Prm{bstk} family_type")) unless $changeBaud->{maxMode};
			$self->debugMsg(4,"ChangeBaudrate: Not $Prm{pers} or $Prm{bstk} family_type - maxMode return success\n");
			$self->{POLL}{output_result} = $changeBaud->{baudrate};
			return $self->poll_return(1);	# Can't maximize baudrate, but no error in maxMode
		}
		$changeBaud->{stage}++; # Move to 3rd stage
	}

	if ($changeBaud->{stage} < 3) { # 3rd stage
		if ($familyType eq $Prm{pers}) {
			unless (defined $self->{$Package}{ATTRIB}{'model'}) { # Make sure this attribute is set
				my $ok = $self->poll_attribute($pkgsub, 'model');
				return $self->poll_return($ok) unless $ok;
			}
			if ($changeBaud->{userExec} = $self->last_prompt =~ />\s?$/) {
				my $ok = $self->poll_enable($pkgsub);
				return $self->poll_return($ok) unless $ok; # Come out if error or if not done yet in non-blocking mode
			}
		}
		$changeBaud->{stage}++; # Move to 4th stage
	}

	if ($changeBaud->{stage} < 4) { # 4th stage
		if ($familyType eq $Prm{pers} && $self->{$Package}{ATTRIB}{'is_nncli'}) {
			if ($changeBaud->{privExec} = $self->last_prompt !~ /\(config/) {
				my ($ok, undef, $resref) = $self->poll_cmd($pkgsub, 'config term');
				return $self->poll_return($ok) unless $ok; # Come out if error or if not done yet in non-blocking mode
				return $self->poll_return($self->error("$pkgsub: Unable to set new baud rate on device")) unless $$resref;
			}
		}
		$changeBaud->{stage}++; # Move to 5th stage
	}

	if ($changeBaud->{stage} < 5) { # 5th stage
		if ($familyType eq $Prm{bstk}) {
			$self->print(line => "terminal speed $changeBaud->{baudrate}", errmode => 'return')
				or return $self->poll_return($self->error("$pkgsub: Unable to set new baud rate on device // ".$self->errmsg));
		}
		elsif ($familyType eq $Prm{pers}) {
			if ($self->{$Package}{ATTRIB}{'model'}  =~ /(?:Passport|ERS)-(?:83|16)\d\d/) { # 8300 & 1600
				if ($self->{$Package}{ATTRIB}{'is_nncli'}) {
					$self->print(line => "boot config sio baud $changeBaud->{baudrate}", errmode => 'return')
						or return $self->poll_return($self->error("$pkgsub: Unable to set new baud rate on device // ".$self->errmsg));
				}
				else {
					$self->print(line => "config bootconfig sio baud $changeBaud->{baudrate}", errmode => 'return')
						or return $self->poll_return($self->error("$pkgsub: Unable to set new baud rate on device // ".$self->errmsg));
				}
			}
			else { # All other PassportERS devices
				if ($self->{$Package}{ATTRIB}{'is_nncli'}) {
					$self->print(line => "boot config sio console baud $changeBaud->{baudrate}", errmode => 'return')
						or return $self->poll_return($self->error("$pkgsub: Unable to set new baud rate on device // ".$self->errmsg));
				}
				else {
					$self->print(line => "config bootconfig sio console baud $changeBaud->{baudrate}", errmode => 'return')
						or return $self->poll_return($self->error("$pkgsub: Unable to set new baud rate on device // ".$self->errmsg));
				}
			}
		}
		$self->debugMsg(4,"ChangeBaudrate: set device to ", \$changeBaud->{baudrate}, "\n");
		$changeBaud->{stage}++; # Move to 6th stage
	}

	if ($changeBaud->{stage} < 6) { # 6th stage
		my $ok = $self->poll_readwait($pkgsub, 0);
		return $self->poll_return($ok) unless $ok; # Come out if error, or if nothing to read in non-blocking mode
		if (length $self->{POLL}{read_buffer} && $self->{POLL}{read_buffer} =~ /$self->{$Package}{prompt_qr}/) {
			# This is a failure, as it would imply that we can see a prompt back, even though we changed the baudrate on the device
			return $self->poll_return($self->error("$pkgsub: Baudrate change had no effect on device; still at $self->baudrate baud")) unless $changeBaud->{maxMode};
			$self->debugMsg(4,"ChangeBaudrate: Baudrate change had no effect on device - maxMode return success\n");
			$self->{POLL}{output_result} = $self->baudrate;
			return $self->poll_return(1);	# Can't maximize baudrate, but no error in maxMode
		}
		if (defined $self->{$Package}{ORIGBAUDRATE}) { # Clear note following restore
			$self->{$Package}{ORIGBAUDRATE} = undef if $self->{$Package}{ORIGBAUDRATE} == $changeBaud->{baudrate};
		}
		else { # 1st time this method is run, make a note of original baudrate (needed in DESTROY)
			$self->{$Package}{ORIGBAUDRATE} = $self->baudrate;
		}
		$changeBaud->{stage}++; # Move to 7th stage
	}

	if ($changeBaud->{stage} < 7) { # 7th stage
		my $ok = $self->SUPER::poll_change_baudrate($pkgsub,
			BaudRate	=> $changeBaud->{baudrate},
			ForceBaud	=> $changeBaud->{forcebaud},
		);
		return $self->poll_return($ok) unless $ok; # Come out if error (if errmode='return'), or if nothing to read in non-blocking mode
		$self->debugMsg(4,"ChangeBaudrate: changed local serial port to ", \$changeBaud->{baudrate}, "\n");
		$self->_setAttrib('baudrate', $changeBaud->{baudrate});	# Adjust the attribute as we are sure we changed it now
		$changeBaud->{stage}++; # Move to 8th stage
	}

	if ($changeBaud->{stage} < 8) { # 8th stage
		my $ok = $self->poll_cmd($pkgsub, ''); # Send carriage return + ensure we get valid prompt back
		return $self->poll_return($ok) unless $ok; # Come out if error or if not done yet in non-blocking mode
		$changeBaud->{stage}++; # Move to 9th stage
	}

	if ($changeBaud->{stage} < 9) { # 9th stage
		if ($familyType eq $Prm{pers} && $self->{$Package}{ATTRIB}{'is_nncli'}) {
			if ($changeBaud->{privExec}) {
				my ($ok, undef, $resref) = $self->poll_cmd($pkgsub, 'exit');
				return $self->poll_return($ok) unless $ok; # Come out if error or if not done yet in non-blocking mode
				return $self->poll_return($self->error("$pkgsub: Error while changing baud rate")) unless $$resref;
			}
		}
		$changeBaud->{stage}++; # Move to 10th stage
	}

	if ($changeBaud->{stage} < 10) { # 10th stage
		if ($familyType eq $Prm{pers} && $self->{$Package}{ATTRIB}{'is_nncli'}) {
			if ($changeBaud->{userExec}) {
				my ($ok, undef, $resref) = $self->poll_cmd($pkgsub, 'disable');
				return $self->poll_return($ok) unless $ok; # Come out if error or if not done yet in non-blocking mode
				return $self->poll_return($self->error("$pkgsub: Error while changing baud rate")) unless $$resref;
			}
		}
	}
	$self->{POLL}{output_result} = $changeBaud->{baudrate};
	return $self->poll_return(1);
}


sub poll_enable { # Method to handle enable for poll methods (used for both blocking & non-blocking modes)
	my $self = shift;
	my $pkgsub = shift;
	my $pollsub = "${Package}::enable";

	unless ($self->{POLLING}) { # Sanity check
		my (undef, $fileName, $lineNumber) = caller;
		croak "$pollsub (called from $fileName line $lineNumber) can only be used within polled methods";
	}

	unless (defined $self->{POLL}{$pollsub}) { # Only applicable if called from another method already in polling mode
		my @validArgs = ('password', 'prompt_credentials', 'timeout', 'errmode');
		my %args = parseMethodArgs($pkgsub, \@_, \@validArgs, 1);
		if (@_ && !%args) { # Legacy syntax
			($args{password}, $args{prompt_credentials}, $args{timeout}, $args{errmode}) = @_;
		}
		# In which case we need to setup the poll structure for them here (the main poll structure remains unchanged)
		$self->{POLL}{$pollsub} = { # Populate structure with method arguments/storage
			# Set method argument keys
			enable_password		=>	defined $args{password} ? $args{password} : $self->{$Package}{ENABLEPWD},
			prompt_credentials	=>	defined $args{prompt_credentials} ? $args{prompt_credentials} : $self->{prompt_credentials},
			# Declare method storage keys which will be used
			stage			=>	0,
			login_attempted		=>	undef,
			login_failed		=>	undef,
			# Declare keys to be set if method called from another polled method
			errmode			=>	$args{errmode},
		};
		# Cache poll structure keys which this method will use
		$self->poll_struct_cache($pollsub, $args{timeout});
	}
	my $enable = $self->{POLL}{$pollsub};
	local $self->{errmode} = $enable->{errmode} if defined $enable->{errmode};
	return $self->poll_return($self->error("$pkgsub: No connection to enable")) if $self->eof;
	my $familyType = $self->{$Package}{ATTRIB}{'family_type'} || '';
	my $prompt = $self->{$Package}{prompt_qr};
	my $passwordPrompt = $self->{password_prompt_qr};
	my $enablePwd;

	if ($enable->{stage} < 1) { # 1st stage
		$enable->{stage}++; # Ensure we don't come back here in non-blocking mode
		return $self->poll_return($self->error("$pkgsub: No connection established")) unless $familyType;
		return $self->poll_return(1) unless $self->{$Package}{ATTRIB}{'is_nncli'}; # Come out if not in NNCLI mode
		return $self->poll_return(1) unless $self->last_prompt =~ />\s?$/; # Come out if not in UserExec mode
		# Flush any unread data which might be pending
		$self->read(blocking => 0);
		# Send enable command
		$self->print(line => 'enable', errmode => 'return')
			or return $self->poll_return($self->error("$pkgsub: Unable to send CLI command: enable // ".$self->errmsg));
	}

	# Main loop
	do {
		my $ok = $self->poll_read($pkgsub, 'Failed after enable command');
		return $self->poll_return($ok) unless $ok;

		$self->{POLL}{local_buffer} .= $self->{POLL}{read_buffer};
		$enable->{login_failed}++ if $self->{POLL}{local_buffer} =~ /error: Access denied/;
		if ($self->{POLL}{local_buffer} =~ /$passwordPrompt/) { # Handle password prompt
			$enable->{login_attempted}++;
			if (defined $enable->{enable_password}) { # An enable password is supplied
				if ($enable->{login_attempted} == 1) {	# First try; use supplied
					$enablePwd = $enable->{enable_password};
					$self->debugMsg(4,"enable() Sending supplied password\n");
					$self->print(line => $enablePwd, errmode => 'return')
						or return $self->poll_return($self->error("$pkgsub: Unable to send enable password // ".$self->errmsg));
				}
				else {				# Next tries, enter blanks
					$enablePwd = '';
					$self->debugMsg(4,"enable() Sending carriage return instead of supplied password\n");
					$self->print(errmode => 'return')
						or return $self->poll_return($self->error("$pkgsub: Unable to send blank password // ".$self->errmsg));
				}
			}
			else { # No password supplied
				if ($enable->{login_attempted} == 1) {	# First try; use blank
					$enablePwd = '';
					$self->debugMsg(4,"enable() Sending carriage return for password\n");
					$self->print(errmode => 'return')
						or return $self->poll_return($self->error("$pkgsub: Unable to send blank password // ".$self->errmsg));
				}
				elsif ($enable->{login_attempted} == 2) {	# Second try; use cached login password
					$enablePwd = $self->password || '';
					$self->debugMsg(4,"enable() Sending login password for enable password\n");
					$self->print(line => $enablePwd, errmode => 'return')
						or return $self->poll_return($self->error("$pkgsub: Unable to send cached password // ".$self->errmsg));
				}
				else {				# Third try; prompt?
					if ($enable->{prompt_credentials}) {
						$enablePwd = promptCredential($enable->{prompt_credentials}, 'Hide', 'Enable Password');
						$self->print(line => $enablePwd, errmode => 'return')
							or return $self->poll_return($self->error("$pkgsub: Unable to send enable password // ".$self->errmsg));
					}
					else {			# Enter blanks
						$enablePwd = '';
						$self->debugMsg(4,"enable() Sending carriage return instead of prompting for password\n");
						$self->print(errmode => 'return')
							or return $self->poll_return($self->error("$pkgsub: Unable to send blank password // ".$self->errmsg));
					}
				}
			}
			$self->{POLL}{local_buffer} = '';
		}
	} until ($self->{POLL}{local_buffer} =~ /($prompt)/);
	$self->{$Package}{CONFIGCONTEXT} = $2;
	($self->{LASTPROMPT} = $1) =~ s/$LastPromptClense//o; # Remove initial carriage return if there
	return $self->poll_return($self->error("$pkgsub: Password required")) if $enable->{login_failed};
	return $self->poll_return($self->error("$pkgsub: Failed to enter PrivExec mode")) if $self->last_prompt =~ />\s?$/; # If still in UserExec mode
	$self->{$Package}{ENABLEPWD} = $enablePwd if defined $enablePwd;
	return $self->poll_return(1);
}


sub poll_device_more_paging { # Method to handle device_more_paging for poll methods (used for both blocking & non-blocking modes)
	my $self = shift;
	my $pkgsub = shift;
	my $pollsub = "${Package}::device_more_paging";

	unless ($self->{POLLING}) { # Sanity check
		my (undef, $fileName, $lineNumber) = caller;
		croak "$pollsub (called from $fileName line $lineNumber) can only be used within polled methods";
	}

	unless (defined $self->{POLL}{$pollsub}) { # Only applicable if called from another method already in polling mode
		my @validArgs = ('enable', 'timeout', 'errmode');
		my %args = parseMethodArgs($pkgsub, \@_, \@validArgs, 1);
		if (@_ && !%args) { # Legacy syntax
			($args{enable}, $args{timeout}, $args{errmode}) = @_;
		}
		# In which case we need to setup the poll structure for them here (the main poll structure remains unchanged)
		$self->{POLL}{$pollsub} = { # Populate structure with method arguments/storage
			# Set method argument keys
			enable			=>	$args{enable},
			# Declare method storage keys which will be used
			stage			=>	0,
			cmdString		=>	undef,
			# Declare keys to be set if method called from another polled method
			errmode			=>	$args{errmode},
		};
		# Cache poll structure keys which this method will use
		$self->poll_struct_cache($pollsub, $args{timeout});
	}
	my $devMorePage = $self->{POLL}{$pollsub};
	local $self->{errmode} = $devMorePage->{errmode} if defined $devMorePage->{errmode};
	return $self->poll_return($self->error("$pkgsub: No connection to set more paging on")) if $self->eof;
	my $familyType = $self->{$Package}{ATTRIB}{'family_type'} || '';

	return $self->poll_return($self->error("$pkgsub: No connection established")) unless $familyType;
	if ($familyType eq $Prm{bstk}) {
		$devMorePage->{cmdString} = $devMorePage->{enable} ? 23 : 0 unless defined $devMorePage->{cmdString};
		my ($ok, undef, $resref) = $self->poll_cmd($pkgsub, "terminal length $devMorePage->{cmdString}");
		return $self->poll_return($ok) unless $ok;
		return $self->poll_return($self->error("$pkgsub: Failed to set more-paging mode")) unless $$resref;
	}
	elsif ($familyType eq $Prm{pers} || $familyType eq $Prm{xlr}) {
		if ($self->{$Package}{ATTRIB}{'is_nncli'}) { # NNCLI
			if ($devMorePage->{stage} < 1) {
				unless (defined $self->{$Package}{ATTRIB}{'model'}) { # This attribute may not yet be set
					my $ok = $self->poll_attribute($pkgsub, 'model');
					return $self->poll_return($ok) unless $ok;
				}
				if (defined $self->{$Package}{ATTRIB}{'model'} && $self->{$Package}{ATTRIB}{'model'} =~ /(?:Passport|ERS)-83\d\d/) { # 8300 NNCLI
					$devMorePage->{stage} += 2; # Go to section after next
				}
				else { # NNCLI on 8600 or VSP (or if 'model' is not defined we could be on a Standby CPU of 8600 or VSP or 8300..)
					$devMorePage->{stage}++; # Go to next section
				}
			}
			if ($devMorePage->{stage} < 2) { # NNCLI on 8600 or VSP (or if 'model' is not defined we could be on a Standby CPU of 8600 or VSP or 8300..)
				$devMorePage->{cmdString} = $devMorePage->{enable} ? 'enable' : 'disable' unless defined $devMorePage->{cmdString};
				my ($ok, undef, $resref) = $self->poll_cmd($pkgsub, "terminal more $devMorePage->{cmdString}");
				return $self->poll_return($ok) unless $ok;
				return $self->poll_return($self->error("$pkgsub: Failed to set more-paging mode")) if !$$resref && defined $self->{$Package}{ATTRIB}{'model'};
				$devMorePage->{stage}++; # Go to next section (8300) if we failed here and 'model' attrib not defined
				$devMorePage->{stage}++ if $$resref; # Skip next section if we succeded
				$devMorePage->{cmdString} = undef;
			}
			if ($devMorePage->{stage} < 3) { # 8300 NNCLI
				$devMorePage->{cmdString} = $devMorePage->{enable} ? '' : 'no ' unless defined $devMorePage->{cmdString};
				my ($ok, undef, $resref) = $self->cmdConfig($pkgsub, '', "$devMorePage->{cmdString}more");
				return $self->poll_return($ok) unless $ok;
				return $self->poll_return($self->error("$pkgsub: Failed to set more-paging mode")) unless $$resref;
			}
		}
		else { # CLI
			$devMorePage->{cmdString} = $devMorePage->{enable} ? 'true' : 'false' unless defined $devMorePage->{cmdString};
			my ($ok, undef, $resref) = $self->poll_cmd($pkgsub, "config cli more $devMorePage->{cmdString}");
			return $self->poll_return($ok) unless $ok;
			return $self->poll_return($self->error("$pkgsub: Failed to set more-paging mode")) unless $$resref;
		}
	}
	elsif ($familyType eq $Prm{sr}) {
		$devMorePage->{cmdString} = $devMorePage->{enable} ? 23 : 0 unless defined $devMorePage->{cmdString};
		my ($ok, undef, $resref) = $self->cmdConfig($pkgsub, '', "terminal length $devMorePage->{cmdString}");
		return $self->poll_return($ok) unless $ok;
		return $self->poll_return($self->error("$pkgsub: Failed to set more-paging mode")) unless $$resref;
	}
	elsif ($familyType eq $Prm{trpz}) {
		$devMorePage->{cmdString} = $devMorePage->{enable} ? 23 : 0 unless defined $devMorePage->{cmdString};
		my ($ok, undef, $resref) = $self->poll_cmd($pkgsub, "set length $devMorePage->{cmdString}");
		return $self->poll_return($ok) unless $ok;
		return $self->poll_return($self->error("$pkgsub: Failed to set more-paging mode")) unless $$resref;
	}
	elsif ($familyType eq $Prm{xirrus}) {
		$devMorePage->{cmdString} = $devMorePage->{enable} ? 'enable' : 'disable' unless defined $devMorePage->{cmdString};
		my ($ok, undef, $resref) = $self->poll_cmd($pkgsub, "more $devMorePage->{cmdString}");
		return $self->poll_return($ok) unless $ok;
		return $self->poll_return($self->error("$pkgsub: Failed to set more-paging mode")) unless $$resref;
	}
	else {
		return $self->poll_return($self->error("$pkgsub: Cannot configure more paging on family type $familyType"));
	}
	return $self->poll_return(1);
}


sub poll_device_peer_cpu { # Method to handle device_peer_cpu for poll methods (used for both blocking & non-blocking modes)
	my $self = shift;
	my $pkgsub = shift;
	my $pollsub = "${Package}::device_peer_cpu";

	unless ($self->{POLLING}) { # Sanity check
		my (undef, $fileName, $lineNumber) = caller;
		croak "$pollsub (called from $fileName line $lineNumber) can only be used within polled methods";
	}

	unless (defined $self->{POLL}{$pollsub}) { # Only applicable if called from another method already in polling mode
		my @validArgs = ('username', 'password', 'prompt_credentials', 'timeout', 'errmode');
		my %args = parseMethodArgs($pkgsub, \@_, \@validArgs, 1);
		if (@_ && !%args) { # Legacy syntax
			($args{username}, $args{password}, $args{prompt_credentials}, $args{timeout}, $args{errmode}) = @_;
		}
		# In which case we need to setup the poll structure for them here (the main poll structure remains unchanged)
		$self->{POLL}{$pollsub} = { # Populate structure with method arguments/storage
			# Set method argument keys
			username		=>	defined $args{username} ? $args{username} : $self->username,
			password		=>	defined $args{password} ? $args{password} : $self->password,
			prompt_credentials	=>	defined $args{prompt_credentials} ? $args{prompt_credentials} : $self->{prompt_credentials},
			# Declare method storage keys which will be used
			stage			=>	0,
			# Declare keys to be set if method called from another polled method
			errmode			=>	$args{errmode},
		};
		# Cache poll structure keys which this method will use
		$self->poll_struct_cache($pollsub, $args{timeout});
	}
	my $devPeerCpu = $self->{POLL}{$pollsub};
	local $self->{errmode} = $devPeerCpu->{errmode} if defined $devPeerCpu->{errmode};
	return $self->poll_return($self->error("$pkgsub: No connection established")) if $self->eof;
	my $familyType = $self->{$Package}{ATTRIB}{'family_type'} || '';

	if ($devPeerCpu->{stage} < 1) { # 1st stage
		unless ($familyType) {
			return $self->poll_return($self->error("$pkgsub: Attribute family_type not set"));
		}
		unless ($familyType eq $Prm{pers}) {
			return $self->poll_return($self->error("$pkgsub: No peer CPU on family_type $familyType"));
		}
		unless (($devPeerCpu->{username} && $devPeerCpu->{password}) || $devPeerCpu->{prompt_credentials}) {
			return $self->poll_return($self->error("$pkgsub: Username & password required"));
		}
		$devPeerCpu->{stage}++; # Move to 2nd stage
	}

	if ($devPeerCpu->{stage} < 2) { # 2nd stage
		my $ok = $self->poll_enable($pkgsub); # If in nncli mode, need to be in PrivExec
		return $self->poll_return($ok) unless $ok;

		$self->print(line => 'peer telnet', errmode => 'return')
			or return $self->poll_return($self->error("$pkgsub: Unable to send peer telnet command // ".$self->errmsg));
		$devPeerCpu->{stage}++; # Move to 3rd stage
	}

	if ($devPeerCpu->{stage} < 3) { # 3rd stage
		my $ok = $self->poll_waitfor($pkgsub, 'Login: $', undef, 'return');
		return $self->poll_return($self->error("$pkgsub: Never got peer login prompt // ".$self->errmsg)) unless defined $ok;
		return $self->poll_return($ok) unless $ok;

		$devPeerCpu->{username} = promptCredential($devPeerCpu->{prompt_credentials}, 'Clear', 'Username') unless defined $devPeerCpu->{username};
		$self->print(line => $devPeerCpu->{username}, errmode => 'return')
			or return $self->poll_return($self->error("$pkgsub: Unable to send username // ".$self->errmsg));
		$devPeerCpu->{stage}++; # Move to 4th stage
	}

	if ($devPeerCpu->{stage} < 4) { # 4th stage
		my $ok = $self->poll_waitfor($pkgsub, 'Password: $', undef, 'return');
		return $self->poll_return($self->error("$pkgsub: Never got peer password prompt // ".$self->errmsg)) unless defined $ok;
		return $self->poll_return($ok) unless $ok;

		$devPeerCpu->{password} = promptCredential($devPeerCpu->{prompt_credentials}, 'Hide', 'Password') unless defined $devPeerCpu->{password};
		$self->print(line => $devPeerCpu->{password}, errmode => 'return')
			or return $self->poll_return($self->error("$pkgsub: Unable to send password // ".$self->errmsg));
		$devPeerCpu->{stage}++; # Move to last stage
	}

	# Use cmd() to expect a new prompt now
	my $ok = $self->poll_cmd($pkgsub, More_pages => 0, Reset_prompt => 1);
	return $self->poll_return($ok) unless $ok;

	$self->{LASTPROMPT} =~ /$InitPrompt{$self->{$Package}{PROMPTTYPE}}/;
	$self->_setAttrib('cpu_slot', $2);
	$self->_setAttrib('is_master_cpu', $self->{LASTPROMPT} =~ /^@/ ? 0 : 1);
	$self->_setAttrib('is_dual_cpu', 1) if $self->{LASTPROMPT} =~ /^@/;
	return $self->poll_return(1);
}


sub cmdPrivExec { # If nncli send command in PrivExec mode and restore mode on exit; if not nncli just sends command; used for show commands
	my ($self, $pkgsub, $cmdcli, $cmdnncli, $morePages) = @_;
	my $pollsub = "${Package}::cmdPrivExec";
	my ($ok, $outref, $resref);

	unless (defined $self->{POLL}{$pollsub}) { # Create polling structure on 1st call
		$self->{POLL}{$pollsub} = {
			stage		=>	0,
			userExec	=>	undef,
			outref		=>	undef,
			resref		=>	undef,
		};
	}
	my $cmdPrivExec = $self->{POLL}{$pollsub};

	if ($self->{$Package}{ATTRIB}{'is_nncli'}) {
		if ($cmdPrivExec->{stage} < 1) { # 1st stage
			if ($cmdPrivExec->{userExec} = $self->last_prompt =~ />\s?$/) {
				$ok = $self->poll_enable($pkgsub);
				return $ok unless $ok;
			}
			$cmdPrivExec->{stage}++; # Move to 2nd stage
		}
		if ($cmdPrivExec->{stage} < 2) { # 2nd stage
			($ok, $outref, $resref) = $self->poll_cmd($pkgsub, Command => $cmdnncli, More_pages => $morePages);
			return $ok unless $ok;
			$cmdPrivExec->{outref} = $outref;
			$cmdPrivExec->{resref} = $resref;
			$cmdPrivExec->{stage}++; # Move to 3rd stage
		}
		if ($cmdPrivExec->{stage} < 3) { # 3rd stage
			if ($cmdPrivExec->{userExec}) {
				($ok, undef, $resref) = $self->poll_cmd($pkgsub, 'disable');
				return $ok unless $ok;
				return ($ok, undef, $resref) unless $$resref;
			}
			($outref, $resref) = ($cmdPrivExec->{outref}, $cmdPrivExec->{resref});
			$self->{POLL}{$pollsub} = undef;	# Undef once completed
			return (1, $outref, $resref);
		}
	}
	else {
		($ok, $outref, $resref) = $self->poll_cmd($pkgsub, Command => $cmdcli, More_pages => $morePages);
		return $ok unless $ok;
		$self->{POLL}{$pollsub} = undef;	# Undef once completed
		return (1, $outref, $resref);
	}
}


sub cmdConfig { # If nncli send command in Config mode and restore mode on exit; if not nncli just sends command; used for config commands
	my ($self, $pkgsub, $cmdcli, $cmdnncli) = @_;
	my $pollsub = "${Package}::cmdConfig";
	my ($ok, $outref, $resref);

	unless (defined $self->{POLL}{$pollsub}) { # Create polling structure on 1st call
		$self->{POLL}{$pollsub} = {
			stage		=>	0,
			userExec	=>	undef,
			privExec	=>	undef,
			outref		=>	undef,
			resref		=>	undef,
		};
	}
	my $cmdConfig = $self->{POLL}{$pollsub};

	if ($self->{$Package}{ATTRIB}{'is_nncli'}) {
		if ($cmdConfig->{stage} < 1) { # 1st stage
			if ($cmdConfig->{userExec} = $self->last_prompt =~ />\s?$/) {
				$ok = $self->poll_enable($pkgsub);
				return $ok unless $ok;
			}
			$cmdConfig->{stage}++; # Move to 2nd stage
		}
		if ($cmdConfig->{stage} < 2) { # 2nd stage
			if ($cmdConfig->{privExec} = $self->last_prompt !~ /[\(\/]config/) { # This needs to match '(config[-if])' or SecureRouter '/configure'
				($ok, undef, $resref) = $self->poll_cmd($pkgsub, 'config term');
				return $ok unless $ok;
				return ($ok, undef, $resref) unless $$resref;
			}
			$cmdConfig->{stage}++; # Move to 3rd stage
		}
		if ($cmdConfig->{stage} < 3) { # 3rd stage
			($ok, $outref, $resref) = $self->poll_cmd($pkgsub, $cmdnncli);
			return $ok unless $ok;
			$cmdConfig->{outref} = $outref;
			$cmdConfig->{resref} = $resref;
			$cmdConfig->{stage}++; # Move to 4th stage
		}
		if ($cmdConfig->{stage} < 4) { # 4th stage
			if ($cmdConfig->{privExec}) {
				($ok, undef, $resref) = $self->poll_cmd($pkgsub, 'end');
				return $ok unless $ok;
				return ($ok, undef, $resref) unless $$resref;
			}
			$cmdConfig->{stage}++; # Move to 5th stage
		}
		if ($cmdConfig->{stage} < 5) { # 5th stage
			if ($cmdConfig->{userExec}) {
				($ok, undef, $resref) = $self->poll_cmd($pkgsub, 'disable');
				return $ok unless $ok;
				return ($ok, undef, $resref) unless $$resref;
			}
			($outref, $resref) = ($cmdConfig->{outref}, $cmdConfig->{resref});
			$self->{POLL}{$pollsub} = undef;	# Undef once completed
			return (1, $outref, $resref);
		}
	}
	else {
		$cmdcli = "config $cmdcli" unless $cmdcli =~ /^config /; # Prepend config if not already there
		($ok, $outref, $resref) = $self->poll_cmd($pkgsub, $cmdcli);
		return $ok unless $ok;
		$self->{POLL}{$pollsub} = undef;	# Undef once completed
		return (1, $outref, $resref);
	}
}


sub discoverDevice { # Issues CLI commands to host, to determine what family type it belongs to
	my ($self, $pkgsub) = @_;
	my $pollsub = "${Package}::discoverDevice";

	unless (defined $self->{POLL}{$pollsub}) { # Create polling structure on 1st call
		$self->{POLL}{$pollsub} = {
			stage		=>	0,
		};
	}
	my $discDevice = $self->{POLL}{$pollsub};

	if ($discDevice->{stage} < 1) { # Initial loginstage checking - do only once
		$discDevice->{stage}++; # Ensure we don't come back here in non-blocking mode
		$self->debugMsg(4,"\nATTEMPTING EXTENDED DISCOVERY OF HOST DEVICE !\n");

		# Output from commands below is prone to false triggers on the generic prompt;
		#  so we lock it down to the minimum length required
		$self->last_prompt =~ /(.*)([\?\$%#>]\s?)$/;
		$self->prompt(join('', ".{", length($1), ",}$2\$"));
	}

	# Prefer commands unique to platform, and with small output (not more paged)

	if ($discDevice->{stage} < 2) { # Next stage
		# BaystackERS detection command
		my ($ok, $outref) = $self->poll_cmd($pkgsub, 'show ip address');
		return $ok unless $ok;
		$discDevice->{stage}++; # Move to next stage on next cycle
		if ($$outref =~ /\s+Configured\s+In Use\s+Last BootP/) {
			$self->_setAttrib('family_type', $Prm{bstk});
			$self->_setAttrib('is_nncli', 1);
			$self->{$Package}{PROMPTTYPE} = $Prm{bstk};
			$self->debugMsg(4,"Prompt type = $self->{$Package}{PROMPTTYPE}\n\n");
			$self->{LASTPROMPT} =~ /$InitPrompt{$Prm{bstk}}/;
			$self->_setDevicePrompts($Prm{bstk}, $1);
			return (1, $Prm{bstk});
		}
	}
	if ($discDevice->{stage} < 3) { # Next stage
		# PassportERS-nncli detection command
		my ($ok, $outref) = $self->poll_cmd($pkgsub, 'show basic config');
		return $ok unless $ok;
		$discDevice->{stage}++; # Move to next stage on next cycle
		if ($$outref =~ /^\s+auto-recover-delay :/m) {
			$self->_setAttrib('family_type', $Prm{pers});
			$self->_setAttrib('is_nncli', 1);
			$self->_setAttrib('is_master_cpu', 1);
			$self->{$Package}{PROMPTTYPE} ="$Prm{pers}_nncli";
			$self->debugMsg(4,"Prompt type = $self->{$Package}{PROMPTTYPE}\n\n");
			$self->{LASTPROMPT} =~ /$InitPrompt{"$Prm{pers}_nncli"}/;
			$self->_setDevicePrompts("$Prm{pers}_nncli", $1);
			return (1, $Prm{pers});
		}
	}
	if ($discDevice->{stage} < 4) { # Next stage
		# PassportERS-cli detection command
		my ($ok, $outref) = $self->poll_cmd($pkgsub, 'show bootconfig info');
		return $ok unless $ok;
		$discDevice->{stage}++; # Move to next stage on next cycle
		if ($$outref =~ /^Version:\s+(?i:v|REL)?(.+)/m) {
			$self->_setAttrib('fw_version', $1);
			$self->_setAttrib('family_type', $Prm{pers});
			$self->_setAttrib('is_nncli', 0);
			$self->_setAttrib('is_master_cpu', 1);
			$self->{$Package}{PROMPTTYPE} = "$Prm{pers}_cli";
			$self->debugMsg(4,"Prompt type = $self->{$Package}{PROMPTTYPE}\n\n");
			$self->{LASTPROMPT} =~ /$InitPrompt{"$Prm{pers}_cli"}/;
			$self->_setDevicePrompts("$Prm{pers}_cli", $1);
			return (1, $Prm{pers});
		}
	}
	if ($discDevice->{stage} < 5) { # Next stage
		# WLAN 9100 detection command
		my ($ok, $outref) = $self->poll_cmd($pkgsub, 'show contact-info');
		return $ok unless $ok;
		$discDevice->{stage}++; # Move to next stage on next cycle
		if ($$outref =~ /^Access Point Hostname\s*(.+)$/m) {
			my $sysname = $1;
			$self->_setAttrib('family_type', $Prm{xirrus});
			$self->_setAttrib('is_nncli', 1);
			$self->_setAttrib('sysname', $sysname);
			$self->{$Package}{PROMPTTYPE} = $Prm{xirrus};
			$self->debugMsg(4,"Prompt type = $self->{$Package}{PROMPTTYPE}\n\n");
			$self->{LASTPROMPT} =~ /$InitPrompt{$Prm{xirrus}}/;
			$self->_setDevicePrompts($Prm{xirrus}, $1);
			return (1, $Prm{xirrus});
		}
	}
	if ($discDevice->{stage} < 6) { # Next stage
		# Secure Router detection command
		my ($ok, $outref) = $self->poll_cmd($pkgsub, 'show chassis');
		return $ok unless $ok;
		$discDevice->{stage}++; # Move to next stage on next cycle
		if ($$outref =~ /^Chassis Model: (.+)$/m) {
			my $model = $1;
			$self->_setAttrib('family_type', $Prm{sr});
			$self->_setAttrib('is_nncli', 1);
			$self->_setModelAttrib($model);
			$self->{$Package}{PROMPTTYPE} = $Prm{sr};
			$self->debugMsg(4,"Prompt type = $self->{$Package}{PROMPTTYPE}\n\n");
			$self->{LASTPROMPT} =~ /$InitPrompt{$Prm{sr}}/;
			$self->_setDevicePrompts($Prm{sr}, $1);
			return (1, $Prm{sr});
		}
	}
	if ($discDevice->{stage} < 7) { # Next stage
		# WLAN 2300 detection command
		my ($ok, $outref) = $self->poll_cmd($pkgsub, 'show system');
		return $ok unless $ok;
		$discDevice->{stage}++; # Move to next stage on next cycle
		if ($$outref =~ /Product Name:\s+(.+)/g) {
			my $model = $1;
			$self->_setAttrib('family_type', $Prm{trpz});
			$self->_setAttrib('is_nncli', 1);
			$self->_setModelAttrib($model);
			$$outref =~ /System Name:\s+(.+)/g && $self->_setAttrib('sysname', $1);
			$$outref =~ /System MAC:\s+(.+)/g && $self->_setBaseMacAttrib($1);
			$self->{$Package}{PROMPTTYPE} = $Prm{trpz};
			$self->debugMsg(4,"Prompt type = $self->{$Package}{PROMPTTYPE}\n\n");
			$self->{LASTPROMPT} =~ /$InitPrompt{$Prm{trpz}}/;
			$self->_setDevicePrompts($Prm{trpz}, $1);
			return (1, $Prm{trpz});
		}
	}
	if ($discDevice->{stage} < 8) { # Next stage
		# Accelar detection command
		my ($ok, $outref) = $self->poll_cmd($pkgsub, 'show sys perf');
		return $ok unless $ok;
		$discDevice->{stage}++; # Move to next stage on next cycle
		if ($$outref =~ /^\s+NVRamSize:/m) {
			$self->_setAttrib('family_type', $Prm{xlr});
			$self->_setAttrib('is_nncli', 0);
			$self->_setAttrib('is_master_cpu', 1);
			$self->{$Package}{PROMPTTYPE} = $Prm{xlr};
			$self->debugMsg(4,"Prompt type = $self->{$Package}{PROMPTTYPE}\n\n");
			$self->{LASTPROMPT} =~ /$InitPrompt{$Prm{xlr}}/;
			$self->_setDevicePrompts($Prm{xlr}, $1);
			return (1, $Prm{xlr});
		}
	}

	# We give up; set as generic device
	$self->_setAttrib('family_type', $Prm{generic});
	$self->_setAttrib('is_nncli', 0);
	$self->_setDevicePrompts($Prm{generic});
	return (1, $Prm{generic});
}


sub debugMsg { # Print a debug message
	my $self = shift;
	if (shift() & $self->{debug}) {
		my $string1 = shift();
		my $stringRef = shift() || \"";#" Ultraedit hack!
		my $string2 = shift() || "";
		if ($self->{$Package}{DEBUGLOGFH}) {
			print {$self->{$Package}{DEBUGLOGFH}} $string1, $$stringRef, $string2;
		}
		else {
			print $string1, $$stringRef, $string2;
		}
	}
	return;
}


########################################## Internal Private Methods ##########################################

sub _setDevicePrompts { # Steps to set the actual device prompt & more prompt
	my ($self, $keyType, $actualPrompt) = @_;
	my $setPrompt;

	$setPrompt = $Prompt{$keyType};
	if ($actualPrompt) { # Generic prompt will skip this
		# If Perl's metacharacters are used in the switch prompt, backslash them not to mess up prompt regex
		$actualPrompt =~ s/([\{\}\[\]\(\)\^\$\.\|\*\+\?\\])/\\$1/g;
		$setPrompt =~ s/SWITCHNAME/$actualPrompt/;
	}
	$self->prompt($setPrompt);
	$self->more_prompt($MorePrompt{$keyType}, $MorePromptDelay{$keyType});
	return;
}


sub _setSlotPortAttrib { # Set the Slot & Port attributes
	my ($self, $outref) = @_;
	my (@slots, @ports, $currentSlot);
	# Get current attribute if partly stored
	@slots = @{$self->{$Package}{ATTRIB}{'slots'}} if $self->{$Package}{ATTRIBFLAG}{'slots'};
	@ports = @{$self->{$Package}{ATTRIB}{'ports'}} if $self->{$Package}{ATTRIBFLAG}{'ports'};
	while ($$outref =~ /^(?:\s*|interface\s+ethernet|gig)?(?:(\d{1,2})\/)?(\d{1,2}(?:\/\d{1,2})?)/mg) {
		if (defined $1 && (!defined $currentSlot || $1 != $currentSlot)) { # New slot
			$currentSlot = $1;
			push(@slots, $currentSlot) unless grep {$_ eq $currentSlot} @slots;
		}
		if (defined $currentSlot) {
			push(@{$ports[$currentSlot]}, $2) unless grep {$_ eq $2} @{$ports[$currentSlot]};
		}
		else {
			push(@ports, $2) unless grep {$_ eq $2} @ports;
		}
	}
	@slots = sort {$a <=> $b} @slots; # Slots might need re-arranging on older swithes with fastEther & gigEther ports
	$self->_setAttrib('slots', \@slots);
	$self->_setAttrib('ports', \@ports);
	return;
}


sub _setModelAttrib { # Set & re-format the Model attribute
	my ($self, $model) = @_;

	$model =~ s/\s+$//; # Remove trailing spaces
	$model =~ s/^\s+//; # Remove leading spaces

	if ($self->{$Package}{ATTRIB}{'family_type'} eq $Prm{bstk}) {
		# Try and reformat the model number into something like ERS-5510
		$model =~ s/Ethernet Routing Switch /ERS-/;
		$model =~ s/Ethernet Switch /ES-/;
		$model =~ s/Business Policy Switch /BPS-/;
		$model =~ s/Wireless LAN Controller WC/WC-/;
		$model =~ s/Virtual Services Platform /VSP-/;
		$model =~ s/(-\d{3,})([A-Z])/$1-$2/;
	}
	elsif ($self->{$Package}{ATTRIB}{'family_type'} eq $Prm{pers}) {
		$model =~ s/(-\d{3,})([A-Z])/$1-$2/;
	}
	elsif ($self->{$Package}{ATTRIB}{'family_type'} eq $Prm{sr}) {
		# Try and reformat the model number into something like SR-4134
		$model =~ s/SR(\d+)/SR-$1/;		# From show chassis
		$model =~ s/Secure Router /SR-/;	# From banner
	}
	elsif ($self->{$Package}{ATTRIB}{'family_type'} eq $Prm{trpz}) {
		# Try and reformat the model number into something like WSS-2380
		$model = 'WSS-' . $model;
	}
	elsif ($self->{$Package}{ATTRIB}{'family_type'} eq $Prm{xirrus}) {
		# Try and reformat the model number into something like WAP-9132
		$model =~ s/(\D+)(\d+)/$1-$2/;		# From show chassis
	}
	elsif ($self->{$Package}{ATTRIB}{'is_apls'}) {
		# Try and reformat from DSG6248CFP to DSG-6248-CFP
		$model =~ s/^([A-Z]{3})(\d{3,})/$1-$2/;
		$model =~ s/(-\d{3,})([A-Z])/$1-$2/;
	}
	$self->_setAttrib('model', $model);

	# VOSS is a PassportERS with a VSP model name
	if ($self->{$Package}{ATTRIB}{'family_type'} eq $Prm{pers}) {
		if ($self->{$Package}{ATTRIB}{'is_apls'} || $model =~ /^VSP/) { # Requires is_apls to always be set before is_voss
			$self->_setAttrib('is_voss', 1);
		}
		else {
			$self->_setAttrib('is_voss', 0);
		}
	}
	return;
}


sub _setBoxTypeAttrib { # Set & re-format the APLS BoxType attribute
	my ($self, $boxType) = @_;

	$boxType =~ s/\s+$//; # Remove trailing spaces
	$boxType =~ s/^\s+//; # Remove leading spaces

	$boxType =~ s/^([A-Z]{3})(\d{3,})/$1-$2/;
	$boxType =~ s/(-\d{3,})([A-Z])/$1-$2/;
	$self->_setAttrib('apls_box_type', $boxType);
	return;
}


sub _setBaseMacAttrib { # Set & re-format the Base_Mac attribute
	my ($self, $mac) = @_;

	$mac =~ s/\s+$//; # Remove trailing spaces
	$mac =~ s/^\s+//; # Remove leading spaces

	# Reformat the MAC from xx:xx:xx:xx:xx:xx to xx-xx-xx-xx-xx-xx
	$mac =~ s/:/-/g;

	# Reformat the MAC from xxxxxxxxxxxx to xx-xx-xx-xx-xx-xx
	$mac =~ s/([\da-f]{2})([\da-f]{2})([\da-f]{2})([\da-f]{2})([\da-f]{2})([\da-f]{2})/$1-$2-$3-$4-$5-$6/;

	$self->_setAttrib('base_mac', $mac);
	return;
}


sub _setAttrib { # Set attribute
	my ($self, $attrib, $value) = @_;
	if ($attrib eq 'is_nncli' || $attrib eq 'is_acli') {
		$self->{$Package}{ATTRIB}{'is_nncli'} = $value;
		$self->{$Package}{ATTRIBFLAG}{'is_nncli'} = 1;
		$self->{$Package}{ATTRIB}{'is_acli'} = $value;
		$self->{$Package}{ATTRIBFLAG}{'is_acli'} = 1;
	}
	else {
		$self->{$Package}{ATTRIB}{$attrib} = $value;
		$self->{$Package}{ATTRIBFLAG}{$attrib} = 1;
	}
	if (defined $value) {
		$self->debugMsg(4,"Attribute - $attrib => $value\n");
	}
	else {
		$self->debugMsg(4,"Attribute - $attrib => undef\n");
	}
	if ($attrib eq 'family_type') {
		if (defined $Attribute{$value}) {
			$self->{$Package}{ATTRIB}{'all'} = [@{$Attribute{Global}}, @{$Attribute{$value}}];
			$self->debugMsg(4,"Attribute - all = Global + $value attributes\n");
		}
		else {
			$self->{$Package}{ATTRIB}{'all'} = $Attribute{Global};
			$self->debugMsg(4,"Attribute - all = Global only\n");
		}
		$self->{$Package}{ATTRIBFLAG}{'all'} = 1;
	}
	return;
}


sub _determineOutcome { # Determine if an error message was returned by host
	my ($self, $outref, $lastPromptEchoedCmd) = @_;
	my $familyType;

	return unless $familyType = $self->{$Package}{ATTRIB}{'family_type'};
	return if $familyType eq $Prm{generic};
	if ($$outref =~ /$ErrorPatterns{$familyType}/m) {
		(my $errmsg = $1) =~ s/\x07//g; # Suppress bell chars if any
		$self->debugMsg(4,"\ncmd() Detected error message from host:\n", \$errmsg, "\n");
		$self->{$Package}{last_cmd_errmsg} = $lastPromptEchoedCmd . $errmsg;
		return $self->{$Package}{last_cmd_success} = 0;
	}
	else {
		return $self->{$Package}{last_cmd_success} = 1;
	}
}


sub _restoreDeviceBaudrate { # Check done in disconnect and DESTROY to restore device baudrate before quiting
	my $self = shift;
	my $familyType = $self->{$Package}{ATTRIB}{'family_type'} || '';
	# If change_bauderate() was called and serial connection still up...
	if (defined $self->baudrate && defined (my $origBaud = $self->{$Package}{ORIGBAUDRATE}) ) {
		# ...try and restore original baudrate on device before quiting
		if ($familyType eq $Prm{bstk}) {
			$self->errmode('return');
			$self->put($CTRL_C);
			$self->print("terminal speed $origBaud");
		}
		elsif ($familyType eq $Prm{pers}) {
			$self->errmode('return');
			if ($self->{$Package}{ATTRIB}{'is_nncli'}) {
				$self->printlist('enable', 'config term', "boot config sio console baud $origBaud");
			}
			else {
				$self->print("config bootconfig sio console baud $origBaud");
			}
		}
	}
	return 1;
}


sub _printDot {
	local $| = 1; # Flush STDOUT buffer
	print '.';
	return;
}


1;
__END__;