int
read_installed_rpm(struct repoinfo *cinfo)
{
Repo *repo = cinfo->repo;
Pool *pool = repo->pool;
FILE *ofp = 0;
struct stat stb;
memset(&stb, 0, sizeof(stb));
printf("rpm database:");
if (stat(pool_prepend_rootdir_tmp(pool, "/var/lib/rpm/Packages"), &stb))
memset(&stb, 0, sizeof(stb));
calc_cookie_stat(&stb, REPOKEY_TYPE_SHA256, 0, cinfo->cookie);
cinfo->cookieset = 1;
if (usecachedrepo(cinfo, 0, 0))
{
printf(" cached\n");
return 1;
}
printf(" reading\n");
#if defined(ENABLE_SUSEREPO) && defined(PRODUCTS_PATH)
if (repo_add_products(repo, PRODUCTS_PATH, REPO_REUSE_REPODATA | REPO_NO_INTERNALIZE | REPO_USE_ROOTDIR))
{
fprintf(stderr, "product reading failed: %s\n", pool_errstr(pool));
return 0;
}
#endif
#if defined(ENABLE_APPDATA) && defined(APPDATA_PATH)
if (repo_add_appdata_dir(repo, APPDATA_PATH, REPO_REUSE_REPODATA | REPO_NO_INTERNALIZE | REPO_USE_ROOTDIR))
{
fprintf(stderr, "appdata reading failed: %s\n", pool_errstr(pool));
return 0;
}
#elif defined(ENABLE_APPDATA) && defined(APPDATA_LEGACY_PATH)
if (repo_add_appdata_dir(repo, APPDATA_LEGACY_PATH, REPO_REUSE_REPODATA | REPO_NO_INTERNALIZE | REPO_USE_ROOTDIR))
{
fprintf(stderr, "appdata reading from legacy dir failed: %s\n", pool_errstr(pool));
return 0;
}
#endif
ofp = fopen(calc_cachepath(repo, 0, 0), "r");
if (repo_add_rpmdb_reffp(repo, ofp, REPO_REUSE_REPODATA | REPO_NO_INTERNALIZE | REPO_USE_ROOTDIR))
{
fprintf(stderr, "installed db: %s\n", pool_errstr(pool));
return 0;
}
if (ofp)
fclose(ofp);
repo_internalize(repo);
#ifdef SUSE
repo_add_autopattern(repo, 0);
#endif
writecachedrepo(cinfo, 0, 0);
return 1;
}
int
main(int argc, char **argv)
{
Pool *pool;
Repo *repo;
int with_attr = 0;
#ifdef SUSE
int add_auto = 0;
#endif
int c;
pool = pool_create();
repo = repo_create(pool, "<mergesolv>");
while ((c = getopt(argc, argv, "ahX")) >= 0)
{
switch (c)
{
case 'h':
usage();
break;
case 'a':
with_attr = 1;
break;
case 'X':
#ifdef SUSE
add_auto = 1;
#endif
break;
default:
usage();
exit(1);
}
}
if (with_attr)
pool_setloadcallback(pool, loadcallback, 0);
for (; optind < argc; optind++)
{
FILE *fp;
if ((fp = fopen(argv[optind], "r")) == NULL)
{
perror(argv[optind]);
exit(1);
}
if (repo_add_solv(repo, fp, 0))
{
fprintf(stderr, "repo %s: %s\n", argv[optind], pool_errstr(pool));
exit(1);
}
fclose(fp);
}
#ifdef SUSE
if (add_auto)
repo_add_autopattern(repo, 0);
#endif
tool_write(repo, stdout);
pool_free(pool);
return 0;
}
int
read_installed_debian(struct repoinfo *cinfo)
{
struct stat stb;
Repo *repo = cinfo->repo;
Pool *pool = repo->pool;
memset(&stb, 0, sizeof(stb));
printf("dpgk database:");
if (stat(pool_prepend_rootdir_tmp(pool, "/var/lib/dpkg/status"), &stb))
memset(&stb, 0, sizeof(stb));
calc_cookie_stat(&stb, REPOKEY_TYPE_SHA256, 0, cinfo->cookie);
cinfo->cookieset = 1;
if (usecachedrepo(cinfo, 0, 0))
{
printf(" cached\n");
return 1;
}
if (repo_add_debdb(repo, REPO_REUSE_REPODATA | REPO_NO_INTERNALIZE | REPO_USE_ROOTDIR))
{
fprintf(stderr, "installed db: %s\n", pool_errstr(pool));
return 0;
}
repo_internalize(repo);
writecachedrepo(cinfo, 0, 0);
return 1;
}
int
main(int argc, char **argv)
{
int c, flags = 0;
char *attrname = 0;
Pool *pool = pool_create();
Repo *repo = repo_create(pool, "<stdin>");
while ((c = getopt(argc, argv, "hn:")) >= 0)
{
switch(c)
{
case 'h':
usage(0);
break;
case 'n':
attrname = optarg;
break;
default:
usage(1);
break;
}
}
if (repo_add_updateinfoxml(repo, stdin, flags))
{
fprintf(stderr, "updateinfoxml2solv: %s\n", pool_errstr(pool));
exit(1);
}
tool_write(repo, 0, attrname);
pool_free(pool);
exit(0);
}
int main(int argc, char **argv)
{
Pool *pool;
Repo *installed;
Solvable *s;
Id p;
int i;
Queue todo, conflicts;
void *state = 0;
pool = pool_create();
pool_setdebuglevel(pool, 1);
installed = repo_create(pool, "@System");
pool_set_installed(pool, installed);
if (repo_add_rpmdb(installed, 0, 0))
{
fprintf(stderr, "findfileconflicts: %s\n", pool_errstr(pool));
exit(1);
}
queue_init(&todo);
queue_init(&conflicts);
FOR_REPO_SOLVABLES(installed, p, s)
queue_push(&todo, p);
pool_findfileconflicts(pool, &todo, 0, &conflicts, &iterate_handle, (void *)&state);
queue_free(&todo);
for (i = 0; i < conflicts.count; i += 5)
printf("%s: %s[%s] %s[%s]\n", pool_id2str(pool, conflicts.elements[i]), pool_solvid2str(pool, conflicts.elements[i + 1]), pool_id2str(pool, conflicts.elements[i + 2]), pool_solvid2str(pool, conflicts.elements[i + 3]), pool_id2str(pool, conflicts.elements[i + 4]));
if (conflicts.count)
{
Queue job;
int problemcnt;
queue_init(&job);
pool_add_fileconflicts_deps(pool, &conflicts);
pool_addfileprovides(pool);
pool_createwhatprovides(pool);
pool_setdebuglevel(pool, 0);
Solver *solv = solver_create(pool);
queue_push2(&job, SOLVER_VERIFY|SOLVER_SOLVABLE_ALL, 0);
#if 0
solver_set_flag(solv, SOLVER_FLAG_ALLOW_UNINSTALL, 1);
#endif
problemcnt = solver_solve(solv, &job);
if (problemcnt)
solver_printallsolutions(solv);
else
{
Transaction *trans = solver_create_transaction(solv);
transaction_print(trans);
transaction_free(trans);
}
queue_free(&job);
solver_free(solv);
}
queue_free(&conflicts);
exit(0);
}
int
main(int argc, char **argv)
{
Pool *pool;
Repo *repo;
const char *basefile = 0;
int with_attr = 0;
int c;
pool = pool_create();
repo = repo_create(pool, "<mergesolv>");
while ((c = getopt(argc, argv, "ahb:")) >= 0)
{
switch (c)
{
case 'h':
usage();
break;
case 'a':
with_attr = 1;
break;
case 'b':
basefile = optarg;
break;
default:
exit(1);
}
}
if (with_attr)
pool_setloadcallback(pool, loadcallback, 0);
for (; optind < argc; optind++)
{
FILE *fp;
if ((fp = fopen(argv[optind], "r")) == NULL)
{
perror(argv[optind]);
exit(1);
}
if (repo_add_solv(repo, fp, 0))
{
fprintf(stderr, "repo %s: %s\n", argv[optind], pool_errstr(pool));
exit(1);
}
fclose(fp);
}
tool_write(repo, basefile, 0);
pool_free(pool);
return 0;
}
int
main(int argc, char **argv)
{
Pool *pool = pool_create();
Repo *repo = repo_create(pool, "<stdin>");
if (repo_add_appdata(repo, stdin, 0))
{
fprintf(stderr, "appdata2solv: %s\n", pool_errstr(pool));
exit(1);
}
tool_write(repo, 0, 0);
pool_free(pool);
exit(0);
}
int
susetags_load_ext(Repo *repo, Repodata *data)
{
const char *filename, *descrdir;
Id defvendor;
char ext[3];
FILE *fp;
struct repoinfo *cinfo;
const unsigned char *filechksum;
Id filechksumtype;
int flags;
cinfo = repo->appdata;
filename = repodata_lookup_str(data, SOLVID_META, SUSETAGS_FILE_NAME);
if (!filename)
return 0;
/* susetags load */
ext[0] = filename[9];
ext[1] = filename[10];
ext[2] = 0;
printf("[%s:%s", repo->name, ext);
if (usecachedrepo(cinfo, ext, 0))
{
printf(" cached]\n"); fflush(stdout);
return 1;
}
printf(" fetching]\n"); fflush(stdout);
defvendor = repo_lookup_id(repo, SOLVID_META, SUSETAGS_DEFAULTVENDOR);
descrdir = repo_lookup_str(repo, SOLVID_META, SUSETAGS_DESCRDIR);
if (!descrdir)
descrdir = "suse/setup/descr";
filechksumtype = 0;
filechksum = repodata_lookup_bin_checksum(data, SOLVID_META, SUSETAGS_FILE_CHECKSUM, &filechksumtype);
if ((fp = curlfopen(cinfo, pool_tmpjoin(repo->pool, descrdir, "/", filename), 1, filechksum, filechksumtype, 0)) == 0)
return 0;
flags = REPO_USE_LOADING|REPO_EXTEND_SOLVABLES;
if (strcmp(ext, "DL") != 0)
flags |= REPO_LOCALPOOL;
if (repo_add_susetags(repo, fp, defvendor, ext, flags))
{
fclose(fp);
printf("%s\n", pool_errstr(repo->pool));
return 0;
}
fclose(fp);
writecachedrepo(cinfo, ext, data);
return 1;
}
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 && !nopacks)
{
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
*/
if (root && *root)
pool_set_rootdir(pool, root);
repo = repo_create(pool, "installed");
data = repo_add_repodata(repo, 0);
if (!nopacks)
{
if (repo_add_rpmdb(repo, ref, REPO_USE_ROOTDIR | 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)
{
if (root && *root)
{
int rootlen = strlen(root);
if (!strncmp(root, proddir, rootlen))
{
proddir += rootlen;
if (*proddir != '/' && proddir[-1] == '/')
proddir--;
}
}
if (repo_add_products(repo, proddir, REPO_USE_ROOTDIR | REPO_REUSE_REPODATA | REPO_NO_INTERNALIZE))
{
fprintf(stderr, "rpmdb2solv: %s\n", pool_errstr(pool));
exit(1);
}
}
#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 **debs = 0;
char *manifest = 0;
int manifest0 = 0;
int c, i, res, ndebs = 0;
Pool *pool = pool_create();
Repo *repo;
FILE *fp;
char buf[4096], *p;
const char *basefile = 0;
int is_repo = 0;
while ((c = getopt(argc, argv, "0b:m:r")) >= 0)
{
switch(c)
{
case 'b':
basefile = optarg;
break;
case 'm':
manifest = optarg;
break;
case 'r':
is_repo = 1;
break;
case '0':
manifest0 = 1;
break;
default:
exit(1);
}
}
if (manifest)
{
if (!strcmp(manifest, "-"))
fp = stdin;
else if ((fp = fopen(manifest, "r")) == 0)
{
perror(manifest);
exit(1);
}
for (;;)
{
if (manifest0)
{
if (!fgets0(buf, sizeof(buf), fp))
break;
}
else
{
if (!fgets(buf, sizeof(buf), fp))
break;
if ((p = strchr(buf, '\n')) != 0)
*p = 0;
}
debs = solv_extend(debs, ndebs, 1, sizeof(char *), 15);
debs[ndebs++] = strdup(buf);
}
if (fp != stdin)
fclose(fp);
}
while (optind < argc)
{
debs = solv_extend(debs, ndebs, 1, sizeof(char *), 15);
debs[ndebs++] = strdup(argv[optind++]);
}
repo = repo_create(pool, "deb2solv");
repo_add_repodata(repo, 0);
res = 0;
if (!ndebs && !manifest && is_repo)
{
if (repo_add_debpackages(repo, stdin, REPO_REUSE_REPODATA|REPO_NO_INTERNALIZE))
{
fprintf(stderr, "deb2solv: %s\n", pool_errstr(pool));
res = 1;
}
}
for (i = 0; i < ndebs; i++)
{
if (is_repo)
{
if ((fp = fopen(debs[i], "r")) == 0)
{
perror(debs[i]);
res = 1;
continue;
}
if (repo_add_debpackages(repo, fp, REPO_REUSE_REPODATA|REPO_NO_INTERNALIZE))
{
fprintf(stderr, "deb2solv: %s\n", pool_errstr(pool));
res = 1;
}
fclose(fp);
continue;
}
if (repo_add_deb(repo, debs[i], REPO_REUSE_REPODATA|REPO_NO_INTERNALIZE) == 0)
{
fprintf(stderr, "deb2solv: %s\n", pool_errstr(pool));
res = 1;
}
}
repo_internalize(repo);
tool_write(repo, basefile, 0);
pool_free(pool);
for (c = 0; c < ndebs; c++)
free((char *)debs[c]);
solv_free(debs);
exit(res);
}
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);
}
int
susetags_load(struct repoinfo *cinfo, Pool **sigpoolp)
{
Repo *repo = cinfo->repo;
Pool *pool = repo->pool;
Repodata *data;
const char *filename;
const unsigned char *filechksum;
Id filechksumtype;
FILE *fp;
const char *descrdir;
int defvendor;
printf("susetags repo '%s':", cinfo->alias);
fflush(stdout);
descrdir = 0;
defvendor = 0;
if ((fp = curlfopen(cinfo, "content", 0, 0, 0, 0)) == 0)
{
printf(" no content file\n");
cinfo->incomplete = 1;
return 0;
}
calc_cookie_fp(fp, REPOKEY_TYPE_SHA256, cinfo->cookie);
cinfo->cookieset = 1;
if (usecachedrepo(cinfo, 0, 1))
{
printf(" cached\n");
fclose(fp);
return 1;
}
if (cinfo->repo_gpgcheck && !downloadchecksig(cinfo, fp, "content.asc", sigpoolp))
{
fclose(fp);
cinfo->incomplete = 1;
return 0;
}
if (repo_add_content(repo, fp, 0))
{
printf("content: %s\n", pool_errstr(pool));
fclose(fp);
cinfo->incomplete = 1;
return 0;
}
fclose(fp);
defvendor = repo_lookup_id(repo, SOLVID_META, SUSETAGS_DEFAULTVENDOR);
descrdir = repo_lookup_str(repo, SOLVID_META, SUSETAGS_DESCRDIR);
if (!descrdir)
descrdir = "suse/setup/descr";
filename = susetags_find(repo, "packages.gz", &filechksum, &filechksumtype);
if (!filename)
filename = susetags_find(repo, "packages", &filechksum, &filechksumtype);
if (!filename)
{
printf(" no packages file entry, skipped\n");
cinfo->incomplete = 1;
return 0;
}
printf(" fetching\n");
if ((fp = curlfopen(cinfo, pool_tmpjoin(pool, descrdir, "/", filename), 1, filechksum, filechksumtype, 1)) == 0)
{
cinfo->incomplete = 1;
return 0; /* hopeless */
}
if (repo_add_susetags(repo, fp, defvendor, 0, REPO_NO_INTERNALIZE|SUSETAGS_RECORD_SHARES))
{
printf("packages: %s\n", pool_errstr(pool));
fclose(fp);
cinfo->incomplete = 1;
return 0; /* hopeless */
}
fclose(fp);
/* add default language */
filename = susetags_find(repo, "packages.en.gz", &filechksum, &filechksumtype);
if (!filename)
filename = susetags_find(repo, "packages.en", &filechksum, &filechksumtype);
if (filename)
{
if ((fp = curlfopen(cinfo, pool_tmpjoin(pool, descrdir, "/", filename), 1, filechksum, filechksumtype, 1)) != 0)
{
if (repo_add_susetags(repo, fp, defvendor, 0, REPO_NO_INTERNALIZE|REPO_REUSE_REPODATA|REPO_EXTEND_SOLVABLES))
{
printf("packages.en: %s\n", pool_errstr(pool));
cinfo->incomplete = 1;
}
fclose(fp);
}
}
filename = susetags_find(repo, "patterns", &filechksum, &filechksumtype);
if (filename)
{
if ((fp = curlfopen(cinfo, pool_tmpjoin(pool, descrdir, "/", filename), 1, filechksum, filechksumtype, 1)) != 0)
{
char pbuf[256];
while (fgets(pbuf, sizeof(pbuf), fp))
{
int l = strlen(pbuf);
FILE *fp2;
if (l && pbuf[l - 1] == '\n')
pbuf[--l] = 0;
if (!*pbuf || *pbuf == '.' || strchr(pbuf, '/') != 0)
continue;
filename = susetags_find(repo, pbuf, &filechksum, &filechksumtype);
if (filename && (fp2 = curlfopen(cinfo, pool_tmpjoin(pool, descrdir, "/", filename), 1, filechksum, filechksumtype, 1)) != 0)
{
if (repo_add_susetags(repo, fp2, defvendor, 0, REPO_NO_INTERNALIZE))
{
printf("%s: %s\n", pbuf, pool_errstr(pool));
cinfo->incomplete = 1;
}
fclose(fp2);
}
}
fclose(fp);
}
}
#ifdef ENABLE_APPDATA
filename = susetags_find(repo, "appdata.xml.gz", &filechksum, &filechksumtype);
if (!filename)
filename = susetags_find(repo, "appdata.xml", &filechksum, &filechksumtype);
if (filename && (fp = curlfopen(cinfo, pool_tmpjoin(pool, descrdir, "/", filename), 1, filechksum, filechksumtype, 1)) != 0)
{
if (repo_add_appdata(repo, fp, 0))
{
printf("appdata: %s\n", pool_errstr(pool));
cinfo->incomplete = 1;
}
fclose(fp);
}
#endif
repo_internalize(repo);
#ifdef SUSE
repo_add_autopattern(repo, 0);
#endif
data = repo_add_repodata(repo, 0);
repodata_extend_block(data, repo->start, repo->end - repo->start);
susetags_add_ext(repo, data);
repodata_internalize(data);
writecachedrepo(cinfo, 0, 0);
repodata_create_stubs(repo_last_repodata(repo));
return 1;
}
int
main(int argc, char **argv)
{
const char **rpms = 0;
char *manifest = 0;
int manifest0 = 0;
int c, i, res, nrpms = 0;
Pool *pool = pool_create();
Repo *repo;
FILE *fp;
char buf[4096], *p;
const char *basefile = 0;
#ifdef ENABLE_PUBKEY
int pubkeys = 0;
#endif
while ((c = getopt(argc, argv, "0kKb:m:")) >= 0)
{
switch(c)
{
case 'b':
basefile = optarg;
break;
case 'm':
manifest = optarg;
break;
case '0':
manifest0 = 1;
break;
#ifdef ENABLE_PUBKEY
case 'k':
pubkeys = 1;
break;
case 'K':
pubkeys = 2;
break;
#endif
default:
exit(1);
}
}
if (manifest)
{
if (!strcmp(manifest, "-"))
fp = stdin;
else if ((fp = fopen(manifest, "r")) == 0)
{
perror(manifest);
exit(1);
}
for (;;)
{
if (manifest0)
{
if (!fgets0(buf, sizeof(buf), fp))
break;
}
else
{
if (!fgets(buf, sizeof(buf), fp))
break;
if ((p = strchr(buf, '\n')) != 0)
*p = 0;
}
rpms = solv_extend(rpms, nrpms, 1, sizeof(char *), 15);
rpms[nrpms++] = strdup(buf);
}
if (fp != stdin)
fclose(fp);
}
while (optind < argc)
{
rpms = solv_extend(rpms, nrpms, 1, sizeof(char *), 15);
rpms[nrpms++] = strdup(argv[optind++]);
}
repo = repo_create(pool, "rpms2solv");
repo_add_repodata(repo, 0);
res = 0;
for (i = 0; i < nrpms; i++)
{
#ifdef ENABLE_PUBKEY
if (pubkeys == 2)
{
FILE *fp = solv_xfopen(rpms[i], "r");
if (!fp)
{
perror(rpms[i]);
res = 1;
continue;
}
if (repo_add_keyring(repo, fp, REPO_REUSE_REPODATA|REPO_NO_INTERNALIZE|ADD_WITH_KEYSIGNATURES))
{
fprintf(stderr, "rpms2solv: %s\n", pool_errstr(pool));
res = 1;
}
fclose(fp);
continue;
}
if (pubkeys)
{
if (repo_add_pubkey(repo, rpms[i], REPO_REUSE_REPODATA|REPO_NO_INTERNALIZE|ADD_WITH_KEYSIGNATURES) == 0)
{
fprintf(stderr, "rpms2solv: %s\n", pool_errstr(pool));
res = 1;
}
continue;
}
#endif
if (repo_add_rpm(repo, rpms[i], REPO_REUSE_REPODATA|REPO_NO_INTERNALIZE) == 0)
{
fprintf(stderr, "rpms2solv: %s\n", pool_errstr(pool));
res = 1;
}
}
repo_internalize(repo);
tool_write(repo, basefile, 0);
pool_free(pool);
for (c = 0; c < nrpms; c++)
free((char *)rpms[c]);
solv_free(rpms);
exit(res);
}
int
main(int argc, char **argv)
{
Pool *pool;
Repo *repo;
char *infofile = 0, *filesfile = 0;
int c;
while ((c = getopt(argc, argv, "hi:f:")) >= 0)
{
switch(c)
{
case 'h':
usage(0);
break;
case 'i':
infofile = optarg;
break;
case 'f':
filesfile = optarg;
break;
default:
usage(1);
break;
}
}
pool = pool_create();
repo = repo_create(pool, "<stdin>");
if (repo_add_mdk(repo, stdin, REPO_NO_INTERNALIZE))
{
fprintf(stderr, "mdk2solv: %s\n", pool_errstr(pool));
exit(1);
}
if (infofile)
{
FILE *fp = solv_xfopen(infofile, "r");
if (!fp)
{
perror(infofile);
exit(1);
}
if (repo_add_mdk_info(repo, fp, REPO_EXTEND_SOLVABLES | REPO_REUSE_REPODATA | REPO_NO_INTERNALIZE))
{
fprintf(stderr, "mdk2solv: %s\n", pool_errstr(pool));
exit(1);
}
fclose(fp);
}
if (filesfile)
{
FILE *fp = solv_xfopen(filesfile, "r");
if (!fp)
{
perror(filesfile);
exit(1);
}
if (repo_add_mdk_info(repo, fp, REPO_EXTEND_SOLVABLES | REPO_REUSE_REPODATA | REPO_NO_INTERNALIZE))
{
fprintf(stderr, "mdk2solv: %s\n", pool_errstr(pool));
exit(1);
}
fclose(fp);
}
repo_internalize(repo);
tool_write(repo, 0, 0);
pool_free(pool);
exit(0);
}
int
main(int argc, char **argv)
{
FILE *reffp = 0;
Pool *pool = pool_create();
Repo *repo;
Repodata *data;
int c, percent = 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;
#ifdef ENABLE_PUBKEY
int pubkeys = 0;
#endif
#ifdef ENABLE_APPDATA
int add_appdata = 0;
#endif
#ifdef SUSE
int add_auto = 0;
#endif
/*
* parse arguments
*/
while ((c = getopt(argc, argv, "APhnkxXb: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':
break; /* extrapool no longer supported */
case 'X':
#ifdef SUSE
add_auto = 1;
#endif
break;
case 'A':
#ifdef ENABLE_APPDATA
add_appdata = 1;
#endif
break;
case 'o':
outfile = optarg;
break;
#ifdef ENABLE_PUBKEY
case 'k':
nopacks = 1;
pubkeys = 1;
break;
#endif
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 && !nopacks)
{
if ((reffp = fopen(refname, "r")) == NULL)
perror(refname);
}
/*
* create 'installed' repository
* add products
* add rpmdb
* write .solv
*/
if (root && *root)
pool_set_rootdir(pool, root);
repo = repo_create(pool, "installed");
data = repo_add_repodata(repo, 0);
if (!nopacks)
{
if (repo_add_rpmdb_reffp(repo, reffp, REPO_USE_ROOTDIR | REPO_REUSE_REPODATA | REPO_NO_INTERNALIZE | (percent ? RPMDB_REPORT_PROGRESS : 0)))
{
fprintf(stderr, "rpmdb2solv: %s\n", pool_errstr(pool));
exit(1);
}
}
#ifdef ENABLE_PUBKEY
if (pubkeys)
{
if (repo_add_rpmdb_pubkeys(repo, REPO_USE_ROOTDIR | REPO_REUSE_REPODATA | REPO_NO_INTERNALIZE | ADD_WITH_KEYSIGNATURES))
{
fprintf(stderr, "rpmdb2solv: %s\n", pool_errstr(pool));
exit(1);
}
}
#endif
#ifdef ENABLE_SUSEREPO
if (proddir && *proddir)
{
if (root && *root)
{
int rootlen = strlen(root);
if (!strncmp(root, proddir, rootlen))
{
proddir += rootlen;
if (*proddir != '/' && proddir[-1] == '/')
proddir--;
}
}
if (repo_add_products(repo, proddir, REPO_USE_ROOTDIR | REPO_REUSE_REPODATA | REPO_NO_INTERNALIZE))
{
fprintf(stderr, "rpmdb2solv: %s\n", pool_errstr(pool));
exit(1);
}
}
#endif
#ifdef ENABLE_APPDATA
if (add_appdata)
{
repo_add_appdata_dir(repo, "/usr/share/metainfo", REPO_USE_ROOTDIR | REPO_REUSE_REPODATA | REPO_NO_INTERNALIZE | APPDATA_SEARCH_UNINTERNALIZED_FILELIST);
repo_add_appdata_dir(repo, "/usr/share/appdata", REPO_USE_ROOTDIR | REPO_REUSE_REPODATA | REPO_NO_INTERNALIZE | APPDATA_SEARCH_UNINTERNALIZED_FILELIST);
}
#endif
repodata_internalize(data);
if (reffp)
fclose(reffp);
#ifdef SUSE
if (add_auto)
repo_add_autopattern(repo, ADD_NO_AUTOPRODUCTS);
#endif
tool_write(repo, basefile, 0);
pool_free(pool);
exit(0);
}
