wap_push_ppg.c File Reference

#include <time.h>
#include <ctype.h>
#include "wap_push_ppg.h"
#include "wap/wap_events.h"
#include "wap/wsp_caps.h"
#include "wml_compiler.h"
#include "wap-appl.h"
#include "wap/wsp.h"
#include "wap/wsp_strings.h"
#include "wap_push_si_compiler.h"
#include "wap_push_sl_compiler.h"
#include "wap_push_pap_compiler.h"
#include "wap_push_pap_mime.h"
#include "wap_push_ppg_pushuser.h"
#include "wap_ppg_session_machine.def"
#include "wap_ppg_push_machine.def"

Go to the source code of this file.

Data Structures
struct	content
struct	PAPEvent
struct	description_t

Macros
#define	DEFAULT_PPG_URL   "/wappush"
#define	INTEGER(name)   m->name = 0;
#define	OCTSTR(name)   m->name = NULL;
#define	ADDRTUPLE(name)   m->name = NULL;
#define	PUSHMACHINES(name)   m->name = gwlist_create();
#define	CAPABILITIES(name)   m->name = NULL;
#define	MACHINE(fields)   fields
#define	OCTSTR(name)   octstr_destroy(sm->name);
#define	ADDRTUPLE(name)   wap_addr_tuple_destroy(sm->name);
#define	INTEGER(name)   sm->name = 0;
#define	PUSHMACHINES(name)   push_machines_list_destroy(sm->name);
#define	CAPABILITIES(name)   wsp_cap_destroy_list(sm->name);
#define	MACHINE(fields)   fields
#define	INTEGER(name)   m->name = 0;
#define	OCTSTR(name)   m->name = NULL;
#define	OPTIONAL_OCTSTR(name)   m->name = NULL;
#define	ADDRTUPLE(name)   m->name = NULL;
#define	CAPABILITIES   m->name = NULL;
#define	HTTPHEADER(name)   m->name = NULL;
#define	MACHINE(fields)   fields
#define	OCTSTR(name)   octstr_destroy(pm->name);
#define	OPTIONAL_OCTSTR(name)   octstr_destroy(pm->name);
#define	INTEGER(name)
#define	ADDRTUPLE(name)   wap_addr_tuple_destroy(pm->name);
#define	CAPABILITIES(name)   wap_cap_destroy_list(pm->name);
#define	HTTPHEADER(name)   http_destroy_headers(pm->name);
#define	MACHINE(fields)   fields
#define	NUM_CONVERTERS   ((long) (sizeof(converters) / sizeof(converters[0])))
#define	NUM_EXTRACTORS   ((long) (sizeof(extractors) / sizeof(extractors[0])))
#define	NUMBER_OF_BEARERS   sizeof(bearers)/sizeof(bearers[0])
#define	NUMBER_OF_NETWORKS   sizeof(networks)/sizeof(networks[0])
#define	NUMBER_OF_WINA_URIS   sizeof(wina_uri)/sizeof(wina_uri[0])

Typedefs
typedef struct PAPEvent	PAPEvent
typedef struct description_t	description_t

Enumerations
enum	{ TIME_EXPIRED = 0, TIME_TOO_EARLY = 1, NO_CONSTRAINTS = 2 }
enum	{   DEFAULT_HTTP_PORT = 8080, NO_HTTPS_PORT = -1, DEFAULT_NUMBER_OF_PUSHES = 100, PI_TRUSTED = 1,   SSL_CONNECTION_OFF = 0, DEFAULT_NUMBER_OF_USERS = 1024, USER_CONFIGURATION_NOT_ADDED = 0 }
enum	{ USER_CONFIGURATION_ADDED = 1 }
enum	{ limbo, running, terminating }
enum	{ TYPE_HTTP = 0, TYPE_HTTPS = 1 }

Functions
static void	ota_read_thread (void *arg)
static void	http_read_thread (void *arg)
static void	handle_internal_event (WAPEvent *e)
static void	pap_request_thread (void *arg)
static int	handle_push_message (HTTPClient **c, WAPEvent *ppg_event, int status)
static PAPEvent *	pap_event_create (Octstr *ip, Octstr *url, List *push_headers, Octstr *mime_content, List *cgivars, HTTPClient *client)
static void	pap_event_destroy (PAPEvent *p)
static void	pap_event_destroy_item (void *p)
static void	pap_event_unpack (PAPEvent *p, Octstr **ip, Octstr **url, List **push_headers, Octstr **mime_content, List **cgivars, HTTPClient **client)
static PPGSessionMachine *	session_machine_create (WAPAddrTuple *tuple, WAPEvent *e)
static void	session_machine_destroy (void *p)
static PPGPushMachine *	push_machine_create (WAPEvent *e, WAPAddrTuple *tuple)
static void	push_machine_destroy (void *pm)
static void	push_machines_list_destroy (List *pl)
static void	create_session (WAPEvent *e, PPGPushMachine *pm)
static void	request_confirmed_push (long last, PPGPushMachine *pm, PPGSessionMachine *sm)
static void	request_unit_push (long last, PPGPushMachine *pm)
static void	request_push (long last, PPGPushMachine *sm)
static int	response_push_connection (WAPEvent *e, PPGSessionMachine *sm)
static HTTPClient *	response_push_message (PPGPushMachine *pm, long code, int status)
static PPGSessionMachine *	session_find_using_pi_client_address (Octstr *addr)
static PPGPushMachine *	find_ppg_push_machine_using_pid (PPGSessionMachine *sm, long pid)
static PPGPushMachine *	find_ppg_push_machine_using_pi_push_id (PPGSessionMachine *sm, Octstr *pi_push_id)
static PPGPushMachine *	find_unit_ppg_push_machine_using_pi_push_id (Octstr *pi_push_id)
static int	push_has_pi_push_id (void *a, void *b)
static int	push_has_pid (void *a, void *b)
static int	session_has_pi_client_address (void *a, void *b)
static int	session_has_addr (void *a, void *b)
static int	session_has_sid (void *a, void *b)
static int	check_capabilities (List *requested, List *assumed)
static int	transform_message (WAPEvent **e, WAPAddrTuple **tuple, List *push_headers, int connected, Octstr **type)
static long	check_x_wap_application_id_header (List **push_headers)
static int	pap_convert_content (struct content *content)
static int	pap_get_content (struct content *content)
static int	select_bearer_network (WAPEvent **e)
static int	delivery_time_constraints (WAPEvent *e, PPGPushMachine *pm)
static void	deliver_confirmed_push (long last, PPGPushMachine *pm, PPGSessionMachine *sm)
static PPGPushMachine *	deliver_unit_push (long last, PPGPushMachine *pm, PPGSessionMachine *sm, int session_exists)
static int	store_push_data (PPGPushMachine **pm, PPGSessionMachine *sm, WAPEvent *e, WAPAddrTuple *tuple, int cless)
static PPGPushMachine *	update_push_data_with_attribute (PPGSessionMachine **sm, PPGPushMachine *pm, long reason, long status)
static void	remove_push_data (PPGSessionMachine *sm, PPGPushMachine *pm, int cless)
static void	remove_session_data (PPGSessionMachine *sm, int status)
static void	remove_pushless_session (PPGSessionMachine *sm)
static PPGSessionMachine *	store_session_data (PPGSessionMachine *sm, WAPEvent *e, WAPAddrTuple *tuple, int *session_exists)
static PPGSessionMachine *	update_session_data_with_headers (PPGSessionMachine *sm, PPGPushMachine *pm)
static void	deliver_pending_pushes (PPGSessionMachine *sm, int last)
static PPGPushMachine *	abort_delivery (PPGSessionMachine *sm, int status)
static PPGSessionMachine *	update_session_data (PPGSessionMachine *sm, long sid, long port, List *caps)
static int	confirmation_requested (WAPEvent *e)
static int	cless_accepted (WAPEvent *e, PPGSessionMachine *sm)
static int	headers_acceptable (List *push_headers, Octstr **content_header)
static int	type_is (Octstr *content_header, char *required_type)
static int	get_mime_boundary (List *push_headers, Octstr *content_header, Octstr **boundary)
static void	change_header_value (List **push_headers, char *name, char *value)
static void	remove_mime_headers (List **push_headers)
static void	remove_link_headers (List **push_headers)
static void	remove_x_kannel_headers (List **push_headers)
static void	send_bad_message_response (HTTPClient **c, Octstr *body_fragment, int code, int status)
static HTTPClient *	send_push_response (WAPEvent *e, int status)
static void	send_to_pi (HTTPClient **c, Octstr *reply_body, int status)
static void	tell_fatal_error (HTTPClient **c, WAPEvent *e, Octstr *url, int status, int code)
static int	read_ppg_config (Cfg *cfg)
static int	ip_allowed_by_ppg (Octstr *ip)
static Octstr *	convert_wml_to_wmlc (struct content *content)
static Octstr *	convert_si_to_sic (struct content *content)
static Octstr *	convert_sl_to_slc (struct content *content)
static Octstr *	set_smsc_id (List *headers, Octstr *username, int trusted_pi)
static Octstr *	set_dlr_url (List *headers, Octstr *username, int trusted_pi)
static long	set_dlr_mask (List *headers, Octstr *dlr_url)
static Octstr *	set_smsbox_id (List *headers, Octstr *username, int trusted_pi)
static Octstr *	set_service_name (void)
static Octstr *	set_time (void)
static int	deliver_before_test_cleared (Octstr *before, struct tm now)
static int	deliver_after_test_cleared (Octstr *after, struct tm now)
static void	session_machine_assert (PPGSessionMachine *sm)
static void	push_machine_assert (PPGPushMachine *pm)
static Octstr *	tell_ppg_name (void)
static Octstr *	describe_code (long code)
static long	ota_abort_to_pap (long reason)
static int	content_transformable (List *push_headers)
static WAPAddrTuple *	set_addr_tuple (Octstr *address, long cliport, long servport, long address_type, List *push_headers)
static WAPAddrTuple *	addr_tuple_change_cliport (WAPAddrTuple *tuple, long port)
static void	initialize_time_item_array (long time_data[], struct tm now)
static int	date_item_compare (Octstr *before, long time_data, long pos)
static long	parse_appid_header (Octstr **assigned_code)
static Octstr *	escape_fragment (Octstr *fragment)
static int	coriented_deliverable (long code)
static int	is_phone_number (long type_of_address)
static void	replace_octstr_char (Octstr *os1, Octstr *os2, long *pos)
void	wap_push_ppg_init (wap_dispatch_func_t *ota_dispatch, wap_dispatch_func_t *appl_dispatch, Cfg *cfg)
void	wap_push_ppg_shutdown (void)
void	wap_push_ppg_dispatch_event (WAPEvent *e)
PPGSessionMachine *	wap_push_ppg_have_push_session_for (WAPAddrTuple *tuple)
PPGSessionMachine *	wap_push_ppg_have_push_session_for_sid (long sid)
static Octstr *	extract_base64 (struct content *content)

Variables
static enum { ... }	run_status = limbo
static List *	ppg_queue = NULL
static List *	pap_queue = NULL
static List *	ppg_machines = NULL
static List *	ppg_unit_pushes = NULL
static Counter *	push_id_counter = NULL
static Dict *	http_clients = NULL
static Dict *	urls = NULL
static wap_dispatch_func_t *	dispatch_to_ota
static wap_dispatch_func_t *	dispatch_to_appl
static Octstr *	ppg_url = NULL
static long	ppg_port = DEFAULT_HTTP_PORT
static long	number_of_pushes = DEFAULT_NUMBER_OF_PUSHES
static int	trusted_pi = PI_TRUSTED
static long	number_of_users = DEFAULT_NUMBER_OF_USERS
static Octstr *	ppg_deny_ip = NULL
static Octstr *	ppg_allow_ip = NULL
static int	user_configuration = USER_CONFIGURATION_NOT_ADDED
static Octstr *	global_sender = NULL
static Octstr *	ppg_default_smsc = NULL
static Octstr *	ppg_dlr_url = NULL
static Octstr *	ppg_smsbox_id = NULL
static Octstr *	service_name = NULL
struct {
char *   type
char *   result_type
Octstr *(*   convert )(struct content *)
}	converters []
struct {
char *   transfer_encoding
Octstr *(*   extract )(struct content *)
}	extractors []
static char *	bearers []
static char *	networks []
static description_t	pap_desc []
static size_t	desc_tab_size = sizeof(pap_desc) / sizeof(pap_desc[0])
static char *	wina_uri []

Macro Definition Documentation

ADDRTUPLE [1/4]

#define ADDRTUPLE

(

name

)

m->name = NULL;

ADDRTUPLE [2/4]

#define ADDRTUPLE

(

name

)

wap_addr_tuple_destroy(sm->name);

ADDRTUPLE [3/4]

#define ADDRTUPLE

(

name

)

m->name = NULL;

ADDRTUPLE [4/4]

#define ADDRTUPLE

(

name

)

wap_addr_tuple_destroy(pm->name);

CAPABILITIES [1/4]

#define CAPABILITIES

(

name

)

m->name = NULL;

CAPABILITIES [2/4]

#define CAPABILITIES

(

name

)

wsp_cap_destroy_list(sm->name);

CAPABILITIES [3/4]

#define CAPABILITIES   m->name = NULL;

CAPABILITIES [4/4]

#define CAPABILITIES

(

name

)

wap_cap_destroy_list(pm->name);

DEFAULT_PPG_URL

#define DEFAULT_PPG_URL   "/wappush"

Definition at line 113 of file wap_push_ppg.c.

HTTPHEADER [1/2]

#define HTTPHEADER

(

name

)

m->name = NULL;

HTTPHEADER [2/2]

#define HTTPHEADER

(

name

)

http_destroy_headers(pm->name);

INTEGER [1/4]

#define INTEGER

(

name

)

m->name = 0;

INTEGER [2/4]

#define INTEGER

(

name

)

sm->name = 0;

INTEGER [3/4]

#define INTEGER

(

name

)

m->name = 0;

INTEGER [4/4]

#define INTEGER

(

name

)

MACHINE [1/4]

#define MACHINE

(

fields

)

fields

MACHINE [2/4]

#define MACHINE

(

fields

)

fields

MACHINE [3/4]

#define MACHINE

(

fields

)

fields

MACHINE [4/4]

#define MACHINE

(

fields

)

fields

NUM_CONVERTERS

#define NUM_CONVERTERS   ((long) (sizeof(converters) / sizeof(converters[0])))

Definition at line 1991 of file wap_push_ppg.c.

Referenced by pap_convert_content().

NUM_EXTRACTORS

#define NUM_EXTRACTORS   ((long) (sizeof(extractors) / sizeof(extractors[0])))

Definition at line 2001 of file wap_push_ppg.c.

Referenced by pap_get_content().

NUMBER_OF_BEARERS

#define NUMBER_OF_BEARERS   sizeof(bearers)/sizeof(bearers[0])

Definition at line 2070 of file wap_push_ppg.c.

Referenced by select_bearer_network().

NUMBER_OF_NETWORKS

#define NUMBER_OF_NETWORKS   sizeof(networks)/sizeof(networks[0])

Definition at line 2084 of file wap_push_ppg.c.

Referenced by select_bearer_network().

NUMBER_OF_WINA_URIS

#define NUMBER_OF_WINA_URIS   sizeof(wina_uri)/sizeof(wina_uri[0])

Definition at line 2834 of file wap_push_ppg.c.

Referenced by parse_appid_header().

OCTSTR [1/4]

#define OCTSTR

(

name

)

m->name = NULL;

OCTSTR [2/4]

#define OCTSTR

(

name

)

octstr_destroy(sm->name);

OCTSTR [3/4]

#define OCTSTR

(

name

)

m->name = NULL;

OCTSTR [4/4]

#define OCTSTR

(

name

)

octstr_destroy(pm->name);

OPTIONAL_OCTSTR [1/2]

#define OPTIONAL_OCTSTR

(

name

)

m->name = NULL;

OPTIONAL_OCTSTR [2/2]

#define OPTIONAL_OCTSTR

(

name

)

octstr_destroy(pm->name);

PUSHMACHINES [1/2]

#define PUSHMACHINES

(

name

)

m->name = gwlist_create();

PUSHMACHINES [2/2]

#define PUSHMACHINES

(

name

)

push_machines_list_destroy(sm->name);

Typedef Documentation

description_t

typedef struct description_t description_t

Definition at line 2206 of file wap_push_ppg.c.

PAPEvent

typedef struct PAPEvent PAPEvent

Definition at line 216 of file wap_push_ppg.c.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
TIME_EXPIRED
TIME_TOO_EARLY
NO_CONSTRAINTS

Definition at line 92 of file wap_push_ppg.c.

     {
    TIME_EXPIRED = 0,
    TIME_TOO_EARLY = 1,
    NO_CONSTRAINTS = 2
};

anonymous enum

anonymous enum

Enumerator
DEFAULT_HTTP_PORT
NO_HTTPS_PORT
DEFAULT_NUMBER_OF_PUSHES
PI_TRUSTED
SSL_CONNECTION_OFF
DEFAULT_NUMBER_OF_USERS
USER_CONFIGURATION_NOT_ADDED

Definition at line 101 of file wap_push_ppg.c.

     {
    DEFAULT_HTTP_PORT = 8080,
    NO_HTTPS_PORT = -1,
    DEFAULT_NUMBER_OF_PUSHES = 100,
    PI_TRUSTED = 1,
    SSL_CONNECTION_OFF = 0,
    DEFAULT_NUMBER_OF_USERS = 1024,
    USER_CONFIGURATION_NOT_ADDED = 0
};

anonymous enum

anonymous enum

Enumerator
USER_CONFIGURATION_ADDED

Definition at line 111 of file wap_push_ppg.c.

{ USER_CONFIGURATION_ADDED = 1 };

anonymous enum

anonymous enum

Enumerator
limbo
running
terminating

Definition at line 128 of file wap_push_ppg.c.

{limbo, running, terminating} run_status = limbo;

anonymous enum

anonymous enum

Enumerator
TYPE_HTTP
TYPE_HTTPS

Definition at line 392 of file wap_push_ppg.c.

     {
    TYPE_HTTP = 0,
    TYPE_HTTPS = 1
};

Function Documentation

abort_delivery()

static PPGPushMachine * abort_delivery ( PPGSessionMachine *  sm, int  status  )

static

Definition at line 2385 of file wap_push_ppg.c.

References code, gwlist_get(), gwlist_len(), PAP_ABORT_USERPND, PAP_ABORTED, PAP_CAPABILITIES_MISMATCH, push_machine_assert(), description_t::reason, remove_push_data(), response_push_message(), session_machine_assert(), and update_push_data_with_attribute().

Referenced by handle_internal_event().

{
    PPGPushMachine *pm;
    long reason,
         code;

    session_machine_assert(sm);

    pm = NULL;
    reason = PAP_ABORT_USERPND;
    code = PAP_CAPABILITIES_MISMATCH;
    
    while (gwlist_len(sm->push_machines) > 0) {
        pm = gwlist_get(sm->push_machines, 0);
        push_machine_assert(pm);

        pm = update_push_data_with_attribute(&sm, pm, reason, PAP_ABORTED);
        response_push_message(pm, code, status);

        remove_push_data(sm, pm, sm == NULL);
    }

    return pm;
}

addr_tuple_change_cliport()

static WAPAddrTuple * addr_tuple_change_cliport ( WAPAddrTuple *  tuple, long  port  )

static

Definition at line 2882 of file wap_push_ppg.c.

References WAPAddr::address, WAPAddrTuple::local, WAPAddr::port, WAPAddrTuple::remote, and wap_addr_tuple_create().

Referenced by create_session().

{
    WAPAddrTuple *dubble;

    if (tuple == NULL)
        return NULL;

    dubble = wap_addr_tuple_create(tuple->remote->address,
                                   port,
                                   tuple->local->address,
                                   tuple->local->port);

    return dubble;
}

change_header_value()

static void change_header_value ( List **  push_headers, char *  name, char *  value  )

static

Definition at line 2991 of file wap_push_ppg.c.

References http_header_add(), http_header_remove_all(), and name.

Referenced by pap_request_thread(), and transform_message().

{
    http_header_remove_all(*push_headers, name);
    http_header_add(*push_headers, name, value);
}

check_capabilities()

static int check_capabilities ( List *  requested, List *  assumed  )

static

Definition at line 1691 of file wap_push_ppg.c.

Referenced by response_push_connection().

{
    int is_capable;

    is_capable = 1;

    return is_capable;
}

check_x_wap_application_id_header()

static long check_x_wap_application_id_header ( List **  push_headers )

static

Definition at line 1858 of file wap_push_ppg.c.

References http_header_add(), http_header_find_first, http_header_remove_all(), octstr_destroy(), octstr_format(), octstr_get_cstr, and parse_appid_header().

Referenced by handle_push_message().

{
    Octstr *appid_content;
    long coded_value;
    Octstr *cos;
    
    if (*push_headers == NULL)
        return -2;

    appid_content = http_header_find_first(*push_headers, 
        "X-WAP-Application-Id");
    
    if (appid_content == NULL) {
        octstr_destroy(appid_content);
        return -1;
    }

    if ((coded_value = parse_appid_header(&appid_content)) < 0) {
        octstr_destroy(appid_content);
        return -2;
    }
        
    if (coded_value == 2) {
        octstr_destroy(appid_content);
        http_header_remove_all(*push_headers, "X-WAP-Application-Id");
        return -1;
    }

    cos = octstr_format("%ld", coded_value);
    http_header_remove_all(*push_headers, "X-WAP-Application-Id");
    http_header_add(*push_headers, "X-WAP-Application-Id", octstr_get_cstr(cos));
    
    octstr_destroy(appid_content); 
    octstr_destroy(cos);
    
    return coded_value;  
}

cless_accepted()

static int cless_accepted ( WAPEvent *  e, PPGSessionMachine *  sm  )

static

Definition at line 2659 of file wap_push_ppg.c.

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

Referenced by handle_push_message(), and transform_message().

{
    gw_assert(e->type == Push_Message);
    return (e->u.Push_Message.delivery_method == PAP_UNCONFIRMED ||
           e->u.Push_Message.delivery_method == PAP_NOT_SPECIFIED) &&
           (sm == NULL);
}

confirmation_requested()

static int confirmation_requested ( WAPEvent *  e )

static

Definition at line 2483 of file wap_push_ppg.c.

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

Referenced by handle_push_message().

{
    gw_assert(e->type == Push_Message);

    return e->u.Push_Message.delivery_method == PAP_CONFIRMED || 
           e->u.Push_Message.delivery_method == PAP_PREFERCONFIRMED;
}

content_transformable()

static int content_transformable ( List *  push_headers )

static

Definition at line 1899 of file wap_push_ppg.c.

References gw_assert(), gwlist_len(), http_destroy_headers(), http_header_find_all(), http_header_get(), octstr_compare(), octstr_destroy(), and octstr_imm().

Referenced by transform_message().

{
    List *cache_directives;
    long i;
    Octstr *header_name, 
           *header_value;

    gw_assert(push_headers);

    cache_directives = http_header_find_all(push_headers, "Cache-Control");
    if (gwlist_len(cache_directives) == 0) {
        http_destroy_headers(cache_directives);
        return 1;
    }

    i = 0;
    while (i < gwlist_len(cache_directives)) {
        http_header_get(cache_directives, i, &header_name, &header_value);
        if (octstr_compare(header_value, octstr_imm("no-transform")) == 0) {
            http_destroy_headers(cache_directives);
            octstr_destroy(header_name);
            octstr_destroy(header_value);
        return 0;
        }
        ++i;
    }

    http_destroy_headers(cache_directives);
    octstr_destroy(header_name);
    octstr_destroy(header_value);
 
    return 1;
}

convert_si_to_sic()

static Octstr * convert_si_to_sic ( struct content *  content )

static

Definition at line 1947 of file wap_push_ppg.c.

References content::body, content::charset, si_compile(), and warning().

{
    Octstr *sic;

    if (si_compile(content->body, content->charset, &sic) == 0)
        return sic;
    warning(0, "PPG: si compilation failed");
    return NULL;
}

convert_sl_to_slc()

static Octstr * convert_sl_to_slc ( struct content *  content )

static

Definition at line 1957 of file wap_push_ppg.c.

References content::body, content::charset, sl_compile(), and warning().

{
    Octstr *slc;

    if (sl_compile(content->body, content->charset, &slc) == 0)
        return slc;
    warning(0, "PPG: sl compilation failed");
    return NULL;
}

convert_wml_to_wmlc()

static Octstr * convert_wml_to_wmlc ( struct content *  content )

static

Definition at line 1937 of file wap_push_ppg.c.

References content::body, content::charset, warning(), and wml_compile().

{
    Octstr *wmlc;

    if (wml_compile(content->body, content->charset, &wmlc, NULL) == 0)
        return wmlc;
    warning(0, "PPG: wml compilation failed");
    return NULL;
}

coriented_deliverable()

static int coriented_deliverable ( long  code )

static

Definition at line 2670 of file wap_push_ppg.c.

Referenced by handle_push_message().

{
    return appid_code > -1;
}

create_session()

static void create_session ( WAPEvent *  e, PPGPushMachine *  pm  )

static

Definition at line 1476 of file wap_push_ppg.c.

References addr_tuple_change_cliport(), CONNECTIONLESS_PUSH_CLIPORT, dispatch_to_ota, dlr_url, gw_assert(), http_header_duplicate(), octstr_duplicate, PAPEvent::push_headers, push_machine_assert(), service_name, smsbox_id, smsc_id, WAPEvent::type, WAPEvent::u, and wap_event_create.

Referenced by handle_push_message().

{
    WAPEvent *ota_event;
    List *push_headers;
    Octstr *smsc_id;
    Octstr *dlr_url;
    Octstr *smsbox_id;
    Octstr *service_name;

    gw_assert(e->type == Push_Message);
    push_machine_assert(pm);
    
    push_headers = http_header_duplicate(e->u.Push_Message.push_headers);
    smsc_id = octstr_duplicate(e->u.Push_Message.smsc_id);
    dlr_url = octstr_duplicate(e->u.Push_Message.dlr_url);
    smsbox_id = octstr_duplicate(e->u.Push_Message.smsbox_id);
    service_name = octstr_duplicate(e->u.Push_Message.service_name);

    ota_event = wap_event_create(Pom_SessionRequest_Req);
    ota_event->u.Pom_SessionRequest_Req.addr_tuple =
        addr_tuple_change_cliport(pm->addr_tuple,
                                  CONNECTIONLESS_PUSH_CLIPORT);
    ota_event->u.Pom_SessionRequest_Req.push_headers = push_headers;
    ota_event->u.Pom_SessionRequest_Req.push_id = pm->push_id;
    ota_event->u.Pom_SessionRequest_Req.address_type = pm->address_type;
    if (smsc_id != NULL)
        ota_event->u.Pom_SessionRequest_Req.smsc_id = smsc_id;
    else
        ota_event->u.Pom_SessionRequest_Req.smsc_id = NULL;
    if (dlr_url != NULL)
        ota_event->u.Pom_SessionRequest_Req.dlr_url = dlr_url;                                    
    else
        ota_event->u.Pom_SessionRequest_Req.dlr_url = NULL;
    ota_event->u.Pom_SessionRequest_Req.dlr_mask = e->u.Push_Message.dlr_mask;
    if (smsbox_id != NULL)
        ota_event->u.Pom_SessionRequest_Req.smsbox_id = smsbox_id;
    else
        ota_event->u.Pom_SessionRequest_Req.smsbox_id = NULL;
    ota_event->u.Pom_SessionRequest_Req.service_name = service_name;
        
    dispatch_to_ota(ota_event);
}

date_item_compare()

static int date_item_compare ( Octstr *  before, long  time_data, long  pos  )

static

Definition at line 2692 of file wap_push_ppg.c.

References octstr_parse_long().

Referenced by deliver_after_test_cleared(), and deliver_before_test_cleared().

{
    long data;

    if (octstr_parse_long(&data, condition, pos, 10) < 0) {
        return 0;
    }
    if (data < time_data) {
        return -1;
    }
    if (data > time_data) {
        return 1;
    }

    return 0;
}

deliver_after_test_cleared()

static int deliver_after_test_cleared ( Octstr *  after, struct tm  now  )

static

Definition at line 2741 of file wap_push_ppg.c.

References date_item_compare(), initialize_time_item_array(), and octstr_len().

Referenced by delivery_time_constraints().

{
    long time_data[6];
    long j;

    if (after == NULL)
        return 1;
    
    initialize_time_item_array(time_data, now);
    if (date_item_compare(after, time_data[0], 0) == -1)
        return 1;
    if (date_item_compare(after, time_data[0], 0) == 1)
        return 0;

    for (j = 5; j < octstr_len(after); j += 3) {
        if (date_item_compare(after, time_data[(j-5)/3 + 1], j) == -1)
            return 1;
        if (date_item_compare(after, time_data[(j-5)/3 + 1], j) == 1)
            return 0;
    }

    return 0;
}

deliver_before_test_cleared()

static int deliver_before_test_cleared ( Octstr *  before, struct tm  now  )

static

Definition at line 2713 of file wap_push_ppg.c.

References date_item_compare(), initialize_time_item_array(), and octstr_len().

Referenced by delivery_time_constraints().

{  
    long time_data[6];
    long j;

    if (before == NULL)
        return 1;

    initialize_time_item_array(time_data, now);
    if (date_item_compare(before, time_data[0], 0) == 1)
        return 1;
    if (date_item_compare(before, time_data[0], 0) == -1)
        return 0;

    for (j = 5; j < octstr_len(before); j += 3) {
        if (date_item_compare(before, time_data[(j-5)/3 + 1], j) == 1)
            return 1;
        if (date_item_compare(before, time_data[(j-5)/3 + 1], j) == -1)
            return 0;
    }

    return 0;
}

deliver_confirmed_push()

static void deliver_confirmed_push ( long  last, PPGPushMachine *  pm, PPGSessionMachine *  sm  )

static

Definition at line 2322 of file wap_push_ppg.c.

References request_confirmed_push().

Referenced by handle_push_message().

{
    request_confirmed_push(last, pm, sm);
}

deliver_pending_pushes()

static void deliver_pending_pushes ( PPGSessionMachine *  sm, int  last  )

static

Definition at line 2356 of file wap_push_ppg.c.

References gw_assert(), gwlist_get(), gwlist_len(), PAP_DELIVERED1, PAP_UNCONFIRMED, push_machine_assert(), remove_push_data(), request_confirmed_push(), request_push(), session_machine_assert(), and update_push_data_with_attribute().

Referenced by handle_internal_event().

{
    PPGPushMachine *pm;    
    long i;

    session_machine_assert(sm);
    gw_assert(gwlist_len(sm->push_machines) > 0);

    i = 0;
    while (i < gwlist_len(sm->push_machines)) {
        pm = gwlist_get(sm->push_machines, i);
        push_machine_assert(pm);

        if (pm->delivery_method == PAP_UNCONFIRMED) {
            request_push(last, pm); 
            pm = update_push_data_with_attribute(&sm, pm, PAP_UNCONFIRMED, 
                 PAP_DELIVERED1);
            remove_push_data(sm, pm, sm == NULL);
        } else {
            request_confirmed_push(last, pm, sm);
            ++i;
        }
    }
}     

deliver_unit_push()

static PPGPushMachine * deliver_unit_push ( long  last, PPGPushMachine *  pm, PPGSessionMachine *  sm, int  session_exists  )

static

Definition at line 2335 of file wap_push_ppg.c.

References info(), PAP_DELIVERED1, PAP_UNCONFIRMED, push_machine_assert(), request_push(), request_unit_push(), and update_push_data_with_attribute().

Referenced by handle_push_message().

{
    push_machine_assert(pm);
    
    if (!session_exists)
        request_unit_push(last, pm);
    else
        request_push(last, pm);

    pm = update_push_data_with_attribute(&sm, pm, PAP_UNCONFIRMED, 
                                         PAP_DELIVERED1);
    info(0, "PPG: unconfirmed push delivered to OTA");

    return pm;
}

delivery_time_constraints()

static int delivery_time_constraints ( WAPEvent *  e, PPGPushMachine *  pm  )

static

Definition at line 2171 of file wap_push_ppg.c.

References debug(), deliver_after_test_cleared(), deliver_before_test_cleared(), gw_assert(), gw_gmtime(), info(), WAPEvent::type, and WAPEvent::u.

Referenced by handle_push_message().

{
    Octstr *before,
           *after;
    struct tm now;
   
    gw_assert(e->type == Push_Message);
    
    before = e->u.Push_Message.deliver_before_timestamp;
    after = pm->deliver_after_timestamp;
    now = gw_gmtime(time(NULL));

    if (!deliver_before_test_cleared(before, now)) {
        info(0, "PPG: delivery deadline expired, dropping the push message");
        return 0;
    }

    if (!deliver_after_test_cleared(after, now)) {
        debug("wap.push.ppg", 0, "PPG: too early to push the message,"
              " waiting");
        return 1;
    }

    return 2;
}

describe_code()

static Octstr * describe_code ( long  code )

static

Definition at line 2238 of file wap_push_ppg.c.

References code, desc_tab_size, description, octstr_create, octstr_imm(), pap_desc, and description_t::reason.

Referenced by response_push_message(), tell_fatal_error(), and update_push_data_with_attribute().

{
    Octstr *desc;
    size_t i;

    for (i = 0; i < desc_tab_size; i++) {
        if (pap_desc[i].reason == code) {
            desc = octstr_create(pap_desc[i].description);
            return desc;
        }
    }

    return octstr_imm("unknown PAP code");
}

escape_fragment()

static Octstr * escape_fragment ( Octstr *  fragment )

static

Definition at line 3223 of file wap_push_ppg.c.

References octstr_get_char(), octstr_imm(), octstr_len(), and replace_octstr_char().

Referenced by send_bad_message_response().

{
    long i;
    int c;

    i = 0;
    while (i < octstr_len(fragment)) {
        if ((c = octstr_get_char(fragment, i)) == '"') {
            replace_octstr_char(fragment, octstr_imm("&quot;"), &i);
        } else if (c == '<') {
            replace_octstr_char(fragment, octstr_imm("&lt;"), &i);
        } else if (c == '>') {
            replace_octstr_char(fragment, octstr_imm("&gt;"), &i);
        } else if (c == '&') {
            replace_octstr_char(fragment, octstr_imm("&amp;"), &i);
        }
        ++i;
    }

    return fragment;
}

extract_base64()

static Octstr* extract_base64 ( struct content *  content )

static

Definition at line 1968 of file wap_push_ppg.c.

References content::body, octstr_base64_to_binary(), and octstr_duplicate.

{
    Octstr *orig = octstr_duplicate(content->body);
    octstr_base64_to_binary(orig);
    return orig;
}

find_ppg_push_machine_using_pi_push_id()

static PPGPushMachine * find_ppg_push_machine_using_pi_push_id ( PPGSessionMachine *  sm, Octstr *  pi_push_id  )

static

Definition at line 2526 of file wap_push_ppg.c.

References gw_assert(), gwlist_search(), push_has_pi_push_id(), and session_machine_assert().

Referenced by store_push_data().

{
    PPGPushMachine *pm;

    gw_assert(pi_push_id);
    session_machine_assert(sm);

    pm = gwlist_search(sm->push_machines, pi_push_id, push_has_pi_push_id);

    return pm;
}

find_ppg_push_machine_using_pid()

static PPGPushMachine * find_ppg_push_machine_using_pid ( PPGSessionMachine *  sm, long  pid  )

static

Definition at line 2502 of file wap_push_ppg.c.

References gw_assert(), gwlist_search(), push_has_pid(), and session_machine_assert().

Referenced by handle_internal_event().

{
    PPGPushMachine *pm;

    gw_assert(pid >= 0);
    session_machine_assert(sm);

    pm = gwlist_search(sm->push_machines, &pid, push_has_pid);

    return pm;
}

find_unit_ppg_push_machine_using_pi_push_id()

static PPGPushMachine * find_unit_ppg_push_machine_using_pi_push_id ( Octstr *  pi_push_id )

static

Definition at line 2539 of file wap_push_ppg.c.

References gw_assert(), gwlist_search(), ppg_unit_pushes, and push_has_pi_push_id().

Referenced by store_push_data().

{
    PPGPushMachine *pm;

    gw_assert(pi_push_id);
    pm = gwlist_search(ppg_unit_pushes, pi_push_id, push_has_pi_push_id);

    return pm;
}

get_mime_boundary()

static int get_mime_boundary ( List *  push_headers, Octstr *  content_header, Octstr **  boundary  )

static

Definition at line 2959 of file wap_push_ppg.c.

References boundary, content_header, octstr_case_search(), octstr_copy, octstr_get_char(), octstr_imm(), octstr_len(), and warning().

Referenced by pap_request_thread().

{
    long pos;
    Octstr *bos;
    int c, quoted = 0;
    long bstart;

    pos = 0;
    if ((pos = octstr_case_search(content_header, 
                                  bos = octstr_imm("boundary="), 0)) < 0) {
        warning(0, "PPG: get_mime_boundary: no boundary specified");
        return -1;
    }

    pos += octstr_len(bos);
    if (octstr_get_char(content_header, pos) == '"') {
        ++pos;
        quoted = 1;
    }
    
    bstart = pos;
    while ((c = octstr_get_char(content_header, pos)) != -1) {
        if (c == ';' || (quoted && c == '"') || (!quoted && c == ' '))
             break;
        ++pos;
    }
    *boundary = octstr_copy(content_header, bstart, pos - bstart);

    return 0;
}

handle_internal_event()

static void handle_internal_event ( WAPEvent *  e )

static

Definition at line 1199 of file wap_push_ppg.c.

References abort_delivery(), debug(), deliver_pending_pushes(), find_ppg_push_machine_using_pid(), HTTP_OK, NOT_LAST, PAP_ABORTED, PAP_CONFIRMED, PAP_DELIVERED2, WAPAddr::port, port, push_machine_assert(), WAPAddrTuple::remote, remove_push_data(), remove_session_data(), response_push_connection(), session_machine_assert(), WAPEvent::type, WAPEvent::u, update_push_data_with_attribute(), update_session_data(), wap_event_destroy(), wap_event_dump(), wap_push_ppg_have_push_session_for(), and wap_push_ppg_have_push_session_for_sid().

Referenced by ota_read_thread().

{
    long sid,
         pid,
         reason,
         port;
    int http_status;
    PPGPushMachine *pm;
    PPGSessionMachine *sm;
    WAPAddrTuple *tuple;
    List *caps;
        
    http_status = HTTP_OK;
    switch (e->type) {
/*
 * Pap, Chapter 11.1.3 states that if client is incapable, we should abort the
 * push and inform PI. We do this here.
 * In addition, we store session id used as an alias for address tuple and do
 * all pushes pending for this initiator (or abort them).
 */
    case Pom_Connect_Ind:
         debug("wap.push.ppg", 0, "PPG: handle_internal_event: connect"
               " indication from OTA");
         sid = e->u.Pom_Connect_Ind.session_id;
         tuple = e->u.Pom_Connect_Ind.addr_tuple;
         port = tuple->remote->port;
         caps = e->u.Pom_Connect_Ind.requested_capabilities;

         sm = wap_push_ppg_have_push_session_for(tuple);
         sm = update_session_data(sm, sid, port, caps);
        
         if (!response_push_connection(e, sm)) {
         pm = abort_delivery(sm, http_status);
             wap_event_destroy(e);
             return;
         }

/* 
 * hard-coded until we have bearer control implemented
 */
         deliver_pending_pushes(sm, NOT_LAST);  
         wap_event_destroy(e);
    break;

    case Pom_Disconnect_Ind:
        debug("wap.push.ppg", 0, "PPG: handle_internal_event: disconnect"
              " indication from OTA");
        sm = wap_push_ppg_have_push_session_for_sid(
                 e->u.Pom_Disconnect_Ind.session_handle);
        remove_session_data(sm, http_status);
        wap_event_destroy(e);
    break;

/*
 * Only the client can close a session. So we leave session open, even when 
 * there are no active pushes. Note that we do not store PAP attribute very
 * long time. Point is that result notification message, if asked, will rep-
 * ort this fact to PI, after which there is no need to store it any more.
 */
    case Po_ConfirmedPush_Cnf:
        debug("wap.push.ppg", 0, "PPG: handle_internal_event: push"
              " confirmation from OTA");
        sid = e->u.Po_ConfirmedPush_Cnf.session_handle;
        pid = e->u.Po_ConfirmedPush_Cnf.server_push_id;

        sm = wap_push_ppg_have_push_session_for_sid(sid);
        pm = find_ppg_push_machine_using_pid(sm, pid);
        pm = update_push_data_with_attribute(&sm, pm, PAP_CONFIRMED, 
                                             PAP_DELIVERED2);
        wap_event_destroy(e);
        remove_push_data(sm, pm, 0);
    break;

/*
 * Again, PAP attribute will be reported to PI by using result notification.
 */
    case Po_PushAbort_Ind:
        debug("wap.push.ppg", 0, "PPG: handle_internal_event: abort"
              " indication from OTA");
        sid = e->u.Po_PushAbort_Ind.session_handle;
        pid = e->u.Po_PushAbort_Ind.push_id;

        sm = wap_push_ppg_have_push_session_for_sid(sid);
        pm = find_ppg_push_machine_using_pid(sm, pid);
        session_machine_assert(sm);
        push_machine_assert(pm);
        reason = e->u.Po_PushAbort_Ind.reason;
        pm = update_push_data_with_attribute(&sm, pm, reason, PAP_ABORTED);
        remove_session_data(sm, http_status);
        wap_event_destroy(e);
    break;

/*
 * FIXME TRU: Add timeout (a mandatory feature!)
 */
    default:
        debug("wap.ppg", 0, "PPG: handle_internal_event: an unhandled event");
        wap_event_dump(e);
        wap_event_destroy(e);
    break;
    }
}

handle_push_message()

static int handle_push_message ( HTTPClient **  c, WAPEvent *  ppg_event, int  status  )

static

Definition at line 1054 of file wap_push_ppg.c.

References check_x_wap_application_id_header(), cless_accepted(), confirmation_requested(), coriented_deliverable(), create_session(), deliver_confirmed_push(), deliver_unit_push(), delivery_time_constraints(), http_header_mark_transformation(), http_header_remove_all(), info(), NO_CONSTRAINTS, NOT_LAST, octstr_destroy(), PAP_ACCEPTED_FOR_PROCESSING, PAP_ADDRESS_ERROR, PAP_BAD_REQUEST, PAP_DUPLICATE_PUSH_ID, PAP_EXPIRED, PAP_FORBIDDEN, PAP_PENDING, PAP_REQUIRED_BEARER_NOT_AVAILABLE, PAP_TRANSFORMATION_FAILURE, PAP_UNDELIVERABLE1, PAP_UNDELIVERABLE2, PAPEvent::push_headers, remove_push_data(), remove_pushless_session(), response_push_message(), select_bearer_network(), session_find_using_pi_client_address(), store_push_data(), store_session_data(), TIME_EXPIRED, TIME_TOO_EARLY, transform_message(), type, WAPEvent::u, update_push_data_with_attribute(), update_session_data_with_headers(), wap_addr_tuple_destroy(), wap_event_destroy(), and warning().

Referenced by pap_request_thread().

{
    int cless,
        session_exists,
        bearer_supported,
        dummy,
        constraints,
        message_transformable,
        coriented_possible;

    long coded_appid_value;

    PPGPushMachine *pm;
    PPGSessionMachine *sm;
    WAPAddrTuple *tuple=NULL;
    Octstr *cliaddr=NULL;
    Octstr *type=NULL;

    List *push_headers;
   
    push_headers = e->u.Push_Message.push_headers;
    cliaddr = e->u.Push_Message.address_value;
    session_exists = 0;

    sm = session_find_using_pi_client_address(cliaddr);
    coded_appid_value = check_x_wap_application_id_header(&push_headers);
    cless = cless_accepted(e, sm);
    message_transformable = transform_message(&e, &tuple, push_headers, cless, 
                                              &type);

    if (!sm && !cless) {
        sm = store_session_data(sm, e, tuple, &session_exists); 
    }

    if (!store_push_data(&pm, sm, e, tuple, cless)) {
        warning(0, "PPG: handle_push_message: duplicate push id");
        *c = response_push_message(pm, PAP_DUPLICATE_PUSH_ID, status);
        goto no_start;
    }
    
    if (!message_transformable) {
    pm = update_push_data_with_attribute(&sm, pm, 
        PAP_TRANSFORMATION_FAILURE, PAP_UNDELIVERABLE1);  
        if (tuple != NULL)   
        *c = response_push_message(pm, PAP_TRANSFORMATION_FAILURE, status);
        else
        *c = response_push_message(pm, PAP_ADDRESS_ERROR, status);
        goto no_transformation;
    }
    
    dummy = 0;
    pm = update_push_data_with_attribute(&sm, pm, dummy, PAP_PENDING);
    
    bearer_supported = select_bearer_network(&e);
    if (!bearer_supported) {
        pm = update_push_data_with_attribute(&sm, pm, dummy, 
            PAP_UNDELIVERABLE2);
        *c = response_push_message(pm, PAP_REQUIRED_BEARER_NOT_AVAILABLE, status);
        goto no_start;
    }
    
    if ((constraints = delivery_time_constraints(e, pm)) == TIME_EXPIRED) {
        pm = update_push_data_with_attribute(&sm, pm, PAP_FORBIDDEN, 
                                             PAP_EXPIRED);
        *c = response_push_message(pm, PAP_FORBIDDEN, status);
        goto no_start;
    }

/*
 * If time is to early for delivering the push message, we do not remove push
 * data. We response PI here, so that "accepted for processing" means "no 
 * error messages to come".
 */ 

    *c = response_push_message(pm, PAP_ACCEPTED_FOR_PROCESSING, status);
    info(0, "PPG: handle_push_message: push message accepted for processing");

    if (constraints == TIME_TOO_EARLY)
        goto store_push;

    if (constraints == NO_CONSTRAINTS) {
    http_header_mark_transformation(pm->push_headers, pm->push_data, type);
        if (sm)
            sm = update_session_data_with_headers(sm, pm); 

        if (!confirmation_requested(e)) {
            pm = deliver_unit_push(NOT_LAST, pm, sm, session_exists);
            goto unit_push_delivered;
    } 
          
        if (session_exists) {
            deliver_confirmed_push(NOT_LAST, pm, sm);   
        } else { 
            coriented_possible = coriented_deliverable(coded_appid_value); 
        http_header_remove_all(e->u.Push_Message.push_headers, 
                                   "Content-Type");  
            if (coriented_possible) {
                create_session(e, pm);
            } else {
                warning(0, "PPG: handle_push_message: wrong app id for confirmed"
                        " push session creation");
                *c = response_push_message(pm, PAP_BAD_REQUEST, status);
            }
        }
    }

    wap_addr_tuple_destroy(tuple);
    octstr_destroy(type);
    wap_event_destroy(e);
    return 1;

unit_push_delivered:
    wap_addr_tuple_destroy(tuple);
    remove_push_data(sm, pm, cless);
    octstr_destroy(type);
    wap_event_destroy(e);
    return 1;

store_push:
    wap_addr_tuple_destroy(tuple);
    octstr_destroy(type);
    wap_event_destroy(e);
    return 1;

no_transformation:
    wap_addr_tuple_destroy(tuple);
    remove_push_data(sm, pm, cless);
    if (sm)
        remove_pushless_session(sm);
    wap_event_destroy(e);
    return 0;

no_start:
    wap_addr_tuple_destroy(tuple);
    octstr_destroy(type);
    remove_push_data(sm, pm, cless);
    if (sm)
        remove_pushless_session(sm);
    wap_event_destroy(e);
    return 1;
}

headers_acceptable()

static int headers_acceptable ( List *  push_headers, Octstr **  content_header  )

static

Definition at line 2904 of file wap_push_ppg.c.

References content_header, error(), gw_assert(), http_header_find_first, octstr_format(), type_is(), and warning().

Referenced by pap_request_thread().

{
    gw_assert(push_headers);
    *content_header = http_header_find_first(push_headers, "Content-Type");

    if (*content_header == NULL) {
        *content_header = octstr_format("%s", "no content type header found");
        goto error;
    }
    
    if (!type_is(*content_header, "multipart/related")) {
        goto error;
    }

    if (!type_is(*content_header, "application/xml")) {
        goto error;
    }

    return 1;

error:
    warning(0, "PPG: headers_acceptable: got unacceptable push headers");
    return 0;
}

http_read_thread()

static void http_read_thread ( void *  arg )

static

Definition at line 688 of file wap_push_ppg.c.

References PAPEvent::cgivars, client(), gwlist_produce(), http_accept_request(), PAPEvent::ip, PAPEvent::mime_content, pap_event_create(), pap_queue, ppg_port, PAPEvent::push_headers, run_status, running, and url.

Referenced by wap_push_ppg_init(), and wap_push_ppg_shutdown().

{
    PAPEvent *p;
    Octstr *ip; 
    Octstr *url; 
    List *push_headers;
    Octstr *mime_content; 
    List *cgivars;
    HTTPClient *client;

    while (run_status == running) {
        client = http_accept_request(ppg_port, &ip, &url, &push_headers, 
                                     &mime_content, &cgivars);
        if (client == NULL) 
            break;

        p = pap_event_create(ip, url, push_headers, mime_content, cgivars,
                             client);
        gwlist_produce(pap_queue, p);
    }
}

initialize_time_item_array()

static void initialize_time_item_array ( long  time_data[], struct tm  now  )

static

Definition at line 2682 of file wap_push_ppg.c.

Referenced by deliver_after_test_cleared(), and deliver_before_test_cleared().

{
    time_data[0] = now.tm_year + 1900;
    time_data[1] = now.tm_mon + 1;
    time_data[2] = now.tm_mday;
    time_data[3] = now.tm_hour;
    time_data[4] = now.tm_min;
    time_data[5] = now.tm_sec;
}

ip_allowed_by_ppg()

static int ip_allowed_by_ppg ( Octstr *  ip )

static

Definition at line 586 of file wap_push_ppg.c.

References debug(), error(), PAPEvent::ip, octstr_compare(), octstr_imm(), panic, ppg_allow_ip, ppg_deny_ip, trusted_pi, wap_push_ppg_pushuser_search_ip_from_wildcarded_list(), and warning().

Referenced by pap_request_thread().

{
    if (ip == NULL)
        return 0;    

    if (trusted_pi)
        return 1;

    if (ppg_deny_ip == NULL && ppg_allow_ip == NULL) {
        warning(0, "Your ppg core configuration lacks allowed and denied" 
                   " ip lists");
        return 1;
    }

    if (ppg_deny_ip)
        if (octstr_compare(ppg_deny_ip, octstr_imm("*.*.*.*")) == 0) {
            panic(0, "Your ppg core configuration deny all ips, exiting");
            return 0;
        }

    if (ppg_allow_ip)
        if (octstr_compare(ppg_allow_ip, octstr_imm("*.*.*.*")) == 0) {
            warning(0, "Your ppg core configuration allow all ips");
            return 1;
        }

    if (ppg_deny_ip)
        if (wap_push_ppg_pushuser_search_ip_from_wildcarded_list(ppg_deny_ip, ip, 
            octstr_imm(";"), octstr_imm("."))) {
            error(0, "ip found from denied list");
            return 0;
        }

    if (ppg_allow_ip)
        if (wap_push_ppg_pushuser_search_ip_from_wildcarded_list(ppg_allow_ip, ip, 
            octstr_imm(";"), octstr_imm("."))) {
            debug("wap.push.ppg.pushuser", 0, "PPG: ip_allowed_by_ppg: ip found"
                  " from allowed list");
            return 1;
        }

    warning(0, "did not found ip from any of core lists, deny it");
    return 0;
}

is_phone_number()

static int is_phone_number ( long  type_of_address )

static

Definition at line 3245 of file wap_push_ppg.c.

References ADDR_PLMN, and address_type().

Referenced by pap_request_thread().

{
    return address_type == ADDR_PLMN;
}

ota_abort_to_pap()

static long ota_abort_to_pap ( long  reason )

static

Definition at line 2645 of file wap_push_ppg.c.

References description_t::reason.

Referenced by update_push_data_with_attribute().

{
    long offset;

    offset = reason - 0xEA;
    reason = 5026 + offset;

    return reason;
}

ota_read_thread()

static void ota_read_thread ( void *  arg )

static

Definition at line 634 of file wap_push_ppg.c.

References gwlist_consume(), handle_internal_event(), ppg_queue, run_status, and running.

Referenced by wap_push_ppg_init(), and wap_push_ppg_shutdown().

{
    WAPEvent *e;

    while (run_status == running && (e = gwlist_consume(ppg_queue)) != NULL) {
        handle_internal_event(e);
    } 
}

pap_convert_content()

static int pap_convert_content ( struct content *  content )

static

Definition at line 2007 of file wap_push_ppg.c.

References content::body, converters, NUM_CONVERTERS, octstr_compare(), octstr_create, octstr_destroy(), octstr_imm(), result_type, content::type, and type.

Referenced by transform_message().

{
    long i;
    Octstr *new_body;

    for (i = 0; i < NUM_CONVERTERS; i++) {
        if (octstr_compare(content->type, 
            octstr_imm(converters[i].type)) == 0) {
        new_body = converters[i].convert(content);
            if (new_body == NULL)
            return 0;
            octstr_destroy(content->body);
            content->body = new_body;
            octstr_destroy(content->type); 
            content->type = octstr_create(converters[i].result_type);
            return 1;
        }
    }

    return 1;
}

pap_event_create()

static PAPEvent * pap_event_create ( Octstr *  ip, Octstr *  url, List *  push_headers, Octstr *  mime_content, List *  cgivars, HTTPClient *  client  )

static

Definition at line 646 of file wap_push_ppg.c.

References PAPEvent::cgivars, client(), PAPEvent::client, PAPEvent::ip, PAPEvent::mime_content, PAPEvent::push_headers, url, and PAPEvent::url.

Referenced by http_read_thread().

{
    PAPEvent *p;

    p = gw_malloc(sizeof(PAPEvent));
    p->ip = ip;
    p->url = url;
    p->push_headers = push_headers;
    p->mime_content = mime_content;
    p->cgivars = cgivars;
    p->client = client;

    return p;
}

pap_event_destroy()

static void pap_event_destroy ( PAPEvent *  p )

static

Definition at line 663 of file wap_push_ppg.c.

Referenced by pap_event_destroy_item(), and pap_request_thread().

{
    if (p == NULL)
        return;

    gw_free(p);
}

pap_event_destroy_item()

static void pap_event_destroy_item ( void *  p )

static

Definition at line 671 of file wap_push_ppg.c.

References pap_event_destroy().

Referenced by wap_push_ppg_shutdown().

{
    pap_event_destroy(p);
}

pap_event_unpack()

static void pap_event_unpack ( PAPEvent *  p, Octstr **  ip, Octstr **  url, List **  push_headers, Octstr **  mime_content, List **  cgivars, HTTPClient **  client  )

static

Definition at line 676 of file wap_push_ppg.c.

References PAPEvent::cgivars, client(), PAPEvent::client, PAPEvent::ip, PAPEvent::mime_content, PAPEvent::push_headers, url, and PAPEvent::url.

Referenced by pap_request_thread().

{
    *ip = p->ip;
    *url = p->url;
    *push_headers = p->push_headers;
    *mime_content = p->mime_content;
    *cgivars = p->cgivars;
    *client = p->client;
}

pap_get_content()

static int pap_get_content ( struct content *  content )

static

Definition at line 2034 of file wap_push_ppg.c.

References content::body, extractors, NUM_EXTRACTORS, octstr_case_compare(), octstr_destroy(), octstr_imm(), transfer_encoding, and content::type.

Referenced by transform_message().

{
    long i;
    Octstr *new_body;

    for (i = 0; i < NUM_EXTRACTORS; i++) {
        if (octstr_case_compare(content->type, 
            octstr_imm(extractors[i].transfer_encoding)) == 0) {
        
            new_body = extractors[i].extract(content);
            if (new_body == NULL)
            return 0;
            octstr_destroy(content->body);
            content->body = new_body;
        octstr_destroy(content->type);
        content->type = NULL;
            return 1;
        }
    }

    return 1;
}

pap_request_thread()

static void pap_request_thread ( void *  arg )

static

Definition at line 746 of file wap_push_ppg.c.

References boundary, PAPEvent::cgivars, change_header_value(), client(), content_header, debug(), dict_put(), dict_put_once(), dlr_url, error(), get_mime_boundary(), gw_assert(), gwlist_consume(), handle_push_message(), headers_acceptable(), HTTP_ACCEPTED, http_append_headers(), http_clients, http_close_client(), http_destroy_cgiargs(), http_destroy_headers(), http_header_duplicate(), http_header_remove_all(), HTTP_NOT_FOUND, http_remove_hop_headers(), http_send_reply(), HTTP_UNAUTHORIZED, info(), PAPEvent::ip, ip_allowed_by_ppg(), is_phone_number(), PAPEvent::mime_content, mime_parse(), octstr_compare(), octstr_destroy(), octstr_duplicate, octstr_format(), octstr_get_cstr, octstr_imm(), octstr_len(), PAP_BAD_REQUEST, pap_compile(), PAP_DUPLICATE_PUSH_ID, pap_event_destroy(), pap_event_unpack(), PAP_FORBIDDEN, pap_queue, ppg_url, push_data, PAPEvent::push_headers, remove_link_headers(), remove_mime_headers(), remove_x_kannel_headers(), run_status, running, send_bad_message_response(), set_dlr_mask(), set_dlr_url(), set_service_name(), set_smsbox_id(), set_smsc_id(), tell_fatal_error(), trusted_pi, WAPEvent::u, url, urls, user_configuration, username, wap_push_ppg_pushuser_authenticate(), wap_push_ppg_pushuser_client_phone_number_acceptable(), and warning().

Referenced by wap_push_ppg_init(), and wap_push_ppg_shutdown().

{
    WAPEvent *ppg_event;
    PAPEvent *p;
    size_t push_len;
    Octstr *pap_content = NULL;
    Octstr *push_data = NULL;
    Octstr *rdf_content = NULL;
    Octstr *mime_content = NULL;
    Octstr *plos = NULL;               /* a temporary variable*/
    Octstr *boundary = NULL;
    Octstr *content_header = NULL;     /* Content-Type MIME header */
    Octstr *url = NULL;
    Octstr *ip = NULL;
    Octstr *not_found = NULL;
    Octstr *username = NULL;
    int compiler_status,
        http_status;
    List *push_headers,                /* MIME headers themselves */
         *content_headers,             /* Headers from the content entity, see
                                          pap chapters 8.2, 13.1. Rfc 2045 
                                          grammar calls these MIME-part-hea-
                                          ders */
         *cgivars;
    HTTPClient *client;
    Octstr *dlr_url;
    
    http_status = 0;
    url = ip = mime_content = username = NULL;                
  
    while (run_status == running && (p = gwlist_consume(pap_queue)) != NULL) {

        http_status = HTTP_NOT_FOUND;
        pap_event_unpack(p, &ip, &url, &push_headers, &mime_content, 
                         &cgivars, &client);      

        if (octstr_compare(url, ppg_url) != 0) {
            error(0,  "Request <%s> from <%s>: service not found", 
                  octstr_get_cstr(url), octstr_get_cstr(ip));
            debug("wap.push.ppg", 0, "your configuration uses %s",
                  octstr_get_cstr(ppg_url));           
            not_found = octstr_imm("Service not specified\n");
            http_send_reply(client, http_status, push_headers, not_found);
            goto ferror;
        }

        http_status = HTTP_UNAUTHORIZED;
   
        if (!ip_allowed_by_ppg(ip)) {
            error(0,  "Request <%s> from <%s>: ip forbidden, closing the"
                  " client", octstr_get_cstr(url), octstr_get_cstr(ip));
            http_close_client(client);
            goto ferror; 
        }

        if (!trusted_pi && user_configuration) {
        if (!wap_push_ppg_pushuser_authenticate(client, cgivars, ip, 
                                                    push_headers, &username)) {
                 error(0,  "Request <%s> from <%s>: authorisation failure",
                       octstr_get_cstr(url), octstr_get_cstr(ip));
                 goto ferror;
            }
        } else {                        /* J�rg, this wont disappear again */
        username = octstr_imm("");
    }

        http_status = HTTP_ACCEPTED;
        info(0, "PPG: Accept request <%s> from <%s>", octstr_get_cstr(url), 
             octstr_get_cstr(ip));
        
        if (octstr_len(mime_content) == 0) {
        warning(0, "PPG: No MIME content received, the request"
                    " unacceptable");
            send_bad_message_response(&client, octstr_imm("No MIME content"), 
                                      PAP_BAD_REQUEST, http_status);
            if (client == NULL)
                break;
            goto ferror;
        }

        if (!push_headers) {
            warning(0, "PPG: No push headers received , the request"
                    " unacceptable");
            send_bad_message_response(&client, octstr_imm("No push headers"), 
                                      PAP_BAD_REQUEST, http_status);
            if (client == NULL)
                break;
            goto ferror;
        }
        octstr_destroy(ip);
        
        http_remove_hop_headers(push_headers);
        remove_mime_headers(&push_headers);
        remove_link_headers(&push_headers);

        if (!headers_acceptable(push_headers, &content_header)) {
            warning(0,  "PPG: Unparsable push headers, the request"
                    " unacceptable");
            send_bad_message_response(&client, content_header, PAP_BAD_REQUEST,
                                      http_status);
            if (client == NULL)
                break;
            goto herror;
        }
        
        if (get_mime_boundary(push_headers, content_header, &boundary) == -1) {
            warning(0, "PPG: No MIME boundary, the request unacceptable");
            send_bad_message_response(&client, content_header, PAP_BAD_REQUEST,
                                      http_status);
            if (client == NULL) 
                break;
            goto berror;
        }

        gw_assert(mime_content);
        if (!mime_parse(boundary, mime_content, &pap_content, &push_data, 
                        &content_headers, &rdf_content)) {
            send_bad_message_response(&client, mime_content, PAP_BAD_REQUEST,
                                      http_status);
            if (client == NULL)
                break;
            warning(0, "PPG: unable to parse mime content, the request"
                    " unacceptable");
            goto clean;
        } else {
            debug("wap.push.ppg", 0, "PPG: http_read_thread: pap multipart"
                  " accepted");
        }
        
        push_len = octstr_len(push_data); 
        http_header_remove_all(push_headers, "Content-Type");
    http_append_headers(push_headers, content_headers);
        change_header_value(&push_headers, "Content-Length", 
            octstr_get_cstr(plos = octstr_format("%d", push_len)));
        octstr_destroy(plos);
        octstr_destroy(content_header);
    http_destroy_headers(content_headers);

        ppg_event = NULL;
        if ((compiler_status = pap_compile(pap_content, &ppg_event)) == -2) {
        send_bad_message_response(&client, pap_content, PAP_BAD_REQUEST,
                                       http_status);
            if (client == NULL)
            break;
            warning(0, "PPG: pap control entity erroneous, the request" 
                    " unacceptable");
            goto no_compile;
        } else if (compiler_status == -1) {
            send_bad_message_response(&client, pap_content, PAP_BAD_REQUEST,
                                      http_status);
            if (client == NULL)
            break;
            warning(0, "PPG: non implemented pap feature requested, the"
                    " request unacceptable");
            goto no_compile;
        } else {
        if (!dict_put_once(http_clients, 
            ppg_event->u.Push_Message.pi_push_id, client)) {
                warning(0, "PPG: duplicate push id, the request unacceptable");
            tell_fatal_error(&client, ppg_event, url, http_status, 
                                 PAP_DUPLICATE_PUSH_ID);
                if (client == NULL)
                break;
                goto not_acceptable;
        } 

            dict_put(urls, ppg_event->u.Push_Message.pi_push_id, url); 
 
            if (is_phone_number(ppg_event->u.Push_Message.address_type)) {
                if (!trusted_pi && user_configuration && 
                        !wap_push_ppg_pushuser_client_phone_number_acceptable(
                        username, ppg_event->u.Push_Message.address_value)) {
                    tell_fatal_error(&client, ppg_event, url, http_status, 
                                    PAP_FORBIDDEN);
                    if (client == NULL)
                    break;
                    goto not_acceptable;
                }   
            }        
            
            debug("wap.push.ppg", 0, "PPG: http_read_thread: pap control"
                  " entity compiled ok");
            ppg_event->u.Push_Message.push_data = octstr_duplicate(push_data);
            ppg_event->u.Push_Message.smsc_id = set_smsc_id(push_headers, username,
                                                            trusted_pi);
            dlr_url = set_dlr_url(push_headers, username, trusted_pi);
            ppg_event->u.Push_Message.dlr_url = dlr_url;
            ppg_event->u.Push_Message.dlr_mask = set_dlr_mask(push_headers, dlr_url);
            ppg_event->u.Push_Message.smsbox_id = set_smsbox_id(push_headers, username,
                                                                trusted_pi);
            ppg_event->u.Push_Message.service_name = set_service_name();
            remove_x_kannel_headers(&push_headers);
            ppg_event->u.Push_Message.push_headers = http_header_duplicate(push_headers);
            
            if (!handle_push_message(&client, ppg_event, http_status)) {
            if (client == NULL)
            break;
                goto no_transform;
            }
        }

        pap_event_destroy(p);
        http_destroy_headers(push_headers);
        http_destroy_cgiargs(cgivars);
        octstr_destroy(username);
        octstr_destroy(mime_content);
        octstr_destroy(pap_content);
        octstr_destroy(push_data);
        octstr_destroy(rdf_content);
        octstr_destroy(boundary);
        boundary = rdf_content = push_data = pap_content = mime_content = username = NULL;
        continue;

no_transform:
        pap_event_destroy(p);
        http_destroy_headers(push_headers);
        http_destroy_cgiargs(cgivars);
        octstr_destroy(username);
        octstr_destroy(mime_content);
        octstr_destroy(pap_content);
        octstr_destroy(push_data);
        octstr_destroy(rdf_content);
        octstr_destroy(boundary);
        boundary = rdf_content = push_data = pap_content = mime_content = username = NULL;
        continue;

no_compile:
        pap_event_destroy(p);
        http_destroy_headers(push_headers);
        http_destroy_cgiargs(cgivars);
        octstr_destroy(username);
        octstr_destroy(mime_content);
        octstr_destroy(push_data);
        octstr_destroy(rdf_content);
        octstr_destroy(boundary);
        octstr_destroy(url);
        url = boundary = rdf_content = push_data = mime_content = username = NULL;
        continue;

not_acceptable:
        pap_event_destroy(p);
        http_destroy_headers(push_headers);
        http_destroy_cgiargs(cgivars);
        octstr_destroy(username);
        octstr_destroy(mime_content);
        octstr_destroy(pap_content);
        octstr_destroy(push_data);
        octstr_destroy(rdf_content);
        octstr_destroy(boundary);
        octstr_destroy(url);
        url = boundary = rdf_content = push_data = pap_content = mime_content = username = NULL;
        continue;

clean:
        pap_event_destroy(p);
        http_destroy_headers(push_headers);
        http_destroy_headers(content_headers);
        octstr_destroy(pap_content);
        octstr_destroy(push_data);
        octstr_destroy(rdf_content);
        octstr_destroy(content_header);
        octstr_destroy(boundary);
        octstr_destroy(url);
        url = boundary = content_header = rdf_content = push_data = pap_content = NULL;
        continue;

ferror:
        pap_event_destroy(p);
        http_destroy_headers(push_headers);
        http_destroy_cgiargs(cgivars);
        octstr_destroy(username);
        octstr_destroy(url);
        octstr_destroy(ip);
        octstr_destroy(mime_content);
        mime_content = ip = url = username = NULL;
        continue;

herror:
        pap_event_destroy(p);
        http_destroy_headers(push_headers);
        http_destroy_cgiargs(cgivars);
        octstr_destroy(username);
        octstr_destroy(url);
        url = username = NULL;
        continue;

berror:
        pap_event_destroy(p);
        http_destroy_headers(push_headers);
        http_destroy_cgiargs(cgivars);
        octstr_destroy(username);
        octstr_destroy(mime_content);
        octstr_destroy(content_header);
        octstr_destroy(boundary);
        octstr_destroy(url);
        url = boundary = content_header = mime_content = username = NULL;
        continue;
    }
}

parse_appid_header()

static long parse_appid_header ( Octstr **  assigned_code )

static

Definition at line 2845 of file wap_push_ppg.c.

References NUMBER_OF_WINA_URIS, octstr_case_search(), octstr_delete(), octstr_destroy(), octstr_format(), octstr_imm(), octstr_len(), octstr_search(), and wina_uri.

Referenced by check_x_wap_application_id_header().

{
    long pos,
         coded_value;
    size_t i;

    if ((pos = octstr_search(*appid_content, octstr_imm(";"), 0)) >= 0) {
        octstr_delete(*appid_content, pos, 
                      octstr_len(octstr_imm(";app-encoding=")));
        octstr_delete(*appid_content, 0, pos);         /* the URI part */
        return -1;
    } 

    i = 0;
    while (i < NUMBER_OF_WINA_URIS) {
        if ((pos = octstr_case_search(*appid_content, 
                octstr_imm(wina_uri[i]), 0)) >= 0)
            break;
        ++i;
    }

    if (i == NUMBER_OF_WINA_URIS) {
        octstr_destroy(*appid_content);
        *appid_content = octstr_format("%ld", 2);      /* assigned number */
        return -1;                                     /* for wml ua */
    }
    
    octstr_delete(*appid_content, 0, pos);             /* again the URI */
    if ((coded_value = wsp_string_to_application_id(*appid_content)) >= 0) {
        octstr_destroy(*appid_content);
        *appid_content = octstr_format("%ld", coded_value);
        return coded_value;
    }

    return -1;
}

push_has_pi_push_id()

static int push_has_pi_push_id ( void *  a, void *  b  )

static

Definition at line 2515 of file wap_push_ppg.c.

References octstr_compare().

Referenced by find_ppg_push_machine_using_pi_push_id(), and find_unit_ppg_push_machine_using_pi_push_id().

{
    Octstr *pi_push_id;
    PPGPushMachine *pm;

    pi_push_id = b;
    pm = a;

    return octstr_compare(pm->pi_push_id, pi_push_id) == 0;
}

push_has_pid()

static int push_has_pid ( void *  a, void *  b  )

static

Definition at line 2491 of file wap_push_ppg.c.

Referenced by find_ppg_push_machine_using_pid(), update_push_data_with_attribute(), and update_session_data_with_headers().

{
    long *pid;
    PPGPushMachine *pm;

    pid = b;
    pm = a;
    
    return *pid == pm->push_id;
}

push_machine_assert()

static void push_machine_assert ( PPGPushMachine *  pm )

static

Definition at line 1727 of file wap_push_ppg.c.

References gw_assert().

Referenced by abort_delivery(), create_session(), deliver_pending_pushes(), deliver_unit_push(), handle_internal_event(), remove_push_data(), request_confirmed_push(), request_push(), request_unit_push(), response_push_message(), and update_push_data_with_attribute().

{
    gw_assert(pm);
    gw_assert(pm->pi_push_id);
    gw_assert(pm->push_id >= 0);
    gw_assert(pm->session_id >= 0);
    gw_assert(pm->addr_tuple);
    gw_assert(pm->trusted == 1 || pm->trusted == 0);
    gw_assert(pm->authenticated  == 1 || pm->authenticated == 0);
}

push_machine_create()

static PPGPushMachine * push_machine_create ( WAPEvent *  e, WAPAddrTuple *  tuple  )

static

Definition at line 1362 of file wap_push_ppg.c.

References counter_increase(), debug(), http_header_duplicate(), octstr_duplicate, push_id_counter, WAPEvent::u, and wap_addr_tuple_duplicate().

Referenced by store_push_data().

{
    PPGPushMachine *m;

    m = gw_malloc(sizeof(PPGPushMachine));

    #define INTEGER(name) m->name = 0;
    #define OCTSTR(name) m->name = NULL;
    #define OPTIONAL_OCTSTR(name) m->name = NULL;
    #define ADDRTUPLE(name) m->name = NULL;
    #define CAPABILITIES m->name = NULL;
    #define HTTPHEADER(name) m->name = NULL;
    #define MACHINE(fields) fields
    #include "wap_ppg_push_machine.def"

    m->addr_tuple = wap_addr_tuple_duplicate(tuple);
    m->pi_push_id = octstr_duplicate(e->u.Push_Message.pi_push_id);
    m->push_id = counter_increase(push_id_counter);
    m->delivery_method = e->u.Push_Message.delivery_method;
    m->deliver_after_timestamp = 
        octstr_duplicate(e->u.Push_Message.deliver_after_timestamp);
    m->priority = e->u.Push_Message.priority;
    m->push_headers = http_header_duplicate(e->u.Push_Message.push_headers);
    m->push_data = octstr_duplicate(e->u.Push_Message.push_data);

    m->address_type = e->u.Push_Message.address_type;
    if (e->u.Push_Message.smsc_id != NULL)
        m->smsc_id = octstr_duplicate(e->u.Push_Message.smsc_id);
    else
        m->smsc_id = NULL;
    if (e->u.Push_Message.dlr_url != NULL)
        m->dlr_url = octstr_duplicate(e->u.Push_Message.dlr_url);                                 
    else
        m->dlr_url = NULL;
    m->dlr_mask = e->u.Push_Message.dlr_mask;
    if (e->u.Push_Message.smsbox_id != NULL)
        m->smsbox_id = octstr_duplicate(e->u.Push_Message.smsbox_id);
    else
        m->smsbox_id = NULL;
    m->service_name = octstr_duplicate(e->u.Push_Message.service_name);

    m->progress_notes_requested = e->u.Push_Message.progress_notes_requested;
    if (e->u.Push_Message.progress_notes_requested)
        m->ppg_notify_requested_to = 
            octstr_duplicate(e->u.Push_Message.ppg_notify_requested_to);

    debug("wap.push.ppg", 0, "PPG: push machine %ld created", m->push_id);

    return m;
}

push_machine_destroy()

static void push_machine_destroy ( void *  pm )

static

Definition at line 1417 of file wap_push_ppg.c.

References debug().

Referenced by push_machines_list_destroy(), remove_push_data(), and wap_push_ppg_shutdown().

{
    PPGPushMachine *pm;

    if (p == NULL)
        return;

    pm = p;

    debug("wap.push.ppg", 0, "PPG: destroying push machine %ld", 
          pm->push_id); 
    #define OCTSTR(name) octstr_destroy(pm->name);
    #define OPTIONAL_OCTSTR(name) octstr_destroy(pm->name);
    #define INTEGER(name)
    #define ADDRTUPLE(name) wap_addr_tuple_destroy(pm->name);
    #define CAPABILITIES(name) wap_cap_destroy_list(pm->name);
    #define HTTPHEADER(name) http_destroy_headers(pm->name);
    #define MACHINE(fields) fields
    #include "wap_ppg_push_machine.def"

    gw_free(p);
}

push_machines_list_destroy()

static void push_machines_list_destroy ( List *  pl )

static

Definition at line 1440 of file wap_push_ppg.c.

References gwlist_destroy(), and push_machine_destroy().

{
    if (machines == NULL)
        return;

    gwlist_destroy(machines, push_machine_destroy);
}

read_ppg_config()

static int read_ppg_config ( Cfg *  cfg )

static

Definition at line 523 of file wap_push_ppg.c.

References cfg, cfg_destroy(), cfg_get, cfg_get_bool(), cfg_get_integer(), cfg_get_multi_group(), cfg_get_single_group(), global_sender, gwlist_destroy(), NO_HTTPS_PORT, number_of_pushes, number_of_users, octstr_destroy(), octstr_format(), octstr_imm(), panic, ppg_allow_ip, ppg_default_smsc, ppg_deny_ip, ppg_dlr_url, ppg_port, ppg_smsbox_id, ppg_url, service_name, trusted_pi, USER_CONFIGURATION_ADDED, USER_CONFIGURATION_NOT_ADDED, and wap_push_ppg_pushuser_list_add().

Referenced by wap_push_ppg_init().

{
     CfgGroup *grp;
     List *list;

     if (cfg == NULL)
         return USER_CONFIGURATION_NOT_ADDED;

     grp = cfg_get_single_group(cfg, octstr_imm("ppg"));
     if ((ppg_url = cfg_get(grp, octstr_imm("ppg-url"))) == NULL)
         ppg_url = octstr_imm("/wappush");
     cfg_get_integer(&ppg_port, grp, octstr_imm("ppg-port"));
     cfg_get_integer(&number_of_pushes, grp, octstr_imm("concurrent-pushes"));
     cfg_get_bool(&trusted_pi, grp, octstr_imm("trusted-pi"));
     cfg_get_integer(&number_of_users, grp, octstr_imm("users"));
     ppg_deny_ip = cfg_get(grp, octstr_imm("ppg-deny-ip"));
     ppg_allow_ip = cfg_get(grp, octstr_imm("ppg-allow-ip"));
     if ((global_sender = cfg_get(grp, octstr_imm("global-sender"))) == NULL)
         global_sender = octstr_format("%s", "1234");
     ppg_default_smsc = cfg_get(grp, octstr_imm("default-smsc"));
     ppg_dlr_url = cfg_get(grp, octstr_imm("default-dlr-url"));
     ppg_smsbox_id = cfg_get(grp, octstr_imm("ppg-smsbox-id"));
     if ((service_name = cfg_get(grp, octstr_imm("service-name"))) == NULL)
         service_name = octstr_format("%s", "ppg");
   
#ifdef HAVE_LIBSSL
     cfg_get_integer(&ppg_ssl_port, grp, octstr_imm("ppg-ssl-port"));
     ssl_server_cert_file = cfg_get(grp, octstr_imm("ssl-server-cert-file"));
     ssl_server_key_file = cfg_get(grp, octstr_imm("ssl-server-key-file"));
     if (ppg_ssl_port != NO_HTTPS_PORT) {
        if (ssl_server_cert_file == NULL || ssl_server_key_file == NULL) 
            panic(0, "cannot continue without server cert and/or key files");
        conn_use_global_server_certkey_file(ssl_server_cert_file, ssl_server_key_file);
     }        
     octstr_destroy(ssl_server_cert_file);
     octstr_destroy(ssl_server_key_file);
#endif

     /* If pi is trusted, ignore possible user groups. */
     if (trusted_pi) {
        cfg_destroy(cfg);
        return USER_CONFIGURATION_ADDED;
     }

     /* But if it is not, we cannot continue without user groups.*/
     if ((list = cfg_get_multi_group(cfg, octstr_imm("wap-push-user")))
              == NULL) {
         panic(0, "No user group but ppg not trusted, stopping");
         gwlist_destroy(list, NULL);
         cfg_destroy(cfg); 
         return USER_CONFIGURATION_NOT_ADDED;
     }
    
     if (!wap_push_ppg_pushuser_list_add(list, number_of_pushes, 
                                         number_of_users)) {
         panic(0, "unable to create users configuration list, exiting");
         return USER_CONFIGURATION_NOT_ADDED;     
     }  

     cfg_destroy(cfg); 
     return USER_CONFIGURATION_ADDED;
}

remove_link_headers()

static void remove_link_headers ( List **  push_headers )

static

Definition at line 3009 of file wap_push_ppg.c.

References http_header_remove_all().

Referenced by pap_request_thread().

{
    http_header_remove_all(*push_headers, "Host");
}

remove_mime_headers()

static void remove_mime_headers ( List **  push_headers )

static

Definition at line 3001 of file wap_push_ppg.c.

References http_header_remove_all().

Referenced by pap_request_thread().

{
    http_header_remove_all(*push_headers, "MIME-Version");
}

remove_push_data()

static void remove_push_data ( PPGSessionMachine *  sm, PPGPushMachine *  pm, int  cless  )

static

Definition at line 2257 of file wap_push_ppg.c.

References gwlist_delete_equal(), ppg_unit_pushes, push_machine_assert(), push_machine_destroy(), and session_machine_assert().

Referenced by abort_delivery(), deliver_pending_pushes(), handle_internal_event(), handle_push_message(), and remove_session_data().

{
    push_machine_assert(pm);

    if (cless) {
        gwlist_delete_equal(ppg_unit_pushes, pm);
    } else {
        session_machine_assert(sm);
        gwlist_delete_equal(sm->push_machines, pm);
    }

    push_machine_destroy(pm);
}

remove_pushless_session()

static void remove_pushless_session ( PPGSessionMachine *  sm )

static

Definition at line 2437 of file wap_push_ppg.c.

References gwlist_delete_equal(), gwlist_len(), ppg_machines, session_machine_assert(), and session_machine_destroy().

Referenced by handle_push_message().

{
    session_machine_assert(sm);

    if (gwlist_len(sm->push_machines) == 0) {
        gwlist_delete_equal(ppg_machines, sm);
        session_machine_destroy(sm);
    }
}

remove_session_data()

static void remove_session_data ( PPGSessionMachine *  sm, int  status  )

static

Definition at line 2415 of file wap_push_ppg.c.

References code, gwlist_delete_equal(), gwlist_get(), gwlist_len(), PAP_ABORT_USERPND, ppg_machines, remove_push_data(), response_push_message(), session_machine_assert(), and session_machine_destroy().

Referenced by handle_internal_event().

{
    long code;
    PPGPushMachine *pm;

    session_machine_assert(sm);

    code = PAP_ABORT_USERPND;
    
    while (gwlist_len(sm->push_machines) > 0) {
        pm = gwlist_get(sm->push_machines, 0);
        response_push_message(pm, code, status);
        remove_push_data(sm, pm, sm == NULL);
    }

    gwlist_delete_equal(ppg_machines, sm);
    session_machine_destroy(sm);
}

remove_x_kannel_headers()

static void remove_x_kannel_headers ( List **  push_headers )

static

Definition at line 3017 of file wap_push_ppg.c.

References http_header_remove_all().

Referenced by pap_request_thread().

{
    http_header_remove_all(*push_headers, "X-Kannel-SMSC");
    http_header_remove_all(*push_headers, "X-Kannel-DLR-Url");
    http_header_remove_all(*push_headers, "X-Kannel-DLR-Mask");
    http_header_remove_all(*push_headers, "X-Kannel-Smsbox-Id");
}

replace_octstr_char()

static void replace_octstr_char ( Octstr *  os1, Octstr *  os2, long *  pos  )

static

Definition at line 3250 of file wap_push_ppg.c.

References octstr_delete(), octstr_insert(), and octstr_len().

Referenced by escape_fragment().

{
    octstr_delete(os1, *pos, 1);
    octstr_insert(os1, os2, *pos);
    *pos += octstr_len(os2) - 1;
}

request_confirmed_push()

static void request_confirmed_push ( long  last, PPGPushMachine *  pm, PPGSessionMachine *  sm  )

static

Definition at line 1523 of file wap_push_ppg.c.

References debug(), dispatch_to_ota, gw_assert(), http_header_duplicate(), octstr_duplicate, PAPEvent::push_headers, push_machine_assert(), session_machine_assert(), WAPEvent::u, and wap_event_create.

Referenced by deliver_confirmed_push(), and deliver_pending_pushes().

{
    WAPEvent *ota_event;
    List *push_headers;

    gw_assert(last == 0 || last == 1);
    push_machine_assert(pm);
    session_machine_assert(sm);
    
    push_headers = http_header_duplicate(pm->push_headers);

    ota_event = wap_event_create(Po_ConfirmedPush_Req);
    ota_event->u.Po_ConfirmedPush_Req.server_push_id = pm->push_id;
    ota_event->u.Po_ConfirmedPush_Req.push_headers = push_headers;
    ota_event->u.Po_ConfirmedPush_Req.authenticated = pm->authenticated;
    ota_event->u.Po_ConfirmedPush_Req.trusted = pm->trusted;
    ota_event->u.Po_ConfirmedPush_Req.last = last;
 
    if (pm->push_data != NULL)
        ota_event->u.Po_ConfirmedPush_Req.push_body = 
            octstr_duplicate(pm->push_data);
    else
        ota_event->u.Po_ConfirmedPush_Req.push_body = NULL;

    ota_event->u.Po_ConfirmedPush_Req.session_handle = sm->session_id;
    debug("wap.push.ota", 0, "PPG: confirmed push request to OTA");
    
    dispatch_to_ota(ota_event);
}

request_push()

static void request_push ( long  last, PPGPushMachine *  sm  )

static

Definition at line 1600 of file wap_push_ppg.c.

References debug(), dispatch_to_ota, gw_assert(), http_header_duplicate(), octstr_duplicate, PAPEvent::push_headers, push_machine_assert(), WAPEvent::u, and wap_event_create.

Referenced by deliver_pending_pushes(), and deliver_unit_push().

{
    WAPEvent *ota_event;
    List *push_headers;

    gw_assert(last == 0 || last == 1);
    push_machine_assert(pm);
    
    push_headers = http_header_duplicate(pm->push_headers);

    ota_event = wap_event_create(Po_Push_Req);
    ota_event->u.Po_Push_Req.push_headers = push_headers;
    ota_event->u.Po_Push_Req.authenticated = pm->authenticated;
    ota_event->u.Po_Push_Req.trusted = pm->trusted;
    ota_event->u.Po_Push_Req.last = last;

    if (pm->push_data != NULL)
        ota_event->u.Po_Push_Req.push_body = 
            octstr_duplicate(pm->push_data);
    else
        ota_event->u.Po_Push_Req.push_body = NULL;        

    ota_event->u.Po_Push_Req.session_handle = pm->session_id;
    debug("wap.push.ppg", 0, "PPG: OTA request for push");
    
    dispatch_to_ota(ota_event);
}

request_unit_push()

static void request_unit_push ( long  last, PPGPushMachine *  pm  )

static

Definition at line 1558 of file wap_push_ppg.c.

References debug(), dispatch_to_ota, gw_assert(), http_header_duplicate(), octstr_duplicate, PAPEvent::push_headers, push_machine_assert(), WAPEvent::u, wap_addr_tuple_duplicate(), and wap_event_create.

Referenced by deliver_unit_push().

{
    WAPEvent *ota_event;
    List *push_headers;

    gw_assert(last == 0 || last == 1);
    push_machine_assert(pm);
    
    push_headers = http_header_duplicate(pm->push_headers);

    ota_event = wap_event_create(Po_Unit_Push_Req);
    ota_event->u.Po_Unit_Push_Req.addr_tuple = 
        wap_addr_tuple_duplicate(pm->addr_tuple);
    ota_event->u.Po_Unit_Push_Req.push_id = pm->push_id;
    ota_event->u.Po_Unit_Push_Req.push_headers = push_headers;
    ota_event->u.Po_Unit_Push_Req.authenticated = pm->authenticated;
    ota_event->u.Po_Unit_Push_Req.trusted = pm->trusted;
    ota_event->u.Po_Unit_Push_Req.last = last;

    ota_event->u.Po_Unit_Push_Req.address_type = pm->address_type;
    if (pm->smsc_id != NULL)
        ota_event->u.Po_Unit_Push_Req.smsc_id = octstr_duplicate(pm->smsc_id);
    else
        ota_event->u.Po_Unit_Push_Req.smsc_id = NULL;
    if (pm->dlr_url != NULL)
        ota_event->u.Po_Unit_Push_Req.dlr_url = octstr_duplicate(pm->dlr_url);
    else
        ota_event->u.Po_Unit_Push_Req.dlr_url = NULL;
    ota_event->u.Po_Unit_Push_Req.dlr_mask = pm->dlr_mask;
    if (pm->smsbox_id != NULL)   
        ota_event->u.Po_Unit_Push_Req.smsbox_id = octstr_duplicate(pm->smsbox_id);
    else
        ota_event->u.Po_Unit_Push_Req.smsbox_id = NULL;
    if (pm->service_name != NULL)    
        ota_event->u.Po_Unit_Push_Req.service_name = octstr_duplicate(pm->service_name);

    ota_event->u.Po_Unit_Push_Req.push_body = octstr_duplicate(pm->push_data);

    dispatch_to_ota(ota_event);
    debug("wap.push.ppg", 0, "PPG: OTA request for unit push");
}

response_push_connection()

static int response_push_connection ( WAPEvent *  e, PPGSessionMachine *  sm  )

static

Definition at line 1645 of file wap_push_ppg.c.

References check_capabilities(), dispatch_to_appl, gw_assert(), WAPEvent::type, WAPEvent::u, wap_event_create, and wsp_cap_duplicate_list().

Referenced by handle_internal_event().

{
    WAPEvent *appl_event;

    gw_assert(e->type == Pom_Connect_Ind);

    if (sm->assumed_capabilities != NULL && check_capabilities(
            e->u.Pom_Connect_Ind.requested_capabilities, 
            sm->assumed_capabilities) == 0)
       return 0;

    appl_event = wap_event_create(Pom_Connect_Res);
    appl_event->u.Pom_Connect_Res.negotiated_capabilities = 
        wsp_cap_duplicate_list(e->u.Pom_Connect_Ind.requested_capabilities);
    appl_event->u.Pom_Connect_Res.session_id = e->u.Pom_Connect_Ind.session_id;

    dispatch_to_appl(appl_event);

    return 1;
}

response_push_message()

static HTTPClient * response_push_message ( PPGPushMachine *  pm, long  code, int  status  )

static

Definition at line 1671 of file wap_push_ppg.c.

References code, describe_code(), octstr_duplicate, push_machine_assert(), send_push_response(), set_time(), tell_ppg_name(), WAPEvent::u, and wap_event_create.

Referenced by abort_delivery(), handle_push_message(), and remove_session_data().

{
    WAPEvent *e;
    HTTPClient *c;

    push_machine_assert(pm);

    e = wap_event_create(Push_Response);
    e->u.Push_Response.pi_push_id = octstr_duplicate(pm->pi_push_id);
    e->u.Push_Response.sender_name = tell_ppg_name();
    e->u.Push_Response.reply_time = set_time();
    e->u.Push_Response.code = code;
    e->u.Push_Response.desc = describe_code(code);

    c = send_push_response(e, status);

    return c;
}

select_bearer_network()

int select_bearer_network ( WAPEvent **  e )

static

Definition at line 2092 of file wap_push_ppg.c.

References bearers, gw_assert(), networks, NUMBER_OF_BEARERS, NUMBER_OF_NETWORKS, octstr_case_compare(), and octstr_imm().

Referenced by handle_push_message().

{
    Octstr *bearer,
           *network;
    int bearer_required,
        network_required;
    size_t i, 
           j;

    gw_assert((**e).type == Push_Message);

    bearer_required = (**e).u.Push_Message.bearer_required;
    network_required = (**e).u.Push_Message.network_required;
    bearer = octstr_imm("Any");
    network = octstr_imm("Any");
    
    if (!bearer_required || !network_required)
        return 1;

    if (bearer_required)
        bearer = (**e).u.Push_Message.bearer;
    if (network_required)
        network = (**e).u.Push_Message.network;
    
    for (i = 0; i < NUMBER_OF_NETWORKS ; ++i) {
        if (octstr_case_compare(network, octstr_imm(networks[i])) == 0)
            break;
    }
    for (j = 0; j < NUMBER_OF_BEARERS ; ++j) {
        if (octstr_case_compare(bearer, octstr_imm(bearers[j])) == 0)
            break;
    }
    if (i == NUMBER_OF_NETWORKS || j == NUMBER_OF_BEARERS)
        return 0;

    return 1;
}

send_bad_message_response()

static void send_bad_message_response ( HTTPClient **  c, Octstr *  body_fragment, int  code, int  status  )

static

Definition at line 3030 of file wap_push_ppg.c.

References code, debug(), escape_fragment(), octstr_destroy(), octstr_format(), octstr_format_append(), octstr_len(), and send_to_pi().

Referenced by pap_request_thread().

{
    Octstr *reply_body;

    reply_body = octstr_format("%s", 
        "<?xml version=\"1.0\"?>"
        "<!DOCTYPE pap PUBLIC \"-//WAPFORUM//DTD PAP 1.0//EN\""
                   " \"http://www.wapforum.org/DTD/pap_1.0.dtd\">"
        "<pap>"
             "<badmessage-response code=\"");
    octstr_format_append(reply_body, "%d", code);
    octstr_format_append(reply_body, "%s", "\""
                  " desc=\"");
    octstr_format_append(reply_body, "%s", "Not understood due to malformed"
                                           " syntax");
    octstr_format_append(reply_body, "%s", "\"");

    if (fragment != NULL && octstr_len(fragment) != 0) {
        octstr_format_append(reply_body, "%s", " bad-message-fragment=\"");
        octstr_format_append(reply_body, "%S", escape_fragment(fragment));
        octstr_format_append(reply_body, "%s", "\"");
    }

    octstr_format_append(reply_body, "%s", ">"
              "</badmessage-response>"
         "</pap>");

    debug("wap.push.ppg", 0, "PPG: send_bad_message_response: telling pi");
    send_to_pi(c, reply_body, status);

    octstr_destroy(fragment);
}

send_push_response()

static HTTPClient * send_push_response ( WAPEvent *  e, int  status  )

static

Definition at line 3070 of file wap_push_ppg.c.

References debug(), dict_get(), dict_remove(), gw_assert(), http_clients, octstr_destroy(), octstr_format(), octstr_format_append(), send_to_pi(), WAPEvent::type, WAPEvent::u, url, urls, and wap_event_destroy().

Referenced by response_push_message().

{
    Octstr *reply_body,
           *url;
    HTTPClient *c;

    gw_assert(e->type == Push_Response);
    url = dict_get(urls, e->u.Push_Response.pi_push_id);
    dict_remove(urls, e->u.Push_Response.pi_push_id);

    reply_body = octstr_format("%s", 
        "<?xml version=\"1.0\"?>"
        "<!DOCTYPE pap PUBLIC \"-//WAPFORUM//DTD PAP 1.0//EN\""
                   " \"http://www.wapforum.org/DTD/pap_1.0.dtd\">"
        "<pap>"
             "<push-response push-id=\"");
    octstr_format_append(reply_body, "%S", e->u.Push_Response.pi_push_id);
    octstr_format_append(reply_body, "%s", "\""); 

    if (e->u.Push_Response.sender_name != NULL) {
        octstr_format_append(reply_body, "%s",
                   " sender-name=\"");
        octstr_format_append(reply_body, "%S", 
            e->u.Push_Response.sender_name);
        octstr_format_append(reply_body, "%s", "\"");
    }

    if (e->u.Push_Response.reply_time != NULL) {
        octstr_format_append(reply_body, "%s",
                   " reply-time=\"");
        octstr_format_append(reply_body, "%S", 
            e->u.Push_Response.reply_time);
        octstr_format_append(reply_body, "%s", "\"");
    }

    if (url != NULL) {
        octstr_format_append(reply_body, "%s",
                   " sender-address=\"");
        octstr_format_append(reply_body, "%S", url);
        octstr_format_append(reply_body, "%s", "\"");
    }

    octstr_format_append(reply_body, "%s", ">"
             "<response-result code =\"");
    octstr_format_append(reply_body, "%d", e->u.Push_Response.code);
    octstr_format_append(reply_body, "%s", "\"");

    if (e->u.Push_Response.desc != NULL) {
        octstr_format_append(reply_body, "%s", " desc=\"");
        octstr_format_append(reply_body, "%S", e->u.Push_Response.desc);
        octstr_format_append(reply_body, "\"");
    }
    
    octstr_format_append(reply_body, "%s", ">"
              "</response-result>"
              "</push-response>"
          "</pap>");

    octstr_destroy(url);

    c = dict_get(http_clients, e->u.Push_Response.pi_push_id);
    dict_remove(http_clients, e->u.Push_Response.pi_push_id);

    debug("wap.push.ppg", 0, "PPG: send_push_response: telling pi");
    send_to_pi(&c, reply_body, status);

    wap_event_destroy(e);
    return c;
}

send_to_pi()

static void send_to_pi ( HTTPClient **  c, Octstr *  reply_body, int  status  )

static

Definition at line 3205 of file wap_push_ppg.c.

References http_create_empty_headers(), http_destroy_headers(), http_header_add(), http_send_reply(), and octstr_destroy().

Referenced by send_bad_message_response(), send_push_response(), and tell_fatal_error().

                                                                       {
    List *reply_headers;

    reply_headers = http_create_empty_headers();
    http_header_add(reply_headers, "Content-Type", "application/xml");

    if (*c != NULL)
        http_send_reply(*c, status, reply_headers, reply_body);

    octstr_destroy(reply_body);
    http_destroy_headers(reply_headers);
}

session_find_using_pi_client_address()

PPGSessionMachine * session_find_using_pi_client_address ( Octstr *  addr )

static

Definition at line 2145 of file wap_push_ppg.c.

References gwlist_search(), ppg_machines, and session_has_pi_client_address().

Referenced by handle_push_message().

{
    PPGSessionMachine *sm;
    
    sm = gwlist_search(ppg_machines, caddr, session_has_pi_client_address);

    return sm;
}

session_has_addr()

static int session_has_addr ( void *  a, void *  b  )

static

Definition at line 1448 of file wap_push_ppg.c.

References octstr_compare().

Referenced by wap_push_ppg_have_push_session_for().

{
    Octstr *cliaddr;
    PPGSessionMachine *sm;

    cliaddr = b;
    sm = a;
    
    return octstr_compare(sm->addr_tuple->remote->address, cliaddr) == 0;
}

session_has_pi_client_address()

static int session_has_pi_client_address ( void *  a, void *  b  )

static

Definition at line 2130 of file wap_push_ppg.c.

References octstr_compare().

Referenced by session_find_using_pi_client_address().

{
    Octstr *caddr;
    PPGSessionMachine *sm;

    caddr = b;
    sm = a;

    return octstr_compare(caddr, sm->pi_client_address) == 0;
}

session_has_sid()

static int session_has_sid ( void *  a, void *  b  )

static

Definition at line 1459 of file wap_push_ppg.c.

Referenced by wap_push_ppg_have_push_session_for_sid().

{
     PPGSessionMachine *sm;
     long *sid;

     sid = b;
     sm = a;

     return *sid == sm->session_id;
}

session_machine_assert()

static void session_machine_assert ( PPGSessionMachine *  sm )

static

Definition at line 1719 of file wap_push_ppg.c.

References gw_assert().

Referenced by abort_delivery(), deliver_pending_pushes(), find_ppg_push_machine_using_pi_push_id(), find_ppg_push_machine_using_pid(), handle_internal_event(), remove_push_data(), remove_pushless_session(), remove_session_data(), request_confirmed_push(), and update_session_data().

{
    gw_assert(sm);
    gw_assert(sm->session_id >= 0);
    gw_assert(sm->addr_tuple);
    gw_assert(sm->pi_client_address);
}

session_machine_create()

static PPGSessionMachine * session_machine_create ( WAPAddrTuple *  tuple, WAPEvent *  e  )

static

Definition at line 1307 of file wap_push_ppg.c.

References debug(), gw_assert(), gwlist_append(), octstr_duplicate, PAP_CONFIRMED, ppg_machines, WAPEvent::type, WAPEvent::u, wap_addr_tuple_duplicate(), and wsp_cap_duplicate_list().

Referenced by store_session_data().

{
    PPGSessionMachine *m;

    gw_assert(e->type == Push_Message);

    m = gw_malloc(sizeof(PPGSessionMachine));
    
    #define INTEGER(name) m->name = 0;
    #define OCTSTR(name) m->name = NULL;
    #define ADDRTUPLE(name) m->name = NULL;
    #define PUSHMACHINES(name) m->name = gwlist_create();
    #define CAPABILITIES(name) m->name = NULL;
    #define MACHINE(fields) fields
    #include "wap_ppg_session_machine.def"

    m->pi_client_address = octstr_duplicate(e->u.Push_Message.address_value);
    m->addr_tuple = wap_addr_tuple_duplicate(tuple);
    m->assumed_capabilities = 
        wsp_cap_duplicate_list(e->u.Push_Message.pi_capabilities);
    m->preferconfirmed_value = PAP_CONFIRMED;    

    gwlist_append(ppg_machines, m);
    debug("wap.push.ppg", 0, "PPG: Created PPGSessionMachine %ld",
          m->session_id);

    return m;
}

session_machine_destroy()

static void session_machine_destroy ( void *  p )

static

Definition at line 1337 of file wap_push_ppg.c.

References debug().

Referenced by remove_pushless_session(), remove_session_data(), and wap_push_ppg_shutdown().

{
    PPGSessionMachine *sm;

    if (p == NULL)
        return;

    sm = p;
    debug("wap.push.ppg", 0, "PPG: destroying PPGSEssionMachine %ld", 
          sm->session_id);
    
    #define OCTSTR(name) octstr_destroy(sm->name);
    #define ADDRTUPLE(name) wap_addr_tuple_destroy(sm->name);
    #define INTEGER(name) sm->name = 0;
    #define PUSHMACHINES(name) push_machines_list_destroy(sm->name);
    #define CAPABILITIES(name) wsp_cap_destroy_list(sm->name);
    #define MACHINE(fields) fields
    #include "wap_ppg_session_machine.def"
    gw_free(sm);
}

set_addr_tuple()

static WAPAddrTuple * set_addr_tuple ( Octstr *  address, long  cliport, long  servport, long  address_type, List *  push_headers  )

static

Definition at line 2771 of file wap_push_ppg.c.

References ADDR_PLMN, address_type(), from, global_sender, gw_assert(), http_header_remove_all(), http_header_value(), octstr_destroy(), octstr_imm(), and wap_addr_tuple_create().

Referenced by transform_message().

{
    Octstr *cliaddr;
    Octstr *from = NULL;
    WAPAddrTuple *tuple;
    
    gw_assert(address);

    if (address_type == ADDR_PLMN) {
        from = http_header_value(push_headers, octstr_imm("X-Kannel-From"));
        cliaddr = from ? from : global_sender;
    } else {
        cliaddr = octstr_imm("0.0.0.0");
    }

    tuple = wap_addr_tuple_create(address, cliport, cliaddr, servport);

    octstr_destroy(from);
    http_header_remove_all(push_headers, "X-Kannel-From");

    return tuple;
}

set_dlr_mask()

static long set_dlr_mask ( List *  headers, Octstr *  dlr_url  )

static

Definition at line 3314 of file wap_push_ppg.c.

References dlr_mask, http_header_value(), octstr_destroy(), octstr_imm(), octstr_len(), octstr_parse_long(), and warning().

Referenced by pap_request_thread().

{
    Octstr *dlrmaskos;
    long dlr_mask;
    long masklen;    

    dlrmaskos = http_header_value(headers, octstr_imm("X-Kannel-DLR-Mask"));
    if (dlrmaskos == NULL) { 
        return 0;
    }

    if ((masklen = octstr_parse_long(&dlr_mask, dlrmaskos, 0, 10)) != -1 &&
             masklen == octstr_len(dlrmaskos) &&
             dlr_mask >= -1 && dlr_mask <= 31) {
         octstr_destroy(dlrmaskos);
         return dlr_mask;
    }

    warning(0, "unparsable dlr mask, rejected");
    octstr_destroy(dlrmaskos);
    return 0;
}

set_dlr_url()

static Octstr * set_dlr_url ( List *  headers, Octstr *  username, int  trusted_pi  )

static

Definition at line 3291 of file wap_push_ppg.c.

References dlr_url, http_header_value(), octstr_duplicate, octstr_imm(), ppg_dlr_url, trusted_pi, username, and wap_push_ppg_pushuser_dlr_url_get().

Referenced by pap_request_thread().

{
    Octstr *dlr_url = NULL;

    dlr_url = http_header_value(headers, octstr_imm("X-Kannel-DLR-Url"));
    if (dlr_url) {
        return dlr_url;
    }

    if (!trusted_pi)
        dlr_url = wap_push_ppg_pushuser_dlr_url_get(username);

    dlr_url = dlr_url ?
        dlr_url : (ppg_dlr_url ? octstr_duplicate(ppg_dlr_url) : NULL);

    return dlr_url;
}

set_service_name()

static Octstr * set_service_name ( void  )

static

Definition at line 3368 of file wap_push_ppg.c.

References octstr_duplicate, and service_name.

Referenced by pap_request_thread().

{
    return octstr_duplicate(service_name);
}

set_smsbox_id()

static Octstr * set_smsbox_id ( List *  headers, Octstr *  username, int  trusted_pi  )

static

Definition at line 3346 of file wap_push_ppg.c.

References http_header_value(), octstr_duplicate, octstr_imm(), ppg_smsbox_id, smsbox_id, trusted_pi, username, and wap_push_ppg_pushuser_smsbox_id_get().

Referenced by pap_request_thread().

{
    Octstr *smsbox_id = NULL;

    smsbox_id = http_header_value(headers, octstr_imm("X-Kannel-Smsbox-Id"));
    if (smsbox_id != NULL) {
        return smsbox_id;
    }

    if (!trusted_pi)
        smsbox_id = wap_push_ppg_pushuser_smsbox_id_get(username);

    smsbox_id = smsbox_id ?
        smsbox_id : (ppg_smsbox_id ? octstr_duplicate(ppg_smsbox_id) : NULL);

    return smsbox_id;

}

set_smsc_id()

static Octstr * set_smsc_id ( List *  headers, Octstr *  username, int  trusted_pi  )

static

Definition at line 3265 of file wap_push_ppg.c.

References http_header_value(), octstr_duplicate, octstr_imm(), ppg_default_smsc, smsc_id, trusted_pi, username, and wap_push_ppg_pushuser_smsc_id_get().

Referenced by pap_request_thread().

{
    Octstr *smsc_id = NULL;

    smsc_id = http_header_value(headers, octstr_imm("X-Kannel-SMSC"));
    if (smsc_id) {
        return smsc_id;
    }

    if (!trusted_pi)
        smsc_id = wap_push_ppg_pushuser_smsc_id_get(username);

    smsc_id = smsc_id ? 
        smsc_id : (ppg_default_smsc ? octstr_duplicate(ppg_default_smsc) : NULL);

    return smsc_id;
}

set_time()

static Octstr * set_time ( void  )

static

Definition at line 1705 of file wap_push_ppg.c.

References gw_gmtime(), and octstr_format().

Referenced by response_push_message(), tell_fatal_error(), and update_push_data_with_attribute().

{
    Octstr *current_time;
    struct tm now;

    now = gw_gmtime(time(NULL));
    current_time = octstr_format("%04d-%02d-%02dT%02d:%02d:%02dZ", 
                                 now.tm_year + 1900, now.tm_mon + 1, 
                                 now.tm_mday, now.tm_hour, now.tm_min, 
                                 now.tm_sec);

    return current_time;
}

store_push_data()

static int store_push_data ( PPGPushMachine **  pm, PPGSessionMachine *  sm, WAPEvent *  e, WAPAddrTuple *  tuple, int  cless  )

static

Definition at line 2282 of file wap_push_ppg.c.

References debug(), find_ppg_push_machine_using_pi_push_id(), find_unit_ppg_push_machine_using_pi_push_id(), gw_assert(), gwlist_append(), ppg_unit_pushes, push_machine_create(), WAPEvent::type, and WAPEvent::u.

Referenced by handle_push_message().

{ 
    Octstr *pi_push_id;  
    int duplicate_push_id;
    
    gw_assert(e->type == Push_Message);

    pi_push_id = e->u.Push_Message.pi_push_id;

    duplicate_push_id = 0;
    if (((!cless) && 
       (find_ppg_push_machine_using_pi_push_id(sm, pi_push_id) != NULL)) ||
       ((cless) && 
       (find_unit_ppg_push_machine_using_pi_push_id(pi_push_id) != NULL)))
       duplicate_push_id = 1;

    *pm = push_machine_create(e, tuple);
    
    if (duplicate_push_id)
        return !duplicate_push_id;
    
    if (!cless) {
       gwlist_append(sm->push_machines, *pm);
       debug("wap.push.ppg", 0, "PPG: store_push_data: push machine %ld"
             " appended to push list of sm machine %ld", (*pm)->push_id, 
             sm->session_id);
    } else {
       gwlist_append(ppg_unit_pushes, *pm);
       debug("wap.push.ppg", 0, "PPG: store_push_data: push machine %ld"
             " appended to unit push list", (*pm)->push_id);
    }

    return !duplicate_push_id;
}

store_session_data()

static PPGSessionMachine * store_session_data ( PPGSessionMachine *  sm, WAPEvent *  e, WAPAddrTuple *  tuple, int *  session_exists  )

static

Definition at line 2454 of file wap_push_ppg.c.

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

Referenced by handle_push_message().

{
    gw_assert(e->type == Push_Message);

    if (sm == NULL) {
        sm = session_machine_create(tuple, e);
        *session_exists = 0;
    } else
        *session_exists = 1;
    
    return sm;
}

tell_fatal_error()

static void tell_fatal_error ( HTTPClient **  c, WAPEvent *  e, Octstr *  url, int  status, int  code  )

static

Definition at line 3145 of file wap_push_ppg.c.

References code, debug(), describe_code(), gw_assert(), octstr_destroy(), octstr_format(), octstr_format_append(), octstr_get_cstr, send_to_pi(), set_time(), tell_ppg_name(), WAPEvent::type, WAPEvent::u, url, and wap_event_destroy().

Referenced by pap_request_thread().

{
    Octstr *reply_body,
           *dos,                      /* temporaries */
           *tos,
           *sos;

    gw_assert(e->type == Push_Message);
    reply_body = octstr_format("%s", 
        "<?xml version=\"1.0\"?>"
        "<!DOCTYPE pap PUBLIC \"-//WAPFORUM//DTD PAP 1.0//EN\""
                   " \"http://www.wapforum.org/DTD/pap_1.0.dtd\">"
        "<pap>"
             "<push-response push-id=\"");
    octstr_format_append(reply_body, "%S", e->u.Push_Message.pi_push_id);
    octstr_format_append(reply_body, "%s", "\""); 

    octstr_format_append(reply_body, "%s",
                   " sender-name=\"");
    octstr_format_append(reply_body, "%S", tos = tell_ppg_name());
    octstr_format_append(reply_body, "%s", "\"");

    octstr_format_append(reply_body, "%s",
                   " reply-time=\"");
    octstr_format_append(reply_body, "%S", sos = set_time());
    octstr_format_append(reply_body, "%s", "\"");

    octstr_format_append(reply_body, "%s",
                   " sender-address=\"");
    octstr_format_append(reply_body, "%S", url);
    octstr_format_append(reply_body, "%s", "\"");

    octstr_format_append(reply_body, "%s", ">"
             "<response-result code =\"");
    octstr_format_append(reply_body, "%d", code);
    octstr_format_append(reply_body, "%s", "\"");

    octstr_format_append(reply_body, "%s", " desc=\"");
    octstr_format_append(reply_body, "%S", dos = describe_code(code));
    octstr_format_append(reply_body, "\"");

    octstr_format_append(reply_body, "%s", ">"
              "</response-result>"
              "</push-response>"
         "</pap>");

    debug("wap.push.ppg", 0, "PPG: tell_fatal_error: %s", octstr_get_cstr(dos));
    send_to_pi(c, reply_body, status);

    octstr_destroy(dos);
    octstr_destroy(tos);
    octstr_destroy(sos);
    wap_event_destroy(e);
}

tell_ppg_name()

static Octstr * tell_ppg_name ( void  )

static

Definition at line 2157 of file wap_push_ppg.c.

References get_official_name(), and octstr_format().

Referenced by response_push_message(), and tell_fatal_error().

{
     return octstr_format("%S; WAP/1.3 (" GW_NAME "/%s)", get_official_name(), 
                          GW_VERSION);
}

transform_message()

static int transform_message ( WAPEvent **  e, WAPAddrTuple **  tuple, List *  push_headers, int  connected, Octstr **  type  )

static

Definition at line 1761 of file wap_push_ppg.c.

References address_type(), content::body, change_header_value(), content::charset, cless_accepted(), CONNECTED_CLIPORT, CONNECTED_SERVPORT, CONNECTIONLESS_PUSH_CLIPORT, CONNECTIONLESS_SERVPORT, content_transformable(), debug(), error(), gw_assert(), http_header_find_first, http_header_get_content_type(), octstr_destroy(), octstr_get_cstr, octstr_strip_blanks(), pap_convert_content(), pap_get_content(), set_addr_tuple(), content::type, type, and warning().

Referenced by handle_push_message().

{
    int message_deliverable;
    struct content content;
    Octstr *cliaddr;
    long cliport,
         servport,
         address_type;

    gw_assert((**e).type == Push_Message);
    if ((**e).u.Push_Message.push_headers == NULL)
        goto herror;

    cliaddr = (**e).u.Push_Message.address_value;
    push_headers = (**e).u.Push_Message.push_headers;

    if (!cless_accepted) {
        cliport = CONNECTED_CLIPORT;
        servport = CONNECTED_SERVPORT;
    } else {
        cliport = CONNECTIONLESS_PUSH_CLIPORT;
        servport = CONNECTIONLESS_SERVPORT;
    }
    
    address_type = (**e).u.Push_Message.address_type;
    *tuple = set_addr_tuple(cliaddr, cliport, servport, address_type, push_headers);

    if (!content_transformable(push_headers)) 
        goto no_transform;

    content.charset = NULL;
    content.type = NULL;

    content.body = (**e).u.Push_Message.push_data; 
    if (content.body == NULL)
        goto no_transform;

    content.type = http_header_find_first(push_headers, "Content-Transfer-Encoding");
    if (content.type) {
    octstr_strip_blanks(content.type);
    debug("wap.push.ppg", 0, "PPG: Content-Transfer-Encoding is \"%s\"",
          octstr_get_cstr (content.type));
    message_deliverable = pap_get_content(&content);
    
        if (message_deliverable) {
        change_header_value(&push_headers, "Content-Transfer-Encoding", 
                                "binary");
    } else {
        goto error;
    }
    }

    octstr_destroy(content.type);
    http_header_get_content_type(push_headers, &content.type, &content.charset);   
    message_deliverable = pap_convert_content(&content);

    if (content.type == NULL)
        goto error;

    if (message_deliverable) {
        *type = content.type;        
    } else {
        goto error;
    }

    (**e).u.Push_Message.push_data = content.body;
    octstr_destroy(content.charset);

    debug("wap.push.ppg", 0, "PPG: transform_message: push message content"
          " and headers valid");
    return 1;

herror:
    warning(0, "PPG: transform_message: no push headers, cannot accept");
    octstr_destroy(content.type);
    return 0;

error:
    warning(0, "PPG: transform_message: push content erroneous, cannot"
            " accept");
    octstr_destroy(content.type);
    octstr_destroy(content.charset);
    return 0;

no_transform:
    warning(0, "PPG: transform_message: push content non transformable");
    return 1;
}

type_is()

static int type_is ( Octstr *  content_header, char *  required_type  )

static

Definition at line 2935 of file wap_push_ppg.c.

References content_header, name, octstr_case_search(), octstr_destroy(), octstr_format(), and octstr_imm().

Referenced by headers_acceptable().

{
    Octstr *quoted_type,
           *osname;

    osname = octstr_imm(name);
    if (octstr_case_search(content_header, osname, 0) >= 0)
        return 1;

    quoted_type = octstr_format("\"%S\"", osname);

    if (octstr_case_search(content_header, quoted_type, 0) >= 0) {
        octstr_destroy(quoted_type);
        return 1;
    }

    octstr_destroy(quoted_type);
    return 0;
}

update_push_data_with_attribute()

static PPGPushMachine * update_push_data_with_attribute ( PPGSessionMachine **  sm, PPGPushMachine *  pm, long  reason, long  status  )

static

Definition at line 2557 of file wap_push_ppg.c.

References describe_code(), error(), gwlist_append(), gwlist_delete_equal(), gwlist_delete_matching(), ota_abort_to_pap(), PAP_ABORTED, PAP_BAD_REQUEST, PAP_CONFIRMED, PAP_DELIVERED, PAP_DELIVERED1, PAP_DELIVERED2, PAP_EXPIRED, PAP_PENDING, PAP_UNCONFIRMED, PAP_UNDELIVERABLE, PAP_UNDELIVERABLE1, PAP_UNDELIVERABLE2, ppg_machines, ppg_unit_pushes, push_has_pid(), push_machine_assert(), description_t::reason, and set_time().

Referenced by abort_delivery(), deliver_pending_pushes(), deliver_unit_push(), handle_internal_event(), and handle_push_message().

{
    push_machine_assert(qm);
   
    switch (status) {
    case PAP_UNDELIVERABLE1:
         qm->message_state = PAP_UNDELIVERABLE;
         qm->code = PAP_BAD_REQUEST;
    break;

    case PAP_UNDELIVERABLE2:
        qm->code = reason;
        qm->message_state = PAP_UNDELIVERABLE;
        qm->desc = describe_code(reason);
    break;

    case PAP_ABORTED:
        qm->message_state = status;
        qm->code = ota_abort_to_pap(reason);
        qm->event_time = set_time();
        qm->desc = describe_code(reason);
    break;

    case PAP_DELIVERED1:
        qm->message_state = PAP_DELIVERED;
        qm->delivery_method = PAP_UNCONFIRMED;
        qm->event_time = set_time();
    break;

    case PAP_DELIVERED2:
        qm->message_state = PAP_DELIVERED;
        qm->delivery_method = PAP_CONFIRMED;
        qm->event_time = set_time();
    break;

    case PAP_EXPIRED:
        qm->message_state = PAP_EXPIRED;
        qm->event_time = set_time();
        qm->desc = describe_code(reason);
    break;

    case PAP_PENDING:
        qm->message_state = PAP_PENDING;
    break;

    default:
        error(0, "WAP_PUSH_PPG: update_push_data_with_attribute: Non"
              " existing push machine status: %ld", status);
    break;
    }

    if (*sm != NULL){
        gwlist_delete_matching((**sm).push_machines, &qm->push_id, push_has_pid);
        gwlist_append((**sm).push_machines, qm);
        gwlist_delete_equal(ppg_machines, *sm);
        gwlist_append(ppg_machines, *sm);
    } else {
        gwlist_delete_matching(ppg_unit_pushes, &qm->push_id, push_has_pid);
        gwlist_append(ppg_unit_pushes, qm);
    }

    return qm;
}

update_session_data()

static PPGSessionMachine * update_session_data ( PPGSessionMachine *  sm, long  sid, long  port, List *  caps  )

static

Definition at line 2625 of file wap_push_ppg.c.

References gw_assert(), gwlist_append(), gwlist_delete_equal(), port, ppg_machines, session_machine_assert(), and wsp_cap_duplicate_list().

Referenced by handle_internal_event().

{
    session_machine_assert(m);
    gw_assert(sid >= 0);

    m->session_id = sid;
    m->addr_tuple->remote->port = port;
    m->client_capabilities = wsp_cap_duplicate_list(caps);

    gwlist_delete_equal(ppg_machines, m);
    gwlist_append(ppg_machines, m);

    return m;
}

update_session_data_with_headers()

static PPGSessionMachine * update_session_data_with_headers ( PPGSessionMachine *  sm, PPGPushMachine *  pm  )

static

Definition at line 2468 of file wap_push_ppg.c.

References gwlist_append(), gwlist_delete_matching(), and push_has_pid().

Referenced by handle_push_message().

{
    gwlist_delete_matching(sm->push_machines, &pm->push_id, push_has_pid);
    gwlist_append(sm->push_machines, pm);

    return sm;
}

wap_push_ppg_dispatch_event()

void wap_push_ppg_dispatch_event

(

WAPEvent *

e

)

Definition at line 476 of file wap_push_ppg.c.

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

Referenced by confirm_push(), indicate_push_abort(), indicate_push_connection(), indicate_push_disconnect(), indicate_push_resume(), indicate_push_suspend(), and main().

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

wap_push_ppg_have_push_session_for()

PPGSessionMachine* wap_push_ppg_have_push_session_for

(

WAPAddrTuple *

tuple

)

Definition at line 488 of file wap_push_ppg.c.

References WAPAddr::address, gw_assert(), gwlist_search(), ppg_machines, WAPAddrTuple::remote, and session_has_addr().

Referenced by handle_internal_event(), and main_thread().

{
    PPGSessionMachine *sm;

    gw_assert(tuple);
    sm = gwlist_search(ppg_machines, tuple->remote->address, session_has_addr);

    return sm;
}

wap_push_ppg_have_push_session_for_sid()

PPGSessionMachine* wap_push_ppg_have_push_session_for_sid

(

long

sid

)

Definition at line 503 of file wap_push_ppg.c.

References gw_assert(), gwlist_search(), ppg_machines, and session_has_sid().

Referenced by handle_internal_event(), and main_thread().

{
    PPGSessionMachine *sm;

    gw_assert(sid >= 0);
    sm = gwlist_search(ppg_machines, &sid, session_has_sid);

    return sm;
}

wap_push_ppg_init()

void wap_push_ppg_init	(	wap_dispatch_func_t *	ota_dispatch,
		wap_dispatch_func_t *	appl_dispatch,
		Cfg *	cfg
	)

Definition at line 397 of file wap_push_ppg.c.

References cfg, counter_create(), dict_create(), dispatch_to_appl, dispatch_to_ota, gw_assert(), gwlist_add_producer(), gwlist_create, gwthread_create, http_clients, http_open_port(), http_read_thread(), limbo, NO_HTTPS_PORT, number_of_pushes, ota_read_thread(), pap_queue, pap_request_thread(), ppg_machines, ppg_port, ppg_queue, ppg_unit_pushes, push_id_counter, read_ppg_config(), run_status, running, TYPE_HTTP, TYPE_HTTPS, urls, user_configuration, and USER_CONFIGURATION_NOT_ADDED.

Referenced by main().

{
    user_configuration = read_ppg_config(cfg);
    if (user_configuration != USER_CONFIGURATION_NOT_ADDED) {
        ppg_queue = gwlist_create();
        gwlist_add_producer(ppg_queue);
        pap_queue = gwlist_create();
        gwlist_add_producer(pap_queue);
        push_id_counter = counter_create();
        ppg_machines = gwlist_create();
        ppg_unit_pushes = gwlist_create();

        dispatch_to_ota = ota_dispatch;
        dispatch_to_appl = appl_dispatch;

        http_open_port(ppg_port, TYPE_HTTP);
#ifdef HAVE_LIBSSL
        if (ppg_ssl_port != NO_HTTPS_PORT)
            http_open_port(ppg_ssl_port, TYPE_HTTPS);
#endif
        http_clients = dict_create(number_of_pushes, NULL);
        urls = dict_create(number_of_pushes, NULL);

        gw_assert(run_status == limbo);
        run_status = running;
        gwthread_create(ota_read_thread, NULL);
        gwthread_create(http_read_thread, NULL);
#ifdef HAVE_LIBSSL
        if (ppg_ssl_port != NO_HTTPS_PORT) 
            gwthread_create(https_read_thread, NULL);
#endif
        gwthread_create(pap_request_thread, NULL);
    }
}

wap_push_ppg_shutdown()

void wap_push_ppg_shutdown

(

void

)

Definition at line 433 of file wap_push_ppg.c.

References counter_destroy(), debug(), dict_destroy(), global_sender, gw_assert(), gwlist_destroy(), gwlist_len(), gwlist_remove_producer(), gwthread_join_every(), http_clients, http_close_all_ports(), http_read_thread(), NO_HTTPS_PORT, octstr_destroy(), ota_read_thread(), pap_event_destroy_item(), pap_queue, pap_request_thread(), ppg_allow_ip, ppg_default_smsc, ppg_deny_ip, ppg_dlr_url, ppg_machines, ppg_queue, ppg_smsbox_id, ppg_unit_pushes, ppg_url, push_id_counter, push_machine_destroy(), run_status, running, service_name, session_machine_destroy(), terminating, urls, user_configuration, USER_CONFIGURATION_NOT_ADDED, wap_event_destroy_item(), and wap_push_ppg_pushuser_list_destroy().

Referenced by main().

{
     if (user_configuration != USER_CONFIGURATION_NOT_ADDED) {
         gw_assert(run_status == running);
         run_status = terminating;
         gwlist_remove_producer(ppg_queue);
         gwlist_remove_producer(pap_queue);
         octstr_destroy(ppg_url);
         ppg_url = NULL;
         http_close_all_ports();
         dict_destroy(http_clients);
         dict_destroy(urls);
         wap_push_ppg_pushuser_list_destroy();
         octstr_destroy(ppg_deny_ip);
         octstr_destroy(ppg_allow_ip);
         octstr_destroy(global_sender);
         octstr_destroy(service_name);
         octstr_destroy(ppg_default_smsc);
         octstr_destroy(ppg_dlr_url);
         octstr_destroy(ppg_smsbox_id);

         gwthread_join_every(http_read_thread);
#ifdef HAVE_LIBSSL
         if (ppg_ssl_port != NO_HTTPS_PORT)
            gwthread_join_every(https_read_thread);
#endif
         gwthread_join_every(ota_read_thread);
         gwthread_join_every(pap_request_thread);

         gwlist_destroy(ppg_queue, wap_event_destroy_item);
         gwlist_destroy(pap_queue, pap_event_destroy_item);
         counter_destroy(push_id_counter);
     
         debug("wap.push.ppg", 0, "PPG: %ld push session machines left.",
               gwlist_len(ppg_machines));
         gwlist_destroy(ppg_machines, session_machine_destroy);

         debug("wap_push_ppg", 0, "PPG: %ld unit pushes left", 
               gwlist_len(ppg_unit_pushes));
         gwlist_destroy(ppg_unit_pushes, push_machine_destroy);
     }
}

Variable Documentation

bearers

char* bearers[]

static

Initial value:

= {
   "Any",
   "SMS",
   "CSD",
   "GPRS",
   "Packet Data",
   "CDPD"
}

Definition at line 2061 of file wap_push_ppg.c.

Referenced by select_bearer_network().

convert

Octstr*(* convert) (struct content *)

Definition at line 1978 of file wap_push_ppg.c.

converters

struct { ... } converters[]

Initial value:

= {
    { "text/vnd.wap.wml",
      "application/vnd.wap.wmlc",
      convert_wml_to_wmlc },
    { "text/vnd.wap.si",
      "application/vnd.wap.sic",
      convert_si_to_sic },
    { "text/vnd.wap.sl",
      "application/vnd.wap.slc",
      convert_sl_to_slc}
}

Referenced by pap_convert_content().

desc_tab_size

size_t desc_tab_size = sizeof(pap_desc) / sizeof(pap_desc[0])

static

Definition at line 2236 of file wap_push_ppg.c.

Referenced by describe_code().

dispatch_to_appl

wap_dispatch_func_t* dispatch_to_appl

static

Definition at line 177 of file wap_push_ppg.c.

Referenced by response_push_connection(), and wap_push_ppg_init().

dispatch_to_ota

wap_dispatch_func_t* dispatch_to_ota

static

Definition at line 176 of file wap_push_ppg.c.

Referenced by create_session(), request_confirmed_push(), request_push(), request_unit_push(), and wap_push_ppg_init().

extract

Octstr*(* extract) (struct content *)

Definition at line 1995 of file wap_push_ppg.c.

extractors

struct { ... } extractors[]

Initial value:

= {
    { "base64",
      extract_base64 }
}

Referenced by pap_get_content().

global_sender

Octstr* global_sender = NULL

static

Definition at line 197 of file wap_push_ppg.c.

Referenced by read_ppg_config(), set_addr_tuple(), and wap_push_ppg_shutdown().

http_clients

Dict* http_clients = NULL

static

Definition at line 160 of file wap_push_ppg.c.

Referenced by pap_request_thread(), send_push_response(), wap_push_ppg_init(), and wap_push_ppg_shutdown().

networks

char* networks[]

static

Initial value:

= {
    "Any", 
    "GSM",
    "IS-95 CDMA",
    "ANSI-136",
    "AMPS",
    "PDC",
    "IDEN", 
    "PHS",   
    "TETRA"
}

Definition at line 2072 of file wap_push_ppg.c.

Referenced by select_bearer_network().

number_of_pushes

long number_of_pushes = DEFAULT_NUMBER_OF_PUSHES

static

Definition at line 191 of file wap_push_ppg.c.

Referenced by read_ppg_config(), wap_push_ppg_init(), and wap_push_ppg_pushuser_list_add().

number_of_users

long number_of_users = DEFAULT_NUMBER_OF_USERS

static

Definition at line 193 of file wap_push_ppg.c.

Referenced by pushusers_create(), read_ppg_config(), and wap_push_ppg_pushuser_list_add().

pap_desc

description_t pap_desc[]

static

Initial value:

= {
    { PAP_OK, "The request succeeded"},
    { PAP_ACCEPTED_FOR_PROCESSING, "The request has been accepted for"
                                   " processing"},
    { PAP_BAD_REQUEST, "Not understood due to malformed syntax"},
    { PAP_FORBIDDEN, "Request was refused"},
    { PAP_ADDRESS_ERROR, "The client specified not recognised"},
    { PAP_CAPABILITIES_MISMATCH, "Capabilities assumed by PI were not"
                                 "  acceptable for the client specified"},
    { PAP_DUPLICATE_PUSH_ID, "Push id supplied was not unique"},
    { PAP_INTERNAL_SERVER_ERROR, "Server could not fulfill the request due"
                                 " to an internal error"},
    { PAP_TRANSFORMATION_FAILURE, "PPG was unable to perform a transformation"
                                  " of the message"},
    { PAP_REQUIRED_BEARER_NOT_AVAILABLE, "Required bearer not available"},
    { PAP_SERVICE_FAILURE, "The service failed. The client may re-attempt"
                           " the operation"},
    { PAP_CLIENT_ABORTED, "The client aborted the operation. No reason given"},
    { WSP_ABORT_USERREQ, "Wsp requested abort"},
    { WSP_ABORT_USERRFS, "Wsp refused push message. Do not try again"},
    { WSP_ABORT_USERPND, "Push message cannot be delivered to intended"
                         " destination by the wsp"},
    { WSP_ABORT_USERDCR, "Push message discarded due to resource shortage in"
                         " wsp"},
    { WSP_ABORT_USERDCU, "Content type of the push message cannot be"
                         " processed by the wsp"}
}

Definition at line 2208 of file wap_push_ppg.c.

Referenced by describe_code().

pap_queue

List* pap_queue = NULL

static

Definition at line 138 of file wap_push_ppg.c.

Referenced by http_read_thread(), pap_request_thread(), wap_push_ppg_init(), and wap_push_ppg_shutdown().

ppg_allow_ip

Octstr* ppg_allow_ip = NULL

static

Definition at line 195 of file wap_push_ppg.c.

Referenced by ip_allowed_by_ppg(), read_ppg_config(), and wap_push_ppg_shutdown().

ppg_default_smsc

Octstr* ppg_default_smsc = NULL

static

Definition at line 198 of file wap_push_ppg.c.

Referenced by read_ppg_config(), set_smsc_id(), and wap_push_ppg_shutdown().

ppg_deny_ip

Octstr* ppg_deny_ip = NULL

static

Definition at line 194 of file wap_push_ppg.c.

Referenced by ip_allowed_by_ppg(), read_ppg_config(), and wap_push_ppg_shutdown().

ppg_dlr_url

Octstr* ppg_dlr_url = NULL

static

Definition at line 203 of file wap_push_ppg.c.

Referenced by read_ppg_config(), set_dlr_url(), and wap_push_ppg_shutdown().

ppg_machines

List* ppg_machines = NULL

static

Definition at line 143 of file wap_push_ppg.c.

Referenced by remove_pushless_session(), remove_session_data(), session_find_using_pi_client_address(), session_machine_create(), update_push_data_with_attribute(), update_session_data(), wap_push_ppg_have_push_session_for(), wap_push_ppg_have_push_session_for_sid(), wap_push_ppg_init(), and wap_push_ppg_shutdown().

ppg_port

long ppg_port = DEFAULT_HTTP_PORT

static

Definition at line 185 of file wap_push_ppg.c.

Referenced by http_read_thread(), read_ppg_config(), and wap_push_ppg_init().

ppg_queue

List* ppg_queue = NULL

static

Definition at line 133 of file wap_push_ppg.c.

Referenced by ota_read_thread(), wap_push_ppg_dispatch_event(), wap_push_ppg_init(), and wap_push_ppg_shutdown().

ppg_smsbox_id

Octstr* ppg_smsbox_id = NULL

static

Definition at line 204 of file wap_push_ppg.c.

Referenced by read_ppg_config(), set_smsbox_id(), and wap_push_ppg_shutdown().

ppg_unit_pushes

List* ppg_unit_pushes = NULL

static

Definition at line 149 of file wap_push_ppg.c.

Referenced by find_unit_ppg_push_machine_using_pi_push_id(), remove_push_data(), store_push_data(), update_push_data_with_attribute(), wap_push_ppg_init(), and wap_push_ppg_shutdown().

ppg_url

Octstr* ppg_url = NULL

static

Definition at line 184 of file wap_push_ppg.c.

Referenced by pap_request_thread(), read_ppg_config(), and wap_push_ppg_shutdown().

push_id_counter

Counter* push_id_counter = NULL

static

Definition at line 154 of file wap_push_ppg.c.

Referenced by push_machine_create(), wap_push_ppg_init(), and wap_push_ppg_shutdown().

result_type

char* result_type

Definition at line 1977 of file wap_push_ppg.c.

Referenced by pap_convert_content().

run_status

enum { ... } run_status

Referenced by http_read_thread(), ota_read_thread(), pap_request_thread(), wap_push_ppg_dispatch_event(), wap_push_ppg_init(), and wap_push_ppg_shutdown().

service_name

Octstr* service_name = NULL

static

Definition at line 205 of file wap_push_ppg.c.

Referenced by create_session(), make_unit_push_request(), read_ppg_config(), set_service_name(), and wap_push_ppg_shutdown().

transfer_encoding

char* transfer_encoding

Definition at line 1994 of file wap_push_ppg.c.

Referenced by pap_get_content().

trusted_pi

int trusted_pi = PI_TRUSTED

static

Definition at line 192 of file wap_push_ppg.c.

Referenced by ip_allowed_by_ppg(), pap_request_thread(), read_ppg_config(), set_dlr_url(), set_smsbox_id(), and set_smsc_id().

type

char* type

Definition at line 1976 of file wap_push_ppg.c.

Referenced by handle_push_message(), pap_convert_content(), and transform_message().

urls

Dict* urls = NULL

static

Definition at line 165 of file wap_push_ppg.c.

Referenced by pap_request_thread(), send_push_response(), wap_push_ppg_init(), and wap_push_ppg_shutdown().

user_configuration

int user_configuration = USER_CONFIGURATION_NOT_ADDED

static

Definition at line 196 of file wap_push_ppg.c.

Referenced by pap_request_thread(), wap_push_ppg_init(), and wap_push_ppg_shutdown().

wina_uri

char* wina_uri[]

static

Initial value:

=
{   "*",
    "push.sia",
    "wml.ua",
    "wta.ua", 
    "mms.ua", 
    "push.syncml", 
    "loc.ua",
    "syncml.dm",
    "drm.ua",
    "emn.ua",
    "wv.ua",
    "x-wap-microsoft:localcontent.ua",
    "x-wap-microsoft:IMclient.ua",
    "x-wap-docomo:imode.mail.ua",
    "x-wap-docomo:imode.mr.ua",
    "x-wap-docomo:imode.mf.ua",
    "x-motorola:location.ua",
    "x-motorola:now.ua",
    "x-motorola:otaprov.ua",
    "x-motorola:browser.ua",
    "x-motorola:splash.ua",
    "x-wap-nai:mvsw.command",
    "x-wap-openwave:iota.ua",
    "x-wap-docomo:imode.mail2.ua",
    "x-oma-nec:otaprov.ua",
    "x-oma-nokia:call.ua"
}

Definition at line 2805 of file wap_push_ppg.c.

Referenced by parse_appid_header().