polizia_frascati/app/Services/VpnManager.php

<?php

namespace App\Services;

use Illuminate\Support\Facades\Storage;
use Illuminate\Support\Facades\Crypt;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\Schema;

class VpnManager
{
    private $configPath = 'scripts/vpn-config.conf';
    private $scriptPath = 'scripts/vpn-connect.sh';

    public function updateCredentials($username, $password, $server)
    {
        try {
            // Crea il contenuto del file di configurazione
            $configContent = "# Configurazione VPN - storage/scripts/vpn-config.conf\n";
            $configContent .= "# ATTENZIONE: Questo file deve avere permessi 600\n\n";
            $configContent .= "VPN_USERNAME=\"{$username}\"\n";
            $configContent .= "VPN_PASSWORD=\"{$password}\"\n";
            $configContent .= "VPN_SERVER=\"{$server}\"\n";

            // Salva il file di configurazione
            Storage::put($this->configPath, $configContent);

            // Imposta i permessi corretti (solo per sistemi Unix/Linux)
            $fullPath = storage_path('app/' . $this->configPath);
            chmod($fullPath, 0600);

            Log::info('Credenziali VPN aggiornate con successo');
            return true;

        } catch (\Exception $e) {
            Log::error('Errore nell\'aggiornamento delle credenziali VPN: ' . $e->getMessage());
            return false;
        }
    }

    public function getVpnStatus($forceRefresh = false)
    {
        try {
            // Se richiesto refresh, sincronizza con il sistema
            if ($forceRefresh) {
                return $this->syncStatusWithSystem();
            }

            // Verifica se la tabella esiste
            if (!Schema::hasTable('vpn_status')) {
                Log::warning('Tabella vpn_status non esiste');
                return 'disconnected';
            }

            $status = \DB::table('vpn_status')->first();

            if (!$status) {
                // Se non ci sono record, sincronizza con il sistema
                return $this->syncStatusWithSystem();
            }

            return $status->status;

        } catch (\Exception $e) {
            Log::error('Errore nel recupero dello stato VPN: ' . $e->getMessage());
            return 'disconnected';
        }
    }

    public function getLastUpdate()
    {
        try {
            if (!Schema::hasTable('vpn_status')) {
                return now();
            }

            $status = \DB::table('vpn_status')->first();
            return $status ? $status->last_update : now();

        } catch (\Exception $e) {
            Log::error('Errore nel recupero dell\'ultimo aggiornamento VPN: ' . $e->getMessage());
            return now();
        }
    }

    public function checkRealVpnStatus()
    {
        try {
            // Esegui il comando per verificare lo stato reale
            $output = [];
            $returnVar = 0;
            exec('/opt/cisco/anyconnect/bin/vpn state 2>&1', $output, $returnVar);

            $statusText = implode(' ', $output);

            Log::info('VPN real status check', [
                'output' => $output,
                'return_var' => $returnVar,
                'status_text' => $statusText
            ]);

            // Determina lo stato basandosi sull'output
            if (strpos($statusText, 'state: Connected') !== false ||
                strpos($statusText, 'Connected') !== false) {
                return 'connected';
            } elseif (strpos($statusText, 'Disconnected') !== false ||
                      strpos($statusText, 'state: Disconnected') !== false) {
                return 'disconnected';
            } else {
                return 'unknown';
            }

        } catch (\Exception $e) {
            Log::error('Error checking real VPN status: ' . $e->getMessage());
            return 'error';
        }
    }

    public function syncStatusWithSystem()
    {
        try {
            $realStatus = $this->checkRealVpnStatus();

            // Aggiorna il database con lo stato reale
            \DB::table('vpn_status')->updateOrInsert(
                ['id' => 1],
                [
                    'status' => $realStatus,
                    'last_update' => now(),
                    'updated_at' => now(),
                ]
            );

            Log::info('VPN status synced with system', [
                'real_status' => $realStatus
            ]);

            return $realStatus;

        } catch (\Exception $e) {
            Log::error('Error syncing VPN status: ' . $e->getMessage());
            return 'error';
        }
    }

    public function connectVpn()
    {
        try {
            // Prima controlla se è già connesso
            $currentStatus = $this->checkRealVpnStatus();
            if ($currentStatus === 'connected') {
                Log::info('VPN already connected, no action needed');
                return true;
            }

            $scriptPath = storage_path('app/' . $this->scriptPath);

            if (!file_exists($scriptPath)) {
                Log::error('Script VPN non trovato: ' . $scriptPath);
                return false;
            }

            // Esegue lo script in background
            $command = "bash {$scriptPath} > /dev/null 2>&1 &";
            exec($command, $output, $returnVar);

            Log::info('Comando VPN connect eseguito', [
                'command' => $command,
                'return_var' => $returnVar
            ]);

            return true;

        } catch (\Exception $e) {
            Log::error('Errore nell\'esecuzione del comando VPN connect: ' . $e->getMessage());
            return false;
        }
    }

    public function disconnectVpn()
    {
        try {
            // Comando per disconnettere VPN Cisco AnyConnect
            $command = "/opt/cisco/anyconnect/bin/vpn disconnect > /dev/null 2>&1 &";
            exec($command, $output, $returnVar);

            // Aggiorna lo stato nel database
            \DB::table('vpn_status')->updateOrInsert(
                ['id' => 1],
                [
                    'status' => 'disconnected',
                    'last_update' => now(),
                    'updated_at' => now(),
                ]
            );

            Log::info('Comando VPN disconnect eseguito', [
                'command' => $command,
                'return_var' => $returnVar
            ]);

            return true;

        } catch (\Exception $e) {
            Log::error('Errore nell\'esecuzione del comando VPN disconnect: ' . $e->getMessage());
            return false;
        }
    }

    public function makeScriptExecutable()
    {
        try {
            $fullPath = storage_path('app/' . $this->scriptPath);
            chmod($fullPath, 0755);
            return true;
        } catch (\Exception $e) {
            Log::error('Errore nell\'impostazione dei permessi script: ' . $e->getMessage());
            return false;
        }
    }
}