wap_push_ota.c File Reference

#include <errno.h>
#include "wap_push_ota.h"
#include "gwlib/gwlib.h"
#include "wap/wsp.h"
#include "wap/wsp_strings.h"
#include "wap/wsp_pdu.h"

Go to the source code of this file.

Data Structures
struct	BearerboxAddress

Typedefs
typedef struct BearerboxAddress	BearerboxAddress

Enumerations
enum	{ limbo, running, terminating }

Functions
static void	main_thread (void *arg)
static void	handle_ota_event (WAPEvent *e)
static void	make_session_request (WAPEvent *e)
static void	make_push_request (WAPEvent *e)
static void	make_confirmed_push_request (WAPEvent *e)
static void	make_unit_push_request (WAPEvent *e)
static void	abort_push (WAPEvent *e)
static List *	add_push_flag (WAPEvent *e)
static void	check_session_request_headers (List *headers)
static Octstr *	pack_sia (List *headers)
static void	flags_assert (WAPEvent *e)
static void	reason_assert (long reason)
static Octstr *	pack_server_address (void)
static Octstr *	pack_appid_list (List *headers)
static Octstr *	name (Octstr *os)
static BearerboxAddress *	bearerbox_address_create (void)
static void	bearerbox_address_destroy (BearerboxAddress *ba)
void	wap_push_ota_init (wap_dispatch_func_t *wsp_dispatch, wap_dispatch_func_t *wsp_unit_dispatch)
void	wap_push_ota_shutdown (void)
void	wap_push_ota_dispatch_event (WAPEvent *e)
void	wap_push_ota_bb_address_set (Octstr *in)

Variables
static enum { ... }	run_status = limbo
static BearerboxAddress *	bearerbox = NULL
static List *	ota_queue = NULL
static wap_dispatch_func_t *	dispatch_to_wsp
static wap_dispatch_func_t *	dispatch_to_wsp_unit

Typedef Documentation

BearerboxAddress

typedef struct BearerboxAddress BearerboxAddress

Definition at line 110 of file wap_push_ota.c.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
limbo
running
terminating

Definition at line 101 of file wap_push_ota.c.

{limbo, running, terminating} run_status = limbo;

Function Documentation

abort_push()

static void abort_push ( WAPEvent *  e )

static

Definition at line 408 of file wap_push_ota.c.

References dispatch_to_wsp, gw_assert(), reason_assert(), WAPEvent::type, WAPEvent::u, and wap_event_create.

Referenced by handle_ota_event().

{
    WAPEvent *wsp_event;
    long reason;
    
    reason = e->u.Po_PushAbort_Req.reason;
    gw_assert(e->type == Po_PushAbort_Req);
    reason_assert(reason);

    wsp_event = wap_event_create(S_PushAbort_Req);
    wsp_event->u.S_PushAbort_Req.push_id = e->u.Po_PushAbort_Req.push_id;
    wsp_event->u.S_PushAbort_Req.reason = reason;
    wsp_event->u.S_PushAbort_Req.session_handle = 
        e->u.Po_PushAbort_Req.session_id;

    dispatch_to_wsp(wsp_event);    
}

add_push_flag()

static List * add_push_flag ( WAPEvent *  e )

static

Definition at line 430 of file wap_push_ota.c.

References debug(), flags_assert(), http_header_add(), http_header_duplicate(), octstr_destroy(), octstr_format(), octstr_get_cstr, WAPEvent::type, WAPEvent::u, and wap_event_dump().

Referenced by make_confirmed_push_request(), make_push_request(), and make_unit_push_request().

{
    int push_flag,
        trusted,
        authenticated,
        last;

    Octstr *buf;
    List *headers;

    flags_assert(e);

    if (e->type == Po_Unit_Push_Req) {
        trusted = e->u.Po_Unit_Push_Req.trusted << 1;
        authenticated = e->u.Po_Unit_Push_Req.authenticated;
        last = e->u.Po_Unit_Push_Req.last << 2;

        headers = http_header_duplicate(e->u.Po_Unit_Push_Req.push_headers);

    } else if (e->type == Po_Push_Req) {
        trusted = e->u.Po_Push_Req.trusted << 1;
        authenticated = e->u.Po_Push_Req.authenticated;
        last = e->u.Po_Push_Req.last << 2;

        headers = http_header_duplicate(e->u.Po_Push_Req.push_headers);

    } else if (e->type == Po_ConfirmedPush_Req) {
        trusted = e->u.Po_ConfirmedPush_Req.trusted << 1;
        authenticated = e->u.Po_ConfirmedPush_Req.authenticated;
        last = e->u.Po_ConfirmedPush_Req.last << 2;

        headers = http_header_duplicate(
            e->u.Po_ConfirmedPush_Req.push_headers);

    } else {
        debug("wap.ota", 0, "OTA: no push flag when the event is: \n");
        wap_event_dump(e);
        return NULL;
    }

    push_flag = 0;
    push_flag = push_flag | authenticated | trusted | last;
    
    if (push_flag) {
    buf = octstr_format("%d", push_flag);
    http_header_add(headers, "Push-Flag", octstr_get_cstr(buf)); 
    octstr_destroy(buf);
    }

    return headers;
}

bearerbox_address_create()

static BearerboxAddress * bearerbox_address_create ( void  )

static

Definition at line 634 of file wap_push_ota.c.

References BearerboxAddress::address, BearerboxAddress::mutex, and mutex_create.

Referenced by wap_push_ota_init().

{
    BearerboxAddress *ba;    

    ba = gw_malloc(sizeof(BearerboxAddress));
    ba->mutex = mutex_create();
    ba->address = NULL;
    
    return ba;
}

bearerbox_address_destroy()

static void bearerbox_address_destroy ( BearerboxAddress *  ba )

static

Definition at line 645 of file wap_push_ota.c.

References BearerboxAddress::address, BearerboxAddress::mutex, mutex_destroy(), and octstr_destroy().

Referenced by wap_push_ota_shutdown().

{
    if (ba == NULL)
        return;

    octstr_destroy(ba->address);
    mutex_destroy(ba->mutex);
    gw_free(ba);
}

check_session_request_headers()

static void check_session_request_headers ( List *  headers )

static

Definition at line 526 of file wap_push_ota.c.

References http_header_add(), and http_type_accepted().

Referenced by make_session_request().

{
    if (!http_type_accepted(headers, "application/wnd.wap.sia"))
         http_header_add(headers, "Content-Type", "application/vnd.wap.sia"); 
}

flags_assert()

static void flags_assert ( WAPEvent *  e )

static

Definition at line 482 of file wap_push_ota.c.

References gw_assert(), WAPEvent::type, and WAPEvent::u.

Referenced by add_push_flag().

{
    if (e->type == Po_Unit_Push_Req) {
        gw_assert(e->u.Po_Unit_Push_Req.trusted == 0 || 
            e->u.Po_Unit_Push_Req.trusted == 1);
        gw_assert(e->u.Po_Unit_Push_Req.authenticated == 0 || 
            e->u.Po_Unit_Push_Req.authenticated == 1);
        gw_assert(e->u.Po_Unit_Push_Req.last == 0 || 
            e->u.Po_Unit_Push_Req.last == 1);

    } else if (e->type == Po_Push_Req) {
        gw_assert(e->u.Po_Push_Req.trusted == 0 || 
            e->u.Po_Push_Req.trusted == 1);
        gw_assert(e->u.Po_Push_Req.authenticated == 0 || 
            e->u.Po_Push_Req.authenticated == 1);
        gw_assert(e->u.Po_Push_Req.last == 0 || 
            e->u.Po_Push_Req.last == 1);

    } else if (e->type == Po_ConfirmedPush_Req) {
        gw_assert(e->u.Po_ConfirmedPush_Req.trusted == 0 || 
            e->u.Po_ConfirmedPush_Req.trusted == 1);
        gw_assert(e->u.Po_ConfirmedPush_Req.authenticated == 0 || 
            e->u.Po_ConfirmedPush_Req.authenticated == 1);
        gw_assert(e->u.Po_ConfirmedPush_Req.last == 0 || 
            e->u.Po_ConfirmedPush_Req.last == 1);
    }
}

handle_ota_event()

static void handle_ota_event ( WAPEvent *  e )

static

Definition at line 227 of file wap_push_ota.c.

References abort_push(), debug(), make_confirmed_push_request(), make_push_request(), make_session_request(), make_unit_push_request(), WAPEvent::type, wap_event_destroy(), and wap_event_dump().

Referenced by main_thread().

{
    debug("wap.push.ota", 0, "OTA: event arrived");

    switch (e->type) {
    case Pom_SessionRequest_Req:
        make_session_request(e);
    break;

    case Po_Push_Req:
        make_push_request(e);
    break;

    case Po_ConfirmedPush_Req:
        make_confirmed_push_request(e);
    break;

    case Po_Unit_Push_Req:
        make_unit_push_request(e);
    break;

    case Po_PushAbort_Req:
        abort_push(e);
    break;

    default:
        debug("wap.push.ota", 0, "OTA: unhandled event");
        wap_event_dump(e);
    break;
    }

    wap_event_destroy(e);
}

main_thread()

static void main_thread ( void *  arg )

static

Definition at line 217 of file wap_push_ota.c.

References gwlist_consume(), handle_ota_event(), ota_queue, run_status, and running.

Referenced by wap_push_ota_init(), and wap_push_ota_shutdown().

{
    WAPEvent *e;

    while (run_status == running && (e = gwlist_consume(ota_queue)) != NULL) {
        handle_ota_event(e);
    } 

}

make_confirmed_push_request()

static void make_confirmed_push_request ( WAPEvent *  e )

static

Definition at line 329 of file wap_push_ota.c.

References add_push_flag(), debug(), dispatch_to_wsp, gw_assert(), octstr_duplicate, WAPEvent::type, WAPEvent::u, and wap_event_create.

Referenced by handle_ota_event().

{
    WAPEvent *wsp_event;
    List *push_headers;

    gw_assert(e->type == Po_ConfirmedPush_Req);
    push_headers = add_push_flag(e);
    
    wsp_event = wap_event_create(S_ConfirmedPush_Req);
    wsp_event->u.S_ConfirmedPush_Req.server_push_id = 
        e->u.Po_ConfirmedPush_Req.server_push_id;
    wsp_event->u.S_ConfirmedPush_Req.push_headers = push_headers;

    if (e->u.Po_ConfirmedPush_Req.push_body != NULL)
        wsp_event->u.S_ConfirmedPush_Req.push_body =
            octstr_duplicate(e->u.Po_ConfirmedPush_Req.push_body);
    else
        wsp_event->u.S_ConfirmedPush_Req.push_body = NULL;
     
    wsp_event->u.S_ConfirmedPush_Req.session_id = 
        e->u.Po_ConfirmedPush_Req.session_handle;
    debug("wap.push.ota", 0, "OTA: making confirmed push request to wsp");
    
    dispatch_to_wsp(wsp_event);
}

make_push_request()

static void make_push_request ( WAPEvent *  e )

static

Definition at line 309 of file wap_push_ota.c.

References add_push_flag(), dispatch_to_wsp, gw_assert(), octstr_duplicate, WAPEvent::type, WAPEvent::u, and wap_event_create.

Referenced by handle_ota_event().

{
    WAPEvent *wsp_event;
    List *push_headers;

    gw_assert(e->type == Po_Push_Req);
    push_headers = add_push_flag(e);
    
    wsp_event = wap_event_create(S_Push_Req);
    wsp_event->u.S_Push_Req.push_headers = push_headers;
    if (e->u.Po_Push_Req.push_body != NULL)
        wsp_event->u.S_Push_Req.push_body = 
            octstr_duplicate(e->u.Po_Push_Req.push_body);
    else
        wsp_event->u.S_Push_Req.push_body = NULL;
    wsp_event->u.S_Push_Req.session_id = e->u.Po_Push_Req.session_handle;

    dispatch_to_wsp(wsp_event);
}

make_session_request()

static void make_session_request ( WAPEvent *  e )

static

Definition at line 261 of file wap_push_ota.c.

References check_session_request_headers(), debug(), dispatch_to_wsp_unit, gw_assert(), http_header_duplicate(), http_header_find_all(), octstr_duplicate, pack_sia(), WAPEvent::type, WAPEvent::u, wap_addr_tuple_duplicate(), and wap_event_create.

Referenced by handle_ota_event().

{
    WAPEvent *wsp_event;
    List *appid_headers, *push_headers;

    gw_assert(e->type == Pom_SessionRequest_Req);
    push_headers = e->u.Pom_SessionRequest_Req.push_headers;

    check_session_request_headers(push_headers);

    wsp_event = wap_event_create(S_Unit_Push_Req);
    wsp_event->u.S_Unit_Push_Req.address_type =
        e->u.Pom_SessionRequest_Req.address_type;
    if (e->u.Pom_SessionRequest_Req.smsc_id != NULL)
        wsp_event->u.S_Unit_Push_Req.smsc_id =
            octstr_duplicate(e->u.Pom_SessionRequest_Req.smsc_id);
    else
        wsp_event->u.S_Unit_Push_Req.smsc_id = NULL;
    if (e->u.Pom_SessionRequest_Req.dlr_url != NULL)
        wsp_event->u.S_Unit_Push_Req.dlr_url =
            octstr_duplicate(e->u.Pom_SessionRequest_Req.dlr_url);
    else
        wsp_event->u.S_Unit_Push_Req.dlr_url = NULL;
    wsp_event->u.S_Unit_Push_Req.dlr_mask = e->u.Pom_SessionRequest_Req.dlr_mask;
    if (e->u.Pom_SessionRequest_Req.smsbox_id != NULL)
        wsp_event->u.S_Unit_Push_Req.smsbox_id =
            octstr_duplicate(e->u.Pom_SessionRequest_Req.smsbox_id);
    else
        wsp_event->u.S_Unit_Push_Req.smsbox_id = NULL;    
    wsp_event->u.S_Unit_Push_Req.service_name = 
        octstr_duplicate(e->u.Pom_SessionRequest_Req.service_name);

    wsp_event->u.S_Unit_Push_Req.push_id = 
        e->u.Pom_SessionRequest_Req.push_id;
    wsp_event->u.S_Unit_Push_Req.addr_tuple = 
        wap_addr_tuple_duplicate(e->u.Pom_SessionRequest_Req.addr_tuple);
    wsp_event->u.S_Unit_Push_Req.push_headers = 
        http_header_duplicate(push_headers);

    appid_headers = http_header_find_all(push_headers, "X-WAP-Application-Id");
    wsp_event->u.S_Unit_Push_Req.push_body = pack_sia(appid_headers);
    
    debug("wap.push.ota", 0, "OTA: making a connectionless session request for"
          " creating a session");

    dispatch_to_wsp_unit(wsp_event);
}

make_unit_push_request()

static void make_unit_push_request ( WAPEvent *  e )

static

Definition at line 355 of file wap_push_ota.c.

References add_push_flag(), debug(), dispatch_to_wsp_unit, dlr_url, gw_assert(), octstr_duplicate, service_name, smsbox_id, smsc_id, WAPEvent::type, WAPEvent::u, wap_addr_tuple_duplicate(), and wap_event_create.

Referenced by handle_ota_event().

{
    WAPEvent *wsp_event;
    List *push_headers;
    Octstr *smsc_id;
    Octstr *dlr_url;
    Octstr *smsbox_id;
    Octstr *push_body;
    Octstr *service_name;

    gw_assert(e->type == Po_Unit_Push_Req);
    gw_assert(e->u.Po_Unit_Push_Req.addr_tuple);
    gw_assert(e->u.Po_Unit_Push_Req.service_name);

    smsc_id = octstr_duplicate(e->u.Po_Unit_Push_Req.smsc_id); 
    dlr_url = octstr_duplicate(e->u.Po_Unit_Push_Req.dlr_url);
    smsbox_id = octstr_duplicate(e->u.Po_Unit_Push_Req.smsbox_id);
    push_body = octstr_duplicate(e->u.Po_Unit_Push_Req.push_body);
    service_name = octstr_duplicate(e->u.Po_Unit_Push_Req.service_name); 
    push_headers = add_push_flag(e);

    wsp_event = wap_event_create(S_Unit_Push_Req);
    wsp_event->u.S_Unit_Push_Req.addr_tuple = 
        wap_addr_tuple_duplicate(e->u.Po_Unit_Push_Req.addr_tuple);
    wsp_event->u.S_Unit_Push_Req.push_id = e->u.Po_Unit_Push_Req.push_id;
    wsp_event->u.S_Unit_Push_Req.push_headers = push_headers;

    wsp_event->u.S_Unit_Push_Req.address_type = 
        e->u.Po_Unit_Push_Req.address_type;
    if (smsc_id != NULL)
        wsp_event->u.S_Unit_Push_Req.smsc_id = smsc_id;
    else
        wsp_event->u.S_Unit_Push_Req.smsc_id = NULL;  
    if (dlr_url != NULL)      
        wsp_event->u.S_Unit_Push_Req.dlr_url = dlr_url;        
    else  
        wsp_event->u.S_Unit_Push_Req.dlr_url = NULL;      
    wsp_event->u.S_Unit_Push_Req.dlr_mask = e->u.Po_Unit_Push_Req.dlr_mask;            
    if (smsbox_id != NULL)
        wsp_event->u.S_Unit_Push_Req.smsbox_id = smsbox_id;
    else
        wsp_event->u.S_Unit_Push_Req.smsbox_id = NULL;
    wsp_event->u.S_Unit_Push_Req.service_name = service_name;
    if (push_body != NULL)
        wsp_event->u.S_Unit_Push_Req.push_body = push_body;
    else
        wsp_event->u.S_Unit_Push_Req.push_body = NULL;

    dispatch_to_wsp_unit(wsp_event);
    debug("wap.push.ota", 0, "OTA: made connectionless session service"
          " request");
}

name()

static Octstr* name ( Octstr *  os )

static

Definition at line 626 of file wap_push_ota.c.

References get_official_ip(), octstr_compare(), octstr_duplicate, and octstr_imm().

Referenced by wap_push_ota_bb_address_set().

{
    if (octstr_compare(in, octstr_imm("localhost")) != 0)
        return octstr_duplicate(in);
    else
        return octstr_duplicate(get_official_ip());
}

pack_appid_list()

static Octstr * pack_appid_list ( List *  headers )

static

Definition at line 563 of file wap_push_ota.c.

References gw_assert(), gwlist_len(), http_header_get(), octstr_compare(), octstr_create, octstr_destroy(), octstr_format_append(), and octstr_imm().

Referenced by pack_sia().

{
    Octstr *appid_os,
           *header_name,
           *header_value;
    long i;
    size_t len;

    i = 0;
    appid_os = octstr_create("");
    len = (size_t) gwlist_len(headers);

    gw_assert(len);

    while (i < len) {
        http_header_get(headers, i, &header_name, &header_value);
        gw_assert(octstr_compare(header_name, 
                  octstr_imm("X-WAP-Application-Id")) == 0);
        octstr_format_append(appid_os, "%S", header_value);
        octstr_destroy(header_name);
        octstr_destroy(header_value);
        ++i;
    }
    
    return appid_os;
}

pack_server_address()

static Octstr * pack_server_address ( void  )

static

Definition at line 594 of file wap_push_ota.c.

References BearerboxAddress::address, bearerbox, CONNECTED_PORT, GSM_CSD_IPV4, BearerboxAddress::mutex, mutex_lock, mutex_unlock, octstr_append(), octstr_append_char(), octstr_append_decimal(), octstr_create, octstr_destroy(), octstr_duplicate, octstr_len(), octstr_set_bits(), and port.

Referenced by pack_sia().

{
    Octstr *address,
           *ip_address;
    unsigned char address_len;
    long port;
    int bearer_type;

    bearer_type = GSM_CSD_IPV4;
    port = CONNECTED_PORT;

    mutex_lock(bearerbox->mutex);  
    ip_address = octstr_duplicate(bearerbox->address);
    address_len = octstr_len(bearerbox->address);
    mutex_unlock(bearerbox->mutex);  

    address = octstr_create("");
    octstr_append_char(address, address_len);
    octstr_set_bits(address, 0, 1, 1); /* bearer type included */
    octstr_set_bits(address, 1, 1, 1); /* port number included */
    octstr_append_char(address, bearer_type);
    octstr_append_decimal(address, port);
    octstr_append(address, ip_address);
    octstr_destroy(ip_address);
    
    return address;
}

pack_sia()

static Octstr * pack_sia ( List *  headers )

static

Definition at line 536 of file wap_push_ota.c.

References CURRENT_VERSION, http_destroy_headers(), pack_appid_list(), pack_server_address(), wsp_pdu::u, wsp_pdu_create(), wsp_pdu_destroy(), and wsp_pdu_pack().

Referenced by make_session_request().

{
    Octstr *sia_content;
    WSP_PDU *pdu;
   
    pdu = wsp_pdu_create(sia);
    
    pdu->u.sia.version = CURRENT_VERSION;
    pdu->u.sia.application_id_list = pack_appid_list(headers);
    pdu->u.sia.contactpoints = pack_server_address();
    sia_content = wsp_pdu_pack(pdu);
    
    wsp_pdu_destroy(pdu);
    http_destroy_headers(headers);

    return sia_content;
}

reason_assert()

static void reason_assert ( long  reason )

static

Definition at line 513 of file wap_push_ota.c.

References gw_assert(), WSP_ABORT_USERDCR, WSP_ABORT_USERDCU, WSP_ABORT_USERPND, WSP_ABORT_USERREQ, and WSP_ABORT_USERRFS.

Referenced by abort_push().

{
    gw_assert(reason == WSP_ABORT_USERREQ || reason == WSP_ABORT_USERRFS || 
              reason == WSP_ABORT_USERPND || reason == WSP_ABORT_USERDCR || 
              reason == WSP_ABORT_USERDCU);
}

wap_push_ota_bb_address_set()

void wap_push_ota_bb_address_set

(

Octstr *

in

)

Definition at line 203 of file wap_push_ota.c.

References BearerboxAddress::address, bearerbox, gw_assert(), BearerboxAddress::mutex, mutex_lock, mutex_unlock, and name().

Referenced by main().

{
    gw_assert(in);

    mutex_lock(bearerbox->mutex);
    bearerbox->address = name(in);
    mutex_unlock(bearerbox->mutex);
}

wap_push_ota_dispatch_event()

void wap_push_ota_dispatch_event

(

WAPEvent *

e

)

Definition at line 193 of file wap_push_ota.c.

References gw_assert(), gwlist_produce(), ota_queue, run_status, and running.

Referenced by main().

{
    gw_assert(run_status == running); 
    gwlist_produce(ota_queue, e);
}

wap_push_ota_init()

void wap_push_ota_init	(	wap_dispatch_func_t *	wsp_dispatch,
		wap_dispatch_func_t *	wsp_unit_dispatch
	)

Definition at line 166 of file wap_push_ota.c.

References bearerbox, bearerbox_address_create(), dispatch_to_wsp, dispatch_to_wsp_unit, gw_assert(), gwlist_add_producer(), gwlist_create, gwthread_create, limbo, main_thread(), ota_queue, run_status, and running.

Referenced by main().

{
    ota_queue = gwlist_create();
    gwlist_add_producer(ota_queue);

    dispatch_to_wsp = wsp_dispatch;
    dispatch_to_wsp_unit = wsp_unit_dispatch;

    bearerbox = bearerbox_address_create();

    gw_assert(run_status == limbo);
    run_status = running;
    gwthread_create(main_thread, NULL);
}

wap_push_ota_shutdown()

void wap_push_ota_shutdown

(

void

)

Definition at line 182 of file wap_push_ota.c.

References bearerbox, bearerbox_address_destroy(), gw_assert(), gwlist_destroy(), gwlist_remove_producer(), gwthread_join_every(), main_thread(), ota_queue, run_status, running, terminating, and wap_event_destroy_item().

Referenced by main().

{
    gw_assert(run_status == running);
    run_status = terminating;
    gwlist_remove_producer(ota_queue);
    gwthread_join_every(main_thread);

    gwlist_destroy(ota_queue, wap_event_destroy_item);
    bearerbox_address_destroy(bearerbox);
}

Variable Documentation

bearerbox

BearerboxAddress* bearerbox = NULL

static

Definition at line 112 of file wap_push_ota.c.

Referenced by pack_server_address(), wap_push_ota_bb_address_set(), wap_push_ota_init(), and wap_push_ota_shutdown().

dispatch_to_wsp

wap_dispatch_func_t* dispatch_to_wsp

static

Definition at line 116 of file wap_push_ota.c.

Referenced by abort_push(), make_confirmed_push_request(), make_push_request(), and wap_push_ota_init().

dispatch_to_wsp_unit

wap_dispatch_func_t* dispatch_to_wsp_unit

static

Definition at line 117 of file wap_push_ota.c.

Referenced by make_session_request(), make_unit_push_request(), and wap_push_ota_init().

ota_queue

List* ota_queue = NULL

static

Definition at line 114 of file wap_push_ota.c.

Referenced by main_thread(), wap_push_ota_dispatch_event(), wap_push_ota_init(), and wap_push_ota_shutdown().

run_status

enum { ... } run_status

Referenced by main_thread(), wap_push_ota_dispatch_event(), wap_push_ota_init(), and wap_push_ota_shutdown().