sjero.net Git - linphone/blob - coreapi/sal_eXosip2.c

   1 /*
   2 linphone
   3 Copyright (C) 2010  Simon MORLAT (simon.morlat@free.fr)
   4
   5 This program is free software; you can redistribute it and/or
   6 modify it under the terms of the GNU General Public License
   7 as published by the Free Software Foundation; either version 2
   8 of the License, or (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18 */
  19 #ifdef HAVE_CONFIG_H
  20 #include "config.h"
  21 #endif
  22
  23 #include "sal_eXosip2.h"
  24 #include "private.h"
  25 #include "offeranswer.h"
  26
  27 #ifdef ANDROID
  28 // Necessary to make it linked
  29 static void for_linker() { eXosip_transport_hook_register(NULL); }
  30 #endif
  31 static bool_t call_failure(Sal *sal, eXosip_event_t *ev);
  32
  33 static void text_received(Sal *sal, eXosip_event_t *ev);
  34
  35 static void masquerade_via(osip_message_t *msg, const char *ip, const char *port);
  36 static bool_t fix_message_contact(SalOp *op, osip_message_t *request,osip_message_t *last_answer, bool_t expire_last_contact);
  37 static void update_contact_from_response(SalOp *op, osip_message_t *response);
  38
  39 void _osip_list_set_empty(osip_list_t *l, void (*freefunc)(void*)){
  40         void *data;
  41         while(!osip_list_eol(l,0)) {
  42                 data=osip_list_get(l,0);
  43                 osip_list_remove(l,0);
  44                 if (data) freefunc(data);
  45         }
  46 }
  47
  48 void sal_get_default_local_ip(Sal *sal, int address_family,char *ip, size_t iplen){
  49         if (eXosip_guess_localip(address_family,ip,iplen)<0){
  50                 /*default to something */
  51                 strncpy(ip,address_family==AF_INET6 ? "::1" : "127.0.0.1",iplen);
  52                 ms_error("Could not find default routable ip address !");
  53         }
  54 }
  55
  56
  57 static SalOp * sal_find_call(Sal *sal, int cid){
  58         const MSList *elem;
  59         SalOp *op;
  60         for(elem=sal->calls;elem!=NULL;elem=elem->next){
  61                 op=(SalOp*)elem->data;
  62                 if (op->cid==cid) return op;
  63         }
  64         return NULL;
  65 }
  66
  67 static void sal_add_call(Sal *sal, SalOp *op){
  68         sal->calls=ms_list_append(sal->calls,op);
  69 }
  70
  71 static void sal_remove_call(Sal *sal, SalOp *op){
  72         sal->calls=ms_list_remove(sal->calls, op);
  73 }
  74
  75 static SalOp * sal_find_register(Sal *sal, int rid){
  76         const MSList *elem;
  77         SalOp *op;
  78         for(elem=sal->registers;elem!=NULL;elem=elem->next){
  79                 op=(SalOp*)elem->data;
  80                 if (op->rid==rid) return op;
  81         }
  82         return NULL;
  83 }
  84
  85 static void sal_add_register(Sal *sal, SalOp *op){
  86         sal->registers=ms_list_append(sal->registers,op);
  87 }
  88
  89 static void sal_remove_register(Sal *sal, int rid){
  90         MSList *elem;
  91         SalOp *op;
  92         for(elem=sal->registers;elem!=NULL;elem=elem->next){
  93                 op=(SalOp*)elem->data;
  94                 if (op->rid==rid) {
  95                         sal->registers=ms_list_remove_link(sal->registers,elem);
  96                         return;
  97                 }
  98         }
  99 }
 100
 101 static SalOp * sal_find_other(Sal *sal, osip_message_t *response){
 102         const MSList *elem;
 103         SalOp *op;
 104         osip_call_id_t *callid=osip_message_get_call_id(response);
 105         if (callid==NULL) {
 106                 ms_error("There is no call-id in this response !");
 107                 return NULL;
 108         }
 109         for(elem=sal->other_transactions;elem!=NULL;elem=elem->next){
 110                 op=(SalOp*)elem->data;
 111                 if (osip_call_id_match(callid,op->call_id)==0) return op;
 112         }
 113         return NULL;
 114 }
 115
 116 void sal_add_other(Sal *sal, SalOp *op, osip_message_t *request){
 117         osip_call_id_t *callid=osip_message_get_call_id(request);
 118         if (callid==NULL) {
 119                 ms_error("There is no call id in the request !");
 120                 return;
 121         }
 122         osip_call_id_clone(callid,&op->call_id);
 123         sal->other_transactions=ms_list_append(sal->other_transactions,op);
 124 }
 125
 126 static void sal_remove_other(Sal *sal, SalOp *op){
 127         sal->other_transactions=ms_list_remove(sal->other_transactions,op);
 128 }
 129
 130
 131 static void sal_add_pending_auth(Sal *sal, SalOp *op){
 132         sal->pending_auths=ms_list_append(sal->pending_auths,op);
 133 }
 134
 135
 136 static void sal_remove_pending_auth(Sal *sal, SalOp *op){
 137         sal->pending_auths=ms_list_remove(sal->pending_auths,op);
 138 }
 139
 140 void sal_exosip_fix_route(SalOp *op){
 141         if (sal_op_get_route(op)!=NULL){
 142                 osip_route_t *rt=NULL;
 143                 osip_uri_param_t *lr_param=NULL;
 144
 145                 osip_route_init(&rt);
 146                 if (osip_route_parse(rt,sal_op_get_route(op))<0){
 147                         ms_warning("Bad route  %s!",sal_op_get_route(op));
 148                         sal_op_set_route(op,NULL);
 149                 }else{
 150                         /* check if the lr parameter is set , if not add it */
 151                         osip_uri_uparam_get_byname(rt->url, "lr", &lr_param);
 152                         if (lr_param==NULL){
 153                                 char *tmproute;
 154                                 osip_uri_uparam_add(rt->url,osip_strdup("lr"),NULL);
 155                                 osip_route_to_str(rt,&tmproute);
 156                                 sal_op_set_route(op,tmproute);
 157                                 osip_free(tmproute);
 158                         }
 159                 }
 160                 osip_route_free(rt);
 161         }
 162 }
 163
 164 SalOp * sal_op_new(Sal *sal){
 165         SalOp *op=ms_new0(SalOp,1);
 166         __sal_op_init(op,sal);
 167         op->cid=op->did=op->tid=op->rid=op->nid=op->sid=-1;
 168         op->result=NULL;
 169         op->supports_session_timers=FALSE;
 170         op->sdp_offering=TRUE;
 171         op->pending_auth=NULL;
 172         op->sdp_answer=NULL;
 173         op->reinvite=FALSE;
 174         op->call_id=NULL;
 175         op->replaces=NULL;
 176         op->referred_by=NULL;
 177         op->masquerade_via=FALSE;
 178         op->auto_answer_asked=FALSE;
 179         op->auth_info=NULL;
 180         op->terminated=FALSE;
 181         return op;
 182 }
 183
 184 bool_t sal_call_autoanswer_asked(SalOp *op)
 185 {
 186         return op->auto_answer_asked;
 187 }
 188
 189 void sal_op_release(SalOp *op){
 190         if (op->sdp_answer)
 191                 sdp_message_free(op->sdp_answer);
 192         if (op->pending_auth)
 193                 eXosip_event_free(op->pending_auth);
 194         if (op->rid!=-1){
 195                 sal_remove_register(op->base.root,op->rid);
 196                 eXosip_register_remove(op->rid);
 197         }
 198         if (op->cid!=-1){
 199                 ms_message("Cleaning cid %i",op->cid);
 200                 sal_remove_call(op->base.root,op);
 201         }
 202         if (op->sid!=-1){
 203                 sal_remove_out_subscribe(op->base.root,op);
 204         }
 205         if (op->nid!=-1){
 206                 sal_remove_in_subscribe(op->base.root,op);
 207                 if (op->call_id)
 208                         osip_call_id_free(op->call_id);
 209                 op->call_id=NULL;
 210         }
 211         if (op->pending_auth){
 212                 sal_remove_pending_auth(op->base.root,op);
 213         }
 214         if (op->result)
 215                 sal_media_description_unref(op->result);
 216         if (op->call_id){
 217                 sal_remove_other(op->base.root,op);
 218                 osip_call_id_free(op->call_id);
 219         }
 220         if (op->replaces){
 221                 ms_free(op->replaces);
 222         }
 223         if (op->referred_by){
 224                 ms_free(op->referred_by);
 225         }
 226         if (op->auth_info) {
 227                 sal_auth_info_delete(op->auth_info);
 228         }
 229         __sal_op_free(op);
 230 }
 231
 232 static void _osip_trace_func(char *fi, int li, osip_trace_level_t level, char *chfr, va_list ap){
 233         int ortp_level=ORTP_DEBUG;
 234         switch(level){
 235                 case OSIP_INFO1:
 236                 case OSIP_INFO2:
 237                 case OSIP_INFO3:
 238                 case OSIP_INFO4:
 239                         ortp_level=ORTP_MESSAGE;
 240                         break;
 241                 case OSIP_WARNING:
 242                         ortp_level=ORTP_WARNING;
 243                         break;
 244                 case OSIP_ERROR:
 245                 case OSIP_BUG:
 246                         ortp_level=ORTP_ERROR;
 247                         break;
 248                 case OSIP_FATAL:
 249                         ortp_level=ORTP_FATAL;
 250                         break;
 251                 case END_TRACE_LEVEL:
 252                         break;
 253         }
 254         if (ortp_log_level_enabled(level)){
 255                 int len=strlen(chfr);
 256                 char *chfrdup=ortp_strdup(chfr);
 257                 /*need to remove endline*/
 258                 if (len>1){
 259                         if (chfrdup[len-1]=='\n')
 260                                 chfrdup[len-1]='\0';
 261                         if (chfrdup[len-2]=='\r')
 262                                 chfrdup[len-2]='\0';
 263                 }
 264                 ortp_logv(ortp_level,chfrdup,ap);
 265                 ortp_free(chfrdup);
 266         }
 267 }
 268
 269
 270 Sal * sal_init(){
 271         static bool_t firsttime=TRUE;
 272         Sal *sal;
 273         if (firsttime){
 274                 osip_trace_initialize_func (OSIP_INFO4,&_osip_trace_func);
 275                 firsttime=FALSE;
 276         }
 277         eXosip_init();
 278         sal=ms_new0(Sal,1);
 279         sal->keepalive_period=30;
 280         sal->double_reg=TRUE;
 281         sal->use_rports=TRUE;
 282         sal->use_101=TRUE;
 283         sal->reuse_authorization=FALSE;
 284         sal->rootCa = 0;
 285         sal->verify_server_certs=TRUE;
 286         sal->expire_old_contact=FALSE;
 287         return sal;
 288 }
 289
 290 void sal_uninit(Sal* sal){
 291         eXosip_quit();
 292         if (sal->rootCa)
 293                 ms_free(sal->rootCa);
 294         ms_free(sal);
 295 }
 296
 297 void sal_set_user_pointer(Sal *sal, void *user_data){
 298         sal->up=user_data;
 299 }
 300
 301 void *sal_get_user_pointer(const Sal *sal){
 302         return sal->up;
 303 }
 304
 305 static void unimplemented_stub(){
 306         ms_warning("Unimplemented SAL callback");
 307 }
 308
 309 void sal_set_callbacks(Sal *ctx, const SalCallbacks *cbs){
 310         memcpy(&ctx->callbacks,cbs,sizeof(*cbs));
 311         if (ctx->callbacks.call_received==NULL)
 312                 ctx->callbacks.call_received=(SalOnCallReceived)unimplemented_stub;
 313         if (ctx->callbacks.call_ringing==NULL)
 314                 ctx->callbacks.call_ringing=(SalOnCallRinging)unimplemented_stub;
 315         if (ctx->callbacks.call_accepted==NULL)
 316                 ctx->callbacks.call_accepted=(SalOnCallAccepted)unimplemented_stub;
 317         if (ctx->callbacks.call_failure==NULL)
 318                 ctx->callbacks.call_failure=(SalOnCallFailure)unimplemented_stub;
 319         if (ctx->callbacks.call_terminated==NULL)
 320                 ctx->callbacks.call_terminated=(SalOnCallTerminated)unimplemented_stub;
 321         if (ctx->callbacks.call_released==NULL)
 322                 ctx->callbacks.call_released=(SalOnCallReleased)unimplemented_stub;
 323         if (ctx->callbacks.call_updating==NULL)
 324                 ctx->callbacks.call_updating=(SalOnCallUpdating)unimplemented_stub;
 325         if (ctx->callbacks.auth_requested==NULL)
 326                 ctx->callbacks.auth_requested=(SalOnAuthRequested)unimplemented_stub;
 327         if (ctx->callbacks.auth_success==NULL)
 328                 ctx->callbacks.auth_success=(SalOnAuthSuccess)unimplemented_stub;
 329         if (ctx->callbacks.register_success==NULL)
 330                 ctx->callbacks.register_success=(SalOnRegisterSuccess)unimplemented_stub;
 331         if (ctx->callbacks.register_failure==NULL)
 332                 ctx->callbacks.register_failure=(SalOnRegisterFailure)unimplemented_stub;
 333         if (ctx->callbacks.dtmf_received==NULL)
 334                 ctx->callbacks.dtmf_received=(SalOnDtmfReceived)unimplemented_stub;
 335         if (ctx->callbacks.notify==NULL)
 336                 ctx->callbacks.notify=(SalOnNotify)unimplemented_stub;
 337         if (ctx->callbacks.notify_presence==NULL)
 338                 ctx->callbacks.notify_presence=(SalOnNotifyPresence)unimplemented_stub;
 339         if (ctx->callbacks.subscribe_received==NULL)
 340                 ctx->callbacks.subscribe_received=(SalOnSubscribeReceived)unimplemented_stub;
 341         if (ctx->callbacks.text_received==NULL)
 342                 ctx->callbacks.text_received=(SalOnTextReceived)unimplemented_stub;
 343         if (ctx->callbacks.ping_reply==NULL)
 344                 ctx->callbacks.ping_reply=(SalOnPingReply)unimplemented_stub;
 345 }
 346
 347 int sal_unlisten_ports(Sal *ctx){
 348         if (ctx->running){
 349                 eXosip_quit();
 350                 eXosip_init();
 351                 ctx->running=FALSE;
 352         }
 353         return 0;
 354 }
 355
 356 int sal_listen_port(Sal *ctx, const char *addr, int port, SalTransport tr, int is_secure){
 357         int err;
 358         bool_t ipv6;
 359         int proto=IPPROTO_UDP;
 360         int keepalive = ctx->keepalive_period;
 361
 362         switch (tr) {
 363         case SalTransportUDP:
 364                 proto=IPPROTO_UDP;
 365                 eXosip_set_option (EXOSIP_OPT_UDP_KEEP_ALIVE, &keepalive);
 366                 break;
 367         case SalTransportTCP:
 368         case SalTransportTLS:
 369                 proto= IPPROTO_TCP;
 370                         keepalive=-1;
 371                 eXosip_set_option (EXOSIP_OPT_UDP_KEEP_ALIVE,&keepalive);
 372
 373                 if (ctx->rootCa) {
 374                         eXosip_tls_ctx_t tlsCtx;
 375                         memset(&tlsCtx, 0, sizeof(tlsCtx));
 376                         snprintf(tlsCtx.root_ca_cert, sizeof(tlsCtx.client.cert), "%s", ctx->rootCa);
 377                         eXosip_set_tls_ctx(&tlsCtx);
 378                 }
 379 #ifdef HAVE_EXOSIP_TLS_VERIFY_CERTIFICATE
 380                 eXosip_tls_verify_certificate(ctx->verify_server_certs);
 381 #endif
 382                 break;
 383         default:
 384                 ms_warning("unexpected proto, using datagram");
 385         }
 386         /*see if it looks like an IPv6 address*/
 387         int use_rports = ctx->use_rports; // Copy char to int to avoid bad alignment
 388         eXosip_set_option(EXOSIP_OPT_USE_RPORT,&use_rports);
 389         int dont_use_101 = !ctx->use_101; // Copy char to int to avoid bad alignment
 390         eXosip_set_option(EXOSIP_OPT_DONT_SEND_101,&dont_use_101);
 391
 392         ipv6=strchr(addr,':')!=NULL;
 393         eXosip_enable_ipv6(ipv6);
 394
 395         if (is_secure && tr == SalTransportUDP){
 396                 ms_fatal("SIP over DTLS is not supported yet.");
 397                 return -1;
 398         }
 399         err=eXosip_listen_addr(proto, addr, port, ipv6 ?  PF_INET6 : PF_INET, is_secure);
 400         ctx->running=TRUE;
 401         return err;
 402 }
 403
 404 ortp_socket_t sal_get_socket(Sal *ctx){
 405 #ifdef HAVE_EXOSIP_GET_SOCKET
 406         return eXosip_get_socket(IPPROTO_UDP);
 407 #else
 408         ms_warning("Sorry, eXosip does not have eXosip_get_socket() method");
 409         return -1;
 410 #endif
 411 }
 412
 413 void sal_set_user_agent(Sal *ctx, const char *user_agent){
 414         eXosip_set_user_agent(user_agent);
 415 }
 416
 417 void sal_use_session_timers(Sal *ctx, int expires){
 418         ctx->session_expires=expires;
 419 }
 420
 421 void sal_use_one_matching_codec_policy(Sal *ctx, bool_t one_matching_codec){
 422         ctx->one_matching_codec=one_matching_codec;
 423 }
 424
 425 MSList *sal_get_pending_auths(Sal *sal){
 426         return ms_list_copy(sal->pending_auths);
 427 }
 428
 429 void sal_use_double_registrations(Sal *ctx, bool_t enabled){
 430         ctx->double_reg=enabled;
 431 }
 432
 433 void sal_expire_old_registration_contacts(Sal *ctx, bool_t enabled){
 434         ctx->expire_old_contact=enabled;
 435 }
 436
 437 void sal_use_rport(Sal *ctx, bool_t use_rports){
 438         ctx->use_rports=use_rports;
 439 }
 440 void sal_use_101(Sal *ctx, bool_t use_101){
 441         ctx->use_101=use_101;
 442 }
 443
 444 void sal_set_root_ca(Sal* ctx, const char* rootCa) {
 445         if (ctx->rootCa)
 446                 ms_free(ctx->rootCa);
 447         ctx->rootCa = ms_strdup(rootCa);
 448 }
 449
 450 void sal_verify_server_certificates(Sal *ctx, bool_t verify){
 451         ctx->verify_server_certs=verify;
 452 #ifdef HAVE_EXOSIP_TLS_VERIFY_CERTIFICATE
 453         eXosip_tls_verify_certificate(verify);
 454 #endif
 455 }
 456
 457 static int extract_received_rport(osip_message_t *msg, const char **received, int *rportval,SalTransport* transport){
 458         osip_via_t *via=NULL;
 459         osip_generic_param_t *param=NULL;
 460         const char *rport=NULL;
 461
 462         *rportval=5060;
 463         *received=NULL;
 464         osip_message_get_via(msg,0,&via);
 465         if (!via) {
 466                 ms_warning("extract_received_rport(): no via.");
 467                 return -1;
 468         }
 469
 470         *transport = sal_transport_parse(via->protocol);
 471
 472         if (via->port && via->port[0]!='\0')
 473                 *rportval=atoi(via->port);
 474
 475         osip_via_param_get_byname(via,"rport",&param);
 476         if (param) {
 477                 rport=param->gvalue;
 478                 if (rport && rport[0]!='\0') *rportval=atoi(rport);
 479                 *received=via->host;
 480         }
 481         param=NULL;
 482         osip_via_param_get_byname(via,"received",&param);
 483         if (param) *received=param->gvalue;
 484
 485         if (rport==NULL && *received==NULL){
 486                 ms_warning("extract_received_rport(): no rport and no received parameters.");
 487                 return -1;
 488         }
 489         return 0;
 490 }
 491
 492 static void set_sdp(osip_message_t *sip,sdp_message_t *msg){
 493         int sdplen;
 494         char clen[10];
 495         char *sdp=NULL;
 496         sdp_message_to_str(msg,&sdp);
 497         sdplen=strlen(sdp);
 498         snprintf(clen,sizeof(clen),"%i",sdplen);
 499         osip_message_set_body(sip,sdp,sdplen);
 500         osip_message_set_content_type(sip,"application/sdp");
 501         osip_message_set_content_length(sip,clen);
 502         osip_free(sdp);
 503 }
 504
 505 static void set_sdp_from_desc(osip_message_t *sip, const SalMediaDescription *desc, const IceSession *ice_session){
 506         sdp_message_t *msg=media_description_to_sdp(desc, ice_session);
 507         if (msg==NULL) {
 508                 ms_error("Fail to print sdp message !");
 509                 return;
 510         }
 511         set_sdp(sip,msg);
 512         sdp_message_free(msg);
 513 }
 514
 515 static void sdp_process(SalOp *h){
 516         ms_message("Doing SDP offer/answer process of type %s",h->sdp_offering ? "outgoing" : "incoming");
 517         if (h->result){
 518                 sal_media_description_unref(h->result);
 519         }
 520         h->result=sal_media_description_new();
 521         if (h->sdp_offering){
 522                 offer_answer_initiate_outgoing(h->base.local_media,h->base.remote_media,h->result);
 523         }else{
 524                 int i;
 525                 if (h->sdp_answer){
 526                         sdp_message_free(h->sdp_answer);
 527                 }
 528                 offer_answer_initiate_incoming(h->base.local_media,h->base.remote_media,h->result,h->base.root->one_matching_codec);
 529                 h->sdp_answer=media_description_to_sdp(h->result, sal_op_get_ice_session(h));
 530                 /*once we have generated the SDP answer, we modify the result description for processing by the upper layer.
 531                  It should contains media parameters constraint from the remote offer, not our response*/
 532                 strcpy(h->result->addr,h->base.remote_media->addr);
 533                 h->result->bandwidth=h->base.remote_media->bandwidth;
 534
 535                 for(i=0;i<h->result->nstreams;++i){
 536                         if (h->result->streams[i].port>0){
 537                                 strcpy(h->result->streams[i].addr,h->base.remote_media->streams[i].addr);
 538                                 h->result->streams[i].ptime=h->base.remote_media->streams[i].ptime;
 539                                 h->result->streams[i].bandwidth=h->base.remote_media->streams[i].bandwidth;
 540                                 h->result->streams[i].port=h->base.remote_media->streams[i].port;
 541
 542                                 if (h->result->streams[i].proto == SalProtoRtpSavp) {
 543                                         h->result->streams[i].crypto[0] = h->base.remote_media->streams[i].crypto[0];
 544                                 }
 545                         }
 546                 }
 547         }
 548
 549 }
 550
 551 int sal_call_is_offerer(const SalOp *h){
 552         return h->sdp_offering;
 553 }
 554
 555 int sal_call_set_local_media_description(SalOp *h, SalMediaDescription *desc){
 556         if (desc)
 557                 sal_media_description_ref(desc);
 558         if (h->base.local_media)
 559                 sal_media_description_unref(h->base.local_media);
 560         h->base.local_media=desc;
 561         if (h->base.remote_media){
 562                 /*case of an incoming call where we modify the local capabilities between the time
 563                  * the call is ringing and it is accepted (for example if you want to accept without video*/
 564                 /*reset the sdp answer so that it is computed again*/
 565                 if (h->sdp_answer){
 566                         sdp_message_free(h->sdp_answer);
 567                         h->sdp_answer=NULL;
 568                 }
 569         }
 570         return 0;
 571 }
 572
 573 int sal_call(SalOp *h, const char *from, const char *to){
 574         int err;
 575         const char *route;
 576         osip_message_t *invite=NULL;
 577         sal_op_set_from(h,from);
 578         sal_op_set_to(h,to);
 579         sal_exosip_fix_route(h);
 580
 581         h->terminated = FALSE;
 582
 583         route = sal_op_get_route(h);
 584         err=eXosip_call_build_initial_invite(&invite,to,from,route,"Phone call");
 585         if (err!=0){
 586                 ms_error("Could not create call. Error %d (from=%s to=%s route=%s)",
 587                                 err, from, to, route);
 588                 return -1;
 589         }
 590         osip_message_set_allow(invite, "INVITE, ACK, CANCEL, OPTIONS, BYE, REFER, NOTIFY, MESSAGE, SUBSCRIBE, INFO");
 591         if (h->base.contact){
 592                 _osip_list_set_empty(&invite->contacts,(void (*)(void*))osip_contact_free);
 593                 osip_message_set_contact(invite,h->base.contact);
 594         }
 595         if (h->base.root->session_expires!=0){
 596                 osip_message_set_header(invite, "Session-expires", "200");
 597                 osip_message_set_supported(invite, "timer");
 598         }
 599         if (h->base.local_media){
 600                 h->sdp_offering=TRUE;
 601                 set_sdp_from_desc(invite,h->base.local_media,sal_op_get_ice_session(h));
 602         }else h->sdp_offering=FALSE;
 603         if (h->replaces){
 604                 osip_message_set_header(invite,"Replaces",h->replaces);
 605                 if (h->referred_by)
 606                         osip_message_set_header(invite,"Referred-By",h->referred_by);
 607         }
 608
 609         eXosip_lock();
 610         err=eXosip_call_send_initial_invite(invite);
 611         eXosip_unlock();
 612         h->cid=err;
 613         if (err<0){
 614                 ms_error("Fail to send invite ! Error code %d", err);
 615                 return -1;
 616         }else{
 617                 sal_add_call(h->base.root,h);
 618         }
 619         return 0;
 620 }
 621
 622 int sal_call_notify_ringing(SalOp *h, bool_t early_media){
 623         osip_message_t *msg;
 624
 625         /*if early media send also 180 and 183 */
 626         if (early_media){
 627                 msg=NULL;
 628                 eXosip_lock();
 629                 eXosip_call_build_answer(h->tid,183,&msg);
 630                 if (msg){
 631                         sdp_process(h);
 632                         if (h->sdp_answer){
 633                                 set_sdp(msg,h->sdp_answer);
 634                                 sdp_message_free(h->sdp_answer);
 635                                 h->sdp_answer=NULL;
 636                         }
 637                         eXosip_call_send_answer(h->tid,183,msg);
 638                 }
 639                 eXosip_unlock();
 640         }else{
 641                 eXosip_lock();
 642                 eXosip_call_send_answer(h->tid,180,NULL);
 643                 eXosip_unlock();
 644         }
 645         return 0;
 646 }
 647
 648 int sal_call_accept(SalOp * h){
 649         osip_message_t *msg;
 650         const char *contact=sal_op_get_contact(h);
 651         /* sends a 200 OK */
 652         int err=eXosip_call_build_answer(h->tid,200,&msg);
 653         if (err<0 || msg==NULL){
 654                 ms_error("Fail to build answer for call: err=%i",err);
 655                 return -1;
 656         }
 657         if (h->base.root->session_expires!=0){
 658                 if (h->supports_session_timers) osip_message_set_supported(msg, "timer");
 659         }
 660
 661         if (contact) {
 662                 _osip_list_set_empty(&msg->contacts,(void (*)(void*))osip_contact_free);
 663                 osip_message_set_contact(msg,contact);
 664         }
 665
 666         if (h->base.local_media){
 667                 /*this is the case where we received an invite without SDP*/
 668                 if (h->sdp_offering) {
 669                         set_sdp_from_desc(msg,h->base.local_media,sal_op_get_ice_session(h));
 670                 }else{
 671                         if (h->sdp_answer==NULL) sdp_process(h);
 672                         if (h->sdp_answer){
 673                                 set_sdp(msg,h->sdp_answer);
 674                                 sdp_message_free(h->sdp_answer);
 675                                 h->sdp_answer=NULL;
 676                         }
 677                 }
 678         }else{
 679                 ms_error("You are accepting a call but not defined any media capabilities !");
 680         }
 681         eXosip_call_send_answer(h->tid,200,msg);
 682         return 0;
 683 }
 684
 685 int sal_call_decline(SalOp *h, SalReason reason, const char *redirect){
 686         if (reason==SalReasonBusy){
 687                 eXosip_lock();
 688                 eXosip_call_send_answer(h->tid,486,NULL);
 689                 eXosip_unlock();
 690         }
 691         else if (reason==SalReasonTemporarilyUnavailable){
 692                 eXosip_lock();
 693                 eXosip_call_send_answer(h->tid,480,NULL);
 694                 eXosip_unlock();
 695         }else if (reason==SalReasonDoNotDisturb){
 696                 eXosip_lock();
 697                 eXosip_call_send_answer(h->tid,600,NULL);
 698                 eXosip_unlock();
 699         }else if (reason==SalReasonMedia){
 700                 eXosip_lock();
 701                 eXosip_call_send_answer(h->tid,415,NULL);
 702                 eXosip_unlock();
 703         }else if (redirect!=NULL && reason==SalReasonRedirect){
 704                 osip_message_t *msg;
 705                 int code;
 706                 if (strstr(redirect,"sip:")!=0) code=302;
 707                 else code=380;
 708                 eXosip_lock();
 709                 eXosip_call_build_answer(h->tid,code,&msg);
 710                 osip_message_set_contact(msg,redirect);
 711                 eXosip_call_send_answer(h->tid,code,msg);
 712                 eXosip_unlock();
 713         }else sal_call_terminate(h);
 714         return 0;
 715 }
 716
 717 SalMediaDescription * sal_call_get_remote_media_description(SalOp *h){
 718         return h->base.remote_media;
 719 }
 720
 721 SalMediaDescription * sal_call_get_final_media_description(SalOp *h){
 722         if (h->base.local_media && h->base.remote_media && !h->result){
 723                 sdp_process(h);
 724         }
 725         return h->result;
 726 }
 727
 728 int sal_call_set_referer(SalOp *h, SalOp *refered_call){
 729         if (refered_call->replaces)
 730                 h->replaces=ms_strdup(refered_call->replaces);
 731         if (refered_call->referred_by)
 732                 h->referred_by=ms_strdup(refered_call->referred_by);
 733         return 0;
 734 }
 735
 736 static int send_notify_for_refer(int did, const char *sipfrag){
 737         osip_message_t *msg;
 738         eXosip_lock();
 739         eXosip_call_build_notify(did,EXOSIP_SUBCRSTATE_ACTIVE,&msg);
 740         if (msg==NULL){
 741                 eXosip_unlock();
 742                 ms_warning("Could not build NOTIFY for refer.");
 743                 return -1;
 744         }
 745         osip_message_set_content_type(msg,"message/sipfrag");
 746         osip_message_set_header(msg,"Event","refer");
 747         osip_message_set_body(msg,sipfrag,strlen(sipfrag));
 748         eXosip_call_send_request(did,msg);
 749         eXosip_unlock();
 750         return 0;
 751 }
 752
 753 /* currently only support to notify trying and 200Ok*/
 754 int sal_call_notify_refer_state(SalOp *h, SalOp *newcall){
 755         if (newcall==NULL){
 756                 /* in progress*/
 757                 send_notify_for_refer(h->did,"SIP/2.0 100 Trying\r\n");
 758         }
 759         else if (newcall->cid!=-1){
 760                 if (newcall->did==-1){
 761                         /* not yet established*/
 762                         if (!newcall->terminated){
 763                                 /* in progress*/
 764                                 send_notify_for_refer(h->did,"SIP/2.0 100 Trying\r\n");
 765                         }
 766                 }else{
 767                         if (!newcall->terminated){
 768                                 if (send_notify_for_refer(h->did,"SIP/2.0 200 Ok\r\n")==-1){
 769                                         /* we need previous notify transaction to complete, so buffer the request for later*/
 770                                         h->sipfrag_pending="SIP/2.0 200 Ok\r\n";
 771                                 }
 772                         }
 773                 }
 774         }
 775         return 0;
 776 }
 777
 778 int sal_ping(SalOp *op, const char *from, const char *to){
 779         osip_message_t *options=NULL;
 780
 781         sal_op_set_from(op,from);
 782         sal_op_set_to(op,to);
 783         sal_exosip_fix_route(op);
 784
 785         eXosip_options_build_request (&options, sal_op_get_to(op),
 786                         sal_op_get_from(op),sal_op_get_route(op));
 787         if (options){
 788                 if (op->base.root->session_expires!=0){
 789                         osip_message_set_header(options, "Session-expires", "200");
 790                         osip_message_set_supported(options, "timer");
 791                 }
 792                 sal_add_other(sal_op_get_sal(op),op,options);
 793                 return eXosip_options_send_request(options);
 794         }
 795         return -1;
 796 }
 797
 798 int sal_call_refer(SalOp *h, const char *refer_to){
 799         osip_message_t *msg=NULL;
 800         int err=0;
 801         eXosip_lock();
 802         eXosip_call_build_refer(h->did,refer_to, &msg);
 803         if (msg) err=eXosip_call_send_request(h->did, msg);
 804         else err=-1;
 805         eXosip_unlock();
 806         return err;
 807 }
 808
 809 int sal_call_refer_with_replaces(SalOp *h, SalOp *other_call_h){
 810         osip_message_t *msg=NULL;
 811         char referto[256]={0};
 812         int err=0;
 813         eXosip_lock();
 814         if (eXosip_call_get_referto(other_call_h->did,referto,sizeof(referto)-1)!=0){
 815                 ms_error("eXosip_call_get_referto() failed for did=%i",other_call_h->did);
 816                 eXosip_unlock();
 817                 return -1;
 818         }
 819         eXosip_call_build_refer(h->did,referto, &msg);
 820         osip_message_set_header(msg,"Referred-By",h->base.from);
 821         if (msg) err=eXosip_call_send_request(h->did, msg);
 822         else err=-1;
 823         eXosip_unlock();
 824         return err;
 825 }
 826
 827 SalOp *sal_call_get_replaces(SalOp *h){
 828         if (h!=NULL && h->replaces!=NULL){
 829                 int cid;
 830                 eXosip_lock();
 831                 cid=eXosip_call_find_by_replaces(h->replaces);
 832                 eXosip_unlock();
 833                 if (cid>0){
 834                         SalOp *ret=sal_find_call(h->base.root,cid);
 835                         return ret;
 836                 }
 837         }
 838         return NULL;
 839 }
 840
 841 int sal_call_send_dtmf(SalOp *h, char dtmf){
 842         osip_message_t *msg=NULL;
 843         char dtmf_body[128];
 844         char clen[10];
 845
 846         eXosip_lock();
 847         eXosip_call_build_info(h->did,&msg);
 848         if (msg){
 849                 snprintf(dtmf_body, sizeof(dtmf_body), "Signal=%c\r\nDuration=250\r\n", dtmf);
 850                 osip_message_set_body(msg,dtmf_body,strlen(dtmf_body));
 851                 osip_message_set_content_type(msg,"application/dtmf-relay");
 852                 snprintf(clen,sizeof(clen),"%lu",(unsigned long)strlen(dtmf_body));
 853                 osip_message_set_content_length(msg,clen);
 854                 eXosip_call_send_request(h->did,msg);
 855         }
 856         eXosip_unlock();
 857         return 0;
 858 }
 859
 860 static void push_auth_to_exosip(const SalAuthInfo *info){
 861         const char *userid;
 862         if (info->userid==NULL || info->userid[0]=='\0') userid=info->username;
 863         else userid=info->userid;
 864         ms_message("Authentication info for username [%s], id[%s], realm [%s] added to eXosip", info->username,userid, info->realm);
 865         eXosip_add_authentication_info (info->username,userid,
 866                                   info->password, NULL,info->realm);
 867 }
 868 /*
 869  * Just for symmetry ;-)
 870  */
 871 static void pop_auth_from_exosip() {
 872         eXosip_clear_authentication_info();
 873 }
 874
 875 int sal_call_terminate(SalOp *h){
 876         int err;
 877         if (h == NULL) return -1;
 878         if (h->auth_info) push_auth_to_exosip(h->auth_info);
 879         eXosip_lock();
 880         err=eXosip_call_terminate(h->cid,h->did);
 881         eXosip_unlock();
 882         if (!h->base.root->reuse_authorization) pop_auth_from_exosip();
 883         if (err!=0){
 884                 ms_warning("Exosip could not terminate the call: cid=%i did=%i", h->cid,h->did);
 885         }
 886         h->terminated=TRUE;
 887         return 0;
 888 }
 889
 890 void sal_op_authenticate(SalOp *h, const SalAuthInfo *info){
 891         if (h->terminated) return;
 892     if (h->pending_auth){
 893                 push_auth_to_exosip(info);
 894
 895         /*FIXME exosip does not take into account this update register message*/
 896         /*
 897         if (fix_message_contact(h, h->pending_auth->request,h->pending_auth->response)) {
 898
 899         };
 900         */
 901                 update_contact_from_response(h,h->pending_auth->response);
 902                 eXosip_lock();
 903                 eXosip_default_action(h->pending_auth);
 904                 eXosip_unlock();
 905                 ms_message("eXosip_default_action() done");
 906                 if (!h->base.root->reuse_authorization) pop_auth_from_exosip();
 907
 908                 if (h->auth_info) sal_auth_info_delete(h->auth_info); /*if already exist*/
 909                 h->auth_info=sal_auth_info_clone(info); /*store auth info for subsequent request*/
 910         }
 911 }
 912 void sal_op_cancel_authentication(SalOp *h) {
 913         if (h->rid >0) {
 914                 sal_op_get_sal(h)->callbacks.register_failure(h,SalErrorFailure, SalReasonForbidden,_("Authentication failure"));
 915         } else if (h->cid >0) {
 916                 sal_op_get_sal(h)->callbacks.call_failure(h,SalErrorFailure, SalReasonForbidden,_("Authentication failure"),0);
 917         } else {
 918                 ms_warning("Auth failure not handled");
 919         }
 920
 921 }
 922 static void set_network_origin(SalOp *op, osip_message_t *req){
 923         const char *received=NULL;
 924         int rport=5060;
 925         char origin[64]={0};
 926     SalTransport transport;
 927         if (extract_received_rport(req,&received,&rport,&transport)!=0){
 928                 osip_via_t *via=NULL;
 929                 char *tmp;
 930                 osip_message_get_via(req,0,&via);
 931                 received=osip_via_get_host(via);
 932                 tmp=osip_via_get_port(via);
 933                 if (tmp) rport=atoi(tmp);
 934         }
 935     if (transport != SalTransportUDP) {
 936         snprintf(origin,sizeof(origin)-1,"sip:%s:%i",received,rport);
 937     } else {
 938        snprintf(origin,sizeof(origin)-1,"sip:%s:%i;transport=%s",received,rport,sal_transport_to_string(transport));
 939     }
 940         __sal_op_set_network_origin(op,origin);
 941 }
 942
 943 static void set_remote_ua(SalOp* op, osip_message_t *req){
 944         if (op->base.remote_ua==NULL){
 945                 osip_header_t *h=NULL;
 946                 osip_message_get_user_agent(req,0,&h);
 947                 if (h){
 948                         op->base.remote_ua=ms_strdup(h->hvalue);
 949                 }
 950         }
 951 }
 952
 953 static void set_replaces(SalOp *op, osip_message_t *req){
 954         osip_header_t *h=NULL;
 955
 956         if (op->replaces){
 957                 ms_free(op->replaces);
 958                 op->replaces=NULL;
 959         }
 960         osip_message_header_get_byname(req,"replaces",0,&h);
 961         if (h){
 962                 if (h->hvalue && h->hvalue[0]!='\0'){
 963                         op->replaces=ms_strdup(h->hvalue);
 964                 }
 965         }
 966 }
 967
 968 static SalOp *find_op(Sal *sal, eXosip_event_t *ev){
 969         if (ev->cid>0){
 970                 return sal_find_call(sal,ev->cid);
 971         }
 972         if (ev->rid>0){
 973                 return sal_find_register(sal,ev->rid);
 974         }
 975         if (ev->sid>0){
 976                 return sal_find_out_subscribe(sal,ev->sid);
 977         }
 978         if (ev->nid>0){
 979                 return sal_find_in_subscribe(sal,ev->nid);
 980         }
 981         if (ev->response) return sal_find_other(sal,ev->response);
 982         return NULL;
 983 }
 984
 985 static void inc_new_call(Sal *sal, eXosip_event_t *ev){
 986         SalOp *op=sal_op_new(sal);
 987         osip_from_t *from,*to;
 988         osip_call_info_t *call_info;
 989         char *tmp;
 990         sdp_message_t *sdp=eXosip_get_sdp_info(ev->request);
 991         IceSession *ice_session;
 992
 993         set_network_origin(op,ev->request);
 994         set_remote_ua(op,ev->request);
 995         set_replaces(op,ev->request);
 996
 997         if (sdp){
 998                 op->sdp_offering=FALSE;
 999                 op->base.remote_media=sal_media_description_new();
1000                 ice_session=sal_op_get_ice_session(op);
1001                 sdp_to_media_description(sdp,op->base.remote_media,&ice_session);
1002                 sal_op_set_ice_session(op,ice_session);
1003                 sdp_message_free(sdp);
1004         }else op->sdp_offering=TRUE;
1005
1006         from=osip_message_get_from(ev->request);
1007         to=osip_message_get_to(ev->request);
1008         osip_from_to_str(from,&tmp);
1009         sal_op_set_from(op,tmp);
1010         osip_free(tmp);
1011         osip_from_to_str(to,&tmp);
1012         sal_op_set_to(op,tmp);
1013         osip_free(tmp);
1014
1015         osip_message_get_call_info(ev->request,0,&call_info);
1016         if(call_info)
1017         {
1018                 osip_call_info_to_str(call_info,&tmp);
1019                 if( strstr(tmp,"answer-after=") != NULL)
1020                 {
1021                         op->auto_answer_asked=TRUE;
1022                         ms_message("The caller asked to automatically answer the call(Emergency?)\n");
1023                 }
1024                 osip_free(tmp);
1025         }
1026
1027         op->tid=ev->tid;
1028         op->cid=ev->cid;
1029         op->did=ev->did;
1030
1031         sal_add_call(op->base.root,op);
1032         sal->callbacks.call_received(op);
1033 }
1034
1035 static void handle_reinvite(Sal *sal,  eXosip_event_t *ev){
1036         SalOp *op=find_op(sal,ev);
1037         sdp_message_t *sdp;
1038         IceSession *ice_session;
1039
1040         if (op==NULL) {
1041                 ms_warning("Reinvite for non-existing operation !");
1042                 return;
1043         }
1044         op->reinvite=TRUE;
1045         op->tid=ev->tid;
1046         sdp=eXosip_get_sdp_info(ev->request);
1047         if (op->base.remote_media){
1048                 sal_media_description_unref(op->base.remote_media);
1049                 op->base.remote_media=NULL;
1050         }
1051         if (op->result){
1052                 sal_media_description_unref(op->result);
1053                 op->result=NULL;
1054         }
1055         if (sdp){
1056                 op->sdp_offering=FALSE;
1057                 op->base.remote_media=sal_media_description_new();
1058                 ice_session=sal_op_get_ice_session(op);
1059                 sdp_to_media_description(sdp,op->base.remote_media,&ice_session);
1060                 sal_op_set_ice_session(op,ice_session);
1061                 sdp_message_free(sdp);
1062
1063         }else {
1064                 op->sdp_offering=TRUE;
1065         }
1066         sal->callbacks.call_updating(op);
1067 }
1068
1069 static void handle_ack(Sal *sal,  eXosip_event_t *ev){
1070         SalOp *op=find_op(sal,ev);
1071         sdp_message_t *sdp;
1072         IceSession *ice_session;
1073
1074         if (op==NULL) {
1075                 ms_warning("ack for non-existing call !");
1076                 return;
1077         }
1078         if (op->terminated) {
1079                 ms_warning("ack for terminated call, ignoring");
1080                 return;
1081         }
1082
1083         if (op->sdp_offering){
1084                 sdp=eXosip_get_sdp_info(ev->ack);
1085                 if (sdp){
1086                         if (op->base.remote_media)
1087                                 sal_media_description_unref(op->base.remote_media);
1088                         op->base.remote_media=sal_media_description_new();
1089                         ice_session=sal_op_get_ice_session(op);
1090                         sdp_to_media_description(sdp,op->base.remote_media,&ice_session);
1091                         sal_op_set_ice_session(op,ice_session);
1092                         sdp_process(op);
1093                         sdp_message_free(sdp);
1094                 }
1095         }
1096         if (op->reinvite){
1097                 op->reinvite=FALSE;
1098         }
1099         sal->callbacks.call_ack(op);
1100 }
1101
1102 static void update_contact_from_response(SalOp *op, osip_message_t *response){
1103         const char *received;
1104         int rport;
1105         SalTransport transport;
1106         if (extract_received_rport(response,&received,&rport,&transport)==0){
1107                 const char *contact=sal_op_get_contact(op);
1108                 if (!contact){
1109                         /*no contact given yet, use from instead*/
1110                         contact=sal_op_get_from(op);
1111                 }
1112                 if (contact){
1113                         SalAddress *addr=sal_address_new(contact);
1114                         char *tmp;
1115                         sal_address_set_domain(addr,received);
1116                         sal_address_set_port_int(addr,rport);
1117                         if (transport!=SalTransportUDP)
1118                                 sal_address_set_transport(addr,transport);
1119                         tmp=sal_address_as_string(addr);
1120                         ms_message("Contact address updated to %s",tmp);
1121                         sal_op_set_contact(op,tmp);
1122                         sal_address_destroy(addr);
1123                         ms_free(tmp);
1124                 }
1125         }
1126 }
1127
1128 static int call_proceeding(Sal *sal, eXosip_event_t *ev){
1129         SalOp *op=find_op(sal,ev);
1130
1131         if (op==NULL || op->terminated==TRUE) {
1132                 ms_warning("This call has been canceled.");
1133                 eXosip_lock();
1134                 eXosip_call_terminate(ev->cid,ev->did);
1135                 eXosip_unlock();
1136                 return -1;
1137         }
1138         if (ev->did>0)
1139                 op->did=ev->did;
1140         op->tid=ev->tid;
1141
1142         /* update contact if received and rport are set by the server
1143          note: will only be used by remote for next INVITE, if any...*/
1144         update_contact_from_response(op,ev->response);
1145         return 0;
1146 }
1147
1148 static void call_ringing(Sal *sal, eXosip_event_t *ev){
1149         sdp_message_t *sdp;
1150         SalOp *op=find_op(sal,ev);
1151         IceSession *ice_session;
1152         if (call_proceeding(sal, ev)==-1) return;
1153
1154         set_remote_ua(op,ev->response);
1155         sdp=eXosip_get_sdp_info(ev->response);
1156         if (sdp){
1157                 op->base.remote_media=sal_media_description_new();
1158                 ice_session=sal_op_get_ice_session(op);
1159                 sdp_to_media_description(sdp,op->base.remote_media,&ice_session);
1160                 sal_op_set_ice_session(op,ice_session);
1161                 sdp_message_free(sdp);
1162                 if (op->base.local_media) sdp_process(op);
1163         }
1164         sal->callbacks.call_ringing(op);
1165 }
1166
1167 static void call_accepted(Sal *sal, eXosip_event_t *ev){
1168         sdp_message_t *sdp;
1169         osip_message_t *msg=NULL;
1170         SalOp *op=find_op(sal,ev);
1171         const char *contact;
1172         IceSession *ice_session;
1173
1174         if (op==NULL || op->terminated==TRUE) {
1175                 ms_warning("This call has been already terminated.");
1176                 eXosip_lock();
1177                 eXosip_call_terminate(ev->cid,ev->did);
1178                 eXosip_unlock();
1179                 return ;
1180         }
1181
1182         op->did=ev->did;
1183         set_remote_ua(op,ev->response);
1184
1185         sdp=eXosip_get_sdp_info(ev->response);
1186         if (sdp){
1187                 op->base.remote_media=sal_media_description_new();
1188                 ice_session=sal_op_get_ice_session(op);
1189                 sdp_to_media_description(sdp,op->base.remote_media,&ice_session);
1190                 sal_op_set_ice_session(op,ice_session);
1191                 sdp_message_free(sdp);
1192                 if (op->base.local_media) sdp_process(op);
1193         }
1194         eXosip_call_build_ack(ev->did,&msg);
1195         if (msg==NULL) {
1196                 ms_warning("This call has been already terminated.");
1197                 eXosip_lock();
1198                 eXosip_call_terminate(ev->cid,ev->did);
1199                 eXosip_unlock();
1200                 return ;
1201         }
1202         contact=sal_op_get_contact(op);
1203         if (contact) {
1204                 _osip_list_set_empty(&msg->contacts,(void (*)(void*))osip_contact_free);
1205                 osip_message_set_contact(msg,contact);
1206         }
1207         if (op->sdp_answer){
1208                 set_sdp(msg,op->sdp_answer);
1209                 sdp_message_free(op->sdp_answer);
1210                 op->sdp_answer=NULL;
1211         }
1212         eXosip_call_send_ack(ev->did,msg);
1213         sal->callbacks.call_accepted(op);
1214 }
1215
1216 static void call_terminated(Sal *sal, eXosip_event_t *ev){
1217         char *from=NULL;
1218         SalOp *op=find_op(sal,ev);
1219         if (op==NULL){
1220                 ms_warning("Call terminated for already closed call ?");
1221                 return;
1222         }
1223         if (ev->request){
1224                 osip_from_to_str(ev->request->from,&from);
1225         }
1226         sal->callbacks.call_terminated(op,from!=NULL ? from : sal_op_get_from(op));
1227         if (from) osip_free(from);
1228         op->terminated=TRUE;
1229 }
1230
1231 static void call_released(Sal *sal, eXosip_event_t *ev){
1232         SalOp *op=find_op(sal,ev);
1233         if (op==NULL){
1234                 ms_warning("No op associated to this call_released()");
1235                 return;
1236         }
1237         if (!op->terminated){
1238                 /* no response received so far */
1239                 call_failure(sal,ev);
1240         }
1241         sal->callbacks.call_released(op);
1242 }
1243
1244 static int get_auth_data_from_response(osip_message_t *resp, const char **realm, const char **username){
1245         const char *prx_realm=NULL,*www_realm=NULL;
1246         osip_proxy_authenticate_t *prx_auth;
1247         osip_www_authenticate_t *www_auth;
1248
1249         *username=osip_uri_get_username(resp->from->url);
1250         prx_auth=(osip_proxy_authenticate_t*)osip_list_get(&resp->proxy_authenticates,0);
1251         www_auth=(osip_proxy_authenticate_t*)osip_list_get(&resp->www_authenticates,0);
1252         if (prx_auth!=NULL)
1253                 prx_realm=osip_proxy_authenticate_get_realm(prx_auth);
1254         if (www_auth!=NULL)
1255                 www_realm=osip_www_authenticate_get_realm(www_auth);
1256
1257         if (prx_realm){
1258                 *realm=prx_realm;
1259         }else if (www_realm){
1260                 *realm=www_realm;
1261         }else{
1262                 return -1;
1263         }
1264         return 0;
1265 }
1266
1267 static int get_auth_data_from_request(osip_message_t *msg, const char **realm, const char **username){
1268         osip_authorization_t *auth=NULL;
1269         osip_proxy_authorization_t *prx_auth=NULL;
1270
1271         *username=osip_uri_get_username(msg->from->url);
1272         osip_message_get_authorization(msg, 0, &auth);
1273         if (auth){
1274                 *realm=osip_authorization_get_realm(auth);
1275                 return 0;
1276         }
1277         osip_message_get_proxy_authorization(msg,0,&prx_auth);
1278         if (prx_auth){
1279                 *realm=osip_proxy_authorization_get_realm(prx_auth);
1280                 return 0;
1281         }
1282         return -1;
1283 }
1284
1285 static int get_auth_data(eXosip_event_t *ev, const char **realm, const char **username){
1286         if (ev->response && get_auth_data_from_response(ev->response,realm,username)==0) return 0;
1287         if (ev->request && get_auth_data_from_request(ev->request,realm,username)==0) return 0;
1288         return -1;
1289 }
1290
1291 int sal_op_get_auth_requested(SalOp *op, const char **realm, const char **username){
1292         if (op->pending_auth){
1293                 return get_auth_data(op->pending_auth,realm,username);
1294         }
1295         return -1;
1296 }
1297
1298 static bool_t process_authentication(Sal *sal, eXosip_event_t *ev){
1299         SalOp *op;
1300         const char *username,*realm;
1301         op=find_op(sal,ev);
1302         if (op==NULL){
1303                 ms_warning("No operation associated with this authentication !");
1304                 return TRUE;
1305         }
1306         if (get_auth_data(ev,&realm,&username)==0){
1307                 if (op->pending_auth!=NULL){
1308                         eXosip_event_free(op->pending_auth);
1309                         op->pending_auth=ev;
1310                 }else{
1311                         op->pending_auth=ev;
1312                         sal_add_pending_auth(sal,op);
1313                 }
1314
1315                 sal->callbacks.auth_requested(op,realm,username);
1316                 return FALSE;
1317         }
1318         return TRUE;
1319 }
1320
1321 static void authentication_ok(Sal *sal, eXosip_event_t *ev){
1322         SalOp *op;
1323         const char *username,*realm;
1324         op=find_op(sal,ev);
1325         if (op==NULL){
1326                 ms_warning("No operation associated with this authentication_ok!");
1327                 return ;
1328         }
1329         if (op->pending_auth){
1330                 eXosip_event_free(op->pending_auth);
1331                 sal_remove_pending_auth(sal,op);
1332                 op->pending_auth=NULL;
1333         }
1334         if (get_auth_data(ev,&realm,&username)==0){
1335                 sal->callbacks.auth_success(op,realm,username);
1336         }
1337 }
1338
1339 static bool_t call_failure(Sal *sal, eXosip_event_t *ev){
1340         SalOp *op;
1341         int code=0;
1342         char* computedReason=NULL;
1343         const char *reason=NULL;
1344         SalError error=SalErrorUnknown;
1345         SalReason sr=SalReasonUnknown;
1346
1347
1348         op=(SalOp*)find_op(sal,ev);
1349
1350         if (op==NULL) {
1351                 ms_warning("Call failure reported for a closed call, ignored.");
1352                 return TRUE;
1353         }
1354
1355         if (ev->response){
1356                 code=osip_message_get_status_code(ev->response);
1357                 reason=osip_message_get_reason_phrase(ev->response);
1358                 osip_header_t *h=NULL;
1359                 if (!osip_message_header_get_byname(    ev->response
1360                                                                                         ,"Reason"
1361                                                                                         ,0
1362                                                                                         ,&h)) {
1363                         computedReason = ms_strdup_printf("%s %s",reason,osip_header_get_value(h));
1364                         reason = computedReason;
1365
1366                 }
1367         }
1368         switch(code)
1369         {
1370                 case 401:
1371                 case 407:
1372                         return process_authentication(sal,ev);
1373                         break;
1374                 case 400:
1375                         error=SalErrorUnknown;
1376                 break;
1377                 case 404:
1378                         error=SalErrorFailure;
1379                         sr=SalReasonNotFound;
1380                 break;
1381                 case 415:
1382                         error=SalErrorFailure;
1383                         sr=SalReasonMedia;
1384                 break;
1385                 case 422:
1386                         eXosip_default_action(ev);
1387                         return TRUE;
1388                 break;
1389                 case 480:
1390                         error=SalErrorFailure;
1391                         sr=SalReasonTemporarilyUnavailable;
1392                 case 486:
1393                         error=SalErrorFailure;
1394                         sr=SalReasonBusy;
1395                 break;
1396                 case 487:
1397                 break;
1398                 case 600:
1399                         error=SalErrorFailure;
1400                         sr=SalReasonDoNotDisturb;
1401                 break;
1402                 case 603:
1403                         error=SalErrorFailure;
1404                         sr=SalReasonDeclined;
1405                 break;
1406                 default:
1407                         if (code>0){
1408                                 error=SalErrorFailure;
1409                                 sr=SalReasonUnknown;
1410                         }else error=SalErrorNoResponse;
1411         }
1412         op->terminated=TRUE;
1413         sal->callbacks.call_failure(op,error,sr,reason,code);
1414         if (computedReason != NULL){
1415                 ms_free(computedReason);
1416         }
1417         return TRUE;
1418 }
1419
1420 /* Request remote side to send us VFU */
1421 void sal_call_send_vfu_request(SalOp *h){
1422         osip_message_t *msg=NULL;
1423         char info_body[] =
1424                         "<?xml version=\"1.0\" encoding=\"utf-8\" ?>"
1425                          "<media_control>"
1426                          "  <vc_primitive>"
1427                          "    <to_encoder>"
1428                          "      <picture_fast_update></picture_fast_update>"
1429                          "    </to_encoder>"
1430                          "  </vc_primitive>"
1431                          "</media_control>";
1432
1433         char clen[10];
1434
1435         eXosip_lock();
1436         eXosip_call_build_info(h->did,&msg);
1437         if (msg){
1438                 osip_message_set_body(msg,info_body,strlen(info_body));
1439                 osip_message_set_content_type(msg,"application/media_control+xml");
1440                 snprintf(clen,sizeof(clen),"%lu",(unsigned long)strlen(info_body));
1441                 osip_message_set_content_length(msg,clen);
1442                 eXosip_call_send_request(h->did,msg);
1443                 ms_message("Sending VFU request !");
1444         }
1445         eXosip_unlock();
1446 }
1447
1448 static void process_media_control_xml(Sal *sal, eXosip_event_t *ev){
1449         SalOp *op=find_op(sal,ev);
1450         osip_body_t *body=NULL;
1451
1452         if (op==NULL){
1453                 ms_warning("media control xml received without operation context!");
1454                 return ;
1455         }
1456
1457         osip_message_get_body(ev->request,0,&body);
1458         if (body && body->body!=NULL &&
1459                 strstr(body->body,"picture_fast_update")){
1460                 osip_message_t *ans=NULL;
1461                 ms_message("Receiving VFU request !");
1462                 if (sal->callbacks.vfu_request){
1463                         sal->callbacks.vfu_request(op);
1464                         eXosip_call_build_answer(ev->tid,200,&ans);
1465                         if (ans)
1466                                 eXosip_call_send_answer(ev->tid,200,ans);
1467                         return;
1468                 }
1469         }
1470         /*in all other cases we must say it is not implemented.*/
1471         {
1472                 osip_message_t *ans=NULL;
1473                 eXosip_lock();
1474                 eXosip_call_build_answer(ev->tid,501,&ans);
1475                 if (ans)
1476                         eXosip_call_send_answer(ev->tid,501,ans);
1477                 eXosip_unlock();
1478         }
1479 }
1480
1481 static void process_dtmf_relay(Sal *sal, eXosip_event_t *ev){
1482         SalOp *op=find_op(sal,ev);
1483         osip_body_t *body=NULL;
1484
1485         if (op==NULL){
1486                 ms_warning("media dtmf relay received without operation context!");
1487                 return ;
1488         }
1489
1490         osip_message_get_body(ev->request,0,&body);
1491         if (body && body->body!=NULL){
1492                 osip_message_t *ans=NULL;
1493                 const char *name=strstr(body->body,"Signal");
1494                 if (name==NULL) name=strstr(body->body,"signal");
1495                 if (name==NULL) {
1496                         ms_warning("Could not extract the dtmf name from the SIP INFO.");
1497                 }else{
1498                         char tmp[2];
1499                         name+=strlen("signal");
1500                         if (sscanf(name," = %1s",tmp)==1){
1501                                 ms_message("Receiving dtmf %s via SIP INFO.",tmp);
1502                                 if (sal->callbacks.dtmf_received != NULL)
1503                                         sal->callbacks.dtmf_received(op, tmp[0]);
1504                         }
1505                 }
1506                 eXosip_lock();
1507                 eXosip_call_build_answer(ev->tid,200,&ans);
1508                 if (ans)
1509                         eXosip_call_send_answer(ev->tid,200,ans);
1510                 eXosip_unlock();
1511         }
1512 }
1513
1514 static void fill_options_answer(osip_message_t *options){
1515         osip_message_set_allow(options,"INVITE, ACK, BYE, CANCEL, OPTIONS, MESSAGE, SUBSCRIBE, NOTIFY, INFO");
1516         osip_message_set_accept(options,"application/sdp");
1517 }
1518
1519 static void process_refer(Sal *sal, SalOp *op, eXosip_event_t *ev){
1520         osip_header_t *h=NULL;
1521         osip_message_t *ans=NULL;
1522         ms_message("Receiving REFER request !");
1523         osip_message_header_get_byname(ev->request,"Refer-To",0,&h);
1524
1525         if (h){
1526                 osip_from_t *from=NULL;
1527                 char *tmp;
1528                 osip_from_init(&from);
1529
1530                 if (osip_from_parse(from,h->hvalue)==0){
1531                         if (op ){
1532                                 osip_uri_header_t *uh=NULL;
1533                                 osip_header_t *referred_by=NULL;
1534                                 osip_uri_header_get_byname(&from->url->url_headers,(char*)"Replaces",&uh);
1535                                 if (uh!=NULL && uh->gvalue && uh->gvalue[0]!='\0'){
1536                                         ms_message("Found replaces in Refer-To");
1537                                         if (op->replaces){
1538                                                 ms_free(op->replaces);
1539                                         }
1540                                         op->replaces=ms_strdup(uh->gvalue);
1541                                 }
1542                                 osip_message_header_get_byname(ev->request,"Referred-By",0,&referred_by);
1543                                 if (referred_by && referred_by->hvalue && referred_by->hvalue[0]!='\0'){
1544                                         if (op->referred_by)
1545                                                 ms_free(op->referred_by);
1546                                         op->referred_by=ms_strdup(referred_by->hvalue);
1547                                 }
1548                         }
1549                         osip_uri_header_freelist(&from->url->url_headers);
1550                         osip_from_to_str(from,&tmp);
1551                         sal->callbacks.refer_received(sal,op,tmp);
1552                         osip_free(tmp);
1553                         osip_from_free(from);
1554                 }
1555                 eXosip_lock();
1556                 eXosip_call_build_answer(ev->tid,202,&ans);
1557                 if (ans)
1558                         eXosip_call_send_answer(ev->tid,202,ans);
1559                 eXosip_unlock();
1560         }
1561         else
1562         {
1563                 ms_warning("cannot do anything with the refer without destination\n");
1564         }
1565 }
1566
1567 static void process_notify(Sal *sal, eXosip_event_t *ev){
1568         osip_header_t *h=NULL;
1569         char *from=NULL;
1570         SalOp *op=find_op(sal,ev);
1571         osip_message_t *ans=NULL;
1572
1573         ms_message("Receiving NOTIFY request !");
1574         osip_from_to_str(ev->request->from,&from);
1575         osip_message_header_get_byname(ev->request,"Event",0,&h);
1576         if(h){
1577                 osip_body_t *body=NULL;
1578                 //osip_content_type_t *ct=NULL;
1579                 osip_message_get_body(ev->request,0,&body);
1580                 //ct=osip_message_get_content_type(ev->request);
1581                 if (h->hvalue && strcasecmp(h->hvalue,"refer")==0){
1582                         /*special handling of refer events*/
1583                         if (body && body->body){
1584                                 osip_message_t *msg;
1585                                 osip_message_init(&msg);
1586                                 if (osip_message_parse_sipfrag(msg,body->body,strlen(body->body))==0){
1587                                         int code=osip_message_get_status_code(msg);
1588                                         if (code==100){
1589                                                 sal->callbacks.notify_refer(op,SalReferTrying);
1590                                         }else if (code==200){
1591                                                 sal->callbacks.notify_refer(op,SalReferSuccess);
1592                                         }else if (code>=400){
1593                                                 sal->callbacks.notify_refer(op,SalReferFailed);
1594                                         }
1595                                 }
1596                                 osip_message_free(msg);
1597                         }
1598                 }else{
1599                         /*generic handling*/
1600                         sal->callbacks.notify(op,from,h->hvalue);
1601                 }
1602         }
1603         /*answer that we received the notify*/
1604         eXosip_lock();
1605         eXosip_call_build_answer(ev->tid,200,&ans);
1606         if (ans)
1607                 eXosip_call_send_answer(ev->tid,200,ans);
1608         eXosip_unlock();
1609         osip_free(from);
1610 }
1611
1612 static void call_message_new(Sal *sal, eXosip_event_t *ev){
1613         osip_message_t *ans=NULL;
1614         if (ev->request){
1615                 if (MSG_IS_INFO(ev->request)){
1616                         osip_content_type_t *ct;
1617                         ct=osip_message_get_content_type(ev->request);
1618                         if (ct && ct->subtype){
1619                                 if (strcmp(ct->subtype,"media_control+xml")==0)
1620                                         process_media_control_xml(sal,ev);
1621                                 else if (strcmp(ct->subtype,"dtmf-relay")==0)
1622                                         process_dtmf_relay(sal,ev);
1623                                 else {
1624                                         ms_message("Unhandled SIP INFO.");
1625                                         /*send an "Not implemented" answer*/
1626                                         eXosip_lock();
1627                                         eXosip_call_build_answer(ev->tid,501,&ans);
1628                                         if (ans)
1629                                                 eXosip_call_send_answer(ev->tid,501,ans);
1630                                         eXosip_unlock();
1631                                 }
1632                         }else{
1633                                 /*empty SIP INFO, probably to test we are alive. Send an empty answer*/
1634                                 eXosip_lock();
1635                                 eXosip_call_build_answer(ev->tid,200,&ans);
1636                                 if (ans)
1637                                         eXosip_call_send_answer(ev->tid,200,ans);
1638                                 eXosip_unlock();
1639                         }
1640                 }else if(MSG_IS_MESSAGE(ev->request)){
1641                         /* SIP messages could be received into call */
1642                         text_received(sal, ev);
1643                         eXosip_lock();
1644                         eXosip_call_build_answer(ev->tid,200,&ans);
1645                         if (ans)
1646                                 eXosip_call_send_answer(ev->tid,200,ans);
1647                         eXosip_unlock();
1648                 }else if(MSG_IS_REFER(ev->request)){
1649                         SalOp *op=find_op(sal,ev);
1650
1651                         ms_message("Receiving REFER request !");
1652                         process_refer(sal,op,ev);
1653                 }else if(MSG_IS_NOTIFY(ev->request)){
1654                         process_notify(sal,ev);
1655                 }else if (MSG_IS_OPTIONS(ev->request)){
1656                         eXosip_lock();
1657                         eXosip_call_build_answer(ev->tid,200,&ans);
1658                         if (ans){
1659                                 fill_options_answer(ans);
1660                                 eXosip_call_send_answer(ev->tid,200,ans);
1661                         }
1662                         eXosip_unlock();
1663                 }
1664         }else ms_warning("call_message_new: No request ?");
1665 }
1666
1667 static void inc_update(Sal *sal, eXosip_event_t *ev){
1668         osip_message_t *msg=NULL;
1669         ms_message("Processing incoming UPDATE");
1670         eXosip_lock();
1671         eXosip_message_build_answer(ev->tid,200,&msg);
1672         if (msg!=NULL)
1673                 eXosip_message_send_answer(ev->tid,200,msg);
1674         eXosip_unlock();
1675 }
1676
1677 static bool_t comes_from_local_if(osip_message_t *msg){
1678         osip_via_t *via=NULL;
1679         osip_message_get_via(msg,0,&via);
1680         if (via){
1681                 const char *host;
1682                 host=osip_via_get_host(via);
1683                 if (strcmp(host,"127.0.0.1")==0 || strcmp(host,"::1")==0){
1684                         osip_generic_param_t *param=NULL;
1685                         osip_via_param_get_byname(via,"received",&param);
1686                         if (param==NULL) return TRUE;
1687                         if (param->gvalue &&
1688                                 (strcmp(param->gvalue,"127.0.0.1")==0 || strcmp(param->gvalue,"::1")==0)){
1689                                 return TRUE;
1690                         }
1691                 }
1692         }
1693         return FALSE;
1694 }
1695
1696 static void text_received(Sal *sal, eXosip_event_t *ev){
1697         osip_body_t *body=NULL;
1698         char *from=NULL,*msg;
1699
1700         osip_message_get_body(ev->request,0,&body);
1701         if (body==NULL){
1702                 ms_error("Could not get text message from SIP body");
1703                 return;
1704         }
1705         msg=body->body;
1706         osip_from_to_str(ev->request->from,&from);
1707         sal->callbacks.text_received(sal,from,msg);
1708         osip_free(from);
1709 }
1710
1711
1712
1713 static void other_request(Sal *sal, eXosip_event_t *ev){
1714         ms_message("in other_request");
1715         if (ev->request==NULL) return;
1716         if (strcmp(ev->request->sip_method,"MESSAGE")==0){
1717                 text_received(sal,ev);
1718                 eXosip_message_send_answer(ev->tid,200,NULL);
1719         }else if (strcmp(ev->request->sip_method,"OPTIONS")==0){
1720                 osip_message_t *options=NULL;
1721                 eXosip_options_build_answer(ev->tid,200,&options);
1722                 fill_options_answer(options);
1723                 eXosip_options_send_answer(ev->tid,200,options);
1724         }else if (strncmp(ev->request->sip_method, "REFER", 5) == 0){
1725                 ms_message("Receiving REFER request !");
1726                 if (comes_from_local_if(ev->request)) {
1727                         process_refer(sal,NULL,ev);
1728                 }else ms_warning("Ignored REFER not coming from this local loopback interface.");
1729         }else if (strncmp(ev->request->sip_method, "UPDATE", 6) == 0){
1730                 inc_update(sal,ev);
1731     }else {
1732                 char *tmp=NULL;
1733                 size_t msglen=0;
1734                 osip_message_to_str(ev->request,&tmp,&msglen);
1735                 if (tmp){
1736                         ms_message("Unsupported request received:\n%s",tmp);
1737                         osip_free(tmp);
1738                 }
1739                 /*answer with a 501 Not implemented*/
1740                 eXosip_message_send_answer(ev->tid,501,NULL);
1741         }
1742 }
1743
1744 static void masquerade_via(osip_message_t *msg, const char *ip, const char *port){
1745         osip_via_t *via=NULL;
1746         osip_message_get_via(msg,0,&via);
1747         if (via){
1748                 osip_free(via->port);
1749                 via->port=osip_strdup(port);
1750                 osip_free(via->host);
1751                 via->host=osip_strdup(ip);
1752         }
1753 }
1754
1755
1756 static bool_t fix_message_contact(SalOp *op, osip_message_t *request,osip_message_t *last_answer, bool_t expire_last_contact) {
1757         osip_contact_t *ctt=NULL;
1758         const char *received;
1759         int rport;
1760         SalTransport transport;
1761         char port[20];
1762
1763         if (extract_received_rport(last_answer,&received,&rport,&transport)==-1) return FALSE;
1764         osip_message_get_contact(request,0,&ctt);
1765         if (ctt == NULL) {
1766                 ms_warning("fix_message_contact(): no contact to update");
1767                 return FALSE;
1768         }
1769         if (expire_last_contact){
1770                 osip_contact_t *oldct=NULL,*prevct;
1771                 osip_generic_param_t *param=NULL;
1772                 osip_contact_clone(ctt,&oldct);
1773                 while ((prevct=(osip_contact_t*)osip_list_get(&request->contacts,1))!=NULL){
1774                         osip_contact_free(prevct);
1775                         osip_list_remove(&request->contacts,1);
1776                 }
1777                 osip_list_add(&request->contacts,oldct,1);
1778                 osip_contact_param_get_byname(oldct,"expires",&param);
1779                 if (param){
1780                         if (param->gvalue) osip_free(param->gvalue);
1781                         param->gvalue=osip_strdup("0");
1782                 }else{
1783                         osip_contact_param_add(oldct,osip_strdup("expires"),osip_strdup("0"));
1784                 }
1785         }
1786         if (ctt->url->host!=NULL){
1787                 osip_free(ctt->url->host);
1788         }
1789         ctt->url->host=osip_strdup(received);
1790         if (ctt->url->port!=NULL){
1791                 osip_free(ctt->url->port);
1792         }
1793         snprintf(port,sizeof(port),"%i",rport);
1794         ctt->url->port=osip_strdup(port);
1795         if (op->masquerade_via) masquerade_via(request,received,port);
1796
1797         if (transport != SalTransportUDP) {
1798                 sal_address_set_param((SalAddress *)ctt, "transport", sal_transport_to_string(transport));
1799         }
1800         return TRUE;
1801 }
1802
1803 static bool_t register_again_with_updated_contact(SalOp *op, osip_message_t *orig_request, osip_message_t *last_answer){
1804         osip_contact_t *ctt=NULL;
1805         SalAddress* ori_contact_address=NULL;
1806         const char *received;
1807         int rport;
1808         SalTransport transport;
1809         char* tmp;
1810         osip_message_t *msg=NULL;
1811         Sal* sal=op->base.root;
1812         int i=0;
1813         bool_t found_valid_contact=FALSE;
1814         bool_t from_request=FALSE;
1815
1816         if (sal->double_reg==FALSE ) return FALSE;
1817
1818         if (extract_received_rport(last_answer,&received,&rport,&transport)==-1) return FALSE;
1819         do{
1820                 ctt=NULL;
1821                 osip_message_get_contact(last_answer,i,&ctt);
1822                 if (!from_request && ctt==NULL) {
1823                         osip_message_get_contact(orig_request,0,&ctt);
1824                         from_request=TRUE;
1825                 }
1826                 if (ctt){
1827                         osip_contact_to_str(ctt,&tmp);
1828                         ori_contact_address = sal_address_new(tmp);
1829
1830                         /*check if contact is up to date*/
1831                         if (strcmp(sal_address_get_domain(ori_contact_address),received) ==0
1832                                 && sal_address_get_port_int(ori_contact_address) == rport
1833                         && sal_address_get_transport(ori_contact_address) == transport) {
1834                                 if (!from_request){
1835                                         ms_message("Register response has up to date contact, doing nothing.");
1836                                 }else {
1837                                         ms_warning("Register response does not have up to date contact, but last request had."
1838                                                 "Stupid registrar detected, giving up.");
1839                                 }
1840                                 found_valid_contact=TRUE;
1841                         }
1842                         osip_free(tmp);
1843                         sal_address_destroy(ori_contact_address);
1844                 }else break;
1845                 i++;
1846         }while(!found_valid_contact);
1847         if (!found_valid_contact)
1848                 ms_message("Contact do not match, resending register.");
1849         else return FALSE;
1850
1851         eXosip_lock();
1852         eXosip_register_build_register(op->rid,op->expires,&msg);
1853         if (msg==NULL){
1854             eXosip_unlock();
1855             ms_warning("Fail to create a contact updated register.");
1856             return FALSE;
1857         }
1858         if (fix_message_contact(op,msg,last_answer,op->base.root->expire_old_contact)) {
1859                 eXosip_register_send_register(op->rid,msg);
1860                 eXosip_unlock();
1861                 ms_message("Resending new register with updated contact");
1862                 update_contact_from_response(op,last_answer);
1863                 return TRUE;
1864         } else {
1865             ms_warning("Fail to send updated register.");
1866             eXosip_unlock();
1867             return FALSE;
1868         }
1869         eXosip_unlock();
1870         return FALSE;
1871 }
1872
1873 static void registration_success(Sal *sal, eXosip_event_t *ev){
1874         SalOp *op=sal_find_register(sal,ev->rid);
1875         osip_header_t *h=NULL;
1876         bool_t registered;
1877         if (op==NULL){
1878                 ms_error("Receiving register response for unknown operation");
1879                 return;
1880         }
1881         osip_message_get_expires(ev->request,0,&h);
1882         if (h!=NULL && atoi(h->hvalue)!=0){
1883                 registered=TRUE;
1884                 if (!register_again_with_updated_contact(op,ev->request,ev->response)){
1885                         sal->callbacks.register_success(op,registered);
1886                 }
1887         }else {
1888                 sal->callbacks.register_success(op,FALSE);
1889         }
1890 }
1891
1892 static bool_t registration_failure(Sal *sal, eXosip_event_t *ev){
1893         int status_code=0;
1894         const char *reason=NULL;
1895         SalOp *op=sal_find_register(sal,ev->rid);
1896         SalReason sr=SalReasonUnknown;
1897         SalError se=SalErrorUnknown;
1898
1899         if (op==NULL){
1900                 ms_error("Receiving register failure for unknown operation");
1901                 return TRUE;
1902         }
1903         if (ev->response){
1904                 status_code=osip_message_get_status_code(ev->response);
1905                 reason=osip_message_get_reason_phrase(ev->response);
1906         }
1907         switch(status_code){
1908                 case 401:
1909                 case 407:
1910                         return process_authentication(sal,ev);
1911                         break;
1912                 case 423: /*interval too brief*/
1913                         {/*retry with greater interval */
1914                                 osip_header_t *h=NULL;
1915                                 osip_message_t *msg=NULL;
1916                                 osip_message_header_get_byname(ev->response,"min-expires",0,&h);
1917                                 if (h && h->hvalue && h->hvalue[0]!='\0'){
1918                                         int val=atoi(h->hvalue);
1919                                         if (val>op->expires)
1920                                                 op->expires=val;
1921                                 }else op->expires*=2;
1922                                 eXosip_lock();
1923                                 eXosip_register_build_register(op->rid,op->expires,&msg);
1924                                 eXosip_register_send_register(op->rid,msg);
1925                                 eXosip_unlock();
1926                         }
1927                 break;
1928                 case 606: /*Not acceptable, workaround for proxies that don't like private addresses
1929                                  in vias, such as ekiga.net
1930                                  On the opposite, freephonie.net bugs when via are masqueraded.
1931                                  */
1932                         op->masquerade_via=TRUE;
1933                 default:
1934                         /* if contact is up to date, process the failure, otherwise resend a new register with
1935                                 updated contact first, just in case the faillure is due to incorrect contact */
1936                         if (ev->response && register_again_with_updated_contact(op,ev->request,ev->response))
1937                                 return TRUE; /*we are retrying with an updated contact*/
1938                         if (status_code==403){
1939                                 se=SalErrorFailure;
1940                                 sr=SalReasonForbidden;
1941                         }else if (status_code==0){
1942                                 se=SalErrorNoResponse;
1943                         }
1944                         sal->callbacks.register_failure(op,se,sr,reason);
1945         }
1946         return TRUE;
1947 }
1948
1949 static void other_request_reply(Sal *sal,eXosip_event_t *ev){
1950         SalOp *op=find_op(sal,ev);
1951
1952         if (op==NULL){
1953                 ms_warning("other_request_reply(): Receiving response to unknown request.");
1954                 return;
1955         }
1956         if (ev->response){
1957                 update_contact_from_response(op,ev->response);
1958                 if (ev->request && strcmp(osip_message_get_method(ev->request),"OPTIONS")==0)
1959                         sal->callbacks.ping_reply(op);
1960         }
1961 }
1962
1963 static void process_in_call_reply(Sal *sal, eXosip_event_t *ev){
1964         SalOp *op=find_op(sal,ev);
1965         if (ev->response){
1966                 if (ev->request && strcmp(osip_message_get_method(ev->request),"NOTIFY")==0){
1967                         if (op->sipfrag_pending){
1968                                 send_notify_for_refer(op->did,op->sipfrag_pending);
1969                                 op->sipfrag_pending=NULL;
1970                         }
1971                 }
1972         }
1973 }
1974
1975 static bool_t process_event(Sal *sal, eXosip_event_t *ev){
1976         ms_message("linphone process event get a message %d\n",ev->type);
1977         switch(ev->type){
1978                 case EXOSIP_CALL_ANSWERED:
1979                         ms_message("CALL_ANSWERED\n");
1980                         call_accepted(sal,ev);
1981                         authentication_ok(sal,ev);
1982                         break;
1983                 case EXOSIP_CALL_CLOSED:
1984                 case EXOSIP_CALL_CANCELLED:
1985                         ms_message("CALL_CLOSED or CANCELLED\n");
1986                         call_terminated(sal,ev);
1987                         break;
1988                 case EXOSIP_CALL_TIMEOUT:
1989                 case EXOSIP_CALL_NOANSWER:
1990                         ms_message("CALL_TIMEOUT or NOANSWER\n");
1991                         return call_failure(sal,ev);
1992                         break;
1993                 case EXOSIP_CALL_REQUESTFAILURE:
1994                 case EXOSIP_CALL_GLOBALFAILURE:
1995                 case EXOSIP_CALL_SERVERFAILURE:
1996                         ms_message("CALL_REQUESTFAILURE or GLOBALFAILURE or SERVERFAILURE\n");
1997                         return call_failure(sal,ev);
1998                         break;
1999                 case EXOSIP_CALL_RELEASED:
2000                         ms_message("CALL_RELEASED\n");
2001                         call_released(sal, ev);
2002                         break;
2003                 case EXOSIP_CALL_INVITE:
2004                         ms_message("CALL_NEW\n");
2005                         inc_new_call(sal,ev);
2006                         break;
2007                 case EXOSIP_CALL_REINVITE:
2008                         handle_reinvite(sal,ev);
2009                         break;
2010                 case EXOSIP_CALL_ACK:
2011                         ms_message("CALL_ACK");
2012                         handle_ack(sal,ev);
2013                         break;
2014                 case EXOSIP_CALL_REDIRECTED:
2015                         ms_message("CALL_REDIRECTED");
2016                         eXosip_default_action(ev);
2017                         break;
2018                 case EXOSIP_CALL_PROCEEDING:
2019                         ms_message("CALL_PROCEEDING");
2020                         call_proceeding(sal,ev);
2021                         break;
2022                 case EXOSIP_CALL_RINGING:
2023                         ms_message("CALL_RINGING");
2024                         call_ringing(sal,ev);
2025                         authentication_ok(sal,ev);
2026                         break;
2027                 case EXOSIP_CALL_MESSAGE_NEW:
2028                         ms_message("EXOSIP_CALL_MESSAGE_NEW");
2029                         call_message_new(sal,ev);
2030                         break;
2031                 case EXOSIP_CALL_MESSAGE_REQUESTFAILURE:
2032                         if (ev->response &&
2033                                 (ev->response->status_code==407 || ev->response->status_code==401)){
2034                                  return process_authentication(sal,ev);
2035                         }
2036                         break;
2037                 case EXOSIP_CALL_MESSAGE_ANSWERED:
2038                         ms_message("EXOSIP_CALL_MESSAGE_ANSWERED ");
2039                         process_in_call_reply(sal,ev);
2040                 break;
2041                 case EXOSIP_IN_SUBSCRIPTION_NEW:
2042                         ms_message("CALL_IN_SUBSCRIPTION_NEW ");
2043                         sal_exosip_subscription_recv(sal,ev);
2044                         break;
2045                 case EXOSIP_IN_SUBSCRIPTION_RELEASED:
2046                         ms_message("CALL_SUBSCRIPTION_NEW ");
2047                         sal_exosip_in_subscription_closed(sal,ev);
2048                         break;
2049                 case EXOSIP_SUBSCRIPTION_UPDATE:
2050                         ms_message("CALL_SUBSCRIPTION_UPDATE");
2051                         break;
2052                 case EXOSIP_SUBSCRIPTION_NOTIFY:
2053                         ms_message("CALL_SUBSCRIPTION_NOTIFY");
2054                         sal_exosip_notify_recv(sal,ev);
2055                         break;
2056                 case EXOSIP_SUBSCRIPTION_ANSWERED:
2057                         ms_message("EXOSIP_SUBSCRIPTION_ANSWERED, ev->sid=%i, ev->did=%i\n",ev->sid,ev->did);
2058                         sal_exosip_subscription_answered(sal,ev);
2059                         break;
2060                 case EXOSIP_SUBSCRIPTION_CLOSED:
2061                         ms_message("EXOSIP_SUBSCRIPTION_CLOSED\n");
2062                         sal_exosip_subscription_closed(sal,ev);
2063                         break;
2064                 case EXOSIP_SUBSCRIPTION_REQUESTFAILURE:   /**< announce a request failure      */
2065                         if (ev->response && (ev->response->status_code == 407 || ev->response->status_code == 401)){
2066                                 return process_authentication(sal,ev);
2067                         }
2068         case EXOSIP_SUBSCRIPTION_SERVERFAILURE:
2069                 case EXOSIP_SUBSCRIPTION_GLOBALFAILURE:
2070                         sal_exosip_subscription_closed(sal,ev);
2071                         break;
2072                 case EXOSIP_REGISTRATION_FAILURE:
2073                         ms_message("REGISTRATION_FAILURE\n");
2074                         return registration_failure(sal,ev);
2075                         break;
2076                 case EXOSIP_REGISTRATION_SUCCESS:
2077                         authentication_ok(sal,ev);
2078                         registration_success(sal,ev);
2079                         break;
2080                 case EXOSIP_MESSAGE_NEW:
2081                         other_request(sal,ev);
2082                         break;
2083                 case EXOSIP_MESSAGE_PROCEEDING:
2084                 case EXOSIP_MESSAGE_ANSWERED:
2085                 case EXOSIP_MESSAGE_REDIRECTED:
2086                 case EXOSIP_MESSAGE_SERVERFAILURE:
2087                 case EXOSIP_MESSAGE_GLOBALFAILURE:
2088                         other_request_reply(sal,ev);
2089                         break;
2090                 case EXOSIP_MESSAGE_REQUESTFAILURE:
2091                 case EXOSIP_NOTIFICATION_REQUESTFAILURE:
2092                         if (ev->response) {
2093                                 switch (ev->response->status_code) {
2094                                         case 407:
2095                                         case 401:
2096                                                 return process_authentication(sal,ev);
2097                                         case 412: {
2098                                                 eXosip_automatic_action ();
2099                                                 return 1;
2100                                         }
2101                                 }
2102                         }
2103                         other_request_reply(sal,ev);
2104                         break;
2105                 default:
2106                         ms_message("Unhandled exosip event ! %i",ev->type);
2107                         break;
2108         }
2109         return TRUE;
2110 }
2111
2112 int sal_iterate(Sal *sal){
2113         eXosip_event_t *ev;
2114         while((ev=eXosip_event_wait(0,0))!=NULL){
2115                 if (process_event(sal,ev))
2116                         eXosip_event_free(ev);
2117         }
2118 #ifdef HAVE_EXOSIP_TRYLOCK
2119         if (eXosip_trylock()==0){
2120                 eXosip_automatic_refresh();
2121                 eXosip_unlock();
2122         }else{
2123                 ms_warning("eXosip_trylock busy.");
2124         }
2125 #else
2126         eXosip_lock();
2127         eXosip_automatic_refresh();
2128         eXosip_unlock();
2129 #endif
2130         return 0;
2131 }
2132
2133 static void register_set_contact(osip_message_t *msg, const char *contact){
2134         osip_uri_param_t *param = NULL;
2135         osip_contact_t *ct=NULL;
2136         char *line=NULL;
2137         /*we get the line parameter choosed by exosip, and add it to our own contact*/
2138         osip_message_get_contact(msg,0,&ct);
2139         if (ct!=NULL){
2140                 osip_uri_uparam_get_byname(ct->url, "line", &param);
2141                 if (param && param->gvalue)
2142                         line=osip_strdup(param->gvalue);
2143         }
2144         _osip_list_set_empty(&msg->contacts,(void (*)(void*))osip_contact_free);
2145         osip_message_set_contact(msg,contact);
2146         osip_message_get_contact(msg,0,&ct);
2147         osip_uri_uparam_add(ct->url,osip_strdup("line"),line);
2148 }
2149
2150 static void sal_register_add_route(osip_message_t *msg, const char *proxy){
2151         char tmp[256]={0};
2152         snprintf(tmp,sizeof(tmp)-1,"<%s;lr>",proxy);
2153
2154         osip_list_special_free(&msg->routes,(void (*)(void*))osip_route_free);
2155         osip_message_set_route(msg,tmp);
2156 }
2157
2158 int sal_register(SalOp *h, const char *proxy, const char *from, int expires){
2159         osip_message_t *msg;
2160         const char *contact=sal_op_get_contact(h);
2161
2162         sal_op_set_route(h,proxy);
2163         if (h->rid==-1){
2164                 SalAddress *from_parsed=sal_address_new(from);
2165                 char domain[256];
2166                 if (from_parsed==NULL) {
2167                         ms_warning("sal_register() bad from %s",from);
2168                         return -1;
2169                 }
2170                 snprintf(domain,sizeof(domain),"sip:%s",sal_address_get_domain(from_parsed));
2171                 sal_address_destroy(from_parsed);
2172                 eXosip_lock();
2173                 h->rid=eXosip_register_build_initial_register(from,domain,NULL,expires,&msg);
2174                 if (msg){
2175                         if (contact) register_set_contact(msg,contact);
2176                         sal_register_add_route(msg,proxy);
2177                         sal_add_register(h->base.root,h);
2178                 }else{
2179                         ms_error("Could not build initial register.");
2180                         eXosip_unlock();
2181                         return -1;
2182                 }
2183         }else{
2184                 eXosip_lock();
2185                 eXosip_register_build_register(h->rid,expires,&msg);
2186                 sal_register_add_route(msg,proxy);
2187         }
2188         if (msg)
2189                 eXosip_register_send_register(h->rid,msg);
2190         eXosip_unlock();
2191         h->expires=expires;
2192         return (msg != NULL) ? 0 : -1;
2193 }
2194
2195 int sal_register_refresh(SalOp *op, int expires){
2196         osip_message_t *msg=NULL;
2197         const char *contact=sal_op_get_contact(op);
2198
2199         if (op->rid==-1){
2200                 ms_error("Unexistant registration context, not possible to refresh.");
2201                 return -1;
2202         }
2203         eXosip_lock();
2204         eXosip_register_build_register(op->rid,expires,&msg);
2205         if (msg!=NULL){
2206                 if (contact) register_set_contact(msg,contact);
2207                 sal_register_add_route(msg,sal_op_get_route(op));
2208                 eXosip_register_send_register(op->rid,msg);
2209         }else ms_error("Could not build REGISTER refresh message.");
2210         eXosip_unlock();
2211         return (msg != NULL) ? 0 : -1;
2212 }
2213
2214
2215 int sal_unregister(SalOp *h){
2216         osip_message_t *msg=NULL;
2217         eXosip_lock();
2218         eXosip_register_build_register(h->rid,0,&msg);
2219         if (msg) eXosip_register_send_register(h->rid,msg);
2220         else ms_warning("Could not build unREGISTER !");
2221         eXosip_unlock();
2222         return 0;
2223 }
2224
2225 SalAddress * sal_address_new(const char *uri){
2226         osip_from_t *from;
2227         osip_from_init(&from);
2228
2229         // Remove front spaces
2230         while (uri[0]==' ') {
2231                 uri++;
2232         }
2233
2234         if (osip_from_parse(from,uri)!=0){
2235                 osip_from_free(from);
2236                 return NULL;
2237         }
2238         if (from->displayname!=NULL && from->displayname[0]=='"'){
2239                 char *unquoted=osip_strdup_without_quote(from->displayname);
2240                 osip_free(from->displayname);
2241                 from->displayname=unquoted;
2242         }
2243         return (SalAddress*)from;
2244 }
2245
2246 SalAddress * sal_address_clone(const SalAddress *addr){
2247         osip_from_t *ret=NULL;
2248         osip_from_clone((osip_from_t*)addr,&ret);
2249         return (SalAddress*)ret;
2250 }
2251
2252 #define null_if_empty(s) (((s)!=NULL && (s)[0]!='\0') ? (s) : NULL )
2253
2254 const char *sal_address_get_scheme(const SalAddress *addr){
2255         const osip_from_t *u=(const osip_from_t*)addr;
2256         return null_if_empty(u->url->scheme);
2257 }
2258
2259 const char *sal_address_get_display_name(const SalAddress* addr){
2260         const osip_from_t *u=(const osip_from_t*)addr;
2261         return null_if_empty(u->displayname);
2262 }
2263
2264 const char *sal_address_get_username(const SalAddress *addr){
2265         const osip_from_t *u=(const osip_from_t*)addr;
2266         return null_if_empty(u->url->username);
2267 }
2268
2269 const char *sal_address_get_domain(const SalAddress *addr){
2270         const osip_from_t *u=(const osip_from_t*)addr;
2271         return null_if_empty(u->url->host);
2272 }
2273
2274 void sal_address_set_display_name(SalAddress *addr, const char *display_name){
2275         osip_from_t *u=(osip_from_t*)addr;
2276         if (u->displayname!=NULL){
2277                 osip_free(u->displayname);
2278                 u->displayname=NULL;
2279         }
2280         if (display_name!=NULL && display_name[0]!='\0'){
2281                 u->displayname=osip_strdup(display_name);
2282         }
2283 }
2284
2285 void sal_address_set_username(SalAddress *addr, const char *username){
2286         osip_from_t *uri=(osip_from_t*)addr;
2287         if (uri->url->username!=NULL){
2288                 osip_free(uri->url->username);
2289                 uri->url->username=NULL;
2290         }
2291         if (username)
2292                 uri->url->username=osip_strdup(username);
2293 }
2294
2295 void sal_address_set_domain(SalAddress *addr, const char *host){
2296         osip_from_t *uri=(osip_from_t*)addr;
2297         if (uri->url->host!=NULL){
2298                 osip_free(uri->url->host);
2299                 uri->url->host=NULL;
2300         }
2301         if (host)
2302                 uri->url->host=osip_strdup(host);
2303 }
2304
2305 void sal_address_set_port(SalAddress *addr, const char *port){
2306         osip_from_t *uri=(osip_from_t*)addr;
2307         if (uri->url->port!=NULL){
2308                 osip_free(uri->url->port);
2309                 uri->url->port=NULL;
2310         }
2311         if (port)
2312                 uri->url->port=osip_strdup(port);
2313 }
2314
2315 void sal_address_set_port_int(SalAddress *uri, int port){
2316         char tmp[12];
2317         if (port==5060){
2318                 /*this is the default, special case to leave the port field blank*/
2319                 sal_address_set_port(uri,NULL);
2320                 return;
2321         }
2322         snprintf(tmp,sizeof(tmp),"%i",port);
2323         sal_address_set_port(uri,tmp);
2324 }
2325
2326 void sal_address_clean(SalAddress *addr){
2327         osip_generic_param_freelist(& ((osip_from_t*)addr)->gen_params);
2328         osip_uri_param_freelist(& ((osip_from_t*)addr)->url->url_params);
2329 }
2330
2331 char *sal_address_as_string(const SalAddress *u){
2332         char *tmp,*ret;
2333         osip_from_t *from=(osip_from_t *)u;
2334         char *old_displayname=NULL;
2335         /* hack to force use of quotes around the displayname*/
2336         if (from->displayname!=NULL
2337             && from->displayname[0]!='"'){
2338                 old_displayname=from->displayname;
2339                 from->displayname=osip_enquote(from->displayname);
2340         }
2341         osip_from_to_str(from,&tmp);
2342         if (old_displayname!=NULL){
2343                 ms_free(from->displayname);
2344                 from->displayname=old_displayname;
2345         }
2346         ret=ms_strdup(tmp);
2347         osip_free(tmp);
2348         return ret;
2349 }
2350
2351 char *sal_address_as_string_uri_only(const SalAddress *u){
2352         char *tmp=NULL,*ret;
2353         osip_uri_to_str(((osip_from_t*)u)->url,&tmp);
2354         ret=ms_strdup(tmp);
2355         osip_free(tmp);
2356         return ret;
2357 }
2358 void sal_address_set_param(SalAddress *u,const char* name,const char* value) {
2359         osip_uri_param_t *param=NULL;
2360     osip_uri_uparam_get_byname(((osip_from_t*)u)->url,(char*)name,&param);
2361     if (param == NULL){
2362         osip_uri_uparam_add     (((osip_from_t*)u)->url,ms_strdup(name),value ? ms_strdup(value) : NULL);
2363     } else {
2364         osip_free(param->gvalue);
2365         param->gvalue=value ? osip_strdup(value) : NULL;
2366     }
2367
2368 }
2369
2370 void sal_address_destroy(SalAddress *u){
2371         osip_from_free((osip_from_t*)u);
2372 }
2373
2374 void sal_set_keepalive_period(Sal *ctx,unsigned int value) {
2375         ctx->keepalive_period=value;
2376         eXosip_set_option (EXOSIP_OPT_UDP_KEEP_ALIVE, &value);
2377 }
2378 unsigned int sal_get_keepalive_period(Sal *ctx) {
2379         return ctx->keepalive_period;
2380 }
2381
2382 const char * sal_address_get_port(const SalAddress *addr) {
2383         const osip_from_t *u=(const osip_from_t*)addr;
2384         return null_if_empty(u->url->port);
2385 }
2386
2387 int sal_address_get_port_int(const SalAddress *uri) {
2388         const char* port = sal_address_get_port(uri);
2389         if (port != NULL) {
2390                 return atoi(port);
2391         } else {
2392                 return 5060;
2393         }
2394 }
2395 SalTransport sal_address_get_transport(const SalAddress* addr) {
2396     const osip_from_t *u=(const osip_from_t*)addr;
2397     osip_uri_param_t *transport_param=NULL;
2398     osip_uri_uparam_get_byname(u->url,"transport",&transport_param);
2399     if (transport_param == NULL){
2400         return SalTransportUDP;
2401     }  else {
2402         return sal_transport_parse(transport_param->gvalue);
2403     }
2404 }
2405 void sal_address_set_transport(SalAddress* addr,SalTransport transport) {
2406     sal_address_set_param(addr, "transport", sal_transport_to_string(transport));
2407 }
2408
2409 /* sends a reinvite. Local media description may have changed by application since call establishment*/
2410 int sal_call_update(SalOp *h, const char *subject){
2411         int err=0;
2412         osip_message_t *reinvite=NULL;
2413
2414         eXosip_lock();
2415         if(eXosip_call_build_request(h->did,"INVITE",&reinvite) != 0 || reinvite==NULL){
2416                 eXosip_unlock();
2417                 return -1;
2418         }
2419         eXosip_unlock();
2420         osip_message_set_subject(reinvite,subject);
2421         osip_message_set_allow(reinvite, "INVITE, ACK, CANCEL, OPTIONS, BYE, REFER, NOTIFY, MESSAGE, SUBSCRIBE, INFO");
2422         if (h->base.root->session_expires!=0){
2423                 osip_message_set_header(reinvite, "Session-expires", "200");
2424                 osip_message_set_supported(reinvite, "timer");
2425         }
2426         if (h->base.local_media){
2427                 h->sdp_offering=TRUE;
2428                 set_sdp_from_desc(reinvite,h->base.local_media,sal_op_get_ice_session(h));
2429         }else h->sdp_offering=FALSE;
2430         eXosip_lock();
2431         err = eXosip_call_send_request(h->did, reinvite);
2432         eXosip_unlock();
2433         return err;
2434 }
2435 void sal_reuse_authorization(Sal *ctx, bool_t value) {
2436         ctx->reuse_authorization=value;
2437 }