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