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, bool_t expire_last_contact);
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_new0(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;
285 sal->verify_server_certs=TRUE;
286 sal->expire_old_contact=FALSE;
290 void sal_uninit(Sal* sal){
293 ms_free(sal->rootCa);
297 void sal_set_user_pointer(Sal *sal, void *user_data){
301 void *sal_get_user_pointer(const Sal *sal){
305 static void unimplemented_stub(){
306 ms_warning("Unimplemented SAL callback");
309 void sal_set_callbacks(Sal *ctx, const SalCallbacks *cbs){
310 memcpy(&ctx->callbacks,cbs,sizeof(*cbs));
311 if (ctx->callbacks.call_received==NULL)
312 ctx->callbacks.call_received=(SalOnCallReceived)unimplemented_stub;
313 if (ctx->callbacks.call_ringing==NULL)
314 ctx->callbacks.call_ringing=(SalOnCallRinging)unimplemented_stub;
315 if (ctx->callbacks.call_accepted==NULL)
316 ctx->callbacks.call_accepted=(SalOnCallAccepted)unimplemented_stub;
317 if (ctx->callbacks.call_failure==NULL)
318 ctx->callbacks.call_failure=(SalOnCallFailure)unimplemented_stub;
319 if (ctx->callbacks.call_terminated==NULL)
320 ctx->callbacks.call_terminated=(SalOnCallTerminated)unimplemented_stub;
321 if (ctx->callbacks.call_released==NULL)
322 ctx->callbacks.call_released=(SalOnCallReleased)unimplemented_stub;
323 if (ctx->callbacks.call_updating==NULL)
324 ctx->callbacks.call_updating=(SalOnCallUpdating)unimplemented_stub;
325 if (ctx->callbacks.auth_requested==NULL)
326 ctx->callbacks.auth_requested=(SalOnAuthRequested)unimplemented_stub;
327 if (ctx->callbacks.auth_success==NULL)
328 ctx->callbacks.auth_success=(SalOnAuthSuccess)unimplemented_stub;
329 if (ctx->callbacks.register_success==NULL)
330 ctx->callbacks.register_success=(SalOnRegisterSuccess)unimplemented_stub;
331 if (ctx->callbacks.register_failure==NULL)
332 ctx->callbacks.register_failure=(SalOnRegisterFailure)unimplemented_stub;
333 if (ctx->callbacks.dtmf_received==NULL)
334 ctx->callbacks.dtmf_received=(SalOnDtmfReceived)unimplemented_stub;
335 if (ctx->callbacks.notify==NULL)
336 ctx->callbacks.notify=(SalOnNotify)unimplemented_stub;
337 if (ctx->callbacks.notify_presence==NULL)
338 ctx->callbacks.notify_presence=(SalOnNotifyPresence)unimplemented_stub;
339 if (ctx->callbacks.subscribe_received==NULL)
340 ctx->callbacks.subscribe_received=(SalOnSubscribeReceived)unimplemented_stub;
341 if (ctx->callbacks.text_received==NULL)
342 ctx->callbacks.text_received=(SalOnTextReceived)unimplemented_stub;
343 if (ctx->callbacks.ping_reply==NULL)
344 ctx->callbacks.ping_reply=(SalOnPingReply)unimplemented_stub;
347 int sal_unlisten_ports(Sal *ctx){
356 int sal_listen_port(Sal *ctx, const char *addr, int port, SalTransport tr, int is_secure){
359 int proto=IPPROTO_UDP;
360 int keepalive = ctx->keepalive_period;
363 case SalTransportUDP:
365 eXosip_set_option (EXOSIP_OPT_UDP_KEEP_ALIVE, &keepalive);
367 case SalTransportTCP:
368 case SalTransportTLS:
371 eXosip_set_option (EXOSIP_OPT_UDP_KEEP_ALIVE,&keepalive);
374 eXosip_tls_ctx_t tlsCtx;
375 memset(&tlsCtx, 0, sizeof(tlsCtx));
376 snprintf(tlsCtx.root_ca_cert, sizeof(tlsCtx.client.cert), "%s", ctx->rootCa);
377 eXosip_set_tls_ctx(&tlsCtx);
379 #ifdef HAVE_EXOSIP_TLS_VERIFY_CERTIFICATE
380 eXosip_tls_verify_certificate(ctx->verify_server_certs);
384 ms_warning("unexpected proto, using datagram");
386 /*see if it looks like an IPv6 address*/
387 int use_rports = ctx->use_rports; // Copy char to int to avoid bad alignment
388 eXosip_set_option(EXOSIP_OPT_USE_RPORT,&use_rports);
389 int dont_use_101 = !ctx->use_101; // Copy char to int to avoid bad alignment
390 eXosip_set_option(EXOSIP_OPT_DONT_SEND_101,&dont_use_101);
392 ipv6=strchr(addr,':')!=NULL;
393 eXosip_enable_ipv6(ipv6);
395 if (is_secure && tr == SalTransportUDP){
396 ms_fatal("SIP over DTLS is not supported yet.");
399 err=eXosip_listen_addr(proto, addr, port, ipv6 ? PF_INET6 : PF_INET, is_secure);
404 ortp_socket_t sal_get_socket(Sal *ctx){
405 #ifdef HAVE_EXOSIP_GET_SOCKET
406 return eXosip_get_socket(IPPROTO_UDP);
408 ms_warning("Sorry, eXosip does not have eXosip_get_socket() method");
413 void sal_set_user_agent(Sal *ctx, const char *user_agent){
414 eXosip_set_user_agent(user_agent);
417 void sal_use_session_timers(Sal *ctx, int expires){
418 ctx->session_expires=expires;
421 void sal_use_one_matching_codec_policy(Sal *ctx, bool_t one_matching_codec){
422 ctx->one_matching_codec=one_matching_codec;
425 MSList *sal_get_pending_auths(Sal *sal){
426 return ms_list_copy(sal->pending_auths);
429 void sal_use_double_registrations(Sal *ctx, bool_t enabled){
430 ctx->double_reg=enabled;
433 void sal_expire_old_registration_contacts(Sal *ctx, bool_t enabled){
434 ctx->expire_old_contact=enabled;
437 void sal_use_rport(Sal *ctx, bool_t use_rports){
438 ctx->use_rports=use_rports;
440 void sal_use_101(Sal *ctx, bool_t use_101){
441 ctx->use_101=use_101;
444 void sal_set_root_ca(Sal* ctx, const char* rootCa) {
446 ms_free(ctx->rootCa);
447 ctx->rootCa = ms_strdup(rootCa);
450 void sal_verify_server_certificates(Sal *ctx, bool_t verify){
451 ctx->verify_server_certs=verify;
452 #ifdef HAVE_EXOSIP_TLS_VERIFY_CERTIFICATE
453 eXosip_tls_verify_certificate(verify);
457 static int extract_received_rport(osip_message_t *msg, const char **received, int *rportval,SalTransport* transport){
458 osip_via_t *via=NULL;
459 osip_generic_param_t *param=NULL;
460 const char *rport=NULL;
464 osip_message_get_via(msg,0,&via);
466 ms_warning("extract_received_rport(): no via.");
470 *transport = sal_transport_parse(via->protocol);
472 if (via->port && via->port[0]!='\0')
473 *rportval=atoi(via->port);
475 osip_via_param_get_byname(via,"rport",¶m);
478 if (rport && rport[0]!='\0') *rportval=atoi(rport);
482 osip_via_param_get_byname(via,"received",¶m);
483 if (param) *received=param->gvalue;
485 if (rport==NULL && *received==NULL){
486 ms_warning("extract_received_rport(): no rport and no received parameters.");
492 static void set_sdp(osip_message_t *sip,sdp_message_t *msg){
496 sdp_message_to_str(msg,&sdp);
498 snprintf(clen,sizeof(clen),"%i",sdplen);
499 osip_message_set_body(sip,sdp,sdplen);
500 osip_message_set_content_type(sip,"application/sdp");
501 osip_message_set_content_length(sip,clen);
505 static void set_sdp_from_desc(osip_message_t *sip, const SalMediaDescription *desc){
506 sdp_message_t *msg=media_description_to_sdp(desc);
508 ms_error("Fail to print sdp message !");
512 sdp_message_free(msg);
515 static void sdp_process(SalOp *h){
516 ms_message("Doing SDP offer/answer process of type %s",h->sdp_offering ? "outgoing" : "incoming");
518 sal_media_description_unref(h->result);
520 h->result=sal_media_description_new();
521 if (h->sdp_offering){
522 offer_answer_initiate_outgoing(h->base.local_media,h->base.remote_media,h->result);
526 sdp_message_free(h->sdp_answer);
528 offer_answer_initiate_incoming(h->base.local_media,h->base.remote_media,h->result,h->base.root->one_matching_codec);
529 h->sdp_answer=media_description_to_sdp(h->result);
530 /*once we have generated the SDP answer, we modify the result description for processing by the upper layer.
531 It should contains media parameters constraint from the remote offer, not our response*/
532 strcpy(h->result->addr,h->base.remote_media->addr);
533 h->result->bandwidth=h->base.remote_media->bandwidth;
535 for(i=0;i<h->result->nstreams;++i){
536 if (h->result->streams[i].port>0){
537 strcpy(h->result->streams[i].addr,h->base.remote_media->streams[i].addr);
538 h->result->streams[i].ptime=h->base.remote_media->streams[i].ptime;
539 h->result->streams[i].bandwidth=h->base.remote_media->streams[i].bandwidth;
540 h->result->streams[i].port=h->base.remote_media->streams[i].port;
542 if (h->result->streams[i].proto == SalProtoRtpSavp) {
543 h->result->streams[i].crypto[0] = h->base.remote_media->streams[i].crypto[0];
551 int sal_call_is_offerer(const SalOp *h){
552 return h->sdp_offering;
555 int sal_call_set_local_media_description(SalOp *h, SalMediaDescription *desc){
557 sal_media_description_ref(desc);
558 if (h->base.local_media)
559 sal_media_description_unref(h->base.local_media);
560 h->base.local_media=desc;
561 if (h->base.remote_media){
562 /*case of an incoming call where we modify the local capabilities between the time
563 * the call is ringing and it is accepted (for example if you want to accept without video*/
564 /*reset the sdp answer so that it is computed again*/
566 sdp_message_free(h->sdp_answer);
573 int sal_call(SalOp *h, const char *from, const char *to){
576 osip_message_t *invite=NULL;
577 sal_op_set_from(h,from);
579 sal_exosip_fix_route(h);
581 h->terminated = FALSE;
583 route = sal_op_get_route(h);
584 err=eXosip_call_build_initial_invite(&invite,to,from,route,"Phone call");
586 ms_error("Could not create call. Error %d (from=%s to=%s route=%s)",
587 err, from, to, route);
590 osip_message_set_allow(invite, "INVITE, ACK, CANCEL, OPTIONS, BYE, REFER, NOTIFY, MESSAGE, SUBSCRIBE, INFO");
591 if (h->base.contact){
592 _osip_list_set_empty(&invite->contacts,(void (*)(void*))osip_contact_free);
593 osip_message_set_contact(invite,h->base.contact);
595 if (h->base.root->session_expires!=0){
596 osip_message_set_header(invite, "Session-expires", "200");
597 osip_message_set_supported(invite, "timer");
599 if (h->base.local_media){
600 h->sdp_offering=TRUE;
601 set_sdp_from_desc(invite,h->base.local_media);
602 }else h->sdp_offering=FALSE;
604 osip_message_set_header(invite,"Replaces",h->replaces);
606 osip_message_set_header(invite,"Referred-By",h->referred_by);
610 err=eXosip_call_send_initial_invite(invite);
614 ms_error("Fail to send invite ! Error code %d", err);
617 sal_add_call(h->base.root,h);
622 int sal_call_notify_ringing(SalOp *h, bool_t early_media){
625 /*if early media send also 180 and 183 */
629 eXosip_call_build_answer(h->tid,183,&msg);
633 set_sdp(msg,h->sdp_answer);
634 sdp_message_free(h->sdp_answer);
637 eXosip_call_send_answer(h->tid,183,msg);
642 eXosip_call_send_answer(h->tid,180,NULL);
648 int sal_call_accept(SalOp * h){
650 const char *contact=sal_op_get_contact(h);
652 int err=eXosip_call_build_answer(h->tid,200,&msg);
653 if (err<0 || msg==NULL){
654 ms_error("Fail to build answer for call: err=%i",err);
657 if (h->base.root->session_expires!=0){
658 if (h->supports_session_timers) osip_message_set_supported(msg, "timer");
662 _osip_list_set_empty(&msg->contacts,(void (*)(void*))osip_contact_free);
663 osip_message_set_contact(msg,contact);
666 if (h->base.local_media){
667 /*this is the case where we received an invite without SDP*/
668 if (h->sdp_offering) {
669 set_sdp_from_desc(msg,h->base.local_media);
671 if (h->sdp_answer==NULL) sdp_process(h);
673 set_sdp(msg,h->sdp_answer);
674 sdp_message_free(h->sdp_answer);
679 ms_error("You are accepting a call but not defined any media capabilities !");
681 eXosip_call_send_answer(h->tid,200,msg);
685 int sal_call_decline(SalOp *h, SalReason reason, const char *redirect){
686 if (reason==SalReasonBusy){
688 eXosip_call_send_answer(h->tid,486,NULL);
691 else if (reason==SalReasonTemporarilyUnavailable){
693 eXosip_call_send_answer(h->tid,480,NULL);
695 }else if (reason==SalReasonDoNotDisturb){
697 eXosip_call_send_answer(h->tid,600,NULL);
699 }else if (reason==SalReasonMedia){
701 eXosip_call_send_answer(h->tid,415,NULL);
703 }else if (redirect!=NULL && reason==SalReasonRedirect){
706 if (strstr(redirect,"sip:")!=0) code=302;
709 eXosip_call_build_answer(h->tid,code,&msg);
710 osip_message_set_contact(msg,redirect);
711 eXosip_call_send_answer(h->tid,code,msg);
713 }else sal_call_terminate(h);
717 SalMediaDescription * sal_call_get_remote_media_description(SalOp *h){
718 return h->base.remote_media;
721 SalMediaDescription * sal_call_get_final_media_description(SalOp *h){
722 if (h->base.local_media && h->base.remote_media && !h->result){
728 int sal_call_set_referer(SalOp *h, SalOp *refered_call){
729 if (refered_call->replaces)
730 h->replaces=ms_strdup(refered_call->replaces);
731 if (refered_call->referred_by)
732 h->referred_by=ms_strdup(refered_call->referred_by);
736 static int send_notify_for_refer(int did, const char *sipfrag){
739 eXosip_call_build_notify(did,EXOSIP_SUBCRSTATE_ACTIVE,&msg);
742 ms_warning("Could not build NOTIFY for refer.");
745 osip_message_set_content_type(msg,"message/sipfrag");
746 osip_message_set_header(msg,"Event","refer");
747 osip_message_set_body(msg,sipfrag,strlen(sipfrag));
748 eXosip_call_send_request(did,msg);
753 /* currently only support to notify trying and 200Ok*/
754 int sal_call_notify_refer_state(SalOp *h, SalOp *newcall){
757 send_notify_for_refer(h->did,"SIP/2.0 100 Trying\r\n");
759 else if (newcall->cid!=-1){
760 if (newcall->did==-1){
761 /* not yet established*/
762 if (!newcall->terminated){
764 send_notify_for_refer(h->did,"SIP/2.0 100 Trying\r\n");
767 if (!newcall->terminated){
768 if (send_notify_for_refer(h->did,"SIP/2.0 200 Ok\r\n")==-1){
769 /* we need previous notify transaction to complete, so buffer the request for later*/
770 h->sipfrag_pending="SIP/2.0 200 Ok\r\n";
778 int sal_ping(SalOp *op, const char *from, const char *to){
779 osip_message_t *options=NULL;
781 sal_op_set_from(op,from);
782 sal_op_set_to(op,to);
783 sal_exosip_fix_route(op);
785 eXosip_options_build_request (&options, sal_op_get_to(op),
786 sal_op_get_from(op),sal_op_get_route(op));
788 if (op->base.root->session_expires!=0){
789 osip_message_set_header(options, "Session-expires", "200");
790 osip_message_set_supported(options, "timer");
792 sal_add_other(sal_op_get_sal(op),op,options);
793 return eXosip_options_send_request(options);
798 int sal_call_refer(SalOp *h, const char *refer_to){
799 osip_message_t *msg=NULL;
802 eXosip_call_build_refer(h->did,refer_to, &msg);
803 if (msg) err=eXosip_call_send_request(h->did, msg);
809 int sal_call_refer_with_replaces(SalOp *h, SalOp *other_call_h){
810 osip_message_t *msg=NULL;
811 char referto[256]={0};
814 if (eXosip_call_get_referto(other_call_h->did,referto,sizeof(referto)-1)!=0){
815 ms_error("eXosip_call_get_referto() failed for did=%i",other_call_h->did);
819 eXosip_call_build_refer(h->did,referto, &msg);
820 osip_message_set_header(msg,"Referred-By",h->base.from);
821 if (msg) err=eXosip_call_send_request(h->did, msg);
827 SalOp *sal_call_get_replaces(SalOp *h){
828 if (h!=NULL && h->replaces!=NULL){
831 cid=eXosip_call_find_by_replaces(h->replaces);
834 SalOp *ret=sal_find_call(h->base.root,cid);
841 int sal_call_send_dtmf(SalOp *h, char dtmf){
842 osip_message_t *msg=NULL;
847 eXosip_call_build_info(h->did,&msg);
849 snprintf(dtmf_body, sizeof(dtmf_body), "Signal=%c\r\nDuration=250\r\n", dtmf);
850 osip_message_set_body(msg,dtmf_body,strlen(dtmf_body));
851 osip_message_set_content_type(msg,"application/dtmf-relay");
852 snprintf(clen,sizeof(clen),"%lu",(unsigned long)strlen(dtmf_body));
853 osip_message_set_content_length(msg,clen);
854 eXosip_call_send_request(h->did,msg);
860 static void push_auth_to_exosip(const SalAuthInfo *info){
862 if (info->userid==NULL || info->userid[0]=='\0') userid=info->username;
863 else userid=info->userid;
864 ms_message("Authentication info for username [%s], id[%s], realm [%s] added to eXosip", info->username,userid, info->realm);
865 eXosip_add_authentication_info (info->username,userid,
866 info->password, NULL,info->realm);
869 * Just for symmetry ;-)
871 static void pop_auth_from_exosip() {
872 eXosip_clear_authentication_info();
875 int sal_call_terminate(SalOp *h){
877 if (h == NULL) return -1;
878 if (h->auth_info) push_auth_to_exosip(h->auth_info);
880 err=eXosip_call_terminate(h->cid,h->did);
882 if (!h->base.root->reuse_authorization) pop_auth_from_exosip();
884 ms_warning("Exosip could not terminate the call: cid=%i did=%i", h->cid,h->did);
890 void sal_op_authenticate(SalOp *h, const SalAuthInfo *info){
891 if (h->terminated) return;
892 if (h->pending_auth){
893 push_auth_to_exosip(info);
895 /*FIXME exosip does not take into account this update register message*/
897 if (fix_message_contact(h, h->pending_auth->request,h->pending_auth->response)) {
901 update_contact_from_response(h,h->pending_auth->response);
903 eXosip_default_action(h->pending_auth);
905 ms_message("eXosip_default_action() done");
906 if (!h->base.root->reuse_authorization) pop_auth_from_exosip();
908 if (h->auth_info) sal_auth_info_delete(h->auth_info); /*if already exist*/
909 h->auth_info=sal_auth_info_clone(info); /*store auth info for subsequent request*/
912 void sal_op_cancel_authentication(SalOp *h) {
914 sal_op_get_sal(h)->callbacks.register_failure(h,SalErrorFailure, SalReasonForbidden,_("Authentication failure"));
915 } else if (h->cid >0) {
916 sal_op_get_sal(h)->callbacks.call_failure(h,SalErrorFailure, SalReasonForbidden,_("Authentication failure"),0);
918 ms_warning("Auth failure not handled");
922 static void set_network_origin(SalOp *op, osip_message_t *req){
923 const char *received=NULL;
926 SalTransport transport;
927 if (extract_received_rport(req,&received,&rport,&transport)!=0){
928 osip_via_t *via=NULL;
930 osip_message_get_via(req,0,&via);
931 received=osip_via_get_host(via);
932 tmp=osip_via_get_port(via);
933 if (tmp) rport=atoi(tmp);
935 if (transport != SalTransportUDP) {
936 snprintf(origin,sizeof(origin)-1,"sip:%s:%i",received,rport);
938 snprintf(origin,sizeof(origin)-1,"sip:%s:%i;transport=%s",received,rport,sal_transport_to_string(transport));
940 __sal_op_set_network_origin(op,origin);
943 static void set_remote_ua(SalOp* op, osip_message_t *req){
944 if (op->base.remote_ua==NULL){
945 osip_header_t *h=NULL;
946 osip_message_get_user_agent(req,0,&h);
948 op->base.remote_ua=ms_strdup(h->hvalue);
953 static void set_replaces(SalOp *op, osip_message_t *req){
954 osip_header_t *h=NULL;
957 ms_free(op->replaces);
960 osip_message_header_get_byname(req,"replaces",0,&h);
962 if (h->hvalue && h->hvalue[0]!='\0'){
963 op->replaces=ms_strdup(h->hvalue);
968 static SalOp *find_op(Sal *sal, eXosip_event_t *ev){
970 return sal_find_call(sal,ev->cid);
973 return sal_find_register(sal,ev->rid);
976 return sal_find_out_subscribe(sal,ev->sid);
979 return sal_find_in_subscribe(sal,ev->nid);
981 if (ev->response) return sal_find_other(sal,ev->response);
985 static void inc_new_call(Sal *sal, eXosip_event_t *ev){
986 SalOp *op=sal_op_new(sal);
987 osip_from_t *from,*to;
988 osip_call_info_t *call_info;
990 sdp_message_t *sdp=eXosip_get_sdp_info(ev->request);
992 set_network_origin(op,ev->request);
993 set_remote_ua(op,ev->request);
994 set_replaces(op,ev->request);
997 op->sdp_offering=FALSE;
998 op->base.remote_media=sal_media_description_new();
999 sdp_to_media_description(sdp,op->base.remote_media);
1000 sdp_message_free(sdp);
1001 }else op->sdp_offering=TRUE;
1003 from=osip_message_get_from(ev->request);
1004 to=osip_message_get_to(ev->request);
1005 osip_from_to_str(from,&tmp);
1006 sal_op_set_from(op,tmp);
1008 osip_from_to_str(to,&tmp);
1009 sal_op_set_to(op,tmp);
1012 osip_message_get_call_info(ev->request,0,&call_info);
1015 osip_call_info_to_str(call_info,&tmp);
1016 if( strstr(tmp,"answer-after=") != NULL)
1018 op->auto_answer_asked=TRUE;
1019 ms_message("The caller asked to automatically answer the call(Emergency?)\n");
1028 sal_add_call(op->base.root,op);
1029 sal->callbacks.call_received(op);
1032 static void handle_reinvite(Sal *sal, eXosip_event_t *ev){
1033 SalOp *op=find_op(sal,ev);
1037 ms_warning("Reinvite for non-existing operation !");
1042 sdp=eXosip_get_sdp_info(ev->request);
1043 if (op->base.remote_media){
1044 sal_media_description_unref(op->base.remote_media);
1045 op->base.remote_media=NULL;
1048 sal_media_description_unref(op->result);
1052 op->sdp_offering=FALSE;
1053 op->base.remote_media=sal_media_description_new();
1054 sdp_to_media_description(sdp,op->base.remote_media);
1055 sdp_message_free(sdp);
1058 op->sdp_offering=TRUE;
1060 sal->callbacks.call_updating(op);
1063 static void handle_ack(Sal *sal, eXosip_event_t *ev){
1064 SalOp *op=find_op(sal,ev);
1068 ms_warning("ack for non-existing call !");
1071 if (op->terminated) {
1072 ms_warning("ack for terminated call, ignoring");
1076 if (op->sdp_offering){
1077 sdp=eXosip_get_sdp_info(ev->ack);
1079 if (op->base.remote_media)
1080 sal_media_description_unref(op->base.remote_media);
1081 op->base.remote_media=sal_media_description_new();
1082 sdp_to_media_description(sdp,op->base.remote_media);
1084 sdp_message_free(sdp);
1090 sal->callbacks.call_ack(op);
1093 static void update_contact_from_response(SalOp *op, osip_message_t *response){
1094 const char *received;
1096 SalTransport transport;
1097 if (extract_received_rport(response,&received,&rport,&transport)==0){
1098 const char *contact=sal_op_get_contact(op);
1100 /*no contact given yet, use from instead*/
1101 contact=sal_op_get_from(op);
1104 SalAddress *addr=sal_address_new(contact);
1106 sal_address_set_domain(addr,received);
1107 sal_address_set_port_int(addr,rport);
1108 if (transport!=SalTransportUDP)
1109 sal_address_set_transport(addr,transport);
1110 tmp=sal_address_as_string(addr);
1111 ms_message("Contact address updated to %s",tmp);
1112 sal_op_set_contact(op,tmp);
1113 sal_address_destroy(addr);
1119 static int call_proceeding(Sal *sal, eXosip_event_t *ev){
1120 SalOp *op=find_op(sal,ev);
1122 if (op==NULL || op->terminated==TRUE) {
1123 ms_warning("This call has been canceled.");
1125 eXosip_call_terminate(ev->cid,ev->did);
1133 /* update contact if received and rport are set by the server
1134 note: will only be used by remote for next INVITE, if any...*/
1135 update_contact_from_response(op,ev->response);
1139 static void call_ringing(Sal *sal, eXosip_event_t *ev){
1141 SalOp *op=find_op(sal,ev);
1142 if (call_proceeding(sal, ev)==-1) return;
1144 set_remote_ua(op,ev->response);
1145 sdp=eXosip_get_sdp_info(ev->response);
1147 op->base.remote_media=sal_media_description_new();
1148 sdp_to_media_description(sdp,op->base.remote_media);
1149 sdp_message_free(sdp);
1150 if (op->base.local_media) sdp_process(op);
1152 sal->callbacks.call_ringing(op);
1155 static void call_accepted(Sal *sal, eXosip_event_t *ev){
1157 osip_message_t *msg=NULL;
1158 SalOp *op=find_op(sal,ev);
1159 const char *contact;
1161 if (op==NULL || op->terminated==TRUE) {
1162 ms_warning("This call has been already terminated.");
1164 eXosip_call_terminate(ev->cid,ev->did);
1170 set_remote_ua(op,ev->response);
1172 sdp=eXosip_get_sdp_info(ev->response);
1174 op->base.remote_media=sal_media_description_new();
1175 sdp_to_media_description(sdp,op->base.remote_media);
1176 sdp_message_free(sdp);
1177 if (op->base.local_media) sdp_process(op);
1179 eXosip_call_build_ack(ev->did,&msg);
1181 ms_warning("This call has been already terminated.");
1183 eXosip_call_terminate(ev->cid,ev->did);
1187 contact=sal_op_get_contact(op);
1189 _osip_list_set_empty(&msg->contacts,(void (*)(void*))osip_contact_free);
1190 osip_message_set_contact(msg,contact);
1192 if (op->sdp_answer){
1193 set_sdp(msg,op->sdp_answer);
1194 sdp_message_free(op->sdp_answer);
1195 op->sdp_answer=NULL;
1197 eXosip_call_send_ack(ev->did,msg);
1198 sal->callbacks.call_accepted(op);
1201 static void call_terminated(Sal *sal, eXosip_event_t *ev){
1203 SalOp *op=find_op(sal,ev);
1205 ms_warning("Call terminated for already closed call ?");
1209 osip_from_to_str(ev->request->from,&from);
1211 sal->callbacks.call_terminated(op,from!=NULL ? from : sal_op_get_from(op));
1212 if (from) osip_free(from);
1213 op->terminated=TRUE;
1216 static void call_released(Sal *sal, eXosip_event_t *ev){
1217 SalOp *op=find_op(sal,ev);
1219 ms_warning("No op associated to this call_released()");
1222 if (!op->terminated){
1223 /* no response received so far */
1224 call_failure(sal,ev);
1226 sal->callbacks.call_released(op);
1229 static int get_auth_data_from_response(osip_message_t *resp, const char **realm, const char **username){
1230 const char *prx_realm=NULL,*www_realm=NULL;
1231 osip_proxy_authenticate_t *prx_auth;
1232 osip_www_authenticate_t *www_auth;
1234 *username=osip_uri_get_username(resp->from->url);
1235 prx_auth=(osip_proxy_authenticate_t*)osip_list_get(&resp->proxy_authenticates,0);
1236 www_auth=(osip_proxy_authenticate_t*)osip_list_get(&resp->www_authenticates,0);
1238 prx_realm=osip_proxy_authenticate_get_realm(prx_auth);
1240 www_realm=osip_www_authenticate_get_realm(www_auth);
1244 }else if (www_realm){
1252 static int get_auth_data_from_request(osip_message_t *msg, const char **realm, const char **username){
1253 osip_authorization_t *auth=NULL;
1254 osip_proxy_authorization_t *prx_auth=NULL;
1256 *username=osip_uri_get_username(msg->from->url);
1257 osip_message_get_authorization(msg, 0, &auth);
1259 *realm=osip_authorization_get_realm(auth);
1262 osip_message_get_proxy_authorization(msg,0,&prx_auth);
1264 *realm=osip_proxy_authorization_get_realm(prx_auth);
1270 static int get_auth_data(eXosip_event_t *ev, const char **realm, const char **username){
1271 if (ev->response && get_auth_data_from_response(ev->response,realm,username)==0) return 0;
1272 if (ev->request && get_auth_data_from_request(ev->request,realm,username)==0) return 0;
1276 int sal_op_get_auth_requested(SalOp *op, const char **realm, const char **username){
1277 if (op->pending_auth){
1278 return get_auth_data(op->pending_auth,realm,username);
1283 static bool_t process_authentication(Sal *sal, eXosip_event_t *ev){
1285 const char *username,*realm;
1288 ms_warning("No operation associated with this authentication !");
1291 if (get_auth_data(ev,&realm,&username)==0){
1292 if (op->pending_auth!=NULL){
1293 eXosip_event_free(op->pending_auth);
1294 op->pending_auth=ev;
1296 op->pending_auth=ev;
1297 sal_add_pending_auth(sal,op);
1300 sal->callbacks.auth_requested(op,realm,username);
1306 static void authentication_ok(Sal *sal, eXosip_event_t *ev){
1308 const char *username,*realm;
1311 ms_warning("No operation associated with this authentication_ok!");
1314 if (op->pending_auth){
1315 eXosip_event_free(op->pending_auth);
1316 sal_remove_pending_auth(sal,op);
1317 op->pending_auth=NULL;
1319 if (get_auth_data(ev,&realm,&username)==0){
1320 sal->callbacks.auth_success(op,realm,username);
1324 static bool_t call_failure(Sal *sal, eXosip_event_t *ev){
1327 char* computedReason=NULL;
1328 const char *reason=NULL;
1329 SalError error=SalErrorUnknown;
1330 SalReason sr=SalReasonUnknown;
1333 op=(SalOp*)find_op(sal,ev);
1336 ms_warning("Call failure reported for a closed call, ignored.");
1341 code=osip_message_get_status_code(ev->response);
1342 reason=osip_message_get_reason_phrase(ev->response);
1343 osip_header_t *h=NULL;
1344 if (!osip_message_header_get_byname( ev->response
1348 computedReason = ms_strdup_printf("%s %s",reason,osip_header_get_value(h));
1349 reason = computedReason;
1357 return process_authentication(sal,ev);
1360 error=SalErrorUnknown;
1363 error=SalErrorFailure;
1364 sr=SalReasonNotFound;
1367 error=SalErrorFailure;
1371 eXosip_default_action(ev);
1375 error=SalErrorFailure;
1376 sr=SalReasonTemporarilyUnavailable;
1378 error=SalErrorFailure;
1384 error=SalErrorFailure;
1385 sr=SalReasonDoNotDisturb;
1388 error=SalErrorFailure;
1389 sr=SalReasonDeclined;
1393 error=SalErrorFailure;
1394 sr=SalReasonUnknown;
1395 }else error=SalErrorNoResponse;
1397 op->terminated=TRUE;
1398 sal->callbacks.call_failure(op,error,sr,reason,code);
1399 if (computedReason != NULL){
1400 ms_free(computedReason);
1405 /* Request remote side to send us VFU */
1406 void sal_call_send_vfu_request(SalOp *h){
1407 osip_message_t *msg=NULL;
1409 "<?xml version=\"1.0\" encoding=\"utf-8\" ?>"
1413 " <picture_fast_update></picture_fast_update>"
1421 eXosip_call_build_info(h->did,&msg);
1423 osip_message_set_body(msg,info_body,strlen(info_body));
1424 osip_message_set_content_type(msg,"application/media_control+xml");
1425 snprintf(clen,sizeof(clen),"%lu",(unsigned long)strlen(info_body));
1426 osip_message_set_content_length(msg,clen);
1427 eXosip_call_send_request(h->did,msg);
1428 ms_message("Sending VFU request !");
1433 static void process_media_control_xml(Sal *sal, eXosip_event_t *ev){
1434 SalOp *op=find_op(sal,ev);
1435 osip_body_t *body=NULL;
1438 ms_warning("media control xml received without operation context!");
1442 osip_message_get_body(ev->request,0,&body);
1443 if (body && body->body!=NULL &&
1444 strstr(body->body,"picture_fast_update")){
1445 osip_message_t *ans=NULL;
1446 ms_message("Receiving VFU request !");
1447 if (sal->callbacks.vfu_request){
1448 sal->callbacks.vfu_request(op);
1449 eXosip_call_build_answer(ev->tid,200,&ans);
1451 eXosip_call_send_answer(ev->tid,200,ans);
1455 /*in all other cases we must say it is not implemented.*/
1457 osip_message_t *ans=NULL;
1459 eXosip_call_build_answer(ev->tid,501,&ans);
1461 eXosip_call_send_answer(ev->tid,501,ans);
1466 static void process_dtmf_relay(Sal *sal, eXosip_event_t *ev){
1467 SalOp *op=find_op(sal,ev);
1468 osip_body_t *body=NULL;
1471 ms_warning("media dtmf relay received without operation context!");
1475 osip_message_get_body(ev->request,0,&body);
1476 if (body && body->body!=NULL){
1477 osip_message_t *ans=NULL;
1478 const char *name=strstr(body->body,"Signal");
1479 if (name==NULL) name=strstr(body->body,"signal");
1481 ms_warning("Could not extract the dtmf name from the SIP INFO.");
1484 name+=strlen("signal");
1485 if (sscanf(name," = %1s",tmp)==1){
1486 ms_message("Receiving dtmf %s via SIP INFO.",tmp);
1487 if (sal->callbacks.dtmf_received != NULL)
1488 sal->callbacks.dtmf_received(op, tmp[0]);
1492 eXosip_call_build_answer(ev->tid,200,&ans);
1494 eXosip_call_send_answer(ev->tid,200,ans);
1499 static void fill_options_answer(osip_message_t *options){
1500 osip_message_set_allow(options,"INVITE, ACK, BYE, CANCEL, OPTIONS, MESSAGE, SUBSCRIBE, NOTIFY, INFO");
1501 osip_message_set_accept(options,"application/sdp");
1504 static void process_refer(Sal *sal, SalOp *op, eXosip_event_t *ev){
1505 osip_header_t *h=NULL;
1506 osip_message_t *ans=NULL;
1507 ms_message("Receiving REFER request !");
1508 osip_message_header_get_byname(ev->request,"Refer-To",0,&h);
1511 osip_from_t *from=NULL;
1513 osip_from_init(&from);
1515 if (osip_from_parse(from,h->hvalue)==0){
1517 osip_uri_header_t *uh=NULL;
1518 osip_header_t *referred_by=NULL;
1519 osip_uri_header_get_byname(&from->url->url_headers,(char*)"Replaces",&uh);
1520 if (uh!=NULL && uh->gvalue && uh->gvalue[0]!='\0'){
1521 ms_message("Found replaces in Refer-To");
1523 ms_free(op->replaces);
1525 op->replaces=ms_strdup(uh->gvalue);
1527 osip_message_header_get_byname(ev->request,"Referred-By",0,&referred_by);
1528 if (referred_by && referred_by->hvalue && referred_by->hvalue[0]!='\0'){
1529 if (op->referred_by)
1530 ms_free(op->referred_by);
1531 op->referred_by=ms_strdup(referred_by->hvalue);
1534 osip_uri_header_freelist(&from->url->url_headers);
1535 osip_from_to_str(from,&tmp);
1536 sal->callbacks.refer_received(sal,op,tmp);
1538 osip_from_free(from);
1541 eXosip_call_build_answer(ev->tid,202,&ans);
1543 eXosip_call_send_answer(ev->tid,202,ans);
1548 ms_warning("cannot do anything with the refer without destination\n");
1552 static void process_notify(Sal *sal, eXosip_event_t *ev){
1553 osip_header_t *h=NULL;
1555 SalOp *op=find_op(sal,ev);
1556 osip_message_t *ans=NULL;
1558 ms_message("Receiving NOTIFY request !");
1559 osip_from_to_str(ev->request->from,&from);
1560 osip_message_header_get_byname(ev->request,"Event",0,&h);
1562 osip_body_t *body=NULL;
1563 //osip_content_type_t *ct=NULL;
1564 osip_message_get_body(ev->request,0,&body);
1565 //ct=osip_message_get_content_type(ev->request);
1566 if (h->hvalue && strcasecmp(h->hvalue,"refer")==0){
1567 /*special handling of refer events*/
1568 if (body && body->body){
1569 osip_message_t *msg;
1570 osip_message_init(&msg);
1571 if (osip_message_parse_sipfrag(msg,body->body,strlen(body->body))==0){
1572 int code=osip_message_get_status_code(msg);
1574 sal->callbacks.notify_refer(op,SalReferTrying);
1575 }else if (code==200){
1576 sal->callbacks.notify_refer(op,SalReferSuccess);
1577 }else if (code>=400){
1578 sal->callbacks.notify_refer(op,SalReferFailed);
1581 osip_message_free(msg);
1584 /*generic handling*/
1585 sal->callbacks.notify(op,from,h->hvalue);
1588 /*answer that we received the notify*/
1590 eXosip_call_build_answer(ev->tid,200,&ans);
1592 eXosip_call_send_answer(ev->tid,200,ans);
1597 static void call_message_new(Sal *sal, eXosip_event_t *ev){
1598 osip_message_t *ans=NULL;
1600 if (MSG_IS_INFO(ev->request)){
1601 osip_content_type_t *ct;
1602 ct=osip_message_get_content_type(ev->request);
1603 if (ct && ct->subtype){
1604 if (strcmp(ct->subtype,"media_control+xml")==0)
1605 process_media_control_xml(sal,ev);
1606 else if (strcmp(ct->subtype,"dtmf-relay")==0)
1607 process_dtmf_relay(sal,ev);
1609 ms_message("Unhandled SIP INFO.");
1610 /*send an "Not implemented" answer*/
1612 eXosip_call_build_answer(ev->tid,501,&ans);
1614 eXosip_call_send_answer(ev->tid,501,ans);
1618 /*empty SIP INFO, probably to test we are alive. Send an empty answer*/
1620 eXosip_call_build_answer(ev->tid,200,&ans);
1622 eXosip_call_send_answer(ev->tid,200,ans);
1625 }else if(MSG_IS_MESSAGE(ev->request)){
1626 /* SIP messages could be received into call */
1627 text_received(sal, ev);
1629 eXosip_call_build_answer(ev->tid,200,&ans);
1631 eXosip_call_send_answer(ev->tid,200,ans);
1633 }else if(MSG_IS_REFER(ev->request)){
1634 SalOp *op=find_op(sal,ev);
1636 ms_message("Receiving REFER request !");
1637 process_refer(sal,op,ev);
1638 }else if(MSG_IS_NOTIFY(ev->request)){
1639 process_notify(sal,ev);
1640 }else if (MSG_IS_OPTIONS(ev->request)){
1642 eXosip_call_build_answer(ev->tid,200,&ans);
1644 fill_options_answer(ans);
1645 eXosip_call_send_answer(ev->tid,200,ans);
1649 }else ms_warning("call_message_new: No request ?");
1652 static void inc_update(Sal *sal, eXosip_event_t *ev){
1653 osip_message_t *msg=NULL;
1654 ms_message("Processing incoming UPDATE");
1656 eXosip_message_build_answer(ev->tid,200,&msg);
1658 eXosip_message_send_answer(ev->tid,200,msg);
1662 static bool_t comes_from_local_if(osip_message_t *msg){
1663 osip_via_t *via=NULL;
1664 osip_message_get_via(msg,0,&via);
1667 host=osip_via_get_host(via);
1668 if (strcmp(host,"127.0.0.1")==0 || strcmp(host,"::1")==0){
1669 osip_generic_param_t *param=NULL;
1670 osip_via_param_get_byname(via,"received",¶m);
1671 if (param==NULL) return TRUE;
1672 if (param->gvalue &&
1673 (strcmp(param->gvalue,"127.0.0.1")==0 || strcmp(param->gvalue,"::1")==0)){
1681 static void text_received(Sal *sal, eXosip_event_t *ev){
1682 osip_body_t *body=NULL;
1683 char *from=NULL,*msg;
1685 osip_message_get_body(ev->request,0,&body);
1687 ms_error("Could not get text message from SIP body");
1691 osip_from_to_str(ev->request->from,&from);
1692 sal->callbacks.text_received(sal,from,msg);
1698 static void other_request(Sal *sal, eXosip_event_t *ev){
1699 ms_message("in other_request");
1700 if (ev->request==NULL) return;
1701 if (strcmp(ev->request->sip_method,"MESSAGE")==0){
1702 text_received(sal,ev);
1703 eXosip_message_send_answer(ev->tid,200,NULL);
1704 }else if (strcmp(ev->request->sip_method,"OPTIONS")==0){
1705 osip_message_t *options=NULL;
1706 eXosip_options_build_answer(ev->tid,200,&options);
1707 fill_options_answer(options);
1708 eXosip_options_send_answer(ev->tid,200,options);
1709 }else if (strncmp(ev->request->sip_method, "REFER", 5) == 0){
1710 ms_message("Receiving REFER request !");
1711 if (comes_from_local_if(ev->request)) {
1712 process_refer(sal,NULL,ev);
1713 }else ms_warning("Ignored REFER not coming from this local loopback interface.");
1714 }else if (strncmp(ev->request->sip_method, "UPDATE", 6) == 0){
1719 osip_message_to_str(ev->request,&tmp,&msglen);
1721 ms_message("Unsupported request received:\n%s",tmp);
1724 /*answer with a 501 Not implemented*/
1725 eXosip_message_send_answer(ev->tid,501,NULL);
1729 static void masquerade_via(osip_message_t *msg, const char *ip, const char *port){
1730 osip_via_t *via=NULL;
1731 osip_message_get_via(msg,0,&via);
1733 osip_free(via->port);
1734 via->port=osip_strdup(port);
1735 osip_free(via->host);
1736 via->host=osip_strdup(ip);
1741 static bool_t fix_message_contact(SalOp *op, osip_message_t *request,osip_message_t *last_answer, bool_t expire_last_contact) {
1742 osip_contact_t *ctt=NULL;
1743 const char *received;
1745 SalTransport transport;
1748 if (extract_received_rport(last_answer,&received,&rport,&transport)==-1) return FALSE;
1749 osip_message_get_contact(request,0,&ctt);
1751 ms_warning("fix_message_contact(): no contact to update");
1754 if (expire_last_contact){
1755 osip_contact_t *oldct=NULL,*prevct;
1756 osip_generic_param_t *param=NULL;
1757 osip_contact_clone(ctt,&oldct);
1758 while ((prevct=(osip_contact_t*)osip_list_get(&request->contacts,1))!=NULL){
1759 osip_contact_free(prevct);
1760 osip_list_remove(&request->contacts,1);
1762 osip_list_add(&request->contacts,oldct,1);
1763 osip_contact_param_get_byname(oldct,"expires",¶m);
1765 if (param->gvalue) osip_free(param->gvalue);
1766 param->gvalue=osip_strdup("0");
1768 osip_contact_param_add(oldct,osip_strdup("expires"),osip_strdup("0"));
1771 if (ctt->url->host!=NULL){
1772 osip_free(ctt->url->host);
1774 ctt->url->host=osip_strdup(received);
1775 if (ctt->url->port!=NULL){
1776 osip_free(ctt->url->port);
1778 snprintf(port,sizeof(port),"%i",rport);
1779 ctt->url->port=osip_strdup(port);
1780 if (op->masquerade_via) masquerade_via(request,received,port);
1782 if (transport != SalTransportUDP) {
1783 sal_address_set_param((SalAddress *)ctt, "transport", sal_transport_to_string(transport));
1788 static bool_t register_again_with_updated_contact(SalOp *op, osip_message_t *orig_request, osip_message_t *last_answer){
1789 osip_contact_t *ctt=NULL;
1790 SalAddress* ori_contact_address=NULL;
1791 const char *received;
1793 SalTransport transport;
1795 osip_message_t *msg=NULL;
1796 Sal* sal=op->base.root;
1798 bool_t found_valid_contact=FALSE;
1799 bool_t from_request=FALSE;
1801 if (sal->double_reg==FALSE ) return FALSE;
1803 if (extract_received_rport(last_answer,&received,&rport,&transport)==-1) return FALSE;
1806 osip_message_get_contact(last_answer,i,&ctt);
1807 if (!from_request && ctt==NULL) {
1808 osip_message_get_contact(orig_request,0,&ctt);
1812 osip_contact_to_str(ctt,&tmp);
1813 ori_contact_address = sal_address_new(tmp);
1815 /*check if contact is up to date*/
1816 if (strcmp(sal_address_get_domain(ori_contact_address),received) ==0
1817 && sal_address_get_port_int(ori_contact_address) == rport
1818 && sal_address_get_transport(ori_contact_address) == transport) {
1820 ms_message("Register response has up to date contact, doing nothing.");
1822 ms_warning("Register response does not have up to date contact, but last request had."
1823 "Stupid registrar detected, giving up.");
1825 found_valid_contact=TRUE;
1828 sal_address_destroy(ori_contact_address);
1831 }while(!found_valid_contact);
1832 if (!found_valid_contact)
1833 ms_message("Contact do not match, resending register.");
1837 eXosip_register_build_register(op->rid,op->expires,&msg);
1840 ms_warning("Fail to create a contact updated register.");
1843 if (fix_message_contact(op,msg,last_answer,op->base.root->expire_old_contact)) {
1844 eXosip_register_send_register(op->rid,msg);
1846 ms_message("Resending new register with updated contact");
1847 update_contact_from_response(op,last_answer);
1850 ms_warning("Fail to send updated register.");
1858 static void registration_success(Sal *sal, eXosip_event_t *ev){
1859 SalOp *op=sal_find_register(sal,ev->rid);
1860 osip_header_t *h=NULL;
1863 ms_error("Receiving register response for unknown operation");
1866 osip_message_get_expires(ev->request,0,&h);
1867 if (h!=NULL && atoi(h->hvalue)!=0){
1869 if (!register_again_with_updated_contact(op,ev->request,ev->response)){
1870 sal->callbacks.register_success(op,registered);
1873 sal->callbacks.register_success(op,FALSE);
1877 static bool_t registration_failure(Sal *sal, eXosip_event_t *ev){
1879 const char *reason=NULL;
1880 SalOp *op=sal_find_register(sal,ev->rid);
1881 SalReason sr=SalReasonUnknown;
1882 SalError se=SalErrorUnknown;
1885 ms_error("Receiving register failure for unknown operation");
1889 status_code=osip_message_get_status_code(ev->response);
1890 reason=osip_message_get_reason_phrase(ev->response);
1892 switch(status_code){
1895 return process_authentication(sal,ev);
1897 case 423: /*interval too brief*/
1898 {/*retry with greater interval */
1899 osip_header_t *h=NULL;
1900 osip_message_t *msg=NULL;
1901 osip_message_header_get_byname(ev->response,"min-expires",0,&h);
1902 if (h && h->hvalue && h->hvalue[0]!='\0'){
1903 int val=atoi(h->hvalue);
1904 if (val>op->expires)
1906 }else op->expires*=2;
1908 eXosip_register_build_register(op->rid,op->expires,&msg);
1909 eXosip_register_send_register(op->rid,msg);
1913 case 606: /*Not acceptable, workaround for proxies that don't like private addresses
1914 in vias, such as ekiga.net
1915 On the opposite, freephonie.net bugs when via are masqueraded.
1917 op->masquerade_via=TRUE;
1919 /* if contact is up to date, process the failure, otherwise resend a new register with
1920 updated contact first, just in case the faillure is due to incorrect contact */
1921 if (ev->response && register_again_with_updated_contact(op,ev->request,ev->response))
1922 return TRUE; /*we are retrying with an updated contact*/
1923 if (status_code==403){
1925 sr=SalReasonForbidden;
1926 }else if (status_code==0){
1927 se=SalErrorNoResponse;
1929 sal->callbacks.register_failure(op,se,sr,reason);
1934 static void other_request_reply(Sal *sal,eXosip_event_t *ev){
1935 SalOp *op=find_op(sal,ev);
1938 ms_warning("other_request_reply(): Receiving response to unknown request.");
1942 update_contact_from_response(op,ev->response);
1943 if (ev->request && strcmp(osip_message_get_method(ev->request),"OPTIONS")==0)
1944 sal->callbacks.ping_reply(op);
1948 static void process_in_call_reply(Sal *sal, eXosip_event_t *ev){
1949 SalOp *op=find_op(sal,ev);
1951 if (ev->request && strcmp(osip_message_get_method(ev->request),"NOTIFY")==0){
1952 if (op->sipfrag_pending){
1953 send_notify_for_refer(op->did,op->sipfrag_pending);
1954 op->sipfrag_pending=NULL;
1960 static bool_t process_event(Sal *sal, eXosip_event_t *ev){
1961 ms_message("linphone process event get a message %d\n",ev->type);
1963 case EXOSIP_CALL_ANSWERED:
1964 ms_message("CALL_ANSWERED\n");
1965 call_accepted(sal,ev);
1966 authentication_ok(sal,ev);
1968 case EXOSIP_CALL_CLOSED:
1969 case EXOSIP_CALL_CANCELLED:
1970 ms_message("CALL_CLOSED or CANCELLED\n");
1971 call_terminated(sal,ev);
1973 case EXOSIP_CALL_TIMEOUT:
1974 case EXOSIP_CALL_NOANSWER:
1975 ms_message("CALL_TIMEOUT or NOANSWER\n");
1976 return call_failure(sal,ev);
1978 case EXOSIP_CALL_REQUESTFAILURE:
1979 case EXOSIP_CALL_GLOBALFAILURE:
1980 case EXOSIP_CALL_SERVERFAILURE:
1981 ms_message("CALL_REQUESTFAILURE or GLOBALFAILURE or SERVERFAILURE\n");
1982 return call_failure(sal,ev);
1984 case EXOSIP_CALL_RELEASED:
1985 ms_message("CALL_RELEASED\n");
1986 call_released(sal, ev);
1988 case EXOSIP_CALL_INVITE:
1989 ms_message("CALL_NEW\n");
1990 inc_new_call(sal,ev);
1992 case EXOSIP_CALL_REINVITE:
1993 handle_reinvite(sal,ev);
1995 case EXOSIP_CALL_ACK:
1996 ms_message("CALL_ACK");
1999 case EXOSIP_CALL_REDIRECTED:
2000 ms_message("CALL_REDIRECTED");
2001 eXosip_default_action(ev);
2003 case EXOSIP_CALL_PROCEEDING:
2004 ms_message("CALL_PROCEEDING");
2005 call_proceeding(sal,ev);
2007 case EXOSIP_CALL_RINGING:
2008 ms_message("CALL_RINGING");
2009 call_ringing(sal,ev);
2010 authentication_ok(sal,ev);
2012 case EXOSIP_CALL_MESSAGE_NEW:
2013 ms_message("EXOSIP_CALL_MESSAGE_NEW");
2014 call_message_new(sal,ev);
2016 case EXOSIP_CALL_MESSAGE_REQUESTFAILURE:
2018 (ev->response->status_code==407 || ev->response->status_code==401)){
2019 return process_authentication(sal,ev);
2022 case EXOSIP_CALL_MESSAGE_ANSWERED:
2023 ms_message("EXOSIP_CALL_MESSAGE_ANSWERED ");
2024 process_in_call_reply(sal,ev);
2026 case EXOSIP_IN_SUBSCRIPTION_NEW:
2027 ms_message("CALL_IN_SUBSCRIPTION_NEW ");
2028 sal_exosip_subscription_recv(sal,ev);
2030 case EXOSIP_IN_SUBSCRIPTION_RELEASED:
2031 ms_message("CALL_SUBSCRIPTION_NEW ");
2032 sal_exosip_in_subscription_closed(sal,ev);
2034 case EXOSIP_SUBSCRIPTION_UPDATE:
2035 ms_message("CALL_SUBSCRIPTION_UPDATE");
2037 case EXOSIP_SUBSCRIPTION_NOTIFY:
2038 ms_message("CALL_SUBSCRIPTION_NOTIFY");
2039 sal_exosip_notify_recv(sal,ev);
2041 case EXOSIP_SUBSCRIPTION_ANSWERED:
2042 ms_message("EXOSIP_SUBSCRIPTION_ANSWERED, ev->sid=%i, ev->did=%i\n",ev->sid,ev->did);
2043 sal_exosip_subscription_answered(sal,ev);
2045 case EXOSIP_SUBSCRIPTION_CLOSED:
2046 ms_message("EXOSIP_SUBSCRIPTION_CLOSED\n");
2047 sal_exosip_subscription_closed(sal,ev);
2049 case EXOSIP_SUBSCRIPTION_REQUESTFAILURE: /**< announce a request failure */
2050 if (ev->response && (ev->response->status_code == 407 || ev->response->status_code == 401)){
2051 return process_authentication(sal,ev);
2053 case EXOSIP_SUBSCRIPTION_SERVERFAILURE:
2054 case EXOSIP_SUBSCRIPTION_GLOBALFAILURE:
2055 sal_exosip_subscription_closed(sal,ev);
2057 case EXOSIP_REGISTRATION_FAILURE:
2058 ms_message("REGISTRATION_FAILURE\n");
2059 return registration_failure(sal,ev);
2061 case EXOSIP_REGISTRATION_SUCCESS:
2062 authentication_ok(sal,ev);
2063 registration_success(sal,ev);
2065 case EXOSIP_MESSAGE_NEW:
2066 other_request(sal,ev);
2068 case EXOSIP_MESSAGE_PROCEEDING:
2069 case EXOSIP_MESSAGE_ANSWERED:
2070 case EXOSIP_MESSAGE_REDIRECTED:
2071 case EXOSIP_MESSAGE_SERVERFAILURE:
2072 case EXOSIP_MESSAGE_GLOBALFAILURE:
2073 other_request_reply(sal,ev);
2075 case EXOSIP_MESSAGE_REQUESTFAILURE:
2076 case EXOSIP_NOTIFICATION_REQUESTFAILURE:
2078 switch (ev->response->status_code) {
2081 return process_authentication(sal,ev);
2083 eXosip_automatic_action ();
2088 other_request_reply(sal,ev);
2091 ms_message("Unhandled exosip event ! %i",ev->type);
2097 int sal_iterate(Sal *sal){
2099 while((ev=eXosip_event_wait(0,0))!=NULL){
2100 if (process_event(sal,ev))
2101 eXosip_event_free(ev);
2103 #ifdef HAVE_EXOSIP_TRYLOCK
2104 if (eXosip_trylock()==0){
2105 eXosip_automatic_refresh();
2108 ms_warning("eXosip_trylock busy.");
2112 eXosip_automatic_refresh();
2118 static void register_set_contact(osip_message_t *msg, const char *contact){
2119 osip_uri_param_t *param = NULL;
2120 osip_contact_t *ct=NULL;
2122 /*we get the line parameter choosed by exosip, and add it to our own contact*/
2123 osip_message_get_contact(msg,0,&ct);
2125 osip_uri_uparam_get_byname(ct->url, "line", ¶m);
2126 if (param && param->gvalue)
2127 line=osip_strdup(param->gvalue);
2129 _osip_list_set_empty(&msg->contacts,(void (*)(void*))osip_contact_free);
2130 osip_message_set_contact(msg,contact);
2131 osip_message_get_contact(msg,0,&ct);
2132 osip_uri_uparam_add(ct->url,osip_strdup("line"),line);
2135 static void sal_register_add_route(osip_message_t *msg, const char *proxy){
2137 snprintf(tmp,sizeof(tmp)-1,"<%s;lr>",proxy);
2139 osip_list_special_free(&msg->routes,(void (*)(void*))osip_route_free);
2140 osip_message_set_route(msg,tmp);
2143 int sal_register(SalOp *h, const char *proxy, const char *from, int expires){
2144 osip_message_t *msg;
2145 const char *contact=sal_op_get_contact(h);
2147 sal_op_set_route(h,proxy);
2149 SalAddress *from_parsed=sal_address_new(from);
2151 if (from_parsed==NULL) {
2152 ms_warning("sal_register() bad from %s",from);
2155 snprintf(domain,sizeof(domain),"sip:%s",sal_address_get_domain(from_parsed));
2156 sal_address_destroy(from_parsed);
2158 h->rid=eXosip_register_build_initial_register(from,domain,NULL,expires,&msg);
2160 if (contact) register_set_contact(msg,contact);
2161 sal_register_add_route(msg,proxy);
2162 sal_add_register(h->base.root,h);
2164 ms_error("Could not build initial register.");
2170 eXosip_register_build_register(h->rid,expires,&msg);
2171 sal_register_add_route(msg,proxy);
2174 eXosip_register_send_register(h->rid,msg);
2177 return (msg != NULL) ? 0 : -1;
2180 int sal_register_refresh(SalOp *op, int expires){
2181 osip_message_t *msg=NULL;
2182 const char *contact=sal_op_get_contact(op);
2185 ms_error("Unexistant registration context, not possible to refresh.");
2189 eXosip_register_build_register(op->rid,expires,&msg);
2191 if (contact) register_set_contact(msg,contact);
2192 sal_register_add_route(msg,sal_op_get_route(op));
2193 eXosip_register_send_register(op->rid,msg);
2194 }else ms_error("Could not build REGISTER refresh message.");
2196 return (msg != NULL) ? 0 : -1;
2200 int sal_unregister(SalOp *h){
2201 osip_message_t *msg=NULL;
2203 eXosip_register_build_register(h->rid,0,&msg);
2204 if (msg) eXosip_register_send_register(h->rid,msg);
2205 else ms_warning("Could not build unREGISTER !");
2210 SalAddress * sal_address_new(const char *uri){
2212 osip_from_init(&from);
2214 // Remove front spaces
2215 while (uri[0]==' ') {
2219 if (osip_from_parse(from,uri)!=0){
2220 osip_from_free(from);
2223 if (from->displayname!=NULL && from->displayname[0]=='"'){
2224 char *unquoted=osip_strdup_without_quote(from->displayname);
2225 osip_free(from->displayname);
2226 from->displayname=unquoted;
2228 return (SalAddress*)from;
2231 SalAddress * sal_address_clone(const SalAddress *addr){
2232 osip_from_t *ret=NULL;
2233 osip_from_clone((osip_from_t*)addr,&ret);
2234 return (SalAddress*)ret;
2237 #define null_if_empty(s) (((s)!=NULL && (s)[0]!='\0') ? (s) : NULL )
2239 const char *sal_address_get_scheme(const SalAddress *addr){
2240 const osip_from_t *u=(const osip_from_t*)addr;
2241 return null_if_empty(u->url->scheme);
2244 const char *sal_address_get_display_name(const SalAddress* addr){
2245 const osip_from_t *u=(const osip_from_t*)addr;
2246 return null_if_empty(u->displayname);
2249 const char *sal_address_get_username(const SalAddress *addr){
2250 const osip_from_t *u=(const osip_from_t*)addr;
2251 return null_if_empty(u->url->username);
2254 const char *sal_address_get_domain(const SalAddress *addr){
2255 const osip_from_t *u=(const osip_from_t*)addr;
2256 return null_if_empty(u->url->host);
2259 void sal_address_set_display_name(SalAddress *addr, const char *display_name){
2260 osip_from_t *u=(osip_from_t*)addr;
2261 if (u->displayname!=NULL){
2262 osip_free(u->displayname);
2263 u->displayname=NULL;
2265 if (display_name!=NULL && display_name[0]!='\0'){
2266 u->displayname=osip_strdup(display_name);
2270 void sal_address_set_username(SalAddress *addr, const char *username){
2271 osip_from_t *uri=(osip_from_t*)addr;
2272 if (uri->url->username!=NULL){
2273 osip_free(uri->url->username);
2274 uri->url->username=NULL;
2277 uri->url->username=osip_strdup(username);
2280 void sal_address_set_domain(SalAddress *addr, const char *host){
2281 osip_from_t *uri=(osip_from_t*)addr;
2282 if (uri->url->host!=NULL){
2283 osip_free(uri->url->host);
2284 uri->url->host=NULL;
2287 uri->url->host=osip_strdup(host);
2290 void sal_address_set_port(SalAddress *addr, const char *port){
2291 osip_from_t *uri=(osip_from_t*)addr;
2292 if (uri->url->port!=NULL){
2293 osip_free(uri->url->port);
2294 uri->url->port=NULL;
2297 uri->url->port=osip_strdup(port);
2300 void sal_address_set_port_int(SalAddress *uri, int port){
2303 /*this is the default, special case to leave the port field blank*/
2304 sal_address_set_port(uri,NULL);
2307 snprintf(tmp,sizeof(tmp),"%i",port);
2308 sal_address_set_port(uri,tmp);
2311 void sal_address_clean(SalAddress *addr){
2312 osip_generic_param_freelist(& ((osip_from_t*)addr)->gen_params);
2313 osip_uri_param_freelist(& ((osip_from_t*)addr)->url->url_params);
2316 char *sal_address_as_string(const SalAddress *u){
2318 osip_from_t *from=(osip_from_t *)u;
2319 char *old_displayname=NULL;
2320 /* hack to force use of quotes around the displayname*/
2321 if (from->displayname!=NULL
2322 && from->displayname[0]!='"'){
2323 old_displayname=from->displayname;
2324 from->displayname=osip_enquote(from->displayname);
2326 osip_from_to_str(from,&tmp);
2327 if (old_displayname!=NULL){
2328 ms_free(from->displayname);
2329 from->displayname=old_displayname;
2336 char *sal_address_as_string_uri_only(const SalAddress *u){
2337 char *tmp=NULL,*ret;
2338 osip_uri_to_str(((osip_from_t*)u)->url,&tmp);
2343 void sal_address_set_param(SalAddress *u,const char* name,const char* value) {
2344 osip_uri_param_t *param=NULL;
2345 osip_uri_uparam_get_byname(((osip_from_t*)u)->url,(char*)name,¶m);
2347 osip_uri_uparam_add (((osip_from_t*)u)->url,ms_strdup(name),value ? ms_strdup(value) : NULL);
2349 osip_free(param->gvalue);
2350 param->gvalue=value ? osip_strdup(value) : NULL;
2355 void sal_address_destroy(SalAddress *u){
2356 osip_from_free((osip_from_t*)u);
2359 void sal_set_keepalive_period(Sal *ctx,unsigned int value) {
2360 ctx->keepalive_period=value;
2361 eXosip_set_option (EXOSIP_OPT_UDP_KEEP_ALIVE, &value);
2363 unsigned int sal_get_keepalive_period(Sal *ctx) {
2364 return ctx->keepalive_period;
2367 const char * sal_address_get_port(const SalAddress *addr) {
2368 const osip_from_t *u=(const osip_from_t*)addr;
2369 return null_if_empty(u->url->port);
2372 int sal_address_get_port_int(const SalAddress *uri) {
2373 const char* port = sal_address_get_port(uri);
2380 SalTransport sal_address_get_transport(const SalAddress* addr) {
2381 const osip_from_t *u=(const osip_from_t*)addr;
2382 osip_uri_param_t *transport_param=NULL;
2383 osip_uri_uparam_get_byname(u->url,"transport",&transport_param);
2384 if (transport_param == NULL){
2385 return SalTransportUDP;
2387 return sal_transport_parse(transport_param->gvalue);
2390 void sal_address_set_transport(SalAddress* addr,SalTransport transport) {
2391 sal_address_set_param(addr, "transport", sal_transport_to_string(transport));
2394 /* sends a reinvite. Local media description may have changed by application since call establishment*/
2395 int sal_call_update(SalOp *h, const char *subject){
2397 osip_message_t *reinvite=NULL;
2400 if(eXosip_call_build_request(h->did,"INVITE",&reinvite) != 0 || reinvite==NULL){
2405 osip_message_set_subject(reinvite,subject);
2406 osip_message_set_allow(reinvite, "INVITE, ACK, CANCEL, OPTIONS, BYE, REFER, NOTIFY, MESSAGE, SUBSCRIBE, INFO");
2407 if (h->base.root->session_expires!=0){
2408 osip_message_set_header(reinvite, "Session-expires", "200");
2409 osip_message_set_supported(reinvite, "timer");
2411 if (h->base.local_media){
2412 h->sdp_offering=TRUE;
2413 set_sdp_from_desc(reinvite,h->base.local_media);
2414 }else h->sdp_offering=FALSE;
2416 err = eXosip_call_send_request(h->did, reinvite);
2420 void sal_reuse_authorization(Sal *ctx, bool_t value) {
2421 ctx->reuse_authorization=value;