misc.c 67.3 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>
Sylvain Berfini's avatar
Sylvain Berfini committed
35 36 37
#if _MSC_VER
#include <io.h>
#else
aymeric's avatar
aymeric committed
38
#include <unistd.h>
Sylvain Berfini's avatar
Sylvain Berfini committed
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
Sylvain Berfini's avatar
Sylvain Berfini committed
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*/

Simon Morlat's avatar
Simon Morlat committed
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
const char *linphone_core_get_payload_type_description(LinphoneCore *lc, PayloadType *pt){
97 98 99
	//if (ms_filter_codec_supported(pt->mime_type)){
	if (ms_factory_codec_supported(lc->factory, pt->mime_type)){
		MSFilterDesc *desc=ms_factory_get_encoder(lc->factory, pt->mime_type);
100
#ifdef ENABLE_NLS
101 102 103 104
		return dgettext("mediastreamer",desc->text);
#else
		return desc->text;
#endif
105 106
	}
	return NULL;
aymeric's avatar
aymeric committed
107 108
}

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

124

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

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

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

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

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 176
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){
177
			ms_debug("PayloadType %s/%i has bitrate override",pt->mime_type,pt->clock_rate);
178 179 180 181 182 183
			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*/
}

184
int linphone_core_get_payload_type_bitrate(LinphoneCore *lc, const LinphonePayloadType *pt){
185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202
	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
203
	ms_message("Audio bandwidth for this call is %i",call->audio_bw);
aymeric's avatar
aymeric committed
204 205
}

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

aymeric's avatar
aymeric committed
212 213 214
	for(elem=linphone_core_get_audio_codecs(lc);elem!=NULL;elem=elem->next){
		PayloadType *pt=(PayloadType*)elem->data;
		if (payload_type_enabled(pt)){
215 216 217 218 219
			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
220 221 222
			}
		}
	}
223 224
	if (max_codec_bitrate) {
		lc->audio_bw=max_codec_bitrate;
aymeric's avatar
aymeric committed
225 226 227
	}
}

228
bool_t linphone_core_is_payload_type_usable_for_bandwidth(LinphoneCore *lc, const PayloadType *pt, int bandwidth_limit){
Simon Morlat's avatar
Simon Morlat committed
229
	double codec_band;
230
	const int video_enablement_limit = 99;
Simon Morlat's avatar
Simon Morlat committed
231
	bool_t ret=FALSE;
232

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

aymeric's avatar
aymeric committed
253
/* return TRUE if codec can be used with bandwidth, FALSE else*/
254
bool_t linphone_core_check_payload_type_usability(LinphoneCore *lc, const PayloadType *pt){
255 256 257
	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);
258
	if ((pt->type==PAYLOAD_AUDIO_CONTINUOUS || pt->type==PAYLOAD_AUDIO_PACKETIZED)
259
		&& lc->sound_conf.capt_sndcard
260 261 262 263
		&& !(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
264
		&& ms_factory_lookup_filter_by_name(lc->factory, "MSWebRTCAEC")!=NULL){
265 266 267 268 269
		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
270 271 272
}

bool_t lp_spawn_command_line_sync(const char *command, char **result,int *command_ret){
273
#if !defined(_WIN32_WCE) && !defined(LINPHONE_WINDOWS_UNIVERSAL)
aymeric's avatar
aymeric committed
274 275 276 277 278 279 280 281 282 283 284 285 286 287 288
	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;
	}
289
#endif /*_WIN32_WCE*/
aymeric's avatar
aymeric committed
290 291 292
	return FALSE;
}

smorlat's avatar
smorlat committed
293 294 295 296 297 298 299 300 301 302 303 304 305 306
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
307
		ms_error("Bind socket to 0.0.0.0:%i failed: %s",local_port,getSocketError());
smorlat's avatar
smorlat committed
308 309 310 311 312 313 314 315 316 317 318 319
		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
320
static int sendStunRequest(int sock, const struct sockaddr *server, socklen_t addrlen, int id, bool_t changeAddr){
smorlat's avatar
smorlat committed
321 322 323
	char buf[STUN_MAX_MESSAGE_SIZE];
	int len = STUN_MAX_MESSAGE_SIZE;
	StunAtrString username;
324
	StunAtrString password;
smorlat's avatar
smorlat committed
325 326 327 328 329
	StunMessage req;
	int err;
	memset(&req, 0, sizeof(StunMessage));
	memset(&username,0,sizeof(username));
	memset(&password,0,sizeof(password));
smorlat's avatar
smorlat committed
330
	stunBuildReqSimple( &req, &username, changeAddr , changeAddr , id);
aymeric's avatar
aymeric committed
331
	len = stunEncodeMessage( &req, buf, len, &password);
smorlat's avatar
smorlat committed
332 333 334 335 336 337 338 339 340 341 342 343
	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;
}

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

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

350
	} else {
351 352 353 354 355 356 357
		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);
358 359
		}
	}
360 361 362 363 364 365 366 367 368 369
	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;
370

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

373
	snprintf(port, sizeof(port), "%d", port_int);
smorlat's avatar
smorlat committed
374
	memset(&hints,0,sizeof(hints));
375
	hints.ai_family=AF_UNSPEC;
smorlat's avatar
smorlat committed
376 377 378 379 380 381 382 383 384
	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);
385
	*socklen=(socklen_t)res->ai_addrlen;
smorlat's avatar
smorlat committed
386 387 388 389
	freeaddrinfo(res);
	return 0;
}

smorlat's avatar
smorlat committed
390
static int recvStunResponse(ortp_socket_t sock, char *ipaddr, int *port, int *id){
smorlat's avatar
smorlat committed
391
	char buf[STUN_MAX_MESSAGE_SIZE];
392
	int len = STUN_MAX_MESSAGE_SIZE;
smorlat's avatar
smorlat committed
393 394 395 396
	StunMessage resp;
	len=recv(sock,buf,len,0);
	if (len>0){
		struct in_addr ia;
aymeric's avatar
aymeric committed
397 398
		stunParseMessage(buf,len, &resp );
		*id=resp.msgHdr.tr_id.octet[0];
399 400 401 402 403 404 405
		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
406 407 408 409 410
		strncpy(ipaddr,inet_ntoa(ia),LINPHONE_IPADDR_SIZE);
	}
	return len;
}

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

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

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

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

smorlat's avatar
smorlat committed
459
			int id;
460 461
			if (loops%20==0){
				ms_message("Sending stun requests...");
462 463
				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);
464
				if (sock2!=-1){
465 466
					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);
467
				}
468
				if (sock3!=-1){
469 470
					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);
471
				}
472
			}
473
			ms_usleep(10000);
smorlat's avatar
smorlat committed
474

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

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

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

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

573 574
static void stun_server_resolved(LinphoneCore *lc, const char *name, struct addrinfo *addrinfo){
	if (lc->net_conf.stun_addrinfo){
575
		belle_sip_freeaddrinfo(lc->net_conf.stun_addrinfo);
576 577 578 579 580 581 582 583
		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;
Simon Morlat's avatar
Simon Morlat committed
584
	lc->net_conf.stun_res=NULL;
585
}
Simon Morlat's avatar
Simon Morlat committed
586

587
void linphone_core_resolve_stun_server(LinphoneCore *lc){
588 589 590 591
	/*
	 * 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.
	 */
592
	const char *server=lc->net_conf.stun_server;
593
	if (lc->sal && server && !lc->net_conf.stun_res){
594 595 596
		char host[NI_MAXHOST];
		int port=3478;
		linphone_parse_host_port(server,host,sizeof(host),&port);
597
		lc->net_conf.stun_res=sal_resolve_a(lc->sal,host,port,AF_INET,(SalResolverCallback)stun_server_resolved,lc);
598 599 600 601 602 603 604 605 606 607 608
	}
}

/*
 * 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.
609
 * - 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
610 611 612 613 614 615 616 617
 * 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);
Simon Morlat's avatar
Simon Morlat committed
618
		while (!lc->net_conf.stun_addrinfo && lc->net_conf.stun_res!=NULL && wait_ms<wait_limit){
619 620 621 622 623 624 625
			sal_iterate(lc->sal);
			ms_usleep(50000);
			wait_ms+=50;
		}
	}
	return lc->net_conf.stun_addrinfo;
}
Simon Morlat's avatar
Simon Morlat committed
626

627 628 629 630
void linphone_core_enable_forced_ice_relay(LinphoneCore *lc, bool_t enable) {
	lc->forced_ice_relay = enable;
}

631
int linphone_core_gather_ice_candidates(LinphoneCore *lc, LinphoneCall *call){
632
	char local_addr[64];
633
	const struct addrinfo *ai = NULL;
634 635
	IceCheckList *audio_check_list;
	IceCheckList *video_check_list;
636
	IceCheckList *text_check_list;
637 638
	const char *server = linphone_core_get_stun_server(lc);

639
	if (call->ice_session == NULL) return -1;
640 641 642
	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);
643
	if (audio_check_list == NULL) return -1;
644

645 646
	if (call->af==AF_INET6){
		ms_warning("Ice gathering is not implemented for ipv6");
647
		return -1;
648
	}
649 650 651 652 653 654 655
	if (server){
		ai=linphone_core_get_stun_server_addrinfo(lc);
		if (ai==NULL){
			ms_warning("Fail to resolve STUN server for ICE gathering, continuing without stun.");
		}
	}else{
		ms_warning("Ice is used without stun server.");
656
	}
657
	linphone_core_notify_display_status(lc, _("ICE local candidates gathering in progress..."));
658

659 660
	ice_session_enable_forced_relay(call->ice_session, lc->forced_ice_relay);

661
	/* Gather local host candidates. */
662
	if (linphone_core_get_local_ip_for(AF_INET, NULL, local_addr) < 0) {
663
		ms_error("Fail to get local ip");
664
		return -1;
665
	}
666
	if ((ice_check_list_state(audio_check_list) != ICL_Completed) && (ice_check_list_candidates_gathered(audio_check_list) == FALSE)) {
667 668
		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);
669 670
		call->stats[LINPHONE_CALL_STATS_AUDIO].ice_state = LinphoneIceStateInProgress;
	}
671
	if (linphone_core_video_enabled(lc) && (video_check_list != NULL)
672
		&& (ice_check_list_state(video_check_list) != ICL_Completed) && (ice_check_list_candidates_gathered(video_check_list) == FALSE)) {
673 674
		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);
675
		call->stats[LINPHONE_CALL_STATS_VIDEO].ice_state = LinphoneIceStateInProgress;
676
	}
677 678 679 680 681 682
	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;
	}
683 684 685 686 687
	if (ai){
		ms_message("ICE: gathering candidate from [%s]",server);
		/* Gather local srflx candidates. */
		ice_session_gather_candidates(call->ice_session, ai->ai_addr, (socklen_t)ai->ai_addrlen);
		return 1;
688 689 690 691 692
	} else {
		ms_message("ICE: bypass candidates gathering");
		ice_session_compute_candidates_foundations(call->ice_session);
		ice_session_eliminate_redundant_candidates(call->ice_session);
		ice_session_choose_default_candidates(call->ice_session);
693
	}
694
	return 0;
695 696
}

697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714
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";
}

715 716 717 718
void linphone_core_update_ice_state_in_call_stats(LinphoneCall *call)
{
	IceCheckList *audio_check_list;
	IceCheckList *video_check_list;
719
	IceCheckList *text_check_list;
Ghislain MARY's avatar
Ghislain MARY committed
720
	IceSessionState session_state;
721 722

	if (call->ice_session == NULL) return;
723 724
	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);
725
	text_check_list = ice_session_check_list(call->ice_session, call->main_text_stream_index);
726 727
	if (audio_check_list == NULL) return;

Ghislain MARY's avatar
Ghislain MARY committed
728 729
	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))) {
730 731 732 733 734 735 736 737 738 739 740 741 742
		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;
743 744 745 746
					case ICT_CandidateInvalid:
					case ICT_CandidateTypeMax:
						/*shall not happen*/
						break;
747 748 749
				}
			} else {
				call->stats[LINPHONE_CALL_STATS_AUDIO].ice_state = LinphoneIceStateFailed;
Ghislain MARY's avatar
Ghislain MARY committed
750
			}
751 752
		}else call->stats[LINPHONE_CALL_STATS_AUDIO].ice_state = LinphoneIceStateNotActivated;
		
753
		if (call->params->has_video && (video_check_list != NULL)) {
754 755 756 757 758 759 760 761 762 763 764 765
			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;
766 767 768 769
					case ICT_CandidateInvalid:
					case ICT_CandidateTypeMax:
						/*shall not happen*/
						break;
770 771 772 773
				}
			} else {
				call->stats[LINPHONE_CALL_STATS_VIDEO].ice_state = LinphoneIceStateFailed;
			}
Simon Morlat's avatar
Simon Morlat committed
774
		}else call->stats[LINPHONE_CALL_STATS_VIDEO].ice_state = LinphoneIceStateNotActivated;
775 776 777 778 779 780 781 782 783 784 785 786 787 788
		
		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;
789 790 791 792
					case ICT_CandidateInvalid:
					case ICT_CandidateTypeMax:
						/*shall not happen*/
						break;
793 794 795 796 797
				}
			} else {
				call->stats[LINPHONE_CALL_STATS_TEXT].ice_state = LinphoneIceStateFailed;
			}
		}else call->stats[LINPHONE_CALL_STATS_TEXT].ice_state = LinphoneIceStateNotActivated;
798 799
	} else if (session_state == IS_Running) {
		call->stats[LINPHONE_CALL_STATS_AUDIO].ice_state = LinphoneIceStateInProgress;
800
		if (call->params->has_video && (video_check_list != NULL)) {
801 802
			call->stats[LINPHONE_CALL_STATS_VIDEO].ice_state = LinphoneIceStateInProgress;
		}
803 804 805
		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
806 807
	} else {
		call->stats[LINPHONE_CALL_STATS_AUDIO].ice_state = LinphoneIceStateFailed;
808
		if (call->params->has_video && (video_check_list != NULL)) {
Ghislain MARY's avatar
Ghislain MARY committed
809 810
			call->stats[LINPHONE_CALL_STATS_VIDEO].ice_state = LinphoneIceStateFailed;
		}
811 812 813
		if (call->params->realtimetext_enabled && (text_check_list != NULL)) {
			call->stats[LINPHONE_CALL_STATS_TEXT].ice_state = LinphoneIceStateFailed;
		}
814
	}
815 816
	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));
817 818
}

Simon Morlat's avatar
Simon Morlat committed
819
void linphone_call_stop_ice_for_inactive_streams(LinphoneCall *call, SalMediaDescription *desc) {
Ghislain MARY's avatar
Ghislain MARY committed
820
	int i;
Simon Morlat's avatar
Simon Morlat committed
821
	IceSession *session = call->ice_session;
822

Ghislain MARY's avatar
Ghislain MARY committed
823 824 825
	if (session == NULL) return;
	if (ice_session_state(session) == IS_Completed) return;

826
	for (i = 0; i < desc->nb_streams; i++) {
Ghislain MARY's avatar
Ghislain MARY committed
827 828 829
		IceCheckList *cl = ice_session_check_list(session, i);
		if (!sal_stream_description_active(&desc->streams[i]) && cl) {
			ice_session_remove_check_list(session, cl);
Simon Morlat's avatar
Simon Morlat committed
830
			clear_ice_check_list(call, cl);
Ghislain MARY's avatar
Ghislain MARY committed
831 832
		}
	}
833 834

	linphone_core_update_ice_state_in_call_stats(call);
Ghislain MARY's avatar
Ghislain MARY committed
835 836
}

837
void _update_local_media_description_from_ice(SalMediaDescription *desc, IceSession *session, bool_t use_nortpproxy) {
838
	const char *rtp_addr, *rtcp_addr;
839
	IceSessionState session_state = ice_session_state(session);
840
	int nb_candidates;
841
	int i, j;
842
	bool_t result;
843

844
	if (session_state == IS_Completed) {
845
		if (use_nortpproxy) desc->set_nortpproxy = TRUE;
Ghislain MARY's avatar
Ghislain MARY committed
846 847 848 849 850 851
		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!");
		}
852 853
	}
	else {
854
		desc->set_nortpproxy = FALSE;
855
	}