implemented showextip

README.md

@@ -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;

history.txt

@@ -7,6 +7,28 @@ Current version from Geoffray Levasseur <fatalerrors@geoffray-levasseur.org>
 ------------------------------------------------------------------------------
 Version history:
 ------------------------------------------------------------------------------
+# 05/03/2026 v3.6.1
+	Fix a typo in compress.sh
+
+# 05/03/2026 v3.6.0
+	Improved utaz to make it multiformat with lot of it
+	Introduced ppu and ppn
+	Improved update system
+
+# 04/03/2026 v3.5.0
+	rain has now configurable speed and color
+	showinfo adapted to fastfetch, replacing neofetch
+
+# 24/02/2022 v3.3.1
+	Fixed version detection
+	Added "busy" function
+	Fixed use of library functions before it's loaded
+
+# 28/11/2022 v3.3.0
+	Initial version update support
+	Changed versioning code
+	Added installation path detection
+
 # 28/11/2022 v3.2.3
 	Made proper readme file, to improve
 

profile.conf

@@ -0,0 +1,50 @@
+[system]
+# System section is used to set Bash behavior and other system related variables,
+# such as the default pager, the terminal type, etc.
+# Set bash history
+HISTSIZE=50000
+HISTIGNORE="&:[bf]g:exit"
+
+# Set default pager
+PAGER=less
+
+# Set terminal colors behavior
+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 freely global variables for personal use.
+# Set some compiling values
+CFLAGS="-O2 -pipe -march=native"
+CXXFLAGS="$CFLAGS"
+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'

profile.d/compress.sh

@@ -1,3 +1,4 @@
+#!/usr/bin/env bash
 # ------------------------------------------------------------------------------
 # Copyright (c) 2013-2022 Geoffray Levasseur <fatalerrors@geoffray-levasseur.org>
 # Protected by the BSD3 license. Please read bellow for details.
@@ -34,109 +35,326 @@
 # ------------------------------------------------------------------------------
 
 # ------------------------------------------------------------------------------
-# Smartly uncompress archives (zip only)
+# 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()
 {
-    for opt in $@ ; do
+    _ununzip()
-        case $opt in
+    {
-            "-h"|"--help")
+        unzip -o "$1" -d "$2" >/dev/null 2>&1
-                echo "utaz: uncompress all the given files and/or the ones found in the given"
+    }
-                echo "      directories creating an host directory where needed."
+
-                echo
+    _untar()
-                echo "Usage: utaz [option] [directorie(s)|file(s)]"
+    {
-                echo
+        tar -xf "$1" -C "$2"
-                echo "Options:"
+    }
-                echo "	-h, --help		Display that help screen"
+
-                echo "	-d, --delete		If decompression succeeded, delete the source file"
+    _ungzip()
-                echo "	-c, --create-dir	Always create a host directory"
+    {
-                echo "	-n, --no-dir		Never create a host directory"
+        tar -xzf "$1" -C "$2"
-                echo
+    }
+
+    _unbzip2()
+    {
+        tar -xjf "$1" -C "$2"
+    }
+
+    _unxz()
+    {
+        tar -xJf "$1" -C "$2"
+    }
+
+    _unlzop()
+    {
+        lzop -d "$1" -o "$2/$(basename "${1%.*}")"
+    }
+
+    _unlzip()
+    {
+        if command -v plzip >/dev/null 2>&1; then
+            plzip -d -c "$1" > "$2/$(basename "${1%.*}")"
+        else
+            lzip -d -c "$1" > "$2/$(basename "${1%.*}")"
+        fi
+    }
+
+    _ununrar()
+    {
+        unrar x -o+ "$1" "$2/" >/dev/null 2>&1
+    }
+
+    _ununarj()
+    {
+        unarj e "$1" "$2/" >/dev/null 2>&1
+    }
+
+    _unlza()
+    {
+        # lha typically extracts into the current directory
+        # We ensure it hits the target directory
+        (cd "$2" && lha -x "../$1") >/dev/null 2>&1
+    }
+
+    _ununace()
+    {
+        unace x "$1" "$2/" >/dev/null 2>&1
+    }
+
+    _un7z()
+    {
+        7z x "$1" -o"$2/" >/dev/null 2>&1
+    }
+
+    _unzstd()
+    {
+        # Zstd decompresses files directly, often requiring tar for archives
+        tar --zstd -xf "$1" -C "$2"
+    }
+
+    _uncpio()
+    {
+        # CPIO requires careful directory handling
+        (cd "$2" && cpio -id < "../$1") >/dev/null 2>&1
+    }
+
+    _uncabextract()
+    {
+        # Requires 'cabextract' package
+        cabextract "$1" -d "$2/" >/dev/null 2>&1
+    }
+
+    _undeb()
+    {
+        # Extracts data content from a Debian package
+        dpkg-deb -x "$1" "$2/" >/dev/null 2>&1
+    }
+
+    _unrpm()
+    {
+        # Extracts CPIO-based payload from an RPM package
+        # Needs rpm2cpio and cpio
+        rpm2cpio "$1" | (cd "$2/" && cpio -idmv) >/dev/null 2>&1
+    }
+
+    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
             ;;
-
+        --)
-            "-"*)
+            shift
-                disp E "Invalid option, use \"utaz --help\" to display options list"
+            break
-                echo
-                return 1
             ;;
-
         *)
-                # The ${opt%/} writing is to remove trailing / if any
+            disp E "Invalid option, use \"utaz --help\" to display options list"
-                local LIST="$LIST ${opt%/}"
+            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=(".")
 
-    [[ $createdir && $nodir ]] && disp E "The --create-dir and --no-dir options are mutually exclusive."
+    [[ -n ${createdir} && -n ${nodir} ]] && \
+        disp E "The --create-dir and --no-dir options are mutually exclusive."
 
-    [[ ! $LIST ]] && local LIST="."
+    for zitem in "${FILES[@]}"; do
-
+        for f in "${zitem}"/*; do
-    for zitem in $LIST; do
+            local dir="${f%.*}"
-        [[ $(ls $zitem/*.zip 2> /dev/null | wc -l) -eq 0 ]] &&
+            local extractor=""
-            disp W "$zitem contains no supported archive file, skipping." &&
+            case "$f" in
+                *.zip)
+                    extractor="_ununzip"
+                ;;
+                *.tar.gz|*.tgz)
+                    extractor="_ungzip"
+                    ;;
+                *.tar.bz2|*.tbz2)
+                    extractor="_unbzip2"
+                    ;;
+                *.tar.xz|*.txz)
+                    extractor="_unxz"
+                    ;;
+                *.tar.lz|*.tlz)
+                    extractor="_unlzop"
+                    ;;
+                *.tar)
+                    extractor="_untar"
+                    ;;
+                *.rar)
+                    extractor="_ununrar"
+                    ;;
+                *.arj)
+                    extractor="_ununarj"
+                    ;;
+                *.lzh|*.lha)
+                    extractor="_unlha"
+                    ;;
+                *.ace)
+                    extractor="_ununace"
+                    ;;
+                *.7z|*.p7z)
+                    extractor="_un7z"
+                    ;;
+                *.zst)
+                    extractor="_unzstd"
+                    ;;
+                *.cpio)
+                    extractor="_uncpio"
+                    ;;
+                *.cab)
+                    extractor="_uncabextract"
+                    ;;
+                *.deb)
+                    extractor="_undeb"
+                    ;;
+                *.rpm)
+                    extractor="_unrpm"
+                    ;;
+                *)
+                    disp I "File ${f} is not a supported archive, skipping."
                     continue
+                    ;; # Skip non-archive files
+            esac
 
-        for f in $zitem/*.zip; do
+            # Verify binary existence
-            disp I "Processing archive $zitem/$f... "
+            local cmd=${extractor//_un/}
-            local dir=${f::-4}
+            if [[ $cmd == "deb" ]]; then
+                command -v dpkg-deb >/dev/null 2>&1 || {
+                    disp E "The program 'dpkg-deb' is not installed, aborting."
+                    continue
+                }
+            elif [[ $cmd == "rpm" ]]; then
+                command -v rpm2cpio >/dev/null 2>&1 || {
+                    disp E "The program 'rpm2cpio' is not installed, aborting."
+                    continue
+                }
+                command -v cpio >/dev/null 2>&1 || {
+                    disp E "The program 'cpio' is not installed, aborting."
+                    continue
+                }
+            else
+                command -v ${cmd} >/dev/null 2>&1 || {
+                    disp E "Binary ${cmd} necessary to extract ${f} is missing."
+                    continue
+                }
+            fi
 
-            mkdir -p $dir
+            disp I "Processing archive ${f} with ${extractor}..."
+            mkdir -p "${dir}"
             [[ $? -gt 0 ]] &&
                 disp E "The filesystem can't create directories, exit!" &&
                 return 1
 
-            unzip -o $f -d $dir > /dev/null 2>&1
+            ${extractor} "${f}" "${dir}"
             case $? in
             0)
-                    [[ $willrm ]] && rm -f $f && disp I "File $zitem/$f deleted."
+                [[ -n ${willrm} ]] &&
+                     rm -f "${f}" && disp I "File ${zitem}/${f} deleted."
                 ;;
-
             1)
+                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
+                rm -rf "${dir}" >/dev/null 2>&1
                 continue
                 ;;
             esac
 
-            if [[ $createdir ]]; then
+            if [[ -n ${createdir} ]]; then
                 disp I "Archive extracted successfully in subdirectory."
-            elif [[ $nodir ]]; then
+            elif [[ -n ${nodir} ]]; then
-                mv ./$dir/* ./ && rmdir $dir
+                mv "./${dir}/"* ./ && rmdir "${dir}"
                 disp I "Archive extracted successfully, no subdirectory needed."
             else
-                subdirs=$(find $dir -maxdepth 1 | wc -l)
+                # Set nullglob to ensure the array is empty if no files match
-                if [[ $subdirs -eq 2 ]]; then
+                shopt -s nullglob
-                    mv ./$dir/* ./ && rmdir $dir
+                local contents=( "${dir}"/* )
+
+                # Check if exactly one item exists and if that item is a directory
+                if [[ ${#contents[@]} -eq 1 ]] && [[ -d "${contents[0]}" ]]; then
+                    # Single directory detected
+                    mv "${contents[0]}"/* ./ && rmdir "${dir}"
                     disp I "Archive extracted successfully, no subdirectory needed."
                 else
                     disp I "Archive extracted successfully in subdirectory."
                 fi
+                shopt -u nullglob
             fi
         done
     done
 }
 export -f utaz
+# ------------------------------------------------------------------------------
+
 
 # ------------------------------------------------------------------------------
 # Compress directories or files into one or more archive
-# ------------------------------------------------------------------------------
+# Usage: taz [option] [--parallel=<n>] [--format=<format>] [directory1 ... directoryN]
-taz ()
+# 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()
     {
@@ -166,11 +384,11 @@ taz ()
                 disp E "Program 'plzip' or 'lzip' are not installed, aborting."
                 return 127
             }
-            local command=lzip
+            command=lzip
             local procopt=""
             [[ $2 -gt 1 ]] &&
                 disp W "lzip doesn't support multithreading, falling back to 1 thread." &&
-                disp W "Consitder installing plzip to obtain multithreading abilities."
+                disp W "Consider installing plzip to obtain multithreading abilities."
         }
 
         [[ $4 ]] && local verb="-vv"
@@ -194,7 +412,7 @@ taz ()
             local procopt=""
             [[ $2 -gt 1 ]] &&
                 disp W "gzip doesn't support multithreading, falling back to 1 thread." &&
-                disp W "Consitder installing pigz to obtain multithreading abilities."
+                disp W "Consider installing pigz to obtain multithreading abilities."
         }
 
         [[ $4 ]] && local verb="--verbose"
@@ -218,7 +436,7 @@ taz ()
             local procopt=""
             [[ $2 -gt 1 ]] &&
                 disp W "bzip2 doesn't support multithreading, falling back to 1 thread." &&
-                disp W "Consitder installing pbzip2 to obtain multithreading abilities."
+                disp W "Consider installing pbzip2 to obtain multithreading abilities."
         }
 
         [[ $4 ]] && local verb="-v"
@@ -243,85 +461,99 @@ taz ()
         return $?
     }
 
-    for opt in $@ ; do
+    local PARSED
-        case $opt in
+    PARSED=$(getopt -o hdf:p:vq123456789 --long help,delete,format:,parallel:,verbose,quiet --name "taz" -- "$@")
-            "-h"|"--help")
+    if [ $? -ne 0 ]; then
-                echo "taz: archive all files of a directory."
+        disp E "Invalid options, use \"taz --help\" to display usage."
-                echo
+        return 1
-                echo "Usage: taz [option] [--parallel=<n>] [--format=<format>] [directory1 ... directoryN]"
+    fi
-                echo
+    eval set -- "$PARSED"
-                echo "Options:"
+    while true; do
-                echo "	-h, --help	Display that help screen"
+        case "$1" in
-                echo "	-d, --delete	Delete source file or directory after success"
+        -h|--help)
-                echo "	-f, --format	Chose archive format in the given list. If several format are"
+            printf "taz: archive all files of a directory.\n\n"
-                echo "			given, the smalest is kept"
+            printf "Usage: taz [option] [--parallel=<n>] [--format=<format>] [directory1 ... directoryN]\n\n"
-                echo "	-p, --parallel	Number of threads to use (if allowed by underlying utility)"
+            printf "Options:\n"
-                echo "	-v, --verbose	Display progress where possible"
+            printf "\t-h, --help\tDisplay that help screen\n"
-                echo "	-q, --quiet	Display less messages (only errors and warnings)"
+            printf "\t-d, --delete\tDelete source file or directory after success\n"
-                echo "	-1, .., -9	Compression level to use [1=fast/biggest, 9=slow/smallest]"
+            printf "\t-f, --format\tChose archive format in the given list. If several format are"
-                echo
+            printf "\t\t\tgiven, the smalest is kept\n"
-                echo "Supported archive format:"
+            printf "\t-p, --parallel\tNumber of threads to use (if allowed by underlying utility)\n"
-                echo "	Param.| programs      | Algo. | Description"
+            printf "\t-v, --verbose\tDisplay progress where possible\n"
-                echo "	------+---------------+-------+----------------------------------------"
+            printf "\t-q, --quiet\tDisplay less messages (only errors and warnings)\n"
-                echo "	   lz | plzip, lzip   | lzma  | Safe efficient default format"
+            printf "\t-1, .., -9\tCompression level to use [1=fast/biggest, 9=slow/smallest]\n\n"
-                echo "	   xz | xz            | lzma2 | Unsafe, not for long term"
+            printf "Supported archive format:\n"
-                echo "	  bz2 | pbzip2, bzip2 | bzip2 | Historical but less efficient than lz"
+            printf "\tParam.| programs      | Algo. | Description\n"
-                echo "	   gz | pigz, gzip    | lz77  | Historical, safe, fast"
+            printf "\t------+---------------+-------+----------------------------------------\n"
-                echo "	  lzo | lzop          | lzo   | Very fast but no multithread"
+            printf "\t   lz | plzip, lzip   | lzma  | Safe efficient default format\n"
-                echo "	  tar | tar           | tar   | No compression"
+            printf "\t   xz | xz            | lzma2 | Unsafe, not for long term\n"
-                echo
+            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"?*)
+        -f|--format)
-                local compform=$(echo "$opt" | cut -f 2- -d '=')
+            local compform=$2
+            shift 2
             ;;
 
-            "-p"?*|"--parallel"?*)
+        -p|--parallel)
-                local nproc=$(echo "$opt" | cut -f 2- -d '=')
+            local nproc=$2
+            shift 2
             ;;
 
-            "-v"|"--verbose")
+        -v|--verbose)
             local verbose=1
+            shift
             ;;
 
-	    "-q"|"--quiet")
+        -q|--quiet)
-		QUIET=1
+            local quiet=1
+            shift
             ;;
 
-            "-"*)
+        -[1-9])
-		local complevel=$(echo $opt | sed 's/-//')
+            compression="${1#-}"
-		if ! [[ $complevel =~ ^[1-9]+$ ]]; then
+            shift
-		    disp E "Invalid option, use taz --help to display options list"
+            ;;
-                    echo
+        --)
-                    return 1
+            shift
-		fi
+            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 ]] &&
+    [[ $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..."
 
-        if [[ -d $item ]]; then
+        if [[ -d "$item" ]]; then
             disp I "\t Creating $item.tar... "
 
-            tar -cf $item{.tar,}
+            tar -cf "$item.tar" "$item"
             if [[ ! $? -eq 0 ]]; then
                 disp E "tar file creation failed, skipping to next item."
                 continue
@@ -336,7 +568,7 @@ taz ()
         # Skip compression part if tar is asked
         if [[ $compform != "tar" ]]; then
             disp I "\t Compressing archive..."
-            _do$compform $fname $nproc $complevel $verbose
+            _do$compform "$fname" "$nproc" "$complevel" "$verbose"
             [[ ! $? -eq 0 ]] && case $? in
             127)
                 disp E "Compression program unavailable, aborting."
@@ -348,14 +580,18 @@ taz ()
                 ;;
             esac
 
-            [[ $donetar -gt 0 ]] && rm $fname
+            [[ $donetar -gt 0 ]] && rm "$fname"
         fi
 
         if [[ $willrm ]]; then
             disp I "\t Deleting original source as asked... "
-            rm -r $item
+            rm -r "$item"
         fi
     done
-    unset QUIET
+    unset quiet
 }
 export -f taz
+# ------------------------------------------------------------------------------
+
+
+# EOF

profile.d/debug.sh

@@ -1,3 +1,4 @@
+#!/bin/bash
 # ------------------------------------------------------------------------------
 # Copyright (c) 2013-2022 Geoffray Levasseur <fatalerrors@geoffray-levasseur.org>
 # Protected by the BSD3 license. Please read bellow for details.
@@ -35,73 +36,88 @@
 
 # ------------------------------------------------------------------------------
 # Display a backtrace
-# ------------------------------------------------------------------------------
+# Usage: backtrace
-function backtrace ()
+function backtrace()
 {
-    echo "========= Call stack ========="
+    printf "========= Call stack =========\n"
-    typeset -i i=0
+    local i=1 # We begin at 1 to ignore backtrace itself
-    
+    while [[ $i -lt ${#FUNCNAME[@]} ]]; do
-    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)) ]}"
+            "${FUNCNAME[$i]}" "${BASH_SOURCE[$i]}" "${BASH_LINENO[$(( i-1 ))]}"
-        fi
+        ((i++))
-        let i++ || true
     done
     unset func i
-    echo "=============================="
+    printf "==============================\n"
 }
 
 # ------------------------------------------------------------------------------
 # Function to be trapped for errors investigation
-# ------------------------------------------------------------------------------
+function error()
-function error ()
 {
     local errcode=$?
     backtrace
     return $errcode
 }
 
-
 # ------------------------------------------------------------------------------
 # Activate or deactivate error trapping to display backtrace
-# ------------------------------------------------------------------------------
+# Usage: settrace <--on|--off|--status>
-settrace ()
+settrace()
 {
     local status="off"
     [[ $(trap -p ERR) ]] && status="on"
     #trap -p ERR
-    for opt in $@ ; do
+
-        case $opt in
+    local PARSED
-            "-h"|"--help")
+    PARSED=$(getopt -oh --long help,on,off,status -- "$@")
-		echo "Try to activate backtrace display for script debugging."
+    if [[ $? -ne 0 ]]; then
-		echo
+        disp E "Invalid options, use \"settrace --help\" to display usage."
-		echo "Options:"
+        return 1
-		echo "	--on	Activate backtrace generation"
+    fi
-		echo "	--off	Deactivate backtrace generation"
+    eval set -- "$PARSED"
-		echo
+    while true; do
-		echo "That function active a trap event on error. If the script you want to"
+        case $1 in
-		echo "debug overload the ERR bash trap, it will not work."
+        -h|--help)
-		echo
+            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")
+        --on)
-		if [[ $status == "on" ]]; then
+            if [[ ${status} == "on" ]]; then
                 disp W "ERR signal trap is already set, replacing previous trap!"
             fi
             trap "error" ERR
+            shift
             ;;
-	    "--off")
+        --off)
-		if [[ $status != "on" ]]; then
+            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

profile.d/disp.sh

@@ -1,3 +1,4 @@
+#!/bin/bash
 # ------------------------------------------------------------------------------
 # Copyright (c) 2013-2022 Geoffray Levasseur <fatalerrors@geoffray-levasseur.org>
 # Protected by the BSD3 license. Please read bellow for details.
@@ -35,11 +36,11 @@
 
 # ------------------------------------------------------------------------------
 # Color definitions
-# ------------------------------------------------------------------------------
 # Standard 16 colors display declaration
-export DEFAULTFG="\e[0;39m"
+export DEFAULTFG='\e[0;39m'
-export DEFAULTBG="\e[0;49m"
+export DEFAULTBG='\e[0;49m'
-export DEFAULTCOL=${DEFAULTBG}${DEFAULTFG}
+export DEFAULTCOL="${DEFAULTBG}${DEFAULTFG}"
+export RESETCOL=$'\e[0m'
 
 # Regular Colors
 export Black='\e[0;30m'
@@ -110,39 +111,50 @@ 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
     "I")
         local heads="[ ${IGreen}info${DEFAULTFG} ]"
         shift
-            [[ -z $QUIET || $QUIET -ne 1 ]] && echo -e "${heads} $@"
+        [[ -z $QUIET || $QUIET -ne 1 ]] && \
+            printf "%b\n" "${heads} $*${RESETCOL}"
         ;;
     "W")
         local heads="[ ${IYellow}Warning${DEFAULTFG} ]"
         shift
-            echo -e "${heads} $@" >&2
+        printf "%b\n" "${heads} $*${RESETCOL}" >&2
         ;;
     "E")
         local heads="[ ${IRed}ERROR${DEFAULTFG} ]"
         shift
-            echo -e "${heads} $@" >&2
+        printf "%b\n" "${heads} $*${RESETCOL}" >&2
         ;;
     "D")
-	    local heads"[ ${ICyan}debug${DEFAULTFG} ]"
+        local heads="[ ${ICyan}debug${DEFAULTFG} ]"
         shift
-	    [[ -n $DEBUG && $DEBUG -gt 1 ]] && echo -e "${heads} $@"
+        [[ -n $DEBUG && $DEBUG -gt 1 ]] && \
+            printf "%b\n" "${heads} $*${RESETCOL}"
         ;;
-        "*")
+    * )
-            local heads=""
+        [[ -z $QUIET || $QUIET -ne 1 ]] && \
-            [[ -z $QUIET || $QUIET -ne 1 ]] && echo -e "$@"
+            printf "%b\n" "$*"
         ;;
     esac
-    unset heads
 }
 export -f disp
+# ------------------------------------------------------------------------------
+
+
+# EOF

profile.d/filefct.sh

@@ -1,3 +1,4 @@
+#!/usr/bin/env bash
 # ------------------------------------------------------------------------------
 # Copyright (c) 2013-2022 Geoffray Levasseur <fatalerrors@geoffray-levasseur.org>
 # Protected by the BSD3 license. Please read bellow for details.
@@ -35,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
@@ -46,63 +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]]
-clean ()
+# 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
+    local recursive=0 force=0 outshell=0
-        case $opt in
-            "-r"|"--recurs")
-                local recursive=1
-                ;;
 
-            "-h"|"--help")
+    # Define short and long options
-                echo "clean: erase backup files in the given directories."
+    local PARSED
-                echo
+    PARSED=$(getopt -o hrsf --long help,recurs,shell,force -n 'clean' -- "$@")
-                echo "Usage: clean [option] [directory1] [...[directoryX]]"
+
-                echo
+    if [[ $? -ne 0 ]]; then
-                echo "Options:"
+        disp E "Invalid options, use \"clean --help\" to display usage."
-                echo "	-h, --help	Display that help screen"
+        return 1
-                echo "	-r, --recurs	Do a recursive cleaning"
+    fi
-                echo "	-f, --force	Do not ask for confirmation (use with care)"
+
-                echo "	-s, --shell	Do nothing and display what will be executed"
+    eval set -- "$PARSED"
-                echo
+
+    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)
-            "-s"|"--shell")
                 local outshell=1
+                shift
                 ;;
-
+            -f|--force)
-            "-f"|"--force")
                 local force=1
+                shift
                 ;;
-
+            --)
-            "-"*)
+                shift
-                disp E "Invalid option, use \"clean --help\" to display usage."
+                break
-                echo
-                return 1
                 ;;
-
             *)
-                local dirlist="$dirlist $opt"
+                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 "#*#" \
+        find "$dir" "${findopt[@]}" -type f \( -name "*~" -o -name "#*#" -o -name "*.bak" -o -name ".~*#" \) -print0 | while IFS= read -r -d '' f; do
-            -o -name "*.bak" -o -name ".~*#")
-        for f in $dellist; do
             if [[ ! $outshell ]]; then
                 rm $rmopt $f
             else
@@ -113,69 +137,98 @@ clean ()
     unset outshell dirlist dellist findopt rmopt
 }
 export -f clean
+# ------------------------------------------------------------------------------
 
 
 # ------------------------------------------------------------------------------
 # Create a directory then goes inside
-# ------------------------------------------------------------------------------
+# Usage: mcd <directory>
-mcd ()
+mcd()
 {
-    if [[ ! $# -eq 1 ]] ; then
+    if [[ "$1" == "-h" || "$1" == "--help" ]]; then
-        disp E "Create a directory then goes inside."
+        printf "mcd: Create a directory and enter it.\n\n"
-        disp E "Usage: mcd <directory>"
+        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 "Missing parameter. Use \"mcd --help\" to display usage."
         return 1
     fi
-    mkdir -pv $1 && cd $1
+    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]
-rmspc ()
+# 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
+    local PARSED
-        case $opt in
+    PARSED=$(getopt -o hr:c::vs --long help,recursive,subst-char::,verbose,shell -n 'rmspc' -- "$@")
-            "-h"|"--help")
+    if [[ $? -ne 0 ]]; then
-                echo "rmspc: remove spaces from all filenames in current directories"
+        disp E "Invalid options, use \"rmspc --help\" to display usage."
-                echo
+        return 1
-                echo "Usage: rmspc [option]"
+    fi
-                echo
+    eval set -- "$PARSED"
-                echo "Options:"
+
-                echo "	-h, --help		Display that help screen"
+    while true; do
-                echo "	-r, --recursive		Treat subdirectories of the given directory"
+        case "$1" in
-                echo "	-c, --subst-char	Change the replacement character (default is underscore)"
+            -h|--help)
-                echo "	-v, --verbose		Display more details (recursive mode only)"
+                printf "rmspc: remove spaces from all filenames in current directories\n\n"
-                echo "	-s, --shell		Do nothing and display commands that would be executed"
+                printf "Usage: rmspc [option]\n\n"
-		echo
+                printf "Options:\n"
-		echo "Note: if the --subst-char option is given without parameters, spaces will be"
+                printf "\t-h, --help\t\tDisplay that help screen\n"
-		echo "      replaced with nothing (concatenation)."
+                printf "\t-r, --recursive\t\tTreat subdirectories of the given directory\n"
-		echo
+                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)
-            "-r"|"--recursive")
                 local recurs=1
+                shift
                 ;;
-
+            -c|--subst-char)
-            "-c"?*|"--subst-char"?*)
+                # Handle optional argument for short/long options
-		if [[ $(echo $opt | grep "=") ]]; then
+                case "$2" in
-                    local substchar=$(echo "$opt" | cut -f 2- -d '=')
+                "")
-		else
+                    substchar=""
-		    local substchar='none'
-		fi
                     ;;
-
+                *)
-	    "-v"|"--verbose")
+                    substchar="$2"
+                    ;;
+                esac
+                shift 2
+                ;;
+            -v|--verbose)
                 local verb=1
+                shift
                 ;;
-
+            -s|--shell)
-            "-s"|"--shell")
                 local shell=1
+                shift
+                ;;
+            --)
+                shift
+                break
                 ;;
-
             *)
                 disp E "Invalid parameter, use \"rmspc --help\" to display options list"
                 echo
@@ -192,9 +245,9 @@ rmspc ()
         [[ $recurs ]] && [[ -d "$f" ]] && (
             [[ $verb ]] && disp I "Entering directory $(pwd)/$f ..."
             local lastdir=$f
-            pushd "$f" > /dev/null
+            pushd "$f" >/dev/null
             rmspc $@
-            popd > /dev/null
+            popd >/dev/null
             [[ $verb ]] && disp I "Leaving directory $(pwd)/$lastdir"
             unset lastdir
         )
@@ -212,3 +265,450 @@ 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 path="." show_all=1 ext_filter="" ext_list="" min_size="" max_size=""
+
+    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|--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"
+
+    # Prepare find filters
+    local find_cmd=(find "$path" -type f)
+
+    # Extension simple
+    if [[ -n "$ext_filter" ]]; then
+        find_cmd+=(-iname "*.$ext_filter")
+    fi
+
+    # Extension liste
+    if [[ -n "$ext_list" ]]; then
+        IFS=',' read -ra exts <<< "$ext_list"
+        find_cmd+=('(')
+        for i in "${!exts[@]}"; do
+            [[ $i -ne 0 ]] && find_cmd+=(-o)
+            find_cmd+=(-iname "*.${exts[$i]}")
+        done
+        find_cmd+=(')')
+    fi
+
+    # Taille min/max (à évaluer en octets)
+    if [[ -n "$min_size" ]]; then
+        find_cmd+=(-size +"$(numfmt --from=iec "$min_size")"c)
+    fi
+    if [[ -n "$max_size" ]]; then
+        find_cmd+=(-size -"$(( $(numfmt --from=iec "$max_size") + 1 ))"c)
+    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" '
+    # Convert function
+    function human_readable(x) {
+        split("B KiB MiB GiB TiB", units)
+        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
+        if (min == "" || $1 < min) min = $1
+        if (max == "" || $1 > max) max = $1
+        if ($1 == 0) bucket[0]++
+        else {
+            b = int(log($1)/log(1024))
+            bucket[b]++
+        }
+    }
+
+    END {
+        count = NR
+        if (count == 0) {
+            print "No files found."
+            exit
+        }
+
+        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
+
+        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 "Statistics for \"%s\"\n", path
+                printf "-------------------------\n"
+            }
+            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 "\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]
+            }
+        }
+    }'
+}
+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

profile.d/fun.sh

@@ -0,0 +1,108 @@
+#!/usr/bin/env bash
+# ------------------------------------------------------------------------------
+# Copyright (c) 2013-2022 Geoffray Levasseur <fatalerrors@geoffray-levasseur.org>
+# Protected by the BSD3 license. Please read bellow for details.
+#
+# * Redistribution and use in source and binary forms,
+# * with or without modification, are permitted provided
+# * that the following conditions are met:
+# *
+# *   Redistributions of source code must retain the above
+# *   copyright notice, this list of conditions and the
+# *   following disclaimer.
+# *
+# *   Redistributions in binary form must reproduce the above
+# *   copyright notice, this list of conditions and the following
+# *   disclaimer in the documentation and/or other materials
+# *   provided with the distribution.
+# *
+# *   Neither the name of the copyright holder nor the names
+# *   of any other contributors may be used to endorse or
+# *   promote products derived from this software without
+# *   specific prior written permission.
+# *
+# * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+# * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+# * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+# * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+# * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+# * OF SUCH DAMAGE.
+# ------------------------------------------------------------------------------
+
+# ------------------------------------------------------------------------------
+# 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" 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
+                ;;
+            *)
+                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
+}
+# ------------------------------------------------------------------------------
+
+
+# EOF

profile.d/help.sh

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

profile.d/info.sh

@@ -1,3 +1,4 @@
+#!/bin/bash
 # ------------------------------------------------------------------------------
 # Copyright (c) 2013-2022 Geoffray Levasseur <fatalerrors@geoffray-levasseur.org>
 # Protected by the BSD3 license. Please read bellow for details.
@@ -35,56 +36,144 @@
 
 # ------------------------------------------------------------------------------
 # Show profile version
-# ------------------------------------------------------------------------------
+# Usage: ver
-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"
+    while true; do
+        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
+    done
+
+    [[ -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 ()
+meteo()
 {
-    cities=$@
+    local PARSED=$(getopt -o h --long help -n 'meteo' -- "$@")
-    [[ $# -eq 0 ]] && local cities=$DEFAULT_CITY
+    if [[ $? -ne 0 ]]; then
+        disp E "Invalid options, use \"meteo --help\" to display usage."
+        return 1
+    fi
+    eval set -- "$PARSED"
+    while true; do
+        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
+    done
 
-    for city in $cities; do
+    local cities=("$@")
-        curl https://wttr.in/$city || disp E "Failed fetching datas for $city."
+    [[ $# -eq 0 ]] && cities=("$DEFAULT_CITY")
+
+    for city in "${cities[@]}"; do
+        encoded=$(urlencode "$city")
+        curl -s "https://wttr.in/$encoded" || \
+            disp E "Failed fetching datas for $city."
     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"
+    while true; do
+        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
+    done
+
+    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"
         fi
-	figlet -k $(hostname) $figopt
+        if [[ -n $figopt ]]; then
+            figlet -k $figopt $(hostname)
         else
-	echo "$(hostname -f)"
+            figlet $(hostname)
+        fi
+    else
+        hostname -f
     fi
     echo ""
     if command -v neofetch >/dev/null 2>&1; then
         neofetch
+    elif command -v fastfetch >/dev/null 2>&1; then
+        fastfetch
     else
         (
             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)"
+            printf "Uptime: $(uptime -p)\n"
         )
     fi
 }
 export -f showinfo
+# ------------------------------------------------------------------------------
+
+
+load_conf info
+# EOF

profile.d/lang.sh

@@ -1,3 +1,4 @@
+#!/bin/bash
 # ------------------------------------------------------------------------------
 # Copyright (c) 2013-2022 Geoffray Levasseur <fatalerrors@geoffray-levasseur.org>
 # Protected by the BSD3 license. Please read bellow for details.
@@ -33,38 +34,102 @@
 # * OF SUCH DAMAGE.
 # ------------------------------------------------------------------------------
 
-# ------------------------------------------------------------------------------
+locale_check()
-# Change locale to French
-# ------------------------------------------------------------------------------
-setfr ()
 {
-    # Set fr locale definitions
+    locale -a | grep -qx "$1" || {
-    export LANG=fr_FR.UTF-8
+        disp W "Locale '$1' is not installed on this system."
-    export LC_MESSAGES=fr_FR.UTF-8
+        return 1
-    export LC_ALL=fr_FR.UTF-8
+    }
+    return 0
 }
-export -f setfr
+
 
 # ------------------------------------------------------------------------------
-# Change locale to C standard
+# 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"
+    while true; do
+        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
+    done
+
+    local loc=$1
+    [[ -z $loc ]] && disp E "No locale specified." && return 1
+
+    locale_check "$loc" || return 1
+
+    export LANG=$loc
+    export LC_MESSAGES=$loc
+    export LC_TIME=$loc
+    export LC_NUMERIC=$loc
+    export LC_MONETARY=$loc
+    export LC_COLLATE=$loc
+    export LC_CTYPE=$loc
+
+    disp I "Locale set to $loc."
+}
+export -f setlocale
 # ------------------------------------------------------------------------------
-setc ()
+
+
+# ------------------------------------------------------------------------------
+# Special case : change locale to C standard
+# Usage: setc
+setc()
 {
     # Locale definitions
-    export LANG=C
-    export LC_MESSAGES=C
     export LC_ALL=C
+    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 ()
+setus()
 {
-    # Locale definitions
+    setlocale "en_US.UTF-8"
-    export LANG=en_US.UTF-8
-    export LC_MESSAGES=en_US.UTF-8
-    export LC_ALL=en_US.UTF-8
 }
 export -f setus
+# ------------------------------------------------------------------------------
+
+
+# ------------------------------------------------------------------------------
+# EOF

profile.d/net.sh

@@ -1,3 +1,4 @@
+#!/bin/bash
 # ------------------------------------------------------------------------------
 # Copyright (c) 2013-2022 Geoffray Levasseur <fatalerrors@geoffray-levasseur.org>
 # Protected by the BSD3 license. Please read bellow for details.
@@ -35,11 +36,12 @@
 
 # ------------------------------------------------------------------------------
 # Determine if parameter is a valid IPv4 address
-# ------------------------------------------------------------------------------
+# Usage: isipv4 <ip_address>
-isipv4 ()
+isipv4()
 {
     # Set up local variables
     local ip=$1
+    [[ -z $ip ]] && return 1
 
     # Start with a regex format test
     if [[ $ip =~ ^[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}$ ]]; then
@@ -47,8 +49,8 @@ isipv4 ()
         IFS="."
         ip=($ip)
         IFS=$old_ifs
-	if [[ ${ip[0]} -le 255 && ${ip[1]} -le 255 \
+        if [[ ${ip[0]} -le 255 && ${ip[1]} -le 255 &&
-		  && ${ip[2]} -le 255 && ${ip[3]} -le 255 ]]; then
+            ${ip[2]} -le 255 && ${ip[3]} -le 255 ]]; then
             if [[ -t 1 ]]; then
                 disp "The given IPv4 is valid."
             fi
@@ -61,12 +63,13 @@ isipv4 ()
     return 1
 }
 export -f isipv4
+# ------------------------------------------------------------------------------
 
 
 # ------------------------------------------------------------------------------
 # Determine if parameter is a valid IPv4 address
-# ------------------------------------------------------------------------------
+# Usage: isipv6 <ip_address>
-isipv6 ()
+isipv6()
 {
     local ip="$1"
     local regex='^([0-9a-fA-F]{0,4}:){1,7}[0-9a-fA-F]{0,4}$'
@@ -82,3 +85,111 @@ 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="$*"
+    local length="${#str}"
+    for (( i = 0; i < length; i++ )); do
+        local c="${str:i:1}"
+        case "$c" in
+            [a-zA-Z0-9.~_-]) printf "$c" ;;
+            ' ') printf '+' ;;
+            *) printf '%%%02X' "'$c" #| cut -d' ' -f2 ;;
+        esac
+    done
+}
+export -f urlencode
+# ------------------------------------------------------------------------------
+
+
+# ------------------------------------------------------------------------------
+# Fetch and display external IP information
+# Usage: myextip [-i|--ip] [-s|--isp] [-l|--loc] [-c|--coord]
+# If no option is provided, all information will be displayed.
+# Options:
+#   -i, --ip      Display only the external IP address
+#   -s, --isp     Display only the ISP name
+#   -l, --loc     Display only the location (city, region, country)
+#   -c, --coord   Display only the coordinates (latitude, longitude)
+myextip() {
+    local show_ip=false show_isp=false show_loc=false show_coord=false
+    local all=true
+
+    # Parse arguments
+    while [[ "$#" -gt 0 ]]; do
+        case "$1" in
+            -i|--ip)
+                show_ip=true
+                all=false
+                ;;
+            -s|--isp)
+                show_isp=true
+                all=false
+                ;;
+            -l|--loc)
+                show_loc=true
+                all=false
+                ;;
+            -c|--coord)
+                show_coord=true
+                all=false
+                ;;
+            -a|--as)
+                show_as=true
+                all=false
+                ;;
+            -h|--help)
+                printf "Usage: myextip [-i|--ip] [-s|--isp] [-l|--loc] [-c|--coord] [-a|--as]\n"
+                printf "Fetch and display external IP information.\n\n"
+                printf "Options:\n"
+                printf "  -i, --ip      Display only the external IP address\n"
+                printf "  -s, --isp     Display only the ISP name\n"
+                printf "  -l, --loc     Display only the location (city, region, country)\n"
+                printf "  -c, --coord   Display only the coordinates (latitude, longitude)\n"
+                printf "  -a, --as      Display only the Autonomous System (AS) information\n"
+                return 0
+                ;;
+            --)
+                shift
+                break
+                ;;
+            *)
+                disp E "Unknown option: $1"
+                return 1
+                ;;
+        esac
+        shift
+    done
+
+    # Fetch data
+    local response
+    response=$(curl -s http://ip-api.com/json/)
+
+    # Parse with jq
+    if command -v jq >/dev/null 2>&1; then
+        echo "$response" | jq -r --argjson all "$all" --argjson ip "$show_ip" \
+          --argjson isp "$show_isp" --argjson loc "$show_loc" \
+          --argjson coord "$show_coord" --argjson as "$show_as" '
+            [
+                (if $all or $ip then "IP Address : \(.query)" else empty end),
+                (if $all or $isp then "ISP        : \(.isp)" else empty end),
+                (if $all or $loc then "Location   : \(.city), \(.regionName), \(.country)" else empty end),
+                (if $all or $coord then "Coordinates: \(.lat), \(.lon)" else empty end),
+                (if $all or $as then "AS         : \(.as)" else empty end)
+            ] | .[]'
+    else
+        echo "$response"
+    fi
+}
+export -f myextip
+# ------------------------------------------------------------------------------
+
+
+# ------------------------------------------------------------------------------
+# EOF

profile.d/packages.sh

@@ -1,3 +1,4 @@
+#!/bin/bash
 # ------------------------------------------------------------------------------
 # Copyright (c) 2013-2022 Geoffray Levasseur <fatalerrors@geoffray-levasseur.org>
 # Protected by the BSD3 license. Please read bellow for details.
@@ -35,46 +36,64 @@
 
 # ------------------------------------------------------------------------------
 # Look for a package within installed one
-# ------------------------------------------------------------------------------
+# Usage: dpkgs <string>
-dpkgs ()
+pkgs()
 {
-    local count=0
+    local ignore_case=0
-    for opt in $@ ; do
+
-        case $opt in
+    local PARSED
-            "-h"|"--help")
+    PARSED=$(getopt -o hi --long help,ignore-case -n 'pkgs' -- "$@")
-                echo "dpkgs: look for an installed package by it's name."
+    if [[ $? -ne 0 ]]; then
-                echo
+        disp E "Invalid options, use \"pkgs --help\" to display usage."
-                echo "Usage: dpkgs <string>"
+        return 1
+    fi
+    eval set -- "$PARSED"
+
+    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
-                disp E "Invalid option, use \"dpkgs --help\" to display usage."
+                shift
-                echo
+                ;;
-                return 1
+            --)
+                shift
+                break
                 ;;
-
             *)
-                local pkg=$1 && shift
+                disp E "Invalid option: $1"
-                count=$(( $count + 1 ))
-                [[ $count -gt 1 ]] &&
-                    disp E "Please specify a package name, without space, eventually partial." &&
                 return 1
-
                 ;;
         esac
     done
-    [[ $count -lt 1 ]] &&
-        disp E "Please specify a package name, without space, eventually partial." &&
-        return 1
 
-    if [[ $(command -v dpkg >/dev/null 2>&1) ]]; then
+    local pkg="$1"
-	dpkg -l | grep $pkg
+    [[ -z "$pkg" ]] && {
-    elif [[ $(command -v rpm >/dev/null 2>&1) ]]; then
+        disp E "Please specify a package name, without space, eventually partial."
-	rpm -qa | grep $pkg
+        return 1
-    else
+    }
+
+    # 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"
+    if [[ -z $cmd ]]; then
         disp E "No usable package manager seems unavialable."
         return 2
     fi
+    $cmd | grep $grep_opt $pkg
 }
-export -f dpkgs
+export -f pkgs
+# ------------------------------------------------------------------------------
+
+
+# EOF

profile.d/processes.sh

@@ -1,3 +1,4 @@
+#!/bin/bash
 # ------------------------------------------------------------------------------
 # Copyright (c) 2013-2022 Geoffray Levasseur <fatalerrors@geoffray-levasseur.org>
 # Protected by the BSD3 license. Please read bellow for details.
@@ -35,19 +36,93 @@
 
 # ------------------------------------------------------------------------------
 # Search processes matching the given string
-# ------------------------------------------------------------------------------
+# Usage: ppg <string>
-ppg ()
+ppg()
 {
-    ps -edf | grep $@ | grep -v "grep $@"
+    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
+    fi
+
+    # -u lists processes for a specific user
+    # -o provides a clean, standard output format
+    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
+    fi
+
+    # -e: select all processes
+    # -o: specify custom output columns (PID and Command name)
+    # grep -w: ensures exact word matching so 'bash' doesn't match 'dbash'
+    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 ()
+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
@@ -61,15 +136,65 @@ gpid ()
     [[ $result ]] || return 1
 }
 export -f gpid
+# ------------------------------------------------------------------------------
 
 
 # ------------------------------------------------------------------------------
-# Kill all processes owned by the given users
+# Kill all processes owned by the given users (kill user)
-# ------------------------------------------------------------------------------
+# Usage: ku <username1 [username2 ...]>
-ku ()
+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
+        killall -u "$u"
     done
 }
 export -f ku
+# ------------------------------------------------------------------------------
+
+
+# ------------------------------------------------------------------------------
+# Kill all children of a process then the process (kill tree)
+# Usage: kt <pid> [kill_options]
+kt()
+{
+    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" "$@" || break
+    done
+    kill "$@" "$parent_pid"
+}
+# ------------------------------------------------------------------------------
+
+
+# EOF

profile.d/prompt.sh

@@ -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
+    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,23 +83,26 @@ function timer_stop
 }
 
 # ------------------------------------------------------------------------------
-# Function triguered internaly by bash : defining prompt
+# Function triggered internally by bash : defining prompt
-# ------------------------------------------------------------------------------
+# Usage: set_prompt
-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()
 {
-    Last_Command=$? # Must come first!
+    local Last_Command=$? # Must come first!
-    Blue='\[\e[0;34m\]'
+    local Blue='\[\e[0;34m\]'
-    White='\[\e[01;37m\]'
+    local White='\[\e[01;37m\]'
-    Yellow='\[\e[01;93m\]'
+    local Yellow='\[\e[01;93m\]'
-    Red='\[\e[01;31m\]'
+    local Red='\[\e[01;31m\]'
-    Green='\[\e[01;32m\]'
+    local Green='\[\e[01;32m\]'
-    OnGrey='\[\e[47m\]'
+    local OnGrey='\[\e[47m\]'
-    OnRed='\[\e[41m\]'
+    local OnRed='\[\e[41m\]'
-    OnBlue='\[\e[44m\]'
+    local OnBlue='\[\e[44m\]'
-    ICyan='\[\e[0;96m\]'
+    local ICyan='\[\e[0;96m\]'
-    Default='\[\e[00m\]'
+    local Default='\[\e[00m\]'
-    FancyX='\342\234\227'
+    local FancyX='\342\234\227'
-    Checkmark='\342\234\223'
+    local Checkmark='\342\234\223'
 
     # Begin with time
     PS1="\[\e[s$Blue$OnGrey [ \t ] $OnBlue"
@@ -123,3 +135,7 @@ set_prompt ()
     # the text color to the default.
     PS1+="$ICyan\\w \\\$$Default "
 }
+# ------------------------------------------------------------------------------
+
+
+# EOF

profile.d/pwd.sh

@@ -1,3 +1,4 @@
+#!/usr/bin/env bash
 # ------------------------------------------------------------------------------
 # Copyright (c) 2013-2022 Geoffray Levasseur <fatalerrors@geoffray-levasseur.org>
 # Protected by the BSD3 license. Please read bellow for details.
@@ -35,98 +36,110 @@
 
 # ------------------------------------------------------------------------------
 # 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
     local occurs=2 # Bug, if set to 1, seems to be ignored
     local symb=1 maj=1 min=1 numb=1
     local nbpwd=1
+    local extcar
 
-    for opt in $@; do
+local PARSED
-	case $opt in
+    PARSED=$(getopt -o hsnu l e:L:o: --long \
-	    "-h"|"--help")
+        help,nosymbols,nonumbers,noup,nolow,extracars:,length:,occurences: -n 'genpwd' -- "$@")
-		echo "genpwd: generate one or more secure random password."
+    if [[ $? -ne 0 ]]; then return 1; fi
-		echo
+    eval set -- "$PARSED"
-		echo "Usage: genpwd [options] [--extracars=<cars>] [--length=<n>] [nb_passwd]"
+
-		echo
+    while true; do
-		echo "Options:"
+        case "$1" in
-		echo "	-h, --help	Display that help screen"
+            -h|--help)
-		echo "	-s, --nosymbols	Exclude symbols"
+                printf "genpwd: Generate secure random password(s).\n\n"
-		echo "	-n, --nonumbers	Exclude numbers"
+                printf "Usage: genpwd [options] [nb_passwd]\n\n"
-		echo "	-u, --noup	Exclude uppercase letters"
+                printf "Options:\n"
-		echo "	-l, --nolow	Exclude lowercase letters"
+                printf "\t-h, --help\t\tDisplay this help screen\n"
-		echo "	-e=<c>, --extracars=<c>"
+                printf "\t-s, --nosymbols\t\tExclude symbols\n"
-		echo "			Add the given caracters to the possible caracter list"
+                printf "\t-n, --nonumbers\t\tExclude numbers\n"
-		echo "	-L=<n>, --length=<n>"
+                printf "\t-u, --noup\t\tExclude uppercase letters\n"
-		echo "			Set length of the password (default is $length)"
+                printf "\t-l, --nolow\t\tExclude lowercase letters\n"
-		echo "	-o=<n>, --occurences=<n>"
+                printf "\t-e, --extracars <c>\tAdd characters to list\n"
-		echo "			Set the maximum occurences of a same caracter (default is $occurs)"
+                printf "\t-L, --length <n>\tSet password length (default: 16)\n"
-		echo
+                printf "\t-o, --occurences <n>\tMax occurences per character (default: 2)\n"
-		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")
+            -s|--nosymbols)
                 symb=0
+                shift
                 ;;
-	    "-n"|"--nonumbers")
+            -n|--nonumbers)
                 numb=0
+                shift
                 ;;
-	    "-u"|"--noup")
+            -u|--noup)
                 maj=0
+                shift
                 ;;
-	    "-l"|"--nolow")
+            -l|--nolow)
                 min=0
+                shift
                 ;;
-	    "-e"?*|"--extracars"?*)
+            -e|--extracars)
-		local extcar=$(echo "$opt" | cut -f 2- -d '=')
+                extcar="$2"
+                shift 2
                 ;;
-	    "-L"?*|"--length"?*)
+            -L|--length)
-		local length=$(echo "$opt" | cut -f 2- -d '=')
+                length="$2"
                 if ! [[ $length =~ ^[0-9]+$ ]]; then
                     disp E "The --length parameter requires a number."
                     return 1
                 fi
+                shift 2
                 ;;
-	    "-o"?*|"--occurences"?*)
+            -o|--occurences)
-		local occurs=$(echo "$opt" | cut -f 2- -d '=')
+                occurs="$2"
                 if ! [[ $occurs =~ ^[1-9]+$ ]]; then
                     disp E "The --occurs parameter requires a number from 1 to 9."
                     return 1
                 fi
+                shift 2
                 ;;
-	    "-*")
+            --)
-		disp E "Unknow parameter ${opt}."
+                shift; break
-		return 1
                 ;;
             *)
-		if ! [[ $opt =~ ^[1-9]+$ ]]; then
+                break
-		    disp E "Unknow parameter ${opt}."
-		    return 1
-		else
-		    local nbpwd=$opt
-		fi
                 ;;
         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()
+    pickcar() {
-    {
         # When a character is picked we check if it's not appearing already twice
         # elsewhere, we choose an other char, to compensate weak bash randomizer
         while [[ -z $char ]]; do
-	    local char=$(echo ${1:RANDOM%${#1}:1} $RANDOM)
+            local char="${1:RANDOM%${#1}:1} $RANDOM"
-	    if [[ $(awk -F"$char" '{print NF-1}' <<< "$picked") -gt $occurs ]]; then
+            if [[ $(awk -F"$char" '{print NF-1}' <<<"$picked") -gt $occurs ]]; then
                 unset char
             fi
         done
@@ -135,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
@@ -145,27 +158,27 @@ genpwd()
             if [[ $symb == 1 ]]; then
                 pickcar '!.@#&%/^-_'
                 carset+='!.@#&%/^-_'
-		(( rlength++ ))
+                ((rlength++))
             fi
             if [[ $numb == 1 ]]; then
                 pickcar '0123456789'
                 carset+='0123456789'
-		(( rlength++ ))
+                ((rlength++))
             fi
             if [[ $maj == 1 ]]; then
                 pickcar 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
                 carset+='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
-		(( rlength++ ))
+                ((rlength++))
             fi
             if [[ $min == 1 ]]; then
                 pickcar 'abcdefghijklmnopqrstuvwxyz'
                 carset+='abcdefghijklmnopqrstuvwxyz'
-		(( rlength++ ))
+                ((rlength++))
             fi
             if [[ -n $extcar ]]; then
                 pickcar "$extcar"
                 carset+=$extcar
-		(( rlength++ ))
+                ((rlength++))
             fi
 
             # Check if we have enough car to have something viable
@@ -175,7 +188,7 @@ genpwd()
                 return 1
             fi
 
-	    for i in $( seq 1 $(( $length - $rlength )) ); do
+            for i in $(seq 1 $(($length - $rlength))); do
                 pickcar "$carset"
             done
         } | sort -R | awk '{printf "%s", $1}'
@@ -184,3 +197,7 @@ genpwd()
     done
 }
 export -f genpwd
+# ------------------------------------------------------------------------------
+
+
+# EOF

profile.d/rain.sh

@@ -1,3 +1,4 @@
+#!/usr/bin/env bash
 # ------------------------------------------------------------------------------
 # Copyright (c) 2013-2022 Geoffray Levasseur <fatalerrors@geoffray-levasseur.org>
 # Protected by the BSD3 license. Please read bellow for details.
@@ -35,37 +36,110 @@
 
 # ------------------------------------------------------------------------------
 # 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() {
+        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
+    local base_color="white" # default color scheme, can be overridden by --color
+
+    # Analyse arguments
+    while [[ "$#" -gt 0 ]]; do
+        case $1 in
+            -s|--speed)
+                if [[ -n "$2" && ! "$2" =~ ^- ]]; then
+                    step_duration="$2"; shift
+                else
+                    disp E "--speed requires a numeric value."
+                    show_usage && return 1
+                fi
+                ;;
+            -c|--color)
+                if [[ -n "$2" && ! "$2" =~ ^- ]]; then
+                    base_color="$2"; shift
+                else
+                    disp E "--color requires a color name."
+                    show_usage && return 1
+                fi
+                ;;
+            -h|--help)
+                show_usage && return 0
+                ;;
+            *)
+                disp E "Unknown option: $1"
+                show_usage && return 1
+                ;;
+        esac
+        shift
+    done
+
+    # Define colors (256-colors gradients)
+    local rain_colors=()
+    case $base_color in
+        green)  # Matrix style green
+            for i in {22..28} {34..40} {46..48}; do rain_colors+=("\e[38;5;${i}m"); done ;;
+        blue)   # Deep ocean blues
+            for i in {17..21} {27..33} {39..45}; do rain_colors+=("\e[38;5;${i}m"); done ;;
+        red)    # Crimson / blood red
+            for i in {52..52} {88..88} {124..124} {160..160} {196..201}; do rain_colors+=("\e[38;5;${i}m"); done ;;
+        yellow) # Amber / gold
+            for i in {58..58} {100..100} {142..142} {184..184} {226..229}; do rain_colors+=("\e[38;5;${i}m"); done ;;
+        cyan)   # Electric cyan / turquoise
+            for i in {30..31} {37..38} {44..45} {50..51}; do rain_colors+=("\e[38;5;${i}m"); done ;;
+        *)      # Greyscale / white (original style)
+            rain_colors=("\e[37m" "\e[37;1m")
+            for i in {244..255}; do rain_colors+=("\e[38;5;${i}m"); done ;;
+    esac
+
     local exit_st=0
     local rain_cars=("|" "│" "┃" "┆" "┇" "┊" "┋" "╽" "╿")
-    local rain_colors=("\e[37m" "\e[37;1m")
-    # More from 256 color mode
-    for i in {244..255}; do
-        rain_colors=( "${rain_colors[@]}" "\e[38;5;${i}m" )
-    done
     local rain_tab=${#rain_cars[@]}
     local rain_color_tab=${#rain_colors[@]}
     local num_rain_metadata=5
     local term_height=$(tput lines)
     local term_width=$(tput cols)
-    local step_duration=0.050
     local X=0 Y=0 drop_length=0 rain_drop=0
     local max_rain_width=0 new_rain_odd=0 falling_odd=0
 
-
     sigwinch() {
         term_width=$(tput cols)
         term_height=$(tput lines)
         #step_duration=0.025
-        (( max_rain_width = term_width * term_height / 4 ))
+        ((max_rain_width = term_width * term_height / 4))
-        (( max_rain_height = term_height < 10 ? 1 : term_height / 10 ))
+        ((max_rain_height = term_height < 10 ? 1 : term_height / 10))
         # In percentage
-        (( new_rain_odd = term_height > 50 ? 100 : term_height * 2 ))
+        ((new_rain_odd = term_height > 50 ? 100 : term_height * 2))
-        (( new_rain_odd = new_rain_odd * 75 / 100 ))
+        ((new_rain_odd = new_rain_odd * 75 / 100))
-        (( falling_odd = term_height > 25 ? 100 : term_height * 4 ))
+        ((falling_odd = term_height > 25 ? 100 : term_height * 4))
-        (( falling_odd = falling_odd * 90 / 100 ))
+        ((falling_odd = falling_odd * 90 / 100))
     }
 
     do_exit() {
@@ -80,19 +154,19 @@ rain()
             Y=${rains[idx + 1]}
             drop_length=${rains[idx + 4]}
             for ((y = Y; y < Y + drop_length; y++)); do
-                (( y < 1 || y > term_height )) && continue
+                ((y < 1 || y > term_height)) && continue
                 echo -ne "\e[${y};${X}H "
             done
         done
 
         for ((idx = 0; idx < num_rains * num_rain_metadata; idx += num_rain_metadata)); do
-            if (( 100 * RANDOM / 32768 < falling_odd )); then
+            if ((100 * RANDOM / 32768 < falling_odd)); then
                 # Falling
-                if (( ++rains[idx + 1] > term_height )); then
+                if ((++rains[idx + 1] > term_height)); then
                     # Out of screen, bye sweet <3
                     rains=("${rains[@]:0:idx}"
                         "${rains[@]:idx+num_rain_metadata:num_rains*num_rain_metadata}")
-                    (( num_rains-- ))
+                    ((num_rains--))
                     continue
                 fi
             fi
@@ -102,8 +176,8 @@ rain()
             drop_color=${rains[idx + 3]}
             drop_length=${rains[idx + 4]}
             for ((y = Y; y < Y + drop_length; y++)); do
-                (( y < 1 || y > term_height )) && continue
+                ((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
     }
@@ -112,30 +186,30 @@ 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
-    while (( exit_st <= 0 )); do
+    while ((exit_st <= 0)); do
-        if (( $exit_st <=0 )); then
+        if (($exit_st <= 0)); then
             read -n 1 -t $step_duration ch
             case "$ch" in
-                q|Q)
+            q | Q)
                 do_exit
                 ;;
             esac
 
-            if (( num_rains < max_rain_width )) && (( 100 * RANDOM / 32768 < new_rain_odd )); then
+            if ((num_rains < max_rain_width)) && ((100 * RANDOM / 32768 < new_rain_odd)); then
                 # Need new |, 1-based
                 rain_drop="${rain_cars[rain_tab * RANDOM / 32768]}"
                 drop_color="${rain_colors[rain_color_tab * RANDOM / 32768]}"
-                drop_length=$(( max_rain_height * RANDOM / 32768 + 1 ))
+                drop_length=$((max_rain_height * RANDOM / 32768 + 1))
-                X=$(( term_width * RANDOM / 32768 + 1 ))
+                X=$((term_width * RANDOM / 32768 + 1))
-                Y=$(( 1 - drop_length ))
+                Y=$((1 - drop_length))
-                rains=( "${rains[@]}" "$X" "$Y" "$rain_drop" "$drop_color" "$drop_length" )
+                rains=("${rains[@]}" "$X" "$Y" "$rain_drop" "$drop_color" "$drop_length")
-                (( num_rains++ ))
+                ((num_rains++))
             fi
 
             # Let rain fall!
@@ -152,3 +226,6 @@ rain()
     trap - WINCH
 }
 export -f rain
+
+# ------------------------------------------------------------------------------
+# EOF

profile.d/ssh.sh

@@ -1,3 +1,4 @@
+#!/usr/bin/env bash
 # ------------------------------------------------------------------------------
 # Copyright (c) 2013-2022 Geoffray Levasseur <fatalerrors@geoffray-levasseur.org>
 # Protected by the BSD3 license. Please read bellow for details.
@@ -35,20 +36,45 @@
 
 # ------------------------------------------------------------------------------
 # Remove host from know_host (name and IP) for the active user
-# ------------------------------------------------------------------------------
+# Usage: rmhost <hostname|ip> [hostname2|ip2 [...]]
-rmhost ()
+rmhost()
 {
-    if [[ "$#" -lt 1 ]]; then
+    local PARSED
-        disp E "Incorrect number of parameters."
+    PARSED=$(getopt -o h --long help -n 'rmhost' -- "$@")
-        disp E "Usage: rmhost <hostname|ip> [hostname2|ip2 [...]]"
+    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
+    for target in "$@"; do
-	local hst=$1 && shift
+        local hst=$target
-	isipv4 $hst > /dev/null
+        isipv4 "$hst" >/dev/null
         local v4=$?
-	isipv6 $hst > /dev/null
+        isipv6 "$hst" >/dev/null
         local v6=$?
 
         if [[ $v4 -eq 0 || $v6 -eq 0 ]]; then
@@ -58,48 +84,76 @@ rmhost ()
         unset v4 v6
 
         if [[ ! $ip && $hst ]]; then
-	    ip=$(host $hst | grep "has address" | awk '{print $NF}')
+            if ! ip=$(host "$hst" 2>/dev/null | awk '/has address/ {print $NF; exit}'); then
-	    [[ ! $? ]] &&
                 disp E "Impossible to extract IP from hostname." &&
                 return 1
             fi
+            [[ -z $ip ]] && {
+                disp E "Impossible to extract IP from hostname."
+                return 1;
+            }
+        fi
 
         if [[ $hst ]]; then
             disp I "Removing host $hst from ssh known_host..."
-	    ssh-keygen -R $hst > /dev/null
+            ssh-keygen -R $hst >/dev/null
         fi
         if [[ $ip ]]; then
             disp I "Removing IP $ip from ssh known_host..."
-	    ssh-keygen -R $ip > /dev/null
+            ssh-keygen -R $ip >/dev/null
         fi
         unset hst ip
     done
 }
 export -f rmhost
+# ------------------------------------------------------------------------------
 
 
 # ------------------------------------------------------------------------------
 # Login root via SSH on the given machine
-# ------------------------------------------------------------------------------
+# Usage: ssr <server [ssh options]>
-ssr ()
+ssr()
 {
-    for opt in $@ ; do
+    local PARSED
-        case $opt in
+    PARSED=$(getopt -o h --long help -n 'ssr' -- "$@")
-            "-h"|"--help")
+    if [[ $? -ne 0 ]]; then return 1; fi
-                echo "ssr: do a root user ssh login."
+    eval set -- "$PARSED"
-                echo
+
-                echo "Usage: ssr <server [ssh options]>"
+    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
 
-    [[ ! $1 ]] &&
+    command -v ssh >/dev/null 2>&1 || {
-        disp E "Please specify the server you want to log in." &&
+        disp E "ssh is not installed."
+        return 127
+    }
+    [[ ! $1 ]] && {
+        disp E "Please specify the server you want to log in."
         return 1
+    }
 
     local srv=$1 && shift
 
-    ssh -Y root@$srv $@
+    ssh -Y root@"$srv" "$@"
 }
 export -f ssr
+# ------------------------------------------------------------------------------
+
+
+# EOF

profile.d/updates.sh

@@ -0,0 +1,188 @@
+#!/usr/bin/env bash
+# ------------------------------------------------------------------------------
+# Copyright (c) 2013-2022 Geoffray Levasseur <fatalerrors@geoffray-levasseur.org>
+# Protected by the BSD3 license. Please read bellow for details.
+#
+# * Redistribution and use in source and binary forms,
+# * with or without modification, are permitted provided
+# * that the following conditions are met:
+# *
+# *   Redistributions of source code must retain the above
+# *   copyright notice, this list of conditions and the
+# *   following disclaimer.
+# *
+# *   Redistributions in binary form must reproduce the above
+# *   copyright notice, this list of conditions and the following
+# *   disclaimer in the documentation and/or other materials
+# *   provided with the distribution.
+# *
+# *   Neither the name of the copyright holder nor the names
+# *   of any other contributors may be used to endorse or
+# *   promote products derived from this software without
+# *   specific prior written permission.
+# *
+# * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+# * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+# * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+# * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+# * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+# * OF SUCH DAMAGE.
+# ------------------------------------------------------------------------------
+
+export BASE_URL="https://git.geoffray-levasseur.org/fatalerrors/profile"
+export UPDT_URL="$BASE_URL/raw/branch/master"
+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()
+{
+    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
+    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!"
+        return 5
+    }
+
+    if [[ -s $vfile ]]; then
+        local lastver=$(cat $vfile)
+        if [[ $lastver != $PROFVERSION ]]; then
+            disp I "You have version $PROFVERSION installed. Version $lastver is available."
+            (( $quiet != 1 )) && disp I "You should upgrade to last version when possible."
+            result=1
+        else
+            (( $quiet != 1 )) && disp I "Your version is up-to-date."
+            result=0
+        fi
+        rm -f $vfile
+    else
+        disp E "Impossible to read temporary file, impossible to proceed."
+    fi
+    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
+    fi
+
+    if [[ -s $MYPATH/profile.sh ]]; then
+        disp E "Installation path detection failed, cannot upgrade automatically."
+        return 1
+    fi
+
+    if [[ -d $MYPATH/.git ]]; then
+        disp I "Git installation detected, applying git pull."
+        local curdir=$(pwd)
+        cd $MYPATH
+        git pull || {
+            disp E "Git pull failed, upgrade not applyed."
+            cd "$curdir"
+            return 2
+        }
+        disp I "Successfully upgraded using git."
+        cd "$curdir"
+    else
+        disp I "No Git detected. Downloading and applying upgrade from archive..."
+        local tmpdir="/tmp/profile_upg.$$"
+        mkdir -p "$tmpdir" || {
+            disp E "Failed to create temporary directory."
+            return 4
+        }
+
+        local archive="$tmpdir/profile.tar.gz"
+        wget -q "$ARCH_URL" -O "$archive" || {
+            disp E "Failed to download archive."
+            rm -rf "$tmpdir"
+            return 5
+        }
+
+        tar -xzf "$archive" -C "$tmpdir" || {
+            disp E "Archive extraction failed."
+            rm -rf "$tmpdir"
+            return 6
+        }
+
+        disp I "Installing new version..."
+        cp -r "$tmpdir"/profile/* "$MYPATH"/ || {
+            disp E "Failed to copy new files to $MYPATH."
+            rm -rf "$tmpdir"
+            return 7
+        }
+
+        disp I "Upgrade complete. You should now logout and login again."
+        rm -rf "$tmpdir"
+    fi
+}
+# ------------------------------------------------------------------------------
+
+
+# EOF

profile.sh

@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/usr/bin/env bash
 # Begin profile
 # ------------------------------------------------------------------------------
 # Copyright (c) 2013-2022 Geoffray Levasseur <fatalerrors@geoffray-levasseur.org>
@@ -35,46 +35,130 @@
 # * OF SUCH DAMAGE.
 # ------------------------------------------------------------------------------
 
-export PROFVERSION="3.2.3"
+if [[ ! $SHELL =~ bash|zsh ]]; then
-
+    echo "That environment script is designed to be used with bash or zsh being the shell."
-export DEFAULT_CITY="Toulouse"
-
-if [[ ! $(echo $SHELL | grep bash) ]]; then
-    echo "That environmet script is designed to be used with bash or zsh being the shell."
     echo "Please consider using bash or zsh instead, or patch me ;)!"
     return 1
 fi
 
 # ------------------------------------------------------------------------------
 # path* : private functions for PATH variable management
-# ------------------------------------------------------------------------------
+pathremove()
-pathremove ()
 {
-    local ifs=':'
+    local IFS=':'
     local newpath
     local dir
     local pathvar=${2:-PATH}
-    for dir in ${!pathvar} ; do
+    for dir in ${!pathvar}; do
-        if [ "$dir" != "$1" ] ; then
+        if [ "$dir" != "$1" ]; then
             newpath=${newpath:+$newpath:}$dir
         fi
     done
     export $pathvar="$newpath"
 }
 
-pathprepend ()
+pathprepend()
 {
     pathremove $1 $2
     local pathvar=${2:-PATH}
     export $pathvar="$1${!pathvar:+:${!pathvar}}"
 }
 
-pathappend ()
+pathappend()
 {
     pathremove $1 $2
     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
+}
+# ------------------------------------------------------------------------------
 
 
 # ------------------------------------------------------------------------------
@@ -83,40 +167,41 @@ pathappend ()
 # ------------------------------------------------------------------------------
 # ------------------------------------------------------------------------------
 
+# Store script's path (realpath -s resolve symlinks if profile.sh is a symlink)
+if [[ -z "$PROFILE_PATH" ]]; then
+    export MYPATH=$(dirname "$(realpath -s "$0")")
+else
+    export MYPATH="$PROFILE_PATH"
+fi
+if [[ ! -e "$MYPATH/profile.sh" ]]; then
+    echo "[ Warning ] Path detection failed, trying to use pwd..."
+    MYPATH=$(pwd)
+    if [[ ! -e "$MYPATH/profile.sh" ]]; then
+        echo "[ Error ] Impossible to determine installation path, pretty much nothing will work."
+    fi
+fi
+
+if [[ ! -s "$MYPATH/version" ]]; then
+    echo "[ Warning ] Impossible to determine running version of profile, your installation might be broken."
+fi
+export PROFVERSION=$(cat "$MYPATH"/version)
+
 # Build PATH environment variable
-if [[ $EUID -eq 0 ]] ; then
+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
 
-# Set bash history
+# Parse and load general configuration
-export HISTSIZE=50000
+export PROFILE_CONF="$MYPATH/profile.conf"
-export HISTIGNORE="&:[bf]g:exit"
+parse_conf "$PROFILE_CONF"
+load_conf system  # Load Bash system behavior configuration (history, pager, etc.)
+load_conf general # General purpose configuration (compilation flags, etc.)
 
-# Set default pager
+# Load module scripts
-export PAGER=less
+for script in $MYPATH/profile.d/*.sh; do
-
+    if [[ -r $script ]]; then
-# 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 values could be altered after this line
-# ------------------------------------------------------------------------------
-
-# Load personal configuration
-[[ -f ~/.profile.conf ]] && . ~/.profile.conf
-
-# Execute optionnal config script if any
-for script in ~/profile.d/*.sh ; do
-    if [ -r $script ] ; then
         . $script
     fi
 done
@@ -124,34 +209,12 @@ done
 # Interactive shell detection, two methods available each one of those might have different result
 # depending on distribution
 #shopt -q login_shell && INTERACTIVE=1
-[[ $- == *i* ]] && INTERACTIVE=1
+[[ $- == *i* ]] && export INTERACTIVE=1
 
 if [[ $INTERACTIVE ]]; then
     # For compiling (as we often compile with LFS/0linux...)
     #Aliases
-    alias ll='ls -laFh --color=auto'
+    load_alias aliases 
-    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'
 
     # Define PS1
     trap 'timer_start' DEBUG
@@ -159,7 +222,8 @@ if [[ $INTERACTIVE ]]; then
 
     # Set default language
     setfr
-    showinfo
+    showinfo && printf "\n"
+    check_updates -q
     disp I "Profile version $PROFVERSION chargé..."
 fi
 

version

@@ -0,0 +1 @@
+3.95.1-4_beta_1