- tm on_send callbacks support: if such a callback is registered it will be
[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 ser, a free SIP server.
7  *
8  * ser 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  * For a license to use the ser software under conditions
14  * other than those described here, or to purchase support for this
15  * software, please contact iptel.org by e-mail at the following addresses:
16  *    info@iptel.org
17  *
18  * ser is distributed in the hope that it will be useful,
19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21  * GNU General Public License for more details.
22  *
23  * You should have received a copy of the GNU General Public License 
24  * along with this program; if not, write to the Free Software 
25  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
26  *
27  * History:
28  * --------
29  * 2003-03-16  removed _TOTAG (jiri)
30  * 2003-03-06  we keep a list of 200/INV to-tags now (jiri)
31  * 2003-03-01  kr set through a function now (jiri)
32  * 2003-12-04  callbacks per transaction added; completion callback
33  *             merge into them as LOCAL_COMPETED (bogdan)
34  * 2004-02-11  FIFO/CANCEL + alignments (hash=f(callid,cseq)) (uli+jiri)
35  * 2004-02-13  t->is_invite, t->local, t->noisy_ctimer replaced
36  *             with flags (bogdan)
37  * 2004-08-23  avp support added - avp list linked in transaction (bogdan)
38  * 2005-11-03  updated to the new timer interface (dropped tm timers) (andrei)
39  * 2006-08-11  dns failover support (andrei)
40  */
41
42 #include "defs.h"
43
44
45 #ifndef _H_TABLE_H
46 #define _H_TABLE_H
47
48 /*
49  #include <stdio.h>
50  #include <stdlib.h>
51 */
52
53 #include "../../parser/msg_parser.h"
54 #include "../../types.h"
55 #include "../../md5utils.h"
56 #include "../../usr_avp.h"
57 #include "../../timer.h"
58 #include "config.h"
59
60 struct s_table;
61 struct entry;
62 struct cell;
63 struct timer;
64 struct retr_buf;
65
66 #include "../../mem/shm_mem.h"
67 #include "lock.h"
68 #include "sip_msg.h"
69 #include "t_reply.h"
70 #include "t_hooks.h"
71 #ifdef USE_DNS_FAILOVER
72 #include "../../dns_cache.h"
73 #endif
74
75 #define LOCK_HASH(_h) lock_hash((_h))
76 #define UNLOCK_HASH(_h) unlock_hash((_h))
77
78 void lock_hash(int i);
79 void unlock_hash(int i);
80
81
82 #define NO_CANCEL       ( (char*) 0 )
83 #define EXTERNAL_CANCEL ( (char*) -1)
84
85 #define TYPE_LOCAL_ACK    -2
86 #define TYPE_LOCAL_CANCEL -1
87 #define TYPE_REQUEST       0
88
89 /* to be able to assess whether a script writer forgot to
90    release a transaction and leave it for ever in memory,
91    we mark it with operations done over it; if none of these
92    flags is set and script is being left, it is a sign of
93    script error and we need to release on writer's
94    behalf
95
96    REQ_FWDED means there is a UAC with final response timer
97              ticking. If it hits, transaction will be completed.
98    REQ_RPLD means that a transaction has been replied -- either
99             it implies going to wait state, or for invite transactions
100             FR timer is ticking until ACK arrives
101    REQ_RLSD means that a transaction was put on wait explicitly
102             from t_release_transaction
103    REQ_EXIST means that this request is a retransmission which does not
104             affect transactional state
105 */
106 enum kill_reason { REQ_FWDED=1, REQ_RPLD=2, REQ_RLSD=4, REQ_EXIST=8 };
107
108
109 /* #define F_RB_T_ACTIVE                0x01  (obsolete) fr or retr active */
110 #define F_RB_T2                         0x02
111 #define F_RB_RETR_DISABLED      0x04 /* retransmission disabled */
112 #define F_RB_FR_INV     0x08 /* timer switched to FR_INV */
113 #define F_RB_TIMEOUT    0x10 /* timeout */
114 #define F_RB_REPLIED    0x20 /* reply received */
115
116
117 /* if canceled or intended to be canceled, return true */
118 #define uac_dont_fork(uac)      ((uac)->local_cancel.buffer)
119
120
121 typedef struct retr_buf
122 {
123         short activ_type;
124         /* set to status code if the buffer is a reply,
125         0 if request or -1 if local CANCEL */
126         volatile unsigned char flags; /* DISABLED, T2 */
127         volatile unsigned char t_active; /* timer active */
128         unsigned short branch; /* no more then 65k branches :-) */
129         short   buffer_len;
130         char *buffer;
131         /*the cell that contains this retrans_buff*/
132         struct cell* my_T;
133         struct timer_ln timer;
134         struct dest_info dst;
135         ticks_t retr_expire;
136         ticks_t fr_expire; /* ticks value after which fr. will fire */
137 }retr_buf_type;
138
139
140
141 /* User Agent Server content */
142
143 typedef struct ua_server
144 {
145         struct sip_msg   *request;
146         char             *end_request;
147         struct retr_buf  response;
148         /* keep to-tags for local 200 replies for INVITE -- 
149          * we need them for dialog-wise matching of ACKs;
150          * the pointer shows to shmem-ed reply */
151         str                              local_totag;
152         unsigned int     status;
153 }ua_server_type;
154
155
156
157 /* User Agent Client content */
158
159 typedef struct ua_client
160 {
161         /* if we store a reply (branch picking), this is where it is */
162         struct sip_msg  *reply;
163         struct retr_buf  request;
164         /* we maintain a separate copy of cancel rather than
165            reuse the structure for original request; the 
166            original request is no longer needed but its delayed
167            timer may fire and interfere with whoever tries to
168            rewrite it
169         */
170         struct retr_buf local_cancel;
171         /* pointer to retransmission buffer where uri is printed;
172            good for generating ACK/CANCEL */
173 #ifdef USE_DNS_FAILOVER
174         struct dns_srv_handle dns_h;
175 #endif
176         str              uri;
177         /* if we don't store, we at least want to know the status */
178         int             last_received;
179 }ua_client_type;
180
181
182 struct totag_elem {
183         struct totag_elem *next;
184         str tag;
185         short acked;
186 };
187
188
189
190 /* transaction's flags */
191 /* is the transaction's request an INVITE? */
192 #define T_IS_INVITE_FLAG     (1<<0)
193 /* is this a transaction generated by local request? */
194 #define T_IS_LOCAL_FLAG      (1<<1)
195 /* set to one if you want to disallow silent transaction
196    dropping when C timer hits */
197 #define T_NOISY_CTIMER_FLAG  (1<<2)
198 /* transaction canceled */
199 #define T_CANCELED           (1<<3)
200 /* 6xx received => stop forking */
201 #define T_6xx            (1<<4) 
202
203 #define T_IN_AGONY (1<<5) /* set if waiting to die (delete timer)
204                              TODO: replace it with del on unref */
205
206 #define T_DONT_FORK   (T_CANCELED|T_6xx)
207
208
209
210 /* transaction context */
211
212 typedef struct cell
213 {
214         /* linking data */
215         struct cell*     next_cell;
216         struct cell*     prev_cell;
217         /* tells in which hash table entry the cell lives */
218         unsigned int  hash_index;
219         /* sequence number within hash collision slot */
220         unsigned int  label;
221         /* different information about the transaction */
222         unsigned short flags;
223         /* number of forks */
224         short nr_of_outgoings;
225
226         /* how many processes are currently processing this transaction ;
227            note that only processes working on a request/reply belonging
228            to a transaction increase ref_count -- timers don't, since we
229            rely on transaction state machine to clean-up all but wait timer
230            when entering WAIT state and the wait timer is the only place
231            from which a transaction can be deleted (if ref_count==0); good
232            for protecting from conditions in which wait_timer hits and
233            tries to delete a transaction whereas at the same time 
234            a delayed message belonging to the transaction is received */
235         volatile unsigned int ref_count;
236
237         /* needed for generating local ACK/CANCEL for local
238            transactions; all but cseq_n include the entire
239            header field value, cseq_n only Cseq number; with
240            local transactions, pointers point to outbound buffer,
241            with proxied transactions to inbound request */
242         str from, callid, cseq_n, to;
243         /* method shortcut -- for local transactions, pointer to
244            outbound buffer, for proxies transactions pointer to
245            original message; needed for reply matching */
246         str method;
247
248         /* head of callback list */
249         struct tmcb_head_list tmcb_hl;
250
251         /* bindings to wait and delete timer */
252         struct timer_ln wait_timer; /* used also for delete */
253
254         /* UA Server */
255         struct ua_server  uas;
256         /* UA Clients */
257         struct ua_client  uac[ MAX_BRANCHES ];
258         
259         /* to-tags of 200/INVITEs which were received from downstream and 
260          * forwarded or passed to UAC; note that there can be arbitrarily 
261          * many due to downstream forking; */
262         struct totag_elem *fwded_totags;
263
264              /* list with avp */
265         struct usr_avp *uri_avps_from;
266         struct usr_avp *uri_avps_to;
267         struct usr_avp *user_avps_from;
268         struct usr_avp *user_avps_to;
269         struct usr_avp *domain_avps_from;
270         struct usr_avp *domain_avps_to;
271         
272         /* protection against concurrent reply processing */
273         ser_lock_t   reply_mutex;
274         
275         ticks_t fr_timeout;     /* final response interval for retr_bufs */
276         ticks_t fr_inv_timeout; /* final inv. response interval for retr_bufs */
277
278         /* nr of replied branch; 0..MAX_BRANCHES=branch value,
279          * -1 no reply, -2 local reply */
280         short relayed_reply_branch;
281
282         /* the route to take if no final positive reply arrived */
283         unsigned short on_negative;
284         /* the onreply_route to be processed if registered to do so */
285         unsigned short on_reply;
286          /* The route to take for each downstream branch separately */
287         unsigned short on_branch;
288
289         /* MD5checksum  (meaningful only if syn_branch=0) */
290         char md5[MD5_LEN];
291
292 }cell_type;
293
294
295
296 /* double-linked list of cells with hash synonyms */
297 typedef struct entry
298 {
299         struct cell*    first_cell;
300         struct cell*    last_cell;
301         /* currently highest sequence number in a synonym list */
302         unsigned int    next_label;
303         /* sync mutex */
304         ser_lock_t      mutex;
305         unsigned long acc_entries;
306         unsigned long cur_entries;
307 }entry_type;
308
309
310
311 /* transaction table */
312 struct s_table
313 {
314         /* table of hash entries; each of them is a list of synonyms  */
315         struct entry   entrys[ TABLE_ENTRIES ];
316 };
317
318
319 #define list_entry(ptr, type, member) \
320         ((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member)))
321
322 #define get_retr_timer_payload(_tl_) \
323         list_entry( _tl_, struct retr_buf, retr_timer)
324 #define get_fr_timer_payload(_tl_) \
325         list_entry( _tl_, struct retr_buf, fr_timer)
326 #define get_wait_timer_payload(_tl_) \
327         list_entry( _tl_, struct cell, wait_tl)
328 #define get_dele_timer_payload(_tl_) \
329         list_entry( _tl_, struct cell, dele_tl)
330
331 #define get_T_from_reply_rb(_rb_) \
332         list_entry( list_entry( _rb_, (struct ua_server), response),\
333                 struct cell, uas)
334 #define get_T_from_request_rb(_rb_, _br_) \
335         list_entry( list_entry( (rb_, (struct ua_client), request) - \
336                 (_br_)*sizeof(struct retr_buf), struct cell, uas)
337 #define get_T_from_cancel_rb(_rb_, _br_) \
338         list_entry( list_entry( (rb_, (struct ua_client), local_cancel) - \
339                 (_br_)*sizeof(struct retr_buf), struct cell, uas)
340
341 #define is_invite(_t_)           ((_t_)->flags&T_IS_INVITE_FLAG)
342 #define is_local(_t_)            ((_t_)->flags&T_IS_LOCAL_FLAG)
343 #define has_noisy_ctimer(_t_)    ((_t_)->flags&T_NOISY_CTIMER_FLAG)
344
345
346 void set_kr( enum kill_reason kr );
347 enum kill_reason get_kr();
348
349 struct s_table* get_tm_table();
350 struct s_table* init_hash_table();
351 void   free_hash_table( );
352 void   free_cell( struct cell* dead_cell );
353 struct cell*  build_cell( struct sip_msg* p_msg );
354 void   remove_from_hash_table_unsafe( struct cell * p_cell);
355 #ifdef OBSOLETED
356 void   insert_into_hash_table( struct cell * p_cell, unsigned int _hash);
357 #endif
358 void   insert_into_hash_table_unsafe( struct cell * p_cell, unsigned int _hash );
359
360 unsigned int transaction_count( void );
361
362 #endif
363
364