ser_error processing, ipv6-ization of TM, new TM callbacks;
[sip-router] / modules / tm / t_funcs.h
1 /*
2  * $Id$
3  */
4
5
6 #ifndef _T_FUNCS_H
7 #define _T_FUNCS_H
8
9 #include <errno.h>
10 #include <netinet/in.h>
11 #include <netdb.h>
12
13 #include "../../parser/msg_parser.h"
14 #include "../../globals.h"
15 #include "../../udp_server.h"
16 #include "../../msg_translator.h"
17 #include "../../timer.h"
18 #include "../../forward.h"
19 #include "../../mem/mem.h"
20 #include "../../md5utils.h"
21 #include "../../ip_addr.h"
22
23 #include "config.h"
24 #include "lock.h"
25 #include "timer.h"
26 #include "sh_malloc.h"
27 #include "sip_msg.h"
28
29
30 struct s_table;
31 struct timer;
32 struct entry;
33 struct cell;
34
35 extern struct cell      *T;
36 extern unsigned int     global_msg_id;
37 extern struct s_table*  hash_table;
38
39
40
41 #define LOCK_REPLIES(_t) lock(&(_t)->reply_mutex )
42 #define UNLOCK_REPLIES(_t) unlock(&(_t)->reply_mutex )
43 #define LOCK_ACK(_t) lock(&(_t)->ack_mutex )
44 #define UNLOCK_ACK(_t) unlock(&(_t)->ack_mutex )
45 #define LOCK_WAIT(_t) lock(&(_t)->wait_mutex )
46 #define UNLOCK_WAIT(_t) unlock(&(_t)->wait_mutex )
47
48
49 /* send a private buffer: utilize a retransmission structure
50    but take a separate buffer not refered by it; healthy
51    for reducing time spend in REPLIES locks
52 */
53
54 inline static int send_pr_buffer( struct retr_buf *rb,
55         void *buf, int len, char *function, int line )
56 {
57         if (buf && len && rb )
58                 return udp_send( rb->send_sock, buf, 
59                         len, &rb->to,  sizeof(union sockaddr_union) ) ;
60         else {
61                 LOG(L_CRIT, "ERROR: sending an empty buffer from %s (%d)\n",
62                         function, line );
63                 return -1;
64         }
65 }
66
67 #define SEND_PR_BUFFER(_rb,_bf,_le ) \
68         send_pr_buffer( (_rb), (_bf), (_le),  __FUNCTION__, __LINE__ )
69
70 /*
71 #define SEND_PR_BUFFER(_rb,_bf,_le ) \
72         ( ((_bf) && (_le) && (_bf)) ? \
73         udp_send( (_bf), (_le), &((_rb)->to), sizeof(union sockaddr_union) ) : \
74         log_send_error( __FUNCTION__, __LINE__ ) )
75 */
76
77 /* just for understanding of authors of the following macros, who did not
78    include 'PR' in macro names though they use 'PR' macro: PR stands for
79    PRIVATE and indicates usage of memory buffers in PRIVATE memory space,
80    where -- as opposed to SHARED memory space -- no concurrent memory
81    access can occur and thus no locking is needed ! -jiri
82 */
83 #define SEND_ACK_BUFFER( _rb ) \
84         SEND_PR_BUFFER( (_rb) , (_rb)->ack , (_rb)->ack_len )
85
86 #define SEND_CANCEL_BUFFER( _rb ) \
87         SEND_PR_BUFFER( (_rb) , (_rb)->cancel , (_rb)->cancel_len )
88
89 #define SEND_BUFFER( _rb ) \
90         SEND_PR_BUFFER( (_rb) , (_rb)->buffer , (_rb)->buffer_len )
91
92
93 /*
94   macros for reference bitmap (lock-less process non-exclusive ownership) 
95 */
96 #define T_IS_REFED(_T_cell) ((_T_cell)->ref_bitmap)
97 #define T_REFCOUNTER(_T_cell) \
98         ( { int _i=0; \
99                 process_bm_t _b=(_T_cell)->ref_bitmap; \
100                 while (_b) { \
101                         if ( (_b) & 1 ) _i++; \
102                         (_b) >>= 1; \
103                 } ;\
104                 (_i); \
105          } )
106                 
107
108 #ifdef EXTRA_DEBUG
109 #define T_IS_REFED_BYSELF(_T_cell) ((_T_cell)->ref_bitmap & process_bit)
110 #       define DBG_REF(_action, _t) DBG("DEBUG: XXXXX %s (%s:%d): T=%p , ref (bm=%x, cnt=%d)\n",\
111                         (_action), __FUNCTION__, __LINE__, (_t),(_t)->ref_bitmap, T_REFCOUNTER(_t));
112 #       define T_UNREF(_T_cell) \
113         ( { \
114                 DBG_REF("unref", (_T_cell)); \
115                 if (!T_IS_REFED_BYSELF(_T_cell)) { \
116                         DBG("ERROR: unrefering unrefered transaction %p from %s , %s : %d\n", \
117                                 (_T_cell), __FUNCTION__, __FILE__, __LINE__ ); \
118                         abort(); \
119                 } \
120                 (_T_cell)->ref_bitmap &= ~process_bit; \
121         } )
122
123 #       define T_REF(_T_cell) \
124         ( { \
125                 DBG_REF("ref", (_T_cell));       \
126                 if (T_IS_REFED_BYSELF(_T_cell)) { \
127                         DBG("ERROR: refering already refered transaction %p from %s,%s :"\
128                                 " %d\n",(_T_cell), __FUNCTION__, __FILE__, __LINE__ ); \
129                         abort(); \
130                 } \
131                 (_T_cell)->ref_bitmap |= process_bit; \
132         } )
133 #else
134 #       define T_UNREF(_T_cell) ({ (_T_cell)->ref_bitmap &= ~process_bit; })
135 #       define T_REF(_T_cell) ({ (_T_cell)->ref_bitmap |= process_bit; })
136 #endif
137
138
139
140 /*
141 enum addifnew_status { AIN_ERROR, AIN_RETR, AIN_NEW, AIN_NEWACK,
142         AIN_OLDACK, AIN_RTRACK } ;
143 */
144
145
146 int   tm_startup();
147 void tm_shutdown();
148
149
150 /* function returns:
151  *       1 - a new transaction was created
152  *      -1 - error, including retransmission
153  */
154 int  t_add_transaction( struct sip_msg* p_msg  );
155
156
157
158
159 /* function returns:
160  *      -1 - transaction wasn't found
161  *       1 - transaction found
162  */
163 int t_check( struct sip_msg* , int *branch , int* is_cancel);
164
165
166
167
168 /* Forwards the inbound request to a given IP and port.  Returns:
169  *       1 - forward successfull
170  *      -1 - error during forward
171  */
172 /* v6; -jiri
173 int t_forward( struct sip_msg* p_msg , unsigned int dst_ip ,
174                                                                                 unsigned int dst_port);
175 */
176
177
178
179
180 /* Forwards the inbound request to dest. from via.  Returns:
181  *       1 - forward successfull
182  *      -1 - error during forward
183  */
184 /* v6; -jiri
185 int t_forward_uri( struct sip_msg* p_msg  );
186 */
187
188
189
190
191 /* This function is called whenever a reply for our module is received;
192  * we need to register this function on module initialization;
193  * Returns :   0 - core router stops
194  *             1 - core router relay statelessly
195  */
196 int t_on_reply( struct sip_msg  *p_msg ) ;
197
198
199
200
201 /* This function is called whenever a request for our module is received;
202  * we need to register this function on module initialization;
203  * Returns :   0 - core router stops
204  *             1 - core router relay statelessly
205  */
206 int t_on_request_received( struct sip_msg  *p_msg , unsigned int ip, unsigned int port) ;
207
208
209
210
211 /* This function is called whenever a request for our module is received;
212  * we need to register this function on module initialization;
213  * Returns :   0 - core router stops
214  *             1 - core router relay statelessly
215  */
216 int t_on_request_received_uri( struct sip_msg  *p_msg ) ;
217
218
219
220
221 /* returns 1 if everything was OK or -1 for error
222  */
223 int t_release_transaction( struct sip_msg* );
224
225
226
227
228 /* Retransmits the last sent inbound reply.
229  * Returns  -1 - error
230  *           1 - OK
231  */
232 int t_retransmit_reply( /* struct sip_msg * */  );
233
234
235
236
237 /* Force a new response into inbound response buffer.
238  * returns 1 if everything was OK or -1 for erro
239  */
240 int t_send_reply( struct sip_msg * , unsigned int , char *  , unsigned int);
241
242
243
244
245 /* releases T-context */
246 int t_unref( /* struct sip_msg* p_msg */ );
247
248
249
250 /* v6; -jiri
251 int t_forward_nonack( struct sip_msg* p_msg , unsigned int dest_ip_param ,
252         unsigned int dest_port_param );
253 int t_forward_ack( struct sip_msg* p_msg , unsigned int dest_ip_param ,
254         unsigned int dest_port_param );
255 */
256 int t_forward_nonack( struct sip_msg* p_msg, struct proxy_l * p );
257 int t_forward_ack( struct sip_msg* p_msg );
258
259
260 int forward_serial_branch(struct cell* Trans,int branch);
261 struct cell* t_lookupOriginalT(  struct s_table* hash_table,
262         struct sip_msg* p_msg );
263 int t_reply_matching( struct sip_msg* , int* ,  int* );
264 int t_store_incoming_reply( struct cell* , unsigned int , struct sip_msg* );
265 int t_lookup_request( struct sip_msg* p_msg , int leave_new_locked );
266 int t_all_final( struct cell * );
267 int t_build_and_send_ACK( struct cell *Trans , unsigned int brach ,
268         struct sip_msg* rpl);
269 int t_should_relay_response( struct cell *Trans, int new_code, int branch,
270         int *should_store );
271 int t_update_timers_after_sending_reply( struct retr_buf *rb );
272 int t_put_on_wait(  struct cell  *Trans  );
273 int relay_lowest_reply_upstream( struct cell *Trans , struct sip_msg *p_msg );
274 int add_branch_label( struct cell *Trans, struct sip_msg *p_msg , int branch );
275 int get_ip_and_port_from_uri( str* uri , unsigned int *param_ip,
276         unsigned int *param_port);
277 int t_build_and_send_CANCEL(struct cell *Trans, unsigned int branch);
278 char *build_ack( struct sip_msg* rpl, struct cell *trans, int branch ,
279         int *ret_len);
280
281 int t_addifnew( struct sip_msg* p_msg );
282
283 void timer_routine(unsigned int, void*);
284
285
286
287
288 inline int static attach_ack(  struct cell *t, int branch,
289                                                                         char *ack, int ack_len )
290 {
291         LOCK_ACK( t );
292         if (t->uac[branch].request.ack) {
293                 UNLOCK_ACK(t);
294                 shm_free( ack );
295                 LOG(L_WARN, "attach_ack: Warning: ACK already sent out\n");
296                 return 0;
297         }
298         t->uac[branch].request.ack = ack;
299         t->uac[branch].request.ack_len = ack_len;
300         UNLOCK_ACK( t );
301         return 1;
302 }
303
304
305
306
307 /* remove from timer list */
308 static inline void reset_timer( struct s_table *hash_table,
309                                                                                                         struct timer_link* tl )
310 {
311         /* lock(timer_group_lock[ tl->tg ]); */
312         /* hack to work arround this timer group thing*/
313         lock(hash_table->timers[timer_group[tl->tg]].mutex);
314         remove_timer_unsafe( tl );
315         unlock(hash_table->timers[timer_group[tl->tg]].mutex);
316         /*unlock(timer_group_lock[ tl->tg ]);*/
317 }
318
319
320
321
322 /* determine timer length and put on a correct timer list */
323 static inline void set_timer( struct s_table *hash_table,
324                                                         struct timer_link *new_tl, enum lists list_id )
325 {
326         unsigned int timeout;
327         struct timer* list;
328
329
330         if (list_id<FR_TIMER_LIST || list_id>=NR_OF_TIMER_LISTS) {
331                 LOG(L_CRIT, "ERROR: set_timer: unkown list: %d\n", list_id);
332 #ifdef EXTRA_DEBUG
333                 abort();
334 #endif
335                 return;
336         }
337         timeout = timer_id2timeout[ list_id ];
338         list= &(hash_table->timers[ list_id ]);
339
340         lock(list->mutex);
341         /* make sure I'm not already on a list */
342         remove_timer_unsafe( new_tl );
343         add_timer_unsafe( list, new_tl, get_ticks()+timeout);
344         unlock(list->mutex);
345 }
346
347
348
349
350 static inline void reset_retr_timers( struct s_table *h_table,
351                                                                                                         struct cell *p_cell )
352 {
353         int ijk;
354
355         /* lock the first timer list of the FR group -- all other
356            lists share the same lock*/
357         lock(hash_table->timers[RT_T1_TO_1].mutex);
358         remove_timer_unsafe( & p_cell->uas.response.retr_timer );
359         for( ijk=0 ; ijk<(p_cell)->nr_of_outgoings ; ijk++ )  {
360                 remove_timer_unsafe( & p_cell->uac[ijk].request.retr_timer );
361         }
362         unlock(hash_table->timers[RT_T1_TO_1].mutex);
363
364         lock(hash_table->timers[FR_TIMER_LIST].mutex);
365         remove_timer_unsafe( & p_cell->uas.response.fr_timer );
366         for( ijk=0 ; ijk<(p_cell)->nr_of_outgoings ; ijk++ )  {
367                 remove_timer_unsafe( & p_cell->uac[ijk].request.fr_timer );
368         }
369         unlock(hash_table->timers[FR_TIMER_LIST].mutex);
370         DBG("DEBUG:stop_RETR_and_FR_timers : timers stopped\n");
371 }
372
373 void delete_cell( struct cell *p_cell );
374
375 int t_newtran( struct sip_msg* p_msg );
376
377 #endif
378