119 lines
2.2 KiB
Go
119 lines
2.2 KiB
Go
package ipHelper
|
|
|
|
import (
|
|
"bytes"
|
|
"errors"
|
|
"fmt"
|
|
"os/exec"
|
|
"slices"
|
|
|
|
"github.com/vishvananda/netlink"
|
|
"github.com/vishvananda/netlink/nl"
|
|
)
|
|
|
|
var (
|
|
ErrMaxTableSize = errors.New("max table size")
|
|
ErrMaxFwMarkSize = errors.New("max fwmark size")
|
|
)
|
|
|
|
func ExecIp(args ...string) ([]byte, error) {
|
|
cmd := exec.Command("ip", args...)
|
|
var out bytes.Buffer
|
|
cmd.Stdout = &out
|
|
err := cmd.Run()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out.Bytes(), nil
|
|
}
|
|
|
|
func GetUsedFwMarks() ([]uint32, error) {
|
|
markMap := make(map[uint32]struct{})
|
|
|
|
rules, err := netlink.RuleList(nl.FAMILY_ALL)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error while getting rules: %w", err)
|
|
}
|
|
|
|
for _, rule := range rules {
|
|
markMap[rule.Mark] = struct{}{}
|
|
}
|
|
|
|
marks := make([]uint32, len(markMap))
|
|
counter := 0
|
|
for mark, _ := range markMap {
|
|
marks[counter] = mark
|
|
counter++
|
|
}
|
|
|
|
return marks, nil
|
|
}
|
|
|
|
func GetUnusedFwMark(startFrom uint32) (uint32, error) {
|
|
usedFwMarks, err := GetUsedFwMarks()
|
|
if err != nil {
|
|
return 0, fmt.Errorf("error while getting used fwmarks: %w", err)
|
|
}
|
|
|
|
fwmark := startFrom
|
|
for slices.Contains(usedFwMarks, fwmark) {
|
|
fwmark++
|
|
if fwmark == 0xFFFFFFFF {
|
|
return 0, ErrMaxFwMarkSize
|
|
}
|
|
}
|
|
return fwmark, nil
|
|
}
|
|
|
|
func GetUsedTables() ([]int, error) {
|
|
tableMap := map[int]struct{}{
|
|
0: {},
|
|
253: {},
|
|
254: {},
|
|
255: {},
|
|
}
|
|
|
|
routes, err := netlink.RouteListFiltered(nl.FAMILY_ALL, &netlink.Route{}, netlink.RT_FILTER_TABLE)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error while getting routes: %w", err)
|
|
}
|
|
|
|
for _, route := range routes {
|
|
tableMap[route.Table] = struct{}{}
|
|
}
|
|
|
|
rules, err := netlink.RuleList(nl.FAMILY_ALL)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error while getting rules: %w", err)
|
|
}
|
|
|
|
for _, rule := range rules {
|
|
tableMap[rule.Table] = struct{}{}
|
|
}
|
|
|
|
tables := make([]int, len(tableMap))
|
|
counter := 0
|
|
for table, _ := range tableMap {
|
|
tables[counter] = table
|
|
counter++
|
|
}
|
|
|
|
return tables, nil
|
|
}
|
|
|
|
func GetUnusedTable(startFrom int) (int, error) {
|
|
usedTables, err := GetUsedTables()
|
|
if err != nil {
|
|
return 0, fmt.Errorf("error while getting used tables: %w", err)
|
|
}
|
|
|
|
tableID := startFrom
|
|
for slices.Contains(usedTables, tableID) {
|
|
tableID++
|
|
if tableID > 0x3FF {
|
|
return 0, ErrMaxTableSize
|
|
}
|
|
}
|
|
return tableID, nil
|
|
}
|