Bash — Guida Interattiva

#!/bin/bash

# Dichiarazione variabili locali (ATTENZIONE: nessun spazio intorno all'uguale '=')
NOME="Sviluppatore"
CORSO="Bash Base"

# Intercettiamo l'utente in modo robusto per Windows/Git Bash:
# ${USER:-$USERNAME} significa: usa $USER, se vuoto usa $USERNAME
UTENTE_CORRENTE=${USER:-$USERNAME}

# Stampe dell'output sul terminale
echo "Benvenuto, $NOME!"
echo "Utente di sistema corrente: $UTENTE_CORRENTE"
echo "Stai seguendo il corso: $CORSO"

#!/bin/bash

# Dichiarazione variabili locali
NOME="Sviluppatore"
CORSO="Bash Base"

# Intercettiamo l'utente: primo tentativo con ${USER:-$USERNAME}
UTENTE_CORRENTE=${USER:-$USERNAME}

# if [ -z "..." ] verifica se la stringa è vuota (zero-length)
# Se entrambe le variabili d'ambiente sono vuote, usiamo il comando whoami
if [ -z "$UTENTE_CORRENTE" ]; then
    UTENTE_CORRENTE=$(whoami)
fi

# $(date '+formato') esegue il comando date e ne cattura l'output
# %d = giorno, %m = mese, %Y = anno, %H = ore, %M = minuti, %S = secondi
DATA_ORA=$(date '+%d/%m/%Y %H:%M:%S')

# Stampe dell'output sul terminale
echo "═══════════════════════════════════"
echo "Benvenuto, $NOME!"
echo "Utente di sistema: $UTENTE_CORRENTE"
echo "Corso: $CORSO"
echo "Data e ora: $DATA_ORA"
echo "═══════════════════════════════════"

#!/bin/bash

# Intercetta l'utente corrente (compatibile Windows/Git Bash)
UTENTE=${USER:-$USERNAME}
echo "Benvenuto utente $UTENTE!!"

# Richiesta di input testuale: read legge ciò che l'utente digita
echo "Inserisci il nome del progetto da creare:"
read NOME_PROGETTO

echo "Creazione cartella in corso..."

# mkdir -p: crea la cartella genitore "Progetti" se non esiste,
# e non restituisce errore se la sottocartella esiste già
mkdir -p "Progetti/$NOME_PROGETTO"

echo "Cartella '$NOME_PROGETTO' creata con successo!"

# ls -ld mostra i dettagli di una cartella specifica (non il suo contenuto)
ls -ld "Progetti/$NOME_PROGETTO"

#!/bin/bash
# progetti.sh — Creazione struttura cartelle multi-progetto
# Variante di progetto.sh: cartella principale configurabile
# e aggiunta iterativa di sottocartelle tramite ciclo while

# read -p legge l'input dell'utente e lo salva in PRINCIPALE
# Se l'utente preme Invio senza scrivere nulla, PRINCIPALE vale ""
read -p "Nome cartella principale [progetti]: " PRINCIPALE

# Sintassi ${VAR:-valore_di_default}:
# - se $PRINCIPALE non è vuota, usa il valore inserito dall'utente
# - se $PRINCIPALE è vuota (Invio senza scrivere), usa "progetti"
# È il modo idiomatico in Bash per gestire input opzionali
PRINCIPALE=${PRINCIPALE:-"progetti"}

echo "Cartella principale: $PRINCIPALE"
mkdir -p "$PRINCIPALE"

echo ""
echo "Inserisci le sottocartelle una alla volta."
echo "Premi Invio senza scrivere nulla per terminare."
echo ""

# while true crea un ciclo potenzialmente infinito:
# non c'è una condizione di uscita nell'intestazione del ciclo,
# ma all'interno possiamo uscire in qualsiasi momento con break
while true; do

    read -p "  Sottocartella (Invio per finire): " NOME

    # [ -z "$NOME" ] è vero se la stringa è vuota (zero-length)
    # Quando l'utente preme Invio senza scrivere, NOME vale ""
    # break interrompe immediatamente il ciclo while e passa
    # all'istruzione successiva (echo "Struttura finale:")
    if [ -z "$NOME" ]; then
        break
    fi

    mkdir -p "$PRINCIPALE/$NOME"
    echo "  ✓ Creata: $PRINCIPALE/$NOME"

done

echo ""
echo "Struttura finale:"
# find -type d elenca solo le cartelle (esclude i file), sort le ordina
find "$PRINCIPALE" -type d | sort

#!/bin/bash

# $# conta quanti argomenti l'utente ha inserito a riga di comando
# Se non ne ha inseriti, mostriamo l'uso corretto ed usciamo
if [ $# -eq 0 ]; then
    echo "Errore sintattico. Uso corretto: $0 <numero>"
    exit 1
fi

# $1 è il primo parametro inviato (es: ./classifica.sh 5 → $1 vale 5)
numero=$1

# Comparatori per costrutti if-else matematici:
# -lt (less than, <) | -eq (equal, ==) | -le (less or equal, <=)
if [ "$numero" -lt 0 ]; then
    echo "negativo"
elif [ "$numero" -eq 0 ]; then
    echo "zero"
elif [ "$numero" -le 9 ]; then
    echo "piccolo"
else
    echo "grande"
fi

#!/bin/bash

# Verifica se il file dei dati esiste. Se manca, lo creiamo di esempio
if [ ! -f voti.txt ]; then
    echo "File 'voti.txt' non trovato. Inizializzo file di prova..."
    echo -e "18\n24\n30\n26\n22" > voti.txt
fi

somma=0
conta=0

# Il ciclo while read legge il file passato in fondo col simbolo '<'
while read voto; do
    # Ignoriamo eventuali righe vuote nel documento
    [ -z "$voto" ] && continue

    somma=$((somma + voto))
    conta=$((conta + 1))
done < voti.txt

# Divisione intera standard di Bash (non supporta decimali)
media=$((somma / conta))

echo "Somma dei voti analizzati: $somma"
echo "Numero di righe elaborate: $conta"
echo "Media (arrotondata all'intero per limite Bash): $media"

# RISOLUZIONE DEL LIMITE: integrazione con AWK per calcolo decimale preciso
media_precisa=$(awk '{somma+=$1; conta++} END {print somma/conta}' voti.txt)
echo "Media reale (con cifre decimali tramite AWK): $media_precisa"

#!/bin/bash
# stataccessi.sh — Statistiche accessi al sistema

# MAX_ORE parte da 0: qualsiasi valore reale sarà maggiore
# MIN_ORE parte da 99999: qualsiasi valore reale sarà minore
# È il modo standard per inizializzare min/max prima di leggere i dati
MAX_ORE=0
MIN_ORE=99999
MAX_UTENTE=""
MIN_UTENTE=""
TOTALE=0
CONTATORE=0

# while read NOME ORE legge due campi per riga separati da spazio
while read NOME ORE; do

    [ -z "$NOME" ] && continue

    TOTALE=$((TOTALE + ORE))
    CONTATORE=$((CONTATORE + 1))

    # Aggiorna il massimo se le ore correnti superano il massimo trovato finora
    if [ "$ORE" -gt "$MAX_ORE" ]; then
        MAX_ORE=$ORE
        MAX_UTENTE=$NOME
    fi

    # Aggiorna il minimo se le ore correnti sono inferiori al minimo trovato finora
    if [ "$ORE" -lt "$MIN_ORE" ]; then
        MIN_ORE=$ORE
        MIN_UTENTE=$NOME
    fi

done < dati/accessi.txt

# Divisione intera: media approssimata all'ora intera (limite di Bash)
MEDIA=$((TOTALE / CONTATORE))

echo "=== ANALISI ACCESSI AL SISTEMA ==="
echo ""
echo "  Accesso maggiore: $MAX_UTENTE ($MAX_ORE ore)"
echo "  Accesso minore:   $MIN_UTENTE ($MIN_ORE ore)"
echo "  Media totale:     $MEDIA ore"
echo ""
echo "=================================="

#!/bin/bash

# Chiediamo all'utente cosa cercare e dove
read -p "Inserisci la parola da cercare: " PAROLA
read -p "Inserisci il file dove cercare: " FILE

# Verifica che il file esista prima di procedere
if [ ! -f "$FILE" ]; then
    echo "Errore: file non trovato!"
    exit 1
fi

# grep -o stampa solo le corrispondenze (una per riga), wc -l le conta
CONTEGGIO=$(grep -o "$PAROLA" "$FILE" | wc -l)
echo "La parola '$PAROLA' appare $CONTEGGIO volte in $FILE"

#!/bin/bash

# 1. Sicurezza preventiva: la variabile globale $WORDLIST esiste?
if [ -z "$WORDLIST" ]; then
    echo "ATTENZIONE: La variabile globale \$WORDLIST non risulta valorizzata!"
    echo "Abilitazione fallback locale per impedire l'arresto dello script..."
    WORDLIST="./words.txt"

    # Se non esiste neanche il file locale, ne generiamo uno al volo
    if [ ! -f "$WORDLIST" ]; then
        echo -e "casa\nalbero\ntavolo\nbash\ncorso\nsviluppatore\nsistema" > "$WORDLIST"
    fi
fi

echo "Dizionario sorgente caricato da: $WORDLIST"

# 2. Controllo degli argomenti del terminale
if [ $# -eq 0 ]; then
    # Se l'utente non ha passato parametri, li chiediamo con 'read'
    read -p "Inserisci la parola da cercare: " parola
else
    # Altrimenti prendiamo il primo argomento passato
    parola=$1
fi

# 3. Ricerca effettiva (-i = case-insensitive)
echo "Corrispondenze trovate:"
grep -i "$parola" "$WORDLIST"

# 4. Conteggio complessivo delle righe trovate tramite flag '-c'
trovate=$(grep -i -c "$parola" "$WORDLIST")
echo "Totale righe corrispondenti trovate: $trovate"

#!/bin/bash

SORGENTE="Progetti"
DESTINAZIONE="Backup"
# Definiamo la stringa temporale con anno, mese, giorno, ore e minuti
DATA=$(date +%Y-%m-%d_%H-%M)

# Verifichiamo l'esistenza della sorgente con -d (directory exists)
if [ ! -d "$SORGENTE" ]; then
    echo "Errore critico: La cartella sorgente '$SORGENTE' non esiste su disco."
    exit 1
fi

# Genera la cartella di backup se mancante
mkdir -p "$DESTINAZIONE"

echo "Avvio dell'archiviazione dati..."

# Copia ricorsiva (-r) della sorgente, rinominando con la data corrente
cp -r "$SORGENTE" "$DESTINAZIONE/backup_progetti_$DATA"

echo "Operazione conclusa con successo. Archivio registrato in: $DESTINAZIONE/backup_progetti_$DATA"

#!/bin/bash
# grep_regex.sh — ricerca con regex sui file di log
# Prerequisito: esegui da ~/lab_bash/

echo "=== RICERCHE SU errori.log ==="

# 1. Ricerca semplice: include anche ERRORI_parser e simili
echo "--- 1. grep ERROR (include varianti) ---"
grep "ERROR" logs/errori.log
echo ""

# 2. \> = fine parola: ERROR ma NON ERRORI, ERRORI_parser
#    Confronta con il risultato 1 per vedere la differenza
echo "--- 2. grep ERROR\> (solo parola ERROR) ---"
grep "ERROR\>" logs/errori.log
echo ""

# 3. ^ = inizio riga: solo le righe del 16 luglio
echo "--- 3. ^ inizio riga: log del 2026-07-16 ---"
grep "^2026-07-16" logs/errori.log
echo ""

# 4. [0-9]\{2\}:[0-9]\{2\} = orario hh:mm
echo "--- 4. orario hh:mm ---"
grep "[0-9]\{2\}:[0-9]\{2\}" logs/errori.log | head -5
echo ""

# 5. Conta solo le righe con ERROR (parola esatta)
echo "--- 5. Conteggio righe ERROR ---"
N=$(grep "ERROR\>" logs/errori.log | wc -l)
echo "Trovate: $N righe con ERROR"

echo "=== RICERCHE SU accessi.log ==="

# 6. $ = fine riga: solo accessi di tipo LOGIN
echo "--- 6. $ fine riga: solo LOGIN ---"
grep "LOGIN$" logs/accessi.log
echo ""

# 7. Ricerca per utente
echo "--- 7. Tutte le righe di mario ---"
grep "mario" logs/accessi.log
echo ""

# 8. Pipeline: utenti unici con LOGIN
#    grep filtra → cut estrae il nome → sort ordina → uniq toglie duplicati
echo "--- 8. Utenti unici con LOGIN ---"
grep "LOGIN$" logs/accessi.log | cut -d' ' -f3 | sort | uniq

echo ""
echo "=== Fine ricerche ==="

#!/bin/bash
# contatore.sh — Controllo stato servizi ServerLab

SERVIZI_DIR="servizi"

echo "═══════════════════════════════════"
echo "  CONTROLLO SERVIZI — ServerLab"
echo "  Data: $(date '+%d/%m/%Y %H:%M:%S')"
echo "═══════════════════════════════════"

ATTIVI=0
INATTIVI=0

# Il ciclo for itera su ogni file .status trovato nella cartella
# Il glob *.status viene espanso dalla shell prima che il ciclo inizi
for FILE in "$SERVIZI_DIR"/*.status; do

    # basename rimuove percorso ed estensione: servizi/web.status → web
    SERVIZIO=$(basename "$FILE" .status)

    # cat legge l'unica riga del file (ATTIVO oppure INATTIVO)
    STATO=$(cat "$FILE")

    if [ "$STATO" = "ATTIVO" ]; then
        echo "  [ OK ] $SERVIZIO → $STATO"
        ATTIVI=$((ATTIVI + 1))
    else
        echo "  [WARN] $SERVIZIO → $STATO"
        INATTIVI=$((INATTIVI + 1))
    fi

done

echo "═══════════════════════════════════"
echo "  Attivi: $ATTIVI  |  Inattivi: $INATTIVI"

#!/bin/bash
# menu.sh — Pannello di controllo interattivo ServerLab

while true; do
    echo ""
    echo "╔══════════════════════════════╗"
    echo "║   PANNELLO SERVERLAB         ║"
    echo "╠══════════════════════════════╣"
    echo "║  1) Ultimi accessi al server ║"
    echo "║  2) Spazio disco disponibile ║"
    echo "║  3) Elenco utenti registrati ║"
    echo "║  4) Ultimi errori di sistema ║"
    echo "║  0) Esci dal pannello        ║"
    echo "╚══════════════════════════════╝"
    read -p "  Scelta: " SCELTA
    case $SCELTA in
        1) echo "--- Ultimi 5 accessi ---"; tail -n 5 logs/accessi.log ;;
        2) echo "--- Spazio disco ---"; df -h . ;;
        3) echo "--- Utenti registrati ---"
           for F in utenti/*.txt; do echo "  · $(basename "$F" .txt)"; done ;;
        4) echo "--- Ultimi 3 errori ---"; tail -n 3 logs/errori.log ;;
        0) echo "Uscita dal pannello."; break ;;
        *) echo "Scelta non valida." ;;
    esac
done

#!/bin/bash
# funzioni.sh — Toolkit di manutenzione ServerLab
# Le funzioni si definiscono PRIMA di essere chiamate

# ─── FUNZIONE 1: scrivi una riga nel log di sistema ───────────────
# Argomenti: $1 = tipo (INFO/WARN), $2 = messaggio
scrivi_log() {
    local TIPO=$1
    local TESTO=$2
    # local limita la variabile allo scope della funzione
    local TS=$(date '+%Y-%m-%d %H:%M:%S')
    echo "$TS [$TIPO] $TESTO" >> logs/sistema.log
    echo "  → Log: [$TIPO] $TESTO"
}

# ─── FUNZIONE 2: verifica esistenza utente ────────────────────────
# Argomenti: $1 = nome utente
# Return: 0 se trovato (successo), 1 se non trovato (errore)
utente_esiste() {
    local NOME=$1
    if [ -f "utenti/$NOME.txt" ]; then
        return 0   # trovato: la funzione "ha successo"
    else
        return 1   # non trovato: la funzione "fallisce"
    fi
}

# ─── FUNZIONE 3: genera report spazio disco ───────────────────────
# Nessun argomento: usa la data odierna come suffisso del file
genera_report() {
    local OUTFILE="report/disco_$(date +%Y-%m-%d).txt"
    echo "Report disco — $(date '+%d/%m/%Y %H:%M')" > "$OUTFILE"
    echo "──────────────────────────────" >> "$OUTFILE"
    df -h . >> "$OUTFILE"
    echo "  → Report salvato: $OUTFILE"
}

# ─── ESECUZIONE PRINCIPALE ────────────────────────────────────────

echo "=== TOOLKIT SERVERLAB ==="
scrivi_log "INFO" "Avvio toolkit"

echo ""
echo "Verifica utenti:"
for UTENTE in mario anna guest ospite; do
    # if chiama la funzione e usa il suo valore di return (0 = successo)
    if utente_esiste "$UTENTE"; then
        echo "  [ OK ] $UTENTE presente"
        scrivi_log "INFO" "Utente $UTENTE verificato"
    else
        echo "  [WARN] $UTENTE NON trovato"
        scrivi_log "WARN" "Utente $UTENTE assente"
    fi
done

echo ""
genera_report
scrivi_log "INFO" "Toolkit completato"
echo "========================="

#!/bin/bash
# lab12_util.sh — trova minimo e massimo di una lista di numeri
# Riceve valori SOLO come argomenti: non usa read
# Output: "MIN MAX" su una riga, catturato dal main con $()

if [ $# -eq 0 ]; then
    echo "Errore: nessun valore ricevuto" >&2
    exit 1
fi

# Inizializza min e max con il primo valore
MIN=$1
MAX=$1

# Itera su tutti gli argomenti con "$@"
for VALORE in "$@"; do
    if [ "$VALORE" -lt "$MIN" ]; then
        MIN=$VALORE
    fi
    if [ "$VALORE" -gt "$MAX" ]; then
        MAX=$VALORE
    fi
done

# echo stampa "MIN MAX" — il main lo leggerà con cut
echo "$MIN $MAX"

#!/bin/bash
# lab12_main.sh — legge valori e chiama lab12_util.sh per l'analisi

echo "=== ANALISI VALORI ==="
read -p "Inserisci numeri separati da spazio: " INPUT

# Converte l'input in un array (ogni parola diventa un elemento)
ARR=($INPUT)

if [ ${#ARR[@]}" -eq 0 ]; then
    echo "Errore: nessun valore inserito"
    exit 1
fi

echo "Valori inseriti: ${#ARR[@]}"

# Chiama lo script esterno passando tutti gli elementi dell'array
# "${ ARR[@]}" espande l'array come lista di argomenti separati
# $() cattura ciò che lab12_util.sh stampa con echo
RISULTATO=$(bash lab12_util.sh "${ARR[@]}")

# L'output è "MIN MAX" — cut estrae il primo e il secondo campo
MIN=$(echo "$RISULTATO" | cut -d' ' -f1)
MAX=$(echo "$RISULTATO" | cut -d' ' -f2)

echo ""
echo "Minimo: $MIN"
echo "Massimo: $MAX"
echo "========================="