1 | # Wrapper module for _socket, providing some additional facilities |
---|
2 | # implemented in Python. |
---|
3 | |
---|
4 | """\ |
---|
5 | This module provides socket operations and some related functions. |
---|
6 | On Unix, it supports IP (Internet Protocol) and Unix domain sockets. |
---|
7 | On other systems, it only supports IP. Functions specific for a |
---|
8 | socket are available as methods of the socket object. |
---|
9 | |
---|
10 | Functions: |
---|
11 | |
---|
12 | socket() -- create a new socket object |
---|
13 | socketpair() -- create a pair of new socket objects [*] |
---|
14 | fromfd() -- create a socket object from an open file descriptor [*] |
---|
15 | gethostname() -- return the current hostname |
---|
16 | gethostbyname() -- map a hostname to its IP number |
---|
17 | gethostbyaddr() -- map an IP number or hostname to DNS info |
---|
18 | getservbyname() -- map a service name and a protocol name to a port number |
---|
19 | getprotobyname() -- map a protocol name (e.g. 'tcp') to a number |
---|
20 | ntohs(), ntohl() -- convert 16, 32 bit int from network to host byte order |
---|
21 | htons(), htonl() -- convert 16, 32 bit int from host to network byte order |
---|
22 | inet_aton() -- convert IP addr string (123.45.67.89) to 32-bit packed format |
---|
23 | inet_ntoa() -- convert 32-bit packed format IP to string (123.45.67.89) |
---|
24 | ssl() -- secure socket layer support (only available if configured) |
---|
25 | socket.getdefaulttimeout() -- get the default timeout value |
---|
26 | socket.setdefaulttimeout() -- set the default timeout value |
---|
27 | create_connection() -- connects to an address, with an optional timeout and |
---|
28 | optional source address. |
---|
29 | |
---|
30 | [*] not available on all platforms! |
---|
31 | |
---|
32 | Special objects: |
---|
33 | |
---|
34 | SocketType -- type object for socket objects |
---|
35 | error -- exception raised for I/O errors |
---|
36 | has_ipv6 -- boolean value indicating if IPv6 is supported |
---|
37 | |
---|
38 | Integer constants: |
---|
39 | |
---|
40 | AF_INET, AF_UNIX -- socket domains (first argument to socket() call) |
---|
41 | SOCK_STREAM, SOCK_DGRAM, SOCK_RAW -- socket types (second argument) |
---|
42 | |
---|
43 | Many other constants may be defined; these may be used in calls to |
---|
44 | the setsockopt() and getsockopt() methods. |
---|
45 | """ |
---|
46 | |
---|
47 | import _socket |
---|
48 | from _socket import * |
---|
49 | from functools import partial |
---|
50 | from types import MethodType |
---|
51 | |
---|
52 | try: |
---|
53 | import _ssl |
---|
54 | except ImportError: |
---|
55 | # no SSL support |
---|
56 | pass |
---|
57 | else: |
---|
58 | def ssl(sock, keyfile=None, certfile=None): |
---|
59 | # we do an internal import here because the ssl |
---|
60 | # module imports the socket module |
---|
61 | import ssl as _realssl |
---|
62 | warnings.warn("socket.ssl() is deprecated. Use ssl.wrap_socket() instead.", |
---|
63 | DeprecationWarning, stacklevel=2) |
---|
64 | return _realssl.sslwrap_simple(sock, keyfile, certfile) |
---|
65 | |
---|
66 | # we need to import the same constants we used to... |
---|
67 | from _ssl import SSLError as sslerror |
---|
68 | from _ssl import \ |
---|
69 | RAND_add, \ |
---|
70 | RAND_status, \ |
---|
71 | SSL_ERROR_ZERO_RETURN, \ |
---|
72 | SSL_ERROR_WANT_READ, \ |
---|
73 | SSL_ERROR_WANT_WRITE, \ |
---|
74 | SSL_ERROR_WANT_X509_LOOKUP, \ |
---|
75 | SSL_ERROR_SYSCALL, \ |
---|
76 | SSL_ERROR_SSL, \ |
---|
77 | SSL_ERROR_WANT_CONNECT, \ |
---|
78 | SSL_ERROR_EOF, \ |
---|
79 | SSL_ERROR_INVALID_ERROR_CODE |
---|
80 | try: |
---|
81 | from _ssl import RAND_egd |
---|
82 | except ImportError: |
---|
83 | # LibreSSL does not provide RAND_egd |
---|
84 | pass |
---|
85 | |
---|
86 | import os, sys, warnings |
---|
87 | |
---|
88 | try: |
---|
89 | from cStringIO import StringIO |
---|
90 | except ImportError: |
---|
91 | from StringIO import StringIO |
---|
92 | |
---|
93 | try: |
---|
94 | import errno |
---|
95 | except ImportError: |
---|
96 | errno = None |
---|
97 | EBADF = getattr(errno, 'EBADF', 9) |
---|
98 | EINTR = getattr(errno, 'EINTR', 4) |
---|
99 | |
---|
100 | __all__ = ["getfqdn", "create_connection"] |
---|
101 | __all__.extend(os._get_exports_list(_socket)) |
---|
102 | |
---|
103 | |
---|
104 | _realsocket = socket |
---|
105 | |
---|
106 | # WSA error codes |
---|
107 | if sys.platform.lower().startswith("win"): |
---|
108 | errorTab = {} |
---|
109 | errorTab[10004] = "The operation was interrupted." |
---|
110 | errorTab[10009] = "A bad file handle was passed." |
---|
111 | errorTab[10013] = "Permission denied." |
---|
112 | errorTab[10014] = "A fault occurred on the network??" # WSAEFAULT |
---|
113 | errorTab[10022] = "An invalid operation was attempted." |
---|
114 | errorTab[10035] = "The socket operation would block" |
---|
115 | errorTab[10036] = "A blocking operation is already in progress." |
---|
116 | errorTab[10048] = "The network address is in use." |
---|
117 | errorTab[10054] = "The connection has been reset." |
---|
118 | errorTab[10058] = "The network has been shut down." |
---|
119 | errorTab[10060] = "The operation timed out." |
---|
120 | errorTab[10061] = "Connection refused." |
---|
121 | errorTab[10063] = "The name is too long." |
---|
122 | errorTab[10064] = "The host is down." |
---|
123 | errorTab[10065] = "The host is unreachable." |
---|
124 | __all__.append("errorTab") |
---|
125 | |
---|
126 | |
---|
127 | |
---|
128 | def getfqdn(name=''): |
---|
129 | """Get fully qualified domain name from name. |
---|
130 | |
---|
131 | An empty argument is interpreted as meaning the local host. |
---|
132 | |
---|
133 | First the hostname returned by gethostbyaddr() is checked, then |
---|
134 | possibly existing aliases. In case no FQDN is available, hostname |
---|
135 | from gethostname() is returned. |
---|
136 | """ |
---|
137 | name = name.strip() |
---|
138 | if not name or name == '0.0.0.0': |
---|
139 | name = gethostname() |
---|
140 | try: |
---|
141 | hostname, aliases, ipaddrs = gethostbyaddr(name) |
---|
142 | except error: |
---|
143 | pass |
---|
144 | else: |
---|
145 | aliases.insert(0, hostname) |
---|
146 | for name in aliases: |
---|
147 | if '.' in name: |
---|
148 | break |
---|
149 | else: |
---|
150 | name = hostname |
---|
151 | return name |
---|
152 | |
---|
153 | |
---|
154 | _socketmethods = ( |
---|
155 | 'bind', 'connect', 'connect_ex', 'fileno', 'listen', |
---|
156 | 'getpeername', 'getsockname', 'getsockopt', 'setsockopt', |
---|
157 | 'sendall', 'setblocking', |
---|
158 | 'settimeout', 'gettimeout', 'shutdown') |
---|
159 | |
---|
160 | if os.name == "nt": |
---|
161 | _socketmethods = _socketmethods + ('ioctl',) |
---|
162 | |
---|
163 | if sys.platform == "riscos": |
---|
164 | _socketmethods = _socketmethods + ('sleeptaskw',) |
---|
165 | |
---|
166 | # All the method names that must be delegated to either the real socket |
---|
167 | # object or the _closedsocket object. |
---|
168 | _delegate_methods = ("recv", "recvfrom", "recv_into", "recvfrom_into", |
---|
169 | "send", "sendto") |
---|
170 | |
---|
171 | class _closedsocket(object): |
---|
172 | __slots__ = [] |
---|
173 | def _dummy(*args): |
---|
174 | raise error(EBADF, 'Bad file descriptor') |
---|
175 | # All _delegate_methods must also be initialized here. |
---|
176 | send = recv = recv_into = sendto = recvfrom = recvfrom_into = _dummy |
---|
177 | __getattr__ = _dummy |
---|
178 | |
---|
179 | # Wrapper around platform socket objects. This implements |
---|
180 | # a platform-independent dup() functionality. The |
---|
181 | # implementation currently relies on reference counting |
---|
182 | # to close the underlying socket object. |
---|
183 | class _socketobject(object): |
---|
184 | |
---|
185 | __doc__ = _realsocket.__doc__ |
---|
186 | |
---|
187 | __slots__ = ["_sock", "__weakref__"] + list(_delegate_methods) |
---|
188 | |
---|
189 | def __init__(self, family=AF_INET, type=SOCK_STREAM, proto=0, _sock=None): |
---|
190 | if _sock is None: |
---|
191 | _sock = _realsocket(family, type, proto) |
---|
192 | self._sock = _sock |
---|
193 | for method in _delegate_methods: |
---|
194 | setattr(self, method, getattr(_sock, method)) |
---|
195 | |
---|
196 | def close(self, _closedsocket=_closedsocket, |
---|
197 | _delegate_methods=_delegate_methods, setattr=setattr): |
---|
198 | # This function should not reference any globals. See issue #808164. |
---|
199 | self._sock = _closedsocket() |
---|
200 | dummy = self._sock._dummy |
---|
201 | for method in _delegate_methods: |
---|
202 | setattr(self, method, dummy) |
---|
203 | close.__doc__ = _realsocket.close.__doc__ |
---|
204 | |
---|
205 | def accept(self): |
---|
206 | sock, addr = self._sock.accept() |
---|
207 | return _socketobject(_sock=sock), addr |
---|
208 | accept.__doc__ = _realsocket.accept.__doc__ |
---|
209 | |
---|
210 | def dup(self): |
---|
211 | """dup() -> socket object |
---|
212 | |
---|
213 | Return a new socket object connected to the same system resource.""" |
---|
214 | return _socketobject(_sock=self._sock) |
---|
215 | |
---|
216 | def makefile(self, mode='r', bufsize=-1): |
---|
217 | """makefile([mode[, bufsize]]) -> file object |
---|
218 | |
---|
219 | Return a regular file object corresponding to the socket. The mode |
---|
220 | and bufsize arguments are as for the built-in open() function.""" |
---|
221 | return _fileobject(self._sock, mode, bufsize) |
---|
222 | |
---|
223 | family = property(lambda self: self._sock.family, doc="the socket family") |
---|
224 | type = property(lambda self: self._sock.type, doc="the socket type") |
---|
225 | proto = property(lambda self: self._sock.proto, doc="the socket protocol") |
---|
226 | |
---|
227 | def meth(name,self,*args): |
---|
228 | return getattr(self._sock,name)(*args) |
---|
229 | |
---|
230 | for _m in _socketmethods: |
---|
231 | p = partial(meth,_m) |
---|
232 | p.__name__ = _m |
---|
233 | p.__doc__ = getattr(_realsocket,_m).__doc__ |
---|
234 | m = MethodType(p,None,_socketobject) |
---|
235 | setattr(_socketobject,_m,m) |
---|
236 | |
---|
237 | socket = SocketType = _socketobject |
---|
238 | |
---|
239 | class _fileobject(object): |
---|
240 | """Faux file object attached to a socket object.""" |
---|
241 | |
---|
242 | default_bufsize = 8192 |
---|
243 | name = "<socket>" |
---|
244 | |
---|
245 | __slots__ = ["mode", "bufsize", "softspace", |
---|
246 | # "closed" is a property, see below |
---|
247 | "_sock", "_rbufsize", "_wbufsize", "_rbuf", "_wbuf", "_wbuf_len", |
---|
248 | "_close"] |
---|
249 | |
---|
250 | def __init__(self, sock, mode='rb', bufsize=-1, close=False): |
---|
251 | self._sock = sock |
---|
252 | self.mode = mode # Not actually used in this version |
---|
253 | if bufsize < 0: |
---|
254 | bufsize = self.default_bufsize |
---|
255 | self.bufsize = bufsize |
---|
256 | self.softspace = False |
---|
257 | # _rbufsize is the suggested recv buffer size. It is *strictly* |
---|
258 | # obeyed within readline() for recv calls. If it is larger than |
---|
259 | # default_bufsize it will be used for recv calls within read(). |
---|
260 | if bufsize == 0: |
---|
261 | self._rbufsize = 1 |
---|
262 | elif bufsize == 1: |
---|
263 | self._rbufsize = self.default_bufsize |
---|
264 | else: |
---|
265 | self._rbufsize = bufsize |
---|
266 | self._wbufsize = bufsize |
---|
267 | # We use StringIO for the read buffer to avoid holding a list |
---|
268 | # of variously sized string objects which have been known to |
---|
269 | # fragment the heap due to how they are malloc()ed and often |
---|
270 | # realloc()ed down much smaller than their original allocation. |
---|
271 | self._rbuf = StringIO() |
---|
272 | self._wbuf = [] # A list of strings |
---|
273 | self._wbuf_len = 0 |
---|
274 | self._close = close |
---|
275 | |
---|
276 | def _getclosed(self): |
---|
277 | return self._sock is None |
---|
278 | closed = property(_getclosed, doc="True if the file is closed") |
---|
279 | |
---|
280 | def close(self): |
---|
281 | try: |
---|
282 | if self._sock: |
---|
283 | self.flush() |
---|
284 | finally: |
---|
285 | if self._close: |
---|
286 | self._sock.close() |
---|
287 | self._sock = None |
---|
288 | |
---|
289 | def __del__(self): |
---|
290 | try: |
---|
291 | self.close() |
---|
292 | except: |
---|
293 | # close() may fail if __init__ didn't complete |
---|
294 | pass |
---|
295 | |
---|
296 | def flush(self): |
---|
297 | if self._wbuf: |
---|
298 | data = "".join(self._wbuf) |
---|
299 | self._wbuf = [] |
---|
300 | self._wbuf_len = 0 |
---|
301 | buffer_size = max(self._rbufsize, self.default_bufsize) |
---|
302 | data_size = len(data) |
---|
303 | write_offset = 0 |
---|
304 | view = memoryview(data) |
---|
305 | try: |
---|
306 | while write_offset < data_size: |
---|
307 | self._sock.sendall(view[write_offset:write_offset+buffer_size]) |
---|
308 | write_offset += buffer_size |
---|
309 | finally: |
---|
310 | if write_offset < data_size: |
---|
311 | remainder = data[write_offset:] |
---|
312 | del view, data # explicit free |
---|
313 | self._wbuf.append(remainder) |
---|
314 | self._wbuf_len = len(remainder) |
---|
315 | |
---|
316 | def fileno(self): |
---|
317 | return self._sock.fileno() |
---|
318 | |
---|
319 | def write(self, data): |
---|
320 | data = str(data) # XXX Should really reject non-string non-buffers |
---|
321 | if not data: |
---|
322 | return |
---|
323 | self._wbuf.append(data) |
---|
324 | self._wbuf_len += len(data) |
---|
325 | if (self._wbufsize == 0 or |
---|
326 | (self._wbufsize == 1 and '\n' in data) or |
---|
327 | (self._wbufsize > 1 and self._wbuf_len >= self._wbufsize)): |
---|
328 | self.flush() |
---|
329 | |
---|
330 | def writelines(self, list): |
---|
331 | # XXX We could do better here for very long lists |
---|
332 | # XXX Should really reject non-string non-buffers |
---|
333 | lines = filter(None, map(str, list)) |
---|
334 | self._wbuf_len += sum(map(len, lines)) |
---|
335 | self._wbuf.extend(lines) |
---|
336 | if (self._wbufsize <= 1 or |
---|
337 | self._wbuf_len >= self._wbufsize): |
---|
338 | self.flush() |
---|
339 | |
---|
340 | def read(self, size=-1): |
---|
341 | # Use max, disallow tiny reads in a loop as they are very inefficient. |
---|
342 | # We never leave read() with any leftover data from a new recv() call |
---|
343 | # in our internal buffer. |
---|
344 | rbufsize = max(self._rbufsize, self.default_bufsize) |
---|
345 | # Our use of StringIO rather than lists of string objects returned by |
---|
346 | # recv() minimizes memory usage and fragmentation that occurs when |
---|
347 | # rbufsize is large compared to the typical return value of recv(). |
---|
348 | buf = self._rbuf |
---|
349 | buf.seek(0, 2) # seek end |
---|
350 | if size < 0: |
---|
351 | # Read until EOF |
---|
352 | self._rbuf = StringIO() # reset _rbuf. we consume it via buf. |
---|
353 | while True: |
---|
354 | try: |
---|
355 | data = self._sock.recv(rbufsize) |
---|
356 | except error, e: |
---|
357 | if e.args[0] == EINTR: |
---|
358 | continue |
---|
359 | raise |
---|
360 | if not data: |
---|
361 | break |
---|
362 | buf.write(data) |
---|
363 | return buf.getvalue() |
---|
364 | else: |
---|
365 | # Read until size bytes or EOF seen, whichever comes first |
---|
366 | buf_len = buf.tell() |
---|
367 | if buf_len >= size: |
---|
368 | # Already have size bytes in our buffer? Extract and return. |
---|
369 | buf.seek(0) |
---|
370 | rv = buf.read(size) |
---|
371 | self._rbuf = StringIO() |
---|
372 | self._rbuf.write(buf.read()) |
---|
373 | return rv |
---|
374 | |
---|
375 | self._rbuf = StringIO() # reset _rbuf. we consume it via buf. |
---|
376 | while True: |
---|
377 | left = size - buf_len |
---|
378 | # recv() will malloc the amount of memory given as its |
---|
379 | # parameter even though it often returns much less data |
---|
380 | # than that. The returned data string is short lived |
---|
381 | # as we copy it into a StringIO and free it. This avoids |
---|
382 | # fragmentation issues on many platforms. |
---|
383 | try: |
---|
384 | data = self._sock.recv(left) |
---|
385 | except error, e: |
---|
386 | if e.args[0] == EINTR: |
---|
387 | continue |
---|
388 | raise |
---|
389 | if not data: |
---|
390 | break |
---|
391 | n = len(data) |
---|
392 | if n == size and not buf_len: |
---|
393 | # Shortcut. Avoid buffer data copies when: |
---|
394 | # - We have no data in our buffer. |
---|
395 | # AND |
---|
396 | # - Our call to recv returned exactly the |
---|
397 | # number of bytes we were asked to read. |
---|
398 | return data |
---|
399 | if n == left: |
---|
400 | buf.write(data) |
---|
401 | del data # explicit free |
---|
402 | break |
---|
403 | assert n <= left, "recv(%d) returned %d bytes" % (left, n) |
---|
404 | buf.write(data) |
---|
405 | buf_len += n |
---|
406 | del data # explicit free |
---|
407 | #assert buf_len == buf.tell() |
---|
408 | return buf.getvalue() |
---|
409 | |
---|
410 | def readline(self, size=-1): |
---|
411 | buf = self._rbuf |
---|
412 | buf.seek(0, 2) # seek end |
---|
413 | if buf.tell() > 0: |
---|
414 | # check if we already have it in our buffer |
---|
415 | buf.seek(0) |
---|
416 | bline = buf.readline(size) |
---|
417 | if bline.endswith('\n') or len(bline) == size: |
---|
418 | self._rbuf = StringIO() |
---|
419 | self._rbuf.write(buf.read()) |
---|
420 | return bline |
---|
421 | del bline |
---|
422 | if size < 0: |
---|
423 | # Read until \n or EOF, whichever comes first |
---|
424 | if self._rbufsize <= 1: |
---|
425 | # Speed up unbuffered case |
---|
426 | buf.seek(0) |
---|
427 | buffers = [buf.read()] |
---|
428 | self._rbuf = StringIO() # reset _rbuf. we consume it via buf. |
---|
429 | data = None |
---|
430 | recv = self._sock.recv |
---|
431 | while True: |
---|
432 | try: |
---|
433 | while data != "\n": |
---|
434 | data = recv(1) |
---|
435 | if not data: |
---|
436 | break |
---|
437 | buffers.append(data) |
---|
438 | except error, e: |
---|
439 | # The try..except to catch EINTR was moved outside the |
---|
440 | # recv loop to avoid the per byte overhead. |
---|
441 | if e.args[0] == EINTR: |
---|
442 | continue |
---|
443 | raise |
---|
444 | break |
---|
445 | return "".join(buffers) |
---|
446 | |
---|
447 | buf.seek(0, 2) # seek end |
---|
448 | self._rbuf = StringIO() # reset _rbuf. we consume it via buf. |
---|
449 | while True: |
---|
450 | try: |
---|
451 | data = self._sock.recv(self._rbufsize) |
---|
452 | except error, e: |
---|
453 | if e.args[0] == EINTR: |
---|
454 | continue |
---|
455 | raise |
---|
456 | if not data: |
---|
457 | break |
---|
458 | nl = data.find('\n') |
---|
459 | if nl >= 0: |
---|
460 | nl += 1 |
---|
461 | buf.write(data[:nl]) |
---|
462 | self._rbuf.write(data[nl:]) |
---|
463 | del data |
---|
464 | break |
---|
465 | buf.write(data) |
---|
466 | return buf.getvalue() |
---|
467 | else: |
---|
468 | # Read until size bytes or \n or EOF seen, whichever comes first |
---|
469 | buf.seek(0, 2) # seek end |
---|
470 | buf_len = buf.tell() |
---|
471 | if buf_len >= size: |
---|
472 | buf.seek(0) |
---|
473 | rv = buf.read(size) |
---|
474 | self._rbuf = StringIO() |
---|
475 | self._rbuf.write(buf.read()) |
---|
476 | return rv |
---|
477 | self._rbuf = StringIO() # reset _rbuf. we consume it via buf. |
---|
478 | while True: |
---|
479 | try: |
---|
480 | data = self._sock.recv(self._rbufsize) |
---|
481 | except error, e: |
---|
482 | if e.args[0] == EINTR: |
---|
483 | continue |
---|
484 | raise |
---|
485 | if not data: |
---|
486 | break |
---|
487 | left = size - buf_len |
---|
488 | # did we just receive a newline? |
---|
489 | nl = data.find('\n', 0, left) |
---|
490 | if nl >= 0: |
---|
491 | nl += 1 |
---|
492 | # save the excess data to _rbuf |
---|
493 | self._rbuf.write(data[nl:]) |
---|
494 | if buf_len: |
---|
495 | buf.write(data[:nl]) |
---|
496 | break |
---|
497 | else: |
---|
498 | # Shortcut. Avoid data copy through buf when returning |
---|
499 | # a substring of our first recv(). |
---|
500 | return data[:nl] |
---|
501 | n = len(data) |
---|
502 | if n == size and not buf_len: |
---|
503 | # Shortcut. Avoid data copy through buf when |
---|
504 | # returning exactly all of our first recv(). |
---|
505 | return data |
---|
506 | if n >= left: |
---|
507 | buf.write(data[:left]) |
---|
508 | self._rbuf.write(data[left:]) |
---|
509 | break |
---|
510 | buf.write(data) |
---|
511 | buf_len += n |
---|
512 | #assert buf_len == buf.tell() |
---|
513 | return buf.getvalue() |
---|
514 | |
---|
515 | def readlines(self, sizehint=0): |
---|
516 | total = 0 |
---|
517 | list = [] |
---|
518 | while True: |
---|
519 | line = self.readline() |
---|
520 | if not line: |
---|
521 | break |
---|
522 | list.append(line) |
---|
523 | total += len(line) |
---|
524 | if sizehint and total >= sizehint: |
---|
525 | break |
---|
526 | return list |
---|
527 | |
---|
528 | # Iterator protocols |
---|
529 | |
---|
530 | def __iter__(self): |
---|
531 | return self |
---|
532 | |
---|
533 | def next(self): |
---|
534 | line = self.readline() |
---|
535 | if not line: |
---|
536 | raise StopIteration |
---|
537 | return line |
---|
538 | |
---|
539 | _GLOBAL_DEFAULT_TIMEOUT = object() |
---|
540 | |
---|
541 | def create_connection(address, timeout=_GLOBAL_DEFAULT_TIMEOUT, |
---|
542 | source_address=None): |
---|
543 | """Connect to *address* and return the socket object. |
---|
544 | |
---|
545 | Convenience function. Connect to *address* (a 2-tuple ``(host, |
---|
546 | port)``) and return the socket object. Passing the optional |
---|
547 | *timeout* parameter will set the timeout on the socket instance |
---|
548 | before attempting to connect. If no *timeout* is supplied, the |
---|
549 | global default timeout setting returned by :func:`getdefaulttimeout` |
---|
550 | is used. If *source_address* is set it must be a tuple of (host, port) |
---|
551 | for the socket to bind as a source address before making the connection. |
---|
552 | An host of '' or port 0 tells the OS to use the default. |
---|
553 | """ |
---|
554 | |
---|
555 | host, port = address |
---|
556 | err = None |
---|
557 | for res in getaddrinfo(host, port, 0, SOCK_STREAM): |
---|
558 | af, socktype, proto, canonname, sa = res |
---|
559 | sock = None |
---|
560 | try: |
---|
561 | sock = socket(af, socktype, proto) |
---|
562 | if timeout is not _GLOBAL_DEFAULT_TIMEOUT: |
---|
563 | sock.settimeout(timeout) |
---|
564 | if source_address: |
---|
565 | sock.bind(source_address) |
---|
566 | sock.connect(sa) |
---|
567 | return sock |
---|
568 | |
---|
569 | except error as _: |
---|
570 | err = _ |
---|
571 | if sock is not None: |
---|
572 | sock.close() |
---|
573 | |
---|
574 | if err is not None: |
---|
575 | raise err |
---|
576 | else: |
---|
577 | raise error("getaddrinfo returns an empty list") |
---|