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