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.334 2010/02/26 03:15:26 abcd Exp $ |
3 | # $Header: /var/cvsroot/gentoo-x86/eclass/eutils.eclass,v 1.383 2012/02/16 00:27:17 vapier 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 | |
|
|
18 | if [[ ${___ECLASS_ONCE_EUTILS} != "recur -_+^+_- spank" ]] ; then |
|
|
19 | ___ECLASS_ONCE_EUTILS="recur -_+^+_- spank" |
|
|
20 | |
18 | inherit multilib portability |
21 | inherit multilib portability user |
19 | |
22 | |
20 | DESCRIPTION="Based on the ${ECLASS} eclass" |
23 | DESCRIPTION="Based on the ${ECLASS} eclass" |
21 | |
24 | |
22 | if has "${EAPI:-0}" 0 1 2; then |
25 | if has "${EAPI:-0}" 0 1 2; then |
23 | |
26 | |
… | |
… | |
52 | } |
55 | } |
53 | |
56 | |
54 | else |
57 | else |
55 | |
58 | |
56 | ebeep() { |
59 | ebeep() { |
57 | [[ $(type -t eqawarn) == function ]] && \ |
|
|
58 | eqawarn "QA Notice: ebeep is not defined in EAPI=3, please file a bug at http://bugs.gentoo.org" |
60 | ewarn "QA Notice: ebeep is not defined in EAPI=${EAPI}, please file a bug at http://bugs.gentoo.org" |
59 | } |
61 | } |
60 | |
62 | |
61 | epause() { |
63 | epause() { |
62 | [[ $(type -t eqawarn) == function ]] && \ |
|
|
63 | eqawarn "QA Notice: epause is not defined in EAPI=3, 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" |
64 | } |
65 | } |
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 | : |
|
|
79 | } |
66 | fi |
80 | fi |
67 | |
81 | |
68 | # @FUNCTION: ecvs_clean |
82 | # @FUNCTION: ecvs_clean |
69 | # @USAGE: [list of dirs] |
83 | # @USAGE: [list of dirs] |
70 | # @DESCRIPTION: |
84 | # @DESCRIPTION: |
… | |
… | |
84 | esvn_clean() { |
98 | esvn_clean() { |
85 | [[ -z $* ]] && set -- . |
99 | [[ -z $* ]] && set -- . |
86 | find "$@" -type d -name '.svn' -prune -print0 | xargs -0 rm -rf |
100 | find "$@" -type d -name '.svn' -prune -print0 | xargs -0 rm -rf |
87 | } |
101 | } |
88 | |
102 | |
|
|
103 | # @FUNCTION: estack_push |
|
|
104 | # @USAGE: <stack> [items to push] |
|
|
105 | # @DESCRIPTION: |
|
|
106 | # Push any number of items onto the specified stack. Pick a name that |
|
|
107 | # is a valid variable (i.e. stick to alphanumerics), and push as many |
|
|
108 | # items as you like onto the stack at once. |
|
|
109 | # |
|
|
110 | # The following code snippet will echo 5, then 4, then 3, then ... |
|
|
111 | # @CODE |
|
|
112 | # estack_push mystack 1 2 3 4 5 |
|
|
113 | # while estack_pop mystack i ; do |
|
|
114 | # echo "${i}" |
|
|
115 | # done |
|
|
116 | # @CODE |
|
|
117 | estack_push() { |
|
|
118 | [[ $# -eq 0 ]] && die "estack_push: incorrect # of arguments" |
|
|
119 | local stack_name="__ESTACK_$1__" ; shift |
|
|
120 | eval ${stack_name}+=\( \"\$@\" \) |
|
|
121 | } |
|
|
122 | |
|
|
123 | # @FUNCTION: estack_pop |
|
|
124 | # @USAGE: <stack> [variable] |
|
|
125 | # @DESCRIPTION: |
|
|
126 | # Pop a single item off the specified stack. If a variable is specified, |
|
|
127 | # the popped item is stored there. If no more items are available, return |
|
|
128 | # 1, else return 0. See estack_push for more info. |
|
|
129 | estack_pop() { |
|
|
130 | [[ $# -eq 0 || $# -gt 2 ]] && die "estack_pop: incorrect # of arguments" |
|
|
131 | |
|
|
132 | # We use the fugly __estack_xxx var names to avoid collision with |
|
|
133 | # passing back the return value. If we used "local i" and the |
|
|
134 | # caller ran `estack_pop ... i`, we'd end up setting the local |
|
|
135 | # copy of "i" rather than the caller's copy. The __estack_xxx |
|
|
136 | # garbage is preferable to using $1/$2 everywhere as that is a |
|
|
137 | # bit harder to read. |
|
|
138 | local __estack_name="__ESTACK_$1__" ; shift |
|
|
139 | local __estack_retvar=$1 ; shift |
|
|
140 | eval local __estack_i=\${#${__estack_name}\[@\]} |
|
|
141 | # Don't warn -- let the caller interpret this as a failure |
|
|
142 | # or as normal behavior (akin to `shift`) |
|
|
143 | [[ $(( --__estack_i )) -eq -1 ]] && return 1 |
|
|
144 | |
|
|
145 | if [[ -n ${__estack_retvar} ]] ; then |
|
|
146 | eval ${__estack_retvar}=\"\${${__estack_name}\[${__estack_i}\]}\" |
|
|
147 | fi |
|
|
148 | eval unset ${__estack_name}\[${__estack_i}\] |
|
|
149 | } |
|
|
150 | |
89 | # @FUNCTION: eshopts_push |
151 | # @FUNCTION: eshopts_push |
90 | # @USAGE: [options to `set` or `shopt`] |
152 | # @USAGE: [options to `set` or `shopt`] |
91 | # @DESCRIPTION: |
153 | # @DESCRIPTION: |
92 | # 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. |
93 | # 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 |
… | |
… | |
98 | # 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. |
99 | # |
161 | # |
100 | # 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 |
101 | # 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: |
102 | # @CODE |
164 | # @CODE |
103 | # eshopts_push -o noglob |
165 | # eshopts_push -s noglob |
104 | # for x in ${foo} ; do |
166 | # for x in ${foo} ; do |
105 | # if ...some check... ; then |
167 | # if ...some check... ; then |
106 | # eshopts_pop |
168 | # eshopts_pop |
107 | # return 0 |
169 | # return 0 |
108 | # fi |
170 | # fi |
109 | # done |
171 | # done |
110 | # eshopts_pop |
172 | # eshopts_pop |
111 | # @CODE |
173 | # @CODE |
112 | eshopts_push() { |
174 | eshopts_push() { |
113 | # have to assume __ESHOPTS_SAVE__ isn't screwed with |
|
|
114 | # as a `declare -a` here will reset its value |
|
|
115 | local i=${#__ESHOPTS_SAVE__[@]} |
|
|
116 | if [[ $1 == -[su] ]] ; then |
175 | if [[ $1 == -[su] ]] ; then |
117 | __ESHOPTS_SAVE__[$i]=$(shopt -p) |
176 | estack_push eshopts "$(shopt -p)" |
118 | [[ $# -eq 0 ]] && return 0 |
177 | [[ $# -eq 0 ]] && return 0 |
119 | shopt "$@" || die "eshopts_push: bad options to shopt: $*" |
178 | shopt "$@" || die "${FUNCNAME}: bad options to shopt: $*" |
120 | else |
179 | else |
121 | __ESHOPTS_SAVE__[$i]=$- |
180 | estack_push eshopts $- |
122 | [[ $# -eq 0 ]] && return 0 |
181 | [[ $# -eq 0 ]] && return 0 |
123 | set "$@" || die "eshopts_push: bad options to set: $*" |
182 | set "$@" || die "${FUNCNAME}: bad options to set: $*" |
124 | fi |
183 | fi |
125 | } |
184 | } |
126 | |
185 | |
127 | # @FUNCTION: eshopts_pop |
186 | # @FUNCTION: eshopts_pop |
128 | # @USAGE: |
187 | # @USAGE: |
129 | # @DESCRIPTION: |
188 | # @DESCRIPTION: |
130 | # Restore the shell options to the state saved with the corresponding |
189 | # Restore the shell options to the state saved with the corresponding |
131 | # eshopts_push call. See that function for more details. |
190 | # eshopts_push call. See that function for more details. |
132 | eshopts_pop() { |
191 | eshopts_pop() { |
133 | [[ $# -ne 0 ]] && die "eshopts_pop takes no arguments" |
192 | local s |
134 | local i=$(( ${#__ESHOPTS_SAVE__[@]} - 1 )) |
193 | estack_pop eshopts s || die "${FUNCNAME}: unbalanced push" |
135 | [[ ${i} -eq -1 ]] && die "eshopts_{push,pop}: unbalanced pair" |
|
|
136 | local s=${__ESHOPTS_SAVE__[$i]} |
|
|
137 | unset __ESHOPTS_SAVE__[$i] |
|
|
138 | if [[ ${s} == "shopt -"* ]] ; then |
194 | if [[ ${s} == "shopt -"* ]] ; then |
139 | eval "${s}" || die "eshopts_pop: sanity: invalid shopt options: ${s}" |
195 | eval "${s}" || die "${FUNCNAME}: sanity: invalid shopt options: ${s}" |
140 | else |
196 | else |
141 | set +$- || die "eshopts_pop: sanity: invalid shell settings: $-" |
197 | set +$- || die "${FUNCNAME}: sanity: invalid shell settings: $-" |
142 | 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}" |
143 | 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. |
|
|
207 | eumask_push() { |
|
|
208 | estack_push eumask "$(umask)" |
|
|
209 | umask "$@" || die "${FUNCNAME}: bad options to umask: $*" |
|
|
210 | } |
|
|
211 | |
|
|
212 | # @FUNCTION: eumask_pop |
|
|
213 | # @USAGE: |
|
|
214 | # @DESCRIPTION: |
|
|
215 | # Restore the previous umask state. |
|
|
216 | eumask_pop() { |
|
|
217 | [[ $# -eq 0 ]] || die "${FUNCNAME}: we take no options" |
|
|
218 | local s |
|
|
219 | estack_pop eumask s || die "${FUNCNAME}: unbalanced push" |
|
|
220 | umask ${s} || die "${FUNCNAME}: sanity: could not restore umask: ${s}" |
144 | } |
221 | } |
145 | |
222 | |
146 | # @VARIABLE: EPATCH_SOURCE |
223 | # @VARIABLE: EPATCH_SOURCE |
147 | # @DESCRIPTION: |
224 | # @DESCRIPTION: |
148 | # Default directory to search for patches. |
225 | # Default directory to search for patches. |
… | |
… | |
191 | # 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 |
192 | # specified by EPATCH_SOURCE. |
269 | # specified by EPATCH_SOURCE. |
193 | # |
270 | # |
194 | # When processing directories, epatch will apply all patches that match: |
271 | # When processing directories, epatch will apply all patches that match: |
195 | # @CODE |
272 | # @CODE |
196 | # ${EPATCH_FORCE} == "yes" |
273 | # if ${EPATCH_FORCE} != "yes" |
197 | # ??_${ARCH}_foo.${EPATCH_SUFFIX} |
274 | # ??_${ARCH}_foo.${EPATCH_SUFFIX} |
198 | # else |
275 | # else |
199 | # *.${EPATCH_SUFFIX} |
276 | # *.${EPATCH_SUFFIX} |
200 | # @CODE |
277 | # @CODE |
201 | # The leading ?? are typically numbers used to force consistent patch ordering. |
278 | # The leading ?? are typically numbers used to force consistent patch ordering. |
… | |
… | |
240 | local EPATCH_SUFFIX=$1 |
317 | local EPATCH_SUFFIX=$1 |
241 | |
318 | |
242 | elif [[ -d $1 ]] ; then |
319 | elif [[ -d $1 ]] ; then |
243 | # 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) |
244 | 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 $? |
245 | |
327 | |
246 | else |
328 | else |
247 | # 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 ? |
248 | [[ $# -ne 0 ]] && EPATCH_SOURCE=$1 |
330 | [[ $# -ne 0 ]] && EPATCH_SOURCE=$1 |
249 | echo |
331 | echo |
… | |
… | |
280 | # ???_arch_foo.patch |
362 | # ???_arch_foo.patch |
281 | # Else, skip this input altogether |
363 | # Else, skip this input altogether |
282 | local a=${patchname#*_} # strip the ???_ |
364 | local a=${patchname#*_} # strip the ???_ |
283 | a=${a%%_*} # strip the _foo.patch |
365 | a=${a%%_*} # strip the _foo.patch |
284 | if ! [[ ${SINGLE_PATCH} == "yes" || \ |
366 | if ! [[ ${SINGLE_PATCH} == "yes" || \ |
285 | ${EPATCH_FORCE} == "yes" || \ |
367 | ${EPATCH_FORCE} == "yes" || \ |
286 | ${a} == all || \ |
368 | ${a} == all || \ |
287 | ${a} == ${ARCH} ]] |
369 | ${a} == ${ARCH} ]] |
288 | then |
370 | then |
289 | continue |
371 | continue |
290 | fi |
372 | fi |
291 | |
373 | |
292 | # Let people filter things dynamically |
374 | # Let people filter things dynamically |
… | |
… | |
320 | local STDERR_TARGET="${T}/${patchname}.out" |
402 | local STDERR_TARGET="${T}/${patchname}.out" |
321 | if [[ -e ${STDERR_TARGET} ]] ; then |
403 | if [[ -e ${STDERR_TARGET} ]] ; then |
322 | STDERR_TARGET="${T}/${patchname}-$$.out" |
404 | STDERR_TARGET="${T}/${patchname}-$$.out" |
323 | fi |
405 | fi |
324 | |
406 | |
325 | printf "***** %s *****\n\n" "${patchname}" > "${STDERR_TARGET}" |
407 | printf "***** %s *****\nPWD: %s\n\n" "${patchname}" "${PWD}" > "${STDERR_TARGET}" |
326 | |
408 | |
327 | # Decompress the patch if need be |
409 | # Decompress the patch if need be |
328 | local count=0 |
410 | local count=0 |
329 | local PATCH_TARGET |
411 | local PATCH_TARGET |
330 | if [[ -n ${PIPE_CMD} ]] ; then |
412 | if [[ -n ${PIPE_CMD} ]] ; then |
… | |
… | |
349 | 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 }') |
350 | if [[ -n ${abs_paths} ]] ; then |
432 | if [[ -n ${abs_paths} ]] ; then |
351 | count=1 |
433 | count=1 |
352 | 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}" |
353 | 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 |
354 | |
443 | |
355 | # 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 |
356 | while [[ ${count} -lt 5 ]] ; do |
446 | while [[ ${count} -lt 5 ]] ; do |
|
|
447 | patch_cmd="patch -p${count} ${EPATCH_OPTS}" |
|
|
448 | |
357 | # Generate some useful debug info ... |
449 | # Generate some useful debug info ... |
358 | ( |
450 | ( |
359 | _epatch_draw_line "***** ${patchname} *****" |
451 | _epatch_draw_line "***** ${patchname} *****" |
360 | echo |
452 | echo |
361 | echo "PATCH COMMAND: patch -p${count} ${EPATCH_OPTS} < '${PATCH_TARGET}'" |
453 | echo "PATCH COMMAND: ${patch_cmd} < '${PATCH_TARGET}'" |
362 | echo |
454 | echo |
363 | _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} |
364 | ) >> "${STDERR_TARGET}" |
461 | ) >> "${STDERR_TARGET}" |
365 | |
462 | |
366 | if (patch -p${count} ${EPATCH_OPTS} --dry-run -f < "${PATCH_TARGET}") >> "${STDERR_TARGET}" 2>&1 ; then |
463 | if [ $? -eq 0 ] ; then |
367 | ( |
464 | ( |
368 | _epatch_draw_line "***** ${patchname} *****" |
465 | _epatch_draw_line "***** ${patchname} *****" |
369 | echo |
466 | echo |
370 | echo "ACTUALLY APPLYING ${patchname} ..." |
467 | echo "ACTUALLY APPLYING ${patchname} ..." |
371 | echo |
468 | echo |
372 | _epatch_draw_line "***** ${patchname} *****" |
469 | _epatch_draw_line "***** ${patchname} *****" |
373 | 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} |
374 | ) >> "${STDERR_TARGET}" |
475 | ) >> "${STDERR_TARGET}" |
375 | |
476 | |
376 | if [ $? -ne 0 ] ; then |
477 | if [ $? -ne 0 ] ; then |
377 | echo |
478 | echo |
378 | eerror "A dry-run of patch command succeeded, but actually" |
479 | eerror "A dry-run of patch command succeeded, but actually" |
… | |
… | |
401 | eerror " ${STDERR_TARGET}" |
502 | eerror " ${STDERR_TARGET}" |
402 | echo |
503 | echo |
403 | die "Failed Patch: ${patchname}!" |
504 | die "Failed Patch: ${patchname}!" |
404 | fi |
505 | fi |
405 | |
506 | |
406 | # if everything worked, delete the patch log |
507 | # if everything worked, delete the full debug patch log |
407 | 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 |
408 | eend 0 |
517 | eend 0 |
409 | done |
518 | done |
410 | |
519 | |
411 | [[ ${SINGLE_PATCH} == "no" ]] && einfo "Done with patching" |
520 | [[ ${SINGLE_PATCH} == "no" ]] && einfo "Done with patching" |
412 | : # everything worked |
521 | : # everything worked |
413 | } |
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. |
414 | epatch_user() { |
550 | epatch_user() { |
415 | [[ $# -ne 0 ]] && die "epatch_user takes no options" |
551 | [[ $# -ne 0 ]] && die "epatch_user takes no options" |
416 | |
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 | |
417 | # don't clobber any EPATCH vars that the parent might want |
557 | # don't clobber any EPATCH vars that the parent might want |
418 | local EPATCH_SOURCE check base=${PORTAGE_CONFIGROOT%/}/etc/portage/patches |
558 | local EPATCH_SOURCE check base=${PORTAGE_CONFIGROOT%/}/etc/portage/patches |
419 | for check in {${CATEGORY}/${PF},${CATEGORY}/${P},${CATEGORY}/${PN}}; do |
559 | for check in ${CATEGORY}/{${P}-${PR},${P},${PN}}; do |
420 | EPATCH_SOURCE=${base}/${CTARGET}/${check} |
560 | EPATCH_SOURCE=${base}/${CTARGET}/${check} |
421 | [[ -r ${EPATCH_SOURCE} ]] || EPATCH_SOURCE=${base}/${CHOST}/${check} |
561 | [[ -r ${EPATCH_SOURCE} ]] || EPATCH_SOURCE=${base}/${CHOST}/${check} |
422 | [[ -r ${EPATCH_SOURCE} ]] || EPATCH_SOURCE=${base}/${check} |
562 | [[ -r ${EPATCH_SOURCE} ]] || EPATCH_SOURCE=${base}/${check} |
423 | if [[ -d ${EPATCH_SOURCE} ]] ; then |
563 | if [[ -d ${EPATCH_SOURCE} ]] ; then |
424 | EPATCH_SOURCE=${EPATCH_SOURCE} \ |
564 | EPATCH_SOURCE=${EPATCH_SOURCE} \ |
425 | EPATCH_SUFFIX="patch" \ |
565 | EPATCH_SUFFIX="patch" \ |
426 | EPATCH_FORCE="yes" \ |
566 | EPATCH_FORCE="yes" \ |
427 | EPATCH_MULTI_MSG="Applying user patches from ${EPATCH_SOURCE} ..." \ |
567 | EPATCH_MULTI_MSG="Applying user patches from ${EPATCH_SOURCE} ..." \ |
428 | epatch |
568 | epatch |
429 | break |
569 | echo "${EPATCH_SOURCE}" > "${applied}" |
|
|
570 | return 0 |
430 | fi |
571 | fi |
431 | done |
572 | done |
|
|
573 | echo "none" > "${applied}" |
|
|
574 | return 1 |
432 | } |
575 | } |
433 | |
576 | |
434 | # @FUNCTION: emktemp |
577 | # @FUNCTION: emktemp |
435 | # @USAGE: [temp dir] |
578 | # @USAGE: [temp dir] |
436 | # @DESCRIPTION: |
579 | # @DESCRIPTION: |
… | |
… | |
464 | TMPDIR="${topdir}" mktemp -dt tmp.XXXXXXXXXX |
607 | TMPDIR="${topdir}" mktemp -dt tmp.XXXXXXXXXX |
465 | fi |
608 | fi |
466 | fi |
609 | fi |
467 | } |
610 | } |
468 | |
611 | |
469 | # @FUNCTION: egetent |
|
|
470 | # @USAGE: <database> <key> |
|
|
471 | # @MAINTAINER: |
|
|
472 | # base-system@gentoo.org (Linux) |
|
|
473 | # Joe Jezak <josejx@gmail.com> (OS X) |
|
|
474 | # usata@gentoo.org (OS X) |
|
|
475 | # Aaron Walker <ka0ttic@gentoo.org> (FreeBSD) |
|
|
476 | # @DESCRIPTION: |
|
|
477 | # Small wrapper for getent (Linux), |
|
|
478 | # nidump (< Mac OS X 10.5), dscl (Mac OS X 10.5), |
|
|
479 | # and pw (FreeBSD) used in enewuser()/enewgroup() |
|
|
480 | egetent() { |
|
|
481 | case ${CHOST} in |
|
|
482 | *-darwin[678]) |
|
|
483 | case "$2" in |
|
|
484 | *[!0-9]*) # Non numeric |
|
|
485 | nidump $1 . | awk -F":" "{ if (\$1 ~ /^$2$/) {print \$0;exit;} }" |
|
|
486 | ;; |
|
|
487 | *) # Numeric |
|
|
488 | nidump $1 . | awk -F":" "{ if (\$3 == $2) {print \$0;exit;} }" |
|
|
489 | ;; |
|
|
490 | esac |
|
|
491 | ;; |
|
|
492 | *-darwin*) |
|
|
493 | local mytype=$1 |
|
|
494 | [[ "passwd" == $mytype ]] && mytype="Users" |
|
|
495 | [[ "group" == $mytype ]] && mytype="Groups" |
|
|
496 | case "$2" in |
|
|
497 | *[!0-9]*) # Non numeric |
|
|
498 | dscl . -read /$mytype/$2 2>/dev/null |grep RecordName |
|
|
499 | ;; |
|
|
500 | *) # Numeric |
|
|
501 | local mykey="UniqueID" |
|
|
502 | [[ $mytype == "Groups" ]] && mykey="PrimaryGroupID" |
|
|
503 | dscl . -search /$mytype $mykey $2 2>/dev/null |
|
|
504 | ;; |
|
|
505 | esac |
|
|
506 | ;; |
|
|
507 | *-freebsd*|*-dragonfly*) |
|
|
508 | local opts action="user" |
|
|
509 | [[ $1 == "passwd" ]] || action="group" |
|
|
510 | |
|
|
511 | # lookup by uid/gid |
|
|
512 | if [[ $2 == [[:digit:]]* ]] ; then |
|
|
513 | [[ ${action} == "user" ]] && opts="-u" || opts="-g" |
|
|
514 | fi |
|
|
515 | |
|
|
516 | pw show ${action} ${opts} "$2" -q |
|
|
517 | ;; |
|
|
518 | *-netbsd*|*-openbsd*) |
|
|
519 | grep "$2:\*:" /etc/$1 |
|
|
520 | ;; |
|
|
521 | *) |
|
|
522 | type -p nscd >& /dev/null && nscd -i "$1" |
|
|
523 | getent "$1" "$2" |
|
|
524 | ;; |
|
|
525 | esac |
|
|
526 | } |
|
|
527 | |
|
|
528 | # @FUNCTION: enewuser |
|
|
529 | # @USAGE: <user> [uid] [shell] [homedir] [groups] [params] |
|
|
530 | # @DESCRIPTION: |
|
|
531 | # Same as enewgroup, you are not required to understand how to properly add |
|
|
532 | # a user to the system. The only required parameter is the username. |
|
|
533 | # Default uid is (pass -1 for this) next available, default shell is |
|
|
534 | # /bin/false, default homedir is /dev/null, there are no default groups, |
|
|
535 | # and default params sets the comment as 'added by portage for ${PN}'. |
|
|
536 | enewuser() { |
|
|
537 | case ${EBUILD_PHASE} in |
|
|
538 | unpack|compile|test|install) |
|
|
539 | eerror "'enewuser()' called from '${EBUILD_PHASE}()' which is not a pkg_* function." |
|
|
540 | eerror "Package fails at QA and at life. Please file a bug." |
|
|
541 | die "Bad package! enewuser is only for use in pkg_* functions!" |
|
|
542 | esac |
|
|
543 | |
|
|
544 | # get the username |
|
|
545 | local euser=$1; shift |
|
|
546 | if [[ -z ${euser} ]] ; then |
|
|
547 | eerror "No username specified !" |
|
|
548 | die "Cannot call enewuser without a username" |
|
|
549 | fi |
|
|
550 | |
|
|
551 | # lets see if the username already exists |
|
|
552 | if [[ -n $(egetent passwd "${euser}") ]] ; then |
|
|
553 | return 0 |
|
|
554 | fi |
|
|
555 | einfo "Adding user '${euser}' to your system ..." |
|
|
556 | |
|
|
557 | # options to pass to useradd |
|
|
558 | local opts= |
|
|
559 | |
|
|
560 | # handle uid |
|
|
561 | local euid=$1; shift |
|
|
562 | if [[ -n ${euid} && ${euid} != -1 ]] ; then |
|
|
563 | if [[ ${euid} -gt 0 ]] ; then |
|
|
564 | if [[ -n $(egetent passwd ${euid}) ]] ; then |
|
|
565 | euid="next" |
|
|
566 | fi |
|
|
567 | else |
|
|
568 | eerror "Userid given but is not greater than 0 !" |
|
|
569 | die "${euid} is not a valid UID" |
|
|
570 | fi |
|
|
571 | else |
|
|
572 | euid="next" |
|
|
573 | fi |
|
|
574 | if [[ ${euid} == "next" ]] ; then |
|
|
575 | for ((euid = 101; euid <= 999; euid++)); do |
|
|
576 | [[ -z $(egetent passwd ${euid}) ]] && break |
|
|
577 | done |
|
|
578 | fi |
|
|
579 | opts="${opts} -u ${euid}" |
|
|
580 | einfo " - Userid: ${euid}" |
|
|
581 | |
|
|
582 | # handle shell |
|
|
583 | local eshell=$1; shift |
|
|
584 | if [[ ! -z ${eshell} ]] && [[ ${eshell} != "-1" ]] ; then |
|
|
585 | if [[ ! -e ${ROOT}${eshell} ]] ; then |
|
|
586 | eerror "A shell was specified but it does not exist !" |
|
|
587 | die "${eshell} does not exist in ${ROOT}" |
|
|
588 | fi |
|
|
589 | if [[ ${eshell} == */false || ${eshell} == */nologin ]] ; then |
|
|
590 | eerror "Do not specify ${eshell} yourself, use -1" |
|
|
591 | die "Pass '-1' as the shell parameter" |
|
|
592 | fi |
|
|
593 | else |
|
|
594 | for shell in /sbin/nologin /usr/sbin/nologin /bin/false /usr/bin/false /dev/null ; do |
|
|
595 | [[ -x ${ROOT}${shell} ]] && break |
|
|
596 | done |
|
|
597 | |
|
|
598 | if [[ ${shell} == "/dev/null" ]] ; then |
|
|
599 | eerror "Unable to identify the shell to use, proceeding with userland default." |
|
|
600 | case ${USERLAND} in |
|
|
601 | GNU) shell="/bin/false" ;; |
|
|
602 | BSD) shell="/sbin/nologin" ;; |
|
|
603 | Darwin) shell="/usr/sbin/nologin" ;; |
|
|
604 | *) die "Unable to identify the default shell for userland ${USERLAND}" |
|
|
605 | esac |
|
|
606 | fi |
|
|
607 | |
|
|
608 | eshell=${shell} |
|
|
609 | fi |
|
|
610 | einfo " - Shell: ${eshell}" |
|
|
611 | opts="${opts} -s ${eshell}" |
|
|
612 | |
|
|
613 | # handle homedir |
|
|
614 | local ehome=$1; shift |
|
|
615 | if [[ -z ${ehome} ]] || [[ ${ehome} == "-1" ]] ; then |
|
|
616 | ehome="/dev/null" |
|
|
617 | fi |
|
|
618 | einfo " - Home: ${ehome}" |
|
|
619 | opts="${opts} -d ${ehome}" |
|
|
620 | |
|
|
621 | # handle groups |
|
|
622 | local egroups=$1; shift |
|
|
623 | if [[ ! -z ${egroups} ]] ; then |
|
|
624 | local oldifs=${IFS} |
|
|
625 | local defgroup="" exgroups="" |
|
|
626 | |
|
|
627 | export IFS="," |
|
|
628 | for g in ${egroups} ; do |
|
|
629 | export IFS=${oldifs} |
|
|
630 | if [[ -z $(egetent group "${g}") ]] ; then |
|
|
631 | eerror "You must add group ${g} to the system first" |
|
|
632 | die "${g} is not a valid GID" |
|
|
633 | fi |
|
|
634 | if [[ -z ${defgroup} ]] ; then |
|
|
635 | defgroup=${g} |
|
|
636 | else |
|
|
637 | exgroups="${exgroups},${g}" |
|
|
638 | fi |
|
|
639 | export IFS="," |
|
|
640 | done |
|
|
641 | export IFS=${oldifs} |
|
|
642 | |
|
|
643 | opts="${opts} -g ${defgroup}" |
|
|
644 | if [[ ! -z ${exgroups} ]] ; then |
|
|
645 | opts="${opts} -G ${exgroups:1}" |
|
|
646 | fi |
|
|
647 | else |
|
|
648 | egroups="(none)" |
|
|
649 | fi |
|
|
650 | einfo " - Groups: ${egroups}" |
|
|
651 | |
|
|
652 | # handle extra and add the user |
|
|
653 | local oldsandbox=${SANDBOX_ON} |
|
|
654 | export SANDBOX_ON="0" |
|
|
655 | case ${CHOST} in |
|
|
656 | *-darwin*) |
|
|
657 | ### Make the user |
|
|
658 | if [[ -z $@ ]] ; then |
|
|
659 | dscl . create /users/${euser} uid ${euid} |
|
|
660 | dscl . create /users/${euser} shell ${eshell} |
|
|
661 | dscl . create /users/${euser} home ${ehome} |
|
|
662 | dscl . create /users/${euser} realname "added by portage for ${PN}" |
|
|
663 | ### Add the user to the groups specified |
|
|
664 | local oldifs=${IFS} |
|
|
665 | export IFS="," |
|
|
666 | for g in ${egroups} ; do |
|
|
667 | dscl . merge /groups/${g} users ${euser} |
|
|
668 | done |
|
|
669 | export IFS=${oldifs} |
|
|
670 | else |
|
|
671 | einfo "Extra options are not supported on Darwin yet" |
|
|
672 | einfo "Please report the ebuild along with the info below" |
|
|
673 | einfo "eextra: $@" |
|
|
674 | die "Required function missing" |
|
|
675 | fi |
|
|
676 | ;; |
|
|
677 | *-freebsd*|*-dragonfly*) |
|
|
678 | if [[ -z $@ ]] ; then |
|
|
679 | pw useradd ${euser} ${opts} \ |
|
|
680 | -c "added by portage for ${PN}" \ |
|
|
681 | die "enewuser failed" |
|
|
682 | else |
|
|
683 | einfo " - Extra: $@" |
|
|
684 | pw useradd ${euser} ${opts} \ |
|
|
685 | "$@" || die "enewuser failed" |
|
|
686 | fi |
|
|
687 | ;; |
|
|
688 | |
|
|
689 | *-netbsd*) |
|
|
690 | if [[ -z $@ ]] ; then |
|
|
691 | useradd ${opts} ${euser} || die "enewuser failed" |
|
|
692 | else |
|
|
693 | einfo " - Extra: $@" |
|
|
694 | useradd ${opts} ${euser} "$@" || die "enewuser failed" |
|
|
695 | fi |
|
|
696 | ;; |
|
|
697 | |
|
|
698 | *-openbsd*) |
|
|
699 | if [[ -z $@ ]] ; then |
|
|
700 | useradd -u ${euid} -s ${eshell} \ |
|
|
701 | -d ${ehome} -c "Added by portage for ${PN}" \ |
|
|
702 | -g ${egroups} ${euser} || die "enewuser failed" |
|
|
703 | else |
|
|
704 | einfo " - Extra: $@" |
|
|
705 | useradd -u ${euid} -s ${eshell} \ |
|
|
706 | -d ${ehome} -c "Added by portage for ${PN}" \ |
|
|
707 | -g ${egroups} ${euser} "$@" || die "enewuser failed" |
|
|
708 | fi |
|
|
709 | ;; |
|
|
710 | |
|
|
711 | *) |
|
|
712 | if [[ -z $@ ]] ; then |
|
|
713 | useradd ${opts} \ |
|
|
714 | -c "added by portage for ${PN}" \ |
|
|
715 | ${euser} \ |
|
|
716 | || die "enewuser failed" |
|
|
717 | else |
|
|
718 | einfo " - Extra: $@" |
|
|
719 | useradd ${opts} "$@" \ |
|
|
720 | ${euser} \ |
|
|
721 | || die "enewuser failed" |
|
|
722 | fi |
|
|
723 | ;; |
|
|
724 | esac |
|
|
725 | |
|
|
726 | if [[ ! -e ${ROOT}/${ehome} ]] ; then |
|
|
727 | einfo " - Creating ${ehome} in ${ROOT}" |
|
|
728 | mkdir -p "${ROOT}/${ehome}" |
|
|
729 | chown ${euser} "${ROOT}/${ehome}" |
|
|
730 | chmod 755 "${ROOT}/${ehome}" |
|
|
731 | fi |
|
|
732 | |
|
|
733 | export SANDBOX_ON=${oldsandbox} |
|
|
734 | } |
|
|
735 | |
|
|
736 | # @FUNCTION: enewgroup |
|
|
737 | # @USAGE: <group> [gid] |
|
|
738 | # @DESCRIPTION: |
|
|
739 | # This function does not require you to understand how to properly add a |
|
|
740 | # group to the system. Just give it a group name to add and enewgroup will |
|
|
741 | # do the rest. You may specify the gid for the group or allow the group to |
|
|
742 | # allocate the next available one. |
|
|
743 | enewgroup() { |
|
|
744 | case ${EBUILD_PHASE} in |
|
|
745 | unpack|compile|test|install) |
|
|
746 | eerror "'enewgroup()' called from '${EBUILD_PHASE}()' which is not a pkg_* function." |
|
|
747 | eerror "Package fails at QA and at life. Please file a bug." |
|
|
748 | die "Bad package! enewgroup is only for use in pkg_* functions!" |
|
|
749 | esac |
|
|
750 | |
|
|
751 | # get the group |
|
|
752 | local egroup="$1"; shift |
|
|
753 | if [ -z "${egroup}" ] |
|
|
754 | then |
|
|
755 | eerror "No group specified !" |
|
|
756 | die "Cannot call enewgroup without a group" |
|
|
757 | fi |
|
|
758 | |
|
|
759 | # see if group already exists |
|
|
760 | if [[ -n $(egetent group "${egroup}") ]]; then |
|
|
761 | return 0 |
|
|
762 | fi |
|
|
763 | einfo "Adding group '${egroup}' to your system ..." |
|
|
764 | |
|
|
765 | # options to pass to useradd |
|
|
766 | local opts= |
|
|
767 | |
|
|
768 | # handle gid |
|
|
769 | local egid="$1"; shift |
|
|
770 | if [ ! -z "${egid}" ] |
|
|
771 | then |
|
|
772 | if [ "${egid}" -gt 0 ] |
|
|
773 | then |
|
|
774 | if [ -z "`egetent group ${egid}`" ] |
|
|
775 | then |
|
|
776 | if [[ "${CHOST}" == *-darwin* ]]; then |
|
|
777 | opts="${opts} ${egid}" |
|
|
778 | else |
|
|
779 | opts="${opts} -g ${egid}" |
|
|
780 | fi |
|
|
781 | else |
|
|
782 | egid="next available; requested gid taken" |
|
|
783 | fi |
|
|
784 | else |
|
|
785 | eerror "Groupid given but is not greater than 0 !" |
|
|
786 | die "${egid} is not a valid GID" |
|
|
787 | fi |
|
|
788 | else |
|
|
789 | egid="next available" |
|
|
790 | fi |
|
|
791 | einfo " - Groupid: ${egid}" |
|
|
792 | |
|
|
793 | # handle extra |
|
|
794 | local eextra="$@" |
|
|
795 | opts="${opts} ${eextra}" |
|
|
796 | |
|
|
797 | # add the group |
|
|
798 | local oldsandbox="${SANDBOX_ON}" |
|
|
799 | export SANDBOX_ON="0" |
|
|
800 | case ${CHOST} in |
|
|
801 | *-darwin*) |
|
|
802 | if [ ! -z "${eextra}" ]; |
|
|
803 | then |
|
|
804 | einfo "Extra options are not supported on Darwin/OS X yet" |
|
|
805 | einfo "Please report the ebuild along with the info below" |
|
|
806 | einfo "eextra: ${eextra}" |
|
|
807 | die "Required function missing" |
|
|
808 | fi |
|
|
809 | |
|
|
810 | # If we need the next available |
|
|
811 | case ${egid} in |
|
|
812 | *[!0-9]*) # Non numeric |
|
|
813 | for ((egid = 101; egid <= 999; egid++)); do |
|
|
814 | [[ -z $(egetent group ${egid}) ]] && break |
|
|
815 | done |
|
|
816 | esac |
|
|
817 | dscl . create /groups/${egroup} gid ${egid} |
|
|
818 | dscl . create /groups/${egroup} passwd '*' |
|
|
819 | ;; |
|
|
820 | |
|
|
821 | *-freebsd*|*-dragonfly*) |
|
|
822 | case ${egid} in |
|
|
823 | *[!0-9]*) # Non numeric |
|
|
824 | for ((egid = 101; egid <= 999; egid++)); do |
|
|
825 | [[ -z $(egetent group ${egid}) ]] && break |
|
|
826 | done |
|
|
827 | esac |
|
|
828 | pw groupadd ${egroup} -g ${egid} || die "enewgroup failed" |
|
|
829 | ;; |
|
|
830 | |
|
|
831 | *-netbsd*) |
|
|
832 | case ${egid} in |
|
|
833 | *[!0-9]*) # Non numeric |
|
|
834 | for ((egid = 101; egid <= 999; egid++)); do |
|
|
835 | [[ -z $(egetent group ${egid}) ]] && break |
|
|
836 | done |
|
|
837 | esac |
|
|
838 | groupadd -g ${egid} ${egroup} || die "enewgroup failed" |
|
|
839 | ;; |
|
|
840 | |
|
|
841 | *) |
|
|
842 | groupadd ${opts} ${egroup} || die "enewgroup failed" |
|
|
843 | ;; |
|
|
844 | esac |
|
|
845 | export SANDBOX_ON="${oldsandbox}" |
|
|
846 | } |
|
|
847 | |
|
|
848 | # @FUNCTION: edos2unix |
612 | # @FUNCTION: edos2unix |
849 | # @USAGE: <file> [more files ...] |
613 | # @USAGE: <file> [more files ...] |
850 | # @DESCRIPTION: |
614 | # @DESCRIPTION: |
851 | # A handy replacement for dos2unix, recode, fixdos, etc... This allows you |
615 | # A handy replacement for dos2unix, recode, fixdos, etc... This allows you |
852 | # 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 |
853 | # 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 |
854 | # 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. |
855 | edos2unix() { |
619 | edos2unix() { |
856 | echo "$@" | xargs sed -i 's/\r$//' |
620 | [[ $# -eq 0 ]] && return 0 |
|
|
621 | sed -i 's/\r$//' -- "$@" || die |
857 | } |
622 | } |
858 | |
623 | |
|
|
624 | # @FUNCTION: make_desktop_entry |
|
|
625 | # @USAGE: make_desktop_entry(<command>, [name], [icon], [type], [fields]) |
|
|
626 | # @DESCRIPTION: |
859 | # Make a desktop file ! |
627 | # Make a .desktop file. |
860 | # Great for making those icons in kde/gnome startmenu ! |
|
|
861 | # Amaze your friends ! Get the women ! Join today ! |
|
|
862 | # |
628 | # |
863 | # make_desktop_entry(<command>, [name], [icon], [type], [path]) |
629 | # @CODE |
864 | # |
|
|
865 | # binary: what command does the app run with ? |
630 | # binary: what command does the app run with ? |
866 | # name: the name that will show up in the menu |
631 | # name: the name that will show up in the menu |
867 | # icon: give your little like a pretty little icon ... |
632 | # icon: give your little like a pretty little icon ... |
868 | # this can be relative (to /usr/share/pixmaps) or |
633 | # this can be relative (to /usr/share/pixmaps) or |
869 | # a full path to an icon |
634 | # a full path to an icon |
870 | # type: what kind of application is this ? for categories: |
635 | # type: what kind of application is this? |
|
|
636 | # for categories: |
871 | # http://standards.freedesktop.org/menu-spec/latest/apa.html |
637 | # http://standards.freedesktop.org/menu-spec/latest/apa.html |
872 | # 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 |
873 | make_desktop_entry() { |
641 | make_desktop_entry() { |
874 | [[ -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" |
875 | |
643 | |
876 | local exec=${1} |
644 | local exec=${1} |
877 | local name=${2:-${PN}} |
645 | local name=${2:-${PN}} |
878 | local icon=${3:-${PN}} |
646 | local icon=${3:-${PN}} |
879 | local type=${4} |
647 | local type=${4} |
880 | local path=${5} |
648 | local fields=${5} |
881 | |
649 | |
882 | if [[ -z ${type} ]] ; then |
650 | if [[ -z ${type} ]] ; then |
883 | local catmaj=${CATEGORY%%-*} |
651 | local catmaj=${CATEGORY%%-*} |
884 | local catmin=${CATEGORY##*-} |
652 | local catmin=${CATEGORY##*-} |
885 | case ${catmaj} in |
653 | case ${catmaj} in |
886 | app) |
654 | app) |
887 | case ${catmin} in |
655 | case ${catmin} in |
888 | accessibility) type=Accessibility;; |
656 | accessibility) type=Accessibility;; |
889 | admin) type=System;; |
657 | admin) type=System;; |
890 | antivirus) type=System;; |
658 | antivirus) type=System;; |
891 | arch) type=Archiving;; |
659 | arch) type=Archiving;; |
892 | backup) type=Archiving;; |
660 | backup) type=Archiving;; |
893 | cdr) type=DiscBurning;; |
661 | cdr) type=DiscBurning;; |
894 | dicts) type=Dictionary;; |
662 | dicts) type=Dictionary;; |
895 | doc) type=Documentation;; |
663 | doc) type=Documentation;; |
896 | editors) type=TextEditor;; |
664 | editors) type=TextEditor;; |
897 | emacs) type=TextEditor;; |
665 | emacs) type=TextEditor;; |
898 | emulation) type=Emulator;; |
666 | emulation) type=Emulator;; |
899 | laptop) type=HardwareSettings;; |
667 | laptop) type=HardwareSettings;; |
900 | office) type=Office;; |
668 | office) type=Office;; |
901 | pda) type=PDA;; |
669 | pda) type=PDA;; |
902 | vim) type=TextEditor;; |
670 | vim) type=TextEditor;; |
903 | xemacs) type=TextEditor;; |
671 | xemacs) type=TextEditor;; |
904 | *) type=;; |
|
|
905 | esac |
672 | esac |
906 | ;; |
673 | ;; |
907 | |
674 | |
908 | dev) |
675 | dev) |
909 | type="Development" |
676 | type="Development" |
910 | ;; |
677 | ;; |
911 | |
678 | |
912 | games) |
679 | games) |
913 | case ${catmin} in |
680 | case ${catmin} in |
914 | action|fps) type=ActionGame;; |
681 | action|fps) type=ActionGame;; |
915 | arcade) type=ArcadeGame;; |
682 | arcade) type=ArcadeGame;; |
916 | board) type=BoardGame;; |
683 | board) type=BoardGame;; |
917 | emulation) type=Emulator;; |
684 | emulation) type=Emulator;; |
918 | kids) type=KidsGame;; |
685 | kids) type=KidsGame;; |
919 | puzzle) type=LogicGame;; |
686 | puzzle) type=LogicGame;; |
920 | roguelike) type=RolePlaying;; |
687 | roguelike) type=RolePlaying;; |
921 | rpg) type=RolePlaying;; |
688 | rpg) type=RolePlaying;; |
922 | simulation) type=Simulation;; |
689 | simulation) type=Simulation;; |
923 | sports) type=SportsGame;; |
690 | sports) type=SportsGame;; |
924 | strategy) type=StrategyGame;; |
691 | strategy) type=StrategyGame;; |
925 | *) type=;; |
|
|
926 | esac |
692 | esac |
927 | type="Game;${type}" |
693 | type="Game;${type}" |
928 | ;; |
694 | ;; |
929 | |
695 | |
930 | gnome) |
696 | gnome) |
… | |
… | |
939 | type="Network;Email" |
705 | type="Network;Email" |
940 | ;; |
706 | ;; |
941 | |
707 | |
942 | media) |
708 | media) |
943 | case ${catmin} in |
709 | case ${catmin} in |
|
|
710 | gfx) |
944 | gfx) type=Graphics;; |
711 | type=Graphics |
|
|
712 | ;; |
|
|
713 | *) |
|
|
714 | case ${catmin} in |
945 | radio) type=Tuner;; |
715 | radio) type=Tuner;; |
946 | sound) type=Audio;; |
716 | sound) type=Audio;; |
947 | tv) type=TV;; |
717 | tv) type=TV;; |
948 | video) type=Video;; |
718 | video) type=Video;; |
949 | *) type=;; |
719 | esac |
|
|
720 | type="AudioVideo;${type}" |
|
|
721 | ;; |
950 | esac |
722 | esac |
951 | type="AudioVideo;${type}" |
|
|
952 | ;; |
723 | ;; |
953 | |
724 | |
954 | net) |
725 | net) |
955 | case ${catmin} in |
726 | case ${catmin} in |
956 | dialup) type=Dialup;; |
727 | dialup) type=Dialup;; |
957 | ftp) type=FileTransfer;; |
728 | ftp) type=FileTransfer;; |
958 | im) type=InstantMessaging;; |
729 | im) type=InstantMessaging;; |
959 | irc) type=IRCClient;; |
730 | irc) type=IRCClient;; |
960 | mail) type=Email;; |
731 | mail) type=Email;; |
961 | news) type=News;; |
732 | news) type=News;; |
962 | nntp) type=News;; |
733 | nntp) type=News;; |
963 | p2p) type=FileTransfer;; |
734 | p2p) type=FileTransfer;; |
964 | voip) type=Telephony;; |
735 | voip) type=Telephony;; |
965 | *) type=;; |
|
|
966 | esac |
736 | esac |
967 | type="Network;${type}" |
737 | type="Network;${type}" |
968 | ;; |
738 | ;; |
969 | |
739 | |
970 | sci) |
740 | sci) |
971 | case ${catmin} in |
741 | case ${catmin} in |
972 | astro*) type=Astronomy;; |
742 | astro*) type=Astronomy;; |
973 | bio*) type=Biology;; |
743 | bio*) type=Biology;; |
974 | calc*) type=Calculator;; |
744 | calc*) type=Calculator;; |
975 | chem*) type=Chemistry;; |
745 | chem*) type=Chemistry;; |
976 | elec*) type=Electronics;; |
746 | elec*) type=Electronics;; |
977 | geo*) type=Geology;; |
747 | geo*) type=Geology;; |
978 | math*) type=Math;; |
748 | math*) type=Math;; |
979 | physics) type=Physics;; |
749 | physics) type=Physics;; |
980 | visual*) type=DataVisualization;; |
750 | visual*) type=DataVisualization;; |
981 | *) type=;; |
|
|
982 | esac |
751 | esac |
983 | type="Education;Science;${type}" |
752 | type="Education;Science;${type}" |
984 | ;; |
753 | ;; |
985 | |
754 | |
986 | sys) |
755 | sys) |
… | |
… | |
988 | ;; |
757 | ;; |
989 | |
758 | |
990 | www) |
759 | www) |
991 | case ${catmin} in |
760 | case ${catmin} in |
992 | client) type=WebBrowser;; |
761 | client) type=WebBrowser;; |
993 | *) type=;; |
|
|
994 | esac |
762 | esac |
995 | type="Network;${type}" |
763 | type="Network;${type}" |
996 | ;; |
764 | ;; |
997 | |
765 | |
998 | *) |
766 | *) |
… | |
… | |
1010 | |
778 | |
1011 | # Don't append another ";" when a valid category value is provided. |
779 | # Don't append another ";" when a valid category value is provided. |
1012 | type=${type%;}${type:+;} |
780 | type=${type%;}${type:+;} |
1013 | |
781 | |
1014 | eshopts_push -s extglob |
782 | eshopts_push -s extglob |
1015 | if [[ -n ${icon} && ${icon} != /* && ${icon} == *.@(xpm|png|svg) ]]; then |
783 | if [[ -n ${icon} && ${icon} != /* ]] && [[ ${icon} == *.xpm || ${icon} == *.png || ${icon} == *.svg ]]; then |
1016 | ewarn "As described in the Icon Theme Specification, icon file extensions are not" |
784 | ewarn "As described in the Icon Theme Specification, icon file extensions are not" |
1017 | ewarn "allowed in .desktop files if the value is not an absolute path." |
785 | ewarn "allowed in .desktop files if the value is not an absolute path." |
1018 | icon=${icon%.@(xpm|png|svg)} |
786 | icon=${icon%.@(xpm|png|svg)} |
1019 | fi |
787 | fi |
1020 | eshopts_pop |
788 | eshopts_pop |
… | |
… | |
1028 | TryExec=${exec%% *} |
796 | TryExec=${exec%% *} |
1029 | Icon=${icon} |
797 | Icon=${icon} |
1030 | Categories=${type} |
798 | Categories=${type} |
1031 | EOF |
799 | EOF |
1032 | |
800 | |
1033 | [[ ${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}" |
1034 | |
807 | |
1035 | ( |
808 | ( |
1036 | # wrap the env here so that the 'insinto' call |
809 | # wrap the env here so that the 'insinto' call |
1037 | # doesn't corrupt the env of the caller |
810 | # doesn't corrupt the env of the caller |
1038 | insinto /usr/share/applications |
811 | insinto /usr/share/applications |
1039 | doins "${desktop}" |
812 | doins "${desktop}" |
1040 | ) |
813 | ) || die "installing desktop file failed" |
1041 | } |
814 | } |
1042 | |
815 | |
1043 | # @FUNCTION: validate_desktop_entries |
816 | # @FUNCTION: validate_desktop_entries |
1044 | # @USAGE: [directories] |
817 | # @USAGE: [directories] |
1045 | # @MAINTAINER: |
818 | # @MAINTAINER: |
… | |
… | |
1179 | # wrap the env here so that the 'insinto' call |
952 | # wrap the env here so that the 'insinto' call |
1180 | # doesn't corrupt the env of the caller |
953 | # doesn't corrupt the env of the caller |
1181 | insinto /usr/share/pixmaps |
954 | insinto /usr/share/pixmaps |
1182 | newins "$@" |
955 | newins "$@" |
1183 | ) |
956 | ) |
1184 | } |
|
|
1185 | |
|
|
1186 | # for internal use only (unpack_pdv and unpack_makeself) |
|
|
1187 | find_unpackable_file() { |
|
|
1188 | local src=$1 |
|
|
1189 | if [[ -z ${src} ]] ; then |
|
|
1190 | src=${DISTDIR}/${A} |
|
|
1191 | else |
|
|
1192 | if [[ -e ${DISTDIR}/${src} ]] ; then |
|
|
1193 | src=${DISTDIR}/${src} |
|
|
1194 | elif [[ -e ${PWD}/${src} ]] ; then |
|
|
1195 | src=${PWD}/${src} |
|
|
1196 | elif [[ -e ${src} ]] ; then |
|
|
1197 | src=${src} |
|
|
1198 | fi |
|
|
1199 | fi |
|
|
1200 | [[ ! -e ${src} ]] && return 1 |
|
|
1201 | echo "${src}" |
|
|
1202 | } |
|
|
1203 | |
|
|
1204 | # @FUNCTION: unpack_pdv |
|
|
1205 | # @USAGE: <file to unpack> <size of off_t> |
|
|
1206 | # @DESCRIPTION: |
|
|
1207 | # Unpack those pesky pdv generated files ... |
|
|
1208 | # They're self-unpacking programs with the binary package stuffed in |
|
|
1209 | # the middle of the archive. Valve seems to use it a lot ... too bad |
|
|
1210 | # it seems to like to segfault a lot :(. So lets take it apart ourselves. |
|
|
1211 | # |
|
|
1212 | # You have to specify the off_t size ... I have no idea how to extract that |
|
|
1213 | # information out of the binary executable myself. Basically you pass in |
|
|
1214 | # the size of the off_t type (in bytes) on the machine that built the pdv |
|
|
1215 | # archive. |
|
|
1216 | # |
|
|
1217 | # One way to determine this is by running the following commands: |
|
|
1218 | # |
|
|
1219 | # @CODE |
|
|
1220 | # strings <pdv archive> | grep lseek |
|
|
1221 | # strace -elseek <pdv archive> |
|
|
1222 | # @CODE |
|
|
1223 | # |
|
|
1224 | # Basically look for the first lseek command (we do the strings/grep because |
|
|
1225 | # sometimes the function call is _llseek or something) and steal the 2nd |
|
|
1226 | # parameter. Here is an example: |
|
|
1227 | # |
|
|
1228 | # @CODE |
|
|
1229 | # vapier@vapier 0 pdv_unpack # strings hldsupdatetool.bin | grep lseek |
|
|
1230 | # lseek |
|
|
1231 | # vapier@vapier 0 pdv_unpack # strace -elseek ./hldsupdatetool.bin |
|
|
1232 | # lseek(3, -4, SEEK_END) = 2981250 |
|
|
1233 | # @CODE |
|
|
1234 | # |
|
|
1235 | # Thus we would pass in the value of '4' as the second parameter. |
|
|
1236 | unpack_pdv() { |
|
|
1237 | local src=$(find_unpackable_file "$1") |
|
|
1238 | local sizeoff_t=$2 |
|
|
1239 | |
|
|
1240 | [[ -z ${src} ]] && die "Could not locate source for '$1'" |
|
|
1241 | [[ -z ${sizeoff_t} ]] && die "No idea what off_t size was used for this pdv :(" |
|
|
1242 | |
|
|
1243 | local shrtsrc=$(basename "${src}") |
|
|
1244 | echo ">>> Unpacking ${shrtsrc} to ${PWD}" |
|
|
1245 | local metaskip=$(tail -c ${sizeoff_t} "${src}" | hexdump -e \"%i\") |
|
|
1246 | local tailskip=$(tail -c $((${sizeoff_t}*2)) "${src}" | head -c ${sizeoff_t} | hexdump -e \"%i\") |
|
|
1247 | |
|
|
1248 | # grab metadata for debug reasons |
|
|
1249 | local metafile=$(emktemp) |
|
|
1250 | tail -c +$((${metaskip}+1)) "${src}" > "${metafile}" |
|
|
1251 | |
|
|
1252 | # rip out the final file name from the metadata |
|
|
1253 | local datafile=$(tail -c +$((${metaskip}+1)) "${src}" | strings | head -n 1) |
|
|
1254 | datafile=$(basename "${datafile}") |
|
|
1255 | |
|
|
1256 | # now lets uncompress/untar the file if need be |
|
|
1257 | local tmpfile=$(emktemp) |
|
|
1258 | tail -c +$((${tailskip}+1)) ${src} 2>/dev/null | head -c 512 > ${tmpfile} |
|
|
1259 | |
|
|
1260 | local iscompressed=$(file -b "${tmpfile}") |
|
|
1261 | if [[ ${iscompressed:0:8} == "compress" ]] ; then |
|
|
1262 | iscompressed=1 |
|
|
1263 | mv ${tmpfile}{,.Z} |
|
|
1264 | gunzip ${tmpfile} |
|
|
1265 | else |
|
|
1266 | iscompressed=0 |
|
|
1267 | fi |
|
|
1268 | local istar=$(file -b "${tmpfile}") |
|
|
1269 | if [[ ${istar:0:9} == "POSIX tar" ]] ; then |
|
|
1270 | istar=1 |
|
|
1271 | else |
|
|
1272 | istar=0 |
|
|
1273 | fi |
|
|
1274 | |
|
|
1275 | #for some reason gzip dies with this ... dd cant provide buffer fast enough ? |
|
|
1276 | #dd if=${src} ibs=${metaskip} count=1 \ |
|
|
1277 | # | dd ibs=${tailskip} skip=1 \ |
|
|
1278 | # | gzip -dc \ |
|
|
1279 | # > ${datafile} |
|
|
1280 | if [ ${iscompressed} -eq 1 ] ; then |
|
|
1281 | if [ ${istar} -eq 1 ] ; then |
|
|
1282 | tail -c +$((${tailskip}+1)) ${src} 2>/dev/null \ |
|
|
1283 | | head -c $((${metaskip}-${tailskip})) \ |
|
|
1284 | | tar -xzf - |
|
|
1285 | else |
|
|
1286 | tail -c +$((${tailskip}+1)) ${src} 2>/dev/null \ |
|
|
1287 | | head -c $((${metaskip}-${tailskip})) \ |
|
|
1288 | | gzip -dc \ |
|
|
1289 | > ${datafile} |
|
|
1290 | fi |
|
|
1291 | else |
|
|
1292 | if [ ${istar} -eq 1 ] ; then |
|
|
1293 | tail -c +$((${tailskip}+1)) ${src} 2>/dev/null \ |
|
|
1294 | | head -c $((${metaskip}-${tailskip})) \ |
|
|
1295 | | tar --no-same-owner -xf - |
|
|
1296 | else |
|
|
1297 | tail -c +$((${tailskip}+1)) ${src} 2>/dev/null \ |
|
|
1298 | | head -c $((${metaskip}-${tailskip})) \ |
|
|
1299 | > ${datafile} |
|
|
1300 | fi |
|
|
1301 | fi |
|
|
1302 | true |
|
|
1303 | #[ -s "${datafile}" ] || die "failure unpacking pdv ('${metaskip}' '${tailskip}' '${datafile}')" |
|
|
1304 | #assert "failure unpacking pdv ('${metaskip}' '${tailskip}' '${datafile}')" |
|
|
1305 | } |
|
|
1306 | |
|
|
1307 | # @FUNCTION: unpack_makeself |
|
|
1308 | # @USAGE: [file to unpack] [offset] [tail|dd] |
|
|
1309 | # @DESCRIPTION: |
|
|
1310 | # Unpack those pesky makeself generated files ... |
|
|
1311 | # They're shell scripts with the binary package tagged onto |
|
|
1312 | # the end of the archive. Loki utilized the format as does |
|
|
1313 | # many other game companies. |
|
|
1314 | # |
|
|
1315 | # If the file is not specified, then ${A} is used. If the |
|
|
1316 | # offset is not specified then we will attempt to extract |
|
|
1317 | # the proper offset from the script itself. |
|
|
1318 | unpack_makeself() { |
|
|
1319 | local src_input=${1:-${A}} |
|
|
1320 | local src=$(find_unpackable_file "${src_input}") |
|
|
1321 | local skip=$2 |
|
|
1322 | local exe=$3 |
|
|
1323 | |
|
|
1324 | [[ -z ${src} ]] && die "Could not locate source for '${src_input}'" |
|
|
1325 | |
|
|
1326 | local shrtsrc=$(basename "${src}") |
|
|
1327 | echo ">>> Unpacking ${shrtsrc} to ${PWD}" |
|
|
1328 | if [[ -z ${skip} ]] ; then |
|
|
1329 | local ver=$(grep -a '#.*Makeself' "${src}" | awk '{print $NF}') |
|
|
1330 | local skip=0 |
|
|
1331 | exe=tail |
|
|
1332 | case ${ver} in |
|
|
1333 | 1.5.*|1.6.0-nv) # tested 1.5.{3,4,5} ... guessing 1.5.x series is same |
|
|
1334 | skip=$(grep -a ^skip= "${src}" | cut -d= -f2) |
|
|
1335 | ;; |
|
|
1336 | 2.0|2.0.1) |
|
|
1337 | skip=$(grep -a ^$'\t'tail "${src}" | awk '{print $2}' | cut -b2-) |
|
|
1338 | ;; |
|
|
1339 | 2.1.1) |
|
|
1340 | skip=$(grep -a ^offset= "${src}" | awk '{print $2}' | cut -b2-) |
|
|
1341 | let skip="skip + 1" |
|
|
1342 | ;; |
|
|
1343 | 2.1.2) |
|
|
1344 | skip=$(grep -a ^offset= "${src}" | awk '{print $3}' | head -n 1) |
|
|
1345 | let skip="skip + 1" |
|
|
1346 | ;; |
|
|
1347 | 2.1.3) |
|
|
1348 | skip=`grep -a ^offset= "${src}" | awk '{print $3}'` |
|
|
1349 | let skip="skip + 1" |
|
|
1350 | ;; |
|
|
1351 | 2.1.4|2.1.5) |
|
|
1352 | skip=$(grep -a offset=.*head.*wc "${src}" | awk '{print $3}' | head -n 1) |
|
|
1353 | skip=$(head -n ${skip} "${src}" | wc -c) |
|
|
1354 | exe="dd" |
|
|
1355 | ;; |
|
|
1356 | *) |
|
|
1357 | eerror "I'm sorry, but I was unable to support the Makeself file." |
|
|
1358 | eerror "The version I detected was '${ver}'." |
|
|
1359 | eerror "Please file a bug about the file ${shrtsrc} at" |
|
|
1360 | eerror "http://bugs.gentoo.org/ so that support can be added." |
|
|
1361 | die "makeself version '${ver}' not supported" |
|
|
1362 | ;; |
|
|
1363 | esac |
|
|
1364 | debug-print "Detected Makeself version ${ver} ... using ${skip} as offset" |
|
|
1365 | fi |
|
|
1366 | case ${exe} in |
|
|
1367 | tail) exe="tail -n +${skip} '${src}'";; |
|
|
1368 | dd) exe="dd ibs=${skip} skip=1 obs=1024 conv=sync if='${src}'";; |
|
|
1369 | *) die "makeself cant handle exe '${exe}'" |
|
|
1370 | esac |
|
|
1371 | |
|
|
1372 | # lets grab the first few bytes of the file to figure out what kind of archive it is |
|
|
1373 | local tmpfile=$(emktemp) |
|
|
1374 | eval ${exe} 2>/dev/null | head -c 512 > "${tmpfile}" |
|
|
1375 | local filetype=$(file -b "${tmpfile}") |
|
|
1376 | case ${filetype} in |
|
|
1377 | *tar\ archive*) |
|
|
1378 | eval ${exe} | tar --no-same-owner -xf - |
|
|
1379 | ;; |
|
|
1380 | bzip2*) |
|
|
1381 | eval ${exe} | bzip2 -dc | tar --no-same-owner -xf - |
|
|
1382 | ;; |
|
|
1383 | gzip*) |
|
|
1384 | eval ${exe} | tar --no-same-owner -xzf - |
|
|
1385 | ;; |
|
|
1386 | compress*) |
|
|
1387 | eval ${exe} | gunzip | tar --no-same-owner -xf - |
|
|
1388 | ;; |
|
|
1389 | *) |
|
|
1390 | eerror "Unknown filetype \"${filetype}\" ?" |
|
|
1391 | false |
|
|
1392 | ;; |
|
|
1393 | esac |
|
|
1394 | assert "failure unpacking (${filetype}) makeself ${shrtsrc} ('${ver}' +${skip})" |
|
|
1395 | } |
|
|
1396 | |
|
|
1397 | # @FUNCTION: check_license |
|
|
1398 | # @USAGE: [license] |
|
|
1399 | # @DESCRIPTION: |
|
|
1400 | # Display a license for user to accept. If no license is |
|
|
1401 | # specified, then ${LICENSE} is used. |
|
|
1402 | check_license() { |
|
|
1403 | local lic=$1 |
|
|
1404 | if [ -z "${lic}" ] ; then |
|
|
1405 | lic="${PORTDIR}/licenses/${LICENSE}" |
|
|
1406 | else |
|
|
1407 | if [ -e "${PORTDIR}/licenses/${lic}" ] ; then |
|
|
1408 | lic="${PORTDIR}/licenses/${lic}" |
|
|
1409 | elif [ -e "${PWD}/${lic}" ] ; then |
|
|
1410 | lic="${PWD}/${lic}" |
|
|
1411 | elif [ -e "${lic}" ] ; then |
|
|
1412 | lic="${lic}" |
|
|
1413 | fi |
|
|
1414 | fi |
|
|
1415 | local l="`basename ${lic}`" |
|
|
1416 | |
|
|
1417 | # here is where we check for the licenses the user already |
|
|
1418 | # accepted ... if we don't find a match, we make the user accept |
|
|
1419 | local alic |
|
|
1420 | eshopts_push -o noglob # so that bash doesn't expand "*" |
|
|
1421 | for alic in ${ACCEPT_LICENSE} ; do |
|
|
1422 | if [[ ${alic} == ${l} ]]; then |
|
|
1423 | eshopts_pop |
|
|
1424 | return 0 |
|
|
1425 | fi |
|
|
1426 | done |
|
|
1427 | eshopts_pop |
|
|
1428 | [ ! -f "${lic}" ] && die "Could not find requested license ${lic}" |
|
|
1429 | |
|
|
1430 | local licmsg=$(emktemp) |
|
|
1431 | cat <<-EOF > ${licmsg} |
|
|
1432 | ********************************************************** |
|
|
1433 | The following license outlines the terms of use of this |
|
|
1434 | package. You MUST accept this license for installation to |
|
|
1435 | continue. When you are done viewing, hit 'q'. If you |
|
|
1436 | CTRL+C out of this, the install will not run! |
|
|
1437 | ********************************************************** |
|
|
1438 | |
|
|
1439 | EOF |
|
|
1440 | cat ${lic} >> ${licmsg} |
|
|
1441 | ${PAGER:-less} ${licmsg} || die "Could not execute pager (${PAGER}) to accept ${lic}" |
|
|
1442 | einfon "Do you accept the terms of this license (${l})? [yes/no] " |
|
|
1443 | read alic |
|
|
1444 | case ${alic} in |
|
|
1445 | yes|Yes|y|Y) |
|
|
1446 | return 0 |
|
|
1447 | ;; |
|
|
1448 | *) |
|
|
1449 | echo;echo;echo |
|
|
1450 | eerror "You MUST accept the license to continue! Exiting!" |
|
|
1451 | die "Failed to accept license" |
|
|
1452 | ;; |
|
|
1453 | esac |
|
|
1454 | } |
957 | } |
1455 | |
958 | |
1456 | # @FUNCTION: cdrom_get_cds |
959 | # @FUNCTION: cdrom_get_cds |
1457 | # @USAGE: <file on cd1> [file on cd2] [file on cd3] [...] |
960 | # @USAGE: <file on cd1> [file on cd2] [file on cd3] [...] |
1458 | # @DESCRIPTION: |
961 | # @DESCRIPTION: |
… | |
… | |
1506 | export CDROM_ROOT=${CD_ROOT_1:-${CD_ROOT}} |
1009 | export CDROM_ROOT=${CD_ROOT_1:-${CD_ROOT}} |
1507 | einfo "Found CD #${CDROM_CURRENT_CD} root at ${CDROM_ROOT}" |
1010 | einfo "Found CD #${CDROM_CURRENT_CD} root at ${CDROM_ROOT}" |
1508 | export CDROM_SET=-1 |
1011 | export CDROM_SET=-1 |
1509 | for f in ${CDROM_CHECK_1//:/ } ; do |
1012 | for f in ${CDROM_CHECK_1//:/ } ; do |
1510 | ((++CDROM_SET)) |
1013 | ((++CDROM_SET)) |
1511 | [[ -e ${CD_ROOT}/${f} ]] && break |
1014 | [[ -e ${CDROM_ROOT}/${f} ]] && break |
1512 | done |
1015 | done |
1513 | export CDROM_MATCH=${f} |
1016 | export CDROM_MATCH=${f} |
1514 | return |
1017 | return |
1515 | fi |
1018 | fi |
1516 | |
1019 | |
… | |
… | |
1690 | else |
1193 | else |
1691 | newls="" |
1194 | newls="" |
1692 | fi |
1195 | fi |
1693 | for f in $(find "$d" -name '*.po' -exec basename {} .po ';') ; do |
1196 | for f in $(find "$d" -name '*.po' -exec basename {} .po ';') ; do |
1694 | if [[ ${op} == "-i" ]] ; then |
1197 | if [[ ${op} == "-i" ]] ; then |
1695 | hasq ${f} ${ls} && newls="${newls} ${f}" |
1198 | has ${f} ${ls} && newls="${newls} ${f}" |
1696 | else |
1199 | else |
1697 | hasq ${f} ${ls} || newls="${newls} ${f}" |
1200 | has ${f} ${ls} || newls="${newls} ${f}" |
1698 | fi |
1201 | fi |
1699 | done |
1202 | done |
1700 | ls=${newls} |
1203 | ls=${newls} |
1701 | done |
1204 | done |
1702 | else |
1205 | else |
… | |
… | |
1704 | fi |
1207 | fi |
1705 | |
1208 | |
1706 | nols="" |
1209 | nols="" |
1707 | newls="" |
1210 | newls="" |
1708 | for f in ${LINGUAS} ; do |
1211 | for f in ${LINGUAS} ; do |
1709 | if hasq ${f} ${ls} ; then |
1212 | if has ${f} ${ls} ; then |
1710 | newls="${newls} ${f}" |
1213 | newls="${newls} ${f}" |
1711 | else |
1214 | else |
1712 | nols="${nols} ${f}" |
1215 | nols="${nols} ${f}" |
1713 | fi |
1216 | fi |
1714 | done |
1217 | done |
… | |
… | |
1769 | ewarn "the libraries are not being removed. You need to run revdep-rebuild" |
1272 | ewarn "the libraries are not being removed. You need to run revdep-rebuild" |
1770 | ewarn "in order to remove these old dependencies. If you do not have this" |
1273 | ewarn "in order to remove these old dependencies. If you do not have this" |
1771 | ewarn "helper program, simply emerge the 'gentoolkit' package." |
1274 | ewarn "helper program, simply emerge the 'gentoolkit' package." |
1772 | ewarn |
1275 | ewarn |
1773 | fi |
1276 | fi |
|
|
1277 | # temp hack for #348634 #357225 |
|
|
1278 | [[ ${PN} == "mpfr" ]] && lib=${lib##*/} |
1774 | ewarn " # revdep-rebuild --library ${lib##*/}" |
1279 | ewarn " # revdep-rebuild --library '${lib}'" |
1775 | done |
1280 | done |
1776 | if [[ ${notice} -eq 1 ]] ; then |
1281 | if [[ ${notice} -eq 1 ]] ; then |
1777 | ewarn |
1282 | ewarn |
1778 | ewarn "Once you've finished running revdep-rebuild, it should be safe to" |
1283 | ewarn "Once you've finished running revdep-rebuild, it should be safe to" |
1779 | ewarn "delete the old libraries. Here is a copy & paste for the lazy:" |
1284 | ewarn "delete the old libraries. Here is a copy & paste for the lazy:" |
… | |
… | |
1925 | else |
1430 | else |
1926 | newbin "${tmpwrapper}" "${wrapper}" || die |
1431 | newbin "${tmpwrapper}" "${wrapper}" || die |
1927 | fi |
1432 | fi |
1928 | } |
1433 | } |
1929 | |
1434 | |
1930 | # @FUNCTION: prepalldocs |
1435 | # @FUNCTION: path_exists |
1931 | # @USAGE: |
1436 | # @USAGE: [-a|-o] <paths> |
1932 | # @DESCRIPTION: |
1437 | # @DESCRIPTION: |
1933 | # Compress files in /usr/share/doc which are not already |
1438 | # Check if the specified paths exist. Works for all types of paths |
1934 | # compressed, excluding /usr/share/doc/${PF}/html. |
1439 | # (files/dirs/etc...). The -a and -o flags control the requirements |
1935 | # Uses the ecompressdir to do the compression. |
1440 | # of the paths. They correspond to "and" and "or" logic. So the -a |
1936 | # 2009-02-18 by betelgeuse: |
1441 | # flag means all the paths must exist while the -o flag means at least |
1937 | # Commented because ecompressdir is even more internal to |
1442 | # one of the paths must exist. The default behavior is "and". If no |
1938 | # Portage than prepalldocs (it's not even mentioned in man 5 |
1443 | # paths are specified, then the return value is "false". |
1939 | # ebuild). Please submit a better version for review to gentoo-dev |
1444 | path_exists() { |
1940 | # if you want prepalldocs here. |
1445 | local opt=$1 |
1941 | #prepalldocs() { |
1446 | [[ ${opt} == -[ao] ]] && shift || opt="-a" |
1942 | # if [[ -n $1 ]] ; then |
|
|
1943 | # ewarn "prepalldocs: invalid usage; takes no arguments" |
|
|
1944 | # fi |
|
|
1945 | |
1447 | |
1946 | # cd "${D}" |
1448 | # no paths -> return false |
1947 | # [[ -d usr/share/doc ]] || return 0 |
1449 | # same behavior as: [[ -e "" ]] |
|
|
1450 | [[ $# -eq 0 ]] && return 1 |
1948 | |
1451 | |
1949 | # find usr/share/doc -exec gzip {} + |
1452 | local p r=0 |
1950 | # ecompressdir --ignore /usr/share/doc/${PF}/html |
1453 | for p in "$@" ; do |
1951 | # ecompressdir --queue /usr/share/doc |
1454 | [[ -e ${p} ]] |
1952 | #} |
1455 | : $(( r += $? )) |
|
|
1456 | done |
|
|
1457 | |
|
|
1458 | case ${opt} in |
|
|
1459 | -a) return $(( r != 0 )) ;; |
|
|
1460 | -o) return $(( r == $# )) ;; |
|
|
1461 | esac |
|
|
1462 | } |
|
|
1463 | |
|
|
1464 | # @FUNCTION: in_iuse |
|
|
1465 | # @USAGE: <flag> |
|
|
1466 | # @DESCRIPTION: |
|
|
1467 | # Determines whether the given flag is in IUSE. Strips IUSE default prefixes |
|
|
1468 | # as necessary. |
|
|
1469 | # |
|
|
1470 | # Note that this function should not be used in the global scope. |
|
|
1471 | in_iuse() { |
|
|
1472 | debug-print-function ${FUNCNAME} "${@}" |
|
|
1473 | [[ ${#} -eq 1 ]] || die "Invalid args to ${FUNCNAME}()" |
|
|
1474 | |
|
|
1475 | local flag=${1} |
|
|
1476 | local liuse=( ${IUSE} ) |
|
|
1477 | |
|
|
1478 | has "${flag}" "${liuse[@]#[+-]}" |
|
|
1479 | } |
|
|
1480 | |
|
|
1481 | # @FUNCTION: use_if_iuse |
|
|
1482 | # @USAGE: <flag> |
|
|
1483 | # @DESCRIPTION: |
|
|
1484 | # Return true if the given flag is in USE and IUSE. |
|
|
1485 | # |
|
|
1486 | # Note that this function should not be used in the global scope. |
|
|
1487 | use_if_iuse() { |
|
|
1488 | in_iuse $1 || return 1 |
|
|
1489 | use $1 |
|
|
1490 | } |
|
|
1491 | |
|
|
1492 | # @FUNCTION: usex |
|
|
1493 | # @USAGE: <USE flag> [true output] [false output] [true suffix] [false suffix] |
|
|
1494 | # @DESCRIPTION: |
|
|
1495 | # If USE flag is set, echo [true output][true suffix] (defaults to "yes"), |
|
|
1496 | # otherwise echo [false output][false suffix] (defaults to "no"). |
|
|
1497 | usex() { use "$1" && echo "${2-yes}$4" || echo "${3-no}$5" ; } #382963 |
|
|
1498 | |
|
|
1499 | check_license() { die "you no longer need this as portage supports ACCEPT_LICENSE itself"; } |
|
|
1500 | |
|
|
1501 | fi |