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

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