up

main.go

@@ -41,42 +41,33 @@ var (
 
 // -------------------------------------
 
-func loadOrCreateHostKey(path string) (ssh.Signer, error) {
+// ---------- SFTP Server ----------
-	if _, err := os.Stat(path); err == nil {
+
-		b, err := os.ReadFile(path)
+// startSFTPServer démarre un serveur SFTP sur le port 2222
-		if err != nil {
+// avec authentification par IP-allowlist et user/pass.
-			return nil, err
+// Le dossier racine SFTP est défini par `base`.
-		}
+// Les clés hôte sont générées ou chargées depuis le disque.
-		return ssh.ParsePrivateKey(b)
+// Les IP autorisées peuvent se connecter sans mot de passe.
-	}
+// Les autres doivent utiliser le login et mot de passe définis.
-	_, priv, err := ed25519.GenerateKey(rand.Reader)
+// Le serveur écoute sur le port 2222 et gère les connexions SFTP.
-	if err != nil {
+// Il utilise les clés hôte ed25519 et RSA pour la compatibilité.
-		return nil, err
+// Les connexions TCP ont un keep-alive agressif pour éviter les coupures NAT.
-	}
+// Les erreurs de connexion sont loguées, mais le serveur continue à accepter les connexions.
-	pkcs8, err := x509.MarshalPKCS8PrivateKey(priv)
+// Les requêtes SFTP sont traitées avec un serveur SFTP minimaliste.
-	if err != nil {
+// Les erreurs de traitement des requêtes sont loguées.
-		return nil, err
+// Le serveur est conçu pour être lancé dans un goroutine séparé.
-	}
+// Il vérifie que le dossier racine existe et est un répertoire valide.
-	block := &pem.Block{Type: "PRIVATE KEY", Bytes: pkcs8}
+// Les clés hôte sont stockées dans le même répertoire que le serveur SFTP.
-	pemBytes := pem.EncodeToMemory(block)
+// Le serveur utilise le protocole SSH pour établir les connexions SFTP.
-	if err := os.WriteFile(path, pemBytes, 0o600); err != nil {
+// Il gère les canaux de session et les requêtes de sous-système SFTP.
-		return nil, err
+// Les connexions sont acceptées en boucle infinie, avec des logs pour chaque connexion réussie ou échouée.
-	}
+// Les erreurs de handshake SSH sont loguées et la connexion est fermée.
-	return ssh.ParsePrivateKey(pemBytes)
+// Les canaux SFTP sont acceptés et traités pour servir les requêtes SFTP.
-}
+// Le serveur SFTP est initialisé avec des gestionnaires par défaut pour les opérations de fichier.
+// Les erreurs lors de l'initialisation ou du traitement des requêtes SFTP sont loguées.
+// Le serveur continue à accepter les connexions même après des erreurs, garantissant une disponibilité maximale.
+// Il est recommandé de lancer cette fonction dans un goroutine séparé pour ne pas bloquer l'exécution principale du programme.
 
-func ipAllowed(addr string) bool {
-	host, _, err := net.SplitHostPort(addr)
-	if err != nil {
-		host = addr
-	}
-	for _, allow := range AllowedIPs {
-		if host == allow {
-			return true
-		}
-	}
-	return false
-}
 
 func startSFTPServer(base string) {
 	// --- helpers locaux pour charger/générer les clés hôte ---
@@ -244,22 +235,18 @@ func startSFTPServer(base string) {
 func startHTTP() {
 	bd := db.InitDB()
 	app := gin.Default() 
-
 	api := app.Group("/api/v1") 
 	routes.AddRoutes(api, bd) 
 	utils.CreateDefaultFolder(bd) 
-
 	app.Static("/static", "./web") 
 	app.NoRoute(func(c *gin.Context) { 
 		if strings.HasPrefix(c.Request.URL.Path, "/api/") { 
 			c.JSON(404, gin.H{"error": "Not found"}) 
 			return 
 		}
-		c.File("./web/index.html")
+			c.File("./web/index.html") }) 
-	})
+			log.Println("[HTTP] Serveur Gin sur http://localhost:8080") 
-
+			app.Run(":8080")
-	log.Println("[HTTP] Serveur Gin sur http://0.0.0.0:8080")
-	_ = app.Run(":8080")
 	}
 
 func main() {