Radish alpha
H
HardenedBSD-pkg
HardenedBSD Package Manager
Radicle
Git (anonymous pull)
Log in to clone via SSH
Commits ›
Merge branch 'master' of etoilebsd.net:pkgng
jlaffaye committed 15 years ago
commit a7298b65f4d4cec502389a8014ed8f58ab4ab6e1
parent 86b89a884cc25da4d07596a1f7c087269eb5a4db
9 files changed +275 -94
modified libpkg/Makefile
@@ -8,6 +8,7 @@ SHLIB_MAJOR= 0


SRCS=		pkg.c \

		pkgdb.c \
+ 
		pkg_create.c \

		pkg_conflict.c \

		pkg_delete.c \

		pkg_exec.c \
modified libpkg/pkg.h
@@ -78,6 +78,7 @@ int pkg_addscript(struct pkg *, const char *);


/* pkg_manifest */

int pkg_parse_manifest(struct pkg *, char *);
+ 
int pkg_emit_manifest(struct pkg *, char **);



/* pkg_file */

int pkg_file_new(struct pkg_file **);
@@ -118,17 +119,23 @@ struct pkgdb_it * pkgdb_query_dep(struct pkgdb *, const char *);
struct pkgdb_it * pkgdb_query_rdep(struct pkgdb *, const char *);

struct pkgdb_it * pkgdb_query_conflicts(struct pkgdb *, const char *);

struct pkgdb_it * pkgdb_query_files(struct pkgdb *, const char *);
+ 
struct pkgdb_it * pkgdb_query_execs(struct pkgdb *, const char *);
+ 
struct pkgdb_it * pkgdb_query_scripts(struct pkgdb *, const char *);



#define PKG_BASIC 0

#define PKG_DEPS (1<<0)

#define PKG_RDEPS (1<<1)

#define PKG_CONFLICTS (1<<2)

#define PKG_FILES (1<<3)
- 
#define PKG_ALL PKG_BASIC|PKG_DEPS|PKG_RDEPS|PKG_CONFLICTS|PKG_FILES
+ 
#define PKG_EXECS (1<<4)
+ 
#define PKG_SCRIPTS (1<<5)
+ 
#define PKG_ALL PKG_BASIC|PKG_DEPS|PKG_RDEPS|PKG_CONFLICTS|PKG_FILES|PKG_EXECS|PKG_SCRIPTS



int pkgdb_it_next_pkg(struct pkgdb_it *, struct pkg **, int);

int pkgdb_it_next_conflict(struct pkgdb_it *, struct pkg_conflict **);

int pkgdb_it_next_file(struct pkgdb_it *, struct pkg_file **);
+ 
int pkgdb_it_next_exec(struct pkgdb_it *, struct pkg_exec **);
+ 
int pkgdb_it_next_script(struct pkgdb_it *, struct pkg_script **);

void pkgdb_it_free(struct pkgdb_it *);



const char *pkgdb_get_dir(void);
modified libpkg/pkg_create.c
@@ -10,102 +10,124 @@
#include <fcntl.h>



#include "pkg.h"
- 
#include "pkg_manifest.h"
+ 
#include "pkg_private.h"



#define METADATA_GLOB "+{DEINSTALL,INSTALL,MTREE_DIRS}"
- 
static int pkg_create_from_dir(struct pkg_manifest *, const char *, struct archive *);

static const char * pkg_create_set_format(struct archive *, pkg_formats);
+ 
static int pkg_create_from_dir(struct pkg *, const char *, struct archive *);
+ 
static int pkg_create_append_buffer(struct archive *, struct archive_entry *, const char *, const char *);



static int
- 
pkg_create_from_dir(struct pkg_manifest *m, const char *root, struct archive *pkg_archive)
+ 
pkg_create_append_buffer(struct archive *a, struct archive_entry *e, const char *buf, const char *name)
+ 
{
+ 
	if (name == NULL || buf == NULL || buf[0] == '\0' || name[0] == '\0')
+ 
		return (-1);
+
+ 
	archive_entry_clear(e);
+ 
	archive_entry_set_filetype(e, AE_IFREG);
+ 
	archive_entry_set_pathname(e, name);
+ 
	archive_entry_set_size(e, strlen(buf));
+ 
	archive_write_header(a, e);
+ 
	archive_write_data(a, buf, strlen(buf));
+ 
	archive_entry_clear(e);
+
+ 
	return (0);
+
+ 
}
+
+ 
static int
+ 
pkg_create_from_dir(struct pkg *pkg, const char *root, struct archive *pkg_archive)

{

	struct archive_entry *entry;
- 
#if 0
- 
	char *path;
- 
	char glob_pattern[MAXPATHLEN + sizeof(METADATA_GLOB)];
- 
	glob_t g;
- 
#endif

	int fd;
- 
	size_t len/*, i = 0*/;
+ 
	size_t len;

	char buf[BUFSIZ];
- 
	char *buffer;
- 
	size_t buffer_len;

	char fpath[MAXPATHLEN];
- 
	const char *filepath;
+ 
	struct pkg_file **files;
+ 
	struct pkg_script **scripts;

	struct archive *ar;
+ 
	char *m;
+ 
	int i;
+ 
	const char *scriptname;



	ar = archive_read_disk_new();

	archive_read_disk_set_standard_lookup(ar);



	entry = archive_entry_new();
- 
/* TODO: Add metadatas */
- 
#if 0
- 
	path = strdup(mpath);
- 
	buffer = strrchr(path, '/');
- 
	buffer[0] = '\0';
- 
	/* Add the metadatas */
- 
	snprintf(glob_pattern, sizeof(glob_pattern), "%s/"METADATA_GLOB, path);
- 
	free(path);
-
- 
	if (glob(glob_pattern, GLOB_NOSORT|GLOB_BRACE, NULL, &g) == 0) {
- 
		for ( i = 0; i < g.gl_pathc; i++) {
- 
			fd = open(g.gl_pathv[i], O_RDONLY);
- 
			archive_entry_copy_sourcepath(entry, g.gl_pathv[i]);
+ 
	pkg_emit_manifest(pkg, &m);
+
+ 
	pkg_create_append_buffer(pkg_archive, entry, m, "+MANIFEST");
+ 
	free(m);
+ 
	pkg_create_append_buffer(pkg_archive, entry, pkg_get(pkg, PKG_DESC), "+DESC");
+ 
	pkg_create_append_buffer(pkg_archive, entry, pkg_get(pkg, PKG_MTREE), "+MTREE_DIRS");
+
+ 
	if ((scripts = pkg_scripts(pkg)) != NULL) {
+ 
		for (i = 0; scripts[i] != NULL; i++) {
+ 
			switch (pkg_script_type(scripts[i])) {
+ 
				case PKG_SCRIPT_PRE_INSTALL:
+ 
					scriptname = "+PRE_INSTALL";
+ 
					break;
+ 
				case PKG_SCRIPT_POST_INSTALL:
+ 
					scriptname = "+POST_INSTALL";
+ 
					break;
+ 
				case PKG_SCRIPT_INSTALL:
+ 
					scriptname = "+INSTALL";
+ 
					break;
+ 
				case PKG_SCRIPT_PRE_DEINSTALL:
+ 
					scriptname = "+PRE_DEINSTALL";
+ 
					break;
+ 
				case PKG_SCRIPT_POST_DEINSTALL:
+ 
					scriptname = "+POST_DEINSTALL";
+ 
					break;
+ 
				case PKG_SCRIPT_DEINSTALL:
+ 
					scriptname = "+DEINSTALL";
+ 
					break;
+ 
				case PKG_SCRIPT_PRE_UPGRADE:
+ 
					scriptname = "+PRE_UPGRADE";
+ 
					break;
+ 
				case PKG_SCRIPT_POST_UPGRADE:
+ 
					scriptname = "+POST_UPGRADE";
+ 
					break;
+ 
				case PKG_SCRIPT_UPGRADE:
+ 
					scriptname = "+UPGRADE";
+ 
					break;
+ 
			}
+ 
			pkg_create_append_buffer(pkg_archive, entry, pkg_script_data(scripts[i]), scriptname);
+ 
		}
+ 
	}
+
+ 
	if ((files = pkg_files(pkg)) != NULL) {
+ 
		for (i = 0; files[i] != NULL; i++) {
+ 
			if (root != NULL)
+ 
				snprintf(fpath, sizeof(MAXPATHLEN), "%s%s", root, pkg_file_path(files[i]));
+ 
			else
+ 
				strlcpy(fpath, pkg_file_path(files[i]), MAXPATHLEN);
+
+ 
			archive_entry_copy_sourcepath(entry, fpath);



			if (archive_read_disk_entry_from_file(ar, entry, -1, 0) != ARCHIVE_OK)
- 
				warnx("archive_read_disk_entry_from_file(%s): %s", g.gl_pathv[i],
- 
					  archive_error_string(ar));
+ 
				warnx("archive_read_disk_entry_from_file(%s): %s", fpath,
+ 
						archive_error_string(ar));
- 
			archive_entry_set_pathname(entry, basename(g.gl_pathv[i]));
+ 
			archive_entry_set_pathname(entry, pkg_file_path(files[i]));

			archive_write_header(pkg_archive, entry);
- 
			while ( (len = read(fd, buf, sizeof(buf))) > 0 )
- 
				archive_write_data(pkg_archive, buf, len);
+ 
			fd = open(fpath, O_RDONLY);
+ 
			if (fd != -1) {
+ 
				while ( (len = read(fd, buf, sizeof(buf))) > 0 )
+ 
					archive_write_data(pkg_archive, buf, len);
- 
			close(fd);
+ 
				close(fd);
+ 
			}

			archive_entry_clear(entry);

		}

	}
- 
	globfree(&g);
- 
#endif
- 
	buffer = pkg_manifest_dump_buffer(m);
- 
	buffer_len = strlen(buffer);
-
- 
	archive_entry_set_filetype(entry, AE_IFREG);
- 
	archive_entry_set_pathname(entry, "+MANIFEST");
- 
	archive_entry_set_size(entry, buffer_len);
- 
	archive_write_header(pkg_archive, entry);
- 
	archive_write_data(pkg_archive, buffer, buffer_len);
- 
	archive_entry_clear(entry);
-
- 
	free(buffer);
-
- 
	pkg_manifest_file_init(m);
- 
	while (pkg_manifest_file_next(m) == 0) {
- 
		filepath = pkg_manifest_file_path(m);
- 
		snprintf(fpath, sizeof(MAXPATHLEN), "%s/%s", root, filepath);
- 
		archive_entry_copy_sourcepath(entry, filepath);
-
- 
		if (archive_read_disk_entry_from_file(ar, entry, -1, 0) != ARCHIVE_OK)
- 
			warnx("archive_read_disk_entry_from_file(%s): %s", filepath,
- 
				  archive_error_string(ar));
-
- 
		archive_entry_set_pathname(entry, filepath);
- 
		archive_write_header(pkg_archive, entry);
- 
		fd = open(filepath, O_RDONLY);
- 
		if (fd != -1) {
- 
			while ( (len = read(fd, buf, sizeof(buf))) > 0 )
- 
				archive_write_data(pkg_archive, buf, len);
-
- 
			close(fd);
- 
		}
- 
		archive_entry_clear(entry);
- 
	}



	archive_entry_free(entry);

	archive_read_finish(ar);
+ 


	return (0);

}
@@ -116,7 +138,8 @@ pkg_create(const char *mpath, pkg_formats format, const char *outdir, const char
	struct archive *pkg_archive;

	char archive_path[MAXPATHLEN];

	const char *ext;
- 
	struct pkg_manifest *m;
+
+ 
	(void)mpath;



	pkg_archive = archive_write_new();
@@ -126,24 +149,14 @@ pkg_create(const char *mpath, pkg_formats format, const char *outdir, const char
		return (-1);

	}
- 
	if (pkg == NULL && mpath != NULL) {
- 
		m = pkg_manifest_load_file(mpath);
- 
	} else if (pkg != NULL) {
- 
		pkg_manifest_from_pkg(pkg, &m);
- 
	} else {
- 
		err(1, "mpath or pkg required");
- 
	}
-
- 
	snprintf(namever, sizeof(namever), "%s-%s", pkg_manifest_value(m, "name"),
- 
			 pkg_manifest_value(m, "version"));
+ 
	snprintf(namever, sizeof(namever), "%s-%s", pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION));

	snprintf(archive_path, sizeof(archive_path), "%s/%s.%s", outdir, namever, ext);



	archive_write_set_format_pax_restricted(pkg_archive);

	archive_write_open_filename(pkg_archive, archive_path);
- 
	pkg_create_from_dir(m, rootdir, pkg_archive);
+ 
	pkg_create_from_dir(pkg, rootdir, pkg_archive);
- 
	pkg_manifest_free(m);

	archive_write_close(pkg_archive);

	archive_write_finish(pkg_archive);
modified libpkg/pkg_manifest.c
@@ -241,3 +241,57 @@ pkg_parse_manifest(struct pkg *pkg, char *buf)


	return (0);

}
+
+ 
int
+ 
pkg_emit_manifest(struct pkg *pkg, char **dest)
+ 
{
+ 
	struct sbuf *manifest;
+ 
	struct pkg **deps;
+ 
	struct pkg_conflict **conflicts;
+ 
	struct pkg_exec **execs;
+ 
	int i;
+ 
	int len = 0;
+
+ 
	manifest = sbuf_new_auto();
+
+ 
	sbuf_printf(manifest, "@pkg_format_version 0.9\n"
+ 
			"@name %s\n"
+ 
			"@version %s\n"
+ 
			"@origin %s\n"
+ 
			"@comment %s\n",
+ 
			pkg_get(pkg, PKG_NAME),
+ 
			pkg_get(pkg, PKG_VERSION),
+ 
			pkg_get(pkg, PKG_ORIGIN),
+ 
			pkg_get(pkg, PKG_COMMENT));
+
+ 
	if ((deps = pkg_deps(pkg)) != NULL) {
+ 
		for (i = 0; deps[i] != NULL; i++) {
+ 
			sbuf_printf(manifest, "@dep %s %s %s\n",
+ 
					pkg_get(deps[i], PKG_NAME),
+ 
					pkg_get(deps[i], PKG_ORIGIN),
+ 
					pkg_get(deps[i], PKG_VERSION));
+ 
		}
+ 
	}
+
+ 
	if ((conflicts = pkg_conflicts(pkg)) != NULL) {
+ 
		for (i = 0; conflicts[i] != NULL; i++) {
+ 
			sbuf_printf(manifest, "@conflict %s\n", pkg_conflict_glob(conflicts[i]));
+ 
		}
+ 
	}
+
+ 
	if ((execs = pkg_execs(pkg)) != NULL) {
+ 
		for (i = 0; execs[i] != NULL; i++) {
+ 
			sbuf_printf(manifest, "@%s %s\n",
+ 
					pkg_exec_type(execs[i]) == PKG_EXEC ? "exec" : "unexec",
+ 
					pkg_exec_cmd(execs[i]));
+ 
		}
+ 
	}
+
+ 
	sbuf_finish(manifest);
+ 
	len = sbuf_len(manifest);
+ 
	*dest = strdup(sbuf_data(manifest));
+
+ 
	sbuf_free(manifest);
+
+ 
	return (len);
+ 
}
modified libpkg/pkgdb.c
@@ -238,6 +238,8 @@ pkgdb_it_next_pkg(struct pkgdb_it *it, struct pkg **pkg_p, int flags)
	struct pkg *p;

	struct pkg_conflict *c;

	struct pkg_file *f;
+ 
	struct pkg_exec *e;
+ 
	struct pkg_script *s;

	struct pkgdb_it *i;



	assert(it->type == IT_PKG);
@@ -256,6 +258,7 @@ pkgdb_it_next_pkg(struct pkgdb_it *it, struct pkg **pkg_p, int flags)
		pkg_set(pkg, PKG_VERSION, sqlite3_column_text(it->stmt, 2));

		pkg_set(pkg, PKG_COMMENT, sqlite3_column_text(it->stmt, 3));

		pkg_set(pkg, PKG_DESC, sqlite3_column_text(it->stmt, 4));
+ 
		pkg_set(pkg, PKG_MTREE, sqlite3_column_text(it->stmt, 5));



		if (flags & PKG_DEPS) {

			array_init(&pkg->deps, 10);
@@ -304,6 +307,30 @@ pkgdb_it_next_pkg(struct pkgdb_it *it, struct pkg **pkg_p, int flags)
			}

			pkgdb_it_free(i);

		}
+
+ 
		if (flags & PKG_EXECS) {
+ 
			array_init(&pkg->exec, 5);
+
+ 
			i = pkgdb_query_execs(it->db, pkg_get(pkg, PKG_ORIGIN));
+ 
			e = NULL;
+ 
			while (pkgdb_it_next_exec(i, &e) == 0) {
+ 
				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) == 0) {
+ 
				array_append(&pkg->scripts, s);
+ 
				s = NULL;
+ 
			}
+ 
			pkgdb_it_free(i);
+ 
		}

		return (0);

	case SQLITE_DONE:

		return (1);
@@ -365,6 +392,58 @@ pkgdb_it_next_file(struct pkgdb_it *it, struct pkg_file **file_p)
	}

}
+ 
int
+ 
pkgdb_it_next_exec(struct pkgdb_it *it, struct pkg_exec **exec_p)
+ 
{
+ 
	struct pkg_exec *exec;
+
+ 
	assert(it->type == IT_EXEC);
+
+ 
	switch (sqlite3_step(it->stmt)) {
+ 
		case SQLITE_ROW:
+ 
			if (*exec_p == NULL)
+ 
				pkg_exec_new(exec_p);
+ 
			else
+ 
				pkg_exec_reset(*exec_p);
+
+ 
			exec = *exec_p;
+ 
			sbuf_set(&exec->cmd, sqlite3_column_text(it->stmt, 0));
+ 
			exec->type = sqlite3_column_int(it->stmt, 1);
+ 
			return (0);
+ 
		case SQLITE_DONE:
+ 
			return (1);
+ 
		default:
+ 
			pkgdb_set_error(it->db, 0, "sqlite3_step(): %s", sqlite3_errmsg(it->db->sqlite));
+ 
			return (-1);
+ 
	}
+ 
}
+
+ 
int
+ 
pkgdb_it_next_script (struct pkgdb_it *it, struct pkg_script **script_p)
+ 
{
+ 
	struct pkg_script *script;
+
+ 
	assert(it->type == IT_SCRIPT);
+
+ 
	switch (sqlite3_step(it->stmt)) {
+ 
		case SQLITE_ROW:
+ 
			if (*script_p == NULL)
+ 
				pkg_script_new(script_p);
+ 
			else
+ 
				pkg_script_reset(*script_p);
+
+ 
			script = *script_p;
+ 
			sbuf_set(&script->data, sqlite3_column_text(it->stmt, 0));
+ 
			script->type = sqlite3_column_int(it->stmt, 1);
+ 
			return (0);
+ 
		case SQLITE_DONE:
+ 
			return (1);
+ 
		default:
+ 
			pkgdb_set_error(it->db, 0, "sqlite3_step(): %s", sqlite3_errmsg(it->db->sqlite));
+ 
			return (-1);
+ 
	}
+ 
}
+ 


void

pkgdb_it_free(struct pkgdb_it *it)

{
@@ -421,7 +500,7 @@ pkgdb_query(struct pkgdb *db, const char *pattern, match_t match)
	}



	snprintf(sql, sizeof(sql),
- 
			"SELECT origin, name, version, comment, desc FROM packages%s;", comp);
+ 
			"SELECT origin, name, version, comment, desc, mtree FROM packages%s;", comp);



	sqlite3_prepare(db->sqlite, sql, -1, &stmt, NULL);
@@ -437,7 +516,7 @@ pkgdb_query_which(struct pkgdb *db, const char *path)
	sqlite3_stmt *stmt;



	sqlite3_prepare(db->sqlite,
- 
					"SELECT origin, name, version, comment, desc FROM packages, files "
+ 
					"SELECT origin, name, version, comment, desc, mtree FROM packages, files "

					"WHERE origin = files.package_id "

					"AND files.path = ?1;", -1, &stmt, NULL);

	sqlite3_bind_text(stmt, 1, path, -1, SQLITE_TRANSIENT);
@@ -478,7 +557,7 @@ pkgdb_query_conflicts(struct pkgdb *db, const char *origin) {
	sqlite3_stmt *stmt;



	sqlite3_prepare(db->sqlite,
- 
					"SELECT name, origin, version "
+ 
					"SELECT name "

					"FROM conflicts "

					"WHERE package_id = ?1;", -1, &stmt, NULL);

	sqlite3_bind_text(stmt, 1, origin, -1, SQLITE_TRANSIENT);
@@ -500,6 +579,32 @@ pkgdb_query_files(struct pkgdb *db, const char *origin) {


}
+ 
struct pkgdb_it *
+ 
pkgdb_query_execs(struct pkgdb *db, const char *origin) {
+ 
	sqlite3_stmt *stmt;
+ 
	sqlite3_prepare(db->sqlite,
+ 
			"SELECT cmd, type "
+ 
			"FROM exec "
+ 
			"WHERE package_id = ?1", -1, &stmt, NULL);
+
+ 
	sqlite3_bind_text(stmt, 1, origin, -1, SQLITE_TRANSIENT);
+
+ 
	return (pkgdb_it_new(db, stmt, IT_EXEC));
+ 
}
+
+ 
struct pkgdb_it *
+ 
pkgdb_query_scripts(struct pkgdb *db, const char *origin) {
+ 
	sqlite3_stmt *stmt;
+ 
	sqlite3_prepare(db->sqlite,
+ 
			"SELECT script, type "
+ 
			"FROM scripts "
+ 
			"WHERE package_id = ?1", -1, &stmt, NULL);
+
+ 
	sqlite3_bind_text(stmt, 1, origin, -1, SQLITE_TRANSIENT);
+
+ 
	return (pkgdb_it_new(db, stmt, IT_SCRIPT));
+ 
}
+ 


void

pkgdb_set_error(struct pkgdb *db, int errnum, const char *fmt, ...)

{
@@ -551,7 +656,7 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg)
			-1, &stmt_dep, NULL);



	sqlite3_prepare(db->sqlite, "INSERT INTO conflicts (name, package_id)"
- 
			"VALUES (?1, ?2, ?3, ?4);",
+ 
			"VALUES (?1, ?2);",

			-1, &stmt_conflicts, NULL);



	sqlite3_prepare(db->sqlite, "INSERT INTO files (path, sha256, package_id)"
@@ -595,6 +700,9 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg)
		for (i = 0; conflicts[i] != NULL; i++) {

			sqlite3_bind_text(stmt_conflicts, 1, pkg_conflict_glob(conflicts[i]), -1, SQLITE_STATIC);

			sqlite3_bind_text(stmt_conflicts, 2, pkg_get(pkg, PKG_ORIGIN), -1, SQLITE_STATIC);
+
+ 
			sqlite3_step(stmt_conflicts);
+ 
			sqlite3_reset(stmt_conflicts);

		}
modified libpkg/pkgdb.h
@@ -14,7 +14,9 @@ struct pkgdb {
typedef enum _pkgdb_it_t {

	IT_PKG,

	IT_CONFLICT,
- 
	IT_FILE
+ 
	IT_FILE,
+ 
	IT_EXEC,
+ 
	IT_SCRIPT

} pkgdb_it_t;

struct pkgdb_it {

	struct pkgdb *db;
modified pkg/Makefile
@@ -5,7 +5,8 @@ SRCS= main.c \
	which.c \

	register.c \

	version.c \
- 
	add.c
+ 
	add.c \
+ 
	create.c



CFLAGS+=	-I${.CURDIR}/../libpkg

LDADD+=	-L${.CURDIR}/../external -L../libpkg -lpkg -lutil
modified pkg/create.c
@@ -79,9 +79,6 @@ exec_create(int argc, char **argv)
		return (EX_USAGE);

	}
- 
	if (rootdir == NULL)
- 
		rootdir = "/";
- 


	if (outdir == NULL)

		outdir = "./";
@@ -116,10 +113,8 @@ exec_create(int argc, char **argv)


		pkg_new(&pkg);

		while (pkgdb_it_next_pkg(it, &pkg, PKG_ALL) == 0) {
- 
			snprintf(mpath, sizeof(mpath), "%s/%s-%s/+MANIFEST", pkgdb_get_dir(),
- 
					 pkg_name(pkg), pkg_version(pkg));
- 
			printf("Creating package for %s-%s\n", pkg_name(pkg), pkg_version(pkg));
- 
			pkg_create(mpath, fmt, outdir, rootdir, pkg);
+ 
			printf("Creating package for %s-%s\n", pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION));
+ 
			pkg_create(NULL, fmt, outdir, rootdir, pkg);

		}

		pkg_free(pkg);

		pkgdb_it_free(it);
modified pkg/main.c
@@ -23,7 +23,7 @@ static struct commands {
	void (*usage)(void);

} cmd[] = { 

	{ "add", exec_add, usage_add},
- 
	{ "create", NULL, NULL},
+ 
	{ "create", exec_create, usage_create},

	{ "delete", exec_delete, usage_delete},

	{ "info", exec_info, usage_info},

	{ "install", NULL, NULL},