- dialog support added
[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 worx 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 wuld 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 instatntiation (jiri)
72  * 2003-04-30  t_newtran clean up (jiri)
73  */
74
75
76 #include "defs.h"
77
78
79 #include <assert.h>
80 #include "../../comp_defs.h"
81 #include "../../dprint.h"
82 #include "../../config.h"
83 #include "../../parser/parser_f.h"
84 #include "../../parser/parse_from.h"
85 #include "../../ut.h"
86 #include "../../timer.h"
87 #include "../../hash_func.h"
88 #include "../../globals.h"
89 #include "../../forward.h"
90 #include "t_funcs.h"
91 #include "config.h"
92 #include "sip_msg.h"
93 #include "t_hooks.h"
94 #include "t_lookup.h"
95
96 #define EQ_VIA_LEN(_via)\
97         ( (p_msg->via1->bsize-(p_msg->_via->name.s-(p_msg->_via->hdr.s+p_msg->_via->hdr.len)))==\
98                 (t_msg->via1->bsize-(t_msg->_via->name.s-(t_msg->_via->hdr.s+t_msg->_via->hdr.len))) )
99
100
101
102 #define EQ_LEN(_hf) (t_msg->_hf->body.len==p_msg->_hf->body.len)
103 #define EQ_REQ_URI_LEN\
104         (p_msg->first_line.u.request.uri.len==t_msg->first_line.u.request.uri.len)
105
106 #define EQ_STR(_hf) (memcmp(t_msg->_hf->body.s,\
107         p_msg->_hf->body.s, \
108         p_msg->_hf->body.len)==0)
109 #define EQ_REQ_URI_STR\
110         ( memcmp( t_msg->first_line.u.request.uri.s,\
111         p_msg->first_line.u.request.uri.s,\
112         p_msg->first_line.u.request.uri.len)==0)
113 #define EQ_VIA_STR(_via)\
114         ( memcmp( t_msg->_via->name.s,\
115          p_msg->_via->name.s,\
116          (t_msg->via1->bsize-(t_msg->_via->name.s-(t_msg->_via->hdr.s+t_msg->_via->hdr.len)))\
117         )==0 )
118
119
120
121 #define HF_LEN(_hf) ((_hf)->len)
122
123 /* should be request-uri matching used as a part of pre-3261 
124  * transaction matching, as the standard wants us to do so
125  * (and is reasonable to do so, to be able to distinguish
126  * spirals)? turn only off for better interaction with 
127  * devices that are broken and send different r-uri in
128  * CANCEL/ACK than in original INVITE
129  */
130 int ruri_matching=1;
131
132 /* presumably matching transaction for an e2e ACK */
133 static struct cell *t_ack;
134
135 /* this is a global variable which keeps pointer to
136    transaction currently processed by a process; it it
137    set by t_lookup_request or t_reply_matching; don't
138    dare to change it anywhere else as it would
139    break ref_counting
140 */
141
142 static struct cell *T;
143
144 /* number of currently processed message; good to know
145    to be able to doublecheck whether we are still working
146    on a current transaction or a new message arrived;
147    don't even think of changing it
148 */
149 unsigned int     global_msg_id;
150
151 struct cell *get_t() { return T; }
152 void set_t(struct cell *t) { T=t; }
153 void init_t() {global_msg_id=0; set_t(T_UNDEFINED);}
154
155 static inline int parse_dlg( struct sip_msg *msg )
156 {
157         if (parse_headers(msg, HDR_FROM | HDR_CSEQ | HDR_TO, 0)==-1) {
158                 LOG(L_ERR, "ERROR: tid_matching: From or Cseq or To invalid\n");
159                 return 0;
160         }
161         if (parse_from_header(msg)==-1) {
162                 LOG(L_ERR, "ERROR: tid_matching: From broken\n");
163                 return 0;
164         }
165         /* To is automatically parsed through HDR_TO in parse bitmap,
166          * we don't need to worry about it now
167         if (parse_to_header(msg)==-1) {
168                 LOG(L_ERR, "ERROR: tid_matching: To broken\n");
169                 return 0;
170         }
171         */
172         return 1;
173 }
174
175 /* is the ACK (p_msg) in p_msg dialog-wise equal to the INVITE (t_msg) 
176  * except to-tags? */
177 static inline int partial_dlg_matching(struct sip_msg *t_msg, struct sip_msg *p_msg)
178 {
179         struct to_body *inv_from;
180
181         if (!EQ_LEN(callid)) return 0;
182         if (get_cseq(t_msg)->number.len!=get_cseq(p_msg)->number.len)
183                 return 0;
184         inv_from=get_from(t_msg);
185         if (!inv_from) {
186                 LOG(L_ERR, "ERROR: partial_dlg_matching: INV/From not parsed\n");
187                 return 0;
188         }
189         if (inv_from->tag_value.len!=get_from(p_msg)->tag_value.len)
190                 return 0;
191         if (!EQ_STR(callid)) 
192                 return 0;
193         if (memcmp(get_cseq(t_msg)->number.s, get_cseq(p_msg)->number.s,
194                         get_cseq(p_msg)->number.len)!=0)
195                 return 0;
196         if (memcmp(inv_from->tag_value.s, get_from(p_msg)->tag_value.s,
197                         get_from(p_msg)->tag_value.len)!=0)
198                 return 0;
199         return 1;
200 }
201
202 /* are to-tags in ACK/200 same as those we sent out? */
203 static inline int dlg_matching(struct cell *p_cell, struct sip_msg *ack )
204 {
205         if (get_to(ack)->tag_value.len!=p_cell->uas.local_totag.len)
206                 return 0;
207         if (memcmp(get_to(ack)->tag_value.s,p_cell->uas.local_totag.s,
208                                 p_cell->uas.local_totag.len)!=0)
209                 return 0;
210         return 1;
211 }
212
213 static inline int ack_matching(struct cell *p_cell, struct sip_msg *p_msg) 
214 {
215         /* partial dialog matching -- no to-tag, only from-tag, 
216          * callid, cseq number ; */
217         if (!partial_dlg_matching(p_cell->uas.request, p_msg)) 
218                 return 0;
219
220         /* if this transaction is proxied (as opposed to UAS) we're
221          * done now -- we ignore to-tags; the ACK simply belongs to
222          * this UAS part of dialog, whatever to-tag it gained
223          */
224         if (p_cell->relaied_reply_branch!=-2) {
225                 return 2; /* e2e proxied ACK */
226         }
227         /* it's a local dialog -- we wish to verify to-tags too */
228         if (dlg_matching(p_cell, p_msg)) {
229                 return 1;
230         }
231         return 0;
232 }
233
234 /* branch-based transaction matching */
235 static inline int via_matching( struct via_body *inv_via, 
236                                 struct via_body *ack_via )
237 {
238         if (inv_via->tid.len!=ack_via->tid.len)
239                 return 0;
240         if (memcmp(inv_via->tid.s, ack_via->tid.s,
241                                 ack_via->tid.len)!=0)
242                 return 0;
243         /* ok, tid matches -- now make sure that the
244          * originater matches too to avoid confusion with
245          * different senders generating the same tid
246          */
247         if (inv_via->host.len!=ack_via->host.len)
248                 return 0;;
249         if (memcmp(inv_via->host.s, ack_via->host.s,
250                         ack_via->host.len)!=0)
251                 return 0;
252         if (inv_via->port!=ack_via->port)
253                 return 0;
254         if (inv_via->transport.len!=ack_via->transport.len)
255                 return 0;
256         if (memcmp(inv_via->transport.s, ack_via->transport.s,
257                         ack_via->transport.len)!=0)
258                 return 0;
259         /* everything matched -- we found it */
260         return 1;
261 }
262
263
264 /* transaction matching a-la RFC-3261 using transaction ID in branch
265    (the function assumes there is magic cookie in branch) 
266    It returns:
267          2 if e2e ACK for a proxied transaction found
268      1  if found (covers ACK for local UAS)
269          0  if not found (trans undefined)
270 */
271
272 static int matching_3261( struct sip_msg *p_msg, struct cell **trans,
273                         enum request_method skip_method)
274 {
275         struct cell *p_cell;
276         struct sip_msg  *t_msg;
277         struct via_body *via1;
278         int is_ack;
279         int dlg_parsed;
280         int ret;
281
282         via1=p_msg->via1;
283         is_ack=p_msg->REQ_METHOD==METHOD_ACK;
284         dlg_parsed=0;
285         /* update parsed tid */
286         via1->tid.s=via1->branch->value.s+MCOOKIE_LEN;
287         via1->tid.len=via1->branch->value.len-MCOOKIE_LEN;
288
289         for ( p_cell = get_tm_table()->entrys[p_msg->hash_index].first_cell;
290                 p_cell; p_cell = p_cell->next_cell ) 
291         {
292                 t_msg=p_cell->uas.request;
293                 if (skip_method & t_msg->REQ_METHOD)
294                         continue;
295
296                 /* dialog matching needs to be applied for ACK/200s */
297                 if (is_ack && p_cell->uas.status<300) {
298                         /* make sure we have parsed all things we need for dialog
299                          * matching */
300                         if (!dlg_parsed) {
301                                 dlg_parsed=1;
302                                 if (!parse_dlg(p_msg)) {
303                                         LOG(L_ERR, "ERROR: tid_matching: dlg parsing failed\n");
304                                         return 0;
305                                 }
306                         }
307                         ret=ack_matching(p_cell /* t w/invite */, p_msg /* ack */);
308                         if (ret>0) {
309                                 *trans=p_cell;
310                                 return ret; /* 2: e2e proxied ACK, 1 e2e UAS ACK */
311                         }
312                         /* this ACK is neither local "negative" one, nor a proxied
313                          * end-2-end one, nor an end-2-end one for a UAS transaction
314                          * -- we failed to match */
315                         continue;
316                 }
317                 /* now real tid matching occurs  for negative ACKs and any 
318                  * other requests */
319                 if (!via_matching(t_msg->via1 /* inv via */, via1 /* ack */ ))
320                         continue;
321                 /* all matched -- we found the transaction ! */
322                 DBG("DEBUG: RFC3261 transaction matched, tid=%.*s\n",
323                         via1->tid.len, via1->tid.s);
324
325                 *trans=p_cell;
326                 return 1;
327         }
328         /* :-( ... we didn't find any */
329         DBG("DEBUG: RFC3261 transaction matching failed\n");
330         return 0;
331 }
332
333
334 /* function returns:
335  *      negative - transaction wasn't found
336  *                      (-2 = possibly e2e ACK matched )
337  *      positive - transaction found
338  */
339
340 int t_lookup_request( struct sip_msg* p_msg , int leave_new_locked )
341 {
342         struct cell         *p_cell;
343         unsigned int       isACK;
344         struct sip_msg  *t_msg;
345         int ret;
346         struct via_param *branch;
347         int match_status;
348
349         /* parse all*/
350         if (check_transaction_quadruple(p_msg)==0)
351         {
352                 LOG(L_ERR, "ERROR: TM module: t_lookup_request: too few headers\n");
353                 set_t(0);       
354                 /* stop processing */
355                 return 0;
356         }
357
358         /* start searching into the table */
359         if (!p_msg->hash_index)
360                 p_msg->hash_index=hash( p_msg->callid->body , get_cseq(p_msg)->number ) ;
361         isACK = p_msg->REQ_METHOD==METHOD_ACK;
362         DBG("t_lookup_request: start searching: hash=%d, isACK=%d\n",
363                 p_msg->hash_index,isACK);
364
365
366         /* asume not found */
367         ret=-1;
368
369         /* first of all, look if there is RFC3261 magic cookie in branch; if
370          * so, we can do very quick matching and skip the old-RFC bizzar
371          * comparison of many header fields
372          */
373         if (!p_msg->via1) {
374                 LOG(L_ERR, "ERROR: t_lookup_request: no via\n");
375                 set_t(0);       
376                 return 0;
377         }
378         branch=p_msg->via1->branch;
379         if (branch && branch->value.s && branch->value.len>MCOOKIE_LEN
380                         && memcmp(branch->value.s,MCOOKIE,MCOOKIE_LEN)==0) {
381                 /* huhuhu! the cookie is there -- let's proceed fast */
382                 LOCK_HASH(p_msg->hash_index);
383                 match_status=matching_3261(p_msg,&p_cell, 
384                                 /* skip transactions with different method; otherwise CANCEL would 
385                                  * match the previous INVITE trans.  */
386                                 isACK ? ~METHOD_INVITE: ~p_msg->REQ_METHOD);
387                 switch(match_status) {
388                                 case 0: goto notfound;  /* no match */
389                                 case 1: goto found;     /* match */
390                                 case 2: goto e2e_ack;   /* e2e proxy ACK */
391                 }
392         }
393
394         /* ok -- it's ugly old-fashioned transaction matching -- it is
395          * a bit simplified to be fast -- we don't do all the comparisons
396          * of parsed uri, which was simply too bloated */
397         DBG("DEBUG: proceeding to pre-RFC3261 transaction matching\n");
398
399         /* lock the whole entry*/
400         LOCK_HASH(p_msg->hash_index);
401
402         /* all the transactions from the entry are compared */
403         for ( p_cell = get_tm_table()->entrys[p_msg->hash_index].first_cell;
404                   p_cell; p_cell = p_cell->next_cell ) 
405         {
406                 t_msg = p_cell->uas.request;
407
408                 if (!isACK) {   
409                         /* compare lengths first */ 
410                         if (!EQ_LEN(callid)) continue;
411                         if (!EQ_LEN(cseq)) continue;
412                         if (!EQ_LEN(from)) continue;
413                         if (!EQ_LEN(to)) continue;
414                         if (ruri_matching && !EQ_REQ_URI_LEN) continue;
415                         if (!EQ_VIA_LEN(via1)) continue;
416
417                         /* length ok -- move on */
418                         if (!EQ_STR(callid)) continue;
419                         if (!EQ_STR(cseq)) continue;
420                         if (!EQ_STR(from)) continue;
421                         if (!EQ_STR(to)) continue;
422                         if (ruri_matching && !EQ_REQ_URI_STR) continue;
423                         if (!EQ_VIA_STR(via1)) continue;
424
425                         /* request matched ! */
426                         DBG("DEBUG: non-ACK matched\n");
427                         goto found;
428                 } else { /* it's an ACK request*/
429                         /* ACK's relate only to INVITEs */
430                         if (t_msg->REQ_METHOD!=METHOD_INVITE) continue;
431
432                         /* From|To URI , CallID, CSeq # must be always there */
433                         /* compare lengths now */
434                         if (!EQ_LEN(callid)) continue;
435                         /* CSeq only the number without method ! */
436                         if (get_cseq(t_msg)->number.len!=get_cseq(p_msg)->number.len)
437                                 continue;
438                         if (! EQ_LEN(from)) continue;
439                         /* To only the uri -- to many UACs screw up tags  */
440                         if (get_to(t_msg)->uri.len!=get_to(p_msg)->uri.len)
441                                 continue;
442                         if (!EQ_STR(callid)) continue;
443                         if (memcmp(get_cseq(t_msg)->number.s, get_cseq(p_msg)->number.s,
444                                 get_cseq(p_msg)->number.len)!=0) continue;
445                         if (!EQ_STR(from)) continue;
446                         if (memcmp(get_to(t_msg)->uri.s, get_to(p_msg)->uri.s,
447                                 get_to(t_msg)->uri.len)!=0) continue;
448
449                         /* it is e2e ACK/200 */
450                         if (p_cell->uas.status<300) {
451                                 /* all criteria for proxied ACK are ok */
452                                 if (p_cell->relaied_reply_branch!=-2) 
453                                         goto e2e_ack;
454                                 /* it's a local UAS transaction */
455                                 if (dlg_matching(p_cell, p_msg))
456                                         goto found;
457                                 continue;
458                         }
459
460                         /* it is not an e2e ACK/200 -- perhaps it is 
461                          * local negative case; in which case we will want
462                          * more elements to match: r-uri and via; allow
463                          * mismatching r-uri as an config option for broken
464                          * UACs */
465                         if (ruri_matching && ! EQ_REQ_URI_LEN ) continue;
466                         if (! EQ_VIA_LEN(via1)) continue;
467                         if (ruri_matching && !EQ_REQ_URI_STR) continue;
468                         if (!EQ_VIA_STR(via1)) continue;
469
470                         /* wow -- we survived all the check! we matched! */
471                         DBG("DEBUG: non-2xx ACK matched\n");
472                         goto found;
473                 } /* ACK */
474         } /* synonym loop */
475
476 notfound:
477         /* no transaction found */
478         set_t(0);
479         if (!leave_new_locked) {
480                 UNLOCK_HASH(p_msg->hash_index);
481         }
482         DBG("DEBUG: t_lookup_request: no transaction found\n");
483         return -1;
484
485 e2e_ack:
486         t_ack=p_cell;   /* e2e proxied ACK */
487         set_t(0);
488         if (!leave_new_locked) {
489                 UNLOCK_HASH(p_msg->hash_index);
490         }
491         DBG("DEBUG: t_lookup_request: e2e proxy ACK found\n");
492         return -2;
493
494 found:
495         set_t(p_cell);
496         REF_UNSAFE( T );
497         set_kr(REQ_EXIST);
498         UNLOCK_HASH( p_msg->hash_index );
499         DBG("DEBUG: t_lookup_request: transaction found (T=%p)\n",T);
500         return 1;
501 }
502
503
504
505 /* function lookups transaction being cancelled by CANCEL in p_msg;
506  * it returns:
507  *       0 - transaction wasn't found
508  *       T - transaction found
509  */
510 struct cell* t_lookupOriginalT(  struct sip_msg* p_msg )
511 {
512         struct cell     *p_cell;
513         unsigned int     hash_index;
514         struct sip_msg  *t_msg;
515         struct via_param *branch;
516         int ret;
517
518
519         /* start searching in the table */
520         hash_index = p_msg->hash_index;
521         DBG("DEBUG: t_lookupOriginalT: searching on hash entry %d\n",hash_index );
522
523
524         /* first of all, look if there is RFC3261 magic cookie in branch; if
525          * so, we can do very quick matching and skip the old-RFC bizzar
526          * comparison of many header fields
527          */
528         if (!p_msg->via1) {
529                 LOG(L_ERR, "ERROR: t_lookup_request: no via\n");
530                 set_t(0);
531                 return 0;
532         }
533         branch=p_msg->via1->branch;
534         if (branch && branch->value.s && branch->value.len>MCOOKIE_LEN
535                         && memcmp(branch->value.s,MCOOKIE,MCOOKIE_LEN)==0) {
536                 /* huhuhu! the cookie is there -- let's proceed fast */
537                 LOCK_HASH(hash_index);
538                 ret=matching_3261(p_msg, &p_cell,
539                                 /* we are seeking the original transaction --
540                                  * skip CANCEL transactions during search
541                                  */
542                                 METHOD_CANCEL);
543                 if (ret==1) goto found; else goto notfound;
544         }
545
546         /* no cookies --proceed to old-fashioned pre-3261 t-matching */
547
548         LOCK_HASH(hash_index);
549
550         /* all the transactions from the entry are compared */
551         for (p_cell=get_tm_table()->entrys[hash_index].first_cell;
552                 p_cell; p_cell = p_cell->next_cell )
553         {
554                 t_msg = p_cell->uas.request;
555
556                 /* we don't cancel CANCELs ;-) */
557                 if (p_cell->uas.request->REQ_METHOD==METHOD_CANCEL)
558                         continue;
559
560                 /* check lengths now */ 
561                 if (!EQ_LEN(callid))
562                         continue;
563                 if (get_cseq(t_msg)->number.len!=get_cseq(p_msg)->number.len)
564                         continue;
565                 if (!EQ_LEN(from))
566                         continue;
567 #ifdef CANCEL_TAG
568                 if (!EQ_LEN(to))
569                         continue;
570 #else
571                 /* relaxed matching -- we don't care about to-tags anymore,
572                  * many broken UACs screw them up and ignoring them does not
573                  * actually hurt
574                  */
575                 if (get_to(t_msg)->uri.len!=get_to(p_msg)->uri.len)
576                         continue;
577 #endif
578                 if (ruri_matching && !EQ_REQ_URI_LEN)
579                         continue;
580                 if (!EQ_VIA_LEN(via1))
581                         continue;
582
583                 /* check the content now */
584                 if (!EQ_STR(callid))
585                         continue;
586                 if (memcmp(get_cseq(t_msg)->number.s,
587                         get_cseq(p_msg)->number.s,get_cseq(p_msg)->number.len)!=0)
588                         continue;
589                 if (!EQ_STR(from))
590                         continue;
591 #ifdef CANCEL_TAG
592                 if (!EQ_STR(to))
593                         continue;
594 #else
595                 if (memcmp(get_to(t_msg)->uri.s, get_to(p_msg)->uri.s,
596                                         get_to(t_msg)->uri.len)!=0)
597                         continue;
598 #endif
599                 if (ruri_matching && !EQ_REQ_URI_STR)
600                         continue;
601                 if (!EQ_VIA_STR(via1))
602                         continue;
603
604                 /* found */
605                 goto found;
606         }
607
608 notfound:
609         /* no transaction found */
610         DBG("DEBUG: t_lookupOriginalT: no CANCEL maching found! \n" );
611         UNLOCK_HASH(hash_index);
612         DBG("DEBUG: t_lookupOriginalT completed\n");
613         return 0;
614
615 found:
616         DBG("DEBUG: t_lookupOriginalT: canceled transaction"
617                 " found (%p)! \n",p_cell );
618         REF_UNSAFE( p_cell );
619         UNLOCK_HASH(hash_index);
620         DBG("DEBUG: t_lookupOriginalT completed\n");
621         return p_cell;
622 }
623
624
625
626
627 /* Returns 0 - nothing found
628  *         1  - T found
629  */
630 int t_reply_matching( struct sip_msg *p_msg , int *p_branch )
631 {
632         struct cell*  p_cell;
633         int hash_index   = 0;
634         int entry_label  = 0;
635         int branch_id    = 0;
636         char  *hashi, *branchi, *p, *n;
637         int hashl, branchl;
638         int scan_space;
639         str cseq_method;
640         str req_method;
641
642         char *loopi;
643         int loopl;
644         char *syni;
645         int synl;
646         
647         short is_cancel;
648
649         /* make compiler warnnings happy */
650         loopi=0;
651         loopl=0;
652         syni=0;
653         synl=0;
654
655         /* split the branch into pieces: loop_detection_check(ignored),
656          hash_table_id, synonym_id, branch_id */
657
658         if (!(p_msg->via1 && p_msg->via1->branch && p_msg->via1->branch->value.s))
659                 goto nomatch2;
660
661         /* we do RFC 3261 tid matching and want to see first if there is
662          * magic cookie in branch */
663         if (p_msg->via1->branch->value.len<=MCOOKIE_LEN)
664                 goto nomatch2;
665         if (memcmp(p_msg->via1->branch->value.s, MCOOKIE, MCOOKIE_LEN)!=0)
666                 goto nomatch2;
667
668         p=p_msg->via1->branch->value.s+MCOOKIE_LEN;
669         scan_space=p_msg->via1->branch->value.len-MCOOKIE_LEN;
670
671
672         /* hash_id */
673         n=eat_token2_end( p, p+scan_space, BRANCH_SEPARATOR);
674         hashl=n-p;
675         scan_space-=hashl;
676         if (!hashl || scan_space<2 || *n!=BRANCH_SEPARATOR) goto nomatch2;
677         hashi=p;
678         p=n+1;scan_space--;
679
680         if (!syn_branch) {
681                 /* md5 value */
682                 n=eat_token2_end( p, p+scan_space, BRANCH_SEPARATOR );
683                 loopl = n-p;
684                 scan_space-= loopl;
685                 if (n==p || scan_space<2 || *n!=BRANCH_SEPARATOR) 
686                         goto nomatch2;
687                 loopi=p;
688                 p=n+1; scan_space--;
689         } else {
690                 /* synonym id */
691                 n=eat_token2_end( p, p+scan_space, BRANCH_SEPARATOR);
692                 synl=n-p;
693                 scan_space-=synl;
694                 if (!synl || scan_space<2 || *n!=BRANCH_SEPARATOR) 
695                         goto nomatch2;
696                 syni=p;
697                 p=n+1;scan_space--;
698         }
699
700         /* branch id  -  should exceed the scan_space */
701         n=eat_token_end( p, p+scan_space );
702         branchl=n-p;
703         if (!branchl ) goto nomatch2;
704         branchi=p;
705
706         /* sanity check */
707         if ((hash_index=reverse_hex2int(hashi, hashl))<0
708                 ||hash_index>=TABLE_ENTRIES
709                 || (branch_id=reverse_hex2int(branchi, branchl))<0
710                 ||branch_id>=MAX_BRANCHES
711                 || (syn_branch ? (entry_label=reverse_hex2int(syni, synl))<0 
712                         : loopl!=MD5_LEN )
713         ) {
714                 DBG("DEBUG: t_reply_matching: poor reply lables %d label %d "
715                         "branch %d\n",hash_index, entry_label, branch_id );
716                 goto nomatch2;
717         }
718
719
720         DBG("DEBUG: t_reply_matching: hash %d label %d branch %d\n",
721                 hash_index, entry_label, branch_id );
722
723
724         /* search the hash table list at entry 'hash_index'; lock the
725            entry first 
726         */
727         cseq_method=get_cseq(p_msg)->method;
728         is_cancel=cseq_method.len==CANCEL_LEN 
729                 && memcmp(cseq_method.s, CANCEL, CANCEL_LEN)==0;
730         LOCK_HASH(hash_index);
731         for (p_cell = get_tm_table()->entrys[hash_index].first_cell; p_cell; 
732                 p_cell=p_cell->next_cell) {
733
734                 /* first look if branch matches */
735
736                 if (syn_branch) {
737                         if (p_cell->label != entry_label) 
738                                 continue;
739                 } else {
740                         if ( memcmp(p_cell->md5, loopi,MD5_LEN)!=0)
741                                         continue;
742                 }
743
744                 /* sanity check ... too high branch ? */
745                 if ( branch_id>=p_cell->nr_of_outgoings )
746                         continue;
747
748                 /* does method match ? (remember -- CANCELs have the same branch
749                    as cancelled transactions) */
750                 req_method=p_cell->method;
751                 if ( /* method match */
752                         ! ((cseq_method.len==req_method.len 
753                         && memcmp( cseq_method.s, req_method.s, cseq_method.len )==0)
754                         /* or it is a local cancel */
755                         || (is_cancel && p_cell->is_invite 
756                                 /* commented out -- should_cancel_branch set it to
757                                    BUSY_BUFFER to avoid collisions with repliesl;
758                                    thus, we test here by bbuffer size
759                                 */
760                                 /* && p_cell->uac[branch_id].local_cancel.buffer ))) */
761                                 && p_cell->uac[branch_id].local_cancel.buffer_len ))) 
762                         continue;
763
764
765                 /* we passed all disqualifying factors .... the transaction has been
766                    matched !
767                 */
768                 set_t(p_cell);
769                 *p_branch = branch_id;
770                 REF_UNSAFE( T );
771                 UNLOCK_HASH(hash_index);
772                 DBG("DEBUG: t_reply_matching: reply matched (T=%p)!\n",T);
773                 /* if this is a 200 for INVITE, we will wish to store to-tags to be
774                  * able to distuingish retransmissions later and not to call
775                  * TMCB_RESPONSE_OUT uselessly; we do it only if callbacks are
776                  * enabled -- except callback customers, nobody cares about 
777                  * retransmissions of multiple 200/INV or ACK/200s
778                  */
779                 if (p_cell->is_invite && p_msg->REPLY_STATUS>=200 
780                                 && p_msg->REPLY_STATUS<300 
781                                 && ( (!p_cell->local && 
782                                         (callback_array[TMCB_RESPONSE_OUT]||
783                                                 callback_array[TMCB_E2EACK_IN]))
784                                         || (p_cell->local && callback_array[TMCB_LOCAL_COMPLETED]) )) {
785                         if (parse_headers(p_msg, HDR_TO, 0)==-1) {
786                                 LOG(L_ERR, "ERROR: t_reply_matching: to parsing failed\n");
787                         }
788                 }
789                 if (!p_cell->local) 
790                         callback_event(TMCB_RESPONSE_IN, T, p_msg, p_msg->REPLY_STATUS);
791                 return 1;
792         } /* for cycle */
793
794         /* nothing found */
795         UNLOCK_HASH(hash_index);
796         DBG("DEBUG: t_reply_matching: no matching transaction exists\n");
797
798 nomatch2:
799         DBG("DEBUG: t_reply_matching: failure to match a transaction\n");
800         *p_branch = -1;
801         set_t(0);
802         return -1;
803 }
804
805
806
807
808 /* Determine current transaction
809  *
810  *                   Found      Not Found     Error (e.g. parsing)
811  *  Return Value     1          0             -1
812  *  T                ptr        0             T_UNDEFINED
813  */
814 int t_check( struct sip_msg* p_msg , int *param_branch )
815 {
816         int local_branch;
817
818         /* is T still up-to-date ? */
819         DBG("DEBUG: t_check: msg id=%d global id=%d T start=%p\n", 
820                 p_msg->id,global_msg_id,T);
821         if ( p_msg->id != global_msg_id || T==T_UNDEFINED )
822         {
823                 global_msg_id = p_msg->id;
824                 T = T_UNDEFINED;
825                 /* transaction lookup */
826                 if ( p_msg->first_line.type==SIP_REQUEST ) {
827                         /* force parsing all the needed headers*/
828                         if (parse_headers(p_msg, HDR_EOH, 0 )==-1) {
829                                 LOG(L_ERR, "ERROR: t_check: parsing error\n");
830                                 return -1;
831                         }
832                         /* in case, we act as UAS for INVITE and reply with 200,
833                          * we will need to run dialog-matching for subsequent
834                          * ACK, for which we need From-tag; We also need from-tag
835                          * in case people want to have proxied e2e ACKs accounted
836                          */
837                         if (p_msg->REQ_METHOD==METHOD_INVITE 
838                                                         && parse_from_header(p_msg)==-1) {
839                                 LOG(L_ERR, "ERROR: t_check: from parsing failed\n");
840                                 return -1;
841                         }
842                         t_lookup_request( p_msg , 0 /* unlock before returning */ );
843                 } else {
844                         /* we need Via for branch and Cseq method to distinguish
845                            replies with the same branch/cseqNr (CANCEL)
846                         */
847                         if ( parse_headers(p_msg, HDR_VIA1|HDR_CSEQ, 0 )==-1
848                         || !p_msg->via1 || !p_msg->cseq ) {
849                                 LOG(L_ERR, "ERROR: reply cannot be parsed\n");
850                                 return -1;
851                         }
852
853                         /* if that is an INVITE, we will also need to-tag
854                            for later ACK matching
855                         */
856             if ( get_cseq(p_msg)->method.len==INVITE_LEN 
857                                 && memcmp( get_cseq(p_msg)->method.s, INVITE, INVITE_LEN )==0 ) {
858                                         if (parse_headers(p_msg, HDR_TO, 0)==-1
859                                                 || !p_msg->to)  {
860                                                 LOG(L_ERR, "ERROR: INVITE reply cannot be parsed\n");
861                                                 return -1;
862                                         }
863                         }
864
865                         t_reply_matching( p_msg ,
866                                 param_branch!=0?param_branch:&local_branch );
867
868                 }
869 #ifdef EXTRA_DEBUG
870                 if ( T && T!=T_UNDEFINED && T->damocles) {
871                         LOG( L_ERR, "ERROR: transaction %p scheduled for deletion "
872                                 "and called from t_check\n", T);
873                         abort();
874                 }
875 #endif
876                 DBG("DEBUG: t_check: msg id=%d global id=%d T end=%p\n",
877                         p_msg->id,global_msg_id,T);
878         } else {
879                 if (T)
880                         DBG("DEBUG: t_check: T alredy found!\n");
881                 else
882                         DBG("DEBUG: t_check: T previously sought and not found\n");
883         }
884
885         return T ? (T==T_UNDEFINED ? -1 : 1 ) : 0;
886 }
887
888 int init_rb( struct retr_buf *rb, struct sip_msg *msg)
889 {
890         struct socket_info* send_sock;
891         struct via_body* via;
892         int proto;
893
894         via=msg->via1;
895         if (!reply_to_via) {
896                 update_sock_struct_from_ip( &rb->dst.to, msg );
897                 proto=msg->rcv.proto;
898         } else {
899                 /*init retrans buffer*/
900                 if (update_sock_struct_from_via( &(rb->dst.to), msg, via )==-1) {
901                         LOG(L_ERR, "ERROR: init_rb: cannot lookup reply dst: %.*s\n",
902                                 via->host.len, via->host.s );
903                         ser_error=E_BAD_VIA;
904                         return 0;
905                 }
906                 proto=via->proto;
907         }
908         rb->dst.proto=proto;
909         rb->dst.proto_reserved1=msg->rcv.proto_reserved1;
910         send_sock=get_send_socket(&rb->dst.to, proto);
911         if (send_sock==0) {
912                 LOG(L_ERR, "ERROR: init_rb: cannot fwd to af %d, proto %d "
913                         "no socket\n", rb->dst.to.s.sa_family, proto);
914                 ser_error=E_BAD_VIA;
915                 return 0;
916         }
917         rb->dst.send_sock=send_sock;
918         
919     return 1;
920 }
921
922
923 static inline void init_new_t(struct cell *new_cell, struct sip_msg *p_msg)
924 {
925         struct sip_msg *shm_msg;
926
927         shm_msg=new_cell->uas.request;
928         new_cell->from.s=shm_msg->from->name.s;
929         new_cell->from.len=HF_LEN(shm_msg->from);
930         new_cell->to.s=shm_msg->to->name.s;
931         new_cell->to.len=HF_LEN(shm_msg->to);
932         new_cell->callid.s=shm_msg->callid->name.s;
933         new_cell->callid.len=HF_LEN(shm_msg->callid);
934         new_cell->cseq_n.s=shm_msg->cseq->name.s;
935         new_cell->cseq_n.len=get_cseq(shm_msg)->number.s
936                 +get_cseq(shm_msg)->number.len
937                 -shm_msg->cseq->name.s;
938
939         new_cell->method=new_cell->uas.request->first_line.u.request.method;
940         new_cell->is_invite=p_msg->REQ_METHOD==METHOD_INVITE;
941         new_cell->on_negative=get_on_negative();
942         new_cell->on_reply=get_on_reply();
943 }
944
945 static inline int new_t(struct sip_msg *p_msg)
946 {
947         struct cell *new_cell;
948
949         /* for ACK-dlw-wise matching, we want From-tags */
950         if (p_msg->REQ_METHOD==METHOD_INVITE && parse_from_header(p_msg)<0) {
951                         LOG(L_ERR, "ERROR: new_t: no valid From in INVITE\n");
952                         return E_BAD_REQ;
953         }
954         /* make sure uri will be parsed before cloning */
955         if (parse_sip_msg_uri(p_msg)<0) {
956                 LOG(L_ERR, "ERROR: new_t: uri invalid\n");
957                 return E_BAD_REQ;
958         }
959                         
960         /* add new transaction */
961         new_cell = build_cell( p_msg ) ;
962         if  ( !new_cell ){
963                 LOG(L_ERR, "ERROR: new_t: out of mem:\n");
964                 return E_OUT_OF_MEM;
965         } 
966
967         insert_into_hash_table_unsafe( new_cell );
968         set_t(new_cell);
969         INIT_REF_UNSAFE(T);
970         /* init pointers to headers needed to construct local
971            requests such as CANCEL/ACK
972         */
973         init_new_t(new_cell, p_msg);
974         return 1;
975 }
976
977 /* atomic "new_tran" construct; it returns:
978
979         <0      on error
980
981         +1      if a request did not match a transaction
982                 - it that was an ack, the calling function
983                   shall forward statelessy
984                 - otherwise it means, a new transaction was
985                   introduced and the calling function
986                   shall reply/relay/whatever_appropriate
987
988         0 on retransmission
989 */
990 int t_newtran( struct sip_msg* p_msg )
991 {
992         int lret, my_err;
993
994         ret=1;
995
996         /* is T still up-to-date ? */
997         DBG("DEBUG: t_addifnew: msg id=%d , global msg id=%d ,"
998                 " T on entrance=%p\n",p_msg->id,global_msg_id,T);
999
1000         if ( T && T!=T_UNDEFINED  ) {
1001                 LOG(L_ERR, "ERROR: t_newtran: "
1002                         "transaction already in process %p\n", T );
1003                 return E_SCRIPT;
1004         }
1005
1006         global_msg_id = p_msg->id;
1007         T = T_UNDEFINED;
1008         /* first of all, parse everything -- we will store in shared memory 
1009            and need to have all headers ready for generating potential replies 
1010            later; parsing later on demand is not an option since the request 
1011            will be in shmem and applying parse_headers to it would intermix 
1012            shmem with pkg_mem
1013         */
1014         
1015         if (parse_headers(p_msg, HDR_EOH, 0 )) {
1016                 LOG(L_ERR, "ERROR: t_newtran: parse_headers failed\n");
1017                 return E_BAD_REQ;
1018         }
1019         if ((p_msg->parsed_flag & HDR_EOH)!=HDR_EOH) {
1020                         LOG(L_ERR, "ERROR: t_newtran: EoH not parsed\n");
1021                         return E_OUT_OF_MEM;
1022         }
1023         /* t_lookup_requests attmpts to find the transaction; 
1024            it also calls check_transaction_quadruple -> it is
1025            safe to assume we have from/callid/cseq/to
1026         */ 
1027         lret = t_lookup_request( p_msg, 1 /* leave locked if not found */ );
1028
1029         /* on error, pass the error in the stack ... nothing is locked yet
1030            if 0 is returned */
1031         if (lret==0) return E_BAD_TUPEL;
1032
1033         /* transaction found, it's a retransmission  */
1034         if (lret>0) {
1035                 if (p_msg->REQ_METHOD==METHOD_ACK) {
1036                         t_release_transaction(T);
1037                 } else {
1038                         t_retransmit_reply(T);
1039                 }
1040                 /* things are done -- return from script */
1041                 return 0;
1042         }
1043
1044         /* from now on, be careful -- hash table is locked */
1045
1046         if (lret==-2) { /* was it an e2e ACK ? if so, trigger a callback */
1047                 /* no callbacks? complete quickly */
1048                 if (!callback_array[TMCB_E2EACK_IN]) {
1049                         UNLOCK_HASH(p_msg->hash_index);
1050                         return 1;
1051                 } 
1052                 REF_UNSAFE(t_ack);
1053                 UNLOCK_HASH(p_msg->hash_index);
1054                 /* we don't call from within REPLY_LOCK -- that introduces
1055                    a race condition; however, it is so unlikely and the
1056                    impact is so small (callback called multiple times of
1057            multiple ACK/200s received in parallel), that we do not
1058                     better waste time in locks
1059                  */
1060                 if (unmatched_totag(t_ack, p_msg)) {
1061                         callback_event( TMCB_E2EACK_IN, t_ack, p_msg, 
1062                                 p_msg->REQ_METHOD );
1063                 }
1064                 UNREF(t_ack);
1065                 return 1;
1066         } 
1067
1068
1069         /* transaction not found, it's a new request (lret<0, lret!=-2);
1070            establish a new transaction ... */
1071         if (p_msg->REQ_METHOD==METHOD_ACK) { /* ... unless it is in ACK */
1072                 my_err=1;
1073                 goto new_err;
1074         }
1075
1076         my_err=new_t(p_msg);
1077         if (my_err<0) {
1078                 LOG(L_ERR, "ERROR: t_newtran: new_t failed\n");
1079                 goto new_err;
1080         }
1081
1082
1083         UNLOCK_HASH(p_msg->hash_index);
1084         /* now, when the transaction state exists, check if
1085            there is a meaningful Via and calculate it; better
1086            do it now than later: state is established so that
1087            subsequent retransmissions will be absorbed and will
1088           not possibly block during Via DNS resolution; doing
1089            it later would only burn more CPU as if there is an
1090            error, we cannot relay later whatever comes out of the
1091            the transaction 
1092         */
1093         if (!init_rb( &T->uas.response, p_msg)) {
1094                 LOG(L_ERR, "ERROR: t_newtran: unresolveable via1\n");
1095                 put_on_wait( T );
1096                 t_unref(p_msg);
1097                 return E_BAD_VIA;
1098         }
1099
1100         return 1;
1101
1102
1103 new_err:
1104         UNLOCK_HASH(p_msg->hash_index);
1105         return my_err;
1106
1107 }
1108
1109
1110 int t_unref( struct sip_msg* p_msg  )
1111 {
1112         enum kill_reason kr;
1113
1114         if (T==T_UNDEFINED || T==T_NULL_CELL)
1115                 return -1;
1116         if (p_msg->first_line.type==SIP_REQUEST){
1117                 kr=get_kr();
1118                 if (kr==0 
1119                                 ||(p_msg->REQ_METHOD==METHOD_ACK && !(kr & REQ_RLSD))) {
1120                         LOG(L_WARN, "WARNING: script writer didn't release transaction\n");
1121                         t_release_transaction(T);
1122                 }
1123         }
1124         UNREF( T );
1125         set_t(T_UNDEFINED);
1126         return 1;
1127 }
1128
1129 int t_get_trans_ident(struct sip_msg* p_msg, unsigned int* hash_index, unsigned int* label)
1130 {
1131     struct cell* t;
1132     if(t_check(p_msg,0) != 1){
1133         LOG(L_ERR,"ERROR: t_get_trans_ident: no transaction found\n");
1134         return -1;
1135     }
1136     t = get_t();
1137     if(!t){
1138         LOG(L_ERR,"ERROR: t_get_trans_ident: transaction found is NULL\n");
1139         return -1;
1140     }
1141     
1142     *hash_index = t->hash_index;
1143     *label = t->label;
1144
1145     return 1;
1146 }
1147
1148 int t_lookup_ident(struct cell ** trans, unsigned int hash_index, unsigned int label)
1149 {
1150     struct cell* p_cell;
1151
1152     if(hash_index >= TABLE_ENTRIES){
1153                 LOG(L_ERR,"ERROR: t_lookup_ident: invalid hash_index=%u\n",hash_index);
1154                 return -1;
1155     }
1156
1157     LOCK_HASH(hash_index);
1158
1159     /* all the transactions from the entry are compared */
1160     for ( p_cell = get_tm_table()->entrys[hash_index].first_cell;
1161           p_cell; p_cell = p_cell->next_cell ) 
1162     {
1163                 if(p_cell->label == label){
1164                         REF_UNSAFE(p_cell);
1165                         UNLOCK_HASH(hash_index);
1166                         set_t(p_cell);
1167                         *trans=p_cell;
1168                         DBG("DEBUG: t_lookup_ident: transaction found\n");
1169                         return 1;
1170                 }
1171     }
1172         
1173         UNLOCK_HASH(hash_index);
1174         set_t(0);
1175         *trans=p_cell;
1176
1177         DBG("DEBUG: t_lookup_ident: transaction not found\n");
1178     
1179     return -1;
1180 }
1181
1182 int t_is_local(struct sip_msg* p_msg)
1183 {
1184     struct cell* t;
1185     if(t_check(p_msg,0) != 1){
1186         LOG(L_ERR,"ERROR: t_is_local: no transaction found\n");
1187         return -1;
1188     }
1189     t = get_t();
1190     if(!t){
1191         LOG(L_ERR,"ERROR: t_is_local: transaction found is NULL\n");
1192         return -1;
1193     }
1194     
1195     return t->local;
1196 }