/* 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 off_t results_isize (const results_t *r)
{
if (!r || r->type == R_AUR_PKG) {
return 0;
}
return alpm_pkg_get_isize (r->ele);
}
static off_t pkg_get_size(alpm_pkg_t *pkg)
{
switch(config->op) {
case PM_OP_SYNC:
return alpm_pkg_download_size(pkg);
case PM_OP_UPGRADE:
return alpm_pkg_get_size(pkg);
default:
return alpm_pkg_get_isize(pkg);
}
}
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;
}
/* prepare a list of pkgs to display */
static void _display_targets(alpm_list_t *targets, int verbose)
{
char *str;
const char *label;
double size;
off_t isize = 0, rsize = 0, dlsize = 0;
unsigned short cols;
alpm_list_t *i, *rows = NULL, *names = NULL;
if(!targets) {
return;
}
/* gather package info */
for(i = targets; i; i = alpm_list_next(i)) {
pm_target_t *target = i->data;
if(target->install) {
dlsize += alpm_pkg_download_size(target->install);
isize += alpm_pkg_get_isize(target->install);
}
if(target->remove) {
/* add up size of all removed packages */
rsize += alpm_pkg_get_isize(target->remove);
}
}
/* form data for both verbose and non-verbose display */
for(i = targets; i; i = alpm_list_next(i)) {
pm_target_t *target = i->data;
rows = alpm_list_add(rows, create_verbose_row(target));
if(target->install) {
pm_asprintf(&str, "%s-%s", alpm_pkg_get_name(target->install),
alpm_pkg_get_version(target->install));
} else if(isize == 0) {
pm_asprintf(&str, "%s-%s", alpm_pkg_get_name(target->remove),
alpm_pkg_get_version(target->remove));
} else {
pm_asprintf(&str, "%s-%s [removal]", alpm_pkg_get_name(target->remove),
alpm_pkg_get_version(target->remove));
}
names = alpm_list_add(names, str);
}
/* print to screen */
pm_asprintf(&str, _("Packages (%d):"), alpm_list_count(targets));
printf("\n");
cols = getcols(fileno(stdout));
if(verbose) {
alpm_list_t *header = create_verbose_header();
if(table_display(str, header, rows, cols) != 0) {
/* fallback to list display if table wouldn't fit */
list_display(str, names, cols);
}
alpm_list_free(header);
} else {
list_display(str, names, cols);
}
printf("\n");
/* rows is a list of lists of strings, free inner lists here */
for(i = rows; i; i = alpm_list_next(i)) {
alpm_list_t *lp = i->data;
FREELIST(lp);
}
alpm_list_free(rows);
FREELIST(names);
free(str);
if(dlsize > 0 || config->op_s_downloadonly) {
size = humanize_size(dlsize, 'M', 2, &label);
printf(_("Total Download Size: %.2f %s\n"), size, label);
}
if(!config->op_s_downloadonly) {
if(isize > 0) {
size = humanize_size(isize, 'M', 2, &label);
printf(_("Total Installed Size: %.2f %s\n"), size, label);
}
if(rsize > 0 && isize == 0) {
size = humanize_size(rsize, 'M', 2, &label);
printf(_("Total Removed Size: %.2f %s\n"), size, label);
}
/* only show this net value if different from raw installed size */
if(isize > 0 && rsize > 0) {
size = humanize_size(isize - rsize, 'M', 2, &label);
printf(_("Net Upgrade Size: %.2f %s\n"), size, label);
}
}
}
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);
}
static gboolean
pk_backend_get_details_thread (PkBackend *self)
{
gchar **packages;
GError *error = NULL;
g_return_val_if_fail (self != NULL, FALSE);
g_return_val_if_fail (localdb != NULL, FALSE);
packages = pk_backend_get_strv (self, "package_ids");
g_return_val_if_fail (packages != NULL, FALSE);
for (; *packages != NULL; ++packages) {
alpm_pkg_t *pkg;
const alpm_list_t *i;
GString *licenses;
PkGroupEnum group;
const gchar *desc, *url;
gulong size;
if (pk_backend_cancelled (self)) {
break;
}
pkg = pk_backend_find_pkg (self, *packages, &error);
if (pkg == NULL) {
break;
}
i = alpm_pkg_get_licenses (pkg);
if (i == NULL) {
licenses = g_string_new ("Unknown");
} else {
licenses = g_string_new ((const gchar *) i->data);
while ((i = i->next) != NULL) {
const gchar *license = (const gchar *) i->data;
/* assume OR although it may not be correct */
g_string_append_printf (licenses, " or %s",
license);
}
}
group = pk_group_enum_from_string (alpm_pkg_get_group (pkg));
desc = alpm_pkg_get_desc (pkg);
url = alpm_pkg_get_url (pkg);
if (alpm_pkg_get_origin (pkg) == ALPM_PKG_FROM_LOCALDB) {
size = alpm_pkg_get_isize (pkg);
} else {
size = alpm_pkg_download_size (pkg);
}
pk_backend_job_details (self, *packages, licenses->str, group,
desc, url, size);
g_string_free (licenses, TRUE);
}
return pk_backend_finish (self, error);
}
static PyObject* pyalpm_package_get_isize(AlpmPackage *self, void *closure) {
CHECK_IF_INITIALIZED();
return PyLong_FromLongLong(alpm_pkg_get_isize(self->c_data));
}
/* prepare a list of pkgs to display */
static void _display_targets(alpm_list_t *targets, int verbose)
{
char *str;
off_t isize = 0, rsize = 0, dlsize = 0;
unsigned short cols;
alpm_list_t *i, *names = NULL, *header = NULL, *rows = NULL;
if(!targets) {
return;
}
/* gather package info */
for(i = targets; i; i = alpm_list_next(i)) {
pm_target_t *target = i->data;
if(target->install) {
dlsize += alpm_pkg_download_size(target->install);
isize += alpm_pkg_get_isize(target->install);
}
if(target->remove) {
/* add up size of all removed packages */
rsize += alpm_pkg_get_isize(target->remove);
}
}
/* form data for both verbose and non-verbose display */
for(i = targets; i; i = alpm_list_next(i)) {
pm_target_t *target = i->data;
if(verbose) {
rows = alpm_list_add(rows, create_verbose_row(target));
}
if(target->install) {
pm_asprintf(&str, "%s-%s", alpm_pkg_get_name(target->install),
alpm_pkg_get_version(target->install));
} else if(isize == 0) {
pm_asprintf(&str, "%s-%s", alpm_pkg_get_name(target->remove),
alpm_pkg_get_version(target->remove));
} else {
pm_asprintf(&str, "%s-%s [%s]", alpm_pkg_get_name(target->remove),
alpm_pkg_get_version(target->remove), _("removal"));
}
names = alpm_list_add(names, str);
}
/* print to screen */
pm_asprintf(&str, "%s (%zd)", _("Packages"), alpm_list_count(targets));
printf("\n");
cols = getcols(fileno(stdout));
if(verbose) {
header = create_verbose_header(alpm_list_count(targets));
if(table_display(header, rows, cols) != 0) {
/* fallback to list display if table wouldn't fit */
list_display(str, names, cols);
}
} else {
list_display(str, names, cols);
}
printf("\n");
table_free(header, rows);
FREELIST(names);
free(str);
rows = NULL;
if(dlsize > 0 || config->op_s_downloadonly) {
add_transaction_sizes_row(&rows, _("Total Download Size:"), dlsize);
}
if(!config->op_s_downloadonly) {
if(isize > 0) {
add_transaction_sizes_row(&rows, _("Total Installed Size:"), isize);
}
if(rsize > 0 && isize == 0) {
add_transaction_sizes_row(&rows, _("Total Removed Size:"), rsize);
}
/* only show this net value if different from raw installed size */
if(isize > 0 && rsize > 0) {
add_transaction_sizes_row(&rows, _("Net Upgrade Size:"), isize - rsize);
}
}
table_display(NULL, rows, cols);
table_free(NULL, rows);
}