In apropos_db.c, move all btree reading (and safety checks) into the

[mandoc.git] / apropos_db.c

diff --git a/apropos_db.c b/apropos_db.c
index 0ac526241e812f1cb4b1bf2f98bd28d134f2816f..4d9ae874601f577466a3e6d99652908080debc97 100644 (file)
--- a/apropos_db.c
+++ b/apropos_db.c
@@ -1,4 +1,4 @@
-/*     $Id: apropos_db.c,v 1.9 2011/11/20 15:45:37 kristaps Exp $ */
+/*     $Id: apropos_db.c,v 1.17 2011/12/01 23:46:26 kristaps Exp $ */

 /*
  * Copyright (c) 2011 Kristaps Dzonsons <kristaps@bsd.lv>
  * Copyright (c) 2011 Ingo Schwarze <schwarze@openbsd.org>
 /*
  * Copyright (c) 2011 Kristaps Dzonsons <kristaps@bsd.lv>
  * Copyright (c) 2011 Ingo Schwarze <schwarze@openbsd.org>


@@ -24,6 +24,8 @@
 #include <string.h>
 #include <unistd.h>
 
 #include <string.h>
 #include <unistd.h>
 

+#include <arpa/inet.h>
+

 #ifdef __linux__
 # include <db_185.h>
 #else
 #ifdef __linux__
 # include <db_185.h>
 #else


@@ -52,7 +54,6 @@ struct        expr {
        int              regex; /* is regex? */
        int              index; /* index in match array */
        uint64_t         mask; /* type-mask */
        int              regex; /* is regex? */
        int              index; /* index in match array */
        uint64_t         mask; /* type-mask */

-       int              cs; /* is case-sensitive? */

        int              and; /* is rhs of logical AND? */
        char            *v; /* search value */
        regex_t          re; /* compiled re, if regex */
        int              and; /* is rhs of logical AND? */
        char            *v; /* search value */
        regex_t          re; /* compiled re, if regex */


@@ -115,17 +116,18 @@ static    const struct type types[] = {
 };
 
 static DB      *btree_open(void);
 };
 
 static DB      *btree_open(void);

-static int      btree_read(const DBT *, 
-                       const struct mchars *, char **);
+static int      btree_read(const DBT *, const DBT *,
+                       const struct mchars *, 
+                       struct db_val *, char **);

 static int      expreval(const struct expr *, int *);
 static int      expreval(const struct expr *, int *);

-static void     exprexec(const struct expr *, 
+static void     exprexec(const struct expr *,

                        const char *, uint64_t, struct rec *);
                        const char *, uint64_t, struct rec *);

-static int      exprmark(const struct expr *, 
+static int      exprmark(const struct expr *,

                        const char *, uint64_t, int *);
 static struct expr *exprexpr(int, char *[], int *, int *, size_t *);
 static struct expr *exprterm(char *, int);
 static DB      *index_open(void);
                        const char *, uint64_t, int *);
 static struct expr *exprexpr(int, char *[], int *, int *, size_t *);
 static struct expr *exprterm(char *, int);
 static DB      *index_open(void);

-static int      index_read(const DBT *, const DBT *, 
+static int      index_read(const DBT *, const DBT *, int,

                        const struct mchars *, struct rec *);
 static void     norm_string(const char *,
                        const struct mchars *, char **);
                        const struct mchars *, struct rec *);
 static void     norm_string(const char *,
                        const struct mchars *, char **);


@@ -133,7 +135,7 @@ static      size_t   norm_utf8(unsigned int, char[7]);
 static void     recfree(struct rec *);
 static int      single_search(struct rectree *, const struct opts *,
                        const struct expr *, size_t terms,
 static void     recfree(struct rec *);
 static int      single_search(struct rectree *, const struct opts *,
                        const struct expr *, size_t terms,

-                       struct mchars *);
+                       struct mchars *, int);

 
 /*
  * Open the keyword mandoc-db database.
 
 /*
  * Open the keyword mandoc-db database.


@@ -148,7 +150,7 @@ btree_open(void)
        info.flags = R_DUP;
 
        db = dbopen(MANDOC_DB, O_RDONLY, 0, DB_BTREE, &info);
        info.flags = R_DUP;
 
        db = dbopen(MANDOC_DB, O_RDONLY, 0, DB_BTREE, &info);

-       if (NULL != db) 
+       if (NULL != db)

                return(db);
 
        return(NULL);
                return(db);
 
        return(NULL);


@@ -159,24 +161,31 @@ btree_open(void)
  * Return 0 if the database is insane, else 1.
  */
 static int
  * Return 0 if the database is insane, else 1.
  */
 static int

-btree_read(const DBT *v, const struct mchars *mc, char **buf)
+btree_read(const DBT *k, const DBT *v, 
+               const struct mchars *mc, 
+               struct db_val *dbv, char **buf)

 {
 {

+       const struct db_val *vp;

 
 

-       /* Sanity: are we nil-terminated? */
-
-       assert(v->size > 0);
+       /* Are our sizes sane? */
+       if (k->size < 2 || sizeof(struct db_val) != v->size)
+               return(0);

 
 

-       if ('\0' != ((char *)v->data)[(int)v->size - 1])
+       /* Is our string nil-terminated? */
+       if ('\0' != ((const char *)k->data)[(int)k->size - 1])

                return(0);
 
                return(0);
 

-       norm_string((char *)v->data, mc, buf);
+       vp = v->data;
+       norm_string((const char *)k->data, mc, buf);
+       dbv->rec = ntohl(vp->rec);
+       dbv->mask = vp->mask;

        return(1);
 }
 
 /*
  * Take a Unicode codepoint and produce its UTF-8 encoding.
  * This isn't the best way to do this, but it works.
        return(1);
 }
 
 /*
  * Take a Unicode codepoint and produce its UTF-8 encoding.
  * This isn't the best way to do this, but it works.

- * The magic numbers are from the UTF-8 packaging.  
+ * The magic numbers are from the UTF-8 packaging.

  * They're not as scary as they seem: read the UTF-8 spec for details.
  */
 static size_t
  * They're not as scary as they seem: read the UTF-8 spec for details.
  */
 static size_t


@@ -241,7 +250,7 @@ norm_string(const char *val, const struct mchars *mc, char **buf)
        const char       *seq, *cpp;
        int               len, u, pos;
        enum mandoc_esc   esc;
        const char       *seq, *cpp;
        int               len, u, pos;
        enum mandoc_esc   esc;

-       static const char res[] = { '\\', '\t', 
+       static const char res[] = { '\\', '\t',

                                ASCII_NBRSP, ASCII_HYPH, '\0' };
 
        /* Pre-allocate by the length of the input */
                                ASCII_NBRSP, ASCII_HYPH, '\0' };
 
        /* Pre-allocate by the length of the input */


@@ -287,7 +296,7 @@ norm_string(const char *val, const struct mchars *mc, char **buf)
                if (ESCAPE_ERROR == esc)
                        break;
 
                if (ESCAPE_ERROR == esc)
                        break;
 

-               /* 
+               /*

                 * XXX - this just does UTF-8, but we need to know
                 * beforehand whether we should do text substitution.
                 */
                 * XXX - this just does UTF-8, but we need to know
                 * beforehand whether we should do text substitution.
                 */


@@ -345,7 +354,7 @@ index_open(void)
  * Returns 1 if an entry was unpacked, 0 if the database is insane.
  */
 static int
  * Returns 1 if an entry was unpacked, 0 if the database is insane.
  */
 static int

-index_read(const DBT *key, const DBT *val, 
+index_read(const DBT *key, const DBT *val, int index,

                const struct mchars *mc, struct rec *rec)
 {
        size_t           left;
                const struct mchars *mc, struct rec *rec)
 {
        size_t           left;


@@ -364,7 +373,9 @@ index_read(const DBT *key, const DBT *val,
        cp = (char *)val->data;
 
        rec->res.rec = *(recno_t *)key->data;
        cp = (char *)val->data;
 
        rec->res.rec = *(recno_t *)key->data;

+       rec->res.volume = index;

 
 

+       INDEX_BREAD(rec->res.type);

        INDEX_BREAD(rec->res.file);
        INDEX_BREAD(rec->res.cat);
        INDEX_BREAD(rec->res.title);
        INDEX_BREAD(rec->res.file);
        INDEX_BREAD(rec->res.cat);
        INDEX_BREAD(rec->res.title);


@@ -374,15 +385,14 @@ index_read(const DBT *key, const DBT *val,
 }
 
 /*
 }
 
 /*

- * Search mandocdb databases in argv (size argc) for the expression
- * "expr".
+ * Search mandocdb databases in paths for expression "expr".

  * Filter out by "opts".
  * Call "res" with the results, which may be zero.
  * Return 0 if there was a database error, else return 1.
  */
 int
  * Filter out by "opts".
  * Call "res" with the results, which may be zero.
  * Return 0 if there was a database error, else return 1.
  */
 int

-apropos_search(int argc, char *argv[], const struct opts *opts,
-               const struct expr *expr, size_t terms, void *arg, 
+apropos_search(int pathsz, char **paths, const struct opts *opts,
+               const struct expr *expr, size_t terms, void *arg,

                void (*res)(struct res *, size_t, void *))
 {
        struct rectree   tree;
                void (*res)(struct res *, size_t, void *))
 {
        struct rectree   tree;


@@ -392,19 +402,24 @@ apropos_search(int argc, char *argv[], const struct opts *opts,
 
        memset(&tree, 0, sizeof(struct rectree));
 
 
        memset(&tree, 0, sizeof(struct rectree));
 

+       rc = 0;

        mc = mchars_alloc();
 
        mc = mchars_alloc();
 

-       for (rc = 1, i = 0; rc && i < argc; i++) {
-               /* FIXME: ugly warning: we shouldn't get here! */
-               if (chdir(argv[i]))
+       /*
+        * Main loop.  Change into the directory containing manpage
+        * databases.  Run our expession over each database in the set.
+        */
+
+       for (i = 0; i < pathsz; i++) {
+               if (chdir(paths[i]))

                        continue;
                        continue;

-               rc = single_search(&tree, opts, expr, terms, mc);
-               /* FIXME: warn and continue... ? */
+               if ( ! single_search(&tree, opts, expr, terms, mc, i))
+                       goto out;

        }
 
        /*
        }
 
        /*

-        * Count the matching files
-        * and feed them to the output handler.
+        * Count matching files, transfer to a "clean" array, then feed
+        * them to the output handler.

         */
 
        for (mlen = i = 0; i < tree.len; i++)
         */
 
        for (mlen = i = 0; i < tree.len; i++)


@@ -415,12 +430,14 @@ apropos_search(int argc, char *argv[], const struct opts *opts,
 
        for (mlen = i = 0; i < tree.len; i++)
                if (tree.node[i].matched)
 
        for (mlen = i = 0; i < tree.len; i++)
                if (tree.node[i].matched)

-                       memcpy(&ress[mlen++], &tree.node[i].res, 
+                       memcpy(&ress[mlen++], &tree.node[i].res,

                                        sizeof(struct res));
 
        (*res)(ress, mlen, arg);
        free(ress);
 
                                        sizeof(struct res));
 
        (*res)(ress, mlen, arg);
        free(ress);
 

+       rc = 1;
+out:

        for (i = 0; i < tree.len; i++)
                recfree(&tree.node[i]);
 
        for (i = 0; i < tree.len; i++)
                recfree(&tree.node[i]);
 


@@ -432,17 +449,15 @@ apropos_search(int argc, char *argv[], const struct opts *opts,
 static int
 single_search(struct rectree *tree, const struct opts *opts,
                const struct expr *expr, size_t terms,
 static int
 single_search(struct rectree *tree, const struct opts *opts,
                const struct expr *expr, size_t terms,

-               struct mchars *mc)
+               struct mchars *mc, int vol)

 {
        int              root, leaf, ch;
 {
        int              root, leaf, ch;

-       uint64_t         mask;

        DBT              key, val;
        DB              *btree, *idx;
        char            *buf;
        DBT              key, val;
        DB              *btree, *idx;
        char            *buf;

-       recno_t          rec;

        struct rec      *rs;
        struct rec       r;
        struct rec      *rs;
        struct rec       r;

-       struct db_val   *vbuf;
+       struct db_val    vb;

 
        root    = -1;
        leaf    = -1;
 
        root    = -1;
        leaf    = -1;


@@ -453,29 +468,23 @@ single_search(struct rectree *tree, const struct opts *opts,
 
        memset(&r, 0, sizeof(struct rec));
 
 
        memset(&r, 0, sizeof(struct rec));
 

-       if (NULL == (btree = btree_open())) 
-               return(0);
+       if (NULL == (btree = btree_open()))
+               return(1);

 
        if (NULL == (idx = index_open())) {
                (*btree->close)(btree);
 
        if (NULL == (idx = index_open())) {
                (*btree->close)(btree);

-               return(0);
+               return(1);

        }
 
        while (0 == (ch = (*btree->seq)(btree, &key, &val, R_NEXT))) {
        }
 
        while (0 == (ch = (*btree->seq)(btree, &key, &val, R_NEXT))) {

-               if (key.size < 2 || sizeof(struct db_val) != val.size) 
-                       break;
-               if ( ! btree_read(&key, mc, &buf))
+               if ( ! btree_read(&key, &val, mc, &vb, &buf))

                        break;
 
                        break;
 

-               vbuf = val.data;
-               rec = vbuf->rec;
-               mask = vbuf->mask;
-

                /*
                 * See if this keyword record matches any of the
                 * expressions we have stored.
                 */
                /*
                 * See if this keyword record matches any of the
                 * expressions we have stored.
                 */

-               if ( ! exprmark(expr, buf, mask, NULL))
+               if ( ! exprmark(expr, buf, vb.mask, NULL))

                        continue;
 
                /*
                        continue;
 
                /*


@@ -485,13 +494,13 @@ single_search(struct rectree *tree, const struct opts *opts,
                 */
 
                for (leaf = root; leaf >= 0; )
                 */
 
                for (leaf = root; leaf >= 0; )

-                       if (rec > rs[leaf].res.rec && 
+                       if (vb.rec > rs[leaf].res.rec &&

                                        rs[leaf].rhs >= 0)
                                leaf = rs[leaf].rhs;
                                        rs[leaf].rhs >= 0)
                                leaf = rs[leaf].rhs;

-                       else if (rec < rs[leaf].res.rec && 
+                       else if (vb.rec < rs[leaf].res.rec &&

                                        rs[leaf].lhs >= 0)
                                leaf = rs[leaf].lhs;
                                        rs[leaf].lhs >= 0)
                                leaf = rs[leaf].lhs;

-                       else 
+                       else

                                break;
 
                /*
                                break;
 
                /*


@@ -500,9 +509,9 @@ single_search(struct rectree *tree, const struct opts *opts,
                 * try to evaluate it now and continue anyway.
                 */
 
                 * try to evaluate it now and continue anyway.
                 */
 

-               if (leaf >= 0 && rs[leaf].res.rec == rec) {
+               if (leaf >= 0 && rs[leaf].res.rec == vb.rec) {

                        if (0 == rs[leaf].matched)
                        if (0 == rs[leaf].matched)

-                               exprexec(expr, buf, mask, &rs[leaf]);
+                               exprexec(expr, buf, vb.mask, &rs[leaf]);

                        continue;
                }
 
                        continue;
                }
 


@@ -512,14 +521,14 @@ single_search(struct rectree *tree, const struct opts *opts,
                 * database, then begin partial evaluation.
                 */
 
                 * database, then begin partial evaluation.
                 */
 

-               key.data = &rec;
+               key.data = &vb.rec;

                key.size = sizeof(recno_t);
 
                if (0 != (*idx->get)(idx, &key, &val, 0))
                        break;
 
                r.lhs = r.rhs = -1;
                key.size = sizeof(recno_t);
 
                if (0 != (*idx->get)(idx, &key, &val, 0))
                        break;
 
                r.lhs = r.rhs = -1;

-               if ( ! index_read(&key, &val, mc, &r))
+               if ( ! index_read(&key, &val, vol, mc, &r))

                        break;
 
                /* XXX: this should be elsewhere, I guess? */
                        break;
 
                /* XXX: this should be elsewhere, I guess? */


@@ -533,24 +542,25 @@ single_search(struct rectree *tree, const struct opts *opts,
                        (rs, (tree->len + 1) * sizeof(struct rec));
 
                memcpy(&rs[tree->len], &r, sizeof(struct rec));
                        (rs, (tree->len + 1) * sizeof(struct rec));
 
                memcpy(&rs[tree->len], &r, sizeof(struct rec));

-               rs[tree->len].matches = 
+               rs[tree->len].matches =

                        mandoc_calloc(terms, sizeof(int));
 
                        mandoc_calloc(terms, sizeof(int));
 

-               exprexec(expr, buf, mask, &rs[tree->len]); 
+               exprexec(expr, buf, vb.mask, &rs[tree->len]);
+

                /* Append to our tree. */
 
                if (leaf >= 0) {
                /* Append to our tree. */
 
                if (leaf >= 0) {

-                       if (rec > rs[leaf].res.rec)
+                       if (vb.rec > rs[leaf].res.rec)

                                rs[leaf].rhs = tree->len;
                        else
                                rs[leaf].lhs = tree->len;
                } else
                        root = tree->len;
                                rs[leaf].rhs = tree->len;
                        else
                                rs[leaf].lhs = tree->len;
                } else
                        root = tree->len;

-               
+

                memset(&r, 0, sizeof(struct rec));
                tree->len++;
        }
                memset(&r, 0, sizeof(struct rec));
                tree->len++;
        }

-       
+

        (*btree->close)(btree);
        (*idx->close)(idx);
 
        (*btree->close)(btree);
        (*idx->close)(idx);
 


@@ -562,6 +572,7 @@ static void
 recfree(struct rec *rec)
 {
 
 recfree(struct rec *rec)
 {
 

+       free(rec->res.type);

        free(rec->res.file);
        free(rec->res.cat);
        free(rec->res.title);
        free(rec->res.file);
        free(rec->res.cat);
        free(rec->res.title);


@@ -571,6 +582,49 @@ recfree(struct rec *rec)
        free(rec->matches);
 }
 
        free(rec->matches);
 }
 

+/*
+ * Compile a list of straight-up terms.
+ * The arguments are re-written into ~[[:<:]]term[[:>:]], or "term"
+ * surrounded by word boundaries, then pumped through exprterm().
+ * Terms are case-insensitive.
+ * This emulates whatis(1) behaviour.
+ */
+struct expr *
+termcomp(int argc, char *argv[], size_t *tt)
+{
+       char            *buf;
+       int              pos;
+       struct expr     *e, *next;
+       size_t           sz;
+
+       buf = NULL;
+       e = NULL;
+       *tt = 0;
+
+       for (pos = argc - 1; pos >= 0; pos--) {
+               sz = strlen(argv[pos]) + 18;
+               buf = mandoc_realloc(buf, sz);
+               strlcpy(buf, "Nm~[[:<:]]", sz);
+               strlcat(buf, argv[pos], sz);
+               strlcat(buf, "[[:>:]]", sz);
+               if (NULL == (next = exprterm(buf, 0))) {
+                       free(buf);
+                       exprfree(e);
+                       return(NULL);
+               }
+               next->next = e;
+               e = next;
+               (*tt)++;
+       }
+
+       free(buf);
+       return(e);
+}
+
+/*
+ * Compile a sequence of logical expressions.
+ * See apropos.1 for a grammar of this sequence.
+ */

 struct expr *
 exprcomp(int argc, char *argv[], size_t *tt)
 {
 struct expr *
 exprcomp(int argc, char *argv[], size_t *tt)
 {


@@ -625,7 +679,7 @@ exprexpr(int argc, char *argv[], int *pos, int *lvl, size_t *tt)
                log = 0;
 
                if (NULL != e && 0 == strcmp("-a", argv[*pos]))
                log = 0;
 
                if (NULL != e && 0 == strcmp("-a", argv[*pos]))

-                       log = 1;                        
+                       log = 1;

                else if (NULL != e && 0 == strcmp("-o", argv[*pos]))
                        log = 2;
 
                else if (NULL != e && 0 == strcmp("-o", argv[*pos]))
                        log = 2;
 


@@ -642,7 +696,6 @@ exprexpr(int argc, char *argv[], int *pos, int *lvl, size_t *tt)
                        ++(*pos);
                        ++(*lvl);
                        next = mandoc_calloc(1, sizeof(struct expr));
                        ++(*pos);
                        ++(*lvl);
                        next = mandoc_calloc(1, sizeof(struct expr));

-                       next->cs = 1;

                        next->subexpr = exprexpr(argc, argv, pos, lvl, tt);
                        if (NULL == next->subexpr) {
                                free(next);
                        next->subexpr = exprexpr(argc, argv, pos, lvl, tt);
                        if (NULL == next->subexpr) {
                                free(next);


@@ -693,8 +746,6 @@ exprterm(char *buf, int cs)
 
        memset(&e, 0, sizeof(struct expr));
 
 
        memset(&e, 0, sizeof(struct expr));
 

-       e.cs = cs;
-

        /* Choose regex or substring match. */
 
        if (NULL == (e.v = strpbrk(buf, "=~"))) {
        /* Choose regex or substring match. */
 
        if (NULL == (e.v = strpbrk(buf, "=~"))) {


@@ -721,7 +772,7 @@ exprterm(char *buf, int cs)
                e.mask = TYPE_Nm | TYPE_Nd;
 
        if (e.regex) {
                e.mask = TYPE_Nm | TYPE_Nd;
 
        if (e.regex) {

-               i = REG_EXTENDED | REG_NOSUB | cs ? 0 : REG_ICASE;
+               i = REG_EXTENDED | REG_NOSUB | (cs ? 0 : REG_ICASE);

                if (regcomp(&e.re, e.v, i))
                        return(NULL);
        }
                if (regcomp(&e.re, e.v, i))
                        return(NULL);
        }


@@ -737,7 +788,7 @@ void
 exprfree(struct expr *p)
 {
        struct expr     *pp;
 exprfree(struct expr *p)
 {
        struct expr     *pp;

-       
+

        while (NULL != p) {
                if (p->subexpr)
                        exprfree(p->subexpr);
        while (NULL != p) {
                if (p->subexpr)
                        exprfree(p->subexpr);


@@ -751,7 +802,7 @@ exprfree(struct expr *p)
 }
 
 static int
 }
 
 static int

-exprmark(const struct expr *p, const char *cp, 
+exprmark(const struct expr *p, const char *cp,

                uint64_t mask, int *ms)
 {
 
                uint64_t mask, int *ms)
 {
 


@@ -766,13 +817,8 @@ exprmark(const struct expr *p, const char *cp,
                if (p->regex) {
                        if (regexec(&p->re, cp, 0, NULL, 0))
                                continue;
                if (p->regex) {
                        if (regexec(&p->re, cp, 0, NULL, 0))
                                continue;

-               } else if (p->cs) {
-                       if (NULL == strstr(cp, p->v))
-                               continue;
-               } else {
-                       if (NULL == strcasestr(cp, p->v))
-                               continue;
-               }
+               } else if (NULL == strcasestr(cp, p->v))
+                       continue;

 
                if (NULL == ms)
                        return(1);
 
                if (NULL == ms)
                        return(1);


@@ -806,7 +852,7 @@ expreval(const struct expr *p, int *ms)
                for ( ; p->next && p->next->and; p = p->next) {
                        /* Evaluate a subexpression, if applicable. */
                        if (p->next->subexpr && ! ms[p->next->index])
                for ( ; p->next && p->next->and; p = p->next) {
                        /* Evaluate a subexpression, if applicable. */
                        if (p->next->subexpr && ! ms[p->next->index])

-                               ms[p->next->index] = 
+                               ms[p->next->index] =

                                        expreval(p->next->subexpr, ms);
                        match = match && ms[p->next->index];
                }
                                        expreval(p->next->subexpr, ms);
                        match = match && ms[p->next->index];
                }


@@ -823,11 +869,11 @@ expreval(const struct expr *p, int *ms)
  * If this evaluates to true, mark the expression as satisfied.
  */
 static void
  * If this evaluates to true, mark the expression as satisfied.
  */
 static void

-exprexec(const struct expr *p, const char *cp, 
+exprexec(const struct expr *e, const char *cp,

                uint64_t mask, struct rec *r)
 {
 
        assert(0 == r->matched);
                uint64_t mask, struct rec *r)
 {
 
        assert(0 == r->matched);

-       exprmark(p, cp, mask, r->matches);
-       r->matched = expreval(p, r->matches);
+       exprmark(e, cp, mask, r->matches);
+       r->matched = expreval(e, r->matches);

 }
 }