wsp_unit.c File Reference

#include <string.h>
#include "gwlib/gwlib.h"
#include "wsp.h"
#include "wsp_pdu.h"
#include "wsp_headers.h"
#include "wap_events.h"
#include "wsp_strings.h"
#include "wap.h"

Go to the source code of this file.

Enumerations
enum	{ limbo, running, terminating }

Functions
static void	main_thread (void *)
static WAPEvent *	pack_into_result_datagram (WAPEvent *event)
static WAPEvent *	pack_into_push_datagram (WAPEvent *event)
void	wsp_unit_init (wap_dispatch_func_t *datagram_dispatch, wap_dispatch_func_t *application_dispatch)
void	wsp_unit_shutdown (void)
void	wsp_unit_dispatch_event (WAPEvent *event)
static WAPEvent *	unpack_datagram (WAPEvent *datagram)

Variables
static enum { ... }	run_status = limbo
static wap_dispatch_func_t *	dispatch_to_wdp
static wap_dispatch_func_t *	dispatch_to_appl
static List *	queue = NULL

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
limbo
running
terminating

Definition at line 84 of file wsp_unit.c.

{ limbo, running, terminating } run_status = limbo;

Function Documentation

main_thread()

static void main_thread ( void *  arg )

static

Definition at line 217 of file wsp_unit.c.

References debug(), dispatch_to_appl, dispatch_to_wdp, gwlist_consume(), pack_into_push_datagram(), pack_into_result_datagram(), queue, run_status, running, WAPEvent::type, unpack_datagram(), wap_event_assert(), wap_event_destroy(), and warning().

Referenced by wsp_unit_init(), and wsp_unit_shutdown().

{
    WAPEvent *e;
    WAPEvent *newevent;
    
    while (run_status == running && (e = gwlist_consume(queue)) != NULL) {
        debug("wap.wsp.unit", 0, "WSP (UNIT): event arrived");
        wap_event_assert(e);
        switch (e->type) {
        case T_DUnitdata_Ind:
            newevent = unpack_datagram(e);
            if (newevent != NULL)
                dispatch_to_appl(newevent);
            break;

        case S_Unit_MethodResult_Req:
            newevent = pack_into_result_datagram(e);
            if (newevent != NULL)
                dispatch_to_wdp(newevent);
            break;

        case S_Unit_Push_Req:
            newevent = pack_into_push_datagram(e);
            if (newevent != NULL)
                dispatch_to_wdp(newevent);
            debug("wsp.unit", 0, "WSP (UNIT): delivering to wdp");
            break;
    
        default:
            warning(0, "WSP UNIT: Unknown event type %d", e->type);
            break;
        }
        wap_event_destroy(e);
    }
}

pack_into_push_datagram()

static WAPEvent * pack_into_push_datagram ( WAPEvent *  event )

static

Definition at line 298 of file wsp_unit.c.

References debug(), gw_assert(), http_header_add(), octstr_duplicate, octstr_insert_data(), WAPEvent::type, WAPEvent::u, wsp_pdu::u, wap_addr_tuple_duplicate(), wap_event_create, WSP_1_3, wsp_headers_pack(), wsp_pdu_create(), wsp_pdu_destroy(), wsp_pdu_dump(), and wsp_pdu_pack().

Referenced by main_thread().

{
    WAPEvent *datagram;
    WSP_PDU *pdu;
    Octstr *ospdu;
    unsigned char push_id;

    gw_assert(event->type == S_Unit_Push_Req);
    debug("wap.wsp.unit", 0, "WSP_UNIT: Connectionless push accepted");

    http_header_add(event->u.S_Unit_Push_Req.push_headers,
            "Encoding-Version", "1.3");

    pdu = wsp_pdu_create(Push);
    pdu->u.Push.headers = wsp_headers_pack(
            event->u.S_Unit_Push_Req.push_headers, 1, WSP_1_3);
    pdu->u.Push.data = octstr_duplicate(
            event->u.S_Unit_Push_Req.push_body);
    wsp_pdu_dump(pdu, 0);
    ospdu = wsp_pdu_pack(pdu);
    wsp_pdu_destroy(pdu);
    if (ospdu == NULL)
        return NULL;

    push_id = event->u.S_Unit_Push_Req.push_id;
    octstr_insert_data(ospdu, 0, (char *)&push_id, 1);

    datagram = wap_event_create(T_DUnitdata_Req);

    datagram->u.T_DUnitdata_Req.addr_tuple =
            wap_addr_tuple_duplicate(event->u.S_Unit_Push_Req.addr_tuple);
    datagram->u.T_DUnitdata_Req.address_type =
            event->u.S_Unit_Push_Req.address_type;
    if (event->u.S_Unit_Push_Req.smsc_id != NULL)
        datagram->u.T_DUnitdata_Req.smsc_id =
                octstr_duplicate(event->u.S_Unit_Push_Req.smsc_id);
    else
        datagram->u.T_DUnitdata_Req.smsc_id = NULL;
    if (event->u.S_Unit_Push_Req.dlr_url != NULL)
        datagram->u.T_DUnitdata_Req.dlr_url =
                octstr_duplicate(event->u.S_Unit_Push_Req.dlr_url);
    else
        datagram->u.T_DUnitdata_Req.dlr_url = NULL;
    datagram->u.T_DUnitdata_Req.dlr_mask = event->u.S_Unit_Push_Req.dlr_mask;
    if (event->u.S_Unit_Push_Req.smsbox_id != NULL)
        datagram->u.T_DUnitdata_Req.smsbox_id =
                octstr_duplicate(event->u.S_Unit_Push_Req.smsbox_id);
    else
        datagram->u.T_DUnitdata_Req.smsbox_id = NULL;
    datagram->u.T_DUnitdata_Req.service_name =
            octstr_duplicate(event->u.S_Unit_Push_Req.service_name);

    datagram->u.T_DUnitdata_Req.user_data = ospdu;
        
    return datagram;
}

pack_into_result_datagram()

static WAPEvent * pack_into_result_datagram ( WAPEvent *  event )

static

Definition at line 261 of file wsp_unit.c.

References gw_assert(), http_header_add(), octstr_duplicate, octstr_insert_data(), WAPEvent::type, WAPEvent::u, wsp_pdu::u, wap_addr_tuple_duplicate(), wap_event_create, WSP_1_3, wsp_convert_http_status_to_wsp_status(), wsp_headers_pack(), wsp_pdu_create(), wsp_pdu_destroy(), and wsp_pdu_pack().

Referenced by main_thread().

{
    WAPEvent *datagram;
    struct S_Unit_MethodResult_Req *p;
    WSP_PDU *pdu;
    Octstr *ospdu;
    unsigned char tid;
    
    gw_assert(event->type == S_Unit_MethodResult_Req);
    p = &event->u.S_Unit_MethodResult_Req;

    http_header_add(p->response_headers, "Encoding-Version", "1.3");

    pdu = wsp_pdu_create(Reply);
    pdu->u.Reply.status = wsp_convert_http_status_to_wsp_status(p->status);
    pdu->u.Reply.headers = wsp_headers_pack(p->response_headers, 1, WSP_1_3);
    pdu->u.Reply.data = octstr_duplicate(p->response_body);
    ospdu = wsp_pdu_pack(pdu);
    wsp_pdu_destroy(pdu);
    if (ospdu == NULL)
        return NULL;

    tid = p->transaction_id;
    octstr_insert_data(ospdu, 0, (char *)&tid, 1);

    datagram = wap_event_create(T_DUnitdata_Req);
    datagram->u.T_DUnitdata_Req.addr_tuple =
            wap_addr_tuple_duplicate(p->addr_tuple);
    datagram->u.T_DUnitdata_Req.user_data = ospdu;

    return datagram;
}

unpack_datagram()

static WAPEvent* unpack_datagram ( WAPEvent *  datagram )

static

Definition at line 131 of file wsp_unit.c.

References debug(), error(), GET_METHODS, gw_assert(), method, method_name, octstr_delete(), octstr_destroy(), octstr_duplicate, octstr_format(), octstr_get_char(), octstr_len(), POST_METHODS, wsp_pdu::type, WAPEvent::type, WAPEvent::u, wsp_pdu::u, wap_addr_tuple_duplicate(), wap_event_create, wap_event_destroy(), warning(), wsp_headers_unpack(), wsp_pdu_destroy(), and wsp_pdu_unpack().

Referenced by main_thread().

{
    WAPEvent *event;
    Octstr *os;
    WSP_PDU *pdu;
    long tid_byte;
    int method;
    Octstr *method_name;

    gw_assert(datagram->type == T_DUnitdata_Ind);
    
    os = NULL;
    pdu = NULL;
    event = NULL;

    os = octstr_duplicate(datagram->u.T_DUnitdata_Ind.user_data);
    if (os && octstr_len(os) == 0) {
        warning(0, "WSP UNIT: Empty datagram.");
        goto error;
    }
    
    tid_byte = octstr_get_char(os, 0);
    octstr_delete(os, 0, 1);
    
    pdu = wsp_pdu_unpack(os);
    if (pdu == NULL)
        goto error;
    
    if (pdu->type != Get && pdu->type != Post) {
        warning(0, "WSP UNIT: Unsupported PDU type %d", pdu->type);
        goto error;
    }
        
    event = wap_event_create(S_Unit_MethodInvoke_Ind);
    event->u.S_Unit_MethodInvoke_Ind.addr_tuple = wap_addr_tuple_duplicate(
            datagram->u.T_DUnitdata_Ind.addr_tuple);
    event->u.S_Unit_MethodInvoke_Ind.transaction_id = tid_byte;
        
    switch (pdu->type) {
    case Get:
        debug("wap.wsp", 0, "Connectionless Get request received.");
        method = GET_METHODS + pdu->u.Get.subtype;
        event->u.S_Unit_MethodInvoke_Ind.request_uri = 
                octstr_duplicate(pdu->u.Get.uri);
        event->u.S_Unit_MethodInvoke_Ind.request_headers =
                wsp_headers_unpack(pdu->u.Get.headers, 0);
        event->u.S_Unit_MethodInvoke_Ind.request_body = NULL;
        break;

    case Post:
        debug("wap.wsp", 0, "Connectionless Post request received.");
        method = POST_METHODS + pdu->u.Post.subtype;
        event->u.S_Unit_MethodInvoke_Ind.request_uri = 
                octstr_duplicate(pdu->u.Post.uri);
        event->u.S_Unit_MethodInvoke_Ind.request_headers = 
                wsp_headers_unpack(pdu->u.Post.headers, 1);
        event->u.S_Unit_MethodInvoke_Ind.request_body = 
                octstr_duplicate(pdu->u.Post.data);
        break;

    default:
        warning(0, "WSP UNIT: Unsupported PDU type %d", pdu->type);
        goto error;
    }

    method_name = wsp_method_to_string(method);
    if (method_name == NULL)
        method_name = octstr_format("UNKNOWN%02X", method);
    event->u.S_Unit_MethodInvoke_Ind.method = method_name;

    octstr_destroy(os);
    wsp_pdu_destroy(pdu);
    return event;

error:
    octstr_destroy(os);
    wsp_pdu_destroy(pdu);
    wap_event_destroy(event);
    return NULL;
}

wsp_unit_dispatch_event()

void wsp_unit_dispatch_event

(

WAPEvent *

event

)

Definition at line 124 of file wsp_unit.c.

References gwlist_produce(), queue, and wap_event_assert().

Referenced by main(), return_unit_reply(), and wap_dispatch_datagram().

{
    wap_event_assert(event);
    gwlist_produce(queue, event);
}

wsp_unit_init()

void wsp_unit_init	(	wap_dispatch_func_t *	datagram_dispatch,
		wap_dispatch_func_t *	application_dispatch
	)

Definition at line 100 of file wsp_unit.c.

References dispatch_to_appl, dispatch_to_wdp, gwlist_add_producer(), gwlist_create, gwthread_create, main_thread(), queue, run_status, running, and wsp_strings_init().

Referenced by main().

{
    queue = gwlist_create();
    gwlist_add_producer(queue);
    dispatch_to_wdp = datagram_dispatch;
    dispatch_to_appl = application_dispatch;
    wsp_strings_init();
    run_status = running;
    gwthread_create(main_thread, NULL);
}

wsp_unit_shutdown()

void wsp_unit_shutdown

(

void

)

Definition at line 113 of file wsp_unit.c.

References gw_assert(), gwlist_destroy(), gwlist_remove_producer(), gwthread_join_every(), main_thread(), queue, run_status, running, terminating, wap_event_destroy_item(), and wsp_strings_shutdown().

Referenced by main().

{
    gw_assert(run_status == running);
    run_status = terminating;
    gwlist_remove_producer(queue);
    gwthread_join_every(main_thread);
    gwlist_destroy(queue, wap_event_destroy_item);
    wsp_strings_shutdown();
}

Variable Documentation

dispatch_to_appl

wap_dispatch_func_t* dispatch_to_appl

static

Definition at line 87 of file wsp_unit.c.

Referenced by main_thread(), and wsp_unit_init().

dispatch_to_wdp

wap_dispatch_func_t* dispatch_to_wdp

static

Definition at line 86 of file wsp_unit.c.

Referenced by main_thread(), and wsp_unit_init().

queue

List* queue = NULL

static

Definition at line 89 of file wsp_unit.c.

Referenced by main_thread(), wsp_unit_dispatch_event(), wsp_unit_init(), and wsp_unit_shutdown().

run_status

enum { ... } run_status

Referenced by main_thread(), wsp_unit_init(), and wsp_unit_shutdown().