upload http

JIRA: BOTTLENECK-10

Change-Id: I7598427ff904df438ce77c2819ee48ac75ffa8da
Signed-off-by: hongbotian <hongbo.tianhongbo@huawei.com>

10 files changed, 4234 insertions, 0 deletions

diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/file_io/win32/dir.c b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/win32/dir.c
new file mode 100644
index 00000000..29a4e1c4
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/win32/dir.c
@@ -0,0 +1,393 @@
+/* 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"
+#include "apr_arch_file_io.h"
+#include "apr_file_io.h"
+#include "apr_strings.h"
+#include "apr_portable.h"
+#include "apr_arch_atime.h"
+
+#if APR_HAVE_ERRNO_H
+#include <errno.h>
+#endif
+#if APR_HAVE_STRING_H
+#include <string.h>
+#endif
+#if APR_HAVE_DIRENT_H
+#include <dirent.h>
+#endif
+#ifdef HAVE_SYS_STAT_H
+#include <sys/stat.h>
+#endif
+
+
+static apr_status_t dir_cleanup(void *thedir)
+{
+    apr_dir_t *dir = thedir;
+    if (dir->dirhand != INVALID_HANDLE_VALUE && !FindClose(dir->dirhand)) {
+        return apr_get_os_error();
+    }
+    dir->dirhand = INVALID_HANDLE_VALUE;
+    return APR_SUCCESS;
+} 
+
+APR_DECLARE(apr_status_t) apr_dir_open(apr_dir_t **new, const char *dirname,
+                                       apr_pool_t *pool)
+{
+    apr_status_t rv;
+
+    int len = strlen(dirname);
+    (*new) = apr_pcalloc(pool, sizeof(apr_dir_t));
+    /* Leave room here to add and pop the '*' wildcard for FindFirstFile 
+     * and double-null terminate so we have one character to change.
+     */
+    (*new)->dirname = apr_palloc(pool, len + 3);
+    memcpy((*new)->dirname, dirname, len);
+    if (len && (*new)->dirname[len - 1] != '/') {
+    	(*new)->dirname[len++] = '/';
+    }
+    (*new)->dirname[len++] = '\0';
+    (*new)->dirname[len] = '\0';
+
+#if APR_HAS_UNICODE_FS
+    IF_WIN_OS_IS_UNICODE
+    {
+        /* Create a buffer for the longest file name we will ever see 
+         */
+        (*new)->w.entry = apr_pcalloc(pool, sizeof(WIN32_FIND_DATAW));
+        (*new)->name = apr_pcalloc(pool, APR_FILE_MAX * 3 + 1);        
+    }
+#endif
+#if APR_HAS_ANSI_FS
+    ELSE_WIN_OS_IS_ANSI
+    {
+        /* Note that we won't open a directory that is greater than MAX_PATH,
+         * including the trailing /* wildcard suffix.  If a * won't fit, then
+         * neither will any other file name within the directory.
+         * The length not including the trailing '*' is stored as rootlen, to
+         * skip over all paths which are too long.
+         */
+        if (len >= APR_PATH_MAX) {
+            (*new) = NULL;
+            return APR_ENAMETOOLONG;
+        }
+        (*new)->n.entry = apr_pcalloc(pool, sizeof(WIN32_FIND_DATAW));
+    }
+#endif
+    (*new)->rootlen = len - 1;
+    (*new)->pool = pool;
+    (*new)->dirhand = INVALID_HANDLE_VALUE;
+    apr_pool_cleanup_register((*new)->pool, (void *)(*new), dir_cleanup,
+                        apr_pool_cleanup_null);
+
+    rv = apr_dir_read(NULL, 0, *new);
+    if (rv != APR_SUCCESS) {
+        dir_cleanup(*new);
+        *new = NULL;
+    }
+
+    return rv;
+}
+
+APR_DECLARE(apr_status_t) apr_dir_close(apr_dir_t *dir)
+{
+    apr_pool_cleanup_kill(dir->pool, dir, dir_cleanup);
+    return dir_cleanup(dir);
+}
+
+APR_DECLARE(apr_status_t) apr_dir_read(apr_finfo_t *finfo, apr_int32_t wanted,
+                                       apr_dir_t *thedir)
+{
+    apr_status_t rv;
+    char *fname;
+    /* The while loops below allow us to skip all invalid file names, so that
+     * we aren't reporting any files where their absolute paths are too long.
+     */
+#if APR_HAS_UNICODE_FS
+    apr_wchar_t wdirname[APR_PATH_MAX];
+    apr_wchar_t *eos = NULL;
+    IF_WIN_OS_IS_UNICODE
+    {
+        /* This code path is always be invoked by apr_dir_open or
+         * apr_dir_rewind, so return without filling out the finfo.
+         */
+        if (thedir->dirhand == INVALID_HANDLE_VALUE) 
+        {
+            apr_status_t rv;
+            if (rv = utf8_to_unicode_path(wdirname, sizeof(wdirname) 
+                                                     / sizeof(apr_wchar_t), 
+                                          thedir->dirname)) {
+                return rv;
+            }
+            eos = wcschr(wdirname, '\0');
+            eos[0] = '*';
+            eos[1] = '\0';
+            thedir->dirhand = FindFirstFileW(wdirname, thedir->w.entry);
+            eos[0] = '\0';
+            if (thedir->dirhand == INVALID_HANDLE_VALUE) {
+                return apr_get_os_error();
+            }
+            thedir->bof = 1;
+            return APR_SUCCESS;
+        }
+        else if (thedir->bof) {
+            /* Noop - we already called FindFirstFileW from
+             * either apr_dir_open or apr_dir_rewind ... use
+             * that first record.
+             */
+            thedir->bof = 0; 
+        }
+        else if (!FindNextFileW(thedir->dirhand, thedir->w.entry)) {
+            return apr_get_os_error();
+        }
+
+        while (thedir->rootlen &&
+               thedir->rootlen + wcslen(thedir->w.entry->cFileName) >= APR_PATH_MAX)
+        {
+            if (!FindNextFileW(thedir->dirhand, thedir->w.entry)) {
+                return apr_get_os_error();
+            }
+        }
+        if (rv = unicode_to_utf8_path(thedir->name, APR_FILE_MAX * 3 + 1, 
+                                      thedir->w.entry->cFileName))
+            return rv;
+        fname = thedir->name;
+    }
+#endif
+#if APR_HAS_ANSI_FS
+    ELSE_WIN_OS_IS_ANSI
+    {
+        /* This code path is always be invoked by apr_dir_open or 
+         * apr_dir_rewind, so return without filling out the finfo.
+         */
+        if (thedir->dirhand == INVALID_HANDLE_VALUE) {
+            /* '/' terminated, so add the '*' and pop it when we finish */
+            char *eop = strchr(thedir->dirname, '\0');
+            eop[0] = '*';
+            eop[1] = '\0';
+            thedir->dirhand = FindFirstFileA(thedir->dirname, 
+                                             thedir->n.entry);
+            eop[0] = '\0';
+            if (thedir->dirhand == INVALID_HANDLE_VALUE) {
+                return apr_get_os_error();
+            }
+            thedir->bof = 1;
+            return APR_SUCCESS;
+        }
+        else if (thedir->bof) {
+            /* Noop - we already called FindFirstFileW from
+             * either apr_dir_open or apr_dir_rewind ... use
+             * that first record.
+             */
+            thedir->bof = 0; 
+        }
+        else if (!FindNextFileA(thedir->dirhand, thedir->n.entry)) {
+            return apr_get_os_error();
+        }
+        while (thedir->rootlen &&
+               thedir->rootlen + strlen(thedir->n.entry->cFileName) >= MAX_PATH)
+        {
+            if (!FindNextFileA(thedir->dirhand, thedir->n.entry)) {
+                return apr_get_os_error();
+            }
+        }
+        fname = thedir->n.entry->cFileName;
+    }
+#endif
+
+    fillin_fileinfo(finfo, (WIN32_FILE_ATTRIBUTE_DATA *) thedir->w.entry, 
+                    0, wanted);
+    finfo->pool = thedir->pool;
+
+    finfo->valid |= APR_FINFO_NAME;
+    finfo->name = fname;
+
+    if (wanted &= ~finfo->valid) {
+        /* Go back and get more_info if we can't answer the whole inquiry
+         */
+#if APR_HAS_UNICODE_FS
+        IF_WIN_OS_IS_UNICODE
+        {
+            /* Almost all our work is done.  Tack on the wide file name
+             * to the end of the wdirname (already / delimited)
+             */
+            if (!eos)
+                eos = wcschr(wdirname, '\0');
+            wcscpy(eos, thedir->w.entry->cFileName);
+            rv = more_finfo(finfo, wdirname, wanted, MORE_OF_WFSPEC);
+            eos[0] = '\0';
+            return rv;
+        }
+#endif
+#if APR_HAS_ANSI_FS
+        ELSE_WIN_OS_IS_ANSI
+        {
+#if APR_HAS_UNICODE_FS
+            /* Don't waste stack space on a second buffer, the one we set
+             * aside for the wide directory name is twice what we need.
+             */
+            char *fspec = (char*)wdirname;
+#else
+            char fspec[APR_PATH_MAX];
+#endif
+            int dirlen = strlen(thedir->dirname);
+            if (dirlen >= sizeof(fspec))
+                dirlen = sizeof(fspec) - 1;
+            apr_cpystrn(fspec, thedir->dirname, sizeof(fspec));
+            apr_cpystrn(fspec + dirlen, fname, sizeof(fspec) - dirlen);
+            return more_finfo(finfo, fspec, wanted, MORE_OF_FSPEC);
+        }
+#endif
+    }
+
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_dir_rewind(apr_dir_t *dir)
+{
+    apr_status_t rv;
+
+    /* this will mark the handle as invalid and we'll open it
+     * again if apr_dir_read() is subsequently called
+     */
+    rv = dir_cleanup(dir);
+
+    if (rv == APR_SUCCESS)
+        rv = apr_dir_read(NULL, 0, dir);
+
+    return rv;
+}
+
+APR_DECLARE(apr_status_t) apr_dir_make(const char *path, apr_fileperms_t perm,
+                                       apr_pool_t *pool)
+{
+#if APR_HAS_UNICODE_FS
+    IF_WIN_OS_IS_UNICODE
+    {
+        apr_wchar_t wpath[APR_PATH_MAX];
+        apr_status_t rv;
+        if (rv = utf8_to_unicode_path(wpath, sizeof(wpath) 
+                                              / sizeof(apr_wchar_t), path)) {
+            return rv;
+        }
+        if (!CreateDirectoryW(wpath, NULL)) {
+            return apr_get_os_error();
+        }
+    }
+#endif
+#if APR_HAS_ANSI_FS
+    ELSE_WIN_OS_IS_ANSI
+        if (!CreateDirectory(path, NULL)) {
+            return apr_get_os_error();
+        }
+#endif
+    return APR_SUCCESS;
+}
+
+
+static apr_status_t dir_make_parent(char *path,
+                                    apr_fileperms_t perm,
+                                    apr_pool_t *pool)
+{
+    apr_status_t rv;
+    char *ch = strrchr(path, '\\');
+    if (!ch) {
+        return APR_ENOENT;
+    }
+
+    *ch = '\0';
+    rv = apr_dir_make (path, perm, pool); /* Try to make straight off */
+    
+    if (APR_STATUS_IS_ENOENT(rv)) { /* Missing an intermediate dir */
+        rv = dir_make_parent(path, perm, pool);
+
+        if (rv == APR_SUCCESS) {
+            rv = apr_dir_make (path, perm, pool); /* And complete the path */
+        }
+    }
+
+    *ch = '\\'; /* Always replace the slash before returning */
+    return rv;
+}
+
+APR_DECLARE(apr_status_t) apr_dir_make_recursive(const char *path,
+                                                 apr_fileperms_t perm,
+                                                 apr_pool_t *pool)
+{
+    apr_status_t rv = 0;
+    
+    rv = apr_dir_make (path, perm, pool); /* Try to make PATH right out */
+    
+    if (APR_STATUS_IS_EEXIST(rv)) /* It's OK if PATH exists */
+        return APR_SUCCESS;
+    
+    if (APR_STATUS_IS_ENOENT(rv)) { /* Missing an intermediate dir */
+        char *dir;
+        
+        rv = apr_filepath_merge(&dir, "", path, APR_FILEPATH_NATIVE, pool);
+
+        if (rv == APR_SUCCESS)
+            rv = dir_make_parent(dir, perm, pool); /* Make intermediate dirs */
+        
+        if (rv == APR_SUCCESS)
+            rv = apr_dir_make (dir, perm, pool);   /* And complete the path */
+    }
+    return rv;
+}
+
+
+APR_DECLARE(apr_status_t) apr_dir_remove(const char *path, apr_pool_t *pool)
+{
+#if APR_HAS_UNICODE_FS
+    IF_WIN_OS_IS_UNICODE
+    {
+        apr_wchar_t wpath[APR_PATH_MAX];
+        apr_status_t rv;
+        if (rv = utf8_to_unicode_path(wpath, sizeof(wpath) 
+                                              / sizeof(apr_wchar_t), path)) {
+            return rv;
+        }
+        if (!RemoveDirectoryW(wpath)) {
+            return apr_get_os_error();
+        }
+    }
+#endif
+#if APR_HAS_ANSI_FS
+    ELSE_WIN_OS_IS_ANSI
+        if (!RemoveDirectory(path)) {
+            return apr_get_os_error();
+        }
+#endif
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_os_dir_get(apr_os_dir_t **thedir,
+                                         apr_dir_t *dir)
+{
+    if (dir == NULL) {
+        return APR_ENODIR;
+    }
+    *thedir = dir->dirhand;
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_os_dir_put(apr_dir_t **dir,
+                                         apr_os_dir_t *thedir,
+                                         apr_pool_t *pool)
+{
+    return APR_ENOTIMPL;
+}
diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/file_io/win32/filedup.c b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/win32/filedup.c
new file mode 100644
index 00000000..8aaf6df2
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/win32/filedup.c
@@ -0,0 +1,216 @@
+/* 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 "win32/apr_arch_file_io.h"
+#include "apr_file_io.h"
+#include "apr_general.h"
+#include "apr_strings.h"
+#include <string.h>
+#include "apr_arch_inherit.h"
+#include <io.h> /* for [_open/_get]_osfhandle */
+
+
+APR_DECLARE(apr_status_t) apr_file_dup(apr_file_t **new_file,
+                                       apr_file_t *old_file, apr_pool_t *p)
+{
+#ifdef _WIN32_WCE
+    return APR_ENOTIMPL;
+#else
+    HANDLE hproc = GetCurrentProcess();
+    HANDLE newhand = NULL;
+
+    if (!DuplicateHandle(hproc, old_file->filehand, 
+                         hproc, &newhand, 0, FALSE, 
+                         DUPLICATE_SAME_ACCESS)) {
+        return apr_get_os_error();
+    }
+
+    (*new_file) = (apr_file_t *) apr_pcalloc(p, sizeof(apr_file_t));
+    (*new_file)->filehand = newhand;
+    (*new_file)->flags = old_file->flags & ~(APR_STD_FLAGS | APR_INHERIT);
+    (*new_file)->pool = p;
+    (*new_file)->fname = apr_pstrdup(p, old_file->fname);
+    (*new_file)->append = old_file->append;
+    (*new_file)->buffered = FALSE;
+    (*new_file)->ungetchar = old_file->ungetchar;
+
+#if APR_HAS_THREADS
+    if (old_file->mutex) {
+        apr_thread_mutex_create(&((*new_file)->mutex),
+                                APR_THREAD_MUTEX_DEFAULT, p);
+    }
+#endif
+
+    apr_pool_cleanup_register((*new_file)->pool, (void *)(*new_file), file_cleanup,
+                        apr_pool_cleanup_null);
+
+    return APR_SUCCESS;
+#endif /* !defined(_WIN32_WCE) */
+}
+
+APR_DECLARE(apr_status_t) apr_file_dup2(apr_file_t *new_file,
+                                        apr_file_t *old_file, apr_pool_t *p)
+{
+#ifdef _WIN32_WCE
+    return APR_ENOTIMPL;
+#else
+    DWORD stdhandle = 0;
+    HANDLE hproc = GetCurrentProcess();
+    HANDLE newhand = NULL;
+    apr_int32_t newflags;
+    int fd;
+
+    if (new_file->flags & APR_STD_FLAGS)
+    {
+        if ((new_file->flags & APR_STD_FLAGS) == APR_STDERR_FLAG)
+        {
+            /* Flush stderr and unset its buffer, then commit the fd-based buffer.
+             * This is typically a noop for Win2K/XP since services with NULL std
+             * handles [but valid FILE *'s, oddly enough], but is required
+             * for NT 4.0 and to use this code outside of services.
+             */
+            fflush(stderr);
+            setvbuf(stderr, NULL, _IONBF, 0);
+            _commit(2 /* stderr */);
+
+            /* Clone a handle can _close() without harming the source handle,
+             * open an MSVCRT-based pseudo-fd for the file handle, then dup2
+             * and close our temporary pseudo-fd once it's been duplicated.
+             * This will incidently keep the FILE-based stderr in sync.
+             * Note the apparently redundant _O_BINARY coersions are required.
+             * Note the _dup2 will close the previous std Win32 handle.
+             */
+            if (!DuplicateHandle(hproc, old_file->filehand, hproc, &newhand,
+                                 0, FALSE, DUPLICATE_SAME_ACCESS)) {
+                return apr_get_os_error();
+            }
+            fd = _open_osfhandle((INT_PTR)newhand, _O_WRONLY | _O_BINARY);
+            _dup2(fd, 2);
+            _close(fd);
+            _setmode(2, _O_BINARY);
+
+            /* hPipeWrite was _close()'ed above, and _dup2()'ed
+             * to fd 2 creating a new, inherited Win32 handle.
+             * Recover that real handle from fd 2.  Note that
+             * SetStdHandle(STD_ERROR_HANDLE, _get_osfhandle(2))
+             * is implicit in the dup2() call above
+             */
+            newhand = (HANDLE)_get_osfhandle(2);
+        }
+        else if ((new_file->flags & APR_STD_FLAGS) == APR_STDOUT_FLAG) {
+            /* For the process flow see the stderr case above */
+            fflush(stdout);
+            setvbuf(stdout, NULL, _IONBF, 0);
+            _commit(1 /* stdout */);
+
+            if (!DuplicateHandle(hproc, old_file->filehand, hproc, &newhand,
+                                 0, FALSE, DUPLICATE_SAME_ACCESS)) {
+                return apr_get_os_error();
+            }
+            fd = _open_osfhandle((INT_PTR)newhand, _O_WRONLY | _O_BINARY);
+            _dup2(fd, 1);
+            _close(fd);
+            _setmode(1, _O_BINARY);
+            newhand = (HANDLE)_get_osfhandle(1);
+        }
+        else if ((new_file->flags & APR_STD_FLAGS) == APR_STDIN_FLAG) {
+            /* For the process flow see the stderr case above */
+            fflush(stdin);
+            setvbuf(stdin, NULL, _IONBF, 0);
+            _commit(0 /* stdin */);
+
+            if (!DuplicateHandle(hproc, old_file->filehand, hproc, &newhand,
+                                 0, FALSE, DUPLICATE_SAME_ACCESS)) {
+                return apr_get_os_error();
+            }
+            fd = _open_osfhandle((INT_PTR)newhand, _O_RDONLY | _O_BINARY);
+            _dup2(fd, 0);
+            _close(fd);
+            _setmode(0, _O_BINARY);
+            newhand = (HANDLE)_get_osfhandle(0);
+        }
+        newflags = (new_file->flags & APR_STD_FLAGS) 
+                 | (old_file->flags & ~APR_STD_FLAGS) | APR_INHERIT;
+
+        /* No need  to close the old file, _dup2() above did that for us */
+    }
+    else {
+        if (!DuplicateHandle(hproc, old_file->filehand, 
+                             hproc, &newhand, 0,
+                             FALSE, DUPLICATE_SAME_ACCESS)) {
+            return apr_get_os_error();
+        }
+        newflags = old_file->flags & ~(APR_STD_FLAGS | APR_INHERIT);
+
+        if (new_file->filehand
+                && (new_file->filehand != INVALID_HANDLE_VALUE)) {
+            CloseHandle(new_file->filehand);
+        }
+    }
+
+    new_file->flags = newflags;
+    new_file->filehand = newhand;
+    new_file->fname = apr_pstrdup(new_file->pool, old_file->fname);
+    new_file->append = old_file->append;
+    new_file->buffered = FALSE;
+    new_file->ungetchar = old_file->ungetchar;
+
+#if APR_HAS_THREADS
+    if (old_file->mutex) {
+        apr_thread_mutex_create(&(new_file->mutex),
+                                APR_THREAD_MUTEX_DEFAULT, p);
+    }
+#endif
+
+    return APR_SUCCESS;
+#endif /* !defined(_WIN32_WCE) */
+}
+
+APR_DECLARE(apr_status_t) apr_file_setaside(apr_file_t **new_file,
+                                            apr_file_t *old_file,
+                                            apr_pool_t *p)
+{
+    *new_file = (apr_file_t *)apr_palloc(p, sizeof(apr_file_t));
+    memcpy(*new_file, old_file, sizeof(apr_file_t));
+    (*new_file)->pool = p;
+    if (old_file->buffered) {
+        (*new_file)->buffer = apr_palloc(p, APR_FILE_BUFSIZE);
+        if (old_file->direction == 1) {
+            memcpy((*new_file)->buffer, old_file->buffer, old_file->bufpos);
+        }
+        else {
+            memcpy((*new_file)->buffer, old_file->buffer, old_file->dataRead);
+        }
+    }
+    if (old_file->mutex) {
+        apr_thread_mutex_create(&((*new_file)->mutex),
+                                APR_THREAD_MUTEX_DEFAULT, p);
+        apr_thread_mutex_destroy(old_file->mutex);
+    }
+    if (old_file->fname) {
+        (*new_file)->fname = apr_pstrdup(p, old_file->fname);
+    }
+    if (!(old_file->flags & APR_FILE_NOCLEANUP)) {
+        apr_pool_cleanup_register(p, (void *)(*new_file), 
+                                  file_cleanup,
+                                  file_cleanup);
+    }
+
+    old_file->filehand = INVALID_HANDLE_VALUE;
+    apr_pool_cleanup_kill(old_file->pool, (void *)old_file,
+                          file_cleanup);
+    return APR_SUCCESS;
+}
diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/file_io/win32/filepath.c b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/win32/filepath.c
new file mode 100644
index 00000000..f3c1b77b
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/win32/filepath.c
@@ -0,0 +1,985 @@
+/* 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"
+#include "apr_private.h"
+#include "apr_arch_file_io.h"
+#include "apr_strings.h"
+#include "apr_lib.h"
+#include <string.h>
+#include <ctype.h>
+
+#ifdef NETWARE
+#include <unistd.h>
+#include <fsio.h>
+#endif
+
+ /* WinNT accepts several odd forms of a 'root' path.  Under Unicode
+ * calls (ApiFunctionW) the //?/C:/foo or //?/UNC/mach/share/foo forms
+ * are accepted.  Ansi and Unicode functions both accept the //./C:/foo 
+ * form under WinNT/2K.  Since these forms are handled in the utf-8 to 
+ * unicode translation phase, we don't want the user confused by them, so 
+ * we will accept them but always return the canonical C:/ or //mach/share/
+ *
+ * OS2 appears immune from the nonsense :)
+ */
+
+APR_DECLARE(apr_status_t) apr_filepath_root(const char **rootpath, 
+                                            const char **inpath, 
+                                            apr_int32_t flags,
+                                            apr_pool_t *p)
+{
+    const char *testpath = *inpath;
+    char *newpath;
+#ifdef NETWARE
+    char seperator[2] = { 0, 0};
+    char server[APR_PATH_MAX+1];
+    char volume[APR_PATH_MAX+1];
+    char file[APR_PATH_MAX+1];
+    char *volsep = NULL;
+    int elements;
+
+    if (inpath && *inpath)
+        volsep = strchr (*inpath, ':');
+    else
+        return APR_EBADPATH;
+
+    if (strlen(*inpath) > APR_PATH_MAX) {
+        return APR_EBADPATH;
+    }
+
+    seperator[0] = (flags & APR_FILEPATH_NATIVE) ? '\\' : '/';
+
+    /* Allocate and initialize each of the segment buffers
+    */
+    server[0] = volume[0] = file[0] = '\0';
+
+    /* If we don't have a volume separator then don't bother deconstructing
+        the path since we won't use the deconstructed information anyway.
+    */
+    if (volsep) {
+        /* Split the inpath into its separate parts. */
+        deconstruct(testpath, server, volume, NULL, file, NULL, &elements, PATH_UNDEF);
+    
+        /* If we got a volume part then continue splitting out the root.
+            Otherwise we either have an incomplete or relative path
+        */
+        if (volume && strlen(volume) > 0) {
+            newpath = apr_pcalloc(p, strlen(server)+strlen(volume)+5);
+            construct(newpath, server, volume, NULL, NULL, NULL, PATH_NETWARE);
+
+            /* NetWare doesn't add the root slash so we need to add it manually.
+            */
+            strcat(newpath, seperator);
+            *rootpath = newpath;
+
+            /* Skip the inpath pointer down to the first non-root character
+            */
+            newpath = volsep;
+            do {
+                ++newpath;
+            } while (*newpath && ((*newpath == '/') || (*newpath == '\\')));
+            *inpath = newpath;
+
+            /* Need to handle APR_FILEPATH_TRUENAME checking here. */
+
+            return APR_SUCCESS;
+        }
+        else
+            return APR_EBADPATH;
+    }
+    else if ((**inpath == '/') || (**inpath == '\\')) {
+        /* if we have a root path without a volume then just split
+            in same manner as unix although this path will be
+            incomplete.
+        */
+        *rootpath = apr_pstrdup(p, seperator);
+        do {
+            ++(*inpath);
+        } while ((**inpath == '/') || (**inpath == '\\'));
+    }
+    else
+        return APR_ERELATIVE;
+
+    return APR_EINCOMPLETE;
+
+#else /* ndef(NETWARE) */
+
+    char seperator[2];
+    const char *delim1;
+    const char *delim2;
+
+    seperator[0] = (flags & APR_FILEPATH_NATIVE) ? '\\' : '/';
+    seperator[1] = 0;
+
+    if (testpath[0] == '/' || testpath[0] == '\\') {
+        if (testpath[1] == '/' || testpath[1] == '\\') {
+
+#ifdef WIN32 /* //server/share isn't the only // delimited syntax */
+            if ((testpath[2] == '?' || testpath[2] == '.')
+                    && (testpath[3] == '/' || testpath[3] == '\\')) {
+                if (IS_FNCHAR(testpath[4]) && testpath[5] == ':') 
+                {
+                    apr_status_t rv;
+                    testpath += 4;
+                    /* given  '//?/C: or //./C: let us try this
+                     * all over again from the drive designator
+                     */
+                    rv = apr_filepath_root(rootpath, &testpath, flags, p);
+                    if (!rv || rv == APR_EINCOMPLETE)
+                        *inpath = testpath;
+                    return rv;
+                }
+                else if (strncasecmp(testpath + 4, "UNC", 3) == 0
+                      && (testpath[7] == '/' || testpath[7] == '\\') 
+                      && (testpath[2] == '?')) {
+                    /* given  '//?/UNC/machine/share, a little magic 
+                     * at the end makes this all work out by using
+                     * 'C/machine' as the starting point and replacing
+                     * the UNC delimiters with \'s, including the 'C'
+                     */
+                    testpath += 6;
+                }
+                else
+                    /* This must not be a path to a file, but rather
+                     * a volume or device.  Die for now.
+                     */
+                    return APR_EBADPATH;
+            }
+#endif /* WIN32 (non - //server/share syntax) */
+
+            /* Evaluate path of '//[machine/[share[/]]]' */
+            delim1 = testpath + 2;
+            do {
+                /* Protect against //X/ where X is illegal */
+                if (*delim1 && !IS_FNCHAR(*(delim1++)))
+                    return APR_EBADPATH;
+            } while (*delim1 && *delim1 != '/' && *delim1 != '\\');
+
+            if (*delim1) {
+                apr_status_t rv;
+                delim2 = delim1 + 1;
+                while (*delim2 && *delim2 != '/' && *delim2 != '\\') {
+                    /* Protect against //machine/X/ where X is illegal */
+                    if (!IS_FNCHAR(*(delim2++)))
+                        return APR_EBADPATH;
+                } 
+
+                /* Copy the '//machine/[share[/]]' path, always providing 
+                 * an extra byte for the trailing slash.
+                 */
+                newpath = apr_pstrmemdup(p, testpath, delim2 - testpath + 1);
+
+                if (delim2 == delim1 + 1) {
+                    /* We found simply \\machine\, so give up already
+                     */
+                    *rootpath = newpath;
+                    *inpath = delim2;
+                    return APR_EINCOMPLETE;
+                }
+
+                if (flags & APR_FILEPATH_TRUENAME) {
+                    /* Validate the \\Machine\Share\ designation, 
+                     * Win32 will argue about slashed in UNC paths, 
+                     * so use backslashes till we finish testing,
+                     * and add the trailing backslash [required].
+                     * apr_pstrmemdup above guarentees us the new 
+                     * trailing null character.
+                     */
+                    newpath[0] = '\\';
+                    newpath[1] = '\\';
+                    newpath[delim1 - testpath] = '\\';
+                    newpath[delim2 - testpath] = '\\';
+
+                    rv = filepath_root_test(newpath, p);
+                    if (rv)
+                        return rv;
+                    rv = filepath_root_case(&newpath, newpath, p);
+                    if (rv)
+                        return rv;
+                    newpath[0] = seperator[0];
+                    newpath[1] = seperator[0];
+                    newpath[delim1 - testpath] = seperator[0];
+                    newpath[delim2 - testpath] = (*delim2 ? seperator[0] : '\0');
+                }
+                else {                
+                    /* Give back the caller's own choice of delimiters
+                     */
+                    newpath[0] = testpath[0];
+                    newpath[1] = testpath[1];
+                    newpath[delim1 - testpath] = *delim1;
+                    newpath[delim2 - testpath] = *delim2;
+                }
+
+                /* If this root included the trailing / or \ designation 
+                 * then lop off multiple trailing slashes and give back
+                 * appropriate delimiters.
+                 */
+                if (*delim2) {
+                    *inpath = delim2 + 1;
+                    while (**inpath == '/' || **inpath == '\\')
+                        ++*inpath;
+                }
+                else {
+                    *inpath = delim2;
+                }
+
+                *rootpath = newpath;
+                return APR_SUCCESS;
+            }
+            
+            /* Have path of '\\[machine]', if the machine is given,
+             * append same trailing slash as the leading slash
+             */
+            delim1 = strchr(testpath, '\0');
+            if (delim1 > testpath + 2) {
+                newpath = apr_pstrndup(p, testpath, delim1 - testpath + 1);
+                if (flags & APR_FILEPATH_TRUENAME)
+                    newpath[delim1 - testpath] = seperator[0];
+                else
+                    newpath[delim1 - testpath] = newpath[0];
+                newpath[delim1 - testpath + 1] = '\0';
+            }
+            else {
+                newpath = apr_pstrndup(p, testpath, delim1 - testpath);
+            }
+            if (flags & APR_FILEPATH_TRUENAME) {
+                newpath[0] = seperator[0];
+                newpath[1] = seperator[0];
+            }
+            *rootpath = newpath;
+            *inpath = delim1;
+            return APR_EINCOMPLETE;
+        }
+
+        /* Left with a path of '/', what drive are we asking about? 
+         */
+        *inpath = testpath + 1;
+        newpath = apr_palloc(p, 2);
+        if (flags & APR_FILEPATH_TRUENAME)
+            newpath[0] = seperator[0];
+        else
+            newpath[0] = testpath[0];
+        newpath[1] = '\0';
+        *rootpath = newpath;
+        return APR_EINCOMPLETE;
+    }
+
+    /* Evaluate path of 'd:[/]' */
+    if (IS_FNCHAR(*testpath) && testpath[1] == ':') 
+    {
+        apr_status_t rv;
+        /* Validate that D:\ drive exists, test must be rooted
+         * Note that posix/win32 insists a drive letter is upper case,
+         * so who are we to argue with a 'feature'.
+         * It is a safe fold, since only A-Z is legal, and has no
+         * side effects of legal mis-mapped non-us-ascii codes.
+         */
+        newpath = apr_palloc(p, 4);
+        newpath[0] = testpath[0];
+        newpath[1] = testpath[1];
+        newpath[2] = seperator[0];
+        newpath[3] = '\0';
+        if (flags & APR_FILEPATH_TRUENAME) {
+            newpath[0] = apr_toupper(newpath[0]);
+            rv = filepath_root_test(newpath, p);
+            if (rv)
+                return rv;
+        }
+        /* Just give back the root the user handed to us.
+         */
+        if (testpath[2] != '/' && testpath[2] != '\\') {
+            newpath[2] = '\0';
+            *rootpath = newpath;
+            *inpath = testpath + 2;
+            return APR_EINCOMPLETE;
+        }
+
+        /* strip off remaining slashes that designate the root,
+         * give the caller back their original choice of slash
+         * unless this is TRUENAME'ed
+         */
+        *inpath = testpath + 3;
+        while (**inpath == '/' || **inpath == '\\')
+            ++*inpath;
+        if (!(flags & APR_FILEPATH_TRUENAME))
+            newpath[2] = testpath[2];
+        *rootpath = newpath;
+        return APR_SUCCESS;
+    }
+
+    /* Nothing interesting */
+    return APR_ERELATIVE;
+
+#endif /* ndef(NETWARE) */
+}
+
+
+APR_DECLARE(apr_status_t) apr_filepath_merge(char **newpath, 
+                                             const char *basepath, 
+                                             const char *addpath, 
+                                             apr_int32_t flags,
+                                             apr_pool_t *p)
+{
+    char path[APR_PATH_MAX]; /* isn't null term */
+    const char *baseroot = NULL;
+    const char *addroot;
+    apr_size_t rootlen; /* the length of the root portion of path, d:/ is 3 */
+    apr_size_t baselen; /* the length of basepath (excluding baseroot) */
+    apr_size_t keptlen; /* the length of the retained basepath (incl root) */
+    apr_size_t pathlen; /* the length of the result path */
+    apr_size_t segend;  /* the end of the current segment */
+    apr_size_t seglen;  /* the length of the segment (excl trailing chars) */
+    apr_status_t basetype = 0; /* from parsing the basepath's baseroot */
+    apr_status_t addtype;      /* from parsing the addpath's addroot */
+    apr_status_t rv;
+#ifndef NETWARE
+    int fixunc = 0;  /* flag to complete an incomplete UNC basepath */
+#endif
+    
+    /* Treat null as an empty path, otherwise split addroot from the addpath
+     */
+    if (!addpath) {
+        addpath = addroot = "";
+        addtype = APR_ERELATIVE;
+    }
+    else {
+        /* This call _should_ test the path
+         */
+        addtype = apr_filepath_root(&addroot, &addpath, 
+                                    APR_FILEPATH_TRUENAME
+                                    | (flags & APR_FILEPATH_NATIVE),
+                                    p);
+        if (addtype == APR_SUCCESS) {
+            addtype = APR_EABSOLUTE;
+        }
+        else if (addtype == APR_ERELATIVE) {
+            addroot = "";
+        }
+        else if (addtype != APR_EINCOMPLETE) {
+            /* apr_filepath_root was incomprehensible so fail already
+             */
+            return addtype;
+        }
+    }
+
+    /* If addpath is (even partially) rooted, then basepath is
+     * unused.  Ths violates any APR_FILEPATH_SECUREROOTTEST 
+     * and APR_FILEPATH_NOTABSOLUTE flags specified.
+     */
+    if (addtype == APR_EABSOLUTE || addtype == APR_EINCOMPLETE)
+    {
+        if (flags & APR_FILEPATH_SECUREROOTTEST)
+            return APR_EABOVEROOT;
+        if (flags & APR_FILEPATH_NOTABSOLUTE)
+            return addtype;
+    }
+
+    /* Optimized tests before we query the current working path
+     */
+    if (!basepath) {
+
+        /* If APR_FILEPATH_NOTABOVEROOT wasn't specified,
+         * we won't test the root again, it's ignored.
+         * Waste no CPU retrieving the working path.
+         */
+        if (addtype == APR_EABSOLUTE && !(flags & APR_FILEPATH_NOTABOVEROOT)) {
+            basepath = baseroot = "";
+            basetype = APR_ERELATIVE;
+        }
+
+        /* If APR_FILEPATH_NOTABSOLUTE is specified, the caller 
+         * requires an absolutely relative result, So do not retrieve 
+         * the working path.
+         */
+        if (addtype == APR_ERELATIVE && (flags & APR_FILEPATH_NOTABSOLUTE)) {
+            basepath = baseroot = "";
+            basetype = APR_ERELATIVE;
+        }
+    }
+
+    if (!basepath) 
+    {
+        /* Start with the current working path.  This is bass akwards,
+         * but required since the compiler (at least vc) doesn't like
+         * passing the address of a char const* for a char** arg.
+         * We must grab the current path of the designated drive 
+         * if addroot is given in drive-relative form (e.g. d:foo)
+         */
+        char *getpath;
+#ifndef NETWARE
+        if (addtype == APR_EINCOMPLETE && addroot[1] == ':')
+            rv = filepath_drive_get(&getpath, addroot[0], flags, p);
+        else
+#endif
+            rv = apr_filepath_get(&getpath, flags, p);
+        if (rv != APR_SUCCESS)
+            return rv;
+        basepath = getpath;
+    }
+
+    if (!baseroot) {
+        /* This call should _not_ test the path
+         */
+        basetype = apr_filepath_root(&baseroot, &basepath,
+                                     (flags & APR_FILEPATH_NATIVE), p);
+        if (basetype == APR_SUCCESS) {
+            basetype = APR_EABSOLUTE;
+        }
+        else if (basetype == APR_ERELATIVE) {
+            baseroot = "";
+        }
+        else if (basetype != APR_EINCOMPLETE) {
+            /* apr_filepath_root was incomprehensible so fail already
+             */
+            return basetype;
+        }
+    }
+    baselen = strlen(basepath);
+
+    /* If APR_FILEPATH_NOTABSOLUTE is specified, the caller 
+     * requires an absolutely relative result.  If the given 
+     * basepath is not relative then fail.
+     */
+    if ((flags & APR_FILEPATH_NOTABSOLUTE) && basetype != APR_ERELATIVE)
+        return basetype;
+
+    /* The Win32 nightmare on unc street... start combining for
+     * many possible root combinations.
+     */
+    if (addtype == APR_EABSOLUTE)
+    {
+        /* Ignore the given root path, and start with the addroot
+         */
+        if ((flags & APR_FILEPATH_NOTABOVEROOT) 
+                && strncmp(baseroot, addroot, strlen(baseroot)))
+            return APR_EABOVEROOT;
+        keptlen = 0;
+        rootlen = pathlen = strlen(addroot);
+        memcpy(path, addroot, pathlen);
+    }
+    else if (addtype == APR_EINCOMPLETE)
+    {
+        /* There are several types of incomplete paths, 
+         *     incomplete UNC paths         (//foo/ or //),
+         *     drives without rooted paths  (d: as in d:foo), 
+         * and simple roots                 (/ as in /foo).
+         * Deal with these in significantly different manners...
+         */
+#ifndef NETWARE
+        if ((addroot[0] == '/' || addroot[0] == '\\') &&
+            (addroot[1] == '/' || addroot[1] == '\\')) 
+        {
+            /* Ignore the given root path if the incomplete addpath is UNC,
+             * (note that the final result will be incomplete).
+             */
+            if (flags & APR_FILEPATH_NOTRELATIVE)
+                return addtype;
+            if ((flags & APR_FILEPATH_NOTABOVEROOT) 
+                    && strncmp(baseroot, addroot, strlen(baseroot)))
+                return APR_EABOVEROOT;
+            fixunc = 1;
+            keptlen = 0;
+            rootlen = pathlen = strlen(addroot);
+            memcpy(path, addroot, pathlen);
+        }
+        else
+#endif            
+        if ((addroot[0] == '/' || addroot[0] == '\\') && !addroot[1]) 
+        {
+            /* Bring together the drive or UNC root from the baseroot
+             * if the addpath is a simple root and basepath is rooted,
+             * otherwise disregard the basepath entirely.
+             */
+            if (basetype != APR_EABSOLUTE && (flags & APR_FILEPATH_NOTRELATIVE))
+                return basetype;
+            if (basetype != APR_ERELATIVE) {
+#ifndef NETWARE
+                if (basetype == APR_INCOMPLETE 
+                        && (baseroot[0] == '/' || baseroot[0] == '\\')
+                        && (baseroot[1] == '/' || baseroot[1] == '\\'))
+                    fixunc = 1;
+#endif
+                keptlen = rootlen = pathlen = strlen(baseroot);
+                memcpy(path, baseroot, pathlen);
+            }
+            else {
+                if (flags & APR_FILEPATH_NOTABOVEROOT)
+                    return APR_EABOVEROOT;
+                keptlen = 0;
+                rootlen = pathlen = strlen(addroot);
+                memcpy(path, addroot, pathlen);
+            }
+        }
+#ifdef NETWARE
+        else if (filepath_has_drive(addroot, DRIVE_ONLY, p)) 
+        {
+            /* If the addroot is a drive (without a volume root)
+             * use the basepath _if_ it matches this drive letter!
+             * Otherwise we must discard the basepath.
+             */
+            if (!filepath_compare_drive(addroot, baseroot, p) && 
+                filepath_has_drive(baseroot, 0, p)) {
+#else
+        else if (addroot[0] && addroot[1] == ':' && !addroot[2]) 
+        {
+            /* If the addroot is a drive (without a volume root)
+             * use the basepath _if_ it matches this drive letter!
+             * Otherwise we must discard the basepath.
+             */
+            if (addroot[0] == baseroot[0] && baseroot[1] == ':') {
+#endif
+                /* Base the result path on the basepath
+                 */
+                if (basetype != APR_EABSOLUTE && (flags & APR_FILEPATH_NOTRELATIVE))
+                    return basetype;
+                rootlen = strlen(baseroot);
+                keptlen = pathlen = rootlen + baselen;
+                if (keptlen >= sizeof(path))
+                    return APR_ENAMETOOLONG;
+                memcpy(path, baseroot, rootlen);
+                memcpy(path + rootlen, basepath, baselen);
+            } 
+            else {
+                if (flags & APR_FILEPATH_NOTRELATIVE)
+                    return addtype;
+                if (flags & APR_FILEPATH_NOTABOVEROOT)
+                    return APR_EABOVEROOT;
+                keptlen = 0;
+                rootlen = pathlen = strlen(addroot);
+                memcpy(path, addroot, pathlen);
+            }
+        }
+        else {
+            /* Now this is unexpected, we aren't aware of any other
+             * incomplete path forms!  Fail now.
+             */
+            return APR_EBADPATH;
+        }
+    }
+    else { /* addtype == APR_ERELATIVE */
+        /* If both paths are relative, fail early
+         */
+        if (basetype != APR_EABSOLUTE && (flags & APR_FILEPATH_NOTRELATIVE))
+            return basetype;
+
+#ifndef NETWARE
+        /* An incomplete UNC path must be completed
+         */
+        if (basetype == APR_INCOMPLETE 
+                && (baseroot[0] == '/' || baseroot[0] == '\\')
+                && (baseroot[1] == '/' || baseroot[1] == '\\'))
+            fixunc = 1;
+#endif
+
+        /* Base the result path on the basepath
+         */
+        rootlen = strlen(baseroot);
+        keptlen = pathlen = rootlen + baselen;
+        if (keptlen >= sizeof(path))
+            return APR_ENAMETOOLONG;
+        memcpy(path, baseroot, rootlen);
+        memcpy(path + rootlen, basepath, baselen);
+    }
+
+    /* '/' terminate the given root path unless it's already terminated
+     * or is an incomplete drive root.  Correct the trailing slash unless
+     * we have an incomplete UNC path still to fix.
+     */
+    if (pathlen && path[pathlen - 1] != ':') {
+        if (path[pathlen - 1] != '/' && path[pathlen - 1] != '\\') {
+            if (pathlen + 1 >= sizeof(path))
+                return APR_ENAMETOOLONG;
+        
+            path[pathlen++] = ((flags & APR_FILEPATH_NATIVE) ? '\\' : '/');
+        }
+    /*  XXX: wrong, but gotta figure out what I intended;
+     *  else if (!fixunc)
+     *      path[pathlen++] = ((flags & APR_FILEPATH_NATIVE) ? '\\' : '/');
+     */
+    }
+
+    while (*addpath) 
+    {
+        /* Parse each segment, find the closing '/' 
+         */
+        seglen = 0;
+        while (addpath[seglen] && addpath[seglen] != '/'
+                               && addpath[seglen] != '\\')
+            ++seglen;
+
+        /* Truncate all trailing spaces and all but the first two dots */
+        segend = seglen;
+        while (seglen && (addpath[seglen - 1] == ' ' 
+                       || addpath[seglen - 1] == '.')) {
+            if (seglen > 2 || addpath[seglen - 1] != '.' || addpath[0] != '.')
+                --seglen;
+            else
+                break;
+        }
+
+        if (seglen == 0 || (seglen == 1 && addpath[0] == '.')) 
+        {
+            /* NOTE: win32 _hates_ '/ /' and '/. /' (yes, with spaces in there)
+             * so eliminate all preconceptions that it is valid.
+             */
+            if (seglen < segend)
+                return APR_EBADPATH;
+
+#ifndef NETWARE
+            /* This isn't legal unless the unc path is completed
+             */
+            if (fixunc)
+                return APR_EBADPATH;
+#endif
+
+            /* Otherwise, this is a noop segment (/ or ./) so ignore it 
+             */
+        }
+        else if (seglen == 2 && addpath[0] == '.' && addpath[1] == '.') 
+        {
+            /* NOTE: win32 _hates_ '/.. /' (yes, with a space in there)
+             * and '/..../', some functions treat it as ".", and some 
+             * fail! Eliminate all preconceptions that they are valid.
+             */
+            if (seglen < segend && (seglen != 3 || addpath[2] != '.'))
+                return APR_EBADPATH;
+
+#ifndef NETWARE
+            /* This isn't legal unless the unc path is completed
+             */
+            if (fixunc)
+                return APR_EBADPATH;
+#endif
+
+            /* backpath (../) when an absolute path is given */
+            if (rootlen && (pathlen <= rootlen)) 
+            {
+                /* Attempt to move above root.  Always die if the 
+                 * APR_FILEPATH_SECUREROOTTEST flag is specified.
+                 */
+                if (flags & APR_FILEPATH_SECUREROOTTEST)
+                    return APR_EABOVEROOT;
+                
+                /* Otherwise this is simply a noop, above root is root.
+                 */
+            }
+            else if (pathlen == 0 
+                      || (pathlen >= 3 
+                           && (pathlen == 3
+                                || path[pathlen - 4] == ':'
+                                || path[pathlen - 4] == '/' 
+                                || path[pathlen - 4] == '\\')
+                           &&  path[pathlen - 3] == '.' 
+                           &&  path[pathlen - 2] == '.' 
+                           && (path[pathlen - 1] == '/' 
+                                || path[pathlen - 1] == '\\')))
+            {
+                /* Verified path is empty, exactly "..[/\]", or ends
+                 * in "[:/\]..[/\]" - these patterns we will not back
+                 * over since they aren't 'prior segements'.
+                 * 
+                 * If APR_FILEPATH_SECUREROOTTEST.was given, die now.
+                 */
+                if (flags & APR_FILEPATH_SECUREROOTTEST)
+                    return APR_EABOVEROOT;
+
+                /* Otherwise append another backpath.
+                 */
+                if (pathlen + 3 >= sizeof(path))
+                    return APR_ENAMETOOLONG;
+                path[pathlen++] = '.';
+                path[pathlen++] = '.';
+                if (addpath[segend]) {
+                    path[pathlen++] = ((flags & APR_FILEPATH_NATIVE) 
+                                    ? '\\' : ((flags & APR_FILEPATH_TRUENAME)
+                                           ? '/' : addpath[segend]));
+                }
+                /* The 'root' part of this path now includes the ../ path,
+                 * because that backpath will not be parsed by the truename
+                 * code below.
+                 */
+                keptlen = pathlen;
+            }
+            else 
+            {
+                /* otherwise crop the prior segment 
+                 */
+                do {
+                    --pathlen;
+                } while (pathlen && path[pathlen - 1] != '/'
+                                 && path[pathlen - 1] != '\\');
+
+                /* Now test if we are above where we started and back up
+                 * the keptlen offset to reflect the added/altered path.
+                 */
+                if (pathlen < keptlen) 
+                {
+                    if (flags & APR_FILEPATH_SECUREROOTTEST)
+                        return APR_EABOVEROOT;
+                    keptlen = pathlen;
+                }
+            }
+        }
+        else /* not empty or dots */
+        {
+#ifndef NETWARE
+            if (fixunc) {
+                const char *testpath = path;
+                const char *testroot;
+                apr_status_t testtype;
+                apr_size_t i = (addpath[segend] != '\0');
+                
+                /* This isn't legal unless the unc path is complete!
+                 */
+                if (seglen < segend)
+                    return APR_EBADPATH;
+                if (pathlen + seglen + 1 >= sizeof(path))
+                    return APR_ENAMETOOLONG;
+                memcpy(path + pathlen, addpath, seglen + i);
+                
+                /* Always add the trailing slash to a UNC segment
+                 */
+                path[pathlen + seglen] = ((flags & APR_FILEPATH_NATIVE) 
+                                             ? '\\' : '/');
+                pathlen += seglen + 1;
+
+                /* Recanonicalize the UNC root with the new UNC segment,
+                 * and if we succeed, reset this test and the rootlen,
+                 * and replace our path with the canonical UNC root path
+                 */
+                path[pathlen] = '\0';
+                /* This call _should_ test the path
+                 */
+                testtype = apr_filepath_root(&testroot, &testpath, 
+                                             APR_FILEPATH_TRUENAME
+                                             | (flags & APR_FILEPATH_NATIVE),
+                                             p);
+                if (testtype == APR_SUCCESS) {
+                    rootlen = pathlen = (testpath - path);
+                    memcpy(path, testroot, pathlen);
+                    fixunc = 0;
+                }
+                else if (testtype != APR_EINCOMPLETE) {
+                    /* apr_filepath_root was very unexpected so fail already
+                     */
+                    return testtype;
+                }
+            }
+            else
+#endif
+            {
+                /* An actual segment, append it to the destination path
+                 */
+                apr_size_t i = (addpath[segend] != '\0');
+                if (pathlen + seglen + i >= sizeof(path))
+                    return APR_ENAMETOOLONG;
+                memcpy(path + pathlen, addpath, seglen + i);
+                if (i)
+                    path[pathlen + seglen] = ((flags & APR_FILEPATH_NATIVE) 
+                                                 ? '\\' : '/');
+                pathlen += seglen + i;
+            }
+        }
+
+        /* Skip over trailing slash to the next segment
+         */
+        if (addpath[segend])
+            ++segend;
+
+        addpath += segend;
+    }
+    
+    /* keptlen will be the baselen unless the addpath contained
+     * backpath elements.  If so, and APR_FILEPATH_NOTABOVEROOT
+     * is specified (APR_FILEPATH_SECUREROOTTEST was caught above),
+     * compare the string beyond the root to assure the result path 
+     * is still within given basepath.  Note that the root path 
+     * segment is thoroughly tested prior to path parsing.
+     */
+    if ((flags & APR_FILEPATH_NOTABOVEROOT) && baselen) {
+        if (memcmp(basepath, path + rootlen, baselen) != 0)
+            return APR_EABOVEROOT;
+ 
+         /* Ahem... if we have a basepath without a trailing slash,
+          * we better be sure that /foo wasn't replaced with /foobar!
+          */
+        if (basepath[baselen - 1] != '/' && basepath[baselen - 1] != '\\'
+              && path[rootlen + baselen] && path[rootlen + baselen] != '/' 
+                                         && path[rootlen + baselen] != '\\')
+            return APR_EABOVEROOT;
+    }
+
+    if (addpath && (flags & APR_FILEPATH_TRUENAME)) {
+        /* We can always skip the root, it's already true-named. */
+        if (rootlen > keptlen)
+            keptlen = rootlen;
+        if ((path[keptlen] == '/') || (path[keptlen] == '\\')) {
+            /* By rights, keptlen may grown longer than pathlen.
+             * we wont' use it again (in that case) so we don't care.
+             */
+            ++keptlen;
+        }
+        /* Go through all the new segments */
+        while (keptlen < pathlen) {
+            apr_finfo_t finfo;
+            char saveslash = 0;
+            seglen = 0;
+            /* find any slash and set it aside for a minute. */
+            for (seglen = 0; keptlen + seglen < pathlen; ++seglen) {
+                if ((path[keptlen + seglen] == '/')  ||
+                    (path[keptlen + seglen] == '\\')) {
+                    saveslash = path[keptlen + seglen];
+                    break;
+                }
+            }
+            /* Null term for stat! */
+            path[keptlen + seglen] = '\0';
+            if ((rv = apr_lstat(&finfo, path, 
+                                APR_FINFO_TYPE | APR_FINFO_NAME, p))
+                == APR_SUCCESS) {
+                apr_size_t namelen = strlen(finfo.name);
+
+#if defined(OS2) /* only has case folding, never aliases that change the length */
+
+                if (memcmp(finfo.name, path + keptlen, seglen) != 0) {
+                    memcpy(path + keptlen, finfo.name, namelen);
+                }
+#else /* WIN32 || NETWARE; here there be aliases that gire and gimble and change length */
+
+                if ((namelen != seglen) || 
+                    (memcmp(finfo.name, path + keptlen, seglen) != 0)) 
+                {
+                    if (namelen <= seglen) {
+                        memcpy(path + keptlen, finfo.name, namelen);
+                        if ((namelen < seglen) && saveslash) {
+                            memmove(path + keptlen + namelen + 1,
+                                   path + keptlen + seglen + 1,
+                                   pathlen - keptlen - seglen);
+                            pathlen += namelen - seglen;
+                            seglen = namelen;
+                        }
+                    }
+                    else { /* namelen > seglen */
+                        if (pathlen + namelen - seglen >= sizeof(path))
+                            return APR_ENAMETOOLONG;
+                        if (saveslash) {
+                            memmove(path + keptlen + namelen + 1,
+                                   path + keptlen + seglen + 1,
+                                   pathlen - keptlen - seglen);
+                        }
+                        memcpy(path + keptlen, finfo.name, namelen);
+                        pathlen += namelen - seglen;
+                        seglen = namelen;
+                    }
+                }
+#endif /* !OS2 (Whatever that alias was we're over it) */
+
+                /* That's it, the rest is path info. 
+                 * I don't know how we aught to handle this.  Should
+                 * we define a new error to indicate 'more info'?
+                 * Should we split out the rest of the path?
+                 */
+                if ((finfo.filetype != APR_DIR) && 
+                    (finfo.filetype != APR_LNK) && saveslash) 
+                    rv = APR_ENOTDIR;
+#ifdef XXX_FIGURE_THIS_OUT
+                {
+                    /* the example inserts a null between the end of 
+                     * the filename and the next segment, and increments
+                     * the path length so we would return both segments.
+                     */
+                    if (saveslash) {
+                        keptlen += seglen;
+                        path[keptlen] = saveslash;
+                        if (pathlen + 1 >= sizeof(path))
+                            return APR_ENAMETOOLONG;
+                        memmove(path + keptlen + 1,
+                               path + keptlen,
+                               pathlen - keptlen);
+                        path[keptlen] = '\0';
+                        ++pathlen;
+                        break;
+                    }
+                }
+#endif
+            }
+
+            /* put back the '/' */
+            if (saveslash) {
+                path[keptlen + seglen] = saveslash;
+                ++seglen;
+            }
+            keptlen += seglen;
+
+            if (rv != APR_SUCCESS) {
+                if (APR_STATUS_IS_ENOENT(rv))
+                    break;
+                if (APR_STATUS_IS_EPATHWILD(rv))
+                    /* This path included wildcards.  The path elements
+                     * that did not contain wildcards are canonicalized,
+                     * so we will return the path, although later elements
+                     * don't necessarily exist, and aren't canonical.
+                     */
+                    break;
+                else if (APR_STATUS_IS_ENOTDIR(rv))
+                    /* This is a little more serious, we just added a name
+                     * onto a filename (think http's PATH_INFO)
+                     * If the caller is foolish enough to do this, we expect
+                     * the've already canonicalized the root) that they knew
+                     * what they are doing :(
+                     */
+                    break;
+                else
+                    return rv;
+            }
+        }
+    }
+
+    *newpath = apr_pmemdup(p, path, pathlen + 1);
+    (*newpath)[pathlen] = '\0';
+    return APR_SUCCESS;
+}
+
+
+APR_DECLARE(apr_status_t) apr_filepath_list_split(apr_array_header_t **pathelts,
+                                                  const char *liststr,
+                                                  apr_pool_t *p)
+{
+    return apr_filepath_list_split_impl(pathelts, liststr, ';', p);
+}
+
+APR_DECLARE(apr_status_t) apr_filepath_list_merge(char **liststr,
+                                                  apr_array_header_t *pathelts,
+                                                  apr_pool_t *p)
+{
+    return apr_filepath_list_merge_impl(liststr, pathelts, ';', p);
+}
+
+
+APR_DECLARE(apr_status_t) apr_filepath_encoding(int *style, apr_pool_t *p)
+{
+#if APR_HAS_UNICODE_FS
+    IF_WIN_OS_IS_UNICODE
+    {
+        *style = APR_FILEPATH_ENCODING_UTF8;
+        return APR_SUCCESS;
+    }
+#endif
+
+    *style = APR_FILEPATH_ENCODING_LOCALE;
+    return APR_SUCCESS;
+}
diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/file_io/win32/filestat.c b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/win32/filestat.c
new file mode 100644
index 00000000..041b78de
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/win32/filestat.c
@@ -0,0 +1,767 @@
+/* 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"
+#include <aclapi.h>
+#include "apr_private.h"
+#include "apr_arch_file_io.h"
+#include "apr_file_io.h"
+#include "apr_general.h"
+#include "apr_strings.h"
+#include "apr_errno.h"
+#include "apr_time.h"
+#include <sys/stat.h>
+#include "apr_arch_atime.h"
+#include "apr_arch_misc.h"
+
+/* We have to assure that the file name contains no '*'s, or other
+ * wildcards when using FindFirstFile to recover the true file name.
+ */
+static apr_status_t test_safe_name(const char *name)
+{
+    /* Only accept ':' in the second position of the filename,
+     * as the drive letter delimiter:
+     */
+    if (apr_isalpha(*name) && (name[1] == ':')) {
+        name += 2;
+    }
+    while (*name) {
+        if (!IS_FNCHAR(*name) && (*name != '\\') && (*name != '/')) {
+            if (*name == '?' || *name == '*')
+                return APR_EPATHWILD;
+            else
+                return APR_EBADPATH;
+        }
+        ++name;
+    }
+    return APR_SUCCESS;
+}
+
+static apr_status_t free_localheap(void *heap) {
+    LocalFree(heap);
+    return APR_SUCCESS;
+}
+
+static apr_gid_t worldid = NULL;
+
+static void free_world(void)
+{
+    if (worldid) {
+        FreeSid(worldid);
+        worldid = NULL;
+    }
+}
+
+/* Left bit shifts from World scope to given scope */
+typedef enum prot_scope_e {
+    prot_scope_world = 0,
+    prot_scope_group = 4,
+    prot_scope_user =  8
+} prot_scope_e;
+
+static apr_fileperms_t convert_prot(ACCESS_MASK acc, prot_scope_e scope)
+{
+    /* These choices are based on the single filesystem bit that controls
+     * the given behavior.  They are -not- recommended for any set protection
+     * function, such a function should -set- use GENERIC_READ/WRITE/EXECUTE
+     */
+    apr_fileperms_t prot = 0;
+    if (acc & FILE_EXECUTE)
+        prot |= APR_WEXECUTE;
+    if (acc & FILE_WRITE_DATA)
+        prot |= APR_WWRITE;
+    if (acc & FILE_READ_DATA)
+        prot |= APR_WREAD;
+    return (prot << scope);
+}
+
+static void resolve_prot(apr_finfo_t *finfo, apr_int32_t wanted, PACL dacl)
+{
+    TRUSTEE_W ident = {NULL, NO_MULTIPLE_TRUSTEE, TRUSTEE_IS_SID};
+    ACCESS_MASK acc;
+    /*
+     * This function is only invoked for WinNT, 
+     * there is no reason for os_level testing here.
+     */
+    if ((wanted & APR_FINFO_WPROT) && !worldid) {
+        SID_IDENTIFIER_AUTHORITY SIDAuth = SECURITY_WORLD_SID_AUTHORITY;
+        if (AllocateAndInitializeSid(&SIDAuth, 1, SECURITY_WORLD_RID,
+                                     0, 0, 0, 0, 0, 0, 0, &worldid))
+            atexit(free_world);
+        else
+            worldid = NULL;
+    }
+    if ((wanted & APR_FINFO_UPROT) && (finfo->valid & APR_FINFO_USER)) {
+        ident.TrusteeType = TRUSTEE_IS_USER;
+        ident.ptstrName = finfo->user;
+        /* GetEffectiveRightsFromAcl isn't supported under Win9x,
+         * which shouldn't come as a surprize.  Since we are passing
+         * TRUSTEE_IS_SID, always skip the A->W layer.
+         */
+        if (GetEffectiveRightsFromAclW(dacl, &ident, &acc) == ERROR_SUCCESS) {
+            finfo->protection |= convert_prot(acc, prot_scope_user);
+            finfo->valid |= APR_FINFO_UPROT;
+        }
+    }
+    /* Windows NT: did not return group rights.
+     * Windows 2000 returns group rights information.
+     * Since WinNT kernels don't follow the unix model of 
+     * group associations, this all all pretty mute.
+     */
+    if ((wanted & APR_FINFO_GPROT) && (finfo->valid & APR_FINFO_GROUP)) {
+        ident.TrusteeType = TRUSTEE_IS_GROUP;
+        ident.ptstrName = finfo->group;
+        if (GetEffectiveRightsFromAclW(dacl, &ident, &acc) == ERROR_SUCCESS) {
+            finfo->protection |= convert_prot(acc, prot_scope_group);
+            finfo->valid |= APR_FINFO_GPROT;
+        }
+    }
+    if ((wanted & APR_FINFO_WPROT) && (worldid)) {
+        ident.TrusteeType = TRUSTEE_IS_WELL_KNOWN_GROUP;
+        ident.ptstrName = worldid;
+        if (GetEffectiveRightsFromAclW(dacl, &ident, &acc) == ERROR_SUCCESS) {
+            finfo->protection |= convert_prot(acc, prot_scope_world);
+            finfo->valid |= APR_FINFO_WPROT;
+        }
+    }
+}
+
+static apr_status_t resolve_ident(apr_finfo_t *finfo, const char *fname,
+                                  apr_int32_t wanted, apr_pool_t *pool)
+{
+    apr_file_t *thefile = NULL;
+    apr_status_t rv;
+    /* 
+     * NT5 (W2K) only supports symlinks in the same manner as mount points.
+     * This code should eventually take that into account, for now treat
+     * every reparse point as a symlink...
+     *
+     * We must open the file with READ_CONTROL if we plan to retrieve the
+     * user, group or permissions.
+     */
+    
+    if ((rv = apr_file_open(&thefile, fname, APR_OPENINFO
+                          | ((wanted & APR_FINFO_LINK) ? APR_OPENLINK : 0)
+                          | ((wanted & (APR_FINFO_PROT | APR_FINFO_OWNER))
+                                ? APR_READCONTROL : 0),
+                            APR_OS_DEFAULT, pool)) == APR_SUCCESS) {
+        rv = apr_file_info_get(finfo, wanted, thefile);
+        finfo->filehand = NULL;
+        apr_file_close(thefile);
+    }
+    else if (APR_STATUS_IS_EACCES(rv) && (wanted & (APR_FINFO_PROT 
+                                                  | APR_FINFO_OWNER))) {
+        /* We have a backup plan.  Perhaps we couldn't grab READ_CONTROL?
+         * proceed without asking for that permission...
+         */
+        if ((rv = apr_file_open(&thefile, fname, APR_OPENINFO
+                              | ((wanted & APR_FINFO_LINK) ? APR_OPENLINK : 0),
+                                APR_OS_DEFAULT, pool)) == APR_SUCCESS) {
+            rv = apr_file_info_get(finfo, wanted & ~(APR_FINFO_PROT 
+                                                 | APR_FINFO_OWNER),
+                                 thefile);
+            finfo->filehand = NULL;
+            apr_file_close(thefile);
+        }
+    }
+
+    if (rv != APR_SUCCESS && rv != APR_INCOMPLETE)
+        return (rv);
+
+    /* We picked up this case above and had opened the link's properties */
+    if (wanted & APR_FINFO_LINK)
+        finfo->valid |= APR_FINFO_LINK;
+
+    return rv;
+}
+
+static void guess_protection_bits(apr_finfo_t *finfo)
+{
+    /* Read, write execute for owner.  In the Win9x environment, any
+     * readable file is executable (well, not entirely 100% true, but
+     * still looking for some cheap logic that would help us here.)
+     * The same holds on NT if a file doesn't have a DACL (e.g., on FAT)
+     */
+    if (finfo->protection & APR_FREADONLY) {
+        finfo->protection |= APR_WREAD | APR_WEXECUTE;
+    }
+    else {
+        finfo->protection |= APR_WREAD | APR_WEXECUTE | APR_WWRITE;
+    }
+    finfo->protection |= (finfo->protection << prot_scope_group)
+                       | (finfo->protection << prot_scope_user);
+
+    finfo->valid |= APR_FINFO_UPROT | APR_FINFO_GPROT | APR_FINFO_WPROT;
+}
+
+apr_status_t more_finfo(apr_finfo_t *finfo, const void *ufile, 
+                        apr_int32_t wanted, int whatfile)
+{
+    PSID user = NULL, grp = NULL;
+    PACL dacl = NULL;
+    apr_status_t rv;
+
+    if (apr_os_level < APR_WIN_NT)
+        guess_protection_bits(finfo);
+    else if (wanted & (APR_FINFO_PROT | APR_FINFO_OWNER))
+    {
+        /* On NT this request is incredibly expensive, but accurate.
+         * Since the WinNT-only functions below are protected by the
+         * (apr_os_level < APR_WIN_NT) case above, we need no extra
+         * tests, but remember GetNamedSecurityInfo & GetSecurityInfo
+         * are not supported on 9x.
+         */
+        SECURITY_INFORMATION sinf = 0;
+        PSECURITY_DESCRIPTOR pdesc = NULL;
+        if (wanted & (APR_FINFO_USER | APR_FINFO_UPROT))
+            sinf |= OWNER_SECURITY_INFORMATION;
+        if (wanted & (APR_FINFO_GROUP | APR_FINFO_GPROT))
+            sinf |= GROUP_SECURITY_INFORMATION;
+        if (wanted & APR_FINFO_PROT)
+            sinf |= DACL_SECURITY_INFORMATION;
+        if (whatfile == MORE_OF_WFSPEC) {
+            apr_wchar_t *wfile = (apr_wchar_t*) ufile;
+            int fix = 0;
+            if (wcsncmp(wfile, L"\\\\?\\", 4) == 0) {
+                fix = 4;
+                if (wcsncmp(wfile + fix, L"UNC\\", 4) == 0)
+                    wfile[6] = L'\\', fix = 6;
+            }
+            rv = GetNamedSecurityInfoW(wfile + fix, 
+                                 SE_FILE_OBJECT, sinf,
+                                 ((wanted & (APR_FINFO_USER | APR_FINFO_UPROT)) ? &user : NULL),
+                                 ((wanted & (APR_FINFO_GROUP | APR_FINFO_GPROT)) ? &grp : NULL),
+                                 ((wanted & APR_FINFO_PROT) ? &dacl : NULL),
+                                 NULL, &pdesc);
+            if (fix == 6)
+                wfile[6] = L'C';
+        }
+        else if (whatfile == MORE_OF_FSPEC)
+            rv = GetNamedSecurityInfoA((char*)ufile, 
+                                 SE_FILE_OBJECT, sinf,
+                                 ((wanted & (APR_FINFO_USER | APR_FINFO_UPROT)) ? &user : NULL),
+                                 ((wanted & (APR_FINFO_GROUP | APR_FINFO_GPROT)) ? &grp : NULL),
+                                 ((wanted & APR_FINFO_PROT) ? &dacl : NULL),
+                                 NULL, &pdesc);
+        else if (whatfile == MORE_OF_HANDLE)
+            rv = GetSecurityInfo((HANDLE)ufile, 
+                                 SE_FILE_OBJECT, sinf,
+                                 ((wanted & (APR_FINFO_USER | APR_FINFO_UPROT)) ? &user : NULL),
+                                 ((wanted & (APR_FINFO_GROUP | APR_FINFO_GPROT)) ? &grp : NULL),
+                                 ((wanted & APR_FINFO_PROT) ? &dacl : NULL),
+                                 NULL, &pdesc);
+        else
+            return APR_INCOMPLETE;
+        if (rv == ERROR_SUCCESS)
+            apr_pool_cleanup_register(finfo->pool, pdesc, free_localheap, 
+                                 apr_pool_cleanup_null);
+        else
+            user = grp = dacl = NULL;
+
+        if (user) {
+            finfo->user = user;
+            finfo->valid |= APR_FINFO_USER;
+        }
+
+        if (grp) {
+            finfo->group = grp;
+            finfo->valid |= APR_FINFO_GROUP;
+        }
+
+        if (dacl) {
+            /* Retrieved the discresionary access list */
+            resolve_prot(finfo, wanted, dacl);
+        }
+        else if (wanted & APR_FINFO_PROT)
+            guess_protection_bits(finfo);
+    }
+
+    return ((wanted & ~finfo->valid) ? APR_INCOMPLETE : APR_SUCCESS);
+}
+
+
+/* This generic fillin depends upon byhandle to be passed as 0 when
+ * a WIN32_FILE_ATTRIBUTE_DATA or either WIN32_FIND_DATA [A or W] is
+ * passed for wininfo.  When the BY_HANDLE_FILE_INFORMATION structure
+ * is passed for wininfo, byhandle is passed as 1 to offset the one
+ * dword discrepancy in offset of the High/Low size structure members.
+ *
+ * The generic fillin returns 1 if the caller should further inquire
+ * if this is a CHR filetype.  If it's reasonably certain it can't be,
+ * then the function returns 0.
+ */
+int fillin_fileinfo(apr_finfo_t *finfo, 
+                    WIN32_FILE_ATTRIBUTE_DATA *wininfo, 
+                    int byhandle, apr_int32_t wanted) 
+{
+    DWORD *sizes = &wininfo->nFileSizeHigh + byhandle;
+    int warn = 0;
+
+    memset(finfo, '\0', sizeof(*finfo));
+
+    FileTimeToAprTime(&finfo->atime, &wininfo->ftLastAccessTime);
+    FileTimeToAprTime(&finfo->ctime, &wininfo->ftCreationTime);
+    FileTimeToAprTime(&finfo->mtime, &wininfo->ftLastWriteTime);
+
+#if APR_HAS_LARGE_FILES
+    finfo->size =  (apr_off_t)sizes[1]
+                | ((apr_off_t)sizes[0] << 32);
+#else
+    finfo->size = (apr_off_t)sizes[1];
+    if (finfo->size < 0 || sizes[0])
+        finfo->size = 0x7fffffff;
+#endif
+
+    if (wanted & APR_FINFO_LINK &&
+        wininfo->dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) {
+        finfo->filetype = APR_LNK;
+    }
+    else if (wininfo->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
+        finfo->filetype = APR_DIR;
+    }
+    else if (wininfo->dwFileAttributes & FILE_ATTRIBUTE_DEVICE) {
+        /* Warning: This test only succeeds on Win9x, on NT these files
+         * (con, aux, nul, lpt#, com# etc) escape early detection!
+         */
+        finfo->filetype = APR_CHR;
+    }
+    else {
+        /* Warning: Short of opening the handle to the file, the 'FileType'
+         * appears to be unknowable (in any trustworthy or consistent sense)
+         * on WinNT/2K as far as PIPE, CHR, etc are concerned.
+         */
+        if (!wininfo->ftLastWriteTime.dwLowDateTime 
+                && !wininfo->ftLastWriteTime.dwHighDateTime 
+                && !finfo->size)
+            warn = 1;
+        finfo->filetype = APR_REG;
+    }
+
+    /* The following flags are [for this moment] private to Win32.
+     * That's the only excuse for not toggling valid bits to reflect them.
+     */
+    if (wininfo->dwFileAttributes & FILE_ATTRIBUTE_READONLY)
+        finfo->protection = APR_FREADONLY;
+    
+    finfo->valid = APR_FINFO_ATIME | APR_FINFO_CTIME | APR_FINFO_MTIME
+                 | APR_FINFO_SIZE  | APR_FINFO_TYPE;   /* == APR_FINFO_MIN */
+
+    /* Only byhandle optionally tests link targets, so tell that caller
+     * what it wants to hear, otherwise the byattributes is never
+     * reporting anything but the link.
+     */
+    if (!byhandle || (wanted & APR_FINFO_LINK))
+        finfo->valid |= APR_FINFO_LINK;
+    return warn;
+}
+
+
+APR_DECLARE(apr_status_t) apr_file_info_get(apr_finfo_t *finfo, apr_int32_t wanted,
+                                            apr_file_t *thefile)
+{
+    BY_HANDLE_FILE_INFORMATION FileInfo;
+
+    if (thefile->buffered) {
+        /* XXX: flush here is not mutex protected */
+        apr_status_t rv = apr_file_flush(thefile);
+        if (rv != APR_SUCCESS)
+            return rv;
+    }
+
+    if (!GetFileInformationByHandle(thefile->filehand, &FileInfo)) {
+        return apr_get_os_error();
+    }
+
+    fillin_fileinfo(finfo, (WIN32_FILE_ATTRIBUTE_DATA *) &FileInfo, 1, wanted);
+
+    if (finfo->filetype == APR_REG)
+    {
+        /* Go the extra mile to be -certain- that we have a real, regular
+         * file, since the attribute bits aren't a certain thing.  Even
+         * though fillin should have hinted if we *must* do this, we
+         * don't need to take chances while the handle is already open.
+         */
+        DWORD FileType;
+        if (FileType = GetFileType(thefile->filehand)) {
+            if (FileType == FILE_TYPE_CHAR) {
+                finfo->filetype = APR_CHR;
+            }
+            else if (FileType == FILE_TYPE_PIPE) {
+                finfo->filetype = APR_PIPE;
+            }
+            /* Otherwise leave the original conclusion alone 
+             */
+        }
+    }
+
+    finfo->pool = thefile->pool;
+
+    /* ### The finfo lifetime may exceed the lifetime of thefile->pool
+     * but finfo's aren't managed in pools, so where on earth would
+     * we pstrdup the fname into???
+     */
+    finfo->fname = thefile->fname;
+ 
+    /* Extra goodies known only by GetFileInformationByHandle() */
+    finfo->inode  =  (apr_ino_t)FileInfo.nFileIndexLow
+                  | ((apr_ino_t)FileInfo.nFileIndexHigh << 32);
+    finfo->device = FileInfo.dwVolumeSerialNumber;
+    finfo->nlink  = FileInfo.nNumberOfLinks;
+
+    finfo->valid |= APR_FINFO_IDENT | APR_FINFO_NLINK;
+
+    /* If we still want something more (besides the name) go get it! 
+     */
+    if ((wanted &= ~finfo->valid) & ~APR_FINFO_NAME) {
+        return more_finfo(finfo, thefile->filehand, wanted, MORE_OF_HANDLE);
+    }
+
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_file_perms_set(const char *fname,
+                                           apr_fileperms_t perms)
+{
+    return APR_ENOTIMPL;
+}
+
+APR_DECLARE(apr_status_t) apr_stat(apr_finfo_t *finfo, const char *fname,
+                                   apr_int32_t wanted, apr_pool_t *pool)
+{
+    /* XXX: is constant - needs testing - which requires a lighter-weight root test fn */
+    int isroot = 0;
+    apr_status_t ident_rv = 0;
+    apr_status_t rv;
+#if APR_HAS_UNICODE_FS
+    apr_wchar_t wfname[APR_PATH_MAX];
+
+#endif
+    char *filename = NULL;
+    /* These all share a common subset of this structure */
+    union {
+        WIN32_FIND_DATAW w;
+        WIN32_FIND_DATAA n;
+        WIN32_FILE_ATTRIBUTE_DATA i;
+    } FileInfo;
+    
+    /* Catch fname length == MAX_PATH since GetFileAttributesEx fails 
+     * with PATH_NOT_FOUND.  We would rather indicate length error than 
+     * 'not found'
+     */        
+    if (strlen(fname) >= APR_PATH_MAX) {
+        return APR_ENAMETOOLONG;
+    }
+
+#if APR_HAS_UNICODE_FS
+    IF_WIN_OS_IS_UNICODE
+    {
+        if ((wanted & (APR_FINFO_IDENT | APR_FINFO_NLINK)) 
+               || (~wanted & APR_FINFO_LINK)) {
+            /* FindFirstFile and GetFileAttributesEx can't figure the inode,
+             * device or number of links, so we need to resolve with an open 
+             * file handle.  If the user has asked for these fields, fall over 
+             * to the get file info by handle method.  If we fail, or the user
+             * also asks for the file name, continue by our usual means.
+             *
+             * We also must use this method for a 'true' stat, that resolves
+             * a symlink (NTFS Junction) target.  This is because all fileinfo
+             * on a Junction always returns the junction, opening the target
+             * is the only way to resolve the target's attributes.
+             */
+            if ((ident_rv = resolve_ident(finfo, fname, wanted, pool)) 
+                    == APR_SUCCESS)
+                return ident_rv;
+            else if (ident_rv == APR_INCOMPLETE)
+                wanted &= ~finfo->valid;
+        }
+
+        if (rv = utf8_to_unicode_path(wfname, sizeof(wfname) 
+                                            / sizeof(apr_wchar_t), fname))
+            return rv;
+        if (!(wanted & APR_FINFO_NAME)) {
+            if (!GetFileAttributesExW(wfname, GetFileExInfoStandard, 
+                                      &FileInfo.i))
+                return apr_get_os_error();
+        }
+        else {
+            /* Guard against bogus wildcards and retrieve by name
+             * since we want the true name, and set aside a long
+             * enough string to handle the longest file name.
+             */
+            char tmpname[APR_FILE_MAX * 3 + 1];
+            HANDLE hFind;
+            if ((rv = test_safe_name(fname)) != APR_SUCCESS) {
+                return rv;
+            }
+            hFind = FindFirstFileW(wfname, &FileInfo.w);
+            if (hFind == INVALID_HANDLE_VALUE)
+                return apr_get_os_error();
+            FindClose(hFind);
+            if (unicode_to_utf8_path(tmpname, sizeof(tmpname), 
+                                     FileInfo.w.cFileName)) {
+                return APR_ENAMETOOLONG;
+            }
+            filename = apr_pstrdup(pool, tmpname);
+        }
+    }
+#endif
+#if APR_HAS_ANSI_FS
+    ELSE_WIN_OS_IS_ANSI
+    {
+        char *root = NULL;
+        const char *test = fname;
+        rv = apr_filepath_root(&root, &test, APR_FILEPATH_NATIVE, pool);
+        isroot = (root && *root && !(*test));
+
+        if ((apr_os_level >= APR_WIN_98) && (!(wanted & APR_FINFO_NAME) || isroot))
+        {
+            /* cannot use FindFile on a Win98 root, it returns \*
+             * GetFileAttributesExA is not available on Win95
+             */
+            if (!GetFileAttributesExA(fname, GetFileExInfoStandard, 
+                                     &FileInfo.i)) {
+                return apr_get_os_error();
+            }
+        }
+        else if (isroot) {
+            /* This is Win95 and we are trying to stat a root.  Lie.
+             */
+            if (GetDriveType(fname) != DRIVE_UNKNOWN) 
+            {
+                finfo->pool = pool;
+                finfo->filetype = 0;
+                finfo->mtime = apr_time_now();
+                finfo->protection |= APR_WREAD | APR_WEXECUTE | APR_WWRITE;
+                finfo->protection |= (finfo->protection << prot_scope_group) 
+                                   | (finfo->protection << prot_scope_user);
+                finfo->valid |= APR_FINFO_TYPE | APR_FINFO_PROT 
+                              | APR_FINFO_MTIME
+                              | (wanted & APR_FINFO_LINK);
+                return (wanted &= ~finfo->valid) ? APR_INCOMPLETE 
+                                                 : APR_SUCCESS;
+            }
+            else
+                return APR_FROM_OS_ERROR(ERROR_PATH_NOT_FOUND);
+        }
+        else  {
+            /* Guard against bogus wildcards and retrieve by name
+             * since we want the true name, or are stuck in Win95,
+             * or are looking for the root of a Win98 drive.
+             */
+            HANDLE hFind;
+            if ((rv = test_safe_name(fname)) != APR_SUCCESS) {
+                return rv;
+            }
+            hFind = FindFirstFileA(fname, &FileInfo.n);
+            if (hFind == INVALID_HANDLE_VALUE) {
+                return apr_get_os_error();
+    	    } 
+            FindClose(hFind);
+            filename = apr_pstrdup(pool, FileInfo.n.cFileName);
+        }
+    }
+#endif
+
+    if (ident_rv != APR_INCOMPLETE) {
+        if (fillin_fileinfo(finfo, (WIN32_FILE_ATTRIBUTE_DATA *) &FileInfo, 
+                            0, wanted))
+        {
+            /* Go the extra mile to assure we have a file.  WinNT/2000 seems
+             * to reliably translate char devices to the path '\\.\device'
+             * so go ask for the full path.
+             */
+            if (apr_os_level >= APR_WIN_NT)
+            {
+#if APR_HAS_UNICODE_FS
+                apr_wchar_t tmpname[APR_FILE_MAX];
+                apr_wchar_t *tmpoff = NULL;
+                if (GetFullPathNameW(wfname, sizeof(tmpname) / sizeof(apr_wchar_t),
+                                     tmpname, &tmpoff))
+                {
+                    if (!wcsncmp(tmpname, L"\\\\.\\", 4)) {
+#else
+                /* Same initial logic as above, but
+                 * only for WinNT/non-UTF-8 builds of APR:
+                 */
+                char tmpname[APR_FILE_MAX];
+                char *tmpoff;
+                if (GetFullPathName(fname, sizeof(tmpname), tmpname, &tmpoff))
+                {
+                    if (!strncmp(tmpname, "\\\\.\\", 4)) {
+#endif
+                        if (tmpoff == tmpname + 4) {
+                            finfo->filetype = APR_CHR;
+                        }
+                        /* For WHATEVER reason, CHR devices such as \\.\con 
+                         * or \\.\lpt1 *may*not* update tmpoff; in fact the
+                         * resulting tmpoff is set to NULL.  Guard against 
+                         * either case.
+                         *
+                         * This code is identical for wide and narrow chars...
+                         */
+                        else if (!tmpoff) {
+                            tmpoff = tmpname + 4;
+                            while (*tmpoff) {
+                                if (*tmpoff == '\\' || *tmpoff == '/') {
+                                    break;
+                                }
+                                ++tmpoff;
+                            }
+                            if (!*tmpoff) {
+                                finfo->filetype = APR_CHR;
+                            }
+                        }
+                    }
+                }
+                else {
+                    finfo->valid &= ~APR_FINFO_TYPE;
+                }
+
+            }
+            else {
+                finfo->valid &= ~APR_FINFO_TYPE;
+            }
+        }
+        finfo->pool = pool;
+    }
+
+    if (filename && !isroot) {
+        finfo->name = filename;
+        finfo->valid |= APR_FINFO_NAME;
+    }
+
+    if (wanted &= ~finfo->valid) {
+        /* Caller wants more than APR_FINFO_MIN | APR_FINFO_NAME */
+#if APR_HAS_UNICODE_FS
+        if (apr_os_level >= APR_WIN_NT)
+            return more_finfo(finfo, wfname, wanted, MORE_OF_WFSPEC);
+#endif
+        return more_finfo(finfo, fname, wanted, MORE_OF_FSPEC);
+    }
+
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_lstat(apr_finfo_t *finfo, const char *fname,
+                                    apr_int32_t wanted, apr_pool_t *pool)
+{
+    return apr_stat(finfo, fname, wanted | APR_FINFO_LINK, pool);
+}
+
+APR_DECLARE(apr_status_t) apr_file_attrs_set(const char *fname,
+                                             apr_fileattrs_t attributes,
+                                             apr_fileattrs_t attr_mask,
+                                             apr_pool_t *pool)
+{
+    DWORD flags;
+    apr_status_t rv;
+#if APR_HAS_UNICODE_FS
+    apr_wchar_t wfname[APR_PATH_MAX];
+#endif
+
+    /* Don't do anything if we can't handle the requested attributes */
+    if (!(attr_mask & (APR_FILE_ATTR_READONLY
+                       | APR_FILE_ATTR_HIDDEN)))
+        return APR_SUCCESS;
+
+#if APR_HAS_UNICODE_FS
+    IF_WIN_OS_IS_UNICODE
+    {
+        if (rv = utf8_to_unicode_path(wfname,
+                                      sizeof(wfname) / sizeof(wfname[0]),
+                                      fname))
+            return rv;
+        flags = GetFileAttributesW(wfname);
+    }
+#endif
+#if APR_HAS_ANSI_FS
+    ELSE_WIN_OS_IS_ANSI
+    {
+        flags = GetFileAttributesA(fname);
+    }
+#endif
+
+    if (flags == 0xFFFFFFFF)
+        return apr_get_os_error();
+
+    if (attr_mask & APR_FILE_ATTR_READONLY)
+    {
+        if (attributes & APR_FILE_ATTR_READONLY)
+            flags |= FILE_ATTRIBUTE_READONLY;
+        else
+            flags &= ~FILE_ATTRIBUTE_READONLY;
+    }
+
+    if (attr_mask & APR_FILE_ATTR_HIDDEN)
+    {
+        if (attributes & APR_FILE_ATTR_HIDDEN)
+            flags |= FILE_ATTRIBUTE_HIDDEN;
+        else
+            flags &= ~FILE_ATTRIBUTE_HIDDEN;
+    }
+
+#if APR_HAS_UNICODE_FS
+    IF_WIN_OS_IS_UNICODE
+    {
+        rv = SetFileAttributesW(wfname, flags);
+    }
+#endif
+#if APR_HAS_ANSI_FS
+    ELSE_WIN_OS_IS_ANSI
+    {
+        rv = SetFileAttributesA(fname, flags);
+    }
+#endif
+
+    if (rv == 0)
+        return apr_get_os_error();
+
+    return APR_SUCCESS;
+}
+
+
+APR_DECLARE(apr_status_t) apr_file_mtime_set(const char *fname,
+                                             apr_time_t mtime,
+                                             apr_pool_t *pool)
+{
+    apr_file_t *thefile;
+    apr_status_t rv;
+
+    rv = apr_file_open(&thefile, fname,
+                       APR_READ | APR_WRITEATTRS,
+                       APR_OS_DEFAULT, pool);
+    if (!rv)
+    {
+        FILETIME file_ctime;
+        FILETIME file_atime;
+        FILETIME file_mtime;
+
+        if (!GetFileTime(thefile->filehand,
+                         &file_ctime, &file_atime, &file_mtime))
+            rv = apr_get_os_error();
+        else
+        {
+            AprTimeToFileTime(&file_mtime, mtime);
+            if (!SetFileTime(thefile->filehand,
+                             &file_ctime, &file_atime, &file_mtime))
+                rv = apr_get_os_error();
+        }
+
+        apr_file_close(thefile);
+    }
+
+    return rv;
+}
diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/file_io/win32/filesys.c b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/win32/filesys.c
new file mode 100644
index 00000000..ad31e338
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/win32/filesys.c
@@ -0,0 +1,229 @@
+/* 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"
+#include "apr_arch_file_io.h"
+#include "apr_strings.h"
+
+/* Win32 Exceptions:
+ *
+ * Note that trailing spaces and trailing periods are never recorded
+ * in the file system, except by a very obscure bug where any file
+ * that is created with a trailing space or period, followed by the 
+ * ':' stream designator on an NTFS volume can never be accessed again.
+ * In other words, don't ever accept them when designating a stream!
+ *
+ * An interesting side effect is that two or three periods are both 
+ * treated as the parent directory, although the fourth and on are
+ * not [strongly suggest all trailing periods are trimmed off, or
+ * down to two if there are no other characters.]
+ *
+ * Leading spaces and periods are accepted, however.
+ * The * ? < > codes all have wildcard side effects
+ * The " / \ : are exclusively component separator tokens 
+ * The system doesn't accept | for any (known) purpose 
+ * Oddly, \x7f _is_ acceptable ;)
+ */
+
+/* apr_c_is_fnchar[] maps Win32's file name and shell escape symbols
+ *
+ *   element & 1 == valid file name character [excluding delimiters]
+ *   element & 2 == character should be shell (caret) escaped from cmd.exe
+ *
+ * this must be in-sync with Apache httpd's gen_test_char.c for cgi escaping.
+ */
+
+const char apr_c_is_fnchar[256] =
+{/* Reject all ctrl codes... Escape \n and \r (ascii 10 and 13)      */
+    0,0,0,0,0,0,0,0,0,0,2,0,0,2,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ /*   ! " # $ % & ' ( ) * + , - . /  0 1 2 3 4 5 6 7 8 9 : ; < = > ? */
+    1,1,2,1,3,3,3,3,3,3,2,1,1,1,1,0, 1,1,1,1,1,1,1,1,1,1,0,3,2,1,2,2,
+ /* @ A B C D E F G H I J K L M N O  P Q R S T U V W X Y Z [ \ ] ^ _ */
+    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,3,2,3,3,1,
+ /* ` a b c d e f g h i j k l m n o  p q r s t u v w x y z { | } ~   */
+    3,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,3,2,3,3,1,
+ /* High bit codes are accepted (subject to utf-8->Unicode xlation)  */
+    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
+};
+
+
+apr_status_t filepath_root_test(char *path, apr_pool_t *p)
+{
+    apr_status_t rv;
+#if APR_HAS_UNICODE_FS
+    if (apr_os_level >= APR_WIN_NT)
+    {
+        apr_wchar_t wpath[APR_PATH_MAX];
+        if (rv = utf8_to_unicode_path(wpath, sizeof(wpath) 
+                                           / sizeof(apr_wchar_t), path))
+            return rv;
+        rv = GetDriveTypeW(wpath);
+    }
+    else
+#endif
+        rv = GetDriveType(path);
+
+    if (rv == DRIVE_UNKNOWN || rv == DRIVE_NO_ROOT_DIR)
+        return APR_EBADPATH;
+    return APR_SUCCESS;
+}
+
+
+apr_status_t filepath_drive_get(char **rootpath, char drive, 
+                                apr_int32_t flags, apr_pool_t *p)
+{
+    char path[APR_PATH_MAX];
+#if APR_HAS_UNICODE_FS
+    IF_WIN_OS_IS_UNICODE
+    {
+        apr_wchar_t *ignored;
+        apr_wchar_t wdrive[8];
+        apr_wchar_t wpath[APR_PATH_MAX];
+        apr_status_t rv;
+        /* ???: This needs review, apparently "\\?\d:." returns "\\?\d:" 
+         * as if that is useful for anything.
+         */
+        wcscpy(wdrive, L"D:.");
+        wdrive[0] = (apr_wchar_t)(unsigned char)drive;
+        if (!GetFullPathNameW(wdrive, sizeof(wpath) / sizeof(apr_wchar_t), wpath, &ignored))
+            return apr_get_os_error();
+        if ((rv = unicode_to_utf8_path(path, sizeof(path), wpath)))
+            return rv;
+    }
+#endif
+#if APR_HAS_ANSI_FS
+    ELSE_WIN_OS_IS_ANSI
+    {
+        char *ignored;
+        char drivestr[4];
+        drivestr[0] = drive;
+        drivestr[1] = ':';
+        drivestr[2] = '.';;
+        drivestr[3] = '\0';
+        if (!GetFullPathName(drivestr, sizeof(path), path, &ignored))
+            return apr_get_os_error();
+    }
+#endif
+    if (!(flags & APR_FILEPATH_NATIVE)) {
+        for (*rootpath = path; **rootpath; ++*rootpath) {
+            if (**rootpath == '\\')
+                **rootpath = '/';
+        }
+    }
+    *rootpath = apr_pstrdup(p, path);
+    return APR_SUCCESS;
+}
+
+
+apr_status_t filepath_root_case(char **rootpath, char *root, apr_pool_t *p)
+{
+#if APR_HAS_UNICODE_FS
+    IF_WIN_OS_IS_UNICODE
+    {
+        apr_wchar_t *ignored;
+        apr_wchar_t wpath[APR_PATH_MAX];
+        apr_status_t rv;
+        apr_wchar_t wroot[APR_PATH_MAX];
+        /* ???: This needs review, apparently "\\?\d:." returns "\\?\d:" 
+         * as if that is useful for anything.
+         */
+        if (rv = utf8_to_unicode_path(wroot, sizeof(wroot) 
+                                           / sizeof(apr_wchar_t), root))
+            return rv;
+        if (!GetFullPathNameW(wroot, sizeof(wpath) / sizeof(apr_wchar_t), wpath, &ignored))
+            return apr_get_os_error();
+
+        /* Borrow wroot as a char buffer (twice as big as necessary) 
+         */
+        if ((rv = unicode_to_utf8_path((char*)wroot, sizeof(wroot), wpath)))
+            return rv;
+        *rootpath = apr_pstrdup(p, (char*)wroot);
+    }
+#endif
+#if APR_HAS_ANSI_FS
+    ELSE_WIN_OS_IS_ANSI
+    {
+        char path[APR_PATH_MAX];
+        char *ignored;
+        if (!GetFullPathName(root, sizeof(path), path, &ignored))
+            return apr_get_os_error();
+        *rootpath = apr_pstrdup(p, path);
+    }
+#endif
+    return APR_SUCCESS;
+}
+
+
+APR_DECLARE(apr_status_t) apr_filepath_get(char **rootpath, apr_int32_t flags,
+                                           apr_pool_t *p)
+{
+    char path[APR_PATH_MAX];
+#if APR_HAS_UNICODE_FS
+    IF_WIN_OS_IS_UNICODE
+    {
+        apr_wchar_t wpath[APR_PATH_MAX];
+        apr_status_t rv;
+        if (!GetCurrentDirectoryW(sizeof(wpath) / sizeof(apr_wchar_t), wpath))
+            return apr_get_os_error();
+        if ((rv = unicode_to_utf8_path(path, sizeof(path), wpath)))
+            return rv;
+    }
+#endif
+#if APR_HAS_ANSI_FS
+    ELSE_WIN_OS_IS_ANSI
+    {
+        if (!GetCurrentDirectory(sizeof(path), path))
+            return apr_get_os_error();
+    }
+#endif
+    if (!(flags & APR_FILEPATH_NATIVE)) {
+        for (*rootpath = path; **rootpath; ++*rootpath) {
+            if (**rootpath == '\\')
+                **rootpath = '/';
+        }
+    }
+    *rootpath = apr_pstrdup(p, path);
+    return APR_SUCCESS;
+}
+
+
+APR_DECLARE(apr_status_t) apr_filepath_set(const char *rootpath,
+                                           apr_pool_t *p)
+{
+#if APR_HAS_UNICODE_FS
+    IF_WIN_OS_IS_UNICODE
+    {
+        apr_wchar_t wpath[APR_PATH_MAX];
+        apr_status_t rv;
+        if (rv = utf8_to_unicode_path(wpath, sizeof(wpath) 
+                                           / sizeof(apr_wchar_t), rootpath))
+            return rv;
+        if (!SetCurrentDirectoryW(wpath))
+            return apr_get_os_error();
+    }
+#endif
+#if APR_HAS_ANSI_FS
+    ELSE_WIN_OS_IS_ANSI
+    {
+        if (!SetCurrentDirectory(rootpath))
+            return apr_get_os_error();
+    }
+#endif
+    return APR_SUCCESS;
+}
diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/file_io/win32/flock.c b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/win32/flock.c
new file mode 100644
index 00000000..e08e08a7
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/win32/flock.c
@@ -0,0 +1,86 @@
+/* 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_file_io.h"
+
+APR_DECLARE(apr_status_t) apr_file_lock(apr_file_t *thefile, int type)
+{
+#ifdef _WIN32_WCE
+    /* The File locking is unsuported on WCE */
+    return APR_ENOTIMPL;
+#else
+    const DWORD len = 0xffffffff;
+    DWORD flags; 
+
+    flags = ((type & APR_FLOCK_NONBLOCK) ? LOCKFILE_FAIL_IMMEDIATELY : 0)
+          + (((type & APR_FLOCK_TYPEMASK) == APR_FLOCK_SHARED) 
+                                       ? 0 : LOCKFILE_EXCLUSIVE_LOCK);
+    if (apr_os_level >= APR_WIN_NT) {
+        /* Syntax is correct, len is passed for LengthLow and LengthHigh*/
+        OVERLAPPED offset;
+        memset (&offset, 0, sizeof(offset));
+        if (!LockFileEx(thefile->filehand, flags, 0, len, len, &offset))
+            return apr_get_os_error();
+    }
+    else {
+        /* On Win9x, LockFile() never blocks.  Hack in a crufty poll.
+         *
+         * Note that this hack exposes threads to being unserviced forever,
+         * in the situation that the given lock has low availability.
+         * When implemented in the kernel, LockFile will typically use
+         * FIFO or round robin distribution to ensure all threads get 
+         * one crack at the lock; but in this case we can't emulate that.
+         *
+         * However Win9x are barely maintainable anyways, if the user does
+         * choose to build to them, this is the best we can do.
+         */
+        while (!LockFile(thefile->filehand, 0, 0, len, 0)) {
+            DWORD err = GetLastError();
+            if ((err == ERROR_LOCK_VIOLATION) && !(type & APR_FLOCK_NONBLOCK))
+            {
+                Sleep(500); /* pause for a half second */
+                continue;   /* ... and then poll again */
+            }
+            return APR_FROM_OS_ERROR(err);
+        }
+    }
+
+    return APR_SUCCESS;
+#endif /* !defined(_WIN32_WCE) */
+}
+
+APR_DECLARE(apr_status_t) apr_file_unlock(apr_file_t *thefile)
+{
+#ifdef _WIN32_WCE
+    return APR_ENOTIMPL;
+#else
+    DWORD len = 0xffffffff;
+
+    if (apr_os_level >= APR_WIN_NT) {
+        /* Syntax is correct, len is passed for LengthLow and LengthHigh*/
+        OVERLAPPED offset;
+        memset (&offset, 0, sizeof(offset));
+        if (!UnlockFileEx(thefile->filehand, 0, len, len, &offset))
+            return apr_get_os_error();
+    }
+    else {
+        if (!UnlockFile(thefile->filehand, 0, 0, len, 0))
+            return apr_get_os_error();
+    }
+
+    return APR_SUCCESS;
+#endif /* !defined(_WIN32_WCE) */
+}
diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/file_io/win32/open.c b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/win32/open.c
new file mode 100644
index 00000000..a60fba26
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/win32/open.c
@@ -0,0 +1,628 @@
+/* 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_private.h"
+#include "apr_arch_file_io.h"
+#include "apr_file_io.h"
+#include "apr_general.h"
+#include "apr_strings.h"
+#include "apr_portable.h"
+#include "apr_thread_mutex.h"
+#if APR_HAVE_ERRNO_H
+#include <errno.h>
+#endif
+#include <winbase.h>
+#include <string.h>
+#if APR_HAVE_SYS_STAT_H
+#include <sys/stat.h>
+#endif
+#include "apr_arch_misc.h"
+#include "apr_arch_inherit.h"
+#include <io.h>
+
+#if APR_HAS_UNICODE_FS
+apr_status_t utf8_to_unicode_path(apr_wchar_t* retstr, apr_size_t retlen, 
+                                  const char* srcstr)
+{
+    /* TODO: The computations could preconvert the string to determine
+     * the true size of the retstr, but that's a memory over speed
+     * tradeoff that isn't appropriate this early in development.
+     *
+     * Allocate the maximum string length based on leading 4 
+     * characters of \\?\ (allowing nearly unlimited path lengths) 
+     * plus the trailing null, then transform /'s into \\'s since
+     * the \\?\ form doesn't allow '/' path seperators.
+     *
+     * Note that the \\?\ form only works for local drive paths, and
+     * \\?\UNC\ is needed UNC paths.
+     */
+    int srcremains = strlen(srcstr) + 1;
+    apr_wchar_t *t = retstr;
+    apr_status_t rv;
+
+    /* This is correct, we don't twist the filename if it is will
+     * definately be shorter than 248 characters.  It merits some 
+     * performance testing to see if this has any effect, but there
+     * seem to be applications that get confused by the resulting
+     * Unicode \\?\ style file names, especially if they use argv[0]
+     * or call the Win32 API functions such as GetModuleName, etc.
+     * Not every application is prepared to handle such names.
+     * 
+     * Note also this is shorter than MAX_PATH, as directory paths 
+     * are actually limited to 248 characters. 
+     *
+     * Note that a utf-8 name can never result in more wide chars
+     * than the original number of utf-8 narrow chars.
+     */
+    if (srcremains > 248) {
+        if (srcstr[1] == ':' && (srcstr[2] == '/' || srcstr[2] == '\\')) {
+            wcscpy (retstr, L"\\\\?\\");
+            retlen -= 4;
+            t += 4;
+        }
+        else if ((srcstr[0] == '/' || srcstr[0] == '\\')
+              && (srcstr[1] == '/' || srcstr[1] == '\\')
+              && (srcstr[2] != '?')) {
+            /* Skip the slashes */
+            srcstr += 2;
+            srcremains -= 2;
+            wcscpy (retstr, L"\\\\?\\UNC\\");
+            retlen -= 8;
+            t += 8;
+        }
+    }
+
+    if (rv = apr_conv_utf8_to_ucs2(srcstr, &srcremains, t, &retlen)) {
+        return (rv == APR_INCOMPLETE) ? APR_EINVAL : rv;
+    }
+    if (srcremains) {
+        return APR_ENAMETOOLONG;
+    }
+    for (; *t; ++t)
+        if (*t == L'/')
+            *t = L'\\';
+    return APR_SUCCESS;
+}
+
+apr_status_t unicode_to_utf8_path(char* retstr, apr_size_t retlen,
+                                  const apr_wchar_t* srcstr)
+{
+    /* Skip the leading 4 characters if the path begins \\?\, or substitute
+     * // for the \\?\UNC\ path prefix, allocating the maximum string
+     * length based on the remaining string, plus the trailing null.
+     * then transform \\'s back into /'s since the \\?\ form never
+     * allows '/' path seperators, and APR always uses '/'s.
+     */
+    int srcremains = wcslen(srcstr) + 1;
+    apr_status_t rv;
+    char *t = retstr;
+    if (srcstr[0] == L'\\' && srcstr[1] == L'\\' && 
+        srcstr[2] == L'?'  && srcstr[3] == L'\\') {
+        if (srcstr[4] == L'U' && srcstr[5] == L'N' && 
+            srcstr[6] == L'C' && srcstr[7] == L'\\') {
+            srcremains -= 8;
+            srcstr += 8;
+            retstr[0] = '\\';
+            retstr[1] = '\\';
+            retlen -= 2;
+            t += 2;
+        }
+        else {
+            srcremains -= 4;
+            srcstr += 4;
+        }
+    }
+        
+    if (rv = apr_conv_ucs2_to_utf8(srcstr, &srcremains, t, &retlen)) {
+        return rv;
+    }
+    if (srcremains) {
+        return APR_ENAMETOOLONG;
+    }
+    return APR_SUCCESS;
+}
+#endif
+
+void *res_name_from_filename(const char *file, int global, apr_pool_t *pool)
+{
+#if APR_HAS_UNICODE_FS
+    IF_WIN_OS_IS_UNICODE
+    {
+        apr_wchar_t *wpre, *wfile, *ch;
+        apr_size_t n = strlen(file) + 1;
+        apr_size_t r, d;
+        apr_status_t rv;
+
+        if (apr_os_level >= APR_WIN_2000) {
+            if (global)
+                wpre = L"Global\\";
+            else
+                wpre = L"Local\\";
+        }
+        else
+            wpre = L"";
+        r = wcslen(wpre);
+
+        if (n > 256 - r) {
+            file += n - 256 - r;
+            n = 256;
+            /* skip utf8 continuation bytes */
+            while ((*file & 0xC0) == 0x80) {
+                ++file;
+                --n;
+            }
+        }
+        wfile = apr_palloc(pool, (r + n) * sizeof(apr_wchar_t));
+        wcscpy(wfile, wpre);
+        d = n;
+        if (rv = apr_conv_utf8_to_ucs2(file, &n, wfile + r, &d)) {
+            return NULL;
+        }
+        for (ch = wfile + r; *ch; ++ch) {
+            if (*ch == ':' || *ch == '/' || *ch == '\\')
+                *ch = '_';
+        }
+        return wfile;
+    }
+#endif
+#if APR_HAS_ANSI_FS
+    ELSE_WIN_OS_IS_ANSI
+    {
+        char *nfile, *ch;
+        apr_size_t n = strlen(file) + 1;
+
+#if !APR_HAS_UNICODE_FS
+        apr_status_t rv;
+        apr_size_t r, d;
+        char *pre;
+
+        if (apr_os_level >= APR_WIN_2000) {
+            if (global)
+                pre = "Global\\";
+            else
+                pre = "Local\\";
+        }
+        else
+            pre = "";
+        r = strlen(pre);
+
+        if (n > 256 - r) {
+            file += n - 256 - r;
+            n = 256;
+        }
+        nfile = apr_palloc(pool, (r + n) * sizeof(apr_wchar_t));
+        memcpy(nfile, pre, r);
+        memcpy(nfile + r, file, n);
+#else
+        const apr_size_t r = 0;
+        if (n > 256) {
+            file += n - 256;
+            n = 256;
+        }
+        nfile = apr_pmemdup(pool, file, n);
+#endif
+        for (ch = nfile + r; *ch; ++ch) {
+            if (*ch == ':' || *ch == '/' || *ch == '\\')
+                *ch = '_';
+        }
+        return nfile;
+    }
+#endif
+}
+
+
+apr_status_t file_cleanup(void *thefile)
+{
+    apr_file_t *file = thefile;
+    apr_status_t flush_rv = APR_SUCCESS;
+
+    if (file->filehand != INVALID_HANDLE_VALUE) {
+
+        if (file->buffered) {
+            /* XXX: flush here is not mutex protected */
+            flush_rv = apr_file_flush((apr_file_t *)thefile);
+        }
+
+        /* In order to avoid later segfaults with handle 'reuse',
+         * we must protect against the case that a dup2'ed handle
+         * is being closed, and invalidate the corresponding StdHandle 
+         * We also tell msvcrt when stdhandles are closed.
+         */
+        if (file->flags & APR_STD_FLAGS)
+        {
+            if ((file->flags & APR_STD_FLAGS) == APR_STDERR_FLAG) {
+                _close(2);
+                SetStdHandle(STD_ERROR_HANDLE, INVALID_HANDLE_VALUE);
+            }
+            else if ((file->flags & APR_STD_FLAGS) == APR_STDOUT_FLAG) {
+                _close(1);
+                SetStdHandle(STD_OUTPUT_HANDLE, INVALID_HANDLE_VALUE);
+            }
+            else if ((file->flags & APR_STD_FLAGS) == APR_STDIN_FLAG) {
+                _close(0);
+                SetStdHandle(STD_INPUT_HANDLE, INVALID_HANDLE_VALUE);
+            }
+        }
+        else
+            CloseHandle(file->filehand);
+
+        file->filehand = INVALID_HANDLE_VALUE;
+    }
+    if (file->pOverlapped && file->pOverlapped->hEvent) {
+        CloseHandle(file->pOverlapped->hEvent);
+        file->pOverlapped = NULL;
+    }
+    return flush_rv;
+}
+
+APR_DECLARE(apr_status_t) apr_file_open(apr_file_t **new, const char *fname,
+                                   apr_int32_t flag, apr_fileperms_t perm,
+                                   apr_pool_t *pool)
+{
+    HANDLE handle = INVALID_HANDLE_VALUE;
+    DWORD oflags = 0;
+    DWORD createflags = 0;
+    DWORD attributes = 0;
+    DWORD sharemode = FILE_SHARE_READ | FILE_SHARE_WRITE;
+    apr_status_t rv;
+
+    if (flag & APR_READ) {
+        oflags |= GENERIC_READ;
+    }
+    if (flag & APR_WRITE) {
+        oflags |= GENERIC_WRITE;
+    }
+    if (flag & APR_WRITEATTRS) {
+        oflags |= FILE_WRITE_ATTRIBUTES;
+    }
+
+    if (apr_os_level >= APR_WIN_NT) 
+        sharemode |= FILE_SHARE_DELETE;
+
+    if (flag & APR_CREATE) {
+        if (flag & APR_EXCL) {
+            /* only create new if file does not already exist */
+            createflags = CREATE_NEW;
+        } else if (flag & APR_TRUNCATE) {
+            /* truncate existing file or create new */
+            createflags = CREATE_ALWAYS;
+        } else {
+            /* open existing but create if necessary */
+            createflags = OPEN_ALWAYS;
+        }
+    } else if (flag & APR_TRUNCATE) {
+        /* only truncate if file already exists */
+        createflags = TRUNCATE_EXISTING;
+    } else {
+        /* only open if file already exists */
+        createflags = OPEN_EXISTING;
+    }
+
+    if ((flag & APR_EXCL) && !(flag & APR_CREATE)) {
+        return APR_EACCES;
+    }   
+    
+    if (flag & APR_DELONCLOSE) {
+        attributes |= FILE_FLAG_DELETE_ON_CLOSE;
+    }
+
+    if (flag & APR_OPENLINK) {
+       attributes |= FILE_FLAG_OPEN_REPARSE_POINT;
+    }
+
+    /* Without READ or WRITE, we fail unless apr called apr_file_open
+     * internally with the private APR_OPENINFO flag.
+     *
+     * With the APR_OPENINFO flag on NT, use the option flag
+     * FILE_FLAG_BACKUP_SEMANTICS to allow us to open directories.
+     * See the static resolve_ident() fn in file_io/win32/filestat.c
+     */
+    if (!(flag & (APR_READ | APR_WRITE))) {
+        if (flag & APR_OPENINFO) {
+            if (apr_os_level >= APR_WIN_NT) {
+                attributes |= FILE_FLAG_BACKUP_SEMANTICS;
+            }
+        }
+        else {
+            return APR_EACCES;
+        }
+        if (flag & APR_READCONTROL)
+            oflags |= READ_CONTROL;
+    }
+
+    if (flag & APR_XTHREAD) {
+        /* This win32 specific feature is required 
+         * to allow multiple threads to work with the file.
+         */
+        attributes |= FILE_FLAG_OVERLAPPED;
+    }
+
+#if APR_HAS_UNICODE_FS
+    IF_WIN_OS_IS_UNICODE
+    {
+        apr_wchar_t wfname[APR_PATH_MAX];
+
+        if (flag & APR_SENDFILE_ENABLED) {    
+            /* This feature is required to enable sendfile operations
+             * against the file on Win32. Also implies APR_XTHREAD.
+             */
+            flag |= APR_XTHREAD;
+            attributes |= FILE_FLAG_SEQUENTIAL_SCAN | FILE_FLAG_OVERLAPPED;
+        }
+
+        if (rv = utf8_to_unicode_path(wfname, sizeof(wfname) 
+                                               / sizeof(apr_wchar_t), fname))
+            return rv;
+        handle = CreateFileW(wfname, oflags, sharemode,
+                             NULL, createflags, attributes, 0);
+    }
+#endif
+#if APR_HAS_ANSI_FS
+    ELSE_WIN_OS_IS_ANSI {
+        handle = CreateFileA(fname, oflags, sharemode,
+                             NULL, createflags, attributes, 0);
+        if (flag & APR_SENDFILE_ENABLED) {    
+            /* This feature is not supported on this platform.
+             */
+            flag &= ~APR_SENDFILE_ENABLED;
+        }
+
+    }
+#endif
+    if (handle == INVALID_HANDLE_VALUE) {
+        return apr_get_os_error();
+    }
+
+    (*new) = (apr_file_t *)apr_pcalloc(pool, sizeof(apr_file_t));
+    (*new)->pool = pool;
+    (*new)->filehand = handle;
+    (*new)->fname = apr_pstrdup(pool, fname);
+    (*new)->flags = flag;
+    (*new)->timeout = -1;
+    (*new)->ungetchar = -1;
+
+    if (flag & APR_APPEND) {
+        (*new)->append = 1;
+        SetFilePointer((*new)->filehand, 0, NULL, FILE_END);
+    }
+    if (flag & APR_BUFFERED) {
+        (*new)->buffered = 1;
+        (*new)->buffer = apr_palloc(pool, APR_FILE_BUFSIZE);
+    }
+    /* Need the mutex to handled buffered and O_APPEND style file i/o */
+    if ((*new)->buffered || (*new)->append) {
+        rv = apr_thread_mutex_create(&(*new)->mutex, 
+                                     APR_THREAD_MUTEX_DEFAULT, pool);
+        if (rv) {
+            if (file_cleanup(*new) == APR_SUCCESS) {
+                apr_pool_cleanup_kill(pool, *new, file_cleanup);
+            }
+            return rv;
+        }
+    }
+
+    if (!(flag & APR_FILE_NOCLEANUP)) {
+        apr_pool_cleanup_register((*new)->pool, (void *)(*new), file_cleanup,
+                                  apr_pool_cleanup_null);
+    }
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_file_close(apr_file_t *file)
+{
+    apr_status_t stat;
+    if ((stat = file_cleanup(file)) == APR_SUCCESS) {
+        apr_pool_cleanup_kill(file->pool, file, file_cleanup);
+
+        if (file->mutex) {
+            apr_thread_mutex_destroy(file->mutex);
+        }
+
+        return APR_SUCCESS;
+    }
+    return stat;
+}
+
+APR_DECLARE(apr_status_t) apr_file_remove(const char *path, apr_pool_t *pool)
+{
+#if APR_HAS_UNICODE_FS
+    IF_WIN_OS_IS_UNICODE
+    {
+        apr_wchar_t wpath[APR_PATH_MAX];
+        apr_status_t rv;
+        if (rv = utf8_to_unicode_path(wpath, sizeof(wpath) 
+                                              / sizeof(apr_wchar_t), path)) {
+            return rv;
+        }
+        if (DeleteFileW(wpath))
+            return APR_SUCCESS;
+    }
+#endif
+#if APR_HAS_ANSI_FS
+    ELSE_WIN_OS_IS_ANSI
+        if (DeleteFile(path))
+            return APR_SUCCESS;
+#endif
+    return apr_get_os_error();
+}
+
+APR_DECLARE(apr_status_t) apr_file_rename(const char *frompath,
+                                          const char *topath,
+                                          apr_pool_t *pool)
+{
+    IF_WIN_OS_IS_UNICODE
+    {
+#if APR_HAS_UNICODE_FS
+        apr_wchar_t wfrompath[APR_PATH_MAX], wtopath[APR_PATH_MAX];
+        apr_status_t rv;
+        if (rv = utf8_to_unicode_path(wfrompath, sizeof(wfrompath) 
+                                           / sizeof(apr_wchar_t), frompath)) {
+            return rv;
+        }
+        if (rv = utf8_to_unicode_path(wtopath, sizeof(wtopath) 
+                                             / sizeof(apr_wchar_t), topath)) {
+            return rv;
+        }
+#ifndef _WIN32_WCE
+        if (MoveFileExW(wfrompath, wtopath, MOVEFILE_REPLACE_EXISTING |
+                                            MOVEFILE_COPY_ALLOWED))
+#else
+        if (MoveFileW(wfrompath, wtopath))
+#endif
+            return APR_SUCCESS;
+#else
+        if (MoveFileEx(frompath, topath, MOVEFILE_REPLACE_EXISTING |
+                                         MOVEFILE_COPY_ALLOWED))
+            return APR_SUCCESS;
+#endif
+    }
+#if APR_HAS_ANSI_FS
+    ELSE_WIN_OS_IS_ANSI
+    {
+        /* Windows 95 and 98 do not support MoveFileEx, so we'll use
+         * the old MoveFile function.  However, MoveFile requires that
+         * the new file not already exist...so we have to delete that
+         * file if it does.  Perhaps we should back up the to-be-deleted
+         * file in case something happens?
+         */
+        HANDLE handle = INVALID_HANDLE_VALUE;
+
+        if ((handle = CreateFile(topath, GENERIC_WRITE, 0, 0,  
+            OPEN_EXISTING, 0, 0 )) != INVALID_HANDLE_VALUE )
+        {
+            CloseHandle(handle);
+            if (!DeleteFile(topath))
+                return apr_get_os_error();
+        }
+        if (MoveFile(frompath, topath))
+            return APR_SUCCESS;
+    }        
+#endif
+    return apr_get_os_error();
+}
+
+APR_DECLARE(apr_status_t) apr_os_file_get(apr_os_file_t *thefile,
+                                          apr_file_t *file)
+{
+    *thefile = file->filehand;
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_os_file_put(apr_file_t **file,
+                                          apr_os_file_t *thefile,
+                                          apr_int32_t flags,
+                                          apr_pool_t *pool)
+{
+    (*file) = apr_pcalloc(pool, sizeof(apr_file_t));
+    (*file)->pool = pool;
+    (*file)->filehand = *thefile;
+    (*file)->ungetchar = -1; /* no char avail */
+    (*file)->timeout = -1;
+    (*file)->flags = flags;
+
+    if (flags & APR_APPEND) {
+        (*file)->append = 1;
+    }
+    if (flags & APR_BUFFERED) {
+        (*file)->buffered = 1;
+        (*file)->buffer = apr_palloc(pool, APR_FILE_BUFSIZE);
+    }
+
+    if ((*file)->append || (*file)->buffered) {
+        apr_status_t rv;
+        rv = apr_thread_mutex_create(&(*file)->mutex, 
+                                     APR_THREAD_MUTEX_DEFAULT, pool);
+        if (rv) {
+            if (file_cleanup(*file) == APR_SUCCESS) {
+                apr_pool_cleanup_kill(pool, *file, file_cleanup);
+            }
+            return rv;
+        }
+    }
+
+    /* XXX... we pcalloc above so all others are zeroed.
+     * Should we be testing if thefile is a handle to 
+     * a PIPE and set up the mechanics appropriately?
+     *
+     *  (*file)->pipe;
+     */
+    return APR_SUCCESS;
+}    
+
+APR_DECLARE(apr_status_t) apr_file_eof(apr_file_t *fptr)
+{
+    if (fptr->eof_hit == 1) {
+        return APR_EOF;
+    }
+    return APR_SUCCESS;
+}   
+
+APR_DECLARE(apr_status_t) apr_file_open_stderr(apr_file_t **thefile, apr_pool_t *pool)
+{
+#ifdef _WIN32_WCE
+    return APR_ENOTIMPL;
+#else
+    apr_os_file_t file_handle;
+
+    apr_set_os_error(APR_SUCCESS);
+    file_handle = GetStdHandle(STD_ERROR_HANDLE);
+    if (!file_handle)
+        file_handle = INVALID_HANDLE_VALUE;
+
+    return apr_os_file_put(thefile, &file_handle,
+                           APR_WRITE | APR_STDERR_FLAG, pool);
+#endif
+}
+
+APR_DECLARE(apr_status_t) apr_file_open_stdout(apr_file_t **thefile, apr_pool_t *pool)
+{
+#ifdef _WIN32_WCE
+    return APR_ENOTIMPL;
+#else
+    apr_os_file_t file_handle;
+
+    apr_set_os_error(APR_SUCCESS);
+    file_handle = GetStdHandle(STD_OUTPUT_HANDLE);
+    if (!file_handle)
+        file_handle = INVALID_HANDLE_VALUE;
+
+    return apr_os_file_put(thefile, &file_handle,
+                           APR_WRITE | APR_STDOUT_FLAG, pool);
+#endif
+}
+
+APR_DECLARE(apr_status_t) apr_file_open_stdin(apr_file_t **thefile, apr_pool_t *pool)
+{
+#ifdef _WIN32_WCE
+    return APR_ENOTIMPL;
+#else
+    apr_os_file_t file_handle;
+
+    apr_set_os_error(APR_SUCCESS);
+    file_handle = GetStdHandle(STD_INPUT_HANDLE);
+    if (!file_handle)
+        file_handle = INVALID_HANDLE_VALUE;
+
+    return apr_os_file_put(thefile, &file_handle,
+                           APR_READ | APR_STDIN_FLAG, pool);
+#endif
+}
+
+APR_POOL_IMPLEMENT_ACCESSOR(file);
+
+APR_IMPLEMENT_INHERIT_SET(file, flags, pool, file_cleanup)
+ 
+APR_IMPLEMENT_INHERIT_UNSET(file, flags, pool, file_cleanup)
diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/file_io/win32/pipe.c b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/win32/pipe.c
new file mode 100644
index 00000000..78d6b096
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/win32/pipe.c
@@ -0,0 +1,235 @@
+/* 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 "win32/apr_arch_file_io.h"
+#include "apr_file_io.h"
+#include "apr_general.h"
+#include "apr_strings.h"
+#if APR_HAVE_ERRNO_H
+#include <errno.h>
+#endif
+#include <string.h>
+#include <stdio.h>
+#if APR_HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#if APR_HAVE_SYS_STAT_H
+#include <sys/stat.h>
+#endif
+#include "apr_arch_misc.h"
+
+APR_DECLARE(apr_status_t) apr_file_pipe_timeout_set(apr_file_t *thepipe, apr_interval_time_t timeout)
+{
+    /* Always OK to unset timeouts */
+    if (timeout == -1) {
+        thepipe->timeout = timeout;
+        return APR_SUCCESS;
+    }
+    if (!thepipe->pipe) {
+        return APR_ENOTIMPL;
+    }
+    if (timeout && !(thepipe->pOverlapped)) {
+        /* Cannot be nonzero if a pipe was opened blocking
+         */
+        return APR_EINVAL;
+    }
+    thepipe->timeout = timeout;
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_file_pipe_timeout_get(apr_file_t *thepipe, apr_interval_time_t *timeout)
+{
+    /* Always OK to get the timeout (even if it's unset ... -1) */
+    *timeout = thepipe->timeout;
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_file_pipe_create(apr_file_t **in, apr_file_t **out, apr_pool_t *p)
+{
+    /* Unix creates full blocking pipes. */
+    return apr_create_nt_pipe(in, out, APR_FULL_BLOCK, p);
+}
+
+/* apr_create_nt_pipe()
+ * An internal (for now) APR function used by apr_proc_create() 
+ * when setting up pipes to communicate with the child process. 
+ * apr_create_nt_pipe() allows setting the blocking mode of each end of 
+ * the pipe when the pipe is created (rather than after the pipe is created). 
+ * A pipe handle must be opened in full async i/o mode in order to 
+ * emulate Unix non-blocking pipes with timeouts. 
+ *
+ * In general, we don't want to enable child side pipe handles for async i/o.
+ * This prevents us from enabling both ends of the pipe for async i/o in 
+ * apr_file_pipe_create.
+ *
+ * Why not use NamedPipes on NT which support setting pipe state to
+ * non-blocking? On NT, even though you can set a pipe non-blocking, 
+ * there is no clean way to set event driven non-zero timeouts (e.g select(),
+ * WaitForSinglelObject, et. al. will not detect pipe i/o). On NT, you 
+ * have to poll the pipe to detect i/o on a non-blocking pipe.
+ */
+apr_status_t apr_create_nt_pipe(apr_file_t **in, apr_file_t **out, 
+                                apr_int32_t blocking_mode, 
+                                apr_pool_t *p)
+{
+#ifdef _WIN32_WCE
+    return APR_ENOTIMPL;
+#else
+    SECURITY_ATTRIBUTES sa;
+    static unsigned long id = 0;
+    DWORD dwPipeMode;
+    DWORD dwOpenMode;
+    char name[50];
+
+    sa.nLength = sizeof(sa);
+    
+#if APR_HAS_UNICODE_FS
+    IF_WIN_OS_IS_UNICODE
+        sa.bInheritHandle = FALSE;
+#endif
+#if APR_HAS_ANSI_FS
+    ELSE_WIN_OS_IS_ANSI
+        sa.bInheritHandle = TRUE;
+#endif
+    sa.lpSecurityDescriptor = NULL;
+
+    (*in) = (apr_file_t *)apr_pcalloc(p, sizeof(apr_file_t));
+    (*in)->pool = p;
+    (*in)->fname = NULL;
+    (*in)->pipe = 1;
+    (*in)->timeout = -1;
+    (*in)->ungetchar = -1;
+    (*in)->eof_hit = 0;
+    (*in)->filePtr = 0;
+    (*in)->bufpos = 0;
+    (*in)->dataRead = 0;
+    (*in)->direction = 0;
+    (*in)->pOverlapped = NULL;
+
+    (*out) = (apr_file_t *)apr_pcalloc(p, sizeof(apr_file_t));
+    (*out)->pool = p;
+    (*out)->fname = NULL;
+    (*out)->pipe = 1;
+    (*out)->timeout = -1;
+    (*out)->ungetchar = -1;
+    (*out)->eof_hit = 0;
+    (*out)->filePtr = 0;
+    (*out)->bufpos = 0;
+    (*out)->dataRead = 0;
+    (*out)->direction = 0;
+    (*out)->pOverlapped = NULL;
+
+    if (apr_os_level >= APR_WIN_NT) {
+        /* Create the read end of the pipe */
+        dwOpenMode = PIPE_ACCESS_INBOUND;
+        if (blocking_mode == APR_WRITE_BLOCK /* READ_NONBLOCK */
+               || blocking_mode == APR_FULL_NONBLOCK) {
+            dwOpenMode |= FILE_FLAG_OVERLAPPED;
+            (*in)->pOverlapped = (OVERLAPPED*) apr_pcalloc(p, sizeof(OVERLAPPED));
+            (*in)->pOverlapped->hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
+        }
+
+        dwPipeMode = 0;
+
+        sprintf(name, "\\\\.\\pipe\\apr-pipe-%u.%lu", getpid(), id++);
+
+        (*in)->filehand = CreateNamedPipe(name,
+                                          dwOpenMode,
+                                          dwPipeMode,
+                                          1,            //nMaxInstances,
+                                          0,            //nOutBufferSize, 
+                                          65536,        //nInBufferSize,                   
+                                          1,            //nDefaultTimeOut,                
+                                          &sa);
+
+        /* Create the write end of the pipe */
+        dwOpenMode = FILE_ATTRIBUTE_NORMAL;
+        if (blocking_mode == APR_READ_BLOCK /* WRITE_NONBLOCK */
+                || blocking_mode == APR_FULL_NONBLOCK) {
+            dwOpenMode |= FILE_FLAG_OVERLAPPED;
+            (*out)->pOverlapped = (OVERLAPPED*) apr_pcalloc(p, sizeof(OVERLAPPED));
+            (*out)->pOverlapped->hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
+        }
+        
+        (*out)->filehand = CreateFile(name,
+                                      GENERIC_WRITE,   // access mode
+                                      0,               // share mode
+                                      &sa,             // Security attributes
+                                      OPEN_EXISTING,   // dwCreationDisposition
+                                      dwOpenMode,      // Pipe attributes
+                                      NULL);           // handle to template file
+    }
+    else {
+        /* Pipes on Win9* are blocking. Live with it. */
+        if (!CreatePipe(&(*in)->filehand, &(*out)->filehand, &sa, 65536)) {
+            return apr_get_os_error();
+        }
+    }
+
+    apr_pool_cleanup_register((*in)->pool, (void *)(*in), file_cleanup,
+                        apr_pool_cleanup_null);
+    apr_pool_cleanup_register((*out)->pool, (void *)(*out), file_cleanup,
+                        apr_pool_cleanup_null);
+    return APR_SUCCESS;
+#endif /* _WIN32_WCE */
+}
+
+
+APR_DECLARE(apr_status_t) apr_file_namedpipe_create(const char *filename,
+                                                    apr_fileperms_t perm,
+                                                    apr_pool_t *pool)
+{
+    /* Not yet implemented, interface not suitable.
+     * Win32 requires the named pipe to be *opened* at the time it's
+     * created, and to do so, blocking or non blocking must be elected.
+     */
+    return APR_ENOTIMPL;
+}
+
+
+/* XXX: Problem; we need to choose between blocking and nonblocking based
+ * on how *thefile was opened, and we don't have that information :-/
+ * Hack; assume a blocking socket, since the most common use for the fn
+ * would be to handle stdio-style or blocking pipes.  Win32 doesn't have
+ * select() blocking for pipes anyways :(
+ */
+APR_DECLARE(apr_status_t) apr_os_pipe_put_ex(apr_file_t **file,
+                                             apr_os_file_t *thefile,
+                                             int register_cleanup,
+                                             apr_pool_t *pool)
+{
+    (*file) = apr_pcalloc(pool, sizeof(apr_file_t));
+    (*file)->pool = pool;
+    (*file)->pipe = 1;
+    (*file)->timeout = -1;
+    (*file)->ungetchar = -1;
+    (*file)->filehand = *thefile;
+
+    if (register_cleanup) {
+        apr_pool_cleanup_register(pool, *file, file_cleanup,
+                                  apr_pool_cleanup_null);
+    }
+
+    return APR_SUCCESS;
+}
+
+
+APR_DECLARE(apr_status_t) apr_os_pipe_put(apr_file_t **file,
+                                          apr_os_file_t *thefile,
+                                          apr_pool_t *pool)
+{
+    return apr_os_pipe_put_ex(file, thefile, 0, pool);
+}
diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/file_io/win32/readwrite.c b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/win32/readwrite.c
new file mode 100644
index 00000000..5291830a
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/win32/readwrite.c
@@ -0,0 +1,524 @@
+/* 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 "win32/apr_arch_file_io.h"
+#include "apr_file_io.h"
+#include "apr_general.h"
+#include "apr_strings.h"
+#include "apr_lib.h"
+#include "apr_errno.h"
+#include <malloc.h>
+#include "apr_arch_atime.h"
+#include "apr_arch_misc.h"
+
+/*
+ * read_with_timeout() 
+ * Uses async i/o to emulate unix non-blocking i/o with timeouts.
+ */
+static apr_status_t read_with_timeout(apr_file_t *file, void *buf, apr_size_t len, apr_size_t *nbytes)
+{
+    apr_status_t rv;
+    *nbytes = 0;
+
+    /* Handle the zero timeout non-blocking case */
+    if (file->timeout == 0) {
+        /* Peek at the pipe. If there is no data available, return APR_EAGAIN.
+         * If data is available, go ahead and read it.
+         */
+        if (file->pipe) {
+            DWORD bytes;
+            if (!PeekNamedPipe(file->filehand, NULL, 0, NULL, &bytes, NULL)) {
+                rv = apr_get_os_error();
+                if (rv == APR_FROM_OS_ERROR(ERROR_BROKEN_PIPE)) {
+                    rv = APR_EOF;
+                }
+                return rv;
+            }
+            else {
+                if (bytes == 0) {
+                    return APR_EAGAIN;
+                }
+                if (len > bytes) {
+                    len = bytes;
+                }
+            }
+        }
+        else {
+            /* ToDo: Handle zero timeout non-blocking file i/o 
+             * This is not needed until an APR application needs to
+             * timeout file i/o (which means setting file i/o non-blocking)
+             */
+        }
+    }
+
+    if (file->pOverlapped && !file->pipe) {
+        file->pOverlapped->Offset     = (DWORD)file->filePtr;
+        file->pOverlapped->OffsetHigh = (DWORD)(file->filePtr >> 32);
+    }
+
+    rv = ReadFile(file->filehand, buf, len, nbytes, file->pOverlapped);
+
+    if (!rv) {
+        rv = apr_get_os_error();
+        if (rv == APR_FROM_OS_ERROR(ERROR_IO_PENDING)) {
+            /* Wait for the pending i/o */
+            if (file->timeout > 0) {
+                /* timeout in milliseconds... */
+                rv = WaitForSingleObject(file->pOverlapped->hEvent, 
+                                         (DWORD)(file->timeout/1000)); 
+            }
+            else if (file->timeout == -1) {
+                rv = WaitForSingleObject(file->pOverlapped->hEvent, INFINITE);
+            }
+            switch (rv) {
+                case WAIT_OBJECT_0:
+                    GetOverlappedResult(file->filehand, file->pOverlapped, 
+                                        nbytes, TRUE);
+                    rv = APR_SUCCESS;
+                    break;
+
+                case WAIT_TIMEOUT:
+                    rv = APR_TIMEUP;
+                    break;
+
+                case WAIT_FAILED:
+                    rv = apr_get_os_error();
+                    break;
+
+                default:
+                    break;
+            }
+
+            if (rv != APR_SUCCESS) {
+                if (apr_os_level >= APR_WIN_98) {
+                    CancelIo(file->filehand);
+                }
+            }
+        }
+        else if (rv == APR_FROM_OS_ERROR(ERROR_BROKEN_PIPE)) {
+            /* Assume ERROR_BROKEN_PIPE signals an EOF reading from a pipe */
+            rv = APR_EOF;
+        } else if (rv == APR_FROM_OS_ERROR(ERROR_HANDLE_EOF)) {
+            /* Did we hit EOF reading from the handle? */
+            rv = APR_EOF;
+        }
+    } else {
+        /* OK and 0 bytes read ==> end of file */
+        if (*nbytes == 0)
+            rv = APR_EOF;
+        else
+            rv = APR_SUCCESS;
+    }
+    if (rv == APR_SUCCESS && file->pOverlapped && !file->pipe) {
+        file->filePtr += *nbytes;
+    }
+    return rv;
+}
+
+APR_DECLARE(apr_status_t) apr_file_read(apr_file_t *thefile, void *buf, apr_size_t *len)
+{
+    apr_status_t rv;
+    DWORD bytes_read = 0;
+
+    if (*len <= 0) {
+        *len = 0;
+        return APR_SUCCESS;
+    }
+
+    /* If the file is open for xthread support, allocate and
+     * initialize the overlapped and io completion event (hEvent). 
+     * Threads should NOT share an apr_file_t or its hEvent.
+     */
+    if ((thefile->flags & APR_XTHREAD) && !thefile->pOverlapped ) {
+        thefile->pOverlapped = (OVERLAPPED*) apr_pcalloc(thefile->pool, 
+                                                         sizeof(OVERLAPPED));
+        thefile->pOverlapped->hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
+        if (!thefile->pOverlapped->hEvent) {
+            rv = apr_get_os_error();
+            return rv;
+        }
+    }
+
+    /* Handle the ungetchar if there is one */
+    if (thefile->ungetchar != -1) {
+        bytes_read = 1;
+        *(char *)buf = (char)thefile->ungetchar;
+        buf = (char *)buf + 1;
+        (*len)--;
+        thefile->ungetchar = -1;
+        if (*len == 0) {
+            *len = bytes_read;
+            return APR_SUCCESS;
+        }
+    }
+    if (thefile->buffered) {
+        char *pos = (char *)buf;
+        apr_size_t blocksize;
+        apr_size_t size = *len;
+
+        apr_thread_mutex_lock(thefile->mutex);
+
+        if (thefile->direction == 1) {
+            rv = apr_file_flush(thefile);
+            if (rv != APR_SUCCESS) {
+                apr_thread_mutex_unlock(thefile->mutex);
+                return rv;
+            }
+            thefile->bufpos = 0;
+            thefile->direction = 0;
+            thefile->dataRead = 0;
+        }
+
+        rv = 0;
+        while (rv == 0 && size > 0) {
+            if (thefile->bufpos >= thefile->dataRead) {
+                apr_size_t read;
+                rv = read_with_timeout(thefile, thefile->buffer, 
+                                       APR_FILE_BUFSIZE, &read);
+                if (read == 0) {
+                    if (rv == APR_EOF)
+                        thefile->eof_hit = TRUE;
+                    break;
+                }
+                else {
+                    thefile->dataRead = read;
+                    thefile->filePtr += thefile->dataRead;
+                    thefile->bufpos = 0;
+                }
+            }
+
+            blocksize = size > thefile->dataRead - thefile->bufpos ? thefile->dataRead - thefile->bufpos : size;
+            memcpy(pos, thefile->buffer + thefile->bufpos, blocksize);
+            thefile->bufpos += blocksize;
+            pos += blocksize;
+            size -= blocksize;
+        }
+
+        *len = pos - (char *)buf;
+        if (*len) {
+            rv = APR_SUCCESS;
+        }
+        apr_thread_mutex_unlock(thefile->mutex);
+    } else {  
+        /* Unbuffered i/o */
+        apr_size_t nbytes;
+        rv = read_with_timeout(thefile, buf, *len, &nbytes);
+        if (rv == APR_EOF)
+            thefile->eof_hit = TRUE;
+        *len = nbytes;
+    }
+
+    return rv;
+}
+
+APR_DECLARE(apr_status_t) apr_file_write(apr_file_t *thefile, const void *buf, apr_size_t *nbytes)
+{
+    apr_status_t rv;
+    DWORD bwrote;
+
+    /* If the file is open for xthread support, allocate and
+     * initialize the overlapped and io completion event (hEvent). 
+     * Threads should NOT share an apr_file_t or its hEvent.
+     */
+    if ((thefile->flags & APR_XTHREAD) && !thefile->pOverlapped ) {
+        thefile->pOverlapped = (OVERLAPPED*) apr_pcalloc(thefile->pool, 
+                                                         sizeof(OVERLAPPED));
+        thefile->pOverlapped->hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
+        if (!thefile->pOverlapped->hEvent) {
+            rv = apr_get_os_error();
+            return rv;
+        }
+    }
+
+    if (thefile->buffered) {
+        char *pos = (char *)buf;
+        apr_size_t blocksize;
+        apr_size_t size = *nbytes;
+
+        apr_thread_mutex_lock(thefile->mutex);
+
+        if (thefile->direction == 0) {
+            // Position file pointer for writing at the offset we are logically reading from
+            apr_off_t offset = thefile->filePtr - thefile->dataRead + thefile->bufpos;
+            DWORD offlo = (DWORD)offset;
+            DWORD offhi = (DWORD)(offset >> 32);
+            if (offset != thefile->filePtr)
+                SetFilePointer(thefile->filehand, offlo, &offhi, FILE_BEGIN);
+            thefile->bufpos = thefile->dataRead = 0;
+            thefile->direction = 1;
+        }
+
+        rv = 0;
+        while (rv == 0 && size > 0) {
+            if (thefile->bufpos == APR_FILE_BUFSIZE)   // write buffer is full
+                rv = apr_file_flush(thefile);
+
+            blocksize = size > APR_FILE_BUFSIZE - thefile->bufpos ? APR_FILE_BUFSIZE - thefile->bufpos : size;
+            memcpy(thefile->buffer + thefile->bufpos, pos, blocksize);
+            thefile->bufpos += blocksize;
+            pos += blocksize;
+            size -= blocksize;
+        }
+
+        apr_thread_mutex_unlock(thefile->mutex);
+        return rv;
+    } else {
+        if (!thefile->pipe) {
+            apr_off_t offset = 0;
+            apr_status_t rc;
+            if (thefile->append) {
+                /* apr_file_lock will mutex the file across processes.
+                 * The call to apr_thread_mutex_lock is added to avoid
+                 * a race condition between LockFile and WriteFile 
+                 * that occasionally leads to deadlocked threads.
+                 */
+                apr_thread_mutex_lock(thefile->mutex);
+                rc = apr_file_lock(thefile, APR_FLOCK_EXCLUSIVE);
+                if (rc != APR_SUCCESS) {
+                    apr_thread_mutex_unlock(thefile->mutex);
+                    return rc;
+                }
+                rc = apr_file_seek(thefile, APR_END, &offset);
+                if (rc != APR_SUCCESS) {
+                    apr_thread_mutex_unlock(thefile->mutex);
+                    return rc;
+                }
+            }
+            if (thefile->pOverlapped) {
+                thefile->pOverlapped->Offset     = (DWORD)thefile->filePtr;
+                thefile->pOverlapped->OffsetHigh = (DWORD)(thefile->filePtr >> 32);
+            }
+            rv = WriteFile(thefile->filehand, buf, *nbytes, &bwrote,
+                           thefile->pOverlapped);
+            if (thefile->append) {
+                apr_file_unlock(thefile);
+                apr_thread_mutex_unlock(thefile->mutex);
+            }
+        }
+        else {
+            rv = WriteFile(thefile->filehand, buf, *nbytes, &bwrote,
+                           thefile->pOverlapped);
+        }
+        if (rv) {
+            *nbytes = bwrote;
+            rv = APR_SUCCESS;
+        }
+        else {
+            (*nbytes) = 0;
+            rv = apr_get_os_error();
+            if (rv == APR_FROM_OS_ERROR(ERROR_IO_PENDING)) {
+ 
+                DWORD timeout_ms;
+
+                if (thefile->timeout == 0) {
+                    timeout_ms = 0;
+                }
+                else if (thefile->timeout < 0) {
+                    timeout_ms = INFINITE;
+                }
+                else {
+                    timeout_ms = (DWORD)(thefile->timeout / 1000);
+                }
+	       
+                rv = WaitForSingleObject(thefile->pOverlapped->hEvent, timeout_ms);
+                switch (rv) {
+                    case WAIT_OBJECT_0:
+                        GetOverlappedResult(thefile->filehand, thefile->pOverlapped, nbytes, TRUE);
+                        rv = APR_SUCCESS;
+                        break;
+                    case WAIT_TIMEOUT:
+                        rv = APR_TIMEUP;
+                        break;
+                    case WAIT_FAILED:
+                        rv = apr_get_os_error();
+                        break;
+                    default:
+                        break;
+                }
+                if (rv != APR_SUCCESS) {
+                    if (apr_os_level >= APR_WIN_98)
+                        CancelIo(thefile->filehand);
+                }
+            }
+        }
+        if (rv == APR_SUCCESS && thefile->pOverlapped && !thefile->pipe) {
+            thefile->filePtr += *nbytes;
+        }
+    }
+    return rv;
+}
+/* ToDo: Write for it anyway and test the oslevel!
+ * Too bad WriteFileGather() is not supported on 95&98 (or NT prior to SP2)
+ */
+APR_DECLARE(apr_status_t) apr_file_writev(apr_file_t *thefile,
+                                     const struct iovec *vec,
+                                     apr_size_t nvec, 
+                                     apr_size_t *nbytes)
+{
+    apr_status_t rv = APR_SUCCESS;
+    apr_size_t i;
+    DWORD bwrote = 0;
+    char *buf;
+
+    *nbytes = 0;
+    for (i = 0; i < nvec; i++) {
+        buf = vec[i].iov_base;
+        bwrote = vec[i].iov_len;
+        rv = apr_file_write(thefile, buf, &bwrote);
+        *nbytes += bwrote;
+        if (rv != APR_SUCCESS) {
+            break;
+        }
+    }
+    return rv;
+}
+
+APR_DECLARE(apr_status_t) apr_file_putc(char ch, apr_file_t *thefile)
+{
+    DWORD len = 1;
+
+    return apr_file_write(thefile, &ch, &len);
+}
+
+APR_DECLARE(apr_status_t) apr_file_ungetc(char ch, apr_file_t *thefile)
+{
+    thefile->ungetchar = (unsigned char) ch;
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_file_getc(char *ch, apr_file_t *thefile)
+{
+    apr_status_t rc;
+    int bread;
+
+    bread = 1;
+    rc = apr_file_read(thefile, ch, &bread);
+
+    if (rc) {
+        return rc;
+    }
+    
+    if (bread == 0) {
+        thefile->eof_hit = TRUE;
+        return APR_EOF;
+    }
+    return APR_SUCCESS; 
+}
+
+APR_DECLARE(apr_status_t) apr_file_puts(const char *str, apr_file_t *thefile)
+{
+    DWORD len = strlen(str);
+
+    return apr_file_write(thefile, str, &len);
+}
+
+APR_DECLARE(apr_status_t) apr_file_gets(char *str, int len, apr_file_t *thefile)
+{
+    apr_size_t readlen;
+    apr_status_t rv = APR_SUCCESS;
+    int i;    
+
+    for (i = 0; i < len-1; i++) {
+        readlen = 1;
+        rv = apr_file_read(thefile, str+i, &readlen);
+
+        if (rv != APR_SUCCESS && rv != APR_EOF)
+            return rv;
+
+        if (readlen == 0) {
+            /* If we have bytes, defer APR_EOF to the next call */
+            if (i > 0)
+                rv = APR_SUCCESS;
+            break;
+        }
+        
+        if (str[i] == '\n') {
+            i++; /* don't clobber this char below */
+            break;
+        }
+    }
+    str[i] = 0;
+    return rv;
+}
+
+APR_DECLARE(apr_status_t) apr_file_flush(apr_file_t *thefile)
+{
+    if (thefile->buffered) {
+        DWORD written = 0;
+        apr_status_t rc = 0;
+
+        if (thefile->direction == 1 && thefile->bufpos) {
+            if (!WriteFile(thefile->filehand, thefile->buffer, thefile->bufpos, &written, NULL))
+                rc = apr_get_os_error();
+            thefile->filePtr += written;
+
+            if (rc == 0)
+                thefile->bufpos = 0;
+        }
+
+        return rc;
+    }
+
+    /* There isn't anything to do if we aren't buffering the output
+     * so just return success.
+     */
+    return APR_SUCCESS; 
+}
+
+struct apr_file_printf_data {
+    apr_vformatter_buff_t vbuff;
+    apr_file_t *fptr;
+    char *buf;
+};
+
+static int file_printf_flush(apr_vformatter_buff_t *buff)
+{
+    struct apr_file_printf_data *data = (struct apr_file_printf_data *)buff;
+
+    if (apr_file_write_full(data->fptr, data->buf,
+                            data->vbuff.curpos - data->buf, NULL)) {
+        return -1;
+    }
+
+    data->vbuff.curpos = data->buf;
+    return 0;
+}
+
+APR_DECLARE_NONSTD(int) apr_file_printf(apr_file_t *fptr, 
+                                        const char *format, ...)
+{
+    struct apr_file_printf_data data;
+    va_list ap;
+    int count;
+
+    data.buf = malloc(HUGE_STRING_LEN);
+    if (data.buf == NULL) {
+        return 0;
+    }
+    data.vbuff.curpos = data.buf;
+    data.vbuff.endpos = data.buf + HUGE_STRING_LEN;
+    data.fptr = fptr;
+    va_start(ap, format);
+    count = apr_vformatter(file_printf_flush,
+                           (apr_vformatter_buff_t *)&data, format, ap);
+    /* apr_vformatter does not call flush for the last bits */
+    if (count >= 0) file_printf_flush((apr_vformatter_buff_t *)&data);
+
+    va_end(ap);
+
+    free(data.buf);
+    return count;
+}
diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/file_io/win32/seek.c b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/win32/seek.c
new file mode 100644
index 00000000..3a291485
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/srclib/apr/file_io/win32/seek.c
@@ -0,0 +1,171 @@
+/* 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 "win32/apr_arch_file_io.h"
+#include "apr_file_io.h"
+#include <errno.h>
+#include <string.h>
+
+static apr_status_t setptr(apr_file_t *thefile, apr_off_t pos )
+{
+    apr_off_t newbufpos;
+    apr_status_t rv;
+    DWORD rc;
+
+    if (thefile->direction == 1) {
+        /* XXX: flush here is not mutex protected */
+        rv = apr_file_flush(thefile);
+        if (rv != APR_SUCCESS)
+            return rv;
+        thefile->bufpos = thefile->direction = thefile->dataRead = 0;
+    }
+
+    newbufpos = pos - (thefile->filePtr - thefile->dataRead);
+
+    if (newbufpos >= 0 && newbufpos <= thefile->dataRead) {
+        thefile->bufpos = (apr_size_t)newbufpos;
+        rv = APR_SUCCESS;
+    } else {
+        DWORD offlo = (DWORD)pos;
+        DWORD offhi = (DWORD)(pos >> 32);
+        rc = SetFilePointer(thefile->filehand, offlo, &offhi, FILE_BEGIN);
+
+        if (rc == (DWORD)-1)
+            /* A legal value, perhaps?  MSDN implies prior SetLastError isn't
+             * needed, googling for SetLastError SetFilePointer seems
+             * to confirm this.  INVALID_SET_FILE_POINTER is too recently
+             * added for us to rely on it as a constant.
+             */
+            rv = apr_get_os_error();
+        else
+            rv = APR_SUCCESS;
+
+        if (rv == APR_SUCCESS) {
+            thefile->eof_hit = thefile->bufpos = thefile->dataRead = 0;
+            thefile->filePtr = pos;
+        }
+    }
+
+    return rv;
+}
+
+
+APR_DECLARE(apr_status_t) apr_file_seek(apr_file_t *thefile, apr_seek_where_t where, apr_off_t *offset)
+{
+    apr_finfo_t finfo;
+    apr_status_t rc = APR_SUCCESS;
+
+    thefile->eof_hit = 0;
+
+    if (thefile->buffered) {
+        switch (where) {
+            case APR_SET:
+                rc = setptr(thefile, *offset);
+                break;
+
+            case APR_CUR:
+                rc = setptr(thefile, thefile->filePtr - thefile->dataRead 
+                                      + thefile->bufpos + *offset);
+                break;
+
+            case APR_END:
+                rc = apr_file_info_get(&finfo, APR_FINFO_SIZE, thefile);
+                if (rc == APR_SUCCESS)
+                    rc = setptr(thefile, finfo.size + *offset);
+                break;
+
+            default:
+                return APR_EINVAL;
+        }
+
+        *offset = thefile->filePtr - thefile->dataRead + thefile->bufpos;
+        return rc;
+    } 
+    /* A file opened with APR_XTHREAD has been opened for overlapped i/o. 
+     * APR must explicitly track the file pointer in this case.
+     */
+    else if (thefile->pOverlapped || thefile->flags & APR_XTHREAD) {
+        switch(where) {
+            case APR_SET:
+                thefile->filePtr = *offset;
+                break;
+        
+            case APR_CUR:
+                thefile->filePtr += *offset;
+                break;
+        
+            case APR_END:
+                rc = apr_file_info_get(&finfo, APR_FINFO_SIZE, thefile);
+                if (rc == APR_SUCCESS && finfo.size + *offset >= 0)
+                    thefile->filePtr = finfo.size + *offset;
+                break;
+
+            default:
+                return APR_EINVAL;
+        }
+        *offset = thefile->filePtr;
+        return rc;
+    }
+    else {
+        DWORD howmove;
+        DWORD offlo = (DWORD)*offset;
+        DWORD offhi = (DWORD)(*offset >> 32);
+
+        switch(where) {
+            case APR_SET:
+                howmove = FILE_BEGIN;   break;
+            case APR_CUR:
+                howmove = FILE_CURRENT; break;
+            case APR_END:
+                howmove = FILE_END;     break;
+            default:
+                return APR_EINVAL;
+        }
+        offlo = SetFilePointer(thefile->filehand, (LONG)offlo, 
+                               (LONG*)&offhi, howmove);
+        if (offlo == 0xFFFFFFFF)
+            rc = apr_get_os_error();
+        else
+            rc = APR_SUCCESS;
+        /* Since we can land at 0xffffffff we will measure our APR_SUCCESS */
+        if (rc == APR_SUCCESS)
+            *offset = ((apr_off_t)offhi << 32) | offlo;
+        return rc;
+    }
+}
+
+
+APR_DECLARE(apr_status_t) apr_file_trunc(apr_file_t *thefile, apr_off_t offset)
+{
+    apr_status_t rv;
+    DWORD offlo = (DWORD)offset;
+    DWORD offhi = (DWORD)(offset >> 32);
+    DWORD rc;
+
+    rc = SetFilePointer(thefile->filehand, offlo, &offhi, FILE_BEGIN);
+    if (rc == 0xFFFFFFFF)
+        if ((rv = apr_get_os_error()) != APR_SUCCESS)
+            return rv;
+
+    if (!SetEndOfFile(thefile->filehand))
+        return apr_get_os_error();
+
+    if (thefile->buffered) {
+        return setptr(thefile, offset);
+    }
+
+    return APR_SUCCESS;
+}