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