Golang高效实现内网文件传输的实战指南(含完整源码)

func ReadFrame(r *bufio.Reader) (Header, []byte, error) {
	var h Header
	hdr := make([]byte, HeaderSize)
	// 读取完整头部数据
	if _, err := io.ReadFull(r, hdr); err != nil {
		return h, nil, err
	}
	// 解析头部各字段
	h.Magic = binary.BigEndian.Uint32(hdr[0:4])
	// 检查魔数是否匹配
	if h.Magic != MagicValue {
		return h, nil, errors.New("invalid magic")
	}
	h.Version = hdr[4]
	h.Flags = hdr[5]
	h.Cmd = binary.BigEndian.Uint16(hdr[6:8])
	h.StreamID = binary.BigEndian.Uint32(hdr[8:12])
	h.PayloadLen = binary.BigEndian.Uint32(hdr[12:16])
	// 读取负载数据
	payload := make([]byte, h.PayloadLen)
	if _, err := io.ReadFull(r, payload); err != nil {
		return h, nil, err
	}

	// 验证校验和
	expectedChecksum := binary.BigEndian.Uint16(hdr[4:6]) // Checksum在头部的第5-6字节
	if expectedChecksum != 0 { // 如果校验和不为0，则验证
		actualChecksum := calculateChecksum(payload)
		if actualChecksum != expectedChecksum {
			return h, nil, errors.New("checksum mismatch")
		}
	}

	return h, payload, nil
}

func sendFileZeroCopy(conn net.Conn, path string) error {
	if runtime.GOOS != "linux" {
		return fmt.Errorf("sendfile zero-copy only supported on Linux")
	}

	f, err := os.Open(path)
	if err != nil {
		return err
	}
	defer f.Close()

	tcpConn, ok := conn.(*net.TCPConn)
	if !ok {
		return fmt.Errorf("connection is not TCP")
	}

	fileConn, err := tcpConn.File()
	if err != nil {
		return err
	}
	defer fileConn.Close()

	fi, _ := f.Stat()
	off := int64(0)
	size := fi.Size()

	for off < size {
		n, err := unix.Sendfile(int(fileConn.Fd()), int(f.Fd()), &off, int(size-off))
		if err != nil {
			return err
		}
		if n == 0 {
			break
		}
		off += int64(n)
	}
	return nil
}

func writeChunk(f *os.File, offset int64, data []byte) error {
	// 在指定位置写入数据
	_, err := f.WriteAt(data, offset)
	return err
}

func computeChecksum(data []byte) uint32 {
    return crc32.ChecksumIEEE(data)
}

// 代码有简写 以源码为主
ln, _ := net.Listen("tcp", ":9000")
for {
    conn, _ := ln.Accept()
    go handleConn(conn)
}

// 根据命令类型进行分发处理
switch hdr.Cmd {
case frame.CmdAuth:
	// 处理认证请求
	var req fsproto.AuthReq
	if err := proto.Unmarshal(payload, &req); err != nil {
		logger.Error("Failed to unmarshal AuthReq", zap.Error(err))
		return
	}
	handleAuth(conn, req)

case frame.CmdList:
	// 处理列出目录请求
	var req fsproto.ListReq
	if err := proto.Unmarshal(payload, &req); err != nil {
		logger.Error("Failed to unmarshal ListReq", zap.Error(err))
		return
	}
	handleList(conn, req)

case frame.CmdOpen:
	// 处理打开文件请求
	var req fsproto.OpenReq
	if err := proto.Unmarshal(payload, &req); err != nil {
		logger.Error("Failed to unmarshal OpenReq", zap.Error(err))
		return
	}
	handleOpen(conn, req)

case frame.CmdRead:
	// 处理读取文件请求
	var req fsproto.ReadReq
	if err := proto.Unmarshal(payload, &req); err != nil {
		logger.Error("Failed to unmarshal ReadReq", zap.Error(err))
		return
	}
	handleRead(conn, req)

case frame.CmdWrite:
	// 处理写入文件请求
	var req fsproto.WriteReq
	if err := proto.Unmarshal(payload, &req); err != nil {
		logger.Error("Failed to unmarshal WriteReq", zap.Error(err))
		return
	}
	handleWrite(conn, req)

default:
	ogger.Warn("Unknown command", zap.Uint16("cmd", hdr.Cmd))
}

authReq := &fsproto.AuthReq{
    Token: "secret_token",
    ClientId: "client_001",
}
payload,_ := proto.Marshal(authReq)
frame.WriteFrame(conn, frame.Header{Version:1, Cmd:frame.CmdAuth}, payload)

// 打开文件
frame.WriteFrame(conn, frame.Header{Cmd: frame.CmdOpen}, openReqBytes)
// 循环读取文件块
for offset := int64(0); !eof; offset += chunkSize {
    readReq := &fsproto.ReadReq{Handle: handle, Offset: offset, Length: chunkSize}
    payload,_ := proto.Marshal(readReq)
    frame.WriteFrame(conn, frame.Header{Cmd: frame.CmdRead}, payload)
    ...
}