573fad5 SQLite, round 2. — HardenedBSD-pkg

modified libpkg/pkg.c

@@ -1,9 +1,13 @@

 #include <sys/param.h>
 #include <assert.h>
 #include <err.h>
 #include <stdlib.h>
 #include <strings.h>
 #include "pkg.h"
 #include "pkg_private.h"
 #include "pkg_manifest.h"
 #include "pkgdb.h"
 const char *
 pkg_name(struct pkg *pkg)

@@ -39,16 +43,23 @@ int

 pkg_rdep(struct pkg *pkg, struct pkg *rdep)
 {
 	pkg_reset(rdep);
 	(void)pkg;
 	return (-1);
 	return (pkgdb_query_rdep(pkg, rdep));
 }
 int
 pkg_dep(struct pkg *pkg, struct pkg *dep)
 {
 	pkg_reset(dep);
 	(void)pkg;
 	return (-1);
 	return (pkgdb_query_dep(pkg, dep));
 }
 int
 pkg_new(struct pkg **pkg)
 {
 	if ((*pkg = malloc(sizeof(struct pkg))) == NULL)
 		err(EXIT_FAILURE, "malloc()");
 	bzero(*pkg, sizeof(struct pkg));
 	return (0);
 }
 void

@@ -60,7 +71,29 @@ pkg_reset(struct pkg *pkg)

 	pkg->comment = NULL;
 	pkg->desc = NULL;
 	pkg->pdb = NULL;
 	pkg->m = NULL;
 	if (pkg->deps_stmt != NULL) {
 		sqlite3_finalize(pkg->deps_stmt);
 		pkg->deps_stmt = NULL;
 	}
 	if (pkg->rdeps_stmt != NULL) {
 		sqlite3_finalize(pkg->rdeps_stmt);
 		pkg->rdeps_stmt = NULL;
 	}
 	if (pkg->which_stmt != NULL) {
 		sqlite3_finalize(pkg->which_stmt);
 		pkg->which_stmt = NULL;
 	}
 	if (pkg->m != NULL) {
 		pkg_manifest_free(pkg->m);
 		pkg->m = NULL;
 	}
 }
 void
 pkg_free(struct pkg *pkg)
 {
 	pkg_reset(pkg);
 	free(pkg);
 }
 void

modified libpkg/pkg.h

@@ -2,9 +2,9 @@

 #define _PKG_H
 #include <stdint.h>
 #include <stdio.h> /* for size_t */
 struct pkg_manifest;
 struct pkg;
 struct pkgdb;
 typedef enum _match_t {
 	MATCH_ALL,

@@ -14,18 +14,9 @@ typedef enum _match_t {

 	MATCH_EREGEX
 } match_t;
 struct pkg {
 	const char *name;
 	const char *version;
 	const char *origin;
 	const char *comment;
 	const char *desc;
 	struct pkgdb *pdb;
 	struct pkg_manifest *m;
 };
 void pkg_from_manifest(struct pkg*, struct pkg_manifest *);
 int pkg_new(struct pkg **);
 void pkg_reset(struct pkg *);
 void pkg_free(struct pkg *);
 const char *pkg_name(struct pkg *);
 const char *pkg_version(struct pkg *);
 const char *pkg_comment(struct pkg *);

@@ -44,7 +35,6 @@ void pkgdb_query_free(struct pkgdb *);

 int pkgdb_query_which(struct pkgdb *, const char *, struct pkg *);
 const char *pkgdb_get_dir(void);
 int pkgdb_lock(struct pkgdb *, int);
 void pkgdb_warn(struct pkgdb *);
 int pkgdb_errnum(struct pkgdb *);

modified libpkg/pkg_create.c

@@ -11,6 +11,7 @@

 #include <fcntl.h>
 #include "pkg.h"
 #include "pkg_private.h"
 #include "pkg_manifest.h"
 #include "pkgdb.h"
 #include "util.h"

added libpkg/pkg_private.h

@@ -0,0 +1,23 @@

 #ifndef _PKG_PRIVATE_H
 #define _PKG_PRIVATE_H
 #include <sqlite3.h>
 #include "pkg_manifest.h"
 struct pkg {
         const char *name;
         const char *version;
         const char *origin;
         const char *comment;
         const char *desc;
         struct pkgdb *pdb;
 	sqlite3_stmt *deps_stmt;
 	sqlite3_stmt *rdeps_stmt;
 	sqlite3_stmt *which_stmt;
         struct pkg_manifest *m;
 };
 void pkg_from_manifest(struct pkg*, struct pkg_manifest *);
 #endif

modified libpkg/pkgdb.c

@@ -4,18 +4,16 @@

 #include <err.h>
 #include <errno.h>
 #include <assert.h>
 #include <fcntl.h>
 #include <fnmatch.h>
 #include <stdlib.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <string.h>
 #include <unistd.h>
 #include <regex.h>
 #include <sqlite3.h>
 #include "pkg.h"
 #include "pkg_private.h"
 #include "pkgdb.h"
 #ifdef DEBUG

@@ -40,29 +38,6 @@ pkgdb_get_dir(void)

 	return pkg_dbdir;
 }
 /* Acquire/Release a lock to access the database. */
 int
 pkgdb_lock(struct pkgdb *db, int flags)
 {
 	char fname[MAXPATHLEN];
 	if (db->lock_fd == -1) {
 		snprintf(fname, sizeof(fname), "%s/%s", pkgdb_get_dir(), PKGDB_LOCK);
 		if ((db->lock_fd = open(fname, O_RDONLY | O_CREAT, S_IRUSR | S_IRGRP | S_IROTH)) < 0) {
 			pkgdb_set_error(db, errno, "open(%s)", fname);
 			return (-1);
 		}
 	}
 	if (flock(db->lock_fd, flags) < 0) {
 		pkgdb_set_error(db, errno, "unable to acquire lock on %s", fname);
 		return (-1);
 	}
 	return (0);
 }
 static void
 pkgdb_init(sqlite3 *sdb)
 {

@@ -213,12 +188,6 @@ pkgdb_open(struct pkgdb **db)

 void
 pkgdb_close(struct pkgdb *db)
 {
 	/* TODO: useful? */
 	if (db->lock_fd != -1) {
 		pkgdb_lock(db, LOCK_UN);
 		close(db->lock_fd);
 	}
 	sqlite3_close(db->sqlite);
 	free(db);
 }

@@ -279,8 +248,10 @@ pkgdb_query(struct pkgdb *db, struct pkg *pkg)

 	if (retcode == SQLITE_ROW) {
 		pkgdb_stmt_to_pkg(db->stmt, pkg);
 		pkg->pdb = db;
 		return (0);
 	} else if (retcode == SQLITE_DONE) {
 		sqlite3_reset(db->stmt);
 		return (1);
 	} else {
 		pkgdb_set_error(db, 0, "sqlite3_step(): %s", sqlite3_errmsg(db->sqlite));

@@ -291,24 +262,74 @@ pkgdb_query(struct pkgdb *db, struct pkg *pkg)

 int
 pkgdb_query_which(struct pkgdb *db, const char *path, struct pkg *pkg)
 {
 	sqlite3_stmt *stmt;
 	int retcode;
 	pkg_reset(pkg);
 	sqlite3_prepare(db->sqlite,
 					"SELECT origin, name, version, comment, desc FROM packages, files "
 					"WHERE origin = files.package_id "
 					"AND files.path = ?1;", -1, &stmt, NULL);
 	sqlite3_bind_text(stmt, 1, path, -1, SQLITE_STATIC);
 					"AND files.path = ?1;", -1, &pkg->which_stmt, NULL);
 	sqlite3_bind_text(pkg->which_stmt, 1, path, -1, SQLITE_STATIC);
 	pkg_reset(pkg);
 	retcode = sqlite3_step(stmt);
 	if (retcode == SQLITE_ROW)
 		pkgdb_stmt_to_pkg(stmt, pkg);
 	retcode = sqlite3_step(pkg->which_stmt);
 	if (retcode == SQLITE_ROW) {
 		pkgdb_stmt_to_pkg(pkg->which_stmt, pkg);
 		pkg->pdb = db;
 	}
 	/*sqlite3_finalize(stmt);*/
 	return ((retcode == SQLITE_ROW) ? 0 : 1);
 }
 int
 pkgdb_query_dep(struct pkg *pkg, struct pkg *dep) {
 	int retcode;
 	if (pkg->deps_stmt == NULL) {
 		sqlite3_prepare(pkg->pdb->sqlite,
 						"SELECT p.origin, p.name, p.version, p.comment, p.desc FROM packages AS p, deps AS d "
 						"WHERE p.origin = d.origin "
 						"AND d.package_id = ?1;", -1, &pkg->deps_stmt, NULL);
 		sqlite3_bind_text(pkg->deps_stmt, 1, pkg->origin, -1, SQLITE_STATIC);
 	}
 	retcode = sqlite3_step(pkg->deps_stmt);
 	if (retcode == SQLITE_ROW) {
 		pkgdb_stmt_to_pkg(pkg->deps_stmt, dep);
 		dep->pdb = pkg->pdb;
 		return (0);
 	} else if (retcode == SQLITE_DONE) {
 		sqlite3_reset(pkg->deps_stmt);
 		return (1);
 	} else {
 		return (-1);
 	}
 }
 int
 pkgdb_query_rdep(struct pkg *pkg, struct pkg *rdep) {
 	int retcode;
 	if (pkg->rdeps_stmt == NULL) {
 		sqlite3_prepare(pkg->pdb->sqlite,
 						"SELECT p.origin, p.name, p.version, p.comment, p.desc FROM packages AS p, deps AS d "
 						"WHERE p.origin = d.package_id "
 						"AND d.origin = ?1;", -1, &pkg->rdeps_stmt, NULL);
 		sqlite3_bind_text(pkg->rdeps_stmt, 1, pkg->origin, -1, SQLITE_STATIC);
 	}
 	retcode = sqlite3_step(pkg->rdeps_stmt);
 	if (retcode == SQLITE_ROW) {
 		pkgdb_stmt_to_pkg(pkg->rdeps_stmt, rdep);
 		rdep->pdb = pkg->pdb;
 		return (0);
 	} else if (retcode == SQLITE_DONE) {
 		sqlite3_reset(pkg->rdeps_stmt);
 		return (1);
 	} else {
 		return (-1);
 	}
 }
 static void
 pkgdb_stmt_to_pkg(sqlite3_stmt *stmt, struct pkg *pkg)
 {

modified libpkg/pkgdb.h

@@ -10,11 +10,12 @@ struct pkgdb {

         sqlite3 *sqlite;
 	sqlite3_stmt *stmt;
         int lock_fd;
         size_t i; /* iterator */
         int errnum;
         char errstring[BUFSIZ]; /* not enough ? */
         char errstring[1024];
 };
 int pkgdb_query_dep(struct pkg *, struct pkg *);
 int pkgdb_query_rdep(struct pkg *, struct pkg *);
 void pkgdb_set_error(struct pkgdb *, int, const char *, ...);
 #endif

modified pkg/create.c

@@ -21,7 +21,7 @@ int

 cmd_create(int argc, char **argv)
 {
 	struct pkgdb *db;
 	struct pkg pkg;
 	struct pkg *pkg;
 	match_t match = MATCH_EXACT;
 	const char *outdir = NULL;

@@ -103,10 +103,12 @@ cmd_create(int argc, char **argv)

 			return (-1);
 		}
 		while (pkgdb_query(db, &pkg) == 0) {
 			snprintf(mpath, sizeof(mpath), "%s/%s-%s/+MANIFEST", pkgdb_get_dir(), pkg_name(&pkg), pkg_version(&pkg));
 			pkg_create(mpath, fmt, outdir, rootdir, &pkg);
 		pkg_new(&pkg);
 		while (pkgdb_query(db, pkg) == 0) {
 			snprintf(mpath, sizeof(mpath), "%s/%s-%s/+MANIFEST", pkgdb_get_dir(), pkg_name(pkg), pkg_version(pkg));
 			pkg_create(mpath, fmt, outdir, rootdir, pkg);
 		}
 		pkg_free(pkg);
 		pkgdb_query_free(db);
 		pkgdb_close(db);
 	} else {

modified pkg/info.c

@@ -18,7 +18,8 @@ int

 cmd_info(int argc, char **argv)
 {
 	struct pkgdb *db;
 	struct pkg pkg, dep;
 	struct pkg *pkg;
 	struct pkg *dep;
 	unsigned char opt = 0;
 	match_t match = MATCH_EXACT;
 	char ch;

@@ -63,30 +64,36 @@ cmd_info(int argc, char **argv)

 		return (-1);
 	}
 	while (pkgdb_query(db, &pkg) == 0) {
 	pkg_new(&pkg);
 	pkg_new(&dep);
 	while (pkgdb_query(db, pkg) == 0) {
 		if (opt & INFO_EXISTS) {
 			retcode = 0;
 		} else if (opt & INFO_PRINT_DEP) {
 			printf("%s-%s depends on:\n", pkg_name(&pkg), pkg_version(&pkg));
 			printf("%s-%s depends on:\n", pkg_name(pkg), pkg_version(pkg));
 			while (pkg_dep(&pkg, &dep) == 0) {
 				printf("%s-%s\n", pkg_name(&dep), pkg_version(&pkg));
 			while (pkg_dep(pkg, dep) == 0) {
 				printf("%s-%s\n", pkg_name(dep), pkg_version(pkg));
 			}
 			printf("\n");
 		} else if (opt & INFO_PRINT_RDEP) {
 			printf("%s-%s is required by:\n", pkg_name(&pkg), pkg_version(&pkg));
 			while (pkg_rdep(&pkg, &dep) == 0) {
 				printf("%s-%s\n", pkg_name(&dep), pkg_version(&dep));
 			printf("%s-%s is required by:\n", pkg_name(pkg), pkg_version(pkg));
 			while (pkg_rdep(pkg, dep) == 0) {
 				printf("%s-%s\n", pkg_name(dep), pkg_version(dep));
 			}
 			printf("\n");
 		} else {
 			printf("%s-%s: %s\n", pkg_name(&pkg), pkg_version(&pkg), pkg_comment(&pkg));
 			printf("%s-%s: %s\n", pkg_name(pkg), pkg_version(pkg), pkg_comment(pkg));
 		}
 	}
 	if (pkgdb_errnum(db) > -1) {
 	pkg_free(pkg);
 	pkg_free(dep);
 	if (pkgdb_errnum(db) > 0) {
 		pkgdb_warn(db);
 		retcode = -1;
 	}

modified pkg/which.c

@@ -14,7 +14,7 @@ int

 cmd_which(int argc, char **argv)
 {
 	struct pkgdb *db;
 	struct pkg pkg;
 	struct pkg *pkg;
 	char pathabs[MAXPATHLEN];
 	char pathabsdir[MAXPATHLEN];
 	int retcode = 1;

@@ -35,11 +35,13 @@ cmd_which(int argc, char **argv)

 	realpath(dirname(argv[0]), pathabsdir);
 	snprintf(pathabs, sizeof(pathabs), "%s/%s", pathabsdir, basename(argv[0]));
 	if (pkgdb_query_which(db, pathabs, &pkg) == 0) {
 	pkg_new(&pkg);
 	if (pkgdb_query_which(db, pathabs, pkg) == 0) {
 		retcode = 0;
 		printf("%s was installed by package %s-%s\n", pathabs, pkg_name(&pkg),
 			   pkg_version(&pkg));
 		printf("%s was installed by package %s-%s\n", pathabs, pkg_name(pkg),
 			   pkg_version(pkg));
 	}
 	pkg_free(pkg);
 	pkgdb_close(db);
 	return (retcode);