FD_t fdNew(const char *descr)
{
FD_t fd = xcalloc(1, sizeof(*fd));
if (fd == NULL) /* XXX xmalloc never returns NULL */
return NULL;
fd->nrefs = 0;
fd->flags = 0;
fd->magic = FDMAGIC;
fd->urlType = URL_IS_UNKNOWN;
fd->nfps = 0;
memset(fd->fps, 0, sizeof(fd->fps));
fd->fps[0].io = fdio;
fd->fps[0].fp = NULL;
fd->fps[0].fdno = -1;
fd->syserrno = 0;
fd->errcookie = NULL;
fd->stats = xcalloc(1, sizeof(*fd->stats));
fd->digests = NULL;
fd->descr = descr ? xstrdup(descr) : NULL;
return fdLink(fd);
}
int Fclose(FD_t fd)
{
int rc = 0, ec = 0;
if (fd == NULL)
return -1;
fd = fdLink(fd);
fdstat_enter(fd, FDSTAT_CLOSE);
while (fd->nfps >= 0) {
fdio_close_function_t _close = FDIOVEC(fd, close);
rc = _close ? _close(fd) : -2;
if (fd->nfps == 0)
break;
if (ec == 0 && rc)
ec = rc;
fdPop(fd);
}
fdstat_exit(fd, FDSTAT_CLOSE, rc);
DBGIO(fd, (stderr, "==>\tFclose(%p) rc %lx %s\n",
(fd ? fd : NULL), (unsigned long)rc, fdbg(fd)));
fdFree(fd);
return ec;
}
static FD_t bzdOpen(const char * path, const char * mode)
{
FD_t fd;
BZFILE *bzfile;;
if ((bzfile = BZ2_bzopen(path, mode)) == NULL)
return NULL;
fd = fdNew(path);
fdPop(fd); fdPush(fd, bzdio, bzfile, -1);
return fdLink(fd);
}
static FD_t lzdOpen(const char * path, const char * mode)
{
FD_t fd;
LZFILE *lzfile;
if ((lzfile = lzopen(path, mode)) == NULL)
return NULL;
fd = fdNew(path);
fdPop(fd); fdPush(fd, xzdio, lzfile, -1);
return fdLink(fd);
}
static void fdPush(FD_t fd, FDIO_t io, void * fp, int fdno)
{
FDSTACK_t fps = xcalloc(1, sizeof(*fps));
fps->io = io;
fps->fp = fp;
fps->fdno = fdno;
fps->prev = fd->fps;
fd->fps = fps;
fdLink(fd);
}
rpmcpio_t rpmcpioOpen(FD_t fd, char mode)
{
if ((mode & O_ACCMODE) != O_RDONLY &&
(mode & O_ACCMODE) != O_WRONLY)
return NULL;
rpmcpio_t cpio = xcalloc(1, sizeof(*cpio));
cpio->fd = fdLink(fd);
cpio->mode = mode;
cpio->offset = 0;
return cpio;
}
void rpmtsSetScriptFd(rpmts ts, FD_t scriptFd)
{
if (ts != NULL) {
if (ts->scriptFd != NULL) {
ts->scriptFd = fdFree(ts->scriptFd);
ts->scriptFd = NULL;
}
if (scriptFd != NULL)
ts->scriptFd = fdLink(scriptFd);
}
}
static
FD_t gzdOpen(const char * path, const char * fmode)
{
FD_t fd;
gzFile gzfile;
if ((gzfile = gzopen(path, fmode)) == NULL)
return NULL;
fd = fdNew(path);
fdPop(fd); fdPush(fd, gzdio, gzfile, -1);
return fdLink(fd);
}
static FD_t lzdFdopen(FD_t fd, const char * fmode)
{
int fdno;
LZFILE *lzfile;
if (fd == NULL || fmode == NULL) return NULL;
fdno = fdFileno(fd);
fdSetFdno(fd, -1); /* XXX skip the fdio close */
if (fdno < 0) return NULL;
lzfile = lzdopen(fdno, fmode);
if (lzfile == NULL) return NULL;
fdPush(fd, xzdio, lzfile, fdno);
return fdLink(fd);
}
/*@-globuse@*/
static /*@null@*/ FD_t xzdOpen(const char * path, const char * fmode)
/*@globals fileSystem @*/
/*@modifies fileSystem @*/
{
FD_t fd;
mode_t mode = (fmode && fmode[0] == 'w' ? O_WRONLY : O_RDONLY);
XZFILE * xzfile = xzopen(path, fmode);
if (xzfile == NULL)
return NULL;
fd = fdNew("open (xzdOpen)");
fdPop(fd); fdPush(fd, xzdio, xzfile, -1);
fdSetOpen(fd, path, fileno(xzfile->fp), mode);
return fdLink(fd, "xzdOpen");
}
/*@-globuse@*/
static /*@null@*/ FD_t xzdFdopen(void * cookie, const char * fmode)
/*@globals fileSystem, internalState @*/
/*@modifies fileSystem, internalState @*/
{
FD_t fd = c2f(cookie);
int fdno = fdFileno(fd);
XZFILE *xzfile;
assert(fmode != NULL);
fdSetFdno(fd, -1); /* XXX skip the fdio close */
if (fdno < 0) return NULL;
xzfile = xzdopen(fdno, fmode);
if (xzfile == NULL) return NULL;
fdPush(fd, xzdio, xzfile, fdno);
return fdLink(fd, "xzdFdopen");
}
static FD_t bzdFdopen(FD_t fd, const char * fmode)
{
int fdno;
BZFILE *bzfile;
if (fd == NULL || fmode == NULL) return NULL;
fdno = fdFileno(fd);
fdSetFdno(fd, -1); /* XXX skip the fdio close */
if (fdno < 0) return NULL;
bzfile = BZ2_bzdopen(fdno, fmode);
if (bzfile == NULL) return NULL;
fdPush(fd, bzdio, bzfile, fdno); /* Push bzdio onto stack */
return fdLink(fd);
}
static FD_t gzdFdopen(FD_t fd, const char *fmode)
{
int fdno;
gzFile gzfile;
if (fd == NULL || fmode == NULL) return NULL;
fdno = fdFileno(fd);
fdSetFdno(fd, -1); /* XXX skip the fdio close */
if (fdno < 0) return NULL;
gzfile = gzdopen(fdno, fmode);
if (gzfile == NULL) return NULL;
fdPush(fd, gzdio, gzfile, fdno); /* Push gzdio onto stack */
return fdLink(fd);
}
void * rpmShowProgress(const void * arg,
const rpmCallbackType what,
const rpm_loff_t amount,
const rpm_loff_t total,
fnpyKey key,
void * data)
{
Header h = (Header) arg;
int flags = (int) ((long)data);
void * rc = NULL;
const char * filename = (const char *)key;
static FD_t fd = NULL;
switch (what) {
case RPMCALLBACK_INST_OPEN_FILE:
if (filename == NULL || filename[0] == '\0')
return NULL;
fd = Fopen(filename, "r.ufdio");
/* FIX: still necessary? */
if (fd == NULL || Ferror(fd)) {
rpmlog(RPMLOG_ERR, _("open of %s failed: %s\n"), filename,
Fstrerror(fd));
if (fd != NULL) {
Fclose(fd);
fd = NULL;
}
} else
fd = fdLink(fd);
#if defined(POSIX_FADV_WILLNEED)
(void) Fadvise(fd, 0, 0, POSIX_FADV_WILLNEED);
#endif
return (void *)fd;
break;
case RPMCALLBACK_INST_CLOSE_FILE:
/* FIX: still necessary? */
fd = fdFree(fd);
if (fd != NULL) {
Fclose(fd);
fd = NULL;
}
break;
case RPMCALLBACK_INST_START:
case RPMCALLBACK_UNINST_START:
if (rpmcliProgressState != what) {
rpmcliProgressState = what;
if (flags & INSTALL_HASH) {
if (what == RPMCALLBACK_INST_START) {
fprintf(stdout, _("Updating / installing...\n"));
} else {
fprintf(stdout, _("Cleaning up / removing...\n"));
}
fflush(stdout);
}
}
rpmcliHashesCurrent = 0;
if (h == NULL || !(flags & INSTALL_LABEL))
break;
if (flags & INSTALL_HASH) {
char *s = headerGetAsString(h, RPMTAG_NEVR);
if (isatty (STDOUT_FILENO))
fprintf(stdout, "%4d:%-33.33s", rpmcliProgressCurrent + 1, s);
else
fprintf(stdout, "%-38.38s", s);
(void) fflush(stdout);
free(s);
} else {
char *s = headerGetAsString(h, RPMTAG_NEVRA);
fprintf(stdout, "%s\n", s);
(void) fflush(stdout);
free(s);
}
break;
case RPMCALLBACK_INST_STOP:
break;
case RPMCALLBACK_TRANS_PROGRESS:
case RPMCALLBACK_INST_PROGRESS:
case RPMCALLBACK_UNINST_PROGRESS:
if (flags & INSTALL_PERCENT)
fprintf(stdout, "%%%% %f\n", (double) (total
? ((((float) amount) / total) * 100)
: 100.0));
else if (flags & INSTALL_HASH)
printHash(amount, total);
(void) fflush(stdout);
break;
case RPMCALLBACK_TRANS_START:
rpmcliHashesCurrent = 0;
rpmcliProgressTotal = 1;
rpmcliProgressCurrent = 0;
rpmcliPackagesTotal = total;
rpmcliProgressState = what;
if (!(flags & INSTALL_LABEL))
break;
if (flags & INSTALL_HASH)
fprintf(stdout, "%-38s", _("Preparing..."));
else
fprintf(stdout, "%s\n", _("Preparing packages..."));
(void) fflush(stdout);
break;
case RPMCALLBACK_TRANS_STOP:
if (flags & INSTALL_HASH)
printHash(1, 1); /* Fixes "preparing..." progress bar */
rpmcliProgressTotal = rpmcliPackagesTotal;
rpmcliProgressCurrent = 0;
break;
case RPMCALLBACK_UNINST_STOP:
break;
case RPMCALLBACK_UNPACK_ERROR:
break;
case RPMCALLBACK_CPIO_ERROR:
break;
case RPMCALLBACK_SCRIPT_ERROR:
break;
case RPMCALLBACK_SCRIPT_START:
break;
case RPMCALLBACK_SCRIPT_STOP:
break;
case RPMCALLBACK_UNKNOWN:
default:
break;
}
return rc;
}
void * rpmShowProgress(const void * arg,
const rpmCallbackType what,
const rpm_loff_t amount,
const rpm_loff_t total,
fnpyKey key,
void * data)
{
Header h = (Header) arg;
char * s;
int flags = (int) ((long)data);
void * rc = NULL;
const char * filename = (const char *)key;
static FD_t fd = NULL;
int xx;
switch (what) {
case RPMCALLBACK_INST_OPEN_FILE:
if (filename == NULL || filename[0] == '\0')
return NULL;
fd = Fopen(filename, "r.ufdio");
/* FIX: still necessary? */
if (fd == NULL || Ferror(fd)) {
rpmlog(RPMLOG_ERR, _("open of %s failed: %s\n"), filename,
Fstrerror(fd));
if (fd != NULL) {
xx = Fclose(fd);
fd = NULL;
}
} else
fd = fdLink(fd, RPMDBG_M("persist (showProgress)"));
return (void *)fd;
break;
case RPMCALLBACK_INST_CLOSE_FILE:
/* FIX: still necessary? */
fd = fdFree(fd, RPMDBG_M("persist (showProgress)"));
if (fd != NULL) {
xx = Fclose(fd);
fd = NULL;
}
break;
case RPMCALLBACK_INST_START:
rpmcliHashesCurrent = 0;
if (h == NULL || !(flags & INSTALL_LABEL))
break;
/* @todo Remove headerFormat() on a progress callback. */
if (flags & INSTALL_HASH) {
s = headerFormat(h, "%{NAME}", NULL);
if (isatty (STDOUT_FILENO))
fprintf(stdout, "%4d:%-23.23s", rpmcliProgressCurrent + 1, s);
else
fprintf(stdout, "%-28.28s", s);
(void) fflush(stdout);
s = _free(s);
} else {
s = headerFormat(h, "%{NAME}-%{VERSION}-%{RELEASE}", NULL);
fprintf(stdout, "%s\n", s);
(void) fflush(stdout);
s = _free(s);
}
break;
case RPMCALLBACK_TRANS_PROGRESS:
case RPMCALLBACK_INST_PROGRESS:
if (flags & INSTALL_PERCENT)
fprintf(stdout, "%%%% %f\n", (double) (total
? ((((float) amount) / total) * 100)
: 100.0));
else if (flags & INSTALL_HASH)
printHash(amount, total);
(void) fflush(stdout);
break;
case RPMCALLBACK_TRANS_START:
rpmcliHashesCurrent = 0;
rpmcliProgressTotal = 1;
rpmcliProgressCurrent = 0;
if (!(flags & INSTALL_LABEL))
break;
if (flags & INSTALL_HASH)
fprintf(stdout, "%-28s", _("Preparing..."));
else
fprintf(stdout, "%s\n", _("Preparing packages for installation..."));
(void) fflush(stdout);
break;
case RPMCALLBACK_TRANS_STOP:
if (flags & INSTALL_HASH)
printHash(1, 1); /* Fixes "preparing..." progress bar */
rpmcliProgressTotal = rpmcliPackagesTotal;
rpmcliProgressCurrent = 0;
break;
case RPMCALLBACK_UNINST_PROGRESS:
break;
case RPMCALLBACK_UNINST_START:
break;
case RPMCALLBACK_UNINST_STOP:
break;
case RPMCALLBACK_UNPACK_ERROR:
break;
case RPMCALLBACK_CPIO_ERROR:
break;
case RPMCALLBACK_SCRIPT_ERROR:
break;
case RPMCALLBACK_UNKNOWN:
default:
break;
}
return rc;
}