diff --git a/.gitignore b/.gitignore
index 78a92910..f0dcf29e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,7 +1,6 @@
**/TODO
/yggdrasil
/yggdrasilctl
-/yggdrasil.conf
-/yggdrasil.json
+/yggdrasil.*
/run
/test
\ No newline at end of file
diff --git a/cmd/yggdrasil/main.go b/cmd/yggdrasil/main.go
index 36eedb41..19cfcfb1 100644
--- a/cmd/yggdrasil/main.go
+++ b/cmd/yggdrasil/main.go
@@ -107,6 +107,7 @@ func main() {
}
cfg := config.GenerateConfig()
+ var configPath string
var err error
switch {
case *ver:
@@ -124,6 +125,7 @@ func main() {
}
case *useconffile != "":
+ configPath = *useconffile
f, err := os.Open(*useconffile)
if err != nil {
panic(err)
@@ -206,6 +208,9 @@ func main() {
return
}
+ // Set current config for web UI
+ config.SetCurrentConfig(configPath, cfg)
+
n := &node{}
// Set up the Yggdrasil node itself.
diff --git a/src/config/config.go b/src/config/config.go
index 0358da8b..09946ec1 100644
--- a/src/config/config.go
+++ b/src/config/config.go
@@ -30,6 +30,7 @@ import (
"io"
"math/big"
"os"
+ "path/filepath"
"time"
"github.com/hjson/hjson-go/v4"
@@ -274,3 +275,190 @@ func (k *KeyBytes) UnmarshalJSON(b []byte) error {
*k, err = hex.DecodeString(s)
return err
}
+
+// ConfigInfo contains information about the configuration file
+type ConfigInfo struct {
+ Path string `json:"path"`
+ Format string `json:"format"`
+ Data interface{} `json:"data"`
+ Writable bool `json:"writable"`
+}
+
+// Global variables to track the current configuration state
+var (
+ currentConfigPath string
+ currentConfigData *NodeConfig
+)
+
+// SetCurrentConfig sets the current configuration data and path
+func SetCurrentConfig(path string, cfg *NodeConfig) {
+ currentConfigPath = path
+ currentConfigData = cfg
+}
+
+// GetCurrentConfig returns the current configuration information
+func GetCurrentConfig() (*ConfigInfo, error) {
+ var configPath string
+ var configData *NodeConfig
+ var format string = "hjson"
+ var writable bool = false
+
+ // Use current config if available, otherwise try to read from default location
+ if currentConfigPath != "" && currentConfigData != nil {
+ configPath = currentConfigPath
+ configData = currentConfigData
+ } else {
+ // Fallback to default path
+ defaults := GetDefaults()
+ configPath = defaults.DefaultConfigFile
+
+ // Try to read existing config file
+ if _, err := os.Stat(configPath); err == nil {
+ data, err := os.ReadFile(configPath)
+ if err == nil {
+ cfg := GenerateConfig()
+ if err := hjson.Unmarshal(data, cfg); err == nil {
+ configData = cfg
+ // Detect format
+ var jsonTest interface{}
+ if json.Unmarshal(data, &jsonTest) == nil {
+ format = "json"
+ }
+ } else {
+ return nil, fmt.Errorf("failed to parse config file: %v", err)
+ }
+ }
+ } else {
+ // No config file exists, use default
+ configData = GenerateConfig()
+ }
+ }
+
+ // Detect format from file if path is known
+ if configPath != "" {
+ if _, err := os.Stat(configPath); err == nil {
+ data, err := os.ReadFile(configPath)
+ if err == nil {
+ var jsonTest interface{}
+ if json.Unmarshal(data, &jsonTest) == nil {
+ format = "json"
+ }
+ }
+ }
+ }
+
+ // Check if writable
+ if configPath != "" {
+ if _, err := os.Stat(configPath); err == nil {
+ // File exists, check if writable
+ if file, err := os.OpenFile(configPath, os.O_WRONLY, 0); err == nil {
+ writable = true
+ file.Close()
+ }
+ } else {
+ // File doesn't exist, check if directory is writable
+ dir := filepath.Dir(configPath)
+ if stat, err := os.Stat(dir); err == nil && stat.IsDir() {
+ testFile := filepath.Join(dir, ".yggdrasil_write_test")
+ if file, err := os.Create(testFile); err == nil {
+ file.Close()
+ os.Remove(testFile)
+ writable = true
+ }
+ }
+ }
+ }
+
+ return &ConfigInfo{
+ Path: configPath,
+ Format: format,
+ Data: configData,
+ Writable: writable,
+ }, nil
+}
+
+// SaveConfig saves configuration to file
+func SaveConfig(configData interface{}, configPath, format string) error {
+ // Validate config data
+ var testConfig NodeConfig
+ configBytes, err := json.Marshal(configData)
+ if err != nil {
+ return fmt.Errorf("failed to marshal config data: %v", err)
+ }
+
+ if err := json.Unmarshal(configBytes, &testConfig); err != nil {
+ return fmt.Errorf("invalid configuration data: %v", err)
+ }
+
+ // Determine target path
+ targetPath := configPath
+ if targetPath == "" {
+ if currentConfigPath != "" {
+ targetPath = currentConfigPath
+ } else {
+ defaults := GetDefaults()
+ targetPath = defaults.DefaultConfigFile
+ }
+ }
+
+ // Determine format if not specified
+ targetFormat := format
+ if targetFormat == "" {
+ if _, err := os.Stat(targetPath); err == nil {
+ data, readErr := os.ReadFile(targetPath)
+ if readErr == nil {
+ var jsonTest interface{}
+ if json.Unmarshal(data, &jsonTest) == nil {
+ targetFormat = "json"
+ } else {
+ targetFormat = "hjson"
+ }
+ }
+ }
+ if targetFormat == "" {
+ targetFormat = "hjson"
+ }
+ }
+
+ // Create backup if file exists
+ if _, err := os.Stat(targetPath); err == nil {
+ backupPath := targetPath + ".backup"
+ if data, err := os.ReadFile(targetPath); err == nil {
+ if err := os.WriteFile(backupPath, data, 0600); err != nil {
+ return fmt.Errorf("failed to create backup: %v", err)
+ }
+ }
+ }
+
+ // Ensure directory exists
+ dir := filepath.Dir(targetPath)
+ if err := os.MkdirAll(dir, 0755); err != nil {
+ return fmt.Errorf("failed to create config directory: %v", err)
+ }
+
+ // Marshal to target format
+ var outputData []byte
+ if targetFormat == "json" {
+ outputData, err = json.MarshalIndent(configData, "", " ")
+ if err != nil {
+ return fmt.Errorf("failed to marshal JSON: %v", err)
+ }
+ } else {
+ outputData, err = hjson.Marshal(configData)
+ if err != nil {
+ return fmt.Errorf("failed to marshal HJSON: %v", err)
+ }
+ }
+
+ // Write file
+ if err := os.WriteFile(targetPath, outputData, 0600); err != nil {
+ return fmt.Errorf("failed to write config file: %v", err)
+ }
+
+ // Update current config if this is the current config file
+ if targetPath == currentConfigPath {
+ currentConfigData = &testConfig
+ }
+
+ return nil
+}
diff --git a/src/webui/server.go b/src/webui/server.go
index be480dc4..0848d101 100644
--- a/src/webui/server.go
+++ b/src/webui/server.go
@@ -13,6 +13,7 @@ import (
"time"
"github.com/yggdrasil-network/yggdrasil-go/src/admin"
+ "github.com/yggdrasil-network/yggdrasil-go/src/config"
"github.com/yggdrasil-network/yggdrasil-go/src/core"
)
@@ -381,6 +382,105 @@ func (w *WebUIServer) callAdminHandler(command string, args map[string]interface
return w.admin.CallHandler(command, argsBytes)
}
+// Configuration response structures
+type ConfigResponse struct {
+ ConfigPath string `json:"config_path"`
+ ConfigFormat string `json:"config_format"`
+ ConfigData interface{} `json:"config_data"`
+ IsWritable bool `json:"is_writable"`
+}
+
+type ConfigSetRequest struct {
+ ConfigData interface{} `json:"config_data"`
+ ConfigPath string `json:"config_path,omitempty"`
+ Format string `json:"format,omitempty"`
+}
+
+type ConfigSetResponse struct {
+ Success bool `json:"success"`
+ Message string `json:"message"`
+ ConfigPath string `json:"config_path"`
+ BackupPath string `json:"backup_path,omitempty"`
+}
+
+// getConfigHandler handles configuration file reading
+func (w *WebUIServer) getConfigHandler(rw http.ResponseWriter, r *http.Request) {
+ if r.Method != http.MethodGet {
+ http.Error(rw, "Method not allowed", http.StatusMethodNotAllowed)
+ return
+ }
+
+ // Use config package to get current configuration
+ configInfo, err := config.GetCurrentConfig()
+ if err != nil {
+ w.log.Errorf("Failed to get current config: %v", err)
+ http.Error(rw, "Failed to get configuration", http.StatusInternalServerError)
+ return
+ }
+
+ response := ConfigResponse{
+ ConfigPath: configInfo.Path,
+ ConfigFormat: configInfo.Format,
+ ConfigData: configInfo.Data,
+ IsWritable: configInfo.Writable,
+ }
+
+ rw.Header().Set("Content-Type", "application/json")
+ if err := json.NewEncoder(rw).Encode(response); err != nil {
+ w.log.Errorf("Failed to encode config response: %v", err)
+ http.Error(rw, "Failed to encode response", http.StatusInternalServerError)
+ }
+}
+
+// setConfigHandler handles configuration file writing
+func (w *WebUIServer) setConfigHandler(rw http.ResponseWriter, r *http.Request) {
+ if r.Method != http.MethodPost {
+ http.Error(rw, "Method not allowed", http.StatusMethodNotAllowed)
+ return
+ }
+
+ var req ConfigSetRequest
+ if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+ http.Error(rw, "Invalid request body", http.StatusBadRequest)
+ return
+ }
+
+ // Use config package to save configuration
+ err := config.SaveConfig(req.ConfigData, req.ConfigPath, req.Format)
+ if err != nil {
+ response := ConfigSetResponse{
+ Success: false,
+ Message: err.Error(),
+ }
+ w.writeJSONResponse(rw, response)
+ return
+ }
+
+ // Get current config info for response
+ configInfo, err := config.GetCurrentConfig()
+ var configPath string = req.ConfigPath
+ if err == nil && configInfo != nil {
+ configPath = configInfo.Path
+ }
+
+ response := ConfigSetResponse{
+ Success: true,
+ Message: "Configuration saved successfully",
+ ConfigPath: configPath,
+ BackupPath: configPath + ".backup",
+ }
+ w.writeJSONResponse(rw, response)
+}
+
+// writeJSONResponse helper function
+func (w *WebUIServer) writeJSONResponse(rw http.ResponseWriter, data interface{}) {
+ rw.Header().Set("Content-Type", "application/json")
+ if err := json.NewEncoder(rw).Encode(data); err != nil {
+ w.log.Errorf("Failed to encode JSON response: %v", err)
+ http.Error(rw, "Failed to encode response", http.StatusInternalServerError)
+ }
+}
+
func (w *WebUIServer) Start() error {
// Validate listen address before starting
if w.listen != "" {
@@ -415,6 +515,10 @@ func (w *WebUIServer) Start() error {
// Admin API endpoints - with auth
mux.HandleFunc("/api/admin/", w.authMiddleware(w.adminAPIHandler))
+ // Configuration API endpoints - with auth
+ mux.HandleFunc("/api/config/get", w.authMiddleware(w.getConfigHandler))
+ mux.HandleFunc("/api/config/set", w.authMiddleware(w.setConfigHandler))
+
// Setup static files handler (implementation varies by build)
setupStaticHandler(mux, w)
diff --git a/src/webui/static/config.js b/src/webui/static/config.js
new file mode 100644
index 00000000..28e8d0f5
--- /dev/null
+++ b/src/webui/static/config.js
@@ -0,0 +1,411 @@
+// Configuration management functions
+
+let currentConfig = null;
+let configMeta = null;
+
+// Initialize config section
+async function initConfigSection() {
+ try {
+ await loadConfiguration();
+ } catch (error) {
+ console.error('Failed to load configuration:', error);
+ showNotification('Ошибка загрузки конфигурации', 'error');
+ }
+}
+
+// Load current configuration
+async function loadConfiguration() {
+ try {
+ const response = await fetch('/api/config/get', {
+ method: 'GET',
+ credentials: 'same-origin'
+ });
+
+ if (!response.ok) {
+ throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+ }
+
+ const data = await response.json();
+ currentConfig = data.config_data;
+ configMeta = {
+ path: data.config_path,
+ format: data.config_format,
+ isWritable: data.is_writable
+ };
+
+ renderConfigEditor();
+ updateConfigStatus();
+ } catch (error) {
+ console.error('Error loading configuration:', error);
+ throw error;
+ }
+}
+
+// Render configuration editor
+function renderConfigEditor() {
+ const configSection = document.getElementById('config-section');
+
+ const configEditor = `
+
+
+
+
+
+ ${renderConfigGroups()}
+
+
+
+
+
+ ${group.fields.map(field => renderConfigField(field)).join('')}
+
+
+
+
${fieldDescription}
+
+ ${renderConfigInput(fieldName, value, fieldType)}
+
+
+
+ Одно значение на строку
+
+ `;
+
+ case 'object':
+ return `
+
+
+ JSON формат
+
+ `;
+
+ case 'private_key':
+ return `
+
+
+ Приватный ключ (только для чтения)
+
+ `;
+
+ default:
+ return `
+
+ `;
+ }
+}
+
+// Get field type for rendering
+function getFieldType(fieldName, value) {
+ if (fieldName === 'PrivateKey') return 'private_key';
+ if (fieldName.includes('MTU') || fieldName === 'Port') return 'number';
+ if (typeof value === 'boolean') return 'boolean';
+ if (typeof value === 'number') return 'number';
+ if (typeof value === 'string') return 'string';
+ if (Array.isArray(value)) return 'array';
+ if (typeof value === 'object') return 'object';
+ return 'string';
+}
+
+// Get field description
+function getFieldDescription(fieldName) {
+ const descriptions = {
+ 'Peers': 'Список исходящих peer соединений (например: tls://адрес:порт)',
+ 'InterfacePeers': 'Peer соединения по интерфейсам',
+ 'Listen': 'Адреса для входящих соединений',
+ 'AllowedPublicKeys': 'Разрешенные публичные ключи для входящих соединений',
+ 'PrivateKey': 'Приватный ключ узла (НЕ ПЕРЕДАВАЙТЕ НИКОМУ!)',
+ 'PrivateKeyPath': 'Путь к файлу с приватным ключом в формате PEM',
+ 'IfName': 'Имя TUN интерфейса ("auto" для автовыбора, "none" для отключения)',
+ 'IfMTU': 'Максимальный размер передаваемого блока (MTU) для TUN интерфейса',
+ 'MulticastInterfaces': 'Настройки multicast интерфейсов для обнаружения peers',
+ 'AdminListen': 'Адрес для подключения админского интерфейса',
+ 'WebUI': 'Настройки веб-интерфейса',
+ 'NodeInfo': 'Дополнительная информация об узле (видна всей сети)',
+ 'NodeInfoPrivacy': 'Скрыть информацию о платформе и версии',
+ 'LogLookups': 'Логировать поиск peers и узлов'
+ };
+
+ return descriptions[fieldName] || 'Параметр конфигурации';
+}
+
+// Update config value
+function updateConfigValue(fieldName, value) {
+ if (currentConfig) {
+ currentConfig[fieldName] = value;
+ markConfigAsModified();
+ }
+}
+
+// Update array config value
+function updateConfigArrayValue(fieldName, value) {
+ if (currentConfig) {
+ const lines = value.split('\n').filter(line => line.trim() !== '');
+ currentConfig[fieldName] = lines;
+ markConfigAsModified();
+ }
+}
+
+// Update object config value
+function updateConfigObjectValue(fieldName, value) {
+ if (currentConfig) {
+ try {
+ currentConfig[fieldName] = JSON.parse(value);
+ markConfigAsModified();
+ } catch (error) {
+ console.error('Invalid JSON for field', fieldName, ':', error);
+ }
+ }
+}
+
+// Mark config as modified
+function markConfigAsModified() {
+ const saveButton = document.querySelector('.save-btn');
+ if (saveButton) {
+ saveButton.classList.add('modified');
+ }
+}
+
+// Toggle config group
+function toggleConfigGroup(groupKey) {
+ const content = document.getElementById(`config-group-${groupKey}`);
+ const icon = content.parentNode.querySelector('.toggle-icon');
+
+ if (content.style.display === 'none') {
+ content.style.display = 'block';
+ icon.textContent = '▼';
+ } else {
+ content.style.display = 'none';
+ icon.textContent = '▶';
+ }
+}
+
+// Update config status display
+function updateConfigStatus() {
+ // This function could show config validation status, etc.
+}
+
+// Refresh configuration
+async function refreshConfiguration() {
+ try {
+ await loadConfiguration();
+ showNotification('Конфигурация обновлена', 'success');
+ } catch (error) {
+ showNotification('Ошибка обновления конфигурации', 'error');
+ }
+}
+
+// Save configuration
+async function saveConfiguration() {
+ if (!configMeta.isWritable) {
+ showNotification('Файл конфигурации доступен только для чтения', 'error');
+ return;
+ }
+
+ showModal({
+ title: 'config_save_confirm_title',
+ content: `
+
+
Вы уверены, что хотите сохранить изменения в конфигурационный файл?
+
+
Файл: ${configMeta.path}
+
Формат: ${configMeta.format.toUpperCase()}
+
Резервная копия: Будет создана автоматически
+
+
+ ⚠️ Внимание: Неправильная конфигурация может привести к сбою работы узла!
+
+
-
-
-
Основные настройки
-
Базовая конфигурация узла
-
Функция в разработке...
-
-
-
-
Сетевые настройки
-
Параметры сетевого взаимодействия
-
Функция в разработке...
-
-
+
Загрузка конфигурации...