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