Vega strike Python Modules doc: Telnet Class Reference

def close ( self)

Close the connection.

Definition at line 247 of file telnetlib.py.

References Telnet.eof, _Hqxdecoderengine.eof, _Rledecoderengine.eof, POP3.sock, FTP.sock, NNTP.sock, Telnet.sock, SMTP.sock, HTTPConnection.sock, and HTTPSConnection.sock.

 
     def close(self):
         """Close the connection."""
         if self.sock:
             self.sock.close()
         self.sock = 0
         self.eof = 1

def expect	(	self,
		list,
		timeout = `None`
	)

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; default
is no timeout.

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 EOF is read 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 undeterministic, and may depend on the I/O timing.

Definition at line 513 of file telnetlib.py.

References Telnet.cookedq, Telnet.eof, _Hqxdecoderengine.eof, _Rledecoderengine.eof, _fileobject.fileno(), Telnet.fileno(), TCPServer.fileno(), file_wrapper.fileno(), addbase.fileno, Telnet.fill_rawq(), Telnet.process_rawq(), Telnet.read_very_lazy(), and pre.search().

 
     def expect(self, list, timeout=None):
         """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; default
         is no timeout.
 
         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 EOF is read 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 undeterministic, and may depend on the I/O timing.
 
         """
         re = None
         list = list[:]
         indices = range(len(list))
         for i in indices:
             if not hasattr(list[i], "search"):
                 if not re: import re
                 list[i] = re.compile(list[i])
         while 1:
             self.process_rawq()
             for i in indices:
                 m = list[i].search(self.cookedq)
                 if m:
                     e = m.end()
                     text = self.cookedq[:e]
                     self.cookedq = self.cookedq[e:]
                     return (i, m, text)
             if self.eof:
                 break
             if timeout is not None:
                 r, w, x = select.select([self.fileno()], [], [], timeout)
                 if not r:
                     break
             self.fill_rawq()
         text = self.read_very_lazy()
         if not text and self.eof:
             raise EOFError
         return (-1, None, text)
 

def fileno ( self)

Return the fileno() of the socket object used internally.

Definition at line 258 of file telnetlib.py.

 
     def fileno(self):
         """Return the fileno() of the socket object used internally."""
         return self.sock.fileno()

def fill_rawq ( self)

Fill raw queue from exactly one recv() system call.

Block if no data is immediately available.  Set self.eof when
connection is closed.

Definition at line 447 of file telnetlib.py.

References Telnet.eof, _Hqxdecoderengine.eof, _Rledecoderengine.eof, Telnet.irawq, NetrcParseError.msg, GetoptError.msg, Error.msg, HTTPResponse.msg, HTTPError.msg, Telnet.msg(), and Telnet.rawq.

 
     def fill_rawq(self):
         """Fill raw queue from exactly one recv() system call.
 
         Block if no data is immediately available.  Set self.eof when
         connection is closed.
 
         """
         if self.irawq >= len(self.rawq):
             self.rawq = ''
             self.irawq = 0
         # The buffer size should be fairly small so as to avoid quadratic
         # behavior in process_rawq() above
         buf = self.sock.recv(50)
         self.msg("recv %s", `buf`)
         self.eof = (not buf)
         self.rawq = self.rawq + buf

def get_socket ( self)

Return the socket object used internally.

Definition at line 254 of file telnetlib.py.

References POP3.sock, FTP.sock, NNTP.sock, Telnet.sock, SMTP.sock, HTTPConnection.sock, and HTTPSConnection.sock.

 
     def get_socket(self):
         """Return the socket object used internally."""
         return self.sock

def interact ( self)

Interaction function, emulates a very dumb telnet client.

Definition at line 468 of file telnetlib.py.

References Telnet.mt_interact(), Telnet.read_eager(), Devnull.write(), Pickler.write, openrsrc.write(), _Hqxcoderengine.write(), StreamWriter.write(), GzipFile.write(), StringIO.write(), _Rlecoderengine.write(), InteractiveInterpreter.write(), _fileobject.write(), BinHex.write(), Telnet.write(), StreamReaderWriter.write(), ConfigParser.write(), _SpoofOut.write(), StreamRecoder.write(), Marshaller.write, and file_wrapper.write.

 
     def interact(self):
         """Interaction function, emulates a very dumb telnet client."""
         if sys.platform == "win32":
             self.mt_interact()
             return
         while 1:
             rfd, wfd, xfd = select.select([self, sys.stdin], [], [])
             if self in rfd:
                 try:
                     text = self.read_eager()
                 except EOFError:
                     print '*** Connection closed by remote host ***'
                     break
                 if text:
                     sys.stdout.write(text)
                     sys.stdout.flush()
             if sys.stdin in rfd:
                 line = sys.stdin.readline()
                 if not line:
                     break
                 self.write(line)

def listener ( self)

Helper for mt_interact() -- this executes in the other thread.

Definition at line 500 of file telnetlib.py.

References Telnet.read_eager().

 
     def listener(self):
         """Helper for mt_interact() -- this executes in the other thread."""
         while 1:
             try:
                 data = self.read_eager()
             except EOFError:
                 print '*** Connection closed by remote host ***'
                 return
             if data:
                 sys.stdout.write(data)
             else:
                 sys.stdout.flush()

def msg	(	self,
		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.

Definition at line 225 of file telnetlib.py.

References HTTPResponse.debuglevel, Telnet.debuglevel, SMTP.debuglevel, HTTPConnection.debuglevel, HTTP.debuglevel, POP3.host, FTP.host, NNTP.host, Telnet.host, HTTPConnection.host, POP3.port, FTP.port, NNTP.port, Telnet.port, and HTTPConnection.port.

 
     def msg(self, 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.
 
         """
         if self.debuglevel > 0:
             print 'Telnet(%s,%d):' % (self.host, self.port),
             if args:
                 print msg % args
             else:
                 print msg

def mt_interact ( self)

Multithreaded version of interact().

Definition at line 490 of file telnetlib.py.

References Telnet.listener(), Devnull.write(), Pickler.write, openrsrc.write(), _Hqxcoderengine.write(), StreamWriter.write(), GzipFile.write(), StringIO.write(), _Rlecoderengine.write(), InteractiveInterpreter.write(), _fileobject.write(), BinHex.write(), Telnet.write(), StreamReaderWriter.write(), ConfigParser.write(), _SpoofOut.write(), StreamRecoder.write(), Marshaller.write, and file_wrapper.write.

 
     def mt_interact(self):
         """Multithreaded version of interact()."""
         import thread
         thread.start_new_thread(self.listener, ())
         while 1:
             line = sys.stdin.readline()
             if not line:
                 break
             self.write(line)

def open	(	self,
		host,
		port = `0`
	)

Connect to a host.

The optional second argument is the port number, which
defaults to the standard telnet port (23).

Don't try to reopen an already connected instance.

Definition at line 192 of file telnetlib.py.

References Telnet.eof, _Hqxdecoderengine.eof, _Rledecoderengine.eof, POP3.host, FTP.host, NNTP.host, Telnet.host, HTTPConnection.host, POP3.port, FTP.port, NNTP.port, Telnet.port, HTTPConnection.port, POP3.sock, FTP.sock, NNTP.sock, Telnet.sock, SMTP.sock, HTTPConnection.sock, HTTPSConnection.sock, and socket.socket().

 
     def open(self, host, port=0):
         """Connect to a host.
 
         The optional second argument is the port number, which
         defaults to the standard telnet port (23).
 
         Don't try to reopen an already connected instance.
 
         """
         self.eof = 0
         if not port:
             port = TELNET_PORT
         self.host = host
         self.port = port
         msg = "getaddrinfo returns an empty list"
         for res in socket.getaddrinfo(host, port, 0, socket.SOCK_STREAM):
             af, socktype, proto, canonname, sa = res
             try:
                 self.sock = socket.socket(af, socktype, proto)
                 self.sock.connect(sa)
             except socket.error, msg:
                 if self.sock:
                     self.sock.close()
                 self.sock = None
                 continue
             break
         if not self.sock:
             raise socket.error, msg

def process_rawq ( self)

Transfer from raw queue to cooked queue.

Set self.eof when connection is closed.  Don't block unless in
the midst of an IAC sequence.

Definition at line 387 of file telnetlib.py.

References Telnet.cookedq, NetrcParseError.msg, GetoptError.msg, Error.msg, HTTPResponse.msg, HTTPError.msg, Telnet.msg(), Telnet.option_callback, Telnet.rawq, Telnet.rawq_getchar(), POP3.sock, FTP.sock, NNTP.sock, Telnet.sock, SMTP.sock, HTTPConnection.sock, and HTTPSConnection.sock.

 
     def process_rawq(self):
         """Transfer from raw queue to cooked queue.
 
         Set self.eof when connection is closed.  Don't block unless in
         the midst of an IAC sequence.
 
         """
         buf = ''
         try:
             while self.rawq:
                 c = self.rawq_getchar()
                 if c == theNULL:
                     continue
                 if c == "\021":
                     continue
                 if c != IAC:
                     buf = buf + c
                     continue
                 c = self.rawq_getchar()
                 if c == IAC:
                     buf = buf + c
                 elif c in (DO, DONT):
                     opt = self.rawq_getchar()
                     self.msg('IAC %s %d', c == DO and 'DO' or 'DONT', ord(opt))
                     if self.option_callback:
                         self.option_callback(self.sock, c, opt)
                     else:
                         self.sock.sendall(IAC + WONT + opt)
                 elif c in (WILL, WONT):
                     opt = self.rawq_getchar()
                     self.msg('IAC %s %d',
                              c == WILL and 'WILL' or 'WONT', ord(opt))
                     if self.option_callback:
                         self.option_callback(self.sock, c, opt)
                     else:
                         self.sock.sendall(IAC + DONT + opt)
                 else:
                     self.msg('IAC %d not recognized' % ord(opt))
         except EOFError: # raised by self.rawq_getchar()
             pass
         self.cookedq = self.cookedq + buf

def rawq_getchar ( self)

Get next char from raw queue.

Block if no data is immediately available.  Raise EOFError
when connection is closed.

Definition at line 429 of file telnetlib.py.

References Telnet.eof, _Hqxdecoderengine.eof, _Rledecoderengine.eof, Telnet.fill_rawq(), Telnet.irawq, and Telnet.rawq.

 
     def rawq_getchar(self):
         """Get next char from raw queue.
 
         Block if no data is immediately available.  Raise EOFError
         when connection is closed.
 
         """
         if not self.rawq:
             self.fill_rawq()
             if self.eof:
                 raise EOFError
         c = self.rawq[self.irawq]
         self.irawq = self.irawq + 1
         if self.irawq >= len(self.rawq):
             self.rawq = ''
             self.irawq = 0
         return c

def read_all ( self)

Read all data until EOF; block until connection closed.

Definition at line 306 of file telnetlib.py.

References Telnet.cookedq, Telnet.eof, _Hqxdecoderengine.eof, _Rledecoderengine.eof, Telnet.fill_rawq(), and Telnet.process_rawq().

 
     def read_all(self):
         """Read all data until EOF; block until connection closed."""
         self.process_rawq()
         while not self.eof:
             self.fill_rawq()
             self.process_rawq()
         buf = self.cookedq
         self.cookedq = ''
         return buf

def read_eager ( self)

Read readily available data.

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

Definition at line 345 of file telnetlib.py.

References Telnet.cookedq, Telnet.eof, _Hqxdecoderengine.eof, _Rledecoderengine.eof, Telnet.fill_rawq(), Telnet.process_rawq(), Telnet.read_very_lazy(), and Telnet.sock_avail().

 
     def read_eager(self):
         """Read readily available data.
 
         Raise EOFError if connection closed and no cooked data
         available.  Return '' if no cooked data available otherwise.
         Don't block unless in the midst of an IAC sequence.
 
         """
         self.process_rawq()
         while not self.cookedq and not self.eof and self.sock_avail():
             self.fill_rawq()
             self.process_rawq()
         return self.read_very_lazy()

def read_lazy ( self)

Process and return data that's already in the queues (lazy).

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

Definition at line 359 of file telnetlib.py.

References Telnet.process_rawq(), and Telnet.read_very_lazy().

 
     def read_lazy(self):
         """Process and return data that's already in the queues (lazy).
 
         Raise EOFError if connection closed and no data available.
         Return '' if no cooked data available otherwise.  Don't block
         unless in the midst of an IAC sequence.
 
         """
         self.process_rawq()
         return self.read_very_lazy()

def read_some ( self)

Read at least one byte of cooked data unless EOF is hit.

Return '' if EOF is hit.  Block if no data is immediately
available.

Definition at line 316 of file telnetlib.py.

References Telnet.cookedq, Telnet.eof, _Hqxdecoderengine.eof, _Rledecoderengine.eof, Telnet.fill_rawq(), and Telnet.process_rawq().

 
     def read_some(self):
         """Read at least one byte of cooked data unless EOF is hit.
 
         Return '' if EOF is hit.  Block if no data is immediately
         available.
 
         """
         self.process_rawq()
         while not self.cookedq and not self.eof:
             self.fill_rawq()
             self.process_rawq()
         buf = self.cookedq
         self.cookedq = ''
         return buf

def read_until	(	self,
		match,
		timeout = `None`
	)

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.

Definition at line 274 of file telnetlib.py.

References Telnet.cookedq, Telnet.eof, _Hqxdecoderengine.eof, _Rledecoderengine.eof, Telnet.fill_rawq(), sre_parse.max, Telnet.process_rawq(), and Telnet.read_very_lazy().

 
     def read_until(self, match, timeout=None):
         """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.
 
         """
         n = len(match)
         self.process_rawq()
         i = self.cookedq.find(match)
         if i >= 0:
             i = i+n
             buf = self.cookedq[:i]
             self.cookedq = self.cookedq[i:]
             return buf
         s_reply = ([self], [], [])
         s_args = s_reply
         if timeout is not None:
             s_args = s_args + (timeout,)
         while not self.eof and apply(select.select, s_args) == s_reply:
             i = max(0, len(self.cookedq)-n)
             self.fill_rawq()
             self.process_rawq()
             i = self.cookedq.find(match, i)
             if i >= 0:
                 i = i+n
                 buf = self.cookedq[:i]
                 self.cookedq = self.cookedq[i:]
                 return buf
         return self.read_very_lazy()

def read_very_eager ( self)

Read everything that's possible without blocking in I/O (eager).

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

Definition at line 331 of file telnetlib.py.

References Telnet.eof, _Hqxdecoderengine.eof, _Rledecoderengine.eof, Telnet.fill_rawq(), Telnet.process_rawq(), Telnet.read_very_lazy(), and Telnet.sock_avail().

 
     def read_very_eager(self):
         """Read everything that's possible without blocking in I/O (eager).
 
         Raise EOFError if connection closed and no cooked data
         available.  Return '' if no cooked data available otherwise.
         Don't block unless in the midst of an IAC sequence.
 
         """
         self.process_rawq()
         while not self.eof and self.sock_avail():
             self.fill_rawq()
             self.process_rawq()
         return self.read_very_lazy()

def read_very_lazy ( self)

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.  Don't block.

Definition at line 370 of file telnetlib.py.

References Telnet.cookedq, Telnet.eof, _Hqxdecoderengine.eof, _Rledecoderengine.eof, and Telnet.rawq.

 
     def read_very_lazy(self):
         """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.  Don't block.
 
         """
         buf = self.cookedq
         self.cookedq = ''
         if not buf and self.eof and not self.rawq:
             raise EOFError, 'telnet connection closed'
         return buf

def set_debuglevel	(	self,
		debuglevel
	)

Set the debug level.

The higher it is, the more debug output you get (on sys.stdout).

Definition at line 239 of file telnetlib.py.

References HTTPResponse.debuglevel, Telnet.debuglevel, SMTP.debuglevel, HTTPConnection.debuglevel, and HTTP.debuglevel.

 
     def set_debuglevel(self, debuglevel):
         """Set the debug level.
 
         The higher it is, the more debug output you get (on sys.stdout).
 
         """
         self.debuglevel = debuglevel

def set_option_negotiation_callback	(	self,
		callback
	)

Provide a callback function called after each receipt of a telnet option.

Definition at line 383 of file telnetlib.py.

References Telnet.option_callback.

 
     def set_option_negotiation_callback(self, callback):
         """Provide a callback function called after each receipt of a telnet option."""
         self.option_callback = callback

def sock_avail ( self)

Test whether data is available on the socket.

Definition at line 464 of file telnetlib.py.

 
     def sock_avail(self):
         """Test whether data is available on the socket."""
         return select.select([self], [], [], 0) == ([self], [], [])

def write	(	self,
		buffer
	)

Write a string to the socket, doubling any IAC characters.

Can block if the connection is blocked.  May raise
socket.error if the connection is closed.

Definition at line 262 of file telnetlib.py.

References NetrcParseError.msg, GetoptError.msg, Error.msg, HTTPResponse.msg, HTTPError.msg, and Telnet.msg().

 
     def write(self, buffer):
         """Write a string to the socket, doubling any IAC characters.
 
         Can block if the connection is blocked.  May raise
         socket.error if the connection is closed.
 
         """
         if IAC in buffer:
             buffer = buffer.replace(IAC, IAC+IAC)
         self.msg("send %s", `buffer`)
         self.sock.sendall(buffer)

cookedq

Definition at line 186 of file telnetlib.py.

debuglevel

Definition at line 180 of file telnetlib.py.

eof

Definition at line 187 of file telnetlib.py.

host

Definition at line 181 of file telnetlib.py.

irawq

Definition at line 185 of file telnetlib.py.

option_callback

Definition at line 188 of file telnetlib.py.

port

Definition at line 182 of file telnetlib.py.

rawq

Definition at line 184 of file telnetlib.py.

sock

Definition at line 183 of file telnetlib.py.

Public Member Functions

Data Fields

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Field Documentation

Public Member Functions
def	__init__

def	open

def	__del__

def	msg

def	set_debuglevel

def	close

def	get_socket

def	fileno

def	write

def	read_until

def	read_all

def	read_some

def	read_very_eager

def	read_eager

def	read_lazy

def	read_very_lazy

def	set_option_negotiation_callback

def	process_rawq

def	rawq_getchar

def	fill_rawq

def	sock_avail

def	interact

def	mt_interact

def	listener

def	expect