新增扫码中间件支持网络型扫码枪键盘注入,AGV 对接从 WMS 迁至 MES 统一管理;新增拧紧不合格人工处置与 PLC 对账机制,优化退库单关联与工位终端功能,同时清理旧 AGV 任务表,完善数据库与配置项。
630 lines
20 KiB
Go
630 lines
20 KiB
Go
package scanbridge
|
||
|
||
// 扫码中间件(键盘 HID 注入):在单个 TCP 端口上同时接收两类网络型扫码设备的数据,
|
||
// 按内容自动判别帧格式、解析出扫码文本,并用「模拟键盘 HID」注入到当前光标窗口。
|
||
//
|
||
// 两类设备都是 TCP 客户端连到本机 7757,长连接常驻、扫码时才推数据。虽然帧格式不同,
|
||
// 本中间件【按收到的字节内容自动分流】,同一端口同时兼容:
|
||
//
|
||
// A) iData PAD —— 二进制长度前缀帧:
|
||
// [4 字节头 00 03][2 字节大端长度 L][L 字节载荷]
|
||
// 载荷文本形如 "barcode <主条码A> <次条码B>",B 段按字节做了 \uXX 转义需还原。
|
||
// 每收一帧回 ASCII ACK(0x06)。
|
||
//
|
||
// B) 新大陆手机端 —— 长度+校验帧:
|
||
// [1 字节 总长度 N][1 字节 校验和][N-2 字节 载荷(ASCII 原文)]
|
||
// 校验和 = 载荷所有字节之和 & 0xFF。载荷即扫码原文,整段注入。
|
||
// 默认不回包(设备只推不收)。
|
||
//
|
||
// C) HTTP 客户端 —— GET 回状态页不注入;POST/PUT 取 body 提取扫码值注入,回 200。
|
||
//
|
||
// 判别依据(三者互斥、无歧义):首字节 0x00 且次字节 0x03 → PAD;首字节=N(总长,≥3)
|
||
// → 手机端(总长至少 3,首字节不可能为 0x00);以 GET/POST/PUT… 开头 → HTTP。
|
||
//
|
||
// 三种模式解码后都统一走「模拟键盘 HID 注入」,把文本敲进当前光标所在窗口
|
||
// (微信 / 浏览器 / 记事本 / 任意输入框等),末尾不回车 —— 电脑端对设备型号完全无感。
|
||
//
|
||
// 服务常驻监听,因空闲永不主动断开连接。解码结论写入 captures/analysis.log,
|
||
// 原始字节存 captures/raw_*.bin。
|
||
//
|
||
// 端口容错:7757 绑不上(官网工具占用 / 同机两进程同开 / 其它程序占用)时仅记一行日志、
|
||
// 不退出、不影响主进程;谁先绑谁监听,后到的只记日志。
|
||
|
||
import (
|
||
"bytes"
|
||
"context"
|
||
"encoding/hex"
|
||
"encoding/json"
|
||
"fmt"
|
||
"log"
|
||
"net"
|
||
"os"
|
||
"path/filepath"
|
||
"regexp"
|
||
"strconv"
|
||
"strings"
|
||
"time"
|
||
"unicode"
|
||
)
|
||
|
||
const sep = "================================================================"
|
||
|
||
// Options 扫码中间件运行参数。零值字段由 Start 填充默认值(端口 :7757 / 空闲 3s / 字符间隔 2ms)。
|
||
type Options struct {
|
||
Addrs []string // 监听地址列表(默认 [":7757"])
|
||
Idle time.Duration // 空闲超时:仅用于切分帧,永不因空闲断开连接
|
||
KbdDelay time.Duration // 键盘注入字符间隔(模拟真实 HID 速率,默认 2ms)
|
||
NoKbd bool // true=仅日志、不模拟键盘注入(调试用)
|
||
Nlak bool // true=给新大陆手机端也回 ASCII ACK(0x06)(默认不回)
|
||
}
|
||
|
||
// 运行期参数(单进程单实例,由 Start 注入)。
|
||
var (
|
||
kbdDelay time.Duration
|
||
noKbd bool
|
||
nlak bool
|
||
)
|
||
|
||
// unescapeRe 预编译一次,避免每帧重复编译。
|
||
var unescapeRe = regexp.MustCompile(`\\u([0-9A-Fa-f]{2})`)
|
||
|
||
// 三种帧模式
|
||
type frameMode int
|
||
|
||
const (
|
||
modeUnknown frameMode = iota
|
||
modePAD // iData PAD:00 03 + 大端长度
|
||
modeNewland // 新大陆手机:总长 + 校验和
|
||
modeHTTP // HTTP 请求
|
||
)
|
||
|
||
// Start 启动扫码中间件:按 Options 监听端口,接收 iData PAD / 新大陆手机两类设备数据,
|
||
// 解析后模拟键盘 HID 注入当前光标窗口。任一端口被占用仅记日志、不影响主进程;所有端口都失败返回 error(仍非致命)。
|
||
// ctx 取消时优雅关闭所有监听器。
|
||
func Start(ctx context.Context, opts Options) error {
|
||
if len(opts.Addrs) == 0 {
|
||
opts.Addrs = []string{":7757"}
|
||
}
|
||
if opts.Idle <= 0 {
|
||
opts.Idle = 3 * time.Second
|
||
}
|
||
if opts.KbdDelay <= 0 {
|
||
opts.KbdDelay = 2 * time.Millisecond
|
||
}
|
||
kbdDelay = opts.KbdDelay
|
||
noKbd = opts.NoKbd
|
||
nlak = opts.Nlak
|
||
|
||
if err := os.MkdirAll(capturesDir(), 0o755); err != nil {
|
||
log.Printf("⚠️ 扫码中间件创建 captures 目录失败(仅影响落盘,监听与注入不受影响): %v", err)
|
||
}
|
||
|
||
kbdMode := fmt.Sprintf("键盘HID注入(开,不回车,字符间隔=%v)", kbdDelay)
|
||
if noKbd {
|
||
kbdMode = "键盘HID注入(关,仅日志)"
|
||
}
|
||
|
||
okCount := 0
|
||
for _, a := range opts.Addrs {
|
||
a = strings.TrimSpace(a)
|
||
if a == "" {
|
||
continue
|
||
}
|
||
ln, err := net.Listen("tcp", a)
|
||
if err != nil {
|
||
log.Printf("⚠️ 7757 被占用,扫码监听未启动,主程序不受影响: %v", err)
|
||
continue
|
||
}
|
||
okCount++
|
||
log.Printf("✅ 扫码中间件正在监听 %s | %s", a, kbdMode)
|
||
go acceptLoop(ln, a, opts.Idle, ctx)
|
||
}
|
||
|
||
if okCount == 0 {
|
||
log.Printf("⚠️ 扫码监听:没有任何端口监听成功(7757 被占用/被拦截),扫码功能不可用,主程序继续正常运行")
|
||
return fmt.Errorf("scanbridge: no listener bound")
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func acceptLoop(ln net.Listener, port string, idle time.Duration, ctx context.Context) {
|
||
// ctx 取消时关闭监听器,使阻塞的 Accept 返回,干净退出(避免泄漏 goroutine)。
|
||
go func() {
|
||
<-ctx.Done()
|
||
_ = ln.Close()
|
||
}()
|
||
for {
|
||
conn, err := ln.Accept()
|
||
if err != nil {
|
||
select {
|
||
case <-ctx.Done():
|
||
return
|
||
default:
|
||
}
|
||
log.Printf("accept %s 错误: %v", port, err)
|
||
continue
|
||
}
|
||
go handleConn(conn, port, idle)
|
||
}
|
||
}
|
||
|
||
// handleConn 处理一条 TCP 连接:常驻读取,按内容自动识别帧模式;空闲仅用于切分帧,绝不主动断开。
|
||
func handleConn(conn net.Conn, port string, idle time.Duration) {
|
||
defer func() { _ = conn.Close() }()
|
||
remote := conn.RemoteAddr().String()
|
||
log.Printf("🔌 [%s] 新连接: %s", port, remote)
|
||
|
||
var buf []byte
|
||
tmp := make([]byte, 8192)
|
||
mode := modeUnknown
|
||
|
||
for {
|
||
_ = conn.SetReadDeadline(time.Now().Add(idle))
|
||
n, err := conn.Read(tmp)
|
||
if n > 0 {
|
||
buf = append(buf, tmp[:n]...)
|
||
}
|
||
|
||
// ---- 首次数据到达时判定帧模式 ----
|
||
if mode == modeUnknown && len(buf) > 0 {
|
||
switch {
|
||
case buf[0] == 0x00:
|
||
// 首字节 0x00:只可能是 PAD(00 03 头)。手机端首字节=总长(≥3),永不为 0x00。
|
||
// 若 TCP 把 4 字节头拆包、暂时只有 1 字节,则保持 unknown 等下一批,避免误判。
|
||
if len(buf) >= 2 {
|
||
if buf[1] == 0x03 {
|
||
mode = modePAD
|
||
log.Printf("🔧 [%s] %s → iData PAD 二进制帧模式(头=%s)", port, remote, hex2(buf[:min(4, len(buf))]))
|
||
} else {
|
||
// 首字节 0x00 但次字节非 0x03:按手机端兜底(其解析会丢弃非法长度字节重新对齐)
|
||
mode = modeNewland
|
||
log.Printf("📱 [%s] %s → 新大陆手机端「长度+校验」帧模式(首字节 00 非 PAD 头)", port, remote)
|
||
}
|
||
}
|
||
case looksLikeHTTP(buf):
|
||
mode = modeHTTP
|
||
log.Printf("🌐 [%s] %s → HTTP 模式", port, remote)
|
||
default:
|
||
mode = modeNewland
|
||
log.Printf("📱 [%s] %s → 新大陆手机端「长度+校验」帧模式", port, remote)
|
||
}
|
||
}
|
||
|
||
switch mode {
|
||
case modePAD:
|
||
buf = parsePADFrames(conn, remote, buf)
|
||
case modeNewland:
|
||
buf = parseNewlandFrames(conn, remote, buf)
|
||
case modeHTTP:
|
||
if req, rest, ok := trySplitHTTP(buf); ok {
|
||
processHTTP(conn, remote, req)
|
||
buf = rest
|
||
}
|
||
}
|
||
|
||
if err != nil {
|
||
if ne, ok := err.(net.Error); ok && ne.Timeout() {
|
||
// 空闲超时:仅表示"当前没有新数据",连接保持不动
|
||
if mode == modeUnknown && len(buf) > 0 && buf[0] != 0x00 {
|
||
// 攒到了可判定的数据却判不出模式(罕见),兜底记录
|
||
processRaw(conn, remote, buf)
|
||
buf = buf[:0]
|
||
}
|
||
// 若 buf[0]==0x00(疑似 PAD 头碎片),继续等剩余字节,不兜底、不丢弃
|
||
continue
|
||
}
|
||
if len(buf) > 0 {
|
||
log.Printf("⚠️ [%s] 连接关闭时残留 %d 字节,按裸数据兜底处理", port, len(buf))
|
||
processRaw(conn, remote, buf)
|
||
}
|
||
log.Printf("🔌 [%s] 连接结束: %s", port, remote)
|
||
return
|
||
}
|
||
}
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// A) iData PAD: [00 03][2字节大端长度 L][L 字节载荷]
|
||
// ---------------------------------------------------------------------------
|
||
|
||
// parsePADFrames 解析 PAD 帧:头异常/尾部 NUL 等非法字节丢弃 1 字节重新对齐;
|
||
// 帧未收全则缓存等下次。
|
||
func parsePADFrames(conn net.Conn, remote string, buf []byte) []byte {
|
||
for len(buf) >= 4 {
|
||
length := int(buf[2])<<8 | int(buf[3])
|
||
if length <= 0 || length > 16*1024*1024 {
|
||
// 头异常(含帧间残留的尾随 NUL 等),丢弃 1 字节重新对齐
|
||
buf = buf[1:]
|
||
continue
|
||
}
|
||
if len(buf) < 4+length {
|
||
break // 帧未收全
|
||
}
|
||
hdr := buf[:4]
|
||
payload := buf[4 : 4+length]
|
||
buf = buf[4+length:]
|
||
processPADFrame(conn, remote, hdr, payload)
|
||
}
|
||
return buf
|
||
}
|
||
|
||
func processPADFrame(conn net.Conn, remote string, hdr, payload []byte) {
|
||
ts := time.Now().Format("20060102_150405.000")
|
||
raw := append(append([]byte{}, hdr...), payload...)
|
||
text := unescapeUnicode(payload)
|
||
|
||
var b strings.Builder
|
||
b.WriteString("\n" + sep + "\n")
|
||
b.WriteString(fmt.Sprintf("📥 [PAD iData 帧] 时间=%s | 来源=%s | 头=%s | 载荷=%d字节\n", ts, remote, hex2(hdr), len(payload)))
|
||
b.WriteString(sep + "\n")
|
||
b.WriteString(fmt.Sprintf("\n[原始字节 HEX] %s\n", hex2(payload)))
|
||
b.WriteString(fmt.Sprintf("[解码内容] %s\n", text))
|
||
|
||
fields := strings.Fields(text)
|
||
if len(fields) >= 1 && strings.HasPrefix(fields[0], "barcode") {
|
||
b.WriteString("\n[结构化]\n")
|
||
if len(fields) >= 2 {
|
||
b.WriteString(fmt.Sprintf(" 主条码(A) = %s\n", fields[1]))
|
||
}
|
||
if len(fields) >= 3 {
|
||
b.WriteString(fmt.Sprintf(" 次条码(B) = %s\n", fields[2]))
|
||
}
|
||
}
|
||
b.WriteString(sep + "\n")
|
||
|
||
inject := extractInjectText(text)
|
||
b.WriteString(fmt.Sprintf("[注入内容] %s\n", describeInject(inject)))
|
||
b.WriteString(sep + "\n")
|
||
|
||
// 优先注入(用户感知路径),再做落盘/打印等 I/O —— 避免文件写阻塞拖慢注入
|
||
injectText(inject, "PAD")
|
||
sendAck(conn)
|
||
|
||
fmt.Print(b.String())
|
||
appendToLog(b.String())
|
||
saveRaw(ts, remote, raw)
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// B) 新大陆手机端: [1字节 总长度 N][1字节 载荷校验和][N-2 字节 载荷]
|
||
// ---------------------------------------------------------------------------
|
||
|
||
func parseNewlandFrames(conn net.Conn, remote string, buf []byte) []byte {
|
||
for len(buf) >= 2 {
|
||
n := int(buf[0])
|
||
if n < 3 || n > 255 {
|
||
// 长度非法,丢 1 字节重新对齐
|
||
buf = buf[1:]
|
||
continue
|
||
}
|
||
if len(buf) < n {
|
||
break // 帧未收全
|
||
}
|
||
frame := buf[:n]
|
||
buf = buf[n:]
|
||
payload := frame[2:]
|
||
sum := 0
|
||
for _, c := range payload {
|
||
sum += int(c)
|
||
}
|
||
chkOK := byte(sum&0xFF) == frame[1]
|
||
processNewlandFrame(conn, remote, frame, payload, chkOK)
|
||
}
|
||
return buf
|
||
}
|
||
|
||
func processNewlandFrame(conn net.Conn, remote string, frame, payload []byte, chkOK bool) {
|
||
ts := time.Now().Format("20060102_150405.000")
|
||
text := string(payload)
|
||
|
||
chkMark := "校验通过"
|
||
if !chkOK {
|
||
chkMark = "⚠️ 校验不符(仍按原文处理)"
|
||
}
|
||
|
||
var b strings.Builder
|
||
b.WriteString("\n" + sep + "\n")
|
||
b.WriteString(fmt.Sprintf("📥 [手机 新大陆帧] 时间=%s | 来源=%s | 总长=%d | 校验=0x%02X(%s) | 载荷=%d字节\n",
|
||
ts, remote, len(frame), frame[1], chkMark, len(payload)))
|
||
b.WriteString(sep + "\n")
|
||
b.WriteString(fmt.Sprintf("\n[原始字节 HEX] %s\n", hex2(frame)))
|
||
b.WriteString(fmt.Sprintf("[解码内容] %s\n", text))
|
||
|
||
inject := strings.TrimSpace(text)
|
||
if !looksLikeText(inject) {
|
||
inject = ""
|
||
}
|
||
b.WriteString(fmt.Sprintf("[注入内容] %s\n", describeInject(inject)))
|
||
b.WriteString(sep + "\n")
|
||
|
||
// 优先注入,再做落盘/打印等 I/O
|
||
injectText(inject, "手机")
|
||
if nlak {
|
||
sendAck(conn)
|
||
}
|
||
|
||
fmt.Print(b.String())
|
||
appendToLog(b.String())
|
||
saveRaw(ts, remote, frame)
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// C) HTTP
|
||
// ---------------------------------------------------------------------------
|
||
|
||
func processHTTP(conn net.Conn, remote string, data []byte) {
|
||
ts := time.Now().Format("20060102_150405.000")
|
||
var b strings.Builder
|
||
b.WriteString("\n" + sep + "\n")
|
||
b.WriteString(fmt.Sprintf("📥 [HTTP 请求] 时间=%s | 来源=%s | %d字节\n", ts, remote, len(data)))
|
||
b.WriteString(sep + "\n")
|
||
b.WriteString(fmt.Sprintf("\n[原始字节 HEX] %s\n", hex2(data)))
|
||
b.WriteString(fmt.Sprintf("[解码内容] %s\n", string(data)))
|
||
b.WriteString(sep + "\n")
|
||
|
||
// 浏览器 GET / 或健康检查:回状态页,不注入(避免往光标打一堆 HTTP 头)
|
||
if bytes.HasPrefix(data, []byte("GET ")) {
|
||
log.Printf("🌐 收到 HTTP GET(浏览器/健康检查),回状态页,不注入")
|
||
sendHTTPPage(conn)
|
||
fmt.Print(b.String())
|
||
appendToLog(b.String())
|
||
saveRaw(ts, remote, data)
|
||
return
|
||
}
|
||
|
||
injectSrc := data
|
||
if idx := bytes.Index(data, []byte("\r\n\r\n")); idx >= 0 {
|
||
injectSrc = data[idx+4:]
|
||
}
|
||
inject := extractInjectText(string(injectSrc))
|
||
if inject != "" {
|
||
b.WriteString(fmt.Sprintf("[注入内容] %s\n%s\n", describeInject(inject), sep))
|
||
}
|
||
|
||
// 优先注入,再做落盘/打印等 I/O
|
||
injectText(inject, "HTTP")
|
||
sendHTTPOK(conn)
|
||
|
||
fmt.Print(b.String())
|
||
appendToLog(b.String())
|
||
saveRaw(ts, remote, data)
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// 兜底:无法判定模式的数据
|
||
// ---------------------------------------------------------------------------
|
||
|
||
func processRaw(conn net.Conn, remote string, data []byte) {
|
||
ts := time.Now().Format("20060102_150405.000")
|
||
var b strings.Builder
|
||
b.WriteString("\n" + sep + "\n")
|
||
b.WriteString(fmt.Sprintf("📥 [裸数据] 时间=%s | 来源=%s | %d字节\n", ts, remote, len(data)))
|
||
b.WriteString(sep + "\n")
|
||
b.WriteString(fmt.Sprintf("\n[原始字节 HEX] %s\n", hex2(data)))
|
||
b.WriteString(fmt.Sprintf("[解码内容] %s\n", string(data)))
|
||
b.WriteString(sep + "\n")
|
||
|
||
// 优先注入,再做落盘/打印等 I/O
|
||
injectText(extractInjectText(string(data)), "裸数据")
|
||
sendAck(conn)
|
||
|
||
fmt.Print(b.String())
|
||
appendToLog(b.String())
|
||
saveRaw(ts, remote, data)
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// 键盘注入 / 文本处理
|
||
// ---------------------------------------------------------------------------
|
||
|
||
// injectText 统一走键盘 HID 注入(不回车),并记录耗时以便核对节流生效。
|
||
func injectText(s, tag string) {
|
||
if s == "" || noKbd {
|
||
return
|
||
}
|
||
t0 := time.Now()
|
||
if err := sendStringAsKeyboard(s); err != nil {
|
||
log.Printf("⚠️ 键盘注入失败: %v", err)
|
||
} else {
|
||
log.Printf("⌨️ 已模拟键盘输入(%s, %d字符, 耗时%dms): %s",
|
||
tag, len([]rune(s)), time.Since(t0).Milliseconds(), s)
|
||
}
|
||
}
|
||
|
||
func describeInject(s string) string {
|
||
if s == "" {
|
||
return "(无可注入内容)"
|
||
}
|
||
if noKbd {
|
||
return s + " [已禁用注入]"
|
||
}
|
||
return s
|
||
}
|
||
|
||
// extractInjectText 统一提取要注入光标的文本:
|
||
// - PAD 的 "barcode <A> <B>" 格式 → 返回次条码 B
|
||
// - JSON(如 {"code":"..."})→ 返回常见扫码字段值
|
||
// - 其它可读文本(手机端等)→ 返回整段
|
||
// - 不可读/空 → 返回空(不注入)
|
||
func extractInjectText(text string) string {
|
||
fields := strings.Fields(text)
|
||
if len(fields) >= 3 && strings.HasPrefix(fields[0], "barcode") {
|
||
return fields[2]
|
||
}
|
||
if strings.Contains(text, "{") && strings.Contains(text, "}") {
|
||
if v := extractJSONScanValue(text); v != "" {
|
||
return v
|
||
}
|
||
}
|
||
t := strings.TrimSpace(text)
|
||
if t != "" && looksLikeText(t) {
|
||
return t
|
||
}
|
||
return ""
|
||
}
|
||
|
||
// extractJSONScanValue 从 JSON 文本中提取常见扫码字段的值。
|
||
func extractJSONScanValue(s string) string {
|
||
var m map[string]any
|
||
if err := json.Unmarshal([]byte(s), &m); err != nil {
|
||
return ""
|
||
}
|
||
for _, key := range []string{"code", "scan", "scancode", "barcode", "qr", "qrcode", "data", "value", "result", "content", "text", "sn", "id"} {
|
||
if v, ok := m[key]; ok {
|
||
switch val := v.(type) {
|
||
case string:
|
||
if val != "" {
|
||
return val
|
||
}
|
||
case float64:
|
||
return strconv.FormatFloat(val, 'f', -1, 64)
|
||
}
|
||
}
|
||
}
|
||
return ""
|
||
}
|
||
|
||
// unescapeRe 包级预编译一次(见 unescapeRe 定义)。unescapeUnicode 把载荷里的 \uXX(2 位十六进制)
|
||
// 还原成对应字符。
|
||
func unescapeUnicode(b []byte) string {
|
||
return unescapeRe.ReplaceAllStringFunc(string(b), func(s string) string {
|
||
m := unescapeRe.FindStringSubmatch(s)
|
||
if m == nil {
|
||
return s
|
||
}
|
||
c, err := strconv.ParseUint(m[1], 16, 8)
|
||
if err != nil {
|
||
return s
|
||
}
|
||
return string(rune(c))
|
||
})
|
||
}
|
||
|
||
// looksLikeText 判断是否为可打印文本(允许 \r\n\t,其余必须 IsPrint)。
|
||
func looksLikeText(s string) bool {
|
||
for _, r := range s {
|
||
if r == '\r' || r == '\n' || r == '\t' {
|
||
continue
|
||
}
|
||
if !unicode.IsPrint(r) {
|
||
return false
|
||
}
|
||
}
|
||
return true
|
||
}
|
||
|
||
// looksLikeHTTP 判断数据是否像 HTTP 请求。
|
||
func looksLikeHTTP(b []byte) bool {
|
||
for _, p := range [][]byte{[]byte("POST "), []byte("GET "), []byte("PUT "), []byte("DELETE "), []byte("HEAD "), []byte("OPTIONS ")} {
|
||
if bytes.HasPrefix(b, p) {
|
||
return true
|
||
}
|
||
}
|
||
return bytes.Contains(b, []byte("\r\nHost:")) || bytes.Contains(b, []byte("\r\nContent-Type:"))
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// 应答
|
||
// ---------------------------------------------------------------------------
|
||
|
||
// sendAck 回一个 ASCII ACK(0x06),确认已收到(PAD 需要,否则会反复重连)。
|
||
func sendAck(conn net.Conn) {
|
||
_ = conn.SetWriteDeadline(time.Now().Add(3 * time.Second))
|
||
_, _ = conn.Write([]byte{0x06})
|
||
}
|
||
|
||
// sendHTTPOK 给 HTTP 客户端回 200。
|
||
func sendHTTPOK(conn net.Conn) {
|
||
_ = conn.SetWriteDeadline(time.Now().Add(3 * time.Second))
|
||
_, _ = conn.Write([]byte("HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\nContent-Length: 2\r\nConnection: close\r\n\r\nOK"))
|
||
}
|
||
|
||
// sendHTTPPage 给浏览器 GET / 回一个状态页。
|
||
func sendHTTPPage(conn net.Conn) {
|
||
html := `<!doctype html><html><head><meta charset="utf-8"><title>扫码接收服务</title></head>` +
|
||
`<body style="font-family:sans-serif;padding:24px"><h2>扫码统一接收服务运行中</h2>` +
|
||
`<p>本机监听 <b>7757</b>:iData PAD 与新大陆手机端共用该端口,按内容自动识别两种帧格式。</p>` +
|
||
`<p>扫码数据会自动解析,并模拟键盘注入当前光标所在的窗口(微信 / 浏览器 / 记事本等)。</p></body></html>`
|
||
body := []byte(html)
|
||
_ = conn.SetWriteDeadline(time.Now().Add(3 * time.Second))
|
||
_, _ = conn.Write([]byte(fmt.Sprintf(
|
||
"HTTP/1.1 200 OK\r\nContent-Type: text/html; charset=utf-8\r\nContent-Length: %d\r\nConnection: close\r\n\r\n",
|
||
len(body))))
|
||
_, _ = conn.Write(body)
|
||
}
|
||
|
||
// trySplitHTTP 尝试从 buf 中切出一条完整 HTTP 请求(按 Content-Length 判定 body 边界)。
|
||
func trySplitHTTP(buf []byte) (req, rest []byte, ok bool) {
|
||
if !looksLikeHTTP(buf) {
|
||
return nil, nil, false
|
||
}
|
||
idx := bytes.Index(buf, []byte("\r\n\r\n"))
|
||
if idx < 0 {
|
||
return nil, nil, false
|
||
}
|
||
bodyStart := idx + 4
|
||
cl := httpContentLength(buf[:bodyStart])
|
||
if len(buf) < bodyStart+cl {
|
||
return nil, nil, false
|
||
}
|
||
end := bodyStart + cl
|
||
return buf[:end], buf[end:], true
|
||
}
|
||
|
||
func httpContentLength(header []byte) int {
|
||
s := strings.ToLower(string(header))
|
||
i := strings.Index(s, "content-length:")
|
||
if i < 0 {
|
||
return 0
|
||
}
|
||
rest := s[i+len("content-length:"):]
|
||
if j := strings.Index(rest, "\r\n"); j >= 0 {
|
||
rest = rest[:j]
|
||
}
|
||
n, err := strconv.Atoi(strings.TrimSpace(rest))
|
||
if err != nil {
|
||
return 0
|
||
}
|
||
return n
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// 工具函数
|
||
// ---------------------------------------------------------------------------
|
||
|
||
func hex2(b []byte) string { return strings.ToUpper(hex.EncodeToString(b)) }
|
||
|
||
func min(a, b int) int {
|
||
if a < b {
|
||
return a
|
||
}
|
||
return b
|
||
}
|
||
|
||
func saveRaw(ts, remote string, data []byte) {
|
||
name := filepath.Join(capturesDir(), fmt.Sprintf("raw_%s_%s.bin", ts, sanitize(remote)))
|
||
if err := os.WriteFile(name, data, 0o644); err == nil {
|
||
log.Printf("💾 原始字节已保存: %s (%d bytes)", name, len(data))
|
||
}
|
||
}
|
||
|
||
func appendToLog(report string) {
|
||
f, err := os.OpenFile(filepath.Join(capturesDir(), "analysis.log"), os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0o644)
|
||
if err != nil {
|
||
return
|
||
}
|
||
defer f.Close()
|
||
_, _ = f.WriteString(report)
|
||
}
|
||
|
||
func sanitize(s string) string {
|
||
return strings.NewReplacer(":", "_", "[", "", "]", "", " ", "").Replace(s)
|
||
}
|
||
|
||
func capturesDir() string {
|
||
if exe, err := os.Executable(); err == nil {
|
||
return filepath.Join(filepath.Dir(exe), "captures")
|
||
}
|
||
return "captures"
|
||
}
|