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