def from_sock_handoff(cls, recv_sock, **init_args): """Takes a unix socket connection and uses it to receive a connection handoff. Expects the remote process to send it a socket fd and handoff data - see client.handoff_to_sock() While most init args are provided by handoff data, others (eg. logger) can be passed in as extra kwargs. Note this method will block until the connection is closed. """ connection = None try: # receive fd from other process fd = recv_fd(recv_sock) connection = socket.fromfd(fd, socket.AF_INET, socket.SOCK_STREAM) # receive other args as json handoff_data = '' s = True while s: # loop until closed s = recv_sock.recv(4096) handoff_data += s handoff_data = json.loads(handoff_data) handoff_data = {k: v.encode('utf-8') if isinstance(v, unicode) else v for k, v in handoff_data.items()} handoff_data.update(init_args) return cls._from_handoff(connection, **handoff_data) except Exception: if connection: connection.close() raise
def socket(self): """Gets the underlying socket safely.""" hub_id = id(gevent.get_hub()) if hub_id != getattr(self, '_hub_id', -1): self._hub_id = hub_id self._socket = fromfd(self.fileno, self.family, self.proto) return self._socket
def _child(self, socket, run, args, kwargs): """The body of the child process.""" kill_signo = getattr(self, '_kill_signo', None) # Reset environments. reset_signal_handlers(exclude=set([kill_signo] if kill_signo else [])) reset_gevent() # Reinit the socket because the hub has been destroyed. socket = fromfd(socket.fileno(), socket.family, socket.proto) # Make a greenlet but don't start yet. greenlet = Quietlet(run, *args, **kwargs) # Register kill signal handler. if kill_signo: killed = (lambda signo, frame, socket=socket, greenlet=greenlet: self._child_killed(socket, greenlet, frame)) signal.signal(kill_signo, killed) # Notify birth. Use non-gevent socket to avoid gevent conflict. _fromfd = get_original('socket', 'fromfd') _socket = _fromfd(socket.fileno(), socket.family, socket.proto) _socket.sendall(b'\x01') # Run the greenlet. greenlet.start() try: greenlet.join(0) # Catch exceptions before blocking. gevent.spawn(self._watch_child_killers, socket, greenlet) rv = greenlet.get() # Run the function. except SystemExit as e: ok, code, rv = False, e.code, e except BaseException as e: ok, code, rv = False, 1, e else: ok, code = True, 0 # Notify the result. put(socket, (ok, rv)) os._exit(code)
def create_nfqueue_thread(nfqueue_id, func): nfqueue = NetfilterQueue() nfqueue.bind(nfqueue_id, func) nf_queues.append(nfqueue) s = socket.fromfd(nfqueue.get_fd(), socket.AF_UNIX, socket.SOCK_STREAM) sockets.append(s) return gevent.spawn(nfqueue.run_socket, s)
def _copy_listener(self, listener): if isinstance(listener, socket.socket): fd = listener.fileno() family = listener.family type = listener.type proto = listener.proto return socket.fromfd(fd, family, type, proto) return listener
def __init__(self, host='', port=0, fd=None): self.port = port if fd is not None: self.socket = socket.fromfd(fd, socket.AF_INET, socket.SOCK_DGRAM) else: self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) self.socket.bind((host, port)) self.active_host, self.active_port = self.socket.getsockname()
def tcp_listener(address, backlog=None): backlog = backlog or 128 if util.is_ipv6(address[0]): family = socket.AF_INET6 else: family = socket.AF_INET bound = False if 'TPROXY_FD' in os.environ: fd = int(os.environ.pop('TPROXY_FD')) try: sock = socket.fromfd(fd, family, socket.SOCK_STREAM) except socket.error, e: if e[0] == errno.ENOTCONN: log.error("TPROXY_FD should refer to an open socket.") else: raise bound = True
def __init__(self, handler): self.sock = socket.fromfd(handler, socket.AF_INET, socket.SOCK_STREAM) self.write = self.sock.sendall
def reconnect(self, fd): """ connect to an already connected socket """ assert self.sendertasklet is None self.sock = socket.fromfd(fd, socket.AF_INET, socket.SOCK_STREAM) self.sock.settimeout(self.timeout) self._prepare()