RPM Package Manager, CVS Repository
http://rpm5.org/cvs/
____________________________________________________________________________
Server: rpm5.org Name: Jeff Johnson
Root: /v/rpm/cvs Email: j...@rpm5.org
Module: rpm Date: 01-Jun-2017 19:39:56
Branch: rpm-5_4 Handle: 2017060117395600
Added files: (Branch: rpm-5_4)
rpm/rpmio tzstd.c
Modified files: (Branch: rpm-5_4)
rpm/rpmio Makefile.am rpmmacro.h zstio.c
Log:
- zstd: add test program.
Summary:
Revision Changes Path
1.293.2.84 +4 -1 rpm/rpmio/Makefile.am
2.56.4.12 +11 -10 rpm/rpmio/rpmmacro.h
1.1.2.1 +649 -0 rpm/rpmio/tzstd.c
1.1.2.2 +40 -28 rpm/rpmio/zstio.c
____________________________________________________________________________
patch -p0 <<'@@ .'
Index: rpm/rpmio/Makefile.am
============================================================================
$ cvs diff -u -r1.293.2.83 -r1.293.2.84 Makefile.am
--- rpm/rpmio/Makefile.am 30 May 2017 23:48:23 -0000 1.293.2.83
+++ rpm/rpmio/Makefile.am 1 Jun 2017 17:39:56 -0000 1.293.2.84
@@ -20,7 +20,7 @@
microjson.c mongoc-counters.defs
EXTRA_PROGRAMS = rpmcpio rpmdpkg rpmtar rpmz
-EXTRA_PROGRAMS += bdes duk thtml tinv tkey tmacro tmq tpw turg
+EXTRA_PROGRAMS += bdes duk thtml tinv tkey tmacro tmq tpw turg tzstd
noinst_PROGRAMS = tjsmn tmqtt
EXTRA_PROGRAMS += bsdiff bspatch fanotify pcrsed rpmborg rpmcurl \
@@ -679,6 +679,9 @@
turg_SOURCES = turg.c
turg_LDADD = $(RPMIO_LDADD_COMMON)
+tzstd_SOURCES = tzstd.c
+tzstd_LDADD = $(RPMIO_LDADD_COMMON)
+
github_SOURCES = tjson.c
github_CFLAGS = -Wall -Werror -std=gnu99 -O2 -DJSMN_GITHUB
github_LDADD = -lcurl
@@ .
patch -p0 <<'@@ .'
Index: rpm/rpmio/rpmmacro.h
============================================================================
$ cvs diff -u -r2.56.4.11 -r2.56.4.12 rpmmacro.h
--- rpm/rpmio/rpmmacro.h 6 Jul 2016 14:25:43 -0000 2.56.4.11
+++ rpm/rpmio/rpmmacro.h 1 Jun 2017 17:39:56 -0000 2.56.4.12
@@ -180,16 +180,17 @@
void rpmFreeMacros(MacroContext mc);
typedef enum rpmCompressedMagic_e {
- COMPRESSED_NOT = 0, /*!< not compressed */
- COMPRESSED_OTHER = 1, /*!< gzip can handle */
- COMPRESSED_BZIP2 = 2, /*!< bzip2 can handle */
- COMPRESSED_ZIP = 3, /*!< unzip can handle */
- COMPRESSED_LZOP = 4, /*!< lzop can handle */
- COMPRESSED_LZMA = 5, /*!< lzma can handle */
- COMPRESSED_XZ = 6, /*!< xz can handle */
- COMPRESSED_LRZIP = 7, /*!< lrzip can handle */
- COMPRESSED_LZIP = 8, /*!< lzip can handle */
- COMPRESSED_7ZIP = 9, /*!< 7zip can handle */
+ COMPRESSED_NOT = 0, /*!< not compressed */
+ COMPRESSED_OTHER = 1, /*!< gzip can handle */
+ COMPRESSED_BZIP2 = 2, /*!< bzip2 can handle */
+ COMPRESSED_ZIP = 3, /*!< unzip can handle */
+ COMPRESSED_LZOP = 4, /*!< lzop can handle */
+ COMPRESSED_LZMA = 5, /*!< lzma can handle */
+ COMPRESSED_XZ = 6, /*!< xz can handle */
+ COMPRESSED_LRZIP = 7, /*!< lrzip can handle */
+ COMPRESSED_LZIP = 8, /*!< lzip can handle */
+ COMPRESSED_7ZIP = 9, /*!< 7zip can handle */
+ COMPRESSED_ZSTD = 10, /*!< 7zip can handle */
} rpmCompressedMagic;
/**
@@ .
patch -p0 <<'@@ .'
Index: rpm/rpmio/tzstd.c
============================================================================
$ cvs diff -u -r0 -r1.1.2.1 tzstd.c
--- /dev/null 2017-06-01 19:34:23.000000000 +0200
+++ tzstd.c 2017-06-01 19:39:56.447439530 +0200
@@ -0,0 +1,649 @@
+/**
+ * Copyright 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the license found in the
+ * LICENSE-examples file in the root directory of this source tree.
+ */
+
+#include "system.h"
+
+#include "rpmio_internal.h"
+#include <rpmlog.h>
+#include <rpmmacro.h>
+#include <poptIO.h>
+#include <argv.h>
+#include <yarn.h>
+#define PEEK(_bolt) yarnPeekLock(_bolt)
+
+#if defined(WITH_ZSTD)
+#include <zstd.h> // presumes zstd library is installed
+#endif
+
+#include "debug.h"
+
+static int _debug;
+
+int _rpmzsf_debug = -1;
+
+#define SPEW(_fmt, ...) \
+ if ((zsf && ZSF_ISSET(DEBUG)) || _rpmzsf_debug || _rpmio_debug) \
+ fprintf(stderr, _fmt, __VA_ARGS__)
+
+#undef COMPRESSOR
+
+typedef struct rpmzsf_s * rpmzsf;
+struct rpmzsf_s {
+ struct rpmioItem_s _item; /*!< usage mutex and pool identifier. */
+ const char * path; /*!> open path. */
+ const char * fmode;
+ unsigned flags;
+#define RPMZSF_FLAGS_NONE (0)
+#define RPMZSF_FLAGS_DEBUG (1<<0)
+#define RPMZSF_FLAGS_DECOMPRESS (1<<1)
+#define ZSF_ISSET(_foo) (zsf->flags & RPMZSF_FLAGS_##_foo)
+ int fdno;
+ int oflags; /*!< open flags. */
+ int omode; /*!< open mode. */
+
+ size_t nb;
+ size_t nr;
+ size_t nw;
+ int level;
+
+ FILE * ifp;
+ FILE * ofp;
+ size_t nib; /* can always read one full block */
+ void * ib;
+ size_t nob; /* can always flush a full block */
+ void * ob;
+ ZSTD_CStream * cstream;
+ ZSTD_DStream * dstream;
+ ZSTD_inBuffer zib;
+ ZSTD_outBuffer zob;
+};
+
+static void rpmzsfDump(const char * msg, rpmzsf zsf)
+{
+ if (msg) fprintf(stderr, "========================== %s\n", msg);
+ if (zsf) {
+#define PRINT(_fmt, _foo) \
+ { fprintf(stderr, "%25s: %"#_fmt"\n", #_foo, zsf->_foo); }
+ PRINT(s, path);
+ PRINT(s, fmode);
+ PRINT(x, flags);
+ PRINT(d, fdno);
+ PRINT(x, oflags);
+ PRINT(o, omode);
+
+ PRINT(d, level);
+ PRINT(zu, nb);
+
+ if (zsf->cstream) {
+ PRINT(p, cstream);
+ PRINT(p, ofp);
+ PRINT(p, zob.dst);
+ PRINT(p, ob);
+ PRINT(zu, zob.size);
+ PRINT(zu, nob);
+ PRINT(zu, zob.pos);
+ PRINT(zu, nw);
+ }
+
+ if (zsf->dstream) {
+ PRINT(p, dstream);
+ PRINT(p, ifp);
+ PRINT(p, zib.src);
+ PRINT(p, ib);
+ PRINT(zu, zib.size);
+ PRINT(zu, nib);
+ PRINT(zu, zib.pos);
+ PRINT(zu, nr);
+ }
+#undef PRINT
+
+ }
+}
+
+#define rpmzsfLink(_zsf) \
+ ((rpmzsf)rpmioLinkPoolItem((rpmioItem)(_zsf), __FUNCTION__, __FILE__,
__LINE__))
+
+#define rpmzsfFree(_zsf) \
+ ((rpmzsf)rpmioFreePoolItem((rpmioItem)(_zsf), __FUNCTION__, __FILE__,
__LINE__))
+/* =============================================================== */
+static char * rpmzsfDbug(void *_zsf, char *b, size_t nb)
+{
+ rpmzsf zsf = (rpmzsf) _zsf;
+ size_t len = strlen(b);
+ char * be = b + len;
+ rpmioItem item = (rpmioItem) zsf;
+ long use;
+
+ if (zsf && (use = PEEK(item->use)) > 0) {
+ int colorize = isatty(fileno(stderr));
+#define ANSI_BRIGHT_BLUE "\x1b[34;1m"
+#define ANSI_RESET "\x1b[0m"
+ *be++ = '\n';
+ if (colorize) be = stpcpy(be, ANSI_BRIGHT_BLUE);
+ be += sprintf(be, "========================== zsf(%p) use %ld\n",
+ zsf, use);
+#define PRINT(_fmt, _foo) \
+ { be += sprintf(be, "%25s: %"#_fmt"\n", #_foo, zsf->_foo); }
+ PRINT(s, path);
+ PRINT(s, fmode);
+ PRINT(x, flags);
+ PRINT(d, fdno);
+ PRINT(x, oflags);
+ PRINT(o, omode);
+
+ PRINT(d, level);
+ PRINT(zu, nb);
+
+ if (zsf->cstream) {
+ PRINT(p, cstream);
+ PRINT(p, ofp);
+ PRINT(p, zob.dst);
+ PRINT(p, ob);
+ PRINT(zu, zob.size);
+ PRINT(zu, nob);
+ PRINT(zu, zob.pos);
+ PRINT(zu, nw);
+ }
+
+ if (zsf->dstream) {
+ PRINT(p, dstream);
+ PRINT(p, ifp);
+ PRINT(p, zib.src);
+ PRINT(p, ib);
+ PRINT(zu, zib.size);
+ PRINT(zu, nib);
+ PRINT(zu, zib.pos);
+ PRINT(zu, nr);
+ }
+
+#undef PRINT
+ be--;
+ if (colorize) be = stpcpy(be, ANSI_RESET);
+ *be = '\0';
+ }
+ return b;
+}
+
+static void rpmzsfInit(void *_zsf)
+{
+}
+
+
+static void rpmzsfFini(void *_zsf)
+{
+ rpmzsf zsf = (rpmzsf) _zsf;
+ if (zsf) {
+ if (zsf->path)
+ zsf->path = _free(zsf->path);
+ if (zsf->fmode)
+ zsf->fmode = _free(zsf->fmode);
+ zsf->flags = 0;
+ zsf->fdno = -1;
+ zsf->oflags = 0;
+ zsf->omode = 0;
+
+ zsf->nb = 0;
+ zsf->nr = 0;
+ zsf->nw = 0;
+ zsf->level = 0;
+
+ if (zsf->ifp && fileno(zsf->ifp) > 2)
+ fclose(zsf->ifp);
+ zsf->ifp = NULL;
+ if (zsf->ib)
+ zsf->ib = _free(zsf->ib);
+ zsf->nib = 0;
+
+ if (zsf->ofp && fileno(zsf->ofp) > 2)
+ fclose(zsf->ofp);
+ zsf->ofp = NULL;
+ if (zsf->ob)
+ zsf->ob = _free(zsf->ob);
+ zsf->nob = 0;
+
+ if (zsf->cstream)
+ ZSTD_freeCStream(zsf->cstream);
+ zsf->cstream = NULL;
+ if (zsf->dstream)
+ ZSTD_freeDStream(zsf->dstream);
+ zsf->dstream = NULL;
+
+ zsf->zib.src = NULL;
+ zsf->zib.pos = 0;
+ zsf->zib.size = 0;
+ zsf->zob.dst = NULL;
+ zsf->zob.pos = 0;
+ zsf->zob.size = 0;
+ }
+}
+
+RPMIOPOOL_MODULE(zsf)
+
+static rpmzsf rpmzsfNew(const char *path, const char *fmode, int fdno,
unsigned flags)
+{
+ rpmzsf zsf = rpmzsfGetPool(_rpmzsfPool);
+assert(fmode != NULL); /* XXX return NULL instead? */
+
+ const char * s = fmode;
+ int c;
+ int oflags = 0;
+ int omode = 0644;
+ int level = 3; /* XXX zstd permits 1-19 (default: 3) */
+
+ switch ((c = *s++)) {
+ case 'a':
+ oflags = O_WRONLY | O_CREAT | O_APPEND;
+ break;
+ case 'w':
+ oflags = O_WRONLY | O_CREAT | O_TRUNC;
+ break;
+ case 'r':
+ oflags = O_RDONLY;
+ break;
+ }
+
+ while ((c = *s++) != 0) {
+ switch (c) {
+ case '.':
+ break;
+ case '+':
+ oflags &= ~(O_RDONLY|O_WRONLY);
+ oflags |= O_RDWR;
+ continue;
+ break;
+ case 'c': /* XXX no cancel */
+ continue;
+ break;
+ case 'm': /* XXX mmap */
+ continue;
+ break;
+ case 'e': /* O_CLOEXEC */
+ oflags |= O_CLOEXEC;
+ continue;
+ break;
+ case 'n': /* XXX O_NONBLOCK */
+ oflags |= O_NONBLOCK;
+ continue;
+ break;
+ case 't': /* XXX O_TRUNC */
+ continue;
+ break;
+ case 'x':
+ oflags |= O_EXCL;
+ continue;
+ break;
+ case '?':
+ flags |= RPMZSF_FLAGS_DEBUG;
+ continue;
+ break;
+ default:
+ if (c >= (int)'0' && c <= (int)'9') {
+ level = strtol(s-1, (char **)&s, 10);
+assert(level >= 1 && level <= 19);
+ }
+ continue;
+ break;
+ }
+ break;
+ }
+
+ zsf->path = xstrdup(path);
+ zsf->fmode = xstrdup(fmode);
+ zsf->fdno = fdno;
+ zsf->flags = flags;
+
+ zsf->oflags = oflags;
+ zsf->omode = omode;
+
+ zsf->level = level;
+
+ if (ZSF_ISSET(DECOMPRESS)) { /* decompress */
+ zsf->dstream = ZSTD_createDStream();
+ if (zsf->dstream == NULL) {
+ fprintf(stderr, "ZSTD_createDStream() error \n");
+ exit(10);
+ }
+ /*
+ * In more complex scenarios, a file may consist of multiple
+ * appended frames (ex : pzstd).
+ * The following example decompresses only the first frame.
+ * It is compatible with other provided streaming examples.
+ */
+ zsf->nb = ZSTD_initDStream(zsf->dstream);
+ if (ZSTD_isError(zsf->nb)) {
+ fprintf(stderr, "ZSTD_initDStream() error : %s \n",
+ ZSTD_getErrorName(zsf->nb));
+ exit(11); /* XXX */
+ }
+ zsf->nib = ZSTD_CStreamInSize();
+ zsf->ib = xmalloc(zsf->nib);
+#ifdef NOTYET
+ zsf->nob = BUFSIZ;
+ zsf->ob = xmalloc(zsf->nob);
+#else
+ zsf->nob = ZSTD_CStreamOutSize();
+ zsf->ob = xmalloc(zsf->nob);
+#endif
+ } else { /* compress */
+ zsf->cstream = ZSTD_createCStream();
+ if (zsf->cstream == NULL) {
+ fprintf(stderr, "ZSTD_createCStream() error \n");
+ exit(10);
+ }
+ zsf->nb = ZSTD_initCStream(zsf->cstream, level);
+ if (ZSTD_isError(zsf->nb)) {
+ fprintf(stderr, "ZSTD_initCStream() error : %s \n",
+ ZSTD_getErrorName(zsf->nb));
+ exit(11); /* XXX */
+ }
+#ifdef NOTYET
+ zsf->nib = BUFSIZ;
+ zsf->ib = xmalloc(zsf->nib);
+#else
+ zsf->nib = ZSTD_CStreamInSize();
+ zsf->ib = xmalloc(zsf->nib);
+#endif
+ zsf->nob = ZSTD_CStreamOutSize();
+ zsf->ob = xmalloc(zsf->nob);
+ }
+
+ return rpmzsfLink(zsf);
+}
+
+static int rpmzsfFlush(rpmzsf zsf)
+{
+ int rc = -2;
+
+ if (ZSF_ISSET(DECOMPRESS)) { /* decompress */
+assert(zsf->dstream);
+ } else { /* compress */
+assert(zsf->cstream);
+ /* close frame */
+ zsf->zob.dst = zsf->ob;
+ zsf->zob.size = zsf->nob;
+ zsf->zob.pos = 0;
+ /* XXX nremain != 0 on small output buffers. Loop. */
+ size_t nremain = ZSTD_flushStream(zsf->cstream, &zsf->zob);
+ if (nremain) {
+fprintf(stderr, "not fully flushed");
+ rc = -1;
+ } else {
+ zsf->nw = fwrite(zsf->ob, 1, zsf->zob.pos, zsf->ofp);
+assert(zsf->nw == zsf->zob.pos);
+SPEW("<--\tfwrite(%p, 1, %zu, %p) nw %zd\n", zsf->ob, zsf->zob.pos,
zsf->ofp, zsf->nw);
+ rc = 0;
+ }
+ }
+
+SPEW("<--\t%s(%p) rc %d\n", __FUNCTION__, zsf, rc);
+ return rc;
+}
+
+static int rpmzsfClose(rpmzsf zsf)
+{
+ int rc = -2;
+
+SPEW("-->\t%s(%p)\n", __FUNCTION__, zsf);
+ if (ZSF_ISSET(DECOMPRESS)) { /* decompress */
+assert(zsf->dstream);
+ } else { /* compress */
+assert(zsf->cstream);
+ /* close frame */
+ zsf->zob.dst = zsf->ob;
+ zsf->zob.size = zsf->nob;
+ zsf->zob.pos = 0;
+ /* XXX nremain != 0 on small output buffers. Loop. */
+ size_t nremain = ZSTD_endStream(zsf->cstream, &zsf->zob);
+ if (nremain) {
+fprintf(stderr, "not fully flushed");
+ rc = -1;
+ } else {
+ zsf->nw = fwrite(zsf->ob, 1, zsf->zob.pos, zsf->ofp);
+assert(zsf->nw == zsf->zob.pos);
+SPEW("<--\tfwrite(%p, 1, %zu, %p) nw %zd\n", zsf->ob, zsf->zob.pos,
zsf->ofp, zsf->nw);
+ rc = 0;
+ }
+ rpmzsfFini(zsf); /* XXX */
+ }
+
+SPEW("<--\t%s(%p) rc %d\n", __FUNCTION__, zsf, rc);
+ return rc;
+}
+
+/*==============================================================*/
+static ssize_t rpmzsfRead(rpmzsf zsf, void *b, size_t nb)
+{
+ ssize_t rc = 0;
+
+SPEW("-->\t%s(%p,%p[%zd])\n", __FUNCTION__, zsf, b, nb);
+
+ zsf->zob.dst = b;
+ zsf->zob.size = nb;
+ zsf->zob.pos = 0;
+ rc = 0;
+ while (zsf->zob.pos < zsf->zob.size) {
+ if (zsf->zib.pos >= zsf->zib.size) {
+ zsf->nr = fread(zsf->ib, 1, zsf->nib, zsf->ifp);
+ if (zsf->nr <= 0) {
+ rc = zsf->nr;
+ break;
+ }
+ zsf->zib.src = zsf->ib;
+ zsf->zib.size = zsf->nr;
+ zsf->zib.pos = 0;
+ }
+ while (zsf->zib.pos < zsf->zib.size) {
+ zsf->nb = ZSTD_decompressStream(zsf->dstream, &zsf->zob, &zsf->zib);
+SPEW("\t%s: nb %8zd\tzob %zu:%zu\tzib %zu:%zu\n", __FUNCTION__, zsf->nb,
zsf->zob.pos, zsf->zob.size, zsf->zib.pos, zsf->zib.size);
+ /* zsf->nb : size of next compressed block */
+ if (ZSTD_isError(zsf->nb)) {
+ fprintf(stderr, "ZSTD_decompressStream() error : %s \n",
+ ZSTD_getErrorName(zsf->nb));
+ rc = -1;
+ break;
+ }
+ if (zsf->zob.pos >= zsf->zob.size)
+ break;
+ }
+ }
+ rc = (rc >= 0 ? (ssize_t)zsf->zob.pos : rc);
+
+SPEW("<--\t%s(%p,%p[%zd]) rc %ld\n", __FUNCTION__, zsf, b, nb, rc);
+ return rc;
+}
+
+static ssize_t rpmzsfWrite(rpmzsf zsf, void *b, size_t nb)
+{
+ ssize_t rc = -2;
+
+SPEW("-->\t%s(%p,%p[%zd])\n", __FUNCTION__, zsf, b, nb);
+ zsf->zib.src = b;
+ zsf->zib.size = nb;
+ zsf->zib.pos = 0;
+ rc = 0;
+ while (zsf->zib.pos < zsf->zib.size) {
+
+ zsf->zob.dst = zsf->ob;
+ zsf->zob.size = zsf->nob;
+ zsf->zob.pos = 0;
+
+ zsf->nb = ZSTD_compressStream(zsf->cstream, &zsf->zob, &zsf->zib);
+SPEW("\t%s: nb %8zd\tzob %zu:%zu\tzib %zu:%zu\n", "compress", zsf->nb,
zsf->zob.pos, zsf->zob.size, zsf->zib.pos, zsf->zib.size);
+ /* zsf->nb is guaranteed to be <= ZSTD_CStreamInSize() */
+ if (ZSTD_isError(zsf->nb)) {
+ fprintf(stderr, "ZSTD_compressStream() error : %s \n",
+ ZSTD_getErrorName(zsf->nb));
+ rc = -1;
+ break;
+ }
+
+ if (zsf->zob.pos > 0) {
+ zsf->nw = fwrite(zsf->ob, 1, zsf->zob.pos, zsf->ofp);
+assert(zsf->nw == zsf->zob.pos);
+SPEW("<--\tfwrite(%p, 1, %zu, %p) nw %zd\n", zsf->ob, zsf->zob.pos,
zsf->ofp, zsf->nw);
+ }
+
+ }
+
+ rc = (zsf->zib.pos == zsf->zib.size ? (ssize_t) zsf->zib.pos : -1);
+
+SPEW("<--\t%s(%p,%p[%zd]) rc %ld\n", __FUNCTION__, zsf, b, nb, rc);
+ return rc;
+}
+
+static int rpmzsfSeek(void * _zsf, _libio_pos_t pos, int whence)
+{
+ int rc = -2;
+ return rc;
+}
+
+static rpmzsf rpmzsfOpen(const char * path, const char * fmode, int fdno,
unsigned flags)
+{
+ return rpmzsfNew(path, fmode, fdno, flags);
+}
+
+static rpmzsf rpmzsfFdopen(void * _fdno, const char * fmode)
+{
+#ifdef NOTYET
+ int fdno = (int)((long)_fdno); /* XXX hack */
+ return rpmzsfNew(NULL, fmode, fdno, 0);
+#else
+ return NULL;
+#endif
+}
+
+/*==============================================================*/
+static ssize_t rpmzsfCopyAll(rpmzsf zsf)
+{
+ ssize_t rc = -2;
+
+SPEW("==> %s(%p) oflags 0x%x\n", __FUNCTION__, zsf, zsf->oflags);
+
+ if (ZSF_ISSET(DECOMPRESS)) { /* decompress */
+assert(zsf->dstream);
+SPEW("\tDecompressing ... eof %d\n", feof(zsf->ifp));
+ do {
+ zsf->nr = rpmzsfRead(zsf, zsf->ob, zsf->nob);
+ if (zsf->nr <= 0) {
+ rc = zsf->nr;
+ break;
+ }
+ zsf->nw = fwrite(zsf->ob, 1, zsf->nr, zsf->ofp);
+assert(zsf->nw == zsf->nr);
+SPEW("<--\tfwrite(%p, 1, %zu, %p) nw %zd\n", zsf->ob, zsf->nr, zsf->ofp,
zsf->nw);
+ if (zsf->nw <= 0) {
+ rc = zsf->nw;
+ break;
+ }
+ } while (zsf->zib.pos < zsf->zib.size);
+ } else { /* compress */
+assert(zsf->cstream);
+SPEW("\tCompressing ... eof %d\n", feof(zsf->ifp));
+ rc = 0;
+ while (!feof(zsf->ifp)) {
+ zsf->nr = fread(zsf->ib, 1, zsf->nib, zsf->ifp);
+SPEW("<--\tfread(%p, 1, %zu, %p) nr %zd eof %d\n", zsf->ib, zsf->nib,
zsf->ifp, zsf->nr, feof(zsf->ifp));
+ if (zsf->nr <= 0) {
+ rc = zsf->nr;
+ break;
+ }
+ zsf->nw = rpmzsfWrite(zsf, zsf->ib, zsf->nr);
+ if (zsf->nw <= 0) {
+ rc = zsf->nw;
+ break;
+ }
+ }
+ if (!rc)
+ rc = rpmzsfClose(zsf);
+ }
+
+rpmzsfDump(__FUNCTION__, zsf);
+SPEW("<== %s(%p) rc %ld\n", __FUNCTION__, zsf, rc);
+ return rc;
+}
+
+static int compressFile(const char *ifn, const char *fmode)
+{
+ rpmzsf zsf = rpmzsfOpen(ifn, fmode, -1, RPMZSF_FLAGS_NONE);
+ zsf->ifp = fopen(ifn, "rb");;
+SPEW("<--\tfopen(\"%s\", \"%s\") ifp %p\n", ifn, "rb", zsf->ifp);
+assert(zsf->ifp);
+ const char * ofn = rpmGetPath(ifn, ".zst", NULL);
+ zsf->ofp = fopen(ofn, "wb");;
+SPEW("<--\tfopen(\"%s\", \"%s\") ofp %p\n", ofn, "wb", zsf->ofp);
+assert(zsf->ofp);
+ ofn = _free(ofn);
+ int rc = rpmzsfCopyAll(zsf);
+ rc = rpmzsfClose(zsf); /* XXX elsewhere */
+ zsf = rpmzsfFree(zsf);
+ return rc;
+}
+
+static int decompressFile(const char *ifn, const char *fmode)
+{
+ rpmzsf zsf = rpmzsfOpen(ifn, fmode, -1, RPMZSF_FLAGS_DECOMPRESS);
+ zsf->ifp = fopen(ifn, "rb");;
+SPEW("<--\tfopen(\"%s\", \"%s\") ifp %p\n", ifn, "rb", zsf->ifp);
+assert(zsf->ifp);
+ zsf->ofp = stdout;
+ int rc = rpmzsfCopyAll(zsf);
+ zsf = rpmzsfFree(zsf);
+ return rc;
+}
+
+/*==============================================================*/
+#if !defined(POPT_BIT_XOR)
+#define POPT_BIT_XOR (POPT_ARG_VAL|POPT_ARGFLAG_XOR)
+#endif
+
+static struct poptOption rpmzsfOptionsTable[] = {
+ { "debug", 'd', POPT_ARG_VAL|POPT_ARGFLAG_DOC_HIDDEN, &_debug, 1,
+ NULL, NULL },
+
+ { NULL, '\0', POPT_ARG_INCLUDE_TABLE, rpmioOflagsPoptTable, 0,
+ N_("Open(2) flags:"), NULL },
+
+ { NULL, '\0', POPT_ARG_INCLUDE_TABLE, rpmioAllPoptTable, 0,
+ N_("Common options for all rpmio executables:"), NULL },
+
+ POPT_AUTOALIAS
+ POPT_AUTOHELP
+ POPT_TABLEEND
+};
+
+int
+main(int argc, char *argv[])
+{
+ poptContext con = rpmioInit(argc, argv, rpmzsfOptionsTable);
+ ARGV_t av = poptGetArgs(con);
+ int ac = argvCount(av);
+ int ec = 0;
+
+ if (ac != 1) {
+ printf("wrong arguments\n");
+ printf("usage:\n");
+ printf("%s FILE\n", argv[0]);
+ return 1;
+ }
+ const char * ifn = xstrdup(av[0]);
+
+#ifdef NOTYET
+ oflags = rpmioOflags;
+#endif
+
+ switch (2) {
+ case 1: ec = compressFile(ifn, "w3?.zstio"); break;
+ case 2: ec = decompressFile(ifn, "r?.zstio"); break;
+ }
+
+ ifn = _free(ifn);
+
+ con = rpmioFini(con);
+
+ return ec;
+}
@@ .
patch -p0 <<'@@ .'
Index: rpm/rpmio/zstio.c
============================================================================
$ cvs diff -u -r1.1.2.1 -r1.1.2.2 zstio.c
--- rpm/rpmio/zstio.c 30 May 2017 23:48:23 -0000 1.1.2.1
+++ rpm/rpmio/zstio.c 1 Jun 2017 17:39:56 -0000 1.1.2.2
@@ -5,8 +5,11 @@
#include "system.h"
+#include <stddef.h> /* size_t */
+#include <stdint.h>
+
#if defined(HAVE_STDBOOL_H)
-#include <stdbool.h>
+# include <stdbool.h>
#else
typedef enum { true = 1, false = 0 } bool;
#endif
@@ -15,8 +18,6 @@
#include <rpmmacro.h>
#include <rpmcb.h>
-#if defined(WITH_ZSTD)
-
#include <zstd.h>
#include "debug.h"
@@ -38,8 +39,11 @@
unsigned char win[RSYNC_WIN]; /* window elements */
} * rsync_state;
-typedef void * gzFile; /* XXX */
+/* Should zstflush be called only after RSYNC_WIN boundaries? */
+static int enable_rsync = 1;
+/* =============================================================== */
+typedef struct gzFile_s *gzFile;
typedef struct zstdFILE_s {
gzFile gz; /* gzFile is a pointer */
struct rsync_state_s rs;
@@ -47,57 +51,66 @@
uint32_t nb; /* bytes pending for sync */
} * zstdFILE; /* like FILE, to use with star */
-
#ifdef __cplusplus
GENfree(zstdFILE)
#endif /* __cplusplus */
-/* Should zstflush be called only after RSYNC_WIN boundaries? */
-static int enable_rsync = 1;
+struct gzFile_s {
+ FILE *const ifp;
+ size_t const nib;
+ void *const ib;
+ FILE *const ofp;
+ size_t const nob;
+ void *const ob;
+ ZSTD_DStream *const zds;
+ ZSTD_CStream *const zcs;
+};
/* =============================================================== */
static
-const char * zsferror(gzFile gz, int *errnum)
+const char * rpmzsfError(gzFile gz, int *errnum)
{
return "";
}
static
-gzFile zsfopen(const char *path, const char * fmode, int fdno)
+gzFile rpmzsfOpen(const char *path, const char * fmode, int fdno)
{
return NULL;
}
static
-int zsfread(gzFile gz, void *buf, unsigned count)
+int rpmzsfRead(gzFile gz, const void *buf, size_t len)
{
int rc = -1;
+
return rc;
}
static
-int zsfwrite(gzFile gz, const void *buf, unsigned count)
+int rpmzsfWrite(gzFile gz, void *buf, unsigned len)
{
int rc = -1;
+
return rc;
}
static
-int zsfseek(gzFile gz, off_t offset, int whence)
+int rpmzsfSeek(gzFile gz, off_t offset, int whence)
{
int rc = -1;
return rc;
}
static
-int zsfclose(gzFile gz)
+int rpmzsfClose(gzFile gz)
{
int rc = -1;
return rc;
}
static
-int zsfflush(gzFile gz, int flush)
+int rpmzsfFlush(gzFile gz)
{
int rc = -1;
return rc;
@@ -245,20 +258,20 @@
if (!sync_hint(zsf, buf[i]))
continue;
n = i + 1 - (begin - buf);
- rc = zsfwrite(zsf->gz, (const char *)begin, (unsigned)n);
+ rc = rpmzsfWrite(zsf->gz, (void *)begin, (unsigned)n);
if (rc < 0)
return (n_written ? n_written : rc);
n_written += rc;
if (rc < (ssize_t)n)
return n_written;
begin += n;
- rc = zsfflush(zsf->gz, 0);
+ rc = rpmzsfFlush(zsf->gz);
if (rc < 0)
return (n_written ? n_written : rc);
}
if (begin < buf + len) {
n = len - (begin - buf);
- rc = zsfwrite(zsf->gz, (const char *)begin, (unsigned)n);
+ rc = rpmzsfWrite(zsf->gz, (void *)begin, (unsigned)n);
if (rc < 0)
return (n_written ? n_written : rc);
n_written += rc;
@@ -295,7 +308,7 @@
mode_t mode = (fmode && fmode[0] == 'w' ? O_WRONLY : O_RDONLY);
zsf = (zstdFILE) xcalloc(1, sizeof(*zsf));
- zsf->gz = zsfopen(path, fmode, -1);
+ zsf->gz = rpmzsfOpen(path, fmode, -1);
if (zsf->gz == NULL) {
zsf = _free(zsf);
return NULL;
@@ -318,7 +331,7 @@
fdno = fdSetFdno(fd, -1); /* XXX skip the fdio close */
if (fdno < 0) return NULL;
zsf = (zstdFILE) xcalloc(1, sizeof(*zsf));
- zsf->gz = zsfopen(NULL, fmode, fdno);
+ zsf->gz = rpmzsfOpen(NULL, fmode, fdno);
if (zsf->gz == NULL) {
zsf = _free(zsf);
return NULL;
@@ -335,7 +348,7 @@
zstdFILE zsf;
zsf = (zstdFILE) zstFileno(fd);
if (zsf == NULL) return -2;
- return zsfflush(zsf->gz, 0);
+ return rpmzsfFlush(zsf->gz);
}
/* =============================================================== */
@@ -351,11 +364,11 @@
if (zsf == NULL) return -2; /* XXX can't happen */
fdstat_enter(fd, FDSTAT_READ);
- rc = zsfread(zsf->gz, buf, (unsigned)count);
+ rc = rpmzsfRead(zsf->gz, buf, (unsigned)count);
DBGIO(fd, (stderr, "==>\tzstRead(%p,%p,%u) rc %lx %s\n", cookie, buf,
(unsigned)count, (unsigned long)rc, fdbg(fd)));
if (rc < 0) {
int zerror = 0;
- fd->errcookie = zsferror(zsf->gz, &zerror);
+ fd->errcookie = rpmzsfError(zsf->gz, &zerror);
#ifdef DYING
if (zerror == Z_ERRNO) {
fd->syserrno = errno;
@@ -386,11 +399,11 @@
if (enable_rsync)
rc = rsyncable_write(zsf, (const unsigned char *)buf, (unsigned)count);
else
- rc = zsfwrite(zsf->gz, (void *)buf, (unsigned)count);
+ rc = rpmzsfWrite(zsf->gz, (void *)buf, (unsigned)count);
DBGIO(fd, (stderr, "==>\tzstWrite(%p,%p,%u) rc %lx %s\n", cookie, buf,
(unsigned)count, (unsigned long)rc, fdbg(fd)));
if (rc < (ssize_t)count) {
int zerror = 0;
- fd->errcookie = zsferror(zsf->gz, &zerror);
+ fd->errcookie = rpmzsfError(zsf->gz, &zerror);
#ifdef DYING
if (zerror == Z_ERRNO) {
fd->syserrno = errno;
@@ -421,11 +434,11 @@
if (zsf == NULL) return -2; /* XXX can't happen */
fdstat_enter(fd, FDSTAT_SEEK);
- rc = zsfseek(zsf->gz, (long)p, whence);
+ rc = rpmzsfSeek(zsf->gz, (long)p, whence);
DBGIO(fd, (stderr, "==>\tzstSeek(%p,%ld,%d) rc %lx %s\n", cookie, (long)p,
whence, (unsigned long)rc, fdbg(fd)));
if (rc < 0) {
int zerror = 0;
- fd->errcookie = zsferror(zsf->gz, &zerror);
+ fd->errcookie = rpmzsfError(zsf->gz, &zerror);
#ifdef DYING
if (zerror == Z_ERRNO) {
fd->syserrno = errno;
@@ -448,7 +461,7 @@
if (zsf == NULL) return -2; /* XXX can't happen */
fdstat_enter(fd, FDSTAT_CLOSE);
- rc = zsfclose(zsf->gz);
+ rc = rpmzsfClose(zsf->gz);
zsf->gz = NULL;
zsf = _free(zsf);
@@ -483,4 +496,3 @@
FDIO_t zstio = &zstio_s;
-#endif /* WITH_ZLIB */
@@ .
______________________________________________________________________
RPM Package Manager http://rpm5.org
CVS Sources Repository rpm-cvs@rpm5.org
