Radish alpha
H
HardenedBSD-pkg
HardenedBSD Package Manager
Radicle
Git (anonymous pull)
Log in to clone via SSH
Commits ›
Error system for libpkg (not perfect, but here) TODO: be sure to remove ALL err(), exit() from libpkg.
Philippe Pepiot committed 15 years ago
commit d8ab38245ccf7c5408950388b33beec25a0cc235
parent 83d5b51e90e531875375a70be7c375f573904d1f
6 files changed +92 -37
modified libpkg/pkg.c
@@ -142,10 +142,16 @@ pkg_create(char *pkgname, pkg_formats format, const char *outdir, const char *ro


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



	if (pkgdb_query(&db, &pkg) != 0) {
+ 
		if (db.errnum > -1)
+ 
			pkgdb_warn(&db);

		warnx("%s: no such package", pkgname);
+ 
		pkgdb_free(&db);

		return (-1);

	}
modified libpkg/pkg.h
@@ -22,6 +22,8 @@ struct pkgdb {
	const char *pattern;

	match_t match;

	regex_t re;
+ 
	int errnum;
+ 
	char errstring[BUFSIZ]; /* not enough ? */

};



struct pkg {
modified libpkg/pkgdb.c
@@ -3,6 +3,7 @@
#include <sys/file.h>



#include <err.h>
+ 
#include <errno.h>

#include <assert.h>

#include <fcntl.h>

#include <fnmatch.h>
@@ -98,19 +99,26 @@ pkgdb_get_dir(void)
}



/* Acquire/Release a lock to access the database. */
- 
void
+ 
int

pkgdb_lock(struct pkgdb *db, int flags)

{

	char fname[FILENAME_MAX];



	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)
- 
			err(EXIT_FAILURE, "open(%s)", fname);
+
+ 
		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);

	}
- 
	if (flock(db->lock_fd, flags) < 0)
- 
		errx(EXIT_FAILURE, "unable to acquire a lock to the database");
+ 
	return (0);

}



int
@@ -144,19 +152,22 @@ pkgdb_init(struct pkgdb *db, const char *pattern, match_t match)
	db->match = match;

	db->i = 0;

	db->lock_fd = -1;
+ 
	db->errnum = -1;
- 
	if (match != MATCH_ALL && pattern == NULL)
+ 
	if (match != MATCH_ALL && pattern == NULL) {
+ 
		pkgdb_set_error(db, 0, "missing pattern");

		return (-1);
+ 
	}



	/* Regex initialisation */

	if (match == MATCH_REGEX) {

		if (regcomp(&db->re, pattern, REG_BASIC | REG_NOSUB) != 0) {
- 
			warnx("'%s' is not a valid regular expression", pattern);
+ 
			pkgdb_set_error(db, 0, "'%s' is not a valid regular expression", pattern);

			return (-1);

		}

	} else if (match == MATCH_EREGEX) {

		if (regcomp(&db->re, pattern, REG_EXTENDED | REG_NOSUB) != 0) {
- 
			warnx("'%s' is not a valid extended regular expression", pattern);
+ 
			pkgdb_set_error(db, 0, "'%s' is not a valid extended regular expression", pattern);

			return (-1);

		}

	}
@@ -188,3 +199,28 @@ pkgdb_query(struct pkgdb *db, struct pkg *pkg)
	return (pkgdb_cache_query(db, pkg));

}
+ 
void
+ 
pkgdb_set_error(struct pkgdb *db, int errnum, const char *fmt, ...)
+ 
{
+ 
	va_list args;
+
+ 
	va_start(args, fmt);
+ 
	vsnprintf(db->errstring, sizeof(db->errstring), fmt, args);
+ 
	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
+ 
pkgdb_errnum(struct pkgdb *db)
+ 
{
+ 
	return (db->errnum);
+ 
}
modified libpkg/pkgdb.h
@@ -21,6 +21,9 @@ void pkgdb_free(struct pkgdb *);
const char *pkgdb_get_dir(void);

int pkgdb_match(struct pkgdb *, const char *);

void pkg_reset(struct pkg *);
- 
void pkgdb_lock(struct pkgdb *, int);
+ 
int pkgdb_lock(struct pkgdb *, int);
+ 
void pkgdb_set_error(struct pkgdb *, int, const char *, ...);
+ 
void pkgdb_warn(struct pkgdb *);
+ 
int pkgdb_errnum(struct pkgdb *);



#endif
modified libpkg/pkgdb_cache.c
@@ -31,7 +31,7 @@ static const void *pkgdb_cache_vget(struct cdb *, const char *, ...);
static int pkgdb_cache_vadd(struct cdb_make *, const void *, size_t, const char *, va_list);

static int pkgdb_cache_add_string(struct cdb_make *, const char *, const char *, ...);

static int pkgdb_cache_add_int(struct cdb_make *, const char *, size_t);
- 
static void pkgdb_cache_update(struct pkgdb *);
+ 
static int pkgdb_cache_update(struct pkgdb *);



const char *

pkgdb_cache_getattr(struct pkg *pkg, const char *attr)
@@ -47,7 +47,7 @@ pkgdb_cache_getattr(struct pkg *pkg, const char *attr)
		{"version",	PKGDB_VERSION},

		{"comment", PKGDB_COMMENT},

		{"desc",	PKGDB_DESC},
- 
		{"origin",	PKGDB_ORIGIN}
+ 
		{"origin",	PKGDB_ORIGIN},

	};



	len = sizeof(attr_key_map) / sizeof(attr_key_map[0]);
@@ -141,7 +141,7 @@ pkgdb_cache_vget(struct cdb *db, const char *fmt, ...)
		vwarnx(fmt, args);

		va_end(args);

		return NULL;
- 
        }
+ 
	}



	va_end(args);
@@ -170,8 +170,8 @@ pkgdb_cache_dep(struct pkg *pkg, struct pkg *dep)
	return (ret);

}
- 
static void
- 
pkgdb_cache_rebuild(const char *pkg_dbdir, const char *cache_path)
+ 
static int
+ 
pkgdb_cache_rebuild(struct pkgdb *db, const char *pkg_dbdir, const char *cache_path)

{

	int fd;

	char tmppath[MAXPATHLEN];
@@ -187,17 +187,17 @@ pkgdb_cache_rebuild(const char *pkg_dbdir, const char *cache_path)
	warnx("Rebuilding cache...");



	if ((nb_pkg = scandir(pkg_dbdir, &pkg_dirs, select_dir, alphasort)) == -1) {
- 
		warn("scandir(%s)", pkg_dbdir);
- 
		return;
+ 
		pkgdb_set_error(db, errno, "scandir(%s)", pkg_dbdir);
+ 
		return (-1);

	}



	snprintf(tmppath, sizeof(tmppath), "%s/pkgdb.cache-XXXXX", pkg_dbdir);

	if ((fd = mkstemp(tmppath)) == -1) {
- 
		warn("mkstemp(%s)", tmppath);
+ 
		pkgdb_set_error(db, errno, "mkstemp(%s)", tmppath);

		for (idx = 0; idx < nb_pkg; idx++)

			free(pkg_dirs[idx]);

		free(pkg_dirs);
- 
		return;
+ 
		return (-1);

	}



	cdb_make_start(&cdb, fd);
@@ -207,10 +207,9 @@ pkgdb_cache_rebuild(const char *pkg_dbdir, const char *cache_path)
				 pkg_dirs[idx]->d_name);



		if ((m = pkg_manifest_load_file(mpath)) == NULL) {
- 
			warnx("%s not found, converting old +CONTENTS file", mpath);

			if ((m = pkg_compat_convert_installed(pkg_dbdir, pkg_dirs[idx]->d_name,

				 mpath)) == NULL) {
- 
				warnx("error while converting, skipping");
+ 
				warnx("error while inserting %s in cache, skipping", mpath);

				continue;

			}

		}
@@ -248,40 +247,39 @@ pkgdb_cache_rebuild(const char *pkg_dbdir, const char *cache_path)
	close(fd);

	rename(tmppath, cache_path);

	chmod(cache_path, 0644);
+ 
	return (0);

}
- 
static void
+ 
static int

pkgdb_cache_update(struct pkgdb *db)

{

	const char *pkg_dbdir;

	char cache_path[MAXPATHLEN];

	struct stat dir_st, cache_st;
- 
	uid_t uid;
+ 
	int ret = 0;



	pkg_dbdir = pkgdb_get_dir();
- 
	uid = getuid();



	if (stat(pkg_dbdir, &dir_st) == -1) {
- 
		if (uid != 0)
- 
			err(EXIT_FAILURE, "%s:", pkg_dbdir);
-
- 
		if (errno == ENOENT)
- 
			return;
- 
		else
- 
			err(EXIT_FAILURE, "%s:", pkg_dbdir);
+ 
		pkgdb_set_error(db, errno, "stat(%s)", pkg_dbdir);
+ 
		return (-1);

	}



	snprintf(cache_path, sizeof(cache_path), "%s/pkgdb.cache", pkg_dbdir);



	errno = 0; /* Reset it in case it is set to ENOENT */
- 
	if (stat(cache_path, &cache_st) == -1 && errno != ENOENT)
- 
		err(EXIT_FAILURE, "%s:", cache_path);
+ 
	if (stat(cache_path, &cache_st) == -1 && errno != ENOENT) {
+ 
		pkgdb_set_error(db, errno, "stat(%s)", cache_path);
+ 
		return (-1);
+ 
	}



	if (errno == ENOENT || dir_st.st_mtime > cache_st.st_mtime) {

		pkgdb_lock(db, LOCK_EX);
- 
		pkgdb_cache_rebuild(pkg_dbdir, cache_path);
+ 
		ret = pkgdb_cache_rebuild(db, pkg_dbdir, cache_path);

		pkgdb_lock(db, LOCK_UN);

	}
+
+ 
	return (ret);

}



int
@@ -290,7 +288,8 @@ pkgdb_cache_init(struct pkgdb *db)
	char path[MAXPATHLEN];

	int fd;
- 
	pkgdb_cache_update(db);
+ 
	if (pkgdb_cache_update(db) == -1)
+ 
		return (-1);



	if ((db->cdb = malloc(sizeof(struct cdb))) == NULL)

		err(EXIT_FAILURE, "malloc()");
@@ -303,7 +302,7 @@ pkgdb_cache_init(struct pkgdb *db)
		/* TODO custom pkgdb error */

	}
- 
	return (0);
+ 
	return (fd);

}



void
modified pkg/info.c
@@ -51,7 +51,10 @@ cmd_info(int argc, char **argv)
	if (argc == 0)

		match = MATCH_ALL;
- 
	pkgdb_init(&db, argv[0], match);
+ 
	if (pkgdb_init(&db, argv[0], match) == -1) {
+ 
		pkgdb_warn(&db);
+ 
		return (-1);
+ 
	}



	while (pkgdb_query(&db, &pkg) == 0) {

		if (opt & INFO_PRINT_DEP) {
@@ -67,6 +70,12 @@ cmd_info(int argc, char **argv)
		}

	}
+ 
	if (db.errnum > -1) {
+ 
		pkgdb_warn(&db);
+ 
		pkgdb_free(&db);
+ 
		return (-1);
+ 
	}
+ 


	pkgdb_free(&db);

	return (0);

}