home *** CD-ROM | disk | FTP | other *** search
/ Freelog 116 / FreelogNo116-JuilletSeptembre2013.iso / Bureautique / gImageReader / gimagereader_0.9-1_win32.exe / bin / ftplib.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2011-03-24  |  32KB  |  1,108 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.7)
  3.  
  4. """An FTP client class and some helper functions.
  5.  
  6. Based on RFC 959: File Transfer Protocol (FTP), by J. Postel and J. Reynolds
  7.  
  8. Example:
  9.  
  10. >>> from ftplib import FTP
  11. >>> ftp = FTP('ftp.python.org') # connect to host, default port
  12. >>> ftp.login() # default, i.e.: user anonymous, passwd anonymous@
  13. '230 Guest login ok, access restrictions apply.'
  14. >>> ftp.retrlines('LIST') # list directory contents
  15. total 9
  16. drwxr-xr-x   8 root     wheel        1024 Jan  3  1994 .
  17. drwxr-xr-x   8 root     wheel        1024 Jan  3  1994 ..
  18. drwxr-xr-x   2 root     wheel        1024 Jan  3  1994 bin
  19. drwxr-xr-x   2 root     wheel        1024 Jan  3  1994 etc
  20. d-wxrwxr-x   2 ftp      wheel        1024 Sep  5 13:43 incoming
  21. drwxr-xr-x   2 root     wheel        1024 Nov 17  1993 lib
  22. drwxr-xr-x   6 1094     wheel        1024 Sep 13 19:07 pub
  23. drwxr-xr-x   3 root     wheel        1024 Jan  3  1994 usr
  24. -rw-r--r--   1 root     root          312 Aug  1  1994 welcome.msg
  25. '226 Transfer complete.'
  26. >>> ftp.quit()
  27. '221 Goodbye.'
  28. >>>
  29.  
  30. A nice test that reveals some of the network dialogue would be:
  31. python ftplib.py -d localhost -l -p -l
  32. """
  33. import os
  34. import sys
  35.  
  36. try:
  37.     import SOCKS
  38.     socket = SOCKS
  39.     del SOCKS
  40.     from socket import getfqdn
  41.     socket.getfqdn = getfqdn
  42.     del getfqdn
  43. except ImportError:
  44.     import socket
  45.  
  46. from socket import _GLOBAL_DEFAULT_TIMEOUT
  47. __all__ = [
  48.     'FTP',
  49.     'Netrc']
  50. MSG_OOB = 1
  51. FTP_PORT = 21
  52.  
  53. class Error(Exception):
  54.     pass
  55.  
  56.  
  57. class error_reply(Error):
  58.     pass
  59.  
  60.  
  61. class error_temp(Error):
  62.     pass
  63.  
  64.  
  65. class error_perm(Error):
  66.     pass
  67.  
  68.  
  69. class error_proto(Error):
  70.     pass
  71.  
  72. all_errors = (Error, IOError, EOFError)
  73. CRLF = '\r\n'
  74.  
  75. class FTP:
  76.     """An FTP client class.
  77.  
  78.     To create a connection, call the class using these arguments:
  79.             host, user, passwd, acct, timeout
  80.  
  81.     The first four arguments are all strings, and have default value ''.
  82.     timeout must be numeric and defaults to None if not passed,
  83.     meaning that no timeout will be set on any ftp socket(s)
  84.     If a timeout is passed, then this is now the default timeout for all ftp
  85.     socket operations for this instance.
  86.  
  87.     Then use self.connect() with optional host and port argument.
  88.  
  89.     To download a file, use ftp.retrlines('RETR ' + filename),
  90.     or ftp.retrbinary() with slightly different arguments.
  91.     To upload a file, use ftp.storlines() or ftp.storbinary(),
  92.     which have an open file as argument (see their definitions
  93.     below for details).
  94.     The download/upload functions first issue appropriate TYPE
  95.     and PORT or PASV commands.
  96. """
  97.     debugging = 0
  98.     host = ''
  99.     port = FTP_PORT
  100.     sock = None
  101.     file = None
  102.     welcome = None
  103.     passiveserver = 1
  104.     
  105.     def __init__(self, host = '', user = '', passwd = '', acct = '', timeout = _GLOBAL_DEFAULT_TIMEOUT):
  106.         self.timeout = timeout
  107.         if host:
  108.             self.connect(host)
  109.             if user:
  110.                 self.login(user, passwd, acct)
  111.             
  112.  
  113.     
  114.     def connect(self, host = '', port = 0, timeout = -999):
  115.         '''Connect to host.  Arguments are:
  116.          - host: hostname to connect to (string, default previous host)
  117.          - port: port to connect to (integer, default previous port)
  118.         '''
  119.         if host != '':
  120.             self.host = host
  121.         if port > 0:
  122.             self.port = port
  123.         if timeout != -999:
  124.             self.timeout = timeout
  125.         self.sock = socket.create_connection((self.host, self.port), self.timeout)
  126.         self.af = self.sock.family
  127.         self.file = self.sock.makefile('rb')
  128.         self.welcome = self.getresp()
  129.         return self.welcome
  130.  
  131.     
  132.     def getwelcome(self):
  133.         '''Get the welcome message from the server.
  134.         (this is read and squirreled away by connect())'''
  135.         if self.debugging:
  136.             print '*welcome*', self.sanitize(self.welcome)
  137.         return self.welcome
  138.  
  139.     
  140.     def set_debuglevel(self, level):
  141.         '''Set the debugging level.
  142.         The required argument level means:
  143.         0: no debugging output (default)
  144.         1: print commands and responses but not body text etc.
  145.         2: also print raw lines read and sent before stripping CR/LF'''
  146.         self.debugging = level
  147.  
  148.     debug = set_debuglevel
  149.     
  150.     def set_pasv(self, val):
  151.         '''Use passive or active mode for data transfers.
  152.         With a false argument, use the normal PORT mode,
  153.         With a true argument, use the PASV command.'''
  154.         self.passiveserver = val
  155.  
  156.     
  157.     def sanitize(self, s):
  158.         if s[:5] == 'pass ' or s[:5] == 'PASS ':
  159.             i = len(s)
  160.             while i > 5 and s[i - 1] in '\r\n':
  161.                 i = i - 1
  162.             s = s[:5] + '*' * (i - 5) + s[i:]
  163.         return repr(s)
  164.  
  165.     
  166.     def putline(self, line):
  167.         line = line + CRLF
  168.         if self.debugging > 1:
  169.             print '*put*', self.sanitize(line)
  170.         self.sock.sendall(line)
  171.  
  172.     
  173.     def putcmd(self, line):
  174.         if self.debugging:
  175.             print '*cmd*', self.sanitize(line)
  176.         self.putline(line)
  177.  
  178.     
  179.     def getline(self):
  180.         line = self.file.readline()
  181.         if self.debugging > 1:
  182.             print '*get*', self.sanitize(line)
  183.         if not line:
  184.             raise EOFError
  185.         if line[-2:] == CRLF:
  186.             line = line[:-2]
  187.         elif line[-1:] in CRLF:
  188.             line = line[:-1]
  189.         return line
  190.  
  191.     
  192.     def getmultiline(self):
  193.         line = self.getline()
  194.         if line[3:4] == '-':
  195.             code = line[:3]
  196.             while None:
  197.                 nextline = self.getline()
  198.                 line = line + '\n' + nextline
  199.                 if nextline[:3] == code and nextline[3:4] != '-':
  200.                     break
  201.                     continue
  202.                     continue
  203.                 return line
  204.  
  205.     
  206.     def getresp(self):
  207.         resp = self.getmultiline()
  208.         if self.debugging:
  209.             print '*resp*', self.sanitize(resp)
  210.         self.lastresp = resp[:3]
  211.         c = resp[:1]
  212.         if c in ('1', '2', '3'):
  213.             return resp
  214.         if None == '4':
  215.             raise error_temp, resp
  216.         if c == '5':
  217.             raise error_perm, resp
  218.         raise error_proto, resp
  219.  
  220.     
  221.     def voidresp(self):
  222.         """Expect a response beginning with '2'."""
  223.         resp = self.getresp()
  224.         if resp[:1] != '2':
  225.             raise error_reply, resp
  226.         return resp
  227.  
  228.     
  229.     def abort(self):
  230.         """Abort a file transfer.  Uses out-of-band data.
  231.         This does not follow the procedure from the RFC to send Telnet
  232.         IP and Synch; that doesn't seem to work with the servers I've
  233.         tried.  Instead, just send the ABOR command as OOB data."""
  234.         line = 'ABOR' + CRLF
  235.         if self.debugging > 1:
  236.             print '*put urgent*', self.sanitize(line)
  237.         self.sock.sendall(line, MSG_OOB)
  238.         resp = self.getmultiline()
  239.         if resp[:3] not in ('426', '225', '226'):
  240.             raise error_proto, resp
  241.  
  242.     
  243.     def sendcmd(self, cmd):
  244.         '''Send a command and return the response.'''
  245.         self.putcmd(cmd)
  246.         return self.getresp()
  247.  
  248.     
  249.     def voidcmd(self, cmd):
  250.         """Send a command and expect a response beginning with '2'."""
  251.         self.putcmd(cmd)
  252.         return self.voidresp()
  253.  
  254.     
  255.     def sendport(self, host, port):
  256.         '''Send a PORT command with the current host and the given
  257.         port number.
  258.         '''
  259.         hbytes = host.split('.')
  260.         pbytes = [
  261.             repr(port // 256),
  262.             repr(port % 256)]
  263.         bytes = hbytes + pbytes
  264.         cmd = 'PORT ' + ','.join(bytes)
  265.         return self.voidcmd(cmd)
  266.  
  267.     
  268.     def sendeprt(self, host, port):
  269.         '''Send a EPRT command with the current host and the given port number.'''
  270.         af = 0
  271.         if self.af == socket.AF_INET:
  272.             af = 1
  273.         if self.af == socket.AF_INET6:
  274.             af = 2
  275.         if af == 0:
  276.             raise error_proto, 'unsupported address family'
  277.         fields = [
  278.             '',
  279.             repr(af),
  280.             host,
  281.             repr(port),
  282.             '']
  283.         cmd = 'EPRT ' + '|'.join(fields)
  284.         return self.voidcmd(cmd)
  285.  
  286.     
  287.     def makeport(self):
  288.         '''Create a new socket and send a PORT command for it.'''
  289.         msg = 'getaddrinfo returns an empty list'
  290.         sock = None
  291.         for res in socket.getaddrinfo(None, 0, self.af, socket.SOCK_STREAM, 0, socket.AI_PASSIVE):
  292.             (af, socktype, proto, canonname, sa) = res
  293.             
  294.             try:
  295.                 sock = socket.socket(af, socktype, proto)
  296.                 sock.bind(sa)
  297.             except socket.error:
  298.                 msg = None
  299.                 if sock:
  300.                     sock.close()
  301.                 sock = None
  302.                 continue
  303.  
  304.             break
  305.         
  306.         if not sock:
  307.             raise socket.error, msg
  308.         sock.listen(1)
  309.         port = sock.getsockname()[1]
  310.         host = self.sock.getsockname()[0]
  311.         if self.af == socket.AF_INET:
  312.             resp = self.sendport(host, port)
  313.         else:
  314.             resp = self.sendeprt(host, port)
  315.         if self.timeout is not _GLOBAL_DEFAULT_TIMEOUT:
  316.             sock.settimeout(self.timeout)
  317.         return sock
  318.  
  319.     
  320.     def makepasv(self):
  321.         if self.af == socket.AF_INET:
  322.             (host, port) = parse227(self.sendcmd('PASV'))
  323.         else:
  324.             (host, port) = parse229(self.sendcmd('EPSV'), self.sock.getpeername())
  325.         return (host, port)
  326.  
  327.     
  328.     def ntransfercmd(self, cmd, rest = None):
  329.         """Initiate a transfer over the data connection.
  330.  
  331.         If the transfer is active, send a port command and the
  332.         transfer command, and accept the connection.  If the server is
  333.         passive, send a pasv command, connect to it, and start the
  334.         transfer command.  Either way, return the socket for the
  335.         connection and the expected size of the transfer.  The
  336.         expected size may be None if it could not be determined.
  337.  
  338.         Optional `rest' argument can be a string that is sent as the
  339.         argument to a REST command.  This is essentially a server
  340.         marker used to tell the server to skip over any data up to the
  341.         given marker.
  342.         """
  343.         size = None
  344.         if self.passiveserver:
  345.             (host, port) = self.makepasv()
  346.             conn = socket.create_connection((host, port), self.timeout)
  347.             if rest is not None:
  348.                 self.sendcmd('REST %s' % rest)
  349.             resp = self.sendcmd(cmd)
  350.             if resp[0] == '2':
  351.                 resp = self.getresp()
  352.             if resp[0] != '1':
  353.                 raise error_reply, resp
  354.         else:
  355.             sock = self.makeport()
  356.             if rest is not None:
  357.                 self.sendcmd('REST %s' % rest)
  358.             resp = self.sendcmd(cmd)
  359.             if resp[0] == '2':
  360.                 resp = self.getresp()
  361.             if resp[0] != '1':
  362.                 raise error_reply, resp
  363.             (conn, sockaddr) = sock.accept()
  364.             if self.timeout is not _GLOBAL_DEFAULT_TIMEOUT:
  365.                 conn.settimeout(self.timeout)
  366.         if resp[:3] == '150':
  367.             size = parse150(resp)
  368.         return (conn, size)
  369.  
  370.     
  371.     def transfercmd(self, cmd, rest = None):
  372.         '''Like ntransfercmd() but returns only the socket.'''
  373.         return self.ntransfercmd(cmd, rest)[0]
  374.  
  375.     
  376.     def login(self, user = '', passwd = '', acct = ''):
  377.         '''Login, default anonymous.'''
  378.         if not user:
  379.             user = 'anonymous'
  380.         if not passwd:
  381.             passwd = ''
  382.         if not acct:
  383.             acct = ''
  384.         if user == 'anonymous' and passwd in ('', '-'):
  385.             passwd = passwd + 'anonymous@'
  386.         resp = self.sendcmd('USER ' + user)
  387.         if resp[0] == '3':
  388.             resp = self.sendcmd('PASS ' + passwd)
  389.         if resp[0] == '3':
  390.             resp = self.sendcmd('ACCT ' + acct)
  391.         if resp[0] != '2':
  392.             raise error_reply, resp
  393.         return resp
  394.  
  395.     
  396.     def retrbinary(self, cmd, callback, blocksize = 8192, rest = None):
  397.         '''Retrieve data in binary mode.  A new port is created for you.
  398.  
  399.         Args:
  400.           cmd: A RETR command.
  401.           callback: A single parameter callable to be called on each
  402.                     block of data read.
  403.           blocksize: The maximum number of bytes to read from the
  404.                      socket at one time.  [default: 8192]
  405.           rest: Passed to transfercmd().  [default: None]
  406.  
  407.         Returns:
  408.           The response code.
  409.         '''
  410.         self.voidcmd('TYPE I')
  411.         conn = self.transfercmd(cmd, rest)
  412.         while None:
  413.             data = conn.recv(blocksize)
  414.             if not data:
  415.                 break
  416.             continue
  417.             conn.close()
  418.             return self.voidresp()
  419.  
  420.     
  421.     def retrlines(self, cmd, callback = None):
  422.         '''Retrieve data in line mode.  A new port is created for you.
  423.  
  424.         Args:
  425.           cmd: A RETR, LIST, NLST, or MLSD command.
  426.           callback: An optional single parameter callable that is called
  427.                     for each line with the trailing CRLF stripped.
  428.                     [default: print_line()]
  429.  
  430.         Returns:
  431.           The response code.
  432.         '''
  433.         if callback is None:
  434.             callback = print_line
  435.         resp = self.sendcmd('TYPE A')
  436.         conn = self.transfercmd(cmd)
  437.         fp = conn.makefile('rb')
  438.         while None:
  439.             line = fp.readline()
  440.             if self.debugging > 2:
  441.                 print '*retr*', repr(line)
  442.             if not line:
  443.                 break
  444.             if line[-2:] == CRLF:
  445.                 line = line[:-2]
  446.             elif line[-1:] == '\n':
  447.                 line = line[:-1]
  448.             continue
  449.             fp.close()
  450.             conn.close()
  451.             return self.voidresp()
  452.  
  453.     
  454.     def storbinary(self, cmd, fp, blocksize = 8192, callback = None, rest = None):
  455.         '''Store a file in binary mode.  A new port is created for you.
  456.  
  457.         Args:
  458.           cmd: A STOR command.
  459.           fp: A file-like object with a read(num_bytes) method.
  460.           blocksize: The maximum data size to read from fp and send over
  461.                      the connection at once.  [default: 8192]
  462.           callback: An optional single parameter callable that is called on
  463.                     on each block of data after it is sent.  [default: None]
  464.           rest: Passed to transfercmd().  [default: None]
  465.  
  466.         Returns:
  467.           The response code.
  468.         '''
  469.         self.voidcmd('TYPE I')
  470.         conn = self.transfercmd(cmd, rest)
  471.         while None:
  472.             buf = fp.read(blocksize)
  473.             if not buf:
  474.                 break
  475.             if callback:
  476.                 callback(buf)
  477.                 continue
  478.                 continue
  479.                 conn.close()
  480.                 return self.voidresp()
  481.  
  482.     
  483.     def storlines(self, cmd, fp, callback = None):
  484.         '''Store a file in line mode.  A new port is created for you.
  485.  
  486.         Args:
  487.           cmd: A STOR command.
  488.           fp: A file-like object with a readline() method.
  489.           callback: An optional single parameter callable that is called on
  490.                     on each line after it is sent.  [default: None]
  491.  
  492.         Returns:
  493.           The response code.
  494.         '''
  495.         self.voidcmd('TYPE A')
  496.         conn = self.transfercmd(cmd)
  497.         while None:
  498.             buf = fp.readline()
  499.             if not buf:
  500.                 break
  501.             if buf[-2:] != CRLF:
  502.                 if buf[-1] in CRLF:
  503.                     buf = buf[:-1]
  504.                 buf = buf + CRLF
  505.             if callback:
  506.                 callback(buf)
  507.                 continue
  508.                 continue
  509.                 conn.close()
  510.                 return self.voidresp()
  511.  
  512.     
  513.     def acct(self, password):
  514.         '''Send new account name.'''
  515.         cmd = 'ACCT ' + password
  516.         return self.voidcmd(cmd)
  517.  
  518.     
  519.     def nlst(self, *args):
  520.         '''Return a list of files in a given directory (default the current).'''
  521.         cmd = 'NLST'
  522.         for arg in args:
  523.             cmd = cmd + ' ' + arg
  524.         
  525.         files = []
  526.         self.retrlines(cmd, files.append)
  527.         return files
  528.  
  529.     
  530.     def dir(self, *args):
  531.         '''List a directory in long form.
  532.         By default list current directory to stdout.
  533.         Optional last argument is callback function; all
  534.         non-empty arguments before it are concatenated to the
  535.         LIST command.  (This *should* only be used for a pathname.)'''
  536.         cmd = 'LIST'
  537.         func = None
  538.         if args[-1:] and type(args[-1]) != type(''):
  539.             args = args[:-1]
  540.             func = args[-1]
  541.         for arg in args:
  542.             if arg:
  543.                 cmd = cmd + ' ' + arg
  544.                 continue
  545.         self.retrlines(cmd, func)
  546.  
  547.     
  548.     def rename(self, fromname, toname):
  549.         '''Rename a file.'''
  550.         resp = self.sendcmd('RNFR ' + fromname)
  551.         if resp[0] != '3':
  552.             raise error_reply, resp
  553.         return self.voidcmd('RNTO ' + toname)
  554.  
  555.     
  556.     def delete(self, filename):
  557.         '''Delete a file.'''
  558.         resp = self.sendcmd('DELE ' + filename)
  559.         if resp[:3] in ('250', '200'):
  560.             return resp
  561.         raise None, resp
  562.  
  563.     
  564.     def cwd(self, dirname):
  565.         '''Change to a directory.'''
  566.         if dirname == '..':
  567.             
  568.             try:
  569.                 return self.voidcmd('CDUP')
  570.             except error_perm:
  571.                 msg = None
  572.                 if msg.args[0][:3] != '500':
  573.                     raise 
  574.             
  575.  
  576.         if dirname == '':
  577.             dirname = '.'
  578.         cmd = 'CWD ' + dirname
  579.         return self.voidcmd(cmd)
  580.  
  581.     
  582.     def size(self, filename):
  583.         '''Retrieve the size of a file.'''
  584.         resp = self.sendcmd('SIZE ' + filename)
  585.         if resp[:3] == '213':
  586.             s = resp[3:].strip()
  587.             
  588.             try:
  589.                 return int(s)
  590.             except (OverflowError, ValueError):
  591.                 return long(s)
  592.             
  593.  
  594.  
  595.     
  596.     def mkd(self, dirname):
  597.         '''Make a directory, return its full pathname.'''
  598.         resp = self.sendcmd('MKD ' + dirname)
  599.         return parse257(resp)
  600.  
  601.     
  602.     def rmd(self, dirname):
  603.         '''Remove a directory.'''
  604.         return self.voidcmd('RMD ' + dirname)
  605.  
  606.     
  607.     def pwd(self):
  608.         '''Return current working directory.'''
  609.         resp = self.sendcmd('PWD')
  610.         return parse257(resp)
  611.  
  612.     
  613.     def quit(self):
  614.         '''Quit, and close the connection.'''
  615.         resp = self.voidcmd('QUIT')
  616.         self.close()
  617.         return resp
  618.  
  619.     
  620.     def close(self):
  621.         '''Close the connection without assuming anything about it.'''
  622.         if self.file:
  623.             self.file.close()
  624.             self.sock.close()
  625.             self.file = None
  626.             self.sock = None
  627.  
  628.  
  629.  
  630. try:
  631.     import ssl
  632. except ImportError:
  633.     pass
  634.  
  635.  
  636. class FTP_TLS(FTP):
  637.     """A FTP subclass which adds TLS support to FTP as described
  638.         in RFC-4217.
  639.  
  640.         Connect as usual to port 21 implicitly securing the FTP control
  641.         connection before authenticating.
  642.  
  643.         Securing the data connection requires user to explicitly ask
  644.         for it by calling prot_p() method.
  645.  
  646.         Usage example:
  647.         >>> from ftplib import FTP_TLS
  648.         >>> ftps = FTP_TLS('ftp.python.org')
  649.         >>> ftps.login()  # login anonimously previously securing control channel
  650.         '230 Guest login ok, access restrictions apply.'
  651.         >>> ftps.prot_p()  # switch to secure data connection
  652.         '200 Protection level set to P'
  653.         >>> ftps.retrlines('LIST')  # list directory content securely
  654.         total 9
  655.         drwxr-xr-x   8 root     wheel        1024 Jan  3  1994 .
  656.         drwxr-xr-x   8 root     wheel        1024 Jan  3  1994 ..
  657.         drwxr-xr-x   2 root     wheel        1024 Jan  3  1994 bin
  658.         drwxr-xr-x   2 root     wheel        1024 Jan  3  1994 etc
  659.         d-wxrwxr-x   2 ftp      wheel        1024 Sep  5 13:43 incoming
  660.         drwxr-xr-x   2 root     wheel        1024 Nov 17  1993 lib
  661.         drwxr-xr-x   6 1094     wheel        1024 Sep 13 19:07 pub
  662.         drwxr-xr-x   3 root     wheel        1024 Jan  3  1994 usr
  663.         -rw-r--r--   1 root     root          312 Aug  1  1994 welcome.msg
  664.         '226 Transfer complete.'
  665.         >>> ftps.quit()
  666.         '221 Goodbye.'
  667.         >>>
  668.         """
  669.     ssl_version = ssl.PROTOCOL_TLSv1
  670.     
  671.     def __init__(self, host = '', user = '', passwd = '', acct = '', keyfile = None, certfile = None, timeout = _GLOBAL_DEFAULT_TIMEOUT):
  672.         self.keyfile = keyfile
  673.         self.certfile = certfile
  674.         self._prot_p = False
  675.         FTP.__init__(self, host, user, passwd, acct, timeout)
  676.  
  677.     
  678.     def login(self, user = '', passwd = '', acct = '', secure = True):
  679.         if secure and not isinstance(self.sock, ssl.SSLSocket):
  680.             self.auth()
  681.         return FTP.login(self, user, passwd, acct)
  682.  
  683.     
  684.     def auth(self):
  685.         '''Set up secure control connection by using TLS/SSL.'''
  686.         if isinstance(self.sock, ssl.SSLSocket):
  687.             raise ValueError('Already using TLS')
  688.         if self.ssl_version == ssl.PROTOCOL_TLSv1:
  689.             resp = self.voidcmd('AUTH TLS')
  690.         else:
  691.             resp = self.voidcmd('AUTH SSL')
  692.         self.sock = ssl.wrap_socket(self.sock, self.keyfile, self.certfile, ssl_version = self.ssl_version)
  693.         self.file = self.sock.makefile(mode = 'rb')
  694.         return resp
  695.  
  696.     
  697.     def prot_p(self):
  698.         '''Set up secure data connection.'''
  699.         self.voidcmd('PBSZ 0')
  700.         resp = self.voidcmd('PROT P')
  701.         self._prot_p = True
  702.         return resp
  703.  
  704.     
  705.     def prot_c(self):
  706.         '''Set up clear text data connection.'''
  707.         resp = self.voidcmd('PROT C')
  708.         self._prot_p = False
  709.         return resp
  710.  
  711.     
  712.     def ntransfercmd(self, cmd, rest = None):
  713.         (conn, size) = FTP.ntransfercmd(self, cmd, rest)
  714.         if self._prot_p:
  715.             conn = ssl.wrap_socket(conn, self.keyfile, self.certfile, ssl_version = self.ssl_version)
  716.         return (conn, size)
  717.  
  718.     
  719.     def retrbinary(self, cmd, callback, blocksize = 8192, rest = None):
  720.         self.voidcmd('TYPE I')
  721.         conn = self.transfercmd(cmd, rest)
  722.         
  723.         try:
  724.             while None:
  725.                 data = conn.recv(blocksize)
  726.                 if not data:
  727.                     break
  728.                 continue
  729.                 if isinstance(conn, ssl.SSLSocket):
  730.                     conn.unwrap()
  731.             conn.close()
  732.             return self.voidresp()
  733.  
  734.  
  735.     
  736.     def retrlines(self, cmd, callback = None):
  737.         if callback is None:
  738.             callback = print_line
  739.         resp = self.sendcmd('TYPE A')
  740.         conn = self.transfercmd(cmd)
  741.         fp = conn.makefile('rb')
  742.         
  743.         try:
  744.             while None:
  745.                 line = fp.readline()
  746.                 if self.debugging > 2:
  747.                     print '*retr*', repr(line)
  748.                 if not line:
  749.                     break
  750.                 if line[-2:] == CRLF:
  751.                     line = line[:-2]
  752.                 elif line[-1:] == '\n':
  753.                     line = line[:-1]
  754.                 continue
  755.                 if isinstance(conn, ssl.SSLSocket):
  756.                     conn.unwrap()
  757.             fp.close()
  758.             conn.close()
  759.             return self.voidresp()
  760.  
  761.  
  762.     
  763.     def storbinary(self, cmd, fp, blocksize = 8192, callback = None, rest = None):
  764.         self.voidcmd('TYPE I')
  765.         conn = self.transfercmd(cmd, rest)
  766.         
  767.         try:
  768.             while None:
  769.                 buf = fp.read(blocksize)
  770.                 if not buf:
  771.                     break
  772.                 if callback:
  773.                     callback(buf)
  774.                     continue
  775.                     continue
  776.                     if isinstance(conn, ssl.SSLSocket):
  777.                         conn.unwrap()
  778.                 conn.close()
  779.                 return self.voidresp()
  780.  
  781.  
  782.     
  783.     def storlines(self, cmd, fp, callback = None):
  784.         self.voidcmd('TYPE A')
  785.         conn = self.transfercmd(cmd)
  786.         
  787.         try:
  788.             while None:
  789.                 buf = fp.readline()
  790.                 if not buf:
  791.                     break
  792.                 if buf[-2:] != CRLF:
  793.                     if buf[-1] in CRLF:
  794.                         buf = buf[:-1]
  795.                     buf = buf + CRLF
  796.                 if callback:
  797.                     callback(buf)
  798.                     continue
  799.                     continue
  800.                     if isinstance(conn, ssl.SSLSocket):
  801.                         conn.unwrap()
  802.                 conn.close()
  803.                 return self.voidresp()
  804.  
  805.  
  806.  
  807. __all__.append('FTP_TLS')
  808. all_errors = (Error, IOError, EOFError, ssl.SSLError)
  809. _150_re = None
  810.  
  811. def parse150(resp):
  812.     """Parse the '150' response for a RETR request.
  813.     Returns the expected transfer size or None; size is not guaranteed to
  814.     be present in the 150 message.
  815.     """
  816.     global _150_re
  817.     if resp[:3] != '150':
  818.         raise error_reply, resp
  819.     if _150_re is None:
  820.         import re as re
  821.         _150_re = re.compile('150 .* \\((\\d+) bytes\\)', re.IGNORECASE)
  822.     m = _150_re.match(resp)
  823.     if not m:
  824.         return None
  825.     s = None.group(1)
  826.     
  827.     try:
  828.         return int(s)
  829.     except (OverflowError, ValueError):
  830.         return long(s)
  831.  
  832.  
  833. _227_re = None
  834.  
  835. def parse227(resp):
  836.     """Parse the '227' response for a PASV request.
  837.     Raises error_proto if it does not contain '(h1,h2,h3,h4,p1,p2)'
  838.     Return ('host.addr.as.numbers', port#) tuple."""
  839.     global _227_re
  840.     if resp[:3] != '227':
  841.         raise error_reply, resp
  842.     if _227_re is None:
  843.         import re
  844.         _227_re = re.compile('(\\d+),(\\d+),(\\d+),(\\d+),(\\d+),(\\d+)')
  845.     m = _227_re.search(resp)
  846.     if not m:
  847.         raise error_proto, resp
  848.     numbers = m.groups()
  849.     host = '.'.join(numbers[:4])
  850.     port = (int(numbers[4]) << 8) + int(numbers[5])
  851.     return (host, port)
  852.  
  853.  
  854. def parse229(resp, peer):
  855.     """Parse the '229' response for a EPSV request.
  856.     Raises error_proto if it does not contain '(|||port|)'
  857.     Return ('host.addr.as.numbers', port#) tuple."""
  858.     if resp[:3] != '229':
  859.         raise error_reply, resp
  860.     left = resp.find('(')
  861.     if left < 0:
  862.         raise error_proto, resp
  863.     right = resp.find(')', left + 1)
  864.     if right < 0:
  865.         raise error_proto, resp
  866.     if resp[left + 1] != resp[right - 1]:
  867.         raise error_proto, resp
  868.     parts = resp[left + 1:right].split(resp[left + 1])
  869.     if len(parts) != 5:
  870.         raise error_proto, resp
  871.     host = peer[0]
  872.     port = int(parts[3])
  873.     return (host, port)
  874.  
  875.  
  876. def parse257(resp):
  877.     """Parse the '257' response for a MKD or PWD request.
  878.     This is a response to a MKD or PWD request: a directory name.
  879.     Returns the directoryname in the 257 reply."""
  880.     if resp[:3] != '257':
  881.         raise error_reply, resp
  882.     if resp[3:5] != ' "':
  883.         return ''
  884.     dirname = None
  885.     i = 5
  886.     n = len(resp)
  887.     while i < n:
  888.         c = resp[i]
  889.         i = i + 1
  890.         if c == '"':
  891.             if i >= n or resp[i] != '"':
  892.                 break
  893.             i = i + 1
  894.         dirname = dirname + c
  895.     return dirname
  896.  
  897.  
  898. def print_line(line):
  899.     '''Default retrlines callback to print a line.'''
  900.     print line
  901.  
  902.  
  903. def ftpcp(source, sourcename, target, targetname = '', type = 'I'):
  904.     '''Copy file from one FTP-instance to another.'''
  905.     if not targetname:
  906.         targetname = sourcename
  907.     type = 'TYPE ' + type
  908.     source.voidcmd(type)
  909.     target.voidcmd(type)
  910.     (sourcehost, sourceport) = parse227(source.sendcmd('PASV'))
  911.     target.sendport(sourcehost, sourceport)
  912.     treply = target.sendcmd('STOR ' + targetname)
  913.     if treply[:3] not in ('125', '150'):
  914.         raise error_proto
  915.     sreply = source.sendcmd('RETR ' + sourcename)
  916.     if sreply[:3] not in ('125', '150'):
  917.         raise error_proto
  918.     source.voidresp()
  919.     target.voidresp()
  920.  
  921.  
  922. class Netrc:
  923.     """Class to parse & provide access to 'netrc' format files.
  924.  
  925.     See the netrc(4) man page for information on the file format.
  926.  
  927.     WARNING: This class is obsolete -- use module netrc instead.
  928.  
  929.     """
  930.     __defuser = None
  931.     __defpasswd = None
  932.     __defacct = None
  933.     
  934.     def __init__(self, filename = None):
  935.         if filename is None:
  936.             if 'HOME' in os.environ:
  937.                 filename = os.path.join(os.environ['HOME'], '.netrc')
  938.             else:
  939.                 raise IOError, 'specify file to load or set $HOME'
  940.         self._Netrc__hosts = { }
  941.         self._Netrc__macros = { }
  942.         fp = open(filename, 'r')
  943.         in_macro = 0
  944.         while None:
  945.             line = fp.readline()
  946.             if not line:
  947.                 break
  948.             if in_macro and line.strip():
  949.                 macro_lines.append(line)
  950.                 continue
  951.             elif in_macro:
  952.                 self._Netrc__macros[macro_name] = tuple(macro_lines)
  953.                 in_macro = 0
  954.             words = line.split()
  955.             host = None
  956.             user = None
  957.             passwd = None
  958.             acct = None
  959.             default = 0
  960.             i = 0
  961.             while i < len(words):
  962.                 w1 = words[i]
  963.                 if i + 1 < len(words):
  964.                     w2 = words[i + 1]
  965.                 else:
  966.                     w2 = None
  967.                 if w1 == 'default':
  968.                     default = 1
  969.                 elif w1 == 'machine' and w2:
  970.                     host = w2.lower()
  971.                     i = i + 1
  972.                 elif w1 == 'login' and w2:
  973.                     user = w2
  974.                     i = i + 1
  975.                 elif w1 == 'password' and w2:
  976.                     passwd = w2
  977.                     i = i + 1
  978.                 elif w1 == 'account' and w2:
  979.                     acct = w2
  980.                     i = i + 1
  981.                 elif w1 == 'macdef' and w2:
  982.                     macro_name = w2
  983.                     macro_lines = []
  984.                     in_macro = 1
  985.                     break
  986.                 i = i + 1
  987.             if default:
  988.                 if not user:
  989.                     pass
  990.                 self._Netrc__defuser = self._Netrc__defuser
  991.                 if not passwd:
  992.                     pass
  993.                 self._Netrc__defpasswd = self._Netrc__defpasswd
  994.                 if not acct:
  995.                     pass
  996.                 self._Netrc__defacct = self._Netrc__defacct
  997.             if host or host in self._Netrc__hosts:
  998.                 (ouser, opasswd, oacct) = self._Netrc__hosts[host]
  999.                 if not user:
  1000.                     pass
  1001.                 user = ouser
  1002.                 if not passwd:
  1003.                     pass
  1004.                 passwd = opasswd
  1005.                 if not acct:
  1006.                     pass
  1007.                 acct = oacct
  1008.             self._Netrc__hosts[host] = (user, passwd, acct)
  1009.             continue
  1010.             continue
  1011.             return None
  1012.  
  1013.     
  1014.     def get_hosts(self):
  1015.         '''Return a list of hosts mentioned in the .netrc file.'''
  1016.         return self._Netrc__hosts.keys()
  1017.  
  1018.     
  1019.     def get_account(self, host):
  1020.         '''Returns login information for the named host.
  1021.  
  1022.         The return value is a triple containing userid,
  1023.         password, and the accounting field.
  1024.  
  1025.         '''
  1026.         host = host.lower()
  1027.         user = None
  1028.         passwd = None
  1029.         acct = None
  1030.         user = None if host in self._Netrc__hosts else self._Netrc__defuser
  1031.         if not passwd:
  1032.             pass
  1033.         passwd = self._Netrc__defpasswd
  1034.         if not acct:
  1035.             pass
  1036.         acct = self._Netrc__defacct
  1037.         return (user, passwd, acct)
  1038.  
  1039.     
  1040.     def get_macros(self):
  1041.         '''Return a list of all defined macro names.'''
  1042.         return self._Netrc__macros.keys()
  1043.  
  1044.     
  1045.     def get_macro(self, macro):
  1046.         '''Return a sequence of lines which define a named macro.'''
  1047.         return self._Netrc__macros[macro]
  1048.  
  1049.  
  1050.  
  1051. def test():
  1052.     '''Test program.
  1053.     Usage: ftp [-d] [-r[file]] host [-l[dir]] [-d[dir]] [-p] [file] ...
  1054.  
  1055.     -d dir
  1056.     -l list
  1057.     -p password
  1058.     '''
  1059.     if len(sys.argv) < 2:
  1060.         print test.__doc__
  1061.         sys.exit(0)
  1062.     debugging = 0
  1063.     rcfile = None
  1064.     while sys.argv[1] == '-d':
  1065.         debugging = debugging + 1
  1066.         del sys.argv[1]
  1067.     if sys.argv[1][:2] == '-r':
  1068.         rcfile = sys.argv[1][2:]
  1069.         del sys.argv[1]
  1070.     host = sys.argv[1]
  1071.     ftp = FTP(host)
  1072.     ftp.set_debuglevel(debugging)
  1073.     userid = passwd = acct = ''
  1074.     
  1075.     try:
  1076.         netrc = Netrc(rcfile)
  1077.     except IOError:
  1078.         if rcfile is not None:
  1079.             sys.stderr.write('Could not open account file -- using anonymous login.')
  1080.         
  1081.  
  1082.     
  1083.     try:
  1084.         (userid, passwd, acct) = netrc.get_account(host)
  1085.     except KeyError:
  1086.         sys.stderr.write('No account -- using anonymous login.')
  1087.  
  1088.     ftp.login(userid, passwd, acct)
  1089.     for file in sys.argv[2:]:
  1090.         if file[:2] == '-l':
  1091.             ftp.dir(file[2:])
  1092.             continue
  1093.         if file[:2] == '-d':
  1094.             cmd = 'CWD'
  1095.             if file[2:]:
  1096.                 cmd = cmd + ' ' + file[2:]
  1097.             resp = ftp.sendcmd(cmd)
  1098.             continue
  1099.         if file == '-p':
  1100.             ftp.set_pasv(not (ftp.passiveserver))
  1101.             continue
  1102.         ftp.retrbinary('RETR ' + file, sys.stdout.write, 1024)
  1103.     
  1104.     ftp.quit()
  1105.  
  1106. if __name__ == '__main__':
  1107.     test()
  1108.