folkslinux
/
rpm
mirror of https://github.com/rpm-software-management/rpm.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
rpm/lib/cpio.c

1710 lines
40 KiB
C
Raw Blame History

/** \ingroup payload rpmio
* \file lib/cpio.c
* Handle cpio payloads within rpm packages.
*
* \warning FIXME: We don't translate between cpio and system mode bits! These
* should both be the same, but really odd things are going to happen if
* that's not true!
*/
#include "system.h"
#include <rpmlib.h>
#include "rollback.h"
#include "rpmerr.h"
#include "debug.h"
/*@access FD_t@*/
/*@access rpmTransactionSet@*/
/*@access TFI_t@*/
#define CPIO_NEWC_MAGIC "070701"
#define CPIO_CRC_MAGIC "070702"
#define TRAILER "TRAILER!!!"
/** \ingroup payload
* Defines a single file to be included in a cpio payload.
*/
struct cpioFileMapping {
/*@dependent@*/ const char * archivePath; /*!< Path to store in cpio archive. */
/*@dependent@*/ const char * dirName; /*!< Payload file directory. */
/*@dependent@*/ const char * baseName; /*!< Payload file base name. */
/*@dependent@*/ const char * md5sum; /*!< File MD5 sum (NULL disables). */
mode_t finalMode; /*!< Mode of payload file (from header). */
uid_t finalUid; /*!< Uid of payload file (from header). */
gid_t finalGid; /*!< Gid of payload file (from header). */
cpioMapFlags mapFlags;
};
/** \ingroup payload
* Keeps track of set of all hard linked files in archive.
*/
struct hardLink {
struct hardLink * next;
const char ** files; /* nlink of these, used by install */
const void ** fileMaps;
dev_t dev;
ino_t inode;
int nlink;
int linksLeft;
int createdPath;
const struct stat sb;
};
/** \ingroup payload
*/
enum hardLinkType {
HARDLINK_INSTALL=1,
HARDLINK_BUILD
};
/** \ingroup payload
* Cpio archive header information.
* @todo Add support for tar (soon) and ar (eventually) archive formats.
*/
struct cpioCrcPhysicalHeader {
char magic[6];
char inode[8];
char mode[8];
char uid[8];
char gid[8];
char nlink[8];
char mtime[8];
char filesize[8];
char devMajor[8];
char devMinor[8];
char rdevMajor[8];
char rdevMinor[8];
char namesize[8];
char checksum[8]; /* ignored !! */
};
#define PHYS_HDR_SIZE 110 /*!< Don't depend on sizeof(struct) */
/** \ingroup payload
* File name and stat information.
*/
struct cpioHeader {
/*@owned@*/ const char * path;
FD_t cfd;
/*@owned@*/ void * mapi;
/*@dependent@*/ const void * map;
/*@owned@*/ struct hardLink * links;
/*@dependent@*/ struct hardLink * li;
/*@dependent@*/ const char ** failedFile;
int postpone;
int rc;
fileStage a;
struct stat sb;
};
#if 0
static void prtli(const char *msg, struct hardLink * li)
{
if (msg) fprintf(stderr, "%s", msg);
fprintf(stderr, " next %p files %p fileMaps %p dev %x ino %x nlink %d left %d createdPath %d size %d\n", li->next, li->files, li->fileMaps, (unsigned)li->dev, (unsigned)li->inode, li->nlink, li->linksLeft, li->createdPath, li->sb.st_size);
}
#endif
/**
*/
static int mapFlags(const void * this, cpioMapFlags mask) {
const struct cpioFileMapping * map = this;
return (map->mapFlags & mask);
}
/**
*/
static /*@only@*/ const char * mapArchivePath(const void * this) {
const struct cpioFileMapping * map = this;
return xstrdup(map->archivePath);
}
/**
*/
static /*@only@*/ const char * mapFsPath(const void * this) {
const struct cpioFileMapping * map = this;
char * t = xmalloc( strlen(map->dirName) + strlen(map->baseName) + 1);
(void) stpcpy( stpcpy(t, map->dirName), map->baseName);
return t;
}
/**
*/
static mode_t mapFinalMode(const void * this) {
const struct cpioFileMapping * map = this;
return map->finalMode;
}
/**
*/
static uid_t mapFinalUid(const void * this) {
const struct cpioFileMapping * map = this;
return map->finalUid;
}
/**
*/
static gid_t mapFinalGid(const void * this) {
const struct cpioFileMapping * map = this;
return map->finalGid;
}
/**
*/
static /*@observer@*/ const char * const mapMd5sum(const void * this) {
const struct cpioFileMapping * map = this;
return map->md5sum;
}
/**
*/
struct mapi {
/*@dependent@*/ rpmTransactionSet ts;
/*@dependent@*/ TFI_t fi;
int i;
struct cpioFileMapping map;
};
/**
*/
static const void * mapLink(const void * this) {
const struct cpioFileMapping * omap = this;
struct cpioFileMapping * nmap = xcalloc(1, sizeof(*nmap));
*nmap = *omap; /* structure assignment */
return nmap;
}
/**
*/
static void mapFree(/*@only@*/ const void * this) {
free((void *)this);
}
/**
*/
static void mapFreeIterator(/*@only@*/ const void * this)
{
struct mapi * mapi;
rpmTransactionSet ts;
TFI_t fi;
if (this == NULL)
return;
mapi = (void *)this;
ts = mapi->ts;
fi = mapi->fi;
if (ts && ts->notify) {
unsigned int archiveSize = (fi->archiveSize ? fi->archiveSize : 100);
(void)ts->notify(fi->h, RPMCALLBACK_INST_PROGRESS,
archiveSize, archiveSize,
(fi->ap ? fi->ap->key : NULL), ts->notifyData);
}
free((void *)this);
}
/**
*/
static void *
mapInitIterator(/*@kept@*/ const void * this, /*@kept@*/ const void * that)
{
struct mapi * mapi;
rpmTransactionSet ts = (void *)this;
TFI_t fi = (void *)that;
if (fi == NULL)
return NULL;
mapi = xcalloc(1, sizeof(*mapi));
mapi->ts = ts;
mapi->fi = fi;
mapi->i = 0;
if (ts && ts->notify) {
(void)ts->notify(fi->h, RPMCALLBACK_INST_START, 0, fi->archiveSize,
(fi->ap ? fi->ap->key : NULL), ts->notifyData);
}
return mapi;
}
/**
*/
static const void * mapNextIterator(void * this) {
struct mapi * mapi = this;
TFI_t fi = mapi->fi;
struct cpioFileMapping * map = &mapi->map;
int i = mapi->i;
do {
if (!((i = mapi->i) < fi->fc))
return NULL;
mapi->i++;
} while (fi->actions && XFA_SKIPPING(fi->actions[i]));
/* src rpms have simple base name in payload. */
map->archivePath = (fi->apath ? fi->apath[i] + fi->striplen : fi->bnl[i]);
map->dirName = fi->dnl[fi->dil[i]];
map->baseName = fi->bnl[i];
map->md5sum = (fi->fmd5s ? fi->fmd5s[i] : NULL);
map->finalMode = fi->fmodes[i];
map->finalUid = (fi->fuids ? fi->fuids[i] : fi->uid); /* XXX chmod u-s */
map->finalGid = (fi->fgids ? fi->fgids[i] : fi->gid); /* XXX chmod g-s */
map->mapFlags = (fi->fmapflags ? fi->fmapflags[i] : fi->mapflags);
return map;
}
/**
*/
static int cpioStrCmp(const void * a, const void * b) {
const char * afn = *(const char **)a;
const char * bfn = *(const char **)b;
/* Match rpm-4.0 payloads with ./ prefixes. */
if (afn[0] == '.' && afn[1] == '/') afn += 2;
if (bfn[0] == '.' && bfn[1] == '/') bfn += 2;
/* If either path is absolute, make it relative. */
if (afn[0] == '/') afn += 1;
if (bfn[0] == '/') bfn += 1;
return strcmp(afn, bfn);
}
/**
*/
static const void * mapFind(void * this, const char * hdrPath) {
struct mapi * mapi = this;
const TFI_t fi = mapi->fi;
const char ** p;
p = bsearch(&hdrPath, fi->apath, fi->fc, sizeof(hdrPath), cpioStrCmp);
if (p == NULL) {
fprintf(stderr, "*** not mapped %s\n", hdrPath);
return NULL;
}
mapi->i = p - fi->apath;
return mapNextIterator(this);
}
/**
*/
static void pkgCallback(const struct cpioHeader * hdr)
{
struct mapi * mapi = hdr->mapi;
rpmTransactionSet ts;
TFI_t fi;
if (mapi == NULL)
return;
ts = mapi->ts;
fi = mapi->fi;
if (ts && ts->notify)
(void)ts->notify(fi->h, RPMCALLBACK_INST_PROGRESS,
fdGetCpioPos(hdr->cfd), fi->archiveSize,
(fi->ap ? fi->ap->key : NULL), ts->notifyData);
}
/**
* Read data from payload.
* @param cfd payload file handle
* @retval vbuf data from read
* @param amount no. bytes to read
* @return no. bytes read
*/
static inline off_t saferead(FD_t cfd, /*@out@*/void * vbuf, size_t amount)
/*@modifies cfd, *vbuf @*/
{
off_t rc = 0;
char * buf = vbuf;
while (amount > 0) {
size_t nb;
nb = Fread(buf, sizeof(buf[0]), amount, cfd);
if (nb <= 0)
return nb;
rc += nb;
if (rc >= amount)
break;
buf += nb;
amount -= nb;
}
return rc;
}
/**
* Read data from payload and update number of bytes read.
* @param cfd payload file handle
* @retval buf data from read
* @param size no. bytes to read
* @return no. bytes read
*/
static inline off_t ourread(FD_t cfd, /*@out@*/void * buf, size_t size)
/*@modifies cfd, *buf @*/
{
off_t i = saferead(cfd, buf, size);
if (i > 0)
fdSetCpioPos(cfd, fdGetCpioPos(cfd) + i);
return i;
}
/**
* Align input payload handle, skipping input bytes.
* @param cfd payload file handle
* @param modulo data alignment
*/
static inline void padinfd(FD_t cfd, int modulo)
/*@modifies cfd @*/
{
int buf[10];
int amount;
amount = (modulo - fdGetCpioPos(cfd) % modulo) % modulo;
(void)ourread(cfd, buf, amount);
}
/**
* Write data to payload.
* @param cfd payload file handle
* @param vbuf data to write
* @param amount no. bytes to write
* @return no. bytes written
*/
static inline off_t safewrite(FD_t cfd, const void * vbuf, size_t amount)
/*@modifies cfd @*/
{
off_t rc = 0;
const char * buf = vbuf;
while (amount > 0) {
size_t nb;
nb = Fwrite(buf, sizeof(buf[0]), amount, cfd);
if (nb <= 0)
return nb;
rc += nb;
if (rc >= amount)
break;
buf += nb;
amount -= nb;
}
return rc;
}
/**
* Align output payload handle, padding with zeroes.
* @param cfd payload file handle
* @param modulo data alignment
* @return 0 on success, CPIOERR_WRITE_FAILED
*/
static inline int padoutfd(FD_t cfd, size_t * where, int modulo)
/*@modifies cfd, *where @*/
{
static int buf[10] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
int amount;
amount = (modulo - *where % modulo) % modulo;
*where += amount;
if (safewrite(cfd, buf, amount) != amount)
return CPIOERR_WRITE_FAILED;
return 0;
}
/**
* Convert string to unsigned integer (with buffer size check).
* @param input string
* @retval address of 1st character not processed
* @param base numerical conversion base
* @param num max no. of bytes to read
* @return converted integer
*/
static int strntoul(const char *str, /*@out@*/char **endptr, int base, int num)
/*@modifies *endptr @*/
{
char * buf, * end;
unsigned long ret;
buf = alloca(num + 1);
strncpy(buf, str, num);
buf[num] = '\0';
ret = strtoul(buf, &end, base);
if (*end)
*endptr = ((char *)str) + (end - buf); /* XXX discards const */
else
*endptr = ((char *)str) + strlen(str);
return ret;
}
#define GET_NUM_FIELD(phys, log) \
log = strntoul(phys, &end, 16, sizeof(phys)); \
if (*end) return CPIOERR_BAD_HEADER;
#define SET_NUM_FIELD(phys, val, space) \
sprintf(space, "%8.8lx", (unsigned long) (val)); \
memcpy(phys, space, 8);
/**
* Process next cpio heasder.
* @retval hdr file name and stat info
* @return 0 on success
*/
static int getNextHeader(struct cpioHeader * hdr)
/*@modifies hdr->cfd, hdr->path, hdr->sb @*/
{
struct cpioCrcPhysicalHeader physHeader;
struct stat * st = &hdr->sb;
int nameSize;
char * end;
int major, minor;
if (ourread(hdr->cfd, &physHeader, PHYS_HDR_SIZE) != PHYS_HDR_SIZE)
return CPIOERR_READ_FAILED;
if (strncmp(CPIO_CRC_MAGIC, physHeader.magic, sizeof(CPIO_CRC_MAGIC)-1) &&
strncmp(CPIO_NEWC_MAGIC, physHeader.magic, sizeof(CPIO_NEWC_MAGIC)-1))
return CPIOERR_BAD_MAGIC;
GET_NUM_FIELD(physHeader.inode, st->st_ino);
GET_NUM_FIELD(physHeader.mode, st->st_mode);
GET_NUM_FIELD(physHeader.uid, st->st_uid);
GET_NUM_FIELD(physHeader.gid, st->st_gid);
GET_NUM_FIELD(physHeader.nlink, st->st_nlink);
GET_NUM_FIELD(physHeader.mtime, st->st_mtime);
GET_NUM_FIELD(physHeader.filesize, st->st_size);
GET_NUM_FIELD(physHeader.devMajor, major);
GET_NUM_FIELD(physHeader.devMinor, minor);
st->st_dev = /*@-shiftsigned@*/ makedev(major, minor) /*@=shiftsigned@*/ ;
GET_NUM_FIELD(physHeader.rdevMajor, major);
GET_NUM_FIELD(physHeader.rdevMinor, minor);
st->st_rdev = /*@-shiftsigned@*/ makedev(major, minor) /*@=shiftsigned@*/ ;
GET_NUM_FIELD(physHeader.namesize, nameSize);
{ char * t = xmalloc(nameSize + 1);
if (ourread(hdr->cfd, t, nameSize) != nameSize) {
free(t);
hdr->path = NULL;
return CPIOERR_BAD_HEADER;
}
hdr->path = t;
}
/* this is unecessary hdr->path[nameSize] = '\0'; */
padinfd(hdr->cfd, 4);
return 0;
}
/* This could trash files in the path! I'm not sure that's a good thing */
/**
* @param path directory path
* @param perms directory permissions
* @return 0 on success
*/
static int createDirectory(const char * path, mode_t perms)
/*@modifies fileSystem @*/
{
struct stat st;
if (!lstat(path, &st)) {
if (S_ISDIR(st.st_mode))
return 0;
if (S_ISLNK(st.st_mode)) {
if (stat(path, &st)) {
if (errno != ENOENT)
return CPIOERR_STAT_FAILED;
} else {
if (S_ISDIR(st.st_mode))
return 0;
}
}
if (unlink(path))
return CPIOERR_UNLINK_FAILED;
}
if (mkdir(path, 000))
return CPIOERR_MKDIR_FAILED;
if (perms != 000 && chmod(path, perms))
return CPIOERR_CHMOD_FAILED;
return 0;
}
/**
* Set owner, group, and modify/access times.
* @param hdr file name and stat info
* @return 0 on success
*/
static int setInfo(const struct cpioHeader * hdr)
/*@modifies fileSystem @*/
{
int rc = 0;
struct utimbuf stamp;
const struct stat * st = &hdr->sb;
stamp.actime = st->st_mtime;
stamp.modtime = st->st_mtime;
if (!S_ISLNK(st->st_mode)) {
if (!getuid() && chown(hdr->path, st->st_uid, st->st_gid))
rc = CPIOERR_CHOWN_FAILED;
if (!rc && chmod(hdr->path, st->st_mode & 07777))
rc = CPIOERR_CHMOD_FAILED;
if (!rc && utime(hdr->path, &stamp))
rc = CPIOERR_UTIME_FAILED;
} else {
# if ! CHOWN_FOLLOWS_SYMLINK
if (!getuid() && !rc && lchown(hdr->path, st->st_uid, st->st_gid))
rc = CPIOERR_CHOWN_FAILED;
# endif
}
return rc;
}
/**
* Create directories in file path (like "mkdir -p").
* @param filename file path
* @return 0 on success
*/
static int inline checkDirectory(const char * filename) /*@*/
{
/*@only@*/ static char * lastDir = NULL; /* XXX memory leak */
static int lastDirLength = 0;
static int lastDirAlloced = 0;
int length = strlen(filename);
char * buf;
char * chptr;
int rc = 0;
buf = alloca(length + 1);
strcpy(buf, filename);
for (chptr = buf + length - 1; chptr > buf; chptr--) {
if (*chptr == '/') break;
}
if (chptr == buf) return 0; /* /filename - no directories */
*chptr = '\0'; /* buffer is now just directories */
length = strlen(buf);
if (lastDirLength == length && !strcmp(buf, lastDir)) return 0;
if (lastDirAlloced < (length + 1)) {
lastDirAlloced = length + 100;
lastDir = xrealloc(lastDir, lastDirAlloced); /* XXX memory leak */
}
strcpy(lastDir, buf);
lastDirLength = length;
for (chptr = buf + 1; *chptr; chptr++) {
if (*chptr == '/') {
*chptr = '\0';
rc = createDirectory(buf, 0755);
*chptr = '/';
if (rc) return rc;
}
}
rc = createDirectory(buf, 0755);
return rc;
}
/**
* Create file from payload stream.
* @todo Legacy: support brokenEndian MD5 checks?
* @param hdr file name and stat info
* @return 0 on success
*/
static int expandRegular(const struct cpioHeader * hdr)
/*@modifies fileSystem, hdr->cfd @*/
{
const char * filemd5;
FD_t ofd;
char buf[BUFSIZ];
int bytesRead;
const struct stat * st = &hdr->sb;
int left = st->st_size;
int rc = 0;
struct stat sb;
filemd5 = mapMd5sum(hdr->map);
/* Rename the old file before attempting unlink to avoid EBUSY errors */
if (!lstat(hdr->path, &sb)) {
strcpy(buf, hdr->path);
strcat(buf, "-RPMDELETE");
if (rename(hdr->path, buf)) {
rpmError(RPMERR_RENAME, _("can't rename %s to %s: %s\n"),
hdr->path, buf, strerror(errno));
return CPIOERR_UNLINK_FAILED;
}
if (unlink(buf)) {
rpmError(RPMERR_UNLINK, _("can't unlink %s: %s\n"),
buf, strerror(errno));
#if 0
return CPIOERR_UNLINK_FAILED;
#endif
}
}
ofd = Fopen(hdr->path, "w.ufdio");
if (ofd == NULL || Ferror(ofd))
return CPIOERR_OPEN_FAILED;
/* XXX This doesn't support brokenEndian checks. */
if (filemd5)
fdInitMD5(ofd, 0);
while (left) {
bytesRead = ourread(hdr->cfd, buf, left < sizeof(buf) ? left : sizeof(buf));
if (bytesRead <= 0) {
rc = CPIOERR_READ_FAILED;
break;
}
if (Fwrite(buf, sizeof(buf[0]), bytesRead, ofd) != bytesRead) {
rc = CPIOERR_COPY_FAILED;
break;
}
left -= bytesRead;
/* don't call this with fileSize == fileComplete */
if (!rc && left)
pkgCallback(hdr);
}
if (filemd5) {
const char * md5sum = NULL;
Fflush(ofd);
fdFiniMD5(ofd, (void **)&md5sum, NULL, 1);
if (md5sum == NULL) {
rc = CPIOERR_MD5SUM_MISMATCH;
} else {
if (strcmp(md5sum, filemd5))
rc = CPIOERR_MD5SUM_MISMATCH;
free((void *)md5sum);
}
}
Fclose(ofd);
return rc;
}
/**
* Create symlink from payload stream.
* @param hdr file name and stat info
* @return 0 on success
*/
static int expandSymlink(const struct cpioHeader * hdr)
/*@modifies fileSystem, hdr->cfd @*/
{
char buf[2048], buf2[2048];
struct stat sb;
const struct stat * st = &hdr->sb;
int len;
if ((st->st_size + 1)> sizeof(buf))
return CPIOERR_HDR_SIZE;
if (ourread(hdr->cfd, buf, st->st_size) != st->st_size)
return CPIOERR_READ_FAILED;
buf[st->st_size] = '\0';
if (!lstat(hdr->path, &sb)) {
if (S_ISLNK(sb.st_mode)) {
len = readlink(hdr->path, buf2, sizeof(buf2) - 1);
if (len > 0) {
buf2[len] = '\0';
if (!strcmp(buf, buf2)) return 0;
}
}
if (unlink(hdr->path))
return CPIOERR_UNLINK_FAILED;
}
if (symlink(buf, hdr->path) < 0)
return CPIOERR_SYMLINK_FAILED;
return 0;
}
/**
* Create fifo from payload stream.
* @param hdr file name and stat info
* @return 0 on success
*/
static int expandFifo(const struct cpioHeader * hdr)
/*@modifies fileSystem @*/
{
struct stat sb;
if (!lstat(hdr->path, &sb)) {
if (S_ISFIFO(sb.st_mode)) return 0;
if (unlink(hdr->path))
return CPIOERR_UNLINK_FAILED;
}
if (mkfifo(hdr->path, 0))
return CPIOERR_MKFIFO_FAILED;
return 0;
}
/**
* Create fifo from payload stream.
* @param hdr file name and stat info
* @return 0 on success
*/
static int expandDevice(const struct cpioHeader * hdr)
/*@modifies fileSystem @*/
{
const struct stat * st = &hdr->sb;
struct stat sb;
if (!lstat(hdr->path, &sb)) {
if ((S_ISCHR(sb.st_mode) || S_ISBLK(sb.st_mode)) &&
(sb.st_rdev == st->st_rdev))
return 0;
if (unlink(hdr->path))
return CPIOERR_UNLINK_FAILED;
}
if ( /*@-unrecog@*/ mknod(hdr->path, st->st_mode & (~0777), st->st_rdev) /*@=unrecog@*/ )
return CPIOERR_MKNOD_FAILED;
return 0;
}
/**
* Create and initialize set of hard links.
* @param st link stat info
* @param hltype type of hard link set to create
* @return pointer to set of hard links
*/
static /*@only@*/ struct hardLink * newHardLink(const struct stat * st,
enum hardLinkType hltype) /*@*/
{
struct hardLink * li = xmalloc(sizeof(*li));
li->next = NULL;
li->nlink = st->st_nlink;
li->dev = st->st_dev;
li->inode = st->st_ino;
li->createdPath = -1;
switch (hltype) {
case HARDLINK_INSTALL:
li->linksLeft = st->st_nlink;
li->fileMaps = xcalloc(st->st_nlink, sizeof(li->fileMaps[0]));
li->files = NULL;
break;
case HARDLINK_BUILD:
li->linksLeft = 0;
li->fileMaps = NULL;
li->files = xcalloc(st->st_nlink, sizeof(*li->files));
break;
}
{ struct stat * myst = (struct stat *) &li->sb;
*myst = *st; /* structure assignment */
}
return li;
}
/**
* Destroy set of hard links.
* @param li set of hard links
*/
static void freeHardLink( /*@only@*/ struct hardLink * li)
{
if (li->files) {
int i;
for (i = 0; i < li->nlink; i++) {
if (li->files[i] == NULL) continue;
/*@-unqualifiedtrans@*/ free((void *)li->files[i]) /*@=unqualifiedtrans@*/ ;
li->files[i] = NULL;
}
free(li->files);
li->files = NULL;
}
if (li->fileMaps) {
free(li->fileMaps);
li->fileMaps = NULL;
}
free(li);
}
/**
* Create hard links to existing file.
* @return 0 on success
*/
static int createLinks(struct cpioHeader * hdr)
/*@modifies hdr, fileSystem @*/
{
struct stat sb;
int i;
for (i = 0; i < hdr->li->nlink; i++) {
if (i == hdr->li->createdPath) continue;
if (hdr->li->files[i] == NULL) continue;
if (!lstat(hdr->li->files[i], &sb)) {
if (unlink(hdr->li->files[i])) {
if (hdr->failedFile)
*hdr->failedFile = xstrdup(hdr->li->files[i]);
return CPIOERR_UNLINK_FAILED;
}
}
if (link(hdr->li->files[hdr->li->createdPath], hdr->li->files[i])) {
if (hdr->failedFile)
*hdr->failedFile = xstrdup(hdr->li->files[i]);
return CPIOERR_LINK_FAILED;
}
/*@-unqualifiedtrans@*/ free((void *)hdr->li->files[i]) /*@=unqualifiedtrans@*/ ;
hdr->li->files[i] = NULL;
hdr->li->linksLeft--;
}
return 0;
}
/**
* Skip amount bytes on input payload stream.
* @param cfd payload file handle
* @param amount no. bytes to skip
* @return 0 on success
*/
static int eatBytes(FD_t cfd, int amount)
/*@modifies cfd @*/
{
char buf[4096];
int bite;
while (amount) {
bite = (amount > sizeof(buf)) ? sizeof(buf) : amount;
if (ourread(cfd, buf, bite) != bite)
return CPIOERR_READ_FAILED;
amount -= bite;
}
return 0;
}
/**
* Cpio archive extraction state machine.
*/
static int hdrStage(struct cpioHeader * hdr, fileStage a)
{
#ifdef UNUSED
const char * const prev = fileStageString(hdr->a);
#endif
const char * const cur = fileStageString(a);
struct stat * st = &hdr->sb;
int rc = hdr->rc;
switch (a) {
case FI_CREATE:
memset(hdr, 0, sizeof(*hdr));
hdr->path = NULL;
hdr->map = NULL;
hdr->links = NULL;
hdr->li = NULL;
break;
case FI_INIT:
if (hdr->path) {
free((void *)hdr->path); hdr->path = NULL;
}
hdr->postpone = 0;
rc = getNextHeader(hdr);
break;
case FI_MAP:
if (hdr->mapi) {
hdr->map = mapFind(hdr->mapi, hdr->path);
if (hdr->map) {
if (mapFlags(hdr->map, CPIO_MAP_PATH)) {
if (hdr->path) free((void *)hdr->path);
hdr->path = mapFsPath(hdr->map);
}
if (mapFlags(hdr->map, CPIO_MAP_MODE))
st->st_mode = mapFinalMode(hdr->map);
if (mapFlags(hdr->map, CPIO_MAP_UID))
st->st_uid = mapFinalUid(hdr->map);
if (mapFlags(hdr->map, CPIO_MAP_GID))
st->st_gid = mapFinalGid(hdr->map);
}
}
rpmMessage(RPMMESS_DEBUG, _("\t%s path %s\n"), cur, hdr->path);
break;
case FI_SKIP:
eatBytes(hdr->cfd, st->st_size);
break;
case FI_PRE:
rpmMessage(RPMMESS_DEBUG, _("\t%s mkdir/rename %s.TID\n"),
cur, hdr->path);
/*
* This won't get hard linked symlinks right, but I can't seem
* to create those anyway.
*/
if (S_ISREG(st->st_mode) && st->st_nlink > 1) {
for (hdr->li = hdr->links; hdr->li; hdr->li = hdr->li->next) {
if (hdr->li->inode == st->st_ino && hdr->li->dev == st->st_dev)
break;
}
if (hdr->li == NULL) {
hdr->li = newHardLink(st, HARDLINK_BUILD);
hdr->li->next = hdr->links;
hdr->links = hdr->li;
}
hdr->li->files[hdr->li->linksLeft++] = xstrdup(hdr->path);
/* XXX FIXME 0 length hard linked files are broke. */
if (st->st_size && hdr->li->createdPath == -1) {
createLinks(hdr);
/*
* This only happens for cpio archives which contain
* hardlinks w/ the contents of each hardlink being
* listed (intead of the data being given just once. This
* shouldn't happen, but I've made it happen w/ buggy
* code, so what the heck? GNU cpio handles this well fwiw.
*/
eatBytes(hdr->cfd, st->st_size);
}
hdr->postpone = 1;
break;
}
/* XXX diddle hdr->path. */
/* XXX keep track of created directories. */
rc = checkDirectory(hdr->path);
break;
case FI_PROCESS:
if (hdr->postpone)
break;
rpmMessage(RPMMESS_DEBUG, _("\t%s install %s.TID\n"), cur, hdr->path);
if (S_ISREG(st->st_mode))
rc = expandRegular(hdr);
else if (S_ISDIR(st->st_mode))
rc = createDirectory(hdr->path, 000);
else if (S_ISLNK(st->st_mode))
rc = expandSymlink(hdr);
else if (S_ISFIFO(st->st_mode))
rc = expandFifo(hdr);
else if (S_ISCHR(st->st_mode) || S_ISBLK(st->st_mode))
rc = expandDevice(hdr);
else if (S_ISSOCK(st->st_mode))
/* this mimics cpio but probably isnt' right */
rc = expandFifo(hdr);
else
rc = CPIOERR_UNKNOWN_FILETYPE;
break;
case FI_POST:
if (hdr->postpone)
break;
rpmMessage(RPMMESS_DEBUG, _("\t%s set info %s.TID\n"), cur, hdr->path);
if (!rc)
rc = setInfo(hdr);
if (!rc && S_ISREG(st->st_mode) && st->st_nlink > 1) {
hdr->li->createdPath = --hdr->li->linksLeft;
rc = createLinks(hdr);
}
break;
case FI_NOTIFY:
pkgCallback(hdr);
break;
case FI_UNDO:
{ int olderrno = errno;
(void) unlink(hdr->path);
/* XXX remove created directories. */
errno = olderrno;
if (hdr->failedFile && *hdr->failedFile == NULL)
*hdr->failedFile = xstrdup(hdr->path);
}
break;
case FI_COMMIT:
rpmMessage(RPMMESS_DEBUG, _("\t%s rename/rmdir %s\n"), cur, hdr->path);
break;
case FI_DESTROY:
if (hdr->path) {
free((void *)hdr->path); hdr->path = NULL;
}
/* Create any remaining links (if no error), and clean up. */
rc = hdr->rc;
while ((hdr->li = hdr->links) != NULL) {
hdr->links = hdr->li->next;
hdr->li->next = NULL;
if (rc == 0 && hdr->li->linksLeft)
rc = (hdr->li->createdPath != -1)
? createLinks(hdr) : CPIOERR_MISSING_HARDLINK;
freeHardLink(hdr->li);
}
break;
default:
break;
}
hdr->a = a;
hdr->rc = rc;
return rc;
}
/** @todo Verify payload MD5 sum. */
int cpioInstallArchive(const rpmTransactionSet ts, const TFI_t fi, FD_t cfd,
const char ** failedFile)
{
struct cpioHeader ch, *hdr = &ch;
#ifdef DYING
const void * map = NULL;
struct hardLink * links = NULL;
struct hardLink * li = NULL;
#endif
int rc = 0;
#ifdef NOTYET
char * md5sum = NULL;
fdInitMD5(cfd, 0);
#endif
/* Initialize hdr. */
rc = hdrStage(hdr, FI_CREATE);
#ifdef DYING
memset(hdr, 0, sizeof(*hdr));
hdr->path = NULL;
hdr->map = NULL;
hdr->links = NULL;
hdr->li = NULL;
#endif
hdr->cfd = fdLink(cfd, "persist (cpioInstallArchive");
fdSetCpioPos(hdr->cfd, 0);
hdr->mapi = mapInitIterator(ts, fi);
hdr->failedFile = failedFile;
if (hdr->failedFile)
*hdr->failedFile = NULL;
do {
#ifdef DYING
struct stat * st;
if (hdr->path) {
free((void *)hdr->path);
hdr->path = NULL;
}
#endif
/* Clean hdr, free'ing memory, and read next archive header. */
rc = hdrStage(hdr, FI_INIT);
#ifdef DYING
rc = getNextHeader(hdr);
#endif
if (rc) {
#if 0 /* XXX this is the failure point for an unreadable rpm */
rpmError(RPMERR_BADPACKAGE, _("getNextHeader: %s\n"),
cpioStrerror(rc));
#endif
goto exit;
}
if (!strcmp(hdr->path, TRAILER))
break;
#ifdef DYING
st = &hdr->sb;
#endif
/* Remap mode/uid/gid/name of file from archive. */
(void) hdrStage(hdr, FI_MAP);
#ifdef DYING
if (hdr->mapi) {
hdr->map = mapFind(hdr->mapi, hdr->path);
if (hdr->map) {
if (mapFlags(hdr->map, CPIO_MAP_PATH)) {
if (hdr->path) free((void *)hdr->path);
hdr->path = mapFsPath(hdr->map);
}
if (mapFlags(hdr->map, CPIO_MAP_MODE))
st->st_mode = mapFinalMode(hdr->map);
if (mapFlags(hdr->map, CPIO_MAP_UID))
st->st_uid = mapFinalUid(hdr->map);
if (mapFlags(hdr->map, CPIO_MAP_GID))
st->st_gid = mapFinalGid(hdr->map);
}
}
#endif
if (hdr->mapi && hdr->map == NULL) {
rc = hdrStage(hdr, FI_SKIP);
#ifdef DYING
eatBytes(hdr->cfd, st->st_size);
#endif
} else {
#ifdef DYING
/*
* This won't get hard linked symlinks right, but I can't seem
* to create those anyway.
*/
if (S_ISREG(st->st_mode) && st->st_nlink > 1) {
for (hdr->li = hdr->links; hdr->li; hdr->li = hdr->li->next) {
if (hdr->li->inode == st->st_ino &&
hdr->li->dev == st->st_dev)
break;
}
if (hdr->li == NULL) {
hdr->li = newHardLink(st, HARDLINK_BUILD);
hdr->li->next = hdr->links;
hdr->links = hdr->li;
}
hdr->li->files[hdr->li->linksLeft++] = xstrdup(hdr->path);
/* XXX FIXME 0 length hard linked files are broke. */
if (st->st_size && hdr->li->createdPath == -1) {
createLinks(hdr);
/*
* This only happens for cpio archives which contain
* hardlinks w/ the contents of each hardlink being
* listed (intead of the data being given just once. This
* shouldn't happen, but I've made it happen w/ buggy
* code, so what the heck? GNU cpio handles this well fwiw.
*/
eatBytes(hdr->cfd, st->st_size);
}
} else
#endif
{
/* Create any directories in path. */
rc = hdrStage(hdr, FI_PRE);
#ifdef DYING */
rc = checkDirectory(hdr->path);
#endif
if (!rc) {
/* Extract file from archive. */
rc = hdrStage(hdr, FI_PROCESS);
#ifdef DYING
if (S_ISREG(st->st_mode))
rc = expandRegular(hdr);
else if (S_ISDIR(st->st_mode))
rc = createDirectory(hdr->path, 000);
else if (S_ISLNK(st->st_mode))
rc = expandSymlink(hdr);
else if (S_ISFIFO(st->st_mode))
rc = expandFifo(hdr);
else if (S_ISCHR(st->st_mode) || S_ISBLK(st->st_mode))
rc = expandDevice(hdr);
else if (S_ISSOCK(st->st_mode)) {
/* this mimics cpio but probably isnt' right */
rc = expandFifo(hdr);
} else {
rc = CPIOERR_UNKNOWN_FILETYPE;
}
#endif
}
/* If successfully extracted, set final file info. */
if (!rc)
rc = hdrStage(hdr, FI_POST);
#ifdef DYING
if (!rc)
rc = setInfo(hdr);
if (!rc && S_ISREG(st->st_mode) && st->st_nlink > 1) {
li->createdPath = --li->linksLeft;
rc = createLinks(hdr);
}
#endif
}
#ifdef DYING
if (rc && hdr->failedFile && *hdr->failedFile == NULL) {
int olderrno;
*hdr->failedFile = xstrdup(hdr->path);
olderrno = errno;
unlink(hdr->path);
errno = olderrno;
}
#endif
}
padinfd(hdr->cfd, 4);
/* Notify on success. */
if (!rc)
#ifdef DYING
pkgCallback(hdr);
#else
(void) hdrStage(hdr, FI_NOTIFY);
#endif
(void) hdrStage(hdr, (rc ? FI_UNDO : FI_COMMIT));
} while (rc == 0);
rc = hdrStage(hdr, FI_DESTROY);
#ifdef DYING
(void) hdrStage(hdr, FI_UNKNOWN);
if (hdr->path) {
free((void *)hdr->path);
hdr->path = NULL;
}
/* Create any remaining links (if no error), and clean up. */
while ((hdr->li = hdr->links) != NULL) {
hdr->links = hdr->li->next;
hdr->li->next = NULL;
if (rc == 0 && hdr->li->linksLeft) {
if (hdr->li->createdPath == -1)
rc = CPIOERR_MISSING_HARDLINK;
else
rc = createLinks(hdr);
}
freeHardLink(hdr->li);
}
#endif
#ifdef NOTYET
fdFiniMD5(hdr->cfd, (void **)&md5sum, NULL, 1);
if (md5sum)
free(md5sum);
#endif
exit:
if (hdr->cfd) {
fdFree(hdr->cfd, "persist (cpioInstallArchive");
hdr->cfd = NULL;
}
if (hdr->mapi)
mapFreeIterator(hdr->mapi);
return rc;
}
/**
* Write next item to payload stream.
* @param ts transaction set
* @param fi transaction element file info
* @param cfd payload file handle
* @param st stat info for item
* @param map mapping name and flags for item
* @retval sizep address of no. bytes written
* @param writeData should data be written?
* @return 0 on success
*/
static int writeFile(const rpmTransactionSet ts, TFI_t fi, FD_t cfd,
const struct stat * st, const void * map, /*@out@*/ size_t * sizep,
int writeData)
/*@modifies cfd, *sizep @*/
{
const char * fsPath = mapFsPath(map);
const char * archivePath = NULL;
const char * hdrPath = !mapFlags(map, CPIO_MAP_PATH)
? fsPath : (archivePath = mapArchivePath(map));
struct cpioCrcPhysicalHeader hdr;
char buf[8192], symbuf[2048];
dev_t num;
FD_t datafd;
size_t st_size = st->st_size; /* XXX hard links need size preserved */
mode_t st_mode = st->st_mode;
uid_t st_uid = st->st_uid;
gid_t st_gid = st->st_gid;
size_t size, amount = 0;
int rc;
if (mapFlags(map, CPIO_MAP_MODE))
st_mode = (st_mode & S_IFMT) | mapFinalMode(map);
if (mapFlags(map, CPIO_MAP_UID))
st_uid = mapFinalUid(map);
if (mapFlags(map, CPIO_MAP_GID))
st_gid = mapFinalGid(map);
if (!writeData || S_ISDIR(st_mode)) {
st_size = 0;
} else if (S_ISLNK(st_mode)) {
/*
* While linux puts the size of a symlink in the st_size field,
* I don't think that's a specified standard.
*/
amount = Readlink(fsPath, symbuf, sizeof(symbuf));
if (amount <= 0) {
rc = CPIOERR_READLINK_FAILED;
goto exit;
}
st_size = amount;
}
memcpy(hdr.magic, CPIO_NEWC_MAGIC, sizeof(hdr.magic));
SET_NUM_FIELD(hdr.inode, st->st_ino, buf);
SET_NUM_FIELD(hdr.mode, st_mode, buf);
SET_NUM_FIELD(hdr.uid, st_uid, buf);
SET_NUM_FIELD(hdr.gid, st_gid, buf);
SET_NUM_FIELD(hdr.nlink, st->st_nlink, buf);
SET_NUM_FIELD(hdr.mtime, st->st_mtime, buf);
SET_NUM_FIELD(hdr.filesize, st_size, buf);
num = major((unsigned)st->st_dev); SET_NUM_FIELD(hdr.devMajor, num, buf);
num = minor((unsigned)st->st_dev); SET_NUM_FIELD(hdr.devMinor, num, buf);
num = major((unsigned)st->st_rdev); SET_NUM_FIELD(hdr.rdevMajor, num, buf);
num = minor((unsigned)st->st_rdev); SET_NUM_FIELD(hdr.rdevMinor, num, buf);
num = strlen(hdrPath) + 1; SET_NUM_FIELD(hdr.namesize, num, buf);
memcpy(hdr.checksum, "00000000", 8);
if ((rc = safewrite(cfd, &hdr, PHYS_HDR_SIZE)) != PHYS_HDR_SIZE)
goto exit;
if ((rc = safewrite(cfd, hdrPath, num)) != num)
goto exit;
size = PHYS_HDR_SIZE + num;
if ((rc = padoutfd(cfd, &size, 4)))
goto exit;
if (writeData && S_ISREG(st_mode)) {
char *b;
#if HAVE_MMAP
void *mapped;
size_t nmapped;
#endif
/* XXX unbuffered mmap generates *lots* of fdio debugging */
datafd = Fopen(fsPath, "r.ufdio");
if (datafd == NULL || Ferror(datafd)) {
rc = CPIOERR_OPEN_FAILED;
goto exit;
}
#if HAVE_MMAP
nmapped = 0;
mapped = mmap(NULL, st_size, PROT_READ, MAP_SHARED, Fileno(datafd), 0);
if (mapped != (void *)-1) {
b = (char *)mapped;
nmapped = st_size;
} else
#endif
{
b = buf;
}
size += st_size;
while (st_size) {
#if HAVE_MMAP
if (mapped != (void *)-1) {
amount = nmapped;
} else
#endif
{
amount = Fread(b, sizeof(buf[0]),
(st_size > sizeof(buf) ? sizeof(buf) : st_size),
datafd);
if (amount <= 0) {
int olderrno = errno;
Fclose(datafd);
errno = olderrno;
rc = CPIOERR_READ_FAILED;
goto exit;
}
}
if ((rc = safewrite(cfd, b, amount)) != amount) {
int olderrno = errno;
Fclose(datafd);
errno = olderrno;
goto exit;
}
st_size -= amount;
}
#if HAVE_MMAP
if (mapped != (void *)-1) {
/*@-noeffect@*/ munmap(mapped, nmapped) /*@=noeffect@*/;
}
#endif
Fclose(datafd);
} else if (writeData && S_ISLNK(st_mode)) {
if ((rc = safewrite(cfd, symbuf, amount)) != amount)
goto exit;
size += amount;
}
/* this is a noop for most file types */
if ((rc = padoutfd(cfd, &size, 4)))
goto exit;
if (sizep)
*sizep = size;
if (ts && fi && ts->notify) {
(void)ts->notify(fi->h, RPMCALLBACK_INST_PROGRESS, size, size,
(fi->ap ? fi->ap->key : NULL), ts->notifyData);
}
rc = 0;
exit:
if (fsPath) free((void *)fsPath);
return rc;
}
/**
* Write set of linked files to payload stream.
* @param ts transaction set
* @param fi transaction element file info
* @param cfd payload file handle
* @param hlink set of linked files
* @retval sizep address of no. bytes written
* @retval failedFile on error, file name that failed
* @return 0 on success
*/
static int writeLinkedFile(const rpmTransactionSet ts, TFI_t fi, FD_t cfd,
const struct hardLink * hlink, /*@out@*/size_t * sizep,
/*@out@*/const char ** failedFile)
/*@modifies cfd, *sizep, *failedFile @*/
{
const void * map = NULL;
size_t total = 0;
size_t size;
int rc = 0;
int i;
for (i = hlink->nlink - 1; i > hlink->linksLeft; i--) {
map = hlink->fileMaps[i];
if ((rc = writeFile(ts, fi, cfd, &hlink->sb, map, &size, 0)) != 0) {
if (failedFile)
*failedFile = mapFsPath(map);
goto exit;
}
total += size;
mapFree(map); map = NULL;
}
i = hlink->linksLeft;
map = hlink->fileMaps[i];
if ((rc = writeFile(ts, fi, cfd, &hlink->sb, map, &size, 1))) {
if (sizep)
*sizep = total;
if (failedFile)
*failedFile = mapFsPath(map);
goto exit;
}
total += size;
if (sizep)
*sizep = total;
rc = 0;
exit:
if (map)
mapFree(map);
return rc;
}
int cpioBuildArchive(const rpmTransactionSet ts, const TFI_t fi, FD_t cfd,
unsigned int * archiveSize, const char ** failedFile)
{
void * mapi = mapInitIterator(ts, fi);
const void * map;
/*@-fullinitblock@*/
struct hardLink hlinkList = { NULL };
/*@=fullinitblock@*/
struct stat * st = (struct stat *) &hlinkList.sb;
struct hardLink * hlink;
size_t totalsize = 0;
size_t size;
int rc;
hlinkList.next = NULL;
while ((map = mapNextIterator(mapi)) != NULL) {
const char * fsPath;
fsPath = mapFsPath(map);
if (mapFlags(map, CPIO_FOLLOW_SYMLINKS))
rc = Stat(fsPath, st);
else
rc = Lstat(fsPath, st);
if (rc) {
if (failedFile)
*failedFile = fsPath;
return CPIOERR_STAT_FAILED;
}
if (!S_ISDIR(st->st_mode) && st->st_nlink > 1) {
hlink = hlinkList.next;
while (hlink &&
(hlink->dev != st->st_dev || hlink->inode != st->st_ino))
hlink = hlink->next;
if (hlink == NULL) {
hlink = newHardLink(st, HARDLINK_INSTALL);
hlink->next = hlinkList.next;
hlinkList.next = hlink;
}
hlink->fileMaps[--hlink->linksLeft] = mapLink(map);
if (hlink->linksLeft == 0) {
struct hardLink * prev;
rc = writeLinkedFile(ts, fi, cfd, hlink, &size, failedFile);
if (rc) {
free((void *)fsPath);
return rc;
}
totalsize += size;
prev = &hlinkList;
do {
if (prev->next != hlink)
continue;
prev->next = hlink->next;
hlink->next = NULL;
freeHardLink(hlink);
hlink = NULL;
break;
} while ((prev = prev->next) != NULL);
}
} else {
if ((rc = writeFile(ts, fi, cfd, st, map, &size, 1))) {
if (failedFile)
*failedFile = fsPath;
return rc;
}
totalsize += size;
}
free((void *)fsPath);
fsPath = NULL;
}
mapFreeIterator(mapi);
rc = 0;
while ((hlink = hlinkList.next) != NULL) {
hlinkList.next = hlink->next;
hlink->next = NULL;
if (rc == 0) {
rc = writeLinkedFile(ts, fi, cfd, hlink, &size, failedFile);
totalsize += size;
}
freeHardLink(hlink);
}
if (rc)
return rc;
{ struct cpioCrcPhysicalHeader hdr;
memset(&hdr, '0', PHYS_HDR_SIZE);
memcpy(hdr.magic, CPIO_NEWC_MAGIC, sizeof(hdr.magic));
memcpy(hdr.nlink, "00000001", 8);
memcpy(hdr.namesize, "0000000b", 8);
if ((rc = safewrite(cfd, &hdr, PHYS_HDR_SIZE)) != PHYS_HDR_SIZE)
return rc;
if ((rc = safewrite(cfd, "TRAILER!!!", 11)) != 11)
return rc;
totalsize += PHYS_HDR_SIZE + 11;
}
/* GNU cpio pads to 512 bytes here, but we don't. I'm not sure if
it matters or not */
if ((rc = padoutfd(cfd, &totalsize, 4)))
return rc;
if (archiveSize) *archiveSize = totalsize;
return 0;
}
const char *const cpioStrerror(int rc)
{
static char msg[256];
char *s;
int l, myerrno = errno;
strcpy(msg, "cpio: ");
switch (rc) {
default:
s = msg + strlen(msg);
sprintf(s, _("(error 0x%x)"), (unsigned)rc);
s = NULL;
break;
case CPIOERR_BAD_MAGIC: s = _("Bad magic"); break;
case CPIOERR_BAD_HEADER: s = _("Bad/unreadable header");break;
case CPIOERR_OPEN_FAILED: s = "open"; break;
case CPIOERR_CHMOD_FAILED: s = "chmod"; break;
case CPIOERR_CHOWN_FAILED: s = "chown"; break;
case CPIOERR_WRITE_FAILED: s = "write"; break;
case CPIOERR_UTIME_FAILED: s = "utime"; break;
case CPIOERR_UNLINK_FAILED: s = "unlink"; break;
case CPIOERR_SYMLINK_FAILED: s = "symlink"; break;
case CPIOERR_STAT_FAILED: s = "stat"; break;
case CPIOERR_MKDIR_FAILED: s = "mkdir"; break;
case CPIOERR_MKNOD_FAILED: s = "mknod"; break;
case CPIOERR_MKFIFO_FAILED: s = "mkfifo"; break;
case CPIOERR_LINK_FAILED: s = "link"; break;
case CPIOERR_READLINK_FAILED: s = "readlink"; break;
case CPIOERR_READ_FAILED: s = "read"; break;
case CPIOERR_COPY_FAILED: s = "copy"; break;
case CPIOERR_HDR_SIZE: s = _("Header size too big"); break;
case CPIOERR_UNKNOWN_FILETYPE: s = _("Unknown file type"); break;
case CPIOERR_MISSING_HARDLINK: s = _("Missing hard link"); break;
case CPIOERR_MD5SUM_MISMATCH: s = _("MD5 sum mismatch"); break;
case CPIOERR_INTERNAL: s = _("Internal error"); break;
}
l = sizeof(msg) - strlen(msg) - 1;
if (s != NULL) {
if (l > 0) strncat(msg, s, l);
l -= strlen(s);
}
if ((rc & CPIOERR_CHECK_ERRNO) && myerrno) {
s = _(" failed - ");
if (l > 0) strncat(msg, s, l);
l -= strlen(s);
if (l > 0) strncat(msg, strerror(myerrno), l);
}
return msg;
}
Reference in New Issue View Git Blame Copy Permalink