wtp_pdu.c File Reference

#include "gwlib/gwlib.h"
#include "wtp_pdu.h"
#include "wtp_pdu.def"

Go to the source code of this file.

Macros
#define	PDU(name, docstring, fields, is_valid)
#define	UINT(field, docstring, bits)   p->field = 0;
#define	UINTVAR(field, docstring)   p->field = 0;
#define	OCTSTR(field, docstring, lengthfield)   p->field = NULL;
#define	REST(field, docstring)   p->field = NULL;
#define	TYPE(bits, value)
#define	RESERVED(bits)
#define	TPI(confield)
#define	PDU(name, docstring, fields, is_valid)
#define	UINT(field, docstring, bits)
#define	UINTVAR(field, docstring)
#define	OCTSTR(field, docstring, lengthfield)   octstr_destroy(p->field);
#define	REST(field, docstring)   octstr_destroy(p->field);
#define	TYPE(bits, value)
#define	RESERVED(bits)
#define	TPI(confield)
#define	PDU(name, docstring, fields, is_valid)
#define	UINT(field, docstring, bits)   bitpos += (bits);
#define	UINTVAR(field, docstring)
#define	OCTSTR(field, docstring, lengthfield)
#define	REST(field, docstring)
#define	TYPE(bits, value)
#define	RESERVED(bits)   bitpos += (bits);
#define	TPI(confield)
#define	PDU(name, docstring, fields, is_valid)
#define	UINT(field, docstring, bits)
#define	UINTVAR(field, docstring)
#define	OCTSTR(field, docstring, lengthfield)
#define	REST(field, docstring)
#define	TYPE(bits, value)   bitpos += (bits);
#define	RESERVED(bits)   bitpos += (bits);
#define	TPI(confield)
#define	PDU(name, docstring, fields, is_valid)
#define	UINT(field, docstring, bits)
#define	UINTVAR(field, docstring)
#define	OCTSTR(field, docstring, lengthfield)   p->lengthfield = octstr_len(p->field);
#define	REST(field, docstring)
#define	TYPE(bits, value)
#define	RESERVED(bits)
#define	TPI(confield)   p->confield = pdu->options != NULL && gwlist_len(pdu->options) > 0;
#define	PDU(name, docstring, fields, is_valid)
#define	UINT(field, docstring, bits)
#define	UINTVAR(field, docstring)
#define	OCTSTR(field, docstring, lengthfield)
#define	REST(field, docstring)
#define	TYPE(bits, value)
#define	RESERVED(bits)   bitpos += (bits);
#define	TPI(confield)
#define	PDU(name, docstring, fields, is_valid)
#define	UINT(field, docstring, bits)   debug(dbg, 0, "%*s %s: %lu", level, "", docstring, p->field);
#define	UINTVAR(field, docstring)   debug(dbg, 0, "%*s %s: %lu", level, "", docstring, p->field);
#define	OCTSTR(field, docstring, lengthfield)
#define	REST(field, docstring)
#define	TYPE(bits, value)
#define	RESERVED(bits)
#define	TPI(confield)   dump_tpis(pdu->options, level);

Functions
WTP_PDU *	wtp_pdu_create (int type)
void	wtp_pdu_destroy (WTP_PDU *pdu)
void	wtp_tpi_destroy (WTP_TPI *p)
void	wtp_pdu_append_tpi (WTP_PDU *pdu, int type, Octstr *data)
static long	unpack_tpis (Octstr *data, long bitpos, WTP_PDU *pdu)
static long	pack_tpis (Octstr *data, long bitpos, List *tpis)
static void	dump_tpis (List *tpis, int level)
static int	wtp_pdu_type (Octstr *data)
WTP_PDU *	wtp_pdu_unpack (Octstr *data)
static void	fixup_length_fields (WTP_PDU *pdu)
Octstr *	wtp_pdu_pack (WTP_PDU *pdu)
void	wtp_pdu_dump (WTP_PDU *pdu, int level)

Macro Definition Documentation

OCTSTR [1/7]

#define OCTSTR	(		field,
			docstring,
			lengthfield
	)		p->field = NULL;

OCTSTR [2/7]

#define OCTSTR	(		field,
			docstring,
			lengthfield
	)		octstr_destroy(p->field);

OCTSTR [3/7]

#define OCTSTR	(		field,
			docstring,
			lengthfield
	)

OCTSTR [4/7]

#define OCTSTR	(		field,
			docstring,
			lengthfield
	)

Value:

gw_assert(bitpos % 8 == 0); \
    p->field = octstr_copy(data, bitpos / 8, p->lengthfield); \
    bitpos += 8 * p->lengthfield;

OCTSTR [5/7]

#define OCTSTR	(		field,
			docstring,
			lengthfield
	)		p->lengthfield = octstr_len(p->field);

OCTSTR [6/7]

#define OCTSTR	(		field,
			docstring,
			lengthfield
	)

Value:

gw_assert(bitpos % 8 == 0); \
    if (p->field != NULL) \
        octstr_append(data, p->field); \
    bitpos += 8 * octstr_len(p->field);

OCTSTR [7/7]

#define OCTSTR	(		field,
			docstring,
			lengthfield
	)

Value:

debug(dbg, 0, "%*s %s:", level, "", docstring); \
    octstr_dump(p->field, level + 1);

PDU [1/7]

#define PDU	(		name,
			docstring,
			fields,
			is_valid
	)

Value:

case name: {\
    struct name *p; p = &pdu->u.name; \
    fields \
    } break;

PDU [2/7]

#define PDU	(		name,
			docstring,
			fields,
			is_valid
	)

Value:

case name: {\
    struct name *p; p = &pdu->u.name; \
    fields \
    } break;

PDU [3/7]

#define PDU	(		name,
			docstring,
			fields,
			is_valid
	)

Value:

bitpos = 0; \
    thistype = name; \
    fields

PDU [4/7]

#define PDU	(		name,
			docstring,
			fields,
			is_valid
	)

Value:

case name: { \
        struct name *p = &pdu->u.name; \
		fields \
		gw_assert(bitpos % 8 == 0); \
        if (bitpos / 8 != octstr_len(data)) { \
            warning(0, "Bad length for " #name " PDU, " \
                "expected %ld", bitpos / 8); \
        } \
        if (!(is_valid)) { \
            warning(0, #name " PDU failed %s", #is_valid); \
                        return NULL; \
        } \
    } break;

PDU [5/7]

#define PDU	(		name,
			docstring,
			fields,
			is_valid
	)

Value:

case name: { \
        struct name *p = &pdu->u.name; \
        fields \
    } break;

PDU [6/7]

#define PDU	(		name,
			docstring,
			fields,
			is_valid
	)

Value:

case name: { \
        struct name *p = &pdu->u.name; \
		fields \
		gw_assert(bitpos % 8 == 0); \
    } break;

PDU [7/7]

#define PDU	(		name,
			docstring,
			fields,
			is_valid
	)

Value:

case name: { \
        struct name *p = &pdu->u.name; \
        debug(dbg, 0, "%*sWTP %s PDU at %p:", \
            level, "", #name, (void *)pdu); \
        fields \
    } break;

RESERVED [1/7]

#define RESERVED

(

bits

)

RESERVED [2/7]

#define RESERVED

(

bits

)

RESERVED [3/7]

#define RESERVED

(

bits

)

bitpos += (bits);

RESERVED [4/7]

#define RESERVED

(

bits

)

bitpos += (bits);

RESERVED [5/7]

#define RESERVED

(

bits

)

RESERVED [6/7]

#define RESERVED

(

bits

)

bitpos += (bits);

RESERVED [7/7]

#define RESERVED

(

bits

)

REST [1/7]

#define REST	(		field,
			docstring
	)		p->field = NULL;

REST [2/7]

#define REST	(		field,
			docstring
	)		octstr_destroy(p->field);

REST [3/7]

#define REST	(		field,
			docstring
	)

REST [4/7]

#define REST	(		field,
			docstring
	)

Value:

gw_assert(bitpos % 8 == 0); \
    if (bitpos / 8 <= octstr_len(data)) { \
        p->field = octstr_copy(data, bitpos / 8, \
                octstr_len(data) - bitpos / 8); \
        bitpos = octstr_len(data) * 8; \
    } else { \
        p->field = octstr_create(""); \
    }

REST [5/7]

#define REST	(		field,
			docstring
	)

REST [6/7]

#define REST	(		field,
			docstring
	)

Value:

gw_assert(bitpos % 8 == 0); \
    if (p->field != NULL) \
        octstr_append(data, p->field); \
    bitpos += 8 * octstr_len(p->field);

REST [7/7]

#define REST	(		field,
			docstring
	)

Value:

debug(dbg, 0, "%*s %s:", level, "", docstring); \
    octstr_dump(p->field, level + 1);

TPI [1/7]

#define TPI

(

confield

)

TPI [2/7]

#define TPI

(

confield

)

TPI [3/7]

#define TPI

(

confield

)

TPI [4/7]

#define TPI

(

confield

)

Value:

if (p->confield) { \
        pdu->options = gwlist_create(); \
        bitpos = unpack_tpis(data, bitpos, pdu); \
    }

TPI [5/7]

#define TPI

(

confield

)

p->confield = pdu->options != NULL && gwlist_len(pdu->options) > 0;

TPI [6/7]

#define TPI

(

confield

)

Value:

if (p->confield) { \
        bitpos = pack_tpis(data, bitpos, pdu->options); \
    }

TPI [7/7]

#define TPI

(

confield

)

dump_tpis(pdu->options, level);

TYPE [1/7]

#define TYPE	(		bits,
			value
	)

TYPE [2/7]

#define TYPE	(		bits,
			value
	)

TYPE [3/7]

#define TYPE	(		bits,
			value
	)

Value:

if ((bits) != lastnumbits || bitpos != lastpos) { \
        lastval = octstr_get_bits(data, bitpos, (bits)); \
    } \
    if (lastval == (value)) \
        return thistype; \
    lastnumbits = (bits); \
    lastpos = bitpos;

TYPE [4/7]

#define TYPE	(		bits,
			value
	)		bitpos += (bits);

TYPE [5/7]

#define TYPE	(		bits,
			value
	)

TYPE [6/7]

#define TYPE	(		bits,
			value
	)

Value:

octstr_set_bits(data, bitpos, (bits), (value)); \
    bitpos += (bits);

TYPE [7/7]

#define TYPE	(		bits,
			value
	)

UINT [1/7]

#define UINT	(		field,
			docstring,
			bits
	)		p->field = 0;

UINT [2/7]

#define UINT	(		field,
			docstring,
			bits
	)

UINT [3/7]

#define UINT	(		field,
			docstring,
			bits
	)		bitpos += (bits);

UINT [4/7]

#define UINT	(		field,
			docstring,
			bits
	)

Value:

p->field = octstr_get_bits(data, bitpos, (bits)); \
    bitpos += (bits);

UINT [5/7]

#define UINT	(		field,
			docstring,
			bits
	)

UINT [6/7]

#define UINT	(		field,
			docstring,
			bits
	)

Value:

octstr_set_bits(data, bitpos, (bits), p->field); \
    bitpos += (bits);

UINT [7/7]

#define UINT	(		field,
			docstring,
			bits
	)		debug(dbg, 0, "%*s %s: %lu", level, "", docstring, p->field);

UINTVAR [1/7]

#define UINTVAR	(		field,
			docstring
	)		p->field = 0;

UINTVAR [2/7]

#define UINTVAR	(		field,
			docstring
	)

UINTVAR [3/7]

#define UINTVAR	(		field,
			docstring
	)

UINTVAR [4/7]

#define UINTVAR	(		field,
			docstring
	)

Value:

gw_assert(bitpos % 8 == 0); \
    p->field = octstr_get_bits(data, bitpos + 1, 7); \
    while (octstr_get_bits(data, bitpos, 1)) { \
        bitpos += 8; \
        p->field <<= 7; \
        p->field |= octstr_get_bits(data, bitpos + 1, 7); \
    } \
    bitpos += 8;

UINTVAR [5/7]

#define UINTVAR	(		field,
			docstring
	)

UINTVAR [6/7]

#define UINTVAR	(		field,
			docstring
	)

Value:

gw_assert(bitpos % 8 == 0); \
    octstr_append_uintvar(data, p->field); \
    bitpos = 8 * octstr_len(data);

UINTVAR [7/7]

#define UINTVAR	(		field,
			docstring
	)		debug(dbg, 0, "%*s %s: %lu", level, "", docstring, p->field);

Function Documentation

dump_tpis()

static void dump_tpis ( List *  tpis, int  level  )

static

Definition at line 222 of file wtp_pdu.c.

References wtp_tpi::data, debug(), gwlist_get(), gwlist_len(), octstr_dump, and wtp_tpi::type.

                                             {
    int i;
    int num_tpis;
    WTP_TPI *tpi;

    if (tpis == NULL)
        return;

    num_tpis = gwlist_len(tpis);
    for (i = 0; i < num_tpis; i++) {
        tpi = gwlist_get(tpis, i);
        debug("wap.wtp", 0, "%*s TPI type %u:", level, "", tpi->type);
        octstr_dump(tpi->data, level + 1);
    }
}

fixup_length_fields()

static void fixup_length_fields ( WTP_PDU *  pdu )

static

Definition at line 360 of file wtp_pdu.c.

References wtp_pdu::type.

Referenced by wtp_pdu_pack().

                                              {
    switch (pdu->type) {
#define PDU(name, docstring, fields, is_valid) \
    case name: { \
        struct name *p = &pdu->u.name; \
        fields \
    } break;
#define UINT(field, docstring, bits)
#define UINTVAR(field, docstring)
#define OCTSTR(field, docstring, lengthfield) \
    p->lengthfield = octstr_len(p->field);
#define REST(field, docstring)
#define TYPE(bits, value)
#define RESERVED(bits)
#define TPI(confield) \
    p->confield = pdu->options != NULL && gwlist_len(pdu->options) > 0;
#include "wtp_pdu.def"
#undef TPI
#undef RESERVED
#undef TYPE
#undef REST
#undef OCTSTR
#undef UINTVAR
#undef UINT
#undef PDU
    }
}

pack_tpis()

static long pack_tpis ( Octstr *  data, long  bitpos, List *  tpis  )

static

Definition at line 191 of file wtp_pdu.c.

References wtp_tpi::data, gw_assert(), gwlist_get(), gwlist_len(), octstr_append(), octstr_len(), octstr_set_bits(), and wtp_tpi::type.

                                                             {
    long length;
    WTP_TPI *tpi;
    int i;
    int num_tpis;

    num_tpis = gwlist_len(tpis);
    for (i = 0; i < num_tpis; i++) {
        tpi = gwlist_get(tpis, i);
        length = octstr_len(tpi->data);
        octstr_set_bits(data, bitpos, 1, i + 1 < num_tpis);
        octstr_set_bits(data, bitpos + 1, 4, tpi->type);
        if (length >= 4) {
            /* Long TPI */
            octstr_set_bits(data, bitpos + 5, 1, 1);
            octstr_set_bits(data, bitpos + 8, 8, length);
            bitpos += 16;
        } else {
            /* Short TPI */
            octstr_set_bits(data, bitpos + 5, 1, 0);
            octstr_set_bits(data, bitpos + 6, 2, length);
            bitpos += 8;
        }
        gw_assert(bitpos % 8 == 0);
        octstr_append(data, tpi->data);
        bitpos += 8 * length;
    }

    return bitpos;
}

unpack_tpis()

static long unpack_tpis ( Octstr *  data, long  bitpos, WTP_PDU *  pdu  )

static

Definition at line 164 of file wtp_pdu.c.

References gw_assert(), octstr_copy, octstr_get_bits(), type, and wtp_pdu_append_tpi().

                                                                 {
    long length;
    int type;
    Octstr *tpidata;
    int another;

    do {
        another = octstr_get_bits(data, bitpos, 1);
        type = octstr_get_bits(data, bitpos + 1, 4);
        if (octstr_get_bits(data, bitpos + 5, 1)) {
            /* Long TPI */
            length = octstr_get_bits(data, bitpos + 8, 8);
            bitpos += 16;
        } else {
            /* Short TPI */
            length = octstr_get_bits(data, bitpos + 6, 2);
            bitpos += 8;
        }
        gw_assert(bitpos % 8 == 0);
        tpidata = octstr_copy(data, bitpos / 8, length);
        bitpos += 8 * length;
        wtp_pdu_append_tpi(pdu, type, tpidata);
    } while (another);

    return bitpos;
}

wtp_pdu_append_tpi()

void wtp_pdu_append_tpi	(	WTP_PDU *	pdu,
		int	type,
		Octstr *	data
	)

Definition at line 153 of file wtp_pdu.c.

References wtp_tpi::data, gwlist_append(), gwlist_create, wtp_pdu::options, wtp_tpi::type, and type.

Referenced by unpack_tpis(), and wtp_pack_sar_ack().

                                                              {
    WTP_TPI *tpi;

    tpi = gw_malloc(sizeof(*tpi));
    tpi->type = type;
    tpi->data = data;
    if (pdu->options == NULL)
        pdu->options = gwlist_create();
    gwlist_append(pdu->options, tpi);
}

wtp_pdu_create()

WTP_PDU* wtp_pdu_create

(

int

type

)

Definition at line 67 of file wtp_pdu.c.

References wtp_pdu::options, wtp_pdu::type, type, and warning().

Referenced by wtp_pack_abort(), wtp_pack_ack(), wtp_pack_invoke(), wtp_pack_result(), wtp_pack_sar_ack(), and wtp_pack_sar_result().

                                  {
    WTP_PDU *pdu;
    
    pdu = gw_malloc(sizeof(*pdu));
    pdu->type = type;
    pdu->options = NULL;

    switch (pdu->type) {
#define PDU(name, docstring, fields, is_valid) \
    case name: {\
    struct name *p; p = &pdu->u.name; \
    fields \
    } break;
#define UINT(field, docstring, bits) p->field = 0;
#define UINTVAR(field, docstring) p->field = 0;
#define OCTSTR(field, docstring, lengthfield) p->field = NULL;
#define REST(field, docstring) p->field = NULL;
#define TYPE(bits, value) 
#define RESERVED(bits) 
#define TPI(confield)
#include "wtp_pdu.def"
#undef TPI
#undef RESERVED
#undef TYPE
#undef REST
#undef OCTSTR
#undef UINTVAR
#undef UINT
#undef PDU
    default:
        warning(0, "Cannot create unknown WTP PDU type %d", pdu->type);
        break;
    }

    return pdu;
}

wtp_pdu_destroy()

void wtp_pdu_destroy

(

WTP_PDU *

pdu

)

Definition at line 104 of file wtp_pdu.c.

References gwlist_consume(), gwlist_destroy(), gwlist_len(), wtp_pdu::options, wtp_pdu::type, warning(), and wtp_tpi_destroy().

Referenced by main(), unpack_wdp_datagram_real(), wtp_pack_abort(), wtp_pack_ack(), wtp_pack_invoke(), wtp_pack_result(), wtp_pack_sar_ack(), and wtp_pack_sar_result().

                                   {
    if (pdu == NULL)
        return;

    switch (pdu->type) {
#define PDU(name, docstring, fields, is_valid) \
    case name: {\
    struct name *p; p = &pdu->u.name; \
    fields \
    } break;
#define UINT(field, docstring, bits)
#define UINTVAR(field, docstring)
#define OCTSTR(field, docstring, lengthfield) octstr_destroy(p->field);
#define REST(field, docstring) octstr_destroy(p->field);
#define TYPE(bits, value)
#define RESERVED(bits)
#define TPI(confield)
#include "wtp_pdu.def"
#undef TPI
#undef RESERVED
#undef TYPE
#undef REST
#undef OCTSTR
#undef UINTVAR
#undef UINT
#undef PDU
    default:
        warning(0, "Cannot destroy unknown WTP PDU type %d", pdu->type);
        break;
    }

    if (pdu->options) {
        while (gwlist_len(pdu->options)) {
            wtp_tpi_destroy(gwlist_consume(pdu->options));
        }
        gwlist_destroy(pdu->options, NULL);
    }

    gw_free(pdu);
}

wtp_pdu_dump()

void wtp_pdu_dump	(	WTP_PDU *	pdu,
		int	level
	)

Definition at line 446 of file wtp_pdu.c.

References debug(), and wtp_pdu::type.

Referenced by main().

                                           {
     char *dbg = "wap.wtp";

    switch (pdu->type) {
#define PDU(name, docstring, fields, is_valid) \
    case name: { \
        struct name *p = &pdu->u.name; \
        debug(dbg, 0, "%*sWTP %s PDU at %p:", \
            level, "", #name, (void *)pdu); \
        fields \
    } break;
#define UINT(field, docstring, bits) \
    debug(dbg, 0, "%*s %s: %lu", level, "", docstring, p->field);
#define UINTVAR(field, docstring) \
    debug(dbg, 0, "%*s %s: %lu", level, "", docstring, p->field);
#define OCTSTR(field, docstring, lengthfield) \
    debug(dbg, 0, "%*s %s:", level, "", docstring); \
    octstr_dump(p->field, level + 1);
#define REST(field, docstring) \
    debug(dbg, 0, "%*s %s:", level, "", docstring); \
    octstr_dump(p->field, level + 1);
#define TYPE(bits, value)
#define RESERVED(bits)
#define TPI(confield) dump_tpis(pdu->options, level);
#include "wtp_pdu.def"
#undef TPI
#undef RESERVED
#undef TYPE
#undef REST
#undef OCTSTR
#undef UINTVAR
#undef UINT
#undef PDU
    default:
        debug(dbg, 0, "%*sWTP PDU at %p:", level, "", (void *)pdu);
        debug(dbg, 0, "%*s unknown type %u", level, "", pdu->type);
        break;
    }
}

wtp_pdu_pack()

Octstr* wtp_pdu_pack

(

WTP_PDU *

pdu

)

Definition at line 388 of file wtp_pdu.c.

References fixup_length_fields(), octstr_create, panic, and wtp_pdu::type.

Referenced by main(), wtp_pack_abort(), wtp_pack_ack(), wtp_pack_invoke(), wtp_pack_result(), wtp_pack_sar_ack(), and wtp_pack_sar_result().

                                   {
    Octstr *data;
    long bitpos;

    /* We rely on octstr_set_bits to lengthen our octstr as needed. */
    data = octstr_create("");

    fixup_length_fields(pdu);

    bitpos = 0;
    switch (pdu->type) {
#define PDU(name, docstring, fields, is_valid) \
    case name: { \
        struct name *p = &pdu->u.name; \
        fields \
        gw_assert(bitpos % 8 == 0); \
    } break;
#define UINT(field, docstring, bits) \
    octstr_set_bits(data, bitpos, (bits), p->field); \
    bitpos += (bits);
#define UINTVAR(field, docstring) \
    gw_assert(bitpos % 8 == 0); \
    octstr_append_uintvar(data, p->field); \
    bitpos = 8 * octstr_len(data);
#define OCTSTR(field, docstring, lengthfield) \
    gw_assert(bitpos % 8 == 0); \
    if (p->field != NULL) \
        octstr_append(data, p->field); \
    bitpos += 8 * octstr_len(p->field);
#define REST(field, docstring) \
    gw_assert(bitpos % 8 == 0); \
    if (p->field != NULL) \
        octstr_append(data, p->field); \
    bitpos += 8 * octstr_len(p->field);
#define TYPE(bits, value) \
    octstr_set_bits(data, bitpos, (bits), (value)); \
    bitpos += (bits);
#define RESERVED(bits) bitpos += (bits);
#define TPI(confield) \
    if (p->confield) { \
        bitpos = pack_tpis(data, bitpos, pdu->options); \
    }
#include "wtp_pdu.def"
#undef TPI
#undef RESERVED
#undef TYPE
#undef REST
#undef OCTSTR
#undef UINTVAR
#undef UINT
#undef PDU
    default:
        panic(0, "Packing unknown WTP PDU type %ld", (long) pdu->type);
    }

    return data;
}

wtp_pdu_type()

static int wtp_pdu_type ( Octstr *  data )

static

Definition at line 240 of file wtp_pdu.c.

Referenced by wtp_pdu_unpack().

                                      {
    long bitpos;
    long lastpos = -1;
    long lastnumbits = -1;
    long lastval = -1;
    int thistype;

    /* This code looks slow, but an optimizing compiler will
     * reduce it considerably.  gcc -O2 will produce a single
     * call to octstr_get_bits, folllowed by a sequence of
     * tests on lastval. */

/* Only UINT and RESERVED fields may precede the TYPE */
#define PDU(name, docstring, fields, is_valid) \
    bitpos = 0; \
    thistype = name; \
    fields
#define UINT(field, docstring, bits) bitpos += (bits);
#define UINTVAR(field, docstring)
#define OCTSTR(field, docstring, lengthfield)
#define REST(field, docstring)
#define TYPE(bits, value) \
    if ((bits) != lastnumbits || bitpos != lastpos) { \
        lastval = octstr_get_bits(data, bitpos, (bits)); \
    } \
    if (lastval == (value)) \
        return thistype; \
    lastnumbits = (bits); \
    lastpos = bitpos;
#define RESERVED(bits) bitpos += (bits);
#define TPI(confield)
#include "wtp_pdu.def"
#undef TPI
#undef RESERVED
#undef TYPE
#undef REST
#undef OCTSTR
#undef UINTVAR
#undef UINT
#undef PDU

    return -1;
}

wtp_pdu_unpack()

WTP_PDU* wtp_pdu_unpack

(

Octstr *

data

)

Definition at line 284 of file wtp_pdu.c.

References gw_assert(), wtp_pdu::options, wtp_pdu::type, warning(), and wtp_pdu_type().

Referenced by main(), and unpack_wdp_datagram_real().

                                      {
    WTP_PDU *pdu = NULL;
    long bitpos = 0;

    gw_assert(data != NULL);

    pdu = gw_malloc(sizeof(*pdu));

    pdu->type = wtp_pdu_type(data);
    pdu->options = NULL;

    switch (pdu->type) {
#define PDU(name, docstring, fields, is_valid) \
    case name: { \
        struct name *p = &pdu->u.name; \
        fields \
        gw_assert(bitpos % 8 == 0); \
        if (bitpos / 8 != octstr_len(data)) { \
            warning(0, "Bad length for " #name " PDU, " \
                "expected %ld", bitpos / 8); \
        } \
        if (!(is_valid)) { \
            warning(0, #name " PDU failed %s", #is_valid); \
                        return NULL; \
        } \
    } break;
#define UINT(field, docstring, bits) \
    p->field = octstr_get_bits(data, bitpos, (bits)); \
    bitpos += (bits);
#define UINTVAR(field, docstring) \
    gw_assert(bitpos % 8 == 0); \
    p->field = octstr_get_bits(data, bitpos + 1, 7); \
    while (octstr_get_bits(data, bitpos, 1)) { \
        bitpos += 8; \
        p->field <<= 7; \
        p->field |= octstr_get_bits(data, bitpos + 1, 7); \
    } \
    bitpos += 8;
#define OCTSTR(field, docstring, lengthfield) \
    gw_assert(bitpos % 8 == 0); \
    p->field = octstr_copy(data, bitpos / 8, p->lengthfield); \
    bitpos += 8 * p->lengthfield;
#define REST(field, docstring) \
    gw_assert(bitpos % 8 == 0); \
    if (bitpos / 8 <= octstr_len(data)) { \
        p->field = octstr_copy(data, bitpos / 8, \
                octstr_len(data) - bitpos / 8); \
        bitpos = octstr_len(data) * 8; \
    } else { \
        p->field = octstr_create(""); \
    }
#define TYPE(bits, value) bitpos += (bits);
#define RESERVED(bits) bitpos += (bits);
#define TPI(confield) \
    if (p->confield) { \
        pdu->options = gwlist_create(); \
        bitpos = unpack_tpis(data, bitpos, pdu); \
    }
#include "wtp_pdu.def"
#undef TPI
#undef RESERVED
#undef TYPE
#undef REST
#undef OCTSTR
#undef UINTVAR
#undef UINT
#undef PDU
    default:
        warning(0, "WTP PDU with unknown type %d", pdu->type);
        gw_free(pdu);
        return NULL;
    }

    return pdu;
}

wtp_tpi_destroy()

void wtp_tpi_destroy

(

WTP_TPI *

p

)

Definition at line 145 of file wtp_pdu.c.

References wtp_tpi::data, and octstr_destroy().

Referenced by wtp_pdu_destroy().

                                 {
    if (p == NULL)
        return;

    octstr_destroy(p->data);
    gw_free(p);
}