xbps/bin/xbps-query/ownedby.c
Juan RP 0eadaab19d xbps-query: added --regex to use EREs in ownedby and search modes.
This replaces previous -S, --search-regex option. The regex option
can now be used in the ownedby and search modes.

Also added -S, --show option which is the default mode if no other
mode set, and defaults to it to preserve compatibility.
2014-05-26 17:30:44 +02:00

187 lines
4.8 KiB
C

/*-
* Copyright (c) 2010-2014 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 <fnmatch.h>
#include <dirent.h>
#include <assert.h>
#include <regex.h>
#include <xbps.h>
#include "defs.h"
struct ffdata {
bool regex;
const char *pat, *repouri;
xbps_array_t allkeys;
xbps_dictionary_t filesd;
};
static void
match_files_by_pattern(xbps_dictionary_t pkg_filesd,
xbps_dictionary_keysym_t key,
struct ffdata *ffd,
const char *pkgver)
{
xbps_array_t array;
xbps_object_t obj;
const char *keyname, *filestr, *typestr;
regex_t regex;
keyname = xbps_dictionary_keysym_cstring_nocopy(key);
if (strcmp(keyname, "files") == 0)
typestr = "regular file";
else if (strcmp(keyname, "links") == 0)
typestr = "link";
else if (strcmp(keyname, "conf_files") == 0)
typestr = "configuration file";
else
return;
array = xbps_dictionary_get_keysym(pkg_filesd, key);
for (unsigned int i = 0; i < xbps_array_count(array); i++) {
obj = xbps_array_get(array, i);
filestr = NULL;
xbps_dictionary_get_cstring_nocopy(obj, "file", &filestr);
if (filestr == NULL)
continue;
if (ffd->regex) {
regcomp(&regex, ffd->pat, REG_EXTENDED|REG_NOSUB);
if (regexec(&regex, filestr, 0, 0, 0) == 0) {
printf("%s: %s (%s)\n", pkgver, filestr, typestr);
}
regfree(&regex);
} else {
if ((fnmatch(ffd->pat, filestr, FNM_PERIOD)) == 0)
printf("%s: %s (%s)\n", pkgver, filestr, typestr);
}
}
}
static int
ownedby_pkgdb_cb(struct xbps_handle *xhp,
xbps_object_t obj,
const char *obj_key _unused,
void *arg,
bool *done _unused)
{
xbps_dictionary_t pkgmetad;
xbps_array_t files_keys;
struct ffdata *ffd = arg;
const char *pkgver;
(void)obj_key;
(void)done;
xbps_dictionary_get_cstring_nocopy(obj, "pkgver", &pkgver);
pkgmetad = xbps_pkgdb_get_pkg_metadata(xhp, pkgver);
assert(pkgmetad);
files_keys = xbps_dictionary_all_keys(pkgmetad);
for (unsigned int i = 0; i < xbps_array_count(files_keys); i++) {
match_files_by_pattern(pkgmetad,
xbps_array_get(files_keys, i), ffd, pkgver);
}
xbps_object_release(pkgmetad);
xbps_object_release(files_keys);
return 0;
}
static int
repo_match_cb(struct xbps_handle *xhp _unused,
xbps_object_t obj,
const char *key,
void *arg,
bool *done _unused)
{
struct ffdata *ffd = arg;
const char *filestr;
regex_t regex;
for (unsigned int i = 0; i < xbps_array_count(obj); i++) {
xbps_array_get_cstring_nocopy(obj, i, &filestr);
if (ffd->regex) {
regcomp(&regex, ffd->pat, REG_EXTENDED|REG_NOSUB);
if (regexec(&regex, filestr, 0, 0, 0) == 0) {
printf("%s: %s (%s)\n", key, filestr, ffd->repouri);
}
regfree(&regex);
} else {
if ((fnmatch(ffd->pat, filestr, FNM_PERIOD)) == 0)
printf("%s: %s (%s)\n", key, filestr, ffd->repouri);
}
}
return 0;
}
static int
repo_ownedby_cb(struct xbps_repo *repo, void *arg, bool *done _unused)
{
xbps_array_t allkeys;
struct ffdata *ffd = arg;
int rv;
xbps_repo_open_idxfiles(repo);
if (repo->idxfiles == NULL)
return 0;
ffd->repouri = repo->uri;
allkeys = xbps_dictionary_all_keys(repo->idxfiles);
rv = xbps_array_foreach_cb(repo->xhp, allkeys, repo->idxfiles, repo_match_cb, ffd);
xbps_object_release(allkeys);
return rv;
}
int
ownedby(struct xbps_handle *xhp, const char *pat, bool repo, bool regex)
{
struct ffdata ffd;
char *rfile;
int rv;
ffd.regex = regex;
ffd.pat = pat;
if ((rfile = realpath(pat, NULL)) != NULL)
ffd.pat = rfile;
if (repo)
rv = xbps_rpool_foreach(xhp, repo_ownedby_cb, &ffd);
else
rv = xbps_pkgdb_foreach_cb(xhp, ownedby_pkgdb_cb, &ffd);
return rv;
}