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

Diff of /eclass/eutils.eclass

Parent Directory | Revision Log | View Patch Patch

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

 Legend:



Removed from v.1.69
 


changed lines


 
Added in v.1.333
 Legend:



Removed from v.1.69
 


changed lines


 
Added in v.1.333
-Removed from v.1.69
+Added in v.1.333

	ViewVC Help
Powered by ViewVC 1.1.13