Mercurialrazor / file revision
summary | shortlog | changelog | graph | tags | branches | files | changeset | file | revisions | annotate | diff | raw
import.c
author Kristian H?gsberg <krh@redhat.com>
Sun Oct 21 21:42:31 2007 -0400 (2007-10-21)
changeset 47 b3c8d19f743e
parent 42 aedfc8f95227
child 48 458b03594baf
permissions -rw-r--r--
Update TODO a bit. 
     1 #define _GNU_SOURCE

     2 

     3 #include <string.h>

     4 #include <stdio.h>

     5 #include <sys/stat.h>

     6 #include <sys/mman.h>

     7 #include <unistd.h>

     8 #include <fcntl.h>

     9 #include <errno.h>

    10 

    11 #include <expat.h>

    12 #include <rpm/rpmlib.h>

    13 #include <rpm/rpmdb.h>

    14 #include "sha1.h"

    15 #include "razor.h"

    16 

    17 static void

    18 parse_package(struct razor_importer *importer, const char **atts, void *data)

    19 {

    20 	const char *name = NULL, *version = NULL;

    21 	int i;

    22 

    23 	for (i = 0; atts[i]; i += 2) {

    24 		if (strcmp(atts[i], "name") == 0)

    25 			name = atts[i + 1];

    26 		else if (strcmp(atts[i], "version") == 0)

    27 			version = atts[i + 1];

    28 	}

    29 

    30 	if (name == NULL || version == NULL) {

    31 		fprintf(stderr, "invalid package tag, "

    32 			"missing name or version attributes\n");

    33 		return;

    34 	}

    35 

    36 	razor_importer_begin_package(importer, name, version);

    37 }

    38 

    39 enum {

    40 	RZR_REQUIRES, RZR_PROVIDES

    41 };

    42 

    43 static void

    44 parse_property(struct razor_importer *importer, const char **atts, void *data)

    45 {

    46 	const char *name = NULL, *version = NULL;

    47 	int i;

    48 

    49 	for (i = 0; atts[i]; i += 2) {

    50 		if (strcmp(atts[i], "name") == 0)

    51 			name = atts[i + 1];

    52 		if (strcmp(atts[i], "version") == 0)

    53 			version = atts[i + 1];

    54 	}

    55 	

    56 	if (name == NULL) {

    57 		fprintf(stderr, "invalid tag, missing name attribute\n");

    58 		return;

    59 	}

    60 

    61 	switch ((int) data) {

    62 	case RZR_REQUIRES:

    63 		razor_importer_add_requires(importer, name, version);

    64 		break;

    65 	case RZR_PROVIDES:

    66 		razor_importer_add_provides(importer, name, version);

    67 		break;

    68 	}

    69 }

    70 

    71 static void

    72 start_element(void *data, const char *name, const char **atts)

    73 {

    74 	struct razor_importer *importer = data;

    75 

    76 	if (strcmp(name, "package") == 0)

    77 		parse_package(importer, atts, NULL);

    78 	else if (strcmp(name, "requires") == 0)

    79 		parse_property(importer, atts, (void *) RZR_REQUIRES);

    80 	else if (strcmp(name, "provides") == 0)

    81 		parse_property(importer, atts, (void*) RZR_PROVIDES);

    82 }

    83 

    84 static void

    85 end_element (void *data, const char *name)

    86 {

    87 	struct razor_importer *importer = data;

    88 

    89 	if (strcmp(name, "package") == 0)

    90 		razor_importer_finish_package(importer);

    91 }

    92 

    93 static int

    94 import_rzr_file(struct razor_importer *importer, const char *filename)

    95 {

    96 	SHA_CTX sha1;

    97 	XML_Parser parser;

    98 	int fd;

    99 	void *p;

   100 	struct stat stat;

   101 	unsigned char hash[20];

   102 

   103 	fd = open(filename, O_RDONLY);

   104 	if (fstat(fd, &stat) < 0)

   105 		return -1;

   106 	p = mmap(NULL, stat.st_size, PROT_READ, MAP_PRIVATE, fd, 0);

   107 	if (p == MAP_FAILED)

   108 		return -1;

   109 

   110 	parser = XML_ParserCreate(NULL);

   111 	XML_SetUserData(parser, importer);

   112 	XML_SetElementHandler(parser, start_element, end_element);

   113 	if (XML_Parse(parser, p, stat.st_size, 1) == XML_STATUS_ERROR) {

   114 		fprintf(stderr,

   115 			"%s at line %ld, %s\n",

   116 			XML_ErrorString(XML_GetErrorCode(parser)),

   117 			XML_GetCurrentLineNumber(parser),

   118 			filename);

   119 		return 1;

   120 	}

   121 

   122 	XML_ParserFree(parser);

   123 

   124 	SHA1_Init(&sha1);

   125 	SHA1_Update(&sha1, p, stat.st_size);

   126 	SHA1_Final(hash, &sha1);

   127 

   128 	close(fd);

   129 

   130 	munmap(p, stat.st_size);

   131 

   132 	return 0;

   133 }

   134 

   135 struct razor_set *

   136 razor_import_rzr_files(int count, const char *files[])

   137 {

   138 	struct razor_importer *importer;

   139 	int i;

   140 

   141 	importer = razor_importer_new();

   142 

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

   144 		if (import_rzr_file(importer, files[i]) < 0) {

   145 			fprintf(stderr, "failed to import %s\n", files[i]);

   146 			exit(-1);

   147 		}

   148 	}

   149 

   150 	return razor_importer_finish(importer);

   151 }

   152 

   153 /* Import a yum filelist as a razor package set. */

   154 

   155 enum {

   156 	YUM_STATE_BEGIN,

   157 	YUM_STATE_PACKAGE_NAME,

   158 	YUM_STATE_REQUIRES,

   159 	YUM_STATE_PROVIDES,

   160 	YUM_STATE_FILE

   161 };

   162 

   163 struct yum_context {

   164 	struct razor_importer *importer;

   165 	struct import_property_context *current_property_context;

   166 	char *name;

   167 	int state;

   168 };

   169 

   170 static void

   171 yum_start_element(void *data, const char *name, const char **atts)

   172 {

   173 	struct yum_context *ctx = data;

   174 	const char *n, *version;

   175 	int i;

   176 

   177 	if (strcmp(name, "name") == 0) {

   178 		ctx->state = YUM_STATE_PACKAGE_NAME;

   179 	} else if (strcmp(name, "version") == 0) {

   180 		version = NULL;

   181 		for (i = 0; atts[i]; i += 2) {

   182 			if (strcmp(atts[i], "ver") == 0)

   183 				version = atts[i + 1];

   184 		}

   185 		razor_importer_begin_package(ctx->importer, ctx->name, version);

   186 	} else if (strcmp(name, "rpm:requires") == 0) {

   187 		ctx->state = YUM_STATE_REQUIRES;

   188 	} else if (strcmp(name, "rpm:provides") == 0) {

   189 		ctx->state = YUM_STATE_PROVIDES;

   190 	} else if (strcmp(name, "rpm:entry") == 0 &&

   191 		   ctx->state != YUM_STATE_BEGIN) {

   192 		n = NULL;

   193 		version = NULL;

   194 		for (i = 0; atts[i]; i += 2) {

   195 			if (strcmp(atts[i], "name") == 0)

   196 				n = atts[i + 1];

   197 			else if (strcmp(atts[i], "ver") == 0)

   198 				version = atts[i + 1];

   199 		}

   200 

   201 		if (n == NULL) {

   202 			fprintf(stderr, "invalid rpm:entry, "

   203 				"missing name or version attributes\n");

   204 			return;

   205 		}

   206 

   207 		switch (ctx->state) {

   208 		case YUM_STATE_REQUIRES:

   209 			razor_importer_add_requires(ctx->importer, n, version);

   210 			break;

   211 		case YUM_STATE_PROVIDES:

   212 			razor_importer_add_provides(ctx->importer, n, version);

   213 			break;

   214 		}

   215 	} else if (strcmp(name, "file") == 0) {

   216 		ctx->state = YUM_STATE_FILE;

   217 	}

   218 }

   219 

   220 static void

   221 yum_end_element (void *data, const char *name)

   222 {

   223 	struct yum_context *ctx = data;

   224 

   225 	ctx->state = YUM_STATE_BEGIN;

   226 	if (strcmp(name, "package") == 0) {

   227 		free(ctx->name);

   228 		razor_importer_finish_package(ctx->importer);

   229 	}

   230 }

   231 

   232 static void

   233 yum_character_data (void *data, const XML_Char *s, int len)

   234 {

   235 	struct yum_context *ctx = data;

   236 	char filename[PATH_MAX];

   237 

   238 	if (ctx->state == YUM_STATE_PACKAGE_NAME)

   239 		ctx->name = strndup(s, len);

   240 	else if (ctx->state == YUM_STATE_FILE) {

   241 		snprintf(filename, sizeof filename, "%.*s", len, s);

   242 		razor_importer_add_file(ctx->importer, filename);

   243 	}

   244 }

   245 

   246 struct razor_set *

   247 razor_set_create_from_yum_filelist(int fd)

   248 {

   249 	struct yum_context ctx;

   250 	XML_Parser parser;

   251 	char buf[4096];

   252 	int len;

   253 

   254 	ctx.importer = razor_importer_new();	

   255 

   256 	parser = XML_ParserCreate(NULL);

   257 	XML_SetUserData(parser, &ctx);

   258 	XML_SetElementHandler(parser, yum_start_element, yum_end_element);

   259 	XML_SetCharacterDataHandler(parser, yum_character_data);

   260 

   261 	while (1) {

   262 		len = read(fd, buf, sizeof buf);

   263 		if (len < 0) {

   264 			fprintf(stderr,

   265 				"couldn't read input: %s\n", strerror(errno));

   266 			return NULL;

   267 		} else if (len == 0)

   268 			break;

   269 

   270 		if (XML_Parse(parser, buf, len, 0) == XML_STATUS_ERROR) {

   271 			fprintf(stderr,

   272 				"%s at line %ld\n",

   273 				XML_ErrorString(XML_GetErrorCode(parser)),

   274 				XML_GetCurrentLineNumber(parser));

   275 			return NULL;

   276 		}

   277 	}

   278 

   279 	XML_ParserFree(parser);

   280 

   281 	return razor_importer_finish(ctx.importer);

   282 }

   283 

   284 union rpm_entry {

   285 	void *p;

   286 	char *string;

   287 	char **list;

   288 	unsigned int *flags;

   289 };

   290 

   291 struct razor_set *

   292 razor_set_create_from_rpmdb(void)

   293 {

   294 	struct razor_importer *importer;

   295 	rpmdbMatchIterator iter;

   296 	Header h;

   297 	int_32 type, count, i;

   298 	union rpm_entry name, version, release;

   299 	union rpm_entry property_names, property_versions, property_flags;

   300 	union rpm_entry basenames, dirnames, dirindexes;

   301 	char filename[PATH_MAX];

   302 	rpmdb db;

   303 

   304 	rpmReadConfigFiles(NULL, NULL);

   305 

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

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

   308 		exit(1);

   309 	}

   310 

   311 	importer = razor_importer_new();

   312 

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

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

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

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

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

   318 		razor_importer_begin_package(importer,

   319 					     name.string, version.string);

   320 

   321 		headerGetEntry(h, RPMTAG_REQUIRENAME, &type,

   322 			       &property_names.p, &count);

   323 		headerGetEntry(h, RPMTAG_REQUIREVERSION, &type,

   324 			       &property_versions.p, &count);

   325 		headerGetEntry(h, RPMTAG_REQUIREFLAGS, &type,

   326 			       &property_flags.p, &count);

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

   328 			razor_importer_add_requires(importer,

   329 						    property_names.list[i],

   330 						    property_versions.list[i]);

   331 

   332 		headerGetEntry(h, RPMTAG_PROVIDENAME, &type,

   333 			       &property_names.p, &count);

   334 		headerGetEntry(h, RPMTAG_PROVIDEVERSION, &type,

   335 			       &property_versions.p, &count);

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

   337 			razor_importer_add_provides(importer,

   338 						    property_names.list[i],

   339 						    property_versions.list[i]);

   340 

   341 		headerGetEntry(h, RPMTAG_BASENAMES, &type,

   342 			       &basenames.p, &count);

   343 		headerGetEntry(h, RPMTAG_DIRNAMES, &type,

   344 			       &dirnames.p, &count);

   345 		headerGetEntry(h, RPMTAG_DIRINDEXES, &type,

   346 			       &dirindexes.p, &count);

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

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

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

   350 				 basenames.list[i]);

   351 			razor_importer_add_file(importer, filename);

   352 		}

   353 

   354 		razor_importer_finish_package(importer);

   355 	}

   356 

   357 	rpmdbClose(db);

   358 

   359 	return razor_importer_finish(importer);

   360 }
razor