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

Diff of /eclass/eutils.eclass

Parent Directory | Revision Log | View Patch Patch

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

 Legend:



Removed from v.1.56
 


changed lines


 
Added in v.1.360
 Legend:



Removed from v.1.56
 


changed lines


 
Added in v.1.360
-Removed from v.1.56
+Added in v.1.360

	ViewVC Help
Powered by ViewVC 1.1.20