def handle_HELLO(con, msg): # S # con.msg("HELLO wire protocol " + hex(msg.version)) # Send a features request print("receive Hello message") msg = of.ofp_features_request() con.send(msg)
def handle_HELLO(con, msg): #S #con.msg("HELLO wire protocol " + hex(msg.version)) # Send a features request #log.info("recv a hello msg") msg = of.ofp_features_request() con.send(msg)
def _handle_PortStatus(self, event): """ The method sends features_request message every time it receives PortStatus message so that the object always contains upto date information of ports """ connection.send(ofp_features_request())
def __init__(self, sock, send_hello=True): self._previous_stats = [] self.ofnexus = _dummyOFNexus self.sock = sock self.buf = '' Connection.ID += 1 self.ID = Connection.ID # TODO: dpid and features don't belong here; they should be eventually # be in topology.switch self.dpid = None self.features = None self.disconnected = False self.disconnection_raised = False self.connect_time = None self.idle_time = time.time() if send_hello: log.debug('sending of.ofp_hello') self.send(of.ofp_hello()) else: log.debug('sending of.ofp_features_request') msg = of.ofp_features_request() log.debug(msg) self.send(msg) self.original_ports = PortCollection() self.ports = PortCollection() self.ports._chain = self.original_ports
def handle_HELLO (con, msg): #S #con.msg("HELLO wire protocol " + hex(msg.version)) log.debug("-> Hello received") # Send a features request msg = of.ofp_features_request() log.debug("<- Feature request sent") con.send(msg)
def handle_HELLO(con, msg): #S #con.msg("HELLO wire protocol " + hex(msg.version)) # Send a features request "Enviar um pedido, recursos" msg = of.ofp_features_request() con.send(msg)
def handle_HELLO(con, msg): #S #con.msg("HELLO wire protocol " + hex(msg.version)) # Send a features request print("receive Hello message") msg = of.ofp_features_request() con.send(msg)
def handle_HELLO (con, msg): #S #con.msg("HELLO wire protocol " + hex(msg.version)) # Send a features request msg = of.ofp_features_request() con.send(msg) print ("DJ---/pox/openflow/of_01.py handle_HELLO con:",con)
def _on_timer(): for n in nodes: #Sends out requests to the network nodes core.openflow.getConnection(n.connection.dpid).send(of.ofp_features_request()) n.connection.send(of.ofp_stats_request(body=of.ofp_port_stats_request())) n.connection.send(of.ofp_stats_request(body=of.ofp_aggregate_stats_request())) n.connection.send(of.ofp_stats_request(body=of.ofp_flow_stats_request()))
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))
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 = {}
def handle_HELLO (self, con, msg): #S # Send features and switch desc requests if not self._features_request_sent: self._features_request_sent = True fr = of.ofp_features_request() if self.request_description: ss = of.ofp_stats_request() ss.body = of.ofp_desc_stats_request() con.send(fr.pack() + ss.pack()) else: con.send(fr)
def handle_HELLO(self, con, msg): #S # Send features and switch desc requests if not self._features_request_sent: self._features_request_sent = True fr = of.ofp_features_request() if self.request_description: ss = of.ofp_stats_request() ss.body = of.ofp_desc_stats_request() con.send(fr.pack() + ss.pack()) else: con.send(fr)
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 _check_ports(dpid): _dirty_switches.pop(dpid, None) con = core.openflow.getConnection(dpid) if con is None: return """ Barrier (Barreira) : Barreira de solicitação / resposta mensagens são utilizados pelo controlador para garantir dependências de mensagens foram cumpridos ou para receber notificações de operações concluídas . """ con.send(of.ofp_barrier_request()) """ Features (Características): O controlador pode solicitar a identidade e as capacidades básicas de um switch através do envio um pedido de recursos ; o interruptor deve responder com uma características responder que especifica a identidade e básico capacidades da chave. Isto é comumente realizada mediante estabelecimento do canal OpenFlow . """ con.send(of.ofp_features_request()) log.debug("Requested switch features for %s", str(con))
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())
def _realize(self): if self._port_out == self._port_out_cache: return # We really shouldn't need to get the connection here... con = core.openflow.connections.get(self.dpid) if con is None: return data = [] for port_no, cfg in self._port_out.items(): if port_no not in self.ports: continue if port_no not in con.ports: continue p = con.ports[port_no] pm = of.ofp_port_mod(port_no=p.port_no, hw_addr=p.hw_addr, config=cfg, mask=of.OFPPC_NO_FLOOD | of.OFPPC_NO_FWD) data.append(pm.pack()) # We could probably handle the features stuff better data.append(of.ofp_features_request().pack()) if self.send(b''.join(data)): self._port_out_cache = self._port_out self.log.info("Configured %s ports", len(data) - 1)
def handle_HELLO(con, msg): #S #con.msg("HELLO wire protocol " + hex(msg.version)) # Send a features request msg = of.ofp_features_request() con.send(msg)
def handle_HELLO (con, msg): #S #con.msg("HELLO wire protocol " + hex(msg.version)) # Send a features request msg = of.ofp_features_request() con.send(msg)
def timer_func(): for n in nodes: core.openflow.getConnection(n.connection.dpid).send(of.ofp_features_request())
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) # 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 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()) # Some of this is copied from DHCPD's __init__(). 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 = self.ip_addr self.router_addr = None self.dns_addr = None #fix_addr(dns_address, self.router_addr) 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 # An hour #TODO: Actually make them expire :) self.offers = {} # Eth -> IP we offered self.leases = {} # Eth -> IP we leased
def _refresh_features(self): # Not sure if this is strictly necessary; pulled from openflow/spanning_tree.py # We do this after we adjust link state via ofp_port_mod commands. SpanningTreeSwitch.logger.info('switch-{}: Refreshing features.'.format(self.dpid)) self.connection.send(of.ofp_barrier_request()) self.connection.send(of.ofp_features_request())