[BACK]Return to cgi.c CVS log [TXT][DIR] Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/cgi.c between version 1.152 and 1.178

version 1.152, 2017/03/18 16:19:11 version 1.178, 2022/07/05 14:04:25
Line 1 
Line 1 
 /*      $Id$ */  /* $Id$ */
 /*  /*
    * Copyright (c) 2014-2019, 2021, 2022 Ingo Schwarze <schwarze@usta.de>
  * Copyright (c) 2011, 2012 Kristaps Dzonsons <kristaps@bsd.lv>   * Copyright (c) 2011, 2012 Kristaps Dzonsons <kristaps@bsd.lv>
  * Copyright (c) 2014, 2015, 2016, 2017 Ingo Schwarze <schwarze@usta.de>   * Copyright (c) 2022 Anna Vyalkova <cyber@sysrq.in>
  *   *
  * Permission to use, copy, modify, and distribute this software for any   * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above   * purpose with or without fee is hereby granted, provided that the above
Line 14 
Line 15 
  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN   * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF   * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.   * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
    *
    * Implementation of the man.cgi(8) program.
  */   */
 #include "config.h"  #include "config.h"
   
Line 38 
Line 41 
 #include "roff.h"  #include "roff.h"
 #include "mdoc.h"  #include "mdoc.h"
 #include "man.h"  #include "man.h"
   #include "mandoc_parse.h"
 #include "main.h"  #include "main.h"
 #include "manconf.h"  #include "manconf.h"
 #include "mansearch.h"  #include "mansearch.h"
Line 69  enum focus {
Line 73  enum focus {
 static  void             html_print(const char *);  static  void             html_print(const char *);
 static  void             html_putchar(char);  static  void             html_putchar(char);
 static  int              http_decode(char *);  static  int              http_decode(char *);
   static  void             http_encode(const char *);
 static  void             parse_manpath_conf(struct req *);  static  void             parse_manpath_conf(struct req *);
 static  void             parse_path_info(struct req *req, const char *path);  static  void             parse_path_info(struct req *, const char *);
 static  void             parse_query_string(struct req *, const char *);  static  void             parse_query_string(struct req *, const char *);
 static  void             pg_error_badrequest(const char *);  static  void             pg_error_badrequest(const char *);
 static  void             pg_error_internal(void);  static  void             pg_error_internal(void);
 static  void             pg_index(const struct req *);  static  void             pg_index(const struct req *);
 static  void             pg_noresult(const struct req *, const char *);  static  void             pg_noresult(const struct req *, int, const char *,
                                   const char *);
 static  void             pg_redirect(const struct req *, const char *);  static  void             pg_redirect(const struct req *, const char *);
 static  void             pg_search(const struct req *);  static  void             pg_search(const struct req *);
 static  void             pg_searchres(const struct req *,  static  void             pg_searchres(const struct req *,
                                 struct manpage *, size_t);                                  struct manpage *, size_t);
 static  void             pg_show(struct req *, const char *);  static  void             pg_show(struct req *, const char *);
 static  void             resp_begin_html(int, const char *, const char *);  static  int              resp_begin_html(int, const char *, const char *);
 static  void             resp_begin_http(int, const char *);  static  void             resp_begin_http(int, const char *);
 static  void             resp_catman(const struct req *, const char *);  static  void             resp_catman(const struct req *, const char *);
 static  void             resp_copy(const char *);  static  int              resp_copy(const char *, const char *);
 static  void             resp_end_html(void);  static  void             resp_end_html(void);
 static  void             resp_format(const struct req *, const char *);  static  void             resp_format(const struct req *, const char *);
 static  void             resp_searchform(const struct req *, enum focus);  static  void             resp_searchform(const struct req *, enum focus);
 static  void             resp_show(const struct req *, const char *);  static  void             resp_show(const struct req *, const char *);
 static  void             set_query_attr(char **, char **);  static  void             set_query_attr(char **, char **);
   static  int              validate_arch(const char *);
 static  int              validate_filename(const char *);  static  int              validate_filename(const char *);
 static  int              validate_manpath(const struct req *, const char *);  static  int              validate_manpath(const struct req *, const char *);
 static  int              validate_urifrag(const char *);  static  int              validate_urifrag(const char *);
Line 116  static const char *const sec_names[] = {
Line 123  static const char *const sec_names[] = {
 static  const int sec_MAX = sizeof(sec_names) / sizeof(char *);  static  const int sec_MAX = sizeof(sec_names) / sizeof(char *);
   
 static  const char *const arch_names[] = {  static  const char *const arch_names[] = {
     "amd64",       "alpha",       "armv7",      "arm64",      "amd64",       "alpha",       "armv7",       "arm64",
     "hppa",        "i386",        "landisk",      "hppa",        "i386",        "landisk",     "loongson",
     "loongson",    "luna88k",     "macppc",      "mips64",      "luna88k",     "macppc",      "mips64",      "octeon",
     "octeon",      "sgi",         "socppc",      "sparc64",      "powerpc64",   "riscv64",     "sparc64",
   
     "amiga",       "arc",         "armish",      "arm32",      "amiga",       "arc",         "armish",      "arm32",
     "atari",       "aviion",      "beagle",      "cats",      "atari",       "aviion",      "beagle",      "cats",
     "hppa64",      "hp300",      "hppa64",      "hp300",
     "ia64",        "mac68k",      "mvme68k",     "mvme88k",      "ia64",        "mac68k",      "mvme68k",     "mvme88k",
     "mvmeppc",     "palm",        "pc532",       "pegasos",      "mvmeppc",     "palm",        "pc532",       "pegasos",
     "pmax",        "powerpc",     "solbourne",   "sparc",      "pmax",        "powerpc",     "sgi",         "socppc",
       "solbourne",   "sparc",
     "sun3",        "vax",         "wgrisc",      "x68k",      "sun3",        "vax",         "wgrisc",      "x68k",
     "zaurus"      "zaurus"
 };  };
Line 140  html_putchar(char c)
Line 149  html_putchar(char c)
 {  {
   
         switch (c) {          switch (c) {
         case ('"'):          case '"':
                 printf("&quot;");                  printf("&quot;");
                 break;                  break;
         case ('&'):          case '&':
                 printf("&amp;");                  printf("&amp;");
                 break;                  break;
         case ('>'):          case '>':
                 printf("&gt;");                  printf("&gt;");
                 break;                  break;
         case ('<'):          case '<':
                 printf("&lt;");                  printf("&lt;");
                 break;                  break;
         default:          default:
Line 316  http_decode(char *p)
Line 325  http_decode(char *p)
 }  }
   
 static void  static void
   http_encode(const char *p)
   {
           for (; *p != '\0'; p++) {
                   if (isalnum((unsigned char)*p) == 0 &&
                       strchr("-._~", *p) == NULL)
                           printf("%%%2.2X", (unsigned char)*p);
                   else
                           putchar(*p);
           }
   }
   
   static void
 resp_begin_http(int code, const char *msg)  resp_begin_http(int code, const char *msg)
 {  {
   
Line 324  resp_begin_http(int code, const char *msg)
Line 345  resp_begin_http(int code, const char *msg)
   
         printf("Content-Type: text/html; charset=utf-8\r\n"          printf("Content-Type: text/html; charset=utf-8\r\n"
              "Cache-Control: no-cache\r\n"               "Cache-Control: no-cache\r\n"
                "Content-Security-Policy: default-src 'none'; "
                "style-src 'self' 'unsafe-inline'\r\n"
              "Pragma: no-cache\r\n"               "Pragma: no-cache\r\n"
              "\r\n");               "\r\n");
   
         fflush(stdout);          fflush(stdout);
 }  }
   
 static void  static int
 resp_copy(const char *filename)  resp_copy(const char *element, const char *filename)
 {  {
         char     buf[4096];          char     buf[4096];
         ssize_t  sz;          ssize_t  sz;
         int      fd;          int      fd;
   
         if ((fd = open(filename, O_RDONLY)) != -1) {          if ((fd = open(filename, O_RDONLY)) == -1)
                 fflush(stdout);                  return 0;
                 while ((sz = read(fd, buf, sizeof(buf))) > 0)  
                         write(STDOUT_FILENO, buf, sz);          if (element != NULL)
                 close(fd);                  printf("<%s>\n", element);
         }          fflush(stdout);
           while ((sz = read(fd, buf, sizeof(buf))) > 0)
                   write(STDOUT_FILENO, buf, sz);
           close(fd);
           return 1;
 }  }
   
 static void  static int
 resp_begin_html(int code, const char *msg, const char *file)  resp_begin_html(int code, const char *msg, const char *file)
 {  {
         char    *cp;          const char      *name, *sec, *cp;
           int              namesz, secsz;
   
         resp_begin_http(code, msg);          resp_begin_http(code, msg);
   
Line 356  resp_begin_html(int code, const char *msg, const char 
Line 384  resp_begin_html(int code, const char *msg, const char 
                "<html>\n"                 "<html>\n"
                "<head>\n"                 "<head>\n"
                "  <meta charset=\"UTF-8\"/>\n"                 "  <meta charset=\"UTF-8\"/>\n"
                  "  <meta name=\"viewport\""
                         " content=\"width=device-width, initial-scale=1.0\">\n"
                "  <link rel=\"stylesheet\" href=\"%s/mandoc.css\""                 "  <link rel=\"stylesheet\" href=\"%s/mandoc.css\""
                " type=\"text/css\" media=\"all\">\n"                 " type=\"text/css\" media=\"all\">\n"
                "  <title>",                 "  <title>",
                CSS_DIR);                 CSS_DIR);
         if (file != NULL) {          if (file != NULL) {
                 if ((cp = strrchr(file, '/')) != NULL)                  cp = strrchr(file, '/');
                         file = cp + 1;                  name = cp == NULL ? file : cp + 1;
                 if ((cp = strrchr(file, '.')) != NULL) {                  cp = strrchr(name, '.');
                         printf("%.*s(%s) - ", (int)(cp - file), file, cp + 1);                  namesz = cp == NULL ? strlen(name) : cp - name;
                 } else                  sec = NULL;
                         printf("%s - ", file);                  if (cp != NULL && cp[1] != '0') {
                           sec = cp + 1;
                           secsz = strlen(sec);
                   } else if (name - file > 1) {
                           for (cp = name - 2; cp >= file; cp--) {
                                   if (*cp < '1' || *cp > '9')
                                           continue;
                                   sec = cp;
                                   secsz = name - cp - 1;
                                   break;
                           }
                   }
                   printf("%.*s", namesz, name);
                   if (sec != NULL)
                           printf("(%.*s)", secsz, sec);
                   fputs(" - ", stdout);
         }          }
         printf("%s</title>\n"          printf("%s</title>\n"
                "</head>\n"                 "</head>\n"
                "<body>\n",                 "<body>\n",
                CUSTOMIZE_TITLE);                 CUSTOMIZE_TITLE);
   
         resp_copy(MAN_DIR "/header.html");          return resp_copy("header", MAN_DIR "/header.html");
 }  }
   
 static void  static void
 resp_end_html(void)  resp_end_html(void)
 {  {
           if (resp_copy("footer", MAN_DIR "/footer.html"))
                   puts("</footer>");
   
         resp_copy(MAN_DIR "/footer.html");  
   
         puts("</body>\n"          puts("</body>\n"
              "</html>");               "</html>");
 }  }
Line 391  resp_searchform(const struct req *req, enum focus focu
Line 436  resp_searchform(const struct req *req, enum focus focu
 {  {
         int              i;          int              i;
   
         printf("<form action=\"/%s\" method=\"get\">\n"          printf("<form role=\"search\" action=\"/%s\" method=\"get\" "
                  "autocomplete=\"off\" autocapitalize=\"none\">\n"
                "  <fieldset>\n"                 "  <fieldset>\n"
                "    <legend>Manual Page Search Parameters</legend>\n",                 "    <legend>Manual Page Search Parameters</legend>\n",
                scriptname);                 scriptname);
   
         /* Write query input box. */          /* Write query input box. */
   
         printf("    <input type=\"text\" name=\"query\" value=\"");          printf("    <input type=\"search\" name=\"query\" value=\"");
         if (req->q.query != NULL)          if (req->q.query != NULL)
                 html_print(req->q.query);                  html_print(req->q.query);
         printf( "\" size=\"40\"");          printf( "\" size=\"40\"");
Line 416  resp_searchform(const struct req *req, enum focus focu
Line 462  resp_searchform(const struct req *req, enum focus focu
   
         /* Write section selector. */          /* Write section selector. */
   
         puts("    <select name=\"sec\">");          puts("    <select name=\"sec\" aria-label=\"manual section\">");
         for (i = 0; i < sec_MAX; i++) {          for (i = 0; i < sec_MAX; i++) {
                 printf("      <option value=\"%s\"", sec_numbers[i]);                  printf("      <option value=\"%s\"", sec_numbers[i]);
                 if (NULL != req->q.sec &&                  if (NULL != req->q.sec &&
Line 428  resp_searchform(const struct req *req, enum focus focu
Line 474  resp_searchform(const struct req *req, enum focus focu
   
         /* Write architecture selector. */          /* Write architecture selector. */
   
         printf( "    <select name=\"arch\">\n"          printf( "    <select name=\"arch\" aria-label=\"CPU architecture\">\n"
                 "      <option value=\"default\"");                  "      <option value=\"default\"");
         if (NULL == req->q.arch)          if (NULL == req->q.arch)
                 printf(" selected=\"selected\"");                  printf(" selected=\"selected\"");
         puts(">All Architectures</option>");          puts(">All Architectures</option>");
         for (i = 0; i < arch_MAX; i++) {          for (i = 0; i < arch_MAX; i++) {
                 printf("      <option value=\"%s\"", arch_names[i]);                  printf("      <option");
                 if (NULL != req->q.arch &&                  if (NULL != req->q.arch &&
                     0 == strcmp(arch_names[i], req->q.arch))                      0 == strcmp(arch_names[i], req->q.arch))
                         printf(" selected=\"selected\"");                          printf(" selected=\"selected\"");
Line 447  resp_searchform(const struct req *req, enum focus focu
Line 493  resp_searchform(const struct req *req, enum focus focu
         if (req->psz > 1) {          if (req->psz > 1) {
                 puts("    <select name=\"manpath\">");                  puts("    <select name=\"manpath\">");
                 for (i = 0; i < (int)req->psz; i++) {                  for (i = 0; i < (int)req->psz; i++) {
                         printf("      <option ");                          printf("      <option");
                         if (strcmp(req->q.manpath, req->p[i]) == 0)                          if (strcmp(req->q.manpath, req->p[i]) == 0)
                                 printf("selected=\"selected\" ");                                  printf(" selected=\"selected\"");
                         printf("value=\"");                          printf(">");
                         html_print(req->p[i]);                          html_print(req->p[i]);
                         printf("\">");  
                         html_print(req->p[i]);  
                         puts("</option>");                          puts("</option>");
                 }                  }
                 puts("    </select>");                  puts("    </select>");
Line 490  validate_manpath(const struct req *req, const char* ma
Line 534  validate_manpath(const struct req *req, const char* ma
 }  }
   
 static int  static int
   validate_arch(const char *arch)
   {
           int      i;
   
           for (i = 0; i < arch_MAX; i++)
                   if (strcmp(arch, arch_names[i]) == 0)
                           return 1;
   
           return 0;
   }
   
   static int
 validate_filename(const char *file)  validate_filename(const char *file)
 {  {
   
Line 503  validate_filename(const char *file)
Line 559  validate_filename(const char *file)
 static void  static void
 pg_index(const struct req *req)  pg_index(const struct req *req)
 {  {
           if (resp_begin_html(200, NULL, NULL) == 0)
         resp_begin_html(200, NULL, NULL);                  puts("<header>");
         resp_searchform(req, FOCUS_QUERY);          resp_searchform(req, FOCUS_QUERY);
         printf("<p>\n"          printf("</header>\n"
                  "<main>\n"
                  "<p role=\"doc-notice\" aria-label=\"usage\">\n"
                "This web interface is documented in the\n"                 "This web interface is documented in the\n"
                "<a class=\"Xr\" href=\"/%s%sman.cgi.8\">man.cgi(8)</a>\n"                 "<a class=\"Xr\" href=\"/%s%sman.cgi.8\""
                  " aria-label=\"man dot CGI, section 8\">man.cgi(8)</a>\n"
                "manual, and the\n"                 "manual, and the\n"
                "<a class=\"Xr\" href=\"/%s%sapropos.1\">apropos(1)</a>\n"                 "<a class=\"Xr\" href=\"/%s%sapropos.1\""
                  " aria-label=\"apropos, section 1\">apropos(1)</a>\n"
                "manual explains the query syntax.\n"                 "manual explains the query syntax.\n"
                "</p>\n",                 "</p>\n"
                  "</main>\n",
                scriptname, *scriptname == '\0' ? "" : "/",                 scriptname, *scriptname == '\0' ? "" : "/",
                scriptname, *scriptname == '\0' ? "" : "/");                 scriptname, *scriptname == '\0' ? "" : "/");
         resp_end_html();          resp_end_html();
 }  }
   
 static void  static void
 pg_noresult(const struct req *req, const char *msg)  pg_noresult(const struct req *req, int code, const char *http_msg,
       const char *user_msg)
 {  {
         resp_begin_html(200, NULL, NULL);          if (resp_begin_html(code, http_msg, NULL) == 0)
                   puts("<header>");
         resp_searchform(req, FOCUS_QUERY);          resp_searchform(req, FOCUS_QUERY);
         puts("<p>");          puts("</header>");
         puts(msg);          puts("<main>");
           puts("<p role=\"doc-notice\" aria-label=\"no result\">");
           puts(user_msg);
         puts("</p>");          puts("</p>");
           puts("</main>");
         resp_end_html();          resp_end_html();
 }  }
   
 static void  static void
 pg_error_badrequest(const char *msg)  pg_error_badrequest(const char *msg)
 {  {
           if (resp_begin_html(400, "Bad Request", NULL))
         resp_begin_html(400, "Bad Request", NULL);                  puts("</header>");
         puts("<h1>Bad Request</h1>\n"          puts("<main>\n"
              "<p>\n");               "<h1>Bad Request</h1>\n"
                "<p role=\"doc-notice\" aria-label=\"Bad Request\">");
         puts(msg);          puts(msg);
         printf("Try again from the\n"          printf("Try again from the\n"
                "<a href=\"/%s\">main page</a>.\n"                 "<a href=\"/%s\">main page</a>.\n"
                "</p>", scriptname);                 "</p>\n"
                  "</main>\n", scriptname);
         resp_end_html();          resp_end_html();
 }  }
   
 static void  static void
 pg_error_internal(void)  pg_error_internal(void)
 {  {
         resp_begin_html(500, "Internal Server Error", NULL);          if (resp_begin_html(500, "Internal Server Error", NULL))
         puts("<p>Internal Server Error</p>");                  puts("</header>");
           puts("<main><p role=\"doc-notice\">Internal Server Error</p></main>");
         resp_end_html();          resp_end_html();
 }  }
   
 static void  static void
 pg_redirect(const struct req *req, const char *name)  pg_redirect(const struct req *req, const char *name)
 {  {
         printf("Status: 303 See Other\r\n");          printf("Status: 303 See Other\r\n"
         printf("Location: http://%s/", HTTP_HOST);              "Location: /");
         if (*scriptname != '\0')          if (*scriptname != '\0')
                 printf("%s/", scriptname);                  printf("%s/", scriptname);
         if (strcmp(req->q.manpath, req->p[0]))          if (strcmp(req->q.manpath, req->p[0]))
                 printf("%s/", req->q.manpath);                  printf("%s/", req->q.manpath);
         if (req->q.arch != NULL)          if (req->q.arch != NULL)
                 printf("%s/", req->q.arch);                  printf("%s/", req->q.arch);
         printf("%s", name);          http_encode(name);
         if (req->q.sec != NULL)          if (req->q.sec != NULL) {
                 printf(".%s", req->q.sec);                  putchar('.');
                   http_encode(req->q.sec);
           }
         printf("\r\nContent-Type: text/html; charset=utf-8\r\n\r\n");          printf("\r\nContent-Type: text/html; charset=utf-8\r\n\r\n");
 }  }
   
Line 576  pg_searchres(const struct req *req, struct manpage *r,
Line 647  pg_searchres(const struct req *req, struct manpage *r,
         size_t           i, iuse;          size_t           i, iuse;
         int              archprio, archpriouse;          int              archprio, archpriouse;
         int              prio, priouse;          int              prio, priouse;
           int              have_header;
   
         for (i = 0; i < sz; i++) {          for (i = 0; i < sz; i++) {
                 if (validate_filename(r[i].file))                  if (validate_filename(r[i].file))
Line 591  pg_searchres(const struct req *req, struct manpage *r,
Line 663  pg_searchres(const struct req *req, struct manpage *r,
                  * If we have just one result, then jump there now                   * If we have just one result, then jump there now
                  * without any delay.                   * without any delay.
                  */                   */
                 printf("Status: 303 See Other\r\n");                  printf("Status: 303 See Other\r\n"
                 printf("Location: http://%s/%s%s%s/%s",                      "Location: /");
                     HTTP_HOST, scriptname,                  if (*scriptname != '\0')
                     *scriptname == '\0' ? "" : "/",                          printf("%s/", scriptname);
                     req->q.manpath, r[0].file);                  if (strcmp(req->q.manpath, req->p[0]))
                 printf("\r\n"                          printf("%s/", req->q.manpath);
                      "Content-Type: text/html; charset=utf-8\r\n"                  printf("%s\r\n"
                      "\r\n");                      "Content-Type: text/html; charset=utf-8\r\n\r\n",
                       r[0].file);
                 return;                  return;
         }          }
   
Line 641  pg_searchres(const struct req *req, struct manpage *r,
Line 714  pg_searchres(const struct req *req, struct manpage *r,
                         priouse = prio;                          priouse = prio;
                         iuse = i;                          iuse = i;
                 }                  }
                 resp_begin_html(200, NULL, r[iuse].file);                  have_header = resp_begin_html(200, NULL, r[iuse].file);
         } else          } else
                 resp_begin_html(200, NULL, NULL);                  have_header = resp_begin_html(200, NULL, NULL);
   
           if (have_header == 0)
                   puts("<header>");
         resp_searchform(req,          resp_searchform(req,
             req->q.equal || sz == 1 ? FOCUS_NONE : FOCUS_QUERY);              req->q.equal || sz == 1 ? FOCUS_NONE : FOCUS_QUERY);
           puts("</header>");
   
         if (sz > 1) {          if (sz > 1) {
                   puts("<nav>");
                 puts("<table class=\"results\">");                  puts("<table class=\"results\">");
                 for (i = 0; i < sz; i++) {                  for (i = 0; i < sz; i++) {
                         printf("  <tr>\n"                          printf("  <tr>\n"
Line 667  pg_searchres(const struct req *req, struct manpage *r,
Line 744  pg_searchres(const struct req *req, struct manpage *r,
                              "  </tr>");                               "  </tr>");
                 }                  }
                 puts("</table>");                  puts("</table>");
                   puts("</nav>");
         }          }
   
         if (req->q.equal || sz == 1) {          if (req->q.equal || sz == 1) {
Line 688  resp_catman(const struct req *req, const char *file)
Line 766  resp_catman(const struct req *req, const char *file)
         int              italic, bold;          int              italic, bold;
   
         if ((f = fopen(file, "r")) == NULL) {          if ((f = fopen(file, "r")) == NULL) {
                 puts("<p>You specified an invalid manual file.</p>");                  puts("<p role=\"doc-notice\">\n"
                        "  You specified an invalid manual file.\n"
                        "</p>");
                 return;                  return;
         }          }
   
Line 819  resp_format(const struct req *req, const char *file)
Line 899  resp_format(const struct req *req, const char *file)
 {  {
         struct manoutput conf;          struct manoutput conf;
         struct mparse   *mp;          struct mparse   *mp;
         struct roff_man *man;          struct roff_meta *meta;
         void            *vp;          void            *vp;
         int              fd;          int              fd;
         int              usepath;          int              usepath;
   
         if (-1 == (fd = open(file, O_RDONLY, 0))) {          if (-1 == (fd = open(file, O_RDONLY))) {
                 puts("<p>You specified an invalid manual file.</p>");                  puts("<p role=\"doc-notice\">\n"
                        "  You specified an invalid manual file.\n"
                        "</p>");
                 return;                  return;
         }          }
   
         mchars_alloc();          mchars_alloc();
         mp = mparse_alloc(MPARSE_SO | MPARSE_UTF8 | MPARSE_LATIN1,          mp = mparse_alloc(MPARSE_SO | MPARSE_UTF8 | MPARSE_LATIN1 |
             MANDOCLEVEL_BADARG, NULL, req->q.manpath);              MPARSE_VALIDATE, MANDOC_OS_OTHER, req->q.manpath);
         mparse_readfd(mp, fd, file);          mparse_readfd(mp, fd, file);
         close(fd);          close(fd);
           meta = mparse_result(mp);
   
         memset(&conf, 0, sizeof(conf));          memset(&conf, 0, sizeof(conf));
         conf.fragment = 1;          conf.fragment = 1;
Line 843  resp_format(const struct req *req, const char *file)
Line 926  resp_format(const struct req *req, const char *file)
             scriptname, *scriptname == '\0' ? "" : "/",              scriptname, *scriptname == '\0' ? "" : "/",
             usepath ? req->q.manpath : "", usepath ? "/" : "");              usepath ? req->q.manpath : "", usepath ? "/" : "");
   
         mparse_result(mp, &man, NULL);  
         if (man == NULL) {  
                 warnx("fatal mandoc error: %s/%s", req->q.manpath, file);  
                 pg_error_internal();  
                 mparse_free(mp);  
                 mchars_free();  
                 return;  
         }  
   
         vp = html_alloc(&conf);          vp = html_alloc(&conf);
           if (meta->macroset == MACROSET_MDOC)
                   html_mdoc(vp, meta);
           else
                   html_man(vp, meta);
   
         if (man->macroset == MACROSET_MDOC) {  
                 mdoc_validate(man);  
                 html_mdoc(vp, man);  
         } else {  
                 man_validate(man);  
                 html_man(vp, man);  
         }  
   
         html_free(vp);          html_free(vp);
         mparse_free(mp);          mparse_free(mp);
         mchars_free();          mchars_free();
Line 923  pg_show(struct req *req, const char *fullpath)
Line 993  pg_show(struct req *req, const char *fullpath)
                 return;                  return;
         }          }
   
         resp_begin_html(200, NULL, file);          if (resp_begin_html(200, NULL, file) == 0)
                   puts("<header>");
         resp_searchform(req, FOCUS_NONE);          resp_searchform(req, FOCUS_NONE);
           puts("</header>");
         resp_show(req, file);          resp_show(req, file);
         resp_end_html();          resp_end_html();
 }  }
Line 998  pg_search(const struct req *req)
Line 1070  pg_search(const struct req *req)
         if (req->isquery && req->q.equal && argc == 1)          if (req->isquery && req->q.equal && argc == 1)
                 pg_redirect(req, argv[0]);                  pg_redirect(req, argv[0]);
         else if (mansearch(&search, &paths, argc, argv, &res, &ressz) == 0)          else if (mansearch(&search, &paths, argc, argv, &res, &ressz) == 0)
                 pg_noresult(req, "You entered an invalid query.");                  pg_noresult(req, 400, "Bad Request",
                       "You entered an invalid query.");
         else if (ressz == 0)          else if (ressz == 0)
                 pg_noresult(req, "No results found.");                  pg_noresult(req, 404, "Not Found", "No results found.");
         else          else
                 pg_searchres(req, res, ressz);                  pg_searchres(req, res, ressz);
   
Line 1072  main(void)
Line 1145  main(void)
   
         if (*path != '\0') {          if (*path != '\0') {
                 parse_path_info(&req, path);                  parse_path_info(&req, path);
                 if (req.q.manpath == NULL || access(path, F_OK) == -1)                  if (req.q.manpath == NULL || req.q.sec == NULL ||
                       *req.q.query == '\0' || access(path, F_OK) == -1)
                         path = "";                          path = "";
         } else if ((querystring = getenv("QUERY_STRING")) != NULL)          } else if ((querystring = getenv("QUERY_STRING")) != NULL)
                 parse_query_string(&req, querystring);                  parse_query_string(&req, querystring);
Line 1087  main(void)
Line 1161  main(void)
                 return EXIT_FAILURE;                  return EXIT_FAILURE;
         }          }
   
         if ( ! (NULL == req.q.arch || validate_urifrag(req.q.arch))) {          if (req.q.arch != NULL && validate_arch(req.q.arch) == 0) {
                 pg_error_badrequest(                  pg_error_badrequest(
                     "You specified an invalid architecture.");                      "You specified an invalid architecture.");
                 return EXIT_FAILURE;                  return EXIT_FAILURE;
Line 1113  main(void)
Line 1187  main(void)
 }  }
   
 /*  /*
  * If PATH_INFO is not a file name, translate it to a query.   * Translate PATH_INFO to a query.
  */   */
 static void  static void
 parse_path_info(struct req *req, const char *path)  parse_path_info(struct req *req, const char *path)
 {  {
         char    *dir[4];          const char      *name, *sec, *end;
         int      i;  
   
         req->isquery = 0;          req->isquery = 0;
         req->q.equal = 1;          req->q.equal = 1;
         req->q.manpath = mandoc_strdup(path);          req->q.manpath = NULL;
         req->q.arch = NULL;          req->q.arch = NULL;
   
         /* Mandatory manual page name. */          /* Mandatory manual page name. */
         if ((req->q.query = strrchr(req->q.manpath, '/')) == NULL) {          if ((name = strrchr(path, '/')) == NULL)
                 req->q.query = req->q.manpath;                  name = path;
                 req->q.manpath = NULL;          else
         } else                  name++;
                 *req->q.query++ = '\0';  
   
         /* Optional trailing section. */          /* Optional trailing section. */
         if ((req->q.sec = strrchr(req->q.query, '.')) != NULL) {          sec = strrchr(name, '.');
                 if(isdigit((unsigned char)req->q.sec[1])) {          if (sec != NULL && isdigit((unsigned char)*++sec)) {
                         *req->q.sec++ = '\0';                  req->q.query = mandoc_strndup(name, sec - name - 1);
                         req->q.sec = mandoc_strdup(req->q.sec);                  req->q.sec = mandoc_strdup(sec);
                 } else          } else {
                         req->q.sec = NULL;                  req->q.query = mandoc_strdup(name);
                   req->q.sec = NULL;
         }          }
   
         /* Handle the case of name[.section] only. */          /* Handle the case of name[.section] only. */
         if (req->q.manpath == NULL)          if (name == path)
                 return;                  return;
         req->q.query = mandoc_strdup(req->q.query);  
   
         /* Split directory components. */  
         dir[i = 0] = req->q.manpath;  
         while ((dir[i + 1] = strchr(dir[i], '/')) != NULL) {  
                 if (++i == 3) {  
                         pg_error_badrequest(  
                             "You specified too many directory components.");  
                         exit(EXIT_FAILURE);  
                 }  
                 *dir[i]++ = '\0';  
         }  
   
         /* Optional manpath. */          /* Optional manpath. */
         if ((i = validate_manpath(req, req->q.manpath)) == 0)          end = strchr(path, '/');
           req->q.manpath = mandoc_strndup(path, end - path);
           if (validate_manpath(req, req->q.manpath)) {
                   path = end + 1;
                   if (name == path)
                           return;
           } else {
                   free(req->q.manpath);
                 req->q.manpath = NULL;                  req->q.manpath = NULL;
         else if (dir[1] == NULL)          }
                 return;  
   
         /* Optional section. */          /* Optional section. */
         if (strncmp(dir[i], "man", 3) == 0) {          if (strncmp(path, "man", 3) == 0 || strncmp(path, "cat", 3) == 0) {
                   path += 3;
                   end = strchr(path, '/');
                 free(req->q.sec);                  free(req->q.sec);
                 req->q.sec = mandoc_strdup(dir[i++] + 3);                  req->q.sec = mandoc_strndup(path, end - path);
                   path = end + 1;
                   if (name == path)
                           return;
         }          }
         if (dir[i] == NULL) {  
                 if (req->q.manpath == NULL)          /* Optional architecture. */
                         free(dir[0]);          end = strchr(path, '/');
                 return;          if (end + 1 != name) {
                   pg_error_badrequest(
                       "You specified too many directory components.");
                   exit(EXIT_FAILURE);
         }          }
         if (dir[i + 1] != NULL) {          req->q.arch = mandoc_strndup(path, end - path);
           if (validate_arch(req->q.arch) == 0) {
                 pg_error_badrequest(                  pg_error_badrequest(
                     "You specified an invalid directory component.");                      "You specified an invalid directory component.");
                 exit(EXIT_FAILURE);                  exit(EXIT_FAILURE);
         }          }
   
         /* Optional architecture. */  
         if (i) {  
                 req->q.arch = mandoc_strdup(dir[i]);  
                 if (req->q.manpath == NULL)  
                         free(dir[0]);  
         } else  
                 req->q.arch = dir[0];  
 }  }
   
 /*  /*
Legend:
Removed from v.1.152  
changed lines
  Added in v.1.178
CVSweb