wtp_resp.c File Reference

#include "gwlib/gwlib.h"
#include "wtp_resp.h"
#include "wtp_pack.h"
#include "wtp_tid.h"
#include "wtp.h"
#include "timers.h"
#include "wap.h"
#include "wtp_resp_states.def"
#include "wtp_resp_machine.def"

Go to the source code of this file.

Macros
#define	STATE_NAME(state)   case state: return #state;
#define	ROW(state, event, condition, action, new_state)
#define	STATE_NAME(state)
#define	ROW(wtp_state, event_type, condition, action, next_state)
#define	ENUM(name)   resp_machine->name = LISTEN;
#define	EVENT(name)   resp_machine->name = NULL;
#define	INTEGER(name)   resp_machine->name = 0;
#define	TIMER(name)   resp_machine->name = gwtimer_create(resp_queue);
#define	ADDRTUPLE(name)   resp_machine->name = NULL;
#define	LIST(name)   resp_machine->name = NULL;
#define	SARDATA(name)   resp_machine->name = NULL;
#define	MACHINE(field)   field
#define	ENUM(name)   resp_machine->name = LISTEN;
#define	EVENT(name)   wap_event_destroy(resp_machine->name);
#define	INTEGER(name)   resp_machine->name = 0;
#define	TIMER(name)   gwtimer_destroy(resp_machine->name);
#define	ADDRTUPLE(name)   wap_addr_tuple_destroy(resp_machine->name);
#define	LIST(name)   gwlist_destroy(resp_machine->name,sar_info_destroy);
#define	SARDATA(name)   sardata_destroy(resp_machine->name);
#define	MACHINE(field)   field

Enumerations
enum	{ limbo, running, terminating }

Functions
static WTPRespMachine *	resp_machine_create (WAPAddrTuple *tuple, long tid, long tcl)
static void	resp_machine_destroy (void *sm)
static WTPRespMachine *	resp_machine_find_or_create (WAPEvent *event)
static void	resp_event_handle (WTPRespMachine *machine, WAPEvent *event)
static char *	name_resp_state (int name)
static WTPRespMachine *	resp_machine_find (WAPAddrTuple *tuple, long tid, long mid)
static void	main_thread (void *)
static void	start_timer_A (WTPRespMachine *machine)
static void	start_timer_R (WTPRespMachine *machine)
static void	start_timer_W (WTPRespMachine *machine)
static WAPEvent *	create_tr_invoke_ind (WTPRespMachine *sm, Octstr *user_data)
static WAPEvent *	create_tr_abort_ind (WTPRespMachine *sm, long abort_reason)
static WAPEvent *	create_tr_result_cnf (WTPRespMachine *sm)
static int	erroneous_field_in (WAPEvent *event)
static void	handle_wrong_version (WAPEvent *event)
static WAPEvent *	assembly_sar_event (WTPRespMachine *machine, int last_psn)
static int	add_sar_transaction (WTPRespMachine *machine, Octstr *data, int psn)
static int	process_sar_transaction (WTPRespMachine *machine, WAPEvent **event)
static void	begin_sar_result (WTPRespMachine *machine, WAPEvent *event)
static void	continue_sar_result (WTPRespMachine *machine, WAPEvent *event)
static void	resend_sar_result (WTPRespMachine *resp_machine, WAPEvent *event)
static void	sar_info_destroy (void *sar_info)
static void	sardata_destroy (void *sardata)
static void	send_abort (WTPRespMachine *machine, long type, long reason)
static void	send_ack (WTPRespMachine *machine, long ack_type, int rid_flag)
void	wtp_resp_init (wap_dispatch_func_t *datagram_dispatch, wap_dispatch_func_t *session_dispatch, wap_dispatch_func_t *push_dispatch, long timer_freq)
void	wtp_resp_shutdown (void)
void	wtp_resp_dispatch_event (WAPEvent *event)
static void	handle_erroneous_field_in (WAPEvent *event)
static int	is_wanted_resp_machine (void *a, void *b)
static int	is_wanted_sar_data (void *a, void *b)

Variables
static List *	resp_machines = NULL
static Counter *	resp_machine_id_counter = NULL
static enum { ... }	resp_run_status = limbo
wap_dispatch_func_t *	dispatch_to_wdp
wap_dispatch_func_t *	dispatch_to_wsp
wap_dispatch_func_t *	dispatch_to_push
static List *	resp_queue = NULL
static long	resp_timer_freq = -1

Macro Definition Documentation

ADDRTUPLE [1/2]

#define ADDRTUPLE

(

name

)

resp_machine->name = NULL;

ADDRTUPLE [2/2]

#define ADDRTUPLE

(

name

)

wap_addr_tuple_destroy(resp_machine->name);

ENUM [1/2]

#define ENUM

(

name

)

resp_machine->name = LISTEN;

ENUM [2/2]

#define ENUM

(

name

)

resp_machine->name = LISTEN;

EVENT [1/2]

#define EVENT

(

name

)

resp_machine->name = NULL;

EVENT [2/2]

#define EVENT

(

name

)

wap_event_destroy(resp_machine->name);

INTEGER [1/2]

#define INTEGER

(

name

)

resp_machine->name = 0;

INTEGER [2/2]

#define INTEGER

(

name

)

resp_machine->name = 0;

LIST [1/2]

#define LIST

(

name

)

resp_machine->name = NULL;

LIST [2/2]

#define LIST

(

name

)

gwlist_destroy(resp_machine->name,sar_info_destroy);

MACHINE [1/2]

#define MACHINE

(

field

)

field

MACHINE [2/2]

#define MACHINE

(

field

)

field

ROW [1/2]

#define ROW	(		state,
			event,
			condition,
			action,
			new_state
	)

ROW [2/2]

#define ROW	(		wtp_state,
			event_type,
			condition,
			action,
			next_state
	)

Value:

if (resp_machine->state == wtp_state && \
         event->type == event_type && \
         (condition)) { \
         action \
         resp_machine->state = next_state; \
         debug("wap.wtp", 0, "WTP %ld: New state %s", resp_machine->mid,                      #next_state); \
     } else

SARDATA [1/2]

#define SARDATA

(

name

)

resp_machine->name = NULL;

SARDATA [2/2]

#define SARDATA

(

name

)

sardata_destroy(resp_machine->name);

STATE_NAME [1/2]

#define STATE_NAME

(

state

)

case state: return #state;

STATE_NAME [2/2]

#define STATE_NAME

(

state

)

TIMER [1/2]

#define TIMER

(

name

)

resp_machine->name = gwtimer_create(resp_queue);

TIMER [2/2]

#define TIMER

(

name

)

gwtimer_destroy(resp_machine->name);

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
limbo
running
terminating

Definition at line 96 of file wtp_resp.c.

{ limbo, running, terminating } resp_run_status = limbo;

Function Documentation

add_sar_transaction()

static int add_sar_transaction ( WTPRespMachine *  machine, Octstr *  data, int  psn  )

static

Definition at line 833 of file wtp_resp.c.

References debug(), gwlist_append(), gwlist_create, gwlist_search(), is_wanted_sar_data(), octstr_duplicate, sar_info_t::sar_data, and sar_info_t::sar_psn.

Referenced by process_sar_transaction().

{
    sar_info_t *sar_info;

    if (machine->sar_info == NULL) {
        machine->sar_info = gwlist_create();
    }

    if (gwlist_search(machine->sar_info, &psn, is_wanted_sar_data) == NULL) {
        sar_info = gw_malloc(sizeof(sar_info_t));
        sar_info->sar_psn = psn;
        sar_info->sar_data = octstr_duplicate(data);
        gwlist_append(machine->sar_info, sar_info);
        return 0;
    } else {
        debug("wap.wtp", 0, "Duplicated psn found, ignore packet");
        return 1;
    } 
}

assembly_sar_event()

static WAPEvent * assembly_sar_event ( WTPRespMachine *  machine, int  last_psn  )

static

Definition at line 853 of file wtp_resp.c.

References debug(), gwlist_search(), is_wanted_sar_data(), octstr_append(), WAPEvent::RcvInvoke, sar_info_t::sar_data, WAPEvent::u, and wap_event_duplicate().

Referenced by process_sar_transaction().

{
    WAPEvent *e;
    int i;
    sar_info_t *sar_info;

    e = wap_event_duplicate(machine->sar_invoke);

    for (i = 1; i <= last_psn; i++) {
        if ((sar_info = gwlist_search(machine->sar_info, &i, is_wanted_sar_data)) != NULL) {
            octstr_append(e->u.RcvInvoke.user_data,sar_info->sar_data);
        } else {
            debug("wap.wtp", 0, "Packet with psn %d not found", i);
            return e;
        }
    }

    return e;
}

begin_sar_result()

static void begin_sar_result ( WTPRespMachine *  machine, WAPEvent *  event  )

static

Definition at line 894 of file wtp_resp.c.

References WTPSARData::csegm, WTPSARData::data, debug(), dispatch_to_wdp, gw_assert(), WTPSARData::lsegm, WTPSARData::nsegm, octstr_duplicate, octstr_len(), SAR_SEGM_SIZE, WTPSARData::tr, WAPEvent::u, wap_event_duplicate(), and wtp_pack_sar_result().

{
    WAPEvent *result;
    WTPSARData *sar;
    int psn;

    gw_assert(resp_machine->sar != NULL);

    sar = resp_machine->sar;
    sar->data = octstr_duplicate(event->u.TR_Result_Req.user_data);
    sar->nsegm = (octstr_len(sar->data)-1)/SAR_SEGM_SIZE;
    sar->tr = sar->lsegm = 0;
    sar->csegm = -1;

    debug("wap.wtp", 0, "WTP: begin_sar_result(): data len = %lu", 
          octstr_len(sar->data));

    for (psn = 0; !sar->tr; psn++) {
        result = wtp_pack_sar_result(resp_machine, psn);
        if (sar->tr) 
            resp_machine->result = wap_event_duplicate(result);

        debug("wap.wtp", 0, "WTP: dispath_to_wdp(): psn = %u", psn);
        dispatch_to_wdp(result);
        sar->lsegm = psn;
    }

    resp_machine->rid = 1;
}

continue_sar_result()

static void continue_sar_result ( WTPRespMachine *  machine, WAPEvent *  event  )

static

Definition at line 924 of file wtp_resp.c.

References WTPSARData::csegm, debug(), dispatch_to_wdp, gw_assert(), WTPSARData::lsegm, WTPSARData::nsegm, WAPEvent::RcvAck, start_timer_R(), WTPSARData::tr, WAPEvent::type, WAPEvent::u, wap_event_destroy(), wap_event_duplicate(), and wtp_pack_sar_result().

{
    WAPEvent *result;
    WTPSARData *sar;
    int psn;

    gw_assert(resp_machine->sar != NULL && event->type == RcvAck);

    sar = resp_machine->sar;

    debug("wap.wtp", 0, "WTP: continue_sar_result(): lsegm=%d, nsegm=%d, csegm=%d",
          sar->lsegm, sar->nsegm, sar->csegm);

    start_timer_R(resp_machine);

    if (event->u.RcvAck.psn>sar->csegm) {
        sar->csegm = event->u.RcvAck.psn;
    }

    sar->tr = 0;
    wap_event_destroy(resp_machine->result);
    resp_machine->result = NULL;

    for (psn = sar->csegm + 1; !sar->tr; psn++) {
        result = wtp_pack_sar_result(resp_machine, psn);
        if (sar->tr) 
            resp_machine->result = wap_event_duplicate(result);

        debug("wap.wtp", 0, "WTP: dispath_to_wdp(): psn = %u",psn);
        dispatch_to_wdp(result);
        sar->lsegm = psn;
    }
}

create_tr_abort_ind()

static WAPEvent * create_tr_abort_ind ( WTPRespMachine *  sm, long  abort_reason  )

static

Definition at line 682 of file wtp_resp.c.

References WTPRespMachine::mid, RESPONDER_INDICATION, wap_addr_tuple_duplicate(), and wap_event_create.

                                                                            {
    WAPEvent *event;
    
    event = wap_event_create(TR_Abort_Ind);
    event->u.TR_Abort_Ind.abort_code = abort_reason;
    event->u.TR_Abort_Ind.addr_tuple = 
    wap_addr_tuple_duplicate(sm->addr_tuple);
    event->u.TR_Abort_Ind.handle = sm->mid;
    event->u.TR_Abort_Ind.ir_flag = RESPONDER_INDICATION;

    return event;
}

create_tr_invoke_ind()

static WAPEvent * create_tr_invoke_ind ( WTPRespMachine *  sm, Octstr *  user_data  )

static

Definition at line 649 of file wtp_resp.c.

References WTPRespMachine::mid, octstr_duplicate, wap_addr_tuple_duplicate(), and wap_event_create.

{
    WAPEvent *event;
    
    event = wap_event_create(TR_Invoke_Ind);
    event->u.TR_Invoke_Ind.ack_type = sm->u_ack;
    event->u.TR_Invoke_Ind.user_data = octstr_duplicate(user_data);
    event->u.TR_Invoke_Ind.tcl = sm->tcl;
    event->u.TR_Invoke_Ind.addr_tuple = 
    wap_addr_tuple_duplicate(sm->addr_tuple);
    event->u.TR_Invoke_Ind.handle = sm->mid;
    return event;
}

create_tr_result_cnf()

static WAPEvent * create_tr_result_cnf ( WTPRespMachine *  sm )

static

Definition at line 667 of file wtp_resp.c.

References WTPRespMachine::mid, wap_addr_tuple_duplicate(), and wap_event_create.

{
    WAPEvent *event;
    
    event = wap_event_create(TR_Result_Cnf);
    event->u.TR_Result_Cnf.addr_tuple = 
    wap_addr_tuple_duplicate(sm->addr_tuple);
    event->u.TR_Result_Cnf.handle = sm->mid;
    return event;
}

erroneous_field_in()

static int erroneous_field_in ( WAPEvent *  event )

static

Definition at line 365 of file wtp_resp.c.

Referenced by resp_machine_find_or_create().

{
    return event->type == RcvInvoke && event->u.RcvInvoke.version != 0;
}

handle_erroneous_field_in()

static void handle_erroneous_field_in ( WAPEvent *  event )

static

Definition at line 374 of file wtp_resp.c.

References debug(), handle_wrong_version(), WAPEvent::RcvInvoke, WAPEvent::type, and WAPEvent::u.

Referenced by resp_machine_find_or_create().

{
    if (event->type == RcvInvoke) {
        if (event->u.RcvInvoke.version != 0) {
            debug("wap.wtp_resp", 0, "WTP_RESP: wrong version, aborting"
                  "transaction");
            handle_wrong_version(event);
        }
    }
}

handle_wrong_version()

static void handle_wrong_version ( WAPEvent *  event )

static

Definition at line 351 of file wtp_resp.c.

References dispatch_to_wdp, PROVIDER, WAPEvent::RcvInvoke, WAPEvent::type, WAPEvent::u, wtp_pack_abort(), and WTPVERSIONZERO.

Referenced by handle_erroneous_field_in().

{       
    WAPEvent *ab;

    if (event->type == RcvInvoke) {
        ab = wtp_pack_abort(PROVIDER, WTPVERSIONZERO, event->u.RcvInvoke.tid, 
                            event->u.RcvInvoke.addr_tuple);
        dispatch_to_wdp(ab);
    }
}

is_wanted_resp_machine()

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

static

Definition at line 555 of file wtp_resp.c.

References WTPRespMachine::mid, machine_pattern::mid, machine_pattern::tid, machine_pattern::tuple, and wap_addr_tuple_same().

Referenced by resp_machine_find().

{
    machine_pattern *pat;
    WTPRespMachine *m;
    
    m = a;
    pat = b;

    if (m->mid == pat->mid)
    return 1;

    if (pat->mid != -1)
    return 0;

    return m->tid == pat->tid && 
           wap_addr_tuple_same(m->addr_tuple, pat->tuple);
}

is_wanted_sar_data()

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

static

Definition at line 815 of file wtp_resp.c.

References sar_info_t::sar_psn.

Referenced by add_sar_transaction(), and assembly_sar_event().

{
    sar_info_t *s;
    int *i;

    s = a;
    i = b;

    if (*i == s->sar_psn) {
        return 1;
    } else {
        return 0;
    }
}

main_thread()

static void main_thread ( void *  arg )

static

Definition at line 265 of file wtp_resp.c.

References gwlist_consume(), resp_event_handle(), resp_machine_find_or_create(), resp_queue, resp_run_status, running, and wap_event_destroy().

Referenced by wtp_resp_init(), and wtp_resp_shutdown().

{
    WTPRespMachine *sm;
    WAPEvent *e;

    while (resp_run_status == running && 
           (e = gwlist_consume(resp_queue)) != NULL) {

        sm = resp_machine_find_or_create(e);
        if (sm == NULL) {
            wap_event_destroy(e);
        } else {
            resp_event_handle(sm, e);
        }
    }
}

name_resp_state()

static char * name_resp_state ( int  name )

static

Definition at line 285 of file wtp_resp.c.

Referenced by resp_event_handle().

{
       switch (s) {
       #define STATE_NAME(state) case state: return #state;
       #define ROW(state, event, condition, action, new_state)
       #include "wtp_resp_states.def"
       default:
           return "unknown state";
       }
}

process_sar_transaction()

static int process_sar_transaction ( WTPRespMachine *  machine, WAPEvent **  event  )

static

Definition at line 755 of file wtp_resp.c.

References ACKNOWLEDGEMENT, add_sar_transaction(), assembly_sar_event(), dispatch_to_wdp, gw_assert(), WAPEvent::RcvInvoke, WAPEvent::type, WAPEvent::u, wap_event_destroy(), wap_event_duplicate(), and wtp_pack_sar_ack().

Referenced by resp_event_handle().

{
    WAPEvent *e, *orig_event;
    int psn;
  
    orig_event = *event;

    if (orig_event->type == RcvInvoke) { 
        if (!orig_event->u.RcvInvoke.ttr || !orig_event->u.RcvInvoke.gtr) { /* SAR */
            /* Ericcson set TTR flag even if we have the only part */
            if (orig_event->u.RcvInvoke.ttr == 1) {
                return 1; /* Not SAR although TTR flag was set */
            } else {
                /* save initial event */
                machine->sar_invoke = wap_event_duplicate(orig_event);

                /* save data into list with psn = 0 */
                add_sar_transaction(machine, orig_event->u.RcvInvoke.user_data, 0);

                if (orig_event->u.RcvInvoke.gtr == 1) { /* Need to acknowledge */
                    e = wtp_pack_sar_ack(ACKNOWLEDGEMENT, machine->tid,
                                         machine->addr_tuple, 0);
                    dispatch_to_wdp(e);
                }
                return 0;
            }
        } else {
            return 1; /* Not SAR */
        } 
    }

    if (orig_event->type == RcvSegInvoke) {
        add_sar_transaction(machine, orig_event->u.RcvSegInvoke.user_data, 
                            orig_event->u.RcvSegInvoke.psn);

        if (orig_event->u.RcvSegInvoke.gtr == 1) { /* Need to acknowledge */
            e = wtp_pack_sar_ack(ACKNOWLEDGEMENT, machine->tid, machine->addr_tuple,
                                 orig_event->u.RcvSegInvoke.psn);
            dispatch_to_wdp(e);
        }

        if (orig_event->u.RcvSegInvoke.ttr == 1) { /* Need to feed to WSP */

            /* Create assembled event */
            psn = orig_event->u.RcvSegInvoke.psn;
            wap_event_destroy(orig_event);
      
            *event = assembly_sar_event(machine,psn);

            gw_assert(event != NULL);

            return 1;
        }
        return 0;
    }

    /* Not SAR message */
    return 1;
}

resend_sar_result()

static void resend_sar_result ( WTPRespMachine *  resp_machine, WAPEvent *  event  )

static

Definition at line 958 of file wtp_resp.c.

References WTPSARData::csegm, debug(), dispatch_to_wdp, gw_assert(), WTPSARData::lsegm, WTPSARData::nsegm, octstr_get_char(), start_timer_R(), WTPSARData::tr, WAPEvent::type, WAPEvent::u, wtp_pack_sar_result(), and wtp_pack_set_rid().

{
    WAPEvent *result;
    WTPSARData *sar;
    int psn, i;

    gw_assert(resp_machine->sar != NULL && event->type == RcvNegativeAck);

    sar = resp_machine->sar;

    debug("wap.wtp", 0, "WTP: resend_sar_result(): lsegm=%d, nsegm=%d, csegm=%d",
          sar->lsegm, sar->nsegm, sar->csegm);

    start_timer_R(resp_machine);

    if (event->u.RcvNegativeAck.nmissing) { 
        /* if we have a list of missed packets */
        for(i = 0; i < event->u.RcvNegativeAck.nmissing; i++) {
            if ((psn = octstr_get_char(event->u.RcvNegativeAck.missing, i)) >= 0) {     
                result = wtp_pack_sar_result(resp_machine, psn);
                wtp_pack_set_rid(result, 1);
                debug("wap.wtp", 0, "WTP: dispath_to_wdp(): psn = %u", psn);
                dispatch_to_wdp(result);
            }
        }
    } else { 
        /* if we have to resend a whole group */
        sar->tr = 0;
        for (psn = sar->csegm+1; !sar->tr; psn++) {
            result = wtp_pack_sar_result(resp_machine, psn);
            wtp_pack_set_rid(result, 1);
            debug("wap.wtp", 0, "WTP: dispath_to_wdp(): psn = %u", psn);
            dispatch_to_wdp(result);
        }
    }
}

resp_event_handle()

static void resp_event_handle ( WTPRespMachine *  machine, WAPEvent *  event  )

static

Definition at line 302 of file wtp_resp.c.

References debug(), error(), WTPRespMachine::mid, name_resp_state(), process_sar_transaction(), resp_machine_destroy(), start_timer_W(), WAPEvent::type, wap_event_destroy(), wap_event_dump(), and wap_event_name().

Referenced by main_thread().

{
    WAPEvent *wsp_event = NULL;

    /* 
     * We don't feed sar packets into state machine 
     * until we got the whole message 
     */
    if (process_sar_transaction(resp_machine,&event) == 0) {
        debug("wap.wtp", 0, "SAR event received, wait for continue");
        /* For removing state machine in case of incomplete sar */
        start_timer_W(resp_machine);
        if (event != NULL) {
            wap_event_destroy(event);  
        }
        return;
    }

    debug("wap.wtp", 0, "WTP: resp_machine %ld, state %s, event %s.", 
      resp_machine->mid, 
      name_resp_state(resp_machine->state), 
      wap_event_name(event->type));

    #define STATE_NAME(state)
    #define ROW(wtp_state, event_type, condition, action, next_state) \
     if (resp_machine->state == wtp_state && \
         event->type == event_type && \
         (condition)) { \
         action \
         resp_machine->state = next_state; \
         debug("wap.wtp", 0, "WTP %ld: New state %s", resp_machine->mid,                      #next_state); \
     } else 
    #include "wtp_resp_states.def"
     {
         error(0, "WTP: handle_event: unhandled event!");
         debug("wap.wtp", 0, "WTP: handle_event: Unhandled event was:");
         wap_event_dump(event);
             wap_event_destroy(event);
             return;
     }

    if (event != NULL) {
    wap_event_destroy(event);  
    }

    if (resp_machine->state == LISTEN)
        resp_machine_destroy(resp_machine);
}

resp_machine_create()

static WTPRespMachine * resp_machine_create ( WAPAddrTuple *  tuple, long  tid, long  tcl  )

static

Definition at line 589 of file wtp_resp.c.

References counter_increase(), debug(), gwlist_append(), WTPRespMachine::mid, resp_machine_id_counter, resp_machines, and wap_addr_tuple_duplicate().

Referenced by resp_machine_find_or_create().

{
    WTPRespMachine *resp_machine;
    
    resp_machine = gw_malloc(sizeof(WTPRespMachine)); 
        
    #define ENUM(name) resp_machine->name = LISTEN;
    #define EVENT(name) resp_machine->name = NULL;
    #define INTEGER(name) resp_machine->name = 0; 
    #define TIMER(name) resp_machine->name = gwtimer_create(resp_queue); 
    #define ADDRTUPLE(name) resp_machine->name = NULL; 
    #define LIST(name) resp_machine->name = NULL;
    #define SARDATA(name) resp_machine->name = NULL;
    #define MACHINE(field) field
    #include "wtp_resp_machine.def"

    gwlist_append(resp_machines, resp_machine);

    resp_machine->mid = counter_increase(resp_machine_id_counter);
    resp_machine->addr_tuple = wap_addr_tuple_duplicate(tuple);
    resp_machine->tid = tid;
    resp_machine->tcl = tcl;
    
    debug("wap.wtp", 0, "WTP: Created WTPRespMachine %p (%ld)", 
      (void *) resp_machine, resp_machine->mid);

    return resp_machine;
} 

resp_machine_destroy()

static void resp_machine_destroy ( void *  sm )

static

Definition at line 624 of file wtp_resp.c.

References debug(), gwlist_delete_equal(), WTPRespMachine::mid, and resp_machines.

Referenced by resp_event_handle(), and wtp_resp_shutdown().

{
    WTPRespMachine *resp_machine;

    resp_machine = p;
    debug("wap.wtp", 0, "WTP: Destroying WTPRespMachine %p (%ld)", 
      (void *) resp_machine, resp_machine->mid);
    
    gwlist_delete_equal(resp_machines, resp_machine);
        
    #define ENUM(name) resp_machine->name = LISTEN;
    #define EVENT(name) wap_event_destroy(resp_machine->name);
    #define INTEGER(name) resp_machine->name = 0; 
    #define TIMER(name) gwtimer_destroy(resp_machine->name); 
    #define ADDRTUPLE(name) wap_addr_tuple_destroy(resp_machine->name); 
    #define LIST(name) gwlist_destroy(resp_machine->name,sar_info_destroy);
    #define SARDATA(name) sardata_destroy(resp_machine->name);
    #define MACHINE(field) field
    #include "wtp_resp_machine.def"
    gw_free(resp_machine);
}

resp_machine_find()

static WTPRespMachine * resp_machine_find ( WAPAddrTuple *  tuple, long  tid, long  mid  )

static

Definition at line 574 of file wtp_resp.c.

References gwlist_search(), is_wanted_resp_machine(), machine_pattern::mid, resp_machines, machine_pattern::tid, and machine_pattern::tuple.

Referenced by resp_machine_find_or_create().

{
    machine_pattern pat;
    WTPRespMachine *m;
    
    pat.tuple = tuple;
    pat.tid = tid;
    pat.mid = mid;
    
    m = gwlist_search(resp_machines, &pat, is_wanted_resp_machine);
    return m;
}

resp_machine_find_or_create()

static WTPRespMachine * resp_machine_find_or_create ( WAPEvent *  event )

static

Definition at line 397 of file wtp_resp.c.

References debug(), erroneous_field_in(), error(), gw_assert(), handle_erroneous_field_in(), info(), WAPEvent::RcvInvoke, resp_machine_create(), resp_machine_find(), WAPEvent::type, WAPEvent::u, and wap_event_dump().

Referenced by main_thread().

{
    WTPRespMachine *resp_machine = NULL;
    long tid, mid;
    WAPAddrTuple *tuple;

    tid = -1;
    tuple = NULL;
    mid = -1;

    switch (event->type) {
        case RcvInvoke:
            /* check if erroneous fields are given */
            if (erroneous_field_in(event)) {
                handle_erroneous_field_in(event);
                return NULL;
            } else {
                tid = event->u.RcvInvoke.tid;
                tuple = event->u.RcvInvoke.addr_tuple;
            }
            break;

        case RcvSegInvoke:
            tid = event->u.RcvSegInvoke.tid;
            tuple = event->u.RcvSegInvoke.addr_tuple;
            break;

        case RcvAck:
            tid = event->u.RcvAck.tid;
            tuple = event->u.RcvAck.addr_tuple;
            break;

        case RcvNegativeAck:
            tid = event->u.RcvAck.tid;
            tuple = event->u.RcvAck.addr_tuple;
            break;

        case RcvAbort:
            tid = event->u.RcvAbort.tid;
            tuple = event->u.RcvAbort.addr_tuple;
            break;

        case RcvErrorPDU:
            tid = event->u.RcvErrorPDU.tid;
            tuple = event->u.RcvErrorPDU.addr_tuple;
            break;

        case TR_Invoke_Res:
            mid = event->u.TR_Invoke_Res.handle;
            break;

        case TR_Result_Req:
            mid = event->u.TR_Result_Req.handle;
            break;

        case TR_Abort_Req:
            mid = event->u.TR_Abort_Req.handle;
            break;

        case TimerTO_A:
            mid = event->u.TimerTO_A.handle;
            break;

        case TimerTO_R:
            mid = event->u.TimerTO_R.handle;
            break;

        case TimerTO_W:
            mid = event->u.TimerTO_W.handle;
            break;

        default:
            debug("wap.wtp", 0, "WTP: resp_machine_find_or_create:"
                  "unhandled event"); 
            wap_event_dump(event);
            return NULL;
    }

    gw_assert(tuple != NULL || mid != -1);
    resp_machine = resp_machine_find(tuple, tid, mid);
           
    if (resp_machine == NULL){

        switch (event->type) {

        /*
         * When PDU with an illegal header is received, its tcl-field is 
         * irrelevant and possibly meaningless). In this case we must create 
         * a new machine, if there is any. There is a machine for all events 
         * handled stateful manner.
         */
        case RcvErrorPDU:
            debug("wap.wtp_resp", 0, "an erronous pdu received");
            wap_event_dump(event);
            resp_machine = resp_machine_create(tuple, tid, 
                                               event->u.RcvInvoke.tcl); 
            break;
           
        case RcvInvoke:
            resp_machine = resp_machine_create(tuple, tid, 
                                               event->u.RcvInvoke.tcl);
            /* if SAR requested */
            if (!event->u.RcvInvoke.gtr || !event->u.RcvInvoke.ttr) {
                resp_machine->sar = gw_malloc(sizeof(WTPSARData));
                resp_machine->sar->nsegm = 0;
                resp_machine->sar->csegm = 0;
                resp_machine->sar->lsegm = 0;
                resp_machine->sar->data = NULL;     
            }

            break;
        
        case RcvSegInvoke:
            info(0, "WTP_RESP: resp_machine_find_or_create:"
                 " segmented invoke received, yet having no machine");
            break;

        /*
         * This and the following branch implement test nro 3 in WTP 10.2.
         */
        case RcvAck: 
            info(0, "WTP_RESP: resp_machine_find_or_create:"
                 " ack received, yet having no machine");
            break;

        case RcvNegativeAck: 
            info(0, "WTP_RESP: resp_machine_find_or_create:"
                 " negative ack received, yet having no machine");
            break;

        case RcvAbort: 
            info(0, "WTP_RESP: resp_machine_find_or_create:"
                 " abort received, yet having no machine");
            break;

        case TR_Invoke_Res: 
        case TR_Result_Req: 
        case TR_Abort_Req:
            error(0, "WTP_RESP: resp_machine_find_or_create: WSP primitive to"
                  " a wrong WTP machine");
            break;

        case TimerTO_A: 
        case TimerTO_R: 
        case TimerTO_W:
            error(0, "WTP_RESP: resp_machine_find_or_create: timer event"
                  " without a corresponding machine");
            break;
                 
        default:
            error(0, "WTP_RESP: resp_machine_find_or_create: unhandled event");
            wap_event_dump(event);
            break;
        }
   } /* if machine == NULL */   
   return resp_machine;
}

sar_info_destroy()

static void sar_info_destroy ( void *  sar_info )

static

Definition at line 873 of file wtp_resp.c.

References octstr_destroy(), and sar_info_t::sar_data.

{
    sar_info_t *sar_info;

    sar_info = p;
  
    octstr_destroy(sar_info->sar_data);
    gw_free(sar_info);
}

sardata_destroy()

static void sardata_destroy ( void *  sardata )

static

Definition at line 883 of file wtp_resp.c.

References WTPSARData::data, and octstr_destroy().

{
    WTPSARData * sardata;

    if (p) {
        sardata = p;
        octstr_destroy(sardata->data);
        gw_free(sardata);
    }
}

send_abort()

static void send_abort ( WTPRespMachine *  machine, long  type, long  reason  )

static

Definition at line 736 of file wtp_resp.c.

References dispatch_to_wdp, type, and wtp_pack_abort().

{
    WAPEvent *e;

    e = wtp_pack_abort(type, reason, machine->tid, machine->addr_tuple);
    dispatch_to_wdp(e);
}

send_ack()

static void send_ack ( WTPRespMachine *  machine, long  ack_type, int  rid_flag  )

static

Definition at line 744 of file wtp_resp.c.

References dispatch_to_wdp, and wtp_pack_ack().

{
    WAPEvent *e;

    e = wtp_pack_ack(ack_type, rid_flag, machine->tid, machine->addr_tuple);
    dispatch_to_wdp(e);
}

start_timer_A()

static void start_timer_A ( WTPRespMachine *  machine )

static

Definition at line 699 of file wtp_resp.c.

References gwtimer_start(), L_A_WITH_USER_ACK, WTPRespMachine::mid, resp_timer_freq, WAPEvent::u, and wap_event_create.

{
    WAPEvent *timer_event;

    timer_event = wap_event_create(TimerTO_A);
    timer_event->u.TimerTO_A.handle = machine->mid;
    gwtimer_start(machine->timer, L_A_WITH_USER_ACK * resp_timer_freq, 
                  timer_event);
}

start_timer_R()

static void start_timer_R ( WTPRespMachine *  machine )

static

Definition at line 712 of file wtp_resp.c.

References gwtimer_start(), L_R_WITH_USER_ACK, WTPRespMachine::mid, resp_timer_freq, WAPEvent::u, and wap_event_create.

Referenced by continue_sar_result(), and resend_sar_result().

{
    WAPEvent *timer_event;

    timer_event = wap_event_create(TimerTO_R);
    timer_event->u.TimerTO_R.handle = machine->mid;
    gwtimer_start(machine->timer, L_R_WITH_USER_ACK * resp_timer_freq, 
                  timer_event);
}

start_timer_W()

static void start_timer_W ( WTPRespMachine *  machine )

static

Definition at line 726 of file wtp_resp.c.

References gwtimer_start(), WTPRespMachine::mid, resp_timer_freq, WAPEvent::u, W_WITH_USER_ACK, and wap_event_create.

Referenced by resp_event_handle().

{
    WAPEvent *timer_event;

    timer_event = wap_event_create(TimerTO_W);
    timer_event->u.TimerTO_W.handle = machine->mid;
    gwtimer_start(machine->timer, W_WITH_USER_ACK * resp_timer_freq, 
                  timer_event);
}

wtp_resp_dispatch_event()

void wtp_resp_dispatch_event

(

WAPEvent *

event

)

Definition at line 253 of file wtp_resp.c.

References gwlist_produce(), and resp_queue.

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

{
    gwlist_produce(resp_queue, event);
}

wtp_resp_init()

void wtp_resp_init	(	wap_dispatch_func_t *	datagram_dispatch,
		wap_dispatch_func_t *	session_dispatch,
		wap_dispatch_func_t *	push_dispatch,
		long	timer_freq
	)

Definition at line 211 of file wtp_resp.c.

References counter_create(), dispatch_to_push, dispatch_to_wdp, dispatch_to_wsp, gw_assert(), gwlist_add_producer(), gwlist_create, gwthread_create, limbo, main_thread(), resp_machine_id_counter, resp_machines, resp_queue, resp_run_status, resp_timer_freq, running, timer_freq, timers_init(), and wtp_tid_cache_init().

Referenced by main().

{
    resp_machines = gwlist_create();
    resp_machine_id_counter = counter_create();

    resp_queue = gwlist_create();
    gwlist_add_producer(resp_queue);

    dispatch_to_wdp = datagram_dispatch;
    dispatch_to_wsp = session_dispatch;
    dispatch_to_push = push_dispatch;

    timers_init();
    resp_timer_freq = timer_freq;
    wtp_tid_cache_init();

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

wtp_resp_shutdown()

void wtp_resp_shutdown

(

void

)

Definition at line 235 of file wtp_resp.c.

References counter_destroy(), debug(), gw_assert(), gwlist_destroy(), gwlist_len(), gwlist_remove_producer(), gwthread_join_every(), main_thread(), resp_machine_destroy(), resp_machine_id_counter, resp_machines, resp_queue, resp_run_status, running, terminating, timers_shutdown(), wap_event_destroy_item(), and wtp_tid_cache_shutdown().

Referenced by main().

{
    gw_assert(resp_run_status == running);
    resp_run_status = terminating;
    gwlist_remove_producer(resp_queue);
    gwthread_join_every(main_thread);

    debug("wap.wtp", 0, "wtp_resp_shutdown: %ld resp_machines left",
          gwlist_len(resp_machines));
    gwlist_destroy(resp_machines, resp_machine_destroy);
    gwlist_destroy(resp_queue, wap_event_destroy_item);

    counter_destroy(resp_machine_id_counter);

    wtp_tid_cache_shutdown();
    timers_shutdown();
}

Variable Documentation

dispatch_to_push

wap_dispatch_func_t* dispatch_to_push

Definition at line 101 of file wtp_resp.c.

Referenced by wtp_resp_init().

dispatch_to_wdp

wap_dispatch_func_t* dispatch_to_wdp

Definition at line 99 of file wtp_resp.c.

Referenced by begin_sar_result(), continue_sar_result(), handle_wrong_version(), process_sar_transaction(), resend_sar_result(), send_abort(), send_ack(), and wtp_resp_init().

dispatch_to_wsp

wap_dispatch_func_t* dispatch_to_wsp

Definition at line 100 of file wtp_resp.c.

Referenced by wtp_resp_init().

resp_machine_id_counter

Counter* resp_machine_id_counter = NULL

static

Definition at line 83 of file wtp_resp.c.

Referenced by resp_machine_create(), wtp_resp_init(), and wtp_resp_shutdown().

resp_machines

List* resp_machines = NULL

static

Definition at line 77 of file wtp_resp.c.

Referenced by resp_machine_create(), resp_machine_destroy(), resp_machine_find(), wtp_resp_init(), and wtp_resp_shutdown().

resp_queue

List* resp_queue = NULL

static

Definition at line 106 of file wtp_resp.c.

Referenced by main_thread(), wtp_resp_dispatch_event(), wtp_resp_init(), and wtp_resp_shutdown().

resp_run_status

enum { ... } resp_run_status

Referenced by main_thread(), wtp_resp_init(), and wtp_resp_shutdown().

resp_timer_freq

long resp_timer_freq = -1

static

Definition at line 111 of file wtp_resp.c.

Referenced by start_timer_A(), start_timer_R(), start_timer_W(), and wtp_resp_init().