3 Copyright (C) 2010 Simon MORLAT (simon.morlat@free.fr)
5 This program is free software; you can redistribute it and/or
6 modify it under the terms of the GNU General Public License
7 as published by the Free Software Foundation; either version 2
8 of the License, or (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
23 #include "sal_eXosip2.h"
25 #include "offeranswer.h"
28 // Necessary to make it linked
29 static void for_linker() { eXosip_transport_hook_register(NULL); }
31 static bool_t call_failure(Sal *sal, eXosip_event_t *ev);
33 static void text_received(Sal *sal, eXosip_event_t *ev);
35 static void masquerade_via(osip_message_t *msg, const char *ip, const char *port);
36 static bool_t fix_message_contact(SalOp *op, osip_message_t *request,osip_message_t *last_answer);
37 static void update_contact_from_response(SalOp *op, osip_message_t *response);
39 void _osip_list_set_empty(osip_list_t *l, void (*freefunc)(void*)){
41 while(!osip_list_eol(l,0)) {
42 data=osip_list_get(l,0);
43 osip_list_remove(l,0);
44 if (data) freefunc(data);
48 void sal_get_default_local_ip(Sal *sal, int address_family,char *ip, size_t iplen){
49 if (eXosip_guess_localip(address_family,ip,iplen)<0){
50 /*default to something */
51 strncpy(ip,address_family==AF_INET6 ? "::1" : "127.0.0.1",iplen);
52 ms_error("Could not find default routable ip address !");
57 static SalOp * sal_find_call(Sal *sal, int cid){
60 for(elem=sal->calls;elem!=NULL;elem=elem->next){
61 op=(SalOp*)elem->data;
62 if (op->cid==cid) return op;
67 static void sal_add_call(Sal *sal, SalOp *op){
68 sal->calls=ms_list_append(sal->calls,op);
71 static void sal_remove_call(Sal *sal, SalOp *op){
72 sal->calls=ms_list_remove(sal->calls, op);
75 static SalOp * sal_find_register(Sal *sal, int rid){
78 for(elem=sal->registers;elem!=NULL;elem=elem->next){
79 op=(SalOp*)elem->data;
80 if (op->rid==rid) return op;
85 static void sal_add_register(Sal *sal, SalOp *op){
86 sal->registers=ms_list_append(sal->registers,op);
89 static void sal_remove_register(Sal *sal, int rid){
92 for(elem=sal->registers;elem!=NULL;elem=elem->next){
93 op=(SalOp*)elem->data;
95 sal->registers=ms_list_remove_link(sal->registers,elem);
101 static SalOp * sal_find_other(Sal *sal, osip_message_t *response){
104 osip_call_id_t *callid=osip_message_get_call_id(response);
106 ms_error("There is no call-id in this response !");
109 for(elem=sal->other_transactions;elem!=NULL;elem=elem->next){
110 op=(SalOp*)elem->data;
111 if (osip_call_id_match(callid,op->call_id)==0) return op;
116 void sal_add_other(Sal *sal, SalOp *op, osip_message_t *request){
117 osip_call_id_t *callid=osip_message_get_call_id(request);
119 ms_error("There is no call id in the request !");
122 osip_call_id_clone(callid,&op->call_id);
123 sal->other_transactions=ms_list_append(sal->other_transactions,op);
126 static void sal_remove_other(Sal *sal, SalOp *op){
127 sal->other_transactions=ms_list_remove(sal->other_transactions,op);
131 static void sal_add_pending_auth(Sal *sal, SalOp *op){
132 sal->pending_auths=ms_list_append(sal->pending_auths,op);
136 static void sal_remove_pending_auth(Sal *sal, SalOp *op){
137 sal->pending_auths=ms_list_remove(sal->pending_auths,op);
140 void sal_exosip_fix_route(SalOp *op){
141 if (sal_op_get_route(op)!=NULL){
142 osip_route_t *rt=NULL;
143 osip_uri_param_t *lr_param=NULL;
145 osip_route_init(&rt);
146 if (osip_route_parse(rt,sal_op_get_route(op))<0){
147 ms_warning("Bad route %s!",sal_op_get_route(op));
148 sal_op_set_route(op,NULL);
150 /* check if the lr parameter is set , if not add it */
151 osip_uri_uparam_get_byname(rt->url, "lr", &lr_param);
154 osip_uri_uparam_add(rt->url,osip_strdup("lr"),NULL);
155 osip_route_to_str(rt,&tmproute);
156 sal_op_set_route(op,tmproute);
164 SalOp * sal_op_new(Sal *sal){
165 SalOp *op=ms_new(SalOp,1);
166 __sal_op_init(op,sal);
167 op->cid=op->did=op->tid=op->rid=op->nid=op->sid=-1;
169 op->supports_session_timers=FALSE;
170 op->sdp_offering=TRUE;
171 op->pending_auth=NULL;
176 op->referred_by=NULL;
177 op->masquerade_via=FALSE;
178 op->auto_answer_asked=FALSE;
180 op->terminated=FALSE;
184 bool_t sal_call_autoanswer_asked(SalOp *op)
186 return op->auto_answer_asked;
189 void sal_op_release(SalOp *op){
191 sdp_message_free(op->sdp_answer);
192 if (op->pending_auth)
193 eXosip_event_free(op->pending_auth);
195 sal_remove_register(op->base.root,op->rid);
196 eXosip_register_remove(op->rid);
199 ms_message("Cleaning cid %i",op->cid);
200 sal_remove_call(op->base.root,op);
203 sal_remove_out_subscribe(op->base.root,op);
206 sal_remove_in_subscribe(op->base.root,op);
208 osip_call_id_free(op->call_id);
211 if (op->pending_auth){
212 sal_remove_pending_auth(op->base.root,op);
215 sal_media_description_unref(op->result);
217 sal_remove_other(op->base.root,op);
218 osip_call_id_free(op->call_id);
221 ms_free(op->replaces);
223 if (op->referred_by){
224 ms_free(op->referred_by);
227 sal_auth_info_delete(op->auth_info);
232 static void _osip_trace_func(char *fi, int li, osip_trace_level_t level, char *chfr, va_list ap){
233 int ortp_level=ORTP_DEBUG;
239 ortp_level=ORTP_MESSAGE;
242 ortp_level=ORTP_WARNING;
246 ortp_level=ORTP_ERROR;
249 ortp_level=ORTP_FATAL;
251 case END_TRACE_LEVEL:
254 if (ortp_log_level_enabled(level)){
255 int len=strlen(chfr);
256 char *chfrdup=ortp_strdup(chfr);
257 /*need to remove endline*/
259 if (chfrdup[len-1]=='\n')
261 if (chfrdup[len-2]=='\r')
264 ortp_logv(ortp_level,chfrdup,ap);
271 static bool_t firsttime=TRUE;
274 osip_trace_initialize_func (OSIP_INFO4,&_osip_trace_func);
279 sal->keepalive_period=30;
280 sal->double_reg=TRUE;
281 sal->use_rports=TRUE;
283 sal->reuse_authorization=FALSE;
288 void sal_uninit(Sal* sal){
291 ms_free(sal->rootCa);
295 void sal_set_user_pointer(Sal *sal, void *user_data){
299 void *sal_get_user_pointer(const Sal *sal){
303 static void unimplemented_stub(){
304 ms_warning("Unimplemented SAL callback");
307 void sal_set_callbacks(Sal *ctx, const SalCallbacks *cbs){
308 memcpy(&ctx->callbacks,cbs,sizeof(*cbs));
309 if (ctx->callbacks.call_received==NULL)
310 ctx->callbacks.call_received=(SalOnCallReceived)unimplemented_stub;
311 if (ctx->callbacks.call_ringing==NULL)
312 ctx->callbacks.call_ringing=(SalOnCallRinging)unimplemented_stub;
313 if (ctx->callbacks.call_accepted==NULL)
314 ctx->callbacks.call_accepted=(SalOnCallAccepted)unimplemented_stub;
315 if (ctx->callbacks.call_failure==NULL)
316 ctx->callbacks.call_failure=(SalOnCallFailure)unimplemented_stub;
317 if (ctx->callbacks.call_terminated==NULL)
318 ctx->callbacks.call_terminated=(SalOnCallTerminated)unimplemented_stub;
319 if (ctx->callbacks.call_released==NULL)
320 ctx->callbacks.call_released=(SalOnCallReleased)unimplemented_stub;
321 if (ctx->callbacks.call_updating==NULL)
322 ctx->callbacks.call_updating=(SalOnCallUpdating)unimplemented_stub;
323 if (ctx->callbacks.auth_requested==NULL)
324 ctx->callbacks.auth_requested=(SalOnAuthRequested)unimplemented_stub;
325 if (ctx->callbacks.auth_success==NULL)
326 ctx->callbacks.auth_success=(SalOnAuthSuccess)unimplemented_stub;
327 if (ctx->callbacks.register_success==NULL)
328 ctx->callbacks.register_success=(SalOnRegisterSuccess)unimplemented_stub;
329 if (ctx->callbacks.register_failure==NULL)
330 ctx->callbacks.register_failure=(SalOnRegisterFailure)unimplemented_stub;
331 if (ctx->callbacks.dtmf_received==NULL)
332 ctx->callbacks.dtmf_received=(SalOnDtmfReceived)unimplemented_stub;
333 if (ctx->callbacks.notify==NULL)
334 ctx->callbacks.notify=(SalOnNotify)unimplemented_stub;
335 if (ctx->callbacks.notify_presence==NULL)
336 ctx->callbacks.notify_presence=(SalOnNotifyPresence)unimplemented_stub;
337 if (ctx->callbacks.subscribe_received==NULL)
338 ctx->callbacks.subscribe_received=(SalOnSubscribeReceived)unimplemented_stub;
339 if (ctx->callbacks.text_received==NULL)
340 ctx->callbacks.text_received=(SalOnTextReceived)unimplemented_stub;
341 if (ctx->callbacks.ping_reply==NULL)
342 ctx->callbacks.ping_reply=(SalOnPingReply)unimplemented_stub;
345 int sal_unlisten_ports(Sal *ctx){
354 int sal_listen_port(Sal *ctx, const char *addr, int port, SalTransport tr, int is_secure){
357 int proto=IPPROTO_UDP;
358 int keepalive = ctx->keepalive_period;
361 case SalTransportUDP:
363 eXosip_set_option (EXOSIP_OPT_UDP_KEEP_ALIVE, &keepalive);
365 case SalTransportTCP:
366 case SalTransportTLS:
369 eXosip_set_option (EXOSIP_OPT_UDP_KEEP_ALIVE,&keepalive);
372 eXosip_tls_ctx_t tlsCtx;
373 memset(&tlsCtx, 0, sizeof(tlsCtx));
374 snprintf(tlsCtx.root_ca_cert, sizeof(tlsCtx.client.cert), "%s", ctx->rootCa);
375 eXosip_set_tls_ctx(&tlsCtx);
379 ms_warning("unexpected proto, using datagram");
383 eXosip_set_option(13,&err); /*13=EXOSIP_OPT_SRV_WITH_NAPTR, as it is an enum value, we can't use it unless we are sure of the
384 version of eXosip, which is not the case*/
385 /*see if it looks like an IPv6 address*/
386 int use_rports = ctx->use_rports; // Copy char to int to avoid bad alignment
387 eXosip_set_option(EXOSIP_OPT_USE_RPORT,&use_rports);
388 int dont_use_101 = !ctx->use_101; // Copy char to int to avoid bad alignment
389 eXosip_set_option(EXOSIP_OPT_DONT_SEND_101,&dont_use_101);
391 ipv6=strchr(addr,':')!=NULL;
392 eXosip_enable_ipv6(ipv6);
394 if (is_secure && tr == SalTransportUDP){
395 ms_fatal("SIP over DTLS is not supported yet.");
398 err=eXosip_listen_addr(proto, addr, port, ipv6 ? PF_INET6 : PF_INET, is_secure);
399 #ifdef HAVE_EXOSIP_GET_SOCKET
400 ms_message("Exosip has socket number %i",eXosip_get_socket(proto));
407 ortp_socket_t sal_get_socket(Sal *ctx){
408 #ifdef HAVE_EXOSIP_GET_SOCKET
409 return eXosip_get_socket(IPPROTO_UDP);
411 ms_warning("Sorry, eXosip does not have eXosip_get_socket() method");
416 void sal_set_user_agent(Sal *ctx, const char *user_agent){
417 eXosip_set_user_agent(user_agent);
420 void sal_use_session_timers(Sal *ctx, int expires){
421 ctx->session_expires=expires;
424 void sal_use_one_matching_codec_policy(Sal *ctx, bool_t one_matching_codec){
425 ctx->one_matching_codec=one_matching_codec;
428 MSList *sal_get_pending_auths(Sal *sal){
429 return ms_list_copy(sal->pending_auths);
432 void sal_use_double_registrations(Sal *ctx, bool_t enabled){
433 ctx->double_reg=enabled;
436 void sal_use_rport(Sal *ctx, bool_t use_rports){
437 ctx->use_rports=use_rports;
439 void sal_use_101(Sal *ctx, bool_t use_101){
440 ctx->use_101=use_101;
443 void sal_root_ca(Sal* ctx, const char* rootCa) {
445 ms_free(ctx->rootCa);
446 ctx->rootCa = ms_strdup(rootCa);
449 static int extract_received_rport(osip_message_t *msg, const char **received, int *rportval,SalTransport* transport){
450 osip_via_t *via=NULL;
451 osip_generic_param_t *param=NULL;
452 const char *rport=NULL;
456 osip_message_get_via(msg,0,&via);
459 *transport = sal_transport_parse(via->protocol);
461 if (via->port && via->port[0]!='\0')
462 *rportval=atoi(via->port);
464 osip_via_param_get_byname(via,"rport",¶m);
467 if (rport && rport[0]!='\0') *rportval=atoi(rport);
471 osip_via_param_get_byname(via,"received",¶m);
472 if (param) *received=param->gvalue;
474 if (rport==NULL && *received==NULL) return -1;
478 static void set_sdp(osip_message_t *sip,sdp_message_t *msg){
482 sdp_message_to_str(msg,&sdp);
484 snprintf(clen,sizeof(clen),"%i",sdplen);
485 osip_message_set_body(sip,sdp,sdplen);
486 osip_message_set_content_type(sip,"application/sdp");
487 osip_message_set_content_length(sip,clen);
491 static void set_sdp_from_desc(osip_message_t *sip, const SalMediaDescription *desc){
492 sdp_message_t *msg=media_description_to_sdp(desc);
494 ms_error("Fail to print sdp message !");
498 sdp_message_free(msg);
501 static void sdp_process(SalOp *h){
502 ms_message("Doing SDP offer/answer process");
504 sal_media_description_unref(h->result);
506 h->result=sal_media_description_new();
507 if (h->sdp_offering){
508 offer_answer_initiate_outgoing(h->base.local_media,h->base.remote_media,h->result);
511 offer_answer_initiate_incoming(h->base.local_media,h->base.remote_media,h->result,h->base.root->one_matching_codec);
512 h->sdp_answer=media_description_to_sdp(h->result);
513 /*once we have generated the SDP answer, we modify the result description for processing by the upper layer.
514 It should contains media parameters constraint from the remote offer, not our response*/
515 strcpy(h->result->addr,h->base.remote_media->addr);
516 h->result->bandwidth=h->base.remote_media->bandwidth;
517 for(i=0;i<h->result->nstreams;++i){
518 if (h->result->streams[i].port>0){
519 strcpy(h->result->streams[i].addr,h->base.remote_media->streams[i].addr);
520 h->result->streams[i].ptime=h->base.remote_media->streams[i].ptime;
521 h->result->streams[i].bandwidth=h->base.remote_media->streams[i].bandwidth;
522 h->result->streams[i].port=h->base.remote_media->streams[i].port;
529 int sal_call_is_offerer(const SalOp *h){
530 return h->sdp_offering;
533 int sal_call_set_local_media_description(SalOp *h, SalMediaDescription *desc){
535 sal_media_description_ref(desc);
536 if (h->base.local_media)
537 sal_media_description_unref(h->base.local_media);
538 h->base.local_media=desc;
542 int sal_call(SalOp *h, const char *from, const char *to){
545 osip_message_t *invite=NULL;
546 sal_op_set_from(h,from);
548 sal_exosip_fix_route(h);
549 route = sal_op_get_route(h);
550 err=eXosip_call_build_initial_invite(&invite,to,from,route,"Phone call");
552 ms_error("Could not create call. Error %d (from=%s to=%s route=%s)",
553 err, from, to, route);
556 osip_message_set_allow(invite, "INVITE, ACK, CANCEL, OPTIONS, BYE, REFER, NOTIFY, MESSAGE, SUBSCRIBE, INFO");
557 if (h->base.contact){
558 _osip_list_set_empty(&invite->contacts,(void (*)(void*))osip_contact_free);
559 osip_message_set_contact(invite,h->base.contact);
561 if (h->base.root->session_expires!=0){
562 osip_message_set_header(invite, "Session-expires", "200");
563 osip_message_set_supported(invite, "timer");
565 if (h->base.local_media){
566 h->sdp_offering=TRUE;
567 set_sdp_from_desc(invite,h->base.local_media);
568 }else h->sdp_offering=FALSE;
570 osip_message_set_header(invite,"Replaces",h->replaces);
572 osip_message_set_header(invite,"Referred-By",h->referred_by);
576 err=eXosip_call_send_initial_invite(invite);
580 ms_error("Fail to send invite ! Error code %d", err);
583 sal_add_call(h->base.root,h);
588 int sal_call_notify_ringing(SalOp *h, bool_t early_media){
591 /*if early media send also 180 and 183 */
592 if (early_media && h->sdp_answer){
595 eXosip_call_build_answer(h->tid,180,&msg);
597 set_sdp(msg,h->sdp_answer);
598 eXosip_call_send_answer(h->tid,180,msg);
601 eXosip_call_build_answer(h->tid,183,&msg);
603 set_sdp(msg,h->sdp_answer);
604 eXosip_call_send_answer(h->tid,183,msg);
609 eXosip_call_send_answer(h->tid,180,NULL);
615 int sal_call_accept(SalOp * h){
617 const char *contact=sal_op_get_contact(h);
619 int err=eXosip_call_build_answer(h->tid,200,&msg);
620 if (err<0 || msg==NULL){
621 ms_error("Fail to build answer for call: err=%i",err);
624 if (h->base.root->session_expires!=0){
625 if (h->supports_session_timers) osip_message_set_supported(msg, "timer");
629 _osip_list_set_empty(&msg->contacts,(void (*)(void*))osip_contact_free);
630 osip_message_set_contact(msg,contact);
633 if (h->base.local_media){
634 /*this is the case where we received an invite without SDP*/
635 if (h->sdp_offering) {
636 set_sdp_from_desc(msg,h->base.local_media);
639 set_sdp(msg,h->sdp_answer);
640 sdp_message_free(h->sdp_answer);
645 ms_error("You are accepting a call but not defined any media capabilities !");
647 eXosip_call_send_answer(h->tid,200,msg);
651 int sal_call_decline(SalOp *h, SalReason reason, const char *redirect){
652 if (reason==SalReasonBusy){
654 eXosip_call_send_answer(h->tid,486,NULL);
657 else if (reason==SalReasonTemporarilyUnavailable){
659 eXosip_call_send_answer(h->tid,480,NULL);
661 }else if (reason==SalReasonDoNotDisturb){
663 eXosip_call_send_answer(h->tid,600,NULL);
665 }else if (reason==SalReasonMedia){
667 eXosip_call_send_answer(h->tid,415,NULL);
669 }else if (redirect!=NULL && reason==SalReasonRedirect){
672 if (strstr(redirect,"sip:")!=0) code=302;
675 eXosip_call_build_answer(h->tid,code,&msg);
676 osip_message_set_contact(msg,redirect);
677 eXosip_call_send_answer(h->tid,code,msg);
679 }else sal_call_terminate(h);
683 SalMediaDescription * sal_call_get_final_media_description(SalOp *h){
684 if (h->base.local_media && h->base.remote_media && !h->result){
690 int sal_call_set_referer(SalOp *h, SalOp *refered_call){
691 if (refered_call->replaces)
692 h->replaces=ms_strdup(refered_call->replaces);
693 if (refered_call->referred_by)
694 h->referred_by=ms_strdup(refered_call->referred_by);
698 int sal_ping(SalOp *op, const char *from, const char *to){
699 osip_message_t *options=NULL;
701 sal_op_set_from(op,from);
702 sal_op_set_to(op,to);
703 /*bug here: eXosip2 does not honor the route argument*/
704 eXosip_options_build_request (&options, sal_op_get_to(op),
705 sal_op_get_from(op),sal_op_get_route(op));
707 if (op->base.root->session_expires!=0){
708 osip_message_set_header(options, "Session-expires", "200");
709 osip_message_set_supported(options, "timer");
711 sal_add_other(sal_op_get_sal(op),op,options);
712 return eXosip_options_send_request(options);
717 int sal_call_accept_refer(SalOp *op){
718 osip_message_t *msg=NULL;
721 err = eXosip_call_build_notify(op->did,EXOSIP_SUBCRSTATE_ACTIVE,&msg);
724 osip_message_set_header(msg,(const char *)"event","refer");
725 osip_message_set_content_type(msg,"message/sipfrag");
726 osip_message_set_body(msg,"SIP/2.0 100 Trying",sizeof("SIP/2.0 100 Trying"));
727 eXosip_call_send_request(op->did,msg);
731 ms_error("could not get a notify built\n");
737 int sal_call_refer(SalOp *h, const char *refer_to){
738 osip_message_t *msg=NULL;
741 eXosip_call_build_refer(h->did,refer_to, &msg);
742 if (msg) err=eXosip_call_send_request(h->did, msg);
748 int sal_call_refer_with_replaces(SalOp *h, SalOp *other_call_h){
749 osip_message_t *msg=NULL;
750 char referto[256]={0};
753 if (eXosip_call_get_referto(other_call_h->did,referto,sizeof(referto)-1)!=0){
754 ms_error("eXosip_call_get_referto() failed for did=%i",other_call_h->did);
758 eXosip_call_build_refer(h->did,referto, &msg);
759 osip_message_set_header(msg,"Referred-By",h->base.from);
760 if (msg) err=eXosip_call_send_request(h->did, msg);
766 SalOp *sal_call_get_replaces(SalOp *h){
767 if (h!=NULL && h->replaces!=NULL){
770 cid=eXosip_call_find_by_replaces(h->replaces);
773 SalOp *ret=sal_find_call(h->base.root,cid);
780 int sal_call_send_dtmf(SalOp *h, char dtmf){
781 osip_message_t *msg=NULL;
786 eXosip_call_build_info(h->did,&msg);
788 snprintf(dtmf_body, sizeof(dtmf_body), "Signal=%c\r\nDuration=250\r\n", dtmf);
789 osip_message_set_body(msg,dtmf_body,strlen(dtmf_body));
790 osip_message_set_content_type(msg,"application/dtmf-relay");
791 snprintf(clen,sizeof(clen),"%lu",(unsigned long)strlen(dtmf_body));
792 osip_message_set_content_length(msg,clen);
793 eXosip_call_send_request(h->did,msg);
799 static void push_auth_to_exosip(const SalAuthInfo *info){
801 if (info->userid==NULL || info->userid[0]=='\0') userid=info->username;
802 else userid=info->userid;
803 ms_message("Authentication info for username [%s], id[%s], realm [%s] added to eXosip", info->username,userid, info->realm);
804 eXosip_add_authentication_info (info->username,userid,
805 info->password, NULL,info->realm);
808 * Just for symmetry ;-)
810 static void pop_auth_from_exosip() {
811 eXosip_clear_authentication_info();
814 int sal_call_terminate(SalOp *h){
816 if (h == NULL) return -1;
817 if (h->auth_info) push_auth_to_exosip(h->auth_info);
819 err=eXosip_call_terminate(h->cid,h->did);
821 if (!h->base.root->reuse_authorization) pop_auth_from_exosip();
823 ms_warning("Exosip could not terminate the call: cid=%i did=%i", h->cid,h->did);
829 void sal_op_authenticate(SalOp *h, const SalAuthInfo *info){
830 if (h->pending_auth){
831 push_auth_to_exosip(info);
833 /*FIXME exosip does not take into account this update register message*/
835 if (fix_message_contact(h, h->pending_auth->request,h->pending_auth->response)) {
839 update_contact_from_response(h,h->pending_auth->response);
841 eXosip_default_action(h->pending_auth);
843 ms_message("eXosip_default_action() done");
844 if (!h->base.root->reuse_authorization) pop_auth_from_exosip();
846 if (h->auth_info) sal_auth_info_delete(h->auth_info); /*if already exist*/
847 h->auth_info=sal_auth_info_clone(info); /*store auth info for subsequent request*/
850 void sal_op_cancel_authentication(SalOp *h) {
852 sal_op_get_sal(h)->callbacks.register_failure(h,SalErrorFailure, SalReasonForbidden,_("Authentication failure"));
853 } else if (h->cid >0) {
854 sal_op_get_sal(h)->callbacks.call_failure(h,SalErrorFailure, SalReasonForbidden,_("Authentication failure"),0);
856 ms_warning("Auth failure not handled");
860 static void set_network_origin(SalOp *op, osip_message_t *req){
861 const char *received=NULL;
864 SalTransport transport;
865 if (extract_received_rport(req,&received,&rport,&transport)!=0){
866 osip_via_t *via=NULL;
868 osip_message_get_via(req,0,&via);
869 received=osip_via_get_host(via);
870 tmp=osip_via_get_port(via);
871 if (tmp) rport=atoi(tmp);
873 if (transport != SalTransportUDP) {
874 snprintf(origin,sizeof(origin)-1,"sip:%s:%i",received,rport);
876 snprintf(origin,sizeof(origin)-1,"sip:%s:%i;transport=%s",received,rport,sal_transport_to_string(transport));
878 __sal_op_set_network_origin(op,origin);
881 static void set_remote_ua(SalOp* op, osip_message_t *req){
882 if (op->base.remote_ua==NULL){
883 osip_header_t *h=NULL;
884 osip_message_get_user_agent(req,0,&h);
886 op->base.remote_ua=ms_strdup(h->hvalue);
891 static void set_replaces(SalOp *op, osip_message_t *req){
892 osip_header_t *h=NULL;
895 ms_free(op->replaces);
898 osip_message_header_get_byname(req,"replaces",0,&h);
900 if (h->hvalue && h->hvalue[0]!='\0'){
901 op->replaces=ms_strdup(h->hvalue);
906 static SalOp *find_op(Sal *sal, eXosip_event_t *ev){
908 return sal_find_call(sal,ev->cid);
911 return sal_find_register(sal,ev->rid);
914 return sal_find_out_subscribe(sal,ev->sid);
917 return sal_find_in_subscribe(sal,ev->nid);
919 if (ev->response) return sal_find_other(sal,ev->response);
923 static void inc_new_call(Sal *sal, eXosip_event_t *ev){
924 SalOp *op=sal_op_new(sal);
925 osip_from_t *from,*to;
926 osip_call_info_t *call_info;
928 sdp_message_t *sdp=eXosip_get_sdp_info(ev->request);
930 set_network_origin(op,ev->request);
931 set_remote_ua(op,ev->request);
932 set_replaces(op,ev->request);
935 op->sdp_offering=FALSE;
936 op->base.remote_media=sal_media_description_new();
937 sdp_to_media_description(sdp,op->base.remote_media);
938 sdp_message_free(sdp);
939 }else op->sdp_offering=TRUE;
941 from=osip_message_get_from(ev->request);
942 to=osip_message_get_to(ev->request);
943 osip_from_to_str(from,&tmp);
944 sal_op_set_from(op,tmp);
946 osip_from_to_str(to,&tmp);
947 sal_op_set_to(op,tmp);
950 osip_message_get_call_info(ev->request,0,&call_info);
953 osip_call_info_to_str(call_info,&tmp);
954 if( strstr(tmp,"answer-after=") != NULL)
956 op->auto_answer_asked=TRUE;
957 ms_message("The caller asked to automatically answer the call(Emergency?)\n");
966 sal_add_call(op->base.root,op);
967 sal->callbacks.call_received(op);
970 static void handle_reinvite(Sal *sal, eXosip_event_t *ev){
971 SalOp *op=find_op(sal,ev);
973 osip_message_t *msg=NULL;
976 ms_warning("Reinvite for non-existing operation !");
981 sdp=eXosip_get_sdp_info(ev->request);
982 if (op->base.remote_media){
983 sal_media_description_unref(op->base.remote_media);
984 op->base.remote_media=NULL;
987 sal_media_description_unref(op->result);
991 op->sdp_offering=FALSE;
992 op->base.remote_media=sal_media_description_new();
993 sdp_to_media_description(sdp,op->base.remote_media);
994 sdp_message_free(sdp);
995 sal->callbacks.call_updating(op);
997 op->sdp_offering=TRUE;
999 eXosip_call_build_answer(ev->tid,200,&msg);
1001 set_sdp_from_desc(msg,op->base.local_media);
1002 eXosip_call_send_answer(ev->tid,200,msg);
1009 static void handle_ack(Sal *sal, eXosip_event_t *ev){
1010 SalOp *op=find_op(sal,ev);
1014 ms_warning("ack for non-existing call !");
1017 sdp=eXosip_get_sdp_info(ev->ack);
1019 op->base.remote_media=sal_media_description_new();
1020 sdp_to_media_description(sdp,op->base.remote_media);
1022 sdp_message_free(sdp);
1025 if (sdp) sal->callbacks.call_updating(op);
1028 sal->callbacks.call_ack(op);
1032 static void update_contact_from_response(SalOp *op, osip_message_t *response){
1033 const char *received;
1035 SalTransport transport;
1036 if (extract_received_rport(response,&received,&rport,&transport)==0){
1037 const char *contact=sal_op_get_contact(op);
1039 /*no contact given yet, use from instead*/
1040 contact=sal_op_get_from(op);
1043 SalAddress *addr=sal_address_new(contact);
1045 sal_address_set_domain(addr,received);
1046 sal_address_set_port_int(addr,rport);
1047 if (transport!=SalTransportUDP)
1048 sal_address_set_transport(addr,transport);
1049 tmp=sal_address_as_string(addr);
1050 ms_message("Contact address updated to %s",tmp);
1051 sal_op_set_contact(op,tmp);
1052 sal_address_destroy(addr);
1058 static int call_proceeding(Sal *sal, eXosip_event_t *ev){
1059 SalOp *op=find_op(sal,ev);
1061 if (op==NULL || op->terminated==TRUE) {
1062 ms_warning("This call has been canceled.");
1064 eXosip_call_terminate(ev->cid,ev->did);
1072 /* update contact if received and rport are set by the server
1073 note: will only be used by remote for next INVITE, if any...*/
1074 update_contact_from_response(op,ev->response);
1078 static void call_ringing(Sal *sal, eXosip_event_t *ev){
1080 SalOp *op=find_op(sal,ev);
1081 if (call_proceeding(sal, ev)==-1) return;
1083 set_remote_ua(op,ev->response);
1084 sdp=eXosip_get_sdp_info(ev->response);
1086 op->base.remote_media=sal_media_description_new();
1087 sdp_to_media_description(sdp,op->base.remote_media);
1088 sdp_message_free(sdp);
1089 if (op->base.local_media) sdp_process(op);
1091 sal->callbacks.call_ringing(op);
1094 static void call_accepted(Sal *sal, eXosip_event_t *ev){
1096 osip_message_t *msg=NULL;
1097 SalOp *op=find_op(sal,ev);
1098 const char *contact;
1100 if (op==NULL || op->terminated==TRUE) {
1101 ms_warning("This call has been already terminated.");
1103 eXosip_call_terminate(ev->cid,ev->did);
1109 set_remote_ua(op,ev->response);
1111 sdp=eXosip_get_sdp_info(ev->response);
1113 op->base.remote_media=sal_media_description_new();
1114 sdp_to_media_description(sdp,op->base.remote_media);
1115 sdp_message_free(sdp);
1116 if (op->base.local_media) sdp_process(op);
1118 eXosip_call_build_ack(ev->did,&msg);
1120 ms_warning("This call has been already terminated.");
1122 eXosip_call_terminate(ev->cid,ev->did);
1126 contact=sal_op_get_contact(op);
1128 _osip_list_set_empty(&msg->contacts,(void (*)(void*))osip_contact_free);
1129 osip_message_set_contact(msg,contact);
1131 if (op->sdp_answer){
1132 set_sdp(msg,op->sdp_answer);
1133 sdp_message_free(op->sdp_answer);
1134 op->sdp_answer=NULL;
1136 eXosip_call_send_ack(ev->did,msg);
1137 sal->callbacks.call_accepted(op);
1140 static void call_terminated(Sal *sal, eXosip_event_t *ev){
1142 SalOp *op=find_op(sal,ev);
1144 ms_warning("Call terminated for already closed call ?");
1148 osip_from_to_str(ev->request->from,&from);
1150 sal->callbacks.call_terminated(op,from!=NULL ? from : sal_op_get_from(op));
1151 if (from) osip_free(from);
1152 op->terminated=TRUE;
1155 static void call_released(Sal *sal, eXosip_event_t *ev){
1156 SalOp *op=find_op(sal,ev);
1158 ms_warning("No op associated to this call_released()");
1161 if (!op->terminated){
1162 /* no response received so far */
1163 call_failure(sal,ev);
1165 sal->callbacks.call_released(op);
1168 static int get_auth_data_from_response(osip_message_t *resp, const char **realm, const char **username){
1169 const char *prx_realm=NULL,*www_realm=NULL;
1170 osip_proxy_authenticate_t *prx_auth;
1171 osip_www_authenticate_t *www_auth;
1173 *username=osip_uri_get_username(resp->from->url);
1174 prx_auth=(osip_proxy_authenticate_t*)osip_list_get(&resp->proxy_authenticates,0);
1175 www_auth=(osip_proxy_authenticate_t*)osip_list_get(&resp->www_authenticates,0);
1177 prx_realm=osip_proxy_authenticate_get_realm(prx_auth);
1179 www_realm=osip_www_authenticate_get_realm(www_auth);
1183 }else if (www_realm){
1191 static int get_auth_data_from_request(osip_message_t *msg, const char **realm, const char **username){
1192 osip_authorization_t *auth=NULL;
1193 osip_proxy_authorization_t *prx_auth=NULL;
1195 *username=osip_uri_get_username(msg->from->url);
1196 osip_message_get_authorization(msg, 0, &auth);
1198 *realm=osip_authorization_get_realm(auth);
1201 osip_message_get_proxy_authorization(msg,0,&prx_auth);
1203 *realm=osip_proxy_authorization_get_realm(prx_auth);
1209 static int get_auth_data(eXosip_event_t *ev, const char **realm, const char **username){
1210 if (ev->response && get_auth_data_from_response(ev->response,realm,username)==0) return 0;
1211 if (ev->request && get_auth_data_from_request(ev->request,realm,username)==0) return 0;
1215 int sal_op_get_auth_requested(SalOp *op, const char **realm, const char **username){
1216 if (op->pending_auth){
1217 return get_auth_data(op->pending_auth,realm,username);
1222 static bool_t process_authentication(Sal *sal, eXosip_event_t *ev){
1224 const char *username,*realm;
1227 ms_warning("No operation associated with this authentication !");
1230 if (get_auth_data(ev,&realm,&username)==0){
1231 if (op->pending_auth!=NULL){
1232 eXosip_event_free(op->pending_auth);
1233 op->pending_auth=ev;
1235 op->pending_auth=ev;
1236 sal_add_pending_auth(sal,op);
1239 sal->callbacks.auth_requested(op,realm,username);
1245 static void authentication_ok(Sal *sal, eXosip_event_t *ev){
1247 const char *username,*realm;
1250 ms_warning("No operation associated with this authentication_ok!");
1253 if (op->pending_auth){
1254 eXosip_event_free(op->pending_auth);
1255 sal_remove_pending_auth(sal,op);
1256 op->pending_auth=NULL;
1258 if (get_auth_data(ev,&realm,&username)==0){
1259 sal->callbacks.auth_success(op,realm,username);
1263 static bool_t call_failure(Sal *sal, eXosip_event_t *ev){
1266 char* computedReason=NULL;
1267 const char *reason=NULL;
1268 SalError error=SalErrorUnknown;
1269 SalReason sr=SalReasonUnknown;
1272 op=(SalOp*)find_op(sal,ev);
1275 ms_warning("Call failure reported for a closed call, ignored.");
1280 code=osip_message_get_status_code(ev->response);
1281 reason=osip_message_get_reason_phrase(ev->response);
1282 osip_header_t *h=NULL;
1283 if (!osip_message_header_get_byname( ev->response
1287 computedReason = ms_strdup_printf("%s %s",reason,osip_header_get_value(h));
1288 reason = computedReason;
1296 return process_authentication(sal,ev);
1299 error=SalErrorUnknown;
1302 error=SalErrorFailure;
1303 sr=SalReasonNotFound;
1306 error=SalErrorFailure;
1310 eXosip_default_action(ev);
1314 error=SalErrorFailure;
1315 sr=SalReasonTemporarilyUnavailable;
1317 error=SalErrorFailure;
1323 error=SalErrorFailure;
1324 sr=SalReasonDoNotDisturb;
1327 error=SalErrorFailure;
1328 sr=SalReasonDeclined;
1332 error=SalErrorFailure;
1333 sr=SalReasonUnknown;
1334 }else error=SalErrorNoResponse;
1336 op->terminated=TRUE;
1337 sal->callbacks.call_failure(op,error,sr,reason,code);
1338 if (computedReason != NULL){
1339 ms_free(computedReason);
1344 /* Request remote side to send us VFU */
1345 void sal_call_send_vfu_request(SalOp *h){
1346 osip_message_t *msg=NULL;
1348 "<?xml version=\"1.0\" encoding=\"utf-8\" ?>"
1352 " <picture_fast_update></picture_fast_update>"
1360 eXosip_call_build_info(h->did,&msg);
1362 osip_message_set_body(msg,info_body,strlen(info_body));
1363 osip_message_set_content_type(msg,"application/media_control+xml");
1364 snprintf(clen,sizeof(clen),"%lu",(unsigned long)strlen(info_body));
1365 osip_message_set_content_length(msg,clen);
1366 eXosip_call_send_request(h->did,msg);
1367 ms_message("Sending VFU request !");
1372 static void process_media_control_xml(Sal *sal, eXosip_event_t *ev){
1373 SalOp *op=find_op(sal,ev);
1374 osip_body_t *body=NULL;
1377 ms_warning("media control xml received without operation context!");
1381 osip_message_get_body(ev->request,0,&body);
1382 if (body && body->body!=NULL &&
1383 strstr(body->body,"picture_fast_update")){
1384 osip_message_t *ans=NULL;
1385 ms_message("Receiving VFU request !");
1386 if (sal->callbacks.vfu_request){
1387 sal->callbacks.vfu_request(op);
1388 eXosip_call_build_answer(ev->tid,200,&ans);
1390 eXosip_call_send_answer(ev->tid,200,ans);
1394 /*in all other cases we must say it is not implemented.*/
1396 osip_message_t *ans=NULL;
1398 eXosip_call_build_answer(ev->tid,501,&ans);
1400 eXosip_call_send_answer(ev->tid,501,ans);
1405 static void process_dtmf_relay(Sal *sal, eXosip_event_t *ev){
1406 SalOp *op=find_op(sal,ev);
1407 osip_body_t *body=NULL;
1410 ms_warning("media dtmf relay received without operation context!");
1414 osip_message_get_body(ev->request,0,&body);
1415 if (body && body->body!=NULL){
1416 osip_message_t *ans=NULL;
1417 const char *name=strstr(body->body,"Signal");
1418 if (name==NULL) name=strstr(body->body,"signal");
1420 ms_warning("Could not extract the dtmf name from the SIP INFO.");
1423 name+=strlen("signal");
1424 if (sscanf(name," = %1s",tmp)==1){
1425 ms_message("Receiving dtmf %s via SIP INFO.",tmp);
1426 if (sal->callbacks.dtmf_received != NULL)
1427 sal->callbacks.dtmf_received(op, tmp[0]);
1431 eXosip_call_build_answer(ev->tid,200,&ans);
1433 eXosip_call_send_answer(ev->tid,200,ans);
1438 static void fill_options_answer(osip_message_t *options){
1439 osip_message_set_allow(options,"INVITE, ACK, BYE, CANCEL, OPTIONS, MESSAGE, SUBSCRIBE, NOTIFY, INFO");
1440 osip_message_set_accept(options,"application/sdp");
1443 static void process_refer(Sal *sal, SalOp *op, eXosip_event_t *ev){
1444 osip_header_t *h=NULL;
1445 osip_message_t *ans=NULL;
1446 ms_message("Receiving REFER request !");
1447 osip_message_header_get_byname(ev->request,"Refer-To",0,&h);
1450 osip_from_t *from=NULL;
1452 osip_from_init(&from);
1454 if (osip_from_parse(from,h->hvalue)==0){
1456 osip_uri_header_t *uh=NULL;
1457 osip_header_t *referred_by=NULL;
1458 osip_uri_header_get_byname(&from->url->url_headers,(char*)"Replaces",&uh);
1459 if (uh!=NULL && uh->gvalue && uh->gvalue[0]!='\0'){
1460 ms_message("Found replaces in Refer-To");
1462 ms_free(op->replaces);
1464 op->replaces=ms_strdup(uh->gvalue);
1466 osip_message_header_get_byname(ev->request,"Referred-By",0,&referred_by);
1467 if (referred_by && referred_by->hvalue && referred_by->hvalue[0]!='\0'){
1468 if (op->referred_by)
1469 ms_free(op->referred_by);
1470 op->referred_by=ms_strdup(referred_by->hvalue);
1473 osip_uri_header_freelist(&from->url->url_headers);
1474 osip_from_to_str(from,&tmp);
1475 sal->callbacks.refer_received(sal,op,tmp);
1477 osip_from_free(from);
1480 eXosip_call_build_answer(ev->tid,202,&ans);
1482 eXosip_call_send_answer(ev->tid,202,ans);
1487 ms_warning("cannot do anything with the refer without destination\n");
1491 static void call_message_new(Sal *sal, eXosip_event_t *ev){
1492 osip_message_t *ans=NULL;
1494 if (MSG_IS_INFO(ev->request)){
1495 osip_content_type_t *ct;
1496 ct=osip_message_get_content_type(ev->request);
1497 if (ct && ct->subtype){
1498 if (strcmp(ct->subtype,"media_control+xml")==0)
1499 process_media_control_xml(sal,ev);
1500 else if (strcmp(ct->subtype,"dtmf-relay")==0)
1501 process_dtmf_relay(sal,ev);
1503 ms_message("Unhandled SIP INFO.");
1504 /*send an "Not implemented" answer*/
1506 eXosip_call_build_answer(ev->tid,501,&ans);
1508 eXosip_call_send_answer(ev->tid,501,ans);
1512 /*empty SIP INFO, probably to test we are alive. Send an empty answer*/
1514 eXosip_call_build_answer(ev->tid,200,&ans);
1516 eXosip_call_send_answer(ev->tid,200,ans);
1519 }else if(MSG_IS_MESSAGE(ev->request)){
1520 /* SIP messages could be received into call */
1521 text_received(sal, ev);
1523 eXosip_call_build_answer(ev->tid,200,&ans);
1525 eXosip_call_send_answer(ev->tid,200,ans);
1527 }else if(MSG_IS_REFER(ev->request)){
1528 SalOp *op=find_op(sal,ev);
1530 ms_message("Receiving REFER request !");
1531 process_refer(sal,op,ev);
1532 }else if(MSG_IS_NOTIFY(ev->request)){
1533 osip_header_t *h=NULL;
1535 SalOp *op=find_op(sal,ev);
1537 ms_message("Receiving NOTIFY request !");
1538 osip_from_to_str(ev->request->from,&from);
1539 osip_message_header_get_byname(ev->request,"Event",0,&h);
1541 sal->callbacks.notify(op,from,h->hvalue);
1542 /*answer that we received the notify*/
1544 eXosip_call_build_answer(ev->tid,200,&ans);
1546 eXosip_call_send_answer(ev->tid,200,ans);
1549 }else if (MSG_IS_OPTIONS(ev->request)){
1551 eXosip_call_build_answer(ev->tid,200,&ans);
1553 fill_options_answer(ans);
1554 eXosip_call_send_answer(ev->tid,200,ans);
1558 }else ms_warning("call_message_new: No request ?");
1561 static void inc_update(Sal *sal, eXosip_event_t *ev){
1562 osip_message_t *msg=NULL;
1563 ms_message("Processing incoming UPDATE");
1565 eXosip_message_build_answer(ev->tid,200,&msg);
1567 eXosip_message_send_answer(ev->tid,200,msg);
1571 static bool_t comes_from_local_if(osip_message_t *msg){
1572 osip_via_t *via=NULL;
1573 osip_message_get_via(msg,0,&via);
1576 host=osip_via_get_host(via);
1577 if (strcmp(host,"127.0.0.1")==0 || strcmp(host,"::1")==0){
1578 osip_generic_param_t *param=NULL;
1579 osip_via_param_get_byname(via,"received",¶m);
1580 if (param==NULL) return TRUE;
1581 if (param->gvalue &&
1582 (strcmp(param->gvalue,"127.0.0.1")==0 || strcmp(param->gvalue,"::1")==0)){
1590 static void text_received(Sal *sal, eXosip_event_t *ev){
1591 osip_body_t *body=NULL;
1592 char *from=NULL,*msg;
1594 osip_message_get_body(ev->request,0,&body);
1596 ms_error("Could not get text message from SIP body");
1600 osip_from_to_str(ev->request->from,&from);
1601 sal->callbacks.text_received(sal,from,msg);
1607 static void other_request(Sal *sal, eXosip_event_t *ev){
1608 ms_message("in other_request");
1609 if (ev->request==NULL) return;
1610 if (strcmp(ev->request->sip_method,"MESSAGE")==0){
1611 text_received(sal,ev);
1612 eXosip_message_send_answer(ev->tid,200,NULL);
1613 }else if (strcmp(ev->request->sip_method,"OPTIONS")==0){
1614 osip_message_t *options=NULL;
1615 eXosip_options_build_answer(ev->tid,200,&options);
1616 fill_options_answer(options);
1617 eXosip_options_send_answer(ev->tid,200,options);
1618 }else if (strncmp(ev->request->sip_method, "REFER", 5) == 0){
1619 ms_message("Receiving REFER request !");
1620 if (comes_from_local_if(ev->request)) {
1621 process_refer(sal,NULL,ev);
1622 }else ms_warning("Ignored REFER not coming from this local loopback interface.");
1623 }else if (strncmp(ev->request->sip_method, "UPDATE", 6) == 0){
1628 osip_message_to_str(ev->request,&tmp,&msglen);
1630 ms_message("Unsupported request received:\n%s",tmp);
1633 /*answer with a 501 Not implemented*/
1634 eXosip_message_send_answer(ev->tid,501,NULL);
1638 static void masquerade_via(osip_message_t *msg, const char *ip, const char *port){
1639 osip_via_t *via=NULL;
1640 osip_message_get_via(msg,0,&via);
1642 osip_free(via->port);
1643 via->port=osip_strdup(port);
1644 osip_free(via->host);
1645 via->host=osip_strdup(ip);
1650 static bool_t fix_message_contact(SalOp *op, osip_message_t *request,osip_message_t *last_answer) {
1651 osip_contact_t *ctt=NULL;
1652 const char *received;
1654 SalTransport transport;
1657 if (extract_received_rport(last_answer,&received,&rport,&transport)==-1) return FALSE;
1658 osip_message_get_contact(request,0,&ctt);
1660 /*nothing to update*/
1663 if (ctt->url->host!=NULL){
1664 osip_free(ctt->url->host);
1666 ctt->url->host=osip_strdup(received);
1667 if (ctt->url->port!=NULL){
1668 osip_free(ctt->url->port);
1670 snprintf(port,sizeof(port),"%i",rport);
1671 ctt->url->port=osip_strdup(port);
1672 if (op->masquerade_via) masquerade_via(request,received,port);
1674 if (transport != SalTransportUDP) {
1675 sal_address_set_param((SalAddress *)ctt, "transport", sal_transport_to_string(transport));
1680 static bool_t register_again_with_updated_contact(SalOp *op, osip_message_t *orig_request, osip_message_t *last_answer){
1681 osip_contact_t *ctt=NULL;
1682 SalAddress* ori_contact_address=NULL;
1683 const char *received;
1685 SalTransport transport;
1687 osip_message_t *msg=NULL;
1688 Sal* sal=op->base.root;
1690 if (sal->double_reg==FALSE ) return FALSE;
1692 if (extract_received_rport(last_answer,&received,&rport,&transport)==-1) return FALSE;
1693 osip_message_get_contact(orig_request,0,&ctt);
1694 osip_contact_to_str(ctt,&tmp);
1695 ori_contact_address = sal_address_new((const char*)tmp);
1697 /*check if contact is up to date*/
1698 if (strcmp(sal_address_get_domain(ori_contact_address),received) ==0
1699 && sal_address_get_port_int(ori_contact_address) == rport
1700 && sal_address_get_transport(ori_contact_address) == transport) {
1701 ms_message("Register has up to date contact, doing nothing.");
1704 } else ms_message("contact do not match, need to update the register (%s with %s:%i;transport=%s)"
1708 ,sal_transport_to_string(transport));
1710 sal_address_destroy(ori_contact_address);
1712 if (transport == SalTransportUDP) {
1714 eXosip_register_build_register(op->rid,op->expires,&msg);
1717 ms_warning("Fail to create a contact updated register.");
1720 if (fix_message_contact(op,msg,last_answer)) {
1721 eXosip_register_send_register(op->rid,msg);
1723 ms_message("Resending new register with updated contact");
1726 ms_warning("Fail to send updated register.");
1733 update_contact_from_response(op,last_answer);
1737 static void registration_success(Sal *sal, eXosip_event_t *ev){
1738 SalOp *op=sal_find_register(sal,ev->rid);
1739 osip_header_t *h=NULL;
1742 ms_error("Receiving register response for unknown operation");
1745 osip_message_get_expires(ev->request,0,&h);
1746 if (h!=NULL && atoi(h->hvalue)!=0){
1748 if (!register_again_with_updated_contact(op,ev->request,ev->response)){
1749 sal->callbacks.register_success(op,registered);
1752 sal->callbacks.register_success(op,FALSE);
1756 static bool_t registration_failure(Sal *sal, eXosip_event_t *ev){
1758 const char *reason=NULL;
1759 SalOp *op=sal_find_register(sal,ev->rid);
1760 SalReason sr=SalReasonUnknown;
1761 SalError se=SalErrorUnknown;
1764 ms_error("Receiving register failure for unknown operation");
1768 status_code=osip_message_get_status_code(ev->response);
1769 reason=osip_message_get_reason_phrase(ev->response);
1771 switch(status_code){
1774 return process_authentication(sal,ev);
1776 case 423: /*interval too brief*/
1777 {/*retry with greater interval */
1778 osip_header_t *h=NULL;
1779 osip_message_t *msg=NULL;
1780 osip_message_header_get_byname(ev->response,"min-expires",0,&h);
1781 if (h && h->hvalue && h->hvalue[0]!='\0'){
1782 int val=atoi(h->hvalue);
1783 if (val>op->expires)
1785 }else op->expires*=2;
1787 eXosip_register_build_register(op->rid,op->expires,&msg);
1788 eXosip_register_send_register(op->rid,msg);
1792 case 606: /*Not acceptable, workaround for proxies that don't like private addresses
1793 in vias, such as ekiga.net
1794 On the opposite, freephonie.net bugs when via are masqueraded.
1796 op->masquerade_via=TRUE;
1798 /* if contact is up to date, process the failure, otherwise resend a new register with
1799 updated contact first, just in case the faillure is due to incorrect contact */
1800 if (ev->response && register_again_with_updated_contact(op,ev->request,ev->response))
1801 return TRUE; /*we are retrying with an updated contact*/
1802 if (status_code==403){
1804 sr=SalReasonForbidden;
1805 }else if (status_code==0){
1806 se=SalErrorNoResponse;
1808 sal->callbacks.register_failure(op,se,sr,reason);
1813 static void other_request_reply(Sal *sal,eXosip_event_t *ev){
1814 SalOp *op=find_op(sal,ev);
1817 ms_warning("other_request_reply(): Receiving response to unknown request.");
1821 update_contact_from_response(op,ev->response);
1822 if (ev->request && strcmp(osip_message_get_method(ev->request),"OPTIONS")==0)
1823 sal->callbacks.ping_reply(op);
1827 static bool_t process_event(Sal *sal, eXosip_event_t *ev){
1828 ms_message("linphone process event get a message %d\n",ev->type);
1830 case EXOSIP_CALL_ANSWERED:
1831 ms_message("CALL_ANSWERED\n");
1832 call_accepted(sal,ev);
1833 authentication_ok(sal,ev);
1835 case EXOSIP_CALL_CLOSED:
1836 case EXOSIP_CALL_CANCELLED:
1837 ms_message("CALL_CLOSED or CANCELLED\n");
1838 call_terminated(sal,ev);
1840 case EXOSIP_CALL_TIMEOUT:
1841 case EXOSIP_CALL_NOANSWER:
1842 ms_message("CALL_TIMEOUT or NOANSWER\n");
1843 return call_failure(sal,ev);
1845 case EXOSIP_CALL_REQUESTFAILURE:
1846 case EXOSIP_CALL_GLOBALFAILURE:
1847 case EXOSIP_CALL_SERVERFAILURE:
1848 ms_message("CALL_REQUESTFAILURE or GLOBALFAILURE or SERVERFAILURE\n");
1849 return call_failure(sal,ev);
1851 case EXOSIP_CALL_RELEASED:
1852 ms_message("CALL_RELEASED\n");
1853 call_released(sal, ev);
1855 case EXOSIP_CALL_INVITE:
1856 ms_message("CALL_NEW\n");
1857 inc_new_call(sal,ev);
1859 case EXOSIP_CALL_REINVITE:
1860 handle_reinvite(sal,ev);
1862 case EXOSIP_CALL_ACK:
1863 ms_message("CALL_ACK");
1866 case EXOSIP_CALL_REDIRECTED:
1867 ms_message("CALL_REDIRECTED");
1868 eXosip_default_action(ev);
1870 case EXOSIP_CALL_PROCEEDING:
1871 ms_message("CALL_PROCEEDING");
1872 call_proceeding(sal,ev);
1874 case EXOSIP_CALL_RINGING:
1875 ms_message("CALL_RINGING");
1876 call_ringing(sal,ev);
1878 case EXOSIP_CALL_MESSAGE_NEW:
1879 ms_message("EXOSIP_CALL_MESSAGE_NEW");
1880 call_message_new(sal,ev);
1882 case EXOSIP_CALL_MESSAGE_REQUESTFAILURE:
1884 (ev->response->status_code==407 || ev->response->status_code==401)){
1885 return process_authentication(sal,ev);
1888 case EXOSIP_IN_SUBSCRIPTION_NEW:
1889 ms_message("CALL_IN_SUBSCRIPTION_NEW ");
1890 sal_exosip_subscription_recv(sal,ev);
1892 case EXOSIP_IN_SUBSCRIPTION_RELEASED:
1893 ms_message("CALL_SUBSCRIPTION_NEW ");
1894 sal_exosip_in_subscription_closed(sal,ev);
1896 case EXOSIP_SUBSCRIPTION_UPDATE:
1897 ms_message("CALL_SUBSCRIPTION_UPDATE");
1899 case EXOSIP_SUBSCRIPTION_NOTIFY:
1900 ms_message("CALL_SUBSCRIPTION_NOTIFY");
1901 sal_exosip_notify_recv(sal,ev);
1903 case EXOSIP_SUBSCRIPTION_ANSWERED:
1904 ms_message("EXOSIP_SUBSCRIPTION_ANSWERED, ev->sid=%i, ev->did=%i\n",ev->sid,ev->did);
1905 sal_exosip_subscription_answered(sal,ev);
1907 case EXOSIP_SUBSCRIPTION_CLOSED:
1908 ms_message("EXOSIP_SUBSCRIPTION_CLOSED\n");
1909 sal_exosip_subscription_closed(sal,ev);
1911 case EXOSIP_SUBSCRIPTION_REQUESTFAILURE: /**< announce a request failure */
1912 if (ev->response && (ev->response->status_code == 407 || ev->response->status_code == 401)){
1913 return process_authentication(sal,ev);
1915 case EXOSIP_SUBSCRIPTION_SERVERFAILURE:
1916 case EXOSIP_SUBSCRIPTION_GLOBALFAILURE:
1917 sal_exosip_subscription_closed(sal,ev);
1919 case EXOSIP_REGISTRATION_FAILURE:
1920 ms_message("REGISTRATION_FAILURE\n");
1921 return registration_failure(sal,ev);
1923 case EXOSIP_REGISTRATION_SUCCESS:
1924 authentication_ok(sal,ev);
1925 registration_success(sal,ev);
1927 case EXOSIP_MESSAGE_NEW:
1928 other_request(sal,ev);
1930 case EXOSIP_MESSAGE_PROCEEDING:
1931 case EXOSIP_MESSAGE_ANSWERED:
1932 case EXOSIP_MESSAGE_REDIRECTED:
1933 case EXOSIP_MESSAGE_SERVERFAILURE:
1934 case EXOSIP_MESSAGE_GLOBALFAILURE:
1935 other_request_reply(sal,ev);
1937 case EXOSIP_MESSAGE_REQUESTFAILURE:
1938 case EXOSIP_NOTIFICATION_REQUESTFAILURE:
1940 switch (ev->response->status_code) {
1943 return process_authentication(sal,ev);
1945 eXosip_automatic_action ();
1950 other_request_reply(sal,ev);
1953 ms_message("Unhandled exosip event ! %i",ev->type);
1959 int sal_iterate(Sal *sal){
1961 while((ev=eXosip_event_wait(0,0))!=NULL){
1962 if (process_event(sal,ev))
1963 eXosip_event_free(ev);
1966 eXosip_automatic_refresh();
1971 static void register_set_contact(osip_message_t *msg, const char *contact){
1972 osip_uri_param_t *param = NULL;
1973 osip_contact_t *ct=NULL;
1975 /*we get the line parameter choosed by exosip, and add it to our own contact*/
1976 osip_message_get_contact(msg,0,&ct);
1978 osip_uri_uparam_get_byname(ct->url, "line", ¶m);
1979 if (param && param->gvalue)
1980 line=osip_strdup(param->gvalue);
1982 _osip_list_set_empty(&msg->contacts,(void (*)(void*))osip_contact_free);
1983 osip_message_set_contact(msg,contact);
1984 osip_message_get_contact(msg,0,&ct);
1985 osip_uri_uparam_add(ct->url,osip_strdup("line"),line);
1988 int sal_register(SalOp *h, const char *proxy, const char *from, int expires){
1989 osip_message_t *msg;
1990 const char *contact=sal_op_get_contact(h);
1992 sal_op_set_route(h,proxy);
1995 h->rid=eXosip_register_build_initial_register(from,proxy,NULL,expires,&msg);
1997 if (contact) register_set_contact(msg,contact);
1998 sal_add_register(h->base.root,h);
2000 ms_error("Could not build initial register.");
2006 eXosip_register_build_register(h->rid,expires,&msg);
2008 eXosip_register_send_register(h->rid,msg);
2014 int sal_register_refresh(SalOp *op, int expires){
2015 osip_message_t *msg=NULL;
2016 const char *contact=sal_op_get_contact(op);
2019 ms_error("Unexistant registration context, not possible to refresh.");
2023 eXosip_register_build_register(op->rid,expires,&msg);
2025 if (contact) register_set_contact(msg,contact);
2026 eXosip_register_send_register(op->rid,msg);
2027 }else ms_error("Could not build REGISTER refresh message.");
2033 int sal_unregister(SalOp *h){
2034 osip_message_t *msg=NULL;
2036 eXosip_register_build_register(h->rid,0,&msg);
2037 if (msg) eXosip_register_send_register(h->rid,msg);
2038 else ms_warning("Could not build unREGISTER !");
2043 SalAddress * sal_address_new(const char *uri){
2045 osip_from_init(&from);
2047 // Remove front spaces
2048 while (uri[0]==' ') {
2052 if (osip_from_parse(from,uri)!=0){
2053 osip_from_free(from);
2056 if (from->displayname!=NULL && from->displayname[0]=='"'){
2057 char *unquoted=osip_strdup_without_quote(from->displayname);
2058 osip_free(from->displayname);
2059 from->displayname=unquoted;
2061 return (SalAddress*)from;
2064 SalAddress * sal_address_clone(const SalAddress *addr){
2065 osip_from_t *ret=NULL;
2066 osip_from_clone((osip_from_t*)addr,&ret);
2067 return (SalAddress*)ret;
2070 #define null_if_empty(s) (((s)!=NULL && (s)[0]!='\0') ? (s) : NULL )
2072 const char *sal_address_get_scheme(const SalAddress *addr){
2073 const osip_from_t *u=(const osip_from_t*)addr;
2074 return null_if_empty(u->url->scheme);
2077 const char *sal_address_get_display_name(const SalAddress* addr){
2078 const osip_from_t *u=(const osip_from_t*)addr;
2079 return null_if_empty(u->displayname);
2082 const char *sal_address_get_username(const SalAddress *addr){
2083 const osip_from_t *u=(const osip_from_t*)addr;
2084 return null_if_empty(u->url->username);
2087 const char *sal_address_get_domain(const SalAddress *addr){
2088 const osip_from_t *u=(const osip_from_t*)addr;
2089 return null_if_empty(u->url->host);
2092 void sal_address_set_display_name(SalAddress *addr, const char *display_name){
2093 osip_from_t *u=(osip_from_t*)addr;
2094 if (u->displayname!=NULL){
2095 osip_free(u->displayname);
2096 u->displayname=NULL;
2098 if (display_name!=NULL && display_name[0]!='\0'){
2099 u->displayname=osip_strdup(display_name);
2103 void sal_address_set_username(SalAddress *addr, const char *username){
2104 osip_from_t *uri=(osip_from_t*)addr;
2105 if (uri->url->username!=NULL){
2106 osip_free(uri->url->username);
2107 uri->url->username=NULL;
2110 uri->url->username=osip_strdup(username);
2113 void sal_address_set_domain(SalAddress *addr, const char *host){
2114 osip_from_t *uri=(osip_from_t*)addr;
2115 if (uri->url->host!=NULL){
2116 osip_free(uri->url->host);
2117 uri->url->host=NULL;
2120 uri->url->host=osip_strdup(host);
2123 void sal_address_set_port(SalAddress *addr, const char *port){
2124 osip_from_t *uri=(osip_from_t*)addr;
2125 if (uri->url->port!=NULL){
2126 osip_free(uri->url->port);
2127 uri->url->port=NULL;
2130 uri->url->port=osip_strdup(port);
2133 void sal_address_set_port_int(SalAddress *uri, int port){
2136 /*this is the default, special case to leave the port field blank*/
2137 sal_address_set_port(uri,NULL);
2140 snprintf(tmp,sizeof(tmp),"%i",port);
2141 sal_address_set_port(uri,tmp);
2144 void sal_address_clean(SalAddress *addr){
2145 osip_generic_param_freelist(& ((osip_from_t*)addr)->gen_params);
2146 osip_uri_param_freelist(& ((osip_from_t*)addr)->url->url_params);
2149 char *sal_address_as_string(const SalAddress *u){
2151 osip_from_t *from=(osip_from_t *)u;
2152 char *old_displayname=NULL;
2153 /* hack to force use of quotes around the displayname*/
2154 if (from->displayname!=NULL
2155 && from->displayname[0]!='"'){
2156 old_displayname=from->displayname;
2157 from->displayname=osip_enquote(from->displayname);
2159 osip_from_to_str(from,&tmp);
2160 if (old_displayname!=NULL){
2161 ms_free(from->displayname);
2162 from->displayname=old_displayname;
2169 char *sal_address_as_string_uri_only(const SalAddress *u){
2170 char *tmp=NULL,*ret;
2171 osip_uri_to_str(((osip_from_t*)u)->url,&tmp);
2176 void sal_address_set_param(SalAddress *u,const char* name,const char* value) {
2177 osip_uri_param_t *param=NULL;
2178 osip_uri_uparam_get_byname(((osip_from_t*)u)->url,(char*)name,¶m);
2180 osip_uri_uparam_add (((osip_from_t*)u)->url,ms_strdup(name),ms_strdup(value));
2182 osip_free(param->gvalue);
2183 param->gvalue=osip_strdup(value);
2188 void sal_address_destroy(SalAddress *u){
2189 osip_from_free((osip_from_t*)u);
2192 void sal_set_keepalive_period(Sal *ctx,unsigned int value) {
2193 ctx->keepalive_period=value;
2194 eXosip_set_option (EXOSIP_OPT_UDP_KEEP_ALIVE, &value);
2196 unsigned int sal_get_keepalive_period(Sal *ctx) {
2197 return ctx->keepalive_period;
2200 const char * sal_address_get_port(const SalAddress *addr) {
2201 const osip_from_t *u=(const osip_from_t*)addr;
2202 return null_if_empty(u->url->port);
2205 int sal_address_get_port_int(const SalAddress *uri) {
2206 const char* port = sal_address_get_port(uri);
2213 SalTransport sal_address_get_transport(const SalAddress* addr) {
2214 const osip_from_t *u=(const osip_from_t*)addr;
2215 osip_uri_param_t *transport_param=NULL;
2216 osip_uri_uparam_get_byname(u->url,"transport",&transport_param);
2217 if (transport_param == NULL){
2218 return SalTransportUDP;
2220 return sal_transport_parse(transport_param->gvalue);
2223 void sal_address_set_transport(SalAddress* addr,SalTransport transport) {
2224 sal_address_set_param(addr, "transport", sal_transport_to_string(transport));
2227 /* sends a reinvite. Local media description may have changed by application since call establishment*/
2228 int sal_call_update(SalOp *h, const char *subject){
2230 osip_message_t *reinvite=NULL;
2233 if(eXosip_call_build_request(h->did,"INVITE",&reinvite) != 0 || reinvite==NULL){
2238 osip_message_set_subject(reinvite,subject);
2239 osip_message_set_allow(reinvite, "INVITE, ACK, CANCEL, OPTIONS, BYE, REFER, NOTIFY, MESSAGE, SUBSCRIBE, INFO");
2240 if (h->base.root->session_expires!=0){
2241 osip_message_set_header(reinvite, "Session-expires", "200");
2242 osip_message_set_supported(reinvite, "timer");
2244 if (h->base.local_media){
2245 h->sdp_offering=TRUE;
2246 set_sdp_from_desc(reinvite,h->base.local_media);
2247 }else h->sdp_offering=FALSE;
2249 err = eXosip_call_send_request(h->did, reinvite);
2253 void sal_reuse_authorization(Sal *ctx, bool_t value) {
2254 ctx->reuse_authorization=value;