def _exec_cmd_set_table(self, event):
        try:
            msg = event.msg
            dpid = strToDPID(msg["dpid"])
            con = core.openflow.getConnection(dpid)
            if con is None:
                raise RuntimeError("No such switch")

            xid = of.generate_xid()

            fm = of.ofp_flow_mod()
            fm.xid = xid
            fm.command = of.OFPFC_DELETE
            con.send(fm)
            bar = of.ofp_barrier_request()
            bar.xid = xid
            con.send(bar)

            for flow in msg.get("flows", []):
                fm = dict_to_flow_mod(flow)
                fm.xid = xid

                con.send(fm)
                # con.send(of.ofp_barrier_request(xid=xid))
            con.send(of.ofp_barrier_request(xid=xid))

            self.reply(event, **{"type": "set_table", "xid": xid})

        except:
            # log.exception("Exception in set_table")
            log.debug("Exception in set_table - %s:%s", sys.exc_info()[0].__name__, sys.exc_info()[1])
            self.reply(
                event, exception="%s: %s" % (sys.exc_info()[0], sys.exc_info()[1]), traceback=traceback.format_exc()
            )
Example #2
0
def flood(event, ini, fim):
  id = 77770
  lista_ip = listaIp(ini,fim)
  global tempoEnv
  tempoEnv = time.time()-t
  event.connection.send(of.ofp_barrier_request(xid=id)) #0x88880001
  #log.info("Barrier Request enviado em: "+str(time.time()-t)+" ID:"+str(id))
  time.sleep(1)
  for i in range (ini,fim):
    msg3 = of.ofp_flow_mod()
    #msg3.match = of.ofp_match()
    msg3.match.in_port = 1
    #msg3.match.dl_src = EthAddr("48:5b:39:f9:3a:0f")
    #msg3.match.dl_dst = EthAddr("74:d0:2b:81:6c:0f")
    msg3.match.dl_type = 0x0800
    #msg3.match.dl_vlan = 1
    #msg3.match.dl_vlan_pcp = 0
    msg3.match.nw_src = IPAddr(lista_ip[i-ini])
    #msg3.match.nw_src = IPAddr("192.168.56.106")
    msg3.match.nw_dst = IPAddr("192.168.56.102")
    #msg3.match.nw_proto = 17  # tcp = 6 e udp = 17
    #msg3.match.nw_tos = 0
    #msg3.match.tp_src = i+1
    #msg3.match.tp_dst = i+2
    msg3.actions.append(of.ofp_action_output(port = 2))
    event.connection.send(msg3)
  id += 1
  tempoEnv = time.time()-t
  event.connection.send(of.ofp_barrier_request(xid=id))
  log.info("Barrier Request enviado em: "+str(time.time()-t)+" ID:"+str(id))
  #event.connection.send(of.ofp_stats_request())
  log.info("Funcao de flood finalizada. Aguardando barrier reply ID 77771.")
Example #3
0
def modificaRegras(event, ini, fim):
    global tempoEnv
    tempoEnv = time.time() - t
    event.connection.send(of.ofp_barrier_request(xid=66660))
    for i in range(ini, fim):
        event.connection.send(
            of.ofp_flow_mod(match=of.ofp_match(in_port=1),
                            command=of.OFPFC_MODIFY,
                            actions=[of.ofp_action_output(port=3)]))
    tempoEnv = time.time() - t
    event.connection.send(of.ofp_barrier_request(xid=66661))
Example #4
0
def remove(event):
    global tempoEnv
    tempoEnv = time.time() - t
    event.connection.send(of.ofp_barrier_request(xid=55550))
    event.connection.send(
        of.ofp_flow_mod(match=of.ofp_match(in_port=1),
                        command=of.OFPFC_DELETE))
    log.info("Barrier Request enviado em: " + str(time.time() - t) + " ID:" +
             str(id))
    tempoEnv = time.time() - t
    event.connection.send(of.ofp_barrier_request(xid=55551))
def removeRegras(event, ini, fim):
    global tempoEnv
    tempoEnv = time.time() - t
    event.connection.send(of.ofp_barrier_request(xid=66660))
    for i in range(ini, fim):
        event.connection.send(
            of.ofp_flow_mod(match=of.ofp_match(in_port=1,
                                               dl_type=0x0800,
                                               nw_src=IPAddr(lista_ip[i -
                                                                      ini])),
                            command=of.OFPFC_DELETE))
    tempoEnv = time.time() - t
    event.connection.send(of.ofp_barrier_request(xid=66661))
Example #6
0
  def _install_path_mod_src (self, p, match, target_ip, packet_in=None):
    wp = WaitingPath(p, packet_in)
    _sw, _in_port, _out_port = p[0]
    self._install_mod_nw(_sw, _in_port, _out_port, match, target_ip,
                         reverse=True)
    msg = of.ofp_barrier_request()
    _sw.connection.send(msg)
    wp.add_xid(_sw.dpid,msg.xid)

    for sw,in_port,out_port in p[1:]:
      self._install(sw, in_port, out_port, match)
      msg = of.ofp_barrier_request()
      sw.connection.send(msg)
      wp.add_xid(sw.dpid,msg.xid)
Example #7
0
 def _install_path (self, p, match, packet_in=None):
   wp = WaitingPath(p, packet_in)
   for sw,in_port,out_port in p:
     self._install(sw, in_port, out_port, match)
     msg = of.ofp_barrier_request()
     sw.connection.send(msg)
     wp.add_xid(sw.dpid,msg.xid)
Example #8
0
File: of_01.py Project: apanda/pox
def handle_FEATURES_REPLY (con, msg):
  con.features = msg
  con.dpid = msg.datapath_id
  openflowHub._connections[con.dpid] = con

  if openflowHub.miss_send_len is not None:
    con.send(of.ofp_switch_config(miss_send_len = openflowHub.miss_send_len))
  if openflowHub.clear_flows_on_connect:
    con.send(of.ofp_flow_mod(match=of.ofp_match(), command=of.OFPFC_DELETE))
  barrier = of.ofp_barrier_request()
  con.send(barrier)

  def finish_connecting (event):
    if event.xid != barrier.xid:
      con.dpid = None
      con.err("Failed connect for " + pox.lib.util.dpidToStr(msg.datapath_id))
      con.disconnect()
    else:
      con.info("Connected to " + pox.lib.util.dpidToStr(msg.datapath_id))
      #for p in msg.ports: print(p.show())
      openflowHub.raiseEventNoErrors(ConnectionUp, con, msg)
      con.raiseEventNoErrors(ConnectionUp, con, msg)
    return EventHaltAndRemove

  con.addListener(BarrierIn, finish_connecting)
  def _remove_hop (self, hop):
    if hop.status != RouteHop.INSTALLED:
      log.error("route (%s): cannot remove hop from sw (%s)",
                hop.route_id, hop.dpid)
      return
    msg = hop.get_flow_mod()
    msg.command = of.OFPFC_DELETE_STRICT

    con = pox.core.core.openflow.getConnection(hop.dpid)
    if not con:
      # we could be more clever here.  Now, we assume the sw has
      # already been shut down.
      hop.status = RouteHop.REMOVED
      return
    con.send(msg)

    # send the barrier
    barrier_xid = self._xid_generator()
    # Save the pending RoutHop to change the state later
    self._pending_barriers[barrier_xid] = hop
    # Set the RouteHop status
    hop.status = RouteHop.SENT_REMOVE
    con.send(of.ofp_barrier_request(xid=barrier_xid))

    log.debug('_remove_hop:route_id(%s),dpid(%s),barrier(%s)',
              hop.route_id, hop.dpid, barrier_xid)
  def _install_hop (self, hop):
    route = self._routes[hop.route_id]
    first = ( route.hops[0] == hop )
    if first and not route._is_tail_ready():
      return

    # send the flow_mod
    msg = hop.get_flow_mod()
    con = pox.core.core.openflow.getConnection(hop.dpid)
    if not con:
      # switch hasn't connected yet.
      # _handle_ConnectionUp will take care of the installation later
      return
    con.send(msg)

    # send the barrier
    barrier_xid = self._xid_generator()
    # Save the pending RoutHop to change the state later
    self._pending_barriers[barrier_xid] = hop
    # Set the RouteHop status
    hop.status = RouteHop.SENT
    con.send(of.ofp_barrier_request(xid=barrier_xid))

    log.debug('_install_hop:route_id(%s),dpid(%s),barrier(%s)',
              hop.route_id, hop.dpid, barrier_xid)
Example #11
0
def handle_FEATURES_REPLY(con, msg):
    connecting = con.connect_time == None
    con.features = msg
    con.dpid = msg.datapath_id

    if not connecting:
        con.ofnexus._connect(con)
        return

    nexus = core.OpenFlowConnectionArbiter.getNexus(con)
    if nexus is None:
        # Cancel connection
        con.info("No OpenFlow nexus for " +
                 pox.lib.util.dpidToStr(msg.datapath_id))
        con.disconnect()
        return
    con.ofnexus = nexus
    con.ofnexus._connect(con)
    #connections[con.dpid] = con

    barrier = of.ofp_barrier_request()

    listeners = []

    def finish_connecting(event):
        if event.xid != barrier.xid:
            con.dpid = None
            con.err("Failed connect for " +
                    pox.lib.util.dpidToStr(msg.datapath_id))
            con.disconnect()
        else:
            con.info("Connected to " + pox.lib.util.dpidToStr(msg.datapath_id))
            import time
            con.connect_time = time.time()
            #for p in msg.ports: print(p.show())
            con.ofnexus.raiseEventNoErrors(ConnectionUp, con, msg)
            con.raiseEventNoErrors(ConnectionUp, con, msg)
        con.removeListeners(listeners)

    listeners.append(con.addListener(BarrierIn, finish_connecting))

    def also_finish_connecting(event):
        if event.xid != barrier.xid: return
        if event.ofp.type != of.OFPET_BAD_REQUEST: return
        if event.ofp.code != of.OFPBRC_BAD_TYPE: return
        # Okay, so this is probably an HP switch that doesn't support barriers
        # (ugh).  We'll just assume that things are okay.
        finish_connecting(event)

    listeners.append(con.addListener(ErrorIn, also_finish_connecting))

    #TODO: Add a timeout for finish_connecting

    if con.ofnexus.miss_send_len is not None:
        con.send(of.ofp_switch_config(miss_send_len=con.ofnexus.miss_send_len))
    if con.ofnexus.clear_flows_on_connect:
        con.send(of.ofp_flow_mod(match=of.ofp_match(),
                                 command=of.OFPFC_DELETE))

    con.send(barrier)
Example #12
0
    def handle_FEATURES_REPLY(self, con, msg):
        connecting = con.connect_time == None
        con.features = msg
        con.original_ports._ports = set(msg.ports)
        con.ports._reset()
        con.dpid = msg.datapath_id

        nexus = core.OpenFlowConnectionArbiter.getNexus(con)
        if nexus is None:
            # Cancel connection
            con.info("No OpenFlow nexus for " +
                     pox.lib.util.dpidToStr(msg.datapath_id))
            con.disconnect()
            return
        con.ofnexus = nexus
        con.ofnexus._connect(con)

        #TODO: Add a timeout for finish_connecting

        if con.ofnexus.miss_send_len is not None:
            con.send(
                of.ofp_set_config(miss_send_len=con.ofnexus.miss_send_len))
        if con.ofnexus.clear_flows_on_connect:
            con.send(
                of.ofp_flow_mod(match=of.ofp_match(), command=of.OFPFC_DELETE))

        self._barrier = of.ofp_barrier_request()
        con.send(self._barrier)
Example #13
0
    def _install_hop(self, hop):
        route = self._routes[hop.route_id]
        first = (route.hops[0] == hop)
        if first and not route._is_tail_ready():
            return

        # send the flow_mod
        msg = hop.get_flow_mod()
        con = pox.core.core.openflow.getConnection(hop.dpid)
        if not con:
            # switch hasn't connected yet.
            # _handle_ConnectionUp will take care of the installation later
            return
        con.send(msg)

        # send the barrier
        barrier_xid = self._xid_generator()
        # Save the pending RoutHop to change the state later
        self._pending_barriers[barrier_xid] = hop
        # Set the RouteHop status
        hop.status = RouteHop.SENT
        con.send(of.ofp_barrier_request(xid=barrier_xid))

        log.debug('_install_hop:route_id(%s),dpid(%s),barrier(%s)',
                  hop.route_id, hop.dpid, barrier_xid)
Example #14
0
def handle_FEATURES_REPLY(con, msg):
    con.features = msg
    con.dpid = msg.datapath_id
    openflowHub._connections[con.dpid] = con

    if openflowHub.miss_send_len is not None:
        con.send(of.ofp_switch_config(miss_send_len=openflowHub.miss_send_len))
    if openflowHub.clear_flows_on_connect:
        con.send(of.ofp_flow_mod(match=of.ofp_match(),
                                 command=of.OFPFC_DELETE))
    barrier = of.ofp_barrier_request()
    con.send(barrier)

    def finish_connecting(event):
        if event.xid != barrier.xid:
            con.dpid = None
            con.err("Failed connect for " +
                    pox.lib.util.dpidToStr(msg.datapath_id))
            con.disconnect()
        else:
            con.info("Connected to " + pox.lib.util.dpidToStr(msg.datapath_id))
            #for p in msg.ports: print(p.show())
            openflowHub.raiseEventNoErrors(ConnectionUp, con, msg)
            con.raiseEventNoErrors(ConnectionUp, con, msg)
        return EventHaltAndRemove

    con.addListener(BarrierIn, finish_connecting)
Example #15
0
    def _remove_hop(self, hop):
        if hop.status != RouteHop.INSTALLED:
            log.error("route (%s): cannot remove hop from sw (%s)",
                      hop.route_id, hop.dpid)
            return
        msg = hop.get_flow_mod()
        msg.command = of.OFPFC_DELETE_STRICT

        con = pox.core.core.openflow.getConnection(hop.dpid)
        if not con:
            # we could be more clever here.  Now, we assume the sw has
            # already been shut down.
            hop.status = RouteHop.REMOVED
            return
        con.send(msg)

        # send the barrier
        barrier_xid = self._xid_generator()
        # Save the pending RoutHop to change the state later
        self._pending_barriers[barrier_xid] = hop
        # Set the RouteHop status
        hop.status = RouteHop.SENT_REMOVE
        con.send(of.ofp_barrier_request(xid=barrier_xid))

        log.debug('_remove_hop:route_id(%s),dpid(%s),barrier(%s)',
                  hop.route_id, hop.dpid, barrier_xid)
Example #16
0
    def _modify_flow(self, command_type):

        global Barrier_Modifyxid
        msg = of.ofp_flow_mod()

        if command_type == "MOD_ST":
            msg.command = of.OFPFC_MODIFY_STRICT
        elif command_type == "MOD":
            msg.command = of.OFPFC_MODIFY

        self._match_field(msg)

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

            if str(dpidToStr(connection.dpid)) == self.dpid:
                """match actions"""
                self._match_action(msg)
                connection.send(msg)

                barrier = of.ofp_barrier_request()
                barrier.xid = of.generate_xid()
                Barrier_Modifyxid = barrier.xid
                connection.send(barrier)

                # for recover
                self._record_rules(dpid=self.dpid, msg=msg)
def pushRulesToSwitch(connection, rulelist):
    "install a set of rules using a connection to a switch"
    log.debug("Installing %d rules on switch %s" %
              (len(rulelist), connection.sock.getpeername()[0]))
    for rule in rulelist:
        connection.send(rule)
    connection.send(of.ofp_barrier_request())
Example #18
0
  def handle_FEATURES_REPLY (self, con, msg):
    connecting = con.connect_time == None
    con.features = msg
    con.original_ports._ports = set(msg.ports)
    con.ports._reset()
    con.dpid = msg.datapath_id

    # If any port status messages come between now and when the connection is
    # actually up, buffer them to raise later.
    con._deferred_port_status = []

    nexus = core.OpenFlowConnectionArbiter.getNexus(con)
    if nexus is None:
      # Cancel connection
      con.info("No OpenFlow nexus for " +
              pox.lib.util.dpidToStr(msg.datapath_id))
      con.disconnect()
      return
    con.ofnexus = nexus

    #TODO: Add a timeout for finish_connecting

    if con.ofnexus.miss_send_len is not None:
      con.send(of.ofp_set_config(miss_send_len =
                                    con.ofnexus.miss_send_len))
    if con.ofnexus.clear_flows_on_connect:
      con.send(of.ofp_flow_mod(match=of.ofp_match(),command=of.OFPFC_DELETE))

    self._barrier = of.ofp_barrier_request()
    con.send(self._barrier)
Example #19
0
def _handle_BarrierIn(event):
  #numRegras = [250,500,750,1000,1250,1500,1750,2000,2250] #max=2611
  numRegras = [250,500,750] #max=2611
  global pos
  global tempoEnv

  if (event.xid == 77777):
    event.connection.send(of.ofp_barrier_request(xid=77771))
    tempoEnv = time.time()-t

  temporec = time.time()-t
  if (event.xid == 77771):
    vRecebido.append(temporec)
  log.info("Barrier Reply recebido em: "+str(temporec)+" ID:"+str(event.xid))
  if (event.xid == 77771 and pos < len(numRegras)):
    event.connection.send(of.ofp_flow_mod(match=of.ofp_match(in_port=1),command=of.OFPFC_DELETE))
    log.info("Regras port=1 removidas")
    time.sleep(2)
    log.info("Instalando " + str(numRegras[pos]) + " regras")
    flood(event,0,numRegras[pos])
    vRegras.append(numRegras[pos])
    vEnviado.append(tempoEnv)
    pos += 1
  elif(event.xid == 77771 and pos == len(numRegras)):
    log.info("Finalizado. Removendo regras port=1")
    event.connection.send(of.ofp_flow_mod(match=of.ofp_match(in_port=1),command=of.OFPFC_DELETE))
    for i in range(len(vRegras)):
      print "1 "+str(vRegras[i])+' '+str(vEnviado[i])+' '+str(vRecebido[i+1])
Example #20
0
  def handle_FEATURES_REPLY (self, con, msg):
    connecting = con.connect_time == None
    con.features = msg
    con.original_ports._ports = set(msg.ports)
    con.ports._reset()
    con.dpid = msg.datapath_id

    nexus = core.OpenFlowConnectionArbiter.getNexus(con)
    if nexus is None:
      # Cancel connection
      con.info("No OpenFlow nexus for " +
              pox.lib.util.dpidToStr(msg.datapath_id))
      con.disconnect()
      return
    con.ofnexus = nexus
    con.ofnexus._connect(con)

    #TODO: Add a timeout for finish_connecting

    if con.ofnexus.miss_send_len is not None:
      con.send(of.ofp_set_config(miss_send_len =
                                    con.ofnexus.miss_send_len))
    if con.ofnexus.clear_flows_on_connect:
      con.send(of.ofp_flow_mod(match=of.ofp_match(),command=of.OFPFC_DELETE))

    self._barrier = of.ofp_barrier_request()
    con.send(self._barrier)
Example #21
0
 def barrier(self,switch):
     b = of.ofp_barrier_request()
     try:
         self.switches[switch]['connection'].send(b)
     except KeyError, e:
         print "WARNING: couldn't send barrier to switch %s (%s)" % (
             str(switch), e)
Example #22
0
 def _install_path(self, p, match, packet_in=None):
     wp = WaitingPath(p, packet_in)
     for sw, in_port, out_port in p:
         self._install(sw, in_port, out_port, match)
         msg = of.ofp_barrier_request()
         sw.connection.send(msg)
         wp.add_xid(sw.dpid, msg.xid)
Example #23
0
 def barrier(self,switch):
     b = of.ofp_barrier_request()
     try:
         self.switches[switch]['connection'].send(b)
     except KeyError, e:
         print "WARNING: couldn't send barrier to switch %s (%s)" % (
             str(switch), e)
Example #24
0
  def _modify_flow(self,command_type):
    
    global Modifyxid 
    Modifyxid = of.generate_xid()
    msg = of.ofp_flow_mod()
    
    # print "====mod payload ====\n",self.payload
    
    if command_type == "MOD_ST":
      msg.command = of.OFPFC_MODIFY_STRICT
    elif command_type == "MOD":
      msg.command = of.OFPFC_MODIFY
    
    self._match_field(msg)

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

      if str(dpidToStr(connection.dpid)) == self.dpid:
        """match actions"""
        self._match_action(msg)
        connection.send(msg)

        barrier = of.ofp_barrier_request()
        barrier.xid = xid
        connection.send(barrier)

        # for recover
        self._record_rules(dpid = self.dpid , msg = msg)
Example #25
0
def _handle_BarrierIn(event):
    global tempoEnv

    if (event.xid == 77777):
        event.connection.send(of.ofp_barrier_request(xid=77771))
        tempoEnv = time.time() - t

    temporec = time.time() - t
    if (event.xid == 55550):
        vEnviado.append(tempoEnv)
    elif (event.xid == 55551):
        vRecebido.append(temporec)
        print "1 " + str(vRegras[0]) + ' ' + str(vEnviado[0]) + ' ' + str(
            vRecebido[0])

    numRegras = [500, 500]  #max=2611
    global pos
    log.info("Barrier Reply recebido em: " + str(time.time() - t) + " ID:" +
             str(event.xid))
    if (event.xid == 77771 and pos < len(numRegras)):
        log.info("Instalando " + str(numRegras[pos]) + " regras")
        flood(event, 0, numRegras[pos], pos + 1)
        vRegras.append(numRegras[pos])
        pos += 1
    elif (event.xid == 77771 and pos == len(numRegras)):
        remove(event)
        log.info("Finalizado. Removendo regras port=1")
Example #26
0
 def clear_table(self, xid=None):
     fm = of.ofp_flow_mod()
     fm.xid = xid
     fm.command = of.OFPFC_DELETE
     self._con.send(fm)
     bar = of.ofp_barrier_request()
     bar.xid = xid
     self._con.send(bar)
Example #27
0
  def _send_msg(self, con, msgs):
    for msg in msgs:
      msg.xid = self.xid
      con.send(msg)

    self.count += 1
    con.send(of.ofp_barrier_request(xid=self.xid))
    con.addListenerByName("BarrierIn", self._handle_BarrierIn)
Example #28
0
 def clear_table (self, xid = None):
   fm = of.ofp_flow_mod()
   fm.xid = xid
   fm.command = of.OFPFC_DELETE
   self._con.send(fm)
   bar = of.ofp_barrier_request()
   bar.xid = xid
   self._con.send(bar)
Example #29
0
def handle_FEATURES_REPLY (con, msg):
  connecting = con.connect_time == None
  con.features = msg
  con.dpid = msg.datapath_id

  if not connecting:
    con.ofnexus._connect(con)
    return

  nexus = core.OpenFlowConnectionArbiter.getNexus(con)
  if nexus is None:
    # Cancel connection
    con.info("No OpenFlow nexus for " +
             pox.lib.util.dpidToStr(msg.datapath_id))
    con.disconnect()
    return
  con.ofnexus = nexus
  con.ofnexus._connect(con)
  #connections[con.dpid] = con

  barrier = of.ofp_barrier_request()

  listeners = []

  def finish_connecting (event):
    if event.xid != barrier.xid:
      con.dpid = None
      con.err("Failed connect for " + pox.lib.util.dpidToStr(
              msg.datapath_id))
      con.disconnect()
    else:
      con.info("Connected to " + pox.lib.util.dpidToStr(msg.datapath_id))
      import time
      con.connect_time = time.time()
      #for p in msg.ports: print(p.show())
      con.ofnexus.raiseEventNoErrors(ConnectionUp, con, msg)
      con.raiseEventNoErrors(ConnectionUp, con, msg)
    con.removeListeners(listeners)
  listeners.append(con.addListener(BarrierIn, finish_connecting))

  def also_finish_connecting (event):
    if event.xid != barrier.xid: return
    if event.ofp.type != of.OFPET_BAD_REQUEST: return
    if event.ofp.code != of.OFPBRC_BAD_TYPE: return
    # Okay, so this is probably an HP switch that doesn't support barriers
    # (ugh).  We'll just assume that things are okay.
    finish_connecting(event)
  listeners.append(con.addListener(ErrorIn, also_finish_connecting))

  #TODO: Add a timeout for finish_connecting

  if con.ofnexus.miss_send_len is not None:
    con.send(of.ofp_switch_config(miss_send_len =
                                  con.ofnexus.miss_send_len))
  if con.ofnexus.clear_flows_on_connect:
    con.send(of.ofp_flow_mod(match=of.ofp_match(), command=of.OFPFC_DELETE))

  con.send(barrier)
Example #30
0
def _check_ports (dpid):
  """
  Sends a features request to the given dpid
  """
  _dirty_switches.pop(dpid,None)
  con = core.openflow.getConnection(dpid)
  if con is None: return
  con.send(of.ofp_barrier_request())
  con.send(of.ofp_features_request())
  log.debug("Requested switch features for %s", str(con))
Example #31
0
    def _handle_ConnectionUp(self, event):
        log.info("Connection from {}".format(dpid_to_mac(event.connection.dpid)))

        log.info("Clearing all flows from switch")
        msg = of.ofp_flow_mod(command=of.OFPFC_DELETE)
        event.connection.send(msg)

        msg = of.ofp_barrier_request()
        event.connection.send(msg)

        self.state = "Loading"
Example #32
0
  def clear_table (self, xid = None):

    "As modificações em um tabela de fluxo do controlador é feito com a mensagem OFPT_FLOW_MOD"
    fm = of.ofp_flow_mod()
    fm.xid = xid
    "OFPFC_DELETE: Exclui todos os fluxos correspondentes .."
    fm.command = of.OFPFC_DELETE
    self._con.send(fm)
    bar = of.ofp_barrier_request()
    bar.xid = xid
    self._con.send(bar)
Example #33
0
 def connect (self, connection):
   if connection is None:
     self.log.warn("Can't connect to nothing")
     return
   if self.dpid is None:
     self.dpid = connection.dpid
   assert self.dpid == connection.dpid
   if self.ports is None:
     self.ports = connection.features.ports
   self.disconnect()
   self.connection = connection
   self._listeners = self.listenTo(connection)
   self._connected_at = time.time()
   label = dpid_to_str(connection.dpid)
   self.log = log.getChild(label)
   self.log.debug("Connect %s" % (connection,))
   if self._id is None:
     if self.dpid not in switches_by_id and self.dpid <= 254:
       self._id = self.dpid
     else:
       self._id = TopoSwitch._next_id
       TopoSwitch._next_id += 1
     switches_by_id[self._id] = self
   self.network = IPAddr("10.%s.0.0" % (self._id,))
   self.mac = dpid_to_mac(self.dpid)
   con = connection
   log.debug("Disabling flooding for %i ports", len(con.ports))
   for p in con.ports.itervalues():
     if p.port_no >= of.OFPP_MAX: continue
     pm = of.ofp_port_mod(port_no=p.port_no,
                         hw_addr=p.hw_addr,
                         config = of.OFPPC_NO_FLOOD,
                         mask = of.OFPPC_NO_FLOOD)
     con.send(pm)
   con.send(of.ofp_barrier_request())
   con.send(of.ofp_features_request())
   self.send_table()
   def fix_addr (addr, backup):
     if addr is None: return None
     if addr is (): return IPAddr(backup)
     return IPAddr(addr)
   self.ip_addr = IPAddr("10.%s.0.1" % (self._id,))
   self.router_addr = None
   self.dns_addr = None 
   self.subnet = IPAddr("255.0.0.0")
   self.pools = {}
   for p in connection.ports:
     if p < 0 or p >= of.OFPP_MAX: continue
     self.pools[p] = [IPAddr("10.%s.%s.%s" % (self._id,p,n))
                      for n in range(1,255)]
   self.lease_time = 60 * 60
   self.offers = {}
   self.leases = {}
Example #34
0
	def _install_tree (self, s, R, tree, match, packet_in=None):
		wp = WaitingTree(s, tree, packet_in)
		for sw in tree.keys():
			match.in_port = None
			in_port, out_port = tree[sw]
			if sw not in R:
				self._install(sw, in_port, out_port, match, tree = True)
			else:
				self._install(sw, in_port, out_port, match, tree = True, mod_eth = True)
			msg = of.ofp_barrier_request()
			sw.connection.send(msg)
			wp.add_xid(sw.dpid,msg.xid)
Example #35
0
  def _exec_cmd_set_table (self, event):
    try:
      msg = event.msg
      dpid = strToDPID(msg['dpid'])
      con = core.openflow.getConnection(dpid)
      if con is None:
        raise RuntimeError("No such switch")

      xid = of.generate_xid()

      """
      As modificações em um tabela de fluxo do controlador é feito com a mensagem OFPT_FLOW_MOD
      """
      fm = of.ofp_flow_mod()
      fm.xid = xid
      "OFPFC_DELETE: Exclui todos os fluxos correspondentes .."
      fm.command = of.OFPFC_DELETE
      con.send(fm)
      bar = of.ofp_barrier_request()
      bar.xid = xid
      con.send(bar)

      for flow in msg.get('flows',[]):
        fm = dict_to_flow_mod(flow)
        fm.xid = xid

        con.send(fm)
        #con.send(of.ofp_barrier_request(xid=xid))
      con.send(of.ofp_barrier_request(xid=xid))

      self.reply(event,**{'type':'set_table','xid':xid})

    except:
      #log.exception("Exception in set_table")
      log.debug("Exception in set_table - %s:%s",
                sys.exc_info()[0].__name__,
                sys.exc_info()[1])
      self.reply(event,
                 exception="%s: %s" % (sys.exc_info()[0],sys.exc_info()[1]),
                 traceback=traceback.format_exc())
Example #36
0
 def sendBarrier(self, dpid):
     """Send a barrier message
        dpid: datapath id of the switch to receive the barrier"""
     dpid = int(dpid)
     if dpid in self.datapaths:
         dp = self.datapaths[dpid]
         msg = of.ofp_barrier_request()
         dp.send(msg)
         self.perfcounter.start()
         self.log.debug("dpid {0} sent barrier".format(dpid))
     else:
         self.log.debug("dpid {0} not in datapath list".format(dpid))
     return True
Example #37
0
 def sendBarrier(self, dpid):
     """Send a barrier message
        dpid: datapath id of the switch to receive the barrier"""
     dpid = int(dpid)
     if dpid in self.datapaths:
         dp = self.datapaths[dpid]
         msg = of.ofp_barrier_request()
         dp.send(msg)
         self.perfcounter.start()
         self.log.debug("dpid {0} sent barrier".format(dpid))
     else:
         self.log.debug("dpid {0} not in datapath list".format(dpid))
     return True
def flood(event, ini, fim):
    id = 77770
    global tempoEnv
    tempoEnv = time.time() - t
    event.connection.send(of.ofp_barrier_request(xid=id))  #0x88880001
    #log.info("Barrier Request enviado em: "+str(time.time()-t)+" ID:"+str(id))
    time.sleep(1)
    for i in range(ini, fim):
        msg3 = of.ofp_flow_mod()
        msg3.match.in_port = 1
        msg3.match.dl_type = 0x0800
        msg3.match.nw_src = IPAddr(lista_ip[i - ini])
        msg3.table = 1
        msg3.actions.append(of.ofp_action_output(port=2))
        event.connection.send(msg3)
    id += 1
    tempoEnv = time.time() - t
    event.connection.send(of.ofp_barrier_request(xid=id))
    log.info("Barrier Request enviado em: " + str(time.time() - t) + " ID:" +
             str(id))
    #event.connection.send(of.ofp_stats_request())
    log.info("Funcao de flood finalizada. Aguardando barrier reply ID 77771.")
Example #39
0
def _insert_flow_entries(event):
    stats = flow_stats_to_list(event.stats)
    for connection in core.openflow._connections.values():
        log.debug("connection dpid: %s", connection.dpid)
        if connection.dpid == newswitch_dpid:
            log.debug("install rule on switch %s", connection.dpid)
            for flow in stats:
                # log.debug("flow: %s", flow)
                msg = _flow_stats_to_flow_mod(flow)
                connection.send(msg)

            # send barrier message to ensure all flows has been installed
            connection.send(of.ofp_barrier_request(xid=0x80000000))
            connection.addListenerByName("BarrierIn", _handle_flow_ready)
Example #40
0
    def start_migration(self):
        log.info("start copying flow tables...")

        for connection in core.openflow._connections.values():
            if connection.dpid == ovs1_dpid or connection.dpid == ovs2_dpid or connection.dpid == ovs3_dpid:
                connection.send(of.ofp_stats_request(body=of.ofp_flow_stats_request()))
                log.debug("Sent %i flow/port stats request(s)", len(core.openflow._connections))

                # send barrier message to ensure all flows has been installed
                connection.send(of.ofp_barrier_request(xid=copy_barrier_id))
                connection.addListenerByName("BarrierIn", _handle_flow_ready)

                global barrier_count
                barrier_count += 1
Example #41
0
 def send_table (self):
   if self.connection is None:
     self.log.debug("Can't send table: disconnected")
     return
   clear = of.ofp_flow_mod(command=of.OFPFC_DELETE)
   self.connection.send(clear)
   self.connection.send(of.ofp_barrier_request())
   msg = of.ofp_flow_mod()
   msg.match = of.ofp_match()
   msg.match.dl_type = pkt.ethernet.IP_TYPE
   msg.match.nw_proto = pkt.ipv4.UDP_PROTOCOL
   msg.match.tp_src = pkt.dhcp.CLIENT_PORT
   msg.match.tp_dst = pkt.dhcp.SERVER_PORT
   msg.actions.append(of.ofp_action_output(port = of.OFPP_CONTROLLER))
   self.connection.send(msg)
   core.openflow_discovery.install_flow(self.connection)
   src = self
   for dst in switches_by_dpid.itervalues():
     if dst is src: continue
     p = _get_path(src, dst)
     if p is None: continue
     msg = of.ofp_flow_mod()
     msg.match = of.ofp_match()
     msg.match.dl_type = pkt.ethernet.IP_TYPE
     msg.match.nw_dst = "%s/%s" % (dst.network, "255.255.0.0")
     msg.actions.append(of.ofp_action_output(port=p[0][1]))
     self.connection.send(msg)
   for ip,mac in self.ip_to_mac.iteritems():
     self._send_rewrite_rule(ip, mac)
   flood_ports = []
   for port in self.ports:
     p = port.port_no
     if p < 0 or p >= of.OFPP_MAX: continue
     if core.openflow_discovery.is_edge_port(self.dpid, p):
       flood_ports.append(p)
     msg = of.ofp_flow_mod()
     msg.priority -= 1
     msg.match = of.ofp_match()
     msg.match.dl_type = pkt.ethernet.IP_TYPE
     msg.match.nw_dst = "10.%s.%s.0/255.255.255.0" % (self._id,p)
     msg.actions.append(of.ofp_action_output(port=of.OFPP_CONTROLLER))
     self.connection.send(msg)
   msg = of.ofp_flow_mod()
   msg.priority -= 1
   msg.match = of.ofp_match()
   msg.match.dl_type = pkt.ethernet.IP_TYPE
   msg.match.nw_dst = "255.255.255.255"
   for p in flood_ports:
     msg.actions.append(of.ofp_action_output(port=p))
   self.connection.send(msg)
Example #42
0
    def _exec_cmd_set_table(self, event):
        try:
            msg = event.msg
            dpid = strToDPID(msg['dpid'])
            con = core.openflow.getConnection(dpid)
            if con is None:
                raise RuntimeError("No such switch")

            xid = of.generate_xid()

            fm = of.ofp_flow_mod()
            fm.xid = xid
            fm.command = of.OFPFC_DELETE
            con.send(fm)
            bar = of.ofp_barrier_request()
            bar.xid = xid
            con.send(bar)

            for flow in msg.get('flows', []):
                fm = dict_to_flow_mod(flow)
                fm.xid = xid

                con.send(fm)
                #con.send(of.ofp_barrier_request(xid=xid))
            con.send(of.ofp_barrier_request(xid=xid))

            self.reply(event, **{'type': 'set_table', 'xid': xid})

        except:
            #log.exception("Exception in set_table")
            log.debug("Exception in set_table - %s:%s",
                      sys.exc_info()[0].__name__,
                      sys.exc_info()[1])
            self.reply(event,
                       exception="%s: %s" %
                       (sys.exc_info()[0], sys.exc_info()[1]),
                       traceback=traceback.format_exc())
Example #43
0
    def _init(self, flows=[]):
        self.done = False

        xid = of.generateXID()
        self.xid = xid
        self.clear_table(xid=xid)

        self.count = 1 + len(flows)

        for flow in flows:
            fm = dict_to_flow_mod(flow)
            fm.xid = xid

            self._con.send(fm)
            self._con.send(of.ofp_barrier_request(xid=xid))
Example #44
0
  def _init (self, flows = []):
    self.done = False

    xid = of.generateXID()
    self.xid = xid
    self.clear_table(xid=xid)

    self.count = 1 + len(flows)

    for flow in flows:
      fm = dict_to_flow_mod(flow)
      fm.xid = xid

      self._con.send(fm)
      self._con.send(of.ofp_barrier_request(xid=xid))
Example #45
0
def _handle_flowstats_received (event):
  stats = flow_stats_to_list(event.stats)
  log.debug("FlowStatsReceived from %s: %s", 
   dpidToStr(event.connection.dpid), stats)

  #store flow tables in local
  flow_table[event.connection.dpid] = stats

  #insert the flow enries into the new switches
  _insert_flow_entries(event)

  _set_tunnel_rule(event)

 # send barrier message to ensure all flows has been installed             
  event.connection.send(of.ofp_barrier_request(xid=0x80000000))
  event.connection.addListenerByName("BarrierIn", _handle_flow_ready)
Example #46
0
def handle_FEATURES_REPLY (con, msg):
  connecting = con.connect_time == None
  con.features = msg
  con.dpid = msg.datapath_id

  if not connecting:
    con.ofnexus._connect(con)
    return

  nexus = core.OpenFlowConnectionArbiter.getNexus(con)
  if nexus is None:
    # Cancel connection
    con.info("No OpenFlow nexus for " +
             pox.lib.util.dpidToStr(msg.datapath_id))
    con.disconnect()
    return
  con.ofnexus = nexus
  con.ofnexus._connect(con)
  #connections[con.dpid] = con

  barrier = of.ofp_barrier_request()

  def finish_connecting (event):
    if event.xid != barrier.xid:
      con.dpid = None
      con.err("Failed connect for " + pox.lib.util.dpidToStr(
              msg.datapath_id))
      con.disconnect()
    else:
      con.info("Connected to " + pox.lib.util.dpidToStr(msg.datapath_id))
      import time
      con.connect_time = time.time()
      #for p in msg.ports: print(p.show())
      con.ofnexus.raiseEventNoErrors(ConnectionUp, con, msg)
      con.raiseEventNoErrors(ConnectionUp, con, msg)
    return EventHaltAndRemove

  con.addListener(BarrierIn, finish_connecting)

  if con.ofnexus.miss_send_len is not None:
    con.send(of.ofp_switch_config(miss_send_len =
                                  con.ofnexus.miss_send_len))
  if con.ofnexus.clear_flows_on_connect:
    con.send(of.ofp_flow_mod(match=of.ofp_match(), command=of.OFPFC_DELETE))

  con.send(barrier)
Example #47
0
def start_migration():
  print "Start migration..."

  # bring down the interfaces at ovs-1 and ovs-3 
  '''print 'bring down the interfaces in ovs-1'
  remote_cmd.ssh_run_cmd(ovs1_IP,'sudo sh interface-down.sh')
  remote_cmd.ssh_run_cmd(ovs3_IP,'sudo sh interface-down.sh')'''
  
  
  for connection in core.openflow._connections.values():
    if connection.dpid == ovs1_dpid or connection.dpid == ovs2_dpid or connection.dpid == ovs3_dpid:
      connection.send(of.ofp_stats_request(body=of.ofp_flow_stats_request()))
      log.debug("Sent %i flow/port stats request(s)", len(core.openflow._connections))

      # send barrier message to ensure all flows has been installed
      connection.send(of.ofp_barrier_request(xid=0x80000000))
      connection.addListenerByName("BarrierIn", _handle_flow_ready)
Example #48
0
 def _install_tree(self, s, R, tree, match, packet_in=None):
     wp = WaitingTree(s, tree, packet_in)
     for sw in tree.keys():
         match.in_port = None
         in_port, out_port = tree[sw]
         if sw not in R:
             self._install(sw, in_port, out_port, match, tree=True)
         else:
             self._install(sw,
                           in_port,
                           out_port,
                           match,
                           tree=True,
                           mod_eth=True)
         msg = of.ofp_barrier_request()
         sw.connection.send(msg)
         wp.add_xid(sw.dpid, msg.xid)
def _handle_BarrierIn(event):
    global tempoEnv

    if (event.xid == 77777):
        event.connection.send(of.ofp_barrier_request(xid=77771))
        tempoEnv = time.time() - t

    temporec = time.time() - t
    if (event.xid == 66661):
        vRecebido.append(temporec)
    elif (event.xid == 66660):
        tempoEnv = time.time() - t
        vEnviado.append(tempoEnv)

    numRegras = [250, 500, 750, 1000, 1250, 1500, 1750, 2000, 2250]  #max=2611
    #numRegras = [250,500,750] #max=2611
    global pos
    log.info("Barrier Reply recebido em: " + str(time.time() - t) + " ID:" +
             str(event.xid))

    if (event.xid == 66661 and pos > len(numRegras)):
        log.info("Salvando resultados")
        for i in range(len(vRegras)):
            print "1 " + str(vRegras[i]) + ' ' + str(vEnviado[i]) + ' ' + str(
                vRecebido[i])
        log.info("Removendo regras port=1")
        event.connection.send(
            of.ofp_flow_mod(match=of.ofp_match(in_port=1),
                            command=of.OFPFC_DELETE))
        log.info("Finalizado.")

    if (event.xid == 77771 and pos < len(numRegras)):
        event.connection.send(
            of.ofp_flow_mod(match=of.ofp_match(in_port=1),
                            command=of.OFPFC_DELETE))
        log.info("Regras port=1 anteriores removidas")
        log.info("Instalando " + str(numRegras[pos]) + " regras")
        flood(event, 0, numRegras[pos])
        vRegras.append(numRegras[pos])
        log.info("Removendo " + str(numRegras[pos]) + " regras")
        removeRegras(event, 0, numRegras[pos])
        pos += 1
    elif (event.xid == 77771 and pos == len(numRegras)):
        log.info("Esperando ultimo BarrierReply ID 66661")
        pos += 1
Example #50
0
  def connect (self, connection):
    if connection is None:
      self.log.warn("Can't connect to nothing")
      return
    if self.dpid is None:
      self.dpid = connection.dpid
    #reises an exception if not true
    assert self.dpid == connection.dpid
    if self.ports is None:
      self.ports = connection.features.ports
    self.disconnect()
    self.connection = connection
    self._listeners = self.listenTo(connection)
    self._connected_at = time.time()

    label = dpid_to_str(connection.dpid)
    self.log = log.getChild(label)
    self.log.debug("Connect %s" % (connection,))

    #assign an ID to the switch
    if self._id is None:
      if self.dpid not in switches_by_id and self.dpid <= 254:
        self._id = self.dpid
      else:
        self._id = RoutingSwitch._next_id
        RoutingSwitch._next_id += 1
      switches_by_id[self._id] = self
    #assign network address
    self.network = IPAddr("10.%s.0.0" % (self._id,))
    self.mac = dpid_to_mac(self.dpid)

    # Disable flooding
    con = connection
    log.debug("Disabling flooding for %i ports", len(con.ports))
    for p in con.ports.itervalues():
      if p.port_no >= of.OFPP_MAX: continue
      msg = of.ofp_port_mod(port_no=p.port_no, hw_addr=p.hw_addr, config = of.OFPPC_NO_FLOOD, mask = of.OFPPC_NO_FLOOD)
      con.send(msg)

    con.send(of.ofp_barrier_request())
    con.send(of.ofp_features_request())
    # Send thee initial forwarding table to the switch
    self.send_table()
    # Set IP address of the switch
    self.ip_addr = IPAddr("10.%s.0.1" % (self._id,))
def _process_arp_packet_in(event):    
    '''
    if its an arp msg(note, arp src hw adrs is the org eth hw adrs) assuming its from edge host, if its a req:check if we know the src mac. if we dont, its a new host so update table. 
    if you know the ip->pmac, respond. 
    if not, do a bcast. fr nw do flood on all edge switches. bad soln. have bcast semantics instead
    '''
    eth_pkt = event.parsed
    arp_pkt = event.parsed.payload
    org_mac = eth_pkt.src.toStr()
    if org_mac not in actual_pmac:#new host. assign pmac, insert flow table in switch and add to table, mean we dont have arp entry also fr this
        ip = arp_pkt.protosrc.toStr()
        pmac = _handle_new_host(org_mac, ip, event.dpid, event.port)
        handler_id = event.connection.addListenerByName("BarrierIn", _handle_BarrierIn)
        barrier = of.ofp_barrier_request()
        events[barrier.xid] = (handler_id, event, pmac, ip)
        event.connection.send(barrier)
    else:
        _handle_arp(event)
Example #52
0
def _of_test_once():

    log.info("get connections...")

    for connection in core.openflow._connections.values():
        if connection.dpid == g1_dpid:
            global start_time
            start_time = time.time()

            msg = of.ofp_flow_mod()
            msg.match.in_port = 1
            msg.xid = of.generate_xid()
            global xid
            xid = msg.xid
            connection.send(msg)

            connection.send(of.ofp_barrier_request(xid=msg.xid))
            connection.addListenerByName("BarrierIn", _handle_BarrierIn)
Example #53
0
def flow_patch2port (mn1,mn2):
  global barrier_xid_mn1
  global barrier_xid_mn2
  log.info(" Start adding flow at: %s", str(datetime.now()))
  msg1 = of.ofp_flow_mod()
  msg1.priority = 100
  msg1.match.dl_type = 0x800
  msg1.match.nw_dst = listener_ip
  msg1.match.nw_proto = pkt.ipv4.UDP_PROTOCOL
  msg1.match.tp_dst = iperf_dst_port
  #msg1.match.tp_dst = vlc_dst_port
  
  if mn1:
    msg1.match.in_port = patchPort_n_mn1
    msg1.actions.append(of.ofp_action_dl_addr.set_src(dl_addr=mn1_ath1))
    msg1.actions.append(of.ofp_action_dl_addr.set_dst(dl_addr=ap1_ath))
    msg1.actions.append(of.ofp_action_output(port = 1))
    dpid_1 = mn1_br1_dpid

  elif mn2:
    msg1.match.in_port = patchPort_n_mn2
    msg1.actions.append(of.ofp_action_dl_addr.set_src(dl_addr=mn2_ath1))
    msg1.actions.append(of.ofp_action_dl_addr.set_dst(dl_addr=ap3_ath))
    msg1.actions.append(of.ofp_action_output(port = 1))
    dpid_1 = mn2_br1_dpid

  else:
    return

  # pre-handover (patch -> athX)
  core.openflow.sendToDPID(dpid_1,msg1)
  log.debug("[ Flow for br1: %s ] at [ %s ]", dpid_to_str(dpid_1),str(datetime.now()))
  
  #Make sure that 1st flow_mod was implemented
  b=of.ofp_barrier_request()
  if mn1:
    barrier_xid_mn1=b.xid
  elif mn2:
    barrier_xid_mn2=b.xid
  else:
    return

  core.openflow.sendToDPID(dpid_1,b)
  log.debug("Sent Barrier at: %s", str(datetime.now()))
Example #54
0
def _handle_ConnectionUp (event):
    # Set up this switch.
    # After setting up, we send a barrier and wait for the response
    # before starting to listen to packet_ins for this switch -- before
    # the switch is set up, the packet_ins may not be what we expect,
    # and our responses may not work!
    
    # Turn on Nicira packet_ins
    msg = nx.nx_packet_in_format()
    event.connection.send(msg)
    
    # Turn on ability to specify table in flow_mods
    msg = nx.nx_flow_mod_table_id()
    event.connection.send(msg)
    
    # Clear second table
    msg = nx.nx_flow_mod(command=of.OFPFC_DELETE, table_id = 1)
    event.connection.send(msg)
    
    # Fallthrough rule for table 0: flood and send to controller
    msg = nx.nx_flow_mod()
    msg.priority = 1 # Low priority
    
    
    msg.actions.append(of.ofp_action_output(port = of.OFPP_CONTROLLER))
    msg.actions.append(nx.nx_action_resubmit.resubmit_table(table = 1))
    event.connection.send(msg)
    
    # Fallthrough rule for table 1: flood
    msg = nx.nx_flow_mod()
    msg.table_id = 1
    msg.actions.append(of.ofp_action_output(port = of.OFPP_FLOOD))
    event.connection.send(msg)
    
    def ready (event):
        if event.ofp.xid != 0x80000000:
            # Not the right barrier
            return
        log.info("%s ready", event.connection)
        event.connection.addListenerByName("PacketIn", _handle_PacketIn)
        return EventRemove
    
    event.connection.send(of.ofp_barrier_request(xid=0x80000000))
    event.connection.addListenerByName("BarrierIn", ready)
Example #55
0
 def check_socket(self):
     pkt_count = 0
     while True:
         pkt_count += 1
         buff = self.s.recv(100)
         pkt = of.ofp_header()
         pkt.unpack(buff)
         #print('[{}][check_socket]recved: ', len(buff))
         print('\n[{0}] received [{1}]byte data.'.format(pkt_count, len(buff)))
         print(pkt.show())
         if pkt.header_type == gini_of.OFPT_HELLO:  # OFPT_HELLO
             print("OFPT_HELLO msg: ")
             pkt = of.ofp_hello()
             pkt.unpack(buff)
             self.process_hello(pkt)
         elif pkt.header_type == gini_of.OFPT_ECHO_REQUEST:
             print("OFPT_ECHO_REPLY msg: ")
             pkt = of.ofp_echo_request()
             pkt.unpack(buff)
             self.process_echo_request(pkt)
         elif pkt.header_type == gini_of.OFPT_FEATURES_REQUEST:
             print("OFPT_FEATURES_REQUEST msg: ")
             pkt = of.ofp_features_request()
             pkt.unpack(buff)
             self.process_features_request(pkt)
         elif pkt.header_type == gini_of.OFPT_SET_CONFIG:
             print("OFPT_SET_CONFIG msg: ")
             pkt = of.ofp_set_config()
             pkt.unpack(buff)
             self.process_set_config(pkt)
         elif pkt.header_type == gini_of.OFPT_FLOW_MOD:
             print("OFPT_FLOW_MOD msg: ")
             pkt = giniclass_flow_mod()
             pkt.unpack(buff)
             self.process_flow_mod(pkt)
         elif pkt.header_type == gini_of.OFPT_BARRIER_REQUEST:
             print("OFPT_BARRIER_REQUEST msg: ")
             pkt = of.ofp_barrier_request()
             pkt.unpack(buff)
             self.process_barrier_request(pkt)
         else:
             print("Unknown type!: ", pkt.header_type, "details: ")
             print(pkt.show())
Example #56
0
    def _handle_BarrierIn(self, event):
        log.debug("Got barrier.")

        if self.state == "Loading":
            self.mods = []

            for i in range(5000):
                msg = of.ofp_flow_mod()
                msg.priority = random.randint(0x8000, 0xffff)
                msg.command = of.OFPFC_ADD

                matcher = of.ofp_match()
                matcher.dl_type = 0x0800
                matcher.nw_src = IPAddr(random.randint(1,2**32-1))
                matcher.nw_dst = '10.{}.{}.0/24'.format(i/256, i%256)

                msg.match = matcher
                # msg.idle_timeout = OFP_FLOW_PERMANENT
                msg.hard_timeout = of.OFP_FLOW_PERMANENT
                msg.buffer_id = None
                msg.flags = of.OFPFF_CHECK_OVERLAP | of.OFPFF_SEND_FLOW_REM 

                msg.actions.append(of.ofp_action_output(port = 13))
                self.mods.append(msg)
                event.connection.send(msg)
                if i % 100 == 0:
                    log.debug("Sent mod message {}".format(i))
                    time.sleep(1)

            self.state = "Removing"
            msg = of.ofp_barrier_request()
            event.connection.send(msg)
            log.debug("Sending post-add barrier")

        elif self.state == "Removing":
            while len(self.mods):
                i = random.randint(0, len(self.mods)-1)        
                msg = self.mods.pop(i)
                msg.command = of.OFPFC_DELETE
                event.connection.send(msg)
                if len(self.mods) % 25:
                    log.debug("Remaining mods to remove: {}".format(len(self.mods)))
Example #57
0
  def _add_flow(self,command_type):

    global Barrier_Addxid 
    msg = of.ofp_flow_mod()
    msg.command = of.OFPFC_ADD

    self._match_field(msg)

    for connection in core.openflow._connections.values() :
      if str(dpidToStr(connection.dpid)) == self.dpid:
        
        """match actions"""
        self._match_action(msg)
        connection.send(msg)
        barrier = of.ofp_barrier_request()
        barrier.xid = of.generate_xid()
        Barrier_Addxid = barrier.xid
        connection.send(barrier)
        # for recover
        self._record_rules(dpid = self.dpid , msg = msg)
Example #58
0
def flow_mn_2 ():
  global barrier_xid
  print "-----Start add flow---- %s", str(datetime.now())
  log.info("[ mn_br0_dpid = %s ] UP", dpid_to_str(mn_br0_dpid))
  log.info("[ mn_br1_dpid = %s ] UP", dpid_to_str(mn_br1_dpid))
  # MN.br0 (patch -> ath1)
  msg0 = of.ofp_flow_mod()
  msg0.priority = 100
  msg0.match.in_port = 3
  msg0.match.dl_type = 0x800
  msg0.match.nw_dst = "192.168.10.1"
  msg0.actions.append(of.ofp_action_dl_addr.set_src(dl_addr="00:80:48:62:4e:7c"))
  msg0.actions.append(of.ofp_action_dl_addr.set_dst(dl_addr="00:80:48:62:4e:78"))
  msg0.actions.append(of.ofp_action_output(port = 1))
  core.openflow.sendToDPID(mn_br1_dpid,msg0)
  print "FLOW_MOD 1: %s", str(datetime.now())
  #Make sure that 1st flow_mod was implemented
  b=of.ofp_barrier_request()
  barrier_xid=b.xid
  core.openflow.sendToDPID(mn_br1_dpid,b)
  print "BARRIER: %s", str(datetime.now())