home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_2817 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  11.4 KB  |  510 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import sys
  5. import socket
  6. import select
  7. __all__ = [
  8.     'Telnet']
  9. DEBUGLEVEL = 0
  10. TELNET_PORT = 23
  11. IAC = chr(255)
  12. DONT = chr(254)
  13. DO = chr(253)
  14. WONT = chr(252)
  15. WILL = chr(251)
  16. theNULL = chr(0)
  17. SE = chr(240)
  18. NOP = chr(241)
  19. DM = chr(242)
  20. BRK = chr(243)
  21. IP = chr(244)
  22. AO = chr(245)
  23. AYT = chr(246)
  24. EC = chr(247)
  25. EL = chr(248)
  26. GA = chr(249)
  27. SB = chr(250)
  28. BINARY = chr(0)
  29. ECHO = chr(1)
  30. RCP = chr(2)
  31. SGA = chr(3)
  32. NAMS = chr(4)
  33. STATUS = chr(5)
  34. TM = chr(6)
  35. RCTE = chr(7)
  36. NAOL = chr(8)
  37. NAOP = chr(9)
  38. NAOCRD = chr(10)
  39. NAOHTS = chr(11)
  40. NAOHTD = chr(12)
  41. NAOFFD = chr(13)
  42. NAOVTS = chr(14)
  43. NAOVTD = chr(15)
  44. NAOLFD = chr(16)
  45. XASCII = chr(17)
  46. LOGOUT = chr(18)
  47. BM = chr(19)
  48. DET = chr(20)
  49. SUPDUP = chr(21)
  50. SUPDUPOUTPUT = chr(22)
  51. SNDLOC = chr(23)
  52. TTYPE = chr(24)
  53. EOR = chr(25)
  54. TUID = chr(26)
  55. OUTMRK = chr(27)
  56. TTYLOC = chr(28)
  57. VT3270REGIME = chr(29)
  58. X3PAD = chr(30)
  59. NAWS = chr(31)
  60. TSPEED = chr(32)
  61. LFLOW = chr(33)
  62. LINEMODE = chr(34)
  63. XDISPLOC = chr(35)
  64. OLD_ENVIRON = chr(36)
  65. AUTHENTICATION = chr(37)
  66. ENCRYPT = chr(38)
  67. NEW_ENVIRON = chr(39)
  68. TN3270E = chr(40)
  69. XAUTH = chr(41)
  70. CHARSET = chr(42)
  71. RSP = chr(43)
  72. COM_PORT_OPTION = chr(44)
  73. SUPPRESS_LOCAL_ECHO = chr(45)
  74. TLS = chr(46)
  75. KERMIT = chr(47)
  76. SEND_URL = chr(48)
  77. FORWARD_X = chr(49)
  78. PRAGMA_LOGON = chr(138)
  79. SSPI_LOGON = chr(139)
  80. PRAGMA_HEARTBEAT = chr(140)
  81. EXOPL = chr(255)
  82. NOOPT = chr(0)
  83.  
  84. class Telnet:
  85.     
  86.     def __init__(self, host = None, port = 0, timeout = socket._GLOBAL_DEFAULT_TIMEOUT):
  87.         self.debuglevel = DEBUGLEVEL
  88.         self.host = host
  89.         self.port = port
  90.         self.timeout = timeout
  91.         self.sock = None
  92.         self.rawq = ''
  93.         self.irawq = 0
  94.         self.cookedq = ''
  95.         self.eof = 0
  96.         self.iacseq = ''
  97.         self.sb = 0
  98.         self.sbdataq = ''
  99.         self.option_callback = None
  100.         if host is not None:
  101.             self.open(host, port, timeout)
  102.         
  103.  
  104.     
  105.     def open(self, host, port = 0, timeout = socket._GLOBAL_DEFAULT_TIMEOUT):
  106.         self.eof = 0
  107.         if not port:
  108.             port = TELNET_PORT
  109.         
  110.         self.host = host
  111.         self.port = port
  112.         self.timeout = timeout
  113.         self.sock = socket.create_connection((host, port), timeout)
  114.  
  115.     
  116.     def __del__(self):
  117.         self.close()
  118.  
  119.     
  120.     def msg(self, msg, *args):
  121.         if self.debuglevel > 0:
  122.             print 'Telnet(%s,%d):' % (self.host, self.port),
  123.             if args:
  124.                 print msg % args
  125.             else:
  126.                 print msg
  127.         
  128.  
  129.     
  130.     def set_debuglevel(self, debuglevel):
  131.         self.debuglevel = debuglevel
  132.  
  133.     
  134.     def close(self):
  135.         if self.sock:
  136.             self.sock.close()
  137.         
  138.         self.sock = 0
  139.         self.eof = 1
  140.         self.iacseq = ''
  141.         self.sb = 0
  142.  
  143.     
  144.     def get_socket(self):
  145.         return self.sock
  146.  
  147.     
  148.     def fileno(self):
  149.         return self.sock.fileno()
  150.  
  151.     
  152.     def write(self, buffer):
  153.         if IAC in buffer:
  154.             buffer = buffer.replace(IAC, IAC + IAC)
  155.         
  156.         self.msg('send %r', buffer)
  157.         self.sock.sendall(buffer)
  158.  
  159.     
  160.     def read_until(self, match, timeout = None):
  161.         n = len(match)
  162.         self.process_rawq()
  163.         i = self.cookedq.find(match)
  164.         if i >= 0:
  165.             i = i + n
  166.             buf = self.cookedq[:i]
  167.             self.cookedq = self.cookedq[i:]
  168.             return buf
  169.         s_reply = ([
  170.             self], [], [])
  171.         s_args = s_reply
  172.         if timeout is not None:
  173.             s_args = s_args + (timeout,)
  174.             time = time
  175.             import time
  176.             time_start = time()
  177.         
  178.         while not (self.eof) and select.select(*s_args) == s_reply:
  179.             i = max(0, len(self.cookedq) - n)
  180.             self.fill_rawq()
  181.             self.process_rawq()
  182.             i = self.cookedq.find(match, i)
  183.             if i >= 0:
  184.                 i = i + n
  185.                 buf = self.cookedq[:i]
  186.                 self.cookedq = self.cookedq[i:]
  187.                 return buf
  188.             if timeout is not None:
  189.                 elapsed = time() - time_start
  190.                 if elapsed >= timeout:
  191.                     break
  192.                 
  193.                 s_args = s_reply + (timeout - elapsed,)
  194.                 continue
  195.         return self.read_very_lazy()
  196.  
  197.     
  198.     def read_all(self):
  199.         self.process_rawq()
  200.         while not self.eof:
  201.             self.fill_rawq()
  202.             self.process_rawq()
  203.         buf = self.cookedq
  204.         self.cookedq = ''
  205.         return buf
  206.  
  207.     
  208.     def read_some(self):
  209.         self.process_rawq()
  210.         while not (self.cookedq) and not (self.eof):
  211.             self.fill_rawq()
  212.             self.process_rawq()
  213.         buf = self.cookedq
  214.         self.cookedq = ''
  215.         return buf
  216.  
  217.     
  218.     def read_very_eager(self):
  219.         self.process_rawq()
  220.         while not (self.eof) and self.sock_avail():
  221.             self.fill_rawq()
  222.             self.process_rawq()
  223.         return self.read_very_lazy()
  224.  
  225.     
  226.     def read_eager(self):
  227.         self.process_rawq()
  228.         while not (self.cookedq) and not (self.eof) and self.sock_avail():
  229.             self.fill_rawq()
  230.             self.process_rawq()
  231.         return self.read_very_lazy()
  232.  
  233.     
  234.     def read_lazy(self):
  235.         self.process_rawq()
  236.         return self.read_very_lazy()
  237.  
  238.     
  239.     def read_very_lazy(self):
  240.         buf = self.cookedq
  241.         self.cookedq = ''
  242.         if not buf and self.eof and not (self.rawq):
  243.             raise EOFError, 'telnet connection closed'
  244.         not (self.rawq)
  245.         return buf
  246.  
  247.     
  248.     def read_sb_data(self):
  249.         buf = self.sbdataq
  250.         self.sbdataq = ''
  251.         return buf
  252.  
  253.     
  254.     def set_option_negotiation_callback(self, callback):
  255.         self.option_callback = callback
  256.  
  257.     
  258.     def process_rawq(self):
  259.         buf = [
  260.             '',
  261.             '']
  262.         
  263.         try:
  264.             while self.rawq:
  265.                 c = self.rawq_getchar()
  266.                 if not self.iacseq:
  267.                     if c == theNULL:
  268.                         continue
  269.                     
  270.                     if c == '\x11':
  271.                         continue
  272.                     
  273.                     if c != IAC:
  274.                         buf[self.sb] = buf[self.sb] + c
  275.                         continue
  276.                     else:
  277.                         self.iacseq += c
  278.                 c != IAC
  279.                 if len(self.iacseq) == 1:
  280.                     if c in (DO, DONT, WILL, WONT):
  281.                         self.iacseq += c
  282.                         continue
  283.                     
  284.                     self.iacseq = ''
  285.                     if c == IAC:
  286.                         buf[self.sb] = buf[self.sb] + c
  287.                     elif c == SB:
  288.                         self.sb = 1
  289.                         self.sbdataq = ''
  290.                     elif c == SE:
  291.                         self.sb = 0
  292.                         self.sbdataq = self.sbdataq + buf[1]
  293.                         buf[1] = ''
  294.                     
  295.                     if self.option_callback:
  296.                         self.option_callback(self.sock, c, NOOPT)
  297.                     else:
  298.                         self.msg('IAC %d not recognized' % ord(c))
  299.                 self.option_callback
  300.                 if len(self.iacseq) == 2:
  301.                     cmd = self.iacseq[1]
  302.                     self.iacseq = ''
  303.                     opt = c
  304.                     if cmd in (DO, DONT):
  305.                         if not cmd == DO or 'DO':
  306.                             pass
  307.                         self.msg('IAC %s %d', 'DONT', ord(opt))
  308.                         if self.option_callback:
  309.                             self.option_callback(self.sock, cmd, opt)
  310.                         else:
  311.                             self.sock.sendall(IAC + WONT + opt)
  312.                     elif cmd in (WILL, WONT):
  313.                         if not cmd == WILL or 'WILL':
  314.                             pass
  315.                         self.msg('IAC %s %d', 'WONT', ord(opt))
  316.                         if self.option_callback:
  317.                             self.option_callback(self.sock, cmd, opt)
  318.                         else:
  319.                             self.sock.sendall(IAC + DONT + opt)
  320.                     
  321.                 cmd in (DO, DONT)
  322.         except EOFError:
  323.             self.iacseq = ''
  324.             self.sb = 0
  325.  
  326.         self.cookedq = self.cookedq + buf[0]
  327.         self.sbdataq = self.sbdataq + buf[1]
  328.  
  329.     
  330.     def rawq_getchar(self):
  331.         if not self.rawq:
  332.             self.fill_rawq()
  333.             if self.eof:
  334.                 raise EOFError
  335.             self.eof
  336.         
  337.         c = self.rawq[self.irawq]
  338.         self.irawq = self.irawq + 1
  339.         if self.irawq >= len(self.rawq):
  340.             self.rawq = ''
  341.             self.irawq = 0
  342.         
  343.         return c
  344.  
  345.     
  346.     def fill_rawq(self):
  347.         if self.irawq >= len(self.rawq):
  348.             self.rawq = ''
  349.             self.irawq = 0
  350.         
  351.         buf = self.sock.recv(50)
  352.         self.msg('recv %r', buf)
  353.         self.eof = not buf
  354.         self.rawq = self.rawq + buf
  355.  
  356.     
  357.     def sock_avail(self):
  358.         return select.select([
  359.             self], [], [], 0) == ([
  360.             self], [], [])
  361.  
  362.     
  363.     def interact(self):
  364.         if sys.platform == 'win32':
  365.             self.mt_interact()
  366.             return None
  367.         while None:
  368.             (rfd, wfd, xfd) = select.select([
  369.                 self,
  370.                 sys.stdin], [], [])
  371.             if self in rfd:
  372.                 
  373.                 try:
  374.                     text = self.read_eager()
  375.                 except EOFError:
  376.                     sys.platform == 'win32'
  377.                     sys.platform == 'win32'
  378.                     print '*** Connection closed by remote host ***'
  379.                     break
  380.                 except:
  381.                     sys.platform == 'win32'
  382.  
  383.                 if text:
  384.                     sys.stdout.write(text)
  385.                     sys.stdout.flush()
  386.                 
  387.             
  388.             if sys.stdin in rfd:
  389.                 line = sys.stdin.readline()
  390.                 if not line:
  391.                     break
  392.                 
  393.                 self.write(line)
  394.                 continue
  395.             continue
  396.             return None
  397.  
  398.     
  399.     def mt_interact(self):
  400.         import thread
  401.         thread.start_new_thread(self.listener, ())
  402.         while None:
  403.             line = sys.stdin.readline()
  404.             if not line:
  405.                 break
  406.             
  407.             continue
  408.             return None
  409.  
  410.     
  411.     def listener(self):
  412.         while None:
  413.             
  414.             try:
  415.                 data = self.read_eager()
  416.             except EOFError:
  417.                 print '*** Connection closed by remote host ***'
  418.                 return None
  419.  
  420.             if data:
  421.                 sys.stdout.write(data)
  422.                 continue
  423.             sys.stdout.flush()
  424.             continue
  425.             return None
  426.  
  427.     
  428.     def expect(self, list, timeout = None):
  429.         re = None
  430.         list = list[:]
  431.         indices = range(len(list))
  432.         for i in indices:
  433.             if not hasattr(list[i], 'search'):
  434.                 if not re:
  435.                     import re
  436.                 
  437.                 list[i] = re.compile(list[i])
  438.                 continue
  439.         
  440.         if timeout is not None:
  441.             time = time
  442.             import time
  443.             time_start = time()
  444.         
  445.         while None:
  446.             for i in indices:
  447.                 m = list[i].search(self.cookedq)
  448.                 if m:
  449.                     e = m.end()
  450.                     text = self.cookedq[:e]
  451.                     self.cookedq = self.cookedq[e:]
  452.                     return (i, m, text)
  453.             
  454.             if self.eof:
  455.                 break
  456.             
  457.             if timeout is not None:
  458.                 elapsed = time() - time_start
  459.                 if elapsed >= timeout:
  460.                     break
  461.                 
  462.                 s_args = ([
  463.                     self.fileno()], [], [], timeout - elapsed)
  464.                 (r, w, x) = select.select(*s_args)
  465.                 if not r:
  466.                     break
  467.                 
  468.             
  469.             self.fill_rawq()
  470.             continue
  471.             text = self.read_very_lazy()
  472.             if not text and self.eof:
  473.                 raise EOFError
  474.             self.eof
  475.             return (-1, None, text)
  476.  
  477.  
  478.  
  479. def test():
  480.     debuglevel = 0
  481.     while sys.argv[1:] and sys.argv[1] == '-d':
  482.         debuglevel = debuglevel + 1
  483.         del sys.argv[1]
  484.     host = 'localhost'
  485.     if sys.argv[1:]:
  486.         host = sys.argv[1]
  487.     
  488.     port = 0
  489.     if sys.argv[2:]:
  490.         portstr = sys.argv[2]
  491.         
  492.         try:
  493.             port = int(portstr)
  494.         except ValueError:
  495.             port = socket.getservbyname(portstr, 'tcp')
  496.         except:
  497.             None<EXCEPTION MATCH>ValueError
  498.         
  499.  
  500.     None<EXCEPTION MATCH>ValueError
  501.     tn = Telnet()
  502.     tn.set_debuglevel(debuglevel)
  503.     tn.open(host, port, timeout = 0.5)
  504.     tn.interact()
  505.     tn.close()
  506.  
  507. if __name__ == '__main__':
  508.     test()
  509.  
  510.