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("*********** 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): 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.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): 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("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): #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): 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, 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: 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_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 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): #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): # 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_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_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_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