1480 lines
49 KiB
Bash
1480 lines
49 KiB
Bash
# -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
|
|
|
##@inc[../../legacy/sysinc/base
|
|
# -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
|
|
|
# base: fonctions et variables de base pour utilisation sous Linux. requière
|
|
# l'utilisation de bash
|
|
|
|
##@provide sysinc/basevars
|
|
|
|
# === Variables diverses ===
|
|
# répertoire temporaire
|
|
export TMPDIR="${TMPDIR:-${TMP:-${TEMP:-/tmp}}}"
|
|
# BASEHOST est le nom d'hote *sans* domaine
|
|
export BASEHOST="${HOSTNAME%%.*}"
|
|
# FQDNHOST est le nom d'hote avec le domaine
|
|
if [ "$BASEHOST" != "$HOSTNAME" ]; then
|
|
export FQDNHOST="$HOSTNAME"
|
|
else
|
|
export FQDNHOST="$HOSTNAME.$(dnsdomainname)"
|
|
fi
|
|
# emplacement du script courant
|
|
scriptname="$(basename -- "$0")"
|
|
scriptdir="$(cd "$(dirname -- "$0")"; pwd)"
|
|
script="$scriptdir/$scriptname"
|
|
|
|
# fonction pour charger automatiquement /etc/default/$name et ~/etc/default/$name
|
|
function set_defaults() {
|
|
local __f __s
|
|
for __f in "$@"; do
|
|
__s=
|
|
if [ -r "/etc/default/$__f" ]; then
|
|
source "/etc/default/$__f"
|
|
__s=1
|
|
fi
|
|
if [ -r "$HOME/etc/default/$__f" ]; then
|
|
source "$HOME/etc/default/$__f"
|
|
__s=1
|
|
fi
|
|
if [ -z "$__s" ]; then
|
|
# si pas de fichier dans ~/etc/default ni dans /etc/default, lire
|
|
# $scriptdir/lib/default/$scriptname en dernier lieu
|
|
if [ -r "$scriptdir/lib/default/$__f" ]; then
|
|
source "$scriptdir/lib/default/$__f"
|
|
fi
|
|
fi
|
|
done
|
|
}
|
|
|
|
# === diverses fonctions ===
|
|
function is_yes() {
|
|
# retourner vrai si $1 est une valeur "oui"
|
|
[ "$1" == "o" -o "$1" == "O" -o "$1" == "oui" -o "$1" == "OUI" ] && return 0
|
|
[ "$1" == "y" -o "$1" == "Y" -o "$1" == "yes" -o "$1" == "YES" ] && return 0
|
|
[ "$1" == "v" -o "$1" == "V" -o "$1" == "vrai" -o "$1" == "VRAI" ] && return 0
|
|
[ "$1" == "t" -o "$1" == "T" -o "$1" == "true" -o "$1" == "TRUE" ] && return 0
|
|
[ "$1" == "1" ] && return 0
|
|
return 1
|
|
}
|
|
|
|
function is_no() {
|
|
# retourner vrai si $1 est une valeur "non"
|
|
[ "$1" == "n" -o "$1" == "N" -o "$1" == "non" -o "$1" == "NON" ] && return 0
|
|
[ "$1" == "no" -o "$1" == "NO" ] && return 0
|
|
[ "$1" == "f" -o "$1" == "F" -o "$1" == "faux" -o "$1" == "FAUX" ] && return 0
|
|
[ "$1" == "false" -o "$1" == "FALSE" ] && return 0
|
|
[ "$1" == "0" ] && return 0
|
|
return 1
|
|
}
|
|
|
|
# retourner le premier caractère de la chaine $1
|
|
function first_char() { echo "${1:0:1}"; }
|
|
# retourner le dernier caractère de la chaine $1
|
|
function last_char() { echo "${1:$((-1)):1}"; }
|
|
# retourner tous les caractères de la chaine $1, excepté le dernier
|
|
function first_chars() { echo "${1:0:$((${#1}-1))}"; }
|
|
# retourner tous les caractères de la chaine $1, excepté le premier
|
|
function last_chars() { echo "${1:1}"; }
|
|
# Tester si le premier caractère de la chaine $1 est $2
|
|
function first_char_is() { test "${1:0:1}" = "$2"; }
|
|
# Tester si le dernier caractère de la chaine $1 est $2
|
|
function last_char_is() { test "${1:$((-1)):1}" = "$2"; }
|
|
# Tester si la chaine $1 commence par le wildcard $2
|
|
function beginswith() { eval 'test "${1#'"$(quote_arg "$2")"'}" != "$1"'; }
|
|
# Tester si la chaine $1 se termine par le wildcard $2
|
|
function endswith() { eval 'test "${1%'"$(quote_arg "$2")"'}" != "$1"'; }
|
|
# Dans la chaine $1, remplacer \ par \\, " par \" et $ par \$, et l'afficher
|
|
function quote_arg() {
|
|
local s
|
|
s="${1//\\/\\\\}"
|
|
s="${s//\"/\\\"}"
|
|
s="${s//$/\\$}"
|
|
echo "$s"
|
|
## ou:
|
|
#echo "$1" | awk '{ gsub(/\\/, "\\\\"); gsub(/"/, "\\\""); gsub(/\$/, "\\$"); print }'
|
|
}
|
|
# Dans une chaine lue sur stdin, remplacer \ par \\, " par \" et $ par \$ et
|
|
# l'afficher
|
|
function quote_string() {
|
|
awk '{ gsub(/\\/, "\\\\"); gsub(/"/, "\\\""); gsub(/\$/, "\\$"); print }'
|
|
##ou:
|
|
#quote_arg "`cat`"
|
|
## mais cet dernière version est très lente sur un gros fichier
|
|
}
|
|
# Dans la chaine $1, remplacer '%' par '%25', '+' par '%2B', '&' par '%26', '=' par '%3D', ' ' par '+'
|
|
function quote_formvalue() {
|
|
local s="$1"
|
|
s="${s//\%/%25}"
|
|
s="${s//+/%2B}"
|
|
s="${s//&/%26}"
|
|
s="${s//=/%3D}"
|
|
s="${s// /+}"
|
|
echo "$s"
|
|
}
|
|
# Afficher le nombre de lignes d'un fichier
|
|
function get_nblines() {
|
|
[ -f "$1" ] && sed -ne '$=' "$1" || echo 0
|
|
}
|
|
# générer un fichier temporaire et retourner son nom
|
|
function mktempf() {
|
|
mktemp "${1:-"$TMPDIR/tmp.XXXXXX"}"
|
|
}
|
|
# générer un répertoire temporaire et retourner son nom
|
|
function mktempd() {
|
|
mktemp -d "${1:-"$TMPDIR/tmp.XXXXXX"}"
|
|
}
|
|
# Créer le répertoire correspondant à un fichier
|
|
function mkdirof() {
|
|
mkdir -p "$(dirname "$1")"
|
|
}
|
|
# dans la chaine $1, remplacer \ par \\ et " par \", et l'afficher. ceci est
|
|
# utile pour quoter des valeur à insérer dans un script awk
|
|
function quote_awk() {
|
|
local s
|
|
s="${1//\\\\/\\\\}"
|
|
s="${s//\"/\\\"}"
|
|
echo "$s"
|
|
}
|
|
# tester si gawk est disponible
|
|
function require_gawk() {
|
|
local OENC="$UTF8"
|
|
if [ -n "$__legacy_awk__" ]; then
|
|
ewarn "Cette fonction requière gnuawk"
|
|
return 1
|
|
fi
|
|
return 0
|
|
}
|
|
# lancer awk en essayant d'émuler des fonctionnalités de gnuawk (comme l'option
|
|
# -v et la fonction gensub (XXX à faire))
|
|
function uawk() {
|
|
if [ -z "$__legacy_awk__" ]; then
|
|
awk "$@"
|
|
else
|
|
# essayer d'émuler l'option -v
|
|
local script='BEGIN {'
|
|
local done=
|
|
while [ -n "$1" ]; do
|
|
case "$1" in
|
|
--)
|
|
shift
|
|
done=1
|
|
;;
|
|
|
|
-v)
|
|
shift
|
|
local name=${1%%=*}
|
|
local value=${1:$((${#name} + 1))}
|
|
if [ "$value" == "" ]; then
|
|
# valeur vide
|
|
script="$script
|
|
$name = \"\""
|
|
elif [ "${value//[0-9]*/}" == "" ]; then
|
|
# valeur numérique
|
|
script="$script
|
|
$name = $value"
|
|
else
|
|
# valeur alphanumérique
|
|
script="$script
|
|
$name = \"$(quote_awk "$value")\""
|
|
fi
|
|
;;
|
|
|
|
-*)
|
|
#ewarn "option non reconnue: $1"
|
|
;;
|
|
|
|
*)
|
|
done=1
|
|
;;
|
|
esac
|
|
[ -n "$done" ] && break
|
|
shift
|
|
done
|
|
|
|
script="$script
|
|
}
|
|
$1"
|
|
shift
|
|
awk "$script" "$@"
|
|
fi
|
|
}
|
|
# Retourner la commande permettant de donner à la variable ${!1} la valeur $2
|
|
function set_var_cmd() { echo "$1=\"$(quote_arg "$2")\""; }
|
|
# donner à la variable ${!1} la valeur $2
|
|
function set_var() { eval "$1=\"$(quote_arg "$2")\""; }
|
|
# donner à la variable ${!1} la valeur $2. on assume que les valeur sont déjà
|
|
# quotées comme il faut
|
|
function set_var_literal() { eval "$1=$2"; }
|
|
# copier en gardant le maximum de propriétés
|
|
function cp_a() { /bin/cp -a "$@"; }
|
|
# copier récursivement, en suivant les liens symboliques
|
|
function cp_R() { /bin/cp -pR "$@"; }
|
|
# supprimer les fichiers dont on donne éventuellement la liste
|
|
function rm_maybe() {
|
|
local parse_opts=1 arg rm
|
|
for arg in "$@"; do
|
|
# chercher s'il y a un argument autre que des options
|
|
if [ -n "$parse_opts" ]; then
|
|
if [ "$arg" == "--" ]; then
|
|
parse_opts=
|
|
elif [[ "$arg" == "-*" ]]; then
|
|
continue
|
|
elif [ -n "$arg" ]; then
|
|
rm=1
|
|
break
|
|
fi
|
|
elif [ -n "$arg" ]; then
|
|
rm=1
|
|
break
|
|
fi
|
|
done
|
|
[ -n "$rm" ] && /bin/rm "$@"
|
|
}
|
|
# lister les fichiers ou répertoires du répertoire $1, un par ligne
|
|
function list_all() {
|
|
# $1=un répertoire dont le contenu doit être listé
|
|
# $2..@=un ensemble de patterns pour le listage
|
|
local curdir="$(pwd)"
|
|
local b="${1:-.}"; shift
|
|
|
|
cd "$b" 2>/dev/null || return
|
|
eval "/bin/ls -1d ${*:-*} 2>/dev/null"
|
|
cd "$curdir"
|
|
}
|
|
# lister les fichiers du répertoire $1, un par ligne
|
|
function list_files() {
|
|
# $1=un répertoire dont le contenu doit être listé.
|
|
# $2..@=un ensemble de patterns pour le listage
|
|
local f
|
|
local curdir="$(pwd)"
|
|
local b="${1:-.}"; shift
|
|
|
|
cd "$b" 2>/dev/null || return
|
|
eval "/bin/ls -1d ${*:-*} 2>/dev/null" | while read f; do
|
|
[ -f "$f" ] && echo "$f"
|
|
done
|
|
cd "$curdir"
|
|
}
|
|
# lister les répertoires du répertoire $1, un par ligne
|
|
function list_dirs() {
|
|
# $1=un répertoire dont le contenu doit être listé.
|
|
# $2..@=un ensemble de patterns pour le listage
|
|
local f
|
|
local curdir="$(pwd)"
|
|
local b="${1:-.}"; shift
|
|
|
|
cd "$b" 2>/dev/null || return
|
|
eval "/bin/ls -1d ${*:-*} 2>/dev/null" | while read f; do
|
|
[ -d "$f" ] && echo "$f"
|
|
done
|
|
cd "$curdir"
|
|
}
|
|
# copier un fichier dans un répertoire, ou le contenu d'un répertoire dans un
|
|
# autre répertoire, que le répertoire source soit un lien symbolique ou
|
|
# non. Cette fonction existe parce que le comportement de "cp_a src dest" n'est
|
|
# pas consistant selon les plateformes, surtout si src est un lien symbolique
|
|
# sur un répertoire: parfois on copie le lien, parfois on copie le contenu du
|
|
# répertoire, parfois on copie le répertoire...
|
|
function cpdir() {
|
|
# $1=src, $2=dest, $3=method (cp_a par défaut)
|
|
local src="$1" dest="$2" method="${3:-cp_a}"
|
|
|
|
if [ -d "$src" ]; then
|
|
# si c'est un répertoire, traitement particulier
|
|
# tout d'abord, s'assurer que la destination existe
|
|
if [ ! -d "$dest" ]; then
|
|
mkdir -p "$dest"
|
|
fi
|
|
|
|
# ensuite on fait la copie
|
|
local prevdir="$(pwd)"
|
|
|
|
dest="$(abspath "$dest")" # XXX abspath défini dans functions!
|
|
cd "$src"
|
|
if [ -n "$(/bin/ls -a1)" ]; then
|
|
# copier les fichiers
|
|
[ -n "$(/bin/ls -1)" ] && "$method" * "$dest"
|
|
# ne pas oublier les fichiers cachés...
|
|
local i
|
|
for i in .*; do
|
|
[ "$i" == "." -o "$i" == ".." ] && continue
|
|
"$method" "$i" "$dest"
|
|
done
|
|
fi
|
|
cd "$prevdir"
|
|
else
|
|
# sinon, on assume que c'est un fichier
|
|
if [ -f "$dest" ]; then
|
|
# copie du fichier avec remplacement
|
|
"$method" "$src" "$dest"
|
|
elif [ -d "$dest" ]; then
|
|
# copie du fichier dans le répertoire
|
|
"$method" "$src" "$dest"
|
|
else
|
|
# Copie du fichier avec le nom $dest
|
|
mkdirof "$dest"
|
|
"$method" "$src" "$dest"
|
|
fi
|
|
fi
|
|
}
|
|
# transformer les fins de ligne en LF
|
|
function nl2lf() {
|
|
if [ -n "$1" -a "$1" != "-" ]; then
|
|
tr -d '\r' <"$1" >"$1.tmp.$$" &&
|
|
/bin/mv "$1.tmp.$$" "$1"
|
|
[ -f "$1.tmp.$$" ] && /bin/rm -f "$1.tmp.$$"
|
|
else
|
|
tr -d '\r'
|
|
fi
|
|
}
|
|
# transformer les fins de ligne en CRLF
|
|
function _nl2crlf() {
|
|
tr -d '\r' | awk '{print $0 "\r"}'
|
|
}
|
|
function nl2crlf() {
|
|
if [ -n "$1" -a "$1" != "-" ]; then
|
|
_nl2crlf <"$1" >"$1.tmp.$$" &&
|
|
/bin/mv "$1.tmp.$$" "$1"
|
|
[ -f "$1.tmp.$$" ] && /bin/rm -f "$1.tmp.$$"
|
|
else
|
|
_nl2crlf
|
|
fi
|
|
}
|
|
# tester la présence d'un pattern dans un fichier
|
|
function quietgrep() { grep -q "$@"; }
|
|
# tester si deux fichiers sont identiques
|
|
function quietdiff() { diff -q "$@" >&/dev/null; }
|
|
# tester si deux fichiers sont identiques/différents
|
|
function testsame() { quietdiff "$@"; }
|
|
function testdiff() { ! quietdiff "$@"; }
|
|
# test si $2 n'existe pas ou si $1 est plus récent que $2
|
|
function testnewer() { test ! -e "$2" -o "$1" -nt "$2"; }
|
|
# afficher tous les processus avec le maximum d'informations
|
|
function ps_all() { ps -axww; }
|
|
# tester l'existence d'un programme dans le PATH
|
|
function progexists() { test -n "$1" -a -x "$(which "$1" 2>/dev/null)"; }
|
|
# tester si on est root
|
|
function is_root() { test `id -u` -eq 0; }
|
|
# sourcer un fichier s'il existe
|
|
function source_ifexists() { if [ -f "$1" ]; then source "$1" || die; fi; }
|
|
# s'endormir pour une très petite période de temps
|
|
function little_sleep { LC_NUMERIC=C sleep 0.1; }
|
|
# tester si un programme dont on donne le PID tourne
|
|
function is_running() { test -n "$(ps -o pid -p "$1" | grep -v PID)"; }
|
|
# afficher des chemins "jolis"
|
|
function ppath() {
|
|
# Dans un chemin *absolu*, remplacer "$HOME" par "~" et "$(pwd)/" par "",
|
|
# afin que le chemin soit plus facile à lire. Le répertoire courant est
|
|
# spécifié par $2 ou $(pwd) si $2 est vide
|
|
local path="$1" cwd="$2"
|
|
|
|
# essayer de normaliser le chemin
|
|
if [ -d "$path" ]; then path="$(cd "$path"; pwd)"
|
|
elif [ -f "$path" ]; then path="$(cd "$(dirname "$path")"; pwd)/$(basename "$path")"
|
|
else
|
|
: # chemin inexistant, on espère que le chemin est bien formé
|
|
fi
|
|
|
|
if [ -z "$2" ]; then
|
|
cwd="$(pwd)"
|
|
fi
|
|
[ "$path" = "$cwd" ] && path="."
|
|
[ "$cwd" != "/" -a "$cwd" != "$HOME" ] && path="${path/#$cwd\//}"
|
|
path="${path/#$HOME/~}"
|
|
|
|
echo "$path"
|
|
}
|
|
# un équivalent de basename écris en bash. note: le cas $1=/ n'est pas traité correctement
|
|
function bname() {
|
|
local bn="${1%%/}"
|
|
bn="${p##*/}"
|
|
[ -n "$2" ] && bn="${p%%$2}"
|
|
echo "$bn"
|
|
}
|
|
# un équivalent de dirname écris en bash
|
|
function dname() {
|
|
local dn="${1%%/}"
|
|
case "$dn" in
|
|
*/*)
|
|
dn="${dn%/*}"
|
|
;;
|
|
*)
|
|
dn="."
|
|
;;
|
|
esac
|
|
echo "$dn"
|
|
}
|
|
# sed qui modifie le fichier en place. pour compatibilité avec d'autres
|
|
# plateformes (cf system_caps), cette version ne devrait être appelée que de
|
|
# cette manière::
|
|
# sedi "script" [files...]
|
|
# toute autre utilisation fonctionnerait sur Linux mais pas sur MacOS X ou SunOS
|
|
function sedi() {
|
|
sed -i "$@"
|
|
}
|
|
# run_as: fonction pour relancer le script courant afin qu'il tourne avec les
|
|
# droits d'un autre user (typiquement root). Attention! cette fonction ne teste
|
|
# pas avec si on est déjà ce user. Il y a donc un risque de boucle infinie si on
|
|
# ne teste pas le user courant.
|
|
function run_as() {
|
|
# Lancer cette fonction avec les arguments du script en cours. Par exemple::
|
|
# run_as root "$@"
|
|
# Si $2=--noexec, on n'utilise pas la fonction exec, ce qui fait que la
|
|
# fonction retourne. Sinon, on peut considérer que cette fonction ne
|
|
# retourne jamais
|
|
local OENC="$UTF8"
|
|
local user="${1:-root}"; shift
|
|
local exec_maybe=exec
|
|
if [ "$1" = "--noexec" ]; then
|
|
exec_maybe=
|
|
shift
|
|
fi
|
|
|
|
# on peut spécifer localement le niveau de verbosité
|
|
local VERBOSITY="$VERBOSITY" INTERACTION="$INTERACTION"
|
|
set_verbosity "$1" && shift
|
|
|
|
estep "Lancement du script sur $HOSTNAME en tant que $user"
|
|
if is_yes "$UTOOLS_USES_SU" || ! progexists sudo; then
|
|
einfo "Entrez le mot de passe de root"
|
|
$exec_maybe su "$user" -c "${BASH:-/bin/sh} \"$0\" $*"
|
|
else
|
|
einfo "Entrez le mot de passe de $USER (si nécessaire)"
|
|
if [ "$user" == "root" ]; then
|
|
$exec_maybe sudo "${BASH:-/bin/sh}" "$0" "$@"
|
|
else
|
|
local args="$*"
|
|
args="${args//|/\\|}"
|
|
args="${args//</\\<}"
|
|
args="${args//>/\\>}"
|
|
args="${args//;/\\;}"
|
|
$exec_maybe sudo su "$user" -c "${BASH:-/bin/sh} \"$0\" $args"
|
|
fi
|
|
fi
|
|
}
|
|
# run_as_root: fonction pour relancer le script courant afin qu'il tourne en
|
|
# root. Attention! cette fonction ne teste pas avec is_root si on est déjà en
|
|
# root ou non. Ne pas appeler cette fonction si is_root est vrai, on risque une
|
|
# boucle infinie.
|
|
function run_as_root() {
|
|
run_as root "$@"
|
|
}
|
|
|
|
# === fonctions pour contrôler l'encoding en sortie et en entrée ===
|
|
LATIN1=iso-8859-1
|
|
LATIN9=iso-8859-15
|
|
UTF8=utf-8
|
|
|
|
if ! progexists iconv; then
|
|
function iconv() { cat; }
|
|
fi
|
|
|
|
function __lang_encoding() {
|
|
local lang="$(<<<"$LANG" awk '{ print tolower($0) }')"
|
|
case "$lang" in
|
|
fr_fr@euro) echo "iso-8859-15";;
|
|
fr_fr) echo "iso-8859-1";;
|
|
*.utf-8) echo "utf-8";;
|
|
*) ;;
|
|
esac
|
|
}
|
|
function __norm_encoding() {
|
|
awk '{
|
|
enc = tolower($0)
|
|
gsub(/^latin$/, "latin1", enc)
|
|
gsub(/^latin1$/, "iso-8859-1", enc)
|
|
gsub(/^latin9$/, "iso-8859-15", enc)
|
|
gsub(/[-_]/, "", enc)
|
|
if (enc == "iso8859" || enc == "iso88591" || enc == "8859" || enc == "88591") print "iso-8859-1"
|
|
else if (enc == "iso885915" || enc == "885915") print "iso-8859-15"
|
|
else if (enc == "utf8") print "utf-8"
|
|
else print $0
|
|
}' <<<"$1"
|
|
}
|
|
function __init_encoding() {
|
|
local DEFAULT_ENCODING="$(__lang_encoding)"
|
|
[ -n "$DEFAULT_ENCODING" ] || DEFAULT_ENCODING=utf-8
|
|
[ -n "$UTOOLS_OUTPUT_ENCODING" ] || UTOOLS_OUTPUT_ENCODING="$DEFAULT_ENCODING"
|
|
UTOOLS_OUTPUT_ENCODING="$(__norm_encoding "$UTOOLS_OUTPUT_ENCODING")"
|
|
[ -n "$UTOOLS_INPUT_ENCODING" ] || UTOOLS_INPUT_ENCODING="$UTOOLS_OUTPUT_ENCODING"
|
|
UTOOLS_INPUT_ENCODING="$(__norm_encoding "$UTOOLS_INPUT_ENCODING")"
|
|
[ -n "$UTOOLS_EDITOR_ENCODING" ] || UTOOLS_EDITOR_ENCODING="$UTOOLS_INPUT_ENCODING"
|
|
UTOOLS_EDITOR_ENCODING="$(__norm_encoding "$UTOOLS_EDITOR_ENCODING")"
|
|
|
|
IENC="$UTOOLS_INPUT_ENCODING"
|
|
OENC="$UTOOLS_OUTPUT_ENCODING"
|
|
}
|
|
__init_encoding
|
|
|
|
function tooenc() {
|
|
local src="$1" from="${2:-$OENC}" to="${3:-$UTOOLS_OUTPUT_ENCODING}"
|
|
if [ "$from" == "$to" ]; then
|
|
echo "$src"
|
|
else
|
|
iconv -f "$from" -t "$to" <<<"$src"
|
|
fi
|
|
}
|
|
function uecho() { tooenc "$*"; }
|
|
function tooenc_() {
|
|
local src="$1" from="${2:-$OENC}" to="${3:-$UTOOLS_OUTPUT_ENCODING}"
|
|
if [ "$from" == "$to" ]; then
|
|
echo_ "$src"
|
|
else
|
|
echo_ "$src" | iconv -f "$from" -t "$to"
|
|
fi
|
|
}
|
|
function uecho_() { tooenc_ "$*"; }
|
|
function toienc() {
|
|
local var_="$1" to_="${2:-$IENC}" from_="${3:-$UTOOLS_INPUT_ENCODING}"
|
|
if [ "$from_" != "$to_" ]; then
|
|
set_var "$var_" "$(iconv -f "$from_" -t "$to_" <<<"${!1}")"
|
|
fi
|
|
}
|
|
function uread() {
|
|
local var_
|
|
[ $# == 0 ] && set -- REPLY
|
|
read "$@"
|
|
for var_ in "$@"; do
|
|
[ -z "$var_" -o "${var_:0:1}" == "-" ] && continue # ignorer les options
|
|
toienc "$var_"
|
|
done
|
|
}
|
|
|
|
function stooenc() {
|
|
local from="${1:-$OENC}" to="${2:-$UTOOLS_OUTPUT_ENCODING}"
|
|
if [ "$from" == "$to" ]; then
|
|
cat
|
|
else
|
|
iconv -f "$from" -t "$to"
|
|
fi
|
|
}
|
|
function stoolatin1() { stooenc "iso-8859-1"; }
|
|
function stoolatin9() { stooenc "iso-8859-15"; }
|
|
function stooutf8() { stooenc "utf-8"; }
|
|
function stoienc() {
|
|
local to="${1:-$IENC}" from="${2:-$UTOOLS_INPUT_ENCODING}"
|
|
if [ "$from" == "$to" ]; then
|
|
cat
|
|
else
|
|
iconv -f "$from" -t "$to"
|
|
fi
|
|
}
|
|
function stoilatin1() { stoienc "iso-8859-1"; }
|
|
function stoilatin9() { stoienc "iso-8859-15"; }
|
|
function stoiutf8() { stoienc "utf-8"; }
|
|
|
|
# === fonctions pour contrôler l'affichage et l'interaction utilisateur ===
|
|
# ces fonctions n'affiche le message que si le niveau de "verbosité" est
|
|
# suffisant:
|
|
# 4=afficher les messages de debug; 3=afficher les message informatifs;
|
|
# 2=afficher les warnings et les notes; 1=afficher les erreurs
|
|
# 0=ne rien afficher
|
|
|
|
# niveau de "verbosité". on commence par défaut à 3
|
|
MIN_VERBOSITY=0
|
|
DEF_VERBOSITY=3
|
|
MAX_VERBOSITY=4
|
|
export VERBOSITY="${VERBOSITY:-$DEF_VERBOSITY}"
|
|
# niveau d'interaction.
|
|
MIN_INTERACTION=0
|
|
DEF_INTERACTION=2
|
|
MAX_INTERACTION=3
|
|
export INTERACTION="${INTERACTION:-$DEF_INTERACTION}"
|
|
|
|
function set_verbosity() {
|
|
# Configurer le niveau de verbosité ou d'interaction en fonction de la
|
|
# valeur de $1. Retourner 0 si l'argument a été utilisé, 1 sinon
|
|
|
|
# $2 est la valeur d'un préfixe pour reconnaitre des options courtes
|
|
# supplémentaires. Par défaut, les options suivantes sont reconnues: -c, -q,
|
|
# -v, -Q, -D, ... Si le préfixe est -v par exemple, les options reconnues
|
|
# seront -vc, -vq, -vv, -vQ, -vD, ... *en plus* de -c, -q, -v, -Q, -D, ...
|
|
|
|
local retval=0
|
|
local enable_fake_arg=
|
|
local prefix="-"
|
|
|
|
if [ "$1" = "--enable-fake-arg" ]; then
|
|
shift
|
|
enable_fake_arg=1
|
|
fi
|
|
|
|
[ -n "$2" ] && prefix="$2"
|
|
case "$1" in
|
|
# Ne changer, ni le niveau de verbosité, ni le niveau d'interaction, mais
|
|
# seulement si --enable-fake-arg a été activé
|
|
# Cette option permet à ask_yesno() et read_value() de spécifier les
|
|
# messages qui doivent être affichés dans le niveau par défaut de
|
|
# verbosité/interaction
|
|
-c|"${prefix}c"|--default)
|
|
[ -n "$enable_fake_arg" ] || retval=1
|
|
;;
|
|
|
|
# Configurer le niveau de verbosité en fonction de l'argument: -q le
|
|
# diminue, -Q le met au minimum, -v l'augmente, -D le met au maximum
|
|
-q|"${prefix}q"|--quiet)
|
|
[ $VERBOSITY -gt $MIN_VERBOSITY ] && VERBOSITY=$(($VERBOSITY - 1))
|
|
;;
|
|
-v|"${prefix}v"|--verbose)
|
|
[ $VERBOSITY -lt $MAX_VERBOSITY ] && VERBOSITY=$(($VERBOSITY + 1))
|
|
;;
|
|
-Q|"${prefix}Q"|--very-quiet)
|
|
VERBOSITY=$MIN_VERBOSITY
|
|
;;
|
|
-D|"${prefix}D"|--debug)
|
|
VERBOSITY=$MAX_VERBOSITY
|
|
;;
|
|
|
|
# Configurer le niveau d'interaction en fonction de l'argument: -b le met au
|
|
# minimum, -y le diminue, -i l'augmente
|
|
-b|"${prefix}b"|--batch)
|
|
# niveau d'interaction minimum
|
|
INTERACTION=$MIN_INTERACTION
|
|
;;
|
|
-y|"${prefix}y"|--automatic)
|
|
# Dimininuer le niveau d'interaction
|
|
[ $INTERACTION -gt $MIN_INTERACTION ] && INTERACTION=$(($INTERACTION - 1))
|
|
;;
|
|
-i|"${prefix}i"|--interactive)
|
|
# Augmenter le niveau d'interaction. Augmenter aussi le niveau de verbosité
|
|
[ $INTERACTION -lt $MAX_INTERACTION ] && INTERACTION=$(($INTERACTION + 1))
|
|
;;
|
|
|
|
*)
|
|
retval=1
|
|
;;
|
|
esac
|
|
return $retval
|
|
}
|
|
|
|
function check_verbosity() {
|
|
# Teste si le niveau de verbosité/interaction courant est suffisant pour une
|
|
# opération dont le niveau est donné par $1
|
|
|
|
# Par exemple, 'check_verbosity -y' ne retourne vrai que si le niveau
|
|
# d'interaction courant est supérieur ou égal à ($DEF_INTERACTION - 1). Cela
|
|
# permet d'afficher un message ou d'effectuer une opération si on est au
|
|
# moins en mode automatic (par contre, en mode batch, l'opération ne sera
|
|
# pas effectué
|
|
|
|
# De même 'check_verbosity -v' ne retourne vrai que si le niveau de
|
|
# verbosité courant est supérieur ou égal à ($DEF_VERBOSITY+1). Cela permet
|
|
# de n'afficher un message que si l'on est en mode verbose par exemple.
|
|
|
|
# 'check_verbosity -c' retourne toujours vrai
|
|
|
|
# Si $1 n'est pas un argument valide pour set_verbosity, alors on teste le
|
|
# niveau de verbosité ou d'interaction par défaut. si $2!="", alors on teste
|
|
# si le niveau de verbosité courant est supérieur à $2. Si $3!="", alors on
|
|
# teste sur le niveau d'interaction est supérieur à $3
|
|
|
|
# Si le premier argument est --action, alors on affiche "shift", "return",
|
|
# ou ":" suivant l'action à effectuer. Sinon, retourner 0 si le niveau est
|
|
# correct (Si $2="" et $3="", l'argument a été interprété et il faut faire
|
|
# un shift. Sinon l'argument a peut-être été interprété. On ne sait pas
|
|
# alors, sauf si on spécifie --action, s'il faut faire un shift ou non), 1
|
|
# si le niveau n'est pas correct, mais l'argument $1 a été interprété (donc
|
|
# il faut faire un shift) et 2 si l'argument n'est pas correct (n'a pas été
|
|
# interprété)
|
|
|
|
local verbosity="$VERBOSITY" interaction="$INTERACTION"
|
|
local VERBOSITY="$DEF_VERBOSITY" INTERACTION="$DEF_INTERACTION"
|
|
local action=
|
|
|
|
if [ "$1" = "--action" ]; then
|
|
shift
|
|
action=1
|
|
fi
|
|
|
|
if set_verbosity --enable-fake-arg "$1"; then
|
|
shift
|
|
if [ $interaction -ne $INTERACTION -a $interaction -ge $INTERACTION ] ||
|
|
[ $verbosity -ne $VERBOSITY -a $verbosity -ge $VERBOSITY ] ||
|
|
[ $interaction -eq $INTERACTION -a $verbosity -eq $VERBOSITY ]; then
|
|
[ -n "$action" ] && echo shift
|
|
return 0
|
|
else
|
|
[ -n "$action" ] && echo return
|
|
return 1
|
|
fi
|
|
else
|
|
if [ -n "$2" ] && [ "$verbosity" -gt "$2" ]; then
|
|
[ -n "$action" ] && echo :
|
|
return 0 # ce cas n'est pas équivalent à celui ci-dessus (pas de shift à faire!)
|
|
elif [ -n "$3" ] && [ "$interaction" -gt "$3" ]; then
|
|
[ -n "$action" ] && echo :
|
|
return 0 # ce cas n'est pas équivalent à celui ci-dessus (pas de shift à faire!)
|
|
else
|
|
[ -n "$action" ] && echo return
|
|
return 2
|
|
fi
|
|
fi
|
|
}
|
|
|
|
function echo_() { echo -n "$*"; }
|
|
|
|
# Couleurs
|
|
tty -s <&1 && NO_COLORS= || NO_COLORS=1
|
|
function get_color() {
|
|
[ -n "$NO_COLORS" ] && return
|
|
[ -z "$*" ] && set RESET
|
|
|
|
echo_ $'\e['
|
|
local sep
|
|
while [ -n "$1" ]; do
|
|
[ -n "$sep" ] && echo_ ";"
|
|
case "$1" in
|
|
z|RESET) echo_ "0";;
|
|
o|BLACK) echo_ "30";;
|
|
r|RED) echo_ "31";;
|
|
g|GREEN) echo_ "32";;
|
|
y|YELLOW) echo_ "33";;
|
|
b|BLUE) echo_ "34";;
|
|
m|MAGENTA) echo_ "35";;
|
|
c|CYAN) echo_ "36";;
|
|
w|WHITE) echo_ "37";;
|
|
DEFAULT) echo_ "39";;
|
|
O|BLACK_BG) echo_ "40";;
|
|
R|RED_BG) echo_ "41";;
|
|
G|GREEN_BG) echo_ "42";;
|
|
Y|YELLOW_BG) echo_ "43";;
|
|
B|BLUE_BG) echo_ "44";;
|
|
M|MAGENTA_BG) echo_ "45";;
|
|
C|CYAN_BG) echo_ "46";;
|
|
W|WHITE_BG) echo_ "47";;
|
|
DEFAULT_BG) echo_ "49";;
|
|
@|BOLD) echo_ "1";;
|
|
-|FAINT) echo_ "2";;
|
|
_|UNDERLINED) echo_ "4";;
|
|
~|REVERSE) echo_ "7";;
|
|
n|NORMAL) echo_ "22";;
|
|
esac
|
|
sep=1
|
|
shift
|
|
done
|
|
echo_ "m"
|
|
}
|
|
|
|
COULEUR_ROUGE="$(get_color RED BOLD)"
|
|
COULEUR_VERTE="$(get_color GREEN BOLD)"
|
|
COULEUR_JAUNE="$(get_color YELLOW BOLD)"
|
|
COULEUR_BLEUE="$(get_color BLUE BOLD)"
|
|
COULEUR_BLANCHE="$(get_color WHITE BOLD)"
|
|
COULEUR_NORMALE="$(get_color RESET)"
|
|
|
|
# tester le niveau de "verbosité" ou d'interaction
|
|
function is_quiet() { [ $VERBOSITY -lt $DEF_VERBOSITY ]; }
|
|
function is_verbose() { ! is_quiet; }
|
|
function is_interactive() { [ $INTERACTION -ge $DEF_INTERACTION ]; }
|
|
function is_automatic() { [ $INTERACTION -lt $DEF_INTERACTION ]; }
|
|
function is_batch() { [ $INTERACTION -eq $MIN_INTERACTION ]; }
|
|
|
|
# afficher une erreur *sur stderr*
|
|
function display_error() { [ $VERBOSITY -gt 0 ]; }
|
|
function eerror() {
|
|
eval `check_verbosity --action "$1" 0`
|
|
echo_ "${COULEUR_ROUGE}error:${COULEUR_NORMALE} " 1>&2
|
|
tooenc "$*" 1>&2
|
|
}
|
|
|
|
# afficher un warning ou une note *sur stderr*
|
|
function display_warning() { [ $VERBOSITY -gt 1 ]; }
|
|
function ewarn() {
|
|
eval `check_verbosity --action "$1" 1`
|
|
echo_ "${COULEUR_JAUNE}warning:${COULEUR_NORMALE} " 1>&2
|
|
tooenc "$*" 1>&2
|
|
}
|
|
function enote() {
|
|
eval `check_verbosity --action "$1" 1`
|
|
echo_ "${COULEUR_VERTE}note:${COULEUR_NORMALE} " 1>&2
|
|
tooenc "$*" 1>&2
|
|
}
|
|
|
|
# afficher une information
|
|
function display_info() { [ $VERBOSITY -gt 2 ]; }
|
|
function etitle() {
|
|
eval `check_verbosity --action "$1" 2`
|
|
echo_ "${COULEUR_BLANCHE}>>> "
|
|
tooenc_ "$*"
|
|
echo " <<<${COULEUR_NORMALE}"
|
|
}
|
|
function esubtitle() {
|
|
eval `check_verbosity --action "$1" 2`
|
|
echo_ "${COULEUR_BLANCHE}*** "
|
|
tooenc_ "$*"
|
|
echo "${COULEUR_NORMALE}"
|
|
}
|
|
function eimportant() {
|
|
eval `check_verbosity --action "$1" 2`
|
|
echo_ "${COULEUR_ROUGE}important:${COULEUR_NORMALE} "
|
|
tooenc "$*"
|
|
}
|
|
function eattention() {
|
|
eval `check_verbosity --action "$1" 2`
|
|
echo_ "${COULEUR_JAUNE}attention:${COULEUR_NORMALE} "
|
|
tooenc "$*"
|
|
}
|
|
function ecomment() {
|
|
eval `check_verbosity --action "$1" 2`
|
|
echo_ "${COULEUR_VERTE}commentaire:${COULEUR_NORMALE} "
|
|
tooenc "$*"
|
|
}
|
|
function einfo() {
|
|
eval `check_verbosity --action "$1" 2`
|
|
tooenc "$*"
|
|
}
|
|
function einfon() {
|
|
eval `check_verbosity --action "$1" 2`
|
|
tooenc_ "$*"
|
|
}
|
|
|
|
# afficher un message de debug
|
|
function is_debug() { [ $VERBOSITY -gt 3 ]; }
|
|
function edebug() {
|
|
eval `check_verbosity --action "$1" 3`
|
|
echo_ "${COULEUR_BLANCHE}debug:${COULEUR_NORMALE} "
|
|
tooenc "$*"
|
|
}
|
|
function edebugn() {
|
|
eval `check_verbosity --action "$1" 3`
|
|
echo_ "${COULEUR_BLANCHE}debug:${COULEUR_NORMALE} "
|
|
tooenc_ "$*"
|
|
}
|
|
|
|
# Fonctions d'affichage pour suivre la progression d'opérations
|
|
function estep() {
|
|
# Une opération entière
|
|
eval `check_verbosity --action "$1" 2`
|
|
echo_ "${COULEUR_BLANCHE}*${COULEUR_NORMALE} "
|
|
tooenc "$*"
|
|
}
|
|
function estepn() {
|
|
# Une opération entière
|
|
eval `check_verbosity --action "$1" 2`
|
|
echo_ "${COULEUR_BLANCHE}*${COULEUR_NORMALE} "
|
|
tooenc_ "$*"
|
|
}
|
|
|
|
function ebegin() {
|
|
# Le début d'une opération
|
|
eval `check_verbosity --action "$1" 2`
|
|
echo_ "${COULEUR_BLANCHE}*${COULEUR_NORMALE} "
|
|
tooenc_ "$*"
|
|
echo_ ":"
|
|
utools_ESTATUS_=0
|
|
utools_edot_first_=1
|
|
}
|
|
|
|
function edot() {
|
|
# Une étape d'une opération commencée par ebegin, matérialisée par un "."
|
|
# Si l'argument est un fichier, utiliser -f pour que "$HOME" et "$(pwd)/"
|
|
# soient remplacés respectivement par "~" et "" (afin que les chemins soient
|
|
# plus courts)
|
|
# Si l'argument est un commentaire, utiliser -m pour le spécifier. -w
|
|
# indique que l'argument est un warning: un x jaune est affiché, avec le
|
|
# message associé si on est en mode debug.
|
|
# Sinon, l'argument est un status. 0 affiche un ".", sinon on affiche un "x"
|
|
local status=$?
|
|
local warn= color=
|
|
|
|
if [ -n "$utools_edot_first_" ]; then
|
|
# au premier dot, afficher un espace d'abord
|
|
echo_ " "
|
|
utools_edot_first_=
|
|
fi
|
|
|
|
eval `check_verbosity --action "$1" 2`
|
|
if is_debug; then
|
|
local msg paths path
|
|
if [ "$1" = "-f" ]; then
|
|
# chemins
|
|
shift
|
|
for path in "$@"; do
|
|
paths="${paths:+$paths,}$(ppath "$path")"
|
|
done
|
|
msg="$paths"
|
|
elif [ "$1" = "-m" -o "$1" = "-w" ]; then
|
|
# message
|
|
[ "$1" = "-w" ] && warn=1 # message de warning
|
|
shift
|
|
msg="$(tooenc "$*")"
|
|
else
|
|
# status
|
|
[ -n "$1" ] && status="$1"
|
|
fi
|
|
|
|
[ "$utools_ESTATUS_" -eq 0 -a "$status" -ne 0 ] && utools_ESTATUS_="$status"
|
|
if [ "$status" -eq 0 -a -z "$warn" ]; then
|
|
echo_ "${msg:+
|
|
}.${msg:+($msg)}"
|
|
else
|
|
color="$COULEUR_ROUGE"
|
|
[ -n "$warn" ] && color="$COULEUR_JAUNE"
|
|
echo_ "${msg:+
|
|
}${color}x${COULEUR_NORMALE}${msg:+($msg)}"
|
|
fi
|
|
else
|
|
if [ "$1" = "-f" -o "$1" = "-m" -o "$1" = "-w" ]; then
|
|
[ "$1" = "-w" ] && warn=1 # message de warning
|
|
shift
|
|
else
|
|
[ -n "$1" ] && status="$1"
|
|
fi
|
|
|
|
[ "$utools_ESTATUS_" -eq 0 -a "$status" -ne 0 ] && utools_ESTATUS_="$status"
|
|
if [ "$status" -eq 0 -a -z "$warn" ]; then
|
|
echo_ "."
|
|
else
|
|
color="$COULEUR_ROUGE"
|
|
[ -n "$warn" ] && color="$COULEUR_JAUNE"
|
|
echo_ "${color}x${COULEUR_NORMALE}"
|
|
fi
|
|
fi
|
|
}
|
|
|
|
function ewait() {
|
|
# Une étape d'un opération commencée par ebegin, matérialisée par des "+"
|
|
# qui s'affichent tant que le processus de PID $1 tourne
|
|
# à utiliser de cette manière:
|
|
# ebegin "lancement de cmd"
|
|
# cmd &
|
|
# ewait $!
|
|
# eend
|
|
local action status
|
|
action="$(check_verbosity --action "$1" 2)"
|
|
status=$? # le status de check_verbosity
|
|
if [ "$action" == "return" ]; then #
|
|
# ne rien afficher, mais attendre quand même que le processus s'arrête
|
|
[ $status -eq 1 ] && shift
|
|
|
|
local pid="$1"
|
|
[ -n "$pid" ] && wait "$pid"
|
|
return
|
|
fi
|
|
|
|
eval "$action"
|
|
|
|
if [ -n "$utools_edot_first_" ]; then
|
|
# au premier dot, afficher un espace d'abord
|
|
echo_ " "
|
|
utools_edot_first_=
|
|
fi
|
|
|
|
local pid="$1"
|
|
local count=2 # attendre 2 secondes avant de commencer à afficher des "+"
|
|
[ -z "$pid" ] && return
|
|
|
|
little_sleep # certains processus retournent tout de suite
|
|
while is_running "$pid"; do
|
|
sleep 1
|
|
if [ $count -gt 0 ]; then
|
|
count=$(($count - 1))
|
|
else
|
|
echo_ "+"
|
|
fi
|
|
done
|
|
echo_ "." # terminer par un "."
|
|
}
|
|
|
|
function eend() {
|
|
# la fin d'une opération commencée par ebegin
|
|
local status=0
|
|
|
|
eval `check_verbosity --action "$1" 2`
|
|
|
|
[ -n "$1" ] && status="$1"
|
|
[ "$utools_ESTATUS_" -eq 0 -a "$status" -ne 0 ] && utools_ESTATUS_="$status"
|
|
if [ "$utools_ESTATUS_" -eq 0 ]; then
|
|
echo " ${COULEUR_VERTE}ok${COULEUR_NORMALE}"
|
|
else
|
|
echo " ${COULEUR_ROUGE}error${COULEUR_NORMALE}"
|
|
fi
|
|
|
|
status=$utools_ESTATUS_
|
|
unset utools_ESTATUS_
|
|
return $status
|
|
}
|
|
|
|
# Arrêter le script avec un message d'erreur
|
|
function die() { [ -n "$*" ] && eerror "$@"; exit 1; }
|
|
|
|
# === Nom du système ===
|
|
export SYSTEM_NAME="`uname -s`"
|
|
beginswith "$SYSTEM_NAME" CYGWIN && SYSTEM_NAME=Cygwin
|
|
beginswith "$SYSTEM_NAME" MINGW32 && SYSTEM_NAME=Mingw
|
|
export SYSTEM_MACHINE="`uname -m`"
|
|
|
|
if [ "$SYSTEM_NAME" == "Linux" ]; then
|
|
if [ -f /etc/debian_version ]; then
|
|
LINUX_FLAVOUR=debian
|
|
elif [ -f /etc/gentoo-release ]; then
|
|
LINUX_FLAVOUR=gentoo
|
|
elif [ -f /etc/redhat-release ]; then
|
|
LINUX_FLAVOUR=redhat
|
|
else
|
|
LINUX_FLAVOUR=
|
|
fi
|
|
if [ "$SYSTEM_MACHINE" == "x86_64" ]; then
|
|
SYSTEM_BITS=64
|
|
else
|
|
SYSTEM_BITS=32
|
|
fi
|
|
elif [ "$SYSTEM_NAME" == "Darwin" ]; then
|
|
MACOSX_VERSION="$(grep -A 1 CFBundleShortVersionString /System/Library/Frameworks/CoreServices.framework/Frameworks/Metadata.framework/Resources/version.plist | grep string | sed 's/.*<string>//g
|
|
s/<\/string>.*$//g')"
|
|
MACOSX_NAME=UNSUPPORTED
|
|
if beginswith "$MACOSX_VERSION" 10.5; then
|
|
MACOSX_NAME=LEOPARD
|
|
elif beginswith "$MACOSX_VERSION" 10.4; then
|
|
MACOSX_NAME=TIGER
|
|
fi
|
|
SYSTEM_BITS=
|
|
fi
|
|
|
|
# === vérifications ===
|
|
[ -d "$TMPDIR" ] || ewarn "TMPDIR ($TMPDIR) n'existe pas"
|
|
##@inc]../../legacy/sysinc/base
|
|
__MAKE_SYSTEM_CAPS__="$(dirname "$0")/../../legacy/system_caps"
|
|
##@inc[../../legacy/sysinc/system_caps
|
|
# -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
|
##@require base
|
|
|
|
# system_caps: Déterminer les capacités du syteme sur lequel nous tournons. Ces
|
|
# scripts sont prévus pour adapter un système non Linux pour qu'il fonctionne a
|
|
# peu près comme Linux. Les fonctions de base qui doivent être adaptées le sont
|
|
# en fonction du système sur lequel on tourne. Il suffit d'inclure ce fichier
|
|
# pour bénéficier des nouvelles fonctionnalités
|
|
|
|
# note: sous Linux, ces scripts sont essentiellement un no-op
|
|
|
|
__SYSTEM_CAPS_COMPUTED__=
|
|
if [ -z "$__MAKE_SYSTEM_CAPS__" -a -z "$__FORCE_COMPUTE_SYSTEM_CAPS__" -a -f "@@dest@@/legacy/system_caps" ]; then
|
|
source "@@dest@@/legacy/system_caps"
|
|
fi
|
|
|
|
unset __FORCE_COMPUTE_SYSTEM_CAPS__
|
|
if [ -z "$__SYSTEM_CAPS_COMPUTED__" ]; then
|
|
if [ -n "$__MAKE_SYSTEM_CAPS__" ]; then
|
|
>"$__MAKE_SYSTEM_CAPS__"
|
|
fi
|
|
|
|
function __define_and_eval__() {
|
|
if [ -n "$__MAKE_SYSTEM_CAPS__" ]; then
|
|
echo "$1" >>"$__MAKE_SYSTEM_CAPS__"
|
|
fi
|
|
eval "$1"
|
|
}
|
|
|
|
function __verify_system__() {
|
|
# Vérifier que le système est supporté
|
|
local OENC="$UTF8"
|
|
local system
|
|
for system in Linux SunOS Darwin Cygwin Mingw unsupported; do
|
|
[ "$system" = "$SYSTEM_NAME" ] && break
|
|
[ "$system" = "unsupported" ] && die "$SYSTEM_NAME: Système non supporté"
|
|
done
|
|
}
|
|
__verify_system__; unset -f __verify_system__
|
|
|
|
function __get_which_caps__() {
|
|
[ "$SYSTEM_NAME" = "Linux" ] && return
|
|
|
|
# Obtenir les capacités de which: certaines implémentations affichent "no x
|
|
# in ..." sur stdout au lieu de l'afficher sur stderr
|
|
local OENC="$UTF8"
|
|
local tmpout="$TMPDIR/which_test.$$.out"
|
|
local tmperr="$TMPDIR/which_test.$$.err"
|
|
which __une_appli_qui_existe_pas__ >"$tmpout" 2>"$tmperr"
|
|
if [ -s "$tmpout" ]; then
|
|
__legacy_which__=1 # legacy
|
|
elif [ -s "$tmperr" ]; then
|
|
: # cas normal
|
|
else
|
|
__legacy_which__=2 # MacOSX 10.5
|
|
fi
|
|
/bin/rm -f "$tmpout"
|
|
/bin/rm -f "$tmperr"
|
|
|
|
if [ "$__legacy_which__" == 1 ]; then
|
|
local grep="${grep:-`which grep 2>&1`}"
|
|
if [ -x "$grep" ]; then
|
|
__define_and_eval__ 'function progexists() { test -n "$1" -a -z "$(which "$1" 2>&1 | '"$grep"' "^no $1")"; }'
|
|
else
|
|
die "grep est requis pour l'implémentation de progexists() sur ce système"
|
|
fi
|
|
elif [ "$__legacy_which__" == 2 ]; then
|
|
__define_and_eval__ 'function progexists() { which "$1" >&/dev/null; }'
|
|
fi
|
|
}
|
|
__get_which_caps__; unset -f __get_which_caps__
|
|
|
|
function __set_prog_func__() {
|
|
# Tester la présence d'un programme sur le système en cours, et si
|
|
# le programme doit être accedé avec un chemin absolu, créer une
|
|
# fonction du nom de ce programme qui pourra être utilisée pour
|
|
# appeler ce programme.
|
|
|
|
# $1 == nom de la fonction a créer. Il s'agit géneralement du nom du
|
|
# programme, mais ce n'est pas une obligation.
|
|
|
|
# $2 == nom à afficher si le programme n'est pas trouvé. Le message
|
|
# affiché sera de la forme "Ce script requière $2....". Si cette
|
|
# valeur est non vide, le programme *doit exister* sinon le script
|
|
# se termine. Si la valeur est "-", alors il s'agit de $1.
|
|
|
|
# $3..$n == chemins dans lesquels il faut chercher le programme. Si
|
|
# la valeur est "-", on teste si le programme est disponible dans le
|
|
# path.
|
|
local OENC="$UTF8"
|
|
local prog="$1"; shift
|
|
local req="$1"; shift
|
|
|
|
if [ -z "$prog" ]; then
|
|
die "USAGE: __set_prog_func__ prog_func req? path [paths...]"
|
|
fi
|
|
|
|
if [ -n "${!prog}" ]; then
|
|
# Si une variable de ce nom est deja definie, on assume qu'il
|
|
# s'agit du chemin vers le programme
|
|
__define_and_eval__ 'function '"$prog"'() { '"${!prog}"' "$@"; }'
|
|
return 0
|
|
fi
|
|
|
|
local found=
|
|
while [ -n "$1" ]; do
|
|
local path="$1"; shift
|
|
|
|
if [ "$path" = "--legacy" ]; then
|
|
# Declarer que les programmes qui suivent sont "legacy"
|
|
__define_and_eval__ 'export __legacy_'"$prog"'__=1'
|
|
continue
|
|
fi
|
|
|
|
if [ "${path#/}" = "$path" ] && progexists "$path"; then
|
|
# Si on donne un nom de programme, et que ce programme se
|
|
# trouve dans le path, l'adopter avec son chemin absolu
|
|
if [ "$path" != "$prog" ]; then
|
|
path="$(type -p "$path")"
|
|
__define_and_eval__ 'function '"$prog"'() { "'"$path"'" "$@"; }'
|
|
fi
|
|
found=1
|
|
break
|
|
fi
|
|
|
|
if [ "$path" = "-" ] && progexists "$prog"; then
|
|
# pas la peine de creer une fonction, la commande existe
|
|
# deja avec ce nom-la dans le path
|
|
found=1
|
|
break
|
|
fi
|
|
|
|
if [ -d "$path" ]; then path="$path/$prog"; fi
|
|
if [ -d "$path" ]; then continue; fi
|
|
|
|
if [ -x "$path" ]; then
|
|
__define_and_eval__ 'function '"$prog"'() { "'"$path"'" "$@"; }'
|
|
found=1
|
|
break
|
|
fi
|
|
done
|
|
|
|
if [ -z "$found" -a -n "$req" ]; then
|
|
if [ "$req" = "-" ]; then req="$prog"; fi
|
|
die "Ce script requière $req
|
|
Si ce programme est installé, faites
|
|
export $prog=/path/to/$prog
|
|
et relancez ce script"
|
|
fi
|
|
|
|
test -n "$found"
|
|
}
|
|
|
|
function __get_tools_path_and_caps__() {
|
|
[ "$SYSTEM_NAME" = "Linux" ] && return
|
|
|
|
# Obtenir l'emplacement d'outils standards, tels que:
|
|
# cp, awk, grep, diff, tar, ps, date
|
|
local system
|
|
|
|
# cp
|
|
for system in SunOS Darwin; do
|
|
[ "$SYSTEM_NAME" = "$system" ] && __define_and_eval__ 'export __legacy_cp__=1'
|
|
done
|
|
[ -n "$__legacy_cp__" ] && __define_and_eval__ 'function cp_a() { /bin/cp -pR "$@"; }'
|
|
|
|
# awk
|
|
if [ "$SYSTEM_NAME" = "SunOS" ]; then
|
|
__set_prog_func__ awk "gawk or nawk" \
|
|
gawk \
|
|
/usr/sfw/bin/gawk \
|
|
/opt/sfw/bin/gawk \
|
|
--legacy nawk \
|
|
/usr/bin/nawk
|
|
|
|
elif [ "$SYSTEM_NAME" = "Darwin" ]; then
|
|
# note: gensub() n'est supporté que sur gnuawk
|
|
# si __legacy_awk__ est défini, on sait que cette fonction n'est pas
|
|
# disponible
|
|
__set_prog_func__ awk "gawk or nawk" \
|
|
gawk \
|
|
/sw/bin/gawk \
|
|
/sw/bin/awk \
|
|
--legacy /usr/bin/awk
|
|
fi
|
|
|
|
# grep
|
|
if [ "$SYSTEM_NAME" = "SunOS" ]; then
|
|
__set_prog_func__ grep - \
|
|
ggrep \
|
|
/usr/sfw/bin/ggrep \
|
|
/opt/sfw/bin/ggrep \
|
|
--legacy /usr/bin/grep
|
|
fi
|
|
if [ -n "$__legacy_grep__" ]; then
|
|
__define_and_eval__ 'function quietgrep() { grep "$@" >&/dev/null; }'
|
|
fi
|
|
|
|
# diff
|
|
if [ "$SYSTEM_NAME" = "SunOS" ]; then
|
|
__set_prog_func__ diff - \
|
|
gdiff \
|
|
/usr/sfw/bin/gdiff \
|
|
/opt/sfw/bin/gdiff \
|
|
--legacy /usr/bin/diff
|
|
fi
|
|
if [ -n "$__legacy_diff__" ]; then
|
|
__define_and_eval__ 'function quietdiff() { diff "$@" >&/dev/null; }'
|
|
fi
|
|
|
|
# tar
|
|
if [ "$SYSTEM_NAME" = "SunOS" ]; then
|
|
__set_prog_func__ tar - \
|
|
gtar \
|
|
/usr/sfw/bin/gtar \
|
|
/opt/sfw/bin/gtar \
|
|
--legacy /usr/bin/tar
|
|
|
|
elif [ "$SYSTEM_NAME" = "Darwin" ]; then
|
|
__set_prog_func__ tar - \
|
|
gnutar gtar \
|
|
/sw/bin/gtar \
|
|
--legacy /usr/bin/tar
|
|
fi
|
|
|
|
# ps
|
|
if [ "$SYSTEM_NAME" = "SunOS" ]; then
|
|
__set_prog_func__ ps - \
|
|
/usr/ucb/ps \
|
|
--legacy /usr/bin/ps
|
|
__set_prog_func__ legacyps - \
|
|
/usr/bin/ps
|
|
__define_and_eval__ 'function is_running() { test -n "$(legacyps -o pid -p "$1" | grep -v PID)"; }'
|
|
fi
|
|
if [ -n "$__legacy_ps__" ]; then
|
|
__define_and_eval__ 'function ps_all() { ps -ef; }'
|
|
fi
|
|
|
|
# sleep
|
|
if [ "$SYSTEM_NAME" = "SunOS" -o "$SYSTEM_NAME" = "Darwin" ]; then
|
|
__define_and_eval__ 'function little_sleep() { n=1000; while [ $n -gt 0 ]; do n=$(($n - 1)); done; }'
|
|
fi
|
|
|
|
# date
|
|
if [ "$SYSTEM_NAME" = "SunOS" ]; then
|
|
__set_prog_func__ date - \
|
|
gdate \
|
|
/usr/sfw/bin/gdate \
|
|
/opt/sfw/bin/gdate \
|
|
--legacy /usr/bin/date
|
|
|
|
elif [ "$SYSTEM_NAME" = "Darwin" ]; then
|
|
__set_prog_func__ date - \
|
|
--legacy /bin/date
|
|
fi
|
|
|
|
# readlink
|
|
if ! progexists readlink; then
|
|
__define_and_eval__ 'function readlink() { if [ -L "$1" ]; then /bin/ls -ld "$1" | awk '"'"'{print $11'"'"'}; fi; }'
|
|
fi
|
|
|
|
# mktemp
|
|
if ! progexists mktemp; then
|
|
__define_and_eval__ 'function mktemp() { make_tempfile "$@"; }'
|
|
fi
|
|
|
|
# curl/wget (pour dumpurl)
|
|
if ! progexists curl; then
|
|
if [ "$SYSTEM_NAME" = "SunOS" ]; then
|
|
if __set_prog_func__ curl "" /usr/local/bin/curl; then
|
|
__define_and_eval__ 'export __curl_EXISTS__=1'
|
|
fi
|
|
fi
|
|
fi
|
|
if ! progexists wget; then
|
|
if [ "$SYSTEM_NAME" = "SunOS" ]; then
|
|
if __set_prog_func__ wget "" /usr/sfw/bin/wget /opt/sfw/bin/wget; then
|
|
__define_and_eval__ 'export __wget_EXISTS__=1'
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
# is_root
|
|
if [ "$SYSTEM_NAME" = "SunOS" ]; then
|
|
__define_and_eval__ 'function is_root() { id | quietgrep "uid=0"; }'
|
|
|
|
elif [ "$SYSTEM_NAME" = "Cygwin" -o "$SYSTEM_NAME" = "Mingw" ]; then
|
|
# on assume que sur ces systèmes, l'utilisateur est maitre à bord.
|
|
__define_and_eval__ 'function is_root() { true; }'
|
|
fi
|
|
|
|
# sedi
|
|
if [ "$SYSTEM_NAME" = "Darwin" ]; then
|
|
__define_and_eval__ 'function __1sedi() {
|
|
local script="$1" input="$2"
|
|
if sed -i.bak "$script" "$input"; then
|
|
/bin/rm -f "$input.bak"
|
|
fi
|
|
}
|
|
function sedi() {
|
|
local script="$1" input
|
|
shift
|
|
for input in "$@"; do
|
|
__1sedi "$script" "$input"
|
|
done
|
|
}'
|
|
elif [ "$SYSTEM_NAME" = "SunOS" ]; then
|
|
__define_and_eval__ 'function __1sedi() {
|
|
local script="$1" input="$2"
|
|
if sed "$script" "$input" >"$input.out.$$"; then
|
|
chmod "$(/bin/ls -l "$input" | awk '\''function oct(mod) {
|
|
value = 0
|
|
if (substr(mod, 1, 1) == "r") value = value + 4
|
|
if (substr(mod, 2, 1) == "w") value = value + 2
|
|
if (substr(mod, 3, 1) == "x") value = value + 1
|
|
return value
|
|
}
|
|
{
|
|
print oct(substr($1, 2, 3)) oct(substr($1, 5, 3)) oct(substr($1, 8, 3))
|
|
}'\'')" "$input.out.$$"
|
|
/bin/mv -f "$input.out.$$" "$input"
|
|
fi
|
|
}
|
|
function sedi() {
|
|
local script="$1" input
|
|
shift
|
|
for input in "$@"; do
|
|
__1sedi "$script" "$input"
|
|
done
|
|
}'
|
|
fi
|
|
|
|
# parse_date
|
|
if [ "$SYSTEM_NAME" = "Darwin" ]; then
|
|
function __pd_isleap() {
|
|
# tester si l'année $1 est bissextile
|
|
[ $(($1 % 4)) -eq 0 -a \( $(($1 % 100)) -ne 0 -o $(($1 % 400)) -eq 0 \) ]
|
|
}
|
|
function __pd_fix_month() {
|
|
# soit $1 le nom d'une variable contenant une année, et $2 le nom d'une
|
|
# variable contenant un mois, normaliser les valeurs de ces variables, en
|
|
# ajustant si nécessaire les valeurs.
|
|
local __pdfm_y="${!1}" __pdfm_m="${!2}"
|
|
let __pdfm_m=$__pdfm_m-1
|
|
while [ $__pdfm_m -gt 11 ]; do
|
|
let __pdfm_m=$__pdfm_m-12
|
|
let __pdfm_y=$__pdfm_y+1
|
|
done
|
|
while [ $__pdfm_m -lt 0 ]; do
|
|
let __pdfm_m=$__pdfm_m+12
|
|
let __pdfm_y=$__pdfm_y-1
|
|
done
|
|
let __pdfm_m=$__pdfm_m+1
|
|
eval "$1=$__pdfm_y; $2=$__pdfm_m"
|
|
}
|
|
__PD_MONTHDAYS=(0 31 28 31 30 31 30 31 31 30 31 30 31)
|
|
function __pd_monthdays() {
|
|
# calculer le nombre de jours du mois $2 de l'année $1
|
|
local y="$1" m="$2" mds
|
|
__pd_fix_month y m
|
|
mds="${__PD_MONTHDAYS[$m]}"
|
|
[ "$m" -eq 2 ] && __pd_isleap "$y" && let mds=$mds+1
|
|
echo $mds
|
|
}
|
|
function __pd_fix_day() {
|
|
# soit $1 le nom d'une variable contenant une année, $2 le nom d'une
|
|
# variable contenant un mois et $3 le nom d'une variable contenant un jour,
|
|
# normaliser les valeurs de ces variables, en ajustant si nécessaire les
|
|
# valeurs. cette fonction assume que la valeur de $2 est déjà corrigée avec
|
|
# __pd_fix_month
|
|
local __pdfd_y="${!1}" __pdfd_m="${!2}" __pdfd_d="${!3}" __pdfd_mds
|
|
let __pdfd_d=$__pdfd_d-1
|
|
let __pdfd_mds=$(__pd_monthdays $__pdfd_y $__pdfd_m)
|
|
while [ $__pdfd_d -gt $(($__pdfd_mds-1)) ]; do
|
|
let __pdfd_d=$__pdfd_d-$__pdfd_mds
|
|
let __pdfd_m=$__pdfd_m+1
|
|
__pd_fix_month __pdfd_y __pdfd_m
|
|
let __pdfd_mds=$(__pd_monthdays $__pdfd_y $__pdfd_m)
|
|
done
|
|
while [ $__pdfd_d -lt 0 ]; do
|
|
let __pdfd_m=$__pdfd_m-1
|
|
__pd_fix_month __pdfd_y __pdfd_m
|
|
let __pdfd_d=$__pdfd_d-$(__pd_monthdays $__pdfd_y $__pdfd_m)
|
|
done
|
|
let __pdfd_d=$__pdfd_d+1
|
|
eval "$1=$__pdfd_y; $2=$__pdfd_m; $3=$__pdfd_d"
|
|
}
|
|
function __pd_fix_date() {
|
|
# soit $1 le nom d'une variable contenant une année, $2 le nom d'une
|
|
# variable contenant un mois et $3 le nom d'une variable contenant un jour,
|
|
# normaliser les valeurs de ces variables, en ajustant si nécessaire les
|
|
# valeurs.
|
|
local __pdf_y="${!1}" __pdf_m="${!2}" __pdf_d="${!3}"
|
|
}
|
|
function parse_date() {
|
|
local value="$1" type="${2:-date}"
|
|
local d m y
|
|
# date courante
|
|
eval "$(date +%d/%m/%Y | awk -F/ '{
|
|
print "d=" $1 "; m=" $2 "; y=" $3
|
|
}')"
|
|
if [ "${value#+}" != "$value" ]; then
|
|
# ajouter $1 jours
|
|
d="$(($d+${value#+}))"
|
|
else
|
|
# parser une nouvelle date, en complétant avec les informations de la
|
|
# date du jour
|
|
eval "$(<<<"$value" awk -F/ "BEGIN {
|
|
dn=$dn; mn=$mn; yn=$yn
|
|
}"'
|
|
{
|
|
d = $1 + 0; if (d < 1) d = dn + 0;
|
|
m = $2 + 0; if (m < 1) m = mn + 0;
|
|
if ($3 == "") y = yn + 0;
|
|
else { y = $3 + 0; if (y < 100) y = y + 2000; }
|
|
print "d=" d "; m=" m "; y=" y
|
|
}')"
|
|
fi
|
|
# ensuite corriger les champs si nécessaire
|
|
__pd_fix_month y m
|
|
__pd_fix_day y m d
|
|
# enfin formater la date selon les volontés de l'utilisateur
|
|
case "$type" in
|
|
d|date)
|
|
awk "BEGIN { d=$d; m=$m; y=$y; "'printf "%02i/%02i/%04i\n", d, m, y }'
|
|
;;
|
|
l|ldap)
|
|
awk "BEGIN { d=$d; m=$m; y=$y; "'printf "%04i%02i%02i000000+0400\n", y, m, d }'
|
|
;;
|
|
esac
|
|
}
|
|
fi
|
|
}
|
|
__get_tools_path_and_caps__
|
|
unset -f __set_prog_func__ __get_tools_path_and_caps__
|
|
|
|
__define_and_eval__ "__SYSTEM_CAPS_COMPUTED__=1"
|
|
unset -f __define_and_eval__
|
|
fi
|
|
##@inc]../../legacy/sysinc/system_caps
|