Main Page | Alphabetical List | Data Structures | Directories | File List | Data Fields | Globals
wap

wsp_pdu.c File Reference

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

Include dependency graph for wsp_pdu.c:

Include dependency graph

Go to the source code of this file.

Defines

#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 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 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 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 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 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 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)

Functions

WSP_PDU * wsp_pdu_create (int type)
void wsp_pdu_destroy (WSP_PDU *pdu)
int wsp_pdu_type (Octstr *data)
WSP_PDU * wsp_pdu_unpack (Octstr *data)
void fixup_length_fields (WSP_PDU *pdu)
Octstr * wsp_pdu_pack (WSP_PDU *pdu)
void wsp_pdu_dump (WSP_PDU *pdu, int level)

Define Documentation

#define OCTSTR (  field,
docstring,
lengthfield   ) 
 

Value:

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

#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);

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

#define OCTSTR (  field,
docstring,
lengthfield   ) 
 

Value:

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

#define OCTSTR (  field,
docstring,
lengthfield   ) 
 

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

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

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

Value:

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

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

Value:

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

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

Value:

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

#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); \
        } \
    } break;

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

Value:

bitpos = 0; \
    thistype = name; \
    fields

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

Value:

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

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

Value:

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

#define RESERVED (  bits   ) 
 

#define RESERVED (  bits   )     bitpos += (bits);
 

#define RESERVED (  bits   ) 
 

#define RESERVED (  bits   )     bitpos += (bits);
 

#define RESERVED (  bits   )     bitpos += (bits);
 

#define RESERVED (  bits   ) 
 

#define RESERVED (  bits   ) 
 

#define REST (  field,
docstring   ) 
 

Value:

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

#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);

#define REST (  field,
docstring   ) 
 

#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(""); \
    }

#define REST (  field,
docstring   ) 
 

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

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

#define TYPE (  bits,
value   ) 
 

#define TYPE (  bits,
value   ) 
 

Value:

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

#define TYPE (  bits,
value   ) 
 

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

#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;

#define TYPE (  bits,
value   ) 
 

#define TYPE (  bits,
value   ) 
 

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

#define UINT (  field,
docstring,
bits   ) 
 

Value:

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

#define UINT (  field,
docstring,
bits   ) 
 

#define UINT (  field,
docstring,
bits   ) 
 

Value:

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

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

#define UINT (  field,
docstring,
bits   ) 
 

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

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

#define UINTVAR (  field,
docstring   ) 
 

Value:

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

#define UINTVAR (  field,
docstring   ) 
 

#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;

#define UINTVAR (  field,
docstring   ) 
 

#define UINTVAR (  field,
docstring   ) 
 

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

Function Documentation

void fixup_length_fields (  WSP_PDU *  pdu  )  [static]
 

Definition at line 246 of file wsp_pdu.c.

References pdu, wsp_pdu::type, and WSP_PDU.

00246                                               {
00247     switch (pdu->type) {
00248 #define PDU(name, docstring, fields, is_valid) \
00249     case name: { \
00250         struct name *p; p = &pdu->u.name; \
00251         fields \
00252     } break;
00253 #define UINT(field, docstring, bits)
00254 #define UINTVAR(field, docstring)
00255 #define OCTSTR(field, docstring, lengthfield) \
00256     p->lengthfield = octstr_len(p->field);
00257 #define REST(field, docstring)
00258 #define TYPE(bits, value)
00259 #define RESERVED(bits)
00260 #include "wsp_pdu.def"
00261 #undef RESERVED
00262 #undef TYPE
00263 #undef REST
00264 #undef OCTSTR
00265 #undef UINTVAR
00266 #undef UINT
00267 #undef PDU
00268     }
00269 }

WSP_PDU* wsp_pdu_create (  int  type  ) 
 

Definition at line 68 of file wsp_pdu.c.

References panic, pdu, wsp_pdu::type, and WSP_PDU.

Referenced by make_confirmedpush_pdu(), make_connectreply_pdu(), make_push_pdu(), make_resume_reply_pdu(), pack_into_push_datagram(), pack_into_result_datagram(), and pack_sia().

00068                                   {
00069     WSP_PDU *pdu;
00070     
00071     pdu = gw_malloc(sizeof(*pdu));
00072     pdu->type = type;
00073 
00074     switch (pdu->type) {
00075 #define PDU(name, docstring, fields, is_valid) \
00076     case name: {\
00077     struct name *p; p = &pdu->u.name; \
00078     fields \
00079     } break;
00080 #define UINT(field, docstring, bits) p->field = 0;
00081 #define UINTVAR(field, docstring) p->field = 0;
00082 #define OCTSTR(field, docstring, lengthfield) p->field = NULL;
00083 #define REST(field, docstring) p->field = NULL;
00084 #define TYPE(bits, value)
00085 #define RESERVED(bits)
00086 #include "wsp_pdu.def"
00087 #undef RESERVED
00088 #undef TYPE
00089 #undef REST
00090 #undef OCTSTR
00091 #undef UINTVAR
00092 #undef UINT
00093 #undef PDU
00094     default:
00095         panic(0, "Internal error: Unknown PDU type %d", pdu->type);
00096         break;
00097     }
00098 
00099     return pdu;
00100 }

void wsp_pdu_destroy (  WSP_PDU *  pdu  ) 
 

Definition at line 102 of file wsp_pdu.c.

References panic, pdu, wsp_pdu::type, and WSP_PDU.

Referenced by main(), main_thread(), make_connectreply_pdu(), make_resume_reply_pdu(), pack_into_push_datagram(), pack_into_result_datagram(), pack_sia(), push_client_event_handle(), send_invoke(), and unpack_datagram().

00102                                    {
00103     if (pdu == NULL)
00104         return;
00105 
00106     switch (pdu->type) {
00107 #define PDU(name, docstring, fields, is_valid) \
00108     case name: {\
00109     struct name *p; p = &pdu->u.name; \
00110     fields \
00111     } break;
00112 #define UINT(field, docstring, bits)
00113 #define UINTVAR(field, docstring)
00114 #define OCTSTR(field, docstring, lengthfield) octstr_destroy(p->field);
00115 #define REST(field, docstring) octstr_destroy(p->field);
00116 #define TYPE(bits, value)
00117 #define RESERVED(bits)
00118 #include "wsp_pdu.def"
00119 #undef RESERVED
00120 #undef TYPE
00121 #undef REST
00122 #undef OCTSTR
00123 #undef UINTVAR
00124 #undef UINT
00125 #undef PDU
00126     default:
00127         panic(0, "Cannot destroy unknown WSP PDU type %d", pdu->type);
00128         break;
00129     }
00130 
00131     gw_free(pdu);
00132 }

void wsp_pdu_dump (  WSP_PDU *  pdu,
int  level
) 
 

Definition at line 324 of file wsp_pdu.c.

References debug(), pdu, wsp_pdu::type, and WSP_PDU.

Referenced by main().

00324                                            {
00325     char *dbg = "wap.wsp";
00326 
00327     switch (pdu->type) {
00328 #define PDU(name, docstring, fields, is_valid) \
00329     case name: { \
00330         struct name *p = &pdu->u.name; \
00331         debug(dbg, 0, "%*sWSP %s PDU at %p:", \
00332             level, "", #name, (void *)pdu); \
00333         fields \
00334     } break;
00335 #define UINT(field, docstring, bits) \
00336     debug(dbg, 0, "%*s %s: %lu", level, "", docstring, p->field);
00337 #define UINTVAR(field, docstring) \
00338     debug(dbg, 0, "%*s %s: %lu", level, "", docstring, p->field);
00339 #define OCTSTR(field, docstring, lengthfield) \
00340     debug(dbg, 0, "%*s %s:", level, "", docstring); \
00341     octstr_dump(p->field, level + 1);
00342 #define REST(field, docstring) \
00343     debug(dbg, 0, "%*s %s:", level, "", docstring); \
00344     octstr_dump(p->field, level + 1);
00345 #define TYPE(bits, value)
00346 #define RESERVED(bits)
00347 #include "wsp_pdu.def"
00348 #undef RESERVED
00349 #undef TYPE
00350 #undef REST
00351 #undef OCTSTR
00352 #undef UINTVAR
00353 #undef UINT
00354 #undef PDU
00355     default:
00356         debug(dbg, 0, "%*sWSP PDU at %p:", level, "", (void *)pdu);
00357         debug(dbg, 0, "%*s unknown type %u", level, "", pdu->type);
00358         break;
00359     }
00360     debug("wap.wsp", 0, "%*sWSP PDU dump ends.", level, "");
00361 }

Here is the call graph for this function:

Octstr* wsp_pdu_pack (  WSP_PDU *  pdu  ) 
 

Definition at line 271 of file wsp_pdu.c.

References data, fixup_length_fields(), octstr_create, panic, pdu, wsp_pdu::type, and WSP_PDU.

Referenced by main(), make_connectreply_pdu(), make_resume_reply_pdu(), pack_into_push_datagram(), pack_into_result_datagram(), pack_sia(), and send_invoke().

00271                                    {
00272     Octstr *data;
00273     long bitpos;
00274 
00275     /* We rely on octstr_set_bits to lengthen our octstr as needed. */
00276     data = octstr_create("");
00277 
00278     fixup_length_fields(pdu);
00279 
00280     bitpos = 0;
00281     switch (pdu->type) {
00282 #define PDU(name, docstring, fields, is_valid) \
00283     case name: { \
00284         struct name *p = &pdu->u.name; \
00285         fields \
00286         gw_assert(bitpos % 8 == 0); \
00287     } break;
00288 #define UINT(field, docstring, bits) \
00289     octstr_set_bits(data, bitpos, (bits), p->field); \
00290     bitpos += (bits);
00291 #define UINTVAR(field, docstring) \
00292     gw_assert(bitpos % 8 == 0); \
00293     octstr_append_uintvar(data, p->field); \
00294     bitpos = 8 * octstr_len(data);
00295 #define OCTSTR(field, docstring, lengthfield) \
00296     gw_assert(bitpos % 8 == 0); \
00297     if (p->field != NULL) \
00298         octstr_append(data, p->field); \
00299     bitpos += 8 * octstr_len(p->field);
00300 #define REST(field, docstring) \
00301     gw_assert(bitpos % 8 == 0); \
00302     if (p->field != NULL) \
00303         octstr_append(data, p->field); \
00304     bitpos += 8 * octstr_len(p->field);
00305 #define TYPE(bits, value) \
00306     octstr_set_bits(data, bitpos, (bits), (value)); \
00307     bitpos += (bits);
00308 #define RESERVED(bits) bitpos += (bits);
00309 #include "wsp_pdu.def"
00310 #undef RESERVED
00311 #undef TYPE
00312 #undef REST
00313 #undef OCTSTR
00314 #undef UINTVAR
00315 #undef UINT
00316 #undef PDU
00317     default:
00318         panic(0, "Packing unknown WSP PDU type %ld", (long) pdu->type);
00319     }
00320 
00321     return data;
00322 }

Here is the call graph for this function:

int wsp_pdu_type (  Octstr *  data  )  [static]
 

Definition at line 136 of file wsp_pdu.c.

Referenced by wsp_pdu_unpack().

00136                                       {
00137     long bitpos;
00138     long lastpos = -1;
00139     long lastnumbits = -1;
00140     long lastval = -1;
00141     int thistype;
00142 
00143     /* This code looks slow, but an optimizing compiler will
00144      * reduce it considerably.  gcc -O2 will produce a single
00145      * call to octstr_get_bits, folllowed by a sequence of
00146      * tests on lastval. */
00147 
00148 /* Only UINT and RESERVED fields may precede the TYPE */
00149 #define PDU(name, docstring, fields, is_valid) \
00150     bitpos = 0; \
00151     thistype = name; \
00152     fields
00153 #define UINT(field, docstring, bits) bitpos += (bits);
00154 #define UINTVAR(field, docstring)
00155 #define OCTSTR(field, docstring, lengthfield)
00156 #define REST(field, docstring)
00157 #define TYPE(bits, value) \
00158     if ((bits) != lastnumbits || bitpos != lastpos) { \
00159         lastval = octstr_get_bits(data, bitpos, (bits)); \
00160     } \
00161     if (lastval == (value)) \
00162         return thistype; \
00163     lastnumbits = (bits); \
00164     lastpos = bitpos;
00165 #define RESERVED(bits) bitpos += (bits);
00166 #include "wsp_pdu.def"
00167 #undef RESERVED
00168 #undef TYPE
00169 #undef REST
00170 #undef OCTSTR
00171 #undef UINTVAR
00172 #undef UINT
00173 #undef PDU
00174 
00175     return -1;
00176 }

WSP_PDU* wsp_pdu_unpack (  Octstr *  data  ) 
 

Definition at line 178 of file wsp_pdu.c.

References data, gw_assert, pdu, wsp_pdu::type, warning(), WSP_PDU, and wsp_pdu_type().

Referenced by main(), main_thread(), push_client_event_handle(), and unpack_datagram().

00178                                       {
00179     WSP_PDU *pdu = NULL;
00180     long bitpos = 0;
00181 
00182     gw_assert(data != NULL);
00183 
00184     pdu = gw_malloc(sizeof(*pdu));
00185 
00186     pdu->type = wsp_pdu_type(data);
00187 
00188     switch (pdu->type) {
00189 #define PDU(name, docstring, fields, is_valid) \
00190     case name: { \
00191         struct name *p = &pdu->u.name; \
00192         fields \
00193         gw_assert(bitpos % 8 == 0); \
00194         if (bitpos / 8 != octstr_len(data)) { \
00195             warning(0, "Bad length for " #name " PDU, " \
00196                 "expected %ld", bitpos / 8); \
00197         } \
00198         if (!(is_valid)) { \
00199             warning(0, #name " PDU failed %s", #is_valid); \
00200         } \
00201     } break;
00202 #define UINT(field, docstring, bits) \
00203     p->field = octstr_get_bits(data, bitpos, (bits)); \
00204     bitpos += (bits);
00205 #define UINTVAR(field, docstring) \
00206     gw_assert(bitpos % 8 == 0); \
00207     p->field = octstr_get_bits(data, bitpos + 1, 7); \
00208     while (octstr_get_bits(data, bitpos, 1)) { \
00209         bitpos += 8; \
00210         p->field <<= 7; \
00211         p->field |= octstr_get_bits(data, bitpos + 1, 7); \
00212     } \
00213     bitpos += 8;
00214 #define OCTSTR(field, docstring, lengthfield) \
00215     gw_assert(bitpos % 8 == 0); \
00216     p->field = octstr_copy(data, bitpos / 8, p->lengthfield); \
00217     bitpos += 8 * p->lengthfield;
00218 #define REST(field, docstring) \
00219     gw_assert(bitpos % 8 == 0); \
00220     if (bitpos / 8 <= octstr_len(data)) { \
00221         p->field = octstr_copy(data, bitpos / 8, \
00222                 octstr_len(data) - bitpos / 8); \
00223         bitpos = octstr_len(data) * 8; \
00224     } else { \
00225         p->field = octstr_create(""); \
00226     }
00227 #define TYPE(bits, value) bitpos += (bits);
00228 #define RESERVED(bits) bitpos += (bits);
00229 #include "wsp_pdu.def"
00230 #undef RESERVED
00231 #undef TYPE
00232 #undef REST
00233 #undef OCTSTR
00234 #undef UINTVAR
00235 #undef UINT
00236 #undef PDU
00237     default:
00238         warning(0, "WSP PDU with unknown type %d", pdu->type);
00239         gw_free(pdu);
00240         return NULL;
00241     }
00242 
00243     return pdu;
00244 }

Here is the call graph for this function:

See file LICENSE for details about the license agreement for using, modifying, copying or deriving work from this software.