static int register_repo(config_repo_t *repo) { alpm_list_t *i; alpm_db_t *db; repo->siglevel = merge_siglevel(config->siglevel, repo->siglevel, repo->siglevel_mask); db = alpm_register_syncdb(config->handle, repo->name, repo->siglevel); if(db == NULL) { pm_printf(ALPM_LOG_ERROR, _("could not register '%s' database (%s)\n"), repo->name, alpm_strerror(alpm_errno(config->handle))); return 1; } pm_printf(ALPM_LOG_DEBUG, "setting usage of %d for %s repository\n", repo->usage == 0 ? ALPM_DB_USAGE_ALL : repo->usage, repo->name); alpm_db_set_usage(db, repo->usage == 0 ? ALPM_DB_USAGE_ALL : repo->usage); for(i = repo->servers; i; i = alpm_list_next(i)) { char *value = i->data; if(_add_mirror(db, value) != 0) { pm_printf(ALPM_LOG_ERROR, _("could not add mirror '%s' to database '%s' (%s)\n"), value, repo->name, alpm_strerror(alpm_errno(config->handle))); return 1; } } return 0; }
static int remove_target(const char *target) { alpm_pkg_t *pkg; alpm_db_t *db_local = alpm_get_localdb(config->handle); alpm_list_t *p; if((pkg = alpm_db_get_pkg(db_local, target)) != NULL) { if(alpm_remove_pkg(config->handle, pkg) == -1) { pm_printf(ALPM_LOG_ERROR, "'%s': %s\n", target, alpm_strerror(alpm_errno(config->handle))); return -1; } config->explicit_removes = alpm_list_add(config->explicit_removes, pkg); return 0; } /* fallback to group */ alpm_group_t *grp = alpm_db_get_group(db_local, target); if(grp == NULL) { pm_printf(ALPM_LOG_ERROR, _("target not found: %s\n"), target); return -1; } for(p = grp->packages; p; p = alpm_list_next(p)) { pkg = p->data; if(alpm_remove_pkg(config->handle, pkg) == -1) { pm_printf(ALPM_LOG_ERROR, "'%s': %s\n", target, alpm_strerror(alpm_errno(config->handle))); return -1; } config->explicit_removes = alpm_list_add(config->explicit_removes, pkg); } return 0; }
gboolean pk_backend_transaction_simulate (PkBackend *self, GError **error) { alpm_list_t *data = NULL; gchar *prefix; g_return_val_if_fail (self != NULL, FALSE); g_return_val_if_fail (alpm != NULL, FALSE); if (alpm_trans_prepare (alpm, &data) >= 0) { return TRUE; } switch (alpm_errno (alpm)) { case ALPM_ERR_PKG_INVALID_ARCH: prefix = alpm_pkg_build_list (data); alpm_list_free (data); break; case ALPM_ERR_UNSATISFIED_DEPS: prefix = alpm_miss_build_list (data); alpm_list_free_inner (data, alpm_depmissing_free); alpm_list_free (data); break; case ALPM_ERR_CONFLICTING_DEPS: prefix = alpm_conflict_build_list (data); alpm_list_free_inner (data, alpm_conflict_free); alpm_list_free (data); break; case ALPM_ERR_FILE_CONFLICTS: prefix = alpm_fileconflict_build_list (data); alpm_list_free_inner (data, alpm_fileconflict_free); alpm_list_free (data); break; default: prefix = NULL; if (data != NULL) { g_warning ("unhandled error %d", alpm_errno (alpm)); } break; } if (prefix != NULL) { alpm_errno_t errno = alpm_errno (alpm); g_set_error (error, ALPM_ERROR, errno, "%s: %s", prefix, alpm_strerror (errno)); g_free (prefix); } else { alpm_errno_t errno = alpm_errno (alpm); g_set_error_literal (error, ALPM_ERROR, errno, alpm_strerror (errno)); } return FALSE; }
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(); }
gboolean pk_backend_transaction_commit (PkBackend *self, GError **error) { alpm_list_t *data = NULL; gchar *prefix; g_return_val_if_fail (self != NULL, FALSE); g_return_val_if_fail (alpm != NULL, FALSE); if (pk_backend_cancelled (self)) { return TRUE; } pk_backend_job_set_allow_cancel (self, FALSE); pk_backend_job_set_status (self, PK_STATUS_ENUM_RUNNING); if (alpm_trans_commit (alpm, &data) >= 0) { return TRUE; } switch (alpm_errno (alpm)) { case ALPM_ERR_FILE_CONFLICTS: prefix = alpm_fileconflict_build_list (data); alpm_list_free_inner (data, alpm_fileconflict_free); alpm_list_free (data); break; case ALPM_ERR_PKG_INVALID: case ALPM_ERR_DLT_INVALID: prefix = alpm_string_build_list (data); alpm_list_free (data); break; default: prefix = NULL; if (data != NULL) { g_warning ("unhandled error %d", alpm_errno (alpm)); } break; } if (prefix != NULL) { alpm_errno_t errno = alpm_errno (alpm); g_set_error (error, ALPM_ERROR, errno, "%s: %s", prefix, alpm_strerror (errno)); g_free (prefix); } else { alpm_errno_t errno = alpm_errno (alpm); g_set_error_literal (error, ALPM_ERROR, errno, alpm_strerror (errno)); } return FALSE; }
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; }
/** Free the resources. * * @param ret the return value */ int ipacman_add_server(const char *name, const char *server) { alpm_db_t *db; db = alpm_register_syncdb(handle, name, ALPM_SIG_DATABASE_OPTIONAL); if(db == NULL) { printf("could not register '%s' database (%s)\n", name, alpm_strerror(alpm_errno(handle))); return 1; } if(alpm_db_add_server(db, server) != 0) { printf("could not add server URL to database '%s': %s (%s)\n", name, server, alpm_strerror(alpm_errno(handle))); return 1; } return 0; }
static gboolean pk_backend_repo_disable_thread (PkBackend *self) { const alpm_list_t *i; const gchar *repo; GError *error = NULL; g_return_val_if_fail (self != NULL, FALSE); g_return_val_if_fail (alpm != NULL, FALSE); g_return_val_if_fail (disabled != NULL, FALSE); repo = pk_backend_get_string (self, "repo_id"); g_return_val_if_fail (repo != NULL, FALSE); for (i = alpm_get_syncdbs (alpm); i != NULL; i = i->next) { alpm_db_t *db = (alpm_db_t *) i->data; const gchar *name = alpm_db_get_name (db); if (g_strcmp0 (repo, name) == 0) { if (alpm_db_unregister (db) < 0) { alpm_errno_t errno = alpm_errno (alpm); g_set_error (&error, ALPM_ERROR, errno, "[%s]: %s", repo, alpm_strerror (errno)); } else { g_hash_table_insert (disabled, g_strdup (repo), GINT_TO_POINTER (1)); } break; } } if (i == NULL) { int code = ALPM_ERR_DB_NULL; g_set_error (&error, ALPM_ERROR, code, "[%s]: %s", repo, alpm_strerror (code)); } if (error != NULL) { pk_backend_error (self, error); g_error_free (error); } pk_backend_thread_finished (self); return (error == NULL); }
static int _add_mirror(alpm_db_t *db, char *value) { const char *dbname = alpm_db_get_name(db); /* let's attempt a replacement for the current repo */ char *temp = strreplace(value, "$repo", dbname); /* let's attempt a replacement for the arch */ const char *arch = config->arch; char *server; if(arch) { server = strreplace(temp, "$arch", arch); free(temp); } else { if(strstr(temp, "$arch")) { free(temp); pm_printf(ALPM_LOG_ERROR, _("mirror '%s' contains the '%s' variable, but no '%s' is defined.\n"), value, "$arch", "Architecture"); return 1; } server = temp; } if(alpm_db_add_server(db, server) != 0) { /* pm_errno is set by alpm_db_setserver */ pm_printf(ALPM_LOG_ERROR, _("could not add server URL to database '%s': %s (%s)\n"), dbname, server, alpm_strerror(alpm_errno(config->handle))); free(server); return 1; } free(server); return 0; }
static void pk_backend_repo_enable_thread (PkBackendJob *job, GVariant *params, gpointer user_data) { const gchar *repo; GError *error = NULL; g_return_val_if_fail (self != NULL, FALSE); g_return_val_if_fail (disabled != NULL, FALSE); repo = pk_backend_get_string (self, "repo_id"); if (g_hash_table_remove (disabled, repo)) { /* reload configuration to preserve ordering */ if (disabled_repos_configure (disabled, &error)) { pk_backend_repo_list_changed (self); } } else { int code = PM_ERR_DB_NOT_NULL; g_set_error (&error, ALPM_ERROR, code, "[%s]: %s", repo, alpm_strerror (code)); } if (error != NULL) { pk_backend_error (self, error); g_error_free (error); } pk_backend_job_finished (self); }
gboolean pk_backend_transaction_initialize (PkBackend *self, alpm_transflag_t flags, GError **error) { g_return_val_if_fail (self != NULL, FALSE); g_return_val_if_fail (alpm != NULL, FALSE); g_return_val_if_fail (cancellable != NULL, FALSE); if (alpm_trans_init (alpm, flags) < 0) { alpm_errno_t errno = alpm_errno (alpm); g_set_error_literal (error, ALPM_ERROR, errno, alpm_strerror (errno)); return FALSE; } alpm_option_set_eventcb (alpm, pk_backend_transaction_event_cb); alpm_option_set_questioncb (alpm, pk_backend_transaction_conv_cb); alpm_option_set_progresscb (alpm, pk_backend_transaction_progress_cb); alpm_option_set_dlcb (alpm, pk_backend_transaction_dlcb); alpm_option_set_totaldlcb (alpm, pk_backend_transaction_totaldlcb); g_cancellable_connect (cancellable, G_CALLBACK (transaction_cancelled_cb), self, NULL); return TRUE; }
static alpm_list_t *gather_packages(alpm_handle_t *alpm, alpm_list_t *targets) { alpm_list_t *results = NULL; if (opt_localpkg) { alpm_list_t *i; /* load each target as a package */ for (i = targets; i; i = alpm_list_next(i)) { alpm_pkg_t *pkg; int err; err = alpm_pkg_load(alpm, i->data, 0, 0, &pkg); if (err) { fprintf(stderr, "error: %s: %s\n", (const char*)i->data, alpm_strerror(alpm_errno(alpm))); continue; } results = alpm_list_add(results, pkg); } } else { results = resolve_pkg(targets); } return results; }
static alpm_list_t * pk_backend_find_requirer (PkBackend *self, alpm_list_t *pkgs, const gchar *name, GError **error) { alpm_pkg_t *requirer; g_return_val_if_fail (self != NULL, pkgs); g_return_val_if_fail (name != NULL, pkgs); g_return_val_if_fail (localdb != NULL, pkgs); if (alpm_list_find_pkg (pkgs, name) != NULL) { return pkgs; } /* look for local requirers */ requirer = alpm_db_get_pkg (localdb, name); if (requirer != NULL) { pk_backend_pkg (self, requirer, PK_INFO_ENUM_INSTALLED); if (pk_backend_get_bool (self, "recursive")) { pkgs = alpm_list_add (pkgs, requirer); } } else { int code = ALPM_ERR_PKG_NOT_FOUND; g_set_error (error, ALPM_ERROR, code, "%s: %s", name, alpm_strerror (code)); } return pkgs; }
static gboolean pk_backend_repo_enable_thread (PkBackend *self) { const gchar *repo; GError *error = NULL; g_return_val_if_fail (self != NULL, FALSE); g_return_val_if_fail (disabled != NULL, FALSE); repo = pk_backend_get_string (self, "repo_id"); g_return_val_if_fail (repo != NULL, FALSE); if (g_hash_table_remove (disabled, repo)) { /* reload configuration to preserve ordering */ if (disabled_repos_configure (disabled, TRUE, &error)) { pk_backend_repo_list_changed (self); } } else { int code = ALPM_ERR_DB_NOT_NULL; g_set_error (&error, ALPM_ERROR, code, "[%s]: %s", repo, alpm_strerror (code)); } if (error != NULL) { pk_backend_error (self, error); g_error_free (error); } pk_backend_thread_finished (self); return (error == NULL); }
gboolean pk_backend_transaction_end (PkBackend *self, GError **error) { g_return_val_if_fail (self != NULL, FALSE); g_return_val_if_fail (alpm != NULL, FALSE); alpm_option_set_eventcb (alpm, NULL); alpm_option_set_questioncb (alpm, NULL); alpm_option_set_progresscb (alpm, NULL); alpm_option_set_dlcb (alpm, NULL); alpm_option_set_totaldlcb (alpm, NULL); if (dpkg != NULL) { pk_backend_transaction_download_end (self); } if (tpkg != NULL) { pk_backend_output_end (self); } if (alpm_trans_release (alpm) < 0) { alpm_errno_t errno = alpm_errno (alpm); g_set_error_literal (error, ALPM_ERROR, errno, alpm_strerror (errno)); return FALSE; } return TRUE; }
/* * Return: 0 for success. */ int ipacman_sync_packages(alpm_list_t *targets) { int ret = 0; alpm_list_t *i; alpm_list_t *sync_dbs = alpm_get_syncdbs(handle); if(sync_dbs == NULL) { printf("no usable package repositories configured.\n"); return 1; } /* ensure all known dbs are valid */ for(i = sync_dbs; i; i = alpm_list_next(i)) { alpm_db_t *db = i->data; if(alpm_db_get_valid(db)) { printf("database '%s' is not valid (%s)\n", alpm_db_get_name(db), alpm_strerror(alpm_errno(handle))); ret = 1; } } if (ret) return ret; /* Step 1: create a new transaction... */ ret = alpm_trans_init(handle, ALPM_TRANS_FLAG_FORCE); if(ret == -1) { trans_init_error(handle); return 1; } /* process targets */ for(i = targets; i; i = alpm_list_next(i)) { const char *targ = i->data; if(process_target(targ, ret) == 1) { ret = 1; } } if(ret) { if(alpm_trans_release(handle) == -1) { printf("failed to release transaction (%s)\n", alpm_strerror(alpm_errno(handle))); } return ret; } return sync_prepare_execute(); }
static int trans_release(alpm_handle_t *handle) { if(alpm_trans_release(handle) == -1) { printf("failed to release transaction (%s)\n", alpm_strerror(alpm_errno(handle))); return -1; } return 0; }
int trans_release(void) { if(alpm_trans_release(config->handle) == -1) { pm_printf(ALPM_LOG_ERROR, _("failed to release transaction (%s)\n"), alpm_strerror(alpm_errno(config->handle))); return -1; } return 0; }
static gboolean disabled_repos_configure (GHashTable *table, gboolean only_trusted, GError **error) { const alpm_list_t *i; g_return_val_if_fail (table != NULL, FALSE); g_return_val_if_fail (alpm != NULL, FALSE); if (alpm_unregister_all_syncdbs (alpm) < 0) { alpm_errno_t errno = alpm_errno (alpm); g_set_error_literal (error, ALPM_ERROR, errno, alpm_strerror (errno)); return FALSE; } for (i = configured; i != NULL; i = i->next) { PkBackendRepo *repo = (PkBackendRepo *) i->data; alpm_siglevel_t level = repo->level; alpm_db_t *db; if (g_hash_table_lookup (table, repo->name) != NULL) { /* repo is disabled */ continue; } else if (!only_trusted) { level &= ~ALPM_SIG_PACKAGE; level &= ~ALPM_SIG_DATABASE; level &= ~ALPM_SIG_USE_DEFAULT; } db = alpm_register_syncdb (alpm, repo->name, level); if (db == NULL) { alpm_errno_t errno = alpm_errno (alpm); g_set_error (error, ALPM_ERROR, errno, "[%s]: %s", repo->name, alpm_strerror (errno)); return FALSE; } alpm_db_set_servers (db, alpm_list_strdup (repo->servers)); } return TRUE; }
/** * Wrap up a section once we have reached the end of it. This should be called * when a subsequent section is encountered, or when we have reached the end of * the root config file. Once called, all existing saved config pieces on the * section struct are freed. * @param section the current parsed and saved section data * @param parse_options whether we are parsing options or repo data * @return 0 on success, 1 on failure */ static int finish_section(struct section_t *section, int parse_options) { int ret = 0; alpm_list_t *i; alpm_db_t *db; pm_printf(ALPM_LOG_DEBUG, "config: finish section '%s'\n", section->name); /* parsing options (or nothing)- nothing to do except free the pieces */ if(!section->name || parse_options || section->is_options) { goto cleanup; } /* if we are not looking at options sections only, register a db */ db = alpm_register_syncdb(config->handle, section->name, section->siglevel); if(db == NULL) { pm_printf(ALPM_LOG_ERROR, _("could not register '%s' database (%s)\n"), section->name, alpm_strerror(alpm_errno(config->handle))); ret = 1; goto cleanup; } for(i = section->servers; i; i = alpm_list_next(i)) { char *value = i->data; if(_add_mirror(db, value) != 0) { pm_printf(ALPM_LOG_ERROR, _("could not add mirror '%s' to database '%s' (%s)\n"), value, section->name, alpm_strerror(alpm_errno(config->handle))); ret = 1; goto cleanup; } free(value); } cleanup: alpm_list_free(section->servers); section->servers = NULL; section->siglevel = ALPM_SIG_USE_DEFAULT; free(section->name); section->name = NULL; return ret; }
static gboolean asb_package_alpm_open (AsbPackage *pkg, const gchar *filename, GError **error) { AsbPackageAlpm *pkg_alpm = ASB_PACKAGE_ALPM (pkg); AsbPackageAlpmPrivate *priv = GET_PRIVATE (pkg_alpm); alpm_errno_t alpm_error; /* initialize the alpm library */ priv->handle = alpm_initialize ("/", "/tmp", &alpm_error); if (priv->handle == NULL) { g_set_error (error, ASB_PLUGIN_ERROR, ASB_PLUGIN_ERROR_FAILED, "libalpm initialization failed %s (%u) for %s", alpm_strerror (alpm_error), alpm_error, filename); return FALSE; } /* open the package */ if (alpm_pkg_load (priv->handle, filename, TRUE, 0, &priv->package) == -1) { g_set_error (error, ASB_PLUGIN_ERROR, ASB_PLUGIN_ERROR_FAILED, "Failed to load package %s : %s (%u)", filename, alpm_strerror (alpm_errno (priv->handle)), alpm_errno (priv->handle)); alpm_release (priv->handle); return FALSE; } asb_package_set_name (pkg, alpm_pkg_get_name (priv->package)); asb_package_set_url (pkg, alpm_pkg_get_url (priv->package)); asb_package_set_arch (pkg, alpm_pkg_get_arch (priv->package)); asb_package_alpm_ensure_version (pkg, error); return TRUE; }
/** * call-seq: * new( rootpath , dbpath ) → an_alpm * * Creates a new Alpm instance configured for the given directories. * * === Parameters * [rootpath] * File system root directory to install packages under. * [dbpath] * Directory used for permanent storage of things like the * list of currently installed packages. * * === Return value * The newly created instance. */ static VALUE initialize(VALUE self, VALUE root, VALUE dbpath) { alpm_handle_t* p_alpm = NULL; alpm_errno_t err; p_alpm = alpm_initialize(StringValuePtr(root), StringValuePtr(dbpath), &err); if (!p_alpm) rb_raise(rb_eRuntimeError, "Initializing alpm library failed: %s", alpm_strerror(err)); DATA_PTR(self) = p_alpm; return self; }
alpm_pkg_t * pk_backend_find_pkg (PkBackend *self, const gchar *package_id, GError **error) { gchar **package; const gchar *repo_id; alpm_db_t *db = NULL; alpm_pkg_t *pkg; g_return_val_if_fail (self != NULL, NULL); g_return_val_if_fail (package_id != NULL, NULL); g_return_val_if_fail (alpm != NULL, NULL); g_return_val_if_fail (localdb != NULL, NULL); package = pk_package_id_split (package_id); repo_id = package[PK_PACKAGE_ID_DATA]; /* find the database to search in */ if (g_strcmp0 (repo_id, "installed") == 0) { db = localdb; } else { const alpm_list_t *i = alpm_get_syncdbs (alpm); for (; i != NULL; i = i->next) { const gchar *repo = alpm_db_get_name (i->data); if (g_strcmp0 (repo, repo_id) == 0) { db = i->data; break; } } } if (db != NULL) { pkg = alpm_db_get_pkg (db, package[PK_PACKAGE_ID_NAME]); } else { pkg = NULL; } if (pkg != NULL) { const gchar *version = alpm_pkg_get_version (pkg); if (g_strcmp0 (version, package[PK_PACKAGE_ID_VERSION]) != 0) { pkg = NULL; } } if (pkg == NULL) { int code = ALPM_ERR_PKG_NOT_FOUND; g_set_error (error, ALPM_ERROR, code, "%s: %s", package_id, alpm_strerror (code)); } g_strfreev (package); return pkg; }
static void trans_init_error(alpm_handle_t *handle) { alpm_errno_t err = alpm_errno(handle); printf("failed to init transaction (%s)\n", alpm_strerror(err)); if(err == ALPM_ERR_HANDLE_LOCK) { const char *lockfile = alpm_option_get_lockfile(handle); printf("could not lock database: %s\n", strerror(errno)); if(access(lockfile, F_OK) == 0) { fprintf(stderr, " if you're sure a package manager is not already\n" " running, you can remove %s\n", lockfile); } } }
static alpm_handle_t *alpm_init(void) { alpm_handle_t *alpm = NULL; enum _alpm_errno_t alpm_errno = 0; FILE *fp; char line[PATH_MAX]; char *ptr, *section = NULL; alpm = alpm_initialize("/", "/var/lib/pacman", &alpm_errno); if (!alpm) { alpm_strerror(alpm_errno); return NULL; } db_local = alpm_get_localdb(alpm); fp = fopen("/etc/pacman.conf", "r"); if (!fp) { perror("fopen: /etc/pacman.conf"); return alpm; } while (fgets(line, PATH_MAX, fp)) { strtrim(line); if (strlen(line) == 0 || line[0] == '#') { continue; } if ((ptr = strchr(line, '#'))) { *ptr = '\0'; } if (line[0] == '[' && line[strlen(line) - 1] == ']') { ptr = &line[1]; if (section) { free(section); } section = strdup(ptr); section[strlen(section) - 1] = '\0'; if (strcmp(section, "options") != 0) { alpm_register_syncdb(alpm, section, 0); } } } free(section); fclose(fp); return alpm; }
static gboolean pk_alpm_disabled_repos_configure (PkBackend *backend, gboolean only_trusted, GError **error) { PkBackendAlpmPrivate *priv = pk_backend_get_user_data (backend); const alpm_list_t *i; if (alpm_unregister_all_syncdbs (priv->alpm) < 0) { alpm_errno_t errno = alpm_errno (priv->alpm); g_set_error_literal (error, PK_ALPM_ERROR, errno, alpm_strerror (errno)); return FALSE; } for (i = priv->configured_repos; i != NULL; i = i->next) { PkBackendRepo *repo = (PkBackendRepo *) i->data; alpm_siglevel_t level = repo->level; alpm_db_t *db; if (!only_trusted) { level &= ~ALPM_SIG_PACKAGE; level &= ~ALPM_SIG_DATABASE; level &= ~ALPM_SIG_USE_DEFAULT; } db = alpm_register_syncdb (priv->alpm, repo->name, level); if (db == NULL) { alpm_errno_t errno = alpm_errno (priv->alpm); g_set_error (error, PK_ALPM_ERROR, errno, "[%s]: %s", repo->name, alpm_strerror (errno)); return FALSE; } alpm_db_set_servers (db, alpm_list_strdup (repo->servers)); } return TRUE; }
/** * @brief Modify the 'local' package database. * * @param targets a list of packages (as strings) to modify * * @return 0 on success, 1 on failure */ int pacman_database(alpm_list_t *targets) { alpm_list_t *i; alpm_db_t *db_local; int retval = 0; alpm_pkgreason_t reason; if(targets == NULL) { pm_printf(ALPM_LOG_ERROR, _("no targets specified (use -h for help)\n")); return 1; } if(config->flags & ALPM_TRANS_FLAG_ALLDEPS) { /* --asdeps */ reason = ALPM_PKG_REASON_DEPEND; } else if(config->flags & ALPM_TRANS_FLAG_ALLEXPLICIT) { /* --asexplicit */ reason = ALPM_PKG_REASON_EXPLICIT; } else { pm_printf(ALPM_LOG_ERROR, _("no install reason specified (use -h for help)\n")); return 1; } /* Lock database */ if(trans_init(0, 0) == -1) { return 1; } db_local = alpm_option_get_localdb(config->handle); for(i = targets; i; i = alpm_list_next(i)) { char *pkgname = i->data; alpm_pkg_t *pkg = alpm_db_get_pkg(db_local, pkgname); if(!pkg || alpm_db_set_pkgreason(config->handle, pkg, reason)) { pm_printf(ALPM_LOG_ERROR, _("could not set install reason for package %s (%s)\n"), pkgname, alpm_strerror(alpm_errno(config->handle))); retval = 1; } else { if(reason == ALPM_PKG_REASON_DEPEND) { printf(_("%s: install reason has been set to 'installed as dependency'\n"), pkgname); } else { printf(_("%s: install reason has been set to 'explicitly installed'\n"), pkgname); } } } /* Unlock database */ if(trans_release() == -1) { return 1; } return retval; }
static void checkdbs(alpm_list_t *dbnames) { alpm_db_t *db = NULL; alpm_list_t *i; const alpm_siglevel_t level = ALPM_SIG_DATABASE | ALPM_SIG_DATABASE_OPTIONAL; for(i = dbnames; i; i = alpm_list_next(i)) { const char *dbname = i->data; db = alpm_register_syncdb(handle, dbname, level); if(db == NULL) { fprintf(stderr, "error: could not register sync database '%s' (%s)\n", dbname, alpm_strerror(alpm_errno(handle))); continue; } checkpkgs(alpm_db_get_pkgcache(db)); } }
static alpm_list_t *expac_search_files(expac_t *expac, alpm_list_t *targets) { alpm_list_t *i, *r = NULL; for(i = targets; i; i = i->next) { const char *path = i->data; alpm_pkg_t *pkg; if(alpm_pkg_load(expac->alpm, path, 0, 0, &pkg) != 0) { fprintf(stderr, "error: %s: %s\n", path, alpm_strerror(alpm_errno(expac->alpm))); continue; } r = alpm_list_add(r, pkg); } return r; }