示例#1
0
    def test_supports_ipv6(self):
        self.addCleanup(supports_ipv6.cache_clear)
        if supports_ipv6():
            with mock.patch('psutil._common.socket') as s:
                s.has_ipv6 = False
                supports_ipv6.cache_clear()
                assert not supports_ipv6()

            supports_ipv6.cache_clear()
            with mock.patch('psutil._common.socket.socket',
                            side_effect=socket.error) as s:
                assert not supports_ipv6()
                assert s.called

            supports_ipv6.cache_clear()
            with mock.patch('psutil._common.socket.socket',
                            side_effect=socket.gaierror) as s:
                assert not supports_ipv6()
                supports_ipv6.cache_clear()
                assert s.called

            supports_ipv6.cache_clear()
            with mock.patch('psutil._common.socket.socket.bind',
                            side_effect=socket.gaierror) as s:
                assert not supports_ipv6()
                supports_ipv6.cache_clear()
                assert s.called
        else:
            with self.assertRaises(Exception):
                sock = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
                sock.bind(("::1", 0))
示例#2
0
    def test_supports_ipv6(self):
        self.addCleanup(supports_ipv6.cache_clear)
        if supports_ipv6():
            with mock.patch('psutil._common.socket') as s:
                s.has_ipv6 = False
                supports_ipv6.cache_clear()
                assert not supports_ipv6()

            supports_ipv6.cache_clear()
            with mock.patch('psutil._common.socket.socket',
                            side_effect=socket.error) as s:
                assert not supports_ipv6()
                assert s.called

            supports_ipv6.cache_clear()
            with mock.patch('psutil._common.socket.socket',
                            side_effect=socket.gaierror) as s:
                assert not supports_ipv6()
                supports_ipv6.cache_clear()
                assert s.called

            supports_ipv6.cache_clear()
            with mock.patch('psutil._common.socket.socket.bind',
                            side_effect=socket.gaierror) as s:
                assert not supports_ipv6()
                supports_ipv6.cache_clear()
                assert s.called
        else:
            with self.assertRaises(Exception):
                sock = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
                sock.bind(("::1", 0))
示例#3
0
class TestUnconnectedSockets(Base, unittest.TestCase):
    """Tests sockets which are open but not connected to anything."""

    def test_tcp_v4(self):
        addr = ("127.0.0.1", get_free_port())
        with closing(bind_socket(AF_INET, SOCK_STREAM, addr=addr)) as sock:
            conn = self.check_socket(sock)
            assert not conn.raddr
            self.assertEqual(conn.status, psutil.CONN_LISTEN)

    @unittest.skipIf(not supports_ipv6(), "IPv6 not supported")
    def test_tcp_v6(self):
        addr = ("::1", get_free_port())
        with closing(bind_socket(AF_INET6, SOCK_STREAM, addr=addr)) as sock:
            conn = self.check_socket(sock)
            assert not conn.raddr
            self.assertEqual(conn.status, psutil.CONN_LISTEN)

    def test_udp_v4(self):
        addr = ("127.0.0.1", get_free_port())
        with closing(bind_socket(AF_INET, SOCK_DGRAM, addr=addr)) as sock:
            conn = self.check_socket(sock)
            assert not conn.raddr
            self.assertEqual(conn.status, psutil.CONN_NONE)

    @unittest.skipIf(not supports_ipv6(), "IPv6 not supported")
    def test_udp_v6(self):
        addr = ("::1", get_free_port())
        with closing(bind_socket(AF_INET6, SOCK_DGRAM, addr=addr)) as sock:
            conn = self.check_socket(sock)
            assert not conn.raddr
            self.assertEqual(conn.status, psutil.CONN_NONE)

    @unittest.skipIf(not POSIX, 'POSIX only')
    def test_unix_tcp(self):
        with unix_socket_path() as name:
            with closing(bind_unix_socket(name, type=SOCK_STREAM)) as sock:
                conn = self.check_socket(sock)
                assert not conn.raddr
                self.assertEqual(conn.status, psutil.CONN_NONE)

    @unittest.skipIf(not POSIX, 'POSIX only')
    def test_unix_udp(self):
        with unix_socket_path() as name:
            with closing(bind_unix_socket(name, type=SOCK_STREAM)) as sock:
                conn = self.check_socket(sock)
                assert not conn.raddr
                self.assertEqual(conn.status, psutil.CONN_NONE)
示例#4
0
文件: __init__.py 项目: mabuaita/ops
def create_sockets():
    """Open as many socket families / types as possible."""
    socks = []
    fname1 = fname2 = None
    try:
        socks.append(bind_socket(socket.AF_INET, socket.SOCK_STREAM))
        socks.append(bind_socket(socket.AF_INET, socket.SOCK_DGRAM))
        if supports_ipv6():
            socks.append(bind_socket(socket.AF_INET6, socket.SOCK_STREAM))
            socks.append(bind_socket(socket.AF_INET6, socket.SOCK_DGRAM))
        if POSIX and HAS_CONNECTIONS_UNIX:
            fname1 = unix_socket_path().__enter__()
            fname2 = unix_socket_path().__enter__()
            s1, s2 = unix_socketpair(fname1)
            s3 = bind_unix_socket(fname2, type=socket.SOCK_DGRAM)
            # self.addCleanup(safe_rmpath, fname1)
            # self.addCleanup(safe_rmpath, fname2)
            for s in (s1, s2, s3):
                socks.append(s)
        yield socks
    finally:
        for s in socks:
            s.close()
        if fname1 is not None:
            safe_rmpath(fname1)
        if fname2 is not None:
            safe_rmpath(fname2)
示例#5
0
    def test_connections(self):
        def create_socket(family, type):
            sock = socket.socket(family, type)
            sock.bind(('', 0))
            if type == socket.SOCK_STREAM:
                sock.listen(1)
            return sock

        socks = []
        socks.append(create_socket(socket.AF_INET, socket.SOCK_STREAM))
        socks.append(create_socket(socket.AF_INET, socket.SOCK_DGRAM))
        if supports_ipv6():
            socks.append(create_socket(socket.AF_INET6, socket.SOCK_STREAM))
            socks.append(create_socket(socket.AF_INET6, socket.SOCK_DGRAM))
        if hasattr(socket, 'AF_UNIX'):
            safe_remove(TESTFN)
            s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
            s.bind(TESTFN)
            s.listen(1)
            socks.append(s)
        kind = 'all'
        # TODO: UNIX sockets are temporarily implemented by parsing
        # 'pfiles' cmd  output; we don't want that part of the code to
        # be executed.
        if SUNOS:
            kind = 'inet'
        try:
            self.execute('connections', kind=kind)
        finally:
            for s in socks:
                s.close()
示例#6
0
文件: __init__.py 项目: kiddfz/psutil
def create_sockets():
    """Open as many socket families / types as possible."""
    socks = []
    fname1 = fname2 = None
    try:
        socks.append(bind_socket(socket.AF_INET, socket.SOCK_STREAM))
        socks.append(bind_socket(socket.AF_INET, socket.SOCK_DGRAM))
        if supports_ipv6():
            socks.append(bind_socket(socket.AF_INET6, socket.SOCK_STREAM))
            socks.append(bind_socket(socket.AF_INET6, socket.SOCK_DGRAM))
        if POSIX and HAS_CONNECTIONS_UNIX:
            fname1 = unix_socket_path().__enter__()
            fname2 = unix_socket_path().__enter__()
            s1, s2 = unix_socketpair(fname1)
            s3 = bind_unix_socket(fname2, type=socket.SOCK_DGRAM)
            # self.addCleanup(safe_rmpath, fname1)
            # self.addCleanup(safe_rmpath, fname2)
            for s in (s1, s2, s3):
                socks.append(s)
        yield socks
    finally:
        for s in socks:
            s.close()
        if fname1 is not None:
            safe_rmpath(fname1)
        if fname2 is not None:
            safe_rmpath(fname2)
示例#7
0
    def test_connections(self):
        def create_socket(family, type):
            sock = socket.socket(family, type)
            sock.bind(('', 0))
            if type == socket.SOCK_STREAM:
                sock.listen(1)
            return sock

        socks = []
        socks.append(create_socket(socket.AF_INET, socket.SOCK_STREAM))
        socks.append(create_socket(socket.AF_INET, socket.SOCK_DGRAM))
        if supports_ipv6():
            socks.append(create_socket(socket.AF_INET6, socket.SOCK_STREAM))
            socks.append(create_socket(socket.AF_INET6, socket.SOCK_DGRAM))
        if hasattr(socket, 'AF_UNIX'):
            safe_rmpath(TESTFN)
            s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
            s.bind(TESTFN)
            s.listen(1)
            socks.append(s)
        kind = 'all'
        # TODO: UNIX sockets are temporarily implemented by parsing
        # 'pfiles' cmd  output; we don't want that part of the code to
        # be executed.
        if SUNOS:
            kind = 'inet'
        try:
            self.execute('connections', kind=kind)
        finally:
            for s in socks:
                s.close()
示例#8
0
 def create_sockets(self):
     """Open as many socket families / types as possible.
     This is needed to excercise as many C code sections as
     possible for net_connections() functions.
     The returned sockets are already scheduled for cleanup.
     """
     socks = []
     try:
         socks.append(bind_socket(socket.AF_INET, socket.SOCK_STREAM))
         socks.append(bind_socket(socket.AF_INET, socket.SOCK_DGRAM))
         if supports_ipv6():
             socks.append(bind_socket(socket.AF_INET6, socket.SOCK_STREAM))
             socks.append(bind_socket(socket.AF_INET6, socket.SOCK_DGRAM))
         if POSIX and not SUNOS:  # TODO: SunOS
             name1 = unix_socket_path().__enter__()
             name2 = unix_socket_path().__enter__()
             s1, s2 = unix_socketpair(name1)
             s3 = bind_unix_socket(name2, type=socket.SOCK_DGRAM)
             self.addCleanup(safe_rmpath, name1)
             self.addCleanup(safe_rmpath, name2)
             for s in (s1, s2, s3):
                 socks.append(s)
         return socks
     finally:
         for s in socks:
             self.addCleanup(s.close)
示例#9
0
文件: test_misc.py 项目: nem0301/APM
 def test_supports_ipv6(self):
     if supports_ipv6():
         with mock.patch('psutil._common.socket') as s:
             s.has_ipv6 = False
             assert not supports_ipv6()
         with mock.patch('psutil._common.socket.socket',
                         side_effect=socket.error) as s:
             assert not supports_ipv6()
             assert s.called
         with mock.patch('psutil._common.socket.socket',
                         side_effect=socket.gaierror) as s:
             assert not supports_ipv6()
             assert s.called
         with mock.patch('psutil._common.socket.socket.bind',
                         side_effect=socket.gaierror) as s:
             assert not supports_ipv6()
             assert s.called
     else:
         if hasattr(socket, 'AF_INET6'):
             with self.assertRaises(Exception):
                 sock = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
                 sock.bind(("::1", 0))
示例#10
0
 def test_supports_ipv6(self):
     if supports_ipv6():
         with mock.patch('psutil._common.socket') as s:
             s.has_ipv6 = False
             assert not supports_ipv6()
         with mock.patch('psutil._common.socket.socket',
                         side_effect=socket.error) as s:
             assert not supports_ipv6()
             assert s.called
         with mock.patch('psutil._common.socket.socket',
                         side_effect=socket.gaierror) as s:
             assert not supports_ipv6()
             assert s.called
         with mock.patch('psutil._common.socket.socket.bind',
                         side_effect=socket.gaierror) as s:
             assert not supports_ipv6()
             assert s.called
     else:
         if hasattr(socket, 'AF_INET6'):
             with self.assertRaises(Exception):
                 sock = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
                 sock.bind(("::1", 0))
示例#11
0
 def test_multi_sockets_filtering(self):
     with create_sockets() as socks:
         cons = thisproc.connections(kind='all')
         self.assertEqual(len(cons), len(socks))
         # tcp
         cons = thisproc.connections(kind='tcp')
         self.assertEqual(len(cons), 2 if supports_ipv6() else 1)
         for conn in cons:
             self.assertIn(conn.family, (AF_INET, AF_INET6))
             self.assertEqual(conn.type, SOCK_STREAM)
         # tcp4
         cons = thisproc.connections(kind='tcp4')
         self.assertEqual(len(cons), 1)
         self.assertEqual(cons[0].family, AF_INET)
         self.assertEqual(cons[0].type, SOCK_STREAM)
         # tcp6
         if supports_ipv6():
             cons = thisproc.connections(kind='tcp6')
             self.assertEqual(len(cons), 1)
             self.assertEqual(cons[0].family, AF_INET6)
             self.assertEqual(cons[0].type, SOCK_STREAM)
         # udp
         cons = thisproc.connections(kind='udp')
         self.assertEqual(len(cons), 2 if supports_ipv6() else 1)
         for conn in cons:
             self.assertIn(conn.family, (AF_INET, AF_INET6))
             self.assertEqual(conn.type, SOCK_DGRAM)
         # udp4
         cons = thisproc.connections(kind='udp4')
         self.assertEqual(len(cons), 1)
         self.assertEqual(cons[0].family, AF_INET)
         self.assertEqual(cons[0].type, SOCK_DGRAM)
         # udp6
         if supports_ipv6():
             cons = thisproc.connections(kind='udp6')
             self.assertEqual(len(cons), 1)
             self.assertEqual(cons[0].family, AF_INET6)
             self.assertEqual(cons[0].type, SOCK_DGRAM)
         # inet
         cons = thisproc.connections(kind='inet')
         self.assertEqual(len(cons), 4 if supports_ipv6() else 2)
         for conn in cons:
             self.assertIn(conn.family, (AF_INET, AF_INET6))
             self.assertIn(conn.type, (SOCK_STREAM, SOCK_DGRAM))
         # inet6
         if supports_ipv6():
             cons = thisproc.connections(kind='inet6')
             self.assertEqual(len(cons), 2)
             for conn in cons:
                 self.assertEqual(conn.family, AF_INET6)
                 self.assertIn(conn.type, (SOCK_STREAM, SOCK_DGRAM))
         # unix
         if HAS_CONNECTIONS_UNIX:
             cons = thisproc.connections(kind='unix')
             self.assertEqual(len(cons), 3)
             for conn in cons:
                 self.assertEqual(conn.family, AF_UNIX)
                 self.assertIn(conn.type, (SOCK_STREAM, SOCK_DGRAM))
示例#12
0
 def test_multi_sockets_filtering(self):
     with create_sockets() as socks:
         cons = thisproc.connections(kind='all')
         self.assertEqual(len(cons), len(socks))
         # tcp
         cons = thisproc.connections(kind='tcp')
         self.assertEqual(len(cons), 2 if supports_ipv6() else 1)
         for conn in cons:
             self.assertIn(conn.family, (AF_INET, AF_INET6))
             self.assertEqual(conn.type, SOCK_STREAM)
         # tcp4
         cons = thisproc.connections(kind='tcp4')
         self.assertEqual(len(cons), 1)
         self.assertEqual(cons[0].family, AF_INET)
         self.assertEqual(cons[0].type, SOCK_STREAM)
         # tcp6
         if supports_ipv6():
             cons = thisproc.connections(kind='tcp6')
             self.assertEqual(len(cons), 1)
             self.assertEqual(cons[0].family, AF_INET6)
             self.assertEqual(cons[0].type, SOCK_STREAM)
         # udp
         cons = thisproc.connections(kind='udp')
         self.assertEqual(len(cons), 2 if supports_ipv6() else 1)
         for conn in cons:
             self.assertIn(conn.family, (AF_INET, AF_INET6))
             self.assertEqual(conn.type, SOCK_DGRAM)
         # udp4
         cons = thisproc.connections(kind='udp4')
         self.assertEqual(len(cons), 1)
         self.assertEqual(cons[0].family, AF_INET)
         self.assertEqual(cons[0].type, SOCK_DGRAM)
         # udp6
         if supports_ipv6():
             cons = thisproc.connections(kind='udp6')
             self.assertEqual(len(cons), 1)
             self.assertEqual(cons[0].family, AF_INET6)
             self.assertEqual(cons[0].type, SOCK_DGRAM)
         # inet
         cons = thisproc.connections(kind='inet')
         self.assertEqual(len(cons), 4 if supports_ipv6() else 2)
         for conn in cons:
             self.assertIn(conn.family, (AF_INET, AF_INET6))
             self.assertIn(conn.type, (SOCK_STREAM, SOCK_DGRAM))
         # inet6
         if supports_ipv6():
             cons = thisproc.connections(kind='inet6')
             self.assertEqual(len(cons), 2)
             for conn in cons:
                 self.assertEqual(conn.family, AF_INET6)
                 self.assertIn(conn.type, (SOCK_STREAM, SOCK_DGRAM))
         # unix
         if HAS_CONNECTIONS_UNIX:
             cons = thisproc.connections(kind='unix')
             self.assertEqual(len(cons), 3)
             for conn in cons:
                 self.assertEqual(conn.family, AF_UNIX)
                 self.assertIn(conn.type, (SOCK_STREAM, SOCK_DGRAM))
示例#13
0
 def test_count(self):
     with create_sockets():
         # tcp
         cons = thisproc.connections(kind='tcp')
         self.assertEqual(len(cons), 2 if supports_ipv6() else 1)
         for conn in cons:
             self.assertIn(conn.family, (AF_INET, AF_INET6))
             self.assertEqual(conn.type, SOCK_STREAM)
         # tcp4
         cons = thisproc.connections(kind='tcp4')
         self.assertEqual(len(cons), 1)
         self.assertEqual(cons[0].family, AF_INET)
         self.assertEqual(cons[0].type, SOCK_STREAM)
         # tcp6
         if supports_ipv6():
             cons = thisproc.connections(kind='tcp6')
             self.assertEqual(len(cons), 1)
             self.assertEqual(cons[0].family, AF_INET6)
             self.assertEqual(cons[0].type, SOCK_STREAM)
         # udp
         cons = thisproc.connections(kind='udp')
         self.assertEqual(len(cons), 2 if supports_ipv6() else 1)
         for conn in cons:
             self.assertIn(conn.family, (AF_INET, AF_INET6))
             self.assertEqual(conn.type, SOCK_DGRAM)
         # udp4
         cons = thisproc.connections(kind='udp4')
         self.assertEqual(len(cons), 1)
         self.assertEqual(cons[0].family, AF_INET)
         self.assertEqual(cons[0].type, SOCK_DGRAM)
         # udp6
         if supports_ipv6():
             cons = thisproc.connections(kind='udp6')
             self.assertEqual(len(cons), 1)
             self.assertEqual(cons[0].family, AF_INET6)
             self.assertEqual(cons[0].type, SOCK_DGRAM)
         # inet
         cons = thisproc.connections(kind='inet')
         self.assertEqual(len(cons), 4 if supports_ipv6() else 2)
         for conn in cons:
             self.assertIn(conn.family, (AF_INET, AF_INET6))
             self.assertIn(conn.type, (SOCK_STREAM, SOCK_DGRAM))
         # inet6
         if supports_ipv6():
             cons = thisproc.connections(kind='inet6')
             self.assertEqual(len(cons), 2)
             for conn in cons:
                 self.assertEqual(conn.family, AF_INET6)
                 self.assertIn(conn.type, (SOCK_STREAM, SOCK_DGRAM))
         # Skipped on BSD becayse by default the Python process
         # creates a UNIX socket to '/var/run/log'.
         if HAS_CONNECTIONS_UNIX and not (FREEBSD or NETBSD):
             cons = thisproc.connections(kind='unix')
             self.assertEqual(len(cons), 3)
             for conn in cons:
                 self.assertEqual(conn.family, AF_UNIX)
                 self.assertIn(conn.type, (SOCK_STREAM, SOCK_DGRAM))
示例#14
0
 def test_create_sockets(self):
     with create_sockets() as socks:
         fams = collections.defaultdict(int)
         types = collections.defaultdict(int)
         for s in socks:
             fams[s.family] += 1
             # work around http://bugs.python.org/issue30204
             types[s.getsockopt(socket.SOL_SOCKET, socket.SO_TYPE)] += 1
         self.assertGreaterEqual(fams[socket.AF_INET], 2)
         if supports_ipv6():
             self.assertGreaterEqual(fams[socket.AF_INET6], 2)
         if POSIX and HAS_CONNECTIONS_UNIX:
             self.assertGreaterEqual(fams[socket.AF_UNIX], 2)
         self.assertGreaterEqual(types[socket.SOCK_STREAM], 2)
         self.assertGreaterEqual(types[socket.SOCK_DGRAM], 2)
示例#15
0
 def test_create_sockets(self):
     with create_sockets() as socks:
         fams = collections.defaultdict(int)
         types = collections.defaultdict(int)
         for s in socks:
             fams[s.family] += 1
             # work around http://bugs.python.org/issue30204
             types[s.getsockopt(socket.SOL_SOCKET, socket.SO_TYPE)] += 1
         self.assertGreaterEqual(fams[socket.AF_INET], 2)
         if supports_ipv6():
             self.assertGreaterEqual(fams[socket.AF_INET6], 2)
         if POSIX and HAS_CONNECTIONS_UNIX:
             self.assertGreaterEqual(fams[socket.AF_UNIX], 2)
         self.assertGreaterEqual(types[socket.SOCK_STREAM], 2)
         self.assertGreaterEqual(types[socket.SOCK_DGRAM], 2)
示例#16
0
    def test_connections(self):
        def create_socket(family, type):
            sock = socket.socket(family, type)
            sock.bind(('', 0))
            if type == socket.SOCK_STREAM:
                sock.listen(1)
            return sock

        # Open as many socket types as possible so that we excercise
        # as many C code sections as possible.
        socks = []
        socks.append(create_socket(socket.AF_INET, socket.SOCK_STREAM))
        socks.append(create_socket(socket.AF_INET, socket.SOCK_DGRAM))
        if supports_ipv6():
            socks.append(create_socket(socket.AF_INET6, socket.SOCK_STREAM))
            socks.append(create_socket(socket.AF_INET6, socket.SOCK_DGRAM))
        if POSIX and not SUNOS:  # TODO: SunOS
            name1 = unix_socket_path().__enter__()
            name2 = unix_socket_path().__enter__()
            s1, s2 = unix_socketpair(name1)
            s3 = bind_unix_socket(name2, type=socket.SOCK_DGRAM)
            self.addCleanup(safe_rmpath, name1)
            self.addCleanup(safe_rmpath, name2)
            for s in (s1, s2, s3):
                socks.append(s)

        # TODO: UNIX sockets are temporarily implemented by parsing
        # 'pfiles' cmd  output; we don't want that part of the code to
        # be executed.
        kind = 'inet' if SUNOS else 'all'
        # Make sure we did a proper setup.
        self.assertEqual(
            len(psutil.Process().connections(kind=kind)), len(socks))
        try:
            self.execute(self.proc.connections, kind)
        finally:
            for s in socks:
                s.close()
示例#17
0
    def test_combos(self):
        def check_conn(proc, conn, family, type, laddr, raddr, status, kinds):
            all_kinds = ("all", "inet", "inet4", "inet6", "tcp", "tcp4",
                         "tcp6", "udp", "udp4", "udp6")
            self.check_connection_ntuple(conn)
            self.assertEqual(conn.family, family)
            self.assertEqual(conn.type, type)
            self.assertEqual(conn.laddr, laddr)
            self.assertEqual(conn.raddr, raddr)
            self.assertEqual(conn.status, status)
            for kind in all_kinds:
                cons = proc.connections(kind=kind)
                if kind in kinds:
                    assert cons
                else:
                    assert not cons, cons
            # compare against system-wide connections
            # XXX Solaris can't retrieve system-wide UNIX
            # sockets.
            if HAS_CONNECTIONS_UNIX:
                self.compare_procsys_connections(proc.pid, [conn])

        tcp_template = textwrap.dedent("""
            import socket, time
            s = socket.socket($family, socket.SOCK_STREAM)
            s.bind(('$addr', 0))
            s.listen(5)
            with open('$testfn', 'w') as f:
                f.write(str(s.getsockname()[:2]))
            time.sleep(60)
        """)

        udp_template = textwrap.dedent("""
            import socket, time
            s = socket.socket($family, socket.SOCK_DGRAM)
            s.bind(('$addr', 0))
            with open('$testfn', 'w') as f:
                f.write(str(s.getsockname()[:2]))
            time.sleep(60)
        """)

        # must be relative on Windows
        testfile = os.path.basename(self.get_testfn(dir=os.getcwd()))
        tcp4_template = string.Template(tcp_template).substitute(
            family=int(AF_INET), addr="127.0.0.1", testfn=testfile)
        udp4_template = string.Template(udp_template).substitute(
            family=int(AF_INET), addr="127.0.0.1", testfn=testfile)
        tcp6_template = string.Template(tcp_template).substitute(
            family=int(AF_INET6), addr="::1", testfn=testfile)
        udp6_template = string.Template(udp_template).substitute(
            family=int(AF_INET6), addr="::1", testfn=testfile)

        # launch various subprocess instantiating a socket of various
        # families and types to enrich psutil results
        tcp4_proc = self.pyrun(tcp4_template)
        tcp4_addr = eval(wait_for_file(testfile))
        udp4_proc = self.pyrun(udp4_template)
        udp4_addr = eval(wait_for_file(testfile))
        if supports_ipv6():
            tcp6_proc = self.pyrun(tcp6_template)
            tcp6_addr = eval(wait_for_file(testfile))
            udp6_proc = self.pyrun(udp6_template)
            udp6_addr = eval(wait_for_file(testfile))
        else:
            tcp6_proc = None
            udp6_proc = None
            tcp6_addr = None
            udp6_addr = None

        for p in thisproc.children():
            cons = p.connections()
            self.assertEqual(len(cons), 1)
            for conn in cons:
                # TCP v4
                if p.pid == tcp4_proc.pid:
                    check_conn(p, conn, AF_INET, SOCK_STREAM, tcp4_addr, (),
                               psutil.CONN_LISTEN,
                               ("all", "inet", "inet4", "tcp", "tcp4"))
                # UDP v4
                elif p.pid == udp4_proc.pid:
                    check_conn(p, conn, AF_INET, SOCK_DGRAM, udp4_addr, (),
                               psutil.CONN_NONE,
                               ("all", "inet", "inet4", "udp", "udp4"))
                # TCP v6
                elif p.pid == getattr(tcp6_proc, "pid", None):
                    check_conn(p, conn, AF_INET6, SOCK_STREAM, tcp6_addr, (),
                               psutil.CONN_LISTEN,
                               ("all", "inet", "inet6", "tcp", "tcp6"))
                # UDP v6
                elif p.pid == getattr(udp6_proc, "pid", None):
                    check_conn(p, conn, AF_INET6, SOCK_DGRAM, udp6_addr, (),
                               psutil.CONN_NONE,
                               ("all", "inet", "inet6", "udp", "udp6"))
示例#18
0
class TestUnconnectedSockets(_ConnTestCase):
    """Tests sockets which are open but not connected to anything."""
    def get_conn_from_sock(self, sock):
        cons = thisproc.connections(kind='all')
        smap = dict([(c.fd, c) for c in cons])
        if NETBSD or FREEBSD:
            # NetBSD opens a UNIX socket to /var/log/run
            # so there may be more connections.
            return smap[sock.fileno()]
        else:
            self.assertEqual(len(cons), 1)
            if cons[0].fd != -1:
                self.assertEqual(smap[sock.fileno()].fd, sock.fileno())
            return cons[0]

    def check_socket(self, sock):
        """Given a socket, makes sure it matches the one obtained
        via psutil. It assumes this process created one connection
        only (the one supposed to be checked).
        """
        conn = self.get_conn_from_sock(sock)
        self.check_connection_ntuple(conn)

        # fd, family, type
        if conn.fd != -1:
            self.assertEqual(conn.fd, sock.fileno())
        self.assertEqual(conn.family, sock.family)
        # see: http://bugs.python.org/issue30204
        self.assertEqual(conn.type,
                         sock.getsockopt(socket.SOL_SOCKET, socket.SO_TYPE))

        # local address
        laddr = sock.getsockname()
        if not laddr and PY3 and isinstance(laddr, bytes):
            # See: http://bugs.python.org/issue30205
            laddr = laddr.decode()
        if sock.family == AF_INET6:
            laddr = laddr[:2]
        if sock.family == AF_UNIX and OPENBSD:
            # No addresses are set for UNIX sockets on OpenBSD.
            pass
        else:
            self.assertEqual(conn.laddr, laddr)

        # XXX Solaris can't retrieve system-wide UNIX sockets
        if sock.family == AF_UNIX and HAS_CONNECTIONS_UNIX:
            cons = thisproc.connections(kind='all')
            self.compare_procsys_connections(os.getpid(), cons, kind='all')
        return conn

    def test_tcp_v4(self):
        addr = ("127.0.0.1", get_free_port())
        with closing(bind_socket(AF_INET, SOCK_STREAM, addr=addr)) as sock:
            conn = self.check_socket(sock)
            assert not conn.raddr
            self.assertEqual(conn.status, psutil.CONN_LISTEN)

    @unittest.skipIf(not supports_ipv6(), "IPv6 not supported")
    def test_tcp_v6(self):
        addr = ("::1", get_free_port())
        with closing(bind_socket(AF_INET6, SOCK_STREAM, addr=addr)) as sock:
            conn = self.check_socket(sock)
            assert not conn.raddr
            self.assertEqual(conn.status, psutil.CONN_LISTEN)

    def test_udp_v4(self):
        addr = ("127.0.0.1", get_free_port())
        with closing(bind_socket(AF_INET, SOCK_DGRAM, addr=addr)) as sock:
            conn = self.check_socket(sock)
            assert not conn.raddr
            self.assertEqual(conn.status, psutil.CONN_NONE)

    @unittest.skipIf(not supports_ipv6(), "IPv6 not supported")
    def test_udp_v6(self):
        addr = ("::1", get_free_port())
        with closing(bind_socket(AF_INET6, SOCK_DGRAM, addr=addr)) as sock:
            conn = self.check_socket(sock)
            assert not conn.raddr
            self.assertEqual(conn.status, psutil.CONN_NONE)

    @unittest.skipIf(not POSIX, 'POSIX only')
    def test_unix_tcp(self):
        testfn = self.get_testfn()
        with closing(bind_unix_socket(testfn, type=SOCK_STREAM)) as sock:
            conn = self.check_socket(sock)
            assert not conn.raddr
            self.assertEqual(conn.status, psutil.CONN_NONE)

    @unittest.skipIf(not POSIX, 'POSIX only')
    def test_unix_udp(self):
        testfn = self.get_testfn()
        with closing(bind_unix_socket(testfn, type=SOCK_STREAM)) as sock:
            conn = self.check_socket(sock)
            assert not conn.raddr
            self.assertEqual(conn.status, psutil.CONN_NONE)
示例#19
0
    def test_combos(self):
        def check_conn(proc, conn, family, type, laddr, raddr, status, kinds):
            all_kinds = ("all", "inet", "inet4", "inet6", "tcp", "tcp4",
                         "tcp6", "udp", "udp4", "udp6")
            check_connection_ntuple(conn)
            self.assertEqual(conn.family, family)
            self.assertEqual(conn.type, type)
            self.assertEqual(conn.laddr, laddr)
            self.assertEqual(conn.raddr, raddr)
            self.assertEqual(conn.status, status)
            for kind in all_kinds:
                cons = proc.connections(kind=kind)
                if kind in kinds:
                    assert cons
                else:
                    assert not cons, cons
            # compare against system-wide connections
            # XXX Solaris can't retrieve system-wide UNIX
            # sockets.
            if HAS_CONNECTIONS_UNIX:
                self.compare_procsys_connections(proc.pid, [conn])

        tcp_template = textwrap.dedent("""
            import socket, time
            s = socket.socket($family, socket.SOCK_STREAM)
            s.bind(('$addr', 0))
            s.listen(1)
            with open('$testfn', 'w') as f:
                f.write(str(s.getsockname()[:2]))
            time.sleep(60)
        """)

        udp_template = textwrap.dedent("""
            import socket, time
            s = socket.socket($family, socket.SOCK_DGRAM)
            s.bind(('$addr', 0))
            with open('$testfn', 'w') as f:
                f.write(str(s.getsockname()[:2]))
            time.sleep(60)
        """)

        from string import Template
        testfile = os.path.basename(TESTFN)
        tcp4_template = Template(tcp_template).substitute(
            family=int(AF_INET), addr="127.0.0.1", testfn=testfile)
        udp4_template = Template(udp_template).substitute(
            family=int(AF_INET), addr="127.0.0.1", testfn=testfile)
        tcp6_template = Template(tcp_template).substitute(
            family=int(AF_INET6), addr="::1", testfn=testfile)
        udp6_template = Template(udp_template).substitute(
            family=int(AF_INET6), addr="::1", testfn=testfile)

        # launch various subprocess instantiating a socket of various
        # families and types to enrich psutil results
        tcp4_proc = pyrun(tcp4_template)
        tcp4_addr = eval(wait_for_file(testfile))
        udp4_proc = pyrun(udp4_template)
        udp4_addr = eval(wait_for_file(testfile))
        if supports_ipv6():
            tcp6_proc = pyrun(tcp6_template)
            tcp6_addr = eval(wait_for_file(testfile))
            udp6_proc = pyrun(udp6_template)
            udp6_addr = eval(wait_for_file(testfile))
        else:
            tcp6_proc = None
            udp6_proc = None
            tcp6_addr = None
            udp6_addr = None

        for p in thisproc.children():
            cons = p.connections()
            self.assertEqual(len(cons), 1)
            for conn in cons:
                # TCP v4
                if p.pid == tcp4_proc.pid:
                    check_conn(p, conn, AF_INET, SOCK_STREAM, tcp4_addr, (),
                               psutil.CONN_LISTEN,
                               ("all", "inet", "inet4", "tcp", "tcp4"))
                # UDP v4
                elif p.pid == udp4_proc.pid:
                    check_conn(p, conn, AF_INET, SOCK_DGRAM, udp4_addr, (),
                               psutil.CONN_NONE,
                               ("all", "inet", "inet4", "udp", "udp4"))
                # TCP v6
                elif p.pid == getattr(tcp6_proc, "pid", None):
                    check_conn(p, conn, AF_INET6, SOCK_STREAM, tcp6_addr, (),
                               psutil.CONN_LISTEN,
                               ("all", "inet", "inet6", "tcp", "tcp6"))
                # UDP v6
                elif p.pid == getattr(udp6_proc, "pid", None):
                    check_conn(p, conn, AF_INET6, SOCK_DGRAM, udp6_addr, (),
                               psutil.CONN_NONE,
                               ("all", "inet", "inet6", "udp", "udp6"))

        # err
        self.assertRaises(ValueError, p.connections, kind='???')