*** empty log message ***

1 files changed, 952 insertions, 0 deletions

diff --git a/isys/uncpio.c b/isys/uncpio.c
new file mode 100644
index 000000000..e65c4fc82
--- /dev/null
+++ b/isys/uncpio.c
@@ -0,0 +1,952 @@
+#define HAVE_ALLOCA_H 1
+#define MAJOR_IN_SYSMACROS 1
+
+#if HAVE_ALLOCA_H
+# include <alloca.h>
+#endif
+
+#define _(foo) (foo)
+
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <utime.h>
+
+#include "cpio.h"
+
+#if MAJOR_IN_SYSMACROS 
+#include <sys/sysmacros.h>
+#elif MAJOR_IN_MKDEV 
+#include <sys/mkdev.h>
+#endif
+
+#define CPIO_NEWC_MAGIC	"070701"
+#define CPIO_CRC_MAGIC	"070702"
+#define TRAILER		"TRAILER!!!"
+
+/* 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! */
+
+/* We need to maintain our oun file pointer to allow padding */
+struct ourfd {
+    gzFile fd;
+    int pos;
+};
+
+struct hardLink {
+    struct hardLink * next;
+    char ** files;		/* there are nlink of these, used by install */
+    int * fileMaps;		/* used by build */
+    dev_t dev;
+    ino_t inode;
+    int nlink;			
+    int linksLeft;
+    int createdPath;
+    struct stat sb;
+};
+
+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) */
+
+struct cpioHeader {
+    ino_t inode;
+    mode_t mode;
+    uid_t uid;
+    gid_t gid;
+    int nlink;
+    time_t mtime;
+    long size;
+    dev_t dev, rdev;
+    char * path;
+};
+
+static inline off_t ourread(struct ourfd * thefd, void * buf, size_t size) {
+    off_t i;
+
+    i = gzread(thefd->fd, buf, size);
+    thefd->pos += i;
+    
+    return i;
+}
+
+static inline void padinfd(struct ourfd * fd, int modulo) {
+    int buf[10];
+    int amount;
+    
+    amount = (modulo - fd->pos % modulo) % modulo;
+    ourread(fd, buf, amount);
+}
+
+static inline off_t safewrite(int fd, void * vbuf, size_t amount) {
+    int rc = 0;
+    char * buf = vbuf;
+
+    while (amount && (rc = write(fd, buf, amount)) < amount && rc > 0) {
+	buf += rc;
+	amount -= rc;
+    }
+
+    if (rc < 0) return rc;
+
+    return 0; 
+}
+
+static inline int padoutfd(int fd, size_t * where, int modulo) {
+    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(fd, buf, amount)) 
+	return CPIOERR_WRITE_FAILED;
+    return 0;
+}
+
+static int strntoul(const char * str, char ** endptr, int base, int num) {
+    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 = "";
+
+    return strtoul(buf, endptr, base);
+}
+
+#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);
+
+static int getNextHeader(struct ourfd * fd, struct cpioHeader * chPtr) {
+    struct cpioCrcPhysicalHeader physHeader;
+    int nameSize;
+    char * end;
+    int major, minor;
+
+    if (ourread(fd, &physHeader, PHYS_HDR_SIZE) != PHYS_HDR_SIZE) 
+	return CPIOERR_READ_FAILED;
+
+    if (strncmp(CPIO_CRC_MAGIC, physHeader.magic, strlen(CPIO_CRC_MAGIC)) &&
+	strncmp(CPIO_NEWC_MAGIC, physHeader.magic, strlen(CPIO_NEWC_MAGIC)))
+	return CPIOERR_BAD_MAGIC;
+
+    GET_NUM_FIELD(physHeader.inode, chPtr->inode);
+    GET_NUM_FIELD(physHeader.mode, chPtr->mode);
+    GET_NUM_FIELD(physHeader.uid, chPtr->uid);
+    GET_NUM_FIELD(physHeader.gid, chPtr->gid);
+    GET_NUM_FIELD(physHeader.nlink, chPtr->nlink);
+    GET_NUM_FIELD(physHeader.mtime, chPtr->mtime);
+    GET_NUM_FIELD(physHeader.filesize, chPtr->size);
+
+    GET_NUM_FIELD(physHeader.devMajor, major);
+    GET_NUM_FIELD(physHeader.devMinor, minor);
+    chPtr->dev = makedev(major, minor);
+
+    GET_NUM_FIELD(physHeader.rdevMajor, major);
+    GET_NUM_FIELD(physHeader.rdevMinor, minor);
+    chPtr->rdev = makedev(major, minor);
+
+    GET_NUM_FIELD(physHeader.namesize, nameSize);
+
+    chPtr->path = malloc(nameSize + 1);
+    if (ourread(fd, chPtr->path, nameSize) != nameSize) {
+	free(chPtr->path);
+	return CPIOERR_BAD_HEADER;
+    }
+
+    /* this is unecessary chPtr->path[nameSize] = '\0'; */
+
+    padinfd(fd, 4);
+
+    return 0;
+}
+
+int cpioFileMapCmp(const void * a, const void * b) {
+    const struct cpioFileMapping * first = a;
+    const struct cpioFileMapping * second = b;
+
+    return (strcmp(first->archivePath, second->archivePath));
+}
+
+/* This could trash files in the path! I'm not sure that's a good thing */
+static int createDirectory(char * path, mode_t perms) {
+    struct stat sb;
+    int dounlink;
+
+    if (!lstat(path, &sb)) {
+	if (S_ISDIR(sb.st_mode)) {
+	    return 0;
+	} else if (S_ISLNK(sb.st_mode)) {
+	    if (stat(path, &sb)) {
+		if (errno != ENOENT) 
+		    return CPIOERR_STAT_FAILED;
+		dounlink = 1;
+	    } else {
+		if (S_ISDIR(sb.st_mode))
+		    return 0;
+		dounlink = 1;
+	    }
+	} else {
+	    dounlink = 1;
+	}
+
+	if (dounlink && unlink(path)) {
+	    return CPIOERR_UNLINK_FAILED;
+	}
+    }
+
+    if (mkdir(path, 000))
+	return CPIOERR_MKDIR_FAILED;
+
+    if (chmod(path, perms))
+	return CPIOERR_CHMOD_FAILED;
+
+    return 0;
+}
+
+static int setInfo(struct cpioHeader * hdr) {
+    int rc = 0;
+    struct utimbuf stamp;
+
+    stamp.actime = hdr->mtime; 
+    stamp.modtime = hdr->mtime;
+
+    if (!S_ISLNK(hdr->mode)) {
+	if (!getuid() && chown(hdr->path, hdr->uid, hdr->gid))
+	    rc = CPIOERR_CHOWN_FAILED;
+	if (!rc && chmod(hdr->path, hdr->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, hdr->uid, hdr->gid))
+		rc = CPIOERR_CHOWN_FAILED;
+#       endif
+    }
+
+    return rc;
+}
+
+static int checkDirectory(char * filename) {
+    static char * lastDir = NULL;
+    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 = realloc(lastDir, lastDirAlloced);
+    }
+
+    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;
+}
+
+static int expandRegular(struct ourfd * fd, struct cpioHeader * hdr,
+			 cpioCallback cb, void * cbData) {
+    int out;
+    char buf[8192];
+    int bytesRead;
+    int left = hdr->size;
+    int rc = 0;
+    struct cpioCallbackInfo cbInfo;
+    struct stat sb;
+
+    if (!lstat(hdr->path, &sb))
+	if (unlink(hdr->path))
+	    return CPIOERR_UNLINK_FAILED;
+
+    out = open(hdr->path, O_CREAT | O_WRONLY, 0);
+    if (out < 0) 
+	return CPIOERR_OPEN_FAILED;
+
+    cbInfo.file = hdr->path;
+    cbInfo.fileSize = hdr->size;
+
+    while (left) {
+	bytesRead = ourread(fd, buf, left < sizeof(buf) ? left : sizeof(buf));
+	if (bytesRead <= 0) {
+	    rc = CPIOERR_READ_FAILED;
+	    break;
+	}
+
+	if (write(out, buf, bytesRead) != bytesRead) {
+	    rc = CPIOERR_COPY_FAILED;
+	    break;
+	}
+
+	left -= bytesRead;
+
+	/* don't call this with fileSize == fileComplete */
+	if (!rc && cb && left) {
+	    cbInfo.fileComplete = hdr->size - left;
+	    cbInfo.bytesProcessed = fd->pos;
+	    cb(&cbInfo, cbData);
+	}
+    }
+
+    close(out);
+    
+    return rc;
+}
+
+static int expandSymlink(struct ourfd * fd, struct cpioHeader * hdr) {
+    char buf[2048], buf2[2048];
+    struct stat sb;
+    int len;
+
+    if ((hdr->size + 1)> sizeof(buf))
+	return CPIOERR_INTERNAL;
+
+    if (ourread(fd, buf, hdr->size) != hdr->size)
+	return CPIOERR_READ_FAILED;
+
+    buf[hdr->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;
+}
+
+static int expandFifo(struct ourfd * fd, struct cpioHeader * hdr) {
+    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; 
+}
+
+static int expandDevice(struct ourfd * fd, struct cpioHeader * hdr) {
+    struct stat sb;
+
+    if (!lstat(hdr->path, &sb)) {
+	if ((S_ISCHR(sb.st_mode) || S_ISBLK(sb.st_mode)) && 
+		(sb.st_rdev == hdr->rdev))
+	    return 0;
+	if (unlink(hdr->path))
+	    return CPIOERR_UNLINK_FAILED;
+    }
+
+    if (mknod(hdr->path, hdr->mode & (~0777), hdr->rdev))
+	return CPIOERR_MKNOD_FAILED;
+    
+    return 0;
+}
+
+static void freeLink(struct hardLink * li) {
+    int i;
+
+    for (i = 0; i < li->nlink; i++) {
+	if (li->files[i]) free(li->files[i]);
+    }
+    free(li->files);
+}
+
+static int createLinks(struct hardLink * li, const char ** failedFile) {
+    int i;
+    struct stat sb;
+
+    for (i = 0; i < li->nlink; i++) {
+	if (i == li->createdPath) continue;
+	if (!li->files[i]) continue;
+
+	if (!lstat(li->files[i], &sb)) {
+	    if (unlink(li->files[i])) {
+		*failedFile = strdup(li->files[i]);
+		return CPIOERR_UNLINK_FAILED;
+	    }
+	}
+
+	if (link(li->files[li->createdPath], li->files[i])) {
+	    *failedFile = strdup(li->files[i]);
+	    return CPIOERR_LINK_FAILED;
+	}
+
+	free(li->files[i]);
+	li->files[i] = NULL;
+	li->linksLeft--;
+    }
+
+    return 0;
+}
+
+static int eatBytes(struct ourfd * fd, int amount) {
+    char buf[4096];
+    int bite;
+   
+    while (amount) {
+	bite = (amount > sizeof(buf)) ? sizeof(buf) : amount;
+	if (ourread(fd, buf, bite) != bite)
+	    return CPIOERR_READ_FAILED;
+	amount -= bite;
+    }
+
+    return 0;
+}
+
+int cpioInstallArchive(gzFile stream, struct cpioFileMapping * mappings, 
+		       int numMappings, cpioCallback cb, void * cbData,
+		       const char ** failedFile) {
+    struct cpioHeader ch;
+    struct ourfd fd;
+    int rc = 0;
+    int linkNum = 0;
+    struct cpioFileMapping * map = NULL;
+    struct cpioFileMapping needle;
+    mode_t cpioMode;
+    int olderr;
+    struct cpioCallbackInfo cbInfo;
+    struct hardLink * links = NULL;
+    struct hardLink * li = NULL;
+
+    fd.fd = stream;
+    fd.pos = 0;
+
+    *failedFile = NULL;
+
+    do {
+	if ((rc = getNextHeader(&fd, &ch))) {
+	    fprintf(stderr, _("error %d reading header: %s\n"), rc, strerror(errno));
+	    return CPIOERR_BAD_HEADER;
+	}
+
+	if (!strcmp(ch.path, TRAILER)) {
+	    free(ch.path);
+	    break;
+	}
+
+	if (mappings) {
+	    needle.archivePath = ch.path;
+	    map = bsearch(&needle, mappings, numMappings, sizeof(needle),
+			  cpioFileMapCmp);
+	}
+
+	if (mappings && !map) {
+	    eatBytes(&fd, ch.size);
+	} else {
+	    cpioMode = ch.mode;
+
+	    if (map) {
+		if (map->mapFlags & CPIO_MAP_PATH) {
+		    free(ch.path);
+		    ch.path = strdup(map->fsPath);
+		} 
+
+		if (map->mapFlags & CPIO_MAP_MODE)
+		    ch.mode = map->finalMode;
+		if (map->mapFlags & CPIO_MAP_UID)
+		    ch.uid = map->finalUid;
+		if (map->mapFlags & CPIO_MAP_GID)
+		    ch.gid = map->finalGid;
+	    }
+
+	    /* This won't get hard linked symlinks right, but I can't seem 
+	       to create those anyway */
+
+	    if (S_ISREG(ch.mode) && ch.nlink > 1) {
+		li = links;
+		for (li = links; li; li = li->next) {
+		    if (li->inode == ch.inode && li->dev == ch.dev) break;
+		}
+
+		if (!li) {
+		    li = malloc(sizeof(*li));
+		    li->inode = ch.inode;
+		    li->dev = ch.dev;
+		    li->nlink = ch.nlink;
+		    li->linksLeft = ch.nlink;
+		    li->createdPath = -1;
+		    li->files = calloc(sizeof(char *), li->nlink);
+		    li->next = links;
+		    links = li;
+		}
+
+		for (linkNum = 0; linkNum < li->nlink; linkNum++)
+		    if (!li->files[linkNum]) break;
+		li->files[linkNum] = strdup(ch.path);
+	    }
+		
+	    if ((ch.nlink > 1) && S_ISREG(ch.mode) && !ch.size &&
+		li->createdPath == -1) {
+		/* defer file creation */
+	    } else if ((ch.nlink > 1) && S_ISREG(ch.mode) && 
+		       (li->createdPath != -1)) {
+		createLinks(li, failedFile);
+
+		/* 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 */
+		if (ch.size) eatBytes(&fd, ch.size);
+	    } else {
+		rc = checkDirectory(ch.path);
+
+		if (!rc) {
+		    if (S_ISREG(ch.mode))
+			rc = expandRegular(&fd, &ch, cb, cbData);
+		    else if (S_ISDIR(ch.mode))
+			rc = createDirectory(ch.path, 000);
+		    else if (S_ISLNK(ch.mode))
+			rc = expandSymlink(&fd, &ch);
+		    else if (S_ISFIFO(ch.mode))
+			rc = expandFifo(&fd, &ch);
+		    else if (S_ISCHR(ch.mode) || S_ISBLK(ch.mode))
+			rc = expandDevice(&fd, &ch);
+		    else if (S_ISSOCK(ch.mode)) {
+			/* this mimicks cpio but probably isnt' right */
+			rc = expandFifo(&fd, &ch);
+		    } else {
+			rc = CPIOERR_INTERNAL;
+		    }
+		}
+
+		if (!rc)
+		    rc = setInfo(&ch);
+
+		if (S_ISREG(ch.mode) && ch.nlink > 1) {
+		    li->createdPath = linkNum;
+		    li->linksLeft--;
+		    rc = createLinks(li, failedFile);
+		}
+	    }
+
+	    if (rc && !*failedFile) {
+		*failedFile = strdup(ch.path);
+
+		olderr = errno;
+		unlink(ch.path);
+		errno = olderr;
+	    }
+	}
+
+	padinfd(&fd, 4);
+
+	if (!rc && cb) {
+	    cbInfo.file = ch.path;
+	    cbInfo.fileSize = ch.size;
+	    cbInfo.fileComplete = ch.size;
+	    cbInfo.bytesProcessed = fd.pos;
+	    cb(&cbInfo, cbData);
+	}
+
+	free(ch.path);
+    } while (1 && !rc);
+
+    li = links;
+    while (li && !rc) {
+	if (li->linksLeft) {
+	    if (li->createdPath == -1)
+		rc = CPIOERR_INTERNAL;
+	    else 
+		rc = createLinks(li, failedFile);
+	}
+
+	freeLink(li);
+
+	links = li;
+	li = li->next;
+	free(links);
+	links = li;
+    }
+
+    li = links;
+    /* if an error got us here links will still be eating some memory */
+    while (li) {
+	freeLink(li);
+	links = li;
+	li = li->next;
+	free(links);
+    }
+
+    return rc;
+}
+
+static int writeFile(int fd, struct stat sb, struct cpioFileMapping * map, 
+		     size_t * sizeptr, int writeData) {
+    struct cpioCrcPhysicalHeader hdr;
+    char buf[8192], symbuf[2048];
+    dev_t num;
+    int datafd;
+    size_t size, amount = 0;
+    int rc, olderrno;
+
+    if (!(map->mapFlags & CPIO_MAP_PATH))
+	map->archivePath = map->fsPath;
+    if (map->mapFlags & CPIO_MAP_MODE)
+	sb.st_mode = (sb.st_mode & S_IFMT) | map->finalMode;
+    if (map->mapFlags & CPIO_MAP_UID)
+	sb.st_uid = map->finalUid;
+    if (map->mapFlags & CPIO_MAP_GID)
+	sb.st_gid = map->finalGid;
+
+    if (!writeData || S_ISDIR(sb.st_mode)) {
+	sb.st_size = 0;
+    } else if (S_ISLNK(sb.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(map->fsPath, symbuf, sizeof(symbuf));
+	if (amount <= 0) {
+	    return CPIOERR_READLINK_FAILED;
+	}
+
+	sb.st_size = amount;
+    }
+
+    memcpy(hdr.magic, CPIO_NEWC_MAGIC, sizeof(hdr.magic));
+    SET_NUM_FIELD(hdr.inode, sb.st_ino, buf);
+    SET_NUM_FIELD(hdr.mode, sb.st_mode, buf);
+    SET_NUM_FIELD(hdr.uid, sb.st_uid, buf);
+    SET_NUM_FIELD(hdr.gid, sb.st_gid, buf);
+    SET_NUM_FIELD(hdr.nlink, sb.st_nlink, buf);
+    SET_NUM_FIELD(hdr.mtime, sb.st_mtime, buf);
+    SET_NUM_FIELD(hdr.filesize, sb.st_size, buf);
+
+    num = major(sb.st_dev); SET_NUM_FIELD(hdr.devMajor, num, buf);
+    num = minor(sb.st_dev); SET_NUM_FIELD(hdr.devMinor, num, buf);
+    num = major(sb.st_rdev); SET_NUM_FIELD(hdr.rdevMajor, num, buf);
+    num = minor(sb.st_rdev); SET_NUM_FIELD(hdr.rdevMinor, num, buf);
+
+    num = strlen(map->archivePath) + 1; SET_NUM_FIELD(hdr.namesize, num, buf);
+    memcpy(hdr.checksum, "00000000", 8);
+
+    if ((rc = safewrite(fd, &hdr, PHYS_HDR_SIZE)))
+	return rc;
+    if ((rc = safewrite(fd, map->archivePath, num)))
+	return rc;
+    size = PHYS_HDR_SIZE + num;
+    if ((rc = padoutfd(fd, &size, 4)))
+	return rc;
+	
+    if (writeData && S_ISREG(sb.st_mode)) {
+	/* FIXME: we should use mmap here if it's available */
+	if ((datafd = open(map->fsPath, O_RDONLY)) < 0)
+	    return CPIOERR_OPEN_FAILED;
+
+	size += sb.st_size;
+
+	while (sb.st_size) {
+	    amount = read(datafd, buf, 
+		     sb.st_size > sizeof(buf) ? sizeof(buf) : sb.st_size);
+	    if (amount <= 0) {
+		olderrno = errno;
+		close(datafd);
+		errno = olderrno;
+		return CPIOERR_READ_FAILED;
+	    }
+
+	    if ((rc = safewrite(fd, buf, amount))) {
+		olderrno = errno;
+		close(datafd);
+		errno = olderrno;
+		return rc;
+	    }
+
+	    sb.st_size -= amount;
+	}
+
+	close(datafd);
+    } else if (writeData && S_ISLNK(sb.st_mode)) {
+	if ((rc = safewrite(fd, symbuf, amount)))
+	    return rc;
+	size += amount;
+    }
+
+    /* this is a noop for most file types */
+    if ((rc = padoutfd(fd, &size, 4)))
+	return rc;
+
+    *sizeptr = size;
+
+    return 0;
+}
+
+static int writeLinkedFile(int fd, struct hardLink * hlink, 
+			   struct cpioFileMapping * mappings,
+			   cpioCallback cb, void * cbData,
+			   size_t * sizeptr,
+			   char ** failedFile) {
+    int i, rc;
+    size_t size;
+    struct cpioCallbackInfo cbinfo;
+
+    *sizeptr = 0;
+
+    for (i = hlink->nlink - 1; i > hlink->linksLeft; i--) {
+	if ((rc = writeFile(fd, hlink->sb, mappings + hlink->fileMaps[i], 
+			    &size, 0))) {
+	    if (failedFile) *failedFile = 
+		    mappings[hlink->fileMaps[i]].fsPath;
+	    return rc;
+	}
+
+	*sizeptr += size;
+
+	if (cb) {
+	    cbinfo.file = mappings[i].archivePath;
+	    cb(&cbinfo, cbData);
+	}
+    }
+
+    if ((rc = writeFile(fd, hlink->sb, 
+			mappings + hlink->fileMaps[hlink->linksLeft], 
+			&size, 1))) {
+	if (failedFile) 
+	    *failedFile = mappings[hlink->fileMaps[hlink->linksLeft]].fsPath;
+	return rc;
+    }
+
+    *sizeptr += size;
+
+    if (cb) {
+	cbinfo.file = mappings[i].archivePath;
+	cb(&cbinfo, cbData);
+    }
+
+    return 0;
+}
+
+int cpioBuildArchive(int fd, struct cpioFileMapping * mappings, 
+		     int numMappings, cpioCallback cb, void * cbData,
+		     unsigned int * archiveSize, char ** failedFile) {
+    size_t size, totalsize = 0;
+    int rc;
+    int i;
+    struct cpioCallbackInfo cbinfo;
+    struct cpioCrcPhysicalHeader hdr;
+    struct stat sb;
+    struct hardLink hlinkList = { NULL };
+    struct hardLink * hlink, * parent;
+
+    hlinkList.next = NULL;
+
+    for (i = 0; i < numMappings; i++) {
+	if (mappings[i].mapFlags & CPIO_FOLLOW_SYMLINKS)
+	    rc = stat(mappings[i].fsPath, &sb);
+	else
+	    rc = lstat(mappings[i].fsPath, &sb);
+
+	if (rc) {
+	    if (failedFile) *failedFile = mappings[i].fsPath;
+	    return CPIOERR_STAT_FAILED;
+	}
+
+	if (!S_ISDIR(sb.st_mode) && sb.st_nlink > 1) {
+	    hlink = hlinkList.next;
+	    while (hlink && 
+		   (hlink->dev != sb.st_dev || hlink->inode != sb.st_ino))
+		hlink = hlink->next;
+	    if (!hlink) {
+		hlink = malloc(sizeof(*hlink));
+		hlink->next = hlinkList.next;
+		hlinkList.next = hlink;
+		hlink->sb = sb;
+		hlink->dev = sb.st_dev;
+		hlink->inode = sb.st_ino;
+		hlink->nlink = sb.st_nlink;
+		hlink->linksLeft = sb.st_nlink;
+		hlink->fileMaps = malloc(sizeof(*hlink->fileMaps) * 
+						sb.st_nlink);
+	    }
+
+	    hlink->fileMaps[--hlink->linksLeft] = i;
+
+	    if (!hlink->linksLeft) {
+		if ((rc = writeLinkedFile(fd, hlink, mappings, cb, cbData,
+			 		  &size, failedFile)))
+		    return rc;
+
+		totalsize += size;
+
+		free(hlink->fileMaps);
+
+		parent = &hlinkList;
+		while (parent->next != hlink) parent = parent->next;
+		parent->next = parent->next->next;
+		free(hlink);
+	    }
+	} else {
+	    if ((rc = writeFile(fd, sb, mappings + i, &size, 1))) {
+		if (failedFile) *failedFile = mappings[i].fsPath;
+		return rc;
+	    }
+
+	    if (cb) {
+		cbinfo.file = mappings[i].archivePath;
+		cb(&cbinfo, cbData);
+	    }
+
+	    totalsize += size;
+	}
+    }    
+
+    hlink = hlinkList.next;
+    while (hlink) {
+	if ((rc = writeLinkedFile(fd, hlink, mappings, cb, cbData,
+				  &size, failedFile)))
+	    return rc;
+	free(hlink->fileMaps);
+	parent = hlink;
+	hlink = hlink->next;
+	free(parent);
+
+	totalsize += size;
+    }
+
+    memset(&hdr, '0', sizeof(hdr));
+    memcpy(hdr.magic, CPIO_NEWC_MAGIC, sizeof(hdr.magic));
+    memcpy(hdr.nlink, "00000001", 8);
+    memcpy(hdr.namesize, "0000000b", 8);
+    if ((rc = safewrite(fd, &hdr, PHYS_HDR_SIZE)))
+	return rc;
+    if ((rc = safewrite(fd, "TRAILER!!!", 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(fd, &totalsize, 4)))
+	return rc;
+
+    if (archiveSize) *archiveSize = totalsize;
+
+    return 0;
+}
+
+const char * 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)"), rc);
+	s = NULL;
+	break;
+    case CPIOERR_BAD_MAGIC:	s = _("Bad magic");		break;
+    case CPIOERR_BAD_HEADER:	s = _("Bad 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_INTERNAL:	s = _("Internal error");	break;
+    case CPIOERR_HDR_SIZE:	s = _("Header size too big");	break;
+    case CPIOERR_UNKNOWN_FILETYPE: s = _("Unknown file type");	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) {
+	s = _(" failed - ");
+	if (l > 0) strncat(msg, s, l);
+	l -= strlen(s);
+	if (l > 0) strncat(msg, strerror(myerrno), l);
+    }
+    return msg;
+}