wtp.c File Reference

#include "wtp.h"
#include "wap_events.h"
#include "wtp_pdu.h"

Go to the source code of this file.

Functions
static WAPEvent *	unpack_wdp_datagram_real (WAPEvent *datagram)
static int	deduce_tid (Octstr *user_data)
static int	concatenated_message (Octstr *user_data)
static int	truncated_datagram (WAPEvent *event)
static WAPEvent *	unpack_invoke (WTP_PDU *pdu, WAPAddrTuple *addr_tuple)
static WAPEvent *	unpack_segmented_invoke (WTP_PDU *pdu, WAPAddrTuple *addr_tuple)
static WAPEvent *	unpack_result (WTP_PDU *pdu, WAPAddrTuple *addr_tuple)
static WAPEvent *	unpack_ack (WTP_PDU *pdu, WAPAddrTuple *addr_tuple)
static WAPEvent *	unpack_negative_ack (WTP_PDU *pdu, WAPAddrTuple *addr_tuple)
static WAPEvent *	unpack_abort (WTP_PDU *pdu, WAPAddrTuple *addr_tuple)
static WAPEvent *	pack_error (WAPEvent *datagram)
List *	wtp_unpack_wdp_datagram (WAPEvent *datagram)
int	wtp_event_is_for_responder (WAPEvent *event)

Function Documentation

concatenated_message()

static int concatenated_message ( Octstr *  user_data )

static

Definition at line 434 of file wtp.c.

References octstr_get_char().

Referenced by wtp_unpack_wdp_datagram().

{
       return octstr_get_char(user_data, 0) == 0x00;
}

deduce_tid()

static int deduce_tid ( Octstr *  user_data )

static

Definition at line 429 of file wtp.c.

References octstr_get_bits().

Referenced by pack_error().

{ 
    return octstr_get_bits(user_data, 8, 16);
}

pack_error()

static WAPEvent * pack_error ( WAPEvent *  datagram )

static

Definition at line 316 of file wtp.c.

References deduce_tid(), gw_assert(), WAPEvent::type, WAPEvent::u, wap_addr_tuple_duplicate(), and wap_event_create.

Referenced by unpack_wdp_datagram_real().

{
    WAPEvent *event;

    gw_assert(datagram->type == T_DUnitdata_Ind);

    event = wap_event_create(RcvErrorPDU);
    event->u.RcvErrorPDU.tid = deduce_tid(datagram->u.T_DUnitdata_Ind.user_data);
    event->u.RcvErrorPDU.addr_tuple = 
    wap_addr_tuple_duplicate(datagram->u.T_DUnitdata_Ind.addr_tuple);

    return event;
}

truncated_datagram()

static int truncated_datagram ( WAPEvent *  event )

static

Definition at line 195 of file wtp.c.

References debug(), gw_assert(), octstr_len(), WAPEvent::type, WAPEvent::u, and wap_event_dump().

Referenced by unpack_wdp_datagram_real().

{
    gw_assert(dgram->type == T_DUnitdata_Ind);

    if (octstr_len(dgram->u.T_DUnitdata_Ind.user_data) < 3) {
        debug("wap.wtp", 0, "A too short PDU received");
        wap_event_dump(dgram);
        return 1;
    } else
        return 0;
}

unpack_abort()

static WAPEvent * unpack_abort ( WTP_PDU *  pdu, WAPAddrTuple *  addr_tuple  )

static

Definition at line 303 of file wtp.c.

References addr_tuple, wtp_pdu::u, wap_addr_tuple_duplicate(), and wap_event_create.

Referenced by unpack_wdp_datagram_real().

{
     WAPEvent *event;

     event = wap_event_create(RcvAbort);
     event->u.RcvAbort.tid = pdu->u.Abort.tid;
     event->u.RcvAbort.abort_type = pdu->u.Abort.abort_type;
     event->u.RcvAbort.abort_reason = pdu->u.Abort.abort_reason;
     event->u.RcvAbort.addr_tuple = wap_addr_tuple_duplicate(addr_tuple);

     return event;
}

unpack_ack()

static WAPEvent * unpack_ack ( WTP_PDU *  pdu, WAPAddrTuple *  addr_tuple  )

static

Definition at line 262 of file wtp.c.

References addr_tuple, wtp_tpi::data, gwlist_get(), gwlist_len(), octstr_get_bits(), wtp_pdu::options, TPI_PSN, wtp_tpi::type, wtp_pdu::u, wap_addr_tuple_duplicate(), and wap_event_create.

Referenced by unpack_wdp_datagram_real().

{
    WAPEvent *event;
    WTP_TPI *tpi;
    int i, num_tpis;

    event = wap_event_create(RcvAck);
    event->u.RcvAck.tid = pdu->u.Ack.tid;
    event->u.RcvAck.tid_ok = pdu->u.Ack.tidverify;
    event->u.RcvAck.rid = pdu->u.Ack.rid;
    event->u.RcvAck.addr_tuple = wap_addr_tuple_duplicate(addr_tuple);

    /* Set default to 0 because Ack on 1 piece message has no tpi */
    event->u.RcvAck.psn = 0;
    num_tpis = gwlist_len(pdu->options);

    for (i = 0; i < num_tpis; i++) {
        tpi = gwlist_get(pdu->options, i);
        if (tpi->type == TPI_PSN) {
            event->u.RcvAck.psn = octstr_get_bits(tpi->data,0,8);
            break;
        }
    }

    return event;
}

unpack_invoke()

static WAPEvent * unpack_invoke ( WTP_PDU *  pdu, WAPAddrTuple *  addr_tuple  )

static

Definition at line 207 of file wtp.c.

References addr_tuple, octstr_duplicate, wtp_pdu::u, wap_addr_tuple_duplicate(), and wap_event_create.

Referenced by unpack_wdp_datagram_real().

{
    WAPEvent *event;

    event = wap_event_create(RcvInvoke);
    event->u.RcvInvoke.user_data = 
        octstr_duplicate(pdu->u.Invoke.user_data);
    event->u.RcvInvoke.tcl = pdu->u.Invoke.class;
    event->u.RcvInvoke.tid = pdu->u.Invoke.tid;
    event->u.RcvInvoke.tid_new = pdu->u.Invoke.tidnew;
    event->u.RcvInvoke.rid = pdu->u.Invoke.rid;
    event->u.RcvInvoke.up_flag = pdu->u.Invoke.uack;
    event->u.RcvInvoke.no_cache_supported = 0;
    event->u.RcvInvoke.version = pdu->u.Invoke.version;
    event->u.RcvInvoke.gtr = pdu->u.Invoke.gtr;
    event->u.RcvInvoke.ttr = pdu->u.Invoke.ttr;
    event->u.RcvInvoke.addr_tuple = wap_addr_tuple_duplicate(addr_tuple);

    return event;
}

unpack_negative_ack()

static WAPEvent * unpack_negative_ack ( WTP_PDU *  pdu, WAPAddrTuple *  addr_tuple  )

static

Definition at line 289 of file wtp.c.

References addr_tuple, octstr_duplicate, wtp_pdu::u, wap_addr_tuple_duplicate(), and wap_event_create.

Referenced by unpack_wdp_datagram_real().

{
    WAPEvent *event;

    event = wap_event_create(RcvNegativeAck);
    event->u.RcvNegativeAck.tid = pdu->u.Negative_ack.tid;
    event->u.RcvNegativeAck.rid = pdu->u.Negative_ack.rid;
    event->u.RcvNegativeAck.nmissing = pdu->u.Negative_ack.nmissing;
    event->u.RcvNegativeAck.missing = octstr_duplicate(pdu->u.Negative_ack.missing);
    event->u.RcvNegativeAck.addr_tuple = wap_addr_tuple_duplicate(addr_tuple);
    
    return event;
}

unpack_result()

static WAPEvent * unpack_result ( WTP_PDU *  pdu, WAPAddrTuple *  addr_tuple  )

static

Definition at line 246 of file wtp.c.

References addr_tuple, octstr_duplicate, wtp_pdu::u, wap_addr_tuple_duplicate(), and wap_event_create.

Referenced by unpack_wdp_datagram_real().

{
    WAPEvent *event;

    event = wap_event_create(RcvResult);
    event->u.RcvResult.user_data = 
        octstr_duplicate(pdu->u.Result.user_data);
    event->u.RcvResult.tid = pdu->u.Result.tid;
    event->u.RcvResult.rid = pdu->u.Result.rid;
    event->u.RcvResult.gtr = pdu->u.Result.gtr;
    event->u.RcvResult.ttr = pdu->u.Result.ttr;
    event->u.RcvResult.addr_tuple = wap_addr_tuple_duplicate(addr_tuple);

    return event;
}

unpack_segmented_invoke()

static WAPEvent * unpack_segmented_invoke ( WTP_PDU *  pdu, WAPAddrTuple *  addr_tuple  )

static

Definition at line 228 of file wtp.c.

References addr_tuple, octstr_duplicate, wtp_pdu::u, wap_addr_tuple_duplicate(), and wap_event_create.

Referenced by unpack_wdp_datagram_real().

{
    WAPEvent *event;

    event = wap_event_create(RcvSegInvoke);
    event->u.RcvSegInvoke.user_data = 
        octstr_duplicate(pdu->u.Segmented_invoke.user_data);
    event->u.RcvSegInvoke.tid = pdu->u.Segmented_invoke.tid;
    event->u.RcvSegInvoke.rid = pdu->u.Segmented_invoke.rid;
    event->u.RcvSegInvoke.no_cache_supported = 0;
    event->u.RcvSegInvoke.gtr = pdu->u.Segmented_invoke.gtr;
    event->u.RcvSegInvoke.ttr = pdu->u.Segmented_invoke.ttr;
    event->u.RcvSegInvoke.psn = pdu->u.Segmented_invoke.psn;
    event->u.RcvSegInvoke.addr_tuple = wap_addr_tuple_duplicate(addr_tuple);

    return event;
}

unpack_wdp_datagram_real()

WAPEvent * unpack_wdp_datagram_real ( WAPEvent *  datagram )

static

Definition at line 342 of file wtp.c.

References debug(), error(), gw_assert(), pack_error(), truncated_datagram(), wtp_pdu::type, WAPEvent::type, WAPEvent::u, unpack_abort(), unpack_ack(), unpack_invoke(), unpack_negative_ack(), unpack_result(), unpack_segmented_invoke(), wap_event_assert(), wap_event_destroy(), wap_event_dump(), warning(), wtp_event_is_for_responder(), wtp_pdu_destroy(), and wtp_pdu_unpack().

Referenced by wtp_unpack_wdp_datagram().

{
    WTP_PDU *pdu;
    WAPEvent *event;
    Octstr *data;

    gw_assert(datagram->type == T_DUnitdata_Ind);

    data = datagram->u.T_DUnitdata_Ind.user_data;

    if (truncated_datagram(datagram)) {
        warning(0, "WTP: got a truncated datagram, ignoring");
        return NULL;
    }

    pdu = wtp_pdu_unpack(data);

    /*
     * wtp_pdu_unpack returned NULL, we have send here a rcv error event,
     * but now we silently drop the packet. Because we can't figure out
     * in the pack_error() call if the TID value and hence the direction
     * inditation is really for initiator or responder. 
     */
    if (pdu == NULL) {
        error(0, "WTP: cannot unpack pdu, dropping packet.");
        return NULL;
    }           

    event = NULL;

    switch (pdu->type) {

    case Invoke:
        event = unpack_invoke(pdu, datagram->u.T_DUnitdata_Ind.addr_tuple);
        /* if an WTP initiator gets invoke, it would be an illegal pdu. */
        if (!wtp_event_is_for_responder(event)){
            debug("wap.wtp", 0, "WTP: Invoke when initiator. Message was");
            wap_event_destroy(event);
            event = pack_error(datagram);
        }
        break;

    case Segmented_invoke:
        event = unpack_segmented_invoke(pdu, datagram->u.T_DUnitdata_Ind.addr_tuple);
        break;

    case Result:
        event = unpack_result(pdu, datagram->u.T_DUnitdata_Ind.addr_tuple);
        /* if an WTP responder gets result, it would be an illegal pdu. */
        if (wtp_event_is_for_responder(event)){
            debug("wap.wtp", 0, "WTP: Result when responder. Message was");
            wap_event_destroy(event);
            event = pack_error(datagram);
        }
        break;

    case Ack:
        event = unpack_ack(pdu, datagram->u.T_DUnitdata_Ind.addr_tuple);    
        break;

    case Negative_ack:
        event = unpack_negative_ack(pdu, datagram->u.T_DUnitdata_Ind.addr_tuple);    
        break;

    case Abort:
        event = unpack_abort(pdu, datagram->u.T_DUnitdata_Ind.addr_tuple);
        break;         

    default:
        event = pack_error(datagram);
        debug("wap.wtp", 0, "WTP: Unhandled PDU type. Message was");
            wap_event_dump(datagram);
        return event;
    }

    wtp_pdu_destroy(pdu);
    
    wap_event_assert(event);
    return event;
}

wtp_event_is_for_responder()

int wtp_event_is_for_responder

(

WAPEvent *

event

)

Definition at line 156 of file wtp.c.

References error(), INITIATOR_TID_LIMIT, WAPEvent::type, and wap_event_dump().

Referenced by unpack_wdp_datagram_real(), wap_dispatch_datagram(), and wtp_event_dump().

{

     switch(event->type){
          
     case RcvInvoke:
         return event->u.RcvInvoke.tid < INITIATOR_TID_LIMIT;

     case RcvSegInvoke:
        return event->u.RcvSegInvoke.tid < INITIATOR_TID_LIMIT;

     case RcvResult:
         return event->u.RcvResult.tid < INITIATOR_TID_LIMIT;

     case RcvAck:
        return event->u.RcvAck.tid < INITIATOR_TID_LIMIT;

     case RcvNegativeAck:
        return event->u.RcvNegativeAck.tid < INITIATOR_TID_LIMIT;

     case RcvAbort:
        return event->u.RcvAbort.tid < INITIATOR_TID_LIMIT;

     case RcvErrorPDU:
        return event->u.RcvErrorPDU.tid < INITIATOR_TID_LIMIT;

     default:
        error(1, "Received an erroneous PDU corresponding an event");
        wap_event_dump(event);
        return -1;
     }
}

wtp_unpack_wdp_datagram()

List* wtp_unpack_wdp_datagram

(

WAPEvent *

datagram

)

Definition at line 98 of file wtp.c.

References concatenated_message(), gw_assert(), GW_WARNING, gwlist_append(), gwlist_create, octstr_copy, octstr_delete(), octstr_destroy(), octstr_dump, octstr_duplicate, octstr_get_bits(), octstr_get_char(), octstr_len(), WAPEvent::type, WAPEvent::u, unpack_wdp_datagram_real(), wap_event_assert(), wap_event_destroy(), wap_event_duplicate(), and warning().

Referenced by wap_dispatch_datagram(), and wtp_event_dump().

{
     List *events = NULL;
     WAPEvent *event = NULL;
     WAPEvent *subdgram = NULL;
     Octstr *data = NULL;
     long pdu_len;

     gw_assert(datagram->type == T_DUnitdata_Ind);

     events = gwlist_create();
        
     if (concatenated_message(datagram->u.T_DUnitdata_Ind.user_data)) {
        data = octstr_duplicate(datagram->u.T_DUnitdata_Ind.user_data);
        octstr_delete(data, 0, 1);

        while (octstr_len(data) != 0) {

            if (octstr_get_bits(data, 0, 1) == 0) {
                pdu_len = octstr_get_char(data, 0);
                octstr_delete(data, 0, 1);
            } else {
                pdu_len = octstr_get_bits(data, 1, 15);
                octstr_delete(data, 0, 2);
            }
      
            subdgram = wap_event_duplicate(datagram);
            octstr_destroy(subdgram->u.T_DUnitdata_Ind.user_data);
            subdgram->u.T_DUnitdata_Ind.user_data = octstr_copy(data, 0, pdu_len);
            wap_event_assert(subdgram);
            if ((event = unpack_wdp_datagram_real(subdgram)) != NULL) {
                wap_event_assert(event);
                gwlist_append(events, event);
            }
            octstr_delete(data, 0, pdu_len);
            wap_event_destroy(subdgram);
        }

        octstr_destroy(data);

    } else if ((event = unpack_wdp_datagram_real(datagram)) != NULL) { 
        wap_event_assert(event);
        gwlist_append(events, event);
    } else {
        warning(0, "WTP: Dropping unhandled datagram data:");
        octstr_dump(datagram->u.T_DUnitdata_Ind.user_data, 0, GW_WARNING);
    }

    return events;
}