2286938 Style police: use a consistent style for object accessor functions. — HardenedBSD-pkg

modified libpkg/pkg.c

@@ -548,7 +548,7 @@ pkg_adddep(struct pkg *pkg, const char *name, const char *origin, const char *ve

 	assert(version != NULL && version[0] != '\0');
 	while (pkg_deps(pkg, &d) != EPKG_END) {
 		if (!strcmp(origin, pkg_dep_get(d, PKG_DEP_ORIGIN))) {
 		if (!strcmp(origin, pkg_dep_origin(d))) {
 			pkg_emit_error("duplicate dependency listing: %s-%s, ignoring", name, version);
 			return (EPKG_OK);
 		}

@@ -602,8 +602,8 @@ pkg_addfile_attr(struct pkg *pkg, const char *path, const char *sha256, const ch

 	if (check_duplicates) {
 		while (pkg_files(pkg, &f) != EPKG_END) {
 			if (!strcmp(path, pkg_file_get(f, PKG_FILE_PATH))) {
 				pkg_emit_error("duplicate file listing: %s, ignoring", pkg_file_get(f, PKG_FILE_PATH));
 			if (!strcmp(path, pkg_file_path(f))) {
 				pkg_emit_error("duplicate file listing: %s, ignoring", pkg_file_path(f));
 				return (EPKG_OK);
 			}
 		}

@@ -1061,8 +1061,8 @@ pkg_copy_tree(struct pkg *pkg, const char *src, const char *dest)

 	}
 	while (pkg_files(pkg, &file) == EPKG_OK) {
 		snprintf(spath, sizeof(spath), "%s%s", src, pkg_file_get(file, PKG_FILE_PATH));
 		snprintf(dpath, sizeof(dpath), "%s%s", dest, pkg_file_get(file, PKG_FILE_PATH));
 		snprintf(spath, sizeof(spath), "%s%s", src, pkg_file_path(file));
 		snprintf(dpath, sizeof(dpath), "%s%s", dest, pkg_file_path(file));
 		packing_append_file(pack, spath, dpath);
 	}

@@ -1081,8 +1081,8 @@ pkg_test_filesum(struct pkg *pkg)

 	assert(pkg != NULL);
 	while (pkg_files(pkg, &f) == EPKG_OK) {
 		path = pkg_file_get(f, PKG_FILE_PATH);
 		sum = pkg_file_get(f, PKG_FILE_SUM);
 		path = pkg_file_path(f);
 		sum = pkg_file_cksum(f);
 		if (*sum != '\0') {
 			sha256_file(path, sha256);
 			if (strcmp(sha256, sum) != 0)

@@ -1105,8 +1105,8 @@ pkg_recompute(struct pkgdb *db, struct pkg *pkg)

 	char sha256[SHA256_DIGEST_LENGTH * 2 + 1];
 	while (pkg_files(pkg, &f) == EPKG_OK) {
 		path = pkg_file_get(f, PKG_FILE_PATH);
 		sum = pkg_file_get(f, PKG_FILE_SUM);
 		path = pkg_file_path(f);
 		sum = pkg_file_cksum(f);
 		if (lstat(path, &st) == 0) {
 			regular = true;
 			if (S_ISLNK(st.st_mode)) {

modified libpkg/pkg_add.c

@@ -47,7 +47,7 @@ dep_installed(struct pkg_dep *dep, struct pkgdb *db) {

 	struct pkgdb_it *it;
 	int ret = EPKG_FATAL;
 	it = pkgdb_query(db, pkg_dep_get(dep, PKG_DEP_ORIGIN), MATCH_EXACT);
 	it = pkgdb_query(db, pkg_dep_origin(dep), MATCH_EXACT);
 	if (pkgdb_it_next(it, &p, PKG_LOAD_BASIC) == EPKG_OK)
 		ret = EPKG_OK;

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

 	while (pkg_deps(pkg, &dep) == EPKG_OK) {
 		if (dep_installed(dep, db) != EPKG_OK) {
 			snprintf(dpath, sizeof(dpath), "%s/%s-%s%s", basedir,
 					 pkg_dep_get(dep, PKG_DEP_NAME), pkg_dep_get(dep, PKG_DEP_VERSION),
 					 pkg_dep_name(dep), pkg_dep_version(dep),
 					 ext);
 			if ((flags & PKG_ADD_UPGRADE) == 0 && access(dpath, F_OK) == 0) {

modified libpkg/pkg_create.c

@@ -62,11 +62,11 @@ pkg_create_from_dir(struct pkg *pkg, const char *root, struct packing *pkg_archi

 	 */
 	while (pkg_files(pkg, &file) == EPKG_OK) {
 		if (root != NULL)
 			snprintf(fpath, sizeof(fpath), "%s%s", root, pkg_file_get(file, PKG_FILE_PATH));
 			snprintf(fpath, sizeof(fpath), "%s%s", root, pkg_file_path(file));
 		else
 			strlcpy(fpath, pkg_file_get(file, PKG_FILE_PATH), sizeof(fpath));
 			strlcpy(fpath, pkg_file_path(file), sizeof(fpath));
 		if ((pkg_file_get(file, PKG_FILE_SUM) == NULL || pkg_file_get(file, PKG_FILE_SUM)[0] == '\0') && lstat(fpath, &st) == 0 && !S_ISLNK(st.st_mode)) {
 		if ((pkg_file_cksum(file) == NULL || pkg_file_cksum(file)[0] == '\0') && lstat(fpath, &st) == 0 && !S_ISLNK(st.st_mode)) {
 			if (sha256_file(fpath, sha256) != EPKG_OK)
 				return (EPKG_FATAL);
 			strlcpy(file->sum, sha256, sizeof(file->sum));

@@ -83,11 +83,11 @@ pkg_create_from_dir(struct pkg *pkg, const char *root, struct packing *pkg_archi

 	while (pkg_files(pkg, &file) == EPKG_OK) {
 		if (root != NULL)
 			snprintf(fpath, sizeof(fpath), "%s%s", root, pkg_file_get(file, PKG_FILE_PATH));
 			snprintf(fpath, sizeof(fpath), "%s%s", root, pkg_file_path(file));
 		else
 			strlcpy(fpath, pkg_file_get(file, PKG_FILE_PATH), sizeof(fpath));
 			strlcpy(fpath, pkg_file_path(file), sizeof(fpath));
 		ret = packing_append_file_attr(pkg_archive, fpath, pkg_file_get(file, PKG_FILE_PATH), file->uname, file->gname, file->perm);
 		ret = packing_append_file_attr(pkg_archive, fpath, pkg_file_path(file), file->uname, file->gname, file->perm);
 		pkg_config_bool(PKG_CONFIG_DEVELOPER_MODE, &developer);
 		if (developer && ret != EPKG_OK)
 			return (ret);

modified libpkg/pkg_delete.c

@@ -125,14 +125,14 @@ pkg_delete_files(struct pkg *pkg, int force)

 		if (file->keep == 1)
 			continue;
 		path = pkg_file_get(file, PKG_FILE_PATH);
 		path = pkg_file_path(file);
 		/* Regular files and links */
 		/* check sha256 */
 		if (!force && pkg_file_get(file, PKG_FILE_SUM)[0] != '\0') {
 		if (!force && pkg_file_cksum(file)[0] != '\0') {
 			if (sha256_file(path, sha256) != EPKG_OK)
 				continue;
 			if (strcmp(sha256, pkg_file_get(file, PKG_FILE_SUM)) != 0) {
 			if (strcmp(sha256, pkg_file_cksum(file)) != 0) {
 				pkg_emit_error("%s fails original SHA256 checksum,"
 							   " not removing", path);
 				continue;

modified libpkg/pkg_elf.c

@@ -100,7 +100,7 @@ test_depends(struct pkgdb *db, struct pkg *pkg, const char *name)

 		dep = NULL;
 		found = false;
 		while (pkg_deps(pkg, &dep) == EPKG_OK) {
 			if (strcmp(pkg_dep_get(dep, PKG_DEP_ORIGIN), deporigin) == 0) {
 			if (strcmp(pkg_dep_origin(dep), deporigin) == 0) {
 				found = true;
 				break;
 			}

@@ -295,7 +295,7 @@ pkg_analyse_files(struct pkgdb *db, struct pkg *pkg)

 				PKG_CONTAINS_H_OR_LA);
 	while (pkg_files(pkg, &file) == EPKG_OK) {
 		fpath = pkg_file_get(file, PKG_FILE_PATH);
 		fpath = pkg_file_path(file);
 		ret = analyse_elf(db, pkg, fpath);
 		if (developer) {
 			if (ret != EPKG_OK && ret != EPKG_END)

modified libpkg/pkg_jobs.c

@@ -129,7 +129,7 @@ pkg_jobs_keep_files_to_del(struct pkg *p1, struct pkg *p2)

 		f2 = NULL;
 		while (pkg_files(p2, &f2) == EPKG_OK) {
 			if (strcmp(pkg_file_get(f1, PKG_FILE_PATH), pkg_file_get(f2, PKG_FILE_PATH)) == 0) {
 			if (strcmp(pkg_file_path(f1), pkg_file_path(f2)) == 0) {
 				f1->keep = 1;
 				break;
 			}

modified libpkg/pkg_manifest.c

@@ -736,9 +736,9 @@ pkg_emit_manifest(struct pkg *pkg, char **dest)

 		if (map == -1)
 			manifest_append_map(map, mapping, "deps", BLOCK);
 		manifest_append_map(depkv, map, pkg_dep_get(dep, PKG_DEP_NAME), FLOW);
 		manifest_append_kv(depkv, "origin", pkg_dep_get(dep, PKG_DEP_ORIGIN), PLAIN);
 		manifest_append_kv(depkv, "version", pkg_dep_get(dep, PKG_DEP_VERSION), PLAIN);
 		manifest_append_map(depkv, map, pkg_dep_name(dep), FLOW);
 		manifest_append_kv(depkv, "origin", pkg_dep_origin(dep), PLAIN);
 		manifest_append_kv(depkv, "version", pkg_dep_version(dep), PLAIN);
 	}
 	seq = -1;

@@ -787,8 +787,8 @@ pkg_emit_manifest(struct pkg *pkg, char **dest)

 	while (pkg_files(pkg, &file) == EPKG_OK) {
 		if (map == -1)
 			manifest_append_map(map, mapping, "files", BLOCK);
 		urlencode(pkg_file_get(file, PKG_FILE_PATH), &tmpsbuf);
 		manifest_append_kv(map, sbuf_get(tmpsbuf), pkg_file_get(file, PKG_FILE_SUM) && strlen(pkg_file_get(file, PKG_FILE_SUM)) > 0 ? pkg_file_get(file, PKG_FILE_SUM) : "-", PLAIN);
 		urlencode(pkg_file_path(file), &tmpsbuf);
 		manifest_append_kv(map, sbuf_get(tmpsbuf), pkg_file_cksum(file) && strlen(pkg_file_cksum(file)) > 0 ? pkg_file_cksum(file) : "-", PLAIN);
 	}
 	seq = -1;

modified libpkg/pkg_repo.c

@@ -690,9 +690,9 @@ pkg_create_repo(char *path, bool force, void (progress)(struct pkg *pkg, void *d

 		dep = NULL;
 		while (pkg_deps(pkg, &dep) == EPKG_OK) {
 			if (run_prepared_statement(DEPS,
 			    pkg_dep_get(dep, PKG_DEP_ORIGIN),
 			    pkg_dep_get(dep, PKG_DEP_NAME),
 			    pkg_dep_get(dep, PKG_DEP_VERSION),
 			    pkg_dep_origin(dep),
 			    pkg_dep_name(dep),
 			    pkg_dep_version(dep),
 			    package_id) != SQLITE_DONE) {
 				ERROR_SQLITE(sqlite);
 				retcode = EPKG_FATAL;

modified libpkg/pkgdb.c

@@ -1801,8 +1801,8 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg, int complete)

 	 */
 	while (pkg_deps(pkg, &dep) == EPKG_OK) {
 		if (run_prstmt(DEPS, pkg_dep_get(dep, PKG_DEP_ORIGIN),
 		    pkg_dep_get(dep, PKG_DEP_NAME), pkg_dep_get(dep, PKG_DEP_VERSION),
 		if (run_prstmt(DEPS, pkg_dep_origin(dep),
 		    pkg_dep_name(dep), pkg_dep_version(dep),
 		    package_id) != SQLITE_DONE) {
 			ERROR_SQLITE(s);
 			goto cleanup;

@@ -1814,10 +1814,10 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg, int complete)

 	 */
 	while (pkg_files(pkg, &file) == EPKG_OK) {
 		if ((ret = run_prstmt(FILES, pkg_file_get(file, PKG_FILE_PATH),
 		    pkg_file_get(file, PKG_FILE_SUM), package_id)) != SQLITE_DONE) {
 		if ((ret = run_prstmt(FILES, pkg_file_path(file),
 		    pkg_file_cksum(file), package_id)) != SQLITE_DONE) {
 			if (ret == SQLITE_CONSTRAINT) {
 				if ((it = pkgdb_query_which(db, pkg_file_get(file, PKG_FILE_PATH))) == NULL) {
 				if ((it = pkgdb_query_which(db, pkg_file_path(file))) == NULL) {
 					ERROR_SQLITE(s);
 				}
 				if ((ret = pkgdb_it_next(it, &pkg2, PKG_LOAD_BASIC)) == EPKG_OK) {

@@ -1826,7 +1826,7 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg, int complete)

 					    " (installs files into the same place). "
 					    " Problematic file: %s",
 					    name, version, name2, version2,
 					    pkg_file_get(file, PKG_FILE_PATH));
 					    pkg_file_path(file));
 					pkg_free(pkg2);
 				} else {
 					ERROR_SQLITE(s);

@@ -2967,13 +2967,13 @@ pkgdb_integrity_append(struct pkgdb *db, struct pkg *p)

 		sqlite3_bind_text(stmt, 1, name, -1, SQLITE_STATIC);
 		sqlite3_bind_text(stmt, 2, origin, -1, SQLITE_STATIC);
 		sqlite3_bind_text(stmt, 3, version, -1, SQLITE_STATIC);
 		sqlite3_bind_text(stmt, 4, pkg_file_get(file, PKG_FILE_PATH), -1, SQLITE_STATIC);
 		sqlite3_bind_text(stmt, 4, pkg_file_path(file), -1, SQLITE_STATIC);
 		if (sqlite3_step(stmt) != SQLITE_DONE) {
 			sbuf_clear(conflictmsg);
 			sbuf_printf(conflictmsg, "WARNING: %s-%s conflict on %s with: \n",
 			    name, version,
 			    pkg_file_get(file, PKG_FILE_PATH));
 			    pkg_file_path(file));
 			if (sqlite3_prepare_v2(db->sqlite, sql_conflicts, -1, &stmt_conflicts, NULL) != SQLITE_OK) {
 				ERROR_SQLITE(db->sqlite);

@@ -2982,7 +2982,7 @@ pkgdb_integrity_append(struct pkgdb *db, struct pkg *p)

 				return (EPKG_FATAL);
 			}
 			sqlite3_bind_text(stmt_conflicts, 1, pkg_file_get(file, PKG_FILE_PATH), -1, SQLITE_STATIC);
 			sqlite3_bind_text(stmt_conflicts, 1, pkg_file_path(file), -1, SQLITE_STATIC);
 			while (sqlite3_step(stmt_conflicts) != SQLITE_DONE) {
 				sbuf_printf(conflictmsg, "\t- %s-%s\n",

@@ -3195,7 +3195,7 @@ pkgdb_file_set_cksum(struct pkgdb *db, struct pkg_file *file, const char *sha256

 		return (EPKG_FATAL);
 	}
 	sqlite3_bind_text(stmt, 1, sha256, -1, SQLITE_STATIC);
 	sqlite3_bind_text(stmt, 2, pkg_file_get(file, PKG_FILE_PATH), -1, SQLITE_STATIC);
 	sqlite3_bind_text(stmt, 2, pkg_file_path(file), -1, SQLITE_STATIC);
 	if (sqlite3_step(stmt) != SQLITE_DONE) {
 		ERROR_SQLITE(db->sqlite);

modified libpkg/rcscripts.c

@@ -54,8 +54,8 @@ pkg_start_stop_rc_scripts(struct pkg *pkg, pkg_rc_attr attr)

 	len = strlen(rc_d_path);
 	while (pkg_files(pkg, &file) == EPKG_OK) {
 		if (strncmp(rc_d_path, pkg_file_get(file, PKG_FILE_PATH), len) == 0) {
 			rcfile = pkg_file_get(file, PKG_FILE_PATH);
 		if (strncmp(rc_d_path, pkg_file_path(file), len) == 0) {
 			rcfile = pkg_file_path(file);
 			rcfile += len;
 			rc = strrchr(rcfile, '/');
 			rc++;

modified pkg/check.c

@@ -71,9 +71,9 @@ check_deps(struct pkgdb *db, struct pkg *p, struct deps_head *dh)

 	while (pkg_deps(p, &dep) == EPKG_OK) {
 		/* do we have a missing dependency? */
 		if (pkg_is_installed(db, pkg_dep_get(dep, PKG_DEP_ORIGIN)) != EPKG_OK) {
 		if (pkg_is_installed(db, pkg_dep_origin(dep)) != EPKG_OK) {
 			printf("%s has a missing dependency: %s\n", origin,
 			       pkg_dep_get(dep, PKG_DEP_ORIGIN)),
 			       pkg_dep_origin(dep)),
 			add_missing_dep(dep, dh, &nbpkgs);
 		}
 	}

@@ -90,7 +90,7 @@ add_missing_dep(struct pkg_dep *d, struct deps_head *dh, int *nbpkgs)

 	assert(d != NULL);
 	/* do not add duplicate entries in the queue */
 	origin = pkg_dep_get(d, PKG_DEP_ORIGIN);
 	origin = pkg_dep_origin(d);
 	STAILQ_FOREACH(e, dh, next)
 		if (strcmp(e->origin, origin) == 0)

@@ -99,9 +99,9 @@ add_missing_dep(struct pkg_dep *d, struct deps_head *dh, int *nbpkgs)

 	if ((e = calloc(1, sizeof(struct deps_entry))) == NULL)
 		err(1, "calloc(deps_entry)");
 	e->name = strdup(pkg_dep_get(d, PKG_DEP_NAME));
 	e->version = strdup(pkg_dep_get(d, PKG_DEP_VERSION));
 	e->origin = strdup(pkg_dep_get(d, PKG_DEP_ORIGIN));
 	e->name = strdup(pkg_dep_name(d));
 	e->version = strdup(pkg_dep_version(d));
 	e->origin = strdup(pkg_dep_origin(d));
 	(*nbpkgs)++;

modified pkg/event.c

@@ -144,7 +144,7 @@ event_callback(void *data, struct pkg_event *ev)

 		pkg_get(pkg, PKG_NAME, &name, PKG_VERSION, &version);
 		fprintf(stderr, "%s-%s is required by:", name, version);
 		while (pkg_rdeps(pkg, &dep) == EPKG_OK) {
 			fprintf(stderr, " %s-%s", pkg_dep_get(dep, PKG_DEP_NAME), pkg_dep_get(dep, PKG_DEP_VERSION));
 			fprintf(stderr, " %s-%s", pkg_dep_name(dep), pkg_dep_version(dep));
 		}
 		if (ev->e_required.force == 1)
 			fprintf(stderr, ", deleting anyway\n");

@@ -158,8 +158,8 @@ event_callback(void *data, struct pkg_event *ev)

 		printf("%s-%s already installed\n", name, version);
 		break;
 	case PKG_EVENT_MISSING_DEP:
 		fprintf(stderr, "missing dependency %s-%s", pkg_dep_get(ev->e_missing_dep.dep, PKG_DEP_NAME),
 		    pkg_dep_get(ev->e_missing_dep.dep, PKG_DEP_VERSION));
 		fprintf(stderr, "missing dependency %s-%s", pkg_dep_name(ev->e_missing_dep.dep),
 		    pkg_dep_version(ev->e_missing_dep.dep));
 		break;
 	case PKG_EVENT_NOREMOTEDB:
 		fprintf(stderr, "Unable to open remote database \"%s\". Try running '%s update' first.\n", ev->e_remotedb.repo, getprogname());

@@ -175,7 +175,7 @@ event_callback(void *data, struct pkg_event *ev)

 		break;
 	case PKG_EVENT_FILE_MISMATCH:
 		pkg_get(ev->e_file_mismatch.pkg, PKG_NAME, &name, PKG_VERSION, &version);
 		fprintf(stderr, "%s-%s: checksum mismatch for %s\n", name, version, pkg_file_get(ev->e_file_mismatch.file, PKG_FILE_PATH));
 		fprintf(stderr, "%s-%s: checksum mismatch for %s\n", name, version, pkg_file_path(ev->e_file_mismatch.file));
 	default:
 		break;
 	}

modified pkg/query.c

@@ -198,20 +198,20 @@ format_str(struct pkg *pkg, struct sbuf *dest, const char *qstr, void *data)

 				case 'd':
 					qstr++;
 					if (qstr[0] == 'n')
 						sbuf_cat(dest, pkg_dep_get((struct pkg_dep *)data, PKG_DEP_NAME));
 						sbuf_cat(dest, pkg_dep_name((struct pkg_dep *)data));
 					else if (qstr[0] == 'o')
 						sbuf_cat(dest, pkg_dep_get((struct pkg_dep *)data, PKG_DEP_ORIGIN));
 						sbuf_cat(dest, pkg_dep_origin((struct pkg_dep *)data));
 					else if (qstr[0] == 'v')
 						sbuf_cat(dest, pkg_dep_get((struct pkg_dep *)data, PKG_DEP_VERSION));
 						sbuf_cat(dest, pkg_dep_version((struct pkg_dep *)data));
 					break;
 				case 'r':
 					qstr++;
 					if (qstr[0] == 'n')
 						sbuf_cat(dest, pkg_dep_get((struct pkg_dep *)data, PKG_DEP_NAME));
 						sbuf_cat(dest, pkg_dep_name((struct pkg_dep *)data));
 					else if (qstr[0] == 'o')
 						sbuf_cat(dest, pkg_dep_get((struct pkg_dep *)data, PKG_DEP_ORIGIN));
 						sbuf_cat(dest, pkg_dep_origin((struct pkg_dep *)data));
 					else if (qstr[0] == 'v')
 						sbuf_cat(dest, pkg_dep_get((struct pkg_dep *)data, PKG_DEP_VERSION));
 						sbuf_cat(dest, pkg_dep_version((struct pkg_dep *)data));
 					break;
 				case 'C':
 					sbuf_cat(dest, pkg_category_name((struct pkg_category *)data));

@@ -219,9 +219,9 @@ format_str(struct pkg *pkg, struct sbuf *dest, const char *qstr, void *data)

 				case 'F':
 					qstr++;
 					if (qstr[0] == 'p')
 						sbuf_cat(dest, pkg_file_get((struct pkg_file *)data, PKG_FILE_PATH));
 						sbuf_cat(dest, pkg_file_path((struct pkg_file *)data));
 					else if (qstr[0] == 's')
 						sbuf_cat(dest, pkg_file_get((struct pkg_file *)data, PKG_FILE_SUM));
 						sbuf_cat(dest, pkg_file_cksum((struct pkg_file *)data));
 					break;
 				case 'O':
 					qstr++;

modified pkg/utils.c

@@ -220,7 +220,7 @@ print_info(struct pkg * const pkg, unsigned int opt)

 			printf("%s-%s depends on:\n", name, version);
                 while (pkg_deps(pkg, &dep) == EPKG_OK) {
                         printf("%s-%s\n", pkg_dep_get(dep, PKG_DEP_NAME), pkg_dep_get(dep, PKG_DEP_VERSION));
                         printf("%s-%s\n", pkg_dep_name(dep), pkg_dep_version(dep));
                 }
                 if (!(opt & INFO_QUIET))

@@ -233,7 +233,7 @@ print_info(struct pkg * const pkg, unsigned int opt)

 			printf("%s-%s is required by:\n", name, version);
                 while (pkg_rdeps(pkg, &dep) == EPKG_OK) {
                         printf("%s-%s\n", pkg_dep_get(dep, PKG_DEP_NAME), pkg_dep_get(dep, PKG_DEP_VERSION));
                         printf("%s-%s\n", pkg_dep_name(dep), pkg_dep_version(dep));
                 }
                 if (!(opt & INFO_QUIET))

@@ -243,7 +243,7 @@ print_info(struct pkg * const pkg, unsigned int opt)

 			printf("%s-%s owns the following files:\n", name, version);
                 while (pkg_files(pkg, &file) == EPKG_OK) {
                         printf("%s\n", pkg_file_get(file, PKG_FILE_PATH));
                         printf("%s\n", pkg_file_path(file));
                 }
                 if (!(opt & INFO_QUIET))