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):
#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 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):
# 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_queues(self):
isNotUsingPriorities = self.getQueuePriorities()
for i in range(len(self.intf_L)):
fr_S = None #make sure we are starting the loop with a blank frame
fr_S = self.intf_L[i].get('in') #get frame from interface i
if fr_S is None:
continue # no frame to process yet
#if isNotUsingPriorities is not None:
# print str(self) + ' is not using priorities? ' + str(isNotUsingPriorities)
#decapsulate the packet
fr = LinkFrame.from_byte_S(fr_S)
pkt_S = fr.data_S
#process the packet as network, or MPLS
if fr.type_S == "Network":
p = NetworkPacket.from_byte_S(pkt_S) #parse a packet out
# print 'NETWORK QUEUE ' + pkt_S
self.process_network_packet(p, i, isNotUsingPriorities)
elif fr.type_S == "MPLS":
# TODO: handle MPLS frames
# print 'MPLS QUEUE ' + pkt_S
mplsPacket = MPLS.from_byte_S(pkt_S) #parse a frame out
#for now, we just relabel the packet as an MPLS frame without encapsulation
#m_fr = p
#send the MPLS frame for processing
self.process_MPLS_frame(mplsPacket, i)
else:
raise('%s: unknown frame type: %s' % (self, fr.type))
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 udt_receive(self):
fr_S = self.intf_L[0].get('in')
if fr_S is None:
return
#decapsulate the network packet
fr = LinkFrame.from_byte_S(fr_S)
assert(fr.type_S == 'Network') #should be receiving network packets by hosts
pkt_S = fr.data_S
print('%s: received packet "%s"' % (self, pkt_S))
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 sort_packet(self, frame):
temp_packet = LinkFrame.from_byte_S(frame)
temp_data = temp_packet.data_S
if temp_packet.type_S == 'MPLS':
m_fr = MPLSFrame.from_byte_S(temp_data)
return m_fr.exp
elif temp_packet.type_S == 'Network':
packet = NetworkPacket.from_byte_S(temp_data)
return packet.priority
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):
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):
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))
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):
#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 udt_receive(self):
fr_S = self.intf_L[0].get('in')
if fr_S is None:
return
#decapsulate the network packet
fr = LinkFrame.from_byte_S(fr_S)
assert(fr.type_S == 'Network') #should be receiving network packets by hosts
pkt_S = fr.data_S
#print('received packet = %s' % str(pkt_S))
print("\n(Host %s) received message: %s" % (str(self), pkt_S))
return pkt_S
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_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_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_queues(self):
count = 0
total = 0
for intf in self.intf_L:
for integer in intf.total:
total += 1
if int(integer) == 1:
count += 1
print("\n" + self.name + ": has total of: " + str(total) +
" packets in queue and: " + str(count) + " with high priority\n")
for i in range(len(self.intf_L)):
fr_S = None #make sure we are starting the loop with a blank frame
fr = None
temp = 0
flag = False
size = self.intf_L[i].in_queue.qsize()
while temp <= size:
fr_S = self.intf_L[i].get('in') #get frame from interface i
if fr_S is None:
flag = True
break # no frame to process yet
elif temp < size:
fr = LinkFrame.from_byte_S(fr_S)
prio = fr.data_S[-1]
if int(prio) != 1:
self.intf_L[i].put(fr.to_byte_S(), 'in', True)
else:
print(self.name + " processing higher priority jobs")
break
temp += 1
if flag:
continue
#decapsulate the packet
#fr = LinkFrame.from_byte_S(fr_S)
pkt_S = fr.data_S
#process the packet as network, or MPLS
if fr.type_S == "Network":
p = NetworkPacket.from_byte_S(pkt_S) #parse a packet out
self.process_network_packet(p, i)
elif fr.type_S == "MPLS":
# TODO: handle MPLS frames
# m_fr = MPLSFrame.from_byte_S(pkt_S) #parse a frame out
m_fr = MPLSF.from_byte_S(pkt_S)
#send the MPLS frame for processing
self.process_MPLS_frame(m_fr, i)
else:
raise ('%s: unknown frame type: %s' % (self, fr.type))
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_queues(self):
for i in range(len(self.intf_L)):
fr_S = None #make sure we are starting the loop with a blank frame
fr_S = self.intf_L[i].get('in') #get frame from interface i
if fr_S is None:
continue # no frame to process yet
#decapsulate the packet
fr = LinkFrame.from_byte_S(fr_S)
pkt_S = fr.data_S
#process the packet as network, or MPLS
if fr.type_S == "Network":
p = NetworkPacket.from_byte_S(pkt_S) #parse a packet out
self.process_network_packet(p, i)
elif fr.type_S == "MPLS":
m_fr = MPLSFrame.from_byte_S(pkt_S) #parse a frame out
self.process_MPLS_frame(m_fr, i)
else:
raise('%s: unknown frame type: %s' % (self, fr.type))
def print_queues(self):
for interface in range(len(self.intf_L)):
temp_list = []
priority_dict = {}
while True:
try:
frame = self.intf_L[interface].out_queue.get(block=False)
except queue.Empty:
break
else:
temp_list.append(frame)
temp_list.sort(key=self.sort_packet, reverse=True)
while len(temp_list) != 0:
temp_S = temp_list.pop(0)
self.intf_L[interface].put(temp_S, 'out')
temp_packet = LinkFrame.from_byte_S(temp_S)
temp_data = temp_packet.data_S
if temp_packet.type_S == 'MPLS':
m_fr = MPLSFrame.from_byte_S(temp_data)
packet = m_fr.pkt
int_priority = int(packet.priority)
if int_priority not in priority_dict:
priority_dict[int_priority] = 1
else:
priority_dict[int_priority] += 1
elif temp_packet.type_S == 'Network':
packet = NetworkPacket.from_byte_S(temp_data)
int_priority = int(packet.priority)
if int_priority not in priority_dict:
priority_dict[int_priority] = 1
else:
priority_dict[int_priority] += 1
for key in priority_dict:
print(
'%s - Interface %d: Queue has %d packets with priority %d'
% (self.name, interface, priority_dict[key], key))
def process_queues(self):
for i in range(len(self.intf_L)):
fr_S = None #make sure we are starting the loop with a blank frame
fr_S = self.intf_L[i].get('in') #get frame from interface i
if fr_S is None:
continue # no frame to process yet
#decapsulate the packet
fr = LinkFrame.from_byte_S(fr_S)
pkt_S = fr.data_S
#process the packet as network, or MPLS
if fr.type_S == "Network":
p = NetworkPacket.from_byte_S(pkt_S) #parse a packet out
self.process_network_packet(p, i)
elif fr.type_S == "MPLS":
# TODO: handle MPLS frames
# m_fr = MPLSFrame.from_byte_S(pkt_S) #parse a frame out
#for now, we just relabel the packet as an MPLS frame without encapsulation
# DEBUGGIN: DECAPSULATE MPLS
# ===================================================================================================== #
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)
print(
'\n\t\t @@@@=> DECAPSULATE MPLS --- PARSE A FRAME OUT <=@@@@\n'
'\t\t @@@@=> NODE [%s] --- got MPLS Frame: %s on INTF [%d] <=@@@@\n'
'\t\t @@@@=> NODE [%s] --- packet after decapsulation: %s <=@@@@\n'
% (self.name, pkt_S, i, self.name, mpls_frame_s))
# ===================================================================================================== #
#m_fr = p
m_fr = mplsFrame
# m_fr = mpls_frame_s
#send the MPLS frame for processing
self.process_MPLS_frame(m_fr, i)
else:
raise ('%s: unknown frame type: %s' % (self, fr.type))
def put(self, pkt, in_or_out, block=False):
if in_or_out == 'out':
fr = LinkFrame.from_byte_S(pkt)
if fr.type_S == "Network":
p = NetworkPacket.from_byte_S(fr.data_S) #parse a packet out
if p.priority in self.queuesize:
self.queuesize[p.priority] += 1
else:
self.queuesize[p.priority] = 1
elif fr.type_S == "MPLS":
m_fr = MPLSlabel.from_byte_S(fr.data_S)
p = NetworkPacket.from_byte_S(m_fr.frame)
if p.priority in self.queuesize:
self.queuesize[p.priority] += 1
else:
self.queuesize[p.priority] = 1
self.out_queue.put(pkt, block)
else:
self.in_queue.put(pkt, block)
def process_queues(self):
for i in range(len(self.intf_L)):
fr_S = None #make sure we are starting the loop with a blank frame
fr_S = self.intf_L[i].get('in') #get frame from interface i
if fr_S is None:
continue # no frame to process yet
#decapsulate the packet
fr = LinkFrame.from_byte_S(fr_S)
pkt_S = fr.data_S
#process the packet as network, or MPLS
if fr.type_S == "Network":
p = NetworkPacket.from_byte_S(pkt_S) #parse a packet out
self.process_network_packet(p, i)
elif fr.type_S == "MPLS":
# TODO: handle MPLS frames
m_fr = MPLSFrame.from_byte_S(pkt_S) #parse a frame out
#send the MPLS frame for processing
self.process_MPLS_frame(
m_fr, i, int(pkt_S[6])
) # Added the priority field to the process method but not the frame itself (needed for lookups)
else:
raise ('%s: unknown frame type: %s' % (self, fr.type))
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_queues(self):
for i in range(len(self.intf_L)):
fr_S = None #make sure we are starting the loop with a blank frame
fr_S = self.intf_L[i].get('in') #get frame from interface i
if fr_S is None:
continue # no frame to process yet
priority = fr_S[1]
#decapsulate the packet
fr = LinkFrame.from_byte_S(fr_S)
#pkt_S = fr.data_S
if priority == '0':
self.p0_queue.append(fr)
else:
self.p1_queue.append(fr)
if (len(self.p1_queue) > 0):
if self.p1_queue[0].type_S == "Network":
pkt_S = self.p1_queue.pop(0).data_S
p = NetworkPacket.from_byte_S(pkt_S) #parse a packet out
self.process_network_packet(p, i)
elif self.p1_queue[0].type_S == "MPLS":
pkt_S = self.p1_queue.pop(0).data_S
m_fr = MPLSFrame.from_byte_S(pkt_S)
self.process_MPLS_frame(m_fr, i)
else:
raise ('%s: unknown frame type: %s' % (self, fr.type))
else:
if self.p0_queue[0].type_S == "Network":
pkt_S = self.p0_queue.pop(0).data_S
p = NetworkPacket.from_byte_S(pkt_S) #parse a packet out
self.process_network_packet(p, i)
elif self.p0_queue[0].type_S == "MPLS":
pkt_S = self.p0_queue.pop(0).data_S
m_fr = MPLSFrame.from_byte_S(pkt_S)
self.process_MPLS_frame(m_fr, i)
else:
raise ('%s: unknown frame type: %s' % (self, fr.type))
def process_queues(self):
for i in range(len(self.intf_L)):
fr_S = None #make sure we are starting the loop with a blank frame
fr_S = self.intf_L[i].get('in') #get frame from interface i
if fr_S is None:
continue # no frame to process yet
#decapsulate the packet
fr = LinkFrame.from_byte_S(fr_S)
pkt_S = fr.data_S
#process the packet as network, or MPLS
if fr.type_S == "Network":
p = NetworkPacket.from_byte_S(pkt_S) #parse a packet out
self.process_network_packet(p, i)
elif fr.type_S == "MPLS":
# TODO: handle MPLS frames
print(pkt_S)
m_fr = MPLSFrame.from_byte_S(pkt_S) #parse a frame out
#for now, we just relabel the packet as an MPLS frame without encapsulation
print("m_fr from process_queues ", m_fr)
#m_fr = p
#send the MPLS frame for processing
self.process_MPLS_frame(m_fr, i)
else:
raise ('%s: unknown frame type: %s' % (self, fr.type))
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
