version 1.15, 2014/01/05 03:06:43 |
version 1.72, 2017/04/18 15:06:49 |
|
|
/* $Id$ */ |
/* $OpenBSD$ */ |
/* |
/* |
* Copyright (c) 2012 Kristaps Dzonsons <kristaps@bsd.lv> |
* Copyright (c) 2012 Kristaps Dzonsons <kristaps@bsd.lv> |
* Copyright (c) 2013, 2014 Ingo Schwarze <schwarze@openbsd.org> |
* Copyright (c) 2013-2017 Ingo Schwarze <schwarze@openbsd.org> |
* |
* |
* Permission to use, copy, modify, and distribute this software for any |
* Permission to use, copy, modify, and distribute this software for any |
* purpose with or without fee is hereby granted, provided that the above |
* purpose with or without fee is hereby granted, provided that the above |
* copyright notice and this permission notice appear in all copies. |
* copyright notice and this permission notice appear in all copies. |
* |
* |
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES |
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHORS DISCLAIM ALL WARRANTIES |
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR |
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR |
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN |
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN |
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF |
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF |
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
*/ |
*/ |
#ifdef HAVE_CONFIG_H |
|
#include "config.h" |
#include "config.h" |
#endif |
|
|
|
|
#include <sys/mman.h> |
|
#include <sys/types.h> |
|
|
#include <assert.h> |
#include <assert.h> |
|
#if HAVE_ERR |
|
#include <err.h> |
|
#endif |
|
#include <errno.h> |
#include <fcntl.h> |
#include <fcntl.h> |
#include <getopt.h> |
#include <glob.h> |
#include <limits.h> |
#include <limits.h> |
#include <regex.h> |
#include <regex.h> |
#include <stdio.h> |
#include <stdio.h> |
|
|
#include <string.h> |
#include <string.h> |
#include <unistd.h> |
#include <unistd.h> |
|
|
#ifdef HAVE_OHASH |
|
#include <ohash.h> |
|
#else |
|
#include "compat_ohash.h" |
|
#endif |
|
#include <sqlite3.h> |
|
|
|
#include "mandoc.h" |
#include "mandoc.h" |
#include "manpath.h" |
#include "mandoc_aux.h" |
|
#include "mandoc_ohash.h" |
|
#include "manconf.h" |
#include "mansearch.h" |
#include "mansearch.h" |
|
#include "dbm.h" |
|
|
#define SQL_BIND_TEXT(_db, _s, _i, _v) \ |
|
do { if (SQLITE_OK != sqlite3_bind_text \ |
|
((_s), (_i)++, (_v), -1, SQLITE_STATIC)) \ |
|
fprintf(stderr, "%s\n", sqlite3_errmsg((_db))); \ |
|
} while (0) |
|
#define SQL_BIND_INT64(_db, _s, _i, _v) \ |
|
do { if (SQLITE_OK != sqlite3_bind_int64 \ |
|
((_s), (_i)++, (_v))) \ |
|
fprintf(stderr, "%s\n", sqlite3_errmsg((_db))); \ |
|
} while (0) |
|
#define SQL_BIND_BLOB(_db, _s, _i, _v) \ |
|
do { if (SQLITE_OK != sqlite3_bind_blob \ |
|
((_s), (_i)++, (&_v), sizeof(_v), SQLITE_STATIC)) \ |
|
fprintf(stderr, "%s\n", sqlite3_errmsg((_db))); \ |
|
} while (0) |
|
|
|
struct expr { |
struct expr { |
uint64_t bits; /* type-mask */ |
/* Used for terms: */ |
const char *substr; /* to search for, if applicable */ |
struct dbm_match match; /* Match type and expression. */ |
regex_t regexp; /* compiled regexp, if applicable */ |
uint64_t bits; /* Type mask. */ |
int open; /* opening parentheses before */ |
/* Used for OR and AND groups: */ |
int and; /* logical AND before */ |
struct expr *next; /* Next child in the parent group. */ |
int close; /* closing parentheses after */ |
struct expr *child; /* First child in this group. */ |
struct expr *next; /* next in sequence */ |
enum { EXPR_TERM, EXPR_OR, EXPR_AND } type; |
}; |
}; |
|
|
struct match { |
const char *const mansearch_keynames[KEY_MAX] = { |
uint64_t id; /* identifier in database */ |
"arch", "sec", "Xr", "Ar", "Fa", "Fl", "Dv", "Fn", |
char *file; /* relative filepath of manpage */ |
"Ic", "Pa", "Cm", "Li", "Em", "Cd", "Va", "Ft", |
char *desc; /* description of manpage */ |
"Tn", "Er", "Ev", "Sy", "Sh", "In", "Ss", "Ox", |
int form; /* 0 == catpage */ |
"An", "Mt", "St", "Bx", "At", "Nx", "Fx", "Lk", |
|
"Ms", "Bsx", "Dx", "Rs", "Vt", "Lb", "Nm", "Nd" |
}; |
}; |
|
|
struct type { |
|
uint64_t bits; |
|
const char *name; |
|
}; |
|
|
|
static const struct type types[] = { |
static struct ohash *manmerge(struct expr *, struct ohash *); |
{ TYPE_An, "An" }, |
static struct ohash *manmerge_term(struct expr *, struct ohash *); |
{ TYPE_Ar, "Ar" }, |
static struct ohash *manmerge_or(struct expr *, struct ohash *); |
{ TYPE_At, "At" }, |
static struct ohash *manmerge_and(struct expr *, struct ohash *); |
{ TYPE_Bsx, "Bsx" }, |
static char *buildnames(const struct dbm_page *); |
{ TYPE_Bx, "Bx" }, |
static char *buildoutput(size_t, struct dbm_page *); |
{ TYPE_Cd, "Cd" }, |
static size_t lstlen(const char *, size_t); |
{ TYPE_Cm, "Cm" }, |
static void lstcat(char *, size_t *, const char *, const char *); |
{ TYPE_Dv, "Dv" }, |
static int lstmatch(const char *, const char *); |
{ TYPE_Dx, "Dx" }, |
static struct expr *exprcomp(const struct mansearch *, |
{ TYPE_Em, "Em" }, |
int, char *[], int *); |
{ TYPE_Er, "Er" }, |
static struct expr *expr_and(const struct mansearch *, |
{ TYPE_Ev, "Ev" }, |
int, char *[], int *); |
{ TYPE_Fa, "Fa" }, |
static struct expr *exprterm(const struct mansearch *, |
{ TYPE_Fl, "Fl" }, |
int, char *[], int *); |
{ TYPE_Fn, "Fn" }, |
|
{ TYPE_Fn, "Fo" }, |
|
{ TYPE_Ft, "Ft" }, |
|
{ TYPE_Fx, "Fx" }, |
|
{ TYPE_Ic, "Ic" }, |
|
{ TYPE_In, "In" }, |
|
{ TYPE_Lb, "Lb" }, |
|
{ TYPE_Li, "Li" }, |
|
{ TYPE_Lk, "Lk" }, |
|
{ TYPE_Ms, "Ms" }, |
|
{ TYPE_Mt, "Mt" }, |
|
{ TYPE_Nd, "Nd" }, |
|
{ TYPE_Nm, "Nm" }, |
|
{ TYPE_Nx, "Nx" }, |
|
{ TYPE_Ox, "Ox" }, |
|
{ TYPE_Pa, "Pa" }, |
|
{ TYPE_Rs, "Rs" }, |
|
{ TYPE_Sh, "Sh" }, |
|
{ TYPE_Ss, "Ss" }, |
|
{ TYPE_St, "St" }, |
|
{ TYPE_Sy, "Sy" }, |
|
{ TYPE_Tn, "Tn" }, |
|
{ TYPE_Va, "Va" }, |
|
{ TYPE_Va, "Vt" }, |
|
{ TYPE_Xr, "Xr" }, |
|
{ TYPE_sec, "sec" }, |
|
{ TYPE_arch,"arch" }, |
|
{ ~0ULL, "any" }, |
|
{ 0ULL, NULL } |
|
}; |
|
|
|
static char *buildnames(sqlite3 *, sqlite3_stmt *, uint64_t); |
|
static char *buildoutput(sqlite3 *, sqlite3_stmt *, |
|
uint64_t, uint64_t); |
|
static void *hash_alloc(size_t, void *); |
|
static void hash_free(void *, size_t, void *); |
|
static void *hash_halloc(size_t, void *); |
|
static struct expr *exprcomp(const struct mansearch *, |
|
int, char *[]); |
|
static void exprfree(struct expr *); |
static void exprfree(struct expr *); |
static struct expr *exprspec(struct expr *, uint64_t, |
static int manpage_compare(const void *, const void *); |
const char *, const char *); |
|
static struct expr *exprterm(const struct mansearch *, char *, int); |
|
static void sql_append(char **sql, size_t *sz, |
|
const char *newstr, int count); |
|
static void sql_match(sqlite3_context *context, |
|
int argc, sqlite3_value **argv); |
|
static void sql_regexp(sqlite3_context *context, |
|
int argc, sqlite3_value **argv); |
|
static char *sql_statement(const struct expr *); |
|
|
|
|
|
int |
int |
mansearch(const struct mansearch *search, |
mansearch(const struct mansearch *search, |
const struct manpaths *paths, |
const struct manpaths *paths, |
int argc, char *argv[], |
int argc, char *argv[], |
const char *outkey, |
|
struct manpage **res, size_t *sz) |
struct manpage **res, size_t *sz) |
{ |
{ |
int fd, rc, c, ibit; |
|
int64_t id; |
|
uint64_t outbit; |
|
char buf[PATH_MAX]; |
char buf[PATH_MAX]; |
char *sql; |
struct dbm_res *rp; |
|
struct expr *e; |
|
struct dbm_page *page; |
struct manpage *mpage; |
struct manpage *mpage; |
struct expr *e, *ep; |
struct ohash *htab; |
sqlite3 *db; |
size_t cur, i, maxres, outkey; |
sqlite3_stmt *s, *s2; |
unsigned int slot; |
struct match *mp; |
int argi, chdir_status, getcwd_status, im; |
struct ohash_info info; |
|
struct ohash htab; |
|
unsigned int idx; |
|
size_t i, j, cur, maxres; |
|
|
|
memset(&info, 0, sizeof(struct ohash_info)); |
argi = 0; |
|
if ((e = exprcomp(search, argc, argv, &argi)) == NULL) { |
|
*sz = 0; |
|
return 0; |
|
} |
|
|
info.halloc = hash_halloc; |
cur = maxres = 0; |
info.alloc = hash_alloc; |
|
info.hfree = hash_free; |
|
info.key_offset = offsetof(struct match, id); |
|
|
|
*sz = cur = maxres = 0; |
|
sql = NULL; |
|
*res = NULL; |
*res = NULL; |
fd = -1; |
|
e = NULL; |
|
rc = 0; |
|
|
|
if (0 == argc) |
outkey = KEY_Nd; |
goto out; |
if (search->outkey != NULL) |
if (NULL == (e = exprcomp(search, argc, argv))) |
for (im = 0; im < KEY_MAX; im++) |
goto out; |
if (0 == strcasecmp(search->outkey, |
|
mansearch_keynames[im])) { |
outbit = 0; |
outkey = im; |
if (NULL != outkey) { |
|
for (ibit = 0; types[ibit].bits; ibit++) { |
|
if (0 == strcasecmp(types[ibit].name, outkey)) { |
|
outbit = types[ibit].bits; |
|
break; |
break; |
} |
} |
} |
|
} |
|
|
|
/* |
/* |
* Save a descriptor to the current working directory. |
* Remember the original working directory, if possible. |
* Since pathnames in the "paths" variable might be relative, |
* This will be needed if the second or a later directory |
* and we'll be chdir()ing into them, we need to keep a handle |
* is given as a relative path. |
* on our current directory from which to start the chdir(). |
* Do not error out if the current directory is not |
|
* searchable: Maybe it won't be needed after all. |
*/ |
*/ |
|
|
if (NULL == getcwd(buf, PATH_MAX)) { |
if (getcwd(buf, PATH_MAX) == NULL) { |
perror(NULL); |
getcwd_status = 0; |
goto out; |
(void)strlcpy(buf, strerror(errno), sizeof(buf)); |
} else if (-1 == (fd = open(buf, O_RDONLY, 0))) { |
} else |
perror(buf); |
getcwd_status = 1; |
goto out; |
|
} |
|
|
|
sql = sql_statement(e); |
|
|
|
/* |
/* |
* Loop over the directories (containing databases) for us to |
* Loop over the directories (containing databases) for us to |
* search. |
* search. |
Line 222 mansearch(const struct mansearch *search, |
|
Line 137 mansearch(const struct mansearch *search, |
|
* scan it for our match expression. |
* scan it for our match expression. |
*/ |
*/ |
|
|
|
chdir_status = 0; |
for (i = 0; i < paths->sz; i++) { |
for (i = 0; i < paths->sz; i++) { |
if (-1 == fchdir(fd)) { |
if (chdir_status && paths->paths[i][0] != '/') { |
perror(buf); |
if ( ! getcwd_status) { |
free(*res); |
warnx("%s: getcwd: %s", paths->paths[i], buf); |
break; |
continue; |
} else if (-1 == chdir(paths->paths[i])) { |
} else if (chdir(buf) == -1) { |
perror(paths->paths[i]); |
warn("%s", buf); |
|
continue; |
|
} |
|
} |
|
if (chdir(paths->paths[i]) == -1) { |
|
warn("%s", paths->paths[i]); |
continue; |
continue; |
} |
} |
|
chdir_status = 1; |
|
|
c = sqlite3_open_v2 |
if (dbm_open(MANDOC_DB) == -1) { |
(MANDOC_DB, &db, |
warn("%s/%s", paths->paths[i], MANDOC_DB); |
SQLITE_OPEN_READONLY, NULL); |
continue; |
|
} |
|
|
if (SQLITE_OK != c) { |
if ((htab = manmerge(e, NULL)) == NULL) { |
perror(MANDOC_DB); |
dbm_close(); |
sqlite3_close(db); |
|
continue; |
continue; |
} |
} |
|
|
|
for (rp = ohash_first(htab, &slot); rp != NULL; |
|
rp = ohash_next(htab, &slot)) { |
|
page = dbm_page_get(rp->page); |
|
|
|
if (lstmatch(search->sec, page->sect) == 0 || |
|
lstmatch(search->arch, page->arch) == 0) |
|
continue; |
|
|
|
if (cur + 1 > maxres) { |
|
maxres += 1024; |
|
*res = mandoc_reallocarray(*res, |
|
maxres, sizeof(**res)); |
|
} |
|
mpage = *res + cur; |
|
mandoc_asprintf(&mpage->file, "%s/%s", |
|
paths->paths[i], page->file + 1); |
|
mpage->names = buildnames(page); |
|
mpage->output = buildoutput(outkey, page); |
|
mpage->ipath = i; |
|
mpage->bits = rp->bits; |
|
mpage->sec = *page->sect - '0'; |
|
if (mpage->sec < 0 || mpage->sec > 9) |
|
mpage->sec = 10; |
|
mpage->form = *page->file; |
|
free(rp); |
|
cur++; |
|
} |
|
ohash_delete(htab); |
|
free(htab); |
|
dbm_close(); |
|
|
/* |
/* |
* Define the SQL functions for substring |
* In man(1) mode, prefer matches in earlier trees |
* and regular expression matching. |
* over matches in later trees. |
*/ |
*/ |
|
|
c = sqlite3_create_function(db, "match", 2, |
if (cur && search->firstmatch) |
SQLITE_ANY, NULL, sql_match, NULL, NULL); |
break; |
assert(SQLITE_OK == c); |
} |
c = sqlite3_create_function(db, "regexp", 2, |
qsort(*res, cur, sizeof(struct manpage), manpage_compare); |
SQLITE_ANY, NULL, sql_regexp, NULL, NULL); |
if (chdir_status && getcwd_status && chdir(buf) == -1) |
assert(SQLITE_OK == c); |
warn("%s", buf); |
|
exprfree(e); |
|
*sz = cur; |
|
return 1; |
|
} |
|
|
j = 1; |
/* |
c = sqlite3_prepare_v2(db, sql, -1, &s, NULL); |
* Merge the results for the expression tree rooted at e |
if (SQLITE_OK != c) |
* into the the result list htab. |
fprintf(stderr, "%s\n", sqlite3_errmsg(db)); |
*/ |
|
static struct ohash * |
|
manmerge(struct expr *e, struct ohash *htab) |
|
{ |
|
switch (e->type) { |
|
case EXPR_TERM: |
|
return manmerge_term(e, htab); |
|
case EXPR_OR: |
|
return manmerge_or(e->child, htab); |
|
case EXPR_AND: |
|
return manmerge_and(e->child, htab); |
|
default: |
|
abort(); |
|
} |
|
} |
|
|
for (ep = e; NULL != ep; ep = ep->next) { |
static struct ohash * |
if (NULL == ep->substr) { |
manmerge_term(struct expr *e, struct ohash *htab) |
SQL_BIND_BLOB(db, s, j, ep->regexp); |
{ |
} else |
struct dbm_res res, *rp; |
SQL_BIND_TEXT(db, s, j, ep->substr); |
uint64_t ib; |
SQL_BIND_INT64(db, s, j, ep->bits); |
unsigned int slot; |
} |
int im; |
|
|
memset(&htab, 0, sizeof(struct ohash)); |
if (htab == NULL) { |
ohash_init(&htab, 4, &info); |
htab = mandoc_malloc(sizeof(*htab)); |
|
mandoc_ohash_init(htab, 4, offsetof(struct dbm_res, page)); |
|
} |
|
|
|
for (im = 0, ib = 1; im < KEY_MAX; im++, ib <<= 1) { |
|
if ((e->bits & ib) == 0) |
|
continue; |
|
|
|
switch (ib) { |
|
case TYPE_arch: |
|
dbm_page_byarch(&e->match); |
|
break; |
|
case TYPE_sec: |
|
dbm_page_bysect(&e->match); |
|
break; |
|
case TYPE_Nm: |
|
dbm_page_byname(&e->match); |
|
break; |
|
case TYPE_Nd: |
|
dbm_page_bydesc(&e->match); |
|
break; |
|
default: |
|
dbm_page_bymacro(im - 2, &e->match); |
|
break; |
|
} |
|
|
/* |
/* |
* Hash each entry on its [unique] document identifier. |
* When hashing for deduplication, use the unique |
* This is a uint64_t. |
* page ID itself instead of a hash function; |
* Instead of using a hash function, simply convert the |
* that is quite efficient. |
* uint64_t to a uint32_t, the hash value's type. |
|
* This gives good performance and preserves the |
|
* distribution of buckets in the table. |
|
*/ |
*/ |
while (SQLITE_ROW == (c = sqlite3_step(s))) { |
|
id = sqlite3_column_int64(s, 5); |
|
idx = ohash_lookup_memory |
|
(&htab, (char *)&id, |
|
sizeof(uint64_t), (uint32_t)id); |
|
|
|
if (NULL != ohash_find(&htab, idx)) |
for (;;) { |
|
res = dbm_page_next(); |
|
if (res.page == -1) |
|
break; |
|
slot = ohash_lookup_memory(htab, |
|
(char *)&res, sizeof(res.page), res.page); |
|
if ((rp = ohash_find(htab, slot)) != NULL) { |
|
rp->bits |= res.bits; |
continue; |
continue; |
|
} |
mp = mandoc_calloc(1, sizeof(struct match)); |
rp = mandoc_malloc(sizeof(*rp)); |
mp->id = id; |
*rp = res; |
mp->file = mandoc_strdup |
ohash_insert(htab, slot, rp); |
((char *)sqlite3_column_text(s, 0)); |
|
mp->desc = mandoc_strdup |
|
((char *)sqlite3_column_text(s, 3)); |
|
mp->form = sqlite3_column_int(s, 4); |
|
ohash_insert(&htab, idx, mp); |
|
} |
} |
|
} |
|
return htab; |
|
} |
|
|
if (SQLITE_DONE != c) |
static struct ohash * |
fprintf(stderr, "%s\n", sqlite3_errmsg(db)); |
manmerge_or(struct expr *e, struct ohash *htab) |
|
{ |
|
while (e != NULL) { |
|
htab = manmerge(e, htab); |
|
e = e->next; |
|
} |
|
return htab; |
|
} |
|
|
sqlite3_finalize(s); |
static struct ohash * |
|
manmerge_and(struct expr *e, struct ohash *htab) |
|
{ |
|
struct ohash *hand, *h1, *h2; |
|
struct dbm_res *res; |
|
unsigned int slot1, slot2; |
|
|
c = sqlite3_prepare_v2(db, |
/* Evaluate the first term of the AND clause. */ |
"SELECT * FROM mlinks WHERE pageid=?", |
|
-1, &s, NULL); |
|
if (SQLITE_OK != c) |
|
fprintf(stderr, "%s\n", sqlite3_errmsg(db)); |
|
|
|
c = sqlite3_prepare_v2(db, |
hand = manmerge(e, NULL); |
"SELECT * FROM keys WHERE pageid=? AND bits & ?", |
|
-1, &s2, NULL); |
|
if (SQLITE_OK != c) |
|
fprintf(stderr, "%s\n", sqlite3_errmsg(db)); |
|
|
|
for (mp = ohash_first(&htab, &idx); |
while ((e = e->next) != NULL) { |
NULL != mp; |
|
mp = ohash_next(&htab, &idx)) { |
|
if (cur + 1 > maxres) { |
|
maxres += 1024; |
|
*res = mandoc_realloc |
|
(*res, maxres * sizeof(struct manpage)); |
|
} |
|
mpage = *res + cur; |
|
if (-1 == asprintf(&mpage->file, "%s/%s", |
|
paths->paths[i], mp->file)) { |
|
perror(0); |
|
exit((int)MANDOCLEVEL_SYSERR); |
|
} |
|
mpage->desc = mp->desc; |
|
mpage->form = mp->form; |
|
mpage->names = buildnames(db, s, mp->id); |
|
mpage->output = outbit ? |
|
buildoutput(db, s2, mp->id, outbit) : NULL; |
|
|
|
free(mp->file); |
/* Evaluate the next term and prepare for ANDing. */ |
free(mp); |
|
cur++; |
h2 = manmerge(e, NULL); |
|
if (ohash_entries(h2) < ohash_entries(hand)) { |
|
h1 = h2; |
|
h2 = hand; |
|
} else |
|
h1 = hand; |
|
hand = mandoc_malloc(sizeof(*hand)); |
|
mandoc_ohash_init(hand, 4, offsetof(struct dbm_res, page)); |
|
|
|
/* Keep all pages that are in both result sets. */ |
|
|
|
for (res = ohash_first(h1, &slot1); res != NULL; |
|
res = ohash_next(h1, &slot1)) { |
|
if (ohash_find(h2, ohash_lookup_memory(h2, |
|
(char *)res, sizeof(res->page), |
|
res->page)) == NULL) |
|
free(res); |
|
else |
|
ohash_insert(hand, ohash_lookup_memory(hand, |
|
(char *)res, sizeof(res->page), |
|
res->page), res); |
} |
} |
|
|
sqlite3_finalize(s); |
/* Discard the merged results. */ |
sqlite3_finalize(s2); |
|
sqlite3_close(db); |
for (res = ohash_first(h2, &slot2); res != NULL; |
ohash_delete(&htab); |
res = ohash_next(h2, &slot2)) |
|
free(res); |
|
ohash_delete(h2); |
|
free(h2); |
|
ohash_delete(h1); |
|
free(h1); |
} |
} |
rc = 1; |
|
out: |
/* Merge the result of the AND into htab. */ |
exprfree(e); |
|
if (-1 != fd) |
if (htab == NULL) |
close(fd); |
return hand; |
free(sql); |
|
*sz = cur; |
for (res = ohash_first(hand, &slot1); res != NULL; |
return(rc); |
res = ohash_next(hand, &slot1)) { |
|
slot2 = ohash_lookup_memory(htab, |
|
(char *)res, sizeof(res->page), res->page); |
|
if (ohash_find(htab, slot2) == NULL) |
|
ohash_insert(htab, slot2, res); |
|
else |
|
free(res); |
|
} |
|
|
|
/* Discard the merged result. */ |
|
|
|
ohash_delete(hand); |
|
free(hand); |
|
return htab; |
} |
} |
|
|
static char * |
void |
buildnames(sqlite3 *db, sqlite3_stmt *s, uint64_t id) |
mansearch_free(struct manpage *res, size_t sz) |
{ |
{ |
char *names, *newnames; |
size_t i; |
const char *oldnames, *sep1, *name, *sec, *sep2, *arch; |
|
size_t i; |
|
int c; |
|
|
|
names = NULL; |
for (i = 0; i < sz; i++) { |
i = 1; |
free(res[i].file); |
SQL_BIND_INT64(db, s, i, id); |
free(res[i].names); |
while (SQLITE_ROW == (c = sqlite3_step(s))) { |
free(res[i].output); |
if (NULL == names) { |
|
oldnames = ""; |
|
sep1 = ""; |
|
} else { |
|
oldnames = names; |
|
sep1 = ", "; |
|
} |
|
sec = sqlite3_column_text(s, 1); |
|
arch = sqlite3_column_text(s, 2); |
|
name = sqlite3_column_text(s, 3); |
|
sep2 = '\0' == *arch ? "" : "/"; |
|
if (-1 == asprintf(&newnames, "%s%s%s(%s%s%s)", |
|
oldnames, sep1, name, sec, sep2, arch)) { |
|
perror(0); |
|
exit((int)MANDOCLEVEL_SYSERR); |
|
} |
|
free(names); |
|
names = newnames; |
|
} |
} |
if (SQLITE_DONE != c) |
free(res); |
fprintf(stderr, "%s\n", sqlite3_errmsg(db)); |
|
sqlite3_reset(s); |
|
return(names); |
|
} |
} |
|
|
|
static int |
|
manpage_compare(const void *vp1, const void *vp2) |
|
{ |
|
const struct manpage *mp1, *mp2; |
|
int diff; |
|
|
|
mp1 = vp1; |
|
mp2 = vp2; |
|
return (diff = mp2->bits - mp1->bits) ? diff : |
|
(diff = mp1->sec - mp2->sec) ? diff : |
|
strcasecmp(mp1->names, mp2->names); |
|
} |
|
|
static char * |
static char * |
buildoutput(sqlite3 *db, sqlite3_stmt *s, uint64_t id, uint64_t outbit) |
buildnames(const struct dbm_page *page) |
{ |
{ |
char *output, *newoutput; |
char *buf; |
const char *oldoutput, *sep1, *data; |
size_t i, sz; |
size_t i; |
|
int c; |
|
|
|
output = NULL; |
sz = lstlen(page->name, 2) + 1 + lstlen(page->sect, 2) + |
i = 1; |
(page->arch == NULL ? 0 : 1 + lstlen(page->arch, 2)) + 2; |
SQL_BIND_INT64(db, s, i, id); |
buf = mandoc_malloc(sz); |
SQL_BIND_INT64(db, s, i, outbit); |
i = 0; |
while (SQLITE_ROW == (c = sqlite3_step(s))) { |
lstcat(buf, &i, page->name, ", "); |
if (NULL == output) { |
buf[i++] = '('; |
oldoutput = ""; |
lstcat(buf, &i, page->sect, ", "); |
sep1 = ""; |
if (page->arch != NULL) { |
} else { |
buf[i++] = '/'; |
oldoutput = output; |
lstcat(buf, &i, page->arch, ", "); |
sep1 = " # "; |
|
} |
|
data = sqlite3_column_text(s, 1); |
|
if (-1 == asprintf(&newoutput, "%s%s%s", |
|
oldoutput, sep1, data)) { |
|
perror(0); |
|
exit((int)MANDOCLEVEL_SYSERR); |
|
} |
|
free(output); |
|
output = newoutput; |
|
} |
} |
if (SQLITE_DONE != c) |
buf[i++] = ')'; |
fprintf(stderr, "%s\n", sqlite3_errmsg(db)); |
buf[i++] = '\0'; |
sqlite3_reset(s); |
assert(i == sz); |
return(output); |
return buf; |
} |
} |
|
|
/* |
/* |
* Implement substring match as an application-defined SQL function. |
* Count the buffer space needed to print the NUL-terminated |
* Using the SQL LIKE or GLOB operators instead would be a bad idea |
* list of NUL-terminated strings, when printing sep separator |
* because that would require escaping metacharacters in the string |
* characters between strings. |
* being searched for. |
|
*/ |
*/ |
static void |
static size_t |
sql_match(sqlite3_context *context, int argc, sqlite3_value **argv) |
lstlen(const char *cp, size_t sep) |
{ |
{ |
|
size_t sz; |
|
|
assert(2 == argc); |
for (sz = 0;; sz++) { |
sqlite3_result_int(context, NULL != strcasestr( |
if (cp[0] == '\0') { |
(const char *)sqlite3_value_text(argv[1]), |
if (cp[1] == '\0') |
(const char *)sqlite3_value_text(argv[0]))); |
break; |
|
sz += sep - 1; |
|
} else if (cp[0] < ' ') |
|
sz--; |
|
cp++; |
|
} |
|
return sz; |
} |
} |
|
|
/* |
/* |
* Implement regular expression match |
* Print the NUL-terminated list of NUL-terminated strings |
* as an application-defined SQL function. |
* into the buffer, seperating strings with sep. |
*/ |
*/ |
static void |
static void |
sql_regexp(sqlite3_context *context, int argc, sqlite3_value **argv) |
lstcat(char *buf, size_t *i, const char *cp, const char *sep) |
{ |
{ |
|
const char *s; |
|
|
assert(2 == argc); |
for (;;) { |
sqlite3_result_int(context, !regexec( |
if (cp[0] == '\0') { |
(regex_t *)sqlite3_value_blob(argv[0]), |
if (cp[1] == '\0') |
(const char *)sqlite3_value_text(argv[1]), |
break; |
0, NULL, 0)); |
s = sep; |
|
while (*s != '\0') |
|
buf[(*i)++] = *s++; |
|
} else if (cp[0] >= ' ') |
|
buf[(*i)++] = cp[0]; |
|
cp++; |
|
} |
} |
} |
|
|
static void |
/* |
sql_append(char **sql, size_t *sz, const char *newstr, int count) |
* Return 1 if the string *want occurs in any of the strings |
|
* in the NUL-terminated string list *have, or 0 otherwise. |
|
* If either argument is NULL or empty, assume no filtering |
|
* is desired and return 1. |
|
*/ |
|
static int |
|
lstmatch(const char *want, const char *have) |
{ |
{ |
size_t newsz; |
if (want == NULL || have == NULL || *have == '\0') |
|
return 1; |
newsz = 1 < count ? (size_t)count : strlen(newstr); |
while (*have != '\0') { |
*sql = mandoc_realloc(*sql, *sz + newsz + 1); |
if (strcasestr(have, want) != NULL) |
if (1 < count) |
return 1; |
memset(*sql + *sz, *newstr, (size_t)count); |
have = strchr(have, '\0') + 1; |
else |
} |
memcpy(*sql + *sz, newstr, newsz); |
return 0; |
*sz += newsz; |
|
(*sql)[*sz] = '\0'; |
|
} |
} |
|
|
/* |
/* |
* Prepare the search SQL statement. |
* Build a list of values taken by the macro im in the manual page. |
*/ |
*/ |
static char * |
static char * |
sql_statement(const struct expr *e) |
buildoutput(size_t im, struct dbm_page *page) |
{ |
{ |
char *sql; |
const char *oldoutput, *sep, *input; |
size_t sz; |
char *output, *newoutput, *value; |
int needop; |
size_t sz, i; |
|
|
sql = mandoc_strdup("SELECT * FROM mpages WHERE "); |
switch (im) { |
sz = strlen(sql); |
case KEY_Nd: |
|
return mandoc_strdup(page->desc); |
|
case KEY_Nm: |
|
input = page->name; |
|
break; |
|
case KEY_sec: |
|
input = page->sect; |
|
break; |
|
case KEY_arch: |
|
input = page->arch; |
|
if (input == NULL) |
|
input = "all\0"; |
|
break; |
|
default: |
|
input = NULL; |
|
break; |
|
} |
|
|
for (needop = 0; NULL != e; e = e->next) { |
if (input != NULL) { |
if (e->and) |
sz = lstlen(input, 3) + 1; |
sql_append(&sql, &sz, " AND ", 1); |
output = mandoc_malloc(sz); |
else if (needop) |
i = 0; |
sql_append(&sql, &sz, " OR ", 1); |
lstcat(output, &i, input, " # "); |
if (e->open) |
output[i++] = '\0'; |
sql_append(&sql, &sz, "(", e->open); |
assert(i == sz); |
sql_append(&sql, &sz, NULL == e->substr ? |
return output; |
"id IN (SELECT pageid FROM keys " |
|
"WHERE key REGEXP ? AND bits & ?)" : |
|
"id IN (SELECT pageid FROM keys " |
|
"WHERE key MATCH ? AND bits & ?)", 1); |
|
if (e->close) |
|
sql_append(&sql, &sz, ")", e->close); |
|
needop = 1; |
|
} |
} |
|
|
return(sql); |
output = NULL; |
|
dbm_macro_bypage(im - 2, page->addr); |
|
while ((value = dbm_macro_next()) != NULL) { |
|
if (output == NULL) { |
|
oldoutput = ""; |
|
sep = ""; |
|
} else { |
|
oldoutput = output; |
|
sep = " # "; |
|
} |
|
mandoc_asprintf(&newoutput, "%s%s%s", oldoutput, sep, value); |
|
free(output); |
|
output = newoutput; |
|
} |
|
return output; |
} |
} |
|
|
/* |
/* |
Line 511 sql_statement(const struct expr *e) |
|
Line 544 sql_statement(const struct expr *e) |
|
* "(", "foo=bar", etc.). |
* "(", "foo=bar", etc.). |
*/ |
*/ |
static struct expr * |
static struct expr * |
exprcomp(const struct mansearch *search, int argc, char *argv[]) |
exprcomp(const struct mansearch *search, int argc, char *argv[], int *argi) |
{ |
{ |
int i, toopen, logic, igncase, toclose; |
struct expr *parent, *child; |
struct expr *first, *next, *cur; |
int needterm, nested; |
|
|
first = cur = NULL; |
if ((nested = *argi) == argc) |
logic = igncase = toclose = 0; |
return NULL; |
toopen = 1; |
needterm = 1; |
|
parent = child = NULL; |
for (i = 0; i < argc; i++) { |
while (*argi < argc) { |
if (0 == strcmp("(", argv[i])) { |
if (strcmp(")", argv[*argi]) == 0) { |
if (igncase) |
if (needterm) |
goto fail; |
warnx("missing term " |
toopen++; |
"before closing parenthesis"); |
toclose++; |
needterm = 0; |
|
if (nested) |
|
break; |
|
warnx("ignoring unmatched right parenthesis"); |
|
++*argi; |
continue; |
continue; |
} else if (0 == strcmp(")", argv[i])) { |
} |
if (toopen || logic || igncase || NULL == cur) |
if (strcmp("-o", argv[*argi]) == 0) { |
goto fail; |
if (needterm) { |
cur->close++; |
if (*argi > 0) |
if (0 > --toclose) |
warnx("ignoring -o after %s", |
goto fail; |
argv[*argi - 1]); |
|
else |
|
warnx("ignoring initial -o"); |
|
} |
|
needterm = 1; |
|
++*argi; |
continue; |
continue; |
} else if (0 == strcmp("-a", argv[i])) { |
} |
if (toopen || logic || igncase || NULL == cur) |
needterm = 0; |
goto fail; |
if (child == NULL) { |
logic = 1; |
child = expr_and(search, argc, argv, argi); |
continue; |
continue; |
} else if (0 == strcmp("-o", argv[i])) { |
|
if (toopen || logic || igncase || NULL == cur) |
|
goto fail; |
|
logic = 2; |
|
continue; |
|
} else if (0 == strcmp("-i", argv[i])) { |
|
if (igncase) |
|
goto fail; |
|
igncase = 1; |
|
continue; |
|
} |
} |
next = exprterm(search, argv[i], !igncase); |
if (parent == NULL) { |
if (NULL == next) |
parent = mandoc_calloc(1, sizeof(*parent)); |
goto fail; |
parent->type = EXPR_OR; |
next->open = toopen; |
parent->next = NULL; |
next->and = (1 == logic); |
parent->child = child; |
if (NULL != first) { |
} |
cur->next = next; |
child->next = expr_and(search, argc, argv, argi); |
cur = next; |
child = child->next; |
} else |
|
cur = first = next; |
|
toopen = logic = igncase = 0; |
|
} |
} |
if (toopen || logic || igncase || toclose) |
if (needterm && *argi) |
goto fail; |
warnx("ignoring trailing %s", argv[*argi - 1]); |
|
return parent == NULL ? child : parent; |
cur->close++; |
|
cur = exprspec(cur, TYPE_arch, search->arch, "^(%s|any)$"); |
|
exprspec(cur, TYPE_sec, search->sec, "^%s$"); |
|
|
|
return(first); |
|
|
|
fail: |
|
if (NULL != first) |
|
exprfree(first); |
|
return(NULL); |
|
} |
} |
|
|
static struct expr * |
static struct expr * |
exprspec(struct expr *cur, uint64_t key, const char *value, |
expr_and(const struct mansearch *search, int argc, char *argv[], int *argi) |
const char *format) |
|
{ |
{ |
char errbuf[BUFSIZ]; |
struct expr *parent, *child; |
char *cp; |
int needterm; |
int irc; |
|
|
|
if (NULL == value) |
needterm = 1; |
return(cur); |
parent = child = NULL; |
|
while (*argi < argc) { |
if (-1 == asprintf(&cp, format, value)) { |
if (strcmp(")", argv[*argi]) == 0) { |
perror(0); |
if (needterm) |
exit((int)MANDOCLEVEL_SYSERR); |
warnx("missing term " |
|
"before closing parenthesis"); |
|
needterm = 0; |
|
break; |
|
} |
|
if (strcmp("-o", argv[*argi]) == 0) |
|
break; |
|
if (strcmp("-a", argv[*argi]) == 0) { |
|
if (needterm) { |
|
if (*argi > 0) |
|
warnx("ignoring -a after %s", |
|
argv[*argi - 1]); |
|
else |
|
warnx("ignoring initial -a"); |
|
} |
|
needterm = 1; |
|
++*argi; |
|
continue; |
|
} |
|
if (needterm == 0) |
|
break; |
|
if (child == NULL) { |
|
child = exprterm(search, argc, argv, argi); |
|
if (child != NULL) |
|
needterm = 0; |
|
continue; |
|
} |
|
needterm = 0; |
|
if (parent == NULL) { |
|
parent = mandoc_calloc(1, sizeof(*parent)); |
|
parent->type = EXPR_AND; |
|
parent->next = NULL; |
|
parent->child = child; |
|
} |
|
child->next = exprterm(search, argc, argv, argi); |
|
if (child->next != NULL) { |
|
child = child->next; |
|
needterm = 0; |
|
} |
} |
} |
cur->next = mandoc_calloc(1, sizeof(struct expr)); |
if (needterm && *argi) |
cur = cur->next; |
warnx("ignoring trailing %s", argv[*argi - 1]); |
cur->and = 1; |
return parent == NULL ? child : parent; |
cur->bits = key; |
|
if (0 != (irc = regcomp(&cur->regexp, cp, |
|
REG_EXTENDED | REG_NOSUB | REG_ICASE))) { |
|
regerror(irc, &cur->regexp, errbuf, sizeof(errbuf)); |
|
fprintf(stderr, "regcomp: %s\n", errbuf); |
|
cur->substr = value; |
|
} |
|
free(cp); |
|
return(cur); |
|
} |
} |
|
|
static struct expr * |
static struct expr * |
exprterm(const struct mansearch *search, char *buf, int cs) |
exprterm(const struct mansearch *search, int argc, char *argv[], int *argi) |
{ |
{ |
char errbuf[BUFSIZ]; |
char errbuf[BUFSIZ]; |
struct expr *e; |
struct expr *e; |
char *key, *v; |
char *key, *val; |
size_t i; |
uint64_t iterbit; |
int irc; |
int cs, i, irc; |
|
|
if ('\0' == *buf) |
if (strcmp("(", argv[*argi]) == 0) { |
return(NULL); |
++*argi; |
|
e = exprcomp(search, argc, argv, argi); |
|
if (*argi < argc) { |
|
assert(strcmp(")", argv[*argi]) == 0); |
|
++*argi; |
|
} else |
|
warnx("unclosed parenthesis"); |
|
return e; |
|
} |
|
|
e = mandoc_calloc(1, sizeof(struct expr)); |
if (strcmp("-i", argv[*argi]) == 0 && *argi + 1 < argc) { |
|
cs = 0; |
|
++*argi; |
|
} else |
|
cs = 1; |
|
|
/*"whatis" mode uses an opaque string and default fields. */ |
e = mandoc_calloc(1, sizeof(*e)); |
|
e->type = EXPR_TERM; |
|
e->bits = 0; |
|
e->next = NULL; |
|
e->child = NULL; |
|
|
if (MANSEARCH_WHATIS & search->flags) { |
if (search->argmode == ARG_NAME) { |
e->substr = buf; |
e->bits = TYPE_Nm; |
e->bits = search->deftype; |
e->match.type = DBM_EXACT; |
return(e); |
e->match.str = argv[(*argi)++]; |
|
return e; |
} |
} |
|
|
/* |
/* |
* If no =~ is specified, search with equality over names and |
* Separate macro keys from search string. |
* descriptions. |
* If needed, request regular expression handling. |
* If =~ begins the phrase, use name and description fields. |
|
*/ |
*/ |
|
|
if (NULL == (v = strpbrk(buf, "=~"))) { |
if (search->argmode == ARG_WORD) { |
e->substr = buf; |
e->bits = TYPE_Nm; |
e->bits = search->deftype; |
e->match.type = DBM_REGEX; |
return(e); |
#if HAVE_REWB_BSD |
} else if (v == buf) |
mandoc_asprintf(&val, "[[:<:]]%s[[:>:]]", argv[*argi]); |
e->bits = search->deftype; |
#elif HAVE_REWB_SYSV |
|
mandoc_asprintf(&val, "\\<%s\\>", argv[*argi]); |
|
#else |
|
mandoc_asprintf(&val, |
|
"(^|[^a-zA-Z01-9_])%s([^a-zA-Z01-9_]|$)", argv[*argi]); |
|
#endif |
|
cs = 0; |
|
} else if ((val = strpbrk(argv[*argi], "=~")) == NULL) { |
|
e->bits = TYPE_Nm | TYPE_Nd; |
|
e->match.type = DBM_SUB; |
|
e->match.str = argv[*argi]; |
|
} else { |
|
if (val == argv[*argi]) |
|
e->bits = TYPE_Nm | TYPE_Nd; |
|
if (*val == '=') { |
|
e->match.type = DBM_SUB; |
|
e->match.str = val + 1; |
|
} else |
|
e->match.type = DBM_REGEX; |
|
*val++ = '\0'; |
|
if (strstr(argv[*argi], "arch") != NULL) |
|
cs = 0; |
|
} |
|
|
if ('~' == *v++) { |
/* Compile regular expressions. */ |
if (0 != (irc = regcomp(&e->regexp, v, |
|
REG_EXTENDED | REG_NOSUB | (cs ? 0 : REG_ICASE)))) { |
if (e->match.type == DBM_REGEX) { |
regerror(irc, &e->regexp, errbuf, sizeof(errbuf)); |
e->match.re = mandoc_malloc(sizeof(*e->match.re)); |
fprintf(stderr, "regcomp: %s\n", errbuf); |
irc = regcomp(e->match.re, val, |
|
REG_EXTENDED | REG_NOSUB | (cs ? 0 : REG_ICASE)); |
|
if (irc) { |
|
regerror(irc, e->match.re, errbuf, sizeof(errbuf)); |
|
warnx("regcomp /%s/: %s", val, errbuf); |
|
} |
|
if (search->argmode == ARG_WORD) |
|
free(val); |
|
if (irc) { |
|
free(e->match.re); |
free(e); |
free(e); |
return(NULL); |
++*argi; |
|
return NULL; |
} |
} |
} else |
} |
e->substr = v; |
|
v[-1] = '\0'; |
|
|
|
|
if (e->bits) { |
|
++*argi; |
|
return e; |
|
} |
|
|
/* |
/* |
* Parse out all possible fields. |
* Parse out all possible fields. |
* If the field doesn't resolve, bail. |
* If the field doesn't resolve, bail. |
*/ |
*/ |
|
|
while (NULL != (key = strsep(&buf, ","))) { |
while (NULL != (key = strsep(&argv[*argi], ","))) { |
if ('\0' == *key) |
if ('\0' == *key) |
continue; |
continue; |
i = 0; |
for (i = 0, iterbit = 1; i < KEY_MAX; i++, iterbit <<= 1) { |
while (types[i].bits && |
if (0 == strcasecmp(key, mansearch_keynames[i])) { |
strcasecmp(types[i].name, key)) |
e->bits |= iterbit; |
i++; |
break; |
if (0 == types[i].bits) { |
} |
free(e); |
|
return(NULL); |
|
} |
} |
e->bits |= types[i].bits; |
if (i == KEY_MAX) { |
|
if (strcasecmp(key, "any")) |
|
warnx("treating unknown key " |
|
"\"%s\" as \"any\"", key); |
|
e->bits |= ~0ULL; |
|
} |
} |
} |
|
|
return(e); |
++*argi; |
|
return e; |
} |
} |
|
|
static void |
static void |
exprfree(struct expr *p) |
exprfree(struct expr *e) |
{ |
{ |
struct expr *pp; |
if (e->next != NULL) |
|
exprfree(e->next); |
while (NULL != p) { |
if (e->child != NULL) |
pp = p->next; |
exprfree(e->child); |
free(p); |
free(e); |
p = pp; |
|
} |
|
} |
|
|
|
static void * |
|
hash_halloc(size_t sz, void *arg) |
|
{ |
|
|
|
return(mandoc_calloc(sz, 1)); |
|
} |
|
|
|
static void * |
|
hash_alloc(size_t sz, void *arg) |
|
{ |
|
|
|
return(mandoc_malloc(sz)); |
|
} |
|
|
|
static void |
|
hash_free(void *p, size_t sz, void *arg) |
|
{ |
|
|
|
free(p); |
|
} |
} |