1 /* $Id: read.c,v 1.10 2011/04/03 10:11:25 kristaps Exp $ */ 2 /* 3 * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv> 4 * Copyright (c) 2010, 2011 Ingo Schwarze <schwarze@openbsd.org> 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 #include <sys/stat.h> 19 #include <sys/mman.h> 20 21 #include <assert.h> 22 #include <ctype.h> 23 #include <fcntl.h> 24 #include <stdarg.h> 25 #include <stdio.h> 26 #include <stdlib.h> 27 #include <string.h> 28 #include <unistd.h> 29 30 #include "mandoc.h" 31 #include "libmandoc.h" 32 #include "mdoc.h" 33 #include "man.h" 34 35 #ifndef MAP_FILE 36 #define MAP_FILE 0 37 #endif 38 39 #define REPARSE_LIMIT 1000 40 41 struct buf { 42 char *buf; /* binary input buffer */ 43 size_t sz; /* size of binary buffer */ 44 }; 45 46 struct mparse { 47 enum mandoclevel file_status; /* status of current parse */ 48 enum mandoclevel wlevel; /* ignore messages below this */ 49 int line; /* line number in the file */ 50 enum mparset inttype; /* which parser to use */ 51 struct man *pman; /* persistent man parser */ 52 struct mdoc *pmdoc; /* persistent mdoc parser */ 53 struct man *man; /* man parser */ 54 struct mdoc *mdoc; /* mdoc parser */ 55 struct roff *roff; /* roff parser (!NULL) */ 56 struct regset regs; /* roff registers */ 57 int reparse_count; /* finite interp. stack */ 58 mandocmsg mmsg; /* warning/error message handler */ 59 void *arg; /* argument to mmsg */ 60 const char *file; 61 }; 62 63 static void resize_buf(struct buf *, size_t); 64 static void mparse_buf_r(struct mparse *, struct buf, int); 65 static void mparse_readfd_r(struct mparse *, int, const char *, int); 66 static void pset(const char *, int, struct mparse *); 67 static void pdesc(struct mparse *, const char *, int); 68 static int read_whole_file(const char *, int, struct buf *, int *); 69 static void mparse_end(struct mparse *); 70 71 static const enum mandocerr mandoclimits[MANDOCLEVEL_MAX] = { 72 MANDOCERR_OK, 73 MANDOCERR_WARNING, 74 MANDOCERR_WARNING, 75 MANDOCERR_ERROR, 76 MANDOCERR_FATAL, 77 MANDOCERR_MAX, 78 MANDOCERR_MAX 79 }; 80 81 static const char * const mandocerrs[MANDOCERR_MAX] = { 82 "ok", 83 84 "generic warning", 85 86 /* related to the prologue */ 87 "no title in document", 88 "document title should be all caps", 89 "unknown manual section", 90 "date missing, using today's date", 91 "cannot parse date, using it verbatim", 92 "prologue macros out of order", 93 "duplicate prologue macro", 94 "macro not allowed in prologue", 95 "macro not allowed in body", 96 97 /* related to document structure */ 98 ".so is fragile, better use ln(1)", 99 "NAME section must come first", 100 "bad NAME section contents", 101 "manual name not yet set", 102 "sections out of conventional order", 103 "duplicate section name", 104 "section not in conventional manual section", 105 106 /* related to macros and nesting */ 107 "skipping obsolete macro", 108 "skipping paragraph macro", 109 "skipping no-space macro", 110 "blocks badly nested", 111 "child violates parent syntax", 112 "nested displays are not portable", 113 "already in literal mode", 114 "line scope broken", 115 116 /* related to missing macro arguments */ 117 "skipping empty macro", 118 "argument count wrong", 119 "missing display type", 120 "list type must come first", 121 "tag lists require a width argument", 122 "missing font type", 123 "skipping end of block that is not open", 124 125 /* related to bad macro arguments */ 126 "skipping argument", 127 "duplicate argument", 128 "duplicate display type", 129 "duplicate list type", 130 "unknown AT&T UNIX version", 131 "bad Boolean value", 132 "unknown font", 133 "unknown standard specifier", 134 "bad width argument", 135 136 /* related to plain text */ 137 "blank line in non-literal context", 138 "tab in non-literal context", 139 "end of line whitespace", 140 "bad comment style", 141 "unknown escape sequence", 142 "unterminated quoted string", 143 144 "generic error", 145 146 /* related to tables */ 147 "bad table syntax", 148 "bad table option", 149 "bad table layout", 150 "no table layout cells specified", 151 "no table data cells specified", 152 "ignore data in cell", 153 "data block still open", 154 "ignoring extra data cells", 155 156 "input stack limit exceeded, infinite loop?", 157 "skipping bad character", 158 "escaped character not allowed in a name", 159 "skipping text before the first section header", 160 "skipping unknown macro", 161 "NOT IMPLEMENTED, please use groff: skipping request", 162 "argument count wrong", 163 "skipping end of block that is not open", 164 "missing end of block", 165 "scope open on exit", 166 "uname(3) system call failed", 167 "macro requires line argument(s)", 168 "macro requires body argument(s)", 169 "macro requires argument(s)", 170 "missing list type", 171 "line argument(s) will be lost", 172 "body argument(s) will be lost", 173 174 "generic fatal error", 175 176 "not a manual", 177 "column syntax is inconsistent", 178 "NOT IMPLEMENTED: .Bd -file", 179 "line scope broken, syntax violated", 180 "argument count wrong, violates syntax", 181 "child violates parent syntax", 182 "argument count wrong, violates syntax", 183 "NOT IMPLEMENTED: .so with absolute path or \"..\"", 184 "no document body", 185 "no document prologue", 186 "static buffer exhausted", 187 }; 188 189 static const char * const mandoclevels[MANDOCLEVEL_MAX] = { 190 "SUCCESS", 191 "RESERVED", 192 "WARNING", 193 "ERROR", 194 "FATAL", 195 "BADARG", 196 "SYSERR" 197 }; 198 199 static void 200 resize_buf(struct buf *buf, size_t initial) 201 { 202 203 buf->sz = buf->sz > initial/2 ? 2 * buf->sz : initial; 204 buf->buf = mandoc_realloc(buf->buf, buf->sz); 205 } 206 207 static void 208 pset(const char *buf, int pos, struct mparse *curp) 209 { 210 int i; 211 212 /* 213 * Try to intuit which kind of manual parser should be used. If 214 * passed in by command-line (-man, -mdoc), then use that 215 * explicitly. If passed as -mandoc, then try to guess from the 216 * line: either skip dot-lines, use -mdoc when finding `.Dt', or 217 * default to -man, which is more lenient. 218 * 219 * Separate out pmdoc/pman from mdoc/man: the first persists 220 * through all parsers, while the latter is used per-parse. 221 */ 222 223 if ('.' == buf[0] || '\'' == buf[0]) { 224 for (i = 1; buf[i]; i++) 225 if (' ' != buf[i] && '\t' != buf[i]) 226 break; 227 if ('\0' == buf[i]) 228 return; 229 } 230 231 switch (curp->inttype) { 232 case (MPARSE_MDOC): 233 if (NULL == curp->pmdoc) 234 curp->pmdoc = mdoc_alloc(&curp->regs, curp); 235 assert(curp->pmdoc); 236 curp->mdoc = curp->pmdoc; 237 return; 238 case (MPARSE_MAN): 239 if (NULL == curp->pman) 240 curp->pman = man_alloc(&curp->regs, curp); 241 assert(curp->pman); 242 curp->man = curp->pman; 243 return; 244 default: 245 break; 246 } 247 248 if (pos >= 3 && 0 == memcmp(buf, ".Dd", 3)) { 249 if (NULL == curp->pmdoc) 250 curp->pmdoc = mdoc_alloc(&curp->regs, curp); 251 assert(curp->pmdoc); 252 curp->mdoc = curp->pmdoc; 253 return; 254 } 255 256 if (NULL == curp->pman) 257 curp->pman = man_alloc(&curp->regs, curp); 258 assert(curp->pman); 259 curp->man = curp->pman; 260 } 261 262 /* 263 * Main parse routine for an opened file. This is called for each 264 * opened file and simply loops around the full input file, possibly 265 * nesting (i.e., with `so'). 266 */ 267 static void 268 mparse_buf_r(struct mparse *curp, struct buf blk, int start) 269 { 270 const struct tbl_span *span; 271 struct buf ln; 272 enum rofferr rr; 273 int i, of, rc; 274 int pos; /* byte number in the ln buffer */ 275 int lnn; /* line number in the real file */ 276 unsigned char c; 277 278 memset(&ln, 0, sizeof(struct buf)); 279 280 lnn = curp->line; 281 pos = 0; 282 283 for (i = 0; i < (int)blk.sz; ) { 284 if (0 == pos && '\0' == blk.buf[i]) 285 break; 286 287 if (start) { 288 curp->line = lnn; 289 curp->reparse_count = 0; 290 } 291 292 while (i < (int)blk.sz && (start || '\0' != blk.buf[i])) { 293 294 /* 295 * When finding an unescaped newline character, 296 * leave the character loop to process the line. 297 * Skip a preceding carriage return, if any. 298 */ 299 300 if ('\r' == blk.buf[i] && i + 1 < (int)blk.sz && 301 '\n' == blk.buf[i + 1]) 302 ++i; 303 if ('\n' == blk.buf[i]) { 304 ++i; 305 ++lnn; 306 break; 307 } 308 309 /* 310 * Warn about bogus characters. If you're using 311 * non-ASCII encoding, you're screwing your 312 * readers. Since I'd rather this not happen, 313 * I'll be helpful and drop these characters so 314 * we don't display gibberish. Note to manual 315 * writers: use special characters. 316 */ 317 318 c = (unsigned char) blk.buf[i]; 319 320 if ( ! (isascii(c) && 321 (isgraph(c) || isblank(c)))) { 322 mandoc_msg(MANDOCERR_BADCHAR, curp, 323 curp->line, pos, "ignoring byte"); 324 i++; 325 continue; 326 } 327 328 /* Trailing backslash = a plain char. */ 329 330 if ('\\' != blk.buf[i] || i + 1 == (int)blk.sz) { 331 if (pos >= (int)ln.sz) 332 resize_buf(&ln, 256); 333 ln.buf[pos++] = blk.buf[i++]; 334 continue; 335 } 336 337 /* 338 * Found escape and at least one other character. 339 * When it's a newline character, skip it. 340 * When there is a carriage return in between, 341 * skip that one as well. 342 */ 343 344 if ('\r' == blk.buf[i + 1] && i + 2 < (int)blk.sz && 345 '\n' == blk.buf[i + 2]) 346 ++i; 347 if ('\n' == blk.buf[i + 1]) { 348 i += 2; 349 ++lnn; 350 continue; 351 } 352 353 if ('"' == blk.buf[i + 1]) { 354 i += 2; 355 /* Comment, skip to end of line */ 356 for (; i < (int)blk.sz; ++i) { 357 if ('\n' == blk.buf[i]) { 358 ++i; 359 ++lnn; 360 break; 361 } 362 } 363 364 /* Backout trailing whitespaces */ 365 for (; pos > 0; --pos) { 366 if (ln.buf[pos - 1] != ' ') 367 break; 368 if (pos > 2 && ln.buf[pos - 2] == '\\') 369 break; 370 } 371 break; 372 } 373 374 /* Some other escape sequence, copy & cont. */ 375 376 if (pos + 1 >= (int)ln.sz) 377 resize_buf(&ln, 256); 378 379 ln.buf[pos++] = blk.buf[i++]; 380 ln.buf[pos++] = blk.buf[i++]; 381 } 382 383 if (pos >= (int)ln.sz) 384 resize_buf(&ln, 256); 385 386 ln.buf[pos] = '\0'; 387 388 /* 389 * A significant amount of complexity is contained by 390 * the roff preprocessor. It's line-oriented but can be 391 * expressed on one line, so we need at times to 392 * readjust our starting point and re-run it. The roff 393 * preprocessor can also readjust the buffers with new 394 * data, so we pass them in wholesale. 395 */ 396 397 of = 0; 398 399 rerun: 400 rr = roff_parseln 401 (curp->roff, curp->line, 402 &ln.buf, &ln.sz, of, &of); 403 404 switch (rr) { 405 case (ROFF_REPARSE): 406 if (REPARSE_LIMIT >= ++curp->reparse_count) 407 mparse_buf_r(curp, ln, 0); 408 else 409 mandoc_msg(MANDOCERR_ROFFLOOP, curp, 410 curp->line, pos, NULL); 411 pos = 0; 412 continue; 413 case (ROFF_APPEND): 414 pos = (int)strlen(ln.buf); 415 continue; 416 case (ROFF_RERUN): 417 goto rerun; 418 case (ROFF_IGN): 419 pos = 0; 420 continue; 421 case (ROFF_ERR): 422 assert(MANDOCLEVEL_FATAL <= curp->file_status); 423 break; 424 case (ROFF_SO): 425 mparse_readfd_r(curp, -1, ln.buf + of, 1); 426 if (MANDOCLEVEL_FATAL <= curp->file_status) 427 break; 428 pos = 0; 429 continue; 430 default: 431 break; 432 } 433 434 /* 435 * If we encounter errors in the recursive parse, make 436 * sure we don't continue parsing. 437 */ 438 439 if (MANDOCLEVEL_FATAL <= curp->file_status) 440 break; 441 442 /* 443 * If input parsers have not been allocated, do so now. 444 * We keep these instanced betwen parsers, but set them 445 * locally per parse routine since we can use different 446 * parsers with each one. 447 */ 448 449 if ( ! (curp->man || curp->mdoc)) 450 pset(ln.buf + of, pos - of, curp); 451 452 /* 453 * Lastly, push down into the parsers themselves. One 454 * of these will have already been set in the pset() 455 * routine. 456 * If libroff returns ROFF_TBL, then add it to the 457 * currently open parse. Since we only get here if 458 * there does exist data (see tbl_data.c), we're 459 * guaranteed that something's been allocated. 460 * Do the same for ROFF_EQN. 461 */ 462 463 rc = -1; 464 465 if (ROFF_TBL == rr) 466 while (NULL != (span = roff_span(curp->roff))) { 467 rc = curp->man ? 468 man_addspan(curp->man, span) : 469 mdoc_addspan(curp->mdoc, span); 470 if (0 == rc) 471 break; 472 } 473 else if (ROFF_EQN == rr) 474 rc = curp->mdoc ? 475 mdoc_addeqn(curp->mdoc, 476 roff_eqn(curp->roff)) : 477 man_addeqn(curp->man, 478 roff_eqn(curp->roff)); 479 else if (curp->man || curp->mdoc) 480 rc = curp->man ? 481 man_parseln(curp->man, 482 curp->line, ln.buf, of) : 483 mdoc_parseln(curp->mdoc, 484 curp->line, ln.buf, of); 485 486 if (0 == rc) { 487 assert(MANDOCLEVEL_FATAL <= curp->file_status); 488 break; 489 } 490 491 /* Temporary buffers typically are not full. */ 492 493 if (0 == start && '\0' == blk.buf[i]) 494 break; 495 496 /* Start the next input line. */ 497 498 pos = 0; 499 } 500 501 free(ln.buf); 502 } 503 504 static void 505 pdesc(struct mparse *curp, const char *file, int fd) 506 { 507 struct buf blk; 508 int with_mmap; 509 510 /* 511 * Run for each opened file; may be called more than once for 512 * each full parse sequence if the opened file is nested (i.e., 513 * from `so'). Simply sucks in the whole file and moves into 514 * the parse phase for the file. 515 */ 516 517 if ( ! read_whole_file(file, fd, &blk, &with_mmap)) { 518 curp->file_status = MANDOCLEVEL_SYSERR; 519 return; 520 } 521 522 /* Line number is per-file. */ 523 524 curp->line = 1; 525 526 mparse_buf_r(curp, blk, 1); 527 528 if (with_mmap) 529 munmap(blk.buf, blk.sz); 530 else 531 free(blk.buf); 532 } 533 534 static int 535 read_whole_file(const char *file, int fd, struct buf *fb, int *with_mmap) 536 { 537 struct stat st; 538 size_t off; 539 ssize_t ssz; 540 541 if (-1 == fstat(fd, &st)) { 542 perror(file); 543 return(0); 544 } 545 546 /* 547 * If we're a regular file, try just reading in the whole entry 548 * via mmap(). This is faster than reading it into blocks, and 549 * since each file is only a few bytes to begin with, I'm not 550 * concerned that this is going to tank any machines. 551 */ 552 553 if (S_ISREG(st.st_mode)) { 554 if (st.st_size >= (1U << 31)) { 555 fprintf(stderr, "%s: input too large\n", file); 556 return(0); 557 } 558 *with_mmap = 1; 559 fb->sz = (size_t)st.st_size; 560 fb->buf = mmap(NULL, fb->sz, PROT_READ, 561 MAP_FILE|MAP_SHARED, fd, 0); 562 if (fb->buf != MAP_FAILED) 563 return(1); 564 } 565 566 /* 567 * If this isn't a regular file (like, say, stdin), then we must 568 * go the old way and just read things in bit by bit. 569 */ 570 571 *with_mmap = 0; 572 off = 0; 573 fb->sz = 0; 574 fb->buf = NULL; 575 for (;;) { 576 if (off == fb->sz) { 577 if (fb->sz == (1U << 31)) { 578 fprintf(stderr, "%s: input too large\n", file); 579 break; 580 } 581 resize_buf(fb, 65536); 582 } 583 ssz = read(fd, fb->buf + (int)off, fb->sz - off); 584 if (ssz == 0) { 585 fb->sz = off; 586 return(1); 587 } 588 if (ssz == -1) { 589 perror(file); 590 break; 591 } 592 off += (size_t)ssz; 593 } 594 595 free(fb->buf); 596 fb->buf = NULL; 597 return(0); 598 } 599 600 static void 601 mparse_end(struct mparse *curp) 602 { 603 604 if (MANDOCLEVEL_FATAL <= curp->file_status) 605 return; 606 607 if (curp->mdoc && ! mdoc_endparse(curp->mdoc)) { 608 assert(MANDOCLEVEL_FATAL <= curp->file_status); 609 return; 610 } 611 612 if (curp->man && ! man_endparse(curp->man)) { 613 assert(MANDOCLEVEL_FATAL <= curp->file_status); 614 return; 615 } 616 617 if ( ! (curp->man || curp->mdoc)) { 618 mandoc_msg(MANDOCERR_NOTMANUAL, curp, 1, 0, NULL); 619 curp->file_status = MANDOCLEVEL_FATAL; 620 return; 621 } 622 623 roff_endparse(curp->roff); 624 } 625 626 static void 627 mparse_readfd_r(struct mparse *curp, int fd, const char *file, int re) 628 { 629 const char *svfile; 630 631 if (-1 == fd) 632 if (-1 == (fd = open(file, O_RDONLY, 0))) { 633 perror(file); 634 curp->file_status = MANDOCLEVEL_SYSERR; 635 return; 636 } 637 638 svfile = curp->file; 639 curp->file = file; 640 641 pdesc(curp, file, fd); 642 643 if (0 == re && MANDOCLEVEL_FATAL > curp->file_status) 644 mparse_end(curp); 645 646 if (STDIN_FILENO != fd && -1 == close(fd)) 647 perror(file); 648 649 curp->file = svfile; 650 } 651 652 enum mandoclevel 653 mparse_readfd(struct mparse *curp, int fd, const char *file) 654 { 655 656 mparse_readfd_r(curp, fd, file, 0); 657 return(curp->file_status); 658 } 659 660 struct mparse * 661 mparse_alloc(enum mparset inttype, enum mandoclevel wlevel, mandocmsg mmsg, void *arg) 662 { 663 struct mparse *curp; 664 665 assert(wlevel <= MANDOCLEVEL_FATAL); 666 667 curp = mandoc_calloc(1, sizeof(struct mparse)); 668 669 curp->wlevel = wlevel; 670 curp->mmsg = mmsg; 671 curp->arg = arg; 672 curp->inttype = inttype; 673 674 curp->roff = roff_alloc(&curp->regs, curp); 675 return(curp); 676 } 677 678 void 679 mparse_reset(struct mparse *curp) 680 { 681 682 memset(&curp->regs, 0, sizeof(struct regset)); 683 684 roff_reset(curp->roff); 685 686 if (curp->mdoc) 687 mdoc_reset(curp->mdoc); 688 if (curp->man) 689 man_reset(curp->man); 690 691 curp->file_status = MANDOCLEVEL_OK; 692 curp->mdoc = NULL; 693 curp->man = NULL; 694 } 695 696 void 697 mparse_free(struct mparse *curp) 698 { 699 700 if (curp->pmdoc) 701 mdoc_free(curp->pmdoc); 702 if (curp->pman) 703 man_free(curp->pman); 704 if (curp->roff) 705 roff_free(curp->roff); 706 707 free(curp); 708 } 709 710 void 711 mparse_result(struct mparse *curp, struct mdoc **mdoc, struct man **man) 712 { 713 714 if (mdoc) 715 *mdoc = curp->mdoc; 716 if (man) 717 *man = curp->man; 718 } 719 720 void 721 mandoc_vmsg(enum mandocerr t, struct mparse *m, 722 int ln, int pos, const char *fmt, ...) 723 { 724 char buf[256]; 725 va_list ap; 726 727 va_start(ap, fmt); 728 vsnprintf(buf, sizeof(buf) - 1, fmt, ap); 729 va_end(ap); 730 731 mandoc_msg(t, m, ln, pos, buf); 732 } 733 734 void 735 mandoc_msg(enum mandocerr er, struct mparse *m, 736 int ln, int col, const char *msg) 737 { 738 enum mandoclevel level; 739 740 level = MANDOCLEVEL_FATAL; 741 while (er < mandoclimits[level]) 742 level--; 743 744 if (level < m->wlevel) 745 return; 746 747 if (m->mmsg) 748 (*m->mmsg)(er, level, m->file, ln, col, msg); 749 750 if (m->file_status < level) 751 m->file_status = level; 752 } 753 754 const char * 755 mparse_strerror(enum mandocerr er) 756 { 757 758 return(mandocerrs[er]); 759 } 760 761 const char * 762 mparse_strlevel(enum mandoclevel lvl) 763 { 764 return(mandoclevels[lvl]); 765 } 766