def process_MPLS_frame(self, m_fr, i):
inface = 1
if self.decap_tbl_D: #DL: MPLS decapsulation if there exists the destination host for the mpls package
if self.decap_tbl_D[m_fr.dest]:
packet = m_fr.packet
inface = self.decap_tbl_D[m_fr.dest]
else: #DL: MPLS forwarding if there's no decapsulation needed then it will be pushed on and relabeled for the next router
for in_lbl in self.frwd_tbl_D:
if m_fr.label == in_lbl:
for interface in self.frwd_tbl_D[in_lbl]:
m_fr.label = self.frwd_tbl_D[in_lbl][interface]
inface = interface
print('%s: processing MPLS frame "%s"' % (self, m_fr))
# for now forward the frame out interface 1
try: #DL: If packet exists then we need to forward that network packet to the host
if packet:
try:
fr = LinkFrame('Network', packet.to_byte_S())
self.intf_L[inface].put(fr.to_byte_S(), 'out', True)
print('%s: forwarding frame "%s" from interface %d to %d' %
(self, fr, i, inface))
except queue.Full:
print('%s: frame "%s" lost on interface %d' % (self, p, i))
pass
except: #DL: If that packet does not exist then we look to forward it along to the next router in the line
try:
fr = LinkFrame('MPLS', m_fr.to_byte_S())
self.intf_L[inface].put(fr.to_byte_S(), 'out', True)
print('%s: forwarding frame "%s" from interface %d to %d' %
(self, fr, i, inface))
except queue.Full:
print('%s: frame "%s" lost on interface %d' % (self, p, i))
pass
def process_MPLS_frame(self, m_fr, i):
print('%s: processing MPLS frame "%s"' % (self, m_fr.__str__()))
forward = self.frwd_tbl_D.get(i)
if forward:
pkt = m_fr
fr = LinkFrame('MPLS', pkt.to_byte_S())
decap = self.decap_tbl_D.get(i)
if decap:
pkt = NetworkPacket.from_byte_S(m_fr.data_S.__str__())
print('%s: decapsulated packet "%s" from MPLS frame "%s"' % (self, pkt, m_fr))
fr = LinkFrame('Network', pkt.to_byte_S())
out = 1
if self.name is 'RA':
if m_fr.label == 'RB':
out = 2
else:
out = 3
elif self.name is 'RD':
out = 2
# for now forward the frame out interface 1
try:
self.intf_L[out].put(fr.to_byte_S(), 'out', True)
print('%s: forwarding frame "%s" from interface %d to %d' % (self, fr, i, 1))
except queue.Full:
print('%s: frame "%s" lost on interface %d' % (self, m_fr, i))
pass
def process_MPLS_frame(self, m_fr, i):
print('%s: processing MPLS frame "%s"' % (self, m_fr.to_byte_S()))
try:
info = self.decap_tbl_D[m_fr.label]
pkt = m_fr.network_packet
l_fr = LinkFrame('Network', pkt.to_byte_S())
out_intf = info[1]
try:
self.intf_L[out_intf].put(l_fr.to_byte_S(), 'out', True)
print(
'%s: forwarding Decapsulated NetPKT "%s" from interface %d to %d'
% (self, pkt, i, out_intf))
except queue.Full:
print('%s: frame "%s" lost on interface %d' % (self, m_fr, i))
pass
except KeyError:
try:
# Gets the info corresponding to the in_label and in interface
info = self.frwd_tbl_D[m_fr.label][i]
m_fr.label = info[0]
out_intf = info[1]
print("Assigning MPLS with new label %s" % info[0])
l_fr = LinkFrame('MPLS', m_fr.to_byte_S())
self.intf_L[out_intf].put(l_fr.to_byte_S(), 'out', True)
print('%s: forwarding frame "%s" from interface %d to %d' %
(self, m_fr, i, out_intf))
except queue.Full:
print('%s: frame "%s" lost on interface %d' % (self, m_fr, i))
pass
def process_MPLS_frame(self, m_fr, i):
#TODO: implement MPLS forward, or MPLS decapsulation if this is the last hop router for the path
#print("*********** interface: ", self)
#print("*********** interface number: ", i)
print('%s: processing MPLS frame "%s"' % (self, m_fr))
#print("UOUUOUUOOUOOUUOUOUOUOUOUOUOUUOOUUO", self, " ", i)
if self.decap_tbl_D.get(
(str(self), i), "no"
) != "no": #check if the (interface, interface_number) is in the encap dict
print(
"* * * ** **** ** * * **** ** * ** ** * * * let's decapsulate"
)
byte_s = m_fr.to_byte_S()
pkt = NetworkPacket.from_byte_S(byte_s[3:])
print("THIS IS THE PACKET", pkt)
fr = LinkFrame('Network', pkt.to_byte_S())
self.intf_L[2].put(fr.to_byte_S(), 'out', True)
# for now forward the frame out interface 1
else:
try:
label = m_fr.get_Label()
#print(' %% % % % % % % % % % % % % % % % % %%', label)
interface_n = self.frwd_tbl_D[str(self) + str(i)][2]
fr = LinkFrame('MPLS', m_fr.to_byte_S())
self.intf_L[interface_n].put(fr.to_byte_S(), 'out', True)
print('%s: forwarding frame "%s" from interface %d to %d' %
(self, fr, interface_n, 1))
except queue.Full:
print('%s: frame "%s" lost on interface %d' % (self, p, i))
pass
def process_MPLS_frame(self, m_fr, i):
print('%s: processing MPLS frame "%s"' % (self, m_fr))
decap_interface = self.decap_tbl_D.get(m_fr.label)
if decap_interface is not None:
packet = m_fr.data_S
out_interface = decap_interface
try:
fr = LinkFrame('Network', m_fr.data_S)
self.intf_L[out_interface].put(fr.to_byte_S(), 'out', True)
print('%s: forwarding frame "%s" from interface %d to %d' %
(self, fr, i, 1))
except queue.Full:
print('%s: frame "%s" lost on interface %d' % (self, m_fr, i))
pass
else:
dictionary = self.frwd_tbl_D[(i, m_fr.label)]
if dictionary is not None:
out_interface = dictionary[0]
try:
fr = LinkFrame('MPLS', m_fr.to_byte_S())
self.intf_L[out_interface].put(fr.to_byte_S(), 'out', True)
print(
'%s: forwarding MPLS frame "%s" from interface %d to %d'
% (self, fr, i, 1))
except queue.Full:
print('%s: frame "%s" lost on interface %d' %
(self, m_fr, i))
pass
def process_MPLS_frame(self, m_fr, i):
interface = -1
if int(m_fr.label) in self.decap_tbl_D:
interface = self.decap_tbl_D[int(m_fr.label)]
packet = m_fr.pkt
fr = LinkFrame('Network', packet.to_byte_S())
self.intf_L[interface].put(fr.to_byte_S(), 'out', True)
#print('%s: decapsulated frame "%s" from interface %d to %d\n' % (self, fr, i, interface))
self.print_queues()
else:
check_tuple = (i, int(m_fr.label))
tuple = self.frwd_tbl_D[check_tuple]
interface = tuple[0]
m_fr.label = tuple[1]
#print('%s: processing MPLS frame "%s"\n' % (self, m_fr))
try:
fr = LinkFrame('MPLS', m_fr.to_byte_S())
self.intf_L[interface].put(fr.to_byte_S(), 'out', True)
#print('%s: forwarding frame "%s" from interface %d to %d\n' % (self, fr, i, interface))
self.print_queues()
except queue.Full:
print('%s: frame "%s" lost on interface %d\n' % (self, fr, i))
pass
def process_MPLS_frame(self, m_fr, i):
#TODO: implement MPLS forward, or MPLS decapsulation if this is the last hop router for the path
print("Label: " + m_fr.label)
data = self.frwd_tbl_D.get(m_fr.label, '')
#print("Data: " + data)
if data != '':
m_fr.label = data[0]
m_fr.dst = data[1]
interf = data[2]
end = self.decap_tbl_D.get(m_fr.label, "CONTINUE")
#print("END = " + end)
print('%s: processing MPLS frame "%s"' % (self, m_fr))
# for now forward the frame out interface 1
try:
if end != "CONTINUE":
pkt = m_fr.to_Network_Packet()
fr = LinkFrame('Network', pkt)
else:
fr = LinkFrame('MPLS', m_fr.to_byte_S())
self.intf_L[interf].put(fr.to_byte_S(), 'out', True)
print('%s: forwarding frame "%s" from interface %d to %d' %
(self, fr, i, 1))
except queue.Full:
print('%s: frame "%s" lost on interface %d' % (self, m_fr, i))
pass
else:
print('****************Could not forward data********************')
print('label was ' + str(m_fr))
def udt_send(self, dst, data_S, priority):
pkt = NetworkPacket(dst, data_S, priority)
print('%s: sending packet "%s" with priority %d' % (self, pkt, priority))
#encapsulate network packet in a link frame (usually would be done by the OS)
fr = LinkFrame('Network', pkt.to_byte_S())
#enque frame onto the interface for transmission
self.intf_L[0].put(fr.to_byte_S(), 'out')
def process_MPLS_frame(self, m_fr, i):
print('%s: processing MPLS frame "%s"' % (self, m_fr))
table = self.frwd_tbl_D[m_fr.label]
m_fr.label = table["outLabel"]
outIntf = table["interface"]
#if the queue is not full, try to decapsulate
try:
#if the next hop is the destination then we can decapsulate the mpls frame
if m_fr.label == table['dest']:
fr = LinkFrame("Network", m_fr.frame)
else:
fr = LinkFrame("MPLS", m_fr.to_byte_S())
self.intf_L[outIntf].put(fr.to_byte_S(), 'out', True)
print('%s: forwarding frame "%s" from interface %d to %d' %
(self, fr, i, outIntf))
except queue.Full:
print('%s: frame "%s" lost on interface %d' % (self, m_fr, i))
pass
def process_MPLS_frame(self, m_fr, i):
#TODO: implement MPLS forward, or MPLS decapsulation if this is the last hop router for the path
#we can do incoming interface, pkt_dst, and then outgoing interface:
#decap_tbl_D = {0 : {H11 : 1}, 1: {H34: 3}, 2: {H17: 4}, 3: {H55: 0}}
#better idea: just do pkt dst and outgoing interface {H1: 1}
#Get the ultimate destination out of the MPLS label
print('%s: processing MPLS frame "%s"' % (self, m_fr))
m_fr_dst_tmp = re.search('(,\w{1,2},)', m_fr.label, flags=0).group()
m_fr_dst = m_fr_dst_tmp.replace(',', '')
#check to see if we have an interface to forward an MPLS out of
if i in self.frwd_tbl_D:
out_interface = self.frwd_tbl_D[i]
frame_type = 'MPLS'
try:
fr = LinkFrame(frame_type, m_fr.to_byte_S())
self.intf_L[out_interface].put(fr.to_byte_S(), 'out', True)
print('%s: forwarding frame "%s" from interface %d to %d' %
(self, fr, i, out_interface))
except queue.Full:
print('%s: frame "%s" lost on interface %d' % (self, m_fr, i))
pass
elif m_fr_dst in self.decap_tbl_D:
#No out interface for an MPLS
#MPLS frame is meant to be decapsulated instead of forwarded
out_interface = self.decap_tbl_D[m_fr_dst]
frame_type = 'Network'
pkt = NetworkPacket.from_byte_S(m_fr.packet)
try:
fr = LinkFrame(frame_type, pkt.to_byte_S())
self.intf_L[out_interface].put(fr.to_byte_S(), 'out', True)
print('%s: forwarding frame "%s" from interface %d to %d' %
(self, fr, i, out_interface))
except queue.Full:
print('%s: frame "%s" lost on interface %d' % (self, pkt, i))
pass
else:
print('DEBUG: Something went wrong')
def process_MPLS_frame(self, m_fr, i):
#TODO: implement MPLS forward, or MPLS decapsulation if this is the last hop router for the path
print('%s: processing MPLS frame "%s"' % (self, m_fr))
## From the label received, we determine where it's going
tbl_D = self.frwd_tbl_D[m_fr.label]
m_fr.label = tbl_D["outLabel"]
outInterface = tbl_D["intf"]
##see if we can decapsulate
try:
if m_fr.label == tbl_D['dest']:
fr = LinkFrame("Network", m_fr.frame)
else:
fr = LinkFrame("MPLS", m_fr.to_byte_S())
# fr = LinkFrame('Network', m_fr.to_byte_S()) ##this is how it used to be set up. Always assume it was in there
self.intf_L[outInterface].put(fr.to_byte_S(), 'out', True)
print('%s: forwarding frame "%s" from interface %d to %d' %
(self, fr, i, outInterface))
except queue.Full:
print('%s: frame "%s" lost on interface %d' % (self, m_fr, i))
pass
def process_MPLS_frame(self, m_fr, i):
if m_fr.label in self.decap_tbl_D:
intf = self.decap_tbl_D[m_fr.label]
packet = m_fr.pkt
fr = LinkFrame('Network', packet.to_byte_S())
self.intf_L[intf].put(fr.to_byte_S(), 'out', True)
print('%s: decapsulated frame "%s" from interface %d to %d' % (self, fr, i, 1))
else:
check = (i, m_fr.label)
t = self.frwd_tbl_D[check]
intf = t[0]
m_fr.label = t[1]
print('%s: processing MPLS frame "%s"' % (self, m_fr))
try:
fr = LinkFrame('MPLS', m_fr.to_byte_S())
self.intf_L[intf].put(fr.to_byte_S(), 'out', True)
print('%s: forwarding frame "%s" from interface %d to %d' % (self, fr, i, 1))
except queue.Full:
print('%s: frame "%s" lost on interface %d' % (self, fr, i))
pass
def process_MPLS_frame(self, m_fr, i):
#TODO: implement MPLS forward, or MPLS decapsulation if this is the last hop router for the path
print('%s: processing MPLS frame "%s"' % (self, m_fr.label))
try:
compare = list(self.decap_tbl_D)[0]
except:
compare = None
if (m_fr.label == compare):
print("Last Hop, Decapsulation")
try:
m_fr.label = self.decap_tbl_D[
m_fr.
label] #check the label and assign the corresponding destination
fr = LinkFrame('Network', m_fr.to_byte_S())
self.intf_L[2].put(fr.to_byte_S(), 'out', True)
print('%s: forwarding packet "%s" from interface %d to %d' %
(self, fr, i, 1))
except queue.Full:
print('%s: frame "%s" lost on interface %d' % (self, m_fr, i))
pass
else:
print("Implement MPLS Forward")
try:
inlabel = m_fr.label
outlabel = list(
self.frwd_tbl_D[inlabel][i].keys())[0] #get out interface
print(outlabel)
inter = self.frwd_tbl_D[inlabel][i][outlabel] #get out label
m_fr.label = outlabel
fr = LinkFrame('MPLS', m_fr.to_byte_S())
self.intf_L[inter].put(fr.to_byte_S(), 'out', True)
print('%s: forwarding frame "%s" from label %d to %d' %
(self, fr, int(inlabel), int(outlabel)))
except queue.Full:
print('%s: frame "%s" lost on interface %d' % (self, m_fr, i))
pass
def process_MPLS_frame(self, m_fr, i):
#TODO: implement MPLS forward, or MPLS decapsulation if this is the last hop router for the path
print('%s: processing MPLS frame "%s"' % (self, m_fr))
# for now forward the frame out interface 1
outInterface = self.frwd_tbl_D[(m_fr.dst, i)][1]
try:
if i in self.decap_tbl_D:
if self.decap_tbl_D[i] == m_fr.dst:
fr = LinkFrame('Network', m_fr.data_S)
#self.intf_L[outInterface].put(fr.to_byte_S(), 'out', True)
print('%s: forwarding frame "%s" from interface %d to %d' %
(self, fr, i, outInterface))
else:
fr = LinkFrame("MPLS", m_fr.to_byte_S())
self.intf_L[outInterface].put(fr.to_byte_S(), 'out', 'True')
print('%s: forwarding frame "%s" from interface %d to %d' %
(self, fr, i, outInterface))
except queue.Full:
print('%s: frame "%s" lost on interface %d' % (self, m_fr, i))
pass
def process_MPLS_frame(self, m_fr, i, priority):
#TODO: implement MPLS forward, or MPLS decapsulation if this is the last hop router for the path
print('%s: processing MPLS frame "%s"' % (self, m_fr))
try:
if (self.decap_tbl_D[m_fr.dst] is "Y"):
pkt = NetworkPacket(m_fr.dst, m_fr.data_S[1:], m_fr.data_S[0])
fr = LinkFrame('Network', pkt.to_byte_S())
j = self.frwd_tbl_D[i][priority][
m_fr.dst] #using a triple nested dictionary now
self.intf_L[j].put(fr.to_byte_S(), 'out', True)
print('%s: forwarding frame "%s" from interface %d to %d' %
(self, fr, i, j))
else:
fr = LinkFrame('MPLS', m_fr.to_byte_S())
j = self.frwd_tbl_D[i][priority][
m_fr.dst] #using a triple nested dictionary now
self.intf_L[j].put(fr.to_byte_S(), 'out', True)
print('%s: forwarding frame "%s" from interface %d to %d' %
(self, fr, i, j))
except queue.Full:
print('%s: frame "%s" lost on interface %d' % (self, m_fr, i))
pass
def process_MPLS_frame(self, m_fr, i):
# TODO: implement MPLS forward, or MPLS decapsulation if this is the last hop router for the path
#print('%s: processing MPLS frame "%s"' % (self, m_fr))
# for now forward the frame out interface 1
try:
# Initalize the output interface to -1
output_interface = -1
#checks if we need to decapsulate or not
if i in self.decap_tbl_D:
# print("Decapsulating Block;\nRouter name:", str(self.name), "\nString received:", str(m_fr.to_byte_s()))
priority = m_fr.packet[2: 3]
dst = m_fr.packet[3:7].strip('0')
data_S = m_fr.packet[7:]
fr = LinkFrame('Network', NetworkPacket(dst, data_S, priority).to_byte_S())
output_interface = self.decap_tbl_D[i][m_fr.label]
else:
fr = LinkFrame('MPLS', m_fr.to_byte_s())
output_interface = self.frwd_tbl_D[int(m_fr.label)]
self.intf_L[output_interface].put(fr.to_byte_S(), 'out', True)
# print('%s: forwarding frame "%s" from interface %d to %d' % (self, fr, i, 1))
except queue.Full:
# print('%s: frame "%s" lost on interface %d' % (self, m_fr, i))
pass
def process_MPLS_frame(self, m_fr, i):
# TODO: implement MPLS forward, or MPLS decapsulation if this is the last hop router for the path
print('%s: processing MPLS frame "%s"' % (self, m_fr))
# for now forward the frame out interface 1
try:
fr = LinkFrame('Network', m_fr.to_byte_S())
# self.print_remaining_queue()
self.intf_L[1].put(fr.to_byte_S(), 'out', True)
self.print_remaining_queue()
print('%s: forwarding frame "%s" from interface %d to %d' %
(self, fr, i, 1))
except queue.Full:
print('%s: frame "%s" lost on interface %d' % (self, m_fr, i))
pass
def process_MPLS_frame(self, m_fr, in_intf):
print('\n%s: processing MPLS frame "%s"' % (self, m_fr))
# if the router has a decapsulation table with specific label
if self.decap_tbl_D.get(m_fr.label) is not None: # Last Hop
print("%s decapsulated packet." % self.name)
# obtain network pack by decapsulation
network_pkt = m_fr.packet
in_label = m_fr.label
intf_out = self.frwd_tbl_D[(in_intf, in_label)][0]
try:
fr = LinkFrame('Network', m_fr.packet) ### m_fr.to_Byte_S
self.intf_L[intf_out].put(fr.to_byte_S(), 'out', True)
print(
'%s: forwarding network packet "%s" from interface %d to %d'
% (self, fr, intf_out, 1))
except queue.Full:
print('%s: frame "%s" lost on interface %d' %
(self, m_fr, intf_out))
pass
# if no decapsulation, then forward
else:
try:
in_label = m_fr.label
out_label = self.frwd_tbl_D[(in_intf, in_label)][1]
intf_out = self.frwd_tbl_D[(in_intf, in_label)][0]
m_fr.label = out_label
fr = LinkFrame('MPLS', m_fr.to_byte_S())
self.intf_L[intf_out].put(fr.to_byte_S(), 'out', True)
print('%s: forwarding frame "%s" from label %d to %d' %
(self, fr, int(in_label), int(out_label)))
except queue.Full:
print('%s: frame "%s" lost on interface %d' %
(self, m_fr, intf_out))
pass
def process_MPLS_frame(self, m_packet, i):
#TODO: implement MPLS forward, or MPLS decapsulation if this is the last hop router for the path
#print('%s: processing MPLS frame "%s"' % (self, m_fr))
# for now forward the frame out interface 1
try:
outInterface = -1
if i in self.decap_tbl_D:
# decapsulate
# print("DECAPSULATION BLOCK\nRouter name = %s\nString received = %s\n" % (str(self.name),m_packet.to_byte_S()))
priority = m_packet.new_packet[2:3]
dst = m_packet.new_packet[3:7].strip('0')
data_S = m_packet.new_packet[7:]
fr = LinkFrame('Network', NetworkPacket(dst, data_S, priority).to_byte_S())
outInterface = self.decap_tbl_D[i][m_packet.label]
else:
fr = LinkFrame('MPLS', m_packet.to_byte_S())
outInterface = self.frwd_tbl_D[int(m_packet.label)]
self.intf_L[outInterface].put(fr.to_byte_S(), 'out', True)
#print('%s: forwarding frame "%s" from interface %d to %d' % (self, fr, i, 1))
except queue.Full:
#print('%s: frame "%s" lost on interface %d' % (self, p, i))
pass
def process_network_packet(self, pkt, i):
#TODO: encapsulate the packet in an MPLS frame based on self.encap_tbl_D
#for now, we just relabel the packet as an MPLS frame without encapsulation
if i in self.encap_tbl_D:
if self.encap_tbl_D[i] == pkt.dst:
m_fr = MPLSF(pkt.dst, pkt)
print('%s: encapsulated packet "%s" as MPLS frame "%s"' %
(self, pkt, m_fr))
#send the encapsulated packet for processing as MPLS frame
self.process_MPLS_frame(m_fr, i)
return
elif i == 0 and pkt.dst == "H1":
m_fr = MPLSF(pkt.dst, pkt)
print('%s: encapsulated packet "%s" as MPLS frame "%s"' %
(self, pkt, m_fr))
#send the encapsulated packet for processing as MPLS frame
self.process_MPLS_frame(m_fr, i)
return
outInterface = self.frwd_tbl_D[(pkt.dst, i)][1]
fr = LinkFrame('Network', (pkt.to_byte_S() + pkt.prio))
self.intf_L[outInterface].put(fr.to_byte_S(), 'out', True)
print('%s: forwarding frame "%s" from interface %d to %d' %
(self, fr, i, outInterface))
def process_network_packet(self, pkt, i):
#TODO: encapsulate the packet in an MPLS frame based on self.encap_tbl_D
#print("process_network_packet being called: ", self, pkt)
#print("*********** interface: ", self)
#print("*********** interface number: ", i)
if self.encap_tbl_D.get(
(str(self), i), "no"
) != "no": #check if the (interface, interface_number) is in the encap dict
print("*#*#*#*#*#**#*#*#*#*##**#*# let's encapsulate")
labelTuple = self.frwd_tbl_D[str(self) + str(i)]
label = labelTuple[0] + str(labelTuple[1])
m_fr = MPLSFrame(pkt, label)
print('%s: encapsulated packet "%s" as MPLS frame "%s"' %
(self, pkt, m_fr))
self.process_MPLS_frame(
m_fr,
i) #This will still get treated as a network packet initially
else:
print("is this the last network packet?")
fr = LinkFrame('Network', pkt.to_byte_S())
self.intf_L[1].put(fr.to_byte_S(), 'out', True)
print('%s: forwarding frame "%s" from interface %d to %d' %
(self, fr, i, 1))
def process_MPLS_frame(self, m_fr, i):
#TODO: implement MPLS forward, or MPLS decapsulation if this is the last hop router for the path
print(
'\nNODE [%s]: --- %s: processing MPLS frame "%s" from incoming interface "%d"\n'
% (self.name, self, m_fr, i))
# for now forward the frame out interface 1
try:
frame_flag = ''
tmp_out_intf = -1
pkt_s = ''
mplsFrame = None
mpls_frame_s = ''
p = None
# Loop via forward table
# Loop via decapsulation table and cheack if frame have to be decapsulated
for node_name, out_in_intf in self.frwd_tbl_D.items():
# Loop via decapsulation table and cheack if frame have to be decapsulated
for out_intf, next_hop_intf in out_in_intf.items():
# In this Network topology 'RD' is the last router, so MPLS frame have to be decapsulated,
# and Network Packet must be created to forward this packet into Host 3
if self.name is 'RD':
for decap_hop_name, decap_intf in self.decap_tbl_D.items(
):
if decap_intf == out_intf:
frame_flag = 'Network'
tmp_out_intf = out_intf
# Decapsulate Frame
pkt_s = str(m_fr)
mplsFrame = MPLSFrame(pkt_s)
mpls_frame_s = mplsFrame.from_byte_S(pkt_s)
if mpls_frame_s[0] is 'M':
pkt_s = mpls_frame_s
mplsFrame = MPLSFrame(mpls_frame_s)
mpls_frame_s = mplsFrame.from_byte_S(pkt_s)
# Build Network Packet
p = NetworkPacket.from_byte_S(mpls_frame_s)
elif self.name is 'RA':
frame_flag = 'MPLS'
tmp_out_intf = out_intf
else:
frame_flag = 'MPLS'
tmp_out_intf = out_intf
# Forward Packets or Frames
if frame_flag is 'Network':
fr = LinkFrame('Network', p.to_byte_S())
self.intf_L[out_intf].put(fr.to_byte_S(), 'out', True)
print(
'@=> %s: forwarding frame "%s" from interface %d to %d <=@'
% (self, fr, out_intf, i))
elif frame_flag is 'MPLS':
# c. [5 points] Implement strict priority forwarding at each router.
# get priority number from this packet
# ============================================================================================= #
"""print("\n\t\t\t @-------=> frame: %s <=-------@\n" % ( str(m_fr) ) )"""
tmp_s = m_fr.from_byte_S(str(m_fr))
if tmp_s[0] is 'M':
tmp_s = m_fr.from_byte_S(str(tmp_s))
"""print("\n\t\t\t @-------=> packet: %s <=-------@\n" % ( tmp_s ) )"""
tmp_s = tmp_s[5:]
priority = int(tmp_s[0])
print(
"\n\t\t\t @-------=> packet: %s --- priority: %d <=-------@\n"
% (tmp_s, priority))
# ============================================================================================= #
fr = LinkFrame('MPLS', m_fr.to_byte_S())
self.intf_L[out_intf].put(fr.to_byte_S(), 'out', True)
print(
'$=> %s: forwarding frame "%s" from interface %d to %d <=$'
% (self, fr, out_intf, i))
except queue.Full:
print('%s: frame "%s" lost on interface %d' % (self, m_fr, i))
pass
