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

Diff of /eclass/eutils.eclass

Parent Directory | Revision Log | View Patch Patch

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

 Legend:



Removed from v.1.209
 


changed lines


 
Added in v.1.363
 Legend:



Removed from v.1.209
 


changed lines


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

	ViewVC Help
Powered by ViewVC 1.1.20