13 files changed, 946 insertions, 109 deletions

diff --git a/utility/Makefile.in b/utility/Makefile.in
index d397b96..69a746c 100644
--- a/utility/Makefile.in
+++ b/utility/Makefile.in
@@ -4,9 +4,11 @@ top_srcdir = @top_srcdir@
 srcdir = @abs_srcdir@
 builddir = @abs_builddir@
 
-CFLAGS = -g -Wall -fno-strict-aliasing @APR_CFLAGS@ @APR_INCLUDES@ @APU_INCLUDES@
+#@APR_CFLAGS@
+CFLAGS = -g3 -Wall -fno-strict-aliasing \
+         @APR_INCLUDES@ @APU_INCLUDES@ @PCRE_CFLAGS@
 CPPFLAGS = @APR_CPPFLAGS@
-LDFLAGS = @APR_LDFLAGS@ @APU_LDFLAGS@
+LDFLAGS = @APR_LDFLAGS@ @APU_LDFLAGS@ @PCRE_LIBS@
 
 ifeq (@OOO_MAINTAIN@,1)
 CFLAGS += -Werror
@@ -16,10 +18,10 @@ STD_DIST = Makefile.in
 
 DISTFILES = $(STD_DIST) $(EXTRA_DIST) $(SOURCES) $(HEADERS)
 
-SOURCES = shell.c config.c logparse.c
-HEADERS = shell.h config.h logparse.h
-OBJECTS = $(patsubst %.c,%.o,$(SOURCES))
-
+SOURCES = shell.c config.c logparse.c ap_pcre.c util.c
+HEADERS = shell.h config.h logparse.h ap_pcre.h util.h
+OBJECTS = $(SOURCES:.c=.o)
+DEPS = $(SOURCES:.c=.d)
 TARGETS = mod_log_sql
 
 all: $(TARGETS)
@@ -27,8 +29,15 @@ all: $(TARGETS)
 mod_log_sql: $(OBJECTS) $(HEADERS)
         $(CC) -o $@ $(OBJECTS) $(LDFLAGS)
 
+%.o: %.c %.d
+        gcc -c $(CFLAGS) $(CPPFLAGS) $< -o $@
+%.d: %.c
+        gcc -MM $(CFLAGS) $(CPPFLAGS) $< -o $@
+
+-include $(DEPS)
+
 clean:
-        $(RM) $(OBJECTS) $(TARGETS)
+        $(RM) $(OBJECTS) $(TARGETS) $(DEPS)
 
 local-dist: $(DISTFILES)
         mkdir -p $(DESTDIR)
diff --git a/utility/ap_pcre.c b/utility/ap_pcre.c
new file mode 100644
index 0000000..b2b9767
--- /dev/null
+++ b/utility/ap_pcre.c
@@ -0,0 +1,344 @@
+/*************************************************
+ *      Perl-Compatible Regular Expressions       *
+ *************************************************/
+
+/*
+ This is a library of functions to support regular expressions whose syntax
+ and semantics are as close as possible to those of the Perl 5 language. See
+ the file Tech.Notes for some information on the internals.
+
+ This module is a wrapper that provides a POSIX API to the underlying PCRE
+ functions.
+
+ Written by: Philip Hazel <ph10@cam.ac.uk>
+
+ Copyright (c) 1997-2004 University of Cambridge
+
+ -----------------------------------------------------------------------------
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ * Neither the name of the University of Cambridge nor the names of its
+ contributors may be used to endorse or promote products derived from
+ this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE.
+ -----------------------------------------------------------------------------
+ */
+
+#include "apr_lib.h"
+#include "apr_strings.h"
+#include "ap_pcre.h"
+#include "pcre.h"
+
+#define APR_WANT_STRFUNC
+#include "apr_want.h"
+
+#ifndef POSIX_MALLOC_THRESHOLD
+#define POSIX_MALLOC_THRESHOLD (10)
+#endif
+
+/* Table of error strings corresponding to POSIX error codes; must be
+ * kept in synch with include/ap_regex.h's AP_REG_E* definitions. */
+
+static const char *const pstring[] = {
+    "", /* Dummy for value 0 */
+    "internal error", /* AP_REG_ASSERT */
+    "failed to get memory", /* AP_REG_ESPACE */
+    "bad argument", /* AP_REG_INVARG */
+    "match failed" /* AP_REG_NOMATCH */
+};
+
+apr_size_t ap_regerror(int errcode, const ap_regex_t *preg, char *errbuf,
+        apr_size_t errbuf_size)
+{
+    const char *message, *addmessage;
+    apr_size_t length, addlength;
+
+    message
+            = (errcode >= (int)(sizeof(pstring)/sizeof(char *))) ? "unknown error code"
+                    : pstring[errcode];
+    length = strlen(message) + 1;
+
+    addmessage = " at offset ";
+    addlength
+            = (preg != NULL && (int)preg->re_erroffset != -1) ? strlen(addmessage)
+                    + 6
+                    : 0;
+
+    if (errbuf_size > 0) {
+        if (addlength > 0 && errbuf_size >= length + addlength)
+            apr_snprintf(errbuf, sizeof errbuf, "%s%s%-6d", message,
+                    addmessage, (int)preg->re_erroffset);
+        else {
+            strncpy(errbuf, message, errbuf_size - 1);
+            errbuf[errbuf_size-1] = 0;
+        }
+    }
+
+    return length + addlength;
+}
+
+/*************************************************
+ *           Free store held by a regex           *
+ *************************************************/
+
+void ap_regfree(ap_regex_t *preg)
+{
+    (pcre_free)(preg->re_pcre);
+}
+
+/*************************************************
+ *            Compile a regular expression        *
+ *************************************************/
+
+/*
+ Arguments:
+ preg        points to a structure for recording the compiled expression
+ pattern     the pattern to compile
+ cflags      compilation flags
+
+ Returns:      0 on success
+ various non-zero codes on failure
+ */
+
+int ap_regcomp(ap_regex_t *preg, const char *pattern, int cflags)
+{
+    const char *errorptr;
+    int erroffset;
+    int options = 0;
+
+    if ((cflags & AP_REG_ICASE) != 0)
+        options |= PCRE_CASELESS;
+    if ((cflags & AP_REG_NEWLINE) != 0)
+        options |= PCRE_MULTILINE;
+
+    preg->re_pcre = pcre_compile(pattern, options, &errorptr, &erroffset, NULL);
+    preg->re_erroffset = erroffset;
+
+    if (preg->re_pcre == NULL)
+        return AP_REG_INVARG;
+
+    preg->re_nsub = pcre_info((const pcre *)preg->re_pcre, NULL, NULL);
+    return 0;
+}
+
+/*************************************************
+ *              Match a regular expression        *
+ *************************************************/
+
+/* Unfortunately, PCRE requires 3 ints of working space for each captured
+ substring, so we have to get and release working store instead of just using
+ the POSIX structures as was done in earlier releases when PCRE needed only 2
+ ints. However, if the number of possible capturing brackets is small, use a
+ block of store on the stack, to reduce the use of malloc/free. The threshold is
+ in a macro that can be changed at configure time. */
+
+int ap_regexec(const ap_regex_t *preg, const char *string, apr_size_t nmatch,
+        ap_regmatch_t pmatch[], int eflags)
+{
+    int rc;
+    int options = 0;
+    int *ovector= NULL;
+    int small_ovector[POSIX_MALLOC_THRESHOLD * 3];
+    int allocated_ovector = 0;
+
+    if ((eflags & AP_REG_NOTBOL) != 0)
+        options |= PCRE_NOTBOL;
+    if ((eflags & AP_REG_NOTEOL) != 0)
+        options |= PCRE_NOTEOL;
+
+    ((ap_regex_t *)preg)->re_erroffset = (apr_size_t)(-1); /* Only has meaning after compile */
+
+    if (nmatch > 0) {
+        if (nmatch <= POSIX_MALLOC_THRESHOLD) {
+            ovector = &(small_ovector[0]);
+        } else {
+            ovector = (int *)malloc(sizeof(int) * nmatch * 3);
+            if (ovector == NULL)
+                return AP_REG_ESPACE;
+            allocated_ovector = 1;
+        }
+    }
+
+    rc = pcre_exec((const pcre *)preg->re_pcre, NULL, string,
+            (int)strlen(string), 0, options, ovector, nmatch * 3);
+
+    if (rc == 0)
+        rc = nmatch; /* All captured slots were filled in */
+
+    if (rc >= 0) {
+        apr_size_t i;
+        for (i = 0; i < (apr_size_t)rc; i++) {
+            pmatch[i].rm_so = ovector[i*2];
+            pmatch[i].rm_eo = ovector[i*2+1];
+        }
+        if (allocated_ovector)
+            free(ovector);
+        for (; i < nmatch; i++)
+            pmatch[i].rm_so = pmatch[i].rm_eo = -1;
+        return 0;
+    }
+
+    else {
+        if (allocated_ovector)
+            free(ovector);
+        switch (rc) {
+        case PCRE_ERROR_NOMATCH:
+            return AP_REG_NOMATCH;
+        case PCRE_ERROR_NULL:
+            return AP_REG_INVARG;
+        case PCRE_ERROR_BADOPTION:
+            return AP_REG_INVARG;
+        case PCRE_ERROR_BADMAGIC:
+            return AP_REG_INVARG;
+        case PCRE_ERROR_UNKNOWN_NODE:
+            return AP_REG_ASSERT;
+        case PCRE_ERROR_NOMEMORY:
+            return AP_REG_ESPACE;
+#ifdef PCRE_ERROR_MATCHLIMIT
+            case PCRE_ERROR_MATCHLIMIT: return AP_REG_ESPACE;
+#endif
+#ifdef PCRE_ERROR_BADUTF8
+            case PCRE_ERROR_BADUTF8: return AP_REG_INVARG;
+#endif
+#ifdef PCRE_ERROR_BADUTF8_OFFSET
+            case PCRE_ERROR_BADUTF8_OFFSET: return AP_REG_INVARG;
+#endif
+        default:
+            return AP_REG_ASSERT;
+        }
+    }
+}
+
+/*
+ * Here's a pool-based interface to the POSIX-esque ap_regcomp().
+ * Note that we return ap_regex_t instead of being passed one.
+ * The reason is that if you use an already-used ap_regex_t structure,
+ * the memory that you've already allocated gets forgotten, and
+ * regfree() doesn't clear it. So we don't allow it.
+ */
+
+static apr_status_t regex_cleanup(void *preg)
+{
+    ap_regfree((ap_regex_t *) preg);
+    return APR_SUCCESS;
+}
+
+ap_regex_t *ap_pregcomp(apr_pool_t *p, const char *pattern, int cflags)
+{
+    ap_regex_t *preg = apr_palloc(p, sizeof *preg);
+
+    if (ap_regcomp(preg, pattern, cflags)) {
+        return NULL;
+    }
+
+    apr_pool_cleanup_register(p, (void *) preg, regex_cleanup,
+            apr_pool_cleanup_null);
+
+    return preg;
+}
+
+void ap_pregfree(apr_pool_t *p, ap_regex_t *reg)
+{
+    ap_regfree(reg);
+    apr_pool_cleanup_kill(p, (void *) reg, regex_cleanup);
+}
+
+/* This function substitutes for $0-$9, filling in regular expression
+ * submatches. Pass it the same nmatch and pmatch arguments that you
+ * passed ap_regexec(). pmatch should not be greater than the maximum number
+ * of subexpressions - i.e. one more than the re_nsub member of ap_regex_t.
+ *
+ * input should be the string with the $-expressions, source should be the
+ * string that was matched against.
+ *
+ * It returns the substituted string, or NULL on error.
+ *
+ * Parts of this code are based on Henry Spencer's regsub(), from his
+ * AT&T V8 regexp package.
+ */
+
+char * ap_pregsub(apr_pool_t *p, const char *input, const char *source,
+        size_t nmatch, ap_regmatch_t pmatch[])
+{
+    const char *src = input;
+    char *dest, *dst;
+    char c;
+    size_t no;
+    int len;
+
+    if (!source)
+        return NULL;
+    if (!nmatch)
+        return apr_pstrdup(p, src);
+
+    /* First pass, find the size */
+
+    len = 0;
+
+    while ((c = *src++) != '\0') {
+        if (c == '&')
+            no = 0;
+        else if (c == '$' && apr_isdigit(*src))
+            no = *src++ - '0';
+        else
+            no = 10;
+
+        if (no> 9) { /* Ordinary character. */
+            if (c == '\\' && (*src == '$' || *src == '&'))
+                c = *src++;
+            len++;
+        } else if (no < nmatch && pmatch[no].rm_so < pmatch[no].rm_eo) {
+            len += pmatch[no].rm_eo - pmatch[no].rm_so;
+        }
+
+    }
+
+    dest = dst = apr_pcalloc(p, len + 1);
+
+    /* Now actually fill in the string */
+
+    src = input;
+
+    while ((c = *src++) != '\0') {
+        if (c == '&')
+            no = 0;
+        else if (c == '$' && apr_isdigit(*src))
+            no = *src++ - '0';
+        else
+            no = 10;
+
+        if (no> 9) { /* Ordinary character. */
+            if (c == '\\' && (*src == '$' || *src == '&'))
+                c = *src++;
+            *dst++ = c;
+        } else if (no < nmatch && pmatch[no].rm_so < pmatch[no].rm_eo) {
+            len = pmatch[no].rm_eo - pmatch[no].rm_so;
+            memcpy(dst, source + pmatch[no].rm_so, len);
+            dst += len;
+        }
+
+    }
+    *dst = '\0';
+
+    return dest;
+}
+/* End of pcreposix.c */
diff --git a/utility/ap_pcre.h b/utility/ap_pcre.h
new file mode 100644
index 0000000..a851d29
--- /dev/null
+++ b/utility/ap_pcre.h
@@ -0,0 +1,176 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/* Derived from PCRE's pcreposix.h.
+
+            Copyright (c) 1997-2004 University of Cambridge
+
+-----------------------------------------------------------------------------
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+
+    * Neither the name of the University of Cambridge nor the names of its
+      contributors may be used to endorse or promote products derived from
+      this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+-----------------------------------------------------------------------------
+*/
+
+/**
+ * @file ap_regex.h
+ * @brief Apache Regex defines
+ */
+
+#ifndef AP_REGEX_H
+#define AP_REGEX_H
+
+#include "apr.h"
+
+/* Allow for C++ users */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Options for ap_regexec: */
+
+#define AP_REG_ICASE    0x01 /** use a case-insensitive match */
+#define AP_REG_NEWLINE  0x02 /** don't match newlines against '.' etc */
+#define AP_REG_NOTBOL   0x04 /** ^ will not match against start-of-string */
+#define AP_REG_NOTEOL   0x08 /** $ will not match against end-of-string */
+
+#define AP_REG_EXTENDED (0)  /** unused */
+#define AP_REG_NOSUB    (0)  /** unused */
+
+/* Error values: */
+enum {
+  AP_REG_ASSERT = 1,  /** internal error ? */
+  AP_REG_ESPACE,      /** failed to get memory */
+  AP_REG_INVARG,      /** invalid argument */
+  AP_REG_NOMATCH      /** match failed */
+};
+
+/* The structure representing a compiled regular expression. */
+typedef struct {
+    void *re_pcre;
+    apr_size_t re_nsub;
+    apr_size_t re_erroffset;
+} ap_regex_t;
+
+/* The structure in which a captured offset is returned. */
+typedef struct {
+    int rm_so;
+    int rm_eo;
+} ap_regmatch_t;
+
+/* The functions */
+
+/**
+ * Compile a regular expression.
+ * @param preg Returned compiled regex
+ * @param regex The regular expression string
+ * @param cflags Must be zero (currently).
+ * @return Zero on success or non-zero on error
+ */
+int ap_regcomp(ap_regex_t *preg, const char *regex, int cflags);
+
+/**
+ * Match a NUL-terminated string against a pre-compiled regex.
+ * @param preg The pre-compiled regex
+ * @param string The string to match
+ * @param nmatch Provide information regarding the location of any matches
+ * @param pmatch Provide information regarding the location of any matches
+ * @param eflags Bitwise OR of any of AP_REG_* flags
+ * @return 0 for successful match, #REG_NOMATCH otherwise
+ */
+int ap_regexec(const ap_regex_t *preg, const char *string,
+                           apr_size_t nmatch, ap_regmatch_t *pmatch, int eflags);
+
+/**
+ * Return the error code returned by regcomp or regexec into error messages
+ * @param errcode the error code returned by regexec or regcomp
+ * @param preg The precompiled regex
+ * @param errbuf A buffer to store the error in
+ * @param errbuf_size The size of the buffer
+ */
+apr_size_t ap_regerror(int errcode, const ap_regex_t *preg,
+                                   char *errbuf, apr_size_t errbuf_size);
+
+/** Destroy a pre-compiled regex.
+ * @param preg The pre-compiled regex to free.
+ */
+void ap_regfree(ap_regex_t *preg);
+
+/**
+ * Compile a regular expression to be used later
+ * @param p The pool to allocate from
+ * @param pattern the regular expression to compile
+ * @param cflags The bitwise or of one or more of the following:
+ *   @li REG_EXTENDED - Use POSIX extended Regular Expressions
+ *   @li REG_ICASE    - Ignore case
+ *   @li REG_NOSUB    - Support for substring addressing of matches
+ *       not required
+ *   @li REG_NEWLINE  - Match-any-character operators don't match new-line
+ * @return The compiled regular expression
+ */
+ap_regex_t * ap_pregcomp(apr_pool_t *p, const char *pattern,
+                                     int cflags);
+
+/**
+ * Free the memory associated with a compiled regular expression
+ * @param p The pool the regex was allocated from
+ * @param reg The regular expression to free
+ */
+void ap_pregfree(apr_pool_t *p, ap_regex_t *reg);
+
+/**
+ * After performing a successful regex match, you may use this function to
+ * perform a series of string substitutions based on subexpressions that were
+ * matched during the call to ap_regexec
+ * @param p The pool to allocate from
+ * @param input An arbitrary string containing $1 through $9.  These are
+ *              replaced with the corresponding matched sub-expressions
+ * @param source The string that was originally matched to the regex
+ * @param nmatch the nmatch returned from ap_pregex
+ * @param pmatch the pmatch array returned from ap_pregex
+ */
+char * ap_pregsub(apr_pool_t *p, const char *input, const char *source,
+                              size_t nmatch, ap_regmatch_t pmatch[]);
+
+#ifdef __cplusplus
+}   /* extern "C" */
+#endif
+
+#endif /* AP_REGEX_T */
+
diff --git a/utility/config.c b/utility/config.c
index 6b3dce1..847d474 100644
--- a/utility/config.c
+++ b/utility/config.c
@@ -3,53 +3,61 @@
 #include "apr_file_io.h"
 #include "apr_strings.h"
 #include "apr_hash.h"
-#include "apr_lib.h"
+
 #include "shell.h"
 #include "config.h"
+#include "util.h"
+#include "logparse.h"
 
 apr_hash_t *g_config_opts;
 
-apr_status_t config_set_string(config_t *cfg, config_opt_t *opt, int argc,
-        const char **argv)
+static apr_status_t config_set_string(config_t *cfg, config_opt_t *opt,
+        int argc, const char **argv)
 {
     int offset = (int)(long)opt->data;
     char **data = (char **)((void *)cfg + offset);
-    if (argc != 2) return APR_EINVAL;
+    if (argc != 2)
+        return APR_EINVAL;
     *data = apr_pstrdup(cfg->pool, argv[1]);
     return APR_SUCCESS;
 }
 
-apr_status_t config_set_int(config_t *cfg, config_opt_t *opt, int argc,
+static apr_status_t config_set_int(config_t *cfg, config_opt_t *opt, int argc,
+        const char **argv) __attribute__ ((__unused__));
+static apr_status_t config_set_int(config_t *cfg, config_opt_t *opt, int argc,
         const char **argv)
 {
     int offset = (int)(long)opt->data;
     int *data = (int *)((void *)cfg + offset);
-    if (argc != 2) return APR_EINVAL;
+    if (argc != 2)
+        return APR_EINVAL;
     *data = apr_atoi64(argv[1]);
     return APR_SUCCESS;
 }
 
-apr_status_t config_set_flag(config_t *cfg, config_opt_t *opt, int argc,
+static apr_status_t config_set_flag(config_t *cfg, config_opt_t *opt, int argc,
         const char **argv)
 {
     int offset = (int)(long)opt->data;
     int *data = (int *)((void *)cfg + offset);
-    if (argc != 2) return APR_EINVAL;
+    if (argc != 2)
+        return APR_EINVAL;
     *data = CHECK_YESNO(argv[1]);
     return APR_SUCCESS;
 }
 
-apr_status_t config_set_loglevel(config_t *cfg, config_opt_t *opt, int argc,
-        const char **argv)
+static apr_status_t config_set_loglevel(config_t *cfg, config_opt_t *opt,
+        int argc, const char **argv)
 {
-    if (argc != 2) return APR_EINVAL;
-    if (!strcasecmp(argv[1],"error")) {
+    if (argc != 2)
+        return APR_EINVAL;
+    if (!strcasecmp(argv[1], "error")) {
         cfg->loglevel = LOGLEVEL_ERROR;
-    } else if (!strcasecmp(argv[1],"warn")) {
+    } else if (!strcasecmp(argv[1], "warn")) {
         cfg->loglevel = LOGLEVEL_WARN;
-    } else if (!strcasecmp(argv[1],"debug")) {
+    } else if (!strcasecmp(argv[1], "debug")) {
         cfg->loglevel = LOGLEVEL_DEBUG;
-    } else if (!strcasecmp(argv[1],"quiet")) {
+    } else if (!strcasecmp(argv[1], "quiet")) {
         cfg->loglevel = LOGLEVEL_QUIET;
     } else {
         cfg->loglevel = LOGLEVEL_ERROR;
@@ -57,49 +65,51 @@ apr_status_t config_set_loglevel(config_t *cfg, config_opt_t *opt, int argc,
     return APR_SUCCESS;
 }
 
-apr_status_t config_set_dbconnect(config_t *cfg, config_opt_t *opt, int argc,
-        const char **argv)
+static apr_status_t config_set_dbconnect(config_t *cfg, config_opt_t *opt,
+        int argc, const char **argv)
 {
     return APR_SUCCESS;
 }
 
-apr_status_t config_set_dbparam(config_t *cfg, config_opt_t *opt, int argc,
-        const char **argv)
+static apr_status_t config_set_dbparam(config_t *cfg, config_opt_t *opt,
+        int argc, const char **argv)
 {
     return APR_SUCCESS;
 }
 
-apr_status_t config_set_inputfile(config_t *cfg, config_opt_t *opt, int argc,
-        const char **argv)
+static apr_status_t config_set_inputfile(config_t *cfg, config_opt_t *opt,
+        int argc, const char **argv)
 {
     char **newp;
-    if (argc != 2) return APR_EINVAL;
+    if (argc != 2)
+        return APR_EINVAL;
     newp = (char **)apr_array_push(cfg->input_files);
     *newp = apr_pstrdup(cfg->pool, argv[1]);
     return APR_SUCCESS;
 }
 
-apr_status_t config_set_dummy(config_t *cfg, config_opt_t *opt, int argc,
-        const char **argv)
+static apr_status_t config_set_dummy(config_t *cfg, config_opt_t *opt,
+        int argc, const char **argv)
 {
     return APR_SUCCESS;
 }
 
-apr_status_t config_set_logformat(config_t *cfg, config_opt_t *opt, int argc,
-        const char **argv)
+static apr_status_t config_set_logformat(config_t *cfg, config_opt_t *opt,
+        int argc, const char **argv)
 {
     config_logformat_t *format;
     config_logformat_field_t *field;
 
-    if (argc != 4) return APR_EINVAL;
+    if (argc != 4)
+        return APR_EINVAL;
 
-    format = apr_hash_get(cfg->log_formats,argv[1],APR_HASH_KEY_STRING);
+    format = apr_hash_get(cfg->log_formats, argv[1], APR_HASH_KEY_STRING);
     if (!format) {
         format = apr_palloc(cfg->pool, sizeof(config_logformat_t));
         format->name = apr_pstrdup(cfg->pool, argv[1]);
         format->fields = apr_array_make(cfg->pool, 5,
                 sizeof(config_logformat_field_t));
-        apr_hash_set(cfg->log_formats, argv[1], APR_HASH_KEY_STRING, format);
+        apr_hash_set(cfg->log_formats, apr_pstrdup(cfg->pool,argv[1]), APR_HASH_KEY_STRING, format);
     }
     field = (config_logformat_field_t *)apr_array_push(format->fields);
     field->name = apr_pstrdup(cfg->pool, argv[2]);
@@ -107,18 +117,100 @@ apr_status_t config_set_logformat(config_t *cfg, config_opt_t *opt, int argc,
     return APR_SUCCESS;
 }
 
+static apr_status_t config_set_output_field(config_t *cfg, config_opt_t *opt,
+        int argc, const char **argv)
+{
+    config_output_field_t *field;
+    char *type, *size, *temp;
+
+    if (argc < 4)
+        return APR_EINVAL;
+    field = (config_output_field_t *)apr_array_push(cfg->output_fields);
+    field->field = apr_pstrdup(cfg->pool, argv[1]);
+    field->source = apr_pstrdup(cfg->pool, argv[3]);
+
+    type = size = apr_pstrdup(cfg->pool, argv[2]);
+    while (*size!='\0' && *size!='(')
+        size++;
+    if (*size == '(') {
+        *size = '\0';
+        size++;
+        temp = size;
+        while (*temp != '\0' && *temp != ')')
+            temp++;
+        *temp = '\0';
+        field->size = apr_atoi64(size);
+    }
+    if (strcasecmp("VARCHAR", type)==0) {
+        field->datatype = LOGSQL_DATATYPE_VARCHAR;
+    } else if (strcasecmp("INT", type)==0) {
+        field->datatype = LOGSQL_DATATYPE_INT;
+    } else if (strcasecmp("CHAR", type)==0) {
+        field->datatype = LOGSQL_DATATYPE_CHAR;
+    } else if (strcasecmp("SMALLINT", type)==0) {
+        field->datatype = LOGSQL_DATATYPE_SMALLINT;
+    } else if (strcasecmp("BIGINT", type)==0) {
+        field->datatype = LOGSQL_DATATYPE_BIGINT;
+    } else {
+        return APR_EINVAL;
+    }
+
+    // Has a function
+    if (argc > 4) {
+        int i;
+        field->fname = apr_pstrdup(cfg->pool, argv[4]);
+        field->func = parser_get_func(field->fname);
+        field->args = apr_pcalloc(cfg->pool, sizeof(char *) * (argc-4+1));
+        for (i=5; i<=argc; i++) {
+            field->args[i-5] = apr_pstrdup(cfg->pool, argv[i]);
+        }
+    }
+
+    return APR_SUCCESS;
+}
+
+static apr_status_t config_set_filter(config_t *cfg, config_opt_t *opt,
+        int argc, const char **argv)
+{
+    int argn = 1;
+    config_filter_t *filter;
+    filter = apr_pcalloc(cfg->pool, sizeof(config_filter_t));
+
+    if (opt->name[0]!='L') { // Pre or post 2-3 args
+        if (argc == 1)
+            return APR_EINVAL;
+        filter->field = apr_pstrdup(cfg->pool, argv[1]);
+        argn++;
+    } // Otherwise Line based only 1-2 args (no field)
+    if (argc <= argn)
+        return APR_EINVAL;
+    if (argv[argn][0] == '+')
+        argn++;
+    if (argv[argn][0] == '-') {
+        filter->negative = 1;
+        argn++;
+    }
+    if (argc <= argn)
+        return APR_EINVAL;
+    filter->filter = apr_pstrdup(cfg->pool, argv[argn]);
+    filter->regex = ap_pregcomp(cfg->pool, filter->filter, AP_REG_ICASE);
+    return APR_SUCCESS;
+}
+
 void config_dump(config_t *cfg)
 {
     apr_hash_index_t *hi;
+    int i;
+    config_output_field_t *fields;
 
-    printf("ErrorLog: %s\n",cfg->errorlog);
-    printf("LogLevel: %d\n",cfg->loglevel);
+    printf("ErrorLog: %s\n", cfg->errorlog);
+    printf("LogLevel: %d\n", cfg->loglevel);
 
-    printf("InputDir: %s\n",cfg->input_dir);
+    printf("InputDir: %s\n", cfg->input_dir);
 
-    printf("Table: %s\n",cfg->table);
-    printf("Transactions: %d\n",cfg->transactions);
-    printf("MachineID: %s\n",cfg->machineid);
+    printf("Table: %s\n", cfg->table);
+    printf("Transactions: %d\n", cfg->transactions);
+    printf("MachineID: %s\n", cfg->machineid);
 
     printf("Log formats:\n");
     for (hi = apr_hash_first(cfg->pool, cfg->log_formats); hi; hi
@@ -128,31 +220,39 @@ void config_dump(config_t *cfg)
         int i;
 
         apr_hash_this(hi, NULL, NULL, (void **)&format);
-        printf(">> %s\n",format->name);
+        printf(">> '%s'\n", format->name);
         fields = (config_logformat_field_t *)format->fields->elts;
         for (i=0; i<format->fields->nelts; i++) {
             printf(">>>> %s:%s\n", fields[i].name, fields[i].datatype);
         }
     }
-    printf("Log Format: %s\n",cfg->logformat);
-
-    printf("DryRun: %d\n",cfg->dryrun);
-    printf("Summary: %d\n",cfg->summary);
-}
-
-static char *lowerstr(apr_pool_t *pool, const char *input) {
-        char *temp;
-        char *itr;
-        temp = apr_pstrdup(pool, input);
-        for (itr=temp; *itr!='\0'; itr++) {
-                *itr = apr_tolower(*itr);
+    printf("Log Format: '%s'\n", cfg->logformat);
+
+    printf("Output Fields:\n");
+    fields = (config_output_field_t *)cfg->output_fields->elts;
+    for (i=0; i<cfg->output_fields->nelts; i++) {
+        printf(">> %s %s(%d): %s", fields[i].field, logsql_field_datatyeName(fields[i].datatype), fields[i].size, fields[i].source);
+        if (fields[i].func) {
+            printf(" :: %s(", fields[i].fname);
+            if (fields[i].args) {
+                int a = 0;
+                while (fields[i].args[a]) {
+                    printf("%s,", fields[i].args[a]);
+                    a++;
+                }
+            }
+            printf(")");
         }
-        return temp;
+        printf("\n");
+    }
+
+    printf("DryRun: %d\n", cfg->dryrun);
+    printf("Summary: %d\n", cfg->summary);
 }
 
 #define config_get_option(name) apr_hash_get(g_config_opts, name, APR_HASH_KEY_STRING)
 
-void config_add_option(apr_pool_t *p, const char *const name,
+static void config_add_option(apr_pool_t *p, const char *const name,
         const char *const help, config_func_t func, void *data)
 {
     config_opt_t *opt;
@@ -164,22 +264,24 @@ void config_add_option(apr_pool_t *p, const char *const name,
     opt->help = help;
     opt->func = func;
     opt->data = data;
-    apr_hash_set(g_config_opts, lowerstr(p,name), APR_HASH_KEY_STRING, opt);
+    apr_hash_set(g_config_opts, lowerstr(p, name), APR_HASH_KEY_STRING, opt);
 }
 
 void config_init(apr_pool_t *p)
 {
-    config_add_option(p, "ErrorLog", "File to log errors",
-            config_set_string, (void *)APR_OFFSETOF(config_t, errorlog));
-    config_add_option(p, "LogLevel", "Set Log Level (error, warn, debug, quiet)",
-            config_set_loglevel, NULL);
+    config_add_option(p, "ErrorLog", "File to log errors", config_set_string,
+            (void *)APR_OFFSETOF(config_t, errorlog));
+    config_add_option(p, "LogLevel",
+            "Set Log Level (error, warn, debug, quiet)", config_set_loglevel,
+            NULL);
 
     config_add_option(p, "InputDirectory", "Directory to scan for log files",
             config_set_string, (void *)APR_OFFSETOF(config_t, input_dir));
     config_add_option(p, "InputFile", "Parse only this file",
             config_set_inputfile, NULL);
 
-    config_add_option(p, "DBConnect", "DB Connection information  type://user:pass@hostname/database",
+    config_add_option(p, "DBConnect",
+            "DB Connection information  type://user:pass@hostname/database",
             config_set_dbconnect, NULL);
     config_add_option(p, "DBParam", "DB Connection Parameter",
             config_set_dbparam, NULL);
@@ -187,14 +289,28 @@ void config_init(apr_pool_t *p)
             config_set_string, (void *)APR_OFFSETOF(config_t, table));
     config_add_option(p, "UseTransactions", "Enable Transactions?",
             config_set_flag, (void *)APR_OFFSETOF(config_t, transactions));
-    config_add_option(p, "MachineID", "Machine ID to set",
-            config_set_string, (void *)APR_OFFSETOF(config_t, machineid));
+    config_add_option(p, "MachineID", "Machine ID to set", config_set_string,
+            (void *)APR_OFFSETOF(config_t, machineid));
 
     config_add_option(p, "LogFormatConfig", "Define input log formats",
             config_set_logformat, NULL);
     config_add_option(p, "LogFormat", "Use this logformat when parsing files",
             config_set_string, (void *)APR_OFFSETOF(config_t, logformat));
 
+    config_add_option(p, "LineFilter",
+            "A regular expression to apply to the input line",
+            config_set_filter, (void *)APR_OFFSETOF(config_t, linefilters));
+    config_add_option(p, "PreFilter",
+            "A regular expression to apply to a specific input field",
+            config_set_filter, (void *)APR_OFFSETOF(config_t, prefilters));
+    config_add_option(p, "PostFilter",
+            "A regular expression to apply to a specific SQL output field",
+            config_set_filter, (void *)APR_OFFSETOF(config_t, postfilters));
+
+    config_add_option(p, "OutputField",
+            "Define output fields: field datatype source optfunc optarg...",
+            config_set_output_field, NULL);
+
     config_add_option(p, "DryRun", "Don't perform any actual database changes",
             config_set_flag, (void *)APR_OFFSETOF(config_t, dryrun));
     config_add_option(p, "Config", "Dummy to handle config directive",
@@ -216,16 +332,20 @@ config_t *config_create(apr_pool_t *p)
     cfg->input_files = apr_array_make(cfg->pool, 10, sizeof(char *));
     cfg->dbconfig = apr_table_make(cfg->pool, 5);
     cfg->log_formats = apr_hash_make(cfg->pool);
-
+    cfg->output_fields = apr_array_make(cfg->pool, 10,
+            sizeof(config_output_field_t));
     return cfg;
 }
 
-int config_merge(void *rec, const char *key, const char *value) {
+static int config_merge(void *rec, const char *key, const char *value)
+{
     config_t *cfg = (config_t *)rec;
 
-    config_opt_t *opt = config_get_option(key);
+    config_opt_t *opt= config_get_option(key);
     if (opt) {
-        const char *args[] = {key, value};
+        const char *args[] = {
+            key,
+            value };
         opt->func(cfg, opt, 2, args);
     } else {
         printf("Unhandled: %s\n", key);
@@ -238,11 +358,11 @@ apr_status_t config_read(config_t *cfg, const char *filename,
 {
     apr_finfo_t finfo;
     apr_file_t *file;
-    apr_status_t rv, ret = APR_SUCCESS;
+    apr_status_t rv, ret= APR_SUCCESS;
     apr_pool_t *tp, *targp;
     config_opt_t *opt;
     char buff[1024];
-    char *ptr, *ptr2;
+    char *ptr;
     char **targv;
     int targc;
     int line;
@@ -254,7 +374,7 @@ apr_status_t config_read(config_t *cfg, const char *filename,
         return APR_ENOENT;
     }
     rv = apr_file_open(&file, filename, APR_FOPEN_READ | APR_BUFFERED,
-            APR_OS_DEFAULT, tp);
+    APR_OS_DEFAULT, tp);
     if (rv != APR_SUCCESS)
         return rv;
 
@@ -267,10 +387,7 @@ apr_status_t config_read(config_t *cfg, const char *filename,
             // skip leading white space
             for (ptr = buff; *ptr == ' ' || *ptr == '\t'; ptr++)
                 ;
-            // chomp off newline
-            for (ptr2 = ptr + strlen(ptr); *ptr2 != '\r' && *ptr2 != '\n'; ptr2--)
-                ;
-            *ptr2 = '\0';
+            line_chomp(ptr);
 
             // skip comments
             if (*ptr == '#')
@@ -278,9 +395,10 @@ apr_status_t config_read(config_t *cfg, const char *filename,
             if (*ptr == '\0')
                 continue;
             apr_pool_clear(targp);
-            apr_tokenize_to_argv(buff, &targv, targp);
+            apr_tokenize_to_argv(ptr, &targv, targp);
             targc = 0;
-            while (targv[targc]) targc++;
+            while (targv[targc])
+                targc++;
             opt = config_get_option(lowerstr(targp,targv[0]));
             if (opt) {
                 rv = opt->func(cfg, opt, targc, (const char **)targv);
@@ -296,10 +414,9 @@ apr_status_t config_read(config_t *cfg, const char *filename,
     } while (rv == APR_SUCCESS);
 
     // Apply merges
-    apr_table_do(config_merge,(void *)cfg,merge,NULL);
+    apr_table_do(config_merge, (void *)cfg, merge, NULL);
 
     apr_file_close(file);
     apr_pool_destroy(tp);
     return ret;
 }
-
diff --git a/utility/config.h b/utility/config.h
index e1827fe..67f8ea5 100644
--- a/utility/config.h
+++ b/utility/config.h
@@ -5,6 +5,8 @@
 #include "apr_hash.h"
 #include "apr_file_io.h"
 
+#include "ap_pcre.h"
+
 typedef enum {
     LOGLEVEL_QUIET = 0,
     LOGLEVEL_ERROR = 1,
@@ -12,7 +14,8 @@ typedef enum {
     LOGLEVEL_DEBUG = 3,
 } loglevel_e;
 
-typedef struct {
+typedef struct config_t config_t;
+struct config_t {
     /** the structures pool (to ease function arguments) */
     apr_pool_t *pool;
 
@@ -46,29 +49,33 @@ typedef struct {
     apr_array_header_t *output_fields;
 
     /** filter configuration */
-    apr_array_header_t *filters;
+    apr_array_header_t *linefilters;
+    apr_array_header_t *prefilters;
+    apr_array_header_t *postfilters;
 
     /** Dry Run */
     int dryrun;
 
     /* Show the summary */
     int summary;
-} config_t;
+};
+
 
-typedef struct {
+typedef struct config_logformat_t config_logformat_t;
+struct config_logformat_t {
     const char *name;
     apr_array_header_t *fields;
-} config_logformat_t;
+};
 
-typedef struct {
+typedef struct config_logformat_field_t config_logformat_field_t;
+struct config_logformat_field_t {
     const char *name;
     const char *datatype;
-} config_logformat_field_t;
+};
 
 typedef struct config_opt_t config_opt_t;
 typedef apr_status_t (*config_func_t)(config_t *cfg, config_opt_t *opt,
         int argc, const char **argv);
-
 struct config_opt_t {
     const char *name;
     const char *help;
@@ -76,6 +83,40 @@ struct config_opt_t {
     void *data;
 };
 
+typedef struct config_filter_t config_filter_t;
+struct config_filter_t {
+    const char *field;
+    const char *filter;
+    int negative;
+    ap_regex_t *regex;
+};
+
+typedef enum {
+    LOGSQL_DATATYPE_INT = 0,
+    LOGSQL_DATATYPE_SMALLINT,
+    LOGSQL_DATATYPE_VARCHAR,
+    LOGSQL_DATATYPE_CHAR,
+    LOGSQL_DATATYPE_BIGINT
+} logsql_field_datatype;
+#define logsql_field_datatyeName(x) \
+        (x == LOGSQL_DATATYPE_INT ? "INT" \
+        : (x == LOGSQL_DATATYPE_SMALLINT ? "SMALLINT" \
+        : (x == LOGSQL_DATATYPE_VARCHAR ? "VARCHAR" \
+        : (x == LOGSQL_DATATYPE_CHAR ? "CHAR" \
+        : (x == LOGSQL_DATATYPE_BIGINT ? "BIGINT" : "ERR")))))
+
+typedef struct config_output_field_t config_output_field_t;
+
+struct config_output_field_t {
+    const char *field;
+    logsql_field_datatype datatype;
+    apr_size_t size;
+    const char *source;
+    const char *fname;
+    void *func;
+    const char **args;
+};
+
 #define CHECK_YESNO(c) ((!strcasecmp(c,"on") || !strcasecmp(c,"yes")) ? 1 : 0)
 
 /**
@@ -99,6 +140,4 @@ config_t *config_create(apr_pool_t *p);
 apr_status_t config_read(config_t *cfg, const char *filename,
         apr_table_t *merge);
 
-void config_generate(const char *filename);
-
 #endif /*CONFIG_H_*/
diff --git a/utility/database.c b/utility/database.c
new file mode 100644
index 0000000..5fece50
--- /dev/null
+++ b/utility/database.c
@@ -0,0 +1,2 @@
+#include "database.h"
+
diff --git a/utility/database.h b/utility/database.h
new file mode 100644
index 0000000..9fc4844
--- /dev/null
+++ b/utility/database.h
@@ -0,0 +1,4 @@
+#ifndef DATABASE_H_
+#define DATABASE_H_
+
+#endif /*DATABASE_H_*/
diff --git a/utility/logparse.c b/utility/logparse.c
index 2940534..4d823ce 100644
--- a/utility/logparse.c
+++ b/utility/logparse.c
@@ -3,7 +3,35 @@
 #include "apr_file_io.h"
 #include "apr_strings.h"
 
-void find_log_files(config_t *cfg)
+#include "util.h"
+
+apr_hash_t *g_parser_funcs;
+
+static apr_status_t parser_func_regexmatch(config_t *cfg, const char *data,
+        int argc, const char **argv)
+{
+    return APR_SUCCESS;
+}
+parser_func_t parser_get_func(const char *name)
+{
+    return apr_hash_get(g_parser_funcs, name, APR_HASH_KEY_STRING);
+}
+
+static void parser_add_func(apr_pool_t *p, const char *const name,
+           parser_func_t func)
+{
+    if (!g_parser_funcs) {
+        g_parser_funcs = apr_hash_make(p);
+    }
+    apr_hash_set(g_parser_funcs, lowerstr(p, name), APR_HASH_KEY_STRING, func);
+}
+
+void parser_init(apr_pool_t *p)
+{
+    parser_add_func(p, "regexmatch", parser_func_regexmatch);
+}
+
+void parser_find_logs(config_t *cfg)
 {
     apr_pool_t *tp;
     apr_dir_t *dir;
@@ -39,7 +67,7 @@ void find_log_files(config_t *cfg)
  *                   found during parsing of the arg_str.
  *    keepquotes:    Keep the quotes instead of stripping them
  */
-apr_status_t tokenize_logline(const char *arg_str, char ***argv_out,
+static apr_status_t tokenize_logline(const char *arg_str, char ***argv_out,
         apr_pool_t *token_context, int keepquotes)
 {
     const char *cp;
@@ -157,7 +185,7 @@ apr_status_t tokenize_logline(const char *arg_str, char ***argv_out,
 
 apr_status_t parse_logfile(config_t *cfg, const char *filename)
 {
-    apr_pool_t *tp, *argp;
+    apr_pool_t *tp, *targp;
     apr_file_t *file;
     apr_status_t rv;
     char buff[2048];
@@ -166,7 +194,7 @@ apr_status_t parse_logfile(config_t *cfg, const char *filename)
     int line;
 
     apr_pool_create(&tp, cfg->pool);
-    apr_pool_create(&argp, tp);
+    apr_pool_create(&targp, tp);
 
     rv = apr_file_open(&file, filename, APR_FOPEN_READ | APR_BUFFERED,
             APR_OS_DEFAULT, tp);
@@ -180,16 +208,16 @@ apr_status_t parse_logfile(config_t *cfg, const char *filename)
         rv = apr_file_gets(buff, 1024, file);
         if (rv == APR_SUCCESS) {
             line++;
-            char *ptr;
             // chomp off newline
-            for (ptr = buff + strlen(buff); *ptr != '\r' && *ptr != '\n'; ptr--)
-                ;
-            *ptr = '\0';
-            apr_pool_clear(argp);
-            tokenize_logline(buff, &targv, argp, 1);
+            line_chomp(buff);
+
+            apr_pool_clear(targp);
+            tokenize_logline(buff, &targv, targp, 1);
             targc = 0;
             while (targv[targc]) targc++;
-            if (targc != 9) {
+            /** @todo Run Line Filters here */
+            rv = parse_processline(targp, cfg, targv, targc);
+            if (rv != APR_SUCCESS) {
                 int i;
                 printf("Line %d(%d): %s\n",line, targc, buff);
                 for (i = 0; targv[i]; i++) {
@@ -203,3 +231,46 @@ apr_status_t parse_logfile(config_t *cfg, const char *filename)
     apr_pool_destroy(tp);
     return APR_SUCCESS;
 }
+
+apr_status_t parse_processline(apr_pool_t *ptemp, config_t *cfg, char **argv, int argc)
+{
+    config_logformat_t *fmt;
+    config_logformat_field_t *ifields;
+    config_output_field_t *ofields;
+    apr_table_t *datain;
+    apr_table_t *dataout;
+    int i;
+
+    fmt = apr_hash_get(cfg->log_formats, cfg->logformat, APR_HASH_KEY_STRING);
+    if (!fmt) return APR_EINVAL;
+    if (fmt->fields->nelts != argc) return APR_EINVAL;
+
+    datain = apr_table_make(ptemp, fmt->fields->nelts);
+    dataout = apr_table_make(ptemp, cfg->output_fields->nelts);
+
+    ifields = (config_logformat_field_t *)fmt->fields->elts;
+    for (i=0; i<fmt->fields->nelts; i++) {
+        apr_table_setn(datain,ifields[i].name,argv[i]);
+    }
+    /** @todo Run Pre Filters here */
+
+    // Convert input fields to output fields
+    ofields = (config_output_field_t *)cfg->output_fields->elts;
+    for (i=0; i<cfg->output_fields->nelts; i++) {
+        const char *t;
+        if (!ofields[i].func) {
+            t = apr_table_get(datain, ofields[i].source);
+            if (!t) {
+                return APR_EINVAL;
+            }
+            apr_table_setn(dataout,ofields[i].field, t);
+            printf("S: %s = %s\n",ofields[i].source, t);
+        } else {
+            printf("S: %s, F: %p\n",ofields[i].source, ofields[i].func);
+        }
+    }
+
+    /** @todo Run Post Filters here */
+
+    return APR_SUCCESS;
+}
diff --git a/utility/logparse.h b/utility/logparse.h
index 540a9e0..ebabf56 100644
--- a/utility/logparse.h
+++ b/utility/logparse.h
@@ -3,8 +3,17 @@
 
 #include "config.h"
 
-void find_log_files(config_t *cfg);
+typedef apr_status_t (*parser_func_t)(config_t *cfg, const char *data,
+        int argc, const char **argv);
+
+parser_func_t parser_get_func(const char *name);
+
+void parser_init(apr_pool_t *p);
+
+void parser_find_logs(config_t *cfg);
 
 apr_status_t parse_logfile(config_t *cfg, const char *filename);
 
+apr_status_t parse_processline(apr_pool_t *ptemp, config_t *cfg, char **argv, int argc);
+
 #endif /*LOGPARSE_H_*/
diff --git a/utility/mod_log_sql.conf b/utility/mod_log_sql.conf
index 6cfae61..72f0205 100644
--- a/utility/mod_log_sql.conf
+++ b/utility/mod_log_sql.conf
@@ -9,7 +9,7 @@ LogLevel notice
 DryRun on
 Summary on
 
-LogFormatConfig CLF host String
+LogFormatConfig CLF remhost String
 LogFormatConfig CLF ident String
 LogFormatConfig CLF user String
 LogFormatConfig CLF date Date
@@ -17,7 +17,7 @@ LogFormatConfig CLF request String
 LogFormatConfig CLF status Number
 LogFormatConfig CLF bytes_sent Number
 
-LogFormatConfig Combined host String
+LogFormatConfig Combined remhost String
 LogFormatConfig Combined ident String
 LogFormatConfig Combined user String
 LogFormatConfig Combined date Date
@@ -28,3 +28,23 @@ LogFormatConfig Combined referer String
 LogFormatConfig Combined agent String
 
 LogFormat Combined
+
+# not yet implemented
+Linefilter - "BAD"
+PreFilter request - "GET \/images"
+PostFilter request_method "GET"
+
+# Usage     field datatype(size)            source      [function [param]...]
+OutputField bytes_sent int                  bytes_sent
+OutputField request_protocol varchar(10)    request     regexmatch "(HTTP\/[\d\.]+)$"
+OutputField remote_host varchar(50)         remhost
+OutputField request_method varchar(25)      request     regexmatch "^(\w+)"
+OutputField time_stamp int                  date        totimestamp
+OutputField status smallint                 status
+OutputField request_uri varchar(255)        request     regexmatch "^\w+ (.+) \w+\.[\d\.]+$"
+OutputField remote_user varchar(50)         user
+OutputField remote_logname varchar(50)      ident
+OutputField remote_time char(28)            date
+#Only used for Combined log input, if standard CLF input, they are ignored
+OutputField agent varchar(255)              agent
+OutputField referer varchar(255)            referer
diff --git a/utility/shell.c b/utility/shell.c
index 07d9da1..eaa7098 100644
--- a/utility/shell.c
+++ b/utility/shell.c
@@ -54,7 +54,7 @@ void show_help(const char *prog, const apr_getopt_option_t *opts, FILE *output)
 
 int main(int argc, const char *const argv[])
 {
-    apr_pool_t *pool;
+    apr_pool_t *pool, *ptemp;
     apr_getopt_t *opts;
     int opt;
     const char *opt_arg;
@@ -69,12 +69,13 @@ int main(int argc, const char *const argv[])
         fprintf(stderr, "Failed to create memory pool!\n");
         exit(1);
     }
+    apr_pool_create(&ptemp, NULL);
 
     /** Iterate over command line arguments
      * shoving args in a apr_table for processing later*/
-    args = apr_table_make(pool, 5);
+    args = apr_table_make(ptemp, 5);
     apr_table_setn(args, "config", "mod_log_sql.conf");
-    apr_getopt_init(&opts, pool, argc, argv);
+    apr_getopt_init(&opts, ptemp, argc, argv);
     while ((rv = apr_getopt_long(opts, _opt_config, &opt, &opt_arg)) == APR_SUCCESS) {
         switch (opt) {
         case 'c':
@@ -122,17 +123,21 @@ int main(int argc, const char *const argv[])
     }
 
     // Process configuration file
+    parser_init(pool);
     config_init(pool);
     base = config_create(pool);
     rv = config_read(base, apr_table_get(args,"Config"), args);
+    apr_pool_destroy(ptemp);
+
     if (APR_STATUS_IS_ENOENT(rv)) {
         fprintf(stderr,"Could not load configuration file: %s\n",apr_table_get(args,"config"));
     } else if (rv) {
         exit(1);
     }
     config_dump(base);
-    // Apply overrides from command line
-    find_log_files(base);
+
+    // Find files and parse
+    parser_find_logs(base);
     if (!apr_is_empty_array(base->input_files)) {
         char **filelist;
         int f, l;
diff --git a/utility/util.c b/utility/util.c
new file mode 100644
index 0000000..ef3ea68
--- /dev/null
+++ b/utility/util.c
@@ -0,0 +1,28 @@
+#include "util.h"
+#include "apr_strings.h"
+#include "apr_lib.h"
+
+
+char *lowerstr(apr_pool_t *pool, const char *input)
+{
+    char *temp;
+    char *itr;
+    temp = apr_pstrdup(pool, input);
+    for (itr=temp; *itr!='\0'; itr++) {
+        *itr = apr_tolower(*itr);
+    }
+    return temp;
+}
+
+void line_chomp(char *str)
+{
+    int len;
+    // chomp off newline
+    len = strlen(str);
+    if (len) {
+        while (str[len-1] == '\r' || str[len-1] == '\n') {
+            str[len-1] = '\0';
+            len--;
+        }
+    }
+}
diff --git a/utility/util.h b/utility/util.h
new file mode 100644
index 0000000..8c48474
--- /dev/null
+++ b/utility/util.h
@@ -0,0 +1,13 @@
+#ifndef UTIL_H_
+#define UTIL_H_
+
+#include "apr_pools.h"
+
+char *lowerstr(apr_pool_t *pool, const char *input);
+
+/**
+ * Chomp new line characters off the end of the line
+ */
+void line_chomp(char *str);
+
+#endif /*UTIL_H_*/