Radish alpha
H
HardenedBSD-pkg
HardenedBSD Package Manager
Radicle
Git (anonymous pull)
Log in to clone via SSH
Commits ›
The struct pkg know which array are initialized.
jlaffaye committed 15 years ago
commit 801b27337bd49c749cc89bfac1de16195b1b112b
parent 67c2d6bf655cbb8dbe0bfed4dd509d21e751bf8c
5 files changed +305 -130
modified libpkg/pkg.c
@@ -10,8 +10,6 @@
#include "pkg_private.h"

#include "pkg_util.h"
- 
static void pkg_free_void(void*);
- 


pkg_t

pkg_type(struct pkg *pkg)

{
@@ -393,6 +391,7 @@ pkg_reset(struct pkg *pkg)
	sbuf_reset(pkg->prefix);



	pkg->flatsize = 0;
+ 
	pkg->flags = 0;

	pkg->path = NULL;



	array_reset(&pkg->deps, &pkg_free_void);
@@ -434,7 +433,7 @@ pkg_free(struct pkg *pkg)
	free(pkg);

}
- 
static void
+ 
void

pkg_free_void(void *p)

{

	if (p != NULL)
modified libpkg/pkg.h
@@ -331,6 +331,14 @@ int pkgdb_it_next_script(struct pkgdb_it *, struct pkg_script **);
int pkgdb_it_next_option(struct pkgdb_it *, struct pkg_option **);

void pkgdb_it_free(struct pkgdb_it *);
+ 
int pkgdb_pkg_loaddeps(struct pkgdb *db, struct pkg *pkg);
+ 
int pkgdb_pkg_loadrdeps(struct pkgdb *db, struct pkg *pkg);
+ 
int pkgdb_pkg_loadconflicts(struct pkgdb *db, struct pkg *pkg);
+ 
int pkgdb_pkg_loadfiles(struct pkgdb *db, struct pkg *pkg);
+ 
int pkgdb_pkg_loadexecs(struct pkgdb *db, struct pkg *pkg);
+ 
int pkgdb_pkg_loadscripts(struct pkgdb *db, struct pkg *pkg);
+ 
int pkgdb_pkg_loadoptions(struct pkgdb *db, struct pkg *pkg);
+ 


const char *pkgdb_get_dir(void);



/* create */
modified libpkg/pkg_delete.c
@@ -22,7 +22,6 @@ dircmp(char *path, struct array *a)
	return (0);

}
- 
/* TODO: take an origin and not a pkg */

int

pkg_delete(struct pkg *pkg, struct pkgdb *db, int force)

{
@@ -46,8 +45,22 @@ pkg_delete(struct pkg *pkg, struct pkgdb *db, int force)
	if (db == NULL)

		return (ERROR_BAD_ARG("db"));
+ 
	/*
+ 
	 * Ensure that we have all the informations we need
+ 
	 */
+ 
	if ((ret = pkgdb_pkg_loadrdeps(db, pkg)) != EPKG_OK)
+ 
		return (ret);
+ 
	if ((ret = pkgdb_pkg_loadfiles(db, pkg)) != EPKG_OK)
+ 
		return (ret);
+ 
	if ((ret = pkgdb_pkg_loadscripts(db, pkg)) != EPKG_OK)
+ 
		return (ret);
+ 
	if ((ret = pkgdb_pkg_loadexecs(db, pkg)) != EPKG_OK)
+ 
		return (ret);
+ 


	rdeps = pkg_rdeps(pkg);

	files = pkg_files(pkg);
+ 
	scripts = pkg_scripts(pkg);
+ 
	execs = pkg_execs(pkg);

	prefix = pkg_get(pkg, PKG_PREFIX);



	if (rdeps == NULL || files == NULL)
@@ -61,26 +74,26 @@ pkg_delete(struct pkg *pkg, struct pkgdb *db, int force)


	script_cmd = sbuf_new_auto();

	/* execute PRE_DEINSTALL */
- 
	if ((scripts = pkg_scripts(pkg)) != NULL)
- 
		for (i = 0; scripts[i] != NULL; i++) {
- 
			switch (pkg_script_type(scripts[i])) {
- 
				case PKG_SCRIPT_DEINSTALL:
- 
					sbuf_reset(script_cmd);
- 
					sbuf_printf(script_cmd, "set -- %s-%s DEINSTALL\n%s", pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION), pkg_script_data(scripts[i]));
- 
					sbuf_finish(script_cmd);
- 
					system(sbuf_data(script_cmd));
- 
					break;
- 
				case PKG_SCRIPT_PRE_DEINSTALL:
- 
					sbuf_reset(script_cmd);
- 
					sbuf_printf(script_cmd, "set -- %s-%s\n%s", pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION), pkg_script_data(scripts[i]));
- 
					sbuf_finish(script_cmd);
- 
					system(sbuf_data(script_cmd));
- 
					break;
- 
				default:
- 
					/* just ignore */
- 
					break;
- 
			}
+ 
	for (i = 0; scripts[i] != NULL; i++) {
+ 
		switch (pkg_script_type(scripts[i])) {
+ 
			case PKG_SCRIPT_DEINSTALL:
+ 
				sbuf_reset(script_cmd);
+ 
				sbuf_printf(script_cmd, "set -- %s-%s DEINSTALL\n%s", pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION), pkg_script_data(scripts[i]));
+ 
				sbuf_finish(script_cmd);
+ 
				system(sbuf_data(script_cmd));
+ 
				break;
+ 
			case PKG_SCRIPT_PRE_DEINSTALL:
+ 
				sbuf_reset(script_cmd);
+ 
				sbuf_printf(script_cmd, "set -- %s-%s\n%s", pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION), pkg_script_data(scripts[i]));
+ 
				sbuf_finish(script_cmd);
+ 
				system(sbuf_data(script_cmd));
+ 
				break;
+ 
			default:
+ 
				/* just ignore */
+ 
				break;

		}
+ 
	}
+ 


	a = archive_read_new();

	archive_read_support_compression_none(a);

	archive_read_support_format_mtree(a);
@@ -126,34 +139,32 @@ pkg_delete(struct pkg *pkg, struct pkgdb *db, int force)
	}

	array_free(&mtreedirs, &free);
- 
	if (scripts != NULL)
- 
		for (i = 0; scripts[i] != NULL; i++) {
- 
			switch (pkg_script_type(scripts[i])) {
- 
				case PKG_SCRIPT_DEINSTALL:
- 
					sbuf_reset(script_cmd);
- 
					sbuf_printf(script_cmd, "set -- %s-%s POST-DEINSTALL\n%s", pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION), pkg_script_data(scripts[i]));
- 
					sbuf_finish(script_cmd);
- 
					system(sbuf_data(script_cmd));
- 
					break;
- 
				case PKG_SCRIPT_POST_DEINSTALL:
- 
					sbuf_reset(script_cmd);
- 
					sbuf_printf(script_cmd, "set -- %s-%s\n%s", pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION), pkg_script_data(scripts[i]));
- 
					sbuf_finish(script_cmd);
- 
					system(sbuf_data(script_cmd));
- 
					break;
- 
				default:
- 
					/* just ignore */
- 
					break;
- 
			}
+ 
	for (i = 0; scripts[i] != NULL; i++) {
+ 
		switch (pkg_script_type(scripts[i])) {
+ 
			case PKG_SCRIPT_DEINSTALL:
+ 
				sbuf_reset(script_cmd);
+ 
				sbuf_printf(script_cmd, "set -- %s-%s POST-DEINSTALL\n%s", pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION), pkg_script_data(scripts[i]));
+ 
				sbuf_finish(script_cmd);
+ 
				system(sbuf_data(script_cmd));
+ 
				break;
+ 
			case PKG_SCRIPT_POST_DEINSTALL:
+ 
				sbuf_reset(script_cmd);
+ 
				sbuf_printf(script_cmd, "set -- %s-%s\n%s", pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION), pkg_script_data(scripts[i]));
+ 
				sbuf_finish(script_cmd);
+ 
				system(sbuf_data(script_cmd));
+ 
				break;
+ 
			default:
+ 
				/* just ignore */
+ 
				break;

		}
+ 
	}



	sbuf_free(script_cmd);



	/* run the @unexec */
- 
	if ((execs = pkg_execs(pkg)) != NULL)
- 
		for (i = 0; execs[i] != NULL; i++)
- 
			if (pkg_exec_type(execs[i]) == PKG_UNEXEC)
- 
				system(pkg_exec_cmd(execs[i]));
+ 
	for (i = 0; execs[i] != NULL; i++)
+ 
		if (pkg_exec_type(execs[i]) == PKG_UNEXEC)
+ 
			system(pkg_exec_cmd(execs[i]));



	return (pkgdb_unregister_pkg(db, pkg_get(pkg, PKG_ORIGIN)));

}
modified libpkg/pkg_private.h
@@ -30,6 +30,7 @@ struct pkg {
	struct array exec;

	struct array options;

	const char *path; /* TODO: remove */
+ 
	int flags;

	pkg_t type;

};
@@ -57,6 +58,7 @@ struct pkg_option {
	struct sbuf *value;

};
+ 
void pkg_free_void(void *);

void pkg_conflict_free_void(void *);

void pkg_script_free_void(void *);

void pkg_exec_free_void(void *);
modified libpkg/pkgdb.c
@@ -264,14 +264,7 @@ int
pkgdb_it_next_pkg(struct pkgdb_it *it, struct pkg **pkg_p, int flags)

{

	struct pkg *pkg;
- 
	struct pkg *p;
- 
	struct pkg_conflict *c;
- 
	struct pkg_file *f;
- 
	struct pkg_exec *e;
- 
	struct pkg_script *s;
- 
	struct pkg_option *o;
- 
	struct pkgdb_it *i;
-
+ 
	int ret;



	if (it == NULL || it->type != IT_PKG)

		return (ERROR_BAD_ARG("it"));
@@ -299,88 +292,34 @@ pkgdb_it_next_pkg(struct pkgdb_it *it, struct pkg **pkg_p, int flags)
		pkg_set(pkg, PKG_PREFIX, sqlite3_column_text(it->stmt, 11));

		pkg_setflatsize(pkg, sqlite3_column_int64(it->stmt, 12));
- 
		if (flags & PKG_DEPS) {
- 
			array_init(&pkg->deps, 10);
-
- 
			i = pkgdb_query_dep(it->db, pkg_get(pkg, PKG_ORIGIN));
- 
			p = NULL;
- 
			while (pkgdb_it_next_pkg(i, &p, PKG_BASIC) == EPKG_OK) {
- 
				array_append(&pkg->deps, p);
- 
				p = NULL;
- 
			}
- 
			pkgdb_it_free(i);
- 
		}
+ 
		if (flags & PKG_DEPS)
+ 
			if ((ret = pkgdb_pkg_loaddeps(it->db, pkg)) != EPKG_OK)
+ 
				return (ret);
- 
		if (flags & PKG_RDEPS) {
- 
			array_init(&pkg->rdeps, 5);
+ 
		if (flags & PKG_RDEPS)
+ 
			if ((ret = pkgdb_pkg_loadrdeps(it->db, pkg)) != EPKG_OK)
+ 
				return (ret);
- 
			i = pkgdb_query_rdep(it->db, pkg_get(pkg, PKG_ORIGIN));
- 
			p = NULL;
- 
			while (pkgdb_it_next_pkg(i, &p, PKG_BASIC) == EPKG_OK) {
- 
				array_append(&pkg->rdeps, p);
- 
				p = NULL;
- 
			}
- 
			pkgdb_it_free(i);
- 
		}
+ 
		if (flags & PKG_CONFLICTS)
+ 
			if ((ret = pkgdb_pkg_loadconflicts(it->db, pkg)) != EPKG_OK)
+ 
				return (ret);
- 
		if (flags & PKG_CONFLICTS) {
- 
			array_init(&pkg->conflicts, 5);
+ 
		if (flags & PKG_FILES)
+ 
			if ((ret = pkgdb_pkg_loadfiles(it->db, pkg)) != EPKG_OK)
+ 
				return (ret);
- 
			i = pkgdb_query_conflicts(it->db, pkg_get(pkg, PKG_ORIGIN));
- 
			c = NULL;
- 
			while (pkgdb_it_next_conflict(i, &c) == EPKG_OK) {
- 
				array_append(&pkg->conflicts, c);
- 
				c = NULL;
- 
			}
- 
			pkgdb_it_free(i);
- 
		}
+ 
		if (flags & PKG_EXECS)
+ 
			if ((ret = pkgdb_pkg_loadexecs(it->db, pkg)) != EPKG_OK)
+ 
				return (ret);
- 
		if (flags & PKG_FILES) {
- 
			array_init(&pkg->files, 10);
-
- 
			i = pkgdb_query_files(it->db, pkg_get(pkg, PKG_ORIGIN));
- 
			f = NULL;
- 
			while (pkgdb_it_next_file(i, &f) == EPKG_OK) {
- 
				array_append(&pkg->files, f);
- 
				f = NULL;
- 
			}
- 
			pkgdb_it_free(i);
- 
		}
+ 
		if (flags & PKG_SCRIPTS)
+ 
			if ((ret = pkgdb_pkg_loadscripts(it->db, pkg)) != EPKG_OK)
+ 
				return (ret);
- 
		if (flags & PKG_EXECS) {
- 
			array_init(&pkg->exec, 5);
+ 
		if (flags & PKG_OPTIONS)
+ 
			if ((ret = pkgdb_pkg_loadoptions(it->db, pkg)) != EPKG_OK)
+ 
				return (ret);
- 
			i = pkgdb_query_execs(it->db, pkg_get(pkg, PKG_ORIGIN));
- 
			e = NULL;
- 
			while (pkgdb_it_next_exec(i, &e) == EPKG_OK) {
- 
				array_append(&pkg->exec, e);
- 
				e = NULL;
- 
			}
- 
			pkgdb_it_free(i);
- 
		}
-
- 
		if (flags & PKG_SCRIPTS) {
- 
			array_init(&pkg->scripts, 6);
-
- 
			i = pkgdb_query_scripts(it->db, pkg_get(pkg, PKG_ORIGIN));
- 
			s = NULL;
- 
			while (pkgdb_it_next_script(i, &s) == EPKG_OK) {
- 
				array_append(&pkg->scripts, s);
- 
				s = NULL;
- 
			}
- 
			pkgdb_it_free(i);
- 
		}
- 
		if (flags & PKG_OPTIONS) {
- 
			array_init(&pkg->options, 5);
-
- 
			i = pkgdb_query_options(it->db, pkg_get(pkg, PKG_ORIGIN));
- 
			o = NULL;
- 
			while (pkgdb_it_next_option(i, &o) == EPKG_OK) {
- 
				array_append(&pkg->options, o);
- 
				o = NULL;
- 
			}
- 
			pkgdb_it_free(i);
- 
		}

		return (EPKG_OK);

	case SQLITE_DONE:

		return (EPKG_END);
@@ -749,7 +688,223 @@ pkgdb_query_options(struct pkgdb *db, const char *origin) {
	return (pkgdb_it_new(db, stmt, IT_OPTION));

}
- 
/* TODO: error handling of this mess */
+ 
int
+ 
pkgdb_pkg_loaddeps(struct pkgdb *db, struct pkg *pkg)
+ 
{
+ 
	struct pkgdb_it *it;
+ 
	struct pkg *p;
+ 
	int ret;
+
+ 
	if (pkg->flags & PKG_DEPS)
+ 
		return (EPKG_OK);
+
+ 
	array_init(&pkg->deps, 10);
+
+ 
	if ((it = pkgdb_query_dep(db, pkg_get(pkg, PKG_ORIGIN))) == NULL)
+ 
		return (EPKG_FATAL);
+
+ 
	p = NULL;
+ 
	while ((ret = pkgdb_it_next_pkg(it, &p, PKG_BASIC)) == EPKG_OK) {
+ 
		array_append(&pkg->deps, p);
+ 
		p = NULL;
+ 
	}
+ 
	pkgdb_it_free(it);
+
+ 
	if (ret != EPKG_END) {
+ 
		array_reset(&pkg->deps, &pkg_free_void);
+ 
		return (ret);
+ 
	}
+
+ 
	pkg->flags |= PKG_DEPS;
+ 
	return (EPKG_OK);
+ 
}
+
+ 
int
+ 
pkgdb_pkg_loadrdeps(struct pkgdb *db, struct pkg *pkg)
+ 
{
+ 
	struct pkgdb_it *it;
+ 
	struct pkg *p;
+ 
	int ret;
+
+ 
	if (pkg->flags & PKG_RDEPS)
+ 
		return (EPKG_OK);
+
+ 
	array_init(&pkg->rdeps, 5);
+
+ 
	if ((it = pkgdb_query_rdep(db, pkg_get(pkg, PKG_ORIGIN))) == NULL)
+ 
		return (EPKG_FATAL);
+
+ 
	p = NULL;
+ 
	while ((ret = pkgdb_it_next_pkg(it, &p, PKG_BASIC)) == EPKG_OK) {
+ 
		array_append(&pkg->rdeps, p);
+ 
		p = NULL;
+ 
	}
+ 
	pkgdb_it_free(it);
+
+ 
	if (ret != EPKG_END) {
+ 
		array_reset(&pkg->rdeps, &pkg_free_void);
+ 
		return (ret);
+ 
	}
+
+ 
	pkg->flags |= PKG_RDEPS;
+ 
	return (EPKG_OK);
+ 
}
+
+ 
int
+ 
pkgdb_pkg_loadconflicts(struct pkgdb *db, struct pkg *pkg)
+ 
{
+ 
	struct pkgdb_it *it;
+ 
	struct pkg_conflict *c;
+ 
	int ret;
+
+ 
	if (pkg->flags & PKG_CONFLICTS)
+ 
		return (EPKG_OK);
+
+ 
	array_init(&pkg->conflicts, 5);
+
+ 
	if ((it = pkgdb_query_conflicts(db, pkg_get(pkg, PKG_ORIGIN))) == NULL)
+ 
		return (EPKG_FATAL);
+
+ 
	c = NULL;
+ 
	while ((ret = pkgdb_it_next_conflict(it, &c)) == EPKG_OK) {
+ 
		array_append(&pkg->conflicts, c);
+ 
		c = NULL;
+ 
	}
+ 
	pkgdb_it_free(it);
+
+ 
	if (ret != EPKG_END) {
+ 
		array_reset(&pkg->conflicts, &pkg_conflict_free_void);
+ 
		return (ret);
+ 
	}
+
+ 
	pkg->flags |= PKG_CONFLICTS;
+ 
	return (EPKG_OK);
+ 
}
+
+ 
int
+ 
pkgdb_pkg_loadfiles(struct pkgdb *db, struct pkg *pkg)
+ 
{
+ 
	struct pkgdb_it *it;
+ 
	struct pkg_file *f;
+ 
	int ret;
+
+ 
	if (pkg->flags & PKG_FILES)
+ 
		return (EPKG_OK);
+
+ 
	array_init(&pkg->files, 10);
+
+ 
	if ((it = pkgdb_query_files(db, pkg_get(pkg, PKG_ORIGIN))) == NULL)
+ 
		return (EPKG_FATAL);
+
+ 
	f = NULL;
+ 
	while ((ret = pkgdb_it_next_file(it, &f)) == EPKG_OK) {
+ 
		array_append(&pkg->files, f);
+ 
		f = NULL;
+ 
	}
+ 
	pkgdb_it_free(it);
+
+ 
	if (ret != EPKG_END) {
+ 
		array_reset(&pkg->files, &free);
+ 
		return (ret);
+ 
	}
+
+ 
	pkg->flags |= PKG_FILES;
+ 
	return (EPKG_OK);
+ 
}
+
+ 
int
+ 
pkgdb_pkg_loadexecs(struct pkgdb *db, struct pkg *pkg)
+ 
{
+ 
	struct pkgdb_it *it;
+ 
	struct pkg_exec *e;
+ 
	int ret;
+
+ 
	if (pkg->flags & PKG_EXECS)
+ 
		return (EPKG_OK);
+
+ 
	array_init(&pkg->exec, 5);
+
+ 
	if ((it = pkgdb_query_execs(db, pkg_get(pkg, PKG_ORIGIN))) == NULL)
+ 
		return (EPKG_FATAL);
+
+ 
	e = NULL;
+ 
	while (pkgdb_it_next_exec(it, &e) == EPKG_OK) {
+ 
		array_append(&pkg->exec, e);
+ 
		e = NULL;
+ 
	}
+ 
	pkgdb_it_free(it);
+
+ 
	if (ret != EPKG_END) {
+ 
		array_reset(&pkg->exec, &pkg_exec_free_void);
+ 
		return (ret);
+ 
	}
+
+ 
	pkg->flags |= PKG_EXECS;
+ 
	return (EPKG_OK);
+ 
}
+
+ 
int
+ 
pkgdb_pkg_loadscripts(struct pkgdb *db, struct pkg *pkg)
+ 
{
+ 
	struct pkgdb_it *it;
+ 
	struct pkg_script *s;
+ 
	int ret;
+
+ 
	if (pkg->flags & PKG_SCRIPTS)
+ 
		return (EPKG_OK);
+
+ 
	array_init(&pkg->scripts, 6);
+
+ 
	if ((it = pkgdb_query_scripts(db, pkg_get(pkg, PKG_ORIGIN))) == NULL)
+ 
		return (EPKG_FATAL);
+
+ 
	s = NULL;
+ 
	while ((ret = pkgdb_it_next_script(it, &s)) == EPKG_OK) {
+ 
		array_append(&pkg->scripts, s);
+ 
		s = NULL;
+ 
	}
+ 
	pkgdb_it_free(it);
+
+ 
	if (ret != EPKG_END) {
+ 
		array_reset(&pkg->scripts, &pkg_script_free_void);
+ 
		return (ret);
+ 
	}
+
+ 
	pkg->flags |= PKG_SCRIPTS;
+ 
	return (EPKG_OK);
+ 
}
+
+ 
int
+ 
pkgdb_pkg_loadoptions(struct pkgdb *db, struct pkg *pkg)
+ 
{
+ 
	struct pkgdb_it *it;
+ 
	struct pkg_option *o;
+ 
	int ret;
+
+ 
	if (pkg->flags & PKG_OPTIONS)
+ 
		return (EPKG_OK);
+
+ 
	array_init(&pkg->options, 5);
+
+ 
	if ((it = pkgdb_query_options(db, pkg_get(pkg, PKG_ORIGIN))) == NULL)
+ 
		return (EPKG_FATAL);
+
+ 
	o = NULL;
+ 
	while ((ret = pkgdb_it_next_option(it, &o)) == EPKG_OK) {
+ 
		array_append(&pkg->options, o);
+ 
		o = NULL;
+ 
	}
+ 
	pkgdb_it_free(it);
+
+ 
	if (ret != EPKG_END) {
+ 
		array_reset(&pkg->options, &pkg_option_free_void);
+ 
		return (ret);
+ 
	}
+
+ 
	pkg->flags |= PKG_OPTIONS;
+ 
	return (EPKG_OK);
+ 
}
+ 


int

pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg)

{