fatalerrors/profile
1
0
Fork 0
Code Issues Pull Requests Projects Releases 9 Wiki Activity

Compare commits

base: fatalerrors:v3.6.1
Branches Tags
fatalerrors:master
fatalerrors:v3.6.1 fatalerrors:v3.6.0 fatalerrors:v3.3.1 fatalerrors:v3.2.3 fatalerrors:v3.2.2 fatalerrors:v3.2.1 fatalerrors:v3.2.0 fatalerrors:v3.1.1 fatalerrors:v3.1.0
...
compare: fatalerrors:7ca0a6fb8809c55c8e0ffa0c795efb248f016a22
Branches Tags
fatalerrors:master
fatalerrors:v3.6.1 fatalerrors:v3.6.0 fatalerrors:v3.3.1 fatalerrors:v3.2.3 fatalerrors:v3.2.2 fatalerrors:v3.2.1 fatalerrors:v3.2.0 fatalerrors:v3.1.1 fatalerrors:v3.1.0

5 Commits
v3.6.1 ... 7ca0a6fb88

Author SHA1 Message Date
fatalerrors
7ca0a6fb88 fixed README, version bump 2026-03-10 10:55:02 +01:00
fatalerrors
25df408e37 implemented ini style parsed configuration file 2026-03-10 10:53:31 +01:00
fatalerrors
3eab1f98d5 fix parameter detection 2026-03-10 10:52:45 +01:00
fatalerrors
6c895b509a pursue --help implementation 2026-03-10 10:52:17 +01:00
fatalerrors
2ece711e1a huge longrun improvements 2026-03-06 17:46:26 +01:00
20 changed files with 1448 additions and 544 deletions
Expand all files Collapse all files

2
README.md
View File

@@ -20,7 +20,7 @@ prompt. Here is a non-exhaustive list of what we have:
- A bar style prompt with hour, execution time and exit code of the last
command;
- clean: erase after confirmation any backup file, possibly recursively;
- dpkgs: search for the given pattern in the installed packages name;
- pkgs: search for the given pattern in the installed packages name;
- expandlist: usefull in scripts, it expand any expression using wildcards into
the corresponding list of file and directories;
- genpwd: generate one or more random secure password;

50
profile.conf Executable file
View File

@@ -0,0 +1,50 @@
[system]
# System section is used to set system-wide variables, such as PATH, environment variables, and other
# settings that affect the entire system. It is also a good place to set some global variables that can be used by the profile or its functions, such as the default editor and pager.
# Set bash history
HISTSIZE=50000
HISTIGNORE="&:[bf]g:exit"
# Set default pager
PAGER=less
# More colors
TERM=xterm-256color
[info]
# Default city for weather forcast
DEFAULT_CITY="Toulouse"
[general]
# General section allow to set any variable that can be used by the profile or its functions. It is
# also a good place to set some global variables that can be used by the profile or its functions, such as
# the compilation flags and make options.
# Set some compiling values
CFLAGS="-O2 -pipe -march=native"
MAKEFLAGS='-j12'
PKGSOURCES='/share/src/archives'
[aliases]
ll='ls -laFh --color=auto'
la='ls -Ah --color=auto'
l='ls -CF --color=auto'
ls='ls --color=auto'
grep='grep --color=auto'
egrep='egrep --color=auto'
fgrep='fgrep --color=auto'
qfind="find . -name "
mkck='make check'
mkin='make install'
mkdin='make DESTDIR=$PWD/dest-install install'
ssh='ssh -Y'
wget='wget -c' # resume mode by default
myip='curl ip.appspot.com'
# Human readable by default
df='df -H'
du='du -ch'
sdu='du -sk ./* | sort -n'
hdu='du -hs ./* | sort -H'

223
profile.d/compress.sh
View File

@@ -35,8 +35,13 @@
# ------------------------------------------------------------------------------
# ------------------------------------------------------------------------------
# Smartly uncompress archives (zip only for now)
# ------------------------------------------------------------------------------
# Smartly uncompress archives
# Usage: utaz [option] [directorie(s)|file(s)]
# Options:
# -h, --help Display that help screen
# -d, --delete If decompression succeeded, delete the source file
# -c, --create-dir Always create a host directory
# -n, --no-dir Never create a host directory
utaz()
{
_ununzip()
@@ -136,53 +141,73 @@ utaz()
rpm2cpio "$1" | (cd "$2/" && cpio -idmv) >/dev/null 2>&1
}
for opt in $@; do
case ${opt} in
"-h" | "--help")
echo "utaz: uncompress all the given files and/or the ones found in the given"
echo " directories creating an host directory where needed."
echo
echo "Usage: utaz [option] [directorie(s)|file(s)]"
echo
echo "Options:"
echo " -h, --help Display that help screen"
echo " -d, --delete If decompression succeeded, delete the source file"
echo " -c, --create-dir Always create a host directory"
echo " -n, --no-dir Never create a host directory"
echo
local PARSED=$(getopt -o hdcn --long help,delete,create-dir,no-dir -n 'utaz' -- "$@")
if [ $? -ne 0 ]; then
disp E "Invalid options, use \"utaz --help\" to display usage."
return 1
fi
eval set -- "$PARSED"
while true; do
case "$1" in
-h|--help)
printf "utaz: uncompress all the given files and/or the ones found in the given\n"
printf " directories creating an host directory where needed.\n\n"
printf "Usage: utaz [option] [directorie(s)|file(s)]\n\n"
printf "Options:\n"
printf "\t-h, --help\t\tDisplay that help screen\n"
printf "\t-d, --delete\t\tIf decompression succeeded, delete the source file\n"
printf "\t-c, --create-dir\tAlways create a host directory\n"
printf "\t-n, --no-dir\t\tNever create a host directory\n\n"
printf "Supported archive format:\n"
printf "\t- zip\n"
printf "\t- tar.gz, .tgz\n"
printf "\t- tar.bz2, .tbz2\n"
printf "\t- tar.xz, .txz\n"
printf "\t- tar.lz, .tlz\n"
printf "\t- rar\n"
printf "\t- arj\n"
printf "\t- lha, lzh\n"
printf "\t- ace\n"
printf "\t- 7z, p7z\n"
printf "\t- zst\n"
printf "\t- cpio\n"
printf "\t- cab\n"
printf "\t- deb\n"
printf "\t- rpm\n"
return 0
;;
"-d" | "--delete")
-d|--delete)
local willrm=1
shift
;;
"-c" | "--create-dir")
-c|--create-dir)
local createdir=1
shift
;;
"-n" | "--no-dir")
-n|--no-dir)
local nodir=1
shift
;;
"-"*)
disp E "Invalid option, use \"utaz --help\" to display options list"
echo
return 1
--)
shift
break
;;
*)
# The ${opt%/} writing is to remove trailing / if any
local LIST="${LIST} ${opt%/}"
disp E "Invalid option, use \"utaz --help\" to display options list"
return 1
;;
esac
done
# The remaining arguments after -- are the files/directories to process,
# "." is used if none is given
local FILES=("$@")
[[ ${#FILES[@]} -eq 0 ]] && FILES=(".")
[[ -n ${createdir} && -n ${nodir} ]] && \
disp E "The --create-dir and --no-dir options are mutually exclusive."
[[ -z ${LIST} ]] && local LIST="."
for zitem in ${LIST}; do
for zitem in "${FILES[@]}"; do
for f in "${zitem}"/*; do
local dir="${f%.*}"
local extractor=""
@@ -193,13 +218,13 @@ utaz()
*.tar.gz|*.tgz)
extractor="_ungzip"
;;
*.tar.bz2)
*.tar.bz2|*.tbz2)
extractor="_unbzip2"
;;
*.tar.xz)
*.tar.xz|*.txz)
extractor="_unxz"
;;
*.tar.lz)
*.tar.lz|*.tlz)
extractor="_unlzop"
;;
*.tar)
@@ -217,7 +242,7 @@ utaz()
*.ace)
extractor="_ununace"
;;
*.7z)
*.7z|*.p7z)
extractor="_un7z"
;;
*.zst)
@@ -277,10 +302,14 @@ utaz()
rm -f "${f}" && disp I "File ${zitem}/${f} deleted."
;;
1)
disp W "Compression program returned a warning: deletion canceled."
if [[ -n ${willrm} ]]; then
disp W "Compression program returned a warning: deletion canceled."
else
disp W "Compression program returned a warning."
fi
;;
*)
disp E "The zip file seems corrupted, failed."
disp E "The compressed file ${f} seems corrupted, failed."
rm -rf "${dir}" >/dev/null 2>&1
continue
;;
@@ -310,10 +339,21 @@ utaz()
done
}
export -f utaz
# ------------------------------------------------------------------------------
# ------------------------------------------------------------------------------
# Compress directories or files into one or more archive
# ------------------------------------------------------------------------------
# Usage: taz [option] [--parallel=<n>] [--format=<format>] [directory1 ... directoryN]
# Options:
# -h, --help Display that help screen
# -d, --delete Delete source file or directory after success
# -f, --format Chose archive format in the given list. If several format are
# given, the smalest is kept
# -p, --parallel Number of threads to use (if allowed by underlying utility)
# -v, --verbose Display progress where possible
# -q, --quiet Display less messages (only errors and warnings)
# -1, .., -9 Compression level to use [1=fast/biggest, 9=slow/smallest]
taz()
{
_doxz()
@@ -421,78 +461,92 @@ taz()
return $?
}
for opt in $@; do
case $opt in
"-h" | "--help")
echo "taz: archive all files of a directory."
echo
echo "Usage: taz [option] [--parallel=<n>] [--format=<format>] [directory1 ... directoryN]"
echo
echo "Options:"
echo " -h, --help Display that help screen"
echo " -d, --delete Delete source file or directory after success"
echo " -f, --format Chose archive format in the given list. If several format are"
echo " given, the smalest is kept"
echo " -p, --parallel Number of threads to use (if allowed by underlying utility)"
echo " -v, --verbose Display progress where possible"
echo " -q, --quiet Display less messages (only errors and warnings)"
echo " -1, .., -9 Compression level to use [1=fast/biggest, 9=slow/smallest]"
echo
echo "Supported archive format:"
echo " Param.| programs | Algo. | Description"
echo " ------+---------------+-------+----------------------------------------"
echo " lz | plzip, lzip | lzma | Safe efficient default format"
echo " xz | xz | lzma2 | Unsafe, not for long term"
echo " bz2 | pbzip2, bzip2 | bzip2 | Historical but less efficient than lz"
echo " gz | pigz, gzip | lz77 | Historical, safe, fast"
echo " lzo | lzop | lzo | Very fast but no multithread"
echo " tar | tar | tar | No compression"
echo
local PARSED
PARSED=$(getopt -o hdf:p:vq123456789 --long help,delete,format:,parallel:,verbose,quiet --name "taz" -- "$@")
if [ $? -ne 0 ]; then
disp E "Invalid options, use \"taz --help\" to display usage."
return 1
fi
eval set -- "$PARSED"
while true; do
case "$1" in
-h|--help)
printf "taz: archive all files of a directory.\n\n"
printf "Usage: taz [option] [--parallel=<n>] [--format=<format>] [directory1 ... directoryN]\n\n"
printf "Options:\n"
printf "\t-h, --help\tDisplay that help screen\n"
printf "\t-d, --delete\tDelete source file or directory after success\n"
printf "\t-f, --format\tChose archive format in the given list. If several format are"
printf "\t\t\tgiven, the smalest is kept\n"
printf "\t-p, --parallel\tNumber of threads to use (if allowed by underlying utility)\n"
printf "\t-v, --verbose\tDisplay progress where possible\n"
printf "\t-q, --quiet\tDisplay less messages (only errors and warnings)\n"
printf "\t-1, .., -9\tCompression level to use [1=fast/biggest, 9=slow/smallest]\n\n"
printf "Supported archive format:\n"
printf "\tParam.| programs | Algo. | Description\n"
printf "\t------+---------------+-------+----------------------------------------\n"
printf "\t lz | plzip, lzip | lzma | Safe efficient default format\n"
printf "\t xz | xz | lzma2 | Unsafe, not for long term\n"
printf "\t bz2 | pbzip2, bzip2 | bzip2 | Historical but less efficient than lz\n"
printf "\t gz | pigz, gzip | lz77 | Historical, safe, fast\n"
printf "\t lzo | lzop | lzo | Very fast but no multithread\n"
printf "\t tar | tar | tar | No compression\n"
printf "\n"
return 0
;;
"-d" | "--delete")
-d|--delete)
local willrm=1
shift
;;
"-f"?* | "--format"?*)
local compform=$(echo "$opt" | cut -f 2- -d '=')
-f|--format)
local compform=$2
shift 2
;;
"-p"?* | "--parallel"?*)
local nproc=$(echo "$opt" | cut -f 2- -d '=')
-p|--parallel)
local nproc=$2
shift 2
;;
"-v" | "--verbose")
-v|--verbose)
local verbose=1
shift
;;
"-q" | "--quiet")
-q|--quiet)
local quiet=1
shift
;;
"-"*)
local complevel=$(echo $opt | sed 's/-//')
if ! [[ $complevel =~ ^[1-9]+$ ]]; then
disp E "Invalid option, use taz --help to display options list"
echo
return 1
fi
-[1-9])
compression="${1#-}"
shift
;;
--)
shift
break
;;
*)
local LIST="$LIST ${opt%/}"
disp E "Invalid option, use \"taz --help\" to display options list"
return 1
;;
esac
done
# The remaining arguments after -- are the files/directories to process,
# "." is used if none is given
local FILES=("$@")
[[ ${#FILES[@]} -eq 0 ]] && FILES=(".")
[[ ! $compform ]] && compform=lz # safe and efficient (unless data are already compressed)
[[ ! $nproc ]] && nproc=1
[[ ! $complevel ]] && complevel=6
[[ $verbose -gt 1 && $quiet -gt 1 ]] &&
disp E "The --verbose and --quiet options can't be used together."
for item in $LIST; do
for item in "${FILES[@]}"; do
local donetar=0
disp I "Processing $item..."
@@ -537,6 +591,7 @@ taz()
unset quiet
}
export -f taz
# ------------------------------------------------------------------------------
# EOF

77
profile.d/debug.sh
View File

@@ -36,27 +36,22 @@
# ------------------------------------------------------------------------------
# Display a backtrace
# ------------------------------------------------------------------------------
# Usage: backtrace
function backtrace()
{
echo "========= Call stack ========="
typeset -i i=0
local func=
for func in "${FUNCNAME[@]}"; do
if [[ $i -ne 0 ]]; then
printf '%15s() %s:%d\n' \
"$func" "${BASH_SOURCE[$i]}" "${BASH_LINENO[(($i - 1))]}"
fi
let i++ || true
printf "========= Call stack =========\n"
local i=1 # We begin at 1 to ignore backtrace itself
while [[ $i -lt ${#FUNCNAME[@]} ]]; do
printf '%15s() %s:%d\n' \
"${FUNCNAME[$i]}" "${BASH_SOURCE[$i]}" "${BASH_LINENO[$(( i-1 ))]}"
((i++))
done
unset func i
echo "=============================="
printf "==============================\n"
}
# ------------------------------------------------------------------------------
# Function to be trapped for errors investigation
# ------------------------------------------------------------------------------
function error()
{
local errcode=$?
@@ -66,45 +61,63 @@ function error()
# ------------------------------------------------------------------------------
# Activate or deactivate error trapping to display backtrace
# ------------------------------------------------------------------------------
# Usage: settrace <--on|--off|--status>
settrace()
{
local status="off"
[[ $(trap -p ERR) ]] && status="on"
#trap -p ERR
for opt in $@; do
case $opt in
"-h" | "--help")
echo "Try to activate backtrace display for script debugging."
echo
echo "Options:"
echo " --on Activate backtrace generation"
echo " --off Deactivate backtrace generation"
echo
echo "That function active a trap event on error. If the script you want to"
echo "debug overload the ERR bash trap, it will not work."
echo
local PARSED
PARSED=$(getopt -oh --long help,on,off,status -- "$@")
if [[ $? -ne 0 ]]; then
disp E "Invalid options, use \"settrace --help\" to display usage."
return 1
fi
eval set -- "$PARSED"
while true; do
case $1 in
-h|--help)
printf "Try to activate backtrace display for script debugging.\n\n"
printf "Options:\n"
printf "\t--on\t\tActivate backtrace generation\n"
printf "\t--off\t\tDeactivate backtrace generation\n\n"
printf "That function active a trap event on error. If the script you want to\n"
printf "debug overload the ERR bash trap, it will not work.\n"
return 0
;;
"--on")
if [[ $status == "on" ]]; then
--on)
if [[ ${status} == "on" ]]; then
disp W "ERR signal trap is already set, replacing previous trap!"
fi
trap "error" ERR
shift
;;
"--off")
if [[ $status != "on" ]]; then
--off)
if [[ ${status} != "on" ]]; then
disp W "ERR signal trap is already unset!"
fi
trap - ERR
shift
;;
"--status")
--status)
disp "ERR trap signal is ${status}."
shift
;;
--)
shift
break
;;
*)
disp E "Invalid options, use \"settrace --help\" to display usage."
return 1
;;
esac
done
unset status
}
export -f settrace
# ------------------------------------------------------------------------------
# EOF

18
profile.d/disp.sh
View File

@@ -36,11 +36,10 @@
# ------------------------------------------------------------------------------
# Color definitions
# ------------------------------------------------------------------------------
# Standard 16 colors display declaration
export DEFAULTFG="\e[0;39m"
export DEFAULTBG="\e[0;49m"
export DEFAULTCOL=${DEFAULTBG}${DEFAULTFG}
export DEFAULTFG='\e[0;39m'
export DEFAULTBG='\e[0;49m'
export DEFAULTCOL="${DEFAULTBG}${DEFAULTFG}"
export RESETCOL=$'\e[0m'
# Regular Colors
@@ -112,10 +111,17 @@ export On_IBlue='\e[0;104m'
export On_IPurple='\e[0;105m'
export On_ICyan='\e[0;106m'
export On_IWhite='\e[0;107m'
# ------------------------------------------------------------------------------
# ------------------------------------------------------------------------------
# Display a message
# ------------------------------------------------------------------------------
# Usage: disp <type> <message>
# Types:
# I : info (green)
# W : warning (yellow)
# E : error (red)
# D : debug (cyan)
disp()
{
case $1 in
@@ -149,4 +155,6 @@ disp()
}
export -f disp
# ------------------------------------------------------------------------------
# EOF

652
profile.d/filefct.sh
View File

@@ -36,9 +36,17 @@
# ------------------------------------------------------------------------------
# expandlist : treat wildcards in a file/directory list
# ------------------------------------------------------------------------------
# Usage: expandlist <item1 [item2 ... itemN]>
expandlist()
{
if [[ "$1" == "-h" || "$1" == "--help" ]]; then
printf "expandlist: Wraps a list of items in double quotes.\n\n"
printf "Usage: expandlist <item1 [item2 ... itemN]>\n\n"
printf "Options:\n"
printf "\t-h, --help\t\tDisplay this help screen\n"
return 0
fi
local result=""
for item in "$1"; do
for content in "$item"; do
@@ -47,62 +55,78 @@ expandlist()
done
echo $result
}
export -f expandlist
# ------------------------------------------------------------------------------
# ------------------------------------------------------------------------------
# Clean a directory or a tree from temporary or backup files
# ------------------------------------------------------------------------------
# Usage: clean [options] [directory1] [...[directoryX]]
# Options:
# -h, --help: display help screen
# -r, --recurs: do a recursive cleaning
# -f, --force: do not ask for confirmation (use with care)
# -s, --shell: do nothing and display what will be executed
clean()
{
for opt in $@; do
case $opt in
"-r" | "--recurs")
local recursive=1
;;
local recursive=0 force=0 outshell=0
"-h" | "--help")
echo "clean: erase backup files in the given directories."
echo
echo "Usage: clean [option] [directory1] [...[directoryX]]"
echo
echo "Options:"
echo " -h, --help Display that help screen"
echo " -r, --recurs Do a recursive cleaning"
echo " -f, --force Do not ask for confirmation (use with care)"
echo " -s, --shell Do nothing and display what will be executed"
echo
return 0
;;
# Define short and long options
local PARSED
PARSED=$(getopt -o hrsf --long help,recurs,shell,force -n 'clean' -- "$@")
"-s" | "--shell")
local outshell=1
;;
if [[ $? -ne 0 ]]; then
disp E "Invalid options, use \"clean --help\" to display usage."
return 1
fi
"-f" | "--force")
local force=1
;;
eval set -- "$PARSED"
"-"*)
disp E "Invalid option, use \"clean --help\" to display usage."
echo
return 1
;;
*)
local dirlist="$dirlist $opt"
;;
while true; do
case "$1" in
-r|--recurs)
local recursive=1
shift
;;
-h|--help)
printf "clean: erase backup files in the given directories.\n\n"
printf "Usage: clean [option] [directory1] [...[directoryX]]\n"
printf "Options:\n"
printf "\t-h, --help\t\tDisplay that help screen\n"
printf "\t-r, --recurs\t\tDo a recursive cleaning\n"
printf "\t-f, --force\t\tDo not ask for confirmation (use with care)\n"
printf "\t-s, --shell\t\tDo nothing and display what will be executed\n"
printf "\n"
return 0
;;
-s|--shell)
local outshell=1
shift
;;
-f|--force)
local force=1
shift
;;
--)
shift
break
;;
*)
disp E "Invalid parameter, use \"clean --help\" to display options list"
return 1
esac
done
[[ ! $dirlist ]] && local dirlist=$(pwd)
# Handle remaining arguments as directories
local dirlist=("$@")
[[ ${#dirlist[@]} -eq 0 ]] && dirlist=(".")
[[ ! $recursive ]] && local findopt="-maxdepth 1"
[[ ! $force ]] && local rmopt="-i"
unset recursive force
for dir in $dirlist; do
local dellist=$(find "$dir" $findopt -type f -name "*~" -o -name "#*#" \
-o -name "*.bak" -o -name ".~*#")
for f in $dellist; do
find "$dir" "${findopt[@]}" -type f \( -name "*~" -o -name "#*#" -o -name "*.bak" -o -name ".~*#" \) -print0 | while IFS= read -r -d '' f; do
if [[ ! $outshell ]]; then
rm $rmopt $f
else
@@ -113,72 +137,103 @@ clean()
unset outshell dirlist dellist findopt rmopt
}
export -f clean
# ------------------------------------------------------------------------------
# ------------------------------------------------------------------------------
# Create a directory then goes inside
# ------------------------------------------------------------------------------
# Usage: mcd <directory>
mcd()
{
if [[ "$1" == "-h" || "$1" == "--help" ]]; then
printf "mcd: Create a directory and enter it.\n\n"
printf "Usage: mcd <directory>\n"
printf "Options:\n"
printf "\t-h, --help\t\tDisplay this help screen\n"
return 0
fi
if [[ ! $# -eq 1 ]]; then
disp E "Create a directory then goes inside."
disp E "Usage: mcd <directory>"
disp E "Missing parameter. Use \"mcd --help\" to display usage."
return 1
fi
mkdir -pv "$1" && cd "$1" || echo "Failed create or change directory."
mkdir -pv "$1" && cd "$1" || {
printf "Failed create and/or change directory.\n"
return 1
}
}
export -f mcd
# ------------------------------------------------------------------------------
# ------------------------------------------------------------------------------
# Rename all files in current directory to replace spaces with _
# ------------------------------------------------------------------------------
# Usage: rmspc [options]
# Options:
# -h, --help: display help screen
# -r, --recursive: treat subdirectories of the given directory
# -c, --subst-char: change the replacement character (default is underscore)
# -v, --verbose: display more details (recursive mode only)
# -s, --shell: do nothing and display commands that would be executed
rmspc()
{
local lst=""
for opt in $@; do
case $opt in
"-h" | "--help")
echo "rmspc: remove spaces from all filenames in current directories"
echo
echo "Usage: rmspc [option]"
echo
echo "Options:"
echo " -h, --help Display that help screen"
echo " -r, --recursive Treat subdirectories of the given directory"
echo " -c, --subst-char Change the replacement character (default is underscore)"
echo " -v, --verbose Display more details (recursive mode only)"
echo " -s, --shell Do nothing and display commands that would be executed"
echo
echo "Note: if the --subst-char option is given without parameters, spaces will be"
echo " replaced with nothing (concatenation)."
echo
return 0
;;
local PARSED
PARSED=$(getopt -o hr:c::vs --long help,recursive,subst-char::,verbose,shell -n 'rmspc' -- "$@")
if [[ $? -ne 0 ]]; then
disp E "Invalid options, use \"rmspc --help\" to display usage."
return 1
fi
eval set -- "$PARSED"
"-r" | "--recursive")
local recurs=1
;;
"-c"?* | "--subst-char"?*)
if [[ $(echo $opt | grep "=") ]]; then
local substchar=$(echo "$opt" | cut -f 2- -d '=')
else
local substchar='none'
fi
;;
"-v" | "--verbose")
local verb=1
;;
"-s" | "--shell")
local shell=1
;;
*)
disp E "Invalid parameter, use \"rmspc --help\" to display options list"
echo
return 1
;;
while true; do
case "$1" in
-h|--help)
printf "rmspc: remove spaces from all filenames in current directories\n\n"
printf "Usage: rmspc [option]\n\n"
printf "Options:\n"
printf "\t-h, --help\t\tDisplay that help screen\n"
printf "\t-r, --recursive\t\tTreat subdirectories of the given directory\n"
printf "\t-c, --subst-char\tChange the replacement character (default is underscore)\n"
printf "\t-v, --verbose\t\tDisplay more details (recursive mode only)\n"
printf "\t-s, --shell\t\tDo nothing and display commands that would be executed\n\n"
printf "Note: if the --subst-char option is given without parameters, spaces will be\n"
printf " replaced with nothing (concatenation).\n"
return 0
;;
-r|--recursive)
local recurs=1
shift
;;
-c|--subst-char)
# Handle optional argument for short/long options
case "$2" in
"")
substchar=""
;;
*)
substchar="$2"
;;
esac
shift 2
;;
-v|--verbose)
local verb=1
shift
;;
-s|--shell)
local shell=1
shift
;;
--)
shift
break
;;
*)
disp E "Invalid parameter, use \"rmspc --help\" to display options list"
echo
return 1
;;
esac
done
@@ -210,38 +265,119 @@ rmspc()
unset lst substchar verb shell newf command mvopt
}
export -f rmspc
# ------------------------------------------------------------------------------
# ------------------------------------------------------------------------------
# display stats about a file structure
# ------------------------------------------------------------------------------
# Usage: file_stats [options] [path]
# Options:
# -H, --human Human readable sizes\n"
# -d, --details Display details (min/max/average/median)
# -m, --average Display only average size
# -M, --median Display only median size
# -c, --count Display only count of files
# -t, --total Display only total size
# -a, --all Display all stats in human readable format (shortcut for -H -d)
# -x, --ext [ext] Filter by extension (e.g. -x log for .log files)
# -X, --ext-list [list] Filter by multiple extensions (e.g. -X log,txt)
# --min [size] Minimum size (e.g., 10M)
# --max [size] Maximum size (e.g., 100M)
file_stats()
{
local human=0 details=0 only_avg=0 only_med=0 only_count=0 only_total=0
local human=0 details=0 only_avg=0 only_med=0 only_count=0 only_total=0
local path="." show_all=1 ext_filter="" ext_list="" min_size="" max_size=""
local OPTIND opt
# Analyse options
while [[ "$1" =~ ^- ]]; do
local PARSED
# Short: H, d, m, M, c, t, a, x:, X:
# Long: human, details, average, median, count, total, all, ext:, ext-list:, min:, max:, help
PARSED=$(getopt -o HdmMctax:X:h --long human,details,average,median,count,total,all,ext:,ext-list:,min:,max:,help -n 'file_stats' -- "$@")
if [[ $? -ne 0 ]]; then
disp E "Invalid options, use \"file_stats --help\" to display usage."
return 1
fi
eval set -- "$PARSED"
while true; do
case "$1" in
-H) human=1 ;;
-d) details=1 ;;
-m) only_avg=1; show_all=0 ;;
-M) only_med=1; show_all=0 ;;
-c) only_count=1; show_all=0 ;;
-t) only_total=1; show_all=0 ;;
-a) human=1; details=1 ;;
-x) ext_filter="${2#.}"; shift ;;
-X) ext_list="${2}"; shift ;;
--min) min_size="$2"; shift ;;
--max) max_size="$2"; shift ;;
--) shift; break ;;
-*) echo "Usage: file_stats [-h] [-d] [-mMctaxX --min N --max N] [path]"; return 1 ;;
-h|--help)
printf "Usage: file_stats [options] [path]\n\n"
printf "Options:\n"
printf "\t-H, --human\t\tHuman readable sizes\n"
printf "\t-d, --details\t\tShow detailed histogram\n"
printf "\t-m, --average\t\tShow only average size\n"
printf "\t-M, --median\t\tShow only median size\n"
printf "\t-c, --count\t\tShow only file count\n"
printf "\t-t, --total\t\tShow only total size\n"
printf "\t-a, --all\t\tShow all (human + details)\n"
printf "\t-x, --ext [ext]\t\tFilter by extension\n"
printf "\t-X, --ext-list [list]\tFilter by comma-separated list\n"
printf "\t--min [size]\t\tMinimum size (e.g., 10M)\n"
printf "\t--max [size]\t\tMaximum size (e.g., 100M)\n"
return 0 ;;
-H|--human)
human=1
shift
;;
-d|--details)
details=1
shift
;;
-m|--average)
only_avg=1
show_all=0
shift
;;
-M|--median)
only_med=1
show_all=0
shift
;;
-c|--count)
only_count=1
show_all=0
shift
;;
-t|--total)
only_total=1
show_all=0
shift
;;
-a|--all)
human=1
details=1
shift
;;
-x|--ext)
ext_filter="${2#.}"
shift 2
;;
-X|--ext-list)
ext_list="$2"
shift 2
;;
--min)
min_size="$2"
shift 2
;;
--max)
max_size="$2"
shift 2
;;
--)
shift
break
;;
*)
disp E "Invalid option: $1"
return 1
;;
esac
shift
done
[ -n "$1" ] && path="$1"
[[ -n "$1" ]] && path="$1"
# Prepare find filters
local find_cmd=(find "$path" -type f)
@@ -271,12 +407,27 @@ file_stats()
fi
# Exécution
"${find_cmd[@]}" -printf "%s\n" 2>/dev/null | sort -n | awk -v human="$human" -v details="$details" -v only_avg="$only_avg" -v only_med="$only_med" -v only_count="$only_count" -v only_total="$only_total" -v show_all="$show_all" -v path="$path" '
"${find_cmd[@]}" -printf "%s\n" 2>/dev/null | sort -n | \
awk -v human="$human" -v details="$details" -v only_avg="$only_avg" \
-v only_med="$only_med" -v only_count="$only_count" \
-v only_total="$only_total" -v show_all="$show_all" -v path="$path" '
# Convert function
function human_readable(x) {
split("B KiB MiB GiB TiB", units)
for (i=1; x>=1024 && i<5; i++) x /= 1024
i = 1
while (x >= 1024 && i < 5) {
x /= 1024
i++
}
return sprintf("%.2f %s", x, units[i])
}
# Display function
function out(label, val, is_size) {
if (human == 1 && is_size == 1) val = human_readable(val)
printf "%-20s : %s\n", label, val
}
{
sizes[NR] = $1
total += $1
@@ -288,50 +439,51 @@ file_stats()
bucket[b]++
}
}
END {
count = NR
if (count == 0) {
print "Aucun fichier trouvé."; exit
print "No files found."
exit
}
moyenne = total / count
if (count % 2 == 1)
mediane = sizes[(count + 1) / 2]
else
mediane = (sizes[count / 2] + sizes[count / 2 + 1]) / 2
average = total / count
# Simple sort for median (awk is not very good at this, we use existing logic)
if (count % 2 == 1) median = sizes[(count + 1) / 2]
else median = (sizes[count / 2] + sizes[count / 2 + 1]) / 2
function out(label, val) {
if (human) val = human_readable(val)
printf "%-20s : %s\n", label, val
}
if (only_avg) out("Taille moyenne", moyenne)
else if (only_med) out("Taille médiane", mediane)
else if (only_count) printf "Nombre de fichiers : %d\n", count
else if (only_total) out("Taille totale", total)
if (only_avg) out("Average size", average, 1)
else if (only_med) out("Median size", median, 1)
else if (only_count) out("Number of files", count, 0)
else if (only_total) out("Total size", total, 1)
else {
if (show_all || human || details) {
printf "Statistiques sur \"%s\"\n", path
printf "Statistics for \"%s\"\n", path
printf "-------------------------\n"
}
out("Nombre de fichiers", count)
out("Taille totale", total)
out("Taille moyenne", moyenne)
out("Taille médiane", mediane)
out("Taille minimale", min)
out("Taille maximale", max)
out("Number of files", count, 0)
out("Total size", total, 1)
out("Average size", average, 1)
out("Median size", median, 1)
out("Minimum size", min, 1)
out("Maximum size", max, 1)
}
if (details) {
print "\nHistogramme des tailles :"
for (i = 0; i in bucket; i++) {
low = 2^i
high = 2^(i+1)
if (i == 0)
label = sprintf("%4s – %4s", "0", "1K")
else
label = sprintf("%4s – %4s", human_readable(low), human_readable(high))
printf "%-20s : %5d fichiers\n", label, bucket[i]
print "\nSize histogram:"
# Use a separate array for the loop to avoid collision
for (b in bucket) {
# Pre-calculate label parts
# 1024^0 = 1 (B), 1024^1 = 1K, etc.
low = (b == 0) ? 0 : (1024^b)
high = 1024^(b+1)
label = sprintf("%-9s – %-9s",
(b == 0) ? "0" : human_readable(low),
human_readable(high))
# We store buckets in an array, access them by index b
printf "%-25s : %6d fichiers\n", label, bucket[b]
}
}
}'
@@ -341,4 +493,222 @@ export -f file_stats
# ------------------------------------------------------------------------------
# Find the biggest files in a directory tree
# Usage: findbig [options] [directory]
# Options:
# -h : display help screen
# -d : display details (ls -l) for each file
# -x : do not cross filesystem boundaries
# -l : limit : number of files to return (default is 10)
findbig()
{
local details=0 limit=10 no_change=0 one_fs=0
local PARSED
PARSED=$(getopt -o hd:l:x --long help,details,one-fs,limit: -n 'findbig' -- "$@")
if [[ $? -ne 0 ]]; then
disp E "Invalid options, use \"findbig --help\" to display usage."
return 1
fi
eval set -- "$PARSED"
while true; do
case "$1" in
-h|--help)
printf "findbig: Find the N biggest files in a directory tree.\n\n"
printf "Usage: findbig [options] [directory]\n\n"
printf "Options:\n"
printf "\t-h, --help\t\tDisplay this help screen\n"
printf "\t-d, --details\t\tShow detailed file info (ls -ld)\n"
printf "\t-l, --limit N\t\tNumber of files to return (default: 10)\n"
printf "\t-x, --one-fs\t\tDo not cross filesystem boundaries\n"
return 0
;;
-d|--details)
details=1
shift
;;
-n|--no-change)
no_change=1
shift
;;
-l|--limit)
limit="$2"
shift 2
;;
--)
shift
break
;;
*)
disp E "Invalid option: $1"
return 1
;;
esac
done
local dir="${1:-.}"
# Prepare find arguments in an array for cleaner handling
local find_args=("-L" "$dir" "-type" "f")
(( one_fs )) && find_args+=("-xdev")
# Logic: find files, print size and path, sort numeric reverse, take N
if (( details )); then
find "${find_args[@]}" -printf "%s %p\n" 2>/dev/null | sort -rn | head -n "$limit" | while read -r size path; do
ls -ld "$path"
done
else
find "${find_args[@]}" -printf "%s %p\n" 2>/dev/null | sort -rn | head -n "$limit"
fi
}
export -f findbig
# ------------------------------------------------------------------------------
# ------------------------------------------------------------------------------
# Find empty files in a directory tree
# Usage: findzero [options] [directory]
# Options:
# -h : display help screen
# -d : display details (ls -l) for each file
# -x : do not cross filesystem boundaries
# --delete : delete empty files and display their paths
findzero() {
local delete=0 details=0 one_fs=0 no_change=0
local PARSED
# o: options, long: long equivalents
PARSED=$(getopt -o hdx --long help,details,one-fs,delete -n 'findzero' -- "$@")
if [[ $? -ne 0 ]]; then
disp E "Invalid options, use \"findzero --help\" to display usage."
return 1
fi
eval set -- "$PARSED"
while true; do
case "$1" in
-h|--help)
printf "findzero: Find or delete empty files in a directory tree.\n\n"
printf "Usage: findzero [options] [directory]\n\n"
printf "Options:\n"
printf "\t-h, --help\t\tDisplay this help screen\n"
printf "\t-d, --details\t\tShow detailed file info (ls -ls)\n"
printf "\t-x, --one-fs\t\tDo not cross filesystem boundaries\n"
printf "\t--delete\t\tActually remove the empty files\n"
return 0 ;;
-d|--details)
details=1
shift
;;
-x|--one-fs)
one_fs=1
shift
;;
--delete)
delete=1
shift
;;
--)
shift
break
;;
*)
disp E "Invalid option: $1"
return 1
;;
esac
done
local dir="${1:-.}"
local find_args=("-L" "$dir" "-type" "f" "-empty")
(( one_fs )) && find_args+=("-xdev")
# Execution logic
if (( delete )); then
disp W "Deleting empty files in $dir..."
find "${find_args[@]}" -delete -print
elif (( details )); then
find "${find_args[@]}" -ls
else
find "${find_args[@]}"
fi
}
export -f findzero
# ------------------------------------------------------------------------------
# ------------------------------------------------------------------------------
# Find dead symbolic links in a directory tree
# Usage: finddead [options] [directory]
# Options:
# -h : display help screen
# -d : display details (ls -l) for each link
# -x : do not cross filesystem boundaries
# --delete : delete dead links and display their paths
finddead() {
local delete=0 details=0 one_fs=0 no_change=0
local PARSED
PARSED=$(getopt -o hdx --long help,details,one-fs,delete -n 'finddead' -- "$@")
if [[ $? -ne 0 ]]; then
disp E "Invalid options, use \"finddead --help\" to display usage."
return 1
fi
eval set -- "$PARSED"
while true; do
case "$1" in
-h|--help)
printf "finddead: Find or delete dead/broken symbolic links.\n\n"
printf "Usage: finddead [options] [directory]\n\n"
printf "Options:\n"
printf "\t-h, --help\t\tDisplay this help screen\n"
printf "\t-d, --details\t\tShow detailed symlink info (ls -ls)\n"
printf "\t-x, --one-fs\t\tDo not cross filesystem boundaries\n"
printf "\t--delete\t\tActually remove the dead links\n"
return 0 ;;
-d|--details)
details=1
shift
;;
-x|--one-fs)
one_fs=1
shift
;;
--delete)
delete=1
shift
;;
--)
shift
break
;;
*)
disp E "Invalid option: $1"
return 1
;;
esac
done
local dir="${1:-.}"
# -xtype l searches for links that do not point to an existing file
local find_args=("$dir" "-xtype" "l")
(( one_fs )) && find_args+=("-xdev")
# Execution logic
if (( delete )); then
disp W "Deleting dead symlinks in $dir..."
find "${find_args[@]}" -delete -print
elif (( details )); then
find "${find_args[@]}" -ls
else
find "${find_args[@]}"
fi
}
export -f finddead
# ------------------------------------------------------------------------------
# EOF

66
profile.d/fun.sh
View File

@@ -36,35 +36,73 @@
# ------------------------------------------------------------------------------
# Make non-IT peoples think you're busy doing something hard
# ------------------------------------------------------------------------------
# Usage: busy [options] [pattern]
# Options:
# --delay=<ms> : add a delay between each line output (milliseconds)
# pattern : the string to search for in the hexdump output (default is "ca fe")
busy()
{
local pattern="ca fe"
for arg in "$@"; do
case "$arg" in
--delay=*)
delay_ms="${arg#*=}"
if ! [[ $delay_ms =~ ^[0-9]+$ ]]; then
disp E "Invalid delay value, must be an integer (milliseconds)."
local pattern="ca fe" delay_ms=0
local PARSED
# Short: h, p:, d:
# Long: help, pattern:, delay:
PARSED=$(getopt -o hp:d: --long help,pattern:,delay: -n 'busy' -- "$@")
if [[ $? -ne 0 ]]; then
disp E "Invalid options, use \"busy --help\" to display usage."
return 1
fi
eval set -- "$PARSED"
while true; do
case "$1" in
-h|--help)
printf "busy: Monitor /dev/urandom for a specific pattern.\n\n"
printf "Usage: busy [options] [pattern]\n\n"
printf "Options:\n"
printf "\t-h, --help\t\tDisplay this help screen\n"
printf "\t-p, --pattern PATTERN\tHex pattern to search (default: \"ca fe\")\n"
printf "\t-d, --delay MS\t\tDelay between matches in milliseconds\n"
return 0
;;
-p|--pattern)
pattern="$2"
shift 2
;;
-d|--delay)
delay_ms="$2"
if ! [[ "$delay_ms" =~ ^[0-9]+$ ]]; then
disp E "Invalid delay: must be an integer (milliseconds)."
return 1
fi
shift 2
;;
--)
shift
break
;;
*)
pattern="$arg"
disp E "Invalid option: $1"
return 1
;;
esac
done
# If a pattern was provided as a positional argument (e.g., 'busy "ff 00"'),
# it is captured here.
[[ -n "$1" ]] && pattern="$1"
# Convert milliseconds to seconds for 'sleep'
local delay_s=$(awk "BEGIN { printf \"%.3f\", $delay_ms / 1000 }")
# Monitor /dev/urandom
cat /dev/urandom | hexdump -C | grep --line-buffered "$pattern" | \
while read -r line; do
echo $line
[[ $delay_ms -gt 0 ]] && sleep "$delay_s"
done
unset pattern
echo "$line"
[[ $delay_ms -gt 0 ]] && sleep "$delay_s"
done
}
# ------------------------------------------------------------------------------
# EOF

61
profile.d/help.sh
View File

@@ -36,38 +36,43 @@
# ------------------------------------------------------------------------------
# Display list of commands and general informations
# ------------------------------------------------------------------------------
# Usage: help
help()
{
cat <<EOF
clean Erase backup files
dpkgs Search for the given package in the installed ones
gpid Give the list of PIDs for the given process name
isipv4 Tell if the given IPv4 is valid
isipv6 Tell if the given IPv6 is valid
ku Kill process owned by users in parameter
mcd Create a directory and go inside
meteo Display curent weather forecast for the configured city
ppg Display process matching the given parameter
ppn Display process matching the exact process name given in parameter
ppu Display processes owned by the given user
rain Let the rain fall
rmhost Remove host (IP and/or DNS name) for current known_host
rmspc Remove spaces from all the files in working directory
setc Set console language to C
setfr Set console language to French
settrace Activate/deactivate call trace for script debugging
setus Set console language to US English
showinfo Show the welcoming baner with basic system information
ssr Do a root login to the given address
taz Compress smartly the given files or directory
utaz Uncompress all zip files in the given (or current) directory
ver Display version of your copy of profile
printf "check_updates\tCheck for profile updates\n"
printf "clean\t\tErase backup files\n"
printf "dpkgs\t\tSearch for the given package in the installed ones\n"
printf "findbig\t\tFind big files in the given (or current) directory\n"
printf "findempty\tFind empty files and directories in the given (or current) directory\n"
printf "finddead\tFind dead symbolic links in the given (or current) directory\n"
printf "gpid\t\tGive the list of PIDs for the given process name\n"
printf "isipv4\t\tTell if the given IPv4 is valid\n"
printf "isipv6\t\tTell if the given IPv6 is valid\n"
printf "ku\t\tKill process owned by users in parameter\n"
printf "mcd\t\tCreate a directory and go inside\n"
printf "meteo\t\tDisplay curent weather forecast for the configured city\n"
printf "ppg\t\tDisplay process matching the given parameter\n"
printf "ppn\t\tDisplay process matching the exact process name given in parameter\n"
printf "ppu\t\tDisplay processes owned by the given user\n"
printf "profile_update\tUpdate profile to the latest version\n"
printf "rain\t\tLet the rain fall\n"
printf "rmhost\t\tRemove host (IP and/or DNS name) for current known_host\n"
printf "rmspc\t\tRemove spaces from all the files in working directory\n"
printf "setlocale\tSet console language to the current locale\n"
printf " * setc\tSet console language to C\n"
printf " * setfr\tSet console language to French\n"
printf " * setus\tSet console language to US English\n"
printf "settrace\tActivate/deactivate call trace for script debugging\n"
printf "showinfo\tShow the welcoming baner with basic system information\n"
printf "ssr\t\tDo a root login to the given address\n"
printf "taz\t\tCompress smartly the given files or directory\n"
printf "utaz\t\tUncompress all zip files in the given (or current) directory\n"
printf "ver\t\tDisplay version of your copy of profile\n\n"
Please use <command> --help to obtain usage details.
EOF
printf "\nPlease use <command> --help to obtain usage details.\n"
}
export -f help
# ------------------------------------------------------------------------------
# EOF

84
profile.d/info.sh
View File

@@ -36,22 +36,66 @@
# ------------------------------------------------------------------------------
# Show profile version
# ------------------------------------------------------------------------------
# Usage: ver
ver()
{
local PARSED=$(getopt -o h --long help -n 'ver' -- "$@")
if [[ $? -ne 0 ]]; then
disp E "Invalid options, use \"ver --help\" to display usage."
return 1
fi
eval set -- "$PARSED"
case "$1" in
-h|--help)
printf "ver: Display the current profile version.\nUsage: ver\n"
return 0
;;
--)
shift
break
;;
*)
disp E "Invalid options, use \"ver --help\" to display usage."
return 1
;;
esac
[[ -z $PROFVERSION ]] && \
disp W "No version defined. Profile is probably badly installed." && \
return 1
disp "Profile version $PROFVERSION."
}
export -f ver
# ------------------------------------------------------------------------------
# ------------------------------------------------------------------------------
# Display weather of the given city (or default one)
# ------------------------------------------------------------------------------
# Usage: meteo [city1 city2 ...]
meteo()
{
local encoded cities=("$@")
local PARSED=$(getopt -o h --long help -n 'meteo' -- "$@")
if [[ $? -ne 0 ]]; then
disp E "Invalid options, use \"meteo --help\" to display usage."
return 1
fi
eval set -- "$PARSED"
case "$1" in
-h|--help)
printf "meteo: Fetch weather data.\nUsage: meteo [city1 city2 ...]\n"
return 0
;;
--)
shift
break
;;
*)
disp E "Invalid options, use \"meteo --help\" to display usage."
return 1
;;
esac
local cities=("$@")
[[ $# -eq 0 ]] && cities=("$DEFAULT_CITY")
for city in "${cities[@]}"; do
@@ -61,13 +105,35 @@ meteo()
done
}
export -f meteo
# ------------------------------------------------------------------------------
# ------------------------------------------------------------------------------
# Display system general information
# ------------------------------------------------------------------------------
# Usage: showinfo
showinfo()
{
echo -e "\n"
local PARSED=$(getopt -o h --long help -n 'showinfo' -- "$@")
if [[ $? -ne 0 ]]; then
disp E "Invalid options, use \"showinfo --help\" to display usage."
return 1
fi
eval set -- "$PARSED"
case "$1" in
-h|--help)
printf "showinfo: Display system information (hostname, kernel, uptime).\nUsage: showinfo\n"
return 0
;;
--)
shift
break
;;
*)
disp E "Invalid options, use \"showinfo --help\" to display usage."
return 1
;;
esac
printf "\n"
if command -v figlet >/dev/null 2>&1; then
if [[ -s /usr/share/figlet/ansi_shadow.flf ]]; then
local figopt="-f ansi_shadow"
@@ -90,15 +156,17 @@ showinfo()
if [[ -s /etc/os-release ]]; then
# shellcheck disable=SC1091
. /etc/os-release
echo "$NAME $VERSION"
printf "$NAME $VERSION\n"
else
cat /proc/version
fi
echo "Uptime: $(uptime -p)"
printf "Uptime: $(uptime -p)\n"
)
fi
}
export -f showinfo
# ------------------------------------------------------------------------------
load_conf info
# EOF

41
profile.d/lang.sh
View File

@@ -34,7 +34,8 @@
# * OF SUCH DAMAGE.
# ------------------------------------------------------------------------------
locale_check() {
locale_check()
{
locale -a | grep -qx "$1" || {
disp W "Locale '$1' is not installed on this system."
return 1
@@ -45,9 +46,34 @@ locale_check() {
# ------------------------------------------------------------------------------
# Change locale to the given one in parameter
# ------------------------------------------------------------------------------
# Usage: setlocale <locale>
setlocale()
{
local PARSED
PARSED=$(getopt -o h --long help -n 'setlocale' -- "$@")
if [[ $? -ne 0 ]]; then
disp E "Invalid options, use \"setlocale --help\" to display usage."
return 1
fi
eval set -- "$PARSED"
case "$1" in
-h|--help)
printf "setlocale: Configure system environment locale variables.\n\n"
printf "Usage: setlocale <locale>\n\n"
printf "Options:\n"
printf " -h, --help Display this help screen\n"
return 0
;;
--)
shift
break
;;
*)
disp E "Invalid options, use \"setlocale --help\" to display usage."
return 1
;;
esac
local loc=$1
[[ -z $loc ]] && disp E "No locale specified." && return 1
@@ -64,11 +90,12 @@ setlocale()
disp I "Locale set to $loc."
}
export -f setlocale
# ------------------------------------------------------------------------------
# ------------------------------------------------------------------------------
# Special case : change locale to C standard
# ------------------------------------------------------------------------------
# Usage: setc
setc()
{
# Locale definitions
@@ -76,27 +103,31 @@ setc()
disp I "Locale changed to standard C (POSIX)."
}
export -f setc
# ------------------------------------------------------------------------------
# ------------------------------------------------------------------------------
# Change locale to French
# ------------------------------------------------------------------------------
# Usage: setfr
setfr()
{
# Set fr locale definitions
setlocale "fr_FR.UTF-8"
}
export -f setfr
# ------------------------------------------------------------------------------
# ------------------------------------------------------------------------------
# Change locale to US (needed by Steam)
# ------------------------------------------------------------------------------
# Usage: setus
setus()
{
setlocale "en_US.UTF-8"
}
export -f setus
# ------------------------------------------------------------------------------
# ------------------------------------------------------------------------------
# EOF

11
profile.d/net.sh
View File

@@ -36,7 +36,7 @@
# ------------------------------------------------------------------------------
# Determine if parameter is a valid IPv4 address
# ------------------------------------------------------------------------------
# Usage: isipv4 <ip_address>
isipv4()
{
# Set up local variables
@@ -63,10 +63,12 @@ isipv4()
return 1
}
export -f isipv4
# ------------------------------------------------------------------------------
# ------------------------------------------------------------------------------
# Determine if parameter is a valid IPv4 address
# ------------------------------------------------------------------------------
# Usage: isipv6 <ip_address>
isipv6()
{
local ip="$1"
@@ -83,10 +85,12 @@ isipv6()
return 1
}
export -f isipv6
# ------------------------------------------------------------------------------
# ------------------------------------------------------------------------------
# Encode a string so it can be used as a URL parameter
# ------------------------------------------------------------------------------
# Usage: urlencode <string>
urlencode() {
local LANG=C
local str="$*"
@@ -101,6 +105,7 @@ urlencode() {
done
}
export -f urlencode
# ------------------------------------------------------------------------------
# ------------------------------------------------------------------------------

68
profile.d/packages.sh
View File

@@ -36,38 +36,53 @@
# ------------------------------------------------------------------------------
# Look for a package within installed one
# ------------------------------------------------------------------------------
# Usage: dpkgs <string>
pkgs()
{
local count=0
for opt in $@; do
case $opt in
"-h" | "--help")
echo "dpkgs: look for an installed package by it's name."
echo
echo "Usage: dpkgs <string>"
return 0
;;
local ignore_case=0
"-"*)
disp E "Invalid option, use \"dpkgs --help\" to display usage."
echo
return 1
;;
local PARSED
PARSED=$(getopt -o hi --long help,ignore-case -n 'pkgs' -- "$@")
if [[ $? -ne 0 ]]; then
disp E "Invalid options, use \"pkgs --help\" to display usage."
return 1
fi
eval set -- "$PARSED"
*)
local pkg=$1 && shift
count=$(($count + 1))
[[ $count -gt 1 ]] &&
disp E "Please specify a package name, without space, eventually partial." &&
while true; do
case "$1" in
-h|--help)
printf "pkgs: Look for an installed package by its name.\n\n"
printf "Usage: pkgs [options] <string>\n\n"
printf "Options:\n"
printf "\t-h, --help\tDisplay this help screen\n"
printf "\t-i, --ignore-case\tIgnore case distinctions\n"
return 0
;;
-i|--ignore-case)
ignore_case=1
shift
;;
--)
shift
break
;;
*)
disp E "Invalid option: $1"
return 1
;;
;;
esac
done
[[ $count -lt 1 ]] &&
disp E "Please specify a package name, without space, eventually partial." &&
local pkg="$1"
[[ -z "$pkg" ]] && {
disp E "Please specify a package name, without space, eventually partial."
return 1
}
# Build grep command
local grep_opt=""
(( ignore_case )) && grep_opt="-i"
command -v dpkg >/dev/null 2>&1 && local cmd="dpkg -l"
command -v rpm >/dev/null 2>&1 && local cmd="rpm -qa"
@@ -75,9 +90,10 @@ pkgs()
disp E "No usable package manager seems unavialable."
return 2
fi
$cmd | grep $pkg
$cmd | grep $grep_opt $pkg
}
export -f pkgs
# ------------------------------------------------------------------------------
# EOF

91
profile.d/processes.sh
View File

@@ -36,18 +36,38 @@
# ------------------------------------------------------------------------------
# Search processes matching the given string
# ------------------------------------------------------------------------------
# Usage: ppg <string>
ppg()
{
if [[ "$1" == "-h" || "$1" == "--help" ]]; then
printf "ppg: Search processes matching the given string.\n\n"
printf "Usage: ppg <string>\n\n"
printf "Options:\n"
printf "\t-h, --help\t\tDisplay this help screen\n"
return 0
fi
if [[ -z "$1" ]]; then
disp E "Usage: ppg <string>"
return 1
fi
ps -edf | grep "$@" | grep -v "grep $@"
}
export -f ppg
# ------------------------------------------------------------------------------
# ------------------------------------------------------------------------------
# List processes owned by a specific user
# ------------------------------------------------------------------------------
# Usage: ppu <username>
ppu()
{
if [[ "$1" == "-h" || "$1" == "--help" ]]; then
printf "ppu: List processes owned by a specific user.\n\n"
printf "Usage: ppu <username>\n\n"
printf "Options:\n"
printf "\t-h, --help\t\tDisplay this help screen\n"
return 0
fi
if [[ -z "$1" ]]; then
disp E "Usage: ppu <username>"
return 1
@@ -58,12 +78,21 @@ ppu()
ps -u "$1" -o pid,user,%cpu,%mem,start,time,command
}
export -f ppu
# ------------------------------------------------------------------------------
# ------------------------------------------------------------------------------
# List processes by exact command name (no path/parameters)
# ------------------------------------------------------------------------------
# Usage: ppn <command_name>
ppn()
{
if [[ "$1" == "-h" || "$1" == "--help" ]]; then
printf "ppn: List processes by exact command name (no path/parameters).\n\n"
printf "Usage: ppn <command_name>\n\n"
printf "Options:\n"
printf "\t-h, --help\t\tDisplay this help screen\n"
return 0
fi
if [[ -z "$1" ]]; then
disp E "Usage: ppn <command_name>"
return 1
@@ -75,12 +104,25 @@ ppn()
ps -eo pid,comm | grep -w "$1"
}
export -f ppn
# ------------------------------------------------------------------------------
# ------------------------------------------------------------------------------
# Get PID list of the given process name
# ------------------------------------------------------------------------------
# Usage: ppid <process_name [process_name2 ...]>
gpid()
{
if [[ "$1" == "-h" || "$1" == "--help" ]]; then
printf "gpid: Get PID list of the given process name.\n\n"
printf "Usage: gpid <process_name [process_name2 ...]>\n\n"
printf "Options:\n"
printf "\t-h, --help\t\tDisplay this help screen\n"
return 0
fi
if [[ -z "$1" ]]; then
disp E "Usage: gpid <process_name [process_name2 ...]>"
return 1
fi
[[ $UID -eq 0 ]] && local psopt="-A"
[[ $# -eq 1 ]] && local single=1
for pid in $@; do
@@ -94,34 +136,65 @@ gpid()
[[ $result ]] || return 1
}
export -f gpid
# ------------------------------------------------------------------------------
# ------------------------------------------------------------------------------
# Kill all processes owned by the given users (kill user)
# ------------------------------------------------------------------------------
# Usage: ku <username1 [username2 ...]>
ku()
{
if [[ "$1" == "-h" || "$1" == "--help" ]]; then
printf "ku: Kill all processes owned by the given users.\n\n"
printf "Usage: ku <username1 [username2 ...]>\n\n"
printf "Options:\n"
printf "\t-h, --help\t\tDisplay this help screen\n"
return 0
fi
if [[ -z "$1" ]]; then
disp E "Usage: ku <username1 [username2 ...]>"
return 1
fi
for u in $@; do
killall -u "$u"
done
}
export -f ku
# ------------------------------------------------------------------------------
# ------------------------------------------------------------------------------
# Kill all children of a process then the process (kill tree)
# ------------------------------------------------------------------------------
# Usage: kt <pid> [kill_options]
kt()
{
[[ -z $1 ]] && echo -e "Usage:\n\tkt <pid> [kill_options]"
if [[ "$1" == "-h" || "$1" == "--help" ]]; then
printf "kt: Kill all children of a process then the process (kill tree).\n\n"
printf "Usage: kt <pid> [kill_options]\n\n"
printf "Options:\n"
printf "\t-h, --help\t\tDisplay this help screen\n"
return 0
fi
if [[ -z "$1" ]]; then
disp E "Usage: ppg <string>"
return 1
fi
local parent_pid="$1"
shift
if [[ "$parent_pid" == "0" || "$parent_pid" == "1" ]]; then
disp E "Safety abort: Refusing to kill PID $parent_pid (system critical)."
return 1
fi
children_pids=$(pgrep -P "$parent_pid")
for pid in $children_pids; do
kt "$pid" "$@"
kt "$pid" "$@" || break
done
kill "$@" "$parent_pid"
}
# ------------------------------------------------------------------------------
# EOF

21
profile.d/prompt.sh
View File

@@ -35,17 +35,26 @@
# ------------------------------------------------------------------------------
# timer_* functions : internal timing function for prompt
# ------------------------------------------------------------------------------
# Usage: timer_now
# This function returns the current time in nanoseconds since the epoch. It
# first tries to use the %N format specifier for nanoseconds, but if that is
# not supported (e.g., on older systems), it falls back to seconds.
function timer_now
{
date +%s%N 2>/dev/null || date +%s
}
# Usage: timer_start
# This function initializes the timer_start variable with the current time in
# nanoseconds. It is used to measure the elapsed time for the prompt.
function timer_start
{
timer_start=${timer_start:-$(timer_now)}
}
# Usage: timer_stop
# This function calculates the elapsed time since timer_start and formats it
# into a human-readable string with appropriate units (us, ms, s, m, h
function timer_stop
{
local delta_us=$((($(timer_now) - $timer_start) / 1000))
@@ -74,8 +83,11 @@ function timer_stop
}
# ------------------------------------------------------------------------------
# Function triguered internaly by bash : defining prompt
# ------------------------------------------------------------------------------
# Function triggered internally by bash : defining prompt
# Usage: set_prompt
# This function is called by bash before displaying the prompt. It sets the
# PS1 variable to a custom prompt that includes the exit status of the last
# command, the elapsed time of the last command, and the current user and host.
set_prompt()
{
local Last_Command=$? # Must come first!
@@ -123,6 +135,7 @@ set_prompt()
# the text color to the default.
PS1+="$ICyan\\w \\\$$Default "
}
# ------------------------------------------------------------------------------
# EOF

163
profile.d/pwd.sh
View File

@@ -36,9 +36,20 @@
# ------------------------------------------------------------------------------
# genpwd : generate a password with different criteria
# default 16 car with up and low car, symbol and number
# Usage: genpwd [options] [--extracars=<cars>] [--length=<n>] [nb_passwd]
# Options:
# -h, --help Display that help screen
# -s, --nosymbols Exclude symbols
# -n, --nonumbers Exclude numbers
# -u, --noup Exclude uppercase letters
# -l, --nolow Exclude lowercase letters
# -e=<c>, --extracars=<c>
# Add the given caracters to the possible caracter list
# -L=<n>, --length=<n>
# Set length of the password (default is 16)
# -o=<n>, --occurences=<n>
# Set the maximum occurences of a same caracter (default is 2)
# The function is very slow on Windows
# ------------------------------------------------------------------------------
genpwd()
{
local length=16
@@ -47,80 +58,81 @@ genpwd()
local nbpwd=1
local extcar
for opt in $@; do
case $opt in
"-h" | "--help")
echo "genpwd: generate one or more secure random password."
echo
echo "Usage: genpwd [options] [--extracars=<cars>] [--length=<n>] [nb_passwd]"
echo
echo "Options:"
echo " -h, --help Display that help screen"
echo " -s, --nosymbols Exclude symbols"
echo " -n, --nonumbers Exclude numbers"
echo " -u, --noup Exclude uppercase letters"
echo " -l, --nolow Exclude lowercase letters"
echo " -e=<c>, --extracars=<c>"
echo " Add the given caracters to the possible caracter list"
echo " -L=<n>, --length=<n>"
echo " Set length of the password (default is $length)"
echo " -o=<n>, --occurences=<n>"
echo " Set the maximum occurences of a same caracter (default is $occurs)"
echo
echo "If the --extracars parameter is given, at least one of the given caracter will"
echo "be used in the final password."
echo
echo "Please note that some caracters might be interpreted by Bash or Awk programs,"
echo "and thus, cannot be used without provoquing errors. Those identified caracters"
echo "are :"
echo ' * ? \ $ { }'
echo
return 0
;;
"-s" | "--nosymbols")
symb=0
;;
"-n" | "--nonumbers")
numb=0
;;
"-u" | "--noup")
maj=0
;;
"-l" | "--nolow")
min=0
;;
"-e"?* | "--extracars"?*)
extcar=$(echo "$opt" | cut -f 2- -d '=')
;;
"-L"?* | "--length"?*)
local length=$(echo "$opt" | cut -f 2- -d '=')
if ! [[ $length =~ ^[0-9]+$ ]]; then
disp E "The --length parameter requires a number."
return 1
fi
;;
"-o"?* | "--occurences"?*)
local occurs=$(echo "$opt" | cut -f 2- -d '=')
if ! [[ $occurs =~ ^[1-9]+$ ]]; then
disp E "The --occurs parameter requires a number from 1 to 9."
return 1
fi
;;
"-*")
disp E "Unknow parameter ${opt}."
return 1
;;
*)
if ! [[ $opt =~ ^[1-9]+$ ]]; then
disp E "Unknow parameter ${opt}."
return 1
else
nbpwd=$opt
fi
;;
local PARSED
PARSED=$(getopt -o hsnu l e:L:o: --long \
help,nosymbols,nonumbers,noup,nolow,extracars:,length:,occurences: -n 'genpwd' -- "$@")
if [[ $? -ne 0 ]]; then return 1; fi
eval set -- "$PARSED"
while true; do
case "$1" in
-h|--help)
printf "genpwd: Generate secure random password(s).\n\n"
printf "Usage: genpwd [options] [nb_passwd]\n\n"
printf "Options:\n"
printf "\t-h, --help\t\tDisplay this help screen\n"
printf "\t-s, --nosymbols\t\tExclude symbols\n"
printf "\t-n, --nonumbers\t\tExclude numbers\n"
printf "\t-u, --noup\t\tExclude uppercase letters\n"
printf "\t-l, --nolow\t\tExclude lowercase letters\n"
printf "\t-e, --extracars <c>\tAdd characters to list\n"
printf "\t-L, --length <n>\tSet password length (default: 16)\n"
printf "\t-o, --occurences <n>\tMax occurences per character (default: 2)\n"
return 0
;;
-s|--nosymbols)
symb=0
shift
;;
-n|--nonumbers)
numb=0
shift
;;
-u|--noup)
maj=0
shift
;;
-l|--nolow)
min=0
shift
;;
-e|--extracars)
extcar="$2"
shift 2
;;
-L|--length)
length="$2"
if ! [[ $length =~ ^[0-9]+$ ]]; then
disp E "The --length parameter requires a number."
return 1
fi
shift 2
;;
-o|--occurences)
occurs="$2"
if ! [[ $occurs =~ ^[1-9]+$ ]]; then
disp E "The --occurs parameter requires a number from 1 to 9."
return 1
fi
shift 2
;;
--)
shift; break
;;
*)
break
;;
esac
done
if [[ -n "$1" ]]; then
nbpwd="$1"
if ! [[ $nbpwd =~ ^[0-9]+$ ]]; then
disp E "The number of password to generate must be a number."
return 1
fi
fi
# Function selecting a random caracter from the list in parameter
pickcar() {
# When a character is picked we check if it's not appearing already twice
@@ -136,7 +148,7 @@ genpwd()
}
disp I "Generating $nbpwd passwords, please wait..."
for n in $(seq 1 $nbpwd); do
for (( n=1; n<=nbpwd; n++ )); do
{
local carset='' # store final caracter set to use
local picked='' # store already used caracter
@@ -185,6 +197,7 @@ genpwd()
done
}
export -f genpwd
# ------------------------------------------------------------------------------
# EOF

57
profile.d/rain.sh
View File

@@ -36,27 +36,36 @@
# ------------------------------------------------------------------------------
# Let the rain fall
# ------------------------------------------------------------------------------
# Usage: rain [OPTIONS]
# Options:
# -s, --speed NUM Set the drop delay in seconds (default: 0.050).
# Lower values = faster rain.
# -c, --color COLOR Set the color theme (default: white).
# -h, --help Display this help message and exit.
# Available Colors:
# green : The classic Matrix digital rain
# blue : Deep ocean blue gradients
# red : Crimson/Blood rain
# yellow : Amber and gold tones
# cyan : Electric cyan/turquoise
# white : Greyscale and white (original style)
rain()
{
show_usage() {
echo -e "Usage: rain [OPTIONS]"
echo -e ""
echo -e "Options:"
echo -e " -s, --speed NUM Set the drop delay in seconds (default: 0.050)."
echo -e " Lower values = faster rain."
echo -e " -c, --color COLOR Set the color theme (default: white)."
echo -e " -h, --help Display this help message and exit."
echo -e ""
echo -e "Available Colors:"
echo -e " \e[32mgreen\e[0m : The classic Matrix digital rain"
echo -e " \e[34mblue\e[0m : Deep ocean blue gradients"
echo -e " \e[31mred\e[0m : Crimson/Blood rain"
echo -e " \e[33myellow\e[0m : Amber and gold tones"
echo -e " \e[36mcyan\e[0m : Electric cyan/turquoise"
echo -e " white : Greyscale and white (original style)"
echo -e ""
echo -e "Example: rain --color green --speed 0.03"
printf "Usage: rain [OPTIONS]\n"
printf "Options:\n"
printf "\t-s, --speed NUM Set the drop delay in seconds (default: 0.050).\n"
printf "\t Lower values = faster rain.\n"
printf "\t-c, --color COLOR Set the color theme (default: white).\n"
printf "\t-h, --help Display this help message and exit.\n\n"
printf "Available Colors:\n"
printf "\t\e[32mgreen\e[0m\t: The classic Matrix digital rain\n"
printf "\t\e[34mblue\e[0m\t: Deep ocean blue gradients\n"
printf "\t\e[31mred\e[0m\t: Crimson/Blood rain\n"
printf "\t\e[33myellow\e[0m\t: Amber and gold tones\n"
printf "\t\e[36mcyan\e[0m\t: Electric cyan/turquoise\n"
printf "\twhite\t: Greyscale and white (original style)\n\n"
printf "Example: rain --color green --speed 0.03\n"
}
local step_duration=0.050
@@ -69,7 +78,7 @@ rain()
if [[ -n "$2" && ! "$2" =~ ^- ]]; then
step_duration="$2"; shift
else
echo -e "\e[31mError: --speed requires a numeric value.\e[0m"
disp E "--speed requires a numeric value."
show_usage && return 1
fi
;;
@@ -77,7 +86,7 @@ rain()
if [[ -n "$2" && ! "$2" =~ ^- ]]; then
base_color="$2"; shift
else
echo -e "\e[31mError: --color requires a color name.\e[0m"
disp E "--color requires a color name."
show_usage && return 1
fi
;;
@@ -85,7 +94,7 @@ rain()
show_usage && return 0
;;
*)
echo -e "\e[31mUnknown option: $1\e[0m"
disp E "Unknown option: $1"
show_usage && return 1
;;
esac
@@ -168,7 +177,7 @@ rain()
drop_length=${rains[idx + 4]}
for ((y = Y; y < Y + drop_length; y++)); do
((y < 1 || y > term_height)) && continue
echo -ne "\e[${y};${X}H${drop_color}${rain_drop}"
printf "\e[${y};${X}H${drop_color}${rain_drop}"
done
done
}
@@ -177,9 +186,9 @@ rain()
trap sigwinch WINCH
# No echo stdin and hide the cursor
stty -echo
echo -ne "\e[?25l"
printf "\e[?25l"
printf "\e[2J"
echo -ne "\e[2J"
local rains=()
local num_rains=0
sigwinch

79
profile.d/ssh.sh
View File

@@ -36,17 +36,42 @@
# ------------------------------------------------------------------------------
# Remove host from know_host (name and IP) for the active user
# ------------------------------------------------------------------------------
# Usage: rmhost <hostname|ip> [hostname2|ip2 [...]]
rmhost()
{
if [[ "$#" -lt 1 ]]; then
disp E "Incorrect number of parameters."
disp E "Usage: rmhost <hostname|ip> [hostname2|ip2 [...]]"
local PARSED
PARSED=$(getopt -o h --long help -n 'rmhost' -- "$@")
if [[ $? -ne 0 ]]; then return 1; fi
eval set -- "$PARSED"
while true; do
case "$1" in
-h|--help)
printf "rmhost: Remove host/IP from ~/.ssh/known_hosts.\n\n"
printf "Usage: rmhost <hostname|ip> [hostname2|ip2 ...]\n\n"
printf "Options:\n"
printf " -h, --help Display this help screen\n"
return 0
;;
--)
shift
break
;;
*)
disp E "Invalid options, use \"rmhost --help\" to display usage."
break
;;
esac
done
# Validation: Ensure at least one argument remains
if [[ $# -eq 0 ]]; then
disp E "Missing argument. Use 'rmhost --help' for usage."
return 1
fi
while [[ $1 ]]; do
local hst=$1 && shift
for target in "$@"; do
local hst=$target
isipv4 "$hst" >/dev/null
local v4=$?
isipv6 "$hst" >/dev/null
@@ -81,20 +106,36 @@ rmhost()
done
}
export -f rmhost
# ------------------------------------------------------------------------------
# ------------------------------------------------------------------------------
# Login root via SSH on the given machine
# ------------------------------------------------------------------------------
# Usage: ssr <server [ssh options]>
ssr()
{
for opt in $@; do
case $opt in
"-h" | "--help")
echo "ssr: do a root user ssh login."
echo
echo "Usage: ssr <server [ssh options]>"
return 0
;;
local PARSED
PARSED=$(getopt -o h --long help -n 'ssr' -- "$@")
if [[ $? -ne 0 ]]; then return 1; fi
eval set -- "$PARSED"
while true; do
case "$1" in
-h|--help)
printf "ssr: SSH into a server as root.\n\n"
printf "Usage: ssr <server> [ssh_options...]\n\n"
printf "Options:\n"
printf "\t-h, --help\t\tDisplay this help screen\n"
return 0
;;
--)
shift
break
;;
*)
disp E "Invalid options, use \"ssr --help\" to display usage."
return 1
;;
esac
done
@@ -102,15 +143,17 @@ ssr()
disp E "ssh is not installed."
return 127
}
[[ ! $1 ]] &&
disp E "Please specify the server you want to log in." &&
[[ ! $1 ]] && {
disp E "Please specify the server you want to log in."
return 1
}
local srv=$1 && shift
ssh -Y root@"$srv" "$@"
}
export -f ssr
# ------------------------------------------------------------------------------
# EOF

71
profile.d/updates.sh
View File

@@ -40,14 +40,40 @@ export ARCH_URL="$BASE_URL/archive/master.tar.gz"
# ------------------------------------------------------------------------------
# Check for profile updates
# ------------------------------------------------------------------------------
# Usage: check_updates [-q]
# If -q is specified, the function will operate in quiet mode (internal use only)
check_updates()
{
if [[ $1 == "-q" ]]; then
# Quiet mode is mostly used internally when profile_upgrade is called
quiet=1
local quiet=0
local PARSED=$(getopt -o hq --long help,quiet -n 'check_updates' -- "$@")
if [[ $? -ne 0 ]]; then
disp E "Invalid options, use \"check_updates --help\" to display usage."
return 1
fi
[[ -n $quiet ]] && disp I "Checking for updates..."
eval set -- "$PARSED"
while true; do
case "$1" in
-h|--help)
printf "check_updates: Check for new versions.\n\n"
printf "Usage: check_updates\n"
return 0
;;
-q|--quiet)
quiet=1
shift
;;
--)
shift
break
;;
*)
break
;;
esac
done
(( $quiet != 1 )) && disp I "Checking for updates..."
local vfile="/tmp/version"
wget "$UPDT_URL/version" -O $vfile >/dev/null 2>&1 || {
disp E "Can't download version file, impossible to proceed!"
@@ -58,10 +84,10 @@ check_updates()
local lastver=$(cat $vfile)
if [[ $lastver != $PROFVERSION ]]; then
disp I "You have version $PROFVERSION installed. Version $lastver is available."
[[ $quiet ]] && disp I "You should upgrade to last version when possible."
(( $quiet != 1 )) && disp I "You should upgrade to last version when possible."
result=1
else
[[ -n $quiet ]] && disp I "Your version is up-to-date."
(( $quiet != 1 )) && disp I "Your version is up-to-date."
result=0
fi
rm -f $vfile
@@ -71,12 +97,38 @@ check_updates()
unset lastver vfile
return $result
}
# ------------------------------------------------------------------------------
# ------------------------------------------------------------------------------
# Apply update to profile
# ------------------------------------------------------------------------------
# Usage: profile_upgrade
profile_upgrade()
{
local PARSED=$(getopt -o h --long help -n 'profile_upgrade' -- "$@")
if [[ $? -ne 0 ]]; then
printf "Invalid options, use \"profile_upgrade --help\" to display usage."
return 1
fi
eval set -- "$PARSED"
while true; do
case "$1" in
-h|--help)
printf "profile_upgrade: Upgrade the profile to the latest version.\n\n"
printf "Usage: profile_upgrade\n"
return 0
;;
--)
shift
break
;;
*)
disp E "Invalid options, use \"profile_upgrade --help\" to display usage."
return 1
;;
esac
done
if check_updates -q; then
disp "No update available."
return 0
@@ -130,4 +182,7 @@ profile_upgrade()
rm -rf "$tmpdir"
fi
}
# ------------------------------------------------------------------------------
# EOF

155
profile.sh
View File

@@ -43,7 +43,6 @@ fi
# ------------------------------------------------------------------------------
# path* : private functions for PATH variable management
# ------------------------------------------------------------------------------
pathremove()
{
local IFS=':'
@@ -71,6 +70,96 @@ pathappend()
local pathvar=${2:-PATH}
export $pathvar="${!pathvar:+${!pathvar}:}$1"
}
# ------------------------------------------------------------------------------
# ------------------------------------------------------------------------------
# Configuration file parser
parse_conf()
{
local config_file="$1"
local current_section=""
[[ ! -f "$config_file" ]] && return 1
while IFS='=' read -r key value || [[ -n "$key" ]]; do
# Clean key and value (strip CR and whitespace)
key=$(printf '%s' "$key" | tr -d '\r' | xargs 2>/dev/null)
value=$(printf '%s' "$value" | tr -d '\r' | xargs 2>/dev/null)
# Skip comments and empty lines
[[ -z "$key" || "$key" =~ ^[#\;] ]] && continue
# Section Detection: [section_name]
if [[ "$key" =~ ^\[(.*)\]$ ]]; then
current_section="${BASH_REMATCH[1]}"
# Dynamically declare the associative array for this section
declare -g -A "CONF_$current_section"
continue
fi
# If we have a key/value pair and are inside a section
if [[ -n "$current_section" && -n "$value" ]]; then
# Strip quotes from value
value="${value%\"}"; value="${value#\"}"
value="${value%\'}"; value="${value#\'}"
# Store in the dynamic array: CONF_sectionname[key]=value
eval "CONF_${current_section}['$key']='$value'"
fi
done < "$config_file"
}
# ------------------------------------------------------------------------------
# ------------------------------------------------------------------------------
# Load command aliases from configuration
load_alias()
{
local section_name="CONF_$1"
# Check if the associative array for this section exists
if [[ "$(declare -p "$section_name" 2>/dev/null)" != "declare -A"* ]]; then
return 1
fi
# Reference the array keys
eval "local keys=\"\${!$section_name[@]}\""
for key in $keys; do
# Fetch the value for this specific key
eval "local cmd=\"\${$section_name[$key]}\""
# Portability check: only alias if the command exists
local base_cmd=$(echo "$cmd" | awk '{print $1}')
if command -v "$base_cmd" >/dev/null 2>&1; then
alias "$key"="$cmd"
fi
done
}
# ------------------------------------------------------------------------------
# ------------------------------------------------------------------------------
# Load configuration values as environment variables
load_conf()
{
local section_name="CONF_$1"
if [[ "$(declare -p "$section_name" 2>/dev/null)" != "declare -A"* ]]; then
return 1
fi
eval "local keys=\"\${!$section_name[@]}\""
for key in $keys; do
eval "local val=\"\${$section_name[$key]}\""
# Export as a standard shell variable
export "$key"="$val"
done
}
# ------------------------------------------------------------------------------
# ------------------------------------------------------------------------------
# ------------------------------------------------------------------------------
@@ -101,41 +190,14 @@ export PROFVERSION=$(cat "$MYPATH"/version)
if [[ $EUID -eq 0 ]]; then
pathappend /sbin:/usr/sbin
fi
[[ -d /share/services/gestparc ]] && pathappend /share/services/gestparc
[[ -d ~/bin ]] && pathappend ~/bin
[[ -d ~/.local/bin ]] && pathappend ~/.local/bin
# ------------------------------------------------------------------------------
# Default values are set here and will be overloaded with config file if any
# ------------------------------------------------------------------------------
# Set bash history
export HISTSIZE=50000
export HISTIGNORE="&:[bf]g:exit"
# Set default pager
export PAGER=less
# More colors
export TERM=xterm-256color
# Set some compiling values
export CFLAGS="-O2 -pipe -march=native"
export MAKEFLAGS='-j12'
export PKGSOURCES='/share/src/archives'
# Default city for weather forcast
export DEFAULT_CITY="Toulouse"
# ------------------------------------------------------------------------------
# Default values could be altered after this line
# ------------------------------------------------------------------------------
# Load global configuration
[[ -f $MYPATH/etc/profile.conf ]] && . $MYPATH/etc/profile.conf
# Load personal configuration
[[ -f ~/.profile.conf ]] && . ~/.profile.conf
# Parse and load general configuration
export PROFILE_CONF="$MYPATH/profile.conf"
parse_conf "$PROFILE_CONF"
load_conf system # Load Bash system behavior configuration (history, pager, etc.)
load_conf general # General purpose configuration (compilation flags, etc.)
# Load module scripts
for script in $MYPATH/profile.d/*.sh; do
@@ -152,30 +214,7 @@ done
if [[ $INTERACTIVE ]]; then
# For compiling (as we often compile with LFS/0linux...)
#Aliases
alias ll='ls -laFh --color=auto'
alias la='ls -Ah --color=auto'
alias l='ls -CF --color=auto'
alias ls='ls --color=auto'
alias grep='grep --color=auto'
alias egrep='egrep --color=auto'
alias fgrep='fgrep --color=auto'
alias qfind="find . -name "
alias mkck='make check'
alias mkin='make install'
alias mkdin='make DESTDIR=$PWD/dest-install install'
alias ssh='ssh -Y'
alias wget='wget -c' # resume mode by default
alias myip='curl ip.appspot.com'
# Human readable by default
alias df='df -H'
alias du='du -ch'
alias sdu='du -sk ./* | sort -n'
alias hdu='du -hs ./* | sort -H'
load_alias aliases
# Define PS1
trap 'timer_start' DEBUG
@@ -183,7 +222,7 @@ if [[ $INTERACTIVE ]]; then
# Set default language
setfr
showinfo
showinfo && printf "\n"
check_updates -q
disp I "Profile version $PROFVERSION chargé..."
fi

2
version
View File

@@ -1 +1 @@
3.6.1
3.95.1-4_beta_1