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