GNU Info

(python2.1-lib.info)Telnet Objects

---

Next: Telnet Example Prev: telnetlib Up: telnetlib

---

Enter node , (file) or (file)node

Telnet Objects
--------------

`Telnet' instances have the following methods:

`read_until(expected[, timeout])'
     Read until a given string is encountered or until timeout.

     When no match is found, return whatever is available instead,
     possibly the empty string.  Raise `EOFError' if the connection is
     closed and no cooked data is available.

`read_all()'
     Read all data until `EOF'; block until connection closed.

`read_some()'
     Read at least one byte of cooked data unless `EOF' is hit.  Return
     `''' if `EOF' is hit.  Block if no data is immediately available.

`read_very_eager()'
     Read everything that can be without blocking in I/O (eager).

     Raise `EOFError' if connection closed and no cooked data
     available.  Return `''' if no cooked data available otherwise.  Do
     not block unless in the midst of an IAC sequence.

`read_eager()'
     Read readily available data.

     Raise `EOFError' if connection closed and no cooked data
     available.  Return `''' if no cooked data available otherwise.  Do
     not block unless in the midst of an IAC sequence.

`read_lazy()'
     Process and return data already in the queues (lazy).

     Raise `EOFError' if connection closed and no data available.
     Return `''' if no cooked data available otherwise.  Do not block
     unless in the midst of an IAC sequence.

`read_very_lazy()'
     Return any data available in the cooked queue (very lazy).

     Raise `EOFError' if connection closed and no data available.
     Return `''' if no cooked data available otherwise.  This method
     never blocks.

`open(host[, port])'
     Connect to a host.  The optional second argument is the port
     number, which defaults to the standard telnet port (23).

     Do not try to reopen an already connected instance.

`msg(msg[, *args])'
     Print a debug message when the debug level is `>' 0.  If extra
     arguments are present, they are substituted in the message using
     the standard string formatting operator.

`set_debuglevel(debuglevel)'
     Set the debug level.  The higher the value of DEBUGLEVEL, the more
     debug output you get (on `sys.stdout').

`close()'
     Close the connection.

`get_socket()'
     Return the socket object used internally.

`fileno()'
     Return the file descriptor of the socket object used internally.

`write(buffer)'
     Write a string to the socket, doubling any IAC characters.  This
     can block if the connection is blocked.  May raise `socket.error'
     if the connection is closed.

`interact()'
     Interaction function, emulates a very dumb telnet client.

`mt_interact()'
     Multithreaded version of `interact()'.

`expect(list[, timeout])'
     Read until one from a list of a regular expressions matches.

     The first argument is a list of regular expressions, either
     compiled (`re.RegexObject' instances) or uncompiled (strings).
     The optional second argument is a timeout, in seconds; the default
     is to block indefinitely.

     Return a tuple of three items: the index in the list of the first
     regular expression that matches; the match object returned; and
     the text read up till and including the match.

     If end of file is found and no text was read, raise `EOFError'.
     Otherwise, when nothing matches, return `(-1, None, TEXT)' where
     TEXT is the text received so far (may be the empty string if a
     timeout happened).

     If a regular expression ends with a greedy match (e.g. ".*") or if
     more than one expression can match the same input, the results are
     indeterministic, and may depend on the I/O timing.