Lib/ftplib.py

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