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