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

Diff of /eclass/eutils.eclass

Parent Directory | Revision Log | View Patch Patch

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

 Legend:



Removed from v.1.228
 


changed lines


 
Added in v.1.398
 Legend:



Removed from v.1.228
 


changed lines


 
Added in v.1.398
-Removed from v.1.228
+Added in v.1.398

	ViewVC Help
Powered by ViewVC 1.1.20