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, rest=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           rest: Passed to transfercmd().  [default: None]
 445
 446         Returns:
 447           The response code.
 448         """
 449         self.voidcmd('TYPE I')
 450         conn = self.transfercmd(cmd, rest)
 451         while 1:
 452             buf = fp.read(blocksize)
 453             if not buf: break
 454             conn.sendall(buf)
 455             if callback: callback(buf)
 456         conn.close()
 457         return self.voidresp()
 458
 459     def storlines(self, cmd, fp, callback=None):
 460         """Store a file in line mode.  A new port is created for you.
 461
 462         Args:
 463           cmd: A STOR command.
 464           fp: A file-like object with a readline() method.
 465           callback: An optional single parameter callable that is called on
 466                     on each line after it is sent.  [default: None]
 467
 468         Returns:
 469           The response code.
 470         """
 471         self.voidcmd('TYPE A')
 472         conn = self.transfercmd(cmd)
 473         while 1:
 474             buf = fp.readline()
 475             if not buf: break
 476             if buf[-2:] != CRLF:
 477                 if buf[-1] in CRLF: buf = buf[:-1]
 478                 buf = buf + CRLF
 479             conn.sendall(buf)
 480             if callback: callback(buf)
 481         conn.close()
 482         return self.voidresp()
 483
 484     def acct(self, password):
 485         '''Send new account name.'''
 486         cmd = 'ACCT ' + password
 487         return self.voidcmd(cmd)
 488
 489     def nlst(self, *args):
 490         '''Return a list of files in a given directory (default the current).'''
 491         cmd = 'NLST'
 492         for arg in args:
 493             cmd = cmd + (' ' + arg)
 494         files = []
 495         self.retrlines(cmd, files.append)
 496         return files
 497
 498     def dir(self, *args):
 499         '''List a directory in long form.
 500         By default list current directory to stdout.
 501         Optional last argument is callback function; all
 502         non-empty arguments before it are concatenated to the
 503         LIST command.  (This *should* only be used for a pathname.)'''
 504         cmd = 'LIST'
 505         func = None
 506         if args[-1:] and type(args[-1]) != type(''):
 507             args, func = args[:-1], args[-1]
 508         for arg in args:
 509             if arg:
 510                 cmd = cmd + (' ' + arg)
 511         self.retrlines(cmd, func)
 512
 513     def rename(self, fromname, toname):
 514         '''Rename a file.'''
 515         resp = self.sendcmd('RNFR ' + fromname)
 516         if resp[0] != '3':
 517             raise error_reply, resp
 518         return self.voidcmd('RNTO ' + toname)
 519
 520     def delete(self, filename):
 521         '''Delete a file.'''
 522         resp = self.sendcmd('DELE ' + filename)
 523         if resp[:3] in ('250', '200'):
 524             return resp
 525         else:
 526             raise error_reply, resp
 527
 528     def cwd(self, dirname):
 529         '''Change to a directory.'''
 530         if dirname == '..':
 531             try:
 532                 return self.voidcmd('CDUP')
 533             except error_perm, msg:
 534                 if msg.args[0][:3] != '500':
 535                     raise
 536         elif dirname == '':
 537             dirname = '.'  # does nothing, but could return error
 538         cmd = 'CWD ' + dirname
 539         return self.voidcmd(cmd)
 540
 541     def size(self, filename):
 542         '''Retrieve the size of a file.'''
 543         # The SIZE command is defined in RFC-3659
 544         resp = self.sendcmd('SIZE ' + filename)
 545         if resp[:3] == '213':
 546             s = resp[3:].strip()
 547             try:
 548                 return int(s)
 549             except (OverflowError, ValueError):
 550                 return long(s)
 551
 552     def mkd(self, dirname):
 553         '''Make a directory, return its full pathname.'''
 554         resp = self.sendcmd('MKD ' + dirname)
 555         return parse257(resp)
 556
 557     def rmd(self, dirname):
 558         '''Remove a directory.'''
 559         return self.voidcmd('RMD ' + dirname)
 560
 561     def pwd(self):
 562         '''Return current working directory.'''
 563         resp = self.sendcmd('PWD')
 564         return parse257(resp)
 565
 566     def quit(self):
 567         '''Quit, and close the connection.'''
 568         resp = self.voidcmd('QUIT')
 569         self.close()
 570         return resp
 571
 572     def close(self):
 573         '''Close the connection without assuming anything about it.'''
 574         if self.file:
 575             self.file.close()
 576             self.sock.close()
 577             self.file = self.sock = None
 578
 579
 580 try:
 581     import ssl
 582 except ImportError:
 583     pass
 584 else:
 585     class FTP_TLS(FTP):
 586         '''A FTP subclass which adds TLS support to FTP as described
 587         in RFC-4217.
 588
 589         Connect as usual to port 21 implicitly securing the FTP control
 590         connection before authenticating.
 591
 592         Securing the data connection requires user to explicitly ask
 593         for it by calling prot_p() method.
 594
 595         Usage example:
 596         >>> from ftplib import FTP_TLS
 597         >>> ftps = FTP_TLS('ftp.python.org')
 598         >>> ftps.login()  # login anonimously previously securing control channel
 599         '230 Guest login ok, access restrictions apply.'
 600         >>> ftps.prot_p()  # switch to secure data connection
 601         '200 Protection level set to P'
 602         >>> ftps.retrlines('LIST')  # list directory content securely
 603         total 9
 604         drwxr-xr-x   8 root     wheel        1024 Jan  3  1994 .
 605         drwxr-xr-x   8 root     wheel        1024 Jan  3  1994 ..
 606         drwxr-xr-x   2 root     wheel        1024 Jan  3  1994 bin
 607         drwxr-xr-x   2 root     wheel        1024 Jan  3  1994 etc
 608         d-wxrwxr-x   2 ftp      wheel        1024 Sep  5 13:43 incoming
 609         drwxr-xr-x   2 root     wheel        1024 Nov 17  1993 lib
 610         drwxr-xr-x   6 1094     wheel        1024 Sep 13 19:07 pub
 611         drwxr-xr-x   3 root     wheel        1024 Jan  3  1994 usr
 612         -rw-r--r--   1 root     root          312 Aug  1  1994 welcome.msg
 613         '226 Transfer complete.'
 614         >>> ftps.quit()
 615         '221 Goodbye.'
 616         >>>
 617         '''
 618         ssl_version = ssl.PROTOCOL_TLSv1
 619
 620         def __init__(self, host='', user='', passwd='', acct='', keyfile=None,
 621                      certfile=None, timeout=_GLOBAL_DEFAULT_TIMEOUT):
 622             self.keyfile = keyfile
 623             self.certfile = certfile
 624             self._prot_p = False
 625             FTP.__init__(self, host, user, passwd, acct, timeout)
 626
 627         def login(self, user='', passwd='', acct='', secure=True):
 628             if secure and not isinstance(self.sock, ssl.SSLSocket):
 629                 self.auth()
 630             return FTP.login(self, user, passwd, acct)
 631
 632         def auth(self):
 633             '''Set up secure control connection by using TLS/SSL.'''
 634             if isinstance(self.sock, ssl.SSLSocket):
 635                 raise ValueError("Already using TLS")
 636             if self.ssl_version == ssl.PROTOCOL_TLSv1:
 637                 resp = self.voidcmd('AUTH TLS')
 638             else:
 639                 resp = self.voidcmd('AUTH SSL')
 640             self.sock = ssl.wrap_socket(self.sock, self.keyfile, self.certfile,
 641                                         ssl_version=self.ssl_version)
 642             self.file = self.sock.makefile(mode='rb')
 643             return resp
 644
 645         def prot_p(self):
 646             '''Set up secure data connection.'''
 647             # PROT defines whether or not the data channel is to be protected.
 648             # Though RFC-2228 defines four possible protection levels,
 649             # RFC-4217 only recommends two, Clear and Private.
 650             # Clear (PROT C) means that no security is to be used on the
 651             # data-channel, Private (PROT P) means that the data-channel
 652             # should be protected by TLS.
 653             # PBSZ command MUST still be issued, but must have a parameter of
 654             # '0' to indicate that no buffering is taking place and the data
 655             # connection should not be encapsulated.
 656             self.voidcmd('PBSZ 0')
 657             resp = self.voidcmd('PROT P')
 658             self._prot_p = True
 659             return resp
 660
 661         def prot_c(self):
 662             '''Set up clear text data connection.'''
 663             resp = self.voidcmd('PROT C')
 664             self._prot_p = False
 665             return resp
 666
 667         # --- Overridden FTP methods
 668
 669         def ntransfercmd(self, cmd, rest=None):
 670             conn, size = FTP.ntransfercmd(self, cmd, rest)
 671             if self._prot_p:
 672                 conn = ssl.wrap_socket(conn, self.keyfile, self.certfile,
 673                                        ssl_version=self.ssl_version)
 674             return conn, size
 675
 676         def retrbinary(self, cmd, callback, blocksize=8192, rest=None):
 677             self.voidcmd('TYPE I')
 678             conn = self.transfercmd(cmd, rest)
 679             try:
 680                 while 1:
 681                     data = conn.recv(blocksize)
 682                     if not data:
 683                         break
 684                     callback(data)
 685                 # shutdown ssl layer
 686                 if isinstance(conn, ssl.SSLSocket):
 687                     conn.unwrap()
 688             finally:
 689                 conn.close()
 690             return self.voidresp()
 691
 692         def retrlines(self, cmd, callback = None):
 693             if callback is None: callback = print_line
 694             resp = self.sendcmd('TYPE A')
 695             conn = self.transfercmd(cmd)
 696             fp = conn.makefile('rb')
 697             try:
 698                 while 1:
 699                     line = fp.readline()
 700                     if self.debugging > 2: print '*retr*', repr(line)
 701                     if not line:
 702                         break
 703                     if line[-2:] == CRLF:
 704                         line = line[:-2]
 705                     elif line[-1:] == '\n':
 706                         line = line[:-1]
 707                     callback(line)
 708                 # shutdown ssl layer
 709                 if isinstance(conn, ssl.SSLSocket):
 710                     conn.unwrap()
 711             finally:
 712                 fp.close()
 713                 conn.close()
 714             return self.voidresp()
 715
 716         def storbinary(self, cmd, fp, blocksize=8192, callback=None, rest=None):
 717             self.voidcmd('TYPE I')
 718             conn = self.transfercmd(cmd, rest)
 719             try:
 720                 while 1:
 721                     buf = fp.read(blocksize)
 722                     if not buf: break
 723                     conn.sendall(buf)
 724                     if callback: callback(buf)
 725                 # shutdown ssl layer
 726                 if isinstance(conn, ssl.SSLSocket):
 727                     conn.unwrap()
 728             finally:
 729                 conn.close()
 730             return self.voidresp()
 731
 732         def storlines(self, cmd, fp, callback=None):
 733             self.voidcmd('TYPE A')
 734             conn = self.transfercmd(cmd)
 735             try:
 736                 while 1:
 737                     buf = fp.readline()
 738                     if not buf: break
 739                     if buf[-2:] != CRLF:
 740                         if buf[-1] in CRLF: buf = buf[:-1]
 741                         buf = buf + CRLF
 742                     conn.sendall(buf)
 743                     if callback: callback(buf)
 744                 # shutdown ssl layer
 745                 if isinstance(conn, ssl.SSLSocket):
 746                     conn.unwrap()
 747             finally:
 748                 conn.close()
 749             return self.voidresp()
 750
 751     __all__.append('FTP_TLS')
 752     all_errors = (Error, IOError, EOFError, ssl.SSLError)
 753
 754
 755 _150_re = None
 756
 757 def parse150(resp):
 758     '''Parse the '150' response for a RETR request.
 759     Returns the expected transfer size or None; size is not guaranteed to
 760     be present in the 150 message.
 761     '''
 762     if resp[:3] != '150':
 763         raise error_reply, resp
 764     global _150_re
 765     if _150_re is None:
 766         import re
 767         _150_re = re.compile("150 .* \((\d+) bytes\)", re.IGNORECASE)
 768     m = _150_re.match(resp)
 769     if not m:
 770         return None
 771     s = m.group(1)
 772     try:
 773         return int(s)
 774     except (OverflowError, ValueError):
 775         return long(s)
 776
 777
 778 _227_re = None
 779
 780 def parse227(resp):
 781     '''Parse the '227' response for a PASV request.
 782     Raises error_proto if it does not contain '(h1,h2,h3,h4,p1,p2)'
 783     Return ('host.addr.as.numbers', port#) tuple.'''
 784
 785     if resp[:3] != '227':
 786         raise error_reply, resp
 787     global _227_re
 788     if _227_re is None:
 789         import re
 790         _227_re = re.compile(r'(\d+),(\d+),(\d+),(\d+),(\d+),(\d+)')
 791     m = _227_re.search(resp)
 792     if not m:
 793         raise error_proto, resp
 794     numbers = m.groups()
 795     host = '.'.join(numbers[:4])
 796     port = (int(numbers[4]) << 8) + int(numbers[5])
 797     return host, port
 798
 799
 800 def parse229(resp, peer):
 801     '''Parse the '229' response for a EPSV request.
 802     Raises error_proto if it does not contain '(|||port|)'
 803     Return ('host.addr.as.numbers', port#) tuple.'''
 804
 805     if resp[:3] != '229':
 806         raise error_reply, resp
 807     left = resp.find('(')
 808     if left < 0: raise error_proto, resp
 809     right = resp.find(')', left + 1)
 810     if right < 0:
 811         raise error_proto, resp # should contain '(|||port|)'
 812     if resp[left + 1] != resp[right - 1]:
 813         raise error_proto, resp
 814     parts = resp[left + 1:right].split(resp[left+1])
 815     if len(parts) != 5:
 816         raise error_proto, resp
 817     host = peer[0]
 818     port = int(parts[3])
 819     return host, port
 820
 821
 822 def parse257(resp):
 823     '''Parse the '257' response for a MKD or PWD request.
 824     This is a response to a MKD or PWD request: a directory name.
 825     Returns the directoryname in the 257 reply.'''
 826
 827     if resp[:3] != '257':
 828         raise error_reply, resp
 829     if resp[3:5] != ' "':
 830         return '' # Not compliant to RFC 959, but UNIX ftpd does this
 831     dirname = ''
 832     i = 5
 833     n = len(resp)
 834     while i < n:
 835         c = resp[i]
 836         i = i+1
 837         if c == '"':
 838             if i >= n or resp[i] != '"':
 839                 break
 840             i = i+1
 841         dirname = dirname + c
 842     return dirname
 843
 844
 845 def print_line(line):
 846     '''Default retrlines callback to print a line.'''
 847     print line
 848
 849
 850 def ftpcp(source, sourcename, target, targetname = '', type = 'I'):
 851     '''Copy file from one FTP-instance to another.'''
 852     if not targetname: targetname = sourcename
 853     type = 'TYPE ' + type
 854     source.voidcmd(type)
 855     target.voidcmd(type)
 856     sourcehost, sourceport = parse227(source.sendcmd('PASV'))
 857     target.sendport(sourcehost, sourceport)
 858     # RFC 959: the user must "listen" [...] BEFORE sending the
 859     # transfer request.
 860     # So: STOR before RETR, because here the target is a "user".
 861     treply = target.sendcmd('STOR ' + targetname)
 862     if treply[:3] not in ('125', '150'): raise error_proto  # RFC 959
 863     sreply = source.sendcmd('RETR ' + sourcename)
 864     if sreply[:3] not in ('125', '150'): raise error_proto  # RFC 959
 865     source.voidresp()
 866     target.voidresp()
 867
 868
 869 class Netrc:
 870     """Class to parse & provide access to 'netrc' format files.
 871
 872     See the netrc(4) man page for information on the file format.
 873
 874     WARNING: This class is obsolete -- use module netrc instead.
 875
 876     """
 877     __defuser = None
 878     __defpasswd = None
 879     __defacct = None
 880
 881     def __init__(self, filename=None):
 882         if filename is None:
 883             if "HOME" in os.environ:
 884                 filename = os.path.join(os.environ["HOME"],
 885                                         ".netrc")
 886             else:
 887                 raise IOError, \
 888                       "specify file to load or set $HOME"
 889         self.__hosts = {}
 890         self.__macros = {}
 891         fp = open(filename, "r")
 892         in_macro = 0
 893         while 1:
 894             line = fp.readline()
 895             if not line: break
 896             if in_macro and line.strip():
 897                 macro_lines.append(line)
 898                 continue
 899             elif in_macro:
 900                 self.__macros[macro_name] = tuple(macro_lines)
 901                 in_macro = 0
 902             words = line.split()
 903             host = user = passwd = acct = None
 904             default = 0
 905             i = 0
 906             while i < len(words):
 907                 w1 = words[i]
 908                 if i+1 < len(words):
 909                     w2 = words[i + 1]
 910                 else:
 911                     w2 = None
 912                 if w1 == 'default':
 913                     default = 1
 914                 elif w1 == 'machine' and w2:
 915                     host = w2.lower()
 916                     i = i + 1
 917                 elif w1 == 'login' and w2:
 918                     user = w2
 919                     i = i + 1
 920                 elif w1 == 'password' and w2:
 921                     passwd = w2
 922                     i = i + 1
 923                 elif w1 == 'account' and w2:
 924                     acct = w2
 925                     i = i + 1
 926                 elif w1 == 'macdef' and w2:
 927                     macro_name = w2
 928                     macro_lines = []
 929                     in_macro = 1
 930                     break
 931                 i = i + 1
 932             if default:
 933                 self.__defuser = user or self.__defuser
 934                 self.__defpasswd = passwd or self.__defpasswd
 935                 self.__defacct = acct or self.__defacct
 936             if host:
 937                 if host in self.__hosts:
 938                     ouser, opasswd, oacct = \
 939                            self.__hosts[host]
 940                     user = user or ouser
 941                     passwd = passwd or opasswd
 942                     acct = acct or oacct
 943                 self.__hosts[host] = user, passwd, acct
 944         fp.close()
 945
 946     def get_hosts(self):
 947         """Return a list of hosts mentioned in the .netrc file."""
 948         return self.__hosts.keys()
 949
 950     def get_account(self, host):
 951         """Returns login information for the named host.
 952
 953         The return value is a triple containing userid,
 954         password, and the accounting field.
 955
 956         """
 957         host = host.lower()
 958         user = passwd = acct = None
 959         if host in self.__hosts:
 960             user, passwd, acct = self.__hosts[host]
 961         user = user or self.__defuser
 962         passwd = passwd or self.__defpasswd
 963         acct = acct or self.__defacct
 964         return user, passwd, acct
 965
 966     def get_macros(self):
 967         """Return a list of all defined macro names."""
 968         return self.__macros.keys()
 969
 970     def get_macro(self, macro):
 971         """Return a sequence of lines which define a named macro."""
 972         return self.__macros[macro]
 973
 974
 975
 976 def test():
 977     '''Test program.
 978     Usage: ftp [-d] [-r[file]] host [-l[dir]] [-d[dir]] [-p] [file] ...
 979
 980     -d dir
 981     -l list
 982     -p password
 983     '''
 984
 985     if len(sys.argv) < 2:
 986         print test.__doc__
 987         sys.exit(0)
 988
 989     debugging = 0
 990     rcfile = None
 991     while sys.argv[1] == '-d':
 992         debugging = debugging+1
 993         del sys.argv[1]
 994     if sys.argv[1][:2] == '-r':
 995         # get name of alternate ~/.netrc file:
 996         rcfile = sys.argv[1][2:]
 997         del sys.argv[1]
 998     host = sys.argv[1]
 999     ftp = FTP(host)
1000     ftp.set_debuglevel(debugging)
1001     userid = passwd = acct = ''
1002     try:
1003         netrc = Netrc(rcfile)
1004     except IOError:
1005         if rcfile is not None:
1006             sys.stderr.write("Could not open account file"
1007                              " -- using anonymous login.")
1008     else:
1009         try:
1010             userid, passwd, acct = netrc.get_account(host)
1011         except KeyError:
1012             # no account for host
1013             sys.stderr.write(
1014                     "No account -- using anonymous login.")
1015     ftp.login(userid, passwd, acct)
1016     for file in sys.argv[2:]:
1017         if file[:2] == '-l':
1018             ftp.dir(file[2:])
1019         elif file[:2] == '-d':
1020             cmd = 'CWD'
1021             if file[2:]: cmd = cmd + ' ' + file[2:]
1022             resp = ftp.sendcmd(cmd)
1023         elif file == '-p':
1024             ftp.set_pasv(not ftp.passiveserver)
1025         else:
1026             ftp.retrbinary('RETR ' + file, \
1027                            sys.stdout.write, 1024)
1028     ftp.quit()
1029
1030
1031 if __name__ == '__main__':
1032     test()