| #!/usr/bin/env python |
| # |
| # Copyright 2007 Google Inc. |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| # |
| |
| |
| |
| |
| |
| |
| |
| """\ |
| This module provides socket operations and some related functions. |
| On Unix, it supports IP (Internet Protocol) and Unix domain sockets. |
| On other systems, it only supports IP. Functions specific for a |
| socket are available as methods of the socket object. |
| |
| Functions: |
| |
| socket() -- create a new socket object |
| socketpair() -- create a pair of new socket objects [*] |
| fromfd() -- create a socket object from an open file descriptor [*] |
| gethostname() -- return the current hostname |
| gethostbyname() -- map a hostname to its IP number |
| gethostbyaddr() -- map an IP number or hostname to DNS info |
| getservbyname() -- map a service name and a protocol name to a port number |
| getprotobyname() -- mape a protocol name (e.g. 'tcp') to a number |
| ntohs(), ntohl() -- convert 16, 32 bit int from network to host byte order |
| htons(), htonl() -- convert 16, 32 bit int from host to network byte order |
| inet_aton() -- convert IP addr string (123.45.67.89) to 32-bit packed format |
| inet_ntoa() -- convert 32-bit packed format IP to string (123.45.67.89) |
| ssl() -- secure socket layer support (only available if configured) |
| socket.getdefaulttimeout() -- get the default timeout value |
| socket.setdefaulttimeout() -- set the default timeout value |
| |
| [*] not available on all platforms! |
| |
| Special objects: |
| |
| SocketType -- type object for socket objects |
| error -- exception raised for I/O errors |
| has_ipv6 -- boolean value indicating if IPv6 is supported |
| |
| Integer constants: |
| |
| AF_INET, AF_UNIX -- socket domains (first argument to socket() call) |
| SOCK_STREAM, SOCK_DGRAM, SOCK_RAW -- socket types (second argument) |
| |
| Many other constants may be defined; these may be used in calls to |
| the setsockopt() and getsockopt() methods. |
| """ |
| |
| |
| from google.appengine.api.remote_socket import _remote_socket as _socket |
| from google.appengine.api.remote_socket._remote_socket import * |
| |
| import os, sys |
| |
| try: |
| from errno import EBADF |
| except ImportError: |
| EBADF = 9 |
| |
| __all__ = ["getfqdn"] |
| __all__.extend(os._get_exports_list(_socket)) |
| |
| _realsocket = socket |
| |
| |
| if sys.platform.lower().startswith("win"): |
| errorTab = {} |
| errorTab[10004] = "The operation was interrupted." |
| errorTab[10009] = "A bad file handle was passed." |
| errorTab[10013] = "Permission denied." |
| errorTab[10014] = "A fault occurred on the network??" |
| errorTab[10022] = "An invalid operation was attempted." |
| errorTab[10035] = "The socket operation would block" |
| errorTab[10036] = "A blocking operation is already in progress." |
| errorTab[10048] = "The network address is in use." |
| errorTab[10054] = "The connection has been reset." |
| errorTab[10058] = "The network has been shut down." |
| errorTab[10060] = "The operation timed out." |
| errorTab[10061] = "Connection refused." |
| errorTab[10063] = "The name is too long." |
| errorTab[10064] = "The host is down." |
| errorTab[10065] = "The host is unreachable." |
| __all__.append("errorTab") |
| |
| |
| |
| def getfqdn(name=''): |
| """Get fully qualified domain name from name. |
| |
| An empty argument is interpreted as meaning the local host. |
| |
| First the hostname returned by gethostbyaddr() is checked, then |
| possibly existing aliases. In case no FQDN is available, hostname |
| from gethostname() is returned. |
| """ |
| name = name.strip() |
| if not name or name == '0.0.0.0': |
| name = gethostname() |
| try: |
| hostname, aliases, ipaddrs = gethostbyaddr(name) |
| except error: |
| pass |
| else: |
| aliases.insert(0, hostname) |
| for name in aliases: |
| if '.' in name: |
| break |
| else: |
| name = hostname |
| return name |
| |
| |
| _socketmethods = ( |
| 'bind', 'connect', 'connect_ex', 'fileno', 'listen', |
| 'getpeername', 'getsockname', 'getsockopt', 'setsockopt', |
| 'sendall', 'setblocking', |
| 'settimeout', 'gettimeout', 'shutdown') |
| |
| |
| |
| _delegate_methods = ("recv", "recvfrom", "recv_into", "recvfrom_into", |
| "send", "sendto") |
| |
| class _closedsocket(object): |
| __slots__ = [] |
| def _dummy(*args): |
| raise error(EBADF, 'Bad file descriptor') |
| |
| send = recv = recv_into = sendto = recvfrom = recvfrom_into = _dummy |
| __getattr__ = _dummy |
| |
| class _socketobject(object): |
| |
| __doc__ = _realsocket.__doc__ |
| |
| __slots__ = ["_sock", "__weakref__"] + list(_delegate_methods) |
| |
| |
| def __getstate__(self): |
| if isinstance(self._sock, _closedsocket): |
| return None |
| return self._sock |
| |
| |
| def __setstate__(self, _sock): |
| if _sock is None: |
| _sock = _closedsocket() |
| self.__init__(_sock=_sock) |
| |
| def __init__(self, family=AF_INET, type=SOCK_STREAM, proto=0, _sock=None): |
| if _sock is None: |
| _sock = _realsocket(family, type, proto) |
| self._sock = _sock |
| for method in _delegate_methods: |
| setattr(self, method, getattr(_sock, method)) |
| |
| def close(self): |
| |
| |
| |
| |
| if isinstance(self._sock, _realsocket): |
| self._sock.close() |
| self._sock = _closedsocket() |
| dummy = self._sock._dummy |
| for method in _delegate_methods: |
| setattr(self, method, dummy) |
| close.__doc__ = _realsocket.close.__doc__ |
| |
| def accept(self): |
| sock, addr = self._sock.accept() |
| return _socketobject(_sock=sock), addr |
| accept.__doc__ = _realsocket.accept.__doc__ |
| |
| def dup(self): |
| """dup() -> socket object |
| |
| Return a new socket object connected to the same system resource.""" |
| return _socketobject(_sock=self._sock) |
| |
| def makefile(self, mode='r', bufsize=-1): |
| """makefile([mode[, bufsize]]) -> file object |
| |
| Return a regular file object corresponding to the socket. The mode |
| and bufsize arguments are as for the built-in open() function.""" |
| return _fileobject(self._sock, mode, bufsize) |
| |
| family = property(lambda self: self._sock.family, doc="the socket family") |
| type = property(lambda self: self._sock.type, doc="the socket type") |
| proto = property(lambda self: self._sock.proto, doc="the socket protocol") |
| |
| _s = ("def %s(self, *args): return self._sock.%s(*args)\n\n" |
| "%s.__doc__ = _realsocket.%s.__doc__\n") |
| for _m in _socketmethods: |
| exec _s % (_m, _m, _m, _m) |
| del _m, _s |
| |
| socket = SocketType = _socketobject |
| |
| class _fileobject(object): |
| """Faux file object attached to a socket object.""" |
| |
| default_bufsize = 8192 |
| name = "<socket>" |
| |
| __slots__ = ["mode", "bufsize", "softspace", |
| |
| "_sock", "_rbufsize", "_wbufsize", "_rbuf", "_wbuf", |
| "_close"] |
| |
| def __init__(self, sock, mode='rb', bufsize=-1, close=False): |
| self._sock = sock |
| self.mode = mode |
| if bufsize < 0: |
| bufsize = self.default_bufsize |
| self.bufsize = bufsize |
| self.softspace = False |
| if bufsize == 0: |
| self._rbufsize = 1 |
| elif bufsize == 1: |
| self._rbufsize = self.default_bufsize |
| else: |
| self._rbufsize = bufsize |
| self._wbufsize = bufsize |
| self._rbuf = "" |
| self._wbuf = [] |
| self._close = close |
| |
| def _getclosed(self): |
| return self._sock is None |
| closed = property(_getclosed, doc="True if the file is closed") |
| |
| def close(self): |
| try: |
| if self._sock: |
| self.flush() |
| finally: |
| if self._close: |
| self._sock.close() |
| self._sock = None |
| |
| def __del__(self): |
| try: |
| self.close() |
| except: |
| |
| pass |
| |
| def flush(self): |
| if self._wbuf: |
| buffer = "".join(self._wbuf) |
| self._wbuf = [] |
| self._sock.sendall(buffer) |
| |
| def fileno(self): |
| return self._sock.fileno() |
| |
| def write(self, data): |
| data = str(data) |
| if not data: |
| return |
| self._wbuf.append(data) |
| if (self._wbufsize == 0 or |
| self._wbufsize == 1 and '\n' in data or |
| self._get_wbuf_len() >= self._wbufsize): |
| self.flush() |
| |
| def writelines(self, list): |
| |
| |
| self._wbuf.extend(filter(None, map(str, list))) |
| if (self._wbufsize <= 1 or |
| self._get_wbuf_len() >= self._wbufsize): |
| self.flush() |
| |
| def _get_wbuf_len(self): |
| buf_len = 0 |
| for x in self._wbuf: |
| buf_len += len(x) |
| return buf_len |
| |
| def read(self, size=-1): |
| data = self._rbuf |
| if size < 0: |
| |
| buffers = [] |
| if data: |
| buffers.append(data) |
| self._rbuf = "" |
| if self._rbufsize <= 1: |
| recv_size = self.default_bufsize |
| else: |
| recv_size = self._rbufsize |
| while True: |
| data = self._sock.recv(recv_size) |
| if not data: |
| break |
| buffers.append(data) |
| return "".join(buffers) |
| else: |
| |
| buf_len = len(data) |
| if buf_len >= size: |
| self._rbuf = data[size:] |
| return data[:size] |
| buffers = [] |
| if data: |
| buffers.append(data) |
| self._rbuf = "" |
| while True: |
| left = size - buf_len |
| recv_size = max(self._rbufsize, left) |
| data = self._sock.recv(recv_size) |
| if not data: |
| break |
| buffers.append(data) |
| n = len(data) |
| if n >= left: |
| self._rbuf = data[left:] |
| buffers[-1] = data[:left] |
| break |
| buf_len += n |
| return "".join(buffers) |
| |
| def readline(self, size=-1): |
| data = self._rbuf |
| if size < 0: |
| |
| if self._rbufsize <= 1: |
| |
| assert data == "" |
| buffers = [] |
| recv = self._sock.recv |
| while data != "\n": |
| data = recv(1) |
| if not data: |
| break |
| buffers.append(data) |
| return "".join(buffers) |
| nl = data.find('\n') |
| if nl >= 0: |
| nl += 1 |
| self._rbuf = data[nl:] |
| return data[:nl] |
| buffers = [] |
| if data: |
| buffers.append(data) |
| self._rbuf = "" |
| while True: |
| data = self._sock.recv(self._rbufsize) |
| if not data: |
| break |
| buffers.append(data) |
| nl = data.find('\n') |
| if nl >= 0: |
| nl += 1 |
| self._rbuf = data[nl:] |
| buffers[-1] = data[:nl] |
| break |
| return "".join(buffers) |
| else: |
| |
| nl = data.find('\n', 0, size) |
| if nl >= 0: |
| nl += 1 |
| self._rbuf = data[nl:] |
| return data[:nl] |
| buf_len = len(data) |
| if buf_len >= size: |
| self._rbuf = data[size:] |
| return data[:size] |
| buffers = [] |
| if data: |
| buffers.append(data) |
| self._rbuf = "" |
| while True: |
| data = self._sock.recv(self._rbufsize) |
| if not data: |
| break |
| buffers.append(data) |
| left = size - buf_len |
| nl = data.find('\n', 0, left) |
| if nl >= 0: |
| nl += 1 |
| self._rbuf = data[nl:] |
| buffers[-1] = data[:nl] |
| break |
| n = len(data) |
| if n >= left: |
| self._rbuf = data[left:] |
| buffers[-1] = data[:left] |
| break |
| buf_len += n |
| return "".join(buffers) |
| |
| def readlines(self, sizehint=0): |
| total = 0 |
| list = [] |
| while True: |
| line = self.readline() |
| if not line: |
| break |
| list.append(line) |
| total += len(line) |
| if sizehint and total >= sizehint: |
| break |
| return list |
| |
| |
| |
| def __iter__(self): |
| return self |
| |
| def next(self): |
| line = self.readline() |
| if not line: |
| raise StopIteration |
| return line |
| |
| |
| _GLOBAL_DEFAULT_TIMEOUT = object() |
| |
| |
| def create_connection(address, timeout=_GLOBAL_DEFAULT_TIMEOUT): |
| """Connect to *address* and return the socket object. |
| |
| Convenience function. Connect to *address* (a 2-tuple ``(host, |
| port)``) and return the socket object. Passing the optional |
| *timeout* parameter will set the timeout on the socket instance |
| before attempting to connect. If no *timeout* is supplied, the |
| global default timeout setting returned by :func:`getdefaulttimeout` |
| is used. |
| """ |
| |
| msg = "getaddrinfo returns an empty list" |
| host, port = address |
| for res in getaddrinfo(host, port, 0, SOCK_STREAM): |
| af, socktype, proto, canonname, sa = res |
| sock = None |
| try: |
| sock = socket(af, socktype, proto) |
| if timeout is not _GLOBAL_DEFAULT_TIMEOUT: |
| sock.settimeout(timeout) |
| sock.connect(sa, host) |
| return sock |
| |
| except error, msg: |
| if sock is not None: |
| sock.close() |
| |
| raise error, msg |
| |
| |
| ssl = None |
