home *** CD-ROM | disk | FTP | other *** search
/ Freelog 116 / FreelogNo116-JuilletSeptembre2013.iso / GestionFichiers / metamorphose / metamorphose2_0.8.2_setup.exe / metamorphose2.exe / ftplib.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2011-01-12  |  19KB  |  818 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (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.             break
  251.         
  252.         if not sock:
  253.             raise socket.error, msg
  254.         sock
  255.         sock.listen(1)
  256.         port = sock.getsockname()[1]
  257.         host = self.sock.getsockname()[0]
  258.         if self.af == socket.AF_INET:
  259.             resp = self.sendport(host, port)
  260.         else:
  261.             resp = self.sendeprt(host, port)
  262.         return sock
  263.  
  264.     
  265.     def makepasv(self):
  266.         if self.af == socket.AF_INET:
  267.             (host, port) = parse227(self.sendcmd('PASV'))
  268.         else:
  269.             (host, port) = parse229(self.sendcmd('EPSV'), self.sock.getpeername())
  270.         return (host, port)
  271.  
  272.     
  273.     def ntransfercmd(self, cmd, rest = None):
  274.         size = None
  275.         if self.passiveserver:
  276.             (host, port) = self.makepasv()
  277.             conn = socket.create_connection((host, port), self.timeout)
  278.             if rest is not None:
  279.                 self.sendcmd('REST %s' % rest)
  280.             
  281.             resp = self.sendcmd(cmd)
  282.             if resp[0] == '2':
  283.                 resp = self.getresp()
  284.             
  285.             if resp[0] != '1':
  286.                 raise error_reply, resp
  287.             resp[0] != '1'
  288.         else:
  289.             sock = self.makeport()
  290.             if rest is not None:
  291.                 self.sendcmd('REST %s' % rest)
  292.             
  293.             resp = self.sendcmd(cmd)
  294.             if resp[0] == '2':
  295.                 resp = self.getresp()
  296.             
  297.             if resp[0] != '1':
  298.                 raise error_reply, resp
  299.             resp[0] != '1'
  300.             (conn, sockaddr) = sock.accept()
  301.         if resp[:3] == '150':
  302.             size = parse150(resp)
  303.         
  304.         return (conn, size)
  305.  
  306.     
  307.     def transfercmd(self, cmd, rest = None):
  308.         return self.ntransfercmd(cmd, rest)[0]
  309.  
  310.     
  311.     def login(self, user = '', passwd = '', acct = ''):
  312.         if not user:
  313.             user = 'anonymous'
  314.         
  315.         if not passwd:
  316.             passwd = ''
  317.         
  318.         if not acct:
  319.             acct = ''
  320.         
  321.         if user == 'anonymous' and passwd in ('', '-'):
  322.             passwd = passwd + 'anonymous@'
  323.         
  324.         resp = self.sendcmd('USER ' + user)
  325.         if resp[0] == '3':
  326.             resp = self.sendcmd('PASS ' + passwd)
  327.         
  328.         if resp[0] == '3':
  329.             resp = self.sendcmd('ACCT ' + acct)
  330.         
  331.         if resp[0] != '2':
  332.             raise error_reply, resp
  333.         resp[0] != '2'
  334.         return resp
  335.  
  336.     
  337.     def retrbinary(self, cmd, callback, blocksize = 8192, rest = None):
  338.         self.voidcmd('TYPE I')
  339.         conn = self.transfercmd(cmd, rest)
  340.         while None:
  341.             data = conn.recv(blocksize)
  342.             if not data:
  343.                 break
  344.             
  345.             continue
  346.             conn.close()
  347.             return self.voidresp()
  348.  
  349.     
  350.     def retrlines(self, cmd, callback = None):
  351.         if callback is None:
  352.             callback = print_line
  353.         
  354.         resp = self.sendcmd('TYPE A')
  355.         conn = self.transfercmd(cmd)
  356.         fp = conn.makefile('rb')
  357.         while None:
  358.             line = fp.readline()
  359.             if self.debugging > 2:
  360.                 print '*retr*', repr(line)
  361.             
  362.             if not line:
  363.                 break
  364.             
  365.             if line[-2:] == CRLF:
  366.                 line = line[:-2]
  367.             elif line[-1:] == '\n':
  368.                 line = line[:-1]
  369.             
  370.             continue
  371.             fp.close()
  372.             conn.close()
  373.             return self.voidresp()
  374.  
  375.     
  376.     def storbinary(self, cmd, fp, blocksize = 8192, callback = None):
  377.         self.voidcmd('TYPE I')
  378.         conn = self.transfercmd(cmd)
  379.         while None:
  380.             buf = fp.read(blocksize)
  381.             if not buf:
  382.                 break
  383.             
  384.             if callback:
  385.                 callback(buf)
  386.                 continue
  387.             continue
  388.             conn.close()
  389.             return self.voidresp()
  390.  
  391.     
  392.     def storlines(self, cmd, fp, callback = None):
  393.         self.voidcmd('TYPE A')
  394.         conn = self.transfercmd(cmd)
  395.         while None:
  396.             buf = fp.readline()
  397.             if not buf:
  398.                 break
  399.             
  400.             if buf[-2:] != CRLF:
  401.                 if buf[-1] in CRLF:
  402.                     buf = buf[:-1]
  403.                 
  404.                 buf = buf + CRLF
  405.             
  406.             if callback:
  407.                 callback(buf)
  408.                 continue
  409.             continue
  410.             conn.close()
  411.             return self.voidresp()
  412.  
  413.     
  414.     def acct(self, password):
  415.         cmd = 'ACCT ' + password
  416.         return self.voidcmd(cmd)
  417.  
  418.     
  419.     def nlst(self, *args):
  420.         cmd = 'NLST'
  421.         for arg in args:
  422.             cmd = cmd + ' ' + arg
  423.         
  424.         files = []
  425.         self.retrlines(cmd, files.append)
  426.         return files
  427.  
  428.     
  429.     def dir(self, *args):
  430.         cmd = 'LIST'
  431.         func = None
  432.         if args[-1:] and type(args[-1]) != type(''):
  433.             args = args[:-1]
  434.             func = args[-1]
  435.         
  436.         for arg in args:
  437.             if arg:
  438.                 cmd = cmd + ' ' + arg
  439.                 continue
  440.         
  441.         self.retrlines(cmd, func)
  442.  
  443.     
  444.     def rename(self, fromname, toname):
  445.         resp = self.sendcmd('RNFR ' + fromname)
  446.         if resp[0] != '3':
  447.             raise error_reply, resp
  448.         resp[0] != '3'
  449.         return self.voidcmd('RNTO ' + toname)
  450.  
  451.     
  452.     def delete(self, filename):
  453.         resp = self.sendcmd('DELE ' + filename)
  454.         if resp[:3] in ('250', '200'):
  455.             return resp
  456.         raise error_reply, resp
  457.  
  458.     
  459.     def cwd(self, dirname):
  460.         if dirname == '..':
  461.             
  462.             try:
  463.                 return self.voidcmd('CDUP')
  464.             except error_perm:
  465.                 msg = None
  466.                 if msg.args[0][:3] != '500':
  467.                     raise 
  468.                 msg.args[0][:3] != '500'
  469.             except:
  470.                 None<EXCEPTION MATCH>error_perm
  471.             
  472.  
  473.         None<EXCEPTION MATCH>error_perm
  474.         if dirname == '':
  475.             dirname = '.'
  476.         
  477.         cmd = 'CWD ' + dirname
  478.         return self.voidcmd(cmd)
  479.  
  480.     
  481.     def size(self, filename):
  482.         resp = self.sendcmd('SIZE ' + filename)
  483.         if resp[:3] == '213':
  484.             s = resp[3:].strip()
  485.             
  486.             try:
  487.                 return int(s)
  488.             except (OverflowError, ValueError):
  489.                 return long(s)
  490.             
  491.  
  492.         None<EXCEPTION MATCH>(OverflowError, ValueError)
  493.  
  494.     
  495.     def mkd(self, dirname):
  496.         resp = self.sendcmd('MKD ' + dirname)
  497.         return parse257(resp)
  498.  
  499.     
  500.     def rmd(self, dirname):
  501.         return self.voidcmd('RMD ' + dirname)
  502.  
  503.     
  504.     def pwd(self):
  505.         resp = self.sendcmd('PWD')
  506.         return parse257(resp)
  507.  
  508.     
  509.     def quit(self):
  510.         resp = self.voidcmd('QUIT')
  511.         self.close()
  512.         return resp
  513.  
  514.     
  515.     def close(self):
  516.         if self.file:
  517.             self.file.close()
  518.             self.sock.close()
  519.             self.file = None
  520.             self.sock = None
  521.         
  522.  
  523.  
  524. _150_re = None
  525.  
  526. def parse150(resp):
  527.     global _150_re
  528.     if resp[:3] != '150':
  529.         raise error_reply, resp
  530.     resp[:3] != '150'
  531.     if _150_re is None:
  532.         import re as re
  533.         _150_re = re.compile('150 .* \\((\\d+) bytes\\)', re.IGNORECASE)
  534.     
  535.     m = _150_re.match(resp)
  536.     if not m:
  537.         return None
  538.     s = m.group(1)
  539.     
  540.     try:
  541.         return int(s)
  542.     except (OverflowError, ValueError):
  543.         m
  544.         m
  545.         return long(s)
  546.  
  547.  
  548. _227_re = None
  549.  
  550. def parse227(resp):
  551.     global _227_re
  552.     if resp[:3] != '227':
  553.         raise error_reply, resp
  554.     resp[:3] != '227'
  555.     if _227_re is None:
  556.         import re
  557.         _227_re = re.compile('(\\d+),(\\d+),(\\d+),(\\d+),(\\d+),(\\d+)')
  558.     
  559.     m = _227_re.search(resp)
  560.     if not m:
  561.         raise error_proto, resp
  562.     m
  563.     numbers = m.groups()
  564.     host = '.'.join(numbers[:4])
  565.     port = (int(numbers[4]) << 8) + int(numbers[5])
  566.     return (host, port)
  567.  
  568.  
  569. def parse229(resp, peer):
  570.     if resp[:3] != '229':
  571.         raise error_reply, resp
  572.     resp[:3] != '229'
  573.     left = resp.find('(')
  574.     if left < 0:
  575.         raise error_proto, resp
  576.     left < 0
  577.     right = resp.find(')', left + 1)
  578.     if right < 0:
  579.         raise error_proto, resp
  580.     right < 0
  581.     if resp[left + 1] != resp[right - 1]:
  582.         raise error_proto, resp
  583.     resp[left + 1] != resp[right - 1]
  584.     parts = resp[left + 1:right].split(resp[left + 1])
  585.     if len(parts) != 5:
  586.         raise error_proto, resp
  587.     len(parts) != 5
  588.     host = peer[0]
  589.     port = int(parts[3])
  590.     return (host, port)
  591.  
  592.  
  593. def parse257(resp):
  594.     if resp[:3] != '257':
  595.         raise error_reply, resp
  596.     resp[:3] != '257'
  597.     if resp[3:5] != ' "':
  598.         return ''
  599.     dirname = ''
  600.     i = 5
  601.     n = len(resp)
  602.     while i < n:
  603.         c = resp[i]
  604.         i = i + 1
  605.         dirname = dirname + c
  606.         continue
  607.         None if c == '"' else resp[3:5] != ' "'
  608.     return dirname
  609.  
  610.  
  611. def print_line(line):
  612.     print line
  613.  
  614.  
  615. def ftpcp(source, sourcename, target, targetname = '', type = 'I'):
  616.     if not targetname:
  617.         targetname = sourcename
  618.     
  619.     type = 'TYPE ' + type
  620.     source.voidcmd(type)
  621.     target.voidcmd(type)
  622.     (sourcehost, sourceport) = parse227(source.sendcmd('PASV'))
  623.     target.sendport(sourcehost, sourceport)
  624.     treply = target.sendcmd('STOR ' + targetname)
  625.     if treply[:3] not in ('125', '150'):
  626.         raise error_proto
  627.     treply[:3] not in ('125', '150')
  628.     sreply = source.sendcmd('RETR ' + sourcename)
  629.     if sreply[:3] not in ('125', '150'):
  630.         raise error_proto
  631.     sreply[:3] not in ('125', '150')
  632.     source.voidresp()
  633.     target.voidresp()
  634.  
  635.  
  636. class Netrc:
  637.     __defuser = None
  638.     __defpasswd = None
  639.     __defacct = None
  640.     
  641.     def __init__(self, filename = None):
  642.         if filename is None:
  643.             if 'HOME' in os.environ:
  644.                 filename = os.path.join(os.environ['HOME'], '.netrc')
  645.             else:
  646.                 raise IOError, 'specify file to load or set $HOME'
  647.         'HOME' in os.environ
  648.         self._Netrc__hosts = { }
  649.         self._Netrc__macros = { }
  650.         fp = open(filename, 'r')
  651.         in_macro = 0
  652.         while None:
  653.             line = fp.readline()
  654.             if not line:
  655.                 break
  656.             
  657.             if in_macro and line.strip():
  658.                 macro_lines.append(line)
  659.                 continue
  660.             elif in_macro:
  661.                 self._Netrc__macros[macro_name] = tuple(macro_lines)
  662.                 in_macro = 0
  663.             
  664.             words = line.split()
  665.             host = None
  666.             user = None
  667.             passwd = None
  668.             acct = None
  669.             default = 0
  670.             i = 0
  671.             while i < len(words):
  672.                 w1 = words[i]
  673.                 if i + 1 < len(words):
  674.                     w2 = words[i + 1]
  675.                 else:
  676.                     w2 = None
  677.                 if w1 == 'default':
  678.                     default = 1
  679.                 elif w1 == 'machine' and w2:
  680.                     host = w2.lower()
  681.                     i = i + 1
  682.                 elif w1 == 'login' and w2:
  683.                     user = w2
  684.                     i = i + 1
  685.                 elif w1 == 'password' and w2:
  686.                     passwd = w2
  687.                     i = i + 1
  688.                 elif w1 == 'account' and w2:
  689.                     acct = w2
  690.                     i = i + 1
  691.                 elif w1 == 'macdef' and w2:
  692.                     macro_name = w2
  693.                     macro_lines = []
  694.                     in_macro = 1
  695.                     break
  696.                 
  697.                 i = i + 1
  698.             if default:
  699.                 if not user:
  700.                     pass
  701.                 self._Netrc__defuser = self._Netrc__defuser
  702.                 if not passwd:
  703.                     pass
  704.                 self._Netrc__defpasswd = self._Netrc__defpasswd
  705.                 if not acct:
  706.                     pass
  707.                 self._Netrc__defacct = self._Netrc__defacct
  708.             
  709.             if host:
  710.                 if host in self._Netrc__hosts:
  711.                     (ouser, opasswd, oacct) = self._Netrc__hosts[host]
  712.                     if not user:
  713.                         pass
  714.                     user = ouser
  715.                     if not passwd:
  716.                         pass
  717.                     passwd = opasswd
  718.                     if not acct:
  719.                         pass
  720.                     acct = oacct
  721.                 
  722.                 self._Netrc__hosts[host] = (user, passwd, acct)
  723.                 continue
  724.             continue
  725.             fp.close()
  726.             return None
  727.  
  728.     
  729.     def get_hosts(self):
  730.         return self._Netrc__hosts.keys()
  731.  
  732.     
  733.     def get_account(self, host):
  734.         host = host.lower()
  735.         user = None
  736.         passwd = None
  737.         acct = None
  738.         if host in self._Netrc__hosts:
  739.             (user, passwd, acct) = self._Netrc__hosts[host]
  740.         
  741.         if not user:
  742.             pass
  743.         user = self._Netrc__defuser
  744.         if not passwd:
  745.             pass
  746.         passwd = self._Netrc__defpasswd
  747.         if not acct:
  748.             pass
  749.         acct = self._Netrc__defacct
  750.         return (user, passwd, acct)
  751.  
  752.     
  753.     def get_macros(self):
  754.         return self._Netrc__macros.keys()
  755.  
  756.     
  757.     def get_macro(self, macro):
  758.         return self._Netrc__macros[macro]
  759.  
  760.  
  761.  
  762. def test():
  763.     if len(sys.argv) < 2:
  764.         print test.__doc__
  765.         sys.exit(0)
  766.     
  767.     debugging = 0
  768.     rcfile = None
  769.     while sys.argv[1] == '-d':
  770.         debugging = debugging + 1
  771.         del sys.argv[1]
  772.     if sys.argv[1][:2] == '-r':
  773.         rcfile = sys.argv[1][2:]
  774.         del sys.argv[1]
  775.     
  776.     host = sys.argv[1]
  777.     ftp = FTP(host)
  778.     ftp.set_debuglevel(debugging)
  779.     userid = passwd = acct = ''
  780.     
  781.     try:
  782.         netrc = Netrc(rcfile)
  783.     except IOError:
  784.         if rcfile is not None:
  785.             sys.stderr.write('Could not open account file -- using anonymous login.')
  786.         
  787.     except:
  788.         rcfile is not None
  789.  
  790.     
  791.     try:
  792.         (userid, passwd, acct) = netrc.get_account(host)
  793.     except KeyError:
  794.         sys.stderr.write('No account -- using anonymous login.')
  795.  
  796.     ftp.login(userid, passwd, acct)
  797.     for file in sys.argv[2:]:
  798.         if file[:2] == '-l':
  799.             ftp.dir(file[2:])
  800.             continue
  801.         if file[:2] == '-d':
  802.             cmd = 'CWD'
  803.             if file[2:]:
  804.                 cmd = cmd + ' ' + file[2:]
  805.             
  806.             resp = ftp.sendcmd(cmd)
  807.             continue
  808.         if file == '-p':
  809.             ftp.set_pasv(not (ftp.passiveserver))
  810.             continue
  811.         ftp.retrbinary('RETR ' + file, sys.stdout.write, 1024)
  812.     
  813.     ftp.quit()
  814.  
  815. if __name__ == '__main__':
  816.     test()
  817.  
  818.