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