static int
convert_from_old(const char *pkg_add_dbdir, bool dry_run)
{
DIR *d;
struct dirent *dp;
struct pkg *p = NULL;
char path[MAXPATHLEN];
struct pkgdb *db = NULL;
if ((d = opendir(pkg_add_dbdir)) == NULL)
err(EX_NOINPUT, "%s", pkg_add_dbdir);
if (pkgdb_open(&db, PKGDB_DEFAULT) != EPKG_OK) {
return (EX_IOERR);
}
while ((dp = readdir(d)) != NULL) {
if (dp->d_type == DT_DIR) {
if (strcmp(dp->d_name, ".") == 0 ||
strcmp(dp->d_name, "..") == 0)
continue;
if (p == NULL) {
if (pkg_new(&p, PKG_OLD_FILE) != EPKG_OK)
err(EX_OSERR, "malloc");
} else
pkg_reset(p, PKG_OLD_FILE);
printf("Converting %s...\n", dp->d_name);
snprintf(path, MAXPATHLEN, "%s/%s", pkg_add_dbdir, dp->d_name);
if (pkg_old_load_from_path(p, path) != EPKG_OK) {
fprintf(stderr, "Skipping invalid package: %s\n", path);
continue;
}
pkg_from_old(p);
if (!dry_run)
pkgdb_register_ports(db, p);
}
}
pkg_free(p);
pkgdb_close(db);
return (EX_OK);
}
int
exec_register(int argc, char **argv)
{
struct pkg *pkg = NULL;
struct pkgdb *db = NULL;
struct pkg_manifest_key *keys = NULL;
regex_t preg;
regmatch_t pmatch[2];
char *arch = NULL;
char myarch[BUFSIZ];
char *www = NULL;
char fpath[MAXPATHLEN];
const char *plist = NULL;
const char *mdir = NULL;
const char *mfile = NULL;
const char *input_path = NULL;
const char *desc = NULL;
const char *location = NULL;
size_t size;
bool developer;
bool legacy = false;
bool old = false;
bool __unused metadata_only = false;
bool testing_mode = false;
int ch;
int i;
int ret = EPKG_OK;
int retcode = EX_OK;
/* options descriptor */
struct option longopts[] = {
{ "automatic", no_argument, NULL, 'A' },
{ "plist", required_argument, NULL, 'f' },
{ "root", required_argument, NULL, 'i' },
{ "legacy", no_argument, NULL, 'l' },
{ "manifest", required_argument, NULL, 'M' },
{ "metadata", required_argument, NULL, 'm' },
{ "old", no_argument, NULL, 'O' },
{ "test", no_argument, NULL, 't' },
{ "relocate", required_argument, NULL, 1 },
{ NULL, 0, NULL, 0},
};
developer = pkg_object_bool(pkg_config_get("DEVELOPER_MODE"));
if (pkg_new(&pkg, PKG_INSTALLED) != EPKG_OK)
err(EX_OSERR, "malloc");
while ((ch = getopt_long(argc, argv, "Adf:i:lM:m:Ot", longopts, NULL)) != -1) {
switch (ch) {
case 'A':
case 'd':
pkg_set(pkg, PKG_AUTOMATIC, (bool)true);
break;
case 'f':
plist = optarg;
break;
case 'i':
input_path = optarg;
break;
case 'l':
legacy = true;
break;
case 'M':
metadata_only = true;
mfile = optarg;
break;
case 'm':
mdir = optarg;
break;
case 'O':
old = true;
break;
case 't':
testing_mode = true;
break;
case 1:
location = optarg;
break;
default:
warnx("Unrecognised option -%c\n", ch);
usage_register();
return (EX_USAGE);
}
}
if (!old) {
retcode = pkgdb_access(PKGDB_MODE_READ |
PKGDB_MODE_WRITE |
PKGDB_MODE_CREATE,
PKGDB_DB_LOCAL);
if (retcode == EPKG_ENOACCESS) {
warnx("Insufficient privileges to register packages");
return (EX_NOPERM);
} else if (retcode != EPKG_OK)
return (EX_IOERR);
else
retcode = EX_OK;
}
/*
* Ideally, the +MANIFEST should be all that is necessary,
* since it can contain all of the meta-data supplied by the
* other files mentioned below. These are here for backwards
* compatibility with the way the ports tree works with
* pkg_tools.
*
* The -M option specifies one manifest file to read the
* meta-data from, and overrides the use of legacy meta-data
* inputs.
*
* Dependencies, shlibs, files etc. may be derived by
* analysing the package files (maybe discovered as the
* content of the staging directory) unless -t (testing_mode)
* is used.
*/
if (mfile != NULL && mdir != NULL) {
warnx("Cannot use both -m and -M together");
usage_register();
return (EX_USAGE);
}
if (mfile == NULL && mdir == NULL) {
warnx("One of either -m or -M flags is required");
usage_register();
return (EX_USAGE);
}
if (mfile != NULL && plist != NULL) {
warnx("-M incompatible with -f option");
usage_register();
return (EX_USAGE);
}
if (testing_mode && input_path != NULL) {
warnx("-i incompatible with -t option");
usage_register();
return (EX_USAGE);
}
pkg_manifest_keys_new(&keys);
if (mfile != NULL) {
ret = pkg_parse_manifest_file(pkg, mfile, keys);
pkg_manifest_keys_free(keys);
if (ret != EPKG_OK)
return (EX_IOERR);
} else {
snprintf(fpath, sizeof(fpath), "%s/+MANIFEST", mdir);
ret = pkg_parse_manifest_file(pkg, fpath, keys);
pkg_manifest_keys_free(keys);
if (ret != EPKG_OK)
return (EX_IOERR);
snprintf(fpath, sizeof(fpath), "%s/+DESC", mdir);
pkg_set_from_file(pkg, PKG_DESC, fpath, false);
snprintf(fpath, sizeof(fpath), "%s/+DISPLAY", mdir);
if (access(fpath, F_OK) == 0)
pkg_set_from_file(pkg, PKG_MESSAGE, fpath, false);
snprintf(fpath, sizeof(fpath), "%s/+MTREE_DIRS", mdir);
if (access(fpath, F_OK) == 0)
pkg_set_from_file(pkg, PKG_MTREE, fpath, false);
for (i = 0; scripts[i] != NULL; i++) {
snprintf(fpath, sizeof(fpath), "%s/%s", mdir,
scripts[i]);
if (access(fpath, F_OK) == 0)
pkg_addscript_file(pkg, fpath);
}
if (www != NULL) {
pkg_set(pkg, PKG_WWW, www);
free(www);
}
pkg_get(pkg, PKG_WWW, &www);
/*
* if www is not given then try to determine it from
* description
*/
if (www == NULL) {
pkg_get(pkg, PKG_DESC, &desc);
regcomp(&preg, "^WWW:[[:space:]]*(.*)$",
REG_EXTENDED|REG_ICASE|REG_NEWLINE);
if (regexec(&preg, desc, 2, pmatch, 0) == 0) {
size = pmatch[1].rm_eo - pmatch[1].rm_so;
www = strndup(&desc[pmatch[1].rm_so], size);
pkg_set(pkg, PKG_WWW, www);
free(www);
} else {
pkg_set(pkg, PKG_WWW, "UNKNOWN");
}
regfree(&preg);
}
if (plist != NULL)
ret += ports_parse_plist(pkg, plist, input_path);
}
if (ret != EPKG_OK) {
return (EX_IOERR);
}
if (!old) {
if (pkgdb_open(&db, PKGDB_DEFAULT) != EPKG_OK)
return (EX_IOERR);
if (pkgdb_obtain_lock(db, PKGDB_LOCK_EXCLUSIVE) != EPKG_OK) {
pkgdb_close(db);
warnx("Cannot get an exclusive lock on a database, it is locked by another process");
return (EX_TEMPFAIL);
}
}
/*
* testing_mode allows updating the local package database
* without any check that the files etc. listed in the meta
* data actually exist on the system. Inappropriate use of
* testing_mode can really screw things up.
*/
if (!testing_mode)
pkg_analyse_files(db, pkg, input_path);
pkg_get(pkg, PKG_ARCH, &arch);
if (arch == NULL) {
/*
* do not take the one from configuration on purpose
* but the real abi of the package.
*/
pkg_get_myarch(myarch, BUFSIZ);
if (developer)
pkg_suggest_arch(pkg, myarch, true);
pkg_set(pkg, PKG_ARCH, myarch);
} else {
if (developer)
pkg_suggest_arch(pkg, arch, false);
}
if (!testing_mode && input_path != NULL)
pkg_copy_tree(pkg, input_path, location ? location : "/");
if (location != NULL)
pkg_addannotation(pkg, "relocated", location);
if (old) {
if (pkg_register_old(pkg) != EPKG_OK)
retcode = EX_SOFTWARE;
} else {
if (pkgdb_register_ports(db, pkg) != EPKG_OK)
retcode = EX_SOFTWARE;
}
if (!legacy && pkg_has_message(pkg))
pkg_printf("%M\n", pkg);
if (!old) {
pkgdb_release_lock(db, PKGDB_LOCK_EXCLUSIVE);
pkgdb_close(db);
}
pkg_free(pkg);
return (retcode);
}
int
exec_register(int argc, char **argv)
{
struct pkg *pkg = NULL;
struct pkgdb *db = NULL;
regex_t preg;
regmatch_t pmatch[2];
int ch;
char *plist = NULL;
char *arch = NULL;
char myarch[BUFSIZ];
char *mdir = NULL;
char *www = NULL;
char *input_path = NULL;
char fpath[MAXPATHLEN + 1];
const char *message;
const char *desc = NULL;
size_t size;
bool legacy = false;
bool developer = false;
int i;
int ret = EPKG_OK, retcode = EX_OK;
if (geteuid() != 0) {
warnx("registering packages can only be done as root");
return (EX_NOPERM);
}
pkg_config_bool(PKG_CONFIG_DEVELOPER_MODE, &developer);
pkg_new(&pkg, PKG_INSTALLED);
while ((ch = getopt(argc, argv, "f:m:i:ld")) != -1) {
switch (ch) {
case 'f':
if ((plist = strdup(optarg)) == NULL)
err(1, "cannot allocate memory");
break;
case 'm':
if ((mdir = strdup(optarg)) == NULL)
err(1, "cannot allocate memory");
break;
case 'd':
pkg_set(pkg, PKG_AUTOMATIC, true);
break;
case 'i':
if ((input_path = strdup(optarg)) == NULL)
err(1, "cannot allocate memory");
break;
case 'l':
legacy = true;
break;
default:
printf("%c\n", ch);
usage_register();
return (EX_USAGE);
}
}
if (plist == NULL)
errx(EX_USAGE, "missing -f flag");
if (mdir == NULL)
errx(EX_USAGE, "missing -m flag");
snprintf(fpath, sizeof(fpath), "%s/+MANIFEST", mdir);
if ((ret = pkg_load_manifest_file(pkg, fpath)) != EPKG_OK) {
return (EX_IOERR);
}
snprintf(fpath, sizeof(fpath), "%s/+DESC", mdir);
pkg_set_from_file(pkg, PKG_DESC, fpath);
snprintf(fpath, sizeof(fpath), "%s/+DISPLAY", mdir);
if (access(fpath, F_OK) == 0)
pkg_set_from_file(pkg, PKG_MESSAGE, fpath);
snprintf(fpath, sizeof(fpath), "%s/+MTREE_DIRS", mdir);
if (access(fpath, F_OK) == 0)
pkg_set_from_file(pkg, PKG_MTREE, fpath);
for (i = 0; scripts[i] != NULL; i++) {
snprintf(fpath, sizeof(fpath), "%s/%s", mdir, scripts[i]);
if (access(fpath, F_OK) == 0)
pkg_addscript_file(pkg, fpath);
}
/* if www is not given then try to determine it from description */
if (www == NULL) {
pkg_get(pkg, PKG_DESC, &desc);
regcomp(&preg, "^WWW:[[:space:]]*(.*)$", REG_EXTENDED|REG_ICASE|REG_NEWLINE);
if (regexec(&preg, desc, 2, pmatch, 0) == 0) {
size = pmatch[1].rm_eo - pmatch[1].rm_so;
www = strndup(&desc[pmatch[1].rm_so], size);
pkg_set(pkg, PKG_WWW, www);
free(www);
} else {
pkg_set(pkg, PKG_WWW, "UNKNOWN");
}
regfree(&preg);
} else {
pkg_set(pkg, PKG_WWW, www);
free(www);
}
ret += ports_parse_plist(pkg, plist, input_path);
if (ret != EPKG_OK) {
return (EX_IOERR);
}
if (plist != NULL)
free(plist);
if (pkgdb_open(&db, PKGDB_DEFAULT) != EPKG_OK) {
return (EX_IOERR);
}
pkg_analyse_files(db, pkg);
pkg_get(pkg, PKG_ARCH, &arch);
if (arch == NULL) {
/*
* do not take the one from configuration on purpose
* but the real abi of the package.
*/
pkg_get_myarch(myarch, BUFSIZ);
if (developer)
pkg_suggest_arch(pkg, myarch, true);
pkg_set(pkg, PKG_ARCH, myarch);
} else {
if (developer)
pkg_suggest_arch(pkg, arch, false);
}
if (input_path != NULL) {
pkg_copy_tree(pkg, input_path, "/");
free(input_path);
}
if (pkgdb_register_ports(db, pkg) != EPKG_OK)
retcode = EX_SOFTWARE;
pkg_get(pkg, PKG_MESSAGE, &message);
if (message != NULL && !legacy)
printf("%s\n", message);
pkgdb_close(db);
pkg_free(pkg);
return (retcode);
}
static int
convert_from_old(const char *pkg_add_dbdir, bool dry_run)
{
DIR *d;
struct dirent *dp;
struct pkg *p = NULL;
char path[MAXPATHLEN];
struct pkgdb *db = NULL;
struct stat sb;
int lock_type = PKGDB_LOCK_EXCLUSIVE;
int ret;
if (dry_run)
ret = pkgdb_access(PKGDB_MODE_READ, PKGDB_DB_LOCAL);
else
ret = pkgdb_access(PKGDB_MODE_READ|PKGDB_MODE_WRITE|
PKGDB_MODE_CREATE, PKGDB_DB_LOCAL);
if (ret == EPKG_ENOACCESS) {
warnx("Insufficient privileges to convert packages");
return (EX_NOPERM);
} else if (ret != EPKG_OK && ret != EPKG_ENODB) {
warnx("Error accessing the package database");
return (EX_SOFTWARE);
}
if ((d = opendir(pkg_add_dbdir)) == NULL)
err(EX_NOINPUT, "%s", pkg_add_dbdir);
if (pkgdb_open(&db, PKGDB_DEFAULT) != EPKG_OK) {
return (EX_IOERR);
}
if (dry_run)
lock_type = PKGDB_LOCK_READONLY;
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);
}
while ((dp = readdir(d)) != NULL) {
if (fstatat(dirfd(d), dp->d_name, &sb, 0) == 0 &&
S_ISDIR(sb.st_mode)) {
if (strcmp(dp->d_name, ".") == 0 ||
strcmp(dp->d_name, "..") == 0)
continue;
if (p != NULL)
pkg_free(p);
if (pkg_new(&p, PKG_OLD_FILE) != EPKG_OK)
err(EX_OSERR, "malloc");
printf("Converting %s...\n", dp->d_name);
snprintf(path, sizeof(path), "%s/%s", pkg_add_dbdir, dp->d_name);
if (pkg_old_load_from_path(p, path) != EPKG_OK) {
fprintf(stderr, "Skipping invalid package: %s\n", path);
continue;
}
pkg_from_old(p);
if (!dry_run)
pkgdb_register_ports(db, p);
}
}
pkg_free(p);
pkgdb_release_lock(db, lock_type);
pkgdb_close(db);
return (EX_OK);
}
