upload http

JIRA: BOTTLENECK-10

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

40 files changed, 4048 insertions, 0 deletions

diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/locks/beos/Makefile.in b/rubbos/app/httpd-2.0.64/srclib/apr/locks/beos/Makefile.in
new file mode 100644
index 00000000..6c8a1bcc
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/srclib/apr/locks/beos/Makefile.in
@@ -0,0 +1,16 @@
+srcdir = @srcdir@
+VPATH = @srcdir@
+
+TARGETS = \
+	thread_mutex.lo \
+	thread_rwlock.lo \
+	thread_cond.lo \
+	proc_mutex.lo
+
+# bring in rules.mk for standard functionality
+@INCLUDE_RULES@
+
+INCDIR=../../include
+INCLUDES=-I$(INCDIR) -I$(INCDIR)/arch
+
+# DO NOT REMOVE
diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/locks/beos/proc_mutex.c b/rubbos/app/httpd-2.0.64/srclib/apr/locks/beos/proc_mutex.c
new file mode 100644
index 00000000..da315ce6
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/srclib/apr/locks/beos/proc_mutex.c
@@ -0,0 +1,169 @@
+/* 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.
+ */
+
+/*Read/Write locking implementation based on the MultiLock code from
+ * Stephen Beaulieu <hippo@be.com>
+ */
+ 
+#include "beos/apr_arch_proc_mutex.h"
+#include "apr_strings.h"
+#include "apr_portable.h"
+
+static apr_status_t _proc_mutex_cleanup(void * data)
+{
+    apr_proc_mutex_t *lock = (apr_proc_mutex_t*)data;
+    if (lock->LockCount != 0) {
+        /* we're still locked... */
+    	while (atomic_add(&lock->LockCount , -1) > 1){
+    	    /* OK we had more than one person waiting on the lock so 
+    	     * the sem is also locked. Release it until we have no more
+    	     * locks left.
+    	     */
+            release_sem (lock->Lock);
+    	}
+    }
+    delete_sem(lock->Lock);
+    return APR_SUCCESS;
+}    
+
+APR_DECLARE(apr_status_t) apr_proc_mutex_create(apr_proc_mutex_t **mutex,
+                                                const char *fname,
+                                                apr_lockmech_e mech,
+                                                apr_pool_t *pool)
+{
+    apr_proc_mutex_t *new;
+    apr_status_t stat = APR_SUCCESS;
+  
+    if (mech != APR_LOCK_DEFAULT) {
+        return APR_ENOTIMPL;
+    }
+
+    new = (apr_proc_mutex_t *)apr_pcalloc(pool, sizeof(apr_proc_mutex_t));
+    if (new == NULL){
+        return APR_ENOMEM;
+    }
+    
+    if ((stat = create_sem(0, "APR_Lock")) < B_NO_ERROR) {
+        _proc_mutex_cleanup(new);
+        return stat;
+    }
+    new->LockCount = 0;
+    new->Lock = stat;  
+    new->pool  = pool;
+
+    apr_pool_cleanup_register(new->pool, (void *)new, _proc_mutex_cleanup,
+                              apr_pool_cleanup_null);
+
+    (*mutex) = new;
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_proc_mutex_child_init(apr_proc_mutex_t **mutex,
+                                                    const char *fname,
+                                                    apr_pool_t *pool)
+{
+    return APR_SUCCESS;
+}
+    
+APR_DECLARE(apr_status_t) apr_proc_mutex_lock(apr_proc_mutex_t *mutex)
+{
+    int32 stat;
+    
+	if (atomic_add(&mutex->LockCount, 1) > 0) {
+		if ((stat = acquire_sem(mutex->Lock)) < B_NO_ERROR) {
+		    atomic_add(&mutex->LockCount, -1);
+		    return stat;
+		}
+	}
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_proc_mutex_trylock(apr_proc_mutex_t *mutex)
+{
+    return APR_ENOTIMPL;
+}
+
+APR_DECLARE(apr_status_t) apr_proc_mutex_unlock(apr_proc_mutex_t *mutex)
+{
+    int32 stat;
+    
+	if (atomic_add(&mutex->LockCount, -1) > 1) {
+        if ((stat = release_sem(mutex->Lock)) < B_NO_ERROR) {
+            atomic_add(&mutex->LockCount, 1);
+            return stat;
+        }
+    }
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_proc_mutex_destroy(apr_proc_mutex_t *mutex)
+{
+    apr_status_t stat;
+    if ((stat = _proc_mutex_cleanup(mutex)) == APR_SUCCESS) {
+        apr_pool_cleanup_kill(mutex->pool, mutex, _proc_mutex_cleanup);
+        return APR_SUCCESS;
+    }
+    return stat;
+}
+
+APR_DECLARE(apr_status_t) apr_proc_mutex_cleanup(void *mutex)
+{
+    return _proc_mutex_cleanup(mutex);
+}
+
+APR_DECLARE(const char *) apr_proc_mutex_lockfile(apr_proc_mutex_t *mutex)
+{
+    return NULL;
+}
+
+APR_DECLARE(const char *) apr_proc_mutex_name(apr_proc_mutex_t *mutex)
+{
+    return "beossem";
+}
+
+APR_DECLARE(const char *) apr_proc_mutex_defname(void)
+{
+    return "beossem";
+}
+
+APR_POOL_IMPLEMENT_ACCESSOR(proc_mutex)
+
+/* Implement OS-specific accessors defined in apr_portable.h */
+
+APR_DECLARE(apr_status_t) apr_os_proc_mutex_get(apr_os_proc_mutex_t *ospmutex,
+                                                apr_proc_mutex_t *pmutex)
+{
+    ospmutex->sem = pmutex->Lock;
+    ospmutex->ben = pmutex->LockCount;
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_os_proc_mutex_put(apr_proc_mutex_t **pmutex,
+                                                apr_os_proc_mutex_t *ospmutex,
+                                                apr_pool_t *pool)
+{
+    if (pool == NULL) {
+        return APR_ENOPOOL;
+    }
+    if ((*pmutex) == NULL) {
+        (*pmutex) = (apr_proc_mutex_t *)apr_pcalloc(pool, sizeof(apr_proc_mutex_t));
+        (*pmutex)->pool = pool;
+    }
+    (*pmutex)->Lock = ospmutex->sem;
+    (*pmutex)->LockCount = ospmutex->ben;
+    return APR_SUCCESS;
+}
+
diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/locks/beos/thread_cond.c b/rubbos/app/httpd-2.0.64/srclib/apr/locks/beos/thread_cond.c
new file mode 100644
index 00000000..3729bf38
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/srclib/apr/locks/beos/thread_cond.c
@@ -0,0 +1,190 @@
+/* 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 "beos/apr_arch_thread_mutex.h"
+#include "beos/apr_arch_thread_cond.h"
+#include "apr_strings.h"
+#include "apr_portable.h"
+
+static apr_status_t thread_cond_cleanup(void *data)
+{
+    struct waiter *w;
+    apr_thread_cond_t *cond = (apr_thread_cond_t *)data;
+
+    acquire_sem(cond->lock);
+/*
+    APR_RING_FOREACH(w, &cond->alist, waiter_t, link) {
+        delete_sem(w->sem);
+    }
+*/
+    delete_sem(cond->lock);
+
+    return APR_SUCCESS;
+}
+
+static struct waiter_t *make_waiter(apr_pool_t *pool)
+{
+    struct waiter_t *w = (struct waiter_t*)
+                       apr_palloc(pool, sizeof(struct waiter_t));
+    if (w == NULL)
+        return NULL;
+      
+    w->sem  = create_sem(0, "apr conditional waiter");
+    if (w->sem < 0)
+        return NULL;
+
+    APR_RING_ELEM_INIT(w, link);
+    
+    return w;
+}
+  
+APR_DECLARE(apr_status_t) apr_thread_cond_create(apr_thread_cond_t **cond,
+                                                 apr_pool_t *pool)
+{
+    apr_thread_cond_t *new_cond;
+    sem_id rv;
+    int i;
+
+    new_cond = (apr_thread_cond_t *)apr_palloc(pool, sizeof(apr_thread_cond_t));
+
+    if (new_cond == NULL)
+        return APR_ENOMEM;
+
+    if ((rv = create_sem(1, "apr conditional lock")) < B_OK)
+        return rv;
+    
+    new_cond->lock = rv;
+    new_cond->pool = pool;
+    APR_RING_INIT(&new_cond->alist, waiter_t, link);
+    APR_RING_INIT(&new_cond->flist, waiter_t, link);
+        
+    for (i=0;i < 10 ;i++) {
+        struct waiter_t *nw = make_waiter(pool);
+        APR_RING_INSERT_TAIL(&new_cond->flist, nw, waiter_t, link);
+    }
+
+    apr_pool_cleanup_register(new_cond->pool,
+                              (void *)new_cond, thread_cond_cleanup,
+                              apr_pool_cleanup_null);
+
+    *cond = new_cond;
+    return APR_SUCCESS;
+}
+
+
+static apr_status_t do_wait(apr_thread_cond_t *cond, apr_thread_mutex_t *mutex,
+                            int timeout)
+{
+    struct waiter_t *wait;
+    thread_id cth = find_thread(NULL);
+    apr_status_t rv;
+    int flags = B_RELATIVE_TIMEOUT;
+    
+    /* We must be the owner of the mutex or we can't do this... */    
+    if (mutex->owner != cth) {
+        /* What should we return??? */
+        return APR_EINVAL;
+    }
+
+    acquire_sem(cond->lock);
+    wait = APR_RING_FIRST(&cond->flist);
+    if (wait)
+        APR_RING_REMOVE(wait, link);
+    else
+        wait = make_waiter(cond->pool);   
+    APR_RING_INSERT_TAIL(&cond->alist, wait, waiter_t, link);
+    cond->condlock = mutex;
+    release_sem(cond->lock);
+       
+    apr_thread_mutex_unlock(cond->condlock);
+
+    if (timeout == 0)
+        flags = 0;
+        
+    rv = acquire_sem_etc(wait->sem, 1, flags, timeout);
+
+    apr_thread_mutex_lock(cond->condlock);
+    
+    if (rv != B_OK)
+        if (rv == B_TIMED_OUT)
+            return APR_TIMEUP;
+        return rv;       
+
+    acquire_sem(cond->lock);
+    APR_RING_REMOVE(wait, link);
+    APR_RING_INSERT_TAIL(&cond->flist, wait, waiter_t, link);
+    release_sem(cond->lock);
+    
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_cond_wait(apr_thread_cond_t *cond,
+                                               apr_thread_mutex_t *mutex)
+{
+    return do_wait(cond, mutex, 0);
+}
+
+APR_DECLARE(apr_status_t) apr_thread_cond_timedwait(apr_thread_cond_t *cond,
+                                                    apr_thread_mutex_t *mutex,
+                                                    apr_interval_time_t timeout)
+{
+    return do_wait(cond, mutex, timeout);
+}
+
+APR_DECLARE(apr_status_t) apr_thread_cond_signal(apr_thread_cond_t *cond)
+{
+    struct waiter_t *wake;
+
+    acquire_sem(cond->lock);    
+    if (!APR_RING_EMPTY(&cond->alist, waiter_t, link)) {
+        wake = APR_RING_FIRST(&cond->alist);
+        APR_RING_REMOVE(wake, link);
+        release_sem(wake->sem);
+        APR_RING_INSERT_TAIL(&cond->flist, wake, waiter_t, link);
+    }
+    release_sem(cond->lock);
+    
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_cond_broadcast(apr_thread_cond_t *cond)
+{
+    struct waiter_t *wake;
+    
+    acquire_sem(cond->lock);
+    while (! APR_RING_EMPTY(&cond->alist, waiter_t, link)) {
+        wake = APR_RING_FIRST(&cond->alist);
+        APR_RING_REMOVE(wake, link);
+        release_sem(wake->sem);
+        APR_RING_INSERT_TAIL(&cond->flist, wake, waiter_t, link);
+    }
+    release_sem(cond->lock);
+    
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_cond_destroy(apr_thread_cond_t *cond)
+{
+    apr_status_t stat;
+    if ((stat = thread_cond_cleanup(cond)) == APR_SUCCESS) {
+        apr_pool_cleanup_kill(cond->pool, cond, thread_cond_cleanup);
+        return APR_SUCCESS;
+    }
+    return stat;
+}
+
+APR_POOL_IMPLEMENT_ACCESSOR(thread_cond)
+
diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/locks/beos/thread_mutex.c b/rubbos/app/httpd-2.0.64/srclib/apr/locks/beos/thread_mutex.c
new file mode 100644
index 00000000..1d23d3cf
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/srclib/apr/locks/beos/thread_mutex.c
@@ -0,0 +1,147 @@
+/* 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.
+ */
+
+/*Read/Write locking implementation based on the MultiLock code from
+ * Stephen Beaulieu <hippo@be.com>
+ */
+ 
+#include "beos/apr_arch_thread_mutex.h"
+#include "apr_strings.h"
+#include "apr_portable.h"
+
+static apr_status_t _thread_mutex_cleanup(void * data)
+{
+    apr_thread_mutex_t *lock = (apr_thread_mutex_t*)data;
+    if (lock->LockCount != 0) {
+        /* we're still locked... */
+    	while (atomic_add(&lock->LockCount , -1) > 1){
+    	    /* OK we had more than one person waiting on the lock so 
+    	     * the sem is also locked. Release it until we have no more
+    	     * locks left.
+    	     */
+            release_sem (lock->Lock);
+    	}
+    }
+    delete_sem(lock->Lock);
+    return APR_SUCCESS;
+}    
+
+APR_DECLARE(apr_status_t) apr_thread_mutex_create(apr_thread_mutex_t **mutex,
+                                                  unsigned int flags,
+                                                  apr_pool_t *pool)
+{
+    apr_thread_mutex_t *new_m;
+    apr_status_t stat = APR_SUCCESS;
+  
+    new_m = (apr_thread_mutex_t *)apr_pcalloc(pool, sizeof(apr_thread_mutex_t));
+    if (new_m == NULL){
+        return APR_ENOMEM;
+    }
+    
+    if ((stat = create_sem(0, "APR_Lock")) < B_NO_ERROR) {
+        _thread_mutex_cleanup(new_m);
+        return stat;
+    }
+    new_m->LockCount = 0;
+    new_m->Lock = stat;  
+    new_m->pool  = pool;
+
+    /* Optimal default is APR_THREAD_MUTEX_UNNESTED, 
+     * no additional checks required for either flag.
+     */
+    new_m->nested = flags & APR_THREAD_MUTEX_NESTED;
+
+    apr_pool_cleanup_register(new_m->pool, (void *)new_m, _thread_mutex_cleanup,
+                              apr_pool_cleanup_null);
+
+    (*mutex) = new_m;
+    return APR_SUCCESS;
+}
+
+#if APR_HAS_CREATE_LOCKS_NP
+APR_DECLARE(apr_status_t) apr_thread_mutex_create_np(apr_thread_mutex_t **mutex,
+                                                   const char *fname,
+                                                   apr_lockmech_e_np mech,
+                                                   apr_pool_t *pool)
+{
+    return APR_ENOTIMPL;
+}       
+#endif
+  
+APR_DECLARE(apr_status_t) apr_thread_mutex_lock(apr_thread_mutex_t *mutex)
+{
+    int32 stat;
+    thread_id me = find_thread(NULL);
+    
+    if (mutex->nested && mutex->owner == me) {
+        mutex->owner_ref++;
+        return APR_SUCCESS;
+    }
+    
+	if (atomic_add(&mutex->LockCount, 1) > 0) {
+		if ((stat = acquire_sem(mutex->Lock)) < B_NO_ERROR) {
+            /* Oh dear, acquire_sem failed!!  */
+		    atomic_add(&mutex->LockCount, -1);
+		    return stat;
+		}
+	}
+
+    mutex->owner = me;
+    mutex->owner_ref = 1;
+    
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_mutex_trylock(apr_thread_mutex_t *mutex)
+{
+    return APR_ENOTIMPL;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_mutex_unlock(apr_thread_mutex_t *mutex)
+{
+    int32 stat;
+        
+    if (mutex->nested && mutex->owner == find_thread(NULL)) {
+        mutex->owner_ref--;
+        if (mutex->owner_ref > 0)
+            return APR_SUCCESS;
+    }
+    
+	if (atomic_add(&mutex->LockCount, -1) > 1) {
+        if ((stat = release_sem(mutex->Lock)) < B_NO_ERROR) {
+            atomic_add(&mutex->LockCount, 1);
+            return stat;
+        }
+    }
+
+    mutex->owner = -1;
+    mutex->owner_ref = 0;
+
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_mutex_destroy(apr_thread_mutex_t *mutex)
+{
+    apr_status_t stat;
+    if ((stat = _thread_mutex_cleanup(mutex)) == APR_SUCCESS) {
+        apr_pool_cleanup_kill(mutex->pool, mutex, _thread_mutex_cleanup);
+        return APR_SUCCESS;
+    }
+    return stat;
+}
+
+APR_POOL_IMPLEMENT_ACCESSOR(thread_mutex)
+
diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/locks/beos/thread_rwlock.c b/rubbos/app/httpd-2.0.64/srclib/apr/locks/beos/thread_rwlock.c
new file mode 100644
index 00000000..915b919c
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/srclib/apr/locks/beos/thread_rwlock.c
@@ -0,0 +1,190 @@
+/* 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.
+ */
+
+/*Read/Write locking implementation based on the MultiLock code from
+ * Stephen Beaulieu <hippo@be.com>
+ */
+ 
+#include "beos/apr_arch_thread_rwlock.h"
+#include "apr_strings.h"
+#include "apr_portable.h"
+
+#define BIG_NUM 100000
+
+static apr_status_t _thread_rw_cleanup(void * data)
+{
+    apr_thread_rwlock_t *mutex = (apr_thread_rwlock_t*)data;
+
+    if (mutex->ReadCount != 0) {
+    	while (atomic_add(&mutex->ReadCount , -1) > 1){
+            release_sem (mutex->Read);
+    	}
+    }
+    if (mutex->WriteCount != 0) {
+    	while (atomic_add(&mutex->WriteCount , -1) > 1){
+            release_sem (mutex->Write);
+    	}
+    }
+    if (mutex->LockCount != 0) {
+    	while (atomic_add(&mutex->LockCount , -1) > 1){
+            release_sem (mutex->Lock);
+    	}
+    }
+    
+    delete_sem(mutex->Read);
+    delete_sem(mutex->Write);
+    delete_sem(mutex->Lock);
+    return APR_SUCCESS;
+}    
+
+APR_DECLARE(apr_status_t) apr_thread_rwlock_create(apr_thread_rwlock_t **rwlock,
+                                                   apr_pool_t *pool)
+{
+    apr_thread_rwlock_t *new;
+  
+    new = (apr_thread_rwlock_t *)apr_pcalloc(pool, sizeof(apr_thread_rwlock_t));
+    if (new == NULL){
+        return APR_ENOMEM;
+    }
+    
+    new->pool  = pool;
+    /* we need to make 3 locks... */
+    new->ReadCount = 0;
+    new->WriteCount = 0;
+    new->LockCount = 0;
+    new->Read  = create_sem(0, "APR_ReadLock");
+    new->Write = create_sem(0, "APR_WriteLock");
+    new->Lock  = create_sem(0, "APR_Lock");
+    
+    if (new->Lock < 0 || new->Read < 0 || new->Write < 0) {
+        _thread_rw_cleanup(new);
+        return -1;
+    }
+
+    apr_pool_cleanup_register(new->pool, (void *)new, _thread_rw_cleanup,
+                              apr_pool_cleanup_null);
+    (*rwlock) = new;
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_rwlock_rdlock(apr_thread_rwlock_t *rwlock)
+{
+    int32 rv = APR_SUCCESS;
+
+    if (find_thread(NULL) == rwlock->writer) {
+        /* we're the writer - no problem */
+        rwlock->Nested++;
+    } else {
+        /* we're not the writer */
+        int32 r = atomic_add(&rwlock->ReadCount, 1);
+        if (r < 0) {
+            /* Oh dear, writer holds lock, wait for sem */
+            rv = acquire_sem_etc(rwlock->Read, 1, B_DO_NOT_RESCHEDULE,
+                                 B_INFINITE_TIMEOUT);
+        }
+    }
+
+    return rv;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_rwlock_tryrdlock(apr_thread_rwlock_t *rwlock)
+{
+    return APR_ENOTIMPL;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_rwlock_wrlock(apr_thread_rwlock_t *rwlock)
+{
+    int rv = APR_SUCCESS;
+
+    if (find_thread(NULL) == rwlock->writer) {
+        rwlock->Nested++;
+    } else {
+        /* we're not the writer... */
+        if (atomic_add(&rwlock->LockCount, 1) >= 1) {
+            /* we're locked - acquire the sem */
+            rv = acquire_sem_etc(rwlock->Lock, 1, B_DO_NOT_RESCHEDULE,
+                                 B_INFINITE_TIMEOUT);
+        }
+        if (rv == APR_SUCCESS) {
+            /* decrement the ReadCount to a large -ve number so that
+             * we block on new readers...
+             */
+            int32 readers = atomic_add(&rwlock->ReadCount, -BIG_NUM);
+            if (readers > 0) {
+                /* readers are holding the lock */
+                rv = acquire_sem_etc(rwlock->Write, readers, B_DO_NOT_RESCHEDULE,
+                                     B_INFINITE_TIMEOUT);
+            }
+            if (rv == APR_SUCCESS)
+                rwlock->writer = find_thread(NULL);
+        }
+    }
+    
+    return rv;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_rwlock_trywrlock(apr_thread_rwlock_t *rwlock)
+{
+    return APR_ENOTIMPL;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_rwlock_unlock(apr_thread_rwlock_t *rwlock)
+{
+    apr_status_t rv = APR_SUCCESS;
+    int32 readers;
+
+    /* we know we hold the lock, so don't check it :) */
+    if (find_thread(NULL) == rwlock->writer) {
+    /* we know we hold the lock, so don't check it :) */
+        if (rwlock->Nested > 1) {
+            /* we're recursively locked */
+            rwlock->Nested--;
+            return APR_SUCCESS;
+        }
+        /* OK so we need to release the sem if we have it :) */
+        readers = atomic_add(&rwlock->ReadCount, BIG_NUM) + BIG_NUM;
+        if (readers > 0) {
+            rv = release_sem_etc(rwlock->Read, readers, B_DO_NOT_RESCHEDULE);
+        }
+        if (rv == APR_SUCCESS) {
+            rwlock->writer = -1;
+            if (atomic_add(&rwlock->LockCount, -1) > 1) {
+                rv = release_sem_etc(rwlock->Lock, 1, B_DO_NOT_RESCHEDULE);
+            }
+        }
+    } else {
+       /* We weren't the Writer, so just release the ReadCount... */
+       if (atomic_add(&rwlock->ReadCount, -1) < 0) {
+            /* we have a writer waiting for the lock, so release it */
+            rv = release_sem_etc(rwlock->Write, 1, B_DO_NOT_RESCHEDULE);
+        }
+    }
+
+    return rv;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_rwlock_destroy(apr_thread_rwlock_t *rwlock)
+{
+    apr_status_t stat;
+    if ((stat = _thread_rw_cleanup(rwlock)) == APR_SUCCESS) {
+        apr_pool_cleanup_kill(rwlock->pool, rwlock, _thread_rw_cleanup);
+        return APR_SUCCESS;
+    }
+    return stat;
+}
+
+APR_POOL_IMPLEMENT_ACCESSOR(thread_rwlock)
+
diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/locks/netware/proc_mutex.c b/rubbos/app/httpd-2.0.64/srclib/apr/locks/netware/proc_mutex.c
new file mode 100644
index 00000000..77411d0b
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/srclib/apr/locks/netware/proc_mutex.c
@@ -0,0 +1,118 @@
+/* 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_portable.h"
+#include "apr_arch_proc_mutex.h"
+#include "apr_arch_thread_mutex.h"
+
+APR_DECLARE(apr_status_t) apr_proc_mutex_create(apr_proc_mutex_t **mutex,
+                                                const char *fname,
+                                                apr_lockmech_e mech,
+                                                apr_pool_t *pool)
+{
+    apr_status_t ret;
+    apr_proc_mutex_t *new_mutex = NULL;
+    new_mutex = (apr_proc_mutex_t *)apr_pcalloc(pool, sizeof(apr_proc_mutex_t));
+	
+	if(new_mutex ==NULL) {
+        return APR_ENOMEM;
+    }     
+    
+    new_mutex->pool = pool;
+    ret = apr_thread_mutex_create(&(new_mutex->mutex), APR_THREAD_MUTEX_DEFAULT, pool);
+
+    if (ret == APR_SUCCESS)
+        *mutex = new_mutex;
+
+    return ret;
+}
+
+APR_DECLARE(apr_status_t) apr_proc_mutex_child_init(apr_proc_mutex_t **mutex,
+                                                    const char *fname,
+                                                    apr_pool_t *pool)
+{
+    return APR_SUCCESS;
+}
+    
+APR_DECLARE(apr_status_t) apr_proc_mutex_lock(apr_proc_mutex_t *mutex)
+{
+    if (mutex)
+        return apr_thread_mutex_lock(mutex->mutex);
+    return APR_ENOLOCK;
+}
+
+APR_DECLARE(apr_status_t) apr_proc_mutex_trylock(apr_proc_mutex_t *mutex)
+{
+    if (mutex)
+        return apr_thread_mutex_trylock(mutex->mutex);
+    return APR_ENOLOCK;
+}
+
+APR_DECLARE(apr_status_t) apr_proc_mutex_unlock(apr_proc_mutex_t *mutex)
+{
+    if (mutex)
+        return apr_thread_mutex_unlock(mutex->mutex);
+    return APR_ENOLOCK;
+}
+
+APR_DECLARE(apr_status_t) apr_proc_mutex_cleanup(void *mutex)
+{
+    return apr_proc_mutex_destroy(mutex);
+}
+
+APR_DECLARE(apr_status_t) apr_proc_mutex_destroy(apr_proc_mutex_t *mutex)
+{
+    if (mutex)
+        return apr_thread_mutex_destroy(mutex->mutex);
+    return APR_ENOLOCK;
+}
+
+APR_DECLARE(const char *) apr_proc_mutex_lockfile(apr_proc_mutex_t *mutex)
+{
+    return NULL;
+}
+
+APR_DECLARE(const char *) apr_proc_mutex_name(apr_proc_mutex_t *mutex)
+{
+    return "netwarethread";
+}
+
+APR_DECLARE(const char *) apr_proc_mutex_defname(void)
+{
+    return "netwarethread";
+}
+
+APR_POOL_IMPLEMENT_ACCESSOR(proc_mutex)
+
+/* Implement OS-specific accessors defined in apr_portable.h */
+
+apr_status_t apr_os_proc_mutex_get(apr_os_proc_mutex_t *ospmutex,
+                                   apr_proc_mutex_t *pmutex)
+{
+    if (pmutex)
+        ospmutex = pmutex->mutex->mutex;
+    return APR_ENOLOCK;
+}
+
+apr_status_t apr_os_proc_mutex_put(apr_proc_mutex_t **pmutex,
+                                   apr_os_proc_mutex_t *ospmutex,
+                                   apr_pool_t *pool)
+{
+    return APR_ENOTIMPL;
+}
+
diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/locks/netware/thread_cond.c b/rubbos/app/httpd-2.0.64/srclib/apr/locks/netware/thread_cond.c
new file mode 100644
index 00000000..dcb21edc
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/srclib/apr/locks/netware/thread_cond.c
@@ -0,0 +1,100 @@
+/* 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 <nks/errno.h>
+
+#include "apr.h"
+#include "apr_private.h"
+#include "apr_general.h"
+#include "apr_strings.h"
+#include "apr_arch_thread_mutex.h"
+#include "apr_arch_thread_cond.h"
+#include "apr_portable.h"
+
+static apr_status_t thread_cond_cleanup(void *data)
+{
+    apr_thread_cond_t *cond = (apr_thread_cond_t *)data;
+
+    NXCondFree(cond->cond);        
+    return APR_SUCCESS;
+} 
+
+APR_DECLARE(apr_status_t) apr_thread_cond_create(apr_thread_cond_t **cond,
+                                                 apr_pool_t *pool)
+{
+    apr_thread_cond_t *new_cond = NULL;
+
+    new_cond = (apr_thread_cond_t *)apr_pcalloc(pool, sizeof(apr_thread_cond_t));
+	
+	if(new_cond ==NULL) {
+        return APR_ENOMEM;
+    }     
+    new_cond->pool = pool;
+
+    new_cond->cond = NXCondAlloc(NULL);
+    
+    if(new_cond->cond == NULL)
+        return APR_ENOMEM;
+
+    apr_pool_cleanup_register(new_cond->pool, new_cond, 
+                                (void*)thread_cond_cleanup,
+                                apr_pool_cleanup_null);
+   *cond = new_cond;
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_cond_wait(apr_thread_cond_t *cond,
+                                               apr_thread_mutex_t *mutex)
+{
+    if (NXCondWait(cond->cond, mutex->mutex) != 0)
+        return APR_EINTR;
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_cond_timedwait(apr_thread_cond_t *cond,
+                                                    apr_thread_mutex_t *mutex,
+                                                    apr_interval_time_t timeout){
+    if (NXCondTimedWait(cond->cond, mutex->mutex, 
+        (timeout*1000)/NXGetSystemTick()) == NX_ETIMEDOUT) {
+        return APR_TIMEUP;
+    }
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_cond_signal(apr_thread_cond_t *cond)
+{
+    NXCondSignal(cond->cond);
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_cond_broadcast(apr_thread_cond_t *cond)
+{
+    NXCondBroadcast(cond->cond);
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_cond_destroy(apr_thread_cond_t *cond)
+{
+    apr_status_t stat;
+    if ((stat = thread_cond_cleanup(cond)) == APR_SUCCESS) {
+        apr_pool_cleanup_kill(cond->pool, cond, thread_cond_cleanup);
+        return APR_SUCCESS;
+    }
+    return stat;
+}
+
+APR_POOL_IMPLEMENT_ACCESSOR(thread_cond)
+
diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/locks/netware/thread_mutex.c b/rubbos/app/httpd-2.0.64/srclib/apr/locks/netware/thread_mutex.c
new file mode 100644
index 00000000..98bf33bd
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/srclib/apr/locks/netware/thread_mutex.c
@@ -0,0 +1,92 @@
+/* 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_general.h"
+#include "apr_strings.h"
+#include "apr_arch_thread_mutex.h"
+#include "apr_portable.h"
+
+static apr_status_t thread_mutex_cleanup(void *data)
+{
+    apr_thread_mutex_t *mutex = (apr_thread_mutex_t *)data;
+
+    NXMutexFree(mutex->mutex);        
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_mutex_create(apr_thread_mutex_t **mutex,
+                                                  unsigned int flags,
+                                                  apr_pool_t *pool)
+{
+    apr_thread_mutex_t *new_mutex = NULL;
+
+    /* XXX: Implement _UNNESTED flavor and favor _DEFAULT for performance
+     */
+    if (flags & APR_THREAD_MUTEX_UNNESTED) {
+        return APR_ENOTIMPL;
+    }
+    new_mutex = (apr_thread_mutex_t *)apr_pcalloc(pool, sizeof(apr_thread_mutex_t));
+	
+	if(new_mutex ==NULL) {
+        return APR_ENOMEM;
+    }     
+    new_mutex->pool = pool;
+
+    new_mutex->mutex = NXMutexAlloc(NX_MUTEX_RECURSIVE, 0, NULL);
+    
+    if(new_mutex->mutex == NULL)
+        return APR_ENOMEM;
+
+    apr_pool_cleanup_register(new_mutex->pool, new_mutex, 
+                                (void*)thread_mutex_cleanup,
+                                apr_pool_cleanup_null);
+   *mutex = new_mutex;
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_mutex_lock(apr_thread_mutex_t *mutex)
+{
+    NXLock(mutex->mutex);
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_mutex_trylock(apr_thread_mutex_t *mutex)
+{
+    if (!NXTryLock(mutex->mutex))
+        return APR_EBUSY;
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_mutex_unlock(apr_thread_mutex_t *mutex)
+{
+    NXUnlock(mutex->mutex);
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_mutex_destroy(apr_thread_mutex_t *mutex)
+{
+    apr_status_t stat;
+    if ((stat = thread_mutex_cleanup(mutex)) == APR_SUCCESS) {
+        apr_pool_cleanup_kill(mutex->pool, mutex, thread_mutex_cleanup);
+        return APR_SUCCESS;
+    }
+    return stat;
+}
+
+APR_POOL_IMPLEMENT_ACCESSOR(thread_mutex)
+
diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/locks/netware/thread_rwlock.c b/rubbos/app/httpd-2.0.64/srclib/apr/locks/netware/thread_rwlock.c
new file mode 100644
index 00000000..d0bf3ddf
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/srclib/apr/locks/netware/thread_rwlock.c
@@ -0,0 +1,102 @@
+/* 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_general.h"
+#include "apr_strings.h"
+#include "apr_arch_thread_rwlock.h"
+#include "apr_portable.h"
+
+static apr_status_t thread_rwlock_cleanup(void *data)
+{
+    apr_thread_rwlock_t *rwlock = (apr_thread_rwlock_t *)data;
+
+    NXRwLockFree (rwlock->rwlock);
+    return APR_SUCCESS;
+} 
+
+APR_DECLARE(apr_status_t) apr_thread_rwlock_create(apr_thread_rwlock_t **rwlock,
+                                                   apr_pool_t *pool)
+{
+    apr_thread_rwlock_t *new_rwlock = NULL;
+   
+	NXHierarchy_t hierarchy = 1;   //for libc NKS NXRwLockAlloc
+	NXLockInfo_t *info;			   //for libc NKS NXRwLockAlloc
+
+    new_rwlock = (apr_thread_rwlock_t *)apr_pcalloc(pool, sizeof(apr_thread_rwlock_t));
+	
+	if(new_rwlock ==NULL) {
+        return APR_ENOMEM;
+    }     
+    new_rwlock->pool = pool;
+    
+    info = (NXLockInfo_t *)apr_pcalloc(pool, sizeof(NXLockInfo_t));
+    new_rwlock->rwlock = NXRwLockAlloc(hierarchy, info);
+    if(new_rwlock->rwlock == NULL)
+        return APR_ENOMEM;
+
+    apr_pool_cleanup_register(new_rwlock->pool, new_rwlock, thread_rwlock_cleanup,
+                              apr_pool_cleanup_null);
+    *rwlock = new_rwlock;
+
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_rwlock_rdlock(apr_thread_rwlock_t *rwlock)
+{
+    NXRdLock(rwlock->rwlock);
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_rwlock_tryrdlock(apr_thread_rwlock_t *rwlock)
+{
+    if (!NXTryRdLock(rwlock->rwlock))
+        return APR_EBUSY;
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_rwlock_wrlock(apr_thread_rwlock_t *rwlock)
+{
+    NXWrLock(rwlock->rwlock);
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_rwlock_trywrlock(apr_thread_rwlock_t *rwlock)
+{
+    if (!NXTryWrLock(rwlock->rwlock))
+        return APR_EBUSY;
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_rwlock_unlock(apr_thread_rwlock_t *rwlock)
+{
+    NXRwUnlock(rwlock->rwlock);
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_rwlock_destroy(apr_thread_rwlock_t *rwlock)
+{
+    apr_status_t stat;
+    if ((stat = thread_rwlock_cleanup(rwlock)) == APR_SUCCESS) {
+        apr_pool_cleanup_kill(rwlock->pool, rwlock, thread_rwlock_cleanup);
+        return APR_SUCCESS;
+    }
+    return stat;
+}
+
+APR_POOL_IMPLEMENT_ACCESSOR(thread_rwlock)
+
diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/locks/os2/Makefile.in b/rubbos/app/httpd-2.0.64/srclib/apr/locks/os2/Makefile.in
new file mode 100644
index 00000000..e22f85c9
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/srclib/apr/locks/os2/Makefile.in
@@ -0,0 +1,18 @@
+srcdir = @srcdir@
+VPATH = @srcdir@
+
+TARGETS = \
+	thread_mutex.lo \
+	thread_rwlock.lo \
+	thread_cond.lo \
+	proc_mutex.lo
+
+# bring in rules.mk for standard functionality
+@INCLUDE_RULES@
+
+INCDIR=../../include
+OSDIR=$(INCDIR)/arch/@OSDIR@
+DEFOSDIR=$(INCDIR)/arch/@DEFAULT_OSDIR@
+INCLUDES=-I$(INCDIR) -I$(OSDIR) -I$(DEFOSDIR)
+
+# DO NOT REMOVE
diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/locks/os2/proc_mutex.c b/rubbos/app/httpd-2.0.64/srclib/apr/locks/os2/proc_mutex.c
new file mode 100644
index 00000000..5a493563
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/srclib/apr/locks/os2/proc_mutex.c
@@ -0,0 +1,234 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "apr_general.h"
+#include "apr_lib.h"
+#include "apr_strings.h"
+#include "apr_portable.h"
+#include "apr_arch_proc_mutex.h"
+#include "apr_arch_file_io.h"
+#include <string.h>
+#include <stddef.h>
+
+#define CurrentTid (*_threadid)
+
+static char *fixed_name(const char *fname, apr_pool_t *pool)
+{
+    char *semname;
+
+    if (fname == NULL)
+        semname = NULL;
+    else {
+        // Semaphores don't live in the file system, fix up the name
+        while (*fname == '/' || *fname == '\\') {
+            fname++;
+        }
+
+        semname = apr_pstrcat(pool, "/SEM32/", fname, NULL);
+
+        if (semname[8] == ':') {
+            semname[8] = '$';
+        }
+    }
+
+    return semname;
+}
+
+
+
+APR_DECLARE(apr_status_t) apr_proc_mutex_cleanup(void *vmutex)
+{
+    apr_proc_mutex_t *mutex = vmutex;
+    return apr_proc_mutex_destroy(mutex);
+}
+
+APR_DECLARE(const char *) apr_proc_mutex_lockfile(apr_proc_mutex_t *mutex)
+{
+    return NULL;
+}
+
+APR_DECLARE(const char *) apr_proc_mutex_name(apr_proc_mutex_t *mutex)
+{
+    return "os2sem";
+}
+
+APR_DECLARE(const char *) apr_proc_mutex_defname(void)
+{
+    return "os2sem";
+}
+
+
+APR_DECLARE(apr_status_t) apr_proc_mutex_create(apr_proc_mutex_t **mutex,
+                                                const char *fname,
+                                                apr_lockmech_e mech,
+                                                apr_pool_t *pool)
+{
+    apr_proc_mutex_t *new;
+    ULONG rc;
+    char *semname;
+
+    if (mech != APR_LOCK_DEFAULT) {
+        return APR_ENOTIMPL;
+    }
+
+    new = (apr_proc_mutex_t *)apr_palloc(pool, sizeof(apr_proc_mutex_t));
+    new->pool       = pool;
+    new->owner      = 0;
+    new->lock_count = 0;
+    *mutex = new;
+
+    semname = fixed_name(fname, pool);
+    rc = DosCreateMutexSem(semname, &(new->hMutex), DC_SEM_SHARED, FALSE);
+
+    if (!rc) {
+        apr_pool_cleanup_register(pool, new, apr_proc_mutex_cleanup, apr_pool_cleanup_null);
+    }
+
+    return APR_FROM_OS_ERROR(rc);
+}
+
+
+
+APR_DECLARE(apr_status_t) apr_proc_mutex_child_init(apr_proc_mutex_t **mutex,
+                                                    const char *fname,
+                                                    apr_pool_t *pool)
+{
+    apr_proc_mutex_t *new;
+    ULONG rc;
+    char *semname;
+
+    new = (apr_proc_mutex_t *)apr_palloc(pool, sizeof(apr_proc_mutex_t));
+    new->pool       = pool;
+    new->owner      = 0;
+    new->lock_count = 0;
+
+    semname = fixed_name(fname, pool);
+    rc = DosOpenMutexSem(semname, &(new->hMutex));
+    *mutex = new;
+
+    if (!rc) {
+        apr_pool_cleanup_register(pool, new, apr_proc_mutex_cleanup, apr_pool_cleanup_null);
+    }
+
+    return APR_FROM_OS_ERROR(rc);
+}
+
+
+
+APR_DECLARE(apr_status_t) apr_proc_mutex_lock(apr_proc_mutex_t *mutex)
+{
+    ULONG rc = DosRequestMutexSem(mutex->hMutex, SEM_INDEFINITE_WAIT);
+
+    if (rc == 0) {
+        mutex->owner = CurrentTid;
+        mutex->lock_count++;
+    }
+
+    return APR_FROM_OS_ERROR(rc);
+}
+
+
+
+APR_DECLARE(apr_status_t) apr_proc_mutex_trylock(apr_proc_mutex_t *mutex)
+{
+    ULONG rc = DosRequestMutexSem(mutex->hMutex, SEM_IMMEDIATE_RETURN);
+
+    if (rc == 0) {
+        mutex->owner = CurrentTid;
+        mutex->lock_count++;
+    }
+
+    return APR_FROM_OS_ERROR(rc);
+}
+
+
+
+APR_DECLARE(apr_status_t) apr_proc_mutex_unlock(apr_proc_mutex_t *mutex)
+{
+    ULONG rc;
+
+    if (mutex->owner == CurrentTid && mutex->lock_count > 0) {
+        mutex->lock_count--;
+        rc = DosReleaseMutexSem(mutex->hMutex);
+        return APR_FROM_OS_ERROR(rc);
+    }
+
+    return APR_SUCCESS;
+}
+
+
+
+APR_DECLARE(apr_status_t) apr_proc_mutex_destroy(apr_proc_mutex_t *mutex)
+{
+    ULONG rc;
+    apr_status_t status = APR_SUCCESS;
+
+    if (mutex->owner == CurrentTid) {
+        while (mutex->lock_count > 0 && status == APR_SUCCESS) {
+            status = apr_proc_mutex_unlock(mutex);
+        }
+    }
+
+    if (status != APR_SUCCESS) {
+        return status;
+    }
+
+    if (mutex->hMutex == 0) {
+        return APR_SUCCESS;
+    }
+
+    rc = DosCloseMutexSem(mutex->hMutex);
+
+    if (!rc) {
+        mutex->hMutex = 0;
+    }
+
+    return APR_FROM_OS_ERROR(rc);
+}
+
+
+
+APR_POOL_IMPLEMENT_ACCESSOR(proc_mutex)
+
+
+
+/* Implement OS-specific accessors defined in apr_portable.h */
+
+APR_DECLARE(apr_status_t) apr_os_proc_mutex_get(apr_os_proc_mutex_t *ospmutex,
+                                                apr_proc_mutex_t *pmutex)
+{
+    *ospmutex = pmutex->hMutex;
+    return APR_ENOTIMPL;
+}
+
+
+
+APR_DECLARE(apr_status_t) apr_os_proc_mutex_put(apr_proc_mutex_t **pmutex,
+                                                apr_os_proc_mutex_t *ospmutex,
+                                                apr_pool_t *pool)
+{
+    apr_proc_mutex_t *new;
+
+    new = (apr_proc_mutex_t *)apr_palloc(pool, sizeof(apr_proc_mutex_t));
+    new->pool       = pool;
+    new->owner      = 0;
+    new->lock_count = 0;
+    new->hMutex     = *ospmutex;
+    *pmutex = new;
+
+    return APR_SUCCESS;
+}
+
diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/locks/os2/thread_cond.c b/rubbos/app/httpd-2.0.64/srclib/apr/locks/os2/thread_cond.c
new file mode 100644
index 00000000..ec6034f5
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/srclib/apr/locks/os2/thread_cond.c
@@ -0,0 +1,60 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "apr_general.h"
+#include "apr_lib.h"
+#include "apr_strings.h"
+#include "apr_portable.h"
+#include "apr_arch_thread_mutex.h"
+#include "apr_arch_thread_cond.h"
+#include "apr_arch_file_io.h"
+#include <string.h>
+
+APR_DECLARE(apr_status_t) apr_thread_cond_create(apr_thread_cond_t **cond,
+                                                 apr_pool_t *pool)
+{
+    return APR_ENOTIMPL;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_cond_wait(apr_thread_cond_t *cond,
+                                               apr_thread_mutex_t *mutex)
+{
+    return APR_ENOTIMPL;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_cond_timedwait(apr_thread_cond_t *cond,
+                                                    apr_thread_mutex_t *mutex,
+                                                    apr_interval_time_t timeout){
+    return APR_ENOTIMPL;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_cond_signal(apr_thread_cond_t *cond)
+{
+    return APR_ENOTIMPL;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_cond_broadcast(apr_thread_cond_t *cond)
+{
+    return APR_ENOTIMPL;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_cond_destroy(apr_thread_cond_t *cond)
+{
+    return APR_ENOTIMPL;
+}
+
+APR_POOL_IMPLEMENT_ACCESSOR(thread_cond)
+
diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/locks/os2/thread_mutex.c b/rubbos/app/httpd-2.0.64/srclib/apr/locks/os2/thread_mutex.c
new file mode 100644
index 00000000..5d8436be
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/srclib/apr/locks/os2/thread_mutex.c
@@ -0,0 +1,102 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "apr_general.h"
+#include "apr_lib.h"
+#include "apr_strings.h"
+#include "apr_portable.h"
+#include "apr_arch_thread_mutex.h"
+#include "apr_arch_file_io.h"
+#include <string.h>
+#include <stddef.h>
+
+static apr_status_t thread_mutex_cleanup(void *themutex)
+{
+    apr_thread_mutex_t *mutex = themutex;
+    return apr_thread_mutex_destroy(mutex);
+}
+
+
+
+/* XXX: Need to respect APR_THREAD_MUTEX_[UN]NESTED flags argument
+ *      or return APR_ENOTIMPL!!!
+ */
+APR_DECLARE(apr_status_t) apr_thread_mutex_create(apr_thread_mutex_t **mutex,
+                                                  unsigned int flags,
+                                                  apr_pool_t *pool)
+{
+    apr_thread_mutex_t *new_mutex;
+    ULONG rc;
+
+    new_mutex = (apr_thread_mutex_t *)apr_palloc(pool, sizeof(apr_thread_mutex_t));
+    new_mutex->pool = pool;
+
+    rc = DosCreateMutexSem(NULL, &(new_mutex->hMutex), 0, FALSE);
+    *mutex = new_mutex;
+
+    if (!rc)
+        apr_pool_cleanup_register(pool, new_mutex, thread_mutex_cleanup, apr_pool_cleanup_null);
+
+    return APR_OS2_STATUS(rc);
+}
+
+
+
+APR_DECLARE(apr_status_t) apr_thread_mutex_lock(apr_thread_mutex_t *mutex)
+{
+    ULONG rc = DosRequestMutexSem(mutex->hMutex, SEM_INDEFINITE_WAIT);
+    return APR_OS2_STATUS(rc);
+}
+
+
+
+APR_DECLARE(apr_status_t) apr_thread_mutex_trylock(apr_thread_mutex_t *mutex)
+{
+    ULONG rc = DosRequestMutexSem(mutex->hMutex, SEM_IMMEDIATE_RETURN);
+    return APR_OS2_STATUS(rc);
+}
+
+
+
+APR_DECLARE(apr_status_t) apr_thread_mutex_unlock(apr_thread_mutex_t *mutex)
+{
+    ULONG rc = DosReleaseMutexSem(mutex->hMutex);
+    return APR_OS2_STATUS(rc);
+}
+
+
+
+APR_DECLARE(apr_status_t) apr_thread_mutex_destroy(apr_thread_mutex_t *mutex)
+{
+    ULONG rc;
+
+    if (mutex->hMutex == 0)
+        return APR_SUCCESS;
+
+    while (DosReleaseMutexSem(mutex->hMutex) == 0);
+
+    rc = DosCloseMutexSem(mutex->hMutex);
+
+    if (!rc) {
+        mutex->hMutex = 0;
+        return APR_SUCCESS;
+    }
+
+    return APR_FROM_OS_ERROR(rc);
+}
+
+APR_POOL_IMPLEMENT_ACCESSOR(thread_mutex)
+
diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/locks/os2/thread_rwlock.c b/rubbos/app/httpd-2.0.64/srclib/apr/locks/os2/thread_rwlock.c
new file mode 100644
index 00000000..195a56bd
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/srclib/apr/locks/os2/thread_rwlock.c
@@ -0,0 +1,200 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "apr_general.h"
+#include "apr_lib.h"
+#include "apr_strings.h"
+#include "apr_portable.h"
+#include "apr_arch_thread_rwlock.h"
+#include "apr_arch_file_io.h"
+#include <string.h>
+
+static apr_status_t thread_rwlock_cleanup(void *therwlock)
+{
+    apr_thread_rwlock_t *rwlock = therwlock;
+    return apr_thread_rwlock_destroy(rwlock);
+}
+
+
+
+APR_DECLARE(apr_status_t) apr_thread_rwlock_create(apr_thread_rwlock_t **rwlock,
+                                                   apr_pool_t *pool)
+{
+    apr_thread_rwlock_t *new_rwlock;
+    ULONG rc;
+
+    new_rwlock = (apr_thread_rwlock_t *)apr_palloc(pool, sizeof(apr_thread_rwlock_t));
+    new_rwlock->pool = pool;
+    new_rwlock->readers = 0;
+
+    rc = DosCreateMutexSem(NULL, &(new_rwlock->write_lock), 0, FALSE);
+
+    if (rc)
+        return APR_FROM_OS_ERROR(rc);
+
+    rc = DosCreateEventSem(NULL, &(new_rwlock->read_done), 0, FALSE);
+
+    if (rc)
+        return APR_FROM_OS_ERROR(rc);
+
+    *rwlock = new_rwlock;
+
+    if (!rc)
+        apr_pool_cleanup_register(pool, new_rwlock, thread_rwlock_cleanup,
+                                  apr_pool_cleanup_null);
+
+    return APR_FROM_OS_ERROR(rc);
+}
+
+
+
+APR_DECLARE(apr_status_t) apr_thread_rwlock_rdlock(apr_thread_rwlock_t *rwlock)
+{
+    ULONG rc, posts;
+
+    rc = DosRequestMutexSem(rwlock->write_lock, SEM_INDEFINITE_WAIT);
+
+    if (rc)
+        return APR_FROM_OS_ERROR(rc);
+
+    /* We've successfully acquired the writer mutex so we can't be locked
+     * for write which means it's ok to add a reader lock. The writer mutex
+     * doubles as race condition protection for the readers counter.
+     */
+    rwlock->readers++;
+    DosResetEventSem(rwlock->read_done, &posts);
+    rc = DosReleaseMutexSem(rwlock->write_lock);
+    return APR_FROM_OS_ERROR(rc);
+}
+
+
+
+APR_DECLARE(apr_status_t) apr_thread_rwlock_tryrdlock(apr_thread_rwlock_t *rwlock)
+{
+    /* As above but with different wait time */
+    ULONG rc, posts;
+
+    rc = DosRequestMutexSem(rwlock->write_lock, SEM_IMMEDIATE_RETURN);
+
+    if (rc)
+        return APR_FROM_OS_ERROR(rc);
+
+    rwlock->readers++;
+    DosResetEventSem(rwlock->read_done, &posts);
+    rc = DosReleaseMutexSem(rwlock->write_lock);
+    return APR_FROM_OS_ERROR(rc);
+}
+
+
+
+APR_DECLARE(apr_status_t) apr_thread_rwlock_wrlock(apr_thread_rwlock_t *rwlock)
+{
+    ULONG rc;
+
+    rc = DosRequestMutexSem(rwlock->write_lock, SEM_INDEFINITE_WAIT);
+
+    if (rc)
+        return APR_FROM_OS_ERROR(rc);
+
+    /* We've got the writer lock but we have to wait for all readers to
+     * unlock before it's ok to use it
+     */
+
+    if (rwlock->readers) {
+        rc = DosWaitEventSem(rwlock->read_done, SEM_INDEFINITE_WAIT);
+
+        if (rc)
+            DosReleaseMutexSem(rwlock->write_lock);
+    }
+
+    return APR_FROM_OS_ERROR(rc);
+}
+
+
+
+APR_DECLARE(apr_status_t) apr_thread_rwlock_trywrlock(apr_thread_rwlock_t *rwlock)
+{
+    ULONG rc;
+
+    rc = DosRequestMutexSem(rwlock->write_lock, SEM_IMMEDIATE_RETURN);
+
+    if (rc)
+        return APR_FROM_OS_ERROR(rc);
+
+    /* We've got the writer lock but we have to wait for all readers to
+     * unlock before it's ok to use it
+     */
+
+    if (rwlock->readers) {
+        /* There are readers active, give up */
+        DosReleaseMutexSem(rwlock->write_lock);
+        rc = ERROR_TIMEOUT;
+    }
+
+    return APR_FROM_OS_ERROR(rc);
+}
+
+
+
+APR_DECLARE(apr_status_t) apr_thread_rwlock_unlock(apr_thread_rwlock_t *rwlock)
+{
+    ULONG rc;
+
+    /* First, guess that we're unlocking a writer */
+    rc = DosReleaseMutexSem(rwlock->write_lock);
+
+    if (rc == ERROR_NOT_OWNER) {
+        /* Nope, we must have a read lock */
+        if (rwlock->readers) {
+            DosEnterCritSec();
+            rwlock->readers--;
+
+            if (rwlock->readers == 0) {
+                DosPostEventSem(rwlock->read_done);
+            }
+
+            DosExitCritSec();
+            rc = 0;
+        }
+    }
+
+    return APR_FROM_OS_ERROR(rc);
+}
+
+
+
+APR_DECLARE(apr_status_t) apr_thread_rwlock_destroy(apr_thread_rwlock_t *rwlock)
+{
+    ULONG rc;
+
+    if (rwlock->write_lock == 0)
+        return APR_SUCCESS;
+
+    while (DosReleaseMutexSem(rwlock->write_lock) == 0);
+
+    rc = DosCloseMutexSem(rwlock->write_lock);
+
+    if (!rc) {
+        rwlock->write_lock = 0;
+        DosCloseEventSem(rwlock->read_done);
+        return APR_SUCCESS;
+    }
+
+    return APR_FROM_OS_ERROR(rc);
+}
+
+APR_POOL_IMPLEMENT_ACCESSOR(thread_rwlock)
+
diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/.libs/global_mutex.o b/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/.libs/global_mutex.o
new file mode 100644
index 00000000..3eebee5d
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/.libs/global_mutex.o
diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/.libs/proc_mutex.o b/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/.libs/proc_mutex.o
new file mode 100644
index 00000000..400b58df
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/.libs/proc_mutex.o
diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/.libs/thread_cond.o b/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/.libs/thread_cond.o
new file mode 100644
index 00000000..bd2f15fe
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/.libs/thread_cond.o
diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/.libs/thread_mutex.o b/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/.libs/thread_mutex.o
new file mode 100644
index 00000000..68df9b5e
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/.libs/thread_mutex.o
diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/.libs/thread_rwlock.o b/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/.libs/thread_rwlock.o
new file mode 100644
index 00000000..3b39fdc5
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/.libs/thread_rwlock.o
diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/Makefile b/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/Makefile
new file mode 100644
index 00000000..7e08a35e
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/Makefile
@@ -0,0 +1,19 @@
+srcdir = .
+
+
+TARGETS = \
+	thread_mutex.lo \
+	thread_rwlock.lo \
+	thread_cond.lo \
+	proc_mutex.lo \
+	global_mutex.lo
+
+# bring in rules.mk for standard functionality
+include /bottlenecks/rubbos/app/httpd-2.0.64/srclib/apr/build/apr_rules.mk
+
+INCDIR=../../include
+INCDIR2=$(INCDIR)/arch
+INCDIR3=$(INCDIR)/arch/unix
+INCLUDES=-I$(INCDIR) -I$(INCDIR2) -I$(INCDIR3)
+
+# DO NOT REMOVE
diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/Makefile.in b/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/Makefile.in
new file mode 100644
index 00000000..618b0eb1
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/Makefile.in
@@ -0,0 +1,19 @@
+srcdir = @srcdir@
+VPATH = @srcdir@
+
+TARGETS = \
+	thread_mutex.lo \
+	thread_rwlock.lo \
+	thread_cond.lo \
+	proc_mutex.lo \
+	global_mutex.lo
+
+# bring in rules.mk for standard functionality
+@INCLUDE_RULES@
+
+INCDIR=../../include
+INCDIR2=$(INCDIR)/arch
+INCDIR3=$(INCDIR)/arch/unix
+INCLUDES=-I$(INCDIR) -I$(INCDIR2) -I$(INCDIR3)
+
+# DO NOT REMOVE
diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/global_mutex.c b/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/global_mutex.c
new file mode 100644
index 00000000..bfe360aa
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/global_mutex.c
@@ -0,0 +1,178 @@
+/* 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_strings.h"
+#include "apr_arch_global_mutex.h"
+#include "apr_proc_mutex.h"
+#include "apr_thread_mutex.h"
+#include "apr_portable.h"
+
+static apr_status_t global_mutex_cleanup(void *data)
+{
+    apr_global_mutex_t *m = (apr_global_mutex_t *)data;
+    apr_status_t rv;
+
+    rv = apr_proc_mutex_destroy(m->proc_mutex);
+
+#if APR_HAS_THREADS
+    if (m->thread_mutex) {
+        if (rv != APR_SUCCESS) {
+            (void)apr_thread_mutex_destroy(m->thread_mutex);
+        }
+        else {
+            rv = apr_thread_mutex_destroy(m->thread_mutex);
+        }
+    }
+#endif /* APR_HAS_THREADS */
+
+    return rv;
+}
+
+APR_DECLARE(apr_status_t) apr_global_mutex_create(apr_global_mutex_t **mutex,
+                                                  const char *fname,
+                                                  apr_lockmech_e mech,
+                                                  apr_pool_t *pool)
+{
+    apr_status_t rv;
+    apr_global_mutex_t *m;
+
+    m = (apr_global_mutex_t *)apr_palloc(pool, sizeof(*m));
+    m->pool = pool;
+
+    rv = apr_proc_mutex_create(&m->proc_mutex, fname, mech, m->pool);
+    if (rv != APR_SUCCESS) {
+        return rv;
+    }
+
+#if APR_HAS_THREADS
+    if (m->proc_mutex->inter_meth->flags & APR_PROCESS_LOCK_MECH_IS_GLOBAL) {
+        m->thread_mutex = NULL; /* We don't need a thread lock. */
+    }
+    else {
+        rv = apr_thread_mutex_create(&m->thread_mutex,
+                                     APR_THREAD_MUTEX_DEFAULT, m->pool);
+        if (rv != APR_SUCCESS) {
+            rv = apr_proc_mutex_destroy(m->proc_mutex);
+            return rv;
+        }
+    }
+#endif /* APR_HAS_THREADS */
+
+    apr_pool_cleanup_register(m->pool, (void *)m,
+                              global_mutex_cleanup, apr_pool_cleanup_null);
+    *mutex = m;
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_global_mutex_child_init(
+                              apr_global_mutex_t **mutex,
+                              const char *fname,
+                              apr_pool_t *pool)
+{
+    apr_status_t rv;
+
+    rv = apr_proc_mutex_child_init(&((*mutex)->proc_mutex), fname, pool);
+    return rv;
+}
+
+APR_DECLARE(apr_status_t) apr_global_mutex_lock(apr_global_mutex_t *mutex)
+{
+    apr_status_t rv;
+
+#if APR_HAS_THREADS
+    if (mutex->thread_mutex) {
+        rv = apr_thread_mutex_lock(mutex->thread_mutex);
+        if (rv != APR_SUCCESS) {
+            return rv;
+        }
+    }
+#endif /* APR_HAS_THREADS */
+
+    rv = apr_proc_mutex_lock(mutex->proc_mutex);
+
+#if APR_HAS_THREADS
+    if (rv != APR_SUCCESS) {
+        if (mutex->thread_mutex) {
+            (void)apr_thread_mutex_unlock(mutex->thread_mutex);
+        }
+    }
+#endif /* APR_HAS_THREADS */
+
+    return rv;
+}
+
+APR_DECLARE(apr_status_t) apr_global_mutex_trylock(apr_global_mutex_t *mutex)
+{
+    apr_status_t rv;
+
+#if APR_HAS_THREADS
+    if (mutex->thread_mutex) {
+        rv = apr_thread_mutex_trylock(mutex->thread_mutex);
+        if (rv != APR_SUCCESS) {
+            return rv;
+        }
+    }
+#endif /* APR_HAS_THREADS */
+
+    rv = apr_proc_mutex_trylock(mutex->proc_mutex);
+
+#if APR_HAS_THREADS
+    if (rv != APR_SUCCESS) {
+        if (mutex->thread_mutex) {
+            (void)apr_thread_mutex_unlock(mutex->thread_mutex);
+        }
+    }
+#endif /* APR_HAS_THREADS */
+
+    return rv;
+}
+
+APR_DECLARE(apr_status_t) apr_global_mutex_unlock(apr_global_mutex_t *mutex)
+{
+    apr_status_t rv;
+
+    rv = apr_proc_mutex_unlock(mutex->proc_mutex);
+#if APR_HAS_THREADS
+    if (mutex->thread_mutex) {
+        if (rv != APR_SUCCESS) {
+            (void)apr_thread_mutex_unlock(mutex->thread_mutex);
+        }
+        else {
+            rv = apr_thread_mutex_unlock(mutex->thread_mutex);
+        }
+    }
+#endif /* APR_HAS_THREADS */
+    return rv;
+}
+
+APR_DECLARE(apr_status_t) apr_os_global_mutex_get(apr_os_global_mutex_t *ospmutex,
+                                                apr_global_mutex_t *pmutex)
+{
+    ospmutex->pool = pmutex->pool;
+    ospmutex->proc_mutex = pmutex->proc_mutex;
+#if APR_HAS_THREADS
+    ospmutex->thread_mutex = pmutex->thread_mutex;
+#endif
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_global_mutex_destroy(apr_global_mutex_t *mutex)
+{
+    return apr_pool_cleanup_run(mutex->pool, mutex, global_mutex_cleanup);
+}
+
+APR_POOL_IMPLEMENT_ACCESSOR(global_mutex)
diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/global_mutex.lo b/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/global_mutex.lo
new file mode 100644
index 00000000..d0fa5457
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/global_mutex.lo
@@ -0,0 +1,12 @@
+# global_mutex.lo - a libtool object file
+# Generated by ltmain.sh - GNU libtool 1.5.26 (1.1220.2.493 2008/02/01 16:58:18)
+#
+# Please DO NOT delete this file!
+# It is necessary for linking the library.
+
+# Name of the PIC object.
+pic_object='.libs/global_mutex.o'
+
+# Name of the non-PIC object.
+non_pic_object='global_mutex.o'
+
diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/global_mutex.o b/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/global_mutex.o
new file mode 100644
index 00000000..7e44179b
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/global_mutex.o
diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/proc_mutex.c b/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/proc_mutex.c
new file mode 100644
index 00000000..eb7b8de4
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/proc_mutex.c
@@ -0,0 +1,894 @@
+/* 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_strings.h"
+#include "apr_arch_proc_mutex.h"
+#include "apr_arch_file_io.h" /* for apr_mkstemp() */
+
+APR_DECLARE(apr_status_t) apr_proc_mutex_destroy(apr_proc_mutex_t *mutex)
+{
+    return apr_pool_cleanup_run(mutex->pool, mutex, apr_proc_mutex_cleanup);
+}
+
+static apr_status_t proc_mutex_no_tryacquire(apr_proc_mutex_t *new_mutex)
+{
+    return APR_ENOTIMPL;
+}
+
+#if APR_HAS_POSIXSEM_SERIALIZE
+
+#ifndef SEM_FAILED
+#define SEM_FAILED (-1)
+#endif
+
+static void proc_mutex_posix_setup(void)
+{
+}
+
+static apr_status_t proc_mutex_posix_cleanup(void *mutex_)
+{
+    apr_proc_mutex_t *mutex=mutex_;
+    apr_status_t stat = APR_SUCCESS;
+    
+    if (mutex->interproc->filedes != -1) {
+        if (sem_close((sem_t *)mutex->interproc->filedes) < 0) {
+            stat = errno;
+        }
+    }
+    return stat;
+}    
+
+static apr_status_t proc_mutex_posix_create(apr_proc_mutex_t *new_mutex,
+                                            const char *fname)
+{
+    sem_t *psem;
+    apr_status_t stat;
+    char semname[31];
+    apr_time_t now;
+    unsigned long sec;
+    unsigned long usec;
+    
+    new_mutex->interproc = apr_palloc(new_mutex->pool,
+                                      sizeof(*new_mutex->interproc));
+    new_mutex->interproc->filedes = -1;
+    /*
+     * This bogusness is to follow what appears to be the
+     * lowest common denominator in Posix semaphore naming:
+     *   - start with '/'
+     *   - be at most 14 chars
+     *   - be unique and not match anything on the filesystem
+     *
+     * Because of this, we ignore fname, and try our
+     * own naming system. We tuck the name away, since it might
+     * be useful for debugging. to  make this as robust as possible,
+     * we initially try something larger (and hopefully more unique)
+     * and gracefully fail down to the LCD above.
+     *
+     * NOTE: Darwin (Mac OS X) seems to be the most restrictive
+     * implementation. Versions previous to Darwin 6.2 had the 14
+     * char limit, but later rev's allow up to 31 characters.
+     *
+     * FIXME: There is a small window of opportunity where
+     * instead of getting a new semaphore descriptor, we get
+     * a previously obtained one. This can happen if the requests
+     * are made at the "same time" and in the small span of time between
+     * the sem_open and the sem_unlink. Use of O_EXCL does not
+     * help here however...
+     *
+     */
+    now = apr_time_now();
+    sec = apr_time_sec(now);
+    usec = apr_time_usec(now);
+    apr_snprintf(semname, sizeof(semname), "/ApR.%lxZ%lx", sec, usec);
+    psem = sem_open((const char *) semname, O_CREAT, 0644, 1);
+    if ((psem == (sem_t *)SEM_FAILED) && (errno == ENAMETOOLONG)) {
+        /* Oh well, good try */
+        semname[13] = '\0';
+        psem = sem_open((const char *) semname, O_CREAT, 0644, 1);
+    }
+
+    if (psem == (sem_t *)SEM_FAILED) {
+        stat = errno;
+        proc_mutex_posix_cleanup(new_mutex);
+        return stat;
+    }
+    /* Ahhh. The joys of Posix sems. Predelete it... */
+    sem_unlink((const char *) semname);
+    new_mutex->interproc->filedes = (int)psem;	/* Ugg */
+    new_mutex->fname = apr_pstrdup(new_mutex->pool, semname);
+    apr_pool_cleanup_register(new_mutex->pool, (void *)new_mutex,
+                              apr_proc_mutex_cleanup, 
+                              apr_pool_cleanup_null);
+    return APR_SUCCESS;
+}
+
+static apr_status_t proc_mutex_posix_acquire(apr_proc_mutex_t *mutex)
+{
+    int rc;
+
+    if ((rc = sem_wait((sem_t *)mutex->interproc->filedes)) < 0) {
+        return errno;
+    }
+    mutex->curr_locked = 1;
+    return APR_SUCCESS;
+}
+
+static apr_status_t proc_mutex_posix_release(apr_proc_mutex_t *mutex)
+{
+    int rc;
+
+    mutex->curr_locked = 0;
+    if ((rc = sem_post((sem_t *)mutex->interproc->filedes)) < 0) {
+        return errno;
+    }
+    return APR_SUCCESS;
+}
+
+static apr_status_t proc_mutex_posix_child_init(apr_proc_mutex_t **mutex,
+                                                apr_pool_t *cont,
+                                                const char *fname)
+{
+    return APR_SUCCESS;
+}
+
+const apr_proc_mutex_unix_lock_methods_t apr_proc_mutex_unix_posix_methods =
+{
+#if APR_PROCESS_LOCK_IS_GLOBAL || !APR_HAS_THREADS || defined(POSIXSEM_IS_GLOBAL)
+    APR_PROCESS_LOCK_MECH_IS_GLOBAL,
+#else
+    0,
+#endif
+    proc_mutex_posix_create,
+    proc_mutex_posix_acquire,
+    proc_mutex_no_tryacquire,
+    proc_mutex_posix_release,
+    proc_mutex_posix_cleanup,
+    proc_mutex_posix_child_init,
+    "posixsem"
+};
+
+#endif /* Posix sem implementation */
+
+#if APR_HAS_SYSVSEM_SERIALIZE
+
+static struct sembuf proc_mutex_op_on;
+static struct sembuf proc_mutex_op_off;
+
+static void proc_mutex_sysv_setup(void)
+{
+    proc_mutex_op_on.sem_num = 0;
+    proc_mutex_op_on.sem_op = -1;
+    proc_mutex_op_on.sem_flg = SEM_UNDO;
+    proc_mutex_op_off.sem_num = 0;
+    proc_mutex_op_off.sem_op = 1;
+    proc_mutex_op_off.sem_flg = SEM_UNDO;
+}
+
+static apr_status_t proc_mutex_sysv_cleanup(void *mutex_)
+{
+    apr_proc_mutex_t *mutex=mutex_;
+    union semun ick;
+    
+    if (mutex->interproc->filedes != -1) {
+        ick.val = 0;
+        semctl(mutex->interproc->filedes, 0, IPC_RMID, ick);
+    }
+    return APR_SUCCESS;
+}    
+
+static apr_status_t proc_mutex_sysv_create(apr_proc_mutex_t *new_mutex,
+                                           const char *fname)
+{
+    union semun ick;
+    apr_status_t rv;
+    
+    new_mutex->interproc = apr_palloc(new_mutex->pool, sizeof(*new_mutex->interproc));
+    new_mutex->interproc->filedes = semget(IPC_PRIVATE, 1, IPC_CREAT | 0600);
+
+    if (new_mutex->interproc->filedes < 0) {
+        rv = errno;
+        proc_mutex_sysv_cleanup(new_mutex);
+        return rv;
+    }
+    ick.val = 1;
+    if (semctl(new_mutex->interproc->filedes, 0, SETVAL, ick) < 0) {
+        rv = errno;
+        proc_mutex_sysv_cleanup(new_mutex);
+        return rv;
+    }
+    new_mutex->curr_locked = 0;
+    apr_pool_cleanup_register(new_mutex->pool,
+                              (void *)new_mutex, apr_proc_mutex_cleanup, 
+                              apr_pool_cleanup_null);
+    return APR_SUCCESS;
+}
+
+static apr_status_t proc_mutex_sysv_acquire(apr_proc_mutex_t *mutex)
+{
+    int rc;
+
+    do {
+        rc = semop(mutex->interproc->filedes, &proc_mutex_op_on, 1);
+    } while (rc < 0 && errno == EINTR);
+    if (rc < 0) {
+        return errno;
+    }
+    mutex->curr_locked = 1;
+    return APR_SUCCESS;
+}
+
+static apr_status_t proc_mutex_sysv_release(apr_proc_mutex_t *mutex)
+{
+    int rc;
+
+    mutex->curr_locked = 0;
+    do {
+        rc = semop(mutex->interproc->filedes, &proc_mutex_op_off, 1);
+    } while (rc < 0 && errno == EINTR);
+    if (rc < 0) {
+        return errno;
+    }
+    return APR_SUCCESS;
+}
+
+static apr_status_t proc_mutex_sysv_child_init(apr_proc_mutex_t **mutex, apr_pool_t *cont, const char *fname)
+{
+    return APR_SUCCESS;
+}
+
+const apr_proc_mutex_unix_lock_methods_t apr_proc_mutex_unix_sysv_methods =
+{
+#if APR_PROCESS_LOCK_IS_GLOBAL || !APR_HAS_THREADS || defined(SYSVSEM_IS_GLOBAL)
+    APR_PROCESS_LOCK_MECH_IS_GLOBAL,
+#else
+    0,
+#endif
+    proc_mutex_sysv_create,
+    proc_mutex_sysv_acquire,
+    proc_mutex_no_tryacquire,
+    proc_mutex_sysv_release,
+    proc_mutex_sysv_cleanup,
+    proc_mutex_sysv_child_init,
+    "sysvsem"
+};
+
+#endif /* SysV sem implementation */
+
+#if APR_HAS_PROC_PTHREAD_SERIALIZE
+
+static void proc_mutex_proc_pthread_setup(void)
+{
+}
+
+static apr_status_t proc_mutex_proc_pthread_cleanup(void *mutex_)
+{
+    apr_proc_mutex_t *mutex=mutex_;
+    apr_status_t rv;
+
+    if (mutex->curr_locked == 1) {
+        if ((rv = pthread_mutex_unlock(mutex->pthread_interproc))) {
+#ifdef PTHREAD_SETS_ERRNO
+            rv = errno;
+#endif
+            return rv;
+        } 
+        if (munmap((caddr_t)mutex->pthread_interproc, sizeof(pthread_mutex_t))){
+            return errno;
+        }
+    }
+    return APR_SUCCESS;
+}    
+
+static apr_status_t proc_mutex_proc_pthread_create(apr_proc_mutex_t *new_mutex,
+                                                   const char *fname)
+{
+    apr_status_t rv;
+    int fd;
+    pthread_mutexattr_t mattr;
+
+    fd = open("/dev/zero", O_RDWR);
+    if (fd < 0) {
+        return errno;
+    }
+
+    new_mutex->pthread_interproc = (pthread_mutex_t *)mmap(
+                                       (caddr_t) 0, 
+                                       sizeof(pthread_mutex_t), 
+                                       PROT_READ | PROT_WRITE, MAP_SHARED,
+                                       fd, 0); 
+    if (new_mutex->pthread_interproc == (pthread_mutex_t *) (caddr_t) -1) {
+        return errno;
+    }
+    close(fd);
+    if ((rv = pthread_mutexattr_init(&mattr))) {
+#ifdef PTHREAD_SETS_ERRNO
+        rv = errno;
+#endif
+        proc_mutex_proc_pthread_cleanup(new_mutex);
+        return rv;
+    }
+    if ((rv = pthread_mutexattr_setpshared(&mattr, PTHREAD_PROCESS_SHARED))) {
+#ifdef PTHREAD_SETS_ERRNO
+        rv = errno;
+#endif
+        proc_mutex_proc_pthread_cleanup(new_mutex);
+        return rv;
+    }
+
+#ifdef HAVE_PTHREAD_MUTEX_ROBUST
+    if ((rv = pthread_mutexattr_setrobust_np(&mattr, 
+                                               PTHREAD_MUTEX_ROBUST_NP))) {
+#ifdef PTHREAD_SETS_ERRNO
+        rv = errno;
+#endif
+        proc_mutex_proc_pthread_cleanup(new_mutex);
+        return rv;
+    }
+    if ((rv = pthread_mutexattr_setprotocol(&mattr, PTHREAD_PRIO_INHERIT))) {
+#ifdef PTHREAD_SETS_ERRNO
+        rv = errno;
+#endif
+        proc_mutex_proc_pthread_cleanup(new_mutex);
+        return rv;
+    }
+#endif /* HAVE_PTHREAD_MUTEX_ROBUST */
+
+    if ((rv = pthread_mutex_init(new_mutex->pthread_interproc, &mattr))) {
+#ifdef PTHREAD_SETS_ERRNO
+        rv = errno;
+#endif
+        proc_mutex_proc_pthread_cleanup(new_mutex);
+        return rv;
+    }
+
+    if ((rv = pthread_mutexattr_destroy(&mattr))) {
+#ifdef PTHREAD_SETS_ERRNO
+        rv = errno;
+#endif
+        proc_mutex_proc_pthread_cleanup(new_mutex);
+        return rv;
+    }
+
+    new_mutex->curr_locked = 0;
+    apr_pool_cleanup_register(new_mutex->pool,
+                              (void *)new_mutex,
+                              apr_proc_mutex_cleanup, 
+                              apr_pool_cleanup_null);
+    return APR_SUCCESS;
+}
+
+static apr_status_t proc_mutex_proc_pthread_acquire(apr_proc_mutex_t *mutex)
+{
+    apr_status_t rv;
+
+    if ((rv = pthread_mutex_lock(mutex->pthread_interproc))) {
+#ifdef PTHREAD_SETS_ERRNO
+        rv = errno;
+#endif
+#ifdef HAVE_PTHREAD_MUTEX_ROBUST
+        /* Okay, our owner died.  Let's try to make it consistent again. */
+        if (rv == EOWNERDEAD) {
+            pthread_mutex_consistent_np(mutex->pthread_interproc);
+        }
+        else
+            return rv;
+#else
+        return rv;
+#endif
+    }
+    mutex->curr_locked = 1;
+    return APR_SUCCESS;
+}
+
+/* TODO: Add proc_mutex_proc_pthread_tryacquire(apr_proc_mutex_t *mutex) */
+
+static apr_status_t proc_mutex_proc_pthread_release(apr_proc_mutex_t *mutex)
+{
+    apr_status_t rv;
+
+    mutex->curr_locked = 0;
+    if ((rv = pthread_mutex_unlock(mutex->pthread_interproc))) {
+#ifdef PTHREAD_SETS_ERRNO
+        rv = errno;
+#endif
+        return rv;
+    }
+    return APR_SUCCESS;
+}
+
+static apr_status_t proc_mutex_proc_pthread_child_init(apr_proc_mutex_t **mutex,
+                                            apr_pool_t *cont, 
+                                            const char *fname)
+{
+    return APR_SUCCESS;
+}
+
+const apr_proc_mutex_unix_lock_methods_t apr_proc_mutex_unix_proc_pthread_methods =
+{
+    APR_PROCESS_LOCK_MECH_IS_GLOBAL,
+    proc_mutex_proc_pthread_create,
+    proc_mutex_proc_pthread_acquire,
+    proc_mutex_no_tryacquire,
+    proc_mutex_proc_pthread_release,
+    proc_mutex_proc_pthread_cleanup,
+    proc_mutex_proc_pthread_child_init,
+    "pthread"
+};
+
+#endif
+
+#if APR_HAS_FCNTL_SERIALIZE
+
+static struct flock proc_mutex_lock_it;
+static struct flock proc_mutex_unlock_it;
+
+static apr_status_t proc_mutex_fcntl_release(apr_proc_mutex_t *);
+
+static void proc_mutex_fcntl_setup(void)
+{
+    proc_mutex_lock_it.l_whence = SEEK_SET;   /* from current point */
+    proc_mutex_lock_it.l_start = 0;           /* -"- */
+    proc_mutex_lock_it.l_len = 0;             /* until end of file */
+    proc_mutex_lock_it.l_type = F_WRLCK;      /* set exclusive/write lock */
+    proc_mutex_lock_it.l_pid = 0;             /* pid not actually interesting */
+    proc_mutex_unlock_it.l_whence = SEEK_SET; /* from current point */
+    proc_mutex_unlock_it.l_start = 0;         /* -"- */
+    proc_mutex_unlock_it.l_len = 0;           /* until end of file */
+    proc_mutex_unlock_it.l_type = F_UNLCK;    /* set exclusive/write lock */
+    proc_mutex_unlock_it.l_pid = 0;           /* pid not actually interesting */
+}
+
+static apr_status_t proc_mutex_fcntl_cleanup(void *mutex_)
+{
+    apr_status_t status;
+    apr_proc_mutex_t *mutex=mutex_;
+
+    if (mutex->curr_locked == 1) {
+        status = proc_mutex_fcntl_release(mutex);
+        if (status != APR_SUCCESS)
+            return status;
+    }
+    if (mutex->interproc) { /* if it was opened successfully */
+        apr_file_close(mutex->interproc);
+    }
+    return APR_SUCCESS;
+}    
+
+static apr_status_t proc_mutex_fcntl_create(apr_proc_mutex_t *new_mutex,
+                                            const char *fname)
+{
+    int rv;
+ 
+    if (fname) {
+        new_mutex->fname = apr_pstrdup(new_mutex->pool, fname);
+        rv = apr_file_open(&new_mutex->interproc, new_mutex->fname,
+                           APR_CREATE | APR_WRITE | APR_EXCL, 
+                           APR_UREAD | APR_UWRITE | APR_GREAD | APR_WREAD,
+                           new_mutex->pool);
+    }
+    else {
+        new_mutex->fname = apr_pstrdup(new_mutex->pool, "/tmp/aprXXXXXX");
+        rv = apr_file_mktemp(&new_mutex->interproc, new_mutex->fname,
+                             APR_CREATE | APR_WRITE | APR_EXCL,
+                             new_mutex->pool);
+    }
+ 
+    if (rv != APR_SUCCESS) {
+        proc_mutex_fcntl_cleanup(new_mutex);
+        return rv;
+    }
+
+    new_mutex->curr_locked = 0;
+    unlink(new_mutex->fname);
+    apr_pool_cleanup_register(new_mutex->pool,
+                              (void*)new_mutex,
+                              apr_proc_mutex_cleanup, 
+                              apr_pool_cleanup_null);
+    return APR_SUCCESS; 
+}
+
+static apr_status_t proc_mutex_fcntl_acquire(apr_proc_mutex_t *mutex)
+{
+    int rc;
+
+    do {
+        rc = fcntl(mutex->interproc->filedes, F_SETLKW, &proc_mutex_lock_it);
+    } while (rc < 0 && errno == EINTR);
+    if (rc < 0) {
+        return errno;
+    }
+    mutex->curr_locked=1;
+    return APR_SUCCESS;
+}
+
+static apr_status_t proc_mutex_fcntl_release(apr_proc_mutex_t *mutex)
+{
+    int rc;
+
+    mutex->curr_locked=0;
+    do {
+        rc = fcntl(mutex->interproc->filedes, F_SETLKW, &proc_mutex_unlock_it);
+    } while (rc < 0 && errno == EINTR);
+    if (rc < 0) {
+        return errno;
+    }
+    return APR_SUCCESS;
+}
+
+static apr_status_t proc_mutex_fcntl_child_init(apr_proc_mutex_t **mutex,
+                                                apr_pool_t *pool, 
+                                                const char *fname)
+{
+    return APR_SUCCESS;
+}
+
+const apr_proc_mutex_unix_lock_methods_t apr_proc_mutex_unix_fcntl_methods =
+{
+#if APR_PROCESS_LOCK_IS_GLOBAL || !APR_HAS_THREADS || defined(FCNTL_IS_GLOBAL)
+    APR_PROCESS_LOCK_MECH_IS_GLOBAL,
+#else
+    0,
+#endif
+    proc_mutex_fcntl_create,
+    proc_mutex_fcntl_acquire,
+    proc_mutex_no_tryacquire,
+    proc_mutex_fcntl_release,
+    proc_mutex_fcntl_cleanup,
+    proc_mutex_fcntl_child_init,
+    "fcntl"
+};
+
+#endif /* fcntl implementation */
+
+#if APR_HAS_FLOCK_SERIALIZE
+
+static apr_status_t proc_mutex_flock_release(apr_proc_mutex_t *);
+
+static void proc_mutex_flock_setup(void)
+{
+}
+
+static apr_status_t proc_mutex_flock_cleanup(void *mutex_)
+{
+    apr_status_t status;
+    apr_proc_mutex_t *mutex=mutex_;
+
+    if (mutex->curr_locked == 1) {
+        status = proc_mutex_flock_release(mutex);
+        if (status != APR_SUCCESS)
+            return status;
+    }
+    if (mutex->interproc) { /* if it was opened properly */
+        apr_file_close(mutex->interproc);
+    }
+    unlink(mutex->fname);
+    return APR_SUCCESS;
+}    
+
+static apr_status_t proc_mutex_flock_create(apr_proc_mutex_t *new_mutex,
+                                            const char *fname)
+{
+    int rv;
+ 
+    if (fname) {
+        new_mutex->fname = apr_pstrdup(new_mutex->pool, fname);
+        rv = apr_file_open(&new_mutex->interproc, new_mutex->fname,
+                           APR_CREATE | APR_WRITE | APR_EXCL, 
+                           APR_UREAD | APR_UWRITE,
+                           new_mutex->pool);
+    }
+    else {
+        new_mutex->fname = apr_pstrdup(new_mutex->pool, "/tmp/aprXXXXXX");
+        rv = apr_file_mktemp(&new_mutex->interproc, new_mutex->fname,
+                             APR_CREATE | APR_WRITE | APR_EXCL,
+                             new_mutex->pool);
+    }
+ 
+    if (rv != APR_SUCCESS) {
+        proc_mutex_flock_cleanup(new_mutex);
+        return errno;
+    }
+    new_mutex->curr_locked = 0;
+    apr_pool_cleanup_register(new_mutex->pool, (void *)new_mutex,
+                              apr_proc_mutex_cleanup,
+                              apr_pool_cleanup_null);
+    return APR_SUCCESS;
+}
+
+static apr_status_t proc_mutex_flock_acquire(apr_proc_mutex_t *mutex)
+{
+    int rc;
+
+    do {
+        rc = flock(mutex->interproc->filedes, LOCK_EX);
+    } while (rc < 0 && errno == EINTR);
+    if (rc < 0) {
+        return errno;
+    }
+    mutex->curr_locked = 1;
+    return APR_SUCCESS;
+}
+
+static apr_status_t proc_mutex_flock_release(apr_proc_mutex_t *mutex)
+{
+    int rc;
+
+    mutex->curr_locked = 0;
+    do {
+        rc = flock(mutex->interproc->filedes, LOCK_UN);
+    } while (rc < 0 && errno == EINTR);
+    if (rc < 0) {
+        return errno;
+    }
+    return APR_SUCCESS;
+}
+
+static apr_status_t proc_mutex_flock_child_init(apr_proc_mutex_t **mutex,
+                                                apr_pool_t *pool, 
+                                                const char *fname)
+{
+    apr_proc_mutex_t *new_mutex;
+    int rv;
+
+    new_mutex = (apr_proc_mutex_t *)apr_palloc(pool, sizeof(apr_proc_mutex_t));
+
+    memcpy(new_mutex, *mutex, sizeof *new_mutex);
+    new_mutex->pool = pool;
+    if (!fname) {
+        fname = (*mutex)->fname;
+    }
+    new_mutex->fname = apr_pstrdup(pool, fname);
+    rv = apr_file_open(&new_mutex->interproc, new_mutex->fname,
+                       APR_WRITE, 0, new_mutex->pool);
+    if (rv != APR_SUCCESS) {
+        proc_mutex_flock_cleanup(new_mutex);
+        return rv;
+    }
+    *mutex = new_mutex;
+    return APR_SUCCESS;
+}
+
+const apr_proc_mutex_unix_lock_methods_t apr_proc_mutex_unix_flock_methods =
+{
+#if APR_PROCESS_LOCK_IS_GLOBAL || !APR_HAS_THREADS || defined(FLOCK_IS_GLOBAL)
+    APR_PROCESS_LOCK_MECH_IS_GLOBAL,
+#else
+    0,
+#endif
+    proc_mutex_flock_create,
+    proc_mutex_flock_acquire,
+    proc_mutex_no_tryacquire,
+    proc_mutex_flock_release,
+    proc_mutex_flock_cleanup,
+    proc_mutex_flock_child_init,
+    "flock"
+};
+
+#endif /* flock implementation */
+
+void apr_proc_mutex_unix_setup_lock(void)
+{
+#if APR_HAS_POSIXSEM_SERIALIZE
+    proc_mutex_posix_setup();
+#endif
+#if APR_HAS_SYSVSEM_SERIALIZE
+    proc_mutex_sysv_setup();
+#endif
+#if APR_HAS_PROC_PTHREAD_SERIALIZE
+    proc_mutex_proc_pthread_setup();
+#endif
+#if APR_HAS_FCNTL_SERIALIZE
+    proc_mutex_fcntl_setup();
+#endif
+#if APR_HAS_FLOCK_SERIALIZE
+    proc_mutex_flock_setup();
+#endif
+}
+
+static apr_status_t proc_mutex_choose_method(apr_proc_mutex_t *new_mutex, apr_lockmech_e mech)
+{
+    switch (mech) {
+    case APR_LOCK_FCNTL:
+#if APR_HAS_FCNTL_SERIALIZE
+        new_mutex->inter_meth = &apr_proc_mutex_unix_fcntl_methods;
+#else
+        return APR_ENOTIMPL;
+#endif
+        break;
+    case APR_LOCK_FLOCK:
+#if APR_HAS_FLOCK_SERIALIZE
+        new_mutex->inter_meth = &apr_proc_mutex_unix_flock_methods;
+#else
+        return APR_ENOTIMPL;
+#endif
+        break;
+    case APR_LOCK_SYSVSEM:
+#if APR_HAS_SYSVSEM_SERIALIZE
+        new_mutex->inter_meth = &apr_proc_mutex_unix_sysv_methods;
+#else
+        return APR_ENOTIMPL;
+#endif
+        break;
+    case APR_LOCK_POSIXSEM:
+#if APR_HAS_POSIXSEM_SERIALIZE
+        new_mutex->inter_meth = &apr_proc_mutex_unix_posix_methods;
+#else
+        return APR_ENOTIMPL;
+#endif
+        break;
+    case APR_LOCK_PROC_PTHREAD:
+#if APR_HAS_PROC_PTHREAD_SERIALIZE
+        new_mutex->inter_meth = &apr_proc_mutex_unix_proc_pthread_methods;
+#else
+        return APR_ENOTIMPL;
+#endif
+        break;
+    case APR_LOCK_DEFAULT:
+#if APR_USE_FLOCK_SERIALIZE
+        new_mutex->inter_meth = &apr_proc_mutex_unix_flock_methods;
+#elif APR_USE_SYSVSEM_SERIALIZE
+        new_mutex->inter_meth = &apr_proc_mutex_unix_sysv_methods;
+#elif APR_USE_FCNTL_SERIALIZE
+        new_mutex->inter_meth = &apr_proc_mutex_unix_fcntl_methods;
+#elif APR_USE_PROC_PTHREAD_SERIALIZE
+        new_mutex->inter_meth = &apr_proc_mutex_unix_proc_pthread_methods;
+#elif APR_USE_POSIXSEM_SERIALIZE
+        new_mutex->inter_meth = &apr_proc_mutex_unix_posix_methods;
+#else
+        return APR_ENOTIMPL;
+#endif
+        break;
+    default:
+        return APR_ENOTIMPL;
+    }
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(const char *) apr_proc_mutex_defname(void)
+{
+    apr_status_t rv;
+    apr_proc_mutex_t mutex;
+
+    if ((rv = proc_mutex_choose_method(&mutex, APR_LOCK_DEFAULT)) != APR_SUCCESS) {
+        return "unknown";
+    }
+    mutex.meth = mutex.inter_meth;
+
+    return apr_proc_mutex_name(&mutex);
+}
+   
+static apr_status_t proc_mutex_create(apr_proc_mutex_t *new_mutex, apr_lockmech_e mech, const char *fname)
+{
+    apr_status_t rv;
+
+    if ((rv = proc_mutex_choose_method(new_mutex, mech)) != APR_SUCCESS) {
+        return rv;
+    }
+
+    new_mutex->meth = new_mutex->inter_meth;
+
+    if ((rv = new_mutex->meth->create(new_mutex, fname)) != APR_SUCCESS) {
+        return rv;
+    }
+
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_proc_mutex_create(apr_proc_mutex_t **mutex,
+                                                const char *fname,
+                                                apr_lockmech_e mech,
+                                                apr_pool_t *pool)
+{
+    apr_proc_mutex_t *new_mutex;
+    apr_status_t rv;
+
+    new_mutex = (apr_proc_mutex_t *)apr_pcalloc(pool,
+                                                sizeof(apr_proc_mutex_t));
+
+    new_mutex->pool  = pool;
+#if APR_HAS_SYSVSEM_SERIALIZE || APR_HAS_FCNTL_SERIALIZE || APR_HAS_FLOCK_SERIALIZE || APR_HAS_POSIXSEM_SERIALIZE
+    new_mutex->interproc = NULL;
+#endif
+
+    if ((rv = proc_mutex_create(new_mutex, mech, fname)) != APR_SUCCESS)
+        return rv;
+
+    *mutex = new_mutex;
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_proc_mutex_child_init(apr_proc_mutex_t **mutex,
+                                                    const char *fname,
+                                                    apr_pool_t *pool)
+{
+    return (*mutex)->meth->child_init(mutex, pool, fname);
+}
+
+APR_DECLARE(apr_status_t) apr_proc_mutex_lock(apr_proc_mutex_t *mutex)
+{
+    return mutex->meth->acquire(mutex);
+}
+
+APR_DECLARE(apr_status_t) apr_proc_mutex_trylock(apr_proc_mutex_t *mutex)
+{
+    return mutex->meth->tryacquire(mutex);
+}
+
+APR_DECLARE(apr_status_t) apr_proc_mutex_unlock(apr_proc_mutex_t *mutex)
+{
+    return mutex->meth->release(mutex);
+}
+
+APR_DECLARE(apr_status_t) apr_proc_mutex_cleanup(void *mutex)
+{
+    return ((apr_proc_mutex_t *)mutex)->meth->cleanup(mutex);
+}
+
+APR_DECLARE(const char *) apr_proc_mutex_name(apr_proc_mutex_t *mutex)
+{
+    return mutex->meth->name;
+}
+
+APR_DECLARE(const char *) apr_proc_mutex_lockfile(apr_proc_mutex_t *mutex)
+{
+    /* posix sems use the fname field but don't use a file,
+     * so be careful 
+     */
+    if (!strcmp(mutex->meth->name, "flock") ||
+        !strcmp(mutex->meth->name, "fcntl")) {
+        return mutex->fname;
+    }
+    return NULL;
+}
+
+APR_POOL_IMPLEMENT_ACCESSOR(proc_mutex)
+
+/* Implement OS-specific accessors defined in apr_portable.h */
+
+APR_DECLARE(apr_status_t) apr_os_proc_mutex_get(apr_os_proc_mutex_t *ospmutex,
+                                                apr_proc_mutex_t *pmutex)
+{
+#if APR_HAS_SYSVSEM_SERIALIZE || APR_HAS_FCNTL_SERIALIZE || APR_HAS_FLOCK_SERIALIZE || APR_HAS_POSIXSEM_SERIALIZE
+    ospmutex->crossproc = pmutex->interproc->filedes;
+#endif
+#if APR_HAS_PROC_PTHREAD_SERIALIZE
+    ospmutex->pthread_interproc = pmutex->pthread_interproc;
+#endif
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_os_proc_mutex_put(apr_proc_mutex_t **pmutex,
+                                                apr_os_proc_mutex_t *ospmutex,
+                                                apr_pool_t *pool)
+{
+    if (pool == NULL) {
+        return APR_ENOPOOL;
+    }
+    if ((*pmutex) == NULL) {
+        (*pmutex) = (apr_proc_mutex_t *)apr_pcalloc(pool,
+                                                    sizeof(apr_proc_mutex_t));
+        (*pmutex)->pool = pool;
+    }
+#if APR_HAS_SYSVSEM_SERIALIZE || APR_HAS_FCNTL_SERIALIZE || APR_HAS_FLOCK_SERIALIZE || APR_HAS_POSIXSEM_SERIALIZE
+    apr_os_file_put(&(*pmutex)->interproc, &ospmutex->crossproc, 0, pool);
+#endif
+#if APR_HAS_PROC_PTHREAD_SERIALIZE
+    (*pmutex)->pthread_interproc = ospmutex->pthread_interproc;
+#endif
+    return APR_SUCCESS;
+}
+
diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/proc_mutex.lo b/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/proc_mutex.lo
new file mode 100644
index 00000000..2359a0ee
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/proc_mutex.lo
@@ -0,0 +1,12 @@
+# proc_mutex.lo - a libtool object file
+# Generated by ltmain.sh - GNU libtool 1.5.26 (1.1220.2.493 2008/02/01 16:58:18)
+#
+# Please DO NOT delete this file!
+# It is necessary for linking the library.
+
+# Name of the PIC object.
+pic_object='.libs/proc_mutex.o'
+
+# Name of the non-PIC object.
+non_pic_object='proc_mutex.o'
+
diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/proc_mutex.o b/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/proc_mutex.o
new file mode 100644
index 00000000..bee8bb3b
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/proc_mutex.o
diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/thread_cond.c b/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/thread_cond.c
new file mode 100644
index 00000000..46d770f1
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/thread_cond.c
@@ -0,0 +1,152 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "apr.h"
+
+#if APR_HAS_THREADS
+
+#include "apr_arch_thread_mutex.h"
+#include "apr_arch_thread_cond.h"
+
+static apr_status_t thread_cond_cleanup(void *data)
+{
+    apr_thread_cond_t *cond = (apr_thread_cond_t *)data;
+    apr_status_t rv;
+
+    rv = pthread_cond_destroy(cond->cond);
+#ifdef PTHREAD_SETS_ERRNO
+    if (rv) {
+        rv = errno;
+    }
+#endif
+    return rv;
+} 
+
+APR_DECLARE(apr_status_t) apr_thread_cond_create(apr_thread_cond_t **cond,
+                                                 apr_pool_t *pool)
+{
+    apr_thread_cond_t *new_cond;
+    apr_status_t rv;
+
+    new_cond = (apr_thread_cond_t *)apr_pcalloc(pool,
+                                                sizeof(apr_thread_cond_t));
+
+    if (new_cond == NULL) {
+        return APR_ENOMEM;
+    }
+
+    new_cond->pool = pool;
+    new_cond->cond = (pthread_cond_t *)apr_palloc(pool, 
+                                                  sizeof(pthread_cond_t));
+
+    if (new_cond->cond == NULL) {
+        return APR_ENOMEM;
+    }
+
+    if ((rv = pthread_cond_init(new_cond->cond, NULL))) {
+#ifdef PTHREAD_SETS_ERRNO
+        rv = errno;
+#endif
+        thread_cond_cleanup(new_cond);
+        return rv;
+    }
+
+    apr_pool_cleanup_register(new_cond->pool,
+                              (void *)new_cond, thread_cond_cleanup,
+                              apr_pool_cleanup_null);
+
+    *cond = new_cond;
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_cond_wait(apr_thread_cond_t *cond,
+                                               apr_thread_mutex_t *mutex)
+{
+    apr_status_t rv;
+
+    rv = pthread_cond_wait(cond->cond, &mutex->mutex);
+#ifdef PTHREAD_SETS_ERRNO
+    if (rv) {
+        rv = errno;
+    }
+#endif
+    return rv;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_cond_timedwait(apr_thread_cond_t *cond,
+                                                    apr_thread_mutex_t *mutex,
+                                                    apr_interval_time_t timeout)
+{
+    apr_status_t rv;
+    apr_time_t then;
+    struct timespec abstime;
+
+    then = apr_time_now() + timeout;
+    abstime.tv_sec = apr_time_sec(then);
+    abstime.tv_nsec = apr_time_usec(then) * 1000; /* nanoseconds */
+
+    rv = pthread_cond_timedwait(cond->cond, &mutex->mutex, &abstime);
+#ifdef PTHREAD_SETS_ERRNO
+    if (rv) {
+        rv = errno;
+    }
+#endif
+    if (ETIMEDOUT == rv) {
+        return APR_TIMEUP;
+    }
+    return rv;
+}
+
+
+APR_DECLARE(apr_status_t) apr_thread_cond_signal(apr_thread_cond_t *cond)
+{
+    apr_status_t rv;
+
+    rv = pthread_cond_signal(cond->cond);
+#ifdef PTHREAD_SETS_ERRNO
+    if (rv) {
+        rv = errno;
+    }
+#endif
+    return rv;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_cond_broadcast(apr_thread_cond_t *cond)
+{
+    apr_status_t rv;
+
+    rv = pthread_cond_broadcast(cond->cond);
+#ifdef PTHREAD_SETS_ERRNO
+    if (rv) {
+        rv = errno;
+    }
+#endif
+    return rv;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_cond_destroy(apr_thread_cond_t *cond)
+{
+    apr_status_t rv;
+    if ((rv = thread_cond_cleanup(cond)) == APR_SUCCESS) {
+        apr_pool_cleanup_kill(cond->pool, cond, thread_cond_cleanup);
+        return APR_SUCCESS;
+    }
+    return rv;
+}
+
+APR_POOL_IMPLEMENT_ACCESSOR(thread_cond)
+
+#endif /* APR_HAS_THREADS */
diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/thread_cond.lo b/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/thread_cond.lo
new file mode 100644
index 00000000..aa4051e8
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/thread_cond.lo
@@ -0,0 +1,12 @@
+# thread_cond.lo - a libtool object file
+# Generated by ltmain.sh - GNU libtool 1.5.26 (1.1220.2.493 2008/02/01 16:58:18)
+#
+# Please DO NOT delete this file!
+# It is necessary for linking the library.
+
+# Name of the PIC object.
+pic_object='.libs/thread_cond.o'
+
+# Name of the non-PIC object.
+non_pic_object='thread_cond.o'
+
diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/thread_cond.o b/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/thread_cond.o
new file mode 100644
index 00000000..b453da92
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/thread_cond.o
diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/thread_mutex.c b/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/thread_mutex.c
new file mode 100644
index 00000000..e146a28f
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/thread_mutex.c
@@ -0,0 +1,138 @@
+/* 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_thread_mutex.h"
+#define APR_WANT_MEMFUNC
+#include "apr_want.h"
+
+#if APR_HAS_THREADS
+
+static apr_status_t thread_mutex_cleanup(void *data)
+{
+    apr_thread_mutex_t *mutex = data;
+    apr_status_t rv;
+
+    rv = pthread_mutex_destroy(&mutex->mutex);
+#ifdef PTHREAD_SETS_ERRNO
+    if (rv) {
+        rv = errno;
+    }
+#endif
+    return rv;
+} 
+
+APR_DECLARE(apr_status_t) apr_thread_mutex_create(apr_thread_mutex_t **mutex,
+                                                  unsigned int flags,
+                                                  apr_pool_t *pool)
+{
+    apr_thread_mutex_t *new_mutex;
+    apr_status_t rv;
+    
+#ifndef HAVE_PTHREAD_MUTEX_RECURSIVE
+    if (flags & APR_THREAD_MUTEX_NESTED) {
+        return APR_ENOTIMPL;
+    }
+#endif
+
+    new_mutex = apr_pcalloc(pool, sizeof(apr_thread_mutex_t));
+    new_mutex->pool = pool;
+
+#ifdef HAVE_PTHREAD_MUTEX_RECURSIVE
+    if (flags & APR_THREAD_MUTEX_NESTED) {
+        pthread_mutexattr_t mattr;
+        
+        rv = pthread_mutexattr_init(&mattr);
+        if (rv) return rv;
+        
+        rv = pthread_mutexattr_settype(&mattr, PTHREAD_MUTEX_RECURSIVE);
+        if (rv) {
+            pthread_mutexattr_destroy(&mattr);
+            return rv;
+        }
+         
+        rv = pthread_mutex_init(&new_mutex->mutex, &mattr);
+        
+        pthread_mutexattr_destroy(&mattr);
+    } else
+#endif
+        rv = pthread_mutex_init(&new_mutex->mutex, NULL);
+
+    if (rv) {
+#ifdef PTHREAD_SETS_ERRNO
+        rv = errno;
+#endif
+        return rv;
+    }
+
+    apr_pool_cleanup_register(new_mutex->pool,
+                              new_mutex, thread_mutex_cleanup,
+                              apr_pool_cleanup_null);
+
+    *mutex = new_mutex;
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_mutex_lock(apr_thread_mutex_t *mutex)
+{
+    apr_status_t rv;
+
+    rv = pthread_mutex_lock(&mutex->mutex);
+#ifdef PTHREAD_SETS_ERRNO
+    if (rv) {
+        rv = errno;
+    }
+#endif
+    
+    return rv;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_mutex_trylock(apr_thread_mutex_t *mutex)
+{
+    apr_status_t rv;
+
+    rv = pthread_mutex_trylock(&mutex->mutex);
+    if (rv) {
+#ifdef PTHREAD_SETS_ERRNO
+        rv = errno;
+#endif
+        return (rv == EBUSY) ? APR_EBUSY : rv;
+    }
+
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_mutex_unlock(apr_thread_mutex_t *mutex)
+{
+    apr_status_t status;
+
+    status = pthread_mutex_unlock(&mutex->mutex);
+#ifdef PTHREAD_SETS_ERRNO
+    if (status) {
+        status = errno;
+    }
+#endif
+
+    return status;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_mutex_destroy(apr_thread_mutex_t *mutex)
+{
+    return apr_pool_cleanup_run(mutex->pool, mutex, thread_mutex_cleanup);
+}
+
+APR_POOL_IMPLEMENT_ACCESSOR(thread_mutex)
+
+#endif /* APR_HAS_THREADS */
diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/thread_mutex.lo b/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/thread_mutex.lo
new file mode 100644
index 00000000..9f6d1033
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/thread_mutex.lo
@@ -0,0 +1,12 @@
+# thread_mutex.lo - a libtool object file
+# Generated by ltmain.sh - GNU libtool 1.5.26 (1.1220.2.493 2008/02/01 16:58:18)
+#
+# Please DO NOT delete this file!
+# It is necessary for linking the library.
+
+# Name of the PIC object.
+pic_object='.libs/thread_mutex.o'
+
+# Name of the non-PIC object.
+non_pic_object='thread_mutex.o'
+
diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/thread_mutex.o b/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/thread_mutex.o
new file mode 100644
index 00000000..87f97293
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/thread_mutex.o
diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/thread_rwlock.c b/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/thread_rwlock.c
new file mode 100644
index 00000000..c322b455
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/thread_rwlock.c
@@ -0,0 +1,198 @@
+/* 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_thread_rwlock.h"
+#include "apr_private.h"
+
+#if APR_HAS_THREADS
+
+#ifdef HAVE_PTHREAD_RWLOCKS
+
+static apr_status_t thread_rwlock_cleanup(void *data)
+{
+    apr_thread_rwlock_t *rwlock = (apr_thread_rwlock_t *)data;
+    apr_status_t stat;
+
+    pthread_rwlock_unlock(rwlock->rwlock);
+    stat = pthread_rwlock_destroy(rwlock->rwlock);
+#ifdef PTHREAD_SETS_ERRNO
+    if (stat) {
+        stat = errno;
+    }
+#endif
+    return stat;
+} 
+
+APR_DECLARE(apr_status_t) apr_thread_rwlock_create(apr_thread_rwlock_t **rwlock,
+                                                   apr_pool_t *pool)
+{
+    apr_thread_rwlock_t *new_rwlock;
+    apr_status_t stat;
+
+    new_rwlock = (apr_thread_rwlock_t *)apr_pcalloc(pool,
+                                                  sizeof(apr_thread_rwlock_t));
+
+    if (new_rwlock == NULL) {
+        return APR_ENOMEM;
+    }
+
+    new_rwlock->pool = pool;
+    new_rwlock->rwlock = (pthread_rwlock_t *)apr_palloc(pool, 
+                                                     sizeof(pthread_rwlock_t));
+
+    if (new_rwlock->rwlock == NULL) {
+        return APR_ENOMEM;
+    }
+
+    if ((stat = pthread_rwlock_init(new_rwlock->rwlock, NULL))) {
+#ifdef PTHREAD_SETS_ERRNO
+        stat = errno;
+#endif
+        thread_rwlock_cleanup(new_rwlock);
+        return stat;
+    }
+
+    apr_pool_cleanup_register(new_rwlock->pool,
+                              (void *)new_rwlock, thread_rwlock_cleanup,
+                              apr_pool_cleanup_null);
+
+    *rwlock = new_rwlock;
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_rwlock_rdlock(apr_thread_rwlock_t *rwlock)
+{
+    apr_status_t stat;
+
+    stat = pthread_rwlock_rdlock(rwlock->rwlock);
+#ifdef PTHREAD_SETS_ERRNO
+    if (stat) {
+        stat = errno;
+    }
+#endif
+    return stat;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_rwlock_tryrdlock(apr_thread_rwlock_t *rwlock)
+{
+    apr_status_t stat;
+
+    stat = pthread_rwlock_tryrdlock(rwlock->rwlock);
+#ifdef PTHREAD_SETS_ERRNO
+    if (stat) {
+        stat = errno;
+    }
+#endif
+    /* Normalize the return code. */
+    if (stat == EBUSY)
+        stat = APR_EBUSY;
+    return stat;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_rwlock_wrlock(apr_thread_rwlock_t *rwlock)
+{
+    apr_status_t stat;
+
+    stat = pthread_rwlock_wrlock(rwlock->rwlock);
+#ifdef PTHREAD_SETS_ERRNO
+    if (stat) {
+        stat = errno;
+    }
+#endif
+    return stat;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_rwlock_trywrlock(apr_thread_rwlock_t *rwlock)
+{
+    apr_status_t stat;
+
+    stat = pthread_rwlock_trywrlock(rwlock->rwlock);
+#ifdef PTHREAD_SETS_ERRNO
+    if (stat) {
+        stat = errno;
+    }
+#endif
+    /* Normalize the return code. */
+    if (stat == EBUSY)
+        stat = APR_EBUSY;
+    return stat;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_rwlock_unlock(apr_thread_rwlock_t *rwlock)
+{
+    apr_status_t stat;
+
+    stat = pthread_rwlock_unlock(rwlock->rwlock);
+#ifdef PTHREAD_SETS_ERRNO
+    if (stat) {
+        stat = errno;
+    }
+#endif
+    return stat;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_rwlock_destroy(apr_thread_rwlock_t *rwlock)
+{
+    apr_status_t stat;
+    if ((stat = thread_rwlock_cleanup(rwlock)) == APR_SUCCESS) {
+        apr_pool_cleanup_kill(rwlock->pool, rwlock, thread_rwlock_cleanup);
+        return APR_SUCCESS;
+    }
+    return stat;
+}
+
+#else  /* HAVE_PTHREAD_RWLOCKS */
+
+APR_DECLARE(apr_status_t) apr_thread_rwlock_create(apr_thread_rwlock_t **rwlock,
+                                                   apr_pool_t *pool)
+{
+    return APR_ENOTIMPL;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_rwlock_rdlock(apr_thread_rwlock_t *rwlock)
+{
+    return APR_ENOTIMPL;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_rwlock_tryrdlock(apr_thread_rwlock_t *rwlock)
+{
+    return APR_ENOTIMPL;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_rwlock_wrlock(apr_thread_rwlock_t *rwlock)
+{
+    return APR_ENOTIMPL;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_rwlock_trywrlock(apr_thread_rwlock_t *rwlock)
+{
+    return APR_ENOTIMPL;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_rwlock_unlock(apr_thread_rwlock_t *rwlock)
+{
+    return APR_ENOTIMPL;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_rwlock_destroy(apr_thread_rwlock_t *rwlock)
+{
+    return APR_ENOTIMPL;
+}
+
+#endif /* HAVE_PTHREAD_RWLOCKS */
+APR_POOL_IMPLEMENT_ACCESSOR(thread_rwlock)
+
+#endif /* APR_HAS_THREADS */
diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/thread_rwlock.lo b/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/thread_rwlock.lo
new file mode 100644
index 00000000..e5ed346e
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/thread_rwlock.lo
@@ -0,0 +1,12 @@
+# thread_rwlock.lo - a libtool object file
+# Generated by ltmain.sh - GNU libtool 1.5.26 (1.1220.2.493 2008/02/01 16:58:18)
+#
+# Please DO NOT delete this file!
+# It is necessary for linking the library.
+
+# Name of the PIC object.
+pic_object='.libs/thread_rwlock.o'
+
+# Name of the non-PIC object.
+non_pic_object='thread_rwlock.o'
+
diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/thread_rwlock.o b/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/thread_rwlock.o
new file mode 100644
index 00000000..42f33daf
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/thread_rwlock.o
diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/locks/win32/proc_mutex.c b/rubbos/app/httpd-2.0.64/srclib/apr/locks/win32/proc_mutex.c
new file mode 100644
index 00000000..3b249045
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/srclib/apr/locks/win32/proc_mutex.c
@@ -0,0 +1,223 @@
+/* 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_general.h"
+#include "apr_strings.h"
+#include "apr_portable.h"
+#include "apr_arch_file_io.h"
+#include "apr_arch_proc_mutex.h"
+#include "apr_arch_misc.h"
+
+static apr_status_t proc_mutex_cleanup(void *mutex_)
+{
+    apr_proc_mutex_t *mutex = mutex_;
+
+    if (mutex->handle) {
+        if (CloseHandle(mutex->handle) == 0) {
+            return apr_get_os_error();
+        }
+    }
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_proc_mutex_create(apr_proc_mutex_t **mutex,
+                                                const char *fname,
+                                                apr_lockmech_e mech,
+                                                apr_pool_t *pool)
+{
+    HANDLE hMutex;
+    void *mutexkey;
+
+    /* res_name_from_filename turns fname into a pseduo-name
+     * without slashes or backslashes, and prepends the \global
+     * prefix on Win2K and later
+     */
+    if (fname) {
+        mutexkey = res_name_from_filename(fname, 1, pool);
+    }
+    else {
+        mutexkey = NULL;
+    }
+
+#if APR_HAS_UNICODE_FS
+    IF_WIN_OS_IS_UNICODE
+    {
+        hMutex = CreateMutexW(NULL, FALSE, mutexkey);
+    }
+#endif
+#if APR_HAS_ANSI_FS
+    ELSE_WIN_OS_IS_ANSI
+    {
+        hMutex = CreateMutexA(NULL, FALSE, mutexkey);
+    }
+#endif
+
+    if (!hMutex) {
+	return apr_get_os_error();
+    }
+
+    *mutex = (apr_proc_mutex_t *)apr_palloc(pool, sizeof(apr_proc_mutex_t));
+    (*mutex)->pool = pool;
+    (*mutex)->handle = hMutex;
+    (*mutex)->fname = fname;
+    apr_pool_cleanup_register((*mutex)->pool, *mutex, 
+                              proc_mutex_cleanup, apr_pool_cleanup_null);
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_proc_mutex_child_init(apr_proc_mutex_t **mutex,
+                                                    const char *fname,
+                                                    apr_pool_t *pool)
+{
+    HANDLE hMutex;
+    void *mutexkey;
+
+    if (!fname) {
+        /* Reinitializing unnamed mutexes is a noop in the Unix code. */
+        return APR_SUCCESS;
+    }
+
+    /* res_name_from_filename turns file into a pseudo-name
+     * without slashes or backslashes, and prepends the \global
+     * prefix on Win2K and later
+     */
+    mutexkey = res_name_from_filename(fname, 1, pool);
+
+#if defined(_WIN32_WCE)
+    hMutex = CreateMutex(NULL, FALSE, mutexkey);
+    if (hMutex && ERROR_ALREADY_EXISTS != GetLastError()) {
+        CloseHandle(hMutex);
+        hMutex = NULL;
+        SetLastError(ERROR_FILE_NOT_FOUND);
+    }
+#else
+#if APR_HAS_UNICODE_FS
+    IF_WIN_OS_IS_UNICODE
+    {
+        hMutex = OpenMutexW(MUTEX_ALL_ACCESS, FALSE, mutexkey);
+    }
+#endif
+#if APR_HAS_ANSI_FS
+    ELSE_WIN_OS_IS_ANSI
+    {
+        hMutex = OpenMutexA(MUTEX_ALL_ACCESS, FALSE, mutexkey);
+    }
+#endif
+#endif
+
+    if (!hMutex) {
+	return apr_get_os_error();
+    }
+
+    *mutex = (apr_proc_mutex_t *)apr_palloc(pool, sizeof(apr_proc_mutex_t));
+    (*mutex)->pool = pool;
+    (*mutex)->handle = hMutex;
+    (*mutex)->fname = fname;
+    apr_pool_cleanup_register((*mutex)->pool, *mutex, 
+                              proc_mutex_cleanup, apr_pool_cleanup_null);
+    return APR_SUCCESS;
+}
+    
+APR_DECLARE(apr_status_t) apr_proc_mutex_lock(apr_proc_mutex_t *mutex)
+{
+    DWORD rv;
+
+    rv = WaitForSingleObject(mutex->handle, INFINITE);
+
+    if (rv == WAIT_OBJECT_0 || rv == WAIT_ABANDONED) {
+        return APR_SUCCESS;
+    }
+    return apr_get_os_error();
+}
+
+APR_DECLARE(apr_status_t) apr_proc_mutex_trylock(apr_proc_mutex_t *mutex)
+{
+    DWORD rv;
+
+    rv = WaitForSingleObject(mutex->handle, 0);
+
+    if (rv == WAIT_OBJECT_0 || rv == WAIT_ABANDONED) {
+        return APR_SUCCESS;
+    } 
+    else if (rv == WAIT_TIMEOUT) {
+        return APR_EBUSY;
+    }
+    return apr_get_os_error();
+}
+
+APR_DECLARE(apr_status_t) apr_proc_mutex_unlock(apr_proc_mutex_t *mutex)
+{
+    if (ReleaseMutex(mutex->handle) == 0) {
+        return apr_get_os_error();
+    }
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_proc_mutex_destroy(apr_proc_mutex_t *mutex)
+{
+    apr_status_t stat;
+
+    stat = proc_mutex_cleanup(mutex);
+    if (stat == APR_SUCCESS) {
+        apr_pool_cleanup_kill(mutex->pool, mutex, proc_mutex_cleanup);
+    }
+    return stat;
+}
+
+APR_DECLARE(const char *) apr_proc_mutex_lockfile(apr_proc_mutex_t *mutex)
+{
+    return NULL;
+}
+
+APR_DECLARE(const char *) apr_proc_mutex_name(apr_proc_mutex_t *mutex)
+{
+    return mutex->fname;
+}
+
+APR_DECLARE(const char *) apr_proc_mutex_defname(void)
+{
+    return "win32mutex";
+}
+
+APR_POOL_IMPLEMENT_ACCESSOR(proc_mutex)
+
+/* Implement OS-specific accessors defined in apr_portable.h */
+
+APR_DECLARE(apr_status_t) apr_os_proc_mutex_get(apr_os_proc_mutex_t *ospmutex,
+                                                apr_proc_mutex_t *mutex)
+{
+    *ospmutex = mutex->handle;
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_os_proc_mutex_put(apr_proc_mutex_t **pmutex,
+                                                apr_os_proc_mutex_t *ospmutex,
+                                                apr_pool_t *pool)
+{
+    if (pool == NULL) {
+        return APR_ENOPOOL;
+    }
+    if ((*pmutex) == NULL) {
+        (*pmutex) = (apr_proc_mutex_t *)apr_palloc(pool,
+                                                   sizeof(apr_proc_mutex_t));
+        (*pmutex)->pool = pool;
+    }
+    (*pmutex)->handle = *ospmutex;
+    return APR_SUCCESS;
+}
+
diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/locks/win32/thread_cond.c b/rubbos/app/httpd-2.0.64/srclib/apr/locks/win32/thread_cond.c
new file mode 100644
index 00000000..ac71a419
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/srclib/apr/locks/win32/thread_cond.c
@@ -0,0 +1,128 @@
+/* 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_general.h"
+#include "apr_strings.h"
+#include "win32/apr_arch_thread_mutex.h"
+#include "win32/apr_arch_thread_cond.h"
+#include "apr_portable.h"
+
+static apr_status_t thread_cond_cleanup(void *data)
+{
+    apr_thread_cond_t *cond = data;
+    CloseHandle(cond->event);
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_cond_create(apr_thread_cond_t **cond,
+                                                 apr_pool_t *pool)
+{
+    *cond = apr_palloc(pool, sizeof(**cond));
+    (*cond)->pool = pool;
+    (*cond)->event = CreateEvent(NULL, TRUE, FALSE, NULL);
+    (*cond)->signal_all = 0;
+    (*cond)->num_waiting = 0;
+    return APR_SUCCESS;
+}
+
+static APR_INLINE apr_status_t _thread_cond_timedwait(apr_thread_cond_t *cond,
+                                                      apr_thread_mutex_t *mutex,
+                                                      DWORD timeout_ms )
+{
+    DWORD res;
+
+    while (1) {
+        cond->num_waiting++;
+
+        apr_thread_mutex_unlock(mutex);
+        res = WaitForSingleObject(cond->event, timeout_ms);
+        apr_thread_mutex_lock(mutex);
+        cond->num_waiting--;
+        if (res != WAIT_OBJECT_0) {
+            apr_status_t rv = apr_get_os_error();
+            if (res == WAIT_TIMEOUT) {
+                return APR_TIMEUP;
+            }
+            return apr_get_os_error();
+        }
+        if (cond->signal_all) {
+            if (cond->num_waiting == 0) {
+                cond->signal_all = 0;
+                cond->signalled = 0;
+                ResetEvent(cond->event);
+            }
+            break;
+        }
+        else if (cond->signalled) {
+            cond->signalled = 0;
+            ResetEvent(cond->event);
+            break;
+        }
+    }
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_cond_wait(apr_thread_cond_t *cond,
+                                               apr_thread_mutex_t *mutex)
+{
+    return _thread_cond_timedwait(cond, mutex, INFINITE);
+}
+
+APR_DECLARE(apr_status_t) apr_thread_cond_timedwait(apr_thread_cond_t *cond,
+                                                    apr_thread_mutex_t *mutex,
+                                                    apr_interval_time_t timeout)
+{
+    DWORD timeout_ms = (DWORD) apr_time_as_msec(timeout);
+
+    return _thread_cond_timedwait(cond, mutex, timeout_ms);
+}
+
+APR_DECLARE(apr_status_t) apr_thread_cond_signal(apr_thread_cond_t *cond)
+{
+    apr_status_t rv = APR_SUCCESS;
+    DWORD res;
+
+    cond->signalled = 1;
+    res = SetEvent(cond->event);
+    if (res == 0) {
+        rv = apr_get_os_error();
+    }
+    return rv;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_cond_broadcast(apr_thread_cond_t *cond)
+{
+    apr_status_t rv = APR_SUCCESS;
+    DWORD res;
+
+    cond->signalled = 1;
+    cond->signal_all = 1;
+    res = SetEvent(cond->event);
+    if (res == 0) {
+        rv = apr_get_os_error();
+    }
+    return rv;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_cond_destroy(apr_thread_cond_t *cond)
+{
+    return apr_pool_cleanup_run(cond->pool, cond, thread_cond_cleanup);
+}
+
+APR_POOL_IMPLEMENT_ACCESSOR(thread_cond)
+
diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/locks/win32/thread_mutex.c b/rubbos/app/httpd-2.0.64/srclib/apr/locks/win32/thread_mutex.c
new file mode 100644
index 00000000..9b10d727
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/srclib/apr/locks/win32/thread_mutex.c
@@ -0,0 +1,136 @@
+/* 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_general.h"
+#include "apr_strings.h"
+#include "apr_arch_thread_mutex.h"
+#include "apr_thread_mutex.h"
+#include "apr_portable.h"
+#include "apr_arch_misc.h"
+
+static apr_status_t thread_mutex_cleanup(void *data)
+{
+    apr_thread_mutex_t *lock = data;
+
+    if (lock->type == thread_mutex_critical_section) {
+        lock->type = -1;
+        DeleteCriticalSection(&lock->section);
+    }
+    else {
+        if (!CloseHandle(lock->handle)) {
+            return apr_get_os_error();
+        }
+    }
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_mutex_create(apr_thread_mutex_t **mutex,
+                                                  unsigned int flags,
+                                                  apr_pool_t *pool)
+{
+    (*mutex) = (apr_thread_mutex_t *)apr_palloc(pool, sizeof(**mutex));
+
+    (*mutex)->pool = pool;
+
+    if (flags & APR_THREAD_MUTEX_UNNESTED) {
+        /* Use an auto-reset signaled event, ready to accept one
+         * waiting thread.
+         */
+        (*mutex)->type = thread_mutex_unnested_event;
+        (*mutex)->handle = CreateEvent(NULL, FALSE, TRUE, NULL);
+    }
+    else {
+#if APR_HAS_UNICODE_FS
+        /* Critical Sections are terrific, performance-wise, on NT.
+         * On Win9x, we cannot 'try' on a critical section, so we 
+         * use a [slower] mutex object, instead.
+         */
+        IF_WIN_OS_IS_UNICODE {
+            InitializeCriticalSection(&(*mutex)->section);
+            (*mutex)->type = thread_mutex_critical_section;
+        }
+#endif
+#if APR_HAS_ANSI_FS
+        ELSE_WIN_OS_IS_ANSI {
+            (*mutex)->type = thread_mutex_nested_mutex;
+            (*mutex)->handle = CreateMutex(NULL, FALSE, NULL);
+
+        }
+#endif
+    }
+
+    apr_pool_cleanup_register((*mutex)->pool, (*mutex), thread_mutex_cleanup,
+                              apr_pool_cleanup_null);
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_mutex_lock(apr_thread_mutex_t *mutex)
+{
+    if (mutex->type == thread_mutex_critical_section) {
+        EnterCriticalSection(&mutex->section);
+    }
+    else {
+        DWORD rv = WaitForSingleObject(mutex->handle, INFINITE);
+	if ((rv != WAIT_OBJECT_0) && (rv != WAIT_ABANDONED)) {
+            return (rv == WAIT_TIMEOUT) ? APR_EBUSY : apr_get_os_error();
+	}
+    }        
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_mutex_trylock(apr_thread_mutex_t *mutex)
+{
+    if (mutex->type == thread_mutex_critical_section) {
+        if (!TryEnterCriticalSection(&mutex->section)) {
+            return APR_EBUSY;
+        }
+    }
+    else {
+        DWORD rv = WaitForSingleObject(mutex->handle, 0);
+	if ((rv != WAIT_OBJECT_0) && (rv != WAIT_ABANDONED)) {
+            return (rv == WAIT_TIMEOUT) ? APR_EBUSY : apr_get_os_error();
+	}
+    }        
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_mutex_unlock(apr_thread_mutex_t *mutex)
+{
+    if (mutex->type == thread_mutex_critical_section) {
+        LeaveCriticalSection(&mutex->section);
+    }
+    else if (mutex->type == thread_mutex_unnested_event) {
+        if (!SetEvent(mutex->handle)) {
+            return apr_get_os_error();
+        }
+    }
+    else if (mutex->type == thread_mutex_nested_mutex) {
+        if (!ReleaseMutex(mutex->handle)) {
+            return apr_get_os_error();
+        }
+    }
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_mutex_destroy(apr_thread_mutex_t *mutex)
+{
+    return apr_pool_cleanup_run(mutex->pool, mutex, thread_mutex_cleanup);
+}
+
+APR_POOL_IMPLEMENT_ACCESSOR(thread_mutex)
+
diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/locks/win32/thread_rwlock.c b/rubbos/app/httpd-2.0.64/srclib/apr/locks/win32/thread_rwlock.c
new file mode 100644
index 00000000..7099509f
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/srclib/apr/locks/win32/thread_rwlock.c
@@ -0,0 +1,165 @@
+/* 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_general.h"
+#include "apr_strings.h"
+#include "win32/apr_arch_thread_rwlock.h"
+#include "apr_portable.h"
+
+static apr_status_t thread_rwlock_cleanup(void *data)
+{
+    apr_thread_rwlock_t *rwlock = data;
+    
+    if (! CloseHandle(rwlock->read_event))
+        return apr_get_os_error();
+
+    if (! CloseHandle(rwlock->write_mutex))
+        return apr_get_os_error();
+    
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t)apr_thread_rwlock_create(apr_thread_rwlock_t **rwlock,
+                                                  apr_pool_t *pool)
+{
+    *rwlock = apr_palloc(pool, sizeof(**rwlock));
+
+    (*rwlock)->pool        = pool;
+    (*rwlock)->readers     = 0;
+
+    if (! ((*rwlock)->read_event = CreateEvent(NULL, TRUE, FALSE, NULL))) {
+        *rwlock = NULL;
+        return apr_get_os_error();
+    }
+
+    if (! ((*rwlock)->write_mutex = CreateMutex(NULL, FALSE, NULL))) {
+        CloseHandle((*rwlock)->read_event);
+        *rwlock = NULL;
+        return apr_get_os_error();
+    }
+
+    apr_pool_cleanup_register(pool, *rwlock, thread_rwlock_cleanup,
+                              apr_pool_cleanup_null);
+
+    return APR_SUCCESS;
+}
+
+static apr_status_t apr_thread_rwlock_rdlock_core(apr_thread_rwlock_t *rwlock,
+                                                  DWORD  milliseconds)
+{
+    DWORD   code = WaitForSingleObject(rwlock->write_mutex, milliseconds);
+
+    if (code == WAIT_FAILED || code == WAIT_TIMEOUT)
+        return APR_FROM_OS_ERROR(code);
+
+    /* We've successfully acquired the writer mutex, we can't be locked
+     * for write, so it's OK to add the reader lock.  The writer mutex
+     * doubles as race condition protection for the readers counter.   
+     */
+    InterlockedIncrement(&rwlock->readers);
+    
+    if (! ResetEvent(rwlock->read_event))
+        return apr_get_os_error();
+    
+    if (! ReleaseMutex(rwlock->write_mutex))
+        return apr_get_os_error();
+    
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_rwlock_rdlock(apr_thread_rwlock_t *rwlock)
+{
+    return apr_thread_rwlock_rdlock_core(rwlock, INFINITE);
+}
+
+APR_DECLARE(apr_status_t) 
+apr_thread_rwlock_tryrdlock(apr_thread_rwlock_t *rwlock)
+{
+    return apr_thread_rwlock_rdlock_core(rwlock, 0);
+}
+
+static apr_status_t 
+apr_thread_rwlock_wrlock_core(apr_thread_rwlock_t *rwlock, DWORD milliseconds)
+{
+    DWORD   code = WaitForSingleObject(rwlock->write_mutex, milliseconds);
+
+    if (code == WAIT_FAILED || code == WAIT_TIMEOUT)
+        return APR_FROM_OS_ERROR(code);
+
+    /* We've got the writer lock but we have to wait for all readers to
+     * unlock before it's ok to use it.
+     */
+    if (rwlock->readers) {
+        /* Must wait for readers to finish before returning, unless this
+         * is an trywrlock (milliseconds == 0):
+         */
+        code = milliseconds
+          ? WaitForSingleObject(rwlock->read_event, milliseconds)
+          : WAIT_TIMEOUT;
+        
+        if (code == WAIT_FAILED || code == WAIT_TIMEOUT) {
+            /* Unable to wait for readers to finish, release write lock: */
+            if (! ReleaseMutex(rwlock->write_mutex))
+                return apr_get_os_error();
+            
+            return APR_FROM_OS_ERROR(code);
+        }
+    }
+
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_rwlock_wrlock(apr_thread_rwlock_t *rwlock)
+{
+    return apr_thread_rwlock_wrlock_core(rwlock, INFINITE);
+}
+
+APR_DECLARE(apr_status_t)apr_thread_rwlock_trywrlock(apr_thread_rwlock_t *rwlock)
+{
+    return apr_thread_rwlock_wrlock_core(rwlock, 0);
+}
+
+APR_DECLARE(apr_status_t) apr_thread_rwlock_unlock(apr_thread_rwlock_t *rwlock)
+{
+    apr_status_t rv = 0;
+
+    /* First, guess that we're unlocking a writer */
+    if (! ReleaseMutex(rwlock->write_mutex))
+        rv = apr_get_os_error();
+    
+    if (rv == APR_FROM_OS_ERROR(ERROR_NOT_OWNER)) {
+        /* Nope, we must have a read lock */
+        if (rwlock->readers &&
+            ! InterlockedDecrement(&rwlock->readers) &&
+            ! SetEvent(rwlock->read_event)) {
+            rv = apr_get_os_error();
+        }
+        else {
+            rv = 0;
+        }
+    }
+
+    return rv;
+}
+
+APR_DECLARE(apr_status_t) apr_thread_rwlock_destroy(apr_thread_rwlock_t *rwlock)
+{
+    return apr_pool_cleanup_run(rwlock->pool, rwlock, thread_rwlock_cleanup);
+}
+
+APR_POOL_IMPLEMENT_ACCESSOR(thread_rwlock)