int
pkgdb_repo_init(sqlite3 *sqlite)
{
int retcode = EPKG_OK;
retcode = sql_exec(sqlite, "PRAGMA synchronous=off");
if (retcode != EPKG_OK)
return (retcode);
retcode = sql_exec(sqlite, "PRAGMA journal_mode=memory");
if (retcode != EPKG_OK)
return (retcode);
retcode = sql_exec(sqlite, "PRAGMA foreign_keys=on");
if (retcode != EPKG_OK)
return (retcode);
retcode = initialize_prepared_statements(sqlite);
if (retcode != EPKG_OK)
return (retcode);
retcode = pkgdb_transaction_begin(sqlite, NULL);
if (retcode != EPKG_OK)
return (retcode);
return (EPKG_OK);
}
static int
pkg_repo_binary_update_incremental(const char *name, struct pkg_repo *repo,
time_t *mtime, bool force)
{
FILE *fmanifest = NULL, *fdigests = NULL /*, *fconflicts = NULL*/;
struct pkg *pkg = NULL;
int rc = EPKG_FATAL;
sqlite3 *sqlite = NULL;
sqlite3_stmt *stmt;
const char *origin, *digest, *offset, *length, *checksum;
char *linebuf = NULL, *p;
int updated = 0, removed = 0, added = 0, processed = 0, pushed = 0;
long num_offset, num_length;
time_t local_t;
time_t digest_t;
time_t packagesite_t;
struct pkg_increment_task_item *ldel = NULL, *ladd = NULL,
*item, *tmp_item;
struct pkg_manifest_key *keys = NULL;
size_t linecap = 0;
ssize_t linelen;
char *map = MAP_FAILED;
size_t len = 0;
int hash_it = 0;
bool in_trans = false, legacy_repo = false;
/* Required for making iterator */
struct pkgdb_it *it = NULL;
struct pkgdb fakedb;
pkg_debug(1, "Pkgrepo, begin incremental update of '%s'", name);
/* In forced mode, ignore mtime */
if (force)
*mtime = 0;
/* Fetch meta */
local_t = *mtime;
if (pkg_repo_fetch_meta(repo, &local_t) == EPKG_FATAL)
pkg_emit_notice("repository %s has no meta file, using "
"default settings", repo->name);
/* Fetch digests */
local_t = *mtime;
fdigests = pkg_repo_fetch_remote_extract_tmp(repo,
repo->meta->digests, &local_t, &rc);
if (fdigests == NULL)
goto cleanup;
/* Fetch packagesite */
digest_t = local_t;
local_t = *mtime;
fmanifest = pkg_repo_fetch_remote_extract_tmp(repo,
repo->meta->manifests, &local_t, &rc);
if (fmanifest == NULL)
goto cleanup;
packagesite_t = local_t;
*mtime = digest_t;
/*fconflicts = repo_fetch_remote_extract_tmp(repo,
repo_conflicts_archive, "txz", &local_t,
&rc, repo_conflicts_file);*/
fseek(fmanifest, 0, SEEK_END);
len = ftell(fmanifest);
/* Detect whether we have legacy repo */
if ((linelen = getline(&linebuf, &linecap, fdigests)) > 0) {
p = linebuf;
origin = strsep(&p, ":");
digest = strsep(&p, ":");
if (digest == NULL) {
pkg_emit_error("invalid digest file format");
rc = EPKG_FATAL;
goto cleanup;
}
if (!pkg_checksum_is_valid(digest, strlen(digest))) {
legacy_repo = true;
pkg_debug(1, "repository '%s' has a legacy digests format", repo->name);
}
}
fseek(fdigests, 0, SEEK_SET);
/* Load local repository data */
rc = pkg_repo_binary_init_update(repo, name, force);
if (rc == EPKG_END) {
/* Need to perform forced update */
repo->ops->close(repo, false);
return (pkg_repo_binary_update_incremental(name, repo, mtime, true));
}
if (rc != EPKG_OK) {
rc = EPKG_FATAL;
goto cleanup;
}
/* Here sqlite is initialized */
sqlite = PRIV_GET(repo);
stmt = pkg_repo_binary_get_origins(sqlite);
if (stmt == NULL) {
rc = EPKG_FATAL;
goto cleanup;
}
fakedb.sqlite = sqlite;
it = pkgdb_it_new_sqlite(&fakedb, stmt, PKG_REMOTE, PKGDB_IT_FLAG_ONCE);
if (it != NULL) {
while (pkgdb_it_next(it, &pkg, PKG_LOAD_BASIC) == EPKG_OK) {
pkg_get(pkg, PKG_ORIGIN, &origin, legacy_repo ? PKG_OLD_DIGEST : PKG_DIGEST,
&digest, PKG_CKSUM, &checksum);
pkg_repo_binary_update_item_new(&ldel, origin, digest, 0, 0, checksum);
}
pkgdb_it_free(it);
}
else {
sqlite3_finalize(stmt);
}
pkg_debug(1, "Pkgrepo, reading new packagesite.yaml for '%s'", name);
/* load the while digests */
while ((linelen = getline(&linebuf, &linecap, fdigests)) > 0) {
p = linebuf;
origin = strsep(&p, ":");
digest = strsep(&p, ":");
offset = strsep(&p, ":");
/* files offset */
strsep(&p, ":");
length = p ? strsep(&p, ":\n") : NULL;
checksum = p ? strsep(&p, ":\n") : NULL;
if (origin == NULL || digest == NULL ||
offset == NULL) {
pkg_emit_error("invalid digest file format");
rc = EPKG_FATAL;
goto cleanup;
}
errno = 0;
num_offset = (long)strtoul(offset, NULL, 10);
if (errno != 0) {
pkg_emit_errno("strtoul", "digest format error");
rc = EPKG_FATAL;
goto cleanup;
}
if (length != NULL) {
errno = 0;
num_length = (long)strtoul(length, NULL, 10);
if (errno != 0) {
pkg_emit_errno("strtoul", "digest format error");
rc = EPKG_FATAL;
goto cleanup;
}
}
else {
num_length = 0;
}
processed++;
HASH_FIND_STR(ldel, origin, item);
if (item == NULL) {
added++;
pkg_repo_binary_update_item_new(&ladd, origin, digest, num_offset,
num_length, checksum);
} else {
HASH_DEL(ldel, item);
if (checksum == NULL || item->checksum == NULL) {
pkg_repo_binary_update_item_new(&ladd, origin, digest,
num_offset, num_length, checksum);
updated++;
}
else if (strcmp(checksum, item->checksum) != 0) {
/* Allow checksum to be used as unique mark */
pkg_repo_binary_update_item_new(&ladd, origin, digest,
num_offset, num_length, checksum);
updated++;
}
pkg_repo_binary_update_item_free(item);
}
}
rc = EPKG_OK;
pkg_debug(1, "Pkgrepo, removing old entries for '%s'", name);
rc = pkgdb_transaction_begin(sqlite, "REPO");
if (rc != EPKG_OK)
goto cleanup;
in_trans = true;
removed = HASH_COUNT(ldel);
hash_it = 0;
if (removed > 0)
pkg_emit_progress_start("Removing expired repository entries");
HASH_ITER(hh, ldel, item, tmp_item) {
pkg_emit_progress_tick(++hash_it, removed);
if (rc == EPKG_OK) {
rc = pkgdb_repo_remove_package(item->origin);
}
else {
pkg_emit_progress_tick(removed, removed);
}
HASH_DEL(ldel, item);
pkg_repo_binary_update_item_free(item);
}
static int
apply_repo_change(struct pkgdb *db, const char *database,
const struct repo_changes *repo_changes, const char *updown,
int version, int *next_version)
{
const struct repo_changes *change;
bool found = false, in_trans = false;
int ret = EPKG_OK;
char sql[8192];
char *errmsg;
for (change = repo_changes; change->version != -1; change++) {
if (change->version == version) {
found = true;
break;
}
}
if (!found) {
pkg_emit_error("Failed to %s \"%s\" repo schema "
" version %d (target version %d) "
"-- change not found", updown, database, version,
REPO_SCHEMA_VERSION);
return (EPKG_FATAL);
}
/* substitute the repo database name */
ret = substitute_into_sql(sql, sizeof(sql), change->sql, database);
/* begin transaction */
if (ret == EPKG_OK) {
in_trans = true;
ret = pkgdb_transaction_begin(db->sqlite, "SCHEMA");
}
/* apply change */
if (ret == EPKG_OK) {
pkg_debug(4, "Pkgdb: running '%s'", sql);
ret = sqlite3_exec(db->sqlite, sql, NULL, NULL, &errmsg);
if (ret != SQLITE_OK) {
pkg_emit_error("sqlite: %s", errmsg);
sqlite3_free(errmsg);
ret = EPKG_FATAL;
}
}
/* update repo user_version */
if (ret == EPKG_OK) {
*next_version = change->next_version;
ret = set_repo_user_version(db->sqlite, database, *next_version);
}
/* commit or rollback */
if (in_trans) {
if (ret != EPKG_OK)
pkgdb_transaction_rollback(db->sqlite, "SCHEMA");
if (pkgdb_transaction_commit(db->sqlite, "SCHEMA") != EPKG_OK)
ret = EPKG_FATAL;
}
if (ret == EPKG_OK) {
pkg_emit_notice("Repo \"%s\" %s schema %d to %d: %s",
database, updown, version,
change->next_version, change->message);
}
return (ret);
}
int
exec_set(int argc, char **argv)
{
struct pkgdb *db = NULL;
struct pkgdb_it *it = NULL;
struct pkg *pkg = NULL;
int ch;
int i;
match_t match = MATCH_EXACT;
int64_t newautomatic = -1;
bool automatic = false;
bool rc = false;
const char *changed = NULL;
char *newvalue = NULL;
char *oldvalue = NULL;
unsigned int loads = PKG_LOAD_BASIC;
unsigned int sets = 0;
unsigned int field = 0, depfield = 0;
int retcode;
struct option longopts[] = {
{ "automatic", required_argument, NULL, 'A' },
{ "all", no_argument, NULL, 'a' },
{ "case-sensitive", no_argument, NULL, 'C' },
{ "glob", no_argument, NULL, 'g' },
{ "case-insensitive", no_argument, NULL, 'i' },
{ "change-origin", required_argument, NULL, 'o' },
{ "change-name", required_argument, NULL, 'n' },
{ "regex", no_argument, NULL, 'x' },
{ "yes", no_argument, NULL, 'y' },
{ NULL, 0, NULL, 0 },
};
while ((ch = getopt_long(argc, argv, "+A:aCgio:xyn:", longopts, NULL)) != -1) {
switch (ch) {
case 'A':
sets |= AUTOMATIC;
newautomatic = optarg[0] - '0';
if (newautomatic != 0 && newautomatic != 1)
errx(EX_USAGE, "Wrong value for -A. "
"Expecting 0 or 1, got: %s",
optarg);
break;
case 'a':
match = MATCH_ALL;
break;
case 'C':
pkgdb_set_case_sensitivity(true);
break;
case 'g':
match = MATCH_GLOB;
break;
case 'i':
pkgdb_set_case_sensitivity(false);
break;
case 'o':
sets |= ORIGIN;
loads |= PKG_LOAD_DEPS;
match = MATCH_ALL;
changed = "origin";
if (!check_change_values(optarg, &oldvalue, &newvalue, '/')) {
errx(EX_USAGE, "Wrong format for -o. "
"Expecting oldorigin:neworigin, got: %s",
optarg);
}
break;
case 'n':
sets |= NAME;
loads |= PKG_LOAD_DEPS;
match = MATCH_ALL;
changed = "name";
if (!check_change_values(optarg, &oldvalue, &newvalue, '\0')) {
errx(EX_USAGE, "Wrong format for -n. "
"Expecting oldname:newname, got: %s",
optarg);
}
break;
case 'x':
match = MATCH_REGEX;
break;
case 'y':
yes = true;
break;
default:
free(oldvalue);
usage_set();
return (EX_USAGE);
}
}
argc -= optind;
argv += optind;
if ((argc < 1 && match != MATCH_ALL) ||
(newautomatic == -1 && newvalue == NULL) ||
(sets & (NAME|ORIGIN)) == (NAME|ORIGIN)) {
usage_set();
return (EX_USAGE);
}
if (sets & NAME) {
field = PKG_SET_NAME;
depfield = PKG_SET_DEPNAME;
}
else if (sets & ORIGIN) {
field = PKG_SET_ORIGIN;
depfield = PKG_SET_DEPORIGIN;
}
retcode = pkgdb_access(PKGDB_MODE_READ|PKGDB_MODE_WRITE,
PKGDB_DB_LOCAL);
if (retcode == EPKG_ENODB) {
if (match == MATCH_ALL)
return (EX_OK);
if (!quiet)
warnx("No packages installed. Nothing to do!");
return (EX_OK);
} else if (retcode == EPKG_ENOACCESS) {
warnx("Insufficient privileges to modify the package database");
return (EX_NOPERM);
} else if (retcode != EPKG_OK) {
warnx("Error accessing package database");
return (EX_SOFTWARE);
}
if (pkgdb_open(&db, PKGDB_DEFAULT) != EPKG_OK) {
free(newvalue);
return (EX_IOERR);
}
if (pkgdb_obtain_lock(db, PKGDB_LOCK_EXCLUSIVE) != EPKG_OK) {
pkgdb_close(db);
free(newvalue);
warnx("Cannot get an exclusive lock on a database, it is locked by another process");
return (EX_TEMPFAIL);
}
if (pkgdb_transaction_begin(db, NULL) != EPKG_OK) {
pkgdb_close(db);
free(newvalue);
warnx("Cannot start transaction for update");
return (EX_TEMPFAIL);
}
if (oldvalue != NULL) {
match = MATCH_ALL;
if ((it = pkgdb_query(db, oldvalue, MATCH_EXACT)) == NULL) {
retcode = EX_IOERR;
goto cleanup;
}
if (pkgdb_it_next(it, &pkg, PKG_LOAD_BASIC) != EPKG_OK) {
pkg = NULL;
/* fprintf(stderr, "%s not installed\n", oldorigin);
free(oldorigin);
pkgdb_it_free(it);
pkgdb_close(db);
return (EX_SOFTWARE);*/
}
rc = yes;
if (!yes) {
if (pkg != NULL)
rc = query_yesno(false, "Change %S from %S to %S for %n-%v? ",
changed, oldvalue, newvalue, pkg, pkg);
else
rc = query_yesno(false, "Change %S from %S to %S for all dependencies? ",
changed, oldvalue, newvalue);
}
if (pkg != NULL && rc) {
if (pkgdb_set(db, pkg, field, newvalue) != EPKG_OK) {
retcode = EX_IOERR;
goto cleanup;
}
}
pkgdb_it_free(it);
}
i = 0;
do {
bool saved_rc = rc;
if ((it = pkgdb_query(db, argv[i], match)) == NULL) {
retcode = EX_IOERR;
goto cleanup;
}
while (pkgdb_it_next(it, &pkg, loads) == EPKG_OK) {
if ((sets & AUTOMATIC) == AUTOMATIC) {
pkg_get(pkg, PKG_AUTOMATIC, &automatic);
if (automatic == newautomatic)
continue;
if (!rc) {
if (newautomatic)
rc = query_yesno(false,
"Mark %n-%v as automatically installed? ",
pkg, pkg);
else
rc = query_yesno(false,
"Mark %n-%v as not automatically installed? ",
pkg, pkg);
}
if (rc)
pkgdb_set(db, pkg, PKG_SET_AUTOMATIC, (int)newautomatic);
rc = saved_rc;
}
if (sets & (ORIGIN|NAME)) {
struct pkg_dep *d = NULL;
while (pkg_deps(pkg, &d) == EPKG_OK) {
/*
* Do not query user when he has already
* been queried.
*/
if (pkgdb_set(db, pkg, depfield, oldvalue, newvalue) != EPKG_OK) {
retcode = EX_IOERR;
goto cleanup;
}
}
}
}
pkgdb_it_free(it);
i++;
} while (i < argc);
cleanup:
free(oldvalue);
free(newvalue);
pkg_free(pkg);
if (retcode == 0) {
pkgdb_transaction_commit(db, NULL);
}
else {
pkgdb_transaction_rollback(db, NULL);
}
pkgdb_release_lock(db, PKGDB_LOCK_EXCLUSIVE);
pkgdb_close(db);
return (retcode);
}
static int
initialize_repo(const char *repodb, bool force, sqlite3 **sqlite)
{
bool incremental = false;
bool db_not_open;
int reposcver;
int retcode = EPKG_OK;
const char initsql[] = ""
"CREATE TABLE packages ("
"id INTEGER PRIMARY KEY,"
"origin TEXT UNIQUE,"
"name TEXT NOT NULL,"
"version TEXT NOT NULL,"
"comment TEXT NOT NULL,"
"desc TEXT NOT NULL,"
"osversion TEXT,"
"arch TEXT NOT NULL,"
"maintainer TEXT NOT NULL,"
"www TEXT,"
"prefix TEXT NOT NULL,"
"pkgsize INTEGER NOT NULL,"
"flatsize INTEGER NOT NULL,"
"licenselogic INTEGER NOT NULL,"
"cksum TEXT NOT NULL,"
/* relative path to the package in the repository */
"path TEXT NOT NULL,"
"pkg_format_version INTEGER"
");"
"CREATE TABLE deps ("
"origin TEXT,"
"name TEXT,"
"version TEXT,"
"package_id INTEGER REFERENCES packages(id)"
" ON DELETE CASCADE ON UPDATE CASCADE,"
"UNIQUE(package_id, origin)"
");"
"CREATE TABLE categories ("
"id INTEGER PRIMARY KEY, "
"name TEXT NOT NULL UNIQUE "
");"
"CREATE TABLE pkg_categories ("
"package_id INTEGER REFERENCES packages(id)"
" ON DELETE CASCADE ON UPDATE CASCADE,"
"category_id INTEGER REFERENCES categories(id)"
" ON DELETE RESTRICT ON UPDATE RESTRICT,"
"UNIQUE(package_id, category_id)"
");"
"CREATE TABLE licenses ("
"id INTEGER PRIMARY KEY,"
"name TEXT NOT NULL UNIQUE"
");"
"CREATE TABLE pkg_licenses ("
"package_id INTEGER REFERENCES packages(id)"
" ON DELETE CASCADE ON UPDATE CASCADE,"
"license_id INTEGER REFERENCES licenses(id)"
" ON DELETE RESTRICT ON UPDATE RESTRICT,"
"UNIQUE(package_id, license_id)"
");"
"CREATE TABLE options ("
"package_id INTEGER REFERENCES packages(id)"
" ON DELETE CASCADE ON UPDATE CASCADE,"
"option TEXT,"
"value TEXT,"
"UNIQUE (package_id, option)"
");"
"CREATE TABLE shlibs ("
"id INTEGER PRIMARY KEY,"
"name TEXT NOT NULL UNIQUE "
");"
"CREATE TABLE pkg_shlibs ("
"package_id INTEGER REFERENCES packages(id)"
" ON DELETE CASCADE ON UPDATE CASCADE,"
"shlib_id INTEGER REFERENCES shlibs(id)"
" ON DELETE RESTRICT ON UPDATE RESTRICT,"
"UNIQUE(package_id, shlib_id)"
");"
"PRAGMA user_version=%d;"
;
if (access(repodb, F_OK) == 0)
incremental = true;
sqlite3_initialize();
db_not_open = true;
while (db_not_open) {
if (sqlite3_open(repodb, sqlite) != SQLITE_OK) {
sqlite3_shutdown();
return (EPKG_FATAL);
}
db_not_open = false;
/* If the schema is too old, or we're forcing a full
update, then we cannot do an incremental update.
Delete the existing repo, and promote this to a
full update */
if (!incremental)
continue;
retcode = get_repo_user_version(*sqlite, "main", &reposcver);
if (retcode != EPKG_OK)
return (EPKG_FATAL);
if (force || reposcver != REPO_SCHEMA_VERSION) {
if (reposcver != REPO_SCHEMA_VERSION)
pkg_emit_error("updating repo schema version "
"from %d to %d", reposcver,
REPO_SCHEMA_VERSION);
sqlite3_close(*sqlite);
unlink(repodb);
incremental = false;
db_not_open = true;
}
}
sqlite3_create_function(*sqlite, "file_exists", 2, SQLITE_ANY, NULL,
file_exists, NULL, NULL);
retcode = sql_exec(*sqlite, "PRAGMA synchronous=off");
if (retcode != EPKG_OK)
return (retcode);
retcode = sql_exec(*sqlite, "PRAGMA journal_mode=memory");
if (retcode != EPKG_OK)
return (retcode);
retcode = sql_exec(*sqlite, "PRAGMA foreign_keys=on");
if (retcode != EPKG_OK)
return (retcode);
if (!incremental) {
retcode = sql_exec(*sqlite, initsql, REPO_SCHEMA_VERSION);
if (retcode != EPKG_OK)
return (retcode);
}
retcode = pkgdb_transaction_begin(*sqlite, NULL);
if (retcode != EPKG_OK)
return (retcode);
/* remove anything that is no longer in the repository. */
if (incremental) {
const char *obsolete[] = {
"packages WHERE NOT FILE_EXISTS(path, cksum)",
"categories WHERE id NOT IN "
"(SELECT category_id FROM pkg_categories)",
"licenses WHERE id NOT IN "
"(SELECT license_id FROM pkg_licenses)",
"shlibs WHERE id NOT IN "
"(SELECT shlib_id FROM pkg_shlibs)"
};
size_t num_objs = sizeof(obsolete) / sizeof(*obsolete);
for (size_t obj = 0; obj < num_objs; obj++)
sql_exec(*sqlite, "DELETE FROM %s;", obsolete[obj]);
}
return (EPKG_OK);
}
static int
pkg_repo_update_incremental(const char *name, struct pkg_repo *repo, time_t *mtime)
{
FILE *fmanifest = NULL, *fdigests = NULL /*, *fconflicts = NULL*/;
sqlite3 *sqlite = NULL;
struct pkg *pkg = NULL;
int rc = EPKG_FATAL;
const char *origin, *digest, *offset, *length;
struct pkgdb_it *it = NULL;
char *linebuf = NULL, *p;
int updated = 0, removed = 0, added = 0, processed = 0, pushed = 0;
long num_offset, num_length;
time_t local_t = *mtime;
time_t digest_t;
time_t packagesite_t;
struct pkg_increment_task_item *ldel = NULL, *ladd = NULL,
*item, *tmp_item;
struct pkg_manifest_key *keys = NULL;
size_t linecap = 0;
ssize_t linelen;
char *map = MAP_FAILED;
size_t len = 0;
int hash_it = 0;
bool in_trans = false, new_repo = true, legacy_repo = false, reuse_repo;
if (access(name, R_OK) != -1)
new_repo = false;
pkg_debug(1, "Pkgrepo, begin incremental update of '%s'", name);
if ((rc = pkgdb_repo_open(name, false, &sqlite, &reuse_repo)) != EPKG_OK) {
return (EPKG_FATAL);
}
if (!reuse_repo) {
pkg_debug(1, "Pkgrepo, need to re-create database '%s'", name);
local_t = 0;
*mtime = 0;
}
if ((rc = pkgdb_repo_init(sqlite)) != EPKG_OK) {
goto cleanup;
}
if ((rc = pkg_repo_register(repo, sqlite)) != EPKG_OK)
goto cleanup;
it = pkgdb_repo_origins(sqlite);
if (it == NULL) {
rc = EPKG_FATAL;
goto cleanup;
}
if (pkg_repo_fetch_meta(repo, NULL) == EPKG_FATAL)
pkg_emit_notice("repository %s has no meta file, using "
"default settings", repo->name);
fdigests = pkg_repo_fetch_remote_extract_tmp(repo,
repo->meta->digests, &local_t, &rc);
if (fdigests == NULL) {
if (rc == EPKG_FATAL)
/* Destroy repo completely */
if (new_repo)
unlink(name);
goto cleanup;
}
digest_t = local_t;
local_t = *mtime;
fmanifest = pkg_repo_fetch_remote_extract_tmp(repo,
repo->meta->manifests, &local_t, &rc);
if (fmanifest == NULL) {
if (rc == EPKG_FATAL)
/* Destroy repo completely */
if (new_repo)
unlink(name);
goto cleanup;
}
packagesite_t = digest_t;
*mtime = packagesite_t > digest_t ? packagesite_t : digest_t;
/*fconflicts = repo_fetch_remote_extract_tmp(repo,
repo_conflicts_archive, "txz", &local_t,
&rc, repo_conflicts_file);*/
fseek(fmanifest, 0, SEEK_END);
len = ftell(fmanifest);
/* Detect whether we have legacy repo */
if ((linelen = getline(&linebuf, &linecap, fdigests)) > 0) {
p = linebuf;
origin = strsep(&p, ":");
digest = strsep(&p, ":");
if (digest == NULL) {
pkg_emit_error("invalid digest file format");
rc = EPKG_FATAL;
goto cleanup;
}
if (!pkg_checksum_is_valid(digest, strlen(digest))) {
legacy_repo = true;
pkg_debug(1, "repository '%s' has a legacy digests format", repo->name);
}
}
fseek(fdigests, 0, SEEK_SET);
/* Load local repo data */
while (pkgdb_it_next(it, &pkg, PKG_LOAD_BASIC) == EPKG_OK) {
pkg_get(pkg, PKG_ORIGIN, &origin, legacy_repo ? PKG_OLD_DIGEST : PKG_DIGEST,
&digest);
pkg_repo_update_increment_item_new(&ldel, origin, digest, 4, 0);
}
pkg_debug(1, "Pkgrepo, reading new packagesite.yaml for '%s'", name);
/* load the while digests */
while ((linelen = getline(&linebuf, &linecap, fdigests)) > 0) {
p = linebuf;
origin = strsep(&p, ":");
digest = strsep(&p, ":");
offset = strsep(&p, ":");
/* files offset */
strsep(&p, ":");
length = strsep(&p, ":");
if (origin == NULL || digest == NULL ||
offset == NULL) {
pkg_emit_error("invalid digest file format");
rc = EPKG_FATAL;
goto cleanup;
}
errno = 0;
num_offset = (long)strtoul(offset, NULL, 10);
if (errno != 0) {
pkg_emit_errno("strtoul", "digest format error");
rc = EPKG_FATAL;
goto cleanup;
}
if (length != NULL) {
errno = 0;
num_length = (long)strtoul(length, NULL, 10);
if (errno != 0) {
pkg_emit_errno("strtoul", "digest format error");
rc = EPKG_FATAL;
goto cleanup;
}
}
else {
num_length = 0;
}
processed++;
HASH_FIND_STR(ldel, origin, item);
if (item == NULL) {
added++;
pkg_repo_update_increment_item_new(&ladd, origin, digest, num_offset,
num_length);
} else {
if (strcmp(digest, item->digest) == 0) {
free(item->origin);
free(item->digest);
HASH_DEL(ldel, item);
free(item);
item = NULL;
} else {
free(item->origin);
free(item->digest);
HASH_DEL(ldel, item);
free(item);
item = NULL;
pkg_repo_update_increment_item_new(&ladd, origin, digest,
num_offset, num_length);
updated++;
}
}
}
rc = EPKG_OK;
pkg_debug(1, "Pkgrepo, removing old entries for '%s'", name);
sql_exec(sqlite, "CREATE TABLE IF NOT EXISTS repo_update (x INTEGER);");
in_trans = true;
rc = pkgdb_transaction_begin(sqlite, "REPO");
if (rc != EPKG_OK)
goto cleanup;
removed = HASH_COUNT(ldel);
hash_it = 0;
pkg_emit_progress_start("Removing expired entries");
HASH_ITER(hh, ldel, item, tmp_item) {
pkg_emit_progress_tick(++hash_it, removed);
if (rc == EPKG_OK) {
rc = pkgdb_repo_remove_package(item->origin);
}
free(item->origin);
free(item->digest);
HASH_DEL(ldel, item);
free(item);
}
