seqnoframe.c

Go to the documentation of this file.

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

FSTATIC void _seqnoframe_setreqid(SeqnoFrame * self, guint64 value);
FSTATIC guint64 _seqnoframe_getreqid(SeqnoFrame * self);
FSTATIC void _seqnoframe_setqid(SeqnoFrame * self, guint16 value);
FSTATIC guint16 _seqnoframe_getqid(SeqnoFrame * self);
FSTATIC void _seqnoframe_updatedata(Frame*, gpointer, gconstpointer, FrameSet*);
FSTATIC gboolean _seqnoframe_isvalid(const Frame*, gconstpointer, gconstpointer);
FSTATIC gboolean _seqnoframe_equal(SeqnoFrame * self, SeqnoFrame* rhs);
FSTATIC int _seqnoframe_compare(SeqnoFrame * self, SeqnoFrame* rhs);
FSTATIC guint32 _seqnoframe_getsessionid(SeqnoFrame * self);
FSTATIC void _seqnoframe_initsessionid(void);
FSTATIC char * _seqnoframe_toString(gconstpointer vself);

static guint32 _sessionId = 0;







FSTATIC void
_seqnoframe_initsessionid(void)
{
#       define          FIVESECONDS     5000000
        guint64 now     = g_get_real_time();
        now /= FIVESECONDS;
        _sessionId = (guint32)now;
}

FSTATIC void
_seqnoframe_setreqid(SeqnoFrame * self, guint64 value)
{
        self->_reqid = value;
}

FSTATIC void
_seqnoframe_setqid(SeqnoFrame * self, guint16 value)
{
        self->_qid = value;
}

FSTATIC guint64
_seqnoframe_getreqid(SeqnoFrame * self)
{
        return self->_reqid;
}
FSTATIC guint16
_seqnoframe_getqid(SeqnoFrame * self)
{
        return self->_qid;
}
FSTATIC guint32
_seqnoframe_getsessionid(SeqnoFrame * self)
{
        return self->_sessionid;
}

FSTATIC gboolean
_seqnoframe_equal(SeqnoFrame * self, SeqnoFrame* rhs)
{
        if (self->_qid != rhs->_qid) {
                return FALSE;
        }
        return self->compare(self, rhs) == 0;
}
FSTATIC int
_seqnoframe_compare(SeqnoFrame * self, SeqnoFrame* rhs)
{
        if (self->getsessionid(self) == self->getsessionid(rhs)) {
                if (self->getreqid(self) < rhs->getreqid(rhs)) {
                        return -1;
                }
                if (self->getreqid(self) > rhs->getreqid(rhs)) {
                        return 1;
                }
                return 0;
        }
                
        if (self->getsessionid(self) < rhs->getsessionid(rhs)) {
                return -1;
        }
        return 1;
}



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

        tlv_set_guint32(pktpos,                                self->_sessionid, pktend);
        tlv_set_guint64(pktpos+sizeof(guint32),                self->_reqid, pktend);
        tlv_set_guint16(pktpos+sizeof(guint32)+sizeof(guint64),self->_qid, pktend);
}
Frame*
seqnoframe_tlvconstructor(gconstpointer tlvstart,       
                          gconstpointer pktend)         
{
        SeqnoFrame*     ret;
        guint16         length  = get_generic_tlv_len(tlvstart, pktend);
        guint16         tlvtype = get_generic_tlv_type(tlvstart, pktend);
        const guint8* valpos = get_generic_tlv_value(tlvstart, pktend);

        g_return_val_if_fail(length == (sizeof(guint64)+sizeof(guint16)+sizeof(guint32)), NULL);

        ret = seqnoframe_new(tlvtype, 0);
        ret->_sessionid = tlv_get_guint32(valpos, pktend);
        ret->setreqid(ret, tlv_get_guint64(valpos+sizeof(guint32), pktend));
        ret->setqid(ret, tlv_get_guint16(valpos+sizeof(guint32)+sizeof(guint64), pktend));
        return CASTTOCLASS(Frame, ret);
}

FSTATIC gboolean
_seqnoframe_isvalid(const Frame* self,          
                  gconstpointer tlvptr,         
                  gconstpointer pktend)         
{
        (void)tlvptr;
        (void)pktend;
        return self->length == (sizeof(guint32)+sizeof(guint64)+sizeof(guint16));
}


SeqnoFrame*
seqnoframe_new(guint16 frametype,       
             int objsize)               
{
        Frame*  frame;
        SeqnoFrame*     sframe;

        if (objsize < ((gssize)sizeof(SeqnoFrame))) {
                objsize = sizeof(SeqnoFrame);
        }

        frame = frame_new(frametype, objsize);
        sframe = NEWSUBCLASS(SeqnoFrame, frame);
        if (_sessionId == 0) {
                _seqnoframe_initsessionid();
        }
        sframe->getreqid = _seqnoframe_getreqid;
        sframe->setreqid = _seqnoframe_setreqid;
        sframe->getqid = _seqnoframe_getqid;
        sframe->setqid = _seqnoframe_setqid;
        sframe->getsessionid = _seqnoframe_getsessionid;
        sframe->equal = _seqnoframe_equal;
        sframe->compare = _seqnoframe_compare;

        // Base class member functions
        sframe->baseclass.baseclass.toString = _seqnoframe_toString;
        sframe->baseclass.updatedata = _seqnoframe_updatedata;
        sframe->baseclass.isvalid = _seqnoframe_isvalid;
        sframe->baseclass.value = NULL;
        sframe->baseclass.setvalue = NULL;
        sframe->baseclass.valuefinalize = NULL;
        sframe->baseclass.length = sizeof(guint32)+sizeof(guint64)+sizeof(guint16);

        // Subclass (i.e., SeqnoFrame) data
        sframe->_sessionid = _sessionId;
        sframe->_reqid = 0;
        sframe->_qid = 0;
        return sframe;
}
SeqnoFrame*
seqnoframe_new_init(guint16 frametype,  
                    guint64 reqid,      
                    guint16 qid)        
{
        SeqnoFrame*     ret = seqnoframe_new(frametype, 0);
        if (ret) {
                ret->setreqid(ret, reqid);
                ret->setqid(ret, qid);
        }
        return ret;
}

FSTATIC char *
_seqnoframe_toString(gconstpointer vself)
{
        const SeqnoFrame*       self = CASTTOCONSTCLASS(SeqnoFrame, vself);
        return g_strdup_printf("SeqnoFrame(type=%d, (%d,%d,"FMT_64BIT"d))", self->baseclass.type, self->_sessionid
        ,       self->_qid, self->_reqid);
}