summaryrefslogtreecommitdiffstats
path: root/src/whatis.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/whatis.c')
-rw-r--r--src/whatis.c943
1 files changed, 943 insertions, 0 deletions
diff --git a/src/whatis.c b/src/whatis.c
new file mode 100644
index 0000000..7306ad7
--- /dev/null
+++ b/src/whatis.c
@@ -0,0 +1,943 @@
+/*
+ * whatis.c: search the index or whatis database(s) for words.
+ *
+ * Copyright (C) 1994, 1995 Graeme W. Wilford. (Wilf.)
+ * Copyright (C) 2001, 2002, 2003, 2004, 2006, 2007, 2008, 2009, 2010, 2011,
+ * 2012 Colin Watson.
+ *
+ * This file is part of man-db.
+ *
+ * man-db is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * man-db 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 man-db; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * routines for whatis and apropos programs. Whatis looks up the
+ * keyword for the description, apropos searches the entire database
+ * for word matches.
+ *
+ * Mon Aug 8 20:35:30 BST 1994 Wilf. (G.Wilford@ee.surrey.ac.uk)
+ *
+ * CJW: Add more safety in the face of corrupted databases.
+ */
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif /* HAVE_CONFIG_H */
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <ctype.h>
+#include <errno.h>
+#include <unistd.h>
+
+#include "gettext.h"
+#include <locale.h>
+#define _(String) gettext (String)
+#define N_(String) gettext_noop (String)
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include "regex.h"
+
+#include "argp.h"
+#include "attribute.h"
+#include "dirname.h"
+#include "error.h"
+#include "gl_hash_set.h"
+#include "gl_list.h"
+#include "gl_xset.h"
+#include "fnmatch.h"
+#include "progname.h"
+#include "xalloc.h"
+#include "xvasprintf.h"
+
+#include "manconfig.h"
+
+#include "appendstr.h"
+#include "cleanup.h"
+#include "debug.h"
+#include "fatal.h"
+#include "filenames.h"
+#include "glcontainers.h"
+#include "pipeline.h"
+#include "pathsearch.h"
+#include "linelength.h"
+#include "wordfnmatch.h"
+#include "xregcomp.h"
+#include "encodings.h"
+#include "sandbox.h"
+#include "util.h"
+
+#include "mydbm.h"
+#include "db_storage.h"
+
+#include "convert.h"
+#include "manp.h"
+
+static gl_list_t manpathlist;
+
+extern char *user_config_file;
+static char **keywords;
+static int num_keywords;
+
+bool am_apropos;
+int quiet = 1;
+man_sandbox *sandbox;
+
+static regex_t *preg;
+static bool regex_opt;
+static bool exact;
+
+static bool wildcard;
+
+static bool require_all;
+
+static bool long_output;
+
+static char **sections;
+
+static char *manp = NULL;
+static const char *alt_systems = "";
+static const char *locale = NULL;
+static char *multiple_locale = NULL, *internal_locale;
+
+static gl_set_t display_seen = NULL;
+
+const char *argp_program_version; /* initialised in main */
+const char *argp_program_bug_address = PACKAGE_BUGREPORT;
+error_t argp_err_exit_status = FAIL;
+
+static const char args_doc[] = N_("KEYWORD...");
+static const char apropos_doc[] = "\v" N_("The --regex option is enabled by default.");
+
+static struct argp_option options[] = {
+ OPT ("debug", 'd', 0, N_("emit debugging messages")),
+ OPT ("verbose", 'v', 0, N_("print verbose warning messages")),
+ OPT ("regex", 'r', 0, N_("interpret each keyword as a regex"), 10),
+ /* apropos only */
+ OPT ("exact", 'e', 0, N_("search each keyword for exact match")),
+ OPT ("wildcard", 'w', 0, N_("the keyword(s) contain wildcards")),
+ /* apropos only */
+ OPT ("and", 'a', 0, N_("require all keywords to match"), 20),
+ OPT ("long", 'l', 0, N_("do not trim output to terminal width"), 30),
+ OPT ("sections", 's', N_("LIST"),
+ N_("search only these sections (colon-separated)"), 40),
+ OPT_ALIAS ("section", 0),
+ OPT ("systems", 'm', N_("SYSTEM"),
+ N_("use manual pages from other systems")),
+ OPT ("manpath", 'M', N_("PATH"),
+ N_("set search path for manual pages to PATH")),
+ OPT ("locale", 'L', N_("LOCALE"),
+ N_("define the locale for this search")),
+ OPT ("config-file", 'C', N_("FILE"),
+ N_("use this user configuration file")),
+ OPT_HIDDEN ("whatis", 'f'),
+ OPT_HIDDEN ("apropos", 'k'),
+ OPT_HELP_COMPAT,
+ { 0 }
+};
+
+static char **split_sections (const char *sections_str)
+{
+ int i = 0;
+ char *str = xstrdup (sections_str);
+ const char *section;
+ char **out = NULL;
+
+ /* Although this is documented as colon-separated, at least Solaris
+ * man's -s option takes a comma-separated list, so we accept that
+ * too for compatibility.
+ */
+ for (section = strtok (str, ":,"); section;
+ section = strtok (NULL, ":,")) {
+ out = xnrealloc (out, i + 2, sizeof *out);
+ out[i++] = xstrdup (section);
+ }
+ if (i)
+ out[i] = NULL;
+
+ free (str);
+ return out;
+}
+
+static error_t parse_opt (int key, char *arg, struct argp_state *state)
+{
+ switch (key) {
+ case 'd':
+ debug_level = true;
+ return 0;
+ case 'v':
+ quiet = 0;
+ return 0;
+ case 'r':
+ regex_opt = true;
+ return 0;
+ case 'e':
+ /* Only makes sense for apropos, but has
+ * historically been accepted by whatis anyway.
+ */
+ regex_opt = false;
+ exact = true;
+ return 0;
+ case 'w':
+ regex_opt = false;
+ wildcard = true;
+ return 0;
+ case 'a':
+ if (am_apropos)
+ require_all = true;
+ else
+ argp_usage (state);
+ return 0;
+ case 'l':
+ long_output = true;
+ return 0;
+ case 's':
+ sections = split_sections (arg);
+ return 0;
+ case 'm':
+ alt_systems = arg;
+ return 0;
+ case 'M':
+ manp = xstrdup (arg);
+ return 0;
+ case 'L':
+ locale = arg;
+ return 0;
+ case 'C':
+ user_config_file = arg;
+ return 0;
+ case 'f':
+ /* helpful override if program name detection fails */
+ am_apropos = false;
+ return 0;
+ case 'k':
+ /* helpful override if program name detection fails */
+ am_apropos = true;
+ return 0;
+ case 'h':
+ argp_state_help (state, state->out_stream,
+ ARGP_HELP_STD_HELP &
+ ~ARGP_HELP_PRE_DOC);
+ break;
+ case ARGP_KEY_ARGS:
+ keywords = state->argv + state->next;
+ num_keywords = state->argc - state->next;
+ return 0;
+ case ARGP_KEY_NO_ARGS:
+ /* Make sure that we have a keyword! */
+ printf (_("%s what?\n"), program_name);
+ exit (FAIL);
+ case ARGP_KEY_SUCCESS:
+ if (am_apropos && !exact && !wildcard)
+ regex_opt = true;
+ return 0;
+ }
+ return ARGP_ERR_UNKNOWN;
+}
+
+static char *help_filter (int key, const char *text, void *input MAYBE_UNUSED)
+{
+ switch (key) {
+ case ARGP_KEY_HELP_PRE_DOC:
+ /* We have no pre-options help text, but the input
+ * text may contain header junk due to gettext ("").
+ */
+ return NULL;
+ default:
+ return (char *) text;
+ }
+}
+
+static struct argp apropos_argp = { options, parse_opt, args_doc, apropos_doc,
+ 0, help_filter };
+static struct argp whatis_argp = { options, parse_opt, args_doc };
+
+static char *locale_manpath (const char *manpath)
+{
+ char *all_locales;
+ char *new_manpath;
+
+ if (multiple_locale && *multiple_locale) {
+ if (internal_locale && *internal_locale)
+ all_locales = xasprintf ("%s:%s", multiple_locale,
+ internal_locale);
+ else
+ all_locales = xstrdup (multiple_locale);
+ } else {
+ if (internal_locale && *internal_locale)
+ all_locales = xstrdup (internal_locale);
+ else
+ all_locales = NULL;
+ }
+
+ new_manpath = add_nls_manpaths (manpath, all_locales);
+ free (all_locales);
+
+ return new_manpath;
+}
+
+/* Do the old thing, if we cannot find the relevant database.
+ * This invokes grep once per argument; we can't do much about this because
+ * we need to know which arguments failed. The only way to speed this up
+ * would be to implement grep internally, but it hardly seems worth it for a
+ * legacy mechanism.
+ */
+static void use_grep (const char * const *pages, int num_pages, char *manpath,
+ bool *found)
+{
+ char *whatis_file = xasprintf ("%s/whatis", manpath);
+ assert (whatis_file);
+
+ if (CAN_ACCESS (whatis_file, R_OK)) {
+ const char *flags;
+ int i;
+
+ if (am_apropos) {
+ if (regex_opt)
+ flags = get_def_user (
+ "apropos_regex_grep_flags",
+ APROPOS_REGEX_GREP_FLAGS);
+ else
+ flags = get_def_user ("apropos_grep_flags",
+ APROPOS_GREP_FLAGS);
+ } else
+ flags = get_def_user ("whatis_grep_flags",
+ WHATIS_GREP_FLAGS);
+
+ for (i = 0; i < num_pages; ++i) {
+ pipeline *grep_pl;
+ pipecmd *grep_cmd;
+ char *anchored_page;
+
+ if (am_apropos)
+ anchored_page = xstrdup (pages[i]);
+ else
+ anchored_page = xasprintf ("^%s", pages[i]);
+
+ grep_cmd = pipecmd_new_argstr
+ (get_def_user ("grep", PROG_GREP));
+ pipecmd_argstr (grep_cmd, flags);
+ pipecmd_args (grep_cmd, anchored_page, whatis_file,
+ (void *) 0);
+ pipecmd_pre_exec (grep_cmd, sandbox_load, sandbox_free,
+ sandbox);
+ grep_pl = pipeline_new_commands (grep_cmd, (void *) 0);
+
+ if (pipeline_run (grep_pl) == 0)
+ found[i] = true;
+
+ free (anchored_page);
+ }
+ } else
+ debug ("warning: can't read the fallback whatis text database "
+ "%s/whatis\n", manpath);
+
+ free (whatis_file);
+}
+
+static struct mandata *resolve_pointers (MYDBM_FILE dbf, struct mandata *info,
+ const char *page)
+{
+ int rounds;
+ const char *newpage;
+
+ if (*(info->pointer) == '-' ||
+ ((!info->name || STREQ (info->name, page)) &&
+ STREQ (info->pointer, page)))
+ return info;
+
+ /* Now we have to work through pointers. The limit of 10 is fairly
+ * arbitrary: it's just there to avoid an infinite loop.
+ */
+ newpage = info->pointer;
+ info = dblookup_exact (dbf, newpage, info->ext, true);
+ for (rounds = 0; rounds < 10; rounds++) {
+ struct mandata *newinfo;
+
+ /* If the pointer lookup fails, do nothing. */
+ if (!info)
+ return NULL;
+
+ if (*(info->pointer) == '-' ||
+ ((!info->name || STREQ (info->name, newpage)) &&
+ STREQ (info->pointer, newpage)))
+ return info;
+
+ newinfo = dblookup_exact (dbf, info->pointer, info->ext, true);
+ free_mandata_struct (info);
+ info = newinfo;
+ }
+
+ if (!quiet)
+ error (0, 0, _("warning: %s contains a pointer loop"), page);
+ return NULL;
+}
+
+/* fill_in_whatis() is really a ../libdb/db_lookup.c routine but whatis.c
+ is the only file that actually requires access to the whatis text... */
+
+/* Take mandata struct (earlier returned from a dblookup()) and return
+ the relative whatis */
+static char *get_whatis (struct mandata *info, const char *page)
+{
+ if (!info)
+ return xstrdup (_("(unknown subject)"));
+
+ /* See if we need to fill in the whatis here. */
+ if (info->whatis != NULL && *(info->whatis))
+ return xstrdup (info->whatis);
+ if (!quiet && *(info->pointer) != '-')
+ error (0, 0, _("warning: %s contains a pointer loop"),
+ page);
+ return xstrdup (_("(unknown subject)"));
+}
+
+/* print out any matches found */
+static void display (MYDBM_FILE dbf, struct mandata *info, const char *page)
+{
+ struct mandata *newinfo;
+ char *string, *whatis, *string_conv;
+ const char *page_name;
+ char *key;
+ int line_len, rest;
+
+ newinfo = resolve_pointers (dbf, info, page);
+ whatis = get_whatis (newinfo, page);
+ if (newinfo == NULL)
+ newinfo = info;
+
+ dbprintf (newinfo);
+
+ if (newinfo->name)
+ page_name = newinfo->name;
+ else
+ page_name = page;
+
+ key = xasprintf ("%s (%s)", page_name, newinfo->ext);
+ if (gl_set_search (display_seen, key))
+ goto out;
+ gl_set_add (display_seen, xstrdup (key));
+
+ line_len = get_line_length ();
+
+ if (!long_output && strlen (page_name) > (size_t) (line_len / 2))
+ string = xasprintf ("%.*s...", line_len / 2 - 3, page_name);
+ else
+ string = xstrdup (page_name);
+ string = appendstr (string, " (", newinfo->ext, ")", (void *) 0);
+ if (!STREQ (newinfo->pointer, "-") && !STREQ (newinfo->pointer, page))
+ string = appendstr (string, " [", newinfo->pointer, "]",
+ (void *) 0);
+
+ if (strlen (string) < (size_t) 20) {
+ int i;
+ string = xrealloc (string, 21);
+ for (i = strlen (string); i < 20; ++i)
+ string[i] = ' ';
+ string[i] = '\0';
+ }
+ string = appendstr (string, " - ", (void *) 0);
+
+ rest = line_len - strlen (string);
+ if (!long_output && strlen (whatis) > (size_t) rest) {
+ whatis[rest - 3] = '\0';
+ string = appendstr (string, whatis, "...\n", (void *) 0);
+ } else
+ string = appendstr (string, whatis, "\n", (void *) 0);
+
+ string_conv = convert_to_locale (string);
+ fputs (string_conv, stdout);
+
+ free (string_conv);
+ free (string);
+
+out:
+ free (key);
+ free (whatis);
+ if (newinfo != info)
+ free_mandata_struct (newinfo);
+}
+
+/* lookup the page and display the results */
+static int do_whatis_section (MYDBM_FILE dbf,
+ const char *page, const char *section)
+{
+ gl_list_t infos;
+ struct mandata *info;
+ int count = 0;
+
+ infos = dblookup_all (dbf, page, section, false);
+ GL_LIST_FOREACH (infos, info) {
+ display (dbf, info, page);
+ count++;
+ }
+ gl_list_free (infos);
+ return count;
+}
+
+static bool suitable_manpath (const char *manpath, const char *page_dir)
+{
+ char *page_manp, *pm;
+ gl_list_t page_manpathlist;
+ bool ret;
+
+ page_manp = get_manpath_from_path (page_dir, false);
+ if (!page_manp || !*page_manp) {
+ free (page_manp);
+ return false;
+ }
+ pm = locale_manpath (page_manp);
+ free (page_manp);
+ page_manp = pm;
+ page_manpathlist = create_pathlist (page_manp);
+
+ ret = gl_list_search (page_manpathlist, manpath) ? true : false;
+
+ free_pathlist (page_manpathlist);
+ free (page_manp);
+ return ret;
+}
+
+static void do_whatis (MYDBM_FILE dbf,
+ const char * const *pages, int num_pages,
+ const char *manpath, bool *found)
+{
+ int i;
+
+ for (i = 0; i < num_pages; ++i) {
+ char *page = xstrdup (pages[i]);
+ struct stat st;
+
+ if (strchr (page, '/') && stat (page, &st) == 0 &&
+ !S_ISDIR (st.st_mode) &&
+ st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)) {
+ /* Perhaps an executable. If its directory is on
+ * $PATH, then we only want to process this page for
+ * matching manual hierarchies.
+ */
+ char *page_dir = dir_name (page);
+
+ if (directory_on_path (page_dir)) {
+ if (suitable_manpath (manpath, page_dir)) {
+ char *old_page = page;
+ page = base_name (old_page);
+ free (old_page);
+ } else {
+ debug ("%s not on manpath for %s\n",
+ manpath, page);
+ free (page_dir);
+ free (page);
+ continue;
+ }
+ }
+ free (page_dir);
+ }
+
+ if (sections) {
+ char * const *section;
+
+ for (section = sections; *section; ++section) {
+ if (do_whatis_section (dbf, page, *section))
+ found[i] = true;
+ }
+ } else {
+ if (do_whatis_section (dbf, page, NULL))
+ found[i] = true;
+ }
+
+ free (page);
+ }
+}
+
+static bool any_set (int num_pages, bool *found_here)
+{
+ int i;
+
+ for (i = 0; i < num_pages; ++i)
+ if (found_here[i])
+ return true;
+ return false;
+}
+
+static bool all_set (int num_pages, bool *found_here)
+{
+ int i;
+
+ for (i = 0; i < num_pages; ++i)
+ if (!found_here[i])
+ return false;
+ return true;
+}
+
+static void parse_name (const char * const *pages, int num_pages,
+ const char *dbname, bool *found, bool *found_here)
+{
+ int i;
+
+ if (regex_opt) {
+ for (i = 0; i < num_pages; ++i) {
+ if (regexec (&preg[i], dbname, 0,
+ (regmatch_t *) 0, 0) == 0)
+ found[i] = found_here[i] = true;
+ }
+ return;
+ }
+
+ if (am_apropos && !wildcard) {
+ for (i = 0; i < num_pages; ++i) {
+ if (strcasecmp (dbname, pages[i]) == 0)
+ found[i] = found_here[i] = true;
+ }
+ return;
+ }
+
+ for (i = 0; i < num_pages; ++i) {
+ if (fnmatch (pages[i], dbname, FNM_CASEFOLD) == 0)
+ found[i] = found_here[i] = true;
+ }
+}
+
+/* return true on word match */
+static bool ATTRIBUTE_PURE match (const char *page, const char *whatis)
+{
+ size_t len = strlen (page);
+ const char *begin;
+ char *p;
+
+ begin = whatis;
+
+ /* check for string match, then see if it is a _word_ */
+ while (whatis && (p = strcasestr (whatis, page))) {
+ char *left = p - 1;
+ char *right = p + len;
+
+ if ((p == begin || (!CTYPE (isalpha, *left) && *left != '_')) &&
+ (!*right || (!CTYPE (isalpha, *right) && *right != '_')))
+ return true;
+ whatis = p + 1;
+ }
+
+ return false;
+}
+
+static void parse_whatis (const char * const *pages, int num_pages,
+ const char *whatis, bool *found, bool *found_here)
+{
+ int i;
+
+ if (regex_opt) {
+ for (i = 0; i < num_pages; ++i) {
+ if (regexec (&preg[i], whatis, 0,
+ (regmatch_t *) 0, 0) == 0)
+ found[i] = found_here[i] = true;
+ }
+ return;
+ }
+
+ if (wildcard) {
+ for (i = 0; i < num_pages; ++i) {
+ if (exact) {
+ if (fnmatch (pages[i], whatis, 0) == 0)
+ found[i] = found_here[i] = true;
+ } else {
+ if (word_fnmatch (pages[i], whatis))
+ found[i] = found_here[i] = true;
+ }
+ }
+ return;
+ }
+
+ for (i = 0; i < num_pages; ++i) {
+ if (match (pages[i], whatis))
+ found[i] = found_here[i] = true;
+ }
+}
+
+/* cjwatson: Optimized functions don't seem to be correct in some
+ * circumstances; disabled for now.
+ */
+#undef BTREE
+
+/* scan for the page, print any matches */
+static void do_apropos (MYDBM_FILE dbf,
+ const char * const *pages, int num_pages, bool *found)
+{
+ datum key, cont;
+ bool *found_here;
+ bool (*combine) (int, bool *);
+#ifndef BTREE
+ datum nextkey;
+#else /* BTREE */
+ int end;
+#endif /* !BTREE */
+
+ found_here = XNMALLOC (num_pages, bool);
+ combine = require_all ? all_set : any_set;
+
+#ifndef BTREE
+ key = MYDBM_FIRSTKEY (dbf);
+ while (MYDBM_DPTR (key)) {
+ cont = MYDBM_FETCH (dbf, key);
+#else /* BTREE */
+ end = man_btree_nextkeydata (dbf, &key, &cont);
+ while (!end) {
+#endif /* !BTREE */
+ char *tab;
+ struct mandata *info = NULL;
+
+ /* bug#4372, NULL pointer dereference in MYDBM_DPTR (cont),
+ * fix by dassen@wi.leidenuniv.nl (J.H.M.Dassen), thanx Ray.
+ * cjwatson: In that case, complain and exit, otherwise we
+ * might loop (bug #95052).
+ */
+ if (!MYDBM_DPTR (cont))
+ {
+ debug ("key was %s\n", MYDBM_DPTR (key));
+ fatal (0,
+ _("Database %s corrupted; rebuild with "
+ "mandb --create"),
+ dbf->name);
+ }
+
+#pragma GCC diagnostic push
+#if GNUC_PREREQ(10,0)
+# pragma GCC diagnostic ignored "-Wanalyzer-use-after-free"
+#endif
+ if (*MYDBM_DPTR (key) == '$')
+ goto nextpage;
+
+ if (*MYDBM_DPTR (cont) == '\t')
+ goto nextpage;
+#pragma GCC diagnostic pop
+
+ /* a real page */
+
+ info = split_content (dbf, MYDBM_DPTR (cont));
+
+ /* If there are sections given, does any of them match
+ * either the section or extension of this page?
+ */
+ if (sections) {
+ char * const *section;
+ bool matched = false;
+
+ for (section = sections; *section; ++section) {
+ if (STREQ (*section, info->sec) ||
+ STREQ (*section, info->ext)) {
+ matched = true;
+ break;
+ }
+ }
+
+ if (!matched)
+ goto nextpage;
+ }
+
+ tab = strrchr (MYDBM_DPTR (key), '\t');
+ if (tab)
+ *tab = '\0';
+
+ memset (found_here, 0, num_pages * sizeof (*found_here));
+ parse_name (pages, num_pages,
+ MYDBM_DPTR (key), found, found_here);
+ if (am_apropos) {
+ char *whatis;
+
+ whatis = info->whatis ? xstrdup (info->whatis) : NULL;
+ if (!combine (num_pages, found_here) && whatis)
+ parse_whatis (pages, num_pages,
+ whatis, found, found_here);
+ free (whatis);
+ }
+ if (combine (num_pages, found_here))
+ display (dbf, info, MYDBM_DPTR (key));
+
+ if (tab)
+ *tab = '\t';
+nextpage:
+#pragma GCC diagnostic push
+#if GNUC_PREREQ(10,0)
+# pragma GCC diagnostic ignored "-Wanalyzer-double-free"
+#endif
+#ifndef BTREE
+ nextkey = MYDBM_NEXTKEY (dbf, key);
+ MYDBM_FREE_DPTR (cont);
+ MYDBM_FREE_DPTR (key);
+ key = nextkey;
+#else /* BTREE */
+ MYDBM_FREE_DPTR (cont);
+ MYDBM_FREE_DPTR (key);
+ end = man_btree_nextkeydata (dbf, &key, &cont);
+#endif /* !BTREE */
+#pragma GCC diagnostic pop
+ free_mandata_struct (info);
+ }
+
+ free (found_here);
+}
+
+/* loop through the man paths, searching for a match */
+static bool search (const char * const *pages, int num_pages)
+{
+ bool *found = XCALLOC (num_pages, bool);
+ char *mp;
+ bool any_found;
+ int i;
+
+ GL_LIST_FOREACH (manpathlist, mp) {
+ char *catpath, *database;
+ MYDBM_FILE dbf;
+
+ catpath = get_catpath (mp, SYSTEM_CAT | USER_CAT);
+ database = mkdbname (catpath ? catpath : mp);
+
+ debug ("path=%s\n", mp);
+
+ dbf = MYDBM_NEW (database);
+ if (!MYDBM_RDOPEN (dbf) || dbver_rd (dbf)) {
+ use_grep (pages, num_pages, mp, found);
+ goto next;
+ }
+
+ if (am_apropos)
+ do_apropos (dbf, pages, num_pages, found);
+ else {
+ if (regex_opt || wildcard)
+ do_apropos (dbf, pages, num_pages, found);
+ else
+ do_whatis (dbf, pages, num_pages, mp, found);
+ }
+
+next:
+ MYDBM_FREE (dbf);
+ free (database);
+ free (catpath);
+ }
+
+ any_found = false;
+ for (i = 0; i < num_pages; ++i) {
+ if (found[i])
+ any_found = true;
+ else
+ fprintf (stderr, _("%s: nothing appropriate.\n"),
+ pages[i]);
+ }
+
+ free (found);
+ return any_found;
+}
+
+int main (int argc, char *argv[])
+{
+ char *program_base_name;
+ int status = OK;
+
+ set_program_name (argv[0]);
+ program_base_name = base_name (program_name);
+ if (STREQ (program_base_name, APROPOS_NAME)) {
+ am_apropos = true;
+ argp_program_version = "apropos " PACKAGE_VERSION;
+ } else {
+ struct argp_option *optionp;
+ am_apropos = false;
+ argp_program_version = "whatis " PACKAGE_VERSION;
+ for (optionp = (struct argp_option *) whatis_argp.options;
+ optionp->name || optionp->key || optionp->arg ||
+ optionp->flags || optionp->doc || optionp->group;
+ ++optionp) {
+ if (!optionp->name)
+ continue;
+ if (STREQ (optionp->name, "exact") ||
+ STREQ (optionp->name, "and"))
+ optionp->flags |= OPTION_HIDDEN;
+ }
+ }
+ free (program_base_name);
+
+ init_debug ();
+ pipeline_install_post_fork (pop_all_cleanups);
+ sandbox = sandbox_init ();
+ init_locale ();
+
+ internal_locale = setlocale (LC_MESSAGES, NULL);
+ /* Use LANGUAGE only when LC_MESSAGES locale category is
+ * neither "C" nor "POSIX". */
+ if (internal_locale && strcmp (internal_locale, "C") &&
+ strcmp (internal_locale, "POSIX"))
+ multiple_locale = getenv ("LANGUAGE");
+ internal_locale = xstrdup (internal_locale ? internal_locale : "C");
+
+ if (argp_parse (am_apropos ? &apropos_argp : &whatis_argp, argc, argv,
+ 0, 0, 0))
+ exit (FAIL);
+
+ read_config_file (user_config_file != NULL);
+
+ /* close this locale and reinitialise if a new locale was
+ issued as an argument or in $MANOPT */
+ if (locale) {
+ free (internal_locale);
+ internal_locale = setlocale (LC_ALL, locale);
+ if (internal_locale)
+ internal_locale = xstrdup (internal_locale);
+ else
+ internal_locale = xstrdup (locale);
+
+ debug ("main(): locale = %s, internal_locale = %s\n",
+ locale, internal_locale);
+ if (internal_locale) {
+ setenv ("LANGUAGE", internal_locale, 1);
+ locale_changed ();
+ multiple_locale = NULL;
+ }
+ }
+
+ /* sort out the internal manpath */
+ if (manp == NULL)
+ manp = locale_manpath (get_manpath (alt_systems));
+ else
+ free (get_manpath (NULL));
+
+ manpathlist = create_pathlist (manp);
+
+ display_seen = new_string_set (GL_HASH_SET);
+
+ if (regex_opt) {
+ int i;
+ preg = XNMALLOC (num_keywords, regex_t);
+ for (i = 0; i < num_keywords; ++i)
+ xregcomp (&preg[i], keywords[i],
+ REG_EXTENDED | REG_NOSUB | REG_ICASE);
+ }
+
+ if (!search ((const char **) keywords, num_keywords))
+ status = NOT_FOUND;
+
+ if (regex_opt) {
+ int i;
+ for (i = 0; i < num_keywords; ++i)
+ regfree (&preg[i]);
+ free (preg);
+ }
+
+ gl_set_free (display_seen);
+ free_pathlist (manpathlist);
+ free (manp);
+ free (internal_locale);
+ sandbox_free (sandbox);
+ exit (status);
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-05-06 20:49:34 +0000