def mdns_show_hosts_line(self, line): """Show hosts of mDNS client.\n""" parser = parsing_opts.gen_parser( self, "mdns_show_hosts", self.mdns_show_hosts_line.__doc__, parsing_opts.EMU_NS_GROUP, parsing_opts.MAC_ADDRESS, ) opts = parser.parse_args(line.split()) ns_key = EMUNamespaceKey(opts.port, opts.vlan, opts.tpid) c_key = EMUClientKey(ns_key, opts.mac) hosts = self.get_client_hosts(c_key=c_key) if hosts: hosts = listify(hosts) keys_to_headers = [ { 'key': 'number', 'header': 'Number' }, { 'key': 'hostname', 'header': 'Hostname' }, ] res = [{ 'number': i + 1, 'hostname': host } for i, host in enumerate(hosts)] self.print_table_by_keys(res, keys_to_headers, title="Hostnames") else: text_tables.print_colored_line( "The client doesn't own any hostname.", "yellow")
def print_table_by_keys(self, data, keys_to_headers, title = None, empty_msg = 'empty'): def _iter_dict(d, keys, max_lens): row_data = [] for j, key in enumerate(keys): val = str(conv_to_str(d.get(key), key)) row_data.append(val) max_lens[j] = max(max_lens[j], len(val)) return row_data if len(data) == 0: text_tables.print_colored_line(empty_msg, 'yellow', buffer = sys.stdout) return table = text_tables.TRexTextTable(title) headers = [e.get('header') for e in keys_to_headers] keys = [e.get('key') for e in keys_to_headers] max_lens = [len(h) for h in headers] table.header(headers) if type(data) is list: for one_record in data: row_data = _iter_dict(one_record, keys, max_lens) table.add_row(row_data) elif type(data) is dict: row_data = _iter_dict(data, keys, max_lens) table.add_row(row_data) # fix table look table.set_cols_align(["c"] * len(headers)) table.set_cols_width(max_lens) table.set_cols_dtype(['a'] * len(headers)) text_tables.print_table_with_header(table, table.title, buffer = sys.stdout)
def dns_show_domains_line(self, line): """Show domains a Name Server holds.\n""" parser = parsing_opts.gen_parser(self, "dns_show_domains", self.dns_show_domains_line.__doc__, parsing_opts.EMU_NS_GROUP, parsing_opts.MAC_ADDRESS) opts = parser.parse_args(line.split()) ns_key = EMUNamespaceKey(opts.port, opts.vlan, opts.tpid) c_key = EMUClientKey(ns_key, opts.mac) domains = self.get_domains(c_key=c_key) if domains: domains = listify(domains) keys_to_headers = [ { 'key': 'number', 'header': 'Number' }, { 'key': 'domain', 'header': 'Domain' }, ] res = [{ 'number': i + 1, 'domain': domain } for i, domain in enumerate(domains)] self.print_table_by_keys(res, keys_to_headers, title="Domains") else: text_tables.print_colored_line( "The Name Server doesn't recognize any domains.", "yellow")
def icmp_get_ping_stats(self, line): """ICMP get ping stats (per client).\n""" parser = parsing_opts.gen_parser(self, "icmp_get_ping_stats", self.icmp_get_ping_stats.__doc__, parsing_opts.MAC_ADDRESS, parsing_opts.EMU_NS_GROUP, parsing_opts.EMU_SHOW_CNT_GROUP, parsing_opts.EMU_DUMPS_OPT ) opts = parser.parse_args(line.split()) ns_key = EMUNamespaceKey(opts.port, opts.vlan, opts.tpid) c_key = EMUClientKey(ns_key, opts.mac) data_cnt = DataCounter(self.emu_c.conn, 'icmp_c_get_ping_stats') data_cnt.set_add_data(c_key=c_key) try: if opts.headers: data_cnt.get_counters_headers() elif opts.clear: self.emu_c.logger.pre_cmd("Clearing all counters :") data_cnt.clear_counters() self.emu_c.logger.post_cmd(True) else: data = data_cnt.get_counters( opts.tables, opts.cnt_types, opts.zero) DataCounter.print_counters( data, opts.verbose, opts.json, opts.yaml) except TRexError as err: text_tables.print_colored_line( '\n' + err.msg, 'yellow', buffer=sys.stdout)
def __icmp_start_ping_print(self, c_key, amount, pace, dst, timeout, pkt_size): res = False self.emu_c.logger.pre_cmd('Starting to ping : ') res = self.start_ping(c_key=c_key, amount=amount, pace=pace, dst=dst, timeout=timeout, pkt_size=pkt_size) self.emu_c.logger.post_cmd(res) if not res: text_tables.print_colored_line("Client is already pinging on in timeout.", 'yellow', buffer=sys.stdout) return res
def icmp_start_ping_wait(self, line): """ICMP start pinging and wait to finish (per client).\n""" parser = parsing_opts.gen_parser(self, "icmp_start_ping_wait", self.icmp_start_ping_wait.__doc__, parsing_opts.MAC_ADDRESS, parsing_opts.EMU_NS_GROUP, parsing_opts.EMU_ICMP_PING_PARAMS, parsing_opts.MONITOR_TYPE_VERBOSE ) opts = parser.parse_args(line.split()) ns_key = EMUNamespaceKey(opts.port, opts.vlan, opts.tpid) c_key = EMUClientKey(ns_key, opts.mac) res = self.__icmp_start_ping_print(c_key=c_key, amount=opts.ping_amount, pace=opts.ping_pace, dst=opts.ping_dst, timeout=opts.ping_timeout, pkt_size=opts.ping_size) amount = opts.ping_amount if opts.ping_amount is not None else 5 # default is 5 packets pace = opts.ping_pace if opts.ping_pace is not None else 1 # default is 1 if res: try: while True: time.sleep(min(1, 100/pace)) stats, err = self.get_ping_stats(c_key=c_key) if err is None: completed = stats['icmp_ping_stats']['requestsSent'] percent = completed / float(amount) * 100.0 dots = '.' * int(percent / 10) text = "Progress: {0:.2f}% {1}".format(percent, dots) sys.stdout.write('\r' + (' ' * 25) + '\r') # clear line sys.stdout.write(format_text(text, 'yellow')) sys.stdout.flush() if opts.verbose: sys.stdout.flush() stats_text = "\n" for key, value in stats['icmp_ping_stats'].items(): stats_text += "{0} {1}: {2:.2f}\n".format( key, ' ' * (20 - len(key)), value) sys.stdout.write(format_text(stats_text, 'green')) sys.stdout.flush() if completed == amount: sys.stdout.write(format_text( '\n\nCompleted\n\n', 'yellow')) sys.stdout.flush() break else: # Could get here if timeout is too short, but shouldn't happen. break except KeyboardInterrupt: text_tables.print_colored_line( '\nInterrupted by a keyboard signal (probably ctrl + c).', 'yellow', buffer=sys.stdout) self.emu_c.logger.pre_cmd('Attempting to stop ping :') res_stop = self.stop_ping(c_key=c_key) self.emu_c.logger.post_cmd(res_stop) return res_stop
def print_gen_data(self, data, title = None, empty_msg = 'empty'): if not data: text_tables.print_colored_line(empty_msg, 'yellow', buffer = sys.stdout) return if title is not None: text_tables.print_colored_line(title, 'yellow', buffer = sys.stdout) for one_data in data: print(conv_unknown_to_str(one_data)) print('') # new line for seperation
def mdns_remove_hosts_line(self, line): """Remove hosts from mDNS client.\n""" parser = parsing_opts.gen_parser(self, "mdns_remove_hosts", self.mdns_remove_hosts_line.__doc__, parsing_opts.EMU_NS_GROUP, parsing_opts.MAC_ADDRESS, parsing_opts.MDNS_HOSTS_LIST) opts = parser.parse_args(line.split()) ns_key = EMUNamespaceKey(opts.port, opts.vlan, opts.tpid) c_key = EMUClientKey(ns_key, opts.mac) non_existing_hosts = self.add_remove_hosts(c_key=c_key, op=True, hosts=opts.hosts) if non_existing_hosts: msg = "Hosts: {} didn't exist.".format(listify(non_existing_hosts)) text_tables.print_colored_line(msg, "yellow") self.logger.post_cmd(True) # If we got here, it was successful
def icmp_stop_ping(self, line): """ICMP stop pinging (per client).\n""" parser = parsing_opts.gen_parser(self, "icmp_stop_ping", self.icmp_stop_ping.__doc__, parsing_opts.MAC_ADDRESS, parsing_opts.EMU_NS_GROUP, ) opts = parser.parse_args(line.split()) ns_key = EMUNamespaceKey(opts.port, opts.vlan, opts.tpid) c_key = EMUClientKey(ns_key, opts.mac) self.emu_c.logger.pre_cmd('Attempting to stop ping :') res = self.stop_ping(c_key=c_key) self.emu_c.logger.post_cmd(res) if not res: text_tables.print_colored_line("No active pinging.", 'yellow', buffer=sys.stdout)
def icmp_ping(self, line): """ICMP ping utility (per client).\n""" parser = parsing_opts.gen_parser(self, "icmp_ping", self.icmp_ping.__doc__, parsing_opts.MAC_ADDRESS, parsing_opts.EMU_NS_GROUP, parsing_opts.EMU_ICMP_PING_PARAMS, ) rows, cols = os.popen('stty size', 'r').read().split() if (int(rows) < self.MIN_ROWS) or (int(cols) < self.MIN_COLS): msg = "\nPing requires console screen size of at least {0}x{1}, current is {2}x{3}".format(self.MIN_COLS, self.MIN_ROWS, cols, rows) text_tables.print_colored_line(msg, 'red', buffer=sys.stdout) return opts = parser.parse_args(line.split()) ns_key = EMUNamespaceKey(opts.port, opts.vlan, opts.tpid) c_key = EMUClientKey(ns_key, opts.mac) self.emu_c.logger.pre_cmd('Starting to ping : ') success, err = self.start_ping(c_key=c_key, amount=opts.ping_amount, pace=opts.ping_pace, dst=opts.ping_dst, payload_size=opts.ping_size, timeout=1) if err is not None: self.emu_c.logger.post_cmd(False) text_tables.print_colored_line(err.msg, 'yellow', buffer=sys.stdout) else: self.emu_c.logger.post_cmd(True) amount = opts.ping_amount if opts.ping_amount is not None else 5 # default is 5 packets try: while True: time.sleep(1) # Don't get statistics too often as RPC requests might overload the Emu Server. stats, err = self.get_ping_stats(c_key=c_key) if err is None: stats = stats['icmp_ping_stats'] sent = stats['requestsSent'] rcv = stats['repliesInOrder'] percent = sent / float(amount) * 100.0 # the latency from the server is in usec min_lat_msec = float(stats['minLatency']) / 1000 max_lat_msec = float(stats['maxLatency']) / 1000 avg_lat_msec = float(stats['avgLatency']) / 1000 err = int(stats['repliesOutOfOrder']) + int(stats['repliesMalformedPkt']) + \ int(stats['repliesBadLatency']) + int(stats['repliesBadIdentifier']) + \ int (stats['dstUnreachable']) text = "Progress: {0:.2f}%, Sent: {1}/{2}, Rcv: {3}/{2}, Err: {4}/{2}, RTT min/avg/max = {5:.2f}/{6:.2f}/{7:.2f} ms" \ .format(percent, sent, amount, rcv, err, min_lat_msec, avg_lat_msec, max_lat_msec) sys.stdout.write('\r' + (' ' * self.MIN_COLS) +'\r') # clear line sys.stdout.write(format_text(text, 'yellow')) sys.stdout.flush() if sent == amount: sys.stdout.write(format_text('\n\nCompleted\n\n', 'yellow')) sys.stdout.flush() break else: # Trying to collect stats after completion. break except KeyboardInterrupt: text_tables.print_colored_line('\nInterrupted by a keyboard signal (probably ctrl + c).', 'yellow', buffer=sys.stdout) self.emu_c.logger.pre_cmd('Attempting to stop ping : ') success, err = self.stop_ping(c_key=c_key) if err is None: self.emu_c.logger.post_cmd(True) else: self.emu_c.logger.post_cmd(False) text_tables.print_colored_line(err.msg, 'yellow', buffer=sys.stdout)