Esempio n. 1
0
 def CreateActions(self, actions, entry, outbound):
   if outbound:
     actions.append(of.ofp_action_dl_addr(of.OFPAT_SET_DL_SRC, self.if_external))
     actions.append(of.ofp_action_nw_addr(of.OFPAT_SET_NW_SRC, NAT_IP_EXTERNAL))
     actions.append(of.ofp_action_tp_port(of.OFPAT_SET_TP_SRC, entry["natport"]))
     actions.append(of.ofp_action_dl_addr(of.OFPAT_SET_DL_DST, GetMACFromIP(entry["extip"])))
     actions.append(of.ofp_action_output(port=self.port_external))
   else:
     actions.append(of.ofp_action_dl_addr(of.OFPAT_SET_DL_SRC, self.if_external))
     actions.append(of.ofp_action_dl_addr(of.OFPAT_SET_DL_DST, entry["int"]))
     actions.append(of.ofp_action_nw_addr(of.OFPAT_SET_NW_DST, entry["intip"]))
     actions.append(of.ofp_action_tp_port(of.OFPAT_SET_TP_DST, entry["intport"]))
     actions.append(of.ofp_action_output(port=GetPortFromIP(entry["intip"])))
Esempio n. 2
0
  def _match_action(self,msg):
    
      if len(self.actions) == 1 and self.actions[0] == "" :
          return

      for action in self.actions:
          
        action_name = action.split('=')[0]
        if action_name != "STRIP_VLAN":
            action_argu = action.split('=')[1]
        
        if(action_name == "OUTPUT"):
            msg.actions.append(of.ofp_action_output(port = int(action_argu)))
      
        elif(action_name == "ENQUEUE"):
            port = action_argu.split(':')[0]
            queue_id = action_argu.split(':')[1]
            msg.actions.append(of.ofp_action_enqueue(port = int(port) , queue_id = int(queue_id)))
    
        elif(action_name == "STRIP_VLAN"):
            msg.actions.append(of.ofp_action_strip_vlan())
    
        elif(action_name == "SET_VLAN_VID"):
            msg.actions.append(of.ofp_action_vlan_vid(vlan_vid = int(action_argu)))
    
        elif(action_name == "SET_VLAN_PCP"):
            msg.actions.append(of.ofp_action_vlan_pcp(vlan_pcp = int(action_argu)))
    
        elif(action_name == "SET_DL_SRC"):
            msg.actions.append(of.ofp_action_dl_addr(type = 4 , dl_addr = EthAddr(action_argu)))
    
        elif(action_name == "SET_DL_DST"):
            msg.actions.append(of.ofp_action_dl_addr(type = 5 , dl_addr = EthAddr(action_argu)))
    
        elif(action_name == "SET_NW_TOS"):
            msg.actions.append(of.ofp_action_nw_tos(nw_tos = int(action_argu)))

        elif(action_name == "SET_NW_SRC"):
            msg.actions.append(of.ofp_action_nw_addr(type = 6 , nw_addr = IPAddr(action_argu)))

        elif(action_name == "SET_NW_DST"):
            msg.actions.append(of.ofp_action_nw_addr(type = 7 , nw_addr = IPAddr(action_argu)))

        elif(action_name == "SET_TP_SRC"):
            msg.actions.append(of.ofp_action_tp_port(type = 9 , tp_port = int(action_argu)))
    
        elif(action_name == "SET_TP_DST"):
            msg.actions.append(of.ofp_action_tp_port(type = 10 , tp_port = int(action_argu)))
Esempio n. 3
0
  def _match_action(self,msg):
    if(self.actions == "OUTPUT"):
      msg.actions.append(of.ofp_action_output(port = int(self.actions_argu)))
      
    elif(self.actions == "enqueue"):
      port = self.actions_argu.split(':')[0]
      queue_id = self.actions_argu.split(':')[1]
      msg.actions.append(of.ofp_action_enqueue(port = int(port) , queue_id = int(queue_id)))
    
    elif(self.actions == "strip-vlan"):
      msg.actions.append(of.ofp_action_strip_vlan())
    
    elif(self.actions == "set-vlan-id"):
      msg.actions.append(of.ofp_action_vlan_vid(vlan_vid = int(self.actions_argu)))
    
    elif(self.actions == "set-vlan-priority"):
      msg.actions.append(of.ofp_action_vlan_pcp(vlan_pcp = int(self.actions_argu)))
    
    elif(self.actions == "SET_DL_SRC"):
      msg.actions.append(of.ofp_action_dl_addr(type = 4 , dl_addr = EthAddr(self.actions_argu)))
    
    elif(self.actions == "SET_DL_DST"):
      msg.actions.append(of.ofp_action_dl_addr(type = 5 , dl_addr = EthAddr(self.actions_argu)))
    
    elif(self.actions == "SET_NW_TOS"):
      msg.actions.append(of.ofp_action_nw_tos(nw_tos = int(self.actions_argu)))

    elif(self.actions == "SET_NW_SRC"):
      msg.actions.append(of.ofp_action_nw_addr(type = 6 , nw_addr = IPAddr(self.actions_argu)))

    elif(self.actions == "SET_NW_DST"):
      msg.actions.append(of.ofp_action_nw_addr(type = 7 , nw_addr = IPAddr(self.actions_argu)))

    elif(self.actions == "SET_TP_SRC"):
      msg.actions.append(of.ofp_action_tp_port(type = 9 , tp_port = int(self.actions_argu)))
    
    elif(self.actions == "SET_TP_DST"):
      msg.actions.append(of.ofp_action_tp_port(type = 10 , tp_port = int(self.actions_argu)))
Esempio n. 4
0
 def CreateActions(self, actions, entry, outbound):
     if outbound:
         actions.append(
             of.ofp_action_dl_addr(of.OFPAT_SET_DL_SRC, self.if_external))
         actions.append(
             of.ofp_action_nw_addr(of.OFPAT_SET_NW_SRC, NAT_IP_EXTERNAL))
         actions.append(
             of.ofp_action_tp_port(of.OFPAT_SET_TP_SRC, entry["natport"]))
         actions.append(
             of.ofp_action_dl_addr(of.OFPAT_SET_DL_DST,
                                   GetMACFromIP(entry["extip"])))
         actions.append(of.ofp_action_output(port=self.port_external))
     else:
         actions.append(
             of.ofp_action_dl_addr(of.OFPAT_SET_DL_SRC, self.if_external))
         actions.append(
             of.ofp_action_dl_addr(of.OFPAT_SET_DL_DST, entry["int"]))
         actions.append(
             of.ofp_action_nw_addr(of.OFPAT_SET_NW_DST, entry["intip"]))
         actions.append(
             of.ofp_action_tp_port(of.OFPAT_SET_TP_DST, entry["intport"]))
         actions.append(
             of.ofp_action_output(port=GetPortFromIP(entry["intip"])))
	def coding_switch(self,packet,packet_in):

		#Assign source mac to forwarding table.
		src_mac = packet.src
		dst_mac = packet.dst
		self.fwd_table[src_mac] = packet_in.in_port

		#log.debug("%s \n" % self.fwd_table)

		if dst_mac in self.fwd_table: 

			#Add flow mod
			msg = of.ofp_flow_mod()
			msg.match = of.ofp_match.from_packet(packet) #Contruct exact match based on incoming packet.
			msg.data = packet_in

			if self.check_vlan(packet): #Send VLAN packets back to the same host socket
				msg.actions.append(of.ofp_action_output(port = of.OFPP_IN_PORT))
				msg.actions.append(of.ofp_action_tp_port(type=of.OFPAT_SET_TP_DST,tp_port=666))
				print("Has VLAN")
			else:
				msg.actions.append(of.ofp_action_output(port = self.fwd_table[dst_mac]))

			#Normal learning switch (No Flow Mods). Used for comparison
			#msg = of.ofp_packet_out() #Instructs switch to send packet out.
			#msg.data = packet_in
			#msg.actions.append(of.ofp_action_output(port = self.fwd_table[dst_mac]))

		else: #Act like a hub and forward to all output ports. 
			msg = of.ofp_packet_out() #Instructs switch to send packet out.
			msg.data = packet_in
			msg.actions.append(of.ofp_action_output(port = of.OFPP_ALL))

		#Send message to switch
		msg.actions.append(of.ofp_action_vlan_vid(vlan_vid = 2135))
		self.connection.send(msg)
Esempio n. 6
0
    def _match_action(self, msg):

        if len(self.actions) == 1 and self.actions[0] == "":
            return

        for action in self.actions:

            action_name = action.split('=')[0]
            if action_name != "STRIP_VLAN":
                action_argu = action.split('=')[1]

            if (action_name == "OUTPUT"):
                msg.actions.append(of.ofp_action_output(port=int(action_argu)))

            elif (action_name == "ENQUEUE"):
                port = action_argu.split(':')[0]
                queue_id = action_argu.split(':')[1]
                msg.actions.append(
                    of.ofp_action_enqueue(port=int(port),
                                          queue_id=int(queue_id)))

            elif (action_name == "STRIP_VLAN"):
                msg.actions.append(of.ofp_action_strip_vlan())

            elif (action_name == "SET_VLAN_VID"):
                msg.actions.append(
                    of.ofp_action_vlan_vid(vlan_vid=int(action_argu)))

            elif (action_name == "SET_VLAN_PCP"):
                msg.actions.append(
                    of.ofp_action_vlan_pcp(vlan_pcp=int(action_argu)))

            elif (action_name == "SET_DL_SRC"):
                msg.actions.append(
                    of.ofp_action_dl_addr(type=4,
                                          dl_addr=EthAddr(action_argu)))

            elif (action_name == "SET_DL_DST"):
                msg.actions.append(
                    of.ofp_action_dl_addr(type=5,
                                          dl_addr=EthAddr(action_argu)))

            elif (action_name == "SET_NW_TOS"):
                msg.actions.append(
                    of.ofp_action_nw_tos(nw_tos=int(action_argu)))

            elif (action_name == "SET_NW_SRC"):
                msg.actions.append(
                    of.ofp_action_nw_addr(type=6, nw_addr=IPAddr(action_argu)))

            elif (action_name == "SET_NW_DST"):
                msg.actions.append(
                    of.ofp_action_nw_addr(type=7, nw_addr=IPAddr(action_argu)))

            elif (action_name == "SET_TP_SRC"):
                msg.actions.append(
                    of.ofp_action_tp_port(type=9, tp_port=int(action_argu)))

            elif (action_name == "SET_TP_DST"):
                msg.actions.append(
                    of.ofp_action_tp_port(type=10, tp_port=int(action_argu)))
  def _handle_PacketIn (self, event):
    """
    Handle packet in messages from the switch to implement above algorithm.
    """#52:54:00:79:95:26 26:6a:fb:3c:f8:fd
    cptv = server_infos(conf.captive_portal.ip,conf.captive_portal.mac,conf.captive_portal.switch_port,conf.captive_portal.tcp_port)#"130.192.225.168","52:54:00:79:95:26",5,8085)
    #cptv = server_infos("130.192.225.156","88:51:fb:42:2b:f8",5,8080)

    if self.connection.dpid not in switchs_info:
        lock.acquire()
        try:
            dpi = DPI()
            dpi.setDPI(self.connection.dpid)
            # add a new switch to our infos
            switchs_info[self.connection.dpid] = switch_infos(self.connection)
        finally:
            lock.release() # release lock, no matter what

    switch =  switchs_info[self.connection.dpid]
    if event.port not in switch.ports_info:
        lock.acquire()
        try:
            #print (dpid_to_str(self.connection.dpid))
            #print self.connection.sock.getpeername()[0]
            switch.ports_info[event.port] = port_infos(event.port)
        finally:
            lock.release() # release lock, no matter what

        #if event.port == conf.my_infos.my_default_GRE_tunnel:
        is_user_port = True
        log.info("Comparing the ports speaking " + str(event.port))
        for not_user_port in conf.my_infos.not_user_ports:
            if str(event.port) == str(not_user_port):
                is_user_port = False
                break

        if not is_user_port:
            log.info("Event port is " + str(event.port))
            log.info("First for the ethernet interface")
            # First rule: allow all traffic
            self.connection.send( of.ofp_flow_mod( action=of.ofp_action_output(port=of.OFPP_NORMAL),
                                       priority=1,
                                       match=of.ofp_match( in_port = event.port)))
        else:
            """
            Packet from user
            """
            log.info("First packet from user")
            # First rule: drop all traffic
            msg = of.ofp_flow_mod()
            msg.priority = 1
            msg.match.in_port = event.port
            msg.actions.append(of.ofp_action_output(port=of.OFPP_NONE))
            self.connection.send(msg)
            # Second rule: normal process for DNS traffic
            msg = of.ofp_flow_mod()
            msg.priority = 100
            msg.match.in_port = event.port
            msg.match.dl_type = 0x800
            msg.match.nw_proto = 17
            msg.match.tp_dst = 53
            msg.actions.append(of.ofp_action_output(port=of.OFPP_NORMAL))
            #msg.data = event.ofp
            self.connection.send(msg)
            # Third rule: normal process for ARP traffic
            msg = of.ofp_flow_mod()
            msg.priority = 100
            msg.match.in_port = event.port
            msg.match.dl_type = 0x806
            msg.actions.append(of.ofp_action_output(port=of.OFPP_NORMAL))
            #msg.data = event.ofp
            self.connection.send(msg)
            # Fourth rule: normal process for DHCPDISCOVER
            msg = of.ofp_flow_mod()
            msg.priority = 100
            msg.match.in_port = event.port
            msg.match.dl_type = 0x800
            msg.match.nw_proto = 17
            msg.match.nw_src = "0.0.0.0"
            msg.match.nw_dst = "255.255.255.255"
            msg.match.tp_src = 68
            msg.match.tp_dst = 67
            msg.actions.append(of.ofp_action_output(port=of.OFPP_NORMAL))
            #msg.data = event.ofp
            self.connection.send(msg)
            # Fifth rule: send the HTTP traffic to the controller
            msg = of.ofp_flow_mod()
            msg.priority = 1000
            msg.match.in_port = event.port
            msg.match.dl_type = 0x800
            msg.match.nw_proto = 6
            msg.match.tp_dst = 80
            msg.actions.append(of.ofp_action_output(port=of.OFPP_CONTROLLER))
            msg.data = event.ofp
            self.connection.send(msg)

    packet = event.parsed
    if not packet.parsed:
      log.info("ignoring unparsed packet")
      return

    client_list = switch.ports_info[event.port].clients_info
    log.info("LOOP Thread id: "+str(thread.get_ident() ))
    log.debug("packet.type: "+ str(packet.type) +" || pkt.ethernet.IP_TYPE: "+ str(pkt.ethernet.IP_TYPE))
    if packet.type == pkt.ethernet.IP_TYPE:
        ipv4_hdr = packet.payload
        log.debug("ipv4_hdr.protocol: "+ str(ipv4_hdr.protocol) +" || pkt.ipv4.TCP_PROTOCOL: "+ str(pkt.ipv4.TCP_PROTOCOL))
        if ipv4_hdr.protocol == pkt.ipv4.TCP_PROTOCOL:
            tcp_hdr = ipv4_hdr.payload
            log.info("tcp_hdr.dstport: "+ str(tcp_hdr.dstport) +" || DestPort: || 80")
            if tcp_hdr.dstport == 80:
                log.debug("packet.src: "+ str(packet.src))

                if str(packet.src) not in client_list:
                    log.info("packet.src is not in client_list")
                    lock.acquire()
                    try:
                        log.info("save host info: IP=" + str(ipv4_hdr.srcip) + ", MAC=" + str(packet.src) + ", INGRESS_SWITCH_PORT=" + str(switch.infos.ports[event.port].name))
                        client_list[str(packet.src)] = host_infos(ipv4_hdr.srcip,packet.src,event.port,0)
                    finally:
                        lock.release() # release lock, no matter what
                else:
                    log.debug("PACKET_IN INFOs: user MAC: "+ str(packet.src)+", user IP: "+ str(ipv4_hdr.srcip))
                    user_infos = client_list[str(packet.src)]
                    user_ip = user_infos.IP
                    log.debug("Local informations: user MAC: "+ str(packet.src)+", user IP: "+ str(user_ip))
                    if user_ip != ipv4_hdr.srcip:
                        log.debug("Updating client IP informations")
                        user_infos.IP = ipv4_hdr.srcip

                client = client_list[str(packet.src)]
                if (client.flag_auth == 0):
                    log.info("installing new flow to set destination IP to captive portal IP")
                    msg = of.ofp_flow_mod()
                    msg.priority = 10000
                    msg.idle_timeout=30
                    msg.match.dl_type = 0x800
                    msg.match.dl_src = client.MAC
                    msg.match.nw_proto = 6
                    #Adding the match on the TCP source port of the user, in order to genererate a PACKET_IN for every
                    #new TCP connection
                    msg.match.tp_src = tcp_hdr.srcport
                    msg.match.tp_dst = 80
                    msg.match.nw_dst = ipv4_hdr.dstip
                    msg.match.in_port = event.port
                    msg.actions.append(of.ofp_action_dl_addr(of.OFPAT_SET_DL_DST,cptv.MAC))
                    msg.actions.append(of.ofp_action_nw_addr(of.OFPAT_SET_NW_DST,cptv.IP))
                    msg.actions.append(of.ofp_action_tp_port(of.OFPAT_SET_TP_DST,cptv.port))
                    msg.actions.append(of.ofp_action_output(port=cptv.switch_port))
                    #msg.data = event.ofp
                    self.connection.send(msg)
                    log.info("installing new flow to set return path")
                    msg = of.ofp_flow_mod()
                    msg.priority = 10000
                    msg.idle_timeout=30
                    msg.match.dl_type = 0x800
                    msg.match.nw_proto = 6
                    msg.match.tp_dst = tcp_hdr.srcport
                    msg.match.nw_dst = ipv4_hdr.srcip
                    msg.match.nw_src = cptv.IP
                    msg.actions.append(of.ofp_action_nw_addr(of.OFPAT_SET_NW_SRC,ipv4_hdr.dstip))
                    msg.actions.append(of.ofp_action_tp_port(of.OFPAT_SET_TP_SRC,tcp_hdr.dstport))
                    msg.actions.append(of.ofp_action_output(port=event.port))
                    msg.data = event.ofp
                    self.connection.send(msg)
                '''
Esempio n. 8
0
    def _handle_PacketIn(self, event):
        """
    Handle packet in messages from the switch to implement above algorithm.
    """#52:54:00:79:95:26 26:6a:fb:3c:f8:fd
        cptv = server_infos(conf.captive_portal.ip, conf.captive_portal.mac,
                            conf.captive_portal.switch_port,
                            conf.captive_portal.tcp_port
                            )  #"130.192.225.168","52:54:00:79:95:26",5,8085)
        #cptv = server_infos("130.192.225.156","88:51:fb:42:2b:f8",5,8080)

        if self.connection.dpid not in switchs_info:
            lock.acquire()
            try:
                dpi = DPI()
                dpi.setDPI(self.connection.dpid)
                # add a new switch to our infos
                switchs_info[self.connection.dpid] = switch_infos(
                    self.connection)
            finally:
                lock.release()  # release lock, no matter what

        switch = switchs_info[self.connection.dpid]
        if event.port not in switch.ports_info:
            lock.acquire()
            try:
                #print (dpid_to_str(self.connection.dpid))
                #print self.connection.sock.getpeername()[0]
                switch.ports_info[event.port] = port_infos(event.port)
            finally:
                lock.release()  # release lock, no matter what

            #if event.port == conf.my_infos.my_default_GRE_tunnel:
            is_user_port = True
            log.info("Comparing the ports speaking " + str(event.port))
            for not_user_port in conf.my_infos.not_user_ports:
                if str(event.port) == str(not_user_port):
                    is_user_port = False
                    break

            if not is_user_port:
                log.info("Event port is " + str(event.port))
                log.info("First for the ethernet interface")
                # First rule: allow all traffic
                self.connection.send(
                    of.ofp_flow_mod(
                        action=of.ofp_action_output(port=of.OFPP_NORMAL),
                        priority=1,
                        match=of.ofp_match(in_port=event.port)))
            else:
                """
            Packet from user
            """
                log.info("First packet from user")
                # First rule: drop all traffic
                msg = of.ofp_flow_mod()
                msg.priority = 1
                msg.match.in_port = event.port
                msg.actions.append(of.ofp_action_output(port=of.OFPP_NONE))
                self.connection.send(msg)
                # Second rule: normal process for DNS traffic
                msg = of.ofp_flow_mod()
                msg.priority = 100
                msg.match.in_port = event.port
                msg.match.dl_type = 0x800
                msg.match.nw_proto = 17
                msg.match.tp_dst = 53
                msg.actions.append(of.ofp_action_output(port=of.OFPP_NORMAL))
                #msg.data = event.ofp
                self.connection.send(msg)
                # Third rule: normal process for ARP traffic
                msg = of.ofp_flow_mod()
                msg.priority = 100
                msg.match.in_port = event.port
                msg.match.dl_type = 0x806
                msg.actions.append(of.ofp_action_output(port=of.OFPP_NORMAL))
                #msg.data = event.ofp
                self.connection.send(msg)
                # Fourth rule: normal process for DHCPDISCOVER
                msg = of.ofp_flow_mod()
                msg.priority = 100
                msg.match.in_port = event.port
                msg.match.dl_type = 0x800
                msg.match.nw_proto = 17
                msg.match.nw_src = "0.0.0.0"
                msg.match.nw_dst = "255.255.255.255"
                msg.match.tp_src = 68
                msg.match.tp_dst = 67
                msg.actions.append(of.ofp_action_output(port=of.OFPP_NORMAL))
                #msg.data = event.ofp
                self.connection.send(msg)
                # Fifth rule: send the HTTP traffic to the controller
                msg = of.ofp_flow_mod()
                msg.priority = 1000
                msg.match.in_port = event.port
                msg.match.dl_type = 0x800
                msg.match.nw_proto = 6
                msg.match.tp_dst = 80
                msg.actions.append(
                    of.ofp_action_output(port=of.OFPP_CONTROLLER))
                msg.data = event.ofp
                self.connection.send(msg)

        packet = event.parsed
        if not packet.parsed:
            log.info("ignoring unparsed packet")
            return

        client_list = switch.ports_info[event.port].clients_info
        log.info("LOOP Thread id: " + str(thread.get_ident()))
        log.debug("packet.type: " + str(packet.type) +
                  " || pkt.ethernet.IP_TYPE: " + str(pkt.ethernet.IP_TYPE))
        if packet.type == pkt.ethernet.IP_TYPE:
            ipv4_hdr = packet.payload
            log.debug("ipv4_hdr.protocol: " + str(ipv4_hdr.protocol) +
                      " || pkt.ipv4.TCP_PROTOCOL: " +
                      str(pkt.ipv4.TCP_PROTOCOL))
            if ipv4_hdr.protocol == pkt.ipv4.TCP_PROTOCOL:
                tcp_hdr = ipv4_hdr.payload
                log.info("tcp_hdr.dstport: " + str(tcp_hdr.dstport) +
                         " || DestPort: || 80")
                if tcp_hdr.dstport == 80:
                    log.debug("packet.src: " + str(packet.src))

                    if packet.src not in client_list:
                        log.info("packet.src is not in client_list")
                        lock.acquire()
                        try:
                            log.info("save host info: IP=" +
                                     str(ipv4_hdr.srcip) + ", MAC=" +
                                     str(packet.src) +
                                     ", INGRESS_SWITCH_PORT=" +
                                     str(switch.infos.ports[event.port].name))
                            client_list[packet.src] = host_infos(
                                ipv4_hdr.srcip, packet.src, event.port, 0)
                        finally:
                            lock.release()  # release lock, no matter what
                    else:
                        log.debug("PACKET_IN INFOs: user MAC: " +
                                  str(packet.src) + ", user IP: " +
                                  str(ipv4_hdr.srcip))
                        user_infos = client_list[packet.src]
                        user_ip = user_infos.IP
                        log.debug("Local informations: user MAC: " +
                                  str(packet.src) + ", user IP: " +
                                  str(user_ip))
                        if user_ip != ipv4_hdr.srcip:
                            log.debug("Updating client IP informations")
                            user_infos.IP = ipv4_hdr.srcip

                    client = client_list[packet.src]
                    if (client.flag_auth == 0):
                        log.info(
                            "installing new flow to set destination IP to captive portal IP"
                        )
                        msg = of.ofp_flow_mod()
                        msg.priority = 10000
                        msg.idle_timeout = 30
                        msg.match.dl_type = 0x800
                        msg.match.dl_src = client.MAC
                        msg.match.nw_proto = 6
                        #Adding the match on the TCP source port of the user, in order to genererate a PACKET_IN for every
                        #new TCP connection
                        msg.match.tp_src = tcp_hdr.srcport
                        msg.match.tp_dst = 80
                        msg.match.nw_dst = ipv4_hdr.dstip
                        msg.match.in_port = event.port
                        msg.actions.append(
                            of.ofp_action_dl_addr(of.OFPAT_SET_DL_DST,
                                                  cptv.MAC))
                        msg.actions.append(
                            of.ofp_action_nw_addr(of.OFPAT_SET_NW_DST,
                                                  cptv.IP))
                        msg.actions.append(
                            of.ofp_action_tp_port(of.OFPAT_SET_TP_DST,
                                                  cptv.port))
                        msg.actions.append(
                            of.ofp_action_output(port=cptv.switch_port))
                        #msg.data = event.ofp
                        self.connection.send(msg)
                        log.info("installing new flow to set return path")
                        msg = of.ofp_flow_mod()
                        msg.priority = 10000
                        msg.idle_timeout = 30
                        msg.match.dl_type = 0x800
                        msg.match.nw_proto = 6
                        msg.match.tp_dst = tcp_hdr.srcport
                        msg.match.nw_dst = ipv4_hdr.srcip
                        msg.match.nw_src = cptv.IP
                        msg.actions.append(
                            of.ofp_action_nw_addr(of.OFPAT_SET_NW_SRC,
                                                  ipv4_hdr.dstip))
                        msg.actions.append(
                            of.ofp_action_tp_port(of.OFPAT_SET_TP_SRC,
                                                  tcp_hdr.dstport))
                        msg.actions.append(
                            of.ofp_action_output(port=event.port))
                        msg.data = event.ofp
                        self.connection.send(msg)
                    '''
Esempio n. 9
0
    def _modify_flow(self, command_type):

        msg = of.ofp_flow_mod()
        print self.payload
        if command_type == "MOD_ST":
            msg.command = of.OFPFC_MODIFY_STRICT
        elif command_type == "MOD":
            msg.command = of.OFPFC_MODIFY

        if self.payload.has_key("wildcards"):
            msg.match.wildcards = int(self.payload['wildcards'])

        if self.payload.has_key("dstIP"):
            msg.match.nw_dst = IPAddr(self.payload['dstIP'])

        if self.payload.has_key("srcMac"):
            msg.match.dl_src = EthAddr(self.payload['srcMac'])

        if self.payload.has_key("srcIP"):
            msg.match.nw_src = IPAddr(self.payload['srcIP'])

        if self.payload.has_key("dstMac"):
            msg.match.dl_dst = EthAddr(self.payload['dstMac'])

        if self.payload.has_key("hardTimeout"):
            msg.hard_timeout = int(self.payload['hardTimeout'])

        if self.payload.has_key("srcPort"):
            msg.match.tp_src = int(self.payload['srcPort'])

        if self.payload.has_key("priority"):
            msg.priority = int(self.payload['priority'])

        if self.payload.has_key("ingressPort"):
            msg.match.in_port = int(self.payload['ingressPort'])

        if self.payload.has_key("vlan"):
            msg.match.dl_vlan = int(self.payload['vlan'])

        if self.payload.has_key("ether-type"):
            msg.match.dl_type = int(self.payload['ether-type'])

        if self.payload.has_key("duration"):
            msg.duration_sec = int(self.payload['duration'])

        if self.payload.has_key("idleTimeout"):
            msg.idle_timeout = int(self.payload['idleTimeout'])

        if self.payload.has_key("netProtocol"):
            msg.match.nw_proto = int(self.payload['netProtocol'])

        self.dpid = self.payload['switch'].replace(':', '-')[6:]
        self._parse_actions(self.payload['actions'])

        for connection in core.openflow._connections.values():

            # print dpidToStr(connection.dpid)
            conn_dpid = str(dpidToStr(connection.dpid))
            print conn_dpid
            if conn_dpid == self.dpid:
                """match actions"""
                if (self.actions == "OUTPUT"):
                    msg.actions.append(
                        of.ofp_action_output(port=int(self.actions_argu)))

                elif (self.actions == "enqueue"):
                    port = self.actions_argu.split(':')[0]
                    queue_id = self.actions_argu.split(':')[1]
                    msg.actions.append(
                        of.ofp_action_enqueue(port=int(port),
                                              queue_id=int(queue_id)))

                elif (self.actions == "strip-vlan"):
                    msg.actions.append(of.ofp_action_strip_vlan())

                elif (self.actions == "set-vlan-id"):
                    msg.actions.append(
                        of.ofp_action_vlan_vid(
                            vlan_vid=int(self.actions_argu)))

                elif (self.actions == "set-vlan-priority"):
                    msg.actions.append(
                        of.ofp_action_vlan_pcp(
                            vlan_pcp=int(self.actions_argu)))

                elif (self.actions == "SET_DL_SRC"):
                    msg.actions.append(
                        of.ofp_action_dl_addr(type=4,
                                              dl_addr=EthAddr(
                                                  self.actions_argu)))

                elif (self.actions == "SET_DL_DST"):
                    msg.actions.append(
                        of.ofp_action_dl_addr(type=5,
                                              dl_addr=EthAddr(
                                                  self.actions_argu)))

                elif (self.actions == "SET_NW_TOS"):
                    msg.actions.append(
                        of.ofp_action_nw_tos(nw_tos=int(self.actions_argu)))

                elif (self.actions == "SET_NW_SRC"):
                    msg.actions.append(
                        of.ofp_action_nw_addr(type=6,
                                              nw_addr=IPAddr(
                                                  self.actions_argu)))

                elif (self.actions == "SET_NW_DST"):
                    msg.actions.append(
                        of.ofp_action_nw_addr(type=7,
                                              nw_addr=IPAddr(
                                                  self.actions_argu)))

                elif (self.actions == "SET_TP_SRC"):
                    msg.actions.append(
                        of.ofp_action_tp_port(type=9,
                                              tp_port=int(self.actions_argu)))

                elif (self.actions == "SET_TP_DST"):
                    msg.actions.append(
                        of.ofp_action_tp_port(type=10,
                                              tp_port=int(self.actions_argu)))

                connection.send(msg)
Esempio n. 10
0
  def _modify_flow(self,command_type):
    
    msg = of.ofp_flow_mod()
    print self.payload
    if command_type == "MOD_ST":
      msg.command = of.OFPFC_MODIFY_STRICT
    elif command_type == "MOD":
      msg.command = of.OFPFC_MODIFY

    if self.payload.has_key("wildcards"):
      msg.match.wildcards = int(self.payload['wildcards'])
    
    if self.payload.has_key("dstIP"):
      msg.match.nw_dst = IPAddr(self.payload['dstIP'])
    
    if self.payload.has_key("srcMac"):
      msg.match.dl_src = EthAddr(self.payload['srcMac'])
    
    if self.payload.has_key("srcIP"):
      msg.match.nw_src = IPAddr(self.payload['srcIP'])
    
    if self.payload.has_key("dstMac"):
      msg.match.dl_dst = EthAddr(self.payload['dstMac'])
    
    if self.payload.has_key("hardTimeout"):
      msg.hard_timeout = int(self.payload['hardTimeout'])
    
    if self.payload.has_key("srcPort"):
      msg.match.tp_src = int(self.payload['srcPort'])
    
    if self.payload.has_key("priority"):
      msg.priority = int(self.payload['priority'])
    
    if self.payload.has_key("ingressPort"):
      msg.match.in_port = int(self.payload['ingressPort'])
    
    if self.payload.has_key("vlan"):
      msg.match.dl_vlan = int(self.payload['vlan'])
    
    if self.payload.has_key("ether-type"):
      msg.match.dl_type = int(self.payload['ether-type'])
    
    if self.payload.has_key("duration"):
      msg.duration_sec = int(self.payload['duration'])
    
    if self.payload.has_key("idleTimeout"):
      msg.idle_timeout = int(self.payload['idleTimeout'])
    
    if self.payload.has_key("netProtocol"):
      msg.match.nw_proto = int(self.payload['netProtocol'])


    self.dpid = self.payload['switch'].replace(':','-')[6:]
    self._parse_actions(self.payload['actions'])

    for connection in core.openflow._connections.values() :

      # print dpidToStr(connection.dpid)
      conn_dpid = str(dpidToStr(connection.dpid))
      print conn_dpid
      if conn_dpid == self.dpid:
        """match actions"""
        if(self.actions == "OUTPUT"):
          msg.actions.append(of.ofp_action_output(port = int(self.actions_argu)))
        
        elif(self.actions == "enqueue"):
          port = self.actions_argu.split(':')[0]
          queue_id = self.actions_argu.split(':')[1]
          msg.actions.append(of.ofp_action_enqueue(port = int(port) , queue_id = int(queue_id)))
        
        elif(self.actions == "strip-vlan"):
          msg.actions.append(of.ofp_action_strip_vlan())
        
        elif(self.actions == "set-vlan-id"):
          msg.actions.append(of.ofp_action_vlan_vid(vlan_vid = int(self.actions_argu)))
        
        elif(self.actions == "set-vlan-priority"):
          msg.actions.append(of.ofp_action_vlan_pcp(vlan_pcp = int(self.actions_argu)))
        
        elif(self.actions == "SET_DL_SRC"):
          msg.actions.append(of.ofp_action_dl_addr(type = 4 , dl_addr = EthAddr(self.actions_argu)))
        
        elif(self.actions == "SET_DL_DST"):
          msg.actions.append(of.ofp_action_dl_addr(type = 5 , dl_addr = EthAddr(self.actions_argu)))
        
        elif(self.actions == "SET_NW_TOS"):
          msg.actions.append(of.ofp_action_nw_tos(nw_tos = int(self.actions_argu)))

        elif(self.actions == "SET_NW_SRC"):
          msg.actions.append(of.ofp_action_nw_addr(type = 6 , nw_addr = IPAddr(self.actions_argu)))

        elif(self.actions == "SET_NW_DST"):
          msg.actions.append(of.ofp_action_nw_addr(type = 7 , nw_addr = IPAddr(self.actions_argu)))

        elif(self.actions == "SET_TP_SRC"):
          msg.actions.append(of.ofp_action_tp_port(type = 9 , tp_port = int(self.actions_argu)))
        
        elif(self.actions == "SET_TP_DST"):
          msg.actions.append(of.ofp_action_tp_port(type = 10 , tp_port = int(self.actions_argu)))

        connection.send(msg)