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

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