def validate(self, payload):
# Strip off udp header size.
payload_len = self.total_len - self.LEN
if payload_len != len(payload):
raise SCMPBadPktLen(
"%s: length in header (%dB) does not match "
"supplied payload (%dB)" %
(self.NAME, self.total_len, self.LEN + len(payload)), 0)
checksum = self._calc_checksum(payload)
if checksum != self._checksum:
raise SCIONChecksumFailed(
"%s: checksum in header (%s) does not match "
"checksum of supplied data (%s)" % (
self.NAME, hex_str(self._checksum), hex_str(checksum)))
def __str__(self):
return (
"%s(%sB): class: %s type: %s "
"length: %sB checksum: %s timestamp: %s" %
(self.NAME, self.LEN, SCMPClass.to_str(self.class_),
scmp_type_name(self.class_, self.type), self.total_len,
hex_str(self._checksum), iso_timestamp(self.timestamp / 1000000)))
def short_desc(self):
a = []
a.append("%s: id: %s (owner: %s) Up? %s" %
(self.NAME, hex_str(self.p.id), self.isd_as(), self.p.up))
for line in str(self.info).splitlines():
a.append(" %s" % line)
return "\n".join(a)
def start_element(self, hex_=False):
"""
Returns the start element of the chain.
"""
if hex_:
return hex_str(self._start_ele)
return self._start_ele
def __str__(self):
s = []
s.append("%s: From: %s (IF: %s) To: %s (IF: %s) Ingress MTU:%s" %
(self.NAME, self.isd_as(), self.p.ifID, self.p.mtu))
s.append(" %s" % self.hof())
s.append(" ig_rev_token: %s" % hex_str(self.p.igRevToken))
return "\n".join(s)
def __str__(self):
with self._lock:
if self.blocks:
act_info = self.blocks[0].info
else:
act_info = "(No active blocks)"
return "SteadyPath %s to %s: %s" % (hex_str(
self.id), self.remote, act_info)
def _process_reply(self, pkt, ext):
"""Process a reply to a steady path request."""
path_id = ext.path_ids[0]
dest = pkt.addrs.src.isd_as
steady = self.dests[dest].get(path_id, None)
if not steady:
logging.error("Unknown path ID: %s:\n%s", hex_str(path_id), pkt)
return
steady.process_reply(pkt, ext)
def current_element(self, hex_=False):
"""
Return the currently used element or 'None'.
"""
if self._next_ele_ptr < 0 or self._next_ele_ptr >= self._length - 1:
return None
ele = self.entries[self._next_ele_ptr + 1]
if hex_:
return hex_str(ele)
return ele
def next_element(self, hex_=False):
"""
Return the next element in the hash chain or 'None' if the chain is
empty.
"""
if self._next_ele_ptr < 0:
return None
ele = self.entries[self._next_ele_ptr]
if hex_:
return hex_str(ele)
return ele
def handle_request(self, packet, _, from_local_socket=True, sock=None):
"""
Main routine to handle incoming SCION packets.
:param bytes packet: The incoming packet to handle.
:param tuple sender: Tuple of sender IP, port.
:param bool from_local_socket:
True, if the packet was received on the local socket.
"""
from_local_as = from_local_socket
pkt = self._parse_packet(packet)
if not pkt:
return
if pkt.ext_hdrs:
logging.debug("Got packet (from_local_as? %s):\n%s", from_local_as,
pkt)
try:
flags = self.handle_extensions(pkt, True, from_local_as)
except SCMPError as e:
self._scmp_validate_error(pkt, e)
return
stop, needs_local = self._process_flags(flags, pkt, from_local_as)
if stop:
logging.debug("Stopped processing")
return
try:
needs_local |= self._needs_local_processing(pkt)
except SCMPError as e:
self._scmp_validate_error(pkt, e)
return
if needs_local:
try:
pkt.parse_payload()
except SCIONBaseError:
log_exception("Error parsing payload:\n%s" % hex_str(packet))
return
handler = self._get_handler(pkt)
else:
# It's a normal packet, just forward it.
handler = self.handle_data
logging.debug(
"handle_request (from_local_as? %s):"
"\n %s\n %s\n handler: %s", from_local_as, pkt.cmn_hdr,
pkt.addrs, handler)
if not handler:
return
try:
handler(pkt, from_local_as)
except SCMPError as e:
self._scmp_validate_error(pkt, e)
except SCIONBaseError:
log_exception("Error handling packet: %s" % pkt)
def _process_req(self, pkt, ext):
"""Process a steady path request."""
path_id = ext.path_ids[0]
self.srcs.setdefault(ext.src_ia, {})
if ext.setup and path_id in self.srcs[ext.src_ia]:
logging.error("Setup request for existing path id: %s\n%s",
hex_str(path_id), pkt)
return
elif not ext.setup and path_id not in self.srcs[ext.src_ia]:
logging.error("Renewal request for non-existant path id: %s\n%s",
hex_str(path_id), pkt)
return
ifid = find_last_ifid(pkt, ext)
if ifid not in self.link_states:
logging.error("Packet came from unknown interface '%s':\n%s", ifid,
pkt)
return
if not ext.accepted:
# Request was already rejected, so just send the packet back.
pkt.reverse()
self.sendq.put(pkt)
return
state = self.link_states[ifid]
req_info = ext.req_block.info
bwsnap = req_info.bw.to_snap()
bwhint = state.add_steady(path_id, req_info.index, bwsnap,
req_info.exp_tick, True, ext.setup)
if bwhint is not None:
# This shouldn't happen - if the local BR accepted the reservation,
# then there should be enough bandwidth available for it. This means
# our state is out of sync.
logging.critical("Requested: %s Available bandwidth: %s\n%s",
bwsnap, bwhint, pkt)
return
self.srcs[ext.src_ia][path_id] = None
# All is good, return the packet to the requestor.
pkt.reverse()
self.sendq.put(pkt)
def _get_msg(self):
if len(self._buf) < 4:
return None
msg_len = struct.unpack("!I", self._buf[:4])[0]
if msg_len + 4 > len(self._buf):
return None
msg = self._buf[4:4 + msg_len]
self._buf = self._buf[4 + msg_len:]
try:
return msg_from_raw(msg)
except SCIONBaseError:
log_exception("Error parsing message: %s" % hex_str(msg),
level=logging.ERROR)
return None
def _parse_end(self, data, req):
"""
Parse the request block/offer block at the end of the header, if
present.
"""
if req:
if self.accepted:
self.req_block = self._parse_block(data, self.total_hops,
self.steady)
else:
self.req_block = self._parse_offers_block(data)
if len(data):
raise SCIONParseError("%s bytes left when parsing %s: %s" %
(len(data), self.NAME, hex_str(data.get())))
self._parse_src_ia()
def _parse_packet(self, packet):
try:
pkt = SCIONL4Packet(packet)
except SCMPError as e:
self._scmp_parse_error(packet, e)
return None
except SCIONBaseError:
log_exception("Error parsing packet: %s" % hex_str(packet),
level=logging.ERROR)
return None
try:
pkt.validate(len(packet))
except SCMPError as e:
self._scmp_validate_error(pkt, e)
return None
except SCIONChecksumFailed:
logging.debug("Dropping packet due to failed checksum:\n%s", pkt)
return pkt
def serve_forever(soc, bridge_mode, scion_mode, kbase, source_isd_as,
target_isd_as):
"""
Serve incoming HTTP requests until a KeyboardInterrupt is received.
:param soc: Socket object that belongs to the server.
:type soc: socket
:param handler: The type of class to be instantiated as the
connection handler.
:type handler: ConnectionHandler or ForwardingProxyConnectionHandler
:param scion_soc: Use SCION multi-path sockets.
:type scion_soc: boolean
"""
while True:
con, addr = soc.accept()
conn_id = hex_str(os.urandom(CONN_ID_BYTES))
if bridge_mode:
params = (ForwardingProxyConnectionHandler, con, addr, conn_id,
scion_mode, kbase, source_isd_as, target_isd_as)
else:
params = ConnectionHandler, con, addr, conn_id
threading.Thread(target=thread_safety_net, args=params,
daemon=True).start()
def __str__(self):
flags = self._pack_flags()
return ("%s(%dB): flags: %s, exp_time: %s, "
"ingress: %s, egress: %s, mac: %s" %
(self.NAME, len(self), HopOFFlags.to_str(flags), self.exp_time,
self.ingress_if, self.egress_if, hex_str(self.mac)))
def __str__(self):
tmp = ["%s(%dB):" % (self.NAME, len(self))]
tmp.append("Ingress: %s" % self.ingress)
tmp.append("Egress: %s" % self.egress)
tmp.append("Mac: %s" % hex_str(self.mac))
return " ".join(tmp)
def hdr_str(name, val):
if not val:
return
ret.append(" %s(%dB): %s" % (name, len(val), hex_str(val)))
def log_recv(self, handler, data):
logging.log(self.level, "Received: %s <%d> : %s",
self._common_prefix(handler, data), len(data),
hex_str(data))
def __str__(self):
return ("%s(%sB): Height: %s Order: %s\n\tSignature: %s\n\tHashes: %s" % (
self.NAME, len(self), self.height, hex_str(self.order),
hex_str(self.signature), hex_str(self.hashes)))
def log_send(self, handler, data):
logging.log(self.level, "Sent: %s <%d> : %s",
self._common_prefix(handler, data), len(data),
hex_str(data))
def __str__(self):
return "UDP hdr (%sB): sport: %s dport: %s length: %sB checksum: %s" \
% (self.LEN, self.src_port, self.dst_port,
self.total_len, hex_str(self._checksum))
def __str__(self):
return "%s(%dB): class: %s payload: %s" % (self.NAME, len(
self), ExtensionClass.to_str(self.EXT_CLASS), hex_str(self.pack()))
def __str__(self):
s = "%s(%dB): %s" % (self.NAME, len(
self._raw), hex_str(self._raw[:self.SNIPPET_LEN]))
if len(self._raw) > self.SNIPPET_LEN:
s += "[...]"
return s
def __str__(self):
return ("%s(%dB): IOF offset:%sB HOF offset: %sB "
"IF id: %s Ingress: %s Rev token: %s" %
(self.NAME, len(self), self.iof_off, self.hof_off, self.if_id,
self.ingress, hex_str(self.rev_info)))
def __str__(self):
return "%s(%sB): Direction: %s MAC: %s" % (
self.NAME, len(self), SCMPAuthDRKeyDirections.to_str(self.direction), hex_str(self.mac))
def __str__(self):
return "%s(%sB):\n\tMeta: %s\n\tAuth: %s" % (self.NAME, len(
self), hex_str(self.metadata), hex_str(self.authenticator))
def __str__(self):
s = "PayloadRaw(%dB): %s" % (len(
self._raw), hex_str(self._raw[:self.SNIPPET_LEN]))
if len(self._raw) > self.SNIPPET_LEN:
s += "[...]"
return s
def __str__(self):
return "%s(%dB): id:%s seq:%s" % (self.NAME, self.LEN, hex_str(
self.id), self.seq)
def _id_with_owner(self, id_): # pragma: no cover
return "%s (Owner: %s)" % (hex_str(id_), ISD_AS(id_[:ISD_AS.LEN]))
