Замена Dproto

package main

import (
    "bufio"
    "crypto/md5"
    "encoding/hex"
    "flag"
    "fmt"
    "io"
    "os"
    "path/filepath"
    "strings"
)

// FileEntry хранит информацию о файле или каталоге
type FileEntry struct {
    Path string
    Hash string
}

// Функция для создания слепка системы для указанного пути и записи его в файл
func createAndSaveSnapshot(rootPath, filename string, excludeDirs []string, verbose bool) ([]FileEntry, error) {
    var newSnapshot []FileEntry
    excludeMap := make(map[string]struct{})
    for _, dir := range excludeDirs {
        absDir, err := filepath.Abs(dir)
        if err == nil {
            excludeMap[absDir] = struct{}{}
        }
    }

    err := filepath.Walk(rootPath, func(path string, info os.FileInfo, err error) error {
        if err != nil {
            if verbose {
                fmt.Printf("Skipping %s due to error: %v\n", path, err)
            }
            return nil
        }

        if info.Mode()&os.ModeSymlink != 0 {
            // Пропуск символических ссылок ВАЖНО!!!
            if verbose {
                fmt.Printf("Skipping symlink: %s\n", path)
            }
            return nil
        }

        absPath, err := filepath.Abs(path)
        if err != nil {
            if verbose {
                fmt.Printf("Skipping %s due to error: %v\n", path, err)
            }
            return nil
        }

        for excludeDir := range excludeMap {
            if absPath == excludeDir || strings.HasPrefix(absPath, excludeDir+string(os.PathSeparator)) {
                return nil
            }
        }

        if !info.IsDir() {
            // Если это файл, происходит вычисление его хэш-суммы
            fileHash, err := hashFile(path)
            if err != nil {
                if verbose {
                    fmt.Printf("Skipping file %s due to error: %v\n", path, err)
                }
                return nil
            }
            newSnapshot = append(newSnapshot, FileEntry{Path: path, Hash: fileHash})
        } else {
            // Если это каталог, добавляет его только в список
            newSnapshot = append(newSnapshot, FileEntry{Path: path})
        }

        return nil
    })
    if err != nil {
        return nil, err
    }

    // Открывает файл для записи слепка системы
    file, err := os.Create(filename)
    if err != nil {
        return nil, err
    }
    defer file.Close()

    // Записывает слепок системы в файл
    for _, entry := range newSnapshot {
        _, err := fmt.Fprintf(file, "%s|%s\n", entry.Path, entry.Hash)
        if err != nil {
            return nil, err
        }
    }
    return newSnapshot, nil
}

// Функция для считывания слепка системы из файла
func readSnapshotFromFile(filename string) ([]FileEntry, error) {
    var snapshot []FileEntry

    file, err := os.Open(filename)
    if err != nil {
        if os.IsNotExist(err) {
            return nil, nil
        }
        return nil, err
    }
    defer file.Close()

    scanner := bufio.NewScanner(file)
    for scanner.Scan() {
        line := scanner.Text()
        parts := strings.SplitN(line, "|", 2)
        if len(parts) != 2 {
            fmt.Printf("Skipping malformed line: %s\n", line)
            continue // Пропуск строк с неправильным форматом
        }
        snapshot = append(snapshot, FileEntry{Path: parts[0], Hash: parts[1]})
    }

    if err := scanner.Err(); err != nil {
        return nil, err
    }

    return snapshot, nil
}

// Функция для расчета хэш-суммы файла
func hashFile(filePath string) (string, error) {
    file, err := os.Open(filePath)
    if err != nil {
        return "", err
    }
    defer file.Close()

    hash := md5.New()
    if _, err := io.Copy(hash, file); err != nil {
        return "", err
    }

    hashSum := hex.EncodeToString(hash.Sum(nil))
    return hashSum, nil
}

// Функция для сравнения двух слепков системы
func compareSnapshots(oldSnapshot, newSnapshot []FileEntry) {
    if len(oldSnapshot) == 0 {
        fmt.Println("Previous snapshot not found. Skipping comparison.")
        return
    }

    // Преобразует новый слепок в словарь для более эффективного сравнения
    newMap := make(map[string]string)
    for _, entry := range newSnapshot {
        newMap[entry.Path] = entry.Hash
    }

    // Сравнивает файлы в предыдущем слепке с файлами в новом слепке
    for _, entry := range oldSnapshot {
        newPath := entry.Path
        newHash, ok := newMap[newPath]
        if !ok {
            fmt.Printf("[-] %s\n", newPath)
            continue
        }
        if entry.Hash != newHash {
            fmt.Printf("[m] %s\n", newPath)

        }
        // Удаляет файл из newMap, чтобы оставшиеся файлы можно было проверить на добавление
        delete(newMap, newPath)
    }

    // Проверяет, были ли добавлены новые файлы
    for path := range newMap {
        fmt.Printf("[+] %s\n", path)
    }
}

func main() {
    
    var (
        rootPath    string
        filename    = "snapshot.txt"
        verbose     = flag.Bool("verbose", false, "Enable verbose output")
        excludeDirs = flag.String("excludeDirs", "", "Comma-separated list of directories to exclude")
    )

    flag.StringVar(&rootPath, "rootPath", "/", "Root path for creating the snapshot")
    flag.Parse()

    // Проверка существования указанного rootPath
    _, err := os.Stat(rootPath)
    if os.IsNotExist(err) {
        fmt.Printf("Error: rootPath %s does not exist\n", rootPath)
        return
    } else if err != nil {
        fmt.Printf("Error checking rootPath %s: %v\n", rootPath, err)
        return
    }

    excludeDirList := strings.Split(*excludeDirs, ",")

    oldSnapshot, err := readSnapshotFromFile(filename)
    if err != nil {
        fmt.Printf("Error reading previous snapshot from file: %v\n", err)
        return
    }

    var newSnapshot []FileEntry

    if oldSnapshot == nil {
        // Создает новый слепок, если предыдущий не найден
        newSnapshot, err = createAndSaveSnapshot(rootPath, filename, excludeDirList, *verbose)
        if err != nil {
            fmt.Printf("Error creating and saving new snapshot: %v\n", err)
            return
        }
        fmt.Printf("Snapshot created and saved to %s\n", filename)
    } else {
        // Проверяет текущие файлы с предыдущим слепком
        newSnapshot, err = createAndSaveSnapshot(rootPath, "/tmp/current_snapshot.txt", excludeDirList, *verbose)
        if err != nil {
            fmt.Printf("Error creating and saving new snapshot: %v\n", err)
            return
        }
        // fmt.Println("Comparing current state with the previous snapshot:")
        compareSnapshots(oldSnapshot, newSnapshot)
        // Отложенное удаление временного файла
        defer os.Remove("/tmp/current_snapshot.txt")
    }
}