home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_580 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  18.4 KB  |  817 lines

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