static int do_add(struct pkgdb *db, struct pkg *pkg, const char *tag, const char *value) { const char *pkgname, *pkgversion; int ret = EPKG_OK; if (yes || query_tty_yesno(false, "%n-%v: Add annotation tagged: %S with " "value: %S? [y/N]: ", pkg, pkg, tag, value)) { ret = pkgdb_add_annotation(db, pkg, tag, value); if (ret == EPKG_OK) { if (!quiet) pkg_printf("%n-%v: added annotation tagged:" " %S\n", pkg, pkg, tag); } else if (ret == EPKG_WARN) { if (!quiet) { pkg_get(pkg, PKG_NAME, &pkgname, PKG_VERSION, &pkgversion); warnx("%s-%s: Cannot add annotation tagged: " "%s -- already exists", pkgname, pkgversion, tag); } } else { pkg_get(pkg, PKG_NAME, &pkgname, PKG_VERSION, &pkgversion); warnx("%s-%s: Failed to add annotation tagged: %s", pkgname, pkgversion, tag); } } return (ret); }
static struct packing * pkg_create_archive(const char *outdir, struct pkg *pkg, pkg_formats format, int required_flags) { char *pkg_path = NULL; struct packing *pkg_archive = NULL; /* * Ensure that we have all the information we need */ if ((pkg->flags & required_flags) != required_flags) { printf("error: required flags not set\n"); return NULL; } if (asprintf(&pkg_path, "%s/%s-%s", outdir, pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION)) == -1) { perror("asprintf"); return NULL; /* XXX do better */ } if (packing_init(&pkg_archive, pkg_path, format) != EPKG_OK) { perror("packing_init"); return NULL; } if (pkg_path != NULL) free(pkg_path); return pkg_archive; }
static int do_delete(struct pkgdb *db, struct pkg *pkg, const char *tag) { const char *pkgname, *pkgversion; int ret = EPKG_OK; if (yes || query_tty_yesno(false, "%n-%v: Delete annotation tagged: %S? " "[y/N]: ", pkg, pkg, tag)) { ret = pkgdb_delete_annotation(db, pkg, tag); if (ret == EPKG_OK) { if (!quiet) pkg_printf("%n-%v: Deleted annotation " "tagged: %S\n", pkg, pkg, tag); } else if (ret == EPKG_WARN) { if (!quiet) { pkg_get(pkg, PKG_NAME, &pkgname, PKG_VERSION, &pkgversion); warnx("%s-%s: Cannot delete annotation " "tagged: %s -- because there is none", pkgname, pkgversion, tag); } } else { pkg_get(pkg, PKG_NAME, &pkgname, PKG_VERSION, &pkgversion); warnx("%s-%s: Failed to delete annotation tagged: %s", pkgname, pkgversion, tag); } } return (ret); }
static int setprefix(struct plist *p, char *line, struct file_attr *a) { char *pkgprefix; /* if no arguments then set default prefix */ if (line[0] == '\0') { pkg_get(p->pkg, PKG_PREFIX, &pkgprefix); strlcpy(p->prefix, pkgprefix, sizeof(p->prefix)); } else strlcpy(p->prefix, line, sizeof(p->prefix)); pkg_get(p->pkg, PKG_PREFIX, &pkgprefix); if (pkgprefix == NULL || *pkgprefix == '\0') pkg_set(p->pkg, PKG_PREFIX, line); p->slash = p->prefix[strlen(p->prefix) -1] == '/' ? "" : "/"; exec_append(p->post_install_buf, "cd %s\n", p->prefix); pre_unexec_append(p->pre_deinstall_buf, "cd %s\n", p->prefix); post_unexec_append(p->post_deinstall_buf, "cd %s\n", p->prefix); free(a); return (EPKG_OK); }
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]; 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); 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); }
int pkg_script_run(struct pkg *pkg, pkg_script_t type) { struct pkg_script *script = NULL; pkg_script_t stype; struct sbuf *script_cmd = sbuf_new_auto(); size_t i; struct { const char *arg; const pkg_script_t b; const pkg_script_t a; } const map[] = { /* a implies b with argument arg */ {"PRE-INSTALL", PKG_SCRIPT_INSTALL, PKG_SCRIPT_PRE_INSTALL}, {"POST-INSTALL", PKG_SCRIPT_INSTALL, PKG_SCRIPT_POST_INSTALL}, {"PRE-UPGRADE", PKG_SCRIPT_UPGRADE, PKG_SCRIPT_PRE_UPGRADE}, {"POST-UPGRADE", PKG_SCRIPT_UPGRADE, PKG_SCRIPT_POST_UPGRADE}, {"DEINSTALL", PKG_SCRIPT_DEINSTALL, PKG_SCRIPT_PRE_DEINSTALL}, {"POST-DEINSTALL", PKG_SCRIPT_DEINSTALL, PKG_SCRIPT_POST_DEINSTALL}, }; for (i = 0; i < sizeof(map) / sizeof(map[0]); i++) { if (map[i].a == type) break; } if (map[i].a != type) return (ERROR_BAD_ARG("type")); while (pkg_scripts(pkg, &script) == EPKG_OK) { stype = pkg_script_type(script); if (stype == map[i].a || stype == map[i].b) { sbuf_reset(script_cmd); sbuf_printf(script_cmd, "PKG_PREFIX=%s\nset -- %s-%s", pkg_get(pkg, PKG_PREFIX), pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION)); if (stype == map[i].b) { /* add arg **/ sbuf_cat(script_cmd, " "); sbuf_cat(script_cmd, map[i].arg); } sbuf_cat(script_cmd, "\n"); sbuf_cat(script_cmd, pkg_script_data(script)); sbuf_finish(script_cmd); system(sbuf_data(script_cmd)); } } sbuf_delete(script_cmd); return (EPKG_OK); }
int pkg_delete(struct pkg *pkg, struct pkgdb *db, int force) { struct pkg **rdeps; int i, ret; struct sbuf *rdep_msg; if (pkg == NULL) return (ERROR_BAD_ARG("pkg")); if (db == NULL) return (ERROR_BAD_ARG("db")); /* * Ensure that we have all the informations we need */ if ((ret = pkgdb_loadrdeps(db, pkg)) != EPKG_OK) return (ret); if ((ret = pkgdb_loadfiles(db, pkg)) != EPKG_OK) return (ret); if ((ret = pkgdb_loadscripts(db, pkg)) != EPKG_OK) return (ret); if ((ret = pkgdb_loadmtree(db, pkg)) != EPKG_OK) return (ret); rdeps = pkg_rdeps(pkg); if (rdeps[0] != NULL) { rdep_msg = sbuf_new_auto(); sbuf_printf(rdep_msg, "%s-%s is required by other packages:", pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION)); for (i = 0;rdeps[i] != NULL; i++) { sbuf_cat(rdep_msg, " "); sbuf_printf(rdep_msg, "%s-%s", pkg_get(rdeps[i], PKG_NAME), pkg_get(rdeps[i], PKG_VERSION)); } if (!force) { sbuf_finish(rdep_msg); ret = pkg_error_set(EPKG_REQUIRED, "%s", sbuf_get(rdep_msg)); sbuf_free(rdep_msg); return ret; } sbuf_cat(rdep_msg, ", deleting anyway"); sbuf_finish(rdep_msg); fprintf(stderr, "%s\n", sbuf_get(rdep_msg)); sbuf_free(rdep_msg); } if ((ret = pkg_script_pre_deinstall(pkg)) != EPKG_OK) return (ret); if ((ret = pkg_delete_files(pkg, force)) != EPKG_OK) return (ret); if ((ret = pkg_script_post_deinstall(pkg)) != EPKG_OK) return (ret); return (pkgdb_unregister_pkg(db, pkg_get(pkg, PKG_ORIGIN))); }
static int pkg_create_matches(int argc, char **argv, match_t match, pkg_formats fmt, const char * const outdir, const char * const rootdir) { int i, ret = EPKG_OK, retcode = EPKG_OK; struct pkgdb *db = NULL; struct pkgdb_it *it = NULL; struct pkg *pkg = NULL; int query_flags = PKG_LOAD_DEPS | PKG_LOAD_CONFLICTS | PKG_LOAD_FILES | PKG_LOAD_CATEGORIES | PKG_LOAD_DIRS | PKG_LOAD_SCRIPTS | PKG_LOAD_OPTIONS | PKG_LOAD_MTREE | PKG_LOAD_LICENSES; if (pkgdb_open(&db, PKGDB_DEFAULT) != EPKG_OK) { pkgdb_close(db); return (EX_IOERR); } if (match != MATCH_ALL) { for (i = 0;i < argc; i++) { if ((it = pkgdb_query(db, argv[i], match)) == NULL) { goto cleanup; } while ((ret = pkgdb_it_next(it, &pkg, query_flags)) == EPKG_OK) { printf("Creating package for %s-%s\n", pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION)); if (pkg_create_installed(outdir, fmt, rootdir, pkg) != EPKG_OK) { retcode++; } } } } else { if ((it = pkgdb_query(db, NULL, match)) == NULL) { goto cleanup; } while ((ret = pkgdb_it_next(it, &pkg, query_flags)) == EPKG_OK) { printf("Creating package for %s-%s\n", pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION)); if (pkg_create_installed(outdir, fmt, rootdir, pkg) != EPKG_OK) { retcode++; } } } cleanup: if (ret != EPKG_END) { retcode++; } pkg_free(pkg); pkgdb_it_free(it); pkgdb_close(db); return (retcode); }
static int pkg_conflicts_chain_cmp_cb(struct pkg_conflict_chain *a, struct pkg_conflict_chain *b) { const char *vera, *verb; if (a->req->skip || b->req->skip) { return (a->req->skip - b->req->skip); } pkg_get(a->req->item->pkg, PKG_VERSION, &vera); pkg_get(b->req->item->pkg, PKG_VERSION, &verb); /* Inverse sort to get the maximum version as the first element */ return (pkg_version_cmp(vera, verb)); }
void pkg_emit_upgrade_finished(struct pkg *p) { struct pkg_event ev; bool syslog_enabled = false; char *name, *version, *newversion; ev.type = PKG_EVENT_UPGRADE_FINISHED; ev.e_upgrade_finished.pkg = p; pkg_config_bool(PKG_CONFIG_SYSLOG, &syslog_enabled); if (syslog_enabled) { const char *actions[] = { "upgraded", "reinstalled", "downgraded" }; int num_actions = sizeof(actions) / sizeof(*actions); int action; pkg_get(p, PKG_NAME, &name, PKG_VERSION, &version, PKG_NEWVERSION, &newversion); action = pkg_version_cmp(version, newversion) + 1; if (action >= 0 && action < num_actions) syslog(LOG_NOTICE, "%s %s: %s -> %s ", name, actions[action], version, newversion); } pkg_emit_event(&ev); }
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 kh_sum_t * populate_sums(struct pkgdb *db) { struct pkg *p = NULL; struct pkgdb_it *it = NULL; const char *sum; char *cksum; size_t slen; kh_sum_t *suml = NULL; khint_t k; int ret; suml = kh_init_sum(); it = pkgdb_repo_search(db, "*", MATCH_GLOB, FIELD_NAME, FIELD_NONE, NULL); while (pkgdb_it_next(it, &p, PKG_LOAD_BASIC) == EPKG_OK) { pkg_get(p, PKG_CKSUM, &sum); slen = MIN(strlen(sum), PKG_FILE_CKSUM_CHARS); cksum = strndup(sum, slen); k = kh_put_sum(suml, cksum, &ret); if (ret != 0) kh_value(suml, k) = cksum; } return (suml); }
/* 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); } }
static int check_deps(struct pkgdb *db, struct pkg *p, struct deps_head *dh, bool noinstall) { struct pkg_dep *dep = NULL; char *name, *version, *origin; int nbpkgs = 0; assert(db != NULL); assert(p != NULL); name = version = origin = NULL; pkg_get(p, PKG_NAME, &name, PKG_VERSION, &version, PKG_ORIGIN, &origin); while (pkg_deps(p, &dep) == EPKG_OK) { /* do we have a missing dependency? */ if (pkg_is_installed(db, pkg_dep_origin(dep)) != EPKG_OK) { if (noinstall) printf("%s\n", pkg_dep_origin(dep)); else printf("%s has a missing dependency: %s\n", origin, pkg_dep_origin(dep)); add_missing_dep(dep, dh, &nbpkgs); } } return (nbpkgs); }
static struct packing * pkg_create_archive(const char *outdir, struct pkg *pkg, pkg_formats format, unsigned required_flags) { char *pkg_path = NULL; struct packing *pkg_archive = NULL; const char *pkgname, *pkgversion; /* * Ensure that we have all the information we need */ if (pkg->type != PKG_OLD_FILE) assert((pkg->flags & required_flags) == required_flags); if (mkdirs(outdir) != EPKG_OK) return NULL; pkg_get(pkg, PKG_NAME, &pkgname, PKG_VERSION, &pkgversion); if (asprintf(&pkg_path, "%s/%s-%s", outdir, pkgname, pkgversion) == -1) { pkg_emit_errno("asprintf", ""); return (NULL); } if (packing_init(&pkg_archive, pkg_path, format) != EPKG_OK) pkg_archive = NULL; free(pkg_path); return pkg_archive; }
static int pkgs_providing_lib(struct pkgdb *db, const char *libname) { struct pkgdb_it *it = NULL; struct pkg *pkg = NULL; const char *name, *version; int ret = EPKG_OK; int count = 0; if ((it = pkgdb_query_shlib_provided(db, libname)) == NULL) { return (EPKG_FATAL); } while ((ret = pkgdb_it_next(it, &pkg, PKG_LOAD_BASIC)) == EPKG_OK) { if (count == 0) printf("%s is provided by the following packages:\n", libname); count++; pkg_get(pkg, PKG_NAME, &name, PKG_VERSION, &version); printf("%s-%s\n", name, version); } if (ret == EPKG_END) { if (count == 0) printf("No packages provide %s.\n", libname); ret = EPKG_OK; } pkg_free(pkg); pkgdb_it_free(it); return (ret); }
void pkg_delete_dir(struct pkg *pkg, struct pkg_dir *dir) { const char *path; const char *prefix_rel; size_t len; pkg_open_root_fd(pkg); path = pkg_dir_path(dir); /* remove the first / */ path++; pkg_get(pkg, PKG_PREFIX, &prefix_rel); prefix_rel++; len = strlen(prefix_rel); if ((strncmp(prefix_rel, path, len) == 0) && path[len] == '/') { pkg_add_dir_to_del(pkg, NULL, path); } else { if (pkg->dir_to_del_len + 1 > pkg->dir_to_del_cap) { pkg->dir_to_del_cap += 64; pkg->dir_to_del = reallocf(pkg->dir_to_del, pkg->dir_to_del_cap * sizeof(char *)); } pkg->dir_to_del[pkg->dir_to_del_len++] = strdup(path); } }
int pkgdb_loadfiles(struct pkgdb *db, struct pkg *pkg) { sqlite3_stmt *stmt; struct pkg_file *f; int ret; const char sql[] = "" "SELECT path, sha256 " "FROM files " "WHERE package_id = ?1 " "ORDER BY PATH ASC"; const char sqldir[] = "" "SELECT path " "FROM pkg_dirs " "WHERE origin = ?1 " "ORDER by path DESC"; if (pkg->type != PKG_INSTALLED) return (ERROR_BAD_ARG("pkg")); if (pkg->flags & PKG_LOAD_FILES) return (EPKG_OK); array_init(&pkg->files, 10); if (sqlite3_prepare_v2(db->sqlite, sql, -1, &stmt, NULL) != SQLITE_OK) return (ERROR_SQLITE(db->sqlite)); sqlite3_bind_int64(stmt, 1, pkg->rowid); while ((ret = sqlite3_step(stmt)) == SQLITE_ROW) { pkg_file_new(&f); strlcpy(f->path, sqlite3_column_text(stmt, 0), sizeof(f->path)); strlcpy(f->sha256, sqlite3_column_text(stmt, 1), sizeof(f->sha256)); array_append(&pkg->files, f); } sqlite3_finalize(stmt); if (ret != SQLITE_DONE) { array_reset(&pkg->files, &free); return (ERROR_SQLITE(db->sqlite)); } if (sqlite3_prepare_v2(db->sqlite, sqldir, -1, &stmt, NULL) != SQLITE_OK) return (ERROR_SQLITE(db->sqlite)); sqlite3_bind_text(stmt, 1, pkg_get(pkg, PKG_ORIGIN), -1, SQLITE_STATIC); while ((ret = sqlite3_step(stmt)) == SQLITE_ROW) { pkg_file_new(&f); strlcpy(f->path, sqlite3_column_text(stmt, 0), sizeof(f->path)); array_append(&pkg->files, f); } sqlite3_finalize(stmt); pkg->flags |= PKG_LOAD_FILES; return (EPKG_OK); }
int pkg_old_load_from_path(struct pkg *pkg, const char *path) { char *desc; char *www; char fpath[MAXPATHLEN]; regex_t preg; regmatch_t pmatch[2]; int i; size_t size; char myarch[BUFSIZ]; if (!is_dir(path)) return (EPKG_FATAL); snprintf(fpath, sizeof(fpath), "%s/+CONTENTS", path); if (ports_parse_plist(pkg, fpath, NULL) != EPKG_OK) return (EPKG_FATAL); snprintf(fpath, sizeof(fpath), "%s/+COMMENT", path); if (access(fpath, F_OK) == 0) pkg_set_from_file(pkg, PKG_COMMENT, fpath, true); snprintf(fpath, sizeof(fpath), "%s/+DESC", path); if (access(fpath, F_OK) == 0) pkg_set_from_file(pkg, PKG_DESC, fpath, false); snprintf(fpath, sizeof(fpath), "%s/+DISPLAY", path); if (access(fpath, F_OK) == 0) pkg_set_from_file(pkg, PKG_MESSAGE, fpath, false); snprintf(fpath, sizeof(fpath), "%s/+MTREE_DIRS", path); if (access(fpath, F_OK) == 0) pkg_set_from_file(pkg, PKG_MTREE, fpath, false); for (i = 0; scripts[i] != NULL; i++) { snprintf(fpath, sizeof(fpath), "%s/%s", path, scripts[i]); if (access(fpath, F_OK) == 0) pkg_addscript_file(pkg, fpath); } pkg_get_myarch(myarch, BUFSIZ); pkg_set(pkg, PKG_ARCH, myarch); pkg_set(pkg, PKG_MAINTAINER, "unknown"); pkg_get(pkg, PKG_DESC, &desc); regcomp(&preg, "^WWW:[[:space:]]*(.*)$", REG_EXTENDED|REG_ICASE|REG_NEWLINE); if (regexec(&preg, desc, 2, pmatch, 0) == 0) { size = pmatch[1].rm_eo - pmatch[1].rm_so; www = strndup(&desc[pmatch[1].rm_so], size); pkg_set(pkg, PKG_WWW, www); free(www); } else { pkg_set(pkg, PKG_WWW, "UNKNOWN"); } regfree(&preg); return (EPKG_OK); }
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); }
/* * Gets the PackageKit repository name for the (remote) package. * * Currently this is the pkgng repository name (not the ident as was previously * the case). * * This does not need to be freed (possibly, TODO: check). */ static const char * repo_of_remote_package(struct pkg *pkg) { const char *repo_name; assert(pkg != NULL); assert(pkg_type(pkg) == PKG_REMOTE); repo_name = NULL; pkg_get(pkg, PKG_REPONAME, &repo_name); return repo_name; }
static int pkg_conflicts_request_resolve_chain(struct pkg *req, struct pkg_conflict_chain *chain) { struct pkg_conflict_chain *elt, *selected = NULL; const char *name, *origin, *slash_pos; pkg_get(req, PKG_NAME, &name); /* * First of all prefer pure origins, where the last element of * an origin is pkg name */ LL_FOREACH(chain, elt) { pkg_get(elt->req->item->pkg, PKG_ORIGIN, &origin); slash_pos = strrchr(origin, '/'); if (slash_pos != NULL) { if (strcmp(slash_pos + 1, name) == 0) { selected = elt; break; } } }
static int setprefix(struct plist *p, char *line, struct file_attr *a) { char *pkgprefix; /* if no arguments then set default prefix */ if (line[0] == '\0') pkg_get(p->pkg, PKG_PREFIX, &p->prefix); else p->prefix = line; pkg_get(p->pkg, PKG_PREFIX, &pkgprefix); if (pkgprefix == NULL || *pkgprefix == '\0') pkg_set(p->pkg, PKG_PREFIX, line); p->slash = p->prefix[strlen(p->prefix) -1] == '/' ? "" : "/"; free(a); return (EPKG_OK); }
static void pkg_effective_rmdir(struct pkgdb *db, struct pkg *pkg) { char prefix_r[MAXPATHLEN]; const char *prefix; size_t i; pkg_get(pkg, PKG_PREFIX, &prefix); snprintf(prefix_r, sizeof(prefix_r), "%s/", prefix + 1); for (i = 0; i < pkg->dir_to_del_len; i++) rmdir_p(db, pkg, pkg->dir_to_del[i], prefix_r); }
static int setprefix(struct plist *p, char *line) { /* if no arguments then set default prefix */ if (line[0] == '\0') pkg_get(p->pkg, PKG_PREFIX, &p->prefix); else p->prefix = line; p->slash = p->prefix[strlen(p->prefix) -1] == '/' ? "" : "/"; 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); }
static void add_to_check(kh_pkgs_t *check, struct pkg *pkg) { const char *uid; int ret; khint_t k; pkg_get(pkg, PKG_UNIQUEID, &uid); k = kh_put_pkgs(check, uid, &ret); if (ret != 0) kh_value(check, k) = pkg; }
static void print_index(struct pkg *pkg, const char *portsdir) { const pkg_object *obj, *list; pkg_iter iter = NULL; pkg_printf("%n-%v|%S/%o|%p|%c|%S/%o/pkg-descr|%m|", pkg, pkg, portsdir, pkg, pkg, pkg, portsdir, pkg, pkg); pkg_get(pkg, PKG_CATEGORIES, &list); while ((obj = pkg_object_iterate(list, &iter))) pkg_printf("%Cn ", obj); printf("\n"); }
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); }
/* The "no concessions to old pkg_tools" variant: just get everything * from the manifest */ int pkg_create_from_manifest(const char *outdir, pkg_formats format, const char *rootdir, const char *manifest, bool old) { struct pkg *pkg = NULL; struct packing *pkg_archive = NULL; char arch[BUFSIZ]; int ret = ENOMEM; char *buf; struct pkg_manifest_key *keys = NULL; pkg_debug(1, "Creating package from stage directory: '%s'", rootdir); if(pkg_new(&pkg, old ? PKG_OLD_FILE : PKG_FILE) != EPKG_OK) { ret = EPKG_FATAL; goto cleanup; } pkg_manifest_keys_new(&keys); if ((ret = pkg_parse_manifest_file(pkg, manifest, keys)) != EPKG_OK) { ret = EPKG_FATAL; goto cleanup; } /* if no arch autodetermine it */ pkg_get(pkg, PKG_ARCH, &buf); if (buf == NULL) { pkg_get_myarch(arch, BUFSIZ); pkg_set(pkg, PKG_ARCH, arch); } /* Create the archive */ pkg_archive = pkg_create_archive(outdir, pkg, format, 0); if (pkg_archive == NULL) { ret = EPKG_FATAL; /* XXX do better */ goto cleanup; } pkg_create_from_dir(pkg, rootdir, pkg_archive); ret = EPKG_OK; cleanup: free(pkg); pkg_manifest_keys_free(keys); if (ret == EPKG_OK) ret = packing_finish(pkg_archive); return (ret); }