alpm_handle_t * pk_backend_configure (const gchar *filename, GError **error) { PkBackendConfig *config; alpm_handle_t *handle; GError *e = NULL; g_return_val_if_fail (filename != NULL, FALSE); g_debug ("reading config from %s", filename); config = pk_backend_config_new (); pk_backend_config_enter_section (config, "options"); if (pk_backend_config_parse (config, filename, NULL, &e)) { handle = pk_backend_config_configure_alpm (config, &e); } else { handle = NULL; } pk_backend_config_free (config); if (e != NULL) { g_propagate_error (error, e); if (handle != NULL) { alpm_release (handle); } return NULL; } else { return handle; } }
int main(int argc, char *argv[]) { int ret; enum _alpm_errno_t err; setlocale(LC_ALL, ""); strings_init(); if (argc == 1) { cwr_fprintf(stderr, LOG_ERROR, "not enough arguments\n"); exit(EXIT_FAILURE); } const command_t *cmd = find(argv[1]); if (!cmd) { cwr_fprintf(stderr, LOG_ERROR, "command %s not understood\n", argv[1]); exit(EXIT_FAILURE); } /* if ((ret = parse_options(argc, argv)) != 0) */ /* return ret; */ cwr_fprintf(stderr, LOG_DEBUG, "initializing alpm\n"); pmhandle = alpm_initialize(PACMAN_ROOT, PACMAN_DBPATH, &err); if (!pmhandle) { cwr_fprintf(stderr, LOG_ERROR, "failed to initialize alpm library\n"); goto finish; } ret = run(cmd, --argc, ++argv); finish: alpm_release(pmhandle); return ret; }
static void expac_free(expac_t *expac) { if(expac == NULL) { return; } alpm_release(expac->alpm); }
static void cleanup(int signum) { if(handle && alpm_release(handle) == -1) { fprintf(stderr, "error releasing alpm\n"); } exit(signum); }
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; }
PyObject* pyalpm_release(PyObject *self, PyObject *args) { AlpmHandle *pyhandle; if(!PyArg_ParseTuple(args, "O!", &AlpmHandleType, &pyhandle)) return NULL; alpm_release(pyhandle->c_data); pyhandle->c_data = NULL; Py_RETURN_NONE; }
void ipacman_cleanup(void) { //specialized for installer /*alpm_option_remove_cachedir(handle, "/PKGS");*/ /* free alpm library resources */ if(handle && alpm_release(handle) == -1) { printf("error releasing alpm library\n"); } }
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; }
/** Free the resources. * * @param ret the return value */ static void cleanup(int ret) { if(config) { /* free alpm library resources */ if(config->handle && alpm_release(config->handle) == -1) { pm_printf(ALPM_LOG_ERROR, "error releasing alpm library\n"); } config_free(config); config = NULL; } /* free memory */ FREELIST(pm_targets); exit(ret); }
void pk_backend_destroy (PkBackend *backend) { PkBackendAlpmPrivate *priv = pk_backend_get_user_data (backend); pk_alpm_groups_destroy (backend); pk_alpm_destroy_databases (backend); if (priv->alpm != NULL) { if (alpm_trans_get_flags (priv->alpm) < 0) alpm_trans_release (priv->alpm); alpm_release (priv->alpm); } FREELIST (priv->syncfirsts); FREELIST (priv->holdpkgs); g_free (priv); }
void cleanup (int ret) { static int cleaned=0; if (cleaned) return; cleaned=1; if (config.handle && alpm_release(config.handle) == -1) fprintf(stderr, "error releasing alpm library\n"); FREELIST(targets); FREE (config.arch); FREE (config.aur_url); FREE (config.configfile); FREE (config.dbpath); FREE (config.rootdir); alpm_cleanup (); aur_cleanup (); color_cleanup (); exit (ret); }
int main(int argc, char *argv[]) { int ret = 1; alpm_handle_t *alpm; alpm_list_t *results = NULL, *i; alpm = alpm_init(); if (!alpm) { return ret; } ret = parse_options(argc, argv, alpm); if (ret != 0) { goto finish; } /* ensure sane defaults */ if (!dblist && !opt_localpkg) { opt_local = true; dblist = alpm_list_add(dblist, db_local); } results = gather_packages(alpm, targets); if (results == NULL) { ret = 1; goto finish; } for (i = results; i; i = alpm_list_next(i)) { alpm_pkg_t *pkg = i->data; ret += print_pkg(pkg, opt_format); } ret = !!ret; /* clamp to zero/one */ if(opt_localpkg) { alpm_list_free_inner(results, (alpm_list_fn_free)alpm_pkg_free); } alpm_list_free(results); finish: alpm_list_free(dblist); alpm_list_free(targets); alpm_release(alpm); return ret; }
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 void pk_backend_destroy_alpm (PkBackend *self) { g_return_if_fail (self != NULL); if (alpm != NULL) { if (alpm_trans_get_flags (alpm) < 0) { alpm_trans_release (alpm); } alpm_release (alpm); alpm = NULL; backend = NULL; } FREELIST (syncfirsts); FREELIST (holdpkgs); g_free (xfercmd); xfercmd = NULL; }
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; }
static void pacman_manager_finalize (GObject *object) { PacmanManagerPrivate *priv; g_return_if_fail (object != NULL); priv = PACMAN_MANAGER_GET_PRIVATE (PACMAN_MANAGER (object)); if (priv->transaction != NULL) { g_object_unref (priv->transaction); } g_free (priv->clean_method); if (priv->transfer != NULL) { g_closure_unref (priv->transfer); } pacman_list_free_full (priv->hold_packages, g_free); pacman_list_free_full (priv->sync_firsts, g_free); pacman_manager = NULL; alpm_release (); G_OBJECT_CLASS (pacman_manager_parent_class)->finalize (object); }
static void cleanup(void) { alpm_list_free(walked); alpm_list_free(provisions); alpm_release(handle); }
int main(int argc, char **argv) { alpm_list_t *i; int ret = 0; if(!(config = parse_opts(argc, argv))) { ret = 1; goto cleanup; } if(checks == 0) { checks = CHECK_DEPENDS | CHECK_FILES; } if(!(handle = pu_initialize_handle_from_config(config))) { fprintf(stderr, "error: failed to initialize alpm.\n"); ret = 1; goto cleanup; } localdb = alpm_get_localdb(handle); pkgcache = alpm_db_get_pkgcache(localdb); for(; optind < argc; ++optind) { if(load_pkg(argv[optind]) == NULL) { ret = 1; } } if(!isatty(fileno(stdin)) && errno != EBADF) { char *buf = NULL; size_t len = 0; ssize_t read; while((read = getdelim(&buf, &len, isep, stdin)) != -1) { if(buf[read - 1] == isep) { buf[read - 1] = '\0'; } if(load_pkg(buf) == NULL) { ret = 1; } } free(buf); } if(ret) { goto cleanup; } if(packages == NULL) { packages = alpm_list_copy(pkgcache); recursive = 0; } else if(recursive) { /* load [opt-]depends */ alpm_list_t *i, *originals = alpm_list_copy(packages); for(i = originals; i; i = alpm_list_next(i)) { add_deps(i->data); } alpm_list_free(originals); } for(i = packages; i; i = alpm_list_next(i)) { int pkgerr = 0; #define RUNCHECK(t, b) if((checks & t) && b != 0) { pkgerr = ret = 1; } RUNCHECK(CHECK_DEPENDS, check_depends(i->data)); RUNCHECK(CHECK_OPT_DEPENDS, check_opt_depends(i->data)); RUNCHECK(CHECK_FILES, check_files(i->data)); RUNCHECK(CHECK_FILE_PROPERTIES, check_file_properties(i->data)); RUNCHECK(CHECK_MD5SUM, check_md5sum(i->data)); RUNCHECK(CHECK_SHA256SUM, check_sha256sum(i->data)); #undef RUNCHECK if(pkgerr && list_broken) { printf("%s\n", alpm_pkg_get_name(i->data)); } } cleanup: alpm_list_free(packages); alpm_release(handle); pu_config_free(config); return ret; }
static void deallocate(void* ptr) { if (ptr) alpm_release(ptr); }