summaryrefslogtreecommitdiffstats
path: root/src/mandb.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/mandb.c')
-rw-r--r--src/mandb.c1034
1 files changed, 1034 insertions, 0 deletions
diff --git a/src/mandb.c b/src/mandb.c
new file mode 100644
index 0000000..07ea923
--- /dev/null
+++ b/src/mandb.c
@@ -0,0 +1,1034 @@
+/*
+ * mandb.c: used to create and initialise global man database.
+ *
+ * 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
+ *
+ * Tue Apr 26 12:56:44 BST 1994 Wilf. (G.Wilford@ee.surrey.ac.uk)
+ *
+ * CJW: Security fixes. Make --test work. Purge old database entries.
+ */
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif /* HAVE_CONFIG_H */
+
+#include <stdbool.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <assert.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/stat.h> /* for chmod() */
+#include <dirent.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <signal.h>
+
+#ifdef MAN_OWNER
+# include <pwd.h>
+#endif /* MAN_OWNER */
+
+#include "argp.h"
+#include "dirname.h"
+#include "error.h"
+#include "gl_hash_map.h"
+#include "gl_list.h"
+#include "gl_xmap.h"
+#include "progname.h"
+#include "stat-time.h"
+#include "timespec.h"
+#include "utimens.h"
+#include "xalloc.h"
+#include "xgetcwd.h"
+#include "xvasprintf.h"
+
+#include "gettext.h"
+#define _(String) gettext (String)
+#define N_(String) gettext_noop (String)
+
+#include "manconfig.h"
+
+#include "cleanup.h"
+#include "debug.h"
+#include "filenames.h"
+#include "glcontainers.h"
+#include "pipeline.h"
+#include "sandbox.h"
+#include "security.h"
+#include "util.h"
+
+#include "db_storage.h"
+#include "mydbm.h"
+
+#include "check_mandirs.h"
+#include "manp.h"
+#include "straycats.h"
+
+int quiet = 1;
+extern bool opt_test; /* don't update db */
+char *manp;
+extern char *extension; /* for globbing.c */
+extern bool force_rescan; /* for check_mandirs.c */
+static char *single_filename = NULL;
+extern char *user_config_file; /* for manp.c */
+#ifdef MAN_OWNER
+struct passwd *man_owner;
+#endif
+man_sandbox *sandbox;
+
+static int purged = 0;
+static int strays = 0;
+
+static bool check_for_strays = true;
+static bool purge = true;
+static bool user;
+static bool create;
+static const char *arg_manp;
+
+struct tried_catdirs_entry {
+ char *manpath;
+ bool seen;
+};
+
+const char *argp_program_version = "mandb " PACKAGE_VERSION;
+const char *argp_program_bug_address = PACKAGE_BUGREPORT;
+error_t argp_err_exit_status = FAIL;
+
+static const char args_doc[] = N_("[MANPATH]");
+
+static struct argp_option options[] = {
+ OPT ("debug", 'd', 0, N_("emit debugging messages")),
+ OPT ("quiet", 'q', 0, N_("work quietly, except for 'bogus' warning")),
+ OPT ("no-straycats", 's', 0,
+ N_("don't look for or add stray cats to the dbs")),
+ OPT ("no-purge", 'p', 0,
+ N_("don't purge obsolete entries from the dbs")),
+ OPT ("user-db", 'u', 0, N_("produce user databases only")),
+ OPT ("create", 'c', 0,
+ N_("create dbs from scratch, rather than updating")),
+ OPT ("test", 't', 0, N_("check manual pages for correctness")),
+ OPT ("filename", 'f', N_("FILENAME"),
+ N_("update just the entry for this filename")),
+ OPT ("config-file", 'C', N_("FILE"),
+ N_("use this user configuration file")),
+ OPT_HELP_COMPAT,
+ { 0 }
+};
+
+static error_t parse_opt (int key, char *arg, struct argp_state *state)
+{
+ static int quiet_temp = 0;
+
+ switch (key) {
+ case 'd':
+ debug_level = true;
+ return 0;
+ case 'q':
+ ++quiet_temp;
+ return 0;
+ case 's':
+ check_for_strays = false;
+ return 0;
+ case 'p':
+ purge = false;
+ return 0;
+ case 'u':
+ user = true;
+ return 0;
+ case 'c':
+ create = true;
+ purge = false;
+ return 0;
+ case 't':
+ opt_test = true;
+ return 0;
+ case 'f':
+ single_filename = arg;
+ create = false;
+ purge = false;
+ check_for_strays = false;
+ return 0;
+ case 'C':
+ user_config_file = arg;
+ return 0;
+ case 'h':
+ argp_state_help (state, state->out_stream,
+ ARGP_HELP_STD_HELP);
+ break;
+ case ARGP_KEY_ARG:
+ if (arg_manp)
+ argp_usage (state);
+ arg_manp = arg;
+ return 0;
+ case ARGP_KEY_SUCCESS:
+ if (opt_test && !debug_level)
+ quiet = 1;
+ else if (quiet_temp == 1)
+ quiet = 2;
+ else
+ quiet = quiet_temp;
+ return 0;
+ }
+ return ARGP_ERR_UNKNOWN;
+}
+
+static struct argp argp = { options, parse_opt, args_doc };
+
+struct dbpaths {
+#ifdef NDBM
+# ifdef BERKELEY_DB
+ char *dbfile;
+ char *tmpdbfile;
+# else /* !BERKELEY_DB NDBM */
+ char *dirfile;
+ char *pagfile;
+ char *tmpdirfile;
+ char *tmppagfile;
+# endif /* BERKELEY_DB */
+#else /* !NDBM */
+ char *xfile;
+ char *xtmpfile;
+#endif /* NDBM */
+};
+
+#ifdef MAN_OWNER
+extern uid_t ruid;
+extern uid_t euid;
+#endif /* MAN_OWNER */
+
+static gl_list_t manpathlist;
+
+extern int pages;
+
+/* remove() with error checking */
+static void check_remove (const char *path)
+{
+ if (remove (path) == -1 && errno != ENOENT)
+ error (0, errno, _("can't remove %s"), path);
+}
+
+/* rename() with error checking */
+static void check_rename (const char *from, const char *to)
+{
+ if (rename (from, to) == -1 && errno != ENOENT) {
+ error (0, errno, _("can't rename %s to %s"), from, to);
+ check_remove (from);
+ }
+}
+
+/* chmod() with error checking */
+static void check_chmod (const char *path, mode_t mode)
+{
+ if (chmod (path, mode) == -1) {
+ error (0, errno, _("can't chmod %s"), path);
+ check_remove (path);
+ }
+}
+
+/* CPhipps 2000/02/24 - Copy a file. */
+static int xcopy (const char *from, const char *to)
+{
+ FILE *ifp, *ofp;
+ struct stat st;
+ struct timespec times[2];
+ static const size_t buf_size = 32 * 1024;
+ char *buf;
+ int ret = 0;
+
+ ifp = fopen (from, "r");
+ if (!ifp) {
+ ret = -errno;
+ if (errno == ENOENT)
+ return 0;
+ error (0, errno, "fopen %s", from);
+ return ret;
+ }
+
+ if (fstat (fileno (ifp), &st) >= 0) {
+ times[0] = get_stat_atime (&st);
+ times[1] = get_stat_mtime (&st);
+ } else {
+ times[0].tv_sec = 0;
+ times[0].tv_nsec = UTIME_OMIT;
+ times[1].tv_sec = 0;
+ times[1].tv_nsec = UTIME_OMIT;
+ }
+
+ ofp = fopen (to, "w");
+ if (!ofp) {
+ ret = -errno;
+ error (0, errno, "fopen %s", to);
+ fclose (ifp);
+ return ret;
+ }
+
+ buf = xmalloc (buf_size);
+ while (!feof (ifp) && !ferror (ifp)) {
+ size_t in = fread (buf, 1, buf_size, ifp);
+ if (in > 0) {
+ if (fwrite (buf, 1, in, ofp) == 0 && ferror (ofp)) {
+ ret = -errno;
+ error (0, errno, _("can't write to %s"), to);
+ break;
+ }
+ } else if (ferror (ifp)) {
+ ret = -errno;
+ error (0, errno, _("can't read from %s"), from);
+ break;
+ }
+ }
+ free (buf);
+
+ fclose (ifp);
+ fclose (ofp);
+
+ if (ret < 0)
+ check_remove (to);
+ else {
+ check_chmod (to, DBMODE);
+ utimens (to, times);
+ }
+
+ return ret;
+}
+
+static void dbpaths_init (struct dbpaths *dbpaths,
+ const char *base, const char *tmpbase)
+{
+#ifdef NDBM
+# ifdef BERKELEY_DB
+ dbpaths->dbfile = xasprintf ("%s.db", base);
+ dbpaths->tmpdbfile = xasprintf ("%s.db", tmpbase);
+# else /* !BERKELEY_DB NDBM */
+ dbpaths->dirfile = xasprintf ("%s.dir", base);
+ dbpaths->pagfile = xasprintf ("%s.pag", base);
+ dbpaths->tmpdirfile = xasprintf ("%s.dir", tmpbase);
+ dbpaths->tmppagfile = xasprintf ("%s.pag", tmpbase);
+# endif /* BERKELEY_DB NDBM */
+#else /* !NDBM */
+ dbpaths->xfile = xstrdup (base);
+ dbpaths->xtmpfile = xstrdup (tmpbase);
+#endif /* NDBM */
+}
+
+static int dbpaths_copy_to_tmp (struct dbpaths *dbpaths)
+{
+#ifdef NDBM
+# ifdef BERKELEY_DB
+ return xcopy (dbpaths->dbfile, dbpaths->tmpdbfile);
+# else /* !BERKELEY_DB NDBM */
+ int ret = xcopy (dbpaths->dirfile, dbpaths->tmpdirfile);
+ if (ret < 0)
+ return ret;
+ return xcopy (dbpaths->pagfile, dbpaths->tmppagfile);
+# endif /* BERKELEY_DB NDBM */
+#else /* !NDBM */
+ return xcopy (dbpaths->xfile, dbpaths->xtmpfile);
+#endif /* NDBM */
+}
+
+static void dbpaths_remove_tmp (struct dbpaths *dbpaths)
+{
+#ifdef NDBM
+# ifdef BERKELEY_DB
+ check_remove (dbpaths->tmpdbfile);
+# else /* !BERKELEY_DB NDBM */
+ check_remove (dbpaths->tmpdirfile);
+ check_remove (dbpaths->tmppagfile);
+# endif /* BERKELEY_DB NDBM */
+#else /* !NDBM */
+ check_remove (dbpaths->xtmpfile);
+#endif /* NDBM */
+}
+
+static void dbpaths_rename_from_tmp (struct dbpaths *dbpaths)
+{
+#ifdef NDBM
+# ifdef BERKELEY_DB
+ check_rename (dbpaths->tmpdbfile, dbpaths->dbfile);
+ check_chmod (dbpaths->dbfile, DBMODE);
+ free (dbpaths->tmpdbfile);
+ dbpaths->tmpdbfile = NULL;
+# else /* not BERKELEY_DB */
+ check_rename (dbpaths->tmpdirfile, dbpaths->dirfile);
+ check_chmod (dbpaths->dirfile, DBMODE);
+ check_rename (dbpaths->tmppagfile, dbpaths->pagfile);
+ check_chmod (dbpaths->pagfile, DBMODE);
+ free (dbpaths->tmpdirfile);
+ free (dbpaths->tmppagfile);
+ dbpaths->tmpdirfile = dbpaths->tmppagfile = NULL;
+# endif /* BERKELEY_DB */
+#else /* not NDBM */
+ check_rename (dbpaths->xtmpfile, dbpaths->xfile);
+ check_chmod (dbpaths->xfile, DBMODE);
+ free (dbpaths->xtmpfile);
+ dbpaths->xtmpfile = NULL;
+#endif /* NDBM */
+}
+
+#ifdef MAN_OWNER
+/* Change the owner of global man databases. */
+static void dbpaths_chown_if_possible (struct dbpaths *dbpaths)
+{
+# ifdef NDBM
+# ifdef BERKELEY_DB
+ chown_if_possible (dbpaths->dbfile);
+# else /* not BERKELEY_DB */
+ chown_if_possible (dbpaths->dirfile);
+ chown_if_possible (dbpaths->pagfile);
+# endif /* BERKELEY_DB */
+# else /* not NDBM */
+ chown_if_possible (dbpaths->xfile);
+# endif /* NDBM */
+}
+#endif /* MAN_OWNER */
+
+/* Remove incomplete databases. This is async-signal-safe. */
+static void dbpaths_unlink_tmp (struct dbpaths *dbpaths)
+{
+#ifdef NDBM
+# ifdef BERKELEY_DB
+ if (dbpaths->tmpdbfile)
+ unlink (dbpaths->tmpdbfile);
+# else /* !BERKELEY_DB NDBM */
+ if (dbpaths->tmpdirfile)
+ unlink (dbpaths->tmpdirfile);
+ if (dbpaths->tmppagfile)
+ unlink (dbpaths->tmppagfile);
+# endif /* BERKELEY_DB NDBM */
+#else /* !NDBM */
+ if (dbpaths->xtmpfile)
+ unlink (dbpaths->xtmpfile);
+#endif /* NDBM */
+}
+
+static void dbpaths_free_elements (struct dbpaths *dbpaths)
+{
+#ifdef NDBM
+# ifdef BERKELEY_DB
+ free (dbpaths->dbfile);
+ free (dbpaths->tmpdbfile);
+ dbpaths->dbfile = dbpaths->tmpdbfile = NULL;
+# else /* !BERKELEY_DB NDBM */
+ free (dbpaths->dirfile);
+ free (dbpaths->pagfile);
+ free (dbpaths->tmpdirfile);
+ free (dbpaths->tmppagfile);
+ dbpaths->dirfile = dbpaths->pagfile = NULL;
+ dbpaths->tmpdirfile = dbpaths->tmppagfile = NULL;
+# endif /* BERKELEY_DB NDBM */
+#else /* !NDBM */
+ free (dbpaths->xfile);
+ free (dbpaths->xtmpfile);
+ dbpaths->xfile = dbpaths->xtmpfile = NULL;
+#endif /* NDBM */
+}
+
+/* Reorganize a database by reading in all the items (assuming that the
+ * database layer provides them in sorted order) and writing them back out.
+ * This has the effect of giving the underlying database the best chance to
+ * produce deterministic output files based only on the set of items and not
+ * on their insertion order, although we may not be able to guarantee that
+ * for all database types.
+ */
+static void reorganize (const char *catpath, bool global_manpath MAYBE_UNUSED)
+{
+ char *dbname, *tmpdbname;
+ struct dbpaths *dbpaths;
+ MYDBM_FILE dbf, tmpdbf;
+ datum key;
+
+ dbname = mkdbname (catpath);
+ tmpdbname = xasprintf ("%s/%d", catpath, getpid ());
+ dbpaths = XZALLOC (struct dbpaths);
+ dbpaths_init (dbpaths, dbname, tmpdbname);
+ dbf = MYDBM_NEW (dbname);
+ tmpdbf = MYDBM_NEW (tmpdbname);
+ if (!MYDBM_RDOPEN (dbf) || dbver_rd (dbf)) {
+ debug ("Failed to open %s read-only\n", dbname);
+ goto out;
+ }
+ if (!MYDBM_CTRWOPEN (tmpdbf)) {
+ debug ("Failed to create %s\n", tmpdbname);
+ goto out;
+ }
+
+ key = MYDBM_FIRSTKEY (dbf);
+ while (MYDBM_DPTR (key)) {
+ datum content, nextkey;
+ int insert_status;
+
+ content = MYDBM_FETCH (dbf, key);
+ insert_status = MYDBM_INSERT (tmpdbf, key, content);
+ MYDBM_FREE_DPTR (content);
+ if (insert_status != 0) {
+ MYDBM_FREE_DPTR (key);
+ goto out;
+ }
+ nextkey = MYDBM_NEXTKEY (dbf, key);
+ MYDBM_FREE_DPTR (key);
+ key = nextkey;
+ }
+
+ dbpaths_rename_from_tmp (dbpaths);
+#ifdef MAN_OWNER
+ if (global_manpath)
+ dbpaths_chown_if_possible (dbpaths);
+#endif /* MAN_OWNER */
+
+out:
+ MYDBM_FREE (tmpdbf);
+ MYDBM_FREE (dbf);
+ dbpaths_unlink_tmp (dbpaths);
+ dbpaths_free_elements (dbpaths);
+ free (dbpaths);
+ free (tmpdbname);
+ free (dbname);
+}
+
+/* Update a single file in an existing database. */
+static int update_one_file (MYDBM_FILE dbf,
+ const char *manpath, const char *filename)
+{
+ if (dbf->file || MYDBM_RWOPEN (dbf)) {
+ struct mandata *info;
+
+ info = filename_info (filename, quiet < 2);
+ if (info) {
+ dbdelete (dbf, info->name, info);
+ purge_pointers (dbf, info->name);
+ }
+ free_mandata_struct (info);
+
+ test_manfile (dbf, filename, manpath);
+ }
+
+ return 1;
+}
+
+/* dont actually create any dbs, just do an update */
+static int update_db_wrapper (MYDBM_FILE dbf,
+ const char *manpath, const char *catpath)
+{
+ int amount;
+
+ if (single_filename)
+ return update_one_file (dbf, manpath, single_filename);
+
+ amount = update_db (dbf, manpath, catpath);
+ if (amount >= 0)
+ return amount;
+
+ return create_db (dbf, manpath, catpath);
+}
+
+#define CACHEDIR_TAG \
+ "Signature: 8a477f597d28d172789f06886806bc55\n" \
+ "# This file is a cache directory tag created by man-db.\n" \
+ "# For information about cache directory tags, see:\n" \
+ "#\thttp://www.brynosaurus.com/cachedir/\n"
+
+/* sort out the database names */
+static int mandb (struct dbpaths *dbpaths,
+ const char *catpath, const char *manpath,
+ bool global_manpath)
+{
+ char *database;
+ int amount;
+ char *dbname;
+ MYDBM_FILE dbf;
+ bool should_create;
+
+ dbname = mkdbname (catpath);
+ database = xasprintf ("%s/%d", catpath, getpid ());
+ dbf = MYDBM_NEW (database);
+
+ if (!STREQ (catpath, manpath)) {
+ char *cachedir_tag;
+ int fd;
+ bool cachedir_tag_exists = false;
+
+ cachedir_tag = xasprintf ("%s/CACHEDIR.TAG", catpath);
+ assert (cachedir_tag);
+ fd = open (cachedir_tag, O_RDONLY);
+ if (fd < 0) {
+ FILE *cachedir_tag_file;
+
+ if (errno != ENOENT)
+ check_remove (cachedir_tag);
+ cachedir_tag_file = fopen (cachedir_tag, "w");
+ if (cachedir_tag_file) {
+ cachedir_tag_exists = true;
+ fputs (CACHEDIR_TAG, cachedir_tag_file);
+ fclose (cachedir_tag_file);
+ }
+ } else {
+ cachedir_tag_exists = true;
+ close (fd);
+ }
+ if (cachedir_tag_exists) {
+ if (global_manpath)
+ chown_if_possible (cachedir_tag);
+ check_chmod (cachedir_tag, DBMODE);
+ }
+ free (cachedir_tag);
+ }
+
+ should_create = (create || opt_test);
+
+ dbpaths_init (dbpaths, dbname, database);
+ if (!should_create && dbpaths_copy_to_tmp (dbpaths) < 0)
+ should_create = true;
+ if (should_create)
+ dbpaths_remove_tmp (dbpaths);
+
+ if (!should_create) {
+ force_rescan = false;
+ if (purge)
+ purged += purge_missing (dbf, manpath, catpath);
+
+ if (force_rescan) {
+ /* We have an existing database and hadn't been
+ * going to recreate it, but purge_missing has
+ * discovered some kind of consistency problem and
+ * requested that we do so anyway. Close the
+ * database and remove temporary copies so that we
+ * start from scratch.
+ */
+ MYDBM_FREE (dbf);
+ dbpaths_remove_tmp (dbpaths);
+ dbf = MYDBM_NEW (database);
+ should_create = true;
+ }
+ }
+
+ if (!quiet)
+ printf (_("Processing manual pages under %s...\n"), manpath);
+
+ if (should_create)
+ amount = create_db (dbf, manpath, catpath);
+ else
+ amount = update_db_wrapper (dbf, manpath, catpath);
+
+ if (check_for_strays && dbf->file)
+ strays += straycats (dbf, manpath);
+
+ MYDBM_FREE (dbf);
+ free (database);
+ free (dbname);
+ return amount;
+}
+
+static int process_manpath (const char *manpath, bool global_manpath,
+ gl_map_t tried_catdirs)
+{
+ char *catpath;
+ struct tried_catdirs_entry *tried;
+ struct stat st;
+ bool run_mandb = false;
+ struct dbpaths *dbpaths = NULL;
+ int amount = 0;
+ bool new_purged = false;
+ bool new_strays = false;
+
+ if (global_manpath) { /* system db */
+ catpath = get_catpath (manpath, SYSTEM_CAT);
+ assert (catpath);
+ } else { /* user db */
+ catpath = get_catpath (manpath, USER_CAT);
+ if (!catpath)
+ catpath = xstrdup (manpath);
+ }
+ tried = XMALLOC (struct tried_catdirs_entry);
+ tried->manpath = xstrdup (manpath);
+ tried->seen = false;
+ gl_map_put (tried_catdirs, xstrdup (catpath), tried);
+
+ if (stat (manpath, &st) < 0 || !S_ISDIR (st.st_mode))
+ goto out;
+ tried->seen = true;
+
+ if (single_filename) {
+ /* The file might be in a per-locale subdirectory that we
+ * aren't processing right now.
+ */
+ char *manpath_prefix = xasprintf ("%s/man", manpath);
+ if (STRNEQ (manpath_prefix, single_filename,
+ strlen (manpath_prefix)))
+ run_mandb = true;
+ free (manpath_prefix);
+ } else
+ run_mandb = true;
+
+ dbpaths = XZALLOC (struct dbpaths);
+ push_cleanup ((cleanup_fun) dbpaths_free_elements, dbpaths, 0);
+ push_cleanup ((cleanup_fun) dbpaths_unlink_tmp, dbpaths, 1);
+ if (run_mandb) {
+ int purged_before = purged;
+ int strays_before = strays;
+ int ret = mandb (dbpaths, catpath, manpath, global_manpath);
+ if (ret < 0) {
+ amount = ret;
+ goto out;
+ }
+ amount += ret;
+ new_purged = purged != purged_before;
+ new_strays = strays != strays_before;
+
+ if (!opt_test && (amount || new_purged || new_strays)) {
+ dbpaths_rename_from_tmp (dbpaths);
+#ifdef MAN_OWNER
+ if (global_manpath)
+ dbpaths_chown_if_possible (dbpaths);
+#endif /* MAN_OWNER */
+ reorganize (catpath, global_manpath);
+ }
+ }
+
+out:
+ if (dbpaths) {
+ dbpaths_unlink_tmp (dbpaths);
+ pop_cleanup ((cleanup_fun) dbpaths_unlink_tmp, dbpaths);
+ dbpaths_free_elements (dbpaths);
+ pop_cleanup ((cleanup_fun) dbpaths_free_elements, dbpaths);
+ free (dbpaths);
+ }
+
+ free (catpath);
+
+ return amount;
+}
+
+static bool is_lang_dir (const char *base)
+{
+ return strlen (base) >= 2 &&
+ base[0] >= 'a' && base[0] <= 'z' &&
+ base[1] >= 'a' && base[1] <= 'z' &&
+ (!base[2] || base[2] < 'a' || base[2] > 'z');
+}
+
+static void tried_catdirs_free (const void *value)
+{
+ struct tried_catdirs_entry *tried =
+ (struct tried_catdirs_entry *) value;
+
+ free (tried->manpath);
+ free (tried);
+}
+
+static void purge_catdir (gl_map_t tried_catdirs, const char *path)
+{
+ struct stat st;
+
+ if (stat (path, &st) == 0 && S_ISDIR (st.st_mode) &&
+ !gl_map_get (tried_catdirs, path)) {
+ if (!quiet)
+ printf (_("Removing obsolete cat directory %s...\n"),
+ path);
+ remove_directory (path, true);
+ }
+}
+
+static void purge_catsubdirs (const char *manpath, const char *catpath)
+{
+ DIR *dir;
+ struct dirent *ent;
+ struct stat st;
+
+ dir = opendir (catpath);
+ if (!dir)
+ return;
+ while ((ent = readdir (dir)) != NULL) {
+ char *mandir, *catdir;
+
+ if (!STRNEQ (ent->d_name, "cat", 3))
+ continue;
+
+ mandir = xasprintf ("%s/man%s", manpath, ent->d_name + 3);
+ assert (mandir);
+ catdir = xasprintf ("%s/%s", catpath, ent->d_name);
+ assert (catdir);
+
+ if (stat (mandir, &st) != 0 && errno == ENOENT) {
+ if (!quiet)
+ printf (_("Removing obsolete cat directory "
+ "%s...\n"), catdir);
+ remove_directory (catdir, true);
+ }
+
+ free (catdir);
+ free (mandir);
+ }
+ closedir (dir);
+}
+
+/* Remove catdirs whose corresponding mandirs no longer exist. For safety,
+ * in case people set catdirs to silly locations, we only do this for the
+ * cat* and NLS subdirectories of catdirs, but not for the top-level catdir
+ * itself (which might contain other data, or which might be difficult for
+ * mandb to recreate with the proper permissions).
+ *
+ * We need to be careful here to avoid removing catdirs just because we
+ * happened not to inspect the corresponding mandir this time round. If a
+ * mandir was inspected and turned out not to exist, then its catdir is
+ * clearly fair game for removal of NLS subdirectories. These must match
+ * the usual NLS pattern (two lower-case letters followed by nothing or a
+ * non-letter).
+ */
+static void purge_catdirs (gl_map_t tried_catdirs)
+{
+ const char *path;
+ struct tried_catdirs_entry *tried;
+
+ GL_MAP_FOREACH (tried_catdirs, path, tried) {
+ char *base;
+ DIR *dir;
+ struct dirent *subdirent;
+
+ base = base_name (path);
+ if (is_lang_dir (base)) {
+ /* expect to check this as a subdirectory later */
+ free (base);
+ continue;
+ }
+ free (base);
+
+ purge_catsubdirs (tried->manpath, path);
+
+ dir = opendir (path);
+ if (!dir)
+ continue;
+ while ((subdirent = readdir (dir)) != NULL) {
+ char *subdirpath;
+ const struct tried_catdirs_entry *subtried;
+
+ if (STREQ (subdirent->d_name, ".") ||
+ STREQ (subdirent->d_name, ".."))
+ continue;
+ if (STRNEQ (subdirent->d_name, "cat", 3))
+ continue;
+ if (!is_lang_dir (subdirent->d_name))
+ continue;
+
+ subdirpath = xasprintf ("%s/%s", path,
+ subdirent->d_name);
+
+ subtried = gl_map_get (tried_catdirs, subdirpath);
+ if (subtried && subtried->seen) {
+ debug ("Seen mandir for %s; not deleting\n",
+ subdirpath);
+ /* However, we may still need to purge cat*
+ * subdirectories.
+ */
+ purge_catsubdirs (subtried->manpath,
+ subdirpath);
+ } else
+ purge_catdir (tried_catdirs, subdirpath);
+
+ free (subdirpath);
+ }
+ closedir (dir);
+ }
+}
+
+int main (int argc, char *argv[])
+{
+ char *sys_manp;
+ int amount = 0;
+ char *mp;
+ gl_map_t tried_catdirs;
+ struct sigaction sa;
+
+#ifdef __profile__
+ char *cwd;
+#endif /* __profile__ */
+
+ set_program_name (argv[0]);
+
+ init_debug ();
+ pipeline_install_post_fork (pop_all_cleanups);
+ sandbox = sandbox_init ();
+ init_locale ();
+
+ /* Reset SIGPIPE to its default disposition. Too many broken pieces
+ * of software (Python << 3.2, gnome-session, etc.) spawn child
+ * processes with SIGPIPE ignored, and this produces noise in cron
+ * mail.
+ */
+ memset (&sa, 0, sizeof sa);
+ sa.sa_handler = SIG_DFL;
+ sigemptyset (&sa.sa_mask);
+ sa.sa_flags = 0;
+ sigaction (SIGPIPE, &sa, NULL);
+
+ if (argp_parse (&argp, argc, argv, 0, 0, 0))
+ exit (FAIL);
+
+#ifdef __profile__
+ cwd = xgetcwd ();
+ if (!cwd) {
+ cwd = xmalloc (1);
+ cwd[0] = '\0';
+ }
+#endif /* __profile__ */
+
+ /* record who we are and drop effective privs for later use */
+ init_security ();
+
+#ifdef MAN_OWNER
+ man_owner = get_man_owner ();
+ if (!user && euid != 0 && euid != man_owner->pw_uid) {
+ user = true;
+ if (!quiet)
+ fprintf (stderr,
+ _("Only the '%s' user can create or update "
+ "system-wide databases; acting as if the "
+ "--user-db option was used.\n"),
+ man_owner->pw_name);
+ }
+#endif /* MAN_OWNER */
+
+ read_config_file (user);
+
+ /* This is required for get_catpath(), regardless */
+ manp = get_manpath (NULL); /* also calls read_config_file() */
+
+ /* pick up the system manpath or use the supplied one */
+ if (arg_manp) {
+ free (manp);
+ manp = xstrdup (arg_manp);
+ } else if (!user) {
+ sys_manp = get_mandb_manpath ();
+ if (sys_manp) {
+ free (manp);
+ manp = sys_manp;
+ } else
+ error (0, 0,
+ _("warning: no MANDB_MAP directives in %s, "
+ "using your manpath"),
+ CONFIG_FILE);
+ }
+
+ /* get the manpath as a list of pointers */
+ manpathlist = create_pathlist (manp);
+
+ /* finished manpath processing, regain privs */
+ regain_effective_privs ();
+
+ tried_catdirs = new_string_map (GL_HASH_MAP, tried_catdirs_free);
+
+ GL_LIST_FOREACH (manpathlist, mp) {
+ bool global_manpath = is_global_mandir (mp);
+ int ret;
+ DIR *dir;
+ struct dirent *subdirent;
+
+ if (global_manpath) { /* system db */
+ if (user)
+ continue;
+ } else { /* user db */
+ drop_effective_privs ();
+ }
+
+ ret = process_manpath (mp, global_manpath, tried_catdirs);
+ if (ret < 0)
+ exit (FATAL);
+ amount += ret;
+
+ dir = opendir (mp);
+ if (!dir) {
+ error (0, errno, _("can't search directory %s"), mp);
+ goto next_manpath;
+ }
+
+ while ((subdirent = readdir (dir)) != NULL) {
+ char *subdirpath;
+
+ /* Look for per-locale subdirectories. */
+ if (STREQ (subdirent->d_name, ".") ||
+ STREQ (subdirent->d_name, ".."))
+ continue;
+ if (STRNEQ (subdirent->d_name, "man", 3))
+ continue;
+
+ subdirpath = xasprintf ("%s/%s", mp,
+ subdirent->d_name);
+ assert (subdirpath);
+ ret = process_manpath (subdirpath, global_manpath,
+ tried_catdirs);
+ if (ret < 0)
+ exit (FATAL);
+ amount += ret;
+ free (subdirpath);
+ }
+
+ closedir (dir);
+
+next_manpath:
+ if (!global_manpath)
+ regain_effective_privs ();
+ }
+
+ purge_catdirs (tried_catdirs);
+ gl_map_free (tried_catdirs);
+
+ if (!quiet) {
+ printf (ngettext ("%d man subdirectory contained newer "
+ "manual pages.\n",
+ "%d man subdirectories contained newer "
+ "manual pages.\n", amount),
+ amount);
+ printf (ngettext ("%d manual page was added.\n",
+ "%d manual pages were added.\n", pages),
+ pages);
+ if (check_for_strays)
+ printf (ngettext ("%d stray cat was added.\n",
+ "%d stray cats were added.\n",
+ strays),
+ strays);
+ if (purge)
+ printf (ngettext ("%d old database entry was "
+ "purged.\n",
+ "%d old database entries were "
+ "purged.\n", purged),
+ purged);
+ }
+
+#ifdef __profile__
+ /* For profiling */
+ if (cwd[0])
+ chdir (cwd);
+#endif /* __profile__ */
+
+ free_pathlist (manpathlist);
+ free (manp);
+ if (create && !amount) {
+ const char *must_create;
+ if (!quiet)
+ fprintf (stderr, _("No databases created."));
+ must_create = getenv ("MAN_MUST_CREATE");
+ if (must_create && STREQ (must_create, "1"))
+ exit (FAIL);
+ }
+ sandbox_free (sandbox);
+ exit (OK);
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-22 03:01:33 +0000