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 28 22:50:57 2007 -0400 (2007-10-28)
changeset 65 8fec3db93757
parent 59 c525dec02ef4
child 66 bb4ca4a47f66
permissions -rw-r--r--
Trim TODO, start tracking what's needed for 0.1 (replace rpm+yum). 
     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[256], buffer[512], *p;

   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, *release;

   175 	char buffer[128];

   176 	int i;

   177 

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

   179 		ctx->state = YUM_STATE_PACKAGE_NAME;

   180 		ctx->p = ctx->name;

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

   182 		version = NULL;

   183 		release = NULL;

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

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

   186 				version = atts[i + 1];

   187 			else if (strcmp(atts[i], "rel") == 0)

   188 				release = atts[i + 1];

   189 		}

   190 		if (version == NULL || release == NULL) {

   191 			fprintf(stderr, "invalid version tag, "

   192 				"missing version or  release attribute\n");

   193 			return;

   194 		}

   195 

   196 		snprintf(buffer, sizeof buffer, "%s-%s", version, release);

   197 		razor_importer_begin_package(ctx->importer, ctx->name, buffer);

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

   199 		ctx->state = YUM_STATE_REQUIRES;

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

   201 		ctx->state = YUM_STATE_PROVIDES;

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

   203 		   ctx->state != YUM_STATE_BEGIN) {

   204 		n = NULL;

   205 		version = NULL;

   206 		release = NULL;

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

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

   209 				n = atts[i + 1];

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

   211 				version = atts[i + 1];

   212 			else if (strcmp(atts[i], "rel") == 0)

   213 				release = atts[i + 1];

   214 		}

   215 

   216 		if (n == NULL) {

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

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

   219 			return;

   220 		}

   221 

   222 		if (version && release)

   223 			snprintf(buffer, sizeof buffer,

   224 				 "%s-%s", version, release);

   225 		else if (version)

   226 			strcpy(buffer, version);

   227 		else

   228 			buffer[0] = '\0';

   229 			

   230 		switch (ctx->state) {

   231 		case YUM_STATE_REQUIRES:

   232 			razor_importer_add_requires(ctx->importer, n, buffer);

   233 			break;

   234 		case YUM_STATE_PROVIDES:

   235 			razor_importer_add_provides(ctx->importer, n, buffer);

   236 			break;

   237 		}

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

   239 		ctx->state = YUM_STATE_FILE;

   240 		ctx->p = ctx->buffer;

   241 	}

   242 }

   243 

   244 static void

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

   246 {

   247 	struct yum_context *ctx = data;

   248 

   249 	ctx->state = YUM_STATE_BEGIN;

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

   251 		razor_importer_finish_package(ctx->importer);

   252 	else if (strcmp(name, "file") == 0)

   253 		razor_importer_add_file(ctx->importer, ctx->buffer);

   254 }

   255 

   256 static void

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

   258 {

   259 	struct yum_context *ctx = data;

   260 

   261 	switch (ctx->state) {

   262 	case YUM_STATE_PACKAGE_NAME:

   263 	case YUM_STATE_FILE:

   264 		memcpy(ctx->p, s, len);

   265 		ctx->p += len;

   266 		*ctx->p = '\0';

   267 		break;

   268 	}

   269 }

   270 

   271 struct razor_set *

   272 razor_set_create_from_yum_filelist(int fd)

   273 {

   274 	struct yum_context ctx;

   275 	XML_Parser parser;

   276 	char buf[4096];

   277 	int len;

   278 

   279 	ctx.importer = razor_importer_new();	

   280 	ctx.state = YUM_STATE_BEGIN;

   281 

   282 	parser = XML_ParserCreate(NULL);

   283 	XML_SetUserData(parser, &ctx);

   284 	XML_SetElementHandler(parser, yum_start_element, yum_end_element);

   285 	XML_SetCharacterDataHandler(parser, yum_character_data);

   286 

   287 	while (1) {

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

   289 		if (len < 0) {

   290 			fprintf(stderr,

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

   292 			return NULL;

   293 		} else if (len == 0)

   294 			break;

   295 

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

   297 			fprintf(stderr,

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

   299 				XML_ErrorString(XML_GetErrorCode(parser)),

   300 				XML_GetCurrentLineNumber(parser));

   301 			return NULL;

   302 		}

   303 	}

   304 

   305 	XML_ParserFree(parser);

   306 

   307 	return razor_importer_finish(ctx.importer);

   308 }

   309 

   310 union rpm_entry {

   311 	void *p;

   312 	char *string;

   313 	char **list;

   314 	unsigned int *flags;

   315 };

   316 

   317 struct razor_set *

   318 razor_set_create_from_rpmdb(void)

   319 {

   320 	struct razor_importer *importer;

   321 	rpmdbMatchIterator iter;

   322 	Header h;

   323 	int_32 type, count, i;

   324 	union rpm_entry name, version, release;

   325 	union rpm_entry property_names, property_versions, property_flags;

   326 	union rpm_entry basenames, dirnames, dirindexes;

   327 	char filename[PATH_MAX];

   328 	rpmdb db;

   329 

   330 	rpmReadConfigFiles(NULL, NULL);

   331 

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

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

   334 		exit(1);

   335 	}

   336 

   337 	importer = razor_importer_new();

   338 

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

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

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

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

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

   344 		snprintf(filename, sizeof filename, "%s-%s",

   345 			 version.string, release.string);

   346 		razor_importer_begin_package(importer, name.string, filename);

   347 

   348 		headerGetEntry(h, RPMTAG_REQUIRENAME, &type,

   349 			       &property_names.p, &count);

   350 		headerGetEntry(h, RPMTAG_REQUIREVERSION, &type,

   351 			       &property_versions.p, &count);

   352 		headerGetEntry(h, RPMTAG_REQUIREFLAGS, &type,

   353 			       &property_flags.p, &count);

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

   355 			razor_importer_add_requires(importer,

   356 						    property_names.list[i],

   357 						    property_versions.list[i]);

   358 

   359 		headerGetEntry(h, RPMTAG_PROVIDENAME, &type,

   360 			       &property_names.p, &count);

   361 		headerGetEntry(h, RPMTAG_PROVIDEVERSION, &type,

   362 			       &property_versions.p, &count);

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

   364 			razor_importer_add_provides(importer,

   365 						    property_names.list[i],

   366 						    property_versions.list[i]);

   367 

   368 		headerGetEntry(h, RPMTAG_BASENAMES, &type,

   369 			       &basenames.p, &count);

   370 		headerGetEntry(h, RPMTAG_DIRNAMES, &type,

   371 			       &dirnames.p, &count);

   372 		headerGetEntry(h, RPMTAG_DIRINDEXES, &type,

   373 			       &dirindexes.p, &count);

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

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

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

   377 				 basenames.list[i]);

   378 			razor_importer_add_file(importer, filename);

   379 		}

   380 

   381 		razor_importer_finish_package(importer);

   382 	}

   383 

   384 	rpmdbClose(db);

   385 

   386 	return razor_importer_finish(importer);

   387 }
razor