a4e7141a7da032e8aef50cad153db165152196cd
[sip-router] / modules / tm / t_funcs.c
1 /*
2  * $Id$
3  *
4  */
5
6 #include "hash_func.h"
7 #include "t_funcs.h"
8 #include "../../dprint.h"
9 #include "../../config.h"
10 #include "../../parser_f.h"
11 #include "../../ut.h"
12 #include "../../timer.h"
13
14
15 struct cell         *T;
16 unsigned int     global_msg_id;
17 struct s_table*  hash_table;
18
19
20
21
22 /* determine timer length and put on a correct timer list */
23 static inline void set_timer( struct s_table *hash_table,
24         struct timer_link *new_tl, enum lists list_id )
25 {
26         unsigned int timeout;
27         static enum lists to_table[NR_OF_TIMER_LISTS] =
28                 {       FR_TIME_OUT, INV_FR_TIME_OUT, WT_TIME_OUT, DEL_TIME_OUT,
29                         RETR_T1, RETR_T1 << 1,  RETR_T1 << 2, RETR_T2 };
30
31         if (list_id<FR_TIMER_LIST || list_id>=NR_OF_TIMER_LISTS) {
32                 LOG(L_CRIT, "ERROR: set_timer: unkown list: %d\n", list_id);
33 #ifdef EXTRA_DEBUG
34                 abort();
35 #endif
36                 return;
37         }
38         timeout = to_table[ list_id ];
39         add_to_tail_of_timer_list( &(hash_table->timers[ list_id ]),
40                 new_tl,get_ticks()+timeout);
41 }
42
43 /* remove from timer list */
44 static inline void reset_timer( struct s_table *hash_table,
45         struct timer_link* tl )
46 {
47         remove_from_timer_list( tl );
48 }
49
50 static inline void reset_retr_timers( struct s_table *h_table,
51         struct cell *p_cell )
52 {
53         int ijk;
54         struct retrans_buff *rb;
55
56         DBG("DEBUG:stop_RETR_and_FR_timers : start \n");
57         reset_timer( h_table, &(p_cell->outbound_response.retr_timer));
58         reset_timer( h_table, &(p_cell->outbound_response.fr_timer));
59
60         for( ijk=0 ; ijk<(p_cell)->nr_of_outgoings ; ijk++ )  { 
61                         if ( rb = p_cell->outbound_request[ijk] ) {
62                                 reset_timer(h_table, &(rb->retr_timer));
63                                 reset_timer(h_table, &(rb->fr_timer));
64                         }
65                 } 
66         DBG("DEBUG:stop_RETR_and_FR_timers : stop\n");
67 }
68
69 int tm_startup()
70 {
71    /* building the hash table*/
72    hash_table = init_hash_table();
73    if (!hash_table)
74       return -1;
75
76 #define init_timer(_id,_handler) \
77         hash_table->timers[(_id)].timeout_handler=(_handler); \
78         hash_table->timers[(_id)].id=(_id);
79
80    init_timer( RT_T1_TO_1, retransmission_handler );
81    init_timer( RT_T1_TO_2, retransmission_handler );
82    init_timer( RT_T1_TO_3, retransmission_handler );
83    init_timer( RT_T2, retransmission_handler );
84    init_timer( FR_TIMER_LIST, final_response_handler );
85    init_timer( FR_INV_TIMER_LIST, final_response_handler );
86    init_timer( WT_TIMER_LIST, wait_handler );
87    init_timer( DELETE_LIST, delete_handler );
88
89    /* register the timer function */
90    register_timer( timer_routine , hash_table , 1 );
91
92    /*first msg id*/
93    global_msg_id = 0;
94    T = T_UNDEFINED;
95
96    return 0;
97 }
98
99
100
101
102 void tm_shutdown()
103 {
104     struct timer_link  *tl, *end, *tmp;
105     int i;
106
107     DBG("DEBUG: tm_shutdown : start\n");
108     /*remember the DELETE LIST */
109     tl = hash_table->timers[DELETE_LIST].first_tl.next_tl;
110         end = & hash_table->timers[DELETE_LIST].last_tl;
111     /*unlink the lists*/
112     for( i=0; i<NR_OF_TIMER_LISTS ; i++ )
113     {
114        //lock( hash_table->timers[i].mutex );
115                 reset_timer_list( hash_table, i );
116        //unlock( hash_table->timers[i].mutex );
117     }
118
119     DBG("DEBUG: tm_shutdown : empting DELETE list\n");
120     /* deletes all cells from DELETE_LIST list (they are no more accessible from enrys) */
121         while (tl!=end) {
122                 tmp=tl->next_tl;
123                 free_cell((struct cell*)tl->payload);
124                  tl=tmp;
125         }
126
127     /* destroy the hash table */
128     DBG("DEBUG: tm_shutdown : empting hash table\n");
129     free_hash_table( hash_table );
130     DBG("DEBUG: tm_shutdown : removing semaphores\n");
131         lock_cleanup();
132     DBG("DEBUG: tm_shutdown : done\n");
133 }
134
135
136
137
138 /* function returns:
139  *       1 - a new transaction was created
140  *      -1 - error, including retransmission
141  */
142 int t_add_transaction( struct sip_msg* p_msg, char* foo, char* bar )
143 {
144    struct cell*    new_cell;
145
146    DBG("DEBUG: t_add_transaction: adding......\n");
147
148    /* sanity check: ACKs can never establish a transaction */
149    if ( p_msg->REQ_METHOD==METHOD_ACK )
150    {
151        LOG(L_ERR, "ERROR: add_transaction: ACK can't be used to add transaction\n");
152       return -1;
153    }
154
155    /* it's about the same transaction or not?*/
156         if (t_check( p_msg , 0 )==-1) return -1;
157
158    /* if the lookup's result is not 0 means that it's a retransmission */
159    if ( T )
160    {
161       LOG(L_ERR,"ERROR: t_add_transaction: won't add a retransmission\n");
162       return -1;
163    }
164
165    /* creates a new transaction */
166    new_cell = build_cell( p_msg ) ;
167    DBG("DEBUG: t_add_transaction: new transaction created %p\n", new_cell);
168    if  ( !new_cell ){
169            LOG(L_ERR, "ERROR: add_transaction: out of mem:\n");
170            sh_status();
171       return -1;
172         }
173    /*insert the transaction into hash table*/
174    insert_into_hash_table( hash_table , new_cell );
175    DBG("DEBUG: t_add_transaction: new transaction inserted, hash: %d\n", new_cell->hash_index );
176
177    T = new_cell;
178         T_REF(T);
179    return 1;
180 }
181
182
183
184
185 /* function returns:
186  *       1 - forward successfull
187  *      -1 - error during forward
188  */
189 int t_forward( struct sip_msg* p_msg , unsigned int dest_ip_param , unsigned int dest_port_param )
190 {
191         unsigned int  dest_ip     = dest_ip_param;
192         unsigned int  dest_port  = dest_port_param;
193         int            branch;
194         unsigned int  len;
195         char                          *buf, *shbuf;
196         struct retrans_buff  *rb;
197
198         buf=NULL;
199         shbuf = NULL;
200         branch = 0;     /* we don't do any forking right now */
201
202         /* it's about the same transaction or not? */
203         if (t_check( p_msg , 0 )==-1) return -1;
204
205         /*if T hasn't been found after all -> return not found (error) */
206         if ( !T )
207         {
208                 DBG("DEBUG: t_forward: no transaction found for request forwarding\n");
209                 return -1;
210         }
211
212         /*if it's an ACK and the status is not final or is final, but error the
213         ACK is not forwarded*/
214         if ( p_msg->REQ_METHOD==METHOD_ACK  && (T->status/100)!=2 ) {
215                 DBG("DEBUG: t_forward: local ACK; don't forward\n");
216                 return 1;
217         }
218
219         /* if it's forwarded for the first time ; else the request is retransmited
220          * from the transaction buffer
221          * when forwarding an ACK, this condition will be all the time false because
222          * the forwarded INVITE is in the retransmission buffer */
223         if ( T->outbound_request[branch]==NULL )
224 {
225                 DBG("DEBUG: t_forward: first time forwarding\n");
226                 /* special case : CANCEL */
227                 if ( p_msg->REQ_METHOD==METHOD_CANCEL  )
228                 {
229                         DBG("DEBUG: t_forward: it's CANCEL\n");
230                         /* find original cancelled transaction; if found, use its
231                            next-hops; otherwise use those passed by script */
232                         if (T->T_canceled==T_UNDEFINED)
233                                 T->T_canceled = t_lookupOriginalT( hash_table , p_msg );
234                         /* if found */
235                         if ( T->T_canceled!=T_NULL )
236                         {
237                                 /* if in 1xx status, send to the same destination */
238                                 if ( (T->T_canceled->status/100)==1 )
239                                 {
240                                         DBG("DEBUG: t_forward: it's CANCEL and I will send "
241                                                 "to the same place where INVITE went\n");
242                                         dest_ip=T->T_canceled->outbound_request[branch]->
243                                                 to.sin_addr.s_addr;
244                                         dest_port = T->T_canceled->outbound_request[branch]->
245                                                 to.sin_port;
246                                 } else { /* transaction exists, but nothing to cancel */
247                                         DBG("DEBUG: t_forward: it's CANCEL but "
248                                                 "I have nothing to cancel here\n");
249                                         /* continue forwarding CANCEL as a stand-alone transaction */
250                                 }
251                         } else { /* transaction does not exists  */
252                                 DBG("DEBUG: t_forward: canceled request not found! "
253                                         "nothing to CANCEL\n");
254                         }
255                 }/* end special case CANCEL*/
256
257                 if ( add_branch_label( T, T->inbound_request , branch )==-1)
258                         goto error;
259                 if ( add_branch_label( T, p_msg , branch )==-1)
260                         goto error;
261                 if ( !(buf = build_req_buf_from_sip_req  ( p_msg, &len)))
262                         goto error;
263
264                 /* allocates a new retrans_buff for the outbound request */
265                 DBG("DEBUG: t_forward: building outbound request\n");
266                 shm_lock();
267                 T->outbound_request[branch] = rb =
268                         (struct retrans_buff*)shm_malloc_unsafe( sizeof(struct retrans_buff)  );
269                 if (!rb)
270                 {
271                         LOG(L_ERR, "ERROR: t_forward: out of shmem\n");
272                         shm_unlock();
273                         goto error;
274                 }
275                 shbuf = (char *) shm_malloc_unsafe( len );
276                 if (!shbuf)
277                 {
278                         LOG(L_ERR, "ERROR: t_forward: out of shmem buffer\n");
279                         shm_unlock();
280                         goto error;
281                 }
282                 shm_unlock();
283                 memset( rb , 0 , sizeof (struct retrans_buff) );
284                 rb->retr_buffer = shbuf;
285                 rb->retr_timer.payload =  rb;
286                 rb->fr_timer.payload =  rb;
287                 rb->to.sin_family = AF_INET;
288                 rb->my_T =  T;
289                 T->nr_of_outgoings = 1;
290                 rb->bufflen = len ;
291                 memcpy( rb->retr_buffer , buf , len );
292                 free( buf ) ; buf=NULL;
293
294                 DBG("DEBUG: t_forward: starting timers (retrans and FR) %d\n",get_ticks() );
295                 /*sets and starts the FINAL RESPONSE timer */
296                 set_timer( hash_table, &(rb->fr_timer), FR_TIMER_LIST );
297
298                 /* sets and starts the RETRANS timer */
299                 rb->retr_list = RT_T1_TO_1;
300                 set_timer( hash_table, &(rb->retr_timer), RT_T1_TO_1 );
301         }/* end for the first time */
302
303         /* if we are forwarding an ACK*/
304         if (  p_msg->REQ_METHOD==METHOD_ACK &&
305                 T->relaied_reply_branch>=0 &&
306                 T->relaied_reply_branch<=T->nr_of_outgoings)
307         {
308                 DBG("DEBUG: t_forward: forwarding ACK [%d]\n",T->relaied_reply_branch);
309                 t_build_and_send_ACK( T, branch ,
310                         T->inbound_response[T->relaied_reply_branch] );
311                 T->inbound_request_isACKed = 1;
312                 return 1;
313         } else /* if we are forwarding a CANCEL*/
314         if (  p_msg->REQ_METHOD==METHOD_CANCEL )
315         {
316                 DBG("DEBUG: t_forward: forwarding CANCEL \n");
317                 /* if no transaction to CANCEL
318                     or if the canceled transaction has a final status -> drop the CANCEL*/
319                 if ( T->T_canceled!=T_NULL && T->T_canceled->status>=200)
320                 {
321                         reset_timer( hash_table, &(rb->fr_timer ));
322                         reset_timer( hash_table, &(rb->retr_timer ));
323                         return 1;
324                 }
325         }
326
327         /* send the request */
328         /* known to be in network order */
329         rb->to.sin_port     =  dest_port;
330         rb->to.sin_addr.s_addr =  dest_ip;
331         rb->to.sin_family = AF_INET;
332
333         SEND_BUFFER( rb );
334
335    return 1;
336
337 error:
338         if (shbuf) shm_free(shbuf);
339         if (rb) {
340                 shm_free(rb);
341                 T->outbound_request[branch]=NULL;
342         }
343         if (buf) free( buf );
344
345         return -1;
346
347 }
348
349
350 /* Forwards the inbound request to dest. from via.  Returns:
351  *       1 - forward successfull
352  *      -1 - error during forward
353  */
354 int t_forward_uri( struct sip_msg* p_msg, char* foo, char* bar  )
355 {
356    unsigned int     ip, port;
357
358    if ( get_ip_and_port_from_uri( p_msg , &ip, &port)<0 )
359    {
360       LOG( L_ERR , "ERROR: t_forward_uri: unable to extarct ip and port from uri!\n" );
361       return -1;
362    }
363
364    return t_forward( p_msg , ip , port );
365 }
366
367
368
369
370 /*  This function is called whenever a reply for our module is received; we need to register
371   *  this function on module initialization;
372   *  Returns :   0 - core router stops
373   *                    1 - core router relay statelessly
374   */
375 int t_on_reply_received( struct sip_msg  *p_msg )
376 {
377         unsigned int  branch,len, msg_status, msg_class;
378         struct sip_msg *clone;
379         int relay;
380         struct retrans_buff *rb;
381
382         clone=NULL;
383
384         /* if a reply received which has not all fields we might want to
385            have for stateul forwarding, give the stateless router
386            a chance for minimum routing; parse only what's needed
387            for MPLS-ize reply matching
388         */
389         if (t_check( p_msg  , &branch )==-1) return 1;
390
391         /* if no T found ->tell the core router to forward statelessly */
392         if ( T<=0 )
393                 return 1;
394         DBG("DEBUG: t_on_reply_received: Original status =%d\n",T->status);
395
396         /* we were not able to process the response due to memory
397            shortage; simply drop it; hopefuly, we will have more
398         memory on the next try */
399         msg_status=p_msg->REPLY_STATUS;
400         msg_class=REPLY_CLASS(p_msg);
401         relay = t_should_relay_response( T , msg_status );
402
403         if (relay && !(clone=sip_msg_cloner( p_msg ))) {
404                 T_UNREF( T );
405                 return 0;
406         }
407
408         rb=T->outbound_request[branch];
409
410         /* stop retransmission */
411         reset_timer( hash_table, &(rb->retr_timer));
412
413         /* stop final response timer only if I got a final response */
414         if ( msg_class>1 )
415                 reset_timer( hash_table, &(rb->fr_timer));
416         /* if a got the first prov. response for an INVITE ->
417            change FR_TIME_OUT to INV_FR_TIME_UT */
418         if (!T->inbound_response[branch] && msg_class==1
419          && T->inbound_request->REQ_METHOD==METHOD_INVITE )
420                 set_timer( hash_table, &(rb->fr_timer), FR_INV_TIMER_LIST );
421         /* get response for INVITE */
422         if ( T->inbound_request->REQ_METHOD==METHOD_INVITE )
423         {
424                 if ( T->outbound_request_isACKed[branch] )
425                 {       /*retransmit the last ACK*/
426                         DBG("DEBUG: t_on_reply_received: retransmitting ACK!!!!!!!!!!!!!!!!!!+!+!+!!\n");
427                         SEND_BUFFER( T->outbound_request[branch] );
428                 } else if (msg_class>2 ) {   /*on a non-200 reply to INVITE*/
429                         DBG("DEBUG: t_on_reply_received: >=3xx reply to INVITE: send ACK\n");
430                         if ( t_build_and_send_ACK( T , branch , p_msg )==-1)
431                         {
432                                 LOG( L_ERR , "ERROR: t_on_reply_received: unable to send ACK\n" );
433                                 if (clone ) sip_msg_free( clone );
434                                 T_UNREF( T );
435                                 return 0;
436                         }
437                 }
438         }
439
440 #       ifdef FORKING
441         /* skipped for the moment*/
442 #       endif
443
444         /* if the incoming response code is not reliable->drop it*/
445         if (!relay) {
446                 T_UNREF( T );
447                 return 0;
448         }
449
450         /* restart retransmission if provisional response came for a non_INVITE ->
451                 retrasmit at RT_T2*/
452         if ( msg_class==1 && T->inbound_request->REQ_METHOD!=METHOD_INVITE )
453         {
454                 rb->retr_list = RT_T2;
455                 set_timer( hash_table, &(rb->retr_timer), RT_T2 );
456         }
457
458         /*store the inbound reply - if there is a previous reply, replace it */
459         if ( T->inbound_response[branch] ) {
460                 sip_msg_free( T->inbound_response[branch] ) ;
461                 DBG("DEBUG: t_store_incoming_reply: previous inbound reply freed....\n");
462         }
463         T->inbound_response[branch] = clone;
464
465         if ( msg_class>=3 && msg_class<=5 )
466         {
467                 if ( t_all_final(T) && relay_lowest_reply_upstream( T , p_msg )==-1 && clone )
468                         goto error;
469         } else {
470                 if (push_reply_from_uac_to_uas( T , branch )==-1 && clone )
471                         goto error;
472         }
473
474         /* nothing to do for the ser core */
475         T_UNREF( T );
476         return 0;
477
478 error:
479         T_UNREF( T );
480         T->inbound_response[branch]=NULL;
481         sip_msg_free( clone );
482         /* don't try to relay statelessly on error */
483         return 0;
484 }
485
486
487 int t_on_request_received( struct sip_msg  *p_msg , unsigned int ip , unsigned int port)
488 {
489         if ( t_check( p_msg , 0 ) )
490         {
491                 if ( p_msg->first_line.u.request.method_value==METHOD_ACK )
492                 {
493                         LOG( L_INFO , "SER: ACK received -> t_release\n");
494                         if ( !t_forward( p_msg , ip , port ) )
495                         {
496                                 LOG( L_WARN, "SER: WARNING: bad forward\n");
497                         }
498                         if ( !t_release_transaction( p_msg ) )
499                         {
500                                 LOG( L_WARN ,"SER: WARNING: bad t_release\n");
501                         }
502                 }
503                 else
504                 {
505                         if ( !t_retransmit_reply( p_msg , 0, 0) )
506                         {
507                                 LOG( L_WARN, "SER: WARNING: bad t_retransmit_reply\n");
508                         }
509                         LOG( L_INFO, "SER: yet another annoying retranmission\n");
510                 }
511                 t_unref( p_msg,0,0 );
512         } else {
513                 if ( p_msg->first_line.u.request.method_value==METHOD_ACK )
514                 {
515                         LOG( L_INFO , "SER: forwarding ACK  statelessly\n");
516                         /* no established transaction ... forward ACK just statelessly*/
517                         forward_request( p_msg , mk_proxy_from_ip(ip,port) );
518                 }
519                 else
520                 {
521                         /* establish transaction*/
522                         if ( !t_add_transaction(p_msg,0,0) )
523                         {
524                                 LOG( L_ERR , "ERROR in ser: t_add_transaction\n");
525                         }
526                         /* reply */
527                         if ( p_msg->first_line.u.request.method_value==METHOD_CANCEL)
528                         {
529                                 LOG( L_INFO, "SER: new CANCEL\n");
530                                 if ( !t_send_reply( p_msg , 200, "glad to cancel") )
531                                 {
532                                         LOG( L_ERR ,"SER:ERROR: t_send_reply\n");
533                                 }
534                         } else {
535                                 LOG( L_INFO, "SER: new transaction\n");
536                                 if ( !t_send_reply( p_msg , 100 , "trying -- your call is important to us") )
537                                 {
538                                         LOG( L_ERR, "SER: ERROR: t_send_reply (100)\n");
539                                 }
540                         }
541                         if ( !t_forward( p_msg, ip, port ) )
542                         {
543                                 LOG( L_ERR , "SER:ERROR: t_forward \n");
544                         }
545                         t_unref( p_msg , 0 , 0);
546                 }
547         }
548
549 }
550
551
552
553
554 int t_on_request_received_uri( struct sip_msg  *p_msg )
555 {
556         unsigned int     ip, port;
557
558         if ( get_ip_and_port_from_uri( p_msg , &ip, &port)<0 )
559         {
560                 LOG( L_ERR , "ERROR: t_on_request_received_uri: \
561                     unable to extract ip and port from uri!\n" );
562                 return -1;
563         }
564
565         return t_on_request_received( p_msg , ip , port );
566 }
567
568
569
570
571 /*   returns 1 if everything was OK or -1 for error
572   */
573 int t_release_transaction( struct sip_msg* p_msg)
574 {
575         if (t_check( p_msg  , 0 )==-1) return 1;
576
577    if ( T && T!=T_UNDEFINED )
578       return t_put_on_wait( T );
579
580    return 1;
581 }
582
583
584
585
586 /* Retransmits the last sent inbound reply.
587
588   * input: p_msg==request for which I want to retransmit an associated
589     reply
590   * Returns  -1 -error
591   *                1 - OK
592   */
593 int t_retransmit_reply( struct sip_msg* p_msg, char* foo, char* bar  )
594 {
595         if (t_check( p_msg  , 0 )==-1) return 1;
596
597    /* if no transaction exists or no reply to be resend -> out */
598    if ( T )
599    {
600         SEND_BUFFER( & T->outbound_response );
601         return 1;
602    }
603
604   /* no transaction found */
605    return -1;
606 }
607
608
609
610
611 int t_unref( struct sip_msg* p_msg, char* foo, char* bar )
612 {
613         if (T==T_UNDEFINED || T==T_NULL)
614                 return -1;
615         T_UNREF( T );
616         T=T_UNDEFINED;
617         return 1;
618 }
619
620
621
622
623 /* Force a new response into inbound response buffer.
624   * returns 1 if everything was OK or -1 for erro
625   */
626 int t_send_reply(  struct sip_msg* p_msg , unsigned int code , char * text )
627 {
628         unsigned int len, buf_len;
629         char * buf;
630         struct retrans_buff *rb;
631
632         DBG("DEBUG: t_send_reply: entered\n");
633         if (t_check( p_msg , 0 )==-1) return -1;
634
635         if (!T)
636         {
637                 LOG(L_ERR, "ERROR: t_send_reply: cannot send a t_reply to a message "
638                         "for which no T-state has been established\n");
639                 return -1;
640         }
641
642         rb = & T->outbound_response;
643         if (!rb->retr_buffer) {
644                 /* initialize retransmission structure */
645                 memset( rb , 0 , sizeof (struct retrans_buff) );
646                 if (update_sock_struct_from_via(  &(rb->to),  p_msg->via1 )==-1)
647                 {
648                         LOG(L_ERR, "ERROR: t_send_reply: cannot lookup reply dst: %s\n",
649                                 p_msg->via1->host.s );
650                         goto error;
651                 }
652
653                 rb->retr_timer.payload = rb;
654                 rb->fr_timer.payload = rb;
655                 rb->to.sin_family = AF_INET;
656                 rb->my_T = T;
657         }
658
659         buf = build_res_buf_from_sip_req( code , text , T->inbound_request , &len );
660         DBG("DEBUG: t_send_reply: buffer computed\n");
661         if (!buf)
662         {
663                 DBG("DEBUG: t_send_reply: response building failed\n");
664                 goto error;
665         }
666
667         /* if this is a first reply (?100), longer replies will probably follow;
668        try avoiding shm_resize by higher buffer size
669     */
670         buf_len = rb->retr_buffer ? len : len + REPLY_OVERBUFFER_LEN;
671
672         if (! (rb->retr_buffer = (char*)shm_resize( rb->retr_buffer, buf_len )))
673         {
674                 LOG(L_ERR, "ERROR: t_send_reply: cannot allocate shmem buffer\n");
675                 goto error2;
676         }
677         rb->bufflen = len ;
678         memcpy( rb->retr_buffer , buf , len );
679         free( buf ) ;
680         T->status = code;
681
682         /* start/stops the proper timers*/
683         DBG("DEBUG: t_send_reply: update timers\n");
684         t_update_timers_after_sending_reply( rb );
685
686         DBG("DEBUG: t_send_reply: send reply\n");
687         /* t_retransmit_reply( p_msg, 0 , 0); */
688         SEND_BUFFER( rb );
689
690         return 1;
691
692 error2:
693         free ( buf );
694 error:
695         return -1;
696 }
697
698
699
700 /* Push a previously stored reply from UA Client to UA Server
701   * and send it out
702   */
703 int push_reply_from_uac_to_uas( struct cell* trans , unsigned int branch )
704 {
705         char *buf;
706         unsigned int len, buf_len;
707         struct retrans_buff *rb;
708
709         DBG("DEBUG: push_reply_from_uac_to_uas: start\n");
710         rb= & trans->outbound_response;
711         /* if there is a reply, release the buffer (everything else stays same) */
712         if ( ! rb->retr_buffer ) {
713                 /*init retrans buffer*/
714                 memset( rb , 0 , sizeof (struct retrans_buff) );
715                 if (update_sock_struct_from_via(  &(rb->to),
716                         trans->inbound_response[branch]->via2 )==-1) {
717                                 LOG(L_ERR, "ERROR: push_reply_from_uac_to_uas: "
718                                         "cannot lookup reply dst: %s\n",
719                                 trans->inbound_response[branch]->via2->host.s );
720                                 goto error;
721                 }
722                 rb->retr_timer.payload = rb;
723                 rb->fr_timer.payload =  rb;
724                 rb->to.sin_family = AF_INET;
725                 rb->my_T = trans;
726
727         } else {
728                 reset_timer( hash_table, &(rb->retr_timer));
729                 reset_timer( hash_table, &(rb->fr_timer));
730         }
731
732         /*  generate the retrans buffer */
733         buf = build_res_buf_from_sip_res ( trans->inbound_response[branch], &len);
734         if (!buf) {
735                 LOG(L_ERR, "ERROR: push_reply_from_uac_to_uas: "
736                         "no shmem for outbound reply buffer\n");
737                 goto error;
738         }
739
740         /* if this is a first reply (?100), longer replies will probably follow;
741         try avoiding shm_resize by higher buffer size */
742         buf_len = rb->retr_buffer ? len : len + REPLY_OVERBUFFER_LEN;
743         if (! (rb->retr_buffer = (char*)shm_resize( rb->retr_buffer, buf_len )))
744         {
745                 LOG(L_ERR, "ERROR: t_send_reply: cannot allocate shmem buffer\n");
746                 goto error1;
747         }
748         rb->bufflen = len ;
749         memcpy( rb->retr_buffer , buf , len );
750         free( buf ) ;
751
752         /* update the status*/
753         trans->status = trans->inbound_response[branch]->REPLY_STATUS;
754         if ( trans->inbound_response[branch]->REPLY_STATUS>=200 &&
755         trans->relaied_reply_branch==-1 )
756                 trans->relaied_reply_branch = branch;
757
758         /* start/stops the proper timers*/
759         t_update_timers_after_sending_reply( rb );
760
761         /*send the reply*/
762         /* t_retransmit_reply( trans->inbound_response[branch], 0 , 0 ); */
763         SEND_BUFFER( rb );
764         return 1;
765
766 error1:
767         free( buf );
768 error:
769         return -1;
770 }
771
772
773
774
775
776 /* ----------------------------HELPER FUNCTIONS-------------------------------- */
777
778
779
780
781 /*  Checks if all the transaction's outbound request has a final response.
782   *  Return   1 - all are final
783   *                0 - some waitting
784   */
785 int t_all_final( struct cell *Trans )
786 {
787    unsigned int i;
788
789         for( i=0 ; i<Trans->nr_of_outgoings ; i++  )
790                 if (  !Trans->inbound_response[i] ||
791                 Trans->inbound_response[i]->REPLY_STATUS<=200 )
792                         return 0;
793
794         DBG("DEBUG: t_all_final: final state!!!!:)) \n");
795         return 1;
796 }
797
798
799
800
801 /* Picks the lowest code reply and send it upstream.
802   *  Returns -1 if no lowest find reply found (all provisional)
803   */
804 int relay_lowest_reply_upstream( struct cell *Trans , struct sip_msg *p_msg )
805 {
806    unsigned int i            =0 ;
807    unsigned int lowest_i = -1;
808    int                 lowest_v = 999;
809
810    for(  ; i<T->nr_of_outgoings ; i++ )
811       if ( T->inbound_response[i] &&
812            T->inbound_response[i]->REPLY_STATUS>=200 &&
813            T->inbound_response[i]->REPLY_STATUS<lowest_v )
814       {
815          lowest_i =i;
816          lowest_v = T->inbound_response[i]->REPLY_STATUS;
817       }
818
819    DBG("DEBUG: relay_lowest_reply_upstream: lowest reply [%d]=%d\n",lowest_i,lowest_v);
820
821    if ( lowest_i != -1 && push_reply_from_uac_to_uas( T ,lowest_i ) == -1 )
822         return -1;
823
824    return lowest_i;
825 }
826
827
828
829
830 /*
831   */
832 int t_update_timers_after_sending_reply( struct retrans_buff *rb )
833 {
834         struct cell *Trans = rb->my_T;
835
836         /* make sure that if we send something final upstream, everything else
837            will be cancelled */
838         if (Trans->status>=300 && Trans->inbound_request->REQ_METHOD==METHOD_INVITE )
839         {
840                 rb->retr_list = RT_T1_TO_1;
841                 set_timer( hash_table, &(rb->retr_timer), RT_T1_TO_1 );
842                 set_timer( hash_table, &(rb->fr_timer), FR_TIMER_LIST );
843         } else if ( Trans->inbound_request->REQ_METHOD==METHOD_CANCEL ) {
844                 if ( Trans->T_canceled==T_UNDEFINED )
845                         Trans->T_canceled = t_lookupOriginalT( hash_table ,
846                                 Trans->inbound_request );
847                 if ( Trans->T_canceled==T_NULL )
848                         return 1;
849                 /* put CANCEL transaction on wait only if canceled transaction already
850                     is in final status and there is nothing to cancel; */
851                 if ( Trans->T_canceled->status>=200)
852                         t_put_on_wait( Trans );
853         } else if (Trans->status>=200)
854                 t_put_on_wait( Trans );
855    return 1;
856 }
857
858
859
860
861 /* Checks if the new reply (with new_code status) should be sent or not
862  *  based on the current
863   * transactin status.
864   * Returns 1 - the response can be sent
865   *         0 - is not indicated to sent
866   */
867 int t_should_relay_response( struct cell *Trans , int new_code )
868 {
869         int T_code;
870
871         T_code = Trans->status;
872
873         if ( T_code >= 200 ) { /* if final response sent out ... */
874                 if (new_code>=200 && new_code < 300  && /* relay only 2xx */
875                         Trans->inbound_request->REQ_METHOD==METHOD_INVITE) {
876                         DBG("DBG: t_should_relay: 200 INV after final sent\n");
877                         return 1;
878                 }
879         } else { /* no final response sent yet */
880                 if (new_code!=100) { /* all but "100 trying" */
881                         DBG("DBG: t_should_relay: !=100 -> relay\n");
882                         return 1;
883                 }
884         }
885         DBG("DBG: t_should_relay: not to be relayed\n");
886         return 0;
887 }
888
889
890
891
892 /*
893   */
894 int t_put_on_wait(  struct cell  *Trans  )
895 {
896         struct timer_link *tl;
897         unsigned int i;
898         if (is_in_timer_list2( &(Trans->wait_tl)))
899         {
900                 DBG("DEBUG: t_put_on_wait: already on wait\n");
901                 return 1;
902         }
903
904         DBG("DEBUG: t_put_on_wait: stopping timers (FR and RETR)\n");
905         /**/
906         for( i=0 ; i<Trans->nr_of_outgoings ; i++ )
907                 if ( Trans->inbound_response[i] && 
908                 REPLY_CLASS(Trans->inbound_response[i])==1)
909                 t_cancel_branch(i);
910
911         /* make double-sure we have finished everything */
912         /* remove from  retranssmision  and  final response   list */
913         reset_retr_timers(hash_table,Trans) ;
914         /* adds to Wait list*/
915         set_timer( hash_table, &(Trans->wait_tl), WT_TIMER_LIST );
916         return 1;
917 }
918
919
920
921
922 /*
923   */
924 int t_cancel_branch(unsigned int branch)
925 {
926         LOG(L_ERR, "ERROR: t_cancel_branch: NOT IMPLEMENTED YET\n");
927 }
928
929
930
931
932 /* Builds an ACK request based on an INVITE request. ACK is send
933   * to same address
934   */
935 int t_build_and_send_ACK( struct cell *Trans, unsigned int branch, struct sip_msg* rpl)
936 {
937    struct sip_msg* p_msg , *r_msg;
938    struct hdr_field *hdr;
939    char *ack_buf, *p, *via;
940    unsigned int len, via_len;
941    int n;
942
943    ack_buf = 0;
944    via =0;
945
946    p_msg = Trans->inbound_request;
947    r_msg = rpl;
948
949    if ( parse_headers(rpl,HDR_TO)==-1 || !rpl->to )
950    {
951         LOG(L_ERR, "ERROR: t_build_and_send_ACK: cannot generate a HBH ACK if key HFs in INVITE missing\n");
952         goto error;
953    }
954
955     len = 0;
956     /*first line's len */
957     len += 4+p_msg->first_line.u.request.uri.len+1+p_msg->first_line.u.request.version.len+CRLF_LEN;
958     /*via*/
959     via = via_builder( p_msg , &via_len );
960     if (!via)
961     {
962         LOG(L_ERR, "ERROR: t_build_and_send_ACK: no via header got from builder\n");
963         goto error;
964     }
965     len+= via_len;
966     /*headers*/
967    for ( hdr=p_msg->headers ; hdr ; hdr=hdr->next )
968       if ( hdr->type==HDR_FROM || hdr->type==HDR_CALLID || hdr->type==HDR_CSEQ )
969                  len += ((hdr->body.s+hdr->body.len ) - hdr->name.s ) + CRLF_LEN ;
970       else if ( hdr->type==HDR_TO )
971                  len += ((r_msg->to->body.s+r_msg->to->body.len ) - r_msg->to->name.s ) + CRLF_LEN ;
972       /*else if ( hdr->type==HDR_)*/
973
974    /* CSEQ method : from INVITE-> ACK */
975    len -= 3  ;
976    /* end of message */
977    len += CRLF_LEN; /*new line*/
978
979    ack_buf = (char *)pkg_malloc( len +1);
980    if (!ack_buf)
981    {
982        LOG(L_ERR, "ERROR: t_build_and_send_ACK: cannot allocate memory\n");
983        goto error;
984    }
985
986    p = ack_buf;
987    DBG("DEBUG: t_build_and_send_ACK: len = %d \n",len);
988
989    /* first line */
990    memcpy( p , "ACK " , 4);
991    p += 4;
992
993    memcpy( p , p_msg->orig+(p_msg->first_line.u.request.uri.s-p_msg->buf) , p_msg->first_line.u.request.uri.len );
994    p += p_msg->first_line.u.request.uri.len;
995
996    *(p++) = ' ';
997
998    memcpy( p , p_msg->orig+(p_msg->first_line.u.request.version.s-p_msg->buf) , p_msg->first_line.u.request.version.len );
999    p += p_msg->first_line.u.request.version.len;
1000
1001    memcpy( p, CRLF, CRLF_LEN );
1002    p+=CRLF_LEN;
1003
1004    /* insert our via */
1005    memcpy( p , via , via_len );
1006    p += via_len;
1007
1008    /*other headers*/
1009    for ( hdr=p_msg->headers ; hdr ; hdr=hdr->next )
1010    {
1011       if ( hdr->type==HDR_FROM || hdr->type==HDR_CALLID  )
1012         {
1013                 memcpy( p , p_msg->orig+(hdr->name.s-p_msg->buf) ,
1014                         ((hdr->body.s+hdr->body.len ) - hdr->name.s ) );
1015                 p += ((hdr->body.s+hdr->body.len ) - hdr->name.s );
1016                 memcpy( p, CRLF, CRLF_LEN );
1017                 p+=CRLF_LEN;
1018         }
1019       else if ( hdr->type==HDR_TO )
1020         {
1021                 memcpy( p , r_msg->orig+(r_msg->to->name.s-r_msg->buf) ,
1022                         ((r_msg->to->body.s+r_msg->to->body.len ) - r_msg->to->name.s ) );
1023                 p += ((r_msg->to->body.s+r_msg->to->body.len ) - r_msg->to->name.s );
1024                 memcpy( p, CRLF, CRLF_LEN );
1025                 p+=CRLF_LEN;
1026         }
1027        else if ( hdr->type==HDR_CSEQ )
1028         {
1029                 memcpy( p , p_msg->orig+(hdr->name.s-p_msg->buf) ,
1030                         (( ((struct cseq_body*)hdr->parsed)->method.s ) - hdr->name.s ) );
1031                 p += (( ((struct cseq_body*)hdr->parsed)->method.s ) - hdr->name.s );
1032                 memcpy( p , "ACK" CRLF, 3+CRLF_LEN );
1033                 p += 3+CRLF_LEN;
1034         }
1035     }
1036
1037     memcpy( p , CRLF , CRLF_LEN );
1038     p += CRLF_LEN;
1039
1040    /* sends the ACK message to the same destination as the INVITE */
1041    udp_send( ack_buf, p-ack_buf, (struct sockaddr*)&(Trans->outbound_request[branch]->to) , sizeof(struct sockaddr_in) );
1042
1043    /* registering the ACK as received, processed and send */
1044    Trans->outbound_request_isACKed[branch] = 1;
1045    if ( (Trans->outbound_request[branch]->retr_buffer =
1046       (char*)shm_resize( Trans->outbound_request[branch]->retr_buffer, p-ack_buf) ))
1047    {
1048        memcpy ( Trans->outbound_request[branch]->retr_buffer , ack_buf , p-ack_buf);
1049        Trans->outbound_request[branch]->bufflen = p-ack_buf;
1050    }
1051    else
1052        Trans->outbound_request[branch]->bufflen = 0;
1053
1054
1055    DBG("DEBUG: t_build_and_send_ACK: ACK sent\n");
1056
1057    /* free mem*/
1058    if (ack_buf) pkg_free( ack_buf );
1059    if (via) pkg_free(via );
1060    return 0;
1061
1062 error:
1063    if (ack_buf) free( ack_buf );
1064    if (via) pkg_free(via );
1065    return -1;
1066 }
1067
1068
1069 void delete_cell( struct cell *p_cell )
1070 {
1071 #ifdef EXTRA_DEBUG
1072         int i;
1073
1074         if (is_in_timer_list2(& p_cell->wait_tl )) {
1075                 LOG( L_ERR, "ERROR: transaction %p scheduled for deletion and still on WAIT\n",
1076                         p_cell);
1077                 abort();
1078         }
1079         if (is_in_timer_list2(& p_cell->outbound_response.retr_timer )) {
1080                 LOG( L_ERR, "ERROR: transaction %p scheduled for deletion and still on RETR (rep)\n",
1081                         p_cell);
1082                 abort();
1083         }
1084         if (is_in_timer_list2(& p_cell->outbound_response.fr_timer )) {
1085                 LOG( L_ERR, "ERROR: transaction %p scheduled for deletion and still on FR (rep)\n",
1086                         p_cell);
1087                 abort();
1088         }
1089         for (i=0; i<p_cell->nr_of_outgoings; i++) {
1090                 if (is_in_timer_list2(& p_cell->outbound_request[i]->retr_timer)) {
1091                         LOG( L_ERR, "ERROR: transaction %p scheduled for deletion and still on RETR (req %d)\n",
1092                         p_cell, i);
1093                         abort();
1094                 }
1095                 if (is_in_timer_list2(& p_cell->outbound_request[i]->fr_timer)) {
1096                         LOG( L_ERR, "ERROR: transaction %p scheduled for deletion and still on FR (req %d)\n",
1097                         p_cell, i);
1098                         abort();
1099                 }
1100         }
1101 #endif
1102         /* still in use ... don't delete */
1103         if ( T_IS_REFED(p_cell) ) {
1104 #ifdef  EXTRA_DEBUG
1105                 if (T_REFCOUNTER(p_cell)>1) {
1106                         DBG("DEBUG: while debugging with a single process, ref_count > 1\n");
1107                         DBG("DEBUG: transaction =%p\n", p_cell );
1108                         abort();
1109                 }
1110 #endif
1111                 DBG("DEBUG: delete_cell: t=%p post for delete (refbitmap %x, refcount %d)\n",
1112                         p_cell,p_cell->ref_bitmap, T_REFCOUNTER(p_cell));
1113                 /* it's added to del list for future del */
1114                 set_timer( hash_table, &(p_cell->dele_tl), DELETE_LIST );
1115         } else {
1116                 DBG("DEBUG: delete_handler : delete transaction %p\n", p_cell );
1117                 free_cell( p_cell );
1118         }
1119 }
1120
1121
1122 /* Returns  -1 = error
1123                     0 = OK
1124 */
1125 int get_ip_and_port_from_uri( struct sip_msg* p_msg , unsigned int *param_ip, unsigned int *param_port)
1126 {
1127         struct hostent  *nhost;
1128         unsigned int      ip, port;
1129         struct sip_uri    parsed_uri;
1130         str                      uri;
1131         int                      err;
1132 #ifdef DNS_IP_HACK
1133         int                      len;
1134 #endif
1135
1136         /* the original uri has been changed? */
1137         if (p_msg->new_uri.s==0 || p_msg->new_uri.len==0)
1138                 uri = p_msg->first_line.u.request.uri;
1139         else
1140                 uri = p_msg->new_uri;
1141
1142         /* parsing the request uri in order to get host and port */
1143         if (parse_uri( uri.s , uri.len , &parsed_uri )<0)
1144         {
1145                 LOG(L_ERR, "ERROR: get_ip_and_port_from_uri: "
1146                    "unable to parse destination uri\n");
1147                 goto error;
1148         }
1149
1150         /* getting the port */
1151         if ( parsed_uri.port.s==0 || parsed_uri.port.len==0 )
1152                 port = SIP_PORT;
1153         else{
1154                 port = str2s( parsed_uri.port.s , parsed_uri.port.len , &err );
1155                 if ( err<0 ){
1156                         LOG(L_ERR, "ERROR: get_ip_and_port_from_uri: "
1157                           "converting port from str to int failed; using default SIP port\n");
1158                         port = SIP_PORT;
1159                 }
1160         }
1161         port = htons( port );
1162
1163         /* getting host address*/
1164 #ifdef DNS_IP_HACK
1165         len=strlen( parsed_uri.host.s );
1166         ip=str2ip(parsed_uri.host.s, len, &err);
1167         if (err==0)
1168                 goto success;
1169 #endif
1170         /* fail over to normal lookup */
1171         nhost = gethostbyname( parsed_uri.host.s );
1172         if ( !nhost )
1173         {
1174                 LOG(L_ERR, "ERROR: get_ip_and_port_from_uri: "
1175                   "cannot resolve host\n");
1176                 goto error;
1177         }
1178         memcpy(&ip, nhost->h_addr_list[0], sizeof(unsigned int));
1179
1180
1181 success:
1182         *param_ip = ip;
1183         *param_port = port;
1184         return 0;
1185
1186 error:
1187         *param_ip = 0;
1188         *param_port = 0;
1189         return -1;
1190 }
1191
1192
1193
1194
1195
1196
1197 /*---------------------TIMEOUT HANDLERS--------------------------*/
1198
1199
1200 void retransmission_handler( void *attr)
1201 {
1202         struct retrans_buff* r_buf ;
1203         enum lists id;
1204
1205         r_buf = (struct retrans_buff*)attr;
1206 #ifdef EXTRA_DEBUG
1207         if (r_buf->my_T->damocles) {
1208                 LOG( L_ERR, "ERROR: transaction %p scheduled for deletion and called from RETR timer\n",
1209                         r_buf->my_T);
1210                 abort();
1211         }       
1212 #endif
1213
1214
1215         /*the transaction is already removed from RETRANSMISSION_LIST by timer*/
1216
1217         /* retransmision */
1218         DBG("DEBUG: retransmission_handler : resending (t=%p)\n", r_buf->my_T);
1219         SEND_BUFFER( r_buf );
1220
1221         id = r_buf->retr_list;
1222         r_buf->retr_list = id < RT_T2 ? id + 1 : RT_T2;
1223
1224         set_timer( hash_table, &(r_buf->retr_timer), id < RT_T2 ? id + 1 : RT_T2 );
1225
1226         DBG("DEBUG: retransmission_handler : done\n");
1227 }
1228
1229
1230
1231
1232 void final_response_handler( void *attr)
1233 {
1234         struct retrans_buff* r_buf = (struct retrans_buff*)attr;
1235
1236 #ifdef EXTRA_DEBUG
1237         if (r_buf->my_T->damocles) {
1238                 LOG( L_ERR, "ERROR: transaction %p scheduled for deletion and called from FR timer\n",
1239                         r_buf->my_T);
1240                 abort();
1241         }       
1242 #endif
1243
1244         /* the transaction is already removed from FR_LIST by the timer */
1245         /* send a 408 */
1246         if ( r_buf->my_T->status<200)
1247         {
1248                 DBG("DEBUG: final_response_handler:stop retransmission and send 408 (t=%p)\n", r_buf->my_T);
1249                 reset_timer( hash_table, &(r_buf->retr_timer) );
1250                 /* dirty hack: t_send_reply would increase ref_count which would indeed
1251                    result in refcount++ which would not -- until timer processe's
1252                    T changes again; currently only on next call to t_send_reply from
1253                    FR timer; thus I fake the values now to avoid recalculating T
1254                    and refcount++
1255
1256                         -jku
1257             */
1258                 T=r_buf->my_T;
1259                 global_msg_id=T->inbound_request->id;
1260
1261                 t_send_reply( r_buf->my_T->inbound_request , 408 , "Request Timeout" );
1262         } else {
1263                 /* put it on WT_LIST - transaction is over */
1264                 DBG("DEBUG: final_response_handler:cancel transaction->put on wait (t=%p)\n", r_buf->my_T);
1265                 t_put_on_wait(  r_buf->my_T );
1266         }
1267         DBG("DEBUG: final_response_handler : done\n");
1268 }
1269
1270
1271
1272
1273 void wait_handler( void *attr)
1274 {
1275         struct cell *p_cell = (struct cell*)attr;
1276
1277 #ifdef EXTRA_DEBUG
1278         if (p_cell->damocles) {
1279                 LOG( L_ERR, "ERROR: transaction %p scheduled for deletion and called from WAIT timer\n",
1280                         p_cell);
1281                 abort();
1282         }       
1283 #endif
1284
1285         /* the transaction is already removed from WT_LIST by the timer */
1286         /* the cell is removed from the hash table */
1287         DBG("DEBUG: wait_handler : removing %p from table \n", p_cell );
1288         remove_from_hash_table( hash_table, p_cell );
1289         DBG("DEBUG: wait_handler : stopping all timers\n");
1290         reset_retr_timers(hash_table,p_cell) ;
1291         /* put it on DEL_LIST - sch for del */
1292 #ifdef EXTRA_DEBUG
1293         p_cell->damocles = 1;
1294 #endif
1295         delete_cell( p_cell );
1296         DBG("DEBUG: wait_handler : done\n");
1297 }
1298
1299
1300 void delete_handler( void *attr)
1301 {
1302         struct cell *p_cell = (struct cell*)attr;
1303
1304         DBG("DEBUG: delete_handler : removing %p \n", p_cell );
1305 #ifdef EXTRA_DEBUG
1306         if (p_cell->damocles==0) {
1307                 LOG( L_ERR, "ERROR: transaction %p not scheduled for deletion and called from DELETE timer\n",
1308                         p_cell);
1309                 abort();
1310         }       
1311 #endif
1312         delete_cell( p_cell );
1313     DBG("DEBUG: delete_handler : done\n");
1314 }