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