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

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