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

Diff of /eclass/eutils.eclass

Parent Directory | Revision Log | View Patch Patch

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

 Legend:



Removed from v.1.214
 


changed lines


 
Added in v.1.334
 Legend:



Removed from v.1.214
 


changed lines


 
Added in v.1.334
-Removed from v.1.214
+Added in v.1.334

	ViewVC Help
Powered by ViewVC 1.1.13