]> git.cameronkatri.com Git - mandoc.git/blobdiff - cgi.c
Note that archives are being hosted at gmane.
[mandoc.git] / cgi.c
diff --git a/cgi.c b/cgi.c
index 17bc6ad7d46ceee9becd9c1232a56d9672b4c17c..c203c67145e515d5e8b1b00930cc12a39ab71d41 100644 (file)
--- a/cgi.c
+++ b/cgi.c
@@ -1,4 +1,4 @@
-/*     $Id: cgi.c,v 1.10 2011/12/07 00:23:04 kristaps Exp $ */
+/*     $Id: cgi.c,v 1.31 2011/12/14 13:36:59 kristaps Exp $ */
 /*
  * Copyright (c) 2011 Kristaps Dzonsons <kristaps@bsd.lv>
  *
@@ -24,6 +24,7 @@
 #include <assert.h>
 #include <ctype.h>
 #include <errno.h>
+#include <dirent.h>
 #include <fcntl.h>
 #include <limits.h>
 #include <regex.h>
@@ -54,31 +55,43 @@ enum        page {
        PAGE__MAX
 };
 
-struct kval {
-       char            *key;
-       char            *val;
+struct paths {
+       char            *name;
+       char            *path;
+};
+
+/*
+ * A query as passed to the search function.
+ */
+struct query {
+       const char      *arch; /* architecture */
+       const char      *sec; /* manual section */
+       const char      *expr; /* unparsed expression string */
+       int              manroot; /* manroot index (or -1)*/
+       int              whatis; /* whether whatis mode */
+       int              legacy; /* whether legacy mode */
 };
 
 struct req {
-       struct kval     *fields;
-       size_t           fieldsz;
+       struct query     q;
+       struct paths    *p;
+       size_t           psz;
        enum page        page;
 };
 
 static int              atou(const char *, unsigned *);
 static void             catman(const char *);
+static int              cmp(const void *, const void *);
 static void             format(const char *);
 static void             html_print(const char *);
 static void             html_putchar(char);
-static int              kval_decode(char *);
-static void             kval_parse(struct kval **, size_t *, char *);
-static void             kval_free(struct kval *, size_t);
-static void             pg_index(const struct manpaths *,
-                               const struct req *, char *);
-static void             pg_search(const struct manpaths *,
-                               const struct req *, char *);
-static void             pg_show(const struct manpaths *,
-                               const struct req *, char *);
+static int              http_decode(char *);
+static void             http_parse(struct req *, char *);
+static int              pathstop(DIR *);
+static void             pathgen(DIR *, char *, struct req *);
+static void             pg_index(const struct req *, char *);
+static void             pg_search(const struct req *, char *);
+static void             pg_show(const struct req *, char *);
 static void             resp_bad(void);
 static void             resp_baddb(void);
 static void             resp_error400(void);
@@ -90,9 +103,10 @@ static      void             resp_index(const struct req *);
 static void             resp_search(struct res *, size_t, void *);
 static void             resp_searchform(const struct req *);
 
-static const char       *progname;
-static const char       *cache;
-static const char       *host;
+static const char       *progname; /* cgi script name */
+static const char       *cache; /* cache directory */
+static const char       *css; /* css directory */
+static const char       *host; /* hostname */
 
 static const char * const pages[PAGE__MAX] = {
        "index", /* PAGE_INDEX */ 
@@ -123,6 +137,10 @@ atou(const char *buf, unsigned *v)
        return(1);
 }
 
+/*
+ * Print a character, escaping HTML along the way.
+ * This will pass non-ASCII straight to output: be warned!
+ */
 static void
 html_putchar(char c)
 {
@@ -147,8 +165,8 @@ html_putchar(char c)
 }
 
 /*
- * Print a word, escaping HTML along the way.
- * This will pass non-ASCII straight to output: be warned!
+ * Call through to html_putchar().
+ * Accepts NULL strings.
  */
 static void
 html_print(const char *p)
@@ -160,30 +178,23 @@ html_print(const char *p)
                html_putchar(*p++);
 }
 
-static void
-kval_free(struct kval *p, size_t sz)
-{
-       int              i;
-
-       for (i = 0; i < (int)sz; i++) {
-               free(p[i].key);
-               free(p[i].val);
-       }
-       free(p);
-}
-
 /*
  * Parse out key-value pairs from an HTTP request variable.
  * This can be either a cookie or a POST/GET string, although man.cgi
  * uses only GET for simplicity.
  */
 static void
-kval_parse(struct kval **kv, size_t *kvsz, char *p)
+http_parse(struct req *req, char *p)
 {
-       char            *key, *val;
-       size_t           sz, cur;
+       char            *key, *val, *manroot;
+       size_t           sz;
+       int              i, legacy;
+
+       memset(&req->q, 0, sizeof(struct query));
 
-       cur = 0;
+       req->q.whatis = 1;
+       legacy = -1;
+       manroot = NULL;
 
        while (p && '\0' != *p) {
                while (' ' == *p)
@@ -218,20 +229,58 @@ kval_parse(struct kval **kv, size_t *kvsz, char *p)
 
                /* Just abort handling. */
 
-               if ( ! kval_decode(key))
-                       return;
-               if ( ! kval_decode(val))
-                       return;
+               if ( ! http_decode(key))
+                       break;
+               if ( ! http_decode(val))
+                       break;
+
+               if (0 == strcmp(key, "expr"))
+                       req->q.expr = val;
+               else if (0 == strcmp(key, "query"))
+                       req->q.expr = val;
+               else if (0 == strcmp(key, "sec"))
+                       req->q.sec = val;
+               else if (0 == strcmp(key, "sektion"))
+                       req->q.sec = val;
+               else if (0 == strcmp(key, "arch"))
+                       req->q.arch = val;
+               else if (0 == strcmp(key, "manpath"))
+                       manroot = val;
+               else if (0 == strcmp(key, "apropos"))
+                       legacy = 0 == strcmp(val, "0");
+               else if (0 == strcmp(key, "op"))
+                       req->q.whatis = 0 == strcasecmp(val, "whatis");
+       }
 
-               if (*kvsz + 1 >= cur) {
-                       cur++;
-                       *kv = mandoc_realloc
-                               (*kv, cur * sizeof(struct kval));
-               }
+       /* Test for old man.cgi compatibility mode. */
+
+       if (legacy == 0) {
+               req->q.whatis = 0;
+               req->q.legacy = 1;
+       } else if (legacy > 0) {
+               req->q.legacy = 1;
+               req->q.whatis = 1;
+       }
+
+       /* 
+        * Section "0" means no section when in legacy mode.
+        * For some man.cgi scripts, "default" arch is none.
+        */
 
-               (*kv)[(int)*kvsz].key = mandoc_strdup(key);
-               (*kv)[(int)*kvsz].val = mandoc_strdup(val);
-               (*kvsz)++;
+       if (req->q.legacy && NULL != req->q.sec)
+               if (0 == strcmp(req->q.sec, "0"))
+                       req->q.sec = NULL;
+       if (req->q.legacy && NULL != req->q.arch)
+               if (0 == strcmp(req->q.arch, "default"))
+                       req->q.arch = NULL;
+
+       /* Default to first manroot. */
+
+       if (NULL != manroot) {
+               for (i = 0; i < (int)req->psz; i++)
+                       if (0 == strcmp(req->p[i].name, manroot))
+                               break;
+               req->q.manroot = i < (int)req->psz ? i : -1;
        }
 }
 
@@ -241,7 +290,7 @@ kval_parse(struct kval **kv, size_t *kvsz, char *p)
  * over the allocated string.
  */
 static int
-kval_decode(char *p)
+http_decode(char *p)
 {
        char             hex[3];
        int              c;
@@ -276,9 +325,9 @@ resp_begin_http(int code, const char *msg)
        if (200 != code)
                printf("Status: %d %s\n", code, msg);
 
-       puts("Content-Type: text/html; charset=utf-8"           "\n"
-            "Cache-Control: no-cache"                          "\n"
-            "Pragma: no-cache"                                 "\n"
+       puts("Content-Type: text/html; charset=utf-8\n"
+            "Cache-Control: no-cache\n"
+            "Pragma: no-cache\n"
             "");
 
        fflush(stdout);
@@ -290,61 +339,73 @@ resp_begin_html(int code, const char *msg)
 
        resp_begin_http(code, msg);
 
-       puts("<!DOCTYPE HTML PUBLIC "                           "\n"
-            " \"-//W3C//DTD HTML 4.01//EN\""                   "\n"
-            " \"http://www.w3.org/TR/html4/strict.dtd\">"      "\n"
-            "<HTML>"                                           "\n"
-            " <HEAD>"                                          "\n"
-            "   <META HTTP-EQUIV=\"Content-Type\" "            "\n"
-            "         CONTENT=\"text/html; charset=utf-8\">"   "\n"
-            "  <TITLE>System Manpage Reference</TITLE>"        "\n"
-            " </HEAD>"                                         "\n"
-            " <BODY>"                                          "\n"
-            "<!-- Begin page content. //-->");
+       printf("<!DOCTYPE HTML PUBLIC "
+              " \"-//W3C//DTD HTML 4.01//EN\""
+              " \"http://www.w3.org/TR/html4/strict.dtd\">\n"
+              "<HTML>\n"
+              "<HEAD>\n"
+              "<META HTTP-EQUIV=\"Content-Type\""
+              " CONTENT=\"text/html; charset=utf-8\">\n"
+              "<LINK REL=\"stylesheet\" HREF=\"%s/man.cgi.css\""
+              " TYPE=\"text/css\" media=\"all\">\n"
+              "<TITLE>System Manpage Reference</TITLE>\n"
+              "</HEAD>\n"
+              "<BODY>\n"
+              "<!-- Begin page content. //-->\n", css);
 }
 
 static void
 resp_end_html(void)
 {
 
-       puts(" </BODY>\n</HTML>");
+       puts("</BODY>\n"
+            "</HTML>");
 }
 
 static void
 resp_searchform(const struct req *req)
 {
-       int              i;
-       const char      *expr, *sec, *arch;
-
-       expr = sec = arch = "";
-
-       for (i = 0; i < (int)req->fieldsz; i++)
-               if (0 == strcmp(req->fields[i].key, "expr"))
-                       expr = req->fields[i].val;
-               else if (0 == strcmp(req->fields[i].key, "sec"))
-                       sec = req->fields[i].val;
-               else if (0 == strcmp(req->fields[i].key, "arch"))
-                       arch = req->fields[i].val;
+       int              i;
 
        puts("<!-- Begin search form. //-->");
-       printf("<FORM ACTION=\"");
-       html_print(progname);
-       printf("/search.html\" METHOD=\"get\">\n");
-       puts(" <FIELDSET>\n"
-            "  <INPUT TYPE=\"submit\" VALUE=\"Search:\">");
-       printf("  Terms: <INPUT TYPE=\"text\" "
-                       "SIZE=\"60\" NAME=\"expr\" VALUE=\"");
-       html_print(expr);
-       puts("\">");
-       printf("  Section: <INPUT TYPE=\"text\" "
-                       "SIZE=\"4\" NAME=\"sec\" VALUE=\"");
-       html_print(sec);
-       puts("\">");
-       printf("  Arch: <INPUT TYPE=\"text\" "
-                       "SIZE=\"8\" NAME=\"arch\" VALUE=\"");
-       html_print(arch);
-       puts("\">");
-       puts(" </FIELDSET>\n</FORM>\n<!-- End search form. //-->");
+       printf("<FORM ACTION=\"%s/search.html\" METHOD=\"get\">\n"
+              "<FIELDSET>\n"
+              "<LEGEND>Search Parameters</LEGEND>\n"
+              "<INPUT TYPE=\"submit\" NAME=\"op\""
+              " VALUE=\"Whatis\"> or \n"
+              "<INPUT TYPE=\"submit\" NAME=\"op\""
+              " VALUE=\"apropos\"> for manuals satisfying \n"
+              "<INPUT TYPE=\"text\" NAME=\"expr\" VALUE=\"",
+              progname);
+       html_print(req->q.expr ? req->q.expr : "");
+       printf("\">, section "
+              "<INPUT TYPE=\"text\""
+              " SIZE=\"4\" NAME=\"sec\" VALUE=\"");
+       html_print(req->q.sec ? req->q.sec : "");
+       printf("\">, arch "
+              "<INPUT TYPE=\"text\""
+              " SIZE=\"8\" NAME=\"arch\" VALUE=\"");
+       html_print(req->q.arch ? req->q.arch : "");
+       printf("\">");
+       if (req->psz > 1) {
+               puts(", <SELECT NAME=\"manpath\">");
+               for (i = 0; i < (int)req->psz; i++) {
+                       printf("<OPTION %s VALUE=\"",
+                               (i == req->q.manroot) ||
+                               (0 == i && -1 == req->q.manroot) ?
+                               "SELECTED=\"selected\"" : "");
+                       html_print(req->p[i].name);
+                       printf("\">");
+                       html_print(req->p[i].name);
+                       puts("</OPTION>");
+               }
+               puts("</SELECT>");
+       }
+       puts(".\n"
+            "<INPUT TYPE=\"reset\" VALUE=\"Reset\">\n"
+            "</FIELDSET>\n"
+            "</FORM>");
+       puts("<!-- End search form. //-->");
 }
 
 static void
@@ -361,12 +422,12 @@ resp_error400(void)
 {
 
        resp_begin_html(400, "Query Malformed");
-       puts("<H1>Malformed Query</H1>\n"
-            "<P>\n"
-            "  The query your entered was malformed.\n"
-            "  Try again from the\n"
-            "  <A HREF=\"/index.html\">main page</A>\n"
-            "</P>");
+       printf("<H1>Malformed Query</H1>\n"
+              "<P>\n"
+              "The query your entered was malformed.\n"
+              "Try again from the\n"
+              "<A HREF=\"%s/index.html\">main page</A>.\n"
+              "</P>", progname);
        resp_end_html();
 }
 
@@ -377,14 +438,14 @@ resp_error404(const char *page)
        resp_begin_html(404, "Not Found");
        puts("<H1>Page Not Found</H1>\n"
             "<P>\n"
-            "  The page you're looking for, ");
-       printf("  <B>");
+            "The page you're looking for, ");
+       printf("<B>");
        html_print(page);
-       puts("</B>,\n"
-            "  could not be found.\n"
-            "  Try searching from the\n"
-            "  <A HREF=\"/index.html\">main page</A>\n"
-            "</P>");
+       printf("</B>,\n"
+              "could not be found.\n"
+              "Try searching from the\n"
+              "<A HREF=\"%s/index.html\">main page</A>.\n"
+              "</P>", progname);
        resp_end_html();
 }
 
@@ -408,7 +469,11 @@ resp_baddb(void)
 static void
 resp_search(struct res *r, size_t sz, void *arg)
 {
-       int              i;
+       int               i;
+       const struct req *req;
+
+       req = (const struct req *)arg;
+       assert(req->q.manroot >= 0);
 
        if (1 == sz) {
                /*
@@ -416,23 +481,46 @@ resp_search(struct res *r, size_t sz, void *arg)
                 * without any delay.
                 */
                puts("Status: 303 See Other");
-               printf("Location: http://%s%s/show/%u/%u.html\n",
-                               host, progname,
+               printf("Location: http://%s%s/show/%d/%u/%u.html\n",
+                               host, progname, req->q.manroot,
                                r[0].volume, r[0].rec);
                puts("Content-Type: text/html; charset=utf-8\n");
                return;
        }
 
+       qsort(r, sz, sizeof(struct res), cmp);
+
        resp_begin_html(200, NULL);
-       resp_searchform((const struct req *)arg);
+       resp_searchform(req);
 
-       if (0 == sz)
-               puts("<P>No results found.</P>");
+       if (0 == sz) {
+               printf("<P>\n"
+                      "No %s results found.\n",
+                      req->q.whatis ? "whatis" : "apropos");
+               if (req->q.whatis) {
+                       printf("(Try <A HREF=\"%s/search.html?"
+                              "op=apropos&amp;expr=", progname);
+                       html_print(req->q.expr ? req->q.expr : "");
+                       printf("&amp;sec=");
+                       html_print(req->q.sec ? req->q.sec : "");
+                       printf("&amp;arch=");
+                       html_print(req->q.arch ? req->q.arch : "");
+                       puts("\">apropos</A>?)");
+               }
+               puts("</P>");
+               resp_end_html();
+               return;
+       }
+
+       puts("<P></P>\n"
+            "<TABLE>");
 
        for (i = 0; i < (int)sz; i++) {
-               printf("<P><A HREF=\"");
-               html_print(progname);
-               printf("/show/%u/%u.html\">", r[i].volume, r[i].rec);
+               printf("<TR>\n"
+                      "<TD CLASS=\"title\">\n"
+                      "<A HREF=\"%s/show/%d/%u/%u.html\">", 
+                               progname, req->q.manroot,
+                               r[i].volume, r[i].rec);
                html_print(r[i].title);
                putchar('(');
                html_print(r[i].cat);
@@ -440,17 +528,21 @@ resp_search(struct res *r, size_t sz, void *arg)
                        putchar('/');
                        html_print(r[i].arch);
                }
-               printf(")</A> ");
+               printf(")</A>\n"
+                      "</TD>\n"
+                      "<TD CLASS=\"desc\">");
                html_print(r[i].desc);
-               puts("</P>");
+               puts("</TD>\n"
+                    "</TR>");
        }
 
+       puts("</TABLE>");
        resp_end_html();
 }
 
 /* ARGSUSED */
 static void
-pg_index(const struct manpaths *ps, const struct req *req, char *path)
+pg_index(const struct req *req, char *path)
 {
 
        resp_index(req);
@@ -470,9 +562,22 @@ catman(const char *file)
                return;
        }
 
-       resp_begin_html(200, NULL);
+       resp_begin_http(200, NULL);
+       printf("<!DOCTYPE HTML PUBLIC "
+              " \"-//W3C//DTD HTML 4.01//EN\""
+              " \"http://www.w3.org/TR/html4/strict.dtd\">\n"
+              "<HTML>\n"
+              "<HEAD>\n"
+              "<META HTTP-EQUIV=\"Content-Type\""
+              " CONTENT=\"text/html; charset=utf-8\">\n"
+              "<LINK REL=\"stylesheet\" HREF=\"%s/catman.css\""
+              " TYPE=\"text/css\" media=\"all\">\n"
+              "<TITLE>System Manpage Reference</TITLE>\n"
+              "</HEAD>\n"
+              "<BODY>\n"
+              "<!-- Begin page content. //-->\n"
+              "<PRE>\n", css);
 
-       puts("<PRE>");
        while (NULL != (p = fgetln(f, &len))) {
                bold = italic = 0;
                for (i = 0; i < (int)len - 1; i++) {
@@ -614,10 +719,10 @@ format(const char *file)
                return;
        }
 
-       snprintf(opts, sizeof(opts), "style=/style.css,"
+       snprintf(opts, sizeof(opts), "style=%s/man.css,"
                        "man=%s/search.html?sec=%%S&expr=%%N,"
-                       "includes=/cgi-bin/man.cgi/usr/include/%%I",
-                       progname);
+                       /*"includes=/cgi-bin/man.cgi/usr/include/%%I"*/,
+                       css, progname);
 
        mparse_result(mp, &mdoc, &man);
        vp = html_alloc(opts);
@@ -636,42 +741,74 @@ format(const char *file)
 }
 
 static void
-pg_show(const struct manpaths *ps, const struct req *req, char *path)
+pg_show(const struct req *req, char *path)
 {
+       struct manpaths  ps;
        char            *sub;
        char             file[MAXPATHLEN];
        const char      *fn, *cp;
        int              rc;
-       unsigned int     vol, rec;
+       unsigned int     vol, rec, mr;
        DB              *idx;
        DBT              key, val;
 
-       if (NULL == path) {
+       idx = NULL;
+
+       /* Parse out mroot, volume, and record from the path. */
+
+       if (NULL == path || NULL == (sub = strchr(path, '/'))) {
                resp_error400();
                return;
-       } else if (NULL == (sub = strrchr(path, '/'))) {
+       } 
+       *sub++ = '\0';
+       if ( ! atou(path, &mr)) {
                resp_error400();
                return;
-       } else
-               *sub++ = '\0';
-
-       if ( ! (atou(path, &vol) && atou(sub, &rec))) {
+       }
+       path = sub;
+       if (NULL == (sub = strchr(path, '/'))) {
                resp_error400();
                return;
-       } else if (vol >= (unsigned int)ps->sz) {
+       }
+       *sub++ = '\0';
+       if ( ! atou(path, &vol) || ! atou(sub, &rec)) {
                resp_error400();
                return;
+       } else if (mr >= (unsigned int)req->psz) {
+               resp_error400();
+               return;
+       }
+
+       /*
+        * Begin by chdir()ing into the manroot.
+        * This way we can pick up the database files, which are
+        * relative to the manpath root.
+        */
+
+       if (-1 == chdir(req->p[(int)mr].path)) {
+               perror(req->p[(int)mr].path);
+               resp_baddb();
+               return;
+       }
+
+       memset(&ps, 0, sizeof(struct manpaths));
+       manpath_manconf(&ps, "etc/catman.conf");
+
+       if (vol >= (unsigned int)ps.sz) {
+               resp_error400();
+               goto out;
        }
 
-       strlcpy(file, ps->paths[vol], MAXPATHLEN);
+       strlcpy(file, ps.paths[vol], MAXPATHLEN);
        strlcat(file, "/mandoc.index", MAXPATHLEN);
 
        /* Open the index recno(3) database. */
 
        idx = dbopen(file, O_RDONLY, 0, DB_RECNO, NULL);
        if (NULL == idx) {
+               perror(file);
                resp_baddb();
-               return;
+               goto out;
        }
 
        key.data = &rec;
@@ -691,46 +828,60 @@ pg_show(const struct manpaths *ps, const struct req *req, char *path)
        else if (NULL == memchr(fn, '\0', val.size - (fn - cp)))
                resp_baddb();
        else {
-               strlcpy(file, ps->paths[vol], MAXPATHLEN);
-               strlcat(file, "/", MAXPATHLEN);
-               strlcat(file, fn, MAXPATHLEN);
                if (0 == strcmp(cp, "cat"))
-                       catman(file);
+                       catman(fn + 1);
                else
-                       format(file);
+                       format(fn + 1);
        }
 out:
-       (*idx->close)(idx);
+       if (idx)
+               (*idx->close)(idx);
+       manpath_free(&ps);
 }
 
 static void
-pg_search(const struct manpaths *ps, const struct req *req, char *path)
+pg_search(const struct req *req, char *path)
 {
        size_t            tt;
+       struct manpaths   ps;
        int               i, sz, rc;
        const char       *ep, *start;
        char            **cp;
        struct opts       opt;
        struct expr      *expr;
 
-       expr = NULL;
-       cp = NULL;
-       ep = NULL;
-       sz = 0;
+       if (req->q.manroot < 0 || 0 == req->psz) {
+               resp_search(NULL, 0, (void *)req);
+               return;
+       }
 
        memset(&opt, 0, sizeof(struct opts));
 
-       for (sz = i = 0; i < (int)req->fieldsz; i++)
-               if (0 == strcmp(req->fields[i].key, "expr"))
-                       ep = req->fields[i].val;
-               else if (0 == strcmp(req->fields[i].key, "sec"))
-                       opt.cat = req->fields[i].val;
-               else if (0 == strcmp(req->fields[i].key, "arch"))
-                       opt.arch = req->fields[i].val;
+       ep       = req->q.expr;
+       opt.arch = req->q.arch;
+       opt.cat  = req->q.sec;
+       rc       = -1;
+       sz       = 0;
+       cp       = NULL;
+
+       /*
+        * Begin by chdir()ing into the root of the manpath.
+        * This way we can pick up the database files, which are
+        * relative to the manpath root.
+        */
+
+       assert(req->q.manroot < (int)req->psz);
+       if (-1 == (chdir(req->p[req->q.manroot].path))) {
+               perror(req->p[req->q.manroot].path);
+               resp_search(NULL, 0, (void *)req);
+               return;
+       }
+
+       memset(&ps, 0, sizeof(struct manpaths));
+       manpath_manconf(&ps, "etc/catman.conf");
 
        /*
-        * Poor man's tokenisation.
-        * Just break apart by spaces.
+        * Poor man's tokenisation: just break apart by spaces.
         * Yes, this is half-ass.  But it works for now.
         */
 
@@ -749,16 +900,17 @@ pg_search(const struct manpaths *ps, const struct req *req, char *path)
                        ep++;
        }
 
-       rc = -1;
-
        /*
         * Pump down into apropos backend.
         * The resp_search() function is called with the results.
         */
 
-       if (NULL != (expr = exprcomp(sz, cp, &tt)))
+       expr = req->q.whatis ? 
+               termcomp(sz, cp, &tt) : exprcomp(sz, cp, &tt);
+
+       if (NULL != expr)
                rc = apropos_search
-                       (ps->sz, ps->paths, &opt,
+                       (ps.sz, ps.paths, &opt,
                         expr, tt, (void *)req, resp_search);
 
        /* ...unless errors occured. */
@@ -773,41 +925,65 @@ pg_search(const struct manpaths *ps, const struct req *req, char *path)
 
        free(cp);
        exprfree(expr);
+       manpath_free(&ps);
 }
 
 int
 main(void)
 {
        int              i;
+       char             buf[MAXPATHLEN];
+       DIR             *cwd;
        struct req       req;
        char            *p, *path, *subpath;
-       struct manpaths  paths;
 
-       /* HTTP init: read and parse the query string. */
+       /* Scan our run-time environment. */
 
-       progname = getenv("SCRIPT_NAME");
-       if (NULL == progname)
+       if (NULL == (cache = getenv("CACHE_DIR")))
+               cache = "/cache/man.cgi";
+
+       if (NULL == (progname = getenv("SCRIPT_NAME")))
                progname = "";
 
-       cache = getenv("CACHE_DIR");
-       if (NULL == cache)
-               cache = "/cache/man.cgi";
+       if (NULL == (css = getenv("CSS_DIR")))
+               css = "";
+
+       if (NULL == (host = getenv("HTTP_HOST")))
+               host = "localhost";
+
+       /*
+        * First we change directory into the cache directory so that
+        * subsequent scanning for manpath directories is rooted
+        * relative to the same position.
+        */
 
        if (-1 == chdir(cache)) {
+               perror(cache);
                resp_bad();
                return(EXIT_FAILURE);
-       }
-
-       host = getenv("HTTP_HOST");
-       if (NULL == host)
-               host = "localhost";
+       } else if (NULL == (cwd = opendir(cache))) {
+               perror(cache);
+               resp_bad();
+               return(EXIT_FAILURE);
+       } 
 
        memset(&req, 0, sizeof(struct req));
 
+       strlcpy(buf, ".", MAXPATHLEN);
+       pathgen(cwd, buf, &req);
+       closedir(cwd);
+
+       /* Next parse out the query string. */
+
        if (NULL != (p = getenv("QUERY_STRING")))
-               kval_parse(&req.fields, &req.fieldsz, p);
+               http_parse(&req, p);
 
-       /* Resolve leading subpath component. */
+       /*
+        * Now juggle paths to extract information.
+        * We want to extract our filetype (the file suffix), the
+        * initial path component, then the trailing component(s).
+        * Start with leading subpath component. 
+        */
 
        subpath = path = NULL;
        req.page = PAGE__MAX;
@@ -838,30 +1014,149 @@ main(void)
                                break;
                        }
 
-       /* Initialise MANPATH. */
-
-       memset(&paths, 0, sizeof(struct manpaths));
-       manpath_manconf("etc/catman.conf", &paths);
-
        /* Route pages. */
 
        switch (req.page) {
        case (PAGE_INDEX):
-               pg_index(&paths, &req, subpath);
+               pg_index(&req, subpath);
                break;
        case (PAGE_SEARCH):
-               pg_search(&paths, &req, subpath);
+               pg_search(&req, subpath);
                break;
        case (PAGE_SHOW):
-               pg_show(&paths, &req, subpath);
+               pg_show(&req, subpath);
                break;
        default:
                resp_error404(path);
                break;
        }
 
-       manpath_free(&paths);
-       kval_free(req.fields, req.fieldsz);
+       for (i = 0; i < (int)req.psz; i++) {
+               free(req.p[i].path);
+               free(req.p[i].name);
+       }
 
+       free(req.p);
        return(EXIT_SUCCESS);
 }
+
+static int
+cmp(const void *p1, const void *p2)
+{
+
+       return(strcasecmp(((const struct res *)p1)->title,
+                               ((const struct res *)p2)->title));
+}
+
+/*
+ * Check to see if an "etc" path consists of a catman.conf file.  If it
+ * does, that means that the path contains a tree created by catman(8)
+ * and should be used for indexing.
+ */
+static int
+pathstop(DIR *dir)
+{
+       struct dirent   *d;
+
+       while (NULL != (d = readdir(dir)))
+               if (DT_REG == d->d_type)
+                       if (0 == strcmp(d->d_name, "catman.conf"))
+                               return(1);
+
+       return(0);
+}
+
+/*
+ * Scan for indexable paths.
+ * This adds all paths with "etc/catman.conf" to the buffer.
+ */
+static void
+pathgen(DIR *dir, char *path, struct req *req)
+{
+       struct dirent   *d;
+       char            *cp;
+       DIR             *cd;
+       int              rc;
+       size_t           sz, ssz;
+
+       sz = strlcat(path, "/", MAXPATHLEN);
+       if (sz >= MAXPATHLEN) {
+               fprintf(stderr, "%s: Path too long", path);
+               return;
+       } 
+
+       /* 
+        * First, scan for the "etc" directory.
+        * If it's found, then see if it should cause us to stop.  This
+        * happens when a catman.conf is found in the directory.
+        */
+
+       rc = 0;
+       while (0 == rc && NULL != (d = readdir(dir))) {
+               if (DT_DIR != d->d_type || strcmp(d->d_name, "etc"))
+                       continue;
+
+               path[(int)sz] = '\0';
+               ssz = strlcat(path, d->d_name, MAXPATHLEN);
+
+               if (ssz >= MAXPATHLEN) {
+                       fprintf(stderr, "%s: Path too long", path);
+                       return;
+               } else if (NULL == (cd = opendir(path))) {
+                       perror(path);
+                       return;
+               } 
+               
+               rc = pathstop(cd);
+               closedir(cd);
+       }
+
+       if (rc > 0) {
+               /* This also strips the trailing slash. */
+               path[(int)--sz] = '\0';
+               req->p = mandoc_realloc
+                       (req->p, 
+                        (req->psz + 1) * sizeof(struct paths));
+               /*
+                * Strip out the leading "./" unless we're just a ".",
+                * in which case use an empty string as our name.
+                */
+               req->p[(int)req->psz].path = mandoc_strdup(path);
+               req->p[(int)req->psz].name = 
+                       cp = mandoc_strdup(path + (1 == sz ? 1 : 2));
+               req->psz++;
+               /* 
+                * The name is just the path with all the slashes taken
+                * out of it.  Simple but effective. 
+                */
+               for ( ; '\0' != *cp; cp++) 
+                       if ('/' == *cp)
+                               *cp = ' ';
+               return;
+       } 
+
+       /*
+        * If no etc/catman.conf was found, recursively enter child
+        * directory and continue scanning.
+        */
+
+       rewinddir(dir);
+       while (NULL != (d = readdir(dir))) {
+               if (DT_DIR != d->d_type || '.' == d->d_name[0])
+                       continue;
+
+               path[(int)sz] = '\0';
+               ssz = strlcat(path, d->d_name, MAXPATHLEN);
+
+               if (ssz >= MAXPATHLEN) {
+                       fprintf(stderr, "%s: Path too long", path);
+                       return;
+               } else if (NULL == (cd = opendir(path))) {
+                       perror(path);
+                       return;
+               }
+
+               pathgen(cd, path, req);
+               closedir(cd);
+       }
+}