3 Copyright (C) 2010 Simon MORLAT (simon.morlat@free.fr)
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.
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.
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.
23 #include "sal_eXosip2.h"
25 #include "offeranswer.h"
28 // Necessary to make it linked
29 static void for_linker() { eXosip_transport_hook_register(NULL); }
31 static bool_t call_failure(Sal *sal, eXosip_event_t *ev);
33 static void text_received(Sal *sal, eXosip_event_t *ev);
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);
39 void _osip_list_set_empty(osip_list_t *l, void (*freefunc)(void*)){
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);
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 !");
57 static SalOp * sal_find_call(Sal *sal, int cid){
60 for(elem=sal->calls;elem!=NULL;elem=elem->next){
61 op=(SalOp*)elem->data;
62 if (op->cid==cid) return op;
67 static void sal_add_call(Sal *sal, SalOp *op){
68 sal->calls=ms_list_append(sal->calls,op);
71 static void sal_remove_call(Sal *sal, SalOp *op){
72 sal->calls=ms_list_remove(sal->calls, op);
75 static SalOp * sal_find_register(Sal *sal, int rid){
78 for(elem=sal->registers;elem!=NULL;elem=elem->next){
79 op=(SalOp*)elem->data;
80 if (op->rid==rid) return op;
85 static void sal_add_register(Sal *sal, SalOp *op){
86 sal->registers=ms_list_append(sal->registers,op);
89 static void sal_remove_register(Sal *sal, int rid){
92 for(elem=sal->registers;elem!=NULL;elem=elem->next){
93 op=(SalOp*)elem->data;
95 sal->registers=ms_list_remove_link(sal->registers,elem);
101 static SalOp * sal_find_other(Sal *sal, osip_message_t *response){
104 osip_call_id_t *callid=osip_message_get_call_id(response);
106 ms_error("There is no call-id in this response !");
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;
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);
119 ms_error("There is no call id in the request !");
122 osip_call_id_clone(callid,&op->call_id);
123 sal->other_transactions=ms_list_append(sal->other_transactions,op);
126 static void sal_remove_other(Sal *sal, SalOp *op){
127 sal->other_transactions=ms_list_remove(sal->other_transactions,op);
131 static void sal_add_pending_auth(Sal *sal, SalOp *op){
132 sal->pending_auths=ms_list_append(sal->pending_auths,op);
136 static void sal_remove_pending_auth(Sal *sal, SalOp *op){
137 sal->pending_auths=ms_list_remove(sal->pending_auths,op);
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;
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);
150 /* check if the lr parameter is set , if not add it */
151 osip_uri_uparam_get_byname(rt->url, "lr", &lr_param);
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);
164 SalOp * sal_op_new(Sal *sal){
165 SalOp *op=ms_new(SalOp,1);
166 __sal_op_init(op,sal);
167 op->cid=op->did=op->tid=op->rid=op->nid=op->sid=-1;
169 op->supports_session_timers=FALSE;
170 op->sdp_offering=TRUE;
171 op->pending_auth=NULL;
176 op->referred_by=NULL;
177 op->masquerade_via=FALSE;
178 op->auto_answer_asked=FALSE;
180 op->terminated=FALSE;
184 bool_t sal_call_autoanswer_asked(SalOp *op)
186 return op->auto_answer_asked;
189 void sal_op_release(SalOp *op){
191 sdp_message_free(op->sdp_answer);
192 if (op->pending_auth)
193 eXosip_event_free(op->pending_auth);
195 sal_remove_register(op->base.root,op->rid);
196 eXosip_register_remove(op->rid);
199 ms_message("Cleaning cid %i",op->cid);
200 sal_remove_call(op->base.root,op);
203 sal_remove_out_subscribe(op->base.root,op);
206 sal_remove_in_subscribe(op->base.root,op);
208 osip_call_id_free(op->call_id);
211 if (op->pending_auth){
212 sal_remove_pending_auth(op->base.root,op);
215 sal_media_description_unref(op->result);
217 sal_remove_other(op->base.root,op);
218 osip_call_id_free(op->call_id);
221 ms_free(op->replaces);
223 if (op->referred_by){
224 ms_free(op->referred_by);
227 sal_auth_info_delete(op->auth_info);
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;
239 ortp_level=ORTP_MESSAGE;
242 ortp_level=ORTP_WARNING;
246 ortp_level=ORTP_ERROR;
249 ortp_level=ORTP_FATAL;
251 case END_TRACE_LEVEL:
254 if (ortp_log_level_enabled(level)){
255 int len=strlen(chfr);
256 char *chfrdup=ortp_strdup(chfr);
257 /*need to remove endline*/
259 if (chfrdup[len-1]=='\n')
261 if (chfrdup[len-2]=='\r')
264 ortp_logv(ortp_level,chfrdup,ap);
271 static bool_t firsttime=TRUE;
274 osip_trace_initialize_func (OSIP_INFO4,&_osip_trace_func);
279 sal->keepalive_period=30;
280 sal->double_reg=TRUE;
281 sal->use_rports=TRUE;
283 sal->reuse_authorization=FALSE;
288 void sal_uninit(Sal* sal){
291 ms_free(sal->rootCa);
295 void sal_set_user_pointer(Sal *sal, void *user_data){
299 void *sal_get_user_pointer(const Sal *sal){
303 static void unimplemented_stub(){
304 ms_warning("Unimplemented SAL callback");
307 void sal_set_callbacks(Sal *ctx, const SalCallbacks *cbs){
308 memcpy(&ctx->callbacks,cbs,sizeof(*cbs));
309 if (ctx->callbacks.call_received==NULL)
310 ctx->callbacks.call_received=(SalOnCallReceived)unimplemented_stub;
311 if (ctx->callbacks.call_ringing==NULL)
312 ctx->callbacks.call_ringing=(SalOnCallRinging)unimplemented_stub;
313 if (ctx->callbacks.call_accepted==NULL)
314 ctx->callbacks.call_accepted=(SalOnCallAccepted)unimplemented_stub;
315 if (ctx->callbacks.call_failure==NULL)
316 ctx->callbacks.call_failure=(SalOnCallFailure)unimplemented_stub;
317 if (ctx->callbacks.call_terminated==NULL)
318 ctx->callbacks.call_terminated=(SalOnCallTerminated)unimplemented_stub;
319 if (ctx->callbacks.call_released==NULL)
320 ctx->callbacks.call_released=(SalOnCallReleased)unimplemented_stub;
321 if (ctx->callbacks.call_updating==NULL)
322 ctx->callbacks.call_updating=(SalOnCallUpdating)unimplemented_stub;
323 if (ctx->callbacks.auth_requested==NULL)
324 ctx->callbacks.auth_requested=(SalOnAuthRequested)unimplemented_stub;
325 if (ctx->callbacks.auth_success==NULL)
326 ctx->callbacks.auth_success=(SalOnAuthSuccess)unimplemented_stub;
327 if (ctx->callbacks.register_success==NULL)
328 ctx->callbacks.register_success=(SalOnRegisterSuccess)unimplemented_stub;
329 if (ctx->callbacks.register_failure==NULL)
330 ctx->callbacks.register_failure=(SalOnRegisterFailure)unimplemented_stub;
331 if (ctx->callbacks.dtmf_received==NULL)
332 ctx->callbacks.dtmf_received=(SalOnDtmfReceived)unimplemented_stub;
333 if (ctx->callbacks.notify==NULL)
334 ctx->callbacks.notify=(SalOnNotify)unimplemented_stub;
335 if (ctx->callbacks.notify_presence==NULL)
336 ctx->callbacks.notify_presence=(SalOnNotifyPresence)unimplemented_stub;
337 if (ctx->callbacks.subscribe_received==NULL)
338 ctx->callbacks.subscribe_received=(SalOnSubscribeReceived)unimplemented_stub;
339 if (ctx->callbacks.text_received==NULL)
340 ctx->callbacks.text_received=(SalOnTextReceived)unimplemented_stub;
341 if (ctx->callbacks.ping_reply==NULL)
342 ctx->callbacks.ping_reply=(SalOnPingReply)unimplemented_stub;
345 int sal_unlisten_ports(Sal *ctx){
354 int sal_listen_port(Sal *ctx, const char *addr, int port, SalTransport tr, int is_secure){
357 int proto=IPPROTO_UDP;
358 int keepalive = ctx->keepalive_period;
361 case SalTransportUDP:
363 eXosip_set_option (EXOSIP_OPT_UDP_KEEP_ALIVE, &keepalive);
365 case SalTransportTCP:
366 case SalTransportTLS:
369 eXosip_set_option (EXOSIP_OPT_UDP_KEEP_ALIVE,&keepalive);
372 eXosip_tls_ctx_t tlsCtx;
373 memset(&tlsCtx, 0, sizeof(tlsCtx));
374 snprintf(tlsCtx.root_ca_cert, sizeof(tlsCtx.client.cert), "%s", ctx->rootCa);
375 eXosip_set_tls_ctx(&tlsCtx);
379 ms_warning("unexpected proto, using datagram");
383 eXosip_set_option(13,&err); /*13=EXOSIP_OPT_SRV_WITH_NAPTR, as it is an enum value, we can't use it unless we are sure of the
384 version of eXosip, which is not the case*/
385 /*see if it looks like an IPv6 address*/
386 int use_rports = ctx->use_rports; // Copy char to int to avoid bad alignment
387 eXosip_set_option(EXOSIP_OPT_USE_RPORT,&use_rports);
388 int dont_use_101 = !ctx->use_101; // Copy char to int to avoid bad alignment
389 eXosip_set_option(EXOSIP_OPT_DONT_SEND_101,&dont_use_101);
391 ipv6=strchr(addr,':')!=NULL;
392 eXosip_enable_ipv6(ipv6);
394 if (is_secure && tr == SalTransportUDP){
395 ms_fatal("SIP over DTLS is not supported yet.");
398 err=eXosip_listen_addr(proto, addr, port, ipv6 ? PF_INET6 : PF_INET, is_secure);
399 #ifdef HAVE_EXOSIP_GET_SOCKET
400 ms_message("Exosip has socket number %i",eXosip_get_socket(proto));
407 ortp_socket_t sal_get_socket(Sal *ctx){
408 #ifdef HAVE_EXOSIP_GET_SOCKET
409 return eXosip_get_socket(IPPROTO_UDP);
411 ms_warning("Sorry, eXosip does not have eXosip_get_socket() method");
416 void sal_set_user_agent(Sal *ctx, const char *user_agent){
417 eXosip_set_user_agent(user_agent);
420 void sal_use_session_timers(Sal *ctx, int expires){
421 ctx->session_expires=expires;
424 void sal_use_one_matching_codec_policy(Sal *ctx, bool_t one_matching_codec){
425 ctx->one_matching_codec=one_matching_codec;
428 MSList *sal_get_pending_auths(Sal *sal){
429 return ms_list_copy(sal->pending_auths);
432 void sal_use_double_registrations(Sal *ctx, bool_t enabled){
433 ctx->double_reg=enabled;
436 void sal_use_rport(Sal *ctx, bool_t use_rports){
437 ctx->use_rports=use_rports;
439 void sal_use_101(Sal *ctx, bool_t use_101){
440 ctx->use_101=use_101;
443 void sal_root_ca(Sal* ctx, const char* rootCa) {
445 ms_free(ctx->rootCa);
446 ctx->rootCa = ms_strdup(rootCa);
449 static int extract_received_rport(osip_message_t *msg, const char **received, int *rportval,SalTransport* transport){
450 osip_via_t *via=NULL;
451 osip_generic_param_t *param=NULL;
452 const char *rport=NULL;
456 osip_message_get_via(msg,0,&via);
459 *transport = sal_transport_parse(via->protocol);
461 if (via->port && via->port[0]!='\0')
462 *rportval=atoi(via->port);
464 osip_via_param_get_byname(via,"rport",¶m);
467 if (rport && rport[0]!='\0') *rportval=atoi(rport);
471 osip_via_param_get_byname(via,"received",¶m);
472 if (param) *received=param->gvalue;
474 if (rport==NULL && *received==NULL) return -1;
478 static void set_sdp(osip_message_t *sip,sdp_message_t *msg){
482 sdp_message_to_str(msg,&sdp);
484 snprintf(clen,sizeof(clen),"%i",sdplen);
485 osip_message_set_body(sip,sdp,sdplen);
486 osip_message_set_content_type(sip,"application/sdp");
487 osip_message_set_content_length(sip,clen);
491 static void set_sdp_from_desc(osip_message_t *sip, const SalMediaDescription *desc){
492 sdp_message_t *msg=media_description_to_sdp(desc);
494 ms_error("Fail to print sdp message !");
498 sdp_message_free(msg);
501 static void sdp_process(SalOp *h){
502 ms_message("Doing SDP offer/answer process");
504 sal_media_description_unref(h->result);
506 h->result=sal_media_description_new();
507 if (h->sdp_offering){
508 offer_answer_initiate_outgoing(h->base.local_media,h->base.remote_media,h->result);
511 offer_answer_initiate_incoming(h->base.local_media,h->base.remote_media,h->result,h->base.root->one_matching_codec);
512 h->sdp_answer=media_description_to_sdp(h->result);
513 /*once we have generated the SDP answer, we modify the result description for processing by the upper layer.
514 It should contains media parameters constraint from the remote offer, not our response*/
515 strcpy(h->result->addr,h->base.remote_media->addr);
516 h->result->bandwidth=h->base.remote_media->bandwidth;
518 for(i=0;i<h->result->nstreams;++i){
519 if (h->result->streams[i].port>0){
520 strcpy(h->result->streams[i].addr,h->base.remote_media->streams[i].addr);
521 h->result->streams[i].ptime=h->base.remote_media->streams[i].ptime;
522 h->result->streams[i].bandwidth=h->base.remote_media->streams[i].bandwidth;
523 h->result->streams[i].port=h->base.remote_media->streams[i].port;
525 if (h->result->streams[i].proto == SalProtoRtpSavp) {
526 h->result->streams[i].crypto[0] = h->base.remote_media->streams[i].crypto[0];
534 int sal_call_is_offerer(const SalOp *h){
535 return h->sdp_offering;
538 int sal_call_set_local_media_description(SalOp *h, SalMediaDescription *desc){
540 sal_media_description_ref(desc);
541 if (h->base.local_media)
542 sal_media_description_unref(h->base.local_media);
543 h->base.local_media=desc;
547 int sal_call(SalOp *h, const char *from, const char *to){
550 osip_message_t *invite=NULL;
551 sal_op_set_from(h,from);
553 sal_exosip_fix_route(h);
555 h->terminated = FALSE;
557 route = sal_op_get_route(h);
558 err=eXosip_call_build_initial_invite(&invite,to,from,route,"Phone call");
560 ms_error("Could not create call. Error %d (from=%s to=%s route=%s)",
561 err, from, to, route);
564 osip_message_set_allow(invite, "INVITE, ACK, CANCEL, OPTIONS, BYE, REFER, NOTIFY, MESSAGE, SUBSCRIBE, INFO");
565 if (h->base.contact){
566 _osip_list_set_empty(&invite->contacts,(void (*)(void*))osip_contact_free);
567 osip_message_set_contact(invite,h->base.contact);
569 if (h->base.root->session_expires!=0){
570 osip_message_set_header(invite, "Session-expires", "200");
571 osip_message_set_supported(invite, "timer");
573 if (h->base.local_media){
574 h->sdp_offering=TRUE;
575 set_sdp_from_desc(invite,h->base.local_media);
576 }else h->sdp_offering=FALSE;
578 osip_message_set_header(invite,"Replaces",h->replaces);
580 osip_message_set_header(invite,"Referred-By",h->referred_by);
584 err=eXosip_call_send_initial_invite(invite);
588 ms_error("Fail to send invite ! Error code %d", err);
591 sal_add_call(h->base.root,h);
596 int sal_call_notify_ringing(SalOp *h, bool_t early_media){
599 /*if early media send also 180 and 183 */
600 if (early_media && h->sdp_answer){
603 eXosip_call_build_answer(h->tid,180,&msg);
605 set_sdp(msg,h->sdp_answer);
606 eXosip_call_send_answer(h->tid,180,msg);
609 eXosip_call_build_answer(h->tid,183,&msg);
611 set_sdp(msg,h->sdp_answer);
612 eXosip_call_send_answer(h->tid,183,msg);
617 eXosip_call_send_answer(h->tid,180,NULL);
623 int sal_call_accept(SalOp * h){
625 const char *contact=sal_op_get_contact(h);
627 int err=eXosip_call_build_answer(h->tid,200,&msg);
628 if (err<0 || msg==NULL){
629 ms_error("Fail to build answer for call: err=%i",err);
632 if (h->base.root->session_expires!=0){
633 if (h->supports_session_timers) osip_message_set_supported(msg, "timer");
637 _osip_list_set_empty(&msg->contacts,(void (*)(void*))osip_contact_free);
638 osip_message_set_contact(msg,contact);
641 if (h->base.local_media){
642 /*this is the case where we received an invite without SDP*/
643 if (h->sdp_offering) {
644 set_sdp_from_desc(msg,h->base.local_media);
647 set_sdp(msg,h->sdp_answer);
648 sdp_message_free(h->sdp_answer);
653 ms_error("You are accepting a call but not defined any media capabilities !");
655 eXosip_call_send_answer(h->tid,200,msg);
659 int sal_call_decline(SalOp *h, SalReason reason, const char *redirect){
660 if (reason==SalReasonBusy){
662 eXosip_call_send_answer(h->tid,486,NULL);
665 else if (reason==SalReasonTemporarilyUnavailable){
667 eXosip_call_send_answer(h->tid,480,NULL);
669 }else if (reason==SalReasonDoNotDisturb){
671 eXosip_call_send_answer(h->tid,600,NULL);
673 }else if (reason==SalReasonMedia){
675 eXosip_call_send_answer(h->tid,415,NULL);
677 }else if (redirect!=NULL && reason==SalReasonRedirect){
680 if (strstr(redirect,"sip:")!=0) code=302;
683 eXosip_call_build_answer(h->tid,code,&msg);
684 osip_message_set_contact(msg,redirect);
685 eXosip_call_send_answer(h->tid,code,msg);
687 }else sal_call_terminate(h);
691 SalMediaDescription * sal_call_get_final_media_description(SalOp *h){
692 if (h->base.local_media && h->base.remote_media && !h->result){
698 int sal_call_set_referer(SalOp *h, SalOp *refered_call){
699 if (refered_call->replaces)
700 h->replaces=ms_strdup(refered_call->replaces);
701 if (refered_call->referred_by)
702 h->referred_by=ms_strdup(refered_call->referred_by);
706 int sal_ping(SalOp *op, const char *from, const char *to){
707 osip_message_t *options=NULL;
709 sal_op_set_from(op,from);
710 sal_op_set_to(op,to);
711 /*bug here: eXosip2 does not honor the route argument*/
712 eXosip_options_build_request (&options, sal_op_get_to(op),
713 sal_op_get_from(op),sal_op_get_route(op));
715 if (op->base.root->session_expires!=0){
716 osip_message_set_header(options, "Session-expires", "200");
717 osip_message_set_supported(options, "timer");
719 sal_add_other(sal_op_get_sal(op),op,options);
720 return eXosip_options_send_request(options);
725 int sal_call_accept_refer(SalOp *op){
726 osip_message_t *msg=NULL;
729 err = eXosip_call_build_notify(op->did,EXOSIP_SUBCRSTATE_ACTIVE,&msg);
732 osip_message_set_header(msg,(const char *)"event","refer");
733 osip_message_set_content_type(msg,"message/sipfrag");
734 osip_message_set_body(msg,"SIP/2.0 100 Trying",sizeof("SIP/2.0 100 Trying"));
735 eXosip_call_send_request(op->did,msg);
739 ms_error("could not get a notify built\n");
745 int sal_call_refer(SalOp *h, const char *refer_to){
746 osip_message_t *msg=NULL;
749 eXosip_call_build_refer(h->did,refer_to, &msg);
750 if (msg) err=eXosip_call_send_request(h->did, msg);
756 int sal_call_refer_with_replaces(SalOp *h, SalOp *other_call_h){
757 osip_message_t *msg=NULL;
758 char referto[256]={0};
761 if (eXosip_call_get_referto(other_call_h->did,referto,sizeof(referto)-1)!=0){
762 ms_error("eXosip_call_get_referto() failed for did=%i",other_call_h->did);
766 eXosip_call_build_refer(h->did,referto, &msg);
767 osip_message_set_header(msg,"Referred-By",h->base.from);
768 if (msg) err=eXosip_call_send_request(h->did, msg);
774 SalOp *sal_call_get_replaces(SalOp *h){
775 if (h!=NULL && h->replaces!=NULL){
778 cid=eXosip_call_find_by_replaces(h->replaces);
781 SalOp *ret=sal_find_call(h->base.root,cid);
788 int sal_call_send_dtmf(SalOp *h, char dtmf){
789 osip_message_t *msg=NULL;
794 eXosip_call_build_info(h->did,&msg);
796 snprintf(dtmf_body, sizeof(dtmf_body), "Signal=%c\r\nDuration=250\r\n", dtmf);
797 osip_message_set_body(msg,dtmf_body,strlen(dtmf_body));
798 osip_message_set_content_type(msg,"application/dtmf-relay");
799 snprintf(clen,sizeof(clen),"%lu",(unsigned long)strlen(dtmf_body));
800 osip_message_set_content_length(msg,clen);
801 eXosip_call_send_request(h->did,msg);
807 static void push_auth_to_exosip(const SalAuthInfo *info){
809 if (info->userid==NULL || info->userid[0]=='\0') userid=info->username;
810 else userid=info->userid;
811 ms_message("Authentication info for username [%s], id[%s], realm [%s] added to eXosip", info->username,userid, info->realm);
812 eXosip_add_authentication_info (info->username,userid,
813 info->password, NULL,info->realm);
816 * Just for symmetry ;-)
818 static void pop_auth_from_exosip() {
819 eXosip_clear_authentication_info();
822 int sal_call_terminate(SalOp *h){
824 if (h == NULL) return -1;
825 if (h->auth_info) push_auth_to_exosip(h->auth_info);
827 err=eXosip_call_terminate(h->cid,h->did);
829 if (!h->base.root->reuse_authorization) pop_auth_from_exosip();
831 ms_warning("Exosip could not terminate the call: cid=%i did=%i", h->cid,h->did);
837 void sal_op_authenticate(SalOp *h, const SalAuthInfo *info){
838 if (h->pending_auth){
839 push_auth_to_exosip(info);
841 /*FIXME exosip does not take into account this update register message*/
843 if (fix_message_contact(h, h->pending_auth->request,h->pending_auth->response)) {
847 update_contact_from_response(h,h->pending_auth->response);
849 eXosip_default_action(h->pending_auth);
851 ms_message("eXosip_default_action() done");
852 if (!h->base.root->reuse_authorization) pop_auth_from_exosip();
854 if (h->auth_info) sal_auth_info_delete(h->auth_info); /*if already exist*/
855 h->auth_info=sal_auth_info_clone(info); /*store auth info for subsequent request*/
858 void sal_op_cancel_authentication(SalOp *h) {
860 sal_op_get_sal(h)->callbacks.register_failure(h,SalErrorFailure, SalReasonForbidden,_("Authentication failure"));
861 } else if (h->cid >0) {
862 sal_op_get_sal(h)->callbacks.call_failure(h,SalErrorFailure, SalReasonForbidden,_("Authentication failure"),0);
864 ms_warning("Auth failure not handled");
868 static void set_network_origin(SalOp *op, osip_message_t *req){
869 const char *received=NULL;
872 SalTransport transport;
873 if (extract_received_rport(req,&received,&rport,&transport)!=0){
874 osip_via_t *via=NULL;
876 osip_message_get_via(req,0,&via);
877 received=osip_via_get_host(via);
878 tmp=osip_via_get_port(via);
879 if (tmp) rport=atoi(tmp);
881 if (transport != SalTransportUDP) {
882 snprintf(origin,sizeof(origin)-1,"sip:%s:%i",received,rport);
884 snprintf(origin,sizeof(origin)-1,"sip:%s:%i;transport=%s",received,rport,sal_transport_to_string(transport));
886 __sal_op_set_network_origin(op,origin);
889 static void set_remote_ua(SalOp* op, osip_message_t *req){
890 if (op->base.remote_ua==NULL){
891 osip_header_t *h=NULL;
892 osip_message_get_user_agent(req,0,&h);
894 op->base.remote_ua=ms_strdup(h->hvalue);
899 static void set_replaces(SalOp *op, osip_message_t *req){
900 osip_header_t *h=NULL;
903 ms_free(op->replaces);
906 osip_message_header_get_byname(req,"replaces",0,&h);
908 if (h->hvalue && h->hvalue[0]!='\0'){
909 op->replaces=ms_strdup(h->hvalue);
914 static SalOp *find_op(Sal *sal, eXosip_event_t *ev){
916 return sal_find_call(sal,ev->cid);
919 return sal_find_register(sal,ev->rid);
922 return sal_find_out_subscribe(sal,ev->sid);
925 return sal_find_in_subscribe(sal,ev->nid);
927 if (ev->response) return sal_find_other(sal,ev->response);
931 static void inc_new_call(Sal *sal, eXosip_event_t *ev){
932 SalOp *op=sal_op_new(sal);
933 osip_from_t *from,*to;
934 osip_call_info_t *call_info;
936 sdp_message_t *sdp=eXosip_get_sdp_info(ev->request);
938 set_network_origin(op,ev->request);
939 set_remote_ua(op,ev->request);
940 set_replaces(op,ev->request);
943 op->sdp_offering=FALSE;
944 op->base.remote_media=sal_media_description_new();
945 sdp_to_media_description(sdp,op->base.remote_media);
946 sdp_message_free(sdp);
947 }else op->sdp_offering=TRUE;
949 from=osip_message_get_from(ev->request);
950 to=osip_message_get_to(ev->request);
951 osip_from_to_str(from,&tmp);
952 sal_op_set_from(op,tmp);
954 osip_from_to_str(to,&tmp);
955 sal_op_set_to(op,tmp);
958 osip_message_get_call_info(ev->request,0,&call_info);
961 osip_call_info_to_str(call_info,&tmp);
962 if( strstr(tmp,"answer-after=") != NULL)
964 op->auto_answer_asked=TRUE;
965 ms_message("The caller asked to automatically answer the call(Emergency?)\n");
974 sal_add_call(op->base.root,op);
975 sal->callbacks.call_received(op);
978 static void handle_reinvite(Sal *sal, eXosip_event_t *ev){
979 SalOp *op=find_op(sal,ev);
981 osip_message_t *msg=NULL;
984 ms_warning("Reinvite for non-existing operation !");
989 sdp=eXosip_get_sdp_info(ev->request);
990 if (op->base.remote_media){
991 sal_media_description_unref(op->base.remote_media);
992 op->base.remote_media=NULL;
995 sal_media_description_unref(op->result);
999 op->sdp_offering=FALSE;
1000 op->base.remote_media=sal_media_description_new();
1001 sdp_to_media_description(sdp,op->base.remote_media);
1002 sdp_message_free(sdp);
1003 sal->callbacks.call_updating(op);
1005 op->sdp_offering=TRUE;
1007 eXosip_call_build_answer(ev->tid,200,&msg);
1009 set_sdp_from_desc(msg,op->base.local_media);
1010 eXosip_call_send_answer(ev->tid,200,msg);
1017 static void handle_ack(Sal *sal, eXosip_event_t *ev){
1018 SalOp *op=find_op(sal,ev);
1022 ms_warning("ack for non-existing call !");
1025 sdp=eXosip_get_sdp_info(ev->ack);
1027 op->base.remote_media=sal_media_description_new();
1028 sdp_to_media_description(sdp,op->base.remote_media);
1030 sdp_message_free(sdp);
1033 if (sdp) sal->callbacks.call_updating(op);
1036 sal->callbacks.call_ack(op);
1040 static void update_contact_from_response(SalOp *op, osip_message_t *response){
1041 const char *received;
1043 SalTransport transport;
1044 if (extract_received_rport(response,&received,&rport,&transport)==0){
1045 const char *contact=sal_op_get_contact(op);
1047 /*no contact given yet, use from instead*/
1048 contact=sal_op_get_from(op);
1051 SalAddress *addr=sal_address_new(contact);
1053 sal_address_set_domain(addr,received);
1054 sal_address_set_port_int(addr,rport);
1055 if (transport!=SalTransportUDP)
1056 sal_address_set_transport(addr,transport);
1057 tmp=sal_address_as_string(addr);
1058 ms_message("Contact address updated to %s",tmp);
1059 sal_op_set_contact(op,tmp);
1060 sal_address_destroy(addr);
1066 static int call_proceeding(Sal *sal, eXosip_event_t *ev){
1067 SalOp *op=find_op(sal,ev);
1069 if (op==NULL || op->terminated==TRUE) {
1070 ms_warning("This call has been canceled.");
1072 eXosip_call_terminate(ev->cid,ev->did);
1080 /* update contact if received and rport are set by the server
1081 note: will only be used by remote for next INVITE, if any...*/
1082 update_contact_from_response(op,ev->response);
1086 static void call_ringing(Sal *sal, eXosip_event_t *ev){
1088 SalOp *op=find_op(sal,ev);
1089 if (call_proceeding(sal, ev)==-1) return;
1091 set_remote_ua(op,ev->response);
1092 sdp=eXosip_get_sdp_info(ev->response);
1094 op->base.remote_media=sal_media_description_new();
1095 sdp_to_media_description(sdp,op->base.remote_media);
1096 sdp_message_free(sdp);
1097 if (op->base.local_media) sdp_process(op);
1099 sal->callbacks.call_ringing(op);
1102 static void call_accepted(Sal *sal, eXosip_event_t *ev){
1104 osip_message_t *msg=NULL;
1105 SalOp *op=find_op(sal,ev);
1106 const char *contact;
1108 if (op==NULL || op->terminated==TRUE) {
1109 ms_warning("This call has been already terminated.");
1111 eXosip_call_terminate(ev->cid,ev->did);
1117 set_remote_ua(op,ev->response);
1119 sdp=eXosip_get_sdp_info(ev->response);
1121 op->base.remote_media=sal_media_description_new();
1122 sdp_to_media_description(sdp,op->base.remote_media);
1123 sdp_message_free(sdp);
1124 if (op->base.local_media) sdp_process(op);
1126 eXosip_call_build_ack(ev->did,&msg);
1128 ms_warning("This call has been already terminated.");
1130 eXosip_call_terminate(ev->cid,ev->did);
1134 contact=sal_op_get_contact(op);
1136 _osip_list_set_empty(&msg->contacts,(void (*)(void*))osip_contact_free);
1137 osip_message_set_contact(msg,contact);
1139 if (op->sdp_answer){
1140 set_sdp(msg,op->sdp_answer);
1141 sdp_message_free(op->sdp_answer);
1142 op->sdp_answer=NULL;
1144 eXosip_call_send_ack(ev->did,msg);
1145 sal->callbacks.call_accepted(op);
1148 static void call_terminated(Sal *sal, eXosip_event_t *ev){
1150 SalOp *op=find_op(sal,ev);
1152 ms_warning("Call terminated for already closed call ?");
1156 osip_from_to_str(ev->request->from,&from);
1158 sal->callbacks.call_terminated(op,from!=NULL ? from : sal_op_get_from(op));
1159 if (from) osip_free(from);
1160 op->terminated=TRUE;
1163 static void call_released(Sal *sal, eXosip_event_t *ev){
1164 SalOp *op=find_op(sal,ev);
1166 ms_warning("No op associated to this call_released()");
1169 if (!op->terminated){
1170 /* no response received so far */
1171 call_failure(sal,ev);
1173 sal->callbacks.call_released(op);
1176 static int get_auth_data_from_response(osip_message_t *resp, const char **realm, const char **username){
1177 const char *prx_realm=NULL,*www_realm=NULL;
1178 osip_proxy_authenticate_t *prx_auth;
1179 osip_www_authenticate_t *www_auth;
1181 *username=osip_uri_get_username(resp->from->url);
1182 prx_auth=(osip_proxy_authenticate_t*)osip_list_get(&resp->proxy_authenticates,0);
1183 www_auth=(osip_proxy_authenticate_t*)osip_list_get(&resp->www_authenticates,0);
1185 prx_realm=osip_proxy_authenticate_get_realm(prx_auth);
1187 www_realm=osip_www_authenticate_get_realm(www_auth);
1191 }else if (www_realm){
1199 static int get_auth_data_from_request(osip_message_t *msg, const char **realm, const char **username){
1200 osip_authorization_t *auth=NULL;
1201 osip_proxy_authorization_t *prx_auth=NULL;
1203 *username=osip_uri_get_username(msg->from->url);
1204 osip_message_get_authorization(msg, 0, &auth);
1206 *realm=osip_authorization_get_realm(auth);
1209 osip_message_get_proxy_authorization(msg,0,&prx_auth);
1211 *realm=osip_proxy_authorization_get_realm(prx_auth);
1217 static int get_auth_data(eXosip_event_t *ev, const char **realm, const char **username){
1218 if (ev->response && get_auth_data_from_response(ev->response,realm,username)==0) return 0;
1219 if (ev->request && get_auth_data_from_request(ev->request,realm,username)==0) return 0;
1223 int sal_op_get_auth_requested(SalOp *op, const char **realm, const char **username){
1224 if (op->pending_auth){
1225 return get_auth_data(op->pending_auth,realm,username);
1230 static bool_t process_authentication(Sal *sal, eXosip_event_t *ev){
1232 const char *username,*realm;
1235 ms_warning("No operation associated with this authentication !");
1238 if (get_auth_data(ev,&realm,&username)==0){
1239 if (op->pending_auth!=NULL){
1240 eXosip_event_free(op->pending_auth);
1241 op->pending_auth=ev;
1243 op->pending_auth=ev;
1244 sal_add_pending_auth(sal,op);
1247 sal->callbacks.auth_requested(op,realm,username);
1253 static void authentication_ok(Sal *sal, eXosip_event_t *ev){
1255 const char *username,*realm;
1258 ms_warning("No operation associated with this authentication_ok!");
1261 if (op->pending_auth){
1262 eXosip_event_free(op->pending_auth);
1263 sal_remove_pending_auth(sal,op);
1264 op->pending_auth=NULL;
1266 if (get_auth_data(ev,&realm,&username)==0){
1267 sal->callbacks.auth_success(op,realm,username);
1271 static bool_t call_failure(Sal *sal, eXosip_event_t *ev){
1274 char* computedReason=NULL;
1275 const char *reason=NULL;
1276 SalError error=SalErrorUnknown;
1277 SalReason sr=SalReasonUnknown;
1280 op=(SalOp*)find_op(sal,ev);
1283 ms_warning("Call failure reported for a closed call, ignored.");
1288 code=osip_message_get_status_code(ev->response);
1289 reason=osip_message_get_reason_phrase(ev->response);
1290 osip_header_t *h=NULL;
1291 if (!osip_message_header_get_byname( ev->response
1295 computedReason = ms_strdup_printf("%s %s",reason,osip_header_get_value(h));
1296 reason = computedReason;
1304 return process_authentication(sal,ev);
1307 error=SalErrorUnknown;
1310 error=SalErrorFailure;
1311 sr=SalReasonNotFound;
1314 error=SalErrorFailure;
1318 eXosip_default_action(ev);
1322 error=SalErrorFailure;
1323 sr=SalReasonTemporarilyUnavailable;
1325 error=SalErrorFailure;
1331 error=SalErrorFailure;
1332 sr=SalReasonDoNotDisturb;
1335 error=SalErrorFailure;
1336 sr=SalReasonDeclined;
1340 error=SalErrorFailure;
1341 sr=SalReasonUnknown;
1342 }else error=SalErrorNoResponse;
1344 op->terminated=TRUE;
1345 sal->callbacks.call_failure(op,error,sr,reason,code);
1346 if (computedReason != NULL){
1347 ms_free(computedReason);
1352 /* Request remote side to send us VFU */
1353 void sal_call_send_vfu_request(SalOp *h){
1354 osip_message_t *msg=NULL;
1356 "<?xml version=\"1.0\" encoding=\"utf-8\" ?>"
1360 " <picture_fast_update></picture_fast_update>"
1368 eXosip_call_build_info(h->did,&msg);
1370 osip_message_set_body(msg,info_body,strlen(info_body));
1371 osip_message_set_content_type(msg,"application/media_control+xml");
1372 snprintf(clen,sizeof(clen),"%lu",(unsigned long)strlen(info_body));
1373 osip_message_set_content_length(msg,clen);
1374 eXosip_call_send_request(h->did,msg);
1375 ms_message("Sending VFU request !");
1380 static void process_media_control_xml(Sal *sal, eXosip_event_t *ev){
1381 SalOp *op=find_op(sal,ev);
1382 osip_body_t *body=NULL;
1385 ms_warning("media control xml received without operation context!");
1389 osip_message_get_body(ev->request,0,&body);
1390 if (body && body->body!=NULL &&
1391 strstr(body->body,"picture_fast_update")){
1392 osip_message_t *ans=NULL;
1393 ms_message("Receiving VFU request !");
1394 if (sal->callbacks.vfu_request){
1395 sal->callbacks.vfu_request(op);
1396 eXosip_call_build_answer(ev->tid,200,&ans);
1398 eXosip_call_send_answer(ev->tid,200,ans);
1402 /*in all other cases we must say it is not implemented.*/
1404 osip_message_t *ans=NULL;
1406 eXosip_call_build_answer(ev->tid,501,&ans);
1408 eXosip_call_send_answer(ev->tid,501,ans);
1413 static void process_dtmf_relay(Sal *sal, eXosip_event_t *ev){
1414 SalOp *op=find_op(sal,ev);
1415 osip_body_t *body=NULL;
1418 ms_warning("media dtmf relay received without operation context!");
1422 osip_message_get_body(ev->request,0,&body);
1423 if (body && body->body!=NULL){
1424 osip_message_t *ans=NULL;
1425 const char *name=strstr(body->body,"Signal");
1426 if (name==NULL) name=strstr(body->body,"signal");
1428 ms_warning("Could not extract the dtmf name from the SIP INFO.");
1431 name+=strlen("signal");
1432 if (sscanf(name," = %1s",tmp)==1){
1433 ms_message("Receiving dtmf %s via SIP INFO.",tmp);
1434 if (sal->callbacks.dtmf_received != NULL)
1435 sal->callbacks.dtmf_received(op, tmp[0]);
1439 eXosip_call_build_answer(ev->tid,200,&ans);
1441 eXosip_call_send_answer(ev->tid,200,ans);
1446 static void fill_options_answer(osip_message_t *options){
1447 osip_message_set_allow(options,"INVITE, ACK, BYE, CANCEL, OPTIONS, MESSAGE, SUBSCRIBE, NOTIFY, INFO");
1448 osip_message_set_accept(options,"application/sdp");
1451 static void process_refer(Sal *sal, SalOp *op, eXosip_event_t *ev){
1452 osip_header_t *h=NULL;
1453 osip_message_t *ans=NULL;
1454 ms_message("Receiving REFER request !");
1455 osip_message_header_get_byname(ev->request,"Refer-To",0,&h);
1458 osip_from_t *from=NULL;
1460 osip_from_init(&from);
1462 if (osip_from_parse(from,h->hvalue)==0){
1464 osip_uri_header_t *uh=NULL;
1465 osip_header_t *referred_by=NULL;
1466 osip_uri_header_get_byname(&from->url->url_headers,(char*)"Replaces",&uh);
1467 if (uh!=NULL && uh->gvalue && uh->gvalue[0]!='\0'){
1468 ms_message("Found replaces in Refer-To");
1470 ms_free(op->replaces);
1472 op->replaces=ms_strdup(uh->gvalue);
1474 osip_message_header_get_byname(ev->request,"Referred-By",0,&referred_by);
1475 if (referred_by && referred_by->hvalue && referred_by->hvalue[0]!='\0'){
1476 if (op->referred_by)
1477 ms_free(op->referred_by);
1478 op->referred_by=ms_strdup(referred_by->hvalue);
1481 osip_uri_header_freelist(&from->url->url_headers);
1482 osip_from_to_str(from,&tmp);
1483 sal->callbacks.refer_received(sal,op,tmp);
1485 osip_from_free(from);
1488 eXosip_call_build_answer(ev->tid,202,&ans);
1490 eXosip_call_send_answer(ev->tid,202,ans);
1495 ms_warning("cannot do anything with the refer without destination\n");
1499 static void call_message_new(Sal *sal, eXosip_event_t *ev){
1500 osip_message_t *ans=NULL;
1502 if (MSG_IS_INFO(ev->request)){
1503 osip_content_type_t *ct;
1504 ct=osip_message_get_content_type(ev->request);
1505 if (ct && ct->subtype){
1506 if (strcmp(ct->subtype,"media_control+xml")==0)
1507 process_media_control_xml(sal,ev);
1508 else if (strcmp(ct->subtype,"dtmf-relay")==0)
1509 process_dtmf_relay(sal,ev);
1511 ms_message("Unhandled SIP INFO.");
1512 /*send an "Not implemented" answer*/
1514 eXosip_call_build_answer(ev->tid,501,&ans);
1516 eXosip_call_send_answer(ev->tid,501,ans);
1520 /*empty SIP INFO, probably to test we are alive. Send an empty answer*/
1522 eXosip_call_build_answer(ev->tid,200,&ans);
1524 eXosip_call_send_answer(ev->tid,200,ans);
1527 }else if(MSG_IS_MESSAGE(ev->request)){
1528 /* SIP messages could be received into call */
1529 text_received(sal, ev);
1531 eXosip_call_build_answer(ev->tid,200,&ans);
1533 eXosip_call_send_answer(ev->tid,200,ans);
1535 }else if(MSG_IS_REFER(ev->request)){
1536 SalOp *op=find_op(sal,ev);
1538 ms_message("Receiving REFER request !");
1539 process_refer(sal,op,ev);
1540 }else if(MSG_IS_NOTIFY(ev->request)){
1541 osip_header_t *h=NULL;
1543 SalOp *op=find_op(sal,ev);
1545 ms_message("Receiving NOTIFY request !");
1546 osip_from_to_str(ev->request->from,&from);
1547 osip_message_header_get_byname(ev->request,"Event",0,&h);
1549 sal->callbacks.notify(op,from,h->hvalue);
1550 /*answer that we received the notify*/
1552 eXosip_call_build_answer(ev->tid,200,&ans);
1554 eXosip_call_send_answer(ev->tid,200,ans);
1557 }else if (MSG_IS_OPTIONS(ev->request)){
1559 eXosip_call_build_answer(ev->tid,200,&ans);
1561 fill_options_answer(ans);
1562 eXosip_call_send_answer(ev->tid,200,ans);
1566 }else ms_warning("call_message_new: No request ?");
1569 static void inc_update(Sal *sal, eXosip_event_t *ev){
1570 osip_message_t *msg=NULL;
1571 ms_message("Processing incoming UPDATE");
1573 eXosip_message_build_answer(ev->tid,200,&msg);
1575 eXosip_message_send_answer(ev->tid,200,msg);
1579 static bool_t comes_from_local_if(osip_message_t *msg){
1580 osip_via_t *via=NULL;
1581 osip_message_get_via(msg,0,&via);
1584 host=osip_via_get_host(via);
1585 if (strcmp(host,"127.0.0.1")==0 || strcmp(host,"::1")==0){
1586 osip_generic_param_t *param=NULL;
1587 osip_via_param_get_byname(via,"received",¶m);
1588 if (param==NULL) return TRUE;
1589 if (param->gvalue &&
1590 (strcmp(param->gvalue,"127.0.0.1")==0 || strcmp(param->gvalue,"::1")==0)){
1598 static void text_received(Sal *sal, eXosip_event_t *ev){
1599 osip_body_t *body=NULL;
1600 char *from=NULL,*msg;
1602 osip_message_get_body(ev->request,0,&body);
1604 ms_error("Could not get text message from SIP body");
1608 osip_from_to_str(ev->request->from,&from);
1609 sal->callbacks.text_received(sal,from,msg);
1615 static void other_request(Sal *sal, eXosip_event_t *ev){
1616 ms_message("in other_request");
1617 if (ev->request==NULL) return;
1618 if (strcmp(ev->request->sip_method,"MESSAGE")==0){
1619 text_received(sal,ev);
1620 eXosip_message_send_answer(ev->tid,200,NULL);
1621 }else if (strcmp(ev->request->sip_method,"OPTIONS")==0){
1622 osip_message_t *options=NULL;
1623 eXosip_options_build_answer(ev->tid,200,&options);
1624 fill_options_answer(options);
1625 eXosip_options_send_answer(ev->tid,200,options);
1626 }else if (strncmp(ev->request->sip_method, "REFER", 5) == 0){
1627 ms_message("Receiving REFER request !");
1628 if (comes_from_local_if(ev->request)) {
1629 process_refer(sal,NULL,ev);
1630 }else ms_warning("Ignored REFER not coming from this local loopback interface.");
1631 }else if (strncmp(ev->request->sip_method, "UPDATE", 6) == 0){
1636 osip_message_to_str(ev->request,&tmp,&msglen);
1638 ms_message("Unsupported request received:\n%s",tmp);
1641 /*answer with a 501 Not implemented*/
1642 eXosip_message_send_answer(ev->tid,501,NULL);
1646 static void masquerade_via(osip_message_t *msg, const char *ip, const char *port){
1647 osip_via_t *via=NULL;
1648 osip_message_get_via(msg,0,&via);
1650 osip_free(via->port);
1651 via->port=osip_strdup(port);
1652 osip_free(via->host);
1653 via->host=osip_strdup(ip);
1658 static bool_t fix_message_contact(SalOp *op, osip_message_t *request,osip_message_t *last_answer) {
1659 osip_contact_t *ctt=NULL;
1660 const char *received;
1662 SalTransport transport;
1665 if (extract_received_rport(last_answer,&received,&rport,&transport)==-1) return FALSE;
1666 osip_message_get_contact(request,0,&ctt);
1668 /*nothing to update*/
1671 if (ctt->url->host!=NULL){
1672 osip_free(ctt->url->host);
1674 ctt->url->host=osip_strdup(received);
1675 if (ctt->url->port!=NULL){
1676 osip_free(ctt->url->port);
1678 snprintf(port,sizeof(port),"%i",rport);
1679 ctt->url->port=osip_strdup(port);
1680 if (op->masquerade_via) masquerade_via(request,received,port);
1682 if (transport != SalTransportUDP) {
1683 sal_address_set_param((SalAddress *)ctt, "transport", sal_transport_to_string(transport));
1688 static bool_t register_again_with_updated_contact(SalOp *op, osip_message_t *orig_request, osip_message_t *last_answer){
1689 osip_contact_t *ctt=NULL;
1690 SalAddress* ori_contact_address=NULL;
1691 const char *received;
1693 SalTransport transport;
1695 osip_message_t *msg=NULL;
1696 Sal* sal=op->base.root;
1698 if (sal->double_reg==FALSE ) return FALSE;
1700 if (extract_received_rport(last_answer,&received,&rport,&transport)==-1) return FALSE;
1701 osip_message_get_contact(orig_request,0,&ctt);
1702 osip_contact_to_str(ctt,&tmp);
1703 ori_contact_address = sal_address_new((const char*)tmp);
1705 /*check if contact is up to date*/
1706 if (strcmp(sal_address_get_domain(ori_contact_address),received) ==0
1707 && sal_address_get_port_int(ori_contact_address) == rport
1708 && sal_address_get_transport(ori_contact_address) == transport) {
1709 ms_message("Register has up to date contact, doing nothing.");
1712 } else ms_message("contact do not match, need to update the register (%s with %s:%i;transport=%s)"
1716 ,sal_transport_to_string(transport));
1718 sal_address_destroy(ori_contact_address);
1720 if (transport == SalTransportUDP) {
1722 eXosip_register_build_register(op->rid,op->expires,&msg);
1725 ms_warning("Fail to create a contact updated register.");
1728 if (fix_message_contact(op,msg,last_answer)) {
1729 eXosip_register_send_register(op->rid,msg);
1731 ms_message("Resending new register with updated contact");
1734 ms_warning("Fail to send updated register.");
1741 update_contact_from_response(op,last_answer);
1745 static void registration_success(Sal *sal, eXosip_event_t *ev){
1746 SalOp *op=sal_find_register(sal,ev->rid);
1747 osip_header_t *h=NULL;
1750 ms_error("Receiving register response for unknown operation");
1753 osip_message_get_expires(ev->request,0,&h);
1754 if (h!=NULL && atoi(h->hvalue)!=0){
1756 if (!register_again_with_updated_contact(op,ev->request,ev->response)){
1757 sal->callbacks.register_success(op,registered);
1760 sal->callbacks.register_success(op,FALSE);
1764 static bool_t registration_failure(Sal *sal, eXosip_event_t *ev){
1766 const char *reason=NULL;
1767 SalOp *op=sal_find_register(sal,ev->rid);
1768 SalReason sr=SalReasonUnknown;
1769 SalError se=SalErrorUnknown;
1772 ms_error("Receiving register failure for unknown operation");
1776 status_code=osip_message_get_status_code(ev->response);
1777 reason=osip_message_get_reason_phrase(ev->response);
1779 switch(status_code){
1782 return process_authentication(sal,ev);
1784 case 423: /*interval too brief*/
1785 {/*retry with greater interval */
1786 osip_header_t *h=NULL;
1787 osip_message_t *msg=NULL;
1788 osip_message_header_get_byname(ev->response,"min-expires",0,&h);
1789 if (h && h->hvalue && h->hvalue[0]!='\0'){
1790 int val=atoi(h->hvalue);
1791 if (val>op->expires)
1793 }else op->expires*=2;
1795 eXosip_register_build_register(op->rid,op->expires,&msg);
1796 eXosip_register_send_register(op->rid,msg);
1800 case 606: /*Not acceptable, workaround for proxies that don't like private addresses
1801 in vias, such as ekiga.net
1802 On the opposite, freephonie.net bugs when via are masqueraded.
1804 op->masquerade_via=TRUE;
1806 /* if contact is up to date, process the failure, otherwise resend a new register with
1807 updated contact first, just in case the faillure is due to incorrect contact */
1808 if (ev->response && register_again_with_updated_contact(op,ev->request,ev->response))
1809 return TRUE; /*we are retrying with an updated contact*/
1810 if (status_code==403){
1812 sr=SalReasonForbidden;
1813 }else if (status_code==0){
1814 se=SalErrorNoResponse;
1816 sal->callbacks.register_failure(op,se,sr,reason);
1821 static void other_request_reply(Sal *sal,eXosip_event_t *ev){
1822 SalOp *op=find_op(sal,ev);
1825 ms_warning("other_request_reply(): Receiving response to unknown request.");
1829 update_contact_from_response(op,ev->response);
1830 if (ev->request && strcmp(osip_message_get_method(ev->request),"OPTIONS")==0)
1831 sal->callbacks.ping_reply(op);
1835 static bool_t process_event(Sal *sal, eXosip_event_t *ev){
1836 ms_message("linphone process event get a message %d\n",ev->type);
1838 case EXOSIP_CALL_ANSWERED:
1839 ms_message("CALL_ANSWERED\n");
1840 call_accepted(sal,ev);
1841 authentication_ok(sal,ev);
1843 case EXOSIP_CALL_CLOSED:
1844 case EXOSIP_CALL_CANCELLED:
1845 ms_message("CALL_CLOSED or CANCELLED\n");
1846 call_terminated(sal,ev);
1848 case EXOSIP_CALL_TIMEOUT:
1849 case EXOSIP_CALL_NOANSWER:
1850 ms_message("CALL_TIMEOUT or NOANSWER\n");
1851 return call_failure(sal,ev);
1853 case EXOSIP_CALL_REQUESTFAILURE:
1854 case EXOSIP_CALL_GLOBALFAILURE:
1855 case EXOSIP_CALL_SERVERFAILURE:
1856 ms_message("CALL_REQUESTFAILURE or GLOBALFAILURE or SERVERFAILURE\n");
1857 return call_failure(sal,ev);
1859 case EXOSIP_CALL_RELEASED:
1860 ms_message("CALL_RELEASED\n");
1861 call_released(sal, ev);
1863 case EXOSIP_CALL_INVITE:
1864 ms_message("CALL_NEW\n");
1865 inc_new_call(sal,ev);
1867 case EXOSIP_CALL_REINVITE:
1868 handle_reinvite(sal,ev);
1870 case EXOSIP_CALL_ACK:
1871 ms_message("CALL_ACK");
1874 case EXOSIP_CALL_REDIRECTED:
1875 ms_message("CALL_REDIRECTED");
1876 eXosip_default_action(ev);
1878 case EXOSIP_CALL_PROCEEDING:
1879 ms_message("CALL_PROCEEDING");
1880 call_proceeding(sal,ev);
1882 case EXOSIP_CALL_RINGING:
1883 ms_message("CALL_RINGING");
1884 call_ringing(sal,ev);
1886 case EXOSIP_CALL_MESSAGE_NEW:
1887 ms_message("EXOSIP_CALL_MESSAGE_NEW");
1888 call_message_new(sal,ev);
1890 case EXOSIP_CALL_MESSAGE_REQUESTFAILURE:
1892 (ev->response->status_code==407 || ev->response->status_code==401)){
1893 return process_authentication(sal,ev);
1896 case EXOSIP_IN_SUBSCRIPTION_NEW:
1897 ms_message("CALL_IN_SUBSCRIPTION_NEW ");
1898 sal_exosip_subscription_recv(sal,ev);
1900 case EXOSIP_IN_SUBSCRIPTION_RELEASED:
1901 ms_message("CALL_SUBSCRIPTION_NEW ");
1902 sal_exosip_in_subscription_closed(sal,ev);
1904 case EXOSIP_SUBSCRIPTION_UPDATE:
1905 ms_message("CALL_SUBSCRIPTION_UPDATE");
1907 case EXOSIP_SUBSCRIPTION_NOTIFY:
1908 ms_message("CALL_SUBSCRIPTION_NOTIFY");
1909 sal_exosip_notify_recv(sal,ev);
1911 case EXOSIP_SUBSCRIPTION_ANSWERED:
1912 ms_message("EXOSIP_SUBSCRIPTION_ANSWERED, ev->sid=%i, ev->did=%i\n",ev->sid,ev->did);
1913 sal_exosip_subscription_answered(sal,ev);
1915 case EXOSIP_SUBSCRIPTION_CLOSED:
1916 ms_message("EXOSIP_SUBSCRIPTION_CLOSED\n");
1917 sal_exosip_subscription_closed(sal,ev);
1919 case EXOSIP_SUBSCRIPTION_REQUESTFAILURE: /**< announce a request failure */
1920 if (ev->response && (ev->response->status_code == 407 || ev->response->status_code == 401)){
1921 return process_authentication(sal,ev);
1923 case EXOSIP_SUBSCRIPTION_SERVERFAILURE:
1924 case EXOSIP_SUBSCRIPTION_GLOBALFAILURE:
1925 sal_exosip_subscription_closed(sal,ev);
1927 case EXOSIP_REGISTRATION_FAILURE:
1928 ms_message("REGISTRATION_FAILURE\n");
1929 return registration_failure(sal,ev);
1931 case EXOSIP_REGISTRATION_SUCCESS:
1932 authentication_ok(sal,ev);
1933 registration_success(sal,ev);
1935 case EXOSIP_MESSAGE_NEW:
1936 other_request(sal,ev);
1938 case EXOSIP_MESSAGE_PROCEEDING:
1939 case EXOSIP_MESSAGE_ANSWERED:
1940 case EXOSIP_MESSAGE_REDIRECTED:
1941 case EXOSIP_MESSAGE_SERVERFAILURE:
1942 case EXOSIP_MESSAGE_GLOBALFAILURE:
1943 other_request_reply(sal,ev);
1945 case EXOSIP_MESSAGE_REQUESTFAILURE:
1946 case EXOSIP_NOTIFICATION_REQUESTFAILURE:
1948 switch (ev->response->status_code) {
1951 return process_authentication(sal,ev);
1953 eXosip_automatic_action ();
1958 other_request_reply(sal,ev);
1961 ms_message("Unhandled exosip event ! %i",ev->type);
1967 int sal_iterate(Sal *sal){
1969 while((ev=eXosip_event_wait(0,0))!=NULL){
1970 if (process_event(sal,ev))
1971 eXosip_event_free(ev);
1974 eXosip_automatic_refresh();
1979 static void register_set_contact(osip_message_t *msg, const char *contact){
1980 osip_uri_param_t *param = NULL;
1981 osip_contact_t *ct=NULL;
1983 /*we get the line parameter choosed by exosip, and add it to our own contact*/
1984 osip_message_get_contact(msg,0,&ct);
1986 osip_uri_uparam_get_byname(ct->url, "line", ¶m);
1987 if (param && param->gvalue)
1988 line=osip_strdup(param->gvalue);
1990 _osip_list_set_empty(&msg->contacts,(void (*)(void*))osip_contact_free);
1991 osip_message_set_contact(msg,contact);
1992 osip_message_get_contact(msg,0,&ct);
1993 osip_uri_uparam_add(ct->url,osip_strdup("line"),line);
1996 int sal_register(SalOp *h, const char *proxy, const char *from, int expires){
1997 osip_message_t *msg;
1998 const char *contact=sal_op_get_contact(h);
2000 sal_op_set_route(h,proxy);
2003 h->rid=eXosip_register_build_initial_register(from,proxy,NULL,expires,&msg);
2005 if (contact) register_set_contact(msg,contact);
2006 sal_add_register(h->base.root,h);
2008 ms_error("Could not build initial register.");
2014 eXosip_register_build_register(h->rid,expires,&msg);
2016 eXosip_register_send_register(h->rid,msg);
2022 int sal_register_refresh(SalOp *op, int expires){
2023 osip_message_t *msg=NULL;
2024 const char *contact=sal_op_get_contact(op);
2027 ms_error("Unexistant registration context, not possible to refresh.");
2031 eXosip_register_build_register(op->rid,expires,&msg);
2033 if (contact) register_set_contact(msg,contact);
2034 eXosip_register_send_register(op->rid,msg);
2035 }else ms_error("Could not build REGISTER refresh message.");
2041 int sal_unregister(SalOp *h){
2042 osip_message_t *msg=NULL;
2044 eXosip_register_build_register(h->rid,0,&msg);
2045 if (msg) eXosip_register_send_register(h->rid,msg);
2046 else ms_warning("Could not build unREGISTER !");
2051 SalAddress * sal_address_new(const char *uri){
2053 osip_from_init(&from);
2055 // Remove front spaces
2056 while (uri[0]==' ') {
2060 if (osip_from_parse(from,uri)!=0){
2061 osip_from_free(from);
2064 if (from->displayname!=NULL && from->displayname[0]=='"'){
2065 char *unquoted=osip_strdup_without_quote(from->displayname);
2066 osip_free(from->displayname);
2067 from->displayname=unquoted;
2069 return (SalAddress*)from;
2072 SalAddress * sal_address_clone(const SalAddress *addr){
2073 osip_from_t *ret=NULL;
2074 osip_from_clone((osip_from_t*)addr,&ret);
2075 return (SalAddress*)ret;
2078 #define null_if_empty(s) (((s)!=NULL && (s)[0]!='\0') ? (s) : NULL )
2080 const char *sal_address_get_scheme(const SalAddress *addr){
2081 const osip_from_t *u=(const osip_from_t*)addr;
2082 return null_if_empty(u->url->scheme);
2085 const char *sal_address_get_display_name(const SalAddress* addr){
2086 const osip_from_t *u=(const osip_from_t*)addr;
2087 return null_if_empty(u->displayname);
2090 const char *sal_address_get_username(const SalAddress *addr){
2091 const osip_from_t *u=(const osip_from_t*)addr;
2092 return null_if_empty(u->url->username);
2095 const char *sal_address_get_domain(const SalAddress *addr){
2096 const osip_from_t *u=(const osip_from_t*)addr;
2097 return null_if_empty(u->url->host);
2100 void sal_address_set_display_name(SalAddress *addr, const char *display_name){
2101 osip_from_t *u=(osip_from_t*)addr;
2102 if (u->displayname!=NULL){
2103 osip_free(u->displayname);
2104 u->displayname=NULL;
2106 if (display_name!=NULL && display_name[0]!='\0'){
2107 u->displayname=osip_strdup(display_name);
2111 void sal_address_set_username(SalAddress *addr, const char *username){
2112 osip_from_t *uri=(osip_from_t*)addr;
2113 if (uri->url->username!=NULL){
2114 osip_free(uri->url->username);
2115 uri->url->username=NULL;
2118 uri->url->username=osip_strdup(username);
2121 void sal_address_set_domain(SalAddress *addr, const char *host){
2122 osip_from_t *uri=(osip_from_t*)addr;
2123 if (uri->url->host!=NULL){
2124 osip_free(uri->url->host);
2125 uri->url->host=NULL;
2128 uri->url->host=osip_strdup(host);
2131 void sal_address_set_port(SalAddress *addr, const char *port){
2132 osip_from_t *uri=(osip_from_t*)addr;
2133 if (uri->url->port!=NULL){
2134 osip_free(uri->url->port);
2135 uri->url->port=NULL;
2138 uri->url->port=osip_strdup(port);
2141 void sal_address_set_port_int(SalAddress *uri, int port){
2144 /*this is the default, special case to leave the port field blank*/
2145 sal_address_set_port(uri,NULL);
2148 snprintf(tmp,sizeof(tmp),"%i",port);
2149 sal_address_set_port(uri,tmp);
2152 void sal_address_clean(SalAddress *addr){
2153 osip_generic_param_freelist(& ((osip_from_t*)addr)->gen_params);
2154 osip_uri_param_freelist(& ((osip_from_t*)addr)->url->url_params);
2157 char *sal_address_as_string(const SalAddress *u){
2159 osip_from_t *from=(osip_from_t *)u;
2160 char *old_displayname=NULL;
2161 /* hack to force use of quotes around the displayname*/
2162 if (from->displayname!=NULL
2163 && from->displayname[0]!='"'){
2164 old_displayname=from->displayname;
2165 from->displayname=osip_enquote(from->displayname);
2167 osip_from_to_str(from,&tmp);
2168 if (old_displayname!=NULL){
2169 ms_free(from->displayname);
2170 from->displayname=old_displayname;
2177 char *sal_address_as_string_uri_only(const SalAddress *u){
2178 char *tmp=NULL,*ret;
2179 osip_uri_to_str(((osip_from_t*)u)->url,&tmp);
2184 void sal_address_set_param(SalAddress *u,const char* name,const char* value) {
2185 osip_uri_param_t *param=NULL;
2186 osip_uri_uparam_get_byname(((osip_from_t*)u)->url,(char*)name,¶m);
2188 osip_uri_uparam_add (((osip_from_t*)u)->url,ms_strdup(name),ms_strdup(value));
2190 osip_free(param->gvalue);
2191 param->gvalue=osip_strdup(value);
2196 void sal_address_destroy(SalAddress *u){
2197 osip_from_free((osip_from_t*)u);
2200 void sal_set_keepalive_period(Sal *ctx,unsigned int value) {
2201 ctx->keepalive_period=value;
2202 eXosip_set_option (EXOSIP_OPT_UDP_KEEP_ALIVE, &value);
2204 unsigned int sal_get_keepalive_period(Sal *ctx) {
2205 return ctx->keepalive_period;
2208 const char * sal_address_get_port(const SalAddress *addr) {
2209 const osip_from_t *u=(const osip_from_t*)addr;
2210 return null_if_empty(u->url->port);
2213 int sal_address_get_port_int(const SalAddress *uri) {
2214 const char* port = sal_address_get_port(uri);
2221 SalTransport sal_address_get_transport(const SalAddress* addr) {
2222 const osip_from_t *u=(const osip_from_t*)addr;
2223 osip_uri_param_t *transport_param=NULL;
2224 osip_uri_uparam_get_byname(u->url,"transport",&transport_param);
2225 if (transport_param == NULL){
2226 return SalTransportUDP;
2228 return sal_transport_parse(transport_param->gvalue);
2231 void sal_address_set_transport(SalAddress* addr,SalTransport transport) {
2232 sal_address_set_param(addr, "transport", sal_transport_to_string(transport));
2235 /* sends a reinvite. Local media description may have changed by application since call establishment*/
2236 int sal_call_update(SalOp *h, const char *subject){
2238 osip_message_t *reinvite=NULL;
2241 if(eXosip_call_build_request(h->did,"INVITE",&reinvite) != 0 || reinvite==NULL){
2246 osip_message_set_subject(reinvite,subject);
2247 osip_message_set_allow(reinvite, "INVITE, ACK, CANCEL, OPTIONS, BYE, REFER, NOTIFY, MESSAGE, SUBSCRIBE, INFO");
2248 if (h->base.root->session_expires!=0){
2249 osip_message_set_header(reinvite, "Session-expires", "200");
2250 osip_message_set_supported(reinvite, "timer");
2252 if (h->base.local_media){
2253 h->sdp_offering=TRUE;
2254 set_sdp_from_desc(reinvite,h->base.local_media);
2255 }else h->sdp_offering=FALSE;
2257 err = eXosip_call_send_request(h->did, reinvite);
2261 void sal_reuse_authorization(Sal *ctx, bool_t value) {
2262 ctx->reuse_authorization=value;