f02c58a Merge branch 'master' of etoilebsd.net:pkgng — HardenedBSD-pkg

modified libpkg/pkg_create.c

@@ -125,7 +125,12 @@ pkg_create(char *pkgname, pkg_formats format, const char *outdir, const char *ro

 	pkg_dbdir = pkgdb_get_dir();
 	if (pkgdb_init(&db, pkgname, MATCH_EXACT) == -1) {
 	if (pkgdb_open(&db) == -1) {
 		pkgdb_warn(&db);
 		return (-1);
 	}
 	if (pkgdb_query_init(&db, pkgname, MATCH_EXACT) == -1) {
 		pkgdb_warn(&db);
 		return (-1);
 	}

@@ -134,9 +139,10 @@ pkg_create(char *pkgname, pkg_formats format, const char *outdir, const char *ro

 		if (db.errnum > -1)
 			pkgdb_warn(&db);
 		warnx("%s: no such package", pkgname);
 		pkgdb_free(&db);
 		pkgdb_query_free(&db);
 		return (-1);
 	}
 	pkgdb_query_free(&db);
 	pkg_archive = archive_write_new();

@@ -157,7 +163,7 @@ pkg_create(char *pkgname, pkg_formats format, const char *outdir, const char *ro

 	archive_write_close(pkg_archive);
 	archive_write_finish(pkg_archive);
 	pkgdb_free(&db);
 	pkgdb_close(&db);
 	return (0);
 }

modified libpkg/pkgdb.c

@@ -68,13 +68,40 @@ pkgdb_match(struct pkgdb *db, const char *pattern)

 }
 int
 pkgdb_init(struct pkgdb *db, const char *pattern, match_t match)
 pkgdb_open(struct pkgdb *db)
 {
 	return (pkgdb_open2(db, true));
 }
 int
 pkgdb_open2(struct pkgdb *db, bool rebuild)
 {
 	db->cdb = NULL;
 	db->lock_fd = -1;
 	db->errnum = -1;
 	db->errstring[0] = '\0';
 	return (pkgdb_cache_open(db, rebuild));
 }
 void
 pkgdb_close(struct pkgdb *db)
 {
 	if (db->lock_fd != -1) {
 		pkgdb_lock(db, LOCK_UN);
 		close(db->lock_fd);
 	}
 	/* call backend close */
 	pkgdb_cache_close(db);
 }
 int
 pkgdb_query_init(struct pkgdb *db, const char *pattern, match_t match)
 {
 	db->pattern = pattern;
 	db->match = match;
 	db->i = 0;
 	db->lock_fd = -1;
 	db->errnum = -1;
 	if (match != MATCH_ALL && pattern == NULL) {
 		pkgdb_set_error(db, 0, "missing pattern");

@@ -94,29 +121,22 @@ pkgdb_init(struct pkgdb *db, const char *pattern, match_t match)

 		}
 	}
 	/* call backend init */
 	return (pkgdb_cache_init(db));
 	return (0);
 }
 void
 pkgdb_free(struct pkgdb *db)
 pkgdb_query_free(struct pkgdb *db)
 {
 	if (db->match == MATCH_REGEX || db->match == MATCH_EREGEX)
 		regfree(&db->re);
 	if (db->lock_fd != -1)
 		close(db->lock_fd);
 	/* call backend free */
 	pkgdb_cache_free(db);
 	return;
 	db->match = -1;
 }
 int
 pkgdb_query(struct pkgdb *db, struct pkg *pkg)
 {
 	pkg_reset(pkg);
 	/* call backend query */
 	return (pkgdb_cache_query(db, pkg));
 }

@@ -131,14 +151,12 @@ pkgdb_set_error(struct pkgdb *db, int errnum, const char *fmt, ...)

 	va_end(args);
 	db->errnum = errnum;
 	return;
 }
 void
 pkgdb_warn(struct pkgdb *db)
 {
 	warnx("%s %s", db->errstring, (db->errnum > 0) ? strerror(db->errnum) : "");
 	return;
 }
 int

modified libpkg/pkgdb.h

@@ -1,12 +1,18 @@

 #ifndef _PKGDB_H
 #define _PKGDB_H
 #include <stdbool.h>
 #include <pkg.h>
 int pkgdb_open(struct pkgdb *);
 int pkgdb_open2(struct pkgdb *, bool);
 void pkgdb_close(struct pkgdb *);
 /* query */
 int pkgdb_init(struct pkgdb *, const char *, match_t);
 int pkgdb_query_init(struct pkgdb *, const char *, match_t);
 int pkgdb_query(struct pkgdb *, struct pkg *);
 void pkgdb_free(struct pkgdb *);
 void pkgdb_query_free(struct pkgdb *);
 /* misc */
 const char *pkgdb_get_dir(void);

modified libpkg/pkgdb_cache.c

@@ -6,9 +6,10 @@

 #include <errno.h>
 #include <fcntl.h>
 #include <inttypes.h>
 #include <stdarg.h>
 #include <stdbool.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdarg.h>
 #include <unistd.h>
 #include <cdb.h>

@@ -191,16 +192,20 @@ pkgdb_cache_rdep(struct pkg *pkg, struct pkg *rdep) {

 }
 static int
 pkgdb_cache_rebuild(struct pkgdb *db, const char *pkg_dbdir, const char *cache_path)
 pkgdb_cache_rebuild(struct pkgdb *db, const char *pkg_dbdir,
 					const char *cache_path, time_t cache_mtime)
 {
 	int fd;
 	char tmppath[MAXPATHLEN];
 	char mpath[MAXPATHLEN];
 	char *hyphen;
 	struct dirent **pkg_dirs;
 	struct pkgdb old_db;
 	struct stat m_st;
 	struct cdb_make cdb;
 	struct pkg pkg;
 	struct pkg dep;
 	struct pkg_manifest *m;
 	struct pkg_manifest *m = NULL;
 	int32_t nb_pkg;
 	int32_t idx;
 	int32_t idep;

@@ -221,20 +226,51 @@ pkgdb_cache_rebuild(struct pkgdb *db, const char *pkg_dbdir, const char *cache_p

 		return (-1);
 	}
 	/* If we have an old db, open it now */
 	if (cache_mtime > 0 && pkgdb_open2(&old_db, false) == -1)
 		errx(EXIT_FAILURE, "can not open old db");
 	cdb_make_start(&cdb, fd);
 	for (idx = 0; idx < nb_pkg; idx++) {
 		snprintf(mpath, sizeof(mpath), "%s/%s/+MANIFEST", pkg_dbdir,
 				 pkg_dirs[idx]->d_name);
 		if ((m = pkg_manifest_load_file(mpath)) == NULL) {
 			if ((m = pkg_compat_convert_installed(pkg_dbdir, pkg_dirs[idx]->d_name,
 				 mpath)) == NULL) {
 				warnx("error while inserting %s in cache, skipping", mpath);
 		if (stat(mpath, &m_st) == -1) {
 			if (errno == ENOENT)
 				m_st.st_mtime = -1;
 			else {
 				pkgdb_set_error(db, errno, "stat(%s)", mpath);
 				return (-1);
 			}
 		}
 		/* Check if the data in the old cache is up-to-date */
 		if (cache_mtime > 0 && m_st.st_mtime > 0 && m_st.st_mtime < cache_mtime) {
 			/* Remove the version */
 			hyphen = strrchr(pkg_dirs[idx]->d_name, '-');
 			hyphen[0] = '\0';
 			pkgdb_query_init(&old_db, pkg_dirs[idx]->d_name, MATCH_EXACT);
 			if (pkgdb_query(&old_db, &pkg) != 0)
 				errx(EXIT_FAILURE, "%s not in cache, why?", pkg_dirs[idx]->d_name);
 			pkgdb_query_free(&old_db);
 		} else {
 			/* The +MANIFEST file exists, load it */
 			if (m_st.st_mtime != -1 && (m = pkg_manifest_load_file(mpath)) == NULL) {
 				warnx("skipping %s", mpath);
 				continue;
 			}
 			/* Create the +MANIFEST file via +CONTENTS */
 			if (m_st.st_mtime == -1) {
 				m = pkg_compat_convert_installed(pkg_dbdir, pkg_dirs[idx]->d_name, mpath);
 				if (m == NULL) {
 					warnx("error while converting +CONTENTS to %s, skipping", mpath);
 					continue;
 				}
 			}
 			pkg_from_manifest(&pkg, m);
 		}
 		pkg_from_manifest(&pkg, m);
 		pkgdb_cache_add_int(&cdb, pkg_name(&pkg), idx);

@@ -250,11 +286,17 @@ pkgdb_cache_rebuild(struct pkgdb *db, const char *pkg_dbdir, const char *cache_p

 			idep++;
 		}
 		pkg_manifest_free(m);
 		if (m != NULL) {
 			pkg_manifest_free(m);
 			m = NULL;
 		}
 		free(pkg_dirs[idx]);
 	}
 	free(pkg_dirs);
 	if (cache_mtime > 0)
 		pkgdb_close(&old_db);
 	/* record packages len */
 	cdb_make_add(&cdb, PKGDB_COUNT, strlen(PKGDB_COUNT), &nb_pkg, sizeof(int32_t));
 	cdb_make_finish(&cdb);

@@ -294,7 +336,8 @@ pkgdb_cache_update(struct pkgdb *db)

 		* +CONTENTS to +MANIFEST format.
 		*/
 		pkgdb_lock(db, LOCK_EX);
 		ret = pkgdb_cache_rebuild(db, pkg_dbdir, cache_path);
 		ret = pkgdb_cache_rebuild(db, pkg_dbdir, cache_path,
 								  (errno != ENOENT) ? cache_st.st_mtime : -1);
 	}
 	pkgdb_lock(db, LOCK_UN);

@@ -302,12 +345,12 @@ pkgdb_cache_update(struct pkgdb *db)

 }
 int
 pkgdb_cache_init(struct pkgdb *db)
 pkgdb_cache_open(struct pkgdb *db, bool rebuild)
 {
 	char path[MAXPATHLEN];
 	int fd;
 	if (pkgdb_cache_update(db) == -1)
 	if (rebuild == true && pkgdb_cache_update(db) == -1)
 		return (-1);
 	if ((db->cdb = malloc(sizeof(struct cdb))) == NULL)

@@ -331,7 +374,7 @@ pkgdb_cache_init(struct pkgdb *db)

 }
 void
 pkgdb_cache_free(struct pkgdb *db)
 pkgdb_cache_close(struct pkgdb *db)
 {
 	close(cdb_fileno(db->cdb));
 	cdb_free(db->cdb);

modified libpkg/pkgdb_cache.h

@@ -1,18 +1,20 @@

 #ifndef _PKGDB_CACHE_H
 #define _PKGDB_CACHE_H
 #include <stdbool.h>
 #include <cdb.h>
 #include "pkgdb.h"
 /* query */
 int pkgdb_cache_open(struct pkgdb *, bool);
 void pkgdb_cache_close(struct pkgdb *);
 int pkgdb_cache_query(struct pkgdb *, struct pkg *);
 /* getter */
 const char *pkgdb_cache_getattr(struct pkg *, const char *);
 /* query */
 int pkgdb_cache_init(struct pkgdb *);
 int pkgdb_cache_dep(struct pkg *, struct pkg *);
 int pkgdb_cache_rdep(struct pkg *, struct pkg *);
 int pkgdb_cache_query(struct pkgdb *, struct pkg *);
 void pkgdb_cache_free(struct pkgdb *);
 #endif

modified pkg/info.c

@@ -11,10 +11,8 @@

  * list of options
  * -s: show package size: TODO
  * -S <type> : show scripts, type can be pre-install etc: TODO
  * -r: show reverse dependency list
  * -l: list contents of a package
  * -w <filename>: (which) finds which package the filename belongs to:
  * -e: return 1 if the package exist otherwise 0
  */
 int

@@ -25,10 +23,14 @@ cmd_info(int argc, char **argv)

 	unsigned char opt = 0;
 	match_t match = MATCH_EXACT;
 	char ch;
 	int retcode = 0;
 	/* TODO: exclusive opts ? */
 	while ((ch = getopt(argc, argv, "gxXdr")) != -1) {
 	while ((ch = getopt(argc, argv, "egxXdr")) != -1) {
 		switch (ch) {
 			case 'e':
 				opt |= INFO_EXISTS;
 				retcode = 1;
 			case 'g':
 				match = MATCH_GLOB;
 				break;

@@ -52,13 +54,20 @@ cmd_info(int argc, char **argv)

 	if (argc == 0)
 		match = MATCH_ALL;
 	if (pkgdb_init(&db, argv[0], match) == -1) {
 	if (pkgdb_open(&db) == -1) {
 		pkgdb_warn(&db);
 		return (-1);
 	}
 	if (pkgdb_query_init(&db, argv[0], match) == -1) {
 		pkgdb_warn(&db);
 		return (-1);
 	}
 	while (pkgdb_query(&db, &pkg) == 0) {
 		if (opt & INFO_PRINT_DEP) {
 		if (opt & INFO_EXISTS) {
 			retcode = 0;
 		} else if (opt & INFO_PRINT_DEP) {
 			printf("%s-%s depends on:\n", pkg_name(&pkg), pkg_version(&pkg));

@@ -80,10 +89,10 @@ cmd_info(int argc, char **argv)

 	if (db.errnum > -1) {
 		pkgdb_warn(&db);
 		pkgdb_free(&db);
 		return (-1);
 		retcode = -1;
 	}
 	pkgdb_free(&db);
 	return (0);
 	pkgdb_query_free(&db);
 	pkgdb_close(&db);
 	return (retcode);
 }

modified pkg/info.h

@@ -3,6 +3,7 @@

 #define INFO_PRINT_DEP (1<<0)
 #define INFO_PRINT_RDEP (1<<1)
 #define INFO_EXISTS (1<<2)
 int cmd_info(int argc, char **argv);
 #endif