frameset.c

Go to the documentation of this file.

#include <string.h>
#include <projectcommon.h>
#include <frameset.h>
#include <frametypes.h>
#include <generic_tlv_min.h>
#include <tlvhelper.h>
FSTATIC void _frameset_indir_finalize(void* f);
FSTATIC void _frameset_finalize(AssimObj* self);
FSTATIC char * _frameset_toString(gconstpointer);

DEBUGDECLARATIONS


FSTATIC SeqnoFrame* _frameset_getseqno(FrameSet* self);

FSTATIC void
_frameset_indir_finalize(void* f)       
{
        Frame*  frame = CASTTOCLASS(Frame, f);
        UNREF(frame);
}

FSTATIC void
_frameset_finalize(AssimObj* obj)       
{
        FrameSet* fs = CASTTOCLASS(FrameSet, obj);
        g_return_if_fail(NULL != fs);
        if (fs->framelist) {
                // Would rather use g_slist_free_full() - but it's too new to be widely deployed...
                while (NULL != fs->framelist) {
                        _frameset_indir_finalize(fs->framelist->data);
                        fs->framelist->data = NULL;
                        fs->framelist = g_slist_delete_link(fs->framelist, fs->framelist);
                }
        }
        if (fs->packet) {
                FREE(fs->packet);
                fs->packet = NULL;
                fs->pktend = NULL;
        }
        memset(fs, 0x0, sizeof(*fs));
        FREECLASSOBJ(fs);
}



FrameSet*
frameset_new(guint16 frameset_type) 
{
        AssimObj*       obj = assimobj_new(sizeof(FrameSet));
        FrameSet*       s = NEWSUBCLASS(FrameSet, obj);

        BINDDEBUG(FrameSet);
        g_return_val_if_fail(s != NULL, NULL);
        s->fstype = frameset_type;
        s->framelist = NULL;
        s->packet = NULL;
        s->pktend = NULL;
        s->fsflags = 0;
        s->baseclass._finalize = _frameset_finalize;
        s->baseclass.toString = _frameset_toString;
        s->getseqno = _frameset_getseqno;
        return s;
}

void
frameset_prepend_frame(FrameSet* fs,    
                       Frame* f)        
{
        g_return_if_fail(NULL != fs && NULL != f);
        REF(f);
        fs->framelist = g_slist_prepend(fs->framelist, f);
}

void
frameset_append_frame(FrameSet* fs,     
                      Frame* f)         
{
        g_return_if_fail(NULL != fs && NULL != f);
        REF(f);
        fs->framelist = g_slist_append(fs->framelist, f);
}

void
frameset_construct_packet(FrameSet* fs,         
                          SignFrame* sigframe,  
                          Frame* cryptframe,    

                          Frame* compressframe) 


{
        GSList*         curframe;               // Current frame as we marshall packet...
        gpointer        curpktpos;              // Current position as we marshall packet...
        gsize           pktsize;
        gsize           fssize = 6;             // "frameset" overhead size
        g_return_if_fail(NULL != fs);
        g_return_if_fail(NULL != sigframe);
        // g_return_if_fail(NULL != fs->framelist); // Is an empty frame list OK?

        /*
         * The general method we employ here is to:
         * 1. Free the current packet, if any
         * 2. Remove current Framelist signature, compression, and encryption frames (if any).
         * 3. Prepend a compression Frame if compm != NULL
         * 4. Prepend an encryption Frame if cryptm != NULL
         * 5. Prepend a signature Frame (sigm may not be NULL).
         * 6. Figure out how much space we think we need to malloc for the packet using Frames.
         * 7. Malloc enough space.
         * 8. Populate all the frames into this new packet in reverse order.
         */

        // Free current packet, if any...
        if (fs->packet) {
                FREE(fs->packet);
                fs->packet = NULL;
                fs->pktend = NULL;
        }
        // Remove any current signature, compression, or encryption frames...
        // (this method only works if they're first, and all together - but that's OK)
        while (fs->framelist) {
                Frame*  item = CASTTOCLASS(Frame, fs->framelist->data);
                g_return_if_fail(NULL != item);
                switch (item->type) {
                        case FRAMETYPE_SIG:
                        case FRAMETYPE_CRYPT:
                        case FRAMETYPE_COMPRESS:
                                UNREF(item);
                                fs->framelist->data = NULL;
                                fs->framelist = g_slist_delete_link(fs->framelist, fs->framelist);
                                continue;
                }
                break;
        }
        if (NULL != compressframe) {
                frameset_prepend_frame(fs, compressframe);
        }
        if (NULL != cryptframe) {
                frameset_prepend_frame(fs, cryptframe);
        }
        // "sigframe" cannot be NULL (see check above)
        frameset_prepend_frame(fs, CASTTOCLASS(Frame, sigframe));

        // Reverse list...
        fs->framelist = g_slist_reverse(fs->framelist);

        // Add "end" frame to the "end" - if not already present...
        if (CASTTOCLASS(Frame, fs->framelist->data)->type != FRAMETYPE_END) {
                Frame* endframe = frame_new(FRAMETYPE_END, 0);
                g_return_if_fail(NULL != endframe);
                frameset_prepend_frame(fs, endframe);
                UNREF(endframe);
        }

        pktsize = fssize;
        for (curframe=fs->framelist; curframe != NULL; curframe = g_slist_next(curframe)) {
                Frame* frame = CASTTOCLASS(Frame, curframe->data);
                pktsize += frame->dataspace(frame);
        }
        fs->packet = MALLOC0(pktsize);
        fs->pktend = ((guint8*)fs->packet + pktsize);
        g_return_if_fail(fs->packet != NULL);

        curpktpos = fs->pktend;

        // Marshall out all our data - in reverse order...
        for (curframe=fs->framelist; curframe != NULL; curframe = g_slist_next(curframe)) {
                Frame* frame = CASTTOCLASS(Frame, curframe->data);
        
                curpktpos = ((guint8*)curpktpos) - frame->dataspace(frame);
                g_return_if_fail(curpktpos >= fs->packet);
                set_generic_tlv_type(curpktpos, frame->type, fs->pktend);
                set_generic_tlv_len(curpktpos, frame->length, fs->pktend);
                frame->updatedata(frame, curpktpos, fs->pktend, fs);
                if (!frame->isvalid(frame, curpktpos, fs->pktend)) {
                        g_error("Generated %s frame is not valid(!)"
                        , proj_class_classname(frame));
                }
        }
        g_return_if_fail(curpktpos == (((guint8*)fs->packet)+fssize));
        // Reverse list - putting it back in the right order
        fs->framelist = g_slist_reverse(fs->framelist);
        // Write out the initial FrameSet header.
        set_generic_tlv_type(fs->packet, fs->fstype, ((guint8*)fs->packet)+fssize);
        set_generic_tlv_len(fs->packet, pktsize-fssize, ((guint8*)fs->packet)+fssize);
        tlv_set_guint16(((guint8*)fs->packet)+4, fs->fsflags, ((guint8*)fs->packet)+fssize);
}

guint16
frameset_get_flags(FrameSet* fs)        
{
        g_return_val_if_fail(NULL != fs, 0xffff);
        return fs->fsflags;
}

guint16
frameset_set_flags(FrameSet* fs,        
                   guint16 flagbits)    
{
        g_return_val_if_fail(NULL != fs, 0xffff);
        fs->fsflags |= flagbits;
        return fs->fsflags;
}

guint16
frameset_clear_flags(FrameSet* fs,      
                     guint16 flagbits)  
{
        g_return_val_if_fail(NULL != fs, 0xffff);
        g_return_val_if_fail(flagbits != 0x0000, fs->fsflags);
        fs->fsflags &= ~flagbits;
        return fs->fsflags;
}

gpointer
frame_append_to_frameset_packet(FrameSet* fs,           
                                Frame* f,               
                                gpointer curpktpos)     
{
        guint8 *        curpos = curpktpos;
        guint8 *        endpos = fs->pktend;

        g_return_val_if_fail(fs != NULL && f != NULL && fs->packet != NULL && curpktpos != NULL, NULL);
        g_return_val_if_fail((curpos + f->dataspace(f)) <= endpos, NULL);

        tlv_set_guint16(curpos, f->type, fs->pktend);
        curpos += 2; // sizeof(guint16)
        tlv_set_guint16(curpos, f->length, fs->pktend);
        curpos += 2; // sizeof(guint16)
        if (f->length > 0) {
                // Zero-length frames are just fine.
                memcpy(curpos, f->value, f->length);
        }
        curpos += f->length;
        return (gpointer)curpos;
}

void
frameset_dump(const FrameSet* fs)       
{
        GSList* curframe;
        g_debug("BEGIN Dumping FrameSet:");
        for (curframe=fs->framelist; curframe != NULL; curframe = g_slist_next(curframe)) {
                Frame* frame = CASTTOCLASS(Frame, curframe->data);
                frame->dump(frame, ".... ");
        }
        g_debug("END FrameSet dump");
}

FSTATIC SeqnoFrame*
_frameset_getseqno(FrameSet* self)
{
        GSList* curframe;
        if (self->_seqframe) {
                return self->_seqframe;
        }
        for (curframe=self->framelist; curframe != NULL; curframe = g_slist_next(curframe)) {
                Frame* frame = CASTTOCLASS(Frame, curframe->data);
                DEBUGMSG4("%s: LOOKING AT FRAME TYPE %d (but want sequence number)", __FUNCTION__, frame->type);
                if (frame->type == FRAMETYPE_REQID) {
                        self->_seqframe = CASTTOCLASS(SeqnoFrame, frame);
                        return self->_seqframe;
                }
        }
        return NULL;
}

FSTATIC char *
_frameset_toString(gconstpointer vself)
{
        GString*        gsret = NULL;
        char*           ret = NULL;
        const FrameSet* self = CASTTOCONSTCLASS(FrameSet, vself);
        GSList*         curframe;
        const char *    comma = "";

        g_return_val_if_fail(self != NULL, NULL);
        gsret = g_string_new("");
        g_string_append_printf(gsret, "FrameSet(fstype=%d, [", self->fstype);

        for (curframe=self->framelist; curframe != NULL; curframe = g_slist_next(curframe)) {
                Frame*  frame = CASTTOCLASS(Frame, curframe->data);
                char*   fstr;
                g_return_val_if_fail(frame != NULL, NULL);
                fstr = frame->baseclass.toString(&frame->baseclass);
                g_string_append_printf(gsret, "%s[%s]", comma, fstr);
                comma = ", ";
                g_free(fstr); fstr = NULL;
        }
        g_string_append_printf(gsret, "])");
        ret = gsret->str;
        g_string_free(gsret, FALSE);
        return ret;
}