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>
Mon Mar 17 19:28:42 2008 -0400 (2008-03-17)
changeset 177 a23f91e78747
parent 172 852e66234cf6
child 178 1efd1945b81a
permissions -rw-r--r--
Only mark pacakges for update if there is a newer version available. 
     1 #include <stdio.h>

     2 #include <stddef.h>

     3 #include <string.h>

     4 #include <errno.h>

     5 #include <sys/stat.h>

     6 #include <sys/mman.h>

     7 #include <sys/types.h>

     8 #include <sys/wait.h>

     9 #include <fcntl.h>

    10 #include <unistd.h>

    11 #include <arpa/inet.h>

    12 #include <rpm/rpmlib.h>

    13 #include <rpm/rpmdb.h>

    14 #include <zlib.h>

    15 

    16 #include "razor.h"

    17 #include "razor-internal.h"

    18 

    19 #define	RPM_LEAD_SIZE 96

    20 

    21 struct rpm_header {

    22 	unsigned char magic[4];

    23 	unsigned char reserved[4];

    24 	int nindex;

    25 	int hsize;

    26 };

    27 

    28 struct rpm_header_index {

    29 	int tag;

    30 	int type;

    31 	int offset;

    32 	int count;

    33 };

    34 

    35 struct razor_rpm {

    36 	struct rpm_header *signature;

    37 	struct rpm_header *header;

    38 	const char **dirs;

    39 	const char *pool;

    40 	void *map;

    41 	size_t size;

    42 	void *payload;

    43 };

    44 

    45 static struct rpm_header_index *

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

    47 {

    48 	struct rpm_header_index *index, *end;

    49 

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

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

    52 	while (index < end) {

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

    54 			return index;

    55 		index++;

    56 	}

    57 

    58 	return NULL;

    59 }

    60 

    61 static const void *

    62 razor_rpm_get_indirect(struct razor_rpm *rpm,

    63 		       unsigned int tag, unsigned int *count)

    64 {

    65 	struct rpm_header_index *index;

    66 

    67 	index = razor_rpm_get_header(rpm, tag);

    68 	if (index != NULL) {

    69 		if (count)

    70 			*count = ntohl(index->count);

    71 

    72 		return rpm->pool + ntohl(index->offset);

    73 	}

    74 

    75 	return NULL;

    76 }

    77 

    78 static enum razor_version_relation

    79 rpm_to_razor_flags (uint_32 flags)

    80 {

    81 	switch (flags & (RPMSENSE_LESS | RPMSENSE_EQUAL | RPMSENSE_GREATER)) {

    82 	case RPMSENSE_LESS:

    83 		return RAZOR_VERSION_LESS;

    84 	case RPMSENSE_LESS|RPMSENSE_EQUAL:

    85 		return RAZOR_VERSION_LESS_OR_EQUAL;

    86 	case RPMSENSE_EQUAL:

    87 		return RAZOR_VERSION_EQUAL;

    88 	case RPMSENSE_GREATER|RPMSENSE_EQUAL:

    89 		return RAZOR_VERSION_GREATER_OR_EQUAL;

    90 	case RPMSENSE_GREATER:

    91 		return RAZOR_VERSION_GREATER;

    92 	}

    93 

    94 	/* FIXME? */

    95 	return RAZOR_VERSION_EQUAL;

    96 }

    97 

    98 static void

    99 import_properties(struct razor_importer *importer, unsigned long type,

   100 		  struct razor_rpm *rpm,

   101 		  int name_tag, int version_tag, int flags_tag)

   102 {

   103 	const char *name, *version;

   104 	const uint_32 *flags;

   105 	uint_32 f;

   106 	unsigned int i, count;

   107 

   108 	name = razor_rpm_get_indirect(rpm, name_tag, &count);

   109 	if (name == NULL)

   110 		return;

   111 

   112 	flags = razor_rpm_get_indirect(rpm, flags_tag, &count);

   113 

   114 	version = razor_rpm_get_indirect(rpm, version_tag, &count);

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

   116 		f = rpm_to_razor_flags(ntohl(flags[i]));

   117 		razor_importer_add_property(importer, name, f, version, type);

   118 		name += strlen(name) + 1;

   119 		version += strlen(version) + 1;

   120 	}

   121 }

   122 

   123 static void

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

   125 {

   126 	const char *name;

   127 	const unsigned long *index;

   128 	unsigned int i, count;

   129 	char buffer[256];

   130 

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

   132 

   133 	index = razor_rpm_get_indirect(rpm, RPMTAG_DIRINDEXES, &count);

   134 	name = razor_rpm_get_indirect(rpm, RPMTAG_BASENAMES, &count);

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

   136 		snprintf(buffer, sizeof buffer,

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

   138 		razor_importer_add_file(importer, buffer);

   139 		name += strlen(name) + 1;

   140 		index++;

   141 	}

   142 }

   143 

   144 struct razor_rpm *

   145 razor_rpm_open(const char *filename)

   146 {

   147 	struct razor_rpm *rpm;

   148 	struct rpm_header_index *base, *index;

   149 	struct stat buf;

   150 	unsigned int count, i, nindex, hsize;

   151 	const char *name;

   152 	int fd;

   153 

   154 	rpm = malloc(sizeof *rpm);

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

   156 

   157 	fd = open(filename, O_RDONLY);

   158 	if (fd < 0) {

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

   160 		return NULL;

   161 	}

   162 

   163 	if (fstat(fd, &buf) < 0) {

   164 		fprintf(stderr, "failed to stat %s (%m)\n", filename);

   165 		return NULL;

   166 	}

   167 

   168 	rpm->size = buf.st_size;

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

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

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

   172 		return NULL;

   173 	}

   174 	close(fd);

   175 

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

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

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

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

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

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

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

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

   184 		nindex * sizeof *index + hsize;

   185 

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

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

   188 

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

   190 	name = razor_rpm_get_indirect(rpm, RPMTAG_DIRNAMES, &count);

   191 	if (name == NULL) {

   192 		fprintf(stderr, "old filename style not handled\n");

   193 		return NULL;

   194 	}

   195 

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

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

   198 		rpm->dirs[i] = name;

   199 		name += strlen(name) + 1;

   200 	}

   201 

   202 	return rpm;

   203 }

   204 

   205 struct cpio_file_header {

   206 	char magic[6];

   207 	char inode[8];

   208 	char mode[8];

   209 	char uid[8];

   210 	char gid[8];

   211 	char nlink[8];

   212 	char mtime[8];

   213 	char filesize[8];

   214 	char devmajor[8];

   215 	char devminor[8];

   216 	char rdevmajor[8];

   217 	char rdevminor[8];

   218 	char namesize[8];

   219 	char checksum[8];

   220 	char filename[0];

   221 };

   222 

   223 /* gzip flags */

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

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

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

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

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

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

   230 

   231 struct installer {

   232 	const char *root;

   233 	struct razor_rpm *rpm;

   234 	z_stream stream;

   235 	unsigned char buffer[32768];

   236 	size_t rest, length;

   237 };

   238 

   239 static int

   240 installer_inflate(struct installer *installer)

   241 {

   242 	size_t length;

   243 	int err;

   244 

   245 	if (ALIGN(installer->rest, 4) > sizeof installer->buffer)

   246 		length = sizeof installer->buffer;

   247 	else

   248 		length = installer->rest;

   249 

   250 	installer->stream.next_out = installer->buffer;

   251 	installer->stream.avail_out = ALIGN(length, 4);

   252 	err = inflate(&installer->stream, Z_SYNC_FLUSH);

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

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

   255 		return -1;

   256 	}

   257 

   258 	installer->rest -= length;

   259 	installer->length = length;

   260 

   261 	return 0;

   262 }

   263 

   264 static int

   265 create_path(struct installer *installer,

   266 	    const char *path, const char *name, unsigned int mode)

   267 {

   268 	char buffer[PATH_MAX];

   269 	struct stat buf;

   270 	int fd, ret;

   271 

   272 	if (razor_create_dir(installer->root, path) < 0)

   273 		return -1;

   274 

   275 	/* assertion: root doesn't end in a slash, path begins and end

   276 	 * with a slash, name does not begin with a slash. */

   277 	snprintf(buffer, sizeof buffer, "%s%s%s",

   278 		 installer->root, path, name);

   279 

   280 	switch (mode >> 12) {

   281 	case REG:

   282 		/* FIXME: handle the case where a file is already there. */

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

   284 		if (fd < 0){

   285 			fprintf(stderr, "failed to create file %s\n", buffer);

   286 			return -1;

   287 		}

   288 		while (installer->rest > 0) {

   289 			if (installer_inflate(installer)) {

   290 				fprintf(stderr, "failed to inflate\n");

   291 				return -1;

   292 			}

   293 			if (razor_write(fd, installer->buffer,

   294 					installer->length)) {

   295 				fprintf(stderr, "failed to write payload\n");

   296 				return -1;

   297 			}

   298 		}

   299 		if (close(fd) < 0) {

   300 			fprintf(stderr, "failed to close %s: %m\n", buffer);

   301 			return -1;

   302 		}

   303 		return 0;

   304 	case XDIR:

   305 		ret = mkdir(buffer, mode & 0x1ff);

   306 		if (ret == 0 || errno != EEXIST)

   307 			return ret;

   308 		if (stat(buffer, &buf) || !S_ISDIR(buf.st_mode)) {

   309 			/* FIXME: also check that mode match. */

   310 			fprintf(stderr,

   311 				"%s exists but is not a directory\n", buffer);

   312 			return -1;

   313 		}

   314 		return 0;

   315 	case PIPE:

   316 	case CDEV:

   317 	case BDEV:

   318 	case SOCK:

   319 		printf("%s: unhandled file type %d\n", buffer, mode >> 12);

   320 		return 0;

   321 	case LINK:

   322 		if (installer_inflate(installer)) {

   323 			fprintf(stderr, "failed to inflate\n");

   324 			return -1;

   325 		}

   326 		if (installer->length >= sizeof installer->buffer) {

   327 			fprintf(stderr, "link name too long\n");

   328 			return -1;

   329 		}

   330 		installer->buffer[installer->length] = '\0';

   331 		if (symlink((const char *) installer->buffer, buffer)) {

   332 			fprintf(stderr, "failed to create symlink, %m\n");

   333 			return -1;

   334 		}

   335 		return 0;

   336 	default:

   337 		printf("%s: unknown file type %d\n", buffer, mode >> 12);

   338 		return 0;

   339 	}

   340 }

   341 

   342 static int

   343 run_script(struct installer *installer,

   344 	   unsigned int program_tag, unsigned int script_tag)

   345 {

   346 	int pid, status, fd[2];

   347 	const char *script = NULL, *program = NULL;

   348 

   349 	program = razor_rpm_get_indirect(installer->rpm, program_tag, NULL);

   350 	script = razor_rpm_get_indirect(installer->rpm, script_tag, NULL);

   351 	if (program == NULL && script == NULL) {

   352 		printf("no script or program for tags %d and %d\n",

   353 		       program_tag, script_tag);

   354 		return -1;

   355 	} else if (program == NULL) {

   356 		program = "/bin/sh";

   357 	}

   358 

   359 	if (pipe(fd) < 0) {

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

   361 		return -1;

   362 	}

   363 	pid = fork();

   364 	if (pid < 0) {

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

   366 	} else if (pid == 0) {

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

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

   369 			return -1;

   370 		}

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

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

   373 			return -1;

   374 		}

   375 		if (chroot(installer->root) < 0) {

   376 			fprintf(stderr, "failed to chroot to %s, %m\n",

   377 				installer->root);

   378 			return -1;

   379 		}

   380 		printf("executing program %s in chroot %s\n",

   381 		       program, installer->root);

   382 		if (execl(program, program, NULL)) {

   383 			fprintf(stderr, "failed to exec %s, %m\n", program);

   384 			exit(-1);

   385 		}

   386 	} else {

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

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

   389 			return -1;

   390 		}

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

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

   393 			return -1;

   394 		}

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

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

   397 			return -1;

   398 		}

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

   400 	}

   401 

   402 	return 0;

   403 }

   404 

   405 static int

   406 installer_init(struct installer *installer)

   407 {

   408 	unsigned char *gz_header;

   409 	int method, flags, err;

   410 

   411 	gz_header = installer->rpm->payload;

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

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

   414 		return -1;

   415 	}

   416 

   417 	method = gz_header[2];

   418 	flags = gz_header[3];

   419 

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

   421 		fprintf(stderr,

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

   423 		return -1;

   424 	}

   425 

   426 	installer->stream.zalloc = NULL;

   427 	installer->stream.zfree = NULL;

   428 	installer->stream.opaque = NULL;

   429 

   430 	installer->stream.next_in  = gz_header + 10;

   431 	installer->stream.avail_in =

   432 		(installer->rpm->map + installer->rpm->size) -

   433 		(void *) installer->stream.next_in;

   434 	installer->stream.next_out = NULL;

   435 	installer->stream.avail_out = 0;

   436 

   437 	err = inflateInit2(&installer->stream, -MAX_WBITS);

   438 	if (err != Z_OK) {

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

   440 		return -1;

   441 	}

   442 

   443 	return 0;

   444 }

   445 

   446 static int

   447 installer_finish(struct installer *installer)

   448 {

   449 	int err;

   450 

   451 	err = inflateEnd(&installer->stream);

   452 

   453 	if (err != Z_OK) {

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

   455 		return -1;

   456 	}	    

   457 

   458 	return 0;

   459 }

   460 

   461 int

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

   463 {

   464 	struct installer installer;

   465 	unsigned int count, i, length;

   466 	struct cpio_file_header *header;

   467 	const unsigned long *size, *index, *flags;

   468 	const unsigned short *mode;

   469 	const char *name, *dir;

   470 	struct stat buf;

   471 

   472 	installer.rpm = rpm;

   473 	installer.root = root;

   474 

   475 	/* FIXME: Only do this before a transaction, not per rpm. */

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

   477 		fprintf(stderr,

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

   479 			root);

   480 		return -1;

   481 	}

   482 

   483 	if (installer_init(&installer))

   484 		return -1;

   485 

   486 	run_script(&installer, RPMTAG_PREINPROG, RPMTAG_PREIN);

   487 

   488 	name = razor_rpm_get_indirect(rpm, RPMTAG_BASENAMES, &count);

   489 	size = razor_rpm_get_indirect(rpm, RPMTAG_FILESIZES, &count);

   490 	index = razor_rpm_get_indirect(rpm, RPMTAG_DIRINDEXES, &count);

   491 	mode = razor_rpm_get_indirect(rpm, RPMTAG_FILEMODES, &count);

   492 	flags = razor_rpm_get_indirect(rpm, RPMTAG_FILEFLAGS, &count);

   493 

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

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

   496 

   497 		/* Skip past the cpio header block unless it's a ghost file,

   498 		 * in which case doesn't appear in the cpio archive. */

   499 		if (!(ntohl(*flags) & RPMFILE_GHOST)) {

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

   501 			length = sizeof *header + strlen(dir) + strlen(name) + 2;

   502 			installer.rest = ALIGN(length, 4);

   503 			if (installer_inflate(&installer))

   504 				return -1;

   505 		}

   506 

   507 		installer.rest = ntohl(*size);

   508 		if (create_path(&installer, dir, name, ntohs(*mode)) < 0)

   509 			return -1;

   510 

   511 		name += strlen(name) + 1;

   512 		index++;

   513 		size++;

   514 		mode++;

   515 		flags++;

   516 	}

   517 

   518 	if (installer_finish(&installer))

   519 		return -1;

   520 

   521 	run_script(&installer, RPMTAG_POSTINPROG, RPMTAG_POSTIN);

   522 

   523 	return 0;

   524 }

   525 

   526 int

   527 razor_rpm_close(struct razor_rpm *rpm)

   528 {

   529 	int err;

   530 

   531 	free(rpm->dirs);

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

   533 	free(rpm);

   534 

   535 	return err;

   536 }

   537 

   538 int

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

   540 {

   541 	const char *name, *version, *release;

   542 	const uint_32 *epoch;

   543 	char evr[128], buf[16];

   544 

   545 	name = razor_rpm_get_indirect(rpm, RPMTAG_NAME, NULL);

   546 	epoch = razor_rpm_get_indirect(rpm, RPMTAG_EPOCH, NULL);

   547 	version = razor_rpm_get_indirect(rpm, RPMTAG_VERSION, NULL);

   548 	release = razor_rpm_get_indirect(rpm, RPMTAG_RELEASE, NULL);

   549 

   550 	if (epoch) {

   551 		snprintf(buf, sizeof buf, "%u", ntohl(*epoch));

   552 		razor_build_evr(evr, sizeof evr, buf, version, release);

   553 	} else {

   554 		razor_build_evr(evr, sizeof evr, NULL, version, release);

   555 	}

   556 	razor_importer_begin_package(importer, name, evr);

   557 

   558 	import_properties(importer, RAZOR_PROPERTY_REQUIRES, rpm,

   559 			  RPMTAG_REQUIRENAME,

   560 			  RPMTAG_REQUIREVERSION,

   561 			  RPMTAG_REQUIREFLAGS);

   562 

   563 	import_properties(importer, RAZOR_PROPERTY_PROVIDES, rpm,

   564 			  RPMTAG_PROVIDENAME,

   565 			  RPMTAG_PROVIDEVERSION,

   566 			  RPMTAG_PROVIDEFLAGS);

   567 

   568 	import_properties(importer, RAZOR_PROPERTY_OBSOLETES, rpm,

   569 			  RPMTAG_OBSOLETENAME,

   570 			  RPMTAG_OBSOLETEVERSION,

   571 			  RPMTAG_OBSOLETEFLAGS);

   572 

   573 	import_properties(importer, RAZOR_PROPERTY_CONFLICTS, rpm,

   574 			  RPMTAG_CONFLICTNAME,

   575 			  RPMTAG_CONFLICTVERSION,

   576 			  RPMTAG_CONFLICTFLAGS);

   577 

   578 	import_files(importer, rpm);

   579 

   580 	razor_importer_finish_package(importer);

   581 

   582 	return 0;

   583 }

   584 

   585 union rpm_entry {

   586 	void *p;

   587 	char *string;

   588 	char **list;

   589 	uint_32 *flags;

   590 	uint_32 integer;

   591 };

   592 

   593 static void

   594 add_properties(struct razor_importer *importer,

   595 	       enum razor_property_type property_type,

   596 	       Header h, int_32 name_tag, int_32 version_tag, int_32 flags_tag)

   597 {

   598 	union rpm_entry names, versions, flags;

   599 	int_32 i, type, count;

   600 

   601 	headerGetEntry(h, name_tag, &type, &names.p, &count);

   602 	headerGetEntry(h, version_tag, &type, &versions.p, &count);

   603 	headerGetEntry(h, flags_tag, &type, &flags.p, &count);

   604 

   605 	for (i = 0; i < count; i++)

   606 		razor_importer_add_property(importer,

   607 					    names.list[i],

   608 					    rpm_to_razor_flags (flags.flags[i]),

   609 					    versions.list[i],

   610 					    property_type);

   611 }

   612 

   613 struct razor_set *

   614 razor_set_create_from_rpmdb(void)

   615 {

   616 	struct razor_importer *importer;

   617 	rpmdbMatchIterator iter;

   618 	Header h;

   619 	int_32 type, count, i;

   620 	union rpm_entry name, epoch, version, release;

   621 	union rpm_entry basenames, dirnames, dirindexes;

   622 	char filename[PATH_MAX], evr[128], buf[16];

   623 	rpmdb db;

   624 

   625 	rpmReadConfigFiles(NULL, NULL);

   626 

   627 	if (rpmdbOpen("", &db, O_RDONLY, 0644) != 0) {

   628 		fprintf(stderr, "cannot open rpm database\n");

   629 		exit(1);

   630 	}

   631 

   632 	importer = razor_importer_new();

   633 

   634 	iter = rpmdbInitIterator(db, 0, NULL, 0);

   635 	while (h = rpmdbNextIterator(iter), h != NULL) {

   636 		headerGetEntry(h, RPMTAG_NAME, &type, &name.p, &count);

   637 		headerGetEntry(h, RPMTAG_EPOCH, &type, &epoch.p, &count);

   638 		headerGetEntry(h, RPMTAG_VERSION, &type, &version.p, &count);

   639 		headerGetEntry(h, RPMTAG_RELEASE, &type, &release.p, &count);

   640 

   641 		if (epoch.flags != NULL) {

   642 			snprintf(buf, sizeof buf, "%u", *epoch.flags);

   643 			razor_build_evr(evr, sizeof evr,

   644 					buf, version.string, release.string);

   645 		} else {

   646 			razor_build_evr(evr, sizeof evr,

   647 					NULL, version.string, release.string);

   648 		}

   649 

   650 		razor_importer_begin_package(importer, name.string, evr);

   651 

   652 		add_properties(importer, RAZOR_PROPERTY_REQUIRES, h,

   653 			       RPMTAG_REQUIRENAME,

   654 			       RPMTAG_REQUIREVERSION,

   655 			       RPMTAG_REQUIREFLAGS);

   656 

   657 		add_properties(importer, RAZOR_PROPERTY_PROVIDES, h,

   658 			       RPMTAG_PROVIDENAME,

   659 			       RPMTAG_PROVIDEVERSION,

   660 			       RPMTAG_PROVIDEFLAGS);

   661 

   662 		add_properties(importer, RAZOR_PROPERTY_OBSOLETES, h,

   663 			       RPMTAG_OBSOLETENAME,

   664 			       RPMTAG_OBSOLETEVERSION,

   665 			       RPMTAG_OBSOLETEFLAGS);

   666 

   667 		add_properties(importer, RAZOR_PROPERTY_CONFLICTS, h,

   668 			       RPMTAG_CONFLICTNAME,

   669 			       RPMTAG_CONFLICTVERSION,

   670 			       RPMTAG_CONFLICTFLAGS);

   671 

   672 		headerGetEntry(h, RPMTAG_BASENAMES, &type,

   673 			       &basenames.p, &count);

   674 		headerGetEntry(h, RPMTAG_DIRNAMES, &type,

   675 			       &dirnames.p, &count);

   676 		headerGetEntry(h, RPMTAG_DIRINDEXES, &type,

   677 			       &dirindexes.p, &count);

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

   679 			snprintf(filename, sizeof filename, "%s%s",

   680 				 dirnames.list[dirindexes.flags[i]],

   681 				 basenames.list[i]);

   682 			razor_importer_add_file(importer, filename);

   683 		}

   684 

   685 		razor_importer_finish_package(importer);

   686 	}

   687 

   688 	rpmdbClose(db);

   689 

   690 	return razor_importer_finish(importer);

   691 }
razor