/** * 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 is_unrequired(alpm_pkg_t *pkg) { alpm_list_t *requiredby = alpm_pkg_compute_requiredby(pkg); if(requiredby == NULL) { return 1; } FREELIST(requiredby); return 0; }
static gboolean pk_backend_required_by_thread (PkBackend *self) { gchar **packages; alpm_list_t *i, *pkgs = NULL; GError *error = NULL; g_return_val_if_fail (self != NULL, FALSE); packages = pk_backend_get_strv (self, "package_ids"); g_return_val_if_fail (packages != NULL, FALSE); /* construct an initial package list */ for (; *packages != NULL; ++packages) { alpm_pkg_t *pkg; if (pk_backend_cancelled (self)) { break; } pkg = pk_backend_find_pkg (self, *packages, &error); if (pkg == NULL) { break; } pkgs = alpm_list_add (pkgs, pkg); } /* package list might be modified along the way but that is ok */ for (i = pkgs; i != NULL; i = i->next) { alpm_list_t *requiredby; if (pk_backend_cancelled (self) || error != NULL) { break; } requiredby = alpm_pkg_compute_requiredby (i->data); for (; requiredby != NULL; requiredby = requiredby->next) { if (pk_backend_cancelled (self) || error != NULL) { break; } pkgs = pk_backend_find_requirer (self, pkgs, requiredby->data, &error); } FREELIST (requiredby); } alpm_list_free (pkgs); return pk_backend_finish (self, error); }
static PyObject* pyalpm_pkg_compute_requiredby(PyObject *rawself, PyObject *args) { AlpmPackage *self = (AlpmPackage*)rawself; PyObject *pyresult; CHECK_IF_INITIALIZED(); { alpm_list_t *result = alpm_pkg_compute_requiredby(self->c_data); pyresult = alpmlist_to_pylist(result, pyobject_from_string); FREELIST(result); } return pyresult; }
static int print_pkg(alpm_pkg_t *pkg, const char *format) { const char *f, *end; char fmt[64], buf[64]; int len, out = 0; end = format + strlen(format); for (f = format; f < end; f++) { len = 0; if (*f == '%') { len = strspn(f + 1 + len, printf_flags); len += strspn(f + 1 + len, digits); snprintf(fmt, len + 3, "%ss", f); fmt[len + 1] = 's'; f += len + 1; switch (*f) { /* simple attributes */ case 'f': /* filename */ out += printf(fmt, alpm_pkg_get_filename(pkg)); break; case 'n': /* package name */ out += printf(fmt, alpm_pkg_get_name(pkg)); break; case 'v': /* version */ out += printf(fmt, alpm_pkg_get_version(pkg)); break; case 'd': /* description */ out += printf(fmt, alpm_pkg_get_desc(pkg)); break; case 'u': /* project url */ out += printf(fmt, alpm_pkg_get_url(pkg)); break; case 'p': /* packager name */ out += printf(fmt, alpm_pkg_get_packager(pkg)); break; case 's': /* md5sum */ out += printf(fmt, alpm_pkg_get_md5sum(pkg)); break; case 'a': /* architecutre */ out += printf(fmt, alpm_pkg_get_arch(pkg)); break; case 'i': /* has install scriptlet? */ out += printf(fmt, alpm_pkg_has_scriptlet(pkg) ? "yes" : "no"); break; case 'r': /* repo */ out += printf(fmt, alpm_db_get_name(alpm_pkg_get_db(pkg))); break; case 'w': /* install reason */ out += printf(fmt, alpm_pkg_get_reason(pkg) ? "dependency" : "explicit"); break; case '!': /* result number */ snprintf(buf, sizeof(buf), "%d", opt_pkgcounter++); out += printf(fmt, buf); break; case 'g': /* base64 gpg sig */ out += printf(fmt, alpm_pkg_get_base64_sig(pkg)); break; case 'h': /* sha256sum */ out += printf(fmt, alpm_pkg_get_sha256sum(pkg)); break; /* times */ case 'b': /* build date */ out += print_time(alpm_pkg_get_builddate(pkg)); break; case 'l': /* install date */ out += print_time(alpm_pkg_get_installdate(pkg)); break; /* sizes */ case 'k': /* download size */ out += printf(fmt, size_to_string(alpm_pkg_get_size(pkg))); break; case 'm': /* install size */ out += printf(fmt, size_to_string(alpm_pkg_get_isize(pkg))); break; /* lists */ case 'F': /* files */ out += print_filelist(alpm_pkg_get_files(pkg)); break; case 'N': /* requiredby */ out += print_list(alpm_pkg_compute_requiredby(pkg), NULL); break; case 'L': /* licenses */ out += print_list(alpm_pkg_get_licenses(pkg), NULL); break; case 'G': /* groups */ out += print_list(alpm_pkg_get_groups(pkg), NULL); break; case 'E': /* depends (shortdeps) */ out += print_list(alpm_pkg_get_depends(pkg), (extractfn)alpm_dep_get_name); break; case 'D': /* depends */ out += print_list(alpm_pkg_get_depends(pkg), (extractfn)alpm_dep_compute_string); break; case 'O': /* optdepends */ out += print_list(alpm_pkg_get_optdepends(pkg), (extractfn)format_optdep); break; case 'o': /* optdepends (shortdeps) */ out += print_list(alpm_pkg_get_optdepends(pkg), (extractfn)alpm_dep_get_name); break; case 'C': /* conflicts */ out += print_list(alpm_pkg_get_conflicts(pkg), (extractfn)alpm_dep_get_name); break; case 'S': /* provides (shortdeps) */ out += print_list(alpm_pkg_get_provides(pkg), (extractfn)alpm_dep_get_name); break; case 'P': /* provides */ out += print_list(alpm_pkg_get_provides(pkg), (extractfn)alpm_dep_compute_string); break; case 'R': /* replaces */ out += print_list(alpm_pkg_get_replaces(pkg), (extractfn)alpm_dep_get_name); break; case 'B': /* backup */ out += print_list(alpm_pkg_get_backup(pkg), alpm_backup_get_name); break; case 'V': /* package validation */ out += print_allocated_list(get_validation_method(pkg), NULL); break; case 'M': /* modified */ out += print_allocated_list(get_modified_files(pkg), NULL); break; case '%': fputc('%', stdout); out++; break; default: fputc('?', stdout); out++; break; } } else if (*f == '\\') { char esc[3] = { f[0], f[1], '\0' }; out += print_escaped(esc); ++f; } else { fputc(*f, stdout); out++; } } /* only print a delimeter if any package data was outputted */ if (out > 0) { print_escaped(opt_delim); } return !out; }
void pacman_pkgdump(pmpkg_t *pkg, enum pkgfrom_t from) { static const char *datefmt = "%a %d %b %Y %I:%M:%S %p %Z"; alpm_list_t *i, *results = NULL; pmdb_t *db; pmdepend_t *dep; pmpkgreason_t reason; int has_script; time_t inst_time; struct tm tm_st; char installdate[60]; char builddate[60]; db = alpm_pkg_get_db(pkg); if (!db) { return; } memset(&tm_st, 0, sizeof(struct tm)); inst_time = alpm_pkg_get_builddate(pkg); localtime_r(&inst_time, &tm_st); strftime(builddate, 60, datefmt, &tm_st); /* Local pkg specific */ if (from == PKG_FROM_LOCAL) { has_script = alpm_pkg_has_scriptlet(pkg); reason = alpm_pkg_get_reason(pkg); memset(&tm_st, 0, sizeof(struct tm)); inst_time = alpm_pkg_get_installdate(pkg); localtime_r(&inst_time, &tm_st); strftime(installdate, 60, datefmt, &tm_st); } if (from == PKG_FROM_SYNC) { printf("%s%s ", color.bold, REPO); const char *repo = alpm_db_get_name(db); if (!strcmp(repo, "core")) { printf("%s", color.bred); } else if (!strcmp(repo, "extra")) { printf("%s", color.bgreen); } else { printf("%s", color.bmag); } printf("%s%s\n", repo, color.nocolor); } printf("%s%s%s %s%s%s\n", color.bold, NAME, color.nocolor, color.bold, alpm_pkg_get_name(pkg), color.nocolor); printf("%s%s %s%s%s\n", color.bold, VERSION, color.bgreen, alpm_pkg_get_version(pkg), color.nocolor); printf("%s%s %s%s%s\n", color.bold, URL, color.bcyan, alpm_pkg_get_url(pkg), color.nocolor); print_list_prefix(alpm_pkg_get_licenses(pkg), LICENSES); print_list_prefix(alpm_pkg_get_groups(pkg), GROUPS); print_list_prefix(alpm_pkg_get_provides(pkg), PROVIDES); print_list_deps(alpm_pkg_get_depends(pkg), DEPS); print_list_break(alpm_pkg_get_optdepends(pkg), OPTDEPS); if (from == PKG_FROM_LOCAL) { results = alpm_pkg_compute_requiredby(pkg); print_list_prefix(results, REQBY); } print_list_prefix(alpm_pkg_get_conflicts(pkg), CONFLICTS); print_list_prefix(alpm_pkg_get_replaces(pkg), REPLACES); if (from == PKG_FROM_SYNC) { humanize_size(alpm_pkg_get_size(pkg), DLSZ); } humanize_size(alpm_pkg_get_isize(pkg), INSTSZ); printf("%s%s%s %s\n", color.bold, PKGER, color.nocolor, alpm_pkg_get_packager(pkg)); printf("%s%s%s %s\n", color.bold, ARCH, color.nocolor, alpm_pkg_get_arch(pkg)); printf("%s%s%s %s\n", color.bold, BDATE, color.nocolor, builddate); if (from == PKG_FROM_LOCAL) { printf("%s%s%s %s\n", color.bold, IDATE, color.nocolor, installdate); printf("%s%s%s ", color.bold, REASON, color.nocolor); switch (reason) { case PM_PKG_REASON_EXPLICIT: printf("Explicitly installed"); break; case PM_PKG_REASON_DEPEND: printf("Installed as a dependency for another package"); break; default: printf("Unknown"); break; } printf("\n"); printf("%s%s%s %s\n", color.bold, SCRIPT, color.nocolor, has_script ? "Yes" : "No"); } if (from == PKG_FROM_SYNC) { printf("%s%s%s %s\n", color.bold, MD5SUM, color.nocolor, alpm_pkg_get_md5sum(pkg)); } printf("%s%s%s %s\n", color.bold, DESC, color.nocolor, alpm_pkg_get_desc(pkg)); FREELIST(results); }
/** * Display the details of a package. * Extra information entails 'required by' info for sync packages and backup * files info for local packages. * @param pkg package to display information for * @param from the type of package we are dealing with * @param extra should we show extra information */ void dump_pkg_full(alpm_pkg_t *pkg, int extra) { unsigned short cols; time_t bdate, idate; alpm_pkgfrom_t from; double size; char bdatestr[50] = "", idatestr[50] = ""; const char *label, *reason; alpm_list_t *validation = NULL, *requiredby = NULL, *optionalfor = NULL; from = alpm_pkg_get_origin(pkg); /* set variables here, do all output below */ bdate = (time_t)alpm_pkg_get_builddate(pkg); if(bdate) { strftime(bdatestr, 50, "%c", localtime(&bdate)); } idate = (time_t)alpm_pkg_get_installdate(pkg); if(idate) { strftime(idatestr, 50, "%c", localtime(&idate)); } switch(alpm_pkg_get_reason(pkg)) { case ALPM_PKG_REASON_EXPLICIT: reason = _("Explicitly installed"); break; case ALPM_PKG_REASON_DEPEND: reason = _("Installed as a dependency for another package"); break; default: reason = _("Unknown"); break; } alpm_pkgvalidation_t v = alpm_pkg_get_validation(pkg); if(v) { if(v & ALPM_PKG_VALIDATION_NONE) { validation = alpm_list_add(validation, _("None")); } else { if(v & ALPM_PKG_VALIDATION_MD5SUM) { validation = alpm_list_add(validation, _("MD5 Sum")); } if(v & ALPM_PKG_VALIDATION_SHA256SUM) { validation = alpm_list_add(validation, _("SHA256 Sum")); } if(v & ALPM_PKG_VALIDATION_SIGNATURE) { validation = alpm_list_add(validation, _("Signature")); } } } else { validation = alpm_list_add(validation, _("Unknown")); } if(extra || from == ALPM_PKG_FROM_LOCALDB) { /* compute this here so we don't get a pause in the middle of output */ requiredby = alpm_pkg_compute_requiredby(pkg); optionalfor = alpm_pkg_compute_optionalfor(pkg); } cols = getcols(fileno(stdout)); /* actual output */ if(from == ALPM_PKG_FROM_SYNCDB) { string_display(_("Repository :"), alpm_db_get_name(alpm_pkg_get_db(pkg)), cols); } string_display(_("Name :"), alpm_pkg_get_name(pkg), cols); string_display(_("Version :"), alpm_pkg_get_version(pkg), cols); string_display(_("Description :"), alpm_pkg_get_desc(pkg), cols); string_display(_("Architecture :"), alpm_pkg_get_arch(pkg), cols); string_display(_("URL :"), alpm_pkg_get_url(pkg), cols); list_display(_("Licenses :"), alpm_pkg_get_licenses(pkg), cols); list_display(_("Groups :"), alpm_pkg_get_groups(pkg), cols); deplist_display(_("Provides :"), alpm_pkg_get_provides(pkg), cols); deplist_display(_("Depends On :"), alpm_pkg_get_depends(pkg), cols); optdeplist_display(pkg, cols); if(extra || from == ALPM_PKG_FROM_LOCALDB) { list_display(_("Required By :"), requiredby, cols); list_display(_("Optional For :"), optionalfor, cols); } deplist_display(_("Conflicts With :"), alpm_pkg_get_conflicts(pkg), cols); deplist_display(_("Replaces :"), alpm_pkg_get_replaces(pkg), cols); size = humanize_size(alpm_pkg_get_size(pkg), '\0', 2, &label); if(from == ALPM_PKG_FROM_SYNCDB) { printf("%s%s%s %6.2f %s\n", config->colstr.title, _("Download Size :"), config->colstr.nocolor, size, label); } else if(from == ALPM_PKG_FROM_FILE) { printf("%s%s%s %6.2f %s\n", config->colstr.title, _("Compressed Size:"), config->colstr.nocolor, size, label); } else { // autodetect size for "Installed Size" label = "\0"; } size = humanize_size(alpm_pkg_get_isize(pkg), label[0], 2, &label); printf("%s%s%s %6.2f %s\n", config->colstr.title, _("Installed Size :"), config->colstr.nocolor, size, label); string_display(_("Packager :"), alpm_pkg_get_packager(pkg), cols); string_display(_("Build Date :"), bdatestr, cols); if(from == ALPM_PKG_FROM_LOCALDB) { string_display(_("Install Date :"), idatestr, cols); string_display(_("Install Reason :"), reason, cols); } if(from == ALPM_PKG_FROM_FILE || from == ALPM_PKG_FROM_LOCALDB) { string_display(_("Install Script :"), alpm_pkg_has_scriptlet(pkg) ? _("Yes") : _("No"), cols); } if(from == ALPM_PKG_FROM_SYNCDB && extra) { const char *base64_sig = alpm_pkg_get_base64_sig(pkg); alpm_list_t *keys = NULL; if(base64_sig) { unsigned char *decoded_sigdata = NULL; size_t data_len; alpm_decode_signature(base64_sig, &decoded_sigdata, &data_len); alpm_extract_keyid(config->handle, alpm_pkg_get_name(pkg), decoded_sigdata, data_len, &keys); } else { keys = alpm_list_add(keys, _("None")); } string_display(_("MD5 Sum :"), alpm_pkg_get_md5sum(pkg), cols); string_display(_("SHA256 Sum :"), alpm_pkg_get_sha256sum(pkg), cols); list_display(_("Signatures :"), keys, cols); } else { list_display(_("Validated By :"), validation, cols); } if(from == ALPM_PKG_FROM_FILE) { alpm_siglist_t siglist; int err = alpm_pkg_check_pgp_signature(pkg, &siglist); if(err && alpm_errno(config->handle) == ALPM_ERR_SIG_MISSING) { string_display(_("Signatures :"), _("None"), cols); } else if(err) { string_display(_("Signatures :"), alpm_strerror(alpm_errno(config->handle)), cols); } else { signature_display(_("Signatures :"), &siglist, cols); } alpm_siglist_cleanup(&siglist); } /* Print additional package info if info flag passed more than once */ if(from == ALPM_PKG_FROM_LOCALDB && extra) { dump_pkg_backups(pkg); } /* final newline to separate packages */ printf("\n"); FREELIST(requiredby); alpm_list_free(validation); }