home *** CD-ROM | disk | FTP | other *** search
/ Chip 2011 November / CHIP_2011_11.iso / Programy / Narzedzia / Calibre / calibre-0.8.18.msi / file_262 / ftplib.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2011-09-09  |  21.9 KB  |  881 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.7)
  3.  
  4. import os
  5. import sys
  6.  
  7. try:
  8.     import SOCKS
  9.     socket = SOCKS
  10.     del SOCKS
  11.     from socket import getfqdn
  12.     socket.getfqdn = getfqdn
  13.     del getfqdn
  14. except ImportError:
  15.     import socket
  16.  
  17. from socket import _GLOBAL_DEFAULT_TIMEOUT
  18. __all__ = [
  19.     'FTP',
  20.     'Netrc']
  21. MSG_OOB = 1
  22. FTP_PORT = 21
  23.  
  24. class Error(Exception):
  25.     pass
  26.  
  27.  
  28. class error_reply(Error):
  29.     pass
  30.  
  31.  
  32. class error_temp(Error):
  33.     pass
  34.  
  35.  
  36. class error_perm(Error):
  37.     pass
  38.  
  39.  
  40. class error_proto(Error):
  41.     pass
  42.  
  43. all_errors = (Error, IOError, EOFError)
  44. CRLF = '\r\n'
  45.  
  46. class FTP:
  47.     debugging = 0
  48.     host = ''
  49.     port = FTP_PORT
  50.     sock = None
  51.     file = None
  52.     welcome = None
  53.     passiveserver = 1
  54.     
  55.     def __init__(self, host = '', user = '', passwd = '', acct = '', timeout = _GLOBAL_DEFAULT_TIMEOUT):
  56.         self.timeout = timeout
  57.         if host:
  58.             self.connect(host)
  59.             if user:
  60.                 self.login(user, passwd, acct)
  61.             
  62.  
  63.     
  64.     def connect(self, host = '', port = 0, timeout = -999):
  65.         if host != '':
  66.             self.host = host
  67.         if port > 0:
  68.             self.port = port
  69.         if timeout != -999:
  70.             self.timeout = timeout
  71.         self.sock = socket.create_connection((self.host, self.port), self.timeout)
  72.         self.af = self.sock.family
  73.         self.file = self.sock.makefile('rb')
  74.         self.welcome = self.getresp()
  75.         return self.welcome
  76.  
  77.     
  78.     def getwelcome(self):
  79.         if self.debugging:
  80.             print '*welcome*', self.sanitize(self.welcome)
  81.         return self.welcome
  82.  
  83.     
  84.     def set_debuglevel(self, level):
  85.         self.debugging = level
  86.  
  87.     debug = set_debuglevel
  88.     
  89.     def set_pasv(self, val):
  90.         self.passiveserver = val
  91.  
  92.     
  93.     def sanitize(self, s):
  94.         if s[:5] == 'pass ' or s[:5] == 'PASS ':
  95.             i = len(s)
  96.             while i > 5 and s[i - 1] in '\r\n':
  97.                 i = i - 1
  98.             s = s[:5] + '*' * (i - 5) + s[i:]
  99.         return repr(s)
  100.  
  101.     
  102.     def putline(self, line):
  103.         line = line + CRLF
  104.         if self.debugging > 1:
  105.             print '*put*', self.sanitize(line)
  106.         self.sock.sendall(line)
  107.  
  108.     
  109.     def putcmd(self, line):
  110.         if self.debugging:
  111.             print '*cmd*', self.sanitize(line)
  112.         self.putline(line)
  113.  
  114.     
  115.     def getline(self):
  116.         line = self.file.readline()
  117.         if self.debugging > 1:
  118.             print '*get*', self.sanitize(line)
  119.         if not line:
  120.             raise EOFError
  121.         if line[-2:] == CRLF:
  122.             line = line[:-2]
  123.         elif line[-1:] in CRLF:
  124.             line = line[:-1]
  125.         return line
  126.  
  127.     
  128.     def getmultiline(self):
  129.         line = self.getline()
  130.         if line[3:4] == '-':
  131.             code = line[:3]
  132.             while None:
  133.                 nextline = self.getline()
  134.                 line = line + '\n' + nextline
  135.                 if nextline[:3] == code and nextline[3:4] != '-':
  136.                     break
  137.                     continue
  138.                     continue
  139.                 return line
  140.  
  141.     
  142.     def getresp(self):
  143.         resp = self.getmultiline()
  144.         if self.debugging:
  145.             print '*resp*', self.sanitize(resp)
  146.         self.lastresp = resp[:3]
  147.         c = resp[:1]
  148.         if c in ('1', '2', '3'):
  149.             return resp
  150.         if None == '4':
  151.             raise error_temp, resp
  152.         if c == '5':
  153.             raise error_perm, resp
  154.         raise error_proto, resp
  155.  
  156.     
  157.     def voidresp(self):
  158.         resp = self.getresp()
  159.         if resp[:1] != '2':
  160.             raise error_reply, resp
  161.         return resp
  162.  
  163.     
  164.     def abort(self):
  165.         line = 'ABOR' + CRLF
  166.         if self.debugging > 1:
  167.             print '*put urgent*', self.sanitize(line)
  168.         self.sock.sendall(line, MSG_OOB)
  169.         resp = self.getmultiline()
  170.         if resp[:3] not in ('426', '225', '226'):
  171.             raise error_proto, resp
  172.  
  173.     
  174.     def sendcmd(self, cmd):
  175.         self.putcmd(cmd)
  176.         return self.getresp()
  177.  
  178.     
  179.     def voidcmd(self, cmd):
  180.         self.putcmd(cmd)
  181.         return self.voidresp()
  182.  
  183.     
  184.     def sendport(self, host, port):
  185.         hbytes = host.split('.')
  186.         pbytes = [
  187.             repr(port // 256),
  188.             repr(port % 256)]
  189.         bytes = hbytes + pbytes
  190.         cmd = 'PORT ' + ','.join(bytes)
  191.         return self.voidcmd(cmd)
  192.  
  193.     
  194.     def sendeprt(self, host, port):
  195.         af = 0
  196.         if self.af == socket.AF_INET:
  197.             af = 1
  198.         if self.af == socket.AF_INET6:
  199.             af = 2
  200.         if af == 0:
  201.             raise error_proto, 'unsupported address family'
  202.         fields = [
  203.             '',
  204.             repr(af),
  205.             host,
  206.             repr(port),
  207.             '']
  208.         cmd = 'EPRT ' + '|'.join(fields)
  209.         return self.voidcmd(cmd)
  210.  
  211.     
  212.     def makeport(self):
  213.         msg = 'getaddrinfo returns an empty list'
  214.         sock = None
  215.         for res in socket.getaddrinfo(None, 0, self.af, socket.SOCK_STREAM, 0, socket.AI_PASSIVE):
  216.             (af, socktype, proto, canonname, sa) = res
  217.             
  218.             try:
  219.                 sock = socket.socket(af, socktype, proto)
  220.                 sock.bind(sa)
  221.             except socket.error:
  222.                 msg = None
  223.                 if sock:
  224.                     sock.close()
  225.                 sock = None
  226.                 continue
  227.  
  228.         
  229.         if not sock:
  230.             raise socket.error, msg
  231.         sock.listen(1)
  232.         port = sock.getsockname()[1]
  233.         host = self.sock.getsockname()[0]
  234.         if self.af == socket.AF_INET:
  235.             resp = self.sendport(host, port)
  236.         else:
  237.             resp = self.sendeprt(host, port)
  238.         if self.timeout is not _GLOBAL_DEFAULT_TIMEOUT:
  239.             sock.settimeout(self.timeout)
  240.         return sock
  241.  
  242.     
  243.     def makepasv(self):
  244.         if self.af == socket.AF_INET:
  245.             (host, port) = parse227(self.sendcmd('PASV'))
  246.         else:
  247.             (host, port) = parse229(self.sendcmd('EPSV'), self.sock.getpeername())
  248.         return (host, port)
  249.  
  250.     
  251.     def ntransfercmd(self, cmd, rest = None):
  252.         size = None
  253.         if self.passiveserver:
  254.             (host, port) = self.makepasv()
  255.             conn = socket.create_connection((host, port), self.timeout)
  256.             if rest is not None:
  257.                 self.sendcmd('REST %s' % rest)
  258.             resp = self.sendcmd(cmd)
  259.             if resp[0] == '2':
  260.                 resp = self.getresp()
  261.             if resp[0] != '1':
  262.                 raise error_reply, resp
  263.         else:
  264.             sock = self.makeport()
  265.             if rest is not None:
  266.                 self.sendcmd('REST %s' % rest)
  267.             resp = self.sendcmd(cmd)
  268.             if resp[0] == '2':
  269.                 resp = self.getresp()
  270.             if resp[0] != '1':
  271.                 raise error_reply, resp
  272.             (conn, sockaddr) = sock.accept()
  273.             if self.timeout is not _GLOBAL_DEFAULT_TIMEOUT:
  274.                 conn.settimeout(self.timeout)
  275.         if resp[:3] == '150':
  276.             size = parse150(resp)
  277.         return (conn, size)
  278.  
  279.     
  280.     def transfercmd(self, cmd, rest = None):
  281.         return self.ntransfercmd(cmd, rest)[0]
  282.  
  283.     
  284.     def login(self, user = '', passwd = '', acct = ''):
  285.         if not user:
  286.             user = 'anonymous'
  287.         if not passwd:
  288.             passwd = ''
  289.         if not acct:
  290.             acct = ''
  291.         if user == 'anonymous' and passwd in ('', '-'):
  292.             passwd = passwd + 'anonymous@'
  293.         resp = self.sendcmd('USER ' + user)
  294.         if resp[0] == '3':
  295.             resp = self.sendcmd('PASS ' + passwd)
  296.         if resp[0] == '3':
  297.             resp = self.sendcmd('ACCT ' + acct)
  298.         if resp[0] != '2':
  299.             raise error_reply, resp
  300.         return resp
  301.  
  302.     
  303.     def retrbinary(self, cmd, callback, blocksize = 8192, rest = None):
  304.         self.voidcmd('TYPE I')
  305.         conn = self.transfercmd(cmd, rest)
  306.         while None:
  307.             data = conn.recv(blocksize)
  308.             if not data:
  309.                 break
  310.             continue
  311.             conn.close()
  312.             return self.voidresp()
  313.  
  314.     
  315.     def retrlines(self, cmd, callback = None):
  316.         if callback is None:
  317.             callback = print_line
  318.         resp = self.sendcmd('TYPE A')
  319.         conn = self.transfercmd(cmd)
  320.         fp = conn.makefile('rb')
  321.         while None:
  322.             line = fp.readline()
  323.             if self.debugging > 2:
  324.                 print '*retr*', repr(line)
  325.             if not line:
  326.                 break
  327.             if line[-2:] == CRLF:
  328.                 line = line[:-2]
  329.             elif line[-1:] == '\n':
  330.                 line = line[:-1]
  331.             continue
  332.             fp.close()
  333.             conn.close()
  334.             return self.voidresp()
  335.  
  336.     
  337.     def storbinary(self, cmd, fp, blocksize = 8192, callback = None, rest = None):
  338.         self.voidcmd('TYPE I')
  339.         conn = self.transfercmd(cmd, rest)
  340.         while None:
  341.             buf = fp.read(blocksize)
  342.             if not buf:
  343.                 break
  344.             if callback:
  345.                 callback(buf)
  346.                 continue
  347.                 continue
  348.                 conn.close()
  349.                 return self.voidresp()
  350.  
  351.     
  352.     def storlines(self, cmd, fp, callback = None):
  353.         self.voidcmd('TYPE A')
  354.         conn = self.transfercmd(cmd)
  355.         while None:
  356.             buf = fp.readline()
  357.             if not buf:
  358.                 break
  359.             if buf[-2:] != CRLF:
  360.                 if buf[-1] in CRLF:
  361.                     buf = buf[:-1]
  362.                 buf = buf + CRLF
  363.             if callback:
  364.                 callback(buf)
  365.                 continue
  366.                 continue
  367.                 conn.close()
  368.                 return self.voidresp()
  369.  
  370.     
  371.     def acct(self, password):
  372.         cmd = 'ACCT ' + password
  373.         return self.voidcmd(cmd)
  374.  
  375.     
  376.     def nlst(self, *args):
  377.         cmd = 'NLST'
  378.         for arg in args:
  379.             cmd = cmd + ' ' + arg
  380.         
  381.         files = []
  382.         self.retrlines(cmd, files.append)
  383.         return files
  384.  
  385.     
  386.     def dir(self, *args):
  387.         cmd = 'LIST'
  388.         func = None
  389.         if args[-1:] and type(args[-1]) != type(''):
  390.             args = args[:-1]
  391.             func = args[-1]
  392.         for arg in args:
  393.             if arg:
  394.                 cmd = cmd + ' ' + arg
  395.                 continue
  396.         self.retrlines(cmd, func)
  397.  
  398.     
  399.     def rename(self, fromname, toname):
  400.         resp = self.sendcmd('RNFR ' + fromname)
  401.         if resp[0] != '3':
  402.             raise error_reply, resp
  403.         return self.voidcmd('RNTO ' + toname)
  404.  
  405.     
  406.     def delete(self, filename):
  407.         resp = self.sendcmd('DELE ' + filename)
  408.         if resp[:3] in ('250', '200'):
  409.             return resp
  410.         raise None, resp
  411.  
  412.     
  413.     def cwd(self, dirname):
  414.         if dirname == '..':
  415.             
  416.             try:
  417.                 return self.voidcmd('CDUP')
  418.             except error_perm:
  419.                 msg = None
  420.                 if msg.args[0][:3] != '500':
  421.                     raise 
  422.             
  423.  
  424.         if dirname == '':
  425.             dirname = '.'
  426.         cmd = 'CWD ' + dirname
  427.         return self.voidcmd(cmd)
  428.  
  429.     
  430.     def size(self, filename):
  431.         resp = self.sendcmd('SIZE ' + filename)
  432.         if resp[:3] == '213':
  433.             s = resp[3:].strip()
  434.             
  435.             try:
  436.                 return int(s)
  437.             except (OverflowError, ValueError):
  438.                 return long(s)
  439.             
  440.  
  441.  
  442.     
  443.     def mkd(self, dirname):
  444.         resp = self.sendcmd('MKD ' + dirname)
  445.         return parse257(resp)
  446.  
  447.     
  448.     def rmd(self, dirname):
  449.         return self.voidcmd('RMD ' + dirname)
  450.  
  451.     
  452.     def pwd(self):
  453.         resp = self.sendcmd('PWD')
  454.         return parse257(resp)
  455.  
  456.     
  457.     def quit(self):
  458.         resp = self.voidcmd('QUIT')
  459.         self.close()
  460.         return resp
  461.  
  462.     
  463.     def close(self):
  464.         if self.file:
  465.             self.file.close()
  466.             self.sock.close()
  467.             self.file = None
  468.             self.sock = None
  469.  
  470.  
  471.  
  472. try:
  473.     import ssl
  474. except ImportError:
  475.     pass
  476.  
  477.  
  478. class FTP_TLS(FTP):
  479.     ssl_version = ssl.PROTOCOL_TLSv1
  480.     
  481.     def __init__(self, host = '', user = '', passwd = '', acct = '', keyfile = None, certfile = None, timeout = _GLOBAL_DEFAULT_TIMEOUT):
  482.         self.keyfile = keyfile
  483.         self.certfile = certfile
  484.         self._prot_p = False
  485.         FTP.__init__(self, host, user, passwd, acct, timeout)
  486.  
  487.     
  488.     def login(self, user = '', passwd = '', acct = '', secure = True):
  489.         if secure and not isinstance(self.sock, ssl.SSLSocket):
  490.             self.auth()
  491.         return FTP.login(self, user, passwd, acct)
  492.  
  493.     
  494.     def auth(self):
  495.         if isinstance(self.sock, ssl.SSLSocket):
  496.             raise ValueError('Already using TLS')
  497.         if self.ssl_version == ssl.PROTOCOL_TLSv1:
  498.             resp = self.voidcmd('AUTH TLS')
  499.         else:
  500.             resp = self.voidcmd('AUTH SSL')
  501.         self.sock = ssl.wrap_socket(self.sock, self.keyfile, self.certfile, ssl_version = self.ssl_version)
  502.         self.file = self.sock.makefile(mode = 'rb')
  503.         return resp
  504.  
  505.     
  506.     def prot_p(self):
  507.         self.voidcmd('PBSZ 0')
  508.         resp = self.voidcmd('PROT P')
  509.         self._prot_p = True
  510.         return resp
  511.  
  512.     
  513.     def prot_c(self):
  514.         resp = self.voidcmd('PROT C')
  515.         self._prot_p = False
  516.         return resp
  517.  
  518.     
  519.     def ntransfercmd(self, cmd, rest = None):
  520.         (conn, size) = FTP.ntransfercmd(self, cmd, rest)
  521.         if self._prot_p:
  522.             conn = ssl.wrap_socket(conn, self.keyfile, self.certfile, ssl_version = self.ssl_version)
  523.         return (conn, size)
  524.  
  525.     
  526.     def retrbinary(self, cmd, callback, blocksize = 8192, rest = None):
  527.         self.voidcmd('TYPE I')
  528.         conn = self.transfercmd(cmd, rest)
  529.         
  530.         try:
  531.             while None:
  532.                 data = conn.recv(blocksize)
  533.                 if not data:
  534.                     break
  535.                 continue
  536.                 if isinstance(conn, ssl.SSLSocket):
  537.                     conn.unwrap()
  538.             conn.close()
  539.             return self.voidresp()
  540.  
  541.  
  542.     
  543.     def retrlines(self, cmd, callback = None):
  544.         if callback is None:
  545.             callback = print_line
  546.         resp = self.sendcmd('TYPE A')
  547.         conn = self.transfercmd(cmd)
  548.         fp = conn.makefile('rb')
  549.         
  550.         try:
  551.             while None:
  552.                 line = fp.readline()
  553.                 if self.debugging > 2:
  554.                     print '*retr*', repr(line)
  555.                 if not line:
  556.                     break
  557.                 if line[-2:] == CRLF:
  558.                     line = line[:-2]
  559.                 elif line[-1:] == '\n':
  560.                     line = line[:-1]
  561.                 continue
  562.                 if isinstance(conn, ssl.SSLSocket):
  563.                     conn.unwrap()
  564.             fp.close()
  565.             conn.close()
  566.             return self.voidresp()
  567.  
  568.  
  569.     
  570.     def storbinary(self, cmd, fp, blocksize = 8192, callback = None, rest = None):
  571.         self.voidcmd('TYPE I')
  572.         conn = self.transfercmd(cmd, rest)
  573.         
  574.         try:
  575.             while None:
  576.                 buf = fp.read(blocksize)
  577.                 if not buf:
  578.                     break
  579.                 if callback:
  580.                     callback(buf)
  581.                     continue
  582.                     continue
  583.                     if isinstance(conn, ssl.SSLSocket):
  584.                         conn.unwrap()
  585.                 conn.close()
  586.                 return self.voidresp()
  587.  
  588.  
  589.     
  590.     def storlines(self, cmd, fp, callback = None):
  591.         self.voidcmd('TYPE A')
  592.         conn = self.transfercmd(cmd)
  593.         
  594.         try:
  595.             while None:
  596.                 buf = fp.readline()
  597.                 if not buf:
  598.                     break
  599.                 if buf[-2:] != CRLF:
  600.                     if buf[-1] in CRLF:
  601.                         buf = buf[:-1]
  602.                     buf = buf + CRLF
  603.                 if callback:
  604.                     callback(buf)
  605.                     continue
  606.                     continue
  607.                     if isinstance(conn, ssl.SSLSocket):
  608.                         conn.unwrap()
  609.                 conn.close()
  610.                 return self.voidresp()
  611.  
  612.  
  613.  
  614. __all__.append('FTP_TLS')
  615. all_errors = (Error, IOError, EOFError, ssl.SSLError)
  616. _150_re = None
  617.  
  618. def parse150(resp):
  619.     global _150_re
  620.     if resp[:3] != '150':
  621.         raise error_reply, resp
  622.     if _150_re is None:
  623.         import re
  624.         _150_re = re.compile('150 .* \\((\\d+) bytes\\)', re.IGNORECASE)
  625.     m = _150_re.match(resp)
  626.     if not m:
  627.         return None
  628.     s = None.group(1)
  629.     
  630.     try:
  631.         return int(s)
  632.     except (OverflowError, ValueError):
  633.         return long(s)
  634.  
  635.  
  636. _227_re = None
  637.  
  638. def parse227(resp):
  639.     global _227_re
  640.     if resp[:3] != '227':
  641.         raise error_reply, resp
  642.     if _227_re is None:
  643.         import re
  644.         _227_re = re.compile('(\\d+),(\\d+),(\\d+),(\\d+),(\\d+),(\\d+)')
  645.     m = _227_re.search(resp)
  646.     if not m:
  647.         raise error_proto, resp
  648.     numbers = m.groups()
  649.     host = '.'.join(numbers[:4])
  650.     port = (int(numbers[4]) << 8) + int(numbers[5])
  651.     return (host, port)
  652.  
  653.  
  654. def parse229(resp, peer):
  655.     if resp[:3] != '229':
  656.         raise error_reply, resp
  657.     left = resp.find('(')
  658.     if left < 0:
  659.         raise error_proto, resp
  660.     right = resp.find(')', left + 1)
  661.     if right < 0:
  662.         raise error_proto, resp
  663.     if resp[left + 1] != resp[right - 1]:
  664.         raise error_proto, resp
  665.     parts = resp[left + 1:right].split(resp[left + 1])
  666.     if len(parts) != 5:
  667.         raise error_proto, resp
  668.     host = peer[0]
  669.     port = int(parts[3])
  670.     return (host, port)
  671.  
  672.  
  673. def parse257(resp):
  674.     if resp[:3] != '257':
  675.         raise error_reply, resp
  676.     if resp[3:5] != ' "':
  677.         return ''
  678.     dirname = None
  679.     i = 5
  680.     n = len(resp)
  681.     while i < n:
  682.         c = resp[i]
  683.         i = i + 1
  684.         if c == '"':
  685.             if i >= n or resp[i] != '"':
  686.                 break
  687.             i = i + 1
  688.         dirname = dirname + c
  689.     return dirname
  690.  
  691.  
  692. def print_line(line):
  693.     print line
  694.  
  695.  
  696. def ftpcp(source, sourcename, target, targetname = '', type = 'I'):
  697.     if not targetname:
  698.         targetname = sourcename
  699.     type = 'TYPE ' + type
  700.     source.voidcmd(type)
  701.     target.voidcmd(type)
  702.     (sourcehost, sourceport) = parse227(source.sendcmd('PASV'))
  703.     target.sendport(sourcehost, sourceport)
  704.     treply = target.sendcmd('STOR ' + targetname)
  705.     if treply[:3] not in ('125', '150'):
  706.         raise error_proto
  707.     sreply = source.sendcmd('RETR ' + sourcename)
  708.     if sreply[:3] not in ('125', '150'):
  709.         raise error_proto
  710.     source.voidresp()
  711.     target.voidresp()
  712.  
  713.  
  714. class Netrc:
  715.     __defuser = None
  716.     __defpasswd = None
  717.     __defacct = None
  718.     
  719.     def __init__(self, filename = None):
  720.         if filename is None:
  721.             if 'HOME' in os.environ:
  722.                 filename = os.path.join(os.environ['HOME'], '.netrc')
  723.             else:
  724.                 raise IOError, 'specify file to load or set $HOME'
  725.         self._Netrc__hosts = { }
  726.         self._Netrc__macros = { }
  727.         fp = open(filename, 'r')
  728.         in_macro = 0
  729.         while None:
  730.             line = fp.readline()
  731.             if not line:
  732.                 break
  733.             if in_macro and line.strip():
  734.                 macro_lines.append(line)
  735.                 continue
  736.             elif in_macro:
  737.                 self._Netrc__macros[macro_name] = tuple(macro_lines)
  738.                 in_macro = 0
  739.             words = line.split()
  740.             host = None
  741.             user = None
  742.             passwd = None
  743.             acct = None
  744.             default = 0
  745.             i = 0
  746.             while i < len(words):
  747.                 w1 = words[i]
  748.                 if i + 1 < len(words):
  749.                     w2 = words[i + 1]
  750.                 else:
  751.                     w2 = None
  752.                 if w1 == 'default':
  753.                     default = 1
  754.                 elif w1 == 'machine' and w2:
  755.                     host = w2.lower()
  756.                     i = i + 1
  757.                 elif w1 == 'login' and w2:
  758.                     user = w2
  759.                     i = i + 1
  760.                 elif w1 == 'password' and w2:
  761.                     passwd = w2
  762.                     i = i + 1
  763.                 elif w1 == 'account' and w2:
  764.                     acct = w2
  765.                     i = i + 1
  766.                 elif w1 == 'macdef' and w2:
  767.                     macro_name = w2
  768.                     macro_lines = []
  769.                     in_macro = 1
  770.                     break
  771.                 i = i + 1
  772.             if default:
  773.                 if not user:
  774.                     pass
  775.                 self._Netrc__defuser = self._Netrc__defuser
  776.                 if not passwd:
  777.                     pass
  778.                 self._Netrc__defpasswd = self._Netrc__defpasswd
  779.                 if not acct:
  780.                     pass
  781.                 self._Netrc__defacct = self._Netrc__defacct
  782.             if host or host in self._Netrc__hosts:
  783.                 (ouser, opasswd, oacct) = self._Netrc__hosts[host]
  784.                 if not user:
  785.                     pass
  786.                 user = ouser
  787.                 if not passwd:
  788.                     pass
  789.                 passwd = opasswd
  790.                 if not acct:
  791.                     pass
  792.                 acct = oacct
  793.             self._Netrc__hosts[host] = (user, passwd, acct)
  794.             continue
  795.             continue
  796.             return None
  797.  
  798.     
  799.     def get_hosts(self):
  800.         return self._Netrc__hosts.keys()
  801.  
  802.     
  803.     def get_account(self, host):
  804.         host = host.lower()
  805.         user = None
  806.         passwd = None
  807.         acct = None
  808.         if host in self._Netrc__hosts:
  809.             (user, passwd, acct) = self._Netrc__hosts[host]
  810.         if not user:
  811.             pass
  812.         user = self._Netrc__defuser
  813.         if not passwd:
  814.             pass
  815.         passwd = self._Netrc__defpasswd
  816.         if not acct:
  817.             pass
  818.         acct = self._Netrc__defacct
  819.         return (user, passwd, acct)
  820.  
  821.     
  822.     def get_macros(self):
  823.         return self._Netrc__macros.keys()
  824.  
  825.     
  826.     def get_macro(self, macro):
  827.         return self._Netrc__macros[macro]
  828.  
  829.  
  830.  
  831. def test():
  832.     if len(sys.argv) < 2:
  833.         print test.__doc__
  834.         sys.exit(0)
  835.     debugging = 0
  836.     rcfile = None
  837.     while sys.argv[1] == '-d':
  838.         debugging = debugging + 1
  839.         del sys.argv[1]
  840.     if sys.argv[1][:2] == '-r':
  841.         rcfile = sys.argv[1][2:]
  842.         del sys.argv[1]
  843.     host = sys.argv[1]
  844.     ftp = FTP(host)
  845.     ftp.set_debuglevel(debugging)
  846.     userid = passwd = acct = ''
  847.     
  848.     try:
  849.         netrc = Netrc(rcfile)
  850.     except IOError:
  851.         if rcfile is not None:
  852.             sys.stderr.write('Could not open account file -- using anonymous login.')
  853.         
  854.  
  855.     
  856.     try:
  857.         (userid, passwd, acct) = netrc.get_account(host)
  858.     except KeyError:
  859.         sys.stderr.write('No account -- using anonymous login.')
  860.  
  861.     ftp.login(userid, passwd, acct)
  862.     for file in sys.argv[2:]:
  863.         if file[:2] == '-l':
  864.             ftp.dir(file[2:])
  865.             continue
  866.         if file[:2] == '-d':
  867.             cmd = 'CWD'
  868.             if file[2:]:
  869.                 cmd = cmd + ' ' + file[2:]
  870.             resp = ftp.sendcmd(cmd)
  871.             continue
  872.         if file == '-p':
  873.             ftp.set_pasv(not (ftp.passiveserver))
  874.             continue
  875.         ftp.retrbinary('RETR ' + file, sys.stdout.write, 1024)
  876.     
  877.     ftp.quit()
  878.  
  879. if __name__ == '__main__':
  880.     test()
  881.