intframe.c

Go to the documentation of this file.

#include <string.h>
#include <projectcommon.h>
#include <frameset.h>
#include <intframe.h>
#include <frametypes.h>
#include <generic_tlv_min.h>
#include <tlvhelper.h>
FSTATIC int _intframe_intlength(IntFrame *);
FSTATIC void _intframe_setint(IntFrame * self, guint64 value);
FSTATIC guint64 _intframe_getint(IntFrame * self);
FSTATIC void _intframe_updatedata(Frame*, gpointer, gconstpointer, FrameSet*);
FSTATIC gboolean _intframe_isvalid(const Frame*, gconstpointer, gconstpointer);
FSTATIC gchar* _intframe_toString(gconstpointer obj);


FSTATIC int
_intframe_intlength(IntFrame * self)
{
        return self->baseclass.length;
}
FSTATIC void
_intframe_setint(IntFrame * self, guint64 value)
{
        guint64 limit = 0;
        switch (self->baseclass.length) {
                case 1: limit = G_MAXUINT8;
                        break;
                case 2: limit = G_MAXUINT16;
                        break;
                case 3: limit = 0x00ffffffL;
                        break;
                case 4: limit = G_MAXUINT32;
                        break;
                case 8: limit = G_MAXUINT64;
                        break;
        }
        g_return_if_fail(value <= limit);
        self->_value = value;
}

FSTATIC guint64
_intframe_getint(IntFrame * self)
{
        return self->_value;
}

FSTATIC void
_intframe_updatedata(Frame* fself,              
                     gpointer tlvptr,           
                     gconstpointer pktend,      
                     FrameSet* fs)              
{
        IntFrame* self = CASTTOCLASS(IntFrame, fself);
        // NOTE - this gets rid of the "const" coming out of get_generic_tlv_value...
        void * pktpos = GINT_TO_POINTER(GPOINTER_TO_INT(get_generic_tlv_value(tlvptr, pktend)));
        (void)fs;
        g_return_if_fail(NULL != pktpos);

        switch (self->baseclass.length) {
                case 1: tlv_set_guint8(pktpos, (guint8)self->_value, pktend);
                        break;
                case 2: tlv_set_guint16(pktpos, (guint16)self->_value, pktend);
                        break;
                case 3: tlv_set_guint24(pktpos, (guint32)self->_value, pktend);
                        break;
                case 4: tlv_set_guint32(pktpos, (guint32)self->_value, pktend);
                        break;
                case 8: tlv_set_guint64(pktpos, (guint64)self->_value, pktend);
                        break;
                default:g_return_if_reached();
                        break;
        }
}

FSTATIC gboolean
_intframe_isvalid(const Frame* self,                    
                  gconstpointer tlvptr,         
                  gconstpointer pktend)         
{
        int     length = self->length;
        if (tlvptr != NULL) {
                int     tlvlen = get_generic_tlv_len(tlvptr, pktend);
                if (length != tlvlen) {
                        return FALSE;
                }
        }
        switch (self->length) {
                case 1: case 2: case 3: case 4: case 8:
                return TRUE;
        }
        return FALSE;
}

FSTATIC gchar*
_intframe_toString(gconstpointer obj)
{
        const IntFrame* self = CASTTOCONSTCLASS(IntFrame, obj);
        return g_strdup_printf("IntFrame(%d, %d, "FMT_64BIT"d)"
        ,       self->baseclass.type, self->baseclass.length, self->_value);
}

IntFrame*
intframe_new(guint16 frametype, 
             int intbytes)      
{
        Frame*  frame;
        IntFrame*       iframe;
        if (intbytes != 1 && intbytes != 2 && intbytes != 3 && intbytes != 4 && intbytes != 8) {
                return NULL;
        }
        frame = frame_new(frametype, sizeof(IntFrame));
        proj_class_register_subclassed(frame, "IntFrame");
        iframe = CASTTOCLASS(IntFrame, frame);
        iframe->baseclass.length = intbytes;
        iframe->intlength = _intframe_intlength;
        iframe->setint = _intframe_setint;
        iframe->getint = _intframe_getint;
        iframe->baseclass.updatedata = _intframe_updatedata;
        iframe->baseclass.isvalid = _intframe_isvalid;
        iframe->baseclass.value = NULL;
        iframe->baseclass.setvalue = NULL;
        iframe->baseclass.valuefinalize = NULL;
        iframe->baseclass.length = intbytes;
        iframe->baseclass.baseclass.toString = _intframe_toString;
        return iframe;
}
Frame*
intframe_tlvconstructor(gconstpointer tlvstart, 
                        gconstpointer pktend)   
{
        guint16         frametype = get_generic_tlv_type(tlvstart, pktend);
        guint16         framelength = get_generic_tlv_len(tlvstart, pktend);
        const guint8*   framevalue = get_generic_tlv_value(tlvstart, pktend);
        IntFrame *      ret = intframe_new(frametype, framelength);
        guint64         intvalue = G_MAXUINT64;
        g_return_val_if_fail(ret != NULL, NULL);

        ret->baseclass.length = framelength;
        switch (ret->baseclass.length) {
                case 1:
                        intvalue = tlv_get_guint8(framevalue, pktend);
                        break;
                case 2:
                        intvalue = tlv_get_guint16(framevalue, pktend);
                        break;
                case 3:
                        intvalue = tlv_get_guint24(framevalue, pktend);
                        break;
                case 4:
                        intvalue = tlv_get_guint32(framevalue, pktend);
                        break;
                case 8:
                        intvalue = tlv_get_guint64(framevalue, pktend);
                        break;
        }
        ret->setint(ret, intvalue);
        return CASTTOCLASS(Frame, ret);
}