• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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_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
86import os, sys, warnings
87
88try:
89    from cStringIO import StringIO
90except ImportError:
91    from StringIO import StringIO
92
93try:
94    import errno
95except ImportError:
96    errno = None
97EBADF = getattr(errno, 'EBADF', 9)
98EINTR = 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
107if 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
128def 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
160if os.name == "nt":
161    _socketmethods = _socketmethods + ('ioctl',)
162
163if 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
171class _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.
183class _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
227def meth(name,self,*args):
228    return getattr(self._sock,name)(*args)
229
230for _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
237socket = SocketType = _socketobject
238
239class _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
541def 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