void
pool_deb_get_autoinstalled(Pool *pool, FILE *fp, Queue *q, int flags)
{
Id name = 0, arch = 0;
int autoinstalled = -1;
char *buf, *bp;
int x, l, bufl, eof = 0;
Id p, pp;
queue_empty(q);
buf = solv_malloc(4096);
bufl = 4096;
l = 0;
while (!eof)
{
while (bufl - l < 1024)
{
bufl += 4096;
if (bufl > 1024 * 64)
break; /* hmm? */
buf = solv_realloc(buf, bufl);
}
if (!fgets(buf + l, bufl - l, fp))
{
eof = 1;
buf[l] = '\n';
buf[l + 1] = 0;
}
l = strlen(buf);
if (l && buf[l - 1] == '\n')
buf[--l] = 0;
if (!*buf || eof)
{
l = 0;
if (name && autoinstalled > 0)
{
if ((flags & GET_USERINSTALLED_NAMEARCH) != 0)
queue_push2(q, name, arch);
else if ((flags & GET_USERINSTALLED_NAMES) != 0)
queue_push(q, name);
else
{
FOR_PROVIDES(p, pp, name)
{
Solvable *s = pool->solvables + p;
if (s->name != name)
continue;
if (arch && s->arch != arch)
continue;
queue_push(q, p);
}
}
}
name = arch = 0;
autoinstalled = -1;
continue;
}
char *
hy_chksum_str(const unsigned char *chksum, int type)
{
int length = checksum_type2length(type);
char *s = solv_malloc(2 * length + 1);
solv_bin2hex(chksum, length, s);
return s;
}
static unsigned char *
decompress(unsigned char *in, int inl, int *outlp)
{
z_stream strm;
int outl, ret;
unsigned char *out;
memset(&strm, 0, sizeof(strm));
strm.next_in = in;
strm.avail_in = inl;
out = solv_malloc(4096);
strm.next_out = out;
strm.avail_out = 4096;
outl = 0;
ret = inflateInit2(&strm, -MAX_WBITS);
if (ret != Z_OK)
{
free(out);
return 0;
}
for (;;)
{
if (strm.avail_out == 0)
{
outl += 4096;
out = solv_realloc(out, outl + 4096);
strm.next_out = out + outl;
strm.avail_out = 4096;
}
ret = inflate(&strm, Z_NO_FLUSH);
if (ret == Z_STREAM_END)
break;
if (ret != Z_OK)
{
free(out);
return 0;
}
}
outl += 4096 - strm.avail_out;
inflateEnd(&strm);
*outlp = outl;
return out;
}
int
repo_add_content(Repo *repo, FILE *fp, int flags)
{
Pool *pool = repo->pool;
char *line, *linep;
int aline;
Solvable *s;
struct parsedata pd;
Repodata *data;
Id handle = 0;
int contentstyle = 0;
char *descrdir = 0;
char *datadir = 0;
char *defvendor = 0;
int i = 0;
int res = 0;
/* architectures
we use the first architecture in BASEARCHS or noarch
for the product. At the end we create (clone) the product
for each one of the remaining architectures
we allow max 4 archs
*/
unsigned int numotherarchs = 0;
Id *otherarchs = 0;
memset(&pd, 0, sizeof(pd));
line = solv_malloc(1024);
aline = 1024;
pd.repo = repo;
linep = line;
s = 0;
data = repo_add_repodata(repo, flags);
for (;;)
{
char *key, *value;
/* read line into big-enough buffer */
if (linep - line + 16 > aline)
{
aline = linep - line;
line = solv_realloc(line, aline + 512);
linep = line + aline;
aline += 512;
}
if (!fgets(linep, aline - (linep - line), fp))
break;
linep += strlen(linep);
if (linep == line || linep[-1] != '\n')
continue;
while ( --linep > line && ( linep[-1] == ' ' || linep[-1] == '\t' ) )
; /* skip trailing ws */
*linep = 0;
linep = line;
/* expect "key value" lines */
value = line;
key = splitword(&value);
if (key)
{
#if 0
fprintf (stderr, "key %s, value %s\n", key, value);
#endif
#define istag(x) (!strcmp (key, x))
#define code10 (contentstyle == 10)
#define code11 (contentstyle == 11)
if (istag ("CONTENTSTYLE"))
{
if (contentstyle)
pool_debug(pool, SOLV_ERROR, "repo_content: 'CONTENTSTYLE' must be first line of 'content'\n");
contentstyle = atoi(value);
continue;
}
if (!contentstyle)
contentstyle = 10;
/* repository tags */
/* we also replicate some of them into the product solvables
* to be backward compatible */
if (istag ("REPOID"))
{
repodata_add_poolstr_array(data, SOLVID_META, REPOSITORY_REPOID, value);
continue;
}
if (istag ("REPOKEYWORDS"))
{
add_multiple_strings(data, SOLVID_META, REPOSITORY_KEYWORDS, value);
continue;
}
if (istag ("DISTRO"))
{
Id dh = repodata_new_handle(data);
char *p;
/* like with createrepo --distro */
if ((p = strchr(value, ',')) != 0)
{
*p++ = 0;
if (*value)
repodata_set_poolstr(data, dh, REPOSITORY_PRODUCT_CPEID, value);
}
else
p = value;
if (*p)
repodata_set_str(data, dh, REPOSITORY_PRODUCT_LABEL, p);
repodata_add_flexarray(data, SOLVID_META, REPOSITORY_DISTROS, dh);
continue;
}
if (istag ("DESCRDIR"))
{
if (descrdir)
free(descrdir);
else
repodata_set_str(data, SOLVID_META, SUSETAGS_DESCRDIR, value);
if (s)
repodata_set_str(data, s - pool->solvables, SUSETAGS_DESCRDIR, value);
descrdir = solv_strdup(value);
continue;
}
if (istag ("DATADIR"))
{
if (datadir)
free(datadir);
else
repodata_set_str(data, SOLVID_META, SUSETAGS_DATADIR, value);
if (s)
repodata_set_str(data, s - pool->solvables, SUSETAGS_DATADIR, value);
datadir = solv_strdup(value);
continue;
}
if (istag ("VENDOR"))
{
if (defvendor)
free(defvendor);
else
repodata_set_poolstr(data, SOLVID_META, SUSETAGS_DEFAULTVENDOR, value);
if (s)
s->vendor = pool_str2id(pool, value, 1);
defvendor = solv_strdup(value);
continue;
}
if (istag ("META") || istag ("HASH") || istag ("KEY"))
{
char *checksumtype, *checksum;
Id fh, type;
int l;
if ((checksumtype = splitword(&value)) == 0)
continue;
if ((checksum = splitword(&value)) == 0)
continue;
if (!*value)
continue;
type = solv_chksum_str2type(checksumtype);
if (!type)
{
pool_error(pool, -1, "%s: unknown checksum type '%s'", value, checksumtype);
res = 1;
continue;
}
l = solv_chksum_len(type);
if (strlen(checksum) != 2 * l)
{
pool_error(pool, -1, "%s: invalid checksum length for %s", value, checksumtype);
res = 1;
continue;
}
fh = repodata_new_handle(data);
repodata_set_poolstr(data, fh, SUSETAGS_FILE_TYPE, key);
repodata_set_str(data, fh, SUSETAGS_FILE_NAME, value);
repodata_set_checksum(data, fh, SUSETAGS_FILE_CHECKSUM, type, checksum);
repodata_add_flexarray(data, SOLVID_META, SUSETAGS_FILE, fh);
continue;
}
/* product tags */
if ((code10 && istag ("PRODUCT"))
|| (code11 && istag ("NAME")))
{
if (s && !s->name)
{
/* this solvable was created without seeing a
PRODUCT entry, just set the name and continue */
s->name = pool_str2id(pool, join(&pd, "product", ":", value), 1);
continue;
}
if (s)
{
/* finish old solvable */
if (!s->arch)
s->arch = ARCH_NOARCH;
if (!s->evr)
s->evr = ID_EMPTY;
if (s->name && s->arch != ARCH_SRC && s->arch != ARCH_NOSRC)
s->provides = repo_addid_dep(repo, s->provides, pool_rel2id(pool, s->name, s->evr, REL_EQ, 1), 0);
if (code10)
s->supplements = repo_fix_supplements(repo, s->provides, s->supplements, 0);
}
/* create new solvable */
s = pool_id2solvable(pool, repo_add_solvable(repo));
handle = s - pool->solvables;
s->name = pool_str2id(pool, join(&pd, "product", ":", value), 1);
if (datadir)
repodata_set_str(data, s - pool->solvables, SUSETAGS_DATADIR, datadir);
if (descrdir)
repodata_set_str(data, s - pool->solvables, SUSETAGS_DESCRDIR, descrdir);
if (defvendor)
s->vendor = pool_str2id(pool, defvendor, 1);
continue;
}
/* Sometimes PRODUCT/NAME is not the first entry, but we need a solvable
from here on. */
if (!s)
{
s = pool_id2solvable(pool, repo_add_solvable(repo));
handle = s - pool->solvables;
}
if (istag ("VERSION"))
pd.tmpvers = solv_strdup(value);
else if (istag ("RELEASE"))
pd.tmprel = solv_strdup(value);
else if (code11 && istag ("DISTRIBUTION"))
repodata_set_poolstr(data, s - pool->solvables, SOLVABLE_DISTRIBUTION, value);
else if (istag ("UPDATEURLS"))
add_multiple_urls(data, handle, value, pool_str2id(pool, "update", 1));
else if (istag ("EXTRAURLS"))
add_multiple_urls(data, handle, value, pool_str2id(pool, "extra", 1));
else if (istag ("OPTIONALURLS"))
add_multiple_urls(data, handle, value, pool_str2id(pool, "optional", 1));
else if (istag ("RELNOTESURL"))
add_multiple_urls(data, handle, value, pool_str2id(pool, "releasenotes", 1));
else if (istag ("SHORTLABEL"))
repodata_set_str(data, s - pool->solvables, PRODUCT_SHORTLABEL, value);
else if (istag ("LABEL")) /* LABEL is the products SUMMARY. */
repodata_set_str(data, s - pool->solvables, SOLVABLE_SUMMARY, value);
else if (!strncmp (key, "LABEL.", 6))
repodata_set_str(data, s - pool->solvables, pool_id2langid(pool, SOLVABLE_SUMMARY, key + 6, 1), value);
else if (istag ("FLAGS"))
add_multiple_strings(data, handle, PRODUCT_FLAGS, value);
else if (istag ("VENDOR")) /* actually already handled above */
s->vendor = pool_str2id(pool, value, 1);
else if (istag ("BASEARCHS"))
{
char *arch;
if ((arch = splitword(&value)) != 0)
{
s->arch = pool_str2id(pool, arch, 1);
while ((arch = splitword(&value)) != 0)
{
otherarchs = solv_extend(otherarchs, numotherarchs, 1, sizeof(Id), 7);
otherarchs[numotherarchs++] = pool_str2id(pool, arch, 1);
}
}
}
if (!code10)
continue;
/*
* Every tag below is Code10 only
*
*/
if (istag ("ARCH"))
/* Theoretically we want to have the best arch of the given
modifiers which still is compatible with the system
arch. We don't know the latter here, though. */
s->arch = ARCH_NOARCH;
else if (istag ("PREREQUIRES"))
s->requires = adddep(pool, &pd, s->requires, value, SOLVABLE_PREREQMARKER);
else if (istag ("REQUIRES"))
s->requires = adddep(pool, &pd, s->requires, value, -SOLVABLE_PREREQMARKER);
else if (istag ("PROVIDES"))
s->provides = adddep(pool, &pd, s->provides, value, 0);
else if (istag ("CONFLICTS"))
s->conflicts = adddep(pool, &pd, s->conflicts, value, 0);
else if (istag ("OBSOLETES"))
s->obsoletes = adddep(pool, &pd, s->obsoletes, value, 0);
else if (istag ("RECOMMENDS"))
s->recommends = adddep(pool, &pd, s->recommends, value, 0);
else if (istag ("SUGGESTS"))
s->suggests = adddep(pool, &pd, s->suggests, value, 0);
else if (istag ("SUPPLEMENTS"))
s->supplements = adddep(pool, &pd, s->supplements, value, 0);
else if (istag ("ENHANCES"))
s->enhances = adddep(pool, &pd, s->enhances, value, 0);
/* FRESHENS doesn't seem to exist. */
else if (istag ("TYPE"))
repodata_set_str(data, s - pool->solvables, PRODUCT_TYPE, value);
/* XXX do something about LINGUAS and ARCH?
* <ma>: Don't think so. zypp does not use or propagate them.
*/
#undef istag
}
else
pool_debug(pool, SOLV_ERROR, "repo_content: malformed line: %s\n", line);
}
if (datadir)
free(datadir);
if (descrdir)
free(descrdir);
if (defvendor)
free(defvendor);
if (s && !s->name)
{
pool_debug(pool, SOLV_ERROR, "repo_content: 'content' incomplete, no product solvable created!\n");
repo_free_solvable(repo, s - pool->solvables, 1);
s = 0;
}
if (s)
{
if (pd.tmprel)
s->evr = makeevr(pool, join(&pd, pd.tmpvers, "-", pd.tmprel));
else
s->evr = makeevr(pool, pd.tmpvers);
pd.tmpvers = solv_free((void *)pd.tmpvers);
pd.tmprel = solv_free((void *)pd.tmprel);
if (!s->arch)
s->arch = ARCH_NOARCH;
if (!s->evr)
s->evr = ID_EMPTY;
if (s->name && s->arch != ARCH_SRC && s->arch != ARCH_NOSRC)
s->provides = repo_addid_dep(repo, s->provides, pool_rel2id(pool, s->name, s->evr, REL_EQ, 1), 0);
if (code10)
s->supplements = repo_fix_supplements(repo, s->provides, s->supplements, 0);
/* now for every other arch, clone the product except the architecture */
for (i = 0; i < numotherarchs; ++i)
{
Solvable *p = pool_id2solvable(pool, repo_add_solvable(repo));
p->name = s->name;
p->evr = s->evr;
p->vendor = s->vendor;
p->arch = otherarchs[i];
/* self provides */
if (s->name && p->arch != ARCH_SRC && p->arch != ARCH_NOSRC)
p->provides = repo_addid_dep(repo, p->provides, pool_rel2id(pool, p->name, p->evr, REL_EQ, 1), 0);
/* now merge the attributes */
repodata_merge_attrs(data, p - pool->solvables, s - pool->solvables);
}
}
if (pd.tmp)
solv_free(pd.tmp);
solv_free(line);
solv_free(otherarchs);
if (!(flags & REPO_NO_INTERNALIZE))
repodata_internalize(data);
return res;
}
int
main(int argc, char **argv)
{
Pool *pool = pool_create();
Repo *repo, *ref = 0;
Repodata *data;
int c, percent = 0;
int extrapool = 0;
int nopacks = 0;
const char *root = 0;
const char *basefile = 0;
const char *refname = 0;
#ifdef ENABLE_SUSEREPO
char *proddir = 0;
#endif
char *outfile = 0;
/*
* parse arguments
*/
while ((c = getopt(argc, argv, "Phnxb:r:p:o:")) >= 0)
switch (c)
{
case 'h':
usage(0);
break;
case 'r':
root = optarg;
break;
case 'b':
basefile = optarg;
break;
case 'n':
nopacks = 1;
break;
case 'P':
percent = 1;
break;
case 'p':
#ifdef ENABLE_SUSEREPO
proddir = optarg;
#endif
break;
case 'x':
extrapool = 1;
break;
case 'o':
outfile = optarg;
break;
default:
usage(1);
}
if (outfile && !freopen(outfile, "w", stdout))
{
perror(outfile);
exit(1);
}
/*
* optional arg is old version of rpmdb solv file
* should make this a real option instead
*/
if (optind < argc)
refname = argv[optind];
if (refname)
{
FILE *fp;
if ((fp = fopen(refname, "r")) == NULL)
{
perror(refname);
}
else
{
Pool *refpool = extrapool ? pool_create() : 0;
ref = repo_create(refpool ? refpool : pool, "ref");
if (repo_add_solv(ref, fp, 0) != 0)
{
fprintf(stderr, "%s: %s\n", refname, pool_errstr(ref->pool));
if (ref->pool != pool)
pool_free(ref->pool);
else
repo_free(ref, 1);
ref = 0;
}
else
repo_disable_paging(ref);
fclose(fp);
}
}
/*
* create 'installed' repository
* add products
* add rpmdb
* write .solv
*/
repo = repo_create(pool, "installed");
data = repo_add_repodata(repo, 0);
if (!nopacks)
{
if (repo_add_rpmdb(repo, ref, root, REPO_REUSE_REPODATA | REPO_NO_INTERNALIZE | (percent ? RPMDB_REPORT_PROGRESS : 0)))
{
fprintf(stderr, "rpmdb2solv: %s\n", pool_errstr(pool));
exit(1);
}
}
#ifdef ENABLE_SUSEREPO
if (proddir && *proddir)
{
char *buf = proddir;
/* if <root> given, not '/', and proddir does not start with <root> */
if (root && *root)
{
int rootlen = strlen(root);
if (strncmp(root, proddir, rootlen))
{
buf = (char *)solv_malloc(rootlen + strlen(proddir) + 2); /* + '/' + \0 */
strcpy(buf, root);
if (root[rootlen - 1] != '/' && *proddir != '/')
buf[rootlen++] = '/';
strcpy(buf + rootlen, proddir);
}
}
if (repo_add_products(repo, buf, root, REPO_REUSE_REPODATA | REPO_NO_INTERNALIZE))
{
fprintf(stderr, "rpmdb2solv: %s\n", pool_errstr(pool));
exit(1);
}
if (buf != proddir)
solv_free(buf);
}
#endif
repodata_internalize(data);
if (ref)
{
if (ref->pool != pool)
pool_free(ref->pool);
else
repo_free(ref, 1);
ref = 0;
}
tool_write(repo, basefile, 0);
pool_free(pool);
exit(0);
}
int
main(int argc, char **argv)
{
const char *contentfile = 0;
const char *attrname = 0;
const char *descrdir = 0;
const char *basefile = 0;
const char *query = 0;
const char *mergefile = 0;
Id defvendor = 0;
int flags = 0;
#ifdef SUSE
int add_auto = 0;
#endif
int c;
Pool *pool;
Repo *repo;
while ((c = getopt(argc, argv, "hn:c:d:b:q:M:X")) >= 0)
{
switch (c)
{
case 'h':
usage(0);
break;
case 'n':
attrname = optarg;
break;
case 'c':
contentfile = optarg;
break;
case 'd':
descrdir = optarg;
break;
case 'b':
basefile = optarg;
break;
case 'q':
query = optarg;
break;
case 'M':
mergefile = optarg;
break;
case 'X':
#ifdef SUSE
add_auto = 1;
#endif
break;
default:
usage(1);
break;
}
}
pool = pool_create();
repo = repo_create(pool, "<susetags>");
repo_add_repodata(repo, 0);
if (contentfile)
{
FILE *fp = fopen(contentfile, "r");
if (!fp)
{
perror(contentfile);
exit(1);
}
if (repo_add_content(repo, fp, REPO_REUSE_REPODATA))
{
fprintf(stderr, "susetags2solv: %s: %s\n", contentfile, pool_errstr(pool));
exit(1);
}
defvendor = repo_lookup_id(repo, SOLVID_META, SUSETAGS_DEFAULTVENDOR);
fclose(fp);
}
if (attrname)
{
/* ensure '.attr' suffix */
const char *dot = strrchr(attrname, '.');
if (!dot || strcmp(dot, ".attr"))
{
int len = strlen (attrname);
char *newname = (char *)malloc(len + 6); /* alloc for <attrname>+'.attr'+'\0' */
strcpy (newname, attrname);
strcpy (newname+len, ".attr");
attrname = newname;
}
}
/*
* descrdir path given, open files and read from there
*/
if (descrdir)
{
char *fnp;
int ndirs, i;
struct dirent **files;
ndirs = scandir(descrdir, &files, 0, alphasort);
if (ndirs < 0)
{
perror(descrdir);
exit(1);
}
/* bring packages to front */
for (i = 0; i < ndirs; i++)
{
char *fn = files[i]->d_name;
if (!strcmp(fn, "packages") || !strcmp(fn, "packages.gz"))
break;
}
if (i == ndirs)
{
fprintf(stderr, "found no packages file\n");
exit(1);
}
if (i)
{
struct dirent *de = files[i];
memmove(files + 1, files, i * sizeof(de));
files[0] = de;
}
fnp = solv_malloc(strlen(descrdir) + 128);
for (i = 0; i < ndirs; i++)
{
char *fn = files[i]->d_name;
if (!strcmp(fn, "packages") || !strcmp(fn, "packages.gz"))
{
FILE *fp;
sprintf(fnp, "%s/%s", descrdir, fn);
fp = solv_xfopen(fnp, 0);
if (!fp)
{
perror(fn);
exit(1);
}
if (repo_add_susetags(repo, fp, defvendor, 0, flags | REPO_REUSE_REPODATA | REPO_NO_INTERNALIZE))
{
fprintf(stderr, "susetags2solv: %s: %s\n", fnp, pool_errstr(pool));
exit(1);
}
fclose(fp);
}
else if (!strcmp(fn, "packages.DU") || !strcmp(fn, "packages.DU.gz"))
{
FILE *fp;
sprintf(fnp, "%s/%s", descrdir, fn);
fp = solv_xfopen(fnp, 0);
if (!fp)
{
perror(fn);
exit(1);
}
if (repo_add_susetags(repo, fp, defvendor, 0, flags | SUSETAGS_EXTEND | REPO_REUSE_REPODATA | REPO_NO_INTERNALIZE))
{
fprintf(stderr, "susetags2solv: %s: %s\n", fnp, pool_errstr(pool));
exit(1);
}
fclose(fp);
}
else if (!strcmp(fn, "packages.FL") || !strcmp(fn, "packages.FL.gz"))
{
#if 0
sprintf(fnp, "%s/%s", descrdir, fn);
FILE *fp = solv_xfopen(fnp, 0);
if (!fp)
{
perror(fn);
exit(1);
}
if (repo_add_susetags(repo, fp, defvendor, 0, flags | SUSETAGS_EXTEND | REPO_REUSE_REPODATA | REPO_NO_INTERNALIZE))
{
fprintf(stderr, "susetags2solv: %s: %s\n", fnp, pool_errstr(pool));
exit(1);
}
fclose(fp);
#else
/* ignore for now. reactivate when filters work */
continue;
#endif
}
else if (!strncmp(fn, "packages.", 9))
{
char lang[6];
char *p;
FILE *fp;
sprintf(fnp, "%s/%s", descrdir, fn);
p = strrchr(fnp, '.');
if (p && !strcmp(p, ".gz"))
{
*p = 0;
p = strrchr(fnp, '.');
}
if (!p || !p[1] || strlen(p + 1) > 5)
continue;
strcpy(lang, p + 1);
sprintf(fnp, "%s/%s", descrdir, fn);
fp = solv_xfopen(fnp, 0);
if (!fp)
{
perror(fn);
exit(1);
}
if (repo_add_susetags(repo, fp, defvendor, lang, flags | SUSETAGS_EXTEND | REPO_REUSE_REPODATA | REPO_NO_INTERNALIZE))
{
fprintf(stderr, "susetags2solv: %s: %s\n", fnp, pool_errstr(pool));
exit(1);
}
fclose(fp);
}
}
for (i = 0; i < ndirs; i++)
free(files[i]);
free(files);
free(fnp);
repo_internalize(repo);
}
else
{
/* read data from stdin */
if (repo_add_susetags(repo, stdin, defvendor, 0, REPO_REUSE_REPODATA | REPO_NO_INTERNALIZE))
{
fprintf(stderr, "susetags2solv: %s\n", pool_errstr(pool));
exit(1);
}
}
repo_internalize(repo);
if (mergefile)
{
FILE *fp = fopen(mergefile, "r");
if (!fp)
{
perror(mergefile);
exit(1);
}
if (repo_add_solv(repo, fp, 0))
{
fprintf(stderr, "susetags2solv: %s\n", pool_errstr(pool));
exit(1);
}
fclose(fp);
}
#ifdef SUSE
if (add_auto)
repo_add_autopattern(repo, 0);
#endif
if (query)
doquery(pool, repo, query);
else
tool_write(repo, basefile, attrname);
pool_free(pool);
exit(0);
}
static unsigned char *
unarmor(char *pubkey, int *pktlp)
{
char *p;
int l, eof;
unsigned char *buf, *bp;
unsigned int v;
*pktlp = 0;
while (strncmp(pubkey, "-----BEGIN PGP PUBLIC KEY BLOCK-----", 36) != 0)
{
pubkey = strchr(pubkey, '\n');
if (!pubkey)
return 0;
pubkey++;
}
pubkey = strchr(pubkey, '\n');
if (!pubkey++)
return 0;
/* skip header lines */
for (;;)
{
while (*pubkey == ' ' || *pubkey == '\t')
pubkey++;
if (*pubkey == '\n')
break;
pubkey = strchr(pubkey, '\n');
if (!pubkey++)
return 0;
}
pubkey++;
p = strchr(pubkey, '=');
if (!p)
return 0;
l = p - pubkey;
bp = buf = solv_malloc(l * 3 / 4 + 4);
eof = 0;
while (!eof)
{
pubkey = r64dec1(pubkey, &v, &eof);
if (!pubkey)
{
solv_free(buf);
return 0;
}
*bp++ = v >> 16;
*bp++ = v >> 8;
*bp++ = v;
}
while (*pubkey == ' ' || *pubkey == '\t' || *pubkey == '\n' || *pubkey == '\r')
pubkey++;
bp -= eof;
if (*pubkey != '=' || (pubkey = r64dec1(pubkey + 1, &v, &eof)) == 0)
{
solv_free(buf);
return 0;
}
if (v != crc24(buf, bp - buf))
{
solv_free(buf);
return 0;
}
while (*pubkey == ' ' || *pubkey == '\t' || *pubkey == '\n' || *pubkey == '\r')
pubkey++;
if (strncmp(pubkey, "-----END PGP PUBLIC KEY BLOCK-----", 34) != 0)
{
solv_free(buf);
return 0;
}
*pktlp = bp - buf;
return buf;
}
int
repo_add_rpmmd(Repo *repo, FILE *fp, const char *language, int flags)
{
Pool *pool = repo->pool;
struct parsedata pd;
char buf[BUFF_SIZE];
int i, l;
struct stateswitch *sw;
Repodata *data;
unsigned int now;
XML_Parser parser;
now = solv_timems(0);
data = repo_add_repodata(repo, flags);
memset(&pd, 0, sizeof(pd));
for (i = 0, sw = stateswitches; sw->from != NUMSTATES; i++, sw++)
{
if (!pd.swtab[sw->from])
pd.swtab[sw->from] = sw;
pd.sbtab[sw->to] = sw->from;
}
pd.common.pool = pool;
pd.common.repo = repo;
pd.data = data;
pd.content = solv_malloc(256);
pd.acontent = 256;
pd.lcontent = 0;
pd.common.tmp = 0;
pd.common.tmpl = 0;
pd.kind = 0;
pd.language = language;
/* initialize the string pool where we will store
the package checksums we know about, to get an Id
we can use in a cache */
stringpool_init_empty(&pd.cspool);
if ((flags & REPO_EXTEND_SOLVABLES) != 0)
{
/* setup join data */
Dataiterator di;
dataiterator_init(&di, pool, repo, 0, SOLVABLE_CHECKSUM, 0, 0);
while (dataiterator_step(&di))
{
const char *str;
int index;
if (!solv_chksum_len(di.key->type))
continue;
str = repodata_chk2str(di.data, di.key->type, (const unsigned char *)di.kv.str);
index = stringpool_str2id(&pd.cspool, str, 1);
if (index >= pd.ncscache)
{
pd.cscache = solv_zextend(pd.cscache, pd.ncscache, index + 1 - pd.ncscache, sizeof(Id), 255);
pd.ncscache = index + 1;
}
pd.cscache[index] = di.solvid;
}
dataiterator_free(&di);
}
parser = XML_ParserCreate(NULL);
XML_SetUserData(parser, &pd);
pd.parser = &parser;
XML_SetElementHandler(parser, startElement, endElement);
XML_SetCharacterDataHandler(parser, characterData);
for (;;)
{
l = fread(buf, 1, sizeof(buf), fp);
if (XML_Parse(parser, buf, l, l == 0) == XML_STATUS_ERROR)
{
pool_debug(pool, SOLV_FATAL, "repo_rpmmd: %s at line %u:%u\n", XML_ErrorString(XML_GetErrorCode(parser)), (unsigned int)XML_GetCurrentLineNumber(parser), (unsigned int)XML_GetCurrentColumnNumber(parser));
exit(1);
}
if (l == 0)
break;
}
XML_ParserFree(parser);
solv_free(pd.content);
solv_free(pd.lastdirstr);
join_freemem();
stringpool_free(&pd.cspool);
solv_free(pd.cscache);
if (!(flags & REPO_NO_INTERNALIZE))
repodata_internalize(data);
POOL_DEBUG(SOLV_DEBUG_STATS, "repo_add_rpmmd took %d ms\n", solv_timems(now));
POOL_DEBUG(SOLV_DEBUG_STATS, "repo size: %d solvables\n", repo->nsolvables);
POOL_DEBUG(SOLV_DEBUG_STATS, "repo memory used: %d K incore, %d K idarray\n", data->incoredatalen/1024, repo->idarraysize / (int)(1024/sizeof(Id)));
return 0;
}
int
repo_add_cudf(Repo *repo, Repo *installedrepo, FILE *fp, Queue *job, int flags)
{
Pool *pool = repo->pool;
char *buf, *p;
int bufa, bufl, c;
Solvable *s;
int instanza = 0;
int inrequest = 0;
int isinstalled = 0;
int keep = 0;
Repo *xrepo;
xrepo = repo ? repo : installedrepo;
if (!xrepo)
return -1;
buf = solv_malloc(4096);
bufa = 4096;
bufl = 0;
s = 0;
while (fgets(buf + bufl, bufa - bufl, fp) > 0)
{
bufl += strlen(buf + bufl);
if (bufl && buf[bufl - 1] != '\n')
{
if (bufa - bufl < 256)
{
bufa += 4096;
buf = solv_realloc(buf, bufa);
}
continue;
}
buf[--bufl] = 0;
c = getc(fp);
if (c == ' ' || c == '\t')
{
/* continuation line */
buf[bufl++] = ' ';
continue;
}
if (c != EOF)
ungetc(c, fp);
bufl = 0;
if (*buf == '#')
continue;
if (!*buf)
{
if (s && !repo && !isinstalled)
{
repo_free_solvable(repo, s - pool->solvables, 1);
s = 0;
}
if (s)
finishpackage(pool, s, keep, job);
s = 0;
keep = 0;
instanza = 0;
inrequest = 0;
continue;
}
p = strchr(buf, ':');
if (!p)
continue; /* hmm */
*p++ = 0;
while (*p == ' ' || *p == '\t')
p++;
if (!instanza)
{
instanza = 1;
inrequest = 0;
if (!strcmp(buf, "request"))
{
inrequest = 1;
continue;
}
if (!strcmp(buf, "package"))
{
s = pool_id2solvable(pool, repo_add_solvable(xrepo));
isinstalled = 0;
keep = 0;
}
}
if (inrequest)
{
if (!job)
continue;
if (!strcmp(buf, "install"))
{
Id id, *idp;
Offset off = makedeps(xrepo, p, 0, 0);
for (idp = xrepo->idarraydata + off; (id = *idp) != 0; idp++)
queue_push2(job, SOLVER_INSTALL|SOLVER_SOLVABLE_PROVIDES, id);
}
else if (!strcmp(buf, "remove"))
{
Id id, *idp;
Offset off = makedeps(xrepo, p, 0, 0);
for (idp = xrepo->idarraydata + off; (id = *idp) != 0; idp++)
queue_push2(job, SOLVER_ERASE|SOLVER_SOLVABLE_PROVIDES, id);
}
else if (!strcmp(buf, "upgrade"))
{
Id id, *idp;
Offset off = makedeps(xrepo, p, 0, 0);
for (idp = xrepo->idarraydata + off; (id = *idp) != 0; idp++)
queue_push2(job, SOLVER_INSTALL|SOLVER_ORUPDATE|SOLVER_SOLVABLE_PROVIDES, id);
}
continue;
}
if (!s)
continue; /* we ignore the preamble for now */
switch (buf[0])
{
case 'c':
if (!strcmp(buf, "conflicts"))
{
s->conflicts = makedeps(s->repo, p, s->conflicts, 0);
continue;
}
case 'd':
if (!strcmp(buf, "depends"))
{
s->requires = makedeps(s->repo, p, s->requires, 0);
continue;
}
break;
case 'k':
if (!strcmp(buf, "keep"))
{
if (!job)
continue;
if (!strcmp(p, "version"))
keep = KEEP_VERSION;
else if (!strcmp(p, "package"))
keep = KEEP_PACKAGE;
else if (!strcmp(p, "feature"))
keep = KEEP_FEATURE;
continue;
}
break;
case 'i':
if (!strcmp(buf, "installed"))
{
if (!strcmp(p, "true"))
{
isinstalled = 1;
if (!installedrepo)
{
repo_free_solvable(repo, s - pool->solvables, 1);
s = 0;
}
else if (s->repo != installedrepo)
{
copysolvabledata(pool, s, installedrepo);
s->repo->nsolvables--;
s->repo = installedrepo;
if (s - pool->solvables < s->repo->start)
s->repo->start = s - pool->solvables;
if (s - pool->solvables >= s->repo->end)
s->repo->end = s - pool->solvables + 1;
s->repo->nsolvables++;
}
}
continue;
}
break;
case 'p':
if (!strcmp(buf, "package"))
{
s->name = pool_str2id(pool, p, 1);
continue;
}
if (!strcmp(buf, "provides"))
{
s->provides = makedeps(s->repo, p, s->provides, 0);
continue;
}
break;
case 'r':
if (!strcmp(buf, "depends"))
{
s->recommends = makedeps(s->repo, p, s->recommends, 0);
continue;
}
break;
case 'v':
if (!strcmp(buf, "version"))
{
s->evr = pool_str2id(pool, p, 1);
continue;
}
break;
}
}
if (s && !repo && !isinstalled)
{
repo_free_solvable(repo, s - pool->solvables, 1);
s = 0;
}
if (s)
finishpackage(pool, s, keep, job);
solv_free(buf);
return 0;
}
int
repo_add_debpackages(Repo *repo, FILE *fp, int flags)
{
Pool *pool = repo->pool;
Repodata *data;
char *buf, *p;
int bufl, l, ll;
Solvable *s;
data = repo_add_repodata(repo, flags);
buf = solv_malloc(4096);
bufl = 4096;
l = 0;
buf[l] = 0;
p = buf;
for (;;)
{
if (!(p = strchr(p, '\n')))
{
int l3;
if (l + 1024 >= bufl)
{
buf = solv_realloc(buf, bufl + 4096);
bufl += 4096;
p = buf + l;
continue;
}
p = buf + l;
ll = fread(p, 1, bufl - l - 1, fp);
if (ll <= 0)
break;
p[ll] = 0;
while ((l3 = strlen(p)) < ll)
p[l3] = '\n';
l += ll;
continue;
}
p++;
if (*p != '\n')
continue;
*p = 0;
ll = p - buf + 1;
s = pool_id2solvable(pool, repo_add_solvable(repo));
control2solvable(s, data, buf);
if (!s->name)
repo_free_solvable(repo, s - pool->solvables, 1);
if (l > ll)
memmove(buf, p + 1, l - ll);
l -= ll;
p = buf;
buf[l] = 0;
}
if (l)
{
s = pool_id2solvable(pool, repo_add_solvable(repo));
control2solvable(s, data, buf);
if (!s->name)
repo_free_solvable(repo, s - pool->solvables, 1);
}
solv_free(buf);
if (!(flags & REPO_NO_INTERNALIZE))
repodata_internalize(data);
return 0;
}
int
repo_add_mdk(Repo *repo, FILE *fp, int flags)
{
Pool *pool = repo->pool;
Repodata *data;
Solvable *s;
char *buf;
int bufa, bufl;
data = repo_add_repodata(repo, flags);
bufa = 4096;
buf = solv_malloc(bufa);
bufl = 0;
s = 0;
while (fgets(buf + bufl, bufa - bufl, fp) > 0)
{
bufl += strlen(buf + bufl);
if (bufl && buf[bufl - 1] != '\n')
{
if (bufa - bufl < 256)
{
bufa += 4096;
buf = solv_realloc(buf, bufa);
}
continue;
}
buf[--bufl] = 0;
bufl = 0;
if (buf[0] != '@')
{
pool_debug(pool, SOLV_ERROR, "bad line <%s>\n", buf);
continue;
}
if (!s)
s = pool_id2solvable(pool, repo_add_solvable(repo));
if (!strncmp(buf + 1, "filesize@", 9))
repodata_set_num(data, s - pool->solvables, SOLVABLE_DOWNLOADSIZE, strtoull(buf + 10, 0, 10));
else if (!strncmp(buf + 1, "summary@", 8))
repodata_set_str(data, s - pool->solvables, SOLVABLE_SUMMARY, buf + 9);
else if (!strncmp(buf + 1, "provides@", 9))
s->provides = parse_deps(s, buf + 10, 0);
else if (!strncmp(buf + 1, "requires@", 9))
s->requires = parse_deps(s, buf + 10, SOLVABLE_PREREQMARKER);
else if (!strncmp(buf + 1, "suggests@", 9))
s->suggests = parse_deps(s, buf + 10, 0);
else if (!strncmp(buf + 1, "obsoletes@", 10))
s->obsoletes = parse_deps(s, buf + 11, 0);
else if (!strncmp(buf + 1, "conflicts@", 10))
s->conflicts = parse_deps(s, buf + 11, 0);
else if (!strncmp(buf + 1, "info@", 5))
{
char *nvra = buf + 6;
char *epochstr;
char *arch;
char *version;
char *filename;
if ((epochstr = strchr(nvra, '@')) != 0)
{
char *sizestr;
*epochstr++ = 0;
if ((sizestr = strchr(epochstr, '@')) != 0)
{
char *groupstr;
*sizestr++ = 0;
if ((groupstr = strchr(sizestr, '@')) != 0)
{
char *n;
*groupstr++ = 0;
if ((n = strchr(groupstr, '@')) != 0)
*n = 0;
if (*groupstr)
repodata_set_poolstr(data, s - pool->solvables, SOLVABLE_GROUP, groupstr);
}
repodata_set_num(data, s - pool->solvables, SOLVABLE_INSTALLSIZE, strtoull(sizestr, 0, 10));
}
}
filename = pool_tmpjoin(pool, nvra, ".rpm", 0);
arch = strrchr(nvra, '.');
if (arch)
{
*arch++ = 0;
s->arch = pool_str2id(pool, arch, 1);
}
/* argh, do we have a distepoch or not, check self-provides */
if (s->provides)
{
Id id, lastid, *idp = s->repo->idarraydata + s->provides;
lastid = 0;
for (idp = s->repo->idarraydata + s->provides; (id = *idp) != 0; idp++)
{
const char *evr, *name;
int namel;
Reldep *rd;
if (!ISRELDEP(id))
continue;
rd = GETRELDEP(pool, id);
if (rd->flags != REL_EQ)
continue;
name = pool_id2str(pool, rd->name);
namel = strlen(name);
if (strncmp(name, nvra, namel) != 0 || nvra[namel] != '-')
continue;
evr = pool_id2str(pool, rd->evr);
evr = strrchr(evr, '-');
if (evr && strchr(evr, ':') != 0)
lastid = id;
}
if (lastid)
{
/* self provides found, and it contains a distepoch */
/* replace with self-provides distepoch to get rid of the disttag */
char *nvradistepoch = strrchr(nvra, '-');
if (nvradistepoch)
{
Reldep *rd = GETRELDEP(pool, lastid);
const char *evr = pool_id2str(pool, rd->evr);
evr = strrchr(evr, '-');
if (evr && (evr = strchr(evr, ':')) != 0)
{
if (strlen(evr) < strlen(nvradistepoch))
strcpy(nvradistepoch, evr);
}
}
}
}
version = strrchr(nvra, '-');
if (version)
{
char *release = version;
*release = 0;
version = strrchr(nvra, '-');
*release = '-';
if (!version)
version = release;
*version++ = 0;
}
else
version = "";
s->name = pool_str2id(pool, nvra, 1);
if (epochstr && *epochstr && strcmp(epochstr, "0") != 0)
{
char *evr = pool_tmpjoin(pool, epochstr, ":", version);
s->evr = pool_str2id(pool, evr, 1);
}
else
s->evr = pool_str2id(pool, version, 1);
repodata_set_location(data, s - pool->solvables, 0, 0, filename);
if (s->name && s->arch != ARCH_SRC && s->arch != ARCH_NOSRC)
s->provides = repo_addid_dep(s->repo, s->provides, pool_rel2id(pool, s->name, s->evr, REL_EQ, 1), 0);
s = 0;
}
else
{
char *tagend = strchr(buf + 1, '@');
if (tagend)
*tagend = 0;
pool_debug(pool, SOLV_ERROR, "unknown tag <%s>\n", buf + 1);
continue;
}
}
if (s)
{
pool_debug(pool, SOLV_ERROR, "unclosed package at EOF\n");
repo_free_solvable(s->repo, s - pool->solvables, 1);
}
solv_free(buf);
if (!(flags & REPO_NO_INTERNALIZE))
repodata_internalize(data);
return 0;
}
static int
nextchunk(struct solv_zchunk *zck, unsigned int streamid)
{
unsigned char *p = zck->chunks;
unsigned char *chunk_chk_ptr;
unsigned int sid, chunk_len, uncompressed_len;
unsigned char *cbuf;
/* free old buffer */
zck->buf = solv_free(zck->buf);
zck->buf_avail = 0;
zck->buf_used = 0;
for (;;)
{
if (zck->nchunks == 0)
{
zck->chunks = p;
return 1; /* EOF reached */
}
if (p >= zck->hdr_end)
return 0;
sid = streamid ? 1 : 0;
/* check if this is the correct stream */
if ((zck->flags & 1) != 0 && (p = getuint(p, zck->hdr_end, &sid)) == 0)
return 0;
chunk_chk_ptr = p; /* remember for verification */
p += zck->chunk_chk_len;
if (p >= zck->hdr_end)
return 0;
if ((p = getuint(p, zck->hdr_end, &chunk_len)) == 0)
return 0;
if ((p = getuint(p, zck->hdr_end, &uncompressed_len)) == 0)
return 0;
zck->nchunks--;
if (sid == streamid)
break;
/* skip the chunk, but the dict chunk must come first */
if (streamid == 0 || skip_bytes(zck->fp, chunk_len, zck->data_chk) == 0)
return 0;
}
zck->chunks = p;
/* ok, read the compressed chunk */
if (!chunk_len)
return uncompressed_len ? 0 : 1;
cbuf = solv_malloc(chunk_len);
if (fread(cbuf, chunk_len, 1, zck->fp) != 1)
{
solv_free(cbuf);
return 0;
}
if (zck->data_chk)
solv_chksum_add(zck->data_chk, cbuf, chunk_len);
/* verify the chunk checksum */
if (zck->chunk_chk_id)
{
Chksum *chk = solv_chksum_create(zck->chunk_chk_id);
if (!chk)
{
solv_free(cbuf);
return 0;
}
solv_chksum_add(chk, cbuf, chunk_len);
if (memcmp(solv_chksum_get(chk, 0), chunk_chk_ptr, zck->chunk_chk_len) != 0)
{
solv_chksum_free(chk, 0);
solv_free(cbuf);
return 0;
}
solv_chksum_free(chk, 0);
}
/* uncompress */
if (zck->comp == 0)
{
/* not compressed */
if (chunk_len != uncompressed_len)
{
solv_free(cbuf);
return 0;
}
zck->buf = cbuf;
zck->buf_avail = uncompressed_len;
return 1;
}
if (zck->comp == 2)
{
/* zstd compressed */
size_t r;
zck->buf = solv_malloc(uncompressed_len + 1); /* +1 so we can detect too large frames */
if (zck->ddict)
r = ZSTD_decompress_usingDDict(zck->dctx, zck->buf, uncompressed_len + 1, cbuf, chunk_len, zck->ddict);
else
r = ZSTD_decompressDCtx(zck->dctx, zck->buf, uncompressed_len + 1, cbuf, chunk_len);
solv_free(cbuf);
if (r != uncompressed_len)
return 0;
zck->buf_avail = uncompressed_len;
return 1;
}
solv_free(cbuf);
return 0;
}
static int gettarhead(struct tarhead *th)
{
int l, type;
long long length;
th->path = solv_free(th->path);
th->ispax = 0;
th->type = 0;
th->length = 0;
th->off = 0;
th->end = 0;
if (th->eof)
return 0;
for (;;)
{
int r = readblock(th->fp, th->blk);
if (r)
{
if (feof(th->fp))
{
th->eof = 1;
return 0;
}
return -1;
}
if (th->blk[0] == 0)
{
th->eof = 1;
return 0;
}
length = parsenum(th->blk + 124, 12);
if (length < 0)
return -1;
type = 0;
switch (th->blk[156])
{
case 'S': case '0':
type = 1; /* file */
break;
case '1':
/* hard link, special length magic... */
if (!th->ispax)
length = 0;
break;
case '5':
type = 2; /* dir */
break;
case '2': case '3': case '4': case '6':
length = 0;
break;
case 'X': case 'x': case 'L':
{
char *data, *pp;
if (length < 1 || length >= 1024 * 1024)
return -1;
l = length;
data = pp = solv_malloc(l + 512);
for (; l > 0; l -= 512, pp += 512)
if (readblock(th->fp, (unsigned char *)pp))
{
solv_free(data);
return -1;
}
type = 3; /* extension */
if (th->blk[156] == 'L')
{
solv_free(th->path);
th->path = data;
length = 0;
break;
}
pp = data;
while (length > 0)
{
int ll = 0;
int l;
for (l = 0; l < length && pp[l] >= '0' && pp[l] <= '9'; l++)
ll = ll * 10 + (pp[l] - '0');
if (l == length || pp[l] != ' ' || ll < 1 || ll > length || pp[ll - 1] != '\n')
{
solv_free(data);
return -1;
}
length -= ll;
pp += l + 1;
ll -= l + 1;
pp[ll - 1] = 0;
if (!strncmp(pp, "path=", 5))
{
solv_free(th->path);
th->path = solv_strdup(pp + 5);
}
pp += ll;
}
solv_free(data);
th->ispax = 1;
length = 0;
break;
}
default:
type = 3; /* extension */
break;
}
if ((type == 1 || type == 2) && !th->path)
{
char path[157];
memcpy(path, th->blk, 156);
path[156] = 0;
if (!memcmp(th->blk + 257, "ustar\0\060\060", 8) && !th->path && th->blk[345])
{
/* POSIX ustar with prefix */
char prefix[156];
memcpy(prefix, th->blk + 345, 155);
prefix[155] = 0;
l = strlen(prefix);
if (l && prefix[l - 1] == '/')
prefix[l - 1] = 0;
th->path = solv_dupjoin(prefix, "/", path);
}
else
th->path = solv_dupjoin(path, 0, 0);
}
if (type == 1 || type == 2)
{
l = strlen(th->path);
if (l && th->path[l - 1] == '/')
{
if (l > 1)
th->path[l - 1] = 0;
type = 2;
}
}
if (type != 3)
break;
while (length > 0)
{
r = readblock(th->fp, th->blk);
if (r)
return r;
length -= 512;
}
}
th->type = type;
th->length = length;
return 1;
}
int
repo_add_code11_products(Repo *repo, const char *dirpath, int flags)
{
Repodata *data;
struct parsedata pd;
struct stateswitch *sw;
DIR *dir;
int i;
data = repo_add_repodata(repo, flags);
memset(&pd, 0, sizeof(pd));
pd.repo = repo;
pd.pool = repo->pool;
pd.data = data;
pd.content = solv_malloc(256);
pd.acontent = 256;
for (i = 0, sw = stateswitches; sw->from != NUMSTATES; i++, sw++)
{
if (!pd.swtab[sw->from])
pd.swtab[sw->from] = sw;
pd.sbtab[sw->to] = sw->from;
}
if (flags & REPO_USE_ROOTDIR)
dirpath = pool_prepend_rootdir(repo->pool, dirpath);
dir = opendir(dirpath);
if (dir)
{
struct dirent *entry;
struct stat st;
char *fullpath;
/* check for <productsdir>/baseproduct on code11 and remember its target inode */
if (stat(join2(&pd.jd, dirpath, "/", "baseproduct"), &st) == 0) /* follow symlink */
pd.baseproduct = st.st_ino;
else
pd.baseproduct = 0;
while ((entry = readdir(dir)))
{
int len = strlen(entry->d_name);
FILE *fp;
if (len <= 5 || strcmp(entry->d_name + len - 5, ".prod") != 0)
continue;
fullpath = join2(&pd.jd, dirpath, "/", entry->d_name);
fp = fopen(fullpath, "r");
if (!fp)
{
pool_error(repo->pool, 0, "%s: %s", fullpath, strerror(errno));
continue;
}
pd.filename = fullpath;
pd.basename = entry->d_name;
add_code11_product(&pd, fp);
fclose(fp);
}
closedir(dir);
}
solv_free(pd.content);
join_freemem(&pd.jd);
if (flags & REPO_USE_ROOTDIR)
solv_free((char *)dirpath);
if (!(flags & REPO_NO_INTERNALIZE))
repodata_internalize(data);
return 0;
}
