delete app

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

22 files changed, 0 insertions, 1658 deletions

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
deleted file mode 100644
index 3eebee5d..00000000
--- a/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/.libs/global_mutex.o
+++ /dev/null
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
deleted file mode 100644
index 400b58df..00000000
--- a/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/.libs/proc_mutex.o
+++ /dev/null
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
deleted file mode 100644
index bd2f15fe..00000000
--- a/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/.libs/thread_cond.o
+++ /dev/null
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
deleted file mode 100644
index 68df9b5e..00000000
--- a/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/.libs/thread_mutex.o
+++ /dev/null
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
deleted file mode 100644
index 3b39fdc5..00000000
--- a/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/.libs/thread_rwlock.o
+++ /dev/null
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
deleted file mode 100644
index 7e08a35e..00000000
--- a/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/Makefile
+++ /dev/null
@@ -1,19 +0,0 @@
-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
deleted file mode 100644
index 618b0eb1..00000000
--- a/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/Makefile.in
+++ /dev/null
@@ -1,19 +0,0 @@
-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
deleted file mode 100644
index bfe360aa..00000000
--- a/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/global_mutex.c
+++ /dev/null
@@ -1,178 +0,0 @@
-/* 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
deleted file mode 100644
index d0fa5457..00000000
--- a/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/global_mutex.lo
+++ /dev/null
@@ -1,12 +0,0 @@
-# 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
deleted file mode 100644
index 7e44179b..00000000
--- a/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/global_mutex.o
+++ /dev/null
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
deleted file mode 100644
index eb7b8de4..00000000
--- a/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/proc_mutex.c
+++ /dev/null
@@ -1,894 +0,0 @@
-/* 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
deleted file mode 100644
index 2359a0ee..00000000
--- a/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/proc_mutex.lo
+++ /dev/null
@@ -1,12 +0,0 @@
-# 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
deleted file mode 100644
index bee8bb3b..00000000
--- a/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/proc_mutex.o
+++ /dev/null
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
deleted file mode 100644
index 46d770f1..00000000
--- a/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/thread_cond.c
+++ /dev/null
@@ -1,152 +0,0 @@
-/* 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
deleted file mode 100644
index aa4051e8..00000000
--- a/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/thread_cond.lo
+++ /dev/null
@@ -1,12 +0,0 @@
-# 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
deleted file mode 100644
index b453da92..00000000
--- a/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/thread_cond.o
+++ /dev/null
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
deleted file mode 100644
index e146a28f..00000000
--- a/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/thread_mutex.c
+++ /dev/null
@@ -1,138 +0,0 @@
-/* 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
deleted file mode 100644
index 9f6d1033..00000000
--- a/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/thread_mutex.lo
+++ /dev/null
@@ -1,12 +0,0 @@
-# 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
deleted file mode 100644
index 87f97293..00000000
--- a/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/thread_mutex.o
+++ /dev/null
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
deleted file mode 100644
index c322b455..00000000
--- a/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/thread_rwlock.c
+++ /dev/null
@@ -1,198 +0,0 @@
-/* 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
deleted file mode 100644
index e5ed346e..00000000
--- a/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/thread_rwlock.lo
+++ /dev/null
@@ -1,12 +0,0 @@
-# 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
deleted file mode 100644
index 42f33daf..00000000
--- a/rubbos/app/httpd-2.0.64/srclib/apr/locks/unix/thread_rwlock.o
+++ /dev/null