char *concat_str_list (alpm_list_t *l) { char *ret; int len=0, j=0; alpm_list_t *i; if (!l) { return NULL; } else { for(i = l; i; i = alpm_list_next(i)) { /* data's len + space for separator */ len += strlen (i->data) + strlen (config.delimiter); } if (len) { len++; /* '\0' at the end */ CALLOC (ret, len, sizeof (char)); strcpy (ret, ""); for(i = l; i; i = alpm_list_next(i)) { if (j++>0) strcat (ret, config.delimiter); strcat (ret, i->data); } } else { return NULL; } } return ret; }
void display_targets(void) { alpm_list_t *i, *targets = NULL; alpm_db_t *db_local = alpm_get_localdb(config->handle); for(i = alpm_trans_get_add(config->handle); i; i = alpm_list_next(i)) { alpm_pkg_t *pkg = i->data; pm_target_t *targ = calloc(1, sizeof(pm_target_t)); if(!targ) return; targ->install = pkg; targ->remove = alpm_db_get_pkg(db_local, alpm_pkg_get_name(pkg)); if(alpm_list_find(config->explicit_adds, pkg, pkg_cmp)) { targ->is_explicit = 1; } targets = alpm_list_add(targets, targ); } for(i = alpm_trans_get_remove(config->handle); i; i = alpm_list_next(i)) { alpm_pkg_t *pkg = i->data; pm_target_t *targ = calloc(1, sizeof(pm_target_t)); if(!targ) return; targ->remove = pkg; if(alpm_list_find(config->explicit_removes, pkg, pkg_cmp)) { targ->is_explicit = 1; } targets = alpm_list_add(targets, targ); } targets = alpm_list_msort(targets, alpm_list_count(targets), target_cmp); _display_targets(targets, config->verbosepkglists); FREELIST(targets); }
char *concat_str_list (const alpm_list_t *l) { char *ret = NULL; size_t len = 0; const size_t sep_len = strlen (config.delimiter); int j = 0; if (!l) { return NULL; } for (const alpm_list_t *i = l; i; i = alpm_list_next(i)) { if (i->data) { /* data's len + space for separator */ len += strlen (i->data) + sep_len; } } if (!len) { return NULL; } len++; /* '\0' at the end */ CALLOC (ret, len, sizeof (char)); for (const alpm_list_t *i = l; i; i = alpm_list_next (i)) { if (i->data) { if (j++ > 0) strcat (ret, config.delimiter); strcat (ret, i->data); } } return ret; }
int pacman_deptest(alpm_list_t *targets) { alpm_list_t *i; alpm_list_t *deps = NULL; alpm_db_t *localdb = alpm_get_localdb(config->handle); for(i = targets; i; i = alpm_list_next(i)) { char *target = i->data; if(!alpm_find_satisfier(alpm_db_get_pkgcache(localdb), target)) { deps = alpm_list_add(deps, target); } } if(deps == NULL) { return 0; } for(i = deps; i; i = alpm_list_next(i)) { const char *dep = i->data; printf("%s\n", dep); } alpm_list_free(deps); return 127; }
void list_display_linebreak(const char *title, const alpm_list_t *list, unsigned short maxcols) { unsigned short len = 0; if(title) { len = (unsigned short)string_length(title) + 1; printf("%s ", title); } if(!list) { printf("%s\n", _("None")); } else { const alpm_list_t *i; /* Print the first element */ indentprint((const char *)list->data, len, maxcols); printf("\n"); /* Print the rest */ for(i = alpm_list_next(list); i; i = alpm_list_next(i)) { size_t j; for(j = 1; j <= len; j++) { printf(" "); } indentprint((const char *)i->data, len, maxcols); printf("\n"); } } }
/** * walk dependencies, showing dependencies of the target */ static void walk_deps(alpm_list_t *dblist, alpm_pkg_t *pkg, tdepth *depth, int rev) { alpm_list_t *deps, *i; if(!pkg || ((max_depth >= 0) && (depth->level > max_depth))) { return; } walked = alpm_list_add(walked, (void *)alpm_pkg_get_name(pkg)); if(rev) { deps = alpm_pkg_compute_requiredby(pkg); } else { deps = get_pkg_dep_names(pkg); } for(i = deps; i; i = alpm_list_next(i)) { const char *pkgname = i->data; int last = alpm_list_next(i) ? 0 : 1; alpm_pkg_t *dep_pkg = alpm_find_dbs_satisfier(handle, dblist, pkgname); if(alpm_list_find_str(walked, dep_pkg ? alpm_pkg_get_name(dep_pkg) : pkgname)) { /* if we've already seen this package, don't print in "unique" output * and don't recurse */ if(!unique) { print(alpm_pkg_get_name(pkg), alpm_pkg_get_name(dep_pkg), pkgname, depth, last); } } else { print(alpm_pkg_get_name(pkg), alpm_pkg_get_name(dep_pkg), pkgname, depth, last); if(dep_pkg) { tdepth d = { depth, NULL, depth->level + 1 }; depth->next = &d; /* last dep, cut off the limb here */ if(last) { if(depth->prev) { depth->prev->next = &d; d.prev = depth->prev; depth = &d; } else { d.prev = NULL; } } walk_deps(dblist, dep_pkg, &d, rev); depth->next = NULL; } } } if(rev) { FREELIST(deps); } else { alpm_list_free(deps); } }
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; }
/** * Find the max string width of each column. Also determines whether values * exist in the column and sets the value in has_data accordingly. * @param header a list of header strings * @param rows a list of lists of rows as strings * @param padding the amount of padding between columns * @param totalcols the total number of columns in the header and each row * @param widths a pointer to store width data * @param has_data a pointer to store whether column has data * * @return the total width of the table; 0 on failure */ static size_t table_calc_widths(const alpm_list_t *header, const alpm_list_t *rows, short padding, size_t totalcols, size_t **widths, int **has_data) { const alpm_list_t *i; size_t curcol, totalwidth = 0, usefulcols = 0; size_t *colwidths; int *coldata; if(totalcols <= 0) { return 0; } colwidths = malloc(totalcols * sizeof(size_t)); coldata = calloc(totalcols, sizeof(int)); if(!colwidths || !coldata) { return 0; } /* header determines column count and initial values of longest_strs */ for(i = header, curcol = 0; i; i = alpm_list_next(i), curcol++) { colwidths[curcol] = string_length(i->data); /* note: header does not determine whether column has data */ } /* now find the longest string in each column */ for(i = rows; i; i = alpm_list_next(i)) { /* grab first column of each row and iterate through columns */ const alpm_list_t *j = i->data; for(curcol = 0; j; j = alpm_list_next(j), curcol++) { const char *str = j->data; size_t str_len = string_length(str); if(str_len > colwidths[curcol]) { colwidths[curcol] = str_len; } if(str_len > 0) { coldata[curcol] = 1; } } } for(i = header, curcol = 0; i; i = alpm_list_next(i), curcol++) { /* only include columns that have data */ if(coldata[curcol]) { usefulcols++; totalwidth += colwidths[curcol]; } } /* add padding between columns */ if(usefulcols > 0) { totalwidth += padding * (usefulcols - 1); } *widths = colwidths; *has_data = coldata; return totalwidth; }
/* search the local database for a matching package */ static int query_search(alpm_list_t *targets) { alpm_list_t *i, *searchlist; int freelist; alpm_db_t *db_local = alpm_option_get_localdb(config->handle); /* if we have a targets list, search for packages matching it */ if(targets) { searchlist = alpm_db_search(db_local, targets); freelist = 1; } else { searchlist = alpm_db_get_pkgcache(db_local); freelist = 0; } if(searchlist == NULL) { return 1; } for(i = searchlist; i; i = alpm_list_next(i)) { alpm_list_t *grp; alpm_pkg_t *pkg = alpm_list_getdata(i); if(!config->quiet) { printf("local/%s %s", alpm_pkg_get_name(pkg), alpm_pkg_get_version(pkg)); } else { printf("%s", alpm_pkg_get_name(pkg)); } if(!config->quiet) { if((grp = alpm_pkg_get_groups(pkg)) != NULL) { alpm_list_t *k; printf(" ("); for(k = grp; k; k = alpm_list_next(k)) { const char *group = alpm_list_getdata(k); printf("%s", group); if(alpm_list_next(k)) { /* only print a spacer if there are more groups */ printf(" "); } } printf(")"); } /* we need a newline and initial indent first */ printf("\n "); indentprint(alpm_pkg_get_desc(pkg), 4); } printf("\n"); } /* we only want to free if the list was a search list */ if(freelist) { alpm_list_free(searchlist); } 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; 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 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; }
void calculate_results_relevance (alpm_list_t *targets) { for (const alpm_list_t *t = targets; t; t = alpm_list_next (t)) { const char *target = t->data; for (const alpm_list_t *r = results; r; r = alpm_list_next(r)) { const char *result = results_name (r->data); const size_t lev_dst = levenshtein_distance (target, result); if (lev_dst < ((results_t *) r->data)->rel) { ((results_t *) r->data)->rel = lev_dst; } } } }
static void checkpkgs(alpm_list_t *pkglist) { alpm_list_t *i, *j; for(i = pkglist; i; i = alpm_list_next(i)) { alpm_pkg_t *pkg = i->data; alpm_list_t *unused = alpm_pkg_unused_deltas(pkg); for(j = unused; j; j = alpm_list_next(j)) { const char *delta = j->data; printf("%s\n", delta); } alpm_list_free(unused); } }
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; }
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; }
int ab_print_contact_records(void) { ft_table_t *table; alpm_list_t *i; ft_set_default_border_style(FT_BASIC2_STYLE); table = ft_create_table(); ft_set_cell_prop(table, FT_ANY_ROW, 0, FT_CPROP_TEXT_ALIGN, FT_ALIGNED_CENTER); ft_set_cell_prop(table, FT_ANY_ROW, 1, FT_CPROP_TEXT_ALIGN, FT_ALIGNED_LEFT); ft_set_cell_prop(table, 0, FT_ANY_COLUMN, FT_CPROP_ROW_TYPE, FT_ROW_HEADER); ft_write_ln(table, "ID", "First Name", "Last Name", "Email"); for (i = contact_list; i; i = alpm_list_next(i)) { ab_contact_t *contact = (ab_contact_t *)i->data; int length = snprintf(NULL, 0, "%d", contact->id); char* idstr = malloc(length + 1); snprintf(idstr, length + 1, "%d", contact->id); ft_write_ln(table, idstr, contact->fname, contact->lname, contact->email); free(idstr); } printf("%s\n", ft_to_string(table)); ft_destroy_table(table); return 0; }
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 void table_print_line(const alpm_list_t *line, short col_padding, size_t colcount, size_t *widths, int *has_data) { size_t i; int need_padding = 0; const alpm_list_t *curcell; for(i = 0, curcell = line; curcell && i < colcount; i++, curcell = alpm_list_next(curcell)) { const struct table_cell_t *cell = curcell->data; const char *str = (cell->label ? cell->label : ""); int cell_width; if(!has_data[i]) { continue; } cell_width = (cell->mode & CELL_RIGHT_ALIGN ? (int)widths[i] : -(int)widths[i]); if(need_padding) { printf("%*s", col_padding, ""); } if(cell->mode & CELL_TITLE) { printf("%s%*s%s", config->colstr.title, cell_width, str, config->colstr.nocolor); } else { printf("%*s", cell_width, str); } need_padding = 1; } printf("\n"); }
static int print_list(alpm_list_t *list, extractfn fn) { alpm_list_t *i; int out = 0; if (!list) { if (opt_verbose) { out += printf("None"); } return out; } i = list; while (1) { char *item = (char*)(fn ? fn(i->data) : i->data); if (item == NULL) { continue; } out += printf("%s", item); if ((i = alpm_list_next(i))) { out += print_escaped(opt_listdelim); } else { break; } } return out; }
static int process_group(alpm_list_t *dbs, const char *group, int error) { int ret = 0; alpm_list_t *i; alpm_list_t *pkgs = alpm_find_group_pkgs(dbs, group); int count = alpm_list_count(pkgs); if(!count) { printf("target not found: %s\n", group); return 1; } if(error) { /* we already know another target errored. there is no reason to prompt the * user here; we already validated the group name so just move on since we * won't actually be installing anything anyway. */ goto cleanup; } for(i = pkgs; i; i = alpm_list_next(i)) { alpm_pkg_t *pkg = i->data; if(process_pkg(pkg) == 1) { ret = 1; goto cleanup; } } cleanup: alpm_list_free(pkgs); return ret; }
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; }
bool does_name_contain_targets (const alpm_list_t *targets, const char *name, bool use_regex) { if (!targets || !name) { return false; } for (const alpm_list_t *t = targets; t; t = alpm_list_next (t)) { const char *target = (const char *)(t->data); if (!target) { continue; } if (use_regex) { regex_t reg; if (regcomp (®, target, REG_EXTENDED | REG_NOSUB | REG_ICASE | REG_NEWLINE) != 0) { return false; } if (regexec (®, name, 0, 0, 0) != 0 && strstr (name, target) == NULL) { regfree (®); return false; } regfree (®); } else if (strcasestr (name, target) == NULL) { return false; } } return true; }
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; }
/** * call-seq: * search(*queries, ...) → an_array * * Search the database with POSIX regular expressions for packages. * === Parameters * [*queries (splat)] * A list of strings interpreted as POSIX regular expressions. * For a package to be found, it must match _all_ queries terms, * not just a single one. Each query is matched against both * the package name and the package description, where only * one needs to match for the package to be considered. * * Note that the match is not performed by Ruby or even Oniguruma/Onigmo, * but directly in libalpm via the +regexp+ library in C. * * === Return value * An array of Package instances whose names matched _all_ regular expressions. */ static VALUE search(int argc, VALUE argv[], VALUE self) { alpm_db_t* p_db = NULL; alpm_list_t* targets = NULL; alpm_list_t* packages = NULL; alpm_list_t* item = NULL; VALUE result = rb_ary_new(); int i; Data_Get_Struct(self, alpm_db_t, p_db); /* Convert our Ruby array to an alpm_list with C strings */ for(i=0; i < argc; i++) { VALUE term = rb_check_string_type(argv[i]); if (!RTEST(term)) { rb_raise(rb_eTypeError, "Argument is not a string (#to_str)"); return Qnil; } targets = alpm_list_add(targets, StringValuePtr(term)); } /* Perform the query */ packages = alpm_db_search(p_db, targets); if (!packages) return result; for(item=packages; item; item = alpm_list_next(item)) rb_ary_push(result, Data_Wrap_Struct(rb_cAlpm_Package, NULL, NULL, item->data)); alpm_list_free(targets); return result; }
/* * 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(); }
void* alpm_list_iterator_next_value (alpm_list_iterator_t *iter) { if (iter->pos) { void* result = alpm_list_get_data (iter->pos); iter->pos = alpm_list_next (iter->pos); return result; } else return NULL; }
static alpm_list_t *get_pkg_dep_names(alpm_pkg_t *pkg) { alpm_list_t *i, *names = NULL; for(i = alpm_pkg_get_depends(pkg); i; i = alpm_list_next(i)) { alpm_depend_t *d = i->data; names = alpm_list_add(names, d->name); } return names; }
alpm_list_t *find_str(alpm_list_t *haystack, const char *needle) { for(; haystack; haystack = alpm_list_next(haystack)) { if(strcasecmp(haystack->data, needle) == 0) { return haystack; } } return NULL; }
/** * @brief Send a callback for any optdepend being removed. * * @param handle the context handle * @param lp list of packages to be removed */ static void remove_notify_needed_optdepends(alpm_handle_t *handle, alpm_list_t *lp) { alpm_list_t *i; for(i = _alpm_db_get_pkgcache(handle->db_local); i; i = alpm_list_next(i)) { alpm_pkg_t *pkg = i->data; alpm_list_t *optdeps = alpm_pkg_get_optdepends(pkg); if(optdeps && !alpm_pkg_find(lp, pkg->name)) { alpm_list_t *j; for(j = optdeps; j; j = alpm_list_next(j)) { alpm_depend_t *optdep = j->data; if(alpm_pkg_find(lp, optdep->name)) { EVENT(handle, ALPM_EVENT_OPTDEP_REQUIRED, pkg, optdep); } } } } }
char *concat_dep_list (alpm_list_t *deps) { alpm_list_t *i, *deps_str = NULL; char *ret; for (i=deps; i; i = alpm_list_next (i)) deps_str = alpm_list_add (deps_str, alpm_dep_compute_string (i->data)); ret = concat_str_list (deps_str); FREELIST (deps_str); return ret; }