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:46:52 2007 -0500 (2007-12-27)
changeset 84 6883222205ad
parent 77 3d14834c56ea
child 85 c5041a93b91a
permissions -rw-r--r--
Use an array of tags instead of a big switch for parsing the RPM headers. 
     1 #include <stdio.h>

     2 #include <stddef.h>

     3 #include <string.h>

     4 #include <sys/stat.h>

     5 #include <sys/mman.h>

     6 #include <fcntl.h>

     7 #include <unistd.h>

     8 #include <arpa/inet.h>

     9 #include <rpm/rpmlib.h>

    10 #include <zlib.h>

    11 

    12 #include "razor.h"

    13 

    14 #define	RPM_LEAD_SIZE 96

    15 

    16 struct rpm_lead {

    17 	unsigned char magic[4];

    18 	unsigned char major;

    19 	unsigned char minor;

    20 	short type;

    21 	short archnum;

    22 	char name[66];

    23 	short osnum;

    24 	short signature_type;

    25 	char reserved[16];

    26 };

    27 

    28 struct rpm_header {

    29 	unsigned char magic[4];

    30 	unsigned char reserved[4];

    31 	int nindex;

    32 	int hsize;

    33 };

    34 

    35 struct rpm_header_index {

    36 	int tag;

    37 	int type;

    38 	int offset;

    39 	int count;

    40 };

    41 

    42 struct properties {

    43 	struct rpm_header_index *name;

    44 	struct rpm_header_index *version;

    45 	struct rpm_header_index *flags;

    46 };

    47 

    48 struct razor_rpm {

    49 	struct rpm_header *signature;

    50 	struct rpm_header *header;

    51 

    52 	struct rpm_header_index *name;

    53 	struct rpm_header_index *version;

    54 	struct rpm_header_index *release;

    55 

    56 	struct rpm_header_index *dirnames;

    57 	struct rpm_header_index *dirindexes;

    58 	struct rpm_header_index *basenames;

    59 	struct rpm_header_index *filesizes;

    60 	struct rpm_header_index *filemodes;

    61 	struct rpm_header_index *filestates;

    62 	const char **dirs;

    63 

    64 	struct rpm_header_index *prein;

    65 	struct rpm_header_index *postin;

    66 	struct rpm_header_index *preun;

    67 	struct rpm_header_index *postun;

    68 

    69 	struct properties provides;

    70 	struct properties requires;

    71 	struct properties obsoletes;

    72 	struct properties conflicts;

    73 

    74 	const char *pool;

    75 	void *map;

    76 	size_t size;

    77 	void *payload;

    78 };

    79 

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

    81 

    82 static void

    83 import_properties(struct razor_importer *importer,

    84 		  struct properties *properties,

    85 		  const char *pool, unsigned long type)

    86 {

    87 	const char *name, *version;

    88 	int i, count;

    89 

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

    91 

    92 	if (properties->name == NULL)

    93 		return;

    94 

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

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

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

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

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

   100 		name += strlen(name) + 1;

   101 		version += strlen(version) + 1;

   102 	}

   103 }

   104 

   105 static void

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

   107 {

   108 	const char *name;

   109 	unsigned long *index;

   110 	int i, count;

   111 	char buffer[256];

   112 

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

   114 

   115 	if (rpm->dirnames == NULL)

   116 		return;

   117 

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

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

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

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

   122 		snprintf(buffer, sizeof buffer,

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

   124 		razor_importer_add_file(importer, buffer);

   125 		name += strlen(name) + 1;

   126 		index++;

   127 	}

   128 }

   129 

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

   131 

   132 static struct index_map {

   133 	unsigned int offset;

   134 	unsigned int tag;

   135 } index_map[] =	{

   136 	MAP_ENTRY(prein, RPMTAG_PREIN),

   137 	MAP_ENTRY(prein, RPMTAG_PREIN),

   138 	MAP_ENTRY(postin, RPMTAG_POSTIN),

   139 	MAP_ENTRY(preun, RPMTAG_PREUN),

   140 	MAP_ENTRY(postun, RPMTAG_POSTUN),

   141 	MAP_ENTRY(name, RPMTAG_NAME),

   142 	MAP_ENTRY(version, RPMTAG_VERSION),

   143 	MAP_ENTRY(release, RPMTAG_RELEASE),

   144 	MAP_ENTRY(requires.name, RPMTAG_REQUIRENAME),

   145 	MAP_ENTRY(requires.version, RPMTAG_REQUIREVERSION),

   146 	MAP_ENTRY(requires.flags, RPMTAG_REQUIREFLAGS),

   147 	MAP_ENTRY(provides.name, RPMTAG_PROVIDENAME),

   148 	MAP_ENTRY(provides.version, RPMTAG_PROVIDEVERSION),

   149 	MAP_ENTRY(provides.flags, RPMTAG_PROVIDEFLAGS),

   150 	MAP_ENTRY(obsoletes.name, RPMTAG_OBSOLETENAME),

   151 	MAP_ENTRY(obsoletes.version, RPMTAG_OBSOLETEVERSION),

   152 	MAP_ENTRY(obsoletes.flags, RPMTAG_OBSOLETEFLAGS),

   153 	MAP_ENTRY(conflicts.name, RPMTAG_CONFLICTNAME),

   154 	MAP_ENTRY(conflicts.version, RPMTAG_CONFLICTVERSION),

   155 	MAP_ENTRY(conflicts.flags, RPMTAG_CONFLICTFLAGS),

   156 	MAP_ENTRY(dirindexes, RPMTAG_DIRINDEXES),

   157 	MAP_ENTRY(basenames, RPMTAG_BASENAMES),

   158 	MAP_ENTRY(dirnames, RPMTAG_DIRNAMES),

   159 	MAP_ENTRY(filesizes, RPMTAG_FILESIZES),

   160 	MAP_ENTRY(filemodes, RPMTAG_FILEMODES),

   161 	MAP_ENTRY(filestates, RPMTAG_FILESTATES),

   162 };

   163 

   164 struct razor_rpm *

   165 razor_rpm_open(const char *filename)

   166 {

   167 	struct razor_rpm *rpm;

   168 	struct rpm_header_index *base, *index;

   169 	struct stat buf;

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

   171 	const char *name;

   172 

   173 	rpm = malloc(sizeof *rpm);

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

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

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

   177 		return NULL;

   178 	}

   179 

   180 	fd = open(filename, O_RDONLY);

   181 	if (fd < 0) {

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

   183 		return NULL;

   184 	}

   185 	rpm->size = buf.st_size;

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

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

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

   189 		return NULL;

   190 	}

   191 	close(fd);

   192 

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

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

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

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

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

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

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

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

   201 		nindex * sizeof *index + hsize;

   202 

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

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

   205 

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

   207 		index = base + i;

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

   209 			struct rpm_header_index **p;

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

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

   212 				*p = index;

   213 			}

   214 		}				 

   215 	}

   216 

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

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

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

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

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

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

   223 			rpm->dirs[i] = name;

   224 			name += strlen(name) + 1;

   225 		}

   226 	}

   227 

   228 	return rpm;

   229 }

   230 

   231 struct cpio_file_header {

   232 	char magic[6];

   233 	char inode[8];

   234 	char mode[8];

   235 	char uid[8];

   236 	char gid[8];

   237 	char nlink[8];

   238 	char mtime[8];

   239 	char filesize[8];

   240 	char devmajor[8];

   241 	char devminor[8];

   242 	char rdevmajor[8];

   243 	char rdevminor[8];

   244 	char namesize[8];

   245 	char checksum[8];

   246 	char filename[0];

   247 };

   248 

   249 /* gzip flags */

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

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

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

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

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

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

   256 

   257 static int

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

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

   260 {

   261 	char buffer[256], *p;

   262 	const char *slash, *next;

   263 	struct stat buf;

   264 

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

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

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

   268 

   269 	strcpy(buffer, root);

   270 	p = buffer + strlen(buffer);

   271 	slash = path;

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

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

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

   275 		p += next - slash;

   276 		*p = '\0';

   277 

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

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

   280 				fprintf(stderr,

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

   282 					buffer);

   283 				return -1;

   284 			}

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

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

   287 				buffer);

   288 			return -1;

   289 		}

   290 		/* FIXME: permissions */

   291 	}

   292 

   293 	*p++ = '/';

   294 	strcpy(p, name);

   295 

   296 	switch (mode >> 12) {

   297 	case REG:

   298 	default:

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

   300 		return *fd;

   301 	case XDIR:

   302 		*fd = -1;

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

   304 	}

   305 }

   306 

   307 int

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

   309 {

   310 	z_stream stream;

   311 	unsigned char payload[32768], *gz_header;

   312 	char buffer[256];

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

   314 	struct cpio_file_header *header;

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

   316 	unsigned short *mode;

   317 	const char *name, *dir;

   318 	struct stat buf;

   319 

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

   321 		fprintf(stderr,

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

   323 			root);

   324 		return -1;

   325 	}

   326 

   327 	gz_header = rpm->payload;

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

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

   330 		return -1;

   331 	}

   332 

   333 	method = gz_header[2];

   334 	flags = gz_header[3];

   335 

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

   337 		fprintf(stderr,

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

   339 		return -1;

   340 	}

   341 

   342 	stream.zalloc = NULL;

   343 	stream.zfree = NULL;

   344 	stream.opaque = NULL;

   345 

   346 	stream.next_in  = gz_header + 10;

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

   348 	stream.next_out = NULL;

   349 	stream.avail_out = 0;

   350 

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

   352 	if (err != Z_OK) {

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

   354 		return -1;

   355 	}

   356 

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

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

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

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

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

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

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

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

   365 

   366 		stream.next_out = payload;

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

   368 		stream.avail_out =

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

   370 		err = inflate(&stream, Z_SYNC_FLUSH);

   371 		if (err != Z_OK) {

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

   373 			return -1;

   374 		}

   375 	    

   376 		header = (struct cpio_file_header *) payload;

   377 

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

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

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

   381 			return -1;

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

   383 			rest = 0;

   384 		else

   385 			rest = ntohl(*size);

   386 

   387 		while (rest > 0) {

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

   389 				length = sizeof payload;

   390 			else

   391 				length = rest;

   392 			stream.next_out = payload;

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

   394 			err = inflate(&stream, Z_SYNC_FLUSH);

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

   396 				fprintf(stderr,

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

   398 				return -1;

   399 			}

   400 			rest -= length;

   401 			stream.next_out = payload;

   402 			while (length > 0) {

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

   404 				if (written < 0) {

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

   406 					return -1;

   407 				}

   408 				length -= written;

   409 			}

   410 		}

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

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

   413 				root, dir, name);

   414 			return -1;

   415 		}

   416 		name += strlen(name) + 1;

   417 		index++;

   418 		size++;

   419 		mode++;

   420 	}

   421 

   422 	err = inflateEnd(&stream);

   423 

   424 	if (err != Z_OK) {

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

   426 		return -1;

   427 	}	    

   428 

   429 	return 0;

   430 }

   431 

   432 int

   433 razor_rpm_close(struct razor_rpm *rpm)

   434 {

   435 	int err;

   436 

   437 	free(rpm->dirs);

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

   439 	free(rpm);

   440 

   441 	return err;

   442 }

   443 

   444 int

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

   446 {

   447 	razor_importer_begin_package(importer,

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

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

   450 

   451 	import_properties(importer, &rpm->requires,

   452 			  rpm->pool, RAZOR_PROPERTY_REQUIRES);

   453 	import_properties(importer, &rpm->provides,

   454 			  rpm->pool, RAZOR_PROPERTY_PROVIDES);

   455 	import_properties(importer, &rpm->conflicts,

   456 			  rpm->pool, RAZOR_PROPERTY_CONFLICTS);

   457 	import_properties(importer, &rpm->obsoletes,

   458 			  rpm->pool, RAZOR_PROPERTY_OBSOLETES);

   459 	import_files(importer, rpm);

   460 

   461 	razor_importer_finish_package(importer);

   462 

   463 	return 0;

   464 }
razor