15cdabbb25989bdbdc9c50a57dfaf0c7daa5efa7
[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    t_check( p_msg , 0 );
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         t_check( p_msg  , 0 );
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    t_check( p_msg , 0);
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 ( parse_headers(p_msg, HDR_VIA1|HDR_VIA2|HDR_TO|HDR_CSEQ )==-1 ||
432                 !p_msg->via1 || !p_msg->via2 || !p_msg->to || !p_msg->cseq )
433         return 1;
434
435         /* we use label-matching to lookup for T */
436         t_check( p_msg , &branch );
437
438         /* if no T found ->tell the core router to forward statelessly */
439         if ( T<=0 )
440                 return 1;
441         DBG("DEBUG: t_on_reply_received: Original status =%d\n",T->status);
442
443         /* we were not able to process the response due to memory
444            shortage; simply drop it; hopefuly, we will have more
445            memory on the next try 
446         */
447         msg_status=p_msg->REPLY_STATUS;
448         msg_class=REPLY_CLASS(p_msg);
449         relay = t_should_relay_response( T , msg_status );
450         if (relay && !(clone=sip_msg_cloner( p_msg ))) {
451                 t_unref( p_msg, NULL, NULL );
452                 return 0;
453         }
454
455         rb=T->outbound_request[branch];
456
457         /* stop retransmission */
458         reset_timer( hash_table, &(rb->retr_timer));
459
460         /* stop final response timer only if I got a final response */
461         if ( msg_class>1 )
462                 reset_timer( hash_table, &(rb->fr_timer));
463         /* if a got the first prov. response for an INVITE -> 
464            change FR_TIME_OUT to INV_FR_TIME_UT */
465         if (!T->inbound_response[branch] && msg_class==1
466          && T->inbound_request->REQ_METHOD==METHOD_INVITE )
467                 set_timer( hash_table, &(rb->fr_timer), FR_INV_TIMER_LIST );
468
469         /* get response for INVITE */
470         if ( T->inbound_request->REQ_METHOD==METHOD_INVITE )
471         {
472                 if ( T->outbound_request_isACKed[branch] )
473                 {   /*retransmit*/
474                         SEND_BUFFER( T->outbound_request[branch] );
475                 } else if (msg_class>2 ) {   /*on a non-200 reply to INVITE*/
476                         DBG("DEBUG: t_on_reply_received: >=3xx reply to INVITE: send ACK\n");
477                         if ( t_build_and_send_ACK( T , branch , p_msg )==-1)
478                         {
479                                 LOG( L_ERR , "ERROR: t_on_reply_received: unable to send ACK\n" );
480                                                 if (clone ) sip_msg_free( clone );
481                                                 t_unref( p_msg, NULL, NULL );
482                                 return 0;
483                         }
484                 }
485         }
486
487 #       ifdef FORKING
488         /* skipped for the moment*/
489 #       endif
490
491         /* if the incoming response code is not reliable->drop it*/
492         if (!relay) {
493                 t_unref( p_msg, NULL, NULL );
494                 return 0;
495         }
496
497         /* restart retransmission if provisional response came for a non_INVITE -> 
498                 retrasmit at RT_T2*/
499         if ( msg_class==1 && T->inbound_request->REQ_METHOD!=METHOD_INVITE )
500         {
501                 rb->retr_list = RT_T2;
502                 set_timer( hash_table, &(rb->retr_timer), RT_T2 );
503         }
504
505         /*store the inbound reply - if there is a previous reply, replace it */
506         if ( T->inbound_response[branch] ) {
507                 sip_msg_free( T->inbound_response[branch] ) ;
508                 DBG("DEBUG: t_store_incoming_reply: previous inbound reply freed....\n");
509         }
510         T->inbound_response[branch] = clone;
511
512         if ( msg_class>=3 && msg_class<=5 )
513         {
514                 if ( t_all_final(T) && relay_lowest_reply_upstream( T , p_msg )==-1 && clone )
515                         goto error;
516         } else {
517                 if (push_reply_from_uac_to_uas( T , branch )==-1 && clone ) 
518                         goto error;
519         }
520
521         /* nothing to do for the ser core */
522         t_unref( p_msg, NULL, NULL );
523         return 0;
524
525 error:
526         t_unref( p_msg, NULL, NULL );
527         T->inbound_response[branch]=NULL;
528         sip_msg_free( clone );
529         return -1;
530 }
531
532
533
534
535 /*   returns 1 if everything was OK or -1 for error
536   */
537 int t_release_transaction( struct sip_msg* p_msg)
538 {
539    t_check( p_msg , 0 );
540
541    if ( T && T!=T_UNDEFINED )
542       return t_put_on_wait( T );
543
544    return 1;
545 }
546
547
548
549
550 /* Retransmits the last sent inbound reply.
551
552   * input: p_msg==request for which I want to retransmit an associated
553     reply
554   * Returns  -1 -error
555   *                1 - OK
556   */
557 int t_retransmit_reply( struct sip_msg* p_msg, char* foo, char* bar  )
558 {
559    t_check( p_msg , 0 );
560
561    /* if no transaction exists or no reply to be resend -> out */
562    if ( T )
563    {
564         SEND_BUFFER( & T->outbound_response );
565         return 1;
566    }
567
568   /* no transaction found */
569    return -1;
570 }
571
572 int t_unref( struct sip_msg* p_msg, char* foo, char* bar )
573 {
574         if (T==T_UNDEFINED || T==T_NULL)
575                 return -1;
576         unref_T(T);
577         T=T_UNDEFINED;
578         return 1;
579 }
580
581
582
583
584 /* Force a new response into inbound response buffer.
585   * returns 1 if everything was OK or -1 for erro
586   */
587 int t_send_reply(  struct sip_msg* p_msg , unsigned int code , char * text )
588 {
589         unsigned int len;
590         char * buf;
591         struct retrans_buff *rb;
592         char *b;
593
594         DBG("DEBUG: t_send_reply: entered\n");
595         t_check( p_msg , 0 );
596
597         if (!T)
598         {
599                 LOG(L_ERR, "ERROR: t_send_reply: cannot send a t_reply to a message "
600                         "for which no T-state has been established\n");
601                 return -1;
602         }
603
604         /* if the incoming response code is not reliable->drop it*/
605         /*
606         if ( !t_should_relay_response( T , code ) )
607                 return 1;
608         */
609
610         rb = & T->outbound_response;
611         if (!rb->retr_buffer) {
612                 /* initialize retransmission structure */
613                 memset( rb , 0 , sizeof (struct retrans_buff) );
614                 if (update_sock_struct_from_via(  &(rb->to),  p_msg->via1 )==-1)
615                 {
616                         LOG(L_ERR, "ERROR: t_send_reply: cannot lookup reply dst: %s\n",
617                                 p_msg->via1->host.s );
618                         goto error;
619                 }
620
621                 rb->retr_timer.payload = rb;
622                 rb->fr_timer.payload = rb;
623                 rb->to.sin_family = AF_INET;
624                 rb->my_T = T;
625         }
626
627         buf = build_res_buf_from_sip_req( code , text , T->inbound_request , &len );
628         DBG("DEBUG: t_send_reply: buffer computed\n");
629         if (!buf)
630         {
631                 DBG("DEBUG: t_send_reply: response building failed\n");
632                 goto error;
633         }
634
635         if (! (b = (char*)sh_malloc( len )))
636         {
637                 LOG(L_ERR, "ERROR: t_send_reply: cannot allocate shmem buffer\n");
638                 goto error2;
639         }
640         /* if present, remove previous message */
641         if (  rb->retr_buffer)
642                 sh_free( rb->retr_buffer );
643         rb->retr_buffer   = b;
644         rb->bufflen = len ;
645         memcpy( rb->retr_buffer , buf , len );
646         free( buf ) ;
647         T->status = code;
648
649         /* start/stops the proper timers*/
650         DBG("DEBUG: t_send_reply: update timers\n");
651         t_update_timers_after_sending_reply( rb );
652
653         DBG("DEBUG: t_send_reply: send reply\n");
654         /* t_retransmit_reply( p_msg, 0 , 0); */
655         SEND_BUFFER( rb );
656
657         return 1;
658
659 error2:
660         free ( buf );
661 error:
662         return -1;
663 }
664
665
666
667 /* Push a previously stored reply from UA Client to UA Server
668   * and send it out
669   */
670 int push_reply_from_uac_to_uas( struct cell* trans , unsigned int branch )
671 {
672         char *buf;
673         unsigned int len;
674         struct retrans_buff *rb;
675         char *b;
676
677         DBG("DEBUG: push_reply_from_uac_to_uas: start\n");
678         rb= & trans->outbound_response;
679         /* if there is a reply, release the buffer (everything else stays same) */
680         if ( ! rb->retr_buffer ) {
681                 /*init retrans buffer*/
682                 memset( rb , 0 , sizeof (struct retrans_buff) );
683                 if (update_sock_struct_from_via(  &(rb->to),  
684                         trans->inbound_response[branch]->via2 )==-1) {
685                                 LOG(L_ERR, "ERROR: push_reply_from_uac_to_uas: "
686                                         "cannot lookup reply dst: %s\n",
687                                 trans->inbound_response[branch]->via2->host.s );
688                                 goto error;
689                 }
690                 rb->retr_timer.payload = rb;
691                 rb->fr_timer.payload =  rb;
692                 rb->to.sin_family = AF_INET;
693                 rb->my_T = trans;
694
695         } else {
696                 reset_timer( hash_table, &(rb->retr_timer));
697                 reset_timer( hash_table, &(rb->fr_timer));
698         }
699
700         /*  generate the retrans buffer */
701         buf = build_res_buf_from_sip_res ( trans->inbound_response[branch], &len);
702         if (!buf) {
703                 LOG(L_ERR, "ERROR: push_reply_from_uac_to_uas: "
704                         "no shmem for outbound reply buffer\n");
705                 goto error;
706         }
707         if ( !(b = (char*)sh_malloc( len ))) {
708                 LOG(L_ERR, "ERROR: push_reply_from_uac_to_uas: "
709                         "no memory to allocate retr_buffer\n");
710                 goto error1;
711         }
712         if (  rb->retr_buffer ) 
713                 sh_free(  rb->retr_buffer ) ;  
714         rb->retr_buffer = b;
715         rb->bufflen = len ;
716         memcpy( rb->retr_buffer , buf , len );
717         free( buf ) ;
718
719         /* update the status*/
720         trans->status = trans->inbound_response[branch]->REPLY_STATUS;
721         if ( trans->inbound_response[branch]->REPLY_STATUS>=200 &&
722          trans->relaied_reply_branch==-1 )
723                 trans->relaied_reply_branch = branch;
724
725         /* start/stops the proper timers*/
726         t_update_timers_after_sending_reply( rb );
727
728         /*send the reply*/
729         /* t_retransmit_reply( trans->inbound_response[branch], 0 , 0 ); */
730         SEND_BUFFER( rb );
731         return 1;
732
733 error1:
734         free( buf );
735 error:
736         return -1;
737 }
738
739
740
741
742
743 /* ----------------------------HELPER FUNCTIONS-------------------------------- */
744
745
746
747
748 /*  Checks if all the transaction's outbound request has a final response.
749   *  Return   1 - all are final
750   *                0 - some waitting
751   */
752 int t_all_final( struct cell *Trans )
753 {
754    unsigned int i;
755
756    for( i=0 ; i<Trans->nr_of_outgoings ; i++  )
757       if (  !Trans->inbound_response[i] ||  
758                         Trans->inbound_response[i]->REPLY_STATUS<=200 )
759          return 0;
760
761   DBG("DEBUG: t_all_final: final state!!!!:)) \n");
762   return 1;
763 }
764
765
766
767
768 /* Picks the lowest code reply and send it upstream.
769   *  Returns -1 if no lowest find reply found (all provisional)
770   */
771 int relay_lowest_reply_upstream( struct cell *Trans , struct sip_msg *p_msg )
772 {
773    unsigned int i            =0 ;
774    unsigned int lowest_i = -1;
775    int                 lowest_v = 999;
776
777    for(  ; i<T->nr_of_outgoings ; i++ )
778       if ( T->inbound_response[i] &&
779            T->inbound_response[i]->REPLY_STATUS>=200 &&
780            T->inbound_response[i]->REPLY_STATUS<lowest_v )
781       {
782          lowest_i =i;
783          lowest_v = T->inbound_response[i]->REPLY_STATUS;
784       }
785
786    DBG("DEBUG: relay_lowest_reply_upstream: lowest reply [%d]=%d\n",lowest_i,lowest_v);
787
788    if ( lowest_i != -1 && push_reply_from_uac_to_uas( T ,lowest_i ) == -1 )
789         return -1;
790
791    return lowest_i;
792 }
793
794
795
796
797 /*
798   */
799 int t_update_timers_after_sending_reply( struct retrans_buff *rb )
800 {
801         struct cell *Trans = rb->my_T;
802
803         /* make sure that if we send something final upstream, everything else 
804            will be cancelled */
805         if (Trans->status>=300 && Trans->inbound_request->REQ_METHOD==METHOD_INVITE )
806         {
807                 rb->retr_list = RT_T1_TO_1;
808                 set_timer( hash_table, &(rb->retr_timer), RT_T1_TO_1 );
809                 set_timer( hash_table, &(rb->fr_timer), FR_TIMER_LIST );
810         } else if ( Trans->inbound_request->REQ_METHOD==METHOD_CANCEL ) {
811                 if ( Trans->T_canceled==T_UNDEFINED )
812                         Trans->T_canceled = t_lookupOriginalT( hash_table , 
813                                 Trans->inbound_request );
814                 if ( Trans->T_canceled==T_NULL )
815                         return 1;
816                 Trans->T_canceled->T_canceler = Trans;
817                 /* put CANCEL transaction on wait only if canceled transaction already
818                    is in final status and there is nothing to cancel; 
819                 */
820                 if ( Trans->T_canceled->status>=200)
821                         t_put_on_wait( Trans );
822         } else if (Trans->status>=200)
823             t_put_on_wait( Trans );
824    return 1;
825 }
826
827
828
829
830 /* Checks if the new reply (with new_code status) should be sent or not 
831  *  based on the current
832   * transactin status. 
833   * Returns 1 - the response can be sent
834   *         0 - is not indicated to sent
835   */
836 int t_should_relay_response( struct cell *Trans , int new_code )
837 {
838         int T_code;
839
840         T_code = Trans->status;
841
842         if ( T_code >= 200 ) { /* if final response sent out ... */
843                 if (new_code>=200 && new_code < 300  && /* relay only 2xx */
844                         Trans->inbound_request->REQ_METHOD==METHOD_INVITE) {
845                         DBG("DBG: t_should_relay: 200 INV after final sent\n");
846                         return 1;
847                 }
848         } else { /* no final response sent yet */
849                 if (new_code!=100) { /* all but "100 trying" */
850                         DBG("DBG: t_should_relay: !=100 -> relay\n");
851                         return 1;
852                 } 
853         }
854         DBG("DBG: t_should_relay: not to be relayed\n");
855         return 0;
856
857
858 /*
859    // have we already sent something? 
860    if ( !Trans->outbound_response.retr_buffer )
861    {
862       DBG("DEBUG: t_should_relay_response: %d response relayed (no previous response sent)\n",new_code);
863       return 1;
864    }
865
866    // have we sent a final response? 
867    if ( (T_code/100)>1 )
868    {  //final response was sent
869       if ( new_code==200 && Trans->inbound_request->REQ_METHOD==METHOD_INVITE )
870       {
871          DBG("DEBUG: t_should_relay_response: %d response relayed (final satus, but 200 to an INVITE)\n",new_code);
872          return 0;
873       }
874    }
875    else
876    { // provisional response was sent 
877       if ( new_code>T_code )
878       {
879          DBG("DEBUG: t_should_relay_response: %d response relayed (higher provisional response)\n",new_code);
880          return 1;
881       }
882    }
883
884    DBG("DEBUG: t_should_relay_response: %d response not relayed\n",new_code);
885    return 0;
886 */
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
973    /* CSEQ method : from INVITE-> ACK, don't count CRLF twice*/
974    len -= 3 + 2 ;
975    /* end of message */
976    len += CRLF_LEN; /*new line*/
977
978    ack_buf = (char *)pkg_malloc( len +1);
979    if (!ack_buf)
980    {
981        LOG(L_ERR, "ERROR: t_build_and_send_ACK: cannot allocate memory\n");
982        goto error;
983    }
984
985    p = ack_buf;
986    DBG("DEBUG: t_build_and_send_ACK: len = %d \n",len);
987
988    /* first line */
989    memcpy( p , "ACK " , 4);
990    p += 4;
991
992    memcpy( p , p_msg->orig+(p_msg->first_line.u.request.uri.s-p_msg->buf) , p_msg->first_line.u.request.uri.len );
993    p += p_msg->first_line.u.request.uri.len;
994
995    *(p++) = ' ';
996
997    memcpy( p , p_msg->orig+(p_msg->first_line.u.request.version.s-p_msg->buf) , p_msg->first_line.u.request.version.len );
998    p += p_msg->first_line.u.request.version.len;
999
1000    memcpy( p, CRLF, CRLF_LEN );
1001    p+=CRLF_LEN;
1002
1003    /* insert our via */
1004    memcpy( p , via , via_len );
1005    p += via_len;
1006
1007    /*other headers*/
1008    for ( hdr=p_msg->headers ; hdr ; hdr=hdr->next )
1009    {
1010       if ( hdr->type==HDR_FROM || hdr->type==HDR_CALLID  )
1011         {
1012                 memcpy( p , p_msg->orig+(hdr->name.s-p_msg->buf) ,
1013                         ((hdr->body.s+hdr->body.len ) - hdr->name.s ) );
1014                 p += ((hdr->body.s+hdr->body.len ) - hdr->name.s );
1015                 memcpy( p, CRLF, CRLF_LEN );
1016                 p+=CRLF_LEN;
1017         }
1018       else if ( hdr->type==HDR_TO )
1019         {
1020                 memcpy( p , r_msg->orig+(r_msg->to->name.s-r_msg->buf) ,
1021                         ((r_msg->to->body.s+r_msg->to->body.len ) - r_msg->to->name.s ) );
1022                 p += ((r_msg->to->body.s+r_msg->to->body.len ) - r_msg->to->name.s );
1023                 memcpy( p, CRLF, CRLF_LEN );
1024                 p+=CRLF_LEN;
1025         }
1026        else if ( hdr->type==HDR_CSEQ )
1027         {
1028                 memcpy( p , p_msg->orig+(hdr->name.s-p_msg->buf) ,
1029                         (( ((struct cseq_body*)hdr->parsed)->method.s ) - hdr->name.s ) );
1030                 p += (( ((struct cseq_body*)hdr->parsed)->method.s ) - hdr->name.s );
1031                 memcpy( p , "ACK" CRLF, 3+CRLF_LEN );
1032                 p += 3+CRLF_LEN;
1033         }
1034     }
1035
1036     memcpy( p , CRLF , CRLF_LEN );
1037     p += CRLF_LEN;
1038
1039    /* sends the ACK message to the same destination as the INVITE */
1040    udp_send( ack_buf, p-ack_buf, (struct sockaddr*)&(T->outbound_request[branch]->to) , sizeof(struct sockaddr_in) );
1041    DBG("DEBUG: t_build_and_send_ACK: ACK sent\n");
1042
1043    /* free mem*/
1044    if (ack_buf) pkg_free( ack_buf );
1045    if (via) pkg_free(via );
1046    return 0;
1047
1048 error:
1049    if (ack_buf) free( ack_buf );
1050    if (via) pkg_free(via );
1051    return -1;
1052 }
1053
1054
1055
1056 /*---------------------TIMEOUT HANDLERS--------------------------*/
1057
1058
1059 void retransmission_handler( void *attr)
1060 {
1061         struct retrans_buff* r_buf ;
1062         enum lists id;
1063
1064         r_buf = (struct retrans_buff*)attr;
1065 #ifdef EXTRA_DEBUG
1066         if (r_buf->my_T->damocles) {
1067                 LOG( L_ERR, "ERROR: transaction %p scheduled for deletion and called from RETR timer\n",
1068                         r_buf->my_T);
1069                 abort();
1070         }       
1071 #endif
1072
1073
1074         /*the transaction is already removed from RETRANSMISSION_LIST by timer*/
1075
1076         /* retransmision */
1077         DBG("DEBUG: retransmission_handler : resending (t=%p)\n", r_buf->my_T);
1078         SEND_BUFFER( r_buf );
1079
1080         id = r_buf->retr_list;
1081         r_buf->retr_list = id < RT_T2 ? id + 1 : RT_T2;
1082
1083         set_timer( hash_table, &(r_buf->retr_timer), id < RT_T2 ? id + 1 : RT_T2 );
1084
1085         DBG("DEBUG: retransmission_handler : done\n");
1086 }
1087
1088
1089
1090
1091 void final_response_handler( void *attr)
1092 {
1093         struct retrans_buff* r_buf = (struct retrans_buff*)attr;
1094
1095 #ifdef EXTRA_DEBUG
1096         if (r_buf->my_T->damocles) {
1097                 LOG( L_ERR, "ERROR: transaction %p scheduled for deletion and called from FR timer\n",
1098                         r_buf->my_T);
1099                 abort();
1100         }       
1101 #endif
1102
1103         /* the transaction is already removed from FR_LIST by the timer */
1104         /* send a 408 */
1105         if ( r_buf->my_T->status<200)
1106         {
1107                 DBG("DEBUG: final_response_handler:stop retransmission and send 408 (t=%p)\n", r_buf->my_T);
1108                 reset_timer( hash_table, &(r_buf->retr_timer) );
1109                 /* dirty hack: t_send_reply would increase ref_count which would indeed
1110                    result in refcount++ which would not -- until timer processe's
1111                    T changes again; currently only on next call to t_send_reply from
1112                    FR timer; thus I fake the values now to avoid recalculating T
1113                    and refcount++
1114
1115                         -jku
1116             */
1117                 T=r_buf->my_T;
1118                 global_msg_id=T->inbound_request->id;
1119
1120                 t_send_reply( r_buf->my_T->inbound_request , 408 , "Request Timeout" );
1121         } else {
1122                 /* put it on WT_LIST - transaction is over */
1123                 DBG("DEBUG: final_response_handler:cancel transaction->put on wait (t=%p)\n", r_buf->my_T);
1124                 t_put_on_wait(  r_buf->my_T );
1125         }
1126         DBG("DEBUG: final_response_handler : done\n");
1127 }
1128
1129
1130
1131
1132 void wait_handler( void *attr)
1133 {
1134         struct cell *p_cell = (struct cell*)attr;
1135
1136 #ifdef EXTRA_DEBUG
1137         if (p_cell->damocles) {
1138                 LOG( L_ERR, "ERROR: transaction %p scheduled for deletion and called from WAIT timer\n",
1139                         p_cell);
1140                 abort();
1141         }       
1142 #endif
1143
1144         /* the transaction is already removed from WT_LIST by the timer */
1145         /* the cell is removed from the hash table */
1146         DBG("DEBUG: wait_handler : removing %p from table \n", p_cell );
1147         remove_from_hash_table( hash_table, p_cell );
1148         DBG("DEBUG: wait_handler : stopping all timers\n");
1149         reset_retr_timers(hash_table,p_cell) ;
1150         /* put it on DEL_LIST - sch for del */
1151 #ifdef EXTRA_DEBUG
1152         p_cell->damocles = 1;
1153 #endif
1154         set_timer( hash_table, &(p_cell->dele_tl), DELETE_LIST );
1155         DBG("DEBUG: wait_handler : done\n");
1156 }
1157
1158
1159
1160
1161 void delete_handler( void *attr)
1162 {
1163         struct cell *p_cell = (struct cell*)attr;
1164
1165 #ifdef EXTRA_DEBUG
1166         int i;
1167         if (p_cell->damocles==0) {
1168                 LOG( L_ERR, "ERROR: transaction %p not scheduled for deletion and called from DELETE timer\n",
1169                         p_cell);
1170                 abort();
1171         }       
1172         if (is_in_timer_list2(& p_cell->wait_tl )) {
1173                 LOG( L_ERR, "ERROR: transaction %p scheduled for deletion and still on WAIT\n",
1174                         p_cell);
1175                 abort();
1176         }
1177         if (is_in_timer_list2(& p_cell->outbound_response.retr_timer )) {
1178                 LOG( L_ERR, "ERROR: transaction %p scheduled for deletion and still on RETR (rep)\n",
1179                         p_cell);
1180                 abort();
1181         }
1182         if (is_in_timer_list2(& p_cell->outbound_response.fr_timer )) {
1183                 LOG( L_ERR, "ERROR: transaction %p scheduled for deletion and still on FR (rep)\n",
1184                         p_cell);
1185                 abort();
1186         }
1187         for (i=0; i<p_cell->nr_of_outgoings; i++) {
1188                 if (is_in_timer_list2(& p_cell->outbound_request[i]->retr_timer)) {
1189                         LOG( L_ERR, "ERROR: transaction %p scheduled for deletion and still on RETR (req %d)\n",
1190                         p_cell, i);
1191                         abort();
1192                 }
1193                 if (is_in_timer_list2(& p_cell->outbound_request[i]->fr_timer)) {
1194                         LOG( L_ERR, "ERROR: transaction %p scheduled for deletion and still on FR (req %d)\n",
1195                         p_cell, i);
1196                         abort();
1197                 }
1198         }
1199
1200 #endif
1201
1202         /* the transaction is already removed from DEL_LIST by the timer */
1203         /* if is not refenceted -> is deleted*/
1204         if ( p_cell->ref_counter==0 )
1205         {
1206                 DBG("DEBUG: delete_handler : delete transaction %p\n", p_cell );
1207                 free_cell( p_cell );
1208         } else {
1209 #ifdef  EXTRA_DEBUG
1210                 if (p_cell->ref_counter>1) {
1211                         DBG("DEBUG: while debugging with a single process, ref_count > 1\n");
1212                         DBG("DEBUG: transaction =%p\n", p_cell );
1213                         abort();
1214                 }
1215 #endif
1216                 DBG("DEBUG: delete_handler: t=%p post for delete (%d)\n",
1217                         p_cell,p_cell->ref_counter);
1218                 /* else it's readded to del list for future del */
1219                 set_timer( hash_table, &(p_cell->dele_tl), DELETE_LIST );
1220     }
1221     DBG("DEBUG: delete_handler : done\n");
1222 }
1223
1224
1225