#include <net/if.h>
#include <ifaddrs.h>
#endif
-
+#include <math.h>
#if !defined(WIN32)
return pt->normal_bitrate;
}
+/*
+ *((codec-birate*ptime/8) + RTP header + UDP header + IP header)*8/ptime;
+ *ptime=1/npacket
+ */
static double get_audio_payload_bandwidth(LinphoneCore *lc, const PayloadType *pt){
double npacket=50;
double packet_size;
int bitrate;
+ if (strcmp(payload_type_get_mime(&payload_type_aaceld_44k), payload_type_get_mime(pt))==0) {
+ /*special case of aac 44K because ptime= 10ms*/
+ npacket=100;
+ }
+
bitrate=get_codec_bitrate(lc,pt);
- packet_size= (((double)bitrate)/(50*8))+UDP_HDR_SZ+RTP_HDR_SZ+IP4_HDR_SZ;
+ packet_size= (((double)bitrate)/(npacket*8))+UDP_HDR_SZ+RTP_HDR_SZ+IP4_HDR_SZ;
return packet_size*8.0*npacket;
}
void linphone_core_update_allocated_audio_bandwidth_in_call(LinphoneCall *call, const PayloadType *pt){
- call->audio_bw=(int)(get_audio_payload_bandwidth(call->core,pt)/1000.0);
+ call->audio_bw=(int)(ceil(get_audio_payload_bandwidth(call->core,pt)/1000.0)); /*rounding codec bandwidth should be avoid, specially for AMR*/
ms_message("Audio bandwidth for this call is %i",call->audio_bw);
}
int parse_hostname_to_addr(const char *server, struct sockaddr_storage *ss, socklen_t *socklen){
struct addrinfo hints,*res=NULL;
+ int family = PF_INET;
+ int port_int = 3478;
int ret;
- const char *port;
+ char port[6];
char host[NI_MAXHOST];
- char *p;
- host[NI_MAXHOST-1]='\0';
- strncpy(host,server,sizeof(host)-1);
- p=strchr(host,':');
- if (p) {
- *p='\0';
- port=p+1;
- }else port="3478";
+ char *p1, *p2;
+ if ((sscanf(server, "[%64[^]]]:%d", host, &port_int) == 2) || (sscanf(server, "[%64[^]]]", host) == 1)) {
+ family = PF_INET6;
+ } else {
+ p1 = strchr(server, ':');
+ p2 = strrchr(server, ':');
+ if (p1 && p2 && (p1 != p2)) {
+ family = PF_INET6;
+ host[NI_MAXHOST-1]='\0';
+ strncpy(host, server, sizeof(host) - 1);
+ } else if (sscanf(server, "%[^:]:%d", host, &port_int) != 2) {
+ host[NI_MAXHOST-1]='\0';
+ strncpy(host, server, sizeof(host) - 1);
+ }
+ }
+ snprintf(port, sizeof(port), "%d", port_int);
memset(&hints,0,sizeof(hints));
- hints.ai_family=PF_INET;
+ hints.ai_family=family;
hints.ai_socktype=SOCK_DGRAM;
hints.ai_protocol=IPPROTO_UDP;
ret=getaddrinfo(host,port,&hints,&res);
return len;
}
-void linphone_core_run_stun_tests(LinphoneCore *lc, LinphoneCall *call){
+/* this functions runs a simple stun test and return the number of milliseconds to complete the tests, or -1 if the test were failed.*/
+int linphone_core_run_stun_tests(LinphoneCore *lc, LinphoneCall *call){
const char *server=linphone_core_get_stun_server(lc);
-
+ StunCandidate *ac=&call->ac;
+ StunCandidate *vc=&call->vc;
+
if (lc->sip_conf.ipv6_enabled){
ms_warning("stun support is not implemented for ipv6");
- return;
+ return -1;
}
if (server!=NULL){
struct sockaddr_storage ss;
bool_t got_audio,got_video;
bool_t cone_audio=FALSE,cone_video=FALSE;
struct timeval init,cur;
- SalEndpointCandidate *ac,*vc;
-
- ac=&call->localdesc->streams[0].candidates[0];
- vc=&call->localdesc->streams[1].candidates[0];
+ double elapsed;
+ int ret=0;
if (parse_hostname_to_addr(server,&ss,&ss_len)<0){
ms_error("Fail to parser stun server address: %s",server);
- return;
+ return -1;
}
if (lc->vtable.display_status!=NULL)
lc->vtable.display_status(lc,_("Stun lookup in progress..."));
/*create the two audio and video RTP sockets, and send STUN message to our stun server */
sock1=create_socket(call->audio_port);
- if (sock1==-1) return;
+ if (sock1==-1) return -1;
if (video_enabled){
sock2=create_socket(call->video_port);
- if (sock2==-1) return ;
+ if (sock2==-1) return -1;
}
got_audio=FALSE;
got_video=FALSE;
gettimeofday(&init,NULL);
do{
- double elapsed;
+
int id;
if (loops%20==0){
ms_message("Sending stun requests...");
elapsed=((cur.tv_sec-init.tv_sec)*1000.0) + ((cur.tv_usec-init.tv_usec)/1000.0);
if (elapsed>2000) {
ms_message("Stun responses timeout, going ahead.");
+ ret=-1;
break;
}
loops++;
}while(!(got_audio && (got_video||sock2==-1) ) );
+ if (ret==0) ret=(int)elapsed;
if (!got_audio){
ms_error("No stun server response for audio port.");
}else{
}
}
}
- if ((ac->addr[0]!='\0' && vc->addr[0]!='\0' && strcmp(ac->addr,vc->addr)==0)
- || sock2==-1){
- strcpy(call->localdesc->addr,ac->addr);
- }
close_socket(sock1);
if (sock2!=-1) close_socket(sock2);
+ return ret;
+ }
+ return -1;
+}
+
+int linphone_core_get_edge_bw(LinphoneCore *lc){
+ int edge_bw=lp_config_get_int(lc->config,"net","edge_bw",20);
+ return edge_bw;
+}
+
+int linphone_core_get_edge_ptime(LinphoneCore *lc){
+ int edge_ptime=lp_config_get_int(lc->config,"net","edge_ptime",100);
+ return edge_ptime;
+}
+
+void linphone_core_adapt_to_network(LinphoneCore *lc, int ping_time_ms, LinphoneCallParams *params){
+ if (ping_time_ms>0 && lp_config_get_int(lc->config,"net","activate_edge_workarounds",0)==1){
+ ms_message("Stun server ping time is %i ms",ping_time_ms);
+ int threshold=lp_config_get_int(lc->config,"net","edge_ping_time",500);
+
+ if (ping_time_ms>threshold){
+ /* we might be in a 2G network*/
+ params->low_bandwidth=TRUE;
+ }/*else use default settings */
+ }
+ if (params->low_bandwidth){
+ params->up_bw=params->down_bw=linphone_core_get_edge_bw(lc);
+ params->up_ptime=params->down_ptime=linphone_core_get_edge_ptime(lc);
+ params->has_video=FALSE;
}
}
+
+
int linphone_core_gather_ice_candidates(LinphoneCore *lc, LinphoneCall *call)
{
char local_addr[64];
lc->vtable.display_status(lc, _("ICE local candidates gathering in progress..."));
/* Gather local host candidates. */
- if (linphone_core_get_local_ip_for(AF_INET, NULL, local_addr) < 0) {
+ if (linphone_core_get_local_ip_for(AF_INET, server, local_addr) < 0) {
ms_error("Fail to get local ip");
return -1;
}
- ice_add_local_candidate(audio_check_list, "host", local_addr, call->audio_port, 1, NULL);
- ice_add_local_candidate(audio_check_list, "host", local_addr, call->audio_port + 1, 2, NULL);
- if (call->params.has_video && (video_check_list != NULL)) {
+ if ((ice_check_list_state(audio_check_list) != ICL_Completed) && (ice_check_list_candidates_gathered(audio_check_list) == FALSE)) {
+ ice_add_local_candidate(audio_check_list, "host", local_addr, call->audio_port, 1, NULL);
+ ice_add_local_candidate(audio_check_list, "host", local_addr, call->audio_port + 1, 2, NULL);
+ call->stats[LINPHONE_CALL_STATS_AUDIO].ice_state = LinphoneIceStateInProgress;
+ }
+ if (call->params.has_video && (video_check_list != NULL)
+ && (ice_check_list_state(video_check_list) != ICL_Completed) && (ice_check_list_candidates_gathered(video_check_list) == FALSE)) {
ice_add_local_candidate(video_check_list, "host", local_addr, call->video_port, 1, NULL);
ice_add_local_candidate(video_check_list, "host", local_addr, call->video_port + 1, 2, NULL);
+ call->stats[LINPHONE_CALL_STATS_VIDEO].ice_state = LinphoneIceStateInProgress;
}
+ ms_message("ICE: gathering candidate from [%s]",server);
/* Gather local srflx candidates. */
ice_session_gather_candidates(call->ice_session, ss, ss_len);
return 0;
}
+void linphone_core_update_ice_state_in_call_stats(LinphoneCall *call)
+{
+ IceCheckList *audio_check_list;
+ IceCheckList *video_check_list;
+ IceSessionState session_state;
+
+ if (call->ice_session == NULL) return;
+ audio_check_list = ice_session_check_list(call->ice_session, 0);
+ video_check_list = ice_session_check_list(call->ice_session, 1);
+ if (audio_check_list == NULL) return;
+
+ session_state = ice_session_state(call->ice_session);
+ if ((session_state == IS_Completed) || ((session_state == IS_Failed) && (ice_session_has_completed_check_list(call->ice_session) == TRUE))) {
+ if (ice_check_list_state(audio_check_list) == ICL_Completed) {
+ switch (ice_check_list_selected_valid_candidate_type(audio_check_list)) {
+ case ICT_HostCandidate:
+ call->stats[LINPHONE_CALL_STATS_AUDIO].ice_state = LinphoneIceStateHostConnection;
+ break;
+ case ICT_ServerReflexiveCandidate:
+ case ICT_PeerReflexiveCandidate:
+ call->stats[LINPHONE_CALL_STATS_AUDIO].ice_state = LinphoneIceStateReflexiveConnection;
+ break;
+ case ICT_RelayedCandidate:
+ call->stats[LINPHONE_CALL_STATS_AUDIO].ice_state = LinphoneIceStateRelayConnection;
+ break;
+ }
+ } else {
+ call->stats[LINPHONE_CALL_STATS_AUDIO].ice_state = LinphoneIceStateFailed;
+ }
+ if (call->params.has_video && (video_check_list != NULL)) {
+ if (ice_check_list_state(video_check_list) == ICL_Completed) {
+ switch (ice_check_list_selected_valid_candidate_type(video_check_list)) {
+ case ICT_HostCandidate:
+ call->stats[LINPHONE_CALL_STATS_VIDEO].ice_state = LinphoneIceStateHostConnection;
+ break;
+ case ICT_ServerReflexiveCandidate:
+ case ICT_PeerReflexiveCandidate:
+ call->stats[LINPHONE_CALL_STATS_VIDEO].ice_state = LinphoneIceStateReflexiveConnection;
+ break;
+ case ICT_RelayedCandidate:
+ call->stats[LINPHONE_CALL_STATS_VIDEO].ice_state = LinphoneIceStateRelayConnection;
+ break;
+ }
+ } else {
+ call->stats[LINPHONE_CALL_STATS_VIDEO].ice_state = LinphoneIceStateFailed;
+ }
+ }
+ } else if (session_state == IS_Running) {
+ call->stats[LINPHONE_CALL_STATS_AUDIO].ice_state = LinphoneIceStateInProgress;
+ if (call->params.has_video && (video_check_list != NULL)) {
+ call->stats[LINPHONE_CALL_STATS_VIDEO].ice_state = LinphoneIceStateInProgress;
+ }
+ } else {
+ call->stats[LINPHONE_CALL_STATS_AUDIO].ice_state = LinphoneIceStateFailed;
+ if (call->params.has_video && (video_check_list != NULL)) {
+ call->stats[LINPHONE_CALL_STATS_VIDEO].ice_state = LinphoneIceStateFailed;
+ }
+ }
+}
+
void linphone_core_update_local_media_description_from_ice(SalMediaDescription *desc, IceSession *session)
{
const char *rtp_addr, *rtcp_addr;
if (session_state == IS_Completed) {
desc->ice_completed = TRUE;
- ice_check_list_selected_valid_local_candidate(ice_session_check_list(session, 0), &rtp_addr, NULL, NULL, NULL);
- strncpy(desc->addr, rtp_addr, sizeof(desc->addr));
+ result = ice_check_list_selected_valid_local_candidate(ice_session_check_list(session, 0), &rtp_addr, NULL, NULL, NULL);
+ if (result == TRUE) {
+ strncpy(desc->addr, rtp_addr, sizeof(desc->addr));
+ } else {
+ ms_warning("If ICE has completed successfully, rtp_addr should be set!");
+ }
}
else {
desc->ice_completed = FALSE;
}
strncpy(desc->ice_pwd, ice_session_local_pwd(session), sizeof(desc->ice_pwd));
strncpy(desc->ice_ufrag, ice_session_local_ufrag(session), sizeof(desc->ice_ufrag));
- for (i = 0; i < desc->nstreams; i++) {
+ for (i = 0; i < desc->n_active_streams; i++) {
SalStreamDescription *stream = &desc->streams[i];
IceCheckList *cl = ice_session_check_list(session, i);
nb_candidates = 0;
if (cl == NULL) continue;
- if (cl->state == ICL_Completed) {
+ if (ice_check_list_state(cl) == ICL_Completed) {
stream->ice_completed = TRUE;
result = ice_check_list_selected_valid_local_candidate(ice_session_check_list(session, i), &rtp_addr, &stream->rtp_port, &rtcp_addr, &stream->rtcp_port);
} else {
else
memset(stream->ice_pwd, 0, sizeof(stream->ice_pwd));
stream->ice_mismatch = ice_check_list_is_mismatch(cl);
- if ((cl->state == ICL_Running) || (cl->state == ICL_Completed)) {
+ if ((ice_check_list_state(cl) == ICL_Running) || (ice_check_list_state(cl) == ICL_Completed)) {
memset(stream->ice_candidates, 0, sizeof(stream->ice_candidates));
for (j = 0; j < MIN(ms_list_size(cl->local_candidates), SAL_MEDIA_DESCRIPTION_MAX_ICE_CANDIDATES); j++) {
SalIceCandidate *sal_candidate = &stream->ice_candidates[nb_candidates];
} else continue;
if (default_addr[0] == '\0') default_addr = desc->addr;
/* Only include the candidates matching the default destination for each component of the stream if the state is Completed as specified in RFC5245 section 9.1.2.2. */
- if ((cl->state == ICL_Completed)
+ if ((ice_check_list_state(cl) == ICL_Completed)
&& !((ice_candidate->taddr.port == default_port) && (strlen(ice_candidate->taddr.ip) == strlen(default_addr)) && (strcmp(ice_candidate->taddr.ip, default_addr) == 0)))
continue;
strncpy(sal_candidate->foundation, ice_candidate->foundation, sizeof(sal_candidate->foundation));
nb_candidates++;
}
}
- if ((cl->state == ICL_Completed) && (ice_session_role(session) == IR_Controlling)) {
+ if ((ice_check_list_state(cl) == ICL_Completed) && (ice_session_role(session) == IR_Controlling)) {
int rtp_port, rtcp_port;
memset(stream->ice_remote_candidates, 0, sizeof(stream->ice_remote_candidates));
- ice_check_list_selected_valid_remote_candidate(cl, &rtp_addr, &rtp_port, &rtcp_addr, &rtcp_port);
- strncpy(stream->ice_remote_candidates[0].addr, rtp_addr, sizeof(stream->ice_remote_candidates[0].addr));
- stream->ice_remote_candidates[0].port = rtp_port;
- strncpy(stream->ice_remote_candidates[1].addr, rtcp_addr, sizeof(stream->ice_remote_candidates[1].addr));
- stream->ice_remote_candidates[1].port = rtcp_port;
+ if (ice_check_list_selected_valid_remote_candidate(cl, &rtp_addr, &rtp_port, &rtcp_addr, &rtcp_port) == TRUE) {
+ strncpy(stream->ice_remote_candidates[0].addr, rtp_addr, sizeof(stream->ice_remote_candidates[0].addr));
+ stream->ice_remote_candidates[0].port = rtp_port;
+ strncpy(stream->ice_remote_candidates[1].addr, rtcp_addr, sizeof(stream->ice_remote_candidates[1].addr));
+ stream->ice_remote_candidates[1].port = rtcp_port;
+ } else {
+ ms_error("ice: Selected valid remote candidates should be present if the check list is in the Completed state");
+ }
+ } else {
+ for (j = 0; j < SAL_MEDIA_DESCRIPTION_MAX_ICE_REMOTE_CANDIDATES; j++) {
+ stream->ice_remote_candidates[j].addr[0] = '\0';
+ stream->ice_remote_candidates[j].port = 0;
+ }
}
}
}
ice_session_restart(call->ice_session);
ice_restarted = TRUE;
} else {
- for (i = 0; i < md->nstreams; i++) {
+ for (i = 0; i < md->n_total_streams; i++) {
const SalStreamDescription *stream = &md->streams[i];
IceCheckList *cl = ice_session_check_list(call->ice_session, i);
if (cl && (strcmp(stream->rtp_addr, "0.0.0.0") == 0)) {
}
ice_session_set_remote_credentials(call->ice_session, md->ice_ufrag, md->ice_pwd);
}
- for (i = 0; i < md->nstreams; i++) {
+ for (i = 0; i < md->n_total_streams; i++) {
const SalStreamDescription *stream = &md->streams[i];
IceCheckList *cl = ice_session_check_list(call->ice_session, i);
if (cl && (stream->ice_pwd[0] != '\0') && (stream->ice_ufrag[0] != '\0')) {
}
/* Create ICE check lists if needed and parse ICE attributes. */
- for (i = 0; i < md->nstreams; i++) {
+ for (i = 0; i < md->n_total_streams; i++) {
const SalStreamDescription *stream = &md->streams[i];
IceCheckList *cl = ice_session_check_list(call->ice_session, i);
- if (cl == NULL) {
+ if ((cl == NULL) && (i < md->n_active_streams)) {
cl = ice_check_list_new();
ice_session_add_check_list(call->ice_session, cl);
switch (stream->type) {
case SalAudio:
- if (call->audiostream != NULL) call->audiostream->ice_check_list = cl;
+ if (call->audiostream != NULL) call->audiostream->ms.ice_check_list = cl;
break;
case SalVideo:
- if (call->videostream != NULL) call->videostream->ice_check_list = cl;
+ if (call->videostream != NULL) call->videostream->ms.ice_check_list = cl;
break;
default:
break;
}
}
- if ((stream->ice_mismatch == TRUE) || (stream->rtp_port == 0)) {
+ if (stream->ice_mismatch == TRUE) {
ice_check_list_set_state(cl, ICL_Failed);
+ } else if (stream->rtp_port == 0) {
+ ice_session_remove_check_list(call->ice_session, cl);
} else {
if ((stream->ice_pwd[0] != '\0') && (stream->ice_ufrag[0] != '\0'))
ice_check_list_set_remote_credentials(cl, stream->ice_ufrag, stream->ice_pwd);
candidate->priority, candidate->foundation, default_candidate);
}
if (ice_restarted == FALSE) {
+ bool_t losing_pairs_added = FALSE;
for (j = 0; j < SAL_MEDIA_DESCRIPTION_MAX_ICE_REMOTE_CANDIDATES; j++) {
const SalIceRemoteCandidate *candidate = &stream->ice_remote_candidates[j];
const char *addr = NULL;
int componentID = j + 1;
if (candidate->addr[0] == '\0') break;
get_default_addr_and_port(componentID, md, stream, &addr, &port);
- ice_add_losing_pair(ice_session_check_list(call->ice_session, i), j + 1, candidate->addr, candidate->port, addr, port);
+ if (j == 0) {
+ /* If we receive a re-invite and we finished ICE processing on our side, use the candidates given by the remote. */
+ ice_check_list_unselect_valid_pairs(cl);
+ }
+ ice_add_losing_pair(cl, j + 1, candidate->addr, candidate->port, addr, port);
+ losing_pairs_added = TRUE;
}
+ if (losing_pairs_added == TRUE) ice_check_list_check_completed(cl);
}
}
}
- for (i = ice_session_nb_check_lists(call->ice_session); i > md->nstreams; i--) {
+ for (i = ice_session_nb_check_lists(call->ice_session); i > md->n_active_streams; i--) {
ice_session_remove_check_list(call->ice_session, ice_session_check_list(call->ice_session, i - 1));
}
ice_session_check_mismatch(call->ice_session);
+ } else {
+ /* Response from remote does not contain mandatory ICE attributes, delete the session. */
+ linphone_call_delete_ice_session(call);
+ return;
}
if (ice_session_nb_check_lists(call->ice_session) == 0) {
linphone_call_delete_ice_session(call);
}
}
+bool_t linphone_core_media_description_contains_video_stream(const SalMediaDescription *md)
+{
+ int i;
+
+ for (i = 0; i < md->n_active_streams; i++) {
+ if (md->streams[i].type == SalVideo)
+ return TRUE;
+ }
+ return FALSE;
+}
+
LinphoneCall * is_a_linphone_call(void *user_pointer){
LinphoneCall *call=(LinphoneCall*)user_pointer;
if (call==NULL) return NULL;
else if (strcasecmp(name,"VOL_RCV")==0) ret|=AUDIO_STREAM_FEATURE_VOL_RCV;
else if (strcasecmp(name,"DTMF")==0) ret|=AUDIO_STREAM_FEATURE_DTMF;
else if (strcasecmp(name,"DTMF_ECHO")==0) ret|=AUDIO_STREAM_FEATURE_DTMF_ECHO;
+ else if (strcasecmp(name,"MIXED_RECORDING")==0) ret|=AUDIO_STREAM_FEATURE_MIXED_RECORDING;
else if (strcasecmp(name,"ALL")==0) ret|=AUDIO_STREAM_FEATURE_ALL;
else if (strcasecmp(name,"NONE")==0) ret=0;
else ms_error("Unsupported audio feature %s requested in config file.",name);
p=n;
}
}else ret=AUDIO_STREAM_FEATURE_ALL;
+
+ if (ret==AUDIO_STREAM_FEATURE_ALL){
+ /*since call recording is specified before creation of the stream in linphonecore,
+ * it will be requested on demand. It is not necessary to include it all the time*/
+ ret&=~AUDIO_STREAM_FEATURE_MIXED_RECORDING;
+ }
return ret;
}
+bool_t linphone_core_tone_indications_enabled(LinphoneCore*lc){
+ return lp_config_get_int(lc->config,"sound","tone_indications",1);
+}
#ifdef HAVE_GETIFADDRS
if (getifaddrs(&ifpstart) < 0) {
return -1;
}
-
+#ifndef __linux
+ #define UP_FLAG IFF_UP /* interface is up */
+#else
+ #define UP_FLAG IFF_RUNNING /* resources allocated */
+#endif
+
for (ifp = ifpstart; ifp != NULL; ifp = ifp->ifa_next) {
if (ifp->ifa_addr && ifp->ifa_addr->sa_family == type
- && (ifp->ifa_flags & IFF_RUNNING) && !(ifp->ifa_flags & IFF_LOOPBACK))
+ && (ifp->ifa_flags & UP_FLAG) && !(ifp->ifa_flags & IFF_LOOPBACK))
{
- getnameinfo(ifp->ifa_addr,
+ if(getnameinfo(ifp->ifa_addr,
(type == AF_INET6) ?
sizeof(struct sockaddr_in6) : sizeof(struct sockaddr_in),
- address, size, NULL, 0, NI_NUMERICHOST);
- if (strchr(address, '%') == NULL) { /*avoid ipv6 link-local addresses */
- /*ms_message("getifaddrs() found %s",address);*/
- ret++;
- break;
+ address, size, NULL, 0, NI_NUMERICHOST) == 0) {
+ if (strchr(address, '%') == NULL) { /*avoid ipv6 link-local addresses */
+ /*ms_message("getifaddrs() found %s",address);*/
+ ret++;
+ break;
+ }
}
}
}
}
int linphone_core_get_local_ip_for(int type, const char *dest, char *result){
- strcpy(result,type==AF_INET ? "127.0.0.1" : "::1");
+ strcpy(result,type==AF_INET ? "127.0.0.1" : "::1");
#ifdef HAVE_GETIFADDRS
- if (dest==NULL) {
- /*we use getifaddrs for lookup of default interface */
- int found_ifs;
-
- found_ifs=get_local_ip_with_getifaddrs(type,result,LINPHONE_IPADDR_SIZE);
- if (found_ifs==1){
- return 0;
- }else if (found_ifs<=0){
- /*absolutely no network on this machine */
- return -1;
- }
- }
+ if (dest==NULL) {
+ /*we use getifaddrs for lookup of default interface */
+ int found_ifs;
+
+ found_ifs=get_local_ip_with_getifaddrs(type,result,LINPHONE_IPADDR_SIZE);
+ if (found_ifs==1){
+ return 0;
+ }else if (found_ifs<=0){
+ /*absolutely no network on this machine */
+ return -1;
+ }
+ }
#endif
- /*else use connect to find the best local ip address */
- if (type==AF_INET)
- dest="87.98.157.38"; /*a public IP address*/
- else dest="2a00:1450:8002::68";
- return get_local_ip_for_with_connect(type,dest,result);
+ /*else use connect to find the best local ip address */
+ if (type==AF_INET)
+ dest="87.98.157.38"; /*a public IP address*/
+ else dest="2a00:1450:8002::68";
+ return get_local_ip_for_with_connect(type,dest,result);
}
#ifndef WIN32