switchdiscovery.c

Go to the documentation of this file.

#include <projectcommon.h>
#include <memory.h>
#include <switchdiscovery.h>
#include <lldp.h>
#include <cdp.h>
#include <fsprotocol.h>
FSTATIC gboolean _switchdiscovery_discover(Discovery* self);
FSTATIC void _switchdiscovery_finalize(AssimObj* self);
FSTATIC gboolean _switchdiscovery_cache_info(SwitchDiscovery* self, gconstpointer pkt, gconstpointer pend);
FSTATIC gboolean _switchdiscovery_dispatch(GSource_pcap_t* gsource, pcap_t*, gconstpointer, gconstpointer,
                          const struct pcap_pkthdr*, const char *, gpointer selfptr);

FSTATIC void
_switchdiscovery_finalize(AssimObj* dself)
{
        SwitchDiscovery * self = CASTTOCLASS(SwitchDiscovery, dself);
        if (self->source) {
                g_source_unref(self->source);
                g_source_destroy(self->source);
                self->source = NULL;
        }
        if (self->switchid) {
                g_free(self->switchid);
                self->switchid = NULL;
        }
        if (self->portid) {
                g_free(self->portid);
                self->portid = NULL;
        }
        
        // Call base object finalization routine (which we saved away)
        self->finalize(&self->baseclass.baseclass);
}

FSTATIC gboolean
_switchdiscovery_discover(Discovery* self)  
{
        (void)self;
        return FALSE;
}


FSTATIC gboolean
_switchdiscovery_dispatch(GSource_pcap_t* gsource, 
                          pcap_t* capstruct,       
                          gconstpointer pkt,       
                          gconstpointer pend,      
                          const struct pcap_pkthdr* pkthdr, 
                          const char * capturedev,  
                          gpointer selfptr         
                          )
{
        SwitchDiscovery*        self = CASTTOCLASS(SwitchDiscovery, selfptr);
        Discovery*              dself = &(self->baseclass);
        NetGSource*             transport = dself->_iosource;
        NetAddr*                dest = dself->_config->getaddr(dself->_config, CONFIGNAME_CMADISCOVER);
        FrameSet*               fs;
        
        (void)gsource; (void)capstruct;
        //g_debug("Got an incoming LLDP/CDP packet");
        ++ self->baseclass.discovercount;
        if (!dest || !_switchdiscovery_cache_info(self, pkt, pend)) {
                return TRUE;
        }
        ++ self->baseclass.reportcount;
        //g_debug("Sending out LLDP/CDP packet - hurray!");
        fs = construct_pcap_frameset(FRAMESETTYPE_SWDISCOVER, pkt, pend, pkthdr, capturedev);
        transport->_netio->sendareliablefs(transport->_netio, dest, DEFAULT_FSP_QID, fs);
        UNREF(fs);
        return TRUE;
}

SwitchDiscovery*
switchdiscovery_new(const char *        instance
,                   const char *        dev     
,                   guint listenmask            
,                   gint priority               
,                   GMainContext*       mcontext
,                   NetGSource*         iosrc   
,                   ConfigContext*      config  
,                   gsize objsize)              
{
        Discovery * dret = discovery_new(instance, iosrc, config
        ,                                objsize < sizeof(SwitchDiscovery) ? sizeof(SwitchDiscovery) : objsize);
        SwitchDiscovery* ret;
        g_return_val_if_fail(dret != NULL, NULL);
        proj_class_register_subclassed(dret, "SwitchDiscovery");

        ret = CASTTOCLASS(SwitchDiscovery, dret);

        ret->finalize = dret->baseclass._finalize;
        dret->baseclass._finalize = _switchdiscovery_finalize;
        dret->discover = _switchdiscovery_discover;
        ret->source = g_source_pcap_new(dev, listenmask, _switchdiscovery_dispatch, NULL, priority, FALSE, mcontext, 0, ret);

        if (objsize == sizeof(SwitchDiscovery)) {
                // Subclass constructors need to register themselves, but we'll register
                // ourselves.
                discovery_register(dret);
        }
        ret->switchid = NULL;   ret->switchidlen = -1;
        ret->portid = NULL;     ret->portidlen = -1;
        return ret;
}

typedef struct _SwitchDiscoveryType SwitchDiscoveryType;
static struct _SwitchDiscoveryType {
        const char *    discoverytype;
        gboolean (*isthistype)(gconstpointer tlv_vp, gconstpointer pktend);
        gconstpointer (*get_switch_id)(gconstpointer tlv_vp, gssize* idlength, gconstpointer pktend);
        gconstpointer (*get_port_id)(gconstpointer tlv_vp, gssize* idlength, gconstpointer pktend);
} discovery_types[] = {
        {"lldp", is_valid_lldp_packet, get_lldp_chassis_id, get_lldp_port_id},
        {"cdp", is_valid_cdp_packet, get_cdp_chassis_id, get_cdp_port_id}
};

FSTATIC gboolean
_switchdiscovery_cache_info(SwitchDiscovery* self,  
                           gconstpointer pkt,      
                           gconstpointer pktend)   
{
        gsize   j;

        for (j=0; j < DIMOF(discovery_types); ++j) {
                gconstpointer   curswitchid;
                gssize          curswitchidlen = -1;
                gconstpointer   curportid;
                gssize          curportidlen = -1;

                if (!discovery_types[j].isthistype(pkt, pktend)) {
                        continue;
                }
                //g_debug("Got packet of type %s", discovery_types[j].discoverytype);
                curswitchid = discovery_types[j].get_switch_id(pkt, &curswitchidlen, pktend);
                curportid = discovery_types[j].get_port_id(pkt, &curportidlen, pktend);
                g_return_val_if_fail(curswitchid != NULL, FALSE);
                g_return_val_if_fail(curportid != NULL, FALSE);

                if (self->switchid == NULL || self->portid == NULL
                    || curportidlen != self->portidlen || curswitchidlen != self->switchidlen
                    || memcmp(curswitchid, self->switchid, curswitchidlen) != 0
                    || memcmp(curportid, self->portid, curportidlen) != 0) {

                        if (self->switchid != NULL) {
                                FREE(self->switchid); self->switchid = NULL;
                        }
                        if (self->portid != NULL) {
                                FREE(self->portid); self->portid = NULL;
                        }
                        self->switchid = g_memdup(curswitchid, curswitchidlen);
                        self->portid = g_memdup(curportid, curportidlen);
                        self->switchidlen = curswitchidlen;
                        self->portidlen = curportidlen;
                        return TRUE;
                }
                break;
        }
        return FALSE;
}