Lines Matching refs:self
69 def __init__(self, conn, baseclass):
70 asynchat.async_chat.__init__(self, conn)
71 self.baseclass = baseclass
72 self.baseclass.last_received_data = ''
73 self.encoding = baseclass.encoding
75 def handle_read(self):
76 new_data = self.recv(1024).decode(self.encoding, 'replace')
77 self.baseclass.last_received_data += new_data
79 def handle_close(self):
83 if not self.dtp_conn_closed:
84 self.baseclass.push('226 transfer complete')
85 self.close()
86 self.dtp_conn_closed = True
88 def push(self, what):
89 if self.baseclass.next_data is not None:
90 what = self.baseclass.next_data
91 self.baseclass.next_data = None
93 return self.close_when_done()
94 super(DummyDTPHandler, self).push(what.encode(self.encoding))
96 def handle_error(self):
104 def __init__(self, conn, encoding=DEFAULT_ENCODING):
105 asynchat.async_chat.__init__(self, conn)
107 self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_OOBINLINE, 1)
108 self.set_terminator(b"\r\n")
109 self.in_buffer = []
110 self.dtp = None
111 self.last_received_cmd = None
112 self.last_received_data = ''
113 self.next_response = ''
114 self.next_data = None
115 self.rest = None
116 self.next_retr_data = RETR_DATA
117 self.push('220 welcome')
118 self.encoding = encoding
122 self.fake_pasv_server_ip = '252.253.254.255'
124 def collect_incoming_data(self, data):
125 self.in_buffer.append(data)
127 def found_terminator(self):
128 line = b''.join(self.in_buffer).decode(self.encoding)
129 self.in_buffer = []
130 if self.next_response:
131 self.push(self.next_response)
132 self.next_response = ''
134 self.last_received_cmd = cmd
140 if hasattr(self, 'cmd_' + cmd):
141 method = getattr(self, 'cmd_' + cmd)
144 self.push('550 command "%s" not understood.' %cmd)
146 def handle_error(self):
149 def push(self, data):
150 asynchat.async_chat.push(self, data.encode(self.encoding) + b'\r\n')
152 def cmd_port(self, arg):
157 self.dtp = self.dtp_handler(s, baseclass=self)
158 self.push('200 active data connection established')
160 def cmd_pasv(self, arg):
161 with socket.create_server((self.socket.getsockname()[0], 0)) as sock:
164 ip = self.fake_pasv_server_ip
166 self.push('227 entering passive mode (%s,%d,%d)' %(ip, p1, p2))
168 self.dtp = self.dtp_handler(conn, baseclass=self)
170 def cmd_eprt(self, arg):
174 self.dtp = self.dtp_handler(s, baseclass=self)
175 self.push('200 active data connection established')
177 def cmd_epsv(self, arg):
178 with socket.create_server((self.socket.getsockname()[0], 0),
182 self.push('229 entering extended passive mode (|||%d|)' %port)
184 self.dtp = self.dtp_handler(conn, baseclass=self)
186 def cmd_echo(self, arg):
188 self.push(arg)
190 def cmd_noop(self, arg):
191 self.push('200 noop ok')
193 def cmd_user(self, arg):
194 self.push('331 username ok')
196 def cmd_pass(self, arg):
197 self.push('230 password ok')
199 def cmd_acct(self, arg):
200 self.push('230 acct ok')
202 def cmd_rnfr(self, arg):
203 self.push('350 rnfr ok')
205 def cmd_rnto(self, arg):
206 self.push('250 rnto ok')
208 def cmd_dele(self, arg):
209 self.push('250 dele ok')
211 def cmd_cwd(self, arg):
212 self.push('250 cwd ok')
214 def cmd_size(self, arg):
215 self.push('250 1000')
217 def cmd_mkd(self, arg):
218 self.push('257 "%s"' %arg)
220 def cmd_rmd(self, arg):
221 self.push('250 rmd ok')
223 def cmd_pwd(self, arg):
224 self.push('257 "pwd ok"')
226 def cmd_type(self, arg):
227 self.push('200 type ok')
229 def cmd_quit(self, arg):
230 self.push('221 quit ok')
231 self.close()
233 def cmd_abor(self, arg):
234 self.push('226 abor ok')
236 def cmd_stor(self, arg):
237 self.push('125 stor ok')
239 def cmd_rest(self, arg):
240 self.rest = arg
241 self.push('350 rest ok')
243 def cmd_retr(self, arg):
244 self.push('125 retr ok')
245 if self.rest is not None:
246 offset = int(self.rest)
249 self.dtp.push(self.next_retr_data[offset:])
250 self.dtp.close_when_done()
251 self.rest = None
253 def cmd_list(self, arg):
254 self.push('125 list ok')
255 self.dtp.push(LIST_DATA)
256 self.dtp.close_when_done()
258 def cmd_nlst(self, arg):
259 self.push('125 nlst ok')
260 self.dtp.push(NLST_DATA)
261 self.dtp.close_when_done()
263 def cmd_opts(self, arg):
264 self.push('200 opts ok')
266 def cmd_mlsd(self, arg):
267 self.push('125 mlsd ok')
268 self.dtp.push(MLSD_DATA)
269 self.dtp.close_when_done()
271 def cmd_setlongretr(self, arg):
273 self.next_retr_data = 'x' * int(arg)
274 self.push('125 setlongretr ok')
281 def __init__(self, address, af=socket.AF_INET, encoding=DEFAULT_ENCODING):
282 threading.Thread.__init__(self)
283 asyncore.dispatcher.__init__(self)
284 self.daemon = True
285 self.create_socket(af, socket.SOCK_STREAM)
286 self.bind(address)
287 self.listen(5)
288 self.active = False
289 self.active_lock = threading.Lock()
290 self.host, self.port = self.socket.getsockname()[:2]
291 self.handler_instance = None
292 self.encoding = encoding
294 def start(self):
295 assert not self.active
296 self.__flag = threading.Event()
297 threading.Thread.start(self)
298 self.__flag.wait()
300 def run(self):
301 self.active = True
302 self.__flag.set()
303 while self.active and asyncore.socket_map:
304 self.active_lock.acquire()
306 self.active_lock.release()
309 def stop(self):
310 assert self.active
311 self.active = False
312 self.join()
314 def handle_accepted(self, conn, addr):
315 self.handler_instance = self.handler(conn, encoding=self.encoding)
317 def handle_connect(self):
318 self.close()
321 def writable(self):
324 def handle_error(self):
339 def secure_connection(self):
342 socket = context.wrap_socket(self.socket,
346 self.del_channel()
347 self.set_socket(socket)
348 self._ssl_accepting = True
350 def _do_ssl_handshake(self):
352 self.socket.do_handshake()
358 return self.handle_close()
361 return self.handle_close()
365 return self.handle_close()
367 self._ssl_accepting = False
369 def _do_ssl_shutdown(self):
370 self._ssl_closing = True
372 self.socket = self.socket.unwrap()
383 self._ssl_closing = False
384 if getattr(self, '_ccc', False) is False:
385 super(SSLConnection, self).close()
389 def handle_read_event(self):
390 if self._ssl_accepting:
391 self._do_ssl_handshake()
392 elif self._ssl_closing:
393 self._do_ssl_shutdown()
395 super(SSLConnection, self).handle_read_event()
397 def handle_write_event(self):
398 if self._ssl_accepting:
399 self._do_ssl_handshake()
400 elif self._ssl_closing:
401 self._do_ssl_shutdown()
403 super(SSLConnection, self).handle_write_event()
405 def send(self, data):
407 return super(SSLConnection, self).send(data)
415 def recv(self, buffer_size):
417 return super(SSLConnection, self).recv(buffer_size)
423 self.handle_close()
427 def handle_error(self):
430 def close(self):
431 if (isinstance(self.socket, ssl.SSLSocket) and
432 self.socket._sslobj is not None):
433 self._do_ssl_shutdown()
435 super(SSLConnection, self).close()
441 def __init__(self, conn, baseclass):
442 DummyDTPHandler.__init__(self, conn, baseclass)
443 if self.baseclass.secure_data_channel:
444 self.secure_connection()
452 def __init__(self, conn, encoding=DEFAULT_ENCODING):
453 DummyFTPHandler.__init__(self, conn, encoding=encoding)
454 self.secure_data_channel = False
455 self._ccc = False
457 def cmd_auth(self, line):
459 self.push('234 AUTH TLS successful')
460 self.secure_connection()
462 def cmd_ccc(self, line):
463 self.push('220 Reverting back to clear-text')
464 self._ccc = True
465 self._do_ssl_shutdown()
467 def cmd_pbsz(self, line):
472 self.push('200 PBSZ=0 successful.')
474 def cmd_prot(self, line):
478 self.push('200 Protection set to Clear')
479 self.secure_data_channel = False
481 self.push('200 Protection set to Private')
482 self.secure_data_channel = True
484 self.push("502 Unrecognized PROT type (use C or P).")
493 def setUp(self, encoding=DEFAULT_ENCODING):
494 self.server = DummyFTPServer((HOST, 0), encoding=encoding)
495 self.server.start()
496 self.client = ftplib.FTP(timeout=TIMEOUT, encoding=encoding)
497 self.client.connect(self.server.host, self.server.port)
499 def tearDown(self):
500 self.client.close()
501 self.server.stop()
503 self.server = None
506 def check_data(self, received, expected):
507 self.assertEqual(len(received), len(expected))
508 self.assertEqual(received, expected)
510 def test_getwelcome(self):
511 self.assertEqual(self.client.getwelcome(), '220 welcome')
513 def test_sanitize(self):
514 self.assertEqual(self.client.sanitize('foo'), repr('foo'))
515 self.assertEqual(self.client.sanitize('pass 12345'), repr('pass *****'))
516 self.assertEqual(self.client.sanitize('PASS 12345'), repr('PASS *****'))
518 def test_exceptions(self):
519 self.assertRaises(ValueError, self.client.sendcmd, 'echo 40\r\n0')
520 self.assertRaises(ValueError, self.client.sendcmd, 'echo 40\n0')
521 self.assertRaises(ValueError, self.client.sendcmd, 'echo 40\r0')
522 self.assertRaises(ftplib.error_temp, self.client.sendcmd, 'echo 400')
523 self.assertRaises(ftplib.error_temp, self.client.sendcmd, 'echo 499')
524 self.assertRaises(ftplib.error_perm, self.client.sendcmd, 'echo 500')
525 self.assertRaises(ftplib.error_perm, self.client.sendcmd, 'echo 599')
526 self.assertRaises(ftplib.error_proto, self.client.sendcmd, 'echo 999')
528 def test_all_errors(self):
538 def test_set_pasv(self):
540 self.assertTrue(self.client.passiveserver)
541 self.client.set_pasv(True)
542 self.assertTrue(self.client.passiveserver)
543 self.client.set_pasv(False)
544 self.assertFalse(self.client.passiveserver)
546 def test_voidcmd(self):
547 self.client.voidcmd('echo 200')
548 self.client.voidcmd('echo 299')
549 self.assertRaises(ftplib.error_reply, self.client.voidcmd, 'echo 199')
550 self.assertRaises(ftplib.error_reply, self.client.voidcmd, 'echo 300')
552 def test_login(self):
553 self.client.login()
555 def test_acct(self):
556 self.client.acct('passwd')
558 def test_rename(self):
559 self.client.rename('a', 'b')
560 self.server.handler_instance.next_response = '200'
561 self.assertRaises(ftplib.error_reply, self.client.rename, 'a', 'b')
563 def test_delete(self):
564 self.client.delete('foo')
565 self.server.handler_instance.next_response = '199'
566 self.assertRaises(ftplib.error_reply, self.client.delete, 'foo')
568 def test_size(self):
569 self.client.size('foo')
571 def test_mkd(self):
572 dir = self.client.mkd('/foo')
573 self.assertEqual(dir, '/foo')
575 def test_rmd(self):
576 self.client.rmd('foo')
578 def test_cwd(self):
579 dir = self.client.cwd('/foo')
580 self.assertEqual(dir, '250 cwd ok')
582 def test_pwd(self):
583 dir = self.client.pwd()
584 self.assertEqual(dir, 'pwd ok')
586 def test_quit(self):
587 self.assertEqual(self.client.quit(), '221 quit ok')
589 self.assertEqual(self.client.sock, None)
591 def test_abort(self):
592 self.client.abort()
594 def test_retrbinary(self):
596 received.append(data.decode(self.client.encoding))
598 self.client.retrbinary('retr', callback)
599 self.check_data(''.join(received), RETR_DATA)
601 def test_retrbinary_rest(self):
603 received.append(data.decode(self.client.encoding))
606 self.client.retrbinary('retr', callback, rest=rest)
607 self.check_data(''.join(received), RETR_DATA[rest:])
609 def test_retrlines(self):
611 self.client.retrlines('retr', received.append)
612 self.check_data(''.join(received), RETR_DATA.replace('\r\n', ''))
614 def test_storbinary(self):
615 f = io.BytesIO(RETR_DATA.encode(self.client.encoding))
616 self.client.storbinary('stor', f)
617 self.check_data(self.server.handler_instance.last_received_data, RETR_DATA)
621 self.client.storbinary('stor', f, callback=lambda x: flag.append(None))
622 self.assertTrue(flag)
624 def test_storbinary_rest(self):
625 data = RETR_DATA.replace('\r\n', '\n').encode(self.client.encoding)
629 self.client.storbinary('stor', f, rest=r)
630 self.assertEqual(self.server.handler_instance.rest, str(r))
632 def test_storlines(self):
633 data = RETR_DATA.replace('\r\n', '\n').encode(self.client.encoding)
635 self.client.storlines('stor', f)
636 self.check_data(self.server.handler_instance.last_received_data, RETR_DATA)
640 self.client.storlines('stor foo', f, callback=lambda x: flag.append(None))
641 self.assertTrue(flag)
646 self.assertRaises(TypeError, self.client.storlines, 'stor foo', f)
648 def test_nlst(self):
649 self.client.nlst()
650 self.assertEqual(self.client.nlst(), NLST_DATA.split('\r\n')[:-1])
652 def test_dir(self):
654 self.client.dir(lambda x: l.append(x))
655 self.assertEqual(''.join(l), LIST_DATA.replace('\r\n', ''))
657 def test_mlsd(self):
658 list(self.client.mlsd())
659 list(self.client.mlsd(path='/'))
660 list(self.client.mlsd(path='/', facts=['size', 'type']))
662 ls = list(self.client.mlsd())
664 self.assertIsInstance(name, str)
665 self.assertIsInstance(facts, dict)
666 self.assertTrue(name)
667 self.assertIn('type', facts)
668 self.assertIn('perm', facts)
669 self.assertIn('unique', facts)
672 self.server.handler_instance.next_data = data
680 _name, facts = next(self.client.mlsd())
681 self.assertEqual(_name, name)
682 self.assertEqual(facts['type'], type)
683 self.assertEqual(facts['perm'], perm)
684 self.assertEqual(facts['unique'], unique)
705 _name, facts = next(self.client.mlsd())
707 self.assertTrue(x.islower())
710 self.assertRaises(StopIteration, next, self.client.mlsd())
712 for x in self.client.mlsd():
713 self.fail("unexpected data %s" % x)
715 def test_makeport(self):
716 with self.client.makeport():
718 self.assertEqual(self.server.handler_instance.last_received_cmd,
721 def test_makepasv(self):
722 host, port = self.client.makepasv()
726 self.assertEqual(self.server.handler_instance.last_received_cmd, 'pasv')
728 def test_makepasv_issue43285_security_disabled(self):
730 self.client.trust_server_pasv_ipv4_address = True
731 bad_host, port = self.client.makepasv()
732 self.assertEqual(
733 bad_host, self.server.handler_instance.fake_pasv_server_ip)
736 socket.create_connection((self.client.sock.getpeername()[0], port),
739 def test_makepasv_issue43285_security_enabled_default(self):
740 self.assertFalse(self.client.trust_server_pasv_ipv4_address)
741 trusted_host, port = self.client.makepasv()
742 self.assertNotEqual(
743 trusted_host, self.server.handler_instance.fake_pasv_server_ip)
748 def test_with_statement(self):
749 self.client.quit()
752 if self.client.sock is None:
755 self.client.sendcmd('noop')
761 with ftplib.FTP(timeout=TIMEOUT) as self.client:
762 self.client.connect(self.server.host, self.server.port)
763 self.client.sendcmd('noop')
764 self.assertTrue(is_client_connected())
765 self.assertEqual(self.server.handler_instance.last_received_cmd, 'quit')
766 self.assertFalse(is_client_connected())
769 with ftplib.FTP(timeout=TIMEOUT) as self.client:
770 self.client.connect(self.server.host, self.server.port)
771 self.client.sendcmd('noop')
772 self.client.quit()
773 self.assertEqual(self.server.handler_instance.last_received_cmd, 'quit')
774 self.assertFalse(is_client_connected())
779 with ftplib.FTP(timeout=TIMEOUT) as self.client:
780 self.client.connect(self.server.host, self.server.port)
781 self.client.sendcmd('noop')
782 self.server.handler_instance.next_response = '550 error on quit'
784 self.assertEqual(str(err), '550 error on quit')
786 self.fail('Exception not raised')
790 self.assertEqual(self.server.handler_instance.last_received_cmd, 'quit')
791 self.assertFalse(is_client_connected())
793 def test_source_address(self):
794 self.client.quit()
797 self.client.connect(self.server.host, self.server.port,
799 self.assertEqual(self.client.sock.getsockname()[1], port)
800 self.client.quit()
803 self.skipTest("couldn't bind to port %d" % port)
806 def test_source_address_passive_connection(self):
808 self.client.source_address = (HOST, port)
810 with self.client.transfercmd('list') as sock:
811 self.assertEqual(sock.getsockname()[1], port)
814 self.skipTest("couldn't bind to port %d" % port)
817 def test_parse257(self):
818 self.assertEqual(ftplib.parse257('257 "/foo/bar"'), '/foo/bar')
819 self.assertEqual(ftplib.parse257('257 "/foo/bar" created'), '/foo/bar')
820 self.assertEqual(ftplib.parse257('257 ""'), '')
821 self.assertEqual(ftplib.parse257('257 "" created'), '')
822 self.assertRaises(ftplib.error_reply, ftplib.parse257, '250 "/foo/bar"')
826 self.assertEqual(ftplib.parse257('257 "/foo/b""ar"'), '/foo/b"ar')
827 self.assertEqual(ftplib.parse257('257 "/foo/b""ar" created'), '/foo/b"ar')
829 def test_line_too_long(self):
830 self.assertRaises(ftplib.Error, self.client.sendcmd,
831 'x' * self.client.maxline * 2)
833 def test_retrlines_too_long(self):
834 self.client.sendcmd('SETLONGRETR %d' % (self.client.maxline * 2))
836 self.assertRaises(ftplib.Error,
837 self.client.retrlines, 'retr', received.append)
839 def test_storlines_too_long(self):
840 f = io.BytesIO(b'x' * self.client.maxline * 2)
841 self.assertRaises(ftplib.Error, self.client.storlines, 'stor', f)
843 def test_encoding_param(self):
846 with self.subTest(encoding=encoding):
847 self.tearDown()
848 self.setUp(encoding=encoding)
849 self.assertEqual(encoding, self.client.encoding)
850 self.test_retrbinary()
851 self.test_storbinary()
852 self.test_retrlines()
853 new_dir = self.client.mkd('/non-ascii dir \xAE')
854 self.check_data(new_dir, '/non-ascii dir \xAE')
857 self.assertEqual(DEFAULT_ENCODING, client.encoding)
863 def setUp(self):
864 self.server = DummyFTPServer((HOSTv6, 0),
867 self.server.start()
868 self.client = ftplib.FTP(timeout=TIMEOUT, encoding=DEFAULT_ENCODING)
869 self.client.connect(self.server.host, self.server.port)
871 def tearDown(self):
872 self.client.close()
873 self.server.stop()
875 self.server = None
878 def test_af(self):
879 self.assertEqual(self.client.af, socket.AF_INET6)
881 def test_makeport(self):
882 with self.client.makeport():
883 self.assertEqual(self.server.handler_instance.last_received_cmd,
886 def test_makepasv(self):
887 host, port = self.client.makepasv()
890 self.assertEqual(self.server.handler_instance.last_received_cmd, 'epsv')
892 def test_transfer(self):
895 received.append(data.decode(self.client.encoding))
897 self.client.retrbinary('retr', callback)
898 self.assertEqual(len(''.join(received)), len(RETR_DATA))
899 self.assertEqual(''.join(received), RETR_DATA)
900 self.client.set_pasv(True)
902 self.client.set_pasv(False)
912 def setUp(self, encoding=DEFAULT_ENCODING):
913 self.server = DummyTLS_FTPServer((HOST, 0), encoding=encoding)
914 self.server.start()
915 self.client = ftplib.FTP_TLS(timeout=TIMEOUT, encoding=encoding)
916 self.client.connect(self.server.host, self.server.port)
918 self.client.auth()
919 self.client.prot_p()
926 def setUp(self, encoding=DEFAULT_ENCODING):
927 self.server = DummyTLS_FTPServer((HOST, 0), encoding=encoding)
928 self.server.start()
929 self.client = ftplib.FTP_TLS(timeout=TIMEOUT)
930 self.client.connect(self.server.host, self.server.port)
932 def tearDown(self):
933 self.client.close()
934 self.server.stop()
936 self.server = None
939 def test_control_connection(self):
940 self.assertNotIsInstance(self.client.sock, ssl.SSLSocket)
941 self.client.auth()
942 self.assertIsInstance(self.client.sock, ssl.SSLSocket)
944 def test_data_connection(self):
946 with self.client.transfercmd('list') as sock:
947 self.assertNotIsInstance(sock, ssl.SSLSocket)
948 self.assertEqual(sock.recv(1024),
949 LIST_DATA.encode(self.client.encoding))
950 self.assertEqual(self.client.voidresp(), "226 transfer complete")
953 self.client.prot_p()
954 with self.client.transfercmd('list') as sock:
955 self.assertIsInstance(sock, ssl.SSLSocket)
958 self.assertEqual(sock.recv(1024),
959 LIST_DATA.encode(self.client.encoding))
960 self.assertEqual(self.client.voidresp(), "226 transfer complete")
963 self.client.prot_c()
964 with self.client.transfercmd('list') as sock:
965 self.assertNotIsInstance(sock, ssl.SSLSocket)
966 self.assertEqual(sock.recv(1024),
967 LIST_DATA.encode(self.client.encoding))
968 self.assertEqual(self.client.voidresp(), "226 transfer complete")
970 def test_login(self):
972 self.assertNotIsInstance(self.client.sock, ssl.SSLSocket)
973 self.client.login()
974 self.assertIsInstance(self.client.sock, ssl.SSLSocket)
976 self.client.login()
978 def test_auth_issued_twice(self):
979 self.client.auth()
980 self.assertRaises(ValueError, self.client.auth)
982 def test_context(self):
983 self.client.quit()
987 self.assertRaises(ValueError, ftplib.FTP_TLS, keyfile=CERTFILE,
989 self.assertRaises(ValueError, ftplib.FTP_TLS, certfile=CERTFILE,
991 self.assertRaises(ValueError, ftplib.FTP_TLS, certfile=CERTFILE,
994 self.client = ftplib.FTP_TLS(context=ctx, timeout=TIMEOUT)
995 self.client.connect(self.server.host, self.server.port)
996 self.assertNotIsInstance(self.client.sock, ssl.SSLSocket)
997 self.client.auth()
998 self.assertIs(self.client.sock.context, ctx)
999 self.assertIsInstance(self.client.sock, ssl.SSLSocket)
1001 self.client.prot_p()
1002 with self.client.transfercmd('list') as sock:
1003 self.assertIs(sock.context, ctx)
1004 self.assertIsInstance(sock, ssl.SSLSocket)
1006 def test_ccc(self):
1007 self.assertRaises(ValueError, self.client.ccc)
1008 self.client.login(secure=True)
1009 self.assertIsInstance(self.client.sock, ssl.SSLSocket)
1010 self.client.ccc()
1011 self.assertRaises(ValueError, self.client.sock.unwrap)
1014 def test_check_hostname(self):
1015 self.client.quit()
1017 self.assertEqual(ctx.verify_mode, ssl.CERT_REQUIRED)
1018 self.assertEqual(ctx.check_hostname, True)
1020 self.client = ftplib.FTP_TLS(context=ctx, timeout=TIMEOUT)
1023 self.client.connect(self.server.host, self.server.port)
1024 with self.assertRaises(ssl.CertificateError):
1025 self.client.auth()
1028 self.client.connect(self.server.host, self.server.port)
1029 self.client.prot_p()
1030 with self.assertRaises(ssl.CertificateError):
1031 with self.client.transfercmd("list") as sock:
1033 self.client.quit()
1035 self.client.connect("localhost", self.server.port)
1036 self.client.auth()
1037 self.client.quit()
1039 self.client.connect("localhost", self.server.port)
1040 self.client.prot_p()
1041 with self.client.transfercmd("list") as sock:
1047 def setUp(self):
1048 self.evt = threading.Event()
1049 self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
1050 self.sock.settimeout(20)
1051 self.port = socket_helper.bind_port(self.sock)
1052 self.server_thread = threading.Thread(target=self.server)
1053 self.server_thread.daemon = True
1054 self.server_thread.start()
1056 self.evt.wait()
1057 self.evt.clear()
1058 self.old_port = ftplib.FTP.port
1059 ftplib.FTP.port = self.port
1061 def tearDown(self):
1062 ftplib.FTP.port = self.old_port
1063 self.server_thread.join()
1065 self.server_thread = None
1067 def server(self):
1072 self.sock.listen()
1074 self.evt.set()
1076 conn, addr = self.sock.accept()
1083 self.evt.set()
1086 self.sock.close()
1088 def testTimeoutDefault(self):
1090 self.assertIsNone(socket.getdefaulttimeout())
1096 self.assertEqual(ftp.sock.gettimeout(), 30)
1097 self.evt.wait()
1100 def testTimeoutNone(self):
1102 self.assertIsNone(socket.getdefaulttimeout())
1108 self.assertIsNone(ftp.sock.gettimeout())
1109 self.evt.wait()
1112 def testTimeoutValue(self):
1115 self.assertEqual(ftp.sock.gettimeout(), 30)
1116 self.evt.wait()
1120 with self.assertRaises(ValueError):
1123 def testTimeoutConnect(self):
1126 self.assertEqual(ftp.sock.gettimeout(), 30)
1127 self.evt.wait()
1130 def testTimeoutDifferentOrder(self):
1133 self.assertEqual(ftp.sock.gettimeout(), 30)
1134 self.evt.wait()
1137 def testTimeoutDirectAccess(self):
1141 self.assertEqual(ftp.sock.gettimeout(), 30)
1142 self.evt.wait()
1147 def test__all__(self):
1152 support.check__all__(self, ftplib, not_exported=not_exported)