Merge APR-Util trunk into APR.

git-svn-id: https://svn.apache.org/repos/asf/apr/apr/trunk@757704 13f79535-47bb-0310-9956-ffa450edef68

7 files changed, 3146 insertions, 0 deletions

diff --git a/util-misc/apr_date.c b/util-misc/apr_date.c
new file mode 100644
index 000000000..28086e334
--- /dev/null
+++ b/util-misc/apr_date.c
@@ -0,0 +1,637 @@
+/* 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.
+ */
+
+/*
+ * apr_date.c: date parsing utility routines
+ *     These routines are (hopefully) platform independent.
+ * 
+ * 27 Oct 1996  Roy Fielding
+ *     Extracted (with many modifications) from mod_proxy.c and
+ *     tested with over 50,000 randomly chosen valid date strings
+ *     and several hundred variations of invalid date strings.
+ * 
+ */
+
+#include "apr.h"
+#include "apr_lib.h"
+
+#define APR_WANT_STRFUNC
+#include "apr_want.h"
+
+#if APR_HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+
+#if APR_HAVE_CTYPE_H
+#include <ctype.h>
+#endif
+
+#include "apr_date.h"
+
+/*
+ * Compare a string to a mask
+ * Mask characters (arbitrary maximum is 256 characters, just in case):
+ *   @ - uppercase letter
+ *   $ - lowercase letter
+ *   & - hex digit
+ *   # - digit
+ *   ~ - digit or space
+ *   * - swallow remaining characters 
+ *  <x> - exact match for any other character
+ */
+APU_DECLARE(int) apr_date_checkmask(const char *data, const char *mask)
+{
+    int i;
+    char d;
+
+    for (i = 0; i < 256; i++) {
+        d = data[i];
+        switch (mask[i]) {
+        case '\0':
+            return (d == '\0');
+
+        case '*':
+            return 1;
+
+        case '@':
+            if (!apr_isupper(d))
+                return 0;
+            break;
+        case '$':
+            if (!apr_islower(d))
+                return 0;
+            break;
+        case '#':
+            if (!apr_isdigit(d))
+                return 0;
+            break;
+        case '&':
+            if (!apr_isxdigit(d))
+                return 0;
+            break;
+        case '~':
+            if ((d != ' ') && !apr_isdigit(d))
+                return 0;
+            break;
+        default:
+            if (mask[i] != d)
+                return 0;
+            break;
+        }
+    }
+    return 0;          /* We only get here if mask is corrupted (exceeds 256) */
+}
+
+/*
+ * Parses an HTTP date in one of three standard forms:
+ *
+ *     Sun, 06 Nov 1994 08:49:37 GMT  ; RFC 822, updated by RFC 1123
+ *     Sunday, 06-Nov-94 08:49:37 GMT ; RFC 850, obsoleted by RFC 1036
+ *     Sun Nov  6 08:49:37 1994       ; ANSI C's asctime() format
+ *
+ * and returns the apr_time_t number of microseconds since 1 Jan 1970 GMT, 
+ * or APR_DATE_BAD if this would be out of range or if the date is invalid.
+ *
+ * The restricted HTTP syntax is
+ * 
+ *     HTTP-date    = rfc1123-date | rfc850-date | asctime-date
+ *
+ *     rfc1123-date = wkday "," SP date1 SP time SP "GMT"
+ *     rfc850-date  = weekday "," SP date2 SP time SP "GMT"
+ *     asctime-date = wkday SP date3 SP time SP 4DIGIT
+ *
+ *     date1        = 2DIGIT SP month SP 4DIGIT
+ *                    ; day month year (e.g., 02 Jun 1982)
+ *     date2        = 2DIGIT "-" month "-" 2DIGIT
+ *                    ; day-month-year (e.g., 02-Jun-82)
+ *     date3        = month SP ( 2DIGIT | ( SP 1DIGIT ))
+ *                    ; month day (e.g., Jun  2)
+ *
+ *     time         = 2DIGIT ":" 2DIGIT ":" 2DIGIT
+ *                    ; 00:00:00 - 23:59:59
+ *
+ *     wkday        = "Mon" | "Tue" | "Wed"
+ *                  | "Thu" | "Fri" | "Sat" | "Sun"
+ *
+ *     weekday      = "Monday" | "Tuesday" | "Wednesday"
+ *                  | "Thursday" | "Friday" | "Saturday" | "Sunday"
+ *
+ *     month        = "Jan" | "Feb" | "Mar" | "Apr"
+ *                  | "May" | "Jun" | "Jul" | "Aug"
+ *                  | "Sep" | "Oct" | "Nov" | "Dec"
+ *
+ * However, for the sake of robustness (and Netscapeness), we ignore the
+ * weekday and anything after the time field (including the timezone).
+ *
+ * This routine is intended to be very fast; 10x faster than using sscanf.
+ *
+ * Originally from Andrew Daviel <andrew@vancouver-webpages.com>, 29 Jul 96
+ * but many changes since then.
+ *
+ */
+APU_DECLARE(apr_time_t) apr_date_parse_http(const char *date)
+{
+    apr_time_exp_t ds;
+    apr_time_t result;
+    int mint, mon;
+    const char *monstr, *timstr;
+    static const int months[12] =
+    {
+    ('J' << 16) | ('a' << 8) | 'n', ('F' << 16) | ('e' << 8) | 'b',
+    ('M' << 16) | ('a' << 8) | 'r', ('A' << 16) | ('p' << 8) | 'r',
+    ('M' << 16) | ('a' << 8) | 'y', ('J' << 16) | ('u' << 8) | 'n',
+    ('J' << 16) | ('u' << 8) | 'l', ('A' << 16) | ('u' << 8) | 'g',
+    ('S' << 16) | ('e' << 8) | 'p', ('O' << 16) | ('c' << 8) | 't',
+    ('N' << 16) | ('o' << 8) | 'v', ('D' << 16) | ('e' << 8) | 'c'};
+
+    if (!date)
+        return APR_DATE_BAD;
+
+    while (*date && apr_isspace(*date))    /* Find first non-whitespace char */
+        ++date;
+
+    if (*date == '\0') 
+        return APR_DATE_BAD;
+
+    if ((date = strchr(date, ' ')) == NULL)       /* Find space after weekday */
+        return APR_DATE_BAD;
+
+    ++date;        /* Now pointing to first char after space, which should be */
+
+    /* start of the actual date information for all 4 formats. */
+
+    if (apr_date_checkmask(date, "## @$$ #### ##:##:## *")) {
+        /* RFC 1123 format with two days */
+        ds.tm_year = ((date[7] - '0') * 10 + (date[8] - '0') - 19) * 100;
+        if (ds.tm_year < 0)
+            return APR_DATE_BAD;
+
+        ds.tm_year += ((date[9] - '0') * 10) + (date[10] - '0');
+
+        ds.tm_mday = ((date[0] - '0') * 10) + (date[1] - '0');
+
+        monstr = date + 3;
+        timstr = date + 12;
+    }
+    else if (apr_date_checkmask(date, "##-@$$-## ##:##:## *")) { 
+        /* RFC 850 format */
+        ds.tm_year = ((date[7] - '0') * 10) + (date[8] - '0');
+        if (ds.tm_year < 70)
+            ds.tm_year += 100;
+
+        ds.tm_mday = ((date[0] - '0') * 10) + (date[1] - '0');
+
+        monstr = date + 3;
+        timstr = date + 10;
+    }
+    else if (apr_date_checkmask(date, "@$$ ~# ##:##:## ####*")) {
+        /* asctime format */
+        ds.tm_year = ((date[16] - '0') * 10 + (date[17] - '0') - 19) * 100;
+        if (ds.tm_year < 0) 
+            return APR_DATE_BAD;
+
+        ds.tm_year += ((date[18] - '0') * 10) + (date[19] - '0');
+
+        if (date[4] == ' ')
+            ds.tm_mday = 0;
+        else
+            ds.tm_mday = (date[4] - '0') * 10;
+
+        ds.tm_mday += (date[5] - '0');
+
+        monstr = date;
+        timstr = date + 7;
+    }
+    else if (apr_date_checkmask(date, "# @$$ #### ##:##:## *")) {
+        /* RFC 1123 format with one day */
+        ds.tm_year = ((date[6] - '0') * 10 + (date[7] - '0') - 19) * 100;
+        if (ds.tm_year < 0)
+            return APR_DATE_BAD;
+
+        ds.tm_year += ((date[8] - '0') * 10) + (date[9] - '0');
+
+        ds.tm_mday = (date[0] - '0');
+
+        monstr = date + 2;
+        timstr = date + 11;
+    }
+    else
+        return APR_DATE_BAD;
+
+    if (ds.tm_mday <= 0 || ds.tm_mday > 31)
+        return APR_DATE_BAD;
+
+    ds.tm_hour = ((timstr[0] - '0') * 10) + (timstr[1] - '0');
+    ds.tm_min = ((timstr[3] - '0') * 10) + (timstr[4] - '0');
+    ds.tm_sec = ((timstr[6] - '0') * 10) + (timstr[7] - '0');
+
+    if ((ds.tm_hour > 23) || (ds.tm_min > 59) || (ds.tm_sec > 61)) 
+        return APR_DATE_BAD;
+
+    mint = (monstr[0] << 16) | (monstr[1] << 8) | monstr[2];
+    for (mon = 0; mon < 12; mon++)
+        if (mint == months[mon])
+            break;
+
+    if (mon == 12)
+        return APR_DATE_BAD;
+
+    if ((ds.tm_mday == 31) && (mon == 3 || mon == 5 || mon == 8 || mon == 10))
+        return APR_DATE_BAD;
+
+    /* February gets special check for leapyear */
+    if ((mon == 1) &&
+        ((ds.tm_mday > 29) || 
+        ((ds.tm_mday == 29)
+        && ((ds.tm_year & 3)
+        || (((ds.tm_year % 100) == 0)
+        && (((ds.tm_year % 400) != 100)))))))
+        return APR_DATE_BAD;
+
+    ds.tm_mon = mon;
+
+    /* ap_mplode_time uses tm_usec and tm_gmtoff fields, but they haven't 
+     * been set yet. 
+     * It should be safe to just zero out these values.
+     * tm_usec is the number of microseconds into the second.  HTTP only
+     * cares about second granularity.
+     * tm_gmtoff is the number of seconds off of GMT the time is.  By
+     * definition all times going through this function are in GMT, so this
+     * is zero. 
+     */
+    ds.tm_usec = 0;
+    ds.tm_gmtoff = 0;
+    if (apr_time_exp_get(&result, &ds) != APR_SUCCESS) 
+        return APR_DATE_BAD;
+    
+    return result;
+}
+
+/*
+ * Parses a string resembling an RFC 822 date.  This is meant to be
+ * leinent in its parsing of dates.  Hence, this will parse a wider 
+ * range of dates than apr_date_parse_http.
+ *
+ * The prominent mailer (or poster, if mailer is unknown) that has
+ * been seen in the wild is included for the unknown formats.
+ *
+ *     Sun, 06 Nov 1994 08:49:37 GMT  ; RFC 822, updated by RFC 1123
+ *     Sunday, 06-Nov-94 08:49:37 GMT ; RFC 850, obsoleted by RFC 1036
+ *     Sun Nov  6 08:49:37 1994       ; ANSI C's asctime() format
+ *     Sun, 6 Nov 1994 08:49:37 GMT   ; RFC 822, updated by RFC 1123
+ *     Sun, 06 Nov 94 08:49:37 GMT    ; RFC 822
+ *     Sun, 6 Nov 94 08:49:37 GMT     ; RFC 822
+ *     Sun, 06 Nov 94 08:49 GMT       ; Unknown [drtr@ast.cam.ac.uk] 
+ *     Sun, 6 Nov 94 08:49 GMT        ; Unknown [drtr@ast.cam.ac.uk]
+ *     Sun, 06 Nov 94 8:49:37 GMT     ; Unknown [Elm 70.85]
+ *     Sun, 6 Nov 94 8:49:37 GMT      ; Unknown [Elm 70.85] 
+ *     Mon,  7 Jan 2002 07:21:22 GMT  ; Unknown [Postfix]
+ *     Sun, 06-Nov-1994 08:49:37 GMT  ; RFC 850 with four digit years
+ *
+ */
+
+#define TIMEPARSE(ds,hr10,hr1,min10,min1,sec10,sec1)        \
+    {                                                       \
+        ds.tm_hour = ((hr10 - '0') * 10) + (hr1 - '0');     \
+        ds.tm_min = ((min10 - '0') * 10) + (min1 - '0');    \
+        ds.tm_sec = ((sec10 - '0') * 10) + (sec1 - '0');    \
+    }
+#define TIMEPARSE_STD(ds,timstr)                            \
+    {                                                       \
+        TIMEPARSE(ds, timstr[0],timstr[1],                  \
+                      timstr[3],timstr[4],                  \
+                      timstr[6],timstr[7]);                 \
+    }
+
+APU_DECLARE(apr_time_t) apr_date_parse_rfc(const char *date)
+{
+    apr_time_exp_t ds;
+    apr_time_t result;
+    int mint, mon;
+    const char *monstr, *timstr, *gmtstr;
+    static const int months[12] =
+    {
+    ('J' << 16) | ('a' << 8) | 'n', ('F' << 16) | ('e' << 8) | 'b',
+    ('M' << 16) | ('a' << 8) | 'r', ('A' << 16) | ('p' << 8) | 'r',
+    ('M' << 16) | ('a' << 8) | 'y', ('J' << 16) | ('u' << 8) | 'n',
+    ('J' << 16) | ('u' << 8) | 'l', ('A' << 16) | ('u' << 8) | 'g',
+    ('S' << 16) | ('e' << 8) | 'p', ('O' << 16) | ('c' << 8) | 't',
+    ('N' << 16) | ('o' << 8) | 'v', ('D' << 16) | ('e' << 8) | 'c' };
+
+    if (!date)
+        return APR_DATE_BAD;
+
+    /* Not all dates have text days at the beginning. */
+    if (!apr_isdigit(date[0]))
+    {
+        while (*date && apr_isspace(*date)) /* Find first non-whitespace char */
+            ++date;
+
+        if (*date == '\0') 
+            return APR_DATE_BAD;
+
+        if ((date = strchr(date, ' ')) == NULL)   /* Find space after weekday */
+            return APR_DATE_BAD;
+
+        ++date;    /* Now pointing to first char after space, which should be */    }
+
+    /* start of the actual date information for all 11 formats. */
+    if (apr_date_checkmask(date, "## @$$ #### ##:##:## *")) {   /* RFC 1123 format */
+        ds.tm_year = ((date[7] - '0') * 10 + (date[8] - '0') - 19) * 100;
+
+        if (ds.tm_year < 0)
+            return APR_DATE_BAD;
+
+        ds.tm_year += ((date[9] - '0') * 10) + (date[10] - '0');
+
+        ds.tm_mday = ((date[0] - '0') * 10) + (date[1] - '0');
+
+        monstr = date + 3;
+        timstr = date + 12;
+        gmtstr = date + 21;
+
+        TIMEPARSE_STD(ds, timstr);
+    }
+    else if (apr_date_checkmask(date, "##-@$$-## ##:##:## *")) {/* RFC 850 format  */
+        ds.tm_year = ((date[7] - '0') * 10) + (date[8] - '0');
+
+        if (ds.tm_year < 70)
+            ds.tm_year += 100;
+
+        ds.tm_mday = ((date[0] - '0') * 10) + (date[1] - '0');
+
+        monstr = date + 3;
+        timstr = date + 10;
+        gmtstr = date + 19;
+
+        TIMEPARSE_STD(ds, timstr);
+    }
+    else if (apr_date_checkmask(date, "@$$ ~# ##:##:## ####*")) {
+        /* asctime format */
+        ds.tm_year = ((date[16] - '0') * 10 + (date[17] - '0') - 19) * 100;
+        if (ds.tm_year < 0) 
+            return APR_DATE_BAD;
+
+        ds.tm_year += ((date[18] - '0') * 10) + (date[19] - '0');
+
+        if (date[4] == ' ')
+            ds.tm_mday = 0;
+        else
+            ds.tm_mday = (date[4] - '0') * 10;
+
+        ds.tm_mday += (date[5] - '0');
+
+        monstr = date;
+        timstr = date + 7;
+        gmtstr = NULL;
+
+        TIMEPARSE_STD(ds, timstr);
+    }
+    else if (apr_date_checkmask(date, "# @$$ #### ##:##:## *")) {
+        /* RFC 1123 format*/
+        ds.tm_year = ((date[6] - '0') * 10 + (date[7] - '0') - 19) * 100;
+
+        if (ds.tm_year < 0)
+            return APR_DATE_BAD;
+
+        ds.tm_year += ((date[8] - '0') * 10) + (date[9] - '0');
+        ds.tm_mday = (date[0] - '0');
+
+        monstr = date + 2;
+        timstr = date + 11;
+        gmtstr = date + 20;
+
+        TIMEPARSE_STD(ds, timstr);
+    }
+    else if (apr_date_checkmask(date, "## @$$ ## ##:##:## *")) {
+        /* This is the old RFC 1123 date format - many many years ago, people
+         * used two-digit years.  Oh, how foolish.
+         *
+         * Two-digit day, two-digit year version. */
+        ds.tm_year = ((date[7] - '0') * 10) + (date[8] - '0');
+
+        if (ds.tm_year < 70)
+            ds.tm_year += 100;
+
+        ds.tm_mday = ((date[0] - '0') * 10) + (date[1] - '0');
+
+        monstr = date + 3;
+        timstr = date + 10;
+        gmtstr = date + 19;
+
+        TIMEPARSE_STD(ds, timstr);
+    } 
+    else if (apr_date_checkmask(date, " # @$$ ## ##:##:## *")) {
+        /* This is the old RFC 1123 date format - many many years ago, people
+         * used two-digit years.  Oh, how foolish.
+         *
+         * Space + one-digit day, two-digit year version.*/
+        ds.tm_year = ((date[7] - '0') * 10) + (date[8] - '0');
+
+        if (ds.tm_year < 70)
+            ds.tm_year += 100;
+
+        ds.tm_mday = (date[1] - '0');
+
+        monstr = date + 3;
+        timstr = date + 10;
+        gmtstr = date + 19;
+
+        TIMEPARSE_STD(ds, timstr);
+    } 
+    else if (apr_date_checkmask(date, "# @$$ ## ##:##:## *")) {
+        /* This is the old RFC 1123 date format - many many years ago, people
+         * used two-digit years.  Oh, how foolish.
+         *
+         * One-digit day, two-digit year version. */
+        ds.tm_year = ((date[6] - '0') * 10) + (date[7] - '0');
+
+        if (ds.tm_year < 70)
+            ds.tm_year += 100;
+
+        ds.tm_mday = (date[0] - '0');
+
+        monstr = date + 2;
+        timstr = date + 9;
+        gmtstr = date + 18;
+
+        TIMEPARSE_STD(ds, timstr);
+    } 
+    else if (apr_date_checkmask(date, "## @$$ ## ##:## *")) {
+        /* Loser format.  This is quite bogus.  */
+        ds.tm_year = ((date[7] - '0') * 10) + (date[8] - '0');
+
+        if (ds.tm_year < 70)
+            ds.tm_year += 100;
+
+        ds.tm_mday = ((date[0] - '0') * 10) + (date[1] - '0');
+
+        monstr = date + 3;
+        timstr = date + 10;
+        gmtstr = NULL;
+
+        TIMEPARSE(ds, timstr[0],timstr[1], timstr[3],timstr[4], '0','0');
+    } 
+    else if (apr_date_checkmask(date, "# @$$ ## ##:## *")) {
+        /* Loser format.  This is quite bogus.  */
+        ds.tm_year = ((date[6] - '0') * 10) + (date[7] - '0');
+
+        if (ds.tm_year < 70)
+            ds.tm_year += 100;
+
+        ds.tm_mday = (date[0] - '0');
+
+        monstr = date + 2;
+        timstr = date + 9;
+        gmtstr = NULL;
+
+        TIMEPARSE(ds, timstr[0],timstr[1], timstr[3],timstr[4], '0','0');
+    }
+    else if (apr_date_checkmask(date, "## @$$ ## #:##:## *")) {
+        /* Loser format.  This is quite bogus.  */
+        ds.tm_year = ((date[7] - '0') * 10) + (date[8] - '0');
+
+        if (ds.tm_year < 70)
+            ds.tm_year += 100;
+
+        ds.tm_mday = ((date[0] - '0') * 10) + (date[1] - '0');
+
+        monstr = date + 3;
+        timstr = date + 9;
+        gmtstr = date + 18;
+
+        TIMEPARSE(ds, '0',timstr[1], timstr[3],timstr[4], timstr[6],timstr[7]);
+    }
+    else if (apr_date_checkmask(date, "# @$$ ## #:##:## *")) {
+         /* Loser format.  This is quite bogus.  */
+        ds.tm_year = ((date[6] - '0') * 10) + (date[7] - '0');
+
+        if (ds.tm_year < 70)
+            ds.tm_year += 100;
+
+        ds.tm_mday = (date[0] - '0');
+
+        monstr = date + 2;
+        timstr = date + 8;
+        gmtstr = date + 17;
+
+        TIMEPARSE(ds, '0',timstr[1], timstr[3],timstr[4], timstr[6],timstr[7]);
+    }
+    else if (apr_date_checkmask(date, " # @$$ #### ##:##:## *")) {   
+        /* RFC 1123 format with a space instead of a leading zero. */
+        ds.tm_year = ((date[7] - '0') * 10 + (date[8] - '0') - 19) * 100;
+
+        if (ds.tm_year < 0)
+            return APR_DATE_BAD;
+
+        ds.tm_year += ((date[9] - '0') * 10) + (date[10] - '0');
+
+        ds.tm_mday = (date[1] - '0');
+
+        monstr = date + 3;
+        timstr = date + 12;
+        gmtstr = date + 21;
+
+        TIMEPARSE_STD(ds, timstr);
+    }
+    else if (apr_date_checkmask(date, "##-@$$-#### ##:##:## *")) {
+       /* RFC 1123 with dashes instead of spaces between date/month/year
+        * This also looks like RFC 850 with four digit years.
+        */
+        ds.tm_year = ((date[7] - '0') * 10 + (date[8] - '0') - 19) * 100;
+        if (ds.tm_year < 0)
+            return APR_DATE_BAD;
+
+        ds.tm_year += ((date[9] - '0') * 10) + (date[10] - '0');
+
+        ds.tm_mday = ((date[0] - '0') * 10) + (date[1] - '0');
+
+        monstr = date + 3;
+        timstr = date + 12;
+        gmtstr = date + 21;
+
+        TIMEPARSE_STD(ds, timstr);
+    }
+    else
+        return APR_DATE_BAD;
+
+    if (ds.tm_mday <= 0 || ds.tm_mday > 31)
+        return APR_DATE_BAD;
+
+    if ((ds.tm_hour > 23) || (ds.tm_min > 59) || (ds.tm_sec > 61)) 
+        return APR_DATE_BAD;
+
+    mint = (monstr[0] << 16) | (monstr[1] << 8) | monstr[2];
+    for (mon = 0; mon < 12; mon++)
+        if (mint == months[mon])
+            break;
+
+    if (mon == 12)
+        return APR_DATE_BAD;
+
+    if ((ds.tm_mday == 31) && (mon == 3 || mon == 5 || mon == 8 || mon == 10))
+        return APR_DATE_BAD;
+
+    /* February gets special check for leapyear */
+
+    if ((mon == 1) &&
+        ((ds.tm_mday > 29)
+        || ((ds.tm_mday == 29)
+        && ((ds.tm_year & 3)
+        || (((ds.tm_year % 100) == 0)
+        && (((ds.tm_year % 400) != 100)))))))
+        return APR_DATE_BAD;
+
+    ds.tm_mon = mon;
+
+    /* tm_gmtoff is the number of seconds off of GMT the time is.
+     *
+     * We only currently support: [+-]ZZZZ where Z is the offset in
+     * hours from GMT.
+     *
+     * If there is any confusion, tm_gmtoff will remain 0.
+     */
+    ds.tm_gmtoff = 0;
+
+    /* Do we have a timezone ? */
+    if (gmtstr) {
+        int offset;
+        switch (*gmtstr) {
+        case '-':
+            offset = atoi(gmtstr+1);
+            ds.tm_gmtoff -= (offset / 100) * 60 * 60;
+            ds.tm_gmtoff -= (offset % 100) * 60;
+            break;
+        case '+':
+            offset = atoi(gmtstr+1);
+            ds.tm_gmtoff += (offset / 100) * 60 * 60;
+            ds.tm_gmtoff += (offset % 100) * 60;
+            break;
+        }
+    }
+
+    /* apr_time_exp_get uses tm_usec field, but it hasn't been set yet. 
+     * It should be safe to just zero out this value.
+     * tm_usec is the number of microseconds into the second.  HTTP only
+     * cares about second granularity.
+     */
+    ds.tm_usec = 0;
+
+    if (apr_time_exp_gmt_get(&result, &ds) != APR_SUCCESS) 
+        return APR_DATE_BAD;
+    
+    return result;
+}
diff --git a/util-misc/apr_queue.c b/util-misc/apr_queue.c
new file mode 100644
index 000000000..8636a824a
--- /dev/null
+++ b/util-misc/apr_queue.c
@@ -0,0 +1,390 @@
+/* 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.
+ */
+
+#include "apr.h"
+
+#if APR_HAVE_STDIO_H
+#include <stdio.h>
+#endif
+#if APR_HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+#if APR_HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#include "apu.h"
+#include "apr_portable.h"
+#include "apr_thread_mutex.h"
+#include "apr_thread_cond.h"
+#include "apr_errno.h"
+#include "apr_queue.h"
+
+#if APR_HAS_THREADS
+/* 
+ * define this to get debug messages
+ *
+#define QUEUE_DEBUG
+ */
+
+struct apr_queue_t {
+    void              **data;
+    unsigned int        nelts; /**< # elements */
+    unsigned int        in;    /**< next empty location */
+    unsigned int        out;   /**< next filled location */
+    unsigned int        bounds;/**< max size of queue */
+    unsigned int        full_waiters;
+    unsigned int        empty_waiters;
+    apr_thread_mutex_t *one_big_mutex;
+    apr_thread_cond_t  *not_empty;
+    apr_thread_cond_t  *not_full;
+    int                 terminated;
+};
+
+#ifdef QUEUE_DEBUG
+static void Q_DBG(char*msg, apr_queue_t *q) {
+    fprintf(stderr, "%ld\t#%d in %d out %d\t%s\n", 
+                    apr_os_thread_current(),
+                    q->nelts, q->in, q->out,
+                    msg
+                    );
+}
+#else
+#define Q_DBG(x,y) 
+#endif
+
+/**
+ * Detects when the apr_queue_t is full. This utility function is expected
+ * to be called from within critical sections, and is not threadsafe.
+ */
+#define apr_queue_full(queue) ((queue)->nelts == (queue)->bounds)
+
+/**
+ * Detects when the apr_queue_t is empty. This utility function is expected
+ * to be called from within critical sections, and is not threadsafe.
+ */
+#define apr_queue_empty(queue) ((queue)->nelts == 0)
+
+/**
+ * Callback routine that is called to destroy this
+ * apr_queue_t when its pool is destroyed.
+ */
+static apr_status_t queue_destroy(void *data) 
+{
+    apr_queue_t *queue = data;
+
+    /* Ignore errors here, we can't do anything about them anyway. */
+
+    apr_thread_cond_destroy(queue->not_empty);
+    apr_thread_cond_destroy(queue->not_full);
+    apr_thread_mutex_destroy(queue->one_big_mutex);
+
+    return APR_SUCCESS;
+}
+
+/**
+ * Initialize the apr_queue_t.
+ */
+APU_DECLARE(apr_status_t) apr_queue_create(apr_queue_t **q, 
+                                           unsigned int queue_capacity, 
+                                           apr_pool_t *a)
+{
+    apr_status_t rv;
+    apr_queue_t *queue;
+    queue = apr_palloc(a, sizeof(apr_queue_t));
+    *q = queue;
+
+    /* nested doesn't work ;( */
+    rv = apr_thread_mutex_create(&queue->one_big_mutex,
+                                 APR_THREAD_MUTEX_UNNESTED,
+                                 a);
+    if (rv != APR_SUCCESS) {
+        return rv;
+    }
+
+    rv = apr_thread_cond_create(&queue->not_empty, a);
+    if (rv != APR_SUCCESS) {
+        return rv;
+    }
+
+    rv = apr_thread_cond_create(&queue->not_full, a);
+    if (rv != APR_SUCCESS) {
+        return rv;
+    }
+
+    /* Set all the data in the queue to NULL */
+    queue->data = apr_pcalloc(a, queue_capacity * sizeof(void*));
+    queue->bounds = queue_capacity;
+    queue->nelts = 0;
+    queue->in = 0;
+    queue->out = 0;
+    queue->terminated = 0;
+    queue->full_waiters = 0;
+    queue->empty_waiters = 0;
+
+    apr_pool_cleanup_register(a, queue, queue_destroy, apr_pool_cleanup_null);
+
+    return APR_SUCCESS;
+}
+
+/**
+ * Push new data onto the queue. Blocks if the queue is full. Once
+ * the push operation has completed, it signals other threads waiting
+ * in apr_queue_pop() that they may continue consuming sockets.
+ */
+APU_DECLARE(apr_status_t) apr_queue_push(apr_queue_t *queue, void *data)
+{
+    apr_status_t rv;
+
+    if (queue->terminated) {
+        return APR_EOF; /* no more elements ever again */
+    }
+
+    rv = apr_thread_mutex_lock(queue->one_big_mutex);
+    if (rv != APR_SUCCESS) {
+        return rv;
+    }
+
+    if (apr_queue_full(queue)) {
+        if (!queue->terminated) {
+            queue->full_waiters++;
+            rv = apr_thread_cond_wait(queue->not_full, queue->one_big_mutex);
+            queue->full_waiters--;
+            if (rv != APR_SUCCESS) {
+                apr_thread_mutex_unlock(queue->one_big_mutex);
+                return rv;
+            }
+        }
+        /* If we wake up and it's still empty, then we were interrupted */
+        if (apr_queue_full(queue)) {
+            Q_DBG("queue full (intr)", queue);
+            rv = apr_thread_mutex_unlock(queue->one_big_mutex);
+            if (rv != APR_SUCCESS) {
+                return rv;
+            }
+            if (queue->terminated) {
+                return APR_EOF; /* no more elements ever again */
+            }
+            else {
+                return APR_EINTR;
+            }
+        }
+    }
+
+    queue->data[queue->in] = data;
+    queue->in = (queue->in + 1) % queue->bounds;
+    queue->nelts++;
+
+    if (queue->empty_waiters) {
+        Q_DBG("sig !empty", queue);
+        rv = apr_thread_cond_signal(queue->not_empty);
+        if (rv != APR_SUCCESS) {
+            apr_thread_mutex_unlock(queue->one_big_mutex);
+            return rv;
+        }
+    }
+
+    rv = apr_thread_mutex_unlock(queue->one_big_mutex);
+    return rv;
+}
+
+/**
+ * Push new data onto the queue. Blocks if the queue is full. Once
+ * the push operation has completed, it signals other threads waiting
+ * in apr_queue_pop() that they may continue consuming sockets.
+ */
+APU_DECLARE(apr_status_t) apr_queue_trypush(apr_queue_t *queue, void *data)
+{
+    apr_status_t rv;
+
+    if (queue->terminated) {
+        return APR_EOF; /* no more elements ever again */
+    }
+
+    rv = apr_thread_mutex_lock(queue->one_big_mutex);
+    if (rv != APR_SUCCESS) {
+        return rv;
+    }
+
+    if (apr_queue_full(queue)) {
+        rv = apr_thread_mutex_unlock(queue->one_big_mutex);
+        return APR_EAGAIN;
+    }
+    
+    queue->data[queue->in] = data;
+    queue->in = (queue->in + 1) % queue->bounds;
+    queue->nelts++;
+
+    if (queue->empty_waiters) {
+        Q_DBG("sig !empty", queue);
+        rv  = apr_thread_cond_signal(queue->not_empty);
+        if (rv != APR_SUCCESS) {
+            apr_thread_mutex_unlock(queue->one_big_mutex);
+            return rv;
+        }
+    }
+
+    rv = apr_thread_mutex_unlock(queue->one_big_mutex);
+    return rv;
+}
+
+/**
+ * not thread safe
+ */
+APU_DECLARE(unsigned int) apr_queue_size(apr_queue_t *queue) {
+    return queue->nelts;
+}
+
+/**
+ * Retrieves the next item from the queue. If there are no
+ * items available, it will block until one becomes available.
+ * Once retrieved, the item is placed into the address specified by
+ * 'data'.
+ */
+APU_DECLARE(apr_status_t) apr_queue_pop(apr_queue_t *queue, void **data)
+{
+    apr_status_t rv;
+
+    if (queue->terminated) {
+        return APR_EOF; /* no more elements ever again */
+    }
+
+    rv = apr_thread_mutex_lock(queue->one_big_mutex);
+    if (rv != APR_SUCCESS) {
+        return rv;
+    }
+
+    /* Keep waiting until we wake up and find that the queue is not empty. */
+    if (apr_queue_empty(queue)) {
+        if (!queue->terminated) {
+            queue->empty_waiters++;
+            rv = apr_thread_cond_wait(queue->not_empty, queue->one_big_mutex);
+            queue->empty_waiters--;
+            if (rv != APR_SUCCESS) {
+                apr_thread_mutex_unlock(queue->one_big_mutex);
+                return rv;
+            }
+        }
+        /* If we wake up and it's still empty, then we were interrupted */
+        if (apr_queue_empty(queue)) {
+            Q_DBG("queue empty (intr)", queue);
+            rv = apr_thread_mutex_unlock(queue->one_big_mutex);
+            if (rv != APR_SUCCESS) {
+                return rv;
+            }
+            if (queue->terminated) {
+                return APR_EOF; /* no more elements ever again */
+            }
+            else {
+                return APR_EINTR;
+            }
+        }
+    } 
+
+    *data = queue->data[queue->out];
+    queue->nelts--;
+
+    queue->out = (queue->out + 1) % queue->bounds;
+    if (queue->full_waiters) {
+        Q_DBG("signal !full", queue);
+        rv = apr_thread_cond_signal(queue->not_full);
+        if (rv != APR_SUCCESS) {
+            apr_thread_mutex_unlock(queue->one_big_mutex);
+            return rv;
+        }
+    }
+
+    rv = apr_thread_mutex_unlock(queue->one_big_mutex);
+    return rv;
+}
+
+/**
+ * Retrieves the next item from the queue. If there are no
+ * items available, return APR_EAGAIN.  Once retrieved,
+ * the item is placed into the address specified by 'data'.
+ */
+APU_DECLARE(apr_status_t) apr_queue_trypop(apr_queue_t *queue, void **data)
+{
+    apr_status_t rv;
+
+    if (queue->terminated) {
+        return APR_EOF; /* no more elements ever again */
+    }
+
+    rv = apr_thread_mutex_lock(queue->one_big_mutex);
+    if (rv != APR_SUCCESS) {
+        return rv;
+    }
+
+    if (apr_queue_empty(queue)) {
+        rv = apr_thread_mutex_unlock(queue->one_big_mutex);
+        return APR_EAGAIN;
+    } 
+
+    *data = queue->data[queue->out];
+    queue->nelts--;
+
+    queue->out = (queue->out + 1) % queue->bounds;
+    if (queue->full_waiters) {
+        Q_DBG("signal !full", queue);
+        rv = apr_thread_cond_signal(queue->not_full);
+        if (rv != APR_SUCCESS) {
+            apr_thread_mutex_unlock(queue->one_big_mutex);
+            return rv;
+        }
+    }
+
+    rv = apr_thread_mutex_unlock(queue->one_big_mutex);
+    return rv;
+}
+
+APU_DECLARE(apr_status_t) apr_queue_interrupt_all(apr_queue_t *queue)
+{
+    apr_status_t rv;
+    Q_DBG("intr all", queue);    
+    if ((rv = apr_thread_mutex_lock(queue->one_big_mutex)) != APR_SUCCESS) {
+        return rv;
+    }
+    apr_thread_cond_broadcast(queue->not_empty);
+    apr_thread_cond_broadcast(queue->not_full);
+
+    if ((rv = apr_thread_mutex_unlock(queue->one_big_mutex)) != APR_SUCCESS) {
+        return rv;
+    }
+
+    return APR_SUCCESS;
+}
+
+APU_DECLARE(apr_status_t) apr_queue_term(apr_queue_t *queue)
+{
+    apr_status_t rv;
+
+    if ((rv = apr_thread_mutex_lock(queue->one_big_mutex)) != APR_SUCCESS) {
+        return rv;
+    }
+
+    /* we must hold one_big_mutex when setting this... otherwise,
+     * we could end up setting it and waking everybody up just after a 
+     * would-be popper checks it but right before they block
+     */
+    queue->terminated = 1;
+    if ((rv = apr_thread_mutex_unlock(queue->one_big_mutex)) != APR_SUCCESS) {
+        return rv;
+    }
+    return apr_queue_interrupt_all(queue);
+}
+
+#endif /* APR_HAS_THREADS */
diff --git a/util-misc/apr_reslist.c b/util-misc/apr_reslist.c
new file mode 100644
index 000000000..0c43e0747
--- /dev/null
+++ b/util-misc/apr_reslist.c
@@ -0,0 +1,473 @@
+/* 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.
+ */
+
+#include <assert.h>
+
+#include "apu.h"
+#include "apr_reslist.h"
+#include "apr_errno.h"
+#include "apr_strings.h"
+#include "apr_thread_mutex.h"
+#include "apr_thread_cond.h"
+#include "apr_ring.h"
+
+/**
+ * A single resource element.
+ */
+struct apr_res_t {
+    apr_time_t freed;
+    void *opaque;
+    APR_RING_ENTRY(apr_res_t) link;
+};
+typedef struct apr_res_t apr_res_t;
+
+/**
+ * A ring of resources representing the list of available resources.
+ */
+APR_RING_HEAD(apr_resring_t, apr_res_t);
+typedef struct apr_resring_t apr_resring_t;
+
+struct apr_reslist_t {
+    apr_pool_t *pool; /* the pool used in constructor and destructor calls */
+    int ntotal;     /* total number of resources managed by this list */
+    int nidle;      /* number of available resources */
+    int min;  /* desired minimum number of available resources */
+    int smax; /* soft maximum on the total number of resources */
+    int hmax; /* hard maximum on the total number of resources */
+    apr_interval_time_t ttl; /* TTL when we have too many resources */
+    apr_interval_time_t timeout; /* Timeout for waiting on resource */
+    apr_reslist_constructor constructor;
+    apr_reslist_destructor destructor;
+    void *params; /* opaque data passed to constructor and destructor calls */
+    apr_resring_t avail_list;
+    apr_resring_t free_list;
+#if APR_HAS_THREADS
+    apr_thread_mutex_t *listlock;
+    apr_thread_cond_t *avail;
+#endif
+};
+
+/**
+ * Grab a resource from the front of the resource list.
+ * Assumes: that the reslist is locked.
+ */
+static apr_res_t *pop_resource(apr_reslist_t *reslist)
+{
+    apr_res_t *res;
+    res = APR_RING_FIRST(&reslist->avail_list);
+    APR_RING_REMOVE(res, link);
+    reslist->nidle--;
+    return res;
+}
+
+/**
+ * Add a resource to the beginning of the list, set the time at which
+ * it was added to the list.
+ * Assumes: that the reslist is locked.
+ */
+static void push_resource(apr_reslist_t *reslist, apr_res_t *resource)
+{
+    APR_RING_INSERT_HEAD(&reslist->avail_list, resource, apr_res_t, link);
+    resource->freed = apr_time_now();
+    reslist->nidle++;
+}
+
+/**
+ * Get an resource container from the free list or create a new one.
+ */
+static apr_res_t *get_container(apr_reslist_t *reslist)
+{
+    apr_res_t *res;
+
+    if (!APR_RING_EMPTY(&reslist->free_list, apr_res_t, link)) {
+        res = APR_RING_FIRST(&reslist->free_list);
+        APR_RING_REMOVE(res, link);
+    }
+    else
+        res = apr_pcalloc(reslist->pool, sizeof(*res));
+    return res;
+}
+
+/**
+ * Free up a resource container by placing it on the free list.
+ */
+static void free_container(apr_reslist_t *reslist, apr_res_t *container)
+{
+    APR_RING_INSERT_TAIL(&reslist->free_list, container, apr_res_t, link);
+}
+
+/**
+ * Create a new resource and return it.
+ * Assumes: that the reslist is locked.
+ */
+static apr_status_t create_resource(apr_reslist_t *reslist, apr_res_t **ret_res)
+{
+    apr_status_t rv;
+    apr_res_t *res;
+
+    res = get_container(reslist);
+
+    rv = reslist->constructor(&res->opaque, reslist->params, reslist->pool);
+
+    *ret_res = res;
+    return rv;
+}
+
+/**
+ * Destroy a single idle resource.
+ * Assumes: that the reslist is locked.
+ */
+static apr_status_t destroy_resource(apr_reslist_t *reslist, apr_res_t *res)
+{
+    return reslist->destructor(res->opaque, reslist->params, reslist->pool);
+}
+
+static apr_status_t reslist_cleanup(void *data_)
+{
+    apr_status_t rv = APR_SUCCESS;
+    apr_reslist_t *rl = data_;
+    apr_res_t *res;
+
+#if APR_HAS_THREADS
+    apr_thread_mutex_lock(rl->listlock);
+#endif
+
+    while (rl->nidle > 0) {
+        apr_status_t rv1;
+        res = pop_resource(rl);
+        rl->ntotal--;
+        rv1 = destroy_resource(rl, res);
+        if (rv1 != APR_SUCCESS) {
+            rv = rv1;  /* loses info in the unlikely event of
+                        * multiple *different* failures */
+        }
+        free_container(rl, res);
+    }
+
+    assert(rl->nidle == 0);
+    assert(rl->ntotal == 0);
+
+#if APR_HAS_THREADS
+    apr_thread_mutex_unlock(rl->listlock);
+    apr_thread_mutex_destroy(rl->listlock);
+    apr_thread_cond_destroy(rl->avail);
+#endif
+
+    return rv;
+}
+
+/**
+ * Perform routine maintenance on the resource list. This call
+ * may instantiate new resources or expire old resources.
+ */
+APU_DECLARE(apr_status_t) apr_reslist_maintain(apr_reslist_t *reslist)
+{
+    apr_time_t now;
+    apr_status_t rv;
+    apr_res_t *res;
+    int created_one = 0;
+
+#if APR_HAS_THREADS
+    apr_thread_mutex_lock(reslist->listlock);
+#endif
+
+    /* Check if we need to create more resources, and if we are allowed to. */
+    while (reslist->nidle < reslist->min && reslist->ntotal < reslist->hmax) {
+        /* Create the resource */
+        rv = create_resource(reslist, &res);
+        if (rv != APR_SUCCESS) {
+            free_container(reslist, res);
+#if APR_HAS_THREADS
+            apr_thread_mutex_unlock(reslist->listlock);
+#endif
+            return rv;
+        }
+        /* Add it to the list */
+        push_resource(reslist, res);
+        /* Update our counters */
+        reslist->ntotal++;
+        /* If someone is waiting on that guy, wake them up. */
+#if APR_HAS_THREADS
+        rv = apr_thread_cond_signal(reslist->avail);
+        if (rv != APR_SUCCESS) {
+            apr_thread_mutex_unlock(reslist->listlock);
+            return rv;
+        }
+#endif
+        created_one++;
+    }
+
+    /* We don't need to see if we're over the max if we were under it before */
+    if (created_one) {
+#if APR_HAS_THREADS
+        apr_thread_mutex_unlock(reslist->listlock);
+#endif
+        return APR_SUCCESS;
+    }
+
+    /* Check if we need to expire old resources */
+    now = apr_time_now();
+    while (reslist->nidle > reslist->smax && reslist->nidle > 0) {
+        /* Peak at the last resource in the list */
+        res = APR_RING_LAST(&reslist->avail_list);
+        /* See if the oldest entry should be expired */
+        if (now - res->freed < reslist->ttl) {
+            /* If this entry is too young, none of the others
+             * will be ready to be expired either, so we are done. */
+            break;
+        }
+        APR_RING_REMOVE(res, link);
+        reslist->nidle--;
+        reslist->ntotal--;
+        rv = destroy_resource(reslist, res);
+        free_container(reslist, res);
+        if (rv != APR_SUCCESS) {
+#if APR_HAS_THREADS
+            apr_thread_mutex_unlock(reslist->listlock);
+#endif
+            return rv;
+        }
+    }
+
+#if APR_HAS_THREADS
+    apr_thread_mutex_unlock(reslist->listlock);
+#endif
+    return APR_SUCCESS;
+}
+
+APU_DECLARE(apr_status_t) apr_reslist_create(apr_reslist_t **reslist,
+                                             int min, int smax, int hmax,
+                                             apr_interval_time_t ttl,
+                                             apr_reslist_constructor con,
+                                             apr_reslist_destructor de,
+                                             void *params,
+                                             apr_pool_t *pool)
+{
+    apr_status_t rv;
+    apr_reslist_t *rl;
+
+    /* Do some sanity checks so we don't thrash around in the
+     * maintenance routine later. */
+    if (min < 0 || min > smax || min > hmax || smax > hmax || hmax == 0 ||
+        ttl < 0) {
+        return APR_EINVAL;
+    }
+
+#if !APR_HAS_THREADS
+    /* There can be only one resource when we have no threads. */
+    if (min > 0) {
+        min = 1;
+    }
+    if (smax > 0) {
+        smax = 1;
+    }
+    hmax = 1;
+#endif
+
+    rl = apr_pcalloc(pool, sizeof(*rl));
+    rl->pool = pool;
+    rl->min = min;
+    rl->smax = smax;
+    rl->hmax = hmax;
+    rl->ttl = ttl;
+    rl->constructor = con;
+    rl->destructor = de;
+    rl->params = params;
+
+    APR_RING_INIT(&rl->avail_list, apr_res_t, link);
+    APR_RING_INIT(&rl->free_list, apr_res_t, link);
+
+#if APR_HAS_THREADS
+    rv = apr_thread_mutex_create(&rl->listlock, APR_THREAD_MUTEX_DEFAULT,
+                                 pool);
+    if (rv != APR_SUCCESS) {
+        return rv;
+    }
+    rv = apr_thread_cond_create(&rl->avail, pool);
+    if (rv != APR_SUCCESS) {
+        return rv;
+    }
+#endif
+
+    rv = apr_reslist_maintain(rl);
+    if (rv != APR_SUCCESS) {
+        /* Destroy what we've created so far.
+         */
+        reslist_cleanup(rl);
+        return rv;
+    }
+
+    apr_pool_cleanup_register(rl->pool, rl, reslist_cleanup,
+                              apr_pool_cleanup_null);
+
+    *reslist = rl;
+
+    return APR_SUCCESS;
+}
+
+APU_DECLARE(apr_status_t) apr_reslist_destroy(apr_reslist_t *reslist)
+{
+    return apr_pool_cleanup_run(reslist->pool, reslist, reslist_cleanup);
+}
+
+APU_DECLARE(apr_status_t) apr_reslist_acquire(apr_reslist_t *reslist,
+                                              void **resource)
+{
+    apr_status_t rv;
+    apr_res_t *res;
+    apr_time_t now;
+
+#if APR_HAS_THREADS
+    apr_thread_mutex_lock(reslist->listlock);
+#endif
+    /* If there are idle resources on the available list, use
+     * them right away. */
+    now = apr_time_now();
+    while (reslist->nidle > 0) {
+        /* Pop off the first resource */
+        res = pop_resource(reslist);
+        if (reslist->ttl && (now - res->freed >= reslist->ttl)) {
+            /* this res is expired - kill it */
+            reslist->ntotal--;
+            rv = destroy_resource(reslist, res);
+            free_container(reslist, res);
+            if (rv != APR_SUCCESS) {
+#if APR_HAS_THREADS
+                apr_thread_mutex_unlock(reslist->listlock);
+#endif
+                return rv;  /* FIXME: this might cause unnecessary fails */
+            }
+            continue;
+        }
+        *resource = res->opaque;
+        free_container(reslist, res);
+#if APR_HAS_THREADS
+        apr_thread_mutex_unlock(reslist->listlock);
+#endif
+        return APR_SUCCESS;
+    }
+    /* If we've hit our max, block until we're allowed to create
+     * a new one, or something becomes free. */
+    while (reslist->ntotal >= reslist->hmax && reslist->nidle <= 0) {
+#if APR_HAS_THREADS
+        if (reslist->timeout) {
+            if ((rv = apr_thread_cond_timedwait(reslist->avail, 
+                reslist->listlock, reslist->timeout)) != APR_SUCCESS) {
+                apr_thread_mutex_unlock(reslist->listlock);
+                return rv;
+            }
+        }
+        else {
+            apr_thread_cond_wait(reslist->avail, reslist->listlock);
+        }
+#else
+        return APR_EAGAIN;
+#endif
+    }
+    /* If we popped out of the loop, first try to see if there
+     * are new resources available for immediate use. */
+    if (reslist->nidle > 0) {
+        res = pop_resource(reslist);
+        *resource = res->opaque;
+        free_container(reslist, res);
+#if APR_HAS_THREADS
+        apr_thread_mutex_unlock(reslist->listlock);
+#endif
+        return APR_SUCCESS;
+    }
+    /* Otherwise the reason we dropped out of the loop
+     * was because there is a new slot available, so create
+     * a resource to fill the slot and use it. */
+    else {
+        rv = create_resource(reslist, &res);
+        if (rv == APR_SUCCESS) {
+            reslist->ntotal++;
+            *resource = res->opaque;
+        }
+        free_container(reslist, res);
+#if APR_HAS_THREADS
+        apr_thread_mutex_unlock(reslist->listlock);
+#endif
+        return rv;
+    }
+}
+
+APU_DECLARE(apr_status_t) apr_reslist_release(apr_reslist_t *reslist,
+                                              void *resource)
+{
+    apr_res_t *res;
+
+#if APR_HAS_THREADS
+    apr_thread_mutex_lock(reslist->listlock);
+#endif
+    res = get_container(reslist);
+    res->opaque = resource;
+    push_resource(reslist, res);
+#if APR_HAS_THREADS
+    apr_thread_cond_signal(reslist->avail);
+    apr_thread_mutex_unlock(reslist->listlock);
+#endif
+
+    return apr_reslist_maintain(reslist);
+}
+
+APU_DECLARE(void) apr_reslist_timeout_set(apr_reslist_t *reslist,
+                                          apr_interval_time_t timeout)
+{
+    reslist->timeout = timeout;
+}
+
+APU_DECLARE(apr_uint32_t) apr_reslist_acquired_count(apr_reslist_t *reslist)
+{
+    apr_uint32_t count;
+
+#if APR_HAS_THREADS
+    apr_thread_mutex_lock(reslist->listlock);
+#endif
+    count = reslist->ntotal - reslist->nidle;
+#if APR_HAS_THREADS
+    apr_thread_mutex_unlock(reslist->listlock);
+#endif
+
+    return count;
+}
+
+APU_DECLARE(apr_status_t) apr_reslist_invalidate(apr_reslist_t *reslist,
+                                                 void *resource)
+{
+    apr_status_t ret;
+#if APR_HAS_THREADS
+    apr_thread_mutex_lock(reslist->listlock);
+#endif
+    ret = reslist->destructor(resource, reslist->params, reslist->pool);
+    reslist->ntotal--;
+#if APR_HAS_THREADS
+    apr_thread_cond_signal(reslist->avail);
+    apr_thread_mutex_unlock(reslist->listlock);
+#endif
+    return ret;
+}
+
+APU_DECLARE(void) apr_reslist_cleanup_order_set(apr_reslist_t *rl,
+                                                apr_uint32_t mode)
+{
+    apr_pool_cleanup_kill(rl->pool, rl, reslist_cleanup);
+    if (mode == APR_RESLIST_CLEANUP_FIRST)
+        apr_pool_pre_cleanup_register(rl->pool, rl, reslist_cleanup);
+    else
+        apr_pool_cleanup_register(rl->pool, rl, reslist_cleanup,
+                                  apr_pool_cleanup_null);
+}
diff --git a/util-misc/apr_rmm.c b/util-misc/apr_rmm.c
new file mode 100644
index 000000000..ed67dc25c
--- /dev/null
+++ b/util-misc/apr_rmm.c
@@ -0,0 +1,446 @@
+/* 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.
+ */
+
+#include "apr_general.h"
+#include "apr_rmm.h"
+#include "apr_errno.h"
+#include "apr_lib.h"
+#include "apr_strings.h"
+
+/* The RMM region is made up of two doubly-linked-list of blocks; the
+ * list of used blocks, and the list of free blocks (either list may
+ * be empty).  The base pointer, rmm->base, points at the beginning of
+ * the shmem region in use.  Each block is addressable by an
+ * apr_rmm_off_t value, which represents the offset from the base
+ * pointer.  The term "address" is used here to mean such a value; an
+ * "offset from rmm->base".
+ *
+ * The RMM region contains exactly one "rmm_hdr_block_t" structure,
+ * the "header block", which is always stored at the base pointer.
+ * The firstused field in this structure is the address of the first
+ * block in the "used blocks" list; the firstfree field is the address
+ * of the first block in the "free blocks" list.
+ *
+ * Each block is prefixed by an "rmm_block_t" structure, followed by
+ * the caller-usable region represented by the block.  The next and
+ * prev fields of the structure are zero if the block is at the end or
+ * beginning of the linked-list respectively, or otherwise hold the
+ * address of the next and previous blocks in the list.  ("address 0",
+ * i.e. rmm->base is *not* a valid address for a block, since the
+ * header block is always stored at that address).
+ *
+ * At creation, the RMM region is initialized to hold a single block
+ * on the free list representing the entire available shm segment
+ * (minus header block); subsequent allocation and deallocation of
+ * blocks involves splitting blocks and coalescing adjacent blocks,
+ * and switching them between the free and used lists as
+ * appropriate. */
+
+typedef struct rmm_block_t {
+    apr_size_t size;
+    apr_rmm_off_t prev;
+    apr_rmm_off_t next;
+} rmm_block_t;
+
+/* Always at our apr_rmm_off(0):
+ */
+typedef struct rmm_hdr_block_t {
+    apr_size_t abssize;
+    apr_rmm_off_t /* rmm_block_t */ firstused;
+    apr_rmm_off_t /* rmm_block_t */ firstfree;
+} rmm_hdr_block_t;
+
+#define RMM_HDR_BLOCK_SIZE (APR_ALIGN_DEFAULT(sizeof(rmm_hdr_block_t)))
+#define RMM_BLOCK_SIZE (APR_ALIGN_DEFAULT(sizeof(rmm_block_t)))
+
+struct apr_rmm_t {
+    apr_pool_t *p;
+    rmm_hdr_block_t *base;
+    apr_size_t size;
+    apr_anylock_t lock;
+};
+
+static apr_rmm_off_t find_block_by_offset(apr_rmm_t *rmm, apr_rmm_off_t next, 
+                                          apr_rmm_off_t find, int includes)
+{
+    apr_rmm_off_t prev = 0;
+
+    while (next) {
+        struct rmm_block_t *blk = (rmm_block_t*)((char*)rmm->base + next);
+
+        if (find == next)
+            return next;
+
+        /* Overshot? */
+        if (find < next)
+            return includes ? prev : 0;
+
+        prev = next;
+        next = blk->next;
+    }
+    return includes ? prev : 0;
+}
+
+static apr_rmm_off_t find_block_of_size(apr_rmm_t *rmm, apr_size_t size)
+{
+    apr_rmm_off_t next = rmm->base->firstfree;
+    apr_rmm_off_t best = 0;
+    apr_rmm_off_t bestsize = 0;
+
+    while (next) {
+        struct rmm_block_t *blk = (rmm_block_t*)((char*)rmm->base + next);
+
+        if (blk->size == size)
+            return next;
+
+        if (blk->size >= size) {
+            /* XXX: sub optimal algorithm 
+             * We need the most thorough best-fit logic, since we can
+             * never grow our rmm, we are SOL when we hit the wall.
+             */
+            if (!bestsize || (blk->size < bestsize)) {
+                bestsize = blk->size;
+                best = next;
+            }
+        }
+
+        next = blk->next;
+    }
+
+    if (bestsize > RMM_BLOCK_SIZE + size) {
+        struct rmm_block_t *blk = (rmm_block_t*)((char*)rmm->base + best);
+        struct rmm_block_t *new = (rmm_block_t*)((char*)rmm->base + best + size);
+
+        new->size = blk->size - size;
+        new->next = blk->next;
+        new->prev = best;
+
+        blk->size = size;
+        blk->next = best + size;
+
+        if (new->next) {
+            blk = (rmm_block_t*)((char*)rmm->base + new->next);
+            blk->prev = best + size;
+        }
+    }
+
+    return best;
+}
+
+static void move_block(apr_rmm_t *rmm, apr_rmm_off_t this, int free)
+{   
+    struct rmm_block_t *blk = (rmm_block_t*)((char*)rmm->base + this);
+
+    /* close the gap */
+    if (blk->prev) {
+        struct rmm_block_t *prev = (rmm_block_t*)((char*)rmm->base + blk->prev);
+        prev->next = blk->next;
+    }
+    else {
+        if (free) {
+            rmm->base->firstused = blk->next;
+        }
+        else {
+            rmm->base->firstfree = blk->next;
+        }
+    }
+    if (blk->next) {
+        struct rmm_block_t *next = (rmm_block_t*)((char*)rmm->base + blk->next);
+        next->prev = blk->prev;
+    }
+
+    /* now find it in the other list, pushing it to the head if required */
+    if (free) {
+        blk->prev = find_block_by_offset(rmm, rmm->base->firstfree, this, 1);
+        if (!blk->prev) {
+            blk->next = rmm->base->firstfree;
+            rmm->base->firstfree = this;
+        }
+    }
+    else {
+        blk->prev = find_block_by_offset(rmm, rmm->base->firstused, this, 1);
+        if (!blk->prev) {
+            blk->next = rmm->base->firstused;
+            rmm->base->firstused = this;
+        }
+    }
+
+    /* and open it up */
+    if (blk->prev) {
+        struct rmm_block_t *prev = (rmm_block_t*)((char*)rmm->base + blk->prev);
+        if (free && (blk->prev + prev->size == this)) {
+            /* Collapse us into our predecessor */
+            prev->size += blk->size;
+            this = blk->prev;
+            blk = prev;
+        }
+        else {
+            blk->next = prev->next;
+            prev->next = this;
+        }
+    }
+
+    if (blk->next) {
+        struct rmm_block_t *next = (rmm_block_t*)((char*)rmm->base + blk->next);
+        if (free && (this + blk->size == blk->next)) {
+            /* Collapse us into our successor */
+            blk->size += next->size;
+            blk->next = next->next;
+            if (blk->next) {
+                next = (rmm_block_t*)((char*)rmm->base + blk->next);
+                next->prev = this;
+            }
+        }
+        else {
+            next->prev = this;
+        }
+    }
+}
+
+APU_DECLARE(apr_status_t) apr_rmm_init(apr_rmm_t **rmm, apr_anylock_t *lock, 
+                                       void *base, apr_size_t size,
+                                       apr_pool_t *p)
+{
+    apr_status_t rv;
+    rmm_block_t *blk;
+    apr_anylock_t nulllock;
+    
+    if (!lock) {
+        nulllock.type = apr_anylock_none;
+        nulllock.lock.pm = NULL;
+        lock = &nulllock;
+    }
+    if ((rv = APR_ANYLOCK_LOCK(lock)) != APR_SUCCESS)
+        return rv;
+
+    (*rmm) = (apr_rmm_t *)apr_pcalloc(p, sizeof(apr_rmm_t));
+    (*rmm)->p = p;
+    (*rmm)->base = base;
+    (*rmm)->size = size;
+    (*rmm)->lock = *lock;
+
+    (*rmm)->base->abssize = size;
+    (*rmm)->base->firstused = 0;
+    (*rmm)->base->firstfree = RMM_HDR_BLOCK_SIZE;
+
+    blk = (rmm_block_t *)((char*)base + (*rmm)->base->firstfree);
+
+    blk->size = size - (*rmm)->base->firstfree;
+    blk->prev = 0;
+    blk->next = 0;
+
+    return APR_ANYLOCK_UNLOCK(lock);
+}
+
+APU_DECLARE(apr_status_t) apr_rmm_destroy(apr_rmm_t *rmm)
+{
+    apr_status_t rv;
+    rmm_block_t *blk;
+
+    if ((rv = APR_ANYLOCK_LOCK(&rmm->lock)) != APR_SUCCESS) {
+        return rv;
+    }
+    /* Blast it all --- no going back :) */
+    if (rmm->base->firstused) {
+        apr_rmm_off_t this = rmm->base->firstused;
+        do {
+            blk = (rmm_block_t *)((char*)rmm->base + this);
+            this = blk->next;
+            blk->next = blk->prev = 0;
+        } while (this);
+        rmm->base->firstused = 0;
+    }
+    if (rmm->base->firstfree) {
+        apr_rmm_off_t this = rmm->base->firstfree;
+        do {
+            blk = (rmm_block_t *)((char*)rmm->base + this);
+            this = blk->next;
+            blk->next = blk->prev = 0;
+        } while (this);
+        rmm->base->firstfree = 0;
+    }
+    rmm->base->abssize = 0;
+    rmm->size = 0;
+
+    return APR_ANYLOCK_UNLOCK(&rmm->lock);
+}
+
+APU_DECLARE(apr_status_t) apr_rmm_attach(apr_rmm_t **rmm, apr_anylock_t *lock,
+                                         void *base, apr_pool_t *p)
+{
+    apr_anylock_t nulllock;
+
+    if (!lock) {
+        nulllock.type = apr_anylock_none;
+        nulllock.lock.pm = NULL;
+        lock = &nulllock;
+    }
+
+    /* sanity would be good here */
+    (*rmm) = (apr_rmm_t *)apr_pcalloc(p, sizeof(apr_rmm_t));
+    (*rmm)->p = p;
+    (*rmm)->base = base;
+    (*rmm)->size = (*rmm)->base->abssize;
+    (*rmm)->lock = *lock;
+    return APR_SUCCESS;
+}
+
+APU_DECLARE(apr_status_t) apr_rmm_detach(apr_rmm_t *rmm) 
+{
+    /* A noop until we introduce locked/refcounts */
+    return APR_SUCCESS;
+}
+
+APU_DECLARE(apr_rmm_off_t) apr_rmm_malloc(apr_rmm_t *rmm, apr_size_t reqsize)
+{
+    apr_rmm_off_t this;
+    
+    reqsize = APR_ALIGN_DEFAULT(reqsize) + RMM_BLOCK_SIZE;
+
+    APR_ANYLOCK_LOCK(&rmm->lock);
+
+    this = find_block_of_size(rmm, reqsize);
+
+    if (this) {
+        move_block(rmm, this, 0);
+        this += RMM_BLOCK_SIZE;
+    }
+
+    APR_ANYLOCK_UNLOCK(&rmm->lock);
+    return this;
+}
+
+APU_DECLARE(apr_rmm_off_t) apr_rmm_calloc(apr_rmm_t *rmm, apr_size_t reqsize)
+{
+    apr_rmm_off_t this;
+        
+    reqsize = APR_ALIGN_DEFAULT(reqsize) + RMM_BLOCK_SIZE;
+
+    APR_ANYLOCK_LOCK(&rmm->lock);
+
+    this = find_block_of_size(rmm, reqsize);
+
+    if (this) {
+        move_block(rmm, this, 0);
+        this += RMM_BLOCK_SIZE;
+        memset((char*)rmm->base + this, 0, reqsize - RMM_BLOCK_SIZE);
+    }
+
+    APR_ANYLOCK_UNLOCK(&rmm->lock);
+    return this;
+}
+
+APU_DECLARE(apr_rmm_off_t) apr_rmm_realloc(apr_rmm_t *rmm, void *entity,
+                                           apr_size_t reqsize)
+{
+    apr_rmm_off_t this;
+    apr_rmm_off_t old;
+    struct rmm_block_t *blk;
+    apr_size_t oldsize;
+
+    if (!entity) {
+        return apr_rmm_malloc(rmm, reqsize);
+    }
+
+    reqsize = APR_ALIGN_DEFAULT(reqsize);
+    old = apr_rmm_offset_get(rmm, entity);
+
+    if ((this = apr_rmm_malloc(rmm, reqsize)) == 0) {
+        return 0;
+    }
+
+    blk = (rmm_block_t*)((char*)rmm->base + old - RMM_BLOCK_SIZE);
+    oldsize = blk->size;
+
+    memcpy(apr_rmm_addr_get(rmm, this),
+           apr_rmm_addr_get(rmm, old), oldsize < reqsize ? oldsize : reqsize);
+    apr_rmm_free(rmm, old);
+
+    return this;
+}
+
+APU_DECLARE(apr_status_t) apr_rmm_free(apr_rmm_t *rmm, apr_rmm_off_t this)
+{
+    apr_status_t rv;
+    struct rmm_block_t *blk;
+
+    /* A little sanity check is always healthy, especially here.
+     * If we really cared, we could make this compile-time
+     */
+    if (this < RMM_HDR_BLOCK_SIZE + RMM_BLOCK_SIZE) {
+        return APR_EINVAL;
+    }
+
+    this -= RMM_BLOCK_SIZE;
+
+    blk = (rmm_block_t*)((char*)rmm->base + this);
+
+    if ((rv = APR_ANYLOCK_LOCK(&rmm->lock)) != APR_SUCCESS) {
+        return rv;
+    }
+    if (blk->prev) {
+        struct rmm_block_t *prev = (rmm_block_t*)((char*)rmm->base + blk->prev);
+        if (prev->next != this) {
+            APR_ANYLOCK_UNLOCK(&rmm->lock);
+            return APR_EINVAL;
+        }
+    }
+    else {
+        if (rmm->base->firstused != this) {
+            APR_ANYLOCK_UNLOCK(&rmm->lock);
+            return APR_EINVAL;
+        }
+    }
+
+    if (blk->next) {
+        struct rmm_block_t *next = (rmm_block_t*)((char*)rmm->base + blk->next);
+        if (next->prev != this) {
+            APR_ANYLOCK_UNLOCK(&rmm->lock);
+            return APR_EINVAL;
+        }
+    }
+
+    /* Ok, it remained [apparently] sane, so unlink it
+     */
+    move_block(rmm, this, 1);
+    
+    return APR_ANYLOCK_UNLOCK(&rmm->lock);
+}
+
+APU_DECLARE(void *) apr_rmm_addr_get(apr_rmm_t *rmm, apr_rmm_off_t entity) 
+{
+    /* debug-sanity checking here would be good
+     */
+    return (void*)((char*)rmm->base + entity);
+}
+
+APU_DECLARE(apr_rmm_off_t) apr_rmm_offset_get(apr_rmm_t *rmm, void* entity)
+{
+    /* debug, or always, sanity checking here would be good
+     * since the primitive is apr_rmm_off_t, I don't mind penalizing
+     * inverse conversions for safety, unless someone can prove that
+     * there is no choice in some cases.
+     */
+    return ((char*)entity - (char*)rmm->base);
+}
+
+APU_DECLARE(apr_size_t) apr_rmm_overhead_get(int n) 
+{
+    /* overhead per block is at most APR_ALIGN_DEFAULT(1) wasted bytes
+     * for alignment overhead, plus the size of the rmm_block_t
+     * structure. */
+    return RMM_HDR_BLOCK_SIZE + n * (RMM_BLOCK_SIZE + APR_ALIGN_DEFAULT(1));
+}
diff --git a/util-misc/apr_thread_pool.c b/util-misc/apr_thread_pool.c
new file mode 100644
index 000000000..693518d10
--- /dev/null
+++ b/util-misc/apr_thread_pool.c
@@ -0,0 +1,964 @@
+/*
+ * 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.
+ */
+
+#include <assert.h>
+#include "apr_thread_pool.h"
+#include "apr_ring.h"
+#include "apr_thread_cond.h"
+#include "apr_portable.h"
+
+#if APR_HAS_THREADS
+
+#define TASK_PRIORITY_SEGS 4
+#define TASK_PRIORITY_SEG(x) (((x)->dispatch.priority & 0xFF) / 64)
+
+typedef struct apr_thread_pool_task
+{
+    APR_RING_ENTRY(apr_thread_pool_task) link;
+    apr_thread_start_t func;
+    void *param;
+    void *owner;
+    union
+    {
+        apr_byte_t priority;
+        apr_time_t time;
+    } dispatch;
+} apr_thread_pool_task_t;
+
+APR_RING_HEAD(apr_thread_pool_tasks, apr_thread_pool_task);
+
+struct apr_thread_list_elt
+{
+    APR_RING_ENTRY(apr_thread_list_elt) link;
+    apr_thread_t *thd;
+    volatile void *current_owner;
+    volatile enum { TH_RUN, TH_STOP, TH_PROBATION } state;
+};
+
+APR_RING_HEAD(apr_thread_list, apr_thread_list_elt);
+
+struct apr_thread_pool
+{
+    apr_pool_t *pool;
+    volatile apr_size_t thd_max;
+    volatile apr_size_t idle_max;
+    volatile apr_interval_time_t idle_wait;
+    volatile apr_size_t thd_cnt;
+    volatile apr_size_t idle_cnt;
+    volatile apr_size_t task_cnt;
+    volatile apr_size_t scheduled_task_cnt;
+    volatile apr_size_t threshold;
+    volatile apr_size_t tasks_run;
+    volatile apr_size_t tasks_high;
+    volatile apr_size_t thd_high;
+    volatile apr_size_t thd_timed_out;
+    struct apr_thread_pool_tasks *tasks;
+    struct apr_thread_pool_tasks *scheduled_tasks;
+    struct apr_thread_list *busy_thds;
+    struct apr_thread_list *idle_thds;
+    apr_thread_mutex_t *lock;
+    apr_thread_mutex_t *cond_lock;
+    apr_thread_cond_t *cond;
+    volatile int terminated;
+    struct apr_thread_pool_tasks *recycled_tasks;
+    struct apr_thread_list *recycled_thds;
+    apr_thread_pool_task_t *task_idx[TASK_PRIORITY_SEGS];
+};
+
+static apr_status_t thread_pool_construct(apr_thread_pool_t * me,
+                                          apr_size_t init_threads,
+                                          apr_size_t max_threads)
+{
+    apr_status_t rv;
+    int i;
+
+    me->thd_max = max_threads;
+    me->idle_max = init_threads;
+    me->threshold = init_threads / 2;
+    rv = apr_thread_mutex_create(&me->lock, APR_THREAD_MUTEX_NESTED,
+                                 me->pool);
+    if (APR_SUCCESS != rv) {
+        return rv;
+    }
+    rv = apr_thread_mutex_create(&me->cond_lock, APR_THREAD_MUTEX_UNNESTED,
+                                 me->pool);
+    if (APR_SUCCESS != rv) {
+        apr_thread_mutex_destroy(me->lock);
+        return rv;
+    }
+    rv = apr_thread_cond_create(&me->cond, me->pool);
+    if (APR_SUCCESS != rv) {
+        apr_thread_mutex_destroy(me->lock);
+        apr_thread_mutex_destroy(me->cond_lock);
+        return rv;
+    }
+    me->tasks = apr_palloc(me->pool, sizeof(*me->tasks));
+    if (!me->tasks) {
+        goto CATCH_ENOMEM;
+    }
+    APR_RING_INIT(me->tasks, apr_thread_pool_task, link);
+    me->scheduled_tasks = apr_palloc(me->pool, sizeof(*me->scheduled_tasks));
+    if (!me->scheduled_tasks) {
+        goto CATCH_ENOMEM;
+    }
+    APR_RING_INIT(me->scheduled_tasks, apr_thread_pool_task, link);
+    me->recycled_tasks = apr_palloc(me->pool, sizeof(*me->recycled_tasks));
+    if (!me->recycled_tasks) {
+        goto CATCH_ENOMEM;
+    }
+    APR_RING_INIT(me->recycled_tasks, apr_thread_pool_task, link);
+    me->busy_thds = apr_palloc(me->pool, sizeof(*me->busy_thds));
+    if (!me->busy_thds) {
+        goto CATCH_ENOMEM;
+    }
+    APR_RING_INIT(me->busy_thds, apr_thread_list_elt, link);
+    me->idle_thds = apr_palloc(me->pool, sizeof(*me->idle_thds));
+    if (!me->idle_thds) {
+        goto CATCH_ENOMEM;
+    }
+    APR_RING_INIT(me->idle_thds, apr_thread_list_elt, link);
+    me->recycled_thds = apr_palloc(me->pool, sizeof(*me->recycled_thds));
+    if (!me->recycled_thds) {
+        goto CATCH_ENOMEM;
+    }
+    APR_RING_INIT(me->recycled_thds, apr_thread_list_elt, link);
+    me->thd_cnt = me->idle_cnt = me->task_cnt = me->scheduled_task_cnt = 0;
+    me->tasks_run = me->tasks_high = me->thd_high = me->thd_timed_out = 0;
+    me->idle_wait = 0;
+    me->terminated = 0;
+    for (i = 0; i < TASK_PRIORITY_SEGS; i++) {
+        me->task_idx[i] = NULL;
+    }
+    goto FINAL_EXIT;
+  CATCH_ENOMEM:
+    rv = APR_ENOMEM;
+    apr_thread_mutex_destroy(me->lock);
+    apr_thread_mutex_destroy(me->cond_lock);
+    apr_thread_cond_destroy(me->cond);
+  FINAL_EXIT:
+    return rv;
+}
+
+/*
+ * NOTE: This function is not thread safe by itself. Caller should hold the lock
+ */
+static apr_thread_pool_task_t *pop_task(apr_thread_pool_t * me)
+{
+    apr_thread_pool_task_t *task = NULL;
+    int seg;
+
+    /* check for scheduled tasks */
+    if (me->scheduled_task_cnt > 0) {
+        task = APR_RING_FIRST(me->scheduled_tasks);
+        assert(task != NULL);
+        assert(task !=
+               APR_RING_SENTINEL(me->scheduled_tasks, apr_thread_pool_task,
+                                 link));
+        /* if it's time */
+        if (task->dispatch.time <= apr_time_now()) {
+            --me->scheduled_task_cnt;
+            APR_RING_REMOVE(task, link);
+            return task;
+        }
+    }
+    /* check for normal tasks if we're not returning a scheduled task */
+    if (me->task_cnt == 0) {
+        return NULL;
+    }
+
+    task = APR_RING_FIRST(me->tasks);
+    assert(task != NULL);
+    assert(task != APR_RING_SENTINEL(me->tasks, apr_thread_pool_task, link));
+    --me->task_cnt;
+    seg = TASK_PRIORITY_SEG(task);
+    if (task == me->task_idx[seg]) {
+        me->task_idx[seg] = APR_RING_NEXT(task, link);
+        if (me->task_idx[seg] == APR_RING_SENTINEL(me->tasks,
+                                                   apr_thread_pool_task, link)
+            || TASK_PRIORITY_SEG(me->task_idx[seg]) != seg) {
+            me->task_idx[seg] = NULL;
+        }
+    }
+    APR_RING_REMOVE(task, link);
+    return task;
+}
+
+static apr_interval_time_t waiting_time(apr_thread_pool_t * me)
+{
+    apr_thread_pool_task_t *task = NULL;
+
+    task = APR_RING_FIRST(me->scheduled_tasks);
+    assert(task != NULL);
+    assert(task !=
+           APR_RING_SENTINEL(me->scheduled_tasks, apr_thread_pool_task,
+                             link));
+    return task->dispatch.time - apr_time_now();
+}
+
+/*
+ * NOTE: This function is not thread safe by itself. Caller should hold the lock
+ */
+static struct apr_thread_list_elt *elt_new(apr_thread_pool_t * me,
+                                           apr_thread_t * t)
+{
+    struct apr_thread_list_elt *elt;
+
+    if (APR_RING_EMPTY(me->recycled_thds, apr_thread_list_elt, link)) {
+        elt = apr_pcalloc(me->pool, sizeof(*elt));
+        if (NULL == elt) {
+            return NULL;
+        }
+    }
+    else {
+        elt = APR_RING_FIRST(me->recycled_thds);
+        APR_RING_REMOVE(elt, link);
+    }
+
+    APR_RING_ELEM_INIT(elt, link);
+    elt->thd = t;
+    elt->current_owner = NULL;
+    elt->state = TH_RUN;
+    return elt;
+}
+
+/*
+ * The worker thread function. Take a task from the queue and perform it if
+ * there is any. Otherwise, put itself into the idle thread list and waiting
+ * for signal to wake up.
+ * The thread terminate directly by detach and exit when it is asked to stop
+ * after finishing a task. Otherwise, the thread should be in idle thread list
+ * and should be joined.
+ */
+static void *APR_THREAD_FUNC thread_pool_func(apr_thread_t * t, void *param)
+{
+    apr_status_t rv = APR_SUCCESS;
+    apr_thread_pool_t *me = param;
+    apr_thread_pool_task_t *task = NULL;
+    apr_interval_time_t wait;
+    struct apr_thread_list_elt *elt;
+
+    apr_thread_mutex_lock(me->lock);
+    elt = elt_new(me, t);
+    if (!elt) {
+        apr_thread_mutex_unlock(me->lock);
+        apr_thread_exit(t, APR_ENOMEM);
+    }
+
+    while (!me->terminated && elt->state != TH_STOP) {
+        /* Test if not new element, it is awakened from idle */
+        if (APR_RING_NEXT(elt, link) != elt) {
+            --me->idle_cnt;
+            APR_RING_REMOVE(elt, link);
+        }
+
+        APR_RING_INSERT_TAIL(me->busy_thds, elt, apr_thread_list_elt, link);
+        task = pop_task(me);
+        while (NULL != task && !me->terminated) {
+            ++me->tasks_run;
+            elt->current_owner = task->owner;
+            apr_thread_mutex_unlock(me->lock);
+            apr_thread_data_set(task, "apr_thread_pool_task", NULL, t);
+            task->func(t, task->param);
+            apr_thread_mutex_lock(me->lock);
+            APR_RING_INSERT_TAIL(me->recycled_tasks, task,
+                                 apr_thread_pool_task, link);
+            elt->current_owner = NULL;
+            if (TH_STOP == elt->state) {
+                break;
+            }
+            task = pop_task(me);
+        }
+        assert(NULL == elt->current_owner);
+        if (TH_STOP != elt->state)
+            APR_RING_REMOVE(elt, link);
+
+        /* Test if a busy thread been asked to stop, which is not joinable */
+        if ((me->idle_cnt >= me->idle_max
+             && !(me->scheduled_task_cnt && 0 >= me->idle_max)
+             && !me->idle_wait)
+            || me->terminated || elt->state != TH_RUN) {
+            --me->thd_cnt;
+            if ((TH_PROBATION == elt->state) && me->idle_wait)
+                ++me->thd_timed_out;
+            APR_RING_INSERT_TAIL(me->recycled_thds, elt,
+                                 apr_thread_list_elt, link);
+            apr_thread_mutex_unlock(me->lock);
+            apr_thread_detach(t);
+            apr_thread_exit(t, APR_SUCCESS);
+            return NULL;        /* should not be here, safe net */
+        }
+
+        /* busy thread become idle */
+        ++me->idle_cnt;
+        APR_RING_INSERT_TAIL(me->idle_thds, elt, apr_thread_list_elt, link);
+
+        /* 
+         * If there is a scheduled task, always scheduled to perform that task.
+         * Since there is no guarantee that current idle threads are scheduled
+         * for next scheduled task.
+         */
+        if (me->scheduled_task_cnt)
+            wait = waiting_time(me);
+        else if (me->idle_cnt > me->idle_max) {
+            wait = me->idle_wait;
+            elt->state = TH_PROBATION;
+        }
+        else
+            wait = -1;
+
+        apr_thread_mutex_unlock(me->lock);
+        apr_thread_mutex_lock(me->cond_lock);
+        if (wait >= 0) {
+            rv = apr_thread_cond_timedwait(me->cond, me->cond_lock, wait);
+        }
+        else {
+            rv = apr_thread_cond_wait(me->cond, me->cond_lock);
+        }
+        apr_thread_mutex_unlock(me->cond_lock);
+        apr_thread_mutex_lock(me->lock);
+    }
+
+    /* idle thread been asked to stop, will be joined */
+    --me->thd_cnt;
+    apr_thread_mutex_unlock(me->lock);
+    apr_thread_exit(t, APR_SUCCESS);
+    return NULL;                /* should not be here, safe net */
+}
+
+static apr_status_t thread_pool_cleanup(void *me)
+{
+    apr_thread_pool_t *_self = me;
+
+    _self->terminated = 1;
+    apr_thread_pool_idle_max_set(_self, 0);
+    while (_self->thd_cnt) {
+        apr_sleep(20 * 1000);   /* spin lock with 20 ms */
+    }
+    apr_thread_mutex_destroy(_self->lock);
+    apr_thread_mutex_destroy(_self->cond_lock);
+    apr_thread_cond_destroy(_self->cond);
+    return APR_SUCCESS;
+}
+
+APU_DECLARE(apr_status_t) apr_thread_pool_create(apr_thread_pool_t ** me,
+                                                 apr_size_t init_threads,
+                                                 apr_size_t max_threads,
+                                                 apr_pool_t * pool)
+{
+    apr_thread_t *t;
+    apr_status_t rv = APR_SUCCESS;
+    apr_thread_pool_t *tp;
+
+    *me = NULL;
+    tp = apr_pcalloc(pool, sizeof(apr_thread_pool_t));
+
+    tp->pool = pool;
+
+    rv = thread_pool_construct(tp, init_threads, max_threads);
+    if (APR_SUCCESS != rv) {
+        return rv;
+    }
+    apr_pool_cleanup_register(pool, tp, thread_pool_cleanup,
+                              apr_pool_cleanup_null);
+
+    while (init_threads) {
+        rv = apr_thread_create(&t, NULL, thread_pool_func, tp, tp->pool);
+        if (APR_SUCCESS != rv) {
+            break;
+        }
+        tp->thd_cnt++;
+        if (tp->thd_cnt > tp->thd_high) {
+            tp->thd_high = tp->thd_cnt;
+        }
+        --init_threads;
+    }
+
+    if (rv == APR_SUCCESS) {
+        *me = tp;
+    }
+
+    return rv;
+}
+
+APU_DECLARE(apr_status_t) apr_thread_pool_destroy(apr_thread_pool_t * me)
+{
+    return apr_pool_cleanup_run(me->pool, me, thread_pool_cleanup);
+}
+
+/*
+ * NOTE: This function is not thread safe by itself. Caller should hold the lock
+ */
+static apr_thread_pool_task_t *task_new(apr_thread_pool_t * me,
+                                        apr_thread_start_t func,
+                                        void *param, apr_byte_t priority,
+                                        void *owner, apr_time_t time)
+{
+    apr_thread_pool_task_t *t;
+
+    if (APR_RING_EMPTY(me->recycled_tasks, apr_thread_pool_task, link)) {
+        t = apr_pcalloc(me->pool, sizeof(*t));
+        if (NULL == t) {
+            return NULL;
+        }
+    }
+    else {
+        t = APR_RING_FIRST(me->recycled_tasks);
+        APR_RING_REMOVE(t, link);
+    }
+
+    APR_RING_ELEM_INIT(t, link);
+    t->func = func;
+    t->param = param;
+    t->owner = owner;
+    if (time > 0) {
+        t->dispatch.time = apr_time_now() + time;
+    }
+    else {
+        t->dispatch.priority = priority;
+    }
+    return t;
+}
+
+/*
+ * Test it the task is the only one within the priority segment. 
+ * If it is not, return the first element with same or lower priority. 
+ * Otherwise, add the task into the queue and return NULL.
+ *
+ * NOTE: This function is not thread safe by itself. Caller should hold the lock
+ */
+static apr_thread_pool_task_t *add_if_empty(apr_thread_pool_t * me,
+                                            apr_thread_pool_task_t * const t)
+{
+    int seg;
+    int next;
+    apr_thread_pool_task_t *t_next;
+
+    seg = TASK_PRIORITY_SEG(t);
+    if (me->task_idx[seg]) {
+        assert(APR_RING_SENTINEL(me->tasks, apr_thread_pool_task, link) !=
+               me->task_idx[seg]);
+        t_next = me->task_idx[seg];
+        while (t_next->dispatch.priority > t->dispatch.priority) {
+            t_next = APR_RING_NEXT(t_next, link);
+            if (APR_RING_SENTINEL(me->tasks, apr_thread_pool_task, link) ==
+                t_next) {
+                return t_next;
+            }
+        }
+        return t_next;
+    }
+
+    for (next = seg - 1; next >= 0; next--) {
+        if (me->task_idx[next]) {
+            APR_RING_INSERT_BEFORE(me->task_idx[next], t, link);
+            break;
+        }
+    }
+    if (0 > next) {
+        APR_RING_INSERT_TAIL(me->tasks, t, apr_thread_pool_task, link);
+    }
+    me->task_idx[seg] = t;
+    return NULL;
+}
+
+/*
+*   schedule a task to run in "time" microseconds. Find the spot in the ring where
+*   the time fits. Adjust the short_time so the thread wakes up when the time is reached.
+*/
+static apr_status_t schedule_task(apr_thread_pool_t *me,
+                                  apr_thread_start_t func, void *param,
+                                  void *owner, apr_interval_time_t time)
+{
+    apr_thread_pool_task_t *t;
+    apr_thread_pool_task_t *t_loc;
+    apr_thread_t *thd;
+    apr_status_t rv = APR_SUCCESS;
+    apr_thread_mutex_lock(me->lock);
+
+    t = task_new(me, func, param, 0, owner, time);
+    if (NULL == t) {
+        apr_thread_mutex_unlock(me->lock);
+        return APR_ENOMEM;
+    }
+    t_loc = APR_RING_FIRST(me->scheduled_tasks);
+    while (NULL != t_loc) {
+        /* if the time is less than the entry insert ahead of it */
+        if (t->dispatch.time < t_loc->dispatch.time) {
+            ++me->scheduled_task_cnt;
+            APR_RING_INSERT_BEFORE(t_loc, t, link);
+            break;
+        }
+        else {
+            t_loc = APR_RING_NEXT(t_loc, link);
+            if (t_loc ==
+                APR_RING_SENTINEL(me->scheduled_tasks, apr_thread_pool_task,
+                                  link)) {
+                ++me->scheduled_task_cnt;
+                APR_RING_INSERT_TAIL(me->scheduled_tasks, t,
+                                     apr_thread_pool_task, link);
+                break;
+            }
+        }
+    }
+    /* there should be at least one thread for scheduled tasks */
+    if (0 == me->thd_cnt) {
+        rv = apr_thread_create(&thd, NULL, thread_pool_func, me, me->pool);
+        if (APR_SUCCESS == rv) {
+            ++me->thd_cnt;
+            if (me->thd_cnt > me->thd_high)
+                me->thd_high = me->thd_cnt;
+        }
+    }
+    apr_thread_mutex_unlock(me->lock);
+    apr_thread_mutex_lock(me->cond_lock);
+    apr_thread_cond_signal(me->cond);
+    apr_thread_mutex_unlock(me->cond_lock);
+    return rv;
+}
+
+static apr_status_t add_task(apr_thread_pool_t *me, apr_thread_start_t func,
+                             void *param, apr_byte_t priority, int push,
+                             void *owner)
+{
+    apr_thread_pool_task_t *t;
+    apr_thread_pool_task_t *t_loc;
+    apr_thread_t *thd;
+    apr_status_t rv = APR_SUCCESS;
+
+    apr_thread_mutex_lock(me->lock);
+
+    t = task_new(me, func, param, priority, owner, 0);
+    if (NULL == t) {
+        apr_thread_mutex_unlock(me->lock);
+        return APR_ENOMEM;
+    }
+
+    t_loc = add_if_empty(me, t);
+    if (NULL == t_loc) {
+        goto FINAL_EXIT;
+    }
+
+    if (push) {
+        while (APR_RING_SENTINEL(me->tasks, apr_thread_pool_task, link) !=
+               t_loc && t_loc->dispatch.priority >= t->dispatch.priority) {
+            t_loc = APR_RING_NEXT(t_loc, link);
+        }
+    }
+    APR_RING_INSERT_BEFORE(t_loc, t, link);
+    if (!push) {
+        if (t_loc == me->task_idx[TASK_PRIORITY_SEG(t)]) {
+            me->task_idx[TASK_PRIORITY_SEG(t)] = t;
+        }
+    }
+
+  FINAL_EXIT:
+    me->task_cnt++;
+    if (me->task_cnt > me->tasks_high)
+        me->tasks_high = me->task_cnt;
+    if (0 == me->thd_cnt || (0 == me->idle_cnt && me->thd_cnt < me->thd_max &&
+                             me->task_cnt > me->threshold)) {
+        rv = apr_thread_create(&thd, NULL, thread_pool_func, me, me->pool);
+        if (APR_SUCCESS == rv) {
+            ++me->thd_cnt;
+            if (me->thd_cnt > me->thd_high)
+                me->thd_high = me->thd_cnt;
+        }
+    }
+    apr_thread_mutex_unlock(me->lock);
+
+    apr_thread_mutex_lock(me->cond_lock);
+    apr_thread_cond_signal(me->cond);
+    apr_thread_mutex_unlock(me->cond_lock);
+
+    return rv;
+}
+
+APU_DECLARE(apr_status_t) apr_thread_pool_push(apr_thread_pool_t *me,
+                                               apr_thread_start_t func,
+                                               void *param,
+                                               apr_byte_t priority,
+                                               void *owner)
+{
+    return add_task(me, func, param, priority, 1, owner);
+}
+
+APU_DECLARE(apr_status_t) apr_thread_pool_schedule(apr_thread_pool_t *me,
+                                                   apr_thread_start_t func,
+                                                   void *param,
+                                                   apr_interval_time_t time,
+                                                   void *owner)
+{
+    return schedule_task(me, func, param, owner, time);
+}
+
+APU_DECLARE(apr_status_t) apr_thread_pool_top(apr_thread_pool_t *me,
+                                              apr_thread_start_t func,
+                                              void *param,
+                                              apr_byte_t priority,
+                                              void *owner)
+{
+    return add_task(me, func, param, priority, 0, owner);
+}
+
+static apr_status_t remove_scheduled_tasks(apr_thread_pool_t *me,
+                                           void *owner)
+{
+    apr_thread_pool_task_t *t_loc;
+    apr_thread_pool_task_t *next;
+
+    t_loc = APR_RING_FIRST(me->scheduled_tasks);
+    while (t_loc !=
+           APR_RING_SENTINEL(me->scheduled_tasks, apr_thread_pool_task,
+                             link)) {
+        next = APR_RING_NEXT(t_loc, link);
+        /* if this is the owner remove it */
+        if (t_loc->owner == owner) {
+            --me->scheduled_task_cnt;
+            APR_RING_REMOVE(t_loc, link);
+        }
+        t_loc = next;
+    }
+    return APR_SUCCESS;
+}
+
+static apr_status_t remove_tasks(apr_thread_pool_t *me, void *owner)
+{
+    apr_thread_pool_task_t *t_loc;
+    apr_thread_pool_task_t *next;
+    int seg;
+
+    t_loc = APR_RING_FIRST(me->tasks);
+    while (t_loc != APR_RING_SENTINEL(me->tasks, apr_thread_pool_task, link)) {
+        next = APR_RING_NEXT(t_loc, link);
+        if (t_loc->owner == owner) {
+            --me->task_cnt;
+            seg = TASK_PRIORITY_SEG(t_loc);
+            if (t_loc == me->task_idx[seg]) {
+                me->task_idx[seg] = APR_RING_NEXT(t_loc, link);
+                if (me->task_idx[seg] == APR_RING_SENTINEL(me->tasks,
+                                                           apr_thread_pool_task,
+                                                           link)
+                    || TASK_PRIORITY_SEG(me->task_idx[seg]) != seg) {
+                    me->task_idx[seg] = NULL;
+                }
+            }
+            APR_RING_REMOVE(t_loc, link);
+        }
+        t_loc = next;
+    }
+    return APR_SUCCESS;
+}
+
+static void wait_on_busy_threads(apr_thread_pool_t *me, void *owner)
+{
+#ifndef NDEBUG
+    apr_os_thread_t *os_thread;
+#endif
+    struct apr_thread_list_elt *elt;
+    apr_thread_mutex_lock(me->lock);
+    elt = APR_RING_FIRST(me->busy_thds);
+    while (elt != APR_RING_SENTINEL(me->busy_thds, apr_thread_list_elt, link)) {
+        if (elt->current_owner != owner) {
+            elt = APR_RING_NEXT(elt, link);
+            continue;
+        }
+#ifndef NDEBUG
+        /* make sure the thread is not the one calling tasks_cancel */
+        apr_os_thread_get(&os_thread, elt->thd);
+#ifdef WIN32
+        /* hack for apr win32 bug */
+        assert(!apr_os_thread_equal(apr_os_thread_current(), os_thread));
+#else
+        assert(!apr_os_thread_equal(apr_os_thread_current(), *os_thread));
+#endif
+#endif
+        while (elt->current_owner == owner) {
+            apr_thread_mutex_unlock(me->lock);
+            apr_sleep(200 * 1000);
+            apr_thread_mutex_lock(me->lock);
+        }
+        elt = APR_RING_FIRST(me->busy_thds);
+    }
+    apr_thread_mutex_unlock(me->lock);
+    return;
+}
+
+APU_DECLARE(apr_status_t) apr_thread_pool_tasks_cancel(apr_thread_pool_t *me,
+                                                       void *owner)
+{
+    apr_status_t rv = APR_SUCCESS;
+
+    apr_thread_mutex_lock(me->lock);
+    if (me->task_cnt > 0) {
+        rv = remove_tasks(me, owner);
+    }
+    if (me->scheduled_task_cnt > 0) {
+        rv = remove_scheduled_tasks(me, owner);
+    }
+    apr_thread_mutex_unlock(me->lock);
+    wait_on_busy_threads(me, owner);
+
+    return rv;
+}
+
+APU_DECLARE(apr_size_t) apr_thread_pool_tasks_count(apr_thread_pool_t *me)
+{
+    return me->task_cnt;
+}
+
+APU_DECLARE(apr_size_t)
+    apr_thread_pool_scheduled_tasks_count(apr_thread_pool_t *me)
+{
+    return me->scheduled_task_cnt;
+}
+
+APU_DECLARE(apr_size_t) apr_thread_pool_threads_count(apr_thread_pool_t *me)
+{
+    return me->thd_cnt;
+}
+
+APU_DECLARE(apr_size_t) apr_thread_pool_busy_count(apr_thread_pool_t *me)
+{
+    return me->thd_cnt - me->idle_cnt;
+}
+
+APU_DECLARE(apr_size_t) apr_thread_pool_idle_count(apr_thread_pool_t *me)
+{
+    return me->idle_cnt;
+}
+
+APU_DECLARE(apr_size_t)
+    apr_thread_pool_tasks_run_count(apr_thread_pool_t * me)
+{
+    return me->tasks_run;
+}
+
+APU_DECLARE(apr_size_t)
+    apr_thread_pool_tasks_high_count(apr_thread_pool_t * me)
+{
+    return me->tasks_high;
+}
+
+APU_DECLARE(apr_size_t)
+    apr_thread_pool_threads_high_count(apr_thread_pool_t * me)
+{
+    return me->thd_high;
+}
+
+APU_DECLARE(apr_size_t)
+    apr_thread_pool_threads_idle_timeout_count(apr_thread_pool_t * me)
+{
+    return me->thd_timed_out;
+}
+
+
+APU_DECLARE(apr_size_t) apr_thread_pool_idle_max_get(apr_thread_pool_t *me)
+{
+    return me->idle_max;
+}
+
+APU_DECLARE(apr_interval_time_t)
+    apr_thread_pool_idle_wait_get(apr_thread_pool_t * me)
+{
+    return me->idle_wait;
+}
+
+/*
+ * This function stop extra idle threads to the cnt.
+ * @return the number of threads stopped
+ * NOTE: There could be busy threads become idle during this function
+ */
+static struct apr_thread_list_elt *trim_threads(apr_thread_pool_t *me,
+                                                apr_size_t *cnt, int idle)
+{
+    struct apr_thread_list *thds;
+    apr_size_t n, n_dbg, i;
+    struct apr_thread_list_elt *head, *tail, *elt;
+
+    apr_thread_mutex_lock(me->lock);
+    if (idle) {
+        thds = me->idle_thds;
+        n = me->idle_cnt;
+    }
+    else {
+        thds = me->busy_thds;
+        n = me->thd_cnt - me->idle_cnt;
+    }
+    if (n <= *cnt) {
+        apr_thread_mutex_unlock(me->lock);
+        *cnt = 0;
+        return NULL;
+    }
+    n -= *cnt;
+
+    head = APR_RING_FIRST(thds);
+    for (i = 0; i < *cnt; i++) {
+        head = APR_RING_NEXT(head, link);
+    }
+    tail = APR_RING_LAST(thds);
+    if (idle) {
+        APR_RING_UNSPLICE(head, tail, link);
+        me->idle_cnt = *cnt;
+    }
+
+    n_dbg = 0;
+    for (elt = head; elt != tail; elt = APR_RING_NEXT(elt, link)) {
+        elt->state = TH_STOP;
+        n_dbg++;
+    }
+    elt->state = TH_STOP;
+    n_dbg++;
+    assert(n == n_dbg);
+    *cnt = n;
+
+    apr_thread_mutex_unlock(me->lock);
+
+    APR_RING_PREV(head, link) = NULL;
+    APR_RING_NEXT(tail, link) = NULL;
+    return head;
+}
+
+static apr_size_t trim_idle_threads(apr_thread_pool_t *me, apr_size_t cnt)
+{
+    apr_size_t n_dbg;
+    struct apr_thread_list_elt *elt, *head, *tail;
+    apr_status_t rv;
+
+    elt = trim_threads(me, &cnt, 1);
+
+    apr_thread_mutex_lock(me->cond_lock);
+    apr_thread_cond_broadcast(me->cond);
+    apr_thread_mutex_unlock(me->cond_lock);
+
+    n_dbg = 0;
+    if (NULL != (head = elt)) {
+        while (elt) {
+            tail = elt;
+            apr_thread_join(&rv, elt->thd);
+            elt = APR_RING_NEXT(elt, link);
+            ++n_dbg;
+        }
+        apr_thread_mutex_lock(me->lock);
+        APR_RING_SPLICE_TAIL(me->recycled_thds, head, tail,
+                             apr_thread_list_elt, link);
+        apr_thread_mutex_unlock(me->lock);
+    }
+    assert(cnt == n_dbg);
+
+    return cnt;
+}
+
+/* don't join on busy threads for performance reasons, who knows how long will
+ * the task takes to perform
+ */
+static apr_size_t trim_busy_threads(apr_thread_pool_t *me, apr_size_t cnt)
+{
+    trim_threads(me, &cnt, 0);
+    return cnt;
+}
+
+APU_DECLARE(apr_size_t) apr_thread_pool_idle_max_set(apr_thread_pool_t *me,
+                                                     apr_size_t cnt)
+{
+    me->idle_max = cnt;
+    cnt = trim_idle_threads(me, cnt);
+    return cnt;
+}
+
+APU_DECLARE(apr_interval_time_t)
+    apr_thread_pool_idle_wait_set(apr_thread_pool_t * me,
+                                  apr_interval_time_t timeout)
+{
+    apr_interval_time_t oldtime;
+
+    oldtime = me->idle_wait;
+    me->idle_wait = timeout;
+
+    return oldtime;
+}
+
+APU_DECLARE(apr_size_t) apr_thread_pool_thread_max_get(apr_thread_pool_t *me)
+{
+    return me->thd_max;
+}
+
+/*
+ * This function stop extra working threads to the new limit.
+ * NOTE: There could be busy threads become idle during this function
+ */
+APU_DECLARE(apr_size_t) apr_thread_pool_thread_max_set(apr_thread_pool_t *me,
+                                                       apr_size_t cnt)
+{
+    unsigned int n;
+
+    me->thd_max = cnt;
+    if (0 == cnt || me->thd_cnt <= cnt) {
+        return 0;
+    }
+
+    n = me->thd_cnt - cnt;
+    if (n >= me->idle_cnt) {
+        trim_busy_threads(me, n - me->idle_cnt);
+        trim_idle_threads(me, 0);
+    }
+    else {
+        trim_idle_threads(me, me->idle_cnt - n);
+    }
+    return n;
+}
+
+APU_DECLARE(apr_size_t) apr_thread_pool_threshold_get(apr_thread_pool_t *me)
+{
+    return me->threshold;
+}
+
+APU_DECLARE(apr_size_t) apr_thread_pool_threshold_set(apr_thread_pool_t *me,
+                                                      apr_size_t val)
+{
+    apr_size_t ov;
+
+    ov = me->threshold;
+    me->threshold = val;
+    return ov;
+}
+
+APU_DECLARE(apr_status_t) apr_thread_pool_task_owner_get(apr_thread_t *thd,
+                                                         void **owner)
+{
+    apr_status_t rv;
+    apr_thread_pool_task_t *task;
+    void *data;
+
+    rv = apr_thread_data_get(&data, "apr_thread_pool_task", thd);
+    if (rv != APR_SUCCESS) {
+        return rv;
+    }
+
+    task = data;
+    if (!task) {
+        *owner = NULL;
+        return APR_BADARG;
+    }
+
+    *owner = task->owner;
+    return APR_SUCCESS;
+}
+
+#endif /* APR_HAS_THREADS */
+
+/* vim: set ts=4 sw=4 et cin tw=80: */
diff --git a/util-misc/apu_dso.c b/util-misc/apu_dso.c
new file mode 100644
index 000000000..383c5157a
--- /dev/null
+++ b/util-misc/apu_dso.c
@@ -0,0 +1,199 @@
+/* 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.
+ */
+
+#include <ctype.h>
+#include <stdio.h>
+
+#include "apu_config.h"
+#include "apu.h"
+
+#include "apr_pools.h"
+#include "apr_tables.h"
+#include "apr_dso.h"
+#include "apr_strings.h"
+#include "apr_hash.h"
+#include "apr_file_io.h"
+#include "apr_env.h"
+
+#include "apu_internal.h"
+#include "apu_version.h"
+
+#if APU_DSO_BUILD
+
+#if APR_HAS_THREADS
+static apr_thread_mutex_t* mutex = NULL;
+#endif
+static apr_hash_t *dsos = NULL;
+
+#if APR_HAS_THREADS
+apr_status_t apu_dso_mutex_lock()
+{
+    return apr_thread_mutex_lock(mutex);
+}
+apr_status_t apu_dso_mutex_unlock()
+{
+    return apr_thread_mutex_unlock(mutex);
+}
+#else
+apr_status_t apu_dso_mutex_lock() {
+    return APR_SUCCESS;
+}
+apr_status_t apu_dso_mutex_unlock() {
+    return APR_SUCCESS;
+}
+#endif
+
+static apr_status_t apu_dso_term(void *ptr)
+{
+    /* set statics to NULL so init can work again */
+    dsos = NULL;
+#if APR_HAS_THREADS
+    mutex = NULL;
+#endif
+
+    /* Everything else we need is handled by cleanups registered
+     * when we created mutexes and loaded DSOs
+     */
+    return APR_SUCCESS;
+}
+
+apr_status_t apu_dso_init(apr_pool_t *pool)
+{
+    apr_status_t ret = APR_SUCCESS;
+    apr_pool_t *global;
+    apr_pool_t *parent;
+
+    if (dsos != NULL) {
+        return APR_SUCCESS;
+    }
+
+    /* Top level pool scope, need process-scope lifetime */
+    for (parent = global = pool; parent; parent = apr_pool_parent_get(global))
+        global = parent;
+
+    dsos = apr_hash_make(global);
+
+#if APR_HAS_THREADS
+    ret = apr_thread_mutex_create(&mutex, APR_THREAD_MUTEX_DEFAULT, global);
+    /* This already registers a pool cleanup */
+#endif
+
+    apr_pool_cleanup_register(global, NULL, apu_dso_term,
+                              apr_pool_cleanup_null);
+
+    return ret;
+}
+
+apr_status_t apu_dso_load(apr_dso_handle_t **dlhandleptr,
+                          apr_dso_handle_sym_t *dsoptr,
+                          const char *module,
+                          const char *modsym,
+                          apr_pool_t *pool)
+{
+    apr_dso_handle_t *dlhandle = NULL;
+    char *pathlist;
+    char path[APR_PATH_MAX + 1];
+    apr_array_header_t *paths;
+    apr_pool_t *global;
+    apr_status_t rv = APR_EDSOOPEN;
+    char *eos = NULL;
+    int i;
+
+    *dsoptr = apr_hash_get(dsos, module, APR_HASH_KEY_STRING);
+    if (*dsoptr) {
+        return APR_EINIT;
+    }
+
+    /* The driver DSO must have exactly the same lifetime as the
+     * drivers hash table; ignore the passed-in pool */
+    global = apr_hash_pool_get(dsos);
+
+    /* Retrieve our path search list or prepare for a single search */
+    if ((apr_env_get(&pathlist, APR_DSOPATH, pool) != APR_SUCCESS)
+          || (apr_filepath_list_split(&paths, pathlist, pool) != APR_SUCCESS))
+        paths = apr_array_make(pool, 1, sizeof(char*));
+
+#if defined(APU_DSO_LIBDIR)
+    /* Always search our prefix path, but on some platforms such as
+     * win32 this may be left undefined
+     */
+    (*((char **)apr_array_push(paths))) = APU_DSO_LIBDIR;
+#endif
+
+    for (i = 0; i < paths->nelts; ++i)
+    {
+#if defined(WIN32)
+        /* Use win32 dso search semantics and attempt to
+         * load the relative lib on the first pass.
+         */
+        if (!eos) {
+            eos = path;
+            --i;
+        }
+        else
+#endif
+        {
+            eos = apr_cpystrn(path, ((char**)paths->elts)[i], sizeof(path));
+            if ((eos > path) && (eos - path < sizeof(path) - 1))
+                *(eos++) = '/';
+        }
+        apr_cpystrn(eos, module, sizeof(path) - (eos - path));
+
+        rv = apr_dso_load(&dlhandle, path, global);
+        if (dlhandleptr) {
+            *dlhandleptr = dlhandle;
+        }
+        if (rv == APR_SUCCESS) { /* APR_EDSOOPEN */
+            break;
+        }
+#if defined(APU_DSO_LIBDIR)
+        else if (i < paths->nelts - 1) {
+#else
+        else {   /* No APU_DSO_LIBDIR to skip */
+#endif
+             /* try with apr-util-APU_MAJOR_VERSION appended */
+            eos = apr_cpystrn(eos,
+                              "apr-util-" APU_STRINGIFY(APU_MAJOR_VERSION) "/",
+                              sizeof(path) - (eos - path));
+
+            apr_cpystrn(eos, module, sizeof(path) - (eos - path));
+
+            rv = apr_dso_load(&dlhandle, path, global);
+            if (dlhandleptr) {
+                *dlhandleptr = dlhandle;
+            }
+            if (rv == APR_SUCCESS) { /* APR_EDSOOPEN */
+                break;
+            }
+        }
+    }
+
+    if (rv != APR_SUCCESS) /* APR_ESYMNOTFOUND */
+        return rv;
+
+    rv = apr_dso_sym(dsoptr, dlhandle, modsym);
+    if (rv != APR_SUCCESS) { /* APR_ESYMNOTFOUND */
+        apr_dso_unload(dlhandle);
+    }
+    else {
+        module = apr_pstrdup(global, module);
+        apr_hash_set(dsos, module, APR_HASH_KEY_STRING, *dsoptr);
+    }
+    return rv;
+}
+
+#endif /* APU_DSO_BUILD */
+
diff --git a/util-misc/apu_version.c b/util-misc/apu_version.c
new file mode 100644
index 000000000..97e730997
--- /dev/null
+++ b/util-misc/apu_version.c
@@ -0,0 +1,37 @@
+/* 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.
+ */
+
+#include "apr_general.h" /* for APR_STRINGIFY */
+
+#include "apu.h"
+#include "apu_version.h"
+
+APU_DECLARE(void) apu_version(apr_version_t *pvsn)
+{
+    pvsn->major = APU_MAJOR_VERSION;
+    pvsn->minor = APU_MINOR_VERSION;
+    pvsn->patch = APU_PATCH_VERSION;
+#ifdef APU_IS_DEV_VERSION
+    pvsn->is_dev = 1;
+#else
+    pvsn->is_dev = 0;
+#endif
+}
+
+APU_DECLARE(const char *) apu_version_string(void)
+{
+    return APU_VERSION_STRING;
+}