def sockfam_to_enum(num): """Convert a numeric socket family value to an IntEnum member. If it's not a known member, return the numeric value itself. """ if enum is None: return num else: # pragma: no cover try: return socket.AddressFamily(num) except (ValueError, AttributeError): return num
def pid_connections(pid: int, kind: str) -> Iterator[Connection]: allowed_combos = _util.conn_kind_to_combos(kind) if not allowed_combos: return kfiles = { kfile.ki_fdata: (kfile.ki_pid, kfile.ki_fd) for kfile in _list_kinfo_files(pid) if kfile.ki_fd >= 0 and kfile.ki_ftype == DTYPE_SOCKET } if not kfiles: return for (family, stype) in allowed_combos: base_mib = _bsd.sysctlnametomib( "net.{}.pcblist".format(_SOCK_TYPES[family][stype]), maxlen=4, ) mib = [ *base_mib, PCB_ALL, 0, ctypes.sizeof(KinfoPcb), 1000000, ] kinfo_pcb_data = _bsd.sysctl_bytes_retry(mib, None) for kpcb in (KinfoPcb * (len(kinfo_pcb_data) // ctypes.sizeof(KinfoPcb)) ).from_buffer_copy(kinfo_pcb_data): try: pid, fd = kfiles.pop(kpcb.ki_sockaddr) except KeyError: continue yield Connection( family=socket.AddressFamily(kpcb.ki_family), # pylint: disable=no-member type=socket.SocketKind(kpcb.ki_type), # pylint: disable=no-member laddr=kpcb.ki_s.to_addr(kpcb.ki_family), raddr=kpcb.ki_d.to_addr(kpcb.ki_family), status=(_TCP_STATES[kpcb.ki_tstate] if kpcb.ki_type == socket.SOCK_STREAM and kpcb.ki_family != socket.AF_UNIX else None), fd=fd, pid=pid, ) if not kfiles: return
def __init__( self, family: socket.AddressFamily, address: Tuple[HostAddress, int], timeout: float, encryption_settings: Dict[str, str], ): # type (...) -> None super(TCPDataFetcher, self).__init__() self._family = socket.AddressFamily(family) self._address = address self._timeout = timeout self._encryption_settings = encryption_settings self._logger = logging.getLogger("cmk.fetchers.tcp") self._socket: Optional[socket.socket] = None
def __init__( self, file_cache: AgentFileCache, family: socket.AddressFamily, address: Tuple[HostAddress, int], timeout: float, encryption_settings: Dict[str, str], ) -> None: super().__init__(file_cache, logging.getLogger("cmk.fetchers.tcp")) self._family = socket.AddressFamily(family) # json has no builtin tuple, we have to convert self._address = tuple(address) if isinstance(address, list) else address self._timeout = timeout self._encryption_settings = encryption_settings self._socket: Optional[socket.socket] = None
def sessions(self, filters=None, options=None): """ Get currently open websocket sessions. """ return filter_list([{ 'id': i.session_id, 'socket_type': socket.AddressFamily( i.request.transport.get_extra_info('socket').family).name, 'address': i.request.transport.get_extra_info('sockname'), 'authenticated': i.authenticated, 'call_count': i._softhardsemaphore.counter, } for i in self.middleware.get_wsclients().values()], filters, options)
def sessions(self, filters=None, options=None): """ Get currently open websocket sessions. """ return filter_list([{ 'id': i.session_id, 'socket_family': socket.AddressFamily( i.request.transport.get_extra_info('socket').family).name, 'address': ((i.request.headers.get('X-Real-Remote-Addr'), i.request.headers.get('X-Real-Remote-Port')) if i.request.headers.get('X-Real-Remote-Addr') else (i.request.transport.get_extra_info("peername"))), 'authenticated': i.authenticated, 'call_count': i._softhardsemaphore.counter, } for i in self.middleware.get_wsclients().values()], filters, options)
def __init__( self, file_cache: DefaultAgentFileCache, *, family: socket.AddressFamily, address: Tuple[Optional[HostAddress], int], timeout: float, encryption_settings: Mapping[str, str], use_only_cache: bool, ) -> None: super().__init__(file_cache, logging.getLogger("cmk.fetchers.tcp")) self.family: Final = socket.AddressFamily(family) # json has no builtin tuple, we have to convert assert address[0] is not None self.address: Final[Tuple[HostAddress, int]] = (address[0], address[1]) self.timeout: Final = timeout self.encryption_settings: Final = encryption_settings self.use_only_cache: Final = use_only_cache self._socket: Optional[socket.socket] = None
def __init__( self, file_cache: AgentFileCache, *, family: socket.AddressFamily, address: Tuple[Optional[HostAddress], int], timeout: float, host_name: HostName, encryption_settings: Mapping[str, str], ) -> None: super().__init__(file_cache, logging.getLogger("cmk.helper.tcp")) self.family: Final = socket.AddressFamily(family) # json has no builtin tuple, we have to convert self.address: Final[Tuple[Optional[HostAddress], int]] = (address[0], address[1]) self.timeout: Final = timeout self.host_name: Final = host_name self.encryption_settings: Final = encryption_settings self._opt_socket: Optional[socket.socket] = None
async def test_tunnel_rule(): rule = conf.TunnelRule({ "id": "test", "priority": 100, "addr": "*.baidu.com;www.qq.com", "port": "80;443;5555-5566", "tunnel": "web", }) assert rule.id == "test" assert rule.priority == 100 with patch("socket.getaddrinfo") as mocked_getaddrinfo: mocked_getaddrinfo.side_effect = lambda *args: [(socket.AddressFamily( 2), ("1.1.1.1", 0))] assert await rule.is_hit(("www.baidu.com", 80)) == True assert await rule.is_hit(("baidu.com", 80)) == False assert await rule.is_hit(("www.baidu.com", 801)) == False assert await rule.is_hit(("www.qq.com", 443)) == True assert await rule.is_hit(("www.qq.com", 5555)) == True assert await rule.is_hit(("www.qq.com", 5566)) == True assert await rule.is_hit(("www.qq.com", 5567)) == False assert await rule.is_hit(("wwww.qq.com", 5555)) == False
import os import aenum import socket import asyncio as aio import ctypes as ct class sockaddr_un(ct.Structure): _fields_ = [("sun_family", ct.c_ushort), ("sun_path", ct.c_char * 108)] aenum.extend_enum(socket.AddressFamily, "AF_UNIX", 1) AF_UNIX = socket.AddressFamily(1) NULL = 0 def iocp_connect(proactor, conn, address): # _overlapped.WSAConnect(conn.fileno(), address) addr = sockaddr_un(AF_UNIX.value, address.encode() + b"\0") winsock = ct.windll.ws2_32 winsock.connect(conn.fileno(), addr, 110) fut = proactor._loop.create_future() fut.set_result(None) return fut async def create_unix_connection(loop, protocol_factory, path=None, *,
def __init__(self, log_ts, start_ts, hb): self._log_timestamp = log_ts # timestamp when the logevent occurred on the test system self._sut_timestamp = hb[ 'ts'] # timestamp of the event on the system under test self._sut_start_ts = start_ts self._pid = hb[ 'pid'] # TODO: should never change, still required here? # self._process_name = hb['name'] # should never change self._status = hb['status'] # self._username = hb['username'] # should never change self._cpu_percent = hb['cpu_percent'] self._mem_percent = hb['memory_percent'] self._num_threads = hb['num_threads'] self._num_fds = hb['num_fds'] # network connections # https://psutil.readthedocs.io/en/latest/#psutil.Process.connections self._connections = list() for con in hb['connections']: fd = con[0] # fix: psutils encodes AF_INET6 with 10, corresponds with 30 in socket.AddressFamily af_inet_idx = con[1] if (con[1] != 10) else 30 address_family = socket.AddressFamily(af_inet_idx).name socket_kind = socket.SocketKind(con[2]).name listen_addr = con[3] if len(listen_addr) > 0: laddr = {'ip': listen_addr[0], 'port': listen_addr[1]} else: laddr = {'ip': '', 'port': ''} remote_addr = con[4] if len(remote_addr) > 0: raddr = {'ip': remote_addr[0], 'port': remote_addr[1]} else: raddr = {'ip': '', 'port': ''} status = con[5] con_dict = { 'fd': fd, 'family': address_family, 'type': socket_kind, 'laddr': laddr, 'raddr': raddr, 'status': status } self._connections.append(con_dict) # Memory consumption # https://psutil.readthedocs.io/en/latest/#psutil.Process.memory_full_info # http://grodola.blogspot.com/2016/02/psutil-4-real-process-memory-and-environ.html mem_info = hb['memory_info'] mem_rss = mem_info[0] / (1024 * 1024) mem_vms = mem_info[1] / (1024 * 1024) mem_shared = mem_info[2] / (1024 * 1024) mem_text = mem_info[3] / (1024 * 1024) mem_lib = mem_info[4] / (1024 * 1024) mem_data = mem_info[5] / (1024 * 1024) mem_dirty = mem_info[6] / (1024 * 1024) self._memory = { 'rss': mem_rss, 'vms': mem_vms, 'shared': mem_shared, 'text': mem_text, 'lib': mem_lib, 'data': mem_data, 'dirty': mem_dirty } # I/O # https://psutil.readthedocs.io/en/latest/#psutil.Process.io_counters io_counters = hb['io_counters'] io_read_count = io_counters[0] io_write_count = io_counters[1] io_read_chars = io_counters[4] # bytes read via syscalls io_write_chars = io_counters[5] # bytes written via syscalls self._io_counters = { 'read_count': io_read_count, 'write_count': io_write_count, 'read_chars': io_read_chars, 'write_chars': io_write_chars } # CPU times # https://psutil.readthedocs.io/en/latest/#psutil.Process.cpu_times cpu_times = hb['cpu_times'] self._cpu_times = { 'user': cpu_times[0], 'system': cpu_times[1], 'children_user': cpu_times[2], 'children_system': cpu_times[3] } # Context switches # https://psutil.readthedocs.io/en/latest/#psutil.Process.num_ctx_switches ctx_switches = hb['num_ctx_switches'] self._ctx_switches = { 'voluntary': ctx_switches[0], 'involuntary': ctx_switches[1] } # Open files # https://psutil.readthedocs.io/en/latest/#psutil.Process.open_files open_files = hb['open_files'] self._open_files = list() for f in open_files: self._open_files.append({ 'path': f[0], 'fd': f[1], 'pos': f[2], 'mode': f[3], 'flags': f[4] })