for (i = 0; keyacts[i].key != NULL; i++) {

		k = xcalloc(1, sizeof(struct keyword));

		a = xmalloc(sizeof(struct action));

		a->perform = keyacts[i].action;

		DL_APPEND(k->actions, a);

	}

}

static void

keyword_free(struct keyword *k)

{

	DL_FREE(k->actions, free);

	free(k);

}

parse_keywords(struct plist *plist, char *keyword,

    char *line, struct file_attr *attr)

{

	struct action *a;

	int ret = EPKG_FATAL;

	/* if keyword is empty consider it as a file */

	if (*keyword == '\0')

		return (file(plist, line, attr));

	if (k != NULL) {

		LL_FOREACH(k->actions, a) {

			ret = a->perform(plist, line, attr);

	if (p->plistdirfd != -1)

		close(p->plistdirfd);

	free(p->uname);

	free(p->gname);

	char *cert;

	int64_t certlen;

	bool cert_allocated;

	bool trusted;

};

}

static bool

{

	char *hash;

	int nbgood = 0;

	struct pkg_repo_meta_key *mk = NULL;

		if (fatal)

			pkg_emit_error("No signature found");

		return (false);

			return (false);

	}

		if (s->sig != NULL && s->cert == NULL) {

			/*

			 * We may want to check meta

			 */

			if (mk != NULL && mk->pubkey != NULL) {

				s->cert = mk->pubkey;

		s->trusted = false;

		hash = pkg_checksum_data(s->cert, s->certlen,

		    PKG_HASH_TYPE_SHA256_HEX);

			if (fatal)

				pkg_emit_error("At least one of the "

					"certificates has been revoked");

			return (false);

		}

			nbgood++;

			s->trusted = true;

		}

	}

	if (nbgood == 0) {

}

static void

{

		free(s->sig);

		if (s->cert_allocated)

			free(s->cert);

		free(s);

	}

}

}

static int

{

	const char *p = in, *end = in + inlen;

	int rc = EPKG_OK;

	int len = 0, tlen;

	struct sig_cert *s = NULL;

	bool new = false;

	while (p < end) {

		switch (state) {

				free(s);

				return (EPKG_FATAL);

			}

				s = xcalloc(1, sizeof(struct sig_cert));

				tlen = MIN(len, sizeof(s->name) - 1);

				memcpy(s->name, p, tlen);

				new = true;

			}

			else {

				new = false;

			}

			state = fp_parse_siglen;

			p += len;

			if (new)

			break;

		}

static int

pkg_repo_archive_extract_archive(int fd, const char *file,

    struct pkg_repo *repo, int dest_fd,

{

	struct pkg_extract_cbdata cbdata;

	char *sig = NULL;

			s->sig = sig;

			s->siglen = siglen;

			strlcpy(s->name, "signature", sizeof(s->name));

		}

	}

	else if (pkg_repo_signature_type(repo) == SIG_FINGERPRINT) {

pkg_repo_archive_extract_check_archive(int fd, const char *file,

    struct pkg_repo *repo, int dest_fd)

{

	int ret, rc;

	ret = rc = EPKG_OK;

			rc = EPKG_FATAL;

			goto out;

		}

		/*

		 * Here are dragons:

		 * 1) rsa_verify is NOT rsa_verify_cert

		 *

		 * by @bdrewery

		 */

		    dest_fd);

		if (ret != EPKG_OK) {

			pkg_emit_error("Invalid signature, "

		}

	}

	else if (pkg_repo_signature_type(repo) == SIG_FINGERPRINT) {

			ret = rsa_verify_cert(s->cert, s->certlen, s->sig, s->siglen,

				dest_fd);

			if (ret == EPKG_OK && s->trusted) {

	unsigned char *map = NULL;

	int fd, dbdirfd, metafd;

	int rc = EPKG_OK, ret;

	struct pkg_repo_check_cbdata cbdata;

	bool newscheme = false;

	dbdirfd = pkg_get_dbdirfd();

	snprintf(filepath, sizeof(filepath), "%s.meta", pkg_repo_name(repo));

	if (repo->signature_type == SIG_FINGERPRINT) {

		cbdata.len = st.st_size;

		cbdata.map = map;

			if (s->siglen != 0 && s->certlen == 0) {

				/*

				 * We need to load this pubkey from meta

			goto cleanup;

		}

			ret = rsa_verify_cert(s->cert, s->certlen, s->sig, s->siglen,

				metafd);

			if (ret == EPKG_OK && s->trusted)

}

static int

{

	DIR *d;

	struct dirent *ent;

			continue;

		finger = pkg_repo_load_fingerprint(path, ent->d_name);

		if (finger != NULL)

	}

	closedir(d);

		return (EPKG_FATAL);

	}

		pkg_emit_error("No trusted certificates");

		return (EPKG_FATAL);

	}

	struct pkg_conflict *conflicts;

	pkghash *conflictshash;

	char *file;

};

static int

{

	FTS *fts = NULL;

	struct pkg_fts_item *fts_items = NULL, *fts_cur, *fts_start;

	int num_workers, i, remaining_workers, remain, cur_jobs, remain_jobs, nworker;

	size_t len, tasks_per_worker, ntask;

	struct digest_list_entry *dlist = NULL, *cur_dig, *dtmp;

	int retcode = EPKG_FATAL;

	ucl_object_t *meta_dump;

	FILE *mfile;

	char *repopath[2];

	char repodb[MAXPATHLEN];

		close(mfd);

	if (ffd != -1)

		close(ffd);

		pkghash_destroy(curcb->conflictshash);

		curcb->conflictshash = NULL;

		free(curcb);

	}

	if (pfd != NULL)

		free(pfd);

void

pkg_repo_meta_free(struct pkg_repo_meta *meta)

{

	/*

	 * It is safe to free NULL pointer by standard

		free(meta->maintainer);

		free(meta->source);

		free(meta->source_identifier);

			free(k->name);

			free(k->pubkey);

			free(k->pubkey_type);

			free(k);

		}

		free(meta);

	}

}

	while ((cur = ucl_iterate_object(obj, &iter, false)) != NULL) {

		cert = pkg_repo_meta_parse_cert(cur);

		if (cert != NULL)

	}

	*target = meta;

	const char *digest;

	const char *uid;

	const char *assumed_reponame;

	struct pkg_solve_variable *next, *prev;

};

struct pkg_solve_problem {

	struct pkg_jobs *j;

	kvec_t(struct pkg_solve_rule *) rules;

	struct pkg_solve_variable *variables;

	PicoSAT *sat;

	size_t nvars;

void

pkg_solve_problem_free(struct pkg_solve_problem *problem)

{

	while (kv_size(problem->rules)) {

		pkg_solve_rule_free(kv_pop(problem->rules));

	}

	picosat_reset(problem->sat);

	free(problem->variables);

	struct pkg_job_universe_item *un;

	struct pkg *pkg;

	bool libfound, providefound;

	/* Find the first package in the universe list */

	un = pr->un;

	}

	/* Find the corresponding variables chain */

	LL_FOREACH(var, curvar) {

		/*

	LL_FOREACH2(dep, cur, alt_next) {

		uid = cur->uid;

		if (depvar == NULL) {

			pkg_debug(2, "cannot find variable dependency %s", uid);

			continue;

	struct pkg *other;

	uid = conflict->uid;

	if (confvar == NULL) {

		pkg_debug(2, "cannot find conflict %s", uid);

		return (EPKG_END);

	/*

	 * Get the suggested item

	 */

	var = pkg_solve_find_var_in_chain(var, req->item->unit);

	assert(var != NULL);

	/* Assume the most significant variable */

		if (tvar == NULL) {

			pkg_debug(4, "solver: add variable from universe with uid %s", var->uid);

			tvar = var;

		}

		else {

	/* Add rules for all conflict chains */

	HASH_ITER(hh, j->universe->items, un, utmp) {

		if (var == NULL) {

			pkg_emit_error("internal solver error: variable %s is not found",

			    un->pkg->uid);

int

pkg_solve_sat_to_jobs(struct pkg_solve_problem *problem)

{

		pkg_debug(4, "solver: check variable with uid %s", var->uid);

		pkg_solve_insert_res_job(var, problem);

	}

	char *pubkey;

	char *pubkey_type; /* TODO: should be enumeration */

	char *name;

};

typedef enum pkg_checksum_type_e {

	char *source_identifier;

	int64_t revision;

	time_t eol;

	FILE *ssh;

	bool silent;

	struct {

		int in;

};

struct keyword {

	struct action *actions;

};

struct plist {

		size_t len;

		size_t cap;

	} post_patterns;

};

struct file_attr {

struct fingerprint {

	hash_t type;

	char hash[BUFSIZ];

};

int pkg_repo_load_fingerprints(struct pkg_repo *repo);

Checking for upgrades (2 candidates):  done

Processing candidates (2 candidates):  done

Checking integrity... done (2 conflicting)

  - test-1.1 [local2] conflicts with test2-1 [installed] on ${TMPDIR}/b

Checking integrity... done (0 conflicting)

The following 2 package(s) will be affected (of 0 checked):

Number of packages to be upgraded: 2

${JAILED}[1/2] Deinstalling test2-1...

${JAILED}[1/2] Deleting files for test2-1:  done

${JAILED}[2/2] Upgrading test from 1 to 1.1...

${JAILED}[2/2] Extracting test-1.1:  done

"

	atf_check \

		-o inline:"${OUTPUT}" \

Checking for upgrades (2 candidates):  done

Processing candidates (2 candidates):  done

Checking integrity... done (2 conflicting)

  - bar1-1.1 conflicts with bar-1.0 on ${TMPDIR}/file1

Cannot solve problem using SAT solver, trying another plan

Checking integrity... done (0 conflicting)

The following 3 package(s) will be affected (of 0 checked):

Checking for upgrades (2 candidates):  done

Processing candidates (2 candidates):  done

Checking integrity... done (2 conflicting)

  - bar1-1.1 conflicts with bar-1.0 on ${TMPDIR}/file1

Cannot solve problem using SAT solver, trying another plan

Checking integrity... done (0 conflicting)

The following 4 package(s) will be affected (of 0 checked):