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()
def __init__(self, handler):
self.sock = socket.fromfd(handler, socket.AF_INET, socket.SOCK_STREAM)
self.write = self.sock.sendall
