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