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