111 lines
3 KiB
Go
111 lines
3 KiB
Go
// Linsk - A utility to access Linux-native file systems on non-Linux operating systems.
|
|
// Copyright (c) 2023 The Linsk Authors.
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
package storage
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"github.com/AlexSSD7/linsk/nettap"
|
|
"github.com/pkg/errors"
|
|
)
|
|
|
|
const tapAllocPrefix = "tap_alloc_"
|
|
|
|
func (s *Storage) getAllocFilePath(tapName string) (string, error) {
|
|
err := nettap.ValidateTapName(tapName)
|
|
if err != nil {
|
|
return "", errors.Wrap(err, "validate tap name")
|
|
}
|
|
|
|
return filepath.Join(s.path, tapAllocPrefix+tapName), nil
|
|
}
|
|
|
|
func (s *Storage) SaveNetTapAllocation(tapName string, pid int) error {
|
|
allocFilePath, err := s.getAllocFilePath(tapName)
|
|
if err != nil {
|
|
return errors.Wrap(err, "get alloc file path")
|
|
}
|
|
|
|
err = os.WriteFile(allocFilePath, []byte(fmt.Sprint(pid)), 0400)
|
|
if err != nil {
|
|
return errors.Wrap(err, "write alloc file")
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *Storage) ReleaseNetTapAllocation(tapName string) error {
|
|
allocFilePath, err := s.getAllocFilePath(tapName)
|
|
if err != nil {
|
|
return errors.Wrap(err, "get alloc file path")
|
|
}
|
|
|
|
err = os.Remove(allocFilePath)
|
|
if err != nil {
|
|
if errors.Is(err, os.ErrNotExist) {
|
|
s.logger.Warn("Attempted to remove non-existent tap allocation", "tap-name", tapName)
|
|
return nil
|
|
}
|
|
|
|
return errors.Wrap(err, "remove alloc file")
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *Storage) ListNetTapAllocations() ([]nettap.Alloc, error) {
|
|
dirEntries, err := os.ReadDir(s.path)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "read data dir")
|
|
}
|
|
|
|
var ret []nettap.Alloc
|
|
|
|
for _, entry := range dirEntries {
|
|
if strings.HasPrefix(entry.Name(), tapAllocPrefix) {
|
|
entryPath := filepath.Clean(filepath.Join(s.path, entry.Name()))
|
|
|
|
tapName := strings.TrimPrefix(entry.Name(), tapAllocPrefix)
|
|
err := nettap.ValidateTapName(tapName)
|
|
if err != nil {
|
|
s.logger.Error("Failed to validate network tap name in tap allocation file, skipping. External interference?", "error", err.Error(), "name", tapName, "path", entryPath)
|
|
continue
|
|
}
|
|
|
|
data, err := os.ReadFile(entryPath)
|
|
if err != nil {
|
|
return nil, errors.Wrapf(err, "read tap alloc file '%v'", entryPath)
|
|
}
|
|
|
|
pid, err := strconv.ParseUint(string(data), 10, strconv.IntSize-1) // We're aiming for `int` PID.
|
|
if err != nil {
|
|
return nil, errors.Wrapf(err, "parse pid (alloc file '%v')", entryPath)
|
|
}
|
|
|
|
ret = append(ret, nettap.Alloc{
|
|
TapName: tapName,
|
|
PID: int(pid),
|
|
})
|
|
}
|
|
}
|
|
|
|
return ret, nil
|
|
}
|