sjero.net Git - linphone/blob - coreapi/sal_eXosip2.c

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