searchm.h

Go to the documentation of this file.

/*
 * searchm.h
 * Byron Young
 * 2005
 */

#ifndef SEARCHM_H
#define SEARCHM_H

#if defined (SEARCHM_DBM)
#elif defined(SEARCHM_BDB)
#else
#error One of SEARCHM_DBM must be defined.
#endif
/*
 * Some compile time funtionality settings.
 */

/*@def SEARCHM_PURGETIME
 *@brief A time difference, in seconds.
 *An entry in the database contains the last purge time.
 *If the difference, in seconds, between the current request time,
 *and the database last purge time, exceeds this value, purge the database.
 *A zero value implies always purge.
 *During purge, all invalidated search threads are deleted.
 */
#ifndef SEARCHM_PURGE_TIME
# define SEARCHM_PURGE_TIME (120)
#endif /* SEARCHM_PURGE_TIME */

/*@def SEARCHM_INVALIDATE_TIME
 *@brief A time difference, in seconds.
 *Each search thread contains a last accessed time.
 *During a purge, if the difference between the current time and
 *the last access time exceeds this value, remove the search thread from
 *the database.
 */
#ifndef SEARCHM_INVALIDATE_TIME
# define SEARCHM_INVALIDATE_TIME (10)
#endif /* SEARCHM_INVALIDATE_TIME */

/*
 *@def SEARCHM_KEY_PURGETIME
 *@brief The Database key name containing the last time the database was purged.
 *Only the time field is valid.
 */
#define SEARCHM_KEY_PURGETIME "SEARCHMTIME"

/* Size for a general cache */
#define SEARCHM_CACHE_SIZE (1 * 1024)

/* An ASCII character  */
#define SEARCHM_TAG_BEGIN '<'

/* An ASCII string */
/* First character must be SEARCHM_TAG_BEGIN */
#define SEARCHM_TAG_ID "<SEARCHM:"

/* An ASCII character */
#define SEARCHM_TAG_END '>'

#define SEARCHM_DEFAULT_COOKIE_NAME "SEARCHM"

#define SEARCHM_DESC_HTML_HILITE_BEGIN "<b><i>"
/*
 * #define SEARCHM_DESC_HTML_HILITE_BEGIN "<font color=\"green\" size=\"-1\">"
 */

#define SEARCHM_DESC_HTML_HILITE_END "</i></b>"
/*
 *#define SEARCHM_DESC_HTML_HILITE_END "</font>"
 */

#define SEARCHM_AND_WORD "and"

#define SEARCHM_OR_WORD  "or"

#define SEARCHM_NOT_WORD "not"

#define SEARCHM_DEFAULT_RULE SEARCHM_AND_RULE

#define SEARCHM_DEFAULT_METANAME "swishdefault"

/* '(' group begin */
#define SEARCHM_ENC_GB "%28"

/* ')' group end */
#define SEARCHM_ENC_GE "%29"

/* '^' Beginning of line */
#define SEARCHM_ENC_BOL "%5e"

/* '$' End of line */
#define SEARCHM_ENC_EOL "%24"

/* '|' Alternation */
#define SEARCHM_ENC_AL "%7c"

/* '*' match Zero or more */
#define SEARCHM_ENC_ZOM "%2a"

/* '+' match One or more */
#define SEARCHM_ENC_OOM "%2b"

/* '.' match Any Char */
#define SEARCHM_ENC_AC "%2e"


/* '[:space:]' SP space */
/* for GNU, use blank for better results */
#define SEARCHM_ENC_SP "%5b%5b%3aspace%3a%5d%5d"
#define SEARCHM_RE_SPACE "[[:space:]]"
#define SEARCHM_RE_NOT_SPACE "[^[:space:]]"
#define SEARCHM_ENC_NOT_SP "%5b" SEARCHM_ENC_BOL "%5b%3aspace%3a%5d%5d"
/* end space */

#define SEARCHM_RE_START "(^|" SEARCHM_RE_SPACE ")("
#define SEARCHM_ENC_RE_START SEARCHM_ENC_GB SEARCHM_ENC_BOL SEARCHM_ENC_AL SEARCHM_ENC_SP SEARCHM_ENC_GE SEARCHM_ENC_GB

#define SEARCHM_RE_END ")(" SEARCHM_RE_SPACE "|$)"
#define SEARCHM_ENC_RE_END SEARCHM_ENC_GE SEARCHM_ENC_GB SEARCHM_ENC_SP SEARCHM_ENC_AL SEARCHM_ENC_EOL SEARCHM_ENC_GE

#define NULL_STRCMP_CASE 0
#define NULL_STRCMP_NOCASE 1

/* regexec nmatch paramter value */
/* (|)()(|) => 3 + 1 */
#define SEARCHM_NUM_SUB_MATCHES 4

/* 0 => all, 1=>(|), 2=>() */
#define SEARCHM_USE_SUB_MATCH 2

/* ERROR codes */
#define SEARCHM_SUCCESS                      APR_SUCCESS
#define SEARCHM_ERROR_                       (APR_OS_START_USEERR + 1)
#define SEARCHM_ERROR_METHOD_NOT_ALLOWED     (APR_OS_START_USEERR + 2)
#define SEARCHM_ERROR_BAD_REQUEST            (APR_OS_START_USEERR + 3)
#define SEARCHM_INTERNAL_SERVER_ERROR        (APR_OS_START_USEERR + 4)
#define SEARCHM_UNAUTHORIZED                 (APR_OS_START_USEERR + 5)
#define SEARCHM_ERROR_DOC                    (APR_OS_START_USEERR + 6)
#define SEARCHM_ERROR_NOHITS                 (APR_OS_START_USEERR + 7)

#define SEARCHM_ERROR_BUFFEROVERFLOW        -1
#define SEARCHM_ERROR_MALLOC                -2
#define SEARCHM_ERROR_INVALID_INDEX         -3
#define SEARCHM_ERROR_TAG_CACHE_SYNC        -4
#define SEARCHM_ERROR_FILE                  -5
#define SEARCHM_ERROR_INVALID_QUERY         -6
#define SEARCHM_ERROR_INVALID_CONTENT_TYPE  -8
#define SEARCHM_ERROR_ABSOLUTE             -10
#define SEARCHM_ERROR_RELATIVE             -11
#define SEARCHM_ERROR_STRICT               -12
#define SEARCHM_ERROR_SWISH                -13
#define SEARCHM_ENDOFFILE                  -15

#define SEARCHM_MAX_SUBQUERIES 10

#define SEARCHM_PARAMETER_METATAG "metatag"

#define SEARCHM_PARAMETER_QUERY "query"

#define SEARCHM_PARAMETER_CONJ "conj"

#define SEARCHM_MAX_SORTPAIRS 4

#define SEARCHM_PARAMETER_SORT "sort"

#define SEARCHM_PARAMETER_ORDER "order"

#define SEARCHM_MAX_INDEX 4

#define SEARCHM_PARAMETER_INDEX "index"

#define SEARCHM_PARAMETER_DISPLAY "display"

#define SEARCHM_PARAMETER_PAGE "page"

#define SEARCHM_PARAMETER_WITHIN "within"

#define SEARCHM_PARAMETER_REQID "reqid"

#define SEARCHM_ITEMLIST_UNIQUE 0

#define SEARCHM_ITEMLIST_NONUNIQUE 1

#define SEARCHM_ITEMLIST_EMPTY (-INT_MAX)

#define SEARCHM_MAX_TERMS_LIST 32

#define SEARCHM_ERROR_NOTES "error-notes"

#define SEARCHM_LIMIT_STRING "limit"

#define SEARCHM_LIMIT_MAX 2

#define SEARCHM_LIMIT_MAX_SUB 7

/* a hack */
#define SEARCHM_IN_ALL (1<<8)

#define SEARCHM_BUFFER_CHUNK 1024

#define SEARCHM_UNIQUEID_SIZE (APR_MD5_DIGESTSIZE * 2)

#define SEARCHM_BDB_MAX_ENV 32

#define SEARCHM_BDB_MAX_DB 32

/* #define SEARCHM_CONFIG_ICASE 1 */
#define SEARCHM_CONFIG_ICASE 0

#define DB_SEARCHM "DB_SEARCHM"

#define SEARCHM_BDB_MASTERLOCK "SEARCHM_BDB_MASETERLOCK"

#if !defined(OS2) && !defined(WIN32) && !defined(BEOS) && !defined(NETWARE)
#include <unixd.h>
#define MOD_SEARCHM_SET_MUTEX_PERMS
#endif

typedef enum searchm_state {
  searchm_state_notdef=0, 
  searchm_state_off, 
  searchm_state_on 
} searchm_state_e;

typedef enum searchm_termtype {
  tt_equal, 
  tt_quote, 
  tt_left, 
  tt_right, 
  tt_meta, 
  tt_term, 
  tt_none, 
  tt_and, 
  tt_or, 
  tt_not, 
  tt_null 
} searchm_termtype_e;

typedef struct searchm_nodeelem {
  char * t; 
  int i; 
  struct searchm_nodeelem * next; 
  struct searchm_nodeelem * prev; 
} searchm_nodeelem_t, * p_searchm_nodeelem_t;

typedef struct searchm_metaelem {
  char * n; 
  struct searchm_metaelem * next; 
  struct searchm_metaelem * prev; 
  p_searchm_nodeelem_t l; 
  int i; 
} searchm_metaelem_t, * p_searchm_metaelem_t;

typedef struct searchm_metalist {
  p_searchm_metaelem_t ml; 
  int i; 
} searchm_metalist_t, * p_searchm_metalist_t;

typedef struct searchm_termitem {
  char * t; 
  char * re; 
  char * enc; 
  regex_t * preg; 
  regmatch_t * pmatch; 
  regmatch_t * match; 
  int nmatch; 
  int usematch; 
  int bDone; 
  unsigned int pos; 
  unsigned int mpos_b; 
  unsigned int mpos_e; 
} searchm_termitem_t, * p_searchm_termitem_t;

typedef struct searchm_termlist {
  p_searchm_termitem_t tl; 
  int n; 
  int t; 
} searchm_termlist_t, * p_searchm_termlist_t;

typedef enum searchm_tag_ids {
  searchm_qpage=0, 
  searchm_tag_ids_start=searchm_qpage, 
  searchm_qdisplay, 
  searchm_display, 
  searchm_qcmdstring, 
  searchm_reqid, 
  searchm_page, 
  searchm_header_names, /* SwishHeaderNames results.  A comma separated list of all available header names. */
  searchm_hv, /* A SwishHeaderValue. Has associated string data searchm_hv_NAME, where NAME is the actual header name, with any spaces substituted with an ASCII underscore '_'. */
  searchm_hits, 
  searchm_error, /* The error value, if any. */
  searchm_pagenext, 
  searchm_pageprev, 
  searchm_hilitem_string, 
  searchm_parsed_words, 
  searchm_removed_words, 
  searchm_date, 
  searchm_subquery, /* Has associated N value. For sub-query N, the triplets metatagN, queryN, and conjN combined. */
  searchm_total_pages, 
  searchm_full_pages, 
  searchm_start, 
  searchm_end, 
  searchm_sort, 
  searchm_qconj, 
  searchm_qquery, 
  searchm_query, 
  searchm_qmetatag, 
  searchm_within, 
  searchm_qorder, 
  searchm_qsort, 
  searchm_qindex, 
  searchm_index, 
  searchm_last_page, 
  searchm_limit, /* Limit info. Has associated N value. A yes value means that limitN was passed to SwishSetSearchLimit. A no value means that limitN was not given, or was not passed to SwishSetSearchLimit. */
  searchm_low_limit, /* Limit low param. Has associated N value. The actual char * low parameter passed to SwishSetSearchLimit. */
  searchm_up_limit, /* Limit hi param. Has associated N value. The actual char * hi paramter passed to SwishSetSearchLimit. */
  searchm_prop_limit, /* Limit property. Has associated N value. The actual char * property parameter passed to SwishSetSearchLimit. */
  searchm_cabsolute, 
  searchm_crelative, 
  searchm_cstrict, 
  searchm_cindexdir, 
  searchm_dbname, 
  searchm_dbdesc, 
  searchm_dbpointer, 
  searchm_dbadmin, 
  searchm_cbegin, 
  searchm_cresult, 
  searchm_cend, 
  searchm_cnohits, 
  searchm_invalid, 
  searchm_tag_ids_total=searchm_invalid 
} searchm_tag_ids_e;

typedef enum searchm_auto_tags {
  searchm_auto_reccount=0, 
  searchm_auto_tags_start=searchm_auto_reccount, 
  searchm_auto_title, 
  searchm_auto_rank, 
  searchm_auto_docpath, 
  searchm_auto_docsize, 
  searchm_auto_lastmodified, 
  searchm_auto_description, 
  searchm_auto_sdescription, 
  searchm_auto_dbfile, 
  searchm_auto_tags_total 
} searchm_auto_tags_e;

/*
 *@enum searchm_itemlist
 *@brief The types of item lists.
 */
typedef enum searchm_itemlist {
  searchm_itemlist_index=0, 
  searchm_itemlist_start=searchm_itemlist_index, 
  searchm_itemlist_subquery, 
  searchm_itemlist_sortpair, 
  searchm_itemlist_total 
} searchm_itemlist_e;

typedef enum searchm_limit_attr_type {
  searchm_limit_attr_type_date, 
  searchm_limit_attr_type_integer, 
  searchm_limit_attr_type_string 
} searchm_limit_attr_type_e, * p_searchm_limit_attr_type_e;

typedef enum searchm_limit_attr {
  searchm_limit_attr_name, 
  searchm_limit_attr_start=searchm_limit_attr_name, 
  searchm_limit_attr_active, 
  searchm_limit_attr_type, 
  searchm_limit_attr_hi, 
  searchm_limit_attr_low, 
  searchm_limit_attr_total, 
} searchm_limit_attr_e, * p_searchm_limit_attr_e;

typedef struct searchm_limit_data {
  const char * name; 
  const char * active; 
  const char * type; 
  const char * hi[SEARCHM_LIMIT_MAX_SUB]; 
  const char * low[SEARCHM_LIMIT_MAX_SUB]; 
  int bEntries; 
  int bValid; 
  char * limit_hi; 
  char * limit_low; 
  searchm_limit_attr_type_e e_type; 
} searchm_limit_data_t, * p_searchm_limit_data_t;

typedef struct searchm_config {
  char * sza_indexdir; 
  int bSetIndexDir; 
  char * sza_lockfile; 
  int bSetLockFile; 
  int bActivate; 
  int bSetActivate; 
#if defined(SEARCHM_DBM)
  char * sza_dbm; 
  int bSetDBM; 
#elif defined(SEARCHM_BDB) /* SEARCHM_DBM */
  char * sza_home; 
  int bSetHome; 
  char * sza_file; 
  int bSetFile; 
  int i_env; 
  int i_db; 
  searchm_state_e bdb_state; 
#endif /* SEARCHM_BDB */
} searchm_config_t, * p_searchm_config_t;

typedef struct searchm_dir_config {
  int bAbsolute; 
  int bRelative; 
  int bStrict; 
  char * sza_begin; 
  char * sza_result; 
  char * sza_end; 
  char * sza_nohits; 
  char * sza_usertrack_cookie_name; 
  int bSetAbsolute; 
  int bSetRelative; 
  int bSetStrict; 
  int bSetBegin; 
  int bSetResult; 
  int bSetEnd; 
  int bSetNoHits; 
  int bUsertrackCookie; 
  int bSetUserTrackCookieName; 
} searchm_dir_config_t, * p_searchm_dir_config_t;

#define INITIALIZE_SEARCHM_DIR_CONFIG {\
 .bAbsolute=0,\
 .bRelative=0,\
 .bStrict=1,\
 .sza_begin=NULL,\
 .sza_result=NULL,\
 .sza_end=NULL,\
 .sza_nohits=NULL,\
 .sza_usertrack_cookie_name=NULL,\
 .bSetAbsolute=0,\
 .bSetRelative=0,\
 .bSetStrict=0,\
 .bSetBegin=0,\
 .bSetResult=0,\
 .bSetEnd=0,\
 .bSetNoHits=0,\
 .bSetUserTrackCookieName=0,\
 .bUsertrackCookie=0\
}

typedef struct searchm_sub_query {
  int weight; 
  char * metatag; 
  char * query; 
  char * conj; 
  char * sub_query; 
} searchm_sub_query_t, * p_searchm_sub_query_t;

typedef struct searchm_sortpair {
  int weight; 
  char * sort; 
  char * order; 
} searchm_sortpair_t, * p_searchm_sortpair_t;

typedef struct searchm_indexfile {
  int weight; 
  char * index; 
  char * fname; 
  char * dbname; 
  char * dbdesc; 
  char * dbpointer; 
  char * dbadmin; 
} searchm_indexfile_t, * p_searchm_indexfile_t;

typedef struct searchm_cmd_line {
  int  structure; 
  int cmd_structure; 
  int page; 
  int display; 
  int bRequery; 
  int bReqID; 
  unsigned char reqid[SEARCHM_UNIQUEID_SIZE+1]; 
  searchm_sub_query_t sq[SEARCHM_MAX_SUBQUERIES]; 
  searchm_sortpair_t sp[SEARCHM_MAX_SORTPAIRS]; 
  int i_limit; 
  searchm_limit_data_t limit[SEARCHM_LIMIT_MAX]; /* The SwishSearchSetLimit data. */
  int i_index; 
  searchm_indexfile_t index[SEARCHM_MAX_INDEX]; 
  int i_within; 
} searchm_cmd_line_t, * p_searchm_cmd_line_t;

typedef struct searchm_tags {
  char * tag[searchm_tag_ids_total]; 
  char * cache; 
  int i_cache; 
  int i_cache_size; 
} searchm_tags_t, * p_searchm_tags_t;

typedef struct query_info {
  request_rec * p_rr; 
  SW_HANDLE sw_handle; 
  SW_SEARCH sw_search; 
  SW_RESULTS sw_results; 
  SW_RESULT sw_result_item; 
  searchm_cmd_line_t cmd; 
  const char * querystring; 
  char delimiter; 
  char * within; 
  char * swishsort; 
  char * swishquery; 
  char * swishindex; 
  const char ** stopwords_list; 
  const char ** removed_list; 
  apr_pool_t * ptemp; 
  int hits; 
  int page; 
  int display; 
  int pagenext; 
  int pageprev; 
  int i_start; 
  int i_end; 
  int i_full_pages; 
  int i_total_pages; 
  int i_last_page; 
  searchm_tags_t st; 
  int tag[searchm_tag_ids_total]; 
  p_searchm_config_t p_sc; 
  p_searchm_dir_config_t p_sdc; 
  char * p_cbegin; 
  char * p_cresult; 
  char * p_cend; 
  char * p_cnohits; 
  apr_file_t * fp_begin; 
  apr_file_t * fp_result; 
  apr_file_t * fp_end; 
  apr_file_t * fp_nohits; 
  unsigned long ul_bytes_sent; 
  const char * p_cookie; 
  int bRemoteCookie; 
  const char * p_dbcookie; 
  searchm_metalist_t ml; 
  searchm_termlist_t tl; 
  int bInDbase; 
  int bForcePurge; /* If true, then force a purge. */
#if defined(SEARCHM_DBM)
  apr_dbm_t * dbm;
#elif defined(SEARCHM_BDB) /* SEARCHM_DBM */
  u_int32_t lockid; 
  DB_LOCK req_lock; 
  int bReqLock; 
  int bMasterLock; 
#endif /* SEARCHM_BDB*/
} query_info_t, * p_query_info_t;

typedef struct searchm_dbpkt {
  int structure; 
  int display; 
  int bCookie; 
  int bSort; 
  int index; 
  int limit; 
  apr_time_t time; 
} searchm_dbpkt_t, * p_searchm_dbpkt_t;

typedef struct searchm_buffer {
  void * b; 
  unsigned int pos; 
  unsigned int size; 
} searchm_buffer_t, * p_searchm_buffer_t;

typedef struct searchm_cleanup_data {
  apr_pool_t * p; 
  int bSS; 
} searchm_cleanup_data_t, * p_searchm_cleanup_data_t;

/* ******************************* */
#if defined(SEARCHM_BDB)
/* BDB STRUCTURES */
/* ******************************* */

typedef struct searchm_bdb_env {
  DB_ENV * db_env; 
  char * name; 
  u_int32_t lock_id; 
  char * lock_object; 
  DB_LOCK lock; 
} searchm_bdb_env_t, * p_searchm_bdb_env_t;

#define INITIALIZE_SEARCHM_BDB_ENV {\
 .db_env=NULL,\
 .name=NULL,\
 .lock_id=0,\
 .lock_object=NULL\
}

typedef struct searchm_bdb_db {
  DB * db; 
  char * name; 
  int i_env; 
} searchm_bdb_db_t, * p_searchm_bdb_db_t;

#define INITIALIZE_SEARCHM_BDB_DB {\
 .db=NULL,\
 .name=NULL,\
 .i_env=0\
}

typedef struct searchm_bdb {
  searchm_bdb_env_t env[SEARCHM_BDB_MAX_ENV]; 
  searchm_bdb_db_t db[SEARCHM_BDB_MAX_DB]; 
} searchm_bdb_t, * p_searchm_bdb_t;

#endif /* SEARCHM_BDB */

/* GLOBALS */

static apr_global_mutex_t * searchm_global_lock=NULL;

#if APR_HAS_THREADS
static apr_thread_mutex_t * lib_lock;
#endif /* APR_HAS_THREADS */

#if defined (SEARCHM_BDB)

static searchm_bdb_db_t bdb_db_init=INITIALIZE_SEARCHM_BDB_DB;
static searchm_bdb_env_t bdb_env_init=INITIALIZE_SEARCHM_BDB_ENV;

static const u_int32_t bdb_flags=0; 
static const u_int32_t bdb_set_flags=0; 
static const u_int32_t bdb_env_flags=DB_INIT_MPOOL|DB_INIT_LOCK; 
static const u_int32_t bdb_env_set_flags=0; 
static u_int32_t bdbthreaded=0; 
static searchm_bdb_t bdb;

static const db_lockmode_t bdb_lockmode=DB_LOCK_READ;
#endif /* SEARCHM_BDB */

static void * searchm_per_server_config(apr_pool_t *p, server_rec *s);
static int searchm_hook_post_config(apr_pool_t *p, apr_pool_t * plog,
                                   apr_pool_t *ptemp, server_rec *s);
static apr_status_t searchm_pool_post_config_cleanup(void * data);
static void searchm_hook_child_init(apr_pool_t *p, server_rec *s);
static void searchm_hook_child_init(apr_pool_t *p, server_rec *s);
static apr_status_t searchm_pool_child_init_cleanup(void * parm);
static void searchm_process_init(int bSS, apr_pool_t * p);
static void searchm_process_cleanup(int bSS, apr_pool_t * p);
static int searchm_method_handler(request_rec *r);
static apr_status_t searchm_get_querystring(p_query_info_t p_qi);
static apr_status_t searchm_tags_cache_cmdline(p_query_info_t p_qi);
static apr_status_t searchm_tags_cache_add(p_query_info_t p_qi, char * s, searchm_tag_ids_e tag_id, int bDel);
static searchm_tag_ids_e searchm_tagid(char * t, int * p_rval, char ** p_str);
static searchm_auto_tags_e searchm_tagid_auto(char * tag);
static unsigned int searchm_desc_trim_begin(const char * desc, unsigned int mpos, int * bStart);
static unsigned int searchm_desc_trim_end(const char * desc, unsigned int mpos, int * bEnd);
static char * searchm_description_handler(apr_pool_t * pool, apr_pool_t * ptemp, const char * desc, const char ** stopword_list, const char ** removed_list, p_searchm_termlist_t const p_tl);
static apr_status_t  searchm_replace_file(p_query_info_t p_qi, apr_file_t * fp);
static char * searchm_replace_searchm_tag(p_query_info_t p_qi, searchm_tag_ids_e tag_id, int tval, char * p_str);
static int searchm_parse_cmdline(p_query_info_t p_qi);
static apr_status_t searchm_parse_cmdline_display(p_query_info_t p_qi, const char * p_value);
static apr_status_t searchm_parse_cmdline_page(p_query_info_t p_qi, const char * p_value);
static apr_status_t searchm_parse_cmdline_reqid(p_query_info_t p_qi, const char * p_value);
static apr_status_t searchm_process_requestinfo(p_query_info_t p_qi);
static apr_status_t searchm_parse_cmdline_within(p_query_info_t p_qi, const char * p_value);
static apr_status_t searchm_parse_cmdline_index(p_query_info_t p_qi, const char * p_value, int nval);
static apr_status_t searchm_parse_cmdline_conj(p_query_info_t p_qi, const char * p_value, int nval);
static apr_status_t searchm_parse_cmdline_query(p_query_info_t p_qi, const char * p_value, int nval);
static apr_status_t searchm_parse_cmdline_metatag(p_query_info_t p_qi, const char * p_value, int nval);
static apr_status_t searchm_parse_cmdline_order(p_query_info_t p_qi, const char * p_value, int nval);
static apr_status_t searchm_parse_cmdline_sort(p_query_info_t p_qi, const char * p_value, int nval);
static apr_status_t searchm_parse_cmdline_limit(p_query_info_t p_qi, const char * value, int n, searchm_limit_attr_e ltype, int lstype);
static int searchm_limit_process_date(const char * const ld[SEARCHM_LIMIT_MAX_SUB], apr_time_t * t);
static int searchm_limit_process_string(const char * const ld[SEARCHM_LIMIT_MAX_SUB], char ** str, apr_pool_t * p);
static int searchm_limit_process_integer(const char * const ld[SEARCHM_LIMIT_MAX_SUB], char ** str, apr_pool_t * p);
static int searchm_limit_process(p_query_info_t p_qi);
static int searchm_create_filepath(p_query_info_t p_qi);
static int searchm_cmp_weighted(char * p, char * t, int * v);
static int searchm_cmp_stringed(char * p, char * t, char ** p_str);
static int searchm_cmp_limit(const char * param, int * n, p_searchm_limit_attr_e ltype, int * lstype, apr_pool_t * p);
static apr_status_t searchm_itemlist_add(p_query_info_t p_qi, void * list, void * item, searchm_itemlist_e listtype, searchm_tag_ids_e itemtype);
static apr_status_t searchm_pre_query(p_query_info_t p_qi);
static apr_status_t searchm_create_within(p_query_info_t p_qi);
static int searchm_structure_to_id(char * p_value);
static int searchm_error_to_api(int i);
static const char * searchm_set_absolute(cmd_parms *parms, void *dummy,
                                         const int arg);
static const char * searchm_set_relative(cmd_parms *parms, void *dummy,
                                         const int arg);
static const char * searchm_set_strict(cmd_parms *parms, void *dummy,
                                       const int arg);
static const char * searchm_set_indexdir(cmd_parms *parms, void *dummy,
                                         const char *arg);
static const char * searchm_set_lockfile(cmd_parms *parms, void *dummy, const char *arg);
#if defined(SEARCHM_DBM)
static const char * searchm_set_dbm(cmd_parms *parms, void *dummy, const char *arg);
#elif defined(SEARCHM_BDB)
static const char * searchm_set_bdb(cmd_parms *parms, void *dummy, const char *arg1, const char * arg2);
#endif
static const char * searchm_set_begin(cmd_parms *parms, void *dummy,
                                      const char *arg);
static const char * searchm_set_result(cmd_parms *parms, void *dummy,
                                       const char *arg);
static const char * searchm_set_end(cmd_parms *parms, void *dummy,
                                    const char *arg);
static const char * searchm_set_nohits(cmd_parms *parms, void *dummy,
                                       const char *arg);
static const char * searchm_set_activate(cmd_parms *parms, void *dummy, int bool);
static void * searchm_per_dir_config(apr_pool_t * p, char * dir);
static apr_status_t searchm_qi_setup(p_query_info_t p_qi, request_rec * r, p_searchm_config_t p_sc, p_searchm_dir_config_t p_sdc);
static int searchm_metalist_process(p_query_info_t p_qi);
static apr_status_t searchm_subquery_process(p_searchm_metalist_t const p_ml, const char ** sl, unsigned int * index_sl, const char * meta_def, apr_pool_t * p);
static searchm_termtype_e searchm_gettermtype(const char * t);
static searchm_termtype_e searchm_conjtype(const char * const t);
static apr_status_t searchm_addterm(p_searchm_metalist_t p_ml, const char ** sl, int * index_sl, const char * m, int bP, int nterms, apr_pool_t * p);
static apr_status_t searchm_metalist_add(p_searchm_metalist_t const p_ml, const char * mn, p_searchm_metaelem_t * pp_me, apr_pool_t * p);
static p_searchm_metaelem_t searchm_metalist_get(p_searchm_metalist_t p_ml, const char * mn, int * bFound);
static apr_status_t searchm_nodelist_add(p_searchm_metaelem_t const p_me, const char ** sl, int * index_sl, int bP, int nterms, apr_pool_t * p);
static void searchm_metalist_destroy(p_searchm_metalist_t const p_ml);
static int searchm_nullstrcmp(const char * const t1, const char * const t2, const int bCase);
static apr_status_t searchm_nodelist_match(p_searchm_metaelem_t const me, const char ** sl, const int index_sl, const int bP, const int nterms, int * bResult, apr_pool_t * p);
static apr_status_t searchm_phrase_match(p_searchm_metaelem_t const me, const char ** sl, const int index_sl, const int bP, const int nterms, int * bResult, apr_pool_t * p);
static apr_status_t searchm_single_match(const char * t1, const char * t2, const int bWay, int * Result, apr_pool_t * p);
static apr_status_t searchm_termlist_create(p_searchm_metalist_t const p_ml, const char * mn, int bUseNull, p_searchm_termlist_t const p_tl, int * bResult, apr_pool_t * p);
static void searchm_termlist_destroy(p_searchm_termlist_t const p_tl, apr_pool_t * p);
static int searchm_nextmatch(p_searchm_termlist_t const p_tl, const char * desc, unsigned int * pos, int * i_match, unsigned int * mpos_b);
static apr_status_t searchm_cookie_process(p_query_info_t p_qi);
static apr_status_t searchm_swishexecute(p_query_info_t p_qi);
static apr_status_t searchm_phases(p_query_info_t p_qi);
static apr_status_t searchm_phases_nohits(p_query_info_t p_qi);
static void searchm_error_doc(p_query_info_t p_qi) ;
static void searchm_test(p_query_info_t p_qi);
static apr_status_t searchm_generate_reqid(p_query_info_t p_qi);
static apr_status_t searchm_packet_make(p_query_info_t p_qi, void ** pkt, unsigned int * psize);
static apr_status_t searchm_next_string(char ** s, void * v, unsigned int * pos, apr_pool_t * p);
static apr_status_t searchm_packet_split(p_query_info_t p_qi, void * pkt, unsigned int psize);
static apr_status_t searchm_buffer_expand(p_searchm_buffer_t pb, unsigned int min, apr_pool_t * p);
static apr_status_t searchm_buffer_expand(p_searchm_buffer_t pb, unsigned int min, apr_pool_t * p);
static apr_status_t searchm_buffer_add_string(const char * s, p_searchm_buffer_t pb, apr_pool_t * p);
static apr_status_t searchm_buffer_add(void * pv, unsigned int size, p_searchm_buffer_t pb, apr_pool_t * p);
static int searchm_absolute_path(const char * path);
static int   searchm_check_filename(const char * file);
static int searchm_strcmp(const char * s1, const char * s2);
static apr_status_t searchm_dbase_open(p_query_info_t p_qi);
static apr_status_t searchm_dbase_close(p_query_info_t p_qi);
static apr_status_t searchm_dbase_get(p_query_info_t p_qi);
static apr_status_t searchm_dbase_put(p_query_info_t p_qi);
static apr_status_t searchm_dbase_purge(p_query_info_t p_qi);
#if defined(SEARCHM_DBM)
static apr_status_t searchm_dbm_open(p_query_info_t p_qi);
static apr_status_t searchm_dbm_close(p_query_info_t p_qi);
static apr_status_t searchm_dbm_get(p_query_info_t p_qi, const char * p_key, void ** pkt, unsigned int * psize);
static apr_status_t searchm_dbm_fetch(p_query_info_t p_qi, const char * p_key, void ** pkt, unsigned int * psize);
static apr_status_t searchm_dbm_put(p_query_info_t p_qi, const char * p_key, void * pkt, unsigned int psize);
static apr_status_t searchm_dbm_store(p_query_info_t p_qi, const char * p_key, void * pkt, unsigned int psize);
static apr_status_t searchm_dbm_delete(p_query_info_t p_qi, const char * p_key);
static apr_status_t searchm_dbm_firstkey(p_query_info_t p_qi, char ** p_key);
static apr_status_t searchm_dbm_nextkey(p_query_info_t p_qi, char ** p_key);
static apr_status_t searchm_dbm_purge(p_query_info_t p_qi);
#elif defined(SEARCHM_BDB) /* SEARCHM_DBM */
static int searchm_version_check(apr_pool_t * p);
static apr_status_t searchm_bdb_get(p_query_info_t p_qi, const char * p_key, void ** pkt, unsigned int * psize);
static apr_status_t searchm_bdb_put(p_query_info_t p_qi, const char * p_key, void * pkt, unsigned int psize);
static int searchm_bdb_del(p_query_info_t p_qi, const char * p_key, int * bFound);
static int searchm_bdb_env_close(int env_index,  apr_pool_t * p);
static apr_status_t searchm_bdb_env_open(p_query_info_t p_qi);
static apr_status_t searchm_bdb_db_open(p_query_info_t p_qi);
static int searchm_bdb_db_close(int db_index, apr_pool_t * p);
static apr_status_t searchm_bdb_reqlock_get(p_query_info_t p_qi);
static apr_status_t searchm_bdb_masterlock_get(p_query_info_t p_qi, u_int32_t ltype);
static apr_status_t searchm_bdb_reqlock_free(p_query_info_t p_qi);
static apr_status_t searchm_bdb_masterlock_free(p_query_info_t p_qi);
static apr_status_t searchm_bdb_open(p_query_info_t p_qi);
static apr_status_t searchm_bdb_close(p_query_info_t p_qi);
static apr_status_t searchm_bdb_purge(p_query_info_t p_qi);
static apr_status_t searchm_bdb_purge_check(p_query_info_t p_qi, int * bPurge);

#endif /* SEARCHM_BDB */
#endif /* SEARCHM_H */

---