Tarball conversion

4 files changed, 1055 insertions, 0 deletions

diff --git a/time/unix/time.c b/time/unix/time.c
new file mode 100644
index 0000000..dfa45e6
--- /dev/null
+++ b/time/unix/time.c
@@ -0,0 +1,349 @@
+/* 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_portable.h"
+#include "apr_time.h"
+#include "apr_lib.h"
+#include "apr_private.h"
+#include "apr_strings.h"
+
+/* private APR headers */
+#include "apr_arch_internal_time.h"
+
+/* System Headers required for time library */
+#if APR_HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
+#if APR_HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#ifdef HAVE_TIME_H
+#include <time.h>
+#endif
+/* End System Headers */
+
+#if !defined(HAVE_STRUCT_TM_TM_GMTOFF) && !defined(HAVE_STRUCT_TM___TM_GMTOFF)
+static apr_int32_t server_gmt_offset;
+#define NO_GMTOFF_IN_STRUCT_TM
+#endif          
+
+static apr_int32_t get_offset(struct tm *tm)
+{
+#if defined(HAVE_STRUCT_TM_TM_GMTOFF)
+    return tm->tm_gmtoff;
+#elif defined(HAVE_STRUCT_TM___TM_GMTOFF)
+    return tm->__tm_gmtoff;
+#else
+#ifdef NETWARE
+    /* Need to adjust the global variable each time otherwise
+        the web server would have to be restarted when daylight
+        savings changes.
+    */
+    if (daylightOnOff) {
+        return server_gmt_offset + daylightOffset;
+    }
+#else
+    if (tm->tm_isdst)
+        return server_gmt_offset + 3600;
+#endif
+    return server_gmt_offset;
+#endif
+}
+
+APR_DECLARE(apr_status_t) apr_time_ansi_put(apr_time_t *result,
+                                            time_t input)
+{
+    *result = (apr_time_t)input * APR_USEC_PER_SEC;
+    return APR_SUCCESS;
+}
+
+/* NB NB NB NB This returns GMT!!!!!!!!!! */
+APR_DECLARE(apr_time_t) apr_time_now(void)
+{
+    struct timeval tv;
+    gettimeofday(&tv, NULL);
+    return tv.tv_sec * APR_USEC_PER_SEC + tv.tv_usec;
+}
+
+static void explode_time(apr_time_exp_t *xt, apr_time_t t,
+                         apr_int32_t offset, int use_localtime)
+{
+    struct tm tm;
+    time_t tt = (t / APR_USEC_PER_SEC) + offset;
+    xt->tm_usec = t % APR_USEC_PER_SEC;
+
+#if APR_HAS_THREADS && defined (_POSIX_THREAD_SAFE_FUNCTIONS)
+    if (use_localtime)
+        localtime_r(&tt, &tm);
+    else
+        gmtime_r(&tt, &tm);
+#else
+    if (use_localtime)
+        tm = *localtime(&tt);
+    else
+        tm = *gmtime(&tt);
+#endif
+
+    xt->tm_sec  = tm.tm_sec;
+    xt->tm_min  = tm.tm_min;
+    xt->tm_hour = tm.tm_hour;
+    xt->tm_mday = tm.tm_mday;
+    xt->tm_mon  = tm.tm_mon;
+    xt->tm_year = tm.tm_year;
+    xt->tm_wday = tm.tm_wday;
+    xt->tm_yday = tm.tm_yday;
+    xt->tm_isdst = tm.tm_isdst;
+    xt->tm_gmtoff = get_offset(&tm);
+}
+
+APR_DECLARE(apr_status_t) apr_time_exp_tz(apr_time_exp_t *result,
+                                          apr_time_t input, apr_int32_t offs)
+{
+    explode_time(result, input, offs, 0);
+    result->tm_gmtoff = offs;
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_time_exp_gmt(apr_time_exp_t *result,
+                                           apr_time_t input)
+{
+    return apr_time_exp_tz(result, input, 0);
+}
+
+APR_DECLARE(apr_status_t) apr_time_exp_lt(apr_time_exp_t *result,
+                                                apr_time_t input)
+{
+#if defined(__EMX__)
+    /* EMX gcc (OS/2) has a timezone global we can use */
+    return apr_time_exp_tz(result, input, -timezone);
+#else
+    explode_time(result, input, 0, 1);
+    return APR_SUCCESS;
+#endif /* __EMX__ */
+}
+
+APR_DECLARE(apr_status_t) apr_time_exp_get(apr_time_t *t, apr_time_exp_t *xt)
+{
+    apr_time_t year = xt->tm_year;
+    apr_time_t days;
+    static const int dayoffset[12] =
+    {306, 337, 0, 31, 61, 92, 122, 153, 184, 214, 245, 275};
+
+    /* shift new year to 1st March in order to make leap year calc easy */
+
+    if (xt->tm_mon < 2)
+        year--;
+
+    /* Find number of days since 1st March 1900 (in the Gregorian calendar). */
+
+    days = year * 365 + year / 4 - year / 100 + (year / 100 + 3) / 4;
+    days += dayoffset[xt->tm_mon] + xt->tm_mday - 1;
+    days -= 25508;              /* 1 jan 1970 is 25508 days since 1 mar 1900 */
+    days = ((days * 24 + xt->tm_hour) * 60 + xt->tm_min) * 60 + xt->tm_sec;
+
+    if (days < 0) {
+        return APR_EBADDATE;
+    }
+    *t = days * APR_USEC_PER_SEC + xt->tm_usec;
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_time_exp_gmt_get(apr_time_t *t, 
+                                               apr_time_exp_t *xt)
+{
+    apr_status_t status = apr_time_exp_get(t, xt);
+    if (status == APR_SUCCESS)
+        *t -= (apr_time_t) xt->tm_gmtoff * APR_USEC_PER_SEC;
+    return status;
+}
+
+APR_DECLARE(apr_status_t) apr_os_imp_time_get(apr_os_imp_time_t **ostime,
+                                              apr_time_t *aprtime)
+{
+    (*ostime)->tv_usec = *aprtime % APR_USEC_PER_SEC;
+    (*ostime)->tv_sec = *aprtime / APR_USEC_PER_SEC;
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_os_exp_time_get(apr_os_exp_time_t **ostime,
+                                              apr_time_exp_t *aprtime)
+{
+    (*ostime)->tm_sec  = aprtime->tm_sec;
+    (*ostime)->tm_min  = aprtime->tm_min;
+    (*ostime)->tm_hour = aprtime->tm_hour;
+    (*ostime)->tm_mday = aprtime->tm_mday;
+    (*ostime)->tm_mon  = aprtime->tm_mon;
+    (*ostime)->tm_year = aprtime->tm_year;
+    (*ostime)->tm_wday = aprtime->tm_wday;
+    (*ostime)->tm_yday = aprtime->tm_yday;
+    (*ostime)->tm_isdst = aprtime->tm_isdst;
+
+#if defined(HAVE_STRUCT_TM_TM_GMTOFF)
+    (*ostime)->tm_gmtoff = aprtime->tm_gmtoff;
+#elif defined(HAVE_STRUCT_TM___TM_GMTOFF)
+    (*ostime)->__tm_gmtoff = aprtime->tm_gmtoff;
+#endif
+
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_os_imp_time_put(apr_time_t *aprtime,
+                                              apr_os_imp_time_t **ostime,
+                                              apr_pool_t *cont)
+{
+    *aprtime = (*ostime)->tv_sec * APR_USEC_PER_SEC + (*ostime)->tv_usec;
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_os_exp_time_put(apr_time_exp_t *aprtime,
+                                              apr_os_exp_time_t **ostime,
+                                              apr_pool_t *cont)
+{
+    aprtime->tm_sec = (*ostime)->tm_sec;
+    aprtime->tm_min = (*ostime)->tm_min;
+    aprtime->tm_hour = (*ostime)->tm_hour;
+    aprtime->tm_mday = (*ostime)->tm_mday;
+    aprtime->tm_mon = (*ostime)->tm_mon;
+    aprtime->tm_year = (*ostime)->tm_year;
+    aprtime->tm_wday = (*ostime)->tm_wday;
+    aprtime->tm_yday = (*ostime)->tm_yday;
+    aprtime->tm_isdst = (*ostime)->tm_isdst;
+
+#if defined(HAVE_STRUCT_TM_TM_GMTOFF)
+    aprtime->tm_gmtoff = (*ostime)->tm_gmtoff;
+#elif defined(HAVE_STRUCT_TM___TM_GMTOFF)
+    aprtime->tm_gmtoff = (*ostime)->__tm_gmtoff;
+#endif
+
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(void) apr_sleep(apr_interval_time_t t)
+{
+#ifdef OS2
+    DosSleep(t/1000);
+#elif defined(BEOS)
+    snooze(t);
+#elif defined(NETWARE)
+    delay(t/1000);
+#else
+    struct timeval tv;
+    tv.tv_usec = t % APR_USEC_PER_SEC;
+    tv.tv_sec = t / APR_USEC_PER_SEC;
+    select(0, NULL, NULL, NULL, &tv);
+#endif
+}
+
+#ifdef OS2
+APR_DECLARE(apr_status_t) apr_os2_time_to_apr_time(apr_time_t *result,
+                                                   FDATE os2date,
+                                                   FTIME os2time)
+{
+  struct tm tmpdate;
+
+  memset(&tmpdate, 0, sizeof(tmpdate));
+  tmpdate.tm_hour  = os2time.hours;
+  tmpdate.tm_min   = os2time.minutes;
+  tmpdate.tm_sec   = os2time.twosecs * 2;
+
+  tmpdate.tm_mday  = os2date.day;
+  tmpdate.tm_mon   = os2date.month - 1;
+  tmpdate.tm_year  = os2date.year + 80;
+  tmpdate.tm_isdst = -1;
+
+  *result = mktime(&tmpdate) * APR_USEC_PER_SEC;
+  return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_apr_time_to_os2_time(FDATE *os2date,
+                                                   FTIME *os2time,
+                                                   apr_time_t aprtime)
+{
+    time_t ansitime = aprtime / APR_USEC_PER_SEC;
+    struct tm *lt;
+    lt = localtime(&ansitime);
+    os2time->hours    = lt->tm_hour;
+    os2time->minutes  = lt->tm_min;
+    os2time->twosecs  = lt->tm_sec / 2;
+
+    os2date->day      = lt->tm_mday;
+    os2date->month    = lt->tm_mon + 1;
+    os2date->year     = lt->tm_year - 80;
+    return APR_SUCCESS;
+}
+#endif
+
+#ifdef NETWARE
+APR_DECLARE(void) apr_netware_setup_time(void)
+{
+    tzset();
+    server_gmt_offset = -TZONE;
+}
+#else
+APR_DECLARE(void) apr_unix_setup_time(void)
+{
+#ifdef NO_GMTOFF_IN_STRUCT_TM
+    /* Precompute the offset from GMT on systems where it's not
+       in struct tm.
+
+       Note: This offset is normalized to be independent of daylight
+       savings time; if the calculation happens to be done in a
+       time/place where a daylight savings adjustment is in effect,
+       the returned offset has the same value that it would have
+       in the same location if daylight savings were not in effect.
+       The reason for this is that the returned offset can be
+       applied to a past or future timestamp in explode_time(),
+       so the DST adjustment obtained from the current time won't
+       necessarily be applicable.
+
+       mktime() is the inverse of localtime(); so, presumably,
+       passing in a struct tm made by gmtime() let's us calculate
+       the true GMT offset. However, there's a catch: if daylight
+       savings is in effect, gmtime()will set the tm_isdst field
+       and confuse mktime() into returning a time that's offset
+       by one hour. In that case, we must adjust the calculated GMT
+       offset.
+
+     */
+
+    struct timeval now;
+    time_t t1, t2;
+    struct tm t;
+
+    gettimeofday(&now, NULL);
+    t1 = now.tv_sec;
+    t2 = 0;
+
+#if APR_HAS_THREADS && defined(_POSIX_THREAD_SAFE_FUNCTIONS)
+    gmtime_r(&t1, &t);
+#else
+    t = *gmtime(&t1);
+#endif
+    t.tm_isdst = 0; /* we know this GMT time isn't daylight-savings */
+    t2 = mktime(&t);
+    server_gmt_offset = (apr_int32_t) difftime(t1, t2);
+#endif /* NO_GMTOFF_IN_STRUCT_TM */
+}
+
+#endif
+
+/* A noop on all known Unix implementations */
+APR_DECLARE(void) apr_time_clock_hires(apr_pool_t *p)
+{
+    return;
+}
+
+
diff --git a/time/unix/timestr.c b/time/unix/timestr.c
new file mode 100644
index 0000000..f74feba
--- /dev/null
+++ b/time/unix/timestr.c
@@ -0,0 +1,153 @@
+/* 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_portable.h"
+#include "apr_time.h"
+#include "apr_lib.h"
+#include "apr_private.h"
+/* System Headers required for time library */
+#if APR_HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
+#ifdef HAVE_TIME_H
+#include <time.h>
+#endif
+#if APR_HAVE_STRING_H
+#include <string.h>
+#endif
+/* End System Headers */
+
+APR_DECLARE_DATA const char apr_month_snames[12][4] =
+{
+    "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
+};
+APR_DECLARE_DATA const char apr_day_snames[7][4] =
+{
+    "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
+};
+
+apr_status_t apr_rfc822_date(char *date_str, apr_time_t t)
+{
+    apr_time_exp_t xt;
+    const char *s;
+    int real_year;
+
+    apr_time_exp_gmt(&xt, t);
+
+    /* example: "Sat, 08 Jan 2000 18:31:41 GMT" */
+    /*           12345678901234567890123456789  */
+
+    s = &apr_day_snames[xt.tm_wday][0];
+    *date_str++ = *s++;
+    *date_str++ = *s++;
+    *date_str++ = *s++;
+    *date_str++ = ',';
+    *date_str++ = ' ';
+    *date_str++ = xt.tm_mday / 10 + '0';
+    *date_str++ = xt.tm_mday % 10 + '0';
+    *date_str++ = ' ';
+    s = &apr_month_snames[xt.tm_mon][0];
+    *date_str++ = *s++;
+    *date_str++ = *s++;
+    *date_str++ = *s++;
+    *date_str++ = ' ';
+    real_year = 1900 + xt.tm_year;
+    /* This routine isn't y10k ready. */
+    *date_str++ = real_year / 1000 + '0';
+    *date_str++ = real_year % 1000 / 100 + '0';
+    *date_str++ = real_year % 100 / 10 + '0';
+    *date_str++ = real_year % 10 + '0';
+    *date_str++ = ' ';
+    *date_str++ = xt.tm_hour / 10 + '0';
+    *date_str++ = xt.tm_hour % 10 + '0';
+    *date_str++ = ':';
+    *date_str++ = xt.tm_min / 10 + '0';
+    *date_str++ = xt.tm_min % 10 + '0';
+    *date_str++ = ':';
+    *date_str++ = xt.tm_sec / 10 + '0';
+    *date_str++ = xt.tm_sec % 10 + '0';
+    *date_str++ = ' ';
+    *date_str++ = 'G';
+    *date_str++ = 'M';
+    *date_str++ = 'T';
+    *date_str++ = 0;
+    return APR_SUCCESS;
+}
+
+apr_status_t apr_ctime(char *date_str, apr_time_t t)
+{
+    apr_time_exp_t xt;
+    const char *s;
+    int real_year;
+
+    /* example: "Wed Jun 30 21:49:08 1993" */
+    /*           123456789012345678901234  */
+
+    apr_time_exp_lt(&xt, t);
+    s = &apr_day_snames[xt.tm_wday][0];
+    *date_str++ = *s++;
+    *date_str++ = *s++;
+    *date_str++ = *s++;
+    *date_str++ = ' ';
+    s = &apr_month_snames[xt.tm_mon][0];
+    *date_str++ = *s++;
+    *date_str++ = *s++;
+    *date_str++ = *s++;
+    *date_str++ = ' ';
+    *date_str++ = xt.tm_mday / 10 + '0';
+    *date_str++ = xt.tm_mday % 10 + '0';
+    *date_str++ = ' ';
+    *date_str++ = xt.tm_hour / 10 + '0';
+    *date_str++ = xt.tm_hour % 10 + '0';
+    *date_str++ = ':';
+    *date_str++ = xt.tm_min / 10 + '0';
+    *date_str++ = xt.tm_min % 10 + '0';
+    *date_str++ = ':';
+    *date_str++ = xt.tm_sec / 10 + '0';
+    *date_str++ = xt.tm_sec % 10 + '0';
+    *date_str++ = ' ';
+    real_year = 1900 + xt.tm_year;
+    *date_str++ = real_year / 1000 + '0';
+    *date_str++ = real_year % 1000 / 100 + '0';
+    *date_str++ = real_year % 100 / 10 + '0';
+    *date_str++ = real_year % 10 + '0';
+    *date_str++ = 0;
+
+    return APR_SUCCESS;
+}
+
+apr_status_t apr_strftime(char *s, apr_size_t *retsize, apr_size_t max, 
+                        const char *format, apr_time_exp_t *xt)
+{
+    struct tm tm;
+    memset(&tm, 0, sizeof tm);
+    tm.tm_sec  = xt->tm_sec;
+    tm.tm_min  = xt->tm_min;
+    tm.tm_hour = xt->tm_hour;
+    tm.tm_mday = xt->tm_mday;
+    tm.tm_mon  = xt->tm_mon;
+    tm.tm_year = xt->tm_year;
+    tm.tm_wday = xt->tm_wday;
+    tm.tm_yday = xt->tm_yday;
+    tm.tm_isdst = xt->tm_isdst;
+#if defined(HAVE_STRUCT_TM_TM_GMTOFF)
+    tm.tm_gmtoff = xt->tm_gmtoff;
+#elif defined(HAVE_STRUCT_TM___TM_GMTOFF)
+    tm.__tm_gmtoff = xt->tm_gmtoff;
+#endif
+    (*retsize) = strftime(s, max, format, &tm);
+    return APR_SUCCESS;
+}
diff --git a/time/win32/time.c b/time/win32/time.c
new file mode 100644
index 0000000..ecf0228
--- /dev/null
+++ b/time/win32/time.c
@@ -0,0 +1,333 @@
+/* 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_arch_atime.h"
+#include "apr_time.h"
+#include "apr_general.h"
+#include "apr_lib.h"
+#include "apr_portable.h"
+#if APR_HAVE_TIME_H
+#include <time.h>
+#endif
+#if APR_HAVE_ERRNO_H
+#include <errno.h>
+#endif
+#include <string.h>
+#include <winbase.h>
+#include "apr_arch_misc.h"
+
+/* Leap year is any year divisible by four, but not by 100 unless also
+ * divisible by 400
+ */
+#define IsLeapYear(y) ((!(y % 4)) ? (((!(y % 400)) && (y % 100)) ? 1 : 0) : 0)
+
+static DWORD get_local_timezone(TIME_ZONE_INFORMATION **tzresult)
+{
+    static TIME_ZONE_INFORMATION tz;
+    static DWORD result;
+    static int init = 0;
+
+    if (!init) {
+        result = GetTimeZoneInformation(&tz);
+        init = 1;
+    }
+
+    *tzresult = &tz;
+    return result;
+}
+
+static void SystemTimeToAprExpTime(apr_time_exp_t *xt, SYSTEMTIME *tm)
+{
+    static const int dayoffset[12] =
+    {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334};
+
+    /* Note; the caller is responsible for filling in detailed tm_usec,
+     * tm_gmtoff and tm_isdst data when applicable.
+     */
+    xt->tm_usec = tm->wMilliseconds * 1000;
+    xt->tm_sec  = tm->wSecond;
+    xt->tm_min  = tm->wMinute;
+    xt->tm_hour = tm->wHour;
+    xt->tm_mday = tm->wDay;
+    xt->tm_mon  = tm->wMonth - 1;
+    xt->tm_year = tm->wYear - 1900;
+    xt->tm_wday = tm->wDayOfWeek;
+    xt->tm_yday = dayoffset[xt->tm_mon] + (tm->wDay - 1);
+    xt->tm_isdst = 0;
+    xt->tm_gmtoff = 0;
+
+    /* If this is a leap year, and we're past the 28th of Feb. (the
+     * 58th day after Jan. 1), we'll increment our tm_yday by one.
+     */
+    if (IsLeapYear(tm->wYear) && (xt->tm_yday > 58))
+        xt->tm_yday++;
+}
+
+APR_DECLARE(apr_status_t) apr_time_ansi_put(apr_time_t *result, 
+                                                    time_t input)
+{
+    *result = (apr_time_t) input * APR_USEC_PER_SEC;
+    return APR_SUCCESS;
+}
+
+/* Return micro-seconds since the Unix epoch (jan. 1, 1970) UTC */
+APR_DECLARE(apr_time_t) apr_time_now(void)
+{
+    LONGLONG aprtime = 0;
+    FILETIME time;
+#ifndef _WIN32_WCE
+    GetSystemTimeAsFileTime(&time);
+#else
+    SYSTEMTIME st;
+    GetSystemTime(&st);
+    SystemTimeToFileTime(&st, &time);
+#endif
+    FileTimeToAprTime(&aprtime, &time);
+    return aprtime; 
+}
+
+APR_DECLARE(apr_status_t) apr_time_exp_gmt(apr_time_exp_t *result,
+                                           apr_time_t input)
+{
+    FILETIME ft;
+    SYSTEMTIME st;
+    AprTimeToFileTime(&ft, input);
+    FileTimeToSystemTime(&ft, &st);
+    /* The Platform SDK documents that SYSTEMTIME/FILETIME are
+     * generally UTC, so no timezone info needed
+     */
+    SystemTimeToAprExpTime(result, &st);
+    result->tm_usec = (apr_int32_t) (input % APR_USEC_PER_SEC);
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_time_exp_tz(apr_time_exp_t *result, 
+                                          apr_time_t input, 
+                                          apr_int32_t offs)
+{
+    FILETIME ft;
+    SYSTEMTIME st;
+    AprTimeToFileTime(&ft, input + (offs *  APR_USEC_PER_SEC));
+    FileTimeToSystemTime(&ft, &st);
+    /* The Platform SDK documents that SYSTEMTIME/FILETIME are
+     * generally UTC, so we will simply note the offs used.
+     */
+    SystemTimeToAprExpTime(result, &st);
+    result->tm_usec = (apr_int32_t) (input % APR_USEC_PER_SEC);
+    result->tm_gmtoff = offs;
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_time_exp_lt(apr_time_exp_t *result,
+                                          apr_time_t input)
+{
+    SYSTEMTIME st;
+    FILETIME ft, localft;
+
+    AprTimeToFileTime(&ft, input);
+
+#if APR_HAS_UNICODE_FS && !defined(_WIN32_WCE)
+    IF_WIN_OS_IS_UNICODE
+    {
+        TIME_ZONE_INFORMATION *tz;
+        SYSTEMTIME localst;
+        apr_time_t localtime;
+
+        get_local_timezone(&tz);
+
+        FileTimeToSystemTime(&ft, &st);
+
+        /* The Platform SDK documents that SYSTEMTIME/FILETIME are
+         * generally UTC.  We use SystemTimeToTzSpecificLocalTime
+         * because FileTimeToLocalFileFime is documented that the
+         * resulting time local file time would have DST relative
+         * to the *present* date, not the date converted.
+         */
+        SystemTimeToTzSpecificLocalTime(tz, &st, &localst);
+        SystemTimeToAprExpTime(result, &localst);
+        result->tm_usec = (apr_int32_t) (input % APR_USEC_PER_SEC);
+
+
+        /* Recover the resulting time as an apr time and use the
+         * delta for gmtoff in seconds (and ignore msec rounding) 
+         */
+        SystemTimeToFileTime(&localst, &localft);
+        FileTimeToAprTime(&localtime, &localft);
+        result->tm_gmtoff = (int)apr_time_sec(localtime) 
+                          - (int)apr_time_sec(input);
+
+        /* To compute the dst flag, we compare the expected 
+         * local (standard) timezone bias to the delta.
+         * [Note, in war time or double daylight time the
+         * resulting tm_isdst is, desireably, 2 hours]
+         */
+        result->tm_isdst = (result->tm_gmtoff / 3600)
+                         - (-(tz->Bias + tz->StandardBias) / 60);
+    }
+#endif
+#if APR_HAS_ANSI_FS || defined(_WIN32_WCE)
+    ELSE_WIN_OS_IS_ANSI
+    {
+        TIME_ZONE_INFORMATION tz;
+	/* XXX: This code is simply *wrong*.  The time converted will always
+         * map to the *now current* status of daylight savings time.
+         */
+
+        FileTimeToLocalFileTime(&ft, &localft);
+        FileTimeToSystemTime(&localft, &st);
+        SystemTimeToAprExpTime(result, &st);
+        result->tm_usec = (apr_int32_t) (input % APR_USEC_PER_SEC);
+
+        switch (GetTimeZoneInformation(&tz)) {
+            case TIME_ZONE_ID_UNKNOWN:
+                result->tm_isdst = 0;
+                /* Bias = UTC - local time in minutes
+                 * tm_gmtoff is seconds east of UTC
+                 */
+                result->tm_gmtoff = tz.Bias * -60;
+                break;
+            case TIME_ZONE_ID_STANDARD:
+                result->tm_isdst = 0;
+                result->tm_gmtoff = (tz.Bias + tz.StandardBias) * -60;
+                break;
+            case TIME_ZONE_ID_DAYLIGHT:
+                result->tm_isdst = 1;
+                result->tm_gmtoff = (tz.Bias + tz.DaylightBias) * -60;
+                break;
+            default:
+                /* noop */;
+        }
+    }
+#endif
+
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_time_exp_get(apr_time_t *t,
+                                           apr_time_exp_t *xt)
+{
+    apr_time_t year = xt->tm_year;
+    apr_time_t days;
+    static const int dayoffset[12] =
+    {306, 337, 0, 31, 61, 92, 122, 153, 184, 214, 245, 275};
+
+    /* shift new year to 1st March in order to make leap year calc easy */
+
+    if (xt->tm_mon < 2)
+        year--;
+
+    /* Find number of days since 1st March 1900 (in the Gregorian calendar). */
+
+    days = year * 365 + year / 4 - year / 100 + (year / 100 + 3) / 4;
+    days += dayoffset[xt->tm_mon] + xt->tm_mday - 1;
+    days -= 25508;              /* 1 jan 1970 is 25508 days since 1 mar 1900 */
+
+    days = ((days * 24 + xt->tm_hour) * 60 + xt->tm_min) * 60 + xt->tm_sec;
+
+    if (days < 0) {
+        return APR_EBADDATE;
+    }
+    *t = days * APR_USEC_PER_SEC + xt->tm_usec;
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_time_exp_gmt_get(apr_time_t *t,
+                                               apr_time_exp_t *xt)
+{
+    apr_status_t status = apr_time_exp_get(t, xt);
+    if (status == APR_SUCCESS)
+        *t -= (apr_time_t) xt->tm_gmtoff * APR_USEC_PER_SEC;
+    return status;
+}
+
+APR_DECLARE(apr_status_t) apr_os_imp_time_get(apr_os_imp_time_t **ostime,
+                                              apr_time_t *aprtime)
+{
+    /* TODO: Consider not passing in pointer to apr_time_t (e.g., call by value) */
+    AprTimeToFileTime(*ostime, *aprtime);
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_os_exp_time_get(apr_os_exp_time_t **ostime, 
+                                              apr_time_exp_t *aprexptime)
+{
+    (*ostime)->wYear = aprexptime->tm_year + 1900;
+    (*ostime)->wMonth = aprexptime->tm_mon + 1;
+    (*ostime)->wDayOfWeek = aprexptime->tm_wday;
+    (*ostime)->wDay = aprexptime->tm_mday;
+    (*ostime)->wHour = aprexptime->tm_hour;
+    (*ostime)->wMinute = aprexptime->tm_min;
+    (*ostime)->wSecond = aprexptime->tm_sec;
+    (*ostime)->wMilliseconds = aprexptime->tm_usec / 1000;
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_os_imp_time_put(apr_time_t *aprtime,
+                                              apr_os_imp_time_t **ostime,
+                                              apr_pool_t *cont)
+{
+    /* XXX: sanity failure, what is file time, gmt or local ?
+     */
+    FileTimeToAprTime(aprtime, *ostime);
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_os_exp_time_put(apr_time_exp_t *aprtime,
+                                              apr_os_exp_time_t **ostime,
+                                              apr_pool_t *cont)
+{
+    /* The Platform SDK documents that SYSTEMTIME/FILETIME are
+     * generally UTC, so no timezone info needed
+     */
+    SystemTimeToAprExpTime(aprtime, *ostime);
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(void) apr_sleep(apr_interval_time_t t)
+{
+    /* One of the few sane situations for a cast, Sleep
+     * is in ms, not us, and passed as a DWORD value
+     */
+    Sleep((DWORD)(t / 1000));
+}
+
+#if defined(_WIN32_WCE)
+/* A noop on WinCE, like Unix implementation */
+APR_DECLARE(void) apr_time_clock_hires(apr_pool_t *p)
+{
+    return;
+}
+#else
+static apr_status_t clock_restore(void *unsetres)
+{
+    ULONG newRes;
+    SetTimerResolution((ULONG)(apr_ssize_t)unsetres, FALSE, &newRes);
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(void) apr_time_clock_hires(apr_pool_t *p)
+{
+    ULONG newRes;
+    /* Timer resolution is stated in 100ns units.  Note that TRUE requests the
+     * new clock resolution, FALSE above releases the request.
+     */
+    if (SetTimerResolution(10000, TRUE, &newRes) == 0 /* STATUS_SUCCESS */) {
+        /* register the cleanup... */
+        apr_pool_cleanup_register(p, (void*)10000, clock_restore,
+                                  apr_pool_cleanup_null);
+    }
+}
+#endif
diff --git a/time/win32/timestr.c b/time/win32/timestr.c
new file mode 100644
index 0000000..1384123
--- /dev/null
+++ b/time/win32/timestr.c
@@ -0,0 +1,220 @@
+/* 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_arch_atime.h"
+#include "apr_portable.h"
+#include "apr_strings.h"
+
+#if APR_HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+
+APR_DECLARE_DATA const char apr_month_snames[12][4] =
+{
+    "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
+};
+APR_DECLARE_DATA const char apr_day_snames[7][4] =
+{
+    "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
+};
+
+APR_DECLARE(apr_status_t) apr_rfc822_date(char *date_str, apr_time_t t)
+{
+    apr_time_exp_t xt;
+    const char *s;
+    int real_year;
+
+    apr_time_exp_gmt(&xt, t);
+
+    /* example: "Sat, 08 Jan 2000 18:31:41 GMT" */
+    /*           12345678901234567890123456789  */
+
+    s = &apr_day_snames[xt.tm_wday][0];
+    *date_str++ = *s++;
+    *date_str++ = *s++;
+    *date_str++ = *s++;
+    *date_str++ = ',';
+    *date_str++ = ' ';
+    *date_str++ = xt.tm_mday / 10 + '0';
+    *date_str++ = xt.tm_mday % 10 + '0';
+    *date_str++ = ' ';
+    s = &apr_month_snames[xt.tm_mon][0];
+    *date_str++ = *s++;
+    *date_str++ = *s++;
+    *date_str++ = *s++;
+    *date_str++ = ' ';
+    real_year = 1900 + xt.tm_year;
+    /* This routine isn't y10k ready. */
+    *date_str++ = real_year / 1000 + '0';
+    *date_str++ = real_year % 1000 / 100 + '0';
+    *date_str++ = real_year % 100 / 10 + '0';
+    *date_str++ = real_year % 10 + '0';
+    *date_str++ = ' ';
+    *date_str++ = xt.tm_hour / 10 + '0';
+    *date_str++ = xt.tm_hour % 10 + '0';
+    *date_str++ = ':';
+    *date_str++ = xt.tm_min / 10 + '0';
+    *date_str++ = xt.tm_min % 10 + '0';
+    *date_str++ = ':';
+    *date_str++ = xt.tm_sec / 10 + '0';
+    *date_str++ = xt.tm_sec % 10 + '0';
+    *date_str++ = ' ';
+    *date_str++ = 'G';
+    *date_str++ = 'M';
+    *date_str++ = 'T';
+    *date_str++ = 0;
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_ctime(char *date_str, apr_time_t t)
+{
+    apr_time_exp_t xt;
+    const char *s;
+    int real_year;
+
+    /* example: "Wed Jun 30 21:49:08 1993" */
+    /*           123456789012345678901234  */
+
+    apr_time_exp_lt(&xt, t);
+    s = &apr_day_snames[xt.tm_wday][0];
+    *date_str++ = *s++;
+    *date_str++ = *s++;
+    *date_str++ = *s++;
+    *date_str++ = ' ';
+    s = &apr_month_snames[xt.tm_mon][0];
+    *date_str++ = *s++;
+    *date_str++ = *s++;
+    *date_str++ = *s++;
+    *date_str++ = ' ';
+    *date_str++ = xt.tm_mday / 10 + '0';
+    *date_str++ = xt.tm_mday % 10 + '0';
+    *date_str++ = ' ';
+    *date_str++ = xt.tm_hour / 10 + '0';
+    *date_str++ = xt.tm_hour % 10 + '0';
+    *date_str++ = ':';
+    *date_str++ = xt.tm_min / 10 + '0';
+    *date_str++ = xt.tm_min % 10 + '0';
+    *date_str++ = ':';
+    *date_str++ = xt.tm_sec / 10 + '0';
+    *date_str++ = xt.tm_sec % 10 + '0';
+    *date_str++ = ' ';
+    real_year = 1900 + xt.tm_year;
+    *date_str++ = real_year / 1000 + '0';
+    *date_str++ = real_year % 1000 / 100 + '0';
+    *date_str++ = real_year % 100 / 10 + '0';
+    *date_str++ = real_year % 10 + '0';
+    *date_str++ = 0;
+
+    return APR_SUCCESS;
+}
+
+
+#ifndef _WIN32_WCE
+
+static apr_size_t win32_strftime_extra(char *s, size_t max, const char *format,
+                                       const struct tm *tm) 
+{
+   /* If the new format string is bigger than max, the result string won't fit
+    * anyway. If format strings are added, made sure the padding below is
+    * enough */
+    char *new_format = (char *) malloc(max + 11);
+    size_t i, j, format_length = strlen(format);
+    apr_size_t return_value;
+    int length_written;
+
+    for (i = 0, j = 0; (i < format_length && j < max);) {
+        if (format[i] != '%') {
+            new_format[j++] = format[i++];
+            continue;
+        }
+        switch (format[i+1]) {
+            case 'C':
+                length_written = apr_snprintf(new_format + j, max - j, "%2d",
+                    (tm->tm_year + 1970)/100);
+                j = (length_written == -1) ? max : (j + length_written);
+                i += 2;
+                break;
+            case 'D':
+                /* Is this locale dependent? Shouldn't be...
+                   Also note the year 2000 exposure here */
+                memcpy(new_format + j, "%m/%d/%y", 8);
+                i += 2;
+                j += 8;
+                break;
+            case 'r':
+                memcpy(new_format + j, "%I:%M:%S %p", 11);
+                i += 2;
+                j += 11;
+                break;
+            case 'R':
+                memcpy(new_format + j, "%H:%M", 5);
+                i += 2;
+                j += 5;
+                break;
+            case 'T':
+                memcpy(new_format + j, "%H:%M:%S", 8);
+                i += 2;
+                j += 8;
+                break;
+            case 'e':
+                length_written = apr_snprintf(new_format + j, max - j, "%2d",
+                    tm->tm_mday);
+                j = (length_written == -1) ? max : (j + length_written);
+                i += 2;
+                break;
+            default:
+                /* We know we can advance two characters forward here. Also
+                 * makes sure that %% is preserved. */
+                new_format[j++] = format[i++];
+                new_format[j++] = format[i++];
+        }
+    }
+    if (j >= max) {
+        *s = '\0';  /* Defensive programming, okay since output is undefined*/
+        return_value = 0;
+    } else {
+        new_format[j] = '\0';
+        return_value = strftime(s, max, new_format, tm);
+    }
+    free(new_format);
+    return return_value;
+}
+
+#endif
+
+
+APR_DECLARE(apr_status_t) apr_strftime(char *s, apr_size_t *retsize,
+                                       apr_size_t max, const char *format,
+                                       apr_time_exp_t *xt)
+{
+#ifdef _WIN32_WCE
+    return APR_ENOTIMPL;
+#else
+    struct tm tm;
+    memset(&tm, 0, sizeof tm);
+    tm.tm_sec  = xt->tm_sec;
+    tm.tm_min  = xt->tm_min;
+    tm.tm_hour = xt->tm_hour;
+    tm.tm_mday = xt->tm_mday;
+    tm.tm_mon  = xt->tm_mon;
+    tm.tm_year = xt->tm_year;
+    tm.tm_wday = xt->tm_wday;
+    tm.tm_yday = xt->tm_yday;
+    tm.tm_isdst = xt->tm_isdst;
+    (*retsize) = win32_strftime_extra(s, max, format, &tm);
+    return APR_SUCCESS;
+#endif
+}