469 lines
16 KiB
Bash
Executable File
469 lines
16 KiB
Bash
Executable File
#!/usr/bin/env bash
|
|
# ==============================================================================
|
|
# frogg_freebox_check.sh
|
|
# Script Zabbix - Métriques Freebox via API V10
|
|
# Compatible : Zabbix 7.0 / ExternalCheck
|
|
# Auteur : frogg (généré)
|
|
# Répertoire : /usr/lib/zabbix/externalscripts/
|
|
# Usage : frogg_freebox_check.sh <APP_ID> <APP_TOKEN> <HOST> <METRIC>
|
|
# ==============================================================================
|
|
|
|
set -uo pipefail
|
|
# Note: -e retiré volontairement pour gérer les erreurs curl manuellement
|
|
|
|
# ------------------------------------------------------------------------------
|
|
# Dépendances requises : curl, jq, openssl
|
|
# ------------------------------------------------------------------------------
|
|
for cmd in curl jq openssl bc; do
|
|
if ! command -v "$cmd" &>/dev/null; then
|
|
echo "ERREUR: '$cmd' est requis mais introuvable." >&2
|
|
exit 1
|
|
fi
|
|
done
|
|
|
|
# ------------------------------------------------------------------------------
|
|
# Paramètres (fournis par Zabbix via macros du template)
|
|
# ------------------------------------------------------------------------------
|
|
APP_ID="${1:-}"
|
|
APP_TOKEN="${2:-}"
|
|
FREEBOX_HOST="${3:-mafreebox.freebox.fr}"
|
|
METRIC="${4:-}"
|
|
# Mode debug : passer DEBUG=1 en variable d'environnement pour voir les erreurs curl
|
|
DEBUG="${DEBUG:-0}"
|
|
|
|
if [[ -z "$APP_ID" || -z "$APP_TOKEN" || -z "$FREEBOX_HOST" || -z "$METRIC" ]]; then
|
|
echo "Usage: $0 <APP_ID> <APP_TOKEN> <HOST> <METRIC>" >&2
|
|
echo "Métriques disponibles:" >&2
|
|
echo " cpu_percent - Utilisation CPU (%)" >&2
|
|
echo " ram_percent - Utilisation RAM (%)" >&2
|
|
echo " ram_used - RAM utilisée (bytes)" >&2
|
|
echo " ram_total - RAM totale (bytes)" >&2
|
|
echo " hdd_percent - Utilisation HDD (%)" >&2
|
|
echo " hdd_used - HDD utilisé (bytes)" >&2
|
|
echo " hdd_total - HDD total (bytes)" >&2
|
|
echo " net_rate_down - Débit descendant actuel (bit/s)" >&2
|
|
echo " net_rate_up - Débit montant actuel (bit/s)" >&2
|
|
echo " net_bytes_down - Total octets reçus" >&2
|
|
echo " net_bytes_up - Total octets envoyés" >&2
|
|
echo " net_bw_down - Bande passante max descendante (bit/s)" >&2
|
|
echo " net_bw_up - Bande passante max montante (bit/s)" >&2
|
|
echo " temp_cpum - Température CPU mère (°C)" >&2
|
|
echo " temp_cpub - Température CPU box (°C)" >&2
|
|
echo " temp_sw - Température switch (°C)" >&2
|
|
echo " temp_hdd - Température HDD (°C)" >&2
|
|
echo " fan_rpm - Vitesse ventilateur (RPM)" >&2
|
|
echo " uptime - Uptime système (secondes)" >&2
|
|
echo " disk_status - Statut disque (ok=1 / problem=0)" >&2
|
|
exit 1
|
|
fi
|
|
|
|
BASE_URL="https://${FREEBOX_HOST}/api/v10"
|
|
SESSION_FILE="/tmp/.freebox_session_${APP_ID}.cache"
|
|
SESSION_MAX_AGE=1800 # 30 min en secondes
|
|
|
|
# ------------------------------------------------------------------------------
|
|
# Options curl communes
|
|
# --insecure : La Freebox utilise un certificat Free (CA non reconnu par défaut)
|
|
# Si tu veux valider le certificat, télécharge le CA Free :
|
|
# curl -O https://raw.githubusercontent.com/freebox/ssl/main/freebox_root_ca.pem
|
|
# puis remplace --insecure par --cacert /etc/ssl/freebox_root_ca.pem
|
|
# ------------------------------------------------------------------------------
|
|
CURL_OPTS=(
|
|
--insecure # Certificat SSL Free (CA non standard)
|
|
--silent # Pas de barre de progression
|
|
--max-time 15 # Timeout global
|
|
--connect-timeout 5 # Timeout connexion
|
|
--retry 2 # 2 tentatives en cas d'échec réseau
|
|
--retry-delay 1
|
|
)
|
|
# En mode debug, on affiche les erreurs curl sur stderr
|
|
if [[ "$DEBUG" == "1" ]]; then
|
|
CURL_OPTS+=(--show-error)
|
|
fi
|
|
|
|
# ------------------------------------------------------------------------------
|
|
# Fonctions utilitaires
|
|
# ------------------------------------------------------------------------------
|
|
|
|
log_error() {
|
|
echo "ERREUR: $*" >&2
|
|
}
|
|
|
|
log_debug() {
|
|
if [[ "$DEBUG" == "1" ]]; then
|
|
echo "DEBUG: $*" >&2
|
|
fi
|
|
}
|
|
|
|
# Requête API Freebox (sans session, pour login)
|
|
api_request_noauth() {
|
|
local method="$1"
|
|
local endpoint="$2"
|
|
local data="${3:-}"
|
|
local response
|
|
local http_code
|
|
local tmp_body
|
|
tmp_body=$(mktemp)
|
|
|
|
if [[ "$method" == "POST" && -n "$data" ]]; then
|
|
http_code=$(curl "${CURL_OPTS[@]}" \
|
|
-o "$tmp_body" \
|
|
-w "%{http_code}" \
|
|
-X POST \
|
|
-H "Content-Type: application/json" \
|
|
-d "$data" \
|
|
"${BASE_URL}${endpoint}" 2>&1)
|
|
else
|
|
http_code=$(curl "${CURL_OPTS[@]}" \
|
|
-o "$tmp_body" \
|
|
-w "%{http_code}" \
|
|
"${BASE_URL}${endpoint}" 2>&1)
|
|
fi
|
|
|
|
local curl_exit=$?
|
|
response=$(cat "$tmp_body")
|
|
rm -f "$tmp_body"
|
|
|
|
if [[ $curl_exit -ne 0 ]]; then
|
|
log_error "curl a échoué (exit=$curl_exit) sur ${BASE_URL}${endpoint}"
|
|
log_error "Conseil : vérifiez la connectivité et le certificat SSL (mode DEBUG=1 pour détails)"
|
|
exit 2
|
|
fi
|
|
|
|
if [[ "$http_code" != "200" && "$http_code" != "201" ]]; then
|
|
log_error "Réponse HTTP inattendue : $http_code sur ${endpoint}"
|
|
log_debug "Corps de la réponse : $response"
|
|
exit 2
|
|
fi
|
|
|
|
log_debug "Réponse ${endpoint} [HTTP $http_code] : $response"
|
|
echo "$response"
|
|
}
|
|
|
|
# Requête API Freebox avec session token
|
|
api_request() {
|
|
local method="$1"
|
|
local endpoint="$2"
|
|
local session_token="$3"
|
|
local data="${4:-}"
|
|
local response
|
|
local http_code
|
|
local tmp_body
|
|
tmp_body=$(mktemp)
|
|
|
|
if [[ "$method" == "POST" && -n "$data" ]]; then
|
|
http_code=$(curl "${CURL_OPTS[@]}" \
|
|
-o "$tmp_body" \
|
|
-w "%{http_code}" \
|
|
-X POST \
|
|
-H "Content-Type: application/json" \
|
|
-H "X-Fbx-App-Auth: ${session_token}" \
|
|
-d "$data" \
|
|
"${BASE_URL}${endpoint}" 2>&1)
|
|
else
|
|
http_code=$(curl "${CURL_OPTS[@]}" \
|
|
-o "$tmp_body" \
|
|
-w "%{http_code}" \
|
|
-H "X-Fbx-App-Auth: ${session_token}" \
|
|
"${BASE_URL}${endpoint}" 2>&1)
|
|
fi
|
|
|
|
local curl_exit=$?
|
|
response=$(cat "$tmp_body")
|
|
rm -f "$tmp_body"
|
|
|
|
if [[ $curl_exit -ne 0 ]]; then
|
|
log_error "curl a échoué (exit=$curl_exit) sur ${endpoint}"
|
|
# Session peut être expirée : supprimer le cache pour forcer un nouveau login
|
|
rm -f "$SESSION_FILE"
|
|
exit 2
|
|
fi
|
|
|
|
if [[ "$http_code" != "200" && "$http_code" != "201" ]]; then
|
|
log_error "Réponse HTTP inattendue : $http_code sur ${endpoint}"
|
|
log_debug "Corps de la réponse : $response"
|
|
# Si 403, la session est invalide, on purge le cache
|
|
if [[ "$http_code" == "403" || "$http_code" == "401" ]]; then
|
|
log_error "Session invalide, suppression du cache. Relancez la commande."
|
|
rm -f "$SESSION_FILE"
|
|
fi
|
|
exit 2
|
|
fi
|
|
|
|
log_debug "Réponse ${endpoint} [HTTP $http_code] : $response"
|
|
echo "$response"
|
|
}
|
|
|
|
# Génère le mot de passe de session via HMAC-SHA1
|
|
generate_password() {
|
|
local token="$1"
|
|
local challenge="$2"
|
|
echo -n "$challenge" | openssl dgst -sha1 -hmac "$token" | awk '{print $NF}'
|
|
}
|
|
|
|
# ------------------------------------------------------------------------------
|
|
# Gestion de la session (cache pour éviter trop de logins)
|
|
# ------------------------------------------------------------------------------
|
|
|
|
get_session_token() {
|
|
# Vérification du cache
|
|
if [[ -f "$SESSION_FILE" ]]; then
|
|
local file_age
|
|
file_age=$(( $(date +%s) - $(stat -c %Y "$SESSION_FILE" 2>/dev/null || echo 0) ))
|
|
if [[ $file_age -lt $SESSION_MAX_AGE ]]; then
|
|
cat "$SESSION_FILE"
|
|
return 0
|
|
fi
|
|
fi
|
|
|
|
# Récupération du challenge
|
|
local login_resp
|
|
login_resp=$(api_request_noauth "GET" "/login")
|
|
|
|
local success
|
|
success=$(echo "$login_resp" | jq -r '.success // false')
|
|
if [[ "$success" != "true" ]]; then
|
|
log_error "Impossible de récupérer le challenge de login"
|
|
exit 3
|
|
fi
|
|
|
|
local challenge
|
|
challenge=$(echo "$login_resp" | jq -r '.result.challenge')
|
|
if [[ -z "$challenge" || "$challenge" == "null" ]]; then
|
|
log_error "Challenge vide reçu de la Freebox"
|
|
exit 3
|
|
fi
|
|
|
|
# Génération du mot de passe
|
|
local password
|
|
password=$(generate_password "$APP_TOKEN" "$challenge")
|
|
|
|
# Ouverture de session
|
|
local session_payload
|
|
session_payload=$(jq -nc \
|
|
--arg app_id "$APP_ID" \
|
|
--arg password "$password" \
|
|
'{"app_id": $app_id, "password": $password}')
|
|
|
|
local session_resp
|
|
session_resp=$(api_request_noauth "POST" "/login/session" "$session_payload")
|
|
|
|
local session_success
|
|
session_success=$(echo "$session_resp" | jq -r '.success // false')
|
|
if [[ "$session_success" != "true" ]]; then
|
|
local err_msg
|
|
err_msg=$(echo "$session_resp" | jq -r '.msg // "Erreur inconnue"')
|
|
log_error "Échec d'ouverture de session : $err_msg"
|
|
exit 3
|
|
fi
|
|
|
|
local session_token
|
|
session_token=$(echo "$session_resp" | jq -r '.result.session_token')
|
|
if [[ -z "$session_token" || "$session_token" == "null" ]]; then
|
|
log_error "Session token vide"
|
|
exit 3
|
|
fi
|
|
|
|
# Mise en cache
|
|
echo "$session_token" > "$SESSION_FILE"
|
|
chmod 600 "$SESSION_FILE"
|
|
echo "$session_token"
|
|
}
|
|
|
|
# ------------------------------------------------------------------------------
|
|
# Récupération des métriques système (CPU, RAM, Temp, Fan)
|
|
# ------------------------------------------------------------------------------
|
|
|
|
get_system_metrics() {
|
|
local session_token="$1"
|
|
api_request "GET" "/system/" "$session_token"
|
|
}
|
|
|
|
# ------------------------------------------------------------------------------
|
|
# Récupération des métriques réseau (WAN stats)
|
|
# ------------------------------------------------------------------------------
|
|
|
|
get_connection_metrics() {
|
|
local session_token="$1"
|
|
api_request "GET" "/connection/" "$session_token"
|
|
}
|
|
|
|
# ------------------------------------------------------------------------------
|
|
# Récupération des métriques stockage
|
|
# ------------------------------------------------------------------------------
|
|
|
|
get_storage_metrics() {
|
|
local session_token="$1"
|
|
api_request "GET" "/storage/disk/" "$session_token"
|
|
}
|
|
|
|
# ------------------------------------------------------------------------------
|
|
# Calcul du pourcentage HDD
|
|
# Parcourt tous les disques et agrège used/total
|
|
# ------------------------------------------------------------------------------
|
|
|
|
compute_hdd_stats() {
|
|
local storage_json="$1"
|
|
local metric="$2"
|
|
|
|
local total used percent
|
|
total=$(echo "$storage_json" | jq '[.result[]? | .partitions[]? | .total_bytes // 0] | add // 0')
|
|
used=$(echo "$storage_json" | jq '[.result[]? | .partitions[]? | .used_bytes // 0] | add // 0')
|
|
|
|
if [[ "$total" -gt 0 ]]; then
|
|
percent=$(echo "scale=2; ($used * 100) / $total" | bc)
|
|
else
|
|
percent=0
|
|
fi
|
|
|
|
case "$metric" in
|
|
hdd_percent) echo "$percent" ;;
|
|
hdd_used) echo "$used" ;;
|
|
hdd_total) echo "$total" ;;
|
|
esac
|
|
}
|
|
|
|
# ------------------------------------------------------------------------------
|
|
# MAIN - Sélection de la métrique
|
|
# ------------------------------------------------------------------------------
|
|
|
|
SESSION_TOKEN=$(get_session_token)
|
|
|
|
case "$METRIC" in
|
|
|
|
# ---- CPU ------------------------------------------------------------------
|
|
cpu_percent)
|
|
|
|
######## NON DISPONIBLE ATM
|
|
|
|
SYS=$(get_system_metrics "$SESSION_TOKEN")
|
|
echo "$SYS" | jq -r '.result.cpu_usage // 0'
|
|
;;
|
|
|
|
# ---- RAM ------------------------------------------------------------------
|
|
ram_percent)
|
|
|
|
######## NON DISPONIBLE ATM
|
|
|
|
SYS=$(get_system_metrics "$SESSION_TOKEN")
|
|
TOTAL=$(echo "$SYS" | jq -r '.result.total_mem // 1')
|
|
USED=$(echo "$SYS" | jq -r '.result.used_mem // 0')
|
|
if [[ "$TOTAL" -gt 0 ]]; then
|
|
echo "scale=2; ($USED * 100) / $TOTAL" | bc
|
|
else
|
|
echo "0"
|
|
fi
|
|
;;
|
|
|
|
ram_used)
|
|
|
|
######## NON DISPONIBLE ATM
|
|
|
|
SYS=$(get_system_metrics "$SESSION_TOKEN")
|
|
echo "$SYS" | jq -r '.result.used_mem // 0'
|
|
;;
|
|
|
|
ram_total)
|
|
|
|
######## NON DISPONIBLE ATM
|
|
|
|
SYS=$(get_system_metrics "$SESSION_TOKEN")
|
|
echo "$SYS" | jq -r '.result.total_mem // 0'
|
|
;;
|
|
|
|
# ---- HDD ------------------------------------------------------------------
|
|
hdd_percent|hdd_used|hdd_total)
|
|
STORAGE=$(get_storage_metrics "$SESSION_TOKEN")
|
|
compute_hdd_stats "$STORAGE" "$METRIC"
|
|
;;
|
|
|
|
# ---- RÉSEAU ---------------------------------------------------------------
|
|
net_rate_down)
|
|
CONN=$(get_connection_metrics "$SESSION_TOKEN")
|
|
echo "$CONN" | jq -r '.result.rate_down // 0'
|
|
;;
|
|
|
|
net_rate_up)
|
|
CONN=$(get_connection_metrics "$SESSION_TOKEN")
|
|
echo "$CONN" | jq -r '.result.rate_up // 0'
|
|
;;
|
|
|
|
net_bytes_down)
|
|
CONN=$(get_connection_metrics "$SESSION_TOKEN")
|
|
echo "$CONN" | jq -r '.result.bytes_down // 0'
|
|
;;
|
|
|
|
net_bytes_up)
|
|
CONN=$(get_connection_metrics "$SESSION_TOKEN")
|
|
echo "$CONN" | jq -r '.result.bytes_up // 0'
|
|
;;
|
|
|
|
net_bw_down)
|
|
CONN=$(get_connection_metrics "$SESSION_TOKEN")
|
|
echo "$CONN" | jq -r '.result.bandwidth_down // 0'
|
|
;;
|
|
|
|
net_bw_up)
|
|
CONN=$(get_connection_metrics "$SESSION_TOKEN")
|
|
echo "$CONN" | jq -r '.result.bandwidth_up // 0'
|
|
;;
|
|
|
|
# ---- TEMPÉRATURES ---------------------------------------------------------
|
|
temp_cpum)
|
|
# Note : Sur la Pop (r1), il n'y a pas de 'temp_cpum', c'est 'temp_t1' et 'temp_t2'
|
|
# Je te mets 'temp_t1' par défaut, ou adapte selon ce que tu veux remonter
|
|
SYS=$(get_system_metrics "$SESSION_TOKEN")
|
|
echo "$SYS" | jq -r '.result.sensors[]? | select(.id=="temp_t1") | .value // 0'
|
|
;;
|
|
|
|
temp_cpub)
|
|
SYS=$(get_system_metrics "$SESSION_TOKEN")
|
|
echo "$SYS" | jq -r '.result.sensors[]? | select(.id=="temp_cpub") | .value // 0'
|
|
;;
|
|
|
|
temp_sw)
|
|
# Note : Pas de 'temp_sw' (Switch) dans ton JSON Pop, on se rabat sur 'temp_t2'
|
|
SYS=$(get_system_metrics "$SESSION_TOKEN")
|
|
echo "$SYS" | jq -r '.result.sensors[]? | select(.id=="temp_t2") | .value // 0'
|
|
;;
|
|
|
|
temp_hdd)
|
|
# Ton JSON confirme 'customer_hdd_slots': 0 et internal_hdd_size: 0 (Pas de HDD)
|
|
# On laisse la sécurité à 0 au cas où tu branches un disque USB SMART plus tard
|
|
STORAGE=$(get_storage_metrics "$SESSION_TOKEN")
|
|
echo "$STORAGE" | jq -r '[.result[]? | .smart_data.temperature // 0] | first // 0'
|
|
;;
|
|
|
|
# ---- VENTILATEUR ----------------------------------------------------------
|
|
fan_rpm)
|
|
SYS=$(get_system_metrics "$SESSION_TOKEN")
|
|
# L'ID dans ton JSON est 'fan0_speed' au lieu de 'fan_rpm'
|
|
echo "$SYS" | jq -r '.result.fans[]? | select(.id=="fan0_speed") | .value // 0'
|
|
;;
|
|
|
|
# ---- UPTIME ---------------------------------------------------------------
|
|
uptime)
|
|
SYS=$(get_system_metrics "$SESSION_TOKEN")
|
|
echo "$SYS" | jq -r '.result.uptime_val // 0'
|
|
;;
|
|
|
|
# ---- STATUT DISQUE --------------------------------------------------------
|
|
disk_status)
|
|
STORAGE=$(get_storage_metrics "$SESSION_TOKEN")
|
|
# Retourne 1 si tous les disques sont ok, 0 sinon
|
|
ALL_OK=$(echo "$STORAGE" | jq '[.result[]? | select(.state != "ok" and .state != "enabled")] | length == 0')
|
|
if [[ "$ALL_OK" == "true" ]]; then
|
|
echo "1"
|
|
else
|
|
echo "0"
|
|
fi
|
|
;;
|
|
|
|
*)
|
|
log_error "Métrique inconnue : $METRIC"
|
|
exit 1
|
|
;;
|
|
esac
|
|
|
|
exit 0
|