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 A 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") 578
