コード例 #1
0
class SimpleMonitor(Routing.SimpleSwitch):

    LLDP_SEND_GUARD = .05
    LLDP_SEND_PERIOD_PER_PORT = .9
    TIMEOUT_CHECK_PERIOD = 5.
    LINK_TIMEOUT = TIMEOUT_CHECK_PERIOD * 2
    LINK_LLDP_DROP = 5
    LLDP_PACKET_LEN = len(LLDPPacket.lldp_packet(0, 0, DONTCARE_STR, 0))
    DEFAULT_TTL = 120

    
    def __init__(self, *args, **kwargs):
        super(SimpleMonitor, self).__init__(*args, **kwargs)
        self.is_active = True

        #Topology Discovery
        self.link_discovery = True
        self.port_state = {}          # datapath_id => ports
        self.ports = PortDataState()  # Port class -> PortData class
        self.links = LinkState()      # Link class -> timestamp
        self.link_length = 0
        self.switch_ports = {}
	
        self.dpid_to_ip = map_switch_dpid()

        #NPS SDN Specific Dictionary##################################################
        self.dpid_to_node = {0x00012c59e5107640:1, 0x0001c4346b94a200:2,\
                                         0x0001c4346b99dc00:4, 0x0001c4346b946200:5,\
                                         0x0001c4346b971ec0:6, 0x0001f0921c219d40:13}
        ##############################################################################

        self.active_ips = {}
        self.arp_table = {}

        #SDN Application data structures
        self.blacklist = []
        self.throttle_list = []

        #SDN Application Flags
        #This call assigns self.analyze, self.topology,
        #and self.fingerprint and sets up those apps
        self._n_fingerprint = True
        self._n_topology = True
        self._n_analyze = True
        self._load_settings()
        
        #Listen for a signal that tells the controller to update
        #its settings.  This is really tempramental.
        #signal.signal(signal.SIGUSR1, self._load_settings)
        self.threads.append(hub.spawn(self._monitor))
        self.threads.append(hub.spawn(self._listener))

        self.throttle_list = []

    def _load_settings(self, signal=None, frame=None):
	print("Loading the settings file")
        with open("control_node_settings", "r") as f:
            for line in f.readlines():
                exec(line)

        # If the fingerprint app is checked to run and has not been run yet,
        # then do all the following.
        if self.fingerprint and self._n_fingerprint:
            self._n_fingerprint = False
            self.fingerprints = {}
            self.fingerprint_list = createFingerPrintList('fingerprint.xml')
            self.cluster = Cluster()
            self.session = self.cluster.connect('fingerprints')
            db = self.session.execute_async("select * from fpspat")
            for row in db.result():
                mac_addr = row.mac
                self.fingerprints[mac_addr] = {'ip':row.ip, 'os':row.os,\
                                                'switch':row.switch, 'port':row.port,\
                                                'hostname':row.hostname, 'history':row.history}
            print("Downloaded Fingerprint Database \n")

        
        if self.analyze and self._n_analyze:
            self.analyzer = Analyzer()
            self._n_analyze = False
            with open('V','w') as f:
                f.flush()
            with open('D','w') as f:
                f.flush()
            with open('L','w') as f:
                f.flush()
        if self.topology and self._n_topology:
            self._n_topology = False
            self.lldp_event = hub.Event()
            self.link_event = hub.Event()
            self.threads.append(hub.spawn(self.lldp_loop))
            self.threads.append(hub.spawn(self.link_loop))
 


    
    def _listener(self):
        """
        This function will continuously open a file
        named 'commands' and execute each line in 
        that file and then clear the file.  If a 
        command fails, then the file is not cleared,
        so be wary of that.
        """
        while True:
            with open("commands", "r") as f:
                for line in f.readlines():
                    exec(line)
            with open("commands", "w") as f:
                f.flush()
            hub.sleep(2)

    def _monitor(self):
        """
        Runs the monitor app which collects data from the network.
        Will only run if "analyze" is clicked on the GUI's 
        splash screen.
        """
        if self.topology:
            while self.dpids == {}:
        	print("Waiting for live datapaths")
        	hub.sleep(2)
	    #self.map_hosts()

        while True:
            if self.analyze:
                for dp in self.dpids:
                    if dp in self.dpid_to_node:
                       self._request_port_stats(self.dpids[dp])
      	    if self.topology:
		self.draw_graph(1, draw=True)  
            hub.sleep(2)

##################################
#  ARP and ICMP Packet Handlers  #
##################################
    def _handle_arp_rq(self, dst_ip):
    	pkt = packet.Packet()
    	pkt.add_protocol(ethernet.ethernet(ethertype=0x806,\
                                               dst='ff:ff:ff:ff:ff:ff',\
                                               src=self.hw_addr))
        pkt.add_protocol(arp.arp(opcode=arp.ARP_REQUEST,\
                                 src_mac=self.hw_addr,\
                                 src_ip=self.ip_addr,\
                                 dst_mac='00:00:00:00:00:00',\
                                 dst_ip=dst_ip))
        self._flood_packet(pkt)
    

    def _handle_icmp_reply(self, pkt_icmp, pkt_ipv4, datapath):
        if pkt_icmp.type != icmp.ICMP_ECHO_REPLY: return
        if pkt_ipv4.dst != self.ip_addr:
            print(pkt_ipv4.dst, self.ip_addr) 
            return
        print("------------------------")
        print("PING RECEIVED THANK GOD")
        print(pkt_ipv4.src)
        print(pkt_ipv4.dst)
        print(datapath.id)
        print("------------------------")

    #Finish ARP redesignation
    def _handle_arp_reply(self, pkt_arp, port, dpid):
        if pkt_arp.opcode == arp.ARP_REPLY and pkt_arp.dst_mac == self.hw_addr:
            if pkt_arp.src_ip not in self.active_ips:
                print("ARP from " + pkt_arp.src_ip + "\n")
                self.active_ips[pkt_arp.src_ip] =  [dpid, port]
                self.arp_table[pkt_arp.src_ip] = pkt_arp.src_mac
                if self.topology:
                    self.draw_graph(1, draw=True)
        if pkt_arp.opcode == arp.ARP_REQUEST and pkt_arp.src_ip != self.ip_addr:
        #print("ARP Reqest from: " + pkt_arp.src_mac + " requesting: " + pkt_arp.dst_ip)
            if pkt_arp.dst_ip not in self.arp_table: return
            #construct and send ARP reply
            reply_pkt = packet.Packet()
            reply_pkt.add_protocol(ethernet.ethernet(ethertype=0x806,\
                                               dst=pkt_arp.src_mac,\
                                               src=self.arp_table[pkt_arp.dst_ip]))
            reply_pkt.add_protocol(arp.arp(opcode=arp.ARP_REPLY,\
                                 src_mac=self.arp_table[pkt_arp.dst_ip],\
                                 src_ip=pkt_arp.dst_ip,\
                                 dst_mac=pkt_arp.src_mac,\
                                 dst_ip=pkt_arp.src_ip))
            print("Responded to ARP Request: " )
            print("Gave [" + pkt_arp.src_mac + "," + pkt_arp.src_ip + "]" +\
            "[" + pkt_arp.dst_ip + "," + self.arp_table[pkt_arp.dst_ip] + "]") 
            self._send_packet(reply_pkt, self.dpids[int(dpid, 16)]) 


#############################
#  How to send out packets  #
#############################

    def _flood_packet(self, pkt):
    	for dpid in self.dpids:
    	    datapath = self.dpids[dpid]
    	    ofproto = datapath.ofproto
    	    actions = [datapath.ofproto_parser.OFPActionOutput(ofproto.OFPP_FLOOD)]
       	    pkt.serialize()
    	    out = datapath.ofproto_parser.OFPPacketOut(datapath=datapath, buffer_id=0xffffffff,\
    						in_port=ofproto.OFPP_CONTROLLER, actions=actions,\
    						data=pkt.data)
    	    datapath.send_msg(out)
    
    def _send_packet(self, pkt, datapath=None):
	#Pick a random datapath to send from	
        if not datapath:
	    datapath = self.dpids[self.dpids.keys()[randint(0,len(self.dpids)-1)]]
        ofproto = datapath.ofproto
	pkt.serialize()
	ether_pkt = pkt.get_protocol(ethernet.ethernet)
	if ether_pkt.dst in self.mac_to_port[datapath.id]:
	    print("Sending packet out: " + `self.mac_to_port[datapath.id][ether_pkt.dst]`)
            actions = [datapath.ofproto_parser.OFPActionOutput(self.mac_to_port[datapath.id]\
							[ether_pkt.dst])]
            out = datapath.ofproto_parser.OFPPacketOut(datapath=datapath, buffer_id=0xffffffff,\
                                                in_port=ofproto.OFPP_CONTROLLER, actions=actions,\
                                                data=pkt.data)
            datapath.send_msg(out)

##########################
#  How to draw a graph  #
#########################
    def draw_graph(self, timeout, draw=False):
        """
        This function does the actual drawing of the 
        network topology.
        """
    	G = nx.Graph()

        plt.clf()
        labels = {}
        nodes = []
    	host_nodes = []
        for id in self.dpids:
            G.add_node(hex(id))
            labels[hex(id)] = hex(id)
            nodes.append(hex(id))

    	
        for link in self.links:
            G.add_edge(hex(link.src.dpid), hex(link.dst.dpid))
    	for ip in self.active_ips:
    	    if ip not in host_nodes:
    	    	G.add_node(ip)
    	    	G.add_edge(self.active_ips[ip][0], ip)
    		host_nodes.append(ip)

        self.graph = G.copy()
        pos = nx.spring_layout(G)
    	
    	G = nx.Graph()
    	
    	if draw:
            nx.draw(G)
            nx.draw_networkx_nodes(G, pos, nodelist=nodes, node_color='FireBrick',\
                                    node_size=500, alpha=0.8)
    	    nx.draw_networkx_nodes(G, pos, nodelist=host_nodes, node_color='DarkGoldenRod',\
    				node_size=200, alpha=0.8)

    	    for link in self.links:
                    G.add_edge(hex(link.src.dpid), hex(link.dst.dpid))
    	    for ip in self.active_ips:
    		G.add_edge(self.active_ips[ip][0],ip)

    	    nx.draw_networkx_edges(G, pos)
            plt.pause(timeout)


##########################
#  How to create a flow  #
##########################

    def _create_icmp_flow(self,datapath):
        ofproto = datapath.ofproto
        ofproto_parser = datapath.ofproto_parser
        nw_dst = struct.unpack('!I', ipv4_to_bin(self.ip_addr))[0]    
        match = datapath.ofproto_parser.OFPMatch(dl_type=0x800, nw_dst=nw_dst)
        actions = [datapath.ofproto_parser.OFPActionOutput(ofproto.OFPP_CONTROLLER)]
        mod = datapath.ofproto_parser.OFPFlowMod(
                datapath=datapath, match=match, cookie=0, command=ofproto.OFPFC_ADD,
                idle_timeout=0, hard_timeout=0, actions=actions,
                priority=0xFFFF)
        datapath.send_msg(mod)

    def _create_lldp_flow(self, datapath):
        ofproto = datapath.ofproto
        ofproto_parser = datapath.ofproto_parser        
        if ofproto.OFP_VERSION == ofproto_v1_0.OFP_VERSION:
            #Add LLDP Rule
            match = datapath.ofproto_parser.OFPMatch(dl_type=0x88cc)
            actions = [datapath.ofproto_parser.OFPActionOutput(ofproto.OFPP_CONTROLLER)]
            mod = datapath.ofproto_parser.OFPFlowMod(
                        datapath=datapath, match=match, cookie=0, command=ofproto.OFPFC_ADD,
                        idle_timeout=0, hard_timeout=0, actions=actions,
                        priority=0xFFFF)
            datapath.send_msg(mod)

    def _create_arp_flow(self, datapath):
        ofproto = datapath.ofproto
        ofproto_parser = datapath.ofproto_parser
        match = datapath.ofproto_parser.OFPMatch(dl_type=0x0806)
        actions = [datapath.ofproto_parser.OFPActionOutput(ofproto.OFPP_CONTROLLER)]
        mod = datapath.ofproto_parser.OFPFlowMod(
                datapath=datapath, match=match, cookie=0, command=ofproto.OFPFC_ADD,
                idle_timeout=0, hard_timeout=0, actions=actions,
                priority=0xFFFF)
        datapath.send_msg(mod)


###################################
#  How to use Ryu Event Handlers  #
###################################	

    @set_ev_cls(ofp_event.EventOFPStateChange,
            [MAIN_DISPATCHER, DEAD_DISPATCHER])
    def _state_change_handler(self, ev):
        datapath = ev.datapath

        if ev.state == MAIN_DISPATCHER:
            
            dp_multiple_conns = False
            if datapath.id in self.dpids:
                dp_multiple_conns = True
            
            self.logger.debug('register datapath: %016x', datapath.id)
            print("New DPID: " + hex(datapath.id))

            self._register(datapath)
            switch = self._get_switch(datapath.id)

            if not dp_multiple_conns:
                self.send_event_to_observers(event.EventSwitchEnter(switch))
                
            
            self._create_lldp_flow(datapath)
	    self._create_arp_flow(datapath)
    	    self._create_icmp_flow(datapath)


            if not dp_multiple_conns:
                for port in switch.ports:
                    if not port.is_reserved():
                        self._port_added(port)
                        
        elif ev.state == DEAD_DISPATCHER:
	    switch = self._get_switch(datapath.id)
            if datapath.id in self.dpids:
                self.logger.debug('unregister datapath: %016x', datapath.id)
                self._unregister(datapath)
                self.send_event_to_observers(event.EventSwitchLeave(switch))
            
            for port in switch.ports:
                if not port.is_reserved():
                    self.ports.del_port(port)
                    self._link_down(port)
        if self.topology:
            self.lldp_event.set()


    @set_ev_cls(ofp_event.EventOFPPortStatus, MAIN_DISPATCHER)
    def port_status_handler(self, ev):
        msg = ev.msg
    	reason = msg.reason
    	dp = msg.datapath
    	ofpport = msg.desc
    	if reason == dp.ofproto.OFPPR_ADD:
    		self.port_state[dp.id].add(ofpport.port_no, ofpport)
    		self.send_event_to_observers(\
    			event.EventPortAdd(Port(dp.id, dp.ofproto, ofpport)))

    		if not self.link_discovery:
    			return

    		port = self._get_port(dp.id, ofpport.port_no)
    		if port and not port.is_reserved():
    			self._port_added(port)
    			self.lldp_event.set()
    	elif reason == dp.ofproto.OFPPR_DELETE:
    		self.port_state[dp.id].remove(ofpport.port_no)
    		self.send_event_to_observers(\
    			event.EventPortDelete(Port(dp.id, dp.ofproto, ofpport)))

    		if not self.link_discovery:
    			return

    		port = self._get_port(dp.id, ofpport.port_no)
    		if port and not port.is_reserved():
    			self.ports.del_port(port)
    			self._link_down(port)
    			self.lldp_event.set()

    	else:
    		assert reason == dp.ofproto.OFPPR_MODIFY
    		self.port_state[dp.id].modify(ofpport.port_no, ofpport)
    		self.send_event_to_observers(\
    			event.EventPortModify(Port(dp.id, dp.ofproto, ofpport)))

    		if not self.link_discovery:
    			return

    		port = self._get_port(dp.id, ofpport.port_no)
    		if port and not port.is_reserved():
    			if self.ports.set_down(port):
    				self._link_down(port)
    			self.lldp_event.set()

    @set_ev_cls(ofp_event.EventOFPPortStatsReply, MAIN_DISPATCHER)
    def _port_stats_reply_handler(self, ev):
        timestamp = datetime.now()
        self.analyzer.analyze(ev, timestamp.second + (timestamp.microsecond * 1e-6))
    
    @set_ev_cls(ofp_event.EventOFPPacketIn, MAIN_DISPATCHER)
    def app_packet_in_handler(self, ev):
        msg = ev.msg
	pkt = packet.Packet(msg.data)
	pkt_dhcp = pkt.get_protocol(dhcp.dhcp)
	pkt_arp = pkt.get_protocol(arp.arp)
	pkt_icmp = pkt.get_protocol(icmp.icmp)
	pkt_ipv4 = pkt.get_protocol(ipv4.ipv4)
	if pkt_icmp:
	    self._handle_icmp_reply(pkt_icmp, pkt_ipv4, msg.datapath)
	if pkt_arp:
            self._handle_arp_reply(pkt_arp, ev.msg.in_port, hex(msg.datapath.id))   
        if self.fingerprint:
    	    if pkt_dhcp:
    		print("----------------------------------")
    		print(pkt_dhcp.yiaddr)
    		print(pkt_dhcp.op)
    		print("----------------------------------")
    	    self._dhcp_handler(msg)
		
        if self.topology:
            self._lldp_handler(msg)

#######################
#  DHCP Fingerprints  #
#######################

    def _dhcp_handler(self, msg):
        """
        Takes a DHCP packet and parses it for MAC, IP, Switch, Port, Options
        Using the options, this function checks those options against a 
        fingerprint database in order to guess the operating system used 
        by the host.  Afterwards, it stores that information in a 
        Cassandra database.
        """
        dpid = hex(msg.datapath.id)
        pkt = msg.data
        try:
            source_mac, parsedPacket = dhcp_parse(pkt)
		
        except TypeError:
            return 

        hitlist = compare(self.fingerprint_list,parsedPacket)

        hostname = get_dhcp_option_value(parsedPacket[12], 12)
        option53 = get_dhcp_option_value(parsedPacket[12], 53)
        option60 = get_dhcp_option_value(parsedPacket[12], 60)
        if option53:
            dhcptype = dhcp_types[option53]
            if dhcptype != "Discover" and dhcptype != "Request":
                print("Not a request of discover packets, so ignoring")
                return
        if parsedPacket[2]:
            source_ip = hex_to_ip(hex(parsedPacket[2]))
        elif parsedPacket[16]:
            source_ip = hex_to_ip(hex(parsedPacket[16]))
        elif get_dhcp_option_value(parsedPacket[12], 50):
            source_ip = map(ord, get_dhcp_option_value(parsedPacket[12], 50))
            source_ip = '.'.join(str(x) for x in source_ip)
        else:
            source_ip = None

        mac = hex_to_mac(source_mac)

        ### NPS CCW Specific Network ###
        location = DPIDToLocation(dpid)#
        port = str(msg.in_port)        # 
        ################################

        if mac not in self.fingerprints:
            print("New fingerprint")
            print "Source MAC: {}".format(mac)
            print "IP Address: {}".format(source_ip)
            print "Location  : {}".format(location)
            print "Host name : {}".format(hostname)
            print "DHCP Type : {}".format(dhcptype)
            mac_history = ["[%s, %s, %s, %s, %s]" % (source_ip, hitlist[0][0],\
                            location, port, hostname)]
            self.fingerprints[mac] = {'ip':source_ip, 'os':hitlist[0][0],\
                                            'switch':location, 'port':port,\
                                            'hostname':hostname, 'history':mac_history}
            command = "insert into fpspat (MAC, IP, OS, Switch, Port, Hostname,\
                        Time, History) values ('{0}', '{1}', '{2}', '{3}', '{4}',\
                        '{5}', '{6}', {7})".format(mac, source_ip, hitlist[0][0],\
                        location, port, hostname, str(datetime.now()),\
                        mac_history)
            self.session.execute(command)
        
        fp = self.fingerprints[mac]
        changes = []
        time = str(datetime.now())
        for prop,val in [('ip', source_ip), ('os', hitlist[0][0]),('hostname', hostname)]:
            if fp[prop] != val:
                print("The " + prop + " changed")
                changes.append("[" + fp[prop] + " changed to " + val + " at time " + time + "]")
                fp[prop] = val
                command = "update fpspat set " + prop + " = " + `val` + " where MAC = " + `mac`
                print(command)
		self.session.execute(command)

        if changes:
            print("Database updated to reflect changes")
            fp['history'] += changes
	    print(fp['history'])
            command = "update fpspat set History = '{0}' where MAC= '{1}'".format(str(fp['history']),\
		str(mac))
            self.session.execute(command)


#######################################
#  LLDP Portion - Topology Detection  #
#######################################
    def close(self):
        self.is_active = False
        if self.link_discovery:
            self.lldp_event.set()
        self.link_event.set()
        hub.joinall(self.threads)
            
    def _register(self, dp):
        """
        Takes the datapath and registers
        it as a switch.  This is how
        the controller represents the 
        switches.
        """
        assert dp.id is not None

        self.dpids[dp.id] = dp
        if dp.id not in self.port_state:
            self.port_state[dp.id] = PortState()
            for port in dp.ports.values():
                self.port_state[dp.id].add(port.port_no, port)

    def _unregister(self, dp):
        """
        This function is called when a switch
        dies. It helps with the book-keeping
        and clean up.
        """
        if dp.id in self.dpids:
            del self.dpids[dp.id]
            del self.port_state[dp.id]

    def _get_switch(self, dpid):
        """
        Returns the switch representation
        of the datapath id.
        """
        if dpid in self.dpids:
            switch = Switch(self.dpids[dpid])
            for ofpport in self.port_state[dpid].values():
                switch.add_port(ofpport)
            return switch

    def _get_port(self, dpid, port_no):
        """
        Returns the controller's representation of a port.
        """
        switch = self._get_switch(dpid)
        if switch:
            for p in switch.ports:
                if p.port_no == port_no:
                    return p

    def _port_added(self, port):
        """
        Adds the port to a list of ports used to 
        connect two switches.
        """
        lldp_data = LLDPPacket.lldp_packet(
            port.dpid, port.port_no, port.hw_addr, self.DEFAULT_TTL)
        self.ports.add_port(port, lldp_data)
        # LOG.debug('_port_added dpid=%s, port_no=%s, live=%s',
        #           port.dpid, port.port_no, port.is_live())

    def _link_down(self, port):
        """
        Creates an event that will tell the controller
        that the link state has changed so that the 
        controller can reflect that in its representation.
        """
        try:
            dst, rev_link_dst = self.links.port_deleted(port)
        except KeyError:
            # LOG.debug('key error. src=%s, dst=%s',
            #           port, self.links.get_peer(port))
            return
        link = Link(port, dst)
        self.send_event_to_observers(event.EventLinkDelete(link))
        if rev_link_dst:
            rev_link = Link(dst, rev_link_dst)
            self.send_event_to_observers(event.EventLinkDelete(rev_link))
        self.ports.move_front(dst)

    def _lldp_handler(self, msg):
        """
        Will react to LLDP packets by parsing then and creating 
        events so that the controller knows to update its topology
        representation.
        """
        try:
            # Attempt to parse the packet as an LLDP packet
            # Will fail if it is not an LLDP packet
            src_dpid, src_port_no = LLDPPacket.lldp_parse(msg.data)
        except LLDPPacket.LLDPUnknownFormat as e:
            # This handler can receive all the packtes which can be
            # not-LLDP packet. Ignore it silently
            #print("Not LLDP Packet")
            return

        dst_dpid = msg.datapath.id
        if msg.datapath.ofproto.OFP_VERSION == ofproto_v1_0.OFP_VERSION:
            dst_port_no = msg.in_port
        elif msg.datapath.ofproto.OFP_VERSION >= ofproto_v1_2.OFP_VERSION:
            dst_port_no = msg.match['in_port']
        else:
            LOG.error('cannot accept LLDP. unsupported version. %x',
                      msg.datapath.ofproto.OFP_VERSION)

        src = self._get_port(src_dpid, src_port_no)
        if not src or src.dpid == dst_dpid:
            return
        try:
            self.ports.lldp_received(src)
        except KeyError:
            # There are races between EventOFPPacketIn and
            # EventDPPortAdd. So packet-in event can happend before
            # port add event. In that case key error can happend.
            # LOG.debug('lldp_received: KeyError %s', e)
            pass

        dst = self._get_port(dst_dpid, dst_port_no)
        if not dst:
            return

        old_peer = self.links.get_peer(src)
        if old_peer and old_peer != dst:
            old_link = Link(src, old_peer)
            self.send_event_to_observers(event.EventLinkDelete(old_link))

        link = Link(src, dst)
        if link not in self.links:
            self.send_event_to_observers(event.EventLinkAdd(link))
	    if src_dpid not in self.switch_ports:
		self.switch_ports[src_dpid] = []
	    if src_port_no not in self.switch_ports[src_dpid]:
	        self.switch_ports[src_dpid].append(src_port_no)
	    if dst_dpid not in self.switch_ports:
		self.switch_ports[dst_dpid] = []
	    if dst_port_no not in self.switch_ports[dst_dpid]:
		self.switch_ports[dst_dpid].append(dst_port_no)

        if not self.links.update_link(src, dst):
            self.ports.move_front(dst)
            self.lldp_event.set()
            

    def send_lldp_packet(self, port):
        """
        Handles the crafting and sending of LLDP packets
        For each port on each switch, create a packet 
        unique to that (switch,port) combination.
        """
        try:
            port_data = self.ports.lldp_sent(port)
        except KeyError as e:
            # ports can be modified during our sleep in self.lldp_loop()
            # LOG.debug('send_lldp: KeyError %s', e)
            return
        if port_data.is_down:
            return

        dp = self.dpids.get(port.dpid, None)
        if dp is None:
            # datapath was already deleted
            return

        # LOG.debug('lldp sent dpid=%s, port_no=%d', dp.id, port.port_no)
        # TODO:XXX
        if dp.ofproto.OFP_VERSION == ofproto_v1_0.OFP_VERSION:
            actions = [dp.ofproto_parser.OFPActionOutput(port.port_no)]
            dp.send_packet_out(actions=actions, data=port_data.lldp_data)
        elif dp.ofproto.OFP_VERSION >= ofproto_v1_2.OFP_VERSION:
            actions = [dp.ofproto_parser.OFPActionOutput(port.port_no)]
            out = dp.ofproto_parser.OFPPacketOut(
                datapath=dp, in_port=dp.ofproto.OFPP_CONTROLLER,
                buffer_id=dp.ofproto.OFP_NO_BUFFER, actions=actions,
                data=port_data.lldp_data)
            dp.send_msg(out)
        else:
            LOG.error('cannot send lldp packet. unsupported version. %x',
                      dp.ofproto.OFP_VERSION)

    def lldp_loop(self):
        """
        This function is how the topology is kept up to date.
        It will send out LLDP packets at every interval to
        update the topology.
        """
        while self.is_active:
	    self.lldp_event.clear()
            now = time.time()
            timeout = None
            ports_now = []
            ports = []
            for (key, data) in self.ports.items():
                if data.timestamp is None:
                    ports_now.append(key)
                    continue

                expire = data.timestamp + self.LLDP_SEND_PERIOD_PER_PORT
                if expire <= now:
                    ports.append(key)
                    continue

                timeout = expire - now
                break

            for port in ports_now:
                self.send_lldp_packet(port)
            for port in ports:
                self.send_lldp_packet(port)
                hub.sleep(self.LLDP_SEND_GUARD)      # don't burst
            if timeout is not None and ports:
                timeout = 0     # We have already slept
            # LOG.debug('lldp sleep %s', timeout)
            self.draw_graph(1, draw=True)
            self.lldp_event.wait(timeout=timeout)
	
    def link_loop(self):
        """
        This function helps update the actual connection
        between switches.  I don't know the difference
        between this function and lldp_loop, but you
        need both of them, otherwise, the topology won't
        update.
        """
        while self.is_active:
	    self.link_event.clear()
            now = time.time()
	    deleted = []
            for (link, timestamp) in self.links.items():
	        # LOG.debug('%s timestamp %d (now %d)', link, timestamp, now)
	        if timestamp + self.LINK_TIMEOUT < now:
		    src = link.src
		    if src in self.ports:
		        port_data = self.ports.get_port(src)
			# LOG.debug('port_data %s', port_data)
			if port_data.lldp_dropped() > self.LINK_LLDP_DROP:
		            deleted.append(link)

	    for link in deleted:
	        self.links.link_down(link)
		# LOG.debug('delete %s', link)
		self.send_event_to_observers(event.EventLinkDelete(link))

		dst = link.dst
		rev_link = Link(dst, link.src)
		if rev_link not in deleted:
			# It is very likely that the reverse link is also
			# disconnected. Check it early.
			expire = now - self.LINK_TIMEOUT
			self.links.rev_link_set_timestamp(rev_link, expire)
			if dst in self.ports:
				self.ports.move_front(dst)
				self.lldp_event.set()
		if link.dst.port_no in self.switch_ports[link.dst.dpid]:
		    self.switch_ports[link.dst.dpid].remove(link.dst.port_no)
		if link.src.port_no in self.switch_ports[link.src.dpid]:
		    self.switch_ports[link.src.dpid].remove(link.src.port_no)

	    self.link_event.wait(timeout=self.TIMEOUT_CHECK_PERIOD)

##################################
#   Application Implementations  #
##################################	

    def _request_port_stats(self, datapath):
        """
        Sends a message to each switch requesting
        port statistics.  This is used for network
        analytics.
        """
        ofproto = datapath.ofproto
        parser = datapath.ofproto_parser
        req = parser.OFPPortStatsRequest(datapath, 0, ofproto.OFPP_NONE)
        datapath.send_msg(req)


    #Adds or removes an IP flow from each switch
    def _modify_blacklist(self, ipaddr, mode, dl_type=0x800):
       	res = struct.unpack('!I', ipv4_to_bin(ipaddr))[0]
    	if mode == "add":
    	    if ipaddr in self.blacklist:
    	        return
	    self.blacklist.append(ipaddr)
    	elif mode == "remove":
    	    if ipaddr not in self.blacklist:
    	        return
	    self.blacklist.remove(ipaddr)

    	for dp in self.dpids:
    	    datapath = self.dpids[dp]
    	    ofproto = datapath.ofproto
            match = datapath.ofproto_parser.OFPMatch(dl_type=dl_type, nw_src=res)

    	    if mode == "add":
		print("Adding " + ipaddr + " to blacklist")
    	        command = ofproto.OFPFC_ADD
    	    elif mode == "remove":
		print("Removing " + ipaddr + " to blacklsit")
    	        command = ofproto.OFPFC_DELETE
    	    mod = datapath.ofproto_parser.OFPFlowMod(datapath=datapath, match=match,\
                                    cookie=0,command=command, idle_timeout=0, hard_timeout=0,\
                                    priority=ofproto.OFP_DEFAULT_PRIORITY+5,\
                                    flags=ofproto.OFPFF_SEND_FLOW_REM, actions=None)

            datapath.send_msg(mod)			
	
    #Changes transmission rate on a switch's port -- meant for HP switches
    #@todo: make more general? Throttle switches that see an IP address
    def _modify_throttle(self, switch_ip, port, mode, username="******", password="******"):
    	if mode == "add":
            if ipaddr in self.throttle_list: return
    	    self.throttle_list.append((switch, port))
    	    command = 'interface ethernet' + `port` + ' rate-limit all out kbps 10000'
    	elif mode == "rmv":
    	    if ipaddr not in self.throttle_list: return
            self.throttle_list.remove((switch, port))
    	    command = 'no interface ethernet' + `port` + ' rate-limit all out kbps 10000'
    	    
    	print("Starting throttle command")
    	s = pexpect.spawn("ssh %s@%s" %(username, switch_ip))
    	s.expect('.*assword: ')
        # Send the password
        s.sendline(password)
        s.expect('Press any key to continue')
        # Send the return key
        s.send('\r')
        s.sendline('config \n')
        s.sendline(command)
        s.sendline('logo')
        s.sendline('y')
        print('Throttle Successful')

    def clear_all_flows(self):
        for switch in [1,2,3,4,5,6,8,9,10,11,12,13,14]:
            print("Deleting flows on {}".format(switch))
            system("dpctl del-flows tcp:10.10.0.{}:6655".format(switch))
            
        for dp in self.dpids:
            datapath = self.dpids[dp]
            print("Adding flows onto {}".format(dp))
            self._create_lldp_flow(datapath)
        self._create_arp_flow(datapath)
        self._create_icmp_flow(datapath)
    
    def switch_on_all_ports(self,username="******", password="******"):
        for dp in self.dpids:
            dp = hex(dp)
            print("logging into " + self.dpid_to_ip[dp])
            s = spawn("ssh %s@%s" %(username, self.dpid_to_ip[dp]))
            s.expect(".*assword")
            s.sendline(password)
            s.expect("Press any key to continue")
            s.sendline("\r")
            s.sendline("config")
            for n in range(1,25):
                #print("Enabling port " + `n` + " on " + self.dpid_to_ip[dp])
                s.sendline("interface ethernet " + `n` + " enable")
            s.sendline("save")
            s.sendline("logo")
            s.sendline("y")
        print("CREATED FULLY CONNECTED GRAPH")

    def create_spanning_tree(self, username="******", password="******"):
        T = nx.minimum_spanning_tree(self.graph)

        used_links = []
        disabled_ports = {}

        for link in self.links:
            used = False
            src, dst = hex(link.src.dpid), hex(link.dst.dpid)
            for edge in T.edges():
                if (src,dst) == edge or (dst,src) == edge:
                    used = True
            if not used:
                if link.src.dpid not in disabled_ports:
                    disabled_ports[link.src.dpid] = []
                disabled_ports[link.src.dpid].append(link.src.port_no)
        for dp in disabled_ports:
            ip = self.dpid_to_ip[hex(dp)]
            print("logging into " + ip)
            s = spawn("ssh %s@%s" %(username, ip))
            s.expect(".*assword")
            s.sendline(password)
            s.expect("Press any key to continue")
            s.sendline("\r")
            s.sendline("config")
            for n in disabled_ports[dp]:
                #print("Enabling port " + `n` + " on " + self.dpid_to_ip[dp])
                s.sendline("interface ethernet " + `n` + " disable")
            s.sendline("save")
            s.sendline("logo")
            s.sendline("y")
        print("CREATED SPANNING TREE")

    def send_ping(self, ip_dst):
        pkt = packet.Packet()
        if ip_dst in self.arp_table:
            mac_dst = self.arp_table[ip_dst]
        else:
            return
        pkt.add_protocol(ethernet.ethernet(ethertype=0x800,dst=mac_dst,\
                                                           src=self.hw_addr))

        pkt.add_protocol(ipv4.ipv4(dst= ip_dst, src=self.ip_addr,proto=1))
        pkt.add_protocol(icmp.icmp(type_= 8, code=0, csum=0))#Not sure about echo
        print("Ping packet sent")
        self._flood_packet(pkt)

    def map_hosts(self,time=2):
        with open("ipList.txt", "r") as f:
            lines = f.readlines()
        
        shuffle(lines)
        for line in lines:
            line = line.strip()
            print("Sending ARP to " + line)
            self._handle_arp_rq(line)
            hub.sleep(1)