static retvalue addpackages(struct target *target, const char *packagename, const char *controlchunk, /*@null@*/const char *oldcontrolchunk, const char *version, /*@null@*/const char *oldversion, const struct strlist *files, /*@only@*//*@null@*/struct strlist *oldfiles, /*@null@*/struct logger *logger, /*@null@*/struct trackingdata *trackingdata, architecture_t architecture, /*@null@*/const char *oldsource, /*@null@*/const char *oldsversion, /*@null@*/const char *causingrule, /*@null@*/const char *suitefrom) {
retvalue result, r;
struct table *table = target->packages;
enum filetype filetype;
assert (atom_defined(architecture));
if (architecture == architecture_source)
filetype = ft_SOURCE;
else if (architecture == architecture_all)
filetype = ft_ALL_BINARY;
else
filetype = ft_ARCH_BINARY;
/* mark it as needed by this distribution */
r = references_insert(target->identifier, files, oldfiles);
if (RET_WAS_ERROR(r)) {
if (oldfiles != NULL)
strlist_done(oldfiles);
return r;
}
/* Add package to the distribution's database */
if (oldcontrolchunk != NULL) {
result = table_replacerecord(table, packagename, controlchunk);
} else {
result = table_adduniqrecord(table, packagename, controlchunk);
}
if (RET_WAS_ERROR(result)) {
if (oldfiles != NULL)
strlist_done(oldfiles);
return result;
}
if (logger != NULL)
logger_log(logger, target, packagename,
version, oldversion,
controlchunk, oldcontrolchunk,
files, oldfiles, causingrule, suitefrom);
r = trackingdata_insert(trackingdata, filetype, files,
oldsource, oldsversion, oldfiles);
RET_UPDATE(result, r);
/* remove old references to files */
if (oldfiles != NULL) {
r = references_delete(target->identifier, oldfiles, files);
RET_UPDATE(result, r);
strlist_done(oldfiles);
}
return result;
}
static void uploadpermission_release(struct upload_condition *p) {
struct upload_condition *h, *f = NULL;
assert (p != NULL);
do {
h = p->next;
switch (p->type) {
case uc_BINARIES:
case uc_SECTIONS:
case uc_SOURCENAME:
case uc_BYHAND:
case uc_CODENAME:
strlist_done(&p->strings);
break;
case uc_ARCHITECTURES:
atomlist_done(&p->atoms);
break;
case uc_ALWAYS:
case uc_REJECTED:
break;
}
free(f);
/* next one must be freed: */
f = h;
/* and processed: */
p = h;
} while (p != NULL);
}
static void freeoverridepackage(void *n) {
struct overridepackage *p = n;
free(p->packagename);
strlist_done(&p->data.fields);
free(p);
}
retvalue trackingdata_switch(struct trackingdata *data, const char *source, const char *version) {
retvalue r;
if (data->pkg != NULL) {
if (strcmp(data->pkg->sourcename, source) == 0 &&
strcmp(data->pkg->sourceversion, version) == 0)
return RET_OK;
r = tracking_saveonly(data->tracks, data->pkg);
if (RET_WAS_ERROR(r))
return r;
r = trackingdata_remember(data, data->pkg->sourcename,
data->pkg->sourceversion);
strlist_done(&data->pkg->filekeys);
free(data->pkg->refcounts);
free(data->pkg->filetypes);
free(data->pkg);
data->pkg = NULL;
if (RET_WAS_ERROR(r))
return r;
}
r = tracking_getornew(data->tracks, source, version, &data->pkg);
assert (r != RET_NOTHING);
if (RET_WAS_ERROR(r))
return r;
return RET_OK;
}
void deb_free(/*@only@*/struct debpackage *pkg) {
if (pkg != NULL) {
binaries_debdone(&pkg->deb);
if (pkg->filekey != NULL)
strlist_done(&pkg->filekeys);
}
free(pkg);
}
retvalue chunk_getextralinelist(const char *chunk, const char *name, struct strlist *strlist) {
retvalue r;
const char *f, *b, *e;
char *v;
f = chunk_getfield(name, chunk);
if (f == NULL)
return RET_NOTHING;
strlist_init(strlist);
/* walk over the first line */
while (*f != '\0' && *f != '\n')
f++;
/* nothing there is an empty list */
if (*f == '\0')
return RET_OK;
f++;
/* while lines begin with ' ' or '\t', add them */
while (*f == ' ' || *f == '\t') {
while (*f != '\0' && xisblank(*f))
f++;
b = f;
while (*f != '\0' && *f != '\n')
f++;
e = f;
while (e > b && *e != '\0' && xisspace(*e))
e--;
if (!xisspace(*e))
v = strndup(b, e - b + 1);
else
v = strdup("");
if (FAILEDTOALLOC(v)) {
strlist_done(strlist);
return RET_ERROR_OOM;
}
r = strlist_add(strlist, v);
if (!RET_IS_OK(r)) {
strlist_done(strlist);
return r;
}
if (*f == '\0')
return RET_OK;
f++;
}
return RET_OK;
}
void trackedpackage_free(struct trackedpackage *pkg) {
if (pkg != NULL) {
free(pkg->sourcename);
free(pkg->sourceversion);
strlist_done(&pkg->filekeys);
free(pkg->refcounts);
free(pkg->filetypes);
free(pkg);
}
}
static void aa_package_data_free(/*@only@*/struct aa_package_data *data){
if (data == NULL)
return;
free(data->name);
free(data->old_version);
free(data->new_version);
free(data->new_control);
strlist_done(&data->new_filekeys);
checksumsarray_done(&data->new_origfiles);
free(data);
}
retvalue chunk_getuniqwordlist(const char *chunk, const char *name, struct strlist *strlist) {
retvalue r;
const char *f, *b;
char *v;
f = chunk_getfield(name, chunk);
if (f == NULL)
return RET_NOTHING;
strlist_init(strlist);
while (*f != '\0') {
/* walk over spaces */
while (*f != '\0' && xisspace(*f)) {
if (*f == '\n') {
f++;
if (*f != ' ' && *f != '\t')
return RET_OK;
} else
f++;
}
if (*f == '\0')
return RET_OK;
b = f;
/* search for end of word */
while (*f != '\0' && !xisspace(*f))
f++;
v = strndup(b, f - b);
if (FAILEDTOALLOC(v)) {
strlist_done(strlist);
return RET_ERROR_OOM;
}
r = strlist_adduniq(strlist, v);
if (!RET_IS_OK(r)) {
strlist_done(strlist);
return r;
}
}
return RET_OK;
}
/* Like target_removepackage, but delete the package record by cursor */
retvalue package_remove_by_cursor(struct package_cursor *tc, struct logger *logger, struct trackingdata *trackingdata) {
struct target * const target = tc->target;
struct package *old = &tc->current;
struct strlist files;
retvalue result, r;
assert (target != NULL && target->packages != NULL);
assert (target == old->target);
if (logger != NULL) {
(void)package_getversion(old);
}
r = old->target->getfilekeys(old->control, &files);
if (RET_WAS_ERROR(r)) {
return r;
}
if (trackingdata != NULL) {
(void)package_getsource(old);
}
if (verbose > 0)
printf("removing '%s' from '%s'...\n",
old->name, old->target->identifier);
result = cursor_delete(target->packages, tc->cursor, old->name, NULL);
if (RET_IS_OK(result)) {
old->target->wasmodified = true;
if (trackingdata != NULL && old->source != NULL
&& old->sourceversion != NULL) {
r = trackingdata_remove(trackingdata,
old->source, old->sourceversion, &files);
RET_UPDATE(result, r);
}
if (trackingdata == NULL)
old->target->staletracking = true;
if (logger != NULL)
logger_log(logger, old->target, old->name,
NULL, old->version,
NULL, old->control,
NULL, &files,
NULL, NULL);
r = references_delete(old->target->identifier, &files, NULL);
RET_UPDATE(result, r);
}
strlist_done(&files);
return result;
}
void term_free(term *t) {
while (t != NULL) {
struct term_atom *next = t->next;
if (t->isspecial) {
if (t->special.type != NULL &&
t->special.type->done != NULL)
t->special.type->done(t->comparison,
&t->special.comparewith);
} else {
free(t->generic.key);
free(t->generic.comparewith);
}
strlist_done(&t->architectures);
free(t);
t = next;
}
}
void override_free(struct overridefile *info) {
struct overridepattern *i;
if (info == NULL)
return;
#ifdef HAVE_TDESTROY
tdestroy(info->packages, freeoverridepackage);
#endif
while ((i = info->patterns) != NULL) {
if (i == NULL)
return;
strlist_done(&i->data.fields);
free(i->pattern);
info->patterns = i->next;
free(i);
}
free(info);
}
static inline retvalue trackedpackage_removeall(trackingdb tracks, struct trackedpackage *pkg) {
retvalue result = RET_OK, r;
char *id;
// printf("[trackedpackage_removeall %s %s %s]\n", tracks->codename, pkg->sourcename, pkg->sourceversion);
id = calc_trackreferee(tracks->codename, pkg->sourcename,
pkg->sourceversion);
if (FAILEDTOALLOC(id))
return RET_ERROR_OOM;
pkg->flags.deleted = true;
r = references_delete(id, &pkg->filekeys, NULL);
RET_UPDATE(result, r);
free(id);
strlist_done(&pkg->filekeys);
strlist_init(&pkg->filekeys);
free(pkg->refcounts); pkg->refcounts = NULL;
return result;
}
void exportmode_done(struct exportmode *mode) {
assert (mode != NULL);
free(mode->filename);
strlist_done(&mode->hooks);
free(mode->release);
}
static retvalue targetremovesourcepackage(trackingdb t, struct trackedpackage *pkg, struct distribution *distribution, struct target *target) {
size_t component_len, arch_len;
retvalue result, r;
int i;
const char *packagetype = atoms_packagetypes[target->packagetype];
const char *architecture = atoms_architectures[target->architecture];
const char *component = atoms_components[target->component];
result = RET_NOTHING;
component_len = strlen(component);
arch_len = strlen(architecture);
for (i = 0 ; i < pkg->filekeys.count ; i++) {
const char *s, *basefilename, *filekey = pkg->filekeys.values[i];
char *package, *control, *source, *version;
struct strlist filekeys;
bool savedstaletracking;
if (pkg->refcounts[i] <= 0)
continue;
if (strncmp(filekey, "pool/", 5) != 0)
continue;
if (strncmp(filekey+5, component,
component_len) != 0)
continue;
if (filekey[5+component_len] != '/')
continue;
/* check this file could actuall be in this target */
if (pkg->filetypes[i] == ft_ALL_BINARY) {
if (target->packagetype == pt_dsc)
continue;
s = strrchr(filekey, '.');
if (s == NULL)
continue;
if (strcmp(s+1, packagetype) != 0)
continue;
} else if (pkg->filetypes[i] == ft_SOURCE) {
if (target->packagetype != pt_dsc)
continue;
s = strrchr(filekey, '.');
if (s == NULL)
continue;
if (strcmp(s+1, "dsc") != 0)
continue;
} else if (pkg->filetypes[i] == ft_ARCH_BINARY) {
if (target->packagetype == pt_dsc)
continue;
s = strrchr(filekey, '_');
if (s == NULL)
continue;
s++;
if (strncmp(s, architecture, arch_len) != 0
|| s[arch_len] != '.'
|| strcmp(s+arch_len+1, packagetype) != 0)
continue;
} else
continue;
/* get this package, check it has the right source and version,
* and if yes, remove... */
basefilename = strrchr(filekey, '/');
if (basefilename == NULL)
basefilename = filekey;
else
basefilename++;
s = strchr(basefilename, '_');
package = strndup(basefilename, s - basefilename);
if (FAILEDTOALLOC(package))
return RET_ERROR_OOM;
r = table_getrecord(target->packages, package, &control);
if (RET_WAS_ERROR(r)) {
free(package);
return r;
}
if (r == RET_NOTHING) {
if (pkg->filetypes[i] != ft_ALL_BINARY
&& verbose >= -1) {
fprintf(stderr,
"Warning: tracking data might be incosistent:\n"
"cannot find '%s' in '%s', but '%s' should be there.\n",
package, target->identifier,
filekey);
}
free(package);
continue;
}
r = target->getsourceandversion(control, package,
&source, &version);
assert (r != RET_NOTHING);
if (RET_WAS_ERROR(r)) {
free(package);
free(control);
return r;
}
if (strcmp(source, pkg->sourcename) != 0) {
if (pkg->filetypes[i] != ft_ALL_BINARY
&& verbose >= -1) {
fprintf(stderr,
"Warning: tracking data might be incosistent:\n"
"'%s' has '%s' of source '%s', but source '%s' contains '%s'.\n",
target->identifier, package,
source, pkg->sourcename,
filekey);
}
free(source);
free(version);
free(package);
free(control);
continue;
}
free(source);
if (strcmp(version, pkg->sourceversion) != 0) {
if (pkg->filetypes[i] != ft_ALL_BINARY
&& verbose >= -1) {
fprintf(stderr,
"Warning: tracking data might be incosistent:\n"
"'%s' has '%s' of source version '%s', but version '%s' contains '%s'.\n",
target->identifier, package,
version, pkg->sourceversion,
filekey);
}
free(package);
free(version);
free(control);
continue;
}
free(version);
r = target->getfilekeys(control, &filekeys);
assert (r != RET_NOTHING);
if (RET_WAS_ERROR(r)) {
free(package);
free(control);
return r;
}
/* we remove the tracking data outself, so this is not
* told to remove the tracking data, so it might mark things
* as stale, which we do not want.. */
savedstaletracking = target->staletracking;
/* that is a bit wasteful, as it parses some stuff again, but
* but that is better than reimplementing logger here */
r = target_removereadpackage(target, distribution->logger,
package, control, NULL);
target->staletracking = savedstaletracking;
free(control);
free(package);
assert (r != RET_NOTHING);
if (RET_WAS_ERROR(r)) {
strlist_done(&filekeys);
return r;
}
trackedpackage_removefilekeys(t, pkg, &filekeys);
strlist_done(&filekeys);
result = RET_OK;
}
return result;
}
static retvalue distribution_free(struct distribution *distribution) {
retvalue result, r;
bool needsretrack = false;
if (distribution != NULL) {
free(distribution->suite);
free(distribution->fakecomponentprefix);
free(distribution->version);
free(distribution->origin);
free(distribution->notautomatic);
free(distribution->butautomaticupgrades);
free(distribution->label);
free(distribution->description);
free(distribution->deb_override);
free(distribution->udeb_override);
free(distribution->dsc_override);
free(distribution->uploaders);
atomlist_done(&distribution->udebcomponents);
atomlist_done(&distribution->architectures);
atomlist_done(&distribution->components);
strlist_done(&distribution->signwith);
strlist_done(&distribution->updates);
strlist_done(&distribution->pulls);
strlist_done(&distribution->alsoaccept);
exportmode_done(&distribution->dsc);
exportmode_done(&distribution->deb);
exportmode_done(&distribution->udeb);
atomlist_done(&distribution->contents_architectures);
atomlist_done(&distribution->contents_components);
atomlist_done(&distribution->contents_ucomponents);
override_free(distribution->overrides.deb);
override_free(distribution->overrides.udeb);
override_free(distribution->overrides.dsc);
logger_free(distribution->logger);
if (distribution->uploaderslist != NULL) {
uploaders_unlock(distribution->uploaderslist);
}
byhandhooks_free(distribution->byhandhooks);
result = RET_OK;
while (distribution->targets != NULL) {
struct target *next = distribution->targets->next;
if (distribution->targets->staletracking)
needsretrack = true;
r = target_free(distribution->targets);
RET_UPDATE(result, r);
distribution->targets = next;
}
if (distribution->tracking != dt_NONE && needsretrack) {
fprintf(stderr,
"WARNING: Tracking data of '%s' might have become out of date.\n"
"Consider running retrack to avoid getting funny effects.\n",
distribution->codename);
}
free(distribution->codename);
free(distribution);
return result;
} else
return RET_OK;
}
retvalue diffindex_read(const char *diffindexfile, struct diffindex **out_p) {
retvalue r;
char *chunk, *current;
struct strlist history, patches;
struct diffindex *n;
r = readtextfile(diffindexfile, diffindexfile, &chunk, NULL);
ASSERT_NOT_NOTHING(r);
if (RET_WAS_ERROR(r))
return r;
r = chunk_getextralinelist(chunk, "SHA1-History", &history);
if (r == RET_NOTHING) {
fprintf(stderr, "'%s' misses SHA1-History field\n",
diffindexfile);
r = RET_ERROR;
}
if (RET_WAS_ERROR(r)) {
free(chunk);
return r;
}
r = chunk_getextralinelist(chunk, "SHA1-Patches", &patches);
if (r == RET_NOTHING) {
fprintf(stderr, "'%s' misses SHA1-Patches field\n",
diffindexfile);
r = RET_ERROR;
}
if (RET_WAS_ERROR(r)) {
free(chunk);
strlist_done(&history);
return r;
}
r = chunk_getvalue(chunk, "SHA1-Current", ¤t);
free(chunk);
if (r == RET_NOTHING) {
fprintf(stderr, "'%s' misses SHA1-Current field\n",
diffindexfile);
r = RET_ERROR;
}
if (RET_WAS_ERROR(r)) {
strlist_done(&history);
strlist_done(&patches);
return r;
}
n = calloc(1, sizeof(struct diffindex) +
patches.count * sizeof(struct diffindex_patch));
if (FAILEDTOALLOC(n)) {
strlist_done(&history);
strlist_done(&patches);
free(current);
return r;
}
n->patchcount = patches.count;
r = add_current(diffindexfile, n, current);
if (RET_IS_OK(r))
r = add_patches(diffindexfile, n, &patches);
if (RET_IS_OK(r))
r = add_history(diffindexfile, n, &history);
ASSERT_NOT_NOTHING(r);
strlist_done(&history);
strlist_done(&patches);
free(current);
if (RET_IS_OK(r))
*out_p = n;
else
diffindex_free(n);
return r;
}
