Net::Telnet - interact with TELNET port or other TCP ports
SYNOPSIS
use Net::Telnet ();
see METHODS section below
DESCRIPTION
Net::Telnet allows you to make client connections to a TCP port and do
network I/O, especially to a port using the TELNET protocol. Simple
I/O methods such as print, get, and getline are provided. More
sophisticated interactive features are provided because connecting to
a TELNET port ultimately means communicating with a program designed
for human interaction. These interactive features include the ability
to specify a time-out and to wait for patterns to appear in the input
stream, such as the prompt from a shell.
Other reasons to use this module than strictly with a TELNET port are:
*
You're not familiar with sockets and you want a simple way to make
client connections to TCP services.
*
You want to be able to specify your own time-out while connecting,
reading, or writing.
*
You're communicating with an interactive program at the other end of
some socket or pipe and you want to wait for certain patterns to
appear.
Here's an example that prints who's logged-on to the remote host
sparky. In addition to a username and password, you must also know
the user's shell prompt, which for this example is bash$
Usage questions should be directed to the Usenet newsgroup
comp.lang.perl.modules.
Contact me, Jay Rogers <jay@rgrs.com>, if you find any bugs or have
suggestions for improvement.
What To Know Before Using
*
All output is flushed while all input is buffered. Each object
contains its own input buffer.
*
The output record separator for print() and cmd() is set to
"\n" by default, so that you don't have to append all your commands
with a newline. See output_record_separator() to change the
behavior.
*
The methods login() and cmd() use the prompt setting in the
object to determine when a login or remote command is complete. The
method will fail with a time-out if you don't set the prompt
correctly.
*
Use a combination of print() and waitfor() as an alternative to
login() or cmd() when they don't do what you want.
*
Errors such as timing-out are handled according to the errmode
action. The default action is to print an error message to standard
error and have the program die. See errmode() for more
information.
*
To avoid unexpected backslash interpretation, always use single quotes
instead of double quotes to construct a match operator argument for
prompt() and waitfor() (e.g. '/bash\$ $/'). If you're
constructing a DOS like file path, you'll need to use four backslashes
to represent one (e.g. '/c:\\\\users\\\\bill>$/i').
Of course don't forget about regexp metacharacters like ., [, or
$. You'll only need a single backslash to quote them. The anchor
metacharacters ^ and $ refer to positions in the input buffer.
*
In the input stream, each sequence of carriage return and line
feed (i.e. "\015\012" or CR LF) is converted to "\n". In the
output stream, each occurrence of "\n" is converted to a sequence
of CR LF. See binmode() to change the behavior. TCP protocols
typically use the ASCII sequence, carriage return and line feed to
designate a newline.
*
Timing-out while making a connection is disabled for machines that
don't support the alarm() function. Most notably these include
Win32 machines.
More universal support for connection time-outs will be in a later
release.
*
You'll need to be running at least Perl version 5.002 to use this
module. This module does not require any libraries that don't already
come with a standard Perl distribution.
If you have the IO:: libraries installed (they come standard with
perl5.004 and later) then IO::Socket::INET is used as a base class,
otherwise FileHandle is used.
*
Contact me, Jay Rogers <jay@rgrs.com>, if you find any bugs or have
suggestions for improvement.
Debugging
The typical bug causes a time-out error because you've made incorrect
assumptions about what the remote side actually sends. The easiest
way to reconcile what the remote side sends with your expectations is
to use input_log() or dump_log().
dump_log() allows you to see the data being sent from the remote
side before any translation is done, while input_log() shows you
the results after translation. The translation includes converting
end of line characters and stripping and responding to TELNET protocol
commands.
Style of Named Parameters
Two different styles of named parameters are supported. This document
only shows the IO:: style:
Net::Telnet->new(Timeout => 20);
however the dash-option style is also allowed:
Net::Telnet->new(-timeout => 20);
Connecting to a Remote Win32 Machine
By default, Windows machines don't come with a TELNET service.
However, third party TELNET servers can be acquired to provide access
to a DOS shell. As is all too familiar, many of these servers are of
inferior quality.
One particularly nasty problem is a server that sends ANSI terminal
escape sequences despite being told not to. These escape sequences
make your job of parsing the data much more difficult. You can
sometimes avoid this with a server that prompts you for console
mode. Choose no to console mode.
METHODS
In the calling sequences below, square brackets [] represent
optional parameters.
This is the constructor for Net::Telnet objects. A new object is
returned on success, the $errmode action is performed on failure -
see errmode(). The arguments are short-cuts to methods of the same
name.
If the $host argument is given then the object is opened by
connecting to TCP $port on $host. Also see open(). The new
object returned is given the following defaults in the absence of
corresponding named arguments:
The default Host is "localhost"
The default Port is 23
The default Prompt is '/[\$%#>] $/'
The default Timeout is 10
The default Errmode is "die"
The default Output_record_separator is "\n"
The default Input_record_separator is "\n"
The default Binmode is 0, which means do newline translation
The default Cmd_remove_mode is "auto".
binmode - toggle newline translation
$mode = $obj->binmode;
$prev = $obj->binmode($mode);
This method controls whether or not sequences of carriage returns and
line feeds (CR LF or more specifically "\015\012") are translated.
By default they are translated (i.e. binmode is 0).
If no argument is given, the current mode is returned.
If $mode is 1 then binmode is on and newline translation is
not done.
If $mode is 0 then binmode is off and newline translation is
done. In the input stream, each sequence of CR LF is converted to
"\n" and in the output stream, each occurrence of "\n" is
converted to a sequence of CR LF.
Note that input is always buffered. Changing binmode doesn't effect
what's already been read into the buffer. Output is not buffered and
changing binmode will have an immediate effect.
break - send TELNET break character
$ok = $obj->break;
This method sends the TELNET break character. This character is
provided because it's a signal outside the USASCII character set which
is currently given local meaning within many systems. It's intended
to indicate that the Break Key or the Attention Key was hit.
buffer - scalar reference to object's input buffer
$ref = $obj->buffer;
This method returns a scalar reference to the input buffer for
$obj. Data in the input buffer is data that has been read from the
remote side but has yet to be read by the user. Modifications to the
input buffer are returned by a subsequent read.
buffer_empty - discard all data in object's input buffer
$obj->buffer_empty;
This method removes all data in the input buffer for $obj.
close - close object
$ok = $obj->close;
This method closes the socket, file, or pipe associated with the
object.
This method sends the command $string, and reads the characters
sent back by the command up until and including the matching prompt.
It's assumed that the program to which you're sending is some kind of
command prompting interpreter such as a shell.
In a scalar context the characters read are discarded and a boolean is
returned indicating the success or failure of sending the command
string and reading the prompt. Note that in order to return on error,
errmode() must not be set to "die".
In an array context, just the output generated by the command is
returned, one line per element. In other words, all the characters in
between the echoed back command string and the prompt are returned.
If the command happens to return no output, an array containing one
element, the null string is returned. This is so the array will
indicate true in a boolean context.
Many command interpreters echo back the command sent. In most
situations, this method removes the first line returned from the
remote side (i.e. the echoed back command). See cmd_remove_mode()
for more control over this feature.
Use dump_log() to debug when this method keeps timing-out and you
don't think it should.
Consider using a combination of print() and waitfor() as an
alternative to this method when it doesn't do what you want, e.g. the
command you run prompts for input.
Optional named arguments are provided to override the current settings
of prompt, timeout, and cmd_remove_mode.
The Output named argument provides an alternative method of
receiving command output. If you pass a scalar reference, all the
output (even if it contains multiple lines) is returned in the
referenced scalar. If you pass an array or hash reference, the lines
of output are returned in the referenced array or hash.
cmd_remove_mode - toggle removal of echoed commands
$mode = $obj->cmd_remove_mode;
$prev = $obj->cmd_remove_mode($mode);
This method controls how to deal with echoed back commands in the
output returned by cmd(). Typically, when you send a command to the
remote side, the first line of output returned is the command echoed
back. Use this mode to remove the first line of output normally
returned by cmd().
If no argument is given, the current mode is returned.
If $mode is 0 then the command output returned from cmd() has no
lines removed. If $mode is a positive integer, then the first
$mode lines of command output are stripped.
By default, $mode is set to "auto". Auto means that whether or
not the first line of command output is stripped, depends on whether
or not the remote side offered to echo. By default, Net::Telnet
always accepts an offer to echo by the remote side. You can change
the default to reject such an offer using option_accept().
dump_log - log all I/O in dump format
$fh = $obj->dump_log;
$fh = $obj->dump_log($fh);
$fh = $obj->dump_log($filename);
This method starts or stops dump format logging of all the object's
input and output. The dump format shows the blocks read and written
in a hexadecimal and printable character format. This method is
useful when debugging, however you might want to first try
input_log() as it's more readable.
If no argument is given, the current log filehandle is returned. A
null string indicates logging is off.
To stop logging, use a null string as an argument.
If an open filehandle is given, it is used for logging and returned.
Otherwise, the argument is assumed to be the name of a file, the file
is opened and a filehandle to it is returned.
eof - end of file indicator
$eof = $obj->eof;
This method indicates if end of file has been read. Because the input
is buffered this isn't the same thing as $obj has closed. In other
words $obj can be closed but there still can be stuff in the buffer
to be read. Under this condition you can still read but you won't be
able to write.
errmode - define action to be performed on error
$mode = $obj->errmode;
$prev = $obj->errmode($mode);
This method gets or sets the action used when errors are encountered
using the object. The first calling sequence returns the current
error mode. The second calling sequence sets it to $mode and
returns the previous mode. Valid values for $mode are "die"
(the default), "return", a coderef, or an arrayref.
When mode is "die" and an error is encountered using the object,
then an error message is printed to standard error and the program
dies.
When mode is "return" then the method generating the error places
an error message in the object and returns the undefined value in a
scalar context and a null list in list context. The error message may
be obtained using errmsg().
When mode is a coderef, then when an error is encountered
coderef is called with the error message as its first argument.
Using this mode you may have your own subroutine handle errors. If
coderef itself returns then the method generating the error returns
undefined or a null list depending on context.
When mode is an arrayref, the first element of the array must be a
coderef. Any elements that follow are the arguments to coderef.
When an error is encountered, the coderef is called with its
arguments. Using this mode you may have your own subroutine handle
errors. If the coderef itself returns then the method generating
the error returns undefined or a null list depending on context.
errmsg - most recent error message
$msg = $obj->errmsg;
$prev = $obj->errmsg(@msgs);
The first calling sequence returns the error message associated with
the object. The null string is returned if no error has been
encountered yet. The second calling sequence sets the error message
for the object to the concatenation of @msgs and returns the
previous error message. Normally, error messages are set internally
by a method when an error is encountered.
error - perform the error mode action
$obj->error(@msgs);
This method concatenates @msgs into a string and places it in the
object as the error message. Also see errmsg(). It then performs
the error mode. Also see errmode().
If the error mode doesn't cause the program to die then the undefined
value or a null list is returned depending on context.
This method is primarily used by this class or a sub-class to perform
the user requested action when an error is encountered.
fhopen - use already open filehandle for I/O
$ok = $obj->fhopen($fh);
This method associates the open filehandle $fh with $obj for
further I/O. Filehandle $fh must already be opened.
Suppose you want to use the features of this module to do I/O to
something other than a TCP port, for example STDIN or a filehandle
opened to read from a process. Instead of opening the object for I/O
to a TCP port by using open() or new(), call this method
instead.
get - read block of data
$data = $obj->get([Timeout => $secs,]);
This method reads a block of data from the object and returns it along
with any buffered data. If no buffered data is available to return,
it will wait for data to read using the timeout specified in the
object. You can override that timeout using $secs. Also see
timeout(). If buffered data is available to return, it also checks
for a block of data that can be immediately read.
On eof an undefined value is returned. On time-out or other errors
the error mode action is performed.
An undefined value is returned for both eof and time-out when
errmode is not set to "die". Use eof() and timed_out() to
distinguish.
getline - read next line
$line = $obj->getline([Timeout => $secs,]);
This method reads and returns the next line of data from the object.
You can use input_record_separator() to change the notion of what
separates a line. The default is "\n".
If a line isn't immediately available, this method blocks waiting for
a line or the time-out. You can override the object's timeout for
this method using $secs. Also see timeout().
On eof an undefined value is returned. On time-out or other errors
the error mode action is performed.
An undefined value is returned for both eof and time-out when
errmode is not set to "die". Use eof() and timed_out() to
distinguish.
getlines - read next lines
@lines = $obj->getlines([Timeout => $secs,]);
This method reads and returns the next available lines of data from
the object. You can use input_record_separator() to change the
notion of what separates a line. The default is "\n".
If a line isn't immediately available, this method blocks waiting for
one or more lines, or time-out. You can override the object's timeout
for this method using $secs. Also see timeout().
On eof a null array is returned. On time-out or other errors, the
error mode action is performed.
A null array is returned for both eof and time-out when errmode is
not set to "die". Use eof() and timed_out() to distinguish.
host - name of remote host
$host = $obj->host;
$prev = $obj->host($host);
This method designates the remote host. With no argument this method
returns the current host name set in the object. With an argument it
sets the current host name to $host and returns the previous host
name. You may indicate the remote host using either a hostname or an
IP address.
input_log - log all input
$fh = $obj->input_log;
$fh = $obj->input_log($fh);
$fh = $obj->input_log($filename);
This method starts or stops logging of input. This is useful when
debugging. Also see dump_log(). Because most command interpreters
echo back commands received, its likely all your output will also be
in this log. Note that input logging occurs after newline
translation. See binmode() for details on newline translation.
If no argument is given, the log filehandle is returned. A null
string indicates logging is off.
To stop logging, use a null string as an argument.
If an open filehandle is given, it is used for logging and returned.
Otherwise, the argument is assumed to be the name of a file, the file
is opened for logging and a filehandle to it is returned.
input_record_separator - input line delimiter
$rs = $obj->input_record_separator;
$prev = $obj->input_record_separator($rs);
This method designates the line delimiter for input. It's used with
getline(), getlines(), and cmd() to determine lines in the
input.
With no argument this method returns the current input record
separator set in the object. With an argument it sets the input
record separator to $rs and returns the previous value.
lastline - last line read
$line = $obj->lastline;
$prev = $obj->lastline($line);
This method saves the last line read from the object. This may be a
useful error message when the remote side abnormally closes the
connection. Typically the remote side will print an error message
before closing.
With no argument this method returns the last line read from the
object. With an argument it sets the last line read to $line and
returns the previous value. Normally, only internal methods set the
last line.
This method performs a standard login by waiting for a login prompt
and responding with $username, then waiting for the password prompt
and responding with $password, and then waiting for the command
interpreter prompt. If any of those prompts sent by the remote side
don't match what's expected, this method will time-out - unless
timeout is turned off.
Login prompts must match either of the case insensitive patterns:
/login[: ]*$/i
/username[: ]*$/i
Password prompts must match the case insensitive pattern:
/password[: ]*$/i
The command interpreter prompt must match the current setting of
prompt.
Use dump_log() to debug when this method keeps timing-out and you
don't think it should.
Consider using a combination of print() and waitfor() as an
alternative to this method when it doesn't do what you want, e.g. the
remote host doesn't send a username prompt.
Optional named arguments are provided to override the current settings
of prompt and timeout.
max_buffer_length - maximum size of input buffer
$len = $obj->max_buffer_length;
$prev = $obj->max_buffer_length($len);
This method designates the maximum size of the input buffer. An error
is generated when a read causes the buffer to exceed this limit. The
default value is 1,048,576 bytes (1MB). The input buffer can grow
much larger than the block size when you continuously read using
getline() or waitfor() and the data stream contains no newlines
or matching waitfor patterns.
With no argument this method returns the current maximum buffer length
set in the object. With an argument it sets the maximum buffer length
to $len and returns the previous value.
This method opens a TCP connection to $port on $host. If either
argument is missing then the current value of host() or port()
is used. An optional named argument is provided to override the
current setting of timeout.
On time-out or other connection errors, the error mode action is
performed.
Time-outs don't work for this method on machines that don't implement
SIGALRM - most notably Win32 machines. For those machines, an error
is returned when the system reaches its own time-out while trying to
connect.
A side effect of this method is to reset the alarm interval associated
with SIGALRM.
option_accept - indicate willingness to accept a TELNET option
This method is used to indicate whether to accept or reject an offer
to enable a TELNET option made by the remote side. If you're using
Do or Will to indicate a willingness to enable, then a
notification callback must have already been defined by a prior call
to option_callback(). See option_callback() for details on
receiving enable/disable notification of a TELNET option.
You can give multiple Do, Dont, Will, or Wont arguments
for different TELNET options in the same call to this method.
The following example describes the meaning of the named arguments. A
TELNET option, such as TELOPT_ECHO used below, is an integer
constant that you can import from Net::Telnet. See the source in file
Telnet.pm for the complete list.
Do => TELOPT_ECHO
we'll accept an offer to enable the echo option on the local side
Dont => TELOPT_ECHO
we'll reject an offer to enable the echo option on the local side
Will => TELOPT_ECHO
we'll accept an offer to enable the echo option on the remote side
Wont => TELOPT_ECHO
we'll reject an offer to enable the echo option on the remote side
Use option_send() to send a request to the remote side to enable or
disable a particular TELNET option.
option_callback - define the option negotiation callback
$coderef = $obj->option_callback;
$prev = $obj->option_callback($coderef);
This method defines the callback subroutine that's called when a
TELNET option is enabled or disabled. Once defined, the
option_callback may not be undefined. However, calling this method
with a different $coderef changes it.
Here are the circumstances that invoke $coderef:
An option becomes enabled because the remote side requested an enable
and option_accept() had been used to arrange that it be accepted.
The remote side arbitrarily decides to disable an option that is
currently enabled. Note that Net::Telnet always accepts a request to
disable from the remote side.
option_send() was used to send a request to enable or disable an
option and the response from the remote side has just been received.
Note, that if a request to enable is rejected then $coderef is
still invoked even though the option didn't change.
2. $option is the TELNET option. Net::Telnet exports constants
for the various TELNET options which just equate to an integer.
3. $is_remote is a boolean indicating for which side the option
applies.
4. $is_enabled is a boolean indicating the option is enabled or
disabled
5. $was_enabled is a boolean indicating the option was previously
enabled or disabled
6. $buf_position is an integer indicating the position in the
object's input buffer where the option takes effect. See buffer()
to access the object's input buffer.
option_log - log all TELNET options sent or received
$fh = $obj->option_log;
$fh = $obj->option_log($fh);
$fh = $obj->option_log($filename);
This method starts or stops logging of all TELNET options being sent
or received. This is useful for debugging when you send options via
option_send() or you arrange to accept option requests from the
remote side via option_accept(). Also see dump_log().
If no argument is given, the log filehandle is returned. A null
string indicates logging is off.
To stop logging, use a null string as an argument.
If an open filehandle is given, it is used for logging and returned.
Otherwise, the argument is assumed to be the name of a file, the file
is opened for logging and a filehandle to it is returned.
This method is not yet implemented. Look for it in a future version.
option_state - get current state of a TELNET option
$hashref = $obj->option_state($telopt);
This method returns a hashref containing a copy of the current state
of TELNET option $telopt.
Here are the values returned in the hash:
$hashref->{remote_enabled}
boolean that indicates if the option is enabled on the remote side.
$hashref->{remote_enable_ok}
boolean that indicates if it's ok to accept an offer to enable this
option on the remote side.
$hashref->{remote_state}
string used to hold the internal state of option negotiation for this
option on the remote side.
$hashref->{local_enabled}
boolean that indicates if the option is enabled on the local side.
$hashref->{local_enable_ok}
boolean that indicates if it's ok to accept an offer to enable this
option on the local side.
$hashref->{local_state}
string used to hold the internal state of option negotiation for this
option on the local side.
output_field_separator - field separator for print
$ofs = $obj->output_field_separator;
$prev = $obj->output_field_separator($ofs);
This method designates the output field separator for print().
Ordinarily the print method simply prints out the comma separated
fields you specify. Set this to specify what's printed between
fields.
With no argument this method returns the current output field
separator set in the object. With an argument it sets the output
field separator to $ofs and returns the previous value.
output_log - log all output
$fh = $obj->output_log;
$fh = $obj->output_log($fh);
$fh = $obj->output_log($filename);
This method starts or stops logging of output. This is useful when
debugging. Also see dump_log(). Because most command interpreters
echo back commands received, its likely all your output would also be
in an input log. See input_log(). Note that output logging occurs
before newline translation. See binmode() for details on newline
translation.
If no argument is given, the log filehandle is returned. A null
string indicates logging is off.
To stop logging, use a null string as an argument.
If an open filehandle is given, it is used for logging and returned.
Otherwise, the argument is assumed to be the name of a file, the file
is opened for logging and a filehandle to it is returned.
output_record_separator - output line delimiter
$ors = $obj->output_record_separator;
$prev = $obj->output_record_separator($ors);
This method designates the output record separator for print().
Ordinarily the print operator simply prints out the comma separated
fields you specify, with no trailing newline or record separator
assumed. Set this variable to specify what's printed at the end of
the print.
Note: the output record separator is set to "\n" by default, so
there's no need to append all your commands with a newline.
With no argument this method returns the current output record
separator set in the object. With an argument it sets the output
record separator to $ors and returns the previous value.
port - remote port
$port = $obj->port;
$prev = $obj->port($port);
This method designates the remote TCP port. With no argument this
method returns the current port number. With an argument it sets the
current port number to $port and returns the previous port. If
$port is a service name, then first it's converted to a port number
using the perl function getservbyname().
print - write to object
$ok = $obj->print(@list);
This method prints a string or a comma-separated list of strings to
the opened object and returns non-zero if all data was successfully
written.
By default, the output_record_separator() is set to "\n" in order
to have your commands automatically end with a newline. In most cases
your output is being read by a command interpreter which won't accept
a command until newline is read. This is similar to someone typing a
command and hitting the return key.
On failure, it's possible that some data was written. If you choose
to try and recover from a print timing-out, use print_length() to
determine how much was written before time-out occurred.
print_length - number of bytes written by print
$num = $obj->print_length;
This returns the number of bytes successfully written by the most
recent print().
prompt - pattern to match a prompt
$matchop = $obj->prompt;
$prev = $obj->prompt($matchop);
This method sets the pattern used to find a prompt in the input
stream. It must be a string representing a valid perl pattern match
operator. The methods login() and cmd() try to read until
matching the prompt. They will fail with a time-out error if the
pattern you've chosen doesn't match what the remote side sends.
With no argument this method returns the prompt set in the object.
With an argument it sets the prompt to $matchop and returns the
previous value.
The default prompt is '/[\$%#>] $/'
Always use single quotes, instead of double quotes, to construct
$matchop (e.g. '/bash\$ $/'). If you're constructing a DOS like
file path, you'll need to use four backslashes to represent one
(e.g. '/c:\\\\users\\\\bill>$/i').
Of course don't forget about regexp metacharacters like ., [, or
$. You'll only need a single backslash to quote them. The anchor
metacharacters ^ and $ refer to positions in the input buffer.
This method controls whether or not TELNET commands in the data stream
are recognized and handled. The TELNET protocol uses certain
character sequences sent in the data stream to control the session.
If the port you're connecting to isn't using the TELNET protocol, then
you should turn this mode off. The default is on.
If no argument is given, the current mode is returned.
If $mode is 0 then telnet mode is off. If $mode is 1 then
telnet mode is on.
timed_out - time-out indicator
$boolean = $obj->timed_out;
$prev = $obj->timed_out($boolean);
This method indicates if a previous read or write method timed-out.
With no argument this method returns true if a previous method
timed-out. With an argument it sets the indicator. Normally, only
internal methods set this indicator.
timeout - I/O time-out interval
$secs = $obj->timeout;
$prev = $obj->timeout($secs);
This method sets the timeout interval that's used when performing I/O
or connecting to a port. When a method doesn't complete within the
timeout interval then it's an error and the error mode action is
performed.
The timeout may be expressed as a relative or absolute value. If
$secs is greater than or equal to the time the program was started,
as determined by $^T, then it's the absolute time when time-out
occurs. Also see the perl function time(). A relative time-out
happens $secs from when the I/O method begins.
If $secs is 0 then time-out occurs if the data cannot be
immediately read or written. Use the undefined value to turn off
timing-out.
With no argument this method returns the timeout set in the object.
With an argument it sets the timeout to $secs and returns the
previous value.
This method reads until a pattern match or string is found in the
input stream. All the characters before and including the match are
removed from the input stream. On time-out, eof, or other errors the
error mode action is performed.
In an array context the characters before the match and the matched
characters are returned in $prematch and $match.
You can specify more than one pattern or string by simply providing
multiple Match and/or String named arguments. A $matchop
must be a string representing a valid Perl pattern match operator.
The $string is just a substring to find in the input stream.
Use dump_log() to debug when this method keeps timing-out and you
don't think it should.
An optional named argument is provided to override the current setting
of timeout.
To avoid unexpected backslash interpretation, always use single quotes
instead of double quotes to construct a match operator argument for
prompt() and waitfor() (e.g. '/bash\$ $/'). If you're
constructing a DOS like file path, you'll need to use four backslashes
to represent one (e.g. '/c:\\\\users\\\\bill>$/i').
Of course don't forget about regexp metacharacters like ., [, or
$. You'll only need a single backslash to quote them. The anchor
metacharacters ^ and $ refer to positions in the input buffer.
## Request status of messages.
$pop->print("list");
$line = $pop->getline;
print $line;
exit;
Here's an example you can use to down load a file of any type. The
file is read from the remote host's standard output using cat. To
prevent any output processing, the remote host's standard output is
put in raw mode using the Bourne shell. The Bourne shell is used
because some shells, notably tcsh, prevent changing tty modes. Upon
completion, FTP style statistics are printed to stderr.
Copyright 1997, 2000 by Jay Rogers. All rights reserved.
This program is free software; you can redistribute it and/or
modify it under the same terms as Perl itself.