pkg_licenses;

	pkg_list_count;

	pkg_load_metadata;

	pkg_manifest_parser_free;

	pkg_manifest_parser_new;

	pkg_namecmp;

}

int

{

	struct archive *a;

	struct archive_entry *ae;

	int ret;

	if (ret != EPKG_OK && ret != EPKG_END)

		return (EPKG_FATAL);

}

int

{

	struct archive *a;

	struct archive_entry *ae;

	int ret;

	if (ret != EPKG_OK && ret != EPKG_END)

		return (EPKG_FATAL);

}

static int

{

	void *buffer;

	int rc;

	buffer = xmalloc(len);

	archive_read_data(a, buffer, len);

	free(buffer);

	return (rc);

}

int

pkg_open2(struct pkg **pkg_p, struct archive **a, struct archive_entry **ae,

{

	struct pkg	*pkg = NULL;

	pkg_error_t	 retcode = EPKG_OK;

			strcmp(fpath, "+COMPACT_MANIFEST") == 0) {

			manifest = true;

			if (ret != EPKG_OK) {

				retcode = EPKG_FATAL;

				goto cleanup;

		if (!manifest && strcmp(fpath, "+MANIFEST") == 0) {

			manifest = true;

			if (ret != EPKG_OK) {

				if ((flags & PKG_OPEN_TRY) == 0)

					pkg_emit_error("%s is not a valid package: "

struct pkg_plugin;

struct pkg_manifest_parser;

typedef struct ucl_object_s pkg_object;

 * @param keys manifest keys that should be initialised

 * @param flags open flags

 */

/**

 * @return the type of the package.

 * @param buf An NULL-terminated buffer containing the manifest data.

 * @return An error code.

 */

int pkg_manifest_parser_new(struct pkg_manifest_parser **p);

void pkg_manifest_parser_free(struct pkg_manifest_parser *p);

 * @return An error code.

 */

int pkg_add(struct pkgdb *db, const char *path, unsigned flags,

#define PKG_ADD_UPGRADE			(1U << 0)

/* (1U << 1) removed intentionally */

static int

pkg_add_check_pkg_archive(struct pkgdb *db, struct pkg *pkg,

{

	const char	*arch;

	int	ret, retcode;

		if ((flags & PKG_ADD_UPGRADE) == 0 &&

				access(dpath, F_OK) == 0) {

			if (ret != EPKG_OK)

				goto cleanup;

static int

pkg_add_common(struct pkgdb *db, const char *path, unsigned flags,

    struct pkg *local, struct triggers *t)

{

	struct archive		*a;

	 * current archive_entry to the first non-meta file.

	 * If there is no non-meta files, EPKG_END is returned.

	 */

	if (ret == EPKG_END)

		extract = false;

	else if (ret != EPKG_OK) {

	 * Additional checks for non-remote package

	 */

	if (remote == NULL) {

		if (ret != EPKG_OK) {

			/* Do not return error on installed package */

			retcode = (ret == EPKG_INSTALLED ? EPKG_OK : ret);

int

pkg_add(struct pkgdb *db, const char *path, unsigned flags,

{

}

int

pkg_add_from_remote(struct pkgdb *db, const char *path, unsigned flags,

{

}

int

pkg_add_upgrade(struct pkgdb *db, const char *path, unsigned flags,

    struct pkg *rp, struct pkg *lp, struct triggers *t)

{

	if (pkgdb_ensure_loaded(db, lp,

	    PKG_LOAD_FILES|PKG_LOAD_SCRIPTS|PKG_LOAD_DIRS|PKG_LOAD_LUA_SCRIPTS) != EPKG_OK)

		return (EPKG_FATAL);

}

int

/* TODO use file descriptor for rootdir */

static int

load_manifest(struct pkg *pkg, const char *metadata, const char *plist,

{

	int ret;

	if (ret == EPKG_OK && plist != NULL)

		ret = ports_parse_plist(pkg, plist, rootdir);

load_metadata(struct pkg *pkg, const char *metadata, const char *plist,

    const char *rootdir)

{

	regex_t preg;

	regmatch_t pmatch[2];

	size_t size;

	int fd, i;

	/* Let's see if we have a directory or a manifest */

	if ((fd = open(metadata, O_DIRECTORY|O_CLOEXEC)) == -1) {

		if (errno == ENOTDIR)

		pkg_emit_errno("open", metadata);

		return (EPKG_FATAL);

	}

		close(fd);

		return (EPKG_FATAL);

	}

	pkg_load_message_from_file(fd, pkg, "+DISPLAY");

	if (pkg->desc == NULL)

{

	int rc = EPKG_OK;

	struct pkg *pkg = NULL;

	struct pkg_job_request *req;

	if (!(jp->flags & PKG_PATTERN_FLAG_FILE)) {

		rc = pkg_jobs_find_upgrade(j, jp->pattern, jp->match);

	}

	else {

			rc = EPKG_FATAL;

		} else if (pkg_validate(pkg, j->db) == EPKG_OK) {

			if (j->type == PKG_JOBS_UPGRADE && pkg_jobs_installed_local_pkg(j, pkg) != EPKG_OK) {

				pkg_emit_error("%s is not installed, therefore upgrade is impossible",

							pkg->name);

				return (EPKG_NOTINSTALLED);

			}

			pkg->type = PKG_FILE;

					jp->pattern);

			rc = EPKG_FATAL;

		}

	}

	return (rc);

}

static int

{

	struct pkg *new, *old;

	struct pkg_job_request *req;

		flags |= PKG_ADD_AUTOMATIC;

	if (old != NULL)

	else

	return (retcode);

}

pkg_jobs_execute(struct pkg_jobs *j)

{

	struct pkg *p;

	int retcode = EPKG_FATAL;

	pkg_plugin_hook_t pre, post;

	pkg_plugins_hook_run(pre, j, j->db);

	pkg_jobs_set_priorities(j);

	tll_foreach(j->jobs, _p) {

		case PKG_SOLVED_INSTALL:

		case PKG_SOLVED_UPGRADE_INSTALL:

		case PKG_SOLVED_UPGRADE:

			if (retcode != EPKG_OK)

				goto cleanup;

			break;

cleanup:

	pkgdb_release_lock(j->db, PKGDB_LOCK_EXCLUSIVE);

	return (retcode);

}

	uint32_t type;

	uint16_t valid_type;

	int (*parse_data)(struct pkg *, const ucl_object_t *, uint32_t);

} manifest_keys[] = {

	{ "annotations",         PKG_ANNOTATIONS,

			TYPE_SHIFT(UCL_OBJECT), pkg_obj},

	{ "www",                 offsetof(struct pkg, www),

			TYPE_SHIFT(UCL_STRING), pkg_string},

};

static int

urlencode(const char *src, xstring **dest)

{

	return (EPKG_OK);

}

static int

urldecode(const char *src, xstring **dest)

{

	return (EPKG_OK);

}

static int

{

	const ucl_object_t *cur;

	ucl_object_iter_t it = NULL;

	const char *key;

	int ret = EPKG_OK;

		if (key == NULL)

			continue;

		pkg_debug(3, "Manifest: found key: '%s'", key);

		}

		} else {

		}

	}

}

int

{

	const ucl_object_t *cur;

	ucl_object_iter_t it = NULL;

	const char *key;

	/* do a minimal validation */

		key = ucl_object_key(cur);

		if (key == NULL)

			continue;

		}

	}

}

int

{

	struct ucl_parser *p = NULL;

	ucl_object_t *obj = NULL;

	}

	ucl_parser_free(p);

	ucl_object_unref(obj);

	return (rc);

}

int

{

	struct ucl_parser *p = NULL;

	ucl_object_t *obj = NULL;

	}

	ucl_parser_free(p);

	ucl_object_unref(obj);

	free(data);

}

int

{

}

int

	int flags, ret = EPKG_OK;

	size_t sz;

	struct pkg *pkg = NULL;

	char *mdigest = NULL;

	char digestbuf[1024];

	xstring *b;

		break;

	}

	pkg_debug(1, "start worker to parse packages");

	if (ffd != -1)

		repopath = mp_decode_str(&rbuf, &len);

		if (len == 0) /* empty package name means ends of repo */

			break;

			off_t mpos, fpos = 0;

			size_t mlen;

			struct stat st;

	}

cleanup:

	xstring_free(b);

	close(pip);

	free(mdigest);

int pkg_script_run_child(int pid, int *pstat, int inputfd, const char* script_name);

int pkg_open2(struct pkg **p, struct archive **a, struct archive_entry **ae,

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

    pkg_checksum_type_t type);

int pkg_add_upgrade(struct pkgdb *db, const char *path, unsigned flags,

int pkg_add_from_remote(struct pkgdb *db, const char *path, unsigned flags,

void pkg_delete_dir(struct pkg *pkg, struct pkg_dir *dir);

void pkg_delete_file(struct pkg *pkg, struct pkg_file *file);

int pkg_open_root_fd(struct pkg *pkg);

	struct pkg *pkg, unsigned flags)

{

	sqlite3 *sqlite = PRIV_GET(repo);

	struct pkg *cached = NULL;

	char path[MAXPATHLEN];

	int rc;

	/*

	 * Try to get that information from fetched package in cache

	 */

	if (pkg_repo_cached_name(pkg, path, sizeof(path)) != EPKG_OK)

		return (EPKG_FATAL);

	pkg_debug(1, "Binary> loading %s", path);

		pkg_free(cached);

		return EPKG_FATAL;

	}

static int

pkg_repo_binary_add_from_manifest(const char *buf, sqlite3 *sqlite, size_t len,

		struct pkg_repo *repo)

{

	int rc = EPKG_OK;

	if (rc != EPKG_OK)

		return (EPKG_FATAL);

	if (rc != EPKG_OK) {

		goto cleanup;

	}

	sqlite3 *sqlite = NULL;

	int cnt = 0;

	time_t local_t;

	size_t len = 0;

	bool in_trans = false;

	char *path = NULL;

		if ((cnt % 10 ) == 0)

			pkg_emit_progress_tick(totallen, len);

		rc = pkg_repo_binary_add_from_manifest(line, sqlite, linelen,

		if (rc != EPKG_OK) {

			pkg_emit_progress_tick(len, len);

			break;

		free(path);

	}

	pkg_unregister_cleanup_callback(rollback_repo, (void *)name);

	pkg_free(pkg);

	free(line);

	if (f != NULL)

	int i;

	int failedpkgcount = 0;

	pkg_flags f = PKG_FLAG_NONE;

	const char *location = NULL;

	/* options descriptor */

	}

	failedpkgs = xstring_new();

	for (i = 0; i < argc; i++) {

		if (is_url(argv[i]) == EPKG_OK) {

			const char *name = strrchr(argv[i], '/');

		}

			fprintf(failedpkgs->fp, "%s", argv[i]);

			if (i != argc - 1)

				fprintf(failedpkgs->fp, ", ");

			unlink(file);

	}

	pkgdb_release_lock(db, PKGDB_LOCK_EXCLUSIVE);

	pkgdb_close(db);

	int		 cachefd = -1;

	size_t		 total = 0;

	char		 size[8];

#ifdef HAVE_CAPSICUM

	cap_rights_t rights;

#endif

	/* Build the list of out-of-date or obsolete packages */

	recursive_analysis(cachefd, db, cachedir, cachedir, &dl, &sumlist, all,

	    &total);

	pkghash_destroy(sumlist);

cleanup:

	pkgdb_release_lock(db, PKGDB_LOCK_READONLY);

	pkgdb_close(db);

	tll_free_and_free(dl, free);

	if (cachefd != -1)

	bool pkg_exists = false;

	bool origin_search = false;

	bool e_flag = false;

#ifdef HAVE_CAPSICUM

	cap_rights_t rights;

#endif

#endif

		if (opt == INFO_TAG_NAMEVER)

			opt |= INFO_FULL;

		if ((opt & (INFO_RAW | INFO_FILES |

				INFO_DIRS)) == 0)

			open_flags = PKG_OPEN_MANIFEST_COMPACT;

			close(fd);

			return (1);

		}

		print_info(pkg, opt);

		close(fd);

		pkg_free(pkg);

	struct pkgdb		*db = NULL;

	struct pkgdb_it		*it = NULL;

	struct pkg		*pkg = NULL;

	char			*pkgname = NULL;

	int			 query_flags = PKG_LOAD_BASIC;

	match_t			 match = MATCH_EXACT;

		} else if ((query_flags & PKG_LOAD_FILES) == 0) {

			open_flags = PKG_OPEN_MANIFEST_ONLY;

		}

			return (EXIT_FAILURE);

		}

		print_query(pkg, argv[0], multiline);

		pkg_free(pkg);

		return (EXIT_SUCCESS);

	struct pkg_option *option = NULL;

	struct pkg_category *category = NULL;

	struct pkg_file *file = NULL;

	const char *pkg_str;

	int64_t pkg_int;

	int i;

	ATF_REQUIRE_EQ(EPKG_OK, pkg_new(&p, PKG_FILE));

	ATF_REQUIRE(p != NULL);

	ATF_REQUIRE(pkg_get(p, PKG_NAME, &pkg_str) == EPKG_OK);

	ATF_REQUIRE(strcmp(pkg_str, "foobar") == 0);