/*	$OpenBSD: mansearch.c,v 1.50 2016/07/09 15:23:36 schwarze Exp $ */

/*

 * Copyright (c) 2012 Kristaps Dzonsons <kristaps@bsd.lv>

 * Copyright (c) 2013, 2014, 2015 Ingo Schwarze <schwarze@openbsd.org>

 *

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

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

 * copyright notice and this permission notice appear in all copies.

 *

 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHORS DISCLAIM ALL WARRANTIES

 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF

 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR

 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES

 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN

 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF

 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

 */

#include <sys/mman.h>

#include <sys/types.h>

#include <assert.h>

#include <err.h>

#include <errno.h>

#include <fcntl.h>

#include <glob.h>

#include <limits.h>

#include <regex.h>

#include <stdio.h>

#include <stdint.h>

#include <stddef.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <sqlite3.h>

#include "mandoc.h"

#include "mandoc_aux.h"

#include "mandoc_ohash.h"

#include "manconf.h"

#include "mansearch.h"

extern int mansearch_keymax;

extern const char *const mansearch_keynames[];

#define	SQL_BIND_TEXT(_db, _s, _i, _v) \

	do { if (SQLITE_OK != sqlite3_bind_text \

		((_s), (_i)++, (_v), -1, SQLITE_STATIC)) \

		errx((int)MANDOCLEVEL_SYSERR, "%s", sqlite3_errmsg((_db))); \

	} while (0)

#define	SQL_BIND_INT64(_db, _s, _i, _v) \

	do { if (SQLITE_OK != sqlite3_bind_int64 \

		((_s), (_i)++, (_v))) \

		errx((int)MANDOCLEVEL_SYSERR, "%s", 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)) \

		errx((int)MANDOCLEVEL_SYSERR, "%s", sqlite3_errmsg((_db))); \

	} while (0)

struct	expr {

	regex_t		 regexp;  /* compiled regexp, if applicable */

	const char	*substr;  /* to search for, if applicable */

	struct expr	*next;    /* next in sequence */

	uint64_t	 bits;    /* type-mask */

	int		 equal;   /* equality, not subsring match */

	int		 open;    /* opening parentheses before */

	int		 and;	  /* logical AND before */

	int		 close;   /* closing parentheses after */

};

struct	match {

	uint64_t	 pageid; /* identifier in database */

	uint64_t	 bits; /* name type mask */

	char		*desc; /* manual page description */

	int		 form; /* bit field: formatted, zipped? */

};

static	void		 buildnames(const struct mansearch *,

				struct manpage *, sqlite3 *,

				sqlite3_stmt *, uint64_t,

				const char *, int form);

static	char		*buildoutput(sqlite3 *, sqlite3_stmt *,

				 uint64_t, uint64_t);

static	struct expr	*exprcomp(const struct mansearch *,

				int, char *[]);

static	void		 exprfree(struct expr *);

static	struct expr	*exprterm(const struct mansearch *, char *, int);

static	int		 manpage_compare(const void *, const void *);

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

mansearch_setup(int start)

{

	static void	*pagecache;

	int		 c;

#define	PC_PAGESIZE	1280

#define	PC_NUMPAGES	256

		}

		    PROT_READ | PROT_WRITE,

		    MAP_SHARED | MAP_ANON, -1, 0);

		}

		    pagecache, PC_PAGESIZE, PC_NUMPAGES);

	}

	}

}

int

mansearch(const struct mansearch *search,

		const struct manpaths *paths,

		int argc, char *argv[],

		struct manpage **res, size_t *sz)

{

	int64_t		 pageid;

	uint64_t	 outbit, iterbit;

	char		 buf[PATH_MAX];

	char		*sql;

	struct manpage	*mpage;

	struct expr	*e, *ep;

	sqlite3		*db;

	sqlite3_stmt	*s, *s2;

	struct match	*mp;

	struct ohash	 htab;

	unsigned int	 idx;

	size_t		 i, j, cur, maxres;

	int		 c, chdir_status, getcwd_status, indexbit;

	}

			    mansearch_keynames[indexbit])) {

			}

		}

	} else

	/*

	 * Remember the original working directory, if possible.

	 * This will be needed if the second or a later directory

	 * is given as a relative path.

	 * Do not error out if the current directory is not

	 * searchable: Maybe it won't be needed after all.

	 */

	} else

	/*

	 * Loop over the directories (containing databases) for us to

	 * search.

	 * Don't let missing/bad databases/directories phase us.

	 * In each, try to open the resident database and, if it opens,

	 * scan it for our match expression.

	 */

			}

		}

		}

		    SQLITE_OPEN_READONLY, NULL);

		}

		/*

		 * Define the SQL functions for substring

		 * and regular expression matching.

		 */

		    SQLITE_UTF8 | SQLITE_DETERMINISTIC,

		    NULL, sql_match, NULL, NULL);

		    SQLITE_UTF8 | SQLITE_DETERMINISTIC,

		    NULL, sql_regexp, NULL, NULL);

			    "%s", sqlite3_errmsg(db));

			} else

		}

		/*

		 * Hash each entry on its [unique] document identifier.

		 * This is a uint64_t.

		 * Instead of using a hash function, simply convert the

		 * uint64_t to a uint32_t, the hash value's type.

		 * This gives good performance and preserves the

		 * distribution of buckets in the table.

		 */

			    (char *)&pageid, sizeof(uint64_t),

			    (uint32_t)pageid);

				    sqlite3_column_text(s, 0));

		}

		    "SELECT sec, arch, name, pageid FROM mlinks "

		    "WHERE pageid=? ORDER BY sec, arch, name",

		    -1, &s, NULL);

			    "%s", sqlite3_errmsg(db));

		    "SELECT bits, key, pageid FROM keys "

		    "WHERE pageid=? AND bits & ?",

		    -1, &s2, NULL);

			    "%s", sqlite3_errmsg(db));

				    maxres, sizeof(struct manpage));

			}

			    paths->paths[i], mp->form);

				    mp->desc : outbit ?

				    buildoutput(db, s2, mp->pageid, outbit) :

				    NULL;

			}

		}

		/*

		 * In man(1) mode, prefer matches in earlier trees

		 * over matches in later trees.

		 */

	}

}

void

mansearch_free(struct manpage *res, size_t sz)

{

	size_t	 i;

	}

}

static int

manpage_compare(const void *vp1, const void *vp2)

{

	const struct manpage	*mp1, *mp2;

	int			 diff;

	    (diff = mp1->sec - mp2->sec) ? diff :

	    strcasecmp(mp1->names, mp2->names);

}

static void

buildnames(const struct mansearch *search, struct manpage *mpage,

		sqlite3 *db, sqlite3_stmt *s,

		uint64_t pageid, const char *path, int form)

{

	glob_t		 globinfo;

	char		*firstname, *newnames, *prevsec, *prevarch;

	const char	*oldnames, *sep1, *name, *sec, *sep2, *arch, *fsec;

	size_t		 i;

	int		 c, globres;

		/* Decide whether we already have some names. */

		} else {

		}

		/* Fetch the next name, rejecting sec/arch mismatches. */

		    strcasecmp(arch, search->arch))

		/* Remember the first section found. */

		/* If the section changed, append the old one. */

		    (strcmp(sec, prevsec) ||

		     strcmp(arch, prevarch))) {

			    oldnames, prevsec, sep2, prevarch);

		}

		/* Save the new section, to append it later. */

		}

		/* Append the new name. */

		    oldnames, sep1, name);

		/* Also save the first file name encountered. */

		} else {

		}

		    path, sep1, sec, sep2, arch, name, fsec);

		/* Handle unusual file name extensions. */

		else

		    path, sep1, sec, sep2, arch, name);

		    mandoc_strdup(*globinfo.gl_pathv);

	}

	/* If none of the files is usable, use the first name. */

	/* Append one final section to the names. */

		    mpage->names, prevsec, sep2, prevarch);

	}

}

static char *

buildoutput(sqlite3 *db, sqlite3_stmt *s, uint64_t pageid, uint64_t outbit)

{

	char		*output, *newoutput;

	const char	*oldoutput, *sep1, *data;

	size_t		 i;

	int		 c;

		} else {

		}

		    oldoutput, sep1, data);

	}

}

/*

 * Implement substring match as an application-defined SQL function.

 * Using the SQL LIKE or GLOB operators instead would be a bad idea

 * because that would require escaping metacharacters in the string

 * being searched for.

 */

static void

sql_match(sqlite3_context *context, int argc, sqlite3_value **argv)

{

	    (const char *)sqlite3_value_text(argv[1]),

	    (const char *)sqlite3_value_text(argv[0])));

}

/*

 * Implement regular expression match

 * as an application-defined SQL function.

 */

static void

sql_regexp(sqlite3_context *context, int argc, sqlite3_value **argv)

{

	    (regex_t *)sqlite3_value_blob(argv[0]),

	    (const char *)sqlite3_value_text(argv[1]),

	    0, NULL, 0));

}

static void

sql_append(char **sql, size_t *sz, const char *newstr, int count)

{

	size_t		 newsz;

	else

}

/*

 * Prepare the search SQL statement.

 */

static char *

sql_statement(const struct expr *e)

{

	char		*sql;

	size_t		 sz;

	int		 needop;

	    "SELECT desc, form, pageid, bits "

		"FROM mpages NATURAL JOIN names WHERE " :

	    "SELECT desc, form, pageid, 0 FROM mpages WHERE ");

		    TYPE_Nd & e->bits

		    ? (NULL == e->substr

			? "desc REGEXP ?"

			: "desc MATCH ?")

		    : TYPE_Nm == e->bits

		    ? (NULL == e->substr

			? "pageid IN (SELECT pageid FROM names "

			  "WHERE name REGEXP ?)"

			: e->equal

			? "name = ? "

			: "pageid IN (SELECT pageid FROM names "

			  "WHERE name MATCH ?)")

		    : (NULL == e->substr

			? "pageid IN (SELECT pageid FROM keys "

			  "WHERE key REGEXP ? AND bits & ?)"

			: "pageid IN (SELECT pageid FROM keys "

			  "WHERE key MATCH ? AND bits & ?)"), 1);

	}

}

/*

 * Compile a set of string tokens into an expression.

 * Tokens in "argv" are assumed to be individual expression atoms (e.g.,

 * "(", "foo=bar", etc.).

 */

static struct expr *

exprcomp(const struct mansearch *search, int argc, char *argv[])

{

	uint64_t	 mask;

	int		 i, toopen, logic, igncase, toclose;

	struct expr	*first, *prev, *cur, *next;

			continue;

		}

		else

		/*

		 * Searching for descriptions must be split out

		 * because they are stored in the mpages table,

		 * not in the keys table.

		 */

				    sizeof(struct expr));

			}

		}

	}

}

static struct expr *

exprterm(const struct mansearch *search, char *buf, int cs)

{

	char		 errbuf[BUFSIZ];

	struct expr	*e;

	char		*key, *val;

	uint64_t	 iterbit;

	int		 i, irc;

	}

	/*

	 * Separate macro keys from search string.

	 * If needed, request regular expression handling

	 * by setting e->substr to NULL.

	 */

	} else {

	}

	/* Compile regular expressions. */

		    REG_EXTENDED | REG_NOSUB | (cs ? 0 : REG_ICASE));

		}

	}

	/*

	 * Parse out all possible fields.

	 * If the field doesn't resolve, bail.

	 */

			    mansearch_keynames[i])) {

			}

		}

			}

		}

	}

}

static void

exprfree(struct expr *p)

{

	struct expr	*pp;

	}

}