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

Diff of /eclass/eutils.eclass

Parent Directory | Revision Log | View Patch Patch

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

 Legend:



Removed from v.1.195
 


changed lines


 
Added in v.1.334
 Legend:



Removed from v.1.195
 


changed lines


 
Added in v.1.334
-Removed from v.1.195
+Added in v.1.334

	ViewVC Help
Powered by ViewVC 1.1.20