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 20:38:25
Branch: rpm-5_4 Handle: 20170530234823154202
Added files: (Branch: rpm-5_4)
rpm/rpmio zstdio.c
Modified files: (Branch: rpm-5_4)
rpm CHANGES INSTALL
rpm/lib psm.c
rpm/rpmio .cvsignore Makefile.am librpmio.vers rpmio.c
rpmio.h tzstd.c
Removed files: (Branch: rpm-5_4)
rpm/rpmio zstio.c
Log:
- zstd: fix: rename from "zstio" to "zstdio".
Summary:
Revision Changes Path
1.3501.2.568+1 -0 rpm/CHANGES
2.134.2.33 +1 -0 rpm/INSTALL
2.399.2.28 +1 -1 rpm/lib/psm.c
1.41.2.18 +1 -0 rpm/rpmio/.cvsignore
1.293.2.85 +1 -1 rpm/rpmio/Makefile.am
2.199.2.84 +11 -1 rpm/rpmio/librpmio.vers
1.230.2.55 +21 -18 rpm/rpmio/rpmio.c
1.97.2.22 +1 -1 rpm/rpmio/rpmio.h
1.1.2.2 +227 -227 rpm/rpmio/tzstd.c
1.1.2.1 +498 -0 rpm/rpmio/zstdio.c
1.1 +0 -498 rpm/rpmio/zstio.c
____________________________________________________________________________
patch -p0 <<'@@ .'
Index: rpm/CHANGES
============================================================================
$ cvs diff -u -r1.3501.2.567 -r1.3501.2.568 CHANGES
--- rpm/CHANGES 30 May 2017 19:18:37 -0000 1.3501.2.567
+++ rpm/CHANGES 1 Jun 2017 18:38:24 -0000 1.3501.2.568
@@ -1,4 +1,5 @@
5.4.17 -> 5.4.18:
+ - jbj: zstd: fix: rename from "zstio" to "zstdio".
- jbj: zstd: stub in zstd compression framework.
- jbj: msqio: abstract out the AIO queue (AIOQ_t for now).
- jbj: rpmaio: stub in an AIO aiocb pool.
@@ .
patch -p0 <<'@@ .'
Index: rpm/INSTALL
============================================================================
$ cvs diff -u -r2.134.2.32 -r2.134.2.33 INSTALL
--- rpm/INSTALL 10 May 2017 16:57:56 -0000 2.134.2.32
+++ rpm/INSTALL 1 Jun 2017 18:38:24 -0000 2.134.2.33
@@ -48,6 +48,7 @@
ZLib optional 1.2 1.2.8 http://www.zlib.net/
Bzip2 optional 1.0 1.0.6 http://www.bzip.org/
XZ Utils [3] optional 4.999.9 5.2.2 http://tukaani.org/xz/
+Zstd optional 1.2.0 1.2.0 https://github.com/facebook/zstd
File/magic [4] optional 4.00 5.28 ftp://ftp.astron.com/pub/file/
GNU gettext optional 0.18 0.19.8.1
http://www.gnu.org/software/gettext/
GNU iconv optional 1.11 1.11
http://www.gnu.org/software/libiconv/
@@ .
patch -p0 <<'@@ .'
Index: rpm/lib/psm.c
============================================================================
$ cvs diff -u -r2.399.2.27 -r2.399.2.28 psm.c
--- rpm/lib/psm.c 30 May 2017 19:18:39 -0000 2.399.2.27
+++ rpm/lib/psm.c 1 Jun 2017 18:38:24 -0000 2.399.2.28
@@ -2916,7 +2916,7 @@
if (!strcmp(payload_compressor, "xz"))
te = stpcpy(te, ".xzdio");
if (!strcmp(payload_compressor, "zstd"))
- te = stpcpy(te, ".zstio");
+ te = stpcpy(te, ".zstdio");
payload_compressor = _free(payload_compressor);
he->tag = RPMTAG_PAYLOADFORMAT;
@@ .
patch -p0 <<'@@ .'
Index: rpm/rpmio/.cvsignore
============================================================================
$ cvs diff -u -r1.41.2.17 -r1.41.2.18 .cvsignore
--- rpm/rpmio/.cvsignore 20 May 2017 19:25:27 -0000 1.41.2.17
+++ rpm/rpmio/.cvsignore 1 Jun 2017 18:38:25 -0000 1.41.2.18
@@ -82,6 +82,7 @@
ttcl
ttpm
turg
+tzstd
twitter
y.tab.h
cppcheck.out
@@ .
patch -p0 <<'@@ .'
Index: rpm/rpmio/Makefile.am
============================================================================
$ cvs diff -u -r1.293.2.84 -r1.293.2.85 Makefile.am
--- rpm/rpmio/Makefile.am 1 Jun 2017 17:39:56 -0000 1.293.2.84
+++ rpm/rpmio/Makefile.am 1 Jun 2017 18:38:25 -0000 1.293.2.85
@@ -259,7 +259,7 @@
xzdio.c \
yajl.c \
yarn.c \
- zstio.c
+ zstdio.c
librpmio_la_LDFLAGS = -no-undefined -release $(LT_CURRENT).$(LT_REVISION)
if HAVE_LD_VERSION_SCRIPT
@@ .
patch -p0 <<'@@ .'
Index: rpm/rpmio/librpmio.vers
============================================================================
$ cvs diff -u -r2.199.2.83 -r2.199.2.84 librpmio.vers
--- rpm/rpmio/librpmio.vers 30 May 2017 19:18:38 -0000 2.199.2.83
+++ rpm/rpmio/librpmio.vers 1 Jun 2017 18:38:25 -0000 2.199.2.84
@@ -1025,7 +1025,17 @@
yarnRelease;
yarnTwist;
yarnWaitFor;
- zstio;
+ _rpmzstd_debug;
+ _rpmzstdPool;
+ zstdio;
+ rpmzstdClose;
+ rpmzstdFdopen;
+ rpmzstdFlush;
+ rpmzstdNew;
+ rpmzstdOpen;
+ rpmzstdRead;
+ rpmzstdSeek;
+ rpmzstdWrite;
bcon_append;
bcon_append_ctx;
bcon_append_ctx_init;
@@ .
patch -p0 <<'@@ .'
Index: rpm/rpmio/rpmio.c
============================================================================
$ cvs diff -u -r1.230.2.54 -r1.230.2.55 rpmio.c
--- rpm/rpmio/rpmio.c 30 May 2017 19:18:38 -0000 1.230.2.54
+++ rpm/rpmio/rpmio.c 1 Jun 2017 18:38:25 -0000 1.230.2.55
@@ -218,8 +218,8 @@
sprintf(be, "XZD %p fdno %d", fps->fp, fps->fdno);
#endif
#if defined(WITH_ZSTD)
- } else if (fps->io == zstio) {
- sprintf(be, "ZST %p fdno %d", fps->fp, fps->fdno);
+ } else if (fps->io == zstdio) {
+ sprintf(be, "ZSTD %p fdno %d", fps->fp, fps->fdno);
#endif
#if defined(WITH_MQ) || defined(WITH_MSQ)
} else if (fps->io == msqio) {
@@ -2430,7 +2430,7 @@
#endif
#if defined(WITH_ZSTD)
- if (fdGetIo(fd) == zstio) {
+ if (fdGetIo(fd) == zstdio) {
errstr = (const char *)fd->errcookie;
} else
#endif
@@ -2798,7 +2798,7 @@
FD_t Fdopen(FD_t ofd, const char *fmode)
{
- char stdio[20], other[20], zstdio[40+1];
+ char stdio[20], other[20], zfmode[40+1];
const char *end = NULL;
FDIO_t iof = NULL;
FD_t fd = ofd;
@@ -2813,8 +2813,8 @@
cvtfmode(fmode, stdio, sizeof(stdio), other, sizeof(other), &end, NULL);
if (stdio[0] == '\0')
return NULL;
- zstdio[0] = '\0';
- (void) stpcpy( stpcpy(zstdio, stdio), other);
+ zfmode[0] = '\0';
+ (void) stpcpy( stpcpy(zfmode, stdio), other);
if (end == NULL && other[0] == '\0')
return fd;
@@ -2825,25 +2825,25 @@
#if defined(WITH_ZLIB)
} else if (!strcmp(end, "gzdio")) {
iof = gzdio;
- fd = iof->_fdopen(fd, zstdio);
+ fd = iof->_fdopen(fd, zfmode);
#endif
#if defined(WITH_BZIP2)
} else if (!strcmp(end, "bzdio")) {
iof = bzdio;
- fd = iof->_fdopen(fd, zstdio);
+ fd = iof->_fdopen(fd, zfmode);
#endif
#if defined(WITH_XZ)
} else if (!strcmp(end, "lzdio")) {
iof = lzdio;
- fd = iof->_fdopen(fd, zstdio);
+ fd = iof->_fdopen(fd, zfmode);
} else if (!strcmp(end, "xzdio")) {
iof = xzdio;
- fd = iof->_fdopen(fd, zstdio);
+ fd = iof->_fdopen(fd, zfmode);
#endif
#if defined(WITH_ZSTD)
- } else if (!strcmp(end, "zstio")) {
- iof = zstio;
- fd = iof->_fdopen(fd, zstdio);
+ } else if (!strcmp(end, "zstdio")) {
+ iof = zstdio;
+ fd = iof->_fdopen(fd, zfmode);
#endif
#if defined(WITH_MQ) || defined(WITH_MSQ)
} else if (!strcmp(end, "msqio")) {
@@ -2861,7 +2861,7 @@
fprintf(stderr, "*** Fdopen fpio fp %p\n", (void *)fp);
if (fp == NULL)
return NULL;
- /* XXX gzdio/bzdio use fp for private data */
+ /* XXX gzdio/bzdio/zstdio use fp for private data */
if (fdGetFp(fd) == NULL)
fdSetFp(fd, fp);
fdPush(fd, fpio, fp, fdno); /* Push fpio onto stack */
@@ -2873,7 +2873,7 @@
if (*end == '\0') {
#if defined(WITH_ZLIB)
iof = gzdio;
- fd = iof->_fdopen(fd, zstdio);
+ fd = iof->_fdopen(fd, zfmode);
#endif
}
}
@@ -3039,7 +3039,7 @@
return (*xzdio->_flush) ((void *)fd);
#endif
#if defined(WITH_ZSTD)
- if (vh && fdGetIo(fd) == zstio && zstio->_flush != NULL)
+ if (vh && fdGetIo(fd) == zstdio && zstdio->_flush != NULL)
return (*bzdio->_flush) ((void *)fd);
#endif
#if defined(WITH_MQ) || defined(WITH_MSQ)
@@ -3084,9 +3084,9 @@
i--; /* XXX fdio under xzdio always has fdno == -1 */
#endif
#if defined(WITH_ZSTD)
- } else if (fps->io == zstio) {
+ } else if (fps->io == zstdio) {
ec = (fd->syserrno || fd->errcookie != NULL) ? -1 : 0;
- i--; /* XXX fdio under zstio always has fdno == -1 */
+ i--; /* XXX fdio under zstdio always has fdno == -1 */
#endif
#if defined(WITH_MQ) || defined(WITH_MSQ)
} else if (fps->io == msqio) {
@@ -3798,6 +3798,9 @@
RPMIOPOOL_FREE(aio)
RPMIOPOOL_FREE(msq)
+#ifdef NOTYET
+ RPMIOPOOL_FREE(zstd)
+#endif
RPMIOPOOL_FREE(html)
RPMIOPOOL_FREE(mire)
@@ .
patch -p0 <<'@@ .'
Index: rpm/rpmio/rpmio.h
============================================================================
$ cvs diff -u -r1.97.2.21 -r1.97.2.22 rpmio.h
--- rpm/rpmio/rpmio.h 30 May 2017 19:18:38 -0000 1.97.2.21
+++ rpm/rpmio/rpmio.h 1 Jun 2017 18:38:25 -0000 1.97.2.22
@@ -713,7 +713,7 @@
/**
*/
-extern FDIO_t zstio;
+extern FDIO_t zstdio;
/**
*/
@@ .
patch -p0 <<'@@ .'
Index: rpm/rpmio/tzstd.c
============================================================================
$ cvs diff -u -r1.1.2.1 -r1.1.2.2 tzstd.c
--- rpm/rpmio/tzstd.c 1 Jun 2017 17:39:56 -0000 1.1.2.1
+++ rpm/rpmio/tzstd.c 1 Jun 2017 18:38:25 -0000 1.1.2.2
@@ -24,24 +24,24 @@
static int _debug;
-int _rpmzsf_debug = -1;
+int _rpmzstd_debug = -1;
#define SPEW(_fmt, ...) \
- if ((zsf && ZSF_ISSET(DEBUG)) || _rpmzsf_debug || _rpmio_debug) \
+ if ((zstd && ZSTD_ISSET(DEBUG)) || _rpmzstd_debug || _rpmio_debug) \
fprintf(stderr, _fmt, __VA_ARGS__)
#undef COMPRESSOR
-typedef struct rpmzsf_s * rpmzsf;
-struct rpmzsf_s {
+typedef struct rpmzstd_s * rpmzstd;
+struct rpmzstd_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)
+#define RPMZSTD_FLAGS_NONE (0)
+#define RPMZSTD_FLAGS_DEBUG (1<<0)
+#define RPMZSTD_FLAGS_DECOMPRESS (1<<1)
+#define ZSTD_ISSET(_foo) (zstd->flags &
RPMZSTD_FLAGS_##_foo)
int fdno;
int oflags; /*!< open flags. */
int omode; /*!< open mode. */
@@ -63,12 +63,12 @@
ZSTD_outBuffer zob;
};
-static void rpmzsfDump(const char * msg, rpmzsf zsf)
+static void rpmzstdDump(const char * msg, rpmzstd zstd)
{
if (msg) fprintf(stderr, "========================== %s\n", msg);
- if (zsf) {
+ if (zstd) {
#define PRINT(_fmt, _foo) \
- { fprintf(stderr, "%25s: %"#_fmt"\n", #_foo, zsf->_foo); }
+ { fprintf(stderr, "%25s: %"#_fmt"\n", #_foo, zstd->_foo); }
PRINT(s, path);
PRINT(s, fmode);
PRINT(x, flags);
@@ -79,7 +79,7 @@
PRINT(d, level);
PRINT(zu, nb);
- if (zsf->cstream) {
+ if (zstd->cstream) {
PRINT(p, cstream);
PRINT(p, ofp);
PRINT(p, zob.dst);
@@ -90,7 +90,7 @@
PRINT(zu, nw);
}
- if (zsf->dstream) {
+ if (zstd->dstream) {
PRINT(p, dstream);
PRINT(p, ifp);
PRINT(p, zib.src);
@@ -105,30 +105,30 @@
}
}
-#define rpmzsfLink(_zsf) \
- ((rpmzsf)rpmioLinkPoolItem((rpmioItem)(_zsf), __FUNCTION__, __FILE__,
__LINE__))
+#define rpmzstdLink(_zstd) \
+ ((rpmzstd)rpmioLinkPoolItem((rpmioItem)(_zstd), __FUNCTION__, __FILE__,
__LINE__))
-#define rpmzsfFree(_zsf) \
- ((rpmzsf)rpmioFreePoolItem((rpmioItem)(_zsf), __FUNCTION__, __FILE__,
__LINE__))
+#define rpmzstdFree(_zstd) \
+ ((rpmzstd)rpmioFreePoolItem((rpmioItem)(_zstd), __FUNCTION__, __FILE__,
__LINE__))
/* =============================================================== */
-static char * rpmzsfDbug(void *_zsf, char *b, size_t nb)
+static char * rpmzstdDbug(void *_zstd, char *b, size_t nb)
{
- rpmzsf zsf = (rpmzsf) _zsf;
+ rpmzstd zstd = (rpmzstd) _zstd;
size_t len = strlen(b);
char * be = b + len;
- rpmioItem item = (rpmioItem) zsf;
+ rpmioItem item = (rpmioItem) zstd;
long use;
- if (zsf && (use = PEEK(item->use)) > 0) {
+ if (zstd && (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);
+ be += sprintf(be, "========================== zstd(%p) use %ld\n",
+ zstd, use);
#define PRINT(_fmt, _foo) \
- { be += sprintf(be, "%25s: %"#_fmt"\n", #_foo, zsf->_foo); }
+ { be += sprintf(be, "%25s: %"#_fmt"\n", #_foo, zstd->_foo); }
PRINT(s, path);
PRINT(s, fmode);
PRINT(x, flags);
@@ -139,7 +139,7 @@
PRINT(d, level);
PRINT(zu, nb);
- if (zsf->cstream) {
+ if (zstd->cstream) {
PRINT(p, cstream);
PRINT(p, ofp);
PRINT(p, zob.dst);
@@ -150,7 +150,7 @@
PRINT(zu, nw);
}
- if (zsf->dstream) {
+ if (zstd->dstream) {
PRINT(p, dstream);
PRINT(p, ifp);
PRINT(p, zib.src);
@@ -169,64 +169,64 @@
return b;
}
-static void rpmzsfInit(void *_zsf)
+static void rpmzstdInit(void *_zstd)
{
}
-static void rpmzsfFini(void *_zsf)
+static void rpmzstdFini(void *_zstd)
{
- 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;
+ rpmzstd zstd = (rpmzstd) _zstd;
+ if (zstd) {
+ if (zstd->path)
+ zstd->path = _free(zstd->path);
+ if (zstd->fmode)
+ zstd->fmode = _free(zstd->fmode);
+ zstd->flags = 0;
+ zstd->fdno = -1;
+ zstd->oflags = 0;
+ zstd->omode = 0;
- zsf->nb = 0;
- zsf->nr = 0;
- zsf->nw = 0;
- zsf->level = 0;
+ zstd->nb = 0;
+ zstd->nr = 0;
+ zstd->nw = 0;
+ zstd->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 (zstd->ifp && fileno(zstd->ifp) > 2)
+ fclose(zstd->ifp);
+ zstd->ifp = NULL;
+ if (zstd->ib)
+ zstd->ib = _free(zstd->ib);
+ zstd->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 (zstd->ofp && fileno(zstd->ofp) > 2)
+ fclose(zstd->ofp);
+ zstd->ofp = NULL;
+ if (zstd->ob)
+ zstd->ob = _free(zstd->ob);
+ zstd->nob = 0;
- if (zsf->cstream)
- ZSTD_freeCStream(zsf->cstream);
- zsf->cstream = NULL;
- if (zsf->dstream)
- ZSTD_freeDStream(zsf->dstream);
- zsf->dstream = NULL;
+ if (zstd->cstream)
+ ZSTD_freeCStream(zstd->cstream);
+ zstd->cstream = NULL;
+ if (zstd->dstream)
+ ZSTD_freeDStream(zstd->dstream);
+ zstd->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;
+ zstd->zib.src = NULL;
+ zstd->zib.pos = 0;
+ zstd->zib.size = 0;
+ zstd->zob.dst = NULL;
+ zstd->zob.pos = 0;
+ zstd->zob.size = 0;
}
}
-RPMIOPOOL_MODULE(zsf)
+RPMIOPOOL_MODULE(zstd)
-static rpmzsf rpmzsfNew(const char *path, const char *fmode, int fdno,
unsigned flags)
+rpmzstd rpmzstdNew(const char *path, const char *fmode, int fdno, unsigned
flags)
{
- rpmzsf zsf = rpmzsfGetPool(_rpmzsfPool);
+ rpmzstd zstd = rpmzstdGetPool(_rpmzstdPool);
assert(fmode != NULL); /* XXX return NULL instead? */
const char * s = fmode;
@@ -278,7 +278,7 @@
continue;
break;
case '?':
- flags |= RPMZSF_FLAGS_DEBUG;
+ flags |= RPMZSTD_FLAGS_DEBUG;
continue;
break;
default:
@@ -292,19 +292,19 @@
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) {
+ zstd->path = xstrdup(path);
+ zstd->fmode = xstrdup(fmode);
+ zstd->fdno = fdno;
+ zstd->flags = flags;
+
+ zstd->oflags = oflags;
+ zstd->omode = omode;
+
+ zstd->level = level;
+
+ if (ZSTD_ISSET(DECOMPRESS)) { /* decompress */
+ zstd->dstream = ZSTD_createDStream();
+ if (zstd->dstream == NULL) {
fprintf(stderr, "ZSTD_createDStream() error \n");
exit(10);
}
@@ -314,285 +314,285 @@
* 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)) {
+ zstd->nb = ZSTD_initDStream(zstd->dstream);
+ if (ZSTD_isError(zstd->nb)) {
fprintf(stderr, "ZSTD_initDStream() error : %s \n",
- ZSTD_getErrorName(zsf->nb));
+ ZSTD_getErrorName(zstd->nb));
exit(11); /* XXX */
}
- zsf->nib = ZSTD_CStreamInSize();
- zsf->ib = xmalloc(zsf->nib);
+ zstd->nib = ZSTD_CStreamInSize();
+ zstd->ib = xmalloc(zstd->nib);
#ifdef NOTYET
- zsf->nob = BUFSIZ;
- zsf->ob = xmalloc(zsf->nob);
+ zstd->nob = BUFSIZ;
+ zstd->ob = xmalloc(zstd->nob);
#else
- zsf->nob = ZSTD_CStreamOutSize();
- zsf->ob = xmalloc(zsf->nob);
+ zstd->nob = ZSTD_CStreamOutSize();
+ zstd->ob = xmalloc(zstd->nob);
#endif
} else { /* compress */
- zsf->cstream = ZSTD_createCStream();
- if (zsf->cstream == NULL) {
+ zstd->cstream = ZSTD_createCStream();
+ if (zstd->cstream == NULL) {
fprintf(stderr, "ZSTD_createCStream() error \n");
exit(10);
}
- zsf->nb = ZSTD_initCStream(zsf->cstream, level);
- if (ZSTD_isError(zsf->nb)) {
+ zstd->nb = ZSTD_initCStream(zstd->cstream, level);
+ if (ZSTD_isError(zstd->nb)) {
fprintf(stderr, "ZSTD_initCStream() error : %s \n",
- ZSTD_getErrorName(zsf->nb));
+ ZSTD_getErrorName(zstd->nb));
exit(11); /* XXX */
}
#ifdef NOTYET
- zsf->nib = BUFSIZ;
- zsf->ib = xmalloc(zsf->nib);
+ zstd->nib = BUFSIZ;
+ zstd->ib = xmalloc(zstd->nib);
#else
- zsf->nib = ZSTD_CStreamInSize();
- zsf->ib = xmalloc(zsf->nib);
+ zstd->nib = ZSTD_CStreamInSize();
+ zstd->ib = xmalloc(zstd->nib);
#endif
- zsf->nob = ZSTD_CStreamOutSize();
- zsf->ob = xmalloc(zsf->nob);
+ zstd->nob = ZSTD_CStreamOutSize();
+ zstd->ob = xmalloc(zstd->nob);
}
- return rpmzsfLink(zsf);
+ return rpmzstdLink(zstd);
}
-static int rpmzsfFlush(rpmzsf zsf)
+int rpmzstdFlush(rpmzstd zstd)
{
int rc = -2;
- if (ZSF_ISSET(DECOMPRESS)) { /* decompress */
-assert(zsf->dstream);
+ if (ZSTD_ISSET(DECOMPRESS)) { /* decompress */
+assert(zstd->dstream);
} else { /* compress */
-assert(zsf->cstream);
+assert(zstd->cstream);
/* close frame */
- zsf->zob.dst = zsf->ob;
- zsf->zob.size = zsf->nob;
- zsf->zob.pos = 0;
+ zstd->zob.dst = zstd->ob;
+ zstd->zob.size = zstd->nob;
+ zstd->zob.pos = 0;
/* XXX nremain != 0 on small output buffers. Loop. */
- size_t nremain = ZSTD_flushStream(zsf->cstream, &zsf->zob);
+ size_t nremain = ZSTD_flushStream(zstd->cstream, &zstd->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);
+ zstd->nw = fwrite(zstd->ob, 1, zstd->zob.pos, zstd->ofp);
+assert(zstd->nw == zstd->zob.pos);
+SPEW("<--\tfwrite(%p, 1, %zu, %p) nw %zd\n", zstd->ob, zstd->zob.pos,
zstd->ofp, zstd->nw);
rc = 0;
}
}
-SPEW("<--\t%s(%p) rc %d\n", __FUNCTION__, zsf, rc);
+SPEW("<--\t%s(%p) rc %d\n", __FUNCTION__, zstd, rc);
return rc;
}
-static int rpmzsfClose(rpmzsf zsf)
+int rpmzstdClose(rpmzstd zstd)
{
int rc = -2;
-SPEW("-->\t%s(%p)\n", __FUNCTION__, zsf);
- if (ZSF_ISSET(DECOMPRESS)) { /* decompress */
-assert(zsf->dstream);
+SPEW("-->\t%s(%p)\n", __FUNCTION__, zstd);
+ if (ZSTD_ISSET(DECOMPRESS)) { /* decompress */
+assert(zstd->dstream);
} else { /* compress */
-assert(zsf->cstream);
+assert(zstd->cstream);
/* close frame */
- zsf->zob.dst = zsf->ob;
- zsf->zob.size = zsf->nob;
- zsf->zob.pos = 0;
+ zstd->zob.dst = zstd->ob;
+ zstd->zob.size = zstd->nob;
+ zstd->zob.pos = 0;
/* XXX nremain != 0 on small output buffers. Loop. */
- size_t nremain = ZSTD_endStream(zsf->cstream, &zsf->zob);
+ size_t nremain = ZSTD_endStream(zstd->cstream, &zstd->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);
+ zstd->nw = fwrite(zstd->ob, 1, zstd->zob.pos, zstd->ofp);
+assert(zstd->nw == zstd->zob.pos);
+SPEW("<--\tfwrite(%p, 1, %zu, %p) nw %zd\n", zstd->ob, zstd->zob.pos,
zstd->ofp, zstd->nw);
rc = 0;
}
- rpmzsfFini(zsf); /* XXX */
+ rpmzstdFini(zstd); /* XXX */
}
-SPEW("<--\t%s(%p) rc %d\n", __FUNCTION__, zsf, rc);
+SPEW("<--\t%s(%p) rc %d\n", __FUNCTION__, zstd, rc);
return rc;
}
/*==============================================================*/
-static ssize_t rpmzsfRead(rpmzsf zsf, void *b, size_t nb)
+ssize_t rpmzstdRead(rpmzstd zstd, void *b, size_t nb)
{
ssize_t rc = 0;
-SPEW("-->\t%s(%p,%p[%zd])\n", __FUNCTION__, zsf, b, nb);
+SPEW("-->\t%s(%p,%p[%zd])\n", __FUNCTION__, zstd, b, nb);
- zsf->zob.dst = b;
- zsf->zob.size = nb;
- zsf->zob.pos = 0;
+ zstd->zob.dst = b;
+ zstd->zob.size = nb;
+ zstd->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;
+ while (zstd->zob.pos < zstd->zob.size) {
+ if (zstd->zib.pos >= zstd->zib.size) {
+ zstd->nr = fread(zstd->ib, 1, zstd->nib, zstd->ifp);
+ if (zstd->nr <= 0) {
+ rc = zstd->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)) {
+ zstd->zib.src = zstd->ib;
+ zstd->zib.size = zstd->nr;
+ zstd->zib.pos = 0;
+ }
+ while (zstd->zib.pos < zstd->zib.size) {
+ zstd->nb = ZSTD_decompressStream(zstd->dstream, &zstd->zob,
&zstd->zib);
+SPEW("\t%s: nb %8zd\tzob %zu:%zu\tzib %zu:%zu\n", __FUNCTION__, zstd->nb,
zstd->zob.pos, zstd->zob.size, zstd->zib.pos, zstd->zib.size);
+ /* zstd->nb : size of next compressed block */
+ if (ZSTD_isError(zstd->nb)) {
fprintf(stderr, "ZSTD_decompressStream() error : %s \n",
- ZSTD_getErrorName(zsf->nb));
+ ZSTD_getErrorName(zstd->nb));
rc = -1;
break;
}
- if (zsf->zob.pos >= zsf->zob.size)
+ if (zstd->zob.pos >= zstd->zob.size)
break;
}
}
- rc = (rc >= 0 ? (ssize_t)zsf->zob.pos : rc);
+ rc = (rc >= 0 ? (ssize_t)zstd->zob.pos : rc);
-SPEW("<--\t%s(%p,%p[%zd]) rc %ld\n", __FUNCTION__, zsf, b, nb, rc);
+SPEW("<--\t%s(%p,%p[%zd]) rc %ld\n", __FUNCTION__, zstd, b, nb, rc);
return rc;
}
-static ssize_t rpmzsfWrite(rpmzsf zsf, void *b, size_t nb)
+ssize_t rpmzstdWrite(rpmzstd zstd, 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;
+SPEW("-->\t%s(%p,%p[%zd])\n", __FUNCTION__, zstd, b, nb);
+ zstd->zib.src = b;
+ zstd->zib.size = nb;
+ zstd->zib.pos = 0;
rc = 0;
- while (zsf->zib.pos < zsf->zib.size) {
+ while (zstd->zib.pos < zstd->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)) {
+ zstd->zob.dst = zstd->ob;
+ zstd->zob.size = zstd->nob;
+ zstd->zob.pos = 0;
+
+ zstd->nb = ZSTD_compressStream(zstd->cstream, &zstd->zob,
&zstd->zib);
+SPEW("\t%s: nb %8zd\tzob %zu:%zu\tzib %zu:%zu\n", "compress", zstd->nb,
zstd->zob.pos, zstd->zob.size, zstd->zib.pos, zstd->zib.size);
+ /* zstd->nb is guaranteed to be <= ZSTD_CStreamInSize() */
+ if (ZSTD_isError(zstd->nb)) {
fprintf(stderr, "ZSTD_compressStream() error : %s \n",
- ZSTD_getErrorName(zsf->nb));
+ ZSTD_getErrorName(zstd->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);
+ if (zstd->zob.pos > 0) {
+ zstd->nw = fwrite(zstd->ob, 1, zstd->zob.pos, zstd->ofp);
+assert(zstd->nw == zstd->zob.pos);
+SPEW("<--\tfwrite(%p, 1, %zu, %p) nw %zd\n", zstd->ob, zstd->zob.pos,
zstd->ofp, zstd->nw);
}
}
- rc = (zsf->zib.pos == zsf->zib.size ? (ssize_t) zsf->zib.pos : -1);
+ rc = (zstd->zib.pos == zstd->zib.size ? (ssize_t) zstd->zib.pos : -1);
-SPEW("<--\t%s(%p,%p[%zd]) rc %ld\n", __FUNCTION__, zsf, b, nb, rc);
+SPEW("<--\t%s(%p,%p[%zd]) rc %ld\n", __FUNCTION__, zstd, b, nb, rc);
return rc;
}
-static int rpmzsfSeek(void * _zsf, _libio_pos_t pos, int whence)
+int rpmzstdSeek(void * _zstd, _libio_pos_t pos, int whence)
{
int rc = -2;
return rc;
}
-static rpmzsf rpmzsfOpen(const char * path, const char * fmode, int fdno,
unsigned flags)
+rpmzstd rpmzstdOpen(const char * path, const char * fmode, int fdno,
unsigned flags)
{
- return rpmzsfNew(path, fmode, fdno, flags);
+ return rpmzstdNew(path, fmode, fdno, flags);
}
-static rpmzsf rpmzsfFdopen(void * _fdno, const char * fmode)
+rpmzstd rpmzstdFdopen(void * _fdno, const char * fmode)
{
#ifdef NOTYET
int fdno = (int)((long)_fdno); /* XXX hack */
- return rpmzsfNew(NULL, fmode, fdno, 0);
+ return rpmzstdNew(NULL, fmode, fdno, 0);
#else
return NULL;
#endif
}
/*==============================================================*/
-static ssize_t rpmzsfCopyAll(rpmzsf zsf)
+static ssize_t rpmzstdCopyAll(rpmzstd zstd)
{
ssize_t rc = -2;
-SPEW("==> %s(%p) oflags 0x%x\n", __FUNCTION__, zsf, zsf->oflags);
+SPEW("==> %s(%p) oflags 0x%x\n", __FUNCTION__, zstd, zstd->oflags);
- if (ZSF_ISSET(DECOMPRESS)) { /* decompress */
-assert(zsf->dstream);
-SPEW("\tDecompressing ... eof %d\n", feof(zsf->ifp));
+ if (ZSTD_ISSET(DECOMPRESS)) { /* decompress */
+assert(zstd->dstream);
+SPEW("\tDecompressing ... eof %d\n", feof(zstd->ifp));
do {
- zsf->nr = rpmzsfRead(zsf, zsf->ob, zsf->nob);
- if (zsf->nr <= 0) {
- rc = zsf->nr;
+ zstd->nr = rpmzstdRead(zstd, zstd->ob, zstd->nob);
+ if (zstd->nr <= 0) {
+ rc = zstd->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;
+ zstd->nw = fwrite(zstd->ob, 1, zstd->nr, zstd->ofp);
+assert(zstd->nw == zstd->nr);
+SPEW("<--\tfwrite(%p, 1, %zu, %p) nw %zd\n", zstd->ob, zstd->nr, zstd->ofp,
zstd->nw);
+ if (zstd->nw <= 0) {
+ rc = zstd->nw;
break;
}
- } while (zsf->zib.pos < zsf->zib.size);
+ } while (zstd->zib.pos < zstd->zib.size);
} else { /* compress */
-assert(zsf->cstream);
-SPEW("\tCompressing ... eof %d\n", feof(zsf->ifp));
+assert(zstd->cstream);
+SPEW("\tCompressing ... eof %d\n", feof(zstd->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;
+ while (!feof(zstd->ifp)) {
+ zstd->nr = fread(zstd->ib, 1, zstd->nib, zstd->ifp);
+SPEW("<--\tfread(%p, 1, %zu, %p) nr %zd eof %d\n", zstd->ib, zstd->nib,
zstd->ifp, zstd->nr, feof(zstd->ifp));
+ if (zstd->nr <= 0) {
+ rc = zstd->nr;
break;
}
- zsf->nw = rpmzsfWrite(zsf, zsf->ib, zsf->nr);
- if (zsf->nw <= 0) {
- rc = zsf->nw;
+ zstd->nw = rpmzstdWrite(zstd, zstd->ib, zstd->nr);
+ if (zstd->nw <= 0) {
+ rc = zstd->nw;
break;
}
}
if (!rc)
- rc = rpmzsfClose(zsf);
+ rc = rpmzstdClose(zstd);
}
-rpmzsfDump(__FUNCTION__, zsf);
-SPEW("<== %s(%p) rc %ld\n", __FUNCTION__, zsf, rc);
+rpmzstdDump(__FUNCTION__, zstd);
+SPEW("<== %s(%p) rc %ld\n", __FUNCTION__, zstd, 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);
+ rpmzstd zstd = rpmzstdOpen(ifn, fmode, -1, RPMZSTD_FLAGS_NONE);
+ zstd->ifp = fopen(ifn, "rb");;
+SPEW("<--\tfopen(\"%s\", \"%s\") ifp %p\n", ifn, "rb", zstd->ifp);
+assert(zstd->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);
+ zstd->ofp = fopen(ofn, "wb");;
+SPEW("<--\tfopen(\"%s\", \"%s\") ofp %p\n", ofn, "wb", zstd->ofp);
+assert(zstd->ofp);
ofn = _free(ofn);
- int rc = rpmzsfCopyAll(zsf);
- rc = rpmzsfClose(zsf); /* XXX elsewhere */
- zsf = rpmzsfFree(zsf);
+ int rc = rpmzstdCopyAll(zstd);
+ rc = rpmzstdClose(zstd); /* XXX elsewhere */
+ zstd = rpmzstdFree(zstd);
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);
+ rpmzstd zstd = rpmzstdOpen(ifn, fmode, -1, RPMZSTD_FLAGS_DECOMPRESS);
+ zstd->ifp = fopen(ifn, "rb");;
+SPEW("<--\tfopen(\"%s\", \"%s\") ifp %p\n", ifn, "rb", zstd->ifp);
+assert(zstd->ifp);
+ zstd->ofp = stdout;
+ int rc = rpmzstdCopyAll(zstd);
+ zstd = rpmzstdFree(zstd);
return rc;
}
@@ -601,7 +601,7 @@
#define POPT_BIT_XOR (POPT_ARG_VAL|POPT_ARGFLAG_XOR)
#endif
-static struct poptOption rpmzsfOptionsTable[] = {
+static struct poptOption rpmzstdOptionsTable[] = {
{ "debug", 'd', POPT_ARG_VAL|POPT_ARGFLAG_DOC_HIDDEN, &_debug, 1,
NULL, NULL },
@@ -619,7 +619,7 @@
int
main(int argc, char *argv[])
{
- poptContext con = rpmioInit(argc, argv, rpmzsfOptionsTable);
+ poptContext con = rpmioInit(argc, argv, rpmzstdOptionsTable);
ARGV_t av = poptGetArgs(con);
int ac = argvCount(av);
int ec = 0;
@@ -637,8 +637,8 @@
#endif
switch (2) {
- case 1: ec = compressFile(ifn, "w3?.zstio"); break;
- case 2: ec = decompressFile(ifn, "r?.zstio"); break;
+ case 1: ec = compressFile(ifn, "w3?.zstdio"); break;
+ case 2: ec = decompressFile(ifn, "r?.zstdio"); break;
}
ifn = _free(ifn);
@@ .
patch -p0 <<'@@ .'
Index: rpm/rpmio/zstdio.c
============================================================================
$ cvs diff -u -r0 -r1.1.2.1 zstdio.c
--- /dev/null 2017-06-01 20:36:29.000000000 +0200
+++ zstdio.c 2017-06-01 20:38:25.506197574 +0200
@@ -0,0 +1,498 @@
+/** \ingroup rpmio
+ * \file rpmio/zstdio.c
+ * Support for ZSTD compression library.
+ */
+
+#include "system.h"
+
+#include <stddef.h> /* size_t */
+#include <stdint.h>
+
+#if defined(HAVE_STDBOOL_H)
+# include <stdbool.h>
+#else
+typedef enum { true = 1, false = 0 } bool;
+#endif
+
+#include "rpmio_internal.h"
+#include <rpmmacro.h>
+#include <rpmcb.h>
+
+#include <zstd.h>
+
+#include "debug.h"
+
+#define ZSTONLY(fd) assert(fdGetIo(fd) == zstdio)
+
+typedef struct cpio_state_s {
+ uint32_t n; /* byte progress in cpio header
*/
+ uint32_t mode; /* file attributes */
+ uint32_t nlnk;
+ uint32_t size;
+} * cpio_state;
+
+#define RSYNC_WIN 4096
+
+typedef struct rsync_state_s {
+ uint32_t n; /* number of elements in the
window */
+ uint32_t sum; /* current sum */
+ unsigned char win[RSYNC_WIN]; /* window elements */
+} * rsync_state;
+
+/* Should zstdflush 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;
+ struct cpio_state_s cs;
+ uint32_t nb; /* bytes pending for sync */
+} * zstdFILE; /* like FILE, to use with star */
+
+#ifdef __cplusplus
+GENfree(zstdFILE)
+#endif /* __cplusplus */
+
+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 * rpmzsfError(gzFile gz, int *errnum)
+{
+ return "";
+}
+
+static
+gzFile rpmzsfOpen(const char *path, const char * fmode, int fdno)
+{
+ return NULL;
+}
+
+static
+int rpmzsfRead(gzFile gz, const void *buf, size_t len)
+{
+ int rc = -1;
+
+ return rc;
+}
+
+static
+int rpmzsfWrite(gzFile gz, void *buf, unsigned len)
+{
+ int rc = -1;
+
+ return rc;
+}
+
+static
+int rpmzsfSeek(gzFile gz, off_t offset, int whence)
+{
+ int rc = -1;
+ return rc;
+}
+
+static
+int rpmzsfClose(gzFile gz)
+{
+ int rc = -1;
+ return rc;
+}
+
+static
+int rpmzsfFlush(gzFile gz)
+{
+ int rc = -1;
+ return rc;
+}
+
+/* =============================================================== */
+/* from ../lib/cpio.h */
+#define CPIO_NEWC_MAGIC "070701"
+#define PHYS_HDR_SIZE 110
+
+#define OFFSET_MODE (sizeof(CPIO_NEWC_MAGIC)-1 + 1*8)
+#define OFFSET_NLNK (sizeof(CPIO_NEWC_MAGIC)-1 + 4*8)
+#define OFFSET_SIZE (sizeof(CPIO_NEWC_MAGIC)-1 + 6*8)
+
+static inline
+int hex(char c)
+{
+ if (c >= '0' && c <= '9')
+ return (int)(c - '0');
+ else if (c >= 'a' && c <= 'f')
+ return (int)(c - 'a') + 10;
+ else if (c >= 'A' && c <= 'F')
+ return (int)(c - 'A') + 10;
+ return -1;
+}
+
+static inline
+bool cpio_next(cpio_state s, unsigned char c)
+{
+ if (s->n >= sizeof(CPIO_NEWC_MAGIC)-1) {
+ int d = hex(c);
+ if (d < 0) {
+ s->n = 0;
+ return false;
+ }
+ if (0){} /* indent */
+ else if (s->n >= OFFSET_MODE && s->n < OFFSET_MODE+8) {
+ if (s->n == OFFSET_MODE)
+ s->mode = 0;
+ else
+ s->mode <<= 4;
+ s->mode |= d;
+ }
+ else if (s->n >= OFFSET_NLNK && s->n < OFFSET_NLNK+8) {
+ if (s->n == OFFSET_NLNK)
+ s->nlnk = 0;
+ else
+ s->nlnk <<= 4;
+ s->nlnk |= d;
+ }
+ else if (s->n >= OFFSET_SIZE && s->n < OFFSET_SIZE+8) {
+ if (s->n == OFFSET_SIZE)
+ s->size = 0;
+ else
+ s->size <<= 4;
+ s->size |= d;
+ }
+ s->n++;
+ if (s->n >= PHYS_HDR_SIZE) {
+ s->n = 0;
+ if (!S_ISREG(s->mode) || s->nlnk != 1)
+ /* no file data */
+ s->size = 0;
+ return true;
+ }
+ }
+ else if (CPIO_NEWC_MAGIC[s->n] == c) {
+ s->n++;
+ }
+ else {
+ s->n = 0;
+ }
+ return false;
+}
+
+/* =============================================================== */
+static inline
+bool rsync_next(rsync_state s, unsigned char c)
+{
+ uint32_t i;
+
+ if (s->n < RSYNC_WIN) { /* not enough elements */
+ s->sum += (uint32_t)c; /* update the sum */
+ s->win[s->n++] = c; /* remember the element */
+ return false; /* no match */
+ }
+ i = s->n++ % RSYNC_WIN; /* wrap up */
+ s->sum -= (uint32_t)s->win[i]; /* move the window on */
+ s->sum += (uint32_t)c;
+ s->win[i] = c;
+ if (s->sum % RSYNC_WIN == 0) { /* match */
+ s->n = 0; /* reset */
+ s->sum = 0;
+ return true;
+ }
+ return false;
+}
+
+#define CHUNK 4096
+
+static inline
+bool sync_hint(zstdFILE zsf, unsigned char c)
+{
+ bool cpio_hint;
+ bool rsync_hint;
+
+ zsf->nb++;
+ cpio_hint = cpio_next(&zsf->cs, c);
+ if (cpio_hint) {
+ /* cpio header/data boundary */
+ zsf->rs.n = zsf->rs.sum = 0;
+ if (zsf->nb >= 2*CHUNK)
+ /* better sync here */
+ goto cpio_sync;
+ if (zsf->cs.size < CHUNK)
+ /* file is too small */
+ return false;
+ if (zsf->nb < CHUNK/2)
+ /* not enough pending bytes */
+ return false;
+ cpio_sync:
+ zsf->nb = 0;
+ return true;
+ }
+ rsync_hint = rsync_next(&zsf->rs, c);
+ if (rsync_hint) {
+ /* rolling checksum match */
+ assert(zsf->nb >= RSYNC_WIN);
+ zsf->nb = 0;
+ return true;
+ }
+ return false;
+}
+
+static ssize_t
+rsyncable_write(zstdFILE zsf, const unsigned char *const buf, const size_t
len)
+{
+ ssize_t rc;
+ size_t n;
+ ssize_t n_written = 0;
+ const unsigned char *begin = buf;
+ size_t i;
+
+ for (i = 0; i < len; i++) {
+ if (!sync_hint(zsf, buf[i]))
+ continue;
+ n = i + 1 - (begin - buf);
+ 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 = rpmzsfFlush(zsf->gz);
+ if (rc < 0)
+ return (n_written ? n_written : rc);
+ }
+ if (begin < buf + len) {
+ n = len - (begin - buf);
+ rc = rpmzsfWrite(zsf->gz, (void *)begin, (unsigned)n);
+ if (rc < 0)
+ return (n_written ? n_written : rc);
+ n_written += rc;
+ }
+ return n_written;
+}
+
+/* =============================================================== */
+
+RPM_GNUC_PURE
+static inline
+void * zstdFileno(FD_t fd)
+{
+ void * rc = NULL;
+ int i;
+
+ FDSANE(fd);
+ for (i = fd->nfps; i >= 0; i--) {
+ FDSTACK_t * fps = &fd->fps[i];
+ if (fps->io != zstdio)
+ continue;
+ rc = fps->fp;
+ break;
+ }
+
+ return rc;
+}
+
+static
+FD_t zstdOpen(const char * path, const char * fmode)
+{
+ FD_t fd;
+ zstdFILE zsf;
+ mode_t mode = (fmode && fmode[0] == 'w' ? O_WRONLY : O_RDONLY);
+
+ zsf = (zstdFILE) xcalloc(1, sizeof(*zsf));
+ zsf->gz = rpmzsfOpen(path, fmode, -1);
+ if (zsf->gz == NULL) {
+ zsf = _free(zsf);
+ return NULL;
+ }
+ fd = fdNew("open (zstdOpen)");
+ fdPop(fd); fdPush(fd, zstdio, zsf, -1);
+ fdSetOpen(fd, path, -1, mode);
+
+DBGIO(fd, (stderr, "==>\tzstdOpen(\"%s\", \"%s\") fd %p %s\n", path, fmode,
(fd ? fd : NULL), fdbg(fd)));
+ return fdLink(fd, "zstdOpen");
+}
+
+static FD_t zstdFdopen(void * cookie, const char *fmode)
+{
+ FD_t fd = c2f(cookie);
+ int fdno;
+ zstdFILE zsf;
+
+ if (fmode == NULL) return NULL;
+ fdno = fdSetFdno(fd, -1); /* XXX skip the fdio close */
+ if (fdno < 0) return NULL;
+ zsf = (zstdFILE) xcalloc(1, sizeof(*zsf));
+ zsf->gz = rpmzsfOpen(NULL, fmode, fdno);
+ if (zsf->gz == NULL) {
+ zsf = _free(zsf);
+ return NULL;
+ }
+
+ fdPush(fd, zstdio, zsf, fdno); /* Push zstdio onto stack */
+
+ return fdLink(fd, "zstdFdopen");
+}
+
+static int zstdFlush(void * cookie)
+{
+ FD_t fd = c2f(cookie);
+ zstdFILE zsf;
+ zsf = (zstdFILE) zstdFileno(fd);
+ if (zsf == NULL) return -2;
+ return rpmzsfFlush(zsf->gz);
+}
+
+/* =============================================================== */
+static ssize_t zstdRead(void * cookie, char * buf, size_t count)
+{
+ FD_t fd = c2f(cookie);
+ zstdFILE zsf;
+ ssize_t rc;
+
+ if (fd == NULL || fd->bytesRemain == 0) return 0; /* XXX simulate
EOF */
+
+ zsf = (zstdFILE) zstdFileno(fd);
+ if (zsf == NULL) return -2; /* XXX can't happen */
+
+ fdstat_enter(fd, FDSTAT_READ);
+ rc = rpmzsfRead(zsf->gz, buf, (unsigned)count);
+DBGIO(fd, (stderr, "==>\tzstdRead(%p,%p,%u) rc %lx %s\n", cookie, buf,
(unsigned)count, (unsigned long)rc, fdbg(fd)));
+ if (rc < 0) {
+ int zerror = 0;
+ fd->errcookie = rpmzsfError(zsf->gz, &zerror);
+#ifdef DYING
+ if (zerror == Z_ERRNO) {
+ fd->syserrno = errno;
+ fd->errcookie = strerror(fd->syserrno);
+ }
+#endif
+ } else {
+ fdstat_exit(fd, FDSTAT_READ, (rc > 0 ? rc : 0));
+ if (fd->ndigests > 0 && rc > 0) fdUpdateDigests(fd, (const unsigned
char *)buf, rc);
+ }
+ return rc;
+}
+
+static ssize_t zstdWrite(void * cookie, const char * buf, size_t count)
+{
+ FD_t fd = c2f(cookie);
+ zstdFILE zsf;
+ ssize_t rc;
+
+ if (fd == NULL || fd->bytesRemain == 0) return 0; /* XXX simulate
EOF */
+
+ if (fd->ndigests > 0 && count > 0) fdUpdateDigests(fd, (const unsigned
char *)buf, count);
+
+ zsf = (zstdFILE) zstdFileno(fd);
+ if (zsf == NULL) return -2; /* XXX can't happen */
+
+ fdstat_enter(fd, FDSTAT_WRITE);
+ if (enable_rsync)
+ rc = rsyncable_write(zsf, (const unsigned char *)buf, (unsigned)count);
+ else
+ rc = rpmzsfWrite(zsf->gz, (void *)buf, (unsigned)count);
+DBGIO(fd, (stderr, "==>\tzstdWrite(%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 = rpmzsfError(zsf->gz, &zerror);
+#ifdef DYING
+ if (zerror == Z_ERRNO) {
+ fd->syserrno = errno;
+ fd->errcookie = strerror(fd->syserrno);
+ }
+#endif
+ }
+ if (rc > 0)
+ fdstat_exit(fd, FDSTAT_WRITE, rc);
+ return rc;
+}
+
+static int zstdSeek(void * cookie, _libio_pos_t pos, int whence)
+{
+ int rc;
+#ifdef USE_COOKIE_SEEK_POINTER
+ _IO_off64_t p = *pos;
+#else
+ off_t p = pos;
+#endif
+ FD_t fd = c2f(cookie);
+ zstdFILE zsf;
+
+ if (fd == NULL) return -2;
+ assert(fd->bytesRemain == -1); /* XXX FIXME */
+
+ zsf = (zstdFILE) zstdFileno(fd);
+ if (zsf == NULL) return -2; /* XXX can't happen */
+
+ fdstat_enter(fd, FDSTAT_SEEK);
+ rc = rpmzsfSeek(zsf->gz, (long)p, whence);
+DBGIO(fd, (stderr, "==>\tzstdSeek(%p,%ld,%d) rc %lx %s\n", cookie, (long)p,
whence, (unsigned long)rc, fdbg(fd)));
+ if (rc < 0) {
+ int zerror = 0;
+ fd->errcookie = rpmzsfError(zsf->gz, &zerror);
+#ifdef DYING
+ if (zerror == Z_ERRNO) {
+ fd->syserrno = errno;
+ fd->errcookie = strerror(fd->syserrno);
+ }
+#endif
+ }
+ if (rc > 0)
+ fdstat_exit(fd, FDSTAT_SEEK, rc);
+ return rc;
+}
+
+static int zstdClose(void * cookie)
+{
+ FD_t fd = c2f(cookie);
+ zstdFILE zsf;
+ int rc;
+
+ zsf = (zstdFILE) zstdFileno(fd);
+ if (zsf == NULL) return -2; /* XXX can't happen */
+
+ fdstat_enter(fd, FDSTAT_CLOSE);
+ rc = rpmzsfClose(zsf->gz);
+ zsf->gz = NULL;
+ zsf = _free(zsf);
+
+ /* XXX TODO: preserve fd if errors */
+
+ if (fd) {
+DBGIO(fd, (stderr, "==>\tzstdClose(%p) zerror %d %s\n", cookie, rc,
fdbg(fd)));
+ if (rc < 0) {
+ fd->errcookie = "zstdClose error";
+#ifdef DYING
+ if (rc == Z_ERRNO) {
+ fd->syserrno = errno;
+ fd->errcookie = strerror(fd->syserrno);
+ }
+#endif
+ } else if (rc >= 0) {
+ fdstat_exit(fd, FDSTAT_CLOSE, rc);
+ }
+ }
+
+DBGIO(fd, (stderr, "==>\tzstdClose(%p) rc %lx %s\n", cookie, (unsigned
long)rc, fdbg(fd)));
+
+ if (_rpmio_debug || rpmIsDebug()) fdstat_print(fd, "ZSTIO", stderr);
+ if (rc == 0)
+ fd = fdFree(fd, "open (zstdClose)");
+ return rc;
+}
+
+static struct FDIO_s _zstdio = {
+ zstdRead, zstdWrite, zstdSeek, zstdClose, zstdOpen, zstdFdopen, zstdFlush,
+};
+
+FDIO_t zstdio = &_zstdio;
+
@@ .
rm -f rpm/rpmio/zstio.c <<'@@ .'
Index: rpm/rpmio/zstio.c
============================================================================
[NO CHANGE SUMMARY BECAUSE FILE AS A WHOLE IS JUST REMOVED]
@@ .
______________________________________________________________________
RPM Package Manager http://rpm5.org
CVS Sources Repository rpm-cvs@rpm5.org
