static int files_fileowner(alpm_list_t *syncs, alpm_list_t *targets) { int ret = 0; alpm_list_t *t; for(t = targets; t; t = alpm_list_next(t)) { char *filename = NULL, *f; int found = 0; alpm_list_t *s; size_t len; if((filename = strdup(t->data)) == NULL) { goto notfound; } len = strlen(filename); f = filename; while(len > 1 && f[0] == '/') { f = f + 1; len--; } for(s = syncs; s; s = alpm_list_next(s)) { alpm_list_t *p; alpm_db_t *repo = s->data; alpm_list_t *packages = alpm_db_get_pkgcache(repo); for(p = packages; p; p = alpm_list_next(p)) { alpm_pkg_t *pkg = p->data; alpm_filelist_t *files = alpm_pkg_get_files(pkg); if(alpm_filelist_contains(files, f)) { if(!config->quiet) { printf(_("%s is owned by %s/%s %s\n"), f, alpm_db_get_name(repo), alpm_pkg_get_name(pkg), alpm_pkg_get_version(pkg)); } else { printf("%s/%s\n", alpm_db_get_name(repo), alpm_pkg_get_name(pkg)); } found = 1; } } } free(filename); notfound: if(!found) { ret++; } } return 0; }
static int files_fileowner(alpm_list_t *syncs, alpm_list_t *targets) { int ret = 0; alpm_list_t *t; for(t = targets; t; t = alpm_list_next(t)) { char *filename = t->data; int found = 0; alpm_list_t *s; size_t len = strlen(filename); while(len > 1 && filename[0] == '/') { filename++; len--; } for(s = syncs; s; s = alpm_list_next(s)) { alpm_list_t *p; alpm_db_t *repo = s->data; alpm_list_t *packages = alpm_db_get_pkgcache(repo); for(p = packages; p; p = alpm_list_next(p)) { alpm_pkg_t *pkg = p->data; alpm_filelist_t *files = alpm_pkg_get_files(pkg); if(alpm_filelist_contains(files, filename)) { if(config->op_f_machinereadable) { print_line_machinereadable(repo, pkg, filename); } else if(!config->quiet) { const colstr_t *colstr = &config->colstr; printf(_("%s is owned by %s%s/%s%s %s%s\n"), filename, colstr->repo, alpm_db_get_name(repo), colstr->title, alpm_pkg_get_name(pkg), colstr->version, alpm_pkg_get_version(pkg)); } else { printf("%s/%s\n", alpm_db_get_name(repo), alpm_pkg_get_name(pkg)); } found = 1; } } } if(!found) { ret++; } } return 0; }
/** * call-seq: * name() → a_string * * Returns the name of the package database. */ static VALUE name(VALUE self) { alpm_db_t* p_db = NULL; Data_Get_Struct(self, alpm_db_t, p_db); return rb_str_new2(alpm_db_get_name(p_db)); }
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 gchar * alpm_pkg_build_urls (pmpkg_t *pkg) { GString *string = g_string_new (""); #ifdef ALPM_PACKAGE_URL const gchar *name, *arch, *repo, *url; #else const gchar *url; #endif g_return_val_if_fail (pkg != NULL, NULL); /* grab the URL of the package... */ url = alpm_pkg_get_url (pkg); if (url != NULL) { g_string_append_printf (string, "%s;Package website;", url); } #ifdef ALPM_PACKAGE_URL /* ... and construct the distro URL if possible */ name = alpm_pkg_get_name (pkg); arch = alpm_pkg_get_arch (pkg); repo = alpm_db_get_name (alpm_pkg_get_db (pkg)); g_string_append_printf (string, ALPM_PACKAGE_URL ";Distribution page;", repo, arch, name); #endif g_string_truncate (string, string->len - 1); return g_string_free (string, FALSE); }
/* Returns a statically allocated string stating which db the pkg came from * @param sdbs sync dbs * @param pkgname package to search for * @param grp pointer to alpm_list_t * used to store the pkg's groups if any */ const char *which_db(alpm_list_t *sdbs, const char *pkgname, alpm_list_t **grp) { const char *repo = NULL; alpm_list_t *i, *k; pmpkg_t *spkg; for (i = sdbs; i && !repo; i = i->next) { for (k = alpm_db_get_pkgcache(i->data); k; k = k->next) { spkg = k->data; if (!strcmp(alpm_pkg_get_name(spkg), pkgname)) { repo = alpm_db_get_name(i->data); if (grp) { *grp = alpm_pkg_get_groups(spkg); } break; } } } if (!repo) { repo = LOCAL; } return repo; }
static gboolean pk_backend_match_details (alpm_pkg_t *pkg, GRegex *regex) { const gchar *desc; alpm_db_t *db; const alpm_list_t *i; g_return_val_if_fail (pkg != NULL, FALSE); g_return_val_if_fail (regex != NULL, FALSE); /* match the name first... */ if (g_regex_match (regex, alpm_pkg_get_name (pkg), 0, NULL)) return TRUE; /* ... then the description... */ desc = alpm_pkg_get_desc (pkg); if (desc != NULL && g_regex_match (regex, desc, 0, NULL)) return TRUE; /* ... then the database... */ db = alpm_pkg_get_db (pkg); if (db != NULL && g_regex_match (regex, alpm_db_get_name (db), G_REGEX_MATCH_ANCHORED, NULL)) return TRUE; /* ... then the licenses */ for (i = alpm_pkg_get_licenses (pkg); i != NULL; i = i->next) { if (g_regex_match (regex, i->data, G_REGEX_MATCH_ANCHORED, NULL)) return TRUE; } return FALSE; }
void pu_fprint_pkgspec(FILE *stream, alpm_pkg_t *pkg) { const char *c; switch(alpm_pkg_get_origin(pkg)) { case ALPM_PKG_FROM_FILE: c = alpm_pkg_get_filename(pkg); if(strstr(c, "://")) { fprintf(stream, "%s", alpm_pkg_get_filename(pkg)); } else { char *real = realpath(c, NULL); fprintf(stream, "file://%s", real); free(real); } break; case ALPM_PKG_FROM_LOCALDB: fprintf(stream, "local/%s", alpm_pkg_get_name(pkg)); break; case ALPM_PKG_FROM_SYNCDB: fprintf(stream, "%s/%s", alpm_db_get_name(alpm_pkg_get_db(pkg)), alpm_pkg_get_name(pkg)); break; default: /* no idea where this package came from, fall back to its name */ fputs(alpm_pkg_get_name(pkg), stream); break; } }
static gboolean disabled_repos_configure (GHashTable *table, GError **error) { const alpm_list_t *i; g_debug ("reading config from %s", PK_BACKEND_CONFIG_FILE); /* read configuration from pacman.conf file */ if (!pk_backend_configure (PK_BACKEND_CONFIG_FILE, error)) { return FALSE; } /* disable disabled repos */ for (i = alpm_option_get_syncdbs (); i != NULL;) { pmdb_t *db = (pmdb_t *) i->data; const gchar *repo = alpm_db_get_name (db); if (g_hash_table_lookup (table, repo) == NULL) { /* repo is not disabled */ i = i->next; continue; } if (alpm_db_unregister (db) < 0) { g_set_error (error, ALPM_ERROR, pm_errno, "[%s]: %s", repo, alpm_strerrorlast ()); return FALSE; } /* start again because the list gets invalidated */ i = alpm_option_get_syncdbs (); } return TRUE; }
static int files_list(alpm_list_t *syncs, alpm_list_t *targets) { alpm_list_t *i, *j; int ret = 0, found = 0; if(targets != NULL) { for(i = targets; i; i = alpm_list_next(i)) { char *targ = i->data; char *repo = NULL; char *c = strchr(targ, '/'); if(c) { if(! *(c + 1)) { pm_printf(ALPM_LOG_ERROR, _("invalid package: '%s'\n"), targ); ret += 1; continue; } repo = strndup(targ, c - targ); targ = c + 1; } for(j = syncs; j; j = alpm_list_next(j)) { alpm_pkg_t *pkg; alpm_db_t *db = j->data; if(repo) { if(strcmp(alpm_db_get_name(db), repo) != 0) { continue; } } if((pkg = alpm_db_get_pkg(db, targ)) != NULL) { found = 1; dump_file_list(pkg); break; } } if(!found) { targ = i->data; pm_printf(ALPM_LOG_ERROR, _("package '%s' was not found\n"), targ); ret += 1; } free(repo); } } else { for(i = syncs; i; i = alpm_list_next(i)) { alpm_db_t *db = i->data; for(j = alpm_db_get_pkgcache(db); j; j = alpm_list_next(j)) { alpm_pkg_t *pkg = j->data; dump_file_list(pkg); } } } return ret; }
SV* c2p_db(void *db) { if(strcmp(alpm_db_get_name(db), "local") == 0) { return c2p_localdb(db); } else { return c2p_syncdb(db); } }
/** * call-seq: * inspect() → a_string * * Human-readable description. */ static VALUE inspect(VALUE self) { alpm_db_t* p_db = NULL; int len; char buf[256]; Data_Get_Struct(self, alpm_db_t, p_db); len = sprintf(buf, "#<%s %s>", rb_obj_classname(self), alpm_db_get_name(p_db)); return rb_str_new(buf, len); }
/** * Open a package changelog for reading. Similar to fopen in functionality, * except that the returned 'file stream' is from the database. * @param pkg the package (from db) to read the changelog * @return a 'file stream' to the package changelog */ static void *_cache_changelog_open(pmpkg_t *pkg) { char clfile[PATH_MAX]; snprintf(clfile, PATH_MAX, "%s/%s/%s-%s/changelog", alpm_option_get_dbpath(pkg->handle), alpm_db_get_name(alpm_pkg_get_db(pkg)), alpm_pkg_get_name(pkg), alpm_pkg_get_version(pkg)); return fopen(clfile, "r"); }
static alpm_db_t *get_db(const char *dbname) { alpm_list_t *i; for(i = alpm_get_syncdbs(handle); i; i = i->next) { alpm_db_t *db = i->data; if(strcmp(alpm_db_get_name(db), dbname) == 0) { return db; } } return NULL; }
int ipacman_refresh_databases(void) { alpm_list_t *sync_dbs = NULL; alpm_list_t *i; unsigned int success = 0; sync_dbs = alpm_get_syncdbs(handle); if(sync_dbs == NULL) { printf("no usable package repositories configured.\n"); return -1; } printf("Synchronizing package databases...\n"); alpm_logaction(handle, PACMAN_CALLER_PREFIX, "synchronizing package lists\n"); for(i = sync_dbs; i; i = alpm_list_next(i)) { alpm_db_t *db = i->data; int ret = alpm_db_update(1, db); if(ret < 0) { printf("failed to update %s (%s)\n", alpm_db_get_name(db), alpm_strerror(alpm_errno(handle))); } else if(ret == 1) { printf(" %s is up to date\n", alpm_db_get_name(db)); success++; } else { success++; } } /* We should always succeed if at least one DB was upgraded - we may possibly * fail later with unresolved deps, but that should be rare, and would be * expected */ if(!success) { printf("failed to synchronize any databases\n"); trans_init_error(handle); return success; } return 0; }
static void print_line_machinereadable(alpm_db_t *db, alpm_pkg_t *pkg, char *filename) { /* Fields are repo, pkgname, pkgver, filename separated with \0 */ fputs(alpm_db_get_name(db), stdout); fputc(0, stdout); fputs(alpm_pkg_get_name(pkg), stdout); fputc(0, stdout); fputs(alpm_pkg_get_version(pkg), stdout); fputc(0, stdout); fputs(filename, stdout); fputs("\n", stdout); }
CAMLprim value oalpm_pkg_checkmd5sum ( value package ) { pmpkg_t * pkg; pmdb_t * db; CAMLparam1( package ); pkg = Package_val( package ); db = alpm_pkg_get_db( pkg ); if ( strcmp( alpm_db_get_name( db ), "local" ) == 0 ) { caml_failwith( FAIL_CHECK_LOCALPKG ); } OALPMreturn( alpm_pkg_checkmd5sum( pkg )); }
void print_packages(const alpm_list_t *packages) { const alpm_list_t *i; if(!config->print_format) { config->print_format = strdup("%l"); } for(i = packages; i; i = alpm_list_next(i)) { alpm_pkg_t *pkg = i->data; char *string = strdup(config->print_format); char *temp = string; /* %n : pkgname */ if(strstr(temp, "%n")) { string = strreplace(temp, "%n", alpm_pkg_get_name(pkg)); free(temp); temp = string; } /* %v : pkgver */ if(strstr(temp, "%v")) { string = strreplace(temp, "%v", alpm_pkg_get_version(pkg)); free(temp); temp = string; } /* %l : location */ if(strstr(temp, "%l")) { char *pkgloc = pkg_get_location(pkg); string = strreplace(temp, "%l", pkgloc); free(pkgloc); free(temp); temp = string; } /* %r : repo */ if(strstr(temp, "%r")) { const char *repo = "local"; alpm_db_t *db = alpm_pkg_get_db(pkg); if(db) { repo = alpm_db_get_name(db); } string = strreplace(temp, "%r", repo); free(temp); temp = string; } /* %s : size */ if(strstr(temp, "%s")) { char *size; pm_asprintf(&size, "%jd", (intmax_t)pkg_get_size(pkg)); string = strreplace(temp, "%s", size); free(size); free(temp); } printf("%s\n", string); free(string); } }
static gboolean pk_backend_update_databases (PkBackend *self, gint force, GError **error) { alpm_cb_download dlcb; alpm_cb_totaldl totaldlcb; const alpm_list_t *i; g_return_val_if_fail (self != NULL, FALSE); if (!pk_backend_transaction_initialize (self, 0, error)) { return FALSE; } alpm_logaction ("synchronizing package lists\n"); dlcb = alpm_option_get_dlcb (); totaldlcb = alpm_option_get_totaldlcb (); /* set total size to minus the number of databases */ i = alpm_option_get_syncdbs (); totaldlcb (-alpm_list_count (i)); for (; i != NULL; i = i->next) { gint result; if (pk_backend_cancelled (self)) { /* pretend to be finished */ i = NULL; break; } result = alpm_db_update (force, i->data); if (result > 0) { /* fake the download when already up to date */ dlcb ("", 1, 1); } else if (result < 0) { g_set_error (error, ALPM_ERROR, pm_errno, "[%s]: %s", alpm_db_get_name (i->data), alpm_strerrorlast ()); break; } } totaldlcb (0); if (i == NULL) { return pk_backend_transaction_end (self, error); } else { pk_backend_transaction_end (self, NULL); return FALSE; } }
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 alpm_list_t *resolve_pkg(alpm_list_t *targets) { char *pkgname, *reponame; alpm_list_t *t, *r, *ret = NULL; if (targets == NULL) { return all_packages(dblist); } else if (opt_search) { return search_packages(dblist, targets); } else if (opt_groups) { return search_groups(dblist, targets); } /* resolve each target individually from the repo pool */ for (t = targets; t; t = alpm_list_next(t)) { alpm_pkg_t *pkg = NULL; int found = 0; pkgname = reponame = t->data; if (strchr(pkgname, '/')) { strsep(&pkgname, "/"); } else { reponame = NULL; } for (r = dblist; r; r = alpm_list_next(r)) { alpm_db_t *repo = r->data; if (reponame && strcmp(reponame, alpm_db_get_name(repo)) != 0) { continue; } pkg = alpm_db_get_pkg(repo, pkgname); if (pkg == NULL) { continue; } found = 1; ret = alpm_list_add(ret, pkg); if (opt_readone) { break; } } if (!found && opt_verbose) { fprintf(stderr, "error: package `%s' not found\n", pkgname); } } return ret; }
/* returns package info as list of strings */ static alpm_list_t *create_verbose_row(pm_target_t *target) { char *str; off_t size = 0; double human_size; const char *label; alpm_list_t *ret = NULL; /* a row consists of the package name, */ if(target->install) { const alpm_db_t *db = alpm_pkg_get_db(target->install); if(db) { pm_asprintf(&str, "%s/%s", alpm_db_get_name(db), alpm_pkg_get_name(target->install)); } else { pm_asprintf(&str, "%s", alpm_pkg_get_name(target->install)); } } else { pm_asprintf(&str, "%s", alpm_pkg_get_name(target->remove)); } ret = alpm_list_add(ret, str); /* old and new versions */ pm_asprintf(&str, "%s", target->remove != NULL ? alpm_pkg_get_version(target->remove) : ""); ret = alpm_list_add(ret, str); pm_asprintf(&str, "%s", target->install != NULL ? alpm_pkg_get_version(target->install) : ""); ret = alpm_list_add(ret, str); /* and size */ size -= target->remove ? alpm_pkg_get_isize(target->remove) : 0; size += target->install ? alpm_pkg_get_isize(target->install) : 0; human_size = humanize_size(size, 'M', 2, &label); pm_asprintf(&str, "%.2f %s", human_size, label); ret = alpm_list_add(ret, str); size = target->install ? alpm_pkg_download_size(target->install) : 0; if(size != 0) { human_size = humanize_size(size, 'M', 2, &label); pm_asprintf(&str, "%.2f %s", human_size, label); } else { str = NULL; } ret = alpm_list_add(ret, str); return ret; }
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 void pk_backend_get_repo_list_thread (PkBackendJob *job, GVariant *params, gpointer data) { PkBackend *backend = pk_backend_job_get_backend (job); PkBackendAlpmPrivate *priv = pk_backend_get_user_data (backend); const alpm_list_t *i; /* emit enabled repos */ for (i = alpm_get_syncdbs (priv->alpm); i != NULL; i = i->next) { alpm_db_t *db = (alpm_db_t *) i->data; const gchar *repo = alpm_db_get_name (db); if (pk_backend_job_is_cancelled (job)) return; pk_backend_repo_info (job, repo, 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 alpm_list_t *search_exact(alpm_list_t *dblist, alpm_list_t *targets) { char *pkgname, *reponame; alpm_list_t *results = NULL; /* resolve each target individually from the repo pool */ for(alpm_list_t *t = targets; t; t = t->next) { alpm_pkg_t *pkg = NULL; alpm_list_t *r; int found = 0; pkgname = reponame = t->data; if(strchr(pkgname, '/')) { strsep(&pkgname, "/"); } else { reponame = NULL; } for(r = dblist; r; r = r->next) { alpm_db_t *repo = r->data; if(reponame && strcmp(reponame, alpm_db_get_name(repo)) != 0) { continue; } pkg = alpm_db_get_pkg(repo, pkgname); if(pkg == NULL) { continue; } found = 1; results = alpm_list_add(results, pkg); if(opt_readone) { break; } } if(!found && opt_verbose) { fprintf(stderr, "error: package `%s' not found\n", pkgname); } } return results; }
alpm_pkg_t *pu_find_pkgspec(alpm_handle_t *handle, const char *pkgspec) { char *c; if(strstr(pkgspec, "://")) { alpm_pkg_t *pkg; alpm_siglevel_t sl = strncmp(pkgspec, "file://", 7) == 0 ? alpm_option_get_local_file_siglevel(handle) : alpm_option_get_remote_file_siglevel(handle); char *path = alpm_fetch_pkgurl(handle, pkgspec); int err = alpm_pkg_load(handle, path ? path : pkgspec, 1, sl, &pkg); free(path); if(!err) { return pkg; } } else if((c = strchr(pkgspec, '/'))) { alpm_db_t *db = NULL; size_t dblen = c - pkgspec; if(dblen == strlen("local") && memcmp(pkgspec, "local", dblen) == 0) { db = alpm_get_localdb(handle); } else { alpm_list_t *i; for(i = alpm_get_syncdbs(handle); i; i = i->next) { const char *dbname = alpm_db_get_name(i->data); if(dblen == strlen(dbname) && strncmp(pkgspec, dbname, dblen) == 0) { db = i->data; break; } } } if(!db) { return NULL; } else { return alpm_db_get_pkg(db, c + 1); } } return NULL; }
static void pk_backend_repo_disable_thread (PkBackendJob *job, GVariant *params, gpointer user_data) { const alpm_list_t *i; const gchar *repo; GError *error = NULL; repo = pk_backend_get_string (self, "repo_id"); for (i = alpm_option_get_syncdbs (); i != NULL; i = i->next) { pmdb_t *db = (pmdb_t *) i->data; const gchar *name = alpm_db_get_name (db); if (g_strcmp0 (repo, name) == 0) { if (alpm_db_unregister (db) < 0) { g_set_error (&error, ALPM_ERROR, pm_errno, "[%s]: %s", repo, alpm_strerrorlast ()); } else { g_hash_table_insert (disabled, g_strdup (repo), GINT_TO_POINTER (1)); } break; } } if (i == NULL) { int code = PM_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_job_finished (self); }
static gboolean pk_backend_get_repo_list_thread (PkBackend *self) { const alpm_list_t *i; GHashTableIter iter; gpointer key, value; g_return_val_if_fail (self != NULL, FALSE); g_return_val_if_fail (alpm != NULL, FALSE); g_return_val_if_fail (disabled != NULL, FALSE); /* emit enabled repos */ for (i = alpm_get_syncdbs (alpm); i != NULL; i = i->next) { alpm_db_t *db = (alpm_db_t *) i->data; const gchar *repo = alpm_db_get_name (db); if (pk_backend_cancelled (self)) { goto out; } else { pk_backend_repo_info (self, repo, TRUE); } } /* emit disabled repos */ g_hash_table_iter_init (&iter, disabled); while (g_hash_table_iter_next (&iter, &key, &value)) { const gchar *repo = (const gchar *) key; if (pk_backend_cancelled (self)) { goto out; } else { pk_backend_repo_info (self, repo, FALSE); } } out: return pk_backend_finish (self, NULL); }
static void pk_backend_get_repo_list_thread (PkBackendJob *job, GVariant *params, gpointer user_data) { const alpm_list_t *i; GHashTableIter iter; gpointer key, value; g_return_val_if_fail (self != NULL, FALSE); g_return_val_if_fail (disabled != NULL, FALSE); /* emit enabled repos */ for (i = alpm_option_get_syncdbs (); i != NULL; i = i->next) { pmdb_t *db = (pmdb_t *) i->data; const gchar *repo = alpm_db_get_name (db); if (pk_backend_cancelled (self)) { goto out; } else { pk_backend_repo_info (self, repo, TRUE); } } /* emit disabled repos */ g_hash_table_iter_init (&iter, disabled); while (g_hash_table_iter_next (&iter, &key, &value)) { const gchar *repo = (const gchar *) key; if (pk_backend_cancelled (self)) { goto out; } else { pk_backend_repo_info (self, repo, FALSE); } } out: pk_backend_finish (self, NULL); }