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