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