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                 update_contact_from_response(op,last_answer);
1803                 return TRUE;
1804         } else {
1805             ms_warning("Fail to send updated register.");
1806             eXosip_unlock();
1807             return FALSE;
1808         }
1809         eXosip_unlock();
1810         return FALSE;
1811 }
1812
1813 static void registration_success(Sal *sal, eXosip_event_t *ev){
1814         SalOp *op=sal_find_register(sal,ev->rid);
1815         osip_header_t *h=NULL;
1816         bool_t registered;
1817         if (op==NULL){
1818                 ms_error("Receiving register response for unknown operation");
1819                 return;
1820         }
1821         osip_message_get_expires(ev->request,0,&h);
1822         if (h!=NULL && atoi(h->hvalue)!=0){
1823                 registered=TRUE;
1824                 if (!register_again_with_updated_contact(op,ev->request,ev->response)){
1825                         sal->callbacks.register_success(op,registered);
1826                 }
1827         }else {
1828                 sal->callbacks.register_success(op,FALSE);
1829         }
1830 }
1831
1832 static bool_t registration_failure(Sal *sal, eXosip_event_t *ev){
1833         int status_code=0;
1834         const char *reason=NULL;
1835         SalOp *op=sal_find_register(sal,ev->rid);
1836         SalReason sr=SalReasonUnknown;
1837         SalError se=SalErrorUnknown;
1838
1839         if (op==NULL){
1840                 ms_error("Receiving register failure for unknown operation");
1841                 return TRUE;
1842         }
1843         if (ev->response){
1844                 status_code=osip_message_get_status_code(ev->response);
1845                 reason=osip_message_get_reason_phrase(ev->response);
1846         }
1847         switch(status_code){
1848                 case 401:
1849                 case 407:
1850                         return process_authentication(sal,ev);
1851                         break;
1852                 case 423: /*interval too brief*/
1853                         {/*retry with greater interval */
1854                                 osip_header_t *h=NULL;
1855                                 osip_message_t *msg=NULL;
1856                                 osip_message_header_get_byname(ev->response,"min-expires",0,&h);
1857                                 if (h && h->hvalue && h->hvalue[0]!='\0'){
1858                                         int val=atoi(h->hvalue);
1859                                         if (val>op->expires)
1860                                                 op->expires=val;
1861                                 }else op->expires*=2;
1862                                 eXosip_lock();
1863                                 eXosip_register_build_register(op->rid,op->expires,&msg);
1864                                 eXosip_register_send_register(op->rid,msg);
1865                                 eXosip_unlock();
1866                         }
1867                 break;
1868                 case 606: /*Not acceptable, workaround for proxies that don't like private addresses
1869                                  in vias, such as ekiga.net
1870                                  On the opposite, freephonie.net bugs when via are masqueraded.
1871                                  */
1872                         op->masquerade_via=TRUE;
1873                 default:
1874                         /* if contact is up to date, process the failure, otherwise resend a new register with
1875                                 updated contact first, just in case the faillure is due to incorrect contact */
1876                         if (ev->response && register_again_with_updated_contact(op,ev->request,ev->response))
1877                                 return TRUE; /*we are retrying with an updated contact*/
1878                         if (status_code==403){
1879                                 se=SalErrorFailure;
1880                                 sr=SalReasonForbidden;
1881                         }else if (status_code==0){
1882                                 se=SalErrorNoResponse;
1883                         }
1884                         sal->callbacks.register_failure(op,se,sr,reason);
1885         }
1886         return TRUE;
1887 }
1888
1889 static void other_request_reply(Sal *sal,eXosip_event_t *ev){
1890         SalOp *op=find_op(sal,ev);
1891
1892         if (op==NULL){
1893                 ms_warning("other_request_reply(): Receiving response to unknown request.");
1894                 return;
1895         }
1896         if (ev->response){
1897                 update_contact_from_response(op,ev->response);
1898                 if (ev->request && strcmp(osip_message_get_method(ev->request),"OPTIONS")==0)
1899                         sal->callbacks.ping_reply(op);
1900         }
1901 }
1902
1903 static bool_t process_event(Sal *sal, eXosip_event_t *ev){
1904         ms_message("linphone process event get a message %d\n",ev->type);
1905         switch(ev->type){
1906                 case EXOSIP_CALL_ANSWERED:
1907                         ms_message("CALL_ANSWERED\n");
1908                         call_accepted(sal,ev);
1909                         authentication_ok(sal,ev);
1910                         break;
1911                 case EXOSIP_CALL_CLOSED:
1912                 case EXOSIP_CALL_CANCELLED:
1913                         ms_message("CALL_CLOSED or CANCELLED\n");
1914                         call_terminated(sal,ev);
1915                         break;
1916                 case EXOSIP_CALL_TIMEOUT:
1917                 case EXOSIP_CALL_NOANSWER:
1918                         ms_message("CALL_TIMEOUT or NOANSWER\n");
1919                         return call_failure(sal,ev);
1920                         break;
1921                 case EXOSIP_CALL_REQUESTFAILURE:
1922                 case EXOSIP_CALL_GLOBALFAILURE:
1923                 case EXOSIP_CALL_SERVERFAILURE:
1924                         ms_message("CALL_REQUESTFAILURE or GLOBALFAILURE or SERVERFAILURE\n");
1925                         return call_failure(sal,ev);
1926                         break;
1927                 case EXOSIP_CALL_RELEASED:
1928                         ms_message("CALL_RELEASED\n");
1929                         call_released(sal, ev);
1930                         break;
1931                 case EXOSIP_CALL_INVITE:
1932                         ms_message("CALL_NEW\n");
1933                         inc_new_call(sal,ev);
1934                         break;
1935                 case EXOSIP_CALL_REINVITE:
1936                         handle_reinvite(sal,ev);
1937                         break;
1938                 case EXOSIP_CALL_ACK:
1939                         ms_message("CALL_ACK");
1940                         handle_ack(sal,ev);
1941                         break;
1942                 case EXOSIP_CALL_REDIRECTED:
1943                         ms_message("CALL_REDIRECTED");
1944                         eXosip_default_action(ev);
1945                         break;
1946                 case EXOSIP_CALL_PROCEEDING:
1947                         ms_message("CALL_PROCEEDING");
1948                         call_proceeding(sal,ev);
1949                         break;
1950                 case EXOSIP_CALL_RINGING:
1951                         ms_message("CALL_RINGING");
1952                         call_ringing(sal,ev);
1953                         break;
1954                 case EXOSIP_CALL_MESSAGE_NEW:
1955                         ms_message("EXOSIP_CALL_MESSAGE_NEW");
1956                         call_message_new(sal,ev);
1957                         break;
1958                 case EXOSIP_CALL_MESSAGE_REQUESTFAILURE:
1959                         if (ev->response &&
1960                                 (ev->response->status_code==407 || ev->response->status_code==401)){
1961                                  return process_authentication(sal,ev);
1962                         }
1963                         break;
1964                 case EXOSIP_IN_SUBSCRIPTION_NEW:
1965                         ms_message("CALL_IN_SUBSCRIPTION_NEW ");
1966                         sal_exosip_subscription_recv(sal,ev);
1967                         break;
1968                 case EXOSIP_IN_SUBSCRIPTION_RELEASED:
1969                         ms_message("CALL_SUBSCRIPTION_NEW ");
1970                         sal_exosip_in_subscription_closed(sal,ev);
1971                         break;
1972                 case EXOSIP_SUBSCRIPTION_UPDATE:
1973                         ms_message("CALL_SUBSCRIPTION_UPDATE");
1974                         break;
1975                 case EXOSIP_SUBSCRIPTION_NOTIFY:
1976                         ms_message("CALL_SUBSCRIPTION_NOTIFY");
1977                         sal_exosip_notify_recv(sal,ev);
1978                         break;
1979                 case EXOSIP_SUBSCRIPTION_ANSWERED:
1980                         ms_message("EXOSIP_SUBSCRIPTION_ANSWERED, ev->sid=%i, ev->did=%i\n",ev->sid,ev->did);
1981                         sal_exosip_subscription_answered(sal,ev);
1982                         break;
1983                 case EXOSIP_SUBSCRIPTION_CLOSED:
1984                         ms_message("EXOSIP_SUBSCRIPTION_CLOSED\n");
1985                         sal_exosip_subscription_closed(sal,ev);
1986                         break;
1987                 case EXOSIP_SUBSCRIPTION_REQUESTFAILURE:   /**< announce a request failure      */
1988                         if (ev->response && (ev->response->status_code == 407 || ev->response->status_code == 401)){
1989                                 return process_authentication(sal,ev);
1990                         }
1991         case EXOSIP_SUBSCRIPTION_SERVERFAILURE:
1992                 case EXOSIP_SUBSCRIPTION_GLOBALFAILURE:
1993                         sal_exosip_subscription_closed(sal,ev);
1994                         break;
1995                 case EXOSIP_REGISTRATION_FAILURE:
1996                         ms_message("REGISTRATION_FAILURE\n");
1997                         return registration_failure(sal,ev);
1998                         break;
1999                 case EXOSIP_REGISTRATION_SUCCESS:
2000                         authentication_ok(sal,ev);
2001                         registration_success(sal,ev);
2002                         break;
2003                 case EXOSIP_MESSAGE_NEW:
2004                         other_request(sal,ev);
2005                         break;
2006                 case EXOSIP_MESSAGE_PROCEEDING:
2007                 case EXOSIP_MESSAGE_ANSWERED:
2008                 case EXOSIP_MESSAGE_REDIRECTED:
2009                 case EXOSIP_MESSAGE_SERVERFAILURE:
2010                 case EXOSIP_MESSAGE_GLOBALFAILURE:
2011                         other_request_reply(sal,ev);
2012                         break;
2013                 case EXOSIP_MESSAGE_REQUESTFAILURE:
2014                 case EXOSIP_NOTIFICATION_REQUESTFAILURE:
2015                         if (ev->response) {
2016                                 switch (ev->response->status_code) {
2017                                         case 407:
2018                                         case 401:
2019                                                 return process_authentication(sal,ev);
2020                                         case 412: {
2021                                                 eXosip_automatic_action ();
2022                                                 return 1;
2023                                         }
2024                                 }
2025                         }
2026                         other_request_reply(sal,ev);
2027                         break;
2028                 default:
2029                         ms_message("Unhandled exosip event ! %i",ev->type);
2030                         break;
2031         }
2032         return TRUE;
2033 }
2034
2035 int sal_iterate(Sal *sal){
2036         eXosip_event_t *ev;
2037         while((ev=eXosip_event_wait(0,0))!=NULL){
2038                 if (process_event(sal,ev))
2039                         eXosip_event_free(ev);
2040         }
2041 #ifdef HAVE_EXOSIP_TRYLOCK
2042         if (eXosip_trylock()==0){
2043                 eXosip_automatic_refresh();
2044                 eXosip_unlock();
2045         }else{
2046                 ms_warning("eXosip_trylock busy.");
2047         }
2048 #else
2049         eXosip_lock();
2050         eXosip_automatic_refresh();
2051         eXosip_unlock();
2052 #endif
2053         return 0;
2054 }
2055
2056 static void register_set_contact(osip_message_t *msg, const char *contact){
2057         osip_uri_param_t *param = NULL;
2058         osip_contact_t *ct=NULL;
2059         char *line=NULL;
2060         /*we get the line parameter choosed by exosip, and add it to our own contact*/
2061         osip_message_get_contact(msg,0,&ct);
2062         if (ct!=NULL){
2063                 osip_uri_uparam_get_byname(ct->url, "line", &param);
2064                 if (param && param->gvalue)
2065                         line=osip_strdup(param->gvalue);
2066         }
2067         _osip_list_set_empty(&msg->contacts,(void (*)(void*))osip_contact_free);
2068         osip_message_set_contact(msg,contact);
2069         osip_message_get_contact(msg,0,&ct);
2070         osip_uri_uparam_add(ct->url,osip_strdup("line"),line);
2071 }
2072
2073 static void sal_register_add_route(osip_message_t *msg, const char *proxy){
2074         char tmp[256]={0};
2075         snprintf(tmp,sizeof(tmp)-1,"<%s;lr>",proxy);
2076
2077         osip_list_special_free(&msg->routes,(void (*)(void*))osip_route_free);
2078         osip_message_set_route(msg,tmp);
2079 }
2080
2081 int sal_register(SalOp *h, const char *proxy, const char *from, int expires){
2082         osip_message_t *msg;
2083         const char *contact=sal_op_get_contact(h);
2084
2085         sal_op_set_route(h,proxy);
2086         if (h->rid==-1){
2087                 SalAddress *from_parsed=sal_address_new(from);
2088                 char domain[256];
2089                 if (from_parsed==NULL) {
2090                         ms_warning("sal_register() bad from %s",from);
2091                         return -1;
2092                 }
2093                 snprintf(domain,sizeof(domain),"sip:%s",sal_address_get_domain(from_parsed));
2094                 sal_address_destroy(from_parsed);
2095                 eXosip_lock();
2096                 h->rid=eXosip_register_build_initial_register(from,domain,NULL,expires,&msg);
2097                 if (msg){
2098                         if (contact) register_set_contact(msg,contact);
2099                         sal_register_add_route(msg,proxy);
2100                         sal_add_register(h->base.root,h);
2101                 }else{
2102                         ms_error("Could not build initial register.");
2103                         eXosip_unlock();
2104                         return -1;
2105                 }
2106         }else{
2107                 eXosip_lock();
2108                 eXosip_register_build_register(h->rid,expires,&msg);
2109                 sal_register_add_route(msg,proxy);
2110         }
2111         if (msg)
2112                 eXosip_register_send_register(h->rid,msg);
2113         eXosip_unlock();
2114         h->expires=expires;
2115         return (msg != NULL) ? 0 : -1;
2116 }
2117
2118 int sal_register_refresh(SalOp *op, int expires){
2119         osip_message_t *msg=NULL;
2120         const char *contact=sal_op_get_contact(op);
2121
2122         if (op->rid==-1){
2123                 ms_error("Unexistant registration context, not possible to refresh.");
2124                 return -1;
2125         }
2126         eXosip_lock();
2127         eXosip_register_build_register(op->rid,expires,&msg);
2128         if (msg!=NULL){
2129                 if (contact) register_set_contact(msg,contact);
2130                 sal_register_add_route(msg,sal_op_get_route(op));
2131                 eXosip_register_send_register(op->rid,msg);
2132         }else ms_error("Could not build REGISTER refresh message.");
2133         eXosip_unlock();
2134         return (msg != NULL) ? 0 : -1;
2135 }
2136
2137
2138 int sal_unregister(SalOp *h){
2139         osip_message_t *msg=NULL;
2140         eXosip_lock();
2141         eXosip_register_build_register(h->rid,0,&msg);
2142         if (msg) eXosip_register_send_register(h->rid,msg);
2143         else ms_warning("Could not build unREGISTER !");
2144         eXosip_unlock();
2145         return 0;
2146 }
2147
2148 SalAddress * sal_address_new(const char *uri){
2149         osip_from_t *from;
2150         osip_from_init(&from);
2151
2152         // Remove front spaces
2153         while (uri[0]==' ') {
2154                 uri++;
2155         }
2156
2157         if (osip_from_parse(from,uri)!=0){
2158                 osip_from_free(from);
2159                 return NULL;
2160         }
2161         if (from->displayname!=NULL && from->displayname[0]=='"'){
2162                 char *unquoted=osip_strdup_without_quote(from->displayname);
2163                 osip_free(from->displayname);
2164                 from->displayname=unquoted;
2165         }
2166         return (SalAddress*)from;
2167 }
2168
2169 SalAddress * sal_address_clone(const SalAddress *addr){
2170         osip_from_t *ret=NULL;
2171         osip_from_clone((osip_from_t*)addr,&ret);
2172         return (SalAddress*)ret;
2173 }
2174
2175 #define null_if_empty(s) (((s)!=NULL && (s)[0]!='\0') ? (s) : NULL )
2176
2177 const char *sal_address_get_scheme(const SalAddress *addr){
2178         const osip_from_t *u=(const osip_from_t*)addr;
2179         return null_if_empty(u->url->scheme);
2180 }
2181
2182 const char *sal_address_get_display_name(const SalAddress* addr){
2183         const osip_from_t *u=(const osip_from_t*)addr;
2184         return null_if_empty(u->displayname);
2185 }
2186
2187 const char *sal_address_get_username(const SalAddress *addr){
2188         const osip_from_t *u=(const osip_from_t*)addr;
2189         return null_if_empty(u->url->username);
2190 }
2191
2192 const char *sal_address_get_domain(const SalAddress *addr){
2193         const osip_from_t *u=(const osip_from_t*)addr;
2194         return null_if_empty(u->url->host);
2195 }
2196
2197 void sal_address_set_display_name(SalAddress *addr, const char *display_name){
2198         osip_from_t *u=(osip_from_t*)addr;
2199         if (u->displayname!=NULL){
2200                 osip_free(u->displayname);
2201                 u->displayname=NULL;
2202         }
2203         if (display_name!=NULL && display_name[0]!='\0'){
2204                 u->displayname=osip_strdup(display_name);
2205         }
2206 }
2207
2208 void sal_address_set_username(SalAddress *addr, const char *username){
2209         osip_from_t *uri=(osip_from_t*)addr;
2210         if (uri->url->username!=NULL){
2211                 osip_free(uri->url->username);
2212                 uri->url->username=NULL;
2213         }
2214         if (username)
2215                 uri->url->username=osip_strdup(username);
2216 }
2217
2218 void sal_address_set_domain(SalAddress *addr, const char *host){
2219         osip_from_t *uri=(osip_from_t*)addr;
2220         if (uri->url->host!=NULL){
2221                 osip_free(uri->url->host);
2222                 uri->url->host=NULL;
2223         }
2224         if (host)
2225                 uri->url->host=osip_strdup(host);
2226 }
2227
2228 void sal_address_set_port(SalAddress *addr, const char *port){
2229         osip_from_t *uri=(osip_from_t*)addr;
2230         if (uri->url->port!=NULL){
2231                 osip_free(uri->url->port);
2232                 uri->url->port=NULL;
2233         }
2234         if (port)
2235                 uri->url->port=osip_strdup(port);
2236 }
2237
2238 void sal_address_set_port_int(SalAddress *uri, int port){
2239         char tmp[12];
2240         if (port==5060){
2241                 /*this is the default, special case to leave the port field blank*/
2242                 sal_address_set_port(uri,NULL);
2243                 return;
2244         }
2245         snprintf(tmp,sizeof(tmp),"%i",port);
2246         sal_address_set_port(uri,tmp);
2247 }
2248
2249 void sal_address_clean(SalAddress *addr){
2250         osip_generic_param_freelist(& ((osip_from_t*)addr)->gen_params);
2251         osip_uri_param_freelist(& ((osip_from_t*)addr)->url->url_params);
2252 }
2253
2254 char *sal_address_as_string(const SalAddress *u){
2255         char *tmp,*ret;
2256         osip_from_t *from=(osip_from_t *)u;
2257         char *old_displayname=NULL;
2258         /* hack to force use of quotes around the displayname*/
2259         if (from->displayname!=NULL
2260             && from->displayname[0]!='"'){
2261                 old_displayname=from->displayname;
2262                 from->displayname=osip_enquote(from->displayname);
2263         }
2264         osip_from_to_str(from,&tmp);
2265         if (old_displayname!=NULL){
2266                 ms_free(from->displayname);
2267                 from->displayname=old_displayname;
2268         }
2269         ret=ms_strdup(tmp);
2270         osip_free(tmp);
2271         return ret;
2272 }
2273
2274 char *sal_address_as_string_uri_only(const SalAddress *u){
2275         char *tmp=NULL,*ret;
2276         osip_uri_to_str(((osip_from_t*)u)->url,&tmp);
2277         ret=ms_strdup(tmp);
2278         osip_free(tmp);
2279         return ret;
2280 }
2281 void sal_address_set_param(SalAddress *u,const char* name,const char* value) {
2282         osip_uri_param_t *param=NULL;
2283     osip_uri_uparam_get_byname(((osip_from_t*)u)->url,(char*)name,&param);
2284     if (param == NULL){
2285         osip_uri_uparam_add     (((osip_from_t*)u)->url,ms_strdup(name),value ? ms_strdup(value) : NULL);
2286     } else {
2287         osip_free(param->gvalue);
2288         param->gvalue=value ? osip_strdup(value) : NULL;
2289     }
2290
2291 }
2292
2293 void sal_address_destroy(SalAddress *u){
2294         osip_from_free((osip_from_t*)u);
2295 }
2296
2297 void sal_set_keepalive_period(Sal *ctx,unsigned int value) {
2298         ctx->keepalive_period=value;
2299         eXosip_set_option (EXOSIP_OPT_UDP_KEEP_ALIVE, &value);
2300 }
2301 unsigned int sal_get_keepalive_period(Sal *ctx) {
2302         return ctx->keepalive_period;
2303 }
2304
2305 const char * sal_address_get_port(const SalAddress *addr) {
2306         const osip_from_t *u=(const osip_from_t*)addr;
2307         return null_if_empty(u->url->port);
2308 }
2309
2310 int sal_address_get_port_int(const SalAddress *uri) {
2311         const char* port = sal_address_get_port(uri);
2312         if (port != NULL) {
2313                 return atoi(port);
2314         } else {
2315                 return 5060;
2316         }
2317 }
2318 SalTransport sal_address_get_transport(const SalAddress* addr) {
2319     const osip_from_t *u=(const osip_from_t*)addr;
2320     osip_uri_param_t *transport_param=NULL;
2321     osip_uri_uparam_get_byname(u->url,"transport",&transport_param);
2322     if (transport_param == NULL){
2323         return SalTransportUDP;
2324     }  else {
2325         return sal_transport_parse(transport_param->gvalue);
2326     }
2327 }
2328 void sal_address_set_transport(SalAddress* addr,SalTransport transport) {
2329     sal_address_set_param(addr, "transport", sal_transport_to_string(transport));
2330 }
2331
2332 /* sends a reinvite. Local media description may have changed by application since call establishment*/
2333 int sal_call_update(SalOp *h, const char *subject){
2334         int err=0;
2335         osip_message_t *reinvite=NULL;
2336
2337         eXosip_lock();
2338         if(eXosip_call_build_request(h->did,"INVITE",&reinvite) != 0 || reinvite==NULL){
2339                 eXosip_unlock();
2340                 return -1;
2341         }
2342         eXosip_unlock();
2343         osip_message_set_subject(reinvite,subject);
2344         osip_message_set_allow(reinvite, "INVITE, ACK, CANCEL, OPTIONS, BYE, REFER, NOTIFY, MESSAGE, SUBSCRIBE, INFO");
2345         if (h->base.root->session_expires!=0){
2346                 osip_message_set_header(reinvite, "Session-expires", "200");
2347                 osip_message_set_supported(reinvite, "timer");
2348         }
2349         if (h->base.local_media){
2350                 h->sdp_offering=TRUE;
2351                 set_sdp_from_desc(reinvite,h->base.local_media);
2352         }else h->sdp_offering=FALSE;
2353         eXosip_lock();
2354         err = eXosip_call_send_request(h->did, reinvite);
2355         eXosip_unlock();
2356         return err;
2357 }
2358 void sal_reuse_authorization(Sal *ctx, bool_t value) {
2359         ctx->reuse_authorization=value;
2360 }