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"
24 #include "offeranswer.h"
27 // Necessary to make it linked
28 static void for_linker() { eXosip_transport_hook_register(NULL); }
30 static bool_t call_failure(Sal *sal, eXosip_event_t *ev);
32 static void text_received(Sal *sal, eXosip_event_t *ev);
34 static void masquerade_via(osip_message_t *msg, const char *ip, const char *port);
35 static bool_t fix_message_contact(SalOp *op, osip_message_t *request,osip_message_t *last_answer, bool_t expire_last_contact);
36 static void update_contact_from_response(SalOp *op, osip_message_t *response);
38 void _osip_list_set_empty(osip_list_t *l, void (*freefunc)(void*)){
40 while(!osip_list_eol(l,0)) {
41 data=osip_list_get(l,0);
42 osip_list_remove(l,0);
43 if (data) freefunc(data);
47 void sal_get_default_local_ip(Sal *sal, int address_family,char *ip, size_t iplen){
48 if (eXosip_guess_localip(address_family,ip,iplen)<0){
49 /*default to something */
50 strncpy(ip,address_family==AF_INET6 ? "::1" : "127.0.0.1",iplen);
51 ms_error("Could not find default routable ip address !");
56 static SalOp * sal_find_call(Sal *sal, int cid){
59 for(elem=sal->calls;elem!=NULL;elem=elem->next){
60 op=(SalOp*)elem->data;
61 if (op->cid==cid) return op;
66 static void sal_add_call(Sal *sal, SalOp *op){
67 sal->calls=ms_list_append(sal->calls,op);
70 static void sal_remove_call(Sal *sal, SalOp *op){
71 sal->calls=ms_list_remove(sal->calls, op);
74 static SalOp * sal_find_register(Sal *sal, int rid){
77 for(elem=sal->registers;elem!=NULL;elem=elem->next){
78 op=(SalOp*)elem->data;
79 if (op->rid==rid) return op;
84 static void sal_add_register(Sal *sal, SalOp *op){
85 sal->registers=ms_list_append(sal->registers,op);
88 static void sal_remove_register(Sal *sal, int rid){
91 for(elem=sal->registers;elem!=NULL;elem=elem->next){
92 op=(SalOp*)elem->data;
94 sal->registers=ms_list_remove_link(sal->registers,elem);
100 static SalOp * sal_find_other(Sal *sal, osip_message_t *message){
103 osip_call_id_t *callid=osip_message_get_call_id(message);
105 ms_error("There is no call-id in this message !");
108 for(elem=sal->other_transactions;elem!=NULL;elem=elem->next){
109 op=(SalOp*)elem->data;
110 if (osip_call_id_match(callid,op->call_id)==0) return op;
115 void sal_add_other(Sal *sal, SalOp *op, osip_message_t *request){
116 osip_call_id_t *callid=osip_message_get_call_id(request);
118 ms_error("There is no call id in the request !");
121 osip_call_id_clone(callid,&op->call_id);
122 sal->other_transactions=ms_list_append(sal->other_transactions,op);
125 static void sal_remove_other(Sal *sal, SalOp *op){
126 sal->other_transactions=ms_list_remove(sal->other_transactions,op);
130 static void sal_add_pending_auth(Sal *sal, SalOp *op){
131 sal->pending_auths=ms_list_append(sal->pending_auths,op);
135 static void sal_remove_pending_auth(Sal *sal, SalOp *op){
136 sal->pending_auths=ms_list_remove(sal->pending_auths,op);
139 void sal_exosip_fix_route(SalOp *op){
140 if (sal_op_get_route(op)!=NULL){
141 osip_route_t *rt=NULL;
142 osip_uri_param_t *lr_param=NULL;
144 osip_route_init(&rt);
145 if (osip_route_parse(rt,sal_op_get_route(op))<0){
146 ms_warning("Bad route %s!",sal_op_get_route(op));
147 sal_op_set_route(op,NULL);
149 /* check if the lr parameter is set , if not add it */
150 osip_uri_uparam_get_byname(rt->url, "lr", &lr_param);
153 osip_uri_uparam_add(rt->url,osip_strdup("lr"),NULL);
154 osip_route_to_str(rt,&tmproute);
155 sal_op_set_route(op,tmproute);
163 SalOp * sal_op_new(Sal *sal){
164 SalOp *op=ms_new0(SalOp,1);
165 __sal_op_init(op,sal);
166 op->cid=op->did=op->tid=op->rid=op->nid=op->sid=-1;
168 op->supports_session_timers=FALSE;
169 op->sdp_offering=TRUE;
170 op->pending_auth=NULL;
175 op->referred_by=NULL;
176 op->masquerade_via=FALSE;
177 op->auto_answer_asked=FALSE;
179 op->terminated=FALSE;
183 bool_t sal_call_autoanswer_asked(SalOp *op)
185 return op->auto_answer_asked;
188 void sal_op_release(SalOp *op){
190 sdp_message_free(op->sdp_answer);
191 if (op->pending_auth)
192 eXosip_event_free(op->pending_auth);
194 sal_remove_register(op->base.root,op->rid);
195 eXosip_register_remove(op->rid);
198 ms_message("Cleaning cid %i",op->cid);
199 sal_remove_call(op->base.root,op);
202 sal_remove_out_subscribe(op->base.root,op);
205 sal_remove_in_subscribe(op->base.root,op);
207 osip_call_id_free(op->call_id);
210 if (op->pending_auth){
211 sal_remove_pending_auth(op->base.root,op);
214 sal_media_description_unref(op->result);
216 sal_remove_other(op->base.root,op);
217 osip_call_id_free(op->call_id);
220 ms_free(op->replaces);
222 if (op->referred_by){
223 ms_free(op->referred_by);
226 sal_auth_info_delete(op->auth_info);
231 static void _osip_trace_func(char *fi, int li, osip_trace_level_t level, char *chfr, va_list ap){
232 int ortp_level=ORTP_DEBUG;
238 ortp_level=ORTP_MESSAGE;
241 ortp_level=ORTP_WARNING;
245 ortp_level=ORTP_ERROR;
248 ortp_level=ORTP_FATAL;
250 case END_TRACE_LEVEL:
253 if (ortp_log_level_enabled(level)){
254 int len=strlen(chfr);
255 char *chfrdup=ortp_strdup(chfr);
256 /*need to remove endline*/
258 if (chfrdup[len-1]=='\n')
260 if (chfrdup[len-2]=='\r')
263 ortp_logv(ortp_level,chfrdup,ap);
270 static bool_t firsttime=TRUE;
273 osip_trace_initialize_func (OSIP_INFO4,&_osip_trace_func);
278 sal->keepalive_period=30;
279 sal->double_reg=TRUE;
280 sal->use_rports=TRUE;
282 sal->reuse_authorization=FALSE;
284 sal->verify_server_certs=TRUE;
285 sal->expire_old_contact=FALSE;
286 sal->add_dates=FALSE;
291 void sal_uninit(Sal* sal){
294 ms_free(sal->rootCa);
298 void sal_set_user_pointer(Sal *sal, void *user_data){
302 void *sal_get_user_pointer(const Sal *sal){
306 static void unimplemented_stub(){
307 ms_warning("Unimplemented SAL callback");
310 void sal_set_callbacks(Sal *ctx, const SalCallbacks *cbs){
311 memcpy(&ctx->callbacks,cbs,sizeof(*cbs));
312 if (ctx->callbacks.call_received==NULL)
313 ctx->callbacks.call_received=(SalOnCallReceived)unimplemented_stub;
314 if (ctx->callbacks.call_ringing==NULL)
315 ctx->callbacks.call_ringing=(SalOnCallRinging)unimplemented_stub;
316 if (ctx->callbacks.call_accepted==NULL)
317 ctx->callbacks.call_accepted=(SalOnCallAccepted)unimplemented_stub;
318 if (ctx->callbacks.call_failure==NULL)
319 ctx->callbacks.call_failure=(SalOnCallFailure)unimplemented_stub;
320 if (ctx->callbacks.call_terminated==NULL)
321 ctx->callbacks.call_terminated=(SalOnCallTerminated)unimplemented_stub;
322 if (ctx->callbacks.call_released==NULL)
323 ctx->callbacks.call_released=(SalOnCallReleased)unimplemented_stub;
324 if (ctx->callbacks.call_updating==NULL)
325 ctx->callbacks.call_updating=(SalOnCallUpdating)unimplemented_stub;
326 if (ctx->callbacks.auth_requested==NULL)
327 ctx->callbacks.auth_requested=(SalOnAuthRequested)unimplemented_stub;
328 if (ctx->callbacks.auth_success==NULL)
329 ctx->callbacks.auth_success=(SalOnAuthSuccess)unimplemented_stub;
330 if (ctx->callbacks.register_success==NULL)
331 ctx->callbacks.register_success=(SalOnRegisterSuccess)unimplemented_stub;
332 if (ctx->callbacks.register_failure==NULL)
333 ctx->callbacks.register_failure=(SalOnRegisterFailure)unimplemented_stub;
334 if (ctx->callbacks.dtmf_received==NULL)
335 ctx->callbacks.dtmf_received=(SalOnDtmfReceived)unimplemented_stub;
336 if (ctx->callbacks.notify==NULL)
337 ctx->callbacks.notify=(SalOnNotify)unimplemented_stub;
338 if (ctx->callbacks.notify_presence==NULL)
339 ctx->callbacks.notify_presence=(SalOnNotifyPresence)unimplemented_stub;
340 if (ctx->callbacks.subscribe_received==NULL)
341 ctx->callbacks.subscribe_received=(SalOnSubscribeReceived)unimplemented_stub;
342 if (ctx->callbacks.text_received==NULL)
343 ctx->callbacks.text_received=(SalOnTextReceived)unimplemented_stub;
344 if (ctx->callbacks.ping_reply==NULL)
345 ctx->callbacks.ping_reply=(SalOnPingReply)unimplemented_stub;
346 if (ctx->callbacks.message_external_body==NULL)
347 ctx->callbacks.message_external_body=(SalOnMessageExternalBodyReceived)unimplemented_stub;
350 int sal_unlisten_ports(Sal *ctx){
359 int sal_reset_transports(Sal *ctx){
360 #ifdef HAVE_EXOSIP_RESET_TRANSPORTS
362 ms_message("Exosip transports reset.");
363 eXosip_reset_transports();
367 ms_warning("sal_reset_transports() not implemented in this version.");
373 static void set_tls_options(Sal *ctx){
375 eXosip_tls_ctx_t tlsCtx;
376 memset(&tlsCtx, 0, sizeof(tlsCtx));
377 snprintf(tlsCtx.root_ca_cert, sizeof(tlsCtx.client.cert), "%s", ctx->rootCa);
378 eXosip_set_tls_ctx(&tlsCtx);
380 #ifdef HAVE_EXOSIP_TLS_VERIFY_CERTIFICATE
381 eXosip_tls_verify_certificate(ctx->verify_server_certs);
385 void sal_set_dscp(Sal *ctx, int dscp){
388 eXosip_set_option(EXOSIP_OPT_SET_DSCP,&ctx->dscp);
391 int sal_listen_port(Sal *ctx, const char *addr, int port, SalTransport tr, int is_secure){
394 int proto=IPPROTO_UDP;
395 int keepalive = ctx->keepalive_period;
398 case SalTransportUDP:
400 eXosip_set_option (EXOSIP_OPT_UDP_KEEP_ALIVE, &keepalive);
402 case SalTransportTCP:
403 case SalTransportTLS:
406 eXosip_set_option (EXOSIP_OPT_UDP_KEEP_ALIVE,&keepalive);
407 set_tls_options(ctx);
410 ms_warning("unexpected proto, using datagram");
412 /*see if it looks like an IPv6 address*/
413 int use_rports = ctx->use_rports; // Copy char to int to avoid bad alignment
414 eXosip_set_option(EXOSIP_OPT_USE_RPORT,&use_rports);
415 int dont_use_101 = !ctx->use_101; // Copy char to int to avoid bad alignment
416 eXosip_set_option(EXOSIP_OPT_DONT_SEND_101,&dont_use_101);
417 sal_set_dscp(ctx,ctx->dscp);
419 ipv6=strchr(addr,':')!=NULL;
420 eXosip_enable_ipv6(ipv6);
422 if (is_secure && tr == SalTransportUDP){
423 ms_fatal("SIP over DTLS is not supported yet.");
426 err=eXosip_listen_addr(proto, addr, port, ipv6 ? PF_INET6 : PF_INET, is_secure);
431 ortp_socket_t sal_get_socket(Sal *ctx){
432 #ifdef HAVE_EXOSIP_GET_SOCKET
433 return eXosip_get_socket(IPPROTO_UDP);
435 ms_warning("Sorry, eXosip does not have eXosip_get_socket() method");
440 void sal_set_user_agent(Sal *ctx, const char *user_agent){
441 eXosip_set_user_agent(user_agent);
444 void sal_use_session_timers(Sal *ctx, int expires){
445 ctx->session_expires=expires;
448 void sal_use_one_matching_codec_policy(Sal *ctx, bool_t one_matching_codec){
449 ctx->one_matching_codec=one_matching_codec;
452 MSList *sal_get_pending_auths(Sal *sal){
453 return ms_list_copy(sal->pending_auths);
456 void sal_use_double_registrations(Sal *ctx, bool_t enabled){
457 ctx->double_reg=enabled;
460 void sal_expire_old_registration_contacts(Sal *ctx, bool_t enabled){
461 ctx->expire_old_contact=enabled;
464 void sal_use_dates(Sal *ctx, bool_t enabled){
465 ctx->add_dates=enabled;
466 #ifdef EXOSIP_OPT_REGISTER_WITH_DATE
469 eXosip_set_option(EXOSIP_OPT_REGISTER_WITH_DATE,&tmp);
472 if (enabled) ms_warning("Exosip does not support EXOSIP_OPT_REGISTER_WITH_DATE option.");
476 void sal_use_rport(Sal *ctx, bool_t use_rports){
477 ctx->use_rports=use_rports;
479 void sal_use_101(Sal *ctx, bool_t use_101){
480 ctx->use_101=use_101;
483 void sal_set_root_ca(Sal* ctx, const char* rootCa) {
485 ms_free(ctx->rootCa);
486 ctx->rootCa = ms_strdup(rootCa);
487 set_tls_options(ctx);
490 void sal_verify_server_certificates(Sal *ctx, bool_t verify){
491 ctx->verify_server_certs=verify;
492 #ifdef HAVE_EXOSIP_TLS_VERIFY_CERTIFICATE
493 eXosip_tls_verify_certificate(verify);
497 static int extract_received_rport(osip_message_t *msg, const char **received, int *rportval,SalTransport* transport){
498 osip_via_t *via=NULL;
499 osip_generic_param_t *param=NULL;
500 const char *rport=NULL;
504 osip_message_get_via(msg,0,&via);
506 ms_warning("extract_received_rport(): no via.");
510 *transport = sal_transport_parse(via->protocol);
512 if (via->port && via->port[0]!='\0')
513 *rportval=atoi(via->port);
515 osip_via_param_get_byname(via,"rport",¶m);
518 if (rport && rport[0]!='\0') *rportval=atoi(rport);
522 osip_via_param_get_byname(via,"received",¶m);
523 if (param) *received=param->gvalue;
525 if (rport==NULL && *received==NULL){
526 ms_warning("extract_received_rport(): no rport and no received parameters.");
532 static void set_sdp(osip_message_t *sip,sdp_message_t *msg){
536 sdp_message_to_str(msg,&sdp);
538 snprintf(clen,sizeof(clen),"%i",sdplen);
539 osip_message_set_body(sip,sdp,sdplen);
540 osip_message_set_content_type(sip,"application/sdp");
541 osip_message_set_content_length(sip,clen);
545 static void set_sdp_from_desc(osip_message_t *sip, const SalMediaDescription *desc){
546 sdp_message_t *msg=media_description_to_sdp(desc);
548 ms_error("Fail to print sdp message !");
552 sdp_message_free(msg);
555 static void sdp_process(SalOp *h){
556 ms_message("Doing SDP offer/answer process of type %s",h->sdp_offering ? "outgoing" : "incoming");
558 sal_media_description_unref(h->result);
560 h->result=sal_media_description_new();
561 if (h->sdp_offering){
562 offer_answer_initiate_outgoing(h->base.local_media,h->base.remote_media,h->result);
566 sdp_message_free(h->sdp_answer);
568 offer_answer_initiate_incoming(h->base.local_media,h->base.remote_media,h->result,h->base.root->one_matching_codec);
569 h->sdp_answer=media_description_to_sdp(h->result);
570 /*once we have generated the SDP answer, we modify the result description for processing by the upper layer.
571 It should contains media parameters constraint from the remote offer, not our response*/
572 strcpy(h->result->addr,h->base.remote_media->addr);
573 h->result->bandwidth=h->base.remote_media->bandwidth;
575 for(i=0;i<h->result->nstreams;++i){
576 if (h->result->streams[i].rtp_port>0){
577 strcpy(h->result->streams[i].rtp_addr,h->base.remote_media->streams[i].rtp_addr);
578 strcpy(h->result->streams[i].rtcp_addr,h->base.remote_media->streams[i].rtcp_addr);
579 h->result->streams[i].ptime=h->base.remote_media->streams[i].ptime;
580 h->result->streams[i].bandwidth=h->base.remote_media->streams[i].bandwidth;
581 h->result->streams[i].rtp_port=h->base.remote_media->streams[i].rtp_port;
582 h->result->streams[i].rtcp_port=h->base.remote_media->streams[i].rtcp_port;
584 if (h->result->streams[i].proto == SalProtoRtpSavp) {
585 h->result->streams[i].crypto[0] = h->base.remote_media->streams[i].crypto[0];
593 int sal_call_is_offerer(const SalOp *h){
594 return h->sdp_offering;
597 int sal_call_set_local_media_description(SalOp *h, SalMediaDescription *desc){
599 sal_media_description_ref(desc);
600 if (h->base.local_media)
601 sal_media_description_unref(h->base.local_media);
602 h->base.local_media=desc;
603 if (h->base.remote_media){
604 /*case of an incoming call where we modify the local capabilities between the time
605 * the call is ringing and it is accepted (for example if you want to accept without video*/
606 /*reset the sdp answer so that it is computed again*/
608 sdp_message_free(h->sdp_answer);
615 int sal_call(SalOp *h, const char *from, const char *to){
618 osip_message_t *invite=NULL;
619 osip_call_id_t *callid;
620 sal_op_set_from(h,from);
622 sal_exosip_fix_route(h);
624 h->terminated = FALSE;
626 route = sal_op_get_route(h);
627 err=eXosip_call_build_initial_invite(&invite,to,from,route,"Phone call");
629 ms_error("Could not create call. Error %d (from=%s to=%s route=%s)",
630 err, from, to, route);
633 osip_message_set_allow(invite, "INVITE, ACK, CANCEL, OPTIONS, BYE, REFER, NOTIFY, MESSAGE, SUBSCRIBE, INFO");
634 if (h->base.contact){
635 _osip_list_set_empty(&invite->contacts,(void (*)(void*))osip_contact_free);
636 osip_message_set_contact(invite,h->base.contact);
638 if (h->base.root->session_expires!=0){
639 osip_message_set_header(invite, "Session-expires", "200");
640 osip_message_set_supported(invite, "timer");
642 if (h->base.local_media){
643 h->sdp_offering=TRUE;
644 set_sdp_from_desc(invite,h->base.local_media);
645 }else h->sdp_offering=FALSE;
647 osip_message_set_header(invite,"Replaces",h->replaces);
649 osip_message_set_header(invite,"Referred-By",h->referred_by);
653 err=eXosip_call_send_initial_invite(invite);
657 ms_error("Fail to send invite ! Error code %d", err);
660 callid=osip_message_get_call_id(invite);
661 osip_call_id_to_str(callid,(char **)(&h->base.call_id));
662 sal_add_call(h->base.root,h);
667 int sal_call_notify_ringing(SalOp *h, bool_t early_media){
670 /*if early media send also 180 and 183 */
674 eXosip_call_build_answer(h->tid,183,&msg);
678 set_sdp(msg,h->sdp_answer);
679 sdp_message_free(h->sdp_answer);
682 eXosip_call_send_answer(h->tid,183,msg);
687 eXosip_call_send_answer(h->tid,180,NULL);
693 int sal_call_accept(SalOp * h){
695 const char *contact=sal_op_get_contact(h);
697 int err=eXosip_call_build_answer(h->tid,200,&msg);
698 if (err<0 || msg==NULL){
699 ms_error("Fail to build answer for call: err=%i",err);
702 if (h->base.root->session_expires!=0){
703 if (h->supports_session_timers) osip_message_set_supported(msg, "timer");
707 _osip_list_set_empty(&msg->contacts,(void (*)(void*))osip_contact_free);
708 osip_message_set_contact(msg,contact);
711 if (h->base.local_media){
712 /*this is the case where we received an invite without SDP*/
713 if (h->sdp_offering) {
714 set_sdp_from_desc(msg,h->base.local_media);
716 if (h->sdp_answer==NULL) sdp_process(h);
718 set_sdp(msg,h->sdp_answer);
719 sdp_message_free(h->sdp_answer);
724 ms_error("You are accepting a call but not defined any media capabilities !");
726 eXosip_call_send_answer(h->tid,200,msg);
730 int sal_call_decline(SalOp *h, SalReason reason, const char *redirect){
731 if (reason==SalReasonBusy){
733 eXosip_call_send_answer(h->tid,486,NULL);
736 else if (reason==SalReasonTemporarilyUnavailable){
738 eXosip_call_send_answer(h->tid,480,NULL);
740 }else if (reason==SalReasonDoNotDisturb){
742 eXosip_call_send_answer(h->tid,600,NULL);
744 }else if (reason==SalReasonMedia){
746 eXosip_call_send_answer(h->tid,415,NULL);
748 }else if (redirect!=NULL && reason==SalReasonRedirect){
751 if (strstr(redirect,"sip:")!=0) code=302;
754 eXosip_call_build_answer(h->tid,code,&msg);
755 osip_message_set_contact(msg,redirect);
756 eXosip_call_send_answer(h->tid,code,msg);
758 }else sal_call_terminate(h);
762 SalMediaDescription * sal_call_get_remote_media_description(SalOp *h){
763 return h->base.remote_media;
766 SalMediaDescription * sal_call_get_final_media_description(SalOp *h){
767 if (h->base.local_media && h->base.remote_media && !h->result){
773 int sal_call_set_referer(SalOp *h, SalOp *refered_call){
774 if (refered_call->replaces)
775 h->replaces=ms_strdup(refered_call->replaces);
776 if (refered_call->referred_by)
777 h->referred_by=ms_strdup(refered_call->referred_by);
781 static int send_notify_for_refer(int did, const char *sipfrag){
784 eXosip_call_build_notify(did,EXOSIP_SUBCRSTATE_ACTIVE,&msg);
787 ms_warning("Could not build NOTIFY for refer.");
790 osip_message_set_content_type(msg,"message/sipfrag");
791 osip_message_set_header(msg,"Event","refer");
792 osip_message_set_body(msg,sipfrag,strlen(sipfrag));
793 eXosip_call_send_request(did,msg);
798 /* currently only support to notify trying and 200Ok*/
799 int sal_call_notify_refer_state(SalOp *h, SalOp *newcall){
802 send_notify_for_refer(h->did,"SIP/2.0 100 Trying\r\n");
804 else if (newcall->cid!=-1){
805 if (newcall->did==-1){
806 /* not yet established*/
807 if (!newcall->terminated){
809 send_notify_for_refer(h->did,"SIP/2.0 100 Trying\r\n");
812 if (!newcall->terminated){
813 if (send_notify_for_refer(h->did,"SIP/2.0 200 Ok\r\n")==-1){
814 /* we need previous notify transaction to complete, so buffer the request for later*/
815 h->sipfrag_pending="SIP/2.0 200 Ok\r\n";
823 int sal_ping(SalOp *op, const char *from, const char *to){
824 osip_message_t *options=NULL;
826 sal_op_set_from(op,from);
827 sal_op_set_to(op,to);
828 sal_exosip_fix_route(op);
830 eXosip_options_build_request (&options, sal_op_get_to(op),
831 sal_op_get_from(op),sal_op_get_route(op));
833 if (op->base.root->session_expires!=0){
834 osip_message_set_header(options, "Session-expires", "200");
835 osip_message_set_supported(options, "timer");
837 sal_add_other(sal_op_get_sal(op),op,options);
838 return eXosip_options_send_request(options);
843 int sal_call_refer(SalOp *h, const char *refer_to){
844 osip_message_t *msg=NULL;
847 eXosip_call_build_refer(h->did,refer_to, &msg);
848 if (msg) err=eXosip_call_send_request(h->did, msg);
854 int sal_call_refer_with_replaces(SalOp *h, SalOp *other_call_h){
855 osip_message_t *msg=NULL;
856 char referto[256]={0};
859 if (eXosip_call_get_referto(other_call_h->did,referto,sizeof(referto)-1)!=0){
860 ms_error("eXosip_call_get_referto() failed for did=%i",other_call_h->did);
864 eXosip_call_build_refer(h->did,referto, &msg);
865 osip_message_set_header(msg,"Referred-By",h->base.from);
866 if (msg) err=eXosip_call_send_request(h->did, msg);
872 SalOp *sal_call_get_replaces(SalOp *h){
873 if (h!=NULL && h->replaces!=NULL){
876 cid=eXosip_call_find_by_replaces(h->replaces);
879 SalOp *ret=sal_find_call(h->base.root,cid);
886 int sal_call_send_dtmf(SalOp *h, char dtmf){
887 osip_message_t *msg=NULL;
892 eXosip_call_build_info(h->did,&msg);
894 snprintf(dtmf_body, sizeof(dtmf_body), "Signal=%c\r\nDuration=250\r\n", dtmf);
895 osip_message_set_body(msg,dtmf_body,strlen(dtmf_body));
896 osip_message_set_content_type(msg,"application/dtmf-relay");
897 snprintf(clen,sizeof(clen),"%lu",(unsigned long)strlen(dtmf_body));
898 osip_message_set_content_length(msg,clen);
899 eXosip_call_send_request(h->did,msg);
905 static void push_auth_to_exosip(const SalAuthInfo *info){
907 if (info->userid==NULL || info->userid[0]=='\0') userid=info->username;
908 else userid=info->userid;
909 ms_message("Authentication info for username [%s], id[%s], realm [%s] added to eXosip", info->username,userid, info->realm);
910 eXosip_add_authentication_info (info->username,userid,
911 info->password, NULL,info->realm);
914 * Just for symmetry ;-)
916 static void pop_auth_from_exosip() {
917 eXosip_clear_authentication_info();
920 int sal_call_terminate(SalOp *h){
922 if (h == NULL) return -1;
923 if (h->auth_info) push_auth_to_exosip(h->auth_info);
925 err=eXosip_call_terminate(h->cid,h->did);
927 if (!h->base.root->reuse_authorization) pop_auth_from_exosip();
929 ms_warning("Exosip could not terminate the call: cid=%i did=%i", h->cid,h->did);
935 void sal_op_authenticate(SalOp *h, const SalAuthInfo *info){
936 if (h->terminated) return;
937 if (h->pending_auth){
938 push_auth_to_exosip(info);
940 /*FIXME exosip does not take into account this update register message*/
942 if (fix_message_contact(h, h->pending_auth->request,h->pending_auth->response)) {
946 update_contact_from_response(h,h->pending_auth->response);
948 eXosip_default_action(h->pending_auth);
950 ms_message("eXosip_default_action() done");
951 if (!h->base.root->reuse_authorization) pop_auth_from_exosip();
953 if (h->auth_info) sal_auth_info_delete(h->auth_info); /*if already exist*/
954 h->auth_info=sal_auth_info_clone(info); /*store auth info for subsequent request*/
957 void sal_op_cancel_authentication(SalOp *h) {
959 sal_op_get_sal(h)->callbacks.register_failure(h,SalErrorFailure, SalReasonForbidden,"Authentication failure");
960 } else if (h->cid >0) {
961 sal_op_get_sal(h)->callbacks.call_failure(h,SalErrorFailure, SalReasonForbidden,"Authentication failure",0);
963 ms_warning("Auth failure not handled");
967 static void set_network_origin(SalOp *op, osip_message_t *req){
968 const char *received=NULL;
971 SalTransport transport;
972 if (extract_received_rport(req,&received,&rport,&transport)!=0){
973 osip_via_t *via=NULL;
975 osip_message_get_via(req,0,&via);
976 received=osip_via_get_host(via);
977 tmp=osip_via_get_port(via);
978 if (tmp) rport=atoi(tmp);
980 if (transport != SalTransportUDP) {
981 snprintf(origin,sizeof(origin)-1,"sip:%s:%i",received,rport);
983 snprintf(origin,sizeof(origin)-1,"sip:%s:%i;transport=%s",received,rport,sal_transport_to_string(transport));
985 __sal_op_set_network_origin(op,origin);
988 static void set_remote_ua(SalOp* op, osip_message_t *req){
989 if (op->base.remote_ua==NULL){
990 osip_header_t *h=NULL;
991 osip_message_get_user_agent(req,0,&h);
993 op->base.remote_ua=ms_strdup(h->hvalue);
998 static void set_replaces(SalOp *op, osip_message_t *req){
999 osip_header_t *h=NULL;
1002 ms_free(op->replaces);
1005 osip_message_header_get_byname(req,"replaces",0,&h);
1007 if (h->hvalue && h->hvalue[0]!='\0'){
1008 op->replaces=ms_strdup(h->hvalue);
1013 static SalOp *find_op(Sal *sal, eXosip_event_t *ev){
1015 return sal_find_call(sal,ev->cid);
1018 return sal_find_register(sal,ev->rid);
1021 return sal_find_out_subscribe(sal,ev->sid);
1024 return sal_find_in_subscribe(sal,ev->nid);
1026 if (ev->response) return sal_find_other(sal,ev->response);
1027 else if (ev->request) return sal_find_other(sal,ev->request);
1031 static void inc_new_call(Sal *sal, eXosip_event_t *ev){
1032 SalOp *op=sal_op_new(sal);
1033 osip_from_t *from,*to;
1034 osip_call_info_t *call_info;
1036 sdp_message_t *sdp=eXosip_get_sdp_info(ev->request);
1037 osip_call_id_t *callid=osip_message_get_call_id(ev->request);
1038 osip_call_id_to_str(callid,(char**)(&op->base.call_id));
1040 set_network_origin(op,ev->request);
1041 set_remote_ua(op,ev->request);
1042 set_replaces(op,ev->request);
1045 op->sdp_offering=FALSE;
1046 op->base.remote_media=sal_media_description_new();
1047 sdp_to_media_description(sdp,op->base.remote_media);
1048 sdp_message_free(sdp);
1049 }else op->sdp_offering=TRUE;
1051 from=osip_message_get_from(ev->request);
1052 to=osip_message_get_to(ev->request);
1053 osip_from_to_str(from,&tmp);
1054 sal_op_set_from(op,tmp);
1056 osip_from_to_str(to,&tmp);
1057 sal_op_set_to(op,tmp);
1060 osip_message_get_call_info(ev->request,0,&call_info);
1063 osip_call_info_to_str(call_info,&tmp);
1064 if( strstr(tmp,"answer-after=") != NULL)
1066 op->auto_answer_asked=TRUE;
1067 ms_message("The caller asked to automatically answer the call(Emergency?)\n");
1075 sal_add_call(op->base.root,op);
1076 sal->callbacks.call_received(op);
1079 static void handle_reinvite(Sal *sal, eXosip_event_t *ev){
1080 SalOp *op=find_op(sal,ev);
1084 ms_warning("Reinvite for non-existing operation !");
1089 sdp=eXosip_get_sdp_info(ev->request);
1090 if (op->base.remote_media){
1091 sal_media_description_unref(op->base.remote_media);
1092 op->base.remote_media=NULL;
1095 sal_media_description_unref(op->result);
1099 op->sdp_offering=FALSE;
1100 op->base.remote_media=sal_media_description_new();
1101 sdp_to_media_description(sdp,op->base.remote_media);
1102 sdp_message_free(sdp);
1105 op->sdp_offering=TRUE;
1107 sal->callbacks.call_updating(op);
1110 static void handle_ack(Sal *sal, eXosip_event_t *ev){
1111 SalOp *op=find_op(sal,ev);
1115 ms_warning("ack for non-existing call !");
1118 if (op->terminated) {
1119 ms_warning("ack for terminated call, ignoring");
1123 if (op->sdp_offering){
1124 sdp=eXosip_get_sdp_info(ev->ack);
1126 if (op->base.remote_media)
1127 sal_media_description_unref(op->base.remote_media);
1128 op->base.remote_media=sal_media_description_new();
1129 sdp_to_media_description(sdp,op->base.remote_media);
1131 sdp_message_free(sdp);
1137 sal->callbacks.call_ack(op);
1140 static void update_contact_from_response(SalOp *op, osip_message_t *response){
1141 const char *received;
1143 SalTransport transport;
1144 if (extract_received_rport(response,&received,&rport,&transport)==0){
1145 const char *contact=sal_op_get_contact(op);
1147 /*no contact given yet, use from instead*/
1148 contact=sal_op_get_from(op);
1151 SalAddress *addr=sal_address_new(contact);
1153 sal_address_set_domain(addr,received);
1154 sal_address_set_port_int(addr,rport);
1155 if (transport!=SalTransportUDP)
1156 sal_address_set_transport(addr,transport);
1157 tmp=sal_address_as_string(addr);
1158 ms_message("Contact address updated to %s",tmp);
1159 sal_op_set_contact(op,tmp);
1160 sal_address_destroy(addr);
1166 static int call_proceeding(Sal *sal, eXosip_event_t *ev){
1167 SalOp *op=find_op(sal,ev);
1169 if (op==NULL || op->terminated==TRUE) {
1170 ms_warning("This call has been canceled.");
1172 eXosip_call_terminate(ev->cid,ev->did);
1180 /* update contact if received and rport are set by the server
1181 note: will only be used by remote for next INVITE, if any...*/
1182 update_contact_from_response(op,ev->response);
1186 static void call_ringing(Sal *sal, eXosip_event_t *ev){
1188 SalOp *op=find_op(sal,ev);
1189 if (call_proceeding(sal, ev)==-1) return;
1191 set_remote_ua(op,ev->response);
1192 sdp=eXosip_get_sdp_info(ev->response);
1194 op->base.remote_media=sal_media_description_new();
1195 sdp_to_media_description(sdp,op->base.remote_media);
1196 sdp_message_free(sdp);
1197 if (op->base.local_media) sdp_process(op);
1199 sal->callbacks.call_ringing(op);
1202 static void call_accepted(Sal *sal, eXosip_event_t *ev){
1204 osip_message_t *msg=NULL;
1205 SalOp *op=find_op(sal,ev);
1206 const char *contact;
1208 if (op==NULL || op->terminated==TRUE) {
1209 ms_warning("This call has been already terminated.");
1211 eXosip_call_terminate(ev->cid,ev->did);
1217 set_remote_ua(op,ev->response);
1219 sdp=eXosip_get_sdp_info(ev->response);
1221 op->base.remote_media=sal_media_description_new();
1222 sdp_to_media_description(sdp,op->base.remote_media);
1223 sdp_message_free(sdp);
1224 if (op->base.local_media) sdp_process(op);
1226 eXosip_call_build_ack(ev->did,&msg);
1228 ms_warning("This call has been already terminated.");
1230 eXosip_call_terminate(ev->cid,ev->did);
1234 contact=sal_op_get_contact(op);
1236 _osip_list_set_empty(&msg->contacts,(void (*)(void*))osip_contact_free);
1237 osip_message_set_contact(msg,contact);
1239 if (op->sdp_answer){
1240 set_sdp(msg,op->sdp_answer);
1241 sdp_message_free(op->sdp_answer);
1242 op->sdp_answer=NULL;
1244 eXosip_call_send_ack(ev->did,msg);
1245 sal->callbacks.call_accepted(op);
1248 static void call_terminated(Sal *sal, eXosip_event_t *ev){
1250 SalOp *op=find_op(sal,ev);
1252 ms_warning("Call terminated for already closed call ?");
1256 osip_from_to_str(ev->request->from,&from);
1258 sal->callbacks.call_terminated(op,from!=NULL ? from : sal_op_get_from(op));
1259 if (from) osip_free(from);
1260 op->terminated=TRUE;
1263 static void call_released(Sal *sal, eXosip_event_t *ev){
1264 SalOp *op=find_op(sal,ev);
1266 ms_warning("No op associated to this call_released()");
1269 if (!op->terminated){
1270 /* no response received so far */
1271 call_failure(sal,ev);
1273 sal->callbacks.call_released(op);
1276 static int get_auth_data_from_response(osip_message_t *resp, const char **realm, const char **username){
1277 const char *prx_realm=NULL,*www_realm=NULL;
1278 osip_proxy_authenticate_t *prx_auth;
1279 osip_www_authenticate_t *www_auth;
1281 *username=osip_uri_get_username(resp->from->url);
1282 prx_auth=(osip_proxy_authenticate_t*)osip_list_get(&resp->proxy_authenticates,0);
1283 www_auth=(osip_proxy_authenticate_t*)osip_list_get(&resp->www_authenticates,0);
1285 prx_realm=osip_proxy_authenticate_get_realm(prx_auth);
1287 www_realm=osip_www_authenticate_get_realm(www_auth);
1291 }else if (www_realm){
1299 static int get_auth_data_from_request(osip_message_t *msg, const char **realm, const char **username){
1300 osip_authorization_t *auth=NULL;
1301 osip_proxy_authorization_t *prx_auth=NULL;
1303 *username=osip_uri_get_username(msg->from->url);
1304 osip_message_get_authorization(msg, 0, &auth);
1306 *realm=osip_authorization_get_realm(auth);
1309 osip_message_get_proxy_authorization(msg,0,&prx_auth);
1311 *realm=osip_proxy_authorization_get_realm(prx_auth);
1317 static int get_auth_data(eXosip_event_t *ev, const char **realm, const char **username){
1318 if (ev->response && get_auth_data_from_response(ev->response,realm,username)==0) return 0;
1319 if (ev->request && get_auth_data_from_request(ev->request,realm,username)==0) return 0;
1323 int sal_op_get_auth_requested(SalOp *op, const char **realm, const char **username){
1324 if (op->pending_auth){
1325 return get_auth_data(op->pending_auth,realm,username);
1330 static bool_t process_authentication(Sal *sal, eXosip_event_t *ev){
1332 const char *username,*realm;
1335 ms_warning("No operation associated with this authentication !");
1338 if (get_auth_data(ev,&realm,&username)==0){
1339 if (op->pending_auth!=NULL){
1340 eXosip_event_free(op->pending_auth);
1341 op->pending_auth=ev;
1343 op->pending_auth=ev;
1344 sal_add_pending_auth(sal,op);
1347 sal->callbacks.auth_requested(op,realm,username);
1353 static void authentication_ok(Sal *sal, eXosip_event_t *ev){
1355 const char *username,*realm;
1358 ms_warning("No operation associated with this authentication_ok!");
1361 if (op->pending_auth){
1362 eXosip_event_free(op->pending_auth);
1363 sal_remove_pending_auth(sal,op);
1364 op->pending_auth=NULL;
1366 if (get_auth_data(ev,&realm,&username)==0){
1367 sal->callbacks.auth_success(op,realm,username);
1371 static bool_t call_failure(Sal *sal, eXosip_event_t *ev){
1374 char* computedReason=NULL;
1375 const char *reason=NULL;
1376 SalError error=SalErrorUnknown;
1377 SalReason sr=SalReasonUnknown;
1380 op=(SalOp*)find_op(sal,ev);
1383 ms_warning("Call failure reported for a closed call, ignored.");
1388 code=osip_message_get_status_code(ev->response);
1389 reason=osip_message_get_reason_phrase(ev->response);
1390 osip_header_t *h=NULL;
1391 if (!osip_message_header_get_byname( ev->response
1395 computedReason = ms_strdup_printf("%s %s",reason,osip_header_get_value(h));
1396 reason = computedReason;
1404 return process_authentication(sal,ev);
1407 error=SalErrorUnknown;
1410 error=SalErrorFailure;
1411 sr=SalReasonNotFound;
1414 error=SalErrorFailure;
1418 eXosip_default_action(ev);
1422 error=SalErrorFailure;
1423 sr=SalReasonTemporarilyUnavailable;
1425 error=SalErrorFailure;
1431 error=SalErrorFailure;
1432 sr=SalReasonDoNotDisturb;
1435 error=SalErrorFailure;
1436 sr=SalReasonDeclined;
1440 error=SalErrorFailure;
1441 sr=SalReasonUnknown;
1442 }else error=SalErrorNoResponse;
1444 op->terminated=TRUE;
1445 sal->callbacks.call_failure(op,error,sr,reason,code);
1446 if (computedReason != NULL){
1447 ms_free(computedReason);
1452 /* Request remote side to send us VFU */
1453 void sal_call_send_vfu_request(SalOp *h){
1454 osip_message_t *msg=NULL;
1456 "<?xml version=\"1.0\" encoding=\"utf-8\" ?>"
1460 " <picture_fast_update></picture_fast_update>"
1468 eXosip_call_build_info(h->did,&msg);
1470 osip_message_set_body(msg,info_body,strlen(info_body));
1471 osip_message_set_content_type(msg,"application/media_control+xml");
1472 snprintf(clen,sizeof(clen),"%lu",(unsigned long)strlen(info_body));
1473 osip_message_set_content_length(msg,clen);
1474 eXosip_call_send_request(h->did,msg);
1475 ms_message("Sending VFU request !");
1480 static void process_media_control_xml(Sal *sal, eXosip_event_t *ev){
1481 SalOp *op=find_op(sal,ev);
1482 osip_body_t *body=NULL;
1485 ms_warning("media control xml received without operation context!");
1489 osip_message_get_body(ev->request,0,&body);
1490 if (body && body->body!=NULL &&
1491 strstr(body->body,"picture_fast_update")){
1492 osip_message_t *ans=NULL;
1493 ms_message("Receiving VFU request !");
1494 if (sal->callbacks.vfu_request){
1495 sal->callbacks.vfu_request(op);
1496 eXosip_call_build_answer(ev->tid,200,&ans);
1498 eXosip_call_send_answer(ev->tid,200,ans);
1502 /*in all other cases we must say it is not implemented.*/
1504 osip_message_t *ans=NULL;
1506 eXosip_call_build_answer(ev->tid,501,&ans);
1508 eXosip_call_send_answer(ev->tid,501,ans);
1513 static void process_dtmf_relay(Sal *sal, eXosip_event_t *ev){
1514 SalOp *op=find_op(sal,ev);
1515 osip_body_t *body=NULL;
1518 ms_warning("media dtmf relay received without operation context!");
1522 osip_message_get_body(ev->request,0,&body);
1523 if (body && body->body!=NULL){
1524 osip_message_t *ans=NULL;
1525 const char *name=strstr(body->body,"Signal");
1526 if (name==NULL) name=strstr(body->body,"signal");
1528 ms_warning("Could not extract the dtmf name from the SIP INFO.");
1531 name+=strlen("signal");
1532 if (sscanf(name," = %1s",tmp)==1){
1533 ms_message("Receiving dtmf %s via SIP INFO.",tmp);
1534 if (sal->callbacks.dtmf_received != NULL)
1535 sal->callbacks.dtmf_received(op, tmp[0]);
1539 eXosip_call_build_answer(ev->tid,200,&ans);
1541 eXosip_call_send_answer(ev->tid,200,ans);
1546 static void fill_options_answer(osip_message_t *options){
1547 osip_message_set_allow(options,"INVITE, ACK, BYE, CANCEL, OPTIONS, MESSAGE, SUBSCRIBE, NOTIFY, INFO");
1548 osip_message_set_accept(options,"application/sdp");
1551 static void process_refer(Sal *sal, SalOp *op, eXosip_event_t *ev){
1552 osip_header_t *h=NULL;
1553 osip_message_t *ans=NULL;
1554 ms_message("Receiving REFER request !");
1555 osip_message_header_get_byname(ev->request,"Refer-To",0,&h);
1558 osip_from_t *from=NULL;
1560 osip_from_init(&from);
1562 if (osip_from_parse(from,h->hvalue)==0){
1564 osip_uri_header_t *uh=NULL;
1565 osip_header_t *referred_by=NULL;
1566 osip_uri_header_get_byname(&from->url->url_headers,(char*)"Replaces",&uh);
1567 if (uh!=NULL && uh->gvalue && uh->gvalue[0]!='\0'){
1568 ms_message("Found replaces in Refer-To");
1570 ms_free(op->replaces);
1572 op->replaces=ms_strdup(uh->gvalue);
1574 osip_message_header_get_byname(ev->request,"Referred-By",0,&referred_by);
1575 if (referred_by && referred_by->hvalue && referred_by->hvalue[0]!='\0'){
1576 if (op->referred_by)
1577 ms_free(op->referred_by);
1578 op->referred_by=ms_strdup(referred_by->hvalue);
1581 osip_uri_header_freelist(&from->url->url_headers);
1582 osip_from_to_str(from,&tmp);
1583 sal->callbacks.refer_received(sal,op,tmp);
1585 osip_from_free(from);
1588 eXosip_call_build_answer(ev->tid,202,&ans);
1590 eXosip_call_send_answer(ev->tid,202,ans);
1595 ms_warning("cannot do anything with the refer without destination\n");
1599 static void process_notify(Sal *sal, eXosip_event_t *ev){
1600 osip_header_t *h=NULL;
1602 SalOp *op=find_op(sal,ev);
1603 osip_message_t *ans=NULL;
1605 ms_message("Receiving NOTIFY request !");
1606 osip_from_to_str(ev->request->from,&from);
1607 osip_message_header_get_byname(ev->request,"Event",0,&h);
1609 osip_body_t *body=NULL;
1610 //osip_content_type_t *ct=NULL;
1611 osip_message_get_body(ev->request,0,&body);
1612 //ct=osip_message_get_content_type(ev->request);
1613 if (h->hvalue && strcasecmp(h->hvalue,"refer")==0){
1614 /*special handling of refer events*/
1615 if (body && body->body){
1616 osip_message_t *msg;
1617 osip_message_init(&msg);
1618 if (osip_message_parse_sipfrag(msg,body->body,strlen(body->body))==0){
1619 int code=osip_message_get_status_code(msg);
1621 sal->callbacks.notify_refer(op,SalReferTrying);
1622 }else if (code==200){
1623 sal->callbacks.notify_refer(op,SalReferSuccess);
1624 }else if (code>=400){
1625 sal->callbacks.notify_refer(op,SalReferFailed);
1628 osip_message_free(msg);
1631 /*generic handling*/
1632 sal->callbacks.notify(op,from,h->hvalue);
1635 /*answer that we received the notify*/
1637 eXosip_call_build_answer(ev->tid,200,&ans);
1639 eXosip_call_send_answer(ev->tid,200,ans);
1644 static void call_message_new(Sal *sal, eXosip_event_t *ev){
1645 osip_message_t *ans=NULL;
1647 if (MSG_IS_INFO(ev->request)){
1648 osip_content_type_t *ct;
1649 ct=osip_message_get_content_type(ev->request);
1650 if (ct && ct->subtype){
1651 if (strcmp(ct->subtype,"media_control+xml")==0)
1652 process_media_control_xml(sal,ev);
1653 else if (strcmp(ct->subtype,"dtmf-relay")==0)
1654 process_dtmf_relay(sal,ev);
1656 ms_message("Unhandled SIP INFO.");
1657 /*send an "Not implemented" answer*/
1659 eXosip_call_build_answer(ev->tid,501,&ans);
1661 eXosip_call_send_answer(ev->tid,501,ans);
1665 /*empty SIP INFO, probably to test we are alive. Send an empty answer*/
1667 eXosip_call_build_answer(ev->tid,200,&ans);
1669 eXosip_call_send_answer(ev->tid,200,ans);
1672 }else if(MSG_IS_MESSAGE(ev->request)){
1673 /* SIP messages could be received into call */
1674 text_received(sal, ev);
1676 eXosip_call_build_answer(ev->tid,200,&ans);
1678 eXosip_call_send_answer(ev->tid,200,ans);
1680 }else if(MSG_IS_REFER(ev->request)){
1681 SalOp *op=find_op(sal,ev);
1683 ms_message("Receiving REFER request !");
1684 process_refer(sal,op,ev);
1685 }else if(MSG_IS_NOTIFY(ev->request)){
1686 process_notify(sal,ev);
1687 }else if (MSG_IS_OPTIONS(ev->request)){
1689 eXosip_call_build_answer(ev->tid,200,&ans);
1691 fill_options_answer(ans);
1692 eXosip_call_send_answer(ev->tid,200,ans);
1696 }else ms_warning("call_message_new: No request ?");
1699 static void inc_update(Sal *sal, eXosip_event_t *ev){
1700 osip_message_t *msg=NULL;
1701 ms_message("Processing incoming UPDATE");
1703 eXosip_message_build_answer(ev->tid,200,&msg);
1705 eXosip_message_send_answer(ev->tid,200,msg);
1709 static bool_t comes_from_local_if(osip_message_t *msg){
1710 osip_via_t *via=NULL;
1711 osip_message_get_via(msg,0,&via);
1714 host=osip_via_get_host(via);
1715 if (strcmp(host,"127.0.0.1")==0 || strcmp(host,"::1")==0){
1716 osip_generic_param_t *param=NULL;
1717 osip_via_param_get_byname(via,"received",¶m);
1718 if (param==NULL) return TRUE;
1719 if (param->gvalue &&
1720 (strcmp(param->gvalue,"127.0.0.1")==0 || strcmp(param->gvalue,"::1")==0)){
1728 static void text_received(Sal *sal, eXosip_event_t *ev){
1729 osip_body_t *body=NULL;
1730 char *from=NULL,*msg;
1731 osip_content_type_t* content_type;
1732 osip_uri_param_t* external_body_url;
1733 char unquoted_external_body_url [256];
1734 int external_body_size=0;
1736 content_type= osip_message_get_content_type(ev->request);
1737 if (!content_type) {
1738 ms_error("Could not get message because no content type");
1741 osip_from_to_str(ev->request->from,&from);
1742 if (content_type->type
1743 && strcmp(content_type->type, "text")==0
1744 && content_type->subtype
1745 && strcmp(content_type->subtype, "plain")==0 ) {
1746 osip_message_get_body(ev->request,0,&body);
1748 ms_error("Could not get text message from SIP body");
1752 sal->callbacks.text_received(sal,from,msg);
1753 } if (content_type->type
1754 && strcmp(content_type->type, "message")==0
1755 && content_type->subtype
1756 && strcmp(content_type->subtype, "external-body")==0 ) {
1758 osip_content_type_param_get_byname(content_type, "URL", &external_body_url);
1759 /*remove both first and last character*/
1760 strncpy(unquoted_external_body_url
1761 ,&external_body_url->gvalue[1]
1762 ,external_body_size=MIN(strlen(external_body_url->gvalue)-1,sizeof(unquoted_external_body_url)));
1763 unquoted_external_body_url[external_body_size-1]='\0';
1764 sal->callbacks.message_external_body(sal,from,unquoted_external_body_url);
1767 ms_warning("Unsupported content type [%s/%s]",content_type->type,content_type->subtype);
1774 static void other_request(Sal *sal, eXosip_event_t *ev){
1775 ms_message("in other_request");
1776 if (ev->request==NULL) return;
1777 if (strcmp(ev->request->sip_method,"MESSAGE")==0){
1778 text_received(sal,ev);
1779 eXosip_message_send_answer(ev->tid,200,NULL);
1780 }else if (strcmp(ev->request->sip_method,"OPTIONS")==0){
1781 osip_message_t *options=NULL;
1782 eXosip_options_build_answer(ev->tid,200,&options);
1783 fill_options_answer(options);
1784 eXosip_options_send_answer(ev->tid,200,options);
1785 }else if (strncmp(ev->request->sip_method, "REFER", 5) == 0){
1786 ms_message("Receiving REFER request !");
1787 if (comes_from_local_if(ev->request)) {
1788 process_refer(sal,NULL,ev);
1789 }else ms_warning("Ignored REFER not coming from this local loopback interface.");
1790 }else if (strncmp(ev->request->sip_method, "UPDATE", 6) == 0){
1795 osip_message_to_str(ev->request,&tmp,&msglen);
1797 ms_message("Unsupported request received:\n%s",tmp);
1800 /*answer with a 501 Not implemented*/
1801 eXosip_message_send_answer(ev->tid,501,NULL);
1805 static void masquerade_via(osip_message_t *msg, const char *ip, const char *port){
1806 osip_via_t *via=NULL;
1807 osip_message_get_via(msg,0,&via);
1809 osip_free(via->port);
1810 via->port=osip_strdup(port);
1811 osip_free(via->host);
1812 via->host=osip_strdup(ip);
1817 static bool_t fix_message_contact(SalOp *op, osip_message_t *request,osip_message_t *last_answer, bool_t expire_last_contact) {
1818 osip_contact_t *ctt=NULL;
1819 const char *received;
1821 SalTransport transport;
1824 if (extract_received_rport(last_answer,&received,&rport,&transport)==-1) return FALSE;
1825 osip_message_get_contact(request,0,&ctt);
1827 ms_warning("fix_message_contact(): no contact to update");
1830 if (expire_last_contact){
1831 osip_contact_t *oldct=NULL,*prevct;
1832 osip_generic_param_t *param=NULL;
1833 osip_contact_clone(ctt,&oldct);
1834 while ((prevct=(osip_contact_t*)osip_list_get(&request->contacts,1))!=NULL){
1835 osip_contact_free(prevct);
1836 osip_list_remove(&request->contacts,1);
1838 osip_list_add(&request->contacts,oldct,1);
1839 osip_contact_param_get_byname(oldct,"expires",¶m);
1841 if (param->gvalue) osip_free(param->gvalue);
1842 param->gvalue=osip_strdup("0");
1844 osip_contact_param_add(oldct,osip_strdup("expires"),osip_strdup("0"));
1847 if (ctt->url->host!=NULL){
1848 osip_free(ctt->url->host);
1850 ctt->url->host=osip_strdup(received);
1851 if (ctt->url->port!=NULL){
1852 osip_free(ctt->url->port);
1854 snprintf(port,sizeof(port),"%i",rport);
1855 ctt->url->port=osip_strdup(port);
1856 if (op->masquerade_via) masquerade_via(request,received,port);
1858 if (transport != SalTransportUDP) {
1859 sal_address_set_param((SalAddress *)ctt, "transport", sal_transport_to_string(transport));
1864 static bool_t register_again_with_updated_contact(SalOp *op, osip_message_t *orig_request, osip_message_t *last_answer){
1865 osip_contact_t *ctt=NULL;
1866 SalAddress* ori_contact_address=NULL;
1867 const char *received;
1869 SalTransport transport;
1871 osip_message_t *msg=NULL;
1872 Sal* sal=op->base.root;
1874 bool_t found_valid_contact=FALSE;
1875 bool_t from_request=FALSE;
1877 if (sal->double_reg==FALSE ) return FALSE;
1879 if (extract_received_rport(last_answer,&received,&rport,&transport)==-1) return FALSE;
1882 osip_message_get_contact(last_answer,i,&ctt);
1883 if (!from_request && ctt==NULL) {
1884 osip_message_get_contact(orig_request,0,&ctt);
1888 osip_contact_to_str(ctt,&tmp);
1889 ori_contact_address = sal_address_new(tmp);
1891 /*check if contact is up to date*/
1892 if (strcmp(sal_address_get_domain(ori_contact_address),received) ==0
1893 && sal_address_get_port_int(ori_contact_address) == rport
1894 && sal_address_get_transport(ori_contact_address) == transport) {
1896 ms_message("Register response has up to date contact, doing nothing.");
1898 ms_warning("Register response does not have up to date contact, but last request had."
1899 "Stupid registrar detected, giving up.");
1901 found_valid_contact=TRUE;
1904 sal_address_destroy(ori_contact_address);
1907 }while(!found_valid_contact);
1908 if (!found_valid_contact)
1909 ms_message("Contact do not match, resending register.");
1913 eXosip_register_build_register(op->rid,op->expires,&msg);
1916 ms_warning("Fail to create a contact updated register.");
1919 if (fix_message_contact(op,msg,last_answer,op->base.root->expire_old_contact)) {
1920 eXosip_register_send_register(op->rid,msg);
1922 ms_message("Resending new register with updated contact");
1923 update_contact_from_response(op,last_answer);
1926 ms_warning("Fail to send updated register.");
1934 static void registration_success(Sal *sal, eXosip_event_t *ev){
1935 SalOp *op=sal_find_register(sal,ev->rid);
1936 osip_header_t *h=NULL;
1939 ms_error("Receiving register response for unknown operation");
1942 osip_message_get_expires(ev->request,0,&h);
1943 if (h!=NULL && atoi(h->hvalue)!=0){
1945 if (!register_again_with_updated_contact(op,ev->request,ev->response)){
1946 sal->callbacks.register_success(op,registered);
1949 sal->callbacks.register_success(op,FALSE);
1953 static bool_t registration_failure(Sal *sal, eXosip_event_t *ev){
1955 const char *reason=NULL;
1956 SalOp *op=sal_find_register(sal,ev->rid);
1957 SalReason sr=SalReasonUnknown;
1958 SalError se=SalErrorUnknown;
1961 ms_error("Receiving register failure for unknown operation");
1965 status_code=osip_message_get_status_code(ev->response);
1966 reason=osip_message_get_reason_phrase(ev->response);
1968 switch(status_code){
1971 return process_authentication(sal,ev);
1973 case 423: /*interval too brief*/
1974 {/*retry with greater interval */
1975 osip_header_t *h=NULL;
1976 osip_message_t *msg=NULL;
1977 osip_message_header_get_byname(ev->response,"min-expires",0,&h);
1978 if (h && h->hvalue && h->hvalue[0]!='\0'){
1979 int val=atoi(h->hvalue);
1980 if (val>op->expires)
1982 }else op->expires*=2;
1984 eXosip_register_build_register(op->rid,op->expires,&msg);
1985 eXosip_register_send_register(op->rid,msg);
1989 case 606: /*Not acceptable, workaround for proxies that don't like private addresses
1990 in vias, such as ekiga.net
1991 On the opposite, freephonie.net bugs when via are masqueraded.
1993 op->masquerade_via=TRUE;
1995 /* if contact is up to date, process the failure, otherwise resend a new register with
1996 updated contact first, just in case the faillure is due to incorrect contact */
1997 if (ev->response && register_again_with_updated_contact(op,ev->request,ev->response))
1998 return TRUE; /*we are retrying with an updated contact*/
1999 if (status_code==403){
2001 sr=SalReasonForbidden;
2002 }else if (status_code==0){
2003 se=SalErrorNoResponse;
2005 sal->callbacks.register_failure(op,se,sr,reason);
2010 static void other_request_reply(Sal *sal,eXosip_event_t *ev){
2011 SalOp *op=find_op(sal,ev);
2013 ms_warning("other_request_reply(): Receiving response to unknown request.");
2017 ms_message("Processing reponse status [%i] for method [%s]",ev->response->status_code,osip_message_get_method(ev->request));
2018 update_contact_from_response(op,ev->response);
2019 if (ev->request && strcmp(osip_message_get_method(ev->request),"OPTIONS")==0)
2020 sal->callbacks.ping_reply(op);
2022 if (ev->request && strcmp(osip_message_get_method(ev->request),"MESSAGE")==0) {
2023 /*out of call message acknolegment*/
2024 SalTextDeliveryStatus status=SalTextDeliveryFailed;
2026 if (ev->response->status_code<200){
2027 status=SalTextDeliveryInProgress;
2028 }else if (ev->response->status_code<300 && ev->response->status_code>=200){
2029 status=SalTextDeliveryDone;
2032 sal->callbacks.text_delivery_update(op,status);
2036 static void process_in_call_reply(Sal *sal, eXosip_event_t *ev){
2037 SalOp *op=find_op(sal,ev);
2039 if (ev->request && strcmp(osip_message_get_method(ev->request),"NOTIFY")==0){
2040 if (op->sipfrag_pending){
2041 send_notify_for_refer(op->did,op->sipfrag_pending);
2042 op->sipfrag_pending=NULL;
2048 static bool_t process_event(Sal *sal, eXosip_event_t *ev){
2049 ms_message("linphone process event get a message %d\n",ev->type);
2051 case EXOSIP_CALL_ANSWERED:
2052 ms_message("CALL_ANSWERED\n");
2053 call_accepted(sal,ev);
2054 authentication_ok(sal,ev);
2056 case EXOSIP_CALL_CLOSED:
2057 case EXOSIP_CALL_CANCELLED:
2058 ms_message("CALL_CLOSED or CANCELLED\n");
2059 call_terminated(sal,ev);
2061 case EXOSIP_CALL_TIMEOUT:
2062 case EXOSIP_CALL_NOANSWER:
2063 ms_message("CALL_TIMEOUT or NOANSWER\n");
2064 return call_failure(sal,ev);
2066 case EXOSIP_CALL_REQUESTFAILURE:
2067 case EXOSIP_CALL_GLOBALFAILURE:
2068 case EXOSIP_CALL_SERVERFAILURE:
2069 ms_message("CALL_REQUESTFAILURE or GLOBALFAILURE or SERVERFAILURE\n");
2070 return call_failure(sal,ev);
2072 case EXOSIP_CALL_RELEASED:
2073 ms_message("CALL_RELEASED\n");
2074 call_released(sal, ev);
2076 case EXOSIP_CALL_INVITE:
2077 ms_message("CALL_NEW\n");
2078 inc_new_call(sal,ev);
2080 case EXOSIP_CALL_REINVITE:
2081 handle_reinvite(sal,ev);
2083 case EXOSIP_CALL_ACK:
2084 ms_message("CALL_ACK");
2087 case EXOSIP_CALL_REDIRECTED:
2088 ms_message("CALL_REDIRECTED");
2089 eXosip_default_action(ev);
2091 case EXOSIP_CALL_PROCEEDING:
2092 ms_message("CALL_PROCEEDING");
2093 call_proceeding(sal,ev);
2095 case EXOSIP_CALL_RINGING:
2096 ms_message("CALL_RINGING");
2097 call_ringing(sal,ev);
2098 authentication_ok(sal,ev);
2100 case EXOSIP_CALL_MESSAGE_NEW:
2101 ms_message("EXOSIP_CALL_MESSAGE_NEW");
2102 call_message_new(sal,ev);
2104 case EXOSIP_CALL_MESSAGE_REQUESTFAILURE:
2106 (ev->response->status_code==407 || ev->response->status_code==401)){
2107 return process_authentication(sal,ev);
2110 case EXOSIP_CALL_MESSAGE_ANSWERED:
2111 ms_message("EXOSIP_CALL_MESSAGE_ANSWERED ");
2112 process_in_call_reply(sal,ev);
2114 case EXOSIP_IN_SUBSCRIPTION_NEW:
2115 ms_message("CALL_IN_SUBSCRIPTION_NEW ");
2116 sal_exosip_subscription_recv(sal,ev);
2118 case EXOSIP_IN_SUBSCRIPTION_RELEASED:
2119 ms_message("CALL_SUBSCRIPTION_NEW ");
2120 sal_exosip_in_subscription_closed(sal,ev);
2122 case EXOSIP_SUBSCRIPTION_UPDATE:
2123 ms_message("CALL_SUBSCRIPTION_UPDATE");
2125 case EXOSIP_SUBSCRIPTION_NOTIFY:
2126 ms_message("CALL_SUBSCRIPTION_NOTIFY");
2127 sal_exosip_notify_recv(sal,ev);
2129 case EXOSIP_SUBSCRIPTION_ANSWERED:
2130 ms_message("EXOSIP_SUBSCRIPTION_ANSWERED, ev->sid=%i, ev->did=%i\n",ev->sid,ev->did);
2131 sal_exosip_subscription_answered(sal,ev);
2133 case EXOSIP_SUBSCRIPTION_CLOSED:
2134 ms_message("EXOSIP_SUBSCRIPTION_CLOSED\n");
2135 sal_exosip_subscription_closed(sal,ev);
2137 case EXOSIP_SUBSCRIPTION_REQUESTFAILURE: /**< announce a request failure */
2138 if (ev->response && (ev->response->status_code == 407 || ev->response->status_code == 401)){
2139 return process_authentication(sal,ev);
2141 case EXOSIP_SUBSCRIPTION_SERVERFAILURE:
2142 case EXOSIP_SUBSCRIPTION_GLOBALFAILURE:
2143 sal_exosip_subscription_closed(sal,ev);
2145 case EXOSIP_REGISTRATION_FAILURE:
2146 ms_message("REGISTRATION_FAILURE\n");
2147 return registration_failure(sal,ev);
2149 case EXOSIP_REGISTRATION_SUCCESS:
2150 authentication_ok(sal,ev);
2151 registration_success(sal,ev);
2153 case EXOSIP_MESSAGE_NEW:
2154 other_request(sal,ev);
2156 case EXOSIP_MESSAGE_PROCEEDING:
2157 case EXOSIP_MESSAGE_ANSWERED:
2158 case EXOSIP_MESSAGE_REDIRECTED:
2159 case EXOSIP_MESSAGE_SERVERFAILURE:
2160 case EXOSIP_MESSAGE_GLOBALFAILURE:
2161 other_request_reply(sal,ev);
2163 case EXOSIP_MESSAGE_REQUESTFAILURE:
2164 case EXOSIP_NOTIFICATION_REQUESTFAILURE:
2166 switch (ev->response->status_code) {
2169 return process_authentication(sal,ev);
2171 eXosip_automatic_action ();
2176 other_request_reply(sal,ev);
2179 ms_message("Unhandled exosip event ! %i",ev->type);
2185 int sal_iterate(Sal *sal){
2187 while((ev=eXosip_event_wait(0,0))!=NULL){
2188 if (process_event(sal,ev))
2189 eXosip_event_free(ev);
2191 #ifdef HAVE_EXOSIP_TRYLOCK
2192 if (eXosip_trylock()==0){
2193 eXosip_automatic_refresh();
2196 ms_warning("eXosip_trylock busy.");
2200 eXosip_automatic_refresh();
2206 static void register_set_contact(osip_message_t *msg, const char *contact){
2207 osip_uri_param_t *param = NULL;
2208 osip_contact_t *ct=NULL;
2210 /*we get the line parameter choosed by exosip, and add it to our own contact*/
2211 osip_message_get_contact(msg,0,&ct);
2213 osip_uri_uparam_get_byname(ct->url, "line", ¶m);
2214 if (param && param->gvalue)
2215 line=osip_strdup(param->gvalue);
2217 _osip_list_set_empty(&msg->contacts,(void (*)(void*))osip_contact_free);
2218 osip_message_set_contact(msg,contact);
2219 osip_message_get_contact(msg,0,&ct);
2220 osip_uri_uparam_add(ct->url,osip_strdup("line"),line);
2223 static void sal_register_add_route(osip_message_t *msg, const char *proxy){
2225 snprintf(tmp,sizeof(tmp)-1,"<%s;lr>",proxy);
2227 osip_list_special_free(&msg->routes,(void (*)(void*))osip_route_free);
2228 osip_message_set_route(msg,tmp);
2232 int sal_register(SalOp *h, const char *proxy, const char *from, int expires){
2233 osip_message_t *msg;
2234 const char *contact=sal_op_get_contact(h);
2236 sal_op_set_route(h,proxy);
2238 SalAddress *from_parsed=sal_address_new(from);
2240 char *uri, *domain_ptr = NULL;
2241 if (from_parsed==NULL) {
2242 ms_warning("sal_register() bad from %s",from);
2245 /* Get domain using sal_address_as_string_uri_only() and stripping the username part instead of
2246 using sal_address_get_domain() because to have a properly formatted domain with IPv6 proxy addresses. */
2247 uri = sal_address_as_string_uri_only(from_parsed);
2248 if (uri) domain_ptr = strchr(uri, '@');
2250 snprintf(domain,sizeof(domain),"sip:%s",domain_ptr+1);
2252 snprintf(domain,sizeof(domain),"sip:%s",sal_address_get_domain(from_parsed));
2254 if (uri) ms_free(uri);
2255 sal_address_destroy(from_parsed);
2257 h->rid=eXosip_register_build_initial_register(from,domain,NULL,expires,&msg);
2259 if (contact) register_set_contact(msg,contact);
2260 sal_register_add_route(msg,proxy);
2261 sal_add_register(h->base.root,h);
2263 ms_error("Could not build initial register.");
2269 eXosip_register_build_register(h->rid,expires,&msg);
2270 sal_register_add_route(msg,proxy);
2273 eXosip_register_send_register(h->rid,msg);
2277 return (msg != NULL) ? 0 : -1;
2280 int sal_register_refresh(SalOp *op, int expires){
2281 osip_message_t *msg=NULL;
2282 const char *contact=sal_op_get_contact(op);
2285 ms_error("Unexistant registration context, not possible to refresh.");
2288 #ifdef HAVE_EXOSIP_TRYLOCK
2291 /*iOS hack: in the keep alive handler, we have no more than 10 seconds to refresh registers, otherwise the application is suspended forever.
2292 * In order to prevent this case that can occur when the exosip thread is busy with DNS while network isn't in a good shape, we try to take
2293 * the exosip lock in a non blocking way, and give up if it takes too long*/
2294 while (eXosip_trylock()!=0){
2296 if (tries>30) {/*after 3 seconds, give up*/
2297 ms_warning("Could not obtain exosip lock in a reasonable time, giving up.");
2305 eXosip_register_build_register(op->rid,expires,&msg);
2307 if (contact) register_set_contact(msg,contact);
2308 sal_register_add_route(msg,sal_op_get_route(op));
2309 eXosip_register_send_register(op->rid,msg);
2310 }else ms_error("Could not build REGISTER refresh message.");
2312 return (msg != NULL) ? 0 : -1;
2316 int sal_unregister(SalOp *h){
2317 osip_message_t *msg=NULL;
2319 eXosip_register_build_register(h->rid,0,&msg);
2320 if (msg) eXosip_register_send_register(h->rid,msg);
2321 else ms_warning("Could not build unREGISTER !");
2326 SalAddress * sal_address_new(const char *uri){
2328 osip_from_init(&from);
2330 // Remove front spaces
2331 while (uri[0]==' ') {
2335 if (osip_from_parse(from,uri)!=0){
2336 osip_from_free(from);
2339 if (from->displayname!=NULL && from->displayname[0]=='"'){
2340 char *unquoted=osip_strdup_without_quote(from->displayname);
2341 osip_free(from->displayname);
2342 from->displayname=unquoted;
2344 return (SalAddress*)from;
2347 SalAddress * sal_address_clone(const SalAddress *addr){
2348 osip_from_t *ret=NULL;
2349 osip_from_clone((osip_from_t*)addr,&ret);
2350 return (SalAddress*)ret;
2353 #define null_if_empty(s) (((s)!=NULL && (s)[0]!='\0') ? (s) : NULL )
2355 const char *sal_address_get_scheme(const SalAddress *addr){
2356 const osip_from_t *u=(const osip_from_t*)addr;
2357 return null_if_empty(u->url->scheme);
2360 const char *sal_address_get_display_name(const SalAddress* addr){
2361 const osip_from_t *u=(const osip_from_t*)addr;
2362 return null_if_empty(u->displayname);
2365 const char *sal_address_get_username(const SalAddress *addr){
2366 const osip_from_t *u=(const osip_from_t*)addr;
2367 return null_if_empty(u->url->username);
2370 const char *sal_address_get_domain(const SalAddress *addr){
2371 const osip_from_t *u=(const osip_from_t*)addr;
2372 return null_if_empty(u->url->host);
2375 void sal_address_set_display_name(SalAddress *addr, const char *display_name){
2376 osip_from_t *u=(osip_from_t*)addr;
2377 if (u->displayname!=NULL){
2378 osip_free(u->displayname);
2379 u->displayname=NULL;
2381 if (display_name!=NULL && display_name[0]!='\0'){
2382 u->displayname=osip_strdup(display_name);
2386 void sal_address_set_username(SalAddress *addr, const char *username){
2387 osip_from_t *uri=(osip_from_t*)addr;
2388 if (uri->url->username!=NULL){
2389 osip_free(uri->url->username);
2390 uri->url->username=NULL;
2393 uri->url->username=osip_strdup(username);
2396 void sal_address_set_domain(SalAddress *addr, const char *host){
2397 osip_from_t *uri=(osip_from_t*)addr;
2398 if (uri->url->host!=NULL){
2399 osip_free(uri->url->host);
2400 uri->url->host=NULL;
2403 uri->url->host=osip_strdup(host);
2406 void sal_address_set_port(SalAddress *addr, const char *port){
2407 osip_from_t *uri=(osip_from_t*)addr;
2408 if (uri->url->port!=NULL){
2409 osip_free(uri->url->port);
2410 uri->url->port=NULL;
2413 uri->url->port=osip_strdup(port);
2416 void sal_address_set_port_int(SalAddress *uri, int port){
2419 /*this is the default, special case to leave the port field blank*/
2420 sal_address_set_port(uri,NULL);
2423 snprintf(tmp,sizeof(tmp),"%i",port);
2424 sal_address_set_port(uri,tmp);
2427 void sal_address_clean(SalAddress *addr){
2428 osip_generic_param_freelist(& ((osip_from_t*)addr)->gen_params);
2429 osip_uri_param_freelist(& ((osip_from_t*)addr)->url->url_params);
2432 char *sal_address_as_string(const SalAddress *u){
2434 osip_from_t *from=(osip_from_t *)u;
2435 char *old_displayname=NULL;
2436 /* hack to force use of quotes around the displayname*/
2437 if (from->displayname!=NULL
2438 && from->displayname[0]!='"'){
2439 old_displayname=from->displayname;
2440 from->displayname=osip_enquote(from->displayname);
2442 osip_from_to_str(from,&tmp);
2443 if (old_displayname!=NULL){
2444 ms_free(from->displayname);
2445 from->displayname=old_displayname;
2452 char *sal_address_as_string_uri_only(const SalAddress *u){
2453 char *tmp=NULL,*ret;
2454 osip_uri_to_str(((osip_from_t*)u)->url,&tmp);
2459 void sal_address_set_param(SalAddress *u,const char* name,const char* value) {
2460 osip_uri_param_t *param=NULL;
2461 osip_uri_uparam_get_byname(((osip_from_t*)u)->url,(char*)name,¶m);
2463 osip_uri_uparam_add (((osip_from_t*)u)->url,ms_strdup(name),value ? ms_strdup(value) : NULL);
2465 osip_free(param->gvalue);
2466 param->gvalue=value ? osip_strdup(value) : NULL;
2471 void sal_address_destroy(SalAddress *u){
2472 osip_from_free((osip_from_t*)u);
2475 void sal_set_keepalive_period(Sal *ctx,unsigned int value) {
2476 ctx->keepalive_period=value;
2477 eXosip_set_option (EXOSIP_OPT_UDP_KEEP_ALIVE, &value);
2479 unsigned int sal_get_keepalive_period(Sal *ctx) {
2480 return ctx->keepalive_period;
2483 const char * sal_address_get_port(const SalAddress *addr) {
2484 const osip_from_t *u=(const osip_from_t*)addr;
2485 return null_if_empty(u->url->port);
2488 int sal_address_get_port_int(const SalAddress *uri) {
2489 const char* port = sal_address_get_port(uri);
2496 SalTransport sal_address_get_transport(const SalAddress* addr) {
2497 const osip_from_t *u=(const osip_from_t*)addr;
2498 osip_uri_param_t *transport_param=NULL;
2499 osip_uri_uparam_get_byname(u->url,"transport",&transport_param);
2500 if (transport_param == NULL){
2501 return SalTransportUDP;
2503 return sal_transport_parse(transport_param->gvalue);
2506 void sal_address_set_transport(SalAddress* addr,SalTransport transport) {
2507 sal_address_set_param(addr, "transport", sal_transport_to_string(transport));
2510 /* sends a reinvite. Local media description may have changed by application since call establishment*/
2511 int sal_call_update(SalOp *h, const char *subject){
2513 osip_message_t *reinvite=NULL;
2516 if(eXosip_call_build_request(h->did,"INVITE",&reinvite) != 0 || reinvite==NULL){
2521 osip_message_set_subject(reinvite,subject);
2522 osip_message_set_allow(reinvite, "INVITE, ACK, CANCEL, OPTIONS, BYE, REFER, NOTIFY, MESSAGE, SUBSCRIBE, INFO");
2523 if (h->base.contact){
2524 _osip_list_set_empty(&reinvite->contacts,(void (*)(void*))osip_contact_free);
2525 osip_message_set_contact(reinvite,h->base.contact);
2527 if (h->base.root->session_expires!=0){
2528 osip_message_set_header(reinvite, "Session-expires", "200");
2529 osip_message_set_supported(reinvite, "timer");
2531 if (h->base.local_media){
2532 h->sdp_offering=TRUE;
2533 set_sdp_from_desc(reinvite,h->base.local_media);
2534 }else h->sdp_offering=FALSE;
2536 err = eXosip_call_send_request(h->did, reinvite);
2540 void sal_reuse_authorization(Sal *ctx, bool_t value) {
2541 ctx->reuse_authorization=value;