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
