#include <openssl/pem.h>

#define PKGVERSION "1.0.90"

#define PKG_PORTVERSION "1.0.90"

struct pkg;

	/**

	 * The license logic is OR (dual in the ports)

	 */

	/**

	 * The license logic is AND (multi in the ports)

	 */

	/**

	 * The license logic un single (default in the ports)

	 */

} lic_t;

typedef enum {

	PKGDB_REMOTE

} pkgdb_t;

	/**

	 * The pkg refers to a local file archive.

	 */

	/**

	 * The pkg refers to a package available on the remote repository.

	 * @todo Document which attributes are available.

	 */

	/**

	 * The pkg refers to a localy installed package.

	 */

} pkg_t;

/**

 * Used by pkg_get() and pkg_set()

 */

typedef enum {

	PKG_NAME,

	PKG_VERSION,

	PKG_COMMENT,

	PKG_NEWVERSION,

	PKG_REPONAME,

	PKG_REPOURL, /* end of fields */

	PKG_NEW_FLATSIZE,

	PKG_NEW_PKGSIZE,

	PKG_LICENSE_LOGIC,

} pkg_attr;

typedef enum {

	PKG_SET_AUTOMATIC,

	PKG_SET_DEPORIGIN,

	PKG_SET_ORIGIN

typedef enum _pkg_config_key {

	PKG_CONFIG_REPO = 0,

} pkg_config_key;

typedef enum {

 */

 /* Don't conflict with PKG_LOAD_* q.v. */

int pkg_analyse_files(struct pkgdb *, struct pkg *);

 * @param sha256 The new checksum

 * @return An error code

 */

/**

 * Read the content of a file into a buffer, then call pkg_set().

 * @param check_duplicates ensure no duplicate files are added to the pkg?

 * @return An error code.

 */

/**

 * Allocate a new struct pkg_file and add it to the files of pkg;

 * @param check_duplicates ensure no duplicate files are added to the pkg?

 * @return An error code.

 */

/**

 * Add a path

 * @param perm the permission

 * @return An error code.

 */

/**

 * Add a category

 * @param data A pointer which is passed to the callback.

 * @param sum An 65 long char array to receive the sha256 sum

 */

int pkg_finish_repo(char *path, pem_password_cb *cb, char *rsa_key_path);

/**

struct pkgdb_it *pkgdb_query_downgrades(struct pkgdb *db, const char *reponame);

struct pkgdb_it *pkgdb_query_delete(struct pkgdb *db, match_t type, int nbpkgs, char **pkgs, int recursive);

struct pkgdb_it *pkgdb_query_autoremove(struct pkgdb *db);

/**

 * @todo Return directly the struct pkg?

struct pkgdb_it * pkgdb_query_shlib(struct pkgdb *db, const char *shlib);

/* Make sure new PKG_LOAD don't conflict with PKG_CONTAINS_* */

/**

 * @param flags OR'ed PKG_LOAD_*

 * @return An error code.

 */

/**

 * Free a struct pkgdb_it.

 * @param path The path to the package archive file on the local disk

 * @return An error code.

 */

/**

 * Allocate a new pkg_jobs.

/**

 * Create package from an installed & registered package

 */

/**

 * Create package from stage install with a metadata directory

 */

/**

 * Download the latest repo db file and checks its signature if any

static int

dep_installed(struct pkg_dep *dep, struct pkgdb *db) {

	it = pkgdb_query(db, pkg_dep_origin(dep), MATCH_EXACT);

static int

do_extract(struct archive *a, struct archive_entry *ae)

{

	struct stat st;

	do {

}

int

{

	struct archive_entry *ae;

	assert(path != NULL);

	pkg_config_string(PKG_CONFIG_ABI, &myarch);

	pkg_get(pkg, PKG_ARCH, &arch, PKG_ORIGIN, &origin);

		pkg_emit_error("wrong architecture: %s instead of %s",

		    arch, myarch);

		if ((flags & PKG_ADD_FORCE) == 0) {

pkg_create_from_dir(struct pkg *pkg, const char *root,

    struct packing *pkg_archive)

{

	if (pkg_is_valid(pkg) != EPKG_OK) {

		pkg_emit_error("the package is not valid");

static struct packing *

pkg_create_archive(const char *outdir, struct pkg *pkg, pkg_formats format,

{

	/*

	 * Ensure that we have all the information we need

pkg_create_staged(const char *outdir, pkg_formats format, const char *rootdir,

    const char *md_dir, char *plist)

{

	/* Load the manifest from the metadata directory */

	if (snprintf(path, sizeof(path), "%s/+MANIFEST", md_dir) == -1)

pkg_create_installed(const char *outdir, pkg_formats format,

    const char *rootdir, struct pkg *pkg)

{

	assert(pkg->type == PKG_INSTALLED);

#include "private/utils.h"

int

{

	assert(pkg != NULL);

	assert(db != NULL);

}

int

{

	while (pkg_files(pkg, &file) == EPKG_OK) {

		const char *sum = pkg_file_cksum(file);

}

int

{

	while (pkg_dirs(pkg, &dir) == EPKG_OK) {

		if (dir->keep == 1)

		if (pkg_dir_try(dir)) {

			if (rmdir(pkg_dir_path(dir)) == -1 &&

				pkg_emit_errno("rmdir", pkg_dir_path(dir));

		} else {

				pkg_emit_errno("rmdir", pkg_dir_path(dir));

		}

	}

#include "private/db_upgrades.h"

#define DBVERSION 12

static void pkgdb_regex(sqlite3_context *, int, sqlite3_value **, int);

static void pkgdb_regex_basic(sqlite3_context *, int, sqlite3_value **);

static void pkgdb_regex_extended(sqlite3_context *, int, sqlite3_value **);

	const char * const name;

	pkg_attr type;

} columns[] = {

	{ "newflatsize", PKG_NEW_FLATSIZE },

};

static int

    int (*pkg_adddata)(struct pkg *pkg, const char *data), int list)

{

	assert(db != NULL && pkg != NULL);

static const char *

pkgdb_get_reponame(struct pkgdb *db, const char *repo)

{

	assert(db->type == PKGDB_REMOTE);

static void

populate_pkg(sqlite3_stmt *stmt, struct pkg *pkg) {

	assert(stmt != NULL);

static void

pkgdb_regex(sqlite3_context *ctx, int argc, sqlite3_value **argv, int reg_type)

{

	if (argc != 2 || (regex = sqlite3_value_text(argv[0])) == NULL ||

		(str = sqlite3_value_text(argv[1])) == NULL) {

static void

pkgdb_regex_delete(void *p)

{

	regfree(re);

	free(re);

static void

pkgdb_myarch(sqlite3_context *ctx, int argc, sqlite3_value **argv)

{

	if (argc > 1) {

		sqlite3_result_error(ctx, "Invalid usage of myarch\n", -1);

}

static void

{

	if (argc != 2 || (version1 = sqlite3_value_text(argv[0])) == NULL

		sqlite3_result_error(ctx, "Invalid comparison\n", -1);

		return;

	}

static int

pkgdb_upgrade(struct pkgdb *db)

{

	assert(db != NULL);

static int

pkgdb_init(sqlite3 *sdb)

{

	"BEGIN;"

	"CREATE TABLE packages ("

		"id INTEGER PRIMARY KEY,"

int

pkgdb_remote_init(struct pkgdb *db, const char *repo)

{

	"BEGIN;"

	"CREATE INDEX '%s'.deps_origin on deps(origin);"

	"COMMIT;"

static int

pkgdb_open_multirepos(const char *dbdir, struct pkgdb *db)

{

	struct pkg_config_kv *repokv = NULL;

	    "\t/!\\		   WARNING WARNING WARNING		/!\\\n"

	    "\t/!\\	     WORKING ON MULTIPLE REPOSITORIES		/!\\\n"

	    "\t/!\\  THIS FEATURE IS STILL CONSIDERED EXPERIMENTAL	/!\\\n"

int

pkgdb_open(struct pkgdb **db_p, pkgdb_t type)

{

	if (*db_p != NULL) {

		assert((*db_p)->lock_count == 0);

static struct pkgdb_it *

pkgdb_it_new(struct pkgdb *db, sqlite3_stmt *s, int type)

{

	assert(db != NULL && s != NULL);

}

static struct load_on_flag {

} load_on_flag[] = {

};

int

{

	assert(it != NULL);

static const char *

pkgdb_get_pattern_query(const char *pattern, match_t match)

{

	if (pattern != NULL)

		checkorigin = strchr(pattern, '/');

static const char *

pkgdb_get_match_how(match_t match)

{

	switch (match) {

	case MATCH_ALL:

struct pkgdb_it *

pkgdb_query(struct pkgdb *db, const char *pattern, match_t match)

{

	assert(db != NULL);

	assert(match == MATCH_ALL || (pattern != NULL && pattern[0] != '\0'));

struct pkgdb_it *

pkgdb_query_which(struct pkgdb *db, const char *path)

{

		"SELECT p.id, p.origin, p.name, p.version, p.comment, p.desc, "

			"p.message, p.arch, p.maintainer, p.www, "

			"p.prefix, p.flatsize, p.time, p.infos "

struct pkgdb_it *

pkgdb_query_shlib(struct pkgdb *db, const char *shlib)

{

		"SELECT p.id, p.origin, p.name, p.version, p.comment, p.desc, "

			"p.message, p.arch, p.maintainer, p.www, "

			"p.prefix, p.flatsize, p.time, p.infos "

int

pkgdb_is_dir_used(struct pkgdb *db, const char *dir, int64_t *res)

{

		"SELECT count(package_id) FROM pkg_directories, directories "

		"WHERE directory_id = directories.id AND directories.path = ?1;";

int

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

{

	assert(db != NULL && pkg != NULL);

int

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

{

		"SELECT p.name, p.origin, p.version "

		"FROM %Q.packages AS p, %Q.deps AS d "

		"WHERE p.id = d.package_id "

int

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

{

		"SELECT path, sha256 "

		"FROM files "

		"WHERE package_id = ?1 "

int

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

{

		"SELECT path, try "

		"FROM pkg_directories, directories "

		"WHERE package_id = ?1 "

		"AND directory_id = directories.id "

		"ORDER by path DESC";

	assert(db != NULL && pkg != NULL);

	assert(pkg->type == PKG_INSTALLED);

int

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

{

			"AND license_id = l.id "

	assert(db != NULL && pkg != NULL);

int

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

{

			"AND category_id = c.id "

	assert(db != NULL && pkg != NULL);

	if (pkg->type == PKG_REMOTE) {

{

	/*struct pkg_user *u = NULL;

	struct passwd *pwd = NULL;*/

		"SELECT users.name "

		"FROM pkg_users, users "

		"WHERE package_id = ?1 "

		"ORDER by name DESC";

	assert(db != NULL && pkg != NULL);

int

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

{

		"SELECT groups.name "

		"FROM pkg_groups, groups "

		"WHERE package_id = ?1 "

		"ORDER by name DESC";

	assert(db != NULL && pkg != NULL);

int

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

{

			"AND shlib_id = s.id "

	assert(db != NULL && pkg != NULL);

int

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

{

		"SELECT script, type "

		"FROM scripts "

		"WHERE package_id = ?1";

int

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

{

		"SELECT option, value "

		"FROM %Q.options "

		"WHERE package_id = ?1";

int

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

{

		"SELECT m.content "

		"FROM mtree AS m, packages AS p "

		"WHERE m.id = p.mtree_id "

	assert(db != NULL && pkg != NULL);

	assert(pkg->type == PKG_INSTALLED);

		NULL,

		"INSERT OR REPLACE INTO packages( "

			"origin, name, version, comment, desc, message, arch, "

		"TTTTTTTTTTIIITT",

	},

	[DEPS_UPDATE] = {

static int

prstmt_initialize(struct pkgdb *db)

{

	assert(db != NULL);

static int

run_prstmt(sql_prstmt_index s, ...)

{

	stmt = STMT(s);

	argtypes = sql_prepared_statements[s].argtypes;

static void

prstmt_finalize(struct pkgdb *db)

{

	for (i = 0; i < PRSTMT_LAST; i++)

	{

int

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

{

	assert(db != NULL);

	if (!complete && sql_exec(s, "BEGIN;") != EPKG_OK)

		return (EPKG_FATAL);

	/*

	 * Insert mtree record

	 * Insert package record

	 */

	ret = run_prstmt(PKG, origin, name, version, comment, desc, message,

	if (ret != SQLITE_DONE) {

		ERROR_SQLITE(s);

		goto cleanup;

	 */

	while (pkg_files(pkg, &file) == EPKG_OK) {

		ret = run_prstmt(FILES, pkg_path, pkg_sum, package_id);

		if (ret == SQLITE_DONE)

	 */

	while (pkg_categories(pkg, &category) == EPKG_OK) {

		ret = run_prstmt(CATEGORY1, pkg_cat);

		if (ret == SQLITE_DONE)

			ret = run_prstmt(CATEGORY2, package_id, pkg_cat);

int

pkgdb_update_shlibs(struct pkg *pkg, int64_t package_id, sqlite3 *s)

{

	while (pkg_shlibs(pkg, &shlib) == EPKG_OK) {

		if (run_prstmt(SHLIBS1, pkg_shlib_name(shlib))

int

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

{

	assert(db != NULL);

	}

	if ((ret = pkg_analyse_files(db, pkg)) == EPKG_OK) {

			return (EPKG_FATAL);

		s = db->sqlite;

		pkg_get(pkg, PKG_ROWID, &package_id);

		/* Clean out old shlibs first */

			ERROR_SQLITE(db->sqlite);

			return (EPKG_FATAL);

		}

			return (EPKG_FATAL);

		}

			return (EPKG_FATAL);

		/* Save shlibs */

int

pkgdb_register_finale(struct pkgdb *db, int retcode)

{

	assert(db != NULL);

int

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

{

	pkg_emit_install_begin(pkg);

	ret = pkgdb_register_pkg(db, pkg, 0);

		pkg_emit_install_finished(pkg);

	pkgdb_register_finale(db, ret);

	return (ret);

}

int

pkgdb_unregister_pkg(struct pkgdb *db, const char *origin)

{

		"directories WHERE id NOT IN "

			"(SELECT DISTINCT directory_id FROM pkg_directories)",

		"categories WHERE id NOT IN "

		"shlibs WHERE id NOT IN "

			"(SELECT DISTINCT shlib_id FROM pkg_shlibs)"

	};

	assert(db != NULL);

	assert(origin != NULL);

		ERROR_SQLITE(db->sqlite);

		return (EPKG_FATAL);

	}

int

sql_exec(sqlite3 *s, const char *sql, ...)

{

	assert(s != NULL);

	assert(sql != NULL);

static bool

is_attached(sqlite3 *s, const char *name)

{

	assert(s != NULL);

static void

report_already_installed(sqlite3 *s)

{

		"(SELECT p.origin FROM main.packages AS p WHERE "

		"p.origin=pkgjobs.origin AND p.version=pkgjobs.version "

		"AND (SELECT group_concat(option) FROM "

sql_on_all_attached_db(sqlite3 *s, struct sbuf *sql, const char *multireposql,

    const char *compound)

{

	assert(s != NULL);

	assert(compound != NULL);

static void

pkgdb_detach_remotes(sqlite3 *s)

{

	assert(s != NULL);

int

get_pragma(sqlite3 *s, const char *sql, int64_t *res)

{

	assert(s != NULL && sql != NULL);

int

pkgdb_compact(struct pkgdb *db)

{

	assert(db != NULL);

	if (ret != EPKG_OK)

		return (EPKG_FATAL);

	if (ret != EPKG_OK)

		return (EPKG_FATAL);

	/*

	 */

	if (freelist_count / (float)page_count < 0.25)

		return (EPKG_OK);

static int

create_temporary_pkgjobs(sqlite3 *s)

{

	assert(s != NULL);

static struct pkgdb_it *

pkgdb_query_newpkgversion(struct pkgdb *db, const char *repo)

{

		"comment, desc, message, arch, maintainer, "

		"www, prefix, flatsize, newversion, newflatsize, pkgsize, "

		"cksum, repopath, automatic, weight, "

		"'%s' AS dbname FROM pkgjobs;";

	    "INSERT OR IGNORE INTO pkgjobs ("

	    "  pkgid, origin, name, newversion, comment, desc, arch, "

	    "  maintainer, www, prefix, newflatsize, pkgsize, "

pkgdb_query_installs(struct pkgdb *db, match_t match, int nbpkgs, char **pkgs,

    const char *repo, bool force, bool recursive)

{

	if ((it = pkgdb_query_newpkgversion(db, repo)) != NULL) {

		pkg_emit_newpkgversion();

		return (it);

	}

		"comment, desc, message, arch, maintainer, "

		"www, prefix, flatsize, newversion, newflatsize, pkgsize, "

		"cksum, repopath, automatic, weight, "

		"'%s' AS dbname FROM pkgjobs ORDER BY weight DESC;";

	    "maintainer, www, prefix, flatsize, pkgsize, "

	    "cksum, repopath, automatic) "

	    "SELECT DISTINCT r.id, r.origin, r.name, r.version, r.comment, r.desc, "

	    "(SELECT d.origin FROM '%s'.deps AS d, pkgjobs AS j WHERE d.package_id = j.pkgid) "

	    "AND (SELECT origin FROM main.packages WHERE origin=r.origin AND version=r.version) IS NULL;";