int
pkg_register_shlibs(struct pkg *pkg, const char *root)
{
struct pkg_file *file = NULL;
char fpath[MAXPATHLEN];
pkg_list_free(pkg, PKG_SHLIBS_REQUIRED);
if (elf_version(EV_CURRENT) == EV_NONE)
return (EPKG_FATAL);
shlib_list_init();
if (shlib_list_from_elf_hints(_PATH_ELF_HINTS) != EPKG_OK) {
shlib_list_free();
return (EPKG_FATAL);
}
while(pkg_files(pkg, &file) == EPKG_OK) {
if (root != NULL) {
snprintf(fpath, sizeof(fpath), "%s%s", root, pkg_file_path(file));
analyse_elf(pkg, fpath, add_shlibs_to_pkg, NULL);
} else
analyse_elf(pkg, pkg_file_path(file), add_shlibs_to_pkg, NULL);
}
shlib_list_free();
return (EPKG_OK);
}
int
pkg_analyse_files(struct pkgdb *db, struct pkg *pkg, const char *stage)
{
struct pkg_file *file = NULL;
int ret = EPKG_OK;
char fpath[MAXPATHLEN];
bool autodeps = false;
bool developer = false;
int (*action)(void *, struct pkg *, const char *, const char *, bool);
pkg_config_bool(PKG_CONFIG_AUTODEPS, &autodeps);
pkg_config_bool(PKG_CONFIG_DEVELOPER_MODE, &developer);
if (elf_version(EV_CURRENT) == EV_NONE)
return (EPKG_FATAL);
if (autodeps)
action = test_depends;
else
action = add_shlibs_to_pkg;
shlib_list_init();
ret = shlib_list_from_elf_hints(_PATH_ELF_HINTS);
if (ret != EPKG_OK)
goto cleanup;
/* Assume no architecture dependence, for contradiction */
if (developer)
pkg->flags &= ~(PKG_CONTAINS_ELF_OBJECTS |
PKG_CONTAINS_STATIC_LIBS |
PKG_CONTAINS_H_OR_LA);
while (pkg_files(pkg, &file) == EPKG_OK) {
if (stage != NULL)
snprintf(fpath, sizeof(fpath), "%s/%s", stage, pkg_file_path(file));
else
strlcpy(fpath, pkg_file_path(file), sizeof(fpath));
ret = analyse_elf(pkg, fpath, action, db);
if (developer) {
if (ret != EPKG_OK && ret != EPKG_END)
goto cleanup;
analyse_fpath(pkg, fpath);
}
}
ret = EPKG_OK;
cleanup:
shlib_list_free();
return (ret);
}
/* ARGSUSED */
static int
add_shlibs_to_pkg(__unused void *actdata, struct pkg *pkg, const char *fpath,
const char *name, bool is_shlib)
{
const char *pkgname, *pkgversion;
struct pkg_file *file = NULL;
const char *filepath;
switch(filter_system_shlibs(name, NULL, 0)) {
case EPKG_OK: /* A non-system library */
pkg_addshlib_required(pkg, name);
return (EPKG_OK);
case EPKG_END: /* A system library */
return (EPKG_OK);
default:
/* Ignore link resolution errors if we're analysing a
shared library. */
if (is_shlib)
return (EPKG_OK);
while (pkg_files(pkg, &file) == EPKG_OK) {
filepath = pkg_file_path(file);
if (strcmp(&filepath[strlen(filepath) - strlen(name)], name) == 0) {
pkg_addshlib_required(pkg, name);
return (EPKG_OK);
}
}
pkg_get(pkg, PKG_NAME, &pkgname, PKG_VERSION, &pkgversion);
warnx("(%s-%s) %s - shared library %s not found",
pkgname, pkgversion, fpath, name);
return (EPKG_FATAL);
}
}
int
pkg_register_shlibs(struct pkg *pkg)
{
struct pkg_file *file = NULL;
bool shlibs;
pkg_config_bool(PKG_CONFIG_SHLIBS, &shlibs);
pkg_list_free(pkg, PKG_SHLIBS_REQUIRED);
if (!shlibs)
return (EPKG_OK);
if (elf_version(EV_CURRENT) == EV_NONE)
return (EPKG_FATAL);
shlib_list_init();
if (shlib_list_from_elf_hints(_PATH_ELF_HINTS) != EPKG_OK) {
shlib_list_free();
return (EPKG_FATAL);
}
while(pkg_files(pkg, &file) == EPKG_OK)
analyse_elf(pkg, pkg_file_path(file), add_shlibs_to_pkg, NULL);
shlib_list_free();
return (EPKG_OK);
}
int
pkg_analyse_files(struct pkgdb *db, struct pkg *pkg)
{
struct pkg_file *file = NULL;
int ret = EPKG_OK;
const char *fpath;
bool shlibs = false;
bool autodeps = false;
bool developer = false;
int (*action)(void *, struct pkg *, const char *, const char *, bool);
pkg_config_bool(PKG_CONFIG_SHLIBS, &shlibs);
pkg_config_bool(PKG_CONFIG_AUTODEPS, &autodeps);
pkg_config_bool(PKG_CONFIG_DEVELOPER_MODE, &developer);
if (!autodeps && !shlibs && !developer)
return (EPKG_OK);
if (elf_version(EV_CURRENT) == EV_NONE)
return (EPKG_FATAL);
if (autodeps)
action = test_depends;
else if (shlibs)
action = add_shlibs_to_pkg;
else
action = do_nothing;
if (autodeps || shlibs) {
shlib_list_init();
ret = shlib_list_from_elf_hints(_PATH_ELF_HINTS);
if (ret != EPKG_OK)
goto cleanup;
}
/* Assume no architecture dependence, for contradiction */
if (developer)
pkg->flags &= ~(PKG_CONTAINS_ELF_OBJECTS |
PKG_CONTAINS_STATIC_LIBS |
PKG_CONTAINS_H_OR_LA);
while (pkg_files(pkg, &file) == EPKG_OK) {
fpath = pkg_file_path(file);
ret = analyse_elf(pkg, fpath, action, db);
if (developer) {
if (ret != EPKG_OK && ret != EPKG_END)
goto cleanup;
analyse_fpath(pkg, fpath);
}
}
ret = EPKG_OK;
cleanup:
if (autodeps || shlibs)
shlib_list_free();
return (ret);
}
int
pkg_delete_files(struct pkg *pkg, bool force)
{
struct pkg_file *file = NULL;
char sha256[SHA256_DIGEST_LENGTH * 2 + 1];
const char *path;
while (pkg_files(pkg, &file) == EPKG_OK) {
const char *sum = pkg_file_cksum(file);
if (file->keep == 1)
continue;
path = pkg_file_path(file);
/* Regular files and links */
/* check sha256 */
if (!force && sum[0] != '\0') {
if (sha256_file(path, sha256) != EPKG_OK)
continue;
if (strcmp(sha256, sum)) {
pkg_emit_error("%s fails original SHA256 "
"checksum, not removing", path);
continue;
}
}
if (unlink(path) == -1) {
pkg_emit_errno("unlink", path);
continue;
}
}
return (EPKG_OK);
}
int
pkg_delete_files(struct pkg *pkg, int force)
{
struct pkg_file *file = NULL;
char sha256[SHA256_DIGEST_LENGTH * 2 + 1];
const char *path;
while (pkg_files(pkg, &file) == EPKG_OK) {
path = pkg_file_path(file);
/* Regular files and links */
/* check sha256 */
if (!force && pkg_file_sha256(file)[0] != '\0') {
if (sha256_file(path, sha256) == -1) {
pkg_emit_error("sha256 calculation failed for '%s'",
path);
} else if (strcmp(sha256, pkg_file_sha256(file)) != 0) {
pkg_emit_error("%s fails original SHA256 checksum,"
" not removing", path);
continue;
}
}
if (unlink(path) == -1) {
pkg_emit_errno("unlink", path);
continue;
}
}
return (EPKG_OK);
}
void
pkg_delete_file(struct pkg *pkg, struct pkg_file *file, unsigned force)
{
const char *sum = pkg_file_cksum(file);
const char *path;
const char *prefix_rel;
struct stat st;
size_t len;
char sha256[SHA256_DIGEST_LENGTH * 2 + 1];
pkg_open_root_fd(pkg);
path = pkg_file_path(file);
path++;
pkg_get(pkg, PKG_PREFIX, &prefix_rel);
prefix_rel++;
len = strlen(prefix_rel);
/* Regular files and links */
/* check sha256 */
if (!force && sum[0] != '\0') {
if (fstatat(pkg->rootfd, path, &st, AT_SYMLINK_NOFOLLOW) == -1) {
pkg_emit_error("cannot stat %s: %s", path, strerror(errno));
return;
}
if (S_ISLNK(st.st_mode)) {
if (pkg_symlink_cksumat(pkg->rootfd, path, NULL,
sha256) != EPKG_OK)
return;
}
else {
if (sha256_fileat(pkg->rootfd, path, sha256) != EPKG_OK)
return;
}
if (strcmp(sha256, sum)) {
pkg_emit_error("%s fails original SHA256 "
"checksum, not removing", path);
return;
}
}
if (unlinkat(pkg->rootfd, path, 0) == -1) {
if (force < 2)
pkg_emit_errno("unlinkat", path);
return;
}
/* do not bother about directories not in prefix */
if ((strncmp(prefix_rel, path, len) == 0) && path[len] == '/')
pkg_add_dir_to_del(pkg, path, NULL);
}
int
pkg_analyse_files(struct pkgdb *db, struct pkg *pkg)
{
struct pkg_file *file = NULL;
if (elf_version(EV_CURRENT) == EV_NONE)
return (EPKG_FATAL);
while (pkg_files(pkg, &file) == EPKG_OK)
analyse_elf(db, pkg, pkg_file_path(file));
return (EPKG_OK);
}
int
pkg_delete_files(struct pkg *pkg, int force)
{
int do_remove, i;
int ret = EPKG_OK;
struct pkg_file **files;
char sha256[65];
const char *path;
files = pkg_files(pkg);
for (i = 0; files[i] != NULL; i++) {
path = pkg_file_path(files[i]);
/* Directories */
if (path[strlen(path) - 1] == '/') {
/*
* currently do not warn on this because multiple
* packages can own the same directory
*/
rmdir(path);
continue;
}
/* Regular files and links */
/* check sha256 */
do_remove = 1;
if (pkg_file_sha256(files[i])[0] != '\0') {
if (sha256_file(path, sha256) == -1) {
warnx("sha256 calculation failed for '%s'",
path);
} else {
if (strcmp(sha256, pkg_file_sha256(files[i])) != 0) {
if (force)
warnx("%s fails original SHA256 checksum", path);
else {
do_remove = 0;
warnx("%s fails original SHA256 checksum, not removing", path);
}
}
}
}
if (do_remove && unlink(path) == -1) {
warn("unlink(%s)", path);
continue;
}
}
return (ret);
}
int
pkg_analyse_files(struct pkgdb *db, struct pkg *pkg)
{
struct pkg_file **files;
int i;
if (elf_version(EV_CURRENT) == EV_NONE)
return (EPKG_FATAL);
if ((files = pkg_files(pkg)) != NULL)
for (i = 0; files[i] != NULL ; i++)
analyse_elf(db, pkg, pkg_file_path(files[i]));
return (EPKG_OK);
}
int
pkg_delete_files(struct pkg *pkg, unsigned force)
/* force: 0 ... be careful and vocal about it.
* 1 ... remove files without bothering about checksums.
* 2 ... like 1, but remain silent if removal fails.
*/
{
struct pkg_file *file = NULL;
char sha256[SHA256_DIGEST_LENGTH * 2 + 1];
const char *path;
char fpath[MAXPATHLEN];
while (pkg_files(pkg, &file) == EPKG_OK) {
const char *sum = pkg_file_cksum(file);
ucl_object_t *obj;
if (file->keep == 1)
continue;
path = pkg_file_path(file);
obj = pkg_annotation_lookup(pkg, "relocated");
snprintf(fpath, sizeof(fpath), "%s%s",
obj ? pkg_object_string(obj) : "" , path );
/* Regular files and links */
/* check sha256 */
if (!force && sum[0] != '\0') {
if (sha256_file(fpath, sha256) != EPKG_OK)
continue;
if (strcmp(sha256, sum)) {
pkg_emit_error("%s fails original SHA256 "
"checksum, not removing", path);
continue;
}
}
if (unlink(fpath) == -1) {
if (force < 2)
pkg_emit_errno("unlink", fpath);
continue;
}
}
return (EPKG_OK);
}
int
pkg_to_old(struct pkg *p)
{
struct pkg_file *f = NULL;
char md5[MD5_DIGEST_LENGTH * 2 + 1];
const char *sum;
p->type = PKG_OLD_FILE;
while (pkg_files(p, &f) == EPKG_OK) {
sum = pkg_file_cksum(f);
if (sum == NULL || sum[0] == '\0')
continue;
if (md5_file(pkg_file_path(f), md5) == EPKG_OK)
strlcpy(f->sum, md5, sizeof(f->sum));
}
return (EPKG_OK);
}
int
pkg_from_old(struct pkg *p)
{
struct pkg_file *f = NULL;
char sha256[SHA256_DIGEST_LENGTH * 2 + 1];
const char *sum;
p->type = PKG_INSTALLED;
while (pkg_files(p, &f) == EPKG_OK) {
sum = pkg_file_cksum(f);
if (sum == NULL || sum[0] == '\0')
continue;
if (sha256_file(pkg_file_path(f), sha256) == EPKG_OK)
strlcpy(f->sum, sha256, sizeof(f->sum));
}
return (EPKG_OK);
}
void
pkg_delete_file(struct pkg *pkg, struct pkg_file *file, unsigned force)
{
const char *sum = pkg_file_cksum(file);
const char *path;
struct stat st;
char sha256[SHA256_DIGEST_LENGTH * 2 + 1];
pkg_open_root_fd(pkg);
path = pkg_file_path(file);
path++;
/* Regular files and links */
/* check sha256 */
if (!force && sum[0] != '\0') {
if (fstatat(pkg->rootfd, path, &st, AT_SYMLINK_NOFOLLOW) == -1) {
pkg_emit_error("cannot stat %s: %s", path, strerror(errno));
return;
}
if (S_ISLNK(st.st_mode)) {
if (pkg_symlink_cksumat(pkg->rootfd, path, NULL,
sha256) != EPKG_OK)
return;
}
else {
if (sha256_fileat(pkg->rootfd, path, sha256) != EPKG_OK)
return;
}
if (strcmp(sha256, sum)) {
pkg_emit_error("%s fails original SHA256 "
"checksum, not removing", path);
return;
}
}
if (unlinkat(pkg->rootfd, path, 0) == -1) {
if (force < 2)
pkg_emit_errno("unlinkat", path);
return;
}
}
int
pkg_delete_files(struct pkg *pkg, unsigned force)
/* force: 0 ... be careful and vocal about it.
* 1 ... remove files without bothering about checksums.
* 2 ... like 1, but remain silent if removal fails.
*/
{
struct pkg_file *file = NULL;
char sha256[SHA256_DIGEST_LENGTH * 2 + 1];
const char *path;
while (pkg_files(pkg, &file) == EPKG_OK) {
const char *sum = pkg_file_cksum(file);
if (file->keep == 1)
continue;
path = pkg_file_path(file);
/* Regular files and links */
/* check sha256 */
if (!force && sum[0] != '\0') {
if (sha256_file(path, sha256) != EPKG_OK)
continue;
if (strcmp(sha256, sum)) {
pkg_emit_error("%s fails original SHA256 "
"checksum, not removing", path);
continue;
}
}
if (unlink(path) == -1) {
if (force < 2)
pkg_emit_errno("unlink", path);
continue;
}
}
return (EPKG_OK);
}
int
event_callback(void *data, struct pkg_event *ev)
{
struct pkg *pkg = NULL;
struct pkg_dep *dep = NULL;
const char *message;
int *debug = data;
(void) debug;
const char *name, *version, *newversion;
const char *filename;
struct pkg_event_conflict *cur_conflict;
switch(ev->type) {
case PKG_EVENT_ERRNO:
warnx("%s(%s): %s", ev->e_errno.func, ev->e_errno.arg,
strerror(ev->e_errno.no));
break;
case PKG_EVENT_ERROR:
warnx("%s", ev->e_pkg_error.msg);
break;
case PKG_EVENT_NOTICE:
if (!quiet)
warnx("%s", ev->e_pkg_notice.msg);
break;
case PKG_EVENT_DEVELOPER_MODE:
warnx("DEVELOPER_MODE: %s", ev->e_pkg_error.msg);
break;
case PKG_EVENT_FETCHING:
if (quiet || !isatty(fileno(stdin)))
break;
if (fetched == 0) {
filename = strrchr(ev->e_fetching.url, '/');
if (filename != NULL) {
filename++;
} else {
/*
* We failed at being smart, so display
* the entire url.
*/
filename = ev->e_fetching.url;
}
strlcpy(url, filename, sizeof(url));
start_progress_meter(url, ev->e_fetching.total,
&fetched);
}
fetched = ev->e_fetching.done;
if (ev->e_fetching.done == ev->e_fetching.total) {
stop_progress_meter();
fetched = 0;
}
break;
case PKG_EVENT_INSTALL_BEGIN:
if (quiet)
break;
pkg_get(ev->e_install_begin.pkg, PKG_NAME, &name,
PKG_VERSION, &version);
nbdone++;
if (nbactions > 0)
printf("[%d/%d] ", nbdone, nbactions);
printf("Installing %s-%s...", name, version);
/* print to the terminal title*/
printf("%c]0;[%d/%d] Installing %s-%s%c", '\033', nbdone, nbactions, name, version, '\007');
break;
case PKG_EVENT_INSTALL_FINISHED:
if (quiet)
break;
printf(" done\n");
pkg_get(ev->e_install_finished.pkg, PKG_MESSAGE, &message);
if (message != NULL && message[0] != '\0') {
if (messages == NULL)
messages = sbuf_new_auto();
sbuf_printf(messages, "%s\n", message);
}
break;
case PKG_EVENT_INTEGRITYCHECK_BEGIN:
if (quiet)
break;
printf("Checking integrity...");
break;
case PKG_EVENT_INTEGRITYCHECK_FINISHED:
if (quiet)
break;
printf(" done\n");
break;
case PKG_EVENT_INTEGRITYCHECK_CONFLICT:
printf("\nConflict found on path %s between %s-%s(%s) and ",
ev->e_integrity_conflict.pkg_path,
ev->e_integrity_conflict.pkg_name,
ev->e_integrity_conflict.pkg_version,
ev->e_integrity_conflict.pkg_origin);
cur_conflict = ev->e_integrity_conflict.conflicts;
while (cur_conflict) {
if (cur_conflict->next)
printf("%s-%s(%s), ", cur_conflict->name, cur_conflict->version, cur_conflict->origin);
else
printf("%s-%s(%s)", cur_conflict->name, cur_conflict->version, cur_conflict->origin);
cur_conflict = cur_conflict->next;
}
printf("\n");
break;
case PKG_EVENT_DEINSTALL_BEGIN:
if (quiet)
break;
pkg_get(ev->e_deinstall_begin.pkg, PKG_NAME, &name,
PKG_VERSION, &version);
nbdone++;
if (nbactions > 0)
printf("[%d/%d] ", nbdone, nbactions);
printf("Deleting %s-%s...", name, version);
printf("%c]0;[%d/%d] Deleting %s-%s%c", '\033', nbdone,
nbactions, name, version, '\007');
break;
case PKG_EVENT_DEINSTALL_FINISHED:
if (quiet)
break;
printf(" done\n");
break;
case PKG_EVENT_UPGRADE_BEGIN:
if (quiet)
break;
pkg_get(ev->e_upgrade_begin.pkg, PKG_NAME, &name,
PKG_VERSION, &newversion, PKG_OLD_VERSION, &version);
nbdone++;
if (nbactions > 0)
printf("[%d/%d] ", nbdone, nbactions);
switch (pkg_version_cmp(version, newversion)) {
case 1:
printf("Downgrading %s from %s to %s...",
name, version, newversion);
printf("%c]0;[%d/%d] Downgrading %s from %s to %s%c",
'\033', nbdone, nbactions, name, version,
newversion, '\007');
break;
case 0:
printf("Reinstalling %s-%s",
name, version);
printf("%c]0;[%d/%d] Reinstalling %s-%s%c", '\033',
nbdone, nbactions, name, version, '\007');
break;
case -1:
printf("Upgrading %s from %s to %s...",
name, version, newversion);
printf("%c]0;[%d/%d] Upgrading %s from %s to %s%c",
'\033', nbdone, nbactions, name, version,
newversion, '\007');
break;
}
break;
case PKG_EVENT_UPGRADE_FINISHED:
if (quiet)
break;
printf(" done\n");
break;
case PKG_EVENT_LOCKED:
pkg = ev->e_locked.pkg;
pkg_get(pkg, PKG_NAME, &name, PKG_VERSION, &version);
fprintf(stderr, "\n%s-%s is locked and may not be modified\n",
name, version);
break;
case PKG_EVENT_REQUIRED:
pkg = ev->e_required.pkg;
pkg_get(pkg, PKG_NAME, &name, PKG_VERSION, &version);
fprintf(stderr, "\n%s-%s is required by:", name, version);
while (pkg_rdeps(pkg, &dep) == EPKG_OK)
fprintf(stderr, " %s-%s", pkg_dep_name(dep),
pkg_dep_version(dep));
if (ev->e_required.force == 1)
fprintf(stderr, ", deleting anyway\n");
else
fprintf(stderr, "\n");
break;
case PKG_EVENT_ALREADY_INSTALLED:
if (quiet)
break;
pkg_get(ev->e_already_installed.pkg, PKG_NAME, &name,
PKG_VERSION, &version);
printf("%s-%s already installed\n", name, version);
break;
case PKG_EVENT_NOT_FOUND:
printf("Package '%s' was not found in "
"the repositories\n", ev->e_not_found.pkg_name);
break;
case PKG_EVENT_MISSING_DEP:
fprintf(stderr, "missing dependency %s-%s\n",
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());
break;
case PKG_EVENT_NOLOCALDB:
fprintf(stderr, "Local package database nonexistent!\n");
break;
case PKG_EVENT_NEWPKGVERSION:
printf("New version of pkg detected; it needs to be "
"installed first.\nAfter this upgrade it is recommended "
"that you do a full upgrade using: 'pkg upgrade'\n\n");
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_path(ev->e_file_mismatch.file));
break;
case PKG_EVENT_PLUGIN_ERRNO:
warnx("%s: %s(%s): %s", pkg_plugin_get(ev->e_plugin_errno.plugin, PKG_PLUGIN_NAME),
ev->e_plugin_errno.func, ev->e_plugin_errno.arg, strerror(ev->e_plugin_errno.no));
break;
case PKG_EVENT_PLUGIN_ERROR:
warnx("%s: %s", pkg_plugin_get(ev->e_plugin_error.plugin, PKG_PLUGIN_NAME), ev->e_plugin_error.msg);
break;
case PKG_EVENT_PLUGIN_INFO:
if (quiet)
break;
printf("%s: %s\n", pkg_plugin_get(ev->e_plugin_info.plugin, PKG_PLUGIN_NAME), ev->e_plugin_info.msg);
break;
case PKG_EVENT_INCREMENTAL_UPDATE:
if (!quiet)
printf("Incremental update completed, %d packages processed:\n"
"%d packages updated, %d removed and %d added.\n",
ev->e_incremental_update.processed,
ev->e_incremental_update.updated,
ev->e_incremental_update.removed,
ev->e_incremental_update.added);
break;
default:
break;
}
return 0;
}
int
event_callback(void *data, struct pkg_event *ev)
{
struct pkg *pkg = NULL;
struct pkg_dep *dep = NULL;
const char *message;
int *debug = data;
(void) debug;
const char *name, *version, *newversion;
const char *filename;
switch(ev->type) {
case PKG_EVENT_ERRNO:
warn("%s(%s)", ev->e_errno.func, ev->e_errno.arg);
break;
case PKG_EVENT_ERROR:
warnx("%s", ev->e_pkg_error.msg);
break;
case PKG_EVENT_FETCHING:
if (quiet)
break;
if (fetched == 0) {
filename = strrchr(ev->e_fetching.url, '/');
if (filename != NULL) {
filename++;
} else {
/*
* We failed at being smart, so display
* the entire url.
*/
filename = ev->e_fetching.url;
}
strlcpy(url, filename, sizeof(url));
start_progress_meter(url, ev->e_fetching.total,
&fetched);
}
fetched = ev->e_fetching.done;
if (ev->e_fetching.done == ev->e_fetching.total) {
stop_progress_meter();
fetched = 0;
}
break;
case PKG_EVENT_INSTALL_BEGIN:
if (quiet)
break;
pkg_get(ev->e_install_begin.pkg, PKG_NAME, &name,
PKG_VERSION, &version);
printf("Installing %s-%s...", name, version);
break;
case PKG_EVENT_INSTALL_FINISHED:
if (quiet)
break;
printf(" done\n");
pkg_get(ev->e_install_finished.pkg, PKG_MESSAGE, &message);
if (message != NULL && message[0] != '\0') {
if (messages == NULL)
messages = sbuf_new_auto();
sbuf_printf(messages, "%s\n", message);
}
break;
case PKG_EVENT_INTEGRITYCHECK_BEGIN:
if (quiet)
break;
printf("Checking integrity...");
break;
case PKG_EVENT_INTEGRITYCHECK_FINISHED:
if (quiet)
break;
printf(" done\n");
break;
case PKG_EVENT_DEINSTALL_BEGIN:
if (quiet)
break;
pkg_get(ev->e_deinstall_begin.pkg, PKG_NAME, &name,
PKG_VERSION, &version);
printf("Deinstalling %s-%s...", name, version);
break;
case PKG_EVENT_DEINSTALL_FINISHED:
if (quiet)
break;
printf(" done\n");
break;
case PKG_EVENT_UPGRADE_BEGIN:
if (quiet)
break;
pkg_get(ev->e_upgrade_finished.pkg, PKG_NAME, &name,
PKG_VERSION, &version, PKG_NEWVERSION, &newversion);
switch (pkg_version_cmp(version, newversion)) {
case 1:
printf("Downgrading %s from %s to %s...", name,
version, newversion);
break;
case 0:
printf("Reinstalling %s-%s", name, version);
break;
case -1:
printf("Upgrading %s from %s to %s...", name,
version, newversion);
break;
}
break;
case PKG_EVENT_UPGRADE_FINISHED:
if (quiet)
break;
printf(" done\n");
break;
case PKG_EVENT_REQUIRED:
pkg = ev->e_required.pkg;
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_name(dep),
pkg_dep_version(dep));
if (ev->e_required.force == 1)
fprintf(stderr, ", deleting anyway\n");
else
fprintf(stderr, "\n");
break;
case PKG_EVENT_ALREADY_INSTALLED:
if (quiet)
break;
pkg_get(ev->e_already_installed.pkg, PKG_NAME, &name,
PKG_VERSION, &version);
printf("%s-%s already installed\n", name, version);
break;
case PKG_EVENT_MISSING_DEP:
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());
break;
case PKG_EVENT_NOLOCALDB:
/* only cares if run as root */
if (geteuid() == 0)
fprintf(stderr, "Unable to create local database!\n");
break;
case PKG_EVENT_NEWPKGVERSION:
printf("New version of pkg detected; it needs to be "
"installed first.\nAfter this upgrade it is recommended"
"that you do a full upgrade using: 'pkg upgrade'\n\n");
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_path(ev->e_file_mismatch.file));
default:
break;
}
return 0;
}
static int
test_depends(void *actdata, struct pkg *pkg, const char *fpath,
const char *name, bool is_shlib)
{
struct pkgdb *db = actdata;
struct pkg_dep *dep = NULL;
struct pkgdb_it *it = NULL;
struct pkg *d;
const char *deporigin, *depname, *depversion;
const char *pkgname, *pkgversion;
bool deplocked;
char pathbuf[MAXPATHLEN];
struct pkg_file *file = NULL;
const char *filepath;
assert(db != NULL);
switch(filter_system_shlibs(name, pathbuf, sizeof(pathbuf))) {
case EPKG_OK: /* A non-system library */
break;
case EPKG_END: /* A system library */
return (EPKG_OK);
default:
/* Ignore link resolution errors if we're analysing a
shared library. */
if (is_shlib)
return (EPKG_OK);
while (pkg_files(pkg, &file) == EPKG_OK) {
filepath = pkg_file_path(file);
if (strcmp(&filepath[strlen(filepath) - strlen(name)], name) == 0) {
pkg_addshlib_required(pkg, name);
return (EPKG_OK);
}
}
pkg_get(pkg, PKG_NAME, &pkgname, PKG_VERSION, &pkgversion);
warnx("(%s-%s) %s - shared library %s not found",
pkgname, pkgversion, fpath, name);
return (EPKG_FATAL);
}
pkg_addshlib_required(pkg, name);
if ((it = pkgdb_query_which(db, pathbuf, false)) == NULL)
return (EPKG_OK);
d = NULL;
if (pkgdb_it_next(it, &d, PKG_LOAD_BASIC) == EPKG_OK) {
pkg_get(d, PKG_ORIGIN, &deporigin,
PKG_NAME, &depname,
PKG_VERSION, &depversion,
PKG_LOCKED, &deplocked);
dep = pkg_dep_lookup(pkg, deporigin);
if (dep == NULL) {
pkg_debug(1, "Autodeps: adding unlisted depends (%s): %s-%s",
pathbuf, depname, depversion);
pkg_adddep(pkg, depname, deporigin, depversion,
deplocked);
}
pkg_free(d);
}
pkgdb_it_free(it);
return (EPKG_OK);
}
void
test_manifest(void)
{
struct pkg *p = NULL;
struct pkg_dep *dep = NULL;
struct pkg_conflict *conflict = NULL;
struct pkg_option *option = NULL;
struct pkg_file *file = NULL;
int i;
ATF_REQUIRE_EQ(EPKG_OK, pkg_new(&p, PKG_FILE));
ATF_REQUIRE(p != NULL);
ATF_REQUIRE_EQ(EPKG_OK, pkg_parse_manifest(p, manifest));
#if 0
ATF_REQUIRE(strcmp(pkg_get(p, PKG_NAME), "foobar") == 0);
ATF_REQUIRE(strcmp(pkg_get(p, PKG_VERSION), "0.3") == 0);
ATF_REQUIRE(strcmp(pkg_get(p, PKG_ORIGIN), "foo/bar") == 0);
ATF_REQUIRE(strcmp(pkg_get(p, PKG_COMMENT), "A dummy manifest") == 0);
ATF_REQUIRE(strcmp(pkg_get(p, PKG_ARCH), "amd64") == 0);
ATF_REQUIRE(strcmp(pkg_get(p, PKG_VERSION), "800500") == 0);
ATF_REQUIRE(strcmp(pkg_get(p, PKG_WWW), "http://www.foobar.com") == 0);
ATF_REQUIRE(strcmp(pkg_get(p, PKG_MAINTAINER), "*****@*****.**") == 0);
#endif
i = 0;
while (pkg_deps(p, &dep) == EPKG_OK) {
if (i == 0) {
ATF_REQUIRE(strcmp(pkg_dep_name(dep), "depfoo") == 0);
ATF_REQUIRE(strcmp(pkg_dep_origin(dep), "dep/foo") == 0);
ATF_REQUIRE(strcmp(pkg_dep_version(dep), "1.2") == 0);
} else if (i == 1) {
ATF_REQUIRE(strcmp(pkg_dep_name(dep), "depbar") == 0);
ATF_REQUIRE(strcmp(pkg_dep_origin(dep), "dep/bar") == 0);
ATF_REQUIRE(strcmp(pkg_dep_version(dep), "3.4") == 0);
}
i++;
}
ATF_REQUIRE(i == 2);
i = 0;
#if 0
while (pkg_conflicts(p, &conflict) == EPKG_OK) {
if (i == 0) {
ATF_REQUIRE(strcmp(pkg_conflict_glob(conflict), "foo-*") == 0);
} else if (i == 1) {
ATF_REQUIRE(strcmp(pkg_conflict_glob(conflict), "bar-*") == 0);
}
i++;
}
ATF_REQUIRE(i == 2);
#endif
i = 0;
while (pkg_options(p, &option) == EPKG_OK) {
if (i == 0) {
ATF_REQUIRE(strcmp(pkg_option_opt(option), "foo") == 0);
ATF_REQUIRE(strcmp(pkg_option_value(option), "true") == 0);
} else if (i == 1) {
ATF_REQUIRE(strcmp(pkg_option_opt(option), "bar") == 0);
ATF_REQUIRE(strcmp(pkg_option_value(option), "false") == 0);
}
i++;
}
ATF_REQUIRE(i == 2);
ATF_REQUIRE(pkg_files(p, &file) == EPKG_OK);
ATF_REQUIRE(strcmp(pkg_file_path(file), "/usr/local/bin/foo") ==
0);
#if 0
ATF_REQUIRE(strcmp(pkg_file_sha256(file),
"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b")
== 0);
#endif
pkg_free(p);
/* p = NULL;
ATF_REQUIRE(pkg_new(&p, PKG_FILE) == EPKG_OK);
ATF_REQUIRE(pkg_parse_manifest(p, wrong_manifest1) == EPKG_FATAL);
pkg_free(p);
p = NULL;
ATF_REQUIRE(pkg_new(&p, PKG_FILE) == EPKG_OK);
ATF_REQUIRE(pkg_parse_manifest(p, wrong_manifest2) == EPKG_FATAL);
pkg_free(p);
p = NULL;
ATF_REQUIRE(pkg_new(&p, PKG_FILE) == EPKG_OK);
ATF_REQUIRE(pkg_parse_manifest(p, wrong_manifest3) == EPKG_FATAL);
pkg_free(p);
p = NULL;
ATF_REQUIRE(pkg_new(&p, PKG_FILE) == EPKG_OK);
ATF_REQUIRE(pkg_parse_manifest(p, wrong_manifest4) == EPKG_FATAL);
pkg_free(p);
*/
}
static int
pkg_create_from_dir(struct pkg *pkg, const char *root, struct packing *pkg_archive)
{
char fpath[MAXPATHLEN];
struct pkg_file **files;
struct pkg_script **scripts;
char *m;
int i;
const char *scriptname = NULL;
pkg_emit_manifest(pkg, &m);
packing_append_buffer(pkg_archive, m, "+MANIFEST", strlen(m));
free(m);
packing_append_buffer(pkg_archive, pkg_get(pkg, PKG_DESC), "+DESC", strlen(pkg_get(pkg, PKG_DESC)));
packing_append_buffer(pkg_archive, pkg_get(pkg, PKG_MTREE), "+MTREE_DIRS", strlen(pkg_get(pkg, PKG_MTREE)));
if ((scripts = pkg_scripts(pkg)) != NULL) {
for (i = 0; scripts[i] != NULL; i++) {
switch (pkg_script_type(scripts[i])) {
case PKG_SCRIPT_PRE_INSTALL:
scriptname = "+PRE_INSTALL";
break;
case PKG_SCRIPT_POST_INSTALL:
scriptname = "+POST_INSTALL";
break;
case PKG_SCRIPT_INSTALL:
scriptname = "+INSTALL";
break;
case PKG_SCRIPT_PRE_DEINSTALL:
scriptname = "+PRE_DEINSTALL";
break;
case PKG_SCRIPT_POST_DEINSTALL:
scriptname = "+POST_DEINSTALL";
break;
case PKG_SCRIPT_DEINSTALL:
scriptname = "+DEINSTALL";
break;
case PKG_SCRIPT_PRE_UPGRADE:
scriptname = "+PRE_UPGRADE";
break;
case PKG_SCRIPT_POST_UPGRADE:
scriptname = "+POST_UPGRADE";
break;
case PKG_SCRIPT_UPGRADE:
scriptname = "+UPGRADE";
break;
}
packing_append_buffer(pkg_archive, pkg_script_data(scripts[i]), scriptname, strlen(pkg_script_data(scripts[i])));
}
}
if ((files = pkg_files(pkg)) != NULL) {
for (i = 0; files[i] != NULL; i++) {
if (root != NULL)
snprintf(fpath, sizeof(MAXPATHLEN), "%s%s", root, pkg_file_path(files[i]));
else
strlcpy(fpath, pkg_file_path(files[i]), MAXPATHLEN);
packing_append_file(pkg_archive, fpath, pkg_file_path(files[i]));
}
}
return (EPKG_OK);
}
int
event_callback(void *data, struct pkg_event *ev)
{
struct pkg *pkg = NULL;
int *debug = data;
(void) debug;
const char *filename;
struct pkg_event_conflict *cur_conflict;
switch(ev->type) {
case PKG_EVENT_ERRNO:
warnx("%s(%s): %s", ev->e_errno.func, ev->e_errno.arg,
strerror(ev->e_errno.no));
break;
case PKG_EVENT_ERROR:
warnx("%s", ev->e_pkg_error.msg);
break;
case PKG_EVENT_NOTICE:
if (!quiet)
warnx("%s", ev->e_pkg_notice.msg);
break;
case PKG_EVENT_DEVELOPER_MODE:
warnx("DEVELOPER_MODE: %s", ev->e_pkg_error.msg);
break;
case PKG_EVENT_FETCHING:
if (quiet || !isatty(fileno(stdin)))
break;
if (fetched == 0) {
filename = strrchr(ev->e_fetching.url, '/');
if (filename != NULL) {
filename++;
} else {
/*
* We failed at being smart, so display
* the entire url.
*/
filename = ev->e_fetching.url;
}
strlcpy(url, filename, sizeof(url));
start_progress_meter(url, ev->e_fetching.total,
&fetched);
}
fetched = ev->e_fetching.done;
if (ev->e_fetching.done == ev->e_fetching.total) {
stop_progress_meter();
fetched = 0;
}
break;
case PKG_EVENT_INSTALL_BEGIN:
if (quiet)
break;
else {
struct sbuf *msg;
nbdone++;
msg = sbuf_new_auto();
if (msg == NULL) {
warn("sbuf_new_auto() failed");
break;
}
print_status_begin(msg);
pkg = ev->e_install_begin.pkg;
pkg_sbuf_printf(msg, "Installing %n-%v...", pkg, pkg);
print_status_end(msg);
}
break;
case PKG_EVENT_INSTALL_FINISHED:
if (quiet)
break;
printf(" done\n");
if (pkg_has_message(ev->e_install_finished.pkg)) {
if (messages == NULL)
messages = sbuf_new_auto();
pkg_sbuf_printf(messages, "%M\n",
ev->e_install_finished.pkg);
}
break;
case PKG_EVENT_INTEGRITYCHECK_BEGIN:
if (quiet)
break;
printf("Checking integrity...");
break;
case PKG_EVENT_INTEGRITYCHECK_FINISHED:
if (quiet)
break;
printf(" done\n");
break;
case PKG_EVENT_INTEGRITYCHECK_CONFLICT:
printf("\nConflict found on path %s between %s-%s(%s) and ",
ev->e_integrity_conflict.pkg_path,
ev->e_integrity_conflict.pkg_name,
ev->e_integrity_conflict.pkg_version,
ev->e_integrity_conflict.pkg_origin);
cur_conflict = ev->e_integrity_conflict.conflicts;
while (cur_conflict) {
if (cur_conflict->next)
printf("%s-%s(%s), ", cur_conflict->name,
cur_conflict->version,
cur_conflict->origin);
else
printf("%s-%s(%s)", cur_conflict->name,
cur_conflict->version,
cur_conflict->origin);
cur_conflict = cur_conflict->next;
}
printf("\n");
break;
case PKG_EVENT_DEINSTALL_BEGIN:
if (quiet)
break;
else {
struct sbuf *msg;
nbdone++;
msg = sbuf_new_auto();
if (msg == NULL) {
warn("sbuf_new_auto() failed");
break;
}
print_status_begin(msg);
pkg = ev->e_install_begin.pkg;
pkg_sbuf_printf(msg, "Deleting %n-%v...", pkg, pkg);
print_status_end(msg);
}
break;
case PKG_EVENT_DEINSTALL_FINISHED:
if (quiet)
break;
printf(" done\n");
break;
case PKG_EVENT_UPGRADE_BEGIN:
if (quiet)
break;
else {
struct sbuf *msg;
pkg = ev->e_upgrade_begin.pkg;
nbdone++;
msg = sbuf_new_auto();
if (msg == NULL) {
warn("sbuf_new_auto() failed");
break;
}
print_status_begin(msg);
switch (pkg_version_change(pkg)) {
case PKG_DOWNGRADE:
pkg_sbuf_printf(msg,
"Downgrading %n from %V to %v...",
pkg, pkg, pkg);
break;
case PKG_REINSTALL:
pkg_sbuf_printf(msg, "Reinstalling %n-%V...",
pkg, pkg);
break;
case PKG_UPGRADE:
pkg_sbuf_printf(msg,
"Upgrading %n from %V to %v...",
pkg, pkg, pkg);
break;
}
print_status_end(msg);
}
break;
case PKG_EVENT_UPGRADE_FINISHED:
if (quiet)
break;
printf(" done\n");
if (pkg_has_message(ev->e_upgrade_finished.pkg)) {
if (messages == NULL)
messages = sbuf_new_auto();
pkg_sbuf_printf(messages, "%M\n",
ev->e_upgrade_finished.pkg);
}
break;
case PKG_EVENT_LOCKED:
pkg = ev->e_locked.pkg;
pkg_fprintf(stderr,
"\n%n-%v is locked and may not be modified\n",
pkg, pkg);
break;
case PKG_EVENT_REQUIRED:
pkg = ev->e_required.pkg;
pkg_fprintf(stderr,
"\n%n-%v is required by: %r%{%rn-%rv%| %}",
pkg, pkg, pkg);
if (ev->e_required.force == 1)
fprintf(stderr, ", deleting anyway\n");
else
fprintf(stderr, "\n");
break;
case PKG_EVENT_ALREADY_INSTALLED:
if (quiet)
break;
pkg = ev->e_already_installed.pkg;
pkg_printf("%n-%v already installed\n", pkg, pkg);
break;
case PKG_EVENT_NOT_FOUND:
printf("Package '%s' was not found in "
"the repositories\n", ev->e_not_found.pkg_name);
break;
case PKG_EVENT_MISSING_DEP:
fprintf(stderr, "missing dependency %s-%s\n",
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());
break;
case PKG_EVENT_NOLOCALDB:
fprintf(stderr, "Local package database nonexistent!\n");
break;
case PKG_EVENT_NEWPKGVERSION:
newpkgversion = true;
printf("New version of pkg detected; it needs to be "
"installed first.\n");
break;
case PKG_EVENT_FILE_MISMATCH:
pkg = ev->e_file_mismatch.pkg;
pkg_fprintf(stderr, "%n-%v: checksum mismatch for %S\n", pkg,
pkg, pkg_file_path(ev->e_file_mismatch.file));
break;
case PKG_EVENT_PLUGIN_ERRNO:
warnx("%s: %s(%s): %s",
pkg_plugin_get(ev->e_plugin_errno.plugin, PKG_PLUGIN_NAME),
ev->e_plugin_errno.func, ev->e_plugin_errno.arg,
strerror(ev->e_plugin_errno.no));
break;
case PKG_EVENT_PLUGIN_ERROR:
warnx("%s: %s",
pkg_plugin_get(ev->e_plugin_error.plugin, PKG_PLUGIN_NAME),
ev->e_plugin_error.msg);
break;
case PKG_EVENT_PLUGIN_INFO:
if (quiet)
break;
printf("%s: %s\n",
pkg_plugin_get(ev->e_plugin_info.plugin, PKG_PLUGIN_NAME),
ev->e_plugin_info.msg);
break;
case PKG_EVENT_INCREMENTAL_UPDATE:
if (!quiet)
printf("Incremental update completed, %d packages "
"processed:\n"
"%d packages updated, %d removed and %d added.\n",
ev->e_incremental_update.processed,
ev->e_incremental_update.updated,
ev->e_incremental_update.removed,
ev->e_incremental_update.added);
break;
case PKG_EVENT_DEBUG:
fprintf(stderr, "DBG(%d)> %s\n", ev->e_debug.level, ev->e_debug.msg);
break;
default:
break;
}
return 0;
}
static void
format_str(struct pkg *pkg, struct sbuf *dest, const char *qstr, void *data)
{
char size[7];
const char *tmp;
bool tmp2;
int64_t flatsize;
int64_t timestamp;
lic_t licenselogic;
sbuf_clear(dest);
while (qstr[0] != '\0') {
if (qstr[0] == '%') {
qstr++;
switch (qstr[0]) {
case 'n':
pkg_get(pkg, PKG_NAME, &tmp);
if (tmp != NULL)
sbuf_cat(dest, tmp);
break;
case 'v':
pkg_get(pkg, PKG_VERSION, &tmp);
if (tmp != NULL)
sbuf_cat(dest, tmp);
break;
case 'o':
pkg_get(pkg, PKG_ORIGIN, &tmp);
if (tmp != NULL)
sbuf_cat(dest, tmp);
break;
case 'R':
pkg_get(pkg, PKG_REPONAME, &tmp);
if (tmp != NULL)
sbuf_cat(dest, tmp);
break;
case 'p':
pkg_get(pkg, PKG_PREFIX, &tmp);
if (tmp != NULL)
sbuf_cat(dest, tmp);
break;
case 'm':
pkg_get(pkg, PKG_MAINTAINER, &tmp);
if (tmp != NULL)
sbuf_cat(dest, tmp);
break;
case 'c':
pkg_get(pkg, PKG_COMMENT, &tmp);
if (tmp != NULL)
sbuf_cat(dest, tmp);
break;
case 'w':
pkg_get(pkg, PKG_WWW, &tmp);
if (tmp != NULL)
sbuf_cat(dest, tmp);
break;
case 'i':
pkg_get(pkg, PKG_INFOS, &tmp);
if (tmp != NULL)
sbuf_cat(dest, tmp);
break;
case 'a':
pkg_get(pkg, PKG_AUTOMATIC, &tmp2);
sbuf_printf(dest, "%d", tmp2);
break;
case 'k':
pkg_get(pkg, PKG_LOCKED, &tmp2);
sbuf_printf(dest, "%d", tmp2);
break;
case 't':
pkg_get(pkg, PKG_TIME, ×tamp);
sbuf_printf(dest, "%" PRId64, timestamp);
break;
case 's':
qstr++;
pkg_get(pkg, PKG_FLATSIZE, &flatsize);
if (qstr[0] == 'h') {
humanize_number(size, sizeof(size),
flatsize, "B", HN_AUTOSCALE, 0);
sbuf_cat(dest, size);
} else if (qstr[0] == 'b') {
sbuf_printf(dest, "%" PRId64, flatsize);
}
break;
case 'e':
pkg_get(pkg, PKG_DESC, &tmp);
if (tmp != NULL)
sbuf_cat(dest, tmp);
break;
case '?':
qstr++;
switch (qstr[0]) {
case 'd':
sbuf_printf(dest, "%d", pkg_list_count(pkg, PKG_DEPS) > 0);
break;
case 'r':
sbuf_printf(dest, "%d", pkg_list_count(pkg, PKG_RDEPS) > 0);
break;
case 'C':
sbuf_printf(dest, "%d", pkg_list_count(pkg, PKG_CATEGORIES) > 0);
break;
case 'F':
sbuf_printf(dest, "%d", pkg_list_count(pkg, PKG_FILES) > 0);
break;
case 'O':
sbuf_printf(dest, "%d", pkg_list_count(pkg, PKG_OPTIONS) > 0);
break;
case 'D':
sbuf_printf(dest, "%d", pkg_list_count(pkg, PKG_DIRS) > 0);
break;
case 'L':
sbuf_printf(dest, "%d", pkg_list_count(pkg, PKG_LICENSES) > 0);
break;
case 'U':
sbuf_printf(dest, "%d", pkg_list_count(pkg, PKG_USERS) > 0);
break;
case 'G':
sbuf_printf(dest, "%d", pkg_list_count(pkg, PKG_GROUPS) > 0);
break;
case 'B':
sbuf_printf(dest, "%d", pkg_list_count(pkg, PKG_SHLIBS_REQUIRED) > 0);
break;
case 'b':
sbuf_printf(dest, "%d", pkg_list_count(pkg, PKG_SHLIBS_PROVIDED) > 0);
break;
case 'A':
sbuf_printf(dest, "%d", pkg_list_count(pkg, PKG_ANNOTATIONS) > 0);
break;
}
break;
case '#':
qstr++;
switch (qstr[0]) {
case 'd':
sbuf_printf(dest, "%d", pkg_list_count(pkg, PKG_DEPS));
break;
case 'r':
sbuf_printf(dest, "%d", pkg_list_count(pkg, PKG_RDEPS));
break;
case 'C':
sbuf_printf(dest, "%d", pkg_list_count(pkg, PKG_CATEGORIES));
break;
case 'F':
sbuf_printf(dest, "%d", pkg_list_count(pkg, PKG_FILES));
break;
case 'O':
sbuf_printf(dest, "%d", pkg_list_count(pkg, PKG_OPTIONS));
break;
case 'D':
sbuf_printf(dest, "%d", pkg_list_count(pkg, PKG_DIRS));
break;
case 'L':
sbuf_printf(dest, "%d", pkg_list_count(pkg, PKG_LICENSES));
break;
case 'U':
sbuf_printf(dest, "%d", pkg_list_count(pkg, PKG_USERS));
break;
case 'G':
sbuf_printf(dest, "%d", pkg_list_count(pkg, PKG_GROUPS));
break;
case 'B':
sbuf_printf(dest, "%d", pkg_list_count(pkg, PKG_SHLIBS_REQUIRED));
break;
case 'b':
sbuf_printf(dest, "%d", pkg_list_count(pkg, PKG_SHLIBS_PROVIDED));
break;
case 'A':
sbuf_printf(dest, "%d", pkg_list_count(pkg, PKG_ANNOTATIONS));
break;
}
break;
case 'l':
pkg_get(pkg, PKG_LICENSE_LOGIC, &licenselogic);
switch (licenselogic) {
case LICENSE_SINGLE:
sbuf_cat(dest, "single");
break;
case LICENSE_OR:
sbuf_cat(dest, "or");
break;
case LICENSE_AND:
sbuf_cat(dest, "and");
break;
}
break;
case 'd':
qstr++;
if (qstr[0] == 'n')
sbuf_cat(dest, pkg_dep_name((struct pkg_dep *)data));
else if (qstr[0] == 'o')
sbuf_cat(dest, pkg_dep_origin((struct pkg_dep *)data));
else if (qstr[0] == 'v')
sbuf_cat(dest, pkg_dep_version((struct pkg_dep *)data));
break;
case 'r':
qstr++;
if (qstr[0] == 'n')
sbuf_cat(dest, pkg_dep_name((struct pkg_dep *)data));
else if (qstr[0] == 'o')
sbuf_cat(dest, pkg_dep_origin((struct pkg_dep *)data));
else if (qstr[0] == 'v')
sbuf_cat(dest, pkg_dep_version((struct pkg_dep *)data));
break;
case 'C':
sbuf_cat(dest, pkg_category_name((struct pkg_category *)data));
break;
case 'F':
qstr++;
if (qstr[0] == 'p')
sbuf_cat(dest, pkg_file_path((struct pkg_file *)data));
else if (qstr[0] == 's')
sbuf_cat(dest, pkg_file_cksum((struct pkg_file *)data));
break;
case 'O':
qstr++;
if (qstr[0] == 'k')
sbuf_cat(dest, pkg_option_opt((struct pkg_option *)data));
else if (qstr[0] == 'v')
sbuf_cat(dest, pkg_option_value((struct pkg_option *)data));
break;
case 'D':
sbuf_cat(dest, pkg_dir_path((struct pkg_dir *)data));
break;
case 'L':
sbuf_cat(dest, pkg_license_name((struct pkg_license *)data));
break;
case 'U':
sbuf_cat(dest, pkg_user_name((struct pkg_user *)data));
break;
case 'G':
sbuf_cat(dest, pkg_group_name((struct pkg_group *)data));
break;
case 'B':
case 'b':
sbuf_cat(dest, pkg_shlib_name((struct pkg_shlib *)data));
break;
case 'A':
qstr++;
if (qstr[0] == 't')
sbuf_cat(dest, pkg_annotation_tag((struct pkg_note *)data));
else if (qstr[0] == 'v')
sbuf_cat(dest, pkg_annotation_value((struct pkg_note *)data));
break;
case 'M':
pkg_get(pkg, PKG_MESSAGE, &tmp);
if (tmp != NULL)
sbuf_cat(dest, tmp);
break;
case '%':
sbuf_putc(dest, '%');
break;
}
} else if (qstr[0] == '\\') {
qstr++;
switch (qstr[0]) {
case 'n':
sbuf_putc(dest, '\n');
break;
case 'a':
sbuf_putc(dest, '\a');
break;
case 'b':
sbuf_putc(dest, '\b');
break;
case 'f':
sbuf_putc(dest, '\f');
break;
case 'r':
sbuf_putc(dest, '\r');
break;
case '\\':
sbuf_putc(dest, '\\');
break;
case 't':
sbuf_putc(dest, '\t');
break;
}
} else {
sbuf_putc(dest, qstr[0]);
}
qstr++;
}
sbuf_finish(dest);
}
/*
* Event handler for events emitted by pkg during an installation. TODO: Many
* of these events are unhandled or deficiently handled.
*/
int
event_cb(void *backend_v, struct pkg_event *event)
{
PkBackend *backend;
assert(backend_v != NULL);
assert(event != NULL);
backend = (PkBackend *)backend_v;
switch (event->type) {
case PKG_EVENT_INSTALL_BEGIN:
STATUS(backend, PK_STATUS_ENUM_INSTALL);
emit_package(event->e_install_begin.pkg,
backend,
PK_INFO_ENUM_INSTALLING);
break;
case PKG_EVENT_INSTALL_FINISHED:
emit_package(event->e_install_finished.pkg,
backend,
PK_INFO_ENUM_FINISHED);
break;
case PKG_EVENT_DEINSTALL_BEGIN:
STATUS(backend, PK_STATUS_ENUM_REMOVE);
emit_package(event->e_deinstall_begin.pkg,
backend,
PK_INFO_ENUM_REMOVING);
break;
case PKG_EVENT_DEINSTALL_FINISHED:
emit_package(event->e_deinstall_finished.pkg,
backend,
PK_INFO_ENUM_FINISHED);
break;
case PKG_EVENT_UPGRADE_BEGIN:
STATUS(backend, PK_STATUS_ENUM_UPDATE);
emit_package(event->e_upgrade_begin.pkg,
backend,
PK_INFO_ENUM_UPDATING);
break;
case PKG_EVENT_UPGRADE_FINISHED:
emit_package(event->e_upgrade_finished.pkg,
backend,
PK_INFO_ENUM_FINISHED);
break;
case PKG_EVENT_FETCHING:
STATUS(backend, PK_STATUS_ENUM_DOWNLOAD);
break;
case PKG_EVENT_INTEGRITYCHECK_BEGIN:
case PKG_EVENT_INTEGRITYCHECK_FINISHED:
/* Unimplemented */
break;
case PKG_EVENT_INTEGRITYCHECK_CONFLICT:
ERR(backend,
PK_ERROR_ENUM_PACKAGE_CORRUPT,
event->e_integrity_conflict.pkg_name);
break;
case PKG_EVENT_NEWPKGVERSION:
/* TODO: find a better enum for this? */
ERR(backend,
PK_ERROR_ENUM_PACKAGE_INSTALL_BLOCKED,
"A new version of pkg is available; install that first.");
break;
case PKG_EVENT_NOTICE:
case PKG_EVENT_INCREMENTAL_UPDATE:
/* Unimplemented */
break;
case PKG_EVENT_ERROR:
/*
* This is sometimes used for nonfatal errors, so we can't
* throw an error code here. What we'll do (mainly for debug
* purposes) is post the error into the backend so we can
* retrieve it if it was fatal.
*
* pk_backend_set_string seems to strdup, so we don't have to.
*/
(void)pk_backend_set_string(backend, "job_error",
event->e_pkg_error.msg);
break;
case PKG_EVENT_ERRNO:
case PKG_EVENT_ARCHIVE_COMP_UNSUP:
/* Unimplemented */
break;
case PKG_EVENT_ALREADY_INSTALLED:
ERR(backend,
PK_ERROR_ENUM_PACKAGE_ALREADY_INSTALLED,
"Already installed.");
break;
case PKG_EVENT_FAILED_CKSUM:
case PKG_EVENT_CREATE_DB_ERROR:
/* Unimplemented */
break;
case PKG_EVENT_LOCKED:
/* TODO: find a better enum for this? */
ERR(backend,
PK_ERROR_ENUM_PACKAGE_INSTALL_BLOCKED,
"Package is locked.");
break;
case PKG_EVENT_REQUIRED:
/* TODO: find a better enum for this? */
ERR(backend,
PK_ERROR_ENUM_CANNOT_REMOVE_SYSTEM_PACKAGE,
"Package is required.");
break;
case PKG_EVENT_MISSING_DEP:
ERR(backend,
PK_ERROR_ENUM_DEP_RESOLUTION_FAILED,
"Package is missing a dependency.");
break;
case PKG_EVENT_NOREMOTEDB:
case PKG_EVENT_NOLOCALDB:
/* Unimplemented */
break;
case PKG_EVENT_FILE_MISMATCH:
ERR(backend,
PK_ERROR_ENUM_PACKAGE_CORRUPT,
pkg_file_path(event->e_file_mismatch.file));
break;
case PKG_EVENT_DEVELOPER_MODE:
case PKG_EVENT_PLUGIN_ERRNO:
case PKG_EVENT_PLUGIN_ERROR:
case PKG_EVENT_PLUGIN_INFO:
/* Unimplemented */
break;
case PKG_EVENT_NOT_FOUND:
ERR(backend,
PK_ERROR_ENUM_PACKAGE_DOWNLOAD_FAILED,
event->e_not_found.pkg_name);
}
return EPKG_OK;
}
static void
pipeevent(struct pkg_event *ev)
{
struct pkg *pkg = NULL;
struct pkg_dep *dep = NULL;
struct sbuf *msg, *buf;
const char *message;
const char *name, *version, *newversion;
if (eventpipe < 0)
return;
msg = sbuf_new_auto();
buf = sbuf_new_auto();
switch(ev->type) {
case PKG_EVENT_ERRNO:
sbuf_printf(msg, "{ \"type\": \"ERROR\", "
"\"data\": {"
"\"msg\": \"%s(%s): %s\","
"\"errno\": %d}}",
sbuf_json_escape(buf, ev->e_errno.func),
sbuf_json_escape(buf, ev->e_errno.arg),
sbuf_json_escape(buf, strerror(ev->e_errno.no)),
ev->e_errno.no);
break;
case PKG_EVENT_ERROR:
sbuf_printf(msg, "{ \"type\": \"ERROR\", "
"\"data\": {\"msg\": \"%s\"}}",
sbuf_json_escape(buf, ev->e_pkg_error.msg));
break;
case PKG_EVENT_DEVELOPER_MODE:
sbuf_printf(msg, "{ \"type\": \"ERROR\", "
"\"data\": {\"msg\": \"DEVELOPER_MODE: %s\"}}",
sbuf_json_escape(buf, ev->e_pkg_error.msg));
break;
case PKG_EVENT_FETCHING:
sbuf_printf(msg, "{ \"type\": \"INFO_FETCH\", "
"\"data\": { "
"\"url\": \"%s\", "
"\"fetched\": %" PRId64 ", "
"\"total\": %" PRId64
"}}",
sbuf_json_escape(buf, ev->e_fetching.url),
ev->e_fetching.done,
ev->e_fetching.total
);
break;
case PKG_EVENT_INSTALL_BEGIN:
pkg_get(ev->e_install_begin.pkg, PKG_NAME, &name,
PKG_VERSION, &version);
sbuf_printf(msg, "{ \"type\": \"INFO_INSTALL_BEGIN\", "
"\"data\": { "
"\"pkgname\": \"%s\", "
"\"pkgversion\": \"%s\""
"}}",
name,
version
);
break;
case PKG_EVENT_INSTALL_FINISHED:
pkg_get(ev->e_install_finished.pkg,
PKG_MESSAGE, &message,
PKG_NAME, &name,
PKG_VERSION, &version);
sbuf_printf(msg, "{ \"type\": \"INFO_INSTALL_FINISHED\", "
"\"data\": { "
"\"pkgname\": \"%s\", "
"\"pkgversion\": \"%s\", "
"\"message\": \"%s\""
"}}",
name,
version,
sbuf_json_escape(buf, message));
break;
case PKG_EVENT_INTEGRITYCHECK_BEGIN:
sbuf_printf(msg, "{ \"type\": \"INFO_INTEGRITYCHECK_BEGIN\", "
"\"data\": {}}");
break;
case PKG_EVENT_INTEGRITYCHECK_FINISHED:
sbuf_printf(msg, "{ \"type\": \"INFO_INTEGRITYCHECK_FINISHED\", "
"\"data\": {}}");
break;
case PKG_EVENT_DEINSTALL_BEGIN:
pkg_get(ev->e_deinstall_begin.pkg,
PKG_NAME, &name,
PKG_VERSION, &version);
sbuf_printf(msg, "{ \"type\": \"INFO_DEINSTALL_BEGIN\", "
"\"data\": { "
"\"pkgname\": \"%s\", "
"\"pkgversion\": \"%s\""
"}}",
name,
version);
break;
case PKG_EVENT_DEINSTALL_FINISHED:
pkg_get(ev->e_deinstall_finished.pkg,
PKG_NAME, &name,
PKG_VERSION, &version);
sbuf_printf(msg, "{ \"type\": \"INFO_DEINSTALL_FINISHED\", "
"\"data\": { "
"\"pkgname\": \"%s\", "
"\"pkgversion\": \"%s\""
"}}",
name,
version);
break;
case PKG_EVENT_UPGRADE_BEGIN:
pkg_get(ev->e_upgrade_begin.pkg,
PKG_NAME, &name,
PKG_VERSION, &version,
PKG_NEWVERSION, &newversion);
sbuf_printf(msg, "{ \"type\": \"INFO_UPGRADE_BEGIN\", "
"\"data\": { "
"\"pkgname\": \"%s\", "
"\"pkgversion\": \"%s\" ,"
"\"pkgnewversion\": \"%s\""
"}}",
name,
version,
newversion);
break;
case PKG_EVENT_UPGRADE_FINISHED:
pkg_get(ev->e_upgrade_finished.pkg,
PKG_NAME, &name,
PKG_VERSION, &version,
PKG_NEWVERSION, &newversion);
sbuf_printf(msg, "{ \"type\": \"INFO_UPGRADE_FINISHED\", "
"\"data\": { "
"\"pkgname\": \"%s\", "
"\"pkgversion\": \"%s\" ,"
"\"pkgnewversion\": \"%s\""
"}}",
name,
version,
newversion);
break;
case PKG_EVENT_LOCKED:
pkg_get(ev->e_locked.pkg,
PKG_NAME, &name,
PKG_VERSION, &version);
sbuf_printf(msg, "{ \"type\": \"ERROR_LOCKED\", "
"\"data\": { "
"\"pkgname\": \"%s\", "
"\"pkgversion\": \"%s\""
"}}",
name,
version);
break;
case PKG_EVENT_REQUIRED:
pkg_get(ev->e_required.pkg,
PKG_NAME, &name,
PKG_VERSION, &version);
sbuf_printf(msg, "{ \"type\": \"ERROR_REQUIRED\", "
"\"data\": { "
"\"pkgname\": \"%s\", "
"\"pkgversion\": \"%s\", "
"\"force\": %s, "
"\"required_by\": [",
name,
version,
ev->e_required.force == 1 ? "true": "false");
while (pkg_rdeps(pkg, &dep) == EPKG_OK)
sbuf_printf(msg, "{ \"pkgname\": \"%s\", "
"\"pkgversion\": \"%s\" }, ",
pkg_dep_name(dep),
pkg_dep_version(dep));
sbuf_setpos(msg, sbuf_len(msg) - 2);
sbuf_cat(msg, "]}}");
break;
case PKG_EVENT_ALREADY_INSTALLED:
pkg_get(ev->e_already_installed.pkg,
PKG_NAME, &name,
PKG_VERSION, &version);
sbuf_printf(msg, "{ \"type\": \"ERROR_ALREADY_INSTALLED\", "
"\"data\": { "
"\"pkgname\": \"%s\", "
"\"pkgversion\": \"%s\""
"}}",
name,
version);
break;
case PKG_EVENT_MISSING_DEP:
sbuf_printf(msg, "{ \"type\": \"ERROR_MISSING_DEP\", "
"\"data\": { "
"\"depname\": \"%s\", "
"\"depversion\": \"%s\""
"}}" ,
pkg_dep_name(ev->e_missing_dep.dep),
pkg_dep_version(ev->e_missing_dep.dep));
break;
case PKG_EVENT_NOREMOTEDB:
sbuf_printf(msg, "{ \"type\": \"ERROR_NOREMOTEDB\", "
"\"data\": { "
"\"url\": \"%s\" "
"}}" ,
ev->e_remotedb.repo);
break;
case PKG_EVENT_NOLOCALDB:
sbuf_printf(msg, "{ \"type\": \"ERROR_NOLOCALDB\", "
"\"data\": {} ");
break;
case PKG_EVENT_NEWPKGVERSION:
sbuf_printf(msg, "{ \"type\": \"INFO_NEWPKGVERSION\", "
"\"data\": {} ");
break;
case PKG_EVENT_FILE_MISMATCH:
pkg_get(ev->e_file_mismatch.pkg,
PKG_NAME, &name,
PKG_VERSION, &version);
sbuf_printf(msg, "{ \"type\": \"ERROR_FILE_MISMATCH\", "
"\"data\": { "
"\"pkgname\": \"%s\", "
"\"pkgversion\": \"%s\", "
"\"path\": \"%s\""
"}}",
name,
version,
sbuf_json_escape(buf, pkg_file_path(ev->e_file_mismatch.file)));
break;
case PKG_EVENT_PLUGIN_ERRNO:
sbuf_printf(msg, "{ \"type\": \"ERROR_PLUGIN\", "
"\"data\": {"
"\"plugin\": \"%s\", "
"\"msg\": \"%s(%s): %s\","
"\"errno\": %d"
"}}",
pkg_plugin_get(ev->e_plugin_errno.plugin, PKG_PLUGIN_NAME),
sbuf_json_escape(buf, ev->e_plugin_errno.func),
sbuf_json_escape(buf, ev->e_plugin_errno.arg),
sbuf_json_escape(buf, strerror(ev->e_plugin_errno.no)),
ev->e_plugin_errno.no);
break;
case PKG_EVENT_PLUGIN_ERROR:
sbuf_printf(msg, "{ \"type\": \"ERROR_PLUGIN\", "
"\"data\": {"
"\"plugin\": \"%s\", "
"\"msg\": \"%s\""
"}}",
pkg_plugin_get(ev->e_plugin_error.plugin, PKG_PLUGIN_NAME),
sbuf_json_escape(buf, ev->e_plugin_error.msg));
break;
case PKG_EVENT_PLUGIN_INFO:
sbuf_printf(msg, "{ \"type\": \"INFO_PLUGIN\", "
"\"data\": {"
"\"plugin\": \"%s\", "
"\"msg\": \"%s\""
"}}",
pkg_plugin_get(ev->e_plugin_info.plugin, PKG_PLUGIN_NAME),
sbuf_json_escape(buf, ev->e_plugin_info.msg));
break;
default:
break;
}
sbuf_finish(msg);
dprintf(eventpipe, "%s\n", sbuf_data(msg));
sbuf_delete(msg);
sbuf_delete(buf);
}
void
test_manifest(void)
{
struct pkg *p = NULL;
struct pkg_dep *dep = NULL;
struct pkg_conflict *conflict = NULL;
struct pkg_option *option = NULL;
struct pkg_category *category = NULL;
struct pkg_file *file = NULL;
struct pkg_manifest_key *keys = NULL;
const char *pkg_str;
int64_t pkg_int;
int i;
pkg_manifest_keys_new(&keys);
ATF_REQUIRE(keys != NULL);
ATF_REQUIRE_EQ(EPKG_OK, pkg_new(&p, PKG_FILE));
ATF_REQUIRE(p != NULL);
ATF_REQUIRE_EQ(EPKG_OK, pkg_parse_manifest(p, manifest, strlen(manifest), keys));
pkg_manifest_keys_free(keys);
ATF_REQUIRE(pkg_get(p, PKG_NAME, &pkg_str) == EPKG_OK);
ATF_REQUIRE(strcmp(pkg_str, "foobar") == 0);
ATF_REQUIRE(pkg_get(p, PKG_VERSION, &pkg_str) == EPKG_OK);
ATF_REQUIRE(strcmp(pkg_str, "0.3") == 0);
ATF_REQUIRE(pkg_get(p, PKG_ORIGIN, &pkg_str) == EPKG_OK);
ATF_REQUIRE(strcmp(pkg_str, "foo/bar") == 0);
ATF_REQUIRE(pkg_get(p, PKG_COMMENT, &pkg_str) == EPKG_OK);
ATF_REQUIRE(strcmp(pkg_str, "A dummy manifest") == 0);
ATF_REQUIRE(pkg_get(p, PKG_ARCH, &pkg_str) == EPKG_OK);
ATF_REQUIRE(strcmp(pkg_str, "amd64") == 0);
ATF_REQUIRE(pkg_get(p, PKG_WWW, &pkg_str) == EPKG_OK);
ATF_REQUIRE(strcmp(pkg_str, "http://www.foobar.com") == 0);
ATF_REQUIRE(pkg_get(p, PKG_MAINTAINER, &pkg_str) == EPKG_OK);
ATF_REQUIRE(strcmp(pkg_str, "*****@*****.**") == 0);
ATF_REQUIRE(pkg_get(p, PKG_PREFIX, &pkg_str) == EPKG_OK);
ATF_REQUIRE(strcmp(pkg_str, "/opt/prefix") == 0);
ATF_REQUIRE(pkg_get(p, PKG_DESC, &pkg_str) == EPKG_OK);
ATF_REQUIRE(strcmp(pkg_str, "port description") == 0);
ATF_REQUIRE(pkg_get(p, PKG_MESSAGE, &pkg_str) == EPKG_OK);
ATF_REQUIRE(strcmp(pkg_str, "pkg message") == 0);
ATF_REQUIRE(pkg_get(p, PKG_FLATSIZE, &pkg_int) == EPKG_OK);
ATF_REQUIRE(pkg_int == 10000);
i = 0;
while (pkg_deps(p, &dep) == EPKG_OK) {
if (i == 0) {
ATF_REQUIRE(strcmp(pkg_dep_name(dep), "depfoo") == 0);
ATF_REQUIRE(strcmp(pkg_dep_origin(dep), "dep/foo") == 0);
ATF_REQUIRE(strcmp(pkg_dep_version(dep), "1.2") == 0);
} else if (i == 1) {
ATF_REQUIRE(strcmp(pkg_dep_name(dep), "depbar") == 0);
ATF_REQUIRE(strcmp(pkg_dep_origin(dep), "dep/bar") == 0);
ATF_REQUIRE(strcmp(pkg_dep_version(dep), "3.4") == 0);
}
i++;
}
ATF_REQUIRE(i == 2);
i = 0;
#if 0
while (pkg_conflicts(p, &conflict) == EPKG_OK) {
if (i == 0) {
ATF_REQUIRE(strcmp(pkg_conflict_glob(conflict), "foo-*") == 0);
} else if (i == 1) {
ATF_REQUIRE(strcmp(pkg_conflict_glob(conflict), "bar-*") == 0);
}
i++;
}
ATF_REQUIRE(i == 2);
#endif
i = 0;
while (pkg_options(p, &option) == EPKG_OK) {
if (i == 0) {
ATF_REQUIRE(strcmp(pkg_option_opt(option), "foo") == 0);
ATF_REQUIRE(strcmp(pkg_option_value(option), "true") == 0);
} else if (i == 1) {
ATF_REQUIRE(strcmp(pkg_option_opt(option), "bar") == 0);
ATF_REQUIRE(strcmp(pkg_option_value(option), "false") == 0);
}
i++;
}
ATF_REQUIRE(i == 2);
i = 0;
while (pkg_categories(p, &category) == EPKG_OK) {
if (i == 0) {
ATF_REQUIRE(strcmp(pkg_category_name(category), "foo") == 0);
} else if (i == 1) {
ATF_REQUIRE(strcmp(pkg_category_name(category), "bar") == 0);
}
i++;
}
ATF_REQUIRE(i == 2);
ATF_REQUIRE(pkg_files(p, &file) == EPKG_OK);
ATF_REQUIRE(strcmp(pkg_file_path(file), "/usr/local/bin/foo") ==
0);
#if 0
ATF_REQUIRE(strcmp(pkg_file_sha256(file),
"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b")
== 0);
#endif
pkg_free(p);
/* p = NULL;
ATF_REQUIRE(pkg_new(&p, PKG_FILE) == EPKG_OK);
ATF_REQUIRE(pkg_parse_manifest(p, wrong_manifest1) == EPKG_FATAL);
pkg_free(p);
p = NULL;
ATF_REQUIRE(pkg_new(&p, PKG_FILE) == EPKG_OK);
ATF_REQUIRE(pkg_parse_manifest(p, wrong_manifest2) == EPKG_FATAL);
pkg_free(p);
p = NULL;
ATF_REQUIRE(pkg_new(&p, PKG_FILE) == EPKG_OK);
ATF_REQUIRE(pkg_parse_manifest(p, wrong_manifest3) == EPKG_FATAL);
pkg_free(p);
p = NULL;
ATF_REQUIRE(pkg_new(&p, PKG_FILE) == EPKG_OK);
ATF_REQUIRE(pkg_parse_manifest(p, wrong_manifest4) == EPKG_FATAL);
pkg_free(p);
*/
}
void
print_info(struct pkg * const pkg, unsigned int options)
{
struct pkg_category *cat = NULL;
struct pkg_dep *dep = NULL;
struct pkg_dir *dir = NULL;
struct pkg_file *file = NULL;
struct pkg_group *group = NULL;
struct pkg_license *lic = NULL;
struct pkg_option *option = NULL;
struct pkg_shlib *shlib = NULL;
struct pkg_user *user = NULL;
bool multirepos_enabled = false;
bool print_tag = false;
bool show_locks = false;
char size[7];
const char *name, *version, *prefix, *origin, *reponame, *repourl;
const char *maintainer, *www, *comment, *desc, *message, *arch;
const char *repopath;
const char *tab;
char *m;
unsigned opt;
int64_t flatsize, newflatsize, newpkgsize;
lic_t licenselogic;
bool locked;
int cout = 0; /* Number of characters output */
int info_num; /* Number of different data items to print */
pkg_config_bool(PKG_CONFIG_MULTIREPOS, &multirepos_enabled);
pkg_get(pkg,
PKG_NAME, &name,
PKG_VERSION, &version,
PKG_PREFIX, &prefix,
PKG_ORIGIN, &origin,
PKG_REPONAME, &reponame,
PKG_REPOURL, &repourl,
PKG_MAINTAINER, &maintainer,
PKG_WWW, &www,
PKG_COMMENT, &comment,
PKG_DESC, &desc,
PKG_FLATSIZE, &flatsize,
PKG_NEW_FLATSIZE, &newflatsize,
PKG_NEW_PKGSIZE, &newpkgsize,
PKG_LICENSE_LOGIC, &licenselogic,
PKG_MESSAGE, &message,
PKG_ARCH, &arch,
PKG_REPOPATH, &repopath,
PKG_LOCKED, &locked);
if (!multirepos_enabled)
pkg_config_string(PKG_CONFIG_REPO, &repourl);
if (options & INFO_RAW) { /* Not for remote packages */
if (pkg_type(pkg) != PKG_REMOTE) {
pkg_emit_manifest(pkg, &m);
printf("%s\n", m);
free(m);
}
return;
}
/* Show locking status when requested to display it and the
package is locally installed */
if (pkg_type(pkg) == PKG_INSTALLED && (options & INFO_LOCKED) != 0)
show_locks = true;
if (!quiet) {
/* Print a tag-line identifying the package -- either
NAMEVER, ORIGIN or NAME (in that order of
preference). This may be the only output from this
function */
if (options & INFO_TAG_NAMEVER)
cout = printf("%s-%s", name, version);
else if (options & INFO_TAG_ORIGIN)
cout = printf("%s", origin);
else if (options & INFO_TAG_NAME)
cout = printf("%s", name);
}
/* Don't display a tab if quiet, retains compatibility. */
tab = quiet ? "" : "\t";
/* If we printed a tag, and there are no other items to print,
then just return now. If there's only one single-line item
to print, show it at column 32 on the same line. If there's
one multi-line item to print, start a new line. If there is
more than one item to print per pkg, use 'key : value'
style to show on a new line. */
info_num = 0;
for (opt = 0x1U; opt <= INFO_LASTFIELD; opt <<= 1)
if ((opt & options) != 0)
info_num++;
if (info_num == 0 && cout > 0) {
printf("\n");
return;
}
if (info_num == 1) {
/* Only one item to print */
print_tag = false;
if (!quiet) {
if (options & INFO_MULTILINE)
printf(":\n");
else {
if (cout < 31)
cout = 31 - cout;
else
cout = 1;
printf("%*s", cout, " ");
}
}
} else {
/* Several items to print */
print_tag = true;
if (!quiet)
printf("\n");
}
for (opt = 0x1; opt <= INFO_LASTFIELD; opt <<= 1) {
if ((opt & options) == 0)
continue;
switch (opt) {
case INFO_NAME:
if (print_tag)
printf("%-15s: ", "Name");
printf("%s\n", name);
break;
case INFO_VERSION:
if (print_tag)
printf("%-15s: ", "Version");
printf("%s\n", version);
break;
case INFO_ORIGIN:
if (print_tag)
printf("%-15s: ", "Origin");
printf("%s\n", origin);
break;
case INFO_PREFIX:
if (print_tag)
printf("%-15s: ", "Prefix");
printf("%s\n", prefix);
break;
case INFO_REPOSITORY:
if (pkg_type(pkg) == PKG_REMOTE &&
repourl != NULL && repourl[0] != '\0') {
if (print_tag)
printf("%-15s: ", "Repository");
printf("%s [%s]\n", reponame, repourl);
} else if (!print_tag)
printf("\n");
break;
case INFO_CATEGORIES:
if (pkg_list_count(pkg, PKG_CATEGORIES) > 0) {
if (print_tag)
printf("%-15s: ", "Categories");
if (pkg_categories(pkg, &cat) == EPKG_OK)
printf("%s", pkg_category_name(cat));
while (pkg_categories(pkg, &cat) == EPKG_OK)
printf(" %s", pkg_category_name(cat));
printf("\n");
} else if (!print_tag)
printf("\n");
break;
case INFO_LICENSES:
if (pkg_list_count(pkg, PKG_LICENSES) > 0) {
if (print_tag)
printf("%-15s: ", "Licenses");
if (pkg_licenses(pkg, &lic) == EPKG_OK)
printf("%s", pkg_license_name(lic));
while (pkg_licenses(pkg, &lic) == EPKG_OK) {
if (licenselogic != 1)
printf(" %c", licenselogic);
printf(" %s", pkg_license_name(lic));
}
printf("\n");
} else if (!print_tag)
printf("\n");
break;
case INFO_MAINTAINER:
if (print_tag)
printf("%-15s: ", "Maintainer");
printf("%s\n", maintainer);
break;
case INFO_WWW:
if (print_tag)
printf("%-15s: ", "WWW");
printf("%s\n", www);
break;
case INFO_COMMENT:
if (print_tag)
printf("%-15s: ", "Comment");
printf("%s\n", comment);
break;
case INFO_OPTIONS:
if (pkg_list_count(pkg, PKG_OPTIONS) > 0) {
if (print_tag)
printf("%-15s:\n", "Options");
while (pkg_options(pkg, &option) == EPKG_OK)
printf("%s%-15s: %s\n",
tab,
pkg_option_opt(option),
pkg_option_value(option));
}
break;
case INFO_SHLIBS_REQUIRED:
if (pkg_list_count(pkg, PKG_SHLIBS_REQUIRED) > 0) {
if (print_tag)
printf("%-15s:\n", "Shared Libs required");
while (pkg_shlibs_required(pkg, &shlib) == EPKG_OK)
printf("%s%s\n", tab, pkg_shlib_name(shlib));
}
break;
case INFO_SHLIBS_PROVIDED:
if (pkg_list_count(pkg, PKG_SHLIBS_PROVIDED) > 0) {
if (print_tag)
printf("%-15s:\n", "Shared Libs provided");
while (pkg_shlibs_provided(pkg, &shlib) == EPKG_OK)
printf("%s%s\n", tab, pkg_shlib_name(shlib));
}
break;
case INFO_FLATSIZE:
if (pkg_type(pkg) == PKG_INSTALLED ||
pkg_type(pkg) == PKG_FILE)
humanize_number(size, sizeof(size),
flatsize,"B",
HN_AUTOSCALE, 0);
else
humanize_number(size, sizeof(size),
newflatsize,"B",
HN_AUTOSCALE, 0);
if (print_tag)
printf("%-15s: ", "Flat size");
printf("%s\n", size);
break;
case INFO_PKGSIZE: /* Remote pkgs only */
if (pkg_type(pkg) == PKG_REMOTE) {
humanize_number(size, sizeof(size),
newpkgsize,"B",
HN_AUTOSCALE, 0);
if (print_tag)
printf("%-15s: ", "Pkg size");
printf("%s\n", size);
} else if (!print_tag)
printf("\n");
break;
case INFO_DESCR:
if (print_tag)
printf("%-15s:\n", "Description");
printf("%s\n", desc);
break;
case INFO_MESSAGE:
if (message) {
if (print_tag)
printf("%-15s:\n", "Message");
printf("%s\n", message);
}
break;
case INFO_DEPS:
if (pkg_list_count(pkg, PKG_DEPS) > 0) {
if (print_tag)
printf("%-15s:\n", "Depends on");
while (pkg_deps(pkg, &dep) == EPKG_OK) {
printf("%s%s-%s",
tab,
pkg_dep_name(dep),
pkg_dep_version(dep));
if (show_locks && pkg_dep_is_locked(dep))
printf(" (*)");
printf("\n");
}
}
break;
case INFO_RDEPS:
if (pkg_list_count(pkg, PKG_RDEPS) > 0) {
if (print_tag)
printf("%-15s:\n", "Required by");
while (pkg_rdeps(pkg, &dep) == EPKG_OK) {
printf("%s%s-%s",
tab,
pkg_dep_name(dep),
pkg_dep_version(dep));
if (show_locks && pkg_dep_is_locked(dep))
printf(" (*)");
printf("\n");
}
}
break;
case INFO_FILES: /* Installed pkgs only */
if (pkg_type(pkg) != PKG_REMOTE &&
pkg_list_count(pkg, PKG_FILES) > 0) {
if (print_tag)
printf("%-15s:\n", "Files");
while (pkg_files(pkg, &file) == EPKG_OK)
printf("%s%s\n",
tab,
pkg_file_path(file));
}
break;
case INFO_DIRS: /* Installed pkgs only */
if (pkg_type(pkg) != PKG_REMOTE &&
pkg_list_count(pkg, PKG_DIRS) > 0) {
if (print_tag)
printf("%-15s:\n", "Directories");
while (pkg_dirs(pkg, &dir) == EPKG_OK)
printf("%s%s\n",
tab,
pkg_dir_path(dir));
}
break;
case INFO_USERS: /* Installed pkgs only */
if (pkg_type(pkg) != PKG_REMOTE &&
pkg_list_count(pkg, PKG_USERS) > 0) {
if (print_tag)
printf("%-15s: ", "Users");
if (pkg_users(pkg, &user) == EPKG_OK)
printf("%s", pkg_user_name(user));
while (pkg_users(pkg, &user) == EPKG_OK)
printf(" %s", pkg_user_name(user));
printf("\n");
}
break;
case INFO_GROUPS: /* Installed pkgs only */
if (pkg_type(pkg) != PKG_REMOTE &&
pkg_list_count(pkg, PKG_GROUPS) > 0) {
if (print_tag)
printf("%-15s: ", "Groups");
if (pkg_groups(pkg, &group) == EPKG_OK)
printf("%s", pkg_group_name(group));
while (pkg_groups(pkg, &group) == EPKG_OK)
printf(" %s", pkg_group_name(group));
printf("\n");
}
break;
case INFO_ARCH:
if (print_tag)
printf("%-15s: ", "Architecture");
printf("%s\n", arch);
break;
case INFO_REPOURL:
if (pkg_type(pkg) == PKG_REMOTE &&
repourl != NULL && repourl[0] != '\0') {
if (print_tag)
printf("%-15s: ", "Pkg URL");
if (repourl[strlen(repourl) -1] == '/')
printf("%s%s\n", repourl, repopath);
else
printf("%s/%s\n", repourl, repopath);
} else if (!print_tag)
printf("\n");
break;
case INFO_LOCKED:
if (print_tag)
printf("%-15s: ", "Locked");
printf("%s\n", locked ? "yes" : "no");
break;
}
}
}
static void
pipeevent(struct pkg_event *ev)
{
int i;
struct pkg_dep *dep = NULL;
struct sbuf *msg, *buf;
const char *message;
struct pkg_event_conflict *cur_conflict;
if (eventpipe < 0)
return;
msg = sbuf_new_auto();
buf = sbuf_new_auto();
switch(ev->type) {
case PKG_EVENT_ERRNO:
sbuf_printf(msg, "{ \"type\": \"ERROR\", "
"\"data\": {"
"\"msg\": \"%s(%s): %s\","
"\"errno\": %d}}",
sbuf_json_escape(buf, ev->e_errno.func),
sbuf_json_escape(buf, ev->e_errno.arg),
sbuf_json_escape(buf, strerror(ev->e_errno.no)),
ev->e_errno.no);
break;
case PKG_EVENT_ERROR:
sbuf_printf(msg, "{ \"type\": \"ERROR\", "
"\"data\": {\"msg\": \"%s\"}}",
sbuf_json_escape(buf, ev->e_pkg_error.msg));
break;
case PKG_EVENT_NOTICE:
sbuf_printf(msg, "{ \"type\": \"NOTICE\", "
"\"data\": {\"msg\": \"%s\"}}",
sbuf_json_escape(buf, ev->e_pkg_notice.msg));
break;
case PKG_EVENT_DEVELOPER_MODE:
sbuf_printf(msg, "{ \"type\": \"ERROR\", "
"\"data\": {\"msg\": \"DEVELOPER_MODE: %s\"}}",
sbuf_json_escape(buf, ev->e_pkg_error.msg));
break;
case PKG_EVENT_UPDATE_ADD:
sbuf_printf(msg, "{ \"type\": \"INFO_UPDATE_ADD\", "
"\"data\": { "
"\"fetched\": %d, "
"\"total\": %d"
"}}",
ev->e_upd_add.done,
ev->e_upd_add.total
);
break;
case PKG_EVENT_UPDATE_REMOVE:
sbuf_printf(msg, "{ \"type\": \"INFO_UPDATE_REMOVE\", "
"\"data\": { "
"\"fetched\": %d, "
"\"total\": %d"
"}}",
ev->e_upd_remove.done,
ev->e_upd_remove.total
);
break;
case PKG_EVENT_FETCH_BEGIN:
sbuf_printf(msg, "{ \"type\": \"INFO_FETCH_BEGIN\", "
"\"data\": { "
"\"url\": \"%s\" "
"}}",
sbuf_json_escape(buf, ev->e_fetching.url)
);
break;
case PKG_EVENT_FETCH_FINISHED:
sbuf_printf(msg, "{ \"type\": \"INFO_FETCH_FINISHED\", "
"\"data\": { "
"\"url\": \"%s\" "
"}}",
sbuf_json_escape(buf, ev->e_fetching.url)
);
break;
case PKG_EVENT_INSTALL_BEGIN:
pkg_sbuf_printf(msg, "{ \"type\": \"INFO_INSTALL_BEGIN\", "
"\"data\": { "
"\"pkgname\": \"%n\", "
"\"pkgversion\": \"%v\""
"}}", ev->e_install_begin.pkg, ev->e_install_begin.pkg);
break;
case PKG_EVENT_EXTRACT_BEGIN:
pkg_sbuf_printf(msg, "{ \"type\": \"INFO_EXTRACT_BEGIN\", "
"\"data\": { "
"\"pkgname\": \"%n\", "
"\"pkgversion\": \"%v\""
"}}", ev->e_extract_begin.pkg, ev->e_extract_begin.pkg);
break;
case PKG_EVENT_EXTRACT_FINISHED:
pkg_sbuf_printf(msg, "{ \"type\": \"INFO_EXTRACT_FINISHED\", "
"\"data\": { "
"\"pkgname\": \"%n\", "
"\"pkgversion\": \"%v\""
"}}", ev->e_extract_finished.pkg, ev->e_extract_finished.pkg);
break;
case PKG_EVENT_INSTALL_FINISHED:
pkg_get(ev->e_install_finished.pkg,
PKG_MESSAGE, &message);
pkg_sbuf_printf(msg, "{ \"type\": \"INFO_INSTALL_FINISHED\", "
"\"data\": { "
"\"pkgname\": \"%n\", "
"\"pkgversion\": \"%v\", "
"\"message\": \"%S\""
"}}",
ev->e_install_finished.pkg,
ev->e_install_finished.pkg,
sbuf_json_escape(buf, message));
break;
case PKG_EVENT_INTEGRITYCHECK_BEGIN:
sbuf_printf(msg, "{ \"type\": \"INFO_INTEGRITYCHECK_BEGIN\", "
"\"data\": {}}");
break;
case PKG_EVENT_INTEGRITYCHECK_CONFLICT:
sbuf_printf(msg, "{ \"type\": \"INFO_INTEGRITYCHECK_CONFLICT\","
"\"data\": { "
"\"pkguid\": \"%s\", "
"\"pkgpath\": \"%s\", "
"\"conflicts\": [",
ev->e_integrity_conflict.pkg_uid,
ev->e_integrity_conflict.pkg_path);
cur_conflict = ev->e_integrity_conflict.conflicts;
while (cur_conflict != NULL) {
if (cur_conflict->next != NULL) {
sbuf_printf(msg, "{\"uid\":\"%s\"},",
cur_conflict->uid);
}
else {
sbuf_printf(msg, "{\"uid\":\"%s\"}",
cur_conflict->uid);
break;
}
cur_conflict = cur_conflict->next;
}
sbuf_cat(msg, "]}}");
break;
case PKG_EVENT_INTEGRITYCHECK_FINISHED:
sbuf_printf(msg, "{ \"type\": \"INFO_INTEGRITYCHECK_FINISHED\", "
"\"data\": {\"conflicting\": %d}}",
ev->e_integrity_finished.conflicting);
break;
case PKG_EVENT_DEINSTALL_BEGIN:
pkg_sbuf_printf(msg, "{ \"type\": \"INFO_DEINSTALL_BEGIN\", "
"\"data\": { "
"\"pkgname\": \"%n\", "
"\"pkgversion\": \"%v\""
"}}",
ev->e_deinstall_begin.pkg,
ev->e_deinstall_begin.pkg);
break;
case PKG_EVENT_DEINSTALL_FINISHED:
pkg_sbuf_printf(msg, "{ \"type\": \"INFO_DEINSTALL_FINISHED\", "
"\"data\": { "
"\"pkgname\": \"%n\", "
"\"pkgversion\": \"%v\""
"}}",
ev->e_deinstall_finished.pkg,
ev->e_deinstall_finished.pkg);
break;
case PKG_EVENT_UPGRADE_BEGIN:
pkg_sbuf_printf(msg, "{ \"type\": \"INFO_UPGRADE_BEGIN\", "
"\"data\": { "
"\"pkgname\": \"%n\", "
"\"pkgversion\": \"%v\" ,"
"\"pkgnewversion\": \"%v\""
"}}",
ev->e_upgrade_begin.old,
ev->e_upgrade_begin.old,
ev->e_upgrade_begin.new);
break;
case PKG_EVENT_UPGRADE_FINISHED:
pkg_sbuf_printf(msg, "{ \"type\": \"INFO_UPGRADE_FINISHED\", "
"\"data\": { "
"\"pkgname\": \"%n\", "
"\"pkgversion\": \"%v\" ,"
"\"pkgnewversion\": \"%v\""
"}}",
ev->e_upgrade_begin.old,
ev->e_upgrade_begin.old,
ev->e_upgrade_begin.new);
break;
case PKG_EVENT_LOCKED:
pkg_sbuf_printf(msg, "{ \"type\": \"ERROR_LOCKED\", "
"\"data\": { "
"\"pkgname\": \"%n\", "
"\"pkgversion\": \"%n\""
"}}",
ev->e_locked.pkg,
ev->e_locked.pkg);
break;
case PKG_EVENT_REQUIRED:
pkg_sbuf_printf(msg, "{ \"type\": \"ERROR_REQUIRED\", "
"\"data\": { "
"\"pkgname\": \"%n\", "
"\"pkgversion\": \"%v\", "
"\"force\": %S, "
"\"required_by\": [",
ev->e_required.pkg,
ev->e_required.pkg,
ev->e_required.force == 1 ? "true": "false");
while (pkg_rdeps(ev->e_required.pkg, &dep) == EPKG_OK)
sbuf_printf(msg, "{ \"pkgname\": \"%s\", "
"\"pkgversion\": \"%s\" }, ",
pkg_dep_name(dep),
pkg_dep_version(dep));
sbuf_setpos(msg, sbuf_len(msg) - 2);
sbuf_cat(msg, "]}}");
break;
case PKG_EVENT_ALREADY_INSTALLED:
pkg_sbuf_printf(msg, "{ \"type\": \"ERROR_ALREADY_INSTALLED\", "
"\"data\": { "
"\"pkgname\": \"%n\", "
"\"pkgversion\": \"%v\""
"}}",
ev->e_already_installed.pkg,
ev->e_already_installed.pkg);
break;
case PKG_EVENT_MISSING_DEP:
sbuf_printf(msg, "{ \"type\": \"ERROR_MISSING_DEP\", "
"\"data\": { "
"\"depname\": \"%s\", "
"\"depversion\": \"%s\""
"}}" ,
pkg_dep_name(ev->e_missing_dep.dep),
pkg_dep_version(ev->e_missing_dep.dep));
break;
case PKG_EVENT_NOREMOTEDB:
sbuf_printf(msg, "{ \"type\": \"ERROR_NOREMOTEDB\", "
"\"data\": { "
"\"url\": \"%s\" "
"}}" ,
ev->e_remotedb.repo);
break;
case PKG_EVENT_NOLOCALDB:
sbuf_printf(msg, "{ \"type\": \"ERROR_NOLOCALDB\", "
"\"data\": {} ");
break;
case PKG_EVENT_NEWPKGVERSION:
sbuf_printf(msg, "{ \"type\": \"INFO_NEWPKGVERSION\", "
"\"data\": {} ");
break;
case PKG_EVENT_FILE_MISMATCH:
pkg_sbuf_printf(msg, "{ \"type\": \"ERROR_FILE_MISMATCH\", "
"\"data\": { "
"\"pkgname\": \"%n\", "
"\"pkgversion\": \"%v\", "
"\"path\": \"%S\""
"}}",
ev->e_file_mismatch.pkg,
ev->e_file_mismatch.pkg,
sbuf_json_escape(buf, pkg_file_path(ev->e_file_mismatch.file)));
break;
case PKG_EVENT_PLUGIN_ERRNO:
sbuf_printf(msg, "{ \"type\": \"ERROR_PLUGIN\", "
"\"data\": {"
"\"plugin\": \"%s\", "
"\"msg\": \"%s(%s): %s\","
"\"errno\": %d"
"}}",
pkg_plugin_get(ev->e_plugin_errno.plugin, PKG_PLUGIN_NAME),
sbuf_json_escape(buf, ev->e_plugin_errno.func),
sbuf_json_escape(buf, ev->e_plugin_errno.arg),
sbuf_json_escape(buf, strerror(ev->e_plugin_errno.no)),
ev->e_plugin_errno.no);
break;
case PKG_EVENT_PLUGIN_ERROR:
sbuf_printf(msg, "{ \"type\": \"ERROR_PLUGIN\", "
"\"data\": {"
"\"plugin\": \"%s\", "
"\"msg\": \"%s\""
"}}",
pkg_plugin_get(ev->e_plugin_error.plugin, PKG_PLUGIN_NAME),
sbuf_json_escape(buf, ev->e_plugin_error.msg));
break;
case PKG_EVENT_PLUGIN_INFO:
sbuf_printf(msg, "{ \"type\": \"INFO_PLUGIN\", "
"\"data\": {"
"\"plugin\": \"%s\", "
"\"msg\": \"%s\""
"}}",
pkg_plugin_get(ev->e_plugin_info.plugin, PKG_PLUGIN_NAME),
sbuf_json_escape(buf, ev->e_plugin_info.msg));
break;
case PKG_EVENT_INCREMENTAL_UPDATE:
sbuf_printf(msg, "{ \"type\": \"INFO_INCREMENTAL_UPDATE\", "
"\"data\": {"
"\"name\": \"%s\", "
"\"updated\": %d, "
"\"removed\": %d, "
"\"added\": %d, "
"\"processed\": %d"
"}}", ev->e_incremental_update.reponame,
ev->e_incremental_update.updated,
ev->e_incremental_update.removed,
ev->e_incremental_update.added,
ev->e_incremental_update.processed);
break;
case PKG_EVENT_QUERY_YESNO:
sbuf_printf(msg, "{ \"type\": \"QUERY_YESNO\", "
"\"data\": {"
"\"msg\": \"%s\","
"\"default\": \"%d\""
"}}", ev->e_query_yesno.msg,
ev->e_query_yesno.deft);
break;
case PKG_EVENT_QUERY_SELECT:
sbuf_printf(msg, "{ \"type\": \"QUERY_SELECT\", "
"\"data\": {"
"\"msg\": \"%s\","
"\"ncnt\": \"%d\","
"\"default\": \"%d\","
"\"items\": ["
, ev->e_query_select.msg,
ev->e_query_select.ncnt,
ev->e_query_select.deft);
for (i = 0; i < ev->e_query_select.ncnt - 1; i++)
{
sbuf_printf(msg, "{ \"text\": \"%s\" },",
ev->e_query_select.items[i]);
}
sbuf_printf(msg, "{ \"text\": \"%s\" } ] }}",
ev->e_query_select.items[i]);
break;
case PKG_EVENT_PROGRESS_START:
sbuf_printf(msg, "{ \"type\": \"INFO_PROGRESS_START\", "
"\"data\": {}}");
break;
case PKG_EVENT_PROGRESS_TICK:
sbuf_printf(msg, "{ \"type\": \"INFO_PROGRESS_TICK\", "
"\"data\": { \"current\": %ld, \"total\" : %ld}}",
ev->e_progress_tick.current, ev->e_progress_tick.total);
break;
case PKG_EVENT_BACKUP:
case PKG_EVENT_RESTORE:
break;
default:
break;
}
sbuf_finish(msg);
dprintf(eventpipe, "%s\n", sbuf_data(msg));
sbuf_delete(msg);
sbuf_delete(buf);
}
static int
pkg_create_from_dir(struct pkg *pkg, const char *root,
struct packing *pkg_archive)
{
char fpath[MAXPATHLEN];
struct pkg_file *file = NULL;
struct pkg_dir *dir = NULL;
char *m;
int ret;
const char *mtree;
bool developer;
struct stat st;
char sha256[SHA256_DIGEST_LENGTH * 2 + 1];
int64_t flatsize = 0;
ucl_object_t *obj;
if (pkg_is_valid(pkg) != EPKG_OK) {
pkg_emit_error("the package is not valid");
return (EPKG_FATAL);
}
obj = pkg_annotation_lookup(pkg, "relocated");
/*
* Get / compute size / checksum if not provided in the manifest
*/
while (pkg_files(pkg, &file) == EPKG_OK) {
const char *pkg_path = pkg_file_path(file);
const char *pkg_sum = pkg_file_cksum(file);
snprintf(fpath, sizeof(fpath), "%s%s%s", root ? root : "",
obj ? pkg_object_string(obj) : "", pkg_path);
if (lstat(fpath, &st) != 0 || S_ISLNK(st.st_mode))
continue;
if (file->size == 0)
file->size = (int64_t)st.st_size;
flatsize += file->size;
if (pkg_sum == NULL || pkg_sum[0] == '\0') {
if (pkg->type == PKG_OLD_FILE) {
if (md5_file(fpath, sha256) != EPKG_OK)
return (EPKG_FATAL);
} else {
if (sha256_file(fpath, sha256) != EPKG_OK)
return (EPKG_FATAL);
}
strlcpy(file->sum, sha256, sizeof(file->sum));
}
}
pkg_set(pkg, PKG_FLATSIZE, flatsize);
if (pkg->type == PKG_OLD_FILE) {
const char *desc, *display, *comment;
char oldcomment[BUFSIZ];
pkg_old_emit_content(pkg, &m);
packing_append_buffer(pkg_archive, m, "+CONTENTS", strlen(m));
free(m);
pkg_get(pkg, PKG_DESC, &desc, PKG_MESSAGE, &display, PKG_COMMENT, &comment);
packing_append_buffer(pkg_archive, desc, "+DESC", strlen(desc));
packing_append_buffer(pkg_archive, display, "+DISPLAY", strlen(display));
snprintf(oldcomment, sizeof(oldcomment), "%s\n", comment);
packing_append_buffer(pkg_archive, oldcomment, "+COMMENT", strlen(oldcomment));
} else {
/*
* Register shared libraries used by the package if
* SHLIBS enabled in conf. Deletes shlib info if not.
*/
struct sbuf *b = sbuf_new_auto();
pkg_register_shlibs(pkg, root);
pkg_emit_manifest_sbuf(pkg, b, PKG_MANIFEST_EMIT_COMPACT, NULL);
packing_append_buffer(pkg_archive, sbuf_data(b), "+COMPACT_MANIFEST", sbuf_len(b));
sbuf_clear(b);
pkg_emit_manifest_sbuf(pkg, b, 0, NULL);
sbuf_finish(b);
packing_append_buffer(pkg_archive, sbuf_data(b), "+MANIFEST", sbuf_len(b));
sbuf_delete(b);
}
pkg_get(pkg, PKG_MTREE, &mtree);
if (mtree != NULL)
packing_append_buffer(pkg_archive, mtree, "+MTREE_DIRS",
strlen(mtree));
while (pkg_files(pkg, &file) == EPKG_OK) {
const char *pkg_path = pkg_file_path(file);
snprintf(fpath, sizeof(fpath), "%s%s%s", root ? root : "",
obj ? pkg_object_string(obj) : "", pkg_path);
ret = packing_append_file_attr(pkg_archive, fpath, pkg_path,
file->uname, file->gname, file->perm);
developer = pkg_object_bool(pkg_config_get("DEVELOPER_MODE"));
if (developer && ret != EPKG_OK)
return (ret);
}
while (pkg_dirs(pkg, &dir) == EPKG_OK) {
const char *pkg_path = pkg_dir_path(dir);
snprintf(fpath, sizeof(fpath), "%s%s%s", root ? root : "",
obj ? pkg_object_string(obj) : "", pkg_path);
ret = packing_append_file_attr(pkg_archive, fpath, pkg_path,
dir->uname, dir->gname, dir->perm);
developer = pkg_object_bool(pkg_config_get("DEVELOPER_MODE"));
if (developer && ret != EPKG_OK)
return (ret);
}
return (EPKG_OK);
}
static int
pkg_create_from_dir(struct pkg *pkg, const char *root,
struct packing *pkg_archive)
{
char fpath[MAXPATHLEN + 1];
struct pkg_file *file = NULL;
struct pkg_dir *dir = NULL;
char *m;
int ret;
const char *mtree;
bool developer;
struct stat st;
char sha256[SHA256_DIGEST_LENGTH * 2 + 1];
if (pkg_is_valid(pkg) != EPKG_OK) {
pkg_emit_error("the package is not valid");
return (EPKG_FATAL);
}
/*
* if the checksum is not provided in the manifest recompute it
*/
while (pkg_files(pkg, &file) == EPKG_OK) {
const char *pkg_path = pkg_file_path(file);
const char *pkg_sum = pkg_file_cksum(file);
if (root != NULL)
snprintf(fpath, sizeof(fpath), "%s%s", root, pkg_path);
else
strlcpy(fpath, pkg_path, sizeof(fpath));
if ((pkg_sum == NULL || pkg_sum[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));
}
}
/*
* Register shared libraries used by the package if SHLIBS
* enabled in conf. Deletes shlib info if not.
*/
pkg_register_shlibs(pkg);
pkg_emit_manifest(pkg, &m);
packing_append_buffer(pkg_archive, m, "+MANIFEST", strlen(m));
free(m);
pkg_get(pkg, PKG_MTREE, &mtree);
if (mtree != NULL)
packing_append_buffer(pkg_archive, mtree, "+MTREE_DIRS",
strlen(mtree));
while (pkg_files(pkg, &file) == EPKG_OK) {
const char *pkg_path = pkg_file_path(file);
if (root != NULL)
snprintf(fpath, sizeof(fpath), "%s%s", root, pkg_path);
else
strlcpy(fpath, pkg_path, sizeof(fpath));
ret = packing_append_file_attr(pkg_archive, fpath, pkg_path,
file->uname, file->gname, file->perm);
pkg_config_bool(PKG_CONFIG_DEVELOPER_MODE, &developer);
if (developer && ret != EPKG_OK)
return (ret);
}
while (pkg_dirs(pkg, &dir) == EPKG_OK) {
const char *pkg_path = pkg_dir_path(dir);
if (root != NULL)
snprintf(fpath, sizeof(fpath), "%s%s", root, pkg_path);
else
strlcpy(fpath, pkg_dir_path(dir), sizeof(fpath));
ret = packing_append_file_attr(pkg_archive, fpath, pkg_path,
dir->uname, dir->gname, dir->perm);
pkg_config_bool(PKG_CONFIG_DEVELOPER_MODE, &developer);
if (developer && ret != EPKG_OK)
return (ret);
}
return (EPKG_OK);
}