// 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 }