3 Copyright (C) 2010 Simon MORLAT (simon.morlat@free.fr)
5 This program is free software; you can redistribute it and/or
6 modify it under the terms of the GNU General Public License
7 as published by the Free Software Foundation; either version 2
8 of the License, or (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
23 #include "sal_eXosip2.h"
25 #include "offeranswer.h"
28 // Necessary to make it linked
29 static void for_linker() { eXosip_transport_hook_register(NULL); }
31 static bool_t call_failure(Sal *sal, eXosip_event_t *ev);
33 static void text_received(Sal *sal, eXosip_event_t *ev);
35 static void masquerade_via(osip_message_t *msg, const char *ip, const char *port);
36 static bool_t fix_message_contact(SalOp *op, osip_message_t *request,osip_message_t *last_answer);
37 static void update_contact_from_response(SalOp *op, osip_message_t *response);
39 void _osip_list_set_empty(osip_list_t *l, void (*freefunc)(void*)){
41 while(!osip_list_eol(l,0)) {
42 data=osip_list_get(l,0);
43 osip_list_remove(l,0);
44 if (data) freefunc(data);
48 void sal_get_default_local_ip(Sal *sal, int address_family,char *ip, size_t iplen){
49 if (eXosip_guess_localip(address_family,ip,iplen)<0){
50 /*default to something */
51 strncpy(ip,address_family==AF_INET6 ? "::1" : "127.0.0.1",iplen);
52 ms_error("Could not find default routable ip address !");
57 static SalOp * sal_find_call(Sal *sal, int cid){
60 for(elem=sal->calls;elem!=NULL;elem=elem->next){
61 op=(SalOp*)elem->data;
62 if (op->cid==cid) return op;
67 static void sal_add_call(Sal *sal, SalOp *op){
68 sal->calls=ms_list_append(sal->calls,op);
71 static void sal_remove_call(Sal *sal, SalOp *op){
72 sal->calls=ms_list_remove(sal->calls, op);
75 static SalOp * sal_find_register(Sal *sal, int rid){
78 for(elem=sal->registers;elem!=NULL;elem=elem->next){
79 op=(SalOp*)elem->data;
80 if (op->rid==rid) return op;
85 static void sal_add_register(Sal *sal, SalOp *op){
86 sal->registers=ms_list_append(sal->registers,op);
89 static void sal_remove_register(Sal *sal, int rid){
92 for(elem=sal->registers;elem!=NULL;elem=elem->next){
93 op=(SalOp*)elem->data;
95 sal->registers=ms_list_remove_link(sal->registers,elem);
101 static SalOp * sal_find_other(Sal *sal, osip_message_t *response){
104 osip_call_id_t *callid=osip_message_get_call_id(response);
106 ms_error("There is no call-id in this response !");
109 for(elem=sal->other_transactions;elem!=NULL;elem=elem->next){
110 op=(SalOp*)elem->data;
111 if (osip_call_id_match(callid,op->call_id)==0) return op;
116 void sal_add_other(Sal *sal, SalOp *op, osip_message_t *request){
117 osip_call_id_t *callid=osip_message_get_call_id(request);
119 ms_error("There is no call id in the request !");
122 osip_call_id_clone(callid,&op->call_id);
123 sal->other_transactions=ms_list_append(sal->other_transactions,op);
126 static void sal_remove_other(Sal *sal, SalOp *op){
127 sal->other_transactions=ms_list_remove(sal->other_transactions,op);
131 static void sal_add_pending_auth(Sal *sal, SalOp *op){
132 sal->pending_auths=ms_list_append(sal->pending_auths,op);
136 static void sal_remove_pending_auth(Sal *sal, SalOp *op){
137 sal->pending_auths=ms_list_remove(sal->pending_auths,op);
140 void sal_exosip_fix_route(SalOp *op){
141 if (sal_op_get_route(op)!=NULL){
142 osip_route_t *rt=NULL;
143 osip_uri_param_t *lr_param=NULL;
145 osip_route_init(&rt);
146 if (osip_route_parse(rt,sal_op_get_route(op))<0){
147 ms_warning("Bad route %s!",sal_op_get_route(op));
148 sal_op_set_route(op,NULL);
150 /* check if the lr parameter is set , if not add it */
151 osip_uri_uparam_get_byname(rt->url, "lr", &lr_param);
154 osip_uri_uparam_add(rt->url,osip_strdup("lr"),NULL);
155 osip_route_to_str(rt,&tmproute);
156 sal_op_set_route(op,tmproute);
164 SalOp * sal_op_new(Sal *sal){
165 SalOp *op=ms_new(SalOp,1);
166 __sal_op_init(op,sal);
167 op->cid=op->did=op->tid=op->rid=op->nid=op->sid=-1;
169 op->supports_session_timers=FALSE;
170 op->sdp_offering=TRUE;
171 op->pending_auth=NULL;
176 op->referred_by=NULL;
177 op->masquerade_via=FALSE;
178 op->auto_answer_asked=FALSE;
180 op->terminated=FALSE;
184 bool_t sal_call_autoanswer_asked(SalOp *op)
186 return op->auto_answer_asked;
189 void sal_op_release(SalOp *op){
191 sdp_message_free(op->sdp_answer);
192 if (op->pending_auth)
193 eXosip_event_free(op->pending_auth);
195 sal_remove_register(op->base.root,op->rid);
196 eXosip_register_remove(op->rid);
199 ms_message("Cleaning cid %i",op->cid);
200 sal_remove_call(op->base.root,op);
203 sal_remove_out_subscribe(op->base.root,op);
206 sal_remove_in_subscribe(op->base.root,op);
208 osip_call_id_free(op->call_id);
211 if (op->pending_auth){
212 sal_remove_pending_auth(op->base.root,op);
215 sal_media_description_unref(op->result);
217 sal_remove_other(op->base.root,op);
218 osip_call_id_free(op->call_id);
221 ms_free(op->replaces);
223 if (op->referred_by){
224 ms_free(op->referred_by);
227 sal_auth_info_delete(op->auth_info);
232 static void _osip_trace_func(char *fi, int li, osip_trace_level_t level, char *chfr, va_list ap){
233 int ortp_level=ORTP_DEBUG;
239 ortp_level=ORTP_MESSAGE;
242 ortp_level=ORTP_WARNING;
246 ortp_level=ORTP_ERROR;
249 ortp_level=ORTP_FATAL;
251 case END_TRACE_LEVEL:
254 if (ortp_log_level_enabled(level)){
255 int len=strlen(chfr);
256 char *chfrdup=ortp_strdup(chfr);
257 /*need to remove endline*/
259 if (chfrdup[len-1]=='\n')
261 if (chfrdup[len-2]=='\r')
264 ortp_logv(ortp_level,chfrdup,ap);
271 static bool_t firsttime=TRUE;
274 osip_trace_initialize_func (OSIP_INFO4,&_osip_trace_func);
279 sal->keepalive_period=30;
280 sal->double_reg=TRUE;
281 sal->use_rports=TRUE;
283 sal->reuse_authorization=FALSE;
285 sal->verify_server_certs=TRUE;
289 void sal_uninit(Sal* sal){
292 ms_free(sal->rootCa);
296 void sal_set_user_pointer(Sal *sal, void *user_data){
300 void *sal_get_user_pointer(const Sal *sal){
304 static void unimplemented_stub(){
305 ms_warning("Unimplemented SAL callback");
308 void sal_set_callbacks(Sal *ctx, const SalCallbacks *cbs){
309 memcpy(&ctx->callbacks,cbs,sizeof(*cbs));
310 if (ctx->callbacks.call_received==NULL)
311 ctx->callbacks.call_received=(SalOnCallReceived)unimplemented_stub;
312 if (ctx->callbacks.call_ringing==NULL)
313 ctx->callbacks.call_ringing=(SalOnCallRinging)unimplemented_stub;
314 if (ctx->callbacks.call_accepted==NULL)
315 ctx->callbacks.call_accepted=(SalOnCallAccepted)unimplemented_stub;
316 if (ctx->callbacks.call_failure==NULL)
317 ctx->callbacks.call_failure=(SalOnCallFailure)unimplemented_stub;
318 if (ctx->callbacks.call_terminated==NULL)
319 ctx->callbacks.call_terminated=(SalOnCallTerminated)unimplemented_stub;
320 if (ctx->callbacks.call_released==NULL)
321 ctx->callbacks.call_released=(SalOnCallReleased)unimplemented_stub;
322 if (ctx->callbacks.call_updating==NULL)
323 ctx->callbacks.call_updating=(SalOnCallUpdating)unimplemented_stub;
324 if (ctx->callbacks.auth_requested==NULL)
325 ctx->callbacks.auth_requested=(SalOnAuthRequested)unimplemented_stub;
326 if (ctx->callbacks.auth_success==NULL)
327 ctx->callbacks.auth_success=(SalOnAuthSuccess)unimplemented_stub;
328 if (ctx->callbacks.register_success==NULL)
329 ctx->callbacks.register_success=(SalOnRegisterSuccess)unimplemented_stub;
330 if (ctx->callbacks.register_failure==NULL)
331 ctx->callbacks.register_failure=(SalOnRegisterFailure)unimplemented_stub;
332 if (ctx->callbacks.dtmf_received==NULL)
333 ctx->callbacks.dtmf_received=(SalOnDtmfReceived)unimplemented_stub;
334 if (ctx->callbacks.notify==NULL)
335 ctx->callbacks.notify=(SalOnNotify)unimplemented_stub;
336 if (ctx->callbacks.notify_presence==NULL)
337 ctx->callbacks.notify_presence=(SalOnNotifyPresence)unimplemented_stub;
338 if (ctx->callbacks.subscribe_received==NULL)
339 ctx->callbacks.subscribe_received=(SalOnSubscribeReceived)unimplemented_stub;
340 if (ctx->callbacks.text_received==NULL)
341 ctx->callbacks.text_received=(SalOnTextReceived)unimplemented_stub;
342 if (ctx->callbacks.ping_reply==NULL)
343 ctx->callbacks.ping_reply=(SalOnPingReply)unimplemented_stub;
346 int sal_unlisten_ports(Sal *ctx){
355 int sal_listen_port(Sal *ctx, const char *addr, int port, SalTransport tr, int is_secure){
358 int proto=IPPROTO_UDP;
359 int keepalive = ctx->keepalive_period;
362 case SalTransportUDP:
364 eXosip_set_option (EXOSIP_OPT_UDP_KEEP_ALIVE, &keepalive);
366 case SalTransportTCP:
367 case SalTransportTLS:
370 eXosip_set_option (EXOSIP_OPT_UDP_KEEP_ALIVE,&keepalive);
373 eXosip_tls_ctx_t tlsCtx;
374 memset(&tlsCtx, 0, sizeof(tlsCtx));
375 snprintf(tlsCtx.root_ca_cert, sizeof(tlsCtx.client.cert), "%s", ctx->rootCa);
376 eXosip_set_tls_ctx(&tlsCtx);
378 #ifdef HAVE_EXOSIP_TLS_VERIFY_CERTIFICATE
379 eXosip_tls_verify_certificate(ctx->verify_server_certs);
383 ms_warning("unexpected proto, using datagram");
385 /*see if it looks like an IPv6 address*/
386 int use_rports = ctx->use_rports; // Copy char to int to avoid bad alignment
387 eXosip_set_option(EXOSIP_OPT_USE_RPORT,&use_rports);
388 int dont_use_101 = !ctx->use_101; // Copy char to int to avoid bad alignment
389 eXosip_set_option(EXOSIP_OPT_DONT_SEND_101,&dont_use_101);
391 ipv6=strchr(addr,':')!=NULL;
392 eXosip_enable_ipv6(ipv6);
394 if (is_secure && tr == SalTransportUDP){
395 ms_fatal("SIP over DTLS is not supported yet.");
398 err=eXosip_listen_addr(proto, addr, port, ipv6 ? PF_INET6 : PF_INET, is_secure);
403 ortp_socket_t sal_get_socket(Sal *ctx){
404 #ifdef HAVE_EXOSIP_GET_SOCKET
405 return eXosip_get_socket(IPPROTO_UDP);
407 ms_warning("Sorry, eXosip does not have eXosip_get_socket() method");
412 void sal_set_user_agent(Sal *ctx, const char *user_agent){
413 eXosip_set_user_agent(user_agent);
416 void sal_use_session_timers(Sal *ctx, int expires){
417 ctx->session_expires=expires;
420 void sal_use_one_matching_codec_policy(Sal *ctx, bool_t one_matching_codec){
421 ctx->one_matching_codec=one_matching_codec;
424 MSList *sal_get_pending_auths(Sal *sal){
425 return ms_list_copy(sal->pending_auths);
428 void sal_use_double_registrations(Sal *ctx, bool_t enabled){
429 ctx->double_reg=enabled;
432 void sal_use_rport(Sal *ctx, bool_t use_rports){
433 ctx->use_rports=use_rports;
435 void sal_use_101(Sal *ctx, bool_t use_101){
436 ctx->use_101=use_101;
439 void sal_set_root_ca(Sal* ctx, const char* rootCa) {
441 ms_free(ctx->rootCa);
442 ctx->rootCa = ms_strdup(rootCa);
445 void sal_verify_server_certificates(Sal *ctx, bool_t verify){
446 ctx->verify_server_certs=verify;
447 #ifdef HAVE_EXOSIP_TLS_VERIFY_CERTIFICATE
448 eXosip_tls_verify_certificate(verify);
452 static int extract_received_rport(osip_message_t *msg, const char **received, int *rportval,SalTransport* transport){
453 osip_via_t *via=NULL;
454 osip_generic_param_t *param=NULL;
455 const char *rport=NULL;
459 osip_message_get_via(msg,0,&via);
461 ms_warning("extract_received_rport(): no via.");
465 *transport = sal_transport_parse(via->protocol);
467 if (via->port && via->port[0]!='\0')
468 *rportval=atoi(via->port);
470 osip_via_param_get_byname(via,"rport",¶m);
473 if (rport && rport[0]!='\0') *rportval=atoi(rport);
477 osip_via_param_get_byname(via,"received",¶m);
478 if (param) *received=param->gvalue;
480 if (rport==NULL && *received==NULL){
481 ms_warning("extract_received_rport(): no rport and no received parameters.");
487 static void set_sdp(osip_message_t *sip,sdp_message_t *msg){
491 sdp_message_to_str(msg,&sdp);
493 snprintf(clen,sizeof(clen),"%i",sdplen);
494 osip_message_set_body(sip,sdp,sdplen);
495 osip_message_set_content_type(sip,"application/sdp");
496 osip_message_set_content_length(sip,clen);
500 static void set_sdp_from_desc(osip_message_t *sip, const SalMediaDescription *desc){
501 sdp_message_t *msg=media_description_to_sdp(desc);
503 ms_error("Fail to print sdp message !");
507 sdp_message_free(msg);
510 static void sdp_process(SalOp *h){
511 ms_message("Doing SDP offer/answer process of type %s",h->sdp_offering ? "outgoing" : "incoming");
513 sal_media_description_unref(h->result);
515 h->result=sal_media_description_new();
516 if (h->sdp_offering){
517 offer_answer_initiate_outgoing(h->base.local_media,h->base.remote_media,h->result);
521 sdp_message_free(h->sdp_answer);
523 offer_answer_initiate_incoming(h->base.local_media,h->base.remote_media,h->result,h->base.root->one_matching_codec);
524 h->sdp_answer=media_description_to_sdp(h->result);
525 /*once we have generated the SDP answer, we modify the result description for processing by the upper layer.
526 It should contains media parameters constraint from the remote offer, not our response*/
527 strcpy(h->result->addr,h->base.remote_media->addr);
528 h->result->bandwidth=h->base.remote_media->bandwidth;
530 for(i=0;i<h->result->nstreams;++i){
531 if (h->result->streams[i].port>0){
532 strcpy(h->result->streams[i].addr,h->base.remote_media->streams[i].addr);
533 h->result->streams[i].ptime=h->base.remote_media->streams[i].ptime;
534 h->result->streams[i].bandwidth=h->base.remote_media->streams[i].bandwidth;
535 h->result->streams[i].port=h->base.remote_media->streams[i].port;
537 if (h->result->streams[i].proto == SalProtoRtpSavp) {
538 h->result->streams[i].crypto[0] = h->base.remote_media->streams[i].crypto[0];
546 int sal_call_is_offerer(const SalOp *h){
547 return h->sdp_offering;
550 int sal_call_set_local_media_description(SalOp *h, SalMediaDescription *desc){
552 sal_media_description_ref(desc);
553 if (h->base.local_media)
554 sal_media_description_unref(h->base.local_media);
555 h->base.local_media=desc;
556 if (h->base.remote_media){
557 /*case of an incoming call where we modify the local capabilities between the time
558 * the call is ringing and it is accepted (for example if you want to accept without video*/
559 /*reset the sdp answer so that it is computed again*/
561 sdp_message_free(h->sdp_answer);
568 int sal_call(SalOp *h, const char *from, const char *to){
571 osip_message_t *invite=NULL;
572 sal_op_set_from(h,from);
574 sal_exosip_fix_route(h);
576 h->terminated = FALSE;
578 route = sal_op_get_route(h);
579 err=eXosip_call_build_initial_invite(&invite,to,from,route,"Phone call");
581 ms_error("Could not create call. Error %d (from=%s to=%s route=%s)",
582 err, from, to, route);
585 osip_message_set_allow(invite, "INVITE, ACK, CANCEL, OPTIONS, BYE, REFER, NOTIFY, MESSAGE, SUBSCRIBE, INFO");
586 if (h->base.contact){
587 _osip_list_set_empty(&invite->contacts,(void (*)(void*))osip_contact_free);
588 osip_message_set_contact(invite,h->base.contact);
590 if (h->base.root->session_expires!=0){
591 osip_message_set_header(invite, "Session-expires", "200");
592 osip_message_set_supported(invite, "timer");
594 if (h->base.local_media){
595 h->sdp_offering=TRUE;
596 set_sdp_from_desc(invite,h->base.local_media);
597 }else h->sdp_offering=FALSE;
599 osip_message_set_header(invite,"Replaces",h->replaces);
601 osip_message_set_header(invite,"Referred-By",h->referred_by);
605 err=eXosip_call_send_initial_invite(invite);
609 ms_error("Fail to send invite ! Error code %d", err);
612 sal_add_call(h->base.root,h);
617 int sal_call_notify_ringing(SalOp *h, bool_t early_media){
620 /*if early media send also 180 and 183 */
624 eXosip_call_build_answer(h->tid,183,&msg);
628 set_sdp(msg,h->sdp_answer);
629 sdp_message_free(h->sdp_answer);
632 eXosip_call_send_answer(h->tid,183,msg);
637 eXosip_call_send_answer(h->tid,180,NULL);
643 int sal_call_accept(SalOp * h){
645 const char *contact=sal_op_get_contact(h);
647 int err=eXosip_call_build_answer(h->tid,200,&msg);
648 if (err<0 || msg==NULL){
649 ms_error("Fail to build answer for call: err=%i",err);
652 if (h->base.root->session_expires!=0){
653 if (h->supports_session_timers) osip_message_set_supported(msg, "timer");
657 _osip_list_set_empty(&msg->contacts,(void (*)(void*))osip_contact_free);
658 osip_message_set_contact(msg,contact);
661 if (h->base.local_media){
662 /*this is the case where we received an invite without SDP*/
663 if (h->sdp_offering) {
664 set_sdp_from_desc(msg,h->base.local_media);
666 if (h->sdp_answer==NULL) sdp_process(h);
668 set_sdp(msg,h->sdp_answer);
669 sdp_message_free(h->sdp_answer);
674 ms_error("You are accepting a call but not defined any media capabilities !");
676 eXosip_call_send_answer(h->tid,200,msg);
680 int sal_call_decline(SalOp *h, SalReason reason, const char *redirect){
681 if (reason==SalReasonBusy){
683 eXosip_call_send_answer(h->tid,486,NULL);
686 else if (reason==SalReasonTemporarilyUnavailable){
688 eXosip_call_send_answer(h->tid,480,NULL);
690 }else if (reason==SalReasonDoNotDisturb){
692 eXosip_call_send_answer(h->tid,600,NULL);
694 }else if (reason==SalReasonMedia){
696 eXosip_call_send_answer(h->tid,415,NULL);
698 }else if (redirect!=NULL && reason==SalReasonRedirect){
701 if (strstr(redirect,"sip:")!=0) code=302;
704 eXosip_call_build_answer(h->tid,code,&msg);
705 osip_message_set_contact(msg,redirect);
706 eXosip_call_send_answer(h->tid,code,msg);
708 }else sal_call_terminate(h);
712 SalMediaDescription * sal_call_get_remote_media_description(SalOp *h){
713 return h->base.remote_media;
716 SalMediaDescription * sal_call_get_final_media_description(SalOp *h){
717 if (h->base.local_media && h->base.remote_media && !h->result){
723 int sal_call_set_referer(SalOp *h, SalOp *refered_call){
724 if (refered_call->replaces)
725 h->replaces=ms_strdup(refered_call->replaces);
726 if (refered_call->referred_by)
727 h->referred_by=ms_strdup(refered_call->referred_by);
731 static int send_notify_for_refer(int did, const char *sipfrag){
734 eXosip_call_build_notify(did,EXOSIP_SUBCRSTATE_ACTIVE,&msg);
737 ms_warning("Could not build NOTIFY for refer.");
740 osip_message_set_content_type(msg,"message/sipfrag");
741 osip_message_set_header(msg,"Event","refer");
742 osip_message_set_body(msg,sipfrag,strlen(sipfrag));
743 eXosip_call_send_request(did,msg);
748 /* currently only support to notify trying and 200Ok*/
749 int sal_call_notify_refer_state(SalOp *h, SalOp *newcall){
752 send_notify_for_refer(h->did,"SIP/2.0 100 Trying\r\n");
754 else if (newcall->cid!=-1){
755 if (newcall->did==-1){
756 /* not yet established*/
757 if (!newcall->terminated){
759 send_notify_for_refer(h->did,"SIP/2.0 100 Trying\r\n");
762 if (!newcall->terminated){
763 if (send_notify_for_refer(h->did,"SIP/2.0 200 Ok\r\n")==-1){
764 /* we need previous notify transaction to complete, so buffer the request for later*/
765 h->sipfrag_pending="SIP/2.0 200 Ok\r\n";
773 int sal_ping(SalOp *op, const char *from, const char *to){
774 osip_message_t *options=NULL;
776 sal_op_set_from(op,from);
777 sal_op_set_to(op,to);
778 sal_exosip_fix_route(op);
780 eXosip_options_build_request (&options, sal_op_get_to(op),
781 sal_op_get_from(op),sal_op_get_route(op));
783 if (op->base.root->session_expires!=0){
784 osip_message_set_header(options, "Session-expires", "200");
785 osip_message_set_supported(options, "timer");
787 sal_add_other(sal_op_get_sal(op),op,options);
788 return eXosip_options_send_request(options);
793 int sal_call_refer(SalOp *h, const char *refer_to){
794 osip_message_t *msg=NULL;
797 eXosip_call_build_refer(h->did,refer_to, &msg);
798 if (msg) err=eXosip_call_send_request(h->did, msg);
804 int sal_call_refer_with_replaces(SalOp *h, SalOp *other_call_h){
805 osip_message_t *msg=NULL;
806 char referto[256]={0};
809 if (eXosip_call_get_referto(other_call_h->did,referto,sizeof(referto)-1)!=0){
810 ms_error("eXosip_call_get_referto() failed for did=%i",other_call_h->did);
814 eXosip_call_build_refer(h->did,referto, &msg);
815 osip_message_set_header(msg,"Referred-By",h->base.from);
816 if (msg) err=eXosip_call_send_request(h->did, msg);
822 SalOp *sal_call_get_replaces(SalOp *h){
823 if (h!=NULL && h->replaces!=NULL){
826 cid=eXosip_call_find_by_replaces(h->replaces);
829 SalOp *ret=sal_find_call(h->base.root,cid);
836 int sal_call_send_dtmf(SalOp *h, char dtmf){
837 osip_message_t *msg=NULL;
842 eXosip_call_build_info(h->did,&msg);
844 snprintf(dtmf_body, sizeof(dtmf_body), "Signal=%c\r\nDuration=250\r\n", dtmf);
845 osip_message_set_body(msg,dtmf_body,strlen(dtmf_body));
846 osip_message_set_content_type(msg,"application/dtmf-relay");
847 snprintf(clen,sizeof(clen),"%lu",(unsigned long)strlen(dtmf_body));
848 osip_message_set_content_length(msg,clen);
849 eXosip_call_send_request(h->did,msg);
855 static void push_auth_to_exosip(const SalAuthInfo *info){
857 if (info->userid==NULL || info->userid[0]=='\0') userid=info->username;
858 else userid=info->userid;
859 ms_message("Authentication info for username [%s], id[%s], realm [%s] added to eXosip", info->username,userid, info->realm);
860 eXosip_add_authentication_info (info->username,userid,
861 info->password, NULL,info->realm);
864 * Just for symmetry ;-)
866 static void pop_auth_from_exosip() {
867 eXosip_clear_authentication_info();
870 int sal_call_terminate(SalOp *h){
872 if (h == NULL) return -1;
873 if (h->auth_info) push_auth_to_exosip(h->auth_info);
875 err=eXosip_call_terminate(h->cid,h->did);
877 if (!h->base.root->reuse_authorization) pop_auth_from_exosip();
879 ms_warning("Exosip could not terminate the call: cid=%i did=%i", h->cid,h->did);
885 void sal_op_authenticate(SalOp *h, const SalAuthInfo *info){
886 if (h->terminated) return;
887 if (h->pending_auth){
888 push_auth_to_exosip(info);
890 /*FIXME exosip does not take into account this update register message*/
892 if (fix_message_contact(h, h->pending_auth->request,h->pending_auth->response)) {
896 update_contact_from_response(h,h->pending_auth->response);
898 eXosip_default_action(h->pending_auth);
900 ms_message("eXosip_default_action() done");
901 if (!h->base.root->reuse_authorization) pop_auth_from_exosip();
903 if (h->auth_info) sal_auth_info_delete(h->auth_info); /*if already exist*/
904 h->auth_info=sal_auth_info_clone(info); /*store auth info for subsequent request*/
907 void sal_op_cancel_authentication(SalOp *h) {
909 sal_op_get_sal(h)->callbacks.register_failure(h,SalErrorFailure, SalReasonForbidden,_("Authentication failure"));
910 } else if (h->cid >0) {
911 sal_op_get_sal(h)->callbacks.call_failure(h,SalErrorFailure, SalReasonForbidden,_("Authentication failure"),0);
913 ms_warning("Auth failure not handled");
917 static void set_network_origin(SalOp *op, osip_message_t *req){
918 const char *received=NULL;
921 SalTransport transport;
922 if (extract_received_rport(req,&received,&rport,&transport)!=0){
923 osip_via_t *via=NULL;
925 osip_message_get_via(req,0,&via);
926 received=osip_via_get_host(via);
927 tmp=osip_via_get_port(via);
928 if (tmp) rport=atoi(tmp);
930 if (transport != SalTransportUDP) {
931 snprintf(origin,sizeof(origin)-1,"sip:%s:%i",received,rport);
933 snprintf(origin,sizeof(origin)-1,"sip:%s:%i;transport=%s",received,rport,sal_transport_to_string(transport));
935 __sal_op_set_network_origin(op,origin);
938 static void set_remote_ua(SalOp* op, osip_message_t *req){
939 if (op->base.remote_ua==NULL){
940 osip_header_t *h=NULL;
941 osip_message_get_user_agent(req,0,&h);
943 op->base.remote_ua=ms_strdup(h->hvalue);
948 static void set_replaces(SalOp *op, osip_message_t *req){
949 osip_header_t *h=NULL;
952 ms_free(op->replaces);
955 osip_message_header_get_byname(req,"replaces",0,&h);
957 if (h->hvalue && h->hvalue[0]!='\0'){
958 op->replaces=ms_strdup(h->hvalue);
963 static SalOp *find_op(Sal *sal, eXosip_event_t *ev){
965 return sal_find_call(sal,ev->cid);
968 return sal_find_register(sal,ev->rid);
971 return sal_find_out_subscribe(sal,ev->sid);
974 return sal_find_in_subscribe(sal,ev->nid);
976 if (ev->response) return sal_find_other(sal,ev->response);
980 static void inc_new_call(Sal *sal, eXosip_event_t *ev){
981 SalOp *op=sal_op_new(sal);
982 osip_from_t *from,*to;
983 osip_call_info_t *call_info;
985 sdp_message_t *sdp=eXosip_get_sdp_info(ev->request);
987 set_network_origin(op,ev->request);
988 set_remote_ua(op,ev->request);
989 set_replaces(op,ev->request);
992 op->sdp_offering=FALSE;
993 op->base.remote_media=sal_media_description_new();
994 sdp_to_media_description(sdp,op->base.remote_media);
995 sdp_message_free(sdp);
996 }else op->sdp_offering=TRUE;
998 from=osip_message_get_from(ev->request);
999 to=osip_message_get_to(ev->request);
1000 osip_from_to_str(from,&tmp);
1001 sal_op_set_from(op,tmp);
1003 osip_from_to_str(to,&tmp);
1004 sal_op_set_to(op,tmp);
1007 osip_message_get_call_info(ev->request,0,&call_info);
1010 osip_call_info_to_str(call_info,&tmp);
1011 if( strstr(tmp,"answer-after=") != NULL)
1013 op->auto_answer_asked=TRUE;
1014 ms_message("The caller asked to automatically answer the call(Emergency?)\n");
1023 sal_add_call(op->base.root,op);
1024 sal->callbacks.call_received(op);
1027 static void handle_reinvite(Sal *sal, eXosip_event_t *ev){
1028 SalOp *op=find_op(sal,ev);
1032 ms_warning("Reinvite for non-existing operation !");
1037 sdp=eXosip_get_sdp_info(ev->request);
1038 if (op->base.remote_media){
1039 sal_media_description_unref(op->base.remote_media);
1040 op->base.remote_media=NULL;
1043 sal_media_description_unref(op->result);
1047 op->sdp_offering=FALSE;
1048 op->base.remote_media=sal_media_description_new();
1049 sdp_to_media_description(sdp,op->base.remote_media);
1050 sdp_message_free(sdp);
1053 op->sdp_offering=TRUE;
1055 sal->callbacks.call_updating(op);
1058 static void handle_ack(Sal *sal, eXosip_event_t *ev){
1059 SalOp *op=find_op(sal,ev);
1063 ms_warning("ack for non-existing call !");
1066 if (op->terminated) {
1067 ms_warning("ack for terminated call, ignoring");
1071 if (op->sdp_offering){
1072 sdp=eXosip_get_sdp_info(ev->ack);
1074 if (op->base.remote_media)
1075 sal_media_description_unref(op->base.remote_media);
1076 op->base.remote_media=sal_media_description_new();
1077 sdp_to_media_description(sdp,op->base.remote_media);
1079 sdp_message_free(sdp);
1085 sal->callbacks.call_ack(op);
1088 static void update_contact_from_response(SalOp *op, osip_message_t *response){
1089 const char *received;
1091 SalTransport transport;
1092 if (extract_received_rport(response,&received,&rport,&transport)==0){
1093 const char *contact=sal_op_get_contact(op);
1095 /*no contact given yet, use from instead*/
1096 contact=sal_op_get_from(op);
1099 SalAddress *addr=sal_address_new(contact);
1101 sal_address_set_domain(addr,received);
1102 sal_address_set_port_int(addr,rport);
1103 if (transport!=SalTransportUDP)
1104 sal_address_set_transport(addr,transport);
1105 tmp=sal_address_as_string(addr);
1106 ms_message("Contact address updated to %s",tmp);
1107 sal_op_set_contact(op,tmp);
1108 sal_address_destroy(addr);
1114 static int call_proceeding(Sal *sal, eXosip_event_t *ev){
1115 SalOp *op=find_op(sal,ev);
1117 if (op==NULL || op->terminated==TRUE) {
1118 ms_warning("This call has been canceled.");
1120 eXosip_call_terminate(ev->cid,ev->did);
1128 /* update contact if received and rport are set by the server
1129 note: will only be used by remote for next INVITE, if any...*/
1130 update_contact_from_response(op,ev->response);
1134 static void call_ringing(Sal *sal, eXosip_event_t *ev){
1136 SalOp *op=find_op(sal,ev);
1137 if (call_proceeding(sal, ev)==-1) return;
1139 set_remote_ua(op,ev->response);
1140 sdp=eXosip_get_sdp_info(ev->response);
1142 op->base.remote_media=sal_media_description_new();
1143 sdp_to_media_description(sdp,op->base.remote_media);
1144 sdp_message_free(sdp);
1145 if (op->base.local_media) sdp_process(op);
1147 sal->callbacks.call_ringing(op);
1150 static void call_accepted(Sal *sal, eXosip_event_t *ev){
1152 osip_message_t *msg=NULL;
1153 SalOp *op=find_op(sal,ev);
1154 const char *contact;
1156 if (op==NULL || op->terminated==TRUE) {
1157 ms_warning("This call has been already terminated.");
1159 eXosip_call_terminate(ev->cid,ev->did);
1165 set_remote_ua(op,ev->response);
1167 sdp=eXosip_get_sdp_info(ev->response);
1169 op->base.remote_media=sal_media_description_new();
1170 sdp_to_media_description(sdp,op->base.remote_media);
1171 sdp_message_free(sdp);
1172 if (op->base.local_media) sdp_process(op);
1174 eXosip_call_build_ack(ev->did,&msg);
1176 ms_warning("This call has been already terminated.");
1178 eXosip_call_terminate(ev->cid,ev->did);
1182 contact=sal_op_get_contact(op);
1184 _osip_list_set_empty(&msg->contacts,(void (*)(void*))osip_contact_free);
1185 osip_message_set_contact(msg,contact);
1187 if (op->sdp_answer){
1188 set_sdp(msg,op->sdp_answer);
1189 sdp_message_free(op->sdp_answer);
1190 op->sdp_answer=NULL;
1192 eXosip_call_send_ack(ev->did,msg);
1193 sal->callbacks.call_accepted(op);
1196 static void call_terminated(Sal *sal, eXosip_event_t *ev){
1198 SalOp *op=find_op(sal,ev);
1200 ms_warning("Call terminated for already closed call ?");
1204 osip_from_to_str(ev->request->from,&from);
1206 sal->callbacks.call_terminated(op,from!=NULL ? from : sal_op_get_from(op));
1207 if (from) osip_free(from);
1208 op->terminated=TRUE;
1211 static void call_released(Sal *sal, eXosip_event_t *ev){
1212 SalOp *op=find_op(sal,ev);
1214 ms_warning("No op associated to this call_released()");
1217 if (!op->terminated){
1218 /* no response received so far */
1219 call_failure(sal,ev);
1221 sal->callbacks.call_released(op);
1224 static int get_auth_data_from_response(osip_message_t *resp, const char **realm, const char **username){
1225 const char *prx_realm=NULL,*www_realm=NULL;
1226 osip_proxy_authenticate_t *prx_auth;
1227 osip_www_authenticate_t *www_auth;
1229 *username=osip_uri_get_username(resp->from->url);
1230 prx_auth=(osip_proxy_authenticate_t*)osip_list_get(&resp->proxy_authenticates,0);
1231 www_auth=(osip_proxy_authenticate_t*)osip_list_get(&resp->www_authenticates,0);
1233 prx_realm=osip_proxy_authenticate_get_realm(prx_auth);
1235 www_realm=osip_www_authenticate_get_realm(www_auth);
1239 }else if (www_realm){
1247 static int get_auth_data_from_request(osip_message_t *msg, const char **realm, const char **username){
1248 osip_authorization_t *auth=NULL;
1249 osip_proxy_authorization_t *prx_auth=NULL;
1251 *username=osip_uri_get_username(msg->from->url);
1252 osip_message_get_authorization(msg, 0, &auth);
1254 *realm=osip_authorization_get_realm(auth);
1257 osip_message_get_proxy_authorization(msg,0,&prx_auth);
1259 *realm=osip_proxy_authorization_get_realm(prx_auth);
1265 static int get_auth_data(eXosip_event_t *ev, const char **realm, const char **username){
1266 if (ev->response && get_auth_data_from_response(ev->response,realm,username)==0) return 0;
1267 if (ev->request && get_auth_data_from_request(ev->request,realm,username)==0) return 0;
1271 int sal_op_get_auth_requested(SalOp *op, const char **realm, const char **username){
1272 if (op->pending_auth){
1273 return get_auth_data(op->pending_auth,realm,username);
1278 static bool_t process_authentication(Sal *sal, eXosip_event_t *ev){
1280 const char *username,*realm;
1283 ms_warning("No operation associated with this authentication !");
1286 if (get_auth_data(ev,&realm,&username)==0){
1287 if (op->pending_auth!=NULL){
1288 eXosip_event_free(op->pending_auth);
1289 op->pending_auth=ev;
1291 op->pending_auth=ev;
1292 sal_add_pending_auth(sal,op);
1295 sal->callbacks.auth_requested(op,realm,username);
1301 static void authentication_ok(Sal *sal, eXosip_event_t *ev){
1303 const char *username,*realm;
1306 ms_warning("No operation associated with this authentication_ok!");
1309 if (op->pending_auth){
1310 eXosip_event_free(op->pending_auth);
1311 sal_remove_pending_auth(sal,op);
1312 op->pending_auth=NULL;
1314 if (get_auth_data(ev,&realm,&username)==0){
1315 sal->callbacks.auth_success(op,realm,username);
1319 static bool_t call_failure(Sal *sal, eXosip_event_t *ev){
1322 char* computedReason=NULL;
1323 const char *reason=NULL;
1324 SalError error=SalErrorUnknown;
1325 SalReason sr=SalReasonUnknown;
1328 op=(SalOp*)find_op(sal,ev);
1331 ms_warning("Call failure reported for a closed call, ignored.");
1336 code=osip_message_get_status_code(ev->response);
1337 reason=osip_message_get_reason_phrase(ev->response);
1338 osip_header_t *h=NULL;
1339 if (!osip_message_header_get_byname( ev->response
1343 computedReason = ms_strdup_printf("%s %s",reason,osip_header_get_value(h));
1344 reason = computedReason;
1352 return process_authentication(sal,ev);
1355 error=SalErrorUnknown;
1358 error=SalErrorFailure;
1359 sr=SalReasonNotFound;
1362 error=SalErrorFailure;
1366 eXosip_default_action(ev);
1370 error=SalErrorFailure;
1371 sr=SalReasonTemporarilyUnavailable;
1373 error=SalErrorFailure;
1379 error=SalErrorFailure;
1380 sr=SalReasonDoNotDisturb;
1383 error=SalErrorFailure;
1384 sr=SalReasonDeclined;
1388 error=SalErrorFailure;
1389 sr=SalReasonUnknown;
1390 }else error=SalErrorNoResponse;
1392 op->terminated=TRUE;
1393 sal->callbacks.call_failure(op,error,sr,reason,code);
1394 if (computedReason != NULL){
1395 ms_free(computedReason);
1400 /* Request remote side to send us VFU */
1401 void sal_call_send_vfu_request(SalOp *h){
1402 osip_message_t *msg=NULL;
1404 "<?xml version=\"1.0\" encoding=\"utf-8\" ?>"
1408 " <picture_fast_update></picture_fast_update>"
1416 eXosip_call_build_info(h->did,&msg);
1418 osip_message_set_body(msg,info_body,strlen(info_body));
1419 osip_message_set_content_type(msg,"application/media_control+xml");
1420 snprintf(clen,sizeof(clen),"%lu",(unsigned long)strlen(info_body));
1421 osip_message_set_content_length(msg,clen);
1422 eXosip_call_send_request(h->did,msg);
1423 ms_message("Sending VFU request !");
1428 static void process_media_control_xml(Sal *sal, eXosip_event_t *ev){
1429 SalOp *op=find_op(sal,ev);
1430 osip_body_t *body=NULL;
1433 ms_warning("media control xml received without operation context!");
1437 osip_message_get_body(ev->request,0,&body);
1438 if (body && body->body!=NULL &&
1439 strstr(body->body,"picture_fast_update")){
1440 osip_message_t *ans=NULL;
1441 ms_message("Receiving VFU request !");
1442 if (sal->callbacks.vfu_request){
1443 sal->callbacks.vfu_request(op);
1444 eXosip_call_build_answer(ev->tid,200,&ans);
1446 eXosip_call_send_answer(ev->tid,200,ans);
1450 /*in all other cases we must say it is not implemented.*/
1452 osip_message_t *ans=NULL;
1454 eXosip_call_build_answer(ev->tid,501,&ans);
1456 eXosip_call_send_answer(ev->tid,501,ans);
1461 static void process_dtmf_relay(Sal *sal, eXosip_event_t *ev){
1462 SalOp *op=find_op(sal,ev);
1463 osip_body_t *body=NULL;
1466 ms_warning("media dtmf relay received without operation context!");
1470 osip_message_get_body(ev->request,0,&body);
1471 if (body && body->body!=NULL){
1472 osip_message_t *ans=NULL;
1473 const char *name=strstr(body->body,"Signal");
1474 if (name==NULL) name=strstr(body->body,"signal");
1476 ms_warning("Could not extract the dtmf name from the SIP INFO.");
1479 name+=strlen("signal");
1480 if (sscanf(name," = %1s",tmp)==1){
1481 ms_message("Receiving dtmf %s via SIP INFO.",tmp);
1482 if (sal->callbacks.dtmf_received != NULL)
1483 sal->callbacks.dtmf_received(op, tmp[0]);
1487 eXosip_call_build_answer(ev->tid,200,&ans);
1489 eXosip_call_send_answer(ev->tid,200,ans);
1494 static void fill_options_answer(osip_message_t *options){
1495 osip_message_set_allow(options,"INVITE, ACK, BYE, CANCEL, OPTIONS, MESSAGE, SUBSCRIBE, NOTIFY, INFO");
1496 osip_message_set_accept(options,"application/sdp");
1499 static void process_refer(Sal *sal, SalOp *op, eXosip_event_t *ev){
1500 osip_header_t *h=NULL;
1501 osip_message_t *ans=NULL;
1502 ms_message("Receiving REFER request !");
1503 osip_message_header_get_byname(ev->request,"Refer-To",0,&h);
1506 osip_from_t *from=NULL;
1508 osip_from_init(&from);
1510 if (osip_from_parse(from,h->hvalue)==0){
1512 osip_uri_header_t *uh=NULL;
1513 osip_header_t *referred_by=NULL;
1514 osip_uri_header_get_byname(&from->url->url_headers,(char*)"Replaces",&uh);
1515 if (uh!=NULL && uh->gvalue && uh->gvalue[0]!='\0'){
1516 ms_message("Found replaces in Refer-To");
1518 ms_free(op->replaces);
1520 op->replaces=ms_strdup(uh->gvalue);
1522 osip_message_header_get_byname(ev->request,"Referred-By",0,&referred_by);
1523 if (referred_by && referred_by->hvalue && referred_by->hvalue[0]!='\0'){
1524 if (op->referred_by)
1525 ms_free(op->referred_by);
1526 op->referred_by=ms_strdup(referred_by->hvalue);
1529 osip_uri_header_freelist(&from->url->url_headers);
1530 osip_from_to_str(from,&tmp);
1531 sal->callbacks.refer_received(sal,op,tmp);
1533 osip_from_free(from);
1536 eXosip_call_build_answer(ev->tid,202,&ans);
1538 eXosip_call_send_answer(ev->tid,202,ans);
1543 ms_warning("cannot do anything with the refer without destination\n");
1547 static void process_notify(Sal *sal, eXosip_event_t *ev){
1548 osip_header_t *h=NULL;
1550 SalOp *op=find_op(sal,ev);
1551 osip_message_t *ans=NULL;
1553 ms_message("Receiving NOTIFY request !");
1554 osip_from_to_str(ev->request->from,&from);
1555 osip_message_header_get_byname(ev->request,"Event",0,&h);
1557 osip_body_t *body=NULL;
1558 //osip_content_type_t *ct=NULL;
1559 osip_message_get_body(ev->request,0,&body);
1560 //ct=osip_message_get_content_type(ev->request);
1561 if (h->hvalue && strcasecmp(h->hvalue,"refer")==0){
1562 /*special handling of refer events*/
1563 if (body && body->body){
1564 osip_message_t *msg;
1565 osip_message_init(&msg);
1566 if (osip_message_parse_sipfrag(msg,body->body,strlen(body->body))==0){
1567 int code=osip_message_get_status_code(msg);
1569 sal->callbacks.notify_refer(op,SalReferTrying);
1570 }else if (code==200){
1571 sal->callbacks.notify_refer(op,SalReferSuccess);
1572 }else if (code>=400){
1573 sal->callbacks.notify_refer(op,SalReferFailed);
1576 osip_message_free(msg);
1579 /*generic handling*/
1580 sal->callbacks.notify(op,from,h->hvalue);
1583 /*answer that we received the notify*/
1585 eXosip_call_build_answer(ev->tid,200,&ans);
1587 eXosip_call_send_answer(ev->tid,200,ans);
1592 static void call_message_new(Sal *sal, eXosip_event_t *ev){
1593 osip_message_t *ans=NULL;
1595 if (MSG_IS_INFO(ev->request)){
1596 osip_content_type_t *ct;
1597 ct=osip_message_get_content_type(ev->request);
1598 if (ct && ct->subtype){
1599 if (strcmp(ct->subtype,"media_control+xml")==0)
1600 process_media_control_xml(sal,ev);
1601 else if (strcmp(ct->subtype,"dtmf-relay")==0)
1602 process_dtmf_relay(sal,ev);
1604 ms_message("Unhandled SIP INFO.");
1605 /*send an "Not implemented" answer*/
1607 eXosip_call_build_answer(ev->tid,501,&ans);
1609 eXosip_call_send_answer(ev->tid,501,ans);
1613 /*empty SIP INFO, probably to test we are alive. Send an empty answer*/
1615 eXosip_call_build_answer(ev->tid,200,&ans);
1617 eXosip_call_send_answer(ev->tid,200,ans);
1620 }else if(MSG_IS_MESSAGE(ev->request)){
1621 /* SIP messages could be received into call */
1622 text_received(sal, ev);
1624 eXosip_call_build_answer(ev->tid,200,&ans);
1626 eXosip_call_send_answer(ev->tid,200,ans);
1628 }else if(MSG_IS_REFER(ev->request)){
1629 SalOp *op=find_op(sal,ev);
1631 ms_message("Receiving REFER request !");
1632 process_refer(sal,op,ev);
1633 }else if(MSG_IS_NOTIFY(ev->request)){
1634 process_notify(sal,ev);
1635 }else if (MSG_IS_OPTIONS(ev->request)){
1637 eXosip_call_build_answer(ev->tid,200,&ans);
1639 fill_options_answer(ans);
1640 eXosip_call_send_answer(ev->tid,200,ans);
1644 }else ms_warning("call_message_new: No request ?");
1647 static void inc_update(Sal *sal, eXosip_event_t *ev){
1648 osip_message_t *msg=NULL;
1649 ms_message("Processing incoming UPDATE");
1651 eXosip_message_build_answer(ev->tid,200,&msg);
1653 eXosip_message_send_answer(ev->tid,200,msg);
1657 static bool_t comes_from_local_if(osip_message_t *msg){
1658 osip_via_t *via=NULL;
1659 osip_message_get_via(msg,0,&via);
1662 host=osip_via_get_host(via);
1663 if (strcmp(host,"127.0.0.1")==0 || strcmp(host,"::1")==0){
1664 osip_generic_param_t *param=NULL;
1665 osip_via_param_get_byname(via,"received",¶m);
1666 if (param==NULL) return TRUE;
1667 if (param->gvalue &&
1668 (strcmp(param->gvalue,"127.0.0.1")==0 || strcmp(param->gvalue,"::1")==0)){
1676 static void text_received(Sal *sal, eXosip_event_t *ev){
1677 osip_body_t *body=NULL;
1678 char *from=NULL,*msg;
1680 osip_message_get_body(ev->request,0,&body);
1682 ms_error("Could not get text message from SIP body");
1686 osip_from_to_str(ev->request->from,&from);
1687 sal->callbacks.text_received(sal,from,msg);
1693 static void other_request(Sal *sal, eXosip_event_t *ev){
1694 ms_message("in other_request");
1695 if (ev->request==NULL) return;
1696 if (strcmp(ev->request->sip_method,"MESSAGE")==0){
1697 text_received(sal,ev);
1698 eXosip_message_send_answer(ev->tid,200,NULL);
1699 }else if (strcmp(ev->request->sip_method,"OPTIONS")==0){
1700 osip_message_t *options=NULL;
1701 eXosip_options_build_answer(ev->tid,200,&options);
1702 fill_options_answer(options);
1703 eXosip_options_send_answer(ev->tid,200,options);
1704 }else if (strncmp(ev->request->sip_method, "REFER", 5) == 0){
1705 ms_message("Receiving REFER request !");
1706 if (comes_from_local_if(ev->request)) {
1707 process_refer(sal,NULL,ev);
1708 }else ms_warning("Ignored REFER not coming from this local loopback interface.");
1709 }else if (strncmp(ev->request->sip_method, "UPDATE", 6) == 0){
1714 osip_message_to_str(ev->request,&tmp,&msglen);
1716 ms_message("Unsupported request received:\n%s",tmp);
1719 /*answer with a 501 Not implemented*/
1720 eXosip_message_send_answer(ev->tid,501,NULL);
1724 static void masquerade_via(osip_message_t *msg, const char *ip, const char *port){
1725 osip_via_t *via=NULL;
1726 osip_message_get_via(msg,0,&via);
1728 osip_free(via->port);
1729 via->port=osip_strdup(port);
1730 osip_free(via->host);
1731 via->host=osip_strdup(ip);
1736 static bool_t fix_message_contact(SalOp *op, osip_message_t *request,osip_message_t *last_answer) {
1737 osip_contact_t *ctt=NULL;
1738 const char *received;
1740 SalTransport transport;
1743 if (extract_received_rport(last_answer,&received,&rport,&transport)==-1) return FALSE;
1744 osip_message_get_contact(request,0,&ctt);
1746 ms_warning("fix_message_contact(): no contact to update");
1749 if (ctt->url->host!=NULL){
1750 osip_free(ctt->url->host);
1752 ctt->url->host=osip_strdup(received);
1753 if (ctt->url->port!=NULL){
1754 osip_free(ctt->url->port);
1756 snprintf(port,sizeof(port),"%i",rport);
1757 ctt->url->port=osip_strdup(port);
1758 if (op->masquerade_via) masquerade_via(request,received,port);
1760 if (transport != SalTransportUDP) {
1761 sal_address_set_param((SalAddress *)ctt, "transport", sal_transport_to_string(transport));
1766 static bool_t register_again_with_updated_contact(SalOp *op, osip_message_t *orig_request, osip_message_t *last_answer){
1767 osip_contact_t *ctt=NULL;
1768 SalAddress* ori_contact_address=NULL;
1769 const char *received;
1771 SalTransport transport;
1773 osip_message_t *msg=NULL;
1774 Sal* sal=op->base.root;
1776 if (sal->double_reg==FALSE ) return FALSE;
1778 if (extract_received_rport(last_answer,&received,&rport,&transport)==-1) return FALSE;
1779 osip_message_get_contact(orig_request,0,&ctt);
1780 osip_contact_to_str(ctt,&tmp);
1781 ori_contact_address = sal_address_new(tmp);
1783 /*check if contact is up to date*/
1784 if (strcmp(sal_address_get_domain(ori_contact_address),received) ==0
1785 && sal_address_get_port_int(ori_contact_address) == rport
1786 && sal_address_get_transport(ori_contact_address) == transport) {
1787 ms_message("Register has up to date contact, doing nothing.");
1789 sal_address_destroy(ori_contact_address);
1791 } else ms_message("contact do not match, need to update the register (%s with %s:%i;transport=%s)"
1795 ,sal_transport_to_string(transport));
1797 sal_address_destroy(ori_contact_address);
1800 eXosip_register_build_register(op->rid,op->expires,&msg);
1803 ms_warning("Fail to create a contact updated register.");
1806 if (fix_message_contact(op,msg,last_answer)) {
1807 eXosip_register_send_register(op->rid,msg);
1809 ms_message("Resending new register with updated contact");
1810 update_contact_from_response(op,last_answer);
1813 ms_warning("Fail to send updated register.");
1821 static void registration_success(Sal *sal, eXosip_event_t *ev){
1822 SalOp *op=sal_find_register(sal,ev->rid);
1823 osip_header_t *h=NULL;
1826 ms_error("Receiving register response for unknown operation");
1829 osip_message_get_expires(ev->request,0,&h);
1830 if (h!=NULL && atoi(h->hvalue)!=0){
1832 if (!register_again_with_updated_contact(op,ev->request,ev->response)){
1833 sal->callbacks.register_success(op,registered);
1836 sal->callbacks.register_success(op,FALSE);
1840 static bool_t registration_failure(Sal *sal, eXosip_event_t *ev){
1842 const char *reason=NULL;
1843 SalOp *op=sal_find_register(sal,ev->rid);
1844 SalReason sr=SalReasonUnknown;
1845 SalError se=SalErrorUnknown;
1848 ms_error("Receiving register failure for unknown operation");
1852 status_code=osip_message_get_status_code(ev->response);
1853 reason=osip_message_get_reason_phrase(ev->response);
1855 switch(status_code){
1858 return process_authentication(sal,ev);
1860 case 423: /*interval too brief*/
1861 {/*retry with greater interval */
1862 osip_header_t *h=NULL;
1863 osip_message_t *msg=NULL;
1864 osip_message_header_get_byname(ev->response,"min-expires",0,&h);
1865 if (h && h->hvalue && h->hvalue[0]!='\0'){
1866 int val=atoi(h->hvalue);
1867 if (val>op->expires)
1869 }else op->expires*=2;
1871 eXosip_register_build_register(op->rid,op->expires,&msg);
1872 eXosip_register_send_register(op->rid,msg);
1876 case 606: /*Not acceptable, workaround for proxies that don't like private addresses
1877 in vias, such as ekiga.net
1878 On the opposite, freephonie.net bugs when via are masqueraded.
1880 op->masquerade_via=TRUE;
1882 /* if contact is up to date, process the failure, otherwise resend a new register with
1883 updated contact first, just in case the faillure is due to incorrect contact */
1884 if (ev->response && register_again_with_updated_contact(op,ev->request,ev->response))
1885 return TRUE; /*we are retrying with an updated contact*/
1886 if (status_code==403){
1888 sr=SalReasonForbidden;
1889 }else if (status_code==0){
1890 se=SalErrorNoResponse;
1892 sal->callbacks.register_failure(op,se,sr,reason);
1897 static void other_request_reply(Sal *sal,eXosip_event_t *ev){
1898 SalOp *op=find_op(sal,ev);
1901 ms_warning("other_request_reply(): Receiving response to unknown request.");
1905 update_contact_from_response(op,ev->response);
1906 if (ev->request && strcmp(osip_message_get_method(ev->request),"OPTIONS")==0)
1907 sal->callbacks.ping_reply(op);
1911 static void process_in_call_reply(Sal *sal, eXosip_event_t *ev){
1912 SalOp *op=find_op(sal,ev);
1914 if (ev->request && strcmp(osip_message_get_method(ev->request),"NOTIFY")==0){
1915 if (op->sipfrag_pending){
1916 send_notify_for_refer(op->did,op->sipfrag_pending);
1917 op->sipfrag_pending=NULL;
1923 static bool_t process_event(Sal *sal, eXosip_event_t *ev){
1924 ms_message("linphone process event get a message %d\n",ev->type);
1926 case EXOSIP_CALL_ANSWERED:
1927 ms_message("CALL_ANSWERED\n");
1928 call_accepted(sal,ev);
1929 authentication_ok(sal,ev);
1931 case EXOSIP_CALL_CLOSED:
1932 case EXOSIP_CALL_CANCELLED:
1933 ms_message("CALL_CLOSED or CANCELLED\n");
1934 call_terminated(sal,ev);
1936 case EXOSIP_CALL_TIMEOUT:
1937 case EXOSIP_CALL_NOANSWER:
1938 ms_message("CALL_TIMEOUT or NOANSWER\n");
1939 return call_failure(sal,ev);
1941 case EXOSIP_CALL_REQUESTFAILURE:
1942 case EXOSIP_CALL_GLOBALFAILURE:
1943 case EXOSIP_CALL_SERVERFAILURE:
1944 ms_message("CALL_REQUESTFAILURE or GLOBALFAILURE or SERVERFAILURE\n");
1945 return call_failure(sal,ev);
1947 case EXOSIP_CALL_RELEASED:
1948 ms_message("CALL_RELEASED\n");
1949 call_released(sal, ev);
1951 case EXOSIP_CALL_INVITE:
1952 ms_message("CALL_NEW\n");
1953 inc_new_call(sal,ev);
1955 case EXOSIP_CALL_REINVITE:
1956 handle_reinvite(sal,ev);
1958 case EXOSIP_CALL_ACK:
1959 ms_message("CALL_ACK");
1962 case EXOSIP_CALL_REDIRECTED:
1963 ms_message("CALL_REDIRECTED");
1964 eXosip_default_action(ev);
1966 case EXOSIP_CALL_PROCEEDING:
1967 ms_message("CALL_PROCEEDING");
1968 call_proceeding(sal,ev);
1970 case EXOSIP_CALL_RINGING:
1971 ms_message("CALL_RINGING");
1972 call_ringing(sal,ev);
1973 authentication_ok(sal,ev);
1975 case EXOSIP_CALL_MESSAGE_NEW:
1976 ms_message("EXOSIP_CALL_MESSAGE_NEW");
1977 call_message_new(sal,ev);
1979 case EXOSIP_CALL_MESSAGE_REQUESTFAILURE:
1981 (ev->response->status_code==407 || ev->response->status_code==401)){
1982 return process_authentication(sal,ev);
1985 case EXOSIP_CALL_MESSAGE_ANSWERED:
1986 ms_message("EXOSIP_CALL_MESSAGE_ANSWERED ");
1987 process_in_call_reply(sal,ev);
1989 case EXOSIP_IN_SUBSCRIPTION_NEW:
1990 ms_message("CALL_IN_SUBSCRIPTION_NEW ");
1991 sal_exosip_subscription_recv(sal,ev);
1993 case EXOSIP_IN_SUBSCRIPTION_RELEASED:
1994 ms_message("CALL_SUBSCRIPTION_NEW ");
1995 sal_exosip_in_subscription_closed(sal,ev);
1997 case EXOSIP_SUBSCRIPTION_UPDATE:
1998 ms_message("CALL_SUBSCRIPTION_UPDATE");
2000 case EXOSIP_SUBSCRIPTION_NOTIFY:
2001 ms_message("CALL_SUBSCRIPTION_NOTIFY");
2002 sal_exosip_notify_recv(sal,ev);
2004 case EXOSIP_SUBSCRIPTION_ANSWERED:
2005 ms_message("EXOSIP_SUBSCRIPTION_ANSWERED, ev->sid=%i, ev->did=%i\n",ev->sid,ev->did);
2006 sal_exosip_subscription_answered(sal,ev);
2008 case EXOSIP_SUBSCRIPTION_CLOSED:
2009 ms_message("EXOSIP_SUBSCRIPTION_CLOSED\n");
2010 sal_exosip_subscription_closed(sal,ev);
2012 case EXOSIP_SUBSCRIPTION_REQUESTFAILURE: /**< announce a request failure */
2013 if (ev->response && (ev->response->status_code == 407 || ev->response->status_code == 401)){
2014 return process_authentication(sal,ev);
2016 case EXOSIP_SUBSCRIPTION_SERVERFAILURE:
2017 case EXOSIP_SUBSCRIPTION_GLOBALFAILURE:
2018 sal_exosip_subscription_closed(sal,ev);
2020 case EXOSIP_REGISTRATION_FAILURE:
2021 ms_message("REGISTRATION_FAILURE\n");
2022 return registration_failure(sal,ev);
2024 case EXOSIP_REGISTRATION_SUCCESS:
2025 authentication_ok(sal,ev);
2026 registration_success(sal,ev);
2028 case EXOSIP_MESSAGE_NEW:
2029 other_request(sal,ev);
2031 case EXOSIP_MESSAGE_PROCEEDING:
2032 case EXOSIP_MESSAGE_ANSWERED:
2033 case EXOSIP_MESSAGE_REDIRECTED:
2034 case EXOSIP_MESSAGE_SERVERFAILURE:
2035 case EXOSIP_MESSAGE_GLOBALFAILURE:
2036 other_request_reply(sal,ev);
2038 case EXOSIP_MESSAGE_REQUESTFAILURE:
2039 case EXOSIP_NOTIFICATION_REQUESTFAILURE:
2041 switch (ev->response->status_code) {
2044 return process_authentication(sal,ev);
2046 eXosip_automatic_action ();
2051 other_request_reply(sal,ev);
2054 ms_message("Unhandled exosip event ! %i",ev->type);
2060 int sal_iterate(Sal *sal){
2062 while((ev=eXosip_event_wait(0,0))!=NULL){
2063 if (process_event(sal,ev))
2064 eXosip_event_free(ev);
2066 #ifdef HAVE_EXOSIP_TRYLOCK
2067 if (eXosip_trylock()==0){
2068 eXosip_automatic_refresh();
2071 ms_warning("eXosip_trylock busy.");
2075 eXosip_automatic_refresh();
2081 static void register_set_contact(osip_message_t *msg, const char *contact){
2082 osip_uri_param_t *param = NULL;
2083 osip_contact_t *ct=NULL;
2085 /*we get the line parameter choosed by exosip, and add it to our own contact*/
2086 osip_message_get_contact(msg,0,&ct);
2088 osip_uri_uparam_get_byname(ct->url, "line", ¶m);
2089 if (param && param->gvalue)
2090 line=osip_strdup(param->gvalue);
2092 _osip_list_set_empty(&msg->contacts,(void (*)(void*))osip_contact_free);
2093 osip_message_set_contact(msg,contact);
2094 osip_message_get_contact(msg,0,&ct);
2095 osip_uri_uparam_add(ct->url,osip_strdup("line"),line);
2098 static void sal_register_add_route(osip_message_t *msg, const char *proxy){
2100 snprintf(tmp,sizeof(tmp)-1,"<%s;lr>",proxy);
2102 osip_list_special_free(&msg->routes,(void (*)(void*))osip_route_free);
2103 osip_message_set_route(msg,tmp);
2106 int sal_register(SalOp *h, const char *proxy, const char *from, int expires){
2107 osip_message_t *msg;
2108 const char *contact=sal_op_get_contact(h);
2110 sal_op_set_route(h,proxy);
2112 SalAddress *from_parsed=sal_address_new(from);
2114 if (from_parsed==NULL) {
2115 ms_warning("sal_register() bad from %s",from);
2118 snprintf(domain,sizeof(domain),"sip:%s",sal_address_get_domain(from_parsed));
2119 sal_address_destroy(from_parsed);
2121 h->rid=eXosip_register_build_initial_register(from,domain,NULL,expires,&msg);
2123 if (contact) register_set_contact(msg,contact);
2124 sal_register_add_route(msg,proxy);
2125 sal_add_register(h->base.root,h);
2127 ms_error("Could not build initial register.");
2133 eXosip_register_build_register(h->rid,expires,&msg);
2134 sal_register_add_route(msg,proxy);
2137 eXosip_register_send_register(h->rid,msg);
2140 return (msg != NULL) ? 0 : -1;
2143 int sal_register_refresh(SalOp *op, int expires){
2144 osip_message_t *msg=NULL;
2145 const char *contact=sal_op_get_contact(op);
2148 ms_error("Unexistant registration context, not possible to refresh.");
2152 eXosip_register_build_register(op->rid,expires,&msg);
2154 if (contact) register_set_contact(msg,contact);
2155 sal_register_add_route(msg,sal_op_get_route(op));
2156 eXosip_register_send_register(op->rid,msg);
2157 }else ms_error("Could not build REGISTER refresh message.");
2159 return (msg != NULL) ? 0 : -1;
2163 int sal_unregister(SalOp *h){
2164 osip_message_t *msg=NULL;
2166 eXosip_register_build_register(h->rid,0,&msg);
2167 if (msg) eXosip_register_send_register(h->rid,msg);
2168 else ms_warning("Could not build unREGISTER !");
2173 SalAddress * sal_address_new(const char *uri){
2175 osip_from_init(&from);
2177 // Remove front spaces
2178 while (uri[0]==' ') {
2182 if (osip_from_parse(from,uri)!=0){
2183 osip_from_free(from);
2186 if (from->displayname!=NULL && from->displayname[0]=='"'){
2187 char *unquoted=osip_strdup_without_quote(from->displayname);
2188 osip_free(from->displayname);
2189 from->displayname=unquoted;
2191 return (SalAddress*)from;
2194 SalAddress * sal_address_clone(const SalAddress *addr){
2195 osip_from_t *ret=NULL;
2196 osip_from_clone((osip_from_t*)addr,&ret);
2197 return (SalAddress*)ret;
2200 #define null_if_empty(s) (((s)!=NULL && (s)[0]!='\0') ? (s) : NULL )
2202 const char *sal_address_get_scheme(const SalAddress *addr){
2203 const osip_from_t *u=(const osip_from_t*)addr;
2204 return null_if_empty(u->url->scheme);
2207 const char *sal_address_get_display_name(const SalAddress* addr){
2208 const osip_from_t *u=(const osip_from_t*)addr;
2209 return null_if_empty(u->displayname);
2212 const char *sal_address_get_username(const SalAddress *addr){
2213 const osip_from_t *u=(const osip_from_t*)addr;
2214 return null_if_empty(u->url->username);
2217 const char *sal_address_get_domain(const SalAddress *addr){
2218 const osip_from_t *u=(const osip_from_t*)addr;
2219 return null_if_empty(u->url->host);
2222 void sal_address_set_display_name(SalAddress *addr, const char *display_name){
2223 osip_from_t *u=(osip_from_t*)addr;
2224 if (u->displayname!=NULL){
2225 osip_free(u->displayname);
2226 u->displayname=NULL;
2228 if (display_name!=NULL && display_name[0]!='\0'){
2229 u->displayname=osip_strdup(display_name);
2233 void sal_address_set_username(SalAddress *addr, const char *username){
2234 osip_from_t *uri=(osip_from_t*)addr;
2235 if (uri->url->username!=NULL){
2236 osip_free(uri->url->username);
2237 uri->url->username=NULL;
2240 uri->url->username=osip_strdup(username);
2243 void sal_address_set_domain(SalAddress *addr, const char *host){
2244 osip_from_t *uri=(osip_from_t*)addr;
2245 if (uri->url->host!=NULL){
2246 osip_free(uri->url->host);
2247 uri->url->host=NULL;
2250 uri->url->host=osip_strdup(host);
2253 void sal_address_set_port(SalAddress *addr, const char *port){
2254 osip_from_t *uri=(osip_from_t*)addr;
2255 if (uri->url->port!=NULL){
2256 osip_free(uri->url->port);
2257 uri->url->port=NULL;
2260 uri->url->port=osip_strdup(port);
2263 void sal_address_set_port_int(SalAddress *uri, int port){
2266 /*this is the default, special case to leave the port field blank*/
2267 sal_address_set_port(uri,NULL);
2270 snprintf(tmp,sizeof(tmp),"%i",port);
2271 sal_address_set_port(uri,tmp);
2274 void sal_address_clean(SalAddress *addr){
2275 osip_generic_param_freelist(& ((osip_from_t*)addr)->gen_params);
2276 osip_uri_param_freelist(& ((osip_from_t*)addr)->url->url_params);
2279 char *sal_address_as_string(const SalAddress *u){
2281 osip_from_t *from=(osip_from_t *)u;
2282 char *old_displayname=NULL;
2283 /* hack to force use of quotes around the displayname*/
2284 if (from->displayname!=NULL
2285 && from->displayname[0]!='"'){
2286 old_displayname=from->displayname;
2287 from->displayname=osip_enquote(from->displayname);
2289 osip_from_to_str(from,&tmp);
2290 if (old_displayname!=NULL){
2291 ms_free(from->displayname);
2292 from->displayname=old_displayname;
2299 char *sal_address_as_string_uri_only(const SalAddress *u){
2300 char *tmp=NULL,*ret;
2301 osip_uri_to_str(((osip_from_t*)u)->url,&tmp);
2306 void sal_address_set_param(SalAddress *u,const char* name,const char* value) {
2307 osip_uri_param_t *param=NULL;
2308 osip_uri_uparam_get_byname(((osip_from_t*)u)->url,(char*)name,¶m);
2310 osip_uri_uparam_add (((osip_from_t*)u)->url,ms_strdup(name),value ? ms_strdup(value) : NULL);
2312 osip_free(param->gvalue);
2313 param->gvalue=value ? osip_strdup(value) : NULL;
2318 void sal_address_destroy(SalAddress *u){
2319 osip_from_free((osip_from_t*)u);
2322 void sal_set_keepalive_period(Sal *ctx,unsigned int value) {
2323 ctx->keepalive_period=value;
2324 eXosip_set_option (EXOSIP_OPT_UDP_KEEP_ALIVE, &value);
2326 unsigned int sal_get_keepalive_period(Sal *ctx) {
2327 return ctx->keepalive_period;
2330 const char * sal_address_get_port(const SalAddress *addr) {
2331 const osip_from_t *u=(const osip_from_t*)addr;
2332 return null_if_empty(u->url->port);
2335 int sal_address_get_port_int(const SalAddress *uri) {
2336 const char* port = sal_address_get_port(uri);
2343 SalTransport sal_address_get_transport(const SalAddress* addr) {
2344 const osip_from_t *u=(const osip_from_t*)addr;
2345 osip_uri_param_t *transport_param=NULL;
2346 osip_uri_uparam_get_byname(u->url,"transport",&transport_param);
2347 if (transport_param == NULL){
2348 return SalTransportUDP;
2350 return sal_transport_parse(transport_param->gvalue);
2353 void sal_address_set_transport(SalAddress* addr,SalTransport transport) {
2354 sal_address_set_param(addr, "transport", sal_transport_to_string(transport));
2357 /* sends a reinvite. Local media description may have changed by application since call establishment*/
2358 int sal_call_update(SalOp *h, const char *subject){
2360 osip_message_t *reinvite=NULL;
2363 if(eXosip_call_build_request(h->did,"INVITE",&reinvite) != 0 || reinvite==NULL){
2368 osip_message_set_subject(reinvite,subject);
2369 osip_message_set_allow(reinvite, "INVITE, ACK, CANCEL, OPTIONS, BYE, REFER, NOTIFY, MESSAGE, SUBSCRIBE, INFO");
2370 if (h->base.root->session_expires!=0){
2371 osip_message_set_header(reinvite, "Session-expires", "200");
2372 osip_message_set_supported(reinvite, "timer");
2374 if (h->base.local_media){
2375 h->sdp_offering=TRUE;
2376 set_sdp_from_desc(reinvite,h->base.local_media);
2377 }else h->sdp_offering=FALSE;
2379 err = eXosip_call_send_request(h->did, reinvite);
2383 void sal_reuse_authorization(Sal *ctx, bool_t value) {
2384 ctx->reuse_authorization=value;