def client(svc, counter): def get_path_info(myaddr, dst_isd_as): sd = start_sciond(myaddr) path = sd.get_paths(dst_isd_as)[0] if_id = path.get_fwd_if() return (path, sd.ifid2br[if_id].addr, sd.ifid2br[if_id].port) print("client %d running:" % counter) s = SCIONTCPSocket() caddr = SCIONAddr.from_values(c_isd_as, c_ip) s.bind((caddr, 0)) path_info = get_path_info(caddr, s_isd_as) print(path_info) if svc: saddr = SCIONAddr.from_values(s_isd_as, SVCType.PS_A) s.connect(saddr, 0, *path_info) # SVC does not have a port specified else: saddr = SCIONAddr.from_values(s_isd_as, s_ip) s.connect(saddr, 5000, *path_info) # s.set_recv_tout(5.0) # print(s.get_recv_tout()) start = time.time() size = struct.unpack("!I", recv_all(s, 4, 0))[0] tmp = b'' print("To receive: %dB" % size) while len(tmp) != size: tmp += s.recv(1024) print('.', end="", flush=True) print("\nMSG received, len, svc", len(tmp), svc) time_elapsed = time.time()-start print("Time elapsed: %s, speed %.2fkB/s\n" % (time_elapsed, size/time_elapsed/1000)) s.close()
def test_with_svc(self): dst_addr = SCIONAddr.from_values(ISD_AS("1-1"), SVCType.BS_A) src_addr = SCIONAddr.from_values(ISD_AS("1-1"), HostAddrIPv4("127.0.0.1")) connector = self._setup_connector(svc_info_desc=("bs", "bs1")) # Call ntools.eq_(connector._resolve_dst_addr(src_addr, dst_addr), "bs1") # Tests connector.get_service_info.assert_called_once_with(["bs"])
def test_with_different_ases(self): dst_addr = SCIONAddr.from_values(ISD_AS("1-2"), HostAddrSVC(0, raw=False)) src_addr = SCIONAddr.from_values(ISD_AS("1-1"), HostAddrIPv4("127.0.0.1")) connector = self._setup_connector(svc_info_desc=("bs", "bs1")) # Call ntools.eq_(connector._resolve_dst_addr(src_addr, dst_addr), None) # Tests ntools.assert_false(connector.get_service_info.called)
def _parse(self, dst_type, src_type, raw): data = Raw(raw, self.NAME, self.calc_lens(dst_type, src_type)[0]) dst_ia = ISD_AS(data.pop(ISD_AS.LEN)) src_ia = ISD_AS(data.pop(ISD_AS.LEN)) dst_addr_t = haddr_get_type(dst_type) dst_addr = dst_addr_t(data.pop(dst_addr_t.LEN)) self.dst = SCIONAddr.from_values(dst_ia, dst_addr) src_addr_t = haddr_get_type(src_type) src_addr = src_addr_t(data.pop(src_addr_t.LEN)) self.src = SCIONAddr.from_values(src_ia, src_addr) self.update() if self.src.host.TYPE == AddrType.SVC: raise SCMPBadSrcType("Invalid source type: SVC")
def test_with_host(self, host_info): dst_addr = SCIONAddr.from_values(ISD_AS("1-1"), HostAddrIPv4("127.0.0.2")) src_addr = SCIONAddr.from_values(ISD_AS("1-1"), HostAddrIPv4("127.0.0.1")) connector = self._setup_connector() # Call ntools.eq_(connector._resolve_dst_addr(src_addr, dst_addr), host_info.return_value) # Tests ntools.assert_false(connector.get_service_info.called) host_info.assert_called_once_with([HostAddrIPv4("127.0.0.2")], SCION_UDP_EH_DATA_PORT)
def _setup_sockets(self, init): """ Setup incoming socket and register with dispatcher """ self._tcp_sock = None self._tcp_new_conns = queue.Queue(MAX_QUEUE) # New TCP connections. if self._port is None: # No scion socket desired. return svc = SERVICE_TO_SVC_A.get(self.SERVICE_TYPE) # Setup TCP "accept" socket. self._setup_tcp_accept_socket(svc) # Setup UDP socket if self.bind: # TODO(jonghoonkwon): Fix me to setup socket for a proper bind address, # if the element has more than one bind addresses host_addr, b_port = self.bind[0] b_addr = SCIONAddr.from_values(self.topology.isd_as, host_addr) self._udp_sock = ReliableSocket( reg=(self.addr, self._port, init, svc), bind_ip=(b_addr, b_port)) else: self._udp_sock = ReliableSocket( reg=(self.addr, self._port, init, svc)) if not self._udp_sock.registered: self._udp_sock = None return self._port = self._udp_sock.port self._socks.add(self._udp_sock, self.handle_recv)
def main(): args = setup_main("cli_srv_ext_test") if args.run_server: dst = SCIONAddr.from_values(ISD_AS(args.dst_ia), haddr_parse_interface(args.server)) ExtServer(args.data.encode('utf-8'), dst, port=int(args.port)).run() else: src = SCIONAddr.from_values(ISD_AS(args.src_ia), haddr_parse_interface(args.client)) dst = SCIONAddr.from_values(ISD_AS(args.dst_ia), haddr_parse_interface(args.server)) ExtClient(args.data.encode('utf-8'), src, dst, dport=int(args.port), retries=args.retries).run()
def scion_server_socket(server_address, api_addr, isd_as): logging.info("Starting SCION test server application.") soc = ScionServerSocket(L4Proto.SSP, bytes(api_addr, 'ascii')) host = HostAddrIPv4(server_address[0]) saddr = SCIONAddr.from_values(isd_as, host) soc.bind(server_address[1], saddr) soc.listen() return soc
def __init__(self, server_id, conf_dir, public=None, bind=None): """ :param str server_id: server identifier. :param str conf_dir: configuration directory. :param list public: (host_addr, port) of the element's public address (i.e. the address visible to other network elements). :param list bind: (host_addr, port) of the element's bind address, if any (i.e. the address the element uses to identify itself to the local operating system, if it differs from the public address due to NAT). """ self.id = server_id self.conf_dir = conf_dir self.ifid2br = {} self.topology = Topology.from_file( os.path.join(self.conf_dir, TOPO_FILE)) self.config = Config.from_file( os.path.join(self.conf_dir, AS_CONF_FILE)) # Must be over-ridden by child classes: self.CTRL_PLD_CLASS_MAP = {} self.SCMP_PLD_CLASS_MAP = {} self.public = public self.bind = bind if self.SERVICE_TYPE: own_config = self.topology.get_own_config(self.SERVICE_TYPE, server_id) if public is None: self.public = own_config.public if bind is None: self.bind = own_config.bind self.init_ifid2br() self.trust_store = TrustStore(self.conf_dir) self.total_dropped = 0 self._core_ases = defaultdict( list) # Mapping ISD_ID->list of core ASes self.init_core_ases() self.run_flag = threading.Event() self.run_flag.set() self.stopped_flag = threading.Event() self.stopped_flag.clear() self._in_buf = queue.Queue(MAX_QUEUE) self._socks = SocketMgr() self._startup = time.time() if self.USE_TCP: self._DefaultMeta = TCPMetadata else: self._DefaultMeta = UDPMetadata self.unverified_segs = set() self.unv_segs_lock = threading.RLock() self.requested_trcs = {} self.req_trcs_lock = threading.Lock() self.requested_certs = {} self.req_certs_lock = threading.Lock() # TODO(jonghoonkwon): Fix me to setup sockets for multiple public addresses host_addr, self._port = self.public[0] self.addr = SCIONAddr.from_values(self.topology.isd_as, host_addr) self._setup_sockets(True)
def scion_server_socket(server_address, isd_as): logging.info("Starting SCION test server application.") sockdir = "/run/shm/sciond/%s.sock" % isd_as soc = ScionServerSocket(L4Proto.SSP, bytes(sockdir, 'ascii')) host = HostAddrIPv4(server_address[0]) saddr = SCIONAddr.from_values(ISD_AS(isd_as), host) soc.bind(server_address[1], saddr) soc.listen() return soc
def __init__(self, finished, addr): # We need the lib sciond here already. connector = lib_sciond.init(get_sciond_api_addr(addr)) cs_info = lib_sciond.get_service_info( [ServiceType.CS], connector=connector)[ServiceType.CS] cs = cs_info.host_info(0) cs_addr = SCIONAddr.from_values(addr.isd_as, cs.ipv4() or cs.ipv6()) self.cert_done = False super().__init__("", finished, addr, cs_addr, cs.p.port)
def _create_hdrs(self): """ Create headers for a SCION packet """ dest = SCIONAddr.from_values(self.remote, SVCType.SB_A) cmn_hdr, addr_hdr = build_base_hdrs(self.addr, dest) payload = SIBRAPayload.from_values() udp_hdr = SCIONUDPHeader.from_values(self.addr, self._port, dest, 0) return cmn_hdr, addr_hdr, udp_hdr, payload
def main(): parser = argparse.ArgumentParser() parser.add_argument('-l', '--loglevel', default="INFO", help='Console logging level (Default: %(default)s)') parser.add_argument('-c', '--count', default=1, type=int, help='Number of packets to send. 0 means unlimited.') parser.add_argument( '-s', '--size', default=0, type=int, help='Size of packets to send. 0 means use the MTU of the path.') parser.add_argument( '-w', '--wait', default=0, type=int, help='Wait time in milliseconds after a packet has been sent.') parser.add_argument('src_ia', help='Src ISD-AS') parser.add_argument('src_addr', help='Src IP') parser.add_argument('dst_ia', help='Dst ISD-AS') parser.add_argument('dst_addr', help='Dst IP') args = parser.parse_args() init_logging("logs/pktgen", console_level=args.loglevel) src = SCIONAddr.from_values(ISD_AS(args.src_ia), haddr_parse_interface(args.src_addr)) dst = SCIONAddr.from_values(ISD_AS(args.dst_ia), haddr_parse_interface(args.dst_addr)) gen = PktGen(b"data", "finished", src, dst, 3000, size=args.size) start = time.time() try: gen.run(args.count, args.wait) except KeyboardInterrupt: pass total = time.time() - start logging.info("Sent %d %dB packets in %.3fs (%d pps, %d bps)", gen.sent, gen.size, total, gen.sent / total, (gen.sent * gen.size * 8) / total)
def _run_test(self, isd_as): logging.info("Testing: %s", isd_as) finished = threading.Event() addr = SCIONAddr.from_values(isd_as, self.client_ip) client = self._create_client(finished, addr) client.run() if client.success: return True logging.error("Client success? %s", client.success) return False
def main(): args = setup_main("scmp_error_test") src = SCIONAddr.from_values(ISD_AS(args.src_ia), haddr_parse_interface(args.client)) dst = SCIONAddr.from_values(ISD_AS(args.dst_ia), haddr_parse_interface(args.server)) data = ("%s<->%s" % (src, dst)).encode("UTF-8") success = True for cls_ in GEN_LIST: logging.info("===========> Testing: %s", cls_.DESC) client = cls_(copy.deepcopy(data), copy.deepcopy(src), copy.deepcopy(dst), 0, api=True) if not client.run(): success = False if not success: sys.exit(1)
def __init__(self, server_id: str, conf_dir: str, host_addr: HostAddrBase = None, port: int = None) -> None: """ :param str server_id: server identifier. :param str conf_dir: configuration directory. :param `HostAddrBase` host_addr: the interface to bind to. Overrides the address in the topology config. :param int port: the port to bind to. Overrides the address in the topology config. """ self.id = server_id self.conf_dir = conf_dir self.ifid2br = {} # type: Dict[int, RouterElement] self._port = port self.topology = Topology.from_file( os.path.join(self.conf_dir, TOPO_FILE)) self.config = Config.from_file( os.path.join(self.conf_dir, AS_CONF_FILE)) # Must be over-ridden by child classes: # self.CTRL_PLD_CLASS_MAP = {} # type: Dict[str, Dict[Optional[int], Callable[[object, object, object], None]]] # self.SCMP_PLD_CLASS_MAP = {} # type: Dict[int, Dict[Optional[int], Callable[[object, object], None]]] if self._service_type(): own_config = self.topology.get_own_config(self._service_type(), server_id) if host_addr is None: host_addr = own_config.addr if self._port is None: self._port = own_config.port self.addr = SCIONAddr.from_values(self.topology.isd_as, host_addr) # type: SCIONAddr self.init_ifid2br() self.trust_store = TrustStore(self.conf_dir) self.total_dropped = 0 self._core_ases = defaultdict( list_object ) # type: defaultdict[int, List[object]] # Mapping ISD_ID->list of core ASes self.init_core_ases() self.run_flag = threading.Event() self.run_flag.set() self.stopped_flag = threading.Event() self.stopped_flag.clear() self._in_buf = queue.Queue(MAX_QUEUE) # type: queue.Queue[object] self._socks = SocketMgr() self._setup_sockets(True) self._startup = time.time() if SCIONElement.USE_TCP: self.DefaultMeta = TCPMetadata # type: Type[MetadataBase] else: self.DefaultMeta = UDPMetadata
def _run(self): """ Run a test for every pair of src and dst """ # Generate all possible pairs, and randomise the order. pairs = list(product(self.src_ias, self.dst_ias)) random.shuffle(pairs) count = 0 for src_ia, dst_ia in pairs: if not self.local and src_ia == dst_ia: continue count += 1 if self.max_runs and count > self.max_runs: logging.debug("Hit max runs (%d), stopping", self.max_runs) break src = SCIONAddr.from_values(src_ia, self.client_ip) dst = SCIONAddr.from_values(dst_ia, self.server_ip) t = threading.current_thread() t.name = "%s %s > %s main" % (self.NAME, src_ia, dst_ia) if not self._run_test(src, dst): sys.exit(1)
def __init__(self, server_id, conf_dir, host_addr=None, port=None): """ :param str server_id: server identifier. :param str conf_dir: configuration directory. :param `HostAddrBase` host_addr: the interface to bind to. Overrides the address in the topology config. :param int port: the port to bind to. Overrides the address in the topology config. """ self.id = server_id self.conf_dir = conf_dir self.ifid2br = {} self._port = port self.topology = Topology.from_file( os.path.join(self.conf_dir, TOPO_FILE)) self.config = Config.from_file( os.path.join(self.conf_dir, AS_CONF_FILE)) # Must be over-ridden by child classes: self.CTRL_PLD_CLASS_MAP = {} self.SCMP_PLD_CLASS_MAP = {} if self.SERVICE_TYPE: own_config = self.topology.get_own_config(self.SERVICE_TYPE, server_id) if host_addr is None: host_addr = own_config.addr if self._port is None: self._port = own_config.port self.addr = SCIONAddr.from_values(self.topology.isd_as, host_addr) self.init_ifid2br() self.trust_store = TrustStore(self.conf_dir) self.total_dropped = 0 self._core_ases = defaultdict(list) # Mapping ISD_ID->list of core ASes self.init_core_ases() self.run_flag = threading.Event() self.run_flag.set() self.stopped_flag = threading.Event() self.stopped_flag.clear() self._in_buf = queue.Queue(MAX_QUEUE) self._socks = SocketMgr() self._setup_sockets(True) self._startup = time.time() if self.USE_TCP: self.DefaultMeta = TCPMetadata else: self.DefaultMeta = UDPMetadata self.unverified_segs = set() self.unv_segs_lock = threading.RLock() self.requested_trcs = set() self.req_trcs_lock = threading.Lock() self.requested_certs = set() self.req_certs_lock = threading.Lock()
def _create_reg_pkt(self, type_, remote=False): if remote: dst_ia = self.remote path = self.seg.get_path(True) else: dst_ia = self.addr.isd_as path = SCIONPath() pcb = self._create_reg_pcb(remote) pld = PathRecordsReg.from_values({type_: [pcb]}) dest = SCIONAddr.from_values(dst_ia, SVCType.PS_A) cmn_hdr, addr_hdr = build_base_hdrs(self.addr, dest) udp_hdr = SCIONUDPHeader.from_values(self.addr, self._port, dest, 0) return SCIONL4Packet.from_values(cmn_hdr, addr_hdr, path, [], udp_hdr, pld)
def addr_c2py(caddr): """ Helper function to convert C_SCIONAddr to SCIONAddr :param caddr: C_SCIONAddr to convert :type caddr: C_SCIONAddr :returns: Converted object :rtype: SCIONAddr """ isd_as = ISD_AS(caddr.isd_as.to_bytes(4, 'big')) if caddr.host.addr_type == 0: return None htype = haddr_get_type(caddr.host.addr_type) haddr = haddr_parse(caddr.host.addr_type, bytes(caddr.host.addr)[:htype.LEN]) return SCIONAddr.from_values(isd_as, haddr)
def _build_packet(self, dst_host=None, path=None, ext_hdrs=(), dst_ia=None, payload=None, dst_port=0): if dst_host is None: dst_host = HostAddrNone() if dst_ia is None: dst_ia = self.addr.isd_as if path is None: path = SCIONPath() if payload is None: payload = PayloadRaw() dst_addr = SCIONAddr.from_values(dst_ia, dst_host) cmn_hdr, addr_hdr = build_base_hdrs(dst_addr, self.addr) udp_hdr = SCIONUDPHeader.from_values( self.addr, self._port, dst_addr, dst_port) return SCIONL4Packet.from_values( cmn_hdr, addr_hdr, path, ext_hdrs, udp_hdr, payload)
def __init__(self, server_id, conf_dir, host_addr=None, port=SCION_UDP_PORT): """ :param str server_id: server identifier. :param str conf_dir: configuration directory. :param `HostAddrBase` host_addr: the interface to bind to. Overrides the address in the topology config. :param int port: the port to bind to. """ self.id = server_id self.conf_dir = conf_dir self.ifid2er = {} self._port = port self.topology = Topology.from_file( os.path.join(self.conf_dir, TOPO_FILE)) self.config = Config.from_file( os.path.join(self.conf_dir, AS_CONF_FILE)) # Must be over-ridden by child classes: self.CTRL_PLD_CLASS_MAP = {} self.SCMP_PLD_CLASS_MAP = {} if host_addr is None: own_config = self.topology.get_own_config(self.SERVICE_TYPE, server_id) host_addr = own_config.addr self.addr = SCIONAddr.from_values(self.topology.isd_as, host_addr) self._dns = DNSCachingClient( [str(s.addr) for s in self.topology.dns_servers], self.topology.dns_domain) self.init_ifid2er() self.trust_store = TrustStore(self.conf_dir) self.total_dropped = 0 self._core_ases = defaultdict( list) # Mapping ISD_ID->list of core ASes self.init_core_ases() self.run_flag = threading.Event() self.run_flag.set() self.stopped_flag = threading.Event() self.stopped_flag.clear() self._in_buf = queue.Queue(MAX_QUEUE) self._socks = SocketMgr() self._setup_socket(True) self._startup = time.time()
def __init__(self, connection, address, conn_id, scion_mode, kbase, source_isd_as, target_isd_as): """ Create a ConnectionHandler class to handle the incoming HTTP(S) request. :param connection: Socket object that belong to the incoming connection :type connection: socket :param address: Address of the connecting party. :type address: host, port """ self.scion_mode = scion_mode self.socket_kbase = kbase isd_as = ISD_AS(target_isd_as) host = HostAddrIPv4(self.target_proxy[0]) self.scion_target_proxy = SCIONAddr.from_values(isd_as, host) self.scion_target_port = self.target_proxy[1] self.isd_as = source_isd_as super().__init__(connection, address, conn_id)
def server(svc=False): print("server running") s = SCIONTCPSocket() print('setsockopt') s.setsockopt(SockOpt.SOF_REUSEADDR) print(s.getsockopt(SockOpt.SOF_REUSEADDR)) addr = SCIONAddr.from_values(s_isd_as, s_ip) if svc: s.bind((addr, 6000), svc=SVCType.PS_A) else: s.bind((addr, 5000)) s.listen() while True: new_sock, addr, path = s.accept() print("Accepted: addr and path:", addr, path) msg = get_msg() # time.sleep(10) new_sock.send(msg) new_sock.close()
def __init__(self, sd, finished, addr): cs = sd.dns_query_topo(CERTIFICATE_SERVICE)[0] cs_addr = SCIONAddr.from_values(addr.isd_as, cs) self.cert_done = False super().__init__(sd, "", finished, addr, cs_addr, SCION_UDP_PORT)
def test(self): """ Create a certificate chain and verify it with a TRC file. Sign a message with the private key of the last certificate in the chain and verify it. """ cert10 = CertificateChain(get_cert_chain_file_path(1, 10, 1, 10, 0)) trc = TRC(get_trc_file_path(1, 10, 1, 0)) print('TRC verification', trc.verify()) print('Cert Chain verification:', cert10.verify('ISD:1-AD:10', trc, 0)) sig_priv10 = read_file(get_sig_key_file_path(1, 10)) sig_priv10 = base64.b64decode(sig_priv10) msg = b'abcd' sig = sign(msg, sig_priv10) print('Sig test:', verify_sig_chain_trc(msg, sig, 'ISD:1-AD:10', cert10, trc, 0)) sig_priv13 = read_file(get_sig_key_file_path(1, 13)) sig_priv13 = base64.b64decode(sig_priv13) msg = b'abd' sig = sign(msg, sig_priv13) CertificateChain.from_values([]) print('Sig test 2:', verify_sig_chain_trc(msg, sig, 'ISD:1-AD:13', cert10, trc, 0), '\n') topology = Topology.from_file( "topology/ISD1/topologies/ISD:1-AD:10.json") src_addr = SCIONAddr.from_values(topology.isd_id, topology.ad_id, IPv4Address("127.0.0.1")) dst_addr = topology.certificate_servers[0].addr sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) sock.bind((str(src_addr.host_addr), SCION_UDP_PORT)) print("Sending TRC request (ISD:1-V:0) to local CS.") msg = TRCRequest.from_values( PT.TRC_REQ_LOCAL, src_addr, topology.parent_border_routers[0].interface.if_id, topology.isd_id, topology.ad_id, 1, 0).pack() sock.sendto(msg, (str(dst_addr), SCION_UDP_PORT)) temp_file = './temp.txt' timeout = 5 ready = select.select([sock], [], [], timeout) if not ready[0]: print("Error: no TRC reply was received!") sock.close() return data, _ = sock.recvfrom(SCION_BUFLEN) print("Received TRC reply from local CS.") trc_reply = TRCReply(data) write_file(temp_file, trc_reply.trc.decode('utf-8')) trc = TRC(temp_file) assert trc.verify() print("Sending cert chain request (ISD:1-AD:16-V:0) to local CS.") msg = CertChainRequest.from_values( PT.CERT_CHAIN_REQ_LOCAL, src_addr, topology.parent_border_routers[0].interface.if_id, topology.isd_id, topology.ad_id, 1, 16, 0).pack() sock.sendto(msg, (str(dst_addr), SCION_UDP_PORT)) ready = select.select([sock], [], [], timeout) if not ready[0]: print("Error: no cert chain reply was received!") sock.close() return data, _ = sock.recvfrom(SCION_BUFLEN) print("Received cert chain reply from local CS.") cert_chain_reply = CertChainReply(data) write_file(temp_file, cert_chain_reply.cert_chain.decode('utf-8')) cert_chain = CertificateChain(temp_file) assert cert_chain.verify('ISD:1-AD:16', trc, 0) os.remove(temp_file) sock.close()
def main(): parser = argparse.ArgumentParser() parser.add_argument('-l', '--loglevel', default="INFO", help='Console logging level (Default: %(default)s)') parser.add_argument('-c', '--count', default=1, type=int, help='Number of packets to send. 0 means unlimited.') parser.add_argument( '-s', '--size', default=0, type=int, help='Size of packets to send. 0 means use the MTU of the path.') parser.add_argument( '-w', '--wait', default=0, type=int, help='Wait time in milliseconds after a packet has been sent.') parser.add_argument('-r', '--random', action='store_true', help='Run with randomized wait time and packet size') parser.add_argument( '-la', '--lambd', default=50, type=int, help='Number of packets that are sent in average per second. ' '0 means that as many packets as possible are sent.' ' Only used with -r flag') parser.add_argument( '-n', '--number', default=1000, type=int, help='Number of random sized packets to be used. Only used with -r flag.' '(Default: %(default)s)') parser.add_argument('src_ia', help='Src ISD-AS') parser.add_argument('src_addr', help='Src IP') parser.add_argument('dst_ia', help='Dst ISD-AS') parser.add_argument('dst_addr', help='Dst IP') args = parser.parse_args() init_logging("logs/pktgen", console_level=args.loglevel) src = SCIONAddr.from_values(ISD_AS(args.src_ia), haddr_parse_interface(args.src_addr)) dst = SCIONAddr.from_values(ISD_AS(args.dst_ia), haddr_parse_interface(args.dst_addr)) gen = PktGen(b"data", "finished", src, dst, 3000, size=args.size) if args.random and (args.wait or args.size): logging.warning( "Flags -w and -s are not used in random mode. See -h for help.") elif not args.random and (args.lambd != 50 or args.number != 1000): logging.warning( "Flags -la and -n are not used in performance mode. See -h for help." ) try: if args.random: gen.random_run(args.count, args.lambd, args.number) else: gen.run(args.count, args.wait) except KeyboardInterrupt: pass total = time.time() - gen.start if args.random: logging.info("Sent %d bytes in %d packets in %.3fs (%d pps, %d bps)", gen.bytes_sent, gen.sent, total, gen.sent / total, (gen.bytes_sent * 8) / total) else: logging.info("Sent %d %dB packets in %.3fs (%d pps, %d bps)", gen.sent, gen.size, total, gen.sent / total, (gen.sent * gen.size * 8) / total)
def get_addr(self): return SCIONAddr.from_values(self.ia, self.host)
def _needs_local_processing(self, pkt): return pkt.addrs.dst in [ self.addr, SCIONAddr.from_values(self.addr.isd_as, self.interface.addr), ]
def __init__(self, isd_as, ip, pubkey): self.addr = SCIONAddr.from_values(ISD_AS(isd_as), haddr_parse(1, ip)) self.pubkey = pubkey