413 lines
14 KiB
Bash
413 lines
14 KiB
Bash
#!/usr/bin/env bash
|
|
# ------------------------------------------------------------------------------
|
|
# Copyright (c) 2013-2026 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.
|
|
# ------------------------------------------------------------------------------
|
|
|
|
# ------------------------------------------------------------------------------
|
|
# Show profile version
|
|
# Usage: ver
|
|
ver()
|
|
{
|
|
local PARSED
|
|
|
|
PARSED=$(getopt -o h --long help -n 'ver' -- "$@")
|
|
# shellcheck disable=SC2181 # getopt return code is checked immediately after
|
|
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 for the given city (or the default one)
|
|
# Usage: meteo [city1 city2 ...]
|
|
meteo()
|
|
{
|
|
local PARSED
|
|
|
|
PARSED=$(getopt -o h --long help -n 'meteo' -- "$@")
|
|
# shellcheck disable=SC2181 # getopt return code is checked immediately after
|
|
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.\n"
|
|
printf "Usage: meteo [city1 city2 ...]\n"
|
|
printf "If no city is provided, the default city from configuration will be used.\n"
|
|
return 0
|
|
;;
|
|
--)
|
|
shift
|
|
break
|
|
;;
|
|
*)
|
|
disp E "Invalid options, use \"meteo --help\" to display usage."
|
|
return 1
|
|
;;
|
|
esac
|
|
done
|
|
|
|
local cities=("$@")
|
|
local city="" encoded=""
|
|
[[ $# -eq 0 ]] && cities=("${METEO_DEFAULT_CITY:-}")
|
|
|
|
if [[ ${#cities[@]} -eq 0 || -z "${cities[0]}" ]]; then
|
|
disp E "No city given and METEO_DEFAULT_CITY is not set. Use 'meteo <city>'."
|
|
return 1
|
|
fi
|
|
|
|
for city in "${cities[@]}"; do
|
|
encoded=$(urlencode "$city")
|
|
dwl "https://wttr.in/$encoded" || \
|
|
disp E "Failed to fetch weather data for $city."
|
|
done
|
|
}
|
|
export -f meteo
|
|
# ------------------------------------------------------------------------------
|
|
|
|
|
|
# ------------------------------------------------------------------------------
|
|
# Display a system information block using only /proc and /sys — no external tools.
|
|
# Usage: pinfo
|
|
pinfo()
|
|
{
|
|
local _row
|
|
_row() {
|
|
printf " %b%-12s%b %b%s%b\n" "$_lbl" "$1" "$_rst" "$_val" "$2" "$_rst"
|
|
}
|
|
|
|
local PARSED
|
|
PARSED=$(getopt -o h --long help -n 'pinfo' -- "$@")
|
|
# shellcheck disable=SC2181
|
|
if [[ $? -ne 0 ]]; then
|
|
disp E "Invalid options, use \"pinfo --help\" to display usage."
|
|
return 1
|
|
fi
|
|
eval set -- "$PARSED"
|
|
while true; do
|
|
case "$1" in
|
|
-h|--help)
|
|
printf "pinfo: Display system information from /proc and /sys (no external tools required).\n"
|
|
printf "Usage: pinfo\n"
|
|
return 0
|
|
;;
|
|
--)
|
|
shift
|
|
break
|
|
;;
|
|
*)
|
|
disp E "Invalid options, use \"pinfo --help\" to display usage."
|
|
return 1
|
|
;;
|
|
esac
|
|
done
|
|
|
|
# --- Hostname ---
|
|
local hostname_str
|
|
if [[ -r /proc/sys/kernel/hostname ]]; then
|
|
read -r hostname_str < /proc/sys/kernel/hostname
|
|
else
|
|
hostname_str="${HOSTNAME:-unknown}"
|
|
fi
|
|
|
|
# --- OS release (security: parsed line by line, never sourced) ---
|
|
local os_name="Unknown" os_version=""
|
|
if [[ -r /etc/os-release ]]; then
|
|
local _osr_key _osr_val
|
|
while IFS='=' read -r _osr_key _osr_val; do
|
|
_osr_val="${_osr_val//\"/}"
|
|
case "$_osr_key" in
|
|
NAME) os_name="$_osr_val" ;;
|
|
VERSION_ID) os_version="$_osr_val" ;;
|
|
esac
|
|
done < /etc/os-release
|
|
fi
|
|
|
|
# --- Kernel release ---
|
|
local kernel_str="unknown"
|
|
[[ -r /proc/sys/kernel/osrelease ]] && read -r kernel_str < /proc/sys/kernel/osrelease
|
|
|
|
# --- Architecture (set by bash at startup from the ELF interpreter) ---
|
|
local arch_str="${HOSTTYPE:-unknown}"
|
|
|
|
# --- Uptime (seconds from /proc/uptime) ---
|
|
local uptime_str="unknown"
|
|
if [[ -r /proc/uptime ]]; then
|
|
local _upraw
|
|
read -r _upraw _ < /proc/uptime
|
|
local _upsec="${_upraw%%.*}"
|
|
local _days=$(( _upsec / 86400 ))
|
|
local _hours=$(( (_upsec % 86400) / 3600 ))
|
|
local _mins=$(( (_upsec % 3600) / 60 ))
|
|
local _secs=$(( _upsec % 60 ))
|
|
uptime_str=""
|
|
(( _days > 0 )) && uptime_str+="${_days}d "
|
|
(( _hours > 0 || _days > 0 )) && uptime_str+="${_hours}h "
|
|
uptime_str+="${_mins}m ${_secs}s"
|
|
fi
|
|
|
|
# --- Load average ---
|
|
local load_str="unknown"
|
|
if [[ -r /proc/loadavg ]]; then
|
|
local _l1 _l5 _l15
|
|
read -r _l1 _l5 _l15 _ < /proc/loadavg
|
|
load_str="${_l1} ${_l5} ${_l15} (1/5/15 min)"
|
|
fi
|
|
|
|
# --- CPU model and logical/physical core count (pure bash) ---
|
|
local cpu_model="unknown" cpu_threads=0
|
|
local -A _seen_cores=()
|
|
local _cur_phys="" _cpu_line
|
|
if [[ -r /proc/cpuinfo ]]; then
|
|
while IFS= read -r _cpu_line; do
|
|
case "$_cpu_line" in
|
|
"model name"*|"Model name"*|"Hardware"*)
|
|
[[ "$cpu_model" == "unknown" ]] && cpu_model="${_cpu_line#*: }"
|
|
;;
|
|
"processor"*)
|
|
(( cpu_threads++ ))
|
|
;;
|
|
"physical id"*)
|
|
_cur_phys="${_cpu_line#*: }"
|
|
;;
|
|
"core id"*)
|
|
_seen_cores["${_cur_phys}:${_cpu_line#*: }"]=1
|
|
;;
|
|
esac
|
|
done < /proc/cpuinfo
|
|
fi
|
|
local cpu_cores="${#_seen_cores[@]}"
|
|
(( cpu_cores == 0 )) && cpu_cores=$cpu_threads
|
|
|
|
# --- Memory (pure bash, /proc/meminfo, values in kB) ---
|
|
local mem_total=0 mem_available=0 swap_total=0 swap_free=0
|
|
if [[ -r /proc/meminfo ]]; then
|
|
local _mkey _mval _munit
|
|
while read -r _mkey _mval _munit; do
|
|
case "${_mkey%:}" in
|
|
MemTotal) mem_total="$_mval" ;;
|
|
MemAvailable) mem_available="$_mval" ;;
|
|
SwapTotal) swap_total="$_mval" ;;
|
|
SwapFree) swap_free="$_mval" ;;
|
|
esac
|
|
done < /proc/meminfo
|
|
fi
|
|
local mem_total_mib=$(( mem_total / 1024 ))
|
|
local mem_used_mib=$(( (mem_total - mem_available) / 1024 ))
|
|
local swap_total_mib=$(( swap_total / 1024 ))
|
|
local swap_used_mib=$(( (swap_total - swap_free) / 1024 ))
|
|
|
|
# --- Process count (glob over numeric /proc entries) ---
|
|
local proc_count=0 _pdir
|
|
for _pdir in /proc/[0-9]*/; do
|
|
[[ -d "$_pdir" ]] && (( proc_count++ ))
|
|
done
|
|
|
|
# --- Shell and terminal ---
|
|
local shell_str="${BASH:-bash} ${BASH_VERSION%\(*}"
|
|
local term_str="${TERM:-unknown}"
|
|
|
|
# --- GPU (no external tools required; sysfs first, then /proc/bus/pci) ---
|
|
local -a gpu_list=()
|
|
local _gdir _gname _gline
|
|
# Preferred: sysfs drm — each card has a device/vendor+device pair readable
|
|
# without root. The human-readable name comes from the uevent file.
|
|
for _gdir in /sys/class/drm/card[0-9]*/device; do
|
|
[[ -d "$_gdir" ]] || continue
|
|
_gname=""
|
|
# Try uevent: contains PCI_ID and sometimes DRIVER
|
|
if [[ -r "$_gdir/uevent" ]]; then
|
|
local _uev_driver="" _uev_pci=""
|
|
local _uev_line
|
|
while IFS='=' read -r _uev_key _uev_val; do
|
|
case "$_uev_key" in
|
|
DRIVER) _uev_driver="$_uev_val" ;;
|
|
PCI_ID) _uev_pci="$_uev_val" ;;
|
|
esac
|
|
done < "$_gdir/uevent"
|
|
[[ -n "$_uev_pci" ]] && _gname="PCI ${_uev_pci}"
|
|
[[ -n "$_uev_driver" ]] && _gname+=" (${_uev_driver})"
|
|
fi
|
|
# Better: label file written by driver (e.g. amdgpu, i915)
|
|
if [[ -r "$_gdir/label" ]]; then
|
|
read -r _gname < "$_gdir/label"
|
|
elif [[ -r "$_gdir/../label" ]]; then
|
|
read -r _gname < "$_gdir/../label"
|
|
fi
|
|
# Better still: product name from hwmon or power supply description
|
|
# Try modalias vendor/device text via /sys/.../subsystem_device not always human
|
|
# Last resort: readable model via drm connector name
|
|
[[ -z "$_gname" ]] && _gname="unknown GPU"
|
|
gpu_list+=("$_gname")
|
|
done
|
|
|
|
# Fallback: scan /proc/bus/pci/devices — field 1 is vendor:device hex, field 14 is name
|
|
if (( ${#gpu_list[@]} == 0 )) && [[ -r /proc/bus/pci/devices ]]; then
|
|
while IFS=$'\t' read -r _pci_bus _pci_id _pci_irq _rest _pci_name; do
|
|
# Display class is in the high 16 bits of field 2 (vendor:device word)
|
|
# /proc/bus/pci/devices col 1 is busdevfn, col 2 is vendorID<<16|deviceID
|
|
# The class 0x03xx is "Display controller / VGA compatible"
|
|
case "$_pci_name" in
|
|
*VGA*|*Display*|*3D*|*GPU*|*Graphics*|*Radeon*|*GeForce*|*Intel*Iris*|*Intel*UHD*|*Intel*HD*Graphics*)
|
|
gpu_list+=("$_pci_name")
|
|
;;
|
|
esac
|
|
done < /proc/bus/pci/devices
|
|
fi
|
|
|
|
# --- Render ---
|
|
local _lbl="${BIWhite:-}" _val="${ICyan:-}" _rst="${DEFAULTCOL:-}"
|
|
|
|
printf "\n"
|
|
_row "Hostname" "$hostname_str"
|
|
_row "OS" "${os_name}${os_version:+ $os_version}"
|
|
_row "Kernel" "$kernel_str"
|
|
_row "Arch" "$arch_str"
|
|
_row "Uptime" "$uptime_str"
|
|
_row "Load avg" "$load_str"
|
|
_row "CPU" "$cpu_model"
|
|
_row "Cores" "${cpu_cores} physical, ${cpu_threads} logical"
|
|
if (( ${#gpu_list[@]} > 0 )); then
|
|
local _gi
|
|
for _gi in "${!gpu_list[@]}"; do
|
|
local _gpu_lbl="GPU"
|
|
(( ${#gpu_list[@]} > 1 )) && _gpu_lbl="GPU $(( _gi + 1 ))"
|
|
_row "$_gpu_lbl" "${gpu_list[$_gi]}"
|
|
done
|
|
fi
|
|
_row "Memory" "${mem_used_mib} MiB used / ${mem_total_mib} MiB total"
|
|
if (( swap_total > 0 )); then
|
|
_row "Swap" "${swap_used_mib} MiB used / ${swap_total_mib} MiB total"
|
|
fi
|
|
_row "Processes" "$proc_count"
|
|
_row "Shell" "$shell_str"
|
|
_row "Terminal" "$term_str"
|
|
printf "\n"
|
|
}
|
|
export -f pinfo
|
|
# ------------------------------------------------------------------------------
|
|
|
|
|
|
# ------------------------------------------------------------------------------
|
|
# Display system general information
|
|
# Usage: showinfo
|
|
showinfo()
|
|
{
|
|
local PARSED
|
|
|
|
PARSED=$(getopt -o h --long help -n 'showinfo' -- "$@")
|
|
# shellcheck disable=SC2181 # getopt return code is checked immediately after
|
|
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 and fetch output when available).\n"
|
|
printf "Usage: showinfo\n"
|
|
return 0
|
|
;;
|
|
--)
|
|
shift
|
|
break
|
|
;;
|
|
*)
|
|
disp E "Invalid options, use \"showinfo --help\" to display usage."
|
|
return 1
|
|
;;
|
|
esac
|
|
done
|
|
|
|
local hostname_str
|
|
local figopt=()
|
|
hostname_str="$(hostname)"
|
|
|
|
printf "\n"
|
|
if command -v figlet >/dev/null 2>&1; then
|
|
[[ -s /usr/share/figlet/ansi_shadow.flf ]] && \
|
|
figopt=(-f ansi_shadow)
|
|
figlet -k "${figopt[@]}" "$hostname_str"
|
|
else
|
|
printf "%s\n" "$hostname_str"
|
|
fi
|
|
|
|
printf "\n"
|
|
if command -v neofetch >/dev/null 2>&1; then
|
|
neofetch
|
|
elif command -v fastfetch >/dev/null 2>&1; then
|
|
fastfetch
|
|
else
|
|
pinfo "$@"
|
|
fi
|
|
}
|
|
export -f showinfo
|
|
# ------------------------------------------------------------------------------
|
|
|
|
|
|
load_conf info
|
|
# EOF
|