2023-08-24 11:42:17 +01:00
|
|
|
// Package arpdb implements the Network Neighborhood Database.
|
|
|
|
package arpdb
|
2022-03-15 17:57:46 +00:00
|
|
|
|
|
|
|
import (
|
|
|
|
"bufio"
|
2022-03-30 13:11:57 +01:00
|
|
|
"bytes"
|
2022-03-15 17:57:46 +00:00
|
|
|
"fmt"
|
|
|
|
"net"
|
2022-10-25 13:08:12 +01:00
|
|
|
"net/netip"
|
2022-03-15 17:57:46 +00:00
|
|
|
"sync"
|
|
|
|
|
2023-08-24 11:42:17 +01:00
|
|
|
"github.com/AdguardTeam/AdGuardHome/internal/aghos"
|
2022-03-15 17:57:46 +00:00
|
|
|
"github.com/AdguardTeam/golibs/errors"
|
2023-08-24 11:42:17 +01:00
|
|
|
"github.com/AdguardTeam/golibs/log"
|
|
|
|
"github.com/AdguardTeam/golibs/netutil"
|
2022-10-21 18:42:00 +01:00
|
|
|
"golang.org/x/exp/slices"
|
2022-03-15 17:57:46 +00:00
|
|
|
)
|
|
|
|
|
2023-08-24 11:42:17 +01:00
|
|
|
// Variables and functions to substitute in tests.
|
|
|
|
var (
|
|
|
|
// aghosRunCommand is the function to run shell commands.
|
|
|
|
aghosRunCommand = aghos.RunCommand
|
2022-03-15 17:57:46 +00:00
|
|
|
|
2023-08-24 11:42:17 +01:00
|
|
|
// rootDirFS is the filesystem pointing to the root directory.
|
|
|
|
rootDirFS = aghos.RootDirFS()
|
|
|
|
)
|
|
|
|
|
|
|
|
// Interface stores and refreshes the network neighborhood reported by ARP
|
|
|
|
// (Address Resolution Protocol).
|
|
|
|
type Interface interface {
|
2022-03-15 17:57:46 +00:00
|
|
|
// Refresh updates the stored data. It must be safe for concurrent use.
|
|
|
|
Refresh() (err error)
|
|
|
|
|
|
|
|
// Neighbors returnes the last set of data reported by ARP. Both the method
|
|
|
|
// and it's result must be safe for concurrent use.
|
|
|
|
Neighbors() (ns []Neighbor)
|
|
|
|
}
|
|
|
|
|
2023-08-24 11:42:17 +01:00
|
|
|
// New returns the [Interface] properly initialized for the OS.
|
|
|
|
func New() (arp Interface) {
|
2022-03-23 17:47:45 +00:00
|
|
|
return newARPDB()
|
2022-03-15 17:57:46 +00:00
|
|
|
}
|
|
|
|
|
2023-08-24 11:42:17 +01:00
|
|
|
// Empty is the [Interface] implementation that does nothing.
|
|
|
|
type Empty struct{}
|
2022-03-15 17:57:46 +00:00
|
|
|
|
|
|
|
// type check
|
2023-08-24 11:42:17 +01:00
|
|
|
var _ Interface = Empty{}
|
2022-03-15 17:57:46 +00:00
|
|
|
|
2023-08-24 11:42:17 +01:00
|
|
|
// Refresh implements the [Interface] interface for EmptyARPContainer. It does
|
2022-03-15 17:57:46 +00:00
|
|
|
// nothing and always returns nil error.
|
2023-08-24 11:42:17 +01:00
|
|
|
func (Empty) Refresh() (err error) { return nil }
|
2022-03-15 17:57:46 +00:00
|
|
|
|
2023-08-24 11:42:17 +01:00
|
|
|
// Neighbors implements the [Interface] interface for EmptyARPContainer. It
|
|
|
|
// always returns nil.
|
|
|
|
func (Empty) Neighbors() (ns []Neighbor) { return nil }
|
2022-03-15 17:57:46 +00:00
|
|
|
|
|
|
|
// Neighbor is the pair of IP address and MAC address reported by ARP.
|
|
|
|
type Neighbor struct {
|
|
|
|
// Name is the hostname of the neighbor. Empty name is valid since not each
|
|
|
|
// implementation of ARP is able to retrieve that.
|
|
|
|
Name string
|
|
|
|
|
|
|
|
// IP contains either IPv4 or IPv6.
|
2022-10-25 13:08:12 +01:00
|
|
|
IP netip.Addr
|
2022-03-15 17:57:46 +00:00
|
|
|
|
|
|
|
// MAC contains the hardware address.
|
|
|
|
MAC net.HardwareAddr
|
|
|
|
}
|
|
|
|
|
|
|
|
// Clone returns the deep copy of n.
|
|
|
|
func (n Neighbor) Clone() (clone Neighbor) {
|
|
|
|
return Neighbor{
|
|
|
|
Name: n.Name,
|
2022-10-25 13:08:12 +01:00
|
|
|
IP: n.IP,
|
2022-10-21 18:42:00 +01:00
|
|
|
MAC: slices.Clone(n.MAC),
|
2022-03-15 17:57:46 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-09-01 13:24:44 +01:00
|
|
|
// validatedHostname returns h if it's a valid hostname, or an empty string
|
|
|
|
// otherwise, logging the validation error.
|
2023-08-24 11:42:17 +01:00
|
|
|
func validatedHostname(h string) (host string) {
|
|
|
|
err := netutil.ValidateHostname(h)
|
|
|
|
if err != nil {
|
|
|
|
log.Debug("arpdb: parsing arp output: host: %s", err)
|
|
|
|
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
|
|
|
|
return h
|
|
|
|
}
|
|
|
|
|
2022-03-15 17:57:46 +00:00
|
|
|
// neighs is the helper type that stores neighbors to avoid copying its methods
|
2023-08-24 11:42:17 +01:00
|
|
|
// among all the [Interface] implementations.
|
2022-03-15 17:57:46 +00:00
|
|
|
type neighs struct {
|
|
|
|
mu *sync.RWMutex
|
|
|
|
ns []Neighbor
|
|
|
|
}
|
|
|
|
|
|
|
|
// len returns the length of the neighbors slice. It's safe for concurrent use.
|
|
|
|
func (ns *neighs) len() (l int) {
|
|
|
|
ns.mu.RLock()
|
|
|
|
defer ns.mu.RUnlock()
|
|
|
|
|
|
|
|
return len(ns.ns)
|
|
|
|
}
|
|
|
|
|
|
|
|
// clone returns a deep copy of the underlying neighbors slice. It's safe for
|
|
|
|
// concurrent use.
|
|
|
|
func (ns *neighs) clone() (cloned []Neighbor) {
|
|
|
|
ns.mu.RLock()
|
|
|
|
defer ns.mu.RUnlock()
|
|
|
|
|
|
|
|
cloned = make([]Neighbor, len(ns.ns))
|
|
|
|
for i, n := range ns.ns {
|
|
|
|
cloned[i] = n.Clone()
|
|
|
|
}
|
|
|
|
|
|
|
|
return cloned
|
|
|
|
}
|
|
|
|
|
|
|
|
// reset replaces the underlying slice with the new one. It's safe for
|
|
|
|
// concurrent use.
|
|
|
|
func (ns *neighs) reset(with []Neighbor) {
|
|
|
|
ns.mu.Lock()
|
|
|
|
defer ns.mu.Unlock()
|
|
|
|
|
|
|
|
ns.ns = with
|
|
|
|
}
|
|
|
|
|
|
|
|
// parseNeighsFunc parses the text from sc as if it'd be an output of some
|
|
|
|
// ARP-related command. lenHint is a hint for the size of the allocated slice
|
|
|
|
// of Neighbors.
|
|
|
|
type parseNeighsFunc func(sc *bufio.Scanner, lenHint int) (ns []Neighbor)
|
|
|
|
|
2023-08-24 11:42:17 +01:00
|
|
|
// cmdARPDB is the implementation of the [Interface] that uses command line to
|
2022-03-15 17:57:46 +00:00
|
|
|
// retrieve data.
|
|
|
|
type cmdARPDB struct {
|
2022-03-30 13:11:57 +01:00
|
|
|
parse parseNeighsFunc
|
|
|
|
ns *neighs
|
|
|
|
cmd string
|
|
|
|
args []string
|
2022-03-15 17:57:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// type check
|
2023-08-24 11:42:17 +01:00
|
|
|
var _ Interface = (*cmdARPDB)(nil)
|
2022-03-15 17:57:46 +00:00
|
|
|
|
2023-08-24 11:42:17 +01:00
|
|
|
// Refresh implements the [Interface] interface for *cmdARPDB.
|
2022-03-15 17:57:46 +00:00
|
|
|
func (arp *cmdARPDB) Refresh() (err error) {
|
|
|
|
defer func() { err = errors.Annotate(err, "cmd arpdb: %w") }()
|
|
|
|
|
2022-03-30 13:11:57 +01:00
|
|
|
code, out, err := aghosRunCommand(arp.cmd, arp.args...)
|
2022-03-15 17:57:46 +00:00
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf("running command: %w", err)
|
2022-03-30 13:11:57 +01:00
|
|
|
} else if code != 0 {
|
|
|
|
return fmt.Errorf("running command: unexpected exit code %d", code)
|
2022-03-15 17:57:46 +00:00
|
|
|
}
|
|
|
|
|
2022-03-30 13:11:57 +01:00
|
|
|
sc := bufio.NewScanner(bytes.NewReader(out))
|
2022-03-15 17:57:46 +00:00
|
|
|
ns := arp.parse(sc, arp.ns.len())
|
|
|
|
if err = sc.Err(); err != nil {
|
2022-03-30 13:11:57 +01:00
|
|
|
// TODO(e.burkov): This error seems unreachable. Investigate.
|
2022-03-15 17:57:46 +00:00
|
|
|
return fmt.Errorf("scanning the output: %w", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
arp.ns.reset(ns)
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2023-08-24 11:42:17 +01:00
|
|
|
// Neighbors implements the [Interface] interface for *cmdARPDB.
|
2022-03-15 17:57:46 +00:00
|
|
|
func (arp *cmdARPDB) Neighbors() (ns []Neighbor) {
|
|
|
|
return arp.ns.clone()
|
|
|
|
}
|
|
|
|
|
2023-08-24 11:42:17 +01:00
|
|
|
// arpdbs is the [Interface] that combines several [Interface] implementations
|
|
|
|
// and consequently switches between those.
|
2022-03-15 17:57:46 +00:00
|
|
|
type arpdbs struct {
|
2023-08-24 11:42:17 +01:00
|
|
|
// arps is the set of [Interface] implementations to range through.
|
|
|
|
arps []Interface
|
2022-03-30 13:11:57 +01:00
|
|
|
neighs
|
2022-03-15 17:57:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// newARPDBs returns a properly initialized *arpdbs. It begins refreshing from
|
|
|
|
// the first of arps.
|
2023-08-24 11:42:17 +01:00
|
|
|
func newARPDBs(arps ...Interface) (arp *arpdbs) {
|
2022-03-15 17:57:46 +00:00
|
|
|
return &arpdbs{
|
|
|
|
arps: arps,
|
2022-03-30 13:11:57 +01:00
|
|
|
neighs: neighs{
|
|
|
|
mu: &sync.RWMutex{},
|
|
|
|
ns: make([]Neighbor, 0),
|
|
|
|
},
|
2022-03-15 17:57:46 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// type check
|
2023-08-24 11:42:17 +01:00
|
|
|
var _ Interface = (*arpdbs)(nil)
|
2022-03-15 17:57:46 +00:00
|
|
|
|
2023-08-24 11:42:17 +01:00
|
|
|
// Refresh implements the [Interface] interface for *arpdbs.
|
2022-03-15 17:57:46 +00:00
|
|
|
func (arp *arpdbs) Refresh() (err error) {
|
|
|
|
var errs []error
|
2022-03-30 13:11:57 +01:00
|
|
|
|
|
|
|
for _, a := range arp.arps {
|
|
|
|
err = a.Refresh()
|
|
|
|
if err != nil {
|
|
|
|
errs = append(errs, err)
|
|
|
|
|
|
|
|
continue
|
2022-03-15 17:57:46 +00:00
|
|
|
}
|
|
|
|
|
2022-03-30 13:11:57 +01:00
|
|
|
arp.reset(a.Neighbors())
|
|
|
|
|
|
|
|
return nil
|
2022-03-15 17:57:46 +00:00
|
|
|
}
|
|
|
|
|
2023-08-15 13:09:08 +01:00
|
|
|
return errors.Annotate(errors.Join(errs...), "each arpdb failed: %w")
|
2022-03-15 17:57:46 +00:00
|
|
|
}
|
|
|
|
|
2023-08-24 11:42:17 +01:00
|
|
|
// Neighbors implements the [Interface] interface for *arpdbs.
|
2022-03-30 13:11:57 +01:00
|
|
|
//
|
|
|
|
// TODO(e.burkov): Think of a way to avoid cloning the slice twice.
|
2022-03-15 17:57:46 +00:00
|
|
|
func (arp *arpdbs) Neighbors() (ns []Neighbor) {
|
2022-03-30 13:11:57 +01:00
|
|
|
return arp.clone()
|
2022-03-15 17:57:46 +00:00
|
|
|
}
|