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