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