- updated to latest avp api
[sip-router] / modules / tm / t_lookup.c
1 /*
2  * $Id$
3  *
4  * This C-file takes care of matching requests and replies with
5  * existing transactions. Note that we do not do SIP-compliant
6  * request matching as asked by SIP spec. We do bitwise matching of 
7  * all header fields in requests which form a transaction key. 
8  * It is much faster and it works pretty well -- we haven't 
9  * had any interop issue neither in lab nor in bake-offs. The reason
10  * is that retransmissions do look same as original requests
11  * (it would be really silly if they would be mangled). The only
12  * exception is we parse To as To in ACK is compared to To in
13  * reply and both  of them are constructed by different software.
14  * 
15  * As for reply matching, we match based on branch value -- that is
16  * faster too. There are two versions .. with SYNONYMs #define
17  * enabled, the branch includes ordinal number of a transaction
18  * in a synonym list in hash table and is somewhat faster but
19  * not reboot-resilient. SYNONYMs turned off are little slower
20  * but work across reboots as well.
21  *
22  * The branch parameter is formed as follows:
23  * SYNONYMS  on: hash.synonym.branch
24  * SYNONYMS off: hash.md5.branch
25  *
26  * -jiri
27  *
28  *
29  * Copyright (C) 2001-2003 FhG Fokus
30  *
31  * This file is part of ser, a free SIP server.
32  *
33  * ser is free software; you can redistribute it and/or modify
34  * it under the terms of the GNU General Public License as published by
35  * the Free Software Foundation; either version 2 of the License, or
36  * (at your option) any later version
37  *
38  * For a license to use the ser software under conditions
39  * other than those described here, or to purchase support for this
40  * software, please contact iptel.org by e-mail at the following addresses:
41  *    info@iptel.org
42  *
43  * ser is distributed in the hope that it will be useful,
44  * but WITHOUT ANY WARRANTY; without even the implied warranty of
45  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
46  * GNU General Public License for more details.
47  *
48  * You should have received a copy of the GNU General Public License 
49  * along with this program; if not, write to the Free Software 
50  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
51  *
52  * History:
53  * ----------
54  * 2003-01-23  options for disabling r-uri matching introduced (jiri)
55  *              nameser_compat.h (andrei)
56  * 2003-01-27  next baby-step to removing ZT - PRESERVE_ZT (jiri)
57  * 2003-01-28  scratchpad removed (jiri)
58  * 2003-02-13  init_rb() is proto indep. & it uses struct dest_info (andrei)
59  * 2003-02-24  s/T_NULL/T_NULL_CELL/ to avoid redefinition conflict w/
60  * 2003-02-27  3261 ACK/200 consumption bug removed (jiri)
61  * 2003-02-28 scratchpad compatibility abandoned (jiri)
62  * 2003-03-01  kr set through a function now (jiri)
63  * 2003-03-06  dialog matching introduced for ACKs -- that's important for 
64  *             INVITE UAS (like INVITE) and 200/ACK proxy matching (jiri)
65  * 2003-03-29  optimization: e2e ACK matching only if callback installed
66  *             (jiri)
67  * 2003-03-30  set_kr for requests only (jiri)
68  * 2003-04-04  bug_fix: RESPONSE_IN callback not called for local
69  *             UAC transactions (jiri)
70  * 2003-04-07  new transactions inherit on_negative and on_relpy from script
71  *             variables on instantiation (jiri)
72  * 2003-04-30  t_newtran clean up (jiri)
73  * 2003-08-21  request lookups fixed to skip UAC transactions, 
74  *             thanks Ed (jiri)
75  * 2003-12-04  global TM callbacks switched to per transaction callbacks
76  *             (bogdan)
77  * 2004-02-11  FIFO/CANCEL + alignments (hash=f(callid,cseq)) (uli+jiri)
78  * 2004-02-13: t->is_invite and t->local replaced with flags (bogdan)
79  * 2004-10-10: use of mhomed disabled for replies (jiri)
80  * 2005-02-01: use the incoming request interface for sending the replies
81  *             - changes in init_rb() (bogdan)
82  */
83
84 #include "defs.h"
85
86
87 #include "../../comp_defs.h"
88 #include "../../dprint.h"
89 #include "../../config.h"
90 #include "../../parser/parser_f.h"
91 #include "../../parser/parse_from.h"
92 #include "../../ut.h"
93 #include "../../timer.h"
94 #include "../../hash_func.h"
95 #include "../../globals.h"
96 #include "../../forward.h"
97 #include "t_funcs.h"
98 #include "config.h"
99 #include "sip_msg.h"
100 #include "t_hooks.h"
101 #include "t_fwd.h"
102 #include "t_lookup.h"
103 #include "dlg.h" /* for t_lookup_callid */
104 #include "t_msgbuilder.h" /* for t_lookup_callid */
105
106 #define EQ_VIA_LEN(_via)\
107         ( (p_msg->via1->bsize-(p_msg->_via->name.s-(p_msg->_via->hdr.s+p_msg->_via->hdr.len)))==\
108                 (t_msg->via1->bsize-(t_msg->_via->name.s-(t_msg->_via->hdr.s+t_msg->_via->hdr.len))) )
109
110
111
112 #define EQ_LEN(_hf) (t_msg->_hf->body.len==p_msg->_hf->body.len)
113 #define EQ_REQ_URI_LEN\
114         (p_msg->first_line.u.request.uri.len==t_msg->first_line.u.request.uri.len)
115
116 #define EQ_STR(_hf) (memcmp(t_msg->_hf->body.s,\
117         p_msg->_hf->body.s, \
118         p_msg->_hf->body.len)==0)
119 #define EQ_REQ_URI_STR\
120         ( memcmp( t_msg->first_line.u.request.uri.s,\
121         p_msg->first_line.u.request.uri.s,\
122         p_msg->first_line.u.request.uri.len)==0)
123 #define EQ_VIA_STR(_via)\
124         ( memcmp( t_msg->_via->name.s,\
125          p_msg->_via->name.s,\
126          (t_msg->via1->bsize-(t_msg->_via->name.s-(t_msg->_via->hdr.s+t_msg->_via->hdr.len)))\
127         )==0 )
128
129
130
131 #define HF_LEN(_hf) ((_hf)->len)
132
133 /* should be request-uri matching used as a part of pre-3261 
134  * transaction matching, as the standard wants us to do so
135  * (and is reasonable to do so, to be able to distinguish
136  * spirals)? turn only off for better interaction with 
137  * devices that are broken and send different r-uri in
138  * CANCEL/ACK than in original INVITE
139  */
140 int ruri_matching=1;
141 int via1_matching=1;
142
143 /* presumably matching transaction for an e2e ACK */
144 static struct cell *t_ack;
145
146 /* this is a global variable which keeps pointer to
147    transaction currently processed by a process; it it
148    set by t_lookup_request or t_reply_matching; don't
149    dare to change it anywhere else as it would
150    break ref_counting
151 */
152
153 static struct cell *T;
154
155 /* number of currently processed message; good to know
156    to be able to doublecheck whether we are still working
157    on a current transaction or a new message arrived;
158    don't even think of changing it
159 */
160 unsigned int     global_msg_id;
161
162 struct cell *get_t() { return T; }
163 void set_t(struct cell *t) { T=t; }
164 void init_t() {global_msg_id=0; set_t(T_UNDEFINED);}
165
166 static inline int parse_dlg( struct sip_msg *msg )
167 {
168         if (parse_headers(msg, HDR_FROM_F | HDR_CSEQ_F | HDR_TO_F, 0)==-1) {
169                 LOG(L_ERR, "ERROR: parse_dlg: From or Cseq or To invalid\n");
170                 return 0;
171         }
172         if ((msg->from==0)||(msg->cseq==0)||(msg->to==0)) {
173                 LOG(L_ERR, "ERROR: parse_dlg: missing From or Cseq or To\n");
174                 return 0;
175         }
176
177         if (parse_from_header(msg)==-1) {
178                 LOG(L_ERR, "ERROR: parse_dlg: From broken\n");
179                 return 0;
180         }
181         /* To is automatically parsed through HDR_TO in parse bitmap,
182          * we don't need to worry about it now
183         if (parse_to_header(msg)==-1) {
184                 LOG(L_ERR, "ERROR: tid_matching: To broken\n");
185                 return 0;
186         }
187         */
188         return 1;
189 }
190
191 /* is the ACK (p_msg) in p_msg dialog-wise equal to the INVITE (t_msg) 
192  * except to-tags? */
193 static inline int partial_dlg_matching(struct sip_msg *t_msg, struct sip_msg *p_msg)
194 {
195         struct to_body *inv_from;
196
197         if (!EQ_LEN(callid)) return 0;
198         if (get_cseq(t_msg)->number.len!=get_cseq(p_msg)->number.len)
199                 return 0;
200         inv_from=get_from(t_msg);
201         if (!inv_from) {
202                 LOG(L_ERR, "ERROR: partial_dlg_matching: INV/From not parsed\n");
203                 return 0;
204         }
205         if (inv_from->tag_value.len!=get_from(p_msg)->tag_value.len)
206                 return 0;
207         if (!EQ_STR(callid)) 
208                 return 0;
209         if (memcmp(get_cseq(t_msg)->number.s, get_cseq(p_msg)->number.s,
210                         get_cseq(p_msg)->number.len)!=0)
211                 return 0;
212         if (memcmp(inv_from->tag_value.s, get_from(p_msg)->tag_value.s,
213                         get_from(p_msg)->tag_value.len)!=0)
214                 return 0;
215         return 1;
216 }
217
218 /* are to-tags in ACK/200 same as those we sent out? */
219 static inline int dlg_matching(struct cell *p_cell, struct sip_msg *ack )
220 {
221         if (get_to(ack)->tag_value.len!=p_cell->uas.local_totag.len)
222                 return 0;
223         if (memcmp(get_to(ack)->tag_value.s,p_cell->uas.local_totag.s,
224                                 p_cell->uas.local_totag.len)!=0)
225                 return 0;
226         return 1;
227 }
228
229 static inline int ack_matching(struct cell *p_cell, struct sip_msg *p_msg) 
230 {
231         /* partial dialog matching -- no to-tag, only from-tag, 
232          * callid, cseq number ; */
233         if (!partial_dlg_matching(p_cell->uas.request, p_msg)) 
234                 return 0;
235
236         /* if this transaction is proxied (as opposed to UAS) we're
237          * done now -- we ignore to-tags; the ACK simply belongs to
238          * this UAS part of dialog, whatever to-tag it gained
239          */
240         if (p_cell->relayed_reply_branch!=-2) {
241                 return 2; /* e2e proxied ACK */
242         }
243         /* it's a local dialog -- we wish to verify to-tags too */
244         if (dlg_matching(p_cell, p_msg)) {
245                 return 1;
246         }
247         return 0;
248 }
249
250 /* branch-based transaction matching */
251 static inline int via_matching( struct via_body *inv_via, 
252                                 struct via_body *ack_via )
253 {
254         if (inv_via->tid.len!=ack_via->tid.len)
255                 return 0;
256         if (memcmp(inv_via->tid.s, ack_via->tid.s,
257                                 ack_via->tid.len)!=0)
258                 return 0;
259         /* ok, tid matches -- now make sure that the
260          * originator matches too to avoid confusion with
261          * different senders generating the same tid
262          */
263         if (inv_via->host.len!=ack_via->host.len)
264                 return 0;;
265         if (memcmp(inv_via->host.s, ack_via->host.s,
266                         ack_via->host.len)!=0)
267                 return 0;
268         if (inv_via->port!=ack_via->port)
269                 return 0;
270         if (inv_via->transport.len!=ack_via->transport.len)
271                 return 0;
272         if (memcmp(inv_via->transport.s, ack_via->transport.s,
273                         ack_via->transport.len)!=0)
274                 return 0;
275         /* everything matched -- we found it */
276         return 1;
277 }
278
279
280 /* transaction matching a-la RFC-3261 using transaction ID in branch
281    (the function assumes there is magic cookie in branch) 
282    It returns:
283          2 if e2e ACK for a proxied transaction found
284      1  if found (covers ACK for local UAS)
285          0  if not found (trans undefined)
286 */
287
288 static int matching_3261( struct sip_msg *p_msg, struct cell **trans,
289                         enum request_method skip_method)
290 {
291         struct cell *p_cell;
292         struct sip_msg  *t_msg;
293         struct via_body *via1;
294         int is_ack;
295         int dlg_parsed;
296         int ret = 0;
297         struct cell *e2e_ack_trans;
298
299         e2e_ack_trans=0;
300         via1=p_msg->via1;
301         is_ack=p_msg->REQ_METHOD==METHOD_ACK;
302         dlg_parsed=0;
303         /* update parsed tid */
304         via1->tid.s=via1->branch->value.s+MCOOKIE_LEN;
305         via1->tid.len=via1->branch->value.len-MCOOKIE_LEN;
306
307         for ( p_cell = get_tm_table()->entrys[p_msg->hash_index].first_cell;
308                 p_cell; p_cell = p_cell->next_cell ) 
309         {
310                 t_msg=p_cell->uas.request;
311                 if (!t_msg) continue;  /* don't try matching UAC transactions */
312                 if (skip_method & t_msg->REQ_METHOD) continue;
313
314                 /* here we do an exercise which will be removed from future code
315                    versions: we try to match end-2-end ACKs if they appear at our
316                    server. This allows some applications bound to TM via callbacks
317                    to correlate the e2e ACKs with transaction context, e.g., for
318                    purpose of accounting. We think it is a bad place here, among
319                    other things because it is not reliable. If a transaction loops
320                    via SER the ACK can't be matched to proper INVITE transaction
321                    (it is a separate transactino with its own branch ID) and it
322                    matches all transaction instances in the loop dialog-wise.
323                    Eventually, regardless to which transaction in the loop the
324                    ACK belongs, only the first one will match.
325                 */
326
327                 /* dialog matching needs to be applied for ACK/200s */
328                 if (is_ack && p_cell->uas.status<300 && e2e_ack_trans==0) {
329                         /* make sure we have parsed all things we need for dialog
330                          * matching */
331                         if (!dlg_parsed) {
332                                 dlg_parsed=1;
333                                 if (!parse_dlg(p_msg)) {
334                                         LOG(L_ERR, "ERROR: matching_3261: dlg parsing failed\n");
335                                         return 0;
336                                 }
337                         }
338                         ret=ack_matching(p_cell /* t w/invite */, p_msg /* ack */);
339                         if (ret>0) {
340                                 e2e_ack_trans=p_cell;
341                                 break;
342                         }
343                         /* this ACK is neither local "negative" one, nor a proxied
344                          * end-2-end one, nor an end-2-end one for a UAS transaction
345                          * -- we failed to match */
346                         continue;
347                 }
348                 /* now real tid matching occurs  for negative ACKs and any 
349                  * other requests */
350                 if (!via_matching(t_msg->via1 /* inv via */, via1 /* ack */ ))
351                         continue;
352                 /* all matched -- we found the transaction ! */
353                 DBG("DEBUG: RFC3261 transaction matched, tid=%.*s\n",
354                         via1->tid.len, via1->tid.s);
355
356                 *trans=p_cell;
357                 return 1;
358         }
359         /* :-( ... we didn't find any */
360         
361         /* just check if it we found an e2e ACK previously */
362         if (e2e_ack_trans) {
363                 *trans=e2e_ack_trans;
364                 return ret;
365         }
366         DBG("DEBUG: RFC3261 transaction matching failed\n");
367         return 0;
368 }
369
370
371 /* function returns:
372  *      negative - transaction wasn't found
373  *                      (-2 = possibly e2e ACK matched )
374  *      positive - transaction found
375  */
376
377 int t_lookup_request( struct sip_msg* p_msg , int leave_new_locked )
378 {
379         struct cell         *p_cell;
380         unsigned int       isACK;
381         struct sip_msg  *t_msg;
382         int ret;
383         struct via_param *branch;
384         int match_status;
385         struct cell *e2e_ack_trans;
386
387         /* parse all*/
388         if (check_transaction_quadruple(p_msg)==0)
389         {
390                 LOG(L_ERR, "ERROR: TM module: t_lookup_request: too few headers\n");
391                 set_t(0);       
392                 /* stop processing */
393                 return 0;
394         }
395
396         /* start searching into the table */
397         if (!p_msg->hash_index)
398                 p_msg->hash_index=hash( p_msg->callid->body , get_cseq(p_msg)->number ) ;
399         isACK = p_msg->REQ_METHOD==METHOD_ACK;
400         DBG("t_lookup_request: start searching: hash=%d, isACK=%d\n",
401                 p_msg->hash_index,isACK);
402
403
404         /* assume not found */
405         ret=-1;
406         e2e_ack_trans = 0;
407
408         /* first of all, look if there is RFC3261 magic cookie in branch; if
409          * so, we can do very quick matching and skip the old-RFC bizzar
410          * comparison of many header fields
411          */
412         if (!p_msg->via1) {
413                 LOG(L_ERR, "ERROR: t_lookup_request: no via\n");
414                 set_t(0);       
415                 return 0;
416         }
417         branch=p_msg->via1->branch;
418         if (branch && branch->value.s && branch->value.len>MCOOKIE_LEN
419                         && memcmp(branch->value.s,MCOOKIE,MCOOKIE_LEN)==0) {
420                 /* huhuhu! the cookie is there -- let's proceed fast */
421                 LOCK_HASH(p_msg->hash_index);
422                 match_status=matching_3261(p_msg,&p_cell, 
423                                 /* skip transactions with different method; otherwise CANCEL would 
424                                  * match the previous INVITE trans.  */
425                                 isACK ? ~METHOD_INVITE: ~p_msg->REQ_METHOD);
426                 switch(match_status) {
427                                 case 0: goto notfound;  /* no match */
428                                 case 1: goto found;     /* match */
429                                 case 2: goto e2e_ack;   /* e2e proxy ACK */
430                 }
431         }
432
433         /* ok -- it's ugly old-fashioned transaction matching -- it is
434          * a bit simplified to be fast -- we don't do all the comparisons
435          * of parsed uri, which was simply too bloated */
436         DBG("DEBUG: proceeding to pre-RFC3261 transaction matching\n");
437
438         /* lock the whole entry*/
439         LOCK_HASH(p_msg->hash_index);
440
441         /* all the transactions from the entry are compared */
442         for ( p_cell = get_tm_table()->entrys[p_msg->hash_index].first_cell;
443                   p_cell; p_cell = p_cell->next_cell ) 
444         {
445                 t_msg = p_cell->uas.request;
446
447                 if (!t_msg) continue; /* skip UAC transactions */
448
449                 if (!isACK) {   
450                         /* compare lengths first */ 
451                         if (!EQ_LEN(callid)) continue;
452                         if (!EQ_LEN(cseq)) continue;
453                         if (!EQ_LEN(from)) continue;
454                         if (!EQ_LEN(to)) continue;
455                         if (ruri_matching && !EQ_REQ_URI_LEN) continue;
456                         if (via1_matching && !EQ_VIA_LEN(via1)) continue;
457
458                         /* length ok -- move on */
459                         if (!EQ_STR(callid)) continue;
460                         if (!EQ_STR(cseq)) continue;
461                         if (!EQ_STR(from)) continue;
462                         if (!EQ_STR(to)) continue;
463                         if (ruri_matching && !EQ_REQ_URI_STR) continue;
464                         if (via1_matching && !EQ_VIA_STR(via1)) continue;
465
466                         /* request matched ! */
467                         DBG("DEBUG: non-ACK matched\n");
468                         goto found;
469                 } else { /* it's an ACK request*/
470                         /* ACK's relate only to INVITEs */
471                         if (t_msg->REQ_METHOD!=METHOD_INVITE) continue;
472
473                         /* From|To URI , CallID, CSeq # must be always there */
474                         /* compare lengths now */
475                         if (!EQ_LEN(callid)) continue;
476                         /* CSeq only the number without method ! */
477                         if (get_cseq(t_msg)->number.len!=get_cseq(p_msg)->number.len)
478                                 continue;
479                         if (! EQ_LEN(from)) continue;
480                         /* To only the uri -- to many UACs screw up tags  */
481                         if (get_to(t_msg)->uri.len!=get_to(p_msg)->uri.len)
482                                 continue;
483                         if (!EQ_STR(callid)) continue;
484                         if (memcmp(get_cseq(t_msg)->number.s, get_cseq(p_msg)->number.s,
485                                 get_cseq(p_msg)->number.len)!=0) continue;
486                         if (!EQ_STR(from)) continue;
487                         if (memcmp(get_to(t_msg)->uri.s, get_to(p_msg)->uri.s,
488                                 get_to(t_msg)->uri.len)!=0) continue;
489
490                         /* it is e2e ACK/200 */
491                         if (p_cell->uas.status<300 && e2e_ack_trans==0) {
492                                 /* all criteria for proxied ACK are ok */
493                                 if (p_cell->relayed_reply_branch!=-2) {
494                                         e2e_ack_trans=p_cell;
495                                         continue;
496                                 }
497                                 /* it's a local UAS transaction */
498                                 if (dlg_matching(p_cell, p_msg))
499                                         goto found;
500                                 continue;
501                         }
502
503                         /* it is not an e2e ACK/200 -- perhaps it is 
504                          * local negative case; in which case we will want
505                          * more elements to match: r-uri and via; allow
506                          * mismatching r-uri as an config option for broken
507                          * UACs */
508                         if (ruri_matching && !EQ_REQ_URI_LEN ) continue;
509                         if (via1_matching && !EQ_VIA_LEN(via1)) continue;
510                         if (ruri_matching && !EQ_REQ_URI_STR) continue;
511                         if (via1_matching && !EQ_VIA_STR(via1)) continue;
512
513                         /* wow -- we survived all the check! we matched! */
514                         DBG("DEBUG: non-2xx ACK matched\n");
515                         goto found;
516                 } /* ACK */
517         } /* synonym loop */
518
519 notfound:
520
521         if (e2e_ack_trans) {
522                 p_cell=e2e_ack_trans;
523                 goto e2e_ack;
524         }
525                 
526         /* no transaction found */
527         set_t(0);
528         if (!leave_new_locked) {
529                 UNLOCK_HASH(p_msg->hash_index);
530         }
531         DBG("DEBUG: t_lookup_request: no transaction found\n");
532         return -1;
533
534 e2e_ack:
535         t_ack=p_cell;   /* e2e proxied ACK */
536         set_t(0);
537         if (!leave_new_locked) {
538                 UNLOCK_HASH(p_msg->hash_index);
539         }
540         DBG("DEBUG: t_lookup_request: e2e proxy ACK found\n");
541         return -2;
542
543 found:
544         set_t(p_cell);
545         REF_UNSAFE( T );
546         set_kr(REQ_EXIST);
547         UNLOCK_HASH( p_msg->hash_index );
548         DBG("DEBUG: t_lookup_request: transaction found (T=%p)\n",T);
549         return 1;
550 }
551
552
553
554 /* function lookups transaction being canceled by CANCEL in p_msg;
555  * it returns:
556  *       0 - transaction wasn't found
557  *       T - transaction found
558  */
559 struct cell* t_lookupOriginalT(  struct sip_msg* p_msg )
560 {
561         struct cell     *p_cell;
562         unsigned int     hash_index;
563         struct sip_msg  *t_msg;
564         struct via_param *branch;
565         int ret;
566
567
568         /* start searching in the table */
569         hash_index = p_msg->hash_index;
570         DBG("DEBUG: t_lookupOriginalT: searching on hash entry %d\n",hash_index );
571
572
573         /* first of all, look if there is RFC3261 magic cookie in branch; if
574          * so, we can do very quick matching and skip the old-RFC bizzar
575          * comparison of many header fields
576          */
577         if (!p_msg->via1) {
578                 LOG(L_ERR, "ERROR: t_lookupOriginalT: no via\n");
579                 set_t(0);
580                 return 0;
581         }
582         branch=p_msg->via1->branch;
583         if (branch && branch->value.s && branch->value.len>MCOOKIE_LEN
584                         && memcmp(branch->value.s,MCOOKIE,MCOOKIE_LEN)==0) {
585                 /* huhuhu! the cookie is there -- let's proceed fast */
586                 LOCK_HASH(hash_index);
587                 ret=matching_3261(p_msg, &p_cell,
588                                 /* we are seeking the original transaction --
589                                  * skip CANCEL transactions during search
590                                  */
591                                 METHOD_CANCEL);
592                 if (ret==1) goto found; else goto notfound;
593         }
594
595         /* no cookies --proceed to old-fashioned pre-3261 t-matching */
596
597         LOCK_HASH(hash_index);
598
599         /* all the transactions from the entry are compared */
600         for (p_cell=get_tm_table()->entrys[hash_index].first_cell;
601                 p_cell; p_cell = p_cell->next_cell )
602         {
603                 t_msg = p_cell->uas.request;
604
605                 if (!t_msg) continue; /* skip UAC transactions */
606
607                 /* we don't cancel CANCELs ;-) */
608                 if (t_msg->REQ_METHOD==METHOD_CANCEL)
609                         continue;
610
611                 /* check lengths now */ 
612                 if (!EQ_LEN(callid))
613                         continue;
614                 if (get_cseq(t_msg)->number.len!=get_cseq(p_msg)->number.len)
615                         continue;
616                 if (!EQ_LEN(from))
617                         continue;
618 #ifdef CANCEL_TAG
619                 if (!EQ_LEN(to))
620                         continue;
621 #else
622                 /* relaxed matching -- we don't care about to-tags anymore,
623                  * many broken UACs screw them up and ignoring them does not
624                  * actually hurt
625                  */
626                 if (get_to(t_msg)->uri.len!=get_to(p_msg)->uri.len)
627                         continue;
628 #endif
629                 if (ruri_matching && !EQ_REQ_URI_LEN)
630                         continue;
631                 if (via1_matching && !EQ_VIA_LEN(via1))
632                         continue;
633
634                 /* check the content now */
635                 if (!EQ_STR(callid))
636                         continue;
637                 if (memcmp(get_cseq(t_msg)->number.s,
638                         get_cseq(p_msg)->number.s,get_cseq(p_msg)->number.len)!=0)
639                         continue;
640                 if (!EQ_STR(from))
641                         continue;
642 #ifdef CANCEL_TAG
643                 if (!EQ_STR(to))
644                         continue;
645 #else
646                 if (memcmp(get_to(t_msg)->uri.s, get_to(p_msg)->uri.s,
647                                         get_to(t_msg)->uri.len)!=0)
648                         continue;
649 #endif
650                 if (ruri_matching && !EQ_REQ_URI_STR)
651                         continue;
652                 if (via1_matching && !EQ_VIA_STR(via1))
653                         continue;
654
655                 /* found */
656                 goto found;
657         }
658
659 notfound:
660         /* no transaction found */
661         DBG("DEBUG: t_lookupOriginalT: no CANCEL matching found! \n" );
662         UNLOCK_HASH(hash_index);
663         DBG("DEBUG: t_lookupOriginalT completed\n");
664         return 0;
665
666 found:
667         DBG("DEBUG: t_lookupOriginalT: canceled transaction"
668                 " found (%p)! \n",p_cell );
669         REF_UNSAFE( p_cell );
670         UNLOCK_HASH(hash_index);
671         DBG("DEBUG: t_lookupOriginalT completed\n");
672         return p_cell;
673 }
674
675
676
677
678 /* Returns 0 - nothing found
679  *         1  - T found
680  */
681 int t_reply_matching( struct sip_msg *p_msg , int *p_branch )
682 {
683         struct cell*  p_cell;
684         unsigned int hash_index   = 0;
685         int entry_label  = 0;
686         unsigned int branch_id    = 0;
687         char  *hashi, *branchi, *p, *n;
688         int hashl, branchl;
689         int scan_space;
690         str cseq_method;
691         str req_method;
692
693         char *loopi;
694         int loopl;
695         char *syni;
696         int synl;
697         
698         short is_cancel;
699
700         /* make compiler warnings happy */
701         loopi=0;
702         loopl=0;
703         syni=0;
704         synl=0;
705
706         /* split the branch into pieces: loop_detection_check(ignored),
707          hash_table_id, synonym_id, branch_id */
708
709         if (!(p_msg->via1 && p_msg->via1->branch && p_msg->via1->branch->value.s))
710                 goto nomatch2;
711
712         /* we do RFC 3261 tid matching and want to see first if there is
713          * magic cookie in branch */
714         if (p_msg->via1->branch->value.len<=MCOOKIE_LEN)
715                 goto nomatch2;
716         if (memcmp(p_msg->via1->branch->value.s, MCOOKIE, MCOOKIE_LEN)!=0)
717                 goto nomatch2;
718
719         p=p_msg->via1->branch->value.s+MCOOKIE_LEN;
720         scan_space=p_msg->via1->branch->value.len-MCOOKIE_LEN;
721
722
723         /* hash_id */
724         n=eat_token2_end( p, p+scan_space, BRANCH_SEPARATOR);
725         hashl=n-p;
726         scan_space-=hashl;
727         if (!hashl || scan_space<2 || *n!=BRANCH_SEPARATOR) goto nomatch2;
728         hashi=p;
729         p=n+1;scan_space--;
730
731         if (!syn_branch) {
732                 /* md5 value */
733                 n=eat_token2_end( p, p+scan_space, BRANCH_SEPARATOR );
734                 loopl = n-p;
735                 scan_space-= loopl;
736                 if (n==p || scan_space<2 || *n!=BRANCH_SEPARATOR) 
737                         goto nomatch2;
738                 loopi=p;
739                 p=n+1; scan_space--;
740         } else {
741                 /* synonym id */
742                 n=eat_token2_end( p, p+scan_space, BRANCH_SEPARATOR);
743                 synl=n-p;
744                 scan_space-=synl;
745                 if (!synl || scan_space<2 || *n!=BRANCH_SEPARATOR) 
746                         goto nomatch2;
747                 syni=p;
748                 p=n+1;scan_space--;
749         }
750
751         /* branch id  -  should exceed the scan_space */
752         n=eat_token_end( p, p+scan_space );
753         branchl=n-p;
754         if (!branchl ) goto nomatch2;
755         branchi=p;
756
757         /* sanity check */
758         if (reverse_hex2int(hashi, hashl, &hash_index)<0
759                 ||hash_index>=TABLE_ENTRIES
760                 || reverse_hex2int(branchi, branchl, &branch_id)<0
761                 ||branch_id>=MAX_BRANCHES
762                 || (syn_branch ? (reverse_hex2int(syni, synl, &entry_label))<0 
763                         : loopl!=MD5_LEN )
764         ) {
765                 DBG("DEBUG: t_reply_matching: poor reply labels %d label %d "
766                         "branch %d\n", hash_index, entry_label, branch_id );
767                 goto nomatch2;
768         }
769
770
771         DBG("DEBUG: t_reply_matching: hash %d label %d branch %d\n",
772                 hash_index, entry_label, branch_id );
773
774
775         /* search the hash table list at entry 'hash_index'; lock the
776            entry first 
777         */
778         cseq_method=get_cseq(p_msg)->method;
779         is_cancel=cseq_method.len==CANCEL_LEN 
780                 && memcmp(cseq_method.s, CANCEL, CANCEL_LEN)==0;
781         LOCK_HASH(hash_index);
782         for (p_cell = get_tm_table()->entrys[hash_index].first_cell; p_cell; 
783                 p_cell=p_cell->next_cell) {
784
785                 /* first look if branch matches */
786
787                 if (syn_branch) {
788                         if (p_cell->label != entry_label) 
789                                 continue;
790                 } else {
791                         if ( memcmp(p_cell->md5, loopi,MD5_LEN)!=0)
792                                         continue;
793                 }
794
795                 /* sanity check ... too high branch ? */
796                 if ( branch_id>=p_cell->nr_of_outgoings )
797                         continue;
798
799                 /* does method match ? (remember -- CANCELs have the same branch
800                    as canceled transactions) */
801                 req_method=p_cell->method;
802                 if ( /* method match */
803                         ! ((cseq_method.len==req_method.len 
804                         && memcmp( cseq_method.s, req_method.s, cseq_method.len )==0)
805                         /* or it is a local cancel */
806                         || (is_cancel && is_invite(p_cell)
807                                 /* commented out -- should_cancel_branch set it to
808                                    BUSY_BUFFER to avoid collisions with replies;
809                                    thus, we test here by buffer size
810                                 */
811                                 /* && p_cell->uac[branch_id].local_cancel.buffer ))) */
812                                 && p_cell->uac[branch_id].local_cancel.buffer_len ))) 
813                         continue;
814
815
816                 /* we passed all disqualifying factors .... the transaction has been
817                    matched !
818                 */
819                 set_t(p_cell);
820                 *p_branch =(int) branch_id;
821                 REF_UNSAFE( T );
822                 UNLOCK_HASH(hash_index);
823                 DBG("DEBUG: t_reply_matching: reply matched (T=%p)!\n",T);
824                 /* if this is a 200 for INVITE, we will wish to store to-tags to be
825                  * able to distinguish retransmissions later and not to call
826                  * TMCB_RESPONSE_OUT uselessly; we do it only if callbacks are
827                  * enabled -- except callback customers, nobody cares about 
828                  * retransmissions of multiple 200/INV or ACK/200s
829                  */
830                 if (is_invite(p_cell) && p_msg->REPLY_STATUS>=200 
831                 && p_msg->REPLY_STATUS<300 
832                 && ( (!is_local(p_cell) &&
833                                 has_tran_tmcbs(p_cell,TMCB_RESPONSE_OUT|TMCB_E2EACK_IN) )
834                         || (is_local(p_cell)&&has_tran_tmcbs(p_cell,TMCB_LOCAL_COMPLETED))
835                 )) {
836                         if (parse_headers(p_msg, HDR_TO_F, 0)==-1) {
837                                 LOG(L_ERR, "ERROR: t_reply_matching: to parsing failed\n");
838                         }
839                 }
840                 if (!is_local(p_cell)) {
841                         run_trans_callbacks( TMCB_RESPONSE_IN, T, T->uas.request, p_msg,
842                                 p_msg->REPLY_STATUS);
843                 }
844                 return 1;
845         } /* for cycle */
846
847         /* nothing found */
848         UNLOCK_HASH(hash_index);
849         DBG("DEBUG: t_reply_matching: no matching transaction exists\n");
850
851 nomatch2:
852         DBG("DEBUG: t_reply_matching: failure to match a transaction\n");
853         *p_branch = -1;
854         set_t(0);
855         return -1;
856 }
857
858
859
860
861 /* Determine current transaction
862  *
863  *                   Found      Not Found     Error (e.g. parsing)
864  *  Return Value     1          0             -1
865  *  T                ptr        0             T_UNDEFINED
866  */
867 int t_check( struct sip_msg* p_msg , int *param_branch )
868 {
869         int local_branch;
870
871         /* is T still up-to-date ? */
872         DBG("DEBUG: t_check: msg id=%d global id=%d T start=%p\n", 
873                 p_msg->id,global_msg_id,T);
874         if ( p_msg->id != global_msg_id || T==T_UNDEFINED )
875         {
876                 global_msg_id = p_msg->id;
877                 T = T_UNDEFINED;
878                 /* transaction lookup */
879                 if ( p_msg->first_line.type==SIP_REQUEST ) {
880                         /* force parsing all the needed headers*/
881                         if (parse_headers(p_msg, HDR_EOH_F, 0 )==-1) {
882                                 LOG(L_ERR, "ERROR: t_check: parsing error\n");
883                                 return -1;
884                         }
885                         /* in case, we act as UAS for INVITE and reply with 200,
886                          * we will need to run dialog-matching for subsequent
887                          * ACK, for which we need From-tag; We also need from-tag
888                          * in case people want to have proxied e2e ACKs accounted
889                          */
890                         if (p_msg->REQ_METHOD==METHOD_INVITE 
891                                                         && parse_from_header(p_msg)==-1) {
892                                 LOG(L_ERR, "ERROR: t_check: from parsing failed\n");
893                                 return -1;
894                         }
895                         t_lookup_request( p_msg , 0 /* unlock before returning */ );
896                 } else {
897                         /* we need Via for branch and Cseq method to distinguish
898                            replies with the same branch/cseqNr (CANCEL)
899                         */
900                         if ( parse_headers(p_msg, HDR_VIA1_F|HDR_CSEQ_F, 0 )==-1
901                         || !p_msg->via1 || !p_msg->cseq ) {
902                                 LOG(L_ERR, "ERROR: reply cannot be parsed\n");
903                                 return -1;
904                         }
905
906                         /* if that is an INVITE, we will also need to-tag
907                            for later ACK matching
908                         */
909             if ( get_cseq(p_msg)->method.len==INVITE_LEN 
910                                 && memcmp( get_cseq(p_msg)->method.s, INVITE, INVITE_LEN )==0 ) {
911                                         if (parse_headers(p_msg, HDR_TO_F, 0)==-1
912                                                 || !p_msg->to)  {
913                                                 LOG(L_ERR, "ERROR: INVITE reply cannot be parsed\n");
914                                                 return -1;
915                                         }
916                         }
917
918                         t_reply_matching( p_msg ,
919                                 param_branch!=0?param_branch:&local_branch );
920
921                 }
922 #ifdef EXTRA_DEBUG
923                 if ( T && T!=T_UNDEFINED && T->damocles) {
924                         LOG( L_ERR, "ERROR: transaction %p scheduled for deletion "
925                                 "and called from t_check\n", T);
926                         abort();
927                 }
928 #endif
929                 DBG("DEBUG: t_check: msg id=%d global id=%d T end=%p\n",
930                         p_msg->id,global_msg_id,T);
931         } else {
932                 if (T)
933                         DBG("DEBUG: t_check: T already found!\n");
934                 else
935                         DBG("DEBUG: t_check: T previously sought and not found\n");
936         }
937
938         return T ? (T==T_UNDEFINED ? -1 : 1 ) : 0;
939 }
940
941 int init_rb( struct retr_buf *rb, struct sip_msg *msg)
942 {
943         /*struct socket_info* send_sock;*/
944         struct via_body* via;
945         int proto;
946         int backup_mhomed;
947
948         via=msg->via1;
949         if (!reply_to_via) {
950                 update_sock_struct_from_ip( &rb->dst.to, msg );
951                 proto=msg->rcv.proto;
952         } else {
953                 /*init retrans buffer*/
954                 if (update_sock_struct_from_via( &(rb->dst.to), msg, via )==-1) {
955                         LOG(L_ERR, "ERROR: init_rb: cannot lookup reply dst: %.*s\n",
956                                 via->host.len, via->host.s );
957                         ser_error=E_BAD_VIA;
958                         return 0;
959                 }
960                 proto=via->proto;
961         }
962         rb->dst.proto=proto;
963         rb->dst.proto_reserved1=msg->rcv.proto_reserved1;
964         /* turn off mhomed for generating replies -- they are ideally sent to where
965            request came from to make life with NATs and other beasts easier
966         */
967         backup_mhomed=mhomed;
968         mhomed=0;
969         mhomed=backup_mhomed;
970         /* use for sending replies the incoming interface of the request -bogdan */
971         /*send_sock=get_send_socket(msg, &rb->dst.to, proto);
972         if (send_sock==0) {
973                 LOG(L_ERR, "ERROR: init_rb: cannot fwd to af %d, proto %d "
974                         "no socket\n", rb->dst.to.s.sa_family, proto);
975                 ser_error=E_BAD_VIA;
976                 return 0;
977         }*/
978         rb->dst.send_sock=msg->rcv.bind_address;
979         return 1;
980 }
981
982
983 static inline void init_new_t(struct cell *new_cell, struct sip_msg *p_msg)
984 {
985         struct sip_msg *shm_msg;
986
987         shm_msg=new_cell->uas.request;
988         new_cell->from.s=shm_msg->from->name.s;
989         new_cell->from.len=HF_LEN(shm_msg->from);
990         new_cell->to.s=shm_msg->to->name.s;
991         new_cell->to.len=HF_LEN(shm_msg->to);
992         new_cell->callid.s=shm_msg->callid->name.s;
993         new_cell->callid.len=HF_LEN(shm_msg->callid);
994         new_cell->cseq_n.s=shm_msg->cseq->name.s;
995         new_cell->cseq_n.len=get_cseq(shm_msg)->number.s
996                 +get_cseq(shm_msg)->number.len
997                 -shm_msg->cseq->name.s;
998
999         new_cell->method=new_cell->uas.request->first_line.u.request.method;
1000         if (p_msg->REQ_METHOD==METHOD_INVITE) new_cell->flags |= T_IS_INVITE_FLAG;
1001         new_cell->on_negative=get_on_negative();
1002         new_cell->on_reply=get_on_reply();
1003         new_cell->on_branch=get_on_branch();
1004 }
1005
1006 static inline int new_t(struct sip_msg *p_msg)
1007 {
1008         struct cell *new_cell;
1009
1010         /* for ACK-dlw-wise matching, we want From-tags */
1011         if (p_msg->REQ_METHOD==METHOD_INVITE && parse_from_header(p_msg)<0) {
1012                         LOG(L_ERR, "ERROR: new_t: no valid From in INVITE\n");
1013                         return E_BAD_REQ;
1014         }
1015         /* make sure uri will be parsed before cloning */
1016         if (parse_sip_msg_uri(p_msg)<0) {
1017                 LOG(L_ERR, "ERROR: new_t: uri invalid\n");
1018                 return E_BAD_REQ;
1019         }
1020                         
1021         /* add new transaction */
1022         new_cell = build_cell( p_msg ) ;
1023         if  ( !new_cell ){
1024                 LOG(L_ERR, "ERROR: new_t: out of mem:\n");
1025                 return E_OUT_OF_MEM;
1026         } 
1027
1028         insert_into_hash_table_unsafe( new_cell, p_msg->hash_index );
1029         set_t(new_cell);
1030         INIT_REF_UNSAFE(T);
1031         /* init pointers to headers needed to construct local
1032            requests such as CANCEL/ACK
1033         */
1034         init_new_t(new_cell, p_msg);
1035         return 1;
1036 }
1037
1038 /* atomic "new_tran" construct; it returns:
1039
1040         <0      on error
1041
1042         +1      if a request did not match a transaction
1043                 - it that was an ack, the calling function
1044                   shall forward statelessly
1045                 - otherwise it means, a new transaction was
1046                   introduced and the calling function
1047                   shall reply/relay/whatever_appropriate
1048
1049         0 on retransmission
1050 */
1051 int t_newtran( struct sip_msg* p_msg )
1052 {
1053         int lret, my_err;
1054
1055
1056         /* is T still up-to-date ? */
1057         DBG("DEBUG: t_newtran: msg id=%d , global msg id=%d ,"
1058                 " T on entrance=%p\n",p_msg->id,global_msg_id,T);
1059
1060         if ( T && T!=T_UNDEFINED  ) {
1061                 LOG(L_ERR, "ERROR: t_newtran: "
1062                         "transaction already in process %p\n", T );
1063                 return E_SCRIPT;
1064         }
1065
1066         global_msg_id = p_msg->id;
1067         T = T_UNDEFINED;
1068         /* first of all, parse everything -- we will store in shared memory 
1069            and need to have all headers ready for generating potential replies 
1070            later; parsing later on demand is not an option since the request 
1071            will be in shmem and applying parse_headers to it would intermix 
1072            shmem with pkg_mem
1073         */
1074         
1075         if (parse_headers(p_msg, HDR_EOH_F, 0 )) {
1076                 LOG(L_ERR, "ERROR: t_newtran: parse_headers failed\n");
1077                 return E_BAD_REQ;
1078         }
1079         if ((p_msg->parsed_flag & HDR_EOH_F)!=HDR_EOH_F) {
1080                         LOG(L_ERR, "ERROR: t_newtran: EoH not parsed\n");
1081                         return E_OUT_OF_MEM;
1082         }
1083         /* t_lookup_requests attempts to find the transaction; 
1084            it also calls check_transaction_quadruple -> it is
1085            safe to assume we have from/callid/cseq/to
1086         */ 
1087         lret = t_lookup_request( p_msg, 1 /* leave locked if not found */ );
1088
1089         /* on error, pass the error in the stack ... nothing is locked yet
1090            if 0 is returned */
1091         if (lret==0) return E_BAD_TUPEL;
1092
1093         /* transaction found, it's a retransmission  */
1094         if (lret>0) {
1095                 if (p_msg->REQ_METHOD==METHOD_ACK) {
1096                         t_release_transaction(T);
1097                 } else {
1098                         t_retransmit_reply(T);
1099                 }
1100                 /* things are done -- return from script */
1101                 return 0;
1102         }
1103
1104         /* from now on, be careful -- hash table is locked */
1105
1106         if (lret==-2) { /* was it an e2e ACK ? if so, trigger a callback */
1107                 /* no callbacks? complete quickly */
1108                 if ( !has_tran_tmcbs(t_ack,TMCB_E2EACK_IN) ) {
1109                         UNLOCK_HASH(p_msg->hash_index);
1110                         return 1;
1111                 } 
1112                 REF_UNSAFE(t_ack);
1113                 UNLOCK_HASH(p_msg->hash_index);
1114                 /* we don't call from within REPLY_LOCK -- that introduces
1115                  * a race condition; however, it is so unlikely and the
1116                  * impact is so small (callback called multiple times of
1117                  * multiple ACK/200s received in parallel), that we do not
1118                  * better waste time in locks  */
1119                 if (unmatched_totag(t_ack, p_msg)) {
1120                         run_trans_callbacks( TMCB_E2EACK_IN , t_ack, p_msg, 0,
1121                                 -p_msg->REQ_METHOD );
1122                 }
1123                 UNREF(t_ack);
1124                 return 1;
1125         } 
1126
1127
1128         /* transaction not found, it's a new request (lret<0, lret!=-2);
1129            establish a new transaction ... */
1130         if (p_msg->REQ_METHOD==METHOD_ACK) { /* ... unless it is in ACK */
1131                 my_err=1;
1132                 goto new_err;
1133         }
1134
1135         my_err=new_t(p_msg);
1136         if (my_err<0) {
1137                 LOG(L_ERR, "ERROR: t_newtran: new_t failed\n");
1138                 goto new_err;
1139         }
1140
1141
1142         UNLOCK_HASH(p_msg->hash_index);
1143         /* now, when the transaction state exists, check if
1144            there is a meaningful Via and calculate it; better
1145            do it now than later: state is established so that
1146            subsequent retransmissions will be absorbed and will
1147           not possibly block during Via DNS resolution; doing
1148            it later would only burn more CPU as if there is an
1149            error, we cannot relay later whatever comes out of the
1150            the transaction 
1151         */
1152         if (!init_rb( &T->uas.response, p_msg)) {
1153                 LOG(L_ERR, "ERROR: t_newtran: unresolvable via1\n");
1154                 put_on_wait( T );
1155                 t_unref(p_msg);
1156                 return E_BAD_VIA;
1157         }
1158
1159         return 1;
1160
1161
1162 new_err:
1163         UNLOCK_HASH(p_msg->hash_index);
1164         return my_err;
1165
1166 }
1167
1168
1169 int t_unref( struct sip_msg* p_msg  )
1170 {
1171         enum kill_reason kr;
1172
1173         if (T==T_UNDEFINED || T==T_NULL_CELL)
1174                 return -1;
1175         if (p_msg->first_line.type==SIP_REQUEST){
1176                 kr=get_kr();
1177                 if (kr==0 
1178                                 ||(p_msg->REQ_METHOD==METHOD_ACK && !(kr & REQ_RLSD))) {
1179                         LOG(L_WARN, "WARNING: script writer didn't release transaction\n");
1180                         t_release_transaction(T);
1181                 }
1182         }
1183         UNREF( T );
1184         set_t(T_UNDEFINED);
1185         return 1;
1186 }
1187
1188 int t_get_trans_ident(struct sip_msg* p_msg, unsigned int* hash_index, unsigned int* label)
1189 {
1190     struct cell* t;
1191     if(t_check(p_msg,0) != 1){
1192         LOG(L_ERR,"ERROR: t_get_trans_ident: no transaction found\n");
1193         return -1;
1194     }
1195     t = get_t();
1196     if(!t){
1197         LOG(L_ERR,"ERROR: t_get_trans_ident: transaction found is NULL\n");
1198         return -1;
1199     }
1200     
1201     *hash_index = t->hash_index;
1202     *label = t->label;
1203
1204     return 1;
1205 }
1206
1207 int t_lookup_ident(struct cell ** trans, unsigned int hash_index, unsigned int label)
1208 {
1209     struct cell* p_cell;
1210
1211     if(hash_index >= TABLE_ENTRIES){
1212                 LOG(L_ERR,"ERROR: t_lookup_ident: invalid hash_index=%u\n",hash_index);
1213                 return -1;
1214     }
1215
1216     LOCK_HASH(hash_index);
1217
1218     /* all the transactions from the entry are compared */
1219     for ( p_cell = get_tm_table()->entrys[hash_index].first_cell;
1220           p_cell; p_cell = p_cell->next_cell ) 
1221     {
1222                 if(p_cell->label == label){
1223                         REF_UNSAFE(p_cell);
1224                         UNLOCK_HASH(hash_index);
1225                         set_t(p_cell);
1226                         *trans=p_cell;
1227                         DBG("DEBUG: t_lookup_ident: transaction found\n");
1228                         return 1;
1229                 }
1230     }
1231         
1232         UNLOCK_HASH(hash_index);
1233         set_t(0);
1234         *trans=p_cell;
1235
1236         DBG("DEBUG: t_lookup_ident: transaction not found\n");
1237     
1238     return -1;
1239 }
1240
1241 int t_is_local(struct sip_msg* p_msg)
1242 {
1243     struct cell* t;
1244     if(t_check(p_msg,0) != 1){
1245         LOG(L_ERR,"ERROR: t_is_local: no transaction found\n");
1246         return -1;
1247     }
1248     t = get_t();
1249     if(!t){
1250         LOG(L_ERR,"ERROR: t_is_local: transaction found is NULL\n");
1251         return -1;
1252     }
1253     
1254     return is_local(t);
1255 }
1256
1257 /* lookup a transaction by callid and cseq, parameters are pure
1258  * header field content only, e.g. "123@10.0.0.1" and "11"
1259  */
1260 int t_lookup_callid(struct cell ** trans, str callid, str cseq) {
1261         struct cell* p_cell;
1262         unsigned hash_index;
1263
1264         /* I use MAX_HEADER, not sure if this is a good choice... */
1265         char callid_header[MAX_HEADER];
1266         char cseq_header[MAX_HEADER];
1267         /* save return value of print_* functions here */
1268         char* endpos;
1269
1270         /* need method, which is always INVITE in our case */
1271         /* CANCEL is only useful after INVITE */
1272         str invite_method;
1273         char* invite_string = INVITE;
1274         
1275         invite_method.s = invite_string;
1276         invite_method.len = INVITE_LEN;
1277         
1278         /* lookup the hash index where the transaction is stored */
1279         hash_index=hash(callid, cseq);
1280
1281         if(hash_index >= TABLE_ENTRIES){
1282                 LOG(L_ERR,"ERROR: t_lookup_callid: invalid hash_index=%u\n",hash_index);
1283                 return -1;
1284         }
1285
1286         /* create header fields the same way tm does itself, then compare headers */
1287         endpos = print_callid_mini(callid_header, callid);
1288         DBG("created comparable call_id header field: >%.*s<\n", 
1289                         (int)(endpos - callid_header), callid_header); 
1290
1291         endpos = print_cseq_mini(cseq_header, &cseq, &invite_method);
1292         DBG("created comparable cseq header field: >%.*s<\n", 
1293                         (int)(endpos - cseq_header), cseq_header); 
1294
1295         LOCK_HASH(hash_index);
1296         DBG("just locked hash index %u, looking for transactions there:\n", hash_index);
1297
1298         /* all the transactions from the entry are compared */
1299         for ( p_cell = get_tm_table()->entrys[hash_index].first_cell;
1300           p_cell; p_cell = p_cell->next_cell ) {
1301                 
1302                 /* compare complete header fields, casecmp to make sure invite=INVITE */
1303                 if ( (strncmp(callid_header, p_cell->callid.s, p_cell->callid.len) == 0)
1304                         && (strncasecmp(cseq_header, p_cell->cseq_n.s, p_cell->cseq_n.len) == 0) ) {
1305                         DBG("we have a match: callid=>>%.*s<< cseq=>>%.*s<<\n", p_cell->callid.len, 
1306                                 p_cell->callid.s, p_cell->cseq_n.len, p_cell->cseq_n.s);
1307                         REF_UNSAFE(p_cell);
1308                         UNLOCK_HASH(hash_index);
1309                         set_t(p_cell);
1310                         *trans=p_cell;
1311                         DBG("DEBUG: t_lookup_callid: transaction found.\n");
1312                         return 1;
1313                 }
1314                 DBG("NO match: callid=%.*s cseq=%.*s\n", p_cell->callid.len, 
1315                         p_cell->callid.s, p_cell->cseq_n.len, p_cell->cseq_n.s);
1316                         
1317         }
1318
1319         UNLOCK_HASH(hash_index);
1320         DBG("DEBUG: t_lookup_callid: transaction not found.\n");
1321     
1322         return -1;
1323 }
1324