frame.c

Go to the documentation of this file.

#include <frame.h>
#include <generic_tlv_min.h>
#include <memory.h>

FSTATIC void _frame_default_finalize(AssimObj * self);
FSTATIC gsize _frame_total_size(Frame* f);
FSTATIC gboolean _frame_default_isvalid(const Frame *, gconstpointer,   gconstpointer);
FSTATIC void _frame_setvalue(Frame *, gpointer, guint16, GDestroyNotify valnotify);
FSTATIC void _frame_updatedata(Frame *, gpointer, gconstpointer, FrameSet*);
FSTATIC void _frame_dump(const Frame *, const char * prefix);

DEBUGDECLARATIONS


FSTATIC void
_frame_default_finalize(AssimObj * obj) 
{
        Frame*  self = CASTTOCLASS(Frame, obj);
        DEBUGMSG5("%s: Finalizing Frame at 0x%p", __FUNCTION__, self);
        if (self->value && self->valuefinalize) {
                self->valuefinalize(self->value);
        }
        memset(self, 0x00, sizeof(Frame));
        _assimobj_finalize(obj);
}
FSTATIC void
frame_default_valuefinalize(gpointer value) 
{
        if (value) {
                DEBUGMSG4("%s: freeing Frame value at 0x%p", __FUNCTION__, value);
                FREE(value);
        }
}

FSTATIC gsize
_frame_total_size(Frame* f)     
{
        g_return_val_if_fail(f != NULL, 0);
        return (gsize)(FRAME_INITSIZE + f->length);
}

FSTATIC gboolean
_frame_default_isvalid(const Frame * self,              
                       gconstpointer tlvptr,    
                       gconstpointer pktend)    
{
        (void)self;
        (void)tlvptr;
        (void)pktend;
        return TRUE;
}

FSTATIC void
_frame_setvalue(Frame * self,                   
                gpointer value,                 
                guint16 length,                 
                GDestroyNotify valnotify)       
{
        if (self->value && self->valuefinalize) {
                self->valuefinalize(self);
        }
        self->value = value;
        self->length = length;
        self->valuefinalize = valnotify;
}

FSTATIC void
_frame_updatedata(Frame * self,                 
                  gpointer tlvptr,              
                  gconstpointer pktend,         
                  FrameSet* fs)                 
{
        (void)fs;
        // set_generic_tlv_value does pretty exhaustive error checking.
        set_generic_tlv_value(tlvptr, self->value, self->length, pktend);
}

Frame*
frame_new(guint16 frame_type,   
          gsize framesize)      
{
        AssimObj * newobj;
        Frame * newframe = NULL;

        BINDDEBUG(Frame);
        if (framesize < sizeof(Frame)) {
                framesize = sizeof(Frame);
        }
        newobj   = assimobj_new(framesize);
        if (framesize == sizeof(Frame)) {
                DEBUGMSG5("%s: Constructing New Frame at 0x%p", __FUNCTION__, newobj);
        }
        if (newobj != NULL) {
                newframe = NEWSUBCLASS(Frame, newobj);
                newobj->_finalize       = _frame_default_finalize;
                newframe->type          = frame_type;
                newframe->length        = 0;
                newframe->value         = NULL;
                newframe->dataspace     = _frame_total_size;
                newframe->isvalid       = _frame_default_isvalid;
                newframe->setvalue      = _frame_setvalue;
                newframe->updatedata    = _frame_updatedata;
                newframe->dump          = _frame_dump;
                newframe->valuefinalize = NULL;
        }
        return newframe;
}
Frame*
frame_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);
        Frame *         ret = frame_new(frametype, 0);
        g_return_val_if_fail(ret != NULL, NULL);

        ret->length = framelength;
        ret->setvalue(ret, g_memdup(framevalue, framelength), framelength, frame_default_valuefinalize);
        return ret;
}
void
_frame_dump(const Frame * f,                    
            const char * prefix)                
{
        g_debug("%s%s: type = %d, length = %d", 
                prefix,
                proj_class_classname(f),
                f->type,
                f->length);
}