@@ -34,6 +34,8 @@

  * 2003-04-04  bug_fix: REQ_IN callback not called for local 

  *             UAC transactions (jiri)

  * 2003-09-12  timer_link->tg will be set only if EXTRA_DEBUG (andrei)

+ * 2003-12-04  global callbacks replaceed with callbacks per transaction;

+ *             completion callback merged into them as LOCAL_COMPETED (bogdan)

  */

 #include "defs.h"

@@ -106,6 +108,7 @@ void free_cell( struct cell* dead_cell )

 	int i;

 	struct sip_msg *rpl;

 	struct totag_elem *tt, *foo;

+	struct tm_callback *cbs, *cbs_tmp;

 	release_cell_lock( dead_cell );

 	shm_lock();

@@ -116,8 +119,12 @@ void free_cell( struct cell* dead_cell )

 	if ( dead_cell->uas.response.buffer )

 		shm_free_unsafe( dead_cell->uas.response.buffer );

-	/* completion callback */

-	if (dead_cell->cbp) shm_free_unsafe(dead_cell->cbp);

+	/* callbacks */

+	for( cbs=dead_cell->tmcb_hl.first ; cbs ; ) {

+		cbs_tmp = cbs;

+		cbs = cbs->next;

+		shm_free_unsafe( cbs_tmp );

+	}

 	/* UA Clients */

 	for ( i =0 ; i<dead_cell->nr_of_outgoings;  i++ )

@@ -183,15 +190,10 @@ struct cell*  build_cell( struct sip_msg* p_msg )

 	new_cell->uas.response.retr_timer.payload = &(new_cell->uas.response);

 	new_cell->uas.response.my_T=new_cell;

-	/* bogdan - debug */

-	/*fprintf(stderr,"before clone VIA |%.*s|\n",via_len(p_msg->via1),

-		via_s(p_msg->via1,p_msg));*/

-

 	/* enter callback, which may potentially want to parse some stuff,

-	   before the request is shmem-ized

-	*/ 

-    if (p_msg) callback_event(TMCB_REQUEST_IN, new_cell, p_msg,

-            p_msg->REQ_METHOD );

+	 * before the request is shmem-ized */

+	if ( p_msg && has_reqin_tmcbs() )

+		run_reqin_callbacks( new_cell, p_msg, p_msg->REQ_METHOD);

 	if (p_msg) {

 		new_cell->uas.request = sip_msg_cloner(p_msg);

@@ -29,6 +29,8 @@

  * 2003-03-16  removed _TOTAG (jiri)

  * 2003-03-06  we keep a list of 200/INV to-tags now (jiri)

  * 2003-03-01  kr set through a function now (jiri)

+ * 2003-12-04  callbacks per transaction added; completion callback

+ *             merge into them as LOCAL_COMPETED (bogdan)

  */

 #include "defs.h"

@@ -174,21 +176,15 @@ typedef struct cell

 	   with proxied transactions to inbound request */

 	str from, callid, cseq_n, to;

 	/* a short-cut for remember whether this transaction needs

-	   INVITE-special handling (e.g., CANCEL, ACK, FR...)

-	*/

+	   INVITE-special handling (e.g., CANCEL, ACK, FR...)  */

 	short is_invite;

 	/* method shortcut -- for local transactions, pointer to

 	   outbound buffer, for proxies transactions pointer to

-	   original message; needed for reply matching

-	*/

+	   original message; needed for reply matching */

 	str method;

-	/* callback and parameter on completion of local transactions */

-	transaction_cb *completion_cb;

-	/* the parameter stores a pointer to shmem -- it will be released

-	   during freeing transaction too

-	*/

-	void *cbp;

+	/* head of callback list */

+	struct tmcb_head_list tmcb_hl;

 	/* how many processes are currently processing this transaction ;

 	   note that only processes working on a request/reply belonging

@@ -110,6 +110,8 @@ void tm_shutdown()

 	free_timer_table();

 	DBG("DEBUG: tm_shutdown : removing semaphores\n");

 	lock_cleanup();

+	DBG("DEBUG: tm_shutdown : destroing tmcb lists\n");

+	destroy_tmcb_lists();

 	free_tm_stats();

 	DBG("DEBUG: tm_shutdown : done\n");

 }

@@ -39,6 +39,8 @@

  *  2003-03-30  we now watch downstream delivery and if it fails, send an

  *              error message upstream (jiri)

  *  2003-04-14  use protocol from uri (jiri)

+ *  2003-12-04  global TM callbacks switched to per transaction callbacks

+ *              (bogdan)

  */

 #include "defs.h"

@@ -83,8 +85,8 @@ char *print_uac_request( struct cell *t, struct sip_msg *i_req,

 	/* ... update uri ... */

 	i_req->new_uri=*uri;

-	/* ... give apps a chance to change things ... */

-	callback_event( TMCB_REQUEST_FWDED, t, i_req, -i_req->REQ_METHOD);

+	/* run the specific callbacks for this transaction */

+	run_trans_callbacks( TMCB_REQUEST_FWDED , t, i_req, 0, -i_req->REQ_METHOD);

 	/* ... and build it now */

 	buf=build_req_buf_from_sip_req( i_req, len, send_sock, proto );

@@ -28,6 +28,9 @@

  * History:

  * --------

  *  2003-03-19  replaced all the mallocs/frees w/ pkg_malloc/pkg_free (andrei)

+ *  2003-12-04  global callbacks moved into transaction callbacks;

+ *              multiple events per callback added; single list per

+ *              transaction for all its callbacks (bogdan)

  */

 #include "defs.h"

@@ -38,46 +41,150 @@

 #include "../../error.h"

 #include "../../mem/mem.h"

 #include "t_hooks.h"

+#include "t_lookup.h"

+#include "t_funcs.h"

-/* strange things happen if callback_array is static on openbsd */

-struct tm_callback_s* callback_array[ TMCB_END ] = { 0, 0 } ;

-static int callback_id=0;

-/* register a callback function 'f' of type 'cbt'; will be called

-   back whenever the event 'cbt' occurs in transaction module

-*/

-int register_tmcb( tmcb_type cbt, transaction_cb f, void *param )

+struct tmcb_head_list* req_in_tmcb_hl = 0;

+

+

+

+int init_tmcb_lists()

+{

+	req_in_tmcb_hl = (struct tmcb_head_list*)shm_malloc

+		( sizeof(struct tmcb_head_list) );

+	if (req_in_tmcb_hl==0) {

+		LOG(L_CRIT,"ERROR:tm:init_tmcb_lists: nomore shared mem\n");

+		return -1;

+	}

+	req_in_tmcb_hl->first = 0;

+	req_in_tmcb_hl->reg_types = 0;

+	return 1;

+}

+

+

+void destroy_tmcb_lists()

 {

-	struct tm_callback_s *cbs;

+	struct tm_callback *cbp, *cbp_tmp;

-	if (cbt<0 || cbt>=TMCB_END ) {

-		LOG(L_ERR, "ERROR: register_tmcb: invalid callback type: %d\n",

-			cbt );

-		return E_BUG;

+	if (!req_in_tmcb_hl)

+		return;

+

+	for( cbp=req_in_tmcb_hl->first; cbp ; ) {

+		cbp_tmp = cbp;

+		cbp = cbp->next;

+		if (cbp->param) shm_free( cbp->param );

+		shm_free( cbp_tmp );

 	}

-	if (!(cbs=pkg_malloc( sizeof( struct tm_callback_s)))) {

-		LOG(L_ERR, "ERROR: register_tmcb: out of mem\n");

+	shm_free(req_in_tmcb_hl);

+}

+

+

+inline int insert_tmcb(struct tmcb_head_list *cb_list, int types,

+									transaction_cb f, void *param )

+{

+	struct tm_callback *cbp;

+

+	/* build a new callback structure */

+	if (!(cbp=shm_malloc( sizeof( struct tm_callback)))) {

+		LOG(L_ERR, "ERROR:tm:register_tmcb: out of shm. mem\n");

 		return E_OUT_OF_MEM;

 	}

-	callback_id++;

-	cbs->id=callback_id;

-	cbs->callback=f;

-	cbs->next=callback_array[ cbt ];

-	cbs->param=param;

-	callback_array[ cbt ]=cbs;

+	/* link it into the proper place... */

+	cbp->next = cb_list->first;

+	cb_list->first = cbp;

+	cb_list->reg_types |= types;

+	/* ... and fill it up */

+	cbp->callback = f;

+	cbp->param = param;

+	cbp->types = types;

+	if (cbp->next)

+		cbp->id = cbp->next->id+1;

+	else

+		cbp->id = 0;

+

+	return 1;

+}

+

+

+

+/* register a callback function 'f' for 'types' mask of events;

+ * will be called back whenever one of the events occurs in transaction module

+ * (global or per transacation, depinding of event type)

+*/

+int register_tmcb( struct sip_msg* p_msg, int types, transaction_cb f,

+																void *param )

+{

+	struct cell* t;

+	struct tmcb_head_list *cb_list;

+

+	/* are the callback types valid?... */

+	if ( types<0 || types>=TMCB_MAX ) {

+		LOG(L_CRIT, "BUG:tm:register_tmcb: invalid callback types: mask=%d\n",

+			types);

+		return E_BUG;

+	}

+	if (types&TMCB_REQUEST_IN) {

+		if (types!=TMCB_REQUEST_IN) {

+			LOG(L_CRIT, "BUG:tm:register_tmcb: callback type TMCB_REQUEST_IN "

+				"can't be register along with types\n");

+			return E_BUG;

+		}

+		cb_list = req_in_tmcb_hl;

+	} else {

+		/* look for the transaction */

+		if ( t_check(p_msg,0)!=1 ){

+			LOG(L_CRIT,"BUG:tm:register_tmcb: no transaction found\n");

+			return E_BUG;

+		}

+		if ( (t=get_t())==0 ) {

+			LOG(L_CRIT,"BUG:tm:register_tmcb: transaction found is NULL\n");

+			return E_BUG;

+		}

+		cb_list = &(t->tmcb_hl);

+	}

+

+	return insert_tmcb( cb_list, types, f, param );

+}

-	return callback_id;

+

+void run_trans_callbacks( int type , struct cell *trans,

+						struct sip_msg *req, struct sip_msg *rpl, int code )

+{

+	static struct tmcb_params params = {0,0,0,0};

+	struct tm_callback    *cbp;

+

+	params.req = req;

+	params.rpl = rpl;

+	params.code = code;

+

+	for (cbp=trans->tmcb_hl.first; cbp; cbp=cbp->next)  {

+		if ( (cbp->types)&type ) {

+			DBG("DBG: trans=%p, callback type %d, id %d entered\n",

+				trans, type, cbp->id );

+			params.param = cbp->param;

+			cbp->callback( trans, type, &params );

+		}

+	}

 }

-void callback_event( tmcb_type cbt , struct cell *trans,

-	struct sip_msg *msg, int code )

+

+

+void run_reqin_callbacks( struct cell *trans, struct sip_msg *req, int code )

 {

-	struct tm_callback_s *cbs;

+	static struct tmcb_params params = {0,0,0,0};

+	struct tm_callback    *cbp;

-	for (cbs=callback_array[ cbt ]; cbs; cbs=cbs->next)  {

-		DBG("DBG: callback type %d, id %d entered\n", cbt, cbs->id );

-		cbs->callback( trans, msg, code, cbs->param );

+	params.req = req;

+	params.code = code;

+

+	for (cbp=req_in_tmcb_hl->first; cbp; cbp=cbp->next)  {

+		DBG("DBG: trans=%p, callback type %d, id %d entered\n",

+			trans, cbp->types, cbp->id );

+		params.param = cbp->param;

+		cbp->callback( trans, cbp->types, &params );

 	}

 }

+

@@ -26,8 +26,11 @@

  *

  * History:

  * --------

- * 2003-03-16 backwards-compatibility callback names introduced (jiri)

- * 2003-03-06 old callbacks renamed, new one introduced (jiri)

+ * 2003-03-16 : backwards-compatibility callback names introduced (jiri)

+ * 2003-03-06 : old callbacks renamed, new one introduced (jiri)

+ * 2003-12-04 : global callbacks moved into transaction callbacks;

+ *              multiple events per callback added; single list per

+ *              transaction for all its callbacks (bogdan)

  */

@@ -36,25 +39,20 @@

 #include "defs.h"

-

 struct sip_msg;

 struct cell;

-/* backwards compatibility hooks */

-#define TMCB_REPLY TMCB_RESPONSE_OUT

-#define TMCB_E2EACK TMCB_E2EACK_IN

-#define TMCB_REPLY_IN TMCB_RESPONSE_IN

-#define TMCB_REQUEST_OUT TMCB_REQUEST_FWDED

-#define TMCB_ON_NEGATIVE TMCB_ON_FAILURE

-

-typedef enum { 

-		/* input events */

-		TMCB_RESPONSE_IN=1, TMCB_REQUEST_IN, TMCB_E2EACK_IN, 

-		/* routing decisions in progress */

-		TMCB_REQUEST_FWDED, TMCB_RESPONSE_FWDED, TMCB_ON_FAILURE,

-		/* completion events */

-		TMCB_RESPONSE_OUT, TMCB_LOCAL_COMPLETED, 

-		TMCB_END } tmcb_type;

+

+#define TMCB_REQUEST_IN       (1<<0)

+#define TMCB_RESPONSE_IN      (1<<1)

+#define TMCB_E2EACK_IN        (1<<2)

+#define TMCB_REQUEST_FWDED    (1<<3)

+#define TMCB_RESPONSE_FWDED   (1<<4)

+#define TMCB_ON_FAILURE_RO    (1<<5)

+#define TMCB_ON_FAILURE       (1<<6)

+#define TMCB_RESPONSE_OUT     (1<<7)

+#define TMCB_LOCAL_COMPLETED  (1<<8)

+#define TMCB_MAX              ((1<<9)-1)

 /* 

  *  Caution: most of the callbacks work with shmem-ized messages

@@ -65,6 +63,13 @@ typedef enum {

  *  is a non-dereferencable pointer indicating that no message

  *  was received and a timer hit instead.

  *

+ *  All callbacks excepting the TMCB_REQUEST_IN are associates to a

+ *  transaction. It means they will be run only when the event will hint

+ *  the transaction the callbacks were register for.

+ *  TMCB_REQUEST_IN is a global callback - it means it will be run for

+ *  all transactions.

+ *

+ *

  *  Callback description:

  *  ---------------------

  *

@@ -98,6 +103,11 @@ typedef enum {

  *    drops state silently, doesn't use callbacks and expects the

  *    transaction to complete statelessly.

  *

+ *  TMCB_ON_FAILURE_RO -- called on receipt of a reply or timer;

+ *  it means all branches completed with a failure; the callback 

+ *  function MUST not change anything in the transaction (READONLY)

+ *  that's a chance for doing ACC or stuff like this

+ *

  *  TMCB_ON_FAILURE -- called on receipt of a reply or timer;

  *  it means all branches completed with a failure; that's 

  *  a chance for example to add new transaction branches

@@ -139,36 +149,73 @@ typedef enum {

  *  TMCB_LOCAL COMPLETED -- final reply for localy initiated

  *  transaction arrived. Message may be FAKED_REPLY.

  *

- *  TMCB_END	- just a bumper

-

-	see the 'acc' module for an example of callback usage

 	note that callbacks MUST be installed before forking

-    (callback lists do not live in shmem and have no access

+	(callback lists do not live in shmem and have no access

 	protection), i.e., at best from mod_init functions.

-	also, note: the callback param is currently not used;

-	if whoever wishes to use a callback parameter, use

-	trans->cbp

+	the callback's param MUST be in shared memory and will

+	NOT be freed by TM; you must do it yourself from the

+	callback function id necessary.

 */

-typedef void (transaction_cb) ( struct cell* t, struct sip_msg* msg, 

-	int code, void *param );

-struct tm_callback_s {

-	int id;

-	transaction_cb* callback;

-	struct tm_callback_s* next;

+/* pack structure with all params passed toa callback function */

+struct tmcb_params {

+	struct sip_msg* req;

+	struct sip_msg* rpl;

+	int code;

 	void *param;

 };

+/* callback function prototype */

+typedef void (transaction_cb) (struct cell* t, int type, struct tmcb_params*);

+/* register callback function prototype */

+typedef int (*register_tmcb_f)(struct sip_msg* p_msg, int cb_types,

+		transaction_cb f, void *param);

+

+

+struct tm_callback {

+	int id;                      /* id of this callback - useless */

+	int types;                   /* types of events that trigger the callback*/

+	transaction_cb* callback;    /* callback function */

+	void *param;                 /* param to be passed to callback function */

+	struct tm_callback* next;

+};

+

+struct tmcb_head_list {

+	struct tm_callback *first;

+	int reg_types;

+};

+

+

+extern struct tmcb_head_list*  req_in_tmcb_hl;

+

+

+#define has_tran_tmcbs(_T_, _types_) \

+	( ((_T_)->tmcb_hl.reg_types)|(_types_) )

+#define has_reqin_tmcbs() \

+	( req_in_tmcb_hl->first!=0 )

+

+

+int init_tmcb_lists();

+

+void destroy_tmcb_lists();

+

+

+/* register a callback for several types of events */

+int register_tmcb( struct sip_msg* p_msg, int types, transaction_cb f,

+																void *param );

-extern struct tm_callback_s* callback_array[ TMCB_END ];

+/* inserts a callback into the a callback list */

+int insert_tmcb(struct tmcb_head_list *cb_list, int types,

+									transaction_cb f, void *param );

-typedef int (*register_tmcb_f)(tmcb_type cbt, transaction_cb f, void *param);

+/* run all transaction callbacks for an event type */

+void run_trans_callbacks( int type , struct cell *trans,

+						struct sip_msg *req, struct sip_msg *rpl, int code );

-int register_tmcb( tmcb_type cbt, transaction_cb f, void *param );

-void callback_event( tmcb_type cbt, struct cell *trans,

-	struct sip_msg *msg, int code );

+/* run all REQUEST_IN callbacks */

+void run_reqin_callbacks( struct cell *trans, struct sip_msg *req, int code );

 #endif

@@ -72,6 +72,8 @@

  * 2003-04-30  t_newtran clean up (jiri)

  * 2003-08-21  request lookups fixed to skip UAC transactions, 

  *             thanks Ed (jiri)

+ * 2003-12-04  global TM callbacks switched to per transaction callbacks

+ *             (bogdan)

  */

@@ -784,17 +786,19 @@ int t_reply_matching( struct sip_msg *p_msg , int *p_branch )

 		 * retransmissions of multiple 200/INV or ACK/200s

 		 */

 		if (p_cell->is_invite && p_msg->REPLY_STATUS>=200 

-				&& p_msg->REPLY_STATUS<300 

-				&& ( (!p_cell->local && 

-					(callback_array[TMCB_RESPONSE_OUT]||

-						callback_array[TMCB_E2EACK_IN]))

-					|| (p_cell->local && callback_array[TMCB_LOCAL_COMPLETED]) )) {

+		&& p_msg->REPLY_STATUS<300 

+		&& ( (!p_cell->local && 

+				has_tran_tmcbs(p_cell,TMCB_RESPONSE_OUT|TMCB_E2EACK_IN) )

+			|| (p_cell->local && has_tran_tmcbs(p_cell,TMCB_LOCAL_COMPLETED))

+		)) {

 			if (parse_headers(p_msg, HDR_TO, 0)==-1) {

 				LOG(L_ERR, "ERROR: t_reply_matching: to parsing failed\n");

 			}

 		}

-		if (!p_cell->local) 

-			callback_event(TMCB_RESPONSE_IN, T, p_msg, p_msg->REPLY_STATUS);

+		if (!p_cell->local) {

+			run_trans_callbacks( TMCB_RESPONSE_IN, T, T->uas.request, p_msg,

+				p_msg->REPLY_STATUS);

+		}

 		return 1;

 	} /* for cycle */

@@ -1051,21 +1055,20 @@ int t_newtran( struct sip_msg* p_msg )

 	if (lret==-2) { /* was it an e2e ACK ? if so, trigger a callback */

 		/* no callbacks? complete quickly */

-		if (!callback_array[TMCB_E2EACK_IN]) {

+		if ( !has_tran_tmcbs(t_ack,TMCB_E2EACK_IN) ) {

 			UNLOCK_HASH(p_msg->hash_index);

 			return 1;

 		} 

 		REF_UNSAFE(t_ack);

 		UNLOCK_HASH(p_msg->hash_index);

 		/* we don't call from within REPLY_LOCK -- that introduces

-	   	   a race condition; however, it is so unlikely and the

-	   	   impact is so small (callback called multiple times of

-           multiple ACK/200s received in parallel), that we do not

-	   	    better waste time in locks

-		 */

+		 * a race condition; however, it is so unlikely and the

+		 * impact is so small (callback called multiple times of

+		 * multiple ACK/200s received in parallel), that we do not

+		 * better waste time in locks  */

 		if (unmatched_totag(t_ack, p_msg)) {

-			callback_event( TMCB_E2EACK_IN, t_ack, p_msg, 

-				p_msg->REQ_METHOD );

+			run_trans_callbacks( TMCB_E2EACK_IN , t_ack, p_msg, 0,

+				-p_msg->REQ_METHOD );

 		}

 		UNREF(t_ack);

 		return 1;

@@ -52,6 +52,8 @@

  *  2003-11-05  flag context updated from failure/reply handlers back

  *              to transaction context (jiri)

  *  2003-11-11: build_lump_rpl() removed, add_lump_rpl() has flags (bogdan)

+ *  2003-12-04  global TM callbacks switched to per transaction callbacks

+ *              (bogdan)

  */

@@ -102,6 +104,7 @@ static int goto_on_negative=0;

 static int goto_on_reply=0;

+

 /* we store the reply_route # in private memory which is

    then processed during t_relay; we cannot set this value

    before t_relay creates transaction context or after

@@ -309,11 +312,13 @@ static int _reply_light( struct cell *trans, char* buf, unsigned int len,

 	if (code>=200) {

 		if (trans->local) {

 			DBG("DEBUG: local transaction completed from _reply\n");

-			callback_event( TMCB_LOCAL_COMPLETED, trans, FAKED_REPLY, code );

-			if (trans->completion_cb) 

-				trans->completion_cb( trans, FAKED_REPLY, code, trans->cbp);

+			if ( has_tran_tmcbs(trans, TMCB_LOCAL_COMPLETED) )

+				run_trans_callbacks( TMCB_LOCAL_COMPLETED, trans,

+					0, FAKED_REPLY, code);

 		} else {

-			callback_event( TMCB_RESPONSE_OUT, trans, FAKED_REPLY, code );

+			if ( has_tran_tmcbs(trans, TMCB_RESPONSE_OUT) )

+				run_trans_callbacks( TMCB_RESPONSE_OUT, trans,

+					trans->uas.request, FAKED_REPLY, code);

 		}

 		cleanup_uac_timers( trans );

@@ -380,45 +385,15 @@ static int _reply( struct cell *trans, struct sip_msg* p_msg,

 }

-/* create a temporary faked message environment in which a conserved

- * t->uas.request in shmem is partially duplicated to pkgmem

- * to allow pkg-based actions to use it; 

- *

- * if restore parameter is set, the environment is restored to the

- * original setting and return value is unsignificant (always 0); 

- * otherwise  a faked environment if created; if that fails,

- * false is returned

- */

-static int faked_env(struct sip_msg *fake, 

-				struct cell *_t,

-				struct sip_msg *shmem_msg,

-				int _restore )

+/*if msg is set -> it will fake the env. vars conforming with the msg; if NULL

+ * the env. will be restore to original */

+static inline void faked_env( struct cell *t,struct sip_msg *msg)

 {

 	static enum route_mode backup_mode;

 	static struct cell *backup_t;

 	static unsigned int backup_msgid;

-	if (_restore) goto restore;

-

-	/* 

-     on_negative_reply faked msg now copied from shmem msg (as opposed

-     to zero-ing) -- more "read-only" actions (exec in particular) will 

-     work from reply_route as they will see msg->from, etc.; caution, 

-     rw actions may append some pkg stuff to msg, which will possibly be 

-     never released (shmem is released in a single block)

-    */

-	memcpy( fake, shmem_msg, sizeof(struct sip_msg));

-

-	/* if we set msg_id to something different from current's message

-       id, the first t_fork will properly clean new branch URIs

-	*/

-	fake->id=shmem_msg->id-1;

-	/* set items, which will be duped to pkg_mem, to zero, so that

-	 * "restore" called on error does not free the original items */

-	fake->add_rm=0;

-	fake->body_lumps=0;

-	fake->new_uri.s=0; fake->new_uri.len=0; 

-

+	if (msg) {

 	/* remember we are back in request processing, but process

 	 * a shmem-ed replica of the request; advertise it in rmode;

 	 * for example t_reply needs to know that

@@ -435,90 +410,109 @@ static int faked_env(struct sip_msg *fake,

 	backup_t=get_t();

 	backup_msgid=global_msg_id;

 	/* fake transaction and message id */

-	global_msg_id=fake->id;

-	set_t(_t);

+		global_msg_id=msg->id;

+		set_t(t);

+	} else {

+		/* restore original environment */

+		set_t(backup_t);

+		global_msg_id=backup_msgid;

+		rmode=backup_mode;

+	}

+}

+

+

+

+/* return 1 if a failure_route processes */

+static inline int run_failure_handlers(struct cell *t, struct sip_msg *rpl,

+																	int code)

+{

+	static struct sip_msg fake_req;

+	struct sip_msg *shmem_msg = t->uas.request;

+

+	/* failure_route for a local UAC? */

+	if (!shmem_msg) {

+		LOG(L_WARN, "Warning: run_failure_handlers: no UAC support\n");

+		return 0;

+	}

+

+	/* don't start faking anything if we don't have to */

+	if ( !has_tran_tmcbs( t, TMCB_ON_FAILURE) && !t->on_negative ) {

+		return 1;

+	}

-	/* environment is set up now, try to fake the message */

+	/* on_negative_reply faked msg now copied from shmem msg (as opposed

+	 * to zero-ing) -- more "read-only" actions (exec in particular) will

+	 * work from reply_route as they will see msg->from, etc.; caution,

+	 * rw actions may append some pkg stuff to msg, which will possibly be

+	 * never released (shmem is released in a single block) */

+	memcpy( &fake_req, shmem_msg, sizeof(struct sip_msg));

+

+	/* if we set msg_id to something different from current's message

+	 * id, the first t_fork will properly clean new branch URIs */

+	fake_req.id=shmem_msg->id-1;

 	/* new_uri can change -- make a private copy */

 	if (shmem_msg->new_uri.s!=0 && shmem_msg->new_uri.len!=0) {

-		fake->new_uri.s=pkg_malloc(shmem_msg->new_uri.len+1);

-		if (!fake->new_uri.s) {

-			LOG(L_ERR, "ERROR: faked_env: no uri/pkg mem\n");

-			goto restore;

+		fake_req.new_uri.s=pkg_malloc(shmem_msg->new_uri.len+1);

+		if (!fake_req.new_uri.s) {

+			LOG(L_ERR, "ERROR: run_failure_handlers: no uri/pkg mem\n");

+			return 0;

 		}

-		fake->new_uri.len=shmem_msg->new_uri.len;

-		memcpy( fake->new_uri.s, shmem_msg->new_uri.s, 

-			fake->new_uri.len);

-		fake->new_uri.s[fake->new_uri.len]=0;

-	} 

+		fake_req.new_uri.len=shmem_msg->new_uri.len;

+		memcpy( fake_req.new_uri.s, shmem_msg->new_uri.s, 

+			fake_req.new_uri.len);

+		fake_req.new_uri.s[fake_req.new_uri.len]=0;

+	}

 	/* create a duplicated lump list to which actions can add

-	 * new pkg items 

-	 */

+	 * new pkg items  */

 	if (shmem_msg->add_rm) {

-		fake->add_rm=dup_lump_list(shmem_msg->add_rm);

-		if (!fake->add_rm) { /* non_emty->empty ... failure */

-			LOG(L_ERR, "ERROR: on_negative_reply: lump dup failed\n");

-			goto restore;

+		fake_req.add_rm=dup_lump_list(shmem_msg->add_rm);

+		if (!fake_req.add_rm) { /* non_emty->empty ... failure */

+			LOG(L_ERR, "ERROR: run_failure_handlers: lump dup failed\n");

+			if (fake_req.new_uri.s) pkg_free(fake_req.new_uri.s);

+			return 0;

 		}

 	}

+	/* same for the body lumps */

 	if (shmem_msg->body_lumps) {

-		fake->body_lumps=dup_lump_list(shmem_msg->body_lumps);

-		if (!fake->body_lumps) { /* non_empty->empty ... failure */

-			LOG(L_ERR, "ERROR: on_negative_reply: lump dup failed\n");

-			goto restore;

+		fake_req.body_lumps=dup_lump_list(shmem_msg->body_lumps);

+		if (!fake_req.body_lumps) { /* non_empty->empty ... failure */

+			LOG(L_ERR, "ERROR: on_negative_handlers: lump dup failed\n");

+			free_duped_lump_list(fake_req.add_rm);

+			if (fake_req.new_uri.s) pkg_free(fake_req.new_uri.s);

+			return 0;

 		}

 	}

-	

-	/* success */

-	return 1;

-

-restore:

-	/* restore original environment and destroy faked message */

-	free_duped_lump_list(fake->add_rm);

-	free_duped_lump_list(fake->body_lumps);

-	if (fake->new_uri.s) pkg_free(fake->new_uri.s);

-	set_t(backup_t);

-	global_msg_id=backup_msgid;

-	rmode=backup_mode;

-	/* if failure handler changed flag, update transaction context */

-	shmem_msg->flags=fake->flags;

-	return 0;

-}

-/* return 1 if a failure_route processes */

-int failure_route(struct cell *t)

-{

-	struct sip_msg faked_msg;

-	struct sip_msg *orig_request;

-

-	/* don't do anything if we don't have to */

-	if (!t->on_negative) return 0;

-	orig_request=t->uas.request;

-	/* failure_route for a local UAC? */

-	if (!orig_request) {

-		LOG(L_WARN, "Warning: failure_route: no UAC support\n");

-		return 0;

-	}

+	/* fake also the env. conforming to the fake msg */

+	faked_env( t, &fake_req);

+	/* DONE with faking ;-) -> run the failure handlers */

-	/* if fake message creation failes, return error too */

-	if (!faked_env(&faked_msg, t, orig_request, 0 /* create fake */ )) {

-		LOG(L_ERR, "ERROR: on_negative_reply: faked_env failed\n");

-		return 0;

+	if ( has_tran_tmcbs( t, TMCB_ON_FAILURE) ) {

+		run_trans_callbacks( TMCB_ON_FAILURE, t, &fake_req, rpl, code);

 	}

-

+	if (t->on_negative) {

 	/* avoid recursion -- if failure_route forwards, and does not 

 	 * set next failure route, failure_route will not be rentered

 	 * on failure */

 	t_on_negative(0);

 	/* run a reply_route action if some was marked */

-	if (run_actions(failure_rlist[t->on_negative], &faked_msg)<0)

-		LOG(L_ERR, "ERROR: on_negative_reply: "

-			"Error in do_action\n");

-	/* restore original environment */

-	faked_env(&faked_msg, 0, orig_request, 1 );

+		if (run_actions(failure_rlist[t->on_negative], &fake_req)<0)

+			LOG(L_ERR, "ERROR: run_failure_handlers: Error in do_action\n");

+	}

+

+	/* restore original environment and free the fake msg */

+	faked_env( t, 0);

+	free_duped_lump_list(fake_req.add_rm);

+	free_duped_lump_list(fake_req.body_lumps);

+	fake_req.add_rm = fake_req.body_lumps = 0;

+	if (fake_req.new_uri.s) {

+		pkg_free(fake_req.new_uri.s);

+		fake_req.new_uri.s = 0;

+	}

+

 	return 1;

 }

@@ -572,7 +566,6 @@ static enum rps t_should_relay_response( struct cell *Trans , int new_code,

 	int branch , int *should_store, int *should_relay,

 	branch_bm_t *cancel_bitmap, struct sip_msg *reply )

 {

-	

 	int branch_cnt;

 	int picked_branch;

 	int picked_code;

@@ -630,15 +623,16 @@ static enum rps t_should_relay_response( struct cell *Trans , int new_code,

 		/* no more pending branches -- try if that changes after

 		   a callback; save banch count to be able to determine

-		   later if new branches were initiated

-		*/

+		   later if new branches were initiated */

 		branch_cnt=Trans->nr_of_outgoings;

-		callback_event( TMCB_ON_FAILURE, Trans, 

-			picked_branch==branch?reply:Trans->uac[picked_branch].reply, 

-			picked_code);

-		/* here, we create a faked environment, from which we

-		 * return to request processing, if marked to do so */

-		failure_route(Trans);

+

+		/* run ON_FAILURE handlers ( route and callbacks) */

+		if ( has_tran_tmcbs( Trans, TMCB_ON_FAILURE_RO|TMCB_ON_FAILURE)

+		|| Trans->on_negative ) {

+			run_failure_handlers( Trans,

+				picked_branch==branch?reply:Trans->uac[picked_branch].reply, 

+				picked_code);

+		}

 		/* look if the callback perhaps replied transaction; it also

 		   covers the case in which a transaction is replied localy

@@ -849,7 +843,7 @@ enum rps relay_reply( struct cell *t, struct sip_msg *p_msg, int branch,

 	/* remember, what was sent upstream to know whether we are

-	   forwarding a first final reply or not */

+	 * forwarding a first final reply or not */

 	/* *** store and relay message as needed *** */

 	reply_status = t_should_relay_response(t, msg_status, branch, 

@@ -866,19 +860,19 @@ enum rps relay_reply( struct cell *t, struct sip_msg *p_msg, int branch,

 	uas_rb = & t->uas.response;

 	if (relay >= 0 ) {

-

 		/* initialize sockets for outbound reply */

 		uas_rb->activ_type=msg_status;

 		/* only messages known to be relayed immediately will be

-		   be called on; we do not evoke this callback on messages

-		   stored in shmem -- they are fixed and one cannot change them

-		   anyway 

-        */

-		if (msg_status<300 && branch==relay) {

-			callback_event( TMCB_RESPONSE_FWDED, t, p_msg, msg_status );

+		 * be called on; we do not evoke this callback on messages

+		 * stored in shmem -- they are fixed and one cannot change them

+		 * anyway */

+		if (msg_status<300 && branch==relay

+		&& has_tran_tmcbs(t,TMCB_RESPONSE_FWDED) ) {

+			run_trans_callbacks( TMCB_RESPONSE_FWDED, t, t->uas.request,

+				p_msg, msg_status );

 		}

 		/* try bulding the outbound reply from either the current

-	       or a stored message */

+		 * or a stored message */

 		relayed_msg = branch==relay ? p_msg :  t->uac[relay].reply;

 		if (relayed_msg==FAKED_REPLY) {

 			tm_stats->replied_localy++;

@@ -942,9 +936,8 @@ enum rps relay_reply( struct cell *t, struct sip_msg *p_msg, int branch,

 		t->relaied_reply_branch = relay;

 		if (t->is_invite && relayed_msg!=FAKED_REPLY

-				&& relayed_code>=200 && relayed_code < 300

-				&& (callback_array[TMCB_RESPONSE_OUT] ||

-						callback_array[TMCB_E2EACK_IN]))  {

+		&& relayed_code>=200 && relayed_code < 300

+		&& has_tran_tmcbs( t, TMCB_RESPONSE_OUT|TMCB_E2EACK_IN) ) {

 			totag_retr=update_totag_set(t, relayed_msg);

 		}

 	}; /* if relay ... */

@@ -956,8 +949,10 @@ enum rps relay_reply( struct cell *t, struct sip_msg *p_msg, int branch,