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