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; } } repo_add_deltainfoxml(repo, stdin, flags); tool_write(repo, 0, attrname); pool_free(pool); exit(0); }
int main(int argc, char **argv) { int c, flags = 0; const char *query = 0; Pool *pool = pool_create(); Repo *repo = repo_create(pool, "<stdin>"); while ((c = getopt (argc, argv, "hq:")) >= 0) { switch(c) { case 'h': usage(0); break; case 'q': query = optarg; break; default: usage(1); break; } } repo_add_repomdxml(repo, stdin, flags); if (query) doquery(pool, repo, query); else tool_write(repo, 0, 0); pool_free(pool); exit(0); }
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 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); }
Pool * read_sigs() { Pool *sigpool = pool_create(); #if defined(ENABLE_PUBKEY) && defined(ENABLE_RPMDB) Repo *repo = repo_create(sigpool, "pubkeys"); repo_add_rpmdb_pubkeys(repo, 0); #endif return sigpool; }
int main(int argc, char **argv) { Pool *pool = pool_create(); Repo *repo = repo_create(pool, "<stdin>"); repo_add_helix(repo, stdin, 0); tool_write(repo, 0, 0); pool_free(pool); 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 main() { 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); repo_add_rpmdb(installed, 0, 0, 0); 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", id2str(pool, conflicts.elements[i]), solvid2str(pool, conflicts.elements[i + 1]), id2str(pool, conflicts.elements[i + 2]), solvid2str(pool, conflicts.elements[i + 3]), id2str(pool, conflicts.elements[i + 4])); if (conflicts.count) { Queue job; queue_init(&job); pool_add_fileconflicts_deps(pool, &conflicts); pool_addfileprovides(pool); pool_createwhatprovides(pool); pool_setdebuglevel(pool, 0); Solver *solv = solver_create(pool); solv->fixsystem = 1; #if 0 solv->allowuninstall = 1; #endif solver_solve(solv, &job); if (solv->problems.count) solver_printallsolutions(solv); else solver_printtransaction(solv); queue_free(&job); solver_free(solv); } queue_free(&conflicts); exit(0); }
ModulePackageContainer::ModulePackageContainer(bool allArch, std::string installRoot, const char * arch) : pImpl(new Impl) { if (allArch) { dnf_sack_set_all_arch(pImpl->moduleSack, TRUE); } else { dnf_sack_set_arch(pImpl->moduleSack, arch, NULL); } Pool * pool = dnf_sack_get_pool(pImpl->moduleSack); HyRepo hrepo = hy_repo_create("available"); auto repoImpl = libdnf::repoGetImpl(hrepo); LibsolvRepo *repo = repo_create(pool, "available"); repo->appdata = hrepo; repoImpl->libsolvRepo = repo; repoImpl->needs_internalizing = 1; pImpl->installRoot = installRoot; }
int load_repo(Pool *pool, const char *name, const char *path, int installed) { HyRepo hrepo = hy_repo_create(name); Repo *r = repo_create(pool, name); hrepo->libsolv_repo = r; r->appdata = hrepo; FILE *fp = fopen(path, "r"); if (!fp) return 1; testcase_add_testtags(r, fp, 0); if (installed) pool_set_installed(pool, r); fclose(fp); return 0; }
int main(int argc, char **argv) { int flags = 0; char *attrname = 0; Pool *pool = pool_create(); Repo *repo = repo_create(pool, "<stdin>"); argv++; argc--; while (argc--) { const char *s = argv[0]; if (*s++ == '-') while (*s) switch (*s++) { case 'h': usage(NULL); break; case 'n': if (argc) { attrname = argv[1]; argv++; argc--; } else usage("argument required for '-n'"); break; case 'k': break; default : break; } argv++; } repo_add_diskusagexml(repo, stdin, flags); tool_write(repo, 0, 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) { 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 *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); }
Id ModulePackage::createPlatformSolvable(DnfSack * sack, DnfSack * moduleSack, const std::vector<std::string> & osReleasePaths, const std::string install_root, const char * platformModule) { std::pair<std::string, std::string> parsedPlatform; std::string name; std::string stream; if (platformModule) { parsedPlatform = parsePlatform(platformModule); if (!parsedPlatform.first.empty() && !parsedPlatform.second.empty()) { name = parsedPlatform.first; stream = parsedPlatform.second; } else { throw std::runtime_error( tfm::format(_("Invalid format of Platform module: %s"), platformModule)); } } else if (sack) { Query baseQuery(sack); baseQuery.addFilter(HY_PKG_PROVIDES, HY_EQ, "system-release"); baseQuery.addFilter(HY_PKG_LATEST, HY_EQ, 1); baseQuery.apply(); Query availableQuery(baseQuery); availableQuery.addFilter(HY_PKG_REPONAME, HY_NEQ, HY_SYSTEM_REPO_NAME); auto platform = availableQuery.getStringsFromProvide("base-module"); auto platformSize = platform.size(); if (platformSize == 1) { parsedPlatform = parsePlatform(*platform.begin()); } else if (platformSize > 1) { auto logger(Log::getLogger()); logger->debug(_("Multiple module platforms provided by available packages\n")); } if (!parsedPlatform.first.empty() && !parsedPlatform.second.empty()) { name = parsedPlatform.first; stream = parsedPlatform.second; } else { baseQuery.addFilter(HY_PKG_REPONAME, HY_EQ, HY_SYSTEM_REPO_NAME); platform = baseQuery.getStringsFromProvide("base-module"); platformSize = platform.size(); if (platformSize == 1) { parsedPlatform = parsePlatform(*platform.begin()); } else if (platformSize > 1) { auto logger(Log::getLogger()); logger->debug(_("Multiple module platforms provided by installed packages\n")); } if (!parsedPlatform.first.empty() && !parsedPlatform.second.empty()) { name = parsedPlatform.first; stream = parsedPlatform.second; } } } if (name.empty() || stream.empty()) { for (auto & osReleasePath: osReleasePaths) { std::string path; if (install_root == "/") { path = osReleasePath; } else { if (install_root.back() == '/') { path = install_root.substr(0, install_root.size() -1); } else { path = install_root; } path += osReleasePath; } std::pair<std::string, std::string> platform; try { platform = getPlatformStream(path); } catch (const std::exception & except) { auto logger(Log::getLogger()); logger->debug(tfm::format(_("Detection of Platform Module in %s failed: %s"), osReleasePath, std::string(except.what()))); } if (!platform.first.empty() && !platform.second.empty()) { name = platform.first; stream = platform.second; break; } else { auto logger(Log::getLogger()); logger->debug(tfm::format(_("Missing PLATFORM_ID in %s"), osReleasePath)); } } } if (name.empty() || stream.empty()) { throw std::runtime_error(_("No valid Platform ID detected")); } std::string version = "0"; std::string context = "00000000"; Pool * pool = dnf_sack_get_pool(moduleSack); HyRepo hrepo = hy_repo_create(HY_SYSTEM_REPO_NAME); auto repoImpl = libdnf::repoGetImpl(hrepo); LibsolvRepo *repo = repo_create(pool, HY_SYSTEM_REPO_NAME); repo->appdata = hrepo; repoImpl->libsolvRepo = repo; repoImpl->needs_internalizing = 1; Id id = repo_add_solvable(repo); Solvable *solvable = pool_id2solvable(pool, id); setSovable(pool, solvable, name, stream, version, context, "noarch"); repoImpl->needs_internalizing = 1; dnf_sack_set_provides_not_ready(moduleSack); dnf_sack_set_considered_to_update(moduleSack); pool_set_installed(pool, repo); return id; }
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); }
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) { Pool *pool; Repo *commandlinerepo = 0; Id *commandlinepkgs = 0; Id p; struct repoinfo *repoinfos, installedrepoinfo; int nrepoinfos = 0; int mainmode = 0, mode = 0; int i, newpkgs; Queue job, checkq; Solver *solv = 0; Transaction *trans; FILE **newpkgsfps; Queue repofilter; Queue kindfilter; Queue archfilter; int archfilter_src = 0; int cleandeps = 0; int forcebest = 0; char *rootdir = 0; char *keyname = 0; int keyname_depstr = 0; int debuglevel = 0; int answer, acnt = 0; argc--; argv++; while (argc && !strcmp(argv[0], "-d")) { debuglevel++; argc--; argv++; } if (!argv[0]) usage(1); if (!strcmp(argv[0], "install") || !strcmp(argv[0], "in")) { mainmode = MODE_INSTALL; mode = SOLVER_INSTALL; } #if defined(SUSE) || defined(FEDORA) else if (!strcmp(argv[0], "patch")) { mainmode = MODE_PATCH; mode = SOLVER_INSTALL; } #endif else if (!strcmp(argv[0], "erase") || !strcmp(argv[0], "rm")) { mainmode = MODE_ERASE; mode = SOLVER_ERASE; } else if (!strcmp(argv[0], "list") || !strcmp(argv[0], "ls")) { mainmode = MODE_LIST; mode = 0; } else if (!strcmp(argv[0], "info")) { mainmode = MODE_INFO; mode = 0; } else if (!strcmp(argv[0], "search") || !strcmp(argv[0], "se")) { mainmode = MODE_SEARCH; mode = 0; } else if (!strcmp(argv[0], "verify")) { mainmode = MODE_VERIFY; mode = SOLVER_VERIFY; } else if (!strcmp(argv[0], "update") || !strcmp(argv[0], "up")) { mainmode = MODE_UPDATE; mode = SOLVER_UPDATE; } else if (!strcmp(argv[0], "dist-upgrade") || !strcmp(argv[0], "dup")) { mainmode = MODE_DISTUPGRADE; mode = SOLVER_DISTUPGRADE; } else if (!strcmp(argv[0], "repos") || !strcmp(argv[0], "repolist") || !strcmp(argv[0], "lr")) { mainmode = MODE_REPOLIST; mode = 0; } else usage(1); for (;;) { if (argc > 2 && !strcmp(argv[1], "--root")) { rootdir = argv[2]; argc -= 2; argv += 2; } else if (argc > 1 && !strcmp(argv[1], "--clean")) { cleandeps = 1; argc--; argv++; } else if (argc > 1 && !strcmp(argv[1], "--best")) { forcebest = 1; argc--; argv++; } else if (argc > 1 && !strcmp(argv[1], "--depstr")) { keyname_depstr = 1; argc--; argv++; } else if (argc > 2 && !strcmp(argv[1], "--keyname")) { keyname = argv[2]; argc -= 2; argv += 2; } else break; } set_userhome(); pool = pool_create(); pool_set_rootdir(pool, rootdir); #if 0 { const char *langs[] = {"de_DE", "de", "en"}; pool_set_languages(pool, langs, sizeof(langs)/sizeof(*langs)); } #endif pool_setloadcallback(pool, load_stub, 0); #ifdef SUSE pool->nscallback = nscallback; #endif if (debuglevel) pool_setdebuglevel(pool, debuglevel); setarch(pool); pool_set_flag(pool, POOL_FLAG_ADDFILEPROVIDESFILTERED, 1); repoinfos = read_repoinfos(pool, &nrepoinfos); sort_repoinfos(repoinfos, nrepoinfos); if (mainmode == MODE_REPOLIST) { int j = 1; for (i = 0; i < nrepoinfos; i++) { struct repoinfo *cinfo = repoinfos + i; if (!cinfo->enabled) continue; printf("%d: %-20s %s (prio %d)\n", j++, cinfo->alias, cinfo->name, cinfo->priority); } exit(0); } memset(&installedrepoinfo, 0, sizeof(installedrepoinfo)); if (!read_installed_repo(&installedrepoinfo, pool)) exit(1); read_repos(pool, repoinfos, nrepoinfos); /* setup filters */ queue_init(&repofilter); queue_init(&kindfilter); queue_init(&archfilter); while (argc > 1) { if (!strcmp(argv[1], "-i")) { queue_push2(&repofilter, SOLVER_SOLVABLE_REPO | SOLVER_SETREPO, pool->installed->repoid); argc--; argv++; } else if (argc > 2 && (!strcmp(argv[1], "-r") || !strcmp(argv[1], "--repo"))) { Id repoid = find_repo(argv[2], pool, repoinfos, nrepoinfos); if (!repoid) { fprintf(stderr, "%s: no such repo\n", argv[2]); exit(1); } /* SETVENDOR is actually wrong but useful */ queue_push2(&repofilter, SOLVER_SOLVABLE_REPO | SOLVER_SETREPO | SOLVER_SETVENDOR, repoid); argc -= 2; argv += 2; } else if (argc > 2 && !strcmp(argv[1], "--arch")) { if (!strcmp(argv[2], "src") || !strcmp(argv[2], "nosrc")) archfilter_src = 1; queue_push2(&archfilter, SOLVER_SOLVABLE_PROVIDES, pool_rel2id(pool, 0, pool_str2id(pool, argv[2], 1), REL_ARCH, 1)); argc -= 2; argv += 2; } else if (argc > 2 && (!strcmp(argv[1], "-t") || !strcmp(argv[1], "--type"))) { const char *kind = argv[2]; if (!strcmp(kind, "srcpackage")) { /* hey! should use --arch! */ queue_push2(&archfilter, SOLVER_SOLVABLE_PROVIDES, pool_rel2id(pool, 0, ARCH_SRC, REL_ARCH, 1)); archfilter_src = 1; argc -= 2; argv += 2; continue; } if (!strcmp(kind, "package")) kind = ""; if (!strcmp(kind, "all")) queue_push2(&kindfilter, SOLVER_SOLVABLE_ALL, 0); else queue_push2(&kindfilter, SOLVER_SOLVABLE_PROVIDES, pool_rel2id(pool, 0, pool_str2id(pool, kind, 1), REL_KIND, 1)); argc -= 2; argv += 2; } else break; } if (mainmode == MODE_SEARCH) { Queue sel, q; Dataiterator di; if (argc != 2) usage(1); pool_createwhatprovides(pool); queue_init(&sel); dataiterator_init(&di, pool, 0, 0, 0, argv[1], SEARCH_SUBSTRING|SEARCH_NOCASE); dataiterator_set_keyname(&di, SOLVABLE_NAME); dataiterator_set_search(&di, 0, 0); while (dataiterator_step(&di)) queue_push2(&sel, SOLVER_SOLVABLE, di.solvid); dataiterator_set_keyname(&di, SOLVABLE_SUMMARY); dataiterator_set_search(&di, 0, 0); while (dataiterator_step(&di)) queue_push2(&sel, SOLVER_SOLVABLE, di.solvid); dataiterator_set_keyname(&di, SOLVABLE_DESCRIPTION); dataiterator_set_search(&di, 0, 0); while (dataiterator_step(&di)) queue_push2(&sel, SOLVER_SOLVABLE, di.solvid); dataiterator_free(&di); if (repofilter.count) selection_filter(pool, &sel, &repofilter); queue_init(&q); selection_solvables(pool, &sel, &q); queue_free(&sel); for (i = 0; i < q.count; i++) { Solvable *s = pool_id2solvable(pool, q.elements[i]); printf(" - %s [%s]: %s\n", pool_solvable2str(pool, s), s->repo->name, solvable_lookup_str(s, SOLVABLE_SUMMARY)); } queue_free(&q); exit(0); } /* process command line packages */ if (mainmode == MODE_LIST || mainmode == MODE_INFO || mainmode == MODE_INSTALL) { for (i = 1; i < argc; i++) { if (!is_cmdline_package((const char *)argv[i])) continue; if (access(argv[i], R_OK)) { perror(argv[i]); exit(1); } if (!commandlinepkgs) commandlinepkgs = solv_calloc(argc, sizeof(Id)); if (!commandlinerepo) commandlinerepo = repo_create(pool, "@commandline"); p = add_cmdline_package(commandlinerepo, (const char *)argv[i]); if (!p) { fprintf(stderr, "could not add '%s'\n", argv[i]); exit(1); } commandlinepkgs[i] = p; } if (commandlinerepo) repo_internalize(commandlinerepo); } #if defined(ENABLE_RPMDB) if (pool->disttype == DISTTYPE_RPM) addfileprovides(pool); #endif #ifdef SUSE add_autopackages(pool); #endif pool_createwhatprovides(pool); if (keyname) keyname = solv_dupjoin("solvable:", keyname, 0); queue_init(&job); for (i = 1; i < argc; i++) { Queue job2; int flags, rflags; if (commandlinepkgs && commandlinepkgs[i]) { queue_push2(&job, SOLVER_SOLVABLE, commandlinepkgs[i]); continue; } queue_init(&job2); flags = SELECTION_NAME|SELECTION_PROVIDES|SELECTION_GLOB; flags |= SELECTION_CANON|SELECTION_DOTARCH|SELECTION_REL; if (kindfilter.count) flags |= SELECTION_SKIP_KIND; if (mode == MODE_LIST || archfilter_src) flags |= SELECTION_WITH_SOURCE; if (argv[i][0] == '/') flags |= SELECTION_FILELIST | (mode == MODE_ERASE ? SELECTION_INSTALLED_ONLY : 0); if (!keyname) rflags = selection_make(pool, &job2, argv[i], flags); else { if (keyname_depstr) flags |= SELECTION_MATCH_DEPSTR; rflags = selection_make_matchdeps(pool, &job2, argv[i], flags, pool_str2id(pool, keyname, 1), 0); } if (repofilter.count) selection_filter(pool, &job2, &repofilter); if (archfilter.count) selection_filter(pool, &job2, &archfilter); if (kindfilter.count) selection_filter(pool, &job2, &kindfilter); if (!job2.count) { flags |= SELECTION_NOCASE; if (!keyname) rflags = selection_make(pool, &job2, argv[i], flags); else rflags = selection_make_matchdeps(pool, &job2, argv[i], flags, pool_str2id(pool, keyname, 1), 0); if (repofilter.count) selection_filter(pool, &job2, &repofilter); if (archfilter.count) selection_filter(pool, &job2, &archfilter); if (kindfilter.count) selection_filter(pool, &job2, &kindfilter); if (job2.count) printf("[ignoring case for '%s']\n", argv[i]); } if (!job2.count) { fprintf(stderr, "nothing matches '%s'\n", argv[i]); exit(1); } if (rflags & SELECTION_FILELIST) printf("[using file list match for '%s']\n", argv[i]); if (rflags & SELECTION_PROVIDES) printf("[using capability match for '%s']\n", argv[i]); queue_insertn(&job, job.count, job2.count, job2.elements); queue_free(&job2); } keyname = solv_free(keyname); if (!job.count && (mainmode == MODE_UPDATE || mainmode == MODE_DISTUPGRADE || mainmode == MODE_VERIFY || repofilter.count || archfilter.count || kindfilter.count)) { queue_push2(&job, SOLVER_SOLVABLE_ALL, 0); if (repofilter.count) selection_filter(pool, &job, &repofilter); if (archfilter.count) selection_filter(pool, &job, &archfilter); if (kindfilter.count) selection_filter(pool, &job, &kindfilter); } queue_free(&repofilter); queue_free(&archfilter); queue_free(&kindfilter); if (!job.count && mainmode != MODE_PATCH) { printf("no package matched\n"); exit(1); } if (mainmode == MODE_LIST || mainmode == MODE_INFO) { /* list mode, no solver needed */ Queue q; queue_init(&q); for (i = 0; i < job.count; i += 2) { int j; queue_empty(&q); pool_job2solvables(pool, &q, job.elements[i], job.elements[i + 1]); for (j = 0; j < q.count; j++) { Solvable *s = pool_id2solvable(pool, q.elements[j]); if (mainmode == MODE_INFO) { const char *str; printf("Name: %s\n", pool_solvable2str(pool, s)); printf("Repo: %s\n", s->repo->name); printf("Summary: %s\n", solvable_lookup_str(s, SOLVABLE_SUMMARY)); str = solvable_lookup_str(s, SOLVABLE_URL); if (str) printf("Url: %s\n", str); str = solvable_lookup_str(s, SOLVABLE_LICENSE); if (str) printf("License: %s\n", str); printf("Description:\n%s\n", solvable_lookup_str(s, SOLVABLE_DESCRIPTION)); printf("\n"); } else { #if 1 const char *sum = solvable_lookup_str_lang(s, SOLVABLE_SUMMARY, "de", 1); #else const char *sum = solvable_lookup_str_poollang(s, SOLVABLE_SUMMARY); #endif printf(" - %s [%s]\n", pool_solvable2str(pool, s), s->repo->name); if (sum) printf(" %s\n", sum); } } } queue_free(&q); queue_free(&job); pool_free(pool); free_repoinfos(repoinfos, nrepoinfos); solv_free(commandlinepkgs); exit(0); } #if defined(SUSE) || defined(FEDORA) if (mainmode == MODE_PATCH) add_patchjobs(pool, &job); #endif // add mode for (i = 0; i < job.count; i += 2) { job.elements[i] |= mode; if (mode == SOLVER_UPDATE && pool_isemptyupdatejob(pool, job.elements[i], job.elements[i + 1])) job.elements[i] ^= SOLVER_UPDATE ^ SOLVER_INSTALL; if (cleandeps) job.elements[i] |= SOLVER_CLEANDEPS; if (forcebest) job.elements[i] |= SOLVER_FORCEBEST; } // multiversion test // queue_push2(&job, SOLVER_MULTIVERSION|SOLVER_SOLVABLE_NAME, pool_str2id(pool, "kernel-pae", 1)); // queue_push2(&job, SOLVER_MULTIVERSION|SOLVER_SOLVABLE_NAME, pool_str2id(pool, "kernel-pae-base", 1)); // queue_push2(&job, SOLVER_MULTIVERSION|SOLVER_SOLVABLE_NAME, pool_str2id(pool, "kernel-pae-extra", 1)); #if 0 queue_push2(&job, SOLVER_INSTALL|SOLVER_SOLVABLE_PROVIDES, pool_rel2id(pool, NAMESPACE_LANGUAGE, 0, REL_NAMESPACE, 1)); queue_push2(&job, SOLVER_ERASE|SOLVER_CLEANDEPS|SOLVER_SOLVABLE_PROVIDES, pool_rel2id(pool, NAMESPACE_LANGUAGE, 0, REL_NAMESPACE, 1)); #endif rerunsolver: solv = solver_create(pool); solver_set_flag(solv, SOLVER_FLAG_SPLITPROVIDES, 1); #ifdef FEDORA solver_set_flag(solv, SOLVER_FLAG_ALLOW_VENDORCHANGE, 1); #endif if (mainmode == MODE_ERASE) solver_set_flag(solv, SOLVER_FLAG_ALLOW_UNINSTALL, 1); /* don't nag */ solver_set_flag(solv, SOLVER_FLAG_BEST_OBEY_POLICY, 1); for (;;) { Id problem, solution; int pcnt, scnt; if (!solver_solve(solv, &job)) break; pcnt = solver_problem_count(solv); printf("Found %d problems:\n", pcnt); for (problem = 1; problem <= pcnt; problem++) { int take = 0; printf("Problem %d/%d:\n", problem, pcnt); solver_printprobleminfo(solv, problem); printf("\n"); scnt = solver_solution_count(solv, problem); for (solution = 1; solution <= scnt; solution++) { printf("Solution %d:\n", solution); solver_printsolution(solv, problem, solution); printf("\n"); } for (;;) { char inbuf[128], *ip; printf("Please choose a solution: "); fflush(stdout); *inbuf = 0; if (!(ip = fgets(inbuf, sizeof(inbuf), stdin))) { printf("Abort.\n"); exit(1); } while (*ip == ' ' || *ip == '\t') ip++; if (*ip >= '0' && *ip <= '9') { take = atoi(ip); if (take >= 1 && take <= scnt) break; } if (*ip == 's') { take = 0; break; } if (*ip == 'q') { printf("Abort.\n"); exit(1); } } if (!take) continue; solver_take_solution(solv, problem, take, &job); } } trans = solver_create_transaction(solv); if (!trans->steps.count) { printf("Nothing to do.\n"); transaction_free(trans); solver_free(solv); queue_free(&job); pool_free(pool); free_repoinfos(repoinfos, nrepoinfos); solv_free(commandlinepkgs); exit(1); } /* display transaction to the user and ask for confirmation */ printf("\n"); printf("Transaction summary:\n\n"); transaction_print(trans); #if defined(SUSE) showdiskusagechanges(trans); #endif printf("install size change: %d K\n", transaction_calc_installsizechange(trans)); printf("\n"); acnt = solver_alternatives_count(solv); if (acnt) { if (acnt == 1) printf("Have one alternative:\n"); else printf("Have %d alternatives:\n", acnt); for (i = 1; i <= acnt; i++) { Id id, from; int atype = solver_get_alternative(solv, i, &id, &from, 0, 0, 0); printf(" - %s\n", solver_alternative2str(solv, atype, id, from)); } printf("\n"); answer = yesno("OK to continue (y/n/a)? ", 'a'); } else answer = yesno("OK to continue (y/n)? ", 0); if (answer == 'a') { Queue choicesq; Queue answerq; Id id, from, chosen; int j; queue_init(&choicesq); queue_init(&answerq); for (i = 1; i <= acnt; i++) { int atype = solver_get_alternative(solv, i, &id, &from, &chosen, &choicesq, 0); printf("\n%s\n", solver_alternative2str(solv, atype, id, from)); for (j = 0; j < choicesq.count; j++) { Id p = choicesq.elements[j]; if (p < 0) p = -p; queue_push(&answerq, p); printf("%6d: %s\n", answerq.count, pool_solvid2str(pool, p)); } } queue_free(&choicesq); printf("\n"); for (;;) { char inbuf[128], *ip; int neg = 0; printf("OK to continue (y/n), or number to change alternative: "); fflush(stdout); *inbuf = 0; if (!(ip = fgets(inbuf, sizeof(inbuf), stdin))) { printf("Abort.\n"); exit(1); } while (*ip == ' ' || *ip == '\t') ip++; if (*ip == '-' && ip[1] >= '0' && ip[1] <= '9') { neg = 1; ip++; } if (*ip >= '0' && *ip <= '9') { int take = atoi(ip); if (take > 0 && take <= answerq.count) { Id p = answerq.elements[take - 1]; queue_free(&answerq); queue_push2(&job, (neg ? SOLVER_DISFAVOR : SOLVER_FAVOR) | SOLVER_SOLVABLE_NAME, pool->solvables[p].name); solver_free(solv); solv = 0; goto rerunsolver; break; } } if (*ip == 'n' || *ip == 'y') { answer = *ip == 'n' ? 0 : *ip; break; } } queue_free(&answerq); } if (!answer) { printf("Abort.\n"); transaction_free(trans); solver_free(solv); queue_free(&job); pool_free(pool); free_repoinfos(repoinfos, nrepoinfos); solv_free(commandlinepkgs); exit(1); } /* download all new packages */ queue_init(&checkq); newpkgs = transaction_installedresult(trans, &checkq); newpkgsfps = 0; if (newpkgs) { int downloadsize = 0; for (i = 0; i < newpkgs; i++) { Solvable *s; p = checkq.elements[i]; s = pool_id2solvable(pool, p); downloadsize += solvable_lookup_sizek(s, SOLVABLE_DOWNLOADSIZE, 0); } printf("Downloading %d packages, %d K\n", newpkgs, downloadsize); newpkgsfps = solv_calloc(newpkgs, sizeof(*newpkgsfps)); for (i = 0; i < newpkgs; i++) { const char *loc; Solvable *s; struct repoinfo *cinfo; p = checkq.elements[i]; s = pool_id2solvable(pool, p); if (s->repo == commandlinerepo) { loc = solvable_lookup_location(s, 0); if (!loc) continue; if (!(newpkgsfps[i] = fopen(loc, "r"))) { perror(loc); exit(1); } putchar('.'); continue; } cinfo = s->repo->appdata; if (!cinfo || cinfo->type == TYPE_INSTALLED) { printf("%s: no repository information\n", s->repo->name); exit(1); } loc = solvable_lookup_location(s, 0); if (!loc) continue; /* pseudo package? */ #if defined(ENABLE_RPMDB) if (pool->installed && pool->installed->nsolvables) { if ((newpkgsfps[i] = trydeltadownload(s, loc)) != 0) { putchar('d'); fflush(stdout); continue; /* delta worked! */ } } #endif if ((newpkgsfps[i] = downloadpackage(s, loc)) == 0) { printf("\n%s: %s not found in repository\n", s->repo->name, loc); exit(1); } putchar('.'); fflush(stdout); } putchar('\n'); } #if defined(ENABLE_RPMDB) && (defined(SUSE) || defined(FEDORA) || defined(MANDRIVA) || defined(MAGEIA)) /* check for file conflicts */ if (newpkgs) { Queue conflicts; queue_init(&conflicts); if (checkfileconflicts(pool, &checkq, newpkgs, newpkgsfps, &conflicts)) { if (yesno("Re-run solver (y/n/q)? ", 0)) { for (i = 0; i < newpkgs; i++) if (newpkgsfps[i]) fclose(newpkgsfps[i]); newpkgsfps = solv_free(newpkgsfps); solver_free(solv); solv = 0; pool_add_fileconflicts_deps(pool, &conflicts); queue_free(&conflicts); goto rerunsolver; } } queue_free(&conflicts); } #endif /* and finally commit the transaction */ printf("Committing transaction:\n\n"); transaction_order(trans, 0); for (i = 0; i < trans->steps.count; i++) { int j; FILE *fp; Id type; p = trans->steps.elements[i]; type = transaction_type(trans, p, SOLVER_TRANSACTION_RPM_ONLY); switch(type) { case SOLVER_TRANSACTION_ERASE: printf("erase %s\n", pool_solvid2str(pool, p)); commit_transactionelement(pool, type, p, 0); break; case SOLVER_TRANSACTION_INSTALL: case SOLVER_TRANSACTION_MULTIINSTALL: printf("install %s\n", pool_solvid2str(pool, p)); for (j = 0; j < newpkgs; j++) if (checkq.elements[j] == p) break; fp = j < newpkgs ? newpkgsfps[j] : 0; if (!fp) continue; commit_transactionelement(pool, type, p, fp); fclose(fp); newpkgsfps[j] = 0; break; default: break; } } for (i = 0; i < newpkgs; i++) if (newpkgsfps[i]) fclose(newpkgsfps[i]); solv_free(newpkgsfps); queue_free(&checkq); transaction_free(trans); solver_free(solv); queue_free(&job); pool_free(pool); free_repoinfos(repoinfos, nrepoinfos); solv_free(commandlinepkgs); exit(0); }
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) { int c, flags = 0; const char *attrname = 0; const char *basefile = 0; const char *dir = 0; const char *locale = 0; Pool *pool = pool_create(); Repo *repo = repo_create(pool, "<stdin>"); while ((c = getopt (argc, argv, "hkn:b:d:l:")) >= 0) { switch(c) { case 'h': usage(0); break; case 'k': flags |= RPMMD_KINDS_SEPARATELY; /* do not use! */ break; case 'n': attrname = optarg; break; case 'b': basefile = optarg; break; case 'd': dir = optarg; break; case 'l': locale = optarg; break; default: usage(1); break; } } if (dir) { FILE *fp; int l; char *fnp; l = strlen(dir) + 128; fnp = sat_malloc(l+1); snprintf(fnp, l, "%s/primary.xml.gz", dir); if (!(fp = myfopen(fnp))) { perror(fnp); exit(1); } repo_add_rpmmd(repo, fp, 0, flags); fclose(fp); snprintf(fnp, l, "%s/diskusagedata.xml.gz", dir); if ((fp = myfopen(fnp))) { repo_add_rpmmd(repo, fp, 0, flags); fclose(fp); } if (locale) { if (snprintf(fnp, l, "%s/translation-%s.xml.gz", dir, locale) >= l) { fprintf(stderr, "-l parameter too long\n"); exit(1); } while (!(fp = myfopen(fnp))) { fprintf(stderr, "not opened %s\n", fnp); if (strlen(locale) > 2) { if (snprintf(fnp, l, "%s/translation-%.2s.xml.gz", dir, locale) >= l) { fprintf(stderr, "-l parameter too long\n"); exit(1); } if ((fp = myfopen(fnp))) break; } perror(fnp); exit(1); } fprintf(stderr, "opened %s\n", fnp); repo_add_rpmmd(repo, fp, 0, flags); fclose(fp); } sat_free(fnp); } else repo_add_rpmmd(repo, stdin, 0, flags); tool_write(repo, basefile, attrname); pool_free(pool); exit(0); }