home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 October / maximum-cd-2011-10.iso / DiscContents / digsby_setup.exe / lib / ZSI / wstools / TimeoutSocket.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2011-06-22  |  5.3 KB  |  218 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  3.  
  4. ident = '$Id: TimeoutSocket.py 237 2003-05-20 21:10:14Z warnes $'
  5. import string
  6. import socket
  7. import select
  8. import errno
  9. WSAEINVAL = getattr(errno, 'WSAEINVAL', 10022)
  10.  
  11. class TimeoutSocket:
  12.     
  13.     def __init__(self, timeout = 20, sock = None):
  14.         self.timeout = float(timeout)
  15.         self.inbuf = ''
  16.         if sock is None:
  17.             sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  18.         
  19.         self.sock = sock
  20.         self.sock.setblocking(0)
  21.         self._rbuf = ''
  22.         self._wbuf = ''
  23.  
  24.     
  25.     def __getattr__(self, name):
  26.         return getattr(self.sock, name)
  27.  
  28.     
  29.     def connect(self, *addr):
  30.         timeout = self.timeout
  31.         sock = self.sock
  32.         
  33.         try:
  34.             sock.setblocking(0)
  35.             apply(sock.connect, addr)
  36.             sock.setblocking(timeout != 0)
  37.             return 1
  38.         except socket.error:
  39.             why = None
  40.             if not timeout:
  41.                 raise 
  42.             timeout
  43.             sock.setblocking(1)
  44.             if len(why.args) == 1:
  45.                 code = 0
  46.             else:
  47.                 (code, why) = why
  48.             if code not in (errno.EINPROGRESS, errno.EALREADY, errno.EWOULDBLOCK):
  49.                 raise 
  50.             code not in (errno.EINPROGRESS, errno.EALREADY, errno.EWOULDBLOCK)
  51.             (r, w, e) = select.select([], [
  52.                 sock], [], timeout)
  53.             if w:
  54.                 
  55.                 try:
  56.                     apply(sock.connect, addr)
  57.                     return 1
  58.                 except socket.error:
  59.                     why = None
  60.                     if len(why.args) == 1:
  61.                         code = 0
  62.                     else:
  63.                         (code, why) = why
  64.                     if code in (errno.EISCONN, WSAEINVAL):
  65.                         return 1
  66.                     raise 
  67.                 except:
  68.                     None<EXCEPTION MATCH>socket.error
  69.                 
  70.  
  71.             None<EXCEPTION MATCH>socket.error
  72.  
  73.         raise TimeoutError('socket connect() timeout.')
  74.  
  75.     
  76.     def send(self, data, flags = 0):
  77.         total = len(data)
  78.         next = 0
  79.         while None:
  80.             (r, w, e) = select.select([], [
  81.                 self.sock], [], self.timeout)
  82.             if w:
  83.                 buff = data[next:next + 8192]
  84.                 sent = self.sock.send(buff, flags)
  85.                 next = next + sent
  86.                 if next == total:
  87.                     return total
  88.                 continue
  89.             
  90.             raise TimeoutError('socket send() timeout.')
  91.             continue
  92.             return None
  93.  
  94.     
  95.     def recv(self, amt, flags = 0):
  96.         if select.select([
  97.             self.sock], [], [], self.timeout)[0]:
  98.             return self.sock.recv(amt, flags)
  99.         raise TimeoutError('socket recv() timeout.')
  100.  
  101.     buffsize = 4096
  102.     handles = 1
  103.     
  104.     def makefile(self, mode = 'r', buffsize = -1):
  105.         self.handles = self.handles + 1
  106.         self.mode = mode
  107.         return self
  108.  
  109.     
  110.     def close(self):
  111.         self.handles = self.handles - 1
  112.         if self.handles == 0 and self.sock.fileno() >= 0:
  113.             self.sock.close()
  114.         
  115.  
  116.     
  117.     def read(self, n = -1):
  118.         if not isinstance(n, type(1)):
  119.             n = -1
  120.         
  121.         if n >= 0:
  122.             k = len(self._rbuf)
  123.             if n <= k:
  124.                 data = self._rbuf[:n]
  125.                 self._rbuf = self._rbuf[n:]
  126.                 return data
  127.             n = n - k
  128.             L = [
  129.                 self._rbuf]
  130.             self._rbuf = ''
  131.             while n > 0:
  132.                 new = self.recv(max(n, self.buffsize))
  133.                 if not new:
  134.                     break
  135.                 
  136.                 k = len(new)
  137.                 if k > n:
  138.                     L.append(new[:n])
  139.                     self._rbuf = new[n:]
  140.                     break
  141.                 
  142.                 L.append(new)
  143.                 n = n - k
  144.             return ''.join(L)
  145.         k = max(4096, self.buffsize)
  146.         L = [
  147.             self._rbuf]
  148.         self._rbuf = ''
  149.         while None:
  150.             new = self.recv(k)
  151.             if not new:
  152.                 break
  153.             
  154.             k = min(k * 2, 1048576)
  155.             continue
  156.             return ''.join(L)
  157.  
  158.     
  159.     def readline(self, limit = -1):
  160.         data = ''
  161.         i = self._rbuf.find('\n')
  162.         while i < 0 and not None if limit < limit else limit <= len(self._rbuf):
  163.             new = self.recv(self.buffsize)
  164.             if not new:
  165.                 break
  166.             
  167.             i = new.find('\n')
  168.             if i >= 0:
  169.                 i = i + len(self._rbuf)
  170.             
  171.             self._rbuf = self._rbuf + new
  172.         if i < 0:
  173.             i = len(self._rbuf)
  174.         else:
  175.             i = i + 1
  176.         if limit <= limit:
  177.             pass
  178.         elif limit < len(self._rbuf):
  179.             i = limit
  180.         
  181.         data = self._rbuf[:i]
  182.         self._rbuf = self._rbuf[i:]
  183.         return data
  184.  
  185.     
  186.     def readlines(self, sizehint = 0):
  187.         total = 0
  188.         list = []
  189.         while None:
  190.             line = self.readline()
  191.             if not line:
  192.                 break
  193.             
  194.             total += len(line)
  195.             if sizehint and total >= sizehint:
  196.                 break
  197.                 continue
  198.             continue
  199.             return list
  200.  
  201.     
  202.     def writelines(self, list):
  203.         self.send(''.join(list))
  204.  
  205.     
  206.     def write(self, data):
  207.         self.send(data)
  208.  
  209.     
  210.     def flush(self):
  211.         pass
  212.  
  213.  
  214.  
  215. class TimeoutError(Exception):
  216.     pass
  217.  
  218.