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 argument:
  80             host, user, passwd, acct
  81     These are all strings, and have default value ''.
  82     Then use self.connect() with optional host and port argument.
  83
  84     To download a file, use ftp.retrlines('RETR ' + filename),
  85     or ftp.retrbinary() with slightly different arguments.
  86     To upload a file, use ftp.storlines() or ftp.storbinary(),
  87     which have an open file as argument (see their definitions
  88     below for details).
  89     The download/upload functions first issue appropriate TYPE
  90     and PORT or PASV commands.
  91 '''
  92
  93     debugging = 0
  94     host = ''
  95     port = FTP_PORT
  96     sock = None
  97     file = None
  98     welcome = None
  99     passiveserver = 1
 100
 101     # Initialization method (called by class instantiation).
 102     # Initialize host to localhost, port to standard ftp port
 103     # Optional arguments are host (for connect()),
 104     # and user, passwd, acct (for login())
 105     def __init__(self, host='', user='', passwd='', acct=''):
 106         if host:
 107             self.connect(host)
 108             if user: self.login(user, passwd, acct)
 109
 110     def connect(self, host = '', port = 0):
 111         '''Connect to host.  Arguments are:
 112         - host: hostname to connect to (string, default previous host)
 113         - port: port to connect to (integer, default previous port)'''
 114         if host: self.host = host
 115         if port: self.port = port
 116         msg = "getaddrinfo returns an empty list"
 117         for res in socket.getaddrinfo(self.host, self.port, 0, socket.SOCK_STREAM):
 118             af, socktype, proto, canonname, sa = res
 119             try:
 120                 self.sock = socket.socket(af, socktype, proto)
 121                 self.sock.connect(sa)
 122             except socket.error, msg:
 123                 if self.sock:
 124                     self.sock.close()
 125                 self.sock = None
 126                 continue
 127             break
 128         if not self.sock:
 129             raise socket.error, msg
 130         self.af = af
 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 `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 == '4':
 212             raise error_temp, resp
 213         if c == '5':
 214             raise error_perm, resp
 215         if c not in '123':
 216             raise error_proto, resp
 217         return 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 = [`port/256`, `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 = ['', `af`, host, `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             af, socktype, proto, canon, sa = socket.getaddrinfo(host, port, 0, socket.SOCK_STREAM)[0]
 323             conn = socket.socket(af, socktype, proto)
 324             conn.connect(sa)
 325             if rest is not None:
 326                 self.sendcmd("REST %s" % rest)
 327             resp = self.sendcmd(cmd)
 328             if resp[0] != '1':
 329                 raise error_reply, resp
 330         else:
 331             sock = self.makeport()
 332             if rest is not None:
 333                 self.sendcmd("REST %s" % rest)
 334             resp = self.sendcmd(cmd)
 335             if resp[0] != '1':
 336                 raise error_reply, resp
 337             conn, sockaddr = sock.accept()
 338         if resp[:3] == '150':
 339             # this is conditional in case we received a 125
 340             size = parse150(resp)
 341         return conn, size
 342
 343     def transfercmd(self, cmd, rest=None):
 344         """Like ntransfercmd() but returns only the socket."""
 345         return self.ntransfercmd(cmd, rest)[0]
 346
 347     def login(self, user = '', passwd = '', acct = ''):
 348         '''Login, default anonymous.'''
 349         if not user: user = 'anonymous'
 350         if not passwd: passwd = ''
 351         if not acct: acct = ''
 352         if user == 'anonymous' and passwd in ('', '-'):
 353             # If there is no anonymous ftp password specified
 354             # then we'll just use anonymous@
 355             # We don't send any other thing because:
 356             # - We want to remain anonymous
 357             # - We want to stop SPAM
 358             # - We don't want to let ftp sites to discriminate by the user,
 359             #   host or country.
 360             passwd = passwd + 'anonymous@'
 361         resp = self.sendcmd('USER ' + user)
 362         if resp[0] == '3': resp = self.sendcmd('PASS ' + passwd)
 363         if resp[0] == '3': resp = self.sendcmd('ACCT ' + acct)
 364         if resp[0] != '2':
 365             raise error_reply, resp
 366         return resp
 367
 368     def retrbinary(self, cmd, callback, blocksize=8192, rest=None):
 369         """Retrieve data in binary mode.
 370
 371         `cmd' is a RETR command.  `callback' is a callback function is
 372         called for each block.  No more than `blocksize' number of
 373         bytes will be read from the socket.  Optional `rest' is passed
 374         to transfercmd().
 375
 376         A new port is created for you.  Return the response code.
 377         """
 378         self.voidcmd('TYPE I')
 379         conn = self.transfercmd(cmd, rest)
 380         while 1:
 381             data = conn.recv(blocksize)
 382             if not data:
 383                 break
 384             callback(data)
 385         conn.close()
 386         return self.voidresp()
 387
 388     def retrlines(self, cmd, callback = None):
 389         '''Retrieve data in line mode.
 390         The argument is a RETR or LIST command.
 391         The callback function (2nd argument) is called for each line,
 392         with trailing CRLF stripped.  This creates a new port for you.
 393         print_line() is the default callback.'''
 394         if callback is None: callback = print_line
 395         resp = self.sendcmd('TYPE A')
 396         conn = self.transfercmd(cmd)
 397         fp = conn.makefile('rb')
 398         while 1:
 399             line = fp.readline()
 400             if self.debugging > 2: print '*retr*', `line`
 401             if not line:
 402                 break
 403             if line[-2:] == CRLF:
 404                 line = line[:-2]
 405             elif line[-1:] == '\n':
 406                 line = line[:-1]
 407             callback(line)
 408         fp.close()
 409         conn.close()
 410         return self.voidresp()
 411
 412     def storbinary(self, cmd, fp, blocksize=8192):
 413         '''Store a file in binary mode.'''
 414         self.voidcmd('TYPE I')
 415         conn = self.transfercmd(cmd)
 416         while 1:
 417             buf = fp.read(blocksize)
 418             if not buf: break
 419             conn.sendall(buf)
 420         conn.close()
 421         return self.voidresp()
 422
 423     def storlines(self, cmd, fp):
 424         '''Store a file in line mode.'''
 425         self.voidcmd('TYPE A')
 426         conn = self.transfercmd(cmd)
 427         while 1:
 428             buf = fp.readline()
 429             if not buf: break
 430             if buf[-2:] != CRLF:
 431                 if buf[-1] in CRLF: buf = buf[:-1]
 432                 buf = buf + CRLF
 433             conn.sendall(buf)
 434         conn.close()
 435         return self.voidresp()
 436
 437     def acct(self, password):
 438         '''Send new account name.'''
 439         cmd = 'ACCT ' + password
 440         return self.voidcmd(cmd)
 441
 442     def nlst(self, *args):
 443         '''Return a list of files in a given directory (default the current).'''
 444         cmd = 'NLST'
 445         for arg in args:
 446             cmd = cmd + (' ' + arg)
 447         files = []
 448         self.retrlines(cmd, files.append)
 449         return files
 450
 451     def dir(self, *args):
 452         '''List a directory in long form.
 453         By default list current directory to stdout.
 454         Optional last argument is callback function; all
 455         non-empty arguments before it are concatenated to the
 456         LIST command.  (This *should* only be used for a pathname.)'''
 457         cmd = 'LIST'
 458         func = None
 459         if args[-1:] and type(args[-1]) != type(''):
 460             args, func = args[:-1], args[-1]
 461         for arg in args:
 462             if arg:
 463                 cmd = cmd + (' ' + arg)
 464         self.retrlines(cmd, func)
 465
 466     def rename(self, fromname, toname):
 467         '''Rename a file.'''
 468         resp = self.sendcmd('RNFR ' + fromname)
 469         if resp[0] != '3':
 470             raise error_reply, resp
 471         return self.voidcmd('RNTO ' + toname)
 472
 473     def delete(self, filename):
 474         '''Delete a file.'''
 475         resp = self.sendcmd('DELE ' + filename)
 476         if resp[:3] in ('250', '200'):
 477             return resp
 478         elif resp[:1] == '5':
 479             raise error_perm, resp
 480         else:
 481             raise error_reply, resp
 482
 483     def cwd(self, dirname):
 484         '''Change to a directory.'''
 485         if dirname == '..':
 486             try:
 487                 return self.voidcmd('CDUP')
 488             except error_perm, msg:
 489                 if msg.args[0][:3] != '500':
 490                     raise
 491         elif dirname == '':
 492             dirname = '.'  # does nothing, but could return error
 493         cmd = 'CWD ' + dirname
 494         return self.voidcmd(cmd)
 495
 496     def size(self, filename):
 497         '''Retrieve the size of a file.'''
 498         # Note that the RFC doesn't say anything about 'SIZE'
 499         resp = self.sendcmd('SIZE ' + filename)
 500         if resp[:3] == '213':
 501             s = resp[3:].strip()
 502             try:
 503                 return int(s)
 504             except (OverflowError, ValueError):
 505                 return long(s)
 506
 507     def mkd(self, dirname):
 508         '''Make a directory, return its full pathname.'''
 509         resp = self.sendcmd('MKD ' + dirname)
 510         return parse257(resp)
 511
 512     def rmd(self, dirname):
 513         '''Remove a directory.'''
 514         return self.voidcmd('RMD ' + dirname)
 515
 516     def pwd(self):
 517         '''Return current working directory.'''
 518         resp = self.sendcmd('PWD')
 519         return parse257(resp)
 520
 521     def quit(self):
 522         '''Quit, and close the connection.'''
 523         resp = self.voidcmd('QUIT')
 524         self.close()
 525         return resp
 526
 527     def close(self):
 528         '''Close the connection without assuming anything about it.'''
 529         if self.file:
 530             self.file.close()
 531             self.sock.close()
 532             self.file = self.sock = None
 533
 534
 535 _150_re = None
 536
 537 def parse150(resp):
 538     '''Parse the '150' response for a RETR request.
 539     Returns the expected transfer size or None; size is not guaranteed to
 540     be present in the 150 message.
 541     '''
 542     if resp[:3] != '150':
 543         raise error_reply, resp
 544     global _150_re
 545     if _150_re is None:
 546         import re
 547         _150_re = re.compile("150 .* \((\d+) bytes\)", re.IGNORECASE)
 548     m = _150_re.match(resp)
 549     if not m:
 550         return None
 551     s = m.group(1)
 552     try:
 553         return int(s)
 554     except (OverflowError, ValueError):
 555         return long(s)
 556
 557
 558 _227_re = None
 559
 560 def parse227(resp):
 561     '''Parse the '227' response for a PASV request.
 562     Raises error_proto if it does not contain '(h1,h2,h3,h4,p1,p2)'
 563     Return ('host.addr.as.numbers', port#) tuple.'''
 564
 565     if resp[:3] != '227':
 566         raise error_reply, resp
 567     global _227_re
 568     if _227_re is None:
 569         import re
 570         _227_re = re.compile(r'(\d+),(\d+),(\d+),(\d+),(\d+),(\d+)')
 571     m = _227_re.search(resp)
 572     if not m:
 573         raise error_proto, resp
 574     numbers = m.groups()
 575     host = '.'.join(numbers[:4])
 576     port = (int(numbers[4]) << 8) + int(numbers[5])
 577     return host, port
 578
 579
 580 def parse229(resp, peer):
 581     '''Parse the '229' response for a EPSV request.
 582     Raises error_proto if it does not contain '(|||port|)'
 583     Return ('host.addr.as.numbers', port#) tuple.'''
 584
 585     if resp[:3] <> '229':
 586         raise error_reply, resp
 587     left = resp.find('(')
 588     if left < 0: raise error_proto, resp
 589     right = resp.find(')', left + 1)
 590     if right < 0:
 591         raise error_proto, resp # should contain '(|||port|)'
 592     if resp[left + 1] <> resp[right - 1]:
 593         raise error_proto, resp
 594     parts = resp[left + 1:right].split(resp[left+1])
 595     if len(parts) <> 5:
 596         raise error_proto, resp
 597     host = peer[0]
 598     port = int(parts[3])
 599     return host, port
 600
 601
 602 def parse257(resp):
 603     '''Parse the '257' response for a MKD or PWD request.
 604     This is a response to a MKD or PWD request: a directory name.
 605     Returns the directoryname in the 257 reply.'''
 606
 607     if resp[:3] != '257':
 608         raise error_reply, resp
 609     if resp[3:5] != ' "':
 610         return '' # Not compliant to RFC 959, but UNIX ftpd does this
 611     dirname = ''
 612     i = 5
 613     n = len(resp)
 614     while i < n:
 615         c = resp[i]
 616         i = i+1
 617         if c == '"':
 618             if i >= n or resp[i] != '"':
 619                 break
 620             i = i+1
 621         dirname = dirname + c
 622     return dirname
 623
 624
 625 def print_line(line):
 626     '''Default retrlines callback to print a line.'''
 627     print line
 628
 629
 630 def ftpcp(source, sourcename, target, targetname = '', type = 'I'):
 631     '''Copy file from one FTP-instance to another.'''
 632     if not targetname: targetname = sourcename
 633     type = 'TYPE ' + type
 634     source.voidcmd(type)
 635     target.voidcmd(type)
 636     sourcehost, sourceport = parse227(source.sendcmd('PASV'))
 637     target.sendport(sourcehost, sourceport)
 638     # RFC 959: the user must "listen" [...] BEFORE sending the
 639     # transfer request.
 640     # So: STOR before RETR, because here the target is a "user".
 641     treply = target.sendcmd('STOR ' + targetname)
 642     if treply[:3] not in ('125', '150'): raise error_proto  # RFC 959
 643     sreply = source.sendcmd('RETR ' + sourcename)
 644     if sreply[:3] not in ('125', '150'): raise error_proto  # RFC 959
 645     source.voidresp()
 646     target.voidresp()
 647
 648
 649 class Netrc:
 650     """Class to parse & provide access to 'netrc' format files.
 651
 652     See the netrc(4) man page for information on the file format.
 653
 654     WARNING: This class is obsolete -- use module netrc instead.
 655
 656     """
 657     __defuser = None
 658     __defpasswd = None
 659     __defacct = None
 660
 661     def __init__(self, filename=None):
 662         if filename is None:
 663             if "HOME" in os.environ:
 664                 filename = os.path.join(os.environ["HOME"],
 665                                         ".netrc")
 666             else:
 667                 raise IOError, \
 668                       "specify file to load or set $HOME"
 669         self.__hosts = {}
 670         self.__macros = {}
 671         fp = open(filename, "r")
 672         in_macro = 0
 673         while 1:
 674             line = fp.readline()
 675             if not line: break
 676             if in_macro and line.strip():
 677                 macro_lines.append(line)
 678                 continue
 679             elif in_macro:
 680                 self.__macros[macro_name] = tuple(macro_lines)
 681                 in_macro = 0
 682             words = line.split()
 683             host = user = passwd = acct = None
 684             default = 0
 685             i = 0
 686             while i < len(words):
 687                 w1 = words[i]
 688                 if i+1 < len(words):
 689                     w2 = words[i + 1]
 690                 else:
 691                     w2 = None
 692                 if w1 == 'default':
 693                     default = 1
 694                 elif w1 == 'machine' and w2:
 695                     host = w2.lower()
 696                     i = i + 1
 697                 elif w1 == 'login' and w2:
 698                     user = w2
 699                     i = i + 1
 700                 elif w1 == 'password' and w2:
 701                     passwd = w2
 702                     i = i + 1
 703                 elif w1 == 'account' and w2:
 704                     acct = w2
 705                     i = i + 1
 706                 elif w1 == 'macdef' and w2:
 707                     macro_name = w2
 708                     macro_lines = []
 709                     in_macro = 1
 710                     break
 711                 i = i + 1
 712             if default:
 713                 self.__defuser = user or self.__defuser
 714                 self.__defpasswd = passwd or self.__defpasswd
 715                 self.__defacct = acct or self.__defacct
 716             if host:
 717                 if host in self.__hosts:
 718                     ouser, opasswd, oacct = \
 719                            self.__hosts[host]
 720                     user = user or ouser
 721                     passwd = passwd or opasswd
 722                     acct = acct or oacct
 723                 self.__hosts[host] = user, passwd, acct
 724         fp.close()
 725
 726     def get_hosts(self):
 727         """Return a list of hosts mentioned in the .netrc file."""
 728         return self.__hosts.keys()
 729
 730     def get_account(self, host):
 731         """Returns login information for the named host.
 732
 733         The return value is a triple containing userid,
 734         password, and the accounting field.
 735
 736         """
 737         host = host.lower()
 738         user = passwd = acct = None
 739         if host in self.__hosts:
 740             user, passwd, acct = self.__hosts[host]
 741         user = user or self.__defuser
 742         passwd = passwd or self.__defpasswd
 743         acct = acct or self.__defacct
 744         return user, passwd, acct
 745
 746     def get_macros(self):
 747         """Return a list of all defined macro names."""
 748         return self.__macros.keys()
 749
 750     def get_macro(self, macro):
 751         """Return a sequence of lines which define a named macro."""
 752         return self.__macros[macro]
 753
 754
 755
 756 def test():
 757     '''Test program.
 758     Usage: ftp [-d] [-r[file]] host [-l[dir]] [-d[dir]] [-p] [file] ...'''
 759
 760     debugging = 0
 761     rcfile = None
 762     while sys.argv[1] == '-d':
 763         debugging = debugging+1
 764         del sys.argv[1]
 765     if sys.argv[1][:2] == '-r':
 766         # get name of alternate ~/.netrc file:
 767         rcfile = sys.argv[1][2:]
 768         del sys.argv[1]
 769     host = sys.argv[1]
 770     ftp = FTP(host)
 771     ftp.set_debuglevel(debugging)
 772     userid = passwd = acct = ''
 773     try:
 774         netrc = Netrc(rcfile)
 775     except IOError:
 776         if rcfile is not None:
 777             sys.stderr.write("Could not open account file"
 778                              " -- using anonymous login.")
 779     else:
 780         try:
 781             userid, passwd, acct = netrc.get_account(host)
 782         except KeyError:
 783             # no account for host
 784             sys.stderr.write(
 785                     "No account -- using anonymous login.")
 786     ftp.login(userid, passwd, acct)
 787     for file in sys.argv[2:]:
 788         if file[:2] == '-l':
 789             ftp.dir(file[2:])
 790         elif file[:2] == '-d':
 791             cmd = 'CWD'
 792             if file[2:]: cmd = cmd + ' ' + file[2:]
 793             resp = ftp.sendcmd(cmd)
 794         elif file == '-p':
 795             ftp.set_pasv(not ftp.passiveserver)
 796         else:
 797             ftp.retrbinary('RETR ' + file, \
 798                            sys.stdout.write, 1024)
 799     ftp.quit()
 800
 801
 802 if __name__ == '__main__':
 803     test()