wtp_init.c File Reference

#include "gwlib/gwlib.h"
#include "wtp_init.h"
#include "wtp_pack.h"
#include "wap.h"
#include "wtp_init_machine.def"
#include "wtp_init_states.def"

Go to the source code of this file.

Macros
#define	ENUM(name)   init_machine->name = INITIATOR_NULL_STATE;
#define	INTEGER(name)   init_machine->name = 0;
#define	EVENT(name)   init_machine->name = NULL;
#define	TIMER(name)   init_machine->name = gwtimer_create(queue);
#define	ADDRTUPLE(name)   init_machine->name = NULL;
#define	MACHINE(field)   field
#define	ENUM(name)   init_machine->name = INITIATOR_NULL_STATE;
#define	INTEGER(name)   init_machine->name = 0;
#define	EVENT(name)   wap_event_destroy(init_machine->name);
#define	TIMER(name)   gwtimer_destroy(init_machine->name);
#define	ADDRTUPLE(name)   wap_addr_tuple_destroy(init_machine->name);
#define	MACHINE(field)   field
#define	INIT_STATE_NAME(state)   case state: return (unsigned char *) #state;
#define	ROW(state, event, condition, action, new_state)
#define	INIT_STATE_NAME(state)
#define	ROW(init_state, event_type, condition, action, next_state)

Enumerations
enum	{ limbo, running, terminating }

Functions
static void	main_thread (void *arg)
static WTPInitMachine *	init_machine_create (WAPAddrTuple *tuple, unsigned short tid, int tidnew)
static void	init_machine_destroy (void *sm)
static void	handle_init_event (WTPInitMachine *machine, WAPEvent *event)
static WTPInitMachine *	init_machine_find_or_create (WAPEvent *event)
static WAPEvent *	create_tr_abort_ind (WTPInitMachine *sm, long abort_reason)
static WAPEvent *	create_tr_invoke_cnf (WTPInitMachine *machine)
static int	tid_wrapped (unsigned short tid)
static void	send_abort (WTPInitMachine *machine, long type, long reason)
static void	send_ack (WTPInitMachine *machine, long ack_type, int rid_flag)
static unsigned short	rcv_tid (unsigned short tid)
static void	start_initiator_timer_R (WTPInitMachine *machine)
static void	stop_initiator_timer (Timer *timer)
void	wtp_initiator_init (wap_dispatch_func_t *datagram_dispatch, wap_dispatch_func_t *session_dispatch, long timer_freq)
void	wtp_initiator_shutdown (void)
void	wtp_initiator_dispatch_event (WAPEvent *event)
static unsigned char *	name_init_state (int s)
static int	is_wanted_init_machine (void *a, void *b)
static WTPInitMachine *	init_machine_find (WAPAddrTuple *tuple, long tid, long mid)

Variables
static List *	init_machines = NULL
static Counter *	init_machine_id_counter = NULL
static int	tidnew = 1
static List *	queue = NULL
static enum { ... }	initiator_run_status = limbo
static wap_dispatch_func_t *	dispatch_to_wdp
static wap_dispatch_func_t *	dispatch_to_wsp
static long	init_timer_freq = -1

Macro Definition Documentation

ADDRTUPLE [1/2]

#define ADDRTUPLE

(

name

)

init_machine->name = NULL;

ADDRTUPLE [2/2]

#define ADDRTUPLE

(

name

)

wap_addr_tuple_destroy(init_machine->name);

ENUM [1/2]

#define ENUM

(

name

)

init_machine->name = INITIATOR_NULL_STATE;

ENUM [2/2]

#define ENUM

(

name

)

init_machine->name = INITIATOR_NULL_STATE;

EVENT [1/2]

#define EVENT

(

name

)

init_machine->name = NULL;

EVENT [2/2]

#define EVENT

(

name

)

wap_event_destroy(init_machine->name);

INIT_STATE_NAME [1/2]

#define INIT_STATE_NAME

(

state

)

case state: return (unsigned char *) #state;

INIT_STATE_NAME [2/2]

#define INIT_STATE_NAME

(

state

)

INTEGER [1/2]

#define INTEGER

(

name

)

init_machine->name = 0;

INTEGER [2/2]

#define INTEGER

(

name

)

init_machine->name = 0;

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	(		init_state,
			event_type,
			condition,
			action,
			next_state
	)

Value:

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

TIMER [1/2]

#define TIMER

(

name

)

init_machine->name = gwtimer_create(queue);

TIMER [2/2]

#define TIMER

(

name

)

gwtimer_destroy(init_machine->name);

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
limbo
running
terminating

Definition at line 101 of file wtp_init.c.

{ limbo, running, terminating } initiator_run_status = limbo;

Function Documentation

create_tr_abort_ind()

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

static

Definition at line 520 of file wtp_init.c.

References INITIATOR_INDICATION, WTPInitMachine::mid, 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 = INITIATOR_INDICATION;

    return event;
}

create_tr_invoke_cnf()

static WAPEvent * create_tr_invoke_cnf ( WTPInitMachine *  machine )

static

Definition at line 503 of file wtp_init.c.

References gw_assert(), WTPInitMachine::mid, wap_addr_tuple_duplicate(), and wap_event_create.

{
    WAPEvent *event;

    gw_assert(init_machine != NULL);
    event = wap_event_create(TR_Invoke_Cnf);
    event->u.TR_Invoke_Cnf.handle = init_machine->mid;
    event->u.TR_Invoke_Cnf.addr_tuple = 
        wap_addr_tuple_duplicate(init_machine->addr_tuple);

    return event;
}

handle_init_event()

static void handle_init_event ( WTPInitMachine *  machine, WAPEvent *  event  )

static

Definition at line 301 of file wtp_init.c.

References debug(), error(), init_machine_destroy(), WTPInitMachine::mid, name_init_state(), WAPEvent::type, wap_event_destroy(), wap_event_dump(), and wap_event_name().

Referenced by main_thread().

{
     WAPEvent *wsp_event = NULL;

     debug("wap.wtp", 0, "WTP_INIT: initiator machine %ld, state %s,"
           " event %s.", 
       init_machine->mid, 
       name_init_state(init_machine->state), 
       wap_event_name(event->type));
       
     #define INIT_STATE_NAME(state)
     #define ROW(init_state, event_type, condition, action, next_state) \
     if (init_machine->state == init_state && \
         event->type == event_type && \
         (condition)) { \
         action \
         init_machine->state = next_state; \
         debug("wap.wtp", 0, "WTP_INIT %ld: New state %s", \
                   init_machine->mid, #next_state); \
     } else 
      #include "wtp_init_states.def"
     {
         error(1, "WTP_INIT: handle_init_event: unhandled event!");
         debug("wap.wtp.init", 0, "WTP_INIT: handle_init_event:"
                   "Unhandled event was:");
         wap_event_dump(event);
             wap_event_destroy(event);
             return;
     }

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

      if (init_machine->state == INITIATOR_NULL_STATE)
          init_machine_destroy(init_machine);      
}

init_machine_create()

static WTPInitMachine * init_machine_create ( WAPAddrTuple *  tuple, unsigned short  tid, int  tidnew  )

static

Definition at line 229 of file wtp_init.c.

References counter_increase(), debug(), gwlist_append(), init_machine_id_counter, init_machines, WTPInitMachine::mid, machine_pattern::tid, tidnew, machine_pattern::tuple, and wap_addr_tuple_duplicate().

Referenced by init_machine_find_or_create().

{
     WTPInitMachine *init_machine;
    
     init_machine = gw_malloc(sizeof(WTPInitMachine)); 
        
     #define ENUM(name) init_machine->name = INITIATOR_NULL_STATE;
     #define INTEGER(name) init_machine->name = 0; 
     #define EVENT(name) init_machine->name = NULL;
     #define TIMER(name) init_machine->name = gwtimer_create(queue); 
     #define ADDRTUPLE(name) init_machine->name = NULL; 
     #define MACHINE(field) field
     #include "wtp_init_machine.def"

     gwlist_append(init_machines, init_machine);

     init_machine->mid = counter_increase(init_machine_id_counter);
     init_machine->addr_tuple = wap_addr_tuple_duplicate(tuple);
     init_machine->tid = tid;
     init_machine->tidnew = tidnew;
    
     debug("wap.wtp", 0, "WTP: Created WTPInitMachine %p (%ld)", 
       (void *) init_machine, init_machine->mid);

     return init_machine;
}

init_machine_destroy()

static void init_machine_destroy ( void *  sm )

static

Definition at line 261 of file wtp_init.c.

References debug(), gwlist_delete_equal(), init_machines, and WTPInitMachine::mid.

Referenced by handle_init_event(), and wtp_initiator_shutdown().

{
     WTPInitMachine *init_machine;

     init_machine = p;
     debug("wap.wtp", 0, "WTP: Destroying WTPInitMachine %p (%ld)", 
        (void *) init_machine, init_machine->mid);
    
     gwlist_delete_equal(init_machines, init_machine);
        
     #define ENUM(name) init_machine->name = INITIATOR_NULL_STATE;
     #define INTEGER(name) init_machine->name = 0; 
     #define EVENT(name) wap_event_destroy(init_machine->name); 
     #define TIMER(name) gwtimer_destroy(init_machine->name); 
     #define ADDRTUPLE(name) wap_addr_tuple_destroy(init_machine->name); 
     #define MACHINE(field) field
     #include "wtp_init_machine.def"
     gw_free(init_machine);
}

init_machine_find()

static WTPInitMachine* init_machine_find ( WAPAddrTuple *  tuple, long  tid, long  mid  )

static

Definition at line 357 of file wtp_init.c.

References gwlist_search(), init_machines, is_wanted_init_machine(), machine_pattern::mid, machine_pattern::tid, and machine_pattern::tuple.

Referenced by init_machine_find_or_create().

{
    struct machine_pattern pat;
    WTPInitMachine *m;
    
    pat.tuple = tuple;
    pat.tid = tid;
    pat.mid = mid;
    
    m = gwlist_search(init_machines, &pat, is_wanted_init_machine);
    return m;
}

init_machine_find_or_create()

static WTPInitMachine * init_machine_find_or_create ( WAPEvent *  event )

static

Definition at line 388 of file wtp_init.c.

References dispatch_to_wdp, error(), gw_assert(), info(), init_machine_create(), init_machine_find(), INVALIDTID, WTPInitMachine::mid, machine_pattern::mid, PROVIDER, rcv_tid(), WAPEvent::RcvAck, machine_pattern::tid, tid_wrapped(), tidnew, machine_pattern::tuple, WAPEvent::type, WAPEvent::u, wap_event_dump(), and wtp_pack_abort().

Referenced by main_thread().

{
    WTPInitMachine *machine = NULL;
    long mid;
    static long tid = -1; 
    WAPAddrTuple *tuple;

    mid = -1;
    tuple = NULL;

    switch (event->type) {
    case RcvAck:
        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:
        mid = event->u.RcvErrorPDU.tid;
        tid = event->u.RcvErrorPDU.tid;
        tuple = event->u.RcvErrorPDU.addr_tuple;
    break;
/*
 * When we are receiving an invoke requirement, we must create a new trans-
 * action and generate a new tid. This can be wrapped, and should have its 
 * first bit turned.
 */
    case TR_Invoke_Req:
    ++tid;
        if (tid_wrapped(tid)) {
        tidnew = 1;
            tid = 0;
        }
                   
    tid = rcv_tid(tid);
        tuple = event->u.TR_Invoke_Req.addr_tuple;
        mid = event->u.TR_Invoke_Req.handle;
    break;

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

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

    default:
    error(0, "WTP_INIT: machine_find_or_create: unhandled event");
        wap_event_dump(event);
        return NULL;
    }

    gw_assert(tuple != NULL || mid != -1);
    machine = init_machine_find(tuple, tid, mid);

    if (machine == NULL){

    switch (event->type){
    case RcvAck:   
   
/* 
 * Case nro 2 If we do not have a tid asked for, we send a negative answer, 
 * i.e. an abort with reason INVALIDTID. 
 */
         if (event->u.RcvAck.tid_ok) {
         dispatch_to_wdp(wtp_pack_abort(PROVIDER, INVALIDTID,
                                                tid, tuple));
             }

/* Case nro 3, normal ack */
             else
                 info(0, "WTP_INIT: machine_find_or_create: ack "
                     "received, yet having no machine");
    break;

/* Case nro 3, abort */
        case RcvAbort:
            info(0, "WTP_INIT: machine_find_or_create: abort "
                 "received, yet having no machine");
    break;

    case TR_Invoke_Req:
        machine = init_machine_create(tuple, tid, tidnew);
            machine->mid = event->u.TR_Invoke_Req.handle;
    break;

    case TR_Abort_Req:
            error(0, "WTP_INIT: machine_find_or_create: WSP "
                  "primitive to a wrong WTP machine");
    break;

    case TimerTO_R:
        error(0, "WTP_INIT: machine_find_or_create: timer "
                       "event without a corresponding machine");
        break;
       
        default:
            error(0, "WTP_INIT: machine_find_or_create: unhandled"
                  "event");
            wap_event_dump(event);
        break; 
        }
   } 

   return machine;
}

is_wanted_init_machine()

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

static

Definition at line 339 of file wtp_init.c.

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

Referenced by init_machine_find().

{
    struct machine_pattern *pat;
    WTPInitMachine *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);
}

main_thread()

static void main_thread ( void *  arg )

static

Definition at line 214 of file wtp_init.c.

References gwlist_consume(), handle_init_event(), init_machine_find_or_create(), initiator_run_status, queue, running, and wap_event_destroy().

Referenced by wtp_initiator_init(), and wtp_initiator_shutdown().

{
    WTPInitMachine *sm;
    WAPEvent *e;

    while (initiator_run_status == running && 
          (e = gwlist_consume(queue)) != NULL) {
        sm = init_machine_find_or_create(e);
    if (sm == NULL)
        wap_event_destroy(e);
    else
        handle_init_event(sm, e);
    }
}

name_init_state()

static unsigned char* name_init_state ( int  s )

static

Definition at line 284 of file wtp_init.c.

Referenced by handle_init_event().

{
       switch (s){
       #define INIT_STATE_NAME(state) case state: return (unsigned char *) #state;
       #define ROW(state, event, condition, action, new_state)
       #include "wtp_init_states.def"
       default:
           return (unsigned char *)"unknown state";
       }
}

rcv_tid()

static unsigned short rcv_tid ( unsigned short  tid )

static

Definition at line 541 of file wtp_init.c.

References machine_pattern::tid.

Referenced by init_machine_find_or_create(), tid_in_window(), and wtp_tid_is_valid().

{
    return tid ^ 0x8000;
}

send_abort()

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

static

Definition at line 571 of file wtp_init.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 ( WTPInitMachine *  machine, long  ack_type, int  rid_flag  )

static

Definition at line 579 of file wtp_init.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_initiator_timer_R()

static void start_initiator_timer_R ( WTPInitMachine *  machine )

static

Definition at line 550 of file wtp_init.c.

References gwtimer_start(), init_timer_freq, WTPInitMachine::mid, S_R_WITH_USER_ACK, S_R_WITHOUT_USER_ACK, WAPEvent::u, and wap_event_create.

{
    WAPEvent *timer_event;
    int seconds;

    timer_event = wap_event_create(TimerTO_R);
    timer_event->u.TimerTO_R.handle = machine->mid;
    if (machine->u_ack)
        seconds = S_R_WITH_USER_ACK * init_timer_freq;
    else
        seconds = S_R_WITHOUT_USER_ACK * init_timer_freq;
    gwtimer_start(machine->timer, seconds, timer_event);
}

stop_initiator_timer()

static void stop_initiator_timer ( Timer *  timer )

static

Definition at line 564 of file wtp_init.c.

References debug(), gw_assert(), and gwtimer_stop().

{
    debug("wap.wtp_init", 0, "stopping timer");
    gw_assert(timer);
    gwtimer_stop(timer);
}

tid_wrapped()

static int tid_wrapped ( unsigned short  tid )

static

Definition at line 536 of file wtp_init.c.

References machine_pattern::tid.

Referenced by init_machine_find_or_create().

{
    return tid > (1 << 15);
}

wtp_initiator_dispatch_event()

void wtp_initiator_dispatch_event

(

WAPEvent *

event

)

Definition at line 204 of file wtp_init.c.

References gwlist_produce(), and queue.

Referenced by main(), and wap_dispatch_datagram().

{
    gwlist_produce(queue, event);
}

wtp_initiator_init()

void wtp_initiator_init	(	wap_dispatch_func_t *	datagram_dispatch,
		wap_dispatch_func_t *	session_dispatch,
		long	timer_freq
	)

Definition at line 168 of file wtp_init.c.

References counter_create(), dispatch_to_wdp, dispatch_to_wsp, gw_assert(), gwlist_add_producer(), gwlist_create, gwthread_create, init_machine_id_counter, init_machines, init_timer_freq, initiator_run_status, limbo, main_thread(), queue, running, timer_freq, and timers_init().

Referenced by main().

{
    init_machines = gwlist_create();
    init_machine_id_counter = counter_create();
     
    queue = gwlist_create();
    gwlist_add_producer(queue);

    dispatch_to_wdp = datagram_dispatch;
    dispatch_to_wsp = session_dispatch;

    timers_init();
    init_timer_freq = timer_freq;

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

wtp_initiator_shutdown()

void wtp_initiator_shutdown

(

void

)

Definition at line 188 of file wtp_init.c.

References counter_destroy(), debug(), gw_assert(), gwlist_destroy(), gwlist_len(), gwlist_remove_producer(), gwthread_join_every(), init_machine_destroy(), init_machine_id_counter, init_machines, initiator_run_status, main_thread(), queue, running, terminating, timers_shutdown(), and wap_event_destroy_item().

Referenced by main().

{
    gw_assert(initiator_run_status == running);
    initiator_run_status = terminating;
    gwlist_remove_producer(queue);
    gwthread_join_every(main_thread);

    debug("wap.wtp", 0, "wtp_initiator_shutdown: %ld init_machines left",
          gwlist_len(init_machines));
    gwlist_destroy(init_machines, init_machine_destroy);
    gwlist_destroy(queue, wap_event_destroy_item);

    counter_destroy(init_machine_id_counter);
    timers_shutdown();
}

Variable Documentation

dispatch_to_wdp

wap_dispatch_func_t* dispatch_to_wdp

static

Definition at line 103 of file wtp_init.c.

Referenced by init_machine_find_or_create(), send_abort(), send_ack(), and wtp_initiator_init().

dispatch_to_wsp

wap_dispatch_func_t* dispatch_to_wsp

static

Definition at line 104 of file wtp_init.c.

Referenced by wtp_initiator_init().

init_machine_id_counter

Counter* init_machine_id_counter = NULL

static

Definition at line 78 of file wtp_init.c.

Referenced by init_machine_create(), wtp_initiator_init(), and wtp_initiator_shutdown().

init_machines

List* init_machines = NULL

static

Definition at line 73 of file wtp_init.c.

Referenced by init_machine_create(), init_machine_destroy(), init_machine_find(), wtp_initiator_init(), and wtp_initiator_shutdown().

init_timer_freq

long init_timer_freq = -1

static

Definition at line 109 of file wtp_init.c.

Referenced by start_initiator_timer_R(), and wtp_initiator_init().

initiator_run_status

enum { ... } initiator_run_status

Referenced by main_thread(), wtp_initiator_init(), and wtp_initiator_shutdown().

queue

List* queue = NULL

static

Definition at line 89 of file wtp_init.c.

Referenced by main_thread(), wtp_initiator_dispatch_event(), wtp_initiator_init(), and wtp_initiator_shutdown().

tidnew

int tidnew = 1

static

Definition at line 84 of file wtp_init.c.

Referenced by init_machine_create(), and init_machine_find_or_create().