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;
285 sal->verify_server_certs=TRUE;
289 void sal_uninit(Sal* sal){
292 ms_free(sal->rootCa);
296 void sal_set_user_pointer(Sal *sal, void *user_data){
300 void *sal_get_user_pointer(const Sal *sal){
304 static void unimplemented_stub(){
305 ms_warning("Unimplemented SAL callback");
308 void sal_set_callbacks(Sal *ctx, const SalCallbacks *cbs){
309 memcpy(&ctx->callbacks,cbs,sizeof(*cbs));
310 if (ctx->callbacks.call_received==NULL)
311 ctx->callbacks.call_received=(SalOnCallReceived)unimplemented_stub;
312 if (ctx->callbacks.call_ringing==NULL)
313 ctx->callbacks.call_ringing=(SalOnCallRinging)unimplemented_stub;
314 if (ctx->callbacks.call_accepted==NULL)
315 ctx->callbacks.call_accepted=(SalOnCallAccepted)unimplemented_stub;
316 if (ctx->callbacks.call_failure==NULL)
317 ctx->callbacks.call_failure=(SalOnCallFailure)unimplemented_stub;
318 if (ctx->callbacks.call_terminated==NULL)
319 ctx->callbacks.call_terminated=(SalOnCallTerminated)unimplemented_stub;
320 if (ctx->callbacks.call_released==NULL)
321 ctx->callbacks.call_released=(SalOnCallReleased)unimplemented_stub;
322 if (ctx->callbacks.call_updating==NULL)
323 ctx->callbacks.call_updating=(SalOnCallUpdating)unimplemented_stub;
324 if (ctx->callbacks.auth_requested==NULL)
325 ctx->callbacks.auth_requested=(SalOnAuthRequested)unimplemented_stub;
326 if (ctx->callbacks.auth_success==NULL)
327 ctx->callbacks.auth_success=(SalOnAuthSuccess)unimplemented_stub;
328 if (ctx->callbacks.register_success==NULL)
329 ctx->callbacks.register_success=(SalOnRegisterSuccess)unimplemented_stub;
330 if (ctx->callbacks.register_failure==NULL)
331 ctx->callbacks.register_failure=(SalOnRegisterFailure)unimplemented_stub;
332 if (ctx->callbacks.dtmf_received==NULL)
333 ctx->callbacks.dtmf_received=(SalOnDtmfReceived)unimplemented_stub;
334 if (ctx->callbacks.notify==NULL)
335 ctx->callbacks.notify=(SalOnNotify)unimplemented_stub;
336 if (ctx->callbacks.notify_presence==NULL)
337 ctx->callbacks.notify_presence=(SalOnNotifyPresence)unimplemented_stub;
338 if (ctx->callbacks.subscribe_received==NULL)
339 ctx->callbacks.subscribe_received=(SalOnSubscribeReceived)unimplemented_stub;
340 if (ctx->callbacks.text_received==NULL)
341 ctx->callbacks.text_received=(SalOnTextReceived)unimplemented_stub;
342 if (ctx->callbacks.ping_reply==NULL)
343 ctx->callbacks.ping_reply=(SalOnPingReply)unimplemented_stub;
346 int sal_unlisten_ports(Sal *ctx){
355 int sal_listen_port(Sal *ctx, const char *addr, int port, SalTransport tr, int is_secure){
358 int proto=IPPROTO_UDP;
359 int keepalive = ctx->keepalive_period;
362 case SalTransportUDP:
364 eXosip_set_option (EXOSIP_OPT_UDP_KEEP_ALIVE, &keepalive);
366 case SalTransportTCP:
367 case SalTransportTLS:
370 eXosip_set_option (EXOSIP_OPT_UDP_KEEP_ALIVE,&keepalive);
373 eXosip_tls_ctx_t tlsCtx;
374 memset(&tlsCtx, 0, sizeof(tlsCtx));
375 snprintf(tlsCtx.root_ca_cert, sizeof(tlsCtx.client.cert), "%s", ctx->rootCa);
376 eXosip_set_tls_ctx(&tlsCtx);
378 #ifdef HAVE_EXOSIP_TLS_VERIFY_CERTIFICATE
379 eXosip_tls_verify_certificate(ctx->verify_server_certs);
383 ms_warning("unexpected proto, using datagram");
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);
403 ortp_socket_t sal_get_socket(Sal *ctx){
404 #ifdef HAVE_EXOSIP_GET_SOCKET
405 return eXosip_get_socket(IPPROTO_UDP);
407 ms_warning("Sorry, eXosip does not have eXosip_get_socket() method");
412 void sal_set_user_agent(Sal *ctx, const char *user_agent){
413 eXosip_set_user_agent(user_agent);
416 void sal_use_session_timers(Sal *ctx, int expires){
417 ctx->session_expires=expires;
420 void sal_use_one_matching_codec_policy(Sal *ctx, bool_t one_matching_codec){
421 ctx->one_matching_codec=one_matching_codec;
424 MSList *sal_get_pending_auths(Sal *sal){
425 return ms_list_copy(sal->pending_auths);
428 void sal_use_double_registrations(Sal *ctx, bool_t enabled){
429 ctx->double_reg=enabled;
432 void sal_use_rport(Sal *ctx, bool_t use_rports){
433 ctx->use_rports=use_rports;
435 void sal_use_101(Sal *ctx, bool_t use_101){
436 ctx->use_101=use_101;
439 void sal_set_root_ca(Sal* ctx, const char* rootCa) {
441 ms_free(ctx->rootCa);
442 ctx->rootCa = ms_strdup(rootCa);
445 void sal_verify_server_certificates(Sal *ctx, bool_t verify){
446 ctx->verify_server_certs=verify;
447 #ifdef HAVE_EXOSIP_TLS_VERIFY_CERTIFICATE
448 eXosip_tls_verify_certificate(verify);
452 static int extract_received_rport(osip_message_t *msg, const char **received, int *rportval,SalTransport* transport){
453 osip_via_t *via=NULL;
454 osip_generic_param_t *param=NULL;
455 const char *rport=NULL;
459 osip_message_get_via(msg,0,&via);
461 ms_warning("extract_received_rport(): no via.");
465 *transport = sal_transport_parse(via->protocol);
467 if (via->port && via->port[0]!='\0')
468 *rportval=atoi(via->port);
470 osip_via_param_get_byname(via,"rport",¶m);
473 if (rport && rport[0]!='\0') *rportval=atoi(rport);
477 osip_via_param_get_byname(via,"received",¶m);
478 if (param) *received=param->gvalue;
480 if (rport==NULL && *received==NULL){
481 ms_warning("extract_received_rport(): no rport and no received parameters.");
487 static void set_sdp(osip_message_t *sip,sdp_message_t *msg){
491 sdp_message_to_str(msg,&sdp);
493 snprintf(clen,sizeof(clen),"%i",sdplen);
494 osip_message_set_body(sip,sdp,sdplen);
495 osip_message_set_content_type(sip,"application/sdp");
496 osip_message_set_content_length(sip,clen);
500 static void set_sdp_from_desc(osip_message_t *sip, const SalMediaDescription *desc){
501 sdp_message_t *msg=media_description_to_sdp(desc);
503 ms_error("Fail to print sdp message !");
507 sdp_message_free(msg);
510 static void sdp_process(SalOp *h){
511 ms_message("Doing SDP offer/answer process of type %s",h->sdp_offering ? "outgoing" : "incoming");
513 sal_media_description_unref(h->result);
515 h->result=sal_media_description_new();
516 if (h->sdp_offering){
517 offer_answer_initiate_outgoing(h->base.local_media,h->base.remote_media,h->result);
521 sdp_message_free(h->sdp_answer);
523 offer_answer_initiate_incoming(h->base.local_media,h->base.remote_media,h->result,h->base.root->one_matching_codec);
524 h->sdp_answer=media_description_to_sdp(h->result);
525 /*once we have generated the SDP answer, we modify the result description for processing by the upper layer.
526 It should contains media parameters constraint from the remote offer, not our response*/
527 strcpy(h->result->addr,h->base.remote_media->addr);
528 h->result->bandwidth=h->base.remote_media->bandwidth;
530 for(i=0;i<h->result->nstreams;++i){
531 if (h->result->streams[i].port>0){
532 strcpy(h->result->streams[i].addr,h->base.remote_media->streams[i].addr);
533 h->result->streams[i].ptime=h->base.remote_media->streams[i].ptime;
534 h->result->streams[i].bandwidth=h->base.remote_media->streams[i].bandwidth;
535 h->result->streams[i].port=h->base.remote_media->streams[i].port;
537 if (h->result->streams[i].proto == SalProtoRtpSavp) {
538 h->result->streams[i].crypto[0] = h->base.remote_media->streams[i].crypto[0];
546 int sal_call_is_offerer(const SalOp *h){
547 return h->sdp_offering;
550 int sal_call_set_local_media_description(SalOp *h, SalMediaDescription *desc){
552 sal_media_description_ref(desc);
553 if (h->base.local_media)
554 sal_media_description_unref(h->base.local_media);
555 h->base.local_media=desc;
556 if (h->base.remote_media){
557 /*case of an incoming call where we modify the local capabilities between the time
558 * the call is ringing and it is accepted (for example if you want to accept without video*/
559 /*reset the sdp answer so that it is computed again*/
561 sdp_message_free(h->sdp_answer);
568 int sal_call(SalOp *h, const char *from, const char *to){
571 osip_message_t *invite=NULL;
572 sal_op_set_from(h,from);
574 sal_exosip_fix_route(h);
576 h->terminated = FALSE;
578 route = sal_op_get_route(h);
579 err=eXosip_call_build_initial_invite(&invite,to,from,route,"Phone call");
581 ms_error("Could not create call. Error %d (from=%s to=%s route=%s)",
582 err, from, to, route);
585 osip_message_set_allow(invite, "INVITE, ACK, CANCEL, OPTIONS, BYE, REFER, NOTIFY, MESSAGE, SUBSCRIBE, INFO");
586 if (h->base.contact){
587 _osip_list_set_empty(&invite->contacts,(void (*)(void*))osip_contact_free);
588 osip_message_set_contact(invite,h->base.contact);
590 if (h->base.root->session_expires!=0){
591 osip_message_set_header(invite, "Session-expires", "200");
592 osip_message_set_supported(invite, "timer");
594 if (h->base.local_media){
595 h->sdp_offering=TRUE;
596 set_sdp_from_desc(invite,h->base.local_media);
597 }else h->sdp_offering=FALSE;
599 osip_message_set_header(invite,"Replaces",h->replaces);
601 osip_message_set_header(invite,"Referred-By",h->referred_by);
605 err=eXosip_call_send_initial_invite(invite);
609 ms_error("Fail to send invite ! Error code %d", err);
612 sal_add_call(h->base.root,h);
617 int sal_call_notify_ringing(SalOp *h, bool_t early_media){
620 /*if early media send also 180 and 183 */
624 eXosip_call_build_answer(h->tid,180,&msg);
626 eXosip_call_build_answer(h->tid,183,&msg);
630 set_sdp(msg,h->sdp_answer);
631 sdp_message_free(h->sdp_answer);
634 eXosip_call_send_answer(h->tid,183,msg);
639 eXosip_call_send_answer(h->tid,180,NULL);
645 int sal_call_accept(SalOp * h){
647 const char *contact=sal_op_get_contact(h);
649 int err=eXosip_call_build_answer(h->tid,200,&msg);
650 if (err<0 || msg==NULL){
651 ms_error("Fail to build answer for call: err=%i",err);
654 if (h->base.root->session_expires!=0){
655 if (h->supports_session_timers) osip_message_set_supported(msg, "timer");
659 _osip_list_set_empty(&msg->contacts,(void (*)(void*))osip_contact_free);
660 osip_message_set_contact(msg,contact);
663 if (h->base.local_media){
664 /*this is the case where we received an invite without SDP*/
665 if (h->sdp_offering) {
666 set_sdp_from_desc(msg,h->base.local_media);
668 if (h->sdp_answer==NULL) sdp_process(h);
670 set_sdp(msg,h->sdp_answer);
671 sdp_message_free(h->sdp_answer);
676 ms_error("You are accepting a call but not defined any media capabilities !");
678 eXosip_call_send_answer(h->tid,200,msg);
682 int sal_call_decline(SalOp *h, SalReason reason, const char *redirect){
683 if (reason==SalReasonBusy){
685 eXosip_call_send_answer(h->tid,486,NULL);
688 else if (reason==SalReasonTemporarilyUnavailable){
690 eXosip_call_send_answer(h->tid,480,NULL);
692 }else if (reason==SalReasonDoNotDisturb){
694 eXosip_call_send_answer(h->tid,600,NULL);
696 }else if (reason==SalReasonMedia){
698 eXosip_call_send_answer(h->tid,415,NULL);
700 }else if (redirect!=NULL && reason==SalReasonRedirect){
703 if (strstr(redirect,"sip:")!=0) code=302;
706 eXosip_call_build_answer(h->tid,code,&msg);
707 osip_message_set_contact(msg,redirect);
708 eXosip_call_send_answer(h->tid,code,msg);
710 }else sal_call_terminate(h);
714 SalMediaDescription * sal_call_get_remote_media_description(SalOp *h){
715 return h->base.remote_media;
718 SalMediaDescription * sal_call_get_final_media_description(SalOp *h){
719 if (h->base.local_media && h->base.remote_media && !h->result){
725 int sal_call_set_referer(SalOp *h, SalOp *refered_call){
726 if (refered_call->replaces)
727 h->replaces=ms_strdup(refered_call->replaces);
728 if (refered_call->referred_by)
729 h->referred_by=ms_strdup(refered_call->referred_by);
733 int sal_ping(SalOp *op, const char *from, const char *to){
734 osip_message_t *options=NULL;
736 sal_op_set_from(op,from);
737 sal_op_set_to(op,to);
738 sal_exosip_fix_route(op);
740 eXosip_options_build_request (&options, sal_op_get_to(op),
741 sal_op_get_from(op),sal_op_get_route(op));
743 if (op->base.root->session_expires!=0){
744 osip_message_set_header(options, "Session-expires", "200");
745 osip_message_set_supported(options, "timer");
747 sal_add_other(sal_op_get_sal(op),op,options);
748 return eXosip_options_send_request(options);
753 int sal_call_accept_refer(SalOp *op){
754 osip_message_t *msg=NULL;
757 err = eXosip_call_build_notify(op->did,EXOSIP_SUBCRSTATE_ACTIVE,&msg);
760 osip_message_set_header(msg,(const char *)"event","refer");
761 osip_message_set_content_type(msg,"message/sipfrag");
762 osip_message_set_body(msg,"SIP/2.0 100 Trying",sizeof("SIP/2.0 100 Trying"));
763 eXosip_call_send_request(op->did,msg);
767 ms_error("could not get a notify built\n");
773 int sal_call_refer(SalOp *h, const char *refer_to){
774 osip_message_t *msg=NULL;
777 eXosip_call_build_refer(h->did,refer_to, &msg);
778 if (msg) err=eXosip_call_send_request(h->did, msg);
784 int sal_call_refer_with_replaces(SalOp *h, SalOp *other_call_h){
785 osip_message_t *msg=NULL;
786 char referto[256]={0};
789 if (eXosip_call_get_referto(other_call_h->did,referto,sizeof(referto)-1)!=0){
790 ms_error("eXosip_call_get_referto() failed for did=%i",other_call_h->did);
794 eXosip_call_build_refer(h->did,referto, &msg);
795 osip_message_set_header(msg,"Referred-By",h->base.from);
796 if (msg) err=eXosip_call_send_request(h->did, msg);
802 SalOp *sal_call_get_replaces(SalOp *h){
803 if (h!=NULL && h->replaces!=NULL){
806 cid=eXosip_call_find_by_replaces(h->replaces);
809 SalOp *ret=sal_find_call(h->base.root,cid);
816 int sal_call_send_dtmf(SalOp *h, char dtmf){
817 osip_message_t *msg=NULL;
822 eXosip_call_build_info(h->did,&msg);
824 snprintf(dtmf_body, sizeof(dtmf_body), "Signal=%c\r\nDuration=250\r\n", dtmf);
825 osip_message_set_body(msg,dtmf_body,strlen(dtmf_body));
826 osip_message_set_content_type(msg,"application/dtmf-relay");
827 snprintf(clen,sizeof(clen),"%lu",(unsigned long)strlen(dtmf_body));
828 osip_message_set_content_length(msg,clen);
829 eXosip_call_send_request(h->did,msg);
835 static void push_auth_to_exosip(const SalAuthInfo *info){
837 if (info->userid==NULL || info->userid[0]=='\0') userid=info->username;
838 else userid=info->userid;
839 ms_message("Authentication info for username [%s], id[%s], realm [%s] added to eXosip", info->username,userid, info->realm);
840 eXosip_add_authentication_info (info->username,userid,
841 info->password, NULL,info->realm);
844 * Just for symmetry ;-)
846 static void pop_auth_from_exosip() {
847 eXosip_clear_authentication_info();
850 int sal_call_terminate(SalOp *h){
852 if (h == NULL) return -1;
853 if (h->auth_info) push_auth_to_exosip(h->auth_info);
855 err=eXosip_call_terminate(h->cid,h->did);
857 if (!h->base.root->reuse_authorization) pop_auth_from_exosip();
859 ms_warning("Exosip could not terminate the call: cid=%i did=%i", h->cid,h->did);
865 void sal_op_authenticate(SalOp *h, const SalAuthInfo *info){
866 if (h->pending_auth){
867 push_auth_to_exosip(info);
869 /*FIXME exosip does not take into account this update register message*/
871 if (fix_message_contact(h, h->pending_auth->request,h->pending_auth->response)) {
875 update_contact_from_response(h,h->pending_auth->response);
877 eXosip_default_action(h->pending_auth);
879 ms_message("eXosip_default_action() done");
880 if (!h->base.root->reuse_authorization) pop_auth_from_exosip();
882 if (h->auth_info) sal_auth_info_delete(h->auth_info); /*if already exist*/
883 h->auth_info=sal_auth_info_clone(info); /*store auth info for subsequent request*/
886 void sal_op_cancel_authentication(SalOp *h) {
888 sal_op_get_sal(h)->callbacks.register_failure(h,SalErrorFailure, SalReasonForbidden,_("Authentication failure"));
889 } else if (h->cid >0) {
890 sal_op_get_sal(h)->callbacks.call_failure(h,SalErrorFailure, SalReasonForbidden,_("Authentication failure"),0);
892 ms_warning("Auth failure not handled");
896 static void set_network_origin(SalOp *op, osip_message_t *req){
897 const char *received=NULL;
900 SalTransport transport;
901 if (extract_received_rport(req,&received,&rport,&transport)!=0){
902 osip_via_t *via=NULL;
904 osip_message_get_via(req,0,&via);
905 received=osip_via_get_host(via);
906 tmp=osip_via_get_port(via);
907 if (tmp) rport=atoi(tmp);
909 if (transport != SalTransportUDP) {
910 snprintf(origin,sizeof(origin)-1,"sip:%s:%i",received,rport);
912 snprintf(origin,sizeof(origin)-1,"sip:%s:%i;transport=%s",received,rport,sal_transport_to_string(transport));
914 __sal_op_set_network_origin(op,origin);
917 static void set_remote_ua(SalOp* op, osip_message_t *req){
918 if (op->base.remote_ua==NULL){
919 osip_header_t *h=NULL;
920 osip_message_get_user_agent(req,0,&h);
922 op->base.remote_ua=ms_strdup(h->hvalue);
927 static void set_replaces(SalOp *op, osip_message_t *req){
928 osip_header_t *h=NULL;
931 ms_free(op->replaces);
934 osip_message_header_get_byname(req,"replaces",0,&h);
936 if (h->hvalue && h->hvalue[0]!='\0'){
937 op->replaces=ms_strdup(h->hvalue);
942 static SalOp *find_op(Sal *sal, eXosip_event_t *ev){
944 return sal_find_call(sal,ev->cid);
947 return sal_find_register(sal,ev->rid);
950 return sal_find_out_subscribe(sal,ev->sid);
953 return sal_find_in_subscribe(sal,ev->nid);
955 if (ev->response) return sal_find_other(sal,ev->response);
959 static void inc_new_call(Sal *sal, eXosip_event_t *ev){
960 SalOp *op=sal_op_new(sal);
961 osip_from_t *from,*to;
962 osip_call_info_t *call_info;
964 sdp_message_t *sdp=eXosip_get_sdp_info(ev->request);
966 set_network_origin(op,ev->request);
967 set_remote_ua(op,ev->request);
968 set_replaces(op,ev->request);
971 op->sdp_offering=FALSE;
972 op->base.remote_media=sal_media_description_new();
973 sdp_to_media_description(sdp,op->base.remote_media);
974 sdp_message_free(sdp);
975 }else op->sdp_offering=TRUE;
977 from=osip_message_get_from(ev->request);
978 to=osip_message_get_to(ev->request);
979 osip_from_to_str(from,&tmp);
980 sal_op_set_from(op,tmp);
982 osip_from_to_str(to,&tmp);
983 sal_op_set_to(op,tmp);
986 osip_message_get_call_info(ev->request,0,&call_info);
989 osip_call_info_to_str(call_info,&tmp);
990 if( strstr(tmp,"answer-after=") != NULL)
992 op->auto_answer_asked=TRUE;
993 ms_message("The caller asked to automatically answer the call(Emergency?)\n");
1002 sal_add_call(op->base.root,op);
1003 sal->callbacks.call_received(op);
1006 static void handle_reinvite(Sal *sal, eXosip_event_t *ev){
1007 SalOp *op=find_op(sal,ev);
1009 osip_message_t *msg=NULL;
1012 ms_warning("Reinvite for non-existing operation !");
1017 sdp=eXosip_get_sdp_info(ev->request);
1018 if (op->base.remote_media){
1019 sal_media_description_unref(op->base.remote_media);
1020 op->base.remote_media=NULL;
1023 sal_media_description_unref(op->result);
1027 op->sdp_offering=FALSE;
1028 op->base.remote_media=sal_media_description_new();
1029 sdp_to_media_description(sdp,op->base.remote_media);
1030 sdp_message_free(sdp);
1031 sal->callbacks.call_updating(op);
1033 op->sdp_offering=TRUE;
1035 eXosip_call_build_answer(ev->tid,200,&msg);
1037 set_sdp_from_desc(msg,op->base.local_media);
1038 eXosip_call_send_answer(ev->tid,200,msg);
1045 static void handle_ack(Sal *sal, eXosip_event_t *ev){
1046 SalOp *op=find_op(sal,ev);
1050 ms_warning("ack for non-existing call !");
1054 if (op->sdp_offering){
1055 sdp=eXosip_get_sdp_info(ev->ack);
1057 if (op->base.remote_media)
1058 sal_media_description_unref(op->base.remote_media);
1059 op->base.remote_media=sal_media_description_new();
1060 sdp_to_media_description(sdp,op->base.remote_media);
1062 sdp_message_free(sdp);
1068 sal->callbacks.call_ack(op);
1072 static void update_contact_from_response(SalOp *op, osip_message_t *response){
1073 const char *received;
1075 SalTransport transport;
1076 if (extract_received_rport(response,&received,&rport,&transport)==0){
1077 const char *contact=sal_op_get_contact(op);
1079 /*no contact given yet, use from instead*/
1080 contact=sal_op_get_from(op);
1083 SalAddress *addr=sal_address_new(contact);
1085 sal_address_set_domain(addr,received);
1086 sal_address_set_port_int(addr,rport);
1087 if (transport!=SalTransportUDP)
1088 sal_address_set_transport(addr,transport);
1089 tmp=sal_address_as_string(addr);
1090 ms_message("Contact address updated to %s",tmp);
1091 sal_op_set_contact(op,tmp);
1092 sal_address_destroy(addr);
1098 static int call_proceeding(Sal *sal, eXosip_event_t *ev){
1099 SalOp *op=find_op(sal,ev);
1101 if (op==NULL || op->terminated==TRUE) {
1102 ms_warning("This call has been canceled.");
1104 eXosip_call_terminate(ev->cid,ev->did);
1112 /* update contact if received and rport are set by the server
1113 note: will only be used by remote for next INVITE, if any...*/
1114 update_contact_from_response(op,ev->response);
1118 static void call_ringing(Sal *sal, eXosip_event_t *ev){
1120 SalOp *op=find_op(sal,ev);
1121 if (call_proceeding(sal, ev)==-1) return;
1123 set_remote_ua(op,ev->response);
1124 sdp=eXosip_get_sdp_info(ev->response);
1126 op->base.remote_media=sal_media_description_new();
1127 sdp_to_media_description(sdp,op->base.remote_media);
1128 sdp_message_free(sdp);
1129 if (op->base.local_media) sdp_process(op);
1131 sal->callbacks.call_ringing(op);
1134 static void call_accepted(Sal *sal, eXosip_event_t *ev){
1136 osip_message_t *msg=NULL;
1137 SalOp *op=find_op(sal,ev);
1138 const char *contact;
1140 if (op==NULL || op->terminated==TRUE) {
1141 ms_warning("This call has been already terminated.");
1143 eXosip_call_terminate(ev->cid,ev->did);
1149 set_remote_ua(op,ev->response);
1151 sdp=eXosip_get_sdp_info(ev->response);
1153 op->base.remote_media=sal_media_description_new();
1154 sdp_to_media_description(sdp,op->base.remote_media);
1155 sdp_message_free(sdp);
1156 if (op->base.local_media) sdp_process(op);
1158 eXosip_call_build_ack(ev->did,&msg);
1160 ms_warning("This call has been already terminated.");
1162 eXosip_call_terminate(ev->cid,ev->did);
1166 contact=sal_op_get_contact(op);
1168 _osip_list_set_empty(&msg->contacts,(void (*)(void*))osip_contact_free);
1169 osip_message_set_contact(msg,contact);
1171 if (op->sdp_answer){
1172 set_sdp(msg,op->sdp_answer);
1173 sdp_message_free(op->sdp_answer);
1174 op->sdp_answer=NULL;
1176 eXosip_call_send_ack(ev->did,msg);
1177 sal->callbacks.call_accepted(op);
1180 static void call_terminated(Sal *sal, eXosip_event_t *ev){
1182 SalOp *op=find_op(sal,ev);
1184 ms_warning("Call terminated for already closed call ?");
1188 osip_from_to_str(ev->request->from,&from);
1190 sal->callbacks.call_terminated(op,from!=NULL ? from : sal_op_get_from(op));
1191 if (from) osip_free(from);
1192 op->terminated=TRUE;
1195 static void call_released(Sal *sal, eXosip_event_t *ev){
1196 SalOp *op=find_op(sal,ev);
1198 ms_warning("No op associated to this call_released()");
1201 if (!op->terminated){
1202 /* no response received so far */
1203 call_failure(sal,ev);
1205 sal->callbacks.call_released(op);
1208 static int get_auth_data_from_response(osip_message_t *resp, const char **realm, const char **username){
1209 const char *prx_realm=NULL,*www_realm=NULL;
1210 osip_proxy_authenticate_t *prx_auth;
1211 osip_www_authenticate_t *www_auth;
1213 *username=osip_uri_get_username(resp->from->url);
1214 prx_auth=(osip_proxy_authenticate_t*)osip_list_get(&resp->proxy_authenticates,0);
1215 www_auth=(osip_proxy_authenticate_t*)osip_list_get(&resp->www_authenticates,0);
1217 prx_realm=osip_proxy_authenticate_get_realm(prx_auth);
1219 www_realm=osip_www_authenticate_get_realm(www_auth);
1223 }else if (www_realm){
1231 static int get_auth_data_from_request(osip_message_t *msg, const char **realm, const char **username){
1232 osip_authorization_t *auth=NULL;
1233 osip_proxy_authorization_t *prx_auth=NULL;
1235 *username=osip_uri_get_username(msg->from->url);
1236 osip_message_get_authorization(msg, 0, &auth);
1238 *realm=osip_authorization_get_realm(auth);
1241 osip_message_get_proxy_authorization(msg,0,&prx_auth);
1243 *realm=osip_proxy_authorization_get_realm(prx_auth);
1249 static int get_auth_data(eXosip_event_t *ev, const char **realm, const char **username){
1250 if (ev->response && get_auth_data_from_response(ev->response,realm,username)==0) return 0;
1251 if (ev->request && get_auth_data_from_request(ev->request,realm,username)==0) return 0;
1255 int sal_op_get_auth_requested(SalOp *op, const char **realm, const char **username){
1256 if (op->pending_auth){
1257 return get_auth_data(op->pending_auth,realm,username);
1262 static bool_t process_authentication(Sal *sal, eXosip_event_t *ev){
1264 const char *username,*realm;
1267 ms_warning("No operation associated with this authentication !");
1270 if (get_auth_data(ev,&realm,&username)==0){
1271 if (op->pending_auth!=NULL){
1272 eXosip_event_free(op->pending_auth);
1273 op->pending_auth=ev;
1275 op->pending_auth=ev;
1276 sal_add_pending_auth(sal,op);
1279 sal->callbacks.auth_requested(op,realm,username);
1285 static void authentication_ok(Sal *sal, eXosip_event_t *ev){
1287 const char *username,*realm;
1290 ms_warning("No operation associated with this authentication_ok!");
1293 if (op->pending_auth){
1294 eXosip_event_free(op->pending_auth);
1295 sal_remove_pending_auth(sal,op);
1296 op->pending_auth=NULL;
1298 if (get_auth_data(ev,&realm,&username)==0){
1299 sal->callbacks.auth_success(op,realm,username);
1303 static bool_t call_failure(Sal *sal, eXosip_event_t *ev){
1306 char* computedReason=NULL;
1307 const char *reason=NULL;
1308 SalError error=SalErrorUnknown;
1309 SalReason sr=SalReasonUnknown;
1312 op=(SalOp*)find_op(sal,ev);
1315 ms_warning("Call failure reported for a closed call, ignored.");
1320 code=osip_message_get_status_code(ev->response);
1321 reason=osip_message_get_reason_phrase(ev->response);
1322 osip_header_t *h=NULL;
1323 if (!osip_message_header_get_byname( ev->response
1327 computedReason = ms_strdup_printf("%s %s",reason,osip_header_get_value(h));
1328 reason = computedReason;
1336 return process_authentication(sal,ev);
1339 error=SalErrorUnknown;
1342 error=SalErrorFailure;
1343 sr=SalReasonNotFound;
1346 error=SalErrorFailure;
1350 eXosip_default_action(ev);
1354 error=SalErrorFailure;
1355 sr=SalReasonTemporarilyUnavailable;
1357 error=SalErrorFailure;
1363 error=SalErrorFailure;
1364 sr=SalReasonDoNotDisturb;
1367 error=SalErrorFailure;
1368 sr=SalReasonDeclined;
1372 error=SalErrorFailure;
1373 sr=SalReasonUnknown;
1374 }else error=SalErrorNoResponse;
1376 op->terminated=TRUE;
1377 sal->callbacks.call_failure(op,error,sr,reason,code);
1378 if (computedReason != NULL){
1379 ms_free(computedReason);
1384 /* Request remote side to send us VFU */
1385 void sal_call_send_vfu_request(SalOp *h){
1386 osip_message_t *msg=NULL;
1388 "<?xml version=\"1.0\" encoding=\"utf-8\" ?>"
1392 " <picture_fast_update></picture_fast_update>"
1400 eXosip_call_build_info(h->did,&msg);
1402 osip_message_set_body(msg,info_body,strlen(info_body));
1403 osip_message_set_content_type(msg,"application/media_control+xml");
1404 snprintf(clen,sizeof(clen),"%lu",(unsigned long)strlen(info_body));
1405 osip_message_set_content_length(msg,clen);
1406 eXosip_call_send_request(h->did,msg);
1407 ms_message("Sending VFU request !");
1412 static void process_media_control_xml(Sal *sal, eXosip_event_t *ev){
1413 SalOp *op=find_op(sal,ev);
1414 osip_body_t *body=NULL;
1417 ms_warning("media control xml received without operation context!");
1421 osip_message_get_body(ev->request,0,&body);
1422 if (body && body->body!=NULL &&
1423 strstr(body->body,"picture_fast_update")){
1424 osip_message_t *ans=NULL;
1425 ms_message("Receiving VFU request !");
1426 if (sal->callbacks.vfu_request){
1427 sal->callbacks.vfu_request(op);
1428 eXosip_call_build_answer(ev->tid,200,&ans);
1430 eXosip_call_send_answer(ev->tid,200,ans);
1434 /*in all other cases we must say it is not implemented.*/
1436 osip_message_t *ans=NULL;
1438 eXosip_call_build_answer(ev->tid,501,&ans);
1440 eXosip_call_send_answer(ev->tid,501,ans);
1445 static void process_dtmf_relay(Sal *sal, eXosip_event_t *ev){
1446 SalOp *op=find_op(sal,ev);
1447 osip_body_t *body=NULL;
1450 ms_warning("media dtmf relay received without operation context!");
1454 osip_message_get_body(ev->request,0,&body);
1455 if (body && body->body!=NULL){
1456 osip_message_t *ans=NULL;
1457 const char *name=strstr(body->body,"Signal");
1458 if (name==NULL) name=strstr(body->body,"signal");
1460 ms_warning("Could not extract the dtmf name from the SIP INFO.");
1463 name+=strlen("signal");
1464 if (sscanf(name," = %1s",tmp)==1){
1465 ms_message("Receiving dtmf %s via SIP INFO.",tmp);
1466 if (sal->callbacks.dtmf_received != NULL)
1467 sal->callbacks.dtmf_received(op, tmp[0]);
1471 eXosip_call_build_answer(ev->tid,200,&ans);
1473 eXosip_call_send_answer(ev->tid,200,ans);
1478 static void fill_options_answer(osip_message_t *options){
1479 osip_message_set_allow(options,"INVITE, ACK, BYE, CANCEL, OPTIONS, MESSAGE, SUBSCRIBE, NOTIFY, INFO");
1480 osip_message_set_accept(options,"application/sdp");
1483 static void process_refer(Sal *sal, SalOp *op, eXosip_event_t *ev){
1484 osip_header_t *h=NULL;
1485 osip_message_t *ans=NULL;
1486 ms_message("Receiving REFER request !");
1487 osip_message_header_get_byname(ev->request,"Refer-To",0,&h);
1490 osip_from_t *from=NULL;
1492 osip_from_init(&from);
1494 if (osip_from_parse(from,h->hvalue)==0){
1496 osip_uri_header_t *uh=NULL;
1497 osip_header_t *referred_by=NULL;
1498 osip_uri_header_get_byname(&from->url->url_headers,(char*)"Replaces",&uh);
1499 if (uh!=NULL && uh->gvalue && uh->gvalue[0]!='\0'){
1500 ms_message("Found replaces in Refer-To");
1502 ms_free(op->replaces);
1504 op->replaces=ms_strdup(uh->gvalue);
1506 osip_message_header_get_byname(ev->request,"Referred-By",0,&referred_by);
1507 if (referred_by && referred_by->hvalue && referred_by->hvalue[0]!='\0'){
1508 if (op->referred_by)
1509 ms_free(op->referred_by);
1510 op->referred_by=ms_strdup(referred_by->hvalue);
1513 osip_uri_header_freelist(&from->url->url_headers);
1514 osip_from_to_str(from,&tmp);
1515 sal->callbacks.refer_received(sal,op,tmp);
1517 osip_from_free(from);
1520 eXosip_call_build_answer(ev->tid,202,&ans);
1522 eXosip_call_send_answer(ev->tid,202,ans);
1527 ms_warning("cannot do anything with the refer without destination\n");
1531 static void call_message_new(Sal *sal, eXosip_event_t *ev){
1532 osip_message_t *ans=NULL;
1534 if (MSG_IS_INFO(ev->request)){
1535 osip_content_type_t *ct;
1536 ct=osip_message_get_content_type(ev->request);
1537 if (ct && ct->subtype){
1538 if (strcmp(ct->subtype,"media_control+xml")==0)
1539 process_media_control_xml(sal,ev);
1540 else if (strcmp(ct->subtype,"dtmf-relay")==0)
1541 process_dtmf_relay(sal,ev);
1543 ms_message("Unhandled SIP INFO.");
1544 /*send an "Not implemented" answer*/
1546 eXosip_call_build_answer(ev->tid,501,&ans);
1548 eXosip_call_send_answer(ev->tid,501,ans);
1552 /*empty SIP INFO, probably to test we are alive. Send an empty answer*/
1554 eXosip_call_build_answer(ev->tid,200,&ans);
1556 eXosip_call_send_answer(ev->tid,200,ans);
1559 }else if(MSG_IS_MESSAGE(ev->request)){
1560 /* SIP messages could be received into call */
1561 text_received(sal, ev);
1563 eXosip_call_build_answer(ev->tid,200,&ans);
1565 eXosip_call_send_answer(ev->tid,200,ans);
1567 }else if(MSG_IS_REFER(ev->request)){
1568 SalOp *op=find_op(sal,ev);
1570 ms_message("Receiving REFER request !");
1571 process_refer(sal,op,ev);
1572 }else if(MSG_IS_NOTIFY(ev->request)){
1573 osip_header_t *h=NULL;
1575 SalOp *op=find_op(sal,ev);
1577 ms_message("Receiving NOTIFY request !");
1578 osip_from_to_str(ev->request->from,&from);
1579 osip_message_header_get_byname(ev->request,"Event",0,&h);
1581 sal->callbacks.notify(op,from,h->hvalue);
1582 /*answer that we received the notify*/
1584 eXosip_call_build_answer(ev->tid,200,&ans);
1586 eXosip_call_send_answer(ev->tid,200,ans);
1589 }else if (MSG_IS_OPTIONS(ev->request)){
1591 eXosip_call_build_answer(ev->tid,200,&ans);
1593 fill_options_answer(ans);
1594 eXosip_call_send_answer(ev->tid,200,ans);
1598 }else ms_warning("call_message_new: No request ?");
1601 static void inc_update(Sal *sal, eXosip_event_t *ev){
1602 osip_message_t *msg=NULL;
1603 ms_message("Processing incoming UPDATE");
1605 eXosip_message_build_answer(ev->tid,200,&msg);
1607 eXosip_message_send_answer(ev->tid,200,msg);
1611 static bool_t comes_from_local_if(osip_message_t *msg){
1612 osip_via_t *via=NULL;
1613 osip_message_get_via(msg,0,&via);
1616 host=osip_via_get_host(via);
1617 if (strcmp(host,"127.0.0.1")==0 || strcmp(host,"::1")==0){
1618 osip_generic_param_t *param=NULL;
1619 osip_via_param_get_byname(via,"received",¶m);
1620 if (param==NULL) return TRUE;
1621 if (param->gvalue &&
1622 (strcmp(param->gvalue,"127.0.0.1")==0 || strcmp(param->gvalue,"::1")==0)){
1630 static void text_received(Sal *sal, eXosip_event_t *ev){
1631 osip_body_t *body=NULL;
1632 char *from=NULL,*msg;
1634 osip_message_get_body(ev->request,0,&body);
1636 ms_error("Could not get text message from SIP body");
1640 osip_from_to_str(ev->request->from,&from);
1641 sal->callbacks.text_received(sal,from,msg);
1647 static void other_request(Sal *sal, eXosip_event_t *ev){
1648 ms_message("in other_request");
1649 if (ev->request==NULL) return;
1650 if (strcmp(ev->request->sip_method,"MESSAGE")==0){
1651 text_received(sal,ev);
1652 eXosip_message_send_answer(ev->tid,200,NULL);
1653 }else if (strcmp(ev->request->sip_method,"OPTIONS")==0){
1654 osip_message_t *options=NULL;
1655 eXosip_options_build_answer(ev->tid,200,&options);
1656 fill_options_answer(options);
1657 eXosip_options_send_answer(ev->tid,200,options);
1658 }else if (strncmp(ev->request->sip_method, "REFER", 5) == 0){
1659 ms_message("Receiving REFER request !");
1660 if (comes_from_local_if(ev->request)) {
1661 process_refer(sal,NULL,ev);
1662 }else ms_warning("Ignored REFER not coming from this local loopback interface.");
1663 }else if (strncmp(ev->request->sip_method, "UPDATE", 6) == 0){
1668 osip_message_to_str(ev->request,&tmp,&msglen);
1670 ms_message("Unsupported request received:\n%s",tmp);
1673 /*answer with a 501 Not implemented*/
1674 eXosip_message_send_answer(ev->tid,501,NULL);
1678 static void masquerade_via(osip_message_t *msg, const char *ip, const char *port){
1679 osip_via_t *via=NULL;
1680 osip_message_get_via(msg,0,&via);
1682 osip_free(via->port);
1683 via->port=osip_strdup(port);
1684 osip_free(via->host);
1685 via->host=osip_strdup(ip);
1690 static bool_t fix_message_contact(SalOp *op, osip_message_t *request,osip_message_t *last_answer) {
1691 osip_contact_t *ctt=NULL;
1692 const char *received;
1694 SalTransport transport;
1697 if (extract_received_rport(last_answer,&received,&rport,&transport)==-1) return FALSE;
1698 osip_message_get_contact(request,0,&ctt);
1700 ms_warning("fix_message_contact(): no contact to update");
1703 if (ctt->url->host!=NULL){
1704 osip_free(ctt->url->host);
1706 ctt->url->host=osip_strdup(received);
1707 if (ctt->url->port!=NULL){
1708 osip_free(ctt->url->port);
1710 snprintf(port,sizeof(port),"%i",rport);
1711 ctt->url->port=osip_strdup(port);
1712 if (op->masquerade_via) masquerade_via(request,received,port);
1714 if (transport != SalTransportUDP) {
1715 sal_address_set_param((SalAddress *)ctt, "transport", sal_transport_to_string(transport));
1720 static bool_t register_again_with_updated_contact(SalOp *op, osip_message_t *orig_request, osip_message_t *last_answer){
1721 osip_contact_t *ctt=NULL;
1722 SalAddress* ori_contact_address=NULL;
1723 const char *received;
1725 SalTransport transport;
1727 osip_message_t *msg=NULL;
1728 Sal* sal=op->base.root;
1730 if (sal->double_reg==FALSE ) return FALSE;
1732 if (extract_received_rport(last_answer,&received,&rport,&transport)==-1) return FALSE;
1733 osip_message_get_contact(orig_request,0,&ctt);
1734 osip_contact_to_str(ctt,&tmp);
1735 ori_contact_address = sal_address_new(tmp);
1737 /*check if contact is up to date*/
1738 if (strcmp(sal_address_get_domain(ori_contact_address),received) ==0
1739 && sal_address_get_port_int(ori_contact_address) == rport
1740 && sal_address_get_transport(ori_contact_address) == transport) {
1741 ms_message("Register has up to date contact, doing nothing.");
1743 sal_address_destroy(ori_contact_address);
1745 } else ms_message("contact do not match, need to update the register (%s with %s:%i;transport=%s)"
1749 ,sal_transport_to_string(transport));
1751 sal_address_destroy(ori_contact_address);
1753 if (transport == SalTransportUDP) {
1755 eXosip_register_build_register(op->rid,op->expires,&msg);
1758 ms_warning("Fail to create a contact updated register.");
1761 if (fix_message_contact(op,msg,last_answer)) {
1762 eXosip_register_send_register(op->rid,msg);
1764 ms_message("Resending new register with updated contact");
1767 ms_warning("Fail to send updated register.");
1774 update_contact_from_response(op,last_answer);
1778 static void registration_success(Sal *sal, eXosip_event_t *ev){
1779 SalOp *op=sal_find_register(sal,ev->rid);
1780 osip_header_t *h=NULL;
1783 ms_error("Receiving register response for unknown operation");
1786 osip_message_get_expires(ev->request,0,&h);
1787 if (h!=NULL && atoi(h->hvalue)!=0){
1789 if (!register_again_with_updated_contact(op,ev->request,ev->response)){
1790 sal->callbacks.register_success(op,registered);
1793 sal->callbacks.register_success(op,FALSE);
1797 static bool_t registration_failure(Sal *sal, eXosip_event_t *ev){
1799 const char *reason=NULL;
1800 SalOp *op=sal_find_register(sal,ev->rid);
1801 SalReason sr=SalReasonUnknown;
1802 SalError se=SalErrorUnknown;
1805 ms_error("Receiving register failure for unknown operation");
1809 status_code=osip_message_get_status_code(ev->response);
1810 reason=osip_message_get_reason_phrase(ev->response);
1812 switch(status_code){
1815 return process_authentication(sal,ev);
1817 case 423: /*interval too brief*/
1818 {/*retry with greater interval */
1819 osip_header_t *h=NULL;
1820 osip_message_t *msg=NULL;
1821 osip_message_header_get_byname(ev->response,"min-expires",0,&h);
1822 if (h && h->hvalue && h->hvalue[0]!='\0'){
1823 int val=atoi(h->hvalue);
1824 if (val>op->expires)
1826 }else op->expires*=2;
1828 eXosip_register_build_register(op->rid,op->expires,&msg);
1829 eXosip_register_send_register(op->rid,msg);
1833 case 606: /*Not acceptable, workaround for proxies that don't like private addresses
1834 in vias, such as ekiga.net
1835 On the opposite, freephonie.net bugs when via are masqueraded.
1837 op->masquerade_via=TRUE;
1839 /* if contact is up to date, process the failure, otherwise resend a new register with
1840 updated contact first, just in case the faillure is due to incorrect contact */
1841 if (ev->response && register_again_with_updated_contact(op,ev->request,ev->response))
1842 return TRUE; /*we are retrying with an updated contact*/
1843 if (status_code==403){
1845 sr=SalReasonForbidden;
1846 }else if (status_code==0){
1847 se=SalErrorNoResponse;
1849 sal->callbacks.register_failure(op,se,sr,reason);
1854 static void other_request_reply(Sal *sal,eXosip_event_t *ev){
1855 SalOp *op=find_op(sal,ev);
1858 ms_warning("other_request_reply(): Receiving response to unknown request.");
1862 update_contact_from_response(op,ev->response);
1863 if (ev->request && strcmp(osip_message_get_method(ev->request),"OPTIONS")==0)
1864 sal->callbacks.ping_reply(op);
1868 static bool_t process_event(Sal *sal, eXosip_event_t *ev){
1869 ms_message("linphone process event get a message %d\n",ev->type);
1871 case EXOSIP_CALL_ANSWERED:
1872 ms_message("CALL_ANSWERED\n");
1873 call_accepted(sal,ev);
1874 authentication_ok(sal,ev);
1876 case EXOSIP_CALL_CLOSED:
1877 case EXOSIP_CALL_CANCELLED:
1878 ms_message("CALL_CLOSED or CANCELLED\n");
1879 call_terminated(sal,ev);
1881 case EXOSIP_CALL_TIMEOUT:
1882 case EXOSIP_CALL_NOANSWER:
1883 ms_message("CALL_TIMEOUT or NOANSWER\n");
1884 return call_failure(sal,ev);
1886 case EXOSIP_CALL_REQUESTFAILURE:
1887 case EXOSIP_CALL_GLOBALFAILURE:
1888 case EXOSIP_CALL_SERVERFAILURE:
1889 ms_message("CALL_REQUESTFAILURE or GLOBALFAILURE or SERVERFAILURE\n");
1890 return call_failure(sal,ev);
1892 case EXOSIP_CALL_RELEASED:
1893 ms_message("CALL_RELEASED\n");
1894 call_released(sal, ev);
1896 case EXOSIP_CALL_INVITE:
1897 ms_message("CALL_NEW\n");
1898 inc_new_call(sal,ev);
1900 case EXOSIP_CALL_REINVITE:
1901 handle_reinvite(sal,ev);
1903 case EXOSIP_CALL_ACK:
1904 ms_message("CALL_ACK");
1907 case EXOSIP_CALL_REDIRECTED:
1908 ms_message("CALL_REDIRECTED");
1909 eXosip_default_action(ev);
1911 case EXOSIP_CALL_PROCEEDING:
1912 ms_message("CALL_PROCEEDING");
1913 call_proceeding(sal,ev);
1915 case EXOSIP_CALL_RINGING:
1916 ms_message("CALL_RINGING");
1917 call_ringing(sal,ev);
1919 case EXOSIP_CALL_MESSAGE_NEW:
1920 ms_message("EXOSIP_CALL_MESSAGE_NEW");
1921 call_message_new(sal,ev);
1923 case EXOSIP_CALL_MESSAGE_REQUESTFAILURE:
1925 (ev->response->status_code==407 || ev->response->status_code==401)){
1926 return process_authentication(sal,ev);
1929 case EXOSIP_IN_SUBSCRIPTION_NEW:
1930 ms_message("CALL_IN_SUBSCRIPTION_NEW ");
1931 sal_exosip_subscription_recv(sal,ev);
1933 case EXOSIP_IN_SUBSCRIPTION_RELEASED:
1934 ms_message("CALL_SUBSCRIPTION_NEW ");
1935 sal_exosip_in_subscription_closed(sal,ev);
1937 case EXOSIP_SUBSCRIPTION_UPDATE:
1938 ms_message("CALL_SUBSCRIPTION_UPDATE");
1940 case EXOSIP_SUBSCRIPTION_NOTIFY:
1941 ms_message("CALL_SUBSCRIPTION_NOTIFY");
1942 sal_exosip_notify_recv(sal,ev);
1944 case EXOSIP_SUBSCRIPTION_ANSWERED:
1945 ms_message("EXOSIP_SUBSCRIPTION_ANSWERED, ev->sid=%i, ev->did=%i\n",ev->sid,ev->did);
1946 sal_exosip_subscription_answered(sal,ev);
1948 case EXOSIP_SUBSCRIPTION_CLOSED:
1949 ms_message("EXOSIP_SUBSCRIPTION_CLOSED\n");
1950 sal_exosip_subscription_closed(sal,ev);
1952 case EXOSIP_SUBSCRIPTION_REQUESTFAILURE: /**< announce a request failure */
1953 if (ev->response && (ev->response->status_code == 407 || ev->response->status_code == 401)){
1954 return process_authentication(sal,ev);
1956 case EXOSIP_SUBSCRIPTION_SERVERFAILURE:
1957 case EXOSIP_SUBSCRIPTION_GLOBALFAILURE:
1958 sal_exosip_subscription_closed(sal,ev);
1960 case EXOSIP_REGISTRATION_FAILURE:
1961 ms_message("REGISTRATION_FAILURE\n");
1962 return registration_failure(sal,ev);
1964 case EXOSIP_REGISTRATION_SUCCESS:
1965 authentication_ok(sal,ev);
1966 registration_success(sal,ev);
1968 case EXOSIP_MESSAGE_NEW:
1969 other_request(sal,ev);
1971 case EXOSIP_MESSAGE_PROCEEDING:
1972 case EXOSIP_MESSAGE_ANSWERED:
1973 case EXOSIP_MESSAGE_REDIRECTED:
1974 case EXOSIP_MESSAGE_SERVERFAILURE:
1975 case EXOSIP_MESSAGE_GLOBALFAILURE:
1976 other_request_reply(sal,ev);
1978 case EXOSIP_MESSAGE_REQUESTFAILURE:
1979 case EXOSIP_NOTIFICATION_REQUESTFAILURE:
1981 switch (ev->response->status_code) {
1984 return process_authentication(sal,ev);
1986 eXosip_automatic_action ();
1991 other_request_reply(sal,ev);
1994 ms_message("Unhandled exosip event ! %i",ev->type);
2000 int sal_iterate(Sal *sal){
2002 while((ev=eXosip_event_wait(0,0))!=NULL){
2003 if (process_event(sal,ev))
2004 eXosip_event_free(ev);
2007 eXosip_automatic_refresh();
2012 static void register_set_contact(osip_message_t *msg, const char *contact){
2013 osip_uri_param_t *param = NULL;
2014 osip_contact_t *ct=NULL;
2016 /*we get the line parameter choosed by exosip, and add it to our own contact*/
2017 osip_message_get_contact(msg,0,&ct);
2019 osip_uri_uparam_get_byname(ct->url, "line", ¶m);
2020 if (param && param->gvalue)
2021 line=osip_strdup(param->gvalue);
2023 _osip_list_set_empty(&msg->contacts,(void (*)(void*))osip_contact_free);
2024 osip_message_set_contact(msg,contact);
2025 osip_message_get_contact(msg,0,&ct);
2026 osip_uri_uparam_add(ct->url,osip_strdup("line"),line);
2029 static void sal_register_add_route(osip_message_t *msg, const char *proxy){
2031 snprintf(tmp,sizeof(tmp)-1,"<%s;lr>",proxy);
2033 osip_list_special_free(&msg->routes,(void (*)(void*))osip_route_free);
2034 osip_message_set_route(msg,tmp);
2037 int sal_register(SalOp *h, const char *proxy, const char *from, int expires){
2038 osip_message_t *msg;
2039 const char *contact=sal_op_get_contact(h);
2041 sal_op_set_route(h,proxy);
2043 SalAddress *from_parsed=sal_address_new(from);
2045 if (from_parsed==NULL) {
2046 ms_warning("sal_register() bad from %s",from);
2049 snprintf(domain,sizeof(domain),"sip:%s",sal_address_get_domain(from_parsed));
2050 sal_address_destroy(from_parsed);
2052 h->rid=eXosip_register_build_initial_register(from,domain,NULL,expires,&msg);
2054 if (contact) register_set_contact(msg,contact);
2055 sal_register_add_route(msg,proxy);
2056 sal_add_register(h->base.root,h);
2058 ms_error("Could not build initial register.");
2064 eXosip_register_build_register(h->rid,expires,&msg);
2065 sal_register_add_route(msg,proxy);
2068 eXosip_register_send_register(h->rid,msg);
2071 return (msg != NULL) ? 0 : -1;
2074 int sal_register_refresh(SalOp *op, int expires){
2075 osip_message_t *msg=NULL;
2076 const char *contact=sal_op_get_contact(op);
2079 ms_error("Unexistant registration context, not possible to refresh.");
2083 eXosip_register_build_register(op->rid,expires,&msg);
2085 if (contact) register_set_contact(msg,contact);
2086 sal_register_add_route(msg,sal_op_get_route(op));
2087 eXosip_register_send_register(op->rid,msg);
2088 }else ms_error("Could not build REGISTER refresh message.");
2090 return (msg != NULL) ? 0 : -1;
2094 int sal_unregister(SalOp *h){
2095 osip_message_t *msg=NULL;
2097 eXosip_register_build_register(h->rid,0,&msg);
2098 if (msg) eXosip_register_send_register(h->rid,msg);
2099 else ms_warning("Could not build unREGISTER !");
2104 SalAddress * sal_address_new(const char *uri){
2106 osip_from_init(&from);
2108 // Remove front spaces
2109 while (uri[0]==' ') {
2113 if (osip_from_parse(from,uri)!=0){
2114 osip_from_free(from);
2117 if (from->displayname!=NULL && from->displayname[0]=='"'){
2118 char *unquoted=osip_strdup_without_quote(from->displayname);
2119 osip_free(from->displayname);
2120 from->displayname=unquoted;
2122 return (SalAddress*)from;
2125 SalAddress * sal_address_clone(const SalAddress *addr){
2126 osip_from_t *ret=NULL;
2127 osip_from_clone((osip_from_t*)addr,&ret);
2128 return (SalAddress*)ret;
2131 #define null_if_empty(s) (((s)!=NULL && (s)[0]!='\0') ? (s) : NULL )
2133 const char *sal_address_get_scheme(const SalAddress *addr){
2134 const osip_from_t *u=(const osip_from_t*)addr;
2135 return null_if_empty(u->url->scheme);
2138 const char *sal_address_get_display_name(const SalAddress* addr){
2139 const osip_from_t *u=(const osip_from_t*)addr;
2140 return null_if_empty(u->displayname);
2143 const char *sal_address_get_username(const SalAddress *addr){
2144 const osip_from_t *u=(const osip_from_t*)addr;
2145 return null_if_empty(u->url->username);
2148 const char *sal_address_get_domain(const SalAddress *addr){
2149 const osip_from_t *u=(const osip_from_t*)addr;
2150 return null_if_empty(u->url->host);
2153 void sal_address_set_display_name(SalAddress *addr, const char *display_name){
2154 osip_from_t *u=(osip_from_t*)addr;
2155 if (u->displayname!=NULL){
2156 osip_free(u->displayname);
2157 u->displayname=NULL;
2159 if (display_name!=NULL && display_name[0]!='\0'){
2160 u->displayname=osip_strdup(display_name);
2164 void sal_address_set_username(SalAddress *addr, const char *username){
2165 osip_from_t *uri=(osip_from_t*)addr;
2166 if (uri->url->username!=NULL){
2167 osip_free(uri->url->username);
2168 uri->url->username=NULL;
2171 uri->url->username=osip_strdup(username);
2174 void sal_address_set_domain(SalAddress *addr, const char *host){
2175 osip_from_t *uri=(osip_from_t*)addr;
2176 if (uri->url->host!=NULL){
2177 osip_free(uri->url->host);
2178 uri->url->host=NULL;
2181 uri->url->host=osip_strdup(host);
2184 void sal_address_set_port(SalAddress *addr, const char *port){
2185 osip_from_t *uri=(osip_from_t*)addr;
2186 if (uri->url->port!=NULL){
2187 osip_free(uri->url->port);
2188 uri->url->port=NULL;
2191 uri->url->port=osip_strdup(port);
2194 void sal_address_set_port_int(SalAddress *uri, int port){
2197 /*this is the default, special case to leave the port field blank*/
2198 sal_address_set_port(uri,NULL);
2201 snprintf(tmp,sizeof(tmp),"%i",port);
2202 sal_address_set_port(uri,tmp);
2205 void sal_address_clean(SalAddress *addr){
2206 osip_generic_param_freelist(& ((osip_from_t*)addr)->gen_params);
2207 osip_uri_param_freelist(& ((osip_from_t*)addr)->url->url_params);
2210 char *sal_address_as_string(const SalAddress *u){
2212 osip_from_t *from=(osip_from_t *)u;
2213 char *old_displayname=NULL;
2214 /* hack to force use of quotes around the displayname*/
2215 if (from->displayname!=NULL
2216 && from->displayname[0]!='"'){
2217 old_displayname=from->displayname;
2218 from->displayname=osip_enquote(from->displayname);
2220 osip_from_to_str(from,&tmp);
2221 if (old_displayname!=NULL){
2222 ms_free(from->displayname);
2223 from->displayname=old_displayname;
2230 char *sal_address_as_string_uri_only(const SalAddress *u){
2231 char *tmp=NULL,*ret;
2232 osip_uri_to_str(((osip_from_t*)u)->url,&tmp);
2237 void sal_address_set_param(SalAddress *u,const char* name,const char* value) {
2238 osip_uri_param_t *param=NULL;
2239 osip_uri_uparam_get_byname(((osip_from_t*)u)->url,(char*)name,¶m);
2241 osip_uri_uparam_add (((osip_from_t*)u)->url,ms_strdup(name),value ? ms_strdup(value) : NULL);
2243 osip_free(param->gvalue);
2244 param->gvalue=value ? osip_strdup(value) : NULL;
2249 void sal_address_destroy(SalAddress *u){
2250 osip_from_free((osip_from_t*)u);
2253 void sal_set_keepalive_period(Sal *ctx,unsigned int value) {
2254 ctx->keepalive_period=value;
2255 eXosip_set_option (EXOSIP_OPT_UDP_KEEP_ALIVE, &value);
2257 unsigned int sal_get_keepalive_period(Sal *ctx) {
2258 return ctx->keepalive_period;
2261 const char * sal_address_get_port(const SalAddress *addr) {
2262 const osip_from_t *u=(const osip_from_t*)addr;
2263 return null_if_empty(u->url->port);
2266 int sal_address_get_port_int(const SalAddress *uri) {
2267 const char* port = sal_address_get_port(uri);
2274 SalTransport sal_address_get_transport(const SalAddress* addr) {
2275 const osip_from_t *u=(const osip_from_t*)addr;
2276 osip_uri_param_t *transport_param=NULL;
2277 osip_uri_uparam_get_byname(u->url,"transport",&transport_param);
2278 if (transport_param == NULL){
2279 return SalTransportUDP;
2281 return sal_transport_parse(transport_param->gvalue);
2284 void sal_address_set_transport(SalAddress* addr,SalTransport transport) {
2285 sal_address_set_param(addr, "transport", sal_transport_to_string(transport));
2288 /* sends a reinvite. Local media description may have changed by application since call establishment*/
2289 int sal_call_update(SalOp *h, const char *subject){
2291 osip_message_t *reinvite=NULL;
2294 if(eXosip_call_build_request(h->did,"INVITE",&reinvite) != 0 || reinvite==NULL){
2299 osip_message_set_subject(reinvite,subject);
2300 osip_message_set_allow(reinvite, "INVITE, ACK, CANCEL, OPTIONS, BYE, REFER, NOTIFY, MESSAGE, SUBSCRIBE, INFO");
2301 if (h->base.root->session_expires!=0){
2302 osip_message_set_header(reinvite, "Session-expires", "200");
2303 osip_message_set_supported(reinvite, "timer");
2305 if (h->base.local_media){
2306 h->sdp_offering=TRUE;
2307 set_sdp_from_desc(reinvite,h->base.local_media);
2308 }else h->sdp_offering=FALSE;
2310 err = eXosip_call_send_request(h->did, reinvite);
2314 void sal_reuse_authorization(Sal *ctx, bool_t value) {
2315 ctx->reuse_authorization=value;