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