def receive_ip(self, datapath, packet, etherFrame, inPort, msg): #Función que se usa cuando se recibe un paquete IP ipPacket = packet.get_protocol(ipv4.ipv4) if ipPacket.dst == self.ports_to_ips[0][0]: #Si va destinado al router if ipPacket.proto == inet.IPPROTO_ICMP: icmpPacket = packet.get_protocol(icmp.icmp) self.check_icmp(datapath, etherFrame, ipPacket, icmpPacket, inPort) #Se usa una función que trata un paquete ICMP return 0 else: send_packet(datapath=datapath,port=inPort,packet=packet) #Se envía el paquete return 1 else: #Si no va destinado al router (next_hop, port) = self.find_in_routingTable(ipPacket.dst) #Almacena el puerto y el siguiente salto #en port y en next_hop if next_hop in self.ipToMac.keys(): #Si está dentro de la tabla de ips y macs se envía. match = datapath.ofproto_parser.OFPMatch(eth_dst=self.ipToMac[next_hop]) actions = [datapath.ofproto_parser.OFPActionOutput(port)] #self.add_flow(datapath, 0, match, actions) self.insertar_flujo(msg=msg, mac=self.ipToMac[next_hop], port=port, mod=1) else: #Si no está dentro de la tabla se construye un paquete ARP para averiguar su MAC # print "---- NEXT_HOP -----", next_hop e = ethernet.ethernet(src=etherFrame.dst, ethertype=ether.ETH_TYPE_ARP) a = arp.arp(opcode=arp.ARP_REQUEST, src_ip=self.ports_to_ips[port-1][0], src_mac=etherFrame.src, dst_ip=next_hop) puerto = etherFrame.src p = Packet() p.add_protocol(e) p.add_protocol(a) if next_hop not in self.dict_pendientes: self.dict_pendientes[next_hop] = [] self.dict_pendientes[next_hop] = self.dict_pendientes[next_hop] + [(msg, port,None,None)] self.send_packet(datapath=datapath, port=port, packet=p)
def packet_in_handler(self, ev): msg = ev.msg datapath = msg.datapath ofproto = datapath.ofproto parser = datapath.ofproto_parser inPort = msg.match['in_port'] dpid = datapath.id packet = Packet(msg.data) etherFrame = packet.get_protocol(ethernet) if (etherFrame.ethertype == ether.ETH_TYPE_IP) & (inPort==INNER_PORT): ipPacket = packet.get_protocol(ipv4) srcIp = ipPacket.src dstIp = ipPacket.dst if srcIp in INNER_IPADDR_LIST: if len(self.address_pool)>0: LOG.debug("Receive the first IP pacekt %s => %s to create flows" % (srcIp,dstIp)) get_ip = self.address_pool.pop(0) self. inner_map_outer[dpid][srcIp] = get_ip #add flow from inner to outer match = parser.OFPMatch(in_port=INNER_PORT, eth_type = ETH_TYPE_IP, ipv4_src = srcIp ) actions = [] actions.append(parser.OFPActionSetField(ipv4_src=get_ip)) actions.append(parser.OFPActionOutput(OUTTER_PORT)) self.add_flow(datapath, 4000, match, actions, idle_timeout=FLOW_IDLE_TIMEOUT,flags=ofproto.OFPFF_SEND_FLOW_REM) #add flow from outer to inner match = parser.OFPMatch(in_port=OUTTER_PORT, eth_type = ETH_TYPE_IP, ipv4_dst = get_ip ) actions = [] actions.append(parser.OFPActionSetField(ipv4_dst=srcIp)) actions.append(parser.OFPActionOutput( INNER_PORT)) self.add_flow(datapath, 4000, match, actions) LOG.debug( time.asctime() + " : IP %s was assigned , left %d avaiable" % (get_ip,len(self.address_pool))) #packet_out the original data with the same buffer_id as it was packet_in,so it could goto table if msg.buffer_id == OFPCML_NO_BUFFER: actions = [parser.OFPActionOutput( OFPP_TABLE) ] out = parser.OFPPacketOut( datapath=datapath, buffer_id=msg.buffer_id, in_port=INNER_PORT, actions=actions,data=msg.data) else: actions = [parser.OFPActionOutput( OFPP_TABLE) ] out = parser.OFPPacketOut( datapath=datapath, buffer_id=msg.buffer_id, in_port=INNER_PORT, actions=actions,data=None) datapath.send_msg(out) return 0 else: LOG.debug("Packet %s => %s was dropped since NAT pool was exhausted!" % (srcIp,dstIp)) return 1 else: LOG.debug("Packet was dropped since source IP %s is illegal!" % srcIp) return 1
def packet_in_handler(self, ev): #Qué hace el router cuando le llegua un paquete #print('ENTRO EN LA RUTINA') msg = ev.msg datapath = msg.datapath ofproto = datapath.ofproto in_port = msg.match['in_port'] packet = Packet(msg.data) eth = packet.get_protocol(ethernet.ethernet) ethertype = packet.get_protocol(ethernet.ethernet) print "PAQUETE: \n", packet src = eth.src #print(src) dst = eth.dst #sdgsa self.mac_to_port[src] = in_port #print(1) if eth.ethertype == ether.ETH_TYPE_ARP: #Si se trata de un paquete ARPÇ self.receive_arp(datapath, packet, ethertype, in_port) elif eth.ethertype == ether.ETH_TYPE_IP: #Si se trata de un paquete IP #print('paquete ip') self.receive_ip(datapath, packet, ethertype, in_port, msg)
def packet_in_handler(self, ev): msg = ev.msg datapath = msg.datapath ofproto = datapath.ofproto inPort = msg.match['in_port'] packet = Packet(msg.data) etherFrame = packet.get_protocol(ethernet) if etherFrame.ethertype == ether.ETH_TYPE_ARP: arpPacket = packet.get_protocol(arp) if arpPacket.dst_ip != OUTER_IPADDR and arpPacket.dst_ip != INNER_IPADDR: LOG.debug("Miss: This ARP packet is not for me.") return 1 arpPacket = packet.get_protocol(arp) self.receive_arp(datapath, packet, etherFrame, inPort) return 0 elif etherFrame.ethertype == ether.ETH_TYPE_IP: ipPacket = packet.get_protocol(ipv4) if ipPacket.dst != OUTER_IPADDR: LOG.debug("Miss: This IP packet is not for me.") return 1 self.receive_ip(datapath, packet, etherFrame, inPort) return 1 else: LOG.debug("receive Unknown packet %s => %s (port%d)" % (etherFrame.src, etherFrame.dst, inPort)) self.print_etherFrame(etherFrame) LOG.debug("Drop packet") return 2
def packet_in_handler(self, ev): msg = ev.msg datapath = msg.datapath ofproto = datapath.ofproto inPort = msg.match['in_port'] dpid = datapath.id self.ip_to_mac.setdefault(dpid, {}) packet = Packet(msg.data) etherFrame = packet.get_protocol(ethernet) srcMAC = etherFrame.src if etherFrame.ethertype == ether.ETH_TYPE_ARP: self.receive_arp(datapath, packet, etherFrame, inPort) return 0 elif etherFrame.ethertype == ether.ETH_TYPE_IP: ipPacket = packet.get_protocol(ipv4) srcIp = ipPacket.src if (ipPacket.proto == IPPROTO_ICMP) & (self.ip_to_mac[dpid][srcIp] == srcMAC): self.receive_icmp(datapath, packet, etherFrame, inPort) return 0 elif (ipPacket.proto == IPPROTO_ICMP): self.send_arp(datapath, ARP_REQUEST, ROUTER_MACADDR1, ROUTER_IPADDR1, "ff:ff:ff:ff:ff:ff", srcIp, inPort) else: LOG.debug("Drop packet") return 1
def packet_in_handler(self, ev): msg = ev.msg datapath = msg.datapath ofproto = datapath.ofproto inPort = msg.match['in_port'] dpid = datapath.id self.ip_to_mac.setdefault(dpid, {}) packet = Packet(msg.data) etherFrame = packet.get_protocol(ethernet) srcMAC = etherFrame.src if etherFrame.ethertype == ether.ETH_TYPE_ARP: self.receive_arp(datapath, packet, etherFrame, inPort) return 0 elif etherFrame.ethertype == ether.ETH_TYPE_IP: ipPacket = packet.get_protocol(ipv4) srcIp = ipPacket.src if (ipPacket.proto==IPPROTO_ICMP) & (self.ip_to_mac[dpid][srcIp] == srcMAC): self.receive_icmp(datapath, packet, etherFrame, inPort) return 0 elif (ipPacket.proto==IPPROTO_ICMP) : self.send_arp(datapath, ARP_REQUEST,ROUTER_MACADDR1, ROUTER_IPADDR1, "ff:ff:ff:ff:ff:ff", srcIp, inPort) else: LOG.debug("Drop packet") return 1
def packet_in_handler(self, ev): #Qué hace el router cuando le llegua un paquete #print('ENTRO EN LA RUTINA') msg = ev.msg datapath = msg.datapath ofproto = datapath.ofproto in_port = msg.match['in_port'] packet = Packet (msg.data) eth = packet.get_protocol(ethernet.ethernet) ethertype = packet.get_protocol(ethernet.ethernet) print "PAQUETE: \n", packet src=eth.src #print(src) dst=eth.dst #sdgsa self.mac_to_port[src] = in_port #print(1) if eth.ethertype==ether.ETH_TYPE_ARP: #Si se trata de un paquete ARPÇ self.receive_arp(datapath, packet, ethertype, in_port) elif eth.ethertype==ether.ETH_TYPE_IP: #Si se trata de un paquete IP #print('paquete ip') self.receive_ip(datapath, packet, ethertype, in_port, msg)
def receive_ip(self, datapath, packet, etherFrame, inPort, msg): #Función que se usa cuando se recibe un paquete IP ipPacket = packet.get_protocol(ipv4.ipv4) #print packet.get_protocol(ipv4.ipv4) print "LLEGÓ UN PAQUETE IP" if ipPacket.dst == self.ports_to_ips[0][0]: #Si va destinado al router print "VA DESTINADO AL ROUTER" if ipPacket.proto == inet.IPPROTO_ICMP: print "Y ES ICMP" icmpPacket = packet.get_protocol(icmp.icmp) self.check_icmp( datapath, etherFrame, ipPacket, icmpPacket, inPort) #Se usa una función que trata un paquete ICMP return 0 else: send_packet(datapath=datapath, port=inPort, packet=packet) #Se envía el paquete return 1 else: #Si no va destinado al router print "NO VA DESTINADO AL ROUTER" (next_hop, port) = self.find_in_routingTable( ipPacket.dst) #Almacena el puerto y el siguiente salto #en port y en next_hop print "¿Está dentro de la tabla ", next_hop, " ?" if next_hop in self.ipToMac.keys( ): #Si está dentro de la tabla de ips y macs se envía. print "ESTÁ DENTRO DE LA TABLA##################################################" print "ipToMac[next_hop] = ", self.ipToMac[next_hop] match = datapath.ofproto_parser.OFPMatch( eth_dst=self.ipToMac[next_hop]) actions = [datapath.ofproto_parser.OFPActionOutput(port)] self.add_flow(datapath, 0, match, actions) self.insertar_flujo(msg, self.ipToMac[next_hop], port) else: #Si no está dentro de la tabla se construye un paquete ARP para averiguar su MAC print "NO ESTÁ DENTRO DE LA TABLA" print "---- NEXT_HOP -----", next_hop e = ethernet.ethernet( #dst=etherFrame.dst, src=etherFrame.dst, ethertype=ether.ETH_TYPE_ARP) a = arp.arp(opcode=arp.ARP_REQUEST, src_ip=self.ports_to_ips[port - 1][0], src_mac=etherFrame.src, dst_ip=next_hop) puerto = etherFrame.src p = Packet() p.add_protocol(e) p.add_protocol(a) if next_hop not in self.dict_pendientes: self.dict_pendientes[next_hop] = [] self.dict_pendientes[ next_hop] = self.dict_pendientes[next_hop] + [(msg, port)] #def send_packet(self, datapath, port, packet): print "llegó por el PUERTO: ", inPort, "Sale por el puerto: ", port self.send_packet(datapath=datapath, port=port, packet=p)
def packet_processor(self, packet): packet_data = {} for protocol_handler in protocols: packet_data[protocol_handler] = packet.get_protocol(protocol_handler) if packet.get_protocol(protocol_handler): print(protocol_handler) pprint.pprint(packet_data, fh) fh.write(",\n") return packet_data
def receive_ip(self, datapath, packet, etherFrame, inPort): ipPacket = packet.get_protocol(ipv4) LOG.debug("receive IP packet %s => %s (port%d)" % (etherFrame.src, etherFrame.dst, inPort)) self.print_etherFrame(etherFrame) self.print_ipPacket(ipPacket) LOG.debug("Drop packet") if inPort == ROUTER_PORT1 and ipPacket.src == HOST_IPADDR1: self.HOST_MACADDR1 = etherFrame.src elif inPort == ROUTER_PORT2 and ipPacket.src == HOST_IPADDR2: self.HOST_MACADDR2 = etherFrame.src if self.HOST_MACADDR1 != None and self.HOST_MACADDR2 != None: if ipPacket.dst == HOST_IPADDR1 or ipPacket.dst == HOST_IPADDR2: self.send_flow(datapath) else: LOG.debug("unknown ip received !") elif self.HOST_MACADDR1 == None or self.HOST_MACADDR2 == None: if ipPacket.dst == HOST_IPADDR2: self.send_arp(datapath, 1, ROUTER_MACADDR2, ROUTER_IPADDR2, "ff:ff:ff:ff:ff:ff", HOST_IPADDR2, ROUTER_PORT2) LOG.debug("send ARP request %s => %s (port%d)" % (ROUTER_MACADDR2, "ff:ff:ff:ff:ff:ff", ROUTER_PORT2)) elif ipPacket.dst == HOST_IPADDR1: self.send_arp(datapath, 1, ROUTER_MACADDR1, ROUTER_IPADDR1, "ff:ff:ff:ff:ff:ff", HOST_IPADDR1, ROUTER_PORT1) LOG.debug("send ARP request %s => %s (port%d)" % (ROUTER_MACADDR1, "ff:ff:ff:ff:ff:ff", ROUTER_PORT1)) else: LOG.debug("unknown ip received !")
def receive_arp(self, datapath, packet, etherFrame, inPort): arp_msg = packet.get_protocol(arp.arp) if arp_msg.opcode == arp.ARP_REQUEST: if arp_msg.dst_ip == self.ports_to_ips[inPort-1][0]: e = ethernet.ethernet(dst=etherFrame.src, src=self.ports_to_ips[inPort-1][2], ethertype=ether.ETH_TYPE_ARP) a = arp.arp(opcode=arp.ARP_REPLY, src_mac=self.ports_to_ips[inPort-1][2], src_ip=arp_msg.dst_ip, dst_mac=etherFrame.src, dst_ip=arp_msg.src_ip) puerto=inPort p = Packet() p.add_protocol(e) p.add_protocol(a) self.send_packet(datapath, puerto, p) elif arp_msg.opcode == arp.ARP_REPLY: self.ipToMac[arp_msg.src_ip] = arp_msg.src_mac for (msg,port,nat,puertoNat) in self.dict_pendientes[arp_msg.src_ip]: if nat == None and puertoNat == None: self.insertar_flujo(msg=msg, mac=arp_msg.src_mac, port=port, mod=1) elif nat == 1: self.insertar_flujo(msg=msg, mod=0, puerto_origen=puertoNat, ip_origen=ip_publica, sentido=1, protoc=1, port=port, mac=arp_msg.src_mac) self.dict_pendientes[arp_msg.src_ip] = []
def process_packet_in(self, dpid, in_port, packet): """Process raw data received from dpid through in_port.""" # Handle ARP packet arp_header = packet.get_protocol(arp.arp) if arp_header: LOGGER.info("Handle ARP packet") # Process ARP request if arp_header.opcode == arp.ARP_REQUEST: # Process ARP request src_ip = arp_header.src_ip src_mac = arp_header.src_mac dst_ip = arp_header.dst_ip LOGGER.info("ARP request: (ip=%s) query (ip=%s)", src_ip, dst_ip) dst_vmac = self.arp_rpc.ip_to_mac.get(dst_ip) if dst_vmac is not None: LOGGER.info("Cache hit: (dst_ip=%s) <=> (vmac=%s)", dst_ip, dst_vmac) # Send arp reply src_mac_reply = dst_vmac vmac_reply = src_mac src_ip_reply = dst_ip dst_ip_reply = src_ip self.send_arp_reply(dpid, in_port, src_ip_reply, src_mac_reply, dst_ip_reply, vmac_reply) else: LOGGER.info("Query failure: MAC for (dst_ip=%s)" "cannot be found", dst_ip)
def receive_arp(self, datapath, packet, etherFrame, inPort): arpPacket = packet.get_protocol(arp) if arpPacket.opcode == 1: operation = "ARP Request" arp_dstIp = arpPacket.dst_ip elif arpPacket.opcode == 2: operation = "ARP Reply" LOG.debug("receive %s %s => %s (port%d)" %(operation, etherFrame.src, etherFrame.dst, inPort)) self.print_etherFrame(etherFrame) self.print_arpPacket(arpPacket) if arpPacket.opcode == 1: self.reply_arp(datapath, etherFrame, arpPacket, arp_dstIp, inPort) elif arpPacket.opcode == 2: if inPort == self.ROUTER_PORT1: self.HOST_IPADDR1 = arpPacket.src_ip self.HOST_MACADDR1 = arpPacket.src_mac self.ROUTER_IPADDR1 = arpPacket.dst_ip self.ROUTER_MACADDR1 = arpPacket.dst_mac elif inPort == self.ROUTER_PORT2: self.HOST_IPADDR2 = arpPacket.src_ip self.HOST_MACADDR2 = arpPacket.src_mac self.ROUTER_IPADDR2 = arpPacket.dst_ip self.ROUTER_MACADDR2 = arpPacket.dst_mac if self.HOST_MACADDR1 != None and self.HOST_MACADDR2 != None: self.send_flow(datapath) return 0
def receive_arp(self, datapath, packet, etherFrame, inPort): arpPacket = packet.get_protocol(arp.arp) if arpPacket.opcode == 1: # save ip address to graph and mac address to dictionary arp_srcIp = arpPacket.src_ip arp_srcMac = etherFrame.src # todo check with json topology if arp_srcIp not in self.net: self.print_info(arp_srcIp + " added to graph") self.net.add_node(arp_srcIp) self.net.add_edge(datapath.id, arp_srcIp, port=inPort) self.net.add_edge(arp_srcIp, datapath.id) self.print_info(self.net.edges(data=True)) self.mac_to_port.setdefault(datapath.id, {}) self.mac_to_port[datapath.id][arp_srcIp] = arp_srcMac arp_dstIp = arpPacket.dst_ip self.print_info("receive ARP request from %s => %s (port%d) for IP address: %s" % (etherFrame.src, etherFrame.dst, inPort, arp_dstIp)) self.reply_arp(datapath, etherFrame, arpPacket, arp_dstIp, inPort) elif arpPacket.opcode == 2: arp_srcIp = arpPacket.src_ip arp_srcMac = etherFrame.src if arp_srcIp not in self.net: self.print_info(arp_srcIp + " added to graph") self.net.add_node(arp_srcIp) self.net.add_edge(datapath.id, arp_srcIp, port=inPort) self.net.add_edge(arp_srcIp, datapath.id) self.print_info(self.net.edges(data=True)) self.mac_to_port.setdefault(datapath.id, {}) self.mac_to_port[datapath.id][arp_srcIp] = arp_srcMac self.print_info("receive ARP reply from %s => %s (port%d) for IP address: %s" % (etherFrame.src, etherFrame.dst, inPort, arp_srcIp))
def receive_arp(self, datapath, packet, etherFrame, inPort): arpPacket = packet.get_protocol(arp) if arpPacket.opcode == 1: operation = "ARP Request" arp_dstIp = arpPacket.dst_ip elif arpPacket.opcode == 2: operation = "ARP Reply" LOG.debug("receive %s %s => %s (port%d)" % (operation, etherFrame.src, etherFrame.dst, inPort)) self.print_etherFrame(etherFrame) self.print_arpPacket(arpPacket) if arpPacket.opcode == 1: self.reply_arp(datapath, etherFrame, arpPacket, arp_dstIp, inPort) elif arpPacket.opcode == 2: if inPort == self.ROUTER_PORT1: self.HOST_IPADDR1 = arpPacket.src_ip self.HOST_MACADDR1 = arpPacket.src_mac self.ROUTER_IPADDR1 = arpPacket.dst_ip self.ROUTER_MACADDR1 = arpPacket.dst_mac elif inPort == self.ROUTER_PORT2: self.HOST_IPADDR2 = arpPacket.src_ip self.HOST_MACADDR2 = arpPacket.src_mac self.ROUTER_IPADDR2 = arpPacket.dst_ip self.ROUTER_MACADDR2 = arpPacket.dst_mac if self.HOST_MACADDR1 != None and self.HOST_MACADDR2 != None: self.send_flow(datapath) return 0
def forwarding(self, packet, currentPath, Eprotocol, openflow, parsedData, in_port): inbound = packet.get_protocol(arp.arp).src_ip #if from back IP's, return for serverIp in range(0, self.back): if inbound == self.backList[serverIp][0]: return #parse and forward response parsing = parsedData.OFPMatch(in_port=in_port, ipv4_dst=self.switchIP, eth_type=0x0800) outbound = [ parsedData.OFPActionSetField(ipv4_dst=self.currentHostIP), parsedData.OFPActionOutput(self.ip2port[self.currentHostIP]) ] instructions = [ parsedData.OFPInstructionActions(openflow.OFPIT_APPLY_ACTIONS, outbound) ] outboundData = parsedData.OFPFlowMod(datapath=currentPath, priority=0, buffer_id=openflow.OFP_NO_BUFFER, match=parsing, instructions=instructions) currentPath.send_msg(outboundData) self.returning(inbound, packet, currentPath, Eprotocol, openflow, parsedData, in_port)
def receive_ip(self, datapath, packet, etherFrame, inPort): ipPacket = packet.get_protocol(ipv4) LOG.debug("receive IP packet %s => %s (port%d)" %(etherFrame.src, etherFrame.dst, inPort)) self.print_etherFrame(etherFrame) self.print_ipPacket(ipPacket) LOG.debug("Drop packet") if inPort == ROUTER_PORT1 and ipPacket.src == HOST_IPADDR1: self.HOST_MACADDR1 = etherFrame.src elif inPort == ROUTER_PORT2 and ipPacket.src == HOST_IPADDR2: self.HOST_MACADDR2 = etherFrame.src if self.HOST_MACADDR1 != None and self.HOST_MACADDR2 != None: if ipPacket.dst == HOST_IPADDR1 or ipPacket.dst == HOST_IPADDR2: self.send_flow(datapath) else: LOG.debug("unknown ip received !") elif self.HOST_MACADDR1 == None or self.HOST_MACADDR2 == None: if ipPacket.dst == HOST_IPADDR2: self.send_arp(datapath, 1, ROUTER_MACADDR2, ROUTER_IPADDR2, "ff:ff:ff:ff:ff:ff", HOST_IPADDR2, ROUTER_PORT2) LOG.debug("send ARP request %s => %s (port%d)" %(ROUTER_MACADDR2, "ff:ff:ff:ff:ff:ff", ROUTER_PORT2)) elif ipPacket.dst == HOST_IPADDR1: self.send_arp(datapath, 1, ROUTER_MACADDR1, ROUTER_IPADDR1, "ff:ff:ff:ff:ff:ff", HOST_IPADDR1, ROUTER_PORT1) LOG.debug("send ARP request %s => %s (port%d)" %(ROUTER_MACADDR1, "ff:ff:ff:ff:ff:ff", ROUTER_PORT1)) else: LOG.debug("unknown ip received !")
def receive_arp(self, datapath, packet, etherFrame, inPort): arpPacket = packet.get_protocol(arp) hostIpAddr = arpPacket.src_ip hostMacAddr = arpPacket.src_mac if arpPacket.opcode == 1: operation = "ARP Request" arp_dstIp = arpPacket.dst_ip elif arpPacket.opcode == 2: operation = "ARP Reply" LOG.debug("receive %s %s => %s (port%d)" % (operation, etherFrame.src, etherFrame.dst, inPort)) self.update_port_ip(datapath.id, inPort, hostIpAddr) self.print_etherFrame(etherFrame) self.print_arpPacket(arpPacket) if arpPacket.opcode == 1: self.reply_arp(datapath, etherFrame, arpPacket, arp_dstIp, inPort) elif arpPacket.opcode == 2: # ARP Response from Host # Old: self.arpInfo[inPort] = ArpTable(hostIpAddr, hostMacAddr, inPort) # New: Create Flow rule that sends packets to the dstIP with matching mac adress pair # TODO: Can be removed. Host data is learned on ARP request # mac__of_router_port = self.get_hwaddr_of_router_port(datapath, inPort) # self.add_flow_gateway_for_ip(datapath, out_port=inPort, dst_ip=hostIpAddr, new_src_mac=mac__of_router_port, # new_dst_mac=hostMacAddr) return 0 return 0
def packet_in_handler(self, ev): """ Routing simplified for prototyping!!! Only works with Topology of testbed0/mininet_multi_switches_ipv4.py :param ev: :return: """ msg = ev.msg datapath = msg.datapath inPort = msg.match['in_port'] packet = Packet(msg.data) etherFrame = packet.get_protocol(ethernet) if etherFrame.ethertype == ether.ETH_TYPE_LLDP: # ignore lldp packet return if etherFrame.ethertype == ether.ETH_TYPE_ARP: self.receive_arp(datapath, packet, etherFrame, inPort) elif etherFrame.ethertype == ether.ETH_TYPE_IP: self.receive_ip(datapath, packet, etherFrame, inPort) else: LOG.debug("receive Unknown packet %s => %s (port%d)" % (etherFrame.src, etherFrame.dst, inPort)) self.print_etherFrame(etherFrame) LOG.debug("Drop packet") return 1 return 0
def handle_arp(self,msg,datapath,packet,etherFrame,inPort): arpPacket = packet.get_protocol(arp) src_IP = arpPacket.src_ip dst_IP = arpPacket.dst_ip src = etherFrame.src self.arpTable[src_IP] = src if arpPacket.opcode == 1: # self.logger.debug('received ARP Request %s => %s (port%d)'%(etherFrame.src,etherFrame.dst,inPort)) if dst_IP == ROUTER_IPADDR1 or dst_IP == ROUTER_IPADDR2: self.reply_arp(datapath,etherFrame,arpPacket,dst_IP,inPort) else: ofproto = datapath.ofproto dstMac = "ff:ff:ff:ff:ff:ff" outPort = ofproto.OFPP_FLOOD self.send_arp(datapath, 1, src, src_IP, dstMac, dst_IP, outPort) elif arpPacket.opcode == 2: self.arpTable[src_IP] = src self.logger.info(self.arpTable) if dst_IP in self.arpTable: parser = datapath.ofproto_parser ofproto = datapath.ofproto out_port = self.mac_to_port[datapath.id][etherFrame.dst] actions = [parser.OFPActionOutput(port=out_port)] in_port = msg.match['in_port'] out = parser.OFPPacketOut(datapath = datapath, buffer_id = ofproto.OFP_NO_BUFFER, in_port = in_port, actions = actions, data = msg.data) # self.logger.info('packet_out:--> %s'%out) datapath.send_msg(out)
def receive_ip(self, datapath, packet, etherFrame, inPort, msg): #Función que se usa cuando se recibe un paquete IP ipPacket = packet.get_protocol(ipv4.ipv4) #print packet.get_protocol(ipv4.ipv4) print "LLEGÓ UN PAQUETE IP" if ipPacket.dst == self.ports_to_ips[0][0]: #Si va destinado al router print "VA DESTINADO AL ROUTER" if ipPacket.proto == inet.IPPROTO_ICMP: print "Y ES ICMP" icmpPacket = packet.get_protocol(icmp.icmp) self.check_icmp(datapath, etherFrame, ipPacket, icmpPacket, inPort) #Se usa una función que trata un paquete ICMP return 0 else: send_packet(datapath=datapath,port=inPort,packet=packet) #Se envía el paquete return 1 else: #Si no va destinado al router print "NO VA DESTINADO AL ROUTER" (next_hop, port) = self.find_in_routingTable(ipPacket.dst) #Almacena el puerto y el siguiente salto #en port y en next_hop print "¿Está dentro de la tabla ", next_hop, " ?" if next_hop in self.ipToMac.keys(): #Si está dentro de la tabla de ips y macs se envía. print "ESTÁ DENTRO DE LA TABLA##################################################" print "ipToMac[next_hop] = ", self.ipToMac[next_hop] match = datapath.ofproto_parser.OFPMatch(eth_dst=self.ipToMac[next_hop]) actions = [datapath.ofproto_parser.OFPActionOutput(port)] self.add_flow(datapath, 0, match, actions) self.insertar_flujo(msg, self.ipToMac[next_hop], port) else: #Si no está dentro de la tabla se construye un paquete ARP para averiguar su MAC print "NO ESTÁ DENTRO DE LA TABLA" print "---- NEXT_HOP -----", next_hop e = ethernet.ethernet(#dst=etherFrame.dst, src=etherFrame.dst, ethertype=ether.ETH_TYPE_ARP) a = arp.arp(opcode=arp.ARP_REQUEST, src_ip=self.ports_to_ips[port-1][0], src_mac=etherFrame.src, dst_ip=next_hop) puerto = etherFrame.src p = Packet() p.add_protocol(e) p.add_protocol(a) if next_hop not in self.dict_pendientes: self.dict_pendientes[next_hop] = [] self.dict_pendientes[next_hop] = self.dict_pendientes[next_hop] + [(msg, port)] #def send_packet(self, datapath, port, packet): print "llegó por el PUERTO: ", inPort, "Sale por el puerto: ", port self.send_packet(datapath=datapath, port=port, packet=p)
def receive_arp(self,datapath,packet,etherFrame,inPort): arpPacket = packet.get_protocol(arp) if arpPacket.opcode == 1 : arp_dstIp = arpPacket.dst_ip self.logger.debug('received ARP Request %s => %s (port%d)'%(etherFrame.src,etherFrame.dst,inPort)) self.reply_arp(datapath,etherFrame,arpPacket,arp_dstIp,inPort) elif arpPacket.opcode == 2 : pass
def receive_arp(self, datapath, packet, etherFrame, inPort): arpPacket = packet.get_protocol(arp) if arpPacket.opcode == 1: arp_dstIp = arpPacket.dst_ip self.reply_arp(datapath, etherFrame, arpPacket, arp_dstIp, inPort) elif arpPacket.opcode == 2: pass
def receive_arp(self, datapath, packet, etherFrame, inPort): arpPacket = packet.get_protocol(arp) if arpPacket.opcode == 1: arp_dstIp = arpPacket.dst_ip LOG.debug("receive ARP request %s => %s (port%d)" %(etherFrame.src, etherFrame.dst, inPort)) self.reply_arp(datapath, etherFrame, arpPacket, arp_dstIp, inPort) elif arpPacket.opcode == 2: pass
def receive_ip(self, datapath, packet, etherFrame, inPort): ipPacket = packet.get_protocol(ipv4) tcpPacket = packet.get_protocol(tcp) LOG.debug("receive IP packet %s => %s (port%d)" % (etherFrame.src, etherFrame.dst, inPort)) self.print_etherFrame(etherFrame) self.print_ipPacket(ipPacket) self.print_tcpPacket(tcpPacket) LOG.debug("Drop packet") if inPort == OUTER_PORT and ipPacket.dst == OUTER_IPADDR: self.CLIENT_MACADDR = etherFrame.src self.CLIENT_IPADDR = ipPacket.src self.CLIENT_TCPADDR = tcpPacket.src_port if self.CLIENT_MACADDR != None: if tcpPacket.dst_port == TCP_HTTP: self.send_flow(datapath) else: LOG.debug("unknown ip received !")
def packet_in_handler(self, ev): msg = ev.msg datapath = msg.datapath inPort = msg.match['in_port'] packet = Packet(msg.data) etherFrame = packet.get_protocol(ethernet.ethernet) #self.logger.debug("Packet in!: %s %s %s %s", datapath.id, inPort, etherFrame.src, etherFrame.dst) if datapath.id == SWITCH3_DPID: if etherFrame.ethertype == ether.ETH_TYPE_ARP: self.logger.debug( "ARP Switch3: Recieved at switch %s port %s ESrc %s EDst %s ARP", datapath.id, inPort, etherFrame.src, etherFrame.dst) self.receive_arp(datapath, packet, etherFrame, inPort) return 0 elif etherFrame.ethertype == ether.ETH_TYPE_IP: ip_packet = packet.get_protocol(ipv4.ipv4) #self.logger.debug("Recieved at switch %s port %s ESrc %s EDst %s IP ISrc %s IDst %s Proto %s", # datapath.id, inPort, etherFrame.src, #etherFrame.dst, ip_packet.src, ip_packet.dst, ip_packet.proto) if ip_packet.proto == 1: # ICMP icmp_packet = packet.get_protocol(icmp.icmp) self.reply_icmp(icmp_packet, ip_packet, etherFrame, inPort, datapath) elif ip_packet.proto == 6: # TCP tcp_packet = packet.get_protocol(tcp.tcp) self.pass_tcp(msg, tcp_packet, ip_packet, etherFrame) else: self.logger.debug("Drop packet") return 1 else: if etherFrame.ethertype == ether.ETH_TYPE_ARP: self.logger.debug( "ARP Switch1/2 Recieved at switch %s port %s ESrc %s EDst %s ARP", datapath.id, inPort, etherFrame.src, etherFrame.dst) self.receive_arp(datapath, packet, etherFrame, inPort) else: self.logger.info( "Error: message from unexpected switch of datapath %s", datapath.id)
def packet_in_handler(self, ev): msg = ev.msg inPort = msg.match['in_port'] packet = Packet(msg.data) etherFrame = packet.get_protocol(ethernet) if (etherFrame.ethertype == ether.ETH_TYPE_IP) & (inPort==INNER_PORT): ipPacket = packet.get_protocol(ipv4) srcIp = ipPacket.src proto = ipPacket.proto assert(proto in self.id_proto) if srcIp in INNER_IPADDR_LIST: if proto == IPPROTO_ICMP: self.process_icmp_pkt(msg) elif proto == IPPROTO_TCP: self.process_tcp_pkt(msg) elif proto == IPPROTO_UDP: self.process_udp_pkt(msg) else: LOG.debug("Packet was dropped since source IP %s is illegal!" % srcIp) return 1
def send_packet(self, packet): if not self._logstash_host: print('Logstash host not specified') return eth_pkt = packet.get_protocol(ethernet.ethernet) tcp_pkt = packet.get_protocol(tcp.tcp) ipv4_pkt = packet.get_protocol(ipv4.ipv4) packet_dict = { 'src_ip': ipv4_pkt.src, 'dst_ip': ipv4_pkt.dst, 'src_port': tcp_pkt.src_port, 'dst_port': tcp_pkt.dst_port, 'src_mac': eth_pkt.src, 'dst_mac': eth_pkt.dst, 'raw': str(packet.protocols[-1]) } print('Sending: ' + str(packet_dict)) requests.post(url=self._logstash_host, json=packet_dict, verify=False)
def receive_arp(self, datapath, packet, etherFrame, inPort): arpPacket = packet.get_protocol(arp) dpid = datapath.id if arpPacket.opcode == ARP_REQUEST: arp_dstIp = arpPacket.dst_ip arp_srcIp = arpPacket.src_ip src_mac = arpPacket.src_mac LOG.debug("receive ARP request %s => %s (port%d)" % (etherFrame.src, etherFrame.dst, inPort)) self.reply_arp(datapath, etherFrame, arpPacket, inPort) elif arpPacket.opcode == ARP_REPLY: pass self.ip_to_mac[dpid][arp_srcIp] = src_mac
def receive_ip(self, datapath, packet, etherFrame, inPort): ipPacket = packet.get_protocol(ipv4) LOG.debug("receive IP packet %s => %s (port%d)" %(etherFrame.src, etherFrame.dst, inPort)) self.print_etherFrame(etherFrame) self.print_ipPacket(ipPacket) if ipPacket.proto == inet.IPPROTO_ICMP: icmpPacket = packet.get_protocol(icmp.icmp) self.check_icmp(datapath, etherFrame, ipPacket, icmpPacket, inPort) return 0 else: LOG.debug("Drop packet") return 1 for portNo in self.arpInfo.keys(): if portNo == inPort: break else: hostIpAddr = ipPacket.src hostMacAddr = etherFrame.src self.arpInfo[inPort] = ArpTable(hostIpAddr, hostMacAddr, inPort) return 0
def receive_ip(self, datapath, packet, etherFrame, inPort): ipPacket = packet.get_protocol(ipv4) LOG.debug("receive IP packet %s => %s (port%d)" % (etherFrame.src, etherFrame.dst, inPort)) self.print_etherFrame(etherFrame) self.print_ipPacket(ipPacket) if ipPacket.proto == inet.IPPROTO_ICMP: icmpPacket = packet.get_protocol(icmp.icmp) self.check_icmp(datapath, etherFrame, ipPacket, icmpPacket, inPort) return 0 else: LOG.debug("Drop packet") return 1 for portNo in self.arpInfo.keys(): if portNo == inPort: break else: hostIpAddr = ipPacket.src hostMacAddr = etherFrame.src self.arpInfo[inPort] = ArpTable(hostIpAddr, hostMacAddr, inPort) return 0
def receiveBadArp(self, datapath, packet, etherFrame, inPort, msg): #get a packet with data on the type of arp packet arpPacket = packet.get_protocol(arp) #if this is a request then opcode is 1 so we must do something if arpPacket.opcode == 1: arp_dstIp = arpPacket.dst_ip #double checks the arp destination is '10.0.0.10' if arp_dstIp == '10.0.0.10': #calls function to build and send message self.replyArp(datapath, etherFrame, arpPacket, arp_dstIp, inPort, msg, packet) else: self.logger.info("2")
def receive_arp(self, datapath, packet, etherFrame, inPort): arpPacket = packet.get_protocol(arp) dpid = datapath.id if arpPacket.opcode == ARP_REQUEST: arp_dstIp = arpPacket.dst_ip arp_srcIp = arpPacket.src_ip src_mac = arpPacket.src_mac LOG.debug("receive ARP request %s => %s (port%d)" %(etherFrame.src, etherFrame.dst, inPort)) self.reply_arp(datapath, etherFrame, arpPacket,inPort) elif arpPacket.opcode == ARP_REPLY: pass self.ip_to_mac[dpid][arp_srcIp] = src_mac
def receive_arp(self, datapath, packet, etherFrame, inPort): arpPacket = packet.get_protocol(arp) if arpPacket.opcode == 1: arp_dstIp = arpPacket.dst_ip LOG.debug("receive ARP request %s => %s (port%d)" % (etherFrame.src, etherFrame.dst, inPort)) # DB lookup for arp reply. Saves new learned IP address # arpPacket.src_ip + inPort self.reply_arp(datapath, etherFrame, arpPacket, arp_dstIp, inPort) elif arpPacket.opcode == 2: pass
def packet_in_handler(self, ev): msg = ev.msg inPort = msg.match['in_port'] packet = Packet(msg.data) etherFrame = packet.get_protocol(ethernet) if (etherFrame.ethertype == ether.ETH_TYPE_IP) & (inPort == INNER_PORT): ipPacket = packet.get_protocol(ipv4) srcIp = ipPacket.src proto = ipPacket.proto assert (proto in self.id_proto) if srcIp in INNER_IPADDR_LIST: if proto == IPPROTO_ICMP: self.process_icmp_pkt(msg) elif proto == IPPROTO_TCP: self.process_tcp_pkt(msg) elif proto == IPPROTO_UDP: self.process_udp_pkt(msg) else: LOG.debug("Packet was dropped since source IP %s is illegal!" % srcIp) return 1
def packet_in_handler(self, ev): msg = ev.msg datapath = msg.datapath ofproto = datapath.ofproto inPort = msg.match['in_port'] packet = Packet(msg.data) etherFrame = packet.get_protocol(ethernet) if etherFrame.ethertype == ether.ETH_TYPE_ARP: self.receive_arp(datapath, packet, etherFrame, inPort) return 0 else: LOG.debug("Drop packet") return 1
def receive_arp(self, datapath, packet, etherFrame, inPort): arpPacket = packet.get_protocol(arp) if arpPacket.opcode == 1: operation = "ARP Request" arp_dstIp = arpPacket.dst_ip LOG.debug("receive %s %s => %s (port%d)" % (operation, etherFrame.src, etherFrame.dst, inPort)) self.print_etherFrame(etherFrame) self.print_arpPacket(arpPacket) if arpPacket.opcode == 1: print("arpPacket: ARP Request") self.reply_arp(datapath, etherFrame, arpPacket, arp_dstIp, inPort)
def sendIcmpResponse(self, packet, ipPacket): icmpPacket = packet.get_protocol(icmp.icmp) if icmpPacket.type == 0: self.print_icmp( icmpPacket ) icmp_length = ipPacket.total_length - 20 buf = (" %d bytes from %s: icmp_req=%d ttl=%d data=[%s] " % (icmp_length, ipPacket.src, icmpPacket.data.seq, ipPacket.ttl, icmpPacket.data.data)) elif icmpPacket.type == 3: buf = "ping ng ( Detination Unreachable )" elif icmpPacket.type == 11: buf = "ping ng ( Time Exceeded )" else: buf = "ping ng ( Unknown reason )" self.ping_q.put(buf)
def sendIcmpResponse(self, packet, ipPacket): icmpPacket = packet.get_protocol(icmp.icmp) if icmpPacket.type == 0: self.print_icmp(icmpPacket) icmp_length = ipPacket.total_length - 20 buf = (" %d bytes from %s: icmp_req=%d ttl=%d data=[%s] " % (icmp_length, ipPacket.src, icmpPacket.data.seq, ipPacket.ttl, icmpPacket.data.data)) elif icmpPacket.type == 3: buf = "ping ng ( Detination Unreachable )" elif icmpPacket.type == 11: buf = "ping ng ( Time Exceeded )" else: buf = "ping ng ( Unknown reason )" self.ping_q.put(buf)
def receive_arp(self, datapath, packet, etherFrame, inPort): arpPacket = packet.get_protocol(arp) if arpPacket.opcode == 1: dst_ip = arpPacket.dst_ip if (datapath.id == SWITCH3_DPID and dst_ip == self.OUTER_IP) \ or (datapath.id == SWITCH1_DPID and dst_ip in (SWITCH_S1_H1_IP, SWITCH_S1_H2_IP)) \ or (datapath.id == SWITCH2_DPID and dst_ip in (SWITCH_S2_H1_IP, SWITCH_S2_H2_IP)): self.send_arp(datapath, 2, datapath.ports[inPort].hw_addr, arpPacket.dst_ip, etherFrame.src, arpPacket.src_ip, inPort) else: self.logger.error( "Unexpected ARP request from dpid %s dst_ip %s", datapath.id, dst_ip) elif arpPacket.opcode == 2: pass
def packet_in_handler(self, ev): msg = ev.msg datapath = msg.datapath ofproto = datapath.ofproto inPort = msg.match['in_port'] packet = Packet(msg.data) etherFrame = packet.get_protocol(ethernet) if etherFrame.ethertype == ether.ETH_TYPE_ARP: self.receive_arp(datapath, packet, etherFrame, inPort) elif etherFrame.ethertype == ether.ETH_TYPE_IP: self.receive_ip(datapath, packet, etherFrame, inPort) else: LOG.debug("receive Unknown packet %s => %s (port%d)" % (etherFrame.src, etherFrame.dst, inPort)) self.print_etherFrame(etherFrame) LOG.debug("Drop packet") return 0
def packet_in_handler(self, ev): msg = ev.msg datapath = msg.datapath ofproto = datapath.ofproto inPort = msg.match['in_port'] packet = Packet(msg.data) etherFrame = packet.get_protocol(ethernet) if etherFrame.ethertype == ether.ETH_TYPE_ARP: self.receive_arp(datapath, packet, etherFrame, inPort) elif etherFrame.ethertype == ether.ETH_TYPE_IP: self.receive_ip(datapath, packet, etherFrame, inPort) else: LOG.debug("receive Unknown packet %s => %s (port%d)" %(etherFrame.src, etherFrame.dst, inPort)) self.print_etherFrame(etherFrame) LOG.debug("Drop packet") return 0
def receive_ip(self, datapath, packet, etherFrame, inPort): ipPacket = packet.get_protocol(ipv4) LOG.debug("receive IP packet %s => %s (port%d)" %(etherFrame.src, etherFrame.dst, inPort)) self.print_etherFrame(etherFrame) self.print_ipPacket(ipPacket) if ipPacket.proto == inet.IPPROTO_ICMP: self.sendIcmpResponse(packet, ipPacket) LOG.debug("Drop packet") if inPort == self.ROUTER_PORT1 and ipPacket.src == self.HOST_IPADDR1: self.HOST_MACADDR1 = etherFrame.src elif inPort == self.ROUTER_PORT2 and ipPacket.src == self.HOST_IPADDR2: self.HOST_MACADDR2 = etherFrame.src if self.HOST_MACADDR1 != None and self.HOST_MACADDR2 != None: if ipPacket.dst == self.HOST_IPADDR1: self.send_flow(datapath) if ipPacket.dst == self.HOST_IPADDR2: self.send_flow(datapath) else: LOG.debug("unknown ip received !") return 1 elif (self.HOST_MACADDR1 == None) or (self.HOST_MACADDR2 == None): if ipPacket.dst == self.HOST_IPADDR2: self.send_arp(datapath, 1, self.ROUTER_MACADDR2, self.ROUTER_IPADDR2, "ff:ff:ff:ff:ff:ff", self.HOST_IPADDR2, self.ROUTER_PORT2) LOG.debug("send ARP request %s => %s (port%d)" %(self.ROUTER_MACADDR2, "ff:ff:ff:ff:ff:ff", self.ROUTER_PORT2)) elif ipPacket.dst == self.HOST_IPADDR1: self.send_arp(datapath, 1, self.ROUTER_MACADDR1, self.ROUTER_IPADDR1, "ff:ff:ff:ff:ff:ff", self.HOST_IPADDR1, self.ROUTER_PORT1) LOG.debug("send ARP request %s => %s (port%d)" %(self.ROUTER_MACADDR1, "ff:ff:ff:ff:ff:ff", self.ROUTER_PORT1)) else: LOG.debug("unknown ip received !") return 1 return 0
def receive_arp(self, datapath, packet, etherFrame, inPort): arpPacket = packet.get_protocol(arp) hostIpAddr = arpPacket.src_ip hostMacAddr = arpPacket.src_mac if arpPacket.opcode == 1: operation = "ARP Request" arp_dstIp = arpPacket.dst_ip elif arpPacket.opcode == 2: operation = "ARP Reply" LOG.debug("receive %s %s => %s (port%d)" %(operation, etherFrame.src, etherFrame.dst, inPort)) self.print_etherFrame(etherFrame) self.print_arpPacket(arpPacket) if arpPacket.opcode == 1: self.reply_arp(datapath, etherFrame, arpPacket, arp_dstIp, inPort) elif arpPacket.opcode == 2: self.arpInfo[inPort] = ArpTable(hostIpAddr, hostMacAddr, inPort) return 0
def receive_arp(self, datapath, packet, etherFrame, inPort): print "LLEGÓ UN PAQUETE ARP" arp_msg = packet.get_protocol(arp.arp) if arp_msg.opcode == arp.ARP_REQUEST: print "ES ARP_REQUEST" # print arp_msg.dst_mac if arp_msg.dst_ip == self.ports_to_ips[inPort-1][0]: print "Y VA DESTINADO A EL ROUTER" #print('Es un ARP_REQUEST al mismo PC') e = ethernet.ethernet(dst=etherFrame.src, src=self.ports_to_ips[inPort-1][2], ethertype=ether.ETH_TYPE_ARP) a = arp.arp(opcode=arp.ARP_REPLY, src_mac=self.ports_to_ips[inPort-1][2], src_ip=arp_msg.dst_ip, dst_mac=etherFrame.src, dst_ip=arp_msg.src_ip) puerto=inPort p = Packet() p.add_protocol(e) p.add_protocol(a) self.send_packet(datapath, puerto, p) #print('Se envió el paquete') else: print('Y VA DESTINADO A OTRO PC') elif arp_msg.opcode == arp.ARP_REPLY: print "ES UN ARP_REPLY!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" #print "Esto es un Reply!" self.ipToMac[arp_msg.src_ip] = arp_msg.src_mac for (msg,port) in self.dict_pendientes[arp_msg.src_ip]: self.insertar_flujo(msg, arp_msg.src_mac, port) self.dict_pendientes[arp_msg.src_ip] = []
def packet_in_handler(self, ev): #Qué hace el router cuando le llegua un paquete msg = ev.msg datapath = msg.datapath ofproto = datapath.ofproto in_port = msg.match['in_port'] packet = Packet(msg.data) eth = packet.get_protocol(ethernet.ethernet) ethertype = packet.get_protocol(ethernet.ethernet) src=eth.src dst=eth.dst self.mac_to_port[src] = in_port used_ports = [] if eth.ethertype==ether.ETH_TYPE_ARP: #Si se trata de un paquete ARP self.receive_arp(datapath, packet, ethertype, in_port) elif eth.ethertype==ether.ETH_TYPE_IP: #Si se trata de un paquete IP print "PAQUETE AL LLEGAR: ", packet cabecera_ip = packet.get_protocol(ipv4.ipv4) print "GUARDA EN IPTOMAC la IP: ", cabecera_ip.src print "RELACIONADA con la MAC: ", src self.ipToMac[cabecera_ip.src] = src try: #Intenta almacenar un paquete del tipo TCP cabecera_tcp = packet.get_protocol(tcp.tcp) except: pass try: #Intenta almacenar un paquete del tipo UDP cabecera_udp = packet.get_protocol(udp.udp) except: pass if cabecera_tcp: #Se trata de un paquete TCP #ALMACENAR LA INFORMACIÓN EN LA TABLA: esta_en_tabla = False fila = None red_privada = True if in_port in [2,3,4]: #Si pertenece a la red privada for em in self.tablaNat: #Busca en la tabla por Ip origen ?? #PUERTO DE ORIGEN if ((cabecera_ip.src == em[0]) and (cabecera_tcp.src_port == em[1])): esta_en_tabla = True fila = em else: #Si pertenece a la red pública red_privada = False for em in self.tablaNat: #Busca en la tabla por puerto destino ?? if cabecera_tcp.dst_port == em[3]: esta_en_tabla = True fila = em if esta_en_tabla == False: #Si no está en la tabla #Se crea un puerto aleatorio. nuevo_puerto = random.randint(5000,5010) while nuevo_puerto in used_ports: nuevo_puerto = random.randint(5000,5010) print "PUERTO A INSERTAR: ", nuevo_puerto used_ports.append(nuevo_puerto) #Se añade a la tabla de nat self.tablaNat.append([cabecera_ip.src,cabecera_tcp.src_port,ip_publica,nuevo_puerto]) #Buscar la entrada aplicable en la tabla de enrutamiento (next_hop, port) = self.find_in_routingTable(cabecera_ip.dst) #Conozco la mac de destino? if next_hop in self.ipToMac.keys(): mac = self.ipToMac[next_hop] else: #Si no está dentro de la tabla se construye un paquete ARP para averiguar su MAC self.enviar_arp(mac_origen=self.ports_to_ips[0][2], port=port, next_hop=next_hop, datapath=datapath, msg=msg, nat=1, puertoNat=nuevo_puerto) else: #Si está en la tabla #Se cambian las propiedades del paquete #Buscar la entrada aplicable en la tabla de enrutamiento (next_hop, port) = self.find_in_routingTable(cabecera_ip.dst) if red_privada == False: #Proviene de la red pública print "PORT: ", port print "ALSDJGFHADKGAD: ", self.ipToMac[fila[0]] #[ip_privada(src), puerto_privado(src_port), ip_publica(dst), puerto_publico(dst_port)] self.insertar_flujo(msg=msg, mod=0, puerto_destino=fila[1], ip_destino=fila[0], sentido=0, protoc=1, port=2, mac=self.ipToMac[fila[0]]) if red_privada == True: #Proviene de la red privada #Conozco la mac de destino? if next_hop in self.ipToMac.keys(): mac = self.ipToMac[next_hop] else: #Si no está dentro de la tabla se construye un paquete ARP para averiguar su MAC self.enviar_arp(mac_origen=self.ports_to_ips[0][2], port=port, next_hop=next_hop, datapath=datapath, msg=msg, nat=1, puertoNat=fila[3]) elif cabecera_udp: #Se trata de un paquete UDP #ALMACENAR LA INFORMACIÓN EN LA TABLA: esta_en_tabla = False fila = None red_privada = True if in_port in [2,3,4]: #Si pertenece a la red privada for em in self.tablaNat: #Busca en la tabla por Ip origen ?? #PUERTO DE ORIGEN if ((cabecera_ip.src == em[0]) and (cabecera_tcp.src_port == em[1])): esta_en_tabla = True fila = em else: #Si pertenece a la red pública red_privada = False for em in self.tablaNat: #Busca en la tabla por puerto destino ?? if cabecera_udp.dst_port == em[3]: esta_en_tabla = True fila = em if esta_en_tabla == False: #Si no está en la tabla #Se crea un puerto aleatorio. nuevo_puerto = random.randint(5000,5010) while nuevo_puerto in used_ports: nuevo_puerto = random.randint(5000,5010) print "PUERTO A INSERTAR: ", nuevo_puerto used_ports.append(nuevo_puerto) #Se añade a la tabla de nat self.tablaNat.append([cabecera_ip.src,cabecera_udp.src_port,ip_publica,nuevo_puerto]) #Buscar la entrada aplicable en la tabla de enrutamiento (next_hop, port) = self.find_in_routingTable(cabecera_ip.dst) #Conozco la mac de destino? if next_hop in self.ipToMac.keys(): mac = self.ipToMac[next_hop] else: #Si no está dentro de la tabla se construye un paquete ARP para averiguar su MAC self.enviar_arp(mac_origen=self.ports_to_ips[0][2], port=port, next_hop=next_hop, datapath=datapath, msg=msg, nat=1, puertoNat=nuevo_puerto) else: #Si está en la tabla #Se cambian las propiedades del paquete #Buscar la entrada aplicable en la tabla de enrutamiento (next_hop, port) = self.find_in_routingTable(cabecera_ip.dst) if red_privada == False: #Proviene de la red pública print "PORT: ", port print "ALSDJGFHADKGAD: ", self.ipToMac[fila[0]] #[ip_privada(src), puerto_privado(src_port), ip_publica(dst), puerto_publico(dst_port)] self.insertar_flujo(msg=msg, mod=0, puerto_destino=fila[1], ip_destino=fila[0], sentido=0, protoc=1, port=2, mac=self.ipToMac[fila[0]]) if red_privada == True: #Proviene de la red privada #Conozco la mac de destino? if next_hop in self.ipToMac.keys(): mac = self.ipToMac[next_hop] else: #Si no está dentro de la tabla se construye un paquete ARP para averiguar su MAC self.enviar_arp(mac_origen=self.ports_to_ips[0][2], port=port, next_hop=next_hop, datapath=datapath, msg=msg, nat=1, puertoNat=fila[3]) else: #Se trata de un paquete ICMP o de otro tipo... self.receive_ip(datapath, packet, ethertype, in_port, msg) print "TABLA: ", self.tablaNat print "PUERTO DE ENTRADA: ", in_port
def process_tcp_pkt(self,msg): """ A new TCP packet should trigger to add two flow entries """ datapath = msg.datapath ofproto = datapath.ofproto parser = datapath.ofproto_parser inPort = msg.match['in_port'] dpid = datapath.id packet = Packet(msg.data) ipPacket = packet.get_protocol(ipv4) tcpPacket = packet.get_protocol(tcp) srcIp = ipPacket.src srcPort = tcpPacket.src_port if len(self.tcp_pool)>0: LOG.debug("Receive the first TCP packet (tcp_src=%s) from %s to create flows" % (srcPort,srcIp)) get_tcp_port = self.tcp_pool.pop(0) self.tcp_map_io[(srcIp,srcPort)] = get_tcp_port #add flow from inner to outer match = parser.OFPMatch(in_port=INNER_PORT, eth_type = ETH_TYPE_IP, ip_proto = IPPROTO_TCP, ipv4_src = srcIp, tcp_src = srcPort ) actions = [] actions.append(parser.OFPActionSetField(ipv4_src=OUTER_IPADDR)) actions.append(parser.OFPActionSetField(tcp_src=get_tcp_port)) actions.append(parser.OFPActionOutput(OUTTER_PORT)) self.add_flow(datapath, 4000, match, actions, idle_timeout=FLOW_IDLE_TIMEOUT,flags=ofproto.OFPFF_SEND_FLOW_REM) #add flow from outer to inner match = parser.OFPMatch(in_port=OUTTER_PORT, eth_type = ETH_TYPE_IP, ip_proto = IPPROTO_TCP, ipv4_dst = OUTER_IPADDR, tcp_dst = get_tcp_port ) actions = [] actions.append(parser.OFPActionSetField(ipv4_dst=srcIp)) actions.append(parser.OFPActionSetField(tcp_dst=srcPort)) actions.append(parser.OFPActionOutput( INNER_PORT)) self.add_flow(datapath, 4000, match, actions) LOG.debug( time.asctime() + " : TCP port %s was assigned to map (%r,%r), left %d avaiable" % (get_tcp_port,srcIp,srcPort,len(self.tcp_pool))) if msg.buffer_id == OFPCML_NO_BUFFER: actions = [parser.OFPActionOutput( OFPP_TABLE)] out = parser.OFPPacketOut( datapath=datapath, buffer_id=OFPCML_NO_BUFFER, in_port=INNER_PORT, actions=actions,data=msg.data) else: actions = [parser.OFPActionOutput( OFPP_TABLE)] out = parser.OFPPacketOut( datapath=datapath, buffer_id=msg.buffer_id, in_port=INNER_PORT, actions=actions,data=None) datapath.send_msg(out) return 0 else: LOG.debug("Packet was dropped since TCP pool was exhausted!") return 1