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
 808         /*FIXME exosip does not take into account this update register message*/
 809         /*
 810         if (fix_message_contact(h, h->pending_auth->request,h->pending_auth->response)) {
 811
 812         };
 813         */
 814                 update_contact_from_response(h,h->pending_auth->response);
 815                 eXosip_lock();
 816                 eXosip_default_action(h->pending_auth);
 817                 eXosip_unlock();
 818                 ms_message("eXosip_default_action() done");
 819                 pop_auth_from_exosip();
 820
 821                 if (h->auth_info) sal_auth_info_delete(h->auth_info); /*if already exist*/
 822                 h->auth_info=sal_auth_info_clone(info); /*store auth info for subsequent request*/
 823         }
 824 }
 825 void sal_op_cancel_authentication(SalOp *h) {
 826         if (h->rid >0) {
 827                 sal_op_get_sal(h)->callbacks.register_failure(h,SalErrorFailure, SalReasonForbidden,_("Authentication failure"));
 828         } else if (h->cid >0) {
 829                 sal_op_get_sal(h)->callbacks.call_failure(h,SalErrorFailure, SalReasonForbidden,_("Authentication failure"),0);
 830         } else {
 831                 ms_warning("Auth failure not handled");
 832         }
 833
 834 }
 835 static void set_network_origin(SalOp *op, osip_message_t *req){
 836         const char *received=NULL;
 837         int rport=5060;
 838         char origin[64];
 839     SalTransport transport;
 840         if (extract_received_rport(req,&received,&rport,&transport)!=0){
 841                 osip_via_t *via=NULL;
 842                 char *tmp;
 843                 osip_message_get_via(req,0,&via);
 844                 received=osip_via_get_host(via);
 845                 tmp=osip_via_get_port(via);
 846                 if (tmp) rport=atoi(tmp);
 847         }
 848     if (transport != SalTransportUDP) {
 849         snprintf(origin,sizeof(origin)-1,"sip:%s:%i",received,rport);
 850     } else {
 851        snprintf(origin,sizeof(origin)-1,"sip:%s:%i;transport=%s",received,rport,sal_transport_to_string(transport));
 852     }
 853         __sal_op_set_network_origin(op,origin);
 854 }
 855
 856 static void set_remote_ua(SalOp* op, osip_message_t *req){
 857         if (op->base.remote_ua==NULL){
 858                 osip_header_t *h=NULL;
 859                 osip_message_get_user_agent(req,0,&h);
 860                 if (h){
 861                         op->base.remote_ua=ms_strdup(h->hvalue);
 862                 }
 863         }
 864 }
 865
 866 static void set_replaces(SalOp *op, osip_message_t *req){
 867         osip_header_t *h=NULL;
 868
 869         if (op->replaces){
 870                 ms_free(op->replaces);
 871                 op->replaces=NULL;
 872         }
 873         osip_message_header_get_byname(req,"replaces",0,&h);
 874         if (h){
 875                 if (h->hvalue && h->hvalue[0]!='\0'){
 876                         op->replaces=ms_strdup(h->hvalue);
 877                 }
 878         }
 879 }
 880
 881 static SalOp *find_op(Sal *sal, eXosip_event_t *ev){
 882         if (ev->cid>0){
 883                 return sal_find_call(sal,ev->cid);
 884         }
 885         if (ev->rid>0){
 886                 return sal_find_register(sal,ev->rid);
 887         }
 888         if (ev->sid>0){
 889                 return sal_find_out_subscribe(sal,ev->sid);
 890         }
 891         if (ev->nid>0){
 892                 return sal_find_in_subscribe(sal,ev->nid);
 893         }
 894         if (ev->response) return sal_find_other(sal,ev->response);
 895         return NULL;
 896 }
 897
 898 static void inc_new_call(Sal *sal, eXosip_event_t *ev){
 899         SalOp *op=sal_op_new(sal);
 900         osip_from_t *from,*to;
 901         osip_call_info_t *call_info;
 902         char *tmp;
 903         sdp_message_t *sdp=eXosip_get_sdp_info(ev->request);
 904
 905         set_network_origin(op,ev->request);
 906         set_remote_ua(op,ev->request);
 907         set_replaces(op,ev->request);
 908
 909         if (sdp){
 910                 op->sdp_offering=FALSE;
 911                 op->base.remote_media=sal_media_description_new();
 912                 sdp_to_media_description(sdp,op->base.remote_media);
 913                 sdp_message_free(sdp);
 914         }else op->sdp_offering=TRUE;
 915
 916         from=osip_message_get_from(ev->request);
 917         to=osip_message_get_to(ev->request);
 918         osip_from_to_str(from,&tmp);
 919         sal_op_set_from(op,tmp);
 920         osip_free(tmp);
 921         osip_from_to_str(to,&tmp);
 922         sal_op_set_to(op,tmp);
 923         osip_free(tmp);
 924
 925         osip_message_get_call_info(ev->request,0,&call_info);
 926         if(call_info)
 927         {
 928                 osip_call_info_to_str(call_info,&tmp);
 929                 if( strstr(tmp,"answer-after=") != NULL)
 930                 {
 931                         op->auto_answer_asked=TRUE;
 932                         ms_message("The caller asked to automatically answer the call(Emergency?)\n");
 933                 }
 934                 osip_free(tmp);
 935         }
 936
 937         op->tid=ev->tid;
 938         op->cid=ev->cid;
 939         op->did=ev->did;
 940
 941         sal_add_call(op->base.root,op);
 942         sal->callbacks.call_received(op);
 943 }
 944
 945 static void handle_reinvite(Sal *sal,  eXosip_event_t *ev){
 946         SalOp *op=find_op(sal,ev);
 947         sdp_message_t *sdp;
 948         osip_message_t *msg=NULL;
 949
 950         if (op==NULL) {
 951                 ms_warning("Reinvite for non-existing operation !");
 952                 return;
 953         }
 954         op->reinvite=TRUE;
 955         op->tid=ev->tid;
 956         sdp=eXosip_get_sdp_info(ev->request);
 957         if (op->base.remote_media){
 958                 sal_media_description_unref(op->base.remote_media);
 959                 op->base.remote_media=NULL;
 960         }
 961         if (op->result){
 962                 sal_media_description_unref(op->result);
 963                 op->result=NULL;
 964         }
 965         if (sdp){
 966                 op->sdp_offering=FALSE;
 967                 op->base.remote_media=sal_media_description_new();
 968                 sdp_to_media_description(sdp,op->base.remote_media);
 969                 sdp_message_free(sdp);
 970                 sal->callbacks.call_updating(op);
 971         }else {
 972                 op->sdp_offering=TRUE;
 973                 eXosip_lock();
 974                 eXosip_call_build_answer(ev->tid,200,&msg);
 975                 if (msg!=NULL){
 976                         set_sdp_from_desc(msg,op->base.local_media);
 977                         eXosip_call_send_answer(ev->tid,200,msg);
 978                 }
 979                 eXosip_unlock();
 980         }
 981
 982 }
 983
 984 static void handle_ack(Sal *sal,  eXosip_event_t *ev){
 985         SalOp *op=find_op(sal,ev);
 986         sdp_message_t *sdp;
 987
 988         if (op==NULL) {
 989                 ms_warning("ack for non-existing call !");
 990                 return;
 991         }
 992         sdp=eXosip_get_sdp_info(ev->ack);
 993         if (sdp){
 994                 op->base.remote_media=sal_media_description_new();
 995                 sdp_to_media_description(sdp,op->base.remote_media);
 996                 sdp_process(op);
 997                 sdp_message_free(sdp);
 998         }
 999         if (op->reinvite){
1000                 if (sdp) sal->callbacks.call_updating(op);
1001                 op->reinvite=FALSE;
1002         }else{
1003                 sal->callbacks.call_ack(op);
1004         }
1005 }
1006
1007 static void update_contact_from_response(SalOp *op, osip_message_t *response){
1008         const char *received;
1009         int rport;
1010         SalTransport transport;
1011         if (extract_received_rport(response,&received,&rport,&transport)==0){
1012                 const char *contact=sal_op_get_contact(op);
1013                 if (!contact){
1014                         /*no contact given yet, use from instead*/
1015                         contact=sal_op_get_from(op);
1016                 }
1017                 if (contact){
1018                         SalAddress *addr=sal_address_new(contact);
1019                         char *tmp;
1020                         sal_address_set_domain(addr,received);
1021                         sal_address_set_port_int(addr,rport);
1022                         sal_address_set_transport(addr,transport);
1023                         tmp=sal_address_as_string(addr);
1024                         ms_message("Contact address updated to %s",tmp);
1025                         sal_op_set_contact(op,tmp);
1026                         sal_address_destroy(addr);
1027                         ms_free(tmp);
1028                 }
1029         }
1030 }
1031
1032 static int call_proceeding(Sal *sal, eXosip_event_t *ev){
1033         SalOp *op=find_op(sal,ev);
1034
1035         if (op==NULL || op->terminated==TRUE) {
1036                 ms_warning("This call has been canceled.");
1037                 eXosip_lock();
1038                 eXosip_call_terminate(ev->cid,ev->did);
1039                 eXosip_unlock();
1040                 return -1;
1041         }
1042         if (ev->did>0)
1043                 op->did=ev->did;
1044         op->tid=ev->tid;
1045
1046         /* update contact if received and rport are set by the server
1047          note: will only be used by remote for next INVITE, if any...*/
1048         update_contact_from_response(op,ev->response);
1049         return 0;
1050 }
1051
1052 static void call_ringing(Sal *sal, eXosip_event_t *ev){
1053         sdp_message_t *sdp;
1054         SalOp *op=find_op(sal,ev);
1055         if (call_proceeding(sal, ev)==-1) return;
1056
1057         set_remote_ua(op,ev->response);
1058         sdp=eXosip_get_sdp_info(ev->response);
1059         if (sdp){
1060                 op->base.remote_media=sal_media_description_new();
1061                 sdp_to_media_description(sdp,op->base.remote_media);
1062                 sdp_message_free(sdp);
1063                 if (op->base.local_media) sdp_process(op);
1064         }
1065         sal->callbacks.call_ringing(op);
1066 }
1067
1068 static void call_accepted(Sal *sal, eXosip_event_t *ev){
1069         sdp_message_t *sdp;
1070         osip_message_t *msg=NULL;
1071         SalOp *op=find_op(sal,ev);
1072         const char *contact;
1073
1074         if (op==NULL || op->terminated==TRUE) {
1075                 ms_warning("This call has been already terminated.");
1076                 eXosip_lock();
1077                 eXosip_call_terminate(ev->cid,ev->did);
1078                 eXosip_unlock();
1079                 return ;
1080         }
1081
1082         op->did=ev->did;
1083         set_remote_ua(op,ev->response);
1084
1085         sdp=eXosip_get_sdp_info(ev->response);
1086         if (sdp){
1087                 op->base.remote_media=sal_media_description_new();
1088                 sdp_to_media_description(sdp,op->base.remote_media);
1089                 sdp_message_free(sdp);
1090                 if (op->base.local_media) sdp_process(op);
1091         }
1092         eXosip_call_build_ack(ev->did,&msg);
1093         contact=sal_op_get_contact(op);
1094         if (contact) {
1095                 _osip_list_set_empty(&msg->contacts,(void (*)(void*))osip_contact_free);
1096                 osip_message_set_contact(msg,contact);
1097         }
1098         if (op->sdp_answer){
1099                 set_sdp(msg,op->sdp_answer);
1100                 sdp_message_free(op->sdp_answer);
1101                 op->sdp_answer=NULL;
1102         }
1103         eXosip_call_send_ack(ev->did,msg);
1104         sal->callbacks.call_accepted(op);
1105 }
1106
1107 static void call_terminated(Sal *sal, eXosip_event_t *ev){
1108         char *from=NULL;
1109         SalOp *op=find_op(sal,ev);
1110         if (op==NULL){
1111                 ms_warning("Call terminated for already closed call ?");
1112                 return;
1113         }
1114         if (ev->request){
1115                 osip_from_to_str(ev->request->from,&from);
1116         }
1117         sal->callbacks.call_terminated(op,from!=NULL ? from : sal_op_get_from(op));
1118         if (from) osip_free(from);
1119         op->terminated=TRUE;
1120 }
1121
1122 static void call_released(Sal *sal, eXosip_event_t *ev){
1123         SalOp *op=find_op(sal,ev);
1124         if (op==NULL){
1125                 ms_warning("No op associated to this call_released()");
1126                 return;
1127         }
1128         if (!op->terminated){
1129                 /* no response received so far */
1130                 call_failure(sal,ev);
1131         }
1132         sal->callbacks.call_released(op);
1133 }
1134
1135 static int get_auth_data_from_response(osip_message_t *resp, const char **realm, const char **username){
1136         const char *prx_realm=NULL,*www_realm=NULL;
1137         osip_proxy_authenticate_t *prx_auth;
1138         osip_www_authenticate_t *www_auth;
1139
1140         *username=osip_uri_get_username(resp->from->url);
1141         prx_auth=(osip_proxy_authenticate_t*)osip_list_get(&resp->proxy_authenticates,0);
1142         www_auth=(osip_proxy_authenticate_t*)osip_list_get(&resp->www_authenticates,0);
1143         if (prx_auth!=NULL)
1144                 prx_realm=osip_proxy_authenticate_get_realm(prx_auth);
1145         if (www_auth!=NULL)
1146                 www_realm=osip_www_authenticate_get_realm(www_auth);
1147
1148         if (prx_realm){
1149                 *realm=prx_realm;
1150         }else if (www_realm){
1151                 *realm=www_realm;
1152         }else{
1153                 return -1;
1154         }
1155         return 0;
1156 }
1157
1158 static int get_auth_data_from_request(osip_message_t *msg, const char **realm, const char **username){
1159         osip_authorization_t *auth=NULL;
1160         osip_proxy_authorization_t *prx_auth=NULL;
1161
1162         *username=osip_uri_get_username(msg->from->url);
1163         osip_message_get_authorization(msg, 0, &auth);
1164         if (auth){
1165                 *realm=osip_authorization_get_realm(auth);
1166                 return 0;
1167         }
1168         osip_message_get_proxy_authorization(msg,0,&prx_auth);
1169         if (prx_auth){
1170                 *realm=osip_proxy_authorization_get_realm(prx_auth);
1171                 return 0;
1172         }
1173         return -1;
1174 }
1175
1176 static int get_auth_data(eXosip_event_t *ev, const char **realm, const char **username){
1177         if (ev->response && get_auth_data_from_response(ev->response,realm,username)==0) return 0;
1178         if (ev->request && get_auth_data_from_request(ev->request,realm,username)==0) return 0;
1179         return -1;
1180 }
1181
1182 int sal_op_get_auth_requested(SalOp *op, const char **realm, const char **username){
1183         if (op->pending_auth){
1184                 return get_auth_data(op->pending_auth,realm,username);
1185         }
1186         return -1;
1187 }
1188
1189 static bool_t process_authentication(Sal *sal, eXosip_event_t *ev){
1190         SalOp *op;
1191         const char *username,*realm;
1192         op=find_op(sal,ev);
1193         if (op==NULL){
1194                 ms_warning("No operation associated with this authentication !");
1195                 return TRUE;
1196         }
1197         if (get_auth_data(ev,&realm,&username)==0){
1198                 if (op->pending_auth!=NULL){
1199                         eXosip_event_free(op->pending_auth);
1200                         op->pending_auth=ev;
1201                 }else{
1202                         op->pending_auth=ev;
1203                         sal_add_pending_auth(sal,op);
1204                 }
1205
1206                 sal->callbacks.auth_requested(op,realm,username);
1207                 return FALSE;
1208         }
1209         return TRUE;
1210 }
1211
1212 static void authentication_ok(Sal *sal, eXosip_event_t *ev){
1213         SalOp *op;
1214         const char *username,*realm;
1215         op=find_op(sal,ev);
1216         if (op==NULL){
1217                 ms_warning("No operation associated with this authentication_ok!");
1218                 return ;
1219         }
1220         if (op->pending_auth){
1221                 eXosip_event_free(op->pending_auth);
1222                 sal_remove_pending_auth(sal,op);
1223                 op->pending_auth=NULL;
1224         }
1225         if (get_auth_data(ev,&realm,&username)==0){
1226                 sal->callbacks.auth_success(op,realm,username);
1227         }
1228 }
1229
1230 static bool_t call_failure(Sal *sal, eXosip_event_t *ev){
1231         SalOp *op;
1232         int code=0;
1233         char* computedReason=NULL;
1234         const char *reason=NULL;
1235         SalError error=SalErrorUnknown;
1236         SalReason sr=SalReasonUnknown;
1237
1238
1239         op=(SalOp*)find_op(sal,ev);
1240
1241         if (op==NULL) {
1242                 ms_warning("Call failure reported for a closed call, ignored.");
1243                 return TRUE;
1244         }
1245
1246         if (ev->response){
1247                 code=osip_message_get_status_code(ev->response);
1248                 reason=osip_message_get_reason_phrase(ev->response);
1249                 osip_header_t *h=NULL;
1250                 if (!osip_message_header_get_byname(    ev->response
1251                                                                                         ,"Reason"
1252                                                                                         ,0
1253                                                                                         ,&h)) {
1254                         computedReason = ms_strdup_printf("%s %s",reason,osip_header_get_value(h));
1255                         reason = computedReason;
1256
1257                 }
1258         }
1259         switch(code)
1260         {
1261                 case 401:
1262                 case 407:
1263                         return process_authentication(sal,ev);
1264                         break;
1265                 case 400:
1266                         error=SalErrorUnknown;
1267                 break;
1268                 case 404:
1269                         error=SalErrorFailure;
1270                         sr=SalReasonNotFound;
1271                 break;
1272                 case 415:
1273                         error=SalErrorFailure;
1274                         sr=SalReasonMedia;
1275                 break;
1276                 case 422:
1277                         eXosip_default_action(ev);
1278                         return TRUE;
1279                 break;
1280                 case 480:
1281                         error=SalErrorFailure;
1282                         sr=SalReasonTemporarilyUnavailable;
1283                 case 486:
1284                         error=SalErrorFailure;
1285                         sr=SalReasonBusy;
1286                 break;
1287                 case 487:
1288                 break;
1289                 case 600:
1290                         error=SalErrorFailure;
1291                         sr=SalReasonDoNotDisturb;
1292                 break;
1293                 case 603:
1294                         error=SalErrorFailure;
1295                         sr=SalReasonDeclined;
1296                 break;
1297                 default:
1298                         if (code>0){
1299                                 error=SalErrorFailure;
1300                                 sr=SalReasonUnknown;
1301                         }else error=SalErrorNoResponse;
1302         }
1303         op->terminated=TRUE;
1304         sal->callbacks.call_failure(op,error,sr,reason,code);
1305         if (computedReason != NULL){
1306                 ms_free(computedReason);
1307         }
1308         return TRUE;
1309 }
1310
1311 /* Request remote side to send us VFU */
1312 void sal_call_send_vfu_request(SalOp *h){
1313         osip_message_t *msg=NULL;
1314         char info_body[] =
1315                         "<?xml version=\"1.0\" encoding=\"utf-8\" ?>"
1316                          "<media_control>"
1317                          "  <vc_primitive>"
1318                          "    <to_encoder>"
1319                          "      <picture_fast_update></picture_fast_update>"
1320                          "    </to_encoder>"
1321                          "  </vc_primitive>"
1322                          "</media_control>";
1323
1324         char clen[10];
1325
1326         eXosip_lock();
1327         eXosip_call_build_info(h->did,&msg);
1328         if (msg){
1329                 osip_message_set_body(msg,info_body,strlen(info_body));
1330                 osip_message_set_content_type(msg,"application/media_control+xml");
1331                 snprintf(clen,sizeof(clen),"%lu",(unsigned long)strlen(info_body));
1332                 osip_message_set_content_length(msg,clen);
1333                 eXosip_call_send_request(h->did,msg);
1334                 ms_message("Sending VFU request !");
1335         }
1336         eXosip_unlock();
1337 }
1338
1339 static void process_media_control_xml(Sal *sal, eXosip_event_t *ev){
1340         SalOp *op=find_op(sal,ev);
1341         osip_body_t *body=NULL;
1342
1343         if (op==NULL){
1344                 ms_warning("media control xml received without operation context!");
1345                 return ;
1346         }
1347
1348         osip_message_get_body(ev->request,0,&body);
1349         if (body && body->body!=NULL &&
1350                 strstr(body->body,"picture_fast_update")){
1351                 osip_message_t *ans=NULL;
1352                 ms_message("Receiving VFU request !");
1353                 if (sal->callbacks.vfu_request){
1354                         sal->callbacks.vfu_request(op);
1355                         eXosip_call_build_answer(ev->tid,200,&ans);
1356                         if (ans)
1357                                 eXosip_call_send_answer(ev->tid,200,ans);
1358                         return;
1359                 }
1360         }
1361         /*in all other cases we must say it is not implemented.*/
1362         {
1363                 osip_message_t *ans=NULL;
1364                 eXosip_lock();
1365                 eXosip_call_build_answer(ev->tid,501,&ans);
1366                 if (ans)
1367                         eXosip_call_send_answer(ev->tid,501,ans);
1368                 eXosip_unlock();
1369         }
1370 }
1371
1372 static void process_dtmf_relay(Sal *sal, eXosip_event_t *ev){
1373         SalOp *op=find_op(sal,ev);
1374         osip_body_t *body=NULL;
1375
1376         if (op==NULL){
1377                 ms_warning("media dtmf relay received without operation context!");
1378                 return ;
1379         }
1380
1381         osip_message_get_body(ev->request,0,&body);
1382         if (body && body->body!=NULL){
1383                 osip_message_t *ans=NULL;
1384                 const char *name=strstr(body->body,"Signal");
1385                 if (name==NULL) name=strstr(body->body,"signal");
1386                 if (name==NULL) {
1387                         ms_warning("Could not extract the dtmf name from the SIP INFO.");
1388                 }else{
1389                         char tmp[2];
1390                         name+=strlen("signal");
1391                         if (sscanf(name," = %1s",tmp)==1){
1392                                 ms_message("Receiving dtmf %s via SIP INFO.",tmp);
1393                                 if (sal->callbacks.dtmf_received != NULL)
1394                                         sal->callbacks.dtmf_received(op, tmp[0]);
1395                         }
1396                 }
1397                 eXosip_lock();
1398                 eXosip_call_build_answer(ev->tid,200,&ans);
1399                 if (ans)
1400                         eXosip_call_send_answer(ev->tid,200,ans);
1401                 eXosip_unlock();
1402         }
1403 }
1404
1405 static void fill_options_answer(osip_message_t *options){
1406         osip_message_set_allow(options,"INVITE, ACK, BYE, CANCEL, OPTIONS, MESSAGE, SUBSCRIBE, NOTIFY, INFO");
1407         osip_message_set_accept(options,"application/sdp");
1408 }
1409
1410 static void process_refer(Sal *sal, SalOp *op, eXosip_event_t *ev){
1411         osip_header_t *h=NULL;
1412         osip_message_t *ans=NULL;
1413         ms_message("Receiving REFER request !");
1414         osip_message_header_get_byname(ev->request,"Refer-To",0,&h);
1415
1416         if (h){
1417                 osip_from_t *from=NULL;
1418                 char *tmp;
1419                 osip_from_init(&from);
1420
1421                 if (osip_from_parse(from,h->hvalue)==0){
1422                         if (op ){
1423                                 osip_uri_header_t *uh=NULL;
1424                                 osip_header_t *referred_by=NULL;
1425                                 osip_uri_header_get_byname(&from->url->url_headers,(char*)"Replaces",&uh);
1426                                 if (uh!=NULL && uh->gvalue && uh->gvalue[0]!='\0'){
1427                                         ms_message("Found replaces in Refer-To");
1428                                         if (op->replaces){
1429                                                 ms_free(op->replaces);
1430                                         }
1431                                         op->replaces=ms_strdup(uh->gvalue);
1432                                 }
1433                                 osip_message_header_get_byname(ev->request,"Referred-By",0,&referred_by);
1434                                 if (referred_by && referred_by->hvalue && referred_by->hvalue[0]!='\0'){
1435                                         if (op->referred_by)
1436                                                 ms_free(op->referred_by);
1437                                         op->referred_by=ms_strdup(referred_by->hvalue);
1438                                 }
1439                         }
1440                         osip_uri_header_freelist(&from->url->url_headers);
1441                         osip_from_to_str(from,&tmp);
1442                         sal->callbacks.refer_received(sal,op,tmp);
1443                         osip_free(tmp);
1444                         osip_from_free(from);
1445                 }
1446                 eXosip_lock();
1447                 eXosip_call_build_answer(ev->tid,202,&ans);
1448                 if (ans)
1449                         eXosip_call_send_answer(ev->tid,202,ans);
1450                 eXosip_unlock();
1451         }
1452         else
1453         {
1454                 ms_warning("cannot do anything with the refer without destination\n");
1455         }
1456 }
1457
1458 static void call_message_new(Sal *sal, eXosip_event_t *ev){
1459         osip_message_t *ans=NULL;
1460         if (ev->request){
1461                 if (MSG_IS_INFO(ev->request)){
1462                         osip_content_type_t *ct;
1463                         ct=osip_message_get_content_type(ev->request);
1464                         if (ct && ct->subtype){
1465                                 if (strcmp(ct->subtype,"media_control+xml")==0)
1466                                         process_media_control_xml(sal,ev);
1467                                 else if (strcmp(ct->subtype,"dtmf-relay")==0)
1468                                         process_dtmf_relay(sal,ev);
1469                                 else {
1470                                         ms_message("Unhandled SIP INFO.");
1471                                         /*send an "Not implemented" answer*/
1472                                         eXosip_lock();
1473                                         eXosip_call_build_answer(ev->tid,501,&ans);
1474                                         if (ans)
1475                                                 eXosip_call_send_answer(ev->tid,501,ans);
1476                                         eXosip_unlock();
1477                                 }
1478                         }else{
1479                                 /*empty SIP INFO, probably to test we are alive. Send an empty answer*/
1480                                 eXosip_lock();
1481                                 eXosip_call_build_answer(ev->tid,200,&ans);
1482                                 if (ans)
1483                                         eXosip_call_send_answer(ev->tid,200,ans);
1484                                 eXosip_unlock();
1485                         }
1486                 }else if(MSG_IS_MESSAGE(ev->request)){
1487                         /* SIP messages could be received into call */
1488                         text_received(sal, ev);
1489                         eXosip_lock();
1490                         eXosip_call_build_answer(ev->tid,200,&ans);
1491                         if (ans)
1492                                 eXosip_call_send_answer(ev->tid,200,ans);
1493                         eXosip_unlock();
1494                 }else if(MSG_IS_REFER(ev->request)){
1495                         SalOp *op=find_op(sal,ev);
1496
1497                         ms_message("Receiving REFER request !");
1498                         process_refer(sal,op,ev);
1499                 }else if(MSG_IS_NOTIFY(ev->request)){
1500                         osip_header_t *h=NULL;
1501                         char *from=NULL;
1502                         SalOp *op=find_op(sal,ev);
1503
1504                         ms_message("Receiving NOTIFY request !");
1505                         osip_from_to_str(ev->request->from,&from);
1506                         osip_message_header_get_byname(ev->request,"Event",0,&h);
1507                         if(h)
1508                                 sal->callbacks.notify(op,from,h->hvalue);
1509                         /*answer that we received the notify*/
1510                         eXosip_lock();
1511                         eXosip_call_build_answer(ev->tid,200,&ans);
1512                         if (ans)
1513                                 eXosip_call_send_answer(ev->tid,200,ans);
1514                         eXosip_unlock();
1515                         osip_free(from);
1516                 }else if (MSG_IS_OPTIONS(ev->request)){
1517                         eXosip_lock();
1518                         eXosip_call_build_answer(ev->tid,200,&ans);
1519                         if (ans){
1520                                 fill_options_answer(ans);
1521                                 eXosip_call_send_answer(ev->tid,200,ans);
1522                         }
1523                         eXosip_unlock();
1524                 }
1525         }else ms_warning("call_message_new: No request ?");
1526 }
1527
1528 static void inc_update(Sal *sal, eXosip_event_t *ev){
1529         osip_message_t *msg=NULL;
1530         ms_message("Processing incoming UPDATE");
1531         eXosip_lock();
1532         eXosip_message_build_answer(ev->tid,200,&msg);
1533         if (msg!=NULL)
1534                 eXosip_message_send_answer(ev->tid,200,msg);
1535         eXosip_unlock();
1536 }
1537
1538 static bool_t comes_from_local_if(osip_message_t *msg){
1539         osip_via_t *via=NULL;
1540         osip_message_get_via(msg,0,&via);
1541         if (via){
1542                 const char *host;
1543                 host=osip_via_get_host(via);
1544                 if (strcmp(host,"127.0.0.1")==0 || strcmp(host,"::1")==0){
1545                         osip_generic_param_t *param=NULL;
1546                         osip_via_param_get_byname(via,"received",&param);
1547                         if (param==NULL) return TRUE;
1548                         if (param->gvalue &&
1549                                 (strcmp(param->gvalue,"127.0.0.1")==0 || strcmp(param->gvalue,"::1")==0)){
1550                                 return TRUE;
1551                         }
1552                 }
1553         }
1554         return FALSE;
1555 }
1556
1557 static void text_received(Sal *sal, eXosip_event_t *ev){
1558         osip_body_t *body=NULL;
1559         char *from=NULL,*msg;
1560
1561         osip_message_get_body(ev->request,0,&body);
1562         if (body==NULL){
1563                 ms_error("Could not get text message from SIP body");
1564                 return;
1565         }
1566         msg=body->body;
1567         osip_from_to_str(ev->request->from,&from);
1568         sal->callbacks.text_received(sal,from,msg);
1569         osip_free(from);
1570 }
1571
1572
1573
1574 static void other_request(Sal *sal, eXosip_event_t *ev){
1575         ms_message("in other_request");
1576         if (ev->request==NULL) return;
1577         if (strcmp(ev->request->sip_method,"MESSAGE")==0){
1578                 text_received(sal,ev);
1579                 eXosip_message_send_answer(ev->tid,200,NULL);
1580         }else if (strcmp(ev->request->sip_method,"OPTIONS")==0){
1581                 osip_message_t *options=NULL;
1582                 eXosip_options_build_answer(ev->tid,200,&options);
1583                 fill_options_answer(options);
1584                 eXosip_options_send_answer(ev->tid,200,options);
1585         }else if (strcmp(ev->request->sip_method,"WAKEUP")==0
1586                 && comes_from_local_if(ev->request)) {
1587                 eXosip_message_send_answer(ev->tid,200,NULL);
1588                 ms_message("Receiving WAKEUP request !");
1589                 sal->callbacks.internal_message(sal,"WAKEUP");
1590         }else if (strncmp(ev->request->sip_method, "REFER", 5) == 0){
1591                 ms_message("Receiving REFER request !");
1592                 if (comes_from_local_if(ev->request)) {
1593                         process_refer(sal,NULL,ev);
1594                 }else ms_warning("Ignored REFER not coming from this local loopback interface.");
1595         }else if (strncmp(ev->request->sip_method, "UPDATE", 6) == 0){
1596                 inc_update(sal,ev);
1597     }else {
1598                 char *tmp=NULL;
1599                 size_t msglen=0;
1600                 osip_message_to_str(ev->request,&tmp,&msglen);
1601                 if (tmp){
1602                         ms_message("Unsupported request received:\n%s",tmp);
1603                         osip_free(tmp);
1604                 }
1605                 /*answer with a 501 Not implemented*/
1606                 eXosip_message_send_answer(ev->tid,501,NULL);
1607         }
1608 }
1609
1610 static void masquerade_via(osip_message_t *msg, const char *ip, const char *port){
1611         osip_via_t *via=NULL;
1612         osip_message_get_via(msg,0,&via);
1613         if (via){
1614                 osip_free(via->port);
1615                 via->port=osip_strdup(port);
1616                 osip_free(via->host);
1617                 via->host=osip_strdup(ip);
1618         }
1619 }
1620
1621
1622 static bool_t fix_message_contact(SalOp *op, osip_message_t *request,osip_message_t *last_answer) {
1623         osip_contact_t *ctt=NULL;
1624         const char *received;
1625         int rport;
1626         SalTransport transport;
1627         char port[20];
1628
1629         if (extract_received_rport(last_answer,&received,&rport,&transport)==-1) return FALSE;
1630         osip_message_get_contact(request,0,&ctt);
1631         if (ctt == NULL) {
1632                 /*nothing to update*/
1633                 return FALSE;
1634         }
1635         if (ctt->url->host!=NULL){
1636                 osip_free(ctt->url->host);
1637         }
1638         ctt->url->host=osip_strdup(received);
1639         if (ctt->url->port!=NULL){
1640                 osip_free(ctt->url->port);
1641         }
1642         snprintf(port,sizeof(port),"%i",rport);
1643         ctt->url->port=osip_strdup(port);
1644         if (op->masquerade_via) masquerade_via(request,received,port);
1645
1646         if (transport != SalTransportUDP) {
1647                 sal_address_set_param((SalAddress *)ctt, "transport", sal_transport_to_string(transport));
1648         }
1649         return TRUE;
1650 }
1651
1652 static bool_t register_again_with_updated_contact(SalOp *op, osip_message_t *orig_request, osip_message_t *last_answer){
1653         osip_contact_t *ctt=NULL;
1654         SalAddress* ori_contact_address=NULL;
1655         const char *received;
1656         int rport;
1657         SalTransport transport;
1658         char* tmp;
1659         osip_message_t *msg=NULL;
1660         Sal* sal=op->base.root;
1661
1662         if (sal->double_reg==FALSE ) return FALSE;
1663
1664         if (extract_received_rport(last_answer,&received,&rport,&transport)==-1) return FALSE;
1665         osip_message_get_contact(orig_request,0,&ctt);
1666         osip_contact_to_str(ctt,&tmp);
1667         ori_contact_address = sal_address_new((const char*)tmp);
1668
1669         /*check if contact is up to date*/
1670         if (strcmp(sal_address_get_domain(ori_contact_address),received) ==0
1671         && sal_address_get_port_int(ori_contact_address) == rport
1672         && sal_address_get_transport(ori_contact_address) == transport) {
1673                 ms_message("Register has up to date contact, doing nothing.");
1674                 osip_free(tmp);
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         osip_free(tmp);
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                         eXosip_unlock();
1695                         ms_message("Resending new register with updated contact");
1696                         return TRUE;
1697                 } else {
1698                     ms_warning("Fail to send updated register.");
1699                     eXosip_unlock();
1700                     return FALSE;
1701                 }
1702                 eXosip_unlock();
1703         }
1704
1705         update_contact_from_response(op,last_answer);
1706         return FALSE;
1707 }
1708
1709 static void registration_success(Sal *sal, eXosip_event_t *ev){
1710         SalOp *op=sal_find_register(sal,ev->rid);
1711         osip_header_t *h=NULL;
1712         bool_t registered;
1713         if (op==NULL){
1714                 ms_error("Receiving register response for unknown operation");
1715                 return;
1716         }
1717         osip_message_get_expires(ev->request,0,&h);
1718         if (h!=NULL && atoi(h->hvalue)!=0){
1719                 registered=TRUE;
1720                 if (!register_again_with_updated_contact(op,ev->request,ev->response)){
1721                         sal->callbacks.register_success(op,registered);
1722                 }
1723         }else {
1724                 sal->callbacks.register_success(op,FALSE);
1725         }
1726 }
1727
1728 static bool_t registration_failure(Sal *sal, eXosip_event_t *ev){
1729         int status_code=0;
1730         const char *reason=NULL;
1731         SalOp *op=sal_find_register(sal,ev->rid);
1732         SalReason sr=SalReasonUnknown;
1733         SalError se=SalErrorUnknown;
1734
1735         if (op==NULL){
1736                 ms_error("Receiving register failure for unknown operation");
1737                 return TRUE;
1738         }
1739         if (ev->response){
1740                 status_code=osip_message_get_status_code(ev->response);
1741                 reason=osip_message_get_reason_phrase(ev->response);
1742         }
1743         switch(status_code){
1744                 case 401:
1745                 case 407:
1746                         return process_authentication(sal,ev);
1747                         break;
1748                 case 606: /*Not acceptable, workaround for proxies that don't like private addresses
1749                                  in vias, such as ekiga.net
1750                                  On the opposite, freephonie.net bugs when via are masqueraded.
1751                                  */
1752                         op->masquerade_via=TRUE;
1753                 default:
1754                         /* if contact is up to date, process the failure, otherwise resend a new register with
1755                                 updated contact first, just in case the faillure is due to incorrect contact */
1756                         if (ev->response && register_again_with_updated_contact(op,ev->request,ev->response))
1757                                 return TRUE; /*we are retrying with an updated contact*/
1758                         if (status_code==403){
1759                                 se=SalErrorFailure;
1760                                 sr=SalReasonForbidden;
1761                         }else if (status_code==0){
1762                                 se=SalErrorNoResponse;
1763                         }
1764                         sal->callbacks.register_failure(op,se,sr,reason);
1765         }
1766         return TRUE;
1767 }
1768
1769 static void other_request_reply(Sal *sal,eXosip_event_t *ev){
1770         SalOp *op=find_op(sal,ev);
1771
1772         if (op==NULL){
1773                 ms_warning("other_request_reply(): Receiving response to unknown request.");
1774                 return;
1775         }
1776         if (ev->response){
1777                 update_contact_from_response(op,ev->response);
1778                 if (ev->request && strcmp(osip_message_get_method(ev->request),"OPTIONS")==0)
1779                         sal->callbacks.ping_reply(op);
1780         }
1781 }
1782
1783 static bool_t process_event(Sal *sal, eXosip_event_t *ev){
1784         ms_message("linphone process event get a message %d\n",ev->type);
1785         switch(ev->type){
1786                 case EXOSIP_CALL_ANSWERED:
1787                         ms_message("CALL_ANSWERED\n");
1788                         call_accepted(sal,ev);
1789                         authentication_ok(sal,ev);
1790                         break;
1791                 case EXOSIP_CALL_CLOSED:
1792                 case EXOSIP_CALL_CANCELLED:
1793                         ms_message("CALL_CLOSED or CANCELLED\n");
1794                         call_terminated(sal,ev);
1795                         break;
1796                 case EXOSIP_CALL_TIMEOUT:
1797                 case EXOSIP_CALL_NOANSWER:
1798                         ms_message("CALL_TIMEOUT or NOANSWER\n");
1799                         return call_failure(sal,ev);
1800                         break;
1801                 case EXOSIP_CALL_REQUESTFAILURE:
1802                 case EXOSIP_CALL_GLOBALFAILURE:
1803                 case EXOSIP_CALL_SERVERFAILURE:
1804                         ms_message("CALL_REQUESTFAILURE or GLOBALFAILURE or SERVERFAILURE\n");
1805                         return call_failure(sal,ev);
1806                         break;
1807                 case EXOSIP_CALL_RELEASED:
1808                         ms_message("CALL_RELEASED\n");
1809                         call_released(sal, ev);
1810                         break;
1811                 case EXOSIP_CALL_INVITE:
1812                         ms_message("CALL_NEW\n");
1813                         inc_new_call(sal,ev);
1814                         break;
1815                 case EXOSIP_CALL_REINVITE:
1816                         handle_reinvite(sal,ev);
1817                         break;
1818                 case EXOSIP_CALL_ACK:
1819                         ms_message("CALL_ACK");
1820                         handle_ack(sal,ev);
1821                         break;
1822                 case EXOSIP_CALL_REDIRECTED:
1823                         ms_message("CALL_REDIRECTED");
1824                         eXosip_default_action(ev);
1825                         break;
1826                 case EXOSIP_CALL_PROCEEDING:
1827                         ms_message("CALL_PROCEEDING");
1828                         call_proceeding(sal,ev);
1829                         break;
1830                 case EXOSIP_CALL_RINGING:
1831                         ms_message("CALL_RINGING");
1832                         call_ringing(sal,ev);
1833                         break;
1834                 case EXOSIP_CALL_MESSAGE_NEW:
1835                         ms_message("EXOSIP_CALL_MESSAGE_NEW");
1836                         call_message_new(sal,ev);
1837                         break;
1838                 case EXOSIP_CALL_MESSAGE_REQUESTFAILURE:
1839                         if (ev->response &&
1840                                 (ev->response->status_code==407 || ev->response->status_code==401)){
1841                                  return process_authentication(sal,ev);
1842                         }
1843                         break;
1844                 case EXOSIP_IN_SUBSCRIPTION_NEW:
1845                         ms_message("CALL_IN_SUBSCRIPTION_NEW ");
1846                         sal_exosip_subscription_recv(sal,ev);
1847                         break;
1848                 case EXOSIP_IN_SUBSCRIPTION_RELEASED:
1849                         ms_message("CALL_SUBSCRIPTION_NEW ");
1850                         sal_exosip_in_subscription_closed(sal,ev);
1851                         break;
1852                 case EXOSIP_SUBSCRIPTION_UPDATE:
1853                         ms_message("CALL_SUBSCRIPTION_UPDATE");
1854                         break;
1855                 case EXOSIP_SUBSCRIPTION_NOTIFY:
1856                         ms_message("CALL_SUBSCRIPTION_NOTIFY");
1857                         sal_exosip_notify_recv(sal,ev);
1858                         break;
1859                 case EXOSIP_SUBSCRIPTION_ANSWERED:
1860                         ms_message("EXOSIP_SUBSCRIPTION_ANSWERED, ev->sid=%i, ev->did=%i\n",ev->sid,ev->did);
1861                         sal_exosip_subscription_answered(sal,ev);
1862                         break;
1863                 case EXOSIP_SUBSCRIPTION_CLOSED:
1864                         ms_message("EXOSIP_SUBSCRIPTION_CLOSED\n");
1865                         sal_exosip_subscription_closed(sal,ev);
1866                         break;
1867                 case EXOSIP_SUBSCRIPTION_REQUESTFAILURE:   /**< announce a request failure      */
1868                         if (ev->response && (ev->response->status_code == 407 || ev->response->status_code == 401)){
1869                                 return process_authentication(sal,ev);
1870                         }
1871         case EXOSIP_SUBSCRIPTION_SERVERFAILURE:
1872                 case EXOSIP_SUBSCRIPTION_GLOBALFAILURE:
1873                         sal_exosip_subscription_closed(sal,ev);
1874                         break;
1875                 case EXOSIP_REGISTRATION_FAILURE:
1876                         ms_message("REGISTRATION_FAILURE\n");
1877                         return registration_failure(sal,ev);
1878                         break;
1879                 case EXOSIP_REGISTRATION_SUCCESS:
1880                         authentication_ok(sal,ev);
1881                         registration_success(sal,ev);
1882                         break;
1883                 case EXOSIP_MESSAGE_NEW:
1884                         other_request(sal,ev);
1885                         break;
1886                 case EXOSIP_MESSAGE_PROCEEDING:
1887                 case EXOSIP_MESSAGE_ANSWERED:
1888                 case EXOSIP_MESSAGE_REDIRECTED:
1889                 case EXOSIP_MESSAGE_SERVERFAILURE:
1890                 case EXOSIP_MESSAGE_GLOBALFAILURE:
1891                         other_request_reply(sal,ev);
1892                         break;
1893                 case EXOSIP_MESSAGE_REQUESTFAILURE:
1894                 case EXOSIP_NOTIFICATION_REQUESTFAILURE:
1895                         if (ev->response) {
1896                                 switch (ev->response->status_code) {
1897                                         case 407:
1898                                         case 401:
1899                                                 return process_authentication(sal,ev);
1900                                         case 412: {
1901                                                 eXosip_automatic_action ();
1902                                                 return 1;
1903                                         }
1904                                 }
1905                         }
1906                         other_request_reply(sal,ev);
1907                         break;
1908                 default:
1909                         ms_message("Unhandled exosip event ! %i",ev->type);
1910                         break;
1911         }
1912         return TRUE;
1913 }
1914
1915 int sal_iterate(Sal *sal){
1916         eXosip_event_t *ev;
1917         while((ev=eXosip_event_wait(0,0))!=NULL){
1918                 if (process_event(sal,ev))
1919                         eXosip_event_free(ev);
1920         }
1921         eXosip_lock();
1922         eXosip_automatic_refresh();
1923         eXosip_unlock();
1924         return 0;
1925 }
1926
1927 static void register_set_contact(osip_message_t *msg, const char *contact){
1928         osip_uri_param_t *param = NULL;
1929         osip_contact_t *ct=NULL;
1930         char *line=NULL;
1931         /*we get the line parameter choosed by exosip, and add it to our own contact*/
1932         osip_message_get_contact(msg,0,&ct);
1933         if (ct!=NULL){
1934                 osip_uri_uparam_get_byname(ct->url, "line", &param);
1935                 if (param && param->gvalue)
1936                         line=osip_strdup(param->gvalue);
1937         }
1938         _osip_list_set_empty(&msg->contacts,(void (*)(void*))osip_contact_free);
1939         osip_message_set_contact(msg,contact);
1940         osip_message_get_contact(msg,0,&ct);
1941         osip_uri_uparam_add(ct->url,osip_strdup("line"),line);
1942 }
1943
1944 int sal_register(SalOp *h, const char *proxy, const char *from, int expires){
1945         osip_message_t *msg;
1946         const char *contact=sal_op_get_contact(h);
1947
1948         sal_op_set_route(h,proxy);
1949         if (h->rid==-1){
1950                 eXosip_lock();
1951                 h->rid=eXosip_register_build_initial_register(from,proxy,NULL,expires,&msg);
1952                 if (msg){
1953                         if (contact) register_set_contact(msg,contact);
1954                         sal_add_register(h->base.root,h);
1955                 }else{
1956                         ms_error("Could not build initial register.");
1957                         eXosip_unlock();
1958                         return -1;
1959                 }
1960         }else{
1961                 eXosip_lock();
1962                 eXosip_register_build_register(h->rid,expires,&msg);
1963         }
1964         eXosip_register_send_register(h->rid,msg);
1965         eXosip_unlock();
1966         h->expires=expires;
1967         return 0;
1968 }
1969
1970 int sal_register_refresh(SalOp *op, int expires){
1971         osip_message_t *msg=NULL;
1972         const char *contact=sal_op_get_contact(op);
1973
1974         if (op->rid==-1){
1975                 ms_error("Unexistant registration context, not possible to refresh.");
1976                 return -1;
1977         }
1978         eXosip_lock();
1979         eXosip_register_build_register(op->rid,expires,&msg);
1980         if (msg!=NULL){
1981                 if (contact) register_set_contact(msg,contact);
1982                 eXosip_register_send_register(op->rid,msg);
1983         }else ms_error("Could not build REGISTER refresh message.");
1984         eXosip_unlock();
1985         return 0;
1986 }
1987
1988
1989 int sal_unregister(SalOp *h){
1990         osip_message_t *msg=NULL;
1991         eXosip_lock();
1992         eXosip_register_build_register(h->rid,0,&msg);
1993         if (msg) eXosip_register_send_register(h->rid,msg);
1994         else ms_warning("Could not build unREGISTER !");
1995         eXosip_unlock();
1996         return 0;
1997 }
1998
1999 SalAddress * sal_address_new(const char *uri){
2000         osip_from_t *from;
2001         osip_from_init(&from);
2002
2003         // Remove front spaces
2004         while (uri[0]==' ') {
2005                 uri++;
2006         }
2007
2008         if (osip_from_parse(from,uri)!=0){
2009                 osip_from_free(from);
2010                 return NULL;
2011         }
2012         if (from->displayname!=NULL && from->displayname[0]=='"'){
2013                 char *unquoted=osip_strdup_without_quote(from->displayname);
2014                 osip_free(from->displayname);
2015                 from->displayname=unquoted;
2016         }
2017         return (SalAddress*)from;
2018 }
2019
2020 SalAddress * sal_address_clone(const SalAddress *addr){
2021         osip_from_t *ret=NULL;
2022         osip_from_clone((osip_from_t*)addr,&ret);
2023         return (SalAddress*)ret;
2024 }
2025
2026 #define null_if_empty(s) (((s)!=NULL && (s)[0]!='\0') ? (s) : NULL )
2027
2028 const char *sal_address_get_scheme(const SalAddress *addr){
2029         const osip_from_t *u=(const osip_from_t*)addr;
2030         return null_if_empty(u->url->scheme);
2031 }
2032
2033 const char *sal_address_get_display_name(const SalAddress* addr){
2034         const osip_from_t *u=(const osip_from_t*)addr;
2035         return null_if_empty(u->displayname);
2036 }
2037
2038 const char *sal_address_get_username(const SalAddress *addr){
2039         const osip_from_t *u=(const osip_from_t*)addr;
2040         return null_if_empty(u->url->username);
2041 }
2042
2043 const char *sal_address_get_domain(const SalAddress *addr){
2044         const osip_from_t *u=(const osip_from_t*)addr;
2045         return null_if_empty(u->url->host);
2046 }
2047
2048 void sal_address_set_display_name(SalAddress *addr, const char *display_name){
2049         osip_from_t *u=(osip_from_t*)addr;
2050         if (u->displayname!=NULL){
2051                 osip_free(u->displayname);
2052                 u->displayname=NULL;
2053         }
2054         if (display_name!=NULL && display_name[0]!='\0'){
2055                 u->displayname=osip_strdup(display_name);
2056         }
2057 }
2058
2059 void sal_address_set_username(SalAddress *addr, const char *username){
2060         osip_from_t *uri=(osip_from_t*)addr;
2061         if (uri->url->username!=NULL){
2062                 osip_free(uri->url->username);
2063                 uri->url->username=NULL;
2064         }
2065         if (username)
2066                 uri->url->username=osip_strdup(username);
2067 }
2068
2069 void sal_address_set_domain(SalAddress *addr, const char *host){
2070         osip_from_t *uri=(osip_from_t*)addr;
2071         if (uri->url->host!=NULL){
2072                 osip_free(uri->url->host);
2073                 uri->url->host=NULL;
2074         }
2075         if (host)
2076                 uri->url->host=osip_strdup(host);
2077 }
2078
2079 void sal_address_set_port(SalAddress *addr, const char *port){
2080         osip_from_t *uri=(osip_from_t*)addr;
2081         if (uri->url->port!=NULL){
2082                 osip_free(uri->url->port);
2083                 uri->url->port=NULL;
2084         }
2085         if (port)
2086                 uri->url->port=osip_strdup(port);
2087 }
2088
2089 void sal_address_set_port_int(SalAddress *uri, int port){
2090         char tmp[12];
2091         if (port==5060){
2092                 /*this is the default, special case to leave the port field blank*/
2093                 sal_address_set_port(uri,NULL);
2094                 return;
2095         }
2096         snprintf(tmp,sizeof(tmp),"%i",port);
2097         sal_address_set_port(uri,tmp);
2098 }
2099
2100 void sal_address_clean(SalAddress *addr){
2101         osip_generic_param_freelist(& ((osip_from_t*)addr)->gen_params);
2102         osip_uri_param_freelist(& ((osip_from_t*)addr)->url->url_params);
2103 }
2104
2105 char *sal_address_as_string(const SalAddress *u){
2106         char *tmp,*ret;
2107         osip_from_t *from=(osip_from_t *)u;
2108         char *old_displayname=NULL;
2109         /* hack to force use of quotes around the displayname*/
2110         if (from->displayname!=NULL
2111             && from->displayname[0]!='"'){
2112                 old_displayname=from->displayname;
2113                 from->displayname=osip_enquote(from->displayname);
2114         }
2115         osip_from_to_str(from,&tmp);
2116         if (old_displayname!=NULL){
2117                 ms_free(from->displayname);
2118                 from->displayname=old_displayname;
2119         }
2120         ret=ms_strdup(tmp);
2121         osip_free(tmp);
2122         return ret;
2123 }
2124
2125 char *sal_address_as_string_uri_only(const SalAddress *u){
2126         char *tmp=NULL,*ret;
2127         osip_uri_to_str(((osip_from_t*)u)->url,&tmp);
2128         ret=ms_strdup(tmp);
2129         osip_free(tmp);
2130         return ret;
2131 }
2132 void sal_address_set_param(SalAddress *u,const char* name,const char* value) {
2133         osip_uri_param_t *param=NULL;
2134     osip_uri_uparam_get_byname(((osip_from_t*)u)->url,(char*)name,&param);
2135     if (param == NULL){
2136         osip_uri_uparam_add     (((osip_from_t*)u)->url,ms_strdup(name),ms_strdup(value));
2137     } else {
2138         osip_free(param->gvalue);
2139         param->gvalue=osip_strdup(value);
2140     }
2141
2142 }
2143
2144 void sal_address_destroy(SalAddress *u){
2145         osip_from_free((osip_from_t*)u);
2146 }
2147
2148 void sal_set_keepalive_period(Sal *ctx,unsigned int value) {
2149         ctx->keepalive_period=value;
2150         eXosip_set_option (EXOSIP_OPT_UDP_KEEP_ALIVE, &value);
2151 }
2152 unsigned int sal_get_keepalive_period(Sal *ctx) {
2153         return ctx->keepalive_period;
2154 }
2155
2156 const char * sal_address_get_port(const SalAddress *addr) {
2157         const osip_from_t *u=(const osip_from_t*)addr;
2158         return null_if_empty(u->url->port);
2159 }
2160
2161 int sal_address_get_port_int(const SalAddress *uri) {
2162         const char* port = sal_address_get_port(uri);
2163         if (port != NULL) {
2164                 return atoi(port);
2165         } else {
2166                 return 5060;
2167         }
2168 }
2169 SalTransport sal_address_get_transport(const SalAddress* addr) {
2170     const osip_from_t *u=(const osip_from_t*)addr;
2171     osip_uri_param_t *transport_param=NULL;
2172     osip_uri_uparam_get_byname(u->url,"transport",&transport_param);
2173     if (transport_param == NULL){
2174         return SalTransportUDP;
2175     }  else {
2176         return sal_transport_parse(transport_param->gvalue);
2177     }
2178 }
2179 void sal_address_set_transport(SalAddress* addr,SalTransport transport) {
2180     sal_address_set_param(addr, "transport", sal_transport_to_string(transport));
2181 }
2182
2183 /* sends a reinvite. Local media description may have changed by application since call establishment*/
2184 int sal_call_update(SalOp *h, const char *subject){
2185         int err=0;
2186         osip_message_t *reinvite=NULL;
2187
2188         eXosip_lock();
2189         if(eXosip_call_build_request(h->did,"INVITE",&reinvite) != 0 || reinvite==NULL){
2190                 eXosip_unlock();
2191                 return -1;
2192         }
2193         eXosip_unlock();
2194         osip_message_set_subject(reinvite,subject);
2195         osip_message_set_allow(reinvite, "INVITE, ACK, CANCEL, OPTIONS, BYE, REFER, NOTIFY, MESSAGE, SUBSCRIBE, INFO");
2196         if (h->base.root->session_expires!=0){
2197                 osip_message_set_header(reinvite, "Session-expires", "200");
2198                 osip_message_set_supported(reinvite, "timer");
2199         }
2200         if (h->base.local_media){
2201                 h->sdp_offering=TRUE;
2202                 set_sdp_from_desc(reinvite,h->base.local_media);
2203         }else h->sdp_offering=FALSE;
2204         eXosip_lock();
2205         err = eXosip_call_send_request(h->did, reinvite);
2206         eXosip_unlock();
2207         return err;
2208 }