static int
pkg_repo_binary_add_from_manifest(char *buf, const char *origin, const char *digest,
long offset, sqlite3 *sqlite,
struct pkg_manifest_key **keys, struct pkg **p, bool is_legacy,
struct pkg_repo *repo)
{
int rc = EPKG_OK;
struct pkg *pkg;
const char *local_origin, *pkg_arch;
if (*p == NULL) {
rc = pkg_new(p, PKG_REMOTE);
if (rc != EPKG_OK)
return (EPKG_FATAL);
} else {
pkg_reset(*p, PKG_REMOTE);
}
pkg = *p;
pkg_manifest_keys_new(keys);
rc = pkg_parse_manifest(pkg, buf, offset, *keys);
if (rc != EPKG_OK) {
goto cleanup;
}
rc = pkg_is_valid(pkg);
if (rc != EPKG_OK) {
goto cleanup;
}
/* Ensure that we have a proper origin and arch*/
pkg_get(pkg, PKG_ORIGIN, &local_origin, PKG_ARCH, &pkg_arch);
if (local_origin == NULL || strcmp(local_origin, origin) != 0) {
pkg_emit_error("manifest contains origin %s while we wanted to add origin %s",
local_origin ? local_origin : "NULL", origin);
rc = EPKG_FATAL;
goto cleanup;
}
if (pkg_arch == NULL || !is_valid_abi(pkg_arch, true)) {
rc = EPKG_FATAL;
pkg_emit_error("repository %s contains packages with wrong ABI: %s",
repo->name, pkg_arch);
goto cleanup;
}
pkg_set(pkg, PKG_REPONAME, repo->name);
if (is_legacy) {
pkg_set(pkg, PKG_OLD_DIGEST, digest);
pkg_checksum_calculate(pkg, NULL);
}
else {
pkg_set(pkg, PKG_DIGEST, digest);
}
rc = pkg_repo_binary_add_pkg(pkg, NULL, sqlite, true);
cleanup:
return (rc);
}
static int
pkg_add_from_manifest(FILE *f, char *buf, const char *origin, long offset,
const char *manifest_digest, const char *local_arch, sqlite3 *sqlite,
struct pkg_manifest_parser **parser, struct pkg **p)
{
int rc = EPKG_OK;
struct pkg *pkg;
const char *local_origin, *pkg_arch;
if (buf == NULL && fseek(f, offset, SEEK_SET) == -1) {
pkg_emit_errno("fseek", "invalid manifest offset");
return (EPKG_FATAL);
}
if (*p == NULL) {
rc = pkg_new(p, PKG_REMOTE);
if (rc != EPKG_OK)
return (EPKG_FATAL);
} else {
pkg_reset(*p, PKG_REMOTE);
}
pkg = *p;
pkg_manifest_parser_new(parser);
if (buf == NULL) {
rc = pkg_parse_manifest_file_ev(pkg, f, *parser);
} else {
rc = pkg_parse_manifest_ev(pkg, buf, offset, *parser);
}
if (rc != EPKG_OK) {
goto cleanup;
}
rc = pkg_is_valid(pkg);
if (rc != EPKG_OK) {
goto cleanup;
}
/* Ensure that we have a proper origin and arch*/
pkg_get(pkg, PKG_ORIGIN, &local_origin, PKG_ARCH, &pkg_arch);
if (local_origin == NULL || strcmp(local_origin, origin) != 0) {
pkg_emit_error("manifest contains origin %s while we wanted to add origin %s",
local_origin ? local_origin : "NULL", origin);
rc = EPKG_FATAL;
goto cleanup;
}
if (pkg_arch == NULL || strcmp(pkg_arch, local_arch) != 0) {
pkg_emit_error("package %s is built for %s arch, and local arch is %s",
origin, pkg_arch ? pkg_arch : "NULL", local_arch);
rc = EPKG_FATAL;
goto cleanup;
}
rc = pkgdb_repo_add_package(pkg, NULL, sqlite, manifest_digest, true, false);
cleanup:
return (rc);
}
static int
pkg_repo_add_from_manifest(char *buf, const char *origin, long offset,
const char *manifest_digest, sqlite3 *sqlite,
struct pkg_manifest_key **keys, struct pkg **p)
{
int rc = EPKG_OK;
struct pkg *pkg;
const char *local_origin, *pkg_arch;
if (*p == NULL) {
rc = pkg_new(p, PKG_REMOTE);
if (rc != EPKG_OK)
return (EPKG_FATAL);
} else {
pkg_reset(*p, PKG_REMOTE);
}
pkg = *p;
pkg_manifest_keys_new(keys);
rc = pkg_parse_manifest(pkg, buf, offset, *keys);
if (rc != EPKG_OK) {
goto cleanup;
}
rc = pkg_is_valid(pkg);
if (rc != EPKG_OK) {
goto cleanup;
}
/* Ensure that we have a proper origin and arch*/
pkg_get(pkg, PKG_ORIGIN, &local_origin, PKG_ARCH, &pkg_arch);
if (local_origin == NULL || strcmp(local_origin, origin) != 0) {
pkg_emit_error("manifest contains origin %s while we wanted to add origin %s",
local_origin ? local_origin : "NULL", origin);
rc = EPKG_FATAL;
goto cleanup;
}
if (pkg_arch == NULL || !is_valid_abi(pkg_arch, true)) {
rc = EPKG_FATAL;
goto cleanup;
}
rc = pkgdb_repo_add_package(pkg, NULL, sqlite, manifest_digest, true);
cleanup:
return (rc);
}
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];
struct pkg_file *file = NULL;
struct pkg_dir *dir = NULL;
int ret;
struct stat st;
int64_t flatsize = 0;
int64_t nfiles;
const char *relocation;
hardlinks_t *hardlinks;
if (pkg_is_valid(pkg) != EPKG_OK) {
pkg_emit_error("the package is not valid");
return (EPKG_FATAL);
}
relocation = pkg_kv_get(&pkg->annotations, "relocated");
if (relocation == NULL)
relocation = "";
if (pkg_rootdir != NULL)
relocation = pkg_rootdir;
/*
* Get / compute size / checksum if not provided in the manifest
*/
nfiles = kh_count(pkg->filehash);
counter_init("file sizes/checksums", nfiles);
hardlinks = kh_init_hardlinks();
while (pkg_files(pkg, &file) == EPKG_OK) {
snprintf(fpath, sizeof(fpath), "%s%s%s", root ? root : "",
relocation, file->path);
if (lstat(fpath, &st) == -1) {
pkg_emit_error("file '%s' is missing", fpath);
return (EPKG_FATAL);
}
if (file->size == 0)
file->size = (int64_t)st.st_size;
if (st.st_nlink == 1 || !check_for_hardlink(hardlinks, &st)) {
flatsize += file->size;
}
file->sum = pkg_checksum_generate_file(fpath,
PKG_HASH_TYPE_SHA256_HEX);
if (file->sum == NULL)
return (EPKG_FATAL);
counter_count();
}
kh_destroy_hardlinks(hardlinks);
counter_end();
pkg->flatsize = flatsize;
if (pkg->type == PKG_OLD_FILE) {
pkg_emit_error("Cannot create an old format package");
return (EPKG_FATAL);
} 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_analyse_files(NULL, 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);
}
counter_init("packing files", nfiles);
while (pkg_files(pkg, &file) == EPKG_OK) {
snprintf(fpath, sizeof(fpath), "%s%s%s", root ? root : "",
relocation, file->path);
ret = packing_append_file_attr(pkg_archive, fpath, file->path,
file->uname, file->gname, file->perm, file->fflags);
if (developer_mode && ret != EPKG_OK)
return (ret);
counter_count();
}
counter_end();
nfiles = kh_count(pkg->dirhash);
counter_init("packing directories", nfiles);
while (pkg_dirs(pkg, &dir) == EPKG_OK) {
snprintf(fpath, sizeof(fpath), "%s%s%s", root ? root : "",
relocation, dir->path);
ret = packing_append_file_attr(pkg_archive, fpath, dir->path,
dir->uname, dir->gname, dir->perm, dir->fflags);
if (developer_mode && ret != EPKG_OK)
return (ret);
counter_count();
}
counter_end();
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);
}
int
pkg_add(struct pkgdb *db, const char *path, unsigned flags, struct pkg_manifest_key *keys)
{
const char *arch;
const char *origin;
const char *name;
struct archive *a;
struct archive_entry *ae;
struct pkg *pkg = NULL;
struct pkg_dep *dep = NULL;
struct pkg *pkg_inst = NULL;
bool extract = true;
bool handle_rc = false;
bool disable_mtree;
char dpath[MAXPATHLEN];
const char *basedir;
const char *ext;
char *mtree;
char *prefix;
int retcode = EPKG_OK;
int ret;
assert(path != NULL);
/*
* Open the package archive file, read all the meta files and set the
* current archive_entry to the first non-meta file.
* If there is no non-meta files, EPKG_END is returned.
*/
ret = pkg_open2(&pkg, &a, &ae, path, keys, 0);
if (ret == EPKG_END)
extract = false;
else if (ret != EPKG_OK) {
retcode = ret;
goto cleanup;
}
if ((flags & PKG_ADD_UPGRADE) == 0)
pkg_emit_install_begin(pkg);
if (pkg_is_valid(pkg) != EPKG_OK) {
pkg_emit_error("the package is not valid");
return (EPKG_FATAL);
}
if (flags & PKG_ADD_AUTOMATIC)
pkg_set(pkg, PKG_AUTOMATIC, (int64_t)true);
/*
* Check the architecture
*/
pkg_get(pkg, PKG_ARCH, &arch, PKG_ORIGIN, &origin, PKG_NAME, &name);
if (!is_valid_abi(arch, true)) {
if ((flags & PKG_ADD_FORCE) == 0) {
retcode = EPKG_FATAL;
goto cleanup;
}
}
/*
* Check if the package is already installed
*/
ret = pkg_try_installed(db, origin, &pkg_inst, PKG_LOAD_BASIC);
if (ret == EPKG_OK) {
if ((flags & PKG_FLAG_FORCE) == 0) {
pkg_emit_already_installed(pkg_inst);
retcode = EPKG_INSTALLED;
pkg_free(pkg_inst);
pkg_inst = NULL;
goto cleanup;
}
else {
pkg_emit_notice("package %s is already installed, forced install", name);
pkg_free(pkg_inst);
pkg_inst = NULL;
}
} else if (ret != EPKG_END) {
retcode = ret;
goto cleanup;
}
/*
* Check for dependencies by searching the same directory as
* the package archive we're reading. Of course, if we're
* reading from a file descriptor or a unix domain socket or
* somesuch, there's no valid directory to search.
*/
if (pkg_type(pkg) == PKG_FILE) {
basedir = dirname(path);
if ((ext = strrchr(path, '.')) == NULL) {
pkg_emit_error("%s has no extension", path);
retcode = EPKG_FATAL;
goto cleanup;
}
} else {
basedir = NULL;
ext = NULL;
}
while (pkg_deps(pkg, &dep) == EPKG_OK) {
if (pkg_is_installed(db, pkg_dep_origin(dep)) == EPKG_OK)
continue;
if (basedir != NULL) {
const char *dep_name = pkg_dep_name(dep);
const char *dep_ver = pkg_dep_version(dep);
snprintf(dpath, sizeof(dpath), "%s/%s-%s%s", basedir,
dep_name, dep_ver, ext);
if ((flags & PKG_ADD_UPGRADE) == 0 &&
access(dpath, F_OK) == 0) {
ret = pkg_add(db, dpath, PKG_ADD_AUTOMATIC, keys);
if (ret != EPKG_OK) {
retcode = EPKG_FATAL;
goto cleanup;
}
} else {
pkg_emit_error("Missing dependency matching '%s'",
pkg_dep_get(dep, PKG_DEP_ORIGIN));
retcode = EPKG_FATAL;
goto cleanup;
}
} else {
retcode = EPKG_FATAL;
pkg_emit_missing_dep(pkg, dep);
goto cleanup;
}
}
/* register the package before installing it in case there are
* problems that could be caught here. */
retcode = pkgdb_register_pkg(db, pkg, flags & PKG_ADD_UPGRADE, flags & PKG_FLAG_FORCE);
if (retcode != EPKG_OK)
goto cleanup;
/* MTREE replicates much of the standard functionality
* inplicit in the way pkg works. It has to remain available
* in the ports for compatibility with the old pkg_tools, but
* ultimately, MTREE should be made redundant. Use this for
* experimantal purposes and to develop MTREE-free versions of
* packages. */
pkg_config_bool(PKG_CONFIG_DISABLE_MTREE, &disable_mtree);
if (!disable_mtree) {
pkg_get(pkg, PKG_PREFIX, &prefix, PKG_MTREE, &mtree);
if ((retcode = do_extract_mtree(mtree, prefix)) != EPKG_OK)
goto cleanup_reg;
}
/*
* Execute pre-install scripts
*/
if ((flags & (PKG_ADD_NOSCRIPT | PKG_ADD_USE_UPGRADE_SCRIPTS)) == 0)
pkg_script_run(pkg, PKG_SCRIPT_PRE_INSTALL);
/* add the user and group if necessary */
/* pkg_add_user_group(pkg); */
/*
* Extract the files on disk.
*/
if (extract && (retcode = do_extract(a, ae)) != EPKG_OK) {
/* If the add failed, clean up (silently) */
pkg_delete_files(pkg, 2);
pkg_delete_dirs(db, pkg, 1);
goto cleanup_reg;
}
/*
* Execute post install scripts
*/
if ((flags & PKG_ADD_NOSCRIPT) == 0) {
if ((flags & PKG_ADD_USE_UPGRADE_SCRIPTS) == PKG_ADD_USE_UPGRADE_SCRIPTS)
pkg_script_run(pkg, PKG_SCRIPT_POST_UPGRADE);
else
pkg_script_run(pkg, PKG_SCRIPT_POST_INSTALL);
}
/*
* start the different related services if the users do want that
* and that the service is running
*/
pkg_config_bool(PKG_CONFIG_HANDLE_RC_SCRIPTS, &handle_rc);
if (handle_rc)
pkg_start_stop_rc_scripts(pkg, PKG_RC_START);
cleanup_reg:
if ((flags & PKG_ADD_UPGRADE) == 0)
pkgdb_register_finale(db, retcode);
if (retcode == EPKG_OK && (flags & PKG_ADD_UPGRADE) == 0)
pkg_emit_install_finished(pkg);
cleanup:
if (a != NULL) {
archive_read_close(a);
archive_read_free(a);
}
pkg_free(pkg);
if (pkg_inst != NULL)
pkg_free(pkg_inst);
return (retcode);
}
int
pkg_add(struct pkgdb *db, const char *path, unsigned flags)
{
const char *arch;
const char *myarch;
const char *origin;
struct archive *a;
struct archive_entry *ae;
struct pkg *pkg = NULL;
struct pkg_dep *dep = NULL;
struct pkg *pkg_inst = NULL;
bool extract = true;
bool handle_rc = false;
char dpath[MAXPATHLEN + 1];
const char *basedir;
const char *ext;
char *mtree;
char *prefix;
int retcode = EPKG_OK;
int ret;
assert(path != NULL);
/*
* Open the package archive file, read all the meta files and set the
* current archive_entry to the first non-meta file.
* If there is no non-meta files, EPKG_END is returned.
*/
ret = pkg_open2(&pkg, &a, &ae, path);
if (ret == EPKG_END)
extract = false;
else if (ret != EPKG_OK) {
retcode = ret;
goto cleanup;
}
if ((flags & PKG_ADD_UPGRADE) == 0)
pkg_emit_install_begin(pkg);
if (pkg_is_valid(pkg) != EPKG_OK) {
pkg_emit_error("the package is not valid");
return (EPKG_FATAL);
}
if (flags & PKG_ADD_AUTOMATIC)
pkg_set(pkg, PKG_AUTOMATIC, true);
/*
* Check the architecture
*/
pkg_config_string(PKG_CONFIG_ABI, &myarch);
pkg_get(pkg, PKG_ARCH, &arch, PKG_ORIGIN, &origin);
if (fnmatch(myarch, arch, FNM_CASEFOLD) == FNM_NOMATCH &&
strncmp(arch, myarch, strlen(myarch)) != 0) {
pkg_emit_error("wrong architecture: %s instead of %s",
arch, myarch);
if ((flags & PKG_ADD_FORCE) == 0) {
retcode = EPKG_FATAL;
goto cleanup;
}
}
/*
* Check if the package is already installed
*/
ret = pkg_try_installed(db, origin, &pkg_inst, PKG_LOAD_BASIC);
if (ret == EPKG_OK) {
pkg_emit_already_installed(pkg_inst);
retcode = EPKG_INSTALLED;
goto cleanup;
} else if (ret != EPKG_END) {
retcode = ret;
goto cleanup;
}
/*
* Check for dependencies
*/
basedir = dirname(path);
if ((ext = strrchr(path, '.')) == NULL) {
pkg_emit_error("%s has no extension", path);
retcode = EPKG_FATAL;
goto cleanup;
}
while (pkg_deps(pkg, &dep) == EPKG_OK) {
if (pkg_is_installed(db, pkg_dep_origin(dep)) != EPKG_OK) {
const char *dep_name = pkg_dep_name(dep);
const char *dep_ver = pkg_dep_version(dep);
snprintf(dpath, sizeof(dpath), "%s/%s-%s%s", basedir,
dep_name, dep_ver, ext);
if ((flags & PKG_ADD_UPGRADE) == 0 &&
access(dpath, F_OK) == 0) {
ret = pkg_add(db, dpath, PKG_ADD_AUTOMATIC);
if (ret != EPKG_OK) {
retcode = EPKG_FATAL;
goto cleanup;
}
} else {
retcode = EPKG_FATAL;
pkg_emit_missing_dep(pkg, dep);
goto cleanup;
}
}
}
/* register the package before installing it in case there are
* problems that could be caught here. */
if ((flags & PKG_ADD_UPGRADE) == 0)
retcode = pkgdb_register_pkg(db, pkg, 0);
else
retcode = pkgdb_register_pkg(db, pkg, 1);
if (retcode != EPKG_OK)
goto cleanup;
pkg_get(pkg, PKG_PREFIX, &prefix, PKG_MTREE, &mtree);
if ((retcode = do_extract_mtree(mtree, prefix)) != EPKG_OK)
goto cleanup_reg;
/*
* Execute pre-install scripts
*/
if ((flags & (PKG_ADD_NOSCRIPT | PKG_ADD_USE_UPGRADE_SCRIPTS)) == 0)
pkg_script_run(pkg, PKG_SCRIPT_PRE_INSTALL);
/* add the user and group if necessary */
/* pkg_add_user_group(pkg); */
/*
* Extract the files on disk.
*/
if (extract && (retcode = do_extract(a, ae)) != EPKG_OK) {
/* If the add failed, clean up */
pkg_delete_files(pkg, 1);
pkg_delete_dirs(db, pkg, 1);
goto cleanup_reg;
}
/*
* Execute post install scripts
*/
if ((flags & PKG_ADD_NOSCRIPT) == 0) {
if (flags & PKG_ADD_USE_UPGRADE_SCRIPTS)
pkg_script_run(pkg, PKG_SCRIPT_POST_UPGRADE);
else
pkg_script_run(pkg, PKG_SCRIPT_POST_INSTALL);
}
/*
* start the different related services if the users do want that
* and that the service is running
*/
pkg_config_bool(PKG_CONFIG_HANDLE_RC_SCRIPTS, &handle_rc);
if (handle_rc)
pkg_start_stop_rc_scripts(pkg, PKG_RC_START);
cleanup_reg:
if ((flags & PKG_ADD_UPGRADE) == 0)
pkgdb_register_finale(db, retcode);
if (retcode == EPKG_OK && (flags & PKG_ADD_UPGRADE) == 0)
pkg_emit_install_finished(pkg);
cleanup:
if (a != NULL)
archive_read_free(a);
pkg_free(pkg);
pkg_free(pkg_inst);
return (retcode);
}
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;
bool developer;
struct stat st;
char sha256[SHA256_DIGEST_LENGTH * 2 + 1];
int64_t flatsize = 0;
const char *relocation;
struct hardlinks *hardlinks = NULL;
if (pkg_is_valid(pkg) != EPKG_OK) {
pkg_emit_error("the package is not valid");
return (EPKG_FATAL);
}
relocation = pkg_kv_get(&pkg->annotations, "relocated");
if (relocation == NULL)
relocation = "";
/*
* Get / compute size / checksum if not provided in the manifest
*/
while (pkg_files(pkg, &file) == EPKG_OK) {
snprintf(fpath, sizeof(fpath), "%s%s%s", root ? root : "",
relocation, file->path);
if (lstat(fpath, &st) == -1) {
pkg_emit_error("file '%s' is missing", fpath);
return (EPKG_FATAL);
}
if (file->size == 0)
file->size = (int64_t)st.st_size;
if (st.st_nlink == 1 || !check_for_hardlink(&hardlinks, &st)) {
flatsize += file->size;
}
if (S_ISLNK(st.st_mode)) {
if (file->sum[0] == '\0') {
if (pkg_symlink_cksum(fpath, root, sha256) == EPKG_OK)
strlcpy(file->sum, sha256, sizeof(file->sum));
else
return (EPKG_FATAL);
}
}
else {
if (file->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->flatsize = flatsize;
HASH_FREE(hardlinks, free);
if (pkg->type == PKG_OLD_FILE) {
char oldcomment[BUFSIZ];
pkg_old_emit_content(pkg, &m);
packing_append_buffer(pkg_archive, m, "+CONTENTS", strlen(m));
free(m);
packing_append_buffer(pkg_archive, pkg->desc, "+DESC", strlen(pkg->desc));
packing_append_buffer(pkg_archive, pkg->message, "+DISPLAY", strlen(pkg->message));
pkg_snprintf(oldcomment, sizeof(oldcomment), "%c\n", pkg);
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_analyse_files(NULL, 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);
}
while (pkg_files(pkg, &file) == EPKG_OK) {
snprintf(fpath, sizeof(fpath), "%s%s%s", root ? root : "",
relocation, file->path);
ret = packing_append_file_attr(pkg_archive, fpath, file->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) {
snprintf(fpath, sizeof(fpath), "%s%s%s", root ? root : "",
relocation, dir->path);
ret = packing_append_file_attr(pkg_archive, fpath, dir->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);
}
