cdp_min.c

Go to the documentation of this file.

#include <stdio.h>

#ifdef _MSC_VER
#       include <winsock.h>
#else
#       include <netinet/in.h>
#endif

#include <cdp.h>
#include <tlvhelper.h>

#define         CDP_OVERHEAD            22

#define         CDP_VERSSZ              1

#define         CDP_TTLSZ               1

#define         CDP_CKSUMSZ             2

#define         CDPINITHDRSZ            (CDP_OVERHEAD+CDP_VERSSZ+CDP_TTLSZ+CDP_CKSUMSZ) /* 26 */



#define         CDPTLV_TYPESZ           2

#define         CDPTLV_LENSZ            2

#define         CDPTLV_TYPELENSZ        (CDPTLV_TYPESZ+CDPTLV_LENSZ) /* 4 */



WINEXPORT gboolean
is_valid_cdp_packet(const void* packet,         
                    const void* pktend) 
{
        const unsigned  reqtypes [] = {1};      // The set of required initial TLV types
                                                // The LLDP list is slighly more impressive ;-)
        unsigned        j = 0;
        const void*     tlv_vp;                 // Pointer to a TLV entry in the CDP packet.
        const void*     next = NULL;
        unsigned        vers;


        if ((const void *)((const unsigned char *)packet+CDPTLV_TYPELENSZ)  > pktend || packet == NULL) {
                fprintf(stderr, "BAD1 packet: %p,  pktend: %p\n", packet, pktend);
                return FALSE;
        }
        /* Heuristic - at this writing, version could be 1 or 2 - Cisco currently defaults to 2 ... */
        if ((vers=get_cdp_vers(packet, pktend)) < 1 || vers > 4
        ||  get_cdp_ttl(packet, pktend) < 3) {
                /*fprintf(stderr, "BAD2 packet: %p,  pktend: %p\n", packet, pktend);*/
                return FALSE;
        }

        for (tlv_vp = get_cdptlv_first(packet, pktend)
        ;    NULL != tlv_vp && tlv_vp < pktend
        ;    tlv_vp = next) {
                unsigned        ttype;
                unsigned        length;

                if ((const void *)((const unsigned char *)tlv_vp+CDPTLV_TYPELENSZ) > pktend) {
                        return FALSE;
                }
                ttype  = get_cdptlv_type(tlv_vp, pktend);
                length = get_cdptlv_len (tlv_vp, pktend);
                next = (const void *)((const unsigned char *)tlv_vp + length);
                if (next > pktend
                ||      length < CDPTLV_TYPELENSZ
                ||      (j < DIMOF(reqtypes) && ttype != reqtypes[j])) {
                        /*fprintf(stderr, "BAD3 packet: %p,  pktend: %p\n", packet, pktend);*/
                        return FALSE;
                }
                j += 1;
        }
        // The only way to exit that loop without returning FALSE is if tlp_vp == pktend
        return TRUE;
}

WINEXPORT guint8
get_cdp_vers(const void* pktptr, 
             const void* pktend) 
{
        const unsigned char *   pkt_uc = pktptr;
        return tlv_get_guint8(pkt_uc+CDP_OVERHEAD, pktend);
}

WINEXPORT guint8
get_cdp_ttl(const void* pktptr, 
            const void* pktend) 
{
        const unsigned char *   pkt_uc = pktptr;
        return tlv_get_guint8(pkt_uc+CDP_OVERHEAD+1, pktend);
}
WINEXPORT guint16
get_cdp_cksum(const void* pktptr, 
              const void* pktend) 
{
        const unsigned char *   pkt_uc = pktptr;
        return tlv_get_guint16(pkt_uc+CDP_OVERHEAD+2, pktend);
}

WINEXPORT guint16
get_cdptlv_type(const void* tlv_vp,  

              const void* pktend)    
{
        return tlv_get_guint16(tlv_vp, pktend);
}

WINEXPORT gsize
get_cdptlv_len(const void* tlv_vp,   

               const void* pktend)    
{
        const unsigned char* tlv_uc = tlv_vp;
        return tlv_get_guint16(tlv_uc+2, pktend);
}
WINEXPORT gsize
get_cdptlv_vlen(const void* tlv_vp,  

                const void* pktend)  
{
        return (unsigned)(get_cdptlv_len(tlv_vp, pktend) - CDPTLV_TYPELENSZ);
}

WINEXPORT const void *
get_cdptlv_body(const void* tlv_vp,     

                const void* pktend)     
{
        g_return_val_if_fail(tlv_vp < pktend, NULL);
        return (const void*)((const unsigned char *)tlv_vp + CDPTLV_TYPELENSZ);
}
WINEXPORT const void *
get_cdptlv_first(const void* pkt,       
                 const void* pktend)    
{
        gsize                   len = (const char *)pktend - (const char *)pkt;
        const unsigned char*    ret = (const unsigned char*)pkt;
        unsigned                vers;
        if (ret == NULL || len < (CDPINITHDRSZ + CDPTLV_TYPELENSZ)
        /* Note that these version and ttl constraints are heuristics, not absolutes */
        ||  (vers=get_cdp_vers(ret, pktend)) < 1 || vers > 5
        ||  get_cdp_ttl(ret, pktend) < 2) {
                return NULL;
        }
        ret += CDPINITHDRSZ;
        if ((ret + get_cdptlv_len(ret, pktend)) > (const unsigned char *)pktend) {
                return NULL;
        }
        return (const void *)ret;
}
WINEXPORT const void *
get_cdptlv_next(const void* tlv_vp,     
                const void* tlv_vpend)  
{
        const unsigned char*    nexttlv;
        const unsigned char*    nextend;
        if (tlv_vp == NULL) {
                return NULL;
        }
        nexttlv = (const unsigned char*)tlv_vp  + get_cdptlv_len(tlv_vp, tlv_vpend);
        if ((const void *)(nexttlv + CDPTLV_TYPELENSZ) > tlv_vpend) {
                // In an ideal world nexttlv would exactly equal tlv_vpend...
                return NULL;
        }
        /* Watch out for malformed packets! (BLACKHAT, PARANOIA) */
        nextend = nexttlv + get_cdptlv_len(nexttlv, tlv_vpend);
        return ((const void *)nextend > tlv_vpend) ? NULL : nexttlv;
}


WINEXPORT const void*
get_cdp_chassis_id(gconstpointer packet,                
                   gssize*     idlength,        
                   gconstpointer pktend)                
{
        const void *    tlv_vp;
        for (tlv_vp=get_cdptlv_first(packet, pktend);
             tlv_vp != NULL;
             tlv_vp = get_cdptlv_next(tlv_vp, pktend)) {
                if (get_cdptlv_type(tlv_vp, pktend) == CDP_TLV_DEVID) {
                        *idlength = get_cdptlv_vlen(tlv_vp, pktend);
                        return get_cdptlv_body(tlv_vp, pktend);
                }
                tlv_vp = get_cdptlv_next(tlv_vp, pktend);
        }
        return NULL;
}


WINEXPORT const void*
get_cdp_port_id(gconstpointer packet,   
                gssize*     idlength,   
                gconstpointer pktend)   
{
        const void *    tlv_vp;
        for (tlv_vp=get_cdptlv_first(packet, pktend);
             tlv_vp != NULL;
             tlv_vp = get_cdptlv_next(tlv_vp, pktend)) {
                if (get_cdptlv_type(tlv_vp, pktend) == CDP_TLV_PORTID) {
                        *idlength = get_cdptlv_vlen(tlv_vp, pktend);
                        return get_cdptlv_body(tlv_vp, pktend);
                }
                tlv_vp = get_cdptlv_next(tlv_vp, pktend);
        }
        return NULL;
}