cgi.c

   1 /*      $Id: cgi.c,v 1.61 2014/07/10 00:52:50 schwarze Exp $ */
   2 /*
   3  * Copyright (c) 2011, 2012 Kristaps Dzonsons <kristaps@bsd.lv>
   4  * Copyright (c) 2014 Ingo Schwarze <schwarze@usta.de>
   5  *
   6  * Permission to use, copy, modify, and distribute this software for any
   7  * purpose with or without fee is hereby granted, provided that the above
   8  * copyright notice and this permission notice appear in all copies.
   9  *
  10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  16  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  17  */
  18 #ifdef HAVE_CONFIG_H
  19 #include "config.h"
  20 #endif
  21
  22 #include <ctype.h>
  23 #include <errno.h>
  24 #include <fcntl.h>
  25 #include <limits.h>
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include <unistd.h>
  30
  31 #include "mandoc.h"
  32 #include "mandoc_aux.h"
  33 #include "main.h"
  34 #include "manpath.h"
  35 #include "mansearch.h"
  36
  37 enum    page {
  38         PAGE_INDEX,
  39         PAGE_SEARCH,
  40         PAGE_SHOW,
  41         PAGE__MAX
  42 };
  43
  44 /*
  45  * A query as passed to the search function.
  46  */
  47 struct  query {
  48         const char      *manpath; /* desired manual directory */
  49         const char      *arch; /* architecture */
  50         const char      *sec; /* manual section */
  51         const char      *expr; /* unparsed expression string */
  52         int              legacy; /* whether legacy mode */
  53 };
  54
  55 struct  req {
  56         struct query      q;
  57         char            **p; /* array of available manpaths */
  58         size_t            psz; /* number of available manpaths */
  59         enum page         page;
  60 };
  61
  62 static  void             catman(const struct req *, const char *);
  63 static  int              cmp(const void *, const void *);
  64 static  void             format(const struct req *, const char *);
  65 static  void             html_print(const char *);
  66 static  void             html_printquery(const struct req *);
  67 static  void             html_putchar(char);
  68 static  int              http_decode(char *);
  69 static  void             http_parse(struct req *, char *);
  70 static  void             http_print(const char *);
  71 static  void             http_putchar(char);
  72 static  void             http_printquery(const struct req *);
  73 static  void             pathgen(struct req *);
  74 static  void             pg_index(const struct req *, char *);
  75 static  void             pg_search(const struct req *, char *);
  76 static  void             pg_show(const struct req *, char *);
  77 static  void             resp_begin_html(int, const char *);
  78 static  void             resp_begin_http(int, const char *);
  79 static  void             resp_end_html(void);
  80 static  void             resp_error_badrequest(const char *);
  81 static  void             resp_error_internal(void);
  82 static  void             resp_error_notfound(const char *);
  83 static  void             resp_index(const struct req *);
  84 static  void             resp_noresult(const struct req *,
  85                                 const char *);
  86 static  void             resp_search(const struct req *,
  87                                 struct manpage *, size_t);
  88 static  void             resp_searchform(const struct req *);
  89
  90 static  const char       *scriptname; /* CGI script name */
  91 static  const char       *mandir; /* contains all manpath directories */
  92 static  const char       *cssdir; /* css directory */
  93 static  const char       *httphost; /* hostname used in the URIs */
  94
  95 static  const char * const pages[PAGE__MAX] = {
  96         "index", /* PAGE_INDEX */
  97         "search", /* PAGE_SEARCH */
  98         "show", /* PAGE_SHOW */
  99 };
 100
 101 /*
 102  * Print a character, escaping HTML along the way.
 103  * This will pass non-ASCII straight to output: be warned!
 104  */
 105 static void
 106 html_putchar(char c)
 107 {
 108
 109         switch (c) {
 110         case ('"'):
 111                 printf("&quote;");
 112                 break;
 113         case ('&'):
 114                 printf("&amp;");
 115                 break;
 116         case ('>'):
 117                 printf("&gt;");
 118                 break;
 119         case ('<'):
 120                 printf("&lt;");
 121                 break;
 122         default:
 123                 putchar((unsigned char)c);
 124                 break;
 125         }
 126 }
 127
 128 static void
 129 http_printquery(const struct req *req)
 130 {
 131
 132         if (NULL != req->q.manpath) {
 133                 printf("&manpath=");
 134                 http_print(req->q.manpath);
 135         }
 136         if (NULL != req->q.sec) {
 137                 printf("&sec=");
 138                 http_print(req->q.sec);
 139         }
 140         if (NULL != req->q.arch) {
 141                 printf("&arch=");
 142                 http_print(req->q.arch);
 143         }
 144         if (NULL != req->q.expr) {
 145                 printf("&expr=");
 146                 http_print(req->q.expr ? req->q.expr : "");
 147         }
 148 }
 149
 150 static void
 151 html_printquery(const struct req *req)
 152 {
 153
 154         if (NULL != req->q.manpath) {
 155                 printf("&amp;manpath=");
 156                 html_print(req->q.manpath);
 157         }
 158         if (NULL != req->q.sec) {
 159                 printf("&amp;sec=");
 160                 html_print(req->q.sec);
 161         }
 162         if (NULL != req->q.arch) {
 163                 printf("&amp;arch=");
 164                 html_print(req->q.arch);
 165         }
 166         if (NULL != req->q.expr) {
 167                 printf("&amp;expr=");
 168                 html_print(req->q.expr ? req->q.expr : "");
 169         }
 170 }
 171
 172 static void
 173 http_print(const char *p)
 174 {
 175
 176         if (NULL == p)
 177                 return;
 178         while ('\0' != *p)
 179                 http_putchar(*p++);
 180 }
 181
 182 /*
 183  * Call through to html_putchar().
 184  * Accepts NULL strings.
 185  */
 186 static void
 187 html_print(const char *p)
 188 {
 189
 190         if (NULL == p)
 191                 return;
 192         while ('\0' != *p)
 193                 html_putchar(*p++);
 194 }
 195
 196 /*
 197  * Parse out key-value pairs from an HTTP request variable.
 198  * This can be either a cookie or a POST/GET string, although man.cgi
 199  * uses only GET for simplicity.
 200  */
 201 static void
 202 http_parse(struct req *req, char *p)
 203 {
 204         char            *key, *val;
 205         int              legacy;
 206
 207         memset(&req->q, 0, sizeof(struct query));
 208         req->q.manpath = req->p[0];
 209
 210         legacy = -1;
 211         while ('\0' != *p) {
 212                 key = p;
 213                 val = NULL;
 214
 215                 p += (int)strcspn(p, ";&");
 216                 if ('\0' != *p)
 217                         *p++ = '\0';
 218                 if (NULL != (val = strchr(key, '=')))
 219                         *val++ = '\0';
 220
 221                 if ('\0' == *key || NULL == val || '\0' == *val)
 222                         continue;
 223
 224                 /* Just abort handling. */
 225
 226                 if ( ! http_decode(key))
 227                         break;
 228                 if (NULL != val && ! http_decode(val))
 229                         break;
 230
 231                 if (0 == strcmp(key, "expr"))
 232                         req->q.expr = val;
 233                 else if (0 == strcmp(key, "query"))
 234                         req->q.expr = val;
 235                 else if (0 == strcmp(key, "sec"))
 236                         req->q.sec = val;
 237                 else if (0 == strcmp(key, "sektion"))
 238                         req->q.sec = val;
 239                 else if (0 == strcmp(key, "arch"))
 240                         req->q.arch = val;
 241                 else if (0 == strcmp(key, "manpath"))
 242                         req->q.manpath = val;
 243                 else if (0 == strcmp(key, "apropos"))
 244                         legacy = 0 == strcmp(val, "0");
 245         }
 246
 247         /* Test for old man.cgi compatibility mode. */
 248
 249         req->q.legacy = legacy > 0;
 250
 251         /*
 252          * Section "0" means no section when in legacy mode.
 253          * For some man.cgi scripts, "default" arch is none.
 254          */
 255
 256         if (req->q.legacy && NULL != req->q.sec)
 257                 if (0 == strcmp(req->q.sec, "0"))
 258                         req->q.sec = NULL;
 259         if (req->q.legacy && NULL != req->q.arch)
 260                 if (0 == strcmp(req->q.arch, "default"))
 261                         req->q.arch = NULL;
 262 }
 263
 264 static void
 265 http_putchar(char c)
 266 {
 267
 268         if (isalnum((unsigned char)c)) {
 269                 putchar((unsigned char)c);
 270                 return;
 271         } else if (' ' == c) {
 272                 putchar('+');
 273                 return;
 274         }
 275         printf("%%%.2x", c);
 276 }
 277
 278 /*
 279  * HTTP-decode a string.  The standard explanation is that this turns
 280  * "%4e+foo" into "n foo" in the regular way.  This is done in-place
 281  * over the allocated string.
 282  */
 283 static int
 284 http_decode(char *p)
 285 {
 286         char             hex[3];
 287         int              c;
 288
 289         hex[2] = '\0';
 290
 291         for ( ; '\0' != *p; p++) {
 292                 if ('%' == *p) {
 293                         if ('\0' == (hex[0] = *(p + 1)))
 294                                 return(0);
 295                         if ('\0' == (hex[1] = *(p + 2)))
 296                                 return(0);
 297                         if (1 != sscanf(hex, "%x", &c))
 298                                 return(0);
 299                         if ('\0' == c)
 300                                 return(0);
 301
 302                         *p = (char)c;
 303                         memmove(p + 1, p + 3, strlen(p + 3) + 1);
 304                 } else
 305                         *p = '+' == *p ? ' ' : *p;
 306         }
 307
 308         *p = '\0';
 309         return(1);
 310 }
 311
 312 static void
 313 resp_begin_http(int code, const char *msg)
 314 {
 315
 316         if (200 != code)
 317                 printf("Status: %d %s\n", code, msg);
 318
 319         puts("Content-Type: text/html; charset=utf-8\n"
 320              "Cache-Control: no-cache\n"
 321              "Pragma: no-cache\n"
 322              "");
 323
 324         fflush(stdout);
 325 }
 326
 327 static void
 328 resp_begin_html(int code, const char *msg)
 329 {
 330
 331         resp_begin_http(code, msg);
 332
 333         printf("<!DOCTYPE HTML PUBLIC "
 334                " \"-//W3C//DTD HTML 4.01//EN\""
 335                " \"http://www.w3.org/TR/html4/strict.dtd\">\n"
 336                "<HTML>\n"
 337                "<HEAD>\n"
 338                "<META HTTP-EQUIV=\"Content-Type\""
 339                " CONTENT=\"text/html; charset=utf-8\">\n"
 340                "<LINK REL=\"stylesheet\" HREF=\"%s/man-cgi.css\""
 341                " TYPE=\"text/css\" media=\"all\">\n"
 342                "<LINK REL=\"stylesheet\" HREF=\"%s/man.css\""
 343                " TYPE=\"text/css\" media=\"all\">\n"
 344                "<TITLE>System Manpage Reference</TITLE>\n"
 345                "</HEAD>\n"
 346                "<BODY>\n"
 347                "<!-- Begin page content. //-->\n",
 348                cssdir, cssdir);
 349 }
 350
 351 static void
 352 resp_end_html(void)
 353 {
 354
 355         puts("</BODY>\n"
 356              "</HTML>");
 357 }
 358
 359 static void
 360 resp_searchform(const struct req *req)
 361 {
 362         int              i;
 363
 364         puts("<!-- Begin search form. //-->");
 365         printf("<DIV ID=\"mancgi\">\n"
 366                "<FORM ACTION=\"%s/search\" METHOD=\"get\">\n"
 367                "<FIELDSET>\n"
 368                "<LEGEND>Search Parameters</LEGEND>\n"
 369                "<INPUT TYPE=\"submit\" "
 370                " VALUE=\"Search\"> for manuals matching \n"
 371                "<INPUT TYPE=\"text\" NAME=\"expr\" VALUE=\"",
 372                scriptname);
 373         html_print(req->q.expr ? req->q.expr : "");
 374         printf("\">, section "
 375                "<INPUT TYPE=\"text\""
 376                " SIZE=\"4\" NAME=\"sec\" VALUE=\"");
 377         html_print(req->q.sec ? req->q.sec : "");
 378         printf("\">, arch "
 379                "<INPUT TYPE=\"text\""
 380                " SIZE=\"8\" NAME=\"arch\" VALUE=\"");
 381         html_print(req->q.arch ? req->q.arch : "");
 382         printf("\">");
 383         if (req->psz > 1) {
 384                 puts(", in <SELECT NAME=\"manpath\">");
 385                 for (i = 0; i < (int)req->psz; i++) {
 386                         printf("<OPTION ");
 387                         if (NULL == req->q.manpath ? 0 == i :
 388                             0 == strcmp(req->q.manpath, req->p[i]))
 389                                 printf("SELECTED=\"selected\" ");
 390                         printf("VALUE=\"");
 391                         html_print(req->p[i]);
 392                         printf("\">");
 393                         html_print(req->p[i]);
 394                         puts("</OPTION>");
 395                 }
 396                 puts("</SELECT>");
 397         }
 398         puts("&mdash;\n"
 399              "<INPUT TYPE=\"reset\" VALUE=\"Reset\">\n"
 400              "</FIELDSET>\n"
 401              "</FORM>\n"
 402              "</DIV>");
 403         puts("<!-- End search form. //-->");
 404 }
 405
 406 static void
 407 resp_index(const struct req *req)
 408 {
 409
 410         resp_begin_html(200, NULL);
 411         puts("<H1>\n"
 412              "Online manuals with "
 413              "<A HREF=\"http://mdocml.bsd.lv/\">mandoc</A>\n"
 414              "</H1>");
 415         resp_searchform(req);
 416         puts("<P>\n"
 417              "This web interface is documented in the "
 418              "<A HREF=\"search?expr=Nm~^man\\.cgi$&amp;sec=8\">"
 419              "man.cgi</A> manual, and the "
 420              "<A HREF=\"search?expr=Nm~^apropos$&amp;sec=1\">"
 421              "apropos</A> manual explains the query syntax.\n"
 422              "</P>");
 423         resp_end_html();
 424 }
 425
 426 static void
 427 resp_noresult(const struct req *req, const char *msg)
 428 {
 429         resp_begin_html(200, NULL);
 430         resp_searchform(req);
 431         puts("<P>");
 432         puts(msg);
 433         puts("</P>");
 434         resp_end_html();
 435 }
 436
 437 static void
 438 resp_error_badrequest(const char *msg)
 439 {
 440
 441         resp_begin_html(400, "Bad Request");
 442         puts("<H1>Bad Request</H1>\n"
 443              "<P>\n");
 444         puts(msg);
 445         printf("Try again from the\n"
 446                "<A HREF=\"%s\">main page</A>.\n"
 447                "</P>", scriptname);
 448         resp_end_html();
 449 }
 450
 451 static void
 452 resp_error_notfound(const char *page)
 453 {
 454
 455         resp_begin_html(404, "Not Found");
 456         puts("<H1>Page Not Found</H1>\n"
 457              "<P>\n"
 458              "The page you're looking for, ");
 459         printf("<B>");
 460         html_print(page);
 461         printf("</B>,\n"
 462                "could not be found.\n"
 463                "Try searching from the\n"
 464                "<A HREF=\"%s\">main page</A>.\n"
 465                "</P>", scriptname);
 466         resp_end_html();
 467 }
 468
 469 static void
 470 resp_error_internal(void)
 471 {
 472         resp_begin_html(500, "Internal Server Error");
 473         puts("<P>Internal Server Error</P>");
 474         resp_end_html();
 475 }
 476
 477 static void
 478 resp_search(const struct req *req, struct manpage *r, size_t sz)
 479 {
 480         size_t           i;
 481
 482         if (1 == sz) {
 483                 /*
 484                  * If we have just one result, then jump there now
 485                  * without any delay.
 486                  */
 487                 puts("Status: 303 See Other");
 488                 printf("Location: http://%s%s/show/%s/%s?",
 489                     httphost, scriptname, req->q.manpath, r[0].file);
 490                 http_printquery(req);
 491                 puts("\n"
 492                      "Content-Type: text/html; charset=utf-8\n");
 493                 return;
 494         }
 495
 496         qsort(r, sz, sizeof(struct manpage), cmp);
 497
 498         resp_begin_html(200, NULL);
 499         resp_searchform(req);
 500         puts("<DIV CLASS=\"results\">");
 501         puts("<TABLE>");
 502
 503         for (i = 0; i < sz; i++) {
 504                 printf("<TR>\n"
 505                        "<TD CLASS=\"title\">\n"
 506                        "<A HREF=\"%s/show/%s/%s?",
 507                     scriptname, req->q.manpath, r[i].file);
 508                 html_printquery(req);
 509                 printf("\">");
 510                 html_print(r[i].names);
 511                 printf("</A>\n"
 512                        "</TD>\n"
 513                        "<TD CLASS=\"desc\">");
 514                 html_print(r[i].output);
 515                 puts("</TD>\n"
 516                      "</TR>");
 517         }
 518
 519         puts("</TABLE>\n"
 520              "</DIV>");
 521         resp_end_html();
 522 }
 523
 524 /* ARGSUSED */
 525 static void
 526 pg_index(const struct req *req, char *path)
 527 {
 528
 529         resp_index(req);
 530 }
 531
 532 static void
 533 catman(const struct req *req, const char *file)
 534 {
 535         FILE            *f;
 536         size_t           len;
 537         int              i;
 538         char            *p;
 539         int              italic, bold;
 540
 541         if (NULL == (f = fopen(file, "r"))) {
 542                 resp_error_badrequest(
 543                     "You specified an invalid manual file.");
 544                 return;
 545         }
 546
 547         resp_begin_html(200, NULL);
 548         resp_searchform(req);
 549         puts("<DIV CLASS=\"catman\">\n"
 550              "<PRE>");
 551
 552         while (NULL != (p = fgetln(f, &len))) {
 553                 bold = italic = 0;
 554                 for (i = 0; i < (int)len - 1; i++) {
 555                         /*
 556                          * This means that the catpage is out of state.
 557                          * Ignore it and keep going (although the
 558                          * catpage is bogus).
 559                          */
 560
 561                         if ('\b' == p[i] || '\n' == p[i])
 562                                 continue;
 563
 564                         /*
 565                          * Print a regular character.
 566                          * Close out any bold/italic scopes.
 567                          * If we're in back-space mode, make sure we'll
 568                          * have something to enter when we backspace.
 569                          */
 570
 571                         if ('\b' != p[i + 1]) {
 572                                 if (italic)
 573                                         printf("</I>");
 574                                 if (bold)
 575                                         printf("</B>");
 576                                 italic = bold = 0;
 577                                 html_putchar(p[i]);
 578                                 continue;
 579                         } else if (i + 2 >= (int)len)
 580                                 continue;
 581
 582                         /* Italic mode. */
 583
 584                         if ('_' == p[i]) {
 585                                 if (bold)
 586                                         printf("</B>");
 587                                 if ( ! italic)
 588                                         printf("<I>");
 589                                 bold = 0;
 590                                 italic = 1;
 591                                 i += 2;
 592                                 html_putchar(p[i]);
 593                                 continue;
 594                         }
 595
 596                         /*
 597                          * Handle funny behaviour troff-isms.
 598                          * These grok'd from the original man2html.c.
 599                          */
 600
 601                         if (('+' == p[i] && 'o' == p[i + 2]) ||
 602                                         ('o' == p[i] && '+' == p[i + 2]) ||
 603                                         ('|' == p[i] && '=' == p[i + 2]) ||
 604                                         ('=' == p[i] && '|' == p[i + 2]) ||
 605                                         ('*' == p[i] && '=' == p[i + 2]) ||
 606                                         ('=' == p[i] && '*' == p[i + 2]) ||
 607                                         ('*' == p[i] && '|' == p[i + 2]) ||
 608                                         ('|' == p[i] && '*' == p[i + 2]))  {
 609                                 if (italic)
 610                                         printf("</I>");
 611                                 if (bold)
 612                                         printf("</B>");
 613                                 italic = bold = 0;
 614                                 putchar('*');
 615                                 i += 2;
 616                                 continue;
 617                         } else if (('|' == p[i] && '-' == p[i + 2]) ||
 618                                         ('-' == p[i] && '|' == p[i + 1]) ||
 619                                         ('+' == p[i] && '-' == p[i + 1]) ||
 620                                         ('-' == p[i] && '+' == p[i + 1]) ||
 621                                         ('+' == p[i] && '|' == p[i + 1]) ||
 622                                         ('|' == p[i] && '+' == p[i + 1]))  {
 623                                 if (italic)
 624                                         printf("</I>");
 625                                 if (bold)
 626                                         printf("</B>");
 627                                 italic = bold = 0;
 628                                 putchar('+');
 629                                 i += 2;
 630                                 continue;
 631                         }
 632
 633                         /* Bold mode. */
 634
 635                         if (italic)
 636                                 printf("</I>");
 637                         if ( ! bold)
 638                                 printf("<B>");
 639                         bold = 1;
 640                         italic = 0;
 641                         i += 2;
 642                         html_putchar(p[i]);
 643                 }
 644
 645                 /*
 646                  * Clean up the last character.
 647                  * We can get to a newline; don't print that.
 648                  */
 649
 650                 if (italic)
 651                         printf("</I>");
 652                 if (bold)
 653                         printf("</B>");
 654
 655                 if (i == (int)len - 1 && '\n' != p[i])
 656                         html_putchar(p[i]);
 657
 658                 putchar('\n');
 659         }
 660
 661         puts("</PRE>\n"
 662              "</DIV>\n"
 663              "</BODY>\n"
 664              "</HTML>");
 665
 666         fclose(f);
 667 }
 668
 669 static void
 670 format(const struct req *req, const char *file)
 671 {
 672         struct mparse   *mp;
 673         int              fd;
 674         struct mdoc     *mdoc;
 675         struct man      *man;
 676         void            *vp;
 677         enum mandoclevel rc;
 678         char             opts[PATH_MAX + 128];
 679
 680         if (-1 == (fd = open(file, O_RDONLY, 0))) {
 681                 resp_error_badrequest(
 682                     "You specified an invalid manual file.");
 683                 return;
 684         }
 685
 686         mp = mparse_alloc(MPARSE_SO, MANDOCLEVEL_FATAL, NULL,
 687             req->q.manpath);
 688         rc = mparse_readfd(mp, fd, file);
 689         close(fd);
 690
 691         if (rc >= MANDOCLEVEL_FATAL) {
 692                 fprintf(stderr, "fatal mandoc error: %s/%s\n",
 693                     req->q.manpath, file);
 694                 resp_error_internal();
 695                 return;
 696         }
 697
 698         snprintf(opts, sizeof(opts),
 699             "fragment,man=%s/search?sec=%%S&expr=Nm~^%%N$",
 700             scriptname);
 701
 702         mparse_result(mp, &mdoc, &man, NULL);
 703         if (NULL == man && NULL == mdoc) {
 704                 fprintf(stderr, "fatal mandoc error: %s/%s\n",
 705                     req->q.manpath, file);
 706                 resp_error_internal();
 707                 mparse_free(mp);
 708                 return;
 709         }
 710
 711         resp_begin_html(200, NULL);
 712         resp_searchform(req);
 713
 714         vp = html_alloc(opts);
 715
 716         if (NULL != mdoc)
 717                 html_mdoc(vp, mdoc);
 718         else
 719                 html_man(vp, man);
 720
 721         puts("</BODY>\n"
 722              "</HTML>");
 723
 724         html_free(vp);
 725         mparse_free(mp);
 726 }
 727
 728 static void
 729 pg_show(const struct req *req, char *path)
 730 {
 731         char            *sub;
 732
 733         if (NULL == path || NULL == (sub = strchr(path, '/'))) {
 734                 resp_error_badrequest(
 735                     "You did not specify a page to show.");
 736                 return;
 737         }
 738         *sub++ = '\0';
 739
 740         /*
 741          * Begin by chdir()ing into the manpath.
 742          * This way we can pick up the database files, which are
 743          * relative to the manpath root.
 744          */
 745
 746         if (-1 == chdir(path)) {
 747                 resp_error_badrequest(
 748                     "You specified an invalid manpath.");
 749                 return;
 750         }
 751
 752         if ('c' == *sub)
 753                 catman(req, sub);
 754         else
 755                 format(req, sub);
 756 }
 757
 758 static void
 759 pg_search(const struct req *req, char *path)
 760 {
 761         struct mansearch          search;
 762         struct manpaths           paths;
 763         struct manpage           *res;
 764         char                    **cp;
 765         const char               *ep, *start;
 766         size_t                    ressz;
 767         int                       i, sz;
 768
 769         /*
 770          * Begin by chdir()ing into the root of the manpath.
 771          * This way we can pick up the database files, which are
 772          * relative to the manpath root.
 773          */
 774
 775         if (-1 == (chdir(req->q.manpath))) {
 776                 resp_error_badrequest(
 777                     "You specified an invalid manpath.");
 778                 return;
 779         }
 780
 781         search.arch = req->q.arch;
 782         search.sec = req->q.sec;
 783         search.deftype = TYPE_Nm | TYPE_Nd;
 784         search.flags = 0;
 785
 786         paths.sz = 1;
 787         paths.paths = mandoc_malloc(sizeof(char *));
 788         paths.paths[0] = mandoc_strdup(".");
 789
 790         /*
 791          * Poor man's tokenisation: just break apart by spaces.
 792          * Yes, this is half-ass.  But it works for now.
 793          */
 794
 795         ep = req->q.expr;
 796         while (ep && isspace((unsigned char)*ep))
 797                 ep++;
 798
 799         sz = 0;
 800         cp = NULL;
 801         while (ep && '\0' != *ep) {
 802                 cp = mandoc_reallocarray(cp, sz + 1, sizeof(char *));
 803                 start = ep;
 804                 while ('\0' != *ep && ! isspace((unsigned char)*ep))
 805                         ep++;
 806                 cp[sz] = mandoc_malloc((ep - start) + 1);
 807                 memcpy(cp[sz], start, ep - start);
 808                 cp[sz++][ep - start] = '\0';
 809                 while (isspace((unsigned char)*ep))
 810                         ep++;
 811         }
 812
 813         if (0 == mansearch(&search, &paths, sz, cp, "Nd", &res, &ressz))
 814                 resp_noresult(req, "You entered an invalid query.");
 815         else if (0 == ressz)
 816                 resp_noresult(req, "No results found.");
 817         else
 818                 resp_search(req, res, ressz);
 819
 820         for (i = 0; i < sz; i++)
 821                 free(cp[i]);
 822         free(cp);
 823
 824         for (i = 0; i < (int)ressz; i++) {
 825                 free(res[i].file);
 826                 free(res[i].names);
 827                 free(res[i].output);
 828         }
 829         free(res);
 830
 831         free(paths.paths[0]);
 832         free(paths.paths);
 833 }
 834
 835 int
 836 main(void)
 837 {
 838         int              i;
 839         struct req       req;
 840         char            *querystring, *path, *subpath;
 841
 842         /* Scan our run-time environment. */
 843
 844         if (NULL == (mandir = getenv("MAN_DIR")))
 845                 mandir = "/man";
 846
 847         if (NULL == (scriptname = getenv("SCRIPT_NAME")))
 848                 scriptname = "";
 849
 850         if (NULL == (cssdir = getenv("CSS_DIR")))
 851                 cssdir = "";
 852
 853         if (NULL == (httphost = getenv("HTTP_HOST")))
 854                 httphost = "localhost";
 855
 856         /*
 857          * First we change directory into the mandir so that
 858          * subsequent scanning for manpath directories is rooted
 859          * relative to the same position.
 860          */
 861
 862         if (-1 == chdir(mandir)) {
 863                 fprintf(stderr, "MAN_DIR: %s: %s\n",
 864                     mandir, strerror(errno));
 865                 resp_error_internal();
 866                 return(EXIT_FAILURE);
 867         }
 868
 869         memset(&req, 0, sizeof(struct req));
 870         pathgen(&req);
 871
 872         /* Next parse out the query string. */
 873
 874         if (NULL != (querystring = getenv("QUERY_STRING")))
 875                 http_parse(&req, querystring);
 876
 877         /*
 878          * Now juggle paths to extract information.
 879          * We want to extract our filetype (the file suffix), the
 880          * initial path component, then the trailing component(s).
 881          * Start with leading subpath component.
 882          */
 883
 884         subpath = path = NULL;
 885         req.page = PAGE__MAX;
 886
 887         if (NULL == (path = getenv("PATH_INFO")) || '\0' == *path)
 888                 req.page = PAGE_INDEX;
 889
 890         if (NULL != path && '/' == *path && '\0' == *++path)
 891                 req.page = PAGE_INDEX;
 892
 893         /* Resolve subpath component. */
 894
 895         if (NULL != path && NULL != (subpath = strchr(path, '/')))
 896                 *subpath++ = '\0';
 897
 898         /* Map path into one we recognise. */
 899
 900         if (NULL != path && '\0' != *path)
 901                 for (i = 0; i < (int)PAGE__MAX; i++)
 902                         if (0 == strcmp(pages[i], path)) {
 903                                 req.page = (enum page)i;
 904                                 break;
 905                         }
 906
 907         /* Route pages. */
 908
 909         switch (req.page) {
 910         case (PAGE_INDEX):
 911                 pg_index(&req, subpath);
 912                 break;
 913         case (PAGE_SEARCH):
 914                 pg_search(&req, subpath);
 915                 break;
 916         case (PAGE_SHOW):
 917                 pg_show(&req, subpath);
 918                 break;
 919         default:
 920                 resp_error_notfound(path);
 921                 break;
 922         }
 923
 924         for (i = 0; i < (int)req.psz; i++)
 925                 free(req.p[i]);
 926         free(req.p);
 927         return(EXIT_SUCCESS);
 928 }
 929
 930 static int
 931 cmp(const void *p1, const void *p2)
 932 {
 933
 934         return(strcasecmp(((const struct manpage *)p1)->names,
 935             ((const struct manpage *)p2)->names));
 936 }
 937
 938 /*
 939  * Scan for indexable paths.
 940  */
 941 static void
 942 pathgen(struct req *req)
 943 {
 944         FILE    *fp;
 945         char    *dp;
 946         size_t   dpsz;
 947
 948         if (NULL == (fp = fopen("manpath.conf", "r")))
 949                 return;
 950
 951         while (NULL != (dp = fgetln(fp, &dpsz))) {
 952                 if ('\n' == dp[dpsz - 1])
 953                         dpsz--;
 954                 req->p = mandoc_realloc(req->p,
 955                     (req->psz + 1) * sizeof(char *));
 956                 req->p[req->psz++] = mandoc_strndup(dp, dpsz);
 957         }
 958 }