Python socket.AF_UNIX() Examples

The following are code examples for showing how to use socket.AF_UNIX(). They are extracted from open source Python projects. You can vote up the examples you like or vote down the ones you don't like. You can also save this page to your account.

Example 1
Project: electrum-martexcoin-server   Author: martexcoin   File: stratum_http.py    (license) View Source Project 7 votes vote down vote up
def __init__(self, addr, requestHandler=StratumJSONRPCRequestHandler,
                 logRequests=False, encoding=None, bind_and_activate=True,
                 address_family=socket.AF_INET):
        self.logRequests = logRequests
        StratumJSONRPCDispatcher.__init__(self, encoding)
        # TCPServer.__init__ has an extra parameter on 2.6+, so
        # check Python version and decide on how to call it
        vi = sys.version_info
        self.address_family = address_family
        if USE_UNIX_SOCKETS and address_family == socket.AF_UNIX:
            # Unix sockets can't be bound if they already exist in the
            # filesystem. The convention of e.g. X11 is to unlink
            # before binding again.
            if os.path.exists(addr):
                try:
                    os.unlink(addr)
                except OSError:
                    logging.warning("Could not unlink socket %s", addr)

        SocketServer.TCPServer.__init__(self, addr, requestHandler, bind_and_activate)

        if fcntl is not None and hasattr(fcntl, 'FD_CLOEXEC'):
            flags = fcntl.fcntl(self.fileno(), fcntl.F_GETFD)
            flags |= fcntl.FD_CLOEXEC
            fcntl.fcntl(self.fileno(), fcntl.F_SETFD, flags) 
Example 2
Project: Python-Network-Programming-Cookbook-Second-Edition   Author: PacktPublishing   File: 3_9a_unix_domain_socket_server.py    (license) View Source Project 7 votes vote down vote up
def run_unix_domain_socket_server():
    if os.path.exists(SERVER_PATH):
        os.remove( SERVER_PATH )
     
    print ("starting unix domain socket server.")
    server = socket.socket( socket.AF_UNIX, socket.SOCK_DGRAM )
    server.bind(SERVER_PATH)
     
    print ("Listening on path: %s" %SERVER_PATH)
    while True:
        datagram = server.recv( 1024 )
        if not datagram:
            break
        else:
            print ("-" * 20)
            print (datagram)
        if "DONE" == datagram:
            break
    print ("-" * 20)
    print ("Server is shutting down now...")
    server.close()
    os.remove(SERVER_PATH)
    print ("Server shutdown and path removed.") 
Example 3
Project: jf   Author: rolycg   File: server_JF.py    (license) View Source Project 7 votes vote down vote up
def query_process_communication():
    global t2
    if os.path.exists('/tmp/process_com_' + login):
        os.remove('/tmp/process_com_' + login)
    sqp = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
    sqp.bind('/tmp/process_com_' + login)
    sqp.listen(1)
    while 1:
        conn_qp, _ = sqp.accept()
        while 1:
            data = conn_qp.recv(10)
            if data:
                if t2 and t2.is_alive():
                    t2.terminate()
                open_writing()
                conn_qp.close()
                break 
Example 4
Project: annotated-py-asyncio   Author: hhstore   File: unix_events.py    (license) View Source Project 6 votes vote down vote up
def create_unix_connection(self, protocol_factory, path, *,
                               ssl=None, sock=None,
                               server_hostname=None):
        assert server_hostname is None or isinstance(server_hostname, str)
        if ssl:
            if server_hostname is None:
                raise ValueError(
                    'you have to pass server_hostname when using ssl')
        else:
            if server_hostname is not None:
                raise ValueError('server_hostname is only meaningful with ssl')

        if path is not None:
            if sock is not None:
                raise ValueError(
                    'path and sock can not be specified at the same time')

            sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM, 0)
            try:
                sock.setblocking(False)
                yield from self.sock_connect(sock, path)
            except:
                sock.close()
                raise

        else:
            if sock is None:
                raise ValueError('no path and sock were specified')
            sock.setblocking(False)

        transport, protocol = yield from self._create_connection_transport(
            sock, protocol_factory, ssl, server_hostname)
        return transport, protocol 
Example 5
Project: OSPTF   Author: xSploited   File: _pslinux.py    (license) View Source Project 6 votes vote down vote up
def __init__(self):
        tcp4 = ("tcp", socket.AF_INET, socket.SOCK_STREAM)
        tcp6 = ("tcp6", socket.AF_INET6, socket.SOCK_STREAM)
        udp4 = ("udp", socket.AF_INET, socket.SOCK_DGRAM)
        udp6 = ("udp6", socket.AF_INET6, socket.SOCK_DGRAM)
        unix = ("unix", socket.AF_UNIX, None)
        self.tmap = {
            "all": (tcp4, tcp6, udp4, udp6, unix),
            "tcp": (tcp4, tcp6),
            "tcp4": (tcp4,),
            "tcp6": (tcp6,),
            "udp": (udp4, udp6),
            "udp4": (udp4,),
            "udp6": (udp6,),
            "unix": (unix,),
            "inet": (tcp4, tcp6, udp4, udp6),
            "inet4": (tcp4, udp4),
            "inet6": (tcp6, udp6),
        }
        self._procfs_path = None 
Example 6
Project: node-agent   Author: Tendrl   File: handler.py    (license) View Source Project 6 votes vote down vote up
def bind_unix_listener(self):
        # http://0pointer.de/blog/projects/systemd.html (search "file
        # descriptor 3")
        try:
            socket_fd = 3
            self.sock = socket.fromfd(socket_fd, socket.AF_UNIX,
                                      socket.SOCK_STREAM)
            self.sock.listen(50)
            return self.sock
        except (TypeError, BlockingIOError, socket.error, ValueError):
            pass
        try:
            self.sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
            if os.path.exists(MESSAGE_SOCK_PATH):
                os.remove(MESSAGE_SOCK_PATH)
            self.sock.bind(MESSAGE_SOCK_PATH)
            self.sock.listen(50)
            return self.sock
        except Exception as ex:
            exc_type, exc_value, exc_tb = sys.exc_info()
            traceback.print_exception(exc_type, exc_value, exc_tb,
                                      file=sys.stderr)
            raise ex 
Example 7
Project: slidoc   Author: mitotic   File: multiproxy.py    (license) View Source Project 6 votes vote down vote up
def connect_to_internal(self):
        if self.closed:
            return

        try:
            assert self.relay_address, "Relay address not defined for internal connection"
            if isinstance(self.relay_address, tuple):
                # relay_address = (host, addr)
                socket_type = socket.AF_INET
            else:
                # relay_address = unix_domain_socket_addr
                socket_type = socket.AF_UNIX
            self.internal_sock = socket.socket(socket_type, socket.SOCK_STREAM, 0)
            self.internal_stream = ChunkyIOStream(self.internal_sock, io_loop=self.proxy_server.io_loop)
            self.internal_stream.set_close_callback(self.internal_disconnected)
            self.internal_stream.connect(self.relay_address, self.internal_connected)
        except Exception, excp:
            logging.warning("multiproxy: Internal connect error: %s", excp)
            self.inbound_flow.error_response("502 Bad Gateway (internal connect error)") 
Example 8
Project: oil   Author: oilshell   File: test_socketserver.py    (license) View Source Project 6 votes vote down vote up
def pickaddr(self, proto):
        if proto == socket.AF_INET:
            return (HOST, 0)
        else:
            # XXX: We need a way to tell AF_UNIX to pick its own name
            # like AF_INET provides port==0.
            dir = None
            if os.name == 'os2':
                dir = '\socket'
            fn = tempfile.mktemp(prefix='unix_socket.', dir=dir)
            if os.name == 'os2':
                # AF_UNIX socket names on OS/2 require a specific prefix
                # which can't include a drive letter and must also use
                # backslashes as directory separators
                if fn[1] == ':':
                    fn = fn[2:]
                if fn[0] in (os.sep, os.altsep):
                    fn = fn[1:]
                if os.sep == '/':
                    fn = fn.replace(os.sep, os.altsep)
                else:
                    fn = fn.replace(os.altsep, os.sep)
            self.test_files.append(fn)
            return fn 
Example 9
Project: logging2   Author: vforgione   File: sockets.py    (license) View Source Project 6 votes vote down vote up
def _create_name(self) -> str:
        """Creates the name for the handler - called from ``__init__`` if a name is not given.

        :returns: a template of `({protocol} )?{host}(:{port})?`
        """
        if self.port:
            port = ':{}'.format(self.port)
        else:
            port = ''

        if self.family == socket.AF_UNIX:
            stype = 'UNIX'
        elif self.type == socket.SOCK_STREAM:
            stype = 'TCP'
        elif self.type == socket.SOCK_DGRAM:
            stype = 'UDP'
        else:
            stype = None  # pragma: no cover

        if stype:
            host = ' {}'.format(self.host)
        else:
            host = self.host  # pragma: no cover

        return '{}{}{}'.format(stype, host, port) 
Example 10
Project: logging2   Author: vforgione   File: sockets.py    (license) View Source Project 6 votes vote down vote up
def __init__(
            self,
            node: str,
            encoding: Optional[str]='utf8',
            name: Optional[str]=None,
            level: Optional[LogLevel]=None
    ):
        """Instantiates a new ``UnixHandler``

        :param node: the path to the socket node on the system
        :param encoding: the message encoding
        :param name: the name of the handler
        :param level: the minimum verbosity level to write log entries
        """
        super().__init__(
            name=name, level=level, host=node, family=socket.AF_UNIX,
            type=socket.SOCK_DGRAM, encoding=encoding) 
Example 11
Project: bluetool   Author: emlid   File: blueserver.py    (license) View Source Project 6 votes vote down vote up
def NewConnection(self, path, fd, properties):
        address = str(path)
        address = address[len(address) - 17:len(address)]
        address = address.replace("_", ":")
        print_info("Connected: {}\n".format(address))

        blue_socket = socket.fromfd(
            fd.take(), socket.AF_UNIX, socket.SOCK_STREAM)

        socket_sink = SocketSink(sock=blue_socket)
        self.bridge = TCPBridge(
            sink=socket_sink,
            port_in=self.tcp_port_in,
            port_out=self.tcp_port_out)

        try:
            self.bridge.start(in_background=False)
        except TCPBridgeError as error:
            print_error(str(error) + "\n")

        self.bridge.stop()
        blue_socket.close()

        print_info("Disconnected: {}\n".format(address))
        Bluetooth().disconnect(address) 
Example 12
Project: web_ctp   Author: molebot   File: test_asyncore.py    (license) View Source Project 6 votes vote down vote up
def test_handle_expt(self):
        # Make sure handle_expt is called on OOB data received.
        # Note: this might fail on some platforms as OOB data is
        # tenuously supported and rarely used.
        if HAS_UNIX_SOCKETS and self.family == socket.AF_UNIX:
            self.skipTest("Not applicable to AF_UNIX sockets.")

        class TestClient(BaseClient):
            def handle_expt(self):
                self.socket.recv(1024, socket.MSG_OOB)
                self.flag = True

        class TestHandler(BaseTestHandler):
            def __init__(self, conn):
                BaseTestHandler.__init__(self, conn)
                self.socket.send(bytes(chr(244), 'latin-1'), socket.MSG_OOB)

        server = BaseServer(self.family, self.addr, TestHandler)
        client = TestClient(self.family, server.address)
        self.loop_waiting_for_flag(client) 
Example 13
Project: dcos   Author: dcos   File: basehandler.py    (license) View Source Project 6 votes vote down vote up
def log_message(self, log_format, *args):
        """Just a patch to make Mockers Requests Handlers compatible with
           Unix Sockets.

        Method logs the request without source IP address/with hard-coded value
        of `unix-socket-connection` if the socket is a Unix Socket.

        Please check the http.server.BaseHTTPRequestHandler documentation
        for the meaning of the function arguments.
        """
        endpoint_id = self.server.context.data['endpoint_id']
        if self.server.address_family == socket.AF_UNIX:
            log.debug("[Endpoint: %s] %s - - [%s] %s\n",
                      endpoint_id,
                      "unix-socket-connection",
                      self.log_date_time_string(),
                      log_format % args)
        else:
            log.debug("[Endpoint: %s] %s - - [%s] %s\n",
                      endpoint_id,
                      self.address_string(),
                      self.log_date_time_string(),
                      log_format % args) 
Example 14
Project: golightan   Author: shirou   File: selector_events.py    (license) View Source Project 6 votes vote down vote up
def sock_connect(self, sock, address):
        """Connect to a remote socket at address.

        This method is a coroutine.
        """
        if self._debug and sock.gettimeout() != 0:
            raise ValueError("the socket must be non-blocking")

        if not hasattr(socket, 'AF_UNIX') or sock.family != socket.AF_UNIX:
            resolved = base_events._ensure_resolved(
                address, family=sock.family, proto=sock.proto, loop=self)
            if not resolved.done():
                yield from resolved
            _, _, _, _, address = resolved.result()[0]

        fut = self.create_future()
        self._sock_connect(fut, sock, address)
        return (yield from fut) 
Example 15
Project: CodeLabs   Author: TheIoTLearningInitiative   File: bluetoothspp.py    (license) View Source Project 6 votes vote down vote up
def NewConnection(self, path, fd, properties):
		self.fd = fd.take()
		print("NewConnection(%s, %d)" % (path, self.fd))


		server_sock = socket.fromfd(self.fd, socket.AF_UNIX, socket.SOCK_STREAM)
		server_sock.setblocking(1)
		server_sock.send("This is Edison SPP loopback test\nAll data will be loopback\nPlease start:\n")

		myfifo.openFifo()

		print('enter recv loop\n')
		try:
		    while True:
		        data = server_sock.recv(1024)
		        print("received: %s" % data)
		        myfifo.writeFifo(data)
		        #server_sock.send("looping back: %s\n" % data)
		except IOError as err:
		    print (err)
		    pass

		server_sock.close()
		print("all done") 
Example 16
Project: CodeLabs   Author: TheIoTLearningInitiative   File: SPP-loopback.py    (license) View Source Project 6 votes vote down vote up
def NewConnection(self, path, fd, properties):
		self.fd = fd.take()
		print("NewConnection(%s, %d)" % (path, self.fd))


		server_sock = socket.fromfd(self.fd, socket.AF_UNIX, socket.SOCK_STREAM)
		server_sock.setblocking(1)
		server_sock.send("This is Edison SPP loopback test\nAll data will be loopback\nPlease start:\n")

		try:
		    while True:
		        data = server_sock.recv(1024)
		        print("received: %s" % data)
			server_sock.send("looping back: %s\n" % data)
		except IOError:
		    pass

		server_sock.close()
		print("all done") 
Example 17
Project: CodeLabs   Author: TheIoTLearningInitiative   File: spp.py    (license) View Source Project 6 votes vote down vote up
def NewConnection(self, path, fd, properties):
		self.fd = fd.take()
                device_path = os.path.basename(path)
		print("\nConnected to %s\nPress [ENTER] to continue" % device_path)

		server_sock = socket.fromfd(self.fd, socket.AF_UNIX, socket.SOCK_STREAM)
		server_sock.settimeout(1)
		server_sock.send("Hello, this is Edison!")
		try:
		    while True:
                        try:
                            data = server_sock.recv(1024)
                            gardening_system.function(data)
                            if data == 'b':
                                server_sock.send(gardening_system.requestData())
                        except socket.timeout:
                            pass
                        gardening_system.myProgram()
		except IOError:
		    pass
		server_sock.close()
                print("\nYour device is now disconnected\nPress [ENTER] to continue") 
Example 18
Project: CodeLabs   Author: TheIoTLearningInitiative   File: spp.py    (license) View Source Project 6 votes vote down vote up
def processSockets(fd):
    data = ""
    server_sock = socket.fromfd(fd,
                                socket.AF_UNIX,
                                socket.SOCK_STREAM)
    server_sock.settimeout(1)
    server_sock.send("Hello, this is Edison!")
    try:
        while not closing:
            try:
                data = server_sock.recv(1024)
                print ("Here's data %s" % data)
                result = ha.callFunction(data)
                if result:
                    server_sock.send(result)
            except socket.timeout:
                pass
    except IOError:
        pass
    server_sock.close()


# Agent class 
Example 19
Project: CodeLabs   Author: TheIoTLearningInitiative   File: spp.py    (license) View Source Project 6 votes vote down vote up
def NewConnection(self, path, fd, properties):
		self.fd = fd.take()
                device_path = os.path.basename(path)
		print("\nConnected to %s\nPress [ENTER] to continue" % device_path)

		server_sock = socket.fromfd(self.fd, socket.AF_UNIX, socket.SOCK_STREAM)
		server_sock.settimeout(1)
		server_sock.send("Hello, this is Edison!")
		try:
		    while True:
                        try:
                            data = server_sock.recv(1024)
                            temperature_monitor.function(data)
                            if data == 'get':
                                server_sock.send(temperature_monitor.requestData())
                        except socket.timeout:
                            pass
                        temperature_monitor.myProgram()
		except IOError:
		    pass
		server_sock.close()
                print("\nYour device is now disconnected\nPress [ENTER] to continue") 
Example 20
Project: ouroboros   Author: pybee   File: reduction.py    (license) View Source Project 6 votes vote down vote up
def recvfds(sock, size):
        '''Receive an array of fds over an AF_UNIX socket.'''
        a = array.array('i')
        bytes_size = a.itemsize * size
        msg, ancdata, flags, addr = sock.recvmsg(1, socket.CMSG_LEN(bytes_size))
        if not msg and not ancdata:
            raise EOFError
        try:
            if ACKNOWLEDGE:
                sock.send(b'A')
            if len(ancdata) != 1:
                raise RuntimeError('received %d items of ancdata' %
                                   len(ancdata))
            cmsg_level, cmsg_type, cmsg_data = ancdata[0]
            if (cmsg_level == socket.SOL_SOCKET and
                cmsg_type == socket.SCM_RIGHTS):
                if len(cmsg_data) % a.itemsize != 0:
                    raise ValueError
                a.frombytes(cmsg_data)
                assert len(a) % 256 == msg[0]
                return list(a)
        except (ValueError, IndexError):
            pass
        raise RuntimeError('Invalid data received') 
Example 21
Project: ouroboros   Author: pybee   File: test_asyncore.py    (license) View Source Project 6 votes vote down vote up
def test_handle_expt(self):
        # Make sure handle_expt is called on OOB data received.
        # Note: this might fail on some platforms as OOB data is
        # tenuously supported and rarely used.
        if HAS_UNIX_SOCKETS and self.family == socket.AF_UNIX:
            self.skipTest("Not applicable to AF_UNIX sockets.")

        class TestClient(BaseClient):
            def handle_expt(self):
                self.socket.recv(1024, socket.MSG_OOB)
                self.flag = True

        class TestHandler(BaseTestHandler):
            def __init__(self, conn):
                BaseTestHandler.__init__(self, conn)
                self.socket.send(bytes(chr(244), 'latin-1'), socket.MSG_OOB)

        server = BaseServer(self.family, self.addr, TestHandler)
        client = TestClient(self.family, server.address)
        self.loop_waiting_for_flag(client) 
Example 22
Project: ouroboros   Author: pybee   File: test_asyncore.py    (license) View Source Project 6 votes vote down vote up
def test_set_reuse_addr(self):
        if HAS_UNIX_SOCKETS and self.family == socket.AF_UNIX:
            self.skipTest("Not applicable to AF_UNIX sockets.")
        sock = socket.socket(self.family)
        try:
            sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        except OSError:
            unittest.skip("SO_REUSEADDR not supported on this platform")
        else:
            # if SO_REUSEADDR succeeded for sock we expect asyncore
            # to do the same
            s = asyncore.dispatcher(socket.socket(self.family))
            self.assertFalse(s.socket.getsockopt(socket.SOL_SOCKET,
                                                 socket.SO_REUSEADDR))
            s.socket.close()
            s.create_socket(self.family)
            s.set_reuse_addr()
            self.assertTrue(s.socket.getsockopt(socket.SOL_SOCKET,
                                                 socket.SO_REUSEADDR))
        finally:
            sock.close() 
Example 23
Project: ouroboros   Author: pybee   File: handlers.py    (license) View Source Project 6 votes vote down vote up
def makeSocket(self, timeout=1):
        """
        A factory method which allows subclasses to define the precise
        type of socket they want.
        """
        if self.port is not None:
            result = socket.create_connection(self.address, timeout=timeout)
        else:
            result = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
            result.settimeout(timeout)
            try:
                result.connect(self.address)
            except OSError:
                result.close()  # Issue 19182
                raise
        return result 
Example 24
Project: ouroboros   Author: pybee   File: handlers.py    (license) View Source Project 6 votes vote down vote up
def _connect_unixsocket(self, address):
        use_socktype = self.socktype
        if use_socktype is None:
            use_socktype = socket.SOCK_DGRAM
        self.socket = socket.socket(socket.AF_UNIX, use_socktype)
        try:
            self.socket.connect(address)
            # it worked, so set self.socktype to the used type
            self.socktype = use_socktype
        except OSError:
            self.socket.close()
            if self.socktype is not None:
                # user didn't specify falling back, so fail
                raise
            use_socktype = socket.SOCK_STREAM
            self.socket = socket.socket(socket.AF_UNIX, use_socktype)
            try:
                self.socket.connect(address)
                # it worked, so set self.socktype to the used type
                self.socktype = use_socktype
            except OSError:
                self.socket.close()
                raise 
Example 25
Project: ops_agent   Author: sjqzhang   File: easy_application.py    (license) View Source Project 6 votes vote down vote up
def bind_unix_listener(self, path, backlog=50, user=None):
        try:
            sock = gevent.socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
            sock.setblocking(0)
            self.unlink(path)
            sock.bind(path)
            if user is not None:
                import pwd
                user = pwd.getpwnam(user)
                os.chown(path, user.pw_uid, user.pw_gid)
            os.chmod(path, 0777)
            sock.listen(backlog)
        except Exception, e:
            self.logger.error("Create unix socket failed: %s", e.__str__())
            return None
        return sock 
Example 26
Project: zenchmarks   Author: squeaky-pl   File: pullpipe.py    (license) View Source Project 6 votes vote down vote up
def recvfd(socketfd):
    """
    Receive a file descriptor from a L{sendmsg} message on the given C{AF_UNIX}
    socket.

    @param socketfd: An C{AF_UNIX} socket, attached to another process waiting
        to send sockets via the ancillary data mechanism in L{send1msg}.

    @param fd: C{int}

    @return: a 2-tuple of (new file descriptor, description).
    @rtype: 2-tuple of (C{int}, C{bytes})
    """
    ourSocket = socket.fromfd(socketfd, socket.AF_UNIX, socket.SOCK_STREAM)
    data, ancillary, flags = recvmsg(ourSocket)
    [(cmsgLevel, cmsgType, packedFD)] = ancillary
    # cmsgLevel and cmsgType really need to be SOL_SOCKET / SCM_RIGHTS, but
    # since those are the *only* standard values, there's not much point in
    # checking.
    [unpackedFD] = unpack("i", packedFD)
    return (unpackedFD, data) 
Example 27
Project: membrane   Author: CrySyS   File: netstat.py    (license) View Source Project 6 votes vote down vote up
def render_text(self, outfd, data):
        linux_common.set_plugin_members(self)

        if not self.addr_space.profile.has_type("inet_sock"):
            # ancient (2.6.9) centos kernels do not have inet_sock in debug info
            raise AttributeError, "Given profile does not have inet_sock, please file a bug if the kernel version is > 2.6.11"

        for task in data:
            for ents in task.netstat():
                if ents[0] == socket.AF_INET:
                    (proto, saddr, sport, daddr, dport, state) = ents[1]
                    outfd.write("{0:8s} {1:<16}:{2:>5} {3:<16}:{4:>5} {5:<15s} {6:>17s}/{7:<5d}\n".format(proto, saddr, sport, daddr, dport, state, task.comm, task.pid))

                elif ents[0] == socket.AF_UNIX and not self._config.IGNORE_UNIX:
                    (name, inum) = ents[1]
                    outfd.write("UNIX {0:<8d} {1:>17s}/{2:<5d} {3:s}\n".format(inum, task.comm, task.pid, name)) 
Example 28
Project: felix   Author: axbaretto   File: test_datastore.py    (license) View Source Project 6 votes vote down vote up
def test_start_driver(self, m_unlink, m_socket, m_timeout, m_popen,
                          m_exists):
        m_exists.return_value = True
        m_sck = Mock()
        m_socket.return_value = m_sck
        m_conn = Mock()
        m_sck.accept.return_value = m_conn, None
        reader, writer = self.watcher._start_driver()
        self.assertEqual(m_socket.mock_calls[0], call(socket.AF_UNIX,
                                                      socket.SOCK_STREAM))
        self.assertEqual(m_sck.bind.mock_calls,
                         [call("/run/felix-driver.sck")])
        self.assertEqual(m_sck.listen.mock_calls, [call(1)])
        self.assertEqual(m_popen.mock_calls[0],
                         call([ANY, "-m", "calico.etcddriver",
                               "/run/felix-driver.sck"]))
        self.assertEqual(m_unlink.mock_calls,
                         [call("/run/felix-driver.sck")] * 2)
        self.assertTrue(isinstance(reader, MessageReader))
        self.assertTrue(isinstance(writer, MessageWriter))
        m_exists.assert_called_once_with("/run")
        m_timeout.assert_called_once_with(10) 
Example 29
Project: jf   Author: rolycg   File: server_JF.py    (license) View Source Project 6 votes vote down vote up
def finish_query(devices, data_layer, son):
    res = {}
    for x in devices.keys():
        for item in devices[x]:
            try:
                res[repr((x[0], x[1], x[2], x[3]))].append(repr(data_layer.get_address(item[1], item[7])))
            except KeyError:
                res[repr((x[0], x[1], x[2], x[3]))] = [repr(data_layer.get_address(item[1], item[7]))]
    s_qp = socket.socket(family=socket.AF_UNIX, type=socket.SOCK_STREAM)
    son.send(json.dumps(res))
    for x in devices.keys():
        devices[x].close()
    data_layer.close()
    try:
        s_qp.connect('/tmp/process_com_' + login)
    except FileNotFoundError:
        print('FileNotFoundError')
    except ConnectionRefusedError:
        print('ConnectionRefusedError')
    s_qp.send(b'True')
    s_qp.close() 
Example 30
Project: jf   Author: rolycg   File: client_JF.py    (license) View Source Project 6 votes vote down vote up
def sign_in(s):
    logged = s.recv(100)
    logged = logged.decode()
    logged = json.loads(logged)
    if logged['logged']:
        return s
    password = getpass.getpass()
    sha = hashlib.md5(password.encode()).hexdigest()
    j = json.dumps({'action': 'login', 'password': sha})
    s.send(j.encode())
    d = s.recv(2048)
    d = json.loads(d.decode())
    try:
        message = d['login']
        if not message:
            print('Wrong password.')
            s.close()
            return None
        else:
            s = socket.socket(family=socket.AF_UNIX, type=socket.SOCK_STREAM)
            s.connect('/tmp/JF_' + login)
            return s
    except KeyError:
        print(error) 
Example 31
Project: Flask_Blog   Author: sugarguo   File: preforkserver.py    (GNU General Public License v3.0) View Source Project 5 votes vote down vote up
def socketpair():
        s1, s2 = eunuchs.socketpair.socketpair()
        p, c = (socket.fromfd(s1, socket.AF_UNIX, socket.SOCK_STREAM),
                socket.fromfd(s2, socket.AF_UNIX, socket.SOCK_STREAM))
        os.close(s1)
        os.close(s2)
        return p, c 
Example 32
Project: electrum-martexcoin-server   Author: martexcoin   File: stratum_http.py    (license) View Source Project 5 votes vote down vote up
def __init__(self, addr, certfile, keyfile,
                 requestHandler=SSLRequestHandler,
                 logRequests=False, encoding=None, bind_and_activate=True,
                 address_family=socket.AF_INET):

        self.logRequests = logRequests
        StratumJSONRPCDispatcher.__init__(self, encoding)
        # TCPServer.__init__ has an extra parameter on 2.6+, so
        # check Python version and decide on how to call it
        vi = sys.version_info
        self.address_family = address_family
        if USE_UNIX_SOCKETS and address_family == socket.AF_UNIX:
            # Unix sockets can't be bound if they already exist in the
            # filesystem. The convention of e.g. X11 is to unlink
            # before binding again.
            if os.path.exists(addr):
                try:
                    os.unlink(addr)
                except OSError:
                    logging.warning("Could not unlink socket %s", addr)

        SSLTCPServer.__init__(self, addr, certfile, keyfile, requestHandler, bind_and_activate)

        if fcntl is not None and hasattr(fcntl, 'FD_CLOEXEC'):
            flags = fcntl.fcntl(self.fileno(), fcntl.F_GETFD)
            flags |= fcntl.FD_CLOEXEC
            fcntl.fcntl(self.fileno(), fcntl.F_SETFD, flags) 
Example 33
Project: abusehelper   Author: Exploit-install   File: roomgraph.py    (license) View Source Project 5 votes vote down vote up
def _start_worker(self):
        env = dict(os.environ)
        env["ABUSEHELPER_SUBPROCESS"] = ""

        # Find out the full package & module name. Don't refer to the
        # variable __loader__ directly to keep flake8 (version 2.5.0)
        # linter happy.
        fullname = globals()["__loader__"].fullname

        own_conn, other_conn = native_socket.socketpair(socket.AF_UNIX, socket.SOCK_STREAM)
        try:
            process = subprocess.Popen(
                [sys.executable, "-m", fullname],
                preexec_fn=os.setpgrp,
                stdin=other_conn.fileno(),
                close_fds=True,
                env=env
            )

            try:
                conn = socket.fromfd(own_conn.fileno(), socket.AF_UNIX, socket.SOCK_STREAM)
            except:
                process.terminate()
                process.wait()
                raise
        finally:
            own_conn.close()
            other_conn.close()
        return process, conn 
Example 34
Project: OSPTF   Author: xSploited   File: _pslinux.py    (license) View Source Project 5 votes vote down vote up
def __init__(self):
        tcp4 = ("tcp", socket.AF_INET, socket.SOCK_STREAM)
        tcp6 = ("tcp6", socket.AF_INET6, socket.SOCK_STREAM)
        udp4 = ("udp", socket.AF_INET, socket.SOCK_DGRAM)
        udp6 = ("udp6", socket.AF_INET6, socket.SOCK_DGRAM)
        unix = ("unix", socket.AF_UNIX, None)
        self.tmap = {
            "all": (tcp4, tcp6, udp4, udp6, unix),
            "tcp": (tcp4, tcp6),
            "tcp4": (tcp4,),
            "tcp6": (tcp6,),
            "udp": (udp4, udp6),
            "udp4": (udp4,),
            "udp6": (udp6,),
            "unix": (unix,),
            "inet": (tcp4, tcp6, udp4, udp6),
            "inet4": (tcp4, udp4),
            "inet6": (tcp6, udp6),
        }
        self._procfs_path = None 
Example 35
Project: packet-queue   Author: google   File: libnetfilter_queue.py    (license) View Source Project 5 votes vote down vote up
def __init__(self):
    self.handle = nfq.nfq_open()
    self.fileno = nfq.nfq_fd(self.handle)
    self.socket = socket.fromfd(self.fileno, socket.AF_UNIX, socket.SOCK_RAW)

    if nfq.nfq_unbind_pf(self.handle, socket.AF_INET) < 0:
      raise OSError('nfq_unbind_pf() failed. Are you root?')

    if nfq.nfq_bind_pf(self.handle, socket.AF_INET) < 0:
      raise OSError('nfq_bind_pf() failed. Are you root?') 
Example 36
Project: lbryum-server   Author: lbryio   File: stratum_http.py    (license) View Source Project 5 votes vote down vote up
def __init__(self, addr, requestHandler=StratumJSONRPCRequestHandler,
                 logRequests=False, encoding=None, bind_and_activate=True,
                 address_family=socket.AF_INET):
        self.logRequests = logRequests
        StratumJSONRPCDispatcher.__init__(self, encoding)
        # TCPServer.__init__ has an extra parameter on 2.6+, so
        # check Python version and decide on how to call it
        vi = sys.version_info
        self.address_family = address_family
        if USE_UNIX_SOCKETS and address_family == socket.AF_UNIX:
            # Unix sockets can't be bound if they already exist in the
            # filesystem. The convention of e.g. X11 is to unlink
            # before binding again.
            if os.path.exists(addr):
                try:
                    os.unlink(addr)
                except OSError:
                    logging.warning("Could not unlink socket %s", addr)

        SocketServer.TCPServer.__init__(self, addr, requestHandler, bind_and_activate)

        if fcntl is not None and hasattr(fcntl, 'FD_CLOEXEC'):
            flags = fcntl.fcntl(self.fileno(), fcntl.F_GETFD)
            flags |= fcntl.FD_CLOEXEC
            fcntl.fcntl(self.fileno(), fcntl.F_SETFD, flags) 
Example 37
Project: lbryum-server   Author: lbryio   File: stratum_http.py    (license) View Source Project 5 votes vote down vote up
def __init__(self, addr, certfile, keyfile,
                 requestHandler=SSLRequestHandler,
                 logRequests=False, encoding=None, bind_and_activate=True,
                 address_family=socket.AF_INET):

        self.logRequests = logRequests
        StratumJSONRPCDispatcher.__init__(self, encoding)
        # TCPServer.__init__ has an extra parameter on 2.6+, so
        # check Python version and decide on how to call it
        vi = sys.version_info
        self.address_family = address_family
        if USE_UNIX_SOCKETS and address_family == socket.AF_UNIX:
            # Unix sockets can't be bound if they already exist in the
            # filesystem. The convention of e.g. X11 is to unlink
            # before binding again.
            if os.path.exists(addr):
                try:
                    os.unlink(addr)
                except OSError:
                    logging.warning("Could not unlink socket %s", addr)

        SSLTCPServer.__init__(self, addr, certfile, keyfile, requestHandler, bind_and_activate)

        if fcntl is not None and hasattr(fcntl, 'FD_CLOEXEC'):
            flags = fcntl.fcntl(self.fileno(), fcntl.F_GETFD)
            flags |= fcntl.FD_CLOEXEC
            fcntl.fcntl(self.fileno(), fcntl.F_SETFD, flags) 
Example 38
Project: dataScryer   Author: Griesbacher   File: livestatus.py    (license) View Source Project 5 votes vote down vote up
def __init__(self, ip=None, soc=None):
        if ip is not None:
            self.__address = ip
            self.__socket_type = socket.AF_INET
        elif soc is not None:
            self.__address = soc
            self.__socket_type = socket.AF_UNIX
        else:
            raise Exception("Neither IP nor socket was given!")
        self.__socket = None
        self.__perf_label_regex = re.compile(
            r'([^=]+)=(U|[\d\.\-]+)([\w\/%]*);?([\d\.\-:[email protected]]+)?;?([\d\.\-:[email protected]]+)?;?([\d\.\-]+)?;?([\d\.\-]+)?;?\s*'
        ) 
Example 39
Project: jd4   Author: vijos   File: pool.py    (license) View Source Project 5 votes vote down vote up
def _compiler_build(compiler, code,
                          time_limit_ns, memory_limit_bytes, process_limit):
    loop = get_event_loop()
    sandbox = await _sandbox_pool.get()
    try:
        await compiler.prepare(sandbox, code.encode())
        output_file = path.join(sandbox.in_dir, 'output')
        mkfifo(output_file)
        with socket(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK) as cgroup_sock:
            cgroup_sock.bind(path.join(sandbox.in_dir, 'cgroup'))
            cgroup_sock.listen()
            build_task = loop.create_task(compiler.build(
                sandbox,
                output_file='/in/output',
                cgroup_file='/in/cgroup'))
            others_task = gather(read_pipe(output_file, _MAX_OUTPUT),
                                 wait_cgroup(cgroup_sock,
                                             build_task,
                                             time_limit_ns,
                                             memory_limit_bytes,
                                             process_limit))
            package, status = await build_task
            output, (time_usage_ns, memory_usage_bytes) = await others_task
        return package, output.decode(encoding='utf-8', errors='replace'), \
               time_usage_ns, memory_usage_bytes
    finally:
        _sandbox_pool.put_nowait(sandbox) 
Example 40
Project: jd4   Author: vijos   File: cgroup.py    (license) View Source Project 5 votes vote down vote up
def enter_cgroup(socket_path):
    with socket(AF_UNIX, SOCK_STREAM) as sock:
        sock.connect(socket_path)
        sock.recv(1) 
Example 41
Project: dhcpkit_vpp   Author: sjm-steffann   File: vpp.py    (license) View Source Project 5 votes vote down vote up
def __init__(self, interfaces: Iterable[VPPInterface], listen_socket: socket.socket, marks: Iterable[str] = None):
        """
        Initialise VPP listener.

        :param interfaces: The interfaces we listen to and their information
        :param listen_socket: The socket we are listening on, may be a unicast or multicast socket
        :param marks: Marks attached to this listener
        """
        self.interfaces = interfaces
        self.listen_socket = listen_socket
        self.marks = list(marks or [])

        # Check that we have Unix Domain sockets
        if self.listen_socket.family != socket.AF_UNIX or self.listen_socket.type != socket.SOCK_DGRAM:
            raise ListeningSocketError("Listen socket has to be Unix domain datagram socket") 
Example 42
Project: pupy   Author: ru-faraon   File: _pslinux.py    (license) View Source Project 5 votes vote down vote up
def __init__(self):
        tcp4 = ("tcp", socket.AF_INET, socket.SOCK_STREAM)
        tcp6 = ("tcp6", socket.AF_INET6, socket.SOCK_STREAM)
        udp4 = ("udp", socket.AF_INET, socket.SOCK_DGRAM)
        udp6 = ("udp6", socket.AF_INET6, socket.SOCK_DGRAM)
        unix = ("unix", socket.AF_UNIX, None)
        self.tmap = {
            "all": (tcp4, tcp6, udp4, udp6, unix),
            "tcp": (tcp4, tcp6),
            "tcp4": (tcp4,),
            "tcp6": (tcp6,),
            "udp": (udp4, udp6),
            "udp4": (udp4,),
            "udp6": (udp6,),
            "unix": (unix,),
            "inet": (tcp4, tcp6, udp4, udp6),
            "inet4": (tcp4, udp4),
            "inet6": (tcp6, udp6),
        }
        self._procfs_path = None 
Example 43
Project: pupy   Author: ru-faraon   File: _pslinux.py    (license) View Source Project 5 votes vote down vote up
def process_inet(self, file, family, type_, inodes, filter_pid=None):
        """Parse /proc/net/tcp* and /proc/net/udp* files."""
        if file.endswith('6') and not os.path.exists(file):
            # IPv6 not supported
            return
        with open_text(file, buffering=BIGGER_FILE_BUFFERING) as f:
            f.readline()  # skip the first line
            for lineno, line in enumerate(f, 1):
                try:
                    _, laddr, raddr, status, _, _, _, _, _, inode = \
                        line.split()[:10]
                except ValueError:
                    raise RuntimeError(
                        "error while parsing %s; malformed line %s %r" % (
                            file, lineno, line))
                if inode in inodes:
                    # # We assume inet sockets are unique, so we error
                    # # out if there are multiple references to the
                    # # same inode. We won't do this for UNIX sockets.
                    # if len(inodes[inode]) > 1 and family != socket.AF_UNIX:
                    #     raise ValueError("ambiguos inode with multiple "
                    #                      "PIDs references")
                    pid, fd = inodes[inode][0]
                else:
                    pid, fd = None, -1
                if filter_pid is not None and filter_pid != pid:
                    continue
                else:
                    if type_ == socket.SOCK_STREAM:
                        status = TCP_STATUSES[status]
                    else:
                        status = _common.CONN_NONE
                    try:
                        laddr = self.decode_address(laddr, family)
                        raddr = self.decode_address(raddr, family)
                    except _Ipv6UnsupportedError:
                        continue
                    yield (fd, family, type_, laddr, raddr, status, pid) 
Example 44
Project: pupy   Author: ru-faraon   File: _pssunos.py    (license) View Source Project 5 votes vote down vote up
def _get_unix_sockets(self, pid):
        """Get UNIX sockets used by process by parsing 'pfiles' output."""
        # TODO: rewrite this in C (...but the damn netstat source code
        # does not include this part! Argh!!)
        cmd = "pfiles %s" % pid
        p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE,
                             stderr=subprocess.PIPE)
        stdout, stderr = p.communicate()
        if PY3:
            stdout, stderr = [x.decode(sys.stdout.encoding)
                              for x in (stdout, stderr)]
        if p.returncode != 0:
            if 'permission denied' in stderr.lower():
                raise AccessDenied(self.pid, self._name)
            if 'no such process' in stderr.lower():
                raise NoSuchProcess(self.pid, self._name)
            raise RuntimeError("%r command error\n%s" % (cmd, stderr))

        lines = stdout.split('\n')[2:]
        for i, line in enumerate(lines):
            line = line.lstrip()
            if line.startswith('sockname: AF_UNIX'):
                path = line.split(' ', 2)[2]
                type = lines[i - 2].strip()
                if type == 'SOCK_STREAM':
                    type = socket.SOCK_STREAM
                elif type == 'SOCK_DGRAM':
                    type = socket.SOCK_DGRAM
                else:
                    type = -1
                yield (-1, socket.AF_UNIX, type, path, "", _common.CONN_NONE) 
Example 45
Project: pupy   Author: ru-faraon   File: _pslinux.py    (license) View Source Project 5 votes vote down vote up
def __init__(self):
        tcp4 = ("tcp", socket.AF_INET, socket.SOCK_STREAM)
        tcp6 = ("tcp6", socket.AF_INET6, socket.SOCK_STREAM)
        udp4 = ("udp", socket.AF_INET, socket.SOCK_DGRAM)
        udp6 = ("udp6", socket.AF_INET6, socket.SOCK_DGRAM)
        unix = ("unix", socket.AF_UNIX, None)
        self.tmap = {
            "all": (tcp4, tcp6, udp4, udp6, unix),
            "tcp": (tcp4, tcp6),
            "tcp4": (tcp4,),
            "tcp6": (tcp6,),
            "udp": (udp4, udp6),
            "udp4": (udp4,),
            "udp6": (udp6,),
            "unix": (unix,),
            "inet": (tcp4, tcp6, udp4, udp6),
            "inet4": (tcp4, udp4),
            "inet6": (tcp6, udp6),
        }
        self._procfs_path = None 
Example 46
Project: pupy   Author: ru-faraon   File: _pslinux.py    (license) View Source Project 5 votes vote down vote up
def process_inet(self, file, family, type_, inodes, filter_pid=None):
        """Parse /proc/net/tcp* and /proc/net/udp* files."""
        if file.endswith('6') and not os.path.exists(file):
            # IPv6 not supported
            return
        with open_text(file, buffering=BIGGER_FILE_BUFFERING) as f:
            f.readline()  # skip the first line
            for lineno, line in enumerate(f, 1):
                try:
                    _, laddr, raddr, status, _, _, _, _, _, inode = \
                        line.split()[:10]
                except ValueError:
                    raise RuntimeError(
                        "error while parsing %s; malformed line %s %r" % (
                            file, lineno, line))
                if inode in inodes:
                    # # We assume inet sockets are unique, so we error
                    # # out if there are multiple references to the
                    # # same inode. We won't do this for UNIX sockets.
                    # if len(inodes[inode]) > 1 and family != socket.AF_UNIX:
                    #     raise ValueError("ambiguos inode with multiple "
                    #                      "PIDs references")
                    pid, fd = inodes[inode][0]
                else:
                    pid, fd = None, -1
                if filter_pid is not None and filter_pid != pid:
                    continue
                else:
                    if type_ == socket.SOCK_STREAM:
                        status = TCP_STATUSES[status]
                    else:
                        status = _common.CONN_NONE
                    try:
                        laddr = self.decode_address(laddr, family)
                        raddr = self.decode_address(raddr, family)
                    except _Ipv6UnsupportedError:
                        continue
                    yield (fd, family, type_, laddr, raddr, status, pid) 
Example 47
Project: parsec-cloud   Author: Scille   File: cli.py    (license) View Source Project 5 votes vote down vote up
def cmd(id, args, socket_path, per_cmd_connection):
    from socket import socket, AF_UNIX, SOCK_STREAM
    sock = socket(AF_UNIX, SOCK_STREAM)
    sock.connect(socket)
    try:
        msg = '%s %s' % (id, args)
        sock.send(msg.encode())
        resp = sock.recv(4096)
        print(resp)
    finally:
        sock.close() 
Example 48
Project: igcollect   Author: innogames   File: haproxy.py    (license) View Source Project 5 votes vote down vote up
def read_ha_proxy_stats(haproxy_stats_socket):
    conn = socket(AF_UNIX, SOCK_STREAM)
    try:
        conn.connect(haproxy_stats_socket)
        conn.sendall(b'show stat\r\n')
        data = conn.recv(BUFFER_SIZE)
        while len(data) % BUFFER_SIZE == 0:
            try:
                data += conn.recv(BUFFER_SIZE, MSG_DONTWAIT)
            except socket.error:
                break
        return data
    finally:
        conn.close() 
Example 49
Project: qmpbackup   Author: abbbi   File: qmp.py    (license) View Source Project 5 votes vote down vote up
def __get_sock(self):
        if isinstance(self.__address, tuple):
            family = socket.AF_INET
        else:
            family = socket.AF_UNIX
        return socket.socket(family, socket.SOCK_STREAM) 
Example 50
Project: Decept   Author: Cisco-Talos   File: decept.py    (license) View Source Project 5 votes vote down vote up
def shutdown(self):
        if self.local_end_type in ConnectionBased:
            server_kill = self.socket_plinko(self.lhost,self.local_end_type)
            if server_kill.type != socket.AF_UNIX:
                server_kill.connect((self.lhost,self.lport))
                server_kill.close()
            elif "unix" in self.local_end_type:
                try:
                    remove(self.lhost)
                except:
                    output("[?.?] Unable to delete Unix Socket: %s"%self.lhost,YELLOW)

        output("[^.^] Thanks for using Decept!")
        sys.exit()