Adding upstream version 2.8.5.upstream/2.8.5upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1009 insertions, 0 deletions

diff --git a/src/whatis.c b/src/whatis.c
new file mode 100644
index 0000000..ee43f10
--- /dev/null
+++ b/src/whatis.c
@@ -0,0 +1,1009 @@
+/*
+ * 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 <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)
+
+#ifdef HAVE_ICONV
+#  include <iconv.h>
+#endif /* HAVE_ICONV */
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include "regex.h"
+
+#include "argp.h"
+#include "dirname.h"
+#include "fnmatch.h"
+#include "progname.h"
+#include "xvasprintf.h"
+
+#include "manconfig.h"
+
+#include "cleanup.h"
+#include "error.h"
+#include "pipeline.h"
+#include "pathsearch.h"
+#include "linelength.h"
+#include "hashtable.h"
+#include "lower.h"
+#include "wordfnmatch.h"
+#include "xregcomp.h"
+#include "encodings.h"
+#include "sandbox.h"
+
+#include "mydbm.h"
+#include "db_storage.h"
+
+#include "manp.h"
+
+static char *manpathlist[MAXDIRS];
+
+extern char *user_config_file;
+static char **keywords;
+static int num_keywords;
+
+int am_apropos;
+char *database;
+int quiet = 1;
+man_sandbox *sandbox;
+
+#ifdef HAVE_ICONV
+iconv_t conv_to_locale;
+#endif /* HAVE_ICONV */
+
+static regex_t *preg;  
+static int regex_opt;
+static int exact;
+
+static int wildcard;
+
+static int require_all;
+
+static int 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 struct hashtable *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[] = {
+	{ "debug",		'd',	0,		0,	N_("emit debugging messages") },
+	{ "verbose",		'v',	0,		0,	N_("print verbose warning messages") },
+	{ "regex",		'r',	0,		0,	N_("interpret each keyword as a regex"),	10 },
+	{ "exact",		'e',	0,		0,	N_("search each keyword for exact match") }, /* apropos only */
+	{ "wildcard",		'w',	0,		0,	N_("the keyword(s) contain wildcards") },
+	{ "and",		'a',	0,		0,	N_("require all keywords to match"),			20 }, /* apropos only */
+	{ "long",		'l',	0,		0,	N_("do not trim output to terminal width"),		30 },
+	{ "sections",		's',	N_("LIST"),	0,	N_("search only these sections (colon-separated)"),	40 },
+	{ "section",		0,	0,		OPTION_ALIAS },
+	{ "systems",		'm',	N_("SYSTEM"),	0,	N_("use manual pages from other systems") },
+	{ "manpath",		'M',	N_("PATH"),	0,	N_("set search path for manual pages to PATH") },
+	{ "locale",		'L',	N_("LOCALE"),	0,	N_("define the locale for this search") },
+	{ "config-file",	'C',	N_("FILE"),	0,	N_("use this user configuration file") },
+	{ "whatis",		'f',	0,		OPTION_HIDDEN,	0 },
+	{ "apropos",		'k',	0,		OPTION_HIDDEN,	0 },
+	{ 0, 'h', 0, OPTION_HIDDEN, 0 }, /* compatibility for --help */
+	{ 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 = 1;
+			return 0;
+		case 'v':
+			quiet = 0;
+			return 0;
+		case 'r':
+			regex_opt = 1;
+			return 0;
+		case 'e':
+			/* Only makes sense for apropos, but has
+			 * historically been accepted by whatis anyway.
+			 */
+			regex_opt = 0;
+			exact = 1;
+			return 0;
+		case 'w':
+			regex_opt = 0;
+			wildcard = 1;
+			return 0;
+		case 'a':
+			if (am_apropos)
+				require_all = 1;
+			else
+				argp_usage (state);
+			return 0;
+		case 'l':
+			long_output = 1;
+			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 = 0;
+			return 0;
+		case 'k':
+			/* helpful override if program name detection fails */
+			am_apropos = 1;
+			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 = 1;
+			return 0;
+	}
+	return ARGP_ERR_UNKNOWN;
+}
+
+static char *help_filter (int key, const char *text,
+			  void *input ATTRIBUTE_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;
+}
+
+#ifdef HAVE_ICONV
+static char *simple_convert (iconv_t conv, char *string)
+{
+	if (conv != (iconv_t) -1) {
+		size_t string_conv_alloc = strlen (string) + 1;
+		char *string_conv = xmalloc (string_conv_alloc);
+		for (;;) {
+			char *inptr = string, *outptr = string_conv;
+			size_t inleft = strlen (string);
+			size_t outleft = string_conv_alloc - 1;
+			if (iconv (conv, (ICONV_CONST char **) &inptr, &inleft,
+				   &outptr, &outleft) == (size_t) -1 &&
+			    errno == E2BIG) {
+				string_conv_alloc <<= 1;
+				string_conv = xrealloc (string_conv,
+							string_conv_alloc);
+			} else {
+				/* Either we succeeded, or we've done our
+				 * best; go ahead and print what we've got.
+				 */
+				string_conv[string_conv_alloc - 1 - outleft] =
+					'\0';
+				break;
+			}
+		}
+		return string_conv;
+	} else
+		return xstrdup (string);
+}
+#else /* !HAVE_ICONV */
+#  define simple_convert(conv, string) xstrdup (string)
+#endif /* HAVE_ICONV */
+
+/* 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,
+		      int *found)
+{
+	char *whatis_file = xasprintf ("%s/whatis", manpath);
+
+	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",
+								     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] = 1;
+
+			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, 1);
+	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, 1);
+		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 (hashtable_lookup_structure (display_seen, key, strlen (key)))
+		goto out;
+	hashtable_install (display_seen, key, strlen (key), NULL);
+
+	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 = simple_convert (conv_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)
+{
+	struct mandata *info;
+	int count = 0;
+
+	info = dblookup_all (dbf, page, section, 0);
+	while (info) {
+		struct mandata *pinfo;
+			
+		display (dbf, info, page);
+		count++;
+		pinfo = info->next;	/* go on to next structure */
+		free_mandata_elements (info);
+	 	free (info);
+		info = pinfo;
+	}
+	return count;
+}
+
+static int suitable_manpath (const char *manpath, const char *page_dir)
+{
+	char *page_manp, *pm;
+	char *page_manpathlist[MAXDIRS], **mp;
+	int ret;
+
+	page_manp = get_manpath_from_path (page_dir, 0);
+	if (!page_manp || !*page_manp) {
+		free (page_manp);
+		return 0;
+	}
+	pm = locale_manpath (page_manp);
+	free (page_manp);
+	page_manp = pm;
+	create_pathlist (page_manp, page_manpathlist);
+
+	ret = 0;
+	for (mp = page_manpathlist; *mp; ++mp) {
+		if (STREQ (*mp, manpath)) {
+			ret = 1;
+			break;
+		}
+	}
+
+	for (mp = page_manpathlist; *mp; ++mp)
+		free (*mp);
+	free (page_manp);
+	return ret;
+}
+
+static void do_whatis (MYDBM_FILE dbf,
+		       const char * const *pages, int num_pages,
+		       const char *manpath, int *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] = 1;
+			}
+		} else {
+			if (do_whatis_section (dbf, page, NULL))
+				found[i] = 1;
+		}
+
+		free (page);
+	}
+}
+
+static int any_set (int num_pages, int *found_here)
+{
+	int i;
+
+	for (i = 0; i < num_pages; ++i)
+		if (found_here[i])
+			return 1;
+	return 0;
+}
+
+static int all_set (int num_pages, int *found_here)
+{
+	int i;
+
+	for (i = 0; i < num_pages; ++i)
+		if (!found_here[i])
+			return 0;
+	return 1;
+}
+
+static void parse_name (const char * const *pages, int num_pages,
+			const char *dbname, int *found, int *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] = 1;
+		}
+		return;
+	}
+
+	if (am_apropos && !wildcard) {
+		char *lowdbname = lower (dbname);
+
+		for (i = 0; i < num_pages; ++i) {
+			if (STREQ (lowdbname, pages[i]))
+				found[i] = found_here[i] = 1;
+		}
+		free (lowdbname);
+		return;
+	}
+
+	for (i = 0; i < num_pages; ++i) {
+		if (fnmatch (pages[i], dbname, 0) == 0)
+			found[i] = found_here[i] = 1;
+	}
+}
+
+/* return 1 on word match */
+static int match (const char *lowpage, const char *whatis)
+{
+	char *lowwhatis = lower (whatis);
+	size_t len = strlen (lowpage);
+	char *p, *begin;
+
+	begin = lowwhatis;
+	
+	/* check for string match, then see if it is a _word_ */
+	while (lowwhatis && (p = strstr (lowwhatis, lowpage))) {
+		char *left = p - 1; 
+		char *right = p + len;
+
+		if ((p == begin || (!CTYPE (islower, *left) && *left != '_')) &&
+		    (!*right || (!CTYPE (islower, *right) && *right != '_'))) {
+		    	free (begin);
+		    	return 1;
+		}
+		lowwhatis = p + 1;
+	}
+
+	free (begin);
+	return 0;
+}
+
+static void parse_whatis (const char * const *pages, char * const *lowpages,
+			  int num_pages, const char *whatis,
+			  int *found, int *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] = 1;
+		}
+		return;
+	}
+
+	if (wildcard) {
+		for (i = 0; i < num_pages; ++i) {
+			if (exact) {
+				if (fnmatch (pages[i], whatis, 0) == 0)
+					found[i] = found_here[i] = 1;
+			} else {
+				if (word_fnmatch (pages[i], whatis))
+					found[i] = found_here[i] = 1;
+			}
+		}
+		return;
+	}
+
+	for (i = 0; i < num_pages; ++i) {
+		if (match (lowpages[i], whatis))
+			found[i] = found_here[i] = 1;
+	}
+}
+
+/* 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, int *found)
+{
+	datum key, cont;
+	char **lowpages;
+	int *found_here;
+	int (*combine) (int, int *);
+	int i;
+#ifndef BTREE
+	datum nextkey;
+#else /* BTREE */
+	int end;
+#endif /* !BTREE */
+
+	lowpages = XNMALLOC (num_pages, char *);
+	for (i = 0; i < num_pages; ++i) {
+		lowpages[i] = lower (pages[i]);
+		debug ("lower(%s) = \"%s\"\n", pages[i], lowpages[i]);
+	}
+	found_here = XNMALLOC (num_pages, int);
+	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 = btree_nextkeydata (dbf, &key, &cont);
+	while (!end) {
+#endif /* !BTREE */
+		char *tab;
+		struct mandata info;
+
+		memset (&info, 0, sizeof (info));
+
+		/* 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));
+			error (FATAL, 0,
+			       _("Database %s corrupted; rebuild with "
+				 "mandb --create"),
+			       database);
+		}
+
+		if (*MYDBM_DPTR (key) == '$')
+			goto nextpage;
+
+		if (*MYDBM_DPTR (cont) == '\t')
+			goto nextpage;
+
+		/* a real page */
+
+		split_content (MYDBM_DPTR (cont), &info);
+
+		/* If there are sections given, does any of them match
+		 * either the section or extension of this page?
+		 */
+		if (sections) {
+			char * const *section;
+			int matched = 0;
+
+			for (section = sections; *section; ++section) {
+				if (STREQ (*section, info.sec) ||
+				    STREQ (*section, info.ext)) {
+					matched = 1;
+					break;
+				}
+			}
+
+			if (!matched)
+				goto nextpage;
+		}
+
+		tab = strrchr (MYDBM_DPTR (key), '\t');
+		if (tab) 
+			 *tab = '\0';
+
+		memset (found_here, 0, num_pages * sizeof (*found_here));
+		if (am_apropos) {
+			char *whatis;
+
+			parse_name ((const char **) lowpages, num_pages,
+				    MYDBM_DPTR (key), found, found_here);
+			whatis = info.whatis ? xstrdup (info.whatis) : NULL;
+			if (!combine (num_pages, found_here) && whatis)
+				parse_whatis (pages, lowpages, num_pages,
+					      whatis, found, found_here);
+			free (whatis);
+		} else
+			parse_name (pages, num_pages,
+				    MYDBM_DPTR (key), found, found_here);
+		if (combine (num_pages, found_here))
+			display (dbf, &info, MYDBM_DPTR (key));
+
+		if (tab)
+			*tab = '\t';
+nextpage:
+#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 = btree_nextkeydata (dbf, &key, &cont);
+#endif /* !BTREE */
+		info.addr = NULL; /* == MYDBM_DPTR (cont), freed above */
+		free_mandata_elements (&info);
+	}
+
+	free (found_here);
+
+	for (i = 0; i < num_pages; ++i)
+		free (lowpages[i]);
+	free (lowpages);
+}
+
+/* loop through the man paths, searching for a match */
+static int search (const char * const *pages, int num_pages)
+{
+	int *found = XCALLOC (num_pages, int);
+	char *catpath, **mp;
+	int any_found, i;
+
+	for (mp = manpathlist; *mp; mp++) {
+		MYDBM_FILE dbf;
+
+		catpath = get_catpath (*mp, SYSTEM_CAT | USER_CAT);
+		
+		if (catpath) {
+			database = mkdbname (catpath);
+			free (catpath);
+		} else
+			database = mkdbname (*mp);
+
+		debug ("path=%s\n", *mp);
+
+		dbf = MYDBM_RDOPEN (database);
+		if (dbf && dbver_rd (dbf)) {
+			MYDBM_CLOSE (dbf);
+			dbf = NULL;
+		}
+		if (!dbf) {
+			use_grep (pages, num_pages, *mp, found);
+			continue;
+		}
+
+		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);
+		}
+		free (database);
+		database = NULL;
+		MYDBM_CLOSE (dbf);
+	}
+
+	chkr_garbage_detector ();
+
+	any_found = 0;
+	for (i = 0; i < num_pages; ++i) {
+		if (found[i])
+			any_found = 1;
+		else
+			fprintf (stderr, _("%s: nothing appropriate.\n"),
+				 pages[i]);
+	}
+
+	free (found);
+	return any_found;
+}
+
+int main (int argc, char *argv[])
+{
+	char *program_base_name;
+#ifdef HAVE_ICONV
+	char *locale_charset;
+#endif
+	int status = OK;
+
+	set_program_name (argv[0]);
+	program_base_name = base_name (program_name);
+	if (STREQ (program_base_name, APROPOS_NAME)) {
+		am_apropos = 1;
+		argp_program_version = "apropos " PACKAGE_VERSION;
+	} else {
+		struct argp_option *optionp;
+		am_apropos = 0;
+		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));
+
+	create_pathlist (manp, manpathlist);
+
+	display_seen = hashtable_create (&null_hashtable_free);
+
+#ifdef HAVE_ICONV
+	locale_charset = xasprintf ("%s//IGNORE", get_locale_charset ());
+	conv_to_locale = iconv_open (locale_charset, "UTF-8");
+	free (locale_charset);
+#endif /* HAVE_ICONV */
+
+	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);
+	}
+
+#ifdef HAVE_ICONV
+	if (conv_to_locale != (iconv_t) -1)
+		iconv_close (conv_to_locale);
+#endif /* HAVE_ICONV */
+	hashtable_free (display_seen);
+	free_pathlist (manpathlist);
+	free (manp);
+	free (internal_locale);
+	exit (status);
+}