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

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