Beispiel #1
0
    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)
Beispiel #2
0
    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
Beispiel #3
0
    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)
Beispiel #4
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:
            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
Beispiel #5
0
    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
Beispiel #6
0
    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
Beispiel #7
0
    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)
Beispiel #8
0
    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)
Beispiel #9
0
    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 !")
Beispiel #11
0
    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] = []
Beispiel #12
0
    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
Beispiel #14
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))
Beispiel #15
0
    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
Beispiel #16
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 !")
Beispiel #18
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.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
Beispiel #19
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
Beispiel #20
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)
Beispiel #21
0
    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)
Beispiel #22
0
 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
Beispiel #23
0
    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
Beispiel #24
0
    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
Beispiel #25
0
    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 !")
Beispiel #26
0
    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)
Beispiel #27
0
    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
Beispiel #28
0
    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)
Beispiel #29
0
 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
Beispiel #30
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 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
Beispiel #32
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")
Beispiel #33
0
 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
Beispiel #35
0
    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
Beispiel #37
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)
            return 0
        else:
            LOG.debug("Drop packet")
            return 1
Beispiel #38
0
    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)
Beispiel #41
0
    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
Beispiel #42
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 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
Beispiel #45
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
Beispiel #46
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] = []
Beispiel #47
0
    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
Beispiel #48
0
 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