misc.c 65.7 KB
Newer Older
aymeric's avatar
aymeric committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

/*
linphone
Copyright (C) 2000  Simon MORLAT (simon.morlat@linphone.org)

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#include "private.h"
22
#include "lpconfig.h"
aymeric's avatar
aymeric committed
23 24 25
#include "mediastreamer2/mediastream.h"
#include <stdlib.h>
#include <stdio.h>
26
#ifdef HAVE_SIGHANDLER_T
aymeric's avatar
aymeric committed
27
#include <signal.h>
28
#endif /*HAVE_SIGHANDLER_T*/
Simon Morlat's avatar
Simon Morlat committed
29 30 31 32

#include <string.h>
#if !defined(_WIN32_WCE)
#include <errno.h>
aymeric's avatar
aymeric committed
33 34
#include <sys/types.h>
#include <sys/stat.h>
35 36 37
#if _MSC_VER
#include <io.h>
#else
aymeric's avatar
aymeric committed
38
#include <unistd.h>
39
#endif
aymeric's avatar
aymeric committed
40
#include <fcntl.h>
Jehan Monnier's avatar
Jehan Monnier committed
41
#endif /*_WIN32_WCE*/
aymeric's avatar
aymeric committed
42

43
#undef snprintf
jehan's avatar
jehan committed
44
#include <mediastreamer2/stun.h>
aymeric's avatar
aymeric committed
45

46 47 48 49
#ifdef HAVE_GETIFADDRS
#include <net/if.h>
#include <ifaddrs.h>
#endif
50
#include <math.h>
51 52 53 54
#if _MSC_VER
#define snprintf _snprintf
#define popen _popen
#define pclose _pclose
55
#endif
56

aymeric's avatar
aymeric committed
57 58 59 60 61

#define UDP_HDR_SZ 8
#define RTP_HDR_SZ 12
#define IP4_HDR_SZ 20   /*20 is the minimum, but there may be some options*/

62
static void clear_ice_check_list(LinphoneCall *call, IceCheckList *removed);
aymeric's avatar
aymeric committed
63

64
bool_t linphone_core_payload_type_enabled(LinphoneCore *lc, const LinphonePayloadType *pt){
65
	if (ms_list_find(lc->codecs_conf.audio_codecs, (PayloadType*) pt) || ms_list_find(lc->codecs_conf.video_codecs, (PayloadType*)pt) || ms_list_find(lc->codecs_conf.text_codecs, (PayloadType*)pt)){
66 67 68 69
		return payload_type_enabled(pt);
	}
	ms_error("Getting enablement status of codec not in audio or video list of PayloadType !");
	return FALSE;
aymeric's avatar
aymeric committed
70
}
71

72
bool_t linphone_core_payload_type_is_vbr(LinphoneCore *lc, const LinphonePayloadType *pt){
73 74 75 76
	if (pt->type==PAYLOAD_VIDEO) return TRUE;
	return !!(pt->flags & PAYLOAD_TYPE_IS_VBR);
}

77
int linphone_core_enable_payload_type(LinphoneCore *lc, LinphonePayloadType *pt, bool_t enabled){
78
	if (ms_list_find(lc->codecs_conf.audio_codecs,pt) || ms_list_find(lc->codecs_conf.video_codecs,pt) || ms_list_find(lc->codecs_conf.text_codecs,pt)){
79
		payload_type_set_enable(pt,enabled);
80
		_linphone_core_codec_config_write(lc);
81
		linphone_core_update_allocated_audio_bandwidth(lc);
82 83 84 85
		return 0;
	}
	ms_error("Enabling codec not in audio or video list of PayloadType !");
	return -1;
aymeric's avatar
aymeric committed
86 87
}

88
int linphone_core_get_payload_type_number(LinphoneCore *lc, const PayloadType *pt){
89
	return payload_type_get_number(pt);
90 91
}

92 93 94 95
void linphone_core_set_payload_type_number(LinphoneCore *lc, PayloadType *pt, int number){
	payload_type_set_number(pt,number);
}

96 97 98
const char *linphone_core_get_payload_type_description(LinphoneCore *lc, PayloadType *pt){
	if (ms_filter_codec_supported(pt->mime_type)){
		MSFilterDesc *desc=ms_filter_get_encoder(pt->mime_type);
99
#ifdef ENABLE_NLS
100 101 102 103
		return dgettext("mediastreamer",desc->text);
#else
		return desc->text;
#endif
104 105
	}
	return NULL;
aymeric's avatar
aymeric committed
106 107
}

108
void linphone_core_set_payload_type_bitrate(LinphoneCore *lc, LinphonePayloadType *pt, int bitrate){
109
	if (ms_list_find(lc->codecs_conf.audio_codecs, (PayloadType*) pt) || ms_list_find(lc->codecs_conf.video_codecs, (PayloadType*)pt) || ms_list_find(lc->codecs_conf.text_codecs, (PayloadType*)pt)){
110
		if (pt->type==PAYLOAD_VIDEO || pt->flags & PAYLOAD_TYPE_IS_VBR){
111 112
			pt->normal_bitrate=bitrate*1000;
			pt->flags|=PAYLOAD_TYPE_BITRATE_OVERRIDE;
113
			linphone_core_update_allocated_audio_bandwidth(lc);
114 115
		}else{
			ms_error("Cannot set an explicit bitrate for codec %s/%i, because it is not VBR.",pt->mime_type,pt->clock_rate);
116
			return;
117
		}
118 119
	} else {
		ms_error("linphone_core_set_payload_type_bitrate() payload type not in audio or video list !");
120 121 122
	}
}

123

124 125 126 127
/*
 *((codec-birate*ptime/8) + RTP header + UDP header + IP header)*8/ptime;
 *ptime=1/npacket
 */
128 129

static double get_audio_payload_bandwidth_from_codec_bitrate(const PayloadType *pt){
aymeric's avatar
aymeric committed
130 131 132
	double npacket=50;
	double packet_size;
	int bitrate;
133

134 135 136
	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;
137 138
	}else if (strcmp(payload_type_get_mime(&payload_type_ilbc), payload_type_get_mime(pt))==0) {
		npacket=1000/30.0;
139
	}
140

141
	bitrate=pt->normal_bitrate;
142
	packet_size= (((double)bitrate)/(npacket*8))+UDP_HDR_SZ+RTP_HDR_SZ+IP4_HDR_SZ;
aymeric's avatar
aymeric committed
143 144 145
	return packet_size*8.0*npacket;
}

146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175
typedef struct vbr_codec_bitrate{
	int max_avail_bitrate;
	int min_rate;
	int recomended_bitrate;
}vbr_codec_bitrate_t;

static vbr_codec_bitrate_t defauls_vbr[]={
	//{ 100, 44100, 100 },
	{ 64, 44100, 50 },
	{ 64, 16000, 40 },
	{ 32, 16000, 32 },
	{ 32, 8000, 32 },
	{ 0 , 8000, 24 },
	{ 0 , 0, 0 }
};

static int lookup_vbr_typical_bitrate(int maxbw, int clock_rate){
	vbr_codec_bitrate_t *it;
	if (maxbw<=0) maxbw=defauls_vbr[0].max_avail_bitrate;
	for(it=defauls_vbr;it->min_rate!=0;it++){
		if (maxbw>=it->max_avail_bitrate && clock_rate>=it->min_rate)
			return it->recomended_bitrate;
	}
	ms_error("lookup_vbr_typical_bitrate(): should not happen.");
	return 32;
}

static int get_audio_payload_bandwidth(LinphoneCore *lc, const PayloadType *pt, int maxbw){
	if (linphone_core_payload_type_is_vbr(lc,pt)){
		if (pt->flags & PAYLOAD_TYPE_BITRATE_OVERRIDE){
176
			ms_debug("PayloadType %s/%i has bitrate override",pt->mime_type,pt->clock_rate);
177 178 179 180 181 182
			return pt->normal_bitrate/1000;
		}
		return lookup_vbr_typical_bitrate(maxbw,pt->clock_rate);
	}else return (int)ceil(get_audio_payload_bandwidth_from_codec_bitrate(pt)/1000.0);/*rounding codec bandwidth should be avoid, specially for AMR*/
}

183
int linphone_core_get_payload_type_bitrate(LinphoneCore *lc, const LinphonePayloadType *pt){
184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201
	int maxbw=get_min_bandwidth(linphone_core_get_download_bandwidth(lc),
					linphone_core_get_upload_bandwidth(lc));
	if (pt->type==PAYLOAD_AUDIO_CONTINUOUS || pt->type==PAYLOAD_AUDIO_PACKETIZED){
		return get_audio_payload_bandwidth(lc,pt,maxbw);
	}else if (pt->type==PAYLOAD_VIDEO){
		int video_bw;
		if (maxbw<=0) {
			video_bw=1500; /*default bitrate for video stream when no bandwidth limit is set, around 1.5 Mbit/s*/
		}else{
			video_bw=get_remaining_bandwidth_for_video(maxbw,lc->audio_bw);
		}
		return video_bw;
	}
	return 0;
}

void linphone_core_update_allocated_audio_bandwidth_in_call(LinphoneCall *call, const PayloadType *pt, int maxbw){
	call->audio_bw=get_audio_payload_bandwidth(call->core,pt,maxbw);
Simon Morlat's avatar
Simon Morlat committed
202
	ms_message("Audio bandwidth for this call is %i",call->audio_bw);
aymeric's avatar
aymeric committed
203 204
}

205
void linphone_core_update_allocated_audio_bandwidth(LinphoneCore *lc){
aymeric's avatar
aymeric committed
206
	const MSList *elem;
207 208 209
	int maxbw=get_min_bandwidth(linphone_core_get_download_bandwidth(lc),
					linphone_core_get_upload_bandwidth(lc));
	int max_codec_bitrate=0;
210

aymeric's avatar
aymeric committed
211 212 213
	for(elem=linphone_core_get_audio_codecs(lc);elem!=NULL;elem=elem->next){
		PayloadType *pt=(PayloadType*)elem->data;
		if (payload_type_enabled(pt)){
214 215 216 217 218
			int pt_bitrate=get_audio_payload_bandwidth(lc,pt,maxbw);
			if (max_codec_bitrate==0) {
				max_codec_bitrate=pt_bitrate;
			}else if (max_codec_bitrate<pt_bitrate){
				max_codec_bitrate=pt_bitrate;
aymeric's avatar
aymeric committed
219 220 221
			}
		}
	}
222 223
	if (max_codec_bitrate) {
		lc->audio_bw=max_codec_bitrate;
aymeric's avatar
aymeric committed
224 225 226
	}
}

227
bool_t linphone_core_is_payload_type_usable_for_bandwidth(LinphoneCore *lc, const PayloadType *pt, int bandwidth_limit){
228
	double codec_band;
229
	const int video_enablement_limit = 99;
230
	bool_t ret=FALSE;
231

232 233 234
	switch (pt->type){
		case PAYLOAD_AUDIO_CONTINUOUS:
		case PAYLOAD_AUDIO_PACKETIZED:
235
			codec_band=get_audio_payload_bandwidth(lc,pt,bandwidth_limit);
236
			ret=bandwidth_is_greater(bandwidth_limit,(int)codec_band);
237
			/*ms_message("Payload %s: codec_bandwidth=%g, bandwidth_limit=%i",pt->mime_type,codec_band,bandwidth_limit);*/
238 239
			break;
		case PAYLOAD_VIDEO:
240
			if (bandwidth_limit<=0 || bandwidth_limit >= video_enablement_limit) {/* infinite or greater than video_enablement_limit*/
241 242 243 244
				ret=TRUE;
			}
			else ret=FALSE;
			break;
Sylvain Berfini's avatar
Sylvain Berfini committed
245 246 247
		case PAYLOAD_TEXT:
			ret=TRUE;
			break;
248 249 250 251
	}
	return ret;
}

aymeric's avatar
aymeric committed
252
/* return TRUE if codec can be used with bandwidth, FALSE else*/
253
bool_t linphone_core_check_payload_type_usability(LinphoneCore *lc, const PayloadType *pt){
254 255 256
	int maxbw=get_min_bandwidth(linphone_core_get_download_bandwidth(lc),
					linphone_core_get_upload_bandwidth(lc));
	bool_t ret=linphone_core_is_payload_type_usable_for_bandwidth(lc, pt, maxbw);
257
	if ((pt->type==PAYLOAD_AUDIO_CONTINUOUS || pt->type==PAYLOAD_AUDIO_PACKETIZED)
258
		&& lc->sound_conf.capt_sndcard
259 260 261 262 263 264 265 266 267 268
		&& !(ms_snd_card_get_capabilities(lc->sound_conf.capt_sndcard) & MS_SND_CARD_CAP_BUILTIN_ECHO_CANCELLER)
		&& linphone_core_echo_cancellation_enabled(lc)
		&& (pt->clock_rate!=16000 && pt->clock_rate!=8000)
		&& strcasecmp(pt->mime_type,"opus")!=0
		&& ms_filter_lookup_by_name("MSWebRTCAEC")!=NULL){
		ms_warning("Payload type %s/%i cannot be used because software echo cancellation is required but is unable to operate at this rate.",
			   pt->mime_type,pt->clock_rate);
		ret=FALSE;
	}
	return ret;
aymeric's avatar
aymeric committed
269 270 271
}

bool_t lp_spawn_command_line_sync(const char *command, char **result,int *command_ret){
272
#if !defined(_WIN32_WCE) && !defined(LINPHONE_WINDOWS_UNIVERSAL)
aymeric's avatar
aymeric committed
273 274 275 276 277 278 279 280 281 282 283 284 285 286 287
	FILE *f=popen(command,"r");
	if (f!=NULL){
		int err;
		*result=ms_malloc(4096);
		err=fread(*result,1,4096-1,f);
		if (err<0){
			ms_warning("Error reading command output:%s",strerror(errno));
			ms_free(result);
			return FALSE;
		}
		(*result)[err]=0;
		err=pclose(f);
		if (command_ret!=NULL) *command_ret=err;
		return TRUE;
	}
288
#endif /*_WIN32_WCE*/
aymeric's avatar
aymeric committed
289 290 291
	return FALSE;
}

smorlat's avatar
smorlat committed
292 293 294 295 296 297 298 299 300 301 302 303 304 305
static ortp_socket_t create_socket(int local_port){
	struct sockaddr_in laddr;
	ortp_socket_t sock;
	int optval;
	sock=socket(PF_INET,SOCK_DGRAM,IPPROTO_UDP);
	if (sock<0) {
		ms_error("Fail to create socket");
		return -1;
	}
	memset (&laddr,0,sizeof(laddr));
	laddr.sin_family=AF_INET;
	laddr.sin_addr.s_addr=INADDR_ANY;
	laddr.sin_port=htons(local_port);
	if (bind(sock,(struct sockaddr*)&laddr,sizeof(laddr))<0){
smorlat's avatar
smorlat committed
306
		ms_error("Bind socket to 0.0.0.0:%i failed: %s",local_port,getSocketError());
smorlat's avatar
smorlat committed
307 308 309 310 311 312 313 314 315 316 317 318
		close_socket(sock);
		return -1;
	}
	optval=1;
	if (setsockopt (sock, SOL_SOCKET, SO_REUSEADDR,
				(SOCKET_OPTION_VALUE)&optval, sizeof (optval))<0){
		ms_warning("Fail to set SO_REUSEADDR");
	}
	set_non_blocking_socket(sock);
	return sock;
}

smorlat's avatar
smorlat committed
319
static int sendStunRequest(int sock, const struct sockaddr *server, socklen_t addrlen, int id, bool_t changeAddr){
smorlat's avatar
smorlat committed
320 321 322
	char buf[STUN_MAX_MESSAGE_SIZE];
	int len = STUN_MAX_MESSAGE_SIZE;
	StunAtrString username;
323
	StunAtrString password;
smorlat's avatar
smorlat committed
324 325 326 327 328
	StunMessage req;
	int err;
	memset(&req, 0, sizeof(StunMessage));
	memset(&username,0,sizeof(username));
	memset(&password,0,sizeof(password));
smorlat's avatar
smorlat committed
329
	stunBuildReqSimple( &req, &username, changeAddr , changeAddr , id);
aymeric's avatar
aymeric committed
330
	len = stunEncodeMessage( &req, buf, len, &password);
smorlat's avatar
smorlat committed
331 332 333 334 335 336 337 338 339 340 341 342
	if (len<=0){
		ms_error("Fail to encode stun message.");
		return -1;
	}
	err=sendto(sock,buf,len,0,server,addrlen);
	if (err<0){
		ms_error("sendto failed: %s",strerror(errno));
		return -1;
	}
	return 0;
}

343 344
int linphone_parse_host_port(const char *input, char *host, size_t hostlen, int *port){
	char tmphost[NI_MAXHOST]={0};
345
	char *p1, *p2;
346

347
	if ((sscanf(input, "[%64[^]]]:%d", tmphost, port) == 2) || (sscanf(input, "[%64[^]]]", tmphost) == 1)) {
348

349
	} else {
350 351 352 353 354 355 356
		p1 = strchr(input, ':');
		p2 = strrchr(input, ':');
		if (p1 && p2 && (p1 != p2)) {/* an ipv6 address without port*/
			strncpy(tmphost, input, sizeof(tmphost) - 1);
		} else if (sscanf(input, "%[^:]:%d", tmphost, port) != 2) {
			/*no port*/
			strncpy(tmphost, input, sizeof(tmphost) - 1);
357 358
		}
	}
359 360 361 362 363 364 365 366 367 368
	strncpy(host,tmphost,hostlen);
	return 0;
}

int parse_hostname_to_addr(const char *server, struct sockaddr_storage *ss, socklen_t *socklen, int default_port){
	struct addrinfo hints,*res=NULL;
	char port[6];
	char host[NI_MAXHOST];
	int port_int=default_port;
	int ret;
369

370
	linphone_parse_host_port(server,host,sizeof(host),&port_int);
371

372
	snprintf(port, sizeof(port), "%d", port_int);
smorlat's avatar
smorlat committed
373
	memset(&hints,0,sizeof(hints));
374
	hints.ai_family=AF_UNSPEC;
smorlat's avatar
smorlat committed
375 376 377 378 379 380 381 382 383
	hints.ai_socktype=SOCK_DGRAM;
	hints.ai_protocol=IPPROTO_UDP;
	ret=getaddrinfo(host,port,&hints,&res);
	if (ret!=0){
		ms_error("getaddrinfo() failed for %s:%s : %s",host,port,gai_strerror(ret));
		return -1;
	}
	if (!res) return -1;
	memcpy(ss,res->ai_addr,res->ai_addrlen);
384
	*socklen=(socklen_t)res->ai_addrlen;
smorlat's avatar
smorlat committed
385 386 387 388
	freeaddrinfo(res);
	return 0;
}

smorlat's avatar
smorlat committed
389
static int recvStunResponse(ortp_socket_t sock, char *ipaddr, int *port, int *id){
smorlat's avatar
smorlat committed
390
	char buf[STUN_MAX_MESSAGE_SIZE];
391
	int len = STUN_MAX_MESSAGE_SIZE;
smorlat's avatar
smorlat committed
392 393 394 395
	StunMessage resp;
	len=recv(sock,buf,len,0);
	if (len>0){
		struct in_addr ia;
aymeric's avatar
aymeric committed
396 397
		stunParseMessage(buf,len, &resp );
		*id=resp.msgHdr.tr_id.octet[0];
398 399 400 401 402 403 404
		if (resp.hasXorMappedAddress){
			*port = resp.xorMappedAddress.ipv4.port;
			ia.s_addr=htonl(resp.xorMappedAddress.ipv4.addr);
		}else if (resp.hasMappedAddress){
			*port = resp.mappedAddress.ipv4.port;
			ia.s_addr=htonl(resp.mappedAddress.ipv4.addr);
		}else return -1;
smorlat's avatar
smorlat committed
405 406 407 408 409
		strncpy(ipaddr,inet_ntoa(ia),LINPHONE_IPADDR_SIZE);
	}
	return len;
}

410
/* this functions runs a simple stun test and return the number of milliseconds to complete the tests, or -1 if the test were failed.*/
411
int linphone_core_run_stun_tests(LinphoneCore *lc, LinphoneCall *call){
smorlat's avatar
smorlat committed
412
	const char *server=linphone_core_get_stun_server(lc);
413 414
	StunCandidate *ac=&call->ac;
	StunCandidate *vc=&call->vc;
415
	StunCandidate *tc=&call->tc;
416

smorlat's avatar
smorlat committed
417 418
	if (lc->sip_conf.ipv6_enabled){
		ms_warning("stun support is not implemented for ipv6");
419
		return -1;
smorlat's avatar
smorlat committed
420
	}
421
	if (call->media_ports[call->main_audio_stream_index].rtp_port==-1){
422 423 424
		ms_warning("Stun-only support not available for system random port");
		return -1;
	}
smorlat's avatar
smorlat committed
425
	if (server!=NULL){
426
		const struct addrinfo *ai=linphone_core_get_stun_server_addrinfo(lc);
427
		ortp_socket_t sock1=-1, sock2=-1, sock3=-1;
428
		int loops=0;
smorlat's avatar
smorlat committed
429
		bool_t video_enabled=linphone_core_video_enabled(lc);
430 431
		bool_t got_audio,got_video,got_text;
		bool_t cone_audio=FALSE,cone_video=FALSE,cone_text=FALSE;
smorlat's avatar
smorlat committed
432
		struct timeval init,cur;
433 434
		double elapsed;
		int ret=0;
435

436 437
		if (ai==NULL){
			ms_error("Could not obtain stun server addrinfo.");
438
			return -1;
smorlat's avatar
smorlat committed
439
		}
440
		linphone_core_notify_display_status(lc,_("Stun lookup in progress..."));
441

smorlat's avatar
smorlat committed
442
		/*create the two audio and video RTP sockets, and send STUN message to our stun server */
443
		sock1=create_socket(call->media_ports[call->main_audio_stream_index].rtp_port);
444
		if (sock1==-1) return -1;
smorlat's avatar
smorlat committed
445
		if (video_enabled){
446
			sock2=create_socket(call->media_ports[call->main_video_stream_index].rtp_port);
447
			if (sock2==-1) return -1;
smorlat's avatar
smorlat committed
448
		}
Sylvain Berfini's avatar
Sylvain Berfini committed
449 450 451
		sock3=create_socket(call->media_ports[call->main_text_stream_index].rtp_port);
		if (sock3==-1) return -1;
		
smorlat's avatar
smorlat committed
452 453
		got_audio=FALSE;
		got_video=FALSE;
454
		got_text=FALSE;
455
		ortp_gettimeofday(&init,NULL);
smorlat's avatar
smorlat committed
456
		do{
457

smorlat's avatar
smorlat committed
458
			int id;
459 460
			if (loops%20==0){
				ms_message("Sending stun requests...");
461 462
				sendStunRequest((int)sock1,ai->ai_addr,(socklen_t)ai->ai_addrlen,11,TRUE);
				sendStunRequest((int)sock1,ai->ai_addr,(socklen_t)ai->ai_addrlen,1,FALSE);
463
				if (sock2!=-1){
464 465
					sendStunRequest((int)sock2,ai->ai_addr,(socklen_t)ai->ai_addrlen,22,TRUE);
					sendStunRequest((int)sock2,ai->ai_addr,(socklen_t)ai->ai_addrlen,2,FALSE);
466
				}
467
				if (sock3!=-1){
468 469
					sendStunRequest((int)sock3,ai->ai_addr,(socklen_t)ai->ai_addrlen,33,TRUE);
					sendStunRequest((int)sock3,ai->ai_addr,(socklen_t)ai->ai_addrlen,3,FALSE);
470
				}
471
			}
472
			ms_usleep(10000);
smorlat's avatar
smorlat committed
473

474 475
			if (recvStunResponse(sock1,ac->addr,
						&ac->port,&id)>0){
smorlat's avatar
smorlat committed
476
				ms_message("STUN test result: local audio port maps to %s:%i",
477 478
						ac->addr,
						ac->port);
smorlat's avatar
smorlat committed
479 480
				if (id==11)
					cone_audio=TRUE;
smorlat's avatar
smorlat committed
481 482
				got_audio=TRUE;
			}
483 484
			if (recvStunResponse(sock2,vc->addr,
							&vc->port,&id)>0){
smorlat's avatar
smorlat committed
485
				ms_message("STUN test result: local video port maps to %s:%i",
486 487
					vc->addr,
					vc->port);
smorlat's avatar
smorlat committed
488 489
				if (id==22)
					cone_video=TRUE;
smorlat's avatar
smorlat committed
490
				got_video=TRUE;
smorlat's avatar
smorlat committed
491
			}
492 493 494 495 496 497 498 499 500
			if (recvStunResponse(sock3,tc->addr,
							&tc->port,&id)>0){
				ms_message("STUN test result: local text port maps to %s:%i",
					tc->addr,
					tc->port);
				if (id==33)
					cone_text=TRUE;
				got_text=TRUE;
			}
501
			ortp_gettimeofday(&cur,NULL);
smorlat's avatar
smorlat committed
502
			elapsed=((cur.tv_sec-init.tv_sec)*1000.0) +  ((cur.tv_usec-init.tv_usec)/1000.0);
503 504
			if (elapsed>2000)  {
				ms_message("Stun responses timeout, going ahead.");
505
				ret=-1;
506 507 508
				break;
			}
			loops++;
509
		}while(!(got_audio && (got_video||sock2==-1) && (got_text||sock3==-1)  ) );
510
		if (ret==0) ret=(int)elapsed;
smorlat's avatar
smorlat committed
511 512
		if (!got_audio){
			ms_error("No stun server response for audio port.");
smorlat's avatar
smorlat committed
513 514
		}else{
			if (!cone_audio) {
515
				ms_message("NAT is symmetric for audio port");
smorlat's avatar
smorlat committed
516
			}
smorlat's avatar
smorlat committed
517
		}
518
		if (sock2!=-1){
smorlat's avatar
smorlat committed
519 520 521 522
			if (!got_video){
				ms_error("No stun server response for video port.");
			}else{
				if (!cone_video) {
523
					ms_message("NAT is symmetric for video port.");
smorlat's avatar
smorlat committed
524 525
				}
			}
smorlat's avatar
smorlat committed
526
		}
527 528 529 530 531 532 533 534 535
		if (sock3!=-1){
			if (!got_text){
				ms_error("No stun server response for text port.");
			}else{
				if (!cone_text) {
					ms_message("NAT is symmetric for text port.");
				}
			}
		}
smorlat's avatar
smorlat committed
536
		close_socket(sock1);
537
		if (sock2!=-1) close_socket(sock2);
538
		if (sock3!=-1) close_socket(sock3);
539
		return ret;
smorlat's avatar
smorlat committed
540
	}
541
	return -1;
smorlat's avatar
smorlat committed
542 543
}

544 545 546 547 548 549 550 551 552 553
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;
}

554
void linphone_core_adapt_to_network(LinphoneCore *lc, int ping_time_ms, LinphoneCallParams *params){
555
	int threshold;
556
	if (ping_time_ms>0 && lp_config_get_int(lc->config,"net","activate_edge_workarounds",0)==1){
557
		ms_message("Stun server ping time is %i ms",ping_time_ms);
558
		threshold=lp_config_get_int(lc->config,"net","edge_ping_time",500);
559

560
		if (ping_time_ms>threshold){
561
			/* we might be in a 2G network*/
jehan's avatar
jehan committed
562
			params->low_bandwidth=TRUE;
563 564
		}/*else use default settings */
	}
565 566 567 568 569
	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;
	}
570 571
}

572 573
static void stun_server_resolved(LinphoneCore *lc, const char *name, struct addrinfo *addrinfo){
	if (lc->net_conf.stun_addrinfo){
574
		belle_sip_freeaddrinfo(lc->net_conf.stun_addrinfo);
575 576 577 578 579 580 581 582
		lc->net_conf.stun_addrinfo=NULL;
	}
	if (addrinfo){
		ms_message("Stun server resolution successful.");
	}else{
		ms_warning("Stun server resolution failed.");
	}
	lc->net_conf.stun_addrinfo=addrinfo;
583
	lc->net_conf.stun_res=NULL;
584
}
585

586
void linphone_core_resolve_stun_server(LinphoneCore *lc){
587 588 589 590
	/*
	 * WARNING: stun server resolution only done in IPv4.
	 * TODO: use IPv6 resolution if linphone_core_ipv6_enabled()==TRUE and use V4Mapped addresses for ICE gathering.
	 */
591
	const char *server=lc->net_conf.stun_server;
592
	if (lc->sal && server && !lc->net_conf.stun_res){
593 594 595
		char host[NI_MAXHOST];
		int port=3478;
		linphone_parse_host_port(server,host,sizeof(host),&port);
596
		lc->net_conf.stun_res=sal_resolve_a(lc->sal,host,port,AF_INET,(SalResolverCallback)stun_server_resolved,lc);
597 598 599 600 601 602 603 604 605 606 607
	}
}

/*
 * This function returns the addrinfo representation of the stun server address.
 * It is critical not to block for a long time if it can't be resolved, otherwise this stucks the main thread when making a call.
 * On the contrary, a fully asynchronous call initiation is complex to develop.
 * The compromise is then:
 * - have a cache of the stun server addrinfo
 * - this cached value is returned when it is non-null
 * - an asynchronous resolution is asked each time this function is called to ensure frequent refreshes of the cached value.
608
 * - if no cached value exists, block for a short time; this case must be unprobable because the resolution will be asked each time the stun server value is
609 610 611 612 613 614 615 616
 * changed.
**/
const struct addrinfo *linphone_core_get_stun_server_addrinfo(LinphoneCore *lc){
	const char *server=linphone_core_get_stun_server(lc);
	if (server){
		int wait_ms=0;
		int wait_limit=1000;
		linphone_core_resolve_stun_server(lc);
617
		while (!lc->net_conf.stun_addrinfo && lc->net_conf.stun_res!=NULL && wait_ms<wait_limit){
618 619 620 621 622 623 624
			sal_iterate(lc->sal);
			ms_usleep(50000);
			wait_ms+=50;
		}
	}
	return lc->net_conf.stun_addrinfo;
}
625

626
int linphone_core_gather_ice_candidates(LinphoneCore *lc, LinphoneCall *call)
627
{
628
	char local_addr[64];
629
	const struct addrinfo *ai;
630 631
	IceCheckList *audio_check_list;
	IceCheckList *video_check_list;
632
	IceCheckList *text_check_list;
633 634
	const char *server = linphone_core_get_stun_server(lc);

635
	if ((server == NULL) || (call->ice_session == NULL)) return -1;
636 637 638
	audio_check_list = ice_session_check_list(call->ice_session, call->main_audio_stream_index);
	video_check_list = ice_session_check_list(call->ice_session, call->main_video_stream_index);
	text_check_list = ice_session_check_list(call->ice_session, call->main_text_stream_index);
639
	if (audio_check_list == NULL) return -1;
640

641 642
	if (call->af==AF_INET6){
		ms_warning("Ice gathering is not implemented for ipv6");
643
		return -1;
644
	}
645 646 647
	ai=linphone_core_get_stun_server_addrinfo(lc);
	if (ai==NULL){
		ms_warning("Fail to resolve STUN server for ICE gathering.");
648
		return -1;
649
	}
650
	linphone_core_notify_display_status(lc, _("ICE local candidates gathering in progress..."));
651

652
	/* Gather local host candidates. */
653
	if (linphone_core_get_local_ip_for(AF_INET, NULL, local_addr) < 0) {
654
		ms_error("Fail to get local ip");
655
		return -1;
656
	}
657
	if ((ice_check_list_state(audio_check_list) != ICL_Completed) && (ice_check_list_candidates_gathered(audio_check_list) == FALSE)) {
658 659
		ice_add_local_candidate(audio_check_list, "host", local_addr, call->media_ports[call->main_audio_stream_index].rtp_port, 1, NULL);
		ice_add_local_candidate(audio_check_list, "host", local_addr, call->media_ports[call->main_audio_stream_index].rtcp_port, 2, NULL);
660 661
		call->stats[LINPHONE_CALL_STATS_AUDIO].ice_state = LinphoneIceStateInProgress;
	}
662
	if (linphone_core_video_enabled(lc) && (video_check_list != NULL)
663
		&& (ice_check_list_state(video_check_list) != ICL_Completed) && (ice_check_list_candidates_gathered(video_check_list) == FALSE)) {
664 665
		ice_add_local_candidate(video_check_list, "host", local_addr, call->media_ports[call->main_video_stream_index].rtp_port, 1, NULL);
		ice_add_local_candidate(video_check_list, "host", local_addr, call->media_ports[call->main_video_stream_index].rtcp_port, 2, NULL);
666
		call->stats[LINPHONE_CALL_STATS_VIDEO].ice_state = LinphoneIceStateInProgress;
667
	}
668 669 670 671 672 673
	if (call->params->realtimetext_enabled && (text_check_list != NULL)
		&& (ice_check_list_state(text_check_list) != ICL_Completed) && (ice_check_list_candidates_gathered(text_check_list) == FALSE)) {
		ice_add_local_candidate(text_check_list, "host", local_addr, call->media_ports[call->main_text_stream_index].rtp_port, 1, NULL);
		ice_add_local_candidate(text_check_list, "host", local_addr, call->media_ports[call->main_text_stream_index].rtcp_port, 2, NULL);
		call->stats[LINPHONE_CALL_STATS_TEXT].ice_state = LinphoneIceStateInProgress;
	}
674

675
	ms_message("ICE: gathering candidate from [%s]",server);
676
	/* Gather local srflx candidates. */
677
	ice_session_gather_candidates(call->ice_session, ai->ai_addr, (socklen_t)ai->ai_addrlen);
678
	return 0;
679 680
}

681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698
const char *linphone_ice_state_to_string(LinphoneIceState state){
	switch(state){
		case LinphoneIceStateFailed:
			return "IceStateFailed";
		case LinphoneIceStateHostConnection:
			return "IceStateHostConnection";
		case LinphoneIceStateInProgress:
			return "IceStateInProgress";
		case LinphoneIceStateNotActivated:
			return "IceStateNotActivated";
		case LinphoneIceStateReflexiveConnection:
			return "IceStateReflexiveConnection";
		case LinphoneIceStateRelayConnection:
			return "IceStateRelayConnection";
	}
	return "invalid";
}

699 700 701 702
void linphone_core_update_ice_state_in_call_stats(LinphoneCall *call)
{
	IceCheckList *audio_check_list;
	IceCheckList *video_check_list;
703
	IceCheckList *text_check_list;
Ghislain MARY's avatar
Ghislain MARY committed
704
	IceSessionState session_state;
705 706

	if (call->ice_session == NULL) return;
707 708
	audio_check_list = ice_session_check_list(call->ice_session, call->main_audio_stream_index);
	video_check_list = ice_session_check_list(call->ice_session, call->main_video_stream_index);
709
	text_check_list = ice_session_check_list(call->ice_session, call->main_text_stream_index);
710 711
	if (audio_check_list == NULL) return;

Ghislain MARY's avatar
Ghislain MARY committed
712 713
	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))) {
714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729
		if (call->params->has_audio && (audio_check_list != NULL)) {
			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;
Ghislain MARY's avatar
Ghislain MARY committed
730
			}
731 732
		}else call->stats[LINPHONE_CALL_STATS_AUDIO].ice_state = LinphoneIceStateNotActivated;
		
733
		if (call->params->has_video && (video_check_list != NULL)) {
734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749
			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;
			}
Simon Morlat's avatar
Simon Morlat committed
750
		}else call->stats[LINPHONE_CALL_STATS_VIDEO].ice_state = LinphoneIceStateNotActivated;
751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769
		
		if (call->params->realtimetext_enabled && (text_check_list != NULL)) {
			if (ice_check_list_state(text_check_list) == ICL_Completed) {
				switch (ice_check_list_selected_valid_candidate_type(text_check_list)) {
					case ICT_HostCandidate:
						call->stats[LINPHONE_CALL_STATS_TEXT].ice_state = LinphoneIceStateHostConnection;
						break;
					case ICT_ServerReflexiveCandidate:
					case ICT_PeerReflexiveCandidate:
						call->stats[LINPHONE_CALL_STATS_TEXT].ice_state = LinphoneIceStateReflexiveConnection;
						break;
					case ICT_RelayedCandidate:
						call->stats[LINPHONE_CALL_STATS_TEXT].ice_state = LinphoneIceStateRelayConnection;
						break;
				}
			} else {
				call->stats[LINPHONE_CALL_STATS_TEXT].ice_state = LinphoneIceStateFailed;
			}
		}else call->stats[LINPHONE_CALL_STATS_TEXT].ice_state = LinphoneIceStateNotActivated;
770 771
	} else if (session_state == IS_Running) {
		call->stats[LINPHONE_CALL_STATS_AUDIO].ice_state = LinphoneIceStateInProgress;
772
		if (call->params->has_video && (video_check_list != NULL)) {
773 774
			call->stats[LINPHONE_CALL_STATS_VIDEO].ice_state = LinphoneIceStateInProgress;
		}
775 776 777
		if (call->params->realtimetext_enabled && (text_check_list != NULL)) {
			call->stats[LINPHONE_CALL_STATS_TEXT].ice_state = LinphoneIceStateInProgress;
		}
Ghislain MARY's avatar
Ghislain MARY committed
778 779
	} else {
		call->stats[LINPHONE_CALL_STATS_AUDIO].ice_state = LinphoneIceStateFailed;
780
		if (call->params->has_video && (video_check_list != NULL)) {
Ghislain MARY's avatar
Ghislain MARY committed
781 782
			call->stats[LINPHONE_CALL_STATS_VIDEO].ice_state = LinphoneIceStateFailed;
		}
783 784 785
		if (call->params->realtimetext_enabled && (text_check_list != NULL)) {
			call->stats[LINPHONE_CALL_STATS_TEXT].ice_state = LinphoneIceStateFailed;
		}
786
	}
787 788
	ms_message("Call [%p] New ICE state: audio: [%s]    video: [%s]    text: [%s]", call,
		   linphone_ice_state_to_string(call->stats[LINPHONE_CALL_STATS_AUDIO].ice_state), linphone_ice_state_to_string(call->stats[LINPHONE_CALL_STATS_VIDEO].ice_state), linphone_ice_state_to_string(call->stats[LINPHONE_CALL_STATS_TEXT].ice_state));
789 790
}

Simon Morlat's avatar
Simon Morlat committed
791
void linphone_call_stop_ice_for_inactive_streams(LinphoneCall *call, SalMediaDescription *desc) {
792
	int i;
793
	IceSession *session = call->ice_session;
794

795 796 797
	if (session == NULL) return;
	if (ice_session_state(session) == IS_Completed) return;

798
	for (i = 0; i < desc->nb_streams; i++) {
799 800 801
		IceCheckList *cl = ice_session_check_list(session, i);
		if (!sal_stream_description_active(&desc->streams[i]) && cl) {
			ice_session_remove_check_list(session, cl);
802
			clear_ice_check_list(call, cl);
803 804
		}
	}
805 806

	linphone_core_update_ice_state_in_call_stats(call);
807 808 809
}

void _update_local_media_description_from_ice(SalMediaDescription *desc, IceSession *session) {
810
	const char *rtp_addr, *rtcp_addr;
811
	IceSessionState session_state = ice_session_state(session);
812
	int nb_candidates;
813
	int i, j;
814
	bool_t result;
815

816 817
	if (session_state == IS_Completed) {
		desc->ice_completed = TRUE;
818 819 820 821 822 823
		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!");
		}
824 825 826 827
	}
	else {
		desc->ice_completed = FALSE;
	}
828 829
	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));
830
	for (i = 0; i < desc->nb_streams; i++) {
831 832
		SalStreamDescription *stream = &desc->streams[i];
		IceCheckList *cl = ice_session_check_list(session, i);
833
		nb_candidates = 0;
834
		if (!sal_stream_description_active(stream) || (cl == NULL)) continue;
835
		if (ice_check_list_state(cl) == ICL_Completed) {
836
			stream->ice_completed = TRUE;
837 838 839 840 841 842
			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 {
			stream->ice_completed = FALSE;
			result = ice_check_list_default_local_candidate(ice_session_check_list(session, i), &rtp_addr, &stream->rtp_port, &rtcp_addr, &stream->rtcp_port);
		}
		if (result == TRUE) {
843 844 845
			strncpy(stream->rtp_addr, rtp_addr, sizeof(stream->rtp_addr));
			strncpy(stream->rtcp_addr, rtcp_addr, sizeof(stream->rtcp_addr));
		} else {
846 847
			memset(stream->rtp_addr, 0, sizeof(stream->rtp_addr));
			memset(stream->rtcp_addr, 0, sizeof(stream->rtcp_addr));
848
		}
849 850 851 852 853 854 855 856
		if ((strlen(ice_check_list_local_pwd(cl)) != strlen(desc->ice_pwd)) || (strcmp(ice_check_list_local_pwd(cl), desc->ice_pwd)))
			strncpy(stream->ice_pwd, ice_check_list_local_pwd(cl), sizeof(stream->ice_pwd));
		else
			memset(stream->ice_pwd, 0, sizeof(stream->ice_pwd));
		if ((strlen(ice_check_list_local_ufrag(cl)) != strlen(desc->ice_ufrag)) || (strcmp(ice_check_list_local_ufrag(cl), desc->ice_ufrag)))
			strncpy(stream->ice_ufrag, ice_check_list_local_ufrag(cl), sizeof(stream->ice_ufrag));
		else
			memset(stream->ice_pwd, 0, sizeof(stream->ice_pwd));
857
		stream->ice_mismatch = ice_check_list_is_mismatch(cl);
858
		if ((ice_check_list_state(cl) == ICL_Running) || (ice_check_list_state(cl) == ICL_Completed)) {
859
			memset(stream->ice_candidates, 0, sizeof(stream->ice_candidates));
Ghislain MARY's avatar
Ghislain MARY committed
860
			for (j = 0; j < MIN(ms_list_size(cl->local_candidates), SAL_MEDIA_DESCRIPTION_MAX_ICE_CANDIDATES); j++) {
861
				SalIceCandidate *sal_candidate = &stream->ice_candidates[nb_candidates];
862 863 864 865 866 867 868 869 870 871 872 873
				IceCandidate *ice_candidate = ms_list_nth_data(cl->local_candidates, j);
				const char *default_addr = NULL;
				int default_port = 0;
				if (ice_candidate->componentID == 1) {
					default_addr = stream->rtp_addr;
					default_port = stream->rtp_port;
				} else if (ice_candidate->componentID == 2) {
					default_addr = stream->rtcp_addr;
					default_port = stream->rtcp_port;
				} 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. */
874
				if ((ice_check_list_state(cl) == ICL_Completed)
875 876 877 878 879 880 881 882 883 884 885 886
					&& !((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));
				sal_candidate->componentID = ice_candidate->componentID;
				sal_candidate->priority = ice_candidate->priority;
				strncpy(sal_candidate->type, ice_candidate_type(ice_candidate), sizeof(sal_candidate->type));
				strncpy(sal_candidate->addr, ice_candidate->taddr.ip, sizeof(sal_candidate->addr));
				sal_candidate->port = ice_candidate->taddr.port;
				if ((ice_candidate->base != NULL) && (ice_candidate->base != ice_candidate)) {
					strncpy(sal_candidate->raddr, ice_candidate->base->taddr.ip, sizeof(sal_candidate->raddr));
					sal_candidate->rport = ice_candidate->base->taddr.port;
				}
887
				nb_candidates++;
888 889
			}
		}
890
		if ((ice_check_list_state(cl) == ICL_Completed) && (ice_session_role(session) == IR_Controlling)) {
891 892
			int rtp_port, rtcp_port;
			memset(stream->ice_remote_candidates, 0, sizeof(stream->ice_remote_candidates));
Ghislain MARY's avatar
Ghislain MARY committed
893
			if (ice_check_list_selected_valid_remote_candidate(cl, &rtp_addr, &rtp_port, &rtcp_addr, &rtcp_port) == TRUE) {
894 895 896 897 898 899 900
				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");
			}
901 902 903 904 905
		} 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;
			}
906 907 908 909
		}
	}
}

910 911 912 913 914 915 916 917 918 919 920 921
static void get_default_addr_and_port(uint16_t componentID, const SalMediaDescription *md, const SalStreamDescription *stream, const char **addr, int *port)
{
	if (componentID == 1) {
		*addr = stream->rtp_addr;
		*port = stream->rtp_port;
	} else if (componentID == 2) {
		*addr = stream->rtcp_addr;
		*port = stream->rtcp_port;
	} else return;
	if ((*addr)[0] == '\0') *addr = md->addr;
}

922 923 924 925 926
static void clear_ice_check_list(LinphoneCall *call, IceCheckList *removed){
	if (call->audiostream && call->audiostream->ms.ice_check_list==removed)
		call->audiostream->ms.ice_check_list=NULL;
	if (call->videostream && call->videostream->ms.ice_check_list==removed)
		call->videostream->ms.ice_check_list=NULL;
927 928
	if (call->textstream && call->textstream->ms.ice_check_list==removed)
		call->textstream->ms.ice_check_list=NULL;
929 930
}

931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946
void linphone_call_clear_unused_ice_candidates(LinphoneCall *call, const SalMediaDescription *md){
	int i;
	
	if (!call->localdesc) return;
	for (i = 0; i < md->nb_streams; i++) {
		const SalStreamDescription *local_stream = &call->localdesc->streams[i];
		const SalStreamDescription *stream = &md->streams[i];
		IceCheckList *cl = ice_session_check_list(call->ice_session, i);
		if (!cl || !local_stream) continue;
		
		if (stream->rtcp_mux && local_stream->rtcp_mux){
			ice_check_list_remove_rtcp_candidates(cl);
		}
	}
}

947
void linphone_call_update_ice_from_remote_media_description(LinphoneCall *call, const SalMediaDescription *md)
948
{
949 950 951 952 953 954
	const SalStreamDescription *stream;
	IceCheckList *cl = NULL;
	bool_t default_candidate = FALSE;
	const char *addr = NULL;
	int port = 0;
	int componentID = 0;
955
	bool_t ice_restarted = FALSE;
956
	bool_t ice_params_found=FALSE;
957 958
	int i, j;
		
959 960 961
	if ((md->ice_pwd[0] != '\0') && (md->ice_ufrag[0] != '\0'))  {
		ice_params_found=TRUE;
	} else {
962
		for (i = 0; i < md->nb_streams; i++) {
963 964
			stream = &md->streams[i];
			cl = ice_session_check_list(call->ice_session, i);
965 966 967 968 969 970 971 972 973 974 975
			if (cl) {
				if ((stream->ice_pwd[0] != '\0') && (stream->ice_ufrag[0] != '\0')) {
					ice_params_found=TRUE;
				} else {
					ice_params_found=FALSE;
					break;
				}
			}
		}
	}
	if (ice_params_found) {
976
		/* Check for ICE restart and set remote credentials. */
977 978 979 980
		if ((strcmp(md->addr, "0.0.0.0") == 0) || (strcmp(md->addr, "::0") == 0)) {
			ice_session_restart(call->ice_session);
			ice_restarted = TRUE;
		} else {
981
			for (i = 0; i < md->nb_streams; i++) {
982 983
				stream = &md->streams[i];
				cl = ice_session_check_list(call->ice_session, i);
984 985 986 987 988 989 990
				if (cl && (strcmp(stream->rtp_addr, "0.0.0.0") == 0)) {
					ice_session_restart(call->ice_session);
					ice_restarted = TRUE;
					break;
				}
			}
		}
991 992 993
		if ((ice_session_remote_ufrag(call->ice_session) == NULL) && (ice_session_remote_pwd(call->ice_session) == NULL)) {
			ice_session_set_remote_credentials(call->ice_session, md->ice_ufrag, md->ice_pwd);
		} else if (ice_session_remote_credentials_changed(call->ice_session, md->ice_ufrag, md->ice_pwd)) {
994 995 996 997
			if (ice_restarted == FALSE) {
				ice_session_restart(call->ice_session);
				ice_restarted = TRUE;
			}
998 999
			ice_session_set_remote_credentials(call->ice_session, md->ice_ufrag, md->ice_pwd);
		}
1000
		for (i = 0; i < md->nb_streams; i++) {
1001 1002
			stream = &md->streams[i];
			cl = ice_session_check_list(call->ice_session, i);
1003 1004
			if (cl && (stream->ice_pwd[0] != '\0') && (stream->ice_ufrag[0] != '\0')) {
				if (ice_check_list_remote_credentials_changed(cl, stream->ice_ufrag, stream->ice_pwd)) {
1005
					if (ice_restarted == FALSE
jehan's avatar
jehan committed
1006 1007
							&& ice_check_list_get_remote_ufrag(cl)
							&& ice_check_list_get_remote_pwd(cl)) {
1008
							/* restart onlu if remote ufrag/paswd was already set*/
1009 1010 1011
						ice_session_restart(call->ice_session);
						ice_restarted = TRUE;
					}
1012
					ice_check_list_set_remote_credentials(cl, stream->ice_ufrag, stream->ice_pwd);
1013 1014 1015 1016 1017 1018
					break;
				}
			}
		}

		/* Create ICE check lists if needed and parse ICE attributes. */
1019
		for (i = 0; i < md->nb_streams; i++) {
1020 1021
			stream = &md->streams[i];
			cl = ice_session_check_list(call->ice_session, i);
1022
			
1023
			if (cl==NULL) continue;
1024
			if (stream->ice_mismatch == TRUE) {
1025
				ice_check_list_set_state(cl, ICL_Failed);
1026
			} else if (stream->rtp_port == 0) {
Ghislain MARY's avatar
Ghislain MARY committed
1027
				ice_session_remove_check_list(call->ice_session, cl);
1028
				clear_ice_check_list(call,cl);
1029 1030 1031 1032 1033
			} 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);
				for (j = 0; j < SAL_MEDIA_DESCRIPTION_MAX_ICE_CANDIDATES; j++) {
					const SalIceCandidate *candidate = &stream->ice_candidates[j];
1034 1035 1036
					default_candidate = FALSE;
					addr = NULL;
					port = 0;
1037
					if (candidate->addr[0] == '\0') break;
1038 1039
					if ((candidate->componentID == 0) || (candidate->componentID > 2)) continue;
					get_default_addr_and_port(candidate->componentID, md, stream, &addr, &port);
1040 1041 1042 1043 1044
					if (addr && (candidate->port == port) && (strlen(candidate->addr) == strlen(addr)) && (strcmp(candidate->addr, addr) == 0))
						default_candidate = TRUE;
					ice_add_remote_candidate(cl, candidate->type, candidate->addr, candidate->port, candidate->componentID,
						candidate->priority, candidate->foundation, default_candidate);
				}
1045
				if (ice_restarted == FALSE) {
1046
					bool_t losing_pairs_added = FALSE;
1047
					for (j = 0; j < SAL_MEDIA_DESCRIPTION_MAX_ICE_CANDIDATES; j++) {
1048 1049 1050 1051 1052
						const SalIceRemoteCandidate *remote_candidate = &stream->ice_remote_candidates[j];
						addr = NULL;
						port = 0;
						componentID = j + 1;
						if (remote_candidate->addr[0] == '\0') break;
1053
						get_default_addr_and_port(componentID, md, stream, &addr, &port);
1054 1055 1056 1057
						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);
						}
1058
						ice_add_losing_pair(cl, j + 1, remote_candidate->addr, remote_candidate->port, addr, port);
1059
						losing_pairs_added = TRUE;
1060
					}
1061
					if (losing_pairs_added == TRUE) ice_check_list_check_completed(cl);
1062
				}
1063 1064
			}
		}
1065
		for (i = 0; i < md->nb_streams; i++) {
1066
			stream = &md->streams[i];
1067
			cl = ice_session_check_list(call->ice_session, i);
1068 1069 1070
			if (!cl) continue;
				
			if (!sal_stream_description_active(stream)) {
1071 1072 1073
				ice_session_remove_check_list_from_idx(call->ice_session, i);
				clear_ice_check_list(call, cl);
			}
1074
		}
1075
		linphone_call_clear_unused_ice_candidates(call, md);
1076
		ice_session_check_mismatch(call->ice_session);
1077 1078 1079 1080
	} else {
		/* Response from remote does not contain mandatory ICE attributes, delete the session. */
		linphone_call_delete_ice_session(call);
		return;
1081
	}
1082
	if (ice_session_nb_check_lists(call->ice_session) == 0) {
1083 1084 1085 1086
		linphone_call_delete_ice_session(call);
	}
}

1087
bool_t linphone_core_media_description_contains_video_stream(const SalMediaDescription *md){
1088 1089
	int i;

1090
	for (i = 0; md && i < md->nb_streams; i++) {
1091
		if (md->streams[i].type == SalVideo && md->streams[i].rtp_port!=0)
1092 1093 1094 1095 1096
			return TRUE;
	}
	return FALSE;
}

1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117
unsigned int linphone_core_get_audio_features(LinphoneCore *lc){
	unsigned int ret=0;
	const char *features=lp_config_get_string(lc->config,"sound","features",NULL);
	if (features){
		char tmp[256]={0};
		char name[256];
		char *p,*n;
		strncpy(tmp,features,sizeof(tmp)-1);
		for(p=tmp;*p!='\0';p++){
			if (*p==' ') continue;
			n=strchr(p,'|');
			if (n) *n='\0';
			sscanf(p,"%s",name);
			ms_message("Found audio feature %s",name);
			if (strcasecmp(name,"PLC")==0) ret|=AUDIO_STREAM_FEATURE_PLC;
			else if (strcasecmp(name,"EC")==0) ret|=AUDIO_STREAM_FEATURE_EC;
			else if (strcasecmp(name,"EQUALIZER")==0) ret|=AUDIO_STREAM_FEATURE_EQUALIZER;
			else if (strcasecmp(name,"VOL_SND")==0) ret|=AUDIO_STREAM_FEATURE_VOL_SND;
			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;
Simon Morlat's avatar
Simon Morlat committed
1118
			else if (strcasecmp(name,"MIXED_RECORDING")==0) ret|=AUDIO_STREAM_FEATURE_MIXED_RECORDING;
1119 1120
			else if (strcasecmp(name,"LOCAL_PLAYING")==0) ret|=AUDIO_STREAM_FEATURE_LOCAL_PLAYING;
			else if (strcasecmp(name,"REMOTE_PLAYING")==0) ret|=AUDIO_STREAM_FEATURE_REMOTE_PLAYING;
1121 1122 1123 1124 1125 1126 1127
			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);
			if (!n) break;
			p=n;
		}
	}else ret=AUDIO_STREAM_FEATURE_ALL;
1128

Simon Morlat's avatar
Simon Morlat committed
1129 1130 1131 1132 1133
	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;
	}
1134 1135 1136
	return ret;
}

1137 1138 1139
bool_t linphone_core_tone_indications_enabled(LinphoneCore*lc){
	return lp_config_get_int(lc->config,"sound","tone_indications",1);
}
1140

1141 1142 1143
#ifdef HAVE_GETIFADDRS

#include <ifaddrs.h>
Simon Morlat's avatar
Simon Morlat committed
1144
static int get_local_ip_with_getifaddrs(int type, char *address, int size){
1145 1146
	struct ifaddrs *ifp;
	struct ifaddrs *ifpstart;
Simon Morlat's avatar
Simon Morlat committed
1147 1148
	char retaddr[LINPHONE_IPADDR_SIZE]={0};
	bool_t found=FALSE;
1149

1150 1151 1152
	if (getifaddrs(&ifpstart) < 0) {
		return -1;
	}
1153 1154 1155 1156 1157
#ifndef __linux
	#define UP_FLAG IFF_UP /* interface is up */
#else
	#define UP_FLAG IFF_RUNNING /* resources allocated */
#endif
1158

1159 1160
	for (ifp = ifpstart; ifp != NULL; ifp = ifp->ifa_next) {
		if (ifp->ifa_addr && ifp->ifa_addr->sa_family == type
1161
			&& (ifp->ifa_flags & UP_FLAG) && !(ifp->ifa_flags & IFF_LOOPBACK))
1162
		{
Yann Diorcet's avatar
Yann Diorcet committed
1163
			if(getnameinfo(ifp->ifa_addr,
1164 1165
						(type == AF_INET6) ?
						sizeof(struct sockaddr_in6) : sizeof(struct sockaddr_in),
Simon Morlat's avatar
Simon Morlat committed
1166 1167
						retaddr, size, NULL, 0, NI_NUMERICHOST) == 0) {
				if (strchr(retaddr, '%') == NULL) {	/*avoid ipv6 link-local addresses */
Yann Diorcet's avatar
Yann Diorcet committed
1168
					/*ms_message("getifaddrs() found %s",address);*/
Simon Morlat's avatar
Simon Morlat committed
1169
					found=TRUE;
Yann Diorcet's avatar
Yann Diorcet committed
1170 1171
					break;
				}
1172 1173 1174 1175
			}
		}
	}
	freeifaddrs(ifpstart);
Simon Morlat's avatar
Simon Morlat committed
1176 1177
	if (found) strncpy(address,retaddr,size);
	return found;
1178 1179 1180 1181
}
#endif


1182
static int get_local_ip_for_with_connect(int type, const char *dest, char *result){
1183