Loading ...
Sorry, an error occurred while loading the content.

Re: [PBML] Use of Net::Telnet

Expand Messages
  • Gerrit P. Haase
    ... %perldoc Net::Telnet NAME Net::Telnet -
    Message 1 of 2 , Nov 29, 2000
    • 0 Attachment
      <29 Nov 2000, 12:20 Uhr wars, als L.Hagen@... folgendes schrub:>
      < [PBML] Use of Net::Telnet >

      > Hi,
      >
      > I'm really new to Perl. And have to use the Net::Telnet module, but
      > don't really know how. Maybe someone can send me a short example on
      > how to use the Net::Telnet module. (e.g. a piece of code that
      > connects to a remote machine, loggs in, etc.)
      > I'm going to run the program on a NT-machine and connect to a remote
      > UNIX-machine.
      >
      > I would really, really appreciate it!
      >
      > Thanks in advance,

      %perldoc Net::Telnet

      NAME
      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$'

      use Net::Telnet ();
      $t = new Net::Telnet (Timeout => 10,
      Prompt => '/bash\$ $/');
      $t->open("sparky");
      $t->login($username, $passwd);
      @lines = $t->cmd("/usr/bin/who");
      print @lines;

      More examples are in the EXAMPLES section below.

      Usage questions should be directed to the Usenet newsgroup
      comp.lang.perl.modules.

      Contact me, Jay Rogers <jay@...>, 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@...>, 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.

      new - create a new Net::Telnet object
      $obj = Net::Telnet->new([Binmode => $mode,]
      [Cmd_remove_mode => $mode,]
      [Dump_Log => $filename,]
      [Errmode => $errmode,]
      [Fhopen => $filehandle,]
      [Host => $host,]
      [Input_log => $file,]
      [Input_record_separator => $char,]
      [Option_log => $file,]
      [Output_log => $file,]
      [Output_record_separator => $char,]
      [Port => $port,]
      [Prompt => $matchop,]
      [Telnetmode => $mode,]
      [Timeout => $secs,]);

      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.

      cmd - issue command and retrieve output
      $ok = $obj->cmd($string);
      $ok = $obj->cmd(String => $string,
      [Output => $ref,]
      [Prompt => $match,]
      [Timeout => $secs,]
      [Cmd_remove_mode => $mode,]);

      @output = $obj->cmd($string);
      @output = $obj->cmd(String => $string,
      [Output => $ref,]
      [Prompt => $match,]
      [Timeout => $secs,]
      [Cmd_remove_mode => $mode,]);

      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.

      login - perform standard login
      $ok = $obj->login($username, $password);

      $ok = $obj->login(Name => $username,
      Password => $password,
      [Prompt => $match,]
      [Timeout => $secs,]);

      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.

      open - connect to port on remote host
      $ok = $obj->open($host);

      $ok = $obj->open([Host => $host,]
      [Port => $port,]
      [Timeout => $secs,]);

      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
      $fh = $obj->option_accept([Do => $telopt,]
      [Dont => $telopt,]
      [Will => $telopt,]
      [Wont => $telopt,]);

      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.

      Here are the arguments passed to *&$coderef*:

      &$coderef($obj, $option, $is_remote,
      $is_enabled, $was_enabled, $buf_position);

      1. *$obj* is the Net::Telnet object

      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.

      option_send - send TELNET option negotiation request
      $ok = $obj->option_send([Do => $telopt,]
      [Dont => $telopt,]
      [Will => $telopt,]
      [Wont => $telopt,]
      [Async => $boolean,]);

      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.

      telnetmode - turn off/on telnet command interpretation
      $mode = $obj->telnetmode;

      $prev = $obj->telnetmode($mode);

      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.

      waitfor - wait for pattern in the input
      $ok = $obj->waitfor($matchop);
      $ok = $obj->waitfor([Match => $matchop,]
      [String => $string,]
      [Timeout => $secs,]);

      ($prematch, $match) = $obj->waitfor($matchop);
      ($prematch, $match) = $obj->waitfor([Match => $matchop,]
      [String => $string,]
      [Timeout => $secs,]);

      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.

      SEE ALSO
      RFC 854
      TELNET Protocol Specification

      ftp://ftp.isi.edu/in-notes/rfc854.txt

      RFC 1143
      Q Method of Implementing TELNET Option Negotiation

      ftp://ftp.isi.edu/in-notes/rfc1143.txt

      TELNET Option Assignments
      ftp://ftp.isi.edu/in-notes/iana/assignments/telnet-options

      EXAMPLES
      This example gets the current weather forecast for Brainerd, Minnesota.

      my ($forecast, $t);

      use Net::Telnet ();
      $t = new Net::Telnet;
      $t->open("rainmaker.wunderground.com");

      ## Wait for first prompt and "hit return".
      $t->waitfor('/continue:.*$/');
      $t->print("");

      ## Wait for second prompt and respond with city code.
      $t->waitfor('/city code.*$/');
      $t->print("BRD");

      ## Read and print the first page of forecast.
      ($forecast) = $t->waitfor('/[ \t]+press return to continue/i');
      print $forecast;

      exit;

      This example checks a POP server to see if you have mail.

      my ($hostname, $line, $passwd, $pop, $username);

      $hostname = "your_destination_host_here";
      $username = "your_username_here";
      $passwd = "your_password_here";

      use Net::Telnet ();
      $pop = new Net::Telnet (Telnetmode => 0);
      $pop->open(Host => $hostname,
      Port => 110);

      ## Read connection message.
      $line = $pop->getline;
      die $line unless $line =~ /^\+OK/;

      ## Send user name.
      $pop->print("user $username");
      $line = $pop->getline;
      die $line unless $line =~ /^\+OK/;

      ## Send password.
      $pop->print("pass $passwd");
      $line = $pop->getline;
      die $line unless $line =~ /^\+OK/;

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

      my ($block, $filename, $host, $hostname, $k_per_sec, $line,
      $num_read, $passwd, $prevblock, $prompt, $size, $size_bsd,
      $size_sysv, $start_time, $total_time, $username);

      $hostname = "your_destination_host_here";
      $username = "your_username_here";
      $passwd = "your_password_here";
      $filename = "your_download_file_here";

      ## Connect and login.
      use Net::Telnet ();
      $host = new Net::Telnet (Timeout => 30,
      Prompt => '/[%#>] $/');
      $host->open($hostname);
      $host->login($username, $passwd);

      ## Make sure prompt won't match anything in send data.
      $prompt = '_funkyPrompt_';
      $host->prompt("/$prompt\$/");
      $host->cmd("set prompt = '$prompt'");

      ## Get size of file.
      ($line) = $host->cmd("/bin/ls -l $filename");
      ($size_bsd, $size_sysv) = (split ' ', $line)[3,4];
      if ($size_sysv =~ /^\d+$/) {
      $size = $size_sysv;
      }
      elsif ($size_bsd =~ /^\d+$/) {
      $size = $size_bsd;
      }
      else {
      die "$filename: no such file on $hostname";
      }

      ## Start sending the file.
      binmode STDOUT;
      $host->binmode(1);
      $host->print("/bin/sh -c 'stty raw; cat $filename'");
      $host->getline; # discard echoed back line

      ## Read file a block at a time.
      $num_read = 0;
      $prevblock = '';
      $start_time = time;
      while (($block = $host->get) and ($block !~ /$prompt$/o)) {
      if (length $block >= length $prompt) {
      print $prevblock;
      $num_read += length $prevblock;
      $prevblock = $block;
      }
      else {
      $prevblock .= $block;
      }

      }
      $host->close;

      ## Print last block without trailing prompt.
      $prevblock .= $block;
      $prevblock =~ s/$prompt$//;
      print $prevblock;
      $num_read += length $prevblock;
      die "error: expected size $size, received size $num_read\n"
      unless $num_read == $size;

      ## Print totals.
      $total_time = (time - $start_time) || 1;
      $k_per_sec = ($size / 1024) / $total_time;
      $k_per_sec = sprintf "%3.1f", $k_per_sec;
      warn("$num_read bytes received in $total_time seconds ",
      "($k_per_sec Kbytes/s)\n");

      exit;

      AUTHOR
      Jay Rogers <jay@...>

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


      gph

      --
      use Filter::exec qw(tr n-za-mN-ZA-M a-zA-Z);
      @§ = ("Whfg", "nabgure", "Crgre", "Unnfr,");
      sbernpu $1 ( @§ ) { cevag ( "$1", " " ) ; };
      $_=1; cevag 'treevg.unnfr@...' vs$_;
    Your message has been successfully submitted and would be delivered to recipients shortly.