generic_tlv_min.c

Go to the documentation of this file.

#include <stdio.h>
#include <string.h>
#include <tlvhelper.h>
#include <frametypes.h>
#include <generic_tlv_min.h>


#define GENERICTLV_HDRSZ        (sizeof(guint16)+sizeof(guint16))

guint16
get_generic_tlv_type(gconstpointer tlv_vp,  
                 gconstpointer pktend)  
{
        return tlv_get_guint16(tlv_vp, pktend);
}

void
set_generic_tlv_type(gpointer tlv_vp,   
                 guint16 newtype,               
                 gconstpointer pktend)          
{
        tlv_set_guint16(tlv_vp, newtype, pktend);
}

guint16
get_generic_tlv_len(gconstpointer tlv_vp,       
                gconstpointer pktend)   
{
        const guint8 * tlvp = tlv_vp;
        return tlv_get_guint16(tlvp+sizeof(guint16), pktend);
}

void
set_generic_tlv_len(gpointer tlv_vp,    
                 guint16 newsize,               
                 gconstpointer pktend)          
{
        guint8 * tlvp = tlv_vp;
        tlv_set_guint16(tlvp+sizeof(guint16), newsize, pktend);
}

gconstpointer
get_generic_tlv_value(gconstpointer tlv_vp,     
                 gconstpointer pktend)          
{
        const guint8*   tlvbytes = tlv_vp;
        (void)pktend;
        return (tlvbytes + GENERICTLV_HDRSZ);
}

gpointer
get_generic_tlv_nonconst_value(gpointer tlv_vp, 
                 gconstpointer pktend)          
{
        guint8* tlvbytes = tlv_vp;
        (void)pktend;
        return (tlvbytes + GENERICTLV_HDRSZ);
}

void
set_generic_tlv_value(gpointer tlv_vp,          
                      void* srcdata,            
                      guint16 srcsize,          
                      gconstpointer pktend)     
{
        guint8*         tlvbytes = tlv_vp;
        g_return_if_fail((gpointer)(tlvbytes+srcsize) <= pktend);
        g_return_if_fail(srcsize == get_generic_tlv_len(tlv_vp, pktend));
        memcpy(tlvbytes + GENERICTLV_HDRSZ, srcdata, srcsize);
}

gboolean
is_valid_generic_tlv_packet(gconstpointer tlv_vp,       //<[in] pointer to beginning of generic TLV packet
                     gconstpointer pktend)      //<[in] pointer to first byte past the end of the packet
{
        const guint16   reqtypes [] = {FRAMETYPE_SIG};
        unsigned        j = 0;
        int             lasttype = -1;
        if (NULL == tlv_vp || ((const guint8*)tlv_vp+GENERICTLV_HDRSZ)  > (const guint8*)pktend) {
                fprintf(stderr, "TLV Invalid because packet is too short\n");
                return FALSE;
        }
        for (tlv_vp = get_generic_tlv_first(tlv_vp, pktend)
        ;       NULL != tlv_vp
        ;       tlv_vp = get_generic_tlv_next(tlv_vp, pktend)) {

                guint16         ttype;
                guint16         length;
                const guint8*   next;

                if (tlv_vp >= pktend) {
                        return FALSE;
                }
                ttype = get_generic_tlv_type(tlv_vp, pktend);
                lasttype = ttype;
                length = get_generic_tlv_len(tlv_vp, pktend);
                next = (const guint8*)tlv_vp + (length+GENERICTLV_HDRSZ);
                if (next > (const guint8*) pktend) {
                        fprintf(stderr, "TLV Invalid because TLV entry extends past end\n");
                        return FALSE;
                }
                if (ttype == FRAMETYPE_END) {
                        if (get_generic_tlv_value(tlv_vp, pktend) == pktend) {
                                return length == 0;
                        }else{
                                fprintf(stderr, "TLV Invalid because END item isn't at end of packet\n");
                                return FALSE;
                        }
                }
                if (j < DIMOF(reqtypes) && ttype != reqtypes[j]) {
                        fprintf(stderr, "TLV Invalid because required TLV types aren't present in right order\n");
                        return FALSE;
                }
                j += 1;
        }
        if (lasttype != FRAMETYPE_END) {
                fprintf(stderr, "TLV Invalid because final type wasn't FRAMETYPE_END (it was %d)\n"
                ,       lasttype);
                return FALSE;
        }
        return TRUE;
}

gconstpointer
get_generic_tlv_first(gconstpointer packet,     
                      gconstpointer pktend)     
{
        const guint8*   inittlv = packet;
        if (packet == NULL
        ||      (inittlv + GENERICTLV_HDRSZ) > (const guint8*)pktend
        ||      (inittlv + GENERICTLV_HDRSZ + get_generic_tlv_len(inittlv, pktend)) > (const guint8*)pktend) {
                return NULL;
        }
        return inittlv;
}

gconstpointer
get_generic_tlv_next(gconstpointer tlv_vp,              
                  gconstpointer pktend) 
{
        const guint8*   nexttlv;
        const guint8*   nextend;
        if (tlv_vp == NULL
        ||  ((const guint8*)tlv_vp+GENERICTLV_HDRSZ) > (const guint8*)pktend
        ||  get_generic_tlv_type(tlv_vp, pktend) == FRAMETYPE_END) {
                return NULL;
        }
        nexttlv = (const guint8*)tlv_vp  + GENERICTLV_HDRSZ + get_generic_tlv_len(tlv_vp, pktend);
        /* Watch out for malformed packets! (BLACKHAT, PARANOIA) */
        nextend = nexttlv + GENERICTLV_HDRSZ + get_generic_tlv_len(nexttlv, pktend);
        /* fprintf(stderr, "LOOK: cur:%p, next: %p, nextend: %p, vpend: %p\n"
        ,       tlv_vp, nexttlv, nextend, pktend); */
        return nextend > (const guint8*)pktend ? NULL : nexttlv;
}

gconstpointer
find_next_generic_tlv_type(gconstpointer tlv_vp,
                       guint16 tlvtype,         
                       gconstpointer pktend)    
{
        while (NULL != tlv_vp && ((const guint8*)tlv_vp+GENERICTLV_HDRSZ) <= (const guint8*)pktend) {
                if (get_generic_tlv_type(tlv_vp, pktend) == tlvtype) {
                        return tlv_vp;
                }
                tlv_vp = get_generic_tlv_next(tlv_vp, pktend);
        }
        return NULL;
}