xbps-rindex: check for consistent shlibs
When adding packages to the index, xbps-rindex will check if the consistency of shlibs is broken by a package. If so, rindex will create a stage file and commit the packages there. Once the consistency is restored, rindex -a will commit the stage area back to the public repo and delete the stage file.
This commit is contained in:
Enno Boland
parent
897ac238c4
commit
4d1ee3b01d
@ -81,7 +81,7 @@ int sign_repo(struct xbps_handle *, const char *, const char *,
|
||||
int sign_pkgs(struct xbps_handle *, int, int, char **, const char *, bool);
|
||||
|
||||
/* From repoflush.c */
|
||||
bool repodata_flush(struct xbps_handle *, const char *,
|
||||
bool repodata_flush(struct xbps_handle *, const char *, const char *,
|
||||
xbps_dictionary_t, xbps_dictionary_t);
|
||||
|
||||
#endif /* !_XBPS_RINDEX_DEFS_H_ */
|
||||
|
||||
@ -54,16 +54,140 @@ set_build_date(const xbps_dictionary_t pkgd, time_t timestamp)
|
||||
return 0;
|
||||
}
|
||||
|
||||
static bool
|
||||
repodata_commit(struct xbps_handle *xhp, const char *repodir,
|
||||
xbps_dictionary_t idx, xbps_dictionary_t meta, xbps_dictionary_t stage) {
|
||||
xbps_object_iterator_t iter;
|
||||
xbps_object_t keysym;
|
||||
int rv;
|
||||
xbps_dictionary_t oldshlibs, usedshlibs;
|
||||
|
||||
if (xbps_dictionary_count(stage) == 0) {
|
||||
// Nothing to do.
|
||||
return true;
|
||||
}
|
||||
|
||||
/*
|
||||
* Find old shlibs-provides
|
||||
*/
|
||||
oldshlibs = xbps_dictionary_create();
|
||||
usedshlibs = xbps_dictionary_create();
|
||||
|
||||
iter = xbps_dictionary_iterator(stage);
|
||||
while ((keysym = xbps_object_iterator_next(iter))) {
|
||||
const char *pkgname = xbps_dictionary_keysym_cstring_nocopy(keysym);
|
||||
xbps_dictionary_t pkg = xbps_dictionary_get(idx, pkgname);
|
||||
xbps_array_t pkgshlibs;
|
||||
|
||||
pkgshlibs = xbps_dictionary_get(pkg, "shlib-provides");
|
||||
for (unsigned int i = 0; i < xbps_array_count(pkgshlibs); i++) {
|
||||
const char *shlib = NULL;
|
||||
xbps_array_get_cstring_nocopy(pkgshlibs, i, &shlib);
|
||||
xbps_dictionary_set_cstring(oldshlibs, shlib, pkgname);
|
||||
}
|
||||
}
|
||||
xbps_object_iterator_release(iter);
|
||||
|
||||
/*
|
||||
* throw away all unused shlibs
|
||||
*/
|
||||
iter = xbps_dictionary_iterator(idx);
|
||||
while ((keysym = xbps_object_iterator_next(iter))) {
|
||||
const char *pkgname = xbps_dictionary_keysym_cstring_nocopy(keysym);
|
||||
xbps_dictionary_t pkg = xbps_dictionary_get(stage, pkgname);
|
||||
xbps_array_t pkgshlibs;
|
||||
if (!pkg)
|
||||
pkg = xbps_dictionary_get_keysym(idx, keysym);
|
||||
pkgshlibs = xbps_dictionary_get(pkg, "shlib-requires");
|
||||
|
||||
for (unsigned int i = 0; i < xbps_array_count(pkgshlibs); i++) {
|
||||
const char *shlib = NULL;
|
||||
xbps_array_t users;
|
||||
xbps_array_get_cstring_nocopy(pkgshlibs, i, &shlib);
|
||||
if (!xbps_dictionary_get(oldshlibs, shlib))
|
||||
continue;
|
||||
users = xbps_dictionary_get(usedshlibs, shlib);
|
||||
if (!users) {
|
||||
users = xbps_array_create();
|
||||
xbps_dictionary_set(usedshlibs, shlib, users);
|
||||
}
|
||||
xbps_array_add_cstring(users, pkgname);
|
||||
}
|
||||
}
|
||||
xbps_object_iterator_release(iter);
|
||||
|
||||
/*
|
||||
* purge all packages that are fullfilled by the stage
|
||||
*/
|
||||
iter = xbps_dictionary_iterator(stage);
|
||||
while ((keysym = xbps_object_iterator_next(iter))) {
|
||||
xbps_dictionary_t pkg = xbps_dictionary_get_keysym(stage, keysym);
|
||||
xbps_array_t pkgshlibs;
|
||||
|
||||
pkgshlibs = xbps_dictionary_get(pkg, "shlib-provides");
|
||||
for (unsigned int i = 0; i < xbps_array_count(pkgshlibs); i++) {
|
||||
const char *shlib;
|
||||
xbps_array_get_cstring_nocopy(pkgshlibs, i, &shlib);
|
||||
xbps_dictionary_remove(usedshlibs, shlib);
|
||||
}
|
||||
}
|
||||
xbps_object_iterator_release(iter);
|
||||
|
||||
if (xbps_dictionary_count(usedshlibs) != 0) {
|
||||
puts("Inconsistent shlibs:");
|
||||
iter = xbps_dictionary_iterator(usedshlibs);
|
||||
while ((keysym = xbps_object_iterator_next(iter))) {
|
||||
const char *shlib = xbps_dictionary_keysym_cstring_nocopy(keysym),
|
||||
*provider = NULL, *pre;
|
||||
xbps_array_t users = xbps_dictionary_get(usedshlibs, shlib);
|
||||
xbps_dictionary_get_cstring_nocopy(oldshlibs, shlib, &provider);
|
||||
|
||||
printf(" %s (provided by: %s; used by: ", shlib, provider);
|
||||
pre = "";
|
||||
for (unsigned int i = 0; i < xbps_array_count(users); i++) {
|
||||
const char *user;
|
||||
xbps_array_get_cstring_nocopy(users, i, &user);
|
||||
xbps_dictionary_remove(usedshlibs, shlib);
|
||||
printf("%s%s",pre, user);
|
||||
pre = ", ";
|
||||
}
|
||||
puts(")");
|
||||
}
|
||||
puts("Packages are added to stage area.");
|
||||
xbps_object_iterator_release(iter);
|
||||
rv = repodata_flush(xhp, repodir, "stagedata", stage, NULL);
|
||||
}
|
||||
else {
|
||||
char *stagefile;
|
||||
iter = xbps_dictionary_iterator(stage);
|
||||
while ((keysym = xbps_object_iterator_next(iter))) {
|
||||
const char *pkgname = xbps_dictionary_keysym_cstring_nocopy(keysym);
|
||||
xbps_dictionary_t pkg = xbps_dictionary_get_keysym(stage, keysym);
|
||||
const char *pkgver, *arch;
|
||||
xbps_dictionary_get_cstring_nocopy(pkg, "pkgver", &pkgver);
|
||||
xbps_dictionary_get_cstring_nocopy(pkg, "architecture", &arch);
|
||||
printf("index: added `%s' (%s).\n", pkgver, arch);
|
||||
xbps_dictionary_set(idx, pkgname, pkg);
|
||||
}
|
||||
xbps_object_iterator_release(iter);
|
||||
stagefile = xbps_repo_path_with_name(xhp, repodir, "stagedata");
|
||||
unlink(stagefile);
|
||||
free(stagefile);
|
||||
rv = repodata_flush(xhp, repodir, "repodata", idx, meta);
|
||||
}
|
||||
xbps_object_release(usedshlibs);
|
||||
xbps_object_release(oldshlibs);
|
||||
return rv;
|
||||
}
|
||||
|
||||
int
|
||||
index_add(struct xbps_handle *xhp, int args, int argmax, char **argv, bool force)
|
||||
{
|
||||
xbps_dictionary_t idx, idxmeta, binpkgd, curpkgd;
|
||||
struct xbps_repo *repo = NULL;
|
||||
xbps_dictionary_t idx, idxmeta, idxstage, binpkgd, curpkgd;
|
||||
struct xbps_repo *repo = NULL, *stage = NULL;
|
||||
struct stat st;
|
||||
char *tmprepodir = NULL, *repodir = NULL, *rlockfname = NULL;
|
||||
int rv = 0, ret = 0, rlockfd = -1;
|
||||
bool flush = false;
|
||||
|
||||
assert(argv);
|
||||
/*
|
||||
@ -79,7 +203,7 @@ index_add(struct xbps_handle *xhp, int args, int argmax, char **argv, bool force
|
||||
rv = -1;
|
||||
goto out;
|
||||
}
|
||||
repo = xbps_repo_open(xhp, repodir);
|
||||
repo = xbps_repo_public_open(xhp, repodir);
|
||||
if (repo == NULL && errno != ENOENT) {
|
||||
fprintf(stderr, "xbps-rindex: cannot open/lock repository "
|
||||
"%s: %s\n", repodir, strerror(errno));
|
||||
@ -93,6 +217,19 @@ index_add(struct xbps_handle *xhp, int args, int argmax, char **argv, bool force
|
||||
idx = xbps_dictionary_create();
|
||||
idxmeta = NULL;
|
||||
}
|
||||
stage = xbps_repo_stage_open(xhp, repodir);
|
||||
if (stage == NULL && errno != ENOENT) {
|
||||
fprintf(stderr, "xbps-rindex: cannot open/lock stage repository "
|
||||
"%s: %s\n", repodir, strerror(errno));
|
||||
rv = -1;
|
||||
goto out;
|
||||
}
|
||||
if (stage) {
|
||||
idxstage = xbps_dictionary_copy_mutable(stage->idx);
|
||||
}
|
||||
else {
|
||||
idxstage = xbps_dictionary_create();
|
||||
}
|
||||
/*
|
||||
* Process all packages specified in argv.
|
||||
*/
|
||||
@ -126,6 +263,8 @@ index_add(struct xbps_handle *xhp, int args, int argmax, char **argv, bool force
|
||||
* than current registered package, update the index; otherwise
|
||||
* pass to the next one.
|
||||
*/
|
||||
curpkgd = xbps_dictionary_get(idxstage, pkgname);
|
||||
if (curpkgd == NULL)
|
||||
curpkgd = xbps_dictionary_get(idx, pkgname);
|
||||
if (curpkgd == NULL) {
|
||||
if (errno && errno != ENOENT) {
|
||||
@ -166,12 +305,6 @@ index_add(struct xbps_handle *xhp, int args, int argmax, char **argv, bool force
|
||||
free(pkgname);
|
||||
continue;
|
||||
}
|
||||
/*
|
||||
* Current package version is greater than
|
||||
* index version.
|
||||
*/
|
||||
printf("index: removed obsolete entry `%s' (%s).\n", opkgver, oarch);
|
||||
xbps_dictionary_remove(idx, pkgname);
|
||||
free(opkgver);
|
||||
free(oarch);
|
||||
}
|
||||
@ -218,16 +351,14 @@ index_add(struct xbps_handle *xhp, int args, int argmax, char **argv, bool force
|
||||
xbps_dictionary_remove(binpkgd, "packaged-with");
|
||||
|
||||
/*
|
||||
* Add new pkg dictionary into the index.
|
||||
* Add new pkg dictionary into the stage index
|
||||
*/
|
||||
if (!xbps_dictionary_set(idx, pkgname, binpkgd)) {
|
||||
if (!xbps_dictionary_set(idxstage, pkgname, binpkgd)) {
|
||||
free(pkgname);
|
||||
free(pkgver);
|
||||
rv = EINVAL;
|
||||
goto out;
|
||||
}
|
||||
flush = true;
|
||||
printf("index: added `%s' (%s).\n", pkgver, arch);
|
||||
xbps_object_release(binpkgd);
|
||||
free(pkgname);
|
||||
free(pkgver);
|
||||
@ -235,18 +366,18 @@ index_add(struct xbps_handle *xhp, int args, int argmax, char **argv, bool force
|
||||
/*
|
||||
* Generate repository data files.
|
||||
*/
|
||||
if (flush) {
|
||||
if (!repodata_flush(xhp, repodir, idx, idxmeta)) {
|
||||
if (!repodata_commit(xhp, repodir, idx, idxmeta, idxstage)) {
|
||||
fprintf(stderr, "%s: failed to write repodata: %s\n",
|
||||
_XBPS_RINDEX, strerror(errno));
|
||||
goto out;
|
||||
}
|
||||
}
|
||||
printf("index: %u packages registered.\n", xbps_dictionary_count(idx));
|
||||
|
||||
out:
|
||||
if (repo)
|
||||
xbps_repo_close(repo);
|
||||
if (stage)
|
||||
xbps_repo_close(stage);
|
||||
|
||||
xbps_repo_unlock(rlockfd, rlockfname);
|
||||
|
||||
|
||||
@ -134,7 +134,7 @@ index_clean(struct xbps_handle *xhp, const char *repodir)
|
||||
xbps_object_release(allkeys);
|
||||
|
||||
if (!xbps_dictionary_equals(dest, repo->idx)) {
|
||||
if (!repodata_flush(xhp, repodir, dest, repo->idxmeta)) {
|
||||
if (!repodata_flush(xhp, repodir, "repodata", dest, repo->idxmeta)) {
|
||||
rv = errno;
|
||||
fprintf(stderr, "failed to write repodata: %s\n",
|
||||
strerror(errno));
|
||||
|
||||
@ -39,7 +39,7 @@
|
||||
|
||||
bool
|
||||
repodata_flush(struct xbps_handle *xhp, const char *repodir,
|
||||
xbps_dictionary_t idx, xbps_dictionary_t meta)
|
||||
const char *reponame, xbps_dictionary_t idx, xbps_dictionary_t meta)
|
||||
{
|
||||
struct archive *ar;
|
||||
char *repofile, *tname, *buf;
|
||||
@ -47,7 +47,7 @@ repodata_flush(struct xbps_handle *xhp, const char *repodir,
|
||||
mode_t mask;
|
||||
|
||||
/* Create a tempfile for our repository archive */
|
||||
repofile = xbps_repo_path(xhp, repodir);
|
||||
repofile = xbps_repo_path_with_name(xhp, repodir, reponame);
|
||||
tname = xbps_xasprintf("%s.XXXXXXXXXX", repofile);
|
||||
mask = umask(S_IXUSR|S_IRWXG|S_IRWXO);
|
||||
if ((repofd = mkstemp(tname)) == -1)
|
||||
|
||||
@ -224,7 +224,7 @@ sign_repo(struct xbps_handle *xhp, const char *repodir,
|
||||
_XBPS_RINDEX, strerror(errno));
|
||||
goto out;
|
||||
}
|
||||
flush_failed = repodata_flush(xhp, repodir, repo->idx, meta);
|
||||
flush_failed = repodata_flush(xhp, repodir, "repodata", repo->idx, meta);
|
||||
xbps_repo_unlock(rlockfd, rlockfname);
|
||||
if (!flush_failed) {
|
||||
fprintf(stderr, "failed to write repodata: %s\n", strerror(errno));
|
||||
|
||||
@ -1499,6 +1499,26 @@ void xbps_repo_unlock(int lockfd, char *lockfname);
|
||||
*/
|
||||
struct xbps_repo *xbps_repo_open(struct xbps_handle *xhp, const char *url);
|
||||
|
||||
/**
|
||||
* Opens a staging repository and returns a xbps_repo object.
|
||||
*
|
||||
* @param[in] xhp Pointer to the xbps_handle struct.
|
||||
* @param[in] uri Repository URI to match.
|
||||
*
|
||||
* @return The matching repository object, NULL otherwise.
|
||||
*/
|
||||
struct xbps_repo *xbps_repo_stage_open(struct xbps_handle *xhp, const char *url);
|
||||
|
||||
/**
|
||||
* Opens a repository and returns a xbps_repo object.
|
||||
*
|
||||
* @param[in] xhp Pointer to the xbps_handle struct.
|
||||
* @param[in] uri Repository URI to match.
|
||||
*
|
||||
* @return The matching repository object, NULL otherwise.
|
||||
*/
|
||||
struct xbps_repo *xbps_repo_public_open(struct xbps_handle *xhp, const char *url);
|
||||
|
||||
/**
|
||||
* Closes a repository object and releases resources.
|
||||
*
|
||||
@ -1517,6 +1537,18 @@ void xbps_repo_close(struct xbps_repo *repo);
|
||||
*/
|
||||
char *xbps_repo_path(struct xbps_handle *xhp, const char *url);
|
||||
|
||||
/**
|
||||
*
|
||||
* Returns a heap-allocated string with the repository local path.
|
||||
*
|
||||
* @param[in] xhp The xbps_handle object.
|
||||
* @param[in] url The repository URL to match.
|
||||
* @param[in] name The repository name (stage or repodata)
|
||||
*
|
||||
* @return A heap allocated string that must be free(3)d when it's unneeded.
|
||||
*/
|
||||
char *xbps_repo_path_with_name(struct xbps_handle *xhp, const char *url, const char *name);
|
||||
|
||||
/**
|
||||
* Remotely fetch repository data and keep it in memory.
|
||||
*
|
||||
|
||||
163
lib/repo.c
163
lib/repo.c
@ -46,12 +46,19 @@
|
||||
*/
|
||||
char *
|
||||
xbps_repo_path(struct xbps_handle *xhp, const char *url)
|
||||
{
|
||||
return xbps_repo_path_with_name(xhp, url, "repodata");
|
||||
}
|
||||
|
||||
char *
|
||||
xbps_repo_path_with_name(struct xbps_handle *xhp, const char *url, const char *name)
|
||||
{
|
||||
assert(xhp);
|
||||
assert(url);
|
||||
assert(strcmp(name, "repodata") == 0 || strcmp(name, "stagedata") == 0);
|
||||
|
||||
return xbps_xasprintf("%s/%s-repodata",
|
||||
url, xhp->target_arch ? xhp->target_arch : xhp->native_arch);
|
||||
return xbps_xasprintf("%s/%s-%s",
|
||||
url, xhp->target_arch ? xhp->target_arch : xhp->native_arch, name);
|
||||
}
|
||||
|
||||
static xbps_dictionary_t
|
||||
@ -182,6 +189,72 @@ repo_open_remote(struct xbps_repo *repo)
|
||||
return rv;
|
||||
}
|
||||
|
||||
static struct xbps_repo *
|
||||
repo_open_with_type(struct xbps_handle *xhp, const char *url, const char *name)
|
||||
{
|
||||
struct xbps_repo *repo;
|
||||
const char *arch;
|
||||
char *repofile;
|
||||
|
||||
assert(xhp);
|
||||
assert(url);
|
||||
|
||||
if (xhp->target_arch)
|
||||
arch = xhp->target_arch;
|
||||
else
|
||||
arch = xhp->native_arch;
|
||||
|
||||
repo = calloc(1, sizeof(struct xbps_repo));
|
||||
assert(repo);
|
||||
repo->fd = -1;
|
||||
repo->xhp = xhp;
|
||||
repo->uri = url;
|
||||
|
||||
if (xbps_repository_is_remote(url)) {
|
||||
/* remote repository */
|
||||
char *rpath;
|
||||
|
||||
if ((rpath = xbps_get_remote_repo_string(url)) == NULL) {
|
||||
free(repo);
|
||||
return NULL;
|
||||
}
|
||||
repofile = xbps_xasprintf("%s/%s/%s-%s", xhp->metadir, rpath, arch, name);
|
||||
free(rpath);
|
||||
repo->is_remote = true;
|
||||
} else {
|
||||
/* local repository */
|
||||
repofile = xbps_repo_path_with_name(xhp, url, name);
|
||||
}
|
||||
/*
|
||||
* In memory repo sync.
|
||||
*/
|
||||
if (repo->is_remote && (xhp->flags & XBPS_FLAG_REPOS_MEMSYNC)) {
|
||||
if (repo_open_remote(repo))
|
||||
return repo;
|
||||
|
||||
goto out;
|
||||
}
|
||||
/*
|
||||
* Open the repository archive.
|
||||
*/
|
||||
repo->fd = open(repofile, O_RDONLY|O_CLOEXEC);
|
||||
if (repo->fd == -1) {
|
||||
int rv = errno;
|
||||
xbps_dbg_printf(xhp, "[repo] `%s' open %s %s\n",
|
||||
repofile, name, strerror(rv));
|
||||
goto out;
|
||||
}
|
||||
if (repo_open_local(repo, repofile)) {
|
||||
free(repofile);
|
||||
return repo;
|
||||
}
|
||||
|
||||
out:
|
||||
free(repofile);
|
||||
xbps_repo_close(repo);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
bool
|
||||
xbps_repo_store(struct xbps_handle *xhp, const char *repo)
|
||||
{
|
||||
@ -221,70 +294,46 @@ xbps_repo_store(struct xbps_handle *xhp, const char *repo)
|
||||
return false;
|
||||
}
|
||||
|
||||
struct xbps_repo *
|
||||
xbps_repo_stage_open(struct xbps_handle *xhp, const char *url)
|
||||
{
|
||||
return repo_open_with_type(xhp, url, "stagedata");
|
||||
}
|
||||
|
||||
struct xbps_repo *
|
||||
xbps_repo_public_open(struct xbps_handle *xhp, const char *url) {
|
||||
return repo_open_with_type(xhp, url, "repodata");
|
||||
}
|
||||
|
||||
struct xbps_repo *
|
||||
xbps_repo_open(struct xbps_handle *xhp, const char *url)
|
||||
{
|
||||
struct xbps_repo *repo;
|
||||
const char *arch;
|
||||
char *repofile;
|
||||
|
||||
assert(xhp);
|
||||
assert(url);
|
||||
|
||||
if (xhp->target_arch)
|
||||
arch = xhp->target_arch;
|
||||
else
|
||||
arch = xhp->native_arch;
|
||||
|
||||
repo = calloc(1, sizeof(struct xbps_repo));
|
||||
assert(repo);
|
||||
repo->fd = -1;
|
||||
repo->xhp = xhp;
|
||||
repo->uri = url;
|
||||
|
||||
if (xbps_repository_is_remote(url)) {
|
||||
/* remote repository */
|
||||
char *rpath;
|
||||
|
||||
if ((rpath = xbps_get_remote_repo_string(url)) == NULL) {
|
||||
free(repo);
|
||||
return NULL;
|
||||
}
|
||||
repofile = xbps_xasprintf("%s/%s/%s-repodata", xhp->metadir, rpath, arch);
|
||||
free(rpath);
|
||||
repo->is_remote = true;
|
||||
} else {
|
||||
/* local repository */
|
||||
repofile = xbps_repo_path(xhp, url);
|
||||
}
|
||||
struct xbps_repo *repo = xbps_repo_public_open(xhp, url);
|
||||
struct xbps_repo *stage = NULL;
|
||||
xbps_dictionary_t idx;
|
||||
const char *pkgname;
|
||||
xbps_object_t keysym;
|
||||
xbps_object_iterator_t iter;
|
||||
/*
|
||||
* In memory repo sync.
|
||||
* Load and merge staging repository if the repository is local.
|
||||
*/
|
||||
if (repo->is_remote && (xhp->flags & XBPS_FLAG_REPOS_MEMSYNC)) {
|
||||
if (repo_open_remote(repo))
|
||||
if (!repo->is_remote) {
|
||||
stage = xbps_repo_stage_open(xhp, url);
|
||||
if (stage == NULL)
|
||||
return repo;
|
||||
|
||||
goto out;
|
||||
idx = xbps_dictionary_copy_mutable(repo->idx);
|
||||
iter = xbps_dictionary_iterator(stage->idx);
|
||||
while ((keysym = xbps_object_iterator_next(iter))) {
|
||||
pkgname = xbps_dictionary_keysym_cstring_nocopy(keysym);
|
||||
xbps_dictionary_set(idx, pkgname,
|
||||
xbps_dictionary_get_keysym(stage->idx, keysym));
|
||||
}
|
||||
/*
|
||||
* Open the repository archive.
|
||||
*/
|
||||
repo->fd = open(repofile, O_RDONLY|O_CLOEXEC);
|
||||
if (repo->fd == -1) {
|
||||
int rv = errno;
|
||||
xbps_dbg_printf(xhp, "[repo] `%s' open repodata %s\n",
|
||||
repofile, strerror(rv));
|
||||
goto out;
|
||||
}
|
||||
if (repo_open_local(repo, repofile)) {
|
||||
free(repofile);
|
||||
xbps_object_iterator_release(iter);
|
||||
xbps_object_release(repo->idx);
|
||||
repo->idx = idx;
|
||||
return repo;
|
||||
}
|
||||
|
||||
out:
|
||||
free(repofile);
|
||||
xbps_repo_close(repo);
|
||||
return NULL;
|
||||
return repo;
|
||||
}
|
||||
|
||||
void
|
||||
|
||||
Loading…
Reference in New Issue
Block a user