/[gentoo-x86]/eclass/eutils.eclass

Diff of /eclass/eutils.eclass

Parent Directory | Revision Log | View Patch Patch

Revision 1.163		Revision 1.349
1	# Copyright 1999-2005 Gentoo Foundation	1	# Copyright 1999-2009 Gentoo Foundation
2	# Distributed under the terms of the GNU General Public License v2	2	# Distributed under the terms of the GNU General Public License v2
3	# $Header: /var/cvsroot/gentoo-x86/eclass/eutils.eclass,v 1.163 2005/03/26 06:33:16 eradicator Exp $	3	# $Header: /var/cvsroot/gentoo-x86/eclass/eutils.eclass,v 1.349 2010/08/19 21:32:26 vapier Exp $
4	#
5	# Author: Martin Schlemmer <azarah@gentoo.org>
6	#
7	# This eclass is for general purpose functions that most ebuilds
8	# have to implement themselves.
9	#
10	# NB: If you add anything, please comment it!
11		4
12	inherit multilib	5	# @ECLASS: eutils.eclass
13	ECLASS=eutils	6	# @MAINTAINER:
14	INHERITED="$INHERITED $ECLASS"	7	# base-system@gentoo.org
		8	# @BLURB: many extra (but common) functions that are used in ebuilds
		9	# @DESCRIPTION:
		10	# The eutils eclass contains a suite of functions that complement
		11	# the ones that ebuild.sh already contain. The idea is that the functions
		12	# are not required in all ebuilds but enough utilize them to have a common
		13	# home rather than having multiple ebuilds implementing the same thing.
		14	#
		15	# Due to the nature of this eclass, some functions may have maintainers
		16	# different from the overall eclass!
15		17
16	DEPEND="!bootstrap? ( sys-devel/patch )"	18	inherit multilib portability
17		19
18	DESCRIPTION="Based on the ${ECLASS} eclass"	20	DESCRIPTION="Based on the ${ECLASS} eclass"
19		21
20	# ecpu_check	22	if has "${EAPI:-0}" 0 1 2; then
21	# Usage:
22	#
23	# ecpu_check array_of_cpu_flags
24	#
25	# array_of_cpu_flags - An array of cpu flags to check against USE flags
26	#
27	# Checks user USE related cpu flags against /proc/cpuinfo. If user enables a
28	# cpu flag that is not supported in their processor flags, it will warn the
29	# user if CROSSCOMPILE is not set to 1 ( because cross compile users are
30	# obviously using different cpu flags than their own cpu ). Examples:
31	#
32	# CPU_FLAGS=(mmx mmx2 sse sse2)
33	# ecpu_check CPU_FLAGS
34	# Chris White <chriswhite@gentoo.org> (03 Feb 2005)
35		23
36	ecpu_check() {	24	# @FUNCTION: epause
37	# Think about changing below to: if [ "${CROSSCOMPILE}" -ne 1 -a -e "/proc/cpuinfo" ]	25	# @USAGE: [seconds]
38	# and dropping the else if you do not plan on adding anything to that	26	# @DESCRIPTION:
39	# empty block ....	27	# Sleep for the specified number of seconds (default of 5 seconds). Useful when
40	# PS: also try to add some quoting, and consider rather using ${foo} than $foo ...	28	# printing a message the user should probably be reading and often used in
41	if [ "${CROSSCOMPILE}" != "1" -a -e "/proc/cpuinfo" ]	29	# conjunction with the ebeep function. If the EPAUSE_IGNORE env var is set,
42	then	30	# don't wait at all. Defined in EAPIs 0 1 and 2.
43	CPU_FLAGS=${1}
44	USER_CPU=`grep "flags" /proc/cpuinfo`
45
46	for flags in `seq 1 ${#CPU_FLAGS[@]}`
47	do
48	if has ${CPU_FLAGS[${flags} - 1]} ${USER_CPU} && ! has ${CPU_FLAGS[${flags} - 1]} ${USE}
49	then
50	ewarn "Your system is ${CPU_FLAGS[${flags} - 1]} capable but you don't have it enabled!"
51	ewarn "You might be cross compiling (in this case set CROSSCOMPILE to 1 to disable this warning."
52	fi
53
54	if ! has ${CPU_FLAGS[${flags} - 1]} ${USER_CPU} && has ${CPU_FLAGS[${flags} -1]} ${USE}
55	then
56	ewarn "You have ${CPU_FLAGS[${flags} - 1]} support enabled but your processor doesn't"
57	ewarn "Seem to support it! You might be cross compiling or do not have /proc filesystem"
58	ewarn "enabled. If either is the case, set CROSSCOMPILE to 1 to disable this warning."
59	fi
60	done
61	fi
62	}
63
64	# Wait for the supplied number of seconds. If no argument is supplied, defaults
65	# to five seconds. If the EPAUSE_IGNORE env var is set, don't wait. If we're not
66	# outputting to a terminal, don't wait. For compatability purposes, the argument
67	# must be an integer greater than zero.
68	# Bug 62950, Ciaran McCreesh <ciaranm@gentoo.org> (05 Sep 2004)
69	epause() {	31	epause() {
70	if [ -z "$EPAUSE_IGNORE" ] && [ -t 1 ] ; then	32	[[ -z ${EPAUSE_IGNORE} ]] && sleep ${1:-5}
71	sleep ${1:-5}
72	fi
73	}	33	}
74		34
75	# Beep the specified number of times (defaults to five). If our output	35	# @FUNCTION: ebeep
76	# is not a terminal, don't beep. If the EBEEP_IGNORE env var is set,	36	# @USAGE: [number of beeps]
77	# don't beep.	37	# @DESCRIPTION:
78	# Bug 62950, Ciaran McCreesh <ciaranm@gentoo.org> (05 Sep 2004)	38	# Issue the specified number of beeps (default of 5 beeps). Useful when
		39	# printing a message the user should probably be reading and often used in
		40	# conjunction with the epause function. If the EBEEP_IGNORE env var is set,
		41	# don't beep at all. Defined in EAPIs 0 1 and 2.
79	ebeep() {	42	ebeep() {
80	local n	43	local n
81	if [ -z "$EBEEP_IGNORE" ] && [ -t 1 ] ; then	44	if [[ -z ${EBEEP_IGNORE} ]] ; then
82	for ((n=1 ; n <= ${1:-5} ; n++)) ; do	45	for ((n=1 ; n <= ${1:-5} ; n++)) ; do
83	echo -ne "\a"	46	echo -ne "\a"
84	sleep 0.1 &>/dev/null ; sleep 0,1 &>/dev/null	47	sleep 0.1 &>/dev/null ; sleep 0,1 &>/dev/null
85	echo -ne "\a"	48	echo -ne "\a"
86	sleep 1	49	sleep 1
87	done	50	done
88	fi	51	fi
89	}	52	}
90		53
91	# This function generate linker scripts in /usr/lib for dynamic	54	else
92	# libs in /lib. This is to fix linking problems when you have
93	# the .so in /lib, and the .a in /usr/lib. What happens is that
94	# in some cases when linking dynamic, the .a in /usr/lib is used
95	# instead of the .so in /lib due to gcc/libtool tweaking ld's
96	# library search path. This cause many builds to fail.
97	# See bug #4411 for more info.
98	#
99	# To use, simply call:
100	#
101	# gen_usr_ldscript libfoo.so
102	#
103	# Note that you should in general use the unversioned name of
104	# the library, as ldconfig should usually update it correctly
105	# to point to the latest version of the library present.
106	#
107	# <azarah@gentoo.org> (26 Oct 2002)
108	#
109	gen_usr_ldscript() {
110	local libdir="$(get_libdir)"
111	# Just make sure it exists
112	dodir /usr/${libdir}
113		55
114	for lib in "${@}" ; do	56	ebeep() {
115	cat > "${D}/usr/${libdir}/${lib}" <<-END_LDSCRIPT	57	ewarn "QA Notice: ebeep is not defined in EAPI=${EAPI}, please file a bug at http://bugs.gentoo.org"
116	/* GNU ld script
117	Since Gentoo has critical dynamic libraries
118	in /lib, and the static versions in /usr/lib,
119	we need to have a "fake" dynamic lib in /usr/lib,
120	otherwise we run into linking problems.
121
122	See bug http://bugs.gentoo.org/4411 for more info.
123	*/
124	GROUP ( /${libdir}/${lib} )
125	END_LDSCRIPT
126	fperms a+x "/usr/${libdir}/${lib}"
127	done
128	}	58	}
129		59
130	# Simple function to draw a line consisting of '=' the same length as $*	60	epause() {
131	#	61	ewarn "QA Notice: epause is not defined in EAPI=${EAPI}, please file a bug at http://bugs.gentoo.org"
132	# <azarah@gentoo.org> (11 Nov 2002)	62	}
133	#
134	draw_line() {
135	local i=0
136	local str_length=""
137		63
138	# Handle calls that do not have args, or wc not being installed ...	64	fi
139	if [ -z "$1" -o ! -x "$(which wc 2>/dev/null)" ]	65
140	then	66	# @FUNCTION: eqawarn
141	echo "==============================================================="	67	# @USAGE: [message]
		68	# @DESCRIPTION:
		69	# Proxy to einfo for package managers that don't provide eqawarn and use the PM
		70	# implementation if available.
		71	if ! declare -F eqawarn >/dev/null ; then
		72	eqawarn() {
		73	einfo "$@"
		74	}
		75	fi
		76
		77	# @FUNCTION: ecvs_clean
		78	# @USAGE: [list of dirs]
		79	# @DESCRIPTION:
		80	# Remove CVS directories recursiveley. Useful when a source tarball contains
		81	# internal CVS directories. Defaults to $PWD.
		82	ecvs_clean() {
		83	[[ -z $* ]] && set -- .
		84	find "$@" -type d -name 'CVS' -prune -print0 \| xargs -0 rm -rf
		85	find "$@" -type f -name '.cvs*' -print0 \| xargs -0 rm -rf
		86	}
		87
		88	# @FUNCTION: esvn_clean
		89	# @USAGE: [list of dirs]
		90	# @DESCRIPTION:
		91	# Remove .svn directories recursiveley. Useful when a source tarball contains
		92	# internal Subversion directories. Defaults to $PWD.
		93	esvn_clean() {
		94	[[ -z $* ]] && set -- .
		95	find "$@" -type d -name '.svn' -prune -print0 \| xargs -0 rm -rf
		96	}
		97
		98	# @FUNCTION: eshopts_push
		99	# @USAGE: [options to `set` or `shopt`]
		100	# @DESCRIPTION:
		101	# Often times code will want to enable a shell option to change code behavior.
		102	# Since changing shell options can easily break other pieces of code (which
		103	# assume the default state), eshopts_push is used to (1) push the current shell
		104	# options onto a stack and (2) pass the specified arguments to set.
		105	#
		106	# If the first argument is '-s' or '-u', we assume you want to call `shopt`
		107	# rather than `set` as there are some options only available via that.
		108	#
		109	# A common example is to disable shell globbing so that special meaning/care
		110	# may be used with variables/arguments to custom functions. That would be:
		111	# @CODE
		112	# eshopts_push -o noglob
		113	# for x in ${foo} ; do
		114	# if ...some check... ; then
		115	# eshopts_pop
142	return 0	116	# return 0
143	fi	117	# fi
144
145	# Get the length of $*
146	str_length="$(echo -n "$*" \| wc -m)"
147
148	while [ "$i" -lt "${str_length}" ]
149	do
150	echo -n "="
151
152	i=$((i + 1))
153	done	118	# done
154		119	# eshopts_pop
155	echo	120	# @CODE
156		121	eshopts_push() {
157	return 0	122	# have to assume __ESHOPTS_SAVE__ isn't screwed with
		123	# as a `declare -a` here will reset its value
		124	local i=${#__ESHOPTS_SAVE__[@]}
		125	if [[ $1 == -[su] ]] ; then
		126	__ESHOPTS_SAVE__[$i]=$(shopt -p)
		127	[[ $# -eq 0 ]] && return 0
		128	shopt "$@" \|\| die "eshopts_push: bad options to shopt: $*"
		129	else
		130	__ESHOPTS_SAVE__[$i]=$-
		131	[[ $# -eq 0 ]] && return 0
		132	set "$@" \|\| die "eshopts_push: bad options to set: $*"
		133	fi
158	}	134	}
159		135
160	# Default directory where patches are located	136	# @FUNCTION: eshopts_pop
		137	# @USAGE:
		138	# @DESCRIPTION:
		139	# Restore the shell options to the state saved with the corresponding
		140	# eshopts_push call. See that function for more details.
		141	eshopts_pop() {
		142	[[ $# -ne 0 ]] && die "eshopts_pop takes no arguments"
		143	local i=$(( ${#__ESHOPTS_SAVE__[@]} - 1 ))
		144	[[ ${i} -eq -1 ]] && die "eshopts_{push,pop}: unbalanced pair"
		145	local s=${__ESHOPTS_SAVE__[$i]}
		146	unset __ESHOPTS_SAVE__[$i]
		147	if [[ ${s} == "shopt -"* ]] ; then
		148	eval "${s}" \|\| die "eshopts_pop: sanity: invalid shopt options: ${s}"
		149	else
		150	set +$- \|\| die "eshopts_pop: sanity: invalid shell settings: $-"
		151	set -${s} \|\| die "eshopts_pop: sanity: unable to restore saved shell settings: ${s}"
		152	fi
		153	}
		154
		155	# @VARIABLE: EPATCH_SOURCE
		156	# @DESCRIPTION:
		157	# Default directory to search for patches.
161	EPATCH_SOURCE="${WORKDIR}/patch"	158	EPATCH_SOURCE="${WORKDIR}/patch"
162	# Default extension for patches	159	# @VARIABLE: EPATCH_SUFFIX
		160	# @DESCRIPTION:
		161	# Default extension for patches (do not prefix the period yourself).
163	EPATCH_SUFFIX="patch.bz2"	162	EPATCH_SUFFIX="patch.bz2"
		163	# @VARIABLE: EPATCH_OPTS
		164	# @DESCRIPTION:
164	# Default options for patch	165	# Default options for patch:
		166	# @CODE
165	# Set -g0 to keep RCS, ClearCase, Perforce and SCCS happy. Bug #24571	167	# -g0 - keep RCS, ClearCase, Perforce and SCCS happy #24571
166	EPATCH_OPTS="-g0"	168	# --no-backup-if-mismatch - do not leave .orig files behind
		169	# -E - automatically remove empty files
		170	# @CODE
		171	EPATCH_OPTS="-g0 -E --no-backup-if-mismatch"
		172	# @VARIABLE: EPATCH_EXCLUDE
		173	# @DESCRIPTION:
167	# List of patches not to apply. Not this is only file names,	174	# List of patches not to apply. Note this is only file names,
168	# and not the full path ..	175	# and not the full path. Globs accepted.
169	EPATCH_EXCLUDE=""	176	EPATCH_EXCLUDE=""
		177	# @VARIABLE: EPATCH_SINGLE_MSG
		178	# @DESCRIPTION:
170	# Change the printed message for a single patch.	179	# Change the printed message for a single patch.
171	EPATCH_SINGLE_MSG=""	180	EPATCH_SINGLE_MSG=""
172	# Force applying bulk patches even if not following the style:	181	# @VARIABLE: EPATCH_MULTI_MSG
173	#	182	# @DESCRIPTION:
174	# ??_${ARCH}_foo.${EPATCH_SUFFIX}	183	# Change the printed message for multiple patches.
175	#	184	EPATCH_MULTI_MSG="Applying various patches (bugfixes/updates) ..."
		185	# @VARIABLE: EPATCH_FORCE
		186	# @DESCRIPTION:
		187	# Only require patches to match EPATCH_SUFFIX rather than the extended
		188	# arch naming style.
176	EPATCH_FORCE="no"	189	EPATCH_FORCE="no"
177		190
178	# This function is for bulk patching, or in theory for just one	191	# @FUNCTION: epatch
179	# or two patches.	192	# @USAGE: [patches] [dirs of patches]
		193	# @DESCRIPTION:
		194	# epatch is designed to greatly simplify the application of patches. It can
		195	# process patch files directly, or directories of patches. The patches may be
		196	# compressed (bzip/gzip/etc...) or plain text. You generally need not specify
		197	# the -p option as epatch will automatically attempt -p0 to -p5 until things
		198	# apply successfully.
180	#	199	#
181	# It should work with .bz2, .gz, .zip and plain text patches.	200	# If you do not specify any options, then epatch will default to the directory
182	# Currently all patches should be the same format.	201	# specified by EPATCH_SOURCE.
183	#	202	#
184	# You do not have to specify '-p' option to patch, as it will	203	# When processing directories, epatch will apply all patches that match:
185	# try with -p0 to -p5 until it succeed, or fail at -p5.	204	# @CODE
186	#	205	# ${EPATCH_FORCE} == "yes"
187	# Above EPATCH_* variables can be used to control various defaults,
188	# bug they should be left as is to ensure an ebuild can rely on
189	# them for.
190	#
191	# Patches are applied in current directory.
192	#
193	# Bulk Patches should preferibly have the form of:
194	#
195	# ??_${ARCH}_foo.${EPATCH_SUFFIX}	206	# ??_${ARCH}_foo.${EPATCH_SUFFIX}
		207	# else
		208	# *.${EPATCH_SUFFIX}
		209	# @CODE
		210	# The leading ?? are typically numbers used to force consistent patch ordering.
		211	# The arch field is used to apply patches only for the host architecture with
		212	# the special value of "all" means apply for everyone. Note that using values
		213	# other than "all" is highly discouraged -- you should apply patches all the
		214	# time and let architecture details be detected at configure/compile time.
196	#	215	#
197	# For example:	216	# If EPATCH_SUFFIX is empty, then no period before it is implied when searching
		217	# for patches to apply.
198	#	218	#
199	# 01_all_misc-fix.patch.bz2	219	# Refer to the other EPATCH_xxx variables for more customization of behavior.
200	# 02_sparc_another-fix.patch.bz2
201	#
202	# This ensures that there are a set order, and you can have ARCH
203	# specific patches.
204	#
205	# If you however give an argument to epatch(), it will treat it as a
206	# single patch that need to be applied if its a file. If on the other
207	# hand its a directory, it will set EPATCH_SOURCE to this.
208	#
209	# <azarah@gentoo.org> (10 Nov 2002)
210	#
211	epatch() {	220	epatch() {
212	local PIPE_CMD=""	221	_epatch_draw_line() {
213	local STDERR_TARGET="${T}/$$.out"	222	# create a line of same length as input string
214	local PATCH_TARGET="${T}/$$.patch"	223	[[ -z $1 ]] && set "$(printf "%65s" '')"
215	local PATCH_SUFFIX=""	224	echo "${1//?/=}"
216	local SINGLE_PATCH="no"	225	}
217	local x=""
218		226
219	if [ "$#" -gt 1 ]	227	unset P4CONFIG P4PORT P4USER # keep perforce at bay #56402
220	then	228
		229	# Let the rest of the code process one user arg at a time --
		230	# each arg may expand into multiple patches, and each arg may
		231	# need to start off with the default global EPATCH_xxx values
		232	if [[ $# -gt 1 ]] ; then
221	local m=""	233	local m
222	einfo "${#} patches to apply ..."
223	for m in "$@" ; do	234	for m in "$@" ; do
224	epatch "${m}"	235	epatch "${m}"
225	done	236	done
226	return 0	237	return 0
227	fi	238	fi
228		239
229	if [ -n "$1" -a -f "$1" ]	240	local SINGLE_PATCH="no"
230	then	241	# no args means process ${EPATCH_SOURCE}
		242	[[ $# -eq 0 ]] && set -- "${EPATCH_SOURCE}"
		243
		244	if [[ -f $1 ]] ; then
231	SINGLE_PATCH="yes"	245	SINGLE_PATCH="yes"
232		246	set -- "$1"
233	local EPATCH_SOURCE="$1"	247	# Use the suffix from the single patch (localize it); the code
		248	# below will find the suffix for us
234	local EPATCH_SUFFIX="${1##*\.}"	249	local EPATCH_SUFFIX=$1
235		250
236	elif [ -n "$1" -a -d "$1" ]	251	elif [[ -d $1 ]] ; then
237	then	252	# Some people like to make dirs of patches w/out suffixes (vim)
238	# Allow no extension if EPATCH_FORCE=yes ... used by vim for example ...	253	set -- "$1"/*${EPATCH_SUFFIX:+."${EPATCH_SUFFIX}"}
239	if [ "${EPATCH_FORCE}" = "yes" ] && [ -z "${EPATCH_SUFFIX}" ]	254
		255	else
		256	# sanity check ... if it isn't a dir or file, wtf man ?
		257	[[ $# -ne 0 ]] && EPATCH_SOURCE=$1
		258	echo
		259	eerror "Cannot find \$EPATCH_SOURCE! Value for \$EPATCH_SOURCE is:"
		260	eerror
		261	eerror " ${EPATCH_SOURCE}"
		262	eerror " ( ${EPATCH_SOURCE##*/} )"
		263	echo
		264	die "Cannot find \$EPATCH_SOURCE!"
		265	fi
		266
		267	local PIPE_CMD
		268	case ${EPATCH_SUFFIX##*\.} in
		269	xz) PIPE_CMD="xz -dc" ;;
		270	lzma) PIPE_CMD="lzma -dc" ;;
		271	bz2) PIPE_CMD="bzip2 -dc" ;;
		272	gz\|Z\|z) PIPE_CMD="gzip -dc" ;;
		273	ZIP\|zip) PIPE_CMD="unzip -p" ;;
		274	*) ;;
		275	esac
		276
		277	[[ ${SINGLE_PATCH} == "no" ]] && einfo "${EPATCH_MULTI_MSG}"
		278
		279	local x
		280	for x in "$@" ; do
		281	# If the patch dir given contains subdirs, or our EPATCH_SUFFIX
		282	# didn't match anything, ignore continue on
		283	[[ ! -f ${x} ]] && continue
		284
		285	local patchname=${x##*/}
		286
		287	# Apply single patches, or forced sets of patches, or
		288	# patches with ARCH dependant names.
		289	# ???_arch_foo.patch
		290	# Else, skip this input altogether
		291	local a=${patchname#*_} # strip the ???_
		292	a=${a%%_*} # strip the _foo.patch
		293	if ! [[ ${SINGLE_PATCH} == "yes" \|\| \
		294	${EPATCH_FORCE} == "yes" \|\| \
		295	${a} == all \|\| \
		296	${a} == ${ARCH} ]]
240	then	297	then
241	local EPATCH_SOURCE="$1/*"	298	continue
		299	fi
		300
		301	# Let people filter things dynamically
		302	if [[ -n ${EPATCH_EXCLUDE} ]] ; then
		303	# let people use globs in the exclude
		304	eshopts_push -o noglob
		305
		306	local ex
		307	for ex in ${EPATCH_EXCLUDE} ; do
		308	if [[ ${patchname} == ${ex} ]] ; then
		309	eshopts_pop
		310	continue 2
		311	fi
		312	done
		313
		314	eshopts_pop
		315	fi
		316
		317	if [[ ${SINGLE_PATCH} == "yes" ]] ; then
		318	if [[ -n ${EPATCH_SINGLE_MSG} ]] ; then
		319	einfo "${EPATCH_SINGLE_MSG}"
		320	else
		321	einfo "Applying ${patchname} ..."
		322	fi
242	else	323	else
243	local EPATCH_SOURCE="$1/*.${EPATCH_SUFFIX}"	324	einfo " ${patchname} ..."
244	fi	325	fi
245	else	326
246	if [ ! -d ${EPATCH_SOURCE} ] \|\| [ -n "$1" ]	327	# most of the time, there will only be one run per unique name,
247	then	328	# but if there are more, make sure we get unique log filenames
248	if [ -n "$1" -a "${EPATCH_SOURCE}" = "${WORKDIR}/patch" ]	329	local STDERR_TARGET="${T}/${patchname}.out"
249	then	330	if [[ -e ${STDERR_TARGET} ]] ; then
250	EPATCH_SOURCE="$1"	331	STDERR_TARGET="${T}/${patchname}-$$.out"
		332	fi
		333
		334	printf "*** %s ***\n\n" "${patchname}" > "${STDERR_TARGET}"
		335
		336	# Decompress the patch if need be
		337	local count=0
		338	local PATCH_TARGET
		339	if [[ -n ${PIPE_CMD} ]] ; then
		340	PATCH_TARGET="${T}/$$.patch"
		341	echo "PIPE_COMMAND: ${PIPE_CMD} ${x} > ${PATCH_TARGET}" >> "${STDERR_TARGET}"
		342
		343	if ! (${PIPE_CMD} "${x}" > "${PATCH_TARGET}") >> "${STDERR_TARGET}" 2>&1 ; then
		344	echo
		345	eerror "Could not extract patch!"
		346	#die "Could not extract patch!"
		347	count=5
		348	break
251	fi	349	fi
		350	else
		351	PATCH_TARGET=${x}
		352	fi
252		353
		354	# Check for absolute paths in patches. If sandbox is disabled,
		355	# people could (accidently) patch files in the root filesystem.
		356	# Or trigger other unpleasantries #237667. So disallow -p0 on
		357	# such patches.
		358	local abs_paths=$(egrep -n '^[-+]{3} /' "${PATCH_TARGET}" \| awk '$2 != "/dev/null" { print }')
		359	if [[ -n ${abs_paths} ]] ; then
		360	count=1
		361	printf "NOTE: skipping -p0 due to absolute paths in patch:\n%s\n" "${abs_paths}" >> "${STDERR_TARGET}"
		362	fi
		363
		364	# Dynamically detect the correct -p# ... i'm lazy, so shoot me :/
		365	while [[ ${count} -lt 5 ]] ; do
		366	# Generate some useful debug info ...
		367	(
		368	_epatch_draw_line "*** ${patchname} ***"
253	echo	369	echo
254	eerror "Cannot find \$EPATCH_SOURCE! Value for \$EPATCH_SOURCE is:"	370	echo "PATCH COMMAND: patch -p${count} ${EPATCH_OPTS} < '${PATCH_TARGET}'"
		371	echo
		372	_epatch_draw_line "*** ${patchname} ***"
		373	) >> "${STDERR_TARGET}"
		374
		375	if (patch -p${count} ${EPATCH_OPTS} --dry-run -f < "${PATCH_TARGET}") >> "${STDERR_TARGET}" 2>&1 ; then
		376	(
		377	_epatch_draw_line "*** ${patchname} ***"
		378	echo
		379	echo "ACTUALLY APPLYING ${patchname} ..."
		380	echo
		381	_epatch_draw_line "*** ${patchname} ***"
		382	patch -p${count} ${EPATCH_OPTS} < "${PATCH_TARGET}" 2>&1
		383	) >> "${STDERR_TARGET}"
		384
		385	if [ $? -ne 0 ] ; then
		386	echo
		387	eerror "A dry-run of patch command succeeded, but actually"
		388	eerror "applying the patch failed!"
		389	#die "Real world sux compared to the dreamworld!"
		390	count=5
		391	fi
		392	break
		393	fi
		394
		395	: $(( count++ ))
		396	done
		397
		398	# if we had to decompress the patch, delete the temp one
		399	if [[ -n ${PIPE_CMD} ]] ; then
		400	rm -f "${PATCH_TARGET}"
		401	fi
		402
		403	if [[ ${count} -ge 5 ]] ; then
		404	echo
		405	eerror "Failed Patch: ${patchname} !"
		406	eerror " ( ${PATCH_TARGET} )"
255	eerror	407	eerror
256	eerror " ${EPATCH_SOURCE}"	408	eerror "Include in your bugreport the contents of:"
257	eerror " ( ${EPATCH_SOURCE##*/} )"	409	eerror
		410	eerror " ${STDERR_TARGET}"
258	echo	411	echo
259	die "Cannot find \$EPATCH_SOURCE!"
260	fi
261
262	local EPATCH_SOURCE="${EPATCH_SOURCE}/*.${EPATCH_SUFFIX}"
263	fi
264
265	case ${EPATCH_SUFFIX##*\.} in
266	bz2)
267	PIPE_CMD="bzip2 -dc"
268	PATCH_SUFFIX="bz2"
269	;;
270	gz\|Z\|z)
271	PIPE_CMD="gzip -dc"
272	PATCH_SUFFIX="gz"
273	;;
274	ZIP\|zip)
275	PIPE_CMD="unzip -p"
276	PATCH_SUFFIX="zip"
277	;;
278	*)
279	PIPE_CMD="cat"
280	PATCH_SUFFIX="patch"
281	;;
282	esac
283
284	if [ "${SINGLE_PATCH}" = "no" ]
285	then
286	einfo "Applying various patches (bugfixes/updates) ..."
287	fi
288	for x in ${EPATCH_SOURCE}
289	do
290	# New ARCH dependant patch naming scheme ...
291	#
292	# ???_arch_foo.patch
293	#
294	if [ -f ${x} ] && \
295	([ "${SINGLE_PATCH}" = "yes" -o "${x/_all_}" != "${x}" -o "`eval echo \$\{x/_${ARCH}_\}`" != "${x}" ] \|\| \
296	[ "${EPATCH_FORCE}" = "yes" ])
297	then
298	local count=0
299	local popts="${EPATCH_OPTS}"
300	local patchname=${x##*/}
301
302	if [ -n "${EPATCH_EXCLUDE}" ]
303	then
304	if [ "${EPATCH_EXCLUDE/${patchname}}" != "${EPATCH_EXCLUDE}" ]
305	then
306	continue
307	fi
308	fi
309
310	if [ "${SINGLE_PATCH}" = "yes" ]
311	then
312	if [ -n "${EPATCH_SINGLE_MSG}" ]
313	then
314	einfo "${EPATCH_SINGLE_MSG}"
315	else
316	einfo "Applying ${patchname} ..."
317	fi
318	else
319	einfo " ${patchname} ..."
320	fi
321
322	echo "*** ${patchname} **" > ${STDERR_TARGET%/}/${patchname}-${STDERR_TARGET##*/}
323	echo >> ${STDERR_TARGET%/}/${patchname}-${STDERR_TARGET##/}
324
325	# Allow for prefix to differ ... im lazy, so shoot me :/
326	while [ "${count}" -lt 5 ]
327	do
328	# Generate some useful debug info ...
329	draw_line "*** ${patchname} **" >> ${STDERR_TARGET%/}/${patchname}-${STDERR_TARGET##*/}
330	echo >> ${STDERR_TARGET%/}/${patchname}-${STDERR_TARGET##/}
331
332	if [ "${PATCH_SUFFIX}" != "patch" ]
333	then
334	echo -n "PIPE_COMMAND: " >> ${STDERR_TARGET%/}/${patchname}-${STDERR_TARGET##/}
335	echo "${PIPE_CMD} ${x} > ${PATCH_TARGET}" >> ${STDERR_TARGET%/}/${patchname}-${STDERR_TARGET##/}
336	else
337	PATCH_TARGET="${x}"
338	fi
339
340	echo -n "PATCH COMMAND: " >> ${STDERR_TARGET%/}/${patchname}-${STDERR_TARGET##/}
341	echo "patch -p${count} ${popts} < ${PATCH_TARGET}" >> ${STDERR_TARGET%/}/${patchname}-${STDERR_TARGET##/}
342
343	echo >> ${STDERR_TARGET%/}/${patchname}-${STDERR_TARGET##/}
344	draw_line "*** ${patchname} **" >> ${STDERR_TARGET%/}/${patchname}-${STDERR_TARGET##*/}
345
346	if [ "${PATCH_SUFFIX}" != "patch" ]
347	then
348	if ! (${PIPE_CMD} ${x} > ${PATCH_TARGET}) >> ${STDERR_TARGET%/}/${patchname}-${STDERR_TARGET##/} 2>&1
349	then
350	echo
351	eerror "Could not extract patch!"
352	#die "Could not extract patch!"
353	count=5
354	break
355	fi
356	fi
357
358	if (cat ${PATCH_TARGET} \| patch -p${count} ${popts} --dry-run -f) >> ${STDERR_TARGET%/}/${patchname}-${STDERR_TARGET##/} 2>&1
359	then
360	draw_line "*** ${patchname} **" > ${STDERR_TARGET%/}/${patchname}-${STDERR_TARGET##*/}.real
361	echo >> ${STDERR_TARGET%/}/${patchname}-${STDERR_TARGET##/}.real
362	echo "ACTUALLY APPLYING ${patchname} ..." >> ${STDERR_TARGET%/}/${patchname}-${STDERR_TARGET##/}.real
363	echo >> ${STDERR_TARGET%/}/${patchname}-${STDERR_TARGET##/}.real
364	draw_line "*** ${patchname} **" >> ${STDERR_TARGET%/}/${patchname}-${STDERR_TARGET##*/}.real
365
366	cat ${PATCH_TARGET} \| patch -p${count} ${popts} >> ${STDERR_TARGET%/}/${patchname}-${STDERR_TARGET##/}.real 2>&1
367
368	if [ "$?" -ne 0 ]
369	then
370	cat ${STDERR_TARGET%/}/${patchname}-${STDERR_TARGET##/}.real >> ${STDERR_TARGET%/}/${patchname}-${STDERR_TARGET##/}
371	echo
372	eerror "A dry-run of patch command succeeded, but actually"
373	eerror "applying the patch failed!"
374	#die "Real world sux compared to the dreamworld!"
375	count=5
376	fi
377
378	rm -f ${STDERR_TARGET%/}/${patchname}-${STDERR_TARGET##/}.real
379
380	break
381	fi
382
383	count=$((count + 1))
384	done
385
386	if [ "${PATCH_SUFFIX}" != "patch" ]
387	then
388	rm -f ${PATCH_TARGET}
389	fi
390
391	if [ "${count}" -eq 5 ]
392	then
393	echo
394	eerror "Failed Patch: ${patchname} !"
395	eerror " ( ${PATCH_TARGET} )"
396	eerror
397	eerror "Include in your bugreport the contents of:"
398	eerror
399	eerror " ${STDERR_TARGET%/}/${patchname}-${STDERR_TARGET##/}"
400	echo
401	die "Failed Patch: ${patchname}!"	412	die "Failed Patch: ${patchname}!"
402	fi	413	fi
403		414
404	rm -f ${STDERR_TARGET%/}/${patchname}-${STDERR_TARGET##/}	415	# if everything worked, delete the patch log
405		416	rm -f "${STDERR_TARGET}"
406	eend 0	417	eend 0
407	fi
408	done	418	done
409	if [ "${SINGLE_PATCH}" = "no" ]
410	then
411	einfo "Done with patching"
412	fi
413	}
414		419
415	# This function return true if we are using the NPTL pthreads	420	[[ ${SINGLE_PATCH} == "no" ]] && einfo "Done with patching"
416	# implementation.	421	: # everything worked
417	#	422	}
418	# <azarah@gentoo.org> (06 March 2003)	423	epatch_user() {
419	#	424	[[ $# -ne 0 ]] && die "epatch_user takes no options"
420	have_NPTL() {
421	cat > ${T}/test-nptl.c <<-"END"
422	#define _XOPEN_SOURCE
423	#include <unistd.h>
424	#include <stdio.h>
425		425
426	int main()	426	# don't clobber any EPATCH vars that the parent might want
427	{	427	local EPATCH_SOURCE check base=${PORTAGE_CONFIGROOT%/}/etc/portage/patches
428	char buf[255];	428	for check in {${CATEGORY}/${PF},${CATEGORY}/${P},${CATEGORY}/${PN}}; do
429	char *str = buf;	429	EPATCH_SOURCE=${base}/${CTARGET}/${check}
430		430	[[ -r ${EPATCH_SOURCE} ]] \|\| EPATCH_SOURCE=${base}/${CHOST}/${check}
431	confstr(_CS_GNU_LIBPTHREAD_VERSION, str, 255);	431	[[ -r ${EPATCH_SOURCE} ]] \|\| EPATCH_SOURCE=${base}/${check}
432	if (NULL != str) {	432	if [[ -d ${EPATCH_SOURCE} ]] ; then
433	printf("%s\n", str);	433	EPATCH_SOURCE=${EPATCH_SOURCE} \
434	if (NULL != strstr(str, "NPTL"))	434	EPATCH_SUFFIX="patch" \
435	return 0;	435	EPATCH_FORCE="yes" \
436	}	436	EPATCH_MULTI_MSG="Applying user patches from ${EPATCH_SOURCE} ..." \
437		437	epatch
438	return 1;
439	}
440	END
441
442	einfon "Checking for _CS_GNU_LIBPTHREAD_VERSION support in glibc ..."
443	if gcc -o ${T}/nptl ${T}/test-nptl.c &> /dev/null
444	then
445	echo "yes"
446	einfon "Checking what PTHREADS implementation we have ..."
447	if ${T}/nptl
448	then
449	return 0	438	return 0
450	else
451	return 1
452	fi
453	else
454	echo "no"
455	fi	439	fi
456		440	done
457	return 1	441	return 1
458	}	442	}
459		443
460	# This function check how many cpu's are present, and then set	444	# @FUNCTION: emktemp
461	# -j in MAKEOPTS accordingly.	445	# @USAGE: [temp dir]
462	#	446	# @DESCRIPTION:
463	# Thanks to nall <nall@gentoo.org> for this.
464	#
465	get_number_of_jobs() {
466	local jobs=0
467
468	if [ ! -r /proc/cpuinfo ]
469	then
470	return 1
471	fi
472
473	# This bit is from H?kan Wessberg <nacka-gentoo@refug.org>, bug #13565.
474	if [ "`egrep "^[[:space:]]*MAKEOPTS=" /etc/make.conf \| wc -l`" -gt 0 ]
475	then
476	ADMINOPTS="`egrep "^[[:space:]]*MAKEOPTS=" /etc/make.conf \| cut -d= -f2 \| sed 's/\"//g'`"
477	ADMINPARAM="`echo ${ADMINOPTS} \| gawk '{match($0, /-j [0-9]/, opt); print opt[0]}'`"
478	ADMINPARAM="${ADMINPARAM/-j}"
479	fi
480
481	export MAKEOPTS="`echo ${MAKEOPTS} \| sed -e 's:-j [0-9]::g'`"
482
483	if [ "${ARCH}" = "amd64" -o "${ARCH}" = "x86" -o "${ARCH}" = "hppa" -o \
484	"${ARCH}" = "arm" -o "${ARCH}" = "mips" -o "${ARCH}" = "ia64" ]
485	then
486	# these archs will always have "[Pp]rocessor"
487	jobs="$((`grep -c ^[Pp]rocessor /proc/cpuinfo` * 2))"
488
489	elif [ "${ARCH}" = "sparc" -o "${ARCH}" = "sparc64" ]
490	then
491	# sparc always has "ncpus active"
492	jobs="$((`grep "^ncpus active" /proc/cpuinfo \| sed -e "s/^.: //"` 2))"
493
494	elif [ "${ARCH}" = "alpha" ]
495	then
496	# alpha has "cpus active", but only when compiled with SMP
497	if [ "`grep -c "^cpus active" /proc/cpuinfo`" -eq 1 ]
498	then
499	jobs="$((`grep "^cpus active" /proc/cpuinfo \| sed -e "s/^.: //"` 2))"
500	else
501	jobs=2
502	fi
503
504	elif [ "${ARCH}" = "ppc" -o "${ARCH}" = "ppc64" ]
505	then
506	# ppc has "processor", but only when compiled with SMP
507	if [ "`grep -c "^processor" /proc/cpuinfo`" -eq 1 ]
508	then
509	jobs="$((`grep -c ^processor /proc/cpuinfo` * 2))"
510	else
511	jobs=2
512	fi
513	elif [ "${ARCH}" = "s390" ]
514	then
515	# s390 has "# processors : "
516	jobs="$((`grep "^\# processors" /proc/cpuinfo \| sed -e "s/^.: //"` 2))"
517	else
518	jobs="$((`grep -c ^cpu /proc/cpuinfo` * 2))"
519	die "Unknown ARCH -- ${ARCH}!"
520	fi
521
522	# Make sure the number is valid ...
523	if [ "${jobs}" -lt 1 ]
524	then
525	jobs=1
526	fi
527
528	if [ -n "${ADMINPARAM}" ]
529	then
530	if [ "${jobs}" -gt "${ADMINPARAM}" ]
531	then
532	einfo "Setting make jobs to \"-j${ADMINPARAM}\" to ensure successful merge ..."
533	export MAKEOPTS="${MAKEOPTS} -j${ADMINPARAM}"
534	else
535	einfo "Setting make jobs to \"-j${jobs}\" to ensure successful merge ..."
536	export MAKEOPTS="${MAKEOPTS} -j${jobs}"
537	fi
538	fi
539	}
540
541	# Cheap replacement for when debianutils (and thus mktemp)	447	# Cheap replacement for when debianutils (and thus mktemp)
542	# does not exist on the users system	448	# does not exist on the users system.
543	# vapier@gentoo.org
544	#
545	# Takes just 1 optional parameter (the directory to create tmpfile in)
546	emktemp() {	449	emktemp() {
547	local exe="touch"	450	local exe="touch"
548	[ "$1" == "-d" ] && exe="mkdir" && shift	451	[[ $1 == -d ]] && exe="mkdir" && shift
549	local topdir="$1"	452	local topdir=$1
550		453
551	if [ -z "${topdir}" ]	454	if [[ -z ${topdir} ]] ; then
552	then
553	[ -z "${T}" ] \	455	[[ -z ${T} ]] \
554	&& topdir="/tmp" \	456	&& topdir="/tmp" \
555	\|\| topdir="${T}"	457	\|\| topdir=${T}
556	fi	458	fi
557		459
558	if [ -z "$(type -p mktemp)" ]	460	if ! type -P mktemp > /dev/null ; then
559	then	461	# system lacks `mktemp` so we have to fake it
560	local tmp=/	462	local tmp=/
561	while [ -e "${tmp}" ] ; do	463	while [[ -e ${tmp} ]] ; do
562	tmp="${topdir}/tmp.${RANDOM}.${RANDOM}.${RANDOM}"	464	tmp=${topdir}/tmp.${RANDOM}.${RANDOM}.${RANDOM}
563	done	465	done
564	${exe} "${tmp}"	466	${exe} "${tmp}" \|\| ${exe} -p "${tmp}"
565	echo "${tmp}"	467	echo "${tmp}"
566	else	468	else
567	[ "${exe}" == "touch" ] \	469	# the args here will give slightly wierd names on BSD,
568	&& exe="-p" \	470	# but should produce a usable file on all userlands
569	\|\| exe="-d"	471	if [[ ${exe} == "touch" ]] ; then
570	mktemp ${exe} "${topdir}"	472	TMPDIR="${topdir}" mktemp -t tmp.XXXXXXXXXX
		473	else
		474	TMPDIR="${topdir}" mktemp -dt tmp.XXXXXXXXXX
571	fi	475	fi
		476	fi
572	}	477	}
573		478
		479	# @FUNCTION: egetent
		480	# @USAGE: <database> <key>
		481	# @MAINTAINER:
		482	# base-system@gentoo.org (Linux)
		483	# Joe Jezak <josejx@gmail.com> (OS X)
		484	# usata@gentoo.org (OS X)
		485	# Aaron Walker <ka0ttic@gentoo.org> (FreeBSD)
		486	# @DESCRIPTION:
574	# Small wrapper for getent (Linux), nidump (Mac OS X),	487	# Small wrapper for getent (Linux),
		488	# nidump (< Mac OS X 10.5), dscl (Mac OS X 10.5),
575	# and pw (FreeBSD) used in enewuser()/enewgroup()	489	# and pw (FreeBSD) used in enewuser()/enewgroup()
576	# Joe Jezak <josejx@gmail.com> and usata@gentoo.org
577	# FBSD stuff: Aaron Walker <ka0ttic@gentoo.org>
578	#
579	# egetent(database, key)
580	egetent() {	490	egetent() {
581	if useq ppc-macos ; then	491	case ${CHOST} in
		492	*-darwin[678])
582	case "$2" in	493	case "$2" in
583	[!0-9]) # Non numeric	494	[!0-9]) # Non numeric
584	nidump $1 . \| awk -F":" "{ if (\$1 ~ /^$2$/) {print \$0;exit;} }"	495	nidump $1 . \| awk -F":" "{ if (\$1 ~ /^$2$/) {print \$0;exit;} }"
585	;;	496	;;
586	*) # Numeric	497	*) # Numeric
587	nidump $1 . \| awk -F":" "{ if (\$3 == $2) {print \$0;exit;} }"	498	nidump $1 . \| awk -F":" "{ if (\$3 == $2) {print \$0;exit;} }"
588	;;	499	;;
589	esac	500	esac
590	elif useq x86-fbsd ; then	501	;;
591	local action	502	-darwin)
592	if [ "$1" == "passwd" ]	503	local mytype=$1
593	then	504	[[ "passwd" == $mytype ]] && mytype="Users"
594	action="user"	505	[[ "group" == $mytype ]] && mytype="Groups"
595	else	506	case "$2" in
596	action="group"	507	[!0-9]) # Non numeric
		508	dscl . -read /$mytype/$2 2>/dev/null \|grep RecordName
		509	;;
		510	*) # Numeric
		511	local mykey="UniqueID"
		512	[[ $mytype == "Groups" ]] && mykey="PrimaryGroupID"
		513	dscl . -search /$mytype $mykey $2 2>/dev/null
		514	;;
		515	esac
		516	;;
		517	-freebsd\|-dragonfly)
		518	local opts action="user"
		519	[[ $1 == "passwd" ]] \|\| action="group"
		520
		521	# lookup by uid/gid
		522	if [[ $2 == [[:digit:]]* ]] ; then
		523	[[ ${action} == "user" ]] && opts="-u" \|\| opts="-g"
597	fi	524	fi
		525
598	pw show "${action}" "$2" -q	526	pw show ${action} ${opts} "$2" -q
599	else	527	;;
		528	-netbsd\|-openbsd)
		529	grep "$2:\*:" /etc/$1
		530	;;
		531	*)
600	which nscd >& /dev/null && nscd -i "$1"	532	type -p nscd >& /dev/null && nscd -i "$1"
601	getent "$1" "$2"	533	getent "$1" "$2"
602	fi	534	;;
		535	esac
603	}	536	}
604		537
605	# Simplify/standardize adding users to the system	538	# @FUNCTION: enewuser
606	# vapier@gentoo.org	539	# @USAGE: <user> [uid] [shell] [homedir] [groups] [params]
607	#	540	# @DESCRIPTION:
608	# enewuser(username, uid, shell, homedir, groups, extra options)	541	# Same as enewgroup, you are not required to understand how to properly add
609	#	542	# a user to the system. The only required parameter is the username.
610	# Default values if you do not specify any:	543	# Default uid is (pass -1 for this) next available, default shell is
611	# username: REQUIRED !	544	# /bin/false, default homedir is /dev/null, there are no default groups,
612	# uid: next available (see useradd(8))	545	# and default params sets the comment as 'added by portage for ${PN}'.
613	# note: pass -1 to get default behavior
614	# shell: /bin/false
615	# homedir: /dev/null
616	# groups: none
617	# extra: comment of 'added by portage for ${PN}'
618	enewuser() {	546	enewuser() {
		547	case ${EBUILD_PHASE} in
		548	unpack\|compile\|test\|install)
		549	eerror "'enewuser()' called from '${EBUILD_PHASE}()' which is not a pkg_* function."
		550	eerror "Package fails at QA and at life. Please file a bug."
		551	die "Bad package! enewuser is only for use in pkg_* functions!"
		552	esac
		553
619	# get the username	554	# get the username
620	local euser="$1"; shift	555	local euser=$1; shift
621	if [ -z "${euser}" ]	556	if [[ -z ${euser} ]] ; then
622	then
623	eerror "No username specified !"	557	eerror "No username specified !"
624	die "Cannot call enewuser without a username"	558	die "Cannot call enewuser without a username"
625	fi	559	fi
626		560
627	# lets see if the username already exists	561	# lets see if the username already exists
628	if [ "${euser}" == "`egetent passwd \"${euser}\" \| cut -d: -f1`" ]	562	if [[ -n $(egetent passwd "${euser}") ]] ; then
629	then
630	return 0	563	return 0
631	fi	564	fi
632	einfo "Adding user '${euser}' to your system ..."	565	einfo "Adding user '${euser}' to your system ..."
633		566
634	# options to pass to useradd	567	# options to pass to useradd
635	local opts=	568	local opts=
636		569
637	# handle uid	570	# handle uid
638	local euid="$1"; shift	571	local euid=$1; shift
639	if [ ! -z "${euid}" ] && [ "${euid}" != "-1" ]	572	if [[ -n ${euid} && ${euid} != -1 ]] ; then
640	then
641	if [ "${euid}" -gt 0 ]	573	if [[ ${euid} -gt 0 ]] ; then
642	then
643	if [ ! -z "`egetent passwd ${euid}`" ]	574	if [[ -n $(egetent passwd ${euid}) ]] ; then
644	then
645	euid="next"	575	euid="next"
646	fi	576	fi
647	else	577	else
648	eerror "Userid given but is not greater than 0 !"	578	eerror "Userid given but is not greater than 0 !"
649	die "${euid} is not a valid UID"	579	die "${euid} is not a valid UID"
650	fi	580	fi
651	else	581	else
652	euid="next"	582	euid="next"
653	fi	583	fi
654	if [ "${euid}" == "next" ]	584	if [[ ${euid} == "next" ]] ; then
655	then	585	for ((euid = 101; euid <= 999; euid++)); do
656	local pwrange
657	if [ "${USERLAND}" == "BSD" ] ; then
658	pwrange="`jot 898 101`"
659	else
660	pwrange="`seq 101 999`"
661	fi
662	for euid in ${pwrange} ; do
663	[ -z "`egetent passwd ${euid}`" ] && break	586	[[ -z $(egetent passwd ${euid}) ]] && break
664	done	587	done
665	fi	588	fi
666	opts="${opts} -u ${euid}"	589	opts="${opts} -u ${euid}"
667	einfo " - Userid: ${euid}"	590	einfo " - Userid: ${euid}"
668		591
669	# handle shell	592	# handle shell
670	local eshell="$1"; shift	593	local eshell=$1; shift
671	if [ ! -z "${eshell}" ] && [ "${eshell}" != "-1" ]	594	if [[ ! -z ${eshell} ]] && [[ ${eshell} != "-1" ]] ; then
672	then	595	if [[ ! -e ${ROOT}${eshell} ]] ; then
673	if [ ! -e "${eshell}" ]
674	then
675	eerror "A shell was specified but it does not exist !"	596	eerror "A shell was specified but it does not exist !"
676	die "${eshell} does not exist"	597	die "${eshell} does not exist in ${ROOT}"
		598	fi
		599	if [[ ${eshell} == /false \|\| ${eshell} == /nologin ]] ; then
		600	eerror "Do not specify ${eshell} yourself, use -1"
		601	die "Pass '-1' as the shell parameter"
677	fi	602	fi
678	else	603	else
679	if [ "${USERLAND}" == "BSD" ]	604	for shell in /sbin/nologin /usr/sbin/nologin /bin/false /usr/bin/false /dev/null ; do
680	then	605	[[ -x ${ROOT}${shell} ]] && break
681	eshell="/usr/bin/false"	606	done
682	else	607
		608	if [[ ${shell} == "/dev/null" ]] ; then
		609	eerror "Unable to identify the shell to use, proceeding with userland default."
		610	case ${USERLAND} in
683	eshell="/bin/false"	611	GNU) shell="/bin/false" ;;
		612	BSD) shell="/sbin/nologin" ;;
		613	Darwin) shell="/usr/sbin/nologin" ;;
		614	*) die "Unable to identify the default shell for userland ${USERLAND}"
		615	esac
684	fi	616	fi
		617
		618	eshell=${shell}
685	fi	619	fi
686	einfo " - Shell: ${eshell}"	620	einfo " - Shell: ${eshell}"
687	opts="${opts} -s ${eshell}"	621	opts="${opts} -s ${eshell}"
688		622
689	# handle homedir	623	# handle homedir
690	local ehome="$1"; shift	624	local ehome=$1; shift
691	if [ -z "${ehome}" ] && [ "${eshell}" != "-1" ]	625	if [[ -z ${ehome} ]] \|\| [[ ${ehome} == "-1" ]] ; then
692	then
693	ehome="/dev/null"	626	ehome="/dev/null"
694	fi	627	fi
695	einfo " - Home: ${ehome}"	628	einfo " - Home: ${ehome}"
696	opts="${opts} -d ${ehome}"	629	opts="${opts} -d ${ehome}"
697		630
698	# handle groups	631	# handle groups
699	local egroups="$1"; shift	632	local egroups=$1; shift
700	if [ ! -z "${egroups}" ]	633	if [[ ! -z ${egroups} ]] ; then
701	then
702	local oldifs="${IFS}"	634	local oldifs=${IFS}
703	local defgroup="" exgroups=""	635	local defgroup="" exgroups=""
704		636
705	export IFS=","	637	export IFS=","
706	for g in ${egroups}	638	for g in ${egroups} ; do
707	do
708	export IFS="${oldifs}"	639	export IFS=${oldifs}
709	if [ -z "`egetent group \"${g}\"`" ]	640	if [[ -z $(egetent group "${g}") ]] ; then
710	then
711	eerror "You must add group ${g} to the system first"	641	eerror "You must add group ${g} to the system first"
712	die "${g} is not a valid GID"	642	die "${g} is not a valid GID"
713	fi	643	fi
714	if [ -z "${defgroup}" ]	644	if [[ -z ${defgroup} ]] ; then
715	then
716	defgroup="${g}"	645	defgroup=${g}
717	else	646	else
718	exgroups="${exgroups},${g}"	647	exgroups="${exgroups},${g}"
719	fi	648	fi
720	export IFS=","	649	export IFS=","
721	done	650	done
722	export IFS="${oldifs}"	651	export IFS=${oldifs}
723		652
724	opts="${opts} -g ${defgroup}"	653	opts="${opts} -g ${defgroup}"
725	if [ ! -z "${exgroups}" ]	654	if [[ ! -z ${exgroups} ]] ; then
726	then
727	opts="${opts} -G ${exgroups:1}"	655	opts="${opts} -G ${exgroups:1}"
728	fi	656	fi
729	else	657	else
730	egroups="(none)"	658	egroups="(none)"
731	fi	659	fi
732	einfo " - Groups: ${egroups}"	660	einfo " - Groups: ${egroups}"
733		661
734	# handle extra and add the user	662	# handle extra and add the user
735	local eextra="$@"
736	local oldsandbox="${SANDBOX_ON}"	663	local oldsandbox=${SANDBOX_ON}
737	export SANDBOX_ON="0"	664	export SANDBOX_ON="0"
738	if useq ppc-macos	665	case ${CHOST} in
739	then	666	-darwin)
740	### Make the user	667	### Make the user
741	if [ -z "${eextra}" ]	668	if [[ -z $@ ]] ; then
742	then
743	dscl . create /users/${euser} uid ${euid}	669	dscl . create /users/${euser} uid ${euid}
744	dscl . create /users/${euser} shell ${eshell}	670	dscl . create /users/${euser} shell ${eshell}
745	dscl . create /users/${euser} home ${ehome}	671	dscl . create /users/${euser} home ${ehome}
746	dscl . create /users/${euser} realname "added by portage for ${PN}"	672	dscl . create /users/${euser} realname "added by portage for ${PN}"
747	### Add the user to the groups specified	673	### Add the user to the groups specified
748	local oldifs="${IFS}"	674	local oldifs=${IFS}
749	export IFS=","	675	export IFS=","
750	for g in ${egroups}	676	for g in ${egroups} ; do
751	do
752	dscl . merge /groups/${g} users ${euser}	677	dscl . merge /groups/${g} users ${euser}
753	done	678	done
754	export IFS="${oldifs}"	679	export IFS=${oldifs}
755	else	680	else
756	einfo "Extra options are not supported on macos yet"	681	einfo "Extra options are not supported on Darwin yet"
757	einfo "Please report the ebuild along with the info below"	682	einfo "Please report the ebuild along with the info below"
758	einfo "eextra: ${eextra}"	683	einfo "eextra: $@"
759	die "Required function missing"	684	die "Required function missing"
760	fi	685	fi
761	elif use x86-fbsd ; then	686	;;
762	if [ -z "${eextra}" ]	687	-freebsd\|-dragonfly)
763	then	688	if [[ -z $@ ]] ; then
764	pw useradd ${euser} ${opts} \	689	pw useradd ${euser} ${opts} \
765	-c "added by portage for ${PN}" \	690	-c "added by portage for ${PN}" \
766	die "enewuser failed"	691	die "enewuser failed"
767	else	692	else
768	einfo " - Extra: ${eextra}"	693	einfo " - Extra: $@"
769	pw useradd ${euser} ${opts} \	694	pw useradd ${euser} ${opts} \
770	-c ${eextra} \|\| die "enewuser failed"	695	"$@" \|\| die "enewuser failed"
771	fi	696	fi
		697	;;
		698
		699	-netbsd)
		700	if [[ -z $@ ]] ; then
		701	useradd ${opts} ${euser} \|\| die "enewuser failed"
772	else	702	else
773	if [ -z "${eextra}" ]	703	einfo " - Extra: $@"
774	then	704	useradd ${opts} ${euser} "$@" \|\| die "enewuser failed"
		705	fi
		706	;;
		707
		708	-openbsd)
		709	if [[ -z $@ ]] ; then
		710	useradd -u ${euid} -s ${eshell} \
		711	-d ${ehome} -c "Added by portage for ${PN}" \
		712	-g ${egroups} ${euser} \|\| die "enewuser failed"
		713	else
		714	einfo " - Extra: $@"
		715	useradd -u ${euid} -s ${eshell} \
		716	-d ${ehome} -c "Added by portage for ${PN}" \
		717	-g ${egroups} ${euser} "$@" \|\| die "enewuser failed"
		718	fi
		719	;;
		720
		721	*)
		722	if [[ -z $@ ]] ; then
775	useradd ${opts} ${euser} \	723	useradd -r ${opts} \
776	-c "added by portage for ${PN}" \	724	-c "added by portage for ${PN}" \
		725	${euser} \
777	\|\| die "enewuser failed"	726	\|\| die "enewuser failed"
778	else	727	else
779	einfo " - Extra: ${eextra}"	728	einfo " - Extra: $@"
780	useradd ${opts} ${euser} ${eextra} \	729	useradd -r ${opts} "$@" \
		730	${euser} \
781	\|\| die "enewuser failed"	731	\|\| die "enewuser failed"
782	fi	732	fi
		733	;;
		734	esac
		735
		736	if [[ ! -e ${ROOT}/${ehome} ]] ; then
		737	einfo " - Creating ${ehome} in ${ROOT}"
		738	mkdir -p "${ROOT}/${ehome}"
		739	chown ${euser} "${ROOT}/${ehome}"
		740	chmod 755 "${ROOT}/${ehome}"
783	fi	741	fi
		742
784	export SANDBOX_ON="${oldsandbox}"	743	export SANDBOX_ON=${oldsandbox}
785
786	if [ ! -e "${ehome}" ] && [ ! -e "${D}/${ehome}" ]
787	then
788	einfo " - Creating ${ehome} in ${D}"
789	dodir ${ehome}
790	fowners ${euser} ${ehome}
791	fperms 755 ${ehome}
792	fi
793	}	744	}
794		745
795	# Simplify/standardize adding groups to the system	746	# @FUNCTION: enewgroup
796	# vapier@gentoo.org	747	# @USAGE: <group> [gid]
797	#	748	# @DESCRIPTION:
798	# enewgroup(group, gid)	749	# This function does not require you to understand how to properly add a
799	#	750	# group to the system. Just give it a group name to add and enewgroup will
800	# Default values if you do not specify any:	751	# do the rest. You may specify the gid for the group or allow the group to
801	# groupname: REQUIRED !	752	# allocate the next available one.
802	# gid: next available (see groupadd(8))
803	# extra: none
804	enewgroup() {	753	enewgroup() {
		754	case ${EBUILD_PHASE} in
		755	unpack\|compile\|test\|install)
		756	eerror "'enewgroup()' called from '${EBUILD_PHASE}()' which is not a pkg_* function."
		757	eerror "Package fails at QA and at life. Please file a bug."
		758	die "Bad package! enewgroup is only for use in pkg_* functions!"
		759	esac
		760
805	# get the group	761	# get the group
806	local egroup="$1"; shift	762	local egroup="$1"; shift
807	if [ -z "${egroup}" ]	763	if [ -z "${egroup}" ]
808	then	764	then
809	eerror "No group specified !"	765	eerror "No group specified !"
810	die "Cannot call enewgroup without a group"	766	die "Cannot call enewgroup without a group"
811	fi	767	fi
812		768
813	# see if group already exists	769	# see if group already exists
814	if [ "${egroup}" == "`egetent group \"${egroup}\" \| cut -d: -f1`" ]	770	if [[ -n $(egetent group "${egroup}") ]]; then
815	then
816	return 0	771	return 0
817	fi	772	fi
818	einfo "Adding group '${egroup}' to your system ..."	773	einfo "Adding group '${egroup}' to your system ..."
819		774
820	# options to pass to useradd	775	# options to pass to useradd
…		…
826	then	781	then
827	if [ "${egid}" -gt 0 ]	782	if [ "${egid}" -gt 0 ]
828	then	783	then
829	if [ -z "`egetent group ${egid}`" ]	784	if [ -z "`egetent group ${egid}`" ]
830	then	785	then
831	if useq ppc-macos ; then	786	if [[ "${CHOST}" == -darwin ]]; then
832	opts="${opts} ${egid}"	787	opts="${opts} ${egid}"
833	else	788	else
834	opts="${opts} -g ${egid}"	789	opts="${opts} -g ${egid}"
835	fi	790	fi
836	else	791	else
…		…
850	opts="${opts} ${eextra}"	805	opts="${opts} ${eextra}"
851		806
852	# add the group	807	# add the group
853	local oldsandbox="${SANDBOX_ON}"	808	local oldsandbox="${SANDBOX_ON}"
854	export SANDBOX_ON="0"	809	export SANDBOX_ON="0"
855	if useq ppc-macos ; then	810	case ${CHOST} in
		811	-darwin)
856	if [ ! -z "${eextra}" ];	812	if [ ! -z "${eextra}" ];
857	then	813	then
858	einfo "Extra options are not supported on macos yet"	814	einfo "Extra options are not supported on Darwin/OS X yet"
859	einfo "Please report the ebuild along with the info below"	815	einfo "Please report the ebuild along with the info below"
860	einfo "eextra: ${eextra}"	816	einfo "eextra: ${eextra}"
861	die "Required function missing"	817	die "Required function missing"
862	fi	818	fi
863		819
864	# If we need the next available	820	# If we need the next available
865	case ${egid} in	821	case ${egid} in
866	[!0-9]) # Non numeric	822	[!0-9]) # Non numeric
867	for egid in `jot 898 101`; do	823	for ((egid = 101; egid <= 999; egid++)); do
868	[ -z "`egetent group ${egid}`" ] && break	824	[[ -z $(egetent group ${egid}) ]] && break
869	done	825	done
870	esac	826	esac
871	dscl . create /groups/${egroup} gid ${egid}	827	dscl . create /groups/${egroup} gid ${egid}
872	dscl . create /groups/${egroup} passwd '*'	828	dscl . create /groups/${egroup} passwd '*'
873	elif use x86-fbsd ; then	829	;;
		830
		831	-freebsd\|-dragonfly)
874	case ${egid} in	832	case ${egid} in
875	[!0-9]) # Non numeric	833	[!0-9]) # Non numeric
876	for egid in `jot 898 101`; do	834	for ((egid = 101; egid <= 999; egid++)); do
877	[ -z "`egetent group ${egid}`" ] && break	835	[[ -z $(egetent group ${egid}) ]] && break
878	done	836	done
879	esac	837	esac
880	pw groupadd ${egroup} -g ${egid} \|\| die "enewgroup failed"	838	pw groupadd ${egroup} -g ${egid} \|\| die "enewgroup failed"
881	else	839	;;
		840
		841	-netbsd)
		842	case ${egid} in
		843	[!0-9]) # Non numeric
		844	for ((egid = 101; egid <= 999; egid++)); do
		845	[[ -z $(egetent group ${egid}) ]] && break
		846	done
		847	esac
		848	groupadd -g ${egid} ${egroup} \|\| die "enewgroup failed"
		849	;;
		850
		851	*)
		852	# We specify -r so that we get a GID in the system range from login.defs
882	groupadd ${opts} ${egroup} \|\| die "enewgroup failed"	853	groupadd -r ${opts} ${egroup} \|\| die "enewgroup failed"
883	fi	854	;;
		855	esac
884	export SANDBOX_ON="${oldsandbox}"	856	export SANDBOX_ON="${oldsandbox}"
885	}	857	}
886		858
887	# Simple script to replace 'dos2unix' binaries	859	# @FUNCTION: edos2unix
888	# vapier@gentoo.org	860	# @USAGE: <file> [more files ...]
889	#	861	# @DESCRIPTION:
890	# edos2unix(file, <more files> ...)	862	# A handy replacement for dos2unix, recode, fixdos, etc... This allows you
		863	# to remove all of these text utilities from DEPEND variables because this
		864	# is a script based solution. Just give it a list of files to convert and
		865	# they will all be changed from the DOS CRLF format to the UNIX LF format.
891	edos2unix() {	866	edos2unix() {
892	for f in "$@"	867	echo "$@" \| xargs sed -i 's/\r$//'
893	do
894	cp "${f}" ${T}/edos2unix
895	sed 's/\r$//' ${T}/edos2unix > "${f}"
896	done
897	}	868	}
898
899
900	##############################################################
901	# START: Handle .desktop files and menu entries #
902	# maybe this should be separated into a new eclass some time #
903	# lanius@gentoo.org #
904	##############################################################
905		869
906	# Make a desktop file !	870	# Make a desktop file !
907	# Great for making those icons in kde/gnome startmenu !	871	# Great for making those icons in kde/gnome startmenu !
908	# Amaze your friends ! Get the women ! Join today !	872	# Amaze your friends ! Get the women ! Join today !
909	#	873	#
910	# make_desktop_entry(<binary>, [name], [icon], [type], [path])	874	# make_desktop_entry(<command>, [name], [icon], [type], [fields])
911	#	875	#
912	# binary: what binary does the app run with ?	876	# binary: what command does the app run with ?
913	# name: the name that will show up in the menu	877	# name: the name that will show up in the menu
914	# icon: give your little like a pretty little icon ...	878	# icon: give your little like a pretty little icon ...
915	# this can be relative (to /usr/share/pixmaps) or	879	# this can be relative (to /usr/share/pixmaps) or
916	# a full path to an icon	880	# a full path to an icon
917	# type: what kind of application is this ? for categories:	881	# type: what kind of application is this ? for categories:
918	# http://www.freedesktop.org/wiki/Standards_2fmenu_2dspec	882	# http://standards.freedesktop.org/menu-spec/latest/apa.html
919	# path: if your app needs to startup in a specific dir	883	# fields: extra fields to append to the desktop file; a printf string
920	make_desktop_entry() {	884	make_desktop_entry() {
921	[[ -z $1 ]] && eerror "make_desktop_entry: You must specify the executable" && return 1	885	[[ -z $1 ]] && die "make_desktop_entry: You must specify the executable"
922		886
923	local exec=${1}	887	local exec=${1}
924	local name=${2:-${PN}}	888	local name=${2:-${PN}}
925	local icon=${3:-${PN}.png}	889	local icon=${3:-${PN}}
926	local type=${4}	890	local type=${4}
927	local path=${5}	891	local fields=${5}
928		892
929	if [[ -z ${type} ]] ; then	893	if [[ -z ${type} ]] ; then
930	local catmaj=${CATEGORY%%-*}	894	local catmaj=${CATEGORY%%-*}
931	local catmin=${CATEGORY##*-}	895	local catmin=${CATEGORY##*-}
932	case ${catmaj} in	896	case ${catmaj} in
933	app)	897	app)
934	case ${catmin} in	898	case ${catmin} in
		899	accessibility) type=Accessibility;;
935	admin) type=System;;	900	admin) type=System;;
		901	antivirus) type=System;;
		902	arch) type=Archiving;;
		903	backup) type=Archiving;;
936	cdr) type=DiscBurning;;	904	cdr) type=DiscBurning;;
937	dicts) type=Dictionary;;	905	dicts) type=Dictionary;;
		906	doc) type=Documentation;;
938	editors) type=TextEditor;;	907	editors) type=TextEditor;;
939	emacs) type=TextEditor;;	908	emacs) type=TextEditor;;
940	emulation) type=Emulator;;	909	emulation) type=Emulator;;
941	laptop) type=HardwareSettings;;	910	laptop) type=HardwareSettings;;
942	office) type=Office;;	911	office) type=Office;;
		912	pda) type=PDA;;
943	vim) type=TextEditor;;	913	vim) type=TextEditor;;
944	xemacs) type=TextEditor;;	914	xemacs) type=TextEditor;;
945	*) type=;;
946	esac	915	esac
947	;;	916	;;
948		917
949	dev)	918	dev)
950	type="Development"	919	type="Development"
951	;;	920	;;
952		921
953	games)	922	games)
954	[[ -z ${path} ]] && path=${GAMES_BINDIR}
955
956	case ${catmin} in	923	case ${catmin} in
957	action) type=ActionGame;;	924	action\|fps) type=ActionGame;;
958	arcade) type=ArcadeGame;;	925	arcade) type=ArcadeGame;;
959	board) type=BoardGame;;	926	board) type=BoardGame;;
960	kid) type=KidsGame;;
961	emulation) type=Emulator;;	927	emulation) type=Emulator;;
		928	kids) type=KidsGame;;
962	puzzle) type=LogicGame;;	929	puzzle) type=LogicGame;;
		930	roguelike) type=RolePlaying;;
963	rpg) type=RolePlaying;;	931	rpg) type=RolePlaying;;
964	roguelike) type=RolePlaying;;
965	simulation) type=Simulation;;	932	simulation) type=Simulation;;
966	sports) type=SportsGame;;	933	sports) type=SportsGame;;
967	strategy) type=StrategyGame;;	934	strategy) type=StrategyGame;;
968	*) type=;;
969	esac	935	esac
970	type="Game;${type}"	936	type="Game;${type}"
971	;;	937	;;
972		938
		939	gnome)
		940	type="Gnome;GTK"
		941	;;
		942
		943	kde)
		944	type="KDE;Qt"
		945	;;
		946
973	mail)	947	mail)
974	type="Network;Email"	948	type="Network;Email"
975	;;	949	;;
976		950
977	media)	951	media)
978	case ${catmin} in	952	case ${catmin} in
		953	gfx)
979	gfx) type=Graphics;;	954	type=Graphics
		955	;;
		956	*)
		957	case ${catmin} in
980	radio) type=Tuner;;	958	radio) type=Tuner;;
981	sound) type=Audio;;	959	sound) type=Audio;;
982	tv) type=TV;;	960	tv) type=TV;;
983	video) type=Video;;	961	video) type=Video;;
984	*) type=;;	962	esac
		963	type="AudioVideo;${type}"
		964	;;
985	esac	965	esac
986	type="AudioVideo;${type}"
987	;;	966	;;
988		967
989	net)	968	net)
990	case ${catmin} in	969	case ${catmin} in
991	dialup) type=Dialup;;	970	dialup) type=Dialup;;
…		…
994	irc) type=IRCClient;;	973	irc) type=IRCClient;;
995	mail) type=Email;;	974	mail) type=Email;;
996	news) type=News;;	975	news) type=News;;
997	nntp) type=News;;	976	nntp) type=News;;
998	p2p) type=FileTransfer;;	977	p2p) type=FileTransfer;;
999	*) type=;;	978	voip) type=Telephony;;
1000	esac	979	esac
1001	type="Network;${type}"	980	type="Network;${type}"
1002	;;	981	;;
1003		982
1004	sci)	983	sci)
1005	case ${catmin} in	984	case ${catmin} in
1006	astro*) type=Astronomoy;;	985	astro*) type=Astronomy;;
1007	bio*) type=Biology;;	986	bio*) type=Biology;;
1008	calc*) type=Calculator;;	987	calc*) type=Calculator;;
1009	chem*) type=Chemistry;;	988	chem*) type=Chemistry;;
		989	elec*) type=Electronics;;
1010	geo*) type=Geology;;	990	geo*) type=Geology;;
1011	math*) type=Math;;	991	math*) type=Math;;
1012	*) type=;;	992	physics) type=Physics;;
		993	visual*) type=DataVisualization;;
1013	esac	994	esac
1014	type="Science;${type}"	995	type="Education;Science;${type}"
		996	;;
		997
		998	sys)
		999	type="System"
1015	;;	1000	;;
1016		1001
1017	www)	1002	www)
1018	case ${catmin} in	1003	case ${catmin} in
1019	client) type=WebBrowser;;	1004	client) type=WebBrowser;;
1020	*) type=;;
1021	esac	1005	esac
1022	type="Network"	1006	type="Network;${type}"
1023	;;	1007	;;
1024		1008
1025	*)	1009	*)
1026	type=	1010	type=
1027	;;	1011	;;
1028	esac	1012	esac
1029	fi	1013	fi
1030		1014	if [ "${SLOT}" == "0" ] ; then
		1015	local desktop_name="${PN}"
		1016	else
		1017	local desktop_name="${PN}-${SLOT}"
		1018	fi
		1019	local desktop="${T}/$(echo ${exec} \| sed 's:[[:space:]/:]:_:g')-${desktop_name}.desktop"
1031	local desktop=${T}/${exec%% *}-${P}.desktop	1020	#local desktop=${T}/${exec%% *:-${desktop_name}}.desktop
1032		1021
		1022	# Don't append another ";" when a valid category value is provided.
		1023	type=${type%;}${type:+;}
		1024
		1025	eshopts_push -s extglob
		1026	if [[ -n ${icon} && ${icon} != /* ]] && [[ ${icon} == .xpm \|\| ${icon} == .png \|\| ${icon} == *.svg ]]; then
		1027	ewarn "As described in the Icon Theme Specification, icon file extensions are not"
		1028	ewarn "allowed in .desktop files if the value is not an absolute path."
		1029	icon=${icon%.@(xpm\|png\|svg)}
		1030	fi
		1031	eshopts_pop
		1032
		1033	cat <<-EOF > "${desktop}"
1033	echo "[Desktop Entry]	1034	[Desktop Entry]
1034	Encoding=UTF-8
1035	Version=0.9.2
1036	Name=${name}	1035	Name=${name}
1037	Type=Application	1036	Type=Application
1038	Comment=${DESCRIPTION}	1037	Comment=${DESCRIPTION}
1039	Exec=${exec}	1038	Exec=${exec}
1040	Path=${path}	1039	TryExec=${exec%% *}
1041	Icon=${icon}	1040	Icon=${icon}
1042	Categories=Application;${type};" > "${desktop}"	1041	Categories=${type}
		1042	EOF
1043		1043
		1044	if [[ ${fields:-=} != = ]] ; then
		1045	# 5th arg used to be value to Path=
		1046	ewarn "make_desktop_entry: update your 5th arg to read Path=${fields}"
		1047	fields="Path=${fields}"
		1048	fi
		1049	[[ -n ${fields} ]] && printf '%b\n' "${fields}" >> "${desktop}"
		1050
		1051	(
		1052	# wrap the env here so that the 'insinto' call
		1053	# doesn't corrupt the env of the caller
1044	insinto /usr/share/applications	1054	insinto /usr/share/applications
1045	doins "${desktop}"	1055	doins "${desktop}"
1046		1056	) \|\| die "installing desktop file failed"
1047	return 0
1048	}	1057	}
1049		1058
1050	# Make a GDM/KDM Session file	1059	# @FUNCTION: validate_desktop_entries
1051	#	1060	# @USAGE: [directories]
1052	# make_desktop_entry(<title>, <command>)	1061	# @MAINTAINER:
1053	# title: File to execute to start the Window Manager	1062	# Carsten Lohrke <carlo@gentoo.org>
1054	# command: Name of the Window Manager	1063	# @DESCRIPTION:
		1064	# Validate desktop entries using desktop-file-utils
		1065	validate_desktop_entries() {
		1066	if [[ -x /usr/bin/desktop-file-validate ]] ; then
		1067	einfo "Checking desktop entry validity"
		1068	local directories=""
		1069	for d in /usr/share/applications $@ ; do
		1070	[[ -d ${D}${d} ]] && directories="${directories} ${D}${d}"
		1071	done
		1072	if [[ -n ${directories} ]] ; then
		1073	for FILE in $(find ${directories} -name "*\.desktop" \
		1074	-not -path '.hidden' \| sort -u 2>/dev/null)
		1075	do
		1076	local temp=$(desktop-file-validate ${FILE} \| grep -v "warning:" \| \
		1077	sed -e "s\|error: \|\|" -e "s\|${FILE}:\|--\|g" )
		1078	[[ -n $temp ]] && elog ${temp/--/${FILE/${D}/}:}
		1079	done
		1080	fi
		1081	echo ""
		1082	else
		1083	einfo "Passing desktop entry validity check. Install dev-util/desktop-file-utils, if you want to help to improve Gentoo."
		1084	fi
		1085	}
1055		1086
		1087	# @FUNCTION: make_session_desktop
		1088	# @USAGE: <title> <command> [command args...]
		1089	# @DESCRIPTION:
		1090	# Make a GDM/KDM Session file. The title is the file to execute to start the
		1091	# Window Manager. The command is the name of the Window Manager.
		1092	#
		1093	# You can set the name of the file via the ${wm} variable.
1056	make_session_desktop() {	1094	make_session_desktop() {
1057
1058	[ -z "$1" ] && eerror "make_session_desktop: You must specify the title" && return 1	1095	[[ -z $1 ]] && eerror "$0: You must specify the title" && return 1
1059	[ -z "$2" ] && eerror "make_session_desktop: You must specify the command" && return 1	1096	[[ -z $2 ]] && eerror "$0: You must specify the command" && return 1
1060		1097
1061	local title="${1}"	1098	local title=$1
1062	local command="${2}"	1099	local command=$2
1063	local desktop="${T}/${wm}.desktop"	1100	local desktop=${T}/${wm:-${PN}}.desktop
		1101	shift 2
1064		1102
		1103	cat <<-EOF > "${desktop}"
1065	echo "[Desktop Entry]	1104	[Desktop Entry]
1066	Encoding=UTF-8
1067	Name=${title}	1105	Name=${title}
1068	Comment=This session logs you into ${title}	1106	Comment=This session logs you into ${title}
1069	Exec=${command}	1107	Exec=${command} $*
1070	TryExec=${command}	1108	TryExec=${command}
1071	Type=Application" > "${desktop}"	1109	Type=XSession
		1110	EOF
1072		1111
		1112	(
		1113	# wrap the env here so that the 'insinto' call
		1114	# doesn't corrupt the env of the caller
1073	insinto /usr/share/xsessions	1115	insinto /usr/share/xsessions
1074	doins "${desktop}"	1116	doins "${desktop}"
1075		1117	)
1076	return 0
1077	}	1118	}
1078		1119
		1120	# @FUNCTION: domenu
		1121	# @USAGE: <menus>
		1122	# @DESCRIPTION:
		1123	# Install the list of .desktop menu files into the appropriate directory
		1124	# (/usr/share/applications).
1079	domenu() {	1125	domenu() {
1080	local i	1126	(
1081	local j	1127	# wrap the env here so that the 'insinto' call
		1128	# doesn't corrupt the env of the caller
		1129	local i j ret=0
1082	insinto /usr/share/applications	1130	insinto /usr/share/applications
1083	for i in ${@}	1131	for i in "$@" ; do
1084	do
1085	if [ -f "${i}" ];	1132	if [[ -f ${i} ]] ; then
1086	then
1087	doins ${i}	1133	doins "${i}"
		1134	((ret+=$?))
1088	elif [ -d "${i}" ];	1135	elif [[ -d ${i} ]] ; then
1089	then
1090	for j in ${i}/*.desktop	1136	for j in "${i}"/*.desktop ; do
1091	do
1092	doins ${j}	1137	doins "${j}"
		1138	((ret+=$?))
1093	done	1139	done
		1140	else
		1141	((++ret))
1094	fi	1142	fi
1095	done	1143	done
		1144	exit ${ret}
		1145	)
1096	}	1146	}
1097		1147
		1148	# @FUNCTION: newmenu
		1149	# @USAGE: <menu> <newname>
		1150	# @DESCRIPTION:
		1151	# Like all other new* functions, install the specified menu as newname.
		1152	newmenu() {
		1153	(
		1154	# wrap the env here so that the 'insinto' call
		1155	# doesn't corrupt the env of the caller
		1156	insinto /usr/share/applications
		1157	newins "$@"
		1158	)
		1159	}
		1160
		1161	# @FUNCTION: doicon
		1162	# @USAGE: <list of icons>
		1163	# @DESCRIPTION:
		1164	# Install the list of icons into the icon directory (/usr/share/pixmaps).
		1165	# This is useful in conjunction with creating desktop/menu files.
1098	doicon() {	1166	doicon() {
1099	local i	1167	(
1100	local j	1168	# wrap the env here so that the 'insinto' call
		1169	# doesn't corrupt the env of the caller
		1170	local i j ret
1101	insinto /usr/share/pixmaps	1171	insinto /usr/share/pixmaps
1102	for i in ${@}	1172	for i in "$@" ; do
1103	do
1104	if [ -f "${i}" ];	1173	if [[ -f ${i} ]] ; then
1105	then
1106	doins ${i}	1174	doins "${i}"
		1175	((ret+=$?))
1107	elif [ -d "${i}" ];	1176	elif [[ -d ${i} ]] ; then
1108	then
1109	for j in ${i}/*.png	1177	for j in "${i}"/*.png ; do
1110	do
1111	doins ${j}	1178	doins "${j}"
		1179	((ret+=$?))
1112	done	1180	done
		1181	else
		1182	((++ret))
1113	fi	1183	fi
1114	done	1184	done
		1185	exit ${ret}
		1186	)
1115	}	1187	}
1116		1188
1117	##############################################################	1189	# @FUNCTION: newicon
1118	# END: Handle .desktop files and menu entries #	1190	# @USAGE: <icon> <newname>
1119	##############################################################	1191	# @DESCRIPTION:
1120		1192	# Like all other new* functions, install the specified icon as newname.
		1193	newicon() {
		1194	(
		1195	# wrap the env here so that the 'insinto' call
		1196	# doesn't corrupt the env of the caller
		1197	insinto /usr/share/pixmaps
		1198	newins "$@"
		1199	)
		1200	}
1121		1201
1122	# for internal use only (unpack_pdv and unpack_makeself)	1202	# for internal use only (unpack_pdv and unpack_makeself)
1123	find_unpackable_file() {	1203	find_unpackable_file() {
1124	local src="$1"	1204	local src=$1
1125	if [ -z "${src}" ]	1205	if [[ -z ${src} ]] ; then
1126	then
1127	src="${DISTDIR}/${A}"	1206	src=${DISTDIR}/${A}
1128	else	1207	else
1129	if [ -e "${DISTDIR}/${src}" ]	1208	if [[ -e ${DISTDIR}/${src} ]] ; then
1130	then
1131	src="${DISTDIR}/${src}"	1209	src=${DISTDIR}/${src}
1132	elif [ -e "${PWD}/${src}" ]	1210	elif [[ -e ${PWD}/${src} ]] ; then
1133	then
1134	src="${PWD}/${src}"	1211	src=${PWD}/${src}
1135	elif [ -e "${src}" ]	1212	elif [[ -e ${src} ]] ; then
1136	then
1137	src="${src}"	1213	src=${src}
1138	fi
1139	fi	1214	fi
1140	[ ! -e "${src}" ] && die "Could not find requested archive ${src}"	1215	fi
		1216	[[ ! -e ${src} ]] && return 1
1141	echo "${src}"	1217	echo "${src}"
1142	}	1218	}
1143		1219
		1220	# @FUNCTION: unpack_pdv
		1221	# @USAGE: <file to unpack> <size of off_t>
		1222	# @DESCRIPTION:
1144	# Unpack those pesky pdv generated files ...	1223	# Unpack those pesky pdv generated files ...
1145	# They're self-unpacking programs with the binary package stuffed in	1224	# They're self-unpacking programs with the binary package stuffed in
1146	# the middle of the archive. Valve seems to use it a lot ... too bad	1225	# the middle of the archive. Valve seems to use it a lot ... too bad
1147	# it seems to like to segfault a lot :(. So lets take it apart ourselves.	1226	# it seems to like to segfault a lot :(. So lets take it apart ourselves.
1148	#	1227	#
1149	# Usage: unpack_pdv [file to unpack] [size of off_t]
1150	# - you have to specify the off_t size ... i have no idea how to extract that	1228	# You have to specify the off_t size ... I have no idea how to extract that
1151	# information out of the binary executable myself. basically you pass in	1229	# information out of the binary executable myself. Basically you pass in
1152	# the size of the off_t type (in bytes) on the machine that built the pdv	1230	# the size of the off_t type (in bytes) on the machine that built the pdv
		1231	# archive.
		1232	#
1153	# archive. one way to determine this is by running the following commands:	1233	# One way to determine this is by running the following commands:
		1234	#
		1235	# @CODE
1154	# strings <pdv archive> \| grep lseek	1236	# strings <pdv archive> \| grep lseek
1155	# strace -elseek <pdv archive>	1237	# strace -elseek <pdv archive>
		1238	# @CODE
		1239	#
1156	# basically look for the first lseek command (we do the strings/grep because	1240	# Basically look for the first lseek command (we do the strings/grep because
1157	# sometimes the function call is _llseek or something) and steal the 2nd	1241	# sometimes the function call is _llseek or something) and steal the 2nd
1158	# parameter. here is an example:	1242	# parameter. Here is an example:
		1243	#
		1244	# @CODE
1159	# root@vapier 0 pdv_unpack # strings hldsupdatetool.bin \| grep lseek	1245	# vapier@vapier 0 pdv_unpack # strings hldsupdatetool.bin \| grep lseek
1160	# lseek	1246	# lseek
1161	# root@vapier 0 pdv_unpack # strace -elseek ./hldsupdatetool.bin	1247	# vapier@vapier 0 pdv_unpack # strace -elseek ./hldsupdatetool.bin
1162	# lseek(3, -4, SEEK_END) = 2981250	1248	# lseek(3, -4, SEEK_END) = 2981250
		1249	# @CODE
		1250	#
1163	# thus we would pass in the value of '4' as the second parameter.	1251	# Thus we would pass in the value of '4' as the second parameter.
1164	unpack_pdv() {	1252	unpack_pdv() {
1165	local src="`find_unpackable_file $1`"	1253	local src=$(find_unpackable_file "$1")
1166	local sizeoff_t="$2"	1254	local sizeoff_t=$2
1167		1255
		1256	[[ -z ${src} ]] && die "Could not locate source for '$1'"
1168	[ -z "${sizeoff_t}" ] && die "No idea what off_t size was used for this pdv :("	1257	[[ -z ${sizeoff_t} ]] && die "No idea what off_t size was used for this pdv :("
1169		1258
1170	local shrtsrc="`basename ${src}`"	1259	local shrtsrc=$(basename "${src}")
1171	echo ">>> Unpacking ${shrtsrc} to ${PWD}"	1260	echo ">>> Unpacking ${shrtsrc} to ${PWD}"
1172	local metaskip=`tail -c ${sizeoff_t} ${src} \| hexdump -e \"%i\"`	1261	local metaskip=$(tail -c ${sizeoff_t} "${src}" \| hexdump -e \"%i\")
1173	local tailskip=`tail -c $((${sizeoff_t}*2)) ${src} \| head -c ${sizeoff_t} \| hexdump -e \"%i\"`	1262	local tailskip=$(tail -c $((${sizeoff_t}*2)) "${src}" \| head -c ${sizeoff_t} \| hexdump -e \"%i\")
1174		1263
1175	# grab metadata for debug reasons	1264	# grab metadata for debug reasons
1176	local metafile="$(emktemp)"	1265	local metafile=$(emktemp)
1177	tail -c +$((${metaskip}+1)) ${src} > ${metafile}	1266	tail -c +$((${metaskip}+1)) "${src}" > "${metafile}"
1178		1267
1179	# rip out the final file name from the metadata	1268	# rip out the final file name from the metadata
1180	local datafile="`tail -c +$((${metaskip}+1)) ${src} \| strings \| head -n 1`"	1269	local datafile=$(tail -c +$((${metaskip}+1)) "${src}" \| strings \| head -n 1)
1181	datafile="`basename ${datafile}`"	1270	datafile=$(basename "${datafile}")
1182		1271
1183	# now lets uncompress/untar the file if need be	1272	# now lets uncompress/untar the file if need be
1184	local tmpfile="$(emktemp)"	1273	local tmpfile=$(emktemp)
1185	tail -c +$((${tailskip}+1)) ${src} 2>/dev/null \| head -c 512 > ${tmpfile}	1274	tail -c +$((${tailskip}+1)) ${src} 2>/dev/null \| head -c 512 > ${tmpfile}
1186		1275
1187	local iscompressed="`file -b ${tmpfile}`"	1276	local iscompressed=$(file -b "${tmpfile}")
1188	if [ "${iscompressed:0:8}" == "compress" ] ; then	1277	if [[ ${iscompressed:0:8} == "compress" ]] ; then
1189	iscompressed=1	1278	iscompressed=1
1190	mv ${tmpfile}{,.Z}	1279	mv ${tmpfile}{,.Z}
1191	gunzip ${tmpfile}	1280	gunzip ${tmpfile}
1192	else	1281	else
1193	iscompressed=0	1282	iscompressed=0
1194	fi	1283	fi
1195	local istar="`file -b ${tmpfile}`"	1284	local istar=$(file -b "${tmpfile}")
1196	if [ "${istar:0:9}" == "POSIX tar" ] ; then	1285	if [[ ${istar:0:9} == "POSIX tar" ]] ; then
1197	istar=1	1286	istar=1
1198	else	1287	else
1199	istar=0	1288	istar=0
1200	fi	1289	fi
1201		1290
…		…
1229	true	1318	true
1230	#[ -s "${datafile}" ] \|\| die "failure unpacking pdv ('${metaskip}' '${tailskip}' '${datafile}')"	1319	#[ -s "${datafile}" ] \|\| die "failure unpacking pdv ('${metaskip}' '${tailskip}' '${datafile}')"
1231	#assert "failure unpacking pdv ('${metaskip}' '${tailskip}' '${datafile}')"	1320	#assert "failure unpacking pdv ('${metaskip}' '${tailskip}' '${datafile}')"
1232	}	1321	}
1233		1322
		1323	# @FUNCTION: unpack_makeself
		1324	# @USAGE: [file to unpack] [offset] [tail\|dd]
		1325	# @DESCRIPTION:
1234	# Unpack those pesky makeself generated files ...	1326	# Unpack those pesky makeself generated files ...
1235	# They're shell scripts with the binary package tagged onto	1327	# They're shell scripts with the binary package tagged onto
1236	# the end of the archive. Loki utilized the format as does	1328	# the end of the archive. Loki utilized the format as does
1237	# many other game companies.	1329	# many other game companies.
1238	#	1330	#
1239	# Usage: unpack_makeself [file to unpack] [offset] [tail\|dd]	1331	# If the file is not specified, then ${A} is used. If the
1240	# - If the file is not specified then unpack will utilize ${A}.
1241	# - If the offset is not specified then we will attempt to extract	1332	# offset is not specified then we will attempt to extract
1242	# the proper offset from the script itself.	1333	# the proper offset from the script itself.
1243	unpack_makeself() {	1334	unpack_makeself() {
		1335	local src_input=${1:-${A}}
1244	local src="$(find_unpackable_file "$1")"	1336	local src=$(find_unpackable_file "${src_input}")
1245	local skip="$2"	1337	local skip=$2
1246	local exe="$3"	1338	local exe=$3
1247		1339
		1340	[[ -z ${src} ]] && die "Could not locate source for '${src_input}'"
		1341
1248	local shrtsrc="$(basename "${src}")"	1342	local shrtsrc=$(basename "${src}")
1249	echo ">>> Unpacking ${shrtsrc} to ${PWD}"	1343	echo ">>> Unpacking ${shrtsrc} to ${PWD}"
1250	if [ -z "${skip}" ]	1344	if [[ -z ${skip} ]] ; then
1251	then
1252	local ver="`grep -a '#.*Makeself' ${src} \| awk '{print $NF}'`"	1345	local ver=$(grep -m1 -a '#.*Makeself' "${src}" \| awk '{print $NF}')
1253	local skip=0	1346	local skip=0
1254	exe=tail	1347	exe=tail
1255	case ${ver} in	1348	case ${ver} in
1256	1.5.*) # tested 1.5.{3,4,5} ... guessing 1.5.x series is same	1349	1.5.*\|1.6.0-nv) # tested 1.5.{3,4,5} ... guessing 1.5.x series is same
1257	skip=$(grep -a ^skip= "${src}" \| cut -d= -f2)	1350	skip=$(grep -a ^skip= "${src}" \| cut -d= -f2)
1258	;;	1351	;;
1259	2.0\|2.0.1)	1352	2.0\|2.0.1)
1260	skip=$(grep -a ^$'\t'tail "${src}" \| awk '{print $2}' \| cut -b2-)	1353	skip=$(grep -a ^$'\t'tail "${src}" \| awk '{print $2}' \| cut -b2-)
1261	;;	1354	;;
1262	2.1.1)	1355	2.1.1)
1263	skip=$(grep -a ^offset= "${src}" \| awk '{print $2}' \| cut -b2-)	1356	skip=$(grep -a ^offset= "${src}" \| awk '{print $2}' \| cut -b2-)
1264	let skip="skip + 1"	1357	(( skip++ ))
1265	;;	1358	;;
1266	2.1.2)	1359	2.1.2)
1267	skip=$(grep -a ^offset= "${src}" \| awk '{print $3}' \| head -n 1)	1360	skip=$(grep -a ^offset= "${src}" \| awk '{print $3}' \| head -n 1)
1268	let skip="skip + 1"	1361	(( skip++ ))
1269	;;	1362	;;
1270	2.1.3)	1363	2.1.3)
1271	skip=`grep -a ^offset= "${src}" \| awk '{print $3}'`	1364	skip=`grep -a ^offset= "${src}" \| awk '{print $3}'`
1272	let skip="skip + 1"	1365	(( skip++ ))
1273	;;	1366	;;
1274	2.1.4)	1367	2.1.4\|2.1.5)
1275	skip=$(grep -a offset=.head.wc "${src}" \| awk '{print $3}' \| head -n 1)	1368	skip=$(grep -a offset=.head.wc "${src}" \| awk '{print $3}' \| head -n 1)
1276	skip=$(head -n ${skip} "${src}" \| wc -c)	1369	skip=$(head -n ${skip} "${src}" \| wc -c)
1277	exe="dd"	1370	exe="dd"
1278	;;	1371	;;
1279	*)	1372	*)
…		…
1286	esac	1379	esac
1287	debug-print "Detected Makeself version ${ver} ... using ${skip} as offset"	1380	debug-print "Detected Makeself version ${ver} ... using ${skip} as offset"
1288	fi	1381	fi
1289	case ${exe} in	1382	case ${exe} in
1290	tail) exe="tail -n +${skip} '${src}'";;	1383	tail) exe="tail -n +${skip} '${src}'";;
1291	dd) exe="dd ibs=${skip} skip=1 obs=1024 conv=sync if='${src}'";;	1384	dd) exe="dd ibs=${skip} skip=1 if='${src}'";;
1292	*) die "makeself cant handle exe '${exe}'"	1385	*) die "makeself cant handle exe '${exe}'"
1293	esac	1386	esac
1294		1387
1295	# lets grab the first few bytes of the file to figure out what kind of archive it is	1388	# lets grab the first few bytes of the file to figure out what kind of archive it is
1296	local tmpfile="$(emktemp)"	1389	local tmpfile=$(emktemp)
1297	eval ${exe} 2>/dev/null \| head -c 512 > "${tmpfile}"	1390	eval ${exe} 2>/dev/null \| head -c 512 > "${tmpfile}"
1298	local filetype="$(file -b "${tmpfile}")"	1391	local filetype=$(file -b "${tmpfile}")
1299	case ${filetype} in	1392	case ${filetype} in
1300	*tar\ archive)	1393	tar\ archive)
1301	eval ${exe} \| tar --no-same-owner -xf -	1394	eval ${exe} \| tar --no-same-owner -xf -
1302	;;	1395	;;
1303	bzip2*)	1396	bzip2*)
1304	eval ${exe} \| bzip2 -dc \| tar --no-same-owner -xf -	1397	eval ${exe} \| bzip2 -dc \| tar --no-same-owner -xf -
1305	;;	1398	;;
…		…
1315	;;	1408	;;
1316	esac	1409	esac
1317	assert "failure unpacking (${filetype}) makeself ${shrtsrc} ('${ver}' +${skip})"	1410	assert "failure unpacking (${filetype}) makeself ${shrtsrc} ('${ver}' +${skip})"
1318	}	1411	}
1319		1412
		1413	# @FUNCTION: check_license
		1414	# @USAGE: [license]
		1415	# @DESCRIPTION:
1320	# Display a license for user to accept.	1416	# Display a license for user to accept. If no license is
1321	#
1322	# Usage: check_license [license]
1323	# - If the file is not specified then ${LICENSE} is used.	1417	# specified, then ${LICENSE} is used.
1324	check_license() {	1418	check_license() {
1325	local lic=$1	1419	local lic=$1
1326	if [ -z "${lic}" ] ; then	1420	if [ -z "${lic}" ] ; then
1327	lic="${PORTDIR}/licenses/${LICENSE}"	1421	lic="${PORTDIR}/licenses/${LICENSE}"
1328	else	1422	else
1329	if [ -e "${PORTDIR}/licenses/${src}" ] ; then	1423	if [ -e "${PORTDIR}/licenses/${lic}" ] ; then
1330	lic="${PORTDIR}/licenses/${src}"	1424	lic="${PORTDIR}/licenses/${lic}"
1331	elif [ -e "${PWD}/${src}" ] ; then	1425	elif [ -e "${PWD}/${lic}" ] ; then
1332	lic="${PWD}/${src}"	1426	lic="${PWD}/${lic}"
1333	elif [ -e "${src}" ] ; then	1427	elif [ -e "${lic}" ] ; then
1334	lic="${src}"	1428	lic="${lic}"
1335	fi
1336	fi	1429	fi
1337	[ ! -f "${lic}" ] && die "Could not find requested license ${src}"	1430	fi
1338	local l="`basename ${lic}`"	1431	local l="`basename ${lic}`"
1339		1432
1340	# here is where we check for the licenses the user already	1433	# here is where we check for the licenses the user already
1341	# accepted ... if we don't find a match, we make the user accept	1434	# accepted ... if we don't find a match, we make the user accept
1342	local shopts=$-
1343	local alic	1435	local alic
1344	set -o noglob #so that bash doesn't expand "*"	1436	eshopts_push -o noglob # so that bash doesn't expand "*"
1345	for alic in ${ACCEPT_LICENSE} ; do	1437	for alic in ${ACCEPT_LICENSE} ; do
1346	if [[ ${alic} == * \|\| ${alic} == ${l} ]]; then	1438	if [[ ${alic} == ${l} ]]; then
1347	set +o noglob; set -${shopts} #reset old shell opts	1439	eshopts_pop
1348	return 0	1440	return 0
1349	fi	1441	fi
1350	done	1442	done
1351	set +o noglob; set -$shopts #reset old shell opts	1443	eshopts_pop
		1444	[ ! -f "${lic}" ] && die "Could not find requested license ${lic}"
1352		1445
1353	local licmsg="$(emktemp)"	1446	local licmsg=$(emktemp)
1354	cat << EOF > ${licmsg}	1447	cat <<-EOF > ${licmsg}
1355	**********************************************************	1448	**********************************************************
1356	The following license outlines the terms of use of this	1449	The following license outlines the terms of use of this
1357	package. You MUST accept this license for installation to	1450	package. You MUST accept this license for installation to
1358	continue. When you are done viewing, hit 'q'. If you	1451	continue. When you are done viewing, hit 'q'. If you
1359	CTRL+C out of this, the install will not run!	1452	CTRL+C out of this, the install will not run!
1360	**********************************************************	1453	**********************************************************
1361		1454
1362	EOF	1455	EOF
1363	cat ${lic} >> ${licmsg}	1456	cat ${lic} >> ${licmsg}
1364	${PAGER:-less} ${licmsg} \|\| die "Could not execute pager (${PAGER}) to accept ${lic}"	1457	${PAGER:-less} ${licmsg} \|\| die "Could not execute pager (${PAGER}) to accept ${lic}"
1365	einfon "Do you accept the terms of this license (${l})? [yes/no] "	1458	einfon "Do you accept the terms of this license (${l})? [yes/no] "
1366	read alic	1459	read alic
1367	case ${alic} in	1460	case ${alic} in
…		…
1374	die "Failed to accept license"	1467	die "Failed to accept license"
1375	;;	1468	;;
1376	esac	1469	esac
1377	}	1470	}
1378		1471
		1472	# @FUNCTION: cdrom_get_cds
		1473	# @USAGE: <file on cd1> [file on cd2] [file on cd3] [...]
		1474	# @DESCRIPTION:
1379	# Aquire cd(s) for those lovely cd-based emerges. Yes, this violates	1475	# Aquire cd(s) for those lovely cd-based emerges. Yes, this violates
1380	# the whole 'non-interactive' policy, but damnit I want CD support !	1476	# the whole 'non-interactive' policy, but damnit I want CD support !
1381	#	1477	#
1382	# with these cdrom functions we handle all the user interaction and	1478	# With these cdrom functions we handle all the user interaction and
1383	# standardize everything. all you have to do is call cdrom_get_cds()	1479	# standardize everything. All you have to do is call cdrom_get_cds()
1384	# and when the function returns, you can assume that the cd has been	1480	# and when the function returns, you can assume that the cd has been
1385	# found at CDROM_ROOT.	1481	# found at CDROM_ROOT.
1386	#	1482	#
		1483	# The function will attempt to locate a cd based upon a file that is on
		1484	# the cd. The more files you give this function, the more cds
		1485	# the cdrom functions will handle.
		1486	#
1387	# normally the cdrom functions will refer to the cds as 'cd #1', 'cd #2',	1487	# Normally the cdrom functions will refer to the cds as 'cd #1', 'cd #2',
1388	# etc... if you want to give the cds better names, then just export	1488	# etc... If you want to give the cds better names, then just export
1389	# the CDROM_NAME_X variables before calling cdrom_get_cds().	1489	# the appropriate CDROM_NAME variable before calling cdrom_get_cds().
		1490	# Use CDROM_NAME for one cd, or CDROM_NAME_# for multiple cds. You can
		1491	# also use the CDROM_NAME_SET bash array.
1390	#	1492	#
1391	# for those multi cd ebuilds, see the cdrom_load_next_cd() below.	1493	# For those multi cd ebuilds, see the cdrom_load_next_cd() function.
1392	#
1393	# Usage: cdrom_get_cds <file on cd1> [file on cd2] [file on cd3] [...]
1394	# - this will attempt to locate a cd based upon a file that is on
1395	# the cd ... the more files you give this function, the more cds
1396	# the cdrom functions will handle
1397	cdrom_get_cds() {	1494	cdrom_get_cds() {
1398	# first we figure out how many cds we're dealing with by	1495	# first we figure out how many cds we're dealing with by
1399	# the # of files they gave us	1496	# the # of files they gave us
1400	local cdcnt=0	1497	local cdcnt=0
1401	local f=	1498	local f=
1402	for f in "$@" ; do	1499	for f in "$@" ; do
1403	cdcnt=$((cdcnt + 1))	1500	((++cdcnt))
1404	export CDROM_CHECK_${cdcnt}="$f"	1501	export CDROM_CHECK_${cdcnt}="$f"
1405	done	1502	done
1406	export CDROM_TOTAL_CDS=${cdcnt}	1503	export CDROM_TOTAL_CDS=${cdcnt}
1407	export CDROM_CURRENT_CD=1	1504	export CDROM_CURRENT_CD=1
1408		1505
1409	# now we see if the user gave use CD_ROOT ...	1506	# now we see if the user gave use CD_ROOT ...
1410	# if they did, let's just believe them that it's correct	1507	# if they did, let's just believe them that it's correct
1411	if [[ ! -z ${CD_ROOT} ]] ; then
1412	export CDROM_ROOT=${CD_ROOT}
1413	einfo "Found CD #${CDROM_CURRENT_CD} root at ${CDROM_ROOT}"
1414	return
1415	fi
1416	# do the same for CD_ROOT_X
1417	if [[ ! -z ${CD_ROOT_1} ]] ; then	1508	if [[ -n ${CD_ROOT}${CD_ROOT_1} ]] ; then
1418	local var=	1509	local var=
1419	cdcnt=0	1510	cdcnt=0
1420	while [[ ${cdcnt} -lt ${CDROM_TOTAL_CDS} ]] ; do	1511	while [[ ${cdcnt} -lt ${CDROM_TOTAL_CDS} ]] ; do
1421	cdcnt=$((cdcnt + 1))	1512	((++cdcnt))
1422	var="CD_ROOT_${cdcnt}"	1513	var="CD_ROOT_${cdcnt}"
		1514	[[ -z ${!var} ]] && var="CD_ROOT"
1423	if [[ -z ${!var} ]] ; then	1515	if [[ -z ${!var} ]] ; then
1424	eerror "You must either use just the CD_ROOT"	1516	eerror "You must either use just the CD_ROOT"
1425	eerror "or specify ALL the CD_ROOT_X variables."	1517	eerror "or specify ALL the CD_ROOT_X variables."
1426	eerror "In this case, you will need ${CDROM_TOTAL_CDS} CD_ROOT_X variables."	1518	eerror "In this case, you will need ${CDROM_TOTAL_CDS} CD_ROOT_X variables."
1427	die "could not locate CD_ROOT_${cdcnt}"	1519	die "could not locate CD_ROOT_${cdcnt}"
1428	fi	1520	fi
1429	export CDROM_ROOTS_${cdcnt}="${!var}"
1430	done	1521	done
1431	export CDROM_ROOT=${CDROM_ROOTS_1}	1522	export CDROM_ROOT=${CD_ROOT_1:-${CD_ROOT}}
1432	einfo "Found CD #${CDROM_CURRENT_CD} root at ${CDROM_ROOT}"	1523	einfo "Found CD #${CDROM_CURRENT_CD} root at ${CDROM_ROOT}"
		1524	export CDROM_SET=-1
		1525	for f in ${CDROM_CHECK_1//:/ } ; do
		1526	((++CDROM_SET))
		1527	[[ -e ${CDROM_ROOT}/${f} ]] && break
		1528	done
		1529	export CDROM_MATCH=${f}
1433	return	1530	return
1434	fi	1531	fi
1435		1532
		1533	# User didn't help us out so lets make sure they know they can
		1534	# simplify the whole process ...
1436	if [[ ${CDROM_TOTAL_CDS} -eq 1 ]] ; then	1535	if [[ ${CDROM_TOTAL_CDS} -eq 1 ]] ; then
1437	einfon "This ebuild will need the "	1536	einfo "This ebuild will need the ${CDROM_NAME:-cdrom for ${PN}}"
1438	if [[ -z ${CDROM_NAME} ]] ; then
1439	echo "cdrom for ${PN}."
1440	else
1441	echo "${CDROM_NAME}."
1442	fi
1443	echo	1537	echo
1444	einfo "If you do not have the CD, but have the data files"	1538	einfo "If you do not have the CD, but have the data files"
1445	einfo "mounted somewhere on your filesystem, just export"	1539	einfo "mounted somewhere on your filesystem, just export"
1446	einfo "the variable CD_ROOT so that it points to the"	1540	einfo "the variable CD_ROOT so that it points to the"
1447	einfo "directory containing the files."	1541	einfo "directory containing the files."
1448	echo	1542	echo
1449	einfo "For example:"	1543	einfo "For example:"
1450	einfo "export CD_ROOT=/mnt/cdrom"	1544	einfo "export CD_ROOT=/mnt/cdrom"
1451	echo	1545	echo
1452	else	1546	else
		1547	if [[ -n ${CDROM_NAME_SET} ]] ; then
		1548	# Translate the CDROM_NAME_SET array into CDROM_NAME_#
		1549	cdcnt=0
		1550	while [[ ${cdcnt} -lt ${CDROM_TOTAL_CDS} ]] ; do
		1551	((++cdcnt))
		1552	export CDROM_NAME_${cdcnt}="${CDROM_NAME_SET[$((${cdcnt}-1))]}"
		1553	done
		1554	fi
		1555
1453	einfo "This package will need access to ${CDROM_TOTAL_CDS} cds."	1556	einfo "This package will need access to ${CDROM_TOTAL_CDS} cds."
1454	cdcnt=0	1557	cdcnt=0
1455	while [[ ${cdcnt} -lt ${CDROM_TOTAL_CDS} ]] ; do	1558	while [[ ${cdcnt} -lt ${CDROM_TOTAL_CDS} ]] ; do
1456	cdcnt=$((cdcnt + 1))	1559	((++cdcnt))
1457	var="CDROM_NAME_${cdcnt}"	1560	var="CDROM_NAME_${cdcnt}"
1458	[[ ! -z ${!var} ]] && einfo " CD ${cdcnt}: ${!var}"	1561	[[ ! -z ${!var} ]] && einfo " CD ${cdcnt}: ${!var}"
1459	done	1562	done
1460	echo	1563	echo
1461	einfo "If you do not have the CDs, but have the data files"	1564	einfo "If you do not have the CDs, but have the data files"
1462	einfo "mounted somewhere on your filesystem, just export"	1565	einfo "mounted somewhere on your filesystem, just export"
1463	einfo "the following variables so they point to the right place:"	1566	einfo "the following variables so they point to the right place:"
1464	einfon ""	1567	einfon ""
1465	cdcnt=0	1568	cdcnt=0
1466	while [[ ${cdcnt} -lt ${CDROM_TOTAL_CDS} ]] ; do	1569	while [[ ${cdcnt} -lt ${CDROM_TOTAL_CDS} ]] ; do
1467	cdcnt=$((cdcnt + 1))	1570	((++cdcnt))
1468	echo -n " CD_ROOT_${cdcnt}"	1571	echo -n " CD_ROOT_${cdcnt}"
1469	done	1572	done
1470	echo	1573	echo
1471	einfo "Or, if you have all the files in the same place, or"	1574	einfo "Or, if you have all the files in the same place, or"
1472	einfo "you only have one cdrom, you can export CD_ROOT"	1575	einfo "you only have one cdrom, you can export CD_ROOT"
…		…
1475	echo	1578	echo
1476	einfo "For example:"	1579	einfo "For example:"
1477	einfo "export CD_ROOT_1=/mnt/cdrom"	1580	einfo "export CD_ROOT_1=/mnt/cdrom"
1478	echo	1581	echo
1479	fi	1582	fi
		1583
		1584	export CDROM_SET=""
1480	export CDROM_CURRENT_CD=0	1585	export CDROM_CURRENT_CD=0
1481	cdrom_load_next_cd	1586	cdrom_load_next_cd
1482	}	1587	}
1483		1588
1484	# this is only used when you need access to more than one cd.	1589	# @FUNCTION: cdrom_load_next_cd
1485	# when you have finished using the first cd, just call this function.	1590	# @DESCRIPTION:
1486	# when it returns, CDROM_ROOT will be pointing to the second cd.	1591	# Some packages are so big they come on multiple CDs. When you're done reading
1487	# remember, you can only go forward in the cd chain, you can't go back.	1592	# files off a CD and want access to the next one, just call this function.
		1593	# Again, all the messy details of user interaction are taken care of for you.
		1594	# Once this returns, just read the variable CDROM_ROOT for the location of the
		1595	# mounted CD. Note that you can only go forward in the CD list, so make sure
		1596	# you only call this function when you're done using the current CD.
1488	cdrom_load_next_cd() {	1597	cdrom_load_next_cd() {
1489	export CDROM_CURRENT_CD=$((CDROM_CURRENT_CD + 1))
1490	local var=	1598	local var
1491		1599	((++CDROM_CURRENT_CD))
1492	if [[ ! -z ${CD_ROOT} ]] ; then
1493	einfo "Using same root as before for CD #${CDROM_CURRENT_CD}"
1494	return
1495	fi
1496		1600
1497	unset CDROM_ROOT	1601	unset CDROM_ROOT
1498	var=CDROM_ROOTS_${CDROM_CURRENT_CD}	1602	var=CD_ROOT_${CDROM_CURRENT_CD}
		1603	[[ -z ${!var} ]] && var="CD_ROOT"
1499	if [[ -z ${!var} ]] ; then	1604	if [[ -z ${!var} ]] ; then
1500	var="CDROM_CHECK_${CDROM_CURRENT_CD}"	1605	var="CDROM_CHECK_${CDROM_CURRENT_CD}"
1501	cdrom_locate_file_on_cd ${!var}	1606	_cdrom_locate_file_on_cd ${!var}
1502	else	1607	else
1503	export CDROM_ROOT=${!var}	1608	export CDROM_ROOT=${!var}
1504	fi	1609	fi
1505		1610
1506	einfo "Found CD #${CDROM_CURRENT_CD} root at ${CDROM_ROOT}"	1611	einfo "Found CD #${CDROM_CURRENT_CD} root at ${CDROM_ROOT}"
…		…
1511	# all it does is try to locate a give file on a cd ... if the cd isn't	1616	# all it does is try to locate a give file on a cd ... if the cd isn't
1512	# found, then a message asking for the user to insert the cdrom will be	1617	# found, then a message asking for the user to insert the cdrom will be
1513	# displayed and we'll hang out here until:	1618	# displayed and we'll hang out here until:
1514	# (1) the file is found on a mounted cdrom	1619	# (1) the file is found on a mounted cdrom
1515	# (2) the user hits CTRL+C	1620	# (2) the user hits CTRL+C
1516	cdrom_locate_file_on_cd() {	1621	_cdrom_locate_file_on_cd() {
		1622	local mline=""
		1623	local showedmsg=0 showjolietmsg=0
		1624
1517	while [[ -z ${CDROM_ROOT} ]] ; do	1625	while [[ -z ${CDROM_ROOT} ]] ; do
		1626	local i=0
		1627	local -a cdset=(${*//:/ })
		1628	if [[ -n ${CDROM_SET} ]] ; then
		1629	cdset=(${cdset[${CDROM_SET}]})
		1630	fi
		1631
		1632	while [[ -n ${cdset[${i}]} ]] ; do
1518	local dir="$(dirname ${@})"	1633	local dir=$(dirname ${cdset[${i}]})
1519	local file="$(basename ${@})"	1634	local file=$(basename ${cdset[${i}]})
1520	local mline=""
1521	local showedmsg=0
1522		1635
1523	for mline in $(mount \| egrep -e '(iso\|cdrom)' \| awk '{print $3}') ; do	1636	local point= node= fs= foo=
		1637	while read point node fs foo ; do
		1638	[[ " cd9660 iso9660 udf " != " ${fs} " ]] && \
		1639	! [[ ${fs} == "subfs" && ",${opts}," == ",fs=cdfss," ]] \
		1640	&& continue
		1641	point=${point//\040/ }
1524	[[ -d ${mline}/${dir} ]] \|\| continue	1642	[[ ! -d ${point}/${dir} ]] && continue
1525	[[ ! -z $(find ${mline}/${dir} -iname ${file} -maxdepth 1) ]] \	1643	[[ -z $(find "${point}/${dir}" -maxdepth 1 -iname "${file}") ]] && continue
1526	&& export CDROM_ROOT=${mline}	1644	export CDROM_ROOT=${point}
		1645	export CDROM_SET=${i}
		1646	export CDROM_MATCH=${cdset[${i}]}
		1647	return
		1648	done <<< "$(get_mounts)"
		1649
		1650	((++i))
1527	done	1651	done
1528		1652
1529	if [[ -z ${CDROM_ROOT} ]] ; then
1530	echo	1653	echo
1531	if [[ ${showedmsg} -eq 0 ]] ; then	1654	if [[ ${showedmsg} -eq 0 ]] ; then
1532	if [[ ${CDROM_TOTAL_CDS} -eq 1 ]] ; then	1655	if [[ ${CDROM_TOTAL_CDS} -eq 1 ]] ; then
1533	if [[ -z ${CDROM_NAME} ]] ; then	1656	if [[ -z ${CDROM_NAME} ]] ; then
1534	einfo "Please insert the cdrom for ${PN} now !"	1657	einfo "Please insert+mount the cdrom for ${PN} now !"
1535	else
1536	einfo "Please insert the ${CDROM_NAME} cdrom now !"
1537	fi
1538	else	1658	else
1539	if [[ -z ${CDROM_NAME_1} ]] ; then
1540	einfo "Please insert cd #${CDROM_CURRENT_CD} for ${PN} now !"
1541	else
1542	local var="CDROM_NAME_${CDROM_CURRENT_CD}"
1543	einfo "Please insert+mount the ${!var} cdrom now !"	1659	einfo "Please insert+mount the ${CDROM_NAME} cdrom now !"
1544	fi
1545	fi	1660	fi
1546	showedmsg=1	1661	else
		1662	if [[ -z ${CDROM_NAME_1} ]] ; then
		1663	einfo "Please insert+mount cd #${CDROM_CURRENT_CD} for ${PN} now !"
		1664	else
		1665	local var="CDROM_NAME_${CDROM_CURRENT_CD}"
		1666	einfo "Please insert+mount the ${!var} cdrom now !"
		1667	fi
1547	fi	1668	fi
		1669	showedmsg=1
		1670	fi
1548	einfo "Press return to scan for the cd again"	1671	einfo "Press return to scan for the cd again"
1549	einfo "or hit CTRL+C to abort the emerge."	1672	einfo "or hit CTRL+C to abort the emerge."
1550	read	1673	echo
		1674	if [[ ${showjolietmsg} -eq 0 ]] ; then
		1675	showjolietmsg=1
		1676	else
		1677	ewarn "If you are having trouble with the detection"
		1678	ewarn "of your CD, it is possible that you do not have"
		1679	ewarn "Joliet support enabled in your kernel. Please"
		1680	ewarn "check that CONFIG_JOLIET is enabled in your kernel."
		1681	ebeep 5
1551	fi	1682	fi
		1683	read \|\| die "something is screwed with your system"
1552	done	1684	done
1553	}	1685	}
1554		1686
		1687	# @FUNCTION: strip-linguas
		1688	# @USAGE: [<allow LINGUAS>\|<-i\|-u> <directories of .po files>]
		1689	# @DESCRIPTION:
1555	# Make sure that LINGUAS only contains languages that	1690	# Make sure that LINGUAS only contains languages that
1556	# a package can support	1691	# a package can support. The first form allows you to
1557	#	1692	# specify a list of LINGUAS. The -i builds a list of po
1558	# usage: strip-linguas <allow LINGUAS>	1693	# files found in all the directories and uses the
1559	# strip-linguas -i <directories of .po files>	1694	# intersection of the lists. The -u builds a list of po
1560	# strip-linguas -u <directories of .po files>	1695	# files found in all the directories and uses the union
1561	#	1696	# of the lists.
1562	# The first form allows you to specify a list of LINGUAS.
1563	# The -i builds a list of po files found in all the
1564	# directories and uses the intersection of the lists.
1565	# The -u builds a list of po files found in all the
1566	# directories and uses the union of the lists.
1567	strip-linguas() {	1697	strip-linguas() {
1568	local ls newls	1698	local ls newls nols
1569	if [[ $1 == "-i" ]] \|\| [[ $1 == "-u" ]] ; then	1699	if [[ $1 == "-i" ]] \|\| [[ $1 == "-u" ]] ; then
1570	local op=$1; shift	1700	local op=$1; shift
1571	ls=" $(find "$1" -name '*.po' -printf '%f ') "; shift	1701	ls=$(find "$1" -name '*.po' -exec basename {} .po ';'); shift
1572	local d f	1702	local d f
1573	for d in "$@" ; do	1703	for d in "$@" ; do
1574	if [[ ${op} == "-u" ]] ; then	1704	if [[ ${op} == "-u" ]] ; then
1575	newls=${ls}	1705	newls=${ls}
1576	else	1706	else
1577	newls=""	1707	newls=""
1578	fi	1708	fi
1579	for f in $(find "$d" -name '*.po' -printf '%f ') ; do	1709	for f in $(find "$d" -name '*.po' -exec basename {} .po ';') ; do
1580	if [[ ${op} == "-i" ]] ; then	1710	if [[ ${op} == "-i" ]] ; then
1581	[[ ${ls/ ${f} /} != ${ls} ]] && newls="${newls} ${f}"	1711	hasq ${f} ${ls} && newls="${newls} ${f}"
1582	else	1712	else
1583	[[ ${ls/ ${f} /} == ${ls} ]] && newls="${newls} ${f}"	1713	hasq ${f} ${ls} \|\| newls="${newls} ${f}"
1584	fi	1714	fi
1585	done	1715	done
1586	ls=${newls}	1716	ls=${newls}
1587	done	1717	done
1588	ls=${ls//.po}
1589	else	1718	else
1590	ls=$@	1719	ls="$@"
1591	fi	1720	fi
1592		1721
1593	ls=" ${ls} "	1722	nols=""
1594	newls=""	1723	newls=""
1595	for f in ${LINGUAS} ; do	1724	for f in ${LINGUAS} ; do
1596	if [[ ${ls/ ${f} /} != ${ls} ]] ; then	1725	if hasq ${f} ${ls} ; then
1597	newls="${newls} ${f}"	1726	newls="${newls} ${f}"
1598	else	1727	else
1599	ewarn "Sorry, but ${PN} does not support the ${f} LINGUA"	1728	nols="${nols} ${f}"
1600	fi	1729	fi
1601	done	1730	done
1602	if [[ -z ${newls} ]] ; then	1731	[[ -n ${nols} ]] \
1603	unset LINGUAS	1732	&& ewarn "Sorry, but ${PN} does not support the LINGUAS:" ${nols}
1604	else
1605	export LINGUAS=${newls:1}	1733	export LINGUAS=${newls:1}
1606	fi
1607	}	1734	}
1608		1735
1609	# moved from kernel.eclass since they are generally useful outside of	1736	# @FUNCTION: preserve_old_lib
1610	# kernel.eclass -iggy (20041002)	1737	# @USAGE: <libs to preserve> [more libs]
1611		1738	# @DESCRIPTION:
1612	# the following functions are useful in kernel module ebuilds, etc.
1613	# for an example see ivtv or drbd ebuilds
1614
1615	# set's ARCH to match what the kernel expects
1616	set_arch_to_kernel() {
1617	i=10
1618	while ((i--)) ; do
1619	ewarn "PLEASE UPDATE TO YOUR PACKAGE TO USE linux-info.eclass"
1620	done
1621	export EUTILS_ECLASS_PORTAGE_ARCH="${ARCH}"
1622	case ${ARCH} in
1623	x86) export ARCH="i386";;
1624	amd64) export ARCH="x86_64";;
1625	hppa) export ARCH="parisc";;
1626	mips) export ARCH="mips";;
1627	sparc) export ARCH="$(tc-arch-kernel)";; # Yeah this is ugly, but it's even WORSE if you don't do this. linux-info.eclass's set_arch_to_kernel is fixed, but won't get used over this one!
1628	*) export ARCH="${ARCH}";;
1629	esac
1630	}
1631
1632	# set's ARCH back to what portage expects
1633	set_arch_to_portage() {
1634	i=10
1635	while ((i--)) ; do
1636	ewarn "PLEASE UPDATE TO YOUR PACKAGE TO USE linux-info.eclass"
1637	done
1638	export ARCH="${EUTILS_ECLASS_PORTAGE_ARCH}"
1639	}
1640
1641	# Jeremy Huddleston <eradicator@gentoo.org>:
1642	# preserve_old_lib /path/to/libblah.so.0
1643	# preserve_old_lib_notify /path/to/libblah.so.0
1644	#
1645	# These functions are useful when a lib in your package changes --soname. Such	1739	# These functions are useful when a lib in your package changes ABI SONAME.
1646	# an example might be from libogg.so.0 to libogg.so.1. Removing libogg.so.0	1740	# An example might be from libogg.so.0 to libogg.so.1. Removing libogg.so.0
1647	# would break packages that link against it. Most people get around this	1741	# would break packages that link against it. Most people get around this
1648	# by using the portage SLOT mechanism, but that is not always a relevant	1742	# by using the portage SLOT mechanism, but that is not always a relevant
1649	# solution, so instead you can add the following to your ebuilds:	1743	# solution, so instead you can call this from pkg_preinst. See also the
1650	#	1744	# preserve_old_lib_notify function.
1651	# src_install() {
1652	# ...
1653	# preserve_old_lib /usr/$(get_libdir)/libogg.so.0
1654	# ...
1655	# }
1656	#
1657	# pkg_postinst() {
1658	# ...
1659	# preserve_old_lib_notify /usr/$(get_libdir)/libogg.so.0
1660	# ...
1661	# }
1662
1663	preserve_old_lib() {	1745	preserve_old_lib() {
1664	LIB=$1	1746	if [[ ${EBUILD_PHASE} != "preinst" ]] ; then
		1747	eerror "preserve_old_lib() must be called from pkg_preinst() only"
		1748	die "Invalid preserve_old_lib() usage"
		1749	fi
		1750	[[ -z $1 ]] && die "Usage: preserve_old_lib <library to preserve> [more libraries to preserve]"
1665		1751
1666	if [ -n "${LIB}" -a -f "${ROOT}${LIB}" ]; then	1752	# let portage worry about it
1667	SONAME=`basename ${LIB}`	1753	has preserve-libs ${FEATURES} && return 0
1668	DIRNAME=`dirname ${LIB}`
1669		1754
1670	dodir ${DIRNAME}	1755	local lib dir
1671	cp ${ROOT}${LIB} ${D}${DIRNAME}	1756	for lib in "$@" ; do
		1757	[[ -e ${ROOT}/${lib} ]] \|\| continue
		1758	dir=${lib%/*}
		1759	dodir ${dir} \|\| die "dodir ${dir} failed"
		1760	cp "${ROOT}"/${lib} "${D}"/${lib} \|\| die "cp ${lib} failed"
1672	touch ${D}${LIB}	1761	touch "${D}"/${lib}
1673	fi	1762	done
1674	}	1763	}
1675		1764
		1765	# @FUNCTION: preserve_old_lib_notify
		1766	# @USAGE: <libs to notify> [more libs]
		1767	# @DESCRIPTION:
		1768	# Spit helpful messages about the libraries preserved by preserve_old_lib.
1676	preserve_old_lib_notify() {	1769	preserve_old_lib_notify() {
1677	LIB=$1	1770	if [[ ${EBUILD_PHASE} != "postinst" ]] ; then
		1771	eerror "preserve_old_lib_notify() must be called from pkg_postinst() only"
		1772	die "Invalid preserve_old_lib_notify() usage"
		1773	fi
1678		1774
1679	if [ -n "${LIB}" -a -f "${ROOT}${LIB}" ]; then	1775	# let portage worry about it
1680	SONAME=`basename ${LIB}`	1776	has preserve-libs ${FEATURES} && return 0
1681		1777
		1778	local lib notice=0
		1779	for lib in "$@" ; do
		1780	[[ -e ${ROOT}/${lib} ]] \|\| continue
		1781	if [[ ${notice} -eq 0 ]] ; then
		1782	notice=1
1682	einfo "An old version of an installed library was detected on your system."	1783	ewarn "Old versions of installed libraries were detected on your system."
1683	einfo "In order to avoid breaking packages that link against is, this older version"	1784	ewarn "In order to avoid breaking packages that depend on these old libs,"
1684	einfo "is not being removed. In order to make full use of this newer version,"	1785	ewarn "the libraries are not being removed. You need to run revdep-rebuild"
1685	einfo "you will need to execute the following command:"	1786	ewarn "in order to remove these old dependencies. If you do not have this"
1686	einfo " revdep-rebuild --soname ${SONAME}"	1787	ewarn "helper program, simply emerge the 'gentoolkit' package."
1687	einfo	1788	ewarn
1688	einfo "After doing that, you can safely remove ${LIB}"
1689	einfo "Note: 'emerge gentoolkit' to get revdep-rebuild"
1690	fi	1789	fi
		1790	ewarn " # revdep-rebuild --library ${lib##*/}"
		1791	done
		1792	if [[ ${notice} -eq 1 ]] ; then
		1793	ewarn
		1794	ewarn "Once you've finished running revdep-rebuild, it should be safe to"
		1795	ewarn "delete the old libraries. Here is a copy & paste for the lazy:"
		1796	for lib in "$@" ; do
		1797	ewarn " # rm '${lib}'"
		1798	done
		1799	fi
1691	}	1800	}
1692		1801
1693	# Hack for people to figure out if a package was built with	1802	# @FUNCTION: built_with_use
1694	# certain USE flags	1803	# @USAGE: [--hidden] [--missing <action>] [-a\|-o] <DEPEND ATOM> <List of USE flags>
		1804	# @DESCRIPTION:
1695	#	1805	#
1696	# Usage: built_with_use [-a\|-o] <DEPEND ATOM> <List of USE flags>	1806	# Deprecated: Use EAPI 2 use deps in DEPEND\|RDEPEND and with has_version calls.
1697	# ex: built_with_use xchat gtk2
1698	#	1807	#
1699	# Flags: -a all USE flags should be utilized	1808	# A temporary hack until portage properly supports DEPENDing on USE
1700	# -o at least one USE flag should be utilized	1809	# flags being enabled in packages. This will check to see if the specified
1701	# Note: the default flag is '-a'	1810	# DEPEND atom was built with the specified list of USE flags. The
		1811	# --missing option controls the behavior if called on a package that does
		1812	# not actually support the defined USE flags (aka listed in IUSE).
		1813	# The default is to abort (call die). The -a and -o flags control
		1814	# the requirements of the USE flags. They correspond to "and" and "or"
		1815	# logic. So the -a flag means all listed USE flags must be enabled
		1816	# while the -o flag means at least one of the listed IUSE flags must be
		1817	# enabled. The --hidden option is really for internal use only as it
		1818	# means the USE flag we're checking is hidden expanded, so it won't be found
		1819	# in IUSE like normal USE flags.
		1820	#
		1821	# Remember that this function isn't terribly intelligent so order of optional
		1822	# flags matter.
1702	built_with_use() {	1823	built_with_use() {
		1824	local hidden="no"
		1825	if [[ $1 == "--hidden" ]] ; then
		1826	hidden="yes"
		1827	shift
		1828	fi
		1829
		1830	local missing_action="die"
		1831	if [[ $1 == "--missing" ]] ; then
		1832	missing_action=$2
		1833	shift ; shift
		1834	case ${missing_action} in
		1835	true\|false\|die) ;;
		1836	*) die "unknown action '${missing_action}'";;
		1837	esac
		1838	fi
		1839
1703	local opt=$1	1840	local opt=$1
1704	[[ ${opt:0:1} = "-" ]] && shift \|\| opt="-a"	1841	[[ ${opt:0:1} = "-" ]] && shift \|\| opt="-a"
1705		1842
1706	local PKG=$(best_version $1)	1843	local PKG=$(best_version $1)
		1844	[[ -z ${PKG} ]] && die "Unable to resolve $1 to an installed package"
1707	shift	1845	shift
1708		1846
1709	local USEFILE="${ROOT}/var/db/pkg/${PKG}/USE"	1847	local USEFILE=${ROOT}/var/db/pkg/${PKG}/USE
1710	[[ ! -e ${USEFILE} ]] && return 1	1848	local IUSEFILE=${ROOT}/var/db/pkg/${PKG}/IUSE
		1849
		1850	# if the IUSE file doesn't exist, the read will error out, we need to handle
		1851	# this gracefully
		1852	if [[ ! -e ${USEFILE} ]] \|\| [[ ! -e ${IUSEFILE} && ${hidden} == "no" ]] ; then
		1853	case ${missing_action} in
		1854	true) return 0;;
		1855	false) return 1;;
		1856	die) die "Unable to determine what USE flags $PKG was built with";;
		1857	esac
		1858	fi
		1859
		1860	if [[ ${hidden} == "no" ]] ; then
		1861	local IUSE_BUILT=( $(<"${IUSEFILE}") )
		1862	# Don't check USE_EXPAND #147237
		1863	local expand
		1864	for expand in $(echo ${USE_EXPAND} \| tr '[:upper:]' '[:lower:]') ; do
		1865	if [[ $1 == ${expand}_* ]] ; then
		1866	expand=""
		1867	break
		1868	fi
		1869	done
		1870	if [[ -n ${expand} ]] ; then
		1871	if ! has $1 ${IUSE_BUILT[@]#[-+]} ; then
		1872	case ${missing_action} in
		1873	true) return 0;;
		1874	false) return 1;;
		1875	die) die "$PKG does not actually support the $1 USE flag!";;
		1876	esac
		1877	fi
		1878	fi
		1879	fi
1711		1880
1712	local USE_BUILT=$(<${USEFILE})	1881	local USE_BUILT=$(<${USEFILE})
1713	while [[ $# -gt 0 ]] ; do	1882	while [[ $# -gt 0 ]] ; do
1714	if [[ ${opt} = "-o" ]] ; then	1883	if [[ ${opt} = "-o" ]] ; then
1715	has $1 ${USE_BUILT} && return 0	1884	has $1 ${USE_BUILT} && return 0
…		…
1719	shift	1888	shift
1720	done	1889	done
1721	[[ ${opt} = "-a" ]]	1890	[[ ${opt} = "-a" ]]
1722	}	1891	}
1723		1892
		1893	# @FUNCTION: epunt_cxx
		1894	# @USAGE: [dir to scan]
		1895	# @DESCRIPTION:
1724	# Many configure scripts wrongly bail when a C++ compiler	1896	# Many configure scripts wrongly bail when a C++ compiler could not be
1725	# could not be detected. #73450	1897	# detected. If dir is not specified, then it defaults to ${S}.
		1898	#
		1899	# http://bugs.gentoo.org/73450
1726	epunt_cxx() {	1900	epunt_cxx() {
1727	local dir=$1	1901	local dir=$1
1728	[[ -z ${dir} ]] && dir=${S}	1902	[[ -z ${dir} ]] && dir=${S}
1729	ebegin "Removing useless C++ checks"	1903	ebegin "Removing useless C++ checks"
1730	local f	1904	local f
1731	for f in $(find ${dir} -name configure) ; do	1905	find "${dir}" -name configure \| while read f ; do
1732	patch -p0 "${f}" "${PORTDIR}/eclass/ELT-patches/nocxx/nocxx.patch" > /dev/null	1906	patch --no-backup-if-mismatch -p0 "${f}" "${PORTDIR}/eclass/ELT-patches/nocxx/nocxx.patch" > /dev/null
1733	done	1907	done
1734	eend 0	1908	eend 0
1735	}	1909	}
1736		1910
1737	# dopamd <file> [more files]	1911	# @FUNCTION: make_wrapper
1738	#	1912	# @USAGE: <wrapper> <target> [chdir] [libpaths] [installpath]
1739	# Install pam auth config file in /etc/pam.d	1913	# @DESCRIPTION:
1740	dopamd() {	1914	# Create a shell wrapper script named wrapper in installpath
1741	[[ -z $1 ]] && die "dopamd requires at least one argument"	1915	# (defaults to the bindir) to execute target (default of wrapper) by
1742		1916	# first optionally setting LD_LIBRARY_PATH to the colon-delimited
1743	use pam \|\| return 0	1917	# libpaths followed by optionally changing directory to chdir.
1744
1745	insinto /etc/pam.d
1746	doins "$@" \|\| die "failed to install $@"
1747	}
1748	# newpamd <old name> <new name>
1749	#
1750	# Install pam file <old name> as <new name> in /etc/pam.d
1751	newpamd() {
1752	[[ $# -ne 2 ]] && die "newpamd requires two arguements"
1753
1754	use pam \|\| return 0
1755
1756	insinto /etc/pam.d
1757	newins "$1" "$2" \|\| die "failed to install $1 as $2"
1758	}
1759
1760	# make a wrapper script ...
1761	# NOTE: this was originally games_make_wrapper, but I noticed other places where
1762	# this could be used, so I have moved it here and made it not games-specific
1763	# -- wolf31o2
1764	# $1 == wrapper name
1765	# $2 == binary to run
1766	# $3 == directory to chdir before running binary
1767	# $4 == extra LD_LIBRARY_PATH's (make it : delimited)
1768	make_wrapper() {	1918	make_wrapper() {
1769	local wrapper=$1 bin=$2 chdir=$3 libdir=$4	1919	local wrapper=$1 bin=$2 chdir=$3 libdir=$4 path=$5
1770	local tmpwrapper=$(emktemp)	1920	local tmpwrapper=$(emktemp)
		1921	# We don't want to quote ${bin} so that people can pass complex
		1922	# things as $bin ... "./someprog --args"
1771	cat << EOF > "${tmpwrapper}"	1923	cat << EOF > "${tmpwrapper}"
1772	#!/bin/sh	1924	#!/bin/sh
1773	cd "${chdir}"	1925	cd "${chdir:-.}"
		1926	if [ -n "${libdir}" ] ; then
		1927	if [ "\${LD_LIBRARY_PATH+set}" = "set" ] ; then
1774	export LD_LIBRARY_PATH="\${LD_LIBRARY_PATH}:${libdir}"	1928	export LD_LIBRARY_PATH="\${LD_LIBRARY_PATH}:${libdir}"
		1929	else
		1930	export LD_LIBRARY_PATH="${libdir}"
		1931	fi
		1932	fi
1775	exec ${bin} "\$@"	1933	exec ${bin} "\$@"
1776	EOF	1934	EOF
1777	chmod go+rx "${tmpwrapper}"	1935	chmod go+rx "${tmpwrapper}"
		1936	if [[ -n ${path} ]] ; then
		1937	(
		1938	exeinto "${path}"
1778	newbin "${tmpwrapper}" "${wrapper}"	1939	newexe "${tmpwrapper}" "${wrapper}"
		1940	) \|\| die
		1941	else
		1942	newbin "${tmpwrapper}" "${wrapper}" \|\| die
		1943	fi
1779	}	1944	}
		1945
		1946	# @FUNCTION: prepalldocs
		1947	# @USAGE:
		1948	# @DESCRIPTION:
		1949	# Compress files in /usr/share/doc which are not already
		1950	# compressed, excluding /usr/share/doc/${PF}/html.
		1951	# Uses the ecompressdir to do the compression.
		1952	# 2009-02-18 by betelgeuse:
		1953	# Commented because ecompressdir is even more internal to
		1954	# Portage than prepalldocs (it's not even mentioned in man 5
		1955	# ebuild). Please submit a better version for review to gentoo-dev
		1956	# if you want prepalldocs here.
		1957	#prepalldocs() {
		1958	# if [[ -n $1 ]] ; then
		1959	# ewarn "prepalldocs: invalid usage; takes no arguments"
		1960	# fi
		1961
		1962	# cd "${D}"
		1963	# [[ -d usr/share/doc ]] \|\| return 0
		1964
		1965	# find usr/share/doc -exec gzip {} +
		1966	# ecompressdir --ignore /usr/share/doc/${PF}/html
		1967	# ecompressdir --queue /usr/share/doc
		1968	#}

 Legend:



Removed from v.1.163
 


changed lines


 
Added in v.1.349
 Legend:



Removed from v.1.163
 


changed lines


 
Added in v.1.349
-Removed from v.1.163
+Added in v.1.349

	ViewVC Help
Powered by ViewVC 1.1.13