signframe.c

Go to the documentation of this file.

#include <string.h>
#include <projectcommon.h>
#include <frameset.h>
#include <signframe.h>
#include <frametypes.h>
#include <generic_tlv_min.h>
#include <tlvhelper.h>

FSTATIC gboolean _signframe_isvalid(const Frame *, gconstpointer, gconstpointer);
FSTATIC void _signframe_updatedata(Frame* self, gpointer tlvptr, gconstpointer pktend, FrameSet* fs);
FSTATIC gpointer _signframe_compute_cksum(GChecksumType, gconstpointer tlvptr, gconstpointer pktend);





FSTATIC gpointer
_signframe_compute_cksum(GChecksumType cksumtype,       
                         gconstpointer tlvptr,          
                         gconstpointer pktend)          
{
        guint16         framelen  = get_generic_tlv_len(tlvptr, pktend);
        const guint8*   nextframe;
        gssize          cksumsize;
        gssize          remainsize;
        gsize           bufsize;
        GChecksum*      cksumobj;
        guint8*         cksumbuf = NULL;

        // Get the size of this type checksum
        cksumsize = g_checksum_type_get_length(cksumtype);
        g_return_val_if_fail(cksumsize > 1, NULL);
        g_return_val_if_fail(framelen == (cksumsize + 2), NULL);

        // Find out what data is left after our frame - the data we operate on...
        nextframe = get_generic_tlv_next(tlvptr, pktend);
        g_return_val_if_fail(nextframe != NULL, NULL);

        // Compute size of remaining data (data after this frame)
        remainsize = (const guint8*)pktend - nextframe;
        g_return_val_if_fail(remainsize > 0, NULL);

        // Create a new checksum object
        cksumobj = g_checksum_new(cksumtype);
        g_return_val_if_fail(NULL != cksumobj, NULL);

        // Compute the checksum on the remainder of the packet
        g_checksum_update(cksumobj, nextframe, remainsize);

        bufsize = cksumsize;
        cksumbuf = MALLOC0(bufsize);
        if (cksumbuf != NULL) {
                // Accumulate the checksum itself - into binary digest form
                g_checksum_get_digest(cksumobj, cksumbuf, &bufsize);

                if (bufsize != (gsize)cksumsize) {
                        FREE(cksumbuf);
                        cksumbuf=NULL;
                }
        }
        g_checksum_free(cksumobj);
        return cksumbuf;
}

FSTATIC gboolean
_signframe_isvalid(const Frame * self,          
                   gconstpointer tlvptr,        
                   gconstpointer pktend)        
{
        const guint8*   framedata;
        guint16         framelen;
        guint8          subtype;
        GChecksumType   cksumtype;
        gssize          cksumsize;
        guint8*         cksumbuf;
        gboolean        ret = TRUE;

        (void)self;

        if (tlvptr == NULL) {
                const SignFrame*        sframe = CASTTOCONSTCLASS(SignFrame, self);
                return (g_checksum_type_get_length(sframe->signaturetype) >= 1);
        }
        framedata = get_generic_tlv_value(tlvptr, pktend);
        framelen  = get_generic_tlv_len(tlvptr, pktend);
        g_return_val_if_fail(framedata != NULL, FALSE);
        g_return_val_if_fail(framelen > 2, FALSE);
        
        // Verify that we are subtype 1 (byte 0)
        subtype   = tlv_get_guint8(framedata,   pktend);
        g_return_val_if_fail(subtype == 1, FALSE);

        // Get the type of the checksum (byte 1)
        cksumtype = (GChecksumType)tlv_get_guint8(framedata+1, pktend);

        cksumsize = g_checksum_type_get_length(cksumtype);
        if (cksumsize < 1) {
                ret = FALSE;
        }else{
                cksumbuf = _signframe_compute_cksum(cksumtype, tlvptr, pktend);
                if (cksumbuf == NULL) {
                        // Failed to compute checksum...
                        ret = FALSE;
                }else{
                        if (memcmp(cksumbuf, framedata+2, cksumsize) != 0) {
                                // Checksum mismatch
                                ret = FALSE;
                        }
                        FREE(cksumbuf);
                        cksumbuf = NULL;
                }
        }
        return ret;
}

FSTATIC void
_signframe_updatedata(Frame* fself,             
                      gpointer tlvptr,          
                      gconstpointer pktend,     
                      FrameSet* fs)             
{
        SignFrame*      self = CASTTOCLASS(SignFrame, fself);
        GChecksumType   cksumtype = self->signaturetype;
        gssize          cksumsize;
        guint8*         cksumbuf;
        guint8*         framedata = get_generic_tlv_nonconst_value(tlvptr, pktend);

        (void)fs;
        g_return_if_fail(framedata != NULL);
        
        // Compute the checksum
        cksumbuf = _signframe_compute_cksum(cksumtype, tlvptr, pktend);
        g_return_if_fail(cksumbuf != NULL);

        // Make sure our frame is sized exactly right
        cksumsize = g_checksum_type_get_length(cksumtype);
        g_return_if_fail(self->baseclass.length == (2 + cksumsize));

        // Put in the frame subtype (byte 0) - (0x01)
        tlv_set_guint8(framedata,   (guint8)1, pktend);

        // Put in the GChecksumType checksum type (byte 1)
        tlv_set_guint8(framedata+1, (guint8)self->signaturetype, pktend);

        // Copy over the checksum data (bytes 2 through cksumsize+2)
        memcpy(framedata+2, cksumbuf, cksumsize);

        // Free the computed checksum
        FREE(cksumbuf); cksumbuf = NULL;
        // That's it!
}


SignFrame*
signframe_new(GChecksumType sigtype,    
              gsize framesize)          
{
        Frame*          baseframe;
        SignFrame*      ret;
        gssize          cksumsize;
        guint16         frame_type = FRAMETYPE_SIG;

        if (framesize < sizeof(SignFrame)) {
                framesize = sizeof(SignFrame);
        }
        cksumsize = g_checksum_type_get_length(sigtype);
        if (cksumsize <= 1) {
                return NULL;
        }
        baseframe = frame_new(frame_type, framesize);
        baseframe->isvalid = _signframe_isvalid;
        baseframe->updatedata = _signframe_updatedata;
        baseframe->length = cksumsize + 2;
        baseframe->value = NULL;
        proj_class_register_subclassed (baseframe, "SignFrame");

        ret = CASTTOCLASS(SignFrame, baseframe);
        ret->signaturetype = sigtype;
        return ret;
}


Frame*
signframe_tlvconstructor(gconstpointer tlvstart, gconstpointer pktend)
{
        guint16         framelength = get_generic_tlv_len(tlvstart, pktend);
        const guint8*   framevalue = get_generic_tlv_value(tlvstart, pktend);
        //guint8                subtype = tlv_get_guint8(framevalue, pktend);
        GChecksumType   cksumtype = tlv_get_guint8(framevalue+1, pktend);
        SignFrame *             ret;

        g_return_val_if_fail(framelength > 2, NULL);

        ret = signframe_new(cksumtype, 0);
        g_return_val_if_fail(NULL != ret, NULL);
        ret->baseclass.length = framelength;
        return CASTTOCLASS(Frame, ret);
}