/* dump out all information */
retvalue files_printmd5sums(void) {
retvalue result, r;
struct cursor *cursor;
const char *filekey, *checksum;
r = table_newglobalcursor(rdb_checksums, &cursor);
if (!RET_IS_OK(r))
return r;
result = RET_NOTHING;
while (cursor_nexttemp(rdb_checksums, cursor, &filekey, &checksum)) {
result = RET_OK;
(void)fputs(filekey, stdout);
(void)putchar(' ');
while (*checksum == ':') {
while (*checksum != ' ' && *checksum != '\0')
checksum++;
if (*checksum == ' ')
checksum++;
}
(void)fputs(checksum, stdout);
(void)putchar('\n');
}
r = cursor_close(rdb_checksums, cursor);
RET_ENDUPDATE(result, r);
return result;
}
/* remove all references from a given identifier */
retvalue references_remove(const char *neededby) {
struct cursor *cursor;
retvalue result, r;
const char *found_to, *found_by;
size_t datalen, l;
r = table_newglobalcursor(rdb_references, &cursor);
if (!RET_IS_OK(r))
return r;
l = strlen(neededby);
result = RET_NOTHING;
while (cursor_nexttempdata(rdb_references, cursor,
&found_to, &found_by, &datalen)) {
if (datalen >= l && strncmp(found_by, neededby, l) == 0 &&
(found_by[l] == '\0' || found_by[l] == ' ')) {
if (verbose > 8)
fprintf(stderr,
"Removing reference to '%s' by '%s'\n",
found_to, neededby);
r = cursor_delete(rdb_references, cursor,
found_to, NULL);
RET_UPDATE(result, r);
if (RET_IS_OK(r)) {
r = pool_dereferenced(found_to);
RET_ENDUPDATE(result, r);
}
}
}
r = cursor_close(rdb_references, cursor);
RET_ENDUPDATE(result, r);
return result;
}
/* dump all references to stdout */
retvalue references_dump(void) {
struct cursor *cursor;
retvalue result, r;
const char *found_to, *found_by;
r = table_newglobalcursor(rdb_references, &cursor);
if (!RET_IS_OK(r))
return r;
result = RET_OK;
while (cursor_nexttemp(rdb_references, cursor,
&found_to, &found_by)) {
if (fputs(found_by, stdout) == EOF ||
putchar(' ') == EOF ||
puts(found_to) == EOF) {
result = RET_ERROR;
break;
}
result = RET_OK;
if (interrupted()) {
result = RET_ERROR_INTERRUPTED;
break;
}
}
r = cursor_close(rdb_references, cursor);
RET_ENDUPDATE(result, r);
return result;
}
retvalue tracking_printall(trackingdb t) {
struct cursor *cursor;
retvalue result, r;
struct trackedpackage *pkg;
const char *key, *value, *data;
size_t datalen;
r = table_newglobalcursor(t->table, &cursor);
if (!RET_IS_OK(r))
return r;
result = RET_NOTHING;
while (cursor_nextpair(t->table, cursor,
&key, &value, &data, &datalen)) {
r = parse_data(key, value, data, datalen, &pkg);
if (RET_IS_OK(r)) {
print(t->codename, pkg);
trackedpackage_free(pkg);
}
RET_UPDATE(result, r);
}
r = cursor_close(t->table, cursor);
RET_ENDUPDATE(result, r);
return result;
}
retvalue tracking_tidyall(trackingdb t) {
struct cursor *cursor;
retvalue result, r;
struct trackedpackage *pkg;
const char *key, *value, *data;
size_t datalen;
r = table_newglobalcursor(t->table, &cursor);
if (!RET_IS_OK(r))
return r;
result = RET_NOTHING;
while (cursor_nextpair(t->table, cursor,
&key, &value, &data, &datalen)) {
r = parse_data(key, value, data, datalen, &pkg);
if (RET_WAS_ERROR(r)) {
result = r;
break;
}
r = trackedpackage_tidy(t, pkg);
RET_UPDATE(result, r);
r = tracking_saveatcursor(t, cursor, pkg);
RET_UPDATE(result, r);
trackedpackage_free(pkg);
}
r = cursor_close(t->table, cursor);
RET_UPDATE(result, r);
return result;
}
retvalue files_collectnewchecksums(void) {
retvalue result, r;
struct cursor *cursor;
const char *filekey, *all;
size_t alllen;
struct checksums *expected;
char *fullfilename;
result = RET_NOTHING;
r = table_newglobalcursor(rdb_checksums, &cursor);
if (!RET_IS_OK(r))
return r;
while (cursor_nexttempdata(rdb_checksums, cursor,
&filekey, &all, &alllen)) {
r = checksums_setall(&expected, all, alllen);
if (!RET_IS_OK(r)) {
RET_UPDATE(result, r);
continue;
}
if (checksums_iscomplete(expected)) {
checksums_free(expected);
continue;
}
fullfilename = files_calcfullfilename(filekey);
if (FAILEDTOALLOC(fullfilename)) {
result = RET_ERROR_OOM;
checksums_free(expected);
break;
}
r = checksums_complete(&expected, fullfilename);
if (r == RET_NOTHING) {
fprintf(stderr, "Missing file '%s'!\n", fullfilename);
r = RET_ERROR_MISSING;
}
if (r == RET_ERROR_WRONG_MD5) {
fprintf(stderr,
"ERROR: Cannot collect missing checksums for '%s'\n"
"as the file in the pool does not match the already recorded checksums\n",
filekey);
}
free(fullfilename);
if (RET_IS_OK(r))
r = files_replace_checksums(filekey, expected);
checksums_free(expected);
RET_UPDATE(result, r);
}
r = cursor_close(rdb_checksums, cursor);
RET_ENDUPDATE(result, r);
return result;
}
retvalue files_checkpool(bool fast) {
retvalue result, r;
struct cursor *cursor;
const char *filekey, *combined;
size_t combinedlen;
struct checksums *expected;
char *fullfilename;
bool improveable = false;
result = RET_NOTHING;
r = table_newglobalcursor(rdb_checksums, &cursor);
if (!RET_IS_OK(r))
return r;
while (cursor_nexttempdata(rdb_checksums, cursor,
&filekey, &combined, &combinedlen)) {
r = checksums_setall(&expected, combined, combinedlen);
if (RET_WAS_ERROR(r)) {
RET_UPDATE(result, r);
continue;
}
fullfilename = files_calcfullfilename(filekey);
if (FAILEDTOALLOC(fullfilename)) {
result = RET_ERROR_OOM;
checksums_free(expected);
break;
}
if (fast)
r = checksums_cheaptest(fullfilename, expected, true);
else
r = checkpoolfile(fullfilename, expected, &improveable);
if (r == RET_NOTHING) {
fprintf(stderr, "Missing file '%s'!\n", fullfilename);
r = RET_ERROR_MISSING;
}
free(fullfilename);
checksums_free(expected);
RET_UPDATE(result, r);
}
r = cursor_close(rdb_checksums, cursor);
RET_ENDUPDATE(result, r);
if (improveable && verbose >= 0)
printf(
"There were files with only some of the checksums this version of reprepro\n"
"can compute recorded. To add those run reprepro collectnewchecksums.\n");
return result;
}
static retvalue tracking_recreatereferences(trackingdb t) {
struct cursor *cursor;
retvalue result, r;
struct trackedpackage *pkg;
char *id;
int i;
const char *key, *value, *data;
size_t datalen;
r = table_newglobalcursor(t->table, &cursor);
if (!RET_IS_OK(r))
return r;
result = RET_NOTHING;
while (cursor_nextpair(t->table, cursor,
&key, &value, &data, &datalen)) {
r = parse_data(key, value, data, datalen, &pkg);
if (RET_WAS_ERROR(r)) {
(void)cursor_close(t->table, cursor);
return r;
}
id = calc_trackreferee(t->codename, pkg->sourcename,
pkg->sourceversion);
if (FAILEDTOALLOC(id)) {
trackedpackage_free(pkg);
(void)cursor_close(t->table, cursor);
return RET_ERROR_OOM;
}
for (i = 0 ; i < pkg->filekeys.count ; i++) {
const char *filekey = pkg->filekeys.values[i];
r = references_increment(filekey, id);
RET_UPDATE(result, r);
}
free(id);
trackedpackage_free(pkg);
}
r = cursor_close(t->table, cursor);
RET_UPDATE(result, r);
return result;
}
/* callback for each registered file */
retvalue files_foreach(per_file_action action, void *privdata) {
retvalue result, r;
struct cursor *cursor;
const char *filekey, *checksum;
r = table_newglobalcursor(rdb_checksums, &cursor);
if (!RET_IS_OK(r))
return r;
result = RET_NOTHING;
while (cursor_nexttemp(rdb_checksums, cursor, &filekey, &checksum)) {
if (interrupted()) {
RET_UPDATE(result, RET_ERROR_INTERRUPTED);
break;
}
r = action(privdata, filekey);
RET_UPDATE(result, r);
}
r = cursor_close(rdb_checksums, cursor);
RET_ENDUPDATE(result, r);
return result;
}
retvalue tracking_reset(trackingdb t) {
struct cursor *cursor;
retvalue result, r;
struct trackedpackage *pkg;
const char *key, *value, *data;
char *newdata;
size_t datalen, newdatalen;
int i;
r = table_newglobalcursor(t->table, &cursor);
if (!RET_IS_OK(r))
return r;
result = RET_NOTHING;
while (cursor_nextpair(t->table, cursor,
&key, &value, &data, &datalen)) {
// this would perhaps be more stable if it just replaced
// everything within the string just received...
result = parse_data(key, value, data, datalen, &pkg);
if (RET_WAS_ERROR(result))
break;
for (i = 0 ; i < pkg->filekeys.count ; i++) {
pkg->refcounts[i] = 0;
}
result = gen_data(pkg, &newdata, &newdatalen);
trackedpackage_free(pkg);
if (RET_IS_OK(result))
result = cursor_replace(t->table, cursor,
newdata, newdatalen);
free(newdata);
if (RET_WAS_ERROR(result))
break;
}
r = cursor_close(t->table, cursor);
RET_UPDATE(result, r);
return result;
}
retvalue files_printchecksums(void) {
retvalue result, r;
struct cursor *cursor;
const char *filekey, *checksum;
r = table_newglobalcursor(rdb_checksums, &cursor);
if (!RET_IS_OK(r))
return r;
result = RET_NOTHING;
while (cursor_nexttemp(rdb_checksums, cursor, &filekey, &checksum)) {
result = RET_OK;
(void)fputs(filekey, stdout);
(void)putchar(' ');
(void)fputs(checksum, stdout);
(void)putchar('\n');
if (interrupted()) {
result = RET_ERROR_INTERRUPTED;
break;
}
}
r = cursor_close(rdb_checksums, cursor);
RET_ENDUPDATE(result, r);
return result;
}
retvalue tracking_foreach_ro(struct distribution *d, tracking_foreach_ro_action *action) {
trackingdb t;
struct cursor *cursor;
retvalue result, r;
struct trackedpackage *pkg;
const char *key, *value, *data;
size_t datalen;
r = tracking_initialize(&t, d, true);
if (!RET_IS_OK(r))
return r;
r = table_newglobalcursor(t->table, &cursor);
if (!RET_IS_OK(r)) {
(void)tracking_done(t);
return r;
}
result = RET_NOTHING;
while (cursor_nextpair(t->table, cursor,
&key, &value, &data, &datalen)) {
r = parse_data(key, value, data, datalen, &pkg);
if (RET_IS_OK(r)) {
r = action(d, pkg);
trackedpackage_free(pkg);
}
RET_UPDATE(result, r);
if (RET_WAS_ERROR(r))
break;
}
r = cursor_close(t->table, cursor);
RET_ENDUPDATE(result, r);
r = tracking_done(t);
RET_ENDUPDATE(result, r);
return result;
}
