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){
 506         sdp_message_t *msg=media_description_to_sdp(desc);
 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);
 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);
 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);
 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
 994         set_network_origin(op,ev->request);
 995         set_remote_ua(op,ev->request);
 996         set_replaces(op,ev->request);
 997
 998         if (sdp){
 999                 op->sdp_offering=FALSE;
1000                 op->base.remote_media=sal_media_description_new();
1001                 sdp_to_media_description(sdp,op->base.remote_media);
1002                 sdp_message_free(sdp);
1003         }else op->sdp_offering=TRUE;
1004
1005         from=osip_message_get_from(ev->request);
1006         to=osip_message_get_to(ev->request);
1007         osip_from_to_str(from,&tmp);
1008         sal_op_set_from(op,tmp);
1009         osip_free(tmp);
1010         osip_from_to_str(to,&tmp);
1011         sal_op_set_to(op,tmp);
1012         osip_free(tmp);
1013
1014         osip_message_get_call_info(ev->request,0,&call_info);
1015         if(call_info)
1016         {
1017                 osip_call_info_to_str(call_info,&tmp);
1018                 if( strstr(tmp,"answer-after=") != NULL)
1019                 {
1020                         op->auto_answer_asked=TRUE;
1021                         ms_message("The caller asked to automatically answer the call(Emergency?)\n");
1022                 }
1023                 osip_free(tmp);
1024         }
1025
1026         op->tid=ev->tid;
1027         op->cid=ev->cid;
1028         op->did=ev->did;
1029
1030         sal_add_call(op->base.root,op);
1031         sal->callbacks.call_received(op);
1032 }
1033
1034 static void handle_reinvite(Sal *sal,  eXosip_event_t *ev){
1035         SalOp *op=find_op(sal,ev);
1036         sdp_message_t *sdp;
1037
1038         if (op==NULL) {
1039                 ms_warning("Reinvite for non-existing operation !");
1040                 return;
1041         }
1042         op->reinvite=TRUE;
1043         op->tid=ev->tid;
1044         sdp=eXosip_get_sdp_info(ev->request);
1045         if (op->base.remote_media){
1046                 sal_media_description_unref(op->base.remote_media);
1047                 op->base.remote_media=NULL;
1048         }
1049         if (op->result){
1050                 sal_media_description_unref(op->result);
1051                 op->result=NULL;
1052         }
1053         if (sdp){
1054                 op->sdp_offering=FALSE;
1055                 op->base.remote_media=sal_media_description_new();
1056                 sdp_to_media_description(sdp,op->base.remote_media);
1057                 sdp_message_free(sdp);
1058
1059         }else {
1060                 op->sdp_offering=TRUE;
1061         }
1062         sal->callbacks.call_updating(op);
1063 }
1064
1065 static void handle_ack(Sal *sal,  eXosip_event_t *ev){
1066         SalOp *op=find_op(sal,ev);
1067         sdp_message_t *sdp;
1068
1069         if (op==NULL) {
1070                 ms_warning("ack for non-existing call !");
1071                 return;
1072         }
1073         if (op->terminated) {
1074                 ms_warning("ack for terminated call, ignoring");
1075                 return;
1076         }
1077
1078         if (op->sdp_offering){
1079                 sdp=eXosip_get_sdp_info(ev->ack);
1080                 if (sdp){
1081                         if (op->base.remote_media)
1082                                 sal_media_description_unref(op->base.remote_media);
1083                         op->base.remote_media=sal_media_description_new();
1084                         sdp_to_media_description(sdp,op->base.remote_media);
1085                         sdp_process(op);
1086                         sdp_message_free(sdp);
1087                 }
1088         }
1089         if (op->reinvite){
1090                 op->reinvite=FALSE;
1091         }
1092         sal->callbacks.call_ack(op);
1093 }
1094
1095 static void update_contact_from_response(SalOp *op, osip_message_t *response){
1096         const char *received;
1097         int rport;
1098         SalTransport transport;
1099         if (extract_received_rport(response,&received,&rport,&transport)==0){
1100                 const char *contact=sal_op_get_contact(op);
1101                 if (!contact){
1102                         /*no contact given yet, use from instead*/
1103                         contact=sal_op_get_from(op);
1104                 }
1105                 if (contact){
1106                         SalAddress *addr=sal_address_new(contact);
1107                         char *tmp;
1108                         sal_address_set_domain(addr,received);
1109                         sal_address_set_port_int(addr,rport);
1110                         if (transport!=SalTransportUDP)
1111                                 sal_address_set_transport(addr,transport);
1112                         tmp=sal_address_as_string(addr);
1113                         ms_message("Contact address updated to %s",tmp);
1114                         sal_op_set_contact(op,tmp);
1115                         sal_address_destroy(addr);
1116                         ms_free(tmp);
1117                 }
1118         }
1119 }
1120
1121 static int call_proceeding(Sal *sal, eXosip_event_t *ev){
1122         SalOp *op=find_op(sal,ev);
1123
1124         if (op==NULL || op->terminated==TRUE) {
1125                 ms_warning("This call has been canceled.");
1126                 eXosip_lock();
1127                 eXosip_call_terminate(ev->cid,ev->did);
1128                 eXosip_unlock();
1129                 return -1;
1130         }
1131         if (ev->did>0)
1132                 op->did=ev->did;
1133         op->tid=ev->tid;
1134
1135         /* update contact if received and rport are set by the server
1136          note: will only be used by remote for next INVITE, if any...*/
1137         update_contact_from_response(op,ev->response);
1138         return 0;
1139 }
1140
1141 static void call_ringing(Sal *sal, eXosip_event_t *ev){
1142         sdp_message_t *sdp;
1143         SalOp *op=find_op(sal,ev);
1144         if (call_proceeding(sal, ev)==-1) return;
1145
1146         set_remote_ua(op,ev->response);
1147         sdp=eXosip_get_sdp_info(ev->response);
1148         if (sdp){
1149                 op->base.remote_media=sal_media_description_new();
1150                 sdp_to_media_description(sdp,op->base.remote_media);
1151                 sdp_message_free(sdp);
1152                 if (op->base.local_media) sdp_process(op);
1153         }
1154         sal->callbacks.call_ringing(op);
1155 }
1156
1157 static void call_accepted(Sal *sal, eXosip_event_t *ev){
1158         sdp_message_t *sdp;
1159         osip_message_t *msg=NULL;
1160         SalOp *op=find_op(sal,ev);
1161         const char *contact;
1162
1163         if (op==NULL || op->terminated==TRUE) {
1164                 ms_warning("This call has been already terminated.");
1165                 eXosip_lock();
1166                 eXosip_call_terminate(ev->cid,ev->did);
1167                 eXosip_unlock();
1168                 return ;
1169         }
1170
1171         op->did=ev->did;
1172         set_remote_ua(op,ev->response);
1173
1174         sdp=eXosip_get_sdp_info(ev->response);
1175         if (sdp){
1176                 op->base.remote_media=sal_media_description_new();
1177                 sdp_to_media_description(sdp,op->base.remote_media);
1178                 sdp_message_free(sdp);
1179                 if (op->base.local_media) sdp_process(op);
1180         }
1181         eXosip_call_build_ack(ev->did,&msg);
1182         if (msg==NULL) {
1183                 ms_warning("This call has been already terminated.");
1184                 eXosip_lock();
1185                 eXosip_call_terminate(ev->cid,ev->did);
1186                 eXosip_unlock();
1187                 return ;
1188         }
1189         contact=sal_op_get_contact(op);
1190         if (contact) {
1191                 _osip_list_set_empty(&msg->contacts,(void (*)(void*))osip_contact_free);
1192                 osip_message_set_contact(msg,contact);
1193         }
1194         if (op->sdp_answer){
1195                 set_sdp(msg,op->sdp_answer);
1196                 sdp_message_free(op->sdp_answer);
1197                 op->sdp_answer=NULL;
1198         }
1199         eXosip_call_send_ack(ev->did,msg);
1200         sal->callbacks.call_accepted(op);
1201 }
1202
1203 static void call_terminated(Sal *sal, eXosip_event_t *ev){
1204         char *from=NULL;
1205         SalOp *op=find_op(sal,ev);
1206         if (op==NULL){
1207                 ms_warning("Call terminated for already closed call ?");
1208                 return;
1209         }
1210         if (ev->request){
1211                 osip_from_to_str(ev->request->from,&from);
1212         }
1213         sal->callbacks.call_terminated(op,from!=NULL ? from : sal_op_get_from(op));
1214         if (from) osip_free(from);
1215         op->terminated=TRUE;
1216 }
1217
1218 static void call_released(Sal *sal, eXosip_event_t *ev){
1219         SalOp *op=find_op(sal,ev);
1220         if (op==NULL){
1221                 ms_warning("No op associated to this call_released()");
1222                 return;
1223         }
1224         if (!op->terminated){
1225                 /* no response received so far */
1226                 call_failure(sal,ev);
1227         }
1228         sal->callbacks.call_released(op);
1229 }
1230
1231 static int get_auth_data_from_response(osip_message_t *resp, const char **realm, const char **username){
1232         const char *prx_realm=NULL,*www_realm=NULL;
1233         osip_proxy_authenticate_t *prx_auth;
1234         osip_www_authenticate_t *www_auth;
1235
1236         *username=osip_uri_get_username(resp->from->url);
1237         prx_auth=(osip_proxy_authenticate_t*)osip_list_get(&resp->proxy_authenticates,0);
1238         www_auth=(osip_proxy_authenticate_t*)osip_list_get(&resp->www_authenticates,0);
1239         if (prx_auth!=NULL)
1240                 prx_realm=osip_proxy_authenticate_get_realm(prx_auth);
1241         if (www_auth!=NULL)
1242                 www_realm=osip_www_authenticate_get_realm(www_auth);
1243
1244         if (prx_realm){
1245                 *realm=prx_realm;
1246         }else if (www_realm){
1247                 *realm=www_realm;
1248         }else{
1249                 return -1;
1250         }
1251         return 0;
1252 }
1253
1254 static int get_auth_data_from_request(osip_message_t *msg, const char **realm, const char **username){
1255         osip_authorization_t *auth=NULL;
1256         osip_proxy_authorization_t *prx_auth=NULL;
1257
1258         *username=osip_uri_get_username(msg->from->url);
1259         osip_message_get_authorization(msg, 0, &auth);
1260         if (auth){
1261                 *realm=osip_authorization_get_realm(auth);
1262                 return 0;
1263         }
1264         osip_message_get_proxy_authorization(msg,0,&prx_auth);
1265         if (prx_auth){
1266                 *realm=osip_proxy_authorization_get_realm(prx_auth);
1267                 return 0;
1268         }
1269         return -1;
1270 }
1271
1272 static int get_auth_data(eXosip_event_t *ev, const char **realm, const char **username){
1273         if (ev->response && get_auth_data_from_response(ev->response,realm,username)==0) return 0;
1274         if (ev->request && get_auth_data_from_request(ev->request,realm,username)==0) return 0;
1275         return -1;
1276 }
1277
1278 int sal_op_get_auth_requested(SalOp *op, const char **realm, const char **username){
1279         if (op->pending_auth){
1280                 return get_auth_data(op->pending_auth,realm,username);
1281         }
1282         return -1;
1283 }
1284
1285 static bool_t process_authentication(Sal *sal, eXosip_event_t *ev){
1286         SalOp *op;
1287         const char *username,*realm;
1288         op=find_op(sal,ev);
1289         if (op==NULL){
1290                 ms_warning("No operation associated with this authentication !");
1291                 return TRUE;
1292         }
1293         if (get_auth_data(ev,&realm,&username)==0){
1294                 if (op->pending_auth!=NULL){
1295                         eXosip_event_free(op->pending_auth);
1296                         op->pending_auth=ev;
1297                 }else{
1298                         op->pending_auth=ev;
1299                         sal_add_pending_auth(sal,op);
1300                 }
1301
1302                 sal->callbacks.auth_requested(op,realm,username);
1303                 return FALSE;
1304         }
1305         return TRUE;
1306 }
1307
1308 static void authentication_ok(Sal *sal, eXosip_event_t *ev){
1309         SalOp *op;
1310         const char *username,*realm;
1311         op=find_op(sal,ev);
1312         if (op==NULL){
1313                 ms_warning("No operation associated with this authentication_ok!");
1314                 return ;
1315         }
1316         if (op->pending_auth){
1317                 eXosip_event_free(op->pending_auth);
1318                 sal_remove_pending_auth(sal,op);
1319                 op->pending_auth=NULL;
1320         }
1321         if (get_auth_data(ev,&realm,&username)==0){
1322                 sal->callbacks.auth_success(op,realm,username);
1323         }
1324 }
1325
1326 static bool_t call_failure(Sal *sal, eXosip_event_t *ev){
1327         SalOp *op;
1328         int code=0;
1329         char* computedReason=NULL;
1330         const char *reason=NULL;
1331         SalError error=SalErrorUnknown;
1332         SalReason sr=SalReasonUnknown;
1333
1334
1335         op=(SalOp*)find_op(sal,ev);
1336
1337         if (op==NULL) {
1338                 ms_warning("Call failure reported for a closed call, ignored.");
1339                 return TRUE;
1340         }
1341
1342         if (ev->response){
1343                 code=osip_message_get_status_code(ev->response);
1344                 reason=osip_message_get_reason_phrase(ev->response);
1345                 osip_header_t *h=NULL;
1346                 if (!osip_message_header_get_byname(    ev->response
1347                                                                                         ,"Reason"
1348                                                                                         ,0
1349                                                                                         ,&h)) {
1350                         computedReason = ms_strdup_printf("%s %s",reason,osip_header_get_value(h));
1351                         reason = computedReason;
1352
1353                 }
1354         }
1355         switch(code)
1356         {
1357                 case 401:
1358                 case 407:
1359                         return process_authentication(sal,ev);
1360                         break;
1361                 case 400:
1362                         error=SalErrorUnknown;
1363                 break;
1364                 case 404:
1365                         error=SalErrorFailure;
1366                         sr=SalReasonNotFound;
1367                 break;
1368                 case 415:
1369                         error=SalErrorFailure;
1370                         sr=SalReasonMedia;
1371                 break;
1372                 case 422:
1373                         eXosip_default_action(ev);
1374                         return TRUE;
1375                 break;
1376                 case 480:
1377                         error=SalErrorFailure;
1378                         sr=SalReasonTemporarilyUnavailable;
1379                 case 486:
1380                         error=SalErrorFailure;
1381                         sr=SalReasonBusy;
1382                 break;
1383                 case 487:
1384                 break;
1385                 case 600:
1386                         error=SalErrorFailure;
1387                         sr=SalReasonDoNotDisturb;
1388                 break;
1389                 case 603:
1390                         error=SalErrorFailure;
1391                         sr=SalReasonDeclined;
1392                 break;
1393                 default:
1394                         if (code>0){
1395                                 error=SalErrorFailure;
1396                                 sr=SalReasonUnknown;
1397                         }else error=SalErrorNoResponse;
1398         }
1399         op->terminated=TRUE;
1400         sal->callbacks.call_failure(op,error,sr,reason,code);
1401         if (computedReason != NULL){
1402                 ms_free(computedReason);
1403         }
1404         return TRUE;
1405 }
1406
1407 /* Request remote side to send us VFU */
1408 void sal_call_send_vfu_request(SalOp *h){
1409         osip_message_t *msg=NULL;
1410         char info_body[] =
1411                         "<?xml version=\"1.0\" encoding=\"utf-8\" ?>"
1412                          "<media_control>"
1413                          "  <vc_primitive>"
1414                          "    <to_encoder>"
1415                          "      <picture_fast_update></picture_fast_update>"
1416                          "    </to_encoder>"
1417                          "  </vc_primitive>"
1418                          "</media_control>";
1419
1420         char clen[10];
1421
1422         eXosip_lock();
1423         eXosip_call_build_info(h->did,&msg);
1424         if (msg){
1425                 osip_message_set_body(msg,info_body,strlen(info_body));
1426                 osip_message_set_content_type(msg,"application/media_control+xml");
1427                 snprintf(clen,sizeof(clen),"%lu",(unsigned long)strlen(info_body));
1428                 osip_message_set_content_length(msg,clen);
1429                 eXosip_call_send_request(h->did,msg);
1430                 ms_message("Sending VFU request !");
1431         }
1432         eXosip_unlock();
1433 }
1434
1435 static void process_media_control_xml(Sal *sal, eXosip_event_t *ev){
1436         SalOp *op=find_op(sal,ev);
1437         osip_body_t *body=NULL;
1438
1439         if (op==NULL){
1440                 ms_warning("media control xml received without operation context!");
1441                 return ;
1442         }
1443
1444         osip_message_get_body(ev->request,0,&body);
1445         if (body && body->body!=NULL &&
1446                 strstr(body->body,"picture_fast_update")){
1447                 osip_message_t *ans=NULL;
1448                 ms_message("Receiving VFU request !");
1449                 if (sal->callbacks.vfu_request){
1450                         sal->callbacks.vfu_request(op);
1451                         eXosip_call_build_answer(ev->tid,200,&ans);
1452                         if (ans)
1453                                 eXosip_call_send_answer(ev->tid,200,ans);
1454                         return;
1455                 }
1456         }
1457         /*in all other cases we must say it is not implemented.*/
1458         {
1459                 osip_message_t *ans=NULL;
1460                 eXosip_lock();
1461                 eXosip_call_build_answer(ev->tid,501,&ans);
1462                 if (ans)
1463                         eXosip_call_send_answer(ev->tid,501,ans);
1464                 eXosip_unlock();
1465         }
1466 }
1467
1468 static void process_dtmf_relay(Sal *sal, eXosip_event_t *ev){
1469         SalOp *op=find_op(sal,ev);
1470         osip_body_t *body=NULL;
1471
1472         if (op==NULL){
1473                 ms_warning("media dtmf relay received without operation context!");
1474                 return ;
1475         }
1476
1477         osip_message_get_body(ev->request,0,&body);
1478         if (body && body->body!=NULL){
1479                 osip_message_t *ans=NULL;
1480                 const char *name=strstr(body->body,"Signal");
1481                 if (name==NULL) name=strstr(body->body,"signal");
1482                 if (name==NULL) {
1483                         ms_warning("Could not extract the dtmf name from the SIP INFO.");
1484                 }else{
1485                         char tmp[2];
1486                         name+=strlen("signal");
1487                         if (sscanf(name," = %1s",tmp)==1){
1488                                 ms_message("Receiving dtmf %s via SIP INFO.",tmp);
1489                                 if (sal->callbacks.dtmf_received != NULL)
1490                                         sal->callbacks.dtmf_received(op, tmp[0]);
1491                         }
1492                 }
1493                 eXosip_lock();
1494                 eXosip_call_build_answer(ev->tid,200,&ans);
1495                 if (ans)
1496                         eXosip_call_send_answer(ev->tid,200,ans);
1497                 eXosip_unlock();
1498         }
1499 }
1500
1501 static void fill_options_answer(osip_message_t *options){
1502         osip_message_set_allow(options,"INVITE, ACK, BYE, CANCEL, OPTIONS, MESSAGE, SUBSCRIBE, NOTIFY, INFO");
1503         osip_message_set_accept(options,"application/sdp");
1504 }
1505
1506 static void process_refer(Sal *sal, SalOp *op, eXosip_event_t *ev){
1507         osip_header_t *h=NULL;
1508         osip_message_t *ans=NULL;
1509         ms_message("Receiving REFER request !");
1510         osip_message_header_get_byname(ev->request,"Refer-To",0,&h);
1511
1512         if (h){
1513                 osip_from_t *from=NULL;
1514                 char *tmp;
1515                 osip_from_init(&from);
1516
1517                 if (osip_from_parse(from,h->hvalue)==0){
1518                         if (op ){
1519                                 osip_uri_header_t *uh=NULL;
1520                                 osip_header_t *referred_by=NULL;
1521                                 osip_uri_header_get_byname(&from->url->url_headers,(char*)"Replaces",&uh);
1522                                 if (uh!=NULL && uh->gvalue && uh->gvalue[0]!='\0'){
1523                                         ms_message("Found replaces in Refer-To");
1524                                         if (op->replaces){
1525                                                 ms_free(op->replaces);
1526                                         }
1527                                         op->replaces=ms_strdup(uh->gvalue);
1528                                 }
1529                                 osip_message_header_get_byname(ev->request,"Referred-By",0,&referred_by);
1530                                 if (referred_by && referred_by->hvalue && referred_by->hvalue[0]!='\0'){
1531                                         if (op->referred_by)
1532                                                 ms_free(op->referred_by);
1533                                         op->referred_by=ms_strdup(referred_by->hvalue);
1534                                 }
1535                         }
1536                         osip_uri_header_freelist(&from->url->url_headers);
1537                         osip_from_to_str(from,&tmp);
1538                         sal->callbacks.refer_received(sal,op,tmp);
1539                         osip_free(tmp);
1540                         osip_from_free(from);
1541                 }
1542                 eXosip_lock();
1543                 eXosip_call_build_answer(ev->tid,202,&ans);
1544                 if (ans)
1545                         eXosip_call_send_answer(ev->tid,202,ans);
1546                 eXosip_unlock();
1547         }
1548         else
1549         {
1550                 ms_warning("cannot do anything with the refer without destination\n");
1551         }
1552 }
1553
1554 static void process_notify(Sal *sal, eXosip_event_t *ev){
1555         osip_header_t *h=NULL;
1556         char *from=NULL;
1557         SalOp *op=find_op(sal,ev);
1558         osip_message_t *ans=NULL;
1559
1560         ms_message("Receiving NOTIFY request !");
1561         osip_from_to_str(ev->request->from,&from);
1562         osip_message_header_get_byname(ev->request,"Event",0,&h);
1563         if(h){
1564                 osip_body_t *body=NULL;
1565                 //osip_content_type_t *ct=NULL;
1566                 osip_message_get_body(ev->request,0,&body);
1567                 //ct=osip_message_get_content_type(ev->request);
1568                 if (h->hvalue && strcasecmp(h->hvalue,"refer")==0){
1569                         /*special handling of refer events*/
1570                         if (body && body->body){
1571                                 osip_message_t *msg;
1572                                 osip_message_init(&msg);
1573                                 if (osip_message_parse_sipfrag(msg,body->body,strlen(body->body))==0){
1574                                         int code=osip_message_get_status_code(msg);
1575                                         if (code==100){
1576                                                 sal->callbacks.notify_refer(op,SalReferTrying);
1577                                         }else if (code==200){
1578                                                 sal->callbacks.notify_refer(op,SalReferSuccess);
1579                                         }else if (code>=400){
1580                                                 sal->callbacks.notify_refer(op,SalReferFailed);
1581                                         }
1582                                 }
1583                                 osip_message_free(msg);
1584                         }
1585                 }else{
1586                         /*generic handling*/
1587                         sal->callbacks.notify(op,from,h->hvalue);
1588                 }
1589         }
1590         /*answer that we received the notify*/
1591         eXosip_lock();
1592         eXosip_call_build_answer(ev->tid,200,&ans);
1593         if (ans)
1594                 eXosip_call_send_answer(ev->tid,200,ans);
1595         eXosip_unlock();
1596         osip_free(from);
1597 }
1598
1599 static void call_message_new(Sal *sal, eXosip_event_t *ev){
1600         osip_message_t *ans=NULL;
1601         if (ev->request){
1602                 if (MSG_IS_INFO(ev->request)){
1603                         osip_content_type_t *ct;
1604                         ct=osip_message_get_content_type(ev->request);
1605                         if (ct && ct->subtype){
1606                                 if (strcmp(ct->subtype,"media_control+xml")==0)
1607                                         process_media_control_xml(sal,ev);
1608                                 else if (strcmp(ct->subtype,"dtmf-relay")==0)
1609                                         process_dtmf_relay(sal,ev);
1610                                 else {
1611                                         ms_message("Unhandled SIP INFO.");
1612                                         /*send an "Not implemented" answer*/
1613                                         eXosip_lock();
1614                                         eXosip_call_build_answer(ev->tid,501,&ans);
1615                                         if (ans)
1616                                                 eXosip_call_send_answer(ev->tid,501,ans);
1617                                         eXosip_unlock();
1618                                 }
1619                         }else{
1620                                 /*empty SIP INFO, probably to test we are alive. Send an empty answer*/
1621                                 eXosip_lock();
1622                                 eXosip_call_build_answer(ev->tid,200,&ans);
1623                                 if (ans)
1624                                         eXosip_call_send_answer(ev->tid,200,ans);
1625                                 eXosip_unlock();
1626                         }
1627                 }else if(MSG_IS_MESSAGE(ev->request)){
1628                         /* SIP messages could be received into call */
1629                         text_received(sal, ev);
1630                         eXosip_lock();
1631                         eXosip_call_build_answer(ev->tid,200,&ans);
1632                         if (ans)
1633                                 eXosip_call_send_answer(ev->tid,200,ans);
1634                         eXosip_unlock();
1635                 }else if(MSG_IS_REFER(ev->request)){
1636                         SalOp *op=find_op(sal,ev);
1637
1638                         ms_message("Receiving REFER request !");
1639                         process_refer(sal,op,ev);
1640                 }else if(MSG_IS_NOTIFY(ev->request)){
1641                         process_notify(sal,ev);
1642                 }else if (MSG_IS_OPTIONS(ev->request)){
1643                         eXosip_lock();
1644                         eXosip_call_build_answer(ev->tid,200,&ans);
1645                         if (ans){
1646                                 fill_options_answer(ans);
1647                                 eXosip_call_send_answer(ev->tid,200,ans);
1648                         }
1649                         eXosip_unlock();
1650                 }
1651         }else ms_warning("call_message_new: No request ?");
1652 }
1653
1654 static void inc_update(Sal *sal, eXosip_event_t *ev){
1655         osip_message_t *msg=NULL;
1656         ms_message("Processing incoming UPDATE");
1657         eXosip_lock();
1658         eXosip_message_build_answer(ev->tid,200,&msg);
1659         if (msg!=NULL)
1660                 eXosip_message_send_answer(ev->tid,200,msg);
1661         eXosip_unlock();
1662 }
1663
1664 static bool_t comes_from_local_if(osip_message_t *msg){
1665         osip_via_t *via=NULL;
1666         osip_message_get_via(msg,0,&via);
1667         if (via){
1668                 const char *host;
1669                 host=osip_via_get_host(via);
1670                 if (strcmp(host,"127.0.0.1")==0 || strcmp(host,"::1")==0){
1671                         osip_generic_param_t *param=NULL;
1672                         osip_via_param_get_byname(via,"received",&param);
1673                         if (param==NULL) return TRUE;
1674                         if (param->gvalue &&
1675                                 (strcmp(param->gvalue,"127.0.0.1")==0 || strcmp(param->gvalue,"::1")==0)){
1676                                 return TRUE;
1677                         }
1678                 }
1679         }
1680         return FALSE;
1681 }
1682
1683 static void text_received(Sal *sal, eXosip_event_t *ev){
1684         osip_body_t *body=NULL;
1685         char *from=NULL,*msg;
1686
1687         osip_message_get_body(ev->request,0,&body);
1688         if (body==NULL){
1689                 ms_error("Could not get text message from SIP body");
1690                 return;
1691         }
1692         msg=body->body;
1693         osip_from_to_str(ev->request->from,&from);
1694         sal->callbacks.text_received(sal,from,msg);
1695         osip_free(from);
1696 }
1697
1698
1699
1700 static void other_request(Sal *sal, eXosip_event_t *ev){
1701         ms_message("in other_request");
1702         if (ev->request==NULL) return;
1703         if (strcmp(ev->request->sip_method,"MESSAGE")==0){
1704                 text_received(sal,ev);
1705                 eXosip_message_send_answer(ev->tid,200,NULL);
1706         }else if (strcmp(ev->request->sip_method,"OPTIONS")==0){
1707                 osip_message_t *options=NULL;
1708                 eXosip_options_build_answer(ev->tid,200,&options);
1709                 fill_options_answer(options);
1710                 eXosip_options_send_answer(ev->tid,200,options);
1711         }else if (strncmp(ev->request->sip_method, "REFER", 5) == 0){
1712                 ms_message("Receiving REFER request !");
1713                 if (comes_from_local_if(ev->request)) {
1714                         process_refer(sal,NULL,ev);
1715                 }else ms_warning("Ignored REFER not coming from this local loopback interface.");
1716         }else if (strncmp(ev->request->sip_method, "UPDATE", 6) == 0){
1717                 inc_update(sal,ev);
1718     }else {
1719                 char *tmp=NULL;
1720                 size_t msglen=0;
1721                 osip_message_to_str(ev->request,&tmp,&msglen);
1722                 if (tmp){
1723                         ms_message("Unsupported request received:\n%s",tmp);
1724                         osip_free(tmp);
1725                 }
1726                 /*answer with a 501 Not implemented*/
1727                 eXosip_message_send_answer(ev->tid,501,NULL);
1728         }
1729 }
1730
1731 static void masquerade_via(osip_message_t *msg, const char *ip, const char *port){
1732         osip_via_t *via=NULL;
1733         osip_message_get_via(msg,0,&via);
1734         if (via){
1735                 osip_free(via->port);
1736                 via->port=osip_strdup(port);
1737                 osip_free(via->host);
1738                 via->host=osip_strdup(ip);
1739         }
1740 }
1741
1742
1743 static bool_t fix_message_contact(SalOp *op, osip_message_t *request,osip_message_t *last_answer, bool_t expire_last_contact) {
1744         osip_contact_t *ctt=NULL;
1745         const char *received;
1746         int rport;
1747         SalTransport transport;
1748         char port[20];
1749
1750         if (extract_received_rport(last_answer,&received,&rport,&transport)==-1) return FALSE;
1751         osip_message_get_contact(request,0,&ctt);
1752         if (ctt == NULL) {
1753                 ms_warning("fix_message_contact(): no contact to update");
1754                 return FALSE;
1755         }
1756         if (expire_last_contact){
1757                 osip_contact_t *oldct=NULL,*prevct;
1758                 osip_generic_param_t *param=NULL;
1759                 osip_contact_clone(ctt,&oldct);
1760                 while ((prevct=(osip_contact_t*)osip_list_get(&request->contacts,1))!=NULL){
1761                         osip_contact_free(prevct);
1762                         osip_list_remove(&request->contacts,1);
1763                 }
1764                 osip_list_add(&request->contacts,oldct,1);
1765                 osip_contact_param_get_byname(oldct,"expires",&param);
1766                 if (param){
1767                         if (param->gvalue) osip_free(param->gvalue);
1768                         param->gvalue=osip_strdup("0");
1769                 }else{
1770                         osip_contact_param_add(oldct,osip_strdup("expires"),osip_strdup("0"));
1771                 }
1772         }
1773         if (ctt->url->host!=NULL){
1774                 osip_free(ctt->url->host);
1775         }
1776         ctt->url->host=osip_strdup(received);
1777         if (ctt->url->port!=NULL){
1778                 osip_free(ctt->url->port);
1779         }
1780         snprintf(port,sizeof(port),"%i",rport);
1781         ctt->url->port=osip_strdup(port);
1782         if (op->masquerade_via) masquerade_via(request,received,port);
1783
1784         if (transport != SalTransportUDP) {
1785                 sal_address_set_param((SalAddress *)ctt, "transport", sal_transport_to_string(transport));
1786         }
1787         return TRUE;
1788 }
1789
1790 static bool_t register_again_with_updated_contact(SalOp *op, osip_message_t *orig_request, osip_message_t *last_answer){
1791         osip_contact_t *ctt=NULL;
1792         SalAddress* ori_contact_address=NULL;
1793         const char *received;
1794         int rport;
1795         SalTransport transport;
1796         char* tmp;
1797         osip_message_t *msg=NULL;
1798         Sal* sal=op->base.root;
1799         int i=0;
1800         bool_t found_valid_contact=FALSE;
1801         bool_t from_request=FALSE;
1802
1803         if (sal->double_reg==FALSE ) return FALSE;
1804
1805         if (extract_received_rport(last_answer,&received,&rport,&transport)==-1) return FALSE;
1806         do{
1807                 ctt=NULL;
1808                 osip_message_get_contact(last_answer,i,&ctt);
1809                 if (!from_request && ctt==NULL) {
1810                         osip_message_get_contact(orig_request,0,&ctt);
1811                         from_request=TRUE;
1812                 }
1813                 if (ctt){
1814                         osip_contact_to_str(ctt,&tmp);
1815                         ori_contact_address = sal_address_new(tmp);
1816
1817                         /*check if contact is up to date*/
1818                         if (strcmp(sal_address_get_domain(ori_contact_address),received) ==0
1819                                 && sal_address_get_port_int(ori_contact_address) == rport
1820                         && sal_address_get_transport(ori_contact_address) == transport) {
1821                                 if (!from_request){
1822                                         ms_message("Register response has up to date contact, doing nothing.");
1823                                 }else {
1824                                         ms_warning("Register response does not have up to date contact, but last request had."
1825                                                 "Stupid registrar detected, giving up.");
1826                                 }
1827                                 found_valid_contact=TRUE;
1828                         }
1829                         osip_free(tmp);
1830                         sal_address_destroy(ori_contact_address);
1831                 }else break;
1832                 i++;
1833         }while(!found_valid_contact);
1834         if (!found_valid_contact)
1835                 ms_message("Contact do not match, resending register.");
1836         else return FALSE;
1837
1838         eXosip_lock();
1839         eXosip_register_build_register(op->rid,op->expires,&msg);
1840         if (msg==NULL){
1841             eXosip_unlock();
1842             ms_warning("Fail to create a contact updated register.");
1843             return FALSE;
1844         }
1845         if (fix_message_contact(op,msg,last_answer,op->base.root->expire_old_contact)) {
1846                 eXosip_register_send_register(op->rid,msg);
1847                 eXosip_unlock();
1848                 ms_message("Resending new register with updated contact");
1849                 update_contact_from_response(op,last_answer);
1850                 return TRUE;
1851         } else {
1852             ms_warning("Fail to send updated register.");
1853             eXosip_unlock();
1854             return FALSE;
1855         }
1856         eXosip_unlock();
1857         return FALSE;
1858 }
1859
1860 static void registration_success(Sal *sal, eXosip_event_t *ev){
1861         SalOp *op=sal_find_register(sal,ev->rid);
1862         osip_header_t *h=NULL;
1863         bool_t registered;
1864         if (op==NULL){
1865                 ms_error("Receiving register response for unknown operation");
1866                 return;
1867         }
1868         osip_message_get_expires(ev->request,0,&h);
1869         if (h!=NULL && atoi(h->hvalue)!=0){
1870                 registered=TRUE;
1871                 if (!register_again_with_updated_contact(op,ev->request,ev->response)){
1872                         sal->callbacks.register_success(op,registered);
1873                 }
1874         }else {
1875                 sal->callbacks.register_success(op,FALSE);
1876         }
1877 }
1878
1879 static bool_t registration_failure(Sal *sal, eXosip_event_t *ev){
1880         int status_code=0;
1881         const char *reason=NULL;
1882         SalOp *op=sal_find_register(sal,ev->rid);
1883         SalReason sr=SalReasonUnknown;
1884         SalError se=SalErrorUnknown;
1885
1886         if (op==NULL){
1887                 ms_error("Receiving register failure for unknown operation");
1888                 return TRUE;
1889         }
1890         if (ev->response){
1891                 status_code=osip_message_get_status_code(ev->response);
1892                 reason=osip_message_get_reason_phrase(ev->response);
1893         }
1894         switch(status_code){
1895                 case 401:
1896                 case 407:
1897                         return process_authentication(sal,ev);
1898                         break;
1899                 case 423: /*interval too brief*/
1900                         {/*retry with greater interval */
1901                                 osip_header_t *h=NULL;
1902                                 osip_message_t *msg=NULL;
1903                                 osip_message_header_get_byname(ev->response,"min-expires",0,&h);
1904                                 if (h && h->hvalue && h->hvalue[0]!='\0'){
1905                                         int val=atoi(h->hvalue);
1906                                         if (val>op->expires)
1907                                                 op->expires=val;
1908                                 }else op->expires*=2;
1909                                 eXosip_lock();
1910                                 eXosip_register_build_register(op->rid,op->expires,&msg);
1911                                 eXosip_register_send_register(op->rid,msg);
1912                                 eXosip_unlock();
1913                         }
1914                 break;
1915                 case 606: /*Not acceptable, workaround for proxies that don't like private addresses
1916                                  in vias, such as ekiga.net
1917                                  On the opposite, freephonie.net bugs when via are masqueraded.
1918                                  */
1919                         op->masquerade_via=TRUE;
1920                 default:
1921                         /* if contact is up to date, process the failure, otherwise resend a new register with
1922                                 updated contact first, just in case the faillure is due to incorrect contact */
1923                         if (ev->response && register_again_with_updated_contact(op,ev->request,ev->response))
1924                                 return TRUE; /*we are retrying with an updated contact*/
1925                         if (status_code==403){
1926                                 se=SalErrorFailure;
1927                                 sr=SalReasonForbidden;
1928                         }else if (status_code==0){
1929                                 se=SalErrorNoResponse;
1930                         }
1931                         sal->callbacks.register_failure(op,se,sr,reason);
1932         }
1933         return TRUE;
1934 }
1935
1936 static void other_request_reply(Sal *sal,eXosip_event_t *ev){
1937         SalOp *op=find_op(sal,ev);
1938
1939         if (op==NULL){
1940                 ms_warning("other_request_reply(): Receiving response to unknown request.");
1941                 return;
1942         }
1943         if (ev->response){
1944                 update_contact_from_response(op,ev->response);
1945                 if (ev->request && strcmp(osip_message_get_method(ev->request),"OPTIONS")==0)
1946                         sal->callbacks.ping_reply(op);
1947         }
1948 }
1949
1950 static void process_in_call_reply(Sal *sal, eXosip_event_t *ev){
1951         SalOp *op=find_op(sal,ev);
1952         if (ev->response){
1953                 if (ev->request && strcmp(osip_message_get_method(ev->request),"NOTIFY")==0){
1954                         if (op->sipfrag_pending){
1955                                 send_notify_for_refer(op->did,op->sipfrag_pending);
1956                                 op->sipfrag_pending=NULL;
1957                         }
1958                 }
1959         }
1960 }
1961
1962 static bool_t process_event(Sal *sal, eXosip_event_t *ev){
1963         ms_message("linphone process event get a message %d\n",ev->type);
1964         switch(ev->type){
1965                 case EXOSIP_CALL_ANSWERED:
1966                         ms_message("CALL_ANSWERED\n");
1967                         call_accepted(sal,ev);
1968                         authentication_ok(sal,ev);
1969                         break;
1970                 case EXOSIP_CALL_CLOSED:
1971                 case EXOSIP_CALL_CANCELLED:
1972                         ms_message("CALL_CLOSED or CANCELLED\n");
1973                         call_terminated(sal,ev);
1974                         break;
1975                 case EXOSIP_CALL_TIMEOUT:
1976                 case EXOSIP_CALL_NOANSWER:
1977                         ms_message("CALL_TIMEOUT or NOANSWER\n");
1978                         return call_failure(sal,ev);
1979                         break;
1980                 case EXOSIP_CALL_REQUESTFAILURE:
1981                 case EXOSIP_CALL_GLOBALFAILURE:
1982                 case EXOSIP_CALL_SERVERFAILURE:
1983                         ms_message("CALL_REQUESTFAILURE or GLOBALFAILURE or SERVERFAILURE\n");
1984                         return call_failure(sal,ev);
1985                         break;
1986                 case EXOSIP_CALL_RELEASED:
1987                         ms_message("CALL_RELEASED\n");
1988                         call_released(sal, ev);
1989                         break;
1990                 case EXOSIP_CALL_INVITE:
1991                         ms_message("CALL_NEW\n");
1992                         inc_new_call(sal,ev);
1993                         break;
1994                 case EXOSIP_CALL_REINVITE:
1995                         handle_reinvite(sal,ev);
1996                         break;
1997                 case EXOSIP_CALL_ACK:
1998                         ms_message("CALL_ACK");
1999                         handle_ack(sal,ev);
2000                         break;
2001                 case EXOSIP_CALL_REDIRECTED:
2002                         ms_message("CALL_REDIRECTED");
2003                         eXosip_default_action(ev);
2004                         break;
2005                 case EXOSIP_CALL_PROCEEDING:
2006                         ms_message("CALL_PROCEEDING");
2007                         call_proceeding(sal,ev);
2008                         break;
2009                 case EXOSIP_CALL_RINGING:
2010                         ms_message("CALL_RINGING");
2011                         call_ringing(sal,ev);
2012                         authentication_ok(sal,ev);
2013                         break;
2014                 case EXOSIP_CALL_MESSAGE_NEW:
2015                         ms_message("EXOSIP_CALL_MESSAGE_NEW");
2016                         call_message_new(sal,ev);
2017                         break;
2018                 case EXOSIP_CALL_MESSAGE_REQUESTFAILURE:
2019                         if (ev->response &&
2020                                 (ev->response->status_code==407 || ev->response->status_code==401)){
2021                                  return process_authentication(sal,ev);
2022                         }
2023                         break;
2024                 case EXOSIP_CALL_MESSAGE_ANSWERED:
2025                         ms_message("EXOSIP_CALL_MESSAGE_ANSWERED ");
2026                         process_in_call_reply(sal,ev);
2027                 break;
2028                 case EXOSIP_IN_SUBSCRIPTION_NEW:
2029                         ms_message("CALL_IN_SUBSCRIPTION_NEW ");
2030                         sal_exosip_subscription_recv(sal,ev);
2031                         break;
2032                 case EXOSIP_IN_SUBSCRIPTION_RELEASED:
2033                         ms_message("CALL_SUBSCRIPTION_NEW ");
2034                         sal_exosip_in_subscription_closed(sal,ev);
2035                         break;
2036                 case EXOSIP_SUBSCRIPTION_UPDATE:
2037                         ms_message("CALL_SUBSCRIPTION_UPDATE");
2038                         break;
2039                 case EXOSIP_SUBSCRIPTION_NOTIFY:
2040                         ms_message("CALL_SUBSCRIPTION_NOTIFY");
2041                         sal_exosip_notify_recv(sal,ev);
2042                         break;
2043                 case EXOSIP_SUBSCRIPTION_ANSWERED:
2044                         ms_message("EXOSIP_SUBSCRIPTION_ANSWERED, ev->sid=%i, ev->did=%i\n",ev->sid,ev->did);
2045                         sal_exosip_subscription_answered(sal,ev);
2046                         break;
2047                 case EXOSIP_SUBSCRIPTION_CLOSED:
2048                         ms_message("EXOSIP_SUBSCRIPTION_CLOSED\n");
2049                         sal_exosip_subscription_closed(sal,ev);
2050                         break;
2051                 case EXOSIP_SUBSCRIPTION_REQUESTFAILURE:   /**< announce a request failure      */
2052                         if (ev->response && (ev->response->status_code == 407 || ev->response->status_code == 401)){
2053                                 return process_authentication(sal,ev);
2054                         }
2055         case EXOSIP_SUBSCRIPTION_SERVERFAILURE:
2056                 case EXOSIP_SUBSCRIPTION_GLOBALFAILURE:
2057                         sal_exosip_subscription_closed(sal,ev);
2058                         break;
2059                 case EXOSIP_REGISTRATION_FAILURE:
2060                         ms_message("REGISTRATION_FAILURE\n");
2061                         return registration_failure(sal,ev);
2062                         break;
2063                 case EXOSIP_REGISTRATION_SUCCESS:
2064                         authentication_ok(sal,ev);
2065                         registration_success(sal,ev);
2066                         break;
2067                 case EXOSIP_MESSAGE_NEW:
2068                         other_request(sal,ev);
2069                         break;
2070                 case EXOSIP_MESSAGE_PROCEEDING:
2071                 case EXOSIP_MESSAGE_ANSWERED:
2072                 case EXOSIP_MESSAGE_REDIRECTED:
2073                 case EXOSIP_MESSAGE_SERVERFAILURE:
2074                 case EXOSIP_MESSAGE_GLOBALFAILURE:
2075                         other_request_reply(sal,ev);
2076                         break;
2077                 case EXOSIP_MESSAGE_REQUESTFAILURE:
2078                 case EXOSIP_NOTIFICATION_REQUESTFAILURE:
2079                         if (ev->response) {
2080                                 switch (ev->response->status_code) {
2081                                         case 407:
2082                                         case 401:
2083                                                 return process_authentication(sal,ev);
2084                                         case 412: {
2085                                                 eXosip_automatic_action ();
2086                                                 return 1;
2087                                         }
2088                                 }
2089                         }
2090                         other_request_reply(sal,ev);
2091                         break;
2092                 default:
2093                         ms_message("Unhandled exosip event ! %i",ev->type);
2094                         break;
2095         }
2096         return TRUE;
2097 }
2098
2099 int sal_iterate(Sal *sal){
2100         eXosip_event_t *ev;
2101         while((ev=eXosip_event_wait(0,0))!=NULL){
2102                 if (process_event(sal,ev))
2103                         eXosip_event_free(ev);
2104         }
2105 #ifdef HAVE_EXOSIP_TRYLOCK
2106         if (eXosip_trylock()==0){
2107                 eXosip_automatic_refresh();
2108                 eXosip_unlock();
2109         }else{
2110                 ms_warning("eXosip_trylock busy.");
2111         }
2112 #else
2113         eXosip_lock();
2114         eXosip_automatic_refresh();
2115         eXosip_unlock();
2116 #endif
2117         return 0;
2118 }
2119
2120 static void register_set_contact(osip_message_t *msg, const char *contact){
2121         osip_uri_param_t *param = NULL;
2122         osip_contact_t *ct=NULL;
2123         char *line=NULL;
2124         /*we get the line parameter choosed by exosip, and add it to our own contact*/
2125         osip_message_get_contact(msg,0,&ct);
2126         if (ct!=NULL){
2127                 osip_uri_uparam_get_byname(ct->url, "line", &param);
2128                 if (param && param->gvalue)
2129                         line=osip_strdup(param->gvalue);
2130         }
2131         _osip_list_set_empty(&msg->contacts,(void (*)(void*))osip_contact_free);
2132         osip_message_set_contact(msg,contact);
2133         osip_message_get_contact(msg,0,&ct);
2134         osip_uri_uparam_add(ct->url,osip_strdup("line"),line);
2135 }
2136
2137 static void sal_register_add_route(osip_message_t *msg, const char *proxy){
2138         char tmp[256]={0};
2139         snprintf(tmp,sizeof(tmp)-1,"<%s;lr>",proxy);
2140
2141         osip_list_special_free(&msg->routes,(void (*)(void*))osip_route_free);
2142         osip_message_set_route(msg,tmp);
2143 }
2144
2145 int sal_register(SalOp *h, const char *proxy, const char *from, int expires){
2146         osip_message_t *msg;
2147         const char *contact=sal_op_get_contact(h);
2148
2149         sal_op_set_route(h,proxy);
2150         if (h->rid==-1){
2151                 SalAddress *from_parsed=sal_address_new(from);
2152                 char domain[256];
2153                 if (from_parsed==NULL) {
2154                         ms_warning("sal_register() bad from %s",from);
2155                         return -1;
2156                 }
2157                 snprintf(domain,sizeof(domain),"sip:%s",sal_address_get_domain(from_parsed));
2158                 sal_address_destroy(from_parsed);
2159                 eXosip_lock();
2160                 h->rid=eXosip_register_build_initial_register(from,domain,NULL,expires,&msg);
2161                 if (msg){
2162                         if (contact) register_set_contact(msg,contact);
2163                         sal_register_add_route(msg,proxy);
2164                         sal_add_register(h->base.root,h);
2165                 }else{
2166                         ms_error("Could not build initial register.");
2167                         eXosip_unlock();
2168                         return -1;
2169                 }
2170         }else{
2171                 eXosip_lock();
2172                 eXosip_register_build_register(h->rid,expires,&msg);
2173                 sal_register_add_route(msg,proxy);
2174         }
2175         if (msg)
2176                 eXosip_register_send_register(h->rid,msg);
2177         eXosip_unlock();
2178         h->expires=expires;
2179         return (msg != NULL) ? 0 : -1;
2180 }
2181
2182 int sal_register_refresh(SalOp *op, int expires){
2183         osip_message_t *msg=NULL;
2184         const char *contact=sal_op_get_contact(op);
2185
2186         if (op->rid==-1){
2187                 ms_error("Unexistant registration context, not possible to refresh.");
2188                 return -1;
2189         }
2190         eXosip_lock();
2191         eXosip_register_build_register(op->rid,expires,&msg);
2192         if (msg!=NULL){
2193                 if (contact) register_set_contact(msg,contact);
2194                 sal_register_add_route(msg,sal_op_get_route(op));
2195                 eXosip_register_send_register(op->rid,msg);
2196         }else ms_error("Could not build REGISTER refresh message.");
2197         eXosip_unlock();
2198         return (msg != NULL) ? 0 : -1;
2199 }
2200
2201
2202 int sal_unregister(SalOp *h){
2203         osip_message_t *msg=NULL;
2204         eXosip_lock();
2205         eXosip_register_build_register(h->rid,0,&msg);
2206         if (msg) eXosip_register_send_register(h->rid,msg);
2207         else ms_warning("Could not build unREGISTER !");
2208         eXosip_unlock();
2209         return 0;
2210 }
2211
2212 SalAddress * sal_address_new(const char *uri){
2213         osip_from_t *from;
2214         osip_from_init(&from);
2215
2216         // Remove front spaces
2217         while (uri[0]==' ') {
2218                 uri++;
2219         }
2220
2221         if (osip_from_parse(from,uri)!=0){
2222                 osip_from_free(from);
2223                 return NULL;
2224         }
2225         if (from->displayname!=NULL && from->displayname[0]=='"'){
2226                 char *unquoted=osip_strdup_without_quote(from->displayname);
2227                 osip_free(from->displayname);
2228                 from->displayname=unquoted;
2229         }
2230         return (SalAddress*)from;
2231 }
2232
2233 SalAddress * sal_address_clone(const SalAddress *addr){
2234         osip_from_t *ret=NULL;
2235         osip_from_clone((osip_from_t*)addr,&ret);
2236         return (SalAddress*)ret;
2237 }
2238
2239 #define null_if_empty(s) (((s)!=NULL && (s)[0]!='\0') ? (s) : NULL )
2240
2241 const char *sal_address_get_scheme(const SalAddress *addr){
2242         const osip_from_t *u=(const osip_from_t*)addr;
2243         return null_if_empty(u->url->scheme);
2244 }
2245
2246 const char *sal_address_get_display_name(const SalAddress* addr){
2247         const osip_from_t *u=(const osip_from_t*)addr;
2248         return null_if_empty(u->displayname);
2249 }
2250
2251 const char *sal_address_get_username(const SalAddress *addr){
2252         const osip_from_t *u=(const osip_from_t*)addr;
2253         return null_if_empty(u->url->username);
2254 }
2255
2256 const char *sal_address_get_domain(const SalAddress *addr){
2257         const osip_from_t *u=(const osip_from_t*)addr;
2258         return null_if_empty(u->url->host);
2259 }
2260
2261 void sal_address_set_display_name(SalAddress *addr, const char *display_name){
2262         osip_from_t *u=(osip_from_t*)addr;
2263         if (u->displayname!=NULL){
2264                 osip_free(u->displayname);
2265                 u->displayname=NULL;
2266         }
2267         if (display_name!=NULL && display_name[0]!='\0'){
2268                 u->displayname=osip_strdup(display_name);
2269         }
2270 }
2271
2272 void sal_address_set_username(SalAddress *addr, const char *username){
2273         osip_from_t *uri=(osip_from_t*)addr;
2274         if (uri->url->username!=NULL){
2275                 osip_free(uri->url->username);
2276                 uri->url->username=NULL;
2277         }
2278         if (username)
2279                 uri->url->username=osip_strdup(username);
2280 }
2281
2282 void sal_address_set_domain(SalAddress *addr, const char *host){
2283         osip_from_t *uri=(osip_from_t*)addr;
2284         if (uri->url->host!=NULL){
2285                 osip_free(uri->url->host);
2286                 uri->url->host=NULL;
2287         }
2288         if (host)
2289                 uri->url->host=osip_strdup(host);
2290 }
2291
2292 void sal_address_set_port(SalAddress *addr, const char *port){
2293         osip_from_t *uri=(osip_from_t*)addr;
2294         if (uri->url->port!=NULL){
2295                 osip_free(uri->url->port);
2296                 uri->url->port=NULL;
2297         }
2298         if (port)
2299                 uri->url->port=osip_strdup(port);
2300 }
2301
2302 void sal_address_set_port_int(SalAddress *uri, int port){
2303         char tmp[12];
2304         if (port==5060){
2305                 /*this is the default, special case to leave the port field blank*/
2306                 sal_address_set_port(uri,NULL);
2307                 return;
2308         }
2309         snprintf(tmp,sizeof(tmp),"%i",port);
2310         sal_address_set_port(uri,tmp);
2311 }
2312
2313 void sal_address_clean(SalAddress *addr){
2314         osip_generic_param_freelist(& ((osip_from_t*)addr)->gen_params);
2315         osip_uri_param_freelist(& ((osip_from_t*)addr)->url->url_params);
2316 }
2317
2318 char *sal_address_as_string(const SalAddress *u){
2319         char *tmp,*ret;
2320         osip_from_t *from=(osip_from_t *)u;
2321         char *old_displayname=NULL;
2322         /* hack to force use of quotes around the displayname*/
2323         if (from->displayname!=NULL
2324             && from->displayname[0]!='"'){
2325                 old_displayname=from->displayname;
2326                 from->displayname=osip_enquote(from->displayname);
2327         }
2328         osip_from_to_str(from,&tmp);
2329         if (old_displayname!=NULL){
2330                 ms_free(from->displayname);
2331                 from->displayname=old_displayname;
2332         }
2333         ret=ms_strdup(tmp);
2334         osip_free(tmp);
2335         return ret;
2336 }
2337
2338 char *sal_address_as_string_uri_only(const SalAddress *u){
2339         char *tmp=NULL,*ret;
2340         osip_uri_to_str(((osip_from_t*)u)->url,&tmp);
2341         ret=ms_strdup(tmp);
2342         osip_free(tmp);
2343         return ret;
2344 }
2345 void sal_address_set_param(SalAddress *u,const char* name,const char* value) {
2346         osip_uri_param_t *param=NULL;
2347     osip_uri_uparam_get_byname(((osip_from_t*)u)->url,(char*)name,&param);
2348     if (param == NULL){
2349         osip_uri_uparam_add     (((osip_from_t*)u)->url,ms_strdup(name),value ? ms_strdup(value) : NULL);
2350     } else {
2351         osip_free(param->gvalue);
2352         param->gvalue=value ? osip_strdup(value) : NULL;
2353     }
2354
2355 }
2356
2357 void sal_address_destroy(SalAddress *u){
2358         osip_from_free((osip_from_t*)u);
2359 }
2360
2361 void sal_set_keepalive_period(Sal *ctx,unsigned int value) {
2362         ctx->keepalive_period=value;
2363         eXosip_set_option (EXOSIP_OPT_UDP_KEEP_ALIVE, &value);
2364 }
2365 unsigned int sal_get_keepalive_period(Sal *ctx) {
2366         return ctx->keepalive_period;
2367 }
2368
2369 const char * sal_address_get_port(const SalAddress *addr) {
2370         const osip_from_t *u=(const osip_from_t*)addr;
2371         return null_if_empty(u->url->port);
2372 }
2373
2374 int sal_address_get_port_int(const SalAddress *uri) {
2375         const char* port = sal_address_get_port(uri);
2376         if (port != NULL) {
2377                 return atoi(port);
2378         } else {
2379                 return 5060;
2380         }
2381 }
2382 SalTransport sal_address_get_transport(const SalAddress* addr) {
2383     const osip_from_t *u=(const osip_from_t*)addr;
2384     osip_uri_param_t *transport_param=NULL;
2385     osip_uri_uparam_get_byname(u->url,"transport",&transport_param);
2386     if (transport_param == NULL){
2387         return SalTransportUDP;
2388     }  else {
2389         return sal_transport_parse(transport_param->gvalue);
2390     }
2391 }
2392 void sal_address_set_transport(SalAddress* addr,SalTransport transport) {
2393     sal_address_set_param(addr, "transport", sal_transport_to_string(transport));
2394 }
2395
2396 /* sends a reinvite. Local media description may have changed by application since call establishment*/
2397 int sal_call_update(SalOp *h, const char *subject){
2398         int err=0;
2399         osip_message_t *reinvite=NULL;
2400
2401         eXosip_lock();
2402         if(eXosip_call_build_request(h->did,"INVITE",&reinvite) != 0 || reinvite==NULL){
2403                 eXosip_unlock();
2404                 return -1;
2405         }
2406         eXosip_unlock();
2407         osip_message_set_subject(reinvite,subject);
2408         osip_message_set_allow(reinvite, "INVITE, ACK, CANCEL, OPTIONS, BYE, REFER, NOTIFY, MESSAGE, SUBSCRIBE, INFO");
2409         if (h->base.contact){
2410                 _osip_list_set_empty(&reinvite->contacts,(void (*)(void*))osip_contact_free);
2411                 osip_message_set_contact(reinvite,h->base.contact);
2412         }
2413         if (h->base.root->session_expires!=0){
2414                 osip_message_set_header(reinvite, "Session-expires", "200");
2415                 osip_message_set_supported(reinvite, "timer");
2416         }
2417         if (h->base.local_media){
2418                 h->sdp_offering=TRUE;
2419                 set_sdp_from_desc(reinvite,h->base.local_media);
2420         }else h->sdp_offering=FALSE;
2421         eXosip_lock();
2422         err = eXosip_call_send_request(h->did, reinvite);
2423         eXosip_unlock();
2424         return err;
2425 }
2426 void sal_reuse_authorization(Sal *ctx, bool_t value) {
2427         ctx->reuse_authorization=value;
2428 }