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].rtp_port>0){
 537                                 strcpy(h->result->streams[i].rtp_addr,h->base.remote_media->streams[i].rtp_addr);
 538                                 strcpy(h->result->streams[i].rtcp_addr,h->base.remote_media->streams[i].rtcp_addr);
 539                                 h->result->streams[i].ptime=h->base.remote_media->streams[i].ptime;
 540                                 h->result->streams[i].bandwidth=h->base.remote_media->streams[i].bandwidth;
 541                                 h->result->streams[i].rtp_port=h->base.remote_media->streams[i].rtp_port;
 542                                 h->result->streams[i].rtcp_port=h->base.remote_media->streams[i].rtcp_port;
 543
 544                                 if (h->result->streams[i].proto == SalProtoRtpSavp) {
 545                                         h->result->streams[i].crypto[0] = h->base.remote_media->streams[i].crypto[0];
 546                                 }
 547                         }
 548                 }
 549         }
 550
 551 }
 552
 553 int sal_call_is_offerer(const SalOp *h){
 554         return h->sdp_offering;
 555 }
 556
 557 int sal_call_set_local_media_description(SalOp *h, SalMediaDescription *desc){
 558         if (desc)
 559                 sal_media_description_ref(desc);
 560         if (h->base.local_media)
 561                 sal_media_description_unref(h->base.local_media);
 562         h->base.local_media=desc;
 563         if (h->base.remote_media){
 564                 /*case of an incoming call where we modify the local capabilities between the time
 565                  * the call is ringing and it is accepted (for example if you want to accept without video*/
 566                 /*reset the sdp answer so that it is computed again*/
 567                 if (h->sdp_answer){
 568                         sdp_message_free(h->sdp_answer);
 569                         h->sdp_answer=NULL;
 570                 }
 571         }
 572         return 0;
 573 }
 574
 575 int sal_call(SalOp *h, const char *from, const char *to){
 576         int err;
 577         const char *route;
 578         osip_message_t *invite=NULL;
 579         sal_op_set_from(h,from);
 580         sal_op_set_to(h,to);
 581         sal_exosip_fix_route(h);
 582
 583         h->terminated = FALSE;
 584
 585         route = sal_op_get_route(h);
 586         err=eXosip_call_build_initial_invite(&invite,to,from,route,"Phone call");
 587         if (err!=0){
 588                 ms_error("Could not create call. Error %d (from=%s to=%s route=%s)",
 589                                 err, from, to, route);
 590                 return -1;
 591         }
 592         osip_message_set_allow(invite, "INVITE, ACK, CANCEL, OPTIONS, BYE, REFER, NOTIFY, MESSAGE, SUBSCRIBE, INFO");
 593         if (h->base.contact){
 594                 _osip_list_set_empty(&invite->contacts,(void (*)(void*))osip_contact_free);
 595                 osip_message_set_contact(invite,h->base.contact);
 596         }
 597         if (h->base.root->session_expires!=0){
 598                 osip_message_set_header(invite, "Session-expires", "200");
 599                 osip_message_set_supported(invite, "timer");
 600         }
 601         if (h->base.local_media){
 602                 h->sdp_offering=TRUE;
 603                 set_sdp_from_desc(invite,h->base.local_media,sal_op_get_ice_session(h));
 604         }else h->sdp_offering=FALSE;
 605         if (h->replaces){
 606                 osip_message_set_header(invite,"Replaces",h->replaces);
 607                 if (h->referred_by)
 608                         osip_message_set_header(invite,"Referred-By",h->referred_by);
 609         }
 610
 611         eXosip_lock();
 612         err=eXosip_call_send_initial_invite(invite);
 613         eXosip_unlock();
 614         h->cid=err;
 615         if (err<0){
 616                 ms_error("Fail to send invite ! Error code %d", err);
 617                 return -1;
 618         }else{
 619                 sal_add_call(h->base.root,h);
 620         }
 621         return 0;
 622 }
 623
 624 int sal_call_notify_ringing(SalOp *h, bool_t early_media){
 625         osip_message_t *msg;
 626
 627         /*if early media send also 180 and 183 */
 628         if (early_media){
 629                 msg=NULL;
 630                 eXosip_lock();
 631                 eXosip_call_build_answer(h->tid,183,&msg);
 632                 if (msg){
 633                         sdp_process(h);
 634                         if (h->sdp_answer){
 635                                 set_sdp(msg,h->sdp_answer);
 636                                 sdp_message_free(h->sdp_answer);
 637                                 h->sdp_answer=NULL;
 638                         }
 639                         eXosip_call_send_answer(h->tid,183,msg);
 640                 }
 641                 eXosip_unlock();
 642         }else{
 643                 eXosip_lock();
 644                 eXosip_call_send_answer(h->tid,180,NULL);
 645                 eXosip_unlock();
 646         }
 647         return 0;
 648 }
 649
 650 int sal_call_accept(SalOp * h){
 651         osip_message_t *msg;
 652         const char *contact=sal_op_get_contact(h);
 653         /* sends a 200 OK */
 654         int err=eXosip_call_build_answer(h->tid,200,&msg);
 655         if (err<0 || msg==NULL){
 656                 ms_error("Fail to build answer for call: err=%i",err);
 657                 return -1;
 658         }
 659         if (h->base.root->session_expires!=0){
 660                 if (h->supports_session_timers) osip_message_set_supported(msg, "timer");
 661         }
 662
 663         if (contact) {
 664                 _osip_list_set_empty(&msg->contacts,(void (*)(void*))osip_contact_free);
 665                 osip_message_set_contact(msg,contact);
 666         }
 667
 668         if (h->base.local_media){
 669                 /*this is the case where we received an invite without SDP*/
 670                 if (h->sdp_offering) {
 671                         set_sdp_from_desc(msg,h->base.local_media,sal_op_get_ice_session(h));
 672                 }else{
 673                         if (h->sdp_answer==NULL) sdp_process(h);
 674                         if (h->sdp_answer){
 675                                 set_sdp(msg,h->sdp_answer);
 676                                 sdp_message_free(h->sdp_answer);
 677                                 h->sdp_answer=NULL;
 678                         }
 679                 }
 680         }else{
 681                 ms_error("You are accepting a call but not defined any media capabilities !");
 682         }
 683         eXosip_call_send_answer(h->tid,200,msg);
 684         return 0;
 685 }
 686
 687 int sal_call_decline(SalOp *h, SalReason reason, const char *redirect){
 688         if (reason==SalReasonBusy){
 689                 eXosip_lock();
 690                 eXosip_call_send_answer(h->tid,486,NULL);
 691                 eXosip_unlock();
 692         }
 693         else if (reason==SalReasonTemporarilyUnavailable){
 694                 eXosip_lock();
 695                 eXosip_call_send_answer(h->tid,480,NULL);
 696                 eXosip_unlock();
 697         }else if (reason==SalReasonDoNotDisturb){
 698                 eXosip_lock();
 699                 eXosip_call_send_answer(h->tid,600,NULL);
 700                 eXosip_unlock();
 701         }else if (reason==SalReasonMedia){
 702                 eXosip_lock();
 703                 eXosip_call_send_answer(h->tid,415,NULL);
 704                 eXosip_unlock();
 705         }else if (redirect!=NULL && reason==SalReasonRedirect){
 706                 osip_message_t *msg;
 707                 int code;
 708                 if (strstr(redirect,"sip:")!=0) code=302;
 709                 else code=380;
 710                 eXosip_lock();
 711                 eXosip_call_build_answer(h->tid,code,&msg);
 712                 osip_message_set_contact(msg,redirect);
 713                 eXosip_call_send_answer(h->tid,code,msg);
 714                 eXosip_unlock();
 715         }else sal_call_terminate(h);
 716         return 0;
 717 }
 718
 719 SalMediaDescription * sal_call_get_remote_media_description(SalOp *h){
 720         return h->base.remote_media;
 721 }
 722
 723 SalMediaDescription * sal_call_get_final_media_description(SalOp *h){
 724         if (h->base.local_media && h->base.remote_media && !h->result){
 725                 sdp_process(h);
 726         }
 727         return h->result;
 728 }
 729
 730 int sal_call_set_referer(SalOp *h, SalOp *refered_call){
 731         if (refered_call->replaces)
 732                 h->replaces=ms_strdup(refered_call->replaces);
 733         if (refered_call->referred_by)
 734                 h->referred_by=ms_strdup(refered_call->referred_by);
 735         return 0;
 736 }
 737
 738 static int send_notify_for_refer(int did, const char *sipfrag){
 739         osip_message_t *msg;
 740         eXosip_lock();
 741         eXosip_call_build_notify(did,EXOSIP_SUBCRSTATE_ACTIVE,&msg);
 742         if (msg==NULL){
 743                 eXosip_unlock();
 744                 ms_warning("Could not build NOTIFY for refer.");
 745                 return -1;
 746         }
 747         osip_message_set_content_type(msg,"message/sipfrag");
 748         osip_message_set_header(msg,"Event","refer");
 749         osip_message_set_body(msg,sipfrag,strlen(sipfrag));
 750         eXosip_call_send_request(did,msg);
 751         eXosip_unlock();
 752         return 0;
 753 }
 754
 755 /* currently only support to notify trying and 200Ok*/
 756 int sal_call_notify_refer_state(SalOp *h, SalOp *newcall){
 757         if (newcall==NULL){
 758                 /* in progress*/
 759                 send_notify_for_refer(h->did,"SIP/2.0 100 Trying\r\n");
 760         }
 761         else if (newcall->cid!=-1){
 762                 if (newcall->did==-1){
 763                         /* not yet established*/
 764                         if (!newcall->terminated){
 765                                 /* in progress*/
 766                                 send_notify_for_refer(h->did,"SIP/2.0 100 Trying\r\n");
 767                         }
 768                 }else{
 769                         if (!newcall->terminated){
 770                                 if (send_notify_for_refer(h->did,"SIP/2.0 200 Ok\r\n")==-1){
 771                                         /* we need previous notify transaction to complete, so buffer the request for later*/
 772                                         h->sipfrag_pending="SIP/2.0 200 Ok\r\n";
 773                                 }
 774                         }
 775                 }
 776         }
 777         return 0;
 778 }
 779
 780 int sal_ping(SalOp *op, const char *from, const char *to){
 781         osip_message_t *options=NULL;
 782
 783         sal_op_set_from(op,from);
 784         sal_op_set_to(op,to);
 785         sal_exosip_fix_route(op);
 786
 787         eXosip_options_build_request (&options, sal_op_get_to(op),
 788                         sal_op_get_from(op),sal_op_get_route(op));
 789         if (options){
 790                 if (op->base.root->session_expires!=0){
 791                         osip_message_set_header(options, "Session-expires", "200");
 792                         osip_message_set_supported(options, "timer");
 793                 }
 794                 sal_add_other(sal_op_get_sal(op),op,options);
 795                 return eXosip_options_send_request(options);
 796         }
 797         return -1;
 798 }
 799
 800 int sal_call_refer(SalOp *h, const char *refer_to){
 801         osip_message_t *msg=NULL;
 802         int err=0;
 803         eXosip_lock();
 804         eXosip_call_build_refer(h->did,refer_to, &msg);
 805         if (msg) err=eXosip_call_send_request(h->did, msg);
 806         else err=-1;
 807         eXosip_unlock();
 808         return err;
 809 }
 810
 811 int sal_call_refer_with_replaces(SalOp *h, SalOp *other_call_h){
 812         osip_message_t *msg=NULL;
 813         char referto[256]={0};
 814         int err=0;
 815         eXosip_lock();
 816         if (eXosip_call_get_referto(other_call_h->did,referto,sizeof(referto)-1)!=0){
 817                 ms_error("eXosip_call_get_referto() failed for did=%i",other_call_h->did);
 818                 eXosip_unlock();
 819                 return -1;
 820         }
 821         eXosip_call_build_refer(h->did,referto, &msg);
 822         osip_message_set_header(msg,"Referred-By",h->base.from);
 823         if (msg) err=eXosip_call_send_request(h->did, msg);
 824         else err=-1;
 825         eXosip_unlock();
 826         return err;
 827 }
 828
 829 SalOp *sal_call_get_replaces(SalOp *h){
 830         if (h!=NULL && h->replaces!=NULL){
 831                 int cid;
 832                 eXosip_lock();
 833                 cid=eXosip_call_find_by_replaces(h->replaces);
 834                 eXosip_unlock();
 835                 if (cid>0){
 836                         SalOp *ret=sal_find_call(h->base.root,cid);
 837                         return ret;
 838                 }
 839         }
 840         return NULL;
 841 }
 842
 843 int sal_call_send_dtmf(SalOp *h, char dtmf){
 844         osip_message_t *msg=NULL;
 845         char dtmf_body[128];
 846         char clen[10];
 847
 848         eXosip_lock();
 849         eXosip_call_build_info(h->did,&msg);
 850         if (msg){
 851                 snprintf(dtmf_body, sizeof(dtmf_body), "Signal=%c\r\nDuration=250\r\n", dtmf);
 852                 osip_message_set_body(msg,dtmf_body,strlen(dtmf_body));
 853                 osip_message_set_content_type(msg,"application/dtmf-relay");
 854                 snprintf(clen,sizeof(clen),"%lu",(unsigned long)strlen(dtmf_body));
 855                 osip_message_set_content_length(msg,clen);
 856                 eXosip_call_send_request(h->did,msg);
 857         }
 858         eXosip_unlock();
 859         return 0;
 860 }
 861
 862 static void push_auth_to_exosip(const SalAuthInfo *info){
 863         const char *userid;
 864         if (info->userid==NULL || info->userid[0]=='\0') userid=info->username;
 865         else userid=info->userid;
 866         ms_message("Authentication info for username [%s], id[%s], realm [%s] added to eXosip", info->username,userid, info->realm);
 867         eXosip_add_authentication_info (info->username,userid,
 868                                   info->password, NULL,info->realm);
 869 }
 870 /*
 871  * Just for symmetry ;-)
 872  */
 873 static void pop_auth_from_exosip() {
 874         eXosip_clear_authentication_info();
 875 }
 876
 877 int sal_call_terminate(SalOp *h){
 878         int err;
 879         if (h == NULL) return -1;
 880         if (h->auth_info) push_auth_to_exosip(h->auth_info);
 881         eXosip_lock();
 882         err=eXosip_call_terminate(h->cid,h->did);
 883         eXosip_unlock();
 884         if (!h->base.root->reuse_authorization) pop_auth_from_exosip();
 885         if (err!=0){
 886                 ms_warning("Exosip could not terminate the call: cid=%i did=%i", h->cid,h->did);
 887         }
 888         h->terminated=TRUE;
 889         return 0;
 890 }
 891
 892 void sal_op_authenticate(SalOp *h, const SalAuthInfo *info){
 893         if (h->terminated) return;
 894     if (h->pending_auth){
 895                 push_auth_to_exosip(info);
 896
 897         /*FIXME exosip does not take into account this update register message*/
 898         /*
 899         if (fix_message_contact(h, h->pending_auth->request,h->pending_auth->response)) {
 900
 901         };
 902         */
 903                 update_contact_from_response(h,h->pending_auth->response);
 904                 eXosip_lock();
 905                 eXosip_default_action(h->pending_auth);
 906                 eXosip_unlock();
 907                 ms_message("eXosip_default_action() done");
 908                 if (!h->base.root->reuse_authorization) pop_auth_from_exosip();
 909
 910                 if (h->auth_info) sal_auth_info_delete(h->auth_info); /*if already exist*/
 911                 h->auth_info=sal_auth_info_clone(info); /*store auth info for subsequent request*/
 912         }
 913 }
 914 void sal_op_cancel_authentication(SalOp *h) {
 915         if (h->rid >0) {
 916                 sal_op_get_sal(h)->callbacks.register_failure(h,SalErrorFailure, SalReasonForbidden,_("Authentication failure"));
 917         } else if (h->cid >0) {
 918                 sal_op_get_sal(h)->callbacks.call_failure(h,SalErrorFailure, SalReasonForbidden,_("Authentication failure"),0);
 919         } else {
 920                 ms_warning("Auth failure not handled");
 921         }
 922
 923 }
 924 static void set_network_origin(SalOp *op, osip_message_t *req){
 925         const char *received=NULL;
 926         int rport=5060;
 927         char origin[64]={0};
 928     SalTransport transport;
 929         if (extract_received_rport(req,&received,&rport,&transport)!=0){
 930                 osip_via_t *via=NULL;
 931                 char *tmp;
 932                 osip_message_get_via(req,0,&via);
 933                 received=osip_via_get_host(via);
 934                 tmp=osip_via_get_port(via);
 935                 if (tmp) rport=atoi(tmp);
 936         }
 937     if (transport != SalTransportUDP) {
 938         snprintf(origin,sizeof(origin)-1,"sip:%s:%i",received,rport);
 939     } else {
 940        snprintf(origin,sizeof(origin)-1,"sip:%s:%i;transport=%s",received,rport,sal_transport_to_string(transport));
 941     }
 942         __sal_op_set_network_origin(op,origin);
 943 }
 944
 945 static void set_remote_ua(SalOp* op, osip_message_t *req){
 946         if (op->base.remote_ua==NULL){
 947                 osip_header_t *h=NULL;
 948                 osip_message_get_user_agent(req,0,&h);
 949                 if (h){
 950                         op->base.remote_ua=ms_strdup(h->hvalue);
 951                 }
 952         }
 953 }
 954
 955 static void set_replaces(SalOp *op, osip_message_t *req){
 956         osip_header_t *h=NULL;
 957
 958         if (op->replaces){
 959                 ms_free(op->replaces);
 960                 op->replaces=NULL;
 961         }
 962         osip_message_header_get_byname(req,"replaces",0,&h);
 963         if (h){
 964                 if (h->hvalue && h->hvalue[0]!='\0'){
 965                         op->replaces=ms_strdup(h->hvalue);
 966                 }
 967         }
 968 }
 969
 970 static SalOp *find_op(Sal *sal, eXosip_event_t *ev){
 971         if (ev->cid>0){
 972                 return sal_find_call(sal,ev->cid);
 973         }
 974         if (ev->rid>0){
 975                 return sal_find_register(sal,ev->rid);
 976         }
 977         if (ev->sid>0){
 978                 return sal_find_out_subscribe(sal,ev->sid);
 979         }
 980         if (ev->nid>0){
 981                 return sal_find_in_subscribe(sal,ev->nid);
 982         }
 983         if (ev->response) return sal_find_other(sal,ev->response);
 984         return NULL;
 985 }
 986
 987 static void inc_new_call(Sal *sal, eXosip_event_t *ev){
 988         SalOp *op=sal_op_new(sal);
 989         osip_from_t *from,*to;
 990         osip_call_info_t *call_info;
 991         char *tmp;
 992         sdp_message_t *sdp=eXosip_get_sdp_info(ev->request);
 993         IceSession *ice_session;
 994
 995         set_network_origin(op,ev->request);
 996         set_remote_ua(op,ev->request);
 997         set_replaces(op,ev->request);
 998
 999         if (sdp){
1000                 op->sdp_offering=FALSE;
1001                 op->base.remote_media=sal_media_description_new();
1002                 ice_session=sal_op_get_ice_session(op);
1003                 sdp_to_media_description(sdp,op->base.remote_media,&ice_session);
1004                 sal_op_set_ice_session(op,ice_session);
1005                 sdp_message_free(sdp);
1006         }else op->sdp_offering=TRUE;
1007
1008         from=osip_message_get_from(ev->request);
1009         to=osip_message_get_to(ev->request);
1010         osip_from_to_str(from,&tmp);
1011         sal_op_set_from(op,tmp);
1012         osip_free(tmp);
1013         osip_from_to_str(to,&tmp);
1014         sal_op_set_to(op,tmp);
1015         osip_free(tmp);
1016
1017         osip_message_get_call_info(ev->request,0,&call_info);
1018         if(call_info)
1019         {
1020                 osip_call_info_to_str(call_info,&tmp);
1021                 if( strstr(tmp,"answer-after=") != NULL)
1022                 {
1023                         op->auto_answer_asked=TRUE;
1024                         ms_message("The caller asked to automatically answer the call(Emergency?)\n");
1025                 }
1026                 osip_free(tmp);
1027         }
1028
1029         op->tid=ev->tid;
1030         op->cid=ev->cid;
1031         op->did=ev->did;
1032
1033         sal_add_call(op->base.root,op);
1034         sal->callbacks.call_received(op);
1035 }
1036
1037 static void handle_reinvite(Sal *sal,  eXosip_event_t *ev){
1038         SalOp *op=find_op(sal,ev);
1039         sdp_message_t *sdp;
1040         IceSession *ice_session;
1041
1042         if (op==NULL) {
1043                 ms_warning("Reinvite for non-existing operation !");
1044                 return;
1045         }
1046         op->reinvite=TRUE;
1047         op->tid=ev->tid;
1048         sdp=eXosip_get_sdp_info(ev->request);
1049         if (op->base.remote_media){
1050                 sal_media_description_unref(op->base.remote_media);
1051                 op->base.remote_media=NULL;
1052         }
1053         if (op->result){
1054                 sal_media_description_unref(op->result);
1055                 op->result=NULL;
1056         }
1057         if (sdp){
1058                 op->sdp_offering=FALSE;
1059                 op->base.remote_media=sal_media_description_new();
1060                 ice_session=sal_op_get_ice_session(op);
1061                 sdp_to_media_description(sdp,op->base.remote_media,&ice_session);
1062                 sal_op_set_ice_session(op,ice_session);
1063                 sdp_message_free(sdp);
1064
1065         }else {
1066                 op->sdp_offering=TRUE;
1067         }
1068         sal->callbacks.call_updating(op);
1069 }
1070
1071 static void handle_ack(Sal *sal,  eXosip_event_t *ev){
1072         SalOp *op=find_op(sal,ev);
1073         sdp_message_t *sdp;
1074         IceSession *ice_session;
1075
1076         if (op==NULL) {
1077                 ms_warning("ack for non-existing call !");
1078                 return;
1079         }
1080         if (op->terminated) {
1081                 ms_warning("ack for terminated call, ignoring");
1082                 return;
1083         }
1084
1085         if (op->sdp_offering){
1086                 sdp=eXosip_get_sdp_info(ev->ack);
1087                 if (sdp){
1088                         if (op->base.remote_media)
1089                                 sal_media_description_unref(op->base.remote_media);
1090                         op->base.remote_media=sal_media_description_new();
1091                         ice_session=sal_op_get_ice_session(op);
1092                         sdp_to_media_description(sdp,op->base.remote_media,&ice_session);
1093                         sal_op_set_ice_session(op,ice_session);
1094                         sdp_process(op);
1095                         sdp_message_free(sdp);
1096                 }
1097         }
1098         if (op->reinvite){
1099                 op->reinvite=FALSE;
1100         }
1101         sal->callbacks.call_ack(op);
1102 }
1103
1104 static void update_contact_from_response(SalOp *op, osip_message_t *response){
1105         const char *received;
1106         int rport;
1107         SalTransport transport;
1108         if (extract_received_rport(response,&received,&rport,&transport)==0){
1109                 const char *contact=sal_op_get_contact(op);
1110                 if (!contact){
1111                         /*no contact given yet, use from instead*/
1112                         contact=sal_op_get_from(op);
1113                 }
1114                 if (contact){
1115                         SalAddress *addr=sal_address_new(contact);
1116                         char *tmp;
1117                         sal_address_set_domain(addr,received);
1118                         sal_address_set_port_int(addr,rport);
1119                         if (transport!=SalTransportUDP)
1120                                 sal_address_set_transport(addr,transport);
1121                         tmp=sal_address_as_string(addr);
1122                         ms_message("Contact address updated to %s",tmp);
1123                         sal_op_set_contact(op,tmp);
1124                         sal_address_destroy(addr);
1125                         ms_free(tmp);
1126                 }
1127         }
1128 }
1129
1130 static int call_proceeding(Sal *sal, eXosip_event_t *ev){
1131         SalOp *op=find_op(sal,ev);
1132
1133         if (op==NULL || op->terminated==TRUE) {
1134                 ms_warning("This call has been canceled.");
1135                 eXosip_lock();
1136                 eXosip_call_terminate(ev->cid,ev->did);
1137                 eXosip_unlock();
1138                 return -1;
1139         }
1140         if (ev->did>0)
1141                 op->did=ev->did;
1142         op->tid=ev->tid;
1143
1144         /* update contact if received and rport are set by the server
1145          note: will only be used by remote for next INVITE, if any...*/
1146         update_contact_from_response(op,ev->response);
1147         return 0;
1148 }
1149
1150 static void call_ringing(Sal *sal, eXosip_event_t *ev){
1151         sdp_message_t *sdp;
1152         SalOp *op=find_op(sal,ev);
1153         IceSession *ice_session;
1154         if (call_proceeding(sal, ev)==-1) return;
1155
1156         set_remote_ua(op,ev->response);
1157         sdp=eXosip_get_sdp_info(ev->response);
1158         if (sdp){
1159                 op->base.remote_media=sal_media_description_new();
1160                 ice_session=sal_op_get_ice_session(op);
1161                 sdp_to_media_description(sdp,op->base.remote_media,&ice_session);
1162                 sal_op_set_ice_session(op,ice_session);
1163                 sdp_message_free(sdp);
1164                 if (op->base.local_media) sdp_process(op);
1165         }
1166         sal->callbacks.call_ringing(op);
1167 }
1168
1169 static void call_accepted(Sal *sal, eXosip_event_t *ev){
1170         sdp_message_t *sdp;
1171         osip_message_t *msg=NULL;
1172         SalOp *op=find_op(sal,ev);
1173         const char *contact;
1174         IceSession *ice_session;
1175
1176         if (op==NULL || op->terminated==TRUE) {
1177                 ms_warning("This call has been already terminated.");
1178                 eXosip_lock();
1179                 eXosip_call_terminate(ev->cid,ev->did);
1180                 eXosip_unlock();
1181                 return ;
1182         }
1183
1184         op->did=ev->did;
1185         set_remote_ua(op,ev->response);
1186
1187         sdp=eXosip_get_sdp_info(ev->response);
1188         if (sdp){
1189                 op->base.remote_media=sal_media_description_new();
1190                 ice_session=sal_op_get_ice_session(op);
1191                 sdp_to_media_description(sdp,op->base.remote_media,&ice_session);
1192                 sal_op_set_ice_session(op,ice_session);
1193                 sdp_message_free(sdp);
1194                 if (op->base.local_media) sdp_process(op);
1195         }
1196         eXosip_call_build_ack(ev->did,&msg);
1197         if (msg==NULL) {
1198                 ms_warning("This call has been already terminated.");
1199                 eXosip_lock();
1200                 eXosip_call_terminate(ev->cid,ev->did);
1201                 eXosip_unlock();
1202                 return ;
1203         }
1204         contact=sal_op_get_contact(op);
1205         if (contact) {
1206                 _osip_list_set_empty(&msg->contacts,(void (*)(void*))osip_contact_free);
1207                 osip_message_set_contact(msg,contact);
1208         }
1209         if (op->sdp_answer){
1210                 set_sdp(msg,op->sdp_answer);
1211                 sdp_message_free(op->sdp_answer);
1212                 op->sdp_answer=NULL;
1213         }
1214         eXosip_call_send_ack(ev->did,msg);
1215         sal->callbacks.call_accepted(op);
1216 }
1217
1218 static void call_terminated(Sal *sal, eXosip_event_t *ev){
1219         char *from=NULL;
1220         SalOp *op=find_op(sal,ev);
1221         if (op==NULL){
1222                 ms_warning("Call terminated for already closed call ?");
1223                 return;
1224         }
1225         if (ev->request){
1226                 osip_from_to_str(ev->request->from,&from);
1227         }
1228         sal->callbacks.call_terminated(op,from!=NULL ? from : sal_op_get_from(op));
1229         if (from) osip_free(from);
1230         op->terminated=TRUE;
1231 }
1232
1233 static void call_released(Sal *sal, eXosip_event_t *ev){
1234         SalOp *op=find_op(sal,ev);
1235         if (op==NULL){
1236                 ms_warning("No op associated to this call_released()");
1237                 return;
1238         }
1239         if (!op->terminated){
1240                 /* no response received so far */
1241                 call_failure(sal,ev);
1242         }
1243         sal->callbacks.call_released(op);
1244 }
1245
1246 static int get_auth_data_from_response(osip_message_t *resp, const char **realm, const char **username){
1247         const char *prx_realm=NULL,*www_realm=NULL;
1248         osip_proxy_authenticate_t *prx_auth;
1249         osip_www_authenticate_t *www_auth;
1250
1251         *username=osip_uri_get_username(resp->from->url);
1252         prx_auth=(osip_proxy_authenticate_t*)osip_list_get(&resp->proxy_authenticates,0);
1253         www_auth=(osip_proxy_authenticate_t*)osip_list_get(&resp->www_authenticates,0);
1254         if (prx_auth!=NULL)
1255                 prx_realm=osip_proxy_authenticate_get_realm(prx_auth);
1256         if (www_auth!=NULL)
1257                 www_realm=osip_www_authenticate_get_realm(www_auth);
1258
1259         if (prx_realm){
1260                 *realm=prx_realm;
1261         }else if (www_realm){
1262                 *realm=www_realm;
1263         }else{
1264                 return -1;
1265         }
1266         return 0;
1267 }
1268
1269 static int get_auth_data_from_request(osip_message_t *msg, const char **realm, const char **username){
1270         osip_authorization_t *auth=NULL;
1271         osip_proxy_authorization_t *prx_auth=NULL;
1272
1273         *username=osip_uri_get_username(msg->from->url);
1274         osip_message_get_authorization(msg, 0, &auth);
1275         if (auth){
1276                 *realm=osip_authorization_get_realm(auth);
1277                 return 0;
1278         }
1279         osip_message_get_proxy_authorization(msg,0,&prx_auth);
1280         if (prx_auth){
1281                 *realm=osip_proxy_authorization_get_realm(prx_auth);
1282                 return 0;
1283         }
1284         return -1;
1285 }
1286
1287 static int get_auth_data(eXosip_event_t *ev, const char **realm, const char **username){
1288         if (ev->response && get_auth_data_from_response(ev->response,realm,username)==0) return 0;
1289         if (ev->request && get_auth_data_from_request(ev->request,realm,username)==0) return 0;
1290         return -1;
1291 }
1292
1293 int sal_op_get_auth_requested(SalOp *op, const char **realm, const char **username){
1294         if (op->pending_auth){
1295                 return get_auth_data(op->pending_auth,realm,username);
1296         }
1297         return -1;
1298 }
1299
1300 static bool_t process_authentication(Sal *sal, eXosip_event_t *ev){
1301         SalOp *op;
1302         const char *username,*realm;
1303         op=find_op(sal,ev);
1304         if (op==NULL){
1305                 ms_warning("No operation associated with this authentication !");
1306                 return TRUE;
1307         }
1308         if (get_auth_data(ev,&realm,&username)==0){
1309                 if (op->pending_auth!=NULL){
1310                         eXosip_event_free(op->pending_auth);
1311                         op->pending_auth=ev;
1312                 }else{
1313                         op->pending_auth=ev;
1314                         sal_add_pending_auth(sal,op);
1315                 }
1316
1317                 sal->callbacks.auth_requested(op,realm,username);
1318                 return FALSE;
1319         }
1320         return TRUE;
1321 }
1322
1323 static void authentication_ok(Sal *sal, eXosip_event_t *ev){
1324         SalOp *op;
1325         const char *username,*realm;
1326         op=find_op(sal,ev);
1327         if (op==NULL){
1328                 ms_warning("No operation associated with this authentication_ok!");
1329                 return ;
1330         }
1331         if (op->pending_auth){
1332                 eXosip_event_free(op->pending_auth);
1333                 sal_remove_pending_auth(sal,op);
1334                 op->pending_auth=NULL;
1335         }
1336         if (get_auth_data(ev,&realm,&username)==0){
1337                 sal->callbacks.auth_success(op,realm,username);
1338         }
1339 }
1340
1341 static bool_t call_failure(Sal *sal, eXosip_event_t *ev){
1342         SalOp *op;
1343         int code=0;
1344         char* computedReason=NULL;
1345         const char *reason=NULL;
1346         SalError error=SalErrorUnknown;
1347         SalReason sr=SalReasonUnknown;
1348
1349
1350         op=(SalOp*)find_op(sal,ev);
1351
1352         if (op==NULL) {
1353                 ms_warning("Call failure reported for a closed call, ignored.");
1354                 return TRUE;
1355         }
1356
1357         if (ev->response){
1358                 code=osip_message_get_status_code(ev->response);
1359                 reason=osip_message_get_reason_phrase(ev->response);
1360                 osip_header_t *h=NULL;
1361                 if (!osip_message_header_get_byname(    ev->response
1362                                                                                         ,"Reason"
1363                                                                                         ,0
1364                                                                                         ,&h)) {
1365                         computedReason = ms_strdup_printf("%s %s",reason,osip_header_get_value(h));
1366                         reason = computedReason;
1367
1368                 }
1369         }
1370         switch(code)
1371         {
1372                 case 401:
1373                 case 407:
1374                         return process_authentication(sal,ev);
1375                         break;
1376                 case 400:
1377                         error=SalErrorUnknown;
1378                 break;
1379                 case 404:
1380                         error=SalErrorFailure;
1381                         sr=SalReasonNotFound;
1382                 break;
1383                 case 415:
1384                         error=SalErrorFailure;
1385                         sr=SalReasonMedia;
1386                 break;
1387                 case 422:
1388                         eXosip_default_action(ev);
1389                         return TRUE;
1390                 break;
1391                 case 480:
1392                         error=SalErrorFailure;
1393                         sr=SalReasonTemporarilyUnavailable;
1394                 case 486:
1395                         error=SalErrorFailure;
1396                         sr=SalReasonBusy;
1397                 break;
1398                 case 487:
1399                 break;
1400                 case 600:
1401                         error=SalErrorFailure;
1402                         sr=SalReasonDoNotDisturb;
1403                 break;
1404                 case 603:
1405                         error=SalErrorFailure;
1406                         sr=SalReasonDeclined;
1407                 break;
1408                 default:
1409                         if (code>0){
1410                                 error=SalErrorFailure;
1411                                 sr=SalReasonUnknown;
1412                         }else error=SalErrorNoResponse;
1413         }
1414         op->terminated=TRUE;
1415         sal->callbacks.call_failure(op,error,sr,reason,code);
1416         if (computedReason != NULL){
1417                 ms_free(computedReason);
1418         }
1419         return TRUE;
1420 }
1421
1422 /* Request remote side to send us VFU */
1423 void sal_call_send_vfu_request(SalOp *h){
1424         osip_message_t *msg=NULL;
1425         char info_body[] =
1426                         "<?xml version=\"1.0\" encoding=\"utf-8\" ?>"
1427                          "<media_control>"
1428                          "  <vc_primitive>"
1429                          "    <to_encoder>"
1430                          "      <picture_fast_update></picture_fast_update>"
1431                          "    </to_encoder>"
1432                          "  </vc_primitive>"
1433                          "</media_control>";
1434
1435         char clen[10];
1436
1437         eXosip_lock();
1438         eXosip_call_build_info(h->did,&msg);
1439         if (msg){
1440                 osip_message_set_body(msg,info_body,strlen(info_body));
1441                 osip_message_set_content_type(msg,"application/media_control+xml");
1442                 snprintf(clen,sizeof(clen),"%lu",(unsigned long)strlen(info_body));
1443                 osip_message_set_content_length(msg,clen);
1444                 eXosip_call_send_request(h->did,msg);
1445                 ms_message("Sending VFU request !");
1446         }
1447         eXosip_unlock();
1448 }
1449
1450 static void process_media_control_xml(Sal *sal, eXosip_event_t *ev){
1451         SalOp *op=find_op(sal,ev);
1452         osip_body_t *body=NULL;
1453
1454         if (op==NULL){
1455                 ms_warning("media control xml received without operation context!");
1456                 return ;
1457         }
1458
1459         osip_message_get_body(ev->request,0,&body);
1460         if (body && body->body!=NULL &&
1461                 strstr(body->body,"picture_fast_update")){
1462                 osip_message_t *ans=NULL;
1463                 ms_message("Receiving VFU request !");
1464                 if (sal->callbacks.vfu_request){
1465                         sal->callbacks.vfu_request(op);
1466                         eXosip_call_build_answer(ev->tid,200,&ans);
1467                         if (ans)
1468                                 eXosip_call_send_answer(ev->tid,200,ans);
1469                         return;
1470                 }
1471         }
1472         /*in all other cases we must say it is not implemented.*/
1473         {
1474                 osip_message_t *ans=NULL;
1475                 eXosip_lock();
1476                 eXosip_call_build_answer(ev->tid,501,&ans);
1477                 if (ans)
1478                         eXosip_call_send_answer(ev->tid,501,ans);
1479                 eXosip_unlock();
1480         }
1481 }
1482
1483 static void process_dtmf_relay(Sal *sal, eXosip_event_t *ev){
1484         SalOp *op=find_op(sal,ev);
1485         osip_body_t *body=NULL;
1486
1487         if (op==NULL){
1488                 ms_warning("media dtmf relay received without operation context!");
1489                 return ;
1490         }
1491
1492         osip_message_get_body(ev->request,0,&body);
1493         if (body && body->body!=NULL){
1494                 osip_message_t *ans=NULL;
1495                 const char *name=strstr(body->body,"Signal");
1496                 if (name==NULL) name=strstr(body->body,"signal");
1497                 if (name==NULL) {
1498                         ms_warning("Could not extract the dtmf name from the SIP INFO.");
1499                 }else{
1500                         char tmp[2];
1501                         name+=strlen("signal");
1502                         if (sscanf(name," = %1s",tmp)==1){
1503                                 ms_message("Receiving dtmf %s via SIP INFO.",tmp);
1504                                 if (sal->callbacks.dtmf_received != NULL)
1505                                         sal->callbacks.dtmf_received(op, tmp[0]);
1506                         }
1507                 }
1508                 eXosip_lock();
1509                 eXosip_call_build_answer(ev->tid,200,&ans);
1510                 if (ans)
1511                         eXosip_call_send_answer(ev->tid,200,ans);
1512                 eXosip_unlock();
1513         }
1514 }
1515
1516 static void fill_options_answer(osip_message_t *options){
1517         osip_message_set_allow(options,"INVITE, ACK, BYE, CANCEL, OPTIONS, MESSAGE, SUBSCRIBE, NOTIFY, INFO");
1518         osip_message_set_accept(options,"application/sdp");
1519 }
1520
1521 static void process_refer(Sal *sal, SalOp *op, eXosip_event_t *ev){
1522         osip_header_t *h=NULL;
1523         osip_message_t *ans=NULL;
1524         ms_message("Receiving REFER request !");
1525         osip_message_header_get_byname(ev->request,"Refer-To",0,&h);
1526
1527         if (h){
1528                 osip_from_t *from=NULL;
1529                 char *tmp;
1530                 osip_from_init(&from);
1531
1532                 if (osip_from_parse(from,h->hvalue)==0){
1533                         if (op ){
1534                                 osip_uri_header_t *uh=NULL;
1535                                 osip_header_t *referred_by=NULL;
1536                                 osip_uri_header_get_byname(&from->url->url_headers,(char*)"Replaces",&uh);
1537                                 if (uh!=NULL && uh->gvalue && uh->gvalue[0]!='\0'){
1538                                         ms_message("Found replaces in Refer-To");
1539                                         if (op->replaces){
1540                                                 ms_free(op->replaces);
1541                                         }
1542                                         op->replaces=ms_strdup(uh->gvalue);
1543                                 }
1544                                 osip_message_header_get_byname(ev->request,"Referred-By",0,&referred_by);
1545                                 if (referred_by && referred_by->hvalue && referred_by->hvalue[0]!='\0'){
1546                                         if (op->referred_by)
1547                                                 ms_free(op->referred_by);
1548                                         op->referred_by=ms_strdup(referred_by->hvalue);
1549                                 }
1550                         }
1551                         osip_uri_header_freelist(&from->url->url_headers);
1552                         osip_from_to_str(from,&tmp);
1553                         sal->callbacks.refer_received(sal,op,tmp);
1554                         osip_free(tmp);
1555                         osip_from_free(from);
1556                 }
1557                 eXosip_lock();
1558                 eXosip_call_build_answer(ev->tid,202,&ans);
1559                 if (ans)
1560                         eXosip_call_send_answer(ev->tid,202,ans);
1561                 eXosip_unlock();
1562         }
1563         else
1564         {
1565                 ms_warning("cannot do anything with the refer without destination\n");
1566         }
1567 }
1568
1569 static void process_notify(Sal *sal, eXosip_event_t *ev){
1570         osip_header_t *h=NULL;
1571         char *from=NULL;
1572         SalOp *op=find_op(sal,ev);
1573         osip_message_t *ans=NULL;
1574
1575         ms_message("Receiving NOTIFY request !");
1576         osip_from_to_str(ev->request->from,&from);
1577         osip_message_header_get_byname(ev->request,"Event",0,&h);
1578         if(h){
1579                 osip_body_t *body=NULL;
1580                 //osip_content_type_t *ct=NULL;
1581                 osip_message_get_body(ev->request,0,&body);
1582                 //ct=osip_message_get_content_type(ev->request);
1583                 if (h->hvalue && strcasecmp(h->hvalue,"refer")==0){
1584                         /*special handling of refer events*/
1585                         if (body && body->body){
1586                                 osip_message_t *msg;
1587                                 osip_message_init(&msg);
1588                                 if (osip_message_parse_sipfrag(msg,body->body,strlen(body->body))==0){
1589                                         int code=osip_message_get_status_code(msg);
1590                                         if (code==100){
1591                                                 sal->callbacks.notify_refer(op,SalReferTrying);
1592                                         }else if (code==200){
1593                                                 sal->callbacks.notify_refer(op,SalReferSuccess);
1594                                         }else if (code>=400){
1595                                                 sal->callbacks.notify_refer(op,SalReferFailed);
1596                                         }
1597                                 }
1598                                 osip_message_free(msg);
1599                         }
1600                 }else{
1601                         /*generic handling*/
1602                         sal->callbacks.notify(op,from,h->hvalue);
1603                 }
1604         }
1605         /*answer that we received the notify*/
1606         eXosip_lock();
1607         eXosip_call_build_answer(ev->tid,200,&ans);
1608         if (ans)
1609                 eXosip_call_send_answer(ev->tid,200,ans);
1610         eXosip_unlock();
1611         osip_free(from);
1612 }
1613
1614 static void call_message_new(Sal *sal, eXosip_event_t *ev){
1615         osip_message_t *ans=NULL;
1616         if (ev->request){
1617                 if (MSG_IS_INFO(ev->request)){
1618                         osip_content_type_t *ct;
1619                         ct=osip_message_get_content_type(ev->request);
1620                         if (ct && ct->subtype){
1621                                 if (strcmp(ct->subtype,"media_control+xml")==0)
1622                                         process_media_control_xml(sal,ev);
1623                                 else if (strcmp(ct->subtype,"dtmf-relay")==0)
1624                                         process_dtmf_relay(sal,ev);
1625                                 else {
1626                                         ms_message("Unhandled SIP INFO.");
1627                                         /*send an "Not implemented" answer*/
1628                                         eXosip_lock();
1629                                         eXosip_call_build_answer(ev->tid,501,&ans);
1630                                         if (ans)
1631                                                 eXosip_call_send_answer(ev->tid,501,ans);
1632                                         eXosip_unlock();
1633                                 }
1634                         }else{
1635                                 /*empty SIP INFO, probably to test we are alive. Send an empty answer*/
1636                                 eXosip_lock();
1637                                 eXosip_call_build_answer(ev->tid,200,&ans);
1638                                 if (ans)
1639                                         eXosip_call_send_answer(ev->tid,200,ans);
1640                                 eXosip_unlock();
1641                         }
1642                 }else if(MSG_IS_MESSAGE(ev->request)){
1643                         /* SIP messages could be received into call */
1644                         text_received(sal, ev);
1645                         eXosip_lock();
1646                         eXosip_call_build_answer(ev->tid,200,&ans);
1647                         if (ans)
1648                                 eXosip_call_send_answer(ev->tid,200,ans);
1649                         eXosip_unlock();
1650                 }else if(MSG_IS_REFER(ev->request)){
1651                         SalOp *op=find_op(sal,ev);
1652
1653                         ms_message("Receiving REFER request !");
1654                         process_refer(sal,op,ev);
1655                 }else if(MSG_IS_NOTIFY(ev->request)){
1656                         process_notify(sal,ev);
1657                 }else if (MSG_IS_OPTIONS(ev->request)){
1658                         eXosip_lock();
1659                         eXosip_call_build_answer(ev->tid,200,&ans);
1660                         if (ans){
1661                                 fill_options_answer(ans);
1662                                 eXosip_call_send_answer(ev->tid,200,ans);
1663                         }
1664                         eXosip_unlock();
1665                 }
1666         }else ms_warning("call_message_new: No request ?");
1667 }
1668
1669 static void inc_update(Sal *sal, eXosip_event_t *ev){
1670         osip_message_t *msg=NULL;
1671         ms_message("Processing incoming UPDATE");
1672         eXosip_lock();
1673         eXosip_message_build_answer(ev->tid,200,&msg);
1674         if (msg!=NULL)
1675                 eXosip_message_send_answer(ev->tid,200,msg);
1676         eXosip_unlock();
1677 }
1678
1679 static bool_t comes_from_local_if(osip_message_t *msg){
1680         osip_via_t *via=NULL;
1681         osip_message_get_via(msg,0,&via);
1682         if (via){
1683                 const char *host;
1684                 host=osip_via_get_host(via);
1685                 if (strcmp(host,"127.0.0.1")==0 || strcmp(host,"::1")==0){
1686                         osip_generic_param_t *param=NULL;
1687                         osip_via_param_get_byname(via,"received",&param);
1688                         if (param==NULL) return TRUE;
1689                         if (param->gvalue &&
1690                                 (strcmp(param->gvalue,"127.0.0.1")==0 || strcmp(param->gvalue,"::1")==0)){
1691                                 return TRUE;
1692                         }
1693                 }
1694         }
1695         return FALSE;
1696 }
1697
1698 static void text_received(Sal *sal, eXosip_event_t *ev){
1699         osip_body_t *body=NULL;
1700         char *from=NULL,*msg;
1701
1702         osip_message_get_body(ev->request,0,&body);
1703         if (body==NULL){
1704                 ms_error("Could not get text message from SIP body");
1705                 return;
1706         }
1707         msg=body->body;
1708         osip_from_to_str(ev->request->from,&from);
1709         sal->callbacks.text_received(sal,from,msg);
1710         osip_free(from);
1711 }
1712
1713
1714
1715 static void other_request(Sal *sal, eXosip_event_t *ev){
1716         ms_message("in other_request");
1717         if (ev->request==NULL) return;
1718         if (strcmp(ev->request->sip_method,"MESSAGE")==0){
1719                 text_received(sal,ev);
1720                 eXosip_message_send_answer(ev->tid,200,NULL);
1721         }else if (strcmp(ev->request->sip_method,"OPTIONS")==0){
1722                 osip_message_t *options=NULL;
1723                 eXosip_options_build_answer(ev->tid,200,&options);
1724                 fill_options_answer(options);
1725                 eXosip_options_send_answer(ev->tid,200,options);
1726         }else if (strncmp(ev->request->sip_method, "REFER", 5) == 0){
1727                 ms_message("Receiving REFER request !");
1728                 if (comes_from_local_if(ev->request)) {
1729                         process_refer(sal,NULL,ev);
1730                 }else ms_warning("Ignored REFER not coming from this local loopback interface.");
1731         }else if (strncmp(ev->request->sip_method, "UPDATE", 6) == 0){
1732                 inc_update(sal,ev);
1733     }else {
1734                 char *tmp=NULL;
1735                 size_t msglen=0;
1736                 osip_message_to_str(ev->request,&tmp,&msglen);
1737                 if (tmp){
1738                         ms_message("Unsupported request received:\n%s",tmp);
1739                         osip_free(tmp);
1740                 }
1741                 /*answer with a 501 Not implemented*/
1742                 eXosip_message_send_answer(ev->tid,501,NULL);
1743         }
1744 }
1745
1746 static void masquerade_via(osip_message_t *msg, const char *ip, const char *port){
1747         osip_via_t *via=NULL;
1748         osip_message_get_via(msg,0,&via);
1749         if (via){
1750                 osip_free(via->port);
1751                 via->port=osip_strdup(port);
1752                 osip_free(via->host);
1753                 via->host=osip_strdup(ip);
1754         }
1755 }
1756
1757
1758 static bool_t fix_message_contact(SalOp *op, osip_message_t *request,osip_message_t *last_answer, bool_t expire_last_contact) {
1759         osip_contact_t *ctt=NULL;
1760         const char *received;
1761         int rport;
1762         SalTransport transport;
1763         char port[20];
1764
1765         if (extract_received_rport(last_answer,&received,&rport,&transport)==-1) return FALSE;
1766         osip_message_get_contact(request,0,&ctt);
1767         if (ctt == NULL) {
1768                 ms_warning("fix_message_contact(): no contact to update");
1769                 return FALSE;
1770         }
1771         if (expire_last_contact){
1772                 osip_contact_t *oldct=NULL,*prevct;
1773                 osip_generic_param_t *param=NULL;
1774                 osip_contact_clone(ctt,&oldct);
1775                 while ((prevct=(osip_contact_t*)osip_list_get(&request->contacts,1))!=NULL){
1776                         osip_contact_free(prevct);
1777                         osip_list_remove(&request->contacts,1);
1778                 }
1779                 osip_list_add(&request->contacts,oldct,1);
1780                 osip_contact_param_get_byname(oldct,"expires",&param);
1781                 if (param){
1782                         if (param->gvalue) osip_free(param->gvalue);
1783                         param->gvalue=osip_strdup("0");
1784                 }else{
1785                         osip_contact_param_add(oldct,osip_strdup("expires"),osip_strdup("0"));
1786                 }
1787         }
1788         if (ctt->url->host!=NULL){
1789                 osip_free(ctt->url->host);
1790         }
1791         ctt->url->host=osip_strdup(received);
1792         if (ctt->url->port!=NULL){
1793                 osip_free(ctt->url->port);
1794         }
1795         snprintf(port,sizeof(port),"%i",rport);
1796         ctt->url->port=osip_strdup(port);
1797         if (op->masquerade_via) masquerade_via(request,received,port);
1798
1799         if (transport != SalTransportUDP) {
1800                 sal_address_set_param((SalAddress *)ctt, "transport", sal_transport_to_string(transport));
1801         }
1802         return TRUE;
1803 }
1804
1805 static bool_t register_again_with_updated_contact(SalOp *op, osip_message_t *orig_request, osip_message_t *last_answer){
1806         osip_contact_t *ctt=NULL;
1807         SalAddress* ori_contact_address=NULL;
1808         const char *received;
1809         int rport;
1810         SalTransport transport;
1811         char* tmp;
1812         osip_message_t *msg=NULL;
1813         Sal* sal=op->base.root;
1814         int i=0;
1815         bool_t found_valid_contact=FALSE;
1816         bool_t from_request=FALSE;
1817
1818         if (sal->double_reg==FALSE ) return FALSE;
1819
1820         if (extract_received_rport(last_answer,&received,&rport,&transport)==-1) return FALSE;
1821         do{
1822                 ctt=NULL;
1823                 osip_message_get_contact(last_answer,i,&ctt);
1824                 if (!from_request && ctt==NULL) {
1825                         osip_message_get_contact(orig_request,0,&ctt);
1826                         from_request=TRUE;
1827                 }
1828                 if (ctt){
1829                         osip_contact_to_str(ctt,&tmp);
1830                         ori_contact_address = sal_address_new(tmp);
1831
1832                         /*check if contact is up to date*/
1833                         if (strcmp(sal_address_get_domain(ori_contact_address),received) ==0
1834                                 && sal_address_get_port_int(ori_contact_address) == rport
1835                         && sal_address_get_transport(ori_contact_address) == transport) {
1836                                 if (!from_request){
1837                                         ms_message("Register response has up to date contact, doing nothing.");
1838                                 }else {
1839                                         ms_warning("Register response does not have up to date contact, but last request had."
1840                                                 "Stupid registrar detected, giving up.");
1841                                 }
1842                                 found_valid_contact=TRUE;
1843                         }
1844                         osip_free(tmp);
1845                         sal_address_destroy(ori_contact_address);
1846                 }else break;
1847                 i++;
1848         }while(!found_valid_contact);
1849         if (!found_valid_contact)
1850                 ms_message("Contact do not match, resending register.");
1851         else return FALSE;
1852
1853         eXosip_lock();
1854         eXosip_register_build_register(op->rid,op->expires,&msg);
1855         if (msg==NULL){
1856             eXosip_unlock();
1857             ms_warning("Fail to create a contact updated register.");
1858             return FALSE;
1859         }
1860         if (fix_message_contact(op,msg,last_answer,op->base.root->expire_old_contact)) {
1861                 eXosip_register_send_register(op->rid,msg);
1862                 eXosip_unlock();
1863                 ms_message("Resending new register with updated contact");
1864                 update_contact_from_response(op,last_answer);
1865                 return TRUE;
1866         } else {
1867             ms_warning("Fail to send updated register.");
1868             eXosip_unlock();
1869             return FALSE;
1870         }
1871         eXosip_unlock();
1872         return FALSE;
1873 }
1874
1875 static void registration_success(Sal *sal, eXosip_event_t *ev){
1876         SalOp *op=sal_find_register(sal,ev->rid);
1877         osip_header_t *h=NULL;
1878         bool_t registered;
1879         if (op==NULL){
1880                 ms_error("Receiving register response for unknown operation");
1881                 return;
1882         }
1883         osip_message_get_expires(ev->request,0,&h);
1884         if (h!=NULL && atoi(h->hvalue)!=0){
1885                 registered=TRUE;
1886                 if (!register_again_with_updated_contact(op,ev->request,ev->response)){
1887                         sal->callbacks.register_success(op,registered);
1888                 }
1889         }else {
1890                 sal->callbacks.register_success(op,FALSE);
1891         }
1892 }
1893
1894 static bool_t registration_failure(Sal *sal, eXosip_event_t *ev){
1895         int status_code=0;
1896         const char *reason=NULL;
1897         SalOp *op=sal_find_register(sal,ev->rid);
1898         SalReason sr=SalReasonUnknown;
1899         SalError se=SalErrorUnknown;
1900
1901         if (op==NULL){
1902                 ms_error("Receiving register failure for unknown operation");
1903                 return TRUE;
1904         }
1905         if (ev->response){
1906                 status_code=osip_message_get_status_code(ev->response);
1907                 reason=osip_message_get_reason_phrase(ev->response);
1908         }
1909         switch(status_code){
1910                 case 401:
1911                 case 407:
1912                         return process_authentication(sal,ev);
1913                         break;
1914                 case 423: /*interval too brief*/
1915                         {/*retry with greater interval */
1916                                 osip_header_t *h=NULL;
1917                                 osip_message_t *msg=NULL;
1918                                 osip_message_header_get_byname(ev->response,"min-expires",0,&h);
1919                                 if (h && h->hvalue && h->hvalue[0]!='\0'){
1920                                         int val=atoi(h->hvalue);
1921                                         if (val>op->expires)
1922                                                 op->expires=val;
1923                                 }else op->expires*=2;
1924                                 eXosip_lock();
1925                                 eXosip_register_build_register(op->rid,op->expires,&msg);
1926                                 eXosip_register_send_register(op->rid,msg);
1927                                 eXosip_unlock();
1928                         }
1929                 break;
1930                 case 606: /*Not acceptable, workaround for proxies that don't like private addresses
1931                                  in vias, such as ekiga.net
1932                                  On the opposite, freephonie.net bugs when via are masqueraded.
1933                                  */
1934                         op->masquerade_via=TRUE;
1935                 default:
1936                         /* if contact is up to date, process the failure, otherwise resend a new register with
1937                                 updated contact first, just in case the faillure is due to incorrect contact */
1938                         if (ev->response && register_again_with_updated_contact(op,ev->request,ev->response))
1939                                 return TRUE; /*we are retrying with an updated contact*/
1940                         if (status_code==403){
1941                                 se=SalErrorFailure;
1942                                 sr=SalReasonForbidden;
1943                         }else if (status_code==0){
1944                                 se=SalErrorNoResponse;
1945                         }
1946                         sal->callbacks.register_failure(op,se,sr,reason);
1947         }
1948         return TRUE;
1949 }
1950
1951 static void other_request_reply(Sal *sal,eXosip_event_t *ev){
1952         SalOp *op=find_op(sal,ev);
1953
1954         if (op==NULL){
1955                 ms_warning("other_request_reply(): Receiving response to unknown request.");
1956                 return;
1957         }
1958         if (ev->response){
1959                 update_contact_from_response(op,ev->response);
1960                 if (ev->request && strcmp(osip_message_get_method(ev->request),"OPTIONS")==0)
1961                         sal->callbacks.ping_reply(op);
1962         }
1963 }
1964
1965 static void process_in_call_reply(Sal *sal, eXosip_event_t *ev){
1966         SalOp *op=find_op(sal,ev);
1967         if (ev->response){
1968                 if (ev->request && strcmp(osip_message_get_method(ev->request),"NOTIFY")==0){
1969                         if (op->sipfrag_pending){
1970                                 send_notify_for_refer(op->did,op->sipfrag_pending);
1971                                 op->sipfrag_pending=NULL;
1972                         }
1973                 }
1974         }
1975 }
1976
1977 static bool_t process_event(Sal *sal, eXosip_event_t *ev){
1978         ms_message("linphone process event get a message %d\n",ev->type);
1979         switch(ev->type){
1980                 case EXOSIP_CALL_ANSWERED:
1981                         ms_message("CALL_ANSWERED\n");
1982                         call_accepted(sal,ev);
1983                         authentication_ok(sal,ev);
1984                         break;
1985                 case EXOSIP_CALL_CLOSED:
1986                 case EXOSIP_CALL_CANCELLED:
1987                         ms_message("CALL_CLOSED or CANCELLED\n");
1988                         call_terminated(sal,ev);
1989                         break;
1990                 case EXOSIP_CALL_TIMEOUT:
1991                 case EXOSIP_CALL_NOANSWER:
1992                         ms_message("CALL_TIMEOUT or NOANSWER\n");
1993                         return call_failure(sal,ev);
1994                         break;
1995                 case EXOSIP_CALL_REQUESTFAILURE:
1996                 case EXOSIP_CALL_GLOBALFAILURE:
1997                 case EXOSIP_CALL_SERVERFAILURE:
1998                         ms_message("CALL_REQUESTFAILURE or GLOBALFAILURE or SERVERFAILURE\n");
1999                         return call_failure(sal,ev);
2000                         break;
2001                 case EXOSIP_CALL_RELEASED:
2002                         ms_message("CALL_RELEASED\n");
2003                         call_released(sal, ev);
2004                         break;
2005                 case EXOSIP_CALL_INVITE:
2006                         ms_message("CALL_NEW\n");
2007                         inc_new_call(sal,ev);
2008                         break;
2009                 case EXOSIP_CALL_REINVITE:
2010                         handle_reinvite(sal,ev);
2011                         break;
2012                 case EXOSIP_CALL_ACK:
2013                         ms_message("CALL_ACK");
2014                         handle_ack(sal,ev);
2015                         break;
2016                 case EXOSIP_CALL_REDIRECTED:
2017                         ms_message("CALL_REDIRECTED");
2018                         eXosip_default_action(ev);
2019                         break;
2020                 case EXOSIP_CALL_PROCEEDING:
2021                         ms_message("CALL_PROCEEDING");
2022                         call_proceeding(sal,ev);
2023                         break;
2024                 case EXOSIP_CALL_RINGING:
2025                         ms_message("CALL_RINGING");
2026                         call_ringing(sal,ev);
2027                         authentication_ok(sal,ev);
2028                         break;
2029                 case EXOSIP_CALL_MESSAGE_NEW:
2030                         ms_message("EXOSIP_CALL_MESSAGE_NEW");
2031                         call_message_new(sal,ev);
2032                         break;
2033                 case EXOSIP_CALL_MESSAGE_REQUESTFAILURE:
2034                         if (ev->response &&
2035                                 (ev->response->status_code==407 || ev->response->status_code==401)){
2036                                  return process_authentication(sal,ev);
2037                         }
2038                         break;
2039                 case EXOSIP_CALL_MESSAGE_ANSWERED:
2040                         ms_message("EXOSIP_CALL_MESSAGE_ANSWERED ");
2041                         process_in_call_reply(sal,ev);
2042                 break;
2043                 case EXOSIP_IN_SUBSCRIPTION_NEW:
2044                         ms_message("CALL_IN_SUBSCRIPTION_NEW ");
2045                         sal_exosip_subscription_recv(sal,ev);
2046                         break;
2047                 case EXOSIP_IN_SUBSCRIPTION_RELEASED:
2048                         ms_message("CALL_SUBSCRIPTION_NEW ");
2049                         sal_exosip_in_subscription_closed(sal,ev);
2050                         break;
2051                 case EXOSIP_SUBSCRIPTION_UPDATE:
2052                         ms_message("CALL_SUBSCRIPTION_UPDATE");
2053                         break;
2054                 case EXOSIP_SUBSCRIPTION_NOTIFY:
2055                         ms_message("CALL_SUBSCRIPTION_NOTIFY");
2056                         sal_exosip_notify_recv(sal,ev);
2057                         break;
2058                 case EXOSIP_SUBSCRIPTION_ANSWERED:
2059                         ms_message("EXOSIP_SUBSCRIPTION_ANSWERED, ev->sid=%i, ev->did=%i\n",ev->sid,ev->did);
2060                         sal_exosip_subscription_answered(sal,ev);
2061                         break;
2062                 case EXOSIP_SUBSCRIPTION_CLOSED:
2063                         ms_message("EXOSIP_SUBSCRIPTION_CLOSED\n");
2064                         sal_exosip_subscription_closed(sal,ev);
2065                         break;
2066                 case EXOSIP_SUBSCRIPTION_REQUESTFAILURE:   /**< announce a request failure      */
2067                         if (ev->response && (ev->response->status_code == 407 || ev->response->status_code == 401)){
2068                                 return process_authentication(sal,ev);
2069                         }
2070         case EXOSIP_SUBSCRIPTION_SERVERFAILURE:
2071                 case EXOSIP_SUBSCRIPTION_GLOBALFAILURE:
2072                         sal_exosip_subscription_closed(sal,ev);
2073                         break;
2074                 case EXOSIP_REGISTRATION_FAILURE:
2075                         ms_message("REGISTRATION_FAILURE\n");
2076                         return registration_failure(sal,ev);
2077                         break;
2078                 case EXOSIP_REGISTRATION_SUCCESS:
2079                         authentication_ok(sal,ev);
2080                         registration_success(sal,ev);
2081                         break;
2082                 case EXOSIP_MESSAGE_NEW:
2083                         other_request(sal,ev);
2084                         break;
2085                 case EXOSIP_MESSAGE_PROCEEDING:
2086                 case EXOSIP_MESSAGE_ANSWERED:
2087                 case EXOSIP_MESSAGE_REDIRECTED:
2088                 case EXOSIP_MESSAGE_SERVERFAILURE:
2089                 case EXOSIP_MESSAGE_GLOBALFAILURE:
2090                         other_request_reply(sal,ev);
2091                         break;
2092                 case EXOSIP_MESSAGE_REQUESTFAILURE:
2093                 case EXOSIP_NOTIFICATION_REQUESTFAILURE:
2094                         if (ev->response) {
2095                                 switch (ev->response->status_code) {
2096                                         case 407:
2097                                         case 401:
2098                                                 return process_authentication(sal,ev);
2099                                         case 412: {
2100                                                 eXosip_automatic_action ();
2101                                                 return 1;
2102                                         }
2103                                 }
2104                         }
2105                         other_request_reply(sal,ev);
2106                         break;
2107                 default:
2108                         ms_message("Unhandled exosip event ! %i",ev->type);
2109                         break;
2110         }
2111         return TRUE;
2112 }
2113
2114 int sal_iterate(Sal *sal){
2115         eXosip_event_t *ev;
2116         while((ev=eXosip_event_wait(0,0))!=NULL){
2117                 if (process_event(sal,ev))
2118                         eXosip_event_free(ev);
2119         }
2120 #ifdef HAVE_EXOSIP_TRYLOCK
2121         if (eXosip_trylock()==0){
2122                 eXosip_automatic_refresh();
2123                 eXosip_unlock();
2124         }else{
2125                 ms_warning("eXosip_trylock busy.");
2126         }
2127 #else
2128         eXosip_lock();
2129         eXosip_automatic_refresh();
2130         eXosip_unlock();
2131 #endif
2132         return 0;
2133 }
2134
2135 static void register_set_contact(osip_message_t *msg, const char *contact){
2136         osip_uri_param_t *param = NULL;
2137         osip_contact_t *ct=NULL;
2138         char *line=NULL;
2139         /*we get the line parameter choosed by exosip, and add it to our own contact*/
2140         osip_message_get_contact(msg,0,&ct);
2141         if (ct!=NULL){
2142                 osip_uri_uparam_get_byname(ct->url, "line", &param);
2143                 if (param && param->gvalue)
2144                         line=osip_strdup(param->gvalue);
2145         }
2146         _osip_list_set_empty(&msg->contacts,(void (*)(void*))osip_contact_free);
2147         osip_message_set_contact(msg,contact);
2148         osip_message_get_contact(msg,0,&ct);
2149         osip_uri_uparam_add(ct->url,osip_strdup("line"),line);
2150 }
2151
2152 static void sal_register_add_route(osip_message_t *msg, const char *proxy){
2153         char tmp[256]={0};
2154         snprintf(tmp,sizeof(tmp)-1,"<%s;lr>",proxy);
2155
2156         osip_list_special_free(&msg->routes,(void (*)(void*))osip_route_free);
2157         osip_message_set_route(msg,tmp);
2158 }
2159
2160 int sal_register(SalOp *h, const char *proxy, const char *from, int expires){
2161         osip_message_t *msg;
2162         const char *contact=sal_op_get_contact(h);
2163
2164         sal_op_set_route(h,proxy);
2165         if (h->rid==-1){
2166                 SalAddress *from_parsed=sal_address_new(from);
2167                 char domain[256];
2168                 if (from_parsed==NULL) {
2169                         ms_warning("sal_register() bad from %s",from);
2170                         return -1;
2171                 }
2172                 snprintf(domain,sizeof(domain),"sip:%s",sal_address_get_domain(from_parsed));
2173                 sal_address_destroy(from_parsed);
2174                 eXosip_lock();
2175                 h->rid=eXosip_register_build_initial_register(from,domain,NULL,expires,&msg);
2176                 if (msg){
2177                         if (contact) register_set_contact(msg,contact);
2178                         sal_register_add_route(msg,proxy);
2179                         sal_add_register(h->base.root,h);
2180                 }else{
2181                         ms_error("Could not build initial register.");
2182                         eXosip_unlock();
2183                         return -1;
2184                 }
2185         }else{
2186                 eXosip_lock();
2187                 eXosip_register_build_register(h->rid,expires,&msg);
2188                 sal_register_add_route(msg,proxy);
2189         }
2190         if (msg)
2191                 eXosip_register_send_register(h->rid,msg);
2192         eXosip_unlock();
2193         h->expires=expires;
2194         return (msg != NULL) ? 0 : -1;
2195 }
2196
2197 int sal_register_refresh(SalOp *op, int expires){
2198         osip_message_t *msg=NULL;
2199         const char *contact=sal_op_get_contact(op);
2200
2201         if (op->rid==-1){
2202                 ms_error("Unexistant registration context, not possible to refresh.");
2203                 return -1;
2204         }
2205         eXosip_lock();
2206         eXosip_register_build_register(op->rid,expires,&msg);
2207         if (msg!=NULL){
2208                 if (contact) register_set_contact(msg,contact);
2209                 sal_register_add_route(msg,sal_op_get_route(op));
2210                 eXosip_register_send_register(op->rid,msg);
2211         }else ms_error("Could not build REGISTER refresh message.");
2212         eXosip_unlock();
2213         return (msg != NULL) ? 0 : -1;
2214 }
2215
2216
2217 int sal_unregister(SalOp *h){
2218         osip_message_t *msg=NULL;
2219         eXosip_lock();
2220         eXosip_register_build_register(h->rid,0,&msg);
2221         if (msg) eXosip_register_send_register(h->rid,msg);
2222         else ms_warning("Could not build unREGISTER !");
2223         eXosip_unlock();
2224         return 0;
2225 }
2226
2227 SalAddress * sal_address_new(const char *uri){
2228         osip_from_t *from;
2229         osip_from_init(&from);
2230
2231         // Remove front spaces
2232         while (uri[0]==' ') {
2233                 uri++;
2234         }
2235
2236         if (osip_from_parse(from,uri)!=0){
2237                 osip_from_free(from);
2238                 return NULL;
2239         }
2240         if (from->displayname!=NULL && from->displayname[0]=='"'){
2241                 char *unquoted=osip_strdup_without_quote(from->displayname);
2242                 osip_free(from->displayname);
2243                 from->displayname=unquoted;
2244         }
2245         return (SalAddress*)from;
2246 }
2247
2248 SalAddress * sal_address_clone(const SalAddress *addr){
2249         osip_from_t *ret=NULL;
2250         osip_from_clone((osip_from_t*)addr,&ret);
2251         return (SalAddress*)ret;
2252 }
2253
2254 #define null_if_empty(s) (((s)!=NULL && (s)[0]!='\0') ? (s) : NULL )
2255
2256 const char *sal_address_get_scheme(const SalAddress *addr){
2257         const osip_from_t *u=(const osip_from_t*)addr;
2258         return null_if_empty(u->url->scheme);
2259 }
2260
2261 const char *sal_address_get_display_name(const SalAddress* addr){
2262         const osip_from_t *u=(const osip_from_t*)addr;
2263         return null_if_empty(u->displayname);
2264 }
2265
2266 const char *sal_address_get_username(const SalAddress *addr){
2267         const osip_from_t *u=(const osip_from_t*)addr;
2268         return null_if_empty(u->url->username);
2269 }
2270
2271 const char *sal_address_get_domain(const SalAddress *addr){
2272         const osip_from_t *u=(const osip_from_t*)addr;
2273         return null_if_empty(u->url->host);
2274 }
2275
2276 void sal_address_set_display_name(SalAddress *addr, const char *display_name){
2277         osip_from_t *u=(osip_from_t*)addr;
2278         if (u->displayname!=NULL){
2279                 osip_free(u->displayname);
2280                 u->displayname=NULL;
2281         }
2282         if (display_name!=NULL && display_name[0]!='\0'){
2283                 u->displayname=osip_strdup(display_name);
2284         }
2285 }
2286
2287 void sal_address_set_username(SalAddress *addr, const char *username){
2288         osip_from_t *uri=(osip_from_t*)addr;
2289         if (uri->url->username!=NULL){
2290                 osip_free(uri->url->username);
2291                 uri->url->username=NULL;
2292         }
2293         if (username)
2294                 uri->url->username=osip_strdup(username);
2295 }
2296
2297 void sal_address_set_domain(SalAddress *addr, const char *host){
2298         osip_from_t *uri=(osip_from_t*)addr;
2299         if (uri->url->host!=NULL){
2300                 osip_free(uri->url->host);
2301                 uri->url->host=NULL;
2302         }
2303         if (host)
2304                 uri->url->host=osip_strdup(host);
2305 }
2306
2307 void sal_address_set_port(SalAddress *addr, const char *port){
2308         osip_from_t *uri=(osip_from_t*)addr;
2309         if (uri->url->port!=NULL){
2310                 osip_free(uri->url->port);
2311                 uri->url->port=NULL;
2312         }
2313         if (port)
2314                 uri->url->port=osip_strdup(port);
2315 }
2316
2317 void sal_address_set_port_int(SalAddress *uri, int port){
2318         char tmp[12];
2319         if (port==5060){
2320                 /*this is the default, special case to leave the port field blank*/
2321                 sal_address_set_port(uri,NULL);
2322                 return;
2323         }
2324         snprintf(tmp,sizeof(tmp),"%i",port);
2325         sal_address_set_port(uri,tmp);
2326 }
2327
2328 void sal_address_clean(SalAddress *addr){
2329         osip_generic_param_freelist(& ((osip_from_t*)addr)->gen_params);
2330         osip_uri_param_freelist(& ((osip_from_t*)addr)->url->url_params);
2331 }
2332
2333 char *sal_address_as_string(const SalAddress *u){
2334         char *tmp,*ret;
2335         osip_from_t *from=(osip_from_t *)u;
2336         char *old_displayname=NULL;
2337         /* hack to force use of quotes around the displayname*/
2338         if (from->displayname!=NULL
2339             && from->displayname[0]!='"'){
2340                 old_displayname=from->displayname;
2341                 from->displayname=osip_enquote(from->displayname);
2342         }
2343         osip_from_to_str(from,&tmp);
2344         if (old_displayname!=NULL){
2345                 ms_free(from->displayname);
2346                 from->displayname=old_displayname;
2347         }
2348         ret=ms_strdup(tmp);
2349         osip_free(tmp);
2350         return ret;
2351 }
2352
2353 char *sal_address_as_string_uri_only(const SalAddress *u){
2354         char *tmp=NULL,*ret;
2355         osip_uri_to_str(((osip_from_t*)u)->url,&tmp);
2356         ret=ms_strdup(tmp);
2357         osip_free(tmp);
2358         return ret;
2359 }
2360 void sal_address_set_param(SalAddress *u,const char* name,const char* value) {
2361         osip_uri_param_t *param=NULL;
2362     osip_uri_uparam_get_byname(((osip_from_t*)u)->url,(char*)name,&param);
2363     if (param == NULL){
2364         osip_uri_uparam_add     (((osip_from_t*)u)->url,ms_strdup(name),value ? ms_strdup(value) : NULL);
2365     } else {
2366         osip_free(param->gvalue);
2367         param->gvalue=value ? osip_strdup(value) : NULL;
2368     }
2369
2370 }
2371
2372 void sal_address_destroy(SalAddress *u){
2373         osip_from_free((osip_from_t*)u);
2374 }
2375
2376 void sal_set_keepalive_period(Sal *ctx,unsigned int value) {
2377         ctx->keepalive_period=value;
2378         eXosip_set_option (EXOSIP_OPT_UDP_KEEP_ALIVE, &value);
2379 }
2380 unsigned int sal_get_keepalive_period(Sal *ctx) {
2381         return ctx->keepalive_period;
2382 }
2383
2384 const char * sal_address_get_port(const SalAddress *addr) {
2385         const osip_from_t *u=(const osip_from_t*)addr;
2386         return null_if_empty(u->url->port);
2387 }
2388
2389 int sal_address_get_port_int(const SalAddress *uri) {
2390         const char* port = sal_address_get_port(uri);
2391         if (port != NULL) {
2392                 return atoi(port);
2393         } else {
2394                 return 5060;
2395         }
2396 }
2397 SalTransport sal_address_get_transport(const SalAddress* addr) {
2398     const osip_from_t *u=(const osip_from_t*)addr;
2399     osip_uri_param_t *transport_param=NULL;
2400     osip_uri_uparam_get_byname(u->url,"transport",&transport_param);
2401     if (transport_param == NULL){
2402         return SalTransportUDP;
2403     }  else {
2404         return sal_transport_parse(transport_param->gvalue);
2405     }
2406 }
2407 void sal_address_set_transport(SalAddress* addr,SalTransport transport) {
2408     sal_address_set_param(addr, "transport", sal_transport_to_string(transport));
2409 }
2410
2411 /* sends a reinvite. Local media description may have changed by application since call establishment*/
2412 int sal_call_update(SalOp *h, const char *subject){
2413         int err=0;
2414         osip_message_t *reinvite=NULL;
2415
2416         eXosip_lock();
2417         if(eXosip_call_build_request(h->did,"INVITE",&reinvite) != 0 || reinvite==NULL){
2418                 eXosip_unlock();
2419                 return -1;
2420         }
2421         eXosip_unlock();
2422         osip_message_set_subject(reinvite,subject);
2423         osip_message_set_allow(reinvite, "INVITE, ACK, CANCEL, OPTIONS, BYE, REFER, NOTIFY, MESSAGE, SUBSCRIBE, INFO");
2424         if (h->base.root->session_expires!=0){
2425                 osip_message_set_header(reinvite, "Session-expires", "200");
2426                 osip_message_set_supported(reinvite, "timer");
2427         }
2428         if (h->base.local_media){
2429                 h->sdp_offering=TRUE;
2430                 set_sdp_from_desc(reinvite,h->base.local_media,sal_op_get_ice_session(h));
2431         }else h->sdp_offering=FALSE;
2432         eXosip_lock();
2433         err = eXosip_call_send_request(h->did, reinvite);
2434         eXosip_unlock();
2435         return err;
2436 }
2437 void sal_reuse_authorization(Sal *ctx, bool_t value) {
2438         ctx->reuse_authorization=value;
2439 }