nvpairframe.c

Go to the documentation of this file.

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


#if defined(_MSC_VER) && _MSC_VER < 1400
// Probably should be defined in some other file - for the case the system doesn't supply it.
gsize
strnlen(char*  str, size_t  maxlen)
{
        char*  p = memchr(str, '\0', maxlen);
 
        if (p == NULL) {
                return maxlen;
        }
        return (p - str);
}
#endif


FSTATIC gboolean _nvpairframe_default_isvalid(const Frame *, gconstpointer, gconstpointer);


gboolean
_nvpairframe_default_isvalid(const Frame * self,        
                              gconstpointer tlvptr,     
                              gconstpointer pktend)     
{
        const NVpairFrame*      nvself;
        gsize                   length;
        const guint8*           namestart;
        const guint8*           valuestart;
        const guint8*           valueendplace;
        const guint8*           valuexpectedplace;

        nvself = CASTTOCONSTCLASS(NVpairFrame, self);
        if (tlvptr == NULL) {
                if (nvself->value == NULL || nvself->name == NULL) {
                        return FALSE;
                }
                return (strnlen(nvself->name, self->length) + strnlen(nvself->value, self->length))
                == (gsize)(self->length-2);
        }
        length = get_generic_tlv_len(tlvptr, pktend);
        namestart = get_generic_tlv_value(tlvptr, pktend);
        valuestart = memchr(namestart, 0x00, length-2);
        if (valuestart == NULL) {
                return FALSE;
        }
        valuestart++;
        g_return_val_if_fail(NULL != tlvptr, FALSE);
        g_return_val_if_fail(NULL != pktend, FALSE);
        g_return_val_if_fail(length > 0,  FALSE);
        g_return_val_if_fail(valuestart < namestart+1, FALSE);

        valueendplace = namestart + length;
        valuexpectedplace = valueendplace-1;
        return valuexpectedplace == memchr(valuestart, 0x00, 1+(valueendplace-valuestart));
}


NVpairFrame*
nvpairframe_new(guint16 frame_type,     
                gchar*  name,           
                gchar*  value,          
                gsize framesize)        
{
        Frame*          baseframe;
        NVpairFrame*    self;

        if (framesize < sizeof(NVpairFrame)){
                framesize = sizeof(NVpairFrame);
        }

        if (name != NULL) {
                g_return_val_if_fail(value != NULL, NULL);
                g_return_val_if_fail(name[0] != '\0', NULL);
        }
        baseframe = frame_new(frame_type, framesize);
        baseframe->isvalid = _nvpairframe_default_isvalid;
        if (name != NULL) {
                name = g_strdup(name);
                value = g_strdup(value);
                baseframe->length = strlen(name) + strlen(value) + 2;
        }
        proj_class_register_subclassed (baseframe, "NVpairFrame");

        self =  CASTTOCLASS(NVpairFrame, baseframe);
        self->name = name;
        self->value = value;
        return self;
}
WINEXPORT Frame*
nvpairframe_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);
        NVpairFrame *   ret = nvpairframe_new(frametype, NULL, NULL, 0);
        Frame *         fret = CASTTOCLASS(Frame, ret);
        g_return_val_if_fail(ret != NULL, NULL);

        ret->baseclass.length = framelength;
        ret->baseclass.setvalue(fret, g_memdup(framevalue, framelength), framelength, frame_default_valuefinalize);
        return fret;
}