pcap_min.c

Go to the documentation of this file.

#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <projectcommon.h>
#include <cdp.h>
#include <lldp.h>
#include <pcap_min.h>
#include <addrframe.h>
#include <proj_classes.h>

#define DIMOF(a)        (sizeof(a)/sizeof(a[0]))


static struct pcap_filter_info {
        const unsigned  filterbit;
        const char *    filter;
        const char *    mcastaddr;
}filterinfo[] = {
        {ENABLE_LLDP,   "(ether proto 0x88cc and ether dst 01:80:c2:00:00:0e)", "01:80:c2:00:00:0e"},
        {ENABLE_CDP,    "(ether proto 0x2000 and ether dst 01:00:0c:cc:cc:cc)", "01:00:0c:cc:cc:cc"},

};

DEBUGDECLARATIONS
FSTATIC gboolean _enable_mcast_address(const char * addrstring, const char * dev, gboolean enable);

pcap_t*
create_pcap_listener(const char * dev           
,                    gboolean blocking          
,                    unsigned listenmask        

,                    struct bpf_program*prog)   
{
        pcap_t*                 pcdescr = NULL;
        bpf_u_int32             maskp;
        bpf_u_int32             netp;
        char                    errbuf[PCAP_ERRBUF_SIZE];
        char *                  expr = NULL;
        int                     filterlen = 1;
        unsigned                j;
        int                     cnt=0;
        int                     rc;
        const char ORWORD [] = " or ";
        gboolean                need_promisc = FALSE;

        BINDDEBUG(pcap_t);
//      setbuf(stdout, NULL);
        setvbuf(stdout, NULL, _IONBF, 0);
        errbuf[0] = '\0';

        // Search the list of valid bits so we can construct the libpcap filter
        // for the given set of protocols on the fly...
        // On this pass we just compute the amount of memory we'll need...
        for (j = 0, cnt = 0; j < DIMOF(filterinfo); ++j) {
                if (listenmask & filterinfo[j].filterbit) {
                        ++cnt;
                        if (cnt > 1) {
                                filterlen += sizeof(ORWORD);
                        }
                        filterlen += strlen(filterinfo[j].filter);
                }
        }
        
        if (filterlen < 2) {
                g_warning("Constructed filter is too short - invalid mask argument.");
                return NULL;
        }
        if (NULL == (expr = malloc(filterlen))) {
                g_error("Out of memory!");
                return NULL;
        }
        // Same song, different verse...
        // This time around, we construct the filter
        expr[0] = '\0';
        for (j = 0, cnt = 0; j < DIMOF(filterinfo); ++j) {
                if (listenmask & filterinfo[j].filterbit) {
                        ++cnt;
                        if (cnt > 1) {
                                g_strlcat(expr, ORWORD, filterlen);
                        }
                        g_strlcat(expr, filterinfo[j].filter, filterlen);
                }
        }
        if (pcap_lookupnet(dev, &netp, &maskp, errbuf) != 0) {
                g_warning("pcap_lookupnet failed: [%s]", errbuf);
                goto oopsie;
        }
        
        if (NULL == (pcdescr = pcap_create(dev, errbuf))) {
                g_warning("pcap_create failed: [%s]", errbuf);
                goto oopsie;
        }
        //pcap_set_promisc(pcdescr, FALSE);
        for (j = 0; j < DIMOF(filterinfo); ++j) {
                if (listenmask & filterinfo[j].filterbit) {
                        const char * addrstring = filterinfo[j].mcastaddr;
                        if (addrstring && !_enable_mcast_address(addrstring, dev, TRUE)) {
                                need_promisc = TRUE;
                        }
                }
        }
        pcap_set_promisc(pcdescr, need_promisc);
#ifdef HAVE_PCAP_SET_RFMON
        pcap_set_rfmon(pcdescr, FALSE);
#endif
        pcap_setdirection(pcdescr, PCAP_D_IN);
        // Weird bug - returns -3 and doesn't show an error message...
        // And pcap_getnonblock also returns -3... Neither should happen AFAIK...
        if ((rc = pcap_setnonblock(pcdescr, !blocking, errbuf)) < 0 && errbuf[0] != '\0') {
                g_warning("pcap_setnonblock(%d) failed: [%s] [rc=%d]", !blocking, errbuf, rc);
                g_warning("Have no idea why this happens - current blocking state is: %d."
                ,       pcap_getnonblock(pcdescr, errbuf));
        }
        pcap_set_snaplen(pcdescr, 1500);
        if (blocking) {
                pcap_set_timeout(pcdescr, 240*1000);
        }else{
                pcap_set_timeout(pcdescr, 1);
        }
        //pcap_set_buffer_size(pcdescr, 1500);
      
        if (pcap_activate(pcdescr) != 0) {
                g_warning("pcap_activate failed: [%s]", pcap_geterr(pcdescr));
                goto oopsie;
        }
        if (pcap_compile(pcdescr, prog, expr, FALSE, maskp) < 0) {
                g_warning("pcap_compile of [%s] failed: [%s]", expr, pcap_geterr(pcdescr));
                goto oopsie;
        }
        if (pcap_setfilter(pcdescr, prog) < 0) {
                g_warning("pcap_setfilter on [%s] failed: [%s]", expr, pcap_geterr(pcdescr));
                goto oopsie;
        }
        DEBUGMSG1("Compile of [%s] worked!\n", expr);
        free(expr); expr = NULL;
        return(pcdescr);

oopsie: // Some kind of failure - free things up and return NULL

        if (expr) {
                free(expr);
                expr = NULL;
        }
        if (pcdescr) {
                close_pcap_listener(pcdescr, dev, listenmask);
                pcdescr = NULL;
        }
        return NULL;
}

void
close_pcap_listener(pcap_t*     pcapdev         
,                   const char* dev             
,                   unsigned    listenmask)     
{
        unsigned j;
        pcap_close(pcapdev);
        for (j = 0; j < DIMOF(filterinfo); ++j) {
                if (listenmask & filterinfo[j].filterbit && filterinfo[j].mcastaddr) {
                        _enable_mcast_address(filterinfo[j].mcastaddr, dev, FALSE);
                }
        }
}


FSTATIC gboolean
_enable_mcast_address(const char * addrstring   
,                    const char * dev           
,                    gboolean enable)           
{
        GSpawnFlags     flags =  G_SPAWN_STDOUT_TO_DEV_NULL | G_SPAWN_STDERR_TO_DEV_NULL | G_SPAWN_SEARCH_PATH;
        gint            exit_status;
        const gchar*    constargv [] =
        {"ip", "maddress", (enable ? "add" : "delete"), addrstring, "dev", dev, NULL};
        gchar*          argv[DIMOF(constargv)];
        unsigned        j;


        if (NULL == addrstring) {
                return FALSE;
        }

        // This is really stupid and annoying - they have the wrong function prototype for g_spawn_sync...
        for (j=0; j < DIMOF(argv); ++j) {
                argv[j] = g_strdup(constargv[j]);
        }

        DEBUGMSG1("Running IP command %s %s %s %s %s %s", argv[0], argv[1], argv[2], argv[3], argv[4], argv[5]);
        if (!g_spawn_sync(NULL, argv, NULL, flags, NULL, NULL, NULL, NULL, &exit_status, NULL)) {
                exit_status = 300;
        }
        for (j=0; j < DIMOF(argv); ++j) {
                g_free(argv[j]);
                argv[j] = NULL;
        }
        DEBUGMSG1("Previous IP command returned %d", exit_status);
        return exit_status == 0;
}