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 #
  36
  37 import os
  38 import sys
  39
  40 # Import SOCKS module if it exists, else standard socket module socket
  41 try:
  42     import SOCKS; socket = SOCKS; del SOCKS # import SOCKS as socket
  43     from socket import getfqdn; socket.getfqdn = getfqdn; del getfqdn
  44 except ImportError:
  45     import socket
  46
  47 __all__ = ["FTP","Netrc"]
  48
  49 # Magic number from <socket.h>
  50 MSG_OOB = 0x1                           # Process data out of band
  51
  52
  53 # The standard FTP server control port
  54 FTP_PORT = 21
  55
  56
  57 # Exception raised when an error or invalid response is received
  58 class Error(Exception): pass
  59 class error_reply(Error): pass          # unexpected [123]xx reply
  60 class error_temp(Error): pass           # 4xx errors
  61 class error_perm(Error): pass           # 5xx errors
  62 class error_proto(Error): pass          # response does not begin with [1-5]
  63
  64
  65 # All exceptions (hopefully) that may be raised here and that aren't
  66 # (always) programming errors on our side
  67 all_errors = (Error, socket.error, IOError, EOFError)
  68
  69
  70 # Line terminators (we always output CRLF, but accept any of CRLF, CR, LF)
  71 CRLF = '\r\n'
  72
  73
  74 # The class itself
  75 class FTP:
  76
  77     '''An FTP client class.
  78
  79     To create a connection, call the class using these arguments:
  80             host, user, passwd, acct, timeout
  81
  82     The first four arguments are all strings, and have default value ''.
  83     timeout must be numeric and defaults to None if not passed,
  84     meaning that no timeout will be set on any ftp socket(s)
  85     If a timeout is passed, then this is now the default timeout for all ftp
  86     socket operations for this instance.
  87
  88     Then use self.connect() with optional host and port argument.
  89
  90     To download a file, use ftp.retrlines('RETR ' + filename),
  91     or ftp.retrbinary() with slightly different arguments.
  92     To upload a file, use ftp.storlines() or ftp.storbinary(),
  93     which have an open file as argument (see their definitions
  94     below for details).
  95     The download/upload functions first issue appropriate TYPE
  96     and PORT or PASV commands.
  97 '''
  98
  99     debugging = 0
 100     host = ''
 101     port = FTP_PORT
 102     sock = None
 103     file = None
 104     welcome = None
 105     passiveserver = 1
 106
 107     # Initialization method (called by class instantiation).
 108     # Initialize host to localhost, port to standard ftp port
 109     # Optional arguments are host (for connect()),
 110     # and user, passwd, acct (for login())
 111     def __init__(self, host='', user='', passwd='', acct='', timeout=None):
 112         self.timeout = timeout
 113         if host:
 114             self.connect(host)
 115             if user:
 116                 self.login(user, passwd, acct)
 117
 118     def connect(self, host='', port=0, timeout=None):
 119         '''Connect to host.  Arguments are:
 120          - host: hostname to connect to (string, default previous host)
 121          - port: port to connect to (integer, default previous port)
 122         '''
 123         if host != '':
 124             self.host = host
 125         if port > 0:
 126             self.port = port
 127         if timeout is not None:
 128             self.timeout = timeout
 129         self.sock = socket.create_connection((self.host, self.port), self.timeout)
 130         self.af = self.sock.family
 131         self.file = self.sock.makefile('rb')
 132         self.welcome = self.getresp()
 133         return self.welcome
 134
 135     def getwelcome(self):
 136         '''Get the welcome message from the server.
 137         (this is read and squirreled away by connect())'''
 138         if self.debugging:
 139             print '*welcome*', self.sanitize(self.welcome)
 140         return self.welcome
 141
 142     def set_debuglevel(self, level):
 143         '''Set the debugging level.
 144         The required argument level means:
 145         0: no debugging output (default)
 146         1: print commands and responses but not body text etc.
 147         2: also print raw lines read and sent before stripping CR/LF'''
 148         self.debugging = level
 149     debug = set_debuglevel
 150
 151     def set_pasv(self, val):
 152         '''Use passive or active mode for data transfers.
 153         With a false argument, use the normal PORT mode,
 154         With a true argument, use the PASV command.'''
 155         self.passiveserver = val
 156
 157     # Internal: "sanitize" a string for printing
 158     def sanitize(self, s):
 159         if s[:5] == 'pass ' or s[:5] == 'PASS ':
 160             i = len(s)
 161             while i > 5 and s[i-1] in '\r\n':
 162                 i = i-1
 163             s = s[:5] + '*'*(i-5) + s[i:]
 164         return repr(s)
 165
 166     # Internal: send one line to the server, appending CRLF
 167     def putline(self, line):
 168         line = line + CRLF
 169         if self.debugging > 1: print '*put*', self.sanitize(line)
 170         self.sock.sendall(line)
 171
 172     # Internal: send one command to the server (through putline())
 173     def putcmd(self, line):
 174         if self.debugging: print '*cmd*', self.sanitize(line)
 175         self.putline(line)
 176
 177     # Internal: return one line from the server, stripping CRLF.
 178     # Raise EOFError if the connection is closed
 179     def getline(self):
 180         line = self.file.readline()
 181         if self.debugging > 1:
 182             print '*get*', self.sanitize(line)
 183         if not line: raise EOFError
 184         if line[-2:] == CRLF: line = line[:-2]
 185         elif line[-1:] in CRLF: line = line[:-1]
 186         return line
 187
 188     # Internal: get a response from the server, which may possibly
 189     # consist of multiple lines.  Return a single string with no
 190     # trailing CRLF.  If the response consists of multiple lines,
 191     # these are separated by '\n' characters in the string
 192     def getmultiline(self):
 193         line = self.getline()
 194         if line[3:4] == '-':
 195             code = line[:3]
 196             while 1:
 197                 nextline = self.getline()
 198                 line = line + ('\n' + nextline)
 199                 if nextline[:3] == code and \
 200                         nextline[3:4] != '-':
 201                     break
 202         return line
 203
 204     # Internal: get a response from the server.
 205     # Raise various errors if the response indicates an error
 206     def getresp(self):
 207         resp = self.getmultiline()
 208         if self.debugging: print '*resp*', self.sanitize(resp)
 209         self.lastresp = resp[:3]
 210         c = resp[:1]
 211         if c in ('1', '2', '3'):
 212             return resp
 213         if c == '4':
 214             raise error_temp, resp
 215         if c == '5':
 216             raise error_perm, resp
 217         raise error_proto, resp
 218
 219     def voidresp(self):
 220         """Expect a response beginning with '2'."""
 221         resp = self.getresp()
 222         if resp[0] != '2':
 223             raise error_reply, resp
 224         return resp
 225
 226     def abort(self):
 227         '''Abort a file transfer.  Uses out-of-band data.
 228         This does not follow the procedure from the RFC to send Telnet
 229         IP and Synch; that doesn't seem to work with the servers I've
 230         tried.  Instead, just send the ABOR command as OOB data.'''
 231         line = 'ABOR' + CRLF
 232         if self.debugging > 1: print '*put urgent*', self.sanitize(line)
 233         self.sock.sendall(line, MSG_OOB)
 234         resp = self.getmultiline()
 235         if resp[:3] not in ('426', '226'):
 236             raise error_proto, resp
 237
 238     def sendcmd(self, cmd):
 239         '''Send a command and return the response.'''
 240         self.putcmd(cmd)
 241         return self.getresp()
 242
 243     def voidcmd(self, cmd):
 244         """Send a command and expect a response beginning with '2'."""
 245         self.putcmd(cmd)
 246         return self.voidresp()
 247
 248     def sendport(self, host, port):
 249         '''Send a PORT command with the current host and the given
 250         port number.
 251         '''
 252         hbytes = host.split('.')
 253         pbytes = [repr(port/256), repr(port%256)]
 254         bytes = hbytes + pbytes
 255         cmd = 'PORT ' + ','.join(bytes)
 256         return self.voidcmd(cmd)
 257
 258     def sendeprt(self, host, port):
 259         '''Send a EPRT command with the current host and the given port number.'''
 260         af = 0
 261         if self.af == socket.AF_INET:
 262             af = 1
 263         if self.af == socket.AF_INET6:
 264             af = 2
 265         if af == 0:
 266             raise error_proto, 'unsupported address family'
 267         fields = ['', repr(af), host, repr(port), '']
 268         cmd = 'EPRT ' + '|'.join(fields)
 269         return self.voidcmd(cmd)
 270
 271     def makeport(self):
 272         '''Create a new socket and send a PORT command for it.'''
 273         msg = "getaddrinfo returns an empty list"
 274         sock = None
 275         for res in socket.getaddrinfo(None, 0, self.af, socket.SOCK_STREAM, 0, socket.AI_PASSIVE):
 276             af, socktype, proto, canonname, sa = res
 277             try:
 278                 sock = socket.socket(af, socktype, proto)
 279                 sock.bind(sa)
 280             except socket.error, msg:
 281                 if sock:
 282                     sock.close()
 283                 sock = None
 284                 continue
 285             break
 286         if not sock:
 287             raise socket.error, msg
 288         sock.listen(1)
 289         port = sock.getsockname()[1] # Get proper port
 290         host = self.sock.getsockname()[0] # Get proper host
 291         if self.af == socket.AF_INET:
 292             resp = self.sendport(host, port)
 293         else:
 294             resp = self.sendeprt(host, port)
 295         return sock
 296
 297     def makepasv(self):
 298         if self.af == socket.AF_INET:
 299             host, port = parse227(self.sendcmd('PASV'))
 300         else:
 301             host, port = parse229(self.sendcmd('EPSV'), self.sock.getpeername())
 302         return host, port
 303
 304     def ntransfercmd(self, cmd, rest=None):
 305         """Initiate a transfer over the data connection.
 306
 307         If the transfer is active, send a port command and the
 308         transfer command, and accept the connection.  If the server is
 309         passive, send a pasv command, connect to it, and start the
 310         transfer command.  Either way, return the socket for the
 311         connection and the expected size of the transfer.  The
 312         expected size may be None if it could not be determined.
 313
 314         Optional `rest' argument can be a string that is sent as the
 315         argument to a RESTART command.  This is essentially a server
 316         marker used to tell the server to skip over any data up to the
 317         given marker.
 318         """
 319         size = None
 320         if self.passiveserver:
 321             host, port = self.makepasv()
 322             conn = socket.create_connection((host, port), self.timeout)
 323             if rest is not None:
 324                 self.sendcmd("REST %s" % rest)
 325             resp = self.sendcmd(cmd)
 326             # Some servers apparently send a 200 reply to
 327             # a LIST or STOR command, before the 150 reply
 328             # (and way before the 226 reply). This seems to
 329             # be in violation of the protocol (which only allows
 330             # 1xx or error messages for LIST), so we just discard
 331             # this response.
 332             if resp[0] == '2':
 333                 resp = self.getresp()
 334             if resp[0] != '1':
 335                 raise error_reply, resp
 336         else:
 337             sock = self.makeport()
 338             if rest is not None:
 339                 self.sendcmd("REST %s" % rest)
 340             resp = self.sendcmd(cmd)
 341             # See above.
 342             if resp[0] == '2':
 343                 resp = self.getresp()
 344             if resp[0] != '1':
 345                 raise error_reply, resp
 346             conn, sockaddr = sock.accept()
 347         if resp[:3] == '150':
 348             # this is conditional in case we received a 125
 349             size = parse150(resp)
 350         return conn, size
 351
 352     def transfercmd(self, cmd, rest=None):
 353         """Like ntransfercmd() but returns only the socket."""
 354         return self.ntransfercmd(cmd, rest)[0]
 355
 356     def login(self, user = '', passwd = '', acct = ''):
 357         '''Login, default anonymous.'''
 358         if not user: user = 'anonymous'
 359         if not passwd: passwd = ''
 360         if not acct: acct = ''
 361         if user == 'anonymous' and passwd in ('', '-'):
 362             # If there is no anonymous ftp password specified
 363             # then we'll just use anonymous@
 364             # We don't send any other thing because:
 365             # - We want to remain anonymous
 366             # - We want to stop SPAM
 367             # - We don't want to let ftp sites to discriminate by the user,
 368             #   host or country.
 369             passwd = passwd + 'anonymous@'
 370         resp = self.sendcmd('USER ' + user)
 371         if resp[0] == '3': resp = self.sendcmd('PASS ' + passwd)
 372         if resp[0] == '3': resp = self.sendcmd('ACCT ' + acct)
 373         if resp[0] != '2':
 374             raise error_reply, resp
 375         return resp
 376
 377     def retrbinary(self, cmd, callback, blocksize=8192, rest=None):
 378         """Retrieve data in binary mode.
 379
 380         `cmd' is a RETR command.  `callback' is a callback function is
 381         called for each block.  No more than `blocksize' number of
 382         bytes will be read from the socket.  Optional `rest' is passed
 383         to transfercmd().
 384
 385         A new port is created for you.  Return the response code.
 386         """
 387         self.voidcmd('TYPE I')
 388         conn = self.transfercmd(cmd, rest)
 389         while 1:
 390             data = conn.recv(blocksize)
 391             if not data:
 392                 break
 393             callback(data)
 394         conn.close()
 395         return self.voidresp()
 396
 397     def retrlines(self, cmd, callback = None):
 398         '''Retrieve data in line mode.
 399         The argument is a RETR or LIST command.
 400         The callback function (2nd argument) is called for each line,
 401         with trailing CRLF stripped.  This creates a new port for you.
 402         print_line() is the default callback.'''
 403         if callback is None: callback = print_line
 404         resp = self.sendcmd('TYPE A')
 405         conn = self.transfercmd(cmd)
 406         fp = conn.makefile('rb')
 407         while 1:
 408             line = fp.readline()
 409             if self.debugging > 2: print '*retr*', repr(line)
 410             if not line:
 411                 break
 412             if line[-2:] == CRLF:
 413                 line = line[:-2]
 414             elif line[-1:] == '\n':
 415                 line = line[:-1]
 416             callback(line)
 417         fp.close()
 418         conn.close()
 419         return self.voidresp()
 420
 421     def storbinary(self, cmd, fp, blocksize=8192):
 422         '''Store a file in binary mode.'''
 423         self.voidcmd('TYPE I')
 424         conn = self.transfercmd(cmd)
 425         while 1:
 426             buf = fp.read(blocksize)
 427             if not buf: break
 428             conn.sendall(buf)
 429         conn.close()
 430         return self.voidresp()
 431
 432     def storlines(self, cmd, fp):
 433         '''Store a file in line mode.'''
 434         self.voidcmd('TYPE A')
 435         conn = self.transfercmd(cmd)
 436         while 1:
 437             buf = fp.readline()
 438             if not buf: break
 439             if buf[-2:] != CRLF:
 440                 if buf[-1] in CRLF: buf = buf[:-1]
 441                 buf = buf + CRLF
 442             conn.sendall(buf)
 443         conn.close()
 444         return self.voidresp()
 445
 446     def acct(self, password):
 447         '''Send new account name.'''
 448         cmd = 'ACCT ' + password
 449         return self.voidcmd(cmd)
 450
 451     def nlst(self, *args):
 452         '''Return a list of files in a given directory (default the current).'''
 453         cmd = 'NLST'
 454         for arg in args:
 455             cmd = cmd + (' ' + arg)
 456         files = []
 457         self.retrlines(cmd, files.append)
 458         return files
 459
 460     def dir(self, *args):
 461         '''List a directory in long form.
 462         By default list current directory to stdout.
 463         Optional last argument is callback function; all
 464         non-empty arguments before it are concatenated to the
 465         LIST command.  (This *should* only be used for a pathname.)'''
 466         cmd = 'LIST'
 467         func = None
 468         if args[-1:] and type(args[-1]) != type(''):
 469             args, func = args[:-1], args[-1]
 470         for arg in args:
 471             if arg:
 472                 cmd = cmd + (' ' + arg)
 473         self.retrlines(cmd, func)
 474
 475     def rename(self, fromname, toname):
 476         '''Rename a file.'''
 477         resp = self.sendcmd('RNFR ' + fromname)
 478         if resp[0] != '3':
 479             raise error_reply, resp
 480         return self.voidcmd('RNTO ' + toname)
 481
 482     def delete(self, filename):
 483         '''Delete a file.'''
 484         resp = self.sendcmd('DELE ' + filename)
 485         if resp[:3] in ('250', '200'):
 486             return resp
 487         elif resp[:1] == '5':
 488             raise error_perm, resp
 489         else:
 490             raise error_reply, resp
 491
 492     def cwd(self, dirname):
 493         '''Change to a directory.'''
 494         if dirname == '..':
 495             try:
 496                 return self.voidcmd('CDUP')
 497             except error_perm, msg:
 498                 if msg.args[0][:3] != '500':
 499                     raise
 500         elif dirname == '':
 501             dirname = '.'  # does nothing, but could return error
 502         cmd = 'CWD ' + dirname
 503         return self.voidcmd(cmd)
 504
 505     def size(self, filename):
 506         '''Retrieve the size of a file.'''
 507         # Note that the RFC doesn't say anything about 'SIZE'
 508         resp = self.sendcmd('SIZE ' + filename)
 509         if resp[:3] == '213':
 510             s = resp[3:].strip()
 511             try:
 512                 return int(s)
 513             except (OverflowError, ValueError):
 514                 return long(s)
 515
 516     def mkd(self, dirname):
 517         '''Make a directory, return its full pathname.'''
 518         resp = self.sendcmd('MKD ' + dirname)
 519         return parse257(resp)
 520
 521     def rmd(self, dirname):
 522         '''Remove a directory.'''
 523         return self.voidcmd('RMD ' + dirname)
 524
 525     def pwd(self):
 526         '''Return current working directory.'''
 527         resp = self.sendcmd('PWD')
 528         return parse257(resp)
 529
 530     def quit(self):
 531         '''Quit, and close the connection.'''
 532         resp = self.voidcmd('QUIT')
 533         self.close()
 534         return resp
 535
 536     def close(self):
 537         '''Close the connection without assuming anything about it.'''
 538         if self.file:
 539             self.file.close()
 540             self.sock.close()
 541             self.file = self.sock = None
 542
 543
 544 _150_re = None
 545
 546 def parse150(resp):
 547     '''Parse the '150' response for a RETR request.
 548     Returns the expected transfer size or None; size is not guaranteed to
 549     be present in the 150 message.
 550     '''
 551     if resp[:3] != '150':
 552         raise error_reply, resp
 553     global _150_re
 554     if _150_re is None:
 555         import re
 556         _150_re = re.compile("150 .* \((\d+) bytes\)", re.IGNORECASE)
 557     m = _150_re.match(resp)
 558     if not m:
 559         return None
 560     s = m.group(1)
 561     try:
 562         return int(s)
 563     except (OverflowError, ValueError):
 564         return long(s)
 565
 566
 567 _227_re = None
 568
 569 def parse227(resp):
 570     '''Parse the '227' response for a PASV request.
 571     Raises error_proto if it does not contain '(h1,h2,h3,h4,p1,p2)'
 572     Return ('host.addr.as.numbers', port#) tuple.'''
 573
 574     if resp[:3] != '227':
 575         raise error_reply, resp
 576     global _227_re
 577     if _227_re is None:
 578         import re
 579         _227_re = re.compile(r'(\d+),(\d+),(\d+),(\d+),(\d+),(\d+)')
 580     m = _227_re.search(resp)
 581     if not m:
 582         raise error_proto, resp
 583     numbers = m.groups()
 584     host = '.'.join(numbers[:4])
 585     port = (int(numbers[4]) << 8) + int(numbers[5])
 586     return host, port
 587
 588
 589 def parse229(resp, peer):
 590     '''Parse the '229' response for a EPSV request.
 591     Raises error_proto if it does not contain '(|||port|)'
 592     Return ('host.addr.as.numbers', port#) tuple.'''
 593
 594     if resp[:3] != '229':
 595         raise error_reply, resp
 596     left = resp.find('(')
 597     if left < 0: raise error_proto, resp
 598     right = resp.find(')', left + 1)
 599     if right < 0:
 600         raise error_proto, resp # should contain '(|||port|)'
 601     if resp[left + 1] != resp[right - 1]:
 602         raise error_proto, resp
 603     parts = resp[left + 1:right].split(resp[left+1])
 604     if len(parts) != 5:
 605         raise error_proto, resp
 606     host = peer[0]
 607     port = int(parts[3])
 608     return host, port
 609
 610
 611 def parse257(resp):
 612     '''Parse the '257' response for a MKD or PWD request.
 613     This is a response to a MKD or PWD request: a directory name.
 614     Returns the directoryname in the 257 reply.'''
 615
 616     if resp[:3] != '257':
 617         raise error_reply, resp
 618     if resp[3:5] != ' "':
 619         return '' # Not compliant to RFC 959, but UNIX ftpd does this
 620     dirname = ''
 621     i = 5
 622     n = len(resp)
 623     while i < n:
 624         c = resp[i]
 625         i = i+1
 626         if c == '"':
 627             if i >= n or resp[i] != '"':
 628                 break
 629             i = i+1
 630         dirname = dirname + c
 631     return dirname
 632
 633
 634 def print_line(line):
 635     '''Default retrlines callback to print a line.'''
 636     print line
 637
 638
 639 def ftpcp(source, sourcename, target, targetname = '', type = 'I'):
 640     '''Copy file from one FTP-instance to another.'''
 641     if not targetname: targetname = sourcename
 642     type = 'TYPE ' + type
 643     source.voidcmd(type)
 644     target.voidcmd(type)
 645     sourcehost, sourceport = parse227(source.sendcmd('PASV'))
 646     target.sendport(sourcehost, sourceport)
 647     # RFC 959: the user must "listen" [...] BEFORE sending the
 648     # transfer request.
 649     # So: STOR before RETR, because here the target is a "user".
 650     treply = target.sendcmd('STOR ' + targetname)
 651     if treply[:3] not in ('125', '150'): raise error_proto  # RFC 959
 652     sreply = source.sendcmd('RETR ' + sourcename)
 653     if sreply[:3] not in ('125', '150'): raise error_proto  # RFC 959
 654     source.voidresp()
 655     target.voidresp()
 656
 657
 658 class Netrc:
 659     """Class to parse & provide access to 'netrc' format files.
 660
 661     See the netrc(4) man page for information on the file format.
 662
 663     WARNING: This class is obsolete -- use module netrc instead.
 664
 665     """
 666     __defuser = None
 667     __defpasswd = None
 668     __defacct = None
 669
 670     def __init__(self, filename=None):
 671         if filename is None:
 672             if "HOME" in os.environ:
 673                 filename = os.path.join(os.environ["HOME"],
 674                                         ".netrc")
 675             else:
 676                 raise IOError, \
 677                       "specify file to load or set $HOME"
 678         self.__hosts = {}
 679         self.__macros = {}
 680         fp = open(filename, "r")
 681         in_macro = 0
 682         while 1:
 683             line = fp.readline()
 684             if not line: break
 685             if in_macro and line.strip():
 686                 macro_lines.append(line)
 687                 continue
 688             elif in_macro:
 689                 self.__macros[macro_name] = tuple(macro_lines)
 690                 in_macro = 0
 691             words = line.split()
 692             host = user = passwd = acct = None
 693             default = 0
 694             i = 0
 695             while i < len(words):
 696                 w1 = words[i]
 697                 if i+1 < len(words):
 698                     w2 = words[i + 1]
 699                 else:
 700                     w2 = None
 701                 if w1 == 'default':
 702                     default = 1
 703                 elif w1 == 'machine' and w2:
 704                     host = w2.lower()
 705                     i = i + 1
 706                 elif w1 == 'login' and w2:
 707                     user = w2
 708                     i = i + 1
 709                 elif w1 == 'password' and w2:
 710                     passwd = w2
 711                     i = i + 1
 712                 elif w1 == 'account' and w2:
 713                     acct = w2
 714                     i = i + 1
 715                 elif w1 == 'macdef' and w2:
 716                     macro_name = w2
 717                     macro_lines = []
 718                     in_macro = 1
 719                     break
 720                 i = i + 1
 721             if default:
 722                 self.__defuser = user or self.__defuser
 723                 self.__defpasswd = passwd or self.__defpasswd
 724                 self.__defacct = acct or self.__defacct
 725             if host:
 726                 if host in self.__hosts:
 727                     ouser, opasswd, oacct = \
 728                            self.__hosts[host]
 729                     user = user or ouser
 730                     passwd = passwd or opasswd
 731                     acct = acct or oacct
 732                 self.__hosts[host] = user, passwd, acct
 733         fp.close()
 734
 735     def get_hosts(self):
 736         """Return a list of hosts mentioned in the .netrc file."""
 737         return self.__hosts.keys()
 738
 739     def get_account(self, host):
 740         """Returns login information for the named host.
 741
 742         The return value is a triple containing userid,
 743         password, and the accounting field.
 744
 745         """
 746         host = host.lower()
 747         user = passwd = acct = None
 748         if host in self.__hosts:
 749             user, passwd, acct = self.__hosts[host]
 750         user = user or self.__defuser
 751         passwd = passwd or self.__defpasswd
 752         acct = acct or self.__defacct
 753         return user, passwd, acct
 754
 755     def get_macros(self):
 756         """Return a list of all defined macro names."""
 757         return self.__macros.keys()
 758
 759     def get_macro(self, macro):
 760         """Return a sequence of lines which define a named macro."""
 761         return self.__macros[macro]
 762
 763
 764
 765 def test():
 766     '''Test program.
 767     Usage: ftp [-d] [-r[file]] host [-l[dir]] [-d[dir]] [-p] [file] ...
 768
 769     -d dir
 770     -l list
 771     -p password
 772     '''
 773
 774     if len(sys.argv) < 2:
 775         print test.__doc__
 776         sys.exit(0)
 777
 778     debugging = 0
 779     rcfile = None
 780     while sys.argv[1] == '-d':
 781         debugging = debugging+1
 782         del sys.argv[1]
 783     if sys.argv[1][:2] == '-r':
 784         # get name of alternate ~/.netrc file:
 785         rcfile = sys.argv[1][2:]
 786         del sys.argv[1]
 787     host = sys.argv[1]
 788     ftp = FTP(host)
 789     ftp.set_debuglevel(debugging)
 790     userid = passwd = acct = ''
 791     try:
 792         netrc = Netrc(rcfile)
 793     except IOError:
 794         if rcfile is not None:
 795             sys.stderr.write("Could not open account file"
 796                              " -- using anonymous login.")
 797     else:
 798         try:
 799             userid, passwd, acct = netrc.get_account(host)
 800         except KeyError:
 801             # no account for host
 802             sys.stderr.write(
 803                     "No account -- using anonymous login.")
 804     ftp.login(userid, passwd, acct)
 805     for file in sys.argv[2:]:
 806         if file[:2] == '-l':
 807             ftp.dir(file[2:])
 808         elif file[:2] == '-d':
 809             cmd = 'CWD'
 810             if file[2:]: cmd = cmd + ' ' + file[2:]
 811             resp = ftp.sendcmd(cmd)
 812         elif file == '-p':
 813             ftp.set_pasv(not ftp.passiveserver)
 814         else:
 815             ftp.retrbinary('RETR ' + file, \
 816                            sys.stdout.write, 1024)
 817     ftp.quit()
 818
 819
 820 if __name__ == '__main__':
 821     test()