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

Diff of /eclass/eutils.eclass

Parent Directory | Revision Log | View Patch Patch

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

 Legend:



Removed from v.1.143
 


changed lines


 
Added in v.1.383
 Legend:



Removed from v.1.143
 


changed lines


 
Added in v.1.383
-Removed from v.1.143
+Added in v.1.383

	ViewVC Help
Powered by ViewVC 1.1.13