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

Diff of /eclass/eutils.eclass

Parent Directory | Revision Log | View Patch Patch

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

 Legend:



Removed from v.1.71
 


changed lines


 
Added in v.1.357
 Legend:



Removed from v.1.71
 


changed lines


 
Added in v.1.357
-Removed from v.1.71
+Added in v.1.357

	ViewVC Help
Powered by ViewVC 1.1.20