Server IP : 85.214.239.14 / Your IP : 3.144.227.73 Web Server : Apache/2.4.62 (Debian) System : Linux h2886529.stratoserver.net 4.9.0 #1 SMP Tue Jan 9 19:45:01 MSK 2024 x86_64 User : www-data ( 33) PHP Version : 7.4.18 Disable Function : pcntl_alarm,pcntl_fork,pcntl_waitpid,pcntl_wait,pcntl_wifexited,pcntl_wifstopped,pcntl_wifsignaled,pcntl_wifcontinued,pcntl_wexitstatus,pcntl_wtermsig,pcntl_wstopsig,pcntl_signal,pcntl_signal_get_handler,pcntl_signal_dispatch,pcntl_get_last_error,pcntl_strerror,pcntl_sigprocmask,pcntl_sigwaitinfo,pcntl_sigtimedwait,pcntl_exec,pcntl_getpriority,pcntl_setpriority,pcntl_async_signals,pcntl_unshare, MySQL : OFF | cURL : OFF | WGET : ON | Perl : ON | Python : ON | Sudo : ON | Pkexec : OFF Directory : /proc/3/task/3/cwd/srv/modoboa/env/lib64/python3.5/site-packages/gevent/ |
Upload File : |
# Copyright (c) 2009-2012 Denis Bilenko. See LICENSE for details. """TCP/SSL server""" from contextlib import closing import sys from _socket import error as SocketError from _socket import SOL_SOCKET from _socket import SO_REUSEADDR from _socket import AF_INET from _socket import SOCK_DGRAM from gevent.baseserver import BaseServer from gevent.socket import EWOULDBLOCK from gevent.socket import socket as GeventSocket from gevent._compat import PYPY, PY3 __all__ = ['StreamServer', 'DatagramServer'] if sys.platform == 'win32': # SO_REUSEADDR on Windows does not mean the same thing as on *nix (issue #217) DEFAULT_REUSE_ADDR = None else: DEFAULT_REUSE_ADDR = 1 if PY3: # sockets and SSL sockets are context managers on Python 3 def _closing_socket(sock): return sock else: # but they are not guaranteed to be so on Python 2 _closing_socket = closing class StreamServer(BaseServer): """ A generic TCP server. Accepts connections on a listening socket and spawns user-provided *handle* function for each connection with 2 arguments: the client socket and the client address. Note that although the errors in a successfully spawned handler will not affect the server or other connections, the errors raised by :func:`accept` and *spawn* cause the server to stop accepting for a short amount of time. The exact period depends on the values of :attr:`min_delay` and :attr:`max_delay` attributes. The delay starts with :attr:`min_delay` and doubles with each successive error until it reaches :attr:`max_delay`. A successful :func:`accept` resets the delay to :attr:`min_delay` again. See :class:`~gevent.baseserver.BaseServer` for information on defining the *handle* function and important restrictions on it. **SSL Support** The server can optionally work in SSL mode when given the correct keyword arguments. (That is, the presence of any keyword arguments will trigger SSL mode.) On Python 2.7.9 and later (any Python version that supports the :class:`ssl.SSLContext`), this can be done with a configured ``SSLContext``. On any Python version, it can be done by passing the appropriate arguments for :func:`ssl.wrap_socket`. The incoming socket will be wrapped into an SSL socket before being passed to the *handle* function. If the *ssl_context* keyword argument is present, it should contain an :class:`ssl.SSLContext`. The remaining keyword arguments are passed to the :meth:`ssl.SSLContext.wrap_socket` method of that object. Depending on the Python version, supported arguments may include: - server_hostname - suppress_ragged_eofs - do_handshake_on_connect .. caution:: When using an SSLContext, it should either be imported from :mod:`gevent.ssl`, or the process needs to be monkey-patched. If the process is not monkey-patched and you pass the standard library SSLContext, the resulting client sockets will not cooperate with gevent. Otherwise, keyword arguments are assumed to apply to :func:`ssl.wrap_socket`. These keyword arguments may include: - keyfile - certfile - cert_reqs - ssl_version - ca_certs - suppress_ragged_eofs - do_handshake_on_connect - ciphers .. versionchanged:: 1.2a2 Add support for the *ssl_context* keyword argument. """ # the default backlog to use if none was provided in __init__ backlog = 256 reuse_addr = DEFAULT_REUSE_ADDR def __init__(self, listener, handle=None, backlog=None, spawn='default', **ssl_args): BaseServer.__init__(self, listener, handle=handle, spawn=spawn) try: if ssl_args: ssl_args.setdefault('server_side', True) if 'ssl_context' in ssl_args: ssl_context = ssl_args.pop('ssl_context') self.wrap_socket = ssl_context.wrap_socket self.ssl_args = ssl_args else: from gevent.ssl import wrap_socket self.wrap_socket = wrap_socket self.ssl_args = ssl_args else: self.ssl_args = None if backlog is not None: if hasattr(self, 'socket'): raise TypeError('backlog must be None when a socket instance is passed') self.backlog = backlog except: self.close() raise @property def ssl_enabled(self): return self.ssl_args is not None def set_listener(self, listener): BaseServer.set_listener(self, listener) try: self.socket = self.socket._sock except AttributeError: pass def init_socket(self): if not hasattr(self, 'socket'): # FIXME: clean up the socket lifetime # pylint:disable=attribute-defined-outside-init self.socket = self.get_listener(self.address, self.backlog, self.family) self.address = self.socket.getsockname() if self.ssl_args: self._handle = self.wrap_socket_and_handle else: self._handle = self.handle @classmethod def get_listener(cls, address, backlog=None, family=None): if backlog is None: backlog = cls.backlog return _tcp_listener(address, backlog=backlog, reuse_addr=cls.reuse_addr, family=family) if PY3: def do_read(self): sock = self.socket try: fd, address = sock._accept() except BlockingIOError: # python 2: pylint: disable=undefined-variable if not sock.timeout: return raise sock = GeventSocket(sock.family, sock.type, sock.proto, fileno=fd) # XXX Python issue #7995? return sock, address else: def do_read(self): try: client_socket, address = self.socket.accept() except SocketError as err: if err.args[0] == EWOULDBLOCK: return raise # XXX: When would this not be the case? In Python 3 it makes sense # because we're using the low-level _accept method, # but not in Python 2. if not isinstance(client_socket, GeventSocket): # This leads to a leak of the watchers in client_socket sockobj = GeventSocket(_sock=client_socket) if PYPY: client_socket._drop() else: sockobj = client_socket return sockobj, address def do_close(self, sock, *args): # pylint:disable=arguments-differ sock.close() def wrap_socket_and_handle(self, client_socket, address): # used in case of ssl sockets with _closing_socket(self.wrap_socket(client_socket, **self.ssl_args)) as ssl_socket: return self.handle(ssl_socket, address) class DatagramServer(BaseServer): """A UDP server""" reuse_addr = DEFAULT_REUSE_ADDR def __init__(self, *args, **kwargs): # The raw (non-gevent) socket, if possible self._socket = None BaseServer.__init__(self, *args, **kwargs) from gevent.lock import Semaphore self._writelock = Semaphore() def init_socket(self): if not hasattr(self, 'socket'): # FIXME: clean up the socket lifetime # pylint:disable=attribute-defined-outside-init self.socket = self.get_listener(self.address, self.family) self.address = self.socket.getsockname() self._socket = self.socket try: self._socket = self._socket._sock except AttributeError: pass @classmethod def get_listener(cls, address, family=None): return _udp_socket(address, reuse_addr=cls.reuse_addr, family=family) def do_read(self): try: data, address = self._socket.recvfrom(8192) except SocketError as err: if err.args[0] == EWOULDBLOCK: return raise return data, address def sendto(self, *args): self._writelock.acquire() try: self.socket.sendto(*args) finally: self._writelock.release() def _tcp_listener(address, backlog=50, reuse_addr=None, family=AF_INET): """A shortcut to create a TCP socket, bind it and put it into listening state.""" sock = GeventSocket(family=family) if reuse_addr is not None: sock.setsockopt(SOL_SOCKET, SO_REUSEADDR, reuse_addr) try: sock.bind(address) except SocketError as ex: strerror = getattr(ex, 'strerror', None) if strerror is not None: ex.strerror = strerror + ': ' + repr(address) raise sock.listen(backlog) sock.setblocking(0) return sock def _udp_socket(address, backlog=50, reuse_addr=None, family=AF_INET): # backlog argument for compat with tcp_listener # pylint:disable=unused-argument # we want gevent.socket.socket here sock = GeventSocket(family=family, type=SOCK_DGRAM) if reuse_addr is not None: sock.setsockopt(SOL_SOCKET, SO_REUSEADDR, reuse_addr) try: sock.bind(address) except SocketError as ex: strerror = getattr(ex, 'strerror', None) if strerror is not None: ex.strerror = strerror + ': ' + repr(address) raise return sock