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>
Fri Oct 05 16:26:27 2007 -0400 (2007-10-05)
changeset 44 3d1a1517fa1d
parent 31 50fd9002d5ee
child 46 8de578466ece
permissions -rw-r--r--
Add diff function to compute the difference between two package sets. 
     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 %d, %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 };

   161 

   162 struct yum_context {

   163 	struct razor_importer *importer;

   164 	struct import_property_context *current_property_context;

   165 	char *name;

   166 	int state;

   167 };

   168 

   169 static void

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

   171 {

   172 	struct yum_context *ctx = data;

   173 	const char *n, *version;

   174 	int i;

   175 

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

   177 		ctx->state = YUM_STATE_PACKAGE_NAME;

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

   179 		version = NULL;

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

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

   182 				version = atts[i + 1];

   183 		}

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

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

   186 		ctx->state = YUM_STATE_REQUIRES;

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

   188 		ctx->state = YUM_STATE_PROVIDES;

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

   190 		   ctx->state != YUM_STATE_BEGIN) {

   191 		n = NULL;

   192 		version = NULL;

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

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

   195 				n = atts[i + 1];

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

   197 				version = atts[i + 1];

   198 		}

   199 

   200 		if (n == NULL) {

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

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

   203 			return;

   204 		}

   205 

   206 		switch (ctx->state) {

   207 		case YUM_STATE_REQUIRES:

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

   209 			break;

   210 		case YUM_STATE_PROVIDES:

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

   212 			break;

   213 		}

   214 

   215 	}

   216 }

   217 

   218 static void

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

   220 {

   221 	struct yum_context *ctx = data;

   222 

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

   224 		free(ctx->name);

   225 		razor_importer_finish_package(ctx->importer);

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

   227 		ctx->state = YUM_STATE_BEGIN;

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

   229 		ctx->state = YUM_STATE_BEGIN;

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

   231 		ctx->state = YUM_STATE_BEGIN;

   232 	}

   233 }

   234 

   235 static void

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

   237 {

   238 	struct yum_context *ctx = data;

   239 

   240 	if (ctx->state == YUM_STATE_PACKAGE_NAME)

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

   242 }

   243 

   244 struct razor_set *

   245 razor_set_create_from_yum_filelist(int fd)

   246 {

   247 	struct yum_context ctx;

   248 	XML_Parser parser;

   249 	char buf[4096];

   250 	int len;

   251 

   252 	ctx.importer = razor_importer_new();	

   253 

   254 	parser = XML_ParserCreate(NULL);

   255 	XML_SetUserData(parser, &ctx);

   256 	XML_SetElementHandler(parser, yum_start_element, yum_end_element);

   257 	XML_SetCharacterDataHandler(parser, yum_character_data);

   258 

   259 	while (1) {

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

   261 		if (len < 0) {

   262 			fprintf(stderr,

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

   264 			return NULL;

   265 		} else if (len == 0)

   266 			break;

   267 

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

   269 			fprintf(stderr,

   270 				"%s at line %d\n",

   271 				XML_ErrorString(XML_GetErrorCode(parser)),

   272 				XML_GetCurrentLineNumber(parser));

   273 			return NULL;

   274 		}

   275 	}

   276 

   277 	XML_ParserFree(parser);

   278 

   279 	return razor_importer_finish(ctx.importer);

   280 }

   281 

   282 union rpm_entry {

   283 	void *p;

   284 	char *string;

   285 	char **list;

   286 	unsigned int *flags;

   287 };

   288 

   289 struct razor_set *

   290 razor_set_create_from_rpmdb(void)

   291 {

   292 	struct razor_importer *importer;

   293 	rpmdbMatchIterator iter;

   294 	Header h;

   295 	int_32 type, count, i;

   296 	union rpm_entry name, version, release;

   297 	union rpm_entry property_names, property_versions, property_flags;

   298 	rpmdb db;

   299 

   300 	rpmReadConfigFiles(NULL, NULL);

   301 

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

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

   304 		exit(1);

   305 	}

   306 

   307 	importer = razor_importer_new();

   308 

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

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

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

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

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

   314 		razor_importer_begin_package(importer,

   315 					     name.string, version.string);

   316 

   317 		headerGetEntry(h, RPMTAG_REQUIRENAME, &type,

   318 			       &property_names.p, &count);

   319 		headerGetEntry(h, RPMTAG_REQUIREVERSION, &type,

   320 			       &property_versions.p, &count);

   321 		headerGetEntry(h, RPMTAG_REQUIREFLAGS, &type,

   322 			       &property_flags.p, &count);

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

   324 			razor_importer_add_requires(importer,

   325 						    property_names.list[i],

   326 						    property_versions.list[i]);

   327 

   328 		headerGetEntry(h, RPMTAG_PROVIDENAME, &type,

   329 			       &property_names.p, &count);

   330 		headerGetEntry(h, RPMTAG_PROVIDEVERSION, &type,

   331 			       &property_versions.p, &count);

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

   333 			razor_importer_add_provides(importer,

   334 						    property_names.list[i],

   335 						    property_versions.list[i]);

   336 

   337 		razor_importer_finish_package(importer);

   338 	}

   339 

   340 	rpmdbClose(db);

   341 

   342 	return razor_importer_finish(importer);

   343 }
razor