int main(int argc, char *argv[])
{
int retval = 1; /* default = false */
alpm_handle_t *handle;
alpm_errno_t err;
alpm_pkg_t *pkg = NULL;
const alpm_siglevel_t level = ALPM_SIG_PACKAGE | ALPM_SIG_PACKAGE_OPTIONAL;
if(argc != 2) {
fprintf(stderr, "testpkg (pacman) v" PACKAGE_VERSION "\n\n"
"Test a pacman package for validity.\n\n"
"Usage: testpkg <package file>\n");
return 1;
}
handle = alpm_initialize(ROOTDIR, DBPATH, &err);
if(!handle) {
fprintf(stderr, "cannot initialize alpm: %s\n", alpm_strerror(err));
return 1;
}
/* let us get log messages from libalpm */
alpm_option_set_logcb(handle, output_cb);
/* set gpgdir to default */
alpm_option_set_gpgdir(handle, GPGDIR);
if(alpm_pkg_load(handle, argv[1], 1, level, &pkg) == -1
|| pkg == NULL) {
err = alpm_errno(handle);
switch(err) {
case ALPM_ERR_PKG_NOT_FOUND:
printf("Cannot find the given file.\n");
break;
case ALPM_ERR_PKG_OPEN:
printf("Cannot open the given file.\n");
break;
case ALPM_ERR_LIBARCHIVE:
case ALPM_ERR_PKG_INVALID:
printf("Package is invalid.\n");
break;
default:
printf("libalpm error: %s\n", alpm_strerror(err));
break;
}
retval = 1;
} else {
alpm_pkg_free(pkg);
printf("Package is valid.\n");
retval = 0;
}
if(alpm_release(handle) == -1) {
fprintf(stderr, "error releasing alpm\n");
}
return retval;
}
/**
* @brief Upgrade a specified list of packages.
*
* @param targets a list of packages (as strings) to upgrade
*
* @return 0 on success, 1 on failure
*/
int pacman_upgrade(alpm_list_t *targets)
{
alpm_list_t *i;
alpm_siglevel_t level = alpm_option_get_default_siglevel(config->handle);
if(targets == NULL) {
pm_printf(ALPM_LOG_ERROR, _("no targets specified (use -h for help)\n"));
return 1;
}
/* Check for URL targets and process them
*/
for(i = targets; i; i = alpm_list_next(i)) {
if(strstr(i->data, "://")) {
char *str = alpm_fetch_pkgurl(config->handle, i->data);
if(str == NULL) {
pm_fprintf(stderr, ALPM_LOG_ERROR, "'%s': %s\n",
(char *)i->data, alpm_strerror(alpm_errno(config->handle)));
return 1;
} else {
free(i->data);
i->data = str;
}
}
}
/* Step 1: create a new transaction */
if(trans_init(config->flags, 1) == -1) {
return 1;
}
printf(_("loading packages...\n"));
/* add targets to the created transaction */
for(i = targets; i; i = alpm_list_next(i)) {
char *targ = alpm_list_getdata(i);
alpm_pkg_t *pkg;
if(alpm_pkg_load(config->handle, targ, 1, level, &pkg) != 0) {
pm_fprintf(stderr, ALPM_LOG_ERROR, "'%s': %s\n",
targ, alpm_strerror(alpm_errno(config->handle)));
trans_release();
return 1;
}
if(alpm_add_pkg(config->handle, pkg) == -1) {
pm_fprintf(stderr, ALPM_LOG_ERROR, "'%s': %s\n",
targ, alpm_strerror(alpm_errno(config->handle)));
alpm_pkg_free(pkg);
trans_release();
return 1;
}
config->explicit_adds = alpm_list_add(config->explicit_adds, pkg);
}
/* now that targets are resolved, we can hand it all off to the sync code */
return sync_prepare_execute();
}
static void
asb_package_alpm_finalize (GObject *object)
{
AsbPackageAlpm *pkg = ASB_PACKAGE_ALPM (object);
AsbPackageAlpmPrivate *priv = GET_PRIVATE (pkg);
/* TODO: handle errors */
alpm_pkg_free (priv->package);
alpm_release (priv->handle);
G_OBJECT_CLASS (asb_package_alpm_parent_class)->finalize (object);
}
int main(int argc, char *argv[])
{
int retval = 1; /* default = false */
pmhandle_t *handle;
enum _pmerrno_t err;
pmpkg_t *pkg = NULL;
if(argc != 2) {
fprintf(stderr, "usage: %s <package file>\n", BASENAME);
return 1;
}
handle = alpm_initialize(ROOTDIR, DBPATH, &err);
if(!handle) {
fprintf(stderr, "cannot initialize alpm: %s\n", alpm_strerror(err));
return 1;
}
/* let us get log messages from libalpm */
alpm_option_set_logcb(handle, output_cb);
if(alpm_pkg_load(handle, argv[1], 1, PM_PGP_VERIFY_OPTIONAL, &pkg) == -1
|| pkg == NULL) {
err = alpm_errno(handle);
switch(err) {
case PM_ERR_PKG_OPEN:
printf("Cannot open the given file.\n");
break;
case PM_ERR_LIBARCHIVE:
case PM_ERR_PKG_INVALID:
printf("Package is invalid.\n");
break;
default:
printf("libalpm error: %s\n", alpm_strerror(err));
break;
}
retval = 1;
} else {
alpm_pkg_free(pkg);
printf("Package is valid.\n");
retval = 0;
}
if(alpm_release(handle) == -1) {
fprintf(stderr, "error releasing alpm\n");
}
return retval;
}
int main(int argc, char **argv)
{
int retval = 1; /* default = false */
pmpkg_t *pkg = NULL;
if(argc != 2) {
fprintf(stderr, "usage: %s <package file>\n", BASENAME);
return(1);
}
if(alpm_initialize() == -1) {
fprintf(stderr, "cannot initialize alpm: %s\n", alpm_strerrorlast());
return(1);
}
/* let us get log messages from libalpm */
alpm_option_set_logcb(output_cb);
if(alpm_pkg_load(argv[1], 1, &pkg) == -1 || pkg == NULL) {
switch(pm_errno) {
case PM_ERR_PKG_OPEN:
printf("Cannot open the given file.\n");
break;
case PM_ERR_LIBARCHIVE:
case PM_ERR_PKG_INVALID:
printf("Package is invalid.\n");
break;
default:
printf("libalpm error: %s\n", alpm_strerrorlast());
break;
}
retval = 1;
} else {
alpm_pkg_free(pkg);
printf("Package is valid.\n");
retval = 0;
}
if(alpm_release() == -1) {
fprintf(stderr, "error releasing alpm: %s\n", alpm_strerrorlast());
}
return(retval);
}
static gint
alpm_add_file (const gchar *filename)
{
alpm_pkg_t *pkg;
alpm_siglevel_t level;
g_return_val_if_fail (filename != NULL, -1);
g_return_val_if_fail (alpm != NULL, -1);
level = alpm_option_get_local_file_siglevel (alpm);
if (alpm_pkg_load (alpm, filename, 1, level, &pkg) < 0) {
return -1;
}
if (alpm_add_pkg (alpm, pkg) < 0) {
alpm_pkg_free (pkg);
return -1;
}
return 0;
}
/**
* @brief Upgrade a specified list of packages.
*
* @param targets a list of packages (as strings) to upgrade
*
* @return 0 on success, 1 on failure
*/
int pacman_upgrade(alpm_list_t *targets)
{
alpm_list_t *i, *data = NULL;
pgp_verify_t check_sig = alpm_option_get_default_sigverify(config->handle);
int retval = 0;
if(targets == NULL) {
pm_printf(PM_LOG_ERROR, _("no targets specified (use -h for help)\n"));
return 1;
}
/* Check for URL targets and process them
*/
for(i = targets; i; i = alpm_list_next(i)) {
if(strstr(i->data, "://")) {
char *str = alpm_fetch_pkgurl(config->handle, i->data);
if(str == NULL) {
pm_fprintf(stderr, PM_LOG_ERROR, "'%s': %s\n",
(char *)i->data, alpm_strerror(alpm_errno(config->handle)));
return 1;
} else {
free(i->data);
i->data = str;
}
}
}
/* Step 1: create a new transaction */
if(trans_init(config->flags) == -1) {
return 1;
}
/* add targets to the created transaction */
for(i = targets; i; i = alpm_list_next(i)) {
char *targ = alpm_list_getdata(i);
pmpkg_t *pkg;
if(alpm_pkg_load(config->handle, targ, 1, check_sig, &pkg) != 0) {
pm_fprintf(stderr, PM_LOG_ERROR, "'%s': %s\n",
targ, alpm_strerror(alpm_errno(config->handle)));
trans_release();
return 1;
}
if(alpm_add_pkg(config->handle, pkg) == -1) {
pm_fprintf(stderr, PM_LOG_ERROR, "'%s': %s\n",
targ, alpm_strerror(alpm_errno(config->handle)));
alpm_pkg_free(pkg);
trans_release();
return 1;
}
}
/* Step 2: "compute" the transaction based on targets and flags */
/* TODO: No, compute nothing. This is stupid. */
if(alpm_trans_prepare(config->handle, &data) == -1) {
enum _pmerrno_t err = alpm_errno(config->handle);
pm_fprintf(stderr, PM_LOG_ERROR, _("failed to prepare transaction (%s)\n"),
alpm_strerror(err));
switch(err) {
case PM_ERR_PKG_INVALID_ARCH:
for(i = data; i; i = alpm_list_next(i)) {
char *pkg = alpm_list_getdata(i);
printf(_(":: package %s does not have a valid architecture\n"), pkg);
}
break;
case PM_ERR_UNSATISFIED_DEPS:
for(i = data; i; i = alpm_list_next(i)) {
pmdepmissing_t *miss = alpm_list_getdata(i);
char *depstring = alpm_dep_compute_string(miss->depend);
/* TODO indicate if the error was a virtual package or not:
* :: %s: requires %s, provided by %s
*/
printf(_(":: %s: requires %s\n"), miss->target, depstring);
free(depstring);
}
break;
case PM_ERR_CONFLICTING_DEPS:
for(i = data; i; i = alpm_list_next(i)) {
pmconflict_t *conflict = alpm_list_getdata(i);
if(strcmp(conflict->package1, conflict->reason) == 0 ||
strcmp(conflict->package2, conflict->reason) == 0) {
printf(_(":: %s and %s are in conflict\n"),
conflict->package1, conflict->package2);
} else {
printf(_(":: %s and %s are in conflict (%s)\n"),
conflict->package1, conflict->package2, conflict->reason);
}
}
break;
default:
break;
}
trans_release();
FREELIST(data);
return 1;
}
/* Step 3: perform the installation */
alpm_list_t *packages = alpm_trans_get_add(config->handle);
if(config->print) {
print_packages(packages);
trans_release();
return 0;
}
/* print targets and ask user confirmation */
if(packages == NULL) { /* we are done */
printf(_(" there is nothing to do\n"));
trans_release();
return retval;
}
display_targets(alpm_trans_get_remove(config->handle), 0);
display_targets(alpm_trans_get_add(config->handle), 1);
printf("\n");
int confirm = yesno(_("Proceed with installation?"));
if(!confirm) {
trans_release();
return retval;
}
if(alpm_trans_commit(config->handle, &data) == -1) {
enum _pmerrno_t err = alpm_errno(config->handle);
pm_fprintf(stderr, PM_LOG_ERROR, _("failed to commit transaction (%s)\n"),
alpm_strerror(err));
switch(err) {
case PM_ERR_FILE_CONFLICTS:
for(i = data; i; i = alpm_list_next(i)) {
pmfileconflict_t *conflict = alpm_list_getdata(i);
switch(conflict->type) {
case PM_FILECONFLICT_TARGET:
printf(_("%s exists in both '%s' and '%s'\n"),
conflict->file, conflict->target, conflict->ctarget);
break;
case PM_FILECONFLICT_FILESYSTEM:
printf(_("%s: %s exists in filesystem\n"),
conflict->target, conflict->file);
break;
}
}
break;
case PM_ERR_PKG_INVALID:
case PM_ERR_DLT_INVALID:
for(i = data; i; i = alpm_list_next(i)) {
char *filename = alpm_list_getdata(i);
printf(_("%s is invalid or corrupted\n"), filename);
}
break;
default:
break;
}
FREELIST(data);
trans_release();
return 1;
}
if(trans_release() == -1) {
retval = 1;
}
return retval;
}
/**
* @brief Upgrade a specified list of packages.
*
* @param targets a list of packages (as strings) to upgrade
*
* @return 0 on success, 1 on failure
*/
int pacman_upgrade(alpm_list_t *targets)
{
int retval = 0;
alpm_list_t *i, *j, *remote = NULL;
if(targets == NULL) {
pm_printf(ALPM_LOG_ERROR, _("no targets specified (use -h for help)\n"));
return 1;
}
/* Check for URL targets and process them
*/
for(i = targets; i; i = alpm_list_next(i)) {
int *r = malloc(sizeof(int));
if(strstr(i->data, "://")) {
char *str = alpm_fetch_pkgurl(config->handle, i->data);
if(str == NULL) {
pm_printf(ALPM_LOG_ERROR, "'%s': %s\n",
(char *)i->data, alpm_strerror(alpm_errno(config->handle)));
retval = 1;
} else {
free(i->data);
i->data = str;
*r = 1;
}
} else {
*r = 0;
}
remote = alpm_list_add(remote, r);
}
if(retval) {
return retval;
}
/* Step 1: create a new transaction */
if(trans_init(config->flags, 1) == -1) {
return 1;
}
printf(_("loading packages...\n"));
/* add targets to the created transaction */
for(i = targets, j = remote; i; i = alpm_list_next(i), j = alpm_list_next(j)) {
const char *targ = i->data;
alpm_pkg_t *pkg;
alpm_siglevel_t level;
if(*(int *)j->data) {
level = alpm_option_get_remote_file_siglevel(config->handle);
} else {
level = alpm_option_get_local_file_siglevel(config->handle);
}
if(alpm_pkg_load(config->handle, targ, 1, level, &pkg) != 0) {
pm_printf(ALPM_LOG_ERROR, "'%s': %s\n",
targ, alpm_strerror(alpm_errno(config->handle)));
retval = 1;
continue;
}
if(alpm_add_pkg(config->handle, pkg) == -1) {
pm_printf(ALPM_LOG_ERROR, "'%s': %s\n",
targ, alpm_strerror(alpm_errno(config->handle)));
alpm_pkg_free(pkg);
retval = 1;
continue;
}
config->explicit_adds = alpm_list_add(config->explicit_adds, pkg);
}
FREELIST(remote);
if(retval) {
trans_release();
return retval;
}
/* now that targets are resolved, we can hand it all off to the sync code */
return sync_prepare_execute();
}
/**
* @brief Upgrade a specified list of packages.
*
* @param targets a list of packages (as strings) to upgrade
*
* @return 0 on success, 1 on failure
*/
int pacman_upgrade(alpm_list_t *targets)
{
int retval = 0, *file_is_remote;
alpm_list_t *i;
unsigned int n, num_targets;
if(targets == NULL) {
pm_printf(ALPM_LOG_ERROR, _("no targets specified (use -h for help)\n"));
return 1;
}
num_targets = alpm_list_count(targets);
/* Check for URL targets and process them */
file_is_remote = malloc(num_targets * sizeof(int));
if(file_is_remote == NULL) {
pm_printf(ALPM_LOG_ERROR, _("memory exhausted\n"));
return 1;
}
for(i = targets, n = 0; i; i = alpm_list_next(i), n++) {
if(strstr(i->data, "://")) {
char *str = alpm_fetch_pkgurl(config->handle, i->data);
if(str == NULL) {
pm_printf(ALPM_LOG_ERROR, "'%s': %s\n",
(char *)i->data, alpm_strerror(alpm_errno(config->handle)));
retval = 1;
} else {
free(i->data);
i->data = str;
file_is_remote[n] = 1;
}
} else {
file_is_remote[n] = 0;
}
}
if(retval) {
goto fail_free;
}
/* Step 1: create a new transaction */
if(trans_init(config->flags, 1) == -1) {
retval = 1;
goto fail_free;
}
printf(_("loading packages...\n"));
/* add targets to the created transaction */
for(i = targets, n = 0; i; i = alpm_list_next(i), n++) {
const char *targ = i->data;
alpm_pkg_t *pkg;
int siglevel;
if(file_is_remote[n]) {
siglevel = alpm_option_get_remote_file_siglevel(config->handle);
} else {
siglevel = alpm_option_get_local_file_siglevel(config->handle);
}
if(alpm_pkg_load(config->handle, targ, 1, siglevel, &pkg) != 0) {
pm_printf(ALPM_LOG_ERROR, "'%s': %s\n",
targ, alpm_strerror(alpm_errno(config->handle)));
retval = 1;
continue;
}
if(alpm_add_pkg(config->handle, pkg) == -1) {
pm_printf(ALPM_LOG_ERROR, "'%s': %s\n",
targ, alpm_strerror(alpm_errno(config->handle)));
alpm_pkg_free(pkg);
retval = 1;
continue;
}
config->explicit_adds = alpm_list_add(config->explicit_adds, pkg);
}
if(retval) {
goto fail_release;
}
free(file_is_remote);
/* now that targets are resolved, we can hand it all off to the sync code */
return sync_prepare_execute();
fail_release:
trans_release();
fail_free:
free(file_is_remote);
return retval;
}
void finalize_autofree_pkg ( value package )
{
fprintf( stderr, "FREEING PACKAGE!\n" );
alpm_pkg_free( Package_val( package ));
return;
}
/** Frees an alpm package loaded via alpm_pkg_load().
* This is the only case where we have to keep track
* of package memory. */
static void free_loaded_pkg(void* ptr)
{
alpm_pkg_t* p_pkg = (alpm_pkg_t*) ptr;
alpm_pkg_free(p_pkg);
}
static void pyalpm_package_dealloc(AlpmPackage *self) {
if (self->needs_free)
alpm_pkg_free(self->c_data);
Py_TYPE(self)->tp_free((PyObject*)self);
}
int pacman_query(alpm_list_t *targets)
{
int ret = 0;
int match = 0;
alpm_list_t *i;
alpm_pkg_t *pkg = NULL;
alpm_db_t *db_local;
/* First: operations that do not require targets */
/* search for a package */
if(config->op_q_search) {
ret = query_search(targets);
return ret;
}
/* looking for groups */
if(config->group) {
ret = query_group(targets);
return ret;
}
if(config->op_q_foreign || config->op_q_upgrade) {
if(check_syncdbs(1, 1)) {
return 1;
}
}
db_local = alpm_option_get_localdb(config->handle);
/* operations on all packages in the local DB
* valid: no-op (plain -Q), list, info, check
* invalid: isfile, owns */
if(targets == NULL) {
if(config->op_q_isfile || config->op_q_owns) {
pm_printf(ALPM_LOG_ERROR, _("no targets specified (use -h for help)\n"));
return 1;
}
for(i = alpm_db_get_pkgcache(db_local); i; i = alpm_list_next(i)) {
pkg = alpm_list_getdata(i);
if(filter(pkg)) {
int value = display(pkg);
if(value != 0) {
ret = 1;
}
match = 1;
}
}
if(!match) {
ret = 1;
}
return ret;
}
/* Second: operations that require target(s) */
/* determine the owner of a file */
if(config->op_q_owns) {
ret = query_fileowner(targets);
return ret;
}
/* operations on named packages in the local DB
* valid: no-op (plain -Q), list, info, check */
for(i = targets; i; i = alpm_list_next(i)) {
char *strname = alpm_list_getdata(i);
if(config->op_q_isfile) {
alpm_pkg_load(config->handle, strname, 1, 0, &pkg);
} else {
pkg = alpm_db_get_pkg(db_local, strname);
}
if(pkg == NULL) {
switch(alpm_errno(config->handle)) {
case ALPM_ERR_PKG_NOT_FOUND:
pm_fprintf(stderr, ALPM_LOG_ERROR,
_("package '%s' was not found\n"), strname);
if(!config->op_q_isfile && access(strname, R_OK) == 0) {
pm_fprintf(stderr, ALPM_LOG_WARNING,
_("'%s' is a file, you might want to use %s.\n"),
strname, "-p/--file");
}
break;
default:
pm_fprintf(stderr, ALPM_LOG_ERROR,
_("could not load package '%s': %s\n"), strname,
alpm_strerror(alpm_errno(config->handle)));
break;
}
ret = 1;
continue;
}
if(filter(pkg)) {
int value = display(pkg);
if(value != 0) {
ret = 1;
}
match = 1;
}
if(config->op_q_isfile) {
alpm_pkg_free(pkg);
pkg = NULL;
}
}
if(!match) {
ret = 1;
}
return ret;
}
int pacman_query(alpm_list_t *targets)
{
int ret = 0;
int match = 0;
alpm_list_t *i;
alpm_pkg_t *pkg = NULL;
alpm_db_t *db_local;
/* First: operations that do not require targets */
/* search for a package */
if(config->op_q_search) {
ret = query_search(targets);
return ret;
}
/* looking for groups */
if(config->group) {
ret = query_group(targets);
return ret;
}
if(config->op_q_foreign || config->op_q_upgrade) {
if(check_syncdbs(1, 1)) {
return 1;
}
}
db_local = alpm_option_get_localdb(config->handle);
/* operations on all packages in the local DB
* valid: no-op (plain -Q), list, info, check
* invalid: isfile, owns */
if(targets == NULL) {
if(config->op_q_isfile || config->op_q_owns) {
pm_printf(ALPM_LOG_ERROR, _("no targets specified (use -h for help)\n"));
return 1;
}
for(i = alpm_db_get_pkgcache(db_local); i; i = alpm_list_next(i)) {
pkg = alpm_list_getdata(i);
if(filter(pkg)) {
int value = display(pkg);
if(value != 0) {
ret = 1;
}
match = 1;
}
}
if(!match) {
ret = 1;
}
return ret;
}
/* Second: operations that require target(s) */
/* determine the owner of a file */
if(config->op_q_owns) {
ret = query_fileowner(targets);
return ret;
}
/* operations on named packages in the local DB
* valid: no-op (plain -Q), list, info, check */
for(i = targets; i; i = alpm_list_next(i)) {
char *strname = alpm_list_getdata(i);
if(config->op_q_isfile) {
alpm_pkg_load(config->handle, strname, 1, 0, &pkg);
} else {
pkg = alpm_db_get_pkg(db_local, strname);
}
if(pkg == NULL) {
pm_fprintf(stderr, ALPM_LOG_ERROR, _("package \"%s\" not found\n"), strname);
ret = 1;
continue;
}
if(filter(pkg)) {
int value = display(pkg);
if(value != 0) {
ret = 1;
}
match = 1;
}
if(config->op_q_isfile) {
alpm_pkg_free(pkg);
pkg = NULL;
}
}
if(!match) {
ret = 1;
}
return ret;
}
