ubgpsuite/lonetix/cpr/xz.c

355 lines
7.3 KiB
C
Executable File

// SPDX-License-Identifier: LGPL-3.0-or-later
/**
* \file cpr/xz.c
*
* Interfaces with `liblzma` and implements LZMA compressor/decompressor.
*
* \copyright The DoubleFourteen Code Forge (C) All Rights Reserved
* \author Lorenzo Cogotti
*/
#include "cpr/xz.h"
#include <assert.h>
#include <limits.h>
#include <lzma.h>
#include <stdlib.h>
#include <string.h>
// some equivalency we assume to be true
STATIC_ASSERT((lzma_check) XZCHK_NONE == LZMA_CHECK_NONE,
"Incorrect XZCHK_NONE definition");
STATIC_ASSERT((lzma_check) XZCHK_CRC32 == LZMA_CHECK_CRC32,
"Incorrect XZCHK_CRC32 definition");
STATIC_ASSERT((lzma_check) XZCHK_CRC64 == LZMA_CHECK_CRC64,
"Incorrect XZCHK_CRC64 definition");
STATIC_ASSERT((lzma_check) XZCHK_SHA256 == LZMA_CHECK_SHA256,
"Incorrect XZCHK_SHA256 definition");
typedef struct XzStmObj XzStmObj;
struct XzStmObj {
lzma_stream xz;
void *streamp;
const StmOps *ops;
unsigned bufsiz;
lzma_action action;
Boolean8 encoding;
Uint8 buf[FLEX_ARRAY]; // `bufsiz` bytes
};
#define XZ_BUFSIZ (32 * 1024)
#define XZ_EIO -2
#define XZ_EBADSTREAM -1
static Sint64 Xz_FlushData(XzStmHn hn)
{
size_t nbytes = hn->bufsiz - hn->xz.avail_out;
Sint64 n = hn->ops->Write(hn->streamp, hn->buf, nbytes);
if (n < 0)
return -1;
size_t left = nbytes - n;
memmove(hn->buf, hn->buf + n, left);
hn->xz.next_out = hn->buf + left;
hn->xz.avail_out = hn->bufsiz - left;
return n;
}
static Sint64 Xz_StmRead(void *streamp, void *buf, size_t nbytes)
{
return Xz_Read((XzStmHn) streamp, buf, nbytes);
}
static Sint64 Xz_StmWrite(void *streamp, const void *buf, size_t nbytes)
{
return Xz_Write((XzStmHn) streamp, buf, nbytes);
}
static Sint64 Xz_StmTell(void *streamp)
{
XzStmHn hn = (XzStmHn) streamp;
return hn->encoding ? hn->xz.total_out : hn->xz.total_in;
}
static Judgement Xz_StmFinish(void *streamp)
{
return Xz_Finish((XzStmHn) streamp);
}
static void Xz_StmClose(void *streamp)
{
Xz_Close((XzStmHn) streamp);
}
static const StmOps xz_stmOps = {
Xz_StmRead,
Xz_StmWrite,
NULL,
Xz_StmTell,
Xz_StmFinish,
Xz_StmClose
};
static const StmOps xz_ncStmOps = {
Xz_StmRead,
Xz_StmWrite,
NULL,
Xz_StmTell,
Xz_StmFinish,
NULL
};
const StmOps *const Xz_StmOps = &xz_stmOps;
const StmOps *const Xz_NcStmOps = &xz_ncStmOps;
static THREAD_LOCAL XzRet xz_errStat = LZMA_OK;
static void Xz_SetErrStat(XzRet ret)
{
xz_errStat = ret;
}
XzRet Xz_GetErrStat(void)
{
return xz_errStat;
}
const char *Xz_ErrorString(XzRet ret)
{
assert(ret != LZMA_NO_CHECK);
assert(ret != LZMA_GET_CHECK);
switch (ret) {
case XZ_EIO: return "I/O error";
case XZ_EBADSTREAM: return "Bad stream operation";
case LZMA_OK: return "Success";
case LZMA_UNSUPPORTED_CHECK: return "Cannot calculate the integrity check";
case LZMA_MEM_ERROR: return "Memory allocation failure";
case LZMA_MEMLIMIT_ERROR: return "Memory usage limit was reached";
case LZMA_FORMAT_ERROR: return "Unrecognized file format";
case LZMA_OPTIONS_ERROR: return "Invalid or unsupported options";
case LZMA_DATA_ERROR: return "Data is corrupt";
case LZMA_BUF_ERROR: return "No progress is possible";
case LZMA_PROG_ERROR: return "Programming error";
default: return "Unknown error";
}
}
XzStmHn Xz_OpenCompress(void *streamp,
const StmOps *ops,
const XzEncOpts *opts)
{
const XzEncOpts default_opts = {
6,
FALSE,
XZCHK_CRC32,
XZ_BUFSIZ
};
if (!opts)
opts = &default_opts;
Uint32 compression = MIN(opts->compress, 9);
Uint32 presets = 0;
if (opts->extreme)
presets |= LZMA_PRESET_EXTREME;
size_t bufsiz = MIN(opts->bufsiz, INT_MAX);
if (bufsiz == 0)
bufsiz = XZ_BUFSIZ;
XzStmObj *hn = (XzStmObj *) malloc(offsetof(XzStmObj, buf[bufsiz]));
if (!hn) {
Xz_SetErrStat(LZMA_MEM_ERROR);
return NULL;
}
memset(&hn->xz, 0, sizeof(hn->xz));
hn->streamp = streamp;
hn->ops = ops;
hn->bufsiz = bufsiz;
hn->action = LZMA_RUN; // ...actually ignored for encoding buffers
hn->encoding = TRUE;
lzma_ret err = lzma_easy_encoder(
&hn->xz,
compression | presets,
(lzma_check) opts->chk
);
if (err != LZMA_OK) {
Xz_SetErrStat(err);
free(hn);
return NULL;
}
hn->xz.next_out = hn->buf;
hn->xz.avail_out = hn->bufsiz;
Xz_SetErrStat(LZMA_OK);
return hn;
}
XzStmHn Xz_OpenDecompress(void *streamp,
const StmOps *ops,
const XzDecOpts *opts)
{
const XzDecOpts default_opts = {
U64_C(0xffffffffffffffff),
FALSE,
FALSE,
XZ_BUFSIZ
};
if (!opts)
opts = &default_opts;
Uint32 mask = LZMA_CONCATENATED;
if (opts->no_concat)
mask &= ~LZMA_CONCATENATED;
#ifdef LZMA_IGNORE_CHECK
if (opts->no_chk)
mask |= LZMA_IGNORE_CHECK;
#endif
size_t bufsiz = MIN(opts->bufsiz, INT_MAX);
if (bufsiz == 0)
bufsiz = XZ_BUFSIZ;
XzStmObj *hn = (XzStmObj *) malloc(offsetof(XzStmObj, buf[bufsiz]));
if (!hn) {
Xz_SetErrStat(LZMA_MEM_ERROR);
return NULL;
}
memset(&hn->xz, 0, sizeof(hn->xz));
hn->streamp = streamp;
hn->ops = ops;
hn->action = LZMA_RUN; // used to force LZMA_FINISH on EOF
hn->bufsiz = bufsiz;
hn->encoding = FALSE;
lzma_ret err = lzma_auto_decoder(&hn->xz, opts->memlimit, mask);
if (err != LZMA_OK) {
Xz_SetErrStat(err);
free(hn);
return NULL;
}
Xz_SetErrStat(LZMA_OK);
return hn;
}
Sint64 Xz_Read(XzStmHn hn, void *buf, size_t nbytes)
{
if (hn->encoding) {
Xz_SetErrStat(XZ_EBADSTREAM);
return -1;
}
XzRet ret = LZMA_OK;
hn->xz.next_out = (Uint8 *) buf;
hn->xz.avail_out = nbytes;
while (hn->xz.avail_out > 0) {
if (hn->xz.avail_in == 0) {
Sint64 n = hn->ops->Read(hn->streamp, hn->buf, hn->bufsiz);
if (n <= 0) {
if (n < 0) {
ret = XZ_EIO;
break;
}
hn->action = LZMA_FINISH;
}
hn->xz.next_in = hn->buf;
hn->xz.avail_in = n;
}
lzma_ret err = lzma_code(&hn->xz, hn->action);
if (err == LZMA_STREAM_END)
break; // NOTE: shouldn't happen for a stream to end before EOF...
if (err != LZMA_OK) {
ret = err;
break;
}
}
Xz_SetErrStat(ret);
return nbytes - hn->xz.avail_out;
}
Sint64 Xz_Write(XzStmHn hn, const void *buf, size_t nbytes)
{
if (!hn->encoding) {
Xz_SetErrStat(XZ_EBADSTREAM);
return -1;
}
XzRet ret = LZMA_OK;
hn->xz.next_in = (Uint8 *) buf;
hn->xz.avail_in = nbytes;
while (hn->xz.avail_in > 0) {
if (hn->xz.avail_out == 0) {
Sint64 n = Xz_FlushData(hn);
if (n < -1) ret = XZ_EIO;
break; // short-write
}
// Disregard `hn->action` on write, we will flush upon Xz_Finish()
lzma_ret err = lzma_code(&hn->xz, LZMA_RUN);
if (err != LZMA_OK) {
ret = err;
break;
}
}
Xz_SetErrStat(ret);
return nbytes - hn->xz.avail_in;
}
Judgement Xz_Finish(XzStmHn hn)
{
if (!hn->encoding) {
Xz_SetErrStat(XZ_EBADSTREAM);
return NG;
}
lzma_ret err;
do {
// Flush LZMA to disk
err = lzma_code(&hn->xz, LZMA_FINISH);
if (err != LZMA_STREAM_END && err != LZMA_OK) {
Xz_SetErrStat(err);
return NG;
}
if (Xz_FlushData(hn) == -1) {
Xz_SetErrStat(XZ_EIO);
return NG;
}
} while (err != LZMA_STREAM_END);
if (hn->xz.avail_out != hn->bufsiz) {
Xz_SetErrStat(LZMA_BUF_ERROR);
return NG;
}
return OK;
}
void Xz_Close(XzStmHn hn)
{
if (hn->ops->Close)
hn->ops->Close(hn->streamp);
lzma_end(&hn->xz);
free(hn);
}