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 eXosip_tls_verify_certificate(ctx->verify_server_certs);
381 ms_warning("unexpected proto, using datagram");
384 /* it does not work, exosip does not implement this option correctly*/
386 eXosip_set_option(EXOSIP_OPT_DNS_CAPABILITIES,&err); /*0=no NAPTR */
388 /*see if it looks like an IPv6 address*/
389 int use_rports = ctx->use_rports; // Copy char to int to avoid bad alignment
390 eXosip_set_option(EXOSIP_OPT_USE_RPORT,&use_rports);
391 int dont_use_101 = !ctx->use_101; // Copy char to int to avoid bad alignment
392 eXosip_set_option(EXOSIP_OPT_DONT_SEND_101,&dont_use_101);
394 ipv6=strchr(addr,':')!=NULL;
395 eXosip_enable_ipv6(ipv6);
397 if (is_secure && tr == SalTransportUDP){
398 ms_fatal("SIP over DTLS is not supported yet.");
401 err=eXosip_listen_addr(proto, addr, port, ipv6 ? PF_INET6 : PF_INET, is_secure);
402 #ifdef HAVE_EXOSIP_GET_SOCKET
403 ms_message("Exosip has socket number %i",eXosip_get_socket(proto));
410 ortp_socket_t sal_get_socket(Sal *ctx){
411 #ifdef HAVE_EXOSIP_GET_SOCKET
412 return eXosip_get_socket(IPPROTO_UDP);
414 ms_warning("Sorry, eXosip does not have eXosip_get_socket() method");
419 void sal_set_user_agent(Sal *ctx, const char *user_agent){
420 eXosip_set_user_agent(user_agent);
423 void sal_use_session_timers(Sal *ctx, int expires){
424 ctx->session_expires=expires;
427 void sal_use_one_matching_codec_policy(Sal *ctx, bool_t one_matching_codec){
428 ctx->one_matching_codec=one_matching_codec;
431 MSList *sal_get_pending_auths(Sal *sal){
432 return ms_list_copy(sal->pending_auths);
435 void sal_use_double_registrations(Sal *ctx, bool_t enabled){
436 ctx->double_reg=enabled;
439 void sal_use_rport(Sal *ctx, bool_t use_rports){
440 ctx->use_rports=use_rports;
442 void sal_use_101(Sal *ctx, bool_t use_101){
443 ctx->use_101=use_101;
446 void sal_set_root_ca(Sal* ctx, const char* rootCa) {
448 ms_free(ctx->rootCa);
449 ctx->rootCa = ms_strdup(rootCa);
452 void sal_verify_server_certificates(Sal *ctx, bool_t verify){
453 ctx->verify_server_certs=verify;
454 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");
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);
525 offer_answer_initiate_incoming(h->base.local_media,h->base.remote_media,h->result,h->base.root->one_matching_codec);
526 h->sdp_answer=media_description_to_sdp(h->result);
527 /*once we have generated the SDP answer, we modify the result description for processing by the upper layer.
528 It should contains media parameters constraint from the remote offer, not our response*/
529 strcpy(h->result->addr,h->base.remote_media->addr);
530 h->result->bandwidth=h->base.remote_media->bandwidth;
532 for(i=0;i<h->result->nstreams;++i){
533 if (h->result->streams[i].port>0){
534 strcpy(h->result->streams[i].addr,h->base.remote_media->streams[i].addr);
535 h->result->streams[i].ptime=h->base.remote_media->streams[i].ptime;
536 h->result->streams[i].bandwidth=h->base.remote_media->streams[i].bandwidth;
537 h->result->streams[i].port=h->base.remote_media->streams[i].port;
539 if (h->result->streams[i].proto == SalProtoRtpSavp) {
540 h->result->streams[i].crypto[0] = h->base.remote_media->streams[i].crypto[0];
548 int sal_call_is_offerer(const SalOp *h){
549 return h->sdp_offering;
552 int sal_call_set_local_media_description(SalOp *h, SalMediaDescription *desc){
554 sal_media_description_ref(desc);
555 if (h->base.local_media)
556 sal_media_description_unref(h->base.local_media);
557 h->base.local_media=desc;
561 int sal_call(SalOp *h, const char *from, const char *to){
564 osip_message_t *invite=NULL;
565 sal_op_set_from(h,from);
567 sal_exosip_fix_route(h);
569 h->terminated = FALSE;
571 route = sal_op_get_route(h);
572 err=eXosip_call_build_initial_invite(&invite,to,from,route,"Phone call");
574 ms_error("Could not create call. Error %d (from=%s to=%s route=%s)",
575 err, from, to, route);
578 osip_message_set_allow(invite, "INVITE, ACK, CANCEL, OPTIONS, BYE, REFER, NOTIFY, MESSAGE, SUBSCRIBE, INFO");
579 if (h->base.contact){
580 _osip_list_set_empty(&invite->contacts,(void (*)(void*))osip_contact_free);
581 osip_message_set_contact(invite,h->base.contact);
583 if (h->base.root->session_expires!=0){
584 osip_message_set_header(invite, "Session-expires", "200");
585 osip_message_set_supported(invite, "timer");
587 if (h->base.local_media){
588 h->sdp_offering=TRUE;
589 set_sdp_from_desc(invite,h->base.local_media);
590 }else h->sdp_offering=FALSE;
592 osip_message_set_header(invite,"Replaces",h->replaces);
594 osip_message_set_header(invite,"Referred-By",h->referred_by);
598 err=eXosip_call_send_initial_invite(invite);
602 ms_error("Fail to send invite ! Error code %d", err);
605 sal_add_call(h->base.root,h);
610 int sal_call_notify_ringing(SalOp *h, bool_t early_media){
613 /*if early media send also 180 and 183 */
614 if (early_media && h->sdp_answer){
617 eXosip_call_build_answer(h->tid,180,&msg);
619 set_sdp(msg,h->sdp_answer);
620 eXosip_call_send_answer(h->tid,180,msg);
623 eXosip_call_build_answer(h->tid,183,&msg);
625 set_sdp(msg,h->sdp_answer);
626 eXosip_call_send_answer(h->tid,183,msg);
631 eXosip_call_send_answer(h->tid,180,NULL);
637 int sal_call_accept(SalOp * h){
639 const char *contact=sal_op_get_contact(h);
641 int err=eXosip_call_build_answer(h->tid,200,&msg);
642 if (err<0 || msg==NULL){
643 ms_error("Fail to build answer for call: err=%i",err);
646 if (h->base.root->session_expires!=0){
647 if (h->supports_session_timers) osip_message_set_supported(msg, "timer");
651 _osip_list_set_empty(&msg->contacts,(void (*)(void*))osip_contact_free);
652 osip_message_set_contact(msg,contact);
655 if (h->base.local_media){
656 /*this is the case where we received an invite without SDP*/
657 if (h->sdp_offering) {
658 set_sdp_from_desc(msg,h->base.local_media);
661 set_sdp(msg,h->sdp_answer);
662 sdp_message_free(h->sdp_answer);
667 ms_error("You are accepting a call but not defined any media capabilities !");
669 eXosip_call_send_answer(h->tid,200,msg);
673 int sal_call_decline(SalOp *h, SalReason reason, const char *redirect){
674 if (reason==SalReasonBusy){
676 eXosip_call_send_answer(h->tid,486,NULL);
679 else if (reason==SalReasonTemporarilyUnavailable){
681 eXosip_call_send_answer(h->tid,480,NULL);
683 }else if (reason==SalReasonDoNotDisturb){
685 eXosip_call_send_answer(h->tid,600,NULL);
687 }else if (reason==SalReasonMedia){
689 eXosip_call_send_answer(h->tid,415,NULL);
691 }else if (redirect!=NULL && reason==SalReasonRedirect){
694 if (strstr(redirect,"sip:")!=0) code=302;
697 eXosip_call_build_answer(h->tid,code,&msg);
698 osip_message_set_contact(msg,redirect);
699 eXosip_call_send_answer(h->tid,code,msg);
701 }else sal_call_terminate(h);
705 SalMediaDescription * sal_call_get_final_media_description(SalOp *h){
706 if (h->base.local_media && h->base.remote_media && !h->result){
712 int sal_call_set_referer(SalOp *h, SalOp *refered_call){
713 if (refered_call->replaces)
714 h->replaces=ms_strdup(refered_call->replaces);
715 if (refered_call->referred_by)
716 h->referred_by=ms_strdup(refered_call->referred_by);
720 int sal_ping(SalOp *op, const char *from, const char *to){
721 osip_message_t *options=NULL;
723 sal_op_set_from(op,from);
724 sal_op_set_to(op,to);
726 /*bug here: eXosip2 does not honor the route argument*/
727 eXosip_options_build_request (&options, sal_op_get_to(op),
728 sal_op_get_from(op),sal_op_get_route(op));
730 if (op->base.root->session_expires!=0){
731 osip_message_set_header(options, "Session-expires", "200");
732 osip_message_set_supported(options, "timer");
734 sal_add_other(sal_op_get_sal(op),op,options);
735 return eXosip_options_send_request(options);
740 int sal_call_accept_refer(SalOp *op){
741 osip_message_t *msg=NULL;
744 err = eXosip_call_build_notify(op->did,EXOSIP_SUBCRSTATE_ACTIVE,&msg);
747 osip_message_set_header(msg,(const char *)"event","refer");
748 osip_message_set_content_type(msg,"message/sipfrag");
749 osip_message_set_body(msg,"SIP/2.0 100 Trying",sizeof("SIP/2.0 100 Trying"));
750 eXosip_call_send_request(op->did,msg);
754 ms_error("could not get a notify built\n");
760 int sal_call_refer(SalOp *h, const char *refer_to){
761 osip_message_t *msg=NULL;
764 eXosip_call_build_refer(h->did,refer_to, &msg);
765 if (msg) err=eXosip_call_send_request(h->did, msg);
771 int sal_call_refer_with_replaces(SalOp *h, SalOp *other_call_h){
772 osip_message_t *msg=NULL;
773 char referto[256]={0};
776 if (eXosip_call_get_referto(other_call_h->did,referto,sizeof(referto)-1)!=0){
777 ms_error("eXosip_call_get_referto() failed for did=%i",other_call_h->did);
781 eXosip_call_build_refer(h->did,referto, &msg);
782 osip_message_set_header(msg,"Referred-By",h->base.from);
783 if (msg) err=eXosip_call_send_request(h->did, msg);
789 SalOp *sal_call_get_replaces(SalOp *h){
790 if (h!=NULL && h->replaces!=NULL){
793 cid=eXosip_call_find_by_replaces(h->replaces);
796 SalOp *ret=sal_find_call(h->base.root,cid);
803 int sal_call_send_dtmf(SalOp *h, char dtmf){
804 osip_message_t *msg=NULL;
809 eXosip_call_build_info(h->did,&msg);
811 snprintf(dtmf_body, sizeof(dtmf_body), "Signal=%c\r\nDuration=250\r\n", dtmf);
812 osip_message_set_body(msg,dtmf_body,strlen(dtmf_body));
813 osip_message_set_content_type(msg,"application/dtmf-relay");
814 snprintf(clen,sizeof(clen),"%lu",(unsigned long)strlen(dtmf_body));
815 osip_message_set_content_length(msg,clen);
816 eXosip_call_send_request(h->did,msg);
822 static void push_auth_to_exosip(const SalAuthInfo *info){
824 if (info->userid==NULL || info->userid[0]=='\0') userid=info->username;
825 else userid=info->userid;
826 ms_message("Authentication info for username [%s], id[%s], realm [%s] added to eXosip", info->username,userid, info->realm);
827 eXosip_add_authentication_info (info->username,userid,
828 info->password, NULL,info->realm);
831 * Just for symmetry ;-)
833 static void pop_auth_from_exosip() {
834 eXosip_clear_authentication_info();
837 int sal_call_terminate(SalOp *h){
839 if (h == NULL) return -1;
840 if (h->auth_info) push_auth_to_exosip(h->auth_info);
842 err=eXosip_call_terminate(h->cid,h->did);
844 if (!h->base.root->reuse_authorization) pop_auth_from_exosip();
846 ms_warning("Exosip could not terminate the call: cid=%i did=%i", h->cid,h->did);
852 void sal_op_authenticate(SalOp *h, const SalAuthInfo *info){
853 if (h->pending_auth){
854 push_auth_to_exosip(info);
856 /*FIXME exosip does not take into account this update register message*/
858 if (fix_message_contact(h, h->pending_auth->request,h->pending_auth->response)) {
862 update_contact_from_response(h,h->pending_auth->response);
864 eXosip_default_action(h->pending_auth);
866 ms_message("eXosip_default_action() done");
867 if (!h->base.root->reuse_authorization) pop_auth_from_exosip();
869 if (h->auth_info) sal_auth_info_delete(h->auth_info); /*if already exist*/
870 h->auth_info=sal_auth_info_clone(info); /*store auth info for subsequent request*/
873 void sal_op_cancel_authentication(SalOp *h) {
875 sal_op_get_sal(h)->callbacks.register_failure(h,SalErrorFailure, SalReasonForbidden,_("Authentication failure"));
876 } else if (h->cid >0) {
877 sal_op_get_sal(h)->callbacks.call_failure(h,SalErrorFailure, SalReasonForbidden,_("Authentication failure"),0);
879 ms_warning("Auth failure not handled");
883 static void set_network_origin(SalOp *op, osip_message_t *req){
884 const char *received=NULL;
887 SalTransport transport;
888 if (extract_received_rport(req,&received,&rport,&transport)!=0){
889 osip_via_t *via=NULL;
891 osip_message_get_via(req,0,&via);
892 received=osip_via_get_host(via);
893 tmp=osip_via_get_port(via);
894 if (tmp) rport=atoi(tmp);
896 if (transport != SalTransportUDP) {
897 snprintf(origin,sizeof(origin)-1,"sip:%s:%i",received,rport);
899 snprintf(origin,sizeof(origin)-1,"sip:%s:%i;transport=%s",received,rport,sal_transport_to_string(transport));
901 __sal_op_set_network_origin(op,origin);
904 static void set_remote_ua(SalOp* op, osip_message_t *req){
905 if (op->base.remote_ua==NULL){
906 osip_header_t *h=NULL;
907 osip_message_get_user_agent(req,0,&h);
909 op->base.remote_ua=ms_strdup(h->hvalue);
914 static void set_replaces(SalOp *op, osip_message_t *req){
915 osip_header_t *h=NULL;
918 ms_free(op->replaces);
921 osip_message_header_get_byname(req,"replaces",0,&h);
923 if (h->hvalue && h->hvalue[0]!='\0'){
924 op->replaces=ms_strdup(h->hvalue);
929 static SalOp *find_op(Sal *sal, eXosip_event_t *ev){
931 return sal_find_call(sal,ev->cid);
934 return sal_find_register(sal,ev->rid);
937 return sal_find_out_subscribe(sal,ev->sid);
940 return sal_find_in_subscribe(sal,ev->nid);
942 if (ev->response) return sal_find_other(sal,ev->response);
946 static void inc_new_call(Sal *sal, eXosip_event_t *ev){
947 SalOp *op=sal_op_new(sal);
948 osip_from_t *from,*to;
949 osip_call_info_t *call_info;
951 sdp_message_t *sdp=eXosip_get_sdp_info(ev->request);
953 set_network_origin(op,ev->request);
954 set_remote_ua(op,ev->request);
955 set_replaces(op,ev->request);
958 op->sdp_offering=FALSE;
959 op->base.remote_media=sal_media_description_new();
960 sdp_to_media_description(sdp,op->base.remote_media);
961 sdp_message_free(sdp);
962 }else op->sdp_offering=TRUE;
964 from=osip_message_get_from(ev->request);
965 to=osip_message_get_to(ev->request);
966 osip_from_to_str(from,&tmp);
967 sal_op_set_from(op,tmp);
969 osip_from_to_str(to,&tmp);
970 sal_op_set_to(op,tmp);
973 osip_message_get_call_info(ev->request,0,&call_info);
976 osip_call_info_to_str(call_info,&tmp);
977 if( strstr(tmp,"answer-after=") != NULL)
979 op->auto_answer_asked=TRUE;
980 ms_message("The caller asked to automatically answer the call(Emergency?)\n");
989 sal_add_call(op->base.root,op);
990 sal->callbacks.call_received(op);
993 static void handle_reinvite(Sal *sal, eXosip_event_t *ev){
994 SalOp *op=find_op(sal,ev);
996 osip_message_t *msg=NULL;
999 ms_warning("Reinvite for non-existing operation !");
1004 sdp=eXosip_get_sdp_info(ev->request);
1005 if (op->base.remote_media){
1006 sal_media_description_unref(op->base.remote_media);
1007 op->base.remote_media=NULL;
1010 sal_media_description_unref(op->result);
1014 op->sdp_offering=FALSE;
1015 op->base.remote_media=sal_media_description_new();
1016 sdp_to_media_description(sdp,op->base.remote_media);
1017 sdp_message_free(sdp);
1018 sal->callbacks.call_updating(op);
1020 op->sdp_offering=TRUE;
1022 eXosip_call_build_answer(ev->tid,200,&msg);
1024 set_sdp_from_desc(msg,op->base.local_media);
1025 eXosip_call_send_answer(ev->tid,200,msg);
1032 static void handle_ack(Sal *sal, eXosip_event_t *ev){
1033 SalOp *op=find_op(sal,ev);
1037 ms_warning("ack for non-existing call !");
1040 sdp=eXosip_get_sdp_info(ev->ack);
1042 op->base.remote_media=sal_media_description_new();
1043 sdp_to_media_description(sdp,op->base.remote_media);
1045 sdp_message_free(sdp);
1048 if (sdp) sal->callbacks.call_updating(op);
1051 sal->callbacks.call_ack(op);
1055 static void update_contact_from_response(SalOp *op, osip_message_t *response){
1056 const char *received;
1058 SalTransport transport;
1059 if (extract_received_rport(response,&received,&rport,&transport)==0){
1060 const char *contact=sal_op_get_contact(op);
1062 /*no contact given yet, use from instead*/
1063 contact=sal_op_get_from(op);
1066 SalAddress *addr=sal_address_new(contact);
1068 sal_address_set_domain(addr,received);
1069 sal_address_set_port_int(addr,rport);
1070 if (transport!=SalTransportUDP)
1071 sal_address_set_transport(addr,transport);
1072 tmp=sal_address_as_string(addr);
1073 ms_message("Contact address updated to %s",tmp);
1074 sal_op_set_contact(op,tmp);
1075 sal_address_destroy(addr);
1081 static int call_proceeding(Sal *sal, eXosip_event_t *ev){
1082 SalOp *op=find_op(sal,ev);
1084 if (op==NULL || op->terminated==TRUE) {
1085 ms_warning("This call has been canceled.");
1087 eXosip_call_terminate(ev->cid,ev->did);
1095 /* update contact if received and rport are set by the server
1096 note: will only be used by remote for next INVITE, if any...*/
1097 update_contact_from_response(op,ev->response);
1101 static void call_ringing(Sal *sal, eXosip_event_t *ev){
1103 SalOp *op=find_op(sal,ev);
1104 if (call_proceeding(sal, ev)==-1) return;
1106 set_remote_ua(op,ev->response);
1107 sdp=eXosip_get_sdp_info(ev->response);
1109 op->base.remote_media=sal_media_description_new();
1110 sdp_to_media_description(sdp,op->base.remote_media);
1111 sdp_message_free(sdp);
1112 if (op->base.local_media) sdp_process(op);
1114 sal->callbacks.call_ringing(op);
1117 static void call_accepted(Sal *sal, eXosip_event_t *ev){
1119 osip_message_t *msg=NULL;
1120 SalOp *op=find_op(sal,ev);
1121 const char *contact;
1123 if (op==NULL || op->terminated==TRUE) {
1124 ms_warning("This call has been already terminated.");
1126 eXosip_call_terminate(ev->cid,ev->did);
1132 set_remote_ua(op,ev->response);
1134 sdp=eXosip_get_sdp_info(ev->response);
1136 op->base.remote_media=sal_media_description_new();
1137 sdp_to_media_description(sdp,op->base.remote_media);
1138 sdp_message_free(sdp);
1139 if (op->base.local_media) sdp_process(op);
1141 eXosip_call_build_ack(ev->did,&msg);
1143 ms_warning("This call has been already terminated.");
1145 eXosip_call_terminate(ev->cid,ev->did);
1149 contact=sal_op_get_contact(op);
1151 _osip_list_set_empty(&msg->contacts,(void (*)(void*))osip_contact_free);
1152 osip_message_set_contact(msg,contact);
1154 if (op->sdp_answer){
1155 set_sdp(msg,op->sdp_answer);
1156 sdp_message_free(op->sdp_answer);
1157 op->sdp_answer=NULL;
1159 eXosip_call_send_ack(ev->did,msg);
1160 sal->callbacks.call_accepted(op);
1163 static void call_terminated(Sal *sal, eXosip_event_t *ev){
1165 SalOp *op=find_op(sal,ev);
1167 ms_warning("Call terminated for already closed call ?");
1171 osip_from_to_str(ev->request->from,&from);
1173 sal->callbacks.call_terminated(op,from!=NULL ? from : sal_op_get_from(op));
1174 if (from) osip_free(from);
1175 op->terminated=TRUE;
1178 static void call_released(Sal *sal, eXosip_event_t *ev){
1179 SalOp *op=find_op(sal,ev);
1181 ms_warning("No op associated to this call_released()");
1184 if (!op->terminated){
1185 /* no response received so far */
1186 call_failure(sal,ev);
1188 sal->callbacks.call_released(op);
1191 static int get_auth_data_from_response(osip_message_t *resp, const char **realm, const char **username){
1192 const char *prx_realm=NULL,*www_realm=NULL;
1193 osip_proxy_authenticate_t *prx_auth;
1194 osip_www_authenticate_t *www_auth;
1196 *username=osip_uri_get_username(resp->from->url);
1197 prx_auth=(osip_proxy_authenticate_t*)osip_list_get(&resp->proxy_authenticates,0);
1198 www_auth=(osip_proxy_authenticate_t*)osip_list_get(&resp->www_authenticates,0);
1200 prx_realm=osip_proxy_authenticate_get_realm(prx_auth);
1202 www_realm=osip_www_authenticate_get_realm(www_auth);
1206 }else if (www_realm){
1214 static int get_auth_data_from_request(osip_message_t *msg, const char **realm, const char **username){
1215 osip_authorization_t *auth=NULL;
1216 osip_proxy_authorization_t *prx_auth=NULL;
1218 *username=osip_uri_get_username(msg->from->url);
1219 osip_message_get_authorization(msg, 0, &auth);
1221 *realm=osip_authorization_get_realm(auth);
1224 osip_message_get_proxy_authorization(msg,0,&prx_auth);
1226 *realm=osip_proxy_authorization_get_realm(prx_auth);
1232 static int get_auth_data(eXosip_event_t *ev, const char **realm, const char **username){
1233 if (ev->response && get_auth_data_from_response(ev->response,realm,username)==0) return 0;
1234 if (ev->request && get_auth_data_from_request(ev->request,realm,username)==0) return 0;
1238 int sal_op_get_auth_requested(SalOp *op, const char **realm, const char **username){
1239 if (op->pending_auth){
1240 return get_auth_data(op->pending_auth,realm,username);
1245 static bool_t process_authentication(Sal *sal, eXosip_event_t *ev){
1247 const char *username,*realm;
1250 ms_warning("No operation associated with this authentication !");
1253 if (get_auth_data(ev,&realm,&username)==0){
1254 if (op->pending_auth!=NULL){
1255 eXosip_event_free(op->pending_auth);
1256 op->pending_auth=ev;
1258 op->pending_auth=ev;
1259 sal_add_pending_auth(sal,op);
1262 sal->callbacks.auth_requested(op,realm,username);
1268 static void authentication_ok(Sal *sal, eXosip_event_t *ev){
1270 const char *username,*realm;
1273 ms_warning("No operation associated with this authentication_ok!");
1276 if (op->pending_auth){
1277 eXosip_event_free(op->pending_auth);
1278 sal_remove_pending_auth(sal,op);
1279 op->pending_auth=NULL;
1281 if (get_auth_data(ev,&realm,&username)==0){
1282 sal->callbacks.auth_success(op,realm,username);
1286 static bool_t call_failure(Sal *sal, eXosip_event_t *ev){
1289 char* computedReason=NULL;
1290 const char *reason=NULL;
1291 SalError error=SalErrorUnknown;
1292 SalReason sr=SalReasonUnknown;
1295 op=(SalOp*)find_op(sal,ev);
1298 ms_warning("Call failure reported for a closed call, ignored.");
1303 code=osip_message_get_status_code(ev->response);
1304 reason=osip_message_get_reason_phrase(ev->response);
1305 osip_header_t *h=NULL;
1306 if (!osip_message_header_get_byname( ev->response
1310 computedReason = ms_strdup_printf("%s %s",reason,osip_header_get_value(h));
1311 reason = computedReason;
1319 return process_authentication(sal,ev);
1322 error=SalErrorUnknown;
1325 error=SalErrorFailure;
1326 sr=SalReasonNotFound;
1329 error=SalErrorFailure;
1333 eXosip_default_action(ev);
1337 error=SalErrorFailure;
1338 sr=SalReasonTemporarilyUnavailable;
1340 error=SalErrorFailure;
1346 error=SalErrorFailure;
1347 sr=SalReasonDoNotDisturb;
1350 error=SalErrorFailure;
1351 sr=SalReasonDeclined;
1355 error=SalErrorFailure;
1356 sr=SalReasonUnknown;
1357 }else error=SalErrorNoResponse;
1359 op->terminated=TRUE;
1360 sal->callbacks.call_failure(op,error,sr,reason,code);
1361 if (computedReason != NULL){
1362 ms_free(computedReason);
1367 /* Request remote side to send us VFU */
1368 void sal_call_send_vfu_request(SalOp *h){
1369 osip_message_t *msg=NULL;
1371 "<?xml version=\"1.0\" encoding=\"utf-8\" ?>"
1375 " <picture_fast_update></picture_fast_update>"
1383 eXosip_call_build_info(h->did,&msg);
1385 osip_message_set_body(msg,info_body,strlen(info_body));
1386 osip_message_set_content_type(msg,"application/media_control+xml");
1387 snprintf(clen,sizeof(clen),"%lu",(unsigned long)strlen(info_body));
1388 osip_message_set_content_length(msg,clen);
1389 eXosip_call_send_request(h->did,msg);
1390 ms_message("Sending VFU request !");
1395 static void process_media_control_xml(Sal *sal, eXosip_event_t *ev){
1396 SalOp *op=find_op(sal,ev);
1397 osip_body_t *body=NULL;
1400 ms_warning("media control xml received without operation context!");
1404 osip_message_get_body(ev->request,0,&body);
1405 if (body && body->body!=NULL &&
1406 strstr(body->body,"picture_fast_update")){
1407 osip_message_t *ans=NULL;
1408 ms_message("Receiving VFU request !");
1409 if (sal->callbacks.vfu_request){
1410 sal->callbacks.vfu_request(op);
1411 eXosip_call_build_answer(ev->tid,200,&ans);
1413 eXosip_call_send_answer(ev->tid,200,ans);
1417 /*in all other cases we must say it is not implemented.*/
1419 osip_message_t *ans=NULL;
1421 eXosip_call_build_answer(ev->tid,501,&ans);
1423 eXosip_call_send_answer(ev->tid,501,ans);
1428 static void process_dtmf_relay(Sal *sal, eXosip_event_t *ev){
1429 SalOp *op=find_op(sal,ev);
1430 osip_body_t *body=NULL;
1433 ms_warning("media dtmf relay received without operation context!");
1437 osip_message_get_body(ev->request,0,&body);
1438 if (body && body->body!=NULL){
1439 osip_message_t *ans=NULL;
1440 const char *name=strstr(body->body,"Signal");
1441 if (name==NULL) name=strstr(body->body,"signal");
1443 ms_warning("Could not extract the dtmf name from the SIP INFO.");
1446 name+=strlen("signal");
1447 if (sscanf(name," = %1s",tmp)==1){
1448 ms_message("Receiving dtmf %s via SIP INFO.",tmp);
1449 if (sal->callbacks.dtmf_received != NULL)
1450 sal->callbacks.dtmf_received(op, tmp[0]);
1454 eXosip_call_build_answer(ev->tid,200,&ans);
1456 eXosip_call_send_answer(ev->tid,200,ans);
1461 static void fill_options_answer(osip_message_t *options){
1462 osip_message_set_allow(options,"INVITE, ACK, BYE, CANCEL, OPTIONS, MESSAGE, SUBSCRIBE, NOTIFY, INFO");
1463 osip_message_set_accept(options,"application/sdp");
1466 static void process_refer(Sal *sal, SalOp *op, eXosip_event_t *ev){
1467 osip_header_t *h=NULL;
1468 osip_message_t *ans=NULL;
1469 ms_message("Receiving REFER request !");
1470 osip_message_header_get_byname(ev->request,"Refer-To",0,&h);
1473 osip_from_t *from=NULL;
1475 osip_from_init(&from);
1477 if (osip_from_parse(from,h->hvalue)==0){
1479 osip_uri_header_t *uh=NULL;
1480 osip_header_t *referred_by=NULL;
1481 osip_uri_header_get_byname(&from->url->url_headers,(char*)"Replaces",&uh);
1482 if (uh!=NULL && uh->gvalue && uh->gvalue[0]!='\0'){
1483 ms_message("Found replaces in Refer-To");
1485 ms_free(op->replaces);
1487 op->replaces=ms_strdup(uh->gvalue);
1489 osip_message_header_get_byname(ev->request,"Referred-By",0,&referred_by);
1490 if (referred_by && referred_by->hvalue && referred_by->hvalue[0]!='\0'){
1491 if (op->referred_by)
1492 ms_free(op->referred_by);
1493 op->referred_by=ms_strdup(referred_by->hvalue);
1496 osip_uri_header_freelist(&from->url->url_headers);
1497 osip_from_to_str(from,&tmp);
1498 sal->callbacks.refer_received(sal,op,tmp);
1500 osip_from_free(from);
1503 eXosip_call_build_answer(ev->tid,202,&ans);
1505 eXosip_call_send_answer(ev->tid,202,ans);
1510 ms_warning("cannot do anything with the refer without destination\n");
1514 static void call_message_new(Sal *sal, eXosip_event_t *ev){
1515 osip_message_t *ans=NULL;
1517 if (MSG_IS_INFO(ev->request)){
1518 osip_content_type_t *ct;
1519 ct=osip_message_get_content_type(ev->request);
1520 if (ct && ct->subtype){
1521 if (strcmp(ct->subtype,"media_control+xml")==0)
1522 process_media_control_xml(sal,ev);
1523 else if (strcmp(ct->subtype,"dtmf-relay")==0)
1524 process_dtmf_relay(sal,ev);
1526 ms_message("Unhandled SIP INFO.");
1527 /*send an "Not implemented" answer*/
1529 eXosip_call_build_answer(ev->tid,501,&ans);
1531 eXosip_call_send_answer(ev->tid,501,ans);
1535 /*empty SIP INFO, probably to test we are alive. Send an empty answer*/
1537 eXosip_call_build_answer(ev->tid,200,&ans);
1539 eXosip_call_send_answer(ev->tid,200,ans);
1542 }else if(MSG_IS_MESSAGE(ev->request)){
1543 /* SIP messages could be received into call */
1544 text_received(sal, ev);
1546 eXosip_call_build_answer(ev->tid,200,&ans);
1548 eXosip_call_send_answer(ev->tid,200,ans);
1550 }else if(MSG_IS_REFER(ev->request)){
1551 SalOp *op=find_op(sal,ev);
1553 ms_message("Receiving REFER request !");
1554 process_refer(sal,op,ev);
1555 }else if(MSG_IS_NOTIFY(ev->request)){
1556 osip_header_t *h=NULL;
1558 SalOp *op=find_op(sal,ev);
1560 ms_message("Receiving NOTIFY request !");
1561 osip_from_to_str(ev->request->from,&from);
1562 osip_message_header_get_byname(ev->request,"Event",0,&h);
1564 sal->callbacks.notify(op,from,h->hvalue);
1565 /*answer that we received the notify*/
1567 eXosip_call_build_answer(ev->tid,200,&ans);
1569 eXosip_call_send_answer(ev->tid,200,ans);
1572 }else if (MSG_IS_OPTIONS(ev->request)){
1574 eXosip_call_build_answer(ev->tid,200,&ans);
1576 fill_options_answer(ans);
1577 eXosip_call_send_answer(ev->tid,200,ans);
1581 }else ms_warning("call_message_new: No request ?");
1584 static void inc_update(Sal *sal, eXosip_event_t *ev){
1585 osip_message_t *msg=NULL;
1586 ms_message("Processing incoming UPDATE");
1588 eXosip_message_build_answer(ev->tid,200,&msg);
1590 eXosip_message_send_answer(ev->tid,200,msg);
1594 static bool_t comes_from_local_if(osip_message_t *msg){
1595 osip_via_t *via=NULL;
1596 osip_message_get_via(msg,0,&via);
1599 host=osip_via_get_host(via);
1600 if (strcmp(host,"127.0.0.1")==0 || strcmp(host,"::1")==0){
1601 osip_generic_param_t *param=NULL;
1602 osip_via_param_get_byname(via,"received",¶m);
1603 if (param==NULL) return TRUE;
1604 if (param->gvalue &&
1605 (strcmp(param->gvalue,"127.0.0.1")==0 || strcmp(param->gvalue,"::1")==0)){
1613 static void text_received(Sal *sal, eXosip_event_t *ev){
1614 osip_body_t *body=NULL;
1615 char *from=NULL,*msg;
1617 osip_message_get_body(ev->request,0,&body);
1619 ms_error("Could not get text message from SIP body");
1623 osip_from_to_str(ev->request->from,&from);
1624 sal->callbacks.text_received(sal,from,msg);
1630 static void other_request(Sal *sal, eXosip_event_t *ev){
1631 ms_message("in other_request");
1632 if (ev->request==NULL) return;
1633 if (strcmp(ev->request->sip_method,"MESSAGE")==0){
1634 text_received(sal,ev);
1635 eXosip_message_send_answer(ev->tid,200,NULL);
1636 }else if (strcmp(ev->request->sip_method,"OPTIONS")==0){
1637 osip_message_t *options=NULL;
1638 eXosip_options_build_answer(ev->tid,200,&options);
1639 fill_options_answer(options);
1640 eXosip_options_send_answer(ev->tid,200,options);
1641 }else if (strncmp(ev->request->sip_method, "REFER", 5) == 0){
1642 ms_message("Receiving REFER request !");
1643 if (comes_from_local_if(ev->request)) {
1644 process_refer(sal,NULL,ev);
1645 }else ms_warning("Ignored REFER not coming from this local loopback interface.");
1646 }else if (strncmp(ev->request->sip_method, "UPDATE", 6) == 0){
1651 osip_message_to_str(ev->request,&tmp,&msglen);
1653 ms_message("Unsupported request received:\n%s",tmp);
1656 /*answer with a 501 Not implemented*/
1657 eXosip_message_send_answer(ev->tid,501,NULL);
1661 static void masquerade_via(osip_message_t *msg, const char *ip, const char *port){
1662 osip_via_t *via=NULL;
1663 osip_message_get_via(msg,0,&via);
1665 osip_free(via->port);
1666 via->port=osip_strdup(port);
1667 osip_free(via->host);
1668 via->host=osip_strdup(ip);
1673 static bool_t fix_message_contact(SalOp *op, osip_message_t *request,osip_message_t *last_answer) {
1674 osip_contact_t *ctt=NULL;
1675 const char *received;
1677 SalTransport transport;
1680 if (extract_received_rport(last_answer,&received,&rport,&transport)==-1) return FALSE;
1681 osip_message_get_contact(request,0,&ctt);
1683 ms_warning("fix_message_contact(): no contact to update");
1686 if (ctt->url->host!=NULL){
1687 osip_free(ctt->url->host);
1689 ctt->url->host=osip_strdup(received);
1690 if (ctt->url->port!=NULL){
1691 osip_free(ctt->url->port);
1693 snprintf(port,sizeof(port),"%i",rport);
1694 ctt->url->port=osip_strdup(port);
1695 if (op->masquerade_via) masquerade_via(request,received,port);
1697 if (transport != SalTransportUDP) {
1698 sal_address_set_param((SalAddress *)ctt, "transport", sal_transport_to_string(transport));
1703 static bool_t register_again_with_updated_contact(SalOp *op, osip_message_t *orig_request, osip_message_t *last_answer){
1704 osip_contact_t *ctt=NULL;
1705 SalAddress* ori_contact_address=NULL;
1706 const char *received;
1708 SalTransport transport;
1710 osip_message_t *msg=NULL;
1711 Sal* sal=op->base.root;
1713 if (sal->double_reg==FALSE ) return FALSE;
1715 if (extract_received_rport(last_answer,&received,&rport,&transport)==-1) return FALSE;
1716 osip_message_get_contact(orig_request,0,&ctt);
1717 osip_contact_to_str(ctt,&tmp);
1718 ori_contact_address = sal_address_new(tmp);
1720 /*check if contact is up to date*/
1721 if (strcmp(sal_address_get_domain(ori_contact_address),received) ==0
1722 && sal_address_get_port_int(ori_contact_address) == rport
1723 && sal_address_get_transport(ori_contact_address) == transport) {
1724 ms_message("Register has up to date contact, doing nothing.");
1726 sal_address_destroy(ori_contact_address);
1728 } else ms_message("contact do not match, need to update the register (%s with %s:%i;transport=%s)"
1732 ,sal_transport_to_string(transport));
1734 sal_address_destroy(ori_contact_address);
1736 if (transport == SalTransportUDP) {
1738 eXosip_register_build_register(op->rid,op->expires,&msg);
1741 ms_warning("Fail to create a contact updated register.");
1744 if (fix_message_contact(op,msg,last_answer)) {
1745 eXosip_register_send_register(op->rid,msg);
1747 ms_message("Resending new register with updated contact");
1750 ms_warning("Fail to send updated register.");
1757 update_contact_from_response(op,last_answer);
1761 static void registration_success(Sal *sal, eXosip_event_t *ev){
1762 SalOp *op=sal_find_register(sal,ev->rid);
1763 osip_header_t *h=NULL;
1766 ms_error("Receiving register response for unknown operation");
1769 osip_message_get_expires(ev->request,0,&h);
1770 if (h!=NULL && atoi(h->hvalue)!=0){
1772 if (!register_again_with_updated_contact(op,ev->request,ev->response)){
1773 sal->callbacks.register_success(op,registered);
1776 sal->callbacks.register_success(op,FALSE);
1780 static bool_t registration_failure(Sal *sal, eXosip_event_t *ev){
1782 const char *reason=NULL;
1783 SalOp *op=sal_find_register(sal,ev->rid);
1784 SalReason sr=SalReasonUnknown;
1785 SalError se=SalErrorUnknown;
1788 ms_error("Receiving register failure for unknown operation");
1792 status_code=osip_message_get_status_code(ev->response);
1793 reason=osip_message_get_reason_phrase(ev->response);
1795 switch(status_code){
1798 return process_authentication(sal,ev);
1800 case 423: /*interval too brief*/
1801 {/*retry with greater interval */
1802 osip_header_t *h=NULL;
1803 osip_message_t *msg=NULL;
1804 osip_message_header_get_byname(ev->response,"min-expires",0,&h);
1805 if (h && h->hvalue && h->hvalue[0]!='\0'){
1806 int val=atoi(h->hvalue);
1807 if (val>op->expires)
1809 }else op->expires*=2;
1811 eXosip_register_build_register(op->rid,op->expires,&msg);
1812 eXosip_register_send_register(op->rid,msg);
1816 case 606: /*Not acceptable, workaround for proxies that don't like private addresses
1817 in vias, such as ekiga.net
1818 On the opposite, freephonie.net bugs when via are masqueraded.
1820 op->masquerade_via=TRUE;
1822 /* if contact is up to date, process the failure, otherwise resend a new register with
1823 updated contact first, just in case the faillure is due to incorrect contact */
1824 if (ev->response && register_again_with_updated_contact(op,ev->request,ev->response))
1825 return TRUE; /*we are retrying with an updated contact*/
1826 if (status_code==403){
1828 sr=SalReasonForbidden;
1829 }else if (status_code==0){
1830 se=SalErrorNoResponse;
1832 sal->callbacks.register_failure(op,se,sr,reason);
1837 static void other_request_reply(Sal *sal,eXosip_event_t *ev){
1838 SalOp *op=find_op(sal,ev);
1841 ms_warning("other_request_reply(): Receiving response to unknown request.");
1845 update_contact_from_response(op,ev->response);
1846 if (ev->request && strcmp(osip_message_get_method(ev->request),"OPTIONS")==0)
1847 sal->callbacks.ping_reply(op);
1851 static bool_t process_event(Sal *sal, eXosip_event_t *ev){
1852 ms_message("linphone process event get a message %d\n",ev->type);
1854 case EXOSIP_CALL_ANSWERED:
1855 ms_message("CALL_ANSWERED\n");
1856 call_accepted(sal,ev);
1857 authentication_ok(sal,ev);
1859 case EXOSIP_CALL_CLOSED:
1860 case EXOSIP_CALL_CANCELLED:
1861 ms_message("CALL_CLOSED or CANCELLED\n");
1862 call_terminated(sal,ev);
1864 case EXOSIP_CALL_TIMEOUT:
1865 case EXOSIP_CALL_NOANSWER:
1866 ms_message("CALL_TIMEOUT or NOANSWER\n");
1867 return call_failure(sal,ev);
1869 case EXOSIP_CALL_REQUESTFAILURE:
1870 case EXOSIP_CALL_GLOBALFAILURE:
1871 case EXOSIP_CALL_SERVERFAILURE:
1872 ms_message("CALL_REQUESTFAILURE or GLOBALFAILURE or SERVERFAILURE\n");
1873 return call_failure(sal,ev);
1875 case EXOSIP_CALL_RELEASED:
1876 ms_message("CALL_RELEASED\n");
1877 call_released(sal, ev);
1879 case EXOSIP_CALL_INVITE:
1880 ms_message("CALL_NEW\n");
1881 inc_new_call(sal,ev);
1883 case EXOSIP_CALL_REINVITE:
1884 handle_reinvite(sal,ev);
1886 case EXOSIP_CALL_ACK:
1887 ms_message("CALL_ACK");
1890 case EXOSIP_CALL_REDIRECTED:
1891 ms_message("CALL_REDIRECTED");
1892 eXosip_default_action(ev);
1894 case EXOSIP_CALL_PROCEEDING:
1895 ms_message("CALL_PROCEEDING");
1896 call_proceeding(sal,ev);
1898 case EXOSIP_CALL_RINGING:
1899 ms_message("CALL_RINGING");
1900 call_ringing(sal,ev);
1902 case EXOSIP_CALL_MESSAGE_NEW:
1903 ms_message("EXOSIP_CALL_MESSAGE_NEW");
1904 call_message_new(sal,ev);
1906 case EXOSIP_CALL_MESSAGE_REQUESTFAILURE:
1908 (ev->response->status_code==407 || ev->response->status_code==401)){
1909 return process_authentication(sal,ev);
1912 case EXOSIP_IN_SUBSCRIPTION_NEW:
1913 ms_message("CALL_IN_SUBSCRIPTION_NEW ");
1914 sal_exosip_subscription_recv(sal,ev);
1916 case EXOSIP_IN_SUBSCRIPTION_RELEASED:
1917 ms_message("CALL_SUBSCRIPTION_NEW ");
1918 sal_exosip_in_subscription_closed(sal,ev);
1920 case EXOSIP_SUBSCRIPTION_UPDATE:
1921 ms_message("CALL_SUBSCRIPTION_UPDATE");
1923 case EXOSIP_SUBSCRIPTION_NOTIFY:
1924 ms_message("CALL_SUBSCRIPTION_NOTIFY");
1925 sal_exosip_notify_recv(sal,ev);
1927 case EXOSIP_SUBSCRIPTION_ANSWERED:
1928 ms_message("EXOSIP_SUBSCRIPTION_ANSWERED, ev->sid=%i, ev->did=%i\n",ev->sid,ev->did);
1929 sal_exosip_subscription_answered(sal,ev);
1931 case EXOSIP_SUBSCRIPTION_CLOSED:
1932 ms_message("EXOSIP_SUBSCRIPTION_CLOSED\n");
1933 sal_exosip_subscription_closed(sal,ev);
1935 case EXOSIP_SUBSCRIPTION_REQUESTFAILURE: /**< announce a request failure */
1936 if (ev->response && (ev->response->status_code == 407 || ev->response->status_code == 401)){
1937 return process_authentication(sal,ev);
1939 case EXOSIP_SUBSCRIPTION_SERVERFAILURE:
1940 case EXOSIP_SUBSCRIPTION_GLOBALFAILURE:
1941 sal_exosip_subscription_closed(sal,ev);
1943 case EXOSIP_REGISTRATION_FAILURE:
1944 ms_message("REGISTRATION_FAILURE\n");
1945 return registration_failure(sal,ev);
1947 case EXOSIP_REGISTRATION_SUCCESS:
1948 authentication_ok(sal,ev);
1949 registration_success(sal,ev);
1951 case EXOSIP_MESSAGE_NEW:
1952 other_request(sal,ev);
1954 case EXOSIP_MESSAGE_PROCEEDING:
1955 case EXOSIP_MESSAGE_ANSWERED:
1956 case EXOSIP_MESSAGE_REDIRECTED:
1957 case EXOSIP_MESSAGE_SERVERFAILURE:
1958 case EXOSIP_MESSAGE_GLOBALFAILURE:
1959 other_request_reply(sal,ev);
1961 case EXOSIP_MESSAGE_REQUESTFAILURE:
1962 case EXOSIP_NOTIFICATION_REQUESTFAILURE:
1964 switch (ev->response->status_code) {
1967 return process_authentication(sal,ev);
1969 eXosip_automatic_action ();
1974 other_request_reply(sal,ev);
1977 ms_message("Unhandled exosip event ! %i",ev->type);
1983 int sal_iterate(Sal *sal){
1985 while((ev=eXosip_event_wait(0,0))!=NULL){
1986 if (process_event(sal,ev))
1987 eXosip_event_free(ev);
1990 eXosip_automatic_refresh();
1995 static void register_set_contact(osip_message_t *msg, const char *contact){
1996 osip_uri_param_t *param = NULL;
1997 osip_contact_t *ct=NULL;
1999 /*we get the line parameter choosed by exosip, and add it to our own contact*/
2000 osip_message_get_contact(msg,0,&ct);
2002 osip_uri_uparam_get_byname(ct->url, "line", ¶m);
2003 if (param && param->gvalue)
2004 line=osip_strdup(param->gvalue);
2006 _osip_list_set_empty(&msg->contacts,(void (*)(void*))osip_contact_free);
2007 osip_message_set_contact(msg,contact);
2008 osip_message_get_contact(msg,0,&ct);
2009 osip_uri_uparam_add(ct->url,osip_strdup("line"),line);
2012 static void sal_register_add_route(osip_message_t *msg, const char *proxy){
2014 snprintf(tmp,sizeof(tmp)-1,"<%s;lr>",proxy);
2015 osip_message_set_route(msg,tmp);
2018 int sal_register(SalOp *h, const char *proxy, const char *from, int expires){
2019 osip_message_t *msg;
2020 const char *contact=sal_op_get_contact(h);
2022 sal_op_set_route(h,proxy);
2024 SalAddress *from_parsed=sal_address_new(from);
2026 if (from_parsed==NULL) {
2027 ms_warning("sal_register() bad from %s",from);
2030 snprintf(domain,sizeof(domain),"sip:%s",sal_address_get_domain(from_parsed));
2031 sal_address_destroy(from_parsed);
2033 h->rid=eXosip_register_build_initial_register(from,domain,NULL,expires,&msg);
2035 if (contact) register_set_contact(msg,contact);
2036 sal_register_add_route(msg,proxy);
2037 sal_add_register(h->base.root,h);
2039 ms_error("Could not build initial register.");
2045 eXosip_register_build_register(h->rid,expires,&msg);
2046 sal_register_add_route(msg,proxy);
2048 eXosip_register_send_register(h->rid,msg);
2054 int sal_register_refresh(SalOp *op, int expires){
2055 osip_message_t *msg=NULL;
2056 const char *contact=sal_op_get_contact(op);
2059 ms_error("Unexistant registration context, not possible to refresh.");
2063 eXosip_register_build_register(op->rid,expires,&msg);
2065 if (contact) register_set_contact(msg,contact);
2066 sal_register_add_route(msg,sal_op_get_route(op));
2067 eXosip_register_send_register(op->rid,msg);
2068 }else ms_error("Could not build REGISTER refresh message.");
2074 int sal_unregister(SalOp *h){
2075 osip_message_t *msg=NULL;
2077 eXosip_register_build_register(h->rid,0,&msg);
2078 if (msg) eXosip_register_send_register(h->rid,msg);
2079 else ms_warning("Could not build unREGISTER !");
2084 SalAddress * sal_address_new(const char *uri){
2086 osip_from_init(&from);
2088 // Remove front spaces
2089 while (uri[0]==' ') {
2093 if (osip_from_parse(from,uri)!=0){
2094 osip_from_free(from);
2097 if (from->displayname!=NULL && from->displayname[0]=='"'){
2098 char *unquoted=osip_strdup_without_quote(from->displayname);
2099 osip_free(from->displayname);
2100 from->displayname=unquoted;
2102 return (SalAddress*)from;
2105 SalAddress * sal_address_clone(const SalAddress *addr){
2106 osip_from_t *ret=NULL;
2107 osip_from_clone((osip_from_t*)addr,&ret);
2108 return (SalAddress*)ret;
2111 #define null_if_empty(s) (((s)!=NULL && (s)[0]!='\0') ? (s) : NULL )
2113 const char *sal_address_get_scheme(const SalAddress *addr){
2114 const osip_from_t *u=(const osip_from_t*)addr;
2115 return null_if_empty(u->url->scheme);
2118 const char *sal_address_get_display_name(const SalAddress* addr){
2119 const osip_from_t *u=(const osip_from_t*)addr;
2120 return null_if_empty(u->displayname);
2123 const char *sal_address_get_username(const SalAddress *addr){
2124 const osip_from_t *u=(const osip_from_t*)addr;
2125 return null_if_empty(u->url->username);
2128 const char *sal_address_get_domain(const SalAddress *addr){
2129 const osip_from_t *u=(const osip_from_t*)addr;
2130 return null_if_empty(u->url->host);
2133 void sal_address_set_display_name(SalAddress *addr, const char *display_name){
2134 osip_from_t *u=(osip_from_t*)addr;
2135 if (u->displayname!=NULL){
2136 osip_free(u->displayname);
2137 u->displayname=NULL;
2139 if (display_name!=NULL && display_name[0]!='\0'){
2140 u->displayname=osip_strdup(display_name);
2144 void sal_address_set_username(SalAddress *addr, const char *username){
2145 osip_from_t *uri=(osip_from_t*)addr;
2146 if (uri->url->username!=NULL){
2147 osip_free(uri->url->username);
2148 uri->url->username=NULL;
2151 uri->url->username=osip_strdup(username);
2154 void sal_address_set_domain(SalAddress *addr, const char *host){
2155 osip_from_t *uri=(osip_from_t*)addr;
2156 if (uri->url->host!=NULL){
2157 osip_free(uri->url->host);
2158 uri->url->host=NULL;
2161 uri->url->host=osip_strdup(host);
2164 void sal_address_set_port(SalAddress *addr, const char *port){
2165 osip_from_t *uri=(osip_from_t*)addr;
2166 if (uri->url->port!=NULL){
2167 osip_free(uri->url->port);
2168 uri->url->port=NULL;
2171 uri->url->port=osip_strdup(port);
2174 void sal_address_set_port_int(SalAddress *uri, int port){
2177 /*this is the default, special case to leave the port field blank*/
2178 sal_address_set_port(uri,NULL);
2181 snprintf(tmp,sizeof(tmp),"%i",port);
2182 sal_address_set_port(uri,tmp);
2185 void sal_address_clean(SalAddress *addr){
2186 osip_generic_param_freelist(& ((osip_from_t*)addr)->gen_params);
2187 osip_uri_param_freelist(& ((osip_from_t*)addr)->url->url_params);
2190 char *sal_address_as_string(const SalAddress *u){
2192 osip_from_t *from=(osip_from_t *)u;
2193 char *old_displayname=NULL;
2194 /* hack to force use of quotes around the displayname*/
2195 if (from->displayname!=NULL
2196 && from->displayname[0]!='"'){
2197 old_displayname=from->displayname;
2198 from->displayname=osip_enquote(from->displayname);
2200 osip_from_to_str(from,&tmp);
2201 if (old_displayname!=NULL){
2202 ms_free(from->displayname);
2203 from->displayname=old_displayname;
2210 char *sal_address_as_string_uri_only(const SalAddress *u){
2211 char *tmp=NULL,*ret;
2212 osip_uri_to_str(((osip_from_t*)u)->url,&tmp);
2217 void sal_address_set_param(SalAddress *u,const char* name,const char* value) {
2218 osip_uri_param_t *param=NULL;
2219 osip_uri_uparam_get_byname(((osip_from_t*)u)->url,(char*)name,¶m);
2221 osip_uri_uparam_add (((osip_from_t*)u)->url,ms_strdup(name),ms_strdup(value));
2223 osip_free(param->gvalue);
2224 param->gvalue=osip_strdup(value);
2229 void sal_address_destroy(SalAddress *u){
2230 osip_from_free((osip_from_t*)u);
2233 void sal_set_keepalive_period(Sal *ctx,unsigned int value) {
2234 ctx->keepalive_period=value;
2235 eXosip_set_option (EXOSIP_OPT_UDP_KEEP_ALIVE, &value);
2237 unsigned int sal_get_keepalive_period(Sal *ctx) {
2238 return ctx->keepalive_period;
2241 const char * sal_address_get_port(const SalAddress *addr) {
2242 const osip_from_t *u=(const osip_from_t*)addr;
2243 return null_if_empty(u->url->port);
2246 int sal_address_get_port_int(const SalAddress *uri) {
2247 const char* port = sal_address_get_port(uri);
2254 SalTransport sal_address_get_transport(const SalAddress* addr) {
2255 const osip_from_t *u=(const osip_from_t*)addr;
2256 osip_uri_param_t *transport_param=NULL;
2257 osip_uri_uparam_get_byname(u->url,"transport",&transport_param);
2258 if (transport_param == NULL){
2259 return SalTransportUDP;
2261 return sal_transport_parse(transport_param->gvalue);
2264 void sal_address_set_transport(SalAddress* addr,SalTransport transport) {
2265 sal_address_set_param(addr, "transport", sal_transport_to_string(transport));
2268 /* sends a reinvite. Local media description may have changed by application since call establishment*/
2269 int sal_call_update(SalOp *h, const char *subject){
2271 osip_message_t *reinvite=NULL;
2274 if(eXosip_call_build_request(h->did,"INVITE",&reinvite) != 0 || reinvite==NULL){
2279 osip_message_set_subject(reinvite,subject);
2280 osip_message_set_allow(reinvite, "INVITE, ACK, CANCEL, OPTIONS, BYE, REFER, NOTIFY, MESSAGE, SUBSCRIBE, INFO");
2281 if (h->base.root->session_expires!=0){
2282 osip_message_set_header(reinvite, "Session-expires", "200");
2283 osip_message_set_supported(reinvite, "timer");
2285 if (h->base.local_media){
2286 h->sdp_offering=TRUE;
2287 set_sdp_from_desc(reinvite,h->base.local_media);
2288 }else h->sdp_offering=FALSE;
2290 err = eXosip_call_send_request(h->did, reinvite);
2294 void sal_reuse_authorization(Sal *ctx, bool_t value) {
2295 ctx->reuse_authorization=value;