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