Radish alpha
H
HardenedBSD-pkg
HardenedBSD Package Manager
Radicle
Git (anonymous pull)
Log in to clone via SSH
Commits ›
complte struct pkg to allow have all the required informations except license because we don't know yet how to handle it
Baptiste Daroussin committed 15 years ago
commit 997b4ecdfb403a5632ea1e16ee22e5cc22737262
parent a7298b65f4d4cec502389a8014ed8f58ab4ab6e1
8 files changed +229 -19
modified libpkg/Makefile
@@ -14,6 +14,7 @@ SRCS= pkg.c \
		pkg_exec.c \

		pkg_file.c \

		pkg_manifest.c \
+ 
		pkg_option.c \

		pkg_ports.c \

		pkg_version.c \

		util.c
modified libpkg/pkg.c
@@ -33,6 +33,14 @@ pkg_get(struct pkg *pkg, pkg_attr attr) {
			return (sbuf_get(pkg->mtree));

		case PKG_MESSAGE:

			return (sbuf_get(pkg->message));
+ 
		case PKG_ARCH:
+ 
			return (sbuf_get(pkg->arch));
+ 
		case PKG_OSVERSION:
+ 
			return (sbuf_get(pkg->osversion));
+ 
		case PKG_MAINTAINER:
+ 
			return (sbuf_get(pkg->maintainer));
+ 
		case PKG_WWW:
+ 
			return (sbuf_get(pkg->www));

	}



	return (NULL);
@@ -59,6 +67,14 @@ pkg_set(struct pkg *pkg, pkg_attr attr, const char *value)
			return (sbuf_set(&pkg->mtree, value));

		case PKG_MESSAGE:

			return (sbuf_set(&pkg->message, value));
+ 
		case PKG_ARCH:
+ 
			return (sbuf_set(&pkg->arch, value));
+ 
		case PKG_OSVERSION:
+ 
			return (sbuf_set(&pkg->osversion, value));
+ 
		case PKG_MAINTAINER:
+ 
			return (sbuf_set(&pkg->maintainer, value));
+ 
		case PKG_WWW:
+ 
			return (sbuf_set(&pkg->www, value));

	}



	return (-1);
@@ -98,6 +114,12 @@ pkg_deps(struct pkg *pkg)
	return ((struct pkg **)pkg->deps.data);

}
+ 
struct pkg_option **
+ 
pkg_options(struct pkg *pkg)
+ 
{
+ 
	return ((struct pkg_option **)pkg->options.data);
+ 
}
+ 


int

pkg_resolvdeps(struct pkg *pkg, struct pkgdb *db) {

	struct pkg *p;
@@ -239,6 +261,10 @@ pkg_reset(struct pkg *pkg)
	sbuf_reset(pkg->desc);

	sbuf_reset(pkg->mtree);

	sbuf_reset(pkg->message);
+ 
	sbuf_reset(pkg->arch);
+ 
	sbuf_reset(pkg->osversion);
+ 
	sbuf_reset(pkg->maintainer);
+ 
	sbuf_reset(pkg->www);



	array_reset(&pkg->deps, &pkg_free_void);

	array_reset(&pkg->rdeps, &pkg_free_void);
@@ -246,6 +272,7 @@ pkg_reset(struct pkg *pkg)
	array_reset(&pkg->files, &free);

	array_reset(&pkg->scripts, &pkg_script_free_void);

	array_reset(&pkg->exec, &pkg_exec_free_void);
+ 
	array_reset(&pkg->options, &pkg_option_free_void);

}



void
@@ -261,6 +288,10 @@ pkg_free(struct pkg *pkg)
	sbuf_free(pkg->desc);

	sbuf_free(pkg->mtree);

	sbuf_free(pkg->message);
+ 
	sbuf_free(pkg->arch);
+ 
	sbuf_free(pkg->osversion);
+ 
	sbuf_free(pkg->maintainer);
+ 
	sbuf_free(pkg->www);



	array_free(&pkg->deps, &pkg_free_void);

	array_free(&pkg->rdeps, &pkg_free_void);
@@ -268,6 +299,7 @@ pkg_free(struct pkg *pkg)
	array_free(&pkg->files, &free);

	array_free(&pkg->scripts, &pkg_script_free_void);

	array_free(&pkg->exec, &pkg_exec_free_void);
+ 
	array_free(&pkg->options, &pkg_option_free_void);



	free(pkg);

}
@@ -349,6 +381,25 @@ pkg_addexec(struct pkg *pkg, const char *cmd, pkg_exec_t type)
}



int
+ 
pkg_addoption(struct pkg *pkg, const char *opt, const char *value)
+ 
{
+ 
	struct pkg_option *option;
+
+ 
	if (opt == NULL || opt[0] == '\0' || value == NULL || value[0] == '\0')
+ 
		return (-1);
+
+ 
	pkg_option_new(&option);
+
+ 
	sbuf_set(&option->opt, opt);
+ 
	sbuf_set(&option->value, value);
+
+ 
	array_init(&pkg->options, 5);
+ 
	array_append(&pkg->options, option);
+
+ 
	return (0);
+ 
}
+
+ 
int

pkg_adddep(struct pkg *pkg, const char *name, const char *origin, const char *version)

{

	struct pkg *dep;
modified libpkg/pkg.h
@@ -32,7 +32,11 @@ typedef enum {
	PKG_COMMENT,

	PKG_DESC,

	PKG_MTREE,
- 
	PKG_MESSAGE
+ 
	PKG_MESSAGE,
+ 
	PKG_ARCH,
+ 
	PKG_OSVERSION,
+ 
	PKG_MAINTAINER,
+ 
	PKG_WWW

} pkg_attr;



typedef enum {
@@ -65,6 +69,7 @@ struct pkg_file ** pkg_files(struct pkg *);
struct pkg_conflict ** pkg_conflicts(struct pkg *);

struct pkg_script ** pkg_scripts(struct pkg *);

struct pkg_exec ** pkg_execs(struct pkg *);
+ 
struct pkg_option ** pkg_options(struct pkg *);

int pkg_resolvdeps(struct pkg *, struct pkgdb *db);



/* pkg setters */
@@ -75,6 +80,7 @@ int pkg_addfile(struct pkg *, const char *, const char *);
int pkg_addconflict(struct pkg *, const char *);

int pkg_addexec(struct pkg *, const char *, pkg_exec_t);

int pkg_addscript(struct pkg *, const char *);
+ 
int pkg_addoption(struct pkg *, const char *, const char *);



/* pkg_manifest */

int pkg_parse_manifest(struct pkg *, char *);
@@ -106,6 +112,13 @@ void pkg_exec_free(struct pkg_exec *);
const char *pkg_exec_cmd(struct pkg_exec *);

pkg_exec_t pkg_exec_type(struct pkg_exec *);
+ 
/* pkg_option */
+ 
int pkg_option_new(struct pkg_option **);
+ 
void pkg_option_reset(struct pkg_option *);
+ 
void pkg_option_free(struct pkg_option *);
+ 
const char *pkg_option_opt(struct pkg_option *);
+ 
const char *pkg_option_value(struct pkg_option *);
+ 


/* pkgdb */

int pkgdb_open(struct pkgdb **);

void pkgdb_close(struct pkgdb *);
@@ -121,6 +134,7 @@ 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 *);
+ 
struct pkgdb_it * pkgdb_query_options(struct pkgdb *, const char *);



#define PKG_BASIC 0

#define PKG_DEPS (1<<0)
@@ -129,13 +143,15 @@ struct pkgdb_it * pkgdb_query_scripts(struct pkgdb *, const char *);
#define PKG_FILES (1<<3)

#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
+ 
#define PKG_OPTIONS (1<<6)
+ 
#define PKG_ALL PKG_BASIC|PKG_DEPS|PKG_RDEPS|PKG_CONFLICTS|PKG_FILES|PKG_EXECS|PKG_SCRIPTS|PKG_OPTIONS



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 **);
+ 
int pkgdb_it_next_option(struct pkgdb_it *, struct pkg_option **);

void pkgdb_it_free(struct pkgdb_it *);



const char *pkgdb_get_dir(void);
added libpkg/pkg_option.c
@@ -0,0 +1,45 @@
+ 
#include <stdlib.h>
+
+ 
#include "pkg.h"
+ 
#include "pkg_private.h"
+
+ 
const char *
+ 
pkg_option_opt(struct pkg_option *option)
+ 
{
+ 
	return (sbuf_get(option->opt));
+ 
}
+
+ 
const char *
+ 
pkg_option_value(struct pkg_option *option)
+ 
{
+ 
	return (sbuf_get(option->value));
+ 
}
+
+ 
int
+ 
pkg_option_new(struct pkg_option **option)
+ 
{
+ 
	if ((*option = calloc(1, sizeof(struct pkg_option))))
+ 
		return (-1);
+ 
	return (0);
+ 
}
+
+ 
void
+ 
pkg_option_reset(struct pkg_option *option)
+ 
{
+ 
	sbuf_reset(option->opt);
+ 
	sbuf_reset(option->value);
+ 
}
+
+ 
void
+ 
pkg_option_free(struct pkg_option *option)
+ 
{
+ 
	sbuf_free(option->opt);
+ 
	sbuf_free(option->value);
+ 
}
+
+ 
void
+ 
pkg_option_free_void(void *o)
+ 
{
+ 
	if (o != NULL)
+ 
		pkg_option_free((struct pkg_option *)o);
+ 
}
modified libpkg/pkg_private.h
@@ -15,12 +15,17 @@ struct pkg {
	struct sbuf *desc;

	struct sbuf *mtree;

	struct sbuf *message;
+ 
	struct sbuf *arch;
+ 
	struct sbuf *osversion;
+ 
	struct sbuf *maintainer;
+ 
	struct sbuf *www;

	struct array deps;

	struct array rdeps;

	struct array conflicts;

	struct array files;

	struct array scripts;

	struct array exec;
+ 
	struct array options;

	pkg_t type;

};
@@ -43,8 +48,14 @@ struct pkg_file {
	char sha256[65];

};
+ 
struct pkg_option {
+ 
	struct sbuf *opt;
+ 
	struct sbuf *value;
+ 
};
+ 


void pkg_conflict_free_void(void *);

void pkg_script_free_void(void *);

void pkg_exec_free_void(void *);
+ 
void pkg_option_free_void(void *);



#endif
modified libpkg/pkgdb.c
@@ -118,6 +118,10 @@ pkgdb_init(sqlite3 *sdb)
		"desc TEXT,"

		"mtree TEXT,"

		"message TEXT,"
+ 
		"arch TEXT,"
+ 
		"osversion TEXT,"
+ 
		"maintainer TEXT,"
+ 
		"www TEXT,"

		"automatic INTEGER,"

		"pkg_format_version INTEGER"

	");"
@@ -136,8 +140,8 @@ pkgdb_init(sqlite3 *sdb)
	"CREATE INDEX exec_package ON exec (package_id);"

	"CREATE TABLE options ("

		"package_id TEXT REFERENCES packages(origin) ON DELETE CASCADE, "
- 
		"name TEXT,"
- 
		"with INTEGER,"
+ 
		"option TEXT,"
+ 
		"value TEXT,"

		"PRIMARY KEY (package_id,name)"

	");"

	"CREATE INDEX options_package ON options (package_id);"
@@ -240,6 +244,7 @@ pkgdb_it_next_pkg(struct pkgdb_it *it, struct pkg **pkg_p, int flags)
	struct pkg_file *f;

	struct pkg_exec *e;

	struct pkg_script *s;
+ 
	struct pkg_option *o;

	struct pkgdb_it *i;



	assert(it->type == IT_PKG);
@@ -259,6 +264,11 @@ pkgdb_it_next_pkg(struct pkgdb_it *it, struct pkg **pkg_p, int flags)
		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));
+ 
		pkg_set(pkg, PKG_MESSAGE, sqlite3_column_text(it->stmt, 6));
+ 
		pkg_set(pkg, PKG_ARCH, sqlite3_column_text(it->stmt, 7));
+ 
		pkg_set(pkg, PKG_OSVERSION, sqlite3_column_text(it->stmt, 8));
+ 
		pkg_set(pkg, PKG_MAINTAINER, sqlite3_column_text(it->stmt, 9));
+ 
		pkg_set(pkg, PKG_WWW, sqlite3_column_text(it->stmt, 10));



		if (flags & PKG_DEPS) {

			array_init(&pkg->deps, 10);
@@ -331,6 +341,17 @@ pkgdb_it_next_pkg(struct pkgdb_it *it, struct pkg **pkg_p, int flags)
			}

			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) == 0) {
+ 
				array_append(&pkg->options, o);
+ 
				o = NULL;
+ 
			}
+ 
			pkgdb_it_free(i);
+ 
		}

		return (0);

	case SQLITE_DONE:

		return (1);
@@ -444,6 +465,32 @@ pkgdb_it_next_script (struct pkgdb_it *it, struct pkg_script **script_p)
	}

}
+ 
int
+ 
pkgdb_it_next_option (struct pkgdb_it *it, struct pkg_option **option_p)
+ 
{
+ 
	struct pkg_option *option;
+
+ 
	assert(it->type == IT_OPTION);
+
+ 
	switch (sqlite3_step(it->stmt)) {
+ 
		case SQLITE_ROW:
+ 
			if (*option_p == NULL)
+ 
				pkg_option_new(option_p);
+ 
			else
+ 
				pkg_option_reset(*option_p);
+
+ 
			option = *option_p;
+ 
			sbuf_set(&option->opt, sqlite3_column_text(it->stmt, 0));
+ 
			sbuf_set(&option->value, sqlite3_column_text(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)

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



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



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



	sqlite3_prepare(db->sqlite,
- 
					"SELECT origin, name, version, comment, desc, mtree FROM packages, files "
+ 
					"SELECT origin, name, version, comment, desc, mtree, message, arch, osversion, maintainer, www,  FROM packages, files "

					"WHERE origin = files.package_id "

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

	sqlite3_bind_text(stmt, 1, path, -1, SQLITE_TRANSIENT);
@@ -605,6 +652,19 @@ pkgdb_query_scripts(struct pkgdb *db, const char *origin) {
	return (pkgdb_it_new(db, stmt, IT_SCRIPT));

}
+ 
struct pkgdb_it *
+ 
pkgdb_query_options(struct pkgdb *db, const char *origin) {
+ 
	sqlite3_stmt *stmt;
+ 
	sqlite3_prepare(db->sqlite,
+ 
			"SELECT option, value "
+ 
			"FROM options "
+ 
			"WHERE package_id = ?1", -1, &stmt, NULL);
+
+ 
	sqlite3_bind_text(stmt, 1, origin, -1, SQLITE_TRANSIENT);
+
+ 
	return (pkgdb_it_new(db, stmt, IT_OPTION));
+ 
}
+ 


void

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

{
@@ -637,12 +697,14 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg)
	struct pkg_conflict **conflicts;

	struct pkg_exec **execs;

	struct pkg_script **scripts;
+ 
	struct pkg_option **options;

	sqlite3_stmt *stmt_pkg;

	sqlite3_stmt *stmt_dep;

	sqlite3_stmt *stmt_conflicts;

	sqlite3_stmt *stmt_file;

	sqlite3_stmt *stmt_exec;

	sqlite3_stmt *stmt_scripts;
+ 
	sqlite3_stmt *stmt_options;

	int i;



	sqlite3_exec(db->sqlite, "BEGIN TRANSACTION;", NULL, NULL, NULL);
@@ -671,6 +733,9 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg)
			"values (?1, ?2, ?3);",

			-1, &stmt_exec, NULL);
+ 
	sqlite3_prepare(db->sqlite, "INSERT INTO options (option, value, package_id)"
+ 
			"values (?1, ?2, ?3);",
+ 
			-1, &stmt_options, NULL);



	sqlite3_bind_text(stmt_pkg, 1, pkg_get(pkg, PKG_ORIGIN), -1, SQLITE_STATIC);

	sqlite3_bind_text(stmt_pkg, 2, pkg_get(pkg, PKG_NAME), -1, SQLITE_STATIC);
@@ -682,9 +747,7 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg)


	sqlite3_step(stmt_pkg);
- 
	deps = pkg_deps(pkg);
-
- 
	if (deps != NULL)
+ 
	if ((deps = pkg_deps(pkg)) != NULL)

		for (i = 0; deps[i] != NULL; i++) {

			sqlite3_bind_text(stmt_dep, 1, pkg_get(deps[i], PKG_ORIGIN), -1, SQLITE_STATIC);

			sqlite3_bind_text(stmt_dep, 2, pkg_get(deps[i], PKG_NAME), -1, SQLITE_STATIC);
@@ -695,8 +758,7 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg)
			sqlite3_reset(stmt_dep);

		}
- 
	conflicts = pkg_conflicts(pkg);
- 
	if (conflicts != NULL)
+ 
	if ((conflicts = pkg_conflicts(pkg)) != NULL)

		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);
@@ -706,8 +768,7 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg)
		}
- 
	files = pkg_files(pkg);
- 
	if (files != NULL)
+ 
	if ((files = pkg_files(pkg)) != NULL)

		for (i = 0; files[i] != NULL; i++) {

			sqlite3_bind_text(stmt_file, 1, pkg_file_path(files[i]), -1, SQLITE_STATIC);

			sqlite3_bind_text(stmt_file, 2, pkg_file_sha256(files[i]), -1, SQLITE_STATIC);
@@ -717,8 +778,7 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg)
			sqlite3_reset(stmt_file);

		}
- 
	scripts = pkg_scripts(pkg);
- 
	if (scripts != NULL)
+ 
	if ((scripts = pkg_scripts(pkg)) != NULL)

		for (i = 0; scripts[i] != NULL; i++) {

			sqlite3_bind_text(stmt_scripts, 1, pkg_script_data(scripts[i]), -1, SQLITE_STATIC);

			sqlite3_bind_int(stmt_scripts, 2, pkg_script_type(scripts[i]));
@@ -727,8 +787,7 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg)
			sqlite3_step(stmt_scripts);

			sqlite3_reset(stmt_scripts);

		}
- 
	execs = pkg_execs(pkg);
- 
	if (execs != NULL)
+ 
	if ((execs = pkg_execs(pkg)) != NULL)

		for (i = 0; execs[i] != NULL; i++) {

			sqlite3_bind_text(stmt_exec, 1, pkg_exec_cmd(execs[i]), -1, SQLITE_STATIC);

			sqlite3_bind_int(stmt_exec, 2, pkg_exec_type(execs[i]));
@@ -737,12 +796,24 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg)
			sqlite3_step(stmt_exec);

			sqlite3_reset(stmt_exec);

		}
+
+ 
	if ((options = pkg_options(pkg)) != NULL)
+ 
		for (i = 0; options[i] != NULL; i++) {
+ 
			sqlite3_bind_text(stmt_options, 1, pkg_option_opt(options[i]), -1, SQLITE_STATIC);
+ 
			sqlite3_bind_text(stmt_options, 2, pkg_option_value(options[i]), -1, SQLITE_STATIC);
+ 
			sqlite3_bind_text(stmt_options, 3, pkg_get(pkg, PKG_ORIGIN), -1, SQLITE_STATIC);
+
+ 
			sqlite3_step(stmt_options);
+ 
			sqlite3_reset(stmt_options);
+ 
		}
+ 


	sqlite3_finalize(stmt_pkg);

	sqlite3_finalize(stmt_dep);

	sqlite3_finalize(stmt_conflicts);

	sqlite3_finalize(stmt_file);

	sqlite3_finalize(stmt_exec);

	sqlite3_finalize(stmt_scripts);
+ 
	sqlite3_finalize(stmt_options);



	sqlite3_exec(db->sqlite, "COMMIT;", NULL, NULL, NULL);
modified libpkg/pkgdb.h
@@ -16,7 +16,8 @@ typedef enum _pkgdb_it_t {
	IT_CONFLICT,

	IT_FILE,

	IT_EXEC,
- 
	IT_SCRIPT
+ 
	IT_SCRIPT,
+ 
	IT_OPTION

} pkgdb_it_t;

struct pkgdb_it {

	struct pkgdb *db;
modified pkg/register.c
@@ -30,7 +30,7 @@ exec_register(int argc, char **argv)
	int ret = 0;



	pkg_new(&pkg);
- 
	while ((ch = getopt(argc, argv, "vc:d:f:p:P:m:o:C:n:M:s:")) != -1) {
+ 
	while ((ch = getopt(argc, argv, "vc:d:f:p:P:m:o:C:n:M:s:a:r:w:O:")) != -1) {

		switch (ch) {

			case 'v':

				/* IGNORE */
@@ -72,6 +72,18 @@ exec_register(int argc, char **argv)
			case 's':

				ret += ports_parse_scripts(pkg, optarg);

				break;
+ 
			case 'a':
+ 
				pkg_set(pkg, PKG_ARCH, optarg);
+ 
				break;
+ 
			case 'r': /* responsible */
+ 
				pkg_set(pkg, PKG_MAINTAINER, optarg);
+ 
				break;
+ 
			case 'w':
+ 
				pkg_set(pkg, PKG_WWW, optarg);
+ 
				break;
+ 
			case 'O':
+ 
				/* TODO options handling */
+ 
				break;

			default:

				printf("%c\n", ch);

				usage_register();
@@ -79,6 +91,8 @@ exec_register(int argc, char **argv)
		}

	}
+ 
	/* TODO: missing osversion get it from uname*/
+ 


	if (ret < 0) {

		pkg_free(pkg);

		return (ret);