1# Wrapper module for _socket, providing some additional facilities
2# implemented in Python.
3
4"""\
5This module provides socket operations and some related functions.
6On Unix, it supports IP (Internet Protocol) and Unix domain sockets.
7On other systems, it only supports IP. Functions specific for a
8socket are available as methods of the socket object.
9
10Functions:
11
12socket() -- create a new socket object
13socketpair() -- create a pair of new socket objects [*]
14fromfd() -- create a socket object from an open file descriptor [*]
15gethostname() -- return the current hostname
16gethostbyname() -- map a hostname to its IP number
17gethostbyaddr() -- map an IP number or hostname to DNS info
18getservbyname() -- map a service name and a protocol name to a port number
19getprotobyname() -- map a protocol name (e.g. 'tcp') to a number
20ntohs(), ntohl() -- convert 16, 32 bit int from network to host byte order
21htons(), htonl() -- convert 16, 32 bit int from host to network byte order
22inet_aton() -- convert IP addr string (123.45.67.89) to 32-bit packed format
23inet_ntoa() -- convert 32-bit packed format IP to string (123.45.67.89)
24ssl() -- secure socket layer support (only available if configured)
25socket.getdefaulttimeout() -- get the default timeout value
26socket.setdefaulttimeout() -- set the default timeout value
27create_connection() -- connects to an address, with an optional timeout and
28                       optional source address.
29
30 [*] not available on all platforms!
31
32Special objects:
33
34SocketType -- type object for socket objects
35error -- exception raised for I/O errors
36has_ipv6 -- boolean value indicating if IPv6 is supported
37
38Integer constants:
39
40AF_INET, AF_UNIX -- socket domains (first argument to socket() call)
41SOCK_STREAM, SOCK_DGRAM, SOCK_RAW -- socket types (second argument)
42
43Many other constants may be defined; these may be used in calls to
44the setsockopt() and getsockopt() methods.
45"""
46
47import _socket
48from _socket import *
49from functools import partial
50from types import MethodType
51
52try:
53    import _ssl
54except ImportError:
55    # no SSL support
56    pass
57else:
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
82import os, sys, warnings
83
84try:
85    from cStringIO import StringIO
86except ImportError:
87    from StringIO import StringIO
88
89try:
90    import errno
91except ImportError:
92    errno = None
93EBADF = getattr(errno, 'EBADF', 9)
94EINTR = 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
103if 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
124def 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
156if os.name == "nt":
157    _socketmethods = _socketmethods + ('ioctl',)
158
159if 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
167class _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.
179class _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
223def meth(name,self,*args):
224    return getattr(self._sock,name)(*args)
225
226for _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
233socket = SocketType = _socketobject
234
235class _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
537def 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