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

Diff of /eclass/eutils.eclass

Parent Directory | Revision Log | View Patch Patch

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

 Legend:



Removed from v.1.49
 


changed lines


 
Added in v.1.349
 Legend:



Removed from v.1.49
 


changed lines


 
Added in v.1.349
-Removed from v.1.49
+Added in v.1.349

	ViewVC Help
Powered by ViewVC 1.1.13