]> git.cameronkatri.com Git - mandoc.git/blob - mandocdb.c
git.ckatri.com / mandoc.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
When the -n or -t flag is given to makewhatis(8),
[mandoc.git] / mandocdb.c
1 /* $Id: mandocdb.c,v 1.128 2014/04/04 02:31:07 schwarze Exp $ */
2 /*
3 * Copyright (c) 2011, 2012 Kristaps Dzonsons <kristaps@bsd.lv>
4 * Copyright (c) 2011, 2012, 2013, 2014 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 #ifdef HAVE_CONFIG_H
19 #include "config.h"
20 #endif
21
22 #include <sys/stat.h>
23 #include <sys/wait.h>
24
25 #include <assert.h>
26 #include <ctype.h>
27 #include <errno.h>
28 #include <fcntl.h>
29 #include <fts.h>
30 #include <getopt.h>
31 #include <limits.h>
32 #include <stddef.h>
33 #include <stdio.h>
34 #include <stdint.h>
35 #include <stdlib.h>
36 #include <string.h>
37 #include <unistd.h>
38
39 #ifdef HAVE_OHASH
40 #include <ohash.h>
41 #else
42 #include "compat_ohash.h"
43 #endif
44 #include <sqlite3.h>
45
46 #include "mdoc.h"
47 #include "man.h"
48 #include "mandoc.h"
49 #include "mandoc_aux.h"
50 #include "manpath.h"
51 #include "mansearch.h"
52
53 extern int mansearch_keymax;
54 extern const char *const mansearch_keynames[];
55
56 #define SQL_EXEC(_v) \
57 if (SQLITE_OK != sqlite3_exec(db, (_v), NULL, NULL, NULL)) \
58 fprintf(stderr, "%s\n", sqlite3_errmsg(db))
59 #define SQL_BIND_TEXT(_s, _i, _v) \
60 if (SQLITE_OK != sqlite3_bind_text \
61 ((_s), (_i)++, (_v), -1, SQLITE_STATIC)) \
62 fprintf(stderr, "%s\n", sqlite3_errmsg(db))
63 #define SQL_BIND_INT(_s, _i, _v) \
64 if (SQLITE_OK != sqlite3_bind_int \
65 ((_s), (_i)++, (_v))) \
66 fprintf(stderr, "%s\n", sqlite3_errmsg(db))
67 #define SQL_BIND_INT64(_s, _i, _v) \
68 if (SQLITE_OK != sqlite3_bind_int64 \
69 ((_s), (_i)++, (_v))) \
70 fprintf(stderr, "%s\n", sqlite3_errmsg(db))
71 #define SQL_STEP(_s) \
72 if (SQLITE_DONE != sqlite3_step((_s))) \
73 fprintf(stderr, "%s\n", sqlite3_errmsg(db))
74
75 enum op {
76 OP_DEFAULT = 0, /* new dbs from dir list or default config */
77 OP_CONFFILE, /* new databases from custom config file */
78 OP_UPDATE, /* delete/add entries in existing database */
79 OP_DELETE, /* delete entries from existing database */
80 OP_TEST /* change no databases, report potential problems */
81 };
82
83 enum form {
84 FORM_NONE, /* format is unknown */
85 FORM_SRC, /* format is -man or -mdoc */
86 FORM_CAT /* format is cat */
87 };
88
89 struct str {
90 char *rendered; /* key in UTF-8 or ASCII form */
91 const struct mpage *mpage; /* if set, the owning parse */
92 uint64_t mask; /* bitmask in sequence */
93 char key[]; /* may contain escape sequences */
94 };
95
96 struct inodev {
97 ino_t st_ino;
98 dev_t st_dev;
99 };
100
101 struct mpage {
102 struct inodev inodev; /* used for hashing routine */
103 int64_t recno; /* id in mpages SQL table */
104 enum form form; /* format from file content */
105 char *sec; /* section from file content */
106 char *arch; /* architecture from file content */
107 char *title; /* title from file content */
108 char *desc; /* description from file content */
109 struct mlink *mlinks; /* singly linked list */
110 };
111
112 struct mlink {
113 char file[PATH_MAX]; /* filename rel. to manpath */
114 enum form dform; /* format from directory */
115 enum form fform; /* format from file name suffix */
116 char *dsec; /* section from directory */
117 char *arch; /* architecture from directory */
118 char *name; /* name from file name (not empty) */
119 char *fsec; /* section from file name suffix */
120 struct mlink *next; /* singly linked list */
121 struct mpage *mpage; /* parent */
122 int gzip; /* filename has a .gz suffix */
123 };
124
125 enum stmt {
126 STMT_DELETE_PAGE = 0, /* delete mpage */
127 STMT_INSERT_PAGE, /* insert mpage */
128 STMT_INSERT_LINK, /* insert mlink */
129 STMT_INSERT_KEY, /* insert parsed key */
130 STMT__MAX
131 };
132
133 typedef int (*mdoc_fp)(struct mpage *, const struct mdoc_node *);
134
135 struct mdoc_handler {
136 mdoc_fp fp; /* optional handler */
137 uint64_t mask; /* set unless handler returns 0 */
138 };
139
140 static void dbclose(int);
141 static void dbadd(struct mpage *, struct mchars *);
142 static void dbadd_mlink(const struct mlink *mlink);
143 static int dbopen(int);
144 static void dbprune(void);
145 static void filescan(const char *);
146 static void *hash_alloc(size_t, void *);
147 static void hash_free(void *, size_t, void *);
148 static void *hash_halloc(size_t, void *);
149 static void mlink_add(struct mlink *, const struct stat *);
150 static int mlink_check(struct mpage *, struct mlink *);
151 static void mlink_free(struct mlink *);
152 static void mlinks_undupe(struct mpage *);
153 static void mpages_free(void);
154 static void mpages_merge(struct mchars *, struct mparse *);
155 static void parse_cat(struct mpage *, int);
156 static void parse_man(struct mpage *, const struct man_node *);
157 static void parse_mdoc(struct mpage *, const struct mdoc_node *);
158 static int parse_mdoc_body(struct mpage *, const struct mdoc_node *);
159 static int parse_mdoc_head(struct mpage *, const struct mdoc_node *);
160 static int parse_mdoc_Fd(struct mpage *, const struct mdoc_node *);
161 static int parse_mdoc_Fn(struct mpage *, const struct mdoc_node *);
162 static int parse_mdoc_Nd(struct mpage *, const struct mdoc_node *);
163 static int parse_mdoc_Nm(struct mpage *, const struct mdoc_node *);
164 static int parse_mdoc_Sh(struct mpage *, const struct mdoc_node *);
165 static int parse_mdoc_Xr(struct mpage *, const struct mdoc_node *);
166 static void putkey(const struct mpage *, char *, uint64_t);
167 static void putkeys(const struct mpage *,
168 const char *, size_t, uint64_t);
169 static void putmdockey(const struct mpage *,
170 const struct mdoc_node *, uint64_t);
171 static void render_key(struct mchars *, struct str *);
172 static void say(const char *, const char *, ...);
173 static int set_basedir(const char *);
174 static int treescan(void);
175 static size_t utf8(unsigned int, char [7]);
176
177 static char tempfilename[32];
178 static char *progname;
179 static int nodb; /* no database changes */
180 static int mparse_options; /* abort the parse early */
181 static int use_all; /* use all found files */
182 static int debug; /* print what we're doing */
183 static int warnings; /* warn about crap */
184 static int write_utf8; /* write UTF-8 output; else ASCII */
185 static int exitcode; /* to be returned by main */
186 static enum op op; /* operational mode */
187 static char basedir[PATH_MAX]; /* current base directory */
188 static struct ohash mpages; /* table of distinct manual pages */
189 static struct ohash mlinks; /* table of directory entries */
190 static struct ohash strings; /* table of all strings */
191 static sqlite3 *db = NULL; /* current database */
192 static sqlite3_stmt *stmts[STMT__MAX]; /* current statements */
193
194 static const struct mdoc_handler mdocs[MDOC_MAX] = {
195 { NULL, 0 }, /* Ap */
196 { NULL, 0 }, /* Dd */
197 { NULL, 0 }, /* Dt */
198 { NULL, 0 }, /* Os */
199 { parse_mdoc_Sh, TYPE_Sh }, /* Sh */
200 { parse_mdoc_head, TYPE_Ss }, /* Ss */
201 { NULL, 0 }, /* Pp */
202 { NULL, 0 }, /* D1 */
203 { NULL, 0 }, /* Dl */
204 { NULL, 0 }, /* Bd */
205 { NULL, 0 }, /* Ed */
206 { NULL, 0 }, /* Bl */
207 { NULL, 0 }, /* El */
208 { NULL, 0 }, /* It */
209 { NULL, 0 }, /* Ad */
210 { NULL, TYPE_An }, /* An */
211 { NULL, TYPE_Ar }, /* Ar */
212 { NULL, TYPE_Cd }, /* Cd */
213 { NULL, TYPE_Cm }, /* Cm */
214 { NULL, TYPE_Dv }, /* Dv */
215 { NULL, TYPE_Er }, /* Er */
216 { NULL, TYPE_Ev }, /* Ev */
217 { NULL, 0 }, /* Ex */
218 { NULL, TYPE_Fa }, /* Fa */
219 { parse_mdoc_Fd, 0 }, /* Fd */
220 { NULL, TYPE_Fl }, /* Fl */
221 { parse_mdoc_Fn, 0 }, /* Fn */
222 { NULL, TYPE_Ft }, /* Ft */
223 { NULL, TYPE_Ic }, /* Ic */
224 { NULL, TYPE_In }, /* In */
225 { NULL, TYPE_Li }, /* Li */
226 { parse_mdoc_Nd, TYPE_Nd }, /* Nd */
227 { parse_mdoc_Nm, TYPE_Nm }, /* Nm */
228 { NULL, 0 }, /* Op */
229 { NULL, 0 }, /* Ot */
230 { NULL, TYPE_Pa }, /* Pa */
231 { NULL, 0 }, /* Rv */
232 { NULL, TYPE_St }, /* St */
233 { NULL, TYPE_Va }, /* Va */
234 { parse_mdoc_body, TYPE_Va }, /* Vt */
235 { parse_mdoc_Xr, 0 }, /* Xr */
236 { NULL, 0 }, /* %A */
237 { NULL, 0 }, /* %B */
238 { NULL, 0 }, /* %D */
239 { NULL, 0 }, /* %I */
240 { NULL, 0 }, /* %J */
241 { NULL, 0 }, /* %N */
242 { NULL, 0 }, /* %O */
243 { NULL, 0 }, /* %P */
244 { NULL, 0 }, /* %R */
245 { NULL, 0 }, /* %T */
246 { NULL, 0 }, /* %V */
247 { NULL, 0 }, /* Ac */
248 { NULL, 0 }, /* Ao */
249 { NULL, 0 }, /* Aq */
250 { NULL, TYPE_At }, /* At */
251 { NULL, 0 }, /* Bc */
252 { NULL, 0 }, /* Bf */
253 { NULL, 0 }, /* Bo */
254 { NULL, 0 }, /* Bq */
255 { NULL, TYPE_Bsx }, /* Bsx */
256 { NULL, TYPE_Bx }, /* Bx */
257 { NULL, 0 }, /* Db */
258 { NULL, 0 }, /* Dc */
259 { NULL, 0 }, /* Do */
260 { NULL, 0 }, /* Dq */
261 { NULL, 0 }, /* Ec */
262 { NULL, 0 }, /* Ef */
263 { NULL, TYPE_Em }, /* Em */
264 { NULL, 0 }, /* Eo */
265 { NULL, TYPE_Fx }, /* Fx */
266 { NULL, TYPE_Ms }, /* Ms */
267 { NULL, 0 }, /* No */
268 { NULL, 0 }, /* Ns */
269 { NULL, TYPE_Nx }, /* Nx */
270 { NULL, TYPE_Ox }, /* Ox */
271 { NULL, 0 }, /* Pc */
272 { NULL, 0 }, /* Pf */
273 { NULL, 0 }, /* Po */
274 { NULL, 0 }, /* Pq */
275 { NULL, 0 }, /* Qc */
276 { NULL, 0 }, /* Ql */
277 { NULL, 0 }, /* Qo */
278 { NULL, 0 }, /* Qq */
279 { NULL, 0 }, /* Re */
280 { NULL, 0 }, /* Rs */
281 { NULL, 0 }, /* Sc */
282 { NULL, 0 }, /* So */
283 { NULL, 0 }, /* Sq */
284 { NULL, 0 }, /* Sm */
285 { NULL, 0 }, /* Sx */
286 { NULL, TYPE_Sy }, /* Sy */
287 { NULL, TYPE_Tn }, /* Tn */
288 { NULL, 0 }, /* Ux */
289 { NULL, 0 }, /* Xc */
290 { NULL, 0 }, /* Xo */
291 { parse_mdoc_head, 0 }, /* Fo */
292 { NULL, 0 }, /* Fc */
293 { NULL, 0 }, /* Oo */
294 { NULL, 0 }, /* Oc */
295 { NULL, 0 }, /* Bk */
296 { NULL, 0 }, /* Ek */
297 { NULL, 0 }, /* Bt */
298 { NULL, 0 }, /* Hf */
299 { NULL, 0 }, /* Fr */
300 { NULL, 0 }, /* Ud */
301 { NULL, TYPE_Lb }, /* Lb */
302 { NULL, 0 }, /* Lp */
303 { NULL, TYPE_Lk }, /* Lk */
304 { NULL, TYPE_Mt }, /* Mt */
305 { NULL, 0 }, /* Brq */
306 { NULL, 0 }, /* Bro */
307 { NULL, 0 }, /* Brc */
308 { NULL, 0 }, /* %C */
309 { NULL, 0 }, /* Es */
310 { NULL, 0 }, /* En */
311 { NULL, TYPE_Dx }, /* Dx */
312 { NULL, 0 }, /* %Q */
313 { NULL, 0 }, /* br */
314 { NULL, 0 }, /* sp */
315 { NULL, 0 }, /* %U */
316 { NULL, 0 }, /* Ta */
317 };
318
319 int
320 main(int argc, char *argv[])
321 {
322 int ch, i;
323 size_t j, sz;
324 const char *path_arg;
325 struct mchars *mc;
326 struct manpaths dirs;
327 struct mparse *mp;
328 struct ohash_info mpages_info, mlinks_info;
329
330 memset(stmts, 0, STMT__MAX * sizeof(sqlite3_stmt *));
331 memset(&dirs, 0, sizeof(struct manpaths));
332
333 mpages_info.alloc = mlinks_info.alloc = hash_alloc;
334 mpages_info.halloc = mlinks_info.halloc = hash_halloc;
335 mpages_info.hfree = mlinks_info.hfree = hash_free;
336
337 mpages_info.key_offset = offsetof(struct mpage, inodev);
338 mlinks_info.key_offset = offsetof(struct mlink, file);
339
340 progname = strrchr(argv[0], '/');
341 if (progname == NULL)
342 progname = argv[0];
343 else
344 ++progname;
345
346 /*
347 * We accept a few different invocations.
348 * The CHECKOP macro makes sure that invocation styles don't
349 * clobber each other.
350 */
351 #define CHECKOP(_op, _ch) do \
352 if (OP_DEFAULT != (_op)) { \
353 fprintf(stderr, "-%c: Conflicting option\n", (_ch)); \
354 goto usage; \
355 } while (/*CONSTCOND*/0)
356
357 path_arg = NULL;
358 op = OP_DEFAULT;
359
360 while (-1 != (ch = getopt(argc, argv, "aC:Dd:npQT:tu:v")))
361 switch (ch) {
362 case ('a'):
363 use_all = 1;
364 break;
365 case ('C'):
366 CHECKOP(op, ch);
367 path_arg = optarg;
368 op = OP_CONFFILE;
369 break;
370 case ('D'):
371 debug++;
372 break;
373 case ('d'):
374 CHECKOP(op, ch);
375 path_arg = optarg;
376 op = OP_UPDATE;
377 break;
378 case ('n'):
379 nodb = 1;
380 break;
381 case ('p'):
382 warnings = 1;
383 break;
384 case ('Q'):
385 mparse_options |= MPARSE_QUICK;
386 break;
387 case ('T'):
388 if (strcmp(optarg, "utf8")) {
389 fprintf(stderr, "-T%s: Unsupported "
390 "output format\n", optarg);
391 goto usage;
392 }
393 write_utf8 = 1;
394 break;
395 case ('t'):
396 CHECKOP(op, ch);
397 dup2(STDOUT_FILENO, STDERR_FILENO);
398 op = OP_TEST;
399 nodb = warnings = 1;
400 break;
401 case ('u'):
402 CHECKOP(op, ch);
403 path_arg = optarg;
404 op = OP_DELETE;
405 break;
406 case ('v'):
407 /* Compatibility with espie@'s makewhatis. */
408 break;
409 default:
410 goto usage;
411 }
412
413 argc -= optind;
414 argv += optind;
415
416 if (OP_CONFFILE == op && argc > 0) {
417 fprintf(stderr, "-C: Too many arguments\n");
418 goto usage;
419 }
420
421 exitcode = (int)MANDOCLEVEL_OK;
422 mp = mparse_alloc(mparse_options, MANDOCLEVEL_FATAL, NULL, NULL);
423 mc = mchars_alloc();
424
425 ohash_init(&mpages, 6, &mpages_info);
426 ohash_init(&mlinks, 6, &mlinks_info);
427
428 if (OP_UPDATE == op || OP_DELETE == op || OP_TEST == op) {
429 /*
430 * Force processing all files.
431 */
432 use_all = 1;
433
434 /*
435 * All of these deal with a specific directory.
436 * Jump into that directory then collect files specified
437 * on the command-line.
438 */
439 if (0 == set_basedir(path_arg))
440 goto out;
441 for (i = 0; i < argc; i++)
442 filescan(argv[i]);
443 if (0 == dbopen(1))
444 goto out;
445 if (OP_TEST != op)
446 dbprune();
447 if (OP_DELETE != op)
448 mpages_merge(mc, mp);
449 dbclose(1);
450 } else {
451 /*
452 * If we have arguments, use them as our manpaths.
453 * If we don't, grok from manpath(1) or however else
454 * manpath_parse() wants to do it.
455 */
456 if (argc > 0) {
457 dirs.paths = mandoc_calloc
458 (argc, sizeof(char *));
459 dirs.sz = (size_t)argc;
460 for (i = 0; i < argc; i++)
461 dirs.paths[i] = mandoc_strdup(argv[i]);
462 } else
463 manpath_parse(&dirs, path_arg, NULL, NULL);
464
465 if (0 == dirs.sz) {
466 exitcode = (int)MANDOCLEVEL_BADARG;
467 say("", "Empty manpath");
468 }
469
470 /*
471 * First scan the tree rooted at a base directory, then
472 * build a new database and finally move it into place.
473 * Ignore zero-length directories and strip trailing
474 * slashes.
475 */
476 for (j = 0; j < dirs.sz; j++) {
477 sz = strlen(dirs.paths[j]);
478 if (sz && '/' == dirs.paths[j][sz - 1])
479 dirs.paths[j][--sz] = '\0';
480 if (0 == sz)
481 continue;
482
483 if (j) {
484 ohash_init(&mpages, 6, &mpages_info);
485 ohash_init(&mlinks, 6, &mlinks_info);
486 }
487
488 if (0 == set_basedir(dirs.paths[j]))
489 goto out;
490 if (0 == treescan())
491 goto out;
492 if (0 == set_basedir(dirs.paths[j]))
493 goto out;
494 if (0 == dbopen(0))
495 goto out;
496
497 mpages_merge(mc, mp);
498 dbclose(0);
499
500 if (j + 1 < dirs.sz) {
501 mpages_free();
502 ohash_delete(&mpages);
503 ohash_delete(&mlinks);
504 }
505 }
506 }
507 out:
508 set_basedir(NULL);
509 manpath_free(&dirs);
510 mchars_free(mc);
511 mparse_free(mp);
512 mpages_free();
513 ohash_delete(&mpages);
514 ohash_delete(&mlinks);
515 return(exitcode);
516 usage:
517 fprintf(stderr, "usage: %s [-aDnpQ] [-C file] [-Tutf8]\n"
518 " %s [-aDnpQ] [-Tutf8] dir ...\n"
519 " %s [-DnpQ] [-Tutf8] -d dir [file ...]\n"
520 " %s [-Dnp] -u dir [file ...]\n"
521 " %s [-Q] -t file ...\n",
522 progname, progname, progname,
523 progname, progname);
524
525 return((int)MANDOCLEVEL_BADARG);
526 }
527
528 /*
529 * Scan a directory tree rooted at "basedir" for manpages.
530 * We use fts(), scanning directory parts along the way for clues to our
531 * section and architecture.
532 *
533 * If use_all has been specified, grok all files.
534 * If not, sanitise paths to the following:
535 *
536 * [./]man*[/<arch>]/<name>.<section>
537 * or
538 * [./]cat<section>[/<arch>]/<name>.0
539 *
540 * TODO: accomodate for multi-language directories.
541 */
542 static int
543 treescan(void)
544 {
545 FTS *f;
546 FTSENT *ff;
547 struct mlink *mlink;
548 int dform, gzip;
549 char *dsec, *arch, *fsec, *cp;
550 const char *path;
551 const char *argv[2];
552
553 argv[0] = ".";
554 argv[1] = (char *)NULL;
555
556 /*
557 * Walk through all components under the directory, using the
558 * logical descent of files.
559 */
560 f = fts_open((char * const *)argv, FTS_LOGICAL, NULL);
561 if (NULL == f) {
562 exitcode = (int)MANDOCLEVEL_SYSERR;
563 say("", "&fts_open");
564 return(0);
565 }
566
567 dsec = arch = NULL;
568 dform = FORM_NONE;
569
570 while (NULL != (ff = fts_read(f))) {
571 path = ff->fts_path + 2;
572 /*
573 * If we're a regular file, add an mlink by using the
574 * stored directory data and handling the filename.
575 */
576 if (FTS_F == ff->fts_info) {
577 if (0 == strcmp(path, MANDOC_DB))
578 continue;
579 if ( ! use_all && ff->fts_level < 2) {
580 if (warnings)
581 say(path, "Extraneous file");
582 continue;
583 }
584 gzip = 0;
585 fsec = NULL;
586 while (NULL == fsec) {
587 fsec = strrchr(ff->fts_name, '.');
588 if (NULL == fsec || strcmp(fsec+1, "gz"))
589 break;
590 gzip = 1;
591 *fsec = '\0';
592 fsec = NULL;
593 }
594 if (NULL == fsec) {
595 if ( ! use_all) {
596 if (warnings)
597 say(path,
598 "No filename suffix");
599 continue;
600 }
601 } else if (0 == strcmp(++fsec, "html")) {
602 if (warnings)
603 say(path, "Skip html");
604 continue;
605 } else if (0 == strcmp(fsec, "ps")) {
606 if (warnings)
607 say(path, "Skip ps");
608 continue;
609 } else if (0 == strcmp(fsec, "pdf")) {
610 if (warnings)
611 say(path, "Skip pdf");
612 continue;
613 } else if ( ! use_all &&
614 ((FORM_SRC == dform && strcmp(fsec, dsec)) ||
615 (FORM_CAT == dform && strcmp(fsec, "0")))) {
616 if (warnings)
617 say(path, "Wrong filename suffix");
618 continue;
619 } else
620 fsec[-1] = '\0';
621
622 mlink = mandoc_calloc(1, sizeof(struct mlink));
623 strlcpy(mlink->file, path, sizeof(mlink->file));
624 mlink->dform = dform;
625 mlink->dsec = dsec;
626 mlink->arch = arch;
627 mlink->name = ff->fts_name;
628 mlink->fsec = fsec;
629 mlink->gzip = gzip;
630 mlink_add(mlink, ff->fts_statp);
631 continue;
632 } else if (FTS_D != ff->fts_info &&
633 FTS_DP != ff->fts_info) {
634 if (warnings)
635 say(path, "Not a regular file");
636 continue;
637 }
638
639 switch (ff->fts_level) {
640 case (0):
641 /* Ignore the root directory. */
642 break;
643 case (1):
644 /*
645 * This might contain manX/ or catX/.
646 * Try to infer this from the name.
647 * If we're not in use_all, enforce it.
648 */
649 cp = ff->fts_name;
650 if (FTS_DP == ff->fts_info)
651 break;
652
653 if (0 == strncmp(cp, "man", 3)) {
654 dform = FORM_SRC;
655 dsec = cp + 3;
656 } else if (0 == strncmp(cp, "cat", 3)) {
657 dform = FORM_CAT;
658 dsec = cp + 3;
659 } else {
660 dform = FORM_NONE;
661 dsec = NULL;
662 }
663
664 if (NULL != dsec || use_all)
665 break;
666
667 if (warnings)
668 say(path, "Unknown directory part");
669 fts_set(f, ff, FTS_SKIP);
670 break;
671 case (2):
672 /*
673 * Possibly our architecture.
674 * If we're descending, keep tabs on it.
675 */
676 if (FTS_DP != ff->fts_info && NULL != dsec)
677 arch = ff->fts_name;
678 else
679 arch = NULL;
680 break;
681 default:
682 if (FTS_DP == ff->fts_info || use_all)
683 break;
684 if (warnings)
685 say(path, "Extraneous directory part");
686 fts_set(f, ff, FTS_SKIP);
687 break;
688 }
689 }
690
691 fts_close(f);
692 return(1);
693 }
694
695 /*
696 * Add a file to the mlinks table.
697 * Do not verify that it's a "valid" looking manpage (we'll do that
698 * later).
699 *
700 * Try to infer the manual section, architecture, and page name from the
701 * path, assuming it looks like
702 *
703 * [./]man*[/<arch>]/<name>.<section>
704 * or
705 * [./]cat<section>[/<arch>]/<name>.0
706 *
707 * See treescan() for the fts(3) version of this.
708 */
709 static void
710 filescan(const char *file)
711 {
712 char buf[PATH_MAX];
713 struct stat st;
714 struct mlink *mlink;
715 char *p, *start;
716
717 assert(use_all);
718
719 if (0 == strncmp(file, "./", 2))
720 file += 2;
721
722 if (NULL == realpath(file, buf)) {
723 exitcode = (int)MANDOCLEVEL_BADARG;
724 say(file, "&realpath");
725 return;
726 }
727
728 if (strstr(buf, basedir) == buf)
729 start = buf + strlen(basedir) + 1;
730 else if (OP_TEST == op)
731 start = buf;
732 else {
733 exitcode = (int)MANDOCLEVEL_BADARG;
734 say("", "%s: outside base directory", buf);
735 return;
736 }
737
738 if (-1 == stat(buf, &st)) {
739 exitcode = (int)MANDOCLEVEL_BADARG;
740 say(file, "&stat");
741 return;
742 } else if ( ! (S_IFREG & st.st_mode)) {
743 exitcode = (int)MANDOCLEVEL_BADARG;
744 say(file, "Not a regular file");
745 return;
746 }
747
748 mlink = mandoc_calloc(1, sizeof(struct mlink));
749 strlcpy(mlink->file, start, sizeof(mlink->file));
750
751 /*
752 * First try to guess our directory structure.
753 * If we find a separator, try to look for man* or cat*.
754 * If we find one of these and what's underneath is a directory,
755 * assume it's an architecture.
756 */
757 if (NULL != (p = strchr(start, '/'))) {
758 *p++ = '\0';
759 if (0 == strncmp(start, "man", 3)) {
760 mlink->dform = FORM_SRC;
761 mlink->dsec = start + 3;
762 } else if (0 == strncmp(start, "cat", 3)) {
763 mlink->dform = FORM_CAT;
764 mlink->dsec = start + 3;
765 }
766
767 start = p;
768 if (NULL != mlink->dsec && NULL != (p = strchr(start, '/'))) {
769 *p++ = '\0';
770 mlink->arch = start;
771 start = p;
772 }
773 }
774
775 /*
776 * Now check the file suffix.
777 * Suffix of `.0' indicates a catpage, `.1-9' is a manpage.
778 */
779 p = strrchr(start, '\0');
780 while (p-- > start && '/' != *p && '.' != *p)
781 /* Loop. */ ;
782
783 if ('.' == *p) {
784 *p++ = '\0';
785 mlink->fsec = p;
786 }
787
788 /*
789 * Now try to parse the name.
790 * Use the filename portion of the path.
791 */
792 mlink->name = start;
793 if (NULL != (p = strrchr(start, '/'))) {
794 mlink->name = p + 1;
795 *p = '\0';
796 }
797 mlink_add(mlink, &st);
798 }
799
800 static void
801 mlink_add(struct mlink *mlink, const struct stat *st)
802 {
803 struct inodev inodev;
804 struct mpage *mpage;
805 unsigned int slot;
806
807 assert(NULL != mlink->file);
808
809 mlink->dsec = mandoc_strdup(mlink->dsec ? mlink->dsec : "");
810 mlink->arch = mandoc_strdup(mlink->arch ? mlink->arch : "");
811 mlink->name = mandoc_strdup(mlink->name ? mlink->name : "");
812 mlink->fsec = mandoc_strdup(mlink->fsec ? mlink->fsec : "");
813
814 if ('0' == *mlink->fsec) {
815 free(mlink->fsec);
816 mlink->fsec = mandoc_strdup(mlink->dsec);
817 mlink->fform = FORM_CAT;
818 } else if ('1' <= *mlink->fsec && '9' >= *mlink->fsec)
819 mlink->fform = FORM_SRC;
820 else
821 mlink->fform = FORM_NONE;
822
823 slot = ohash_qlookup(&mlinks, mlink->file);
824 assert(NULL == ohash_find(&mlinks, slot));
825 ohash_insert(&mlinks, slot, mlink);
826
827 inodev.st_ino = st->st_ino;
828 inodev.st_dev = st->st_dev;
829 slot = ohash_lookup_memory(&mpages, (char *)&inodev,
830 sizeof(struct inodev), inodev.st_ino);
831 mpage = ohash_find(&mpages, slot);
832 if (NULL == mpage) {
833 mpage = mandoc_calloc(1, sizeof(struct mpage));
834 mpage->inodev.st_ino = inodev.st_ino;
835 mpage->inodev.st_dev = inodev.st_dev;
836 ohash_insert(&mpages, slot, mpage);
837 } else
838 mlink->next = mpage->mlinks;
839 mpage->mlinks = mlink;
840 mlink->mpage = mpage;
841 }
842
843 static void
844 mlink_free(struct mlink *mlink)
845 {
846
847 free(mlink->dsec);
848 free(mlink->arch);
849 free(mlink->name);
850 free(mlink->fsec);
851 free(mlink);
852 }
853
854 static void
855 mpages_free(void)
856 {
857 struct mpage *mpage;
858 struct mlink *mlink;
859 unsigned int slot;
860
861 mpage = ohash_first(&mpages, &slot);
862 while (NULL != mpage) {
863 while (NULL != (mlink = mpage->mlinks)) {
864 mpage->mlinks = mlink->next;
865 mlink_free(mlink);
866 }
867 free(mpage->sec);
868 free(mpage->arch);
869 free(mpage->title);
870 free(mpage->desc);
871 free(mpage);
872 mpage = ohash_next(&mpages, &slot);
873 }
874 }
875
876 /*
877 * For each mlink to the mpage, check whether the path looks like
878 * it is formatted, and if it does, check whether a source manual
879 * exists by the same name, ignoring the suffix.
880 * If both conditions hold, drop the mlink.
881 */
882 static void
883 mlinks_undupe(struct mpage *mpage)
884 {
885 char buf[PATH_MAX];
886 struct mlink **prev;
887 struct mlink *mlink;
888 char *bufp;
889
890 mpage->form = FORM_CAT;
891 prev = &mpage->mlinks;
892 while (NULL != (mlink = *prev)) {
893 if (FORM_CAT != mlink->dform) {
894 mpage->form = FORM_NONE;
895 goto nextlink;
896 }
897 if (strlcpy(buf, mlink->file, PATH_MAX) >= PATH_MAX) {
898 if (warnings)
899 say(mlink->file, "Filename too long");
900 goto nextlink;
901 }
902 bufp = strstr(buf, "cat");
903 assert(NULL != bufp);
904 memcpy(bufp, "man", 3);
905 if (NULL != (bufp = strrchr(buf, '.')))
906 *++bufp = '\0';
907 strlcat(buf, mlink->dsec, PATH_MAX);
908 if (NULL == ohash_find(&mlinks,
909 ohash_qlookup(&mlinks, buf)))
910 goto nextlink;
911 if (warnings)
912 say(mlink->file, "Man source exists: %s", buf);
913 if (use_all)
914 goto nextlink;
915 *prev = mlink->next;
916 mlink_free(mlink);
917 continue;
918 nextlink:
919 prev = &(*prev)->next;
920 }
921 }
922
923 static int
924 mlink_check(struct mpage *mpage, struct mlink *mlink)
925 {
926 int match;
927
928 match = 1;
929
930 /*
931 * Check whether the manual section given in a file
932 * agrees with the directory where the file is located.
933 * Some manuals have suffixes like (3p) on their
934 * section number either inside the file or in the
935 * directory name, some are linked into more than one
936 * section, like encrypt(1) = makekey(8).
937 */
938
939 if (FORM_SRC == mpage->form &&
940 strcasecmp(mpage->sec, mlink->dsec)) {
941 match = 0;
942 say(mlink->file, "Section \"%s\" manual in %s directory",
943 mpage->sec, mlink->dsec);
944 }
945
946 /*
947 * Manual page directories exist for each kernel
948 * architecture as returned by machine(1).
949 * However, many manuals only depend on the
950 * application architecture as returned by arch(1).
951 * For example, some (2/ARM) manuals are shared
952 * across the "armish" and "zaurus" kernel
953 * architectures.
954 * A few manuals are even shared across completely
955 * different architectures, for example fdformat(1)
956 * on amd64, i386, sparc, and sparc64.
957 */
958
959 if (strcasecmp(mpage->arch, mlink->arch)) {
960 match = 0;
961 say(mlink->file, "Architecture \"%s\" manual in "
962 "\"%s\" directory", mpage->arch, mlink->arch);
963 }
964
965 if (strcasecmp(mpage->title, mlink->name))
966 match = 0;
967
968 return(match);
969 }
970
971 /*
972 * Run through the files in the global vector "mpages"
973 * and add them to the database specified in "basedir".
974 *
975 * This handles the parsing scheme itself, using the cues of directory
976 * and filename to determine whether the file is parsable or not.
977 */
978 static void
979 mpages_merge(struct mchars *mc, struct mparse *mp)
980 {
981 char any[] = "any";
982 struct ohash_info str_info;
983 int fd[2];
984 struct mpage *mpage, *mpage_dest;
985 struct mlink *mlink, *mlink_dest;
986 struct mdoc *mdoc;
987 struct man *man;
988 char *sodest;
989 char *cp;
990 pid_t child_pid;
991 int match, status;
992 unsigned int pslot;
993 enum mandoclevel lvl;
994
995 str_info.alloc = hash_alloc;
996 str_info.halloc = hash_halloc;
997 str_info.hfree = hash_free;
998 str_info.key_offset = offsetof(struct str, key);
999
1000 if (0 == nodb)
1001 SQL_EXEC("BEGIN TRANSACTION");
1002
1003 mpage = ohash_first(&mpages, &pslot);
1004 while (NULL != mpage) {
1005 mlinks_undupe(mpage);
1006 if (NULL == mpage->mlinks) {
1007 mpage = ohash_next(&mpages, &pslot);
1008 continue;
1009 }
1010
1011 ohash_init(&strings, 6, &str_info);
1012 mparse_reset(mp);
1013 mdoc = NULL;
1014 man = NULL;
1015 sodest = NULL;
1016 child_pid = 0;
1017 fd[0] = -1;
1018 fd[1] = -1;
1019
1020 if (mpage->mlinks->gzip) {
1021 if (-1 == pipe(fd)) {
1022 exitcode = (int)MANDOCLEVEL_SYSERR;
1023 say(mpage->mlinks->file, "&pipe gunzip");
1024 goto nextpage;
1025 }
1026 switch (child_pid = fork()) {
1027 case (-1):
1028 exitcode = (int)MANDOCLEVEL_SYSERR;
1029 say(mpage->mlinks->file, "&fork gunzip");
1030 child_pid = 0;
1031 close(fd[1]);
1032 close(fd[0]);
1033 goto nextpage;
1034 case (0):
1035 close(fd[0]);
1036 if (-1 == dup2(fd[1], STDOUT_FILENO)) {
1037 say(mpage->mlinks->file,
1038 "&dup gunzip");
1039 exit(1);
1040 }
1041 execlp("gunzip", "gunzip", "-c",
1042 mpage->mlinks->file, NULL);
1043 say(mpage->mlinks->file, "&exec gunzip");
1044 exit(1);
1045 default:
1046 close(fd[1]);
1047 break;
1048 }
1049 }
1050
1051 /*
1052 * Try interpreting the file as mdoc(7) or man(7)
1053 * source code, unless it is already known to be
1054 * formatted. Fall back to formatted mode.
1055 */
1056 if (FORM_CAT != mpage->mlinks->dform ||
1057 FORM_CAT != mpage->mlinks->fform) {
1058 lvl = mparse_readfd(mp, fd[0], mpage->mlinks->file);
1059 if (lvl < MANDOCLEVEL_FATAL)
1060 mparse_result(mp, &mdoc, &man, &sodest);
1061 }
1062
1063 if (NULL != sodest) {
1064 mlink_dest = ohash_find(&mlinks,
1065 ohash_qlookup(&mlinks, sodest));
1066 if (NULL != mlink_dest) {
1067
1068 /* The .so target exists. */
1069
1070 mpage_dest = mlink_dest->mpage;
1071 mlink = mpage->mlinks;
1072 while (1) {
1073 mlink->mpage = mpage_dest;
1074
1075 /*
1076 * If the target was already
1077 * processed, add the links
1078 * to the database now.
1079 * Otherwise, this will
1080 * happen when we come
1081 * to the target.
1082 */
1083
1084 if (mpage_dest->recno)
1085 dbadd_mlink(mlink);
1086
1087 if (NULL == mlink->next)
1088 break;
1089 mlink = mlink->next;
1090 }
1091
1092 /* Move all links to the target. */
1093
1094 mlink->next = mlink_dest->next;
1095 mlink_dest->next = mpage->mlinks;
1096 mpage->mlinks = NULL;
1097 }
1098 goto nextpage;
1099 } else if (NULL != mdoc) {
1100 mpage->form = FORM_SRC;
1101 mpage->sec =
1102 mandoc_strdup(mdoc_meta(mdoc)->msec);
1103 mpage->arch = mdoc_meta(mdoc)->arch;
1104 mpage->arch = mandoc_strdup(
1105 NULL == mpage->arch ? "" : mpage->arch);
1106 mpage->title =
1107 mandoc_strdup(mdoc_meta(mdoc)->title);
1108 } else if (NULL != man) {
1109 mpage->form = FORM_SRC;
1110 mpage->sec =
1111 mandoc_strdup(man_meta(man)->msec);
1112 mpage->arch =
1113 mandoc_strdup(mpage->mlinks->arch);
1114 mpage->title =
1115 mandoc_strdup(man_meta(man)->title);
1116 } else {
1117 mpage->form = FORM_CAT;
1118 mpage->sec =
1119 mandoc_strdup(mpage->mlinks->dsec);
1120 mpage->arch =
1121 mandoc_strdup(mpage->mlinks->arch);
1122 mpage->title =
1123 mandoc_strdup(mpage->mlinks->name);
1124 }
1125 putkey(mpage, mpage->sec, TYPE_sec);
1126 putkey(mpage, '\0' == *mpage->arch ?
1127 any : mpage->arch, TYPE_arch);
1128
1129 for (mlink = mpage->mlinks; mlink; mlink = mlink->next) {
1130 if ('\0' != *mlink->dsec)
1131 putkey(mpage, mlink->dsec, TYPE_sec);
1132 if ('\0' != *mlink->fsec)
1133 putkey(mpage, mlink->fsec, TYPE_sec);
1134 putkey(mpage, '\0' == *mlink->arch ?
1135 any : mlink->arch, TYPE_arch);
1136 putkey(mpage, mlink->name, TYPE_Nm);
1137 }
1138
1139 if (warnings && !use_all) {
1140 match = 0;
1141 for (mlink = mpage->mlinks; mlink;
1142 mlink = mlink->next)
1143 if (mlink_check(mpage, mlink))
1144 match = 1;
1145 } else
1146 match = 1;
1147
1148 if (NULL != mdoc) {
1149 if (NULL != (cp = mdoc_meta(mdoc)->name))
1150 putkey(mpage, cp, TYPE_Nm);
1151 assert(NULL == mpage->desc);
1152 parse_mdoc(mpage, mdoc_node(mdoc));
1153 putkey(mpage, NULL != mpage->desc ?
1154 mpage->desc : mpage->mlinks->name, TYPE_Nd);
1155 } else if (NULL != man)
1156 parse_man(mpage, man_node(man));
1157 else
1158 parse_cat(mpage, fd[0]);
1159
1160 dbadd(mpage, mc);
1161
1162 nextpage:
1163 if (child_pid) {
1164 if (-1 == waitpid(child_pid, &status, 0)) {
1165 exitcode = (int)MANDOCLEVEL_SYSERR;
1166 say(mpage->mlinks->file, "&wait gunzip");
1167 } else if (WIFSIGNALED(status)) {
1168 exitcode = (int)MANDOCLEVEL_SYSERR;
1169 say(mpage->mlinks->file,
1170 "gunzip died from signal %d",
1171 WTERMSIG(status));
1172 } else if (WEXITSTATUS(status)) {
1173 exitcode = (int)MANDOCLEVEL_SYSERR;
1174 say(mpage->mlinks->file,
1175 "gunzip failed with code %d",
1176 WEXITSTATUS(status));
1177 }
1178 }
1179 ohash_delete(&strings);
1180 mpage = ohash_next(&mpages, &pslot);
1181 }
1182
1183 if (0 == nodb)
1184 SQL_EXEC("END TRANSACTION");
1185 }
1186
1187 static void
1188 parse_cat(struct mpage *mpage, int fd)
1189 {
1190 FILE *stream;
1191 char *line, *p, *title;
1192 size_t len, plen, titlesz;
1193
1194 stream = (-1 == fd) ?
1195 fopen(mpage->mlinks->file, "r") :
1196 fdopen(fd, "r");
1197 if (NULL == stream) {
1198 if (warnings)
1199 say(mpage->mlinks->file, "&fopen");
1200 return;
1201 }
1202
1203 /* Skip to first blank line. */
1204
1205 while (NULL != (line = fgetln(stream, &len)))
1206 if ('\n' == *line)
1207 break;
1208
1209 /*
1210 * Assume the first line that is not indented
1211 * is the first section header. Skip to it.
1212 */
1213
1214 while (NULL != (line = fgetln(stream, &len)))
1215 if ('\n' != *line && ' ' != *line)
1216 break;
1217
1218 /*
1219 * Read up until the next section into a buffer.
1220 * Strip the leading and trailing newline from each read line,
1221 * appending a trailing space.
1222 * Ignore empty (whitespace-only) lines.
1223 */
1224
1225 titlesz = 0;
1226 title = NULL;
1227
1228 while (NULL != (line = fgetln(stream, &len))) {
1229 if (' ' != *line || '\n' != line[len - 1])
1230 break;
1231 while (len > 0 && isspace((unsigned char)*line)) {
1232 line++;
1233 len--;
1234 }
1235 if (1 == len)
1236 continue;
1237 title = mandoc_realloc(title, titlesz + len);
1238 memcpy(title + titlesz, line, len);
1239 titlesz += len;
1240 title[titlesz - 1] = ' ';
1241 }
1242
1243 /*
1244 * If no page content can be found, or the input line
1245 * is already the next section header, or there is no
1246 * trailing newline, reuse the page title as the page
1247 * description.
1248 */
1249
1250 if (NULL == title || '\0' == *title) {
1251 if (warnings)
1252 say(mpage->mlinks->file,
1253 "Cannot find NAME section");
1254 assert(NULL == mpage->desc);
1255 mpage->desc = mandoc_strdup(mpage->mlinks->name);
1256 putkey(mpage, mpage->mlinks->name, TYPE_Nd);
1257 fclose(stream);
1258 free(title);
1259 return;
1260 }
1261
1262 title = mandoc_realloc(title, titlesz + 1);
1263 title[titlesz] = '\0';
1264
1265 /*
1266 * Skip to the first dash.
1267 * Use the remaining line as the description (no more than 70
1268 * bytes).
1269 */
1270
1271 if (NULL != (p = strstr(title, "- "))) {
1272 for (p += 2; ' ' == *p || '\b' == *p; p++)
1273 /* Skip to next word. */ ;
1274 } else {
1275 if (warnings)
1276 say(mpage->mlinks->file,
1277 "No dash in title line");
1278 p = title;
1279 }
1280
1281 plen = strlen(p);
1282
1283 /* Strip backspace-encoding from line. */
1284
1285 while (NULL != (line = memchr(p, '\b', plen))) {
1286 len = line - p;
1287 if (0 == len) {
1288 memmove(line, line + 1, plen--);
1289 continue;
1290 }
1291 memmove(line - 1, line + 1, plen - len);
1292 plen -= 2;
1293 }
1294
1295 assert(NULL == mpage->desc);
1296 mpage->desc = mandoc_strdup(p);
1297 putkey(mpage, mpage->desc, TYPE_Nd);
1298 fclose(stream);
1299 free(title);
1300 }
1301
1302 /*
1303 * Put a type/word pair into the word database for this particular file.
1304 */
1305 static void
1306 putkey(const struct mpage *mpage, char *value, uint64_t type)
1307 {
1308 char *cp;
1309
1310 assert(NULL != value);
1311 if (TYPE_arch == type)
1312 for (cp = value; *cp; cp++)
1313 if (isupper((unsigned char)*cp))
1314 *cp = _tolower((unsigned char)*cp);
1315 putkeys(mpage, value, strlen(value), type);
1316 }
1317
1318 /*
1319 * Grok all nodes at or below a certain mdoc node into putkey().
1320 */
1321 static void
1322 putmdockey(const struct mpage *mpage,
1323 const struct mdoc_node *n, uint64_t m)
1324 {
1325
1326 for ( ; NULL != n; n = n->next) {
1327 if (NULL != n->child)
1328 putmdockey(mpage, n->child, m);
1329 if (MDOC_TEXT == n->type)
1330 putkey(mpage, n->string, m);
1331 }
1332 }
1333
1334 static void
1335 parse_man(struct mpage *mpage, const struct man_node *n)
1336 {
1337 const struct man_node *head, *body;
1338 char *start, *title;
1339 char byte;
1340 size_t sz;
1341
1342 if (NULL == n)
1343 return;
1344
1345 /*
1346 * We're only searching for one thing: the first text child in
1347 * the BODY of a NAME section. Since we don't keep track of
1348 * sections in -man, run some hoops to find out whether we're in
1349 * the correct section or not.
1350 */
1351
1352 if (MAN_BODY == n->type && MAN_SH == n->tok) {
1353 body = n;
1354 assert(body->parent);
1355 if (NULL != (head = body->parent->head) &&
1356 1 == head->nchild &&
1357 NULL != (head = (head->child)) &&
1358 MAN_TEXT == head->type &&
1359 0 == strcmp(head->string, "NAME") &&
1360 NULL != body->child) {
1361
1362 /*
1363 * Suck the entire NAME section into memory.
1364 * Yes, we might run away.
1365 * But too many manuals have big, spread-out
1366 * NAME sections over many lines.
1367 */
1368
1369 title = NULL;
1370 man_deroff(&title, body);
1371 if (NULL == title)
1372 return;
1373
1374 /*
1375 * Go through a special heuristic dance here.
1376 * Conventionally, one or more manual names are
1377 * comma-specified prior to a whitespace, then a
1378 * dash, then a description. Try to puzzle out
1379 * the name parts here.
1380 */
1381
1382 start = title;
1383 for ( ;; ) {
1384 sz = strcspn(start, " ,");
1385 if ('\0' == start[sz])
1386 break;
1387
1388 byte = start[sz];
1389 start[sz] = '\0';
1390
1391 /*
1392 * Assume a stray trailing comma in the
1393 * name list if a name begins with a dash.
1394 */
1395
1396 if ('-' == start[0] ||
1397 ('\\' == start[0] && '-' == start[1]))
1398 break;
1399
1400 putkey(mpage, start, TYPE_Nm);
1401
1402 if (' ' == byte) {
1403 start += sz + 1;
1404 break;
1405 }
1406
1407 assert(',' == byte);
1408 start += sz + 1;
1409 while (' ' == *start)
1410 start++;
1411 }
1412
1413 if (start == title) {
1414 putkey(mpage, start, TYPE_Nm);
1415 free(title);
1416 return;
1417 }
1418
1419 while (isspace((unsigned char)*start))
1420 start++;
1421
1422 if (0 == strncmp(start, "-", 1))
1423 start += 1;
1424 else if (0 == strncmp(start, "\\-\\-", 4))
1425 start += 4;
1426 else if (0 == strncmp(start, "\\-", 2))
1427 start += 2;
1428 else if (0 == strncmp(start, "\\(en", 4))
1429 start += 4;
1430 else if (0 == strncmp(start, "\\(em", 4))
1431 start += 4;
1432
1433 while (' ' == *start)
1434 start++;
1435
1436 assert(NULL == mpage->desc);
1437 mpage->desc = mandoc_strdup(start);
1438 putkey(mpage, mpage->desc, TYPE_Nd);
1439 free(title);
1440 return;
1441 }
1442 }
1443
1444 for (n = n->child; n; n = n->next) {
1445 if (NULL != mpage->desc)
1446 break;
1447 parse_man(mpage, n);
1448 }
1449 }
1450
1451 static void
1452 parse_mdoc(struct mpage *mpage, const struct mdoc_node *n)
1453 {
1454
1455 assert(NULL != n);
1456 for (n = n->child; NULL != n; n = n->next) {
1457 switch (n->type) {
1458 case (MDOC_ELEM):
1459 /* FALLTHROUGH */
1460 case (MDOC_BLOCK):
1461 /* FALLTHROUGH */
1462 case (MDOC_HEAD):
1463 /* FALLTHROUGH */
1464 case (MDOC_BODY):
1465 /* FALLTHROUGH */
1466 case (MDOC_TAIL):
1467 if (NULL != mdocs[n->tok].fp)
1468 if (0 == (*mdocs[n->tok].fp)(mpage, n))
1469 break;
1470 if (mdocs[n->tok].mask)
1471 putmdockey(mpage, n->child,
1472 mdocs[n->tok].mask);
1473 break;
1474 default:
1475 assert(MDOC_ROOT != n->type);
1476 continue;
1477 }
1478 if (NULL != n->child)
1479 parse_mdoc(mpage, n);
1480 }
1481 }
1482
1483 static int
1484 parse_mdoc_Fd(struct mpage *mpage, const struct mdoc_node *n)
1485 {
1486 const char *start, *end;
1487 size_t sz;
1488
1489 if (SEC_SYNOPSIS != n->sec ||
1490 NULL == (n = n->child) ||
1491 MDOC_TEXT != n->type)
1492 return(0);
1493
1494 /*
1495 * Only consider those `Fd' macro fields that begin with an
1496 * "inclusion" token (versus, e.g., #define).
1497 */
1498
1499 if (strcmp("#include", n->string))
1500 return(0);
1501
1502 if (NULL == (n = n->next) || MDOC_TEXT != n->type)
1503 return(0);
1504
1505 /*
1506 * Strip away the enclosing angle brackets and make sure we're
1507 * not zero-length.
1508 */
1509
1510 start = n->string;
1511 if ('<' == *start || '"' == *start)
1512 start++;
1513
1514 if (0 == (sz = strlen(start)))
1515 return(0);
1516
1517 end = &start[(int)sz - 1];
1518 if ('>' == *end || '"' == *end)
1519 end--;
1520
1521 if (end > start)
1522 putkeys(mpage, start, end - start + 1, TYPE_In);
1523 return(0);
1524 }
1525
1526 static int
1527 parse_mdoc_Fn(struct mpage *mpage, const struct mdoc_node *n)
1528 {
1529 char *cp;
1530
1531 if (NULL == (n = n->child) || MDOC_TEXT != n->type)
1532 return(0);
1533
1534 /*
1535 * Parse: .Fn "struct type *name" "char *arg".
1536 * First strip away pointer symbol.
1537 * Then store the function name, then type.
1538 * Finally, store the arguments.
1539 */
1540
1541 if (NULL == (cp = strrchr(n->string, ' ')))
1542 cp = n->string;
1543
1544 while ('*' == *cp)
1545 cp++;
1546
1547 putkey(mpage, cp, TYPE_Fn);
1548
1549 if (n->string < cp)
1550 putkeys(mpage, n->string, cp - n->string, TYPE_Ft);
1551
1552 for (n = n->next; NULL != n; n = n->next)
1553 if (MDOC_TEXT == n->type)
1554 putkey(mpage, n->string, TYPE_Fa);
1555
1556 return(0);
1557 }
1558
1559 static int
1560 parse_mdoc_Xr(struct mpage *mpage, const struct mdoc_node *n)
1561 {
1562 char *cp;
1563
1564 if (NULL == (n = n->child))
1565 return(0);
1566
1567 if (NULL == n->next) {
1568 putkey(mpage, n->string, TYPE_Xr);
1569 return(0);
1570 }
1571
1572 mandoc_asprintf(&cp, "%s(%s)", n->string, n->next->string);
1573 putkey(mpage, cp, TYPE_Xr);
1574 free(cp);
1575 return(0);
1576 }
1577
1578 static int
1579 parse_mdoc_Nd(struct mpage *mpage, const struct mdoc_node *n)
1580 {
1581
1582 if (MDOC_BODY == n->type)
1583 mdoc_deroff(&mpage->desc, n);
1584 return(0);
1585 }
1586
1587 static int
1588 parse_mdoc_Nm(struct mpage *mpage, const struct mdoc_node *n)
1589 {
1590
1591 return(SEC_NAME == n->sec ||
1592 (SEC_SYNOPSIS == n->sec && MDOC_HEAD == n->type));
1593 }
1594
1595 static int
1596 parse_mdoc_Sh(struct mpage *mpage, const struct mdoc_node *n)
1597 {
1598
1599 return(SEC_CUSTOM == n->sec && MDOC_HEAD == n->type);
1600 }
1601
1602 static int
1603 parse_mdoc_head(struct mpage *mpage, const struct mdoc_node *n)
1604 {
1605
1606 return(MDOC_HEAD == n->type);
1607 }
1608
1609 static int
1610 parse_mdoc_body(struct mpage *mpage, const struct mdoc_node *n)
1611 {
1612
1613 return(MDOC_BODY == n->type);
1614 }
1615
1616 /*
1617 * Add a string to the hash table for the current manual.
1618 * Each string has a bitmask telling which macros it belongs to.
1619 * When we finish the manual, we'll dump the table.
1620 */
1621 static void
1622 putkeys(const struct mpage *mpage,
1623 const char *cp, size_t sz, uint64_t v)
1624 {
1625 struct str *s;
1626 const char *end;
1627 uint64_t mask;
1628 unsigned int slot;
1629 int i;
1630
1631 if (0 == sz)
1632 return;
1633
1634 if (debug > 1) {
1635 for (i = 0, mask = 1;
1636 i < mansearch_keymax;
1637 i++, mask <<= 1)
1638 if (mask & v)
1639 break;
1640 say(mpage->mlinks->file, "Adding key %s=%*s",
1641 mansearch_keynames[i], sz, cp);
1642 }
1643
1644 end = cp + sz;
1645 slot = ohash_qlookupi(&strings, cp, &end);
1646 s = ohash_find(&strings, slot);
1647
1648 if (NULL != s && mpage == s->mpage) {
1649 s->mask |= v;
1650 return;
1651 } else if (NULL == s) {
1652 s = mandoc_calloc(sizeof(struct str) + sz + 1, 1);
1653 memcpy(s->key, cp, sz);
1654 ohash_insert(&strings, slot, s);
1655 }
1656 s->mpage = mpage;
1657 s->mask = v;
1658 }
1659
1660 /*
1661 * Take a Unicode codepoint and produce its UTF-8 encoding.
1662 * This isn't the best way to do this, but it works.
1663 * The magic numbers are from the UTF-8 packaging.
1664 * They're not as scary as they seem: read the UTF-8 spec for details.
1665 */
1666 static size_t
1667 utf8(unsigned int cp, char out[7])
1668 {
1669 size_t rc;
1670
1671 rc = 0;
1672 if (cp <= 0x0000007F) {
1673 rc = 1;
1674 out[0] = (char)cp;
1675 } else if (cp <= 0x000007FF) {
1676 rc = 2;
1677 out[0] = (cp >> 6 & 31) | 192;
1678 out[1] = (cp & 63) | 128;
1679 } else if (cp <= 0x0000FFFF) {
1680 rc = 3;
1681 out[0] = (cp >> 12 & 15) | 224;
1682 out[1] = (cp >> 6 & 63) | 128;
1683 out[2] = (cp & 63) | 128;
1684 } else if (cp <= 0x001FFFFF) {
1685 rc = 4;
1686 out[0] = (cp >> 18 & 7) | 240;
1687 out[1] = (cp >> 12 & 63) | 128;
1688 out[2] = (cp >> 6 & 63) | 128;
1689 out[3] = (cp & 63) | 128;
1690 } else if (cp <= 0x03FFFFFF) {
1691 rc = 5;
1692 out[0] = (cp >> 24 & 3) | 248;
1693 out[1] = (cp >> 18 & 63) | 128;
1694 out[2] = (cp >> 12 & 63) | 128;
1695 out[3] = (cp >> 6 & 63) | 128;
1696 out[4] = (cp & 63) | 128;
1697 } else if (cp <= 0x7FFFFFFF) {
1698 rc = 6;
1699 out[0] = (cp >> 30 & 1) | 252;
1700 out[1] = (cp >> 24 & 63) | 128;
1701 out[2] = (cp >> 18 & 63) | 128;
1702 out[3] = (cp >> 12 & 63) | 128;
1703 out[4] = (cp >> 6 & 63) | 128;
1704 out[5] = (cp & 63) | 128;
1705 } else
1706 return(0);
1707
1708 out[rc] = '\0';
1709 return(rc);
1710 }
1711
1712 /*
1713 * Store the rendered version of a key, or alias the pointer
1714 * if the key contains no escape sequences.
1715 */
1716 static void
1717 render_key(struct mchars *mc, struct str *key)
1718 {
1719 size_t sz, bsz, pos;
1720 char utfbuf[7], res[6];
1721 char *buf;
1722 const char *seq, *cpp, *val;
1723 int len, u;
1724 enum mandoc_esc esc;
1725
1726 assert(NULL == key->rendered);
1727
1728 res[0] = '\\';
1729 res[1] = '\t';
1730 res[2] = ASCII_NBRSP;
1731 res[3] = ASCII_HYPH;
1732 res[4] = ASCII_BREAK;
1733 res[5] = '\0';
1734
1735 val = key->key;
1736 bsz = strlen(val);
1737
1738 /*
1739 * Pre-check: if we have no stop-characters, then set the
1740 * pointer as ourselvse and get out of here.
1741 */
1742 if (strcspn(val, res) == bsz) {
1743 key->rendered = key->key;
1744 return;
1745 }
1746
1747 /* Pre-allocate by the length of the input */
1748
1749 buf = mandoc_malloc(++bsz);
1750 pos = 0;
1751
1752 while ('\0' != *val) {
1753 /*
1754 * Halt on the first escape sequence.
1755 * This also halts on the end of string, in which case
1756 * we just copy, fallthrough, and exit the loop.
1757 */
1758 if ((sz = strcspn(val, res)) > 0) {
1759 memcpy(&buf[pos], val, sz);
1760 pos += sz;
1761 val += sz;
1762 }
1763
1764 switch (*val) {
1765 case (ASCII_HYPH):
1766 buf[pos++] = '-';
1767 val++;
1768 continue;
1769 case ('\t'):
1770 /* FALLTHROUGH */
1771 case (ASCII_NBRSP):
1772 buf[pos++] = ' ';
1773 val++;
1774 /* FALLTHROUGH */
1775 case (ASCII_BREAK):
1776 continue;
1777 default:
1778 break;
1779 }
1780 if ('\\' != *val)
1781 break;
1782
1783 /* Read past the slash. */
1784
1785 val++;
1786
1787 /*
1788 * Parse the escape sequence and see if it's a
1789 * predefined character or special character.
1790 */
1791
1792 esc = mandoc_escape
1793 ((const char **)&val, &seq, &len);
1794 if (ESCAPE_ERROR == esc)
1795 break;
1796 if (ESCAPE_SPECIAL != esc)
1797 continue;
1798
1799 /*
1800 * Render the special character
1801 * as either UTF-8 or ASCII.
1802 */
1803
1804 if (write_utf8) {
1805 if (0 == (u = mchars_spec2cp(mc, seq, len)))
1806 continue;
1807 cpp = utfbuf;
1808 if (0 == (sz = utf8(u, utfbuf)))
1809 continue;
1810 sz = strlen(cpp);
1811 } else {
1812 cpp = mchars_spec2str(mc, seq, len, &sz);
1813 if (NULL == cpp)
1814 continue;
1815 if (ASCII_NBRSP == *cpp) {
1816 cpp = " ";
1817 sz = 1;
1818 }
1819 }
1820
1821 /* Copy the rendered glyph into the stream. */
1822
1823 bsz += sz;
1824 buf = mandoc_realloc(buf, bsz);
1825 memcpy(&buf[pos], cpp, sz);
1826 pos += sz;
1827 }
1828
1829 buf[pos] = '\0';
1830 key->rendered = buf;
1831 }
1832
1833 static void
1834 dbadd_mlink(const struct mlink *mlink)
1835 {
1836 size_t i;
1837
1838 i = 1;
1839 SQL_BIND_TEXT(stmts[STMT_INSERT_LINK], i, mlink->dsec);
1840 SQL_BIND_TEXT(stmts[STMT_INSERT_LINK], i, mlink->arch);
1841 SQL_BIND_TEXT(stmts[STMT_INSERT_LINK], i, mlink->name);
1842 SQL_BIND_INT64(stmts[STMT_INSERT_LINK], i, mlink->mpage->recno);
1843 SQL_STEP(stmts[STMT_INSERT_LINK]);
1844 sqlite3_reset(stmts[STMT_INSERT_LINK]);
1845 }
1846
1847 /*
1848 * Flush the current page's terms (and their bits) into the database.
1849 * Wrap the entire set of additions in a transaction to make sqlite be a
1850 * little faster.
1851 * Also, handle escape sequences at the last possible moment.
1852 */
1853 static void
1854 dbadd(struct mpage *mpage, struct mchars *mc)
1855 {
1856 struct mlink *mlink;
1857 struct str *key;
1858 size_t i;
1859 unsigned int slot;
1860
1861 mlink = mpage->mlinks;
1862
1863 if (nodb) {
1864 while (NULL != mlink) {
1865 fputs(mlink->name, stdout);
1866 if (NULL == mlink->next ||
1867 strcmp(mlink->dsec, mlink->next->dsec) ||
1868 strcmp(mlink->fsec, mlink->next->fsec) ||
1869 strcmp(mlink->arch, mlink->next->arch)) {
1870 putchar('(');
1871 if ('\0' == *mlink->dsec)
1872 fputs(mlink->fsec, stdout);
1873 else
1874 fputs(mlink->dsec, stdout);
1875 if ('\0' != *mlink->arch)
1876 printf("/%s", mlink->arch);
1877 putchar(')');
1878 }
1879 mlink = mlink->next;
1880 if (NULL != mlink)
1881 fputs(", ", stdout);
1882 }
1883 for (key = ohash_first(&strings, &slot); NULL != key;
1884 key = ohash_next(&strings, &slot)) {
1885 if (TYPE_Nd & key->mask) {
1886 if (NULL == key->rendered)
1887 render_key(mc, key);
1888 printf(" - %s", key->rendered);
1889 break;
1890 }
1891 }
1892 putchar('\n');
1893 return;
1894 }
1895
1896 if (debug)
1897 say(mlink->file, "Adding to database");
1898
1899 i = 1;
1900 SQL_BIND_INT(stmts[STMT_INSERT_PAGE], i, FORM_SRC == mpage->form);
1901 SQL_STEP(stmts[STMT_INSERT_PAGE]);
1902 mpage->recno = sqlite3_last_insert_rowid(db);
1903 sqlite3_reset(stmts[STMT_INSERT_PAGE]);
1904
1905 while (NULL != mlink) {
1906 dbadd_mlink(mlink);
1907 mlink = mlink->next;
1908 }
1909
1910 for (key = ohash_first(&strings, &slot); NULL != key;
1911 key = ohash_next(&strings, &slot)) {
1912 assert(key->mpage == mpage);
1913 if (NULL == key->rendered)
1914 render_key(mc, key);
1915 i = 1;
1916 SQL_BIND_INT64(stmts[STMT_INSERT_KEY], i, key->mask);
1917 SQL_BIND_TEXT(stmts[STMT_INSERT_KEY], i, key->rendered);
1918 SQL_BIND_INT64(stmts[STMT_INSERT_KEY], i, mpage->recno);
1919 SQL_STEP(stmts[STMT_INSERT_KEY]);
1920 sqlite3_reset(stmts[STMT_INSERT_KEY]);
1921 if (key->rendered != key->key)
1922 free(key->rendered);
1923 free(key);
1924 }
1925 }
1926
1927 static void
1928 dbprune(void)
1929 {
1930 struct mpage *mpage;
1931 struct mlink *mlink;
1932 size_t i;
1933 unsigned int slot;
1934
1935 if (0 == nodb)
1936 SQL_EXEC("BEGIN TRANSACTION");
1937
1938 for (mpage = ohash_first(&mpages, &slot); NULL != mpage;
1939 mpage = ohash_next(&mpages, &slot)) {
1940 mlink = mpage->mlinks;
1941 if (debug)
1942 say(mlink->file, "Deleting from database");
1943 if (nodb)
1944 continue;
1945 for ( ; NULL != mlink; mlink = mlink->next) {
1946 i = 1;
1947 SQL_BIND_TEXT(stmts[STMT_DELETE_PAGE],
1948 i, mlink->dsec);
1949 SQL_BIND_TEXT(stmts[STMT_DELETE_PAGE],
1950 i, mlink->arch);
1951 SQL_BIND_TEXT(stmts[STMT_DELETE_PAGE],
1952 i, mlink->name);
1953 SQL_STEP(stmts[STMT_DELETE_PAGE]);
1954 sqlite3_reset(stmts[STMT_DELETE_PAGE]);
1955 }
1956 }
1957
1958 if (0 == nodb)
1959 SQL_EXEC("END TRANSACTION");
1960 }
1961
1962 /*
1963 * Close an existing database and its prepared statements.
1964 * If "real" is not set, rename the temporary file into the real one.
1965 */
1966 static void
1967 dbclose(int real)
1968 {
1969 size_t i;
1970 int status;
1971 pid_t child;
1972
1973 if (nodb)
1974 return;
1975
1976 for (i = 0; i < STMT__MAX; i++) {
1977 sqlite3_finalize(stmts[i]);
1978 stmts[i] = NULL;
1979 }
1980
1981 sqlite3_close(db);
1982 db = NULL;
1983
1984 if (real)
1985 return;
1986
1987 if ('\0' == *tempfilename) {
1988 if (-1 == rename(MANDOC_DB "~", MANDOC_DB)) {
1989 exitcode = (int)MANDOCLEVEL_SYSERR;
1990 say(MANDOC_DB, "&rename");
1991 }
1992 return;
1993 }
1994
1995 switch (child = fork()) {
1996 case (-1):
1997 exitcode = (int)MANDOCLEVEL_SYSERR;
1998 say("", "&fork cmp");
1999 return;
2000 case (0):
2001 execlp("cmp", "cmp", "-s",
2002 tempfilename, MANDOC_DB, NULL);
2003 say("", "&exec cmp");
2004 exit(0);
2005 default:
2006 break;
2007 }
2008 if (-1 == waitpid(child, &status, 0)) {
2009 exitcode = (int)MANDOCLEVEL_SYSERR;
2010 say("", "&wait cmp");
2011 } else if (WIFSIGNALED(status)) {
2012 exitcode = (int)MANDOCLEVEL_SYSERR;
2013 say("", "cmp died from signal %d", WTERMSIG(status));
2014 } else if (WEXITSTATUS(status)) {
2015 exitcode = (int)MANDOCLEVEL_SYSERR;
2016 say(MANDOC_DB,
2017 "Data changed, but cannot replace database");
2018 }
2019
2020 *strrchr(tempfilename, '/') = '\0';
2021 switch (child = fork()) {
2022 case (-1):
2023 exitcode = (int)MANDOCLEVEL_SYSERR;
2024 say("", "&fork rm");
2025 return;
2026 case (0):
2027 execlp("rm", "rm", "-rf", tempfilename, NULL);
2028 say("", "&exec rm");
2029 exit((int)MANDOCLEVEL_SYSERR);
2030 default:
2031 break;
2032 }
2033 if (-1 == waitpid(child, &status, 0)) {
2034 exitcode = (int)MANDOCLEVEL_SYSERR;
2035 say("", "&wait rm");
2036 } else if (WIFSIGNALED(status) || WEXITSTATUS(status)) {
2037 exitcode = (int)MANDOCLEVEL_SYSERR;
2038 say("", "%s: Cannot remove temporary directory",
2039 tempfilename);
2040 }
2041 }
2042
2043 /*
2044 * This is straightforward stuff.
2045 * Open a database connection to a "temporary" database, then open a set
2046 * of prepared statements we'll use over and over again.
2047 * If "real" is set, we use the existing database; if not, we truncate a
2048 * temporary one.
2049 * Must be matched by dbclose().
2050 */
2051 static int
2052 dbopen(int real)
2053 {
2054 const char *sql;
2055 int rc, ofl;
2056
2057 if (nodb)
2058 return(1);
2059
2060 *tempfilename = '\0';
2061 ofl = SQLITE_OPEN_READWRITE;
2062
2063 if (real) {
2064 rc = sqlite3_open_v2(MANDOC_DB, &db, ofl, NULL);
2065 if (SQLITE_OK != rc) {
2066 exitcode = (int)MANDOCLEVEL_SYSERR;
2067 say(MANDOC_DB, "%s", sqlite3_errmsg(db));
2068 return(0);
2069 }
2070 goto prepare_statements;
2071 }
2072
2073 ofl |= SQLITE_OPEN_CREATE | SQLITE_OPEN_EXCLUSIVE;
2074
2075 remove(MANDOC_DB "~");
2076 rc = sqlite3_open_v2(MANDOC_DB "~", &db, ofl, NULL);
2077 if (SQLITE_OK == rc)
2078 goto create_tables;
2079 if (MPARSE_QUICK & mparse_options) {
2080 exitcode = (int)MANDOCLEVEL_SYSERR;
2081 say(MANDOC_DB "~", "%s", sqlite3_errmsg(db));
2082 return(0);
2083 }
2084
2085 if (strlcpy(tempfilename, "/tmp/mandocdb.XXXXXX",
2086 sizeof(tempfilename)) >= sizeof(tempfilename)) {
2087 exitcode = (int)MANDOCLEVEL_SYSERR;
2088 say("", "/tmp/mandocdb.XXXXXX: Filename too long");
2089 return(0);
2090 }
2091 if (NULL == mkdtemp(tempfilename)) {
2092 exitcode = (int)MANDOCLEVEL_SYSERR;
2093 say("", "&%s", tempfilename);
2094 return(0);
2095 }
2096 if (strlcat(tempfilename, "/" MANDOC_DB,
2097 sizeof(tempfilename)) >= sizeof(tempfilename)) {
2098 exitcode = (int)MANDOCLEVEL_SYSERR;
2099 say("", "%s/" MANDOC_DB ": Filename too long",
2100 tempfilename);
2101 return(0);
2102 }
2103 rc = sqlite3_open_v2(tempfilename, &db, ofl, NULL);
2104 if (SQLITE_OK != rc) {
2105 exitcode = (int)MANDOCLEVEL_SYSERR;
2106 say("", "%s: %s", tempfilename, sqlite3_errmsg(db));
2107 return(0);
2108 }
2109
2110 create_tables:
2111 sql = "CREATE TABLE \"mpages\" (\n"
2112 " \"form\" INTEGER NOT NULL,\n"
2113 " \"id\" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL\n"
2114 ");\n"
2115 "\n"
2116 "CREATE TABLE \"mlinks\" (\n"
2117 " \"sec\" TEXT NOT NULL,\n"
2118 " \"arch\" TEXT NOT NULL,\n"
2119 " \"name\" TEXT NOT NULL,\n"
2120 " \"pageid\" INTEGER NOT NULL REFERENCES mpages(id) "
2121 "ON DELETE CASCADE\n"
2122 ");\n"
2123 "\n"
2124 "CREATE TABLE \"keys\" (\n"
2125 " \"bits\" INTEGER NOT NULL,\n"
2126 " \"key\" TEXT NOT NULL,\n"
2127 " \"pageid\" INTEGER NOT NULL REFERENCES mpages(id) "
2128 "ON DELETE CASCADE\n"
2129 ");\n";
2130
2131 if (SQLITE_OK != sqlite3_exec(db, sql, NULL, NULL, NULL)) {
2132 exitcode = (int)MANDOCLEVEL_SYSERR;
2133 say(MANDOC_DB, "%s", sqlite3_errmsg(db));
2134 return(0);
2135 }
2136
2137 prepare_statements:
2138 SQL_EXEC("PRAGMA foreign_keys = ON");
2139 sql = "DELETE FROM mpages WHERE id IN "
2140 "(SELECT pageid FROM mlinks WHERE "
2141 "sec=? AND arch=? AND name=?)";
2142 sqlite3_prepare_v2(db, sql, -1, &stmts[STMT_DELETE_PAGE], NULL);
2143 sql = "INSERT INTO mpages "
2144 "(form) VALUES (?)";
2145 sqlite3_prepare_v2(db, sql, -1, &stmts[STMT_INSERT_PAGE], NULL);
2146 sql = "INSERT INTO mlinks "
2147 "(sec,arch,name,pageid) VALUES (?,?,?,?)";
2148 sqlite3_prepare_v2(db, sql, -1, &stmts[STMT_INSERT_LINK], NULL);
2149 sql = "INSERT INTO keys "
2150 "(bits,key,pageid) VALUES (?,?,?)";
2151 sqlite3_prepare_v2(db, sql, -1, &stmts[STMT_INSERT_KEY], NULL);
2152
2153 #ifndef __APPLE__
2154 /*
2155 * When opening a new database, we can turn off
2156 * synchronous mode for much better performance.
2157 */
2158
2159 if (real)
2160 SQL_EXEC("PRAGMA synchronous = OFF");
2161 #endif
2162
2163 return(1);
2164 }
2165
2166 static void *
2167 hash_halloc(size_t sz, void *arg)
2168 {
2169
2170 return(mandoc_calloc(sz, 1));
2171 }
2172
2173 static void *
2174 hash_alloc(size_t sz, void *arg)
2175 {
2176
2177 return(mandoc_malloc(sz));
2178 }
2179
2180 static void
2181 hash_free(void *p, size_t sz, void *arg)
2182 {
2183
2184 free(p);
2185 }
2186
2187 static int
2188 set_basedir(const char *targetdir)
2189 {
2190 static char startdir[PATH_MAX];
2191 static int fd;
2192
2193 /*
2194 * Remember where we started by keeping a fd open to the origin
2195 * path component: throughout this utility, we chdir() a lot to
2196 * handle relative paths, and by doing this, we can return to
2197 * the starting point.
2198 */
2199 if ('\0' == *startdir) {
2200 if (NULL == getcwd(startdir, PATH_MAX)) {
2201 exitcode = (int)MANDOCLEVEL_SYSERR;
2202 if (NULL != targetdir)
2203 say("", "&getcwd");
2204 return(0);
2205 }
2206 if (-1 == (fd = open(startdir, O_RDONLY, 0))) {
2207 exitcode = (int)MANDOCLEVEL_SYSERR;
2208 say("", "&open %s", startdir);
2209 return(0);
2210 }
2211 if (NULL == targetdir)
2212 targetdir = startdir;
2213 } else {
2214 if (-1 == fd)
2215 return(0);
2216 if (-1 == fchdir(fd)) {
2217 close(fd);
2218 basedir[0] = '\0';
2219 exitcode = (int)MANDOCLEVEL_SYSERR;
2220 say("", "&chdir %s", startdir);
2221 return(0);
2222 }
2223 if (NULL == targetdir) {
2224 close(fd);
2225 return(1);
2226 }
2227 }
2228 if (NULL == realpath(targetdir, basedir)) {
2229 basedir[0] = '\0';
2230 exitcode = (int)MANDOCLEVEL_BADARG;
2231 say("", "&%s: realpath", targetdir);
2232 return(0);
2233 } else if (-1 == chdir(basedir)) {
2234 exitcode = (int)MANDOCLEVEL_BADARG;
2235 say("", "&chdir");
2236 return(0);
2237 }
2238 return(1);
2239 }
2240
2241 static void
2242 say(const char *file, const char *format, ...)
2243 {
2244 va_list ap;
2245 int use_errno;
2246
2247 if ('\0' != *basedir)
2248 fprintf(stderr, "%s", basedir);
2249 if ('\0' != *basedir && '\0' != *file)
2250 fputs("//", stderr);
2251 if ('\0' != *file)
2252 fprintf(stderr, "%s", file);
2253
2254 use_errno = 1;
2255 if (NULL != format) {
2256 switch (*format) {
2257 case ('&'):
2258 format++;
2259 break;
2260 case ('\0'):
2261 format = NULL;
2262 break;
2263 default:
2264 use_errno = 0;
2265 break;
2266 }
2267 }
2268 if (NULL != format) {
2269 if ('\0' != *basedir || '\0' != *file)
2270 fputs(": ", stderr);
2271 va_start(ap, format);
2272 vfprintf(stderr, format, ap);
2273 va_end(ap);
2274 }
2275 if (use_errno) {
2276 if ('\0' != *basedir || '\0' != *file || NULL != format)
2277 fputs(": ", stderr);
2278 perror(NULL);
2279 } else
2280 fputc('\n', stderr);
2281 }
A git conversion mirror of mandoc.bsd.lv