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