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

Diff of /eclass/eutils.eclass

Parent Directory | Revision Log | View Patch Patch

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

 Legend:



Removed from v.1.182
 


changed lines


 
Added in v.1.372
 Legend:



Removed from v.1.182
 


changed lines


 
Added in v.1.372
-Removed from v.1.182
+Added in v.1.372

	ViewVC Help
Powered by ViewVC 1.1.20