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

Diff of /eclass/eutils.eclass

Parent Directory | Revision Log | View Patch Patch

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

 Legend:



Removed from v.1.215
 


changed lines


 
Added in v.1.373
 Legend:



Removed from v.1.215
 


changed lines


 
Added in v.1.373
-Removed from v.1.215
+Added in v.1.373

	ViewVC Help
Powered by ViewVC 1.1.20