home *** CD-ROM | disk | FTP | other *** search
/ GameStar 2006 January / Gamestar_80_2006-01_dvd.iso / Dema / Civilization4 / data1.cab / Civ4DemoComponent / Assets / Python / System / poplib.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2005-11-09  |  12.7 KB  |  437 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. '''A POP3 client class.
  5.  
  6. Based on the J. Myers POP3 draft, Jan. 96
  7. '''
  8. import re
  9. import socket
  10. __all__ = [
  11.     'POP3',
  12.     'error_proto',
  13.     'POP3_SSL']
  14.  
  15. class error_proto(Exception):
  16.     pass
  17.  
  18. POP3_PORT = 110
  19. POP3_SSL_PORT = 995
  20. CR = '\r'
  21. LF = '\n'
  22. CRLF = CR + LF
  23.  
  24. class POP3:
  25.     """This class supports both the minimal and optional command sets.
  26.     Arguments can be strings or integers (where appropriate)
  27.     (e.g.: retr(1) and retr('1') both work equally well.
  28.  
  29.     Minimal Command Set:
  30.             USER name               user(name)
  31.             PASS string             pass_(string)
  32.             STAT                    stat()
  33.             LIST [msg]              list(msg = None)
  34.             RETR msg                retr(msg)
  35.             DELE msg                dele(msg)
  36.             NOOP                    noop()
  37.             RSET                    rset()
  38.             QUIT                    quit()
  39.  
  40.     Optional Commands (some servers support these):
  41.             RPOP name               rpop(name)
  42.             APOP name digest        apop(name, digest)
  43.             TOP msg n               top(msg, n)
  44.             UIDL [msg]              uidl(msg = None)
  45.  
  46.     Raises one exception: 'error_proto'.
  47.  
  48.     Instantiate with:
  49.             POP3(hostname, port=110)
  50.  
  51.     NB:     the POP protocol locks the mailbox from user
  52.             authorization until QUIT, so be sure to get in, suck
  53.             the messages, and quit, each time you access the
  54.             mailbox.
  55.  
  56.             POP is a line-based protocol, which means large mail
  57.             messages consume lots of python cycles reading them
  58.             line-by-line.
  59.  
  60.             If it's available on your mail server, use IMAP4
  61.             instead, it doesn't suffer from the two problems
  62.             above.
  63.     """
  64.     
  65.     def __init__(self, host, port = POP3_PORT):
  66.         self.host = host
  67.         self.port = port
  68.         msg = 'getaddrinfo returns an empty list'
  69.         self.sock = None
  70.         for res in socket.getaddrinfo(self.host, self.port, 0, socket.SOCK_STREAM):
  71.             (af, socktype, proto, canonname, sa) = res
  72.             
  73.             try:
  74.                 self.sock = socket.socket(af, socktype, proto)
  75.                 self.sock.connect(sa)
  76.             except socket.error:
  77.                 msg = None
  78.                 if self.sock:
  79.                     self.sock.close()
  80.                 
  81.                 self.sock = None
  82.                 continue
  83.  
  84.         
  85.         if not self.sock:
  86.             raise socket.error, msg
  87.         
  88.         self.file = self.sock.makefile('rb')
  89.         self._debugging = 0
  90.         self.welcome = self._getresp()
  91.  
  92.     
  93.     def _putline(self, line):
  94.         if self._debugging > 1:
  95.             print '*put*', repr(line)
  96.         
  97.         self.sock.sendall('%s%s' % (line, CRLF))
  98.  
  99.     
  100.     def _putcmd(self, line):
  101.         if self._debugging:
  102.             print '*cmd*', repr(line)
  103.         
  104.         self._putline(line)
  105.  
  106.     
  107.     def _getline(self):
  108.         line = self.file.readline()
  109.         if self._debugging > 1:
  110.             print '*get*', repr(line)
  111.         
  112.         if not line:
  113.             raise error_proto('-ERR EOF')
  114.         
  115.         octets = len(line)
  116.         if line[-2:] == CRLF:
  117.             return (line[:-2], octets)
  118.         
  119.         if line[0] == CR:
  120.             return (line[1:-1], octets)
  121.         
  122.         return (line[:-1], octets)
  123.  
  124.     
  125.     def _getresp(self):
  126.         (resp, o) = self._getline()
  127.         if self._debugging > 1:
  128.             print '*resp*', repr(resp)
  129.         
  130.         c = resp[:1]
  131.         if c != '+':
  132.             raise error_proto(resp)
  133.         
  134.         return resp
  135.  
  136.     
  137.     def _getlongresp(self):
  138.         resp = self._getresp()
  139.         list = []
  140.         octets = 0
  141.         (line, o) = self._getline()
  142.         while line != '.':
  143.             if line[:2] == '..':
  144.                 o = o - 1
  145.                 line = line[1:]
  146.             
  147.             octets = octets + o
  148.             list.append(line)
  149.             (line, o) = self._getline()
  150.         return (resp, list, octets)
  151.  
  152.     
  153.     def _shortcmd(self, line):
  154.         self._putcmd(line)
  155.         return self._getresp()
  156.  
  157.     
  158.     def _longcmd(self, line):
  159.         self._putcmd(line)
  160.         return self._getlongresp()
  161.  
  162.     
  163.     def getwelcome(self):
  164.         return self.welcome
  165.  
  166.     
  167.     def set_debuglevel(self, level):
  168.         self._debugging = level
  169.  
  170.     
  171.     def user(self, user):
  172.         '''Send user name, return response
  173.  
  174.         (should indicate password required).
  175.         '''
  176.         return self._shortcmd('USER %s' % user)
  177.  
  178.     
  179.     def pass_(self, pswd):
  180.         """Send password, return response
  181.  
  182.         (response includes message count, mailbox size).
  183.  
  184.         NB: mailbox is locked by server from here to 'quit()'
  185.         """
  186.         return self._shortcmd('PASS %s' % pswd)
  187.  
  188.     
  189.     def stat(self):
  190.         '''Get mailbox status.
  191.  
  192.         Result is tuple of 2 ints (message count, mailbox size)
  193.         '''
  194.         retval = self._shortcmd('STAT')
  195.         rets = retval.split()
  196.         if self._debugging:
  197.             print '*stat*', repr(rets)
  198.         
  199.         numMessages = int(rets[1])
  200.         sizeMessages = int(rets[2])
  201.         return (numMessages, sizeMessages)
  202.  
  203.     
  204.     def list(self, which = None):
  205.         '''Request listing, return result.
  206.  
  207.         Result without a message number argument is in form
  208.         [\'response\', [\'mesg_num octets\', ...]].
  209.  
  210.         Result when a message number argument is given is a
  211.         single response: the "scan listing" for that message.
  212.         '''
  213.         if which is not None:
  214.             return self._shortcmd('LIST %s' % which)
  215.         
  216.         return self._longcmd('LIST')
  217.  
  218.     
  219.     def retr(self, which):
  220.         """Retrieve whole message number 'which'.
  221.  
  222.         Result is in form ['response', ['line', ...], octets].
  223.         """
  224.         return self._longcmd('RETR %s' % which)
  225.  
  226.     
  227.     def dele(self, which):
  228.         """Delete message number 'which'.
  229.  
  230.         Result is 'response'.
  231.         """
  232.         return self._shortcmd('DELE %s' % which)
  233.  
  234.     
  235.     def noop(self):
  236.         '''Does nothing.
  237.  
  238.         One supposes the response indicates the server is alive.
  239.         '''
  240.         return self._shortcmd('NOOP')
  241.  
  242.     
  243.     def rset(self):
  244.         '''Not sure what this does.'''
  245.         return self._shortcmd('RSET')
  246.  
  247.     
  248.     def quit(self):
  249.         '''Signoff: commit changes on server, unlock mailbox, close connection.'''
  250.         
  251.         try:
  252.             resp = self._shortcmd('QUIT')
  253.         except error_proto:
  254.             val = None
  255.             resp = val
  256.  
  257.         self.file.close()
  258.         self.sock.close()
  259.         del self.file
  260.         del self.sock
  261.         return resp
  262.  
  263.     
  264.     def rpop(self, user):
  265.         '''Not sure what this does.'''
  266.         return self._shortcmd('RPOP %s' % user)
  267.  
  268.     timestamp = re.compile('\\+OK.*(<[^>]+>)')
  269.     
  270.     def apop(self, user, secret):
  271.         """Authorisation
  272.  
  273.         - only possible if server has supplied a timestamp in initial greeting.
  274.  
  275.         Args:
  276.                 user    - mailbox user;
  277.                 secret  - secret shared between client and server.
  278.  
  279.         NB: mailbox is locked by server from here to 'quit()'
  280.         """
  281.         m = self.timestamp.match(self.welcome)
  282.         if not m:
  283.             raise error_proto('-ERR APOP not supported by server')
  284.         
  285.         import md5
  286.         digest = md5.new(m.group(1) + secret).digest()
  287.         digest = ''.join(map((lambda x: '%02x' % ord(x)), digest))
  288.         return self._shortcmd('APOP %s %s' % (user, digest))
  289.  
  290.     
  291.     def top(self, which, howmuch):
  292.         """Retrieve message header of message number 'which'
  293.         and first 'howmuch' lines of message body.
  294.  
  295.         Result is in form ['response', ['line', ...], octets].
  296.         """
  297.         return self._longcmd('TOP %s %s' % (which, howmuch))
  298.  
  299.     
  300.     def uidl(self, which = None):
  301.         """Return message digest (unique id) list.
  302.  
  303.         If 'which', result contains unique id for that message
  304.         in the form 'response mesgnum uid', otherwise result is
  305.         the list ['response', ['mesgnum uid', ...], octets]
  306.         """
  307.         if which is not None:
  308.             return self._shortcmd('UIDL %s' % which)
  309.         
  310.         return self._longcmd('UIDL')
  311.  
  312.  
  313.  
  314. class POP3_SSL(POP3):
  315.     '''POP3 client class over SSL connection
  316.  
  317.     Instantiate with: POP3_SSL(hostname, port=995, keyfile=None, certfile=None)
  318.  
  319.            hostname - the hostname of the pop3 over ssl server
  320.            port - port number
  321.            keyfile - PEM formatted file that countains your private key
  322.            certfile - PEM formatted certificate chain file
  323.  
  324.         See the methods of the parent class POP3 for more documentation.
  325.     '''
  326.     
  327.     def __init__(self, host, port = POP3_SSL_PORT, keyfile = None, certfile = None):
  328.         self.host = host
  329.         self.port = port
  330.         self.keyfile = keyfile
  331.         self.certfile = certfile
  332.         self.buffer = ''
  333.         msg = 'getaddrinfo returns an empty list'
  334.         self.sock = None
  335.         for res in socket.getaddrinfo(self.host, self.port, 0, socket.SOCK_STREAM):
  336.             (af, socktype, proto, canonname, sa) = res
  337.             
  338.             try:
  339.                 self.sock = socket.socket(af, socktype, proto)
  340.                 self.sock.connect(sa)
  341.             except socket.error:
  342.                 msg = None
  343.                 if self.sock:
  344.                     self.sock.close()
  345.                 
  346.                 self.sock = None
  347.                 continue
  348.  
  349.         
  350.         if not self.sock:
  351.             raise socket.error, msg
  352.         
  353.         self.file = self.sock.makefile('rb')
  354.         self.sslobj = socket.ssl(self.sock, self.keyfile, self.certfile)
  355.         self._debugging = 0
  356.         self.welcome = self._getresp()
  357.  
  358.     
  359.     def _fillBuffer(self):
  360.         localbuf = self.sslobj.read()
  361.         if len(localbuf) == 0:
  362.             raise error_proto('-ERR EOF')
  363.         
  364.         self.buffer += localbuf
  365.  
  366.     
  367.     def _getline(self):
  368.         line = ''
  369.         renewline = re.compile('.*?\\n')
  370.         match = renewline.match(self.buffer)
  371.         while not match:
  372.             self._fillBuffer()
  373.             match = renewline.match(self.buffer)
  374.         line = match.group(0)
  375.         self.buffer = renewline.sub('', self.buffer, 1)
  376.         if self._debugging > 1:
  377.             print '*get*', repr(line)
  378.         
  379.         octets = len(line)
  380.         if line[-2:] == CRLF:
  381.             return (line[:-2], octets)
  382.         
  383.         if line[0] == CR:
  384.             return (line[1:-1], octets)
  385.         
  386.         return (line[:-1], octets)
  387.  
  388.     
  389.     def _putline(self, line):
  390.         if self._debugging > 1:
  391.             print '*put*', repr(line)
  392.         
  393.         line += CRLF
  394.         bytes = len(line)
  395.         while bytes > 0:
  396.             sent = self.sslobj.write(line)
  397.             if sent == bytes:
  398.                 break
  399.             
  400.             line = line[sent:]
  401.             bytes = bytes - sent
  402.  
  403.     
  404.     def quit(self):
  405.         '''Signoff: commit changes on server, unlock mailbox, close connection.'''
  406.         
  407.         try:
  408.             resp = self._shortcmd('QUIT')
  409.         except error_proto:
  410.             val = None
  411.             resp = val
  412.  
  413.         self.sock.close()
  414.         del self.sslobj
  415.         del self.sock
  416.         return resp
  417.  
  418.  
  419. if __name__ == '__main__':
  420.     import sys
  421.     a = POP3(sys.argv[1])
  422.     print a.getwelcome()
  423.     a.user(sys.argv[2])
  424.     a.pass_(sys.argv[3])
  425.     a.list()
  426.     (numMsgs, totalSize) = a.stat()
  427.     for i in range(1, numMsgs + 1):
  428.         (header, msg, octets) = a.retr(i)
  429.         print 'Message %d:' % i
  430.         for line in msg:
  431.             print '   ' + line
  432.         
  433.         print '-----------------------'
  434.     
  435.     a.quit()
  436.  
  437.