krh@74: #include <stdio.h>
krh@84: #include <stddef.h>
krh@74: #include <string.h>
krh@74: #include <sys/stat.h>
krh@74: #include <sys/mman.h>
krh@85: #include <sys/types.h>
krh@85: #include <sys/wait.h>
krh@74: #include <fcntl.h>
krh@74: #include <unistd.h>
krh@74: #include <arpa/inet.h>
krh@74: #include <rpm/rpmlib.h>
krh@77: #include <zlib.h>
krh@74: 
krh@75: #include "razor.h"
krh@91: #include "razor-internal.h"
krh@75: 
krh@74: #define	RPM_LEAD_SIZE 96
krh@74: 
krh@74: struct rpm_header {
krh@74: 	unsigned char magic[4];
krh@74: 	unsigned char reserved[4];
krh@74: 	int nindex;
krh@74: 	int hsize;
krh@74: };
krh@74: 
krh@74: struct rpm_header_index {
krh@74: 	int tag;
krh@74: 	int type;
krh@74: 	int offset;
krh@74: 	int count;
krh@74: };
krh@74: 
krh@77: struct razor_rpm {
krh@75: 	struct rpm_header *signature;
krh@75: 	struct rpm_header *header;
krh@77: 	const char **dirs;
krh@75: 	const char *pool;
krh@75: 	void *map;
krh@75: 	size_t size;
krh@77: 	void *payload;
krh@75: };
krh@75: 
krh@85: static struct rpm_header_index *
krh@85: razor_rpm_get_header(struct razor_rpm *rpm, unsigned int tag)
krh@85: {
krh@85: 	struct rpm_header_index *index, *end;
krh@85: 
krh@85: 	index = (struct rpm_header_index *) (rpm->header + 1);
krh@85: 	end = index + ntohl(rpm->header->nindex);
krh@85: 	while (index < end) {
krh@85: 		if (ntohl(index->tag) == tag)
krh@85: 			return index;
krh@85: 		index++;
krh@85: 	}
krh@85: 
krh@85: 	return NULL;
krh@85: }
krh@85: 
krh@87: static const void *
krh@87: razor_rpm_get_indirect(struct razor_rpm *rpm,
krh@87: 		       unsigned int tag, unsigned int *count)
krh@87: {
krh@87: 	struct rpm_header_index *index;
krh@87: 
krh@87: 	index = razor_rpm_get_header(rpm, tag);
krh@87: 	if (index != NULL) {
krh@87: 		if (count)
krh@87: 			*count = ntohl(index->count);
krh@87: 
krh@87: 		return rpm->pool + ntohl(index->offset);
krh@87: 	}
krh@87: 
krh@87: 	return NULL;
krh@87: }
krh@87: 
krh@87: static void
krh@87: import_properties(struct razor_importer *importer, unsigned long type,
krh@87: 		  struct razor_rpm *rpm,
krh@87: 		  int name_tag, int version_tag, int flags_tag)
krh@87: {
krh@87: 	const char *name, *version;
krh@87: 	unsigned int i, count;
krh@87: 
krh@87: 	name = razor_rpm_get_indirect(rpm, name_tag, &count);
krh@87: 	if (name == NULL)
krh@87: 		return;
krh@87: 
krh@87: 	/* FIXME: Concat version and release. */
krh@87: 	version = razor_rpm_get_indirect(rpm, version_tag, &count);
krh@87: 	for (i = 0; i < count; i++) {
krh@87: 		razor_importer_add_property(importer, name, version, type);
krh@87: 		name += strlen(name) + 1;
krh@87: 		version += strlen(version) + 1;
krh@87: 	}
krh@87: }
krh@87: 
krh@87: static void
krh@87: import_files(struct razor_importer *importer, struct razor_rpm *rpm)
krh@87: {
krh@87: 	const char *name;
krh@87: 	const unsigned long *index;
krh@87: 	unsigned int i, count;
krh@87: 	char buffer[256];
krh@87: 
krh@87: 	/* assert: count is the same for all arrays */
krh@87: 
krh@87: 	index = razor_rpm_get_indirect(rpm, RPMTAG_DIRINDEXES, &count);
krh@87: 	name = razor_rpm_get_indirect(rpm, RPMTAG_BASENAMES, &count);
krh@87: 	for (i = 0; i < count; i++) {
krh@87: 		snprintf(buffer, sizeof buffer,
krh@87: 			 "%s%s", rpm->dirs[ntohl(*index)], name);
krh@87: 		razor_importer_add_file(importer, buffer);
krh@87: 		name += strlen(name) + 1;
krh@87: 		index++;
krh@87: 	}
krh@87: }
krh@87: 
krh@77: struct razor_rpm *
krh@77: razor_rpm_open(const char *filename)
krh@74: {
krh@77: 	struct razor_rpm *rpm;
krh@74: 	struct rpm_header_index *base, *index;
krh@75: 	struct stat buf;
krh@87: 	unsigned int count, i, nindex, hsize;
krh@77: 	const char *name;
krh@87: 	int fd;
krh@74: 
krh@77: 	rpm = malloc(sizeof *rpm);
krh@75: 	memset(rpm, 0, sizeof *rpm);
krh@74: 
krh@75: 	fd = open(filename, O_RDONLY);
krh@75: 	if (fd < 0) {
krh@75: 		fprintf(stderr, "couldn't open %s\n", filename);
krh@77: 		return NULL;
krh@75: 	}
krh@88: 
krh@88: 	if (fstat(fd, &buf) < 0) {
krh@88: 		fprintf(stderr, "failed to stat %s (%m)\n", filename);
krh@88: 		return NULL;
krh@88: 	}
krh@88: 
krh@75: 	rpm->size = buf.st_size;
krh@75: 	rpm->map = mmap(NULL, rpm->size, PROT_READ, MAP_PRIVATE, fd, 0);
krh@75: 	if (rpm->map == MAP_FAILED) {
krh@75: 		fprintf(stderr, "couldn't mmap %s\n", filename);
krh@77: 		return NULL;
krh@75: 	}
krh@75: 	close(fd);
krh@75: 
krh@75: 	rpm->signature = rpm->map + RPM_LEAD_SIZE;
krh@75: 	nindex = ntohl(rpm->signature->nindex);
krh@75: 	hsize = ntohl(rpm->signature->hsize);
krh@75: 	rpm->header = (void *) (rpm->signature + 1) +
krh@75: 		ALIGN(nindex * sizeof *index + hsize, 8);
krh@77: 	nindex = ntohl(rpm->header->nindex);
krh@77: 	hsize = ntohl(rpm->header->hsize);
krh@77: 	rpm->payload = (void *) (rpm->header + 1) +
krh@77: 		nindex * sizeof *index + hsize;
krh@75: 
krh@75: 	base = (struct rpm_header_index *) (rpm->header + 1);
krh@75: 	rpm->pool = (void *) base + nindex * sizeof *index;
krh@75: 
krh@87: 	/* Look up dir names now so we can index them directly. */
krh@87: 	name = razor_rpm_get_indirect(rpm, RPMTAG_DIRNAMES, &count);
krh@87: 	if (name == NULL) {
krh@87: 		fprintf(stderr, "old filename style not handled\n");
krh@87: 		return NULL;
krh@74: 	}
krh@75: 
krh@87: 	rpm->dirs = calloc(count, sizeof *rpm->dirs);
krh@87: 	for (i = 0; i < count; i++) {
krh@87: 		rpm->dirs[i] = name;
krh@87: 		name += strlen(name) + 1;
krh@77: 	}
krh@77: 
krh@77: 	return rpm;
krh@77: }
krh@77: 
krh@77: struct cpio_file_header {
krh@77: 	char magic[6];
krh@77: 	char inode[8];
krh@77: 	char mode[8];
krh@77: 	char uid[8];
krh@77: 	char gid[8];
krh@77: 	char nlink[8];
krh@77: 	char mtime[8];
krh@77: 	char filesize[8];
krh@77: 	char devmajor[8];
krh@77: 	char devminor[8];
krh@77: 	char rdevmajor[8];
krh@77: 	char rdevminor[8];
krh@77: 	char namesize[8];
krh@77: 	char checksum[8];
krh@77: 	char filename[0];
krh@77: };
krh@77: 
krh@77: /* gzip flags */
krh@77: #define ASCII_FLAG   0x01 /* bit 0 set: file probably ascii text */
krh@77: #define HEAD_CRC     0x02 /* bit 1 set: header CRC present */
krh@77: #define EXTRA_FIELD  0x04 /* bit 2 set: extra field present */
krh@77: #define ORIG_NAME    0x08 /* bit 3 set: original file name present */
krh@77: #define COMMENT      0x10 /* bit 4 set: file comment present */
krh@77: #define RESERVED     0xE0 /* bits 5..7: reserved */
krh@77: 
krh@86: struct installer {
krh@86: 	const char *root;
krh@86: 	struct razor_rpm *rpm;
krh@86: 	z_stream stream;
krh@86: 	unsigned char buffer[32768];
krh@86: 	size_t rest, length;
krh@86: };
krh@86: 
krh@77: static int
krh@86: installer_inflate(struct installer *installer)
krh@86: {
krh@86: 	size_t length;
krh@86: 	int err;
krh@86: 
krh@86: 	if (ALIGN(installer->rest, 4) > sizeof installer->buffer)
krh@86: 		length = sizeof installer->buffer;
krh@86: 	else
krh@86: 		length = installer->rest;
krh@86: 
krh@86: 	installer->stream.next_out = installer->buffer;
krh@86: 	installer->stream.avail_out = ALIGN(length, 4);
krh@86: 	err = inflate(&installer->stream, Z_SYNC_FLUSH);
krh@86: 	if (err != Z_OK && err != Z_STREAM_END) {
krh@86: 		fprintf(stderr, "inflate error: %d (%m)\n", err);
krh@86: 		return -1;
krh@86: 	}
krh@86: 
krh@86: 	installer->rest -= length;
krh@86: 	installer->length = length;
krh@86: 
krh@86: 	return 0;
krh@86: }
krh@86: 
krh@86: static int
krh@86: create_path(struct installer *installer,
krh@86: 	    const char *path, const char *name, unsigned int mode)
krh@77: {
krh@91: 	char buffer[PATH_MAX];
krh@86: 	int fd;
krh@77: 
krh@91: 	if (razor_create_dir(installer->root, path) < 0)
krh@91: 		return -1;
krh@77: 
krh@91: 	snprintf(buffer, sizeof buffer, "%s%s/%s",
krh@91: 		 installer->root, path, name);
krh@77: 
krh@77: 	switch (mode >> 12) {
krh@77: 	case REG:
krh@86: 		fd = open(buffer, O_WRONLY | O_CREAT | O_TRUNC, mode & 0x1ff);
krh@86: 		if (fd < 0){
krh@86: 			fprintf(stderr, "failed to create file %s\n", buffer);
krh@86: 			return -1;
krh@86: 		}
krh@86: 		while (installer->rest > 0) {
krh@86: 			if (installer_inflate(installer)) {
krh@86: 				fprintf(stderr, "failed to inflate\n");
krh@86: 				return -1;
krh@86: 			}
krh@91: 			if (razor_write(fd, installer->buffer,
krh@91: 					installer->length)) {
krh@86: 				fprintf(stderr, "failed to write payload\n");
krh@86: 				return -1;
krh@86: 			}
krh@86: 		}
krh@86: 		if (close(fd) < 0) {
krh@86: 			fprintf(stderr, "failed to close %s: %m\n", buffer);
krh@86: 			return -1;
krh@86: 		}
krh@86: 		return 0;
krh@86: 	case XDIR:
krh@86: 		return mkdir(buffer, mode & 0x1ff);
krh@86: 	case PIPE:
krh@86: 	case CDEV:
krh@86: 	case BDEV:
krh@86: 	case SOCK:
krh@86: 		printf("%s: unhandled file type %d\n", buffer, mode >> 12);
krh@86: 		return 0;
krh@86: 	case LINK:
krh@86: 		if (installer_inflate(installer)) {
krh@86: 			fprintf(stderr, "failed to inflate\n");
krh@86: 			return -1;
krh@86: 		}
krh@86: 		if (installer->length >= sizeof installer->buffer) {
krh@86: 			fprintf(stderr, "link name too long\n");
krh@86: 			return -1;
krh@86: 		}
krh@86: 		installer->buffer[installer->length] = '\0';
krh@86: 		if (symlink((const char *) installer->buffer, buffer)) {
krh@86: 			fprintf(stderr, "failed to create symlink, %m\n");
krh@86: 			return -1;
krh@86: 		}
krh@86: 		return 0;
krh@77: 	default:
krh@86: 		printf("%s: unknown file type %d\n", buffer, mode >> 12);
krh@86: 		return 0;
krh@77: 	}
krh@77: }
krh@77: 
krh@85: static int
krh@86: run_script(struct installer *installer,
krh@86: 	   unsigned int program_tag, unsigned int script_tag)
krh@85: {
krh@85: 	int pid, status, fd[2];
krh@86: 	const char *script = NULL, *program = NULL;
krh@85: 
krh@87: 	program = razor_rpm_get_indirect(installer->rpm, program_tag, NULL);
krh@87: 	script = razor_rpm_get_indirect(installer->rpm, script_tag, NULL);
krh@86: 	if (program == NULL && script == NULL) {
krh@86: 		printf("no script or program for tags %d and %d\n",
krh@86: 		       program_tag, script_tag);
krh@86: 		return -1;
krh@86: 	} else if (program == NULL) {
krh@86: 		program = "/bin/sh";
krh@85: 	}
krh@85: 
krh@85: 	if (pipe(fd) < 0) {
krh@85: 		fprintf(stderr, "failed to create pipe\n");
krh@85: 		return -1;
krh@85: 	}
krh@85: 	pid = fork();
krh@85: 	if (pid < 0) {
krh@85: 		fprintf(stderr, "failed to fork, %m\n");
krh@85: 	} else if (pid == 0) {
krh@85: 		if (dup2(fd[0], STDIN_FILENO) < 0) {
krh@85: 			fprintf(stderr, "failed redirect stdin, %m\n");
krh@85: 			return -1;
krh@85: 		}
krh@85: 		if (close(fd[0]) < 0 || close(fd[1]) < 0) {
krh@85: 			fprintf(stderr, "failed to close pipe, %m\n");
krh@89: 			return -1;
krh@85: 		}
krh@86: 		if (chroot(installer->root) < 0) {
krh@86: 			fprintf(stderr, "failed to chroot to %s, %m\n",
krh@86: 				installer->root);
krh@85: 			return -1;
krh@85: 		}
krh@86: 		printf("executing program %s in chroot %s\n",
krh@86: 		       program, installer->root);
krh@86: 		if (execl(program, program, NULL)) {
krh@86: 			fprintf(stderr, "failed to exec %s, %m\n", program);
krh@89: 			exit(-1);
krh@85: 		}
krh@85: 	} else {
krh@86: 		if (script && write(fd[1], script, strlen(script)) < 0) {
krh@85: 			fprintf(stderr, "failed to pipe script, %m\n");
krh@85: 			return -1;
krh@85: 		}
krh@85: 		if (close(fd[0]) || close(fd[1])) {
krh@85: 			fprintf(stderr, "failed to close pipe, %m\n");
krh@85: 			return -1;
krh@85: 		}
krh@85: 		if (wait(&status) < 0) {
krh@85: 			fprintf(stderr, "wait for child failed, %m");
krh@85: 			return -1;
krh@85: 		}
krh@85: 		printf("script exited with status %d\n", status);
krh@85: 	}
krh@85: 
krh@85: 	return 0;
krh@85: }
krh@85: 
krh@86: static int
krh@86: installer_init(struct installer *installer)
krh@77: {
krh@86: 	unsigned char *gz_header;
krh@86: 	int method, flags, err;
krh@77: 
krh@86: 	gz_header = installer->rpm->payload;
krh@77: 	if (gz_header[0] != 0x1f || gz_header[1] != 0x8b) {
krh@77: 		fprintf(stderr, "payload section doesn't have gz header\n");
krh@77: 		return -1;
krh@77: 	}
krh@77: 
krh@77: 	method = gz_header[2];
krh@77: 	flags = gz_header[3];
krh@77: 
krh@77: 	if (method != Z_DEFLATED || flags != 0) {
krh@77: 		fprintf(stderr,
krh@77: 			"unknown payload compression method or flags set\n");
krh@77: 		return -1;
krh@77: 	}
krh@77: 
krh@86: 	installer->stream.zalloc = NULL;
krh@86: 	installer->stream.zfree = NULL;
krh@86: 	installer->stream.opaque = NULL;
krh@85: 
krh@86: 	installer->stream.next_in  = gz_header + 10;
krh@86: 	installer->stream.avail_in =
krh@86: 		(installer->rpm->map + installer->rpm->size) -
krh@86: 		(void *) installer->stream.next_in;
krh@86: 	installer->stream.next_out = NULL;
krh@86: 	installer->stream.avail_out = 0;
krh@77: 
krh@86: 	err = inflateInit2(&installer->stream, -MAX_WBITS);
krh@77: 	if (err != Z_OK) {
krh@77: 		fprintf(stderr, "inflateInit error: %d\n", err);
krh@77: 		return -1;
krh@77: 	}
krh@77: 
krh@86: 	return 0;
krh@86: }
krh@77: 
krh@86: static int
krh@86: installer_finish(struct installer *installer)
krh@86: {
krh@86: 	int err;
krh@77: 
krh@86: 	err = inflateEnd(&installer->stream);
krh@77: 
krh@77: 	if (err != Z_OK) {
krh@77: 		fprintf(stderr, "inflateEnd error: %d\n", err);
krh@77: 		return -1;
krh@77: 	}	    
krh@77: 
krh@86: 	return 0;
krh@86: }
krh@86: 
krh@86: int
krh@86: razor_rpm_install(struct razor_rpm *rpm, const char *root)
krh@86: {
krh@86: 	struct installer installer;
krh@87: 	unsigned int count, i, length;
krh@86: 	struct cpio_file_header *header;
krh@87: 	const unsigned long *size, *index, *flags;
krh@87: 	const unsigned short *mode;
krh@86: 	const char *name, *dir;
krh@86: 	struct stat buf;
krh@86: 
krh@86: 	installer.rpm = rpm;
krh@86: 	installer.root = root;
krh@86: 
krh@86: 	/* FIXME: Only do this before a transaction, not per rpm. */
krh@86: 	if (stat(root, &buf) < 0 || !S_ISDIR(buf.st_mode)) {
krh@86: 		fprintf(stderr,
krh@86: 			"root installation directory \"%s\" does not exist\n",
krh@86: 			root);
krh@86: 		return -1;
krh@86: 	}
krh@86: 
krh@86: 	if (installer_init(&installer))
krh@86: 		return -1;
krh@86: 
krh@86: 	run_script(&installer, RPMTAG_PREINPROG, RPMTAG_PREIN);
krh@86: 
krh@87: 	name = razor_rpm_get_indirect(rpm, RPMTAG_BASENAMES, &count);
krh@87: 	size = razor_rpm_get_indirect(rpm, RPMTAG_FILESIZES, &count);
krh@87: 	index = razor_rpm_get_indirect(rpm, RPMTAG_DIRINDEXES, &count);
krh@87: 	mode = razor_rpm_get_indirect(rpm, RPMTAG_FILEMODES, &count);
krh@87: 	flags = razor_rpm_get_indirect(rpm, RPMTAG_FILEFLAGS, &count);
krh@86: 
krh@86: 	for (i = 0; i < count; i++) {
krh@86: 		dir = rpm->dirs[ntohl(*index)];
krh@86: 
krh@86: 		/* Skip past the cpio header block unless it's a ghost file,
krh@86: 		 * in which case doesn't appear in the cpio archive. */
krh@86: 		if (!(ntohl(*flags) & RPMFILE_GHOST)) {
krh@86: 			/* Plus two for the leading '.' and the terminating NUL. */
krh@86: 			length = sizeof *header + strlen(dir) + strlen(name) + 2;
krh@86: 			installer.rest = ALIGN(length, 4);
krh@86: 			if (installer_inflate(&installer))
krh@86: 				return -1;
krh@86: 		}
krh@86: 
krh@86: 		installer.rest = ntohl(*size);
krh@86: 		if (create_path(&installer, dir, name, ntohs(*mode)) < 0)
krh@86: 			return -1;
krh@86: 
krh@86: 		name += strlen(name) + 1;
krh@86: 		index++;
krh@86: 		size++;
krh@86: 		mode++;
krh@86: 		flags++;
krh@86: 	}
krh@86: 
krh@86: 	if (installer_finish(&installer))
krh@86: 		return -1;
krh@86: 
krh@86: 	run_script(&installer, RPMTAG_POSTINPROG, RPMTAG_POSTIN);
krh@85: 
krh@75: 	return 0;
krh@74: }
krh@74: 
krh@77: int
krh@77: razor_rpm_close(struct razor_rpm *rpm)
krh@74: {
krh@77: 	int err;
krh@77: 
krh@77: 	free(rpm->dirs);
krh@77: 	err = munmap(rpm->map, rpm->size);
krh@77: 	free(rpm);
krh@77: 
krh@77: 	return err;
krh@75: }
krh@74: 
krh@75: int
krh@77: razor_importer_add_rpm(struct razor_importer *importer, struct razor_rpm *rpm)
krh@75: {
krh@87: 	const char *name, *version, *release;
krh@75: 
krh@87: 	name = razor_rpm_get_indirect(rpm, RPMTAG_NAME, NULL);
krh@87: 	version = razor_rpm_get_indirect(rpm, RPMTAG_VERSION, NULL);
krh@87: 	release = razor_rpm_get_indirect(rpm, RPMTAG_RELEASE, NULL);
krh@87: 
krh@87: 	/* FIXME: Concatenate version and release. */
krh@87: 	razor_importer_begin_package(importer, name, version);
krh@87: 
krh@87: 	import_properties(importer, RAZOR_PROPERTY_REQUIRES, rpm,
krh@87: 			  RPMTAG_REQUIRENAME,
krh@87: 			  RPMTAG_REQUIREVERSION,
krh@87: 			  RPMTAG_REQUIREFLAGS);
krh@87: 
krh@87: 	import_properties(importer, RAZOR_PROPERTY_PROVIDES, rpm,
krh@87: 			  RPMTAG_PROVIDENAME,
krh@87: 			  RPMTAG_PROVIDEVERSION,
krh@87: 			  RPMTAG_PROVIDEFLAGS);
krh@87: 
krh@87: 	import_properties(importer, RAZOR_PROPERTY_OBSOLETES, rpm,
krh@87: 			  RPMTAG_OBSOLETENAME,
krh@87: 			  RPMTAG_OBSOLETEVERSION,
krh@87: 			  RPMTAG_OBSOLETEFLAGS);
krh@87: 
krh@87: 	import_properties(importer, RAZOR_PROPERTY_CONFLICTS, rpm,
krh@87: 			  RPMTAG_CONFLICTNAME,
krh@87: 			  RPMTAG_CONFLICTVERSION,
krh@87: 			  RPMTAG_CONFLICTFLAGS);
krh@87: 
krh@77: 	import_files(importer, rpm);
krh@74: 
krh@75: 	razor_importer_finish_package(importer);
krh@74: 
krh@75: 	return 0;
krh@74: }