def get_free_port(address: str, initial_port: int): """Find an unused TCP port in a specified range. This should not be used in misson-critical applications - a race condition may occur if someone grabs the port before caller of this function has chance to use it. Parameters: address : an ip address of interface to use initial_port : port to start iteration with Return: Iterator that will return next unused port on a specified interface """ try: # On OSX this function requires root privileges psutil.net_connections() except psutil.AccessDenied: return count(initial_port) def _unused_ports(): for port in count(initial_port): # check if the port is being used connect_using_port = ( conn for conn in psutil.net_connections() if hasattr(conn, 'laddr') and conn.laddr[0] == address and conn.laddr[1] == port ) # only generate unused ports if not any(connect_using_port): yield port return _unused_ports()
def get_procinfo_by_address(ip_src, ip_dst, port_src=None, port_dst=None): """ Gets Infos about the Prozess associated with the given address information Both port_src and port_dst must be not None or None at the same time. return -- [pid, "/path/to/command", "user", "hash"] or [] """ result = [] if port_src is not None: pids = [c.pid for c in net_connections() if len(c.raddr) != 0 and c.pid is not None and (c.laddr[0], c.raddr[0], c.laddr[1], c.raddr[1]) == (ip_src, ip_dst, port_src, port_dst)] else: pids = [c.pid for c in net_connections() if len(c.raddr) != 0 and c.pid is not None and (c.laddr[0], c.raddr[0]) == (ip_src, ip_dst)] try: if len(pids) > 1: logger.warning("more than 1 matching process: %r", pids) proc = Process(pids[0]) cmd = [pids[0], proc.cmdline(), proc.username()] hash_input = "%d%s%s" % (cmd[0], cmd[1], cmd[2]) procinfo_hash = hashlib.sha256(hash_input.encode("UTF-8")) cmd.append(procinfo_hash) logger.debug("process info: %r", cmd) return cmd except IndexError: pass return []
def test_connections_ipv6_not_supported(self, supports_ipv6, inet_ntop): # see: https://github.com/giampaolo/psutil/issues/623 try: s = socket.socket(socket.AF_INET6, socket.SOCK_STREAM) self.addCleanup(s.close) s.bind(("::1", 0)) except socket.error: pass psutil.net_connections(kind='inet6')
def __init__(self, cpu=None, users=None, mem=None, listen=None, remote=None, idle=None): if cpu is None: try: self.cpu = int(psutil.cpu_percent()) except: self.cpu = 0 else: self.cpu = int(cpu) if users is None: try: self.users = len(set([ x.name for x in psutil.users()])) except: self.users = 0 else: self.users = int(users) if self.users > 255: self.users = 255 if mem is None: try: self.mem = int(psutil.virtual_memory().percent) except: self.mem = 0 else: self.mem = int(mem) if listen is None: try: self.listen = len(set([ x.laddr[1] for x in psutil.net_connections() if x.status=='LISTEN' ])) except: self.listen = 0 else: self.listen = int(listen) if self.listen > 255: self.listen = 255 if remote is None: try: self.remote = len(set([ x.raddr for x in psutil.net_connections() \ if x.status=='ESTABLISHED' and x.raddr[0] not in ( '127.0.0.1', '::ffff:127.0.0.1' ) ])) except Exception, e: self.remote = 0
def histout(self): connections_A = net_connections() for c in connections_A: self.process_conn(c) while True: sleep(self.interval) connections_B = net_connections() for c in connections_B: if c not in connections_A: self.process_conn(c) connections_A = connections_B
def fetch_pid(port): assert isinstance(port, int) for c in psutil.net_connections(kind='udp'): # if not c.raddr and c.laddr == ('0.0.0.0', port): if c.raddr in ((), ('127.0.0.1', 53)) \ and c.laddr in (('0.0.0.0', port), ('127.0.0.1', port)): return c.pid log.error('No pid found %d', port) for c in psutil.net_connections(kind='udp'): if c.pid: name = fetch_process_name(c.pid) log.error('repr %r name %s', c, name) else: log.error('repr %r', c)
def connections(): ''' Return a JSON object with number of connections on a port. ''' current_app.logger.debug("Getting active connections.") if request.method == 'OPTIONS': return cors_answer_options() active = 0 # Get connections on port 80 conn = psutil.net_connections('inet') if current_app.config['PORT'][0] == 'all': current_app.logger.debug("Counting all active connections.") for connection in conn: active += 1 else: for port in current_app.config['PORT']: current_app.logger.debug("Counting connections on port: " + port + ".") for connection in conn: if connection.laddr[1] == int(port): active += 1 # Return JSON current_app.logger.debug("Connections: " + str(active)) return add_cors_headers(jsonify(connections=active))
def listProcesses(devices): # dear god this is hackish devices["0.0.0.0"] = "lo" devices["127.0.1.1"] = "lo" devices["::"] = "lo" devices["::1"] = "lo" import psutil la = psutil.net_connections() retval = [] for i in la: #### # # The IP and port are stored as a tuple in the psutil._common.sconn namedtouple at # psutil._common.sconn[3] with the IP at [0] and the port at [1] # # The PID is stored at psutil._common.sconn[6] # ## # print i[3][0] + " " + str(i[3][1]) # procs.append([i[3][0], str(i[3][1])]) #### if i[6] is not None: retval.append((i[6], devices[i[3][0]])) # God, I am so sorry. I can feel my Data Structures prof judging me from somewhere # ... among other people... return list(set(retval))
def net_connect_info(self): ''' Note: Get system network connections. net_connect_dict: :return: dict type { 'fd':values, 'family':values, 'type':values, 'laddr':values, # It's tuple 'raddr':values, # It's tuple 'status':values, 'pid':values } ''' flag = 0 net_connect_dict = defaultdict(list) net_connect = psutil.net_connections() for i in net_connect: net_connect_dict[flag].append(i.fd) net_connect_dict[flag].append(i.family) net_connect_dict[flag].append(i.type) net_connect_dict[flag].append(i.laddr) net_connect_dict[flag].append(i.raddr) net_connect_dict[flag].append(i.status) net_connect_dict[flag].append(i.pid) flag += 1 return net_connect_dict
def collect_connections(self): try: results = { 'connections/tcp4': len(psutil.net_connections("tcp4")), 'connections/tcp6': len(psutil.net_connections("tcp6")), 'connections/udp4': len(psutil.net_connections("udp4")), 'connections/udp6': len(psutil.net_connections("udp6")), 'connections/unix': len(psutil.net_connections("unix")) } results['connections/total'] = (results['connections/unix'] + results['connections/udp6'] + results['connections/udp4'] + results['connections/tcp4'] + results['connections/tcp6']) return results except psutil.AccessDenied: # BSD / OSX needs root access for that return {}
def refreshconnections(self): current_layout_lock.acquire() if(self.sourcemodel.current_layout != "conn"): print ("refreshconnections error") current_layout_lock.release() return self.sourcemodel.layoutAboutToBeChanged.emit() self.sourcemodel.removeRows(0, self.sourcemodel.rowCount()) for conn in psutil.net_connections("inet4"): if(conn.type == socket.SOCK_STREAM): proto = QStandardItem("tcp") else: proto = QStandardItem("udp") laddr = QStandardItem(conn.laddr[0]) lport = QStandardItem(str(conn.laddr[1])) if(len(conn.raddr) == 0): continue raddr = QStandardItem(conn.raddr[0]) rport = QStandardItem(str(conn.raddr[1])) status = QStandardItem(conn.status) pid = QStandardItem(str(conn.pid)) if(conn.pid != None): p = psutil.Process(conn.pid) name = QStandardItem(p.name()) else: name = QStandardItem("None") family = QStandardItem("ipv4") self.sourcemodel.appendRow( (family, proto, laddr, lport, raddr, rport, status, pid, name)) self.sourcemodel.layoutChanged.emit() current_layout_lock.release()
def get_connections(self): my_connections = psutil.net_connections() conn_len = len(my_connections) connections_list = [] for i in range(0, conn_len): if my_connections[i].status == 'ESTABLISHED' and \ my_connections[i].laddr[0] <> '0.0.0.0' and \ (not '::' in my_connections[i].laddr[0] or not '::' in my_connections[i].raddr[0]) and \ (len(my_connections[i].laddr[0]) <= 16): try: conn_loc_address = my_connections[i].laddr[0] conn_loc_port = my_connections[i].laddr[1] except Exception: conn_loc_address = 'FAIL' conn_loc_port = 'FAIL' try: conn_rem_address = my_connections[i].raddr[0] conn_rem_port = my_connections[i].raddr[1] except Exception: conn_rem_address = 'FAIL' conn_rem_port = 'FAIL' conn_family = my_connections[i].family conn_status = my_connections[i].status connections_list.append((conn_loc_address,conn_loc_port,conn_rem_address,conn_rem_port,conn_family,conn_status)) connections_list.sort() return {'LIST': connections_list, 'CONNECTIONS':len(connections_list)}
def already_listening(port, renewer=False): """Check if a process is already listening on the port. If so, also tell the user via a display notification. .. warning:: On some operating systems, this function can only usefully be run as root. :param int port: The TCP port in question. :returns: True or False. """ try: net_connections = psutil.net_connections() except psutil.AccessDenied as error: logger.info("Access denied when trying to list network " "connections: %s. Are you root?", error) # this function is just a pre-check that often causes false # positives and problems in testing (c.f. #680 on Mac, #255 # generally); we will fail later in bind() anyway return False listeners = [conn.pid for conn in net_connections if conn.status == 'LISTEN' and conn.type == socket.SOCK_STREAM and conn.laddr[1] == port] try: if listeners and listeners[0] is not None: # conn.pid may be None if the current process doesn't have # permission to identify the listening process! Additionally, # listeners may have more than one element if separate # sockets have bound the same port on separate interfaces. # We currently only have UI to notify the user about one # of them at a time. pid = listeners[0] name = psutil.Process(pid).name() display = zope.component.getUtility(interfaces.IDisplay) extra = "" if renewer: extra = ( " For automated renewal, you may want to use a script that stops" " and starts your webserver. You can find an example at" " https://letsencrypt.org/howitworks/#writing-your-own-renewal-script" ". Alternatively you can use the webroot plugin to renew without" " needing to stop and start your webserver.") display.notification( "The program {0} (process ID {1}) is already listening " "on TCP port {2}. This will prevent us from binding to " "that port. Please stop the {0} program temporarily " "and then try again.{3}".format(name, pid, port, extra), height=13) return True except (psutil.NoSuchProcess, psutil.AccessDenied): # Perhaps the result of a race where the process could have # exited or relinquished the port (NoSuchProcess), or the result # of an OS policy where we're not allowed to look up the process # name (AccessDenied). pass return False
def fetch(db): counted = 0 connections = psutil.net_connections(kind="inet4") listening = set([connection.laddr[1] for connection in connections if connection.status == psutil.CONN_LISTEN]) for connection in connections: if connection.status in (psutil.CONN_NONE, psutil.CONN_LISTEN): continue local_host, local_port = connection.laddr if local_port in listening: continue # ignore incoming connections completely source = connection.laddr target = connection.raddr try: source_host = source[0] target_host = target[0] if source_host in ("127.0.0.1") or target_host in ("127.0.0.1"): continue db.count(" ".join([source_host, target_host, str(target[1])])) counted += 1 except: print("ERROR parsing: %s" % str(connection)) raise print("%i connections counted" % counted)
def main(): hostname = getfqdn() data = '' for k, v in psutil.cpu_times_percent(interval=0.5)._asdict().iteritems(): data += '{0}.cpu.{1} value={2}\n'.format(hostname, k, v) for k, v in psutil.virtual_memory()._asdict().iteritems(): data += '{0}.mem.{1} value={2}\n'.format(hostname, k, v) for k, v in psutil.swap_memory()._asdict().iteritems(): data += '{0}.swap.{1} value={2}\n'.format(hostname, k, v) du = { mp.mountpoint: psutil.disk_usage(mp.mountpoint).percent for mp in psutil.disk_partitions() } for k, v in du.iteritems(): data += '{0}.du_percent.{1} value={2}\n'.format(hostname, k, v) for k, v in psutil.disk_io_counters(perdisk=True).iteritems(): for m, p in v._asdict().iteritems(): data += '{0}.io.{1}.{2} value={3}\n'.format(hostname, k, m, p) for k, v in psutil.net_io_counters(pernic=True).iteritems(): for m, p in v._asdict().iteritems(): data += '{0}.net.{1}.{2} value={3}\n'.format(hostname, k, m, p) connections = map(lambda x: x.status.lower(), psutil.net_connections()) connections = map( lambda x: 'unknown_state' if x == 'none' else x, connections ) for conn in set(connections): data += '{0}.netstat.{1} value={2}\n'.format(hostname, conn, connections.count(conn)) if DEBUG: print data sendData(data)
def pidof(target): """pidof(target) -> int list Get PID(s) of `target`. The returned PID(s) depends on the type of `target`: - :class:`str`: PIDs of all processes with a name matching `target`. - :class:`pwnlib.tubes.process.process`: singleton list of the PID of `target`. - :class:`pwnlib.tubes.sock.sock`: singleton list of the PID at the remote end of `target` if it is running on the host. Otherwise an empty list. Arguments: target(object): The target whose PID(s) to find. Returns: A list of found PIDs. """ if isinstance(target, tubes.sock.sock): local = target.sock.getsockname() remote = target.sock.getpeername() def match(p): return (c.raddr, c.laddr, c.status) == (local, remote, 'ESTABLISHED') return [c.pid for c in psutil.net_connections() if match(c)] elif isinstance(target, tubes.process.process): return [target.proc.pid] else: return pid_by_name(target)
def network(): global netconns if not netconns: netconns = psutil.net_connections() if not netconns: return "Empty" result = netconns.pop() while result.laddr[0].startswith("::") or result.status == "NONE": result = netconns.pop() if result.status == "ESTABLISHED": return "{} {:16} {:16}".format( result.status[0], result.laddr[0]+":"+str(result.laddr[1]), result.raddr[0]+":"+str(result.raddr[1])) elif result.status == "LISTEN": if result.laddr[0] == "127.0.0.1": # We are not interested in local running services. return network() return "{} {:16} {:16}".format( result.status[0], result.laddr[0], "NA") else: return "ERROR IN network()"
def find_available_port(self, start=first_port): """Return the next available port at which a client may listen If module "psutil" is available, this also takes into account any externally used ports such that no occupied port is accidentally used. This is generally recommended. Arguments: start (int, optional): Port from which to start looking, defaults to 6001 """ print("Finding available port..") occupied_ports = list(self.app.clients) try: import psutil occupied_ports += list( c.laddr[-1] for c in psutil.net_connections()) except ImportError: pass available = start while available in occupied_ports: available += 1 print("Distributing new port %i" % available) return available
def get_pid(): """Format: info = {"192.168.1.244:37176 183.61.87.9:13034":"18277/chrome"} """ info = {} proc_names = {} proto_map = { (2, 1): 'tcp', (10, 1): 'tcp6', (2, 2): 'udp', (10, 2): 'udp6' } # get process name and pid for p in psutil.process_iter(): try: proc_names[p.pid] = p.name() except psutil.Error: pass for c in psutil.net_connections(): laddr = '%s:%s' % (c.laddr) raddr = '' if c.raddr: raddr = "%s:%s" % (c.raddr) if c.pid == None or raddr == '': continue info[laddr + " " + raddr] = proto_map.get((c.family, c.type)) + "/" + str(c.pid) + "/" + proc_names.get(c.pid) info[raddr + " " + laddr] = proto_map.get((c.family, c.type)) + "/" + str(c.pid) + "/" + proc_names.get(c.pid) return info
def check_BGP(): ''' Checks bgp.conf for up / down, and the sockets for v4 and v6 BGP established. Returns in the format of: bgp.status <time> <0|1> protocol=<IPv4|IPv6> ''' thyme = int(time.time()) v6_up = 0 v4_up = 0 proc_names = {} if os.readlink(BGP_CONF) != BGP_UP: print 'bgp.status %d %d protocol=IPv6' % (thyme, v6_up) print 'bgp.status %d %d protocol=IPv4' % (thyme, v4_up) else: for p in psutil.process_iter(): try: proc_names[p.pid] = p.name() except psutil.Error: pass for c in psutil.net_connections(kind='inet'): if c.raddr: if c.raddr[1] == PUERTO: if c.status == 'ESTABLISHED': if ':' in c.raddr[0]: v6_up = 1 else: v4_up = 1 else: continue else: continue else: continue print 'bgp.status %d %d protocol=IPv6' % (thyme, v6_up) print 'bgp.status %d %d protocol=IPv4' % (thyme, v4_up)
def test_find_available_port(): x = brozzler.chrome.Chrome(None, None) try: psutil.net_connections(kind='tcp') except psutil.AccessDenied: logging.warn( 'skipping _find_available_port() test because ' 'psutil.net_connections(kind="tcp") raised AccessDenied') return assert x._find_available_port(9800) == 9800 sock = socket.socket() sock.bind(('localhost', 9800)) sock.listen(0) assert x._find_available_port(9800) == 9999 sock.close() assert x._find_available_port(9800) == 9800
def test_net_connections(self): with unix_socket_path() as name: with closing(bind_unix_socket(name)): cons = psutil.net_connections(kind='unix') assert cons for conn in cons: self.assertIsInstance(conn.laddr, str)
def GET(self): PortList = { 'ErrStat' : 0, 'ErrMsg' : "OK", 'Lists' : [], 'Totle' : 0, } param = web.input() if param.has_key('Length') == False: ConfigData['ErrStat'] = -1 ConfigData['ErrMsg'] = u'缺少参数 param:Length=Length' return render.port_list(json.dumps(PortList)) if param.has_key('Start') == False: ConfigData['ErrStat'] = -1 ConfigData['ErrMsg'] = u'缺少参数 param:Start=Start' return render.port_list(json.dumps(PortList)) start = int(param['Start']) length = int(param['Length']) # 获取所有连接 Lists = [] cons = psutil.net_connections('inet') for c in cons: dic = {} if c.type == 1: dic['Type'] = 'TCP' elif c.type == 2: dic['Type'] = 'UDP' # sip sport if len(c.laddr) > 0: dic['Sip'] = c.laddr[0] dic['Sport'] = str(c.laddr[1]) else: dic['Sip'] = 'NULL' dic['Sport'] = '0' # dip dport if len(c.raddr) > 0: dic['Dip'] = c.raddr[0] dic['Dport'] = str(c.raddr[1]) else: dic['Dip'] = 'NULL' dic['Dport'] = '0' dic['Status'] = c.status dic['Pid'] = str(c.pid) #print c.raddr p = psutil.Process(c.pid) # name dic['Process'] = p.exe() # 加入数组 Lists.append(dic) # 排序 Lists.sort(CmpPid) PortList['Lists'] = Lists[start : start + length] PortList['Totle'] = len(Lists) return render.port_list(json.dumps(PortList))
def exposed_get_network(self): netifs = self.get_network_interface() netifs.sort(key=lambda x: x.get("bytes_sent"), reverse=True) conns = psutil.net_connections() conns.sort(key=lambda x: x.status) return pickle.dumps((netifs, conns))
def get_free_port(): # There is a potential for a race condition here, but I think it works ok in practice. port_used = True while port_used: port = random.randrange(4545, 9999) port_used = port in [x.laddr[1] for x in psutil.net_connections()] # noinspection PyUnboundLocalVariable return port
def get_network_info(self): conns = ps.net_connections() self.network['count'] = len(conns) count = 0 for conn in conns: if conn.status is 'ESTABLISHED': count = count + 1 self.network['established'] = count
def refresh_ports(): active_ports = [entry for entry in psutil.net_connections() if entry.status != 'NONE'] for item in self.__cached_ports.iteritems(): socc_obj = [entry for entry in active_ports if entry.laddr == (str(item[1].getsockname()[0]), item[0])] if not socc_obj: self.remove_port(item[0])
def get_net_port_counter(self, *args): port_counter = 0 for c in psutil.net_connections(kind='inet'): if c.status == "ESTABLISHED": if c.laddr[1] in args: port_counter += 1 return port_counter
def _find_process_name(port_number): """ Get the name of the process using the given port number. """ for connection in psutil.net_connections(): if connection.laddr[1] == port_number: return psutil.Process(connection.pid).name() return None
def __type_counter(self, pids): """ Build the STATE_DICT based on the number of connection types """ for p in psutil.net_connections(): if p.pid in pids: self.state_dict[p.status] += 1
def beacon(config): ''' Monitor the number of sockets open on the minion Specify thresholds for number of sockets and only emit a beacon if it is exceeded. .. code-block:: yaml beacons: network_sockets_open: sockets: 1 ''' try: num_conns = len(psutil.net_connections()) except Exception as err: log.error('{0}'.format(err[0])) exit(1) ret = [] if num_conns > config['sockets']: log.debug('{0}: {1}'.format(__virtualname__, num_conns)) ret.append({__virtualname__: num_conns}) return ret
def get_connections(self): my_connections = psutil.net_connections() conn_len = len(my_connections) connections_list = [] for i in range(0, conn_len): if my_connections[i].status == 'ESTABLISHED' and \ my_connections[i].laddr[0] <> '0.0.0.0' and \ (not '::' in my_connections[i].laddr[0] or not '::' in my_connections[i].raddr[0]) and \ (len(my_connections[i].laddr[0]) <= 16): try: conn_loc_address = my_connections[i].laddr[0] conn_loc_port = my_connections[i].laddr[1] except Exception: conn_loc_address = 'FAIL' conn_loc_port = 'FAIL' try: conn_rem_address = my_connections[i].raddr[0] conn_rem_port = my_connections[i].raddr[1] except Exception: conn_rem_address = 'FAIL' conn_rem_port = 'FAIL' conn_family = my_connections[i].family conn_status = my_connections[i].status connections_list.append( (conn_loc_address, conn_loc_port, conn_rem_address, conn_rem_port, conn_family, conn_status)) connections_list.sort() return {'LIST': connections_list, 'CONNECTIONS': len(connections_list)}
def process(self, packet): if self.config.incoming: ip = packet[IP].src port = packet[IP].dport else: ip = packet[IP].dst port = packet[IP].sport connections = psutil.net_connections() pid = list( filter(lambda item: filter_conn(item, ip, port), connections)) if self.config.verbose_extra: print("PID info: " + str(pid)) # pids should only listen on one port at a time... or not? if len(pid) > 0 and len(pid[0]) > 6: pname = psutil.Process(pid[0][6]).name() if self.config.show_port: port = str(pid[0].laddr.port) pidd = str(pid[0].pid) pname += f" PID:{pidd} PORT:{port}" else: pname = f"unknown call to {ip}" self.data.append(pname) if self.config.verbose or self.config.verbose_extra: print("Process " + pname)
def tcp_crawl(exe_list): ip_temp = [] for name in exe_list: for conn in net_connections('all'): laddr, raddr, status, pid = conn[3:] if not raddr: continue try: filename = basename(Process(pid).exe()) except: pass else: if filename == name: #print('远程地址:'+str(raddr)) if raddr.ip != '127.0.0.1' and ':' not in raddr.ip: #判断是否为本机地址以及剔除ipv6 if is_internal_ip(raddr.ip) != True: #判断是否为内网ip f_conf = open('config.txt', 'r') ip_list = f_conf.read() if raddr.ip not in ip_list: ip_temp.append(raddr.ip) print('发现新ip {}--tcp'.format(name)) print(raddr.ip) f_conf.close() return (ip_temp)
def get_connections(self, filters=None): filters = filters or {} connections = [] for c in psutil.net_connections('all'): conn = { 'fd': c.fd, 'pid': c.pid, 'family': socket_families[c.family], 'type': socket_types[c.type], 'local_addr_host': c.laddr[0] if c.laddr else None, 'local_addr_port': c.laddr[1] if c.laddr else None, 'remote_addr_host': c.raddr[0] if c.raddr else None, 'remote_addr_port': c.raddr[1] if c.raddr else None, 'state': c.status } for k, v in filters.iteritems(): if v and conn.get(k) != v: break else: connections.append(conn) return connections
async def netstat(self, ctx): """Information about the networking subsystem""" AD = "-" AF_INET6 = getattr(socket, 'AF_INET6', object()) proto_map = { (AF_INET, SOCK_STREAM): 'tcp', (AF_INET6, SOCK_STREAM): 'tcp6', (AF_INET, SOCK_DGRAM): 'udp', (AF_INET6, SOCK_DGRAM): 'udp6', } template = "{0:<5} {1:<30} {2:<30} {3:<13} {4:<6} {5}\n" msg = template.format( "Proto", "Local address", "Remote address", "Status", "PID", "Program name") proc_names = {} for p in psutil.process_iter(): try: proc_names[p.pid] = p.name() except psutil.Error: pass for c in psutil.net_connections(kind='inet'): laddr = "%s:%s" % c.laddr raddr = "" if c.raddr: raddr = "%s:%s" % c.raddr msg += template.format( proto_map[(c.family, c.type)], laddr, raddr or AD, c.status, c.pid or AD, proc_names.get(c.pid, '?')[:15], ) await self._say(ctx, msg) return
async def get_current(): """ Method which parses haproxy stats and returns detailed proxy statistics for all proxies. Returns: An instance of ProxiesStatsSnapshot. """ start = time.time() net_connections = psutil.net_connections() proxy_stats_list = [] for haproxy_process_name, info in HAPROXY_PROCESSES.items(): logger.debug( "Processing {} haproxy stats".format(haproxy_process_name)) proxy_stats_list += await get_stats_from_one_haproxy( info['socket'], info['configs'], net_connections) stats = ProxiesStatsSnapshot(utc_timestamp=time.mktime( datetime.now().timetuple()), proxies_stats=proxy_stats_list) logger.info( "Prepared stats about {prox} proxies in {elapsed:.1f}s.".format( prox=len(proxy_stats_list), elapsed=time.time() - start)) return stats
def net_connection_memory_info(ports=[80, 443]): """ Print psutil.Process.memory_info for processes with sockets open to the specified ports. Keyword Arguments: ports (list): list of port numbers to match Returns: None """ try: connections = psutil.net_connections() except psutil.AccessDenied as e: logging.error("Must have permissions") logging.exception(e) raise pids = [cnx.pid for cnx in connections if cnx.raddr and cnx.raddr[-1] in ports] print(pids) pids_dict = dict.fromkeys(pids) processes = [x for x in psutil.process_iter() if x.pid in pids_dict] for p in processes: print(p, p.memory_info())
def compare_procsys_connections(pid, proc_cons, kind='all'): """Given a process PID and its list of connections compare those against system-wide connections retrieved via psutil.net_connections. """ from psutil._common import pconn try: sys_cons = psutil.net_connections(kind=kind) except psutil.AccessDenied: # On OSX, system-wide connections are retrieved by iterating # over all processes if OSX: return else: raise # exclude PIDs from syscons sys_cons = [c[:-1] for c in sys_cons if c.pid == pid] if FREEBSD: # On FreeBSD all fds are set to -1 so exclude them # for comparison. proc_cons = [pconn(*[-1] + list(x[1:])) for x in proc_cons] proc_cons.sort() sys_cons.sort() assert proc_cons == sys_cons, (proc_cons, sys_cons)
def make_ports_available(ports: Container[int], timeout_seconds=10): """Make sure a list of ports are available kill occupying process if possible :param ports: list of target ports :param timeout_seconds: number of seconds to wait when killing processes :return: True on success, False on failure """ if not ports: logging.warning("Empty ports is given to make_ports_available()") return True # Get connections whose state are in LISTEN only # Connections in other states won't affect binding as SO_REUSEADDR is used listening_conns_for_port = filter( lambda conn: (conn and conn.status == psutil.CONN_LISTEN and conn.laddr and conn.laddr.port in ports), psutil.net_connections()) success = True for conn in listening_conns_for_port: logging.warning("Freeing port %d used by %s" % (conn.laddr.port, str(conn))) if not conn.pid: logging.error( "Failed to kill process occupying port %d due to lack of pid" % conn.laddr.port) success = False continue logging.warning("Killing pid %d that is using port port %d" % (conn.pid, conn.laddr.port)) process = psutil.Process(conn.pid) process.kill() try: process.wait(timeout=timeout_seconds) except psutil.TimeoutExpired: logging.error("SIGKILL timeout after %d seconds for pid %d" % (timeout_seconds, conn.pid)) continue return success
def connections(): connections = [] net_connections = psutil.net_connections() for connection in net_connections: obj = { k: getattr(connection, k) for k in ('family', 'type', 'laddr', 'raddr', 'status') } try: if connection.pid: obj.update({ k: to_unicode(v) for k, v in psutil.Process(connection.pid).as_dict( {'pid', 'exe', 'name', 'username'}).iteritems() }) set_relations(obj) except: pass connections.append(obj) return connections
def GetNetWorkList(self, get): import psutil netstats = psutil.net_connections() networkList = [] for netstat in netstats: tmp = {} if netstat.type == 1: tmp['type'] = 'tcp' else: tmp['type'] = 'udp' tmp['family'] = netstat.family tmp['laddr'] = netstat.laddr tmp['raddr'] = netstat.raddr tmp['status'] = netstat.status p = psutil.Process(netstat.pid) tmp['process'] = p.name() tmp['pid'] = netstat.pid networkList.append(tmp) del (p) del (tmp) networkList = sorted(networkList, key=lambda x: x['status'], reverse=True) return networkList
def _report_system_info(self): """ Create the system-info.log artifact file, containing a variety of system information that might be useful in diagnosing test failures. """ try: import psutil dir = self.query_abs_dirs()['abs_blob_upload_dir'] self.mkdir_p(dir) path = os.path.join(dir, "system-info.log") with open(path, "w") as f: f.write("System info collected at %s\n\n" % datetime.now()) f.write("\nBoot time %s\n" % datetime.fromtimestamp(psutil.boot_time())) f.write("\nVirtual memory: %s\n" % str(psutil.virtual_memory())) f.write("\nDisk partitions: %s\n" % str(psutil.disk_partitions())) f.write("\nDisk usage (/): %s\n" % str(psutil.disk_usage(os.path.sep))) if not self._is_windows(): # bug 1417189: frequent errors querying users on Windows f.write("\nUsers: %s\n" % str(psutil.users())) f.write("\nNetwork connections:\n") try: for nc in psutil.net_connections(): f.write(" %s\n" % str(nc)) except Exception: f.write("Exception getting network info: %s\n" % sys.exc_info()[0]) f.write("\nProcesses:\n") try: for p in psutil.process_iter(): ctime = str(datetime.fromtimestamp(p.create_time())) f.write(" PID %d %s %s created at %s\n" % (p.pid, p.name(), str(p.cmdline()), ctime)) except Exception: f.write("Exception getting process info: %s\n" % sys.exc_info()[0]) except Exception: # psutil throws a variety of intermittent exceptions self.info("Unable to complete system-info.log: %s" % sys.exc_info()[0])
def get_next_port(typ=None): import psutil try: conns = psutil.net_connections() typ = typ or socket.SOCK_STREAM occupied = set(sc.laddr.port for sc in conns if sc.type == typ and LOW_PORT_BOUND <= sc.laddr.port <= HIGH_PORT_BOUND) except psutil.AccessDenied: import subprocess p = subprocess.Popen('netstat -a -n -p tcp'.split(), stdout=subprocess.PIPE) p.wait() occupied = set() for line in p.stdout: line = to_str(line) if '.' not in line: continue for part in line.split(): if '.' in part: _, port_str = part.rsplit('.', 1) if port_str == '*': continue port = int(port_str) if LOW_PORT_BOUND <= port <= HIGH_PORT_BOUND: occupied.add(int(port_str)) break p.stdout.close() randn = struct.unpack('<Q', os.urandom(8))[0] idx = int(randn % (1 + HIGH_PORT_BOUND - LOW_PORT_BOUND - len(occupied))) for i in irange(LOW_PORT_BOUND, HIGH_PORT_BOUND + 1): if i in occupied: continue if idx == 0: return i idx -= 1 raise SystemError('No ports available.')
def read(self): data = [] timestamp = int(time.time() * 1e6) cpu = psutil.cpu_percent(interval=self.dt, percpu=True) [ data.append((timestamp, 'CPU_{}_USAGE'.format(i), val)) for i, val in enumerate(cpu) ] connections = len(psutil.net_connections()) data.append((timestamp, 'NUM_CONNECTIONS', connections)) net_io = psutil.net_io_counters(True) disk_io = psutil.disk_io_counters(True) [ data.append( (timestamp, '{}_SENT'.format(c.upper()), net_io[c].bytes_sent)) for c in net_io ] [ data.append( (timestamp, '{}_RECV'.format(c.upper()), net_io[c].bytes_recv)) for c in net_io ] [ data.append((timestamp, '{}_READ'.format(d.upper()), disk_io[d].read_bytes)) for d in disk_io ] [ data.append((timestamp, '{}_WRITE'.format(d.upper()), disk_io[d].write_bytes)) for d in disk_io ] return data
def test_net_connections(self): with create_sockets(): ret = psutil.net_connections('all') self.assertEqual(len(ret), len(set(ret))) for conn in ret: assert is_namedtuple(conn)
import psutil import platform version = platform.python_version() sport = 80 status_list = [ "LISTEN", "ESTABLISHED", "TIME_WAIT", "CLOSE_WAIT", "LAST_ACK", "SYN_SENT" ] status_temp = [] net_connections = psutil.net_connections() for key in net_connections: if key.laddr[1] == sport: status_temp.append(key.status) for status in status_list: print(status, status_temp.count(status))
def test_system(self): with create_sockets(): for conn in psutil.net_connections(kind='all'): self.check_connection_ntuple(conn)
def get_ip_addresses(family): for interface, snics in psutil.net_if_addrs().items(): for snic in snics: if snic.family == family: yield snic.address hostnames = list(get_ip_addresses(socket.AF_INET)) hostname = hostnames[0] if param.get("ssh_server"): print("Installing SSH Server on {} [{}]".format(hostname, hostnames)) ssh_password = param.get("ssh_password", "training") # noinspection PyBroadException try: used_ports = [i.laddr.port for i in psutil.net_connections()] port = [i for i in range(10022, 15000) if i not in used_ports][0] result = os.system( "apt-get install -y openssh-server && " "mkdir -p /var/run/sshd && " "echo 'root:{password}' | chpasswd && " "echo 'PermitRootLogin yes' >> /etc/ssh/sshd_config && " "sed -i 's/PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config && " "sed 's@session\s*required\s*pam_loginuid.so@session optional pam_loginuid.so@g' -i /etc/pam.d/sshd && " # noqa: W605 'echo "export VISIBLE=now" >> /etc/profile && ' 'echo "export TRAINS_CONFIG_FILE={trains_config_file}" >> /etc/profile && ' "/usr/sbin/sshd -p {port}".format( password=ssh_password, port=port, trains_config_file=os.environ.get("TRAINS_CONFIG_FILE"),
def __init__(self, path_or_host, port=None, memory='4g', lang='en', timeout=1500, quiet=True, logging_level=logging.WARNING): self.path_or_host = path_or_host self.port = port self.memory = memory self.lang = lang self.timeout = timeout self.quiet = quiet self.logging_level = logging_level logging.basicConfig(level=self.logging_level) # Check args self._check_args() if path_or_host.startswith('http'): self.url = path_or_host + ':' + str(port) logging.info('Using an existing server {}'.format(self.url)) else: # Check Java if not subprocess.call(['java', '-version'], stdout=subprocess.PIPE, stderr=subprocess.STDOUT) == 0: raise RuntimeError('Java not found.') # Check if the dir exists if not os.path.isdir(self.path_or_host): raise IOError(str(self.path_or_host) + ' is not a directory.') directory = os.path.normpath(self.path_or_host) + os.sep self.class_path_dir = directory # Check if the language specific model file exists switcher = { 'en': 'stanford-corenlp-[0-9].[0-9].[0-9]-models.jar', 'zh': 'stanford-chinese-corenlp-[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]-models.jar', 'ar': 'stanford-arabic-corenlp-[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]-models.jar', 'fr': 'stanford-french-corenlp-[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]-models.jar', 'de': 'stanford-german-corenlp-[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]-models.jar', 'es': 'stanford-spanish-corenlp-[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]-models.jar' } jars = { 'en': 'stanford-corenlp-x.x.x-models.jar', 'zh': 'stanford-chinese-corenlp-yyyy-MM-dd-models.jar', 'ar': 'stanford-arabic-corenlp-yyyy-MM-dd-models.jar', 'fr': 'stanford-french-corenlp-yyyy-MM-dd-models.jar', 'de': 'stanford-german-corenlp-yyyy-MM-dd-models.jar', 'es': 'stanford-spanish-corenlp-yyyy-MM-dd-models.jar' } if len(glob.glob(directory + switcher.get(self.lang))) <= 0: raise IOError( jars.get(self.lang) + ' not exists. You should download and place it in the ' + directory + ' first.') # If port not set, auto select if self.port is None: for port_candidate in range(9000, 65535): if port_candidate not in [ conn.laddr[1] for conn in psutil.net_connections() ]: self.port = port_candidate break # Check if the port is in use # if self.port in [conn.laddr[1] for conn in psutil.net_connections()]: # raise IOError('Port ' + str(self.port) + ' is already in use.') # Start native server logging.info('Initializing native server...') cmd = "java" java_args = "-Xmx{}".format(self.memory) java_class = "edu.stanford.nlp.pipeline.StanfordCoreNLPServer" class_path = '"{}*"'.format(directory) args = [ cmd, java_args, '-cp', class_path, java_class, '-port', str(self.port), '-maxCharLength', '2000000' ] args = ' '.join(args) logging.info(args) # Silence with open(os.devnull, 'w') as null_file: out_file = None if self.quiet: out_file = null_file self.p = subprocess.Popen(args, shell=True, stdout=out_file, stderr=subprocess.STDOUT) logging.info('Server shell PID: {}'.format(self.p.pid)) self.url = 'http://localhost:' + str(self.port) # Wait until server starts sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) host_name = urlparse(self.url).hostname time.sleep(1) # OSX, not tested while sock.connect_ex((host_name, self.port)): logging.info('Waiting until the server is available.') time.sleep(1) logging.info('The server is available.')
client.close() def send(request, ip, port): print(request, ip, port) client = Client() client.open() client.send(request, ip, port) client.close() #首先给服务端发一个消息,让他知道已经连上 port_list = [12378, 12346, 12349] net_list = psutil.net_connections() for net in net_list: if net.laddr.port in net_list: pid = net.pid if psutil.pid_exists(pid): process = psutil.Process(12378) print("即将杀死", 12378, "进程") process.kill() print("ok!") data = "sdfs" ip = None while True: sayHello() client = Client()
def create_listener(self, callback_func, port, guarantee_msg_order, endpoint_error_handling=False): """Create and start a listener to accept incoming connections callback_func is the function or coroutine that takes one argument -- the Endpoint connected to the client. In order to call ucp.reset() inside callback_func remember to close the Endpoint given as an argument. It is not enough to Also notice, the listening is closed when the returned Listener goes out of scope thus remember to keep a reference to the object. Parameters ---------- callback_func: function or coroutine A callback function that gets invoked when an incoming connection is accepted port: int, optional An unused port number for listening guarantee_msg_order: boolean, optional Whether to guarantee message order or not. Remember, both peers of the endpoint must set guarantee_msg_order to the same value. endpoint_error_handling: boolean, optional Enable endpoint error handling raising exceptions when an error occurs, may incur in performance penalties but prevents a process from terminating unexpectedly that may happen when disabled. Returns ------- Listener The new listener. When this object is deleted, the listening stops """ self.continuous_ucx_progress() if port in (None, 0): # Get a random port number and check if it's not used yet. Doing this # without relying on `socket` allows preventing UCX errors such as # "none of the available transports can listen for connections", due # to the socket still being in TIME_WAIT state. try: with open("/proc/sys/net/ipv4/ip_local_port_range") as f: start_port, end_port = [int(i) for i in next(f).split()] except FileNotFoundError: start_port, end_port = (32768, 60000) used_ports = set(conn.laddr[1] for conn in psutil.net_connections()) while True: port = randint(start_port, end_port) if port not in used_ports: break logger.info("create_listener() - Start listening on port %d" % port) ret = Listener( ucx_api.UCXListener( worker=self.worker, port=port, cb_func=_listener_handler, cb_args=( callback_func, port, self, guarantee_msg_order, endpoint_error_handling, ), )) return ret
def get_http_connections(): container = 0 for item in psutil.net_connections(kind='tcp'): if item[3][1] == 80 and item[3][0] != '0.0.0.0': container += 1 return container
import psutil from collections import defaultdict from collections import OrderedDict addr = {} countdict = {} process = psutil.net_connections(kind='tcp') addr = defaultdict(list) for i in range(len(process)): if process[i].laddr and process[i].raddr: laddr = "%s@%s" % (process[i].laddr) raddr = "%s@%s" % (process[i].raddr) addr[process[i].pid].append([laddr, raddr, process[i].status]) i = i + 1 for mykey in addr.keys(): countdict[mykey] = len(addr[mykey]) desc = OrderedDict( sorted(countdict.items(), key=lambda kv: kv[1], reverse=True)) print 'PID ,laddr ,raddr ,status' for i in desc.keys(): for n in addr[i]: print "\"%s\", \"%s\", \"%s\", \"%s\"" % (i, n[0], n[1], n[2])
def is_port_taken(port): for conn in psutil.net_connections(kind='tcp'): if conn.laddr[1] == port and conn.status == psutil.CONN_LISTEN: return True return False
import psutil import socket rede_cabeada = psutil.net_if_addrs() socket_connections = psutil.net_connections(kind='inet') # específica para eth0 def ip_adress(): return rede_cabeada['enp2s0'][0][1] # qualquer tipo de interface de rede def get_ip_address(): s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) s.connect(("8.8.8.8", 80)) return s.getsockname()[0]
def net_connections(): return psutil.net_connections()
def check_free_port(port): assert isinstance(port, int) for conn in psutil.net_connections('tcp'): if conn.laddr.port == port and conn.status == "LISTEN": return False return True
import psutil #获取cpu信息 print(psutil.cpu_count()) print(psutil.cpu_count(logical=False)) #统计cpu用户/系统/空闲时间 print(psutil.cpu_times()) for x in range(10): print(psutil.cpu_percent(interval=1, percpu=True)) #获取内存信息 print(psutil.virtual_memory()) print(psutil.swap_memory()) #获取磁盘的信息 print(psutil.disk_partitions()) #磁盘分区信息 print(psutil.disk_usage('/')) #磁盘使用情况 print(psutil.disk_io_counters()) #磁盘io #获取网络信息 print(psutil.net_io_counters()) #获取网络读写字节/包的个数 print(psutil.net_if_addrs()) #获取网络接口信息 print(psutil.net_if_stats()) #获取网络接口状态 print(psutil.net_connections()) #获取当前网络连接信息 #获取进程信息 print(psutil.pids()) #获取所有的进程id p = psutil.Process(7576) print(p) p.exe #进程exe路径 p.cwd #进程工作目录
def get_network_process(self, iface=None, filter_=None): if iface == None: if filter_ == None: table = [] headers = [ "PID/NAME", "PPID/PNAME", "Address Family", "Socket Type", "Listening Address:Port", "Remote Address:Port", "Status" ] p = psutil.net_connections() for instance in p: pid = instance[6] if psutil.Process(int(pid)).parent(): ppid = psutil.Process(int(pid)).parent().pid else: ppid = 0 laddr_section = instance[3] raddr_section = instance[4] pid_name = self.get_pid_name(pid) if ppid != 0: ppid_name = psutil.Process(int(pid)).parent().name() else: ppid_name = "System" spid = "%d/%s" % (pid, pid_name) sppid = "%d/%s" % (ppid, ppid_name) family_addr = instance[1].name socket_type = instance[2].name if laddr_section: laddr = laddr_section[0] lport = laddr_section[1] saddr_port = "%s:%s" % (laddr, lport) else: laddr = "NULL" lport = "NULL" saddr_port = "%s:%s" % (laddr, lport) if raddr_section: raddr = raddr_section[0] rport = raddr_section[1] taddr_port = "%s:%s" % (raddr, rport) else: raddr = "NULL" rport = "NULL" taddr_port = "%s:%s" % (raddr, rport) status = instance[5] table.append([ spid, sppid, family_addr, socket_type, saddr_port, taddr_port, status ]) print(tabulate(table, headers=headers, tablefmt="fancy_grid")) else: f = filter_ table = [] headers = [ "PID/NAME", "PPID/PNAME", "Address Family", "Socket Type", "Listening Address:Port", "Remote Address:Port", "Status" ] p = psutil.net_connections() for instance in p: pid = instance[6] if psutil.Process(int(pid)).parent(): ppid = psutil.Process(int(pid)).parent().pid else: ppid = 0 laddr_section = instance[3] raddr_section = instance[4] pid_name = self.get_pid_name(pid) if ppid != 0: ppid_name = psutil.Process(int(pid)).parent().name() else: ppid_name = "System" spid = "%d/%s" % (pid, pid_name) sppid = "%d/%s" % (ppid, ppid_name) family_addr = instance[1].name socket_type = instance[2].name if laddr_section: laddr = laddr_section[0] lport = laddr_section[1] saddr_port = "%s:%s" % (laddr, lport) else: laddr = "NULL" lport = "NULL" saddr_port = "%s:%s" % (laddr, lport) if raddr_section: raddr = raddr_section[0] rport = raddr_section[1] taddr_port = "%s:%s" % (raddr, rport) else: raddr = "NULL" rport = "NULL" taddr_port = "%s:%s" % (raddr, rport) status = instance[5] if pid_name == f: table.append([ spid, sppid, family_addr, socket_type, saddr_port, taddr_port, status ]) else: pass print(tabulate(table, headers=headers, tablefmt="fancy_grid")) else: if filter_ == None: table = [] headers = [ "PID/NAME", "PPID/PNAME", "Address Family", "Socket Type", "Listening Address:Port", "Remote Address:Port", "Status" ] p = psutil.net_connections(iface) for instance in p: pid = instance[6] if psutil.Process(int(pid)).parent(): ppid = psutil.Process(int(pid)).parent().pid else: ppid = 0 ppid = psutil.Process(int(pid)).parent().pid laddr_section = instance[3] raddr_section = instance[4] pid_name = self.get_pid_name(pid) if ppid != 0: ppid_name = psutil.Process(int(pid)).parent().name() else: ppid_name = "System" spid = "%d/%s" % (pid, pid_name) sppid = "%d/%s" % (ppid, ppid_name) family_addr = instance[1].name socket_type = instance[2].name if laddr_section: laddr = laddr_section[0] lport = laddr_section[1] saddr_port = "%s:%s" % (laddr, lport) else: laddr = "NULL" lport = "NULL" saddr_port = "%s:%s" % (laddr, lport) if raddr_section: raddr = raddr_section[0] rport = raddr_section[1] taddr_port = "%s:%s" % (raddr, rport) else: raddr = "NULL" rport = "NULL" taddr_port = "%s:%s" % (raddr, rport) status = instance[5] table.append([ spid, sppid, family_addr, socket_type, saddr_port, taddr_port, status ]) print(tabulate(table, headers=headers, tablefmt="fancy_grid")) else: f = filter_ table = [] headers = [ "PID/NAME", "PPID/PNAME", "Address Family", "Socket Type", "Listening Address:Port", "Remote Address:Port", "Status" ] p = psutil.net_connections() for instance in p: pid = instance[6] if psutil.Process(int(pid)).parent(): ppid = psutil.Process(int(pid)).parent().pid else: ppid = 0 ppid = psutil.Process(int(pid)).parent().pid laddr_section = instance[3] raddr_section = instance[4] pid_name = self.get_pid_name(pid) if ppid != 0: ppid_name = psutil.Process(int(pid)).parent().name() else: ppid_name = "System" spid = "%d/%s" % (pid, pid_name) sppid = "%d/%s" % (ppid, ppid_name) family_addr = instance[1].name socket_type = instance[2].name if laddr_section: laddr = laddr_section[0] lport = laddr_section[1] saddr_port = "%s:%s" % (laddr, lport) else: laddr = "NULL" lport = "NULL" saddr_port = "%s:%s" % (laddr, lport) if raddr_section: raddr = raddr_section[0] rport = raddr_section[1] taddr_port = "%s:%s" % (raddr, rport) else: raddr = "NULL" rport = "NULL" taddr_port = "%s:%s" % (raddr, rport) status = instance[5] if pid_name == f: table.append([ spid, sppid, family_addr, socket_type, saddr_port, taddr_port, status ]) else: pass print(tabulate(table, headers=headers, tablefmt="fancy_grid"))