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 _parse(self, src_type, dst_type, raw): data = Raw(raw, self.NAME, self.calc_lens(src_type, dst_type)[0]) self.src = SCIONAddr((src_type, data.get())) data.pop(len(self.src)) self.dst = SCIONAddr((dst_type, data.get())) data.pop(len(self.dst)) self.update() if self.src.host.TYPE == AddrType.SVC: raise SCMPBadSrcType("Invalid source type: SVC")
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, raw): data = Raw(raw, self.NAME, self.MIN_LEN, min_=True) src_type = data.pop(1) dst_type = data.pop(1) self.src = SCIONAddr((src_type, data.get())) data.pop(len(self.src)) self.dst = SCIONAddr((dst_type, data.get())) data.pop(len(self.dst)) padding_len = len(data) % OpaqueField.LEN self.path = parse_path(data.pop(len(data) - padding_len))
class PathTransOFPath(Serializable): """ Class used by PathTransportExt to encapsulate a path in data-plane format. """ NAME = "PathTransOFPath" MIN_LEN = 2 def __init__(self, raw=None): # pragma: no cover """ Initialize an instance of the class PathTransOFPath. :param raw: :type raw: """ self.src = None self.dst = None self.path = None super().__init__(raw) def _parse(self, raw): data = Raw(raw, self.NAME, self.MIN_LEN, min_=True) src_type = data.pop(1) dst_type = data.pop(1) self.src = SCIONAddr((src_type, data.get())) data.pop(len(self.src)) self.dst = SCIONAddr((dst_type, data.get())) data.pop(len(self.dst)) padding_len = len(data) % OpaqueField.LEN self.path = parse_path(data.pop(len(data) - padding_len)) @classmethod def from_values(cls, src, dst, path): # pragma: no cover inst = cls() inst.src = src inst.dst = dst inst.path = path return inst def pack(self): # pragma: no cover packed = [] packed.append(struct.pack("!B", self.src.host.TYPE)) packed.append(struct.pack("!B", self.dst.host.TYPE)) packed.append(self.src.pack()) packed.append(self.dst.pack()) packed.append(self.path.pack()) return b"".join(packed) def __len__(self): # pragma: no cover return len(self.pack()) def __str__(self): return "%s -> %s\n%s" % (self.src, self.dst, self.path)
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 _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 calc_lens(cls, dst_type, src_type): try: data_len = SCIONAddr.calc_len(dst_type) except HostAddrInvalidType: raise SCMPBadDstType( "Unsupported dst address type: %s" % dst_type) from None try: data_len += SCIONAddr.calc_len(src_type) except HostAddrInvalidType: raise SCMPBadSrcType( "Unsupported src address type: %s" % src_type) from None pad_len = calc_padding(data_len, cls.BLK_SIZE) total_len = data_len + pad_len assert total_len % cls.BLK_SIZE == 0 return total_len, pad_len
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 _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 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 _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 __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 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 test(self, get_type, raw, isd_as): # Setup inst = SCIONAddr() haddr_type = create_mock(["LEN"]) haddr_type.LEN = 42 get_type.return_value = haddr_type data = create_mock(["pop"]) data.pop.side_effect = ("isd-as", "raw addr") raw.return_value = data isd_as.LEN = 4 # Call inst._parse("atype", "data") # Tests get_type.assert_called_once_with("atype") raw.assert_called_once_with("data", "SCIONAddr", 42 + 4, min_=True) assert_these_calls(data.pop, [call(4), call(42)]) isd_as.assert_called_once_with("isd-as") ntools.eq_(inst.isd_as, isd_as.return_value) haddr_type.assert_called_once_with("raw addr") ntools.eq_(inst.host, haddr_type.return_value)
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 accept(self): self._init_accept_sock() sockname = self._lwip_accept.getsockname()[-SOCK_PATH_LEN:] sockname = sockname.encode('ascii') # Confirmation from old (UNIX) socket. req = APICmd.ACCEPT + sockname self._exec_cmd(req, True) new_sock, _ = self._lwip_accept.accept() # Metadata (path and addr) from new (UNIX) socket. rep = get_lwip_reply(new_sock) self._handle_reply(req[:CMD_SIZE], rep) logging.debug("accept() raw reply: %s", rep) rep = rep[RESP_SIZE:] path_len, = struct.unpack("H", rep[:2]) rep = rep[2:] path = SCIONPath(rep[:path_len]) path.reverse() rep = rep[path_len:] addr = SCIONAddr((rep[0], rep[1:])) # Everything is ok, create new SCION TCP socket. sock = SCIONTCPSocket(new_sock, rpc_mode=False) return sock, addr, path