Mercurialrazor / file revision
summary | shortlog | changelog | graph | tags | branches | files | changeset | file | revisions | annotate | diff | raw
rpm.c
author Kristian H?gsberg <krh@redhat.com>
Thu Dec 27 15:47:09 2007 -0500 (2007-12-27)
changeset 85 c5041a93b91a
parent 84 6883222205ad
child 86 e44ccd213756
permissions -rw-r--r--
Run install scripts. 
     1 #include <stdio.h>

     2 #include <stddef.h>

     3 #include <string.h>

     4 #include <sys/stat.h>

     5 #include <sys/mman.h>

     6 #include <sys/types.h>

     7 #include <sys/wait.h>

     8 #include <fcntl.h>

     9 #include <unistd.h>

    10 #include <arpa/inet.h>

    11 #include <rpm/rpmlib.h>

    12 #include <zlib.h>

    13 

    14 #include "razor.h"

    15 

    16 #define	RPM_LEAD_SIZE 96

    17 

    18 struct rpm_lead {

    19 	unsigned char magic[4];

    20 	unsigned char major;

    21 	unsigned char minor;

    22 	short type;

    23 	short archnum;

    24 	char name[66];

    25 	short osnum;

    26 	short signature_type;

    27 	char reserved[16];

    28 };

    29 

    30 struct rpm_header {

    31 	unsigned char magic[4];

    32 	unsigned char reserved[4];

    33 	int nindex;

    34 	int hsize;

    35 };

    36 

    37 struct rpm_header_index {

    38 	int tag;

    39 	int type;

    40 	int offset;

    41 	int count;

    42 };

    43 

    44 struct properties {

    45 	struct rpm_header_index *name;

    46 	struct rpm_header_index *version;

    47 	struct rpm_header_index *flags;

    48 };

    49 

    50 struct razor_rpm {

    51 	struct rpm_header *signature;

    52 	struct rpm_header *header;

    53 

    54 	struct rpm_header_index *name;

    55 	struct rpm_header_index *version;

    56 	struct rpm_header_index *release;

    57 

    58 	struct rpm_header_index *dirnames;

    59 	struct rpm_header_index *dirindexes;

    60 	struct rpm_header_index *basenames;

    61 	struct rpm_header_index *filesizes;

    62 	struct rpm_header_index *filemodes;

    63 	struct rpm_header_index *filestates;

    64 	const char **dirs;

    65 

    66 	struct properties provides;

    67 	struct properties requires;

    68 	struct properties obsoletes;

    69 	struct properties conflicts;

    70 

    71 	const char *pool;

    72 	void *map;

    73 	size_t size;

    74 	void *payload;

    75 };

    76 

    77 #define ALIGN(value, base) (((value) + (base - 1)) & ~((base) - 1))

    78 

    79 static void

    80 import_properties(struct razor_importer *importer,

    81 		  struct properties *properties,

    82 		  const char *pool, unsigned long type)

    83 {

    84 	const char *name, *version;

    85 	int i, count;

    86 

    87 	/* assert: count is the same for all arrays */

    88 

    89 	if (properties->name == NULL)

    90 		return;

    91 

    92 	count = ntohl(properties->name->count);

    93 	name = pool + ntohl(properties->name->offset);

    94 	version = pool + ntohl(properties->version->offset);

    95 	for (i = 0; i < count; i++) {

    96 		razor_importer_add_property(importer, name, version, type);

    97 		name += strlen(name) + 1;

    98 		version += strlen(version) + 1;

    99 	}

   100 }

   101 

   102 static void

   103 import_files(struct razor_importer *importer, struct razor_rpm *rpm)

   104 {

   105 	const char *name;

   106 	unsigned long *index;

   107 	int i, count;

   108 	char buffer[256];

   109 

   110 	/* assert: count is the same for all arrays */

   111 

   112 	if (rpm->dirnames == NULL)

   113 		return;

   114 

   115 	count = ntohl(rpm->basenames->count);

   116 	index = (unsigned long *) (rpm->pool + ntohl(rpm->dirindexes->offset));

   117 	name = rpm->pool + ntohl(rpm->basenames->offset);

   118 	for (i = 0; i < count; i++) {

   119 		snprintf(buffer, sizeof buffer,

   120 			 "%s%s", rpm->dirs[ntohl(*index)], name);

   121 		razor_importer_add_file(importer, buffer);

   122 		name += strlen(name) + 1;

   123 		index++;

   124 	}

   125 }

   126 

   127 #define MAP_ENTRY(field, tag) { offsetof(struct razor_rpm, field), tag }

   128 

   129 static struct index_map {

   130 	unsigned int offset;

   131 	unsigned int tag;

   132 } index_map[] =	{

   133 	MAP_ENTRY(name, RPMTAG_NAME),

   134 	MAP_ENTRY(version, RPMTAG_VERSION),

   135 	MAP_ENTRY(release, RPMTAG_RELEASE),

   136 	MAP_ENTRY(requires.name, RPMTAG_REQUIRENAME),

   137 	MAP_ENTRY(requires.version, RPMTAG_REQUIREVERSION),

   138 	MAP_ENTRY(requires.flags, RPMTAG_REQUIREFLAGS),

   139 	MAP_ENTRY(provides.name, RPMTAG_PROVIDENAME),

   140 	MAP_ENTRY(provides.version, RPMTAG_PROVIDEVERSION),

   141 	MAP_ENTRY(provides.flags, RPMTAG_PROVIDEFLAGS),

   142 	MAP_ENTRY(obsoletes.name, RPMTAG_OBSOLETENAME),

   143 	MAP_ENTRY(obsoletes.version, RPMTAG_OBSOLETEVERSION),

   144 	MAP_ENTRY(obsoletes.flags, RPMTAG_OBSOLETEFLAGS),

   145 	MAP_ENTRY(conflicts.name, RPMTAG_CONFLICTNAME),

   146 	MAP_ENTRY(conflicts.version, RPMTAG_CONFLICTVERSION),

   147 	MAP_ENTRY(conflicts.flags, RPMTAG_CONFLICTFLAGS),

   148 	MAP_ENTRY(dirindexes, RPMTAG_DIRINDEXES),

   149 	MAP_ENTRY(basenames, RPMTAG_BASENAMES),

   150 	MAP_ENTRY(dirnames, RPMTAG_DIRNAMES),

   151 	MAP_ENTRY(filesizes, RPMTAG_FILESIZES),

   152 	MAP_ENTRY(filemodes, RPMTAG_FILEMODES),

   153 	MAP_ENTRY(filestates, RPMTAG_FILESTATES),

   154 };

   155 

   156 static struct rpm_header_index *

   157 razor_rpm_get_header(struct razor_rpm *rpm, unsigned int tag)

   158 {

   159 	struct rpm_header_index *index, *end;

   160 

   161 	index = (struct rpm_header_index *) (rpm->header + 1);

   162 	end = index + ntohl(rpm->header->nindex);

   163 	while (index < end) {

   164 		if (ntohl(index->tag) == tag)

   165 			return index;

   166 		index++;

   167 	}

   168 

   169 	return NULL;

   170 }

   171 

   172 struct razor_rpm *

   173 razor_rpm_open(const char *filename)

   174 {

   175 	struct razor_rpm *rpm;

   176 	struct rpm_header_index *base, *index;

   177 	struct stat buf;

   178 	int fd, nindex, hsize, i, j, count;

   179 	const char *name;

   180 

   181 	rpm = malloc(sizeof *rpm);

   182 	memset(rpm, 0, sizeof *rpm);

   183 	if (stat(filename, &buf) < 0) {

   184 		fprintf(stderr, "no such file %s (%m)\n", filename);

   185 		return NULL;

   186 	}

   187 

   188 	fd = open(filename, O_RDONLY);

   189 	if (fd < 0) {

   190 		fprintf(stderr, "couldn't open %s\n", filename);

   191 		return NULL;

   192 	}

   193 	rpm->size = buf.st_size;

   194 	rpm->map = mmap(NULL, rpm->size, PROT_READ, MAP_PRIVATE, fd, 0);

   195 	if (rpm->map == MAP_FAILED) {

   196 		fprintf(stderr, "couldn't mmap %s\n", filename);

   197 		return NULL;

   198 	}

   199 	close(fd);

   200 

   201 	rpm->signature = rpm->map + RPM_LEAD_SIZE;

   202 	nindex = ntohl(rpm->signature->nindex);

   203 	hsize = ntohl(rpm->signature->hsize);

   204 	rpm->header = (void *) (rpm->signature + 1) +

   205 		ALIGN(nindex * sizeof *index + hsize, 8);

   206 	nindex = ntohl(rpm->header->nindex);

   207 	hsize = ntohl(rpm->header->hsize);

   208 	rpm->payload = (void *) (rpm->header + 1) +

   209 		nindex * sizeof *index + hsize;

   210 

   211 	base = (struct rpm_header_index *) (rpm->header + 1);

   212 	rpm->pool = (void *) base + nindex * sizeof *index;

   213 

   214 	for (i = 0; i < nindex; i++) {

   215 		index = base + i;

   216 		for (j = 0; j < ARRAY_SIZE(index_map); j++) {

   217 			struct rpm_header_index **p;

   218 			if (index_map[j].tag == ntohl(index->tag)) {

   219 				p = (void *) rpm + index_map[j].offset;

   220 				*p = index;

   221 			}

   222 		}				 

   223 	}

   224 

   225 	/* Look up dir names now so we can index them directly. */

   226 	if (rpm->dirnames != NULL) {

   227 		count = ntohl(rpm->dirnames->count);

   228 		rpm->dirs = calloc(count, sizeof *rpm->dirs);

   229 		name = rpm->pool + ntohl(rpm->dirnames->offset);

   230 		for (i = 0; i < count; i++) {

   231 			rpm->dirs[i] = name;

   232 			name += strlen(name) + 1;

   233 		}

   234 	}

   235 

   236 	return rpm;

   237 }

   238 

   239 struct cpio_file_header {

   240 	char magic[6];

   241 	char inode[8];

   242 	char mode[8];

   243 	char uid[8];

   244 	char gid[8];

   245 	char nlink[8];

   246 	char mtime[8];

   247 	char filesize[8];

   248 	char devmajor[8];

   249 	char devminor[8];

   250 	char rdevmajor[8];

   251 	char rdevminor[8];

   252 	char namesize[8];

   253 	char checksum[8];

   254 	char filename[0];

   255 };

   256 

   257 /* gzip flags */

   258 #define ASCII_FLAG   0x01 /* bit 0 set: file probably ascii text */

   259 #define HEAD_CRC     0x02 /* bit 1 set: header CRC present */

   260 #define EXTRA_FIELD  0x04 /* bit 2 set: extra field present */

   261 #define ORIG_NAME    0x08 /* bit 3 set: original file name present */

   262 #define COMMENT      0x10 /* bit 4 set: file comment present */

   263 #define RESERVED     0xE0 /* bits 5..7: reserved */

   264 

   265 static int

   266 create_path(const char *root, const char *path,

   267 	    const char *name, unsigned mode, int *fd)

   268 {

   269 	char buffer[256], *p;

   270 	const char *slash, *next;

   271 	struct stat buf;

   272 

   273 	/* Create all sub-directories in dir and then create name. We

   274 	 * know root exists and is a dir, root does not end in a '/',

   275 	 * and path has a leading '/'. */

   276 

   277 	strcpy(buffer, root);

   278 	p = buffer + strlen(buffer);

   279 	slash = path;

   280 	for (slash = path; slash[1] != '\0'; slash = next) {

   281 		next = strchr(slash + 1, '/');

   282 		memcpy(p, slash, next - slash);

   283 		p += next - slash;

   284 		*p = '\0';

   285 

   286 		if (stat(buffer, &buf) == 0) {

   287 			if (!S_ISDIR(buf.st_mode)) {

   288 				fprintf(stderr,

   289 					"%s exists but is not a directory\n",

   290 					buffer);

   291 				return -1;

   292 			}

   293 		} else if (mkdir(buffer, 0777) < 0) {

   294 			fprintf(stderr, "failed to make directory %s: %m\n",

   295 				buffer);

   296 			return -1;

   297 		}

   298 		/* FIXME: permissions */

   299 	}

   300 

   301 	*p++ = '/';

   302 	strcpy(p, name);

   303 

   304 	switch (mode >> 12) {

   305 	case REG:

   306 	default:

   307 		*fd = open(buffer, O_WRONLY | O_CREAT | O_TRUNC, mode & 0x1ff);

   308 		return *fd;

   309 	case XDIR:

   310 		*fd = -1;

   311 		return mkdir(buffer, mode & 0x1ff);

   312 	}

   313 }

   314 

   315 static int

   316 run_script(struct razor_rpm *rpm, const char *root, unsigned int tag)

   317 {

   318 	struct rpm_header_index *index;

   319 	int pid, status, fd[2];

   320 	const char *script;

   321 

   322 	index = razor_rpm_get_header(rpm, tag);

   323 	if (index == NULL) {

   324 		fprintf(stderr, "no script for tag %d\n", tag);

   325 		return 0;

   326 	}

   327 

   328 	if (pipe(fd) < 0) {

   329 		fprintf(stderr, "failed to create pipe\n");

   330 		return -1;

   331 	}

   332 	pid = fork();

   333 	if (pid < 0) {

   334 		fprintf(stderr, "failed to fork, %m\n");

   335 	} else if (pid == 0) {

   336 		if (dup2(fd[0], STDIN_FILENO) < 0) {

   337 			fprintf(stderr, "failed redirect stdin, %m\n");

   338 			return -1;

   339 		}

   340 		if (close(fd[0]) < 0 || close(fd[1]) < 0) {

   341 			fprintf(stderr, "failed to close pipe, %m\n");

   342 			exit(-1);

   343 		}

   344 		if (chroot(root) < 0) {

   345 			fprintf(stderr, "failed to chroot to %s, %m\n", root);

   346 			return -1;

   347 		}

   348 		printf("executing script for %d\n", tag);

   349 		if (execl("/bin/sh", "/bin/sh", NULL)) {

   350 			fprintf(stderr, "failed to exec /bin/sh, %m\n");

   351 			return -1;

   352 		}

   353 	} else {

   354 		script = rpm->pool + ntohl(index->offset);

   355 		if (write(fd[1], script, strlen(script)) < 0) {

   356 			fprintf(stderr, "failed to pipe script, %m\n");

   357 			return -1;

   358 		}

   359 		if (close(fd[0]) || close(fd[1])) {

   360 			fprintf(stderr, "failed to close pipe, %m\n");

   361 			return -1;

   362 		}

   363 		if (wait(&status) < 0) {

   364 			fprintf(stderr, "wait for child failed, %m");

   365 			return -1;

   366 		}

   367 		printf("script exited with status %d\n", status);

   368 	}

   369 

   370 	return 0;

   371 }

   372 

   373 int

   374 razor_rpm_install(struct razor_rpm *rpm, const char *root)

   375 {

   376 	z_stream stream;

   377 	unsigned char payload[32768], *gz_header;

   378 	char buffer[256];

   379 	int err, method, flags, count, i, fd, written;

   380 	struct cpio_file_header *header;

   381 	unsigned long *size, *index, rest, length;

   382 	unsigned short *mode;

   383 	const char *name, *dir;

   384 	struct stat buf;

   385 

   386 	if (stat(root, &buf) < 0 || !S_ISDIR(buf.st_mode)) {

   387 		fprintf(stderr,

   388 			"root installation directory \"%s\" does not exist\n",

   389 			root);

   390 		return -1;

   391 	}

   392 

   393 	gz_header = rpm->payload;

   394 	if (gz_header[0] != 0x1f || gz_header[1] != 0x8b) {

   395 		fprintf(stderr, "payload section doesn't have gz header\n");

   396 		return -1;

   397 	}

   398 

   399 	method = gz_header[2];

   400 	flags = gz_header[3];

   401 

   402 	if (method != Z_DEFLATED || flags != 0) {

   403 		fprintf(stderr,

   404 			"unknown payload compression method or flags set\n");

   405 		return -1;

   406 	}

   407 

   408 	run_script(rpm, root, RPMTAG_PREIN);

   409 

   410 	stream.zalloc = NULL;

   411 	stream.zfree = NULL;

   412 	stream.opaque = NULL;

   413 

   414 	stream.next_in  = gz_header + 10;

   415 	stream.avail_in = (rpm->map + rpm->size) - (void *) stream.next_in;

   416 	stream.next_out = NULL;

   417 	stream.avail_out = 0;

   418 

   419 	err = inflateInit2(&stream, -MAX_WBITS);

   420 	if (err != Z_OK) {

   421 		fprintf(stderr, "inflateInit error: %d\n", err);

   422 		return -1;

   423 	}

   424 

   425 	count = ntohl(rpm->basenames->count);

   426 	size = (unsigned long *) (rpm->pool + ntohl(rpm->filesizes->offset));

   427 	index = (unsigned long *) (rpm->pool + ntohl(rpm->dirindexes->offset));

   428 	mode = (unsigned short *) (rpm->pool + ntohl(rpm->filemodes->offset));

   429 	name = rpm->pool + ntohl(rpm->basenames->offset);

   430 	for (i = 0; i < count; i++) {

   431 		dir = rpm->dirs[ntohl(*index)];

   432 		snprintf(buffer, sizeof buffer, "%s%s", dir, name);

   433 

   434 		stream.next_out = payload;

   435 		/* Plus two for the leading '.' and the terminating NUL. */

   436 		stream.avail_out =

   437 			ALIGN(sizeof *header + strlen(buffer) + 2, 4);

   438 		err = inflate(&stream, Z_SYNC_FLUSH);

   439 		if (err != Z_OK) {

   440 			fprintf(stderr, "inflate error: %d\n", err);

   441 			return -1;

   442 		}

   443 	    

   444 		header = (struct cpio_file_header *) payload;

   445 

   446 		/* FIXME: Figure out if it's a symlink, device file,

   447 		 * directorys or whatever.  Maybe do this upfront. */

   448 		if (create_path(root, dir, name, ntohs(*mode), &fd) < 0)

   449 			return -1;

   450 		if (ntohs(*mode) >> 12 == XDIR)

   451 			rest = 0;

   452 		else

   453 			rest = ntohl(*size);

   454 

   455 		while (rest > 0) {

   456 			if (ALIGN(rest, 4) > sizeof payload)

   457 				length = sizeof payload;

   458 			else

   459 				length = rest;

   460 			stream.next_out = payload;

   461 			stream.avail_out = ALIGN(length, 4);

   462 			err = inflate(&stream, Z_SYNC_FLUSH);

   463 			if (err != Z_OK && err != Z_STREAM_END) {

   464 				fprintf(stderr,

   465 					"inflate error: %d (%m)\n", err);

   466 				return -1;

   467 			}

   468 			rest -= length;

   469 			stream.next_out = payload;

   470 			while (length > 0) {

   471 				written = write(fd, stream.next_out, length);

   472 				if (written < 0) {

   473 					fprintf(stderr, "write error: %m\n");

   474 					return -1;

   475 				}

   476 				length -= written;

   477 			}

   478 		}

   479 		if (fd > 0 && close(fd) < 0) {

   480 			fprintf(stderr, "failed to close \"%s/%s%s\": %m\n",

   481 				root, dir, name);

   482 			return -1;

   483 		}

   484 		name += strlen(name) + 1;

   485 		index++;

   486 		size++;

   487 		mode++;

   488 	}

   489 

   490 	err = inflateEnd(&stream);

   491 

   492 	if (err != Z_OK) {

   493 		fprintf(stderr, "inflateEnd error: %d\n", err);

   494 		return -1;

   495 	}	    

   496 

   497 	run_script(rpm, root, RPMTAG_POSTIN);

   498 

   499 	return 0;

   500 }

   501 

   502 int

   503 razor_rpm_close(struct razor_rpm *rpm)

   504 {

   505 	int err;

   506 

   507 	free(rpm->dirs);

   508 	err = munmap(rpm->map, rpm->size);

   509 	free(rpm);

   510 

   511 	return err;

   512 }

   513 

   514 int

   515 razor_importer_add_rpm(struct razor_importer *importer, struct razor_rpm *rpm)

   516 {

   517 	razor_importer_begin_package(importer,

   518 				     rpm->pool + ntohl(rpm->name->offset),

   519 				     rpm->pool + ntohl(rpm->version->offset));

   520 

   521 	import_properties(importer, &rpm->requires,

   522 			  rpm->pool, RAZOR_PROPERTY_REQUIRES);

   523 	import_properties(importer, &rpm->provides,

   524 			  rpm->pool, RAZOR_PROPERTY_PROVIDES);

   525 	import_properties(importer, &rpm->conflicts,

   526 			  rpm->pool, RAZOR_PROPERTY_CONFLICTS);

   527 	import_properties(importer, &rpm->obsoletes,

   528 			  rpm->pool, RAZOR_PROPERTY_OBSOLETES);

   529 	import_files(importer, rpm);

   530 

   531 	razor_importer_finish_package(importer);

   532 

   533 	return 0;

   534 }
razor