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

Diff of /eclass/eutils.eclass

Parent Directory | Revision Log | View Patch Patch

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

 Legend:



Removed from v.1.184
 


changed lines


 
Added in v.1.363
 Legend:



Removed from v.1.184
 


changed lines


 
Added in v.1.363
-Removed from v.1.184
+Added in v.1.363

	ViewVC Help
Powered by ViewVC 1.1.20