def reg_dispatcher(sock, addr, port, init=True, svc=None, scmp=True):
"""
Helper function for registering app with dispatcher
"""
buf = _pack_dispatcher_msg(addr, port, svc, scmp)
if not _connect_dispatcher(sock, init):
return
try:
sock.send(buf)
except OSError:
logging.error("Error while sending registration message")
return False
old_timeout = sock.settimeout(30.0)
try:
buf, _ = sock.recv()
except OSError:
logging.error("Error while receiving registration response")
return False
if not buf:
logging.error("Dispatcher closed socket, retry later")
return False
port = struct.unpack("H", buf)[0]
if not port:
logging.critical("Failed to register with dispatcher")
kill_self()
logging.debug("Registered to dispatcher for addr %s:%d", addr, port)
sock.port = port
sock.settimeout(old_timeout)
return True
def _missing_trc_versions(self, trc_versions):
"""
Check which intermediate trcs are missing and return their versions.
:returns: the missing TRCs'
:rtype set
"""
missing_trcs = set()
for isd, versions in trc_versions.items():
# If not local TRC, only request versions contained in ASMarkings
if isd is not self.topology.isd_as[0]:
for ver in versions:
if self.trust_store.get_trc(isd, ver) is None:
missing_trcs.add((isd, ver))
continue
# Local TRC
max_req_ver = max(versions)
max_local_ver = self.trust_store.get_trc(isd)
lower_ver = 0
if max_local_ver is None:
# This should never happen
logging.critical("Local TRC not found!")
kill_self()
lower_ver = max_local_ver.version + 1
for ver in range(lower_ver, max_req_ver + 1):
missing_trcs.add((isd, ver))
return missing_trcs
def run(self):
"""
Tests AS request/reply functionality before entering the sending loop.
"""
if not self._test_as_request_reply():
self._shutdown()
kill_self()
super().run()
def close(self):
super().close()
if not self.addr:
return
try:
os.unlink(self.addr)
except OSError as e:
logging.critical("Error unlinking unix socket: %s", e)
kill_self()
def _kazoo_start(self):
"""Connect the Kazoo client to Zookeeper."""
logging.info("Connecting to Zookeeper")
try:
self.kazoo.start()
except KazooTimeoutError:
logging.critical(
"Timed out connecting to Zookeeper on startup, exiting")
kill_self()
def bind(self, addr, desc=None):
self.addr = addr
try:
self.sock.bind(addr)
except OSError as e:
logging.critical("Error binding to %s: %s", addr, e)
kill_self()
self.sock.listen(5)
if desc:
logging.debug("%s bound to %s", desc, addr)
def _handle_response(self, spkt):
spkt.parse_payload()
l4 = spkt.l4_hdr
pld = spkt.get_payload()
if (l4.TYPE == L4Proto.SCMP and l4.class_ == SCMPClass.GENERAL
and l4.type == SCMPGeneralClass.ECHO_REPLY
and pld.info.id == self.info.id
and pld.info.seq == self.info.seq):
logging.info("Success!\n%s", spkt)
else:
logging.error("Failure:\n%s", spkt)
kill_self()
def _maintain_hash_tree(self):
"""
Maintain the hashtree. Update the the windows in the connected tree
"""
with self._hash_tree_lock:
if self._next_tree is not None:
self._hash_tree.update(self._next_tree)
self._next_tree = None
else:
logging.critical("Did not create hashtree in time; dying")
kill_self()
logging.info("New Hash Tree TTL beginning")
def bind(self, addr, desc=None):
self.addr = addr
# Use 0666 for socket permissions
old_mask = os.umask(0o111)
try:
self.sock.bind(addr)
except OSError as e:
logging.critical("Error binding to %s: %s", addr, e)
kill_self()
os.umask(old_mask)
self.sock.listen(5)
if desc:
logging.debug("%s bound to %s", desc, addr)
def _get_path_direct(self, flags=0):
logging.debug("Sending PATH request for %s", self.dst)
# Get paths through local API.
paths = []
for _ in range(5):
paths = self.sd.get_paths(self.dst.isd_as, flags=flags)
if paths:
break
else:
logging.critical("Unable to get path directly from sciond")
kill_self()
self.path = paths[0]
self._get_iflist()
def _send_pkt(self, spkt, next_=None):
if not next_:
try:
fh_info = lib_sciond.get_overlay_dest(
spkt, connector=self._connector)
except lib_sciond.SCIONDLibError as e:
logging.error("Error getting first hop: %s" % e)
kill_self()
next_hop = fh_info.ipv4() or fh_info.ipv6()
port = fh_info.p.port
else:
next_hop, port = next_
assert next_hop is not None
logging.debug("Sending (via %s:%s):\n%s", next_hop, port, spkt)
self.sock.send(spkt.pack(), (next_hop, port))
def _try_sciond_api(self, flush=False):
flags = lib_sciond.PathRequestFlags(flush=flush)
start = time.time()
while time.time() - start < API_TOUT:
try:
path_entries = lib_sciond.get_paths(self.dst.isd_as,
flags=flags,
connector=self._connector)
except lib_sciond.SCIONDConnectionError as e:
logging.error("Connection to SCIOND failed: %s " % e)
break
except lib_sciond.SCIONDLibError as e:
logging.error("Error during path lookup: %s" % e)
continue
return path_entries
logging.critical("Unable to get path from local api.")
kill_self()
def _setup_tcp_accept_socket(self, svc):
if not self.USE_TCP:
return
MAX_TRIES = 40
for i in range(MAX_TRIES):
try:
self._tcp_sock = SCIONTCPSocket()
self._tcp_sock.setsockopt(SockOpt.SOF_REUSEADDR)
self._tcp_sock.set_recv_tout(TCP_ACCEPT_POLLING_TOUT)
self._tcp_sock.bind((self.addr, self._port), svc=svc)
self._tcp_sock.listen()
break
except SCIONTCPError as e:
logging.warning("TCP: Cannot connect to LWIP socket: %s" % e)
time.sleep(1) # Wait for dispatcher
else:
logging.critical("TCP: cannot init TCP socket.")
kill_self()
def bind(self, addr, port=0, desc=None):
"""
Bind socket to the specified address & port. If `addr` is ``None``, the
socket will bind to all interfaces.
:param str addr: Address to bind to (can be ``None``, see above).
:param int port: Port to bind to.
:param str desc: Optional purpose of the port.
"""
if addr is None:
addr = "::"
if self._addr_type == AddrType.IPV4:
addr = ""
try:
self.sock.bind((addr, port))
except OSError as e:
logging.critical("Error binding to [%s]:%s: %s", addr, port, e)
kill_self()
self.port = self.sock.getsockname()[1]
if desc:
logging.debug("%s bound to %s:%d", desc, addr, self.port)
def _try_sciond_api(self):
sock = ReliableSocket()
msg = b'\x00' + self.dst.isd_as.pack()
start = time.time()
try:
sock.connect(self.sd.api_addr)
except OSError as e:
logging.critical("Error connecting to sciond: %s", e)
kill_self()
while time.time() - start < API_TOUT:
logging.debug("Sending path request to local API at %s",
self.sd.api_addr)
sock.send(msg)
data = Raw(sock.recv()[0], "Path response")
if data:
sock.close()
return data
logging.debug("Empty response from local api.")
logging.critical("Unable to get path from local api.")
sock.close()
kill_self()
def handle_error(self, *args, **kwargs):
log_exception("Error when serving DNS request:")
kill_self()
