tm: no reason modparams if compiled with no cancelr. support
[sip-router] / modules / tm / h_table.h
1 /*
2  * $Id$
3  *
4  * Copyright (C) 2001-2003 FhG Fokus
5  *
6  * This file is part of SIP-router, a free SIP server.
7  *
8  * SIP-router is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version
12  *
13  * SIP-router is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License 
19  * along with this program; if not, write to the Free Software 
20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
21  *
22  * History:
23  * --------
24  * 2003-03-16  removed _TOTAG (jiri)
25  * 2003-03-06  we keep a list of 200/INV to-tags now (jiri)
26  * 2003-03-01  kr set through a function now (jiri)
27  * 2003-12-04  callbacks per transaction added; completion callback
28  *             merge into them as LOCAL_COMPETED (bogdan)
29  * 2004-02-11  FIFO/CANCEL + alignments (hash=f(callid,cseq)) (uli+jiri)
30  * 2004-02-13  t->is_invite, t->local, t->noisy_ctimer replaced
31  *             with flags (bogdan)
32  * 2004-08-23  avp support added - avp list linked in transaction (bogdan)
33  * 2005-11-03  updated to the new timer interface (dropped tm timers) (andrei)
34  * 2006-08-11  dns failover support (andrei)
35  * 2007-05-29  switch ref_count to atomic and delete a cell automatically on
36  *             UNREF if the ref_count reaches 0 (andrei)
37  * 2007-06-01  support for different retransmissions intervals per transaction;
38  *             added maximum inv. and non-inv. transaction life time (andrei)
39  * 2007-06-06  switched tm bucket list to a simpler and faster clist;
40  *              inlined often used functions (andrei)
41  */
42
43 /**  TM :: hash table, flags and other general defines.
44  * @file 
45  * @ingroup tm
46  */
47
48
49 #ifndef _H_TABLE_H
50 #define _H_TABLE_H
51
52 #include "defs.h"
53 #include "t_stats.h"
54
55 #define TM_DEL_UNREF
56 /* uncomment the next define if you wish to keep hash statistics*/
57 /*
58 #define TM_HASH_STATS
59 */
60 /* use hash stats always in debug mode */
61 #ifdef EXTRA_DEBUG
62 #ifndef TM_HASH_STATS
63 #define TM_HASH_STATS
64 #endif
65 #endif
66
67
68 #include "../../clist.h"
69 #include "../../parser/msg_parser.h"
70 #include "../../types.h"
71 #include "../../md5utils.h"
72 #include "../../usr_avp.h"
73 #ifdef WITH_XAVP
74 #include "../../xavp.h"
75 #endif
76 #include "../../timer.h"
77 #include "../../flags.h"
78 #include "../../atomic_ops.h"
79 #include "../../hash_func.h"
80 #include "config.h"
81
82 /* if TM_DIFF_RT_TIMEOUT is defined, different retransmissions timeouts
83  * can be used for each transaction, at a small memory cost
84  * (extra 4 bytes/transaction) */
85 #define TM_DIFF_RT_TIMEOUT
86
87
88 struct s_table;
89 struct entry;
90 struct cell;
91 struct timer;
92 struct retr_buf;
93 struct ua_client;
94
95 #include "../../mem/shm_mem.h"
96 #include "lock.h"
97 #include "sip_msg.h"
98 #include "t_reply.h"
99 #include "t_hooks.h"
100 #ifdef USE_DNS_FAILOVER
101 #include "../../dns_cache.h"
102 #endif
103
104
105 #define LOCK_HASH(_h) lock_hash((_h))
106 #define UNLOCK_HASH(_h) unlock_hash((_h))
107
108 void lock_hash(int i);
109 void unlock_hash(int i);
110
111
112 #define NO_CANCEL       ( (char*) 0 )
113 #define EXTERNAL_CANCEL ( (char*) -1)
114
115 #define TYPE_LOCAL_ACK    -2
116 #define TYPE_LOCAL_CANCEL -1
117 #define TYPE_REQUEST       0
118
119 /* to be able to assess whether a script writer forgot to
120    release a transaction and leave it for ever in memory,
121    we mark it with operations done over it; if none of these
122    flags is set and script is being left, it is a sign of
123    script error and we need to release on writer's
124    behalf
125
126    REQ_FWDED means there is a UAC with final response timer
127              ticking. If it hits, transaction will be completed.
128    REQ_RPLD means that a transaction has been replied -- either
129             it implies going to wait state, or for invite transactions
130             FR timer is ticking until ACK arrives
131    REQ_RLSD means that a transaction was put on wait explicitly
132             from t_release_transaction
133    REQ_EXIST means that this request is a retransmission which does not
134             affect transactional state
135    REQ_ERR_DELAYED mean that tm wants to send  reply(ser_error) but it
136             delayed it to end-of-script to allow it to be overriden.
137             If this is set and all of the above flag are not => send reply
138             on end of script. If any of the above flags is set, do not
139             send (especially REQ_RPLD and REQ_RLSD).
140 */
141 enum kill_reason { REQ_FWDED=1, REQ_RPLD=2, REQ_RLSD=4, REQ_EXIST=8,
142                                    REQ_ERR_DELAYED=16 };
143
144
145 /* #define F_RB_T_ACTIVE                0x01  (obsolete) fr or retr active */
146 #define F_RB_T2                         0x02
147 #define F_RB_RETR_DISABLED      0x04 /* retransmission disabled */
148 #define F_RB_FR_INV     0x08 /* timer switched to FR_INV */
149 #define F_RB_TIMEOUT    0x10 /* timeout */
150 #define F_RB_REPLIED    0x20 /* reply received */
151 #define F_RB_CANCELED   0x40 /* rb/branch canceled */
152 #define F_RB_DEL_TIMER  0x80 /* timer should be deleted if active */
153 #define F_RB_NH_LOOSE   0x100 /* next hop is a loose router */
154 #define F_RB_NH_STRICT  0x200 /* next hop is a strict router */
155 /* must detect when neither loose nor strict flag is set -> two flags.
156  * alternatively, 1x flag for strict/loose and 1x for loose|strict set/not */
157
158
159 /* if canceled or intended to be canceled, return true */
160 #define uac_dont_fork(uac)      ((uac)->local_cancel.buffer)
161
162
163 typedef struct retr_buf
164 {
165         short activ_type;
166         /* set to status code if the buffer is a reply,
167         0 if request or -1 if local CANCEL */
168         volatile unsigned short flags; /* DISABLED, T2 */
169         volatile unsigned char t_active; /* timer active */
170         unsigned short branch; /* no more then 65k branches :-) */
171         short buffer_len;
172         char *buffer;
173         /*the cell that contains this retrans_buff*/
174         struct cell* my_T;
175         struct timer_ln timer;
176         struct dest_info dst;
177         ticks_t retr_expire;
178         ticks_t fr_expire; /* ticks value after which fr. will fire */
179 }retr_buf_type;
180
181
182
183 /* User Agent Server content */
184
185 typedef struct ua_server
186 {
187         struct sip_msg   *request;
188         char             *end_request;
189         struct retr_buf  response;
190         /* keep to-tags for local 200 replies for INVITE -- 
191          * we need them for dialog-wise matching of ACKs;
192          * the pointer shows to shmem-ed reply */
193         str                              local_totag;
194 #ifdef CANCEL_REASON_SUPPORT
195         struct cancel_reason* cancel_reas; /* pointer to cancel reason, used
196                                                                                   for e2e cancels */
197 #endif /* CANCEL_REASON_SUPPORT */
198         unsigned int     status;
199 }ua_server_type;
200
201
202
203 /* User Agent Client content */
204
205 #define TM_UAC_FLAGS
206 #ifdef TM_UAC_FLAGS
207 /* UAC internal flags */
208 #define TM_UAC_FLAG_RR  1       /* Record-Route applied */
209 #define TM_UAC_FLAG_R2  2       /* 2nd Record-Route applied */
210 #define TM_UAC_FLAG_FB  4       /* Mark first entry in new branch set */
211 #endif
212
213 typedef struct ua_client
214 {
215         /* if we store a reply (branch picking), this is where it is */
216         struct sip_msg  *reply;
217         struct retr_buf  request;
218         /* we maintain a separate copy of cancel rather than
219            reuse the structure for original request; the 
220            original request is no longer needed but its delayed
221            timer may fire and interfere with whoever tries to
222            rewrite it
223         */
224         struct retr_buf local_cancel;
225         /* pointer to retransmission buffer where uri is printed;
226            good for generating ACK/CANCEL */
227 #ifdef USE_DNS_FAILOVER
228         struct dns_srv_handle dns_h;
229 #endif
230         str uri;
231         str path;
232         /* if we don't store, we at least want to know the status */
233         int             last_received;
234
235 #ifdef TM_UAC_FLAGS
236         /* internal flags per tm uac */
237         unsigned int flags;
238 #endif
239         flag_t branch_flags;
240 #ifdef WITH_AS_SUPPORT
241         /**
242          * Resent for every rcvd 2xx reply.
243          * This member's as an alternative to passing the reply to the AS, 
244          * every time a reply for local request is rcvd.
245          * Member can not be union'ed with local_cancel, since CANCEL can happen
246          * concurrently with a 2xx reply (to generate an ACK).
247          */
248         struct retr_buf *local_ack;
249 #endif
250 }ua_client_type;
251
252
253 struct totag_elem {
254         struct totag_elem *next;
255         str tag;
256         volatile int acked;
257 };
258
259
260
261 /* transaction's flags */
262 /* is the transaction's request an INVITE? */
263 #define T_IS_INVITE_FLAG     (1<<0)
264 /* is this a transaction generated by local request? */
265 #define T_IS_LOCAL_FLAG      (1<<1)
266 /* set to one if you want to disallow silent transaction
267    dropping when C timer hits */
268 #define T_NOISY_CTIMER_FLAG  (1<<2)
269 /* transaction canceled
270  * WARNING: this flag can be set outside reply lock from e2e_cancel().
271  * If a future flag could be affected by a race w/ e2e_cancel() the code
272  * should be changed.*/
273 #define T_CANCELED           (1<<3)
274 /* 6xx received => stop forking */
275 #define T_6xx            (1<<4) 
276
277 #define T_IN_AGONY (1<<5) /* set if waiting to die (delete timer)
278                              TODO: replace it with del on unref */
279 #define T_AUTO_INV_100 (1<<6) /* send an 100 reply automatically  to inv. */
280 #ifdef WITH_AS_SUPPORT
281         /* don't generate automatically an ACK for local transaction */
282 #       define T_NO_AUTO_ACK    (1<<7)
283 #endif
284
285 #define T_DISABLE_6xx (1<<8) /* treat 6xx as a normal reply */
286 #define T_DISABLE_FAILOVER (1<<9) /* don't perform dns failover */
287 #ifdef CANCEL_REASON_SUPPORT
288 #define T_NO_E2E_CANCEL_REASON (1<<10) /* don't propagate CANCEL Reason */
289 #endif /* CANCEL_REASON_SUPPORT */
290 #define T_DONT_FORK   (T_CANCELED|T_6xx)
291
292 /* unsigned short should be enough for a retr. timer: max. 65535 ticks =>
293  * max  retr. = 1023 s for tick = 15 ms, which should be more then enough and
294  * saves us 2*2 bytes */
295 typedef unsigned short retr_timeout_t;
296
297 /* transaction context */
298
299 typedef struct cell
300 {
301         /* linking data */
302         /* WARNING: don't move or change order of next_c or prev_c
303          * or breakage will occur */
304         struct cell*     next_c;
305         struct cell*     prev_c;
306         /* tells in which hash table entry the cell lives */
307         unsigned int  hash_index;
308         /* sequence number within hash collision slot */
309         unsigned int  label;
310         /* different information about the transaction */
311         unsigned short flags;
312         /* number of forks */
313         short nr_of_outgoings;
314
315 #ifdef TM_DEL_UNREF
316         /* every time the transaction/cell is referenced from somewhere this
317          * ref_count should be increased (via REF()) and every time the reference
318          * is removed the ref_count should be decreased (via UNREF()).
319          * This includes adding the cell to the hash table (REF() before adding)
320          * and removing it from the hash table (UNREF_FREE() after unlinking).
321          * Exception: it does not include starting/stopping timers (timers are 
322          * forced-stopped every time when ref_count reaches 0)
323          * If the cell is no longer referenced (ref_count==0 after an UNREF),
324          * it will be automatically deleted by the UNREF() operation.
325          */
326         atomic_t ref_count;
327 #else 
328         /* how many processes are currently processing this transaction ;
329            note that only processes working on a request/reply belonging
330            to a transaction increase ref_count -- timers don't, since we
331            rely on transaction state machine to clean-up all but wait timer
332            when entering WAIT state and the wait timer is the only place
333            from which a transaction can be deleted (if ref_count==0); good
334            for protecting from conditions in which wait_timer hits and
335            tries to delete a transaction whereas at the same time 
336            a delayed message belonging to the transaction is received */
337         volatile unsigned int ref_count;
338 #endif
339
340         /* needed for generating local ACK/CANCEL for local
341            transactions; all but cseq_n include the entire
342            header field value, cseq_n only Cseq number; with
343            local transactions, pointers point to outbound buffer,
344            with proxied transactions to inbound request */
345         str from, callid, cseq_n, to;
346         /* method shortcut -- for local transactions, pointer to
347            outbound buffer, for proxies transactions pointer to
348            original message; needed for reply matching */
349         str method;
350
351         /* head of callback list */
352         struct tmcb_head_list tmcb_hl;
353
354         /* bindings to wait and delete timer */
355         struct timer_ln wait_timer; /* used also for delete */
356
357         /* UA Server */
358         struct ua_server  uas;
359         /* UA Clients */
360         struct ua_client  uac[ MAX_BRANCHES ];
361         
362         /* to-tags of 200/INVITEs which were received from downstream and 
363          * forwarded or passed to UAC; note that there can be arbitrarily 
364          * many due to downstream forking; */
365         struct totag_elem *fwded_totags;
366
367              /* list with avp */
368         struct usr_avp *uri_avps_from;
369         struct usr_avp *uri_avps_to;
370         struct usr_avp *user_avps_from;
371         struct usr_avp *user_avps_to;
372         struct usr_avp *domain_avps_from;
373         struct usr_avp *domain_avps_to;
374 #ifdef WITH_XAVP
375         sr_xavp_t *xavps_list;
376 #endif
377
378         /* protection against concurrent reply processing */
379         ser_lock_t   reply_mutex;
380         
381         ticks_t fr_timeout;     /* final response interval for retr_bufs */
382         ticks_t fr_inv_timeout; /* final inv. response interval for retr_bufs */
383 #ifdef TM_DIFF_RT_TIMEOUT
384         retr_timeout_t rt_t1_timeout; /* start retr. interval for retr_bufs */
385         retr_timeout_t rt_t2_timeout; /* maximum retr. interval for retr_bufs */
386 #endif
387         ticks_t end_of_life; /* maximum lifetime */
388
389         /* nr of replied branch; 0..MAX_BRANCHES=branch value,
390          * -1 no reply, -2 local reply */
391         short relayed_reply_branch;
392
393         /* the route to take if no final positive reply arrived */
394         unsigned short on_negative;
395         /* the onreply_route to be processed if registered to do so */
396         unsigned short on_reply;
397          /* The route to take for each downstream branch separately */
398         unsigned short on_branch;
399
400         /* place holder for MD5checksum  (meaningful only if syn_branch=0) */
401         char md5[0]; /* if syn_branch==0 then MD5_LEN bytes are extra alloc'ed*/
402
403 }cell_type;
404
405
406 #if 0
407 /* warning: padding too much => big size increase */
408 #define ENTRY_PAD_TO  128 /* should be a multiple of cacheline size for 
409                              best performance*/
410 #define ENTRY_PAD_BYTES  \
411         (ENTRY_PAD_TO-2*sizeof(struct cell*)+sizeof(ser_lock_t)+sizeof(int)+ \
412                                         2*sizeof(long))
413 #else
414 #define ENTRY_PAD_BYTES 0
415 #endif
416
417 /* double-linked list of cells with hash synonyms */
418 typedef struct entry
419 {
420         /* WARNING: don't move or change order of next_c or prev_c
421          * or breakage will occur */
422         struct cell*    next_c; 
423         struct cell*    prev_c;
424         /* sync mutex */
425         ser_lock_t      mutex;
426         /* currently highest sequence number in a synonym list */
427         unsigned int    next_label;
428 #ifdef TM_HASH_STATS
429         unsigned long acc_entries;
430         unsigned long cur_entries;
431 #endif
432         char _pad[ENTRY_PAD_BYTES];
433 }entry_type;
434
435
436
437 /* transaction table */
438 struct s_table
439 {
440         /* table of hash entries; each of them is a list of synonyms  */
441         struct entry   entries[ TABLE_ENTRIES ];
442 };
443
444 /* pointer to the big table where all the transaction data
445    lives */
446 extern struct s_table*  _tm_table; /* private internal stuff, don't touch
447                                                                           directly */
448
449 #define list_entry(ptr, type, member) \
450         ((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member)))
451
452 #define get_retr_timer_payload(_tl_) \
453         list_entry( _tl_, struct retr_buf, retr_timer)
454 #define get_fr_timer_payload(_tl_) \
455         list_entry( _tl_, struct retr_buf, fr_timer)
456 #define get_wait_timer_payload(_tl_) \
457         list_entry( _tl_, struct cell, wait_tl)
458 #define get_dele_timer_payload(_tl_) \
459         list_entry( _tl_, struct cell, dele_tl)
460
461 #define get_T_from_reply_rb(_rb_) \
462         list_entry( list_entry( _rb_, (struct ua_server), response),\
463                 struct cell, uas)
464 #define get_T_from_request_rb(_rb_, _br_) \
465         list_entry( list_entry( (rb_, (struct ua_client), request) - \
466                 (_br_)*sizeof(struct retr_buf), struct cell, uas)
467 #define get_T_from_cancel_rb(_rb_, _br_) \
468         list_entry( list_entry( (rb_, (struct ua_client), local_cancel) - \
469                 (_br_)*sizeof(struct retr_buf), struct cell, uas)
470
471 #define is_invite(_t_)           ((_t_)->flags&T_IS_INVITE_FLAG)
472 #define is_local(_t_)            ((_t_)->flags&T_IS_LOCAL_FLAG)
473 #define has_noisy_ctimer(_t_)    ((_t_)->flags&T_NOISY_CTIMER_FLAG)
474 #define was_cancelled(_t_)       ((_t_)->flags&T_CANCELED)
475 #define no_new_branches(_t_)     ((_t_)->flags&T_6xx)
476
477
478 void reset_kr();
479 void set_kr( enum kill_reason kr );
480 enum kill_reason get_kr();
481
482 #define get_tm_table() (_tm_table)
483
484 struct s_table* init_hash_table();
485 void   free_hash_table( );
486 void   free_cell( struct cell* dead_cell );
487 struct cell*  build_cell( struct sip_msg* p_msg );
488
489 #ifdef TM_HASH_STATS
490 unsigned int transaction_count( void );
491 #endif
492
493
494 /*  Takes an already created cell and links it into hash table on the
495  *  appropriate entry. */
496 inline static void insert_into_hash_table_unsafe( struct cell * p_cell,
497                                                                                                         unsigned int hash )
498 {
499         p_cell->label = _tm_table->entries[hash].next_label++;
500 #ifdef EXTRA_DEBUG
501         DEBUG("cell label: %u\n", p_cell->label);
502 #endif
503         p_cell->hash_index=hash;
504         /* insert at the beginning */
505         clist_insert(&_tm_table->entries[hash], p_cell, next_c, prev_c);
506
507         /* update stats */
508 #ifdef TM_HASH_STATS
509         _tm_table->entries[hash].cur_entries++;
510         _tm_table->entries[hash].acc_entries++;
511 #endif
512         t_stats_new( is_local(p_cell) );
513 }
514
515
516
517 /*  Un-link a  cell from hash_table, but the cell itself is not released */
518 inline static void remove_from_hash_table_unsafe( struct cell * p_cell)
519 {
520         clist_rm(p_cell, next_c, prev_c);
521 #       ifdef EXTRA_DEBUG
522 #ifdef TM_HASH_STATS
523         if (_tm_table->entries[p_cell->hash_index].cur_entries==0){
524                 LOG(L_CRIT, "BUG: bad things happened: cur_entries=0\n");
525                 abort();
526         }
527 #endif
528 #       endif
529 #ifdef TM_HASH_STATS
530         _tm_table->entries[p_cell->hash_index].cur_entries--;
531 #endif
532         t_stats_deleted( is_local(p_cell) );
533 }
534
535 #endif
536
537