pcap_GSource.c

Go to the documentation of this file.

#include <memory.h>
#include <projectcommon.h>
#include <proj_classes.h>
#include <pcap_min.h>
#include <pcap_GSource.h>
#include <intframe.h>
#include <addrframe.h>
#include <cstringframe.h>
#include <frametypes.h>
#include <misc.h>


FSTATIC gboolean g_source_pcap_prepare(GSource* source, gint* timeout);
FSTATIC gboolean g_source_pcap_check(GSource* source);
FSTATIC gboolean g_source_pcap_dispatch(GSource* source, GSourceFunc callback, gpointer user_data);
FSTATIC void     g_source_pcap_finalize(GSource* source);
FSTATIC guint64 proj_timeval_to_g_real_time(const struct timeval * tv);

static GSourceFuncs g_source_pcap_gsourcefuncs = {
        g_source_pcap_prepare,
        g_source_pcap_check,
        g_source_pcap_dispatch,
        g_source_pcap_finalize,
        NULL,
        NULL
};


GSource*
g_source_pcap_new(const char * dev,     
                  unsigned listenmask,  

                  gboolean (*dispatch)(GSource_pcap_t*  gsource, 
                             pcap_t* capstruct,         
                             gconstpointer pkt,         
                             gconstpointer pend,        
                             const struct pcap_pkthdr* pkthdr, 
                             const char * capturedev,   
                             gpointer userdata),        

                  GDestroyNotify notify,

                  gint priority,        

                  gboolean can_recurse, 
                  GMainContext* context, 
                  gsize objectsize,     
                  gpointer userdata     
                  )
{
        pcap_t*         captureobj;
        GSource*        src;
        GSource_pcap_t* ret;

        if (objectsize < sizeof(GSource_pcap_t)) {
                objectsize = sizeof(GSource_pcap_t);
        }

        // Try and create a GSource object for us to eventually return...
        src = g_source_new(&g_source_pcap_gsourcefuncs, objectsize);
        g_return_val_if_fail(src != NULL, NULL);

        proj_class_register_object(src, "GSource");
        proj_class_register_subclassed(src, "GSource_pcap_t");

        ret = CASTTOCLASS(GSource_pcap_t, src);
        // OK, now create the capture object to associate with it
        if (NULL == (captureobj = create_pcap_listener(dev, FALSE, listenmask, &ret->pcprog))) {
                // OOPS! Didn't work...  Give up.
                g_source_unref(src);
                return NULL;
        }
        ret->capture = captureobj;
        ret->capturedev = g_strdup(dev);
        ret->listenmask = listenmask;
        ret->dispatch = dispatch;
#ifdef _MSC_VER
        // Probably depends on the version of the API - not just being on Windows...
        ret->capturefd = pcap_fileno(ret->capture);
#else
        ret->capturefd = pcap_get_selectable_fd(ret->capture);
#endif
        ret->destroynote = notify;
        ret->gfd.fd = ret->capturefd;
        ret->gfd.events =  G_IO_IN|G_IO_ERR|G_IO_HUP;
        ret->gfd.revents =  0;
        ret->userdata = userdata;
        g_source_add_poll(src, &ret->gfd);
        g_source_set_priority(src, priority);
        g_source_set_can_recurse(src, can_recurse);
        ret->gsourceid = g_source_attach(src, context);
        if (ret->gsourceid == 0) {
                g_source_remove_poll(src, &ret->gfd);
                memset(ret, 0, sizeof(*ret));
                g_source_unref(src);
                src = NULL;
                ret = NULL;
        }
        return (GSource*)ret;
}

gboolean
g_source_pcap_prepare(GSource* source, 
                      gint* timeout)   
{
        // Don't need to do anything prior to a poll(2) call...
        (void)source;
        (void)timeout;
        return FALSE;
}
gboolean
g_source_pcap_check(GSource* src) 
{
        GSource_pcap_t* psrc = CASTTOCLASS(GSource_pcap_t, src);
        
        // revents: received events...
        // @todo: should check for errors in revents
        return 0 != psrc->gfd.revents;
}
gboolean
g_source_pcap_dispatch(GSource* src, 
                       GSourceFunc callback, 
                       gpointer user_data)   
{
        GSource_pcap_t* psrc = CASTTOCLASS(GSource_pcap_t, src);
        const u_char *          pkt;
        struct pcap_pkthdr*     hdr;
        int                     rc; // Meaning of various rc values:
                                    // 1 - read a single packet
                                    // 0 - no packets to read at the moment
                                    // negative - various kinds of errors
        (void)callback;
        (void)user_data;
        // Process all the packets we can find.
        while (1 == (rc = pcap_next_ex(psrc->capture, &hdr, &pkt))) {
                const u_char* pktend = pkt + hdr->caplen;
                if (!psrc->dispatch(psrc, psrc->capture, pkt, pktend, hdr,
                                    psrc->capturedev, psrc->userdata)) {
                        g_source_remove_poll(src, &psrc->gfd);
                        g_source_unref(src);
                        return FALSE;
                }
        }
        // @todo: should check for errors in 'rc'
        return rc >= 0;
}
void
g_source_pcap_finalize(GSource* src)
{
        GSource_pcap_t* psrc = CASTTOCLASS(GSource_pcap_t, src);
        if (psrc->destroynote) {
                psrc->destroynote(psrc);
        }
        if (psrc->capture) {
                close_pcap_listener(psrc->capture, psrc->capturedev, psrc->listenmask);
                pcap_freecode(&psrc->pcprog);
                psrc->capture = NULL;
                g_free(psrc->capturedev);
                psrc->capturedev = NULL;
        }
        proj_class_dissociate(src);
}

FSTATIC guint64
proj_timeval_to_g_real_time(const struct timeval * tv)
{
        guint64         ret;
        ret = (guint64)tv->tv_sec * (guint64)1000000UL;
        ret += (guint64)tv->tv_usec;
        return ret;
}

FrameSet*
construct_pcap_frameset(guint16 framesettype,             
                        gconstpointer pkt,                
                        gconstpointer pktend,             
                        const struct pcap_pkthdr* pkthdr, 
                        const char * interfacep)          
{
        IntFrame*       timeframe = intframe_new(FRAMETYPE_WALLCLOCK, sizeof(proj_timeval_to_g_real_time(NULL)));
        Frame*          pktframe = frame_new(FRAMETYPE_PKTDATA, 0);
        CstringFrame*   intfname = cstringframe_new(FRAMETYPE_INTERFACE, 0);
        CstringFrame*   fsysname = cstringframe_new(FRAMETYPE_HOSTNAME, 0);
        FrameSet*       fs = frameset_new(framesettype);
        const guint8*   bpkt = (const guint8*) pkt;
        gsize           pktlen = ((const guint8*)pktend-bpkt);
        guint8*         cppkt = MALLOC0(pktlen);
        gchar*          sysname;

        sysname = proj_get_sysname();
        g_return_val_if_fail(NULL != sysname, NULL);
        g_return_val_if_fail(fsysname != NULL, NULL);
        g_return_val_if_fail(timeframe != NULL, NULL);
        g_return_val_if_fail(pktframe != NULL, NULL);
        g_return_val_if_fail(intfname != NULL, NULL);
        g_return_val_if_fail(cppkt != NULL, NULL);

        // System name
        fsysname->baseclass.setvalue(&fsysname->baseclass, sysname, strlen(sysname)+1, g_free);
        frameset_append_frame(fs, &fsysname->baseclass);
        UNREF2(fsysname);

        // Interface name
        intfname->baseclass.setvalue(&intfname->baseclass, g_strdup(interfacep), strlen(interfacep)+1, g_free);
        frameset_append_frame(fs, &intfname->baseclass);
        UNREF2(intfname);

        // Local time stamp
        timeframe->setint(timeframe, proj_timeval_to_g_real_time(&(pkthdr->ts)));
        frameset_append_frame(fs, &timeframe->baseclass);
        UNREF2(timeframe);

        // Packet data
        memcpy(cppkt, pkt, pktlen);
        pktframe->setvalue(pktframe, cppkt, pktlen, g_free);
        frameset_append_frame(fs, pktframe);
        UNREF(pktframe);

        return fs;
}