mandoc/mandocdb.c - diff

Return to mandocdb.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/mandocdb.c between version 1.44 and 1.49.2.6

version 1.44, 2012/03/23 05:07:35

version 1.49.2.6, 2013/10/01 00:52:58

Line 1

/* $Id$ */

* Permission to use, copy, modify, and distribute this software for any

* purpose with or without fee is hereby granted, provided that the above

Line 19

#include "config.h"

#endif

#include <sys/param.h>

#include <sys/types.h>

#include <assert.h>

#include <ctype.h>

#include <dirent.h>

#include <errno.h>

#include <fcntl.h>

#include <getopt.h>

#include <limits.h>

#include <stdio.h>

#include <stdint.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#if defined(__linux__)

#if defined(__linux__) || defined(__sun)

# include <endian.h>

# include <db_185.h>

#elif defined(__APPLE__)

Line 43

Line 44

# include <db.h>

#endif

#if defined(__sun)

#include <sys/stat.h>

#endif

#include "man.h"

#include "mdoc.h"

#include "mandoc.h"

Line 58

Line 63

/* Access to the mandoc database on disk. */

struct mdb {

char idxn[MAXPATHLEN]; /* index db filename */

char idxn[PATH_MAX]; /* index db filename */

char dbn[MAXPATHLEN]; /* keyword db filename */

char dbn[PATH_MAX]; /* keyword db filename */

DB *idx; /* index recno database */

DB *db; /* keyword btree database */

};

Line 123 static void hash_put(DB *, const struct buf *, uint

Line 128 static void hash_put(DB *, const struct buf *, uint

static void hash_reset(DB **);

static void index_merge(const struct of *, struct mparse *,

struct buf *, struct buf *, DB *,

struct mdb *, struct recs *,

struct mdb *, struct recs *);

const char *);

static void index_prune(const struct of *, struct mdb *,

struct recs *, const char *);

struct recs *);

static void ofile_argbuild(int, char *[],

static void ofile_argbuild(int, char *[], struct of **,

struct of **, const char *);

const char *);

static void ofile_dirbuild(const char *, const char *,

const char *, int, struct of **);

static void ofile_free(struct of *);

static void pformatted(DB *, struct buf *, struct buf *,

static void pformatted(DB *, struct buf *,

const struct of *, const char *);

struct buf *, const struct of *);

static int pman_node(MAN_ARGS);

static void pmdoc_node(MDOC_ARGS);

static int pmdoc_head(MDOC_ARGS);

Line 294 main(int argc, char *argv[])

Line 298 main(int argc, char *argv[])

struct recs recs;

enum op op; /* current operation */

const char *dir;

char *cp;

char pbuf[PATH_MAX];

int ch, i, flags;

DB *hash; /* temporary keyword hashtable */

BTREEINFO info; /* btree configuration */

size_t sz1, sz2;

size_t sz1, sz2, ipath;

struct buf buf, /* keyword buffer */

dbuf; /* description buffer */

struct of *of; /* list of files for processing */

Line 385 main(int argc, char *argv[])

Line 391 main(int argc, char *argv[])

info.lorder = 4321;

info.flags = R_DUP;

mp = mparse_alloc(MPARSE_AUTO, MANDOCLEVEL_FATAL, NULL, NULL);

mp = mparse_alloc(MPARSE_AUTO, MANDOCLEVEL_FATAL, NULL, NULL, NULL);

memset(&buf, 0, sizeof(struct buf));

memset(&dbuf, 0, sizeof(struct buf));

Line 396 main(int argc, char *argv[])

Line 402 main(int argc, char *argv[])

dbuf.cp = mandoc_malloc(dbuf.size);

if (OP_TEST == op) {

ofile_argbuild(argc, argv, &of, ".");

ofile_argbuild(argc, argv, &of, NULL);

if (NULL == of)

goto out;

index_merge(of, mp, &dbuf, &buf,

index_merge(of, mp, &dbuf, &buf, hash, &mdb, &recs);

hash, &mdb, &recs, ".");

goto out;

}

if (OP_UPDATE == op || OP_DELETE == op) {

strlcat(mdb.dbn, dir, MAXPATHLEN);

if (NULL == realpath(dir, pbuf)) {

strlcat(mdb.dbn, "/", MAXPATHLEN);

perror(dir);

sz1 = strlcat(mdb.dbn, MANDOC_DB, MAXPATHLEN);

exit((int)MANDOCLEVEL_BADARG);

}

if (strlcat(pbuf, "/", PATH_MAX) >= PATH_MAX) {

fprintf(stderr, "%s: path too long\n", pbuf);

exit((int)MANDOCLEVEL_BADARG);

}

strlcat(mdb.idxn, dir, MAXPATHLEN);

strlcat(mdb.dbn, pbuf, PATH_MAX);

strlcat(mdb.idxn, "/", MAXPATHLEN);

sz1 = strlcat(mdb.dbn, MANDOC_DB, PATH_MAX);

sz2 = strlcat(mdb.idxn, MANDOC_IDX, MAXPATHLEN);

if (sz1 >= MAXPATHLEN || sz2 >= MAXPATHLEN) {

strlcat(mdb.idxn, pbuf, PATH_MAX);

fprintf(stderr, "%s: path too long\n", dir);

sz2 = strlcat(mdb.idxn, MANDOC_IDX, PATH_MAX);

if (sz1 >= PATH_MAX || sz2 >= PATH_MAX) {

fprintf(stderr, "%s: path too long\n", mdb.idxn);

exit((int)MANDOCLEVEL_BADARG);

}

Line 430 main(int argc, char *argv[])

Line 442 main(int argc, char *argv[])

exit((int)MANDOCLEVEL_SYSERR);

}

ofile_argbuild(argc, argv, &of, dir);

ofile_argbuild(argc, argv, &of, pbuf);

if (NULL == of)

goto out;

index_prune(of, &mdb, &recs, dir);

index_prune(of, &mdb, &recs);

* Go to the root of the respective manual tree.

Line 449 main(int argc, char *argv[])

Line 461 main(int argc, char *argv[])

exit((int)MANDOCLEVEL_SYSERR);

}

index_merge(of, mp, &dbuf, &buf, hash,

&mdb, &recs, dir);

&mdb, &recs);

}

goto out;

Line 464 main(int argc, char *argv[])

Line 476 main(int argc, char *argv[])

if (argc > 0) {

dirs.paths = mandoc_calloc(argc, sizeof(char *));

dirs.sz = argc;

for (i = 0; i < argc; i++)

for (i = 0; i < argc; i++) {

dirs.paths[i] = mandoc_strdup(argv[i]);

if (NULL == (cp = realpath(argv[i], pbuf))) {

perror(argv[i]);

goto out;

}

dirs.paths[i] = mandoc_strdup(cp);

}

} else

manpath_parse(&dirs, dir, NULL, NULL);

for (i = 0; i < dirs.sz; i++) {

for (ipath = 0; ipath < dirs.sz; ipath++) {

* Go to the root of the respective manual tree.

* This must work or no manuals may be found:

* They are indexed relative to the root.

if (-1 == chdir(dirs.paths[i])) {

if (-1 == chdir(dirs.paths[ipath])) {

perror(dirs.paths[i]);

perror(dirs.paths[ipath]);

exit((int)MANDOCLEVEL_SYSERR);

}

strlcpy(mdb.dbn, MANDOC_DB, MAXPATHLEN);

/* Create a new database in two temporary files. */

strlcpy(mdb.idxn, MANDOC_IDX, MAXPATHLEN);

flags = O_CREAT | O_TRUNC | O_RDWR;

flags = O_CREAT | O_EXCL | O_RDWR;

mdb.db = dbopen(mdb.dbn, flags, 0644, DB_BTREE, &info);

while (NULL == mdb.db) {

mdb.idx = dbopen(mdb.idxn, flags, 0644, DB_RECNO, NULL);

strlcpy(mdb.dbn, MANDOC_DB, PATH_MAX);

strlcat(mdb.dbn, ".XXXXXXXXXX", PATH_MAX);

if (NULL == mdb.db) {

if (NULL == mktemp(mdb.dbn)) {

perror(mdb.dbn);

exit((int)MANDOCLEVEL_SYSERR);

} else if (NULL == mdb.idx) {

}

perror(mdb.idxn);

mdb.db = dbopen(mdb.dbn, flags, 0644,

exit((int)MANDOCLEVEL_SYSERR);

DB_BTREE, &info);

if (NULL == mdb.db && EEXIST != errno) {

perror(mdb.dbn);

exit((int)MANDOCLEVEL_SYSERR);

}

while (NULL == mdb.idx) {

strlcpy(mdb.idxn, MANDOC_IDX, PATH_MAX);

strlcat(mdb.idxn, ".XXXXXXXXXX", PATH_MAX);

if (NULL == mktemp(mdb.idxn)) {

perror(mdb.idxn);

unlink(mdb.dbn);

exit((int)MANDOCLEVEL_SYSERR);

}

mdb.idx = dbopen(mdb.idxn, flags, 0644,

DB_RECNO, NULL);

if (NULL == mdb.idx && EEXIST != errno) {

perror(mdb.idxn);

unlink(mdb.dbn);

exit((int)MANDOCLEVEL_SYSERR);

}

* Search for manuals and fill the new database.

Line 504 main(int argc, char *argv[])

Line 541 main(int argc, char *argv[])

if (NULL != of) {

index_merge(of, mp, &dbuf, &buf, hash,

&mdb, &recs, dirs.paths[i]);

&mdb, &recs);

ofile_free(of);

of = NULL;

}

Line 513 main(int argc, char *argv[])

Line 550 main(int argc, char *argv[])

(*mdb.idx->close)(mdb.idx);

mdb.db = NULL;

mdb.idx = NULL;

* Replace the old database with the new one.

* This is not perfectly atomic,

* but i cannot think of a better way.

if (-1 == rename(mdb.dbn, MANDOC_DB)) {

perror(MANDOC_DB);

unlink(mdb.dbn);

unlink(mdb.idxn);

exit((int)MANDOCLEVEL_SYSERR);

}

if (-1 == rename(mdb.idxn, MANDOC_IDX)) {

perror(MANDOC_IDX);

unlink(MANDOC_DB);

unlink(MANDOC_IDX);

unlink(mdb.idxn);

exit((int)MANDOCLEVEL_SYSERR);

}

out:

Line 546 usage:

Line 603 usage:

void

index_merge(const struct of *of, struct mparse *mp,

struct buf *dbuf, struct buf *buf, DB *hash,

struct mdb *mdb, struct recs *recs,

struct mdb *mdb, struct recs *recs)

const char *basedir)

{

recno_t rec;

int ch, skip;

DBT key, val;

DB *files; /* temporary file name table */

char emptystring[1] = {'\0'};

struct mdoc *mdoc;

struct man *man;

char *p;

const char *fn, *msec, *march, *mtitle;

char *p;

uint64_t mask;

size_t sv;

unsigned seq;

Line 617 index_merge(const struct of *of, struct mparse *mp,

Line 672 index_merge(const struct of *of, struct mparse *mp,

skip = 0;

assert(of->sec);

assert(msec);

if (warnings && strcasecmp(msec, of->sec))

if (warnings)

fprintf(stderr, "%s: section \"%s\" manual "

if (strcasecmp(msec, of->sec))

fprintf(stderr, "%s: "

"section \"%s\" manual "

"in \"%s\" directory\n",

fn, msec, of->sec);

* Manual page directories exist for each kernel

* architecture as returned by machine(1).

Line 640 index_merge(const struct of *of, struct mparse *mp,

Line 696 index_merge(const struct of *of, struct mparse *mp,

assert(of->arch);

assert(march);

if (warnings && strcasecmp(march, of->arch))

if (warnings)

fprintf(stderr, "%s: architecture \"%s\" manual "

if (strcasecmp(march, of->arch))

fprintf(stderr, "%s: "

"architecture \"%s\" manual "

"in \"%s\" directory\n",

fn, march, of->arch);

Line 679 index_merge(const struct of *of, struct mparse *mp,

Line 737 index_merge(const struct of *of, struct mparse *mp,

val.data = NULL;

val.size = 0;

if (0 == skip)

val.data = emptystring;

val.data = "";

else {

ch = (*files->get)(files, &key, &val, 0);

if (ch < 0) {

Line 733 index_merge(const struct of *of, struct mparse *mp,

Line 791 index_merge(const struct of *of, struct mparse *mp,

else if (man)

pman_node(hash, buf, dbuf, man_node(man));

else

pformatted(hash, buf, dbuf, of, basedir);

pformatted(hash, buf, dbuf, of);

/* Test mode, do not access any database. */

Line 780 index_merge(const struct of *of, struct mparse *mp,

Line 838 index_merge(const struct of *of, struct mparse *mp,

}

if (ch < 0) {

perror("hash");

unlink(mdb->dbn);

unlink(mdb->idxn);

exit((int)MANDOCLEVEL_SYSERR);

}

Line 798 index_merge(const struct of *of, struct mparse *mp,

Line 858 index_merge(const struct of *of, struct mparse *mp,

val.size = dbuf->len;

if (verb)

printf("%s: Adding to index: %s\n", basedir, fn);

printf("%s: adding to index\n", fn);

dbt_put(mdb->idx, mdb->idxn, &key, &val);

}

Line 828 index_merge(const struct of *of, struct mparse *mp,

Line 888 index_merge(const struct of *of, struct mparse *mp,

* in `idx' (zeroing its value size).

static void

index_prune(const struct of *ofile, struct mdb *mdb,

index_prune(const struct of *ofile, struct mdb *mdb, struct recs *recs)

struct recs *recs, const char *basedir)

{

const struct of *of;

const char *fn;

Line 904 index_prune(const struct of *ofile, struct mdb *mdb,

Line 963 index_prune(const struct of *ofile, struct mdb *mdb,

}

if (verb)

printf("%s: Deleting from index: %s\n",

printf("%s: deleting from index\n", fn);

basedir, fn);

val.size = 0;

ch = (*mdb->idx->put)(mdb->idx, &key, &val, R_CURSOR);

Line 1314 static int

Line 1372 static int

pman_node(MAN_ARGS)

{

const struct man_node *head, *body;

const char *start, *sv;

char *start, *sv, *title;

size_t sz;

size_t sz, titlesz;

if (NULL == n)

return(0);

Line 1338 pman_node(MAN_ARGS)

Line 1396 pman_node(MAN_ARGS)

NULL != (body = body->child) &&

MAN_TEXT == body->type) {

assert(body->string);

title = NULL;

start = sv = body->string;

titlesz = 0;

* Suck the entire NAME section into memory.

* Yes, we might run away.

* But too many manuals have big, spread-out

* NAME sections over many lines.

for ( ; NULL != body; body = body->next) {

if (MAN_TEXT != body->type)

break;

if (0 == (sz = strlen(body->string)))

continue;

title = mandoc_realloc

(title, titlesz + sz + 1);

memcpy(title + titlesz, body->string, sz);

titlesz += sz + 1;

title[(int)titlesz - 1] = ' ';

}

if (NULL == title)

return(0);

title = mandoc_realloc(title, titlesz + 1);

title[(int)titlesz] = '\0';

/* Skip leading space. */

sv = title;

while (isspace((unsigned char)*sv))

sv++;

if (0 == (sz = strlen(sv))) {

free(title);

return(0);

}

/* Erase trailing space. */

start = &sv[sz - 1];

while (start > sv && isspace((unsigned char)*start))

*start-- = '\0';

if (start == sv) {

free(title);

return(0);

}

start = sv;

* Go through a special heuristic dance here.

* This is why -man manuals are great!

Line 1377 pman_node(MAN_ARGS)

Line 1481 pman_node(MAN_ARGS)

if (sv == start) {

buf_append(buf, start);

free(title);

return(1);

}

while (' ' == *start)

while (isspace((unsigned char)*start))

start++;

if (0 == strncmp(start, "-", 1))

Line 1402 pman_node(MAN_ARGS)

Line 1507 pman_node(MAN_ARGS)

buf_appendb(buf, start, sz);

hash_put(hash, buf, TYPE_Nd);

free(title);

}

Line 1417 pman_node(MAN_ARGS)

Line 1523 pman_node(MAN_ARGS)

* By necessity, this involves rather crude guesswork.

static void

pformatted(DB *hash, struct buf *buf, struct buf *dbuf,

pformatted(DB *hash, struct buf *buf,

const struct of *of, const char *basedir)

struct buf *dbuf, const struct of *of)

{

FILE *stream;

char *line, *p, *title;

Line 1491 pformatted(DB *hash, struct buf *buf, struct buf *dbuf

Line 1597 pformatted(DB *hash, struct buf *buf, struct buf *dbuf

if (NULL == title || '\0' == *title) {

if (warnings)

fprintf(stderr, "%s: Cannot find NAME "

fprintf(stderr, "%s: cannot find NAME section\n",

"section: %s\n", basedir, of->fname);

of->fname);

buf_appendb(dbuf, buf->cp, buf->size);

hash_put(hash, buf, TYPE_Nd);

fclose(stream);

Line 1514 pformatted(DB *hash, struct buf *buf, struct buf *dbuf

Line 1620 pformatted(DB *hash, struct buf *buf, struct buf *dbuf

/* Skip to next word. */ ;

} else {

if (warnings)

fprintf(stderr, "%s/%s: No dash in "

fprintf(stderr, "%s: no dash in title line\n",

"title line\n", basedir, of->fname);

of->fname);

p = title;

}

Line 1542 pformatted(DB *hash, struct buf *buf, struct buf *dbuf

Line 1648 pformatted(DB *hash, struct buf *buf, struct buf *dbuf

}

static void

ofile_argbuild(int argc, char *argv[],

ofile_argbuild(int argc, char *argv[], struct of **of,

struct of **of, const char *basedir)

const char *basedir)

{

char buf[MAXPATHLEN];

char buf[PATH_MAX];

char pbuf[PATH_MAX];

const char *sec, *arch, *title;

char *p;

char *relpath, *p;

int i, src_form;

struct of *nof;

for (i = 0; i < argc; i++) {

if (NULL == (relpath = realpath(argv[i], pbuf))) {

perror(argv[i]);

continue;

}

if (NULL != basedir) {

if (strstr(pbuf, basedir) != pbuf) {

fprintf(stderr, "%s: file outside "

"base directory %s\n",

pbuf, basedir);

continue;

}

relpath = pbuf + strlen(basedir);

}

* Try to infer the manual section, architecture and

Line 1560 ofile_argbuild(int argc, char *argv[],

Line 1680 ofile_argbuild(int argc, char *argv[],

* cat<section>[/<arch>]/<title>.0

if (strlcpy(buf, argv[i], sizeof(buf)) >= sizeof(buf)) {

if (strlcpy(buf, relpath, sizeof(buf)) >= sizeof(buf)) {

fprintf(stderr, "%s: Path too long\n", argv[i]);

fprintf(stderr, "%s: path too long\n", relpath);

continue;

}

sec = arch = title = "";

Line 1594 ofile_argbuild(int argc, char *argv[],

Line 1714 ofile_argbuild(int argc, char *argv[],

}

if ('\0' == *title) {

if (warnings)

fprintf(stderr, "%s/%s: Cannot deduce "

fprintf(stderr,

"title from filename\n",

"%s: cannot deduce title "

basedir, argv[i]);

"from filename\n",

relpath);

title = buf;

}

Line 1605 ofile_argbuild(int argc, char *argv[],

Line 1726 ofile_argbuild(int argc, char *argv[],

nof = mandoc_calloc(1, sizeof(struct of));

nof->fname = mandoc_strdup(argv[i]);

nof->fname = mandoc_strdup(relpath);

nof->sec = mandoc_strdup(sec);

nof->arch = mandoc_strdup(arch);

nof->title = mandoc_strdup(title);

Line 1630 ofile_argbuild(int argc, char *argv[],

Line 1751 ofile_argbuild(int argc, char *argv[],

* Recursively build up a list of files to parse.

* We use this instead of ftw() and so on because I don't want global

* variables hanging around.

* This ignores the mandocdb.db and mandocdb.index files, but assumes that

* This ignores the mandoc.db and mandoc.index files, but assumes that

* everything else is a manual.

* Pass in a pointer to a NULL structure for the first invocation.

Line 1638 static void

Line 1759 static void

ofile_dirbuild(const char *dir, const char* psec, const char *parch,

int p_src_form, struct of **of)

{

char buf[MAXPATHLEN];

char buf[PATH_MAX];

#if defined(__sun)

struct stat sb;

#endif

size_t sz;

DIR *d;

const char *fn, *sec, *arch;

Line 1661 ofile_dirbuild(const char *dir, const char* psec, cons

Line 1785 ofile_dirbuild(const char *dir, const char* psec, cons

src_form = p_src_form;

#if defined(__sun)

stat(dp->d_name, &sb);

if (S_IFDIR & sb.st_mode) {

#else

if (DT_DIR == dp->d_type) {

#endif

sec = psec;

arch = parch;

Line 1704 ofile_dirbuild(const char *dir, const char* psec, cons

Line 1833 ofile_dirbuild(const char *dir, const char* psec, cons

}

buf[0] = '\0';

strlcat(buf, dir, MAXPATHLEN);

strlcat(buf, dir, PATH_MAX);

strlcat(buf, "/", MAXPATHLEN);

strlcat(buf, "/", PATH_MAX);

sz = strlcat(buf, fn, MAXPATHLEN);

sz = strlcat(buf, fn, PATH_MAX);

if (MAXPATHLEN <= sz) {

if (PATH_MAX <= sz) {

if (warnings) fprintf(stderr, "%s/%s: "

"path too long\n", dir, fn);

continue;

Line 1718 ofile_dirbuild(const char *dir, const char* psec, cons

Line 1847 ofile_dirbuild(const char *dir, const char* psec, cons

continue;

}

#if defined(__sun)

if (0 == S_IFREG & sb.st_mode) {

#else

if (DT_REG != dp->d_type) {

#endif

if (warnings)

fprintf(stderr,

"%s/%s: not a regular file\n",

Line 1776 ofile_dirbuild(const char *dir, const char* psec, cons

Line 1909 ofile_dirbuild(const char *dir, const char* psec, cons

if (0 == use_all && MANDOC_FORM & src_form &&

'\0' != *psec) {

buf[0] = '\0';

strlcat(buf, dir, MAXPATHLEN);

strlcat(buf, dir, PATH_MAX);

p = strrchr(buf, '/');

if ('\0' != *parch && NULL != p)

for (p--; p > buf; p--)

Line 1788 ofile_dirbuild(const char *dir, const char* psec, cons

Line 1921 ofile_dirbuild(const char *dir, const char* psec, cons

p++;

if (0 == strncmp("cat", p, 3))

memcpy(p, "man", 3);

strlcat(buf, "/", MAXPATHLEN);

strlcat(buf, "/", PATH_MAX);

sz = strlcat(buf, fn, MAXPATHLEN);

sz = strlcat(buf, fn, PATH_MAX);

if (sz >= MAXPATHLEN) {

if (sz >= PATH_MAX) {

if (warnings) fprintf(stderr,

"%s/%s: path too long\n",

dir, fn);

Line 1799 ofile_dirbuild(const char *dir, const char* psec, cons

Line 1932 ofile_dirbuild(const char *dir, const char* psec, cons

q = strrchr(buf, '.');

if (NULL != q && p < q++) {

*q = '\0';

sz = strlcat(buf, psec, MAXPATHLEN);

sz = strlcat(buf, psec, PATH_MAX);

if (sz >= MAXPATHLEN) {

if (sz >= PATH_MAX) {

if (warnings) fprintf(stderr,

"%s/%s: path too long\n",

dir, fn);

Line 1814 ofile_dirbuild(const char *dir, const char* psec, cons

Line 1947 ofile_dirbuild(const char *dir, const char* psec, cons

buf[0] = '\0';

assert('.' == dir[0]);

if ('/' == dir[1]) {

strlcat(buf, dir + 2, MAXPATHLEN);

strlcat(buf, dir + 2, PATH_MAX);

strlcat(buf, "/", MAXPATHLEN);

strlcat(buf, "/", PATH_MAX);

}

sz = strlcat(buf, fn, MAXPATHLEN);

sz = strlcat(buf, fn, PATH_MAX);

if (sz >= MAXPATHLEN) {

if (sz >= PATH_MAX) {

if (warnings) fprintf(stderr,

"%s/%s: path too long\n", dir, fn);

continue;

CVSweb