- client 模式抓取水星 MW305R DHCP 列表,记录上下线,本地看板 - server 模式收上报,按站点分组持久化,多站点看板,7天滚动 - ESP8266 低功耗固件抓原始 HTML 上报 /api/raw,服务器端解析 - 部署脚本+systemd 单元+文档,交叉编译 Linux 二进制
771 lines
21 KiB
Go
771 lines
21 KiB
Go
// DHCP客户端监控守护进程
|
|
// 适用于 Mercury 水星 MW305R 等路由器管理页面
|
|
//
|
|
// 行为:
|
|
// - 常驻运行,每隔 interval(默认60s)抓取一次 DHCP 客户端列表
|
|
// - 记录每个设备的 上线/下线 时间,追加写入 events.csv
|
|
// - 设备状态持久化到 devices.json(防重启丢失)
|
|
// - 内置 Web 展示页面(默认 :8080),自动刷新
|
|
// - 事件数据滚动保留 retainDays 天(默认7天),超出自动清理
|
|
// - 下线时间说明:DHCP 租约默认10分钟,设备断开后列表仍可能保留
|
|
// 至租约到期,因此检测到的下线时间比真实时间晚 0~10 分钟。
|
|
//
|
|
// 登录方式: 设置 Authorization cookie = "Basic " + base64("admin:"+密码), 需浏览器UA
|
|
// 数据来源: /userRpm/AssignedIpAddrListRpm.htm 页面中的 DHCPDynList JS 数组
|
|
// 数组格式: 每4个元素一组: [客户端名, MAC地址, IP地址, 有效时间], 末尾以 0,0 结束
|
|
package main
|
|
|
|
import (
|
|
"embed"
|
|
"encoding/base64"
|
|
"encoding/csv"
|
|
"encoding/json"
|
|
"flag"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"net/http/cookiejar"
|
|
"os"
|
|
"path/filepath"
|
|
"regexp"
|
|
"sort"
|
|
"strconv"
|
|
"strings"
|
|
"sync"
|
|
"text/tabwriter"
|
|
"time"
|
|
|
|
"golang.org/x/text/encoding/simplifiedchinese"
|
|
)
|
|
|
|
//go:embed web/index.html
|
|
var webFS embed.FS
|
|
|
|
const defaultUA = "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.132 Safari/537.36"
|
|
|
|
const (
|
|
evOnline = "online"
|
|
evOffline = "offline"
|
|
)
|
|
|
|
// Client 表示抓取到的 DHCP 客户端
|
|
type Client struct {
|
|
Name string
|
|
MAC string
|
|
IP string
|
|
LeaseDur string
|
|
}
|
|
|
|
// Event 表示一条上下线事件
|
|
type Event struct {
|
|
Timestamp time.Time `json:"timestamp"`
|
|
Event string `json:"event"` // online / offline
|
|
MAC string `json:"mac"`
|
|
IP string `json:"ip"`
|
|
Name string `json:"name"`
|
|
Detail string `json:"detail"`
|
|
}
|
|
|
|
// Device 表示一个被监控的设备(MAC 为主键)
|
|
type Device struct {
|
|
MAC string `json:"mac"`
|
|
Name string `json:"name"`
|
|
LastIP string `json:"last_ip"`
|
|
FirstSeen time.Time `json:"first_seen"`
|
|
LastOnline *time.Time `json:"last_online,omitempty"`
|
|
LastOffline *time.Time `json:"last_offline,omitempty"`
|
|
Status string `json:"status"` // online / offline
|
|
OnlineCount int `json:"online_count"`
|
|
TotalOnline int64 `json:"total_online_seconds"`
|
|
// absent 是连续缺席的抓取次数(仅内存,不持久化)
|
|
absent int `json:"-"`
|
|
}
|
|
|
|
var dhcpDynListRe = regexp.MustCompile(`(?s)var\s+DHCPDynList\s*=\s*new\s+Array\((.*?)\)\s*;`)
|
|
var stringElemRe = regexp.MustCompile(`"([^"]*)"`)
|
|
|
|
// gbkToUTF8 将 GBK 编码的字节转为 UTF-8 字符串
|
|
func gbkToUTF8(b []byte) string {
|
|
s, err := simplifiedchinese.GBK.NewDecoder().Bytes(b)
|
|
if err != nil {
|
|
return string(b)
|
|
}
|
|
return string(s)
|
|
}
|
|
|
|
// Daemon 守护进程
|
|
type Daemon struct {
|
|
dataDir string // 数据目录(events.csv / devices.json)
|
|
interval time.Duration
|
|
absentToOffline int // 连续缺席多少次判定下线(防抖)
|
|
retainDays int // 事件数据保留天数(滚动清理)
|
|
|
|
baseURL string
|
|
auth string
|
|
client *http.Client
|
|
|
|
mu sync.Mutex
|
|
devices map[string]*Device
|
|
evFile *os.File
|
|
evCSV *csv.Writer
|
|
events []Event // 内存事件(已含7天滚动清理)
|
|
evRotate time.Time
|
|
|
|
// 上报(client 模式)
|
|
reportURL string
|
|
reportToken string
|
|
site string
|
|
lastReportedAt time.Time
|
|
|
|
startTime time.Time
|
|
lastPollOk time.Time
|
|
verbose bool
|
|
}
|
|
|
|
func (d *Daemon) logf(format string, args ...interface{}) {
|
|
t := time.Now().Format("2006-01-02 15:04:05")
|
|
fmt.Printf("[%s] %s\n", t, fmt.Sprintf(format, args...))
|
|
}
|
|
|
|
// fetch 抓取当前 DHCP 客户端列表
|
|
func (d *Daemon) fetch() ([]Client, error) {
|
|
// 先访问根页面(与浏览器 reload 逻辑一致,建立会话)
|
|
if _, err := d.doGet(d.baseURL+"/", d.baseURL+"/"); err != nil {
|
|
return nil, fmt.Errorf("访问根页面: %w", err)
|
|
}
|
|
pageURL := d.baseURL + "/userRpm/AssignedIpAddrListRpm.htm"
|
|
body, err := d.doGet(pageURL, d.baseURL+"/userRpm/MenuRpm.htm")
|
|
if err != nil {
|
|
return nil, fmt.Errorf("抓取页面: %w", err)
|
|
}
|
|
text := string(body)
|
|
if strings.Contains(text, "403 Forbidden") || strings.Contains(text, "You have no authority") {
|
|
return nil, fmt.Errorf("认证被拒绝(403): 请检查密码,或路由器处于登录锁定")
|
|
}
|
|
if strings.Contains(text, "httpAutErrorArray") || strings.Contains(text, "pcPassword") {
|
|
return nil, fmt.Errorf("认证失败: 密码不正确,或路由器因密码错误多次被暂时锁定")
|
|
}
|
|
|
|
return parseDHCPPage(body)
|
|
}
|
|
|
|
// parseDHCPPage 从原始路由器页面 HTML 中解析 DHCP 客户端列表(采集端与服务器端复用)。
|
|
// body 为 /userRpm/AssignedIpAddrListRpm.htm 的响应体。
|
|
func parseDHCPPage(body []byte) ([]Client, error) {
|
|
m := dhcpDynListRe.FindSubmatch(body)
|
|
if m == nil {
|
|
return nil, fmt.Errorf("未找到 DHCPDynList 数据,页面结构可能不同")
|
|
}
|
|
raw := string(m[1])
|
|
var elems []string
|
|
for _, sm := range stringElemRe.FindAllStringSubmatch(raw, -1) {
|
|
elems = append(elems, gbkToUTF8([]byte(sm[1])))
|
|
}
|
|
clients := make([]Client, 0, len(elems)/4)
|
|
for i := 0; i+3 < len(elems); i += 4 {
|
|
clients = append(clients, Client{
|
|
Name: elems[i],
|
|
MAC: strings.ToUpper(elems[i+1]),
|
|
IP: elems[i+2],
|
|
LeaseDur: elems[i+3],
|
|
})
|
|
}
|
|
return clients, nil
|
|
}
|
|
|
|
// doGet 发起带认证 cookie 的 GET 请求并返回响应体
|
|
func (d *Daemon) doGet(url, referer string) ([]byte, error) {
|
|
req, err := http.NewRequest("GET", url, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
req.Header.Set("User-Agent", defaultUA)
|
|
req.Header.Set("Referer", referer)
|
|
// 注意: 不能使用 req.AddCookie,Go 会对含空格的 cookie 值加引号,
|
|
// 路由器要求 Cookie 头为形如 Authorization=Basic xxx 的无引号形式
|
|
req.Header.Set("Cookie", "Authorization="+d.auth)
|
|
resp, err := d.client.Do(req)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer resp.Body.Close()
|
|
var buf strings.Builder
|
|
if _, err := io.Copy(&buf, resp.Body); err != nil {
|
|
return nil, err
|
|
}
|
|
return []byte(buf.String()), nil
|
|
}
|
|
|
|
// poll 单次轮询: 抓取 + 状态判定 + 落盘
|
|
func (d *Daemon) poll() {
|
|
d.mu.Lock()
|
|
defer d.mu.Unlock()
|
|
|
|
now := time.Now()
|
|
clients, err := d.fetch()
|
|
if err != nil {
|
|
d.logf("抓取失败: %v", err)
|
|
return
|
|
}
|
|
d.lastPollOk = now
|
|
|
|
seen := make(map[string]bool, len(clients))
|
|
for _, c := range clients {
|
|
mac := c.MAC
|
|
if mac == "" {
|
|
continue
|
|
}
|
|
dev := d.devices[mac]
|
|
if dev == nil {
|
|
dev = &Device{MAC: mac, Status: evOffline}
|
|
d.devices[mac] = dev
|
|
}
|
|
dev.Name = c.Name
|
|
dev.LastIP = c.IP
|
|
if dev.FirstSeen.IsZero() {
|
|
dev.FirstSeen = now
|
|
}
|
|
|
|
if dev.Status == evOffline {
|
|
// 上线事件
|
|
dev.Status = evOnline
|
|
dev.OnlineCount++
|
|
t := now
|
|
dev.LastOnline = &t
|
|
dev.absent = 0
|
|
d.recordEvent(now, evOnline, mac, c.IP, c.Name, c.LeaseDur)
|
|
d.logf("设备上线: %s (%s) %s", c.Name, mac, c.IP)
|
|
}
|
|
seen[mac] = true
|
|
}
|
|
|
|
// 判定下线: 本次未出现的在线设备
|
|
for mac, dev := range d.devices {
|
|
if dev.Status != evOnline || seen[mac] {
|
|
continue
|
|
}
|
|
dev.absent++
|
|
if dev.absent >= d.absentToOffline {
|
|
dev.Status = evOffline
|
|
t := now
|
|
dev.LastOffline = &t
|
|
if dev.LastOnline != nil {
|
|
dur := now.Sub(*dev.LastOnline)
|
|
dev.TotalOnline += int64(dur.Seconds())
|
|
h := int(dur.Hours())
|
|
m := int(dur.Minutes()) % 60
|
|
detail := fmt.Sprintf("在线时长 %02dh%02dm; 下线检测误差≤%s(DHCP租约)", h, m, "10m")
|
|
d.recordEvent(now, evOffline, mac, dev.LastIP, dev.Name, detail)
|
|
d.logf("设备下线: %s (%s) %s %s", dev.Name, mac, dev.LastIP, detail)
|
|
} else {
|
|
d.recordEvent(now, evOffline, mac, dev.LastIP, dev.Name, "")
|
|
}
|
|
}
|
|
}
|
|
d.save()
|
|
}
|
|
|
|
// recordEvent 追加写一条事件到 events.csv 并加入内存
|
|
func (d *Daemon) recordEvent(t time.Time, ev, mac, ip, name, detail string) {
|
|
// 内存事件(用于 web 展示)
|
|
d.events = append(d.events, Event{Timestamp: t, Event: ev, MAC: mac, IP: ip, Name: name, Detail: detail})
|
|
if d.evCSV == nil {
|
|
return
|
|
}
|
|
row := []string{t.Format(time.RFC3339), ev, mac, ip, name, detail}
|
|
if err := d.evCSV.Write(row); err != nil {
|
|
fmt.Fprintf(os.Stderr, "写入事件失败: %v\n", err)
|
|
return
|
|
}
|
|
d.evCSV.Flush()
|
|
// 每次写入后顺势清理内存中的过期事件(保持内存有界)
|
|
cutoff := time.Now().Add(-time.Duration(d.retainDays) * 24 * time.Hour)
|
|
if i := firstEventAfter(d.events, cutoff); i > 0 {
|
|
d.events = append([]Event(nil), d.events[i:]...)
|
|
}
|
|
}
|
|
|
|
// firstEventAfter 返回第一个 Timestamp >= cutoff 的下标
|
|
func firstEventAfter(evs []Event, cutoff time.Time) int {
|
|
for i, e := range evs {
|
|
if !e.Timestamp.Before(cutoff) {
|
|
return i
|
|
}
|
|
}
|
|
return len(evs)
|
|
}
|
|
|
|
// pruneEvents 滚动清理:去掉超过 retainDays 的旧事件(CSV重写)
|
|
func (d *Daemon) pruneEvents() {
|
|
cutoff := time.Now().Add(-time.Duration(d.retainDays) * 24 * time.Hour)
|
|
// 内存清理
|
|
if i := firstEventAfter(d.events, cutoff); i > 0 {
|
|
d.events = append([]Event(nil), d.events[i:]...)
|
|
}
|
|
// CSV 文件清理:重写整个文件
|
|
if d.evCSV == nil {
|
|
return
|
|
}
|
|
path := filepath.Join(d.dataDir, "events.csv")
|
|
rows, err := readCSV(path)
|
|
if err != nil {
|
|
return
|
|
}
|
|
keep := [][]string{rows[0]} // 表头
|
|
pruned := 0
|
|
for _, r := range rows[1:] {
|
|
if len(r) < 1 {
|
|
continue
|
|
}
|
|
t, err := time.Parse(time.RFC3339, r[0])
|
|
if err != nil || !t.Before(cutoff) {
|
|
keep = append(keep, r)
|
|
} else {
|
|
pruned++
|
|
}
|
|
}
|
|
if pruned == 0 {
|
|
return
|
|
}
|
|
// 关掉当前 writer,重写文件,再重新打开
|
|
d.evCSV.Flush()
|
|
d.evFile.Close()
|
|
if err := writeCSV(path, keep); err != nil {
|
|
d.logf("清理旧事件失败: %v", err)
|
|
}
|
|
d.evFile, _ = os.OpenFile(path, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
|
|
d.evCSV = csv.NewWriter(d.evFile)
|
|
d.logf("事件滚动清理: 移除 %d 条超过 %d 天的旧事件", pruned, d.retainDays)
|
|
}
|
|
|
|
// readCSV 读取 CSV 全部行
|
|
func readCSV(path string) ([][]string, error) {
|
|
f, err := os.Open(path)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer f.Close()
|
|
return csv.NewReader(f).ReadAll()
|
|
}
|
|
|
|
// writeCSV 重写 CSV 文件
|
|
func writeCSV(path string, rows [][]string) error {
|
|
tmp := path + ".tmp"
|
|
f, err := os.Create(tmp)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
w := csv.NewWriter(f)
|
|
if err := w.WriteAll(rows); err != nil {
|
|
f.Close()
|
|
return err
|
|
}
|
|
w.Flush()
|
|
if err := f.Close(); err != nil {
|
|
return err
|
|
}
|
|
return os.Rename(tmp, path)
|
|
}
|
|
|
|
// pruneDevices 清理离线超过 retainDays 的设备记录
|
|
func (d *Daemon) pruneDevices() {
|
|
cutoff := time.Now().Add(-time.Duration(d.retainDays) * 24 * time.Hour)
|
|
removed := 0
|
|
for mac, dev := range d.devices {
|
|
if dev.Status == evOnline {
|
|
continue
|
|
}
|
|
last := dev.LastOffline
|
|
if last == nil {
|
|
last = &dev.FirstSeen
|
|
}
|
|
if last.Before(cutoff) {
|
|
delete(d.devices, mac)
|
|
removed++
|
|
}
|
|
}
|
|
if removed > 0 {
|
|
d.logf("设备记录清理: 移除 %d 台离线超过 %d 天的设备", removed, d.retainDays)
|
|
d.save()
|
|
}
|
|
}
|
|
|
|
// save 持久化设备状态到 devices.json
|
|
func (d *Daemon) save() {
|
|
if d.devices == nil {
|
|
return
|
|
}
|
|
path := filepath.Join(d.dataDir, "devices.json")
|
|
data, err := json.MarshalIndent(d.devices, "", " ")
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "序列化设备状态失败: %v\n", err)
|
|
return
|
|
}
|
|
tmp := path + ".tmp"
|
|
if err := os.WriteFile(tmp, data, 0644); err != nil {
|
|
fmt.Fprintf(os.Stderr, "写设备状态失败: %v\n", err)
|
|
return
|
|
}
|
|
os.Rename(tmp, path)
|
|
}
|
|
|
|
// load 从 devices.json 加载设备状态
|
|
func (d *Daemon) load() {
|
|
path := filepath.Join(d.dataDir, "devices.json")
|
|
data, err := os.ReadFile(path)
|
|
if err != nil {
|
|
return // 首次运行,无历史
|
|
}
|
|
if err := json.Unmarshal(data, &d.devices); err != nil {
|
|
fmt.Fprintf(os.Stderr, "解析 devices.json 失败(忽略): %v\n", err)
|
|
}
|
|
}
|
|
|
|
// printReport 打印设备汇总表
|
|
func (d *Daemon) printReport(w io.Writer) {
|
|
devs := make([]*Device, 0, len(d.devices))
|
|
for _, dev := range d.devices {
|
|
devs = append(devs, dev)
|
|
}
|
|
sort.Slice(devs, func(i, j int) bool {
|
|
di, dj := devs[i], devs[j]
|
|
if di.Status != dj.Status {
|
|
return di.Status == evOnline
|
|
}
|
|
if di.LastOnline != nil && dj.LastOnline != nil {
|
|
return di.LastOnline.After(*dj.LastOnline)
|
|
}
|
|
return di.MAC < dj.MAC
|
|
})
|
|
|
|
tw := tabwriter.NewWriter(w, 0, 4, 2, ' ', 0)
|
|
fmt.Fprintln(tw, "状态\t设备名\tMAC\tIP\t首次发现\t最近上线\t最近下线\t在线次数\t累计在线")
|
|
for _, dev := range devs {
|
|
st := "在线"
|
|
if dev.Status == evOffline {
|
|
st = "离线"
|
|
}
|
|
lo := "-"
|
|
if dev.LastOnline != nil {
|
|
lo = dev.LastOnline.Format("01-02 15:04:05")
|
|
}
|
|
lf := "-"
|
|
if dev.LastOffline != nil {
|
|
lf = dev.LastOffline.Format("01-02 15:04:05")
|
|
}
|
|
fs := "-"
|
|
if !dev.FirstSeen.IsZero() {
|
|
fs = dev.FirstSeen.Format("01-02 15:04:05")
|
|
}
|
|
name := dev.Name
|
|
if name == "" {
|
|
name = "-"
|
|
}
|
|
dur := time.Duration(dev.TotalOnline) * time.Second
|
|
onStr := fmt.Sprintf("%dh%02dm", int(dur.Hours()), int(dur.Minutes())%60)
|
|
fmt.Fprintf(tw, "%s\t%s\t%s\t%s\t%s\t%s\t%s\t%d\t%s\n",
|
|
st, name, dev.MAC, dev.LastIP, fs, lo, lf, dev.OnlineCount, onStr)
|
|
}
|
|
tw.Flush()
|
|
}
|
|
|
|
// ---------- Web 服务 ----------
|
|
|
|
// startWeb 启动内嵌的展示页面和 JSON API
|
|
func (d *Daemon) startWeb(addr string) {
|
|
mux := http.NewServeMux()
|
|
mux.HandleFunc("/", d.handleIndex)
|
|
mux.HandleFunc("/api/devices", d.handleDevices)
|
|
mux.HandleFunc("/api/events", d.handleEvents)
|
|
srv := &http.Server{Addr: addr, Handler: mux}
|
|
go func() {
|
|
d.logf("Web 展示页启动: http://%s (数据保留 %d 天)", addr, d.retainDays)
|
|
if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
|
|
d.logf("Web 服务错误: %v", err)
|
|
}
|
|
}()
|
|
}
|
|
|
|
func (d *Daemon) handleIndex(w http.ResponseWriter, r *http.Request) {
|
|
if r.URL.Path != "/" {
|
|
http.NotFound(w, r)
|
|
return
|
|
}
|
|
data, err := webFS.ReadFile("web/index.html")
|
|
if err != nil {
|
|
http.Error(w, "页面加载失败", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
w.Header().Set("Content-Type", "text/html; charset=utf-8")
|
|
w.Write(data)
|
|
}
|
|
|
|
func (d *Daemon) handleDevices(w http.ResponseWriter, r *http.Request) {
|
|
d.mu.Lock()
|
|
devs := make([]*Device, 0, len(d.devices))
|
|
for _, dev := range d.devices {
|
|
devs = append(devs, dev)
|
|
}
|
|
d.mu.Unlock()
|
|
sort.Slice(devs, func(a, b int) bool {
|
|
if devs[a].Status != devs[b].Status {
|
|
return devs[a].Status == evOnline
|
|
}
|
|
return devs[a].MAC < devs[b].MAC
|
|
})
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
json.NewEncoder(w).Encode(map[string]interface{}{
|
|
"devices": devs,
|
|
"interval": d.interval.String(),
|
|
"retain_days": d.retainDays,
|
|
"last_poll_ok": d.lastPollOk.Format(time.RFC3339),
|
|
"device_count": len(devs),
|
|
})
|
|
}
|
|
|
|
func (d *Daemon) handleEvents(w http.ResponseWriter, r *http.Request) {
|
|
limit := 100
|
|
if v := r.URL.Query().Get("limit"); v != "" {
|
|
if n, err := strconv.Atoi(v); err == nil && n > 0 {
|
|
limit = n
|
|
}
|
|
}
|
|
cutoff := time.Now().Add(-time.Duration(d.retainDays) * 24 * time.Hour)
|
|
d.mu.Lock()
|
|
// 从后往前取最近的 limit 条
|
|
evs := d.events
|
|
start := 0
|
|
if len(evs) > limit {
|
|
start = len(evs) - limit
|
|
}
|
|
out := make([]Event, 0, limit)
|
|
for _, e := range evs[start:] {
|
|
if e.Timestamp.Before(cutoff) {
|
|
continue
|
|
}
|
|
out = append(out, e)
|
|
}
|
|
d.mu.Unlock()
|
|
// 最新在前
|
|
for i, j := 0, len(out)-1; i < j; i, j = i+1, j-1 {
|
|
out[i], out[j] = out[j], out[i]
|
|
}
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
json.NewEncoder(w).Encode(map[string]interface{}{
|
|
"events": out,
|
|
"total": len(out),
|
|
})
|
|
}
|
|
|
|
func main() {
|
|
mode := flag.String("mode", "client", "运行模式: client(采集上报) / server(接收+看板)")
|
|
host := flag.String("host", "192.168.1.1", "路由器管理地址(client模式)")
|
|
password := flag.String("password", "123456", "管理员密码(client模式)")
|
|
useHTTPS := flag.Bool("https", false, "使用 https 协议")
|
|
timeout := flag.Int("timeout", 10, "HTTP 超时秒数")
|
|
interval := flag.Duration("interval", 60*time.Second, "抓取间隔")
|
|
dataDir := flag.String("data", "./data", "数据目录(events.csv / devices.json)")
|
|
once := flag.Bool("once", false, "仅抓取一次并打印当前客户端列表(不常驻)")
|
|
quiet := flag.Bool("quiet", false, "安静模式:不打印每次轮询的设备变动/错误")
|
|
webAddr := flag.String("web", ":8080", "Web 展示页面监听地址(空=不启用)")
|
|
retainDays := flag.Int("retain", 7, "事件/设备数据保留天数(滚动清理)")
|
|
|
|
// 上报参数(client 模式)
|
|
reportURL := flag.String("report", "", "上报服务器地址,如 http://server:8080/api/report(空=不上报)")
|
|
reportToken := flag.String("token", "", "上报/访问令牌,与服务器一致")
|
|
site := flag.String("site", "", "站点标识(站点名,如 home/office)")
|
|
|
|
// 服务器参数(server 模式)
|
|
serverToken := flag.String("stoken", "", "服务器令牌:上报需带此令牌才接收(server模式)")
|
|
// 下线判定防抖: 连续 N 次缺席(默认2次=2分钟)
|
|
// DHCP 租约10分钟,设备断线后列表仍保留→下线检测误差≤10分钟
|
|
absentN := flag.Int("absent", 2, "连续缺席多少次(次)判定下线,防抖用")
|
|
flag.Parse()
|
|
|
|
// ---- server 模式: 接收上报 + 看板 ----
|
|
if *mode == "server" {
|
|
runServer(ServerConfig{
|
|
Addr: *webAddr,
|
|
DataDir: *dataDir,
|
|
Token: *serverToken,
|
|
RetainDays: *retainDays,
|
|
})
|
|
return
|
|
}
|
|
|
|
scheme := "http"
|
|
if *useHTTPS {
|
|
scheme = "https"
|
|
}
|
|
baseURL := fmt.Sprintf("%s://%s", scheme, *host)
|
|
auth := "Basic " + base64.StdEncoding.EncodeToString([]byte("admin:"+*password))
|
|
|
|
jar, err := newJar()
|
|
if err != nil {
|
|
fmt.Fprintln(os.Stderr, "创建 cookie jar 失败:", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
d := &Daemon{
|
|
dataDir: *dataDir,
|
|
interval: *interval,
|
|
absentToOffline: *absentN,
|
|
retainDays: *retainDays,
|
|
baseURL: baseURL,
|
|
auth: auth,
|
|
client: &http.Client{
|
|
Jar: jar,
|
|
Timeout: time.Duration(*timeout) * time.Second,
|
|
},
|
|
devices: map[string]*Device{},
|
|
startTime: time.Now(),
|
|
verbose: !*quiet,
|
|
reportURL: *reportURL,
|
|
reportToken: *reportToken,
|
|
site: *site,
|
|
}
|
|
if d.retainDays < 1 {
|
|
d.retainDays = 1
|
|
}
|
|
if d.absentToOffline < 1 {
|
|
d.absentToOffline = 1
|
|
}
|
|
|
|
// ---- 一次性模式 ----
|
|
if *once {
|
|
clients, err := d.fetch()
|
|
if err != nil {
|
|
fmt.Fprintln(os.Stderr, "抓取失败:", err)
|
|
os.Exit(1)
|
|
}
|
|
sort.Slice(clients, func(i, j int) bool { return ipLess(clients[i].IP, clients[j].IP) })
|
|
tw := tabwriter.NewWriter(os.Stdout, 0, 4, 2, ' ', 0)
|
|
fmt.Fprintln(tw, "客户端名\tMAC地址\tIP地址\t有效时间")
|
|
for _, c := range clients {
|
|
fmt.Fprintf(tw, "%s\t%s\t%s\t%s\n", c.Name, c.MAC, c.IP, c.LeaseDur)
|
|
}
|
|
tw.Flush()
|
|
return
|
|
}
|
|
|
|
// ---- 常驻模式 ----
|
|
defer d.save()
|
|
|
|
// 目录与事件文件
|
|
if err := os.MkdirAll(*dataDir, 0755); err != nil {
|
|
fmt.Fprintln(os.Stderr, "创建数据目录失败:", err)
|
|
os.Exit(1)
|
|
}
|
|
d.load()
|
|
|
|
evPath := filepath.Join(*dataDir, "events.csv")
|
|
evFile, err := os.OpenFile(evPath, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
|
|
if err != nil {
|
|
fmt.Fprintln(os.Stderr, "打开事件日志失败:", err)
|
|
os.Exit(1)
|
|
}
|
|
defer evFile.Close()
|
|
d.evFile = evFile
|
|
d.evCSV = csv.NewWriter(evFile)
|
|
if fi, _ := evFile.Stat(); fi != nil && fi.Size() == 0 {
|
|
d.evCSV.Write([]string{"timestamp", "event", "mac", "ip", "name", "detail"})
|
|
d.evCSV.Flush()
|
|
}
|
|
|
|
// 加载历史事件到内存(供 web 展示)
|
|
if rows, err := readCSV(evPath); err == nil && len(rows) > 1 {
|
|
cutoff := time.Now().Add(-time.Duration(d.retainDays) * 24 * time.Hour)
|
|
for _, r := range rows[1:] {
|
|
if len(r) < 6 {
|
|
continue
|
|
}
|
|
t, err := time.Parse(time.RFC3339, r[0])
|
|
if err != nil || t.Before(cutoff) {
|
|
continue
|
|
}
|
|
d.events = append(d.events, Event{
|
|
Timestamp: t, Event: r[1], MAC: r[2], IP: r[3], Name: r[4], Detail: r[5],
|
|
})
|
|
}
|
|
d.logf("已加载 %d 条历史事件(保留 %d 天)", len(d.events), d.retainDays)
|
|
}
|
|
|
|
d.logf("DHCP 监控启动: %s | 间隔 %s | 数据目录 %s | 历史设备 %d | 数据保留 %d 天",
|
|
baseURL, *interval, *dataDir, len(d.devices), d.retainDays)
|
|
d.logf("下线时间说明: DHCP租约约10分钟,设备断开后列表仍保留至租约到期,下线检测误差≤10分钟;另含%d次缺席防抖", *absentN)
|
|
|
|
// 启动 Web 展示服务(本地页面,可选)
|
|
if *webAddr != "" {
|
|
d.startWeb(*webAddr)
|
|
}
|
|
|
|
// 立即执行一次,再定时
|
|
d.poll()
|
|
// 首次上报(如果配置了)
|
|
d.sendReport()
|
|
if len(d.devices) > 0 {
|
|
d.logf("当前设备:")
|
|
d.printReport(os.Stdout)
|
|
}
|
|
ticker := time.NewTicker(*interval)
|
|
defer ticker.Stop()
|
|
nextReport := time.Now().Add(10 * time.Minute)
|
|
lastPrune := time.Now()
|
|
for range ticker.C {
|
|
d.poll()
|
|
// 上报增量事件 + 快照(只有新事件或周期上报)
|
|
d.sendReport()
|
|
// 每10分钟打印一次设备汇总
|
|
if !*quiet && time.Now().After(nextReport) {
|
|
d.printReport(os.Stdout)
|
|
nextReport = time.Now().Add(10 * time.Minute)
|
|
}
|
|
// 每天一次滚动清理旧数据
|
|
if time.Since(lastPrune) >= 24*time.Hour {
|
|
d.mu.Lock()
|
|
d.pruneEvents()
|
|
d.pruneDevices()
|
|
d.mu.Unlock()
|
|
lastPrune = time.Now()
|
|
}
|
|
}
|
|
}
|
|
|
|
func newJar() (http.CookieJar, error) {
|
|
return cookiejar.New(nil)
|
|
}
|
|
|
|
// ipLess 按 IPv4 数字顺序比较,无法解析的排后
|
|
func ipLess(a, b string) bool {
|
|
av, aok := parseIP(a)
|
|
bv, bok := parseIP(b)
|
|
if !aok {
|
|
return false
|
|
}
|
|
if !bok {
|
|
return true
|
|
}
|
|
for i := 0; i < 4; i++ {
|
|
if av[i] != bv[i] {
|
|
return av[i] < bv[i]
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func parseIP(s string) ([4]byte, bool) {
|
|
var r [4]byte
|
|
parts := strings.Split(s, ".")
|
|
if len(parts) != 4 {
|
|
return r, false
|
|
}
|
|
for i, p := range parts {
|
|
n, err := strconv.Atoi(p)
|
|
if err != nil || n < 0 || n > 255 {
|
|
return r, false
|
|
}
|
|
r[i] = byte(n)
|
|
}
|
|
return r, true
|
|
}
|