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

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