I'm not using it with spanning tree component but installed the flows by
addrule from S1--->S2-->S3 but I am unable to manage the flow from
s3-->s4--->s1 ..I'm stuck in it and don't know the solution
Regards
Uzma Waheed
MSIT-14
SEECS ( NUST )
On Thu, Sep 11, 2014 at 10:44 AM, Murphy McCauley <murphy.mccau...@gmail.com
> wrote:
> It's possible, though the code you are basing this on is not ideal for it.
>
> The code below essentially turns each OpenFlow switch into its own
> learning switch. Learning switches don't really understand the topology,
> so they don't have a lot of control over the paths that end up getting used.
>
> Since your topology has a loop, you are probably using this with POX's
> spanning_tree component. This means that it's extremely likely that the
> paths you get will be paths along the spanning tree -- the links that are
> on the tree are the ones that unknown packets are flooded on, which are
> therefore the ones that the learning switches learn and use. Since the
> spanning tree thinks in terms of symmetrical links, the paths you'll get
> will be symmetrical.
>
> Since you have a small topology and apparently have very specific ideas
> about what you want to accomplish, you might consider simply installing the
> forwarding rules you want by hand.
>
> -- Murphy
>
> On Sep 10, 2014, at 10:31 PM, Uzma Waheed <13msituwah...@seecs.edu.pk>
> wrote:
>
> Hi, everyone I made topology having 4 switches and two hosts are connected
> with each switch. Here is my code for pox . By adding firewall I can
> redirect traffic from s1,s2,s3 to ping h1 to h6. In topology links are as
> S1-->S2--->S3--->S4-->S1
> Is it possible I send ping request from S1-- >S2..>S3 nd get reply from
> S3-->S4--->S1 ?? Does anybody know
>
> Red showing description and yellow showing important parts of code
>
>
> from pox.lib.revent import *
>
> from pox.lib.util import dpidToStr
>
> from pox.lib.addresses import EthAddr
>
> from collections import namedtuple
>
> import os
>
>
> import csv
>
> from pox.core import core
>
> import pox.openflow.libopenflow_01 as of
>
> from pox.lib.util import dpid_to_str
>
> from pox.lib.util import str_to_bool
>
> import time
>
>
> log = core.getLogger()
>
>
> # We don't want to flood immediately when a switch connects.
>
> # Can be overriden on commandline.
>
> _flood_delay = 0
>
>
> class LearningSwitch (object):
>
>
>
> In short, our algorithm looks like this:
>
>
> For each packet from the switch:
>
> 1) Use source address and switch port to update address/port table
>
>
>
> 2) Port for destination address in our address/port table?
>
> No:
>
> 2a) Flood the packet
>
> DONE
>
>
> 3) Install flow table entry in the switch so that this
>
> flow goes out the appopriate port
>
> 3a) Send the packet out appropriate port
>
> """
>
> def __init__ (self, connection, transparent):
>
> # Switch we'll be adding L2 learning switch capabilities to
>
> self.connection = connection
>
> self.transparent = transparent
>
>
> # Our table
>
> self.macToPort = {}
>
>
> # our firewall table
>
> self.firewall = {}
>
>
> #Add couple of rules
>
>
>
> self.AddRule('00-00-00-00-00-01',EthAddr('00:00:00:00:00:06'))
>
> self.AddRule('00-00-00-00-00-02',EthAddr('00:00:00:00:00:06'))
>
> self.AddRule('00-00-00-00-00-03',EthAddr('00:00:00:00:00:06'))
>
> self.AddRule('00-00-00-00-00-01',EthAddr('00:00:00:00:00:01'))
>
> self.AddRule('00-00-00-00-00-02',EthAddr('00:00:00:00:00:01'))
>
> self.AddRule('00-00-00-00-00-03',EthAddr('00:00:00:00:00:01'))
>
> This upper yellow box adds the rules. This is the code which allows above
> sources on dpids. So now traffic won't go from S4 if we ping h1 to h6
>
> # We want to hear PacketIn messages, so we listen
>
> connection.addListeners(self)
>
>
> # We just use this to know when to log a helpful message
>
> self.hold_down_expired = _flood_delay == 0
>
>
>
> def AddRule(self,dpidstr ,src =0 ,value=True):
>
>
> self.firewall[(dpidstr,src)] =value
>
> log.debug("Adding Firewall rule in %s switch of source
> :%s",dpidstr,src)
>
>
> def CheckRule(self,dpidstr,src):
>
> try:
>
> entry =self.firewall[(dpidstr,src)]
>
>
> if(entry == True):
>
> log.debug("Rule for source (%s) found in switch %s is:FORWARD
> ",src,dpidstr)
>
> else:
>
> log.debug("Rule fpr source (%s) found in switch %s is
> :DROP",src,dpidstr)
>
> return entry
>
> except KeyError:
>
> log.debug("Rule (%s) found in %s:DROP",src,dpidstr)
>
> return False
>
>
>
>
>
>
>
>
> def _handle_PacketIn (self, event):
>
> """
>
> Handle packet in messages from the switch to implement above algorithm.
>
> """
>
>
> packet = event.parsed
>
>
> def flood (message = None):
>
> """ Floods the packet """
>
> msg = of.ofp_packet_out()
>
> msg.actions.append(of.ofp_action_output(port = of.OFPP_FLOOD))
>
> msg.data = event.ofp
>
> msg.in_port = event.port
>
> self.connection.send(msg)
>
>
> def drop (duration = None):
>
> """
>
> Drops this packet and optionally installs a flow to continue
>
> dropping similar ones for a while
>
> """
>
> if duration is not None:
>
> if not isinstance(duration, tuple):
>
> duration = (duration,duration)
>
> msg = of.ofp_flow_mod()
>
> msg.match = of.ofp_match.from_packet(packet)
>
>
> msg.idle_timeout = duration[0]
>
> msg.hard_timeout = duration[1]
>
> msg.buffer_id = event.ofp.buffer_id
>
> self.connection.send(msg)
>
> elif event.ofp.buffer_id is not None:
>
> msg = of.ofp_packet_out()
>
> msg.buffer_id = event.ofp.buffer_id
>
> msg.in_port = event.port
>
> self.connection.send(msg)
>
>
> self.macToPort[packet.src] = event.port # 1
>
> This line stores the port against mac for further destination.
>
>
> #additional code
>
>
> dpidstr =dpid_to_str(event.connection.dpid)
>
> #Check firewall rules
>
> if self.CheckRule(dpidstr,packet.src) == False:
>
> drop()
>
> return
>
>
>
>
>
> if packet.dst not in self.macToPort: # 2
>
> flood("Port for %s unknown -- flooding" % (packet.dst,)) # 2a
>
> else:
>
> port = self.macToPort[packet.dst]
>
> It takes port from macToPort table against destination.
>
>
>
> log.debug("installing flow for source %s on incoming port .%i ->
> destination is %s. on destination port%i" %
>
> (packet.src, event.port, packet.dst, port))
>
> msg = of.ofp_flow_mod()
>
> msg.match = of.ofp_match.from_packet(packet, event.port)
>
> msg.idle_timeout = 10
>
> msg.hard_timeout = 30
>
> msg.actions.append(of.ofp_action_output(port = port))
>
> msg.data = event.ofp # 3
>
> self.connection.send(msg)
>
>
>
> class l2_learning (object):
>
> """
>
> Waits for OpenFlow switches to connect and makes them learning switches.
>
> """
>
> def __init__ (self, transparent):
>
> core.openflow.addListeners(self)
>
> self.transparent = transparent
>
>
> def _handle_ConnectionUp (self, event):
>
> log.debug("Connection %s" % (event.connection,))
>
> LearningSwitch(event.connection, self.transparent)
>
>
>
> def launch (transparent=False, hold_down=_flood_delay):
>
> """
>
> Starts an L2 learning switch.
>
> """
>
> try:
>
> global _flood_delay
>
> _flood_delay = int(str(hold_down), 10)
>
> assert _flood_delay >= 0
>
> except:
>
> raise RuntimeError("Expected hold-down to be a number")
>
>
> core.registerNew(l2_learning, str_to_bool(transparent))
>
>
>
>
>
> Regards
> Uzma Waheed
> MSIT-14
> SEECS ( NUST )
>
>
>
> --
> Regards
> Uzma Waheed
> MSIT-14
> SEECS ( NUST )
>
>
>
