int
exec_install(int argc, char **argv)
{
struct pkgdb *db = NULL;
struct pkg_jobs *jobs = NULL;
const char *reponame = NULL;
int retcode;
int updcode = EPKG_OK;
int ch;
int mode, repo_type;
int done = 0;
int lock_type = PKGDB_LOCK_ADVISORY;
bool rc = true;
bool local_only = false;
match_t match = MATCH_EXACT;
pkg_flags f = PKG_FLAG_NONE | PKG_FLAG_PKG_VERSION_TEST;
struct option longopts[] = {
{ "automatic", no_argument, NULL, 'A' },
{ "case-sensitive", no_argument, NULL, 'C' },
{ "force", no_argument, NULL, 'f' },
{ "fetch-only", no_argument, NULL, 'F' },
{ "glob", no_argument, NULL, 'g' },
{ "case-insensitive", no_argument, NULL, 'i' },
{ "no-install-scripts", no_argument, NULL, 'I' },
{ "local-only", no_argument, NULL, 'l' },
{ "ignore-missing", no_argument, NULL, 'M' },
{ "dry-run", no_argument, NULL, 'n' },
{ "quiet", no_argument, NULL, 'q' },
{ "repository", required_argument, NULL, 'r' },
{ "from-root", no_argument, NULL, 'R' },
{ "no-repo-update", no_argument, NULL, 'U' },
{ "regex", no_argument, NULL, 'x' },
{ "yes", no_argument, NULL, 'y' },
{ NULL, 0, NULL, 0 },
};
nbactions = nbdone = 0;
if (strcmp(argv[0], "add") == 0) {
auto_update = false;
local_only = true;
yes = true;
quiet = true;
}
while ((ch = getopt_long(argc, argv, "+ACfFgiIlMnqr:RUxy", longopts, NULL)) != -1) {
switch (ch) {
case 'A':
f |= PKG_FLAG_AUTOMATIC;
break;
case 'C':
pkgdb_set_case_sensitivity(true);
break;
case 'f':
f |= PKG_FLAG_FORCE;
break;
case 'F':
f |= PKG_FLAG_SKIP_INSTALL;
lock_type = PKGDB_LOCK_READONLY;
break;
case 'g':
match = MATCH_GLOB;
break;
case 'i':
pkgdb_set_case_sensitivity(false);
break;
case 'I':
f |= PKG_FLAG_NOSCRIPT;
break;
case 'l':
local_only = true;
auto_update = false;
break;
case 'M':
f |= PKG_FLAG_FORCE_MISSING;
break;
case 'n':
f |= PKG_FLAG_DRY_RUN;
lock_type = PKGDB_LOCK_READONLY;
dry_run = true;
break;
case 'q':
quiet = true;
break;
case 'r':
reponame = optarg;
break;
case 'R':
f |= PKG_FLAG_RECURSIVE;
break;
case 'U':
auto_update = false;
break;
case 'x':
match = MATCH_REGEX;
break;
case 'y':
yes = true;
break;
default:
usage_install();
return (EX_USAGE);
}
}
argc -= optind;
argv += optind;
if (argc < 1) {
usage_install();
return (EX_USAGE);
}
if (dry_run && !auto_update)
mode = PKGDB_MODE_READ;
else
mode = PKGDB_MODE_READ |
PKGDB_MODE_WRITE |
PKGDB_MODE_CREATE;
if (local_only)
repo_type = PKGDB_DB_LOCAL;
else
repo_type = PKGDB_DB_LOCAL|PKGDB_DB_REPO;
retcode = pkgdb_access(mode, repo_type);
if (retcode == EPKG_ENOACCESS && dry_run) {
auto_update = false;
retcode = pkgdb_access(PKGDB_MODE_READ,
repo_type);
}
if (retcode == EPKG_ENOACCESS) {
warnx("Insufficient privileges to install packages");
return (EX_NOPERM);
} else if (retcode != EPKG_OK)
return (EX_IOERR);
else
retcode = EX_SOFTWARE;
/* first update the remote repositories if needed */
if (auto_update &&
(updcode = pkgcli_update(false, false, reponame)) != EPKG_OK)
return (updcode);
if (pkgdb_open_all(&db,
local_only ? PKGDB_DEFAULT : PKGDB_MAYBE_REMOTE,
reponame) != EPKG_OK)
return (EX_IOERR);
if (pkgdb_obtain_lock(db, lock_type) != EPKG_OK) {
pkgdb_close(db);
warnx("Cannot get an advisory lock on a database, it is locked by another process");
return (EX_TEMPFAIL);
}
if (pkg_jobs_new(&jobs, PKG_JOBS_INSTALL, db) != EPKG_OK)
goto cleanup;
if (!local_only && reponame != NULL &&
pkg_jobs_set_repository(jobs, reponame) != EPKG_OK)
goto cleanup;
pkg_jobs_set_flags(jobs, f);
if (pkg_jobs_add(jobs, match, argv, argc) == EPKG_FATAL)
goto cleanup;
if (pkg_jobs_solve(jobs) != EPKG_OK)
goto cleanup;
while ((nbactions = pkg_jobs_count(jobs)) > 0) {
rc = yes;
/* print a summary before applying the jobs */
if (!quiet || dry_run) {
print_jobs_summary(jobs,
"The following %d packages will be affected (of %d checked):\n\n",
nbactions, pkg_jobs_total(jobs));
if (!dry_run) {
rc = query_yesno(false,
"\nProceed with this action? [y/N]: ");
}
else {
rc = false;
}
}
if (rc) {
retcode = pkg_jobs_apply(jobs);
done = 1;
if (retcode == EPKG_CONFLICT) {
printf("Conflicts with the existing packages "
"have been found.\nOne more solver "
"iteration is needed to resolve them.\n");
continue;
}
else if (retcode != EPKG_OK)
goto cleanup;
}
if (messages != NULL) {
sbuf_finish(messages);
printf("%s", sbuf_data(messages));
}
break;
}
if (done == 0 && rc)
printf("The most recent version of packages are already installed\n");
retcode = EX_OK;
cleanup:
pkgdb_release_lock(db, lock_type);
pkg_jobs_free(jobs);
pkgdb_close(db);
if (!rc && newpkgversion)
newpkgversion = false;
return (retcode);
}
int
exec_upgrade(int argc, char **argv)
{
struct pkgdb *db = NULL;
struct pkg_jobs *jobs = NULL;
const char *reponame = NULL;
int retcode;
int updcode;
int ch;
bool yes;
bool dry_run = false;
bool auto_update;
nbactions = nbdone = 0;
pkg_flags f = PKG_FLAG_NONE | PKG_FLAG_PKG_VERSION_TEST;
pkg_config_bool(PKG_CONFIG_ASSUME_ALWAYS_YES, &yes);
pkg_config_bool(PKG_CONFIG_REPO_AUTOUPDATE, &auto_update);
while ((ch = getopt(argc, argv, "fLnqFr:Uy")) != -1) {
switch (ch) {
case 'f':
f |= PKG_FLAG_FORCE;
break;
case 'I':
f |= PKG_FLAG_NOSCRIPT;
break;
case 'L':
warnx("!!! The -L flag is deprecated and will be removed. Please use -U now.");
/* FALLTHROUGH */
case 'U':
auto_update = false;
break;
case 'n':
f |= PKG_FLAG_DRY_RUN;
dry_run = true;
break;
case 'F':
f |= PKG_FLAG_SKIP_INSTALL;
break;
case 'q':
quiet = true;
break;
case 'r':
reponame = optarg;
break;
case 'y':
yes = true;
break;
default:
usage_upgrade();
return (EX_USAGE);
/* NOTREACHED */
}
}
argc -= optind;
argv += optind;
if (argc != 0) {
usage_upgrade();
return (EX_USAGE);
}
if (dry_run)
retcode = pkgdb_access(PKGDB_MODE_READ,
PKGDB_DB_LOCAL|PKGDB_DB_REPO);
else
retcode = pkgdb_access(PKGDB_MODE_READ |
PKGDB_MODE_WRITE |
PKGDB_MODE_CREATE,
PKGDB_DB_LOCAL|PKGDB_DB_REPO);
if (retcode == EPKG_ENOACCESS) {
warnx("Insufficient privilege to upgrade packages");
return (EX_NOPERM);
} else if (retcode != EPKG_OK)
return (EX_IOERR);
else
retcode = EX_SOFTWARE;
/* first update the remote repositories if needed */
if (!dry_run && auto_update &&
(updcode = pkgcli_update(false)) != EPKG_OK)
return (updcode);
if (pkgdb_open(&db, PKGDB_REMOTE) != EPKG_OK)
return (EX_IOERR);
if (pkg_jobs_new(&jobs, PKG_JOBS_UPGRADE, db) != EPKG_OK)
goto cleanup;
if (reponame != NULL && pkg_jobs_set_repository(jobs, reponame) != EPKG_OK)
goto cleanup;
pkg_jobs_set_flags(jobs, f);
if (pkg_jobs_solve(jobs) != EPKG_OK)
goto cleanup;
if ((nbactions = pkg_jobs_count(jobs)) == 0) {
if (!quiet)
printf("Nothing to do\n");
retcode = EXIT_SUCCESS;
goto cleanup;
}
if (!quiet || dry_run) {
print_jobs_summary(jobs,
"Uprgades have been requested for the following %d "
"packages:\n\n", nbactions);
if (!yes && !dry_run)
yes = query_yesno("\nProceed with upgrading "
"packages [y/N]: ");
if (dry_run)
yes = false;
}
if (yes && pkg_jobs_apply(jobs) != EPKG_OK)
goto cleanup;
if (messages != NULL) {
sbuf_finish(messages);
printf("%s", sbuf_data(messages));
}
retcode = EXIT_SUCCESS;
cleanup:
pkg_jobs_free(jobs);
pkgdb_close(db);
return (retcode);
}
int
exec_upgrade(int argc, char **argv)
{
struct pkgdb *db = NULL;
struct pkg_jobs *jobs = NULL;
const char *reponame = NULL;
int retcode;
int updcode;
int ch;
int lock_type = PKGDB_LOCK_ADVISORY;
bool yes = true, yes_arg = false;
bool dry_run = false;
bool auto_update;
int done = 0;
nbactions = nbdone = 0;
pkg_flags f = PKG_FLAG_NONE | PKG_FLAG_PKG_VERSION_TEST;
yes_arg = pkg_object_bool(pkg_config_get("ASSUME_ALWAYS_YES"));
auto_update = pkg_object_bool(pkg_config_get("REPO_AUTOUPDATE"));
while ((ch = getopt(argc, argv, "fInqFr:Uy")) != -1) {
switch (ch) {
case 'f':
f |= PKG_FLAG_FORCE;
break;
case 'I':
f |= PKG_FLAG_NOSCRIPT;
break;
case 'U':
auto_update = false;
break;
case 'n':
f |= PKG_FLAG_DRY_RUN;
lock_type = PKGDB_LOCK_READONLY;
dry_run = true;
break;
case 'F':
f |= PKG_FLAG_SKIP_INSTALL;
lock_type = PKGDB_LOCK_READONLY;
break;
case 'q':
quiet = true;
break;
case 'r':
reponame = optarg;
break;
case 'y':
yes_arg = true;
break;
default:
usage_upgrade();
return (EX_USAGE);
/* NOTREACHED */
}
}
argc -= optind;
argv += optind;
if (argc != 0) {
usage_upgrade();
return (EX_USAGE);
}
if (dry_run && !auto_update)
retcode = pkgdb_access(PKGDB_MODE_READ,
PKGDB_DB_LOCAL|PKGDB_DB_REPO);
else
retcode = pkgdb_access(PKGDB_MODE_READ |
PKGDB_MODE_WRITE |
PKGDB_MODE_CREATE,
PKGDB_DB_LOCAL|PKGDB_DB_REPO);
if (retcode == EPKG_ENOACCESS && dry_run) {
auto_update = false;
retcode = pkgdb_access(PKGDB_MODE_READ,
PKGDB_DB_LOCAL|PKGDB_DB_REPO);
}
if (retcode == EPKG_ENOACCESS) {
warnx("Insufficient privilege to upgrade packages");
return (EX_NOPERM);
} else if (retcode != EPKG_OK)
return (EX_IOERR);
else
retcode = EX_SOFTWARE;
/* first update the remote repositories if needed */
if (auto_update &&
(updcode = pkgcli_update(false, reponame)) != EPKG_OK)
return (updcode);
if (pkgdb_open_all(&db, PKGDB_REMOTE, reponame) != EPKG_OK)
return (EX_IOERR);
if (pkgdb_obtain_lock(db, lock_type, 0, 0) != EPKG_OK) {
pkgdb_close(db);
warnx("Cannot get an advisory lock on a database, it is locked by another process");
return (EX_TEMPFAIL);
}
if (pkg_jobs_new(&jobs, PKG_JOBS_UPGRADE, db) != EPKG_OK)
goto cleanup;
if (reponame != NULL && pkg_jobs_set_repository(jobs, reponame) != EPKG_OK)
goto cleanup;
pkg_jobs_set_flags(jobs, f);
if (pkg_jobs_solve(jobs) != EPKG_OK)
goto cleanup;
while ((nbactions = pkg_jobs_count(jobs)) > 0) {
/* print a summary before applying the jobs */
yes = yes_arg;
if (!quiet || dry_run) {
print_jobs_summary(jobs,
"The following %d packages will be affected (of %d checked):\n\n",
nbactions, pkg_jobs_total(jobs));
if (!yes && !dry_run)
yes = query_yesno(false, "\nProceed with this action [y/N]: ");
if (dry_run)
yes = false;
}
if (yes) {
retcode = pkg_jobs_apply(jobs);
done = 1;
if (retcode == EPKG_CONFLICT) {
printf ("The conflicts with the existing packages have been found.\n"
"We need to run one more solver iteration to resolve them.\n");
continue;
}
else if (retcode != EPKG_OK)
goto cleanup;
}
if (messages != NULL) {
sbuf_finish(messages);
printf("%s", sbuf_data(messages));
}
break;
}
if (done == 0 && yes)
printf("Your packages are up to date\n");
retcode = EX_OK;
cleanup:
pkg_jobs_free(jobs);
pkgdb_release_lock(db, lock_type);
pkgdb_close(db);
if (!yes && newpkgversion)
newpkgversion = false;
return (retcode);
}
int
exec_install(int argc, char **argv)
{
struct pkgdb *db = NULL;
struct pkg_jobs *jobs = NULL;
const char *reponame = NULL;
int retcode;
int updcode = EPKG_OK;
int ch;
bool yes;
bool auto_update;
match_t match = MATCH_EXACT;
bool dry_run = false;
nbactions = nbdone = 0;
pkg_flags f = PKG_FLAG_NONE | PKG_FLAG_PKG_VERSION_TEST;
pkg_config_bool(PKG_CONFIG_ASSUME_ALWAYS_YES, &yes);
pkg_config_bool(PKG_CONFIG_REPO_AUTOUPDATE, &auto_update);
while ((ch = getopt(argc, argv, "AfgIiFnqRr:Uxy")) != -1) {
switch (ch) {
case 'A':
f |= PKG_FLAG_AUTOMATIC;
break;
case 'f':
f |= PKG_FLAG_FORCE;
break;
case 'g':
match = MATCH_GLOB;
break;
case 'I':
f |= PKG_FLAG_NOSCRIPT;
break;
case 'F':
f |= PKG_FLAG_SKIP_INSTALL;
break;
case 'i':
pkgdb_set_case_sensitivity(false);
break;
case 'U':
auto_update = false;
break;
case 'n':
f |= PKG_FLAG_DRY_RUN;
dry_run = true;
break;
case 'q':
quiet = true;
break;
case 'R':
f |= PKG_FLAG_RECURSIVE;
break;
case 'r':
reponame = optarg;
break;
case 'x':
match = MATCH_REGEX;
break;
case 'y':
yes = true;
break;
default:
usage_install();
return (EX_USAGE);
}
}
argc -= optind;
argv += optind;
if (argc < 1) {
usage_install();
return (EX_USAGE);
}
if (dry_run && !auto_update)
retcode = pkgdb_access(PKGDB_MODE_READ,
PKGDB_DB_LOCAL |
PKGDB_DB_REPO);
else
retcode = pkgdb_access(PKGDB_MODE_READ |
PKGDB_MODE_WRITE |
PKGDB_MODE_CREATE,
PKGDB_DB_LOCAL |
PKGDB_DB_REPO);
if (retcode == EPKG_ENOACCESS && dry_run) {
auto_update = false;
retcode = pkgdb_access(PKGDB_MODE_READ,
PKGDB_DB_LOCAL|PKGDB_DB_REPO);
}
if (retcode == EPKG_ENOACCESS) {
warnx("Insufficient privileges to install packages");
return (EX_NOPERM);
} else if (retcode != EPKG_OK)
return (EX_IOERR);
else
retcode = EX_SOFTWARE;
/* first update the remote repositories if needed */
if (auto_update && (updcode = pkgcli_update(false)) != EPKG_OK)
return (updcode);
if (pkgdb_open(&db, PKGDB_REMOTE) != EPKG_OK)
return (EX_IOERR);
if (pkg_jobs_new(&jobs, PKG_JOBS_INSTALL, db) != EPKG_OK)
goto cleanup;
if (reponame != NULL && pkg_jobs_set_repository(jobs, reponame) != EPKG_OK)
goto cleanup;
pkg_jobs_set_flags(jobs, f);
if (pkg_jobs_add(jobs, match, argv, argc) == EPKG_FATAL)
goto cleanup;
if (pkg_jobs_solve(jobs) != EPKG_OK)
goto cleanup;
if ((nbactions = pkg_jobs_count(jobs)) > 0) {
/* print a summary before applying the jobs */
if (!quiet || dry_run) {
print_jobs_summary(jobs,
"The following %d packages will be installed:\n\n",
nbactions);
if (!yes && !dry_run)
yes = query_yesno(
"\nProceed with installing packages [y/N]: ");
if (dry_run)
yes = false;
}
if (yes && pkg_jobs_apply(jobs) != EPKG_OK)
goto cleanup;
if (messages != NULL) {
sbuf_finish(messages);
printf("%s", sbuf_data(messages));
}
}
retcode = EX_OK;
cleanup:
pkg_jobs_free(jobs);
pkgdb_close(db);
if (!yes && newpkgversion)
newpkgversion = false;
return (retcode);
}
int
exec_fetch(int argc, char **argv)
{
struct pkgdb *db = NULL;
struct pkg_jobs *jobs = NULL;
const char *reponame = NULL;
int ch;
int retcode = EX_SOFTWARE;
bool auto_update;
bool upgrades_for_installed = false;
bool yes;
unsigned mode;
match_t match = MATCH_EXACT;
pkg_flags f = PKG_FLAG_NONE;
pkg_config_bool(PKG_CONFIG_REPO_AUTOUPDATE, &auto_update);
pkg_config_bool(PKG_CONFIG_ASSUME_ALWAYS_YES, &yes);
while ((ch = getopt(argc, argv, "adgiqr:Uuxy")) != -1) {
switch (ch) {
case 'a':
match = MATCH_ALL;
break;
case 'd':
f |= PKG_FLAG_WITH_DEPS;
break;
case 'g':
match = MATCH_GLOB;
break;
case 'i':
pkgdb_set_case_sensitivity(false);
break;
case 'U':
auto_update = false;
break;
case 'q':
quiet = true;
break;
case 'r':
reponame = optarg;
break;
case 'u':
f |= PKG_FLAG_UPGRADES_FOR_INSTALLED;
upgrades_for_installed = true;
break;
case 'x':
match = MATCH_REGEX;
break;
case 'y':
yes = true;
break;
default:
usage_fetch();
return (EX_USAGE);
}
}
argc -= optind;
argv += optind;
if (argc < 1 && match != MATCH_ALL && !upgrades_for_installed) {
usage_fetch();
return (EX_USAGE);
}
if (match == MATCH_ALL && upgrades_for_installed) {
usage_fetch();
return (EX_USAGE);
}
/* TODO: Allow the user to specify an output directory via -o
outdir */
if (auto_update)
mode = PKGDB_MODE_READ|PKGDB_MODE_WRITE|PKGDB_MODE_CREATE;
else
mode = PKGDB_MODE_READ;
retcode = pkgdb_access(mode, PKGDB_DB_REPO);
if (retcode == EPKG_ENOACCESS) {
warnx("Insufficient privileges to access repo catalogue");
return (EX_NOPERM);
} else if (retcode != EPKG_OK)
return (EX_IOERR);
if (upgrades_for_installed) {
retcode = pkgdb_access(PKGDB_MODE_READ, PKGDB_DB_LOCAL);
if (retcode == EPKG_ENOACCESS) {
warnx("Insufficient privileges to access the package database");
return (EX_NOPERM);
} else if (retcode != EPKG_OK)
return (EX_IOERR);
}
/* first update the remote repositories if needed */
if (auto_update && (retcode = pkgcli_update(false)) != EPKG_OK)
return (retcode);
if (pkgdb_open(&db, PKGDB_REMOTE) != EPKG_OK)
return (EX_IOERR);
if (pkg_jobs_new(&jobs, PKG_JOBS_FETCH, db) != EPKG_OK)
goto cleanup;
if (reponame != NULL && pkg_jobs_set_repository(jobs, reponame) != EPKG_OK)
goto cleanup;
pkg_jobs_set_flags(jobs, f);
if (!upgrades_for_installed &&
pkg_jobs_add(jobs, match, argv, argc) != EPKG_OK)
goto cleanup;
if (pkg_jobs_solve(jobs) != EPKG_OK)
goto cleanup;
if (pkg_jobs_count(jobs) == 0)
goto cleanup;
if (!quiet) {
print_jobs_summary(jobs, "The following packages will be fetched:\n\n");
if (!yes)
yes = query_yesno("\nProceed with fetching packages [y/N]: ");
}
if (!yes || pkg_jobs_apply(jobs) != EPKG_OK)
goto cleanup;
retcode = EX_OK;
cleanup:
pkg_jobs_free(jobs);
pkgdb_close(db);
return (retcode);
}
int
exec_fetch(int argc, char **argv)
{
struct pkgdb *db = NULL;
struct pkg_jobs *jobs = NULL;
const char *reponame = NULL;
int ch;
int retcode = EX_SOFTWARE;
bool upgrades_for_installed = false, rc;
unsigned mode;
match_t match = MATCH_EXACT;
pkg_flags f = PKG_FLAG_NONE;
struct option longopts[] = {
{ "all", no_argument, NULL, 'a' },
{ "case-sensitive", no_argument, NULL, 'C' },
{ "dependencies", no_argument, NULL, 'd' },
{ "glob", no_argument, NULL, 'g' },
{ "case-insensitive", no_argument, NULL, 'i' },
{ "quiet", no_argument, NULL, 'q' },
{ "repository", required_argument, NULL, 'r' },
{ "avaialbe-updates", no_argument, NULL, 'u' },
{ "no-repo-update", no_argument, NULL, 'U' },
{ "regex", no_argument, NULL, 'x' },
{ "yes", no_argument, NULL, 'y' },
{ NULL, 0, NULL, 0 },
};
while ((ch = getopt_long(argc, argv, "aCdgiqr:Uuxy", longopts, NULL)) != -1) {
switch (ch) {
case 'a':
match = MATCH_ALL;
break;
case 'C':
pkgdb_set_case_sensitivity(true);
break;
case 'd':
f |= PKG_FLAG_WITH_DEPS | PKG_FLAG_RECURSIVE;
break;
case 'g':
match = MATCH_GLOB;
break;
case 'i':
pkgdb_set_case_sensitivity(false);
break;
case 'q':
quiet = true;
break;
case 'r':
reponame = optarg;
break;
case 'u':
f |= PKG_FLAG_UPGRADES_FOR_INSTALLED;
upgrades_for_installed = true;
break;
case 'U':
auto_update = false;
break;
case 'x':
match = MATCH_REGEX;
break;
case 'y':
yes = true;
break;
default:
usage_fetch();
return (EX_USAGE);
}
}
argc -= optind;
argv += optind;
if (argc < 1 && match != MATCH_ALL && !upgrades_for_installed) {
usage_fetch();
return (EX_USAGE);
}
if (match == MATCH_ALL && upgrades_for_installed) {
usage_fetch();
return (EX_USAGE);
}
/* TODO: Allow the user to specify an output directory via -o
outdir */
if (auto_update)
mode = PKGDB_MODE_READ|PKGDB_MODE_WRITE|PKGDB_MODE_CREATE;
else
mode = PKGDB_MODE_READ;
retcode = pkgdb_access(mode, PKGDB_DB_REPO);
if (retcode == EPKG_ENOACCESS) {
warnx("Insufficient privileges to access repo catalogue");
return (EX_NOPERM);
} else if (retcode != EPKG_OK)
return (EX_IOERR);
if (upgrades_for_installed) {
retcode = pkgdb_access(PKGDB_MODE_READ, PKGDB_DB_LOCAL);
if (retcode == EPKG_ENOACCESS) {
warnx("Insufficient privileges to access the package database");
return (EX_NOPERM);
} else if (retcode != EPKG_OK)
return (EX_IOERR);
}
/* first update the remote repositories if needed */
if (auto_update &&
(retcode = pkgcli_update(false, reponame)) != EPKG_OK)
return (retcode);
if (pkgdb_open_all(&db, PKGDB_REMOTE, reponame) != EPKG_OK)
return (EX_IOERR);
if (pkgdb_obtain_lock(db, PKGDB_LOCK_READONLY) != EPKG_OK) {
pkgdb_close(db);
warnx("Cannot get a read lock on a database, it is locked by another process");
return (EX_TEMPFAIL);
}
if (pkg_jobs_new(&jobs, PKG_JOBS_FETCH, db) != EPKG_OK)
goto cleanup;
if (reponame != NULL && pkg_jobs_set_repository(jobs, reponame) != EPKG_OK)
goto cleanup;
pkg_jobs_set_flags(jobs, f);
if (!upgrades_for_installed &&
pkg_jobs_add(jobs, match, argv, argc) != EPKG_OK)
goto cleanup;
if (pkg_jobs_solve(jobs) != EPKG_OK)
goto cleanup;
if (pkg_jobs_count(jobs) == 0)
goto cleanup;
if (!quiet) {
print_jobs_summary(jobs, "The following packages will be fetched:\n\n");
rc = query_yesno(false, "\nProceed with fetching packages [y/N]: ");
}
else {
rc = true;
}
if (!rc || pkg_jobs_apply(jobs) != EPKG_OK)
goto cleanup;
retcode = EX_OK;
cleanup:
pkg_jobs_free(jobs);
pkgdb_release_lock(db, PKGDB_LOCK_READONLY);
pkgdb_close(db);
return (retcode);
}
int
exec_upgrade(int argc, char **argv)
{
struct pkgdb *db = NULL;
struct pkg_jobs *jobs = NULL;
const char *reponame = NULL;
int retcode;
int updcode;
int ch;
int lock_type = PKGDB_LOCK_ADVISORY;
match_t match = MATCH_EXACT;
int done = 0;
bool rc = true;
pkg_flags f = PKG_FLAG_NONE | PKG_FLAG_PKG_VERSION_TEST;
size_t dlbytes, diffbytes, limbytes;
limbytes = pkg_object_int(pkg_config_get("WARN_SIZE_LIMIT"));
struct option longopts[] = {
{ "case-sensitive", no_argument, NULL, 'C' },
{ "force", no_argument, NULL, 'f' },
{ "fetch-only", no_argument, NULL, 'F' },
{ "glob", no_argument, NULL, 'g' },
{ "case-insensitive", no_argument, NULL, 'i' },
{ "no-install-scripts", no_argument, NULL, 'I' },
{ "dry-run", no_argument, NULL, 'n' },
{ "quiet", no_argument, NULL, 'q' },
{ "repository", required_argument, NULL, 'r' },
{ "no-repo-update", no_argument, NULL, 'U' },
{ "regex", no_argument, NULL, 'x' },
{ "yes", no_argument, NULL, 'y' },
{ NULL, 0, NULL, 0 },
};
nbactions = nbdone = 0;
while ((ch = getopt_long(argc, argv, "+CfFgiInqr:Uxy", longopts, NULL)) != -1) {
switch (ch) {
case 'C':
pkgdb_set_case_sensitivity(true);
break;
case 'f':
f |= PKG_FLAG_FORCE;
break;
case 'F':
f |= PKG_FLAG_SKIP_INSTALL;
lock_type = PKGDB_LOCK_READONLY;
break;
case 'g':
match = MATCH_GLOB;
break;
case 'i':
pkgdb_set_case_sensitivity(false);
break;
case 'I':
f |= PKG_FLAG_NOSCRIPT;
break;
case 'n':
f |= PKG_FLAG_DRY_RUN;
lock_type = PKGDB_LOCK_READONLY;
dry_run = true;
break;
case 'q':
quiet = true;
break;
case 'r':
reponame = optarg;
break;
case 'U':
auto_update = false;
break;
case 'x':
match = MATCH_REGEX;
break;
case 'y':
yes = true;
break;
default:
usage_upgrade();
return (EX_USAGE);
/* NOTREACHED */
}
}
argc -= optind;
argv += optind;
if (dry_run && !auto_update)
retcode = pkgdb_access(PKGDB_MODE_READ,
PKGDB_DB_LOCAL|PKGDB_DB_REPO);
else
retcode = pkgdb_access(PKGDB_MODE_READ |
PKGDB_MODE_WRITE |
PKGDB_MODE_CREATE,
PKGDB_DB_LOCAL|PKGDB_DB_REPO);
if (retcode == EPKG_ENOACCESS && dry_run) {
auto_update = false;
retcode = pkgdb_access(PKGDB_MODE_READ,
PKGDB_DB_LOCAL|PKGDB_DB_REPO);
}
if (retcode == EPKG_ENOACCESS) {
warnx("Insufficient privilege to upgrade packages");
return (EX_NOPERM);
} else if (retcode != EPKG_OK)
return (EX_IOERR);
else
retcode = EX_SOFTWARE;
/* first update the remote repositories if needed */
if (auto_update &&
(updcode = pkgcli_update(false, false, reponame)) != EPKG_OK)
return (updcode);
if (pkgdb_open_all(&db, PKGDB_REMOTE, reponame) != EPKG_OK)
return (EX_IOERR);
if (pkgdb_obtain_lock(db, lock_type) != EPKG_OK) {
pkgdb_close(db);
warnx("Cannot get an advisory lock on a database, it is locked by another process");
return (EX_TEMPFAIL);
}
if (pkg_jobs_new(&jobs, PKG_JOBS_UPGRADE, db) != EPKG_OK)
goto cleanup;
if (reponame != NULL && pkg_jobs_set_repository(jobs, reponame) != EPKG_OK)
goto cleanup;
pkg_jobs_set_flags(jobs, f);
if (argc > 0)
if (pkg_jobs_add(jobs, match, argv, argc) == EPKG_FATAL)
goto cleanup;
if (pkg_jobs_solve(jobs) != EPKG_OK)
goto cleanup;
while ((nbactions = pkg_jobs_count(jobs)) > 0) {
/* print a summary before applying the jobs */
rc = yes;
if (!quiet || dry_run) {
print_jobs_summary(jobs, &diffbytes, &dlbytes,
"The following %d package(s) will be affected (of %d checked):\n\n",
nbactions, pkg_jobs_total(jobs));
if (!dry_run) {
if (limbytes && (diffbytes > limbytes || dlbytes > limbytes)) {
rc = query_yesno(false, "\nProceed with this "
"action? ");
}
else {
rc = true;
}
}
else {
rc = false;
}
}
if (rc) {
retcode = pkg_jobs_apply(jobs);
done = 1;
if (retcode == EPKG_CONFLICT) {
printf("Conflicts with the existing packages "
"have been found.\nOne more solver "
"iteration is needed to resolve them.\n");
continue;
}
else if (retcode != EPKG_OK)
goto cleanup;
}
if (messages != NULL) {
sbuf_finish(messages);
printf("%s", sbuf_data(messages));
}
break;
}
if (done == 0 && rc && !quiet)
printf("Your packages are up to date.\n");
retcode = EX_OK;
cleanup:
pkg_jobs_free(jobs);
pkgdb_release_lock(db, lock_type);
pkgdb_close(db);
if (!dry_run)
pkg_cache_full_clean();
if (!rc && newpkgversion)
newpkgversion = false;
return (retcode);
}