325 lines
8.1 KiB
C
325 lines
8.1 KiB
C
/*-
|
|
* Copyright (c) 2008-2013 Juan Romero Pardines.
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
|
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdbool.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <errno.h>
|
|
#include <limits.h>
|
|
#include <libgen.h>
|
|
#include <fnmatch.h>
|
|
#include <assert.h>
|
|
|
|
#include <xbps.h>
|
|
#include "defs.h"
|
|
|
|
static void
|
|
print_value_obj(const char *keyname, xbps_object_t obj,
|
|
const char *indent, bool raw)
|
|
{
|
|
xbps_array_t allkeys;
|
|
xbps_object_t obj2, keysym;
|
|
const char *ksymname, *value;
|
|
char size[8];
|
|
|
|
if (indent == NULL)
|
|
indent = "";
|
|
|
|
switch (xbps_object_type(obj)) {
|
|
case XBPS_TYPE_STRING:
|
|
if (!raw)
|
|
printf("%s%s: ", indent, keyname);
|
|
printf("%s\n", xbps_string_cstring_nocopy(obj));
|
|
break;
|
|
case XBPS_TYPE_NUMBER:
|
|
if (!raw)
|
|
printf("%s%s: ", indent, keyname);
|
|
if (xbps_humanize_number(size,
|
|
(int64_t)xbps_number_unsigned_integer_value(obj)) == -1)
|
|
printf("%ju\n",
|
|
xbps_number_unsigned_integer_value(obj));
|
|
else
|
|
printf("%s\n", size);
|
|
break;
|
|
case XBPS_TYPE_BOOL:
|
|
if (!raw)
|
|
printf("%s%s: ", indent, keyname);
|
|
printf("%s\n", xbps_bool_true(obj) ? "yes" : "no");
|
|
break;
|
|
case XBPS_TYPE_ARRAY:
|
|
if (!raw)
|
|
printf("%s%s:\n", indent, keyname);
|
|
for (unsigned int i = 0; i < xbps_array_count(obj); i++) {
|
|
obj2 = xbps_array_get(obj, i);
|
|
if (xbps_object_type(obj2) == XBPS_TYPE_STRING) {
|
|
value = xbps_string_cstring_nocopy(obj2);
|
|
printf("%s%s%s\n", indent, !raw ? "\t" : "",
|
|
value);
|
|
} else {
|
|
print_value_obj(keyname, obj2, " ", raw);
|
|
}
|
|
}
|
|
break;
|
|
case XBPS_TYPE_DICTIONARY:
|
|
allkeys = xbps_dictionary_all_keys(obj);
|
|
for (unsigned int i = 0; i < xbps_array_count(allkeys); i++) {
|
|
keysym = xbps_array_get(allkeys, i);
|
|
ksymname = xbps_dictionary_keysym_cstring_nocopy(keysym);
|
|
obj2 = xbps_dictionary_get_keysym(obj, keysym);
|
|
print_value_obj(ksymname, obj2, " ", raw);
|
|
}
|
|
xbps_object_release(allkeys);
|
|
if (raw)
|
|
printf("\n");
|
|
break;
|
|
case XBPS_TYPE_DATA:
|
|
if (!raw) {
|
|
xbps_humanize_number(size, (int64_t)xbps_data_size(obj));
|
|
printf("%s%s: %s\n", indent, keyname, size);
|
|
} else {
|
|
FILE *f;
|
|
char buf[BUFSIZ-1];
|
|
void *data;
|
|
|
|
data = xbps_data_data(obj);
|
|
f = fmemopen(data, xbps_data_size(obj), "r");
|
|
assert(f);
|
|
while (fgets(buf, BUFSIZ-1, f))
|
|
printf("%s", buf);
|
|
fclose(f);
|
|
free(data);
|
|
}
|
|
break;
|
|
default:
|
|
xbps_warn_printf("unknown obj type (key %s)\n",
|
|
keyname);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
show_pkg_info_one(xbps_dictionary_t d, const char *keys)
|
|
{
|
|
xbps_object_t obj;
|
|
char *key, *p, *saveptr;
|
|
|
|
if (strchr(keys, ',') == NULL) {
|
|
obj = xbps_dictionary_get(d, keys);
|
|
if (obj == NULL)
|
|
return;
|
|
print_value_obj(keys, obj, NULL, true);
|
|
return;
|
|
}
|
|
key = strdup(keys);
|
|
if (key == NULL)
|
|
abort();
|
|
for ((p = strtok_r(key, ",", &saveptr)); p;
|
|
(p = strtok_r(NULL, ",", &saveptr))) {
|
|
obj = xbps_dictionary_get(d, p);
|
|
if (obj == NULL)
|
|
continue;
|
|
print_value_obj(p, obj, NULL, true);
|
|
}
|
|
free(key);
|
|
}
|
|
|
|
static void
|
|
print_srcrevs(const char *keyname, xbps_string_t obj)
|
|
{
|
|
const char *str = xbps_string_cstring_nocopy(obj);
|
|
|
|
/* parse string appending a \t after EOL */
|
|
printf("%s:\n ", keyname);
|
|
for (unsigned int i = 0; i < strlen(str); i++) {
|
|
if (str[i] == '\n')
|
|
printf("\n ");
|
|
else
|
|
putchar(str[i]);
|
|
}
|
|
putchar('\n');
|
|
}
|
|
|
|
void
|
|
show_pkg_info(xbps_dictionary_t dict)
|
|
{
|
|
xbps_array_t all_keys;
|
|
xbps_object_t obj, keysym;
|
|
const char *keyname;
|
|
|
|
all_keys = xbps_dictionary_all_keys(dict);
|
|
for (unsigned int i = 0; i < xbps_array_count(all_keys); i++) {
|
|
keysym = xbps_array_get(all_keys, i);
|
|
keyname = xbps_dictionary_keysym_cstring_nocopy(keysym);
|
|
obj = xbps_dictionary_get_keysym(dict, keysym);
|
|
/* ignore objs shown by other targets */
|
|
if ((strcmp(keyname, "run_depends") == 0) ||
|
|
(strcmp(keyname, "files") == 0) ||
|
|
(strcmp(keyname, "dirs") == 0) ||
|
|
(strcmp(keyname, "links") == 0))
|
|
continue;
|
|
|
|
/* special case for source-revisions obj */
|
|
if (strcmp(keyname, "source-revisions") == 0) {
|
|
print_srcrevs(keyname, obj);
|
|
continue;
|
|
}
|
|
/* anything else */
|
|
print_value_obj(keyname, obj, NULL, false);
|
|
}
|
|
}
|
|
|
|
int
|
|
show_pkg_files(xbps_dictionary_t filesd)
|
|
{
|
|
xbps_array_t array, allkeys;
|
|
xbps_object_t obj;
|
|
xbps_dictionary_keysym_t ksym;
|
|
const char *keyname, *file;
|
|
|
|
if (xbps_object_type(filesd) != XBPS_TYPE_DICTIONARY)
|
|
return EINVAL;
|
|
|
|
allkeys = xbps_dictionary_all_keys(filesd);
|
|
for (unsigned int i = 0; i < xbps_array_count(allkeys); i++) {
|
|
ksym = xbps_array_get(allkeys, i);
|
|
keyname = xbps_dictionary_keysym_cstring_nocopy(ksym);
|
|
if ((strcmp(keyname, "files") &&
|
|
(strcmp(keyname, "conf_files") &&
|
|
(strcmp(keyname, "links")))))
|
|
continue;
|
|
|
|
array = xbps_dictionary_get(filesd, keyname);
|
|
if (array == NULL || xbps_array_count(array) == 0)
|
|
continue;
|
|
|
|
for (unsigned int x = 0; x < xbps_array_count(array); x++) {
|
|
obj = xbps_array_get(array, x);
|
|
if (xbps_object_type(obj) != XBPS_TYPE_DICTIONARY)
|
|
continue;
|
|
xbps_dictionary_get_cstring_nocopy(obj, "file", &file);
|
|
printf("%s", file);
|
|
if (xbps_dictionary_get_cstring_nocopy(obj,
|
|
"target", &file))
|
|
printf(" -> %s", file);
|
|
|
|
printf("\n");
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
show_pkg_info_from_metadir(struct xbps_handle *xhp,
|
|
const char *pkg,
|
|
const char *option)
|
|
{
|
|
xbps_dictionary_t d, pkgdb_d;
|
|
const char *instdate;
|
|
bool autoinst, hold;
|
|
pkg_state_t state;
|
|
|
|
pkgdb_d = xbps_pkgdb_get_pkg(xhp, pkg);
|
|
if (pkgdb_d == NULL)
|
|
return ENOENT;
|
|
|
|
d = xbps_pkgdb_get_pkg_metadata(xhp, pkg);
|
|
if (d == NULL)
|
|
return ENOENT;
|
|
|
|
if (xbps_dictionary_get_cstring_nocopy(pkgdb_d,
|
|
"install-date", &instdate))
|
|
xbps_dictionary_set_cstring_nocopy(d, "install-date",
|
|
instdate);
|
|
|
|
if (xbps_dictionary_get_bool(pkgdb_d, "automatic-install", &autoinst))
|
|
xbps_dictionary_set_bool(d, "automatic-install", autoinst);
|
|
|
|
if (xbps_dictionary_get_bool(pkgdb_d, "hold", &hold))
|
|
xbps_dictionary_set_bool(d, "hold", hold);
|
|
|
|
xbps_pkg_state_dictionary(pkgdb_d, &state);
|
|
xbps_set_pkg_state_dictionary(d, state);
|
|
|
|
if (option == NULL)
|
|
show_pkg_info(d);
|
|
else
|
|
show_pkg_info_one(d, option);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
show_pkg_files_from_metadir(struct xbps_handle *xhp, const char *pkg)
|
|
{
|
|
xbps_dictionary_t d;
|
|
int rv = 0;
|
|
|
|
d = xbps_pkgdb_get_pkg_metadata(xhp, pkg);
|
|
if (d == NULL)
|
|
return ENOENT;
|
|
|
|
rv = show_pkg_files(d);
|
|
|
|
return rv;
|
|
}
|
|
|
|
int
|
|
repo_show_pkg_info(struct xbps_handle *xhp,
|
|
const char *pattern,
|
|
const char *option)
|
|
{
|
|
xbps_dictionary_t pkgd;
|
|
|
|
if (((pkgd = xbps_rpool_get_pkg(xhp, pattern)) == NULL) &&
|
|
((pkgd = xbps_rpool_get_virtualpkg(xhp, pattern)) == NULL))
|
|
return errno;
|
|
|
|
if (option)
|
|
show_pkg_info_one(pkgd, option);
|
|
else
|
|
show_pkg_info(pkgd);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
repo_show_pkg_files(struct xbps_handle *xhp, const char *pkg)
|
|
{
|
|
xbps_dictionary_t pkgd;
|
|
|
|
pkgd = xbps_rpool_get_pkg_plist(xhp, pkg, "./files.plist");
|
|
if (pkgd == NULL) {
|
|
if (errno != ENOTSUP && errno != ENOENT) {
|
|
fprintf(stderr, "Unexpected error: %s\n",
|
|
strerror(errno));
|
|
return errno;
|
|
}
|
|
}
|
|
|
|
return show_pkg_files(pkgd);
|
|
}
|