compress data using win32 api in go

main.go
import (
    "compress/zlib"
    "compress/gzip"
    "syscall"
    "unsafe"
)
78 chars
7 lines

main.go
func compressDataZlib(data []byte) ([]byte, error) {
    var compressedData []byte
    var outSize uint32

    const (
        CHUNK_SIZE = 1024
        Z_NO_FLUSH = 0
        Z_FINISH  = 4
        Z_OK = 0
        Z_STREAM_END = 1
    )

    zlibDll, err := syscall.LoadDLL("zlib.dll")
    if err != nil {
        return nil, err
    }

    deflateInit2, err := zlibDll.FindProc("deflateInit2_")
    if err != nil {
        return nil, err
    }

    deflate, err := zlibDll.FindProc("deflate")
    if err != nil {
        return nil, err
    }

    var stream struct {
        next_in *byte
        avail_in uint32
        total_in uint32

        next_out *byte
        avail_out uint32
        total_out uint32

        msg *byte
        state *byte

        zalloc uintptr
        zfree uintptr
        opaque uintptr

        data_type int
        adler uint32
        reserved uint32
    }

    const (
        Z_DEFAULT_COMPRESSION = -1
        Z_DEFLATED = 8
        MAX_WBITS = 15
        DEF_MEM_LEVEL = 8
    )

    compressedData = make([]byte, CHUNK_SIZE)
    stream.next_in = &data[0]
    stream.avail_in = uint32(len(data))
    stream.next_out = &compressedData[0]
    stream.avail_out = uint32(len(compressedData))

    // Initialize the compression stream
    ret, _, _ := deflateInit2.Call(
        uintptr(unsafe.Pointer(&stream)),
        uintptr(Z_DEFAULT_COMPRESSION),
        uintptr(Z_DEFLATED),
        uintptr(MAX_WBITS),
        uintptr(DEF_MEM_LEVEL),
        uintptr(0),
    )

    if ret != Z_OK {
        return nil, fmt.Errorf("deflateInit2 failed with return code %d", ret)
    }

    for stream.avail_in > 0 {
        if stream.avail_out == 0 {
            compressedData = append(compressedData, make([]byte, CHUNK_SIZE)...)
            stream.next_out = &compressedData[len(compressedData)-len(stream.next_out)]
            stream.avail_out = uint32(CHUNK_SIZE)
        }

        // Compress the input data
        ret, _, _ = deflate.Call(
            uintptr(unsafe.Pointer(&stream)),
            uintptr(Z_NO_FLUSH),
        )

        if ret != Z_OK {
            return nil, fmt.Errorf("deflate failed with return code %d", ret)
        }
    }

    // Flush out any remaining data
    for ret == Z_OK {
        if stream.avail_out == 0 {
            compressedData = append(compressedData, make([]byte, CHUNK_SIZE)...)
            stream.next_out = &compressedData[len(compressedData)-len(stream.next_out)]
            stream.avail_out = uint32(CHUNK_SIZE)
        }

        ret, _, _ = deflate.Call(
            uintptr(unsafe.Pointer(&stream)),
            uintptr(Z_FINISH),
        )
    }

    if ret != Z_STREAM_END {
        return nil, fmt.Errorf("deflate failed to finish with return code %d", ret)
    }

    // Release the compression stream
    _, _, _ = syscall.Syscall(deflate.Release(), 1, uintptr(unsafe.Pointer(&stream)), 0, 0)
    
    outSize = stream.total_out
    return compressedData[:outSize], nil
}
2969 chars
118 lines

main.go
func compressDataGzip(data []byte) ([]byte, error) {
    var compressedData []byte
    var outSize uint32
    var hdr [10]byte

    const (
        CHUNK_SIZE = 1024
        Z_NO_FLUSH = 0
        Z_FINISH  = 4
        Z_OK = 0
        Z_STREAM_END = 1
    )

    zlibDll, err := syscall.LoadDLL("zlib.dll")
    if err != nil {
        return nil, err
    }

    gzipInit2, err := zlibDll.FindProc("gzopen_w")
    if err != nil {
        return nil, err
    }

    gzip, err := zlibDll.FindProc("gzwrite")
    if err != nil {
        return nil, err
    }

    gzclose, err := zlibDll.FindProc("gzclose")
    if err != nil {
        return nil, err
    }

    // Initialize the gzip stream
    gzfd, _, _ := gzipInit2.Call(
        uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr("dummy"))),
        uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr("wb"))),
    )

    compressedData = make([]byte, CHUNK_SIZE)
    outPos := 0

    // Compress the input data
    for i := 0; i < len(data); i += CHUNK_SIZE {
        chunk := data[i:utils.Min(i+CHUNK_SIZE, len(data))]
        ret, _, _ := gzip.Call(
            gzfd,
            uintptr(unsafe.Pointer(&chunk[0])),
            uintptr(len(chunk)),
        )

        if ret == 0 {
            compressedData = append(compressedData, make([]byte, CHUNK_SIZE)...)
            ret, _, _ = gzip.Call(
                gzfd,
                uintptr(unsafe.Pointer(&chunk[0])),
                uintptr(len(chunk)),
            )

            if ret == 0 {
                return nil, fmt.Errorf("gzwrite failed to write data")
            }
        }

        outPos += int(ret)
    }

    // Flush out any remaining data
    ret, _, _ := gzip.Call(
        gzfd,
        uintptr(unsafe.Pointer(nil)),
        uintptr(0),
    )

    if ret == 0 {
        return nil, fmt.Errorf("gzwrite failed to flush data")
    }

    // Close the gzip stream
    _, _, _ = syscall.Syscall(gzclose.Addr(), 1, gzfd, 0, 0)

    // Append the gzip header and footer to the compressed data
    compressedData = append(hdr[:], compressedData[:outPos]...)
    compressedData = append(compressedData, make([]byte, 8)...)

    // Write the gzip header
    hdr[0] = 0x1f // magic header
    hdr[1] = 0x8b // magic header
    hdr[2] = 8 // compression method
    hdr[3] = 0 // flags
    hdr[4] = byte((uint32(time.Now().Unix()) >> 0) & 0xff)
    hdr[5] = byte((uint32(time.Now().Unix()) >> 8) & 0xff)
    hdr[6] = byte((uint32(time.Now().Unix()) >> 16) & 0xff)
    hdr[7] = byte((uint32(time.Now().Unix()) >> 24) & 0xff)
    hdr[8] = 2 // OS

    outSize = uint32(len(compressedData))
    return compressedData[:outSize], nil
}
2647 chars
100 lines