configure@ 89669

Last change on this file since 89669 was 88425, checked in by vboxsync, 4 years ago
/configure: Minimum is Qt 5.9 from now on, which is generous. 5.9 is already out of support.
Property svn:eol-style set to `LF` Property svn:executable set to ``*
File size: 78.4 KB

Line
1	#!/bin/sh
2	# The purpose of this script is to check for all external tools, headers, and
3	# libraries VBox OSE depends on.
4
5	#
6	# Copyright (C) 2006-2020 Oracle Corporation
7	#
8	# This file is part of VirtualBox Open Source Edition (OSE), as
9	# available from http://www.virtualbox.org. This file is free software;
10	# you can redistribute it and/or modify it under the terms of the GNU
11	# General Public License (GPL) as published by the Free Software
12	# Foundation, in version 2 as it comes in the "COPYING" file of the
13	# VirtualBox OSE distribution. VirtualBox OSE is distributed in the
14	# hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
15	#
16
17	LC_ALL=C
18	export LC_ALL
19
20	# append some extra paths
21	PATH="$PATH:/opt/gnome/bin"
22	# Solaris (order of paths important for tr, grep, sed to work)
23	PATH="/usr/xpg4/bin:$PATH:/usr/local/bin:/usr/sfw/bin:/usr/ccs/bin"
24	ORGPATH=$PATH
25
26	# Wrapper for ancient /usr/bin/which on darwin that always returns 0
27	which_wrapper()
28	{
29	if [ -z "$have_ancient_which" ]; then
30	if which /bin/___cErTaINly_a_nOn_eXisTing_fIle___ 2> /dev/null > /dev/null; then
31	have_ancient_which="yes"
32	else
33	have_ancient_which="no"
34	fi
35	fi
36	if [ "$have_ancient_which" = "yes" ]; then
37	retval=`which $* 2>/dev/null`
38	echo "$retval"
39	test -n "$retval" -a -x "$retval"
40	unset retval
41	else
42	which $* 2> /dev/null
43	fi
44	}
45
46	OS=`uname -s \| sed -e 's/GNU\/Linux/Linux/g' \| tr '[:upper:]' '[:lower:]'`
47	case "$OS" in
48	linux)
49	;;
50	darwin)
51	;;
52	freebsd)
53	;;
54	netbsd)
55	;;
56	sunos)
57	OS='solaris'
58	;;
59	haiku)
60	;;
61	*)
62	echo "Cannot determine OS!"
63	exit 1
64	;;
65	esac
66
67	#
68	# Defaults
69	#
70	OSE=1
71	ODIR="`pwd`/"
72	ODIR_OVERRIDE=0
73	OUT_PATH=""
74	OUT_PATH_OVERRIDE=0
75	SETUP_WINE=
76	ONLY_ADDITIONS=0
77	TARGET_MACHINE=""
78	TARGET_CPU=""
79	WITH_XPCOM=1
80	WITH_PYTHON=1
81	WITH_JAVA=1
82	WITH_VMMRAW=1
83	WITH_LIBIDL=1
84	WITH_GSOAP=0
85	WITH_QT5=1
86	WITH_SDL=1
87	WITH_SDL_TTF=1
88	WITH_X11=1
89	WITH_ALSA=1
90	WITH_PULSE=1
91	WITH_DBUS=1
92	WITH_DEVMAPPER=1
93	WITH_KMODS=1
94	WITH_OPENGL=1
95	WITH_HARDENING=1
96	WITH_UDPTUNNEL=1
97	WITH_VDE=0
98	WITH_VNC=0
99	WITH_EXTPACK=1
100	WITH_DOCS=1
101	WITH_LIBVPX=1
102	WITH_LIBOPUS=1
103	BUILD_LIBXML2=
104	BUILD_LIBCURL=
105	BUILD_LIBSSL=
106	BUILD_LIBVPX=
107	PASSIVE_MESA=0
108	CC="gcc"
109	CC32=""
110	CC64=""
111	CXX="g++"
112	CXX32=""
113	CXX64=""
114	YASM="yasm"
115	IASL="iasl"
116	XSLTPROC="xsltproc"
117	INCCRYPTO=""
118	LIBCRYPTO="-lssl -lcrypto"
119	LIBPTHREAD="-lpthread"
120	LIBCAP="-lcap"
121	GSOAP=""
122	GSOAP_IMPORT=""
123	INCX11="/usr/local/include"
124	LIBX11="-L/usr/X11R6/lib -L/usr/X11R6/lib64 -L/usr/local/lib -lXext -lX11"
125	LIBXCURSOR="-lXcursor"
126	LIBXMU="-lXmu"
127	LIBXINERAMA="-lXinerama"
128	LIBXRANDR="-lXrandr"
129	MAKESELF="makeself"
130	MESA="-lGL"
131	INCZ=""
132	LIBZ="-lz"
133	INCLZF="/usr/include/liblzf"
134	LIBLZF="-llzf"
135	INCVNCSERVER=""
136	LIBVNCSERVER="-lvncserver"
137	INCDEVMAPPER=""
138	LIBDEVMAPPER="-ldevmapper"
139	CXX_FLAGS=""
140	if [ "$OS" = "freebsd" ]; then
141	INCCURL="-I/usr/local/include"
142	LIBCURL="-L/usr/local/lib -lcurl"
143	INCPULSE="-I/usr/local/include"
144	LIBPULSE="-L/usr/local/lib"
145	INCPNG="-I/usr/local/include"
146	LIBPNG="-L/usr/local/lib -lpng"
147	else
148	INCCURL=""
149	LIBCURL="-lcurl"
150	INCPNG=""
151	LIBPNG="-lpng"
152	fi
153	INCVPX=""
154	LIBVPX="-lvpx"
155	PKGCONFIG="`which_wrapper pkg-config`"
156	PYTHONDIR="/usr /usr/local"
157	QT5DIR="/usr/lib/qt5 /usr/share/qt5 /usr/lib64/qt5 /usr /usr/local"
158	QT5DIR_PKGCONFIG=1
159	QT5MAJ=5
160	QT5MIN=9
161	KBUILDDIR="`cd \`dirname $0\`; pwd`/kBuild"
162	DEVDIR="`cd \`dirname $0\`; pwd`/tools"
163	if [ -d "/lib/modules/`uname -r`/build" ]; then
164	LINUX="/lib/modules/`uname -r`/build"
165	elif [ "`echo /lib/modules/`" != "/lib/modules/" ]; then
166	# Get the most recent kernel headers if none match the current kernel.
167	for i in /lib/modules/*; do
168	if [ -r "$i/build" ]; then
169	LINUX="$i/build"
170	fi
171	done
172	fi
173	if [ -z "$LINUX" ]; then
174	LINUX="/usr/src/linux"
175	fi
176	KCHMVIEWER="kchmviewer"
177	LOG="configure.log"
178	CNF="AutoConfig.kmk"
179	ENV="env.sh"
180	BUILD_TYPE="release"
181	# the restricting tool is ar (mri mode).
182	INVALID_CHARS="[^A-Za-z0-9/\\$:._-]"
183
184	if (cd `dirname $0`; pwd)\|grep -q "$INVALID_CHARS"; then
185	echo "Error: VBox base path contains invalid characters!"
186	exit 1
187	fi
188
189	# Posix /bin/sh isn't supporting echo -n. Use printf instead.
190	ECHO_N="printf"
191
192
193	cleanup()
194	{
195	rm -f $ODIR.tmp_src.cc $ODIR.tmp_src.c $ODIR.tmp_out $ODIR.test_execute.log
196	[ "$OS" = "darwin" ] && rm -rf $ODIR.tmp_out.dSYM
197	true
198	}
199
200	fail()
201	{
202	if [ -z "$nofatal" -o "x$1" != "x" ]; then
203	cleanup
204	rm -f $ENV
205	echo "Check $LOG for details"
206	exit 1
207	fi
208	}
209
210	log()
211	{
212	echo "$1"
213	echo "$1" >> $LOG
214	}
215
216	log_success()
217	{
218	if [ -n "$1" ]; then $ECHO_N "$1, "; fi
219	echo "OK."
220	echo "$1" >> $LOG
221	echo >> $LOG
222	echo >> $LOG
223	}
224
225	log_failure()
226	{
227	echo
228	echo " ** $1!"
229	echo "** $1!" >> $LOG
230	echo >> $LOG
231	}
232
233	cnf_append()
234	{
235	printf "%-30s := %s\n" "$1" "$2" >> $CNF
236	}
237
238	strip_l()
239	{
240	echo "$1"\|$KBUILD_SED 's\|-l$[^ ]\+$\|\1\|g; s\|^-[^l][^ ]\|\|g; s\| -[^l][^ ]\|\|g; s\|^ \|\|; s\| *$\|\|g'
241	}
242
243	strip_L()
244	{
245	if [ "$OS" = "darwin" ]; then
246	echo "$1"\|$KBUILD_SED 's\|-F$[^ ]\+$\|\1\|g; s\|^-[^F][^ ]\|\|g; s\| -[^F][^ ]\|\|g; s\|^ \|\|; s\| *$\|\|g'
247	else
248	echo "$1"\|$KBUILD_SED 's\|-L$[^ ]\+$\|\1\|g; s\|^-[^L][^ ]\|\|g; s\| -[^L][^ ]\|\|g; s\|^ \|\|; s\| *$\|\|g'
249	fi
250	}
251
252	L_to_PATH()
253	{
254	echo $1 >> $LOG
255	if [ "$OS" = "darwin" ]; then
256	echo "$1"\|$KBUILD_SED 's\|-F$[^ ]\+$\|\1\|g; s\|^-[^F][^ ]\|\|g; s\| -[^F][^ ]\|\|g; s\|^ \|\|; s\| *$\|\|g; s\| \|:\|g'
257	else
258	echo "$1"\|$KBUILD_SED 's\|-L$[^ ]\+$\|\1\|g; s\|^-[^L][^ ]\|\|g; s\| -[^L][^ ]\|\|g; s\|^ \|\|; s\| *$\|\|g; s\| \|:\|g'
259	fi
260	}
261
262	strip_I()
263	{
264	echo "$1"\|$KBUILD_SED 's\|-I$[^ ]\+$\|\1\|g; s\|^-[^I][^ ]\|\|g; s\| -[^I][^ ]\|\|g; s\|^ \|\|; s\| *$\|\|g'
265	}
266
267	prefix_I()
268	{
269	echo "$1"\|$KBUILD_SED 's\|^\/\|-I/\|g; s\| \/\| -I/\|g'
270	}
271
272	check_avail()
273	{
274	if [ -z "$1" ]; then
275	log_failure "$2 is empty"
276	fail $3
277	return 1
278	elif which_wrapper $1 > /dev/null; then
279	return 0
280	else
281	log_failure "$1 (variable $2) not found"
282	fail $3
283	return 1
284	fi
285	}
286
287
288	# Prepare a test
289	test_header()
290	{
291	echo "*** Checking $1 ***" >> $LOG
292	$ECHO_N "Checking for $1: "
293	}
294
295
296	# Compile a test
297	# $1 compile flags/libs
298	# $2 library name
299	# $3 package name
300	# $4 if this argument is 'nofatal', don't abort
301	test_compile()
302	{
303	echo "compiling the following source file:" >> $LOG
304	cat $ODIR.tmp_src.cc >> $LOG
305	echo "using the following command line:" >> $LOG
306	echo "$CXX $CXX_FLAGS -fPIC -g -O -Wall -o $ODIR.tmp_out $ODIR.tmp_src.cc $1" >> $LOG
307	$CXX $CXX_FLAGS -fPIC -g -O -Wall -o $ODIR.tmp_out $ODIR.tmp_src.cc $1 >> $LOG 2>&1
308	if [ $? -ne 0 ]; then
309	if [ -z "$4" ]; then
310	echo
311	echo " $2 not found at $1 or $3 headers not found"
312	echo " Check the file $LOG for detailed error information."
313	fail
314	else
315	echo >> $LOG
316	echo >> $LOG
317	fi
318	return 1
319	fi
320	return 0
321	}
322
323
324	# Execute a compiled test binary
325	test_execute()
326	{
327	echo "executing the binary" >> $LOG
328	$ODIR.tmp_out > $ODIR.test_execute.log 2>&1
329	rc=$?
330	cat $ODIR.test_execute.log \| tee -a $LOG
331	if [ $rc -ne 0 ]; then
332	fail $1
333	return 1
334	fi
335	echo >> $LOG
336	echo >> $LOG
337	return 0
338	}
339
340
341	# Execute a compiled test binary
342	test_execute_path()
343	{
344	## LD_LIBRARY_PATH to set.
345	local_path="${1}"
346	## Set this to non-empty to make this test non-fatal.
347	local_nofail="${2}"
348	echo "executing the binary (LD_LIBRARY_PATH=$1:$LD_LIBRARY_PATH)" >> $LOG
349	LD_LIBRARY_PATH="${local_path}:$LD_LIBRARY_PATH" $ODIR.tmp_out > $ODIR.test_execute.log 2>&1
350	rc=$?
351	cat $ODIR.test_execute.log \| tee -a $LOG
352	if [ $rc -ne 0 ]; then
353	test -z "${local_nofail}" && fail
354	echo >> $LOG
355	echo >> $LOG
356	return 1
357	fi
358	echo >> $LOG
359	echo >> $LOG
360	return 0
361	}
362
363
364	#
365	# Check for OS, MACHINE, CPU
366	#
367	check_environment()
368	{
369	test_header environment
370	BUILD_CPU=`uname -m`
371	[ "$OS" = "solaris" ] && BUILD_CPU=`isainfo \| cut -f 1 -d ' '`
372	case "$BUILD_CPU" in
373	i[3456789]86\|x86\|i86pc\|BePC)
374	BUILD_MACHINE='x86'
375	LIB='lib'
376	;;
377	x86_64\|amd64)
378	BUILD_MACHINE='amd64'
379	BUILD_CPU='blend'
380	if [ "$OS" != "solaris" ]; then
381	# on AMD64 systems, 64bit libs are usually located in /usr/lib64
382	# see http://www.pathname.com/fhs/pub/fhs-2.3.html#LIB64
383	LIB='lib64'
384	else
385	# Solaris doesn't seem to subscribe to fhs, libs are usually in
386	# a '64' subdirectory of the standard 'lib' dirs while some 64-bit
387	# alternative binaries can be found in 'amd64' subdirs of the 'bin'
388	# ones. So, in order to find the right stuff (esp. sdl-config) we'll
389	# have to make sure the /bin/amd64 dirs are searched before the /bin
390	# ones. (The sed has some sideeffects, but they shouldn't harm us...)
391	echo "64-bit Solaris detected, hacking the PATH" >> $LOG
392	echo "old PATH: $PATH" >> $LOG
393	PATH=`echo ":$PATH:" \| sed -e 's,$:[^:]*/bin$:,\1/amd64:\1:,g' \
394	-e 's/^://' -e 's/:$//g' -e 's/::*/:/g' `
395	export PATH
396	echo "new PATH: $PATH" >> $LOG
397	LIB='lib/64'
398	fi
399	;;
400	sparc64\|sparcv9)
401	BUILD_MACHINE='sparc64'
402	BUILD_CPU='blend'
403	;;
404	sparc32\|sparc\|sparcv8\|sparcv7\|sparcv8e)
405	BUILD_MACHINE='sparc32'
406	BUILD_CPU='blend'
407	;;
408	*)
409	log_failure "Cannot determine system"
410	exit 1
411	;;
412	esac
413	[ -z "$TARGET_MACHINE" ] && TARGET_MACHINE=$BUILD_MACHINE
414	[ -z "$TARGET_CPU" ] && TARGET_CPU=$BUILD_CPU
415	DEVDIR_BIN="$DEVDIR/$OS.$BUILD_MACHINE/bin"
416	log_success "Determined build machine: $OS.$BUILD_MACHINE, target machine: $OS.$TARGET_MACHINE"
417
418	echo "KBUILD_HOST=\"$OS\"" >> $ENV
419	echo "KBUILD_HOST_ARCH=\"$BUILD_MACHINE\"" >> $ENV
420	echo "KBUILD_TARGET=\"$OS\"" >> $ENV
421	echo "KBUILD_TARGET_ARCH=\"$TARGET_MACHINE\"" >> $ENV
422	echo "KBUILD_TARGET_CPU=\"$TARGET_CPU\"" >> $ENV
423	echo "KBUILD_TYPE=\"$BUILD_TYPE\"" >> $ENV
424	echo 'export KBUILD_HOST KBUILD_HOST_ARCH KBUILD_TARGET KBUILD_TARGET_ARCH KBUILD_TARGET_CPU KBUILD_TYPE' >> $ENV
425
426	# obsolete legacy stuff:
427	echo '' >> $ENV
428	echo "# Legacy - do not use:" >> $ENV
429	echo 'BUILD_PLATFORM="$KBUILD_HOST"' >> $ENV
430	echo 'BUILD_PLATFORM_ARCH="$KBUILD_HOST_ARCH"' >> $ENV
431	echo 'BUILD_TARGET="$KBUILD_TARGET"' >> $ENV
432	echo 'BUILD_TARGET_ARCH="$KBUILD_TARGET_ARCH"' >> $ENV
433	echo 'BUILD_TARGET_CPU="$KBUILD_TARGET_CPU"' >> $ENV
434	echo 'BUILD_TYPE="$KBUILD_TYPE"' >> $ENV
435	echo 'export BUILD_PLATFORM BUILD_PLATFORM_ARCH BUILD_TARGET BUILD_TARGET_ARCH BUILD_TARGET_CPU BUILD_TYPE' >> $ENV
436	echo '' >> $ENV
437	}
438
439	#
440	# Check for gcc with version >= 3.2.
441	# We depend on a working gcc, if we fail terminate in every case.
442	#
443	check_gcc()
444	{
445	test_header gcc
446	if check_avail "$CC" CC really; then
447	cc_ver=`$CC -dumpfullversion 2>/dev/null`
448	if [ $? -ne 0 ]; then
449	cc_ver=`$CC -dumpversion 2>/dev/null`
450	fi
451	if [ $? -ne 0 ]; then
452	log_failure "cannot execute '$CC -dumpversion'"
453	fail really
454	fi
455	if check_avail "$CXX" CXX really; then
456	cxx_ver=`$CXX -dumpfullversion 2>/dev/null`
457	if [ $? -ne 0 ]; then
458	cxx_ver=`$CXX -dumpversion 2>/dev/null`
459	fi
460	if [ $? -ne 0 ]; then
461	log_failure "cannot execute '$CXX -dumpversion'"
462	fail really
463	fi
464	cc_maj=`echo $cc_ver\|cut -d. -f1`
465	cc_min=`echo $cc_ver\|cut -d. -f2`
466	if [ "x$cc_ver" != "x$cxx_ver" ]; then
467	log_failure "gcc version $cc_ver does not match g++ version $cxx_ver"
468	fail really
469	elif [ $cc_maj -eq 4 -a $cc_min -eq 0 -a "$OS" = "darwin" ]; then
470	log_success "found version $cc_ver"
471	# gcc-4.0 is allowed for Darwin only
472	elif [ $cc_maj -eq 4 -a $cc_min -eq 2 -a "$OS" = "freebsd" ]; then
473	log_success "found version $cc_ver"
474	# gcc-4.2 is allowed for FreeBSD only
475	elif [ $cc_maj -lt 4 \
476	-o $ $cc_maj -eq 4 -a $cc_min -lt 4 -a "$OS" != "darwin" $ \
477	-o $ $cc_maj -eq 4 -a $cc_min -lt 2 -a "$OS" = "darwin" $ ]; then
478	log_failure "gcc version $cc_maj.$cc_min found, expected gcc 4.x or later"
479	fail really
480	else
481	log_success "found version $cc_ver"
482	fi
483	if [ "$BUILD_MACHINE" = "amd64" ]; then
484	[ -z "$CC32" ] && CC32="$CC -m32"
485	[ -z "$CXX32" ] && CXX32="$CXX -m32"
486	else
487	[ -z "$CC32" ] && CC32="$CC"
488	[ -z "$CXX32" ] && CXX32="$CXX"
489	fi
490	if [ "$BUILD_MACHINE" = "x86" -a "$TARGET_MACHINE" = "amd64" ]; then
491	[ -z "$CC64" ] && CC64="$CC -m64"
492	[ -z "$CXX64" ] && CXX64="$CXX -m64"
493	fi
494	if [ "$TARGET_MACHINE" = "amd64" -a $WITH_VMMRAW -eq 0 ]; then
495	CC32="undefined"
496	CXX32="undefined"
497	fi
498	if [ "$CC" != "gcc" ]; then
499	cnf_append "TOOL_GCC3_CC" "$CC"
500	cnf_append "TOOL_GCC3_AS" "$CC"
501	cnf_append "TOOL_GCC3_LD" "$CC"
502	cnf_append "TOOL_GXX3_CC" "$CC"
503	cnf_append "TOOL_GXX3_AS" "$CC"
504	fi
505	if [ "$CXX" != "g++" ]; then
506	cnf_append "TOOL_GCC3_CXX" "$CXX"
507	cnf_append "TOOL_GXX3_CXX" "$CXX"
508	cnf_append "TOOL_GXX3_LD" "$CXX"
509	fi
510	if [ "$CC32" != "gcc -m32" -a "$CC32" != "undefined" ]; then
511	cnf_append "TOOL_GCC32_CC" "$CC32"
512	cnf_append "TOOL_GCC32_AS" "$CC32"
513	cnf_append "TOOL_GCC32_LD" "$CC32"
514	cnf_append "TOOL_GXX32_CC" "$CC32"
515	cnf_append "TOOL_GXX32_AS" "$CC32"
516	fi
517	if [ "$CXX32" != "g++ -m32" -a "$CXX32" != "undefined" ]; then
518	cnf_append "TOOL_GCC32_CXX" "$CXX32"
519	cnf_append "TOOL_GXX32_CXX" "$CXX32"
520	cnf_append "TOOL_GXX32_LD" "$CXX32"
521	fi
522	# this isn't not necessary, there is not such tool.
523	if [ -n "$CC64" ]; then
524	cnf_append "TOOL_GCC64_CC" "$CC64"
525	cnf_append "TOOL_GCC64_AS" "$CC64"
526	cnf_append "TOOL_GCC64_LD" "$CC64"
527	cnf_append "TOOL_GXX64_CC" "$CC64"
528	cnf_append "TOOL_GXX64_AS" "$CC64"
529	fi
530	if [ -n "$CXX64" ]; then
531	cnf_append "TOOL_GCC64_CXX" "$CXX64"
532	cnf_append "TOOL_GXX64_CXX" "$CXX64"
533	cnf_append "TOOL_GXX64_LD" "$CXX64"
534	fi
535	if [ "$CC" != "gcc" ]; then
536	if [ -n "$CC64" ]; then
537	cnf_append "TOOL_Bs3Gcc64Elf64_CC" "$CC64"
538	else
539	cnf_append "TOOL_Bs3Gcc64Elf64_CC" "$CC"
540	fi
541	if [ -n "$CXX64" ]; then
542	cnf_append "TOOL_Bs3Gcc64Elf64_CXX" "$CXX64"
543	else
544	cnf_append "TOOL_Bs3Gcc64Elf64_CXX" "$CXX"
545	fi
546	fi
547	# Solaris sports a 32-bit gcc/g++.
548	if [ "$OS" = "solaris" -a "$BUILD_MACHINE" = "amd64" ]; then
549	[ "$CC" = "gcc" ] && CC="gcc -m64"
550	[ "$CXX" = "g++" ] && CXX="g++ -m64"
551	fi
552	fi
553	fi
554	}
555
556
557	#
558	# Check for the OpenWatcom compiler, needed for compiling the BIOS
559	#
560	# If the system has Open Watcom installed, WATCOM will be set in the
561	# environment. If the user has her/his own Open Watcom install it will be
562	# pointed to by on the command line, which will set the WATCOM variable.
563	# The only exception is detecting OpenWatcom in tools/common/openwatcom.
564	#
565	check_open_watcom()
566	{
567	test_header "Open Watcom"
568
569	if [ -z "$WATCOM" ]; then
570	WATCOM=`/bin/ls -rd1 $PWD/tools/common/openwatcom/* 2> /dev/null \| head -1`
571	if [ -z "$WATCOM" ]; then
572	if [ $OSE -eq 0 -a $OS = "linux" ]; then
573	log_failure "Open Watcom was not found"
574	exit 1
575	fi
576	log_failure "Open Watcom was not found, using alternative BIOS sources"
577	cnf_append "VBOX_WITH_OPEN_WATCOM" ""
578	return 0;
579	fi
580	fi
581
582	case "$OS" in
583	"darwin") wc_bin="binosx";; # ??
584	"dos") wc_bin="binw";;
585	"freebsd") wc_bin="binfbsd";; # ??
586	"linux") wc_bin="binl";;
587	"netbsd") wc_bin="binnbsd";; # ??
588	"solaris") wc_bin="binsol";; # ??
589	"os2") wc_bin="binp";;
590	"win") wc_bin="binnt";;
591	*) wc_bin="binl";;
592	esac
593
594	# Check that the tools we use are there.
595	for prog in wasm wcc wlink;
596	do
597	if [ ! -f "$WATCOM/$wc_bin/$prog" ]; then
598	log_failure "$WATCOM/$wc_bin/$prog does not exist or is not a regular file."
599	fail
600	fi
601	done
602
603	# Use WASM to get the version.
604	wasm_ver=`$WATCOM/$wc_bin/wasm -? 2>&1 \| sed -e '1!d' -e 's/Open Watcom Assembler Version *//'`
605	if [ -z "$wasm_ver" ]; then
606	log_failure "$WATCOM/$wc_bin/wasm -? did not produce the expected response"
607	fail
608	fi
609	log_success "found version $wasm_ver"
610	cnf_append "PATH_TOOL_OPENWATCOM" "$WATCOM"
611	cnf_append "VBOX_WITH_OPEN_WATCOM" "1"
612
613	unset wasm_ver
614	unset wc_wasm
615	unset wc_bin
616	}
617
618
619	#
620	# Check for yasm, needed to compile assembler files
621	#
622	check_yasm()
623	{
624	test_header yasm
625	if check_avail "$YASM" YASM; then
626	yasm_ver=`$YASM --version\|grep "^yasm"\|sed 's+^yasm $.*$+\1+'`
627	if [ $? -ne 0 ]; then
628	log_failure "yasm not found"
629	fail
630	else
631	yasm_maj=`echo $yasm_ver\|cut -d. -f1`
632	yasm_min=`echo $yasm_ver\|cut -d. -f2`
633	yasm_rev=`echo $yasm_ver\|cut -d. -f3`
634	yasm_ver_mul=`expr $yasm_maj \* 10000 + $yasm_min \* 100 + $yasm_rev`
635	if [ $yasm_ver_mul -lt 10300 ]; then
636	log_failure "found version $yasm_ver, expected at least 1.3.0"
637	fail
638	else
639	[ "$YASM" != "yasm" ] && cnf_append "PATH_TOOL_YASM" "`dirname $YASM`"
640	log_success "found version $yasm_ver"
641	fi
642	fi
643	fi
644	}
645
646
647	#
648	# Check for the iasl ACPI compiler, needed to compile vbox.dsl
649	#
650	check_iasl()
651	{
652	test_header iasl
653	if check_avail "$IASL" IASL; then
654	iasl_ver=`$IASL\|grep "ASL.version"\|sed 's+^ASL.version $[0-9]$.+\1+'`
655	if [ $? -ne 0 ]; then
656	log_failure "iasl not found"
657	fail
658	else
659	log_success "found version $iasl_ver"
660	cnf_append "VBOX_IASLCMD" "`which_wrapper $IASL`"
661	fi
662	fi
663	}
664
665
666	#
667	# Check for xsltproc, needed by Main
668	#
669	check_xsltproc()
670	{
671	if [ -n "$BUILD_LIBXSLT" ]; then
672	return 0;
673	fi
674	test_header xslt
675	if check_avail "$XSLTPROC" XSLTPROC; then
676	xsltproc_ver=`$XSLTPROC --version`
677	if [ $? -ne 0 ]; then
678	log_failure "xsltproc not found"
679	fail
680	else
681	log_success "found"
682	cnf_append "VBOX_XSLTPROC" "`which_wrapper $XSLTPROC`"
683	fi
684	fi
685	}
686
687
688	#
689	# Check for libxml2, needed by the Runtime.
690	# 2.6.24 is known to NOT work, 2.6.26 is known to work (there is no 2.6.25 release)
691	#
692	check_libxml2()
693	{
694	if [ -z "$BUILD_LIBXML2" ]; then
695	test_header libxml2
696	if which_wrapper pkg-config > /dev/null; then
697	libxml2_ver=`pkg-config libxml-2.0 --modversion 2>> $LOG`
698	if [ $? -ne 0 ]; then
699	log_failure "libxml2 not found"
700	fail
701	else
702	FLGXML2=`pkg-config libxml-2.0 --cflags`
703	INCXML2=`strip_I "$FLGXML2"`
704	LIBXML2=`pkg-config libxml-2.0 --libs`
705	cat > $ODIR.tmp_src.cc << EOF
706	#include <cstdio>
707	#include <libxml/xmlversion.h>
708	extern "C" int main(void)
709	{
710	printf("found version %s", LIBXML_DOTTED_VERSION);
711	#if LIBXML_VERSION >= 20626
712	printf(", OK.\n");
713	return 0;
714	#else
715	printf(", expected version 2.6.26 or higher\n");
716	return 1;
717	#endif
718	}
719	EOF
720	[ -n "$INCXML2" ] && I_INCXML2=`prefix_I "$INCXML2"`
721	if test_compile "$LIBXML2 $LIBPTHREAD $I_INCXML2" xml2 xml2; then
722	if test_execute; then
723	cnf_append "SDK_VBOX_LIBXML2_DEFS" "_REENTRANT" ## @todo get defines from --cflags
724	cnf_append "SDK_VBOX_LIBXML2_INCS" "$INCXML2"
725	cnf_append "SDK_VBOX_LIBXML2_LIBS" "`strip_l "$LIBXML2"`"
726	fi
727	fi
728	fi
729	elif which_wrapper xml2-config; then
730	libxml2_ver=`xml2-config --version`
731	if [ $? -ne 0 ]; then
732	log_failure "xml2-config not found"
733	fail
734	else
735	log_success "found version $libxml2_ver"
736	FLGXML2=`xml2-config --cflags`
737	INCXML2=`strip_I "$FLGXML2"`
738	LIBXML2=`xml2-config --libs`
739	cat > $ODIR.tmp_src.cc << EOF
740	#include <cstdio>
741	#include <libxml/xmlversion.h>
742	extern "C" int main(void)
743	{
744	printf("found version %s", LIBXML_DOTTED_VERSION);
745	#if LIBXML_VERSION >= 20626
746	printf(", OK.\n");
747	return 0;
748	#else
749	printf(", expected version 2.6.26 or higher\n");
750	return 1;
751	#endif
752	}
753	EOF
754	[ -n "$INCXML2" ] && I_INCXML2=`prefix_I "$INCXML2"`
755	if test_compile "$LIBXML2 $LIBPTHREAD $I_INCXML2" xml2 xml2; then
756	if test_execute; then
757	cnf_append "SDK_VBOX_LIBXML2_DEFS" "_REENTRANT" ## @todo get defines from --cflags
758	cnf_append "SDK_VBOX_LIBXML2_INCS" "$INCXML2"
759	cnf_append "SDK_VBOX_LIBXML2_LIBS" "`strip_l "$LIBXML2"`"
760	fi
761	fi
762	fi
763	else
764	log_failure "neither pkg-config nor xml2-config found"
765	fail
766	fi
767	fi
768	}
769
770
771	#
772	# Check for libIDL, needed by xpcom
773	#
774	check_libidl()
775	{
776	test_header libIDL
777
778	if which_wrapper libIDL-config-2 > /dev/null; then
779	libidl_ver=`libIDL-config-2 --version`
780	if [ $? -ne 0 ]; then
781	log_failure "libIDL-config-2 not working"
782	fail
783	else
784	log_success "found version $libidl_ver"
785	cnf_append "VBOX_LIBIDL_CONFIG" \
786	"PKG_CONFIG_PATH=`libIDL-config-2 --prefix`/$LIB/pkgconfig `which_wrapper libIDL-config-2`"
787	fi
788	elif check_avail "libIDL-config" libIDL-config; then
789	libidl_ver=`libIDL-config --version`
790	if [ $? -ne 0 ]; then
791	log_failure "libIDL-config not working"
792	fail
793	else
794	log_success "found version $libidl_ver"
795	cnf_append "VBOX_LIBIDL_CONFIG" "`which_wrapper libIDL-config`"
796	fi
797	fi
798	}
799
800
801	#
802	# Check for libdevmapper, needed by the VBoxVolInfo
803	#
804	check_libdevmapper()
805	{
806	test_header libdevmapper
807	cat > $ODIR.tmp_src.cc << EOF
808	#include <cstdio>
809	extern "C" {
810	#define private
811	#include <libdevmapper.h>
812	int main()
813	{
814	char version[80];
815
816	if (!dm_get_library_version(version, sizeof(version)))
817	{
818	printf("dm_get_library_version() failed.\n");
819	return 1;
820	}
821
822	const char* v=version;
823	unsigned int major = 0, minor = 0, micro = 0;
824
825	for (; v !='.' && v != '\0'; v++) major = major10 + v-'0';
826	if (*v == '.') v++;
827	for (; v !='.' && v != '\0'; v++) minor = minor10 + v-'0';
828	if (*v == '.') v++;
829	for (; v !='.' && v != '\0'; v++) micro = micro10 + v-'0';
830
831	printf("found version %s", version);
832	if (major10000 + minor100 + micro >= 10200)
833	{
834	printf(", OK.\n");
835	return 0;
836	}
837	else
838	{
839	printf(", expected version 1.02 or higher\n");
840	return 1;
841	}
842	}
843	}
844	EOF
845	if test_compile "$LIBDEVMAPPER $INCDEVMAPPER" libdevmapper libdevmapper; then
846	if test_execute; then
847	cnf_append "VBOX_WITH_DEVMAPPER" "1"
848	fi
849	fi
850	}
851
852
853	#
854	# Check for openssl, needed for RDP and S3
855	#
856	check_ssl()
857	{
858	if [ -z "$BUILD_LIBSSL" ]; then
859	test_header ssl
860	cat > $ODIR.tmp_src.cc << EOF
861	#include <cstdio>
862	#include <openssl/opensslv.h>
863	#include <openssl/ssl.h>
864	extern "C" int main(void)
865	{
866	printf("found version %s", OPENSSL_VERSION_TEXT);
867	SSL_library_init();
868	#if OPENSSL_VERSION_NUMBER >= 0x10001000
869	printf(", OK.\n");
870	return 0;
871	#else
872	printf(", expected version 1.0.1 or higher\n");
873	return 1;
874	#endif
875	}
876	EOF
877	if test_compile "$INCCRYPTO $LIBCRYPTO" libcrypto openssl; then
878	if test_execute nofatal; then
879	cnf_append "SDK_VBOX_OPENSSL_INCS" "`strip_I "$INCCRYPTO"`"
880	cnf_append "SDK_VBOX_OPENSSL_LIBS" "`strip_l "$LIBCRYPTO"`"
881	cnf_append "SDK_VBOX_BLD_OPENSSL_LIBS" "`strip_l "$LIBCRYPTO"`"
882	fi
883	fi
884	fi
885	}
886
887
888	#
889	# Check for pthread, needed by VBoxSVC, frontends, ...
890	#
891	check_pthread()
892	{
893	test_header pthread
894	cat > $ODIR.tmp_src.cc << EOF
895	#include <cstdio>
896	#include <pthread.h>
897	extern "C" int main(void)
898	{
899	pthread_mutex_t mutex;
900	if (pthread_mutex_init(&mutex, NULL)) {
901	printf("pthread_mutex_init() failed\n");
902	return 1;
903	}
904	if (pthread_mutex_lock(&mutex)) {
905	printf("pthread_mutex_lock() failed\n");
906	return 1;
907	}
908	if (pthread_mutex_unlock(&mutex)) {
909	printf("pthread_mutex_unlock() failed\n");
910	return 1;
911	}
912	printf("found, OK.\n");
913	}
914	EOF
915	if test_compile $LIBPTHREAD pthread pthread; then
916	if test_execute; then
917	cnf_append "LIB_PTHREAD" "`strip_l "$LIBPTHREAD"`"
918	fi
919	fi
920	}
921
922
923	#
924	# Check for zlib, needed by VBoxSVC, Runtime, ...
925	#
926	check_z()
927	{
928	test_header zlib
929	cat > $ODIR.tmp_src.cc << EOF
930	#include <cstdio>
931	#include <zlib.h>
932	extern "C" int main(void)
933	{
934	printf("found version %s", ZLIB_VERSION);
935	#if ZLIB_VERNUM >= 0x1210
936	printf(", OK.\n");
937	return 0;
938	#else
939	printf(", expected version 1.2.1 or higher\n");
940	return 1;
941	#endif
942	}
943	EOF
944	[ -n "$INCZ" ] && I_INCZ=`prefix_I "$INCZ"`
945	if test_compile "$LIBZ $I_INCZ" zlib zlib; then
946	if test_execute; then
947	echo "if1of (\$(KBUILD_TARGET),darwin freebsd haiku linux)" >> $CNF
948	cnf_append " SDK_VBOX_ZLIB_LIBS" "`strip_l "$LIBZ"`"
949	cnf_append " SDK_VBOX_ZLIB_INCS" "$INCZ"
950	echo "endif" >> $CNF
951	fi
952	fi
953	}
954
955
956	#
957	# Check for liblzf, needed by VBoxSVC, Runtime, ...
958	#
959	check_lzf()
960	{
961	test_header liblzf
962	cat > $ODIR.tmp_src.cc << EOF
963	#include <cstdio>
964	#include <lzf.h>
965	extern "C" int main(void)
966	{
967	printf("found LZF API version %u.%u", LZF_VERSION >> 8, LZF_VERSION & 0xff);
968	#if LZF_VERSION >= 0x0105
969	printf(", OK.\n");
970	return 0;
971	#else
972	printf(", expected version 1.5 or higher\n");
973	return 1;
974	#endif
975	}
976	EOF
977	[ -n "$INCLZF" ] && I_INCLZF=`prefix_I "$INCLZF"`
978	if test_compile "$LIBLZF $I_INCLZF" liblzf liblzf nofatal; then
979	if test_execute; then
980	echo "if1of (\$(KBUILD_TARGET),darwin freebsd haiku linux)" >> $CNF
981	cnf_append " SDK_VBOX_LZF_LIBS" "`strip_l "$LIBLZF"`"
982	cnf_append " SDK_VBOX_LZF_INCS" "$INCLZF"
983	echo "endif" >> $CNF
984	fi
985	else
986	echo "not found -- builing liblzf from in-tree code."
987	fi
988	}
989
990
991	#
992	# Check for libpng, needed by kchmviewer
993	#
994	check_png()
995	{
996	test_header libpng
997	cat > $ODIR.tmp_src.cc << EOF
998	#include <cstdio>
999	#include <png.h>
1000	extern "C" int main(void)
1001	{
1002	printf("found version %s", PNG_LIBPNG_VER_STRING);
1003	#if PNG_LIBPNG_VER >= 10205
1004	printf(", OK.\n");
1005	return 0;
1006	#else
1007	printf(", expected version 1.2.5 or higher\n");
1008	return 1;
1009	#endif
1010	}
1011	EOF
1012	[ -n "$INCPNG" ] && I_INCPNG=`prefix_I "$INCPNG"`
1013	if test_compile "$LIBPNG $I_INCPNG" libpng libpng; then
1014	if test_execute; then
1015	cnf_append "SDK_VBOX_LIBPNG_LIBS" "`strip_l "$LIBPNG"`"
1016	cnf_append "SDK_VBOX_LIBPNG_INCS" "$INCPNG"
1017	fi
1018	fi
1019	}
1020
1021	#
1022	# Check for libvncserver, needed for VNC in OSE
1023	#
1024	check_vncserver()
1025	{
1026	test_header libvncserver
1027	cat > $ODIR.tmp_src.cc <<EOF
1028	#include <cstdio>
1029	#include <rfb/rfbconfig.h>
1030
1031	extern "C" int main()
1032	{
1033	const char* v=LIBVNCSERVER_VERSION;
1034	unsigned int major = 0, minor = 0, micro = 0;
1035
1036	for (; v !='.' && v != '\0'; v++) major = major10 + v-'0';
1037	if (*v == '.') v++;
1038	for (; v !='.' && v != '\0'; v++) minor = minor10 + v-'0';
1039	if (*v == '.') v++;
1040	for (; v !='.' && v != '\0'; v++) micro = micro10 + v-'0';
1041
1042	printf("found version %s", LIBVNCSERVER_PACKAGE_VERSION);
1043	if (major10000 + minor100 + micro >= 900)
1044	{
1045	printf(", OK.\n");
1046	return 0;
1047	}
1048	else
1049	{
1050	printf(", expected version 0.9 or higher\n");
1051	return 1;
1052	}
1053	}
1054	EOF
1055	if test_compile "$LIBVNCSERVER $INCVNCSERVER" libvncserver libvncserver; then
1056	if test_execute; then
1057	cnf_append "VBOX_WITH_EXTPACK_VNC" "1"
1058	fi
1059	fi
1060	}
1061
1062	#
1063	# Check for libcurl, needed by S3
1064	#
1065	check_curl()
1066	{
1067	if [ -z "$BUILD_LIBCURL" ]; then
1068	test_header libcurl
1069	cat > $ODIR.tmp_src.cc << EOF
1070	#include <cstdio>
1071	#include <curl/curl.h>
1072	extern "C" int main(void)
1073	{
1074	printf("found version %s", LIBCURL_VERSION);
1075	#if 10000LIBCURL_VERSION_MAJOR + 100LIBCURL_VERSION_MINOR + LIBCURL_VERSION_PATCH >= 71901
1076	printf(", OK.\n");
1077	return 0;
1078	#else
1079	printf(", expected version 7.19.1 or higher\n");
1080	return 1;
1081	#endif
1082	}
1083	EOF
1084	[ -n "$INCCURL" ] && I_INCCURL=`prefix_I "$INCCURL"`
1085	if test_compile "$LIBCURL $I_INCCURL" libcurl libcurl; then
1086	if test_execute; then
1087	cnf_append "SDK_VBOX_LIBCURL_LIBS" "`strip_l "$LIBCURL"`"
1088	cnf_append "SDK_VBOX_LIBCURL_INCS" "$INCCURL"
1089	fi
1090	fi
1091	fi
1092	}
1093
1094
1095	#
1096	# Check for pam, needed by VRDPAuth
1097	# Version 79 was introduced in 9/2005, do we support older versions?
1098	# Debian/sarge uses 76
1099	# OpenSUSE comes with 0.99.xxx where they changed the versioning scheme.
1100	#
1101	check_pam()
1102	{
1103	test_header pam
1104	cat > $ODIR.tmp_src.cc << EOF
1105	#include <cstdio>
1106	#include <security/pam_appl.h>
1107	extern "C" int main(void)
1108	{
1109	printf("found version %d", __LIBPAM_VERSION);
1110	if (__LIBPAM_VERSION >= 76)
1111	{
1112	printf(", OK.\n");
1113	return 0;
1114	}
1115	else
1116	{
1117	printf(", expected version 76 or higher\n");
1118	return 1;
1119	}
1120	}
1121	EOF
1122	if test_compile "-lpam" pam pam nofatal; then
1123	if test_execute nofatal; then
1124	return 0;
1125	fi
1126	fi
1127	echo "pam0.x not found"
1128	test_header linux_pam
1129	cat > $ODIR.tmp_src.cc << EOF
1130	#include <cstdio>
1131	#include <security/pam_appl.h>
1132	extern "C" int main(void)
1133	{
1134	printf("found version %d.%d", __LINUX_PAM__, __LINUX_PAM_MINOR__);
1135	if (__LINUX_PAM__ >= 1)
1136	{
1137	printf(", OK.\n");
1138	return 0;
1139	}
1140	else
1141	{
1142	printf(", expected version 1.0 or higher\n");
1143	return 1;
1144	}
1145	}
1146	EOF
1147	if test_compile "-lpam" pam pam; then
1148	test_execute
1149	fi
1150	}
1151
1152
1153	#
1154	# Check for the SDL library, needed by VBoxSDL and VirtualBox
1155	# We depend at least on version 1.2.7
1156	#
1157	check_sdl()
1158	{
1159	test_header SDL
1160	if [ "$OS" = "darwin" ]; then
1161	if [ -f "/System/Library/Frameworks/SDL.framework/SDL" ]; then
1162	PATH_SDK_LIBSDL="/System/Library/Frameworks/SDL.framework"
1163	elif [ -f "/Library/Frameworks/SDL.framework/SDL" ]; then
1164	PATH_SDK_LIBSDL="/Library/Frameworks/SDL.framework"
1165	fi
1166	if [ -n "$PATH_SDK_LIBSDL" ]; then
1167	foundsdl=1
1168	INCSDL="$PATH_SDK_LIBSDL/Headers"
1169	FLDSDL="-framework SDL"
1170	else
1171	log_failure "SDL framework not found"
1172	fail
1173	fi
1174	else
1175	if which_wrapper sdl-config > /dev/null; then
1176	FLGSDL=`sdl-config --cflags`
1177	INCSDL=`strip_I "$FLGSDL"`
1178	LIBSDL=`sdl-config --libs`
1179	LIBSDLMAIN="-lSDLmain"
1180	FLDSDL=
1181	foundsdl=1
1182	fi
1183	fi
1184	[ "$OS" = "linux" -o "$OS" = "darwin" -o "$OS" = "solaris" ] && LIBSDLMAIN=""
1185	if [ -n "$foundsdl" ]; then
1186	cat > $ODIR.tmp_src.cc << EOF
1187	#include <cstdio>
1188	#include <SDL.h>
1189	#include <SDL_main.h>
1190	#undef main
1191	extern "C" int main(int argc, char** argv)
1192	{
1193	printf("found version %d.%d.%d",
1194	SDL_MAJOR_VERSION, SDL_MINOR_VERSION, SDL_PATCHLEVEL);
1195	#if SDL_VERSION_ATLEAST(1,2,7)
1196	printf(", OK.\n");
1197	return 0;
1198	#else
1199	printf(", expected version 1.2.7 or higher\n");
1200	return 1;
1201	#endif
1202	}
1203	EOF
1204	[ -n "$INCSDL" ] && I_INCSDL=`prefix_I "$INCSDL"`
1205	if test_compile "$LIBSDL $LIBSDLMAIN $I_INCSDL $FLDSDL" SDL SDL; then
1206	if test_execute; then
1207	cnf_append "LIB_SDK_LIBSDL_SDL" "`strip_l "$LIBSDL"`"
1208	cnf_append "SDK_LIBSDL_LIBPATH" "`strip_L "$LIBSDL"`"
1209	cnf_append "LIB_SDK_LIBSDL_SDLMAIN" "`strip_l "$LIBSDLMAIN"`"
1210	[ -n "$INCSDL" ] && cnf_append "SDK_LIBSDL_INCS" "$INCSDL"
1211	[ -n "$FLDSDL" ] && cnf_append "SDK_LIBSDL_LDFLAGS" "$FLDSDL"
1212	fi
1213	fi
1214	else
1215	log_failure "SDL not found (can be disabled using --disable-sdl)"
1216	fail
1217	fi
1218	}
1219
1220
1221	#
1222	# Check for the SDL_ttf library, needed by VBoxSDL (secure label)
1223	#
1224	check_sdl_ttf()
1225	{
1226	test_header SDL_ttf
1227	cat > $ODIR.tmp_src.cc << EOF
1228	#include <cstdio>
1229	#include <SDL_ttf.h>
1230	#ifndef SDL_TTF_MAJOR_VERSION
1231	#define SDL_TTF_MAJOR_VERSION TTF_MAJOR_VERSION
1232	#define SDL_TTF_MINOR_VERSION TTF_MINOR_VERSION
1233	#define SDL_TTF_PATCHLEVEL TTF_PATCHLEVEL
1234	#endif
1235	extern "C" int main(void)
1236	{
1237	printf("found version %d.%d.%d",
1238	SDL_TTF_MAJOR_VERSION, SDL_TTF_MINOR_VERSION, SDL_TTF_PATCHLEVEL);
1239	#if 10000SDL_TTF_MAJOR_VERSION + 100SDL_TTF_MINOR_VERSION + SDL_TTF_PATCHLEVEL >= 20006
1240	printf(", OK.\n");
1241	return 0;
1242	#else
1243	printf(", expected version 2.0.6 or higher\n");
1244	return 1;
1245	#endif
1246	}
1247	EOF
1248	if test_compile "-lSDL_ttf $I_INCSDL" SDL_ttf SDL_ttf nofatal; then
1249	test_execute nofatal \|\| \
1250	cnf_append "VBOX_WITH_SECURELABEL" ""
1251	else
1252	echo "not found -- disabling VBoxSDL secure label."
1253	cnf_append "VBOX_WITH_SECURELABEL" ""
1254	fi
1255	}
1256
1257
1258	#
1259	# Check for libasound, needed by the ALSA audio backend
1260	#
1261	check_alsa()
1262	{
1263	test_header ALSA
1264	cat > $ODIR.tmp_src.cc << EOF
1265	#include <cstdio>
1266	#include <alsa/asoundlib.h>
1267	extern "C" int main(void)
1268	{
1269	printf("found version %d.%d.%d",
1270	SND_LIB_MAJOR, SND_LIB_MINOR, SND_LIB_SUBMINOR);
1271	#if 10000SND_LIB_MAJOR + 100SND_LIB_MINOR + SND_LIB_SUBMINOR >= 10014
1272	printf(", OK.\n");
1273	return 0;
1274	#else
1275	printf(", expected version 1.0.14 or higher\n");
1276	return 1;
1277	#endif
1278	}
1279	EOF
1280	if test_compile "-lasound" asound asound; then
1281	test_execute
1282	fi
1283	}
1284
1285
1286	#
1287	# Check for PulseAudio
1288	#
1289	check_pulse()
1290	{
1291	test_header "PulseAudio"
1292	cat > $ODIR.tmp_src.cc << EOF
1293	#include <cstdio>
1294	#include <pulse/version.h>
1295	extern "C" int main(void)
1296	{
1297	printf("found version %s API version %d", pa_get_headers_version(), PA_API_VERSION);
1298	#if PA_API_VERSION >= 9
1299	printf(", OK.\n");
1300	return 0;
1301	#else
1302	printf(", expected version 0.9.0 (API version 9) or higher\n");
1303	return 1;
1304	#endif
1305	}
1306	EOF
1307	if test_compile "$INCPULSE $LIBPULSE -lpulse" pulse pulse nofatal; then
1308	if test_execute nofatal; then
1309	cnf_append "VBOX_WITH_AUDIO_PULSE" "1"
1310	else
1311	cnf_append "VBOX_WITH_AUDIO_PULSE" ""
1312	fi
1313	else
1314	cnf_append "VBOX_WITH_AUDIO_PULSE" ""
1315	fi
1316	}
1317
1318
1319	#
1320	# Check for the X libraries (Xext, X11)
1321	#
1322	check_x()
1323	{
1324	test_header "X libraries"
1325	cat > $ODIR.tmp_src.cc << EOF
1326	#include <cstdio>
1327	#include <X11/Xlib.h>
1328	extern "C" int main(void)
1329	{
1330	Display *dpy;
1331	int scrn_num;
1332	Screen *scrn;
1333	Window win;
1334
1335	dpy = XOpenDisplay(NULL);
1336	scrn_num = DefaultScreen(dpy);
1337	scrn = ScreenOfDisplay(dpy, scrn_num);
1338	win = XCreateWindow(dpy, RootWindowOfScreen(scrn), 0, 0, 100, 100,
1339	0, 16, InputOutput, CopyFromParent, 0, NULL);
1340	XDestroyWindow(dpy, win);
1341	XCloseDisplay(dpy);
1342	}
1343	EOF
1344	[ -n "$INCX11" ] && I_INCX11=`prefix_I "$INCX11"`
1345	if test_compile "$LIBX11 $I_INCX11" Xlibs Xlibs; then
1346	log_success "found"
1347	fi
1348	}
1349
1350
1351	#
1352	# Check for the Xcursor library, needed by VBoxSDL.
1353	#
1354	check_xcursor()
1355	{
1356	test_header Xcursor
1357	cat > $ODIR.tmp_src.cc << EOF
1358	#include <cstdio>
1359	#include <X11/Xlib.h>
1360	#include <X11/Xcursor/Xcursor.h>
1361	extern "C" int main(void)
1362	{
1363	XcursorImage *cursor = XcursorImageCreate (10, 10);
1364	XcursorImageDestroy(cursor);
1365	return 0;
1366	}
1367	EOF
1368	[ -n "$INCX11" ] && I_INCX11=`prefix_I "$INCX11"`
1369	if test_compile "$LIBX11 $LIBXCURSOR $I_INCX11" Xcursor Xcursor; then
1370	log_success "found"
1371	cnf_append "VBOX_XCURSOR_LIBS" "`strip_l "$LIBXCURSOR"`"
1372	fi
1373	}
1374
1375
1376	#
1377	# Check for the Xinerama library, needed by the Qt GUI
1378	#
1379	check_xinerama()
1380	{
1381	test_header Xinerama
1382	cat > $ODIR.tmp_src.cc << EOF
1383	#include <X11/Xlib.h>
1384	#include <X11/extensions/Xinerama.h>
1385	extern "C" int main(void)
1386	{
1387	Display *dpy;
1388	Bool flag;
1389	dpy = XOpenDisplay(NULL);
1390	if (dpy)
1391	{
1392	flag = XineramaIsActive(dpy);
1393	XCloseDisplay(dpy);
1394	}
1395	}
1396	EOF
1397	[ -n "$INCX11" ] && I_INCX11=`prefix_I "$INCX11"`
1398	if test_compile "$LIBX11 $LIBXINERAMA $I_INCX11" Xinerama Xinerama; then
1399	log_success "found"
1400	fi
1401	}
1402
1403
1404	#
1405	# Check for the XRandR library, needed by the Qt GUI
1406	#
1407	check_xrandr()
1408	{
1409	test_header Xrandr
1410	cat > $ODIR.tmp_src.cc << EOF
1411	#include <X11/Xlib.h>
1412	#include <X11/extensions/Xrandr.h>
1413	extern "C" int main(void)
1414	{
1415	Display *dpy;
1416	Bool flag;
1417	int major, minor;
1418	dpy = XOpenDisplay(NULL);
1419	if (dpy)
1420	{
1421	flag = XRRQueryVersion(dpy, &major, &minor);
1422	XCloseDisplay(dpy);
1423	}
1424	}
1425	EOF
1426	[ -n "$INCX11" ] && I_INCX11=`prefix_I "$INCX11"`
1427	if test_compile "$LIBX11 $LIBXRANDR $I_INCX11" Xrandr Xrandr; then
1428	log_success "found"
1429	fi
1430	}
1431
1432
1433	#
1434	# Check for OpenGL
1435	#
1436	check_opengl()
1437	{
1438	# On darwin this is a on/off decision only
1439	if [ "$OS" = "darwin" ]; then
1440	test_header "OpenGL support"
1441	echo "enabled"
1442	else
1443	check_xmu
1444	check_mesa
1445	fi
1446	}
1447
1448
1449	#
1450	# Check for the Xmu library, needed by OpenGL
1451	#
1452	check_xmu()
1453	{
1454	test_header Xmu
1455	cat > $ODIR.tmp_src.cc << EOF
1456	#include <cstdio>
1457	#include <X11/Xatom.h>
1458	#include <X11/Xlib.h>
1459	#include <X11/Xutil.h>
1460	#include <X11/Xmu/StdCmap.h>
1461	extern "C" int main(void)
1462	{
1463	Display *dpy;
1464	int scrn_num;
1465	Screen *scrn;
1466
1467	dpy = XOpenDisplay(NULL);
1468	if (dpy)
1469	{
1470	scrn_num = DefaultScreen(dpy);
1471	scrn = ScreenOfDisplay(dpy, scrn_num);
1472	Status status = XmuLookupStandardColormap(dpy, RootWindowOfScreen(scrn), 0,
1473	24, XA_RGB_DEFAULT_MAP, False, True);
1474	printf("Status = %x\n", status);
1475	XCloseDisplay(dpy);
1476	}
1477	return 0;
1478	}
1479	EOF
1480	[ -n "$INCX11" ] && I_INCX11=`prefix_I "$INCX11"`
1481	if test_compile "$LIBX11 $LIBXMU $I_INCX11" Xmu Xmu; then
1482	log_success "found"
1483	cnf_append "VBOX_XMU_LIBS" "`strip_l "$LIBXMU"`"
1484	fi
1485	}
1486
1487	#
1488	# Check for Mesa, needed by OpenGL
1489	#
1490	check_mesa()
1491	{
1492	test_header "Mesa / GLU"
1493	cat > $ODIR.tmp_src.cc << EOF
1494	#include <cstdio>
1495	#include <X11/Xlib.h>
1496	#include <GL/glx.h>
1497	#include <GL/glu.h>
1498	extern "C" int main(void)
1499	{
1500	Display *dpy;
1501	int major, minor;
1502
1503	dpy = XOpenDisplay(NULL);
1504	if (dpy)
1505	{
1506	Bool glx_version = glXQueryVersion(dpy, &major, &minor);
1507	XCloseDisplay(dpy);
1508	if (glx_version)
1509	{
1510	printf("found version %u.%u, OK.\n", major, minor);
1511	return 0;
1512	}
1513	}
1514	printf("found (inactive), OK.\n");
1515	return 0;
1516	}
1517	EOF
1518	[ -n "$INCX11" ] && I_INCX11=`prefix_I "$INCX11"`
1519	if test_compile "$LIBX11 $MESA $I_INCX11" Mesa Mesa; then
1520	[ $PASSIVE_MESA -eq 1 ] && unset DISPLAY
1521	test_execute
1522	fi
1523	}
1524
1525
1526	#
1527	# Check for the Qt5 library, needed by the VirtualBox frontend
1528	#
1529	# Currently not fatal.
1530	#
1531	check_qt5()
1532	{
1533	foundqt5=
1534	test_header Qt5
1535	cat > $ODIR.tmp_src.cc << EOF
1536	#include <QtGlobal>
1537	extern "C" int main(void)
1538	{
1539	EOF
1540	echo "#if QT_VERSION >= $(($QT5MAJ65536+$QT5MIN256))" >> $ODIR.tmp_src.cc
1541	cat >> $ODIR.tmp_src.cc << EOF
1542	return 0;
1543	#else
1544	return 1;
1545	#endif
1546	}
1547	EOF
1548	if [ "$OS" = "darwin" ]; then
1549	# First check if there is the internal version of Qt. If yes nothing else
1550	# has to be done.
1551	QT_INTERNAL=`/bin/ls -rd1 $PWD/tools/$BUILD_TARGET.$BUILD_PLATFORM_ARCH/qt/* 2> /dev/null`
1552	for t in $QT_INTERNAL; do
1553	if [ -f "$t/Frameworks/QtCoreVBox.framework/QtCoreVBox" ]; then
1554	cnf_append "VBOX_WITH_ORACLE_QT" "1"
1555	log_success "use internal version"
1556	return
1557	fi
1558	done
1559	# Now try the user provided directory and some of the standard directories.
1560	QT_TRIES="$QT5DIR /System/Library /Library"
1561	for t in $QT_TRIES; do
1562	if [ -f "$t/Frameworks/QtCore.framework/QtCore" -o -f "$t/clang_64/lib/QtCore.framework/QtCore" ]; then
1563	PATH_SDK_QT5="$t"
1564	foundqt5=1
1565	break
1566	fi
1567	done
1568	# Add the necessary params for building the test application
1569	if [ -n "$PATH_SDK_QT5" ]; then
1570	if [ -f "$t/clang_64/lib/QtCore.framework/QtCore" ]; then
1571	INCQT5=-I$PATH_SDK_QT5/clang_64/lib/QtCore.framework/Headers
1572	LIBQT5=-F$PATH_SDK_QT5/clang_64/lib
1573	SDKQT5=$PATH_SDK_QT5/clang_64
1574	else
1575	INCQT5=-I$PATH_SDK_QT5/Frameworks/QtCore.framework/Headers
1576	LIBQT5=-F$PATH_SDK_QT5/Frameworks
1577	SDKQT5=$PATH_SDK_QT5
1578	fi
1579	FLGQT5="-framework QtCore -std=c++11 -Wl,-rpath,`L_to_PATH "$LIBQT5"`"
1580	else
1581	log_failure "Qt5 framework not found (can be disabled using --disable-qt)"
1582	fail
1583	fi
1584	else # !darwin
1585	if [ $QT5DIR_PKGCONFIG -eq 1 ]; then
1586	# Default is to use pkg-config:
1587	if which_wrapper pkg-config > /dev/null; then
1588	qt5_ver=`pkg-config Qt5Core --modversion 2>> $LOG`
1589	if [ $? -eq 0 ]; then
1590	echo "(Qt5 from pkg-config)" >> $LOG
1591	FLGQT5=`pkg-config Qt5Core --cflags`
1592	# gcc 4.8 is able to compile with C++11 (see also VBOX_GCC_std in Config.kmk)
1593	[ $cc_maj -eq 4 -a $cc_min -eq 8 ] && FLGQT5="$FLGQT5 -std=c++11"
1594	INCQT5=`strip_I "$FLGQT5"`
1595	LIBDIR5=`pkg-config Qt5Core --variable=libdir`
1596	LIBQT5=`pkg-config Qt5Core --libs`
1597	LIBQT5="-L$LIBDIR5 $LIBQT5"
1598	TOOLQT5=`pkg-config Qt5Core --variable=prefix`
1599	TOOLQT5BIN=`pkg-config Qt5Core --variable=host_bins`
1600	if test_compile "$LIBQT5 $LIBPTHREAD $FLGQT5" qt5 qt5 nofatal; then
1601	test_execute_path "`L_to_PATH "$LIBQT5"`" nofatal && foundqt5=3 # pkg-config
1602	fi
1603	fi
1604	else
1605	log_failure "pkg-config not found"
1606	fail
1607	fi
1608	fi
1609	if [ -z "$foundqt5" ]; then
1610	# Do it the old way (e.g. user has specified QT5DIR):
1611	for q in $QT5DIR "$PWD/tools/linux.$TARGET_MACHINE"/qt/v5.*; do
1612	echo "(Qt5 from '$q')" >> $LOG
1613	INCQT5="$q/include $q/include/QtCore"
1614	FLGQT5="-DQT_SHARED -std=c++11"
1615	I_INCQT5=`prefix_I "$INCQT5"`
1616	LIBQT5="-L$q/lib -lQt5CoreVBox"
1617	TOOLQT5="$q"
1618	if test_compile "$LIBQT5 $LIBPTHREAD $I_INCQT5 $FLGQT5" qt5 qt5 nofatal &&
1619	test_execute_path "`L_to_PATH "$LIBQT5"`" nofatal; then
1620	foundqt5=2 # internal
1621	break;
1622	fi
1623	LIBQT5="-L$q/lib -lQt5Core"
1624	if test_compile "$LIBQT5 $LIBPTHREAD $I_INCQT5 $FLGQT5" qt5 qt5 nofatal &&
1625	test_execute_path "`L_to_PATH "$LIBQT5"`" nofatal; then
1626	foundqt5=1 # no pkg-config, Qt directory
1627	break;
1628	fi
1629	done
1630	fi
1631	fi
1632	if [ -n "$foundqt5" ]; then
1633	# We decided which version of Qt to use, now enforce the version requirement:
1634	cat > $ODIR.tmp_src.cc << EOF
1635	#include <cstdio>
1636	#include <QtGlobal>
1637	extern "C" int main(void)
1638	{
1639	printf("found version %s", QT_VERSION_STR);
1640	EOF
1641	echo "#if QT_VERSION >= $(($QT5MAJ65536+$QT5MIN256))" >> $ODIR.tmp_src.cc
1642	cat >> $ODIR.tmp_src.cc << EOF
1643	printf(", OK.\n");
1644	return 0;
1645	#else
1646	EOF
1647	echo " printf(\", expected version $QT5MAJ.$QT5MIN or higher\\\\n\");" >> $ODIR.tmp_src.cc
1648	cat >> $ODIR.tmp_src.cc << EOF
1649	return 1;
1650	#endif
1651	}
1652	EOF
1653	[ -n "$INCQT5" ] && I_INCQT5=`prefix_I "$INCQT5"`
1654	if test_compile "$LIBQT5 $LIBPTHREAD $I_INCQT5 $FLGQT5" qt5 qt5 nofatal; then
1655	if test_execute_path "`L_to_PATH "$LIBQT5"`"; then
1656	if [ "$OS" = "darwin" ]; then
1657	# Successful build & run the test application so add the necessary
1658	# params to AutoConfig.kmk:
1659	cnf_append "PATH_SDK_QT5_INC" "`L_to_PATH "$LIBQT5"`"
1660	cnf_append "PATH_SDK_QT5_LIB" "`L_to_PATH "$LIBQT5"`"
1661	cnf_append "PATH_SDK_QT5" "$SDKQT5"
1662	# Check for the moc tool in the Qt directory found & some standard
1663	# directories.
1664	for q in $PATH_SDK_QT5 $PATH_SDK_QT5/clang_64 /usr /Developer/Tools/Qt; do
1665	if which_wrapper "$q/bin/moc" > /dev/null; then
1666	cnf_append "PATH_TOOL_QT5_BIN" "$q/bin"
1667	fi
1668	done
1669	else
1670	# Strip .../QtCore as we add components ourself:
1671	INCQT5=`echo "$INCQT5"\|$KBUILD_SED 's\|$[^ ]*$/QtCore\|\1\|g; s\| $\|\|g'`
1672	# store only the first path, remove all other paths
1673	# most likely pkg-config gave us -I/usr/include/qt5 -I/usr/include/qt5/QtCore
1674	INCQT5=`echo "$INCQT5"\|$KBUILD_SED 's\|$[^ ]$ .\|\1\|'`
1675	cnf_append "VBOX_PATH_QT_LIB" "`strip_L "$LIBQT5"`"
1676	cnf_append "PATH_SDK_QT5_INC" "$INCQT5"
1677	# This is not quite right since the qt libpath does not have to be first...
1678	cnf_append "PATH_SDK_QT5_LIB" '$'"(firstword `strip_L "$LIBQT5"`)"
1679	if [ "$foundqt5" = "2" ]; then
1680	cnf_append "VBOX_WITH_ORACLE_QT" "1"
1681	fi
1682	if [ "$foundqt5" != "3" ]; then
1683	TOOLQT5BIN="$TOOLQT5/bin"
1684	fi
1685	test_header "Qt5 devtools"
1686	# Try it with a suffix, some platforms use that
1687	if which_wrapper "$TOOLQT5BIN/moc-qt5" > /dev/null; then
1688	QT5BINSUFF="-qt5"
1689	else
1690	QT5BINSUFF=""
1691	fi
1692	moc_ver=`$TOOLQT5BIN/moc$QT5BINSUFF -v 2>&1\|sed 's+^.(Qt $.$)+\1+'`
1693	if [ $? -ne 0 ]; then
1694	log_failure "moc$QT5BINSUFF not working"
1695	fail
1696	else
1697	log_success "found version $moc_ver"
1698	cnf_append "VBOX_PATH_QT" "$TOOLQT5"
1699	cnf_append "PATH_SDK_QT5" "$TOOLQT5"
1700	cnf_append "PATH_TOOL_QT5_BIN" "$TOOLQT5BIN"
1701	[ -n "$QT5BINSUFF" ] && cnf_append "TOOL_QT5_BIN_SUFF" "$QT5BINSUFF"
1702	fi
1703	fi
1704	fi
1705	else
1706	log_failure "qt5 not working"
1707	fail
1708	fi
1709	else
1710	log_failure "qt5 not found"
1711	fail
1712	fi
1713	}
1714
1715
1716	#
1717	# Check for libopus
1718	#
1719	check_libopus()
1720	{
1721	if [ -z "$BUILD_LIBOPUS" ]; then
1722	test_header libopus
1723	if which_wrapper pkg-config > /dev/null; then
1724	libopus_ver=`pkg-config opus --modversion 2>> $LOG`
1725	if [ $? -eq 0 ]; then
1726	FLGOPUS=`pkg-config opus --cflags`
1727	INCOPUS=`strip_I "$FLGOPUS"`
1728	LIBOPUS=`pkg-config opus --libs`
1729	fi
1730	cat > $ODIR.tmp_src.cc << EOF
1731	#include <cstdio>
1732	#include <opus/opus.h>
1733	extern "C" int main(void)
1734	{
1735	OpusEncoder *test;
1736	printf("found, OK.\n");
1737	}
1738	EOF
1739	[ -n "$INCOPUS" ] && I_INCOPUS=`prefix_I "$INCOPUS"`
1740	if test_compile "$LIBOPUS $I_INCOPUS" opus opus; then
1741	if test_execute; then
1742	cnf_append "SDK_VBOX_OPUS_INCS" "$INCOPUS"
1743	cnf_append "SDK_VBOX_OPUS_LIBS" "`strip_l "$LIBOPUS"`"
1744	fi
1745	fi
1746	fi
1747	fi
1748	}
1749
1750
1751	#
1752	# Check for libvpx
1753	#
1754	check_vpx()
1755	{
1756	if [ -z "$BUILD_LIBVPX" ]; then
1757	test_header libvpx
1758	if which_wrapper pkg-config > /dev/null; then
1759	libvpx_ver=`pkg-config vpx --modversion 2>> $LOG`
1760	if [ $? -eq 0 ]; then
1761	FLGVPX=`pkg-config vpx --cflags`
1762	INCVPX=`strip_I "$FLGVPX"`
1763	LIBVPX=`pkg-config vpx --libs`
1764	fi
1765	cat > $ODIR.tmp_src.cc << EOF
1766	#include <cstdio>
1767	#include <vpx/vpx_codec.h>
1768	extern "C" int main(void)
1769	{
1770	int version = vpx_codec_version();
1771	int verMajor = VPX_VERSION_MAJOR(version);
1772	int verMinor = VPX_VERSION_MINOR(version);
1773	int verPatch = VPX_VERSION_PATCH(version);
1774	printf("found version %d.%d.%d", verMajor, verMinor, verPatch);
1775	if ( verMajor == 1 && verMinor >= 0
1776	\|\| verMajor == 0 && verMinor == 9 && verPatch >= 5)
1777	{
1778	printf(", OK.\n");
1779	return 0;
1780	}
1781	else
1782	{
1783	printf(", expected version 0.9.5 or higher\n");
1784	return 1;
1785	}
1786	}
1787	EOF
1788	[ -n "$INCVPX" ] && I_INCVPX=`prefix_I "$INCVPX"`
1789	if test_compile "$LIBVPX $I_INCVPX" vpx vpx; then
1790	if test_execute; then
1791	cnf_append "SDK_VBOX_VPX_INCS" "$INCVPX"
1792	cnf_append "SDK_VBOX_VPX_LIBS" "`strip_l "$LIBVPX"`"
1793	fi
1794	fi
1795	fi
1796	fi
1797	}
1798
1799
1800	#
1801	# Check whether static libstdc++ is installed. This library is required
1802	# for the Linux guest additions.
1803	#
1804	check_staticlibstdcxx()
1805	{
1806	test_header "static stc++ library"
1807	libstdcxx=`$CXX -print-file-name=libstdc++.a`
1808	cat > $ODIR.tmp_src.cc << EOF
1809	#include <string>
1810
1811	extern "C" int main(void)
1812	{
1813	std::string s = "test";
1814	return 0;
1815	}
1816	EOF
1817	if test_compile "$libstdcxx" libstdc++ libstdc++; then
1818	log_success "found"
1819	fi
1820	}
1821
1822
1823	#
1824	# Check for Linux sources
1825	#
1826	check_linux()
1827	{
1828	test_header "Linux kernel sources"
1829	cat > $ODIR.tmp_src.c << EOF
1830	#include <linux/version.h>
1831	int printf(const char *format, ...);
1832	int main(void)
1833	{
1834	printf("found version %d.%d.%d", LINUX_VERSION_CODE / 65536,
1835	(LINUX_VERSION_CODE % 65536) / 256,
1836	LINUX_VERSION_CODE % 256);
1837	#if LINUX_VERSION_CODE > KERNEL_VERSION(2,4,0)
1838	printf(", OK.\n");
1839	return 0;
1840	#else
1841	printf(", expected version 2.4.0 or higher\n");
1842	return 1;
1843	#endif
1844	}
1845	EOF
1846	echo "compiling the following source file:" >> $LOG
1847	cat $ODIR.tmp_src.c >> $LOG
1848	echo "using the following command line:" >> $LOG
1849	echo "$CC -O -Wall -o $ODIR.tmp_out $ODIR.tmp_src.c -nostdinc -I$LINUX/include " \
1850	"-I$LINUX/include/generated/uapi" >> $LOG
1851	$CC -O -Wall -o $ODIR.tmp_out $ODIR.tmp_src.c -nostdinc -I$LINUX/include \
1852	-I$LINUX/include/generated/uapi >> $LOG 2>&1
1853	if [ $? -ne 0 ]; then
1854	echo
1855	echo " Linux kernel headers not found at $LINUX"
1856	echo " Check the file $LOG for detailed error information."
1857	fail
1858	else
1859	if test_execute; then
1860	cnf_append "VBOX_LINUX_SRC" "`cd $LINUX ; pwd`"
1861	fi
1862	fi
1863	}
1864
1865	#
1866	# Check for kchmviewer, needed to display the online help
1867	# (unused as we ship kchmviewer)
1868	#
1869	check_kchmviewer()
1870	{
1871	test_header kchmviewer
1872	if check_avail "$KCHMVIEWER" KCHMVIEWER; then
1873	kchmviewer_ver=`$KCHMVIEWER --version\|grep "^KchmViewer:"\|sed 's+^KchmViewer: $.*$+\1+'`
1874	if [ $? -ne 0 ]; then
1875	log_failure "kchmviewer not working"
1876	fail
1877	else
1878	log_success "found version $kchmviewer_ver"
1879	fi
1880	fi
1881	}
1882
1883
1884	#
1885	# Check for the kBuild tools, we don't support GNU make
1886	#
1887	check_kbuild()
1888	{
1889	test_header kBuild
1890	if which_wrapper "$KBUILDDIR/bin/$OS.$BUILD_MACHINE/kmk" > /dev/null; then
1891	KBUILDDIR_BIN="$KBUILDDIR/bin/$OS.$BUILD_MACHINE"
1892
1893	echo "KBUILD_PATH=\"`cd $KBUILDDIR ; pwd`\"" >> $ENV
1894	echo "KBUILD_DEVTOOLS=\"$DEVDIR\"" >> $ENV
1895	echo 'path_kbuild_bin="$KBUILD_PATH/bin/$BUILD_TARGET.$BUILD_PLATFORM_ARCH"' >> $ENV
1896	echo 'path_tools_bin="$KBUILD_DEVTOOLS/$BUILD_TARGET.$BUILD_PLATFORM_ARCH/bin"' >> $ENV
1897
1898	if [ "$OS" = "solaris" ]; then
1899	# Because of sh being non-default shell in Solaris we need to export PATH again when
1900	# sourcing env.sh. Simply exporting from ./configure does not export PATH correctly.
1901	echo "PATH=\"$ORGPATH\"" >> $ENV
1902	echo "echo \"\$PATH\" \| /usr/sfw/bin/ggrep -q \"\$path_kbuild_bin\" \|\| PATH=\"\$path_kbuild_bin:\$PATH\"" >> $ENV
1903	echo "echo \"\$PATH\" \| /usr/sfw/bin/ggrep -q \"\$path_tools_bin\" \|\| PATH=\"\$path_tools_bin:\$PATH\"" >> $ENV
1904	else
1905	echo "echo \"\$PATH\" \| grep -q \"\$path_kbuild_bin\" \|\| PATH=\"\$path_kbuild_bin:\$PATH\"" >> $ENV
1906	echo "echo \"\$PATH\" \| grep -q \"\$path_tools_bin\" \|\| PATH=\"\$path_tools_bin:\$PATH\"" >> $ENV
1907	fi
1908	echo "export KBUILD_PATH KBUILD_DEVTOOLS PATH" >> $ENV
1909	echo "unset path_kbuild_bin path_tools_bin" >> $ENV
1910	KBUILD_SED="$KBUILDDIR_BIN/kmk_sed"
1911
1912	echo '' >> $ENV
1913	echo "# Legacy - do not use:" >> $ENV
1914	echo 'PATH_KBUILD=${KBUILD_PATH}' >> $ENV
1915	echo 'PATH_DEVTOOLS=${KBUILD_DEVTOOLS}' >> $ENV
1916	echo 'export PATH_KBUILD PATH_DEVTOOLS' >> $ENV
1917	echo '' >> $ENV
1918	elif check_avail "kmk" KBUILDDIR really; then
1919	# check for installed kBuild
1920	KBUILD_SED="`which_wrapper kmk_sed`"
1921	else
1922	fail
1923	fi
1924	log_success "found"
1925	}
1926
1927
1928	#
1929	# Check for compiler.h
1930	# Some Linux distributions include "compiler.h" in their libc linux
1931	# headers package, some don't. Most don't need it, building might (!)
1932	# not succeed on openSUSE without it.
1933	#
1934	# See http://www.mail-archive.com/qemu-devel%40nongnu.org/msg07980.html
1935	#
1936	check_compiler_h()
1937	{
1938	test_header compiler.h
1939	if test ! -f "/usr/include/linux/compiler.h"; then
1940	log_success "compiler.h not found"
1941	else
1942	cnf_append "VBOX_WITH_LINUX_COMPILER_H" "1"
1943	log_success "compiler.h found"
1944	fi
1945	}
1946
1947	#
1948	# Check for libcap.
1949	# Required to pass CAP_NET_RAW to our binaries to allow to open SOCK_RAW
1950	# sockets for doing ICMP requests.
1951	#
1952	check_libcap()
1953	{
1954	test_header "libcap library"
1955	cat > $ODIR.tmp_src.cc << EOF
1956	#include <cstdio>
1957	#include <sys/types.h>
1958	#include <linux/types.h>
1959	#include <sys/capability.h>
1960
1961	extern "C" int main(void)
1962	{
1963	char buf[1024];
1964	cap_t caps = cap_get_proc();
1965	snprintf(buf, sizeof(buf), "Current caps are '%s'\n", cap_to_text(caps, NULL));
1966	return 0;
1967	}
1968	EOF
1969	if test_compile $LIBCAP libcap libcap; then
1970	if test_execute; then
1971	log_success "found"
1972	fi
1973	fi
1974	}
1975
1976	#
1977	# Check if we are able to build 32-bit applications (needed for the guest additions)
1978	#
1979	check_32bit()
1980	{
1981	test_header "32-bit support"
1982	cat > $ODIR.tmp_src.c << EOF
1983	#include <stdint.h>
1984	int main(void)
1985	{
1986	return 0;
1987	}
1988	EOF
1989	echo "compiling the following source file:" >> $LOG
1990	cat $ODIR.tmp_src.c >> $LOG
1991	echo "using the following command line:" >> $LOG
1992	echo "$CC -m32 -O -Wall -o $ODIR.tmp_out $ODIR.tmp_src.c" >> $LOG
1993	$CC -m32 -O -Wall -o $ODIR.tmp_out $ODIR.tmp_src.c >> $LOG 2>&1
1994	if [ $? -ne 0 ]; then
1995	echo
1996	echo " Cannot compile 32-bit applications (missing headers and/or libraries)!"
1997	echo " Check the file $LOG for detailed error information."
1998	fail
1999	else
2000	echo "executing the binary" >> $LOG
2001	$ODIR.tmp_out 2> $ODIR.test_execute.log
2002	rc=$?
2003	cat $ODIR.test_execute.log >> $LOG
2004	if [ $rc -ne 0 ]; then
2005	echo
2006	echo " Cannot execute 32-bit applications! Either enable 32-bit support in the"
2007	echo " kernel configuration or use --disable-vmmraw to disable 32-bit guests."
2008	fail
2009	return 1
2010	fi
2011	fi
2012	log_success ""
2013	}
2014
2015
2016	#
2017	# Check for Python
2018	#
2019	check_python()
2020	{
2021	test_header "Python support"
2022
2023	# On darwin this is a on/off decision only
2024	if [ "$OS" = "darwin" ]; then
2025	echo "enabled"
2026	cnf_append "VBOX_WITH_PYTHON" "1"
2027	return
2028	fi
2029
2030	cat > $ODIR.tmp_src.cc << EOF
2031	#include <cstdio>
2032	#include <Python.h>
2033	extern "C" int main(void)
2034	{
2035	Py_Initialize();
2036	printf("found version %s", PY_VERSION);
2037	#if PY_VERSION_HEX >= 0x02060000
2038	printf(", OK.\n");
2039	return 0;
2040	#else
2041	printf(", expected version 2.6 or higher\n");
2042	return 1;
2043	#endif
2044	}
2045	EOF
2046	found=
2047	SUPPYTHONLIBS="python2.7 python2.6 python3.1 python3.2 python3.3 python3.4 python3.4m python3.5 python3.5m python3.6 python3.6m python3.7 python3.7m python3.8 python3.8m python3.9 python3.9m"
2048	for p in $PYTHONDIR; do
2049	for d in $SUPPYTHONLIBS; do
2050	for b in lib/x86_64-linux-gnu lib/i386-linux-gnu lib64 lib/64 lib; do
2051	echo "compiling the following source file:" >> $LOG
2052	cat $ODIR.tmp_src.cc >> $LOG
2053	echo "using the following command line:" >> $LOG
2054	echo "$CXX -O -Wall -o $ODIR.tmp_out $ODIR.tmp_src.cc -I$p/include/$d $p/$b/lib$d.so" >> $LOG
2055	$CXX -O -Wall -o $ODIR.tmp_out $ODIR.tmp_src.cc -I$p/include/$d $p/$b/lib$d.so >> $LOG 2>&1
2056	if [ $? -eq 0 ]; then
2057	found=1
2058	break
2059	fi
2060	done
2061	if [ -n "$found" ]; then break; fi
2062	done
2063	if [ -n "$found" ]; then break; fi
2064	done
2065	if [ -n "$found" ]; then
2066	if test_execute; then
2067	cnf_append "VBOX_WITH_PYTHON" "1"
2068	cnf_append "VBOX_PATH_PYTHON_INC" "$p/include/$d"
2069	cnf_append "VBOX_LIB_PYTHON" "$p/$b/lib$d.so"
2070	else
2071	log_failure "Python not working"
2072	fail
2073	fi
2074	else
2075	log_failure "Python not found"
2076	fail
2077	fi
2078	}
2079
2080
2081	#
2082	# Check for Java
2083	#
2084	check_java()
2085	{
2086	test_header "Java support"
2087	log_success
2088	}
2089
2090
2091	#
2092	# Setup wine
2093	#
2094	setup_wine()
2095	{
2096	test_header "Wine support"
2097	if ! which_wrapper wine > /dev/null; then
2098	echo " wine binary not found"
2099	fail
2100	fi
2101	if ! which_wrapper wine > /dev/null; then
2102	echo " wine not found"
2103	fail
2104	fi
2105	wine_version="`wine --version`"
2106	case "`expr "$wine_version" : 'wine-$[0-9.]*$' '>' 1.1.43`" in
2107	"0")
2108	if ! which_wrapper wineprefixcreate > /dev/null; then
2109	echo " wineprefixcreate not found"
2110	fail
2111	fi
2112	;;
2113	*) eval "wineprefixcreate() { true ; }" ;; # now created automatically
2114	esac
2115	export WINEPREFIX="${ODIR}wine.$BUILD_MACHINE"
2116	echo "WINEPREFIX=\"${ODIR}wine.$BUILD_MACHINE\"" >> $ENV
2117	echo "export WINEPREFIX" >> $ENV
2118	rm -rf $WINEPREFIX
2119	mkdir -p $WINEPREFIX
2120	touch $WINEPREFIX/.no_prelaunch_window_flag
2121	if ! wineprefixcreate -q > /dev/null 2>&1; then
2122	echo " wineprefixcreate failed"
2123	fail
2124	fi
2125	tmp=.tmp.wine.reg
2126	rm -f $tmp
2127	echo 'REGEDIT4' > $tmp
2128	echo '' >> $tmp
2129	echo '[HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Session Manager\Environment]' >> $tmp
2130	echo "\"PATH\"=\"c:\\\\\\\\windows\\\\\\\\system32;c:\\\\\\\\windows;z:$DEVDIR/win.x86/vcc/v8/bin/Microsoft.VC80.CRT;z:$DEVDIR/win.x86/HTML_Help_Workshop/v1.3\"" >> $tmp
2131	echo '' >> $tmp
2132	echo '[HKEY_CURRENT_USER\Software\Wine\AppDefaults\hhc.exe\DllOverrides]' >> $tmp
2133	echo '"itss"="native"' >> $tmp
2134	echo '' >> $tmp
2135	echo '[HKEY_CURRENT_USER\Software\Wine\AppDefaults\hhw.exe\DllOverrides]' >> $tmp
2136	echo '"itss"="native"' >> $tmp
2137	echo '' >> $tmp
2138	if ! wine regedit $tmp > /dev/null 2>&1; then
2139	rm -f $tmp
2140	echo " failed to load registry changes (path)."
2141	fail
2142	fi
2143	rm -f $tmp
2144	log_success "found"
2145	}
2146
2147
2148	#
2149	# Check for gSOAP.
2150	#
2151	check_gsoap()
2152	{
2153	test_header "GSOAP compiler"
2154	if [ -z "$GSOAP" -a -z "$GSOAP_IMPORT" ]; then
2155	if which_wrapper pkg-config > /dev/null; then
2156	GSOAP_CXX_LIBS=`pkg-config gsoapssl++ --libs 2>> $LOG`
2157	if [ $? -eq 0 ]; then
2158	GSOAP=`pkg-config gsoapssl++ --variable=exec_prefix`
2159	GSOAP_IMPORT="$GSOAP/share/gsoap/import"
2160	if [ ! -d "$GSOAP_IMPORT" -a -d "$GSOAP/include/gsoap" ]; then
2161	GSOAP_IMPORT="$GSOAP/include/gsoap"
2162	fi
2163	cnf_append "VBOX_GSOAP_INSTALLED" "1"
2164	cnf_append "VBOX_PATH_GSOAP" "$GSOAP"
2165	cnf_append "VBOX_PATH_GSOAP_IMPORT" "$GSOAP_IMPORT"
2166	if [ -f "$GSOAP/share/gsoap/stdsoap2.cpp" ]; then
2167	cnf_append "VBOX_GSOAP_CXX_SOURCES" "$GSOAP/share/gsoap/stdsoap2.cpp"
2168	else
2169	cnf_append "VBOX_GSOAP_CXX_SOURCES" ""
2170	fi
2171	cnf_append "VBOX_GSOAP_CXX_LIBS" "`strip_l "$GSOAP_CXX_LIBS"`"
2172	gsoap_version=`pkg-config gsoapssl++ --modversion`
2173	log_success "found version $gsoap_version"
2174	return
2175	fi
2176	fi
2177	fi
2178	if [ -z "$GSOAP" ]; then
2179	GSOAP="/usr"
2180	fi
2181	if which_wrapper "$GSOAP/bin/soapcpp2" > /dev/null; then
2182	if which_wrapper "$GSOAP/bin/wsdl2h" > /dev/null; then
2183	if [ -f "$GSOAP/include/stdsoap2.h" ]; then
2184	# TODO: Check for libgsoap++.a/so
2185
2186	if [ -z "$GSOAP_IMPORT" ]; then
2187	GSOAP_IMPORT="$GSOAP/share/gsoap/import"
2188	if [ ! -d "$GSOAP_IMPORT" -a -d "$GSOAP/include/gsoap" ]; then
2189	GSOAP_IMPORT="$GSOAP/include/gsoap"
2190	fi
2191	fi
2192	if [ -f "$GSOAP_IMPORT/stlvector.h" ]; then
2193	cnf_append "VBOX_GSOAP_INSTALLED" "1"
2194	cnf_append "VBOX_PATH_GSOAP" "$GSOAP"
2195	cnf_append "VBOX_PATH_GSOAP_IMPORT" "$GSOAP_IMPORT"
2196	if [ -f "$GSOAP/share/gsoap/stdsoap2.cpp" ]; then
2197	cnf_append "VBOX_GSOAP_CXX_SOURCES" "$GSOAP/share/gsoap/stdsoap2.cpp"
2198	else
2199	cnf_append "VBOX_GSOAP_CXX_SOURCES" ""
2200	fi
2201	cnf_append "VBOX_GSOAP_CXX_LIBS" "libgsoapssl++"
2202	log_success "found"
2203	else
2204	log_failure "stlvector.h not found -- disabling webservice"
2205	cnf_append "VBOX_WITH_WEBSERVICES" ""
2206	fi
2207	else
2208	log_failure "stdsoap2.h not found -- disabling webservice"
2209	cnf_append "VBOX_WITH_WEBSERVICES" ""
2210	fi
2211	else
2212	log_failure "wsdl2h not found -- disabling webservice"
2213	cnf_append "VBOX_WITH_WEBSERVICES" ""
2214	fi
2215	else
2216	log_failure "soapcpp2 not found -- disabling webservice"
2217	cnf_append "VBOX_WITH_WEBSERVICES" ""
2218	fi
2219	}
2220
2221
2222	#
2223	# Determines the Darwin version.
2224	#
2225	check_darwinversion()
2226	{
2227	test_header "Darwin version"
2228	darwin_ver=`uname -r`
2229	case "$darwin_ver" in
2230	20\.*)
2231	darwin_ver="11.0" # Big Sur
2232	;;
2233	19\.*)
2234	darwin_ver="10.15" # Catalina
2235	;;
2236	18\.*)
2237	darwin_ver="10.14" # Mojave
2238	;;
2239	17\.*)
2240	darwin_ver="10.13" # High Sierra
2241	;;
2242	16\.*)
2243	darwin_ver="10.12" # Sierra
2244	;;
2245	15\.*)
2246	darwin_ver="10.11" # El Capitan
2247	;;
2248	14\.*)
2249	darwin_ver="10.10" # Yosemite
2250	;;
2251	13\.*)
2252	darwin_ver="10.9" # Mavericks
2253	;;
2254	*)
2255	echo " failed to determine Darwin version. (uname -r: $darwin_ver)"
2256	fail
2257	darwin_ver="unknown"
2258	;;
2259	esac
2260
2261	log_success "found version $darwin_ver"
2262	}
2263
2264	#
2265	# Check Xcode path
2266	#
2267	check_xcode_path()
2268	{
2269	# Check if WITH_XCODE_DIR is set.
2270	if [ -z "$WITH_XCODE_DIR" ]; then
2271	if [ -d "/Library/Developer/CommandLineTools" -a -f "/Library/Developer/CommandLineTools/usr/bin/clang" ]; then
2272	return 1
2273	else
2274	echo "Please specify --with-xcode-dir option."
2275	return 0
2276	fi
2277	fi
2278
2279	# Check if specified path exists and is a directory containing Xcode.
2280	if [ -d "$1" -a -f "$1/Contents/Developer/usr/bin/xcodebuild" ]; then
2281	return 1
2282	else
2283	echo "Xcode path [$1] not found."
2284	return 0
2285	fi
2286	}
2287
2288	check_xcode()
2289	{
2290	test_header "Xcode and SDK"
2291	check_xcode_path "$WITH_XCODE_DIR"
2292	[ $? -eq 1 ] \|\| fail
2293
2294	# Pick the oldest SDK offered by Xcode, to get maximum compatibility
2295	if [ -z "$WITH_XCODE_DIR" ]; then
2296	devel_subdir="/Library/Developer/CommandLineTools"
2297	sdk_subdir="$devel_subdir/SDKs"
2298	else
2299	devel_subdir="$WITH_XCODE_DIR/Contents/Developer"
2300	sdk_subdir="$devel_subdir/Platforms/MacOSX.platform/Developer/SDKs"
2301	fi
2302	sdk_tries="$sdk_subdir"/MacOSX10.?.sdk" $sdk_subdir"/MacOSX10.??.sdk" $sdk_subdir"/MacOSX.sdk
2303	for t in $sdk_tries; do
2304	if [ -f "$t/SDKSettings.plist" ]; then
2305	sdk="$t"
2306	sdk_ver=`defaults read "$t/SDKSettings.plist" Version`
2307	break
2308	fi
2309	done
2310	if [ -z "$sdk" ]; then
2311	echo " failed to determine SDK directory. ($sdk_subdir/MacOSX*.sdk/SDKSettings.plist should exist)"
2312	fail
2313	fi
2314	xcode_ver=`$devel_subdir/usr/bin/clang --version \| sed -n 's/^.version $[0-9]\{1,\}\.[0-9]\{1,\}\.[0-9]\{1,\}$.$/\1/p'`
2315	if [ $? -ne 0 -o -z "$xcode_ver" ]; then
2316	echo " failed to determine Xcode version."
2317	fail
2318	fi
2319
2320	if [ -z "$WITH_XCODE_DIR" ]; then
2321	cnf_append "VBOX_WITH_EVEN_NEWER_XCODE" "1"
2322	else
2323	cnf_append "VBOX_WITH_MACOSX_COMPILERS_FROM_DEVEL" "1"
2324	cnf_append "PATH_TOOL_VBoxXcode62" "$devel_subdir"
2325	cnf_append "VBOX_PATH_MACOSX_DEVEL_ROOT" "$devel_subdir"
2326	fi
2327	cnf_append "VBOX_PATH_MACOSX_SDK" "$sdk"
2328	if [ -n "$sdk_ver" ]; then
2329	cnf_append "VBOX_DEF_MACOSX_VERSION_MIN" "$sdk_ver"
2330	cnf_append "VBOX_WITHOUT_VBOXPYTHON_FOR_OSX_10_6" "1"
2331	fi
2332
2333	log_success "found version $xcode_ver (SDK: $sdk)"
2334	}
2335
2336
2337	check_makeself()
2338	{
2339	test_header "makeself"
2340	if check_avail "$MAKESELF" makeself; then
2341	makeself_ver=`$MAKESELF --version\|grep version\|sed 's+^Makeself.version $[0-9\.]$.*+\1+'`
2342	if [ $? -ne 0 ]; then
2343	log_failure "makeself not working"
2344	fail
2345	else
2346	log_success "found version $makeself_ver"
2347	cnf_append "VBOX_MAKESELF" "`which_wrapper $MAKESELF`"
2348	fi
2349	fi
2350	}
2351
2352
2353	#
2354	# Show help
2355	#
2356	show_help()
2357	{
2358	cat << EOF
2359	Usage: ./configure [OPTIONS]...
2360
2361	Configuration:
2362	-h, --help display this help and exit
2363	--nofatal don't abort on errors
2364	EOF
2365	[ $WITH_XPCOM -eq 1 ] && echo " --disable-xpcom disable XPCOM and related stuff"
2366	[ $WITH_PYTHON -eq 1 ] && echo " --disable-python disable python bindings"
2367	[ $WITH_JAVA -eq 1 ] && echo " --disable-java disable java bindings"
2368	[ $WITH_VMMRAW -eq 1 ] && echo " --disable-vmmraw disable VMM raw mode (VT-x/AMD-V mandatory!)"
2369	[ $WITH_SDL_TTF -eq 1 ] && echo " --disable-sdl-ttf disable SDL_ttf detection"
2370	[ $WITH_QT5 -eq 1 ] && echo " --disable-qt disable Qt detection"
2371	[ $WITH_ALSA -eq 1 ] && echo " --disable-alsa disable the ALSA sound backend"
2372	[ $WITH_PULSE -eq 1 ] && echo " --disable-pulse disable the PulseAudio backend"
2373	[ $WITH_DBUS -eq 1 ] && echo " --disable-dbus don't use DBus and hal for hardware detection"
2374	[ $WITH_KMODS -eq 1 ] && echo " --disable-kmods don't build Linux kernel modules (host and guest)"
2375	[ $WITH_OPENGL -eq 1 ] && echo " --disable-opengl disable OpenGL support (2D & 3D)"
2376	[ $WITH_QT5 -eq 0 ] && echo " --enable-qt5 enable Qt5 detection"
2377	[ $WITH_GSOAP -eq 0 ] && echo " --enable-webservice enable the webservice stuff"
2378	[ $OSE -eq 1 ] && echo " --enable-vnc enable the VNC server"
2379	[ $OSE -eq 0 ] && echo " --disable-extpack don't build the extpack"
2380	[ $WITH_DOCS -eq 1 ] && echo " --disable-docs don't build the documentation"
2381	[ $WITH_LIBVPX -eq 1 ] && echo " --disable-libvpx don't use libvpx for video capturing"
2382	[ $WITH_LIBOPUS -eq 1 ] && echo " --disable-libopus don't use libopus for audio capturing"
2383	[ "$OS" = "linux" -o "$OS" = "freebsd" ] && echo " --enable-vde enable VDE networking"
2384	cat << EOF
2385	--disable-udptunnel disable UDP tunnel networking
2386	--disable-devmapper disable device mapper library access
2387	--disable-hardening don't be strict about /dev/vboxdrv access
2388	--build-libxml2 build libxml2 from sources
2389	--build-libssl build openssl from sources
2390	EOF
2391	[ $OSE -eq 0 ] && cat << EOF
2392	--build-libcurl build libcurl from sources
2393	--build-libvpx build libvpx from sources
2394	EOF
2395	[ "$OS" != "darwin" ] && echo " --setup-wine setup a Wine directory and register the hhc hack"
2396	cat << EOF
2397	--only-additions only build the Guest Additions
2398
2399	Paths:
2400	--with-gcc=PATH location of the gcc compiler [$CC]
2401	--with-g++=PATH location of the g++ compiler [$CXX]
2402	--with-kbuild=DIR kbuild directory [$KBUILDDIR]
2403	--with-iasl=PATH location of the iasl compiler [$IASL]
2404	--with-yasm=PATH location of the iasl compiler [$YASM]
2405	--with-makeself=PATH location of makeself [$MAKESELF]
2406	EOF
2407	[ "$OS" = "darwin" ] && echo " --with-xcode-dir=DIR custom path to Xcode root directory; it is assumed that Xcode"
2408	[ "$OS" = "darwin" ] && echo " contains OS X 10.6 SDK (required for Mountain Lion and newer hosts"
2409	[ "$OS" = "darwin" ] && echo " only, ignored for the rest)"
2410	[ "$OS" = "linux" ] && echo " --with-linux=DIR Linux kernel source directory [$LINUX]"
2411	[ $WITH_QT5 -eq 1 ] && echo " --with-qt-dir=DIR directory for Qt headers/libraries [pkgconfig]"
2412	[ $WITH_GSOAP -eq 1 ] && echo " --with-gsoap-dir=PATH directory for gSOAP compiler/headers/libraries"
2413	[ $WITH_GSOAP -eq 1 ] && echo " (soapcpp2 and wsdl2h, soapstd2.h, libgsoap++.a/so)"
2414	[ $WITH_GSOAP -eq 1 ] && echo " --with-gsoap-import=PATH directory for gSOAP import files (stlvector.h)"
2415	cat << EOF
2416	--with-openssl-dir=DIR directory for OpenSSL headers/libraries
2417	--with-ow-dir=DIR directory where Open Watcom can be found [$WATCOM]
2418	--out-path=PATH the folder to which configuration and build output
2419	should go
2420
2421	Build type:
2422	-d, --build-debug build with debugging symbols and assertions
2423	--build-profile build with profiling support
2424	--build-headless build headless (without any GUI frontend)
2425	EOF
2426	exit 0
2427	}
2428
2429
2430	#
2431	# The body.
2432	#
2433
2434	# test if we are OSE
2435	if [ $OSE -eq 1 -a -r "`cd \`dirname $0\`; pwd`/src/VBox/RDP/server/server.cpp" ]; then
2436	OSE=0
2437	# Set this as a reminder to print a log message once we know the path of the
2438	# log file
2439	NOT_OSE=1
2440	fi
2441
2442	# Change OS specific defaults; must be before all other stuff
2443	if [ "$OS" = "darwin" ]; then
2444	WITH_SDL=0
2445	WITH_SDL_TTF=0
2446	WITH_X11=0
2447	WITH_ALSA=0
2448	WITH_PULSE=0
2449	WITH_DBUS=0
2450	WITH_KMODS=0
2451	BUILD_LIBXML2=1
2452	BUILD_LIBSSL=1
2453	BUILD_LIBVPX=1
2454	[ $OSE -eq 1 ] \|\| BUILD_LIBCURL=1
2455	[ $OSE -eq 1 ] && WITH_LIBVPX=0
2456	[ $OSE -eq 1 ] && WITH_LIBOPUS=0
2457	WITH_XCODE_DIR=""
2458	elif [ "$OS" = "haiku" ]; then
2459	#WITH_SDL=0
2460	WITH_SDL_TTF=0
2461	WITH_X11=0
2462	WITH_ALSA=0
2463	WITH_PULSE=0
2464	WITH_DBUS=0
2465	WITH_KMODS=0
2466	WITH_LIBIDL=0
2467	WITH_XPCOM=0
2468	BUILD_LIBXSLT=1
2469	BUILD_LIBXML2=1
2470	WITH_LIBVPX=0
2471	WITH_LIBOPUS=0
2472	# it is part of libroot, which is linked by default,
2473	# but the script wants something
2474	LIBPTHREAD="-lroot"
2475	#[ $OSE -eq 1 ] \|\| BUILD_LIBCURL=1
2476	[ $OSE -eq 1 ] \|\| BUILD_LIBSSL=1
2477	elif [ "$OS" = "solaris" ]; then
2478	[ $OSE -eq 1 ] && WITH_LIBVPX=0
2479	[ $OSE -eq 1 ] && WITH_LIBOPUS=0
2480	fi
2481
2482	# scan command line options
2483	for option in "$@"; do
2484	case "$option" in
2485	--help\|-help\|-h)
2486	show_help
2487	;;
2488	--nofatal)
2489	nofatal=1
2490	;;
2491	--env-only)
2492	ENV_ONLY=1
2493	;;
2494	--with-gcc=*)
2495	CC=`echo $option \| cut -d'=' -f2`
2496	;;
2497	--with-g++=*)
2498	CXX=`echo $option \| cut -d'=' -f2`
2499	;;
2500	--with-kbuild=*)
2501	KBUILDDIR=`echo $option \| cut -d'=' -f2`
2502	if echo $KBUILDDIR\|grep -q "$INVALID_CHARS"; then
2503	echo "Error: KBUILDDIR contains invalid characters!"
2504	exit 1
2505	fi
2506	;;
2507	--with-qt-dir=*)
2508	[ $WITH_QT5 -eq 1 ] && QT5DIR=`echo $option \| cut -d'=' -f2`
2509	[ $WITH_QT5 -eq 1 ] && QT5DIR_PKGCONFIG=0
2510	;;
2511	--with-qt5-minor=*)
2512	QT5MIN=`echo $option \| cut -d'=' -f2`
2513	;;
2514	--with-qt5-major=*)
2515	QT5MAJ=`echo $option \| cut -d'=' -f2`
2516	;;
2517	--with-openssl-dir=*)
2518	OPENSSLDIR=`echo $option \| cut -d'=' -f2`
2519	INCCRYPTO="-I${OPENSSLDIR}/include"
2520	LIBCRYPTO="${OPENSSLDIR}/lib/libcrypto.a ${OPENSSLDIR}/lib/libssl.a"
2521	# On Darwin (at least for macports) static OpenSSL also needs zlib.
2522	[ "$OS" = "darwin" ] && LIBCRYPTO="$LIBCRYPTO ${OPENSSLDIR}/lib/libz.a"
2523	;;
2524	--with-ow-dir=*)
2525	WATCOM=`echo $option \| cut -d'=' -f2`
2526	;;
2527	--with-gsoap-dir=*)
2528	GSOAP=`echo $option \| cut -d'=' -f2`
2529	;;
2530	--with-gsoap-import=*)
2531	GSOAP_IMPORT=`echo $option \| cut -d'=' -f2`
2532	;;
2533	--with-iasl=*)
2534	IASL=`echo $option \| cut -d'=' -f2`
2535	;;
2536	--with-yasm=*)
2537	YASM=`echo $option \| cut -d'=' -f2`
2538	;;
2539	--with-xcode-dir=*)
2540	WITH_XCODE_DIR=`echo $option \| cut -d'=' -f2`
2541	;;
2542	--with-linux=*)
2543	LINUX=`echo $option \| cut -d'=' -f2`
2544	;;
2545	--with-makeself=*)
2546	MAKESELF=`echo $option \| cut -d'=' -f2`
2547	;;
2548	--target-arch=*)
2549	TARGET_MACHINE=`echo $option \| cut -d'=' -f2`
2550	;;
2551	--disable-xpcom)
2552	[ $WITH_XPCOM -eq 1 ] && WITH_XPCOM=0
2553	;;
2554	--disable-python)
2555	[ $WITH_PYTHON -eq 1 ] && WITH_PYTHON=0
2556	;;
2557	--disable-java)
2558	[ $WITH_JAVA -eq 1 ] && WITH_JAVA=0
2559	;;
2560	--disable-vmmraw)
2561	[ $WITH_VMMRAW -eq 1 ] && WITH_VMMRAW=0
2562	;;
2563	--disable-sdl-ttf)
2564	[ $WITH_SDL_TTF -eq 1 ] && WITH_SDL_TTF=0
2565	;;
2566	--disable-qt)
2567	[ $WITH_QT5 -eq 1 ] && WITH_QT5=0
2568	;;
2569	--enable-qt5)
2570	[ $WITH_QT5 -eq 0 ] && WITH_QT5=1
2571	;;
2572	--passive-mesa)
2573	PASSIVE_MESA=1
2574	;;
2575	--disable-alsa)
2576	[ $WITH_ALSA -eq 1 ] && WITH_ALSA=0
2577	;;
2578	--disable-pulse)
2579	[ $WITH_PULSE -eq 1 ] && WITH_PULSE=0
2580	;;
2581	--enable-pulse)
2582	WITH_PULSE=2
2583	;;
2584	--disable-dbus)
2585	[ $WITH_DBUS -eq 1 ] && WITH_DBUS=0
2586	;;
2587	--disable-kmods)
2588	[ $WITH_KMODS -eq 1 ] && WITH_KMODS=0
2589	;;
2590	--disable-opengl)
2591	[ $WITH_OPENGL -eq 1 ] && WITH_OPENGL=0
2592	;;
2593	--enable-webservice)
2594	[ $WITH_GSOAP -eq 0 ] && WITH_GSOAP=1
2595	;;
2596	--enable-vnc)
2597	WITH_VNC=1
2598	;;
2599	--disable-hardening)
2600	WITH_HARDENING=0
2601	;;
2602	--disable-extpack)
2603	WITH_EXTPACK=0
2604	;;
2605	--disable-docs)
2606	WITH_DOCS=0
2607	;;
2608	--enable-hardening)
2609	WITH_HARDENING=2
2610	;;
2611	--build-libopus)
2612	BUILD_LIBOPUS=1
2613	;;
2614	--disable-udptunnel)
2615	WITH_UDPTUNNEL=0
2616	;;
2617	--enable-vde)
2618	WITH_VDE=1
2619	;;
2620	--disable-devmapper)
2621	WITH_DEVMAPPER=0
2622	;;
2623	--disable-libvpx)
2624	WITH_LIBVPX=0
2625	;;
2626	--disable-libopus)
2627	WITH_LIBOPUS=0
2628	;;
2629	--disable-sdl)
2630	WITH_SDL=0
2631	;;
2632	--build-debug\|-d)
2633	BUILD_TYPE=debug
2634	;;
2635	--build-profile)
2636	BUILD_TYPE=profile
2637	;;
2638	--build-libxml2)
2639	BUILD_LIBXML2=1
2640	;;
2641	--build-libssl)
2642	BUILD_LIBSSL=1
2643	;;
2644	--build-libcurl)
2645	BUILD_LIBCURL=1
2646	;;
2647	--build-libvpx)
2648	BUILD_LIBVPX=1
2649	;;
2650	--build-headless)
2651	HEADLESS=1
2652	WITH_SDL=0
2653	WITH_SDL_TTF=0
2654	WITH_X11=0
2655	WITH_OPENGL=0
2656	WITH_QT5=0
2657	;;
2658	--ose)
2659	OSE=2
2660	;;
2661	--odir=*)
2662	ODIR="`echo $option \| cut -d'=' -f2`/"
2663	ODIR_OVERRIDE=1
2664	;;
2665	--out-path=*)
2666	out_path="`echo $option \| cut -d'=' -f2`/"
2667	if [ -d $out_path ]; then
2668	saved_path="`pwd`"
2669	cd $out_path
2670	OUT_PATH="`pwd`"
2671	cd $saved_path
2672	OUT_PATH_OVERRIDE=1
2673	if [ $ODIR_OVERRIDE -eq 0 ]; then
2674	# This variable has not yet been overridden. That can still happen.
2675	ODIR=$OUT_PATH/
2676	fi
2677	else
2678	echo "Error: invalid folder \"$out_path\" in option \"$option\""
2679	exit 1
2680	fi
2681	;;
2682	--setup-wine)
2683	[ "$OS" != "darwin" ] && SETUP_WINE=1
2684	;;
2685	--only-additions)
2686	ONLY_ADDITIONS=1
2687	;;
2688	*)
2689	echo
2690	echo "Unrecognized option \"$option\""
2691	echo
2692	show_help
2693	;;
2694	esac
2695	done
2696
2697	LOG="$ODIR$LOG"
2698	ENV="$ODIR$ENV"
2699	CNF="$ODIR$CNF"
2700
2701	# initialize output files
2702	cat > $LOG << EOF
2703	# Log file generated by
2704	#
2705	# '$0 $*'
2706	#
2707
2708	EOF
2709	cat > $CNF << EOF
2710	# -- Makefile --
2711	#
2712	# automatically generated by
2713	#
2714	# '$0 $*'
2715	#
2716	# It will be completely overwritten if configure is executed again.
2717	#
2718
2719	EOF
2720	cat > $ENV << EOF
2721	#!/bin/bash
2722	#
2723	# automatically generated by
2724	#
2725	# '$0 $*'
2726	#
2727	# It will be completely overwritten if configure is executed again.
2728	# Make sure you source this file once before you start to build VBox.
2729	#
2730
2731	EOF
2732
2733	# Print log warning about OSE if necessary
2734	if [ -n "$NOT_OSE" ]; then
2735	echo "Found RDP server, assuming VBOX_OSE = FALSE" >> $LOG
2736	echo >> $LOG
2737	fi
2738
2739
2740	if [ "$BUILD_TYPE" = "debug" ]; then
2741	echo "Creating DEBUG build!" >> $LOG
2742	elif [ "$BUILD_TYPE" = "profile" ]; then
2743	echo "Creating PROFILE build!" >> $LOG
2744	fi
2745
2746	# first determine our environment
2747	check_environment
2748	check_kbuild
2749
2750	[ -n "$ENV_ONLY" ] && exit 0
2751
2752	# append the tools directory to the default search path
2753	echo "$PATH" \| grep -q "$DEVDIR_BIN" \|\| PATH="$PATH:$DEVDIR_BIN"
2754	export PATH
2755
2756	# if we will be writing to a different out directory then set this up now
2757	if [ $OUT_PATH_OVERRIDE -eq 1 ]; then
2758	echo "AUTOCFG=$OUT_PATH/AutoConfig.kmk" >> $ENV
2759	echo "export AUTOCFG" >> $ENV
2760	echo "LOCALCFG=$OUT_PATH/LocalConfig.kmk" >> $ENV
2761	echo "export LOCALCFG" >> $ENV
2762	echo "PATH_OUT_BASE=$OUT_PATH" >> $ENV
2763	echo "export PATH_OUT_BASE" >> $ENV
2764	fi
2765
2766	# don't bother people with -Werror
2767	cnf_append "VBOX_GCC_WERR" "\$(NO_SUCH_VARIABLE)"
2768
2769	# some things are not available in for OSE
2770	if [ $OSE -ge 1 ]; then
2771	cnf_append "VBOX_OSE" "1"
2772	cnf_append "VBOX_WITH_VALIDATIONKIT" ""
2773	cnf_append "VBOX_WITH_WIN32_ADDITIONS" ""
2774
2775	if [ "$OS" = "linux" ]; then
2776	cnf_append "VBOX_WITH_LINUX_ADDITIONS" "1"
2777	else
2778	cnf_append "VBOX_WITH_LINUX_ADDITIONS" ""
2779	fi
2780	echo >> $CNF
2781	fi
2782
2783	# extpack
2784	if [ $ONLY_ADDITIONS -eq 1 ]; then
2785	cnf_append "VBOX_WITH_EXTPACK_PUEL_BUILD" ""
2786	elif [ $OSE -eq 0 ]; then
2787	if [ $WITH_EXTPACK -eq 1 ]; then
2788	BUILD_LIBSSL=1
2789	else
2790	cnf_append "VBOX_WITH_EXTPACK_PUEL_BUILD" ""
2791	fi
2792	fi
2793
2794	# headless
2795	if [ -n "$HEADLESS" ]; then
2796	cnf_append "VBOX_HEADLESS" "1"
2797	fi
2798
2799	# emit disable directives corresponding to any --disable-xxx options.
2800	if [ $WITH_OPENGL -eq 0 ]; then
2801	cnf_append "VBOX_WITH_VMSVGA3D" ""
2802	cnf_append "VBOX_WITH_3D_ACCELERATION" ""
2803	cnf_append "VBOX_WITH_VIDEOHWACCEL" ""
2804	cnf_append "VBOX_GUI_USE_QGL" ""
2805	fi
2806	[ $WITH_XPCOM -eq 0 ] && cnf_append "VBOX_WITH_MAIN" ""
2807	[ $WITH_QT5 -eq 0 ] && cnf_append "VBOX_WITH_QTGUI" ""
2808	[ $WITH_SDL_TTF -eq 0 ] && cnf_append "VBOX_WITH_SECURELABEL" ""
2809	[ $WITH_PYTHON -eq 0 ] && cnf_append "VBOX_WITH_PYTHON" ""
2810	[ $WITH_JAVA -eq 0 ] && cnf_append "VBOX_WITH_JXPCOM" ""
2811	[ $WITH_JAVA -eq 0 ] && cnf_append "VBOX_WITH_JWS" ""
2812	[ $WITH_HARDENING -eq 0 ] && cnf_append "VBOX_WITHOUT_HARDENING" "1"
2813	[ $WITH_HARDENING -eq 2 ] && cnf_append "VBOX_WITH_HARDENING" "2"
2814	[ $WITH_VMMRAW -eq 0 ] && cnf_append "VBOX_WITH_RAW_MODE" ""
2815	if [ $WITH_LIBVPX -eq 0 ]; then
2816	cnf_append "VBOX_WITH_LIBVPX" ""
2817	cnf_append "VBOX_WITH_RECORDING" ""
2818	fi
2819	if [ $WITH_LIBOPUS -eq 0 ]; then
2820	cnf_append "VBOX_WITH_LIBOPUS" ""
2821	cnf_append "VBOX_WITH_AUDIO_RECORDING" ""
2822	fi
2823
2824	# Darwin-specific
2825	[ "$OS" = "darwin" ] && check_darwinversion
2826	# the tools
2827	[ "$OS" != "darwin" ] && check_gcc
2828	[ "$OS" = "darwin" ] && check_xcode
2829	if [ $ONLY_ADDITIONS -eq 0 ]; then
2830	check_open_watcom
2831	[ "$OS" != "darwin" ] && check_iasl
2832	[ $OSE -ge 1 ] && check_yasm
2833	[ "$OS" != "darwin" ] && check_xsltproc
2834	fi
2835
2836	# the libraries
2837	if [ $ONLY_ADDITIONS -eq 0 ]; then
2838	[ "$OS" != "darwin" ] && check_pthread
2839	check_libxml2
2840	[ $WITH_LIBIDL -eq 1 ] && check_libidl
2841	check_z
2842	check_lzf
2843	check_ssl
2844	check_curl
2845	[ $WITH_LIBVPX -eq 1 ] && check_vpx
2846	[ $WITH_LIBOPUS -eq 1 ] && check_libopus
2847	[ "$OS" != "darwin" ] && check_png
2848	[ $OSE -eq 0 -a "$OS" = "linux" ] && check_pam
2849	if [ $WITH_SDL -eq 1 ]; then
2850	check_sdl
2851	else
2852	cnf_append "VBOX_WITH_VBOXSDL" ""
2853	fi
2854	[ $WITH_SDL_TTF -eq 1 -a $OSE -eq 0 ] && check_sdl_ttf
2855	[ $WITH_X11 -eq 1 ] && check_x
2856	# TODO check for xcomposite-dev (X11/extensions/Xcomposite.h, additions only)
2857	# TODO check for libxdamange-dev (X11/extensions/Xdamage.h, additions only)
2858	[ $WITH_X11 -eq 1 ] && check_xcursor
2859	[ $WITH_X11 -eq 1 ] && check_xinerama
2860	[ $WITH_X11 -eq 1 ] && check_xrandr
2861	[ $WITH_OPENGL -eq 1 ] && check_opengl
2862	[ $WITH_QT5 -eq 1 ] && check_qt5
2863	[ $WITH_PYTHON -eq 1 ] && check_python
2864	[ $WITH_JAVA -eq 1 ] && check_java
2865
2866	# PulseAudio
2867	if [ $WITH_PULSE -eq 1 ]; then
2868	check_pulse
2869	elif [ $WITH_PULSE -eq 0 ]; then # Force disabling PulseAudio.
2870	cnf_append "VBOX_WITH_AUDIO_PULSE" ""
2871	elif [ $WITH_PULSE -eq 2 ]; then # --enable-pulse was passed, force PulseAudio.
2872	cnf_append "VBOX_WITH_AUDIO_PULSE" "1"
2873	fi
2874	fi
2875
2876	# Linux-specific
2877	if [ "$OS" = "linux" ]; then
2878	# don't check for the static libstdc++ in the PUEL version as we build the
2879	# additions at a dedicated box
2880	[ $OSE -ge 1 ] && check_staticlibstdcxx
2881	if [ $WITH_KMODS -eq 1 ]; then
2882	check_linux
2883	else
2884	cnf_append "VBOX_LINUX_SRC" ""
2885	cnf_append "VBOX_WITHOUT_LINUX_TEST_BUILDS" "1"
2886	fi
2887	if [ $ONLY_ADDITIONS -eq 0 ]; then
2888	if [ $WITH_ALSA -eq 1 ]; then
2889	check_alsa
2890	else
2891	cnf_append "VBOX_WITH_AUDIO_ALSA" ""
2892	fi
2893	if [ $WITH_DBUS -eq 0 ]; then
2894	cnf_append "VBOX_WITH_DBUS" ""
2895	fi
2896	if [ $WITH_DEVMAPPER -eq 1 ]; then
2897	check_libdevmapper
2898	else
2899	cnf_append "VBOX_WITH_DEVMAPPER" ""
2900	fi
2901	check_libcap
2902	fi
2903	check_compiler_h
2904	[ $ONLY_ADDITIONS -eq 0 -a "$BUILD_MACHINE" = "amd64" -a $WITH_VMMRAW -eq 1 ] && check_32bit
2905	# tools/common/makeself*
2906	[ $OSE -ge 1 ] && check_makeself
2907	fi
2908
2909	[ -n "$SETUP_WINE" ] && setup_wine
2910
2911	if [ $ONLY_ADDITIONS -eq 0 -a $WITH_GSOAP -eq 1 ]; then
2912	check_gsoap
2913	else
2914	if [ $OSE -ge 1 ]; then
2915	cnf_append "VBOX_WITH_WEBSERVICES" ""
2916	fi
2917	fi
2918
2919	# UDPTUNNEL
2920	if [ $ONLY_ADDITIONS -eq 0 -a $WITH_UDPTUNNEL -eq 0 ]; then
2921	cnf_append "VBOX_WITH_UDPTUNNEL" ""
2922	fi
2923
2924	# VDE
2925	if [ $ONLY_ADDITIONS -eq 0 -a "$OS" = "linux" -o "$OS" = "freebsd" ]; then
2926	if [ $WITH_VDE -eq 1 ]; then
2927	cnf_append "VBOX_WITH_VDE" "1"
2928	fi
2929	fi
2930
2931	# DOCS
2932	if [ $ONLY_ADDITIONS -eq 1 -o $WITH_DOCS -eq 0 ]; then
2933	cnf_append "VBOX_WITH_DOCS" ""
2934	cnf_append "VBOX_WITH_DOCS_PACKING" ""
2935	fi
2936
2937	# VNC server support
2938	if [ $ONLY_ADDITIONS -eq 0 -a $OSE -ge 1 ]; then
2939	if [ $WITH_VNC = 1 ]; then
2940	check_vncserver
2941	else
2942	cnf_append "VBOX_WITH_EXTPACK_VNC" ""
2943	fi
2944	fi
2945
2946	if [ $ONLY_ADDITIONS -eq 1 ]; then
2947	cnf_append "VBOX_ONLY_ADDITIONS" "1"
2948	fi
2949
2950	# success!
2951	echo
2952	echo "Successfully generated '$CNF' and '$ENV'."
2953	echo "Source '$ENV' once before you start to build VBox:"
2954	echo ""
2955	echo " source $ENV"
2956	echo " kmk"
2957	echo ""
2958	if [ "$OS" = "linux" ]; then
2959	if [ $OUT_PATH_OVERRIDE -eq 1 ]; then
2960	vbox_out_path=$OUT_PATH
2961	else
2962	vbox_out_path=./out
2963	fi
2964	echo "To compile the kernel modules, do:"
2965	echo ""
2966	echo " cd $vbox_out_path/$OS.$TARGET_MACHINE/$BUILD_TYPE/bin/src"
2967	echo " make"
2968	echo ""
2969	fi
2970	if [ $ONLY_ADDITIONS -eq 1 ]; then
2971	echo ""
2972	echo " Tree configured to build only the Guest Additions"
2973	echo ""
2974	elif [ $WITH_HARDENING -gt 0 ]; then
2975	echo ""
2976	echo " +++ WARNING +++ WARNING +++ WARNING +++ WARNING +++ WARNING +++ WARNING +++"
2977	echo " Hardening is enabled which means that the VBox binaries will not run from"
2978	echo " the binary directory. The binaries have to be installed suid root and some"
2979	echo " more prerequisites have to be fulfilled which is normally done by installing"
2980	echo " the final package. For development, the hardening feature can be disabled"
2981	echo " by specifying the --disable-hardening parameter. Please never disable that"
2982	echo " feature for the final distribution!"
2983	echo " +++ WARNING +++ WARNING +++ WARNING +++ WARNING +++ WARNING +++ WARNING +++"
2984	echo ""
2985	else
2986	echo ""
2987	echo " +++ WARNING +++ WARNING +++ WARNING +++ WARNING +++ WARNING +++ WARNING +++"
2988	echo " Hardening is disabled. Please do NOT build packages for distribution with"
2989	echo " disabled hardening!"
2990	echo " +++ WARNING +++ WARNING +++ WARNING +++ WARNING +++ WARNING +++ WARNING +++"
2991	echo ""
2992	fi
2993	echo "Enjoy!"
2994	cleanup

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/configure@ 89669

Download in other formats: