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

Diff of /eclass/eutils.eclass

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

Revision 1.340 Revision 1.386
1# Copyright 1999-2009 Gentoo Foundation 1# Copyright 1999-2012 Gentoo Foundation
2# Distributed under the terms of the GNU General Public License v2 2# Distributed under the terms of the GNU General Public License v2
3# $Header: /var/cvsroot/gentoo-x86/eclass/eutils.eclass,v 1.340 2010/03/07 03:00:08 vapier Exp $ 3# $Header: /var/cvsroot/gentoo-x86/eclass/eutils.eclass,v 1.386 2012/03/01 22:10:50 naota Exp $
4 4
5# @ECLASS: eutils.eclass 5# @ECLASS: eutils.eclass
6# @MAINTAINER: 6# @MAINTAINER:
7# base-system@gentoo.org 7# base-system@gentoo.org
8# @BLURB: many extra (but common) functions that are used in ebuilds 8# @BLURB: many extra (but common) functions that are used in ebuilds
13# home rather than having multiple ebuilds implementing the same thing. 13# home rather than having multiple ebuilds implementing the same thing.
14# 14#
15# Due to the nature of this eclass, some functions may have maintainers 15# Due to the nature of this eclass, some functions may have maintainers
16# different from the overall eclass! 16# different from the overall eclass!
17 17
18inherit multilib portability 18if [[ ${___ECLASS_ONCE_EUTILS} != "recur -_+^+_- spank" ]] ; then
19___ECLASS_ONCE_EUTILS="recur -_+^+_- spank"
20
21inherit multilib user
19 22
20DESCRIPTION="Based on the ${ECLASS} eclass" 23DESCRIPTION="Based on the ${ECLASS} eclass"
21 24
22if has "${EAPI:-0}" 0 1 2; then 25if has "${EAPI:-0}" 0 1 2; then
23 26
61 ewarn "QA Notice: epause is not defined in EAPI=${EAPI}, please file a bug at http://bugs.gentoo.org" 64 ewarn "QA Notice: epause is not defined in EAPI=${EAPI}, please file a bug at http://bugs.gentoo.org"
62} 65}
63 66
64fi 67fi
65 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.
75if ! declare -F eqawarn >/dev/null ; then
76 eqawarn() {
77 has qa ${PORTAGE_ELOG_CLASSES} && ewarn "$@"
78 :
79 }
80fi
81
66# @FUNCTION: ecvs_clean 82# @FUNCTION: ecvs_clean
67# @USAGE: [list of dirs] 83# @USAGE: [list of dirs]
68# @DESCRIPTION: 84# @DESCRIPTION:
69# Remove CVS directories recursiveley. Useful when a source tarball contains 85# Remove CVS directories recursiveley. Useful when a source tarball contains
70# internal CVS directories. Defaults to $PWD. 86# internal CVS directories. Defaults to $PWD.
82esvn_clean() { 98esvn_clean() {
83 [[ -z $* ]] && set -- . 99 [[ -z $* ]] && set -- .
84 find "$@" -type d -name '.svn' -prune -print0 | xargs -0 rm -rf 100 find "$@" -type d -name '.svn' -prune -print0 | xargs -0 rm -rf
85} 101}
86 102
103# @FUNCTION: estack_push
104# @USAGE: <stack> [items to push]
105# @DESCRIPTION:
106# Push any number of items onto the specified stack. Pick a name that
107# is a valid variable (i.e. stick to alphanumerics), and push as many
108# items as you like onto the stack at once.
109#
110# The following code snippet will echo 5, then 4, then 3, then ...
111# @CODE
112# estack_push mystack 1 2 3 4 5
113# while estack_pop mystack i ; do
114# echo "${i}"
115# done
116# @CODE
117estack_push() {
118 [[ $# -eq 0 ]] && die "estack_push: incorrect # of arguments"
119 local stack_name="__ESTACK_$1__" ; shift
120 eval ${stack_name}+=\( \"\$@\" \)
121}
122
123# @FUNCTION: estack_pop
124# @USAGE: <stack> [variable]
125# @DESCRIPTION:
126# Pop a single item off the specified stack. If a variable is specified,
127# the popped item is stored there. If no more items are available, return
128# 1, else return 0. See estack_push for more info.
129estack_pop() {
130 [[ $# -eq 0 || $# -gt 2 ]] && die "estack_pop: incorrect # of arguments"
131
132 # We use the fugly __estack_xxx var names to avoid collision with
133 # passing back the return value. If we used "local i" and the
134 # caller ran `estack_pop ... i`, we'd end up setting the local
135 # copy of "i" rather than the caller's copy. The __estack_xxx
136 # garbage is preferable to using $1/$2 everywhere as that is a
137 # bit harder to read.
138 local __estack_name="__ESTACK_$1__" ; shift
139 local __estack_retvar=$1 ; shift
140 eval local __estack_i=\${#${__estack_name}\[@\]}
141 # Don't warn -- let the caller interpret this as a failure
142 # or as normal behavior (akin to `shift`)
143 [[ $(( --__estack_i )) -eq -1 ]] && return 1
144
145 if [[ -n ${__estack_retvar} ]] ; then
146 eval ${__estack_retvar}=\"\${${__estack_name}\[${__estack_i}\]}\"
147 fi
148 eval unset ${__estack_name}\[${__estack_i}\]
149}
150
87# @FUNCTION: eshopts_push 151# @FUNCTION: eshopts_push
88# @USAGE: [options to `set` or `shopt`] 152# @USAGE: [options to `set` or `shopt`]
89# @DESCRIPTION: 153# @DESCRIPTION:
90# Often times code will want to enable a shell option to change code behavior. 154# Often times code will want to enable a shell option to change code behavior.
91# Since changing shell options can easily break other pieces of code (which 155# Since changing shell options can easily break other pieces of code (which
96# rather than `set` as there are some options only available via that. 160# rather than `set` as there are some options only available via that.
97# 161#
98# A common example is to disable shell globbing so that special meaning/care 162# A common example is to disable shell globbing so that special meaning/care
99# may be used with variables/arguments to custom functions. That would be: 163# may be used with variables/arguments to custom functions. That would be:
100# @CODE 164# @CODE
101# eshopts_push -o noglob 165# eshopts_push -s noglob
102# for x in ${foo} ; do 166# for x in ${foo} ; do
103# if ...some check... ; then 167# if ...some check... ; then
104# eshopts_pop 168# eshopts_pop
105# return 0 169# return 0
106# fi 170# fi
107# done 171# done
108# eshopts_pop 172# eshopts_pop
109# @CODE 173# @CODE
110eshopts_push() { 174eshopts_push() {
111 # have to assume __ESHOPTS_SAVE__ isn't screwed with
112 # as a `declare -a` here will reset its value
113 local i=${#__ESHOPTS_SAVE__[@]}
114 if [[ $1 == -[su] ]] ; then 175 if [[ $1 == -[su] ]] ; then
115 __ESHOPTS_SAVE__[$i]=$(shopt -p) 176 estack_push eshopts "$(shopt -p)"
116 [[ $# -eq 0 ]] && return 0 177 [[ $# -eq 0 ]] && return 0
117 shopt "$@" || die "eshopts_push: bad options to shopt: $*" 178 shopt "$@" || die "${FUNCNAME}: bad options to shopt: $*"
118 else 179 else
119 __ESHOPTS_SAVE__[$i]=$- 180 estack_push eshopts $-
120 [[ $# -eq 0 ]] && return 0 181 [[ $# -eq 0 ]] && return 0
121 set "$@" || die "eshopts_push: bad options to set: $*" 182 set "$@" || die "${FUNCNAME}: bad options to set: $*"
122 fi 183 fi
123} 184}
124 185
125# @FUNCTION: eshopts_pop 186# @FUNCTION: eshopts_pop
126# @USAGE: 187# @USAGE:
127# @DESCRIPTION: 188# @DESCRIPTION:
128# Restore the shell options to the state saved with the corresponding 189# Restore the shell options to the state saved with the corresponding
129# eshopts_push call. See that function for more details. 190# eshopts_push call. See that function for more details.
130eshopts_pop() { 191eshopts_pop() {
131 [[ $# -ne 0 ]] && die "eshopts_pop takes no arguments" 192 local s
132 local i=$(( ${#__ESHOPTS_SAVE__[@]} - 1 )) 193 estack_pop eshopts s || die "${FUNCNAME}: unbalanced push"
133 [[ ${i} -eq -1 ]] && die "eshopts_{push,pop}: unbalanced pair"
134 local s=${__ESHOPTS_SAVE__[$i]}
135 unset __ESHOPTS_SAVE__[$i]
136 if [[ ${s} == "shopt -"* ]] ; then 194 if [[ ${s} == "shopt -"* ]] ; then
137 eval "${s}" || die "eshopts_pop: sanity: invalid shopt options: ${s}" 195 eval "${s}" || die "${FUNCNAME}: sanity: invalid shopt options: ${s}"
138 else 196 else
139 set +$- || die "eshopts_pop: sanity: invalid shell settings: $-" 197 set +$- || die "${FUNCNAME}: sanity: invalid shell settings: $-"
140 set -${s} || die "eshopts_pop: sanity: unable to restore saved shell settings: ${s}" 198 set -${s} || die "${FUNCNAME}: sanity: unable to restore saved shell settings: ${s}"
141 fi 199 fi
200}
201
202# @FUNCTION: eumask_push
203# @USAGE: <new umask>
204# @DESCRIPTION:
205# Set the umask to the new value specified while saving the previous
206# value onto a stack. Useful for temporarily changing the umask.
207eumask_push() {
208 estack_push eumask "$(umask)"
209 umask "$@" || die "${FUNCNAME}: bad options to umask: $*"
210}
211
212# @FUNCTION: eumask_pop
213# @USAGE:
214# @DESCRIPTION:
215# Restore the previous umask state.
216eumask_pop() {
217 [[ $# -eq 0 ]] || die "${FUNCNAME}: we take no options"
218 local s
219 estack_pop eumask s || die "${FUNCNAME}: unbalanced push"
220 umask ${s} || die "${FUNCNAME}: sanity: could not restore umask: ${s}"
142} 221}
143 222
144# @VARIABLE: EPATCH_SOURCE 223# @VARIABLE: EPATCH_SOURCE
145# @DESCRIPTION: 224# @DESCRIPTION:
146# Default directory to search for patches. 225# Default directory to search for patches.
189# If you do not specify any options, then epatch will default to the directory 268# If you do not specify any options, then epatch will default to the directory
190# specified by EPATCH_SOURCE. 269# specified by EPATCH_SOURCE.
191# 270#
192# When processing directories, epatch will apply all patches that match: 271# When processing directories, epatch will apply all patches that match:
193# @CODE 272# @CODE
194# ${EPATCH_FORCE} == "yes" 273# if ${EPATCH_FORCE} != "yes"
195# ??_${ARCH}_foo.${EPATCH_SUFFIX} 274# ??_${ARCH}_foo.${EPATCH_SUFFIX}
196# else 275# else
197# *.${EPATCH_SUFFIX} 276# *.${EPATCH_SUFFIX}
198# @CODE 277# @CODE
199# The leading ?? are typically numbers used to force consistent patch ordering. 278# The leading ?? are typically numbers used to force consistent patch ordering.
238 local EPATCH_SUFFIX=$1 317 local EPATCH_SUFFIX=$1
239 318
240 elif [[ -d $1 ]] ; then 319 elif [[ -d $1 ]] ; then
241 # Some people like to make dirs of patches w/out suffixes (vim) 320 # Some people like to make dirs of patches w/out suffixes (vim)
242 set -- "$1"/*${EPATCH_SUFFIX:+."${EPATCH_SUFFIX}"} 321 set -- "$1"/*${EPATCH_SUFFIX:+."${EPATCH_SUFFIX}"}
322
323 elif [[ -f ${EPATCH_SOURCE}/$1 ]] ; then
324 # Re-use EPATCH_SOURCE as a search dir
325 epatch "${EPATCH_SOURCE}/$1"
326 return $?
243 327
244 else 328 else
245 # sanity check ... if it isn't a dir or file, wtf man ? 329 # sanity check ... if it isn't a dir or file, wtf man ?
246 [[ $# -ne 0 ]] && EPATCH_SOURCE=$1 330 [[ $# -ne 0 ]] && EPATCH_SOURCE=$1
247 echo 331 echo
278 # ???_arch_foo.patch 362 # ???_arch_foo.patch
279 # Else, skip this input altogether 363 # Else, skip this input altogether
280 local a=${patchname#*_} # strip the ???_ 364 local a=${patchname#*_} # strip the ???_
281 a=${a%%_*} # strip the _foo.patch 365 a=${a%%_*} # strip the _foo.patch
282 if ! [[ ${SINGLE_PATCH} == "yes" || \ 366 if ! [[ ${SINGLE_PATCH} == "yes" || \
283 ${EPATCH_FORCE} == "yes" || \ 367 ${EPATCH_FORCE} == "yes" || \
284 ${a} == all || \ 368 ${a} == all || \
285 ${a} == ${ARCH} ]] 369 ${a} == ${ARCH} ]]
286 then 370 then
287 continue 371 continue
288 fi 372 fi
289 373
290 # Let people filter things dynamically 374 # Let people filter things dynamically
318 local STDERR_TARGET="${T}/${patchname}.out" 402 local STDERR_TARGET="${T}/${patchname}.out"
319 if [[ -e ${STDERR_TARGET} ]] ; then 403 if [[ -e ${STDERR_TARGET} ]] ; then
320 STDERR_TARGET="${T}/${patchname}-$$.out" 404 STDERR_TARGET="${T}/${patchname}-$$.out"
321 fi 405 fi
322 406
323 printf "***** %s *****\n\n" "${patchname}" > "${STDERR_TARGET}" 407 printf "***** %s *****\nPWD: %s\n\n" "${patchname}" "${PWD}" > "${STDERR_TARGET}"
324 408
325 # Decompress the patch if need be 409 # Decompress the patch if need be
326 local count=0 410 local count=0
327 local PATCH_TARGET 411 local PATCH_TARGET
328 if [[ -n ${PIPE_CMD} ]] ; then 412 if [[ -n ${PIPE_CMD} ]] ; then
347 local abs_paths=$(egrep -n '^[-+]{3} /' "${PATCH_TARGET}" | awk '$2 != "/dev/null" { print }') 431 local abs_paths=$(egrep -n '^[-+]{3} /' "${PATCH_TARGET}" | awk '$2 != "/dev/null" { print }')
348 if [[ -n ${abs_paths} ]] ; then 432 if [[ -n ${abs_paths} ]] ; then
349 count=1 433 count=1
350 printf "NOTE: skipping -p0 due to absolute paths in patch:\n%s\n" "${abs_paths}" >> "${STDERR_TARGET}" 434 printf "NOTE: skipping -p0 due to absolute paths in patch:\n%s\n" "${abs_paths}" >> "${STDERR_TARGET}"
351 fi 435 fi
436 # Similar reason, but with relative paths.
437 local rel_paths=$(egrep -n '^[-+]{3} [^ ]*[.][.]/' "${PATCH_TARGET}")
438 if [[ -n ${rel_paths} ]] ; then
439 eqawarn "QA Notice: Your patch uses relative paths '../'."
440 eqawarn " In the future this will cause a failure."
441 eqawarn "${rel_paths}"
442 fi
352 443
353 # Dynamically detect the correct -p# ... i'm lazy, so shoot me :/ 444 # Dynamically detect the correct -p# ... i'm lazy, so shoot me :/
445 local patch_cmd
354 while [[ ${count} -lt 5 ]] ; do 446 while [[ ${count} -lt 5 ]] ; do
447 patch_cmd="${BASH_ALIASES[patch]:-patch} -p${count} ${EPATCH_OPTS}"
448
355 # Generate some useful debug info ... 449 # Generate some useful debug info ...
356 ( 450 (
357 _epatch_draw_line "***** ${patchname} *****" 451 _epatch_draw_line "***** ${patchname} *****"
358 echo 452 echo
359 echo "PATCH COMMAND: patch -p${count} ${EPATCH_OPTS} < '${PATCH_TARGET}'" 453 echo "PATCH COMMAND: ${patch_cmd} < '${PATCH_TARGET}'"
360 echo 454 echo
361 _epatch_draw_line "***** ${patchname} *****" 455 _epatch_draw_line "***** ${patchname} *****"
456 ${patch_cmd} --dry-run -f < "${PATCH_TARGET}" 2>&1
457 ret=$?
458 echo
459 echo "patch program exited with status ${ret}"
460 exit ${ret}
362 ) >> "${STDERR_TARGET}" 461 ) >> "${STDERR_TARGET}"
363 462
364 if (patch -p${count} ${EPATCH_OPTS} --dry-run -f < "${PATCH_TARGET}") >> "${STDERR_TARGET}" 2>&1 ; then 463 if [ $? -eq 0 ] ; then
365 ( 464 (
366 _epatch_draw_line "***** ${patchname} *****" 465 _epatch_draw_line "***** ${patchname} *****"
367 echo 466 echo
368 echo "ACTUALLY APPLYING ${patchname} ..." 467 echo "ACTUALLY APPLYING ${patchname} ..."
369 echo 468 echo
370 _epatch_draw_line "***** ${patchname} *****" 469 _epatch_draw_line "***** ${patchname} *****"
371 patch -p${count} ${EPATCH_OPTS} < "${PATCH_TARGET}" 2>&1 470 ${patch_cmd} < "${PATCH_TARGET}" 2>&1
471 ret=$?
472 echo
473 echo "patch program exited with status ${ret}"
474 exit ${ret}
372 ) >> "${STDERR_TARGET}" 475 ) >> "${STDERR_TARGET}"
373 476
374 if [ $? -ne 0 ] ; then 477 if [ $? -ne 0 ] ; then
375 echo 478 echo
376 eerror "A dry-run of patch command succeeded, but actually" 479 eerror "A dry-run of patch command succeeded, but actually"
399 eerror " ${STDERR_TARGET}" 502 eerror " ${STDERR_TARGET}"
400 echo 503 echo
401 die "Failed Patch: ${patchname}!" 504 die "Failed Patch: ${patchname}!"
402 fi 505 fi
403 506
404 # if everything worked, delete the patch log 507 # if everything worked, delete the full debug patch log
405 rm -f "${STDERR_TARGET}" 508 rm -f "${STDERR_TARGET}"
509
510 # then log away the exact stuff for people to review later
511 cat <<-EOF >> "${T}/epatch.log"
512 PATCH: ${x}
513 CMD: ${patch_cmd}
514 PWD: ${PWD}
515
516 EOF
406 eend 0 517 eend 0
407 done 518 done
408 519
409 [[ ${SINGLE_PATCH} == "no" ]] && einfo "Done with patching" 520 [[ ${SINGLE_PATCH} == "no" ]] && einfo "Done with patching"
410 : # everything worked 521 : # everything worked
411} 522}
523
524# @FUNCTION: epatch_user
525# @USAGE:
526# @DESCRIPTION:
527# Applies user-provided patches to the source tree. The patches are
528# taken from /etc/portage/patches/<CATEGORY>/<PF|P|PN>/, where the first
529# of these three directories to exist will be the one to use, ignoring
530# any more general directories which might exist as well.
531#
532# User patches are intended for quick testing of patches without ebuild
533# modifications, as well as for permanent customizations a user might
534# desire. Obviously, there can be no official support for arbitrarily
535# patched ebuilds. So whenever a build log in a bug report mentions that
536# user patches were applied, the user should be asked to reproduce the
537# problem without these.
538#
539# Not all ebuilds do call this function, so placing patches in the
540# stated directory might or might not work, depending on the package and
541# the eclasses it inherits and uses. It is safe to call the function
542# repeatedly, so it is always possible to add a call at the ebuild
543# level. The first call is the time when the patches will be
544# applied.
545#
546# Ideally, this function should be called after gentoo-specific patches
547# have been applied, so that their code can be modified as well, but
548# before calls to e.g. eautoreconf, as the user patches might affect
549# autotool input files as well.
412epatch_user() { 550epatch_user() {
413 [[ $# -ne 0 ]] && die "epatch_user takes no options" 551 [[ $# -ne 0 ]] && die "epatch_user takes no options"
414 552
553 # Allow multiple calls to this function; ignore all but the first
554 local applied="${T}/epatch_user.log"
555 [[ -e ${applied} ]] && return 2
556
415 # don't clobber any EPATCH vars that the parent might want 557 # don't clobber any EPATCH vars that the parent might want
416 local EPATCH_SOURCE check base=${PORTAGE_CONFIGROOT%/}/etc/portage/patches 558 local EPATCH_SOURCE check base=${PORTAGE_CONFIGROOT%/}/etc/portage/patches
417 for check in {${CATEGORY}/${PF},${CATEGORY}/${P},${CATEGORY}/${PN}}; do 559 for check in ${CATEGORY}/{${P}-${PR},${P},${PN}}; do
418 EPATCH_SOURCE=${base}/${CTARGET}/${check} 560 EPATCH_SOURCE=${base}/${CTARGET}/${check}
419 [[ -r ${EPATCH_SOURCE} ]] || EPATCH_SOURCE=${base}/${CHOST}/${check} 561 [[ -r ${EPATCH_SOURCE} ]] || EPATCH_SOURCE=${base}/${CHOST}/${check}
420 [[ -r ${EPATCH_SOURCE} ]] || EPATCH_SOURCE=${base}/${check} 562 [[ -r ${EPATCH_SOURCE} ]] || EPATCH_SOURCE=${base}/${check}
421 if [[ -d ${EPATCH_SOURCE} ]] ; then 563 if [[ -d ${EPATCH_SOURCE} ]] ; then
422 EPATCH_SOURCE=${EPATCH_SOURCE} \ 564 EPATCH_SOURCE=${EPATCH_SOURCE} \
423 EPATCH_SUFFIX="patch" \ 565 EPATCH_SUFFIX="patch" \
424 EPATCH_FORCE="yes" \ 566 EPATCH_FORCE="yes" \
425 EPATCH_MULTI_MSG="Applying user patches from ${EPATCH_SOURCE} ..." \ 567 EPATCH_MULTI_MSG="Applying user patches from ${EPATCH_SOURCE} ..." \
426 epatch 568 epatch
427 break 569 echo "${EPATCH_SOURCE}" > "${applied}"
570 return 0
428 fi 571 fi
429 done 572 done
573 echo "none" > "${applied}"
574 return 1
430} 575}
431 576
432# @FUNCTION: emktemp 577# @FUNCTION: emktemp
433# @USAGE: [temp dir] 578# @USAGE: [temp dir]
434# @DESCRIPTION: 579# @DESCRIPTION:
462 TMPDIR="${topdir}" mktemp -dt tmp.XXXXXXXXXX 607 TMPDIR="${topdir}" mktemp -dt tmp.XXXXXXXXXX
463 fi 608 fi
464 fi 609 fi
465} 610}
466 611
467# @FUNCTION: egetent
468# @USAGE: <database> <key>
469# @MAINTAINER:
470# base-system@gentoo.org (Linux)
471# Joe Jezak <josejx@gmail.com> (OS X)
472# usata@gentoo.org (OS X)
473# Aaron Walker <ka0ttic@gentoo.org> (FreeBSD)
474# @DESCRIPTION:
475# Small wrapper for getent (Linux),
476# nidump (< Mac OS X 10.5), dscl (Mac OS X 10.5),
477# and pw (FreeBSD) used in enewuser()/enewgroup()
478egetent() {
479 case ${CHOST} in
480 *-darwin[678])
481 case "$2" in
482 *[!0-9]*) # Non numeric
483 nidump $1 . | awk -F":" "{ if (\$1 ~ /^$2$/) {print \$0;exit;} }"
484 ;;
485 *) # Numeric
486 nidump $1 . | awk -F":" "{ if (\$3 == $2) {print \$0;exit;} }"
487 ;;
488 esac
489 ;;
490 *-darwin*)
491 local mytype=$1
492 [[ "passwd" == $mytype ]] && mytype="Users"
493 [[ "group" == $mytype ]] && mytype="Groups"
494 case "$2" in
495 *[!0-9]*) # Non numeric
496 dscl . -read /$mytype/$2 2>/dev/null |grep RecordName
497 ;;
498 *) # Numeric
499 local mykey="UniqueID"
500 [[ $mytype == "Groups" ]] && mykey="PrimaryGroupID"
501 dscl . -search /$mytype $mykey $2 2>/dev/null
502 ;;
503 esac
504 ;;
505 *-freebsd*|*-dragonfly*)
506 local opts action="user"
507 [[ $1 == "passwd" ]] || action="group"
508
509 # lookup by uid/gid
510 if [[ $2 == [[:digit:]]* ]] ; then
511 [[ ${action} == "user" ]] && opts="-u" || opts="-g"
512 fi
513
514 pw show ${action} ${opts} "$2" -q
515 ;;
516 *-netbsd*|*-openbsd*)
517 grep "$2:\*:" /etc/$1
518 ;;
519 *)
520 type -p nscd >& /dev/null && nscd -i "$1"
521 getent "$1" "$2"
522 ;;
523 esac
524}
525
526# @FUNCTION: enewuser
527# @USAGE: <user> [uid] [shell] [homedir] [groups] [params]
528# @DESCRIPTION:
529# Same as enewgroup, you are not required to understand how to properly add
530# a user to the system. The only required parameter is the username.
531# Default uid is (pass -1 for this) next available, default shell is
532# /bin/false, default homedir is /dev/null, there are no default groups,
533# and default params sets the comment as 'added by portage for ${PN}'.
534enewuser() {
535 case ${EBUILD_PHASE} in
536 unpack|compile|test|install)
537 eerror "'enewuser()' called from '${EBUILD_PHASE}()' which is not a pkg_* function."
538 eerror "Package fails at QA and at life. Please file a bug."
539 die "Bad package! enewuser is only for use in pkg_* functions!"
540 esac
541
542 # get the username
543 local euser=$1; shift
544 if [[ -z ${euser} ]] ; then
545 eerror "No username specified !"
546 die "Cannot call enewuser without a username"
547 fi
548
549 # lets see if the username already exists
550 if [[ -n $(egetent passwd "${euser}") ]] ; then
551 return 0
552 fi
553 einfo "Adding user '${euser}' to your system ..."
554
555 # options to pass to useradd
556 local opts=
557
558 # handle uid
559 local euid=$1; shift
560 if [[ -n ${euid} && ${euid} != -1 ]] ; then
561 if [[ ${euid} -gt 0 ]] ; then
562 if [[ -n $(egetent passwd ${euid}) ]] ; then
563 euid="next"
564 fi
565 else
566 eerror "Userid given but is not greater than 0 !"
567 die "${euid} is not a valid UID"
568 fi
569 else
570 euid="next"
571 fi
572 if [[ ${euid} == "next" ]] ; then
573 for ((euid = 101; euid <= 999; euid++)); do
574 [[ -z $(egetent passwd ${euid}) ]] && break
575 done
576 fi
577 opts="${opts} -u ${euid}"
578 einfo " - Userid: ${euid}"
579
580 # handle shell
581 local eshell=$1; shift
582 if [[ ! -z ${eshell} ]] && [[ ${eshell} != "-1" ]] ; then
583 if [[ ! -e ${ROOT}${eshell} ]] ; then
584 eerror "A shell was specified but it does not exist !"
585 die "${eshell} does not exist in ${ROOT}"
586 fi
587 if [[ ${eshell} == */false || ${eshell} == */nologin ]] ; then
588 eerror "Do not specify ${eshell} yourself, use -1"
589 die "Pass '-1' as the shell parameter"
590 fi
591 else
592 for shell in /sbin/nologin /usr/sbin/nologin /bin/false /usr/bin/false /dev/null ; do
593 [[ -x ${ROOT}${shell} ]] && break
594 done
595
596 if [[ ${shell} == "/dev/null" ]] ; then
597 eerror "Unable to identify the shell to use, proceeding with userland default."
598 case ${USERLAND} in
599 GNU) shell="/bin/false" ;;
600 BSD) shell="/sbin/nologin" ;;
601 Darwin) shell="/usr/sbin/nologin" ;;
602 *) die "Unable to identify the default shell for userland ${USERLAND}"
603 esac
604 fi
605
606 eshell=${shell}
607 fi
608 einfo " - Shell: ${eshell}"
609 opts="${opts} -s ${eshell}"
610
611 # handle homedir
612 local ehome=$1; shift
613 if [[ -z ${ehome} ]] || [[ ${ehome} == "-1" ]] ; then
614 ehome="/dev/null"
615 fi
616 einfo " - Home: ${ehome}"
617 opts="${opts} -d ${ehome}"
618
619 # handle groups
620 local egroups=$1; shift
621 if [[ ! -z ${egroups} ]] ; then
622 local oldifs=${IFS}
623 local defgroup="" exgroups=""
624
625 export IFS=","
626 for g in ${egroups} ; do
627 export IFS=${oldifs}
628 if [[ -z $(egetent group "${g}") ]] ; then
629 eerror "You must add group ${g} to the system first"
630 die "${g} is not a valid GID"
631 fi
632 if [[ -z ${defgroup} ]] ; then
633 defgroup=${g}
634 else
635 exgroups="${exgroups},${g}"
636 fi
637 export IFS=","
638 done
639 export IFS=${oldifs}
640
641 opts="${opts} -g ${defgroup}"
642 if [[ ! -z ${exgroups} ]] ; then
643 opts="${opts} -G ${exgroups:1}"
644 fi
645 else
646 egroups="(none)"
647 fi
648 einfo " - Groups: ${egroups}"
649
650 # handle extra and add the user
651 local oldsandbox=${SANDBOX_ON}
652 export SANDBOX_ON="0"
653 case ${CHOST} in
654 *-darwin*)
655 ### Make the user
656 if [[ -z $@ ]] ; then
657 dscl . create /users/${euser} uid ${euid}
658 dscl . create /users/${euser} shell ${eshell}
659 dscl . create /users/${euser} home ${ehome}
660 dscl . create /users/${euser} realname "added by portage for ${PN}"
661 ### Add the user to the groups specified
662 local oldifs=${IFS}
663 export IFS=","
664 for g in ${egroups} ; do
665 dscl . merge /groups/${g} users ${euser}
666 done
667 export IFS=${oldifs}
668 else
669 einfo "Extra options are not supported on Darwin yet"
670 einfo "Please report the ebuild along with the info below"
671 einfo "eextra: $@"
672 die "Required function missing"
673 fi
674 ;;
675 *-freebsd*|*-dragonfly*)
676 if [[ -z $@ ]] ; then
677 pw useradd ${euser} ${opts} \
678 -c "added by portage for ${PN}" \
679 die "enewuser failed"
680 else
681 einfo " - Extra: $@"
682 pw useradd ${euser} ${opts} \
683 "$@" || die "enewuser failed"
684 fi
685 ;;
686
687 *-netbsd*)
688 if [[ -z $@ ]] ; then
689 useradd ${opts} ${euser} || die "enewuser failed"
690 else
691 einfo " - Extra: $@"
692 useradd ${opts} ${euser} "$@" || die "enewuser failed"
693 fi
694 ;;
695
696 *-openbsd*)
697 if [[ -z $@ ]] ; then
698 useradd -u ${euid} -s ${eshell} \
699 -d ${ehome} -c "Added by portage for ${PN}" \
700 -g ${egroups} ${euser} || die "enewuser failed"
701 else
702 einfo " - Extra: $@"
703 useradd -u ${euid} -s ${eshell} \
704 -d ${ehome} -c "Added by portage for ${PN}" \
705 -g ${egroups} ${euser} "$@" || die "enewuser failed"
706 fi
707 ;;
708
709 *)
710 if [[ -z $@ ]] ; then
711 useradd ${opts} \
712 -c "added by portage for ${PN}" \
713 ${euser} \
714 || die "enewuser failed"
715 else
716 einfo " - Extra: $@"
717 useradd ${opts} "$@" \
718 ${euser} \
719 || die "enewuser failed"
720 fi
721 ;;
722 esac
723
724 if [[ ! -e ${ROOT}/${ehome} ]] ; then
725 einfo " - Creating ${ehome} in ${ROOT}"
726 mkdir -p "${ROOT}/${ehome}"
727 chown ${euser} "${ROOT}/${ehome}"
728 chmod 755 "${ROOT}/${ehome}"
729 fi
730
731 export SANDBOX_ON=${oldsandbox}
732}
733
734# @FUNCTION: enewgroup
735# @USAGE: <group> [gid]
736# @DESCRIPTION:
737# This function does not require you to understand how to properly add a
738# group to the system. Just give it a group name to add and enewgroup will
739# do the rest. You may specify the gid for the group or allow the group to
740# allocate the next available one.
741enewgroup() {
742 case ${EBUILD_PHASE} in
743 unpack|compile|test|install)
744 eerror "'enewgroup()' called from '${EBUILD_PHASE}()' which is not a pkg_* function."
745 eerror "Package fails at QA and at life. Please file a bug."
746 die "Bad package! enewgroup is only for use in pkg_* functions!"
747 esac
748
749 # get the group
750 local egroup="$1"; shift
751 if [ -z "${egroup}" ]
752 then
753 eerror "No group specified !"
754 die "Cannot call enewgroup without a group"
755 fi
756
757 # see if group already exists
758 if [[ -n $(egetent group "${egroup}") ]]; then
759 return 0
760 fi
761 einfo "Adding group '${egroup}' to your system ..."
762
763 # options to pass to useradd
764 local opts=
765
766 # handle gid
767 local egid="$1"; shift
768 if [ ! -z "${egid}" ]
769 then
770 if [ "${egid}" -gt 0 ]
771 then
772 if [ -z "`egetent group ${egid}`" ]
773 then
774 if [[ "${CHOST}" == *-darwin* ]]; then
775 opts="${opts} ${egid}"
776 else
777 opts="${opts} -g ${egid}"
778 fi
779 else
780 egid="next available; requested gid taken"
781 fi
782 else
783 eerror "Groupid given but is not greater than 0 !"
784 die "${egid} is not a valid GID"
785 fi
786 else
787 egid="next available"
788 fi
789 einfo " - Groupid: ${egid}"
790
791 # handle extra
792 local eextra="$@"
793 opts="${opts} ${eextra}"
794
795 # add the group
796 local oldsandbox="${SANDBOX_ON}"
797 export SANDBOX_ON="0"
798 case ${CHOST} in
799 *-darwin*)
800 if [ ! -z "${eextra}" ];
801 then
802 einfo "Extra options are not supported on Darwin/OS X yet"
803 einfo "Please report the ebuild along with the info below"
804 einfo "eextra: ${eextra}"
805 die "Required function missing"
806 fi
807
808 # If we need the next available
809 case ${egid} in
810 *[!0-9]*) # Non numeric
811 for ((egid = 101; egid <= 999; egid++)); do
812 [[ -z $(egetent group ${egid}) ]] && break
813 done
814 esac
815 dscl . create /groups/${egroup} gid ${egid}
816 dscl . create /groups/${egroup} passwd '*'
817 ;;
818
819 *-freebsd*|*-dragonfly*)
820 case ${egid} in
821 *[!0-9]*) # Non numeric
822 for ((egid = 101; egid <= 999; egid++)); do
823 [[ -z $(egetent group ${egid}) ]] && break
824 done
825 esac
826 pw groupadd ${egroup} -g ${egid} || die "enewgroup failed"
827 ;;
828
829 *-netbsd*)
830 case ${egid} in
831 *[!0-9]*) # Non numeric
832 for ((egid = 101; egid <= 999; egid++)); do
833 [[ -z $(egetent group ${egid}) ]] && break
834 done
835 esac
836 groupadd -g ${egid} ${egroup} || die "enewgroup failed"
837 ;;
838
839 *)
840 groupadd ${opts} ${egroup} || die "enewgroup failed"
841 ;;
842 esac
843 export SANDBOX_ON="${oldsandbox}"
844}
845
846# @FUNCTION: edos2unix 612# @FUNCTION: edos2unix
847# @USAGE: <file> [more files ...] 613# @USAGE: <file> [more files ...]
848# @DESCRIPTION: 614# @DESCRIPTION:
849# A handy replacement for dos2unix, recode, fixdos, etc... This allows you 615# A handy replacement for dos2unix, recode, fixdos, etc... This allows you
850# to remove all of these text utilities from DEPEND variables because this 616# to remove all of these text utilities from DEPEND variables because this
851# is a script based solution. Just give it a list of files to convert and 617# is a script based solution. Just give it a list of files to convert and
852# they will all be changed from the DOS CRLF format to the UNIX LF format. 618# they will all be changed from the DOS CRLF format to the UNIX LF format.
853edos2unix() { 619edos2unix() {
854 echo "$@" | xargs sed -i 's/\r$//' 620 [[ $# -eq 0 ]] && return 0
621 sed -i 's/\r$//' -- "$@" || die
855} 622}
856 623
624# @FUNCTION: make_desktop_entry
625# @USAGE: make_desktop_entry(<command>, [name], [icon], [type], [fields])
626# @DESCRIPTION:
857# Make a desktop file ! 627# Make a .desktop file.
858# Great for making those icons in kde/gnome startmenu !
859# Amaze your friends ! Get the women ! Join today !
860# 628#
861# make_desktop_entry(<command>, [name], [icon], [type], [path]) 629# @CODE
862#
863# binary: what command does the app run with ? 630# binary: what command does the app run with ?
864# name: the name that will show up in the menu 631# name: the name that will show up in the menu
865# icon: give your little like a pretty little icon ... 632# icon: give your little like a pretty little icon ...
866# this can be relative (to /usr/share/pixmaps) or 633# this can be relative (to /usr/share/pixmaps) or
867# a full path to an icon 634# a full path to an icon
868# type: what kind of application is this ? for categories: 635# type: what kind of application is this?
636# for categories:
869# http://standards.freedesktop.org/menu-spec/latest/apa.html 637# http://standards.freedesktop.org/menu-spec/latest/apa.html
870# path: if your app needs to startup in a specific dir 638# if unset, function tries to guess from package's category
639# fields: extra fields to append to the desktop file; a printf string
640# @CODE
871make_desktop_entry() { 641make_desktop_entry() {
872 [[ -z $1 ]] && eerror "make_desktop_entry: You must specify the executable" && return 1 642 [[ -z $1 ]] && die "make_desktop_entry: You must specify the executable"
873 643
874 local exec=${1} 644 local exec=${1}
875 local name=${2:-${PN}} 645 local name=${2:-${PN}}
876 local icon=${3:-${PN}} 646 local icon=${3:-${PN}}
877 local type=${4} 647 local type=${4}
878 local path=${5} 648 local fields=${5}
879 649
880 if [[ -z ${type} ]] ; then 650 if [[ -z ${type} ]] ; then
881 local catmaj=${CATEGORY%%-*} 651 local catmaj=${CATEGORY%%-*}
882 local catmin=${CATEGORY##*-} 652 local catmin=${CATEGORY##*-}
883 case ${catmaj} in 653 case ${catmaj} in
884 app) 654 app)
885 case ${catmin} in 655 case ${catmin} in
886 accessibility) type=Accessibility;; 656 accessibility) type="Utility;Accessibility";;
887 admin) type=System;; 657 admin) type=System;;
888 antivirus) type=System;; 658 antivirus) type=System;;
889 arch) type=Archiving;; 659 arch) type="Utility;Archiving";;
890 backup) type=Archiving;; 660 backup) type="Utility;Archiving";;
891 cdr) type=DiscBurning;; 661 cdr) type="AudioVideo;DiscBurning";;
892 dicts) type=Dictionary;; 662 dicts) type="Office;Dictionary";;
893 doc) type=Documentation;; 663 doc) type=Documentation;;
894 editors) type=TextEditor;; 664 editors) type="Utility;TextEditor";;
895 emacs) type=TextEditor;; 665 emacs) type="Development;TextEditor";;
896 emulation) type=Emulator;; 666 emulation) type="System;Emulator";;
897 laptop) type=HardwareSettings;; 667 laptop) type="Settings;HardwareSettings";;
898 office) type=Office;; 668 office) type=Office;;
899 pda) type=PDA;; 669 pda) type="Office;PDA";;
900 vim) type=TextEditor;; 670 vim) type="Development;TextEditor";;
901 xemacs) type=TextEditor;; 671 xemacs) type="Development;TextEditor";;
902 esac 672 esac
903 ;; 673 ;;
904 674
905 dev) 675 dev)
906 type="Development" 676 type="Development"
1026 TryExec=${exec%% *} 796 TryExec=${exec%% *}
1027 Icon=${icon} 797 Icon=${icon}
1028 Categories=${type} 798 Categories=${type}
1029 EOF 799 EOF
1030 800
1031 [[ ${path} ]] && echo "Path=${path}" >> "${desktop}" 801 if [[ ${fields:-=} != *=* ]] ; then
802 # 5th arg used to be value to Path=
803 ewarn "make_desktop_entry: update your 5th arg to read Path=${fields}"
804 fields="Path=${fields}"
805 fi
806 [[ -n ${fields} ]] && printf '%b\n' "${fields}" >> "${desktop}"
1032 807
1033 ( 808 (
1034 # wrap the env here so that the 'insinto' call 809 # wrap the env here so that the 'insinto' call
1035 # doesn't corrupt the env of the caller 810 # doesn't corrupt the env of the caller
1036 insinto /usr/share/applications 811 insinto /usr/share/applications
1177 # wrap the env here so that the 'insinto' call 952 # wrap the env here so that the 'insinto' call
1178 # doesn't corrupt the env of the caller 953 # doesn't corrupt the env of the caller
1179 insinto /usr/share/pixmaps 954 insinto /usr/share/pixmaps
1180 newins "$@" 955 newins "$@"
1181 ) 956 )
1182}
1183
1184# for internal use only (unpack_pdv and unpack_makeself)
1185find_unpackable_file() {
1186 local src=$1
1187 if [[ -z ${src} ]] ; then
1188 src=${DISTDIR}/${A}
1189 else
1190 if [[ -e ${DISTDIR}/${src} ]] ; then
1191 src=${DISTDIR}/${src}
1192 elif [[ -e ${PWD}/${src} ]] ; then
1193 src=${PWD}/${src}
1194 elif [[ -e ${src} ]] ; then
1195 src=${src}
1196 fi
1197 fi
1198 [[ ! -e ${src} ]] && return 1
1199 echo "${src}"
1200}
1201
1202# @FUNCTION: unpack_pdv
1203# @USAGE: <file to unpack> <size of off_t>
1204# @DESCRIPTION:
1205# Unpack those pesky pdv generated files ...
1206# They're self-unpacking programs with the binary package stuffed in
1207# the middle of the archive. Valve seems to use it a lot ... too bad
1208# it seems to like to segfault a lot :(. So lets take it apart ourselves.
1209#
1210# You have to specify the off_t size ... I have no idea how to extract that
1211# information out of the binary executable myself. Basically you pass in
1212# the size of the off_t type (in bytes) on the machine that built the pdv
1213# archive.
1214#
1215# One way to determine this is by running the following commands:
1216#
1217# @CODE
1218# strings <pdv archive> | grep lseek
1219# strace -elseek <pdv archive>
1220# @CODE
1221#
1222# Basically look for the first lseek command (we do the strings/grep because
1223# sometimes the function call is _llseek or something) and steal the 2nd
1224# parameter. Here is an example:
1225#
1226# @CODE
1227# vapier@vapier 0 pdv_unpack # strings hldsupdatetool.bin | grep lseek
1228# lseek
1229# vapier@vapier 0 pdv_unpack # strace -elseek ./hldsupdatetool.bin
1230# lseek(3, -4, SEEK_END) = 2981250
1231# @CODE
1232#
1233# Thus we would pass in the value of '4' as the second parameter.
1234unpack_pdv() {
1235 local src=$(find_unpackable_file "$1")
1236 local sizeoff_t=$2
1237
1238 [[ -z ${src} ]] && die "Could not locate source for '$1'"
1239 [[ -z ${sizeoff_t} ]] && die "No idea what off_t size was used for this pdv :("
1240
1241 local shrtsrc=$(basename "${src}")
1242 echo ">>> Unpacking ${shrtsrc} to ${PWD}"
1243 local metaskip=$(tail -c ${sizeoff_t} "${src}" | hexdump -e \"%i\")
1244 local tailskip=$(tail -c $((${sizeoff_t}*2)) "${src}" | head -c ${sizeoff_t} | hexdump -e \"%i\")
1245
1246 # grab metadata for debug reasons
1247 local metafile=$(emktemp)
1248 tail -c +$((${metaskip}+1)) "${src}" > "${metafile}"
1249
1250 # rip out the final file name from the metadata
1251 local datafile=$(tail -c +$((${metaskip}+1)) "${src}" | strings | head -n 1)
1252 datafile=$(basename "${datafile}")
1253
1254 # now lets uncompress/untar the file if need be
1255 local tmpfile=$(emktemp)
1256 tail -c +$((${tailskip}+1)) ${src} 2>/dev/null | head -c 512 > ${tmpfile}
1257
1258 local iscompressed=$(file -b "${tmpfile}")
1259 if [[ ${iscompressed:0:8} == "compress" ]] ; then
1260 iscompressed=1
1261 mv ${tmpfile}{,.Z}
1262 gunzip ${tmpfile}
1263 else
1264 iscompressed=0
1265 fi
1266 local istar=$(file -b "${tmpfile}")
1267 if [[ ${istar:0:9} == "POSIX tar" ]] ; then
1268 istar=1
1269 else
1270 istar=0
1271 fi
1272
1273 #for some reason gzip dies with this ... dd cant provide buffer fast enough ?
1274 #dd if=${src} ibs=${metaskip} count=1 \
1275 # | dd ibs=${tailskip} skip=1 \
1276 # | gzip -dc \
1277 # > ${datafile}
1278 if [ ${iscompressed} -eq 1 ] ; then
1279 if [ ${istar} -eq 1 ] ; then
1280 tail -c +$((${tailskip}+1)) ${src} 2>/dev/null \
1281 | head -c $((${metaskip}-${tailskip})) \
1282 | tar -xzf -
1283 else
1284 tail -c +$((${tailskip}+1)) ${src} 2>/dev/null \
1285 | head -c $((${metaskip}-${tailskip})) \
1286 | gzip -dc \
1287 > ${datafile}
1288 fi
1289 else
1290 if [ ${istar} -eq 1 ] ; then
1291 tail -c +$((${tailskip}+1)) ${src} 2>/dev/null \
1292 | head -c $((${metaskip}-${tailskip})) \
1293 | tar --no-same-owner -xf -
1294 else
1295 tail -c +$((${tailskip}+1)) ${src} 2>/dev/null \
1296 | head -c $((${metaskip}-${tailskip})) \
1297 > ${datafile}
1298 fi
1299 fi
1300 true
1301 #[ -s "${datafile}" ] || die "failure unpacking pdv ('${metaskip}' '${tailskip}' '${datafile}')"
1302 #assert "failure unpacking pdv ('${metaskip}' '${tailskip}' '${datafile}')"
1303}
1304
1305# @FUNCTION: unpack_makeself
1306# @USAGE: [file to unpack] [offset] [tail|dd]
1307# @DESCRIPTION:
1308# Unpack those pesky makeself generated files ...
1309# They're shell scripts with the binary package tagged onto
1310# the end of the archive. Loki utilized the format as does
1311# many other game companies.
1312#
1313# If the file is not specified, then ${A} is used. If the
1314# offset is not specified then we will attempt to extract
1315# the proper offset from the script itself.
1316unpack_makeself() {
1317 local src_input=${1:-${A}}
1318 local src=$(find_unpackable_file "${src_input}")
1319 local skip=$2
1320 local exe=$3
1321
1322 [[ -z ${src} ]] && die "Could not locate source for '${src_input}'"
1323
1324 local shrtsrc=$(basename "${src}")
1325 echo ">>> Unpacking ${shrtsrc} to ${PWD}"
1326 if [[ -z ${skip} ]] ; then
1327 local ver=$(grep -a '#.*Makeself' "${src}" | awk '{print $NF}')
1328 local skip=0
1329 exe=tail
1330 case ${ver} in
1331 1.5.*|1.6.0-nv) # tested 1.5.{3,4,5} ... guessing 1.5.x series is same
1332 skip=$(grep -a ^skip= "${src}" | cut -d= -f2)
1333 ;;
1334 2.0|2.0.1)
1335 skip=$(grep -a ^$'\t'tail "${src}" | awk '{print $2}' | cut -b2-)
1336 ;;
1337 2.1.1)
1338 skip=$(grep -a ^offset= "${src}" | awk '{print $2}' | cut -b2-)
1339 let skip="skip + 1"
1340 ;;
1341 2.1.2)
1342 skip=$(grep -a ^offset= "${src}" | awk '{print $3}' | head -n 1)
1343 let skip="skip + 1"
1344 ;;
1345 2.1.3)
1346 skip=`grep -a ^offset= "${src}" | awk '{print $3}'`
1347 let skip="skip + 1"
1348 ;;
1349 2.1.4|2.1.5)
1350 skip=$(grep -a offset=.*head.*wc "${src}" | awk '{print $3}' | head -n 1)
1351 skip=$(head -n ${skip} "${src}" | wc -c)
1352 exe="dd"
1353 ;;
1354 *)
1355 eerror "I'm sorry, but I was unable to support the Makeself file."
1356 eerror "The version I detected was '${ver}'."
1357 eerror "Please file a bug about the file ${shrtsrc} at"
1358 eerror "http://bugs.gentoo.org/ so that support can be added."
1359 die "makeself version '${ver}' not supported"
1360 ;;
1361 esac
1362 debug-print "Detected Makeself version ${ver} ... using ${skip} as offset"
1363 fi
1364 case ${exe} in
1365 tail) exe="tail -n +${skip} '${src}'";;
1366 dd) exe="dd ibs=${skip} skip=1 obs=1024 conv=sync if='${src}'";;
1367 *) die "makeself cant handle exe '${exe}'"
1368 esac
1369
1370 # lets grab the first few bytes of the file to figure out what kind of archive it is
1371 local tmpfile=$(emktemp)
1372 eval ${exe} 2>/dev/null | head -c 512 > "${tmpfile}"
1373 local filetype=$(file -b "${tmpfile}")
1374 case ${filetype} in
1375 *tar\ archive*)
1376 eval ${exe} | tar --no-same-owner -xf -
1377 ;;
1378 bzip2*)
1379 eval ${exe} | bzip2 -dc | tar --no-same-owner -xf -
1380 ;;
1381 gzip*)
1382 eval ${exe} | tar --no-same-owner -xzf -
1383 ;;
1384 compress*)
1385 eval ${exe} | gunzip | tar --no-same-owner -xf -
1386 ;;
1387 *)
1388 eerror "Unknown filetype \"${filetype}\" ?"
1389 false
1390 ;;
1391 esac
1392 assert "failure unpacking (${filetype}) makeself ${shrtsrc} ('${ver}' +${skip})"
1393}
1394
1395# @FUNCTION: check_license
1396# @USAGE: [license]
1397# @DESCRIPTION:
1398# Display a license for user to accept. If no license is
1399# specified, then ${LICENSE} is used.
1400check_license() {
1401 local lic=$1
1402 if [ -z "${lic}" ] ; then
1403 lic="${PORTDIR}/licenses/${LICENSE}"
1404 else
1405 if [ -e "${PORTDIR}/licenses/${lic}" ] ; then
1406 lic="${PORTDIR}/licenses/${lic}"
1407 elif [ -e "${PWD}/${lic}" ] ; then
1408 lic="${PWD}/${lic}"
1409 elif [ -e "${lic}" ] ; then
1410 lic="${lic}"
1411 fi
1412 fi
1413 local l="`basename ${lic}`"
1414
1415 # here is where we check for the licenses the user already
1416 # accepted ... if we don't find a match, we make the user accept
1417 local alic
1418 eshopts_push -o noglob # so that bash doesn't expand "*"
1419 for alic in ${ACCEPT_LICENSE} ; do
1420 if [[ ${alic} == ${l} ]]; then
1421 eshopts_pop
1422 return 0
1423 fi
1424 done
1425 eshopts_pop
1426 [ ! -f "${lic}" ] && die "Could not find requested license ${lic}"
1427
1428 local licmsg=$(emktemp)
1429 cat <<-EOF > ${licmsg}
1430 **********************************************************
1431 The following license outlines the terms of use of this
1432 package. You MUST accept this license for installation to
1433 continue. When you are done viewing, hit 'q'. If you
1434 CTRL+C out of this, the install will not run!
1435 **********************************************************
1436
1437 EOF
1438 cat ${lic} >> ${licmsg}
1439 ${PAGER:-less} ${licmsg} || die "Could not execute pager (${PAGER}) to accept ${lic}"
1440 einfon "Do you accept the terms of this license (${l})? [yes/no] "
1441 read alic
1442 case ${alic} in
1443 yes|Yes|y|Y)
1444 return 0
1445 ;;
1446 *)
1447 echo;echo;echo
1448 eerror "You MUST accept the license to continue! Exiting!"
1449 die "Failed to accept license"
1450 ;;
1451 esac
1452}
1453
1454# @FUNCTION: cdrom_get_cds
1455# @USAGE: <file on cd1> [file on cd2] [file on cd3] [...]
1456# @DESCRIPTION:
1457# Aquire cd(s) for those lovely cd-based emerges. Yes, this violates
1458# the whole 'non-interactive' policy, but damnit I want CD support !
1459#
1460# With these cdrom functions we handle all the user interaction and
1461# standardize everything. All you have to do is call cdrom_get_cds()
1462# and when the function returns, you can assume that the cd has been
1463# found at CDROM_ROOT.
1464#
1465# The function will attempt to locate a cd based upon a file that is on
1466# the cd. The more files you give this function, the more cds
1467# the cdrom functions will handle.
1468#
1469# Normally the cdrom functions will refer to the cds as 'cd #1', 'cd #2',
1470# etc... If you want to give the cds better names, then just export
1471# the appropriate CDROM_NAME variable before calling cdrom_get_cds().
1472# Use CDROM_NAME for one cd, or CDROM_NAME_# for multiple cds. You can
1473# also use the CDROM_NAME_SET bash array.
1474#
1475# For those multi cd ebuilds, see the cdrom_load_next_cd() function.
1476cdrom_get_cds() {
1477 # first we figure out how many cds we're dealing with by
1478 # the # of files they gave us
1479 local cdcnt=0
1480 local f=
1481 for f in "$@" ; do
1482 ((++cdcnt))
1483 export CDROM_CHECK_${cdcnt}="$f"
1484 done
1485 export CDROM_TOTAL_CDS=${cdcnt}
1486 export CDROM_CURRENT_CD=1
1487
1488 # now we see if the user gave use CD_ROOT ...
1489 # if they did, let's just believe them that it's correct
1490 if [[ -n ${CD_ROOT}${CD_ROOT_1} ]] ; then
1491 local var=
1492 cdcnt=0
1493 while [[ ${cdcnt} -lt ${CDROM_TOTAL_CDS} ]] ; do
1494 ((++cdcnt))
1495 var="CD_ROOT_${cdcnt}"
1496 [[ -z ${!var} ]] && var="CD_ROOT"
1497 if [[ -z ${!var} ]] ; then
1498 eerror "You must either use just the CD_ROOT"
1499 eerror "or specify ALL the CD_ROOT_X variables."
1500 eerror "In this case, you will need ${CDROM_TOTAL_CDS} CD_ROOT_X variables."
1501 die "could not locate CD_ROOT_${cdcnt}"
1502 fi
1503 done
1504 export CDROM_ROOT=${CD_ROOT_1:-${CD_ROOT}}
1505 einfo "Found CD #${CDROM_CURRENT_CD} root at ${CDROM_ROOT}"
1506 export CDROM_SET=-1
1507 for f in ${CDROM_CHECK_1//:/ } ; do
1508 ((++CDROM_SET))
1509 [[ -e ${CD_ROOT}/${f} ]] && break
1510 done
1511 export CDROM_MATCH=${f}
1512 return
1513 fi
1514
1515 # User didn't help us out so lets make sure they know they can
1516 # simplify the whole process ...
1517 if [[ ${CDROM_TOTAL_CDS} -eq 1 ]] ; then
1518 einfo "This ebuild will need the ${CDROM_NAME:-cdrom for ${PN}}"
1519 echo
1520 einfo "If you do not have the CD, but have the data files"
1521 einfo "mounted somewhere on your filesystem, just export"
1522 einfo "the variable CD_ROOT so that it points to the"
1523 einfo "directory containing the files."
1524 echo
1525 einfo "For example:"
1526 einfo "export CD_ROOT=/mnt/cdrom"
1527 echo
1528 else
1529 if [[ -n ${CDROM_NAME_SET} ]] ; then
1530 # Translate the CDROM_NAME_SET array into CDROM_NAME_#
1531 cdcnt=0
1532 while [[ ${cdcnt} -lt ${CDROM_TOTAL_CDS} ]] ; do
1533 ((++cdcnt))
1534 export CDROM_NAME_${cdcnt}="${CDROM_NAME_SET[$((${cdcnt}-1))]}"
1535 done
1536 fi
1537
1538 einfo "This package will need access to ${CDROM_TOTAL_CDS} cds."
1539 cdcnt=0
1540 while [[ ${cdcnt} -lt ${CDROM_TOTAL_CDS} ]] ; do
1541 ((++cdcnt))
1542 var="CDROM_NAME_${cdcnt}"
1543 [[ ! -z ${!var} ]] && einfo " CD ${cdcnt}: ${!var}"
1544 done
1545 echo
1546 einfo "If you do not have the CDs, but have the data files"
1547 einfo "mounted somewhere on your filesystem, just export"
1548 einfo "the following variables so they point to the right place:"
1549 einfon ""
1550 cdcnt=0
1551 while [[ ${cdcnt} -lt ${CDROM_TOTAL_CDS} ]] ; do
1552 ((++cdcnt))
1553 echo -n " CD_ROOT_${cdcnt}"
1554 done
1555 echo
1556 einfo "Or, if you have all the files in the same place, or"
1557 einfo "you only have one cdrom, you can export CD_ROOT"
1558 einfo "and that place will be used as the same data source"
1559 einfo "for all the CDs."
1560 echo
1561 einfo "For example:"
1562 einfo "export CD_ROOT_1=/mnt/cdrom"
1563 echo
1564 fi
1565
1566 export CDROM_SET=""
1567 export CDROM_CURRENT_CD=0
1568 cdrom_load_next_cd
1569}
1570
1571# @FUNCTION: cdrom_load_next_cd
1572# @DESCRIPTION:
1573# Some packages are so big they come on multiple CDs. When you're done reading
1574# files off a CD and want access to the next one, just call this function.
1575# Again, all the messy details of user interaction are taken care of for you.
1576# Once this returns, just read the variable CDROM_ROOT for the location of the
1577# mounted CD. Note that you can only go forward in the CD list, so make sure
1578# you only call this function when you're done using the current CD.
1579cdrom_load_next_cd() {
1580 local var
1581 ((++CDROM_CURRENT_CD))
1582
1583 unset CDROM_ROOT
1584 var=CD_ROOT_${CDROM_CURRENT_CD}
1585 [[ -z ${!var} ]] && var="CD_ROOT"
1586 if [[ -z ${!var} ]] ; then
1587 var="CDROM_CHECK_${CDROM_CURRENT_CD}"
1588 _cdrom_locate_file_on_cd ${!var}
1589 else
1590 export CDROM_ROOT=${!var}
1591 fi
1592
1593 einfo "Found CD #${CDROM_CURRENT_CD} root at ${CDROM_ROOT}"
1594}
1595
1596# this is used internally by the cdrom_get_cds() and cdrom_load_next_cd()
1597# functions. this should *never* be called from an ebuild.
1598# all it does is try to locate a give file on a cd ... if the cd isn't
1599# found, then a message asking for the user to insert the cdrom will be
1600# displayed and we'll hang out here until:
1601# (1) the file is found on a mounted cdrom
1602# (2) the user hits CTRL+C
1603_cdrom_locate_file_on_cd() {
1604 local mline=""
1605 local showedmsg=0 showjolietmsg=0
1606
1607 while [[ -z ${CDROM_ROOT} ]] ; do
1608 local i=0
1609 local -a cdset=(${*//:/ })
1610 if [[ -n ${CDROM_SET} ]] ; then
1611 cdset=(${cdset[${CDROM_SET}]})
1612 fi
1613
1614 while [[ -n ${cdset[${i}]} ]] ; do
1615 local dir=$(dirname ${cdset[${i}]})
1616 local file=$(basename ${cdset[${i}]})
1617
1618 local point= node= fs= foo=
1619 while read point node fs foo ; do
1620 [[ " cd9660 iso9660 udf " != *" ${fs} "* ]] && \
1621 ! [[ ${fs} == "subfs" && ",${opts}," == *",fs=cdfss,"* ]] \
1622 && continue
1623 point=${point//\040/ }
1624 [[ ! -d ${point}/${dir} ]] && continue
1625 [[ -z $(find "${point}/${dir}" -maxdepth 1 -iname "${file}") ]] && continue
1626 export CDROM_ROOT=${point}
1627 export CDROM_SET=${i}
1628 export CDROM_MATCH=${cdset[${i}]}
1629 return
1630 done <<< "$(get_mounts)"
1631
1632 ((++i))
1633 done
1634
1635 echo
1636 if [[ ${showedmsg} -eq 0 ]] ; then
1637 if [[ ${CDROM_TOTAL_CDS} -eq 1 ]] ; then
1638 if [[ -z ${CDROM_NAME} ]] ; then
1639 einfo "Please insert+mount the cdrom for ${PN} now !"
1640 else
1641 einfo "Please insert+mount the ${CDROM_NAME} cdrom now !"
1642 fi
1643 else
1644 if [[ -z ${CDROM_NAME_1} ]] ; then
1645 einfo "Please insert+mount cd #${CDROM_CURRENT_CD} for ${PN} now !"
1646 else
1647 local var="CDROM_NAME_${CDROM_CURRENT_CD}"
1648 einfo "Please insert+mount the ${!var} cdrom now !"
1649 fi
1650 fi
1651 showedmsg=1
1652 fi
1653 einfo "Press return to scan for the cd again"
1654 einfo "or hit CTRL+C to abort the emerge."
1655 echo
1656 if [[ ${showjolietmsg} -eq 0 ]] ; then
1657 showjolietmsg=1
1658 else
1659 ewarn "If you are having trouble with the detection"
1660 ewarn "of your CD, it is possible that you do not have"
1661 ewarn "Joliet support enabled in your kernel. Please"
1662 ewarn "check that CONFIG_JOLIET is enabled in your kernel."
1663 ebeep 5
1664 fi
1665 read || die "something is screwed with your system"
1666 done
1667} 957}
1668 958
1669# @FUNCTION: strip-linguas 959# @FUNCTION: strip-linguas
1670# @USAGE: [<allow LINGUAS>|<-i|-u> <directories of .po files>] 960# @USAGE: [<allow LINGUAS>|<-i|-u> <directories of .po files>]
1671# @DESCRIPTION: 961# @DESCRIPTION:
1688 else 978 else
1689 newls="" 979 newls=""
1690 fi 980 fi
1691 for f in $(find "$d" -name '*.po' -exec basename {} .po ';') ; do 981 for f in $(find "$d" -name '*.po' -exec basename {} .po ';') ; do
1692 if [[ ${op} == "-i" ]] ; then 982 if [[ ${op} == "-i" ]] ; then
1693 hasq ${f} ${ls} && newls="${newls} ${f}" 983 has ${f} ${ls} && newls="${newls} ${f}"
1694 else 984 else
1695 hasq ${f} ${ls} || newls="${newls} ${f}" 985 has ${f} ${ls} || newls="${newls} ${f}"
1696 fi 986 fi
1697 done 987 done
1698 ls=${newls} 988 ls=${newls}
1699 done 989 done
1700 else 990 else
1702 fi 992 fi
1703 993
1704 nols="" 994 nols=""
1705 newls="" 995 newls=""
1706 for f in ${LINGUAS} ; do 996 for f in ${LINGUAS} ; do
1707 if hasq ${f} ${ls} ; then 997 if has ${f} ${ls} ; then
1708 newls="${newls} ${f}" 998 newls="${newls} ${f}"
1709 else 999 else
1710 nols="${nols} ${f}" 1000 nols="${nols} ${f}"
1711 fi 1001 fi
1712 done 1002 done
1767 ewarn "the libraries are not being removed. You need to run revdep-rebuild" 1057 ewarn "the libraries are not being removed. You need to run revdep-rebuild"
1768 ewarn "in order to remove these old dependencies. If you do not have this" 1058 ewarn "in order to remove these old dependencies. If you do not have this"
1769 ewarn "helper program, simply emerge the 'gentoolkit' package." 1059 ewarn "helper program, simply emerge the 'gentoolkit' package."
1770 ewarn 1060 ewarn
1771 fi 1061 fi
1062 # temp hack for #348634 #357225
1063 [[ ${PN} == "mpfr" ]] && lib=${lib##*/}
1772 ewarn " # revdep-rebuild --library ${lib##*/}" 1064 ewarn " # revdep-rebuild --library '${lib}'"
1773 done 1065 done
1774 if [[ ${notice} -eq 1 ]] ; then 1066 if [[ ${notice} -eq 1 ]] ; then
1775 ewarn 1067 ewarn
1776 ewarn "Once you've finished running revdep-rebuild, it should be safe to" 1068 ewarn "Once you've finished running revdep-rebuild, it should be safe to"
1777 ewarn "delete the old libraries. Here is a copy & paste for the lazy:" 1069 ewarn "delete the old libraries. Here is a copy & paste for the lazy:"
1923 else 1215 else
1924 newbin "${tmpwrapper}" "${wrapper}" || die 1216 newbin "${tmpwrapper}" "${wrapper}" || die
1925 fi 1217 fi
1926} 1218}
1927 1219
1928# @FUNCTION: prepalldocs 1220# @FUNCTION: path_exists
1929# @USAGE: 1221# @USAGE: [-a|-o] <paths>
1930# @DESCRIPTION: 1222# @DESCRIPTION:
1931# Compress files in /usr/share/doc which are not already 1223# Check if the specified paths exist. Works for all types of paths
1932# compressed, excluding /usr/share/doc/${PF}/html. 1224# (files/dirs/etc...). The -a and -o flags control the requirements
1933# Uses the ecompressdir to do the compression. 1225# of the paths. They correspond to "and" and "or" logic. So the -a
1934# 2009-02-18 by betelgeuse: 1226# flag means all the paths must exist while the -o flag means at least
1935# Commented because ecompressdir is even more internal to 1227# one of the paths must exist. The default behavior is "and". If no
1936# Portage than prepalldocs (it's not even mentioned in man 5 1228# paths are specified, then the return value is "false".
1937# ebuild). Please submit a better version for review to gentoo-dev 1229path_exists() {
1938# if you want prepalldocs here. 1230 local opt=$1
1939#prepalldocs() { 1231 [[ ${opt} == -[ao] ]] && shift || opt="-a"
1940# if [[ -n $1 ]] ; then
1941# ewarn "prepalldocs: invalid usage; takes no arguments"
1942# fi
1943 1232
1944# cd "${D}" 1233 # no paths -> return false
1945# [[ -d usr/share/doc ]] || return 0 1234 # same behavior as: [[ -e "" ]]
1235 [[ $# -eq 0 ]] && return 1
1946 1236
1947# find usr/share/doc -exec gzip {} + 1237 local p r=0
1948# ecompressdir --ignore /usr/share/doc/${PF}/html 1238 for p in "$@" ; do
1949# ecompressdir --queue /usr/share/doc 1239 [[ -e ${p} ]]
1950#} 1240 : $(( r += $? ))
1241 done
1242
1243 case ${opt} in
1244 -a) return $(( r != 0 )) ;;
1245 -o) return $(( r == $# )) ;;
1246 esac
1247}
1248
1249# @FUNCTION: in_iuse
1250# @USAGE: <flag>
1251# @DESCRIPTION:
1252# Determines whether the given flag is in IUSE. Strips IUSE default prefixes
1253# as necessary.
1254#
1255# Note that this function should not be used in the global scope.
1256in_iuse() {
1257 debug-print-function ${FUNCNAME} "${@}"
1258 [[ ${#} -eq 1 ]] || die "Invalid args to ${FUNCNAME}()"
1259
1260 local flag=${1}
1261 local liuse=( ${IUSE} )
1262
1263 has "${flag}" "${liuse[@]#[+-]}"
1264}
1265
1266# @FUNCTION: use_if_iuse
1267# @USAGE: <flag>
1268# @DESCRIPTION:
1269# Return true if the given flag is in USE and IUSE.
1270#
1271# Note that this function should not be used in the global scope.
1272use_if_iuse() {
1273 in_iuse $1 || return 1
1274 use $1
1275}
1276
1277# @FUNCTION: usex
1278# @USAGE: <USE flag> [true output] [false output] [true suffix] [false suffix]
1279# @DESCRIPTION:
1280# If USE flag is set, echo [true output][true suffix] (defaults to "yes"),
1281# otherwise echo [false output][false suffix] (defaults to "no").
1282usex() { use "$1" && echo "${2-yes}$4" || echo "${3-no}$5" ; } #382963
1283
1284check_license() { die "you no longer need this as portage supports ACCEPT_LICENSE itself"; }
1285
1286fi

Legend:
Removed from v.1.340  
changed lines
  Added in v.1.386

  ViewVC Help
Powered by ViewVC 1.1.20