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