8b08809 Use a single function to set pkg attributes: — HardenedBSD-pkg

modified libpkg/pkg.c

@@ -177,6 +177,9 @@ pkg_vget(struct pkg const *const pkg, va_list ap)

 			case PKG_AUTOMATIC:
 				*va_arg(ap, bool *) = pkg->automatic;
 				break;
 			case PKG_ROWID:
 				*va_arg(ap, int64_t *) = pkg->rowid;
 				break;
 			default:
 				va_arg(ap, void *); /* ignore */
 				break;

@@ -201,38 +204,75 @@ pkg_get2(struct pkg const *const pkg, ...)

 	return (ret);
 }
 int
 pkg_set(struct pkg * pkg, pkg_attr attr, const char *value)
 static int
 pkg_vset(struct pkg *pkg, va_list ap)
 {
 	struct sbuf **sbuf;
 	int attr;
 	assert(pkg != NULL);
 	assert(attr < PKG_NUM_FIELDS);
 	assert(value != NULL || fields[attr].optional == 1);
 	while ((attr = va_arg(ap, int)) != -1) {
 		if (attr < PKG_NUM_FIELDS) {
 			struct sbuf **sbuf;
 			const char *str = va_arg(ap, const char *);
 	if (value == NULL)
 		value = "";
 			sbuf = &pkg->fields[attr];
 	sbuf = &pkg->fields[attr];
 			if (str == NULL)
 				str = "";
 	/*
 	 * Ensure that mtree begins with `#mtree` so libarchive
 	 * could handle it
 	 */
 	if (attr == PKG_MTREE && !STARTS_WITH(value, "#mtree")) {
 		sbuf_set(sbuf, "#mtree\n");
 		sbuf_cat(*sbuf, value);
 		sbuf_finish(*sbuf);
 		return (EPKG_OK);
 			if (attr == PKG_MTREE && !STARTS_WITH(str, "#mtree")) {
 				sbuf_set(sbuf, "#mtree\n");
 				sbuf_cat(*sbuf, str);
 				sbuf_finish(*sbuf);
 				continue;
 			}
 			if (attr == PKG_REPONAME)
 				pkg_add_repo_url(pkg, str);
 			sbuf_set(sbuf, str);
 			continue;
 		}
 		switch (attr) {
 			case PKG_AUTOMATIC:
 				pkg->automatic = va_arg(ap, int);
 				break;
 			case PKG_LICENSE_LOGIC:
 				pkg->licenselogic = va_arg(ap, lic_t);
 				break;
 			case PKG_FLATSIZE:
 				pkg->flatsize = va_arg(ap, int64_t);
 				break;
 			case PKG_NEW_FLATSIZE:
 				pkg->new_flatsize = va_arg(ap, int64_t);
 				break;
 			case PKG_NEW_PKGSIZE:
 				pkg->new_pkgsize = va_arg(ap, int64_t);
 				break;
 			case PKG_ROWID:
 				pkg->rowid = va_arg(ap, int64_t);
 				break;
 			default:
 				va_arg(ap, void *); /* ignore */
 				break;
 		}
 	}
 	/*
 	 * Insert the repository URL as well when inserting the repo name
 	 */
 	if (attr == PKG_REPONAME)
 		pkg_add_repo_url(pkg, value);
 	return (EPKG_OK);
 }
 int
 pkg_set2(struct pkg *pkg, ...)
 {
 	int ret = EPKG_OK;
 	va_list ap;
 	assert(pkg != NULL);
 	va_start(ap, pkg);
 	ret = pkg_vset(pkg, ap);
 	va_end(ap);
 	return (sbuf_set(sbuf, value));
 	return (ret);
 }
 int

@@ -240,6 +280,7 @@ pkg_set_mtree(struct pkg *pkg, const char *mtree) {

 	return (pkg_set(pkg, PKG_MTREE, mtree));
 }
 int
 pkg_set_from_file(struct pkg *pkg, pkg_attr attr, const char *path)
 {

@@ -260,63 +301,6 @@ pkg_set_from_file(struct pkg *pkg, pkg_attr attr, const char *path)

 	return (ret);
 }
 int
 pkg_set_automatic(struct pkg *pkg)
 {
 	assert(pkg != NULL);
 	pkg->automatic = true;
 	return (EPKG_OK);
 }
 int
 pkg_set_flatsize(struct pkg *pkg, int64_t size)
 {
 	assert(pkg != NULL);
 	assert(size >= 0);
 	pkg->flatsize = size;
 	return (EPKG_OK);
 }
 int
 pkg_set_newflatsize(struct pkg *pkg, int64_t size)
 {
 	assert(pkg != NULL);
 	assert(size >= 0);
 	pkg->new_flatsize = size;
 	return (EPKG_OK);
 }
 int
 pkg_set_newpkgsize(struct pkg *pkg, int64_t size)
 {
 	assert(pkg != NULL);
 	assert(size >= 0);
 	pkg->new_pkgsize = size;
 	return (EPKG_OK);
 }
 int
 pkg_set_licenselogic(struct pkg *pkg, int64_t logic)
 {
 	assert(pkg != NULL);
 	pkg->licenselogic = logic;
 	return (EPKG_OK);
 }
 int
 pkg_set_rowid(struct pkg *pkg, int64_t rowid) {
 	assert(pkg != NULL);
 	pkg->rowid = rowid;
 	return (EPKG_OK);
 }
 #define PKG_LIST_NEXT(head, data) do { \
 		if (data == NULL) \
 			data = STAILQ_FIRST(head); \

modified libpkg/pkg.h

@@ -138,7 +138,8 @@ typedef enum {

 	PKG_NEW_FLATSIZE,
 	PKG_NEW_PKGSIZE,
 	PKG_LICENSE_LOGIC,
 	PKG_AUTOMATIC
 	PKG_AUTOMATIC,
 	PKG_ROWID,
 } pkg_attr;
 /**

@@ -363,39 +364,16 @@ int pkg_analyse_files(struct pkgdb *, struct pkg *);

 /**
  * Generic setter for simple attributes.
  */
 int pkg_set(struct pkg *pkg, pkg_attr attr, const char *value);
 int pkg_set_mtree(struct pkg *pkg, const char *value);
 int pkg_set2(struct pkg *pkg, ...);
 #define pkg_set(pkg, ...) pkg_set2(pkg, __VA_ARGS__, -1)
 /*int pkg_set(struct pkg *pkg, pkg_attr attr, const char *value);*/
 /**
  * Read the content of a file into a buffer, then call pkg_set().
  */
 int pkg_set_from_file(struct pkg *pkg, pkg_attr attr, const char *file);
 int pkg_set_automatic(struct pkg *pkg);
 /**
  * set the logic for license combinaison
  */
 int pkg_set_licenselogic(struct pkg *pkg, int64_t licenselogic);
 /**
  * Set the uncompressed size of the package.
  * @return An error code.
  */
 int pkg_set_flatsize(struct pkg *pkg, int64_t size);
 /**
  * Set the uncompressed size of the package, in its futur version.
  * @return An error code.
  */
 int pkg_set_newflatsize(struct pkg *pkg, int64_t size);
 /**
  * Set the compressed size of the package, in its futur version.
  * @return An error code.
  */
 int pkg_set_newpkgsize(struct pkg *pkg, int64_t size);
 /**
  * Allocate a new struct pkg and add it to the deps of pkg.
  * @return An error code.

modified libpkg/pkg_add.c

@@ -113,7 +113,7 @@ pkg_add(struct pkgdb *db, const char *path, int flags)

 	}
 	if (flags & PKG_ADD_AUTOMATIC)
 		pkg_set_automatic(pkg);
 		pkg_set(pkg, PKG_AUTOMATIC, true);
 	if (uname(&u) != 0) {
 		pkg_emit_errno("uname", "");

modified libpkg/pkg_manifest.c

@@ -183,17 +183,17 @@ pkg_set_flatsize_from_node(struct pkg *pkg, yaml_node_t *val, __unused yaml_docu

 		return (EPKG_FATAL);
 	}
 	return (pkg_set_flatsize(pkg, flatsize));
 	return (pkg_set(pkg, PKG_FLATSIZE, flatsize));
 }
 static int
 pkg_set_licenselogic_from_node(struct pkg *pkg, yaml_node_t *val, __unused yaml_document_t *doc, __unused int attr)
 {
 	if (!strcmp(val->data.scalar.value, "single"))
 		pkg_set_licenselogic(pkg, LICENSE_SINGLE);
 		pkg_set(pkg, PKG_LICENSE_LOGIC, LICENSE_SINGLE);
 	else if ( !strcmp(val->data.scalar.value, "and") || !strcmp(val->data.scalar.value, "dual"))
 		pkg_set_licenselogic(pkg, LICENSE_AND);
 		pkg_set(pkg, PKG_LICENSE_LOGIC, LICENSE_AND);
 	else if ( !strcmp(val->data.scalar.value, "or") || !strcmp(val->data.scalar.value, "multi"))
 		pkg_set_licenselogic(pkg, LICENSE_OR);
 		pkg_set(pkg, PKG_LICENSE_LOGIC, LICENSE_OR);
 	else {
 		pkg_emit_error("Unknown license logic: %s", val->data.scalar.value);
 		return (EPKG_FATAL);

@@ -676,10 +676,10 @@ pkg_emit_manifest(struct pkg *pkg, char **dest)

 	mapping = yaml_document_add_mapping(&doc, NULL, YAML_BLOCK_MAPPING_STYLE);
 	pkg_get(pkg, PKG_NAME, &name, PKG_ORIGIN, &pkgorigin, PKG_COMMENT, &comment,
 	    PKG_ARCH, &pkgarch, PKG_OSVERSION, osversion, PKG_WWW, &www,
 	    PKG_ARCH, &pkgarch, PKG_OSVERSION, &osversion, PKG_WWW, &www,
 	    PKG_MAINTAINER, &pkgmaintainer, PKG_PREFIX, &prefix,
 	    PKG_LICENSE_LOGIC, &licenselogic, PKG_DESC, &desc,
 	    PKG_FLATSIZE, &flatsize);
 	    PKG_FLATSIZE, &flatsize, PKG_MESSAGE, &message, PKG_VERSION, &version);
 	manifest_append_kv(mapping, "name", name);
 	manifest_append_kv(mapping, "version", version);
 	manifest_append_kv(mapping, "origin", pkgorigin);

modified libpkg/pkg_ports.c

@@ -318,7 +318,7 @@ ports_parse_plist(struct pkg *pkg, char *plist)

 		}
 	}
 	pkg_set_flatsize(pkg, flatsize);
 	pkg_set(pkg, PKG_FLATSIZE, flatsize);
 	if (sbuf_len(pre_unexec_scripts) > 0) {
 		sbuf_finish(unexec_scripts);

modified libpkg/pkg_private.h

@@ -192,7 +192,7 @@ int pkgdb_integrity_append(struct pkgdb *db, struct pkg *p);

 int pkgdb_integrity_check(struct pkgdb *db);
 struct pkgdb_it *pkgdb_integrity_conflict_local(struct pkgdb *db, const char *origin);
 int pkg_set_rowid(struct pkg *, int64_t rowid);
 int pkg_set_mtree(struct pkg *, const char *mtree);
 /* pkgdb commands */
 int sql_exec(sqlite3 *, const char *, ...);

modified libpkg/pkg_repo.c

@@ -84,7 +84,7 @@ pkg_repo_fetch(struct pkg *pkg)

 		return (EPKG_FATAL);
 	pkg_get(pkg, PKG_REPOPATH, &repopath, PKG_REPOURL, &repourl,
 	    PKG_CKSUM, &sum);
 	    PKG_CKSUM, &sum, PKG_NAME, &name, PKG_VERSION, &version);
 	/* If it is already in the local cachedir, dont bother to download it */
 	if (access(dest, F_OK) == 0)

@@ -660,7 +660,8 @@ pkg_create_repo(char *path, void (progress)(struct pkg *pkg, void *data), void *

 		    PKG_COMMENT, &comment, PKG_DESC, &desc, PKG_ARCH, &arch,
 		    PKG_MAINTAINER, &maintainer, PKG_WWW, &www, PKG_PREFIX, &prefix,
 		    PKG_FLATSIZE, &flatsize, PKG_LICENSE_LOGIC, &licenselogic,
 		    -1);
 		    PKG_OSVERSION, &osversion);
 		sqlite3_bind_text(stmt_pkg, 1, origin, -1, SQLITE_STATIC);
 		sqlite3_bind_text(stmt_pkg, 2, name, -1, SQLITE_STATIC);
 		sqlite3_bind_text(stmt_pkg, 3, version, -1, SQLITE_STATIC);

modified libpkg/pkgdb.c

@@ -38,41 +38,33 @@ static int pkgdb_repos_new(struct pkgdb *, struct pkg_repos **);

 static void populate_pkg(sqlite3_stmt *stmt, struct pkg *pkg);
 static int create_temporary_pkgjobs(sqlite3 *);
 static struct column_text_mapping {
 static struct column_mapping {
 	const char * const name;
 	int (*set_text)(struct pkg *pkg, pkg_attr, const char *);
 	pkg_attr type;
 } columns_text[] = {
 	{ "origin", pkg_set, PKG_ORIGIN},
 	{ "name", pkg_set, PKG_NAME },
 	{ "version", pkg_set, PKG_VERSION },
 	{ "comment", pkg_set, PKG_COMMENT },
 	{ "desc", pkg_set, PKG_DESC },
 	{ "message", pkg_set, PKG_MESSAGE },
 	{ "arch", pkg_set, PKG_ARCH },
 	{ "osversion", pkg_set, PKG_OSVERSION},
 	{ "maintainer", pkg_set, PKG_MAINTAINER},
 	{ "www", pkg_set, PKG_WWW},
 	{ "prefix", pkg_set, PKG_PREFIX},
 	{ "cksum", pkg_set, PKG_CKSUM},
 	{ "repopath", pkg_set, PKG_REPOPATH},
 	{ "dbname", pkg_set, PKG_REPONAME},
 	{ "newversion", pkg_set, PKG_NEWVERSION},
 	{ NULL, NULL, -1 }
 };
 static struct column_int_mapping {
 	const char * const name;
 	int (*set_int)(struct pkg *pkg, int64_t);
 } columns_int[] = {
 	{ "flatsize", pkg_set_flatsize },
 	{ "newflatsize", pkg_set_newflatsize },
 	{ "pkgsize", pkg_set_newpkgsize },
 	{ "licenselogic", pkg_set_licenselogic},
 	{ "rowid", pkg_set_rowid},
 	{ "id", pkg_set_rowid },
 	{ "weight", NULL },
 	{ NULL, NULL}
 } columns[] = {
 	{ "origin", PKG_ORIGIN},
 	{ "name", PKG_NAME },
 	{ "version", PKG_VERSION },
 	{ "comment", PKG_COMMENT },
 	{ "desc", PKG_DESC },
 	{ "message", PKG_MESSAGE },
 	{ "arch", PKG_ARCH },
 	{ "osversion", PKG_OSVERSION},
 	{ "maintainer", PKG_MAINTAINER},
 	{ "www", PKG_WWW},
 	{ "prefix", PKG_PREFIX},
 	{ "cksum", PKG_CKSUM},
 	{ "repopath", PKG_REPOPATH},
 	{ "dbname", PKG_REPONAME},
 	{ "newversion", PKG_NEWVERSION},
 	{ "flatsize", PKG_FLATSIZE },
 	{ "newflatsize", PKG_NEW_FLATSIZE },
 	{ "pkgsize", PKG_NEW_PKGSIZE },
 	{ "licenselogic", PKG_LICENSE_LOGIC},
 	{ "rowid", PKG_ROWID},
 	{ "id", PKG_ROWID },
 	{ "weight", -1 },
 	{ NULL, -1 }
 };
 static int

@@ -121,29 +113,23 @@ populate_pkg(sqlite3_stmt *stmt, struct pkg *pkg) {

 		colname = sqlite3_column_name(stmt, icol);
 		switch (sqlite3_column_type(stmt, icol)) {
 			case SQLITE_TEXT:
 				for (i = 0; columns_text[i].name != NULL; i++ ) {
 					if (!strcmp(columns_text[i].name, colname)) {
 						columns_text[i].set_text(pkg, columns_text[i].type, sqlite3_column_text(stmt, icol));
 				for (i = 0; columns[i].name != NULL; i++ ) {
 					if (!strcmp(columns[i].name, colname)) {
 						pkg_set(pkg, columns[i].type, sqlite3_column_text(stmt, icol));
 						break;
 					}
 				}
 				if (columns_text[i].name == NULL)
 				if (columns[i].name == NULL)
 					pkg_emit_error("Unknown column %s", colname);
 				break;
 			case SQLITE_INTEGER:
 				for (i = 0; columns_int[i].name != NULL; i++ ) {
 					if (!strcmp(columns_int[i].name, colname)) {
 						if (columns_int[i].set_int != NULL)
 							columns_int[i].set_int(pkg, sqlite3_column_int64(stmt, icol));
 				for (i = 0; columns[i].name != NULL; i++ ) {
 					if (!strcmp(columns[i].name, colname)) {
 						pkg_set(pkg, columns[i].type, sqlite3_column_int64(stmt, icol));
 						break;
 					}
 				}
 				if (strcmp(colname, "automatic") == 0) {
 					if (sqlite3_column_int64(stmt, icol) == 1)
 						pkg_set_automatic(pkg);
 					break;
 				}
 				if (columns_int[i].name == NULL)
 				if (columns[i].name == NULL)
 					pkg_emit_error("Unknown column %s", colname);
 				break;
 			case SQLITE_BLOB:

@@ -1464,7 +1450,8 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg, int complete)

 	    PKG_COMMENT, &comment, PKG_DESC, &desc, PKG_MESSAGE, &message,
 	    PKG_ARCH, &arch, PKG_OSVERSION, &osversion, PKG_MAINTAINER, &maintainer,
 	    PKG_WWW, &www, PKG_PREFIX, &prefix, PKG_FLATSIZE, &flatsize,
 	    PKG_AUTOMATIC, &automatic, PKG_LICENSE_LOGIC, &licenselogic);
 	    PKG_AUTOMATIC, &automatic, PKG_LICENSE_LOGIC, &licenselogic,
 	    PKG_NAME, &name);
 	sqlite3_bind_text(stmt_mtree, 1, mtree, -1, SQLITE_STATIC);

modified pkg/delete.c

@@ -93,6 +93,7 @@ exec_delete(int argc, char **argv)

 	while (pkgdb_it_next(it, &pkg, flags) == EPKG_OK) {
 		int64_t flatsize, newflatsize;
 		pkg_get(pkg, PKG_FLATSIZE, &flatsize, PKG_NEW_FLATSIZE, &newflatsize);
 		oldsize += flatsize;
 		newsize += newflatsize;
 		pkg_jobs_add(jobs, pkg);

modified pkg/register.c

@@ -96,7 +96,7 @@ exec_register(int argc, char **argv)

 					err(1, "cannot allocate memory");
 				break;
 			case 'd':
 				pkg_set_automatic(pkg);
 				pkg_set(pkg, PKG_AUTOMATIC, true);
 				break;
 			case 'i':
 				if ((input_path = strdup(optarg)) == NULL)

@@ -199,7 +199,7 @@ exec_register(int argc, char **argv)

 		retcode = EPKG_FATAL;
 	}
 	pkg_get(pkg, PKG_MESSAGE, message);
 	pkg_get(pkg, PKG_MESSAGE, &message);
 	if (message != NULL && !legacy)
 		printf("%s\n", message);

modified pkg/version.c

@@ -282,6 +282,7 @@ exec_version(int argc, char **argv)

 		while (pkgdb_it_next(it, &pkg, PKG_LOAD_BASIC) == EPKG_OK) {
 			cmd = sbuf_new_auto();
 			pkg_get(pkg, PKG_ORIGIN, &origin);
 			sbuf_printf(cmd, "make -C %s/%s -VPKGVERSION", portsdir, origin);
 			sbuf_finish(cmd);
 			if ((res = exec_buf(sbuf_data(cmd))) != NULL) {

modified pkg2legacy/pkg2legacy.c

@@ -109,6 +109,8 @@ main(int argc, char **argv)

 	ae = archive_entry_new();
 	while ((p = fts_read(fts)) != NULL) {
 		const char *name, *version, *origin, *prefix, *comment, *maintainer;
 		const char *www;
 		if (!strcmp(p->fts_name, "repo.txz"))
 			continue;

@@ -119,7 +121,12 @@ main(int argc, char **argv)

 			continue;
 		}
 		printf("Generating %s-%s.tbz...", pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION));
 		pkg_get(pkg, PKG_NAME, &name, PKG_VERSION, &version,
 		    PKG_ORIGIN, &origin, PKG_PREFIX, &prefix, PKG_COMMENT, &comment,
 		    PKG_MAINTAINER, &maintainer, PKG_WWW, &www);
 		printf("Generating %s-%s.tbz...", name, version);
 		fflush(stdout);
 		archive_entry_clear(ae);

@@ -131,21 +138,17 @@ main(int argc, char **argv)

 				"%s|" /* comment */
 				"/usr/ports/%s/pkg-descr|" /* origin */
 				"%s|", /*maintainer */
 				pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION),
 				pkg_get(pkg, PKG_ORIGIN),
 				pkg_get(pkg, PKG_PREFIX),
 				pkg_get(pkg, PKG_COMMENT),
 				pkg_get(pkg, PKG_ORIGIN),
 				pkg_get(pkg, PKG_MAINTAINER)
 				name, version, origin, prefix,
 				comment, origin, maintainer
 			   );
 		while (pkg_categories(pkg, &cat) == EPKG_OK)
 			sbuf_printf(indexfile, "%s ", pkg_category_name(cat));
 		sbuf_cat(indexfile, "||");
 		snprintf(destpath, sizeof(destpath), "%s/All/%s-%s.tbz", destdir, pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION));
 		snprintf(relativepath, sizeof(relativepath), "../All/%s-%s.tbz", pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION));
 		snprintf(linkpath, sizeof(linkpath), "%s/Latest/%s.tbz",destdir, pkg_get(pkg, PKG_NAME));
 		snprintf(destpath, sizeof(destpath), "%s/All/%s-%s.tbz", destdir, name, version);
 		snprintf(relativepath, sizeof(relativepath), "../All/%s-%s.tbz", name, version);
 		snprintf(linkpath, sizeof(linkpath), "%s/Latest/%s.tbz",destdir, name);
 		pkgng = archive_read_new();
 		archive_read_support_format_tar(pkgng);

@@ -162,9 +165,9 @@ main(int argc, char **argv)

 		archive_entry_set_perm(ae, 0644);
 		archive_entry_set_gname(ae, "wheel");
 		archive_entry_set_uname(ae, "root");
 		archive_entry_set_size(ae, strlen(pkg_get(pkg, PKG_COMMENT)));
 		archive_entry_set_size(ae, strlen(comment));
 		archive_write_header(legacypkg, ae);
 		archive_write_data(legacypkg, pkg_get(pkg, PKG_COMMENT), strlen(pkg_get(pkg, PKG_COMMENT)));
 		archive_write_data(legacypkg, comment, strlen(comment));
 		sbuf_clear(sbuf);
 		sbuf_clear(late_sbuf);

@@ -173,10 +176,7 @@ main(int argc, char **argv)

 				"@comment ORIGIN:%s\n"
 				"@cwd %s\n"
 				"@cwd /\n",
 				pkg_get(pkg, PKG_NAME),
 				pkg_get(pkg, PKG_VERSION),
 				pkg_get(pkg, PKG_ORIGIN),
 				pkg_get(pkg, PKG_PREFIX));
 				name, version, origin, prefix);
 		while (pkg_deps(pkg, &dep) == EPKG_OK) {
 			sbuf_printf(sbuf, "@pkgdep %s-%s\n"

@@ -192,7 +192,7 @@ main(int argc, char **argv)

 				"|" /* extract depends */
 				"|" /* patch depends */
 				"\n", /* fetch depends */
 				pkg_get(pkg, PKG_WWW));
 				www);
 		while (pkg_scripts(pkg, &script) == EPKG_OK) {
 			archive_entry_clear(ae);
 			switch (pkg_script_type(script)) {

@@ -363,7 +363,7 @@ main(int argc, char **argv)

 			snprintf(destpath, sizeof(destpath), "%s/%s", destdir, pkg_category_name(cat));
 			if (lstat(destpath, &st) != 0)
 				mkdir(destpath, 0755);
 			snprintf(linkpath, sizeof(linkpath), "%s/%s/%s-%s.tbz", destdir, pkg_category_name(cat), pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION));
 			snprintf(linkpath, sizeof(linkpath), "%s/%s/%s-%s.tbz", destdir, pkg_category_name(cat), name, version);
 			symlink(relativepath, linkpath);
 		}