Go 语言中如何解压缩 zlib 流？

在 Go 语言中使用 zlib 包解压缩 zlib 流时，需要注意数据读取方式，避免将过大的缓冲区切片传递给解压缩器，否则可能会导致错误的输入缓冲区被馈送到解压缩过程中。此外，应使用 zlibreader.read() 方法逐块读取数据，而不是使用 io.copy，后者会导致缓冲区上的 eof 停止所有内容的解压缩。通过正确地读取数据和使用 zlibreader.read() 方法，可以有效地解压缩 zlib 流。

问题是什么？

我无法使用 go 的 zlib 包从 zlib 流中解码有效的压缩块。

我准备了一个 github 存储库，其中包含说明我遇到的问题的代码和数据：https://github.com/andreyst/zlib-issue。

这些块是什么？

它们是由文本游戏服务器（MUD）生成的消息。该游戏服务器以多个块发送压缩消息流，其中第一个块包含 zlib 标头，其他块不包含。

我使用名为“mcclient”的代理捕获了两个块（第一个和第二个），该代理是一个 sidecar，为不支持压缩的 MUD 客户端提供压缩。它是用 C 编写的，并使用 C zlib 库来解码压缩块。

块包含在“chunks”目录中，编号为 0 和 1。 *.in 文件包含压缩数据。 *.out 包含从 mcclient 捕获的未压缩数据。 *.log 包含 zlib 解压状态（inflate 调用的返回码）。

特殊的 all.in 块是与块 1 连接的块 0。

为什么我认为它们是有效的？

1. mcclient 使用 C 语言的 zlib 成功解压缩输入块，没有任何问题。 *.log 状态显示 0 ，这意味着 Z_OK，这意味着 zlib 术语中没有错误。
2. zlib-flate -uncompress < chunks/all.in 在 Linux 下工作没有任何错误，并解压缩为相同的内容。在 Mac OS 下，它也会解压缩到相同的内容，但会出现警告 zlib-flate: 警告：zlib 代码 -5, msg = 输入流已完成，但输出可能仍然有效 — 看起来与预期一致，因为块不包含“官方”流结束。
3. decompress.py 中的 Python 代码可以正确解压缩 all.in 和 0/1 块，没有任何问题。

go 的 zlib 有什么问题？

参见 main.go — 它尝试解压缩这些块，从 all.in 开始，然后尝试逐步解压缩块 0 和 1。

尝试解码 all.in (func all()) 有点成功，至少解压后的数据是相同的，但 zlib reader 返回错误 flate：偏移量 446 之前的输入损坏。

当尝试逐块解压的现实场景时（func stream()），zlib reader 使用预期数据解码第一个块，但返回错误 flate：偏移量 32 之前的损坏输入，并随后尝试解码块 1彻底失败。

问题

是否可以在某种适合这种场景的“流”模式下使用go的zlib包？也许我使用不当？

如果没有，解决方法是什么？另外，了解为什么会这样也很有趣——这是设计使然吗？只是还没有实施吗？我错过了什么？

正确答案

请注意，该错误表示输入后某个偏移处的数据已损坏。这是因为您从文件中读取的方式：

    buf := make([]byte, 100000)
    n, readerr := f.read(buf)
    if readerr != nil {
        log.fatalf("readerr=%v\n", readerr)
    }
    fmt.printf("read bytes, n=%v\n", n)

    buffer := bytes.newbuffer(buf)
    zlibreader, zliberr := zlib.newreader(buffer)
    if zliberr != nil {
        log.fatalf("zliberr=%v\n", zliberr)
    }

buf := make([]byte, 100000) 将制作一个 100000 字节的切片，全部为 0。但是在 all.in 的情况下，您只读取 443 字节。由于您从不缩短切片，因此读取器将在有效数据后面遇到几千个零，并得出结论它已损坏。这就是为什么你会得到输出和错误。

至于流媒体。在 tcp/udp 连接的情况下，您应该能够将 io.reader 连接传递到 zlib.newreader。为了模拟相同的情况，我在修改后的代码中使用了 io.Pipe：

package main

import (
    "bytes"
    "compress/zlib"
    "fmt"
    "io"
    "log"
    "os"

    otherzlib "github.com/4kills/go-zlib"
)

func main() {
    all()
    stream()

    // Alas it hangs :(
    // otherZlib()
}

func all() {
    fmt.Println("==== RUNNING DECOMPRESSION OF all.in")
    fmt.Println("")

    buf, readErr := os.ReadFile("./chunks/all.in")
    if readErr != nil {
        log.Fatalf("readErr=%v\n", readErr)
    }
    fmt.Printf("Read bytes, n=%v\n", len(buf))

    buffer := bytes.NewBuffer(buf)
    zlibReader, zlibErr := zlib.NewReader(buffer)
    if zlibErr != nil {
        log.Fatalf("zlibErr=%v\n", zlibErr)
    }

    out := new(bytes.Buffer)
    written, copyErr := io.Copy(out, zlibReader)
    if copyErr != nil {
        log.Printf("copyErr=%v\n", copyErr)
    }
    fmt.Printf("Written bytes, n=%v, out:\n%v\n", written, out.String())
    fmt.Println("")
}

func stream() {
    fmt.Println("==== RUNNING DECOMPRESSION OF SEPARATE CHUNKS")
    fmt.Println("")

    pRead, pWrite := io.Pipe()
    go func() {
        buf, readErr := os.ReadFile("./chunks/0.in")
        if readErr != nil {
            log.Fatalf("readErr=%v\n", readErr)
        }
        fmt.Printf("Read 0 bytes, n=%v\n", len(buf))

        written0, copy0Err := io.Copy(pWrite, bytes.NewBuffer(buf))
        if copy0Err != nil {
            log.Printf("copy0Err=%v\n", copy0Err)
        }
        fmt.Printf("Written compressed bytes, n0=%v", written0)

        buf, readErr = os.ReadFile("./chunks/1.in")
        if readErr != nil {
            log.Fatalf("read1Err=%v\n", readErr)
        }
        fmt.Printf("Read 1 bytes, n=%v\n", len(buf))

        written1, copy1Err := io.Copy(pWrite, bytes.NewBuffer(buf))
        if copy1Err != nil {
            log.Printf("copy1Err=%v\n", copy1Err)
        }
        fmt.Printf("Written compressed bytes, n1=%v", written1)

        pWrite.Close()
    }()

    zlibReader, zlibErr := zlib.NewReader(pRead)
    if zlibErr != nil {
        log.Fatalf("zlibErr=%v\n", zlibErr)
    }

    out := new(bytes.Buffer)
    written2, copy2Err := io.Copy(out, zlibReader)
    if copy2Err != nil {
        log.Printf("copy2Err=%v\n", copy2Err)
    }
    fmt.Printf("Written decompressed bytes, n0=%v, out:\n%v\n", written2, out.String())

    fmt.Println("")
}

使用此代码，我从 stream() 没有收到任何错误，但我仍然从 all() 收到 copyerr=unexpected eof 错误，看起来 all.in 最后缺少校验和数据，但我认为这是只是一次意外。

经过仔细调试，我发现我错误地传递了太大的缓冲区切片，这导致错误的输入缓冲区被馈送到解压缩。

此外，重要的是不要使用 io.copy，这会导致缓冲区上的 eof 停止所有内容，而是仅使用 zlibreader.read()，这将解压缩当前缓冲区中的所有内容。

我已经更新了代码，现在它可以按预期工作。

到这里，我们也就讲完了《Go 语言中如何解压缩 zlib 流？》的内容了。个人认为，基础知识的学习和巩固，是为了更好的将其运用到项目中，欢迎关注golang学习网公众号，带你了解更多关于的知识点！