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

Diff of /eclass/eutils.eclass

Parent Directory | Revision Log | View Patch Patch

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

 Legend:



Removed from v.1.228
 


changed lines


 
Added in v.1.374
 Legend:



Removed from v.1.228
 


changed lines


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

	ViewVC Help
Powered by ViewVC 1.1.20