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