1
1
mirror of http://git.sesse.net/plocate synced 2025-10-05 23:42:49 +02:00
Files
plocate/conf.cpp
2024-01-06 14:44:59 +01:00

654 lines
17 KiB
C++

/* updatedb configuration.
Copyright (C) 2005, 2007, 2008 Red Hat, Inc. All rights reserved.
This copyrighted material is made available to anyone wishing to use, modify,
copy, or redistribute it subject to the terms and conditions of the GNU General
Public License v.2.
This program is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 51 Franklin
Street, Fifth Floor, Boston, MA 02110-1301, USA.
Author: Miloslav Trmac <mitr@redhat.com>
plocate modifications: Copyright (C) 2020 Steinar H. Gunderson.
plocate parts and modifications are licensed under the GPLv2 or, at your option,
any later version.
*/
#include "conf.h"
#include "lib.h"
#include <algorithm>
#include <ctype.h>
#include <errno.h>
#include <getopt.h>
#include <limits.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
using namespace std;
/* true if locate(1) should check whether files are visible before reporting
them */
bool conf_check_visibility = true;
/* Filesystems to skip, converted to uppercase and sorted by name */
vector<string> conf_prunefs;
/* Directory names to skip, sorted by name */
vector<string> conf_prunenames;
/* Paths to skip, sorted by name using dir_path_cmp () */
vector<string> conf_prunepaths;
/* true if bind mounts should be skipped */
bool conf_prune_bind_mounts; /* = false; */
/* true if pruning debug output was requested */
bool conf_debug_pruning; /* = false; */
/* Root of the directory tree to store in the database (canonical) */
char *conf_scan_root; /* = NULL; */
/* Absolute (not necessarily canonical) path to the database */
string conf_output;
/* 1 if file names should be written to stdout as they are found */
bool conf_verbose; /* = false; */
/* Configuration representation for the database configuration block */
string conf_block;
int conf_block_size = 32;
bool use_debug = false;
/* Parse a STR, store the parsed boolean value to DEST;
return 0 if OK, -1 on error. */
static int
parse_bool(bool *dest, const char *str)
{
if (strcmp(str, "0") == 0 || strcmp(str, "no") == 0) {
*dest = false;
return 0;
}
if (strcmp(str, "1") == 0 || strcmp(str, "yes") == 0) {
*dest = true;
return 0;
}
return -1;
}
/* String list handling */
/* Add values from space-separated VAL to VAR and LIST */
static void
var_add_values(vector<string> *list, const char *val)
{
for (;;) {
const char *start;
while (isspace((unsigned char)*val))
val++;
if (*val == 0)
break;
start = val;
do
val++;
while (*val != 0 && !isspace((unsigned char)*val));
list->emplace_back(start, val - start);
}
}
/* Finish variable LIST, sort its contents, remove duplicates */
static void
var_finish(vector<string> *list)
{
sort(list->begin(), list->end());
auto new_end = unique(list->begin(), list->end());
list->erase(new_end, list->end());
}
/* UPDATEDB_CONF parsing */
/* UPDATEDB_CONF (locked) */
static FILE *uc_file;
/* Line number at token start; type matches error_at_line () */
static unsigned uc_line;
/* Current line number; type matches error_at_line () */
static unsigned uc_current_line;
/* Last string returned by uc_lex */
static string uc_lex_buf;
/* Token types */
enum {
UCT_EOF,
UCT_EOL,
UCT_IDENTIFIER,
UCT_EQUAL,
UCT_QUOTED,
UCT_OTHER,
UCT_PRUNE_BIND_MOUNTS,
UCT_PRUNEFS,
UCT_PRUNENAMES,
UCT_PRUNEPATHS
};
/* Return next token from uc_file; for UCT_IDENTIFIER, UCT_QUOTED or keywords,
store the data to uc_lex_buf (valid until next call). */
static int
uc_lex(void)
{
int c;
uc_lex_buf.clear();
uc_line = uc_current_line;
do {
c = getc_unlocked(uc_file);
if (c == EOF)
return UCT_EOF;
} while (c != '\n' && isspace((unsigned char)c));
switch (c) {
case '#':
do {
c = getc_unlocked(uc_file);
if (c == EOF)
return UCT_EOF;
} while (c != '\n');
/* Fall through */
case '\n':
uc_current_line++;
return UCT_EOL;
case '=':
return UCT_EQUAL;
case '"': {
while ((c = getc_unlocked(uc_file)) != '"') {
if (c == EOF || c == '\n') {
fprintf(stderr, "%s:%u: missing closing `\"'\n",
UPDATEDB_CONF, uc_line);
exit(EXIT_FAILURE);
}
uc_lex_buf.push_back(c);
}
return UCT_QUOTED;
}
default: {
if (!isalpha((unsigned char)c) && c != '_')
return UCT_OTHER;
do {
uc_lex_buf.push_back(c);
c = getc_unlocked(uc_file);
} while (c != EOF && (isalnum((unsigned char)c) || c == '_'));
ungetc(c, uc_file);
if (uc_lex_buf == "PRUNE_BIND_MOUNTS")
return UCT_PRUNE_BIND_MOUNTS;
if (uc_lex_buf == "PRUNEFS")
return UCT_PRUNEFS;
if (uc_lex_buf == "PRUNENAMES")
return UCT_PRUNENAMES;
if (uc_lex_buf == "PRUNEPATHS")
return UCT_PRUNEPATHS;
return UCT_IDENTIFIER;
}
}
}
/* Parse /etc/updatedb.conf. Exit on I/O or syntax error. */
static void
parse_updatedb_conf(void)
{
bool had_prune_bind_mounts, had_prunefs, had_prunenames, had_prunepaths;
uc_file = fopen(UPDATEDB_CONF, "r");
if (uc_file == NULL) {
if (errno != ENOENT) {
perror(UPDATEDB_CONF);
exit(EXIT_FAILURE);
}
return;
}
flockfile(uc_file);
uc_current_line = 1;
had_prune_bind_mounts = false;
had_prunefs = false;
had_prunenames = false;
had_prunepaths = false;
for (;;) {
bool *had_var;
int var_token, token;
token = uc_lex();
switch (token) {
case UCT_EOF:
goto eof;
case UCT_EOL:
continue;
case UCT_PRUNE_BIND_MOUNTS:
had_var = &had_prune_bind_mounts;
break;
case UCT_PRUNEFS:
had_var = &had_prunefs;
break;
case UCT_PRUNENAMES:
had_var = &had_prunenames;
break;
case UCT_PRUNEPATHS:
had_var = &had_prunepaths;
break;
case UCT_IDENTIFIER:
fprintf(stderr, "%s:%u: unknown variable: `%s'\n",
UPDATEDB_CONF, uc_line, uc_lex_buf.c_str());
exit(EXIT_FAILURE);
default:
fprintf(stderr, "%s:%u: variable name expected\n",
UPDATEDB_CONF, uc_line);
exit(EXIT_FAILURE);
}
if (*had_var != false) {
fprintf(stderr, "%s:%u: variable `%s' was already defined\n",
UPDATEDB_CONF, uc_line, uc_lex_buf.c_str());
exit(EXIT_FAILURE);
}
*had_var = true;
var_token = token;
token = uc_lex();
if (token != UCT_EQUAL) {
fprintf(stderr, "%s:%u: `=' expected after variable name\n",
UPDATEDB_CONF, uc_line);
exit(EXIT_FAILURE);
}
token = uc_lex();
if (token != UCT_QUOTED) {
fprintf(stderr, "%s:%u: value in quotes expected after `='\n",
UPDATEDB_CONF, uc_line);
exit(EXIT_FAILURE);
}
if (var_token == UCT_PRUNE_BIND_MOUNTS) {
if (parse_bool(&conf_prune_bind_mounts, uc_lex_buf.c_str()) != 0) {
fprintf(stderr, "%s:%u: invalid value `%s' of PRUNE_BIND_MOUNTS\n",
UPDATEDB_CONF, uc_line, uc_lex_buf.c_str());
exit(EXIT_FAILURE);
}
} else if (var_token == UCT_PRUNEFS)
var_add_values(&conf_prunefs, uc_lex_buf.c_str());
else if (var_token == UCT_PRUNENAMES)
var_add_values(&conf_prunenames, uc_lex_buf.c_str());
else if (var_token == UCT_PRUNEPATHS)
var_add_values(&conf_prunepaths, uc_lex_buf.c_str());
else
abort();
token = uc_lex();
if (token != UCT_EOL && token != UCT_EOF) {
fprintf(stderr, "%s:%u: unexpected data after variable value\n",
UPDATEDB_CONF, uc_line);
exit(EXIT_FAILURE);
}
/* Fall through */
while (token != UCT_EOL) {
if (token == UCT_EOF)
goto eof;
token = uc_lex();
}
}
eof:
if (ferror(uc_file)) {
perror(UPDATEDB_CONF);
exit(EXIT_FAILURE);
}
funlockfile(uc_file);
fclose(uc_file);
}
/* Command-line argument parsing */
/* Output --help text */
static void
help(void)
{
printf("Usage: updatedb [OPTION]...\n"
"Update a plocate database.\n"
"\n"
" -f, --add-prunefs FS omit also FS (space-separated)\n"
" -n, --add-prunenames NAMES omit also NAMES (space-separated)\n"
" -e, --add-prunepaths PATHS omit also PATHS (space-separated)\n"
" --add-single-prunepath PATH omit also PATH\n"
" -U, --database-root PATH the subtree to store in "
"database (default \"/\")\n"
" -h, --help print this help\n"
" -o, --output FILE database to update (default\n"
" `%s')\n"
" -b, --block-size SIZE number of filenames to store\n"
" in each block (default 32)\n"
" --prune-bind-mounts FLAG omit bind mounts (default "
"\"no\")\n"
" --prunefs FS filesystems to omit from "
"database\n"
" --prunenames NAMES directory names to omit from "
"database\n"
" --prunepaths PATHS paths to omit from database\n"
" -l, --require-visibility FLAG check visibility before "
"reporting files\n"
" (default \"yes\")\n"
" -v, --verbose print paths of files as they "
"are found\n"
" -V, --version print version information\n"
"\n"
"The configuration defaults to values read from\n"
"`%s'.\n",
DBFILE, UPDATEDB_CONF);
printf("\n"
"Report bugs to %s.\n",
PACKAGE_BUGREPORT);
}
/* Prepend current working directory to PATH;
return resulting path */
static string
prepend_cwd(const string &path)
{
const char *res;
string buf;
buf.resize(BUFSIZ); /* Not PATH_MAX because it is not defined on some platforms. */
do
buf.resize(buf.size() * 1.5);
while ((res = getcwd(buf.data(), buf.size())) == NULL && errno == ERANGE);
if (res == NULL) {
fprintf(stderr, "%s: %s: can not get current working directory\n",
program_invocation_name, strerror(errno));
exit(EXIT_FAILURE);
}
buf.resize(strlen(buf.data()));
return buf + '/' + path;
}
/* Parse ARGC, ARGV. Exit on error or --help, --version. */
static void
parse_arguments(int argc, char *argv[])
{
enum { OPT_DEBUG_PRUNING = CHAR_MAX + 1,
OPT_ADD_SINGLE_PRUNEPATH = CHAR_MAX + 2 };
static const struct option options[] = {
{ "add-prunefs", required_argument, NULL, 'f' },
{ "add-prunenames", required_argument, NULL, 'n' },
{ "add-prunepaths", required_argument, NULL, 'e' },
{ "add-single-prunepath", required_argument, NULL, OPT_ADD_SINGLE_PRUNEPATH },
{ "database-root", required_argument, NULL, 'U' },
{ "debug-pruning", no_argument, NULL, OPT_DEBUG_PRUNING },
{ "help", no_argument, NULL, 'h' },
{ "output", required_argument, NULL, 'o' },
{ "prune-bind-mounts", required_argument, NULL, 'B' },
{ "prunefs", required_argument, NULL, 'F' },
{ "prunenames", required_argument, NULL, 'N' },
{ "prunepaths", required_argument, NULL, 'P' },
{ "require-visibility", required_argument, NULL, 'l' },
{ "verbose", no_argument, NULL, 'v' },
{ "version", no_argument, NULL, 'V' },
{ "block-size", required_argument, 0, 'b' },
{ "debug", no_argument, 0, 'D' }, // Not documented.
{ NULL, 0, NULL, 0 }
};
bool prunefs_changed, prunenames_changed, prunepaths_changed;
bool got_prune_bind_mounts, got_visibility;
prunefs_changed = false;
prunenames_changed = false;
prunepaths_changed = false;
got_prune_bind_mounts = false;
got_visibility = false;
for (;;) {
int opt, idx;
opt = getopt_long(argc, argv, "U:Ve:f:hl:n:o:vb:D", options, &idx);
switch (opt) {
case -1:
goto options_done;
case '?':
exit(EXIT_FAILURE);
case 'B':
if (got_prune_bind_mounts != false) {
fprintf(stderr, "%s: --%s would override earlier command-line argument\n",
program_invocation_name, "prune-bind-mounts");
exit(EXIT_FAILURE);
}
got_prune_bind_mounts = true;
if (parse_bool(&conf_prune_bind_mounts, optarg) != 0) {
fprintf(stderr, "%s: invalid value %s of --%s\n",
program_invocation_name, optarg, "prune-bind-mounts");
exit(EXIT_FAILURE);
}
break;
case 'F':
if (prunefs_changed != false) {
fprintf(stderr, "%s: --%s would override earlier command-line argument\n",
program_invocation_name, "prunefs");
exit(EXIT_FAILURE);
}
prunefs_changed = true;
conf_prunefs.clear();
var_add_values(&conf_prunefs, optarg);
break;
case 'N':
if (prunenames_changed != false) {
fprintf(stderr, "%s: --%s would override earlier command-line argument\n",
program_invocation_name, "prunenames");
exit(EXIT_FAILURE);
}
prunenames_changed = true;
conf_prunenames.clear();
var_add_values(&conf_prunenames, optarg);
break;
case 'P':
if (prunepaths_changed != false) {
fprintf(stderr, "%s: --%s would override earlier command-line argument\n",
program_invocation_name, "prunepaths");
exit(EXIT_FAILURE);
}
prunepaths_changed = true;
conf_prunepaths.clear();
var_add_values(&conf_prunepaths, optarg);
break;
case 'U':
if (conf_scan_root != NULL) {
fprintf(stderr, "%s: --%s specified twice\n",
program_invocation_name, "database-root");
exit(EXIT_FAILURE);
}
conf_scan_root = realpath(optarg, nullptr);
if (conf_scan_root == NULL) {
fprintf(stderr, "%s: %s: invalid value `%s' of --%s\n",
program_invocation_name, strerror(errno), optarg, "database-root");
exit(EXIT_FAILURE);
}
break;
case 'V':
puts("updatedb (" PACKAGE_NAME ") " PACKAGE_VERSION);
puts("Copyright (C) 2007 Red Hat, Inc. All rights reserved.\n"
"This software is distributed under the GPL v.2.\n"
"\n"
"This program is provided with NO WARRANTY, to the extent "
"permitted by law.");
exit(EXIT_SUCCESS);
case 'e':
prunepaths_changed = true;
var_add_values(&conf_prunepaths, optarg);
break;
case OPT_ADD_SINGLE_PRUNEPATH:
prunepaths_changed = true;
conf_prunepaths.push_back(optarg);
break;
case 'f':
prunefs_changed = true;
var_add_values(&conf_prunefs, optarg);
break;
case 'h':
help();
exit(EXIT_SUCCESS);
case 'l':
if (got_visibility != false) {
fprintf(stderr, "%s: --%s specified twice\n",
program_invocation_name, "require-visibility");
exit(EXIT_FAILURE);
}
got_visibility = true;
if (parse_bool(&conf_check_visibility, optarg) != 0) {
fprintf(stderr, "%s: invalid value `%s' of --%s",
program_invocation_name, optarg, "require-visibility");
exit(EXIT_FAILURE);
}
break;
case 'n':
prunenames_changed = true;
var_add_values(&conf_prunenames, optarg);
break;
case 'o':
if (!conf_output.empty()) {
fprintf(stderr, "%s: --%s specified twice",
program_invocation_name, "output");
exit(EXIT_FAILURE);
}
conf_output = optarg;
break;
case 'v':
conf_verbose = true;
break;
case 'b':
conf_block_size = atoi(optarg);
break;
case 'D':
use_debug = true;
break;
case OPT_DEBUG_PRUNING:
conf_debug_pruning = true;
break;
default:
abort();
}
}
options_done:
if (optind != argc) {
fprintf(stderr, "%s: unexpected operand on command line",
program_invocation_name);
exit(EXIT_FAILURE);
}
if (conf_scan_root == NULL) {
static char root[] = "/";
conf_scan_root = root;
}
if (conf_output.empty())
conf_output = DBFILE;
if (conf_output[0] != '/')
conf_output = prepend_cwd(conf_output);
}
/* Conversion of configuration for main code */
/* Store a string list to OBSTACK */
static void
gen_conf_block_string_list(string *obstack,
const vector<string> *strings)
{
for (const string &str : *strings) {
*obstack += str;
*obstack += '\0';
}
*obstack += '\0';
}
/* Generate conf_block */
static void
gen_conf_block(void)
{
conf_block.clear();
#define CONST(S) conf_block.append(S, sizeof(S))
/* conf_check_visibility value is stored in the header */
CONST("prune_bind_mounts");
/* Add two NUL bytes after the value */
conf_block.append(conf_prune_bind_mounts != false ? "1\0" : "0\0", 3);
CONST("prunefs");
gen_conf_block_string_list(&conf_block, &conf_prunefs);
CONST("prunenames");
gen_conf_block_string_list(&conf_block, &conf_prunenames);
CONST("prunepaths");
gen_conf_block_string_list(&conf_block, &conf_prunepaths);
/* scan_root is contained directly in the header */
/* conf_output, conf_verbose are not relevant */
#undef CONST
}
/* Parse /etc/updatedb.conf and command-line arguments ARGC, ARGV.
Exit on error or --help, --version. */
void conf_prepare(int argc, char *argv[])
{
parse_updatedb_conf();
parse_arguments(argc, argv);
for (string &str : conf_prunefs) {
/* Assuming filesystem names are ASCII-only */
for (char &c : str)
c = toupper(c);
}
/* Finish the variable only after converting filesystem names to upper case
to avoid keeping duplicates that originally differed in case and to sort
them correctly. */
var_finish(&conf_prunefs);
var_finish(&conf_prunenames);
var_finish(&conf_prunepaths);
gen_conf_block();
string_list_dir_path_sort(&conf_prunepaths);
if (conf_debug_pruning) {
fprintf(stderr, "conf_block:\n");
for (char c : conf_block) {
if (isascii((unsigned char)c) && isprint((unsigned char)c) && c != '\\')
putc(c, stderr);
else {
fprintf(stderr, "\\%03o", (unsigned)(unsigned char)c);
if (c == 0)
putc('\n', stderr);
}
}
fprintf(stderr, "\n-----------------------\n");
}
}