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