delete app

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

1 files changed, 0 insertions, 670 deletions

diff --git a/rubbos/app/httpd-2.0.64/srclib/apr-util/buckets/apr_brigade.c b/rubbos/app/httpd-2.0.64/srclib/apr-util/buckets/apr_brigade.c
deleted file mode 100644
index 9e31a04c..00000000
--- a/rubbos/app/httpd-2.0.64/srclib/apr-util/buckets/apr_brigade.c
+++ /dev/null
@@ -1,670 +0,0 @@
-/* Copyright 2000-2005 The Apache Software Foundation or its licensors, as
- * applicable.
- *
- * Licensed 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_lib.h"
-#include "apr_strings.h"
-#include "apr_pools.h"
-#include "apr_tables.h"
-#include "apr_buckets.h"
-#include "apr_errno.h"
-#define APR_WANT_MEMFUNC
-#define APR_WANT_STRFUNC
-#include "apr_want.h"
-
-#if APR_HAVE_SYS_UIO_H
-#include <sys/uio.h>
-#endif
-
-static apr_status_t brigade_cleanup(void *data) 
-{
-    return apr_brigade_cleanup(data);
-}
-
-APU_DECLARE(apr_status_t) apr_brigade_cleanup(void *data)
-{
-    apr_bucket_brigade *b = data;
-    apr_bucket *e;
-
-    /*
-     * Bah! We can't use APR_RING_FOREACH here because this bucket has
-     * gone away when we dig inside it to get the next one.
-     */
-    while (!APR_BRIGADE_EMPTY(b)) {
-        e = APR_BRIGADE_FIRST(b);
-        apr_bucket_delete(e);
-    }
-    /*
-     * We don't need to free(bb) because it's allocated from a pool.
-     */
-    return APR_SUCCESS;
-}
-
-APU_DECLARE(apr_status_t) apr_brigade_destroy(apr_bucket_brigade *b)
-{
-    apr_pool_cleanup_kill(b->p, b, brigade_cleanup);
-    return apr_brigade_cleanup(b);
-}
-
-APU_DECLARE(apr_bucket_brigade *) apr_brigade_create(apr_pool_t *p,
-                                                     apr_bucket_alloc_t *list)
-{
-    apr_bucket_brigade *b;
-
-    b = apr_palloc(p, sizeof(*b));
-    b->p = p;
-    b->bucket_alloc = list;
-
-    APR_RING_INIT(&b->list, apr_bucket, link);
-
-    apr_pool_cleanup_register(b->p, b, brigade_cleanup, apr_pool_cleanup_null);
-    return b;
-}
-
-APU_DECLARE(apr_bucket_brigade *) apr_brigade_split(apr_bucket_brigade *b,
-                                                    apr_bucket *e)
-{
-    apr_bucket_brigade *a;
-    apr_bucket *f;
-
-    a = apr_brigade_create(b->p, b->bucket_alloc);
-    /* Return an empty brigade if there is nothing left in 
-     * the first brigade to split off 
-     */
-    if (e != APR_BRIGADE_SENTINEL(b)) {
-        f = APR_RING_LAST(&b->list);
-        APR_RING_UNSPLICE(e, f, link);
-        APR_RING_SPLICE_HEAD(&a->list, e, f, apr_bucket, link);
-    }
-
-    APR_BRIGADE_CHECK_CONSISTENCY(a);
-    APR_BRIGADE_CHECK_CONSISTENCY(b);
-
-    return a;
-}
-
-APU_DECLARE(apr_status_t) apr_brigade_partition(apr_bucket_brigade *b,
-                                                apr_off_t point,
-                                                apr_bucket **after_point)
-{
-    apr_bucket *e;
-    const char *s;
-    apr_size_t len;
-    apr_status_t rv;
-
-    if (point < 0) {
-        /* this could cause weird (not necessarily SEGV) things to happen */
-        return APR_EINVAL;
-    }
-    if (point == 0) {
-        *after_point = APR_BRIGADE_FIRST(b);
-        return APR_SUCCESS;
-    }
-
-    APR_BRIGADE_CHECK_CONSISTENCY(b);
-
-    APR_BRIGADE_FOREACH(e, b) {
-        if ((e->length == (apr_size_t)(-1)) && (point > (apr_size_t)(-1))) {
-            /* XXX: point is too far out to simply split this bucket,
-             * we must fix this bucket's size and keep going... */
-            rv = apr_bucket_read(e, &s, &len, APR_BLOCK_READ);
-            if (rv != APR_SUCCESS) {
-                *after_point = e;
-                return rv;
-            }
-        }
-        if ((point < e->length) || (e->length == (apr_size_t)(-1))) {
-            /* We already checked e->length -1 above, so we now
-             * trust e->length < MAX_APR_SIZE_T.
-             * First try to split the bucket natively... */
-            if ((rv = apr_bucket_split(e, (apr_size_t)point)) 
-                    != APR_ENOTIMPL) {
-                *after_point = APR_BUCKET_NEXT(e);
-                return rv;
-            }
-
-            /* if the bucket cannot be split, we must read from it,
-             * changing its type to one that can be split */
-            rv = apr_bucket_read(e, &s, &len, APR_BLOCK_READ);
-            if (rv != APR_SUCCESS) {
-                *after_point = e;
-                return rv;
-            }
-
-            /* this assumes that len == e->length, which is okay because e
-             * might have been morphed by the apr_bucket_read() above, but
-             * if it was, the length would have been adjusted appropriately */
-            if (point < e->length) {
-                rv = apr_bucket_split(e, (apr_size_t)point);
-                *after_point = APR_BUCKET_NEXT(e);
-                return rv;
-            }
-        }
-        if (point == e->length) {
-            *after_point = APR_BUCKET_NEXT(e);
-            return APR_SUCCESS;
-        }
-        point -= e->length;
-    }
-    *after_point = APR_BRIGADE_SENTINEL(b); 
-    return APR_INCOMPLETE;
-}
-
-APU_DECLARE(apr_status_t) apr_brigade_length(apr_bucket_brigade *bb,
-                                             int read_all, apr_off_t *length)
-{
-    apr_off_t total = 0;
-    apr_bucket *bkt;
-
-    APR_BRIGADE_FOREACH(bkt, bb) {
-        if (bkt->length == (apr_size_t)(-1)) {
-            const char *ignore;
-            apr_size_t len;
-            apr_status_t status;
-
-            if (!read_all) {
-                *length = -1;
-                return APR_SUCCESS;
-            }
-
-            if ((status = apr_bucket_read(bkt, &ignore, &len,
-                                          APR_BLOCK_READ)) != APR_SUCCESS) {
-                return status;
-            }
-        }
-
-        total += bkt->length;
-    }
-
-    *length = total;
-    return APR_SUCCESS;
-}
-
-APU_DECLARE(apr_status_t) apr_brigade_flatten(apr_bucket_brigade *bb,
-                                              char *c, apr_size_t *len)
-{
-    apr_size_t actual = 0;
-    apr_bucket *b;
- 
-    APR_BRIGADE_FOREACH(b, bb) {
-        const char *str;
-        apr_size_t str_len;
-        apr_status_t status;
-
-        status = apr_bucket_read(b, &str, &str_len, APR_BLOCK_READ);
-        if (status != APR_SUCCESS) {
-            return status;
-        }
-
-        /* If we would overflow. */
-        if (str_len + actual > *len) {
-            str_len = *len - actual;
-        }
-
-        /* XXX: It appears that overflow of the final bucket
-         * is DISCARDED without any warning to the caller.
-         *
-         * No, we only copy the data up to their requested size.  -- jre
-         */
-        memcpy(c, str, str_len);
-
-        c += str_len;
-        actual += str_len;
-
-        /* This could probably be actual == *len, but be safe from stray
-         * photons. */
-        if (actual >= *len) {
-            break;
-        }
-    }
-
-    *len = actual;
-    return APR_SUCCESS;
-}
-
-APU_DECLARE(apr_status_t) apr_brigade_pflatten(apr_bucket_brigade *bb,
-                                               char **c,
-                                               apr_size_t *len,
-                                               apr_pool_t *pool)
-{
-    apr_off_t actual;
-    apr_size_t total;
-    apr_status_t rv;
-
-    apr_brigade_length(bb, 1, &actual);
-    
-    /* XXX: This is dangerous beyond belief.  At least in the
-     * apr_brigade_flatten case, the user explicitly stated their
-     * buffer length - so we don't up and palloc 4GB for a single
-     * file bucket.  This API must grow a useful max boundry,
-     * either compiled-in or preset via the *len value.
-     *
-     * Shouldn't both fn's grow an additional return value for 
-     * the case that the brigade couldn't be flattened into the
-     * provided or allocated buffer (such as APR_EMOREDATA?)
-     * Not a failure, simply an advisory result.
-     */
-    total = (apr_size_t)actual;
-
-    *c = apr_palloc(pool, total);
-    
-    rv = apr_brigade_flatten(bb, *c, &total);
-
-    if (rv != APR_SUCCESS) {
-        return rv;
-    }
-
-    *len = total;
-    return APR_SUCCESS;
-}
-
-APU_DECLARE(apr_status_t) apr_brigade_split_line(apr_bucket_brigade *bbOut,
-                                                 apr_bucket_brigade *bbIn,
-                                                 apr_read_type_e block,
-                                                 apr_off_t maxbytes)
-{
-    apr_off_t readbytes = 0;
-
-    while (!APR_BRIGADE_EMPTY(bbIn)) {
-        const char *pos;
-        const char *str;
-        apr_size_t len;
-        apr_status_t rv;
-        apr_bucket *e;
-
-        e = APR_BRIGADE_FIRST(bbIn);
-        rv = apr_bucket_read(e, &str, &len, block);
-
-        if (rv != APR_SUCCESS) {
-            return rv;
-        }
-
-        pos = memchr(str, APR_ASCII_LF, len);
-        /* We found a match. */
-        if (pos != NULL) {
-            apr_bucket_split(e, pos - str + 1);
-            APR_BUCKET_REMOVE(e);
-            APR_BRIGADE_INSERT_TAIL(bbOut, e);
-            return APR_SUCCESS;
-        }
-        APR_BUCKET_REMOVE(e);
-        if (APR_BUCKET_IS_METADATA(e) || len > APR_BUCKET_BUFF_SIZE/4) {
-            APR_BRIGADE_INSERT_TAIL(bbOut, e);
-        }
-        else {
-            if (len > 0) {
-                rv = apr_brigade_write(bbOut, NULL, NULL, str, len);
-                if (rv != APR_SUCCESS) {
-                    return rv;
-                }
-            }
-            apr_bucket_destroy(e);
-        }
-        readbytes += len;
-        /* We didn't find an APR_ASCII_LF within the maximum line length. */
-        if (readbytes >= maxbytes) {
-            break;
-        }
-    }
-
-    return APR_SUCCESS;
-}
-
-
-APU_DECLARE(apr_status_t) apr_brigade_to_iovec(apr_bucket_brigade *b, 
-                                               struct iovec *vec, int *nvec)
-{
-    int left = *nvec;
-    apr_bucket *e;
-    struct iovec *orig;
-    apr_size_t iov_len;
-    apr_status_t rv;
-
-    orig = vec;
-    APR_BRIGADE_FOREACH(e, b) {
-        if (left-- == 0)
-            break;
-
-        rv = apr_bucket_read(e, (const char **)&vec->iov_base, &iov_len,
-                             APR_NONBLOCK_READ);
-        if (rv != APR_SUCCESS)
-            return rv;
-        vec->iov_len = iov_len; /* set indirectly in case size differs */
-        ++vec;
-    }
-
-    *nvec = vec - orig;
-    return APR_SUCCESS;
-}
-
-APU_DECLARE(apr_status_t) apr_brigade_vputstrs(apr_bucket_brigade *b, 
-                                               apr_brigade_flush flush,
-                                               void *ctx,
-                                               va_list va)
-{
-    for (;;) {
-        const char *str = va_arg(va, const char *);
-        apr_status_t rv;
-
-        if (str == NULL)
-            break;
-
-        rv = apr_brigade_write(b, flush, ctx, str, strlen(str));
-        if (rv != APR_SUCCESS)
-            return rv;
-    }
-
-    return APR_SUCCESS;
-}
-
-APU_DECLARE(apr_status_t) apr_brigade_putc(apr_bucket_brigade *b,
-                                           apr_brigade_flush flush, void *ctx,
-                                           const char c)
-{
-    return apr_brigade_write(b, flush, ctx, &c, 1);
-}
-
-APU_DECLARE(apr_status_t) apr_brigade_write(apr_bucket_brigade *b,
-                                            apr_brigade_flush flush,
-                                            void *ctx, 
-                                            const char *str, apr_size_t nbyte)
-{
-    apr_bucket *e = APR_BRIGADE_LAST(b);
-    apr_size_t remaining = APR_BUCKET_BUFF_SIZE;
-    char *buf = NULL;
-
-    if (!APR_BRIGADE_EMPTY(b) && APR_BUCKET_IS_HEAP(e)) {
-        apr_bucket_heap *h = e->data;
-
-        /* HEAP bucket start offsets are always in-memory, safe to cast */
-        remaining = h->alloc_len - (e->length + (apr_size_t)e->start);
-        buf = h->base + e->start + e->length;
-    }
-
-    if (nbyte > remaining) {
-        /* either a buffer bucket exists but is full, 
-         * or no buffer bucket exists and the data is too big
-         * to buffer.  In either case, we should flush.  */
-        if (flush) {
-            e = apr_bucket_transient_create(str, nbyte, b->bucket_alloc);
-            APR_BRIGADE_INSERT_TAIL(b, e);
-            return flush(b, ctx);
-        }
-        else {
-            e = apr_bucket_heap_create(str, nbyte, NULL, b->bucket_alloc);
-            APR_BRIGADE_INSERT_TAIL(b, e);
-            return APR_SUCCESS;
-        }
-    }
-    else if (!buf) {
-        /* we don't have a buffer, but the data is small enough
-         * that we don't mind making a new buffer */
-        buf = apr_bucket_alloc(APR_BUCKET_BUFF_SIZE, b->bucket_alloc);
-        e = apr_bucket_heap_create(buf, APR_BUCKET_BUFF_SIZE,
-                                   apr_bucket_free, b->bucket_alloc);
-        APR_BRIGADE_INSERT_TAIL(b, e);
-        e->length = 0;   /* We are writing into the brigade, and
-                          * allocating more memory than we need.  This
-                          * ensures that the bucket thinks it is empty just
-                          * after we create it.  We'll fix the length
-                          * once we put data in it below.
-                          */
-    }
-
-    /* there is a sufficiently big buffer bucket available now */
-    memcpy(buf, str, nbyte);
-    e->length += nbyte;
-
-    return APR_SUCCESS;
-}
-
-APU_DECLARE(apr_status_t) apr_brigade_writev(apr_bucket_brigade *b,
-                                             apr_brigade_flush flush,
-                                             void *ctx,
-                                             const struct iovec *vec,
-                                             apr_size_t nvec)
-{
-    apr_bucket *e;
-    apr_size_t total_len;
-    apr_size_t i;
-    char *buf;
-
-    /* Compute the total length of the data to be written.
-     */
-    total_len = 0;
-    for (i = 0; i < nvec; i++) {
-       total_len += vec[i].iov_len;
-    }
-
-    /* If the data to be written is very large, try to convert
-     * the iovec to transient buckets rather than copying.
-     */
-    if (total_len > APR_BUCKET_BUFF_SIZE) {
-        if (flush) {
-            for (i = 0; i < nvec; i++) {
-                e = apr_bucket_transient_create(vec[i].iov_base,
-                                                vec[i].iov_len,
-                                                b->bucket_alloc);
-                APR_BRIGADE_INSERT_TAIL(b, e);
-            }
-            return flush(b, ctx);
-        }
-        else {
-            for (i = 0; i < nvec; i++) {
-                e = apr_bucket_heap_create((const char *) vec[i].iov_base,
-                                           vec[i].iov_len, NULL,
-                                           b->bucket_alloc);
-                APR_BRIGADE_INSERT_TAIL(b, e);
-            }
-            return APR_SUCCESS;
-        }
-    }
-
-    i = 0;
-
-    /* If there is a heap bucket at the end of the brigade
-     * already, copy into the existing bucket.
-     */
-    e = APR_BRIGADE_LAST(b);
-    if (!APR_BRIGADE_EMPTY(b) && APR_BUCKET_IS_HEAP(e)) {
-        apr_bucket_heap *h = e->data;
-        apr_size_t remaining = h->alloc_len -
-            (e->length + (apr_size_t)e->start);
-        buf = h->base + e->start + e->length;
-
-        if (remaining >= total_len) {
-            /* Simple case: all the data will fit in the
-             * existing heap bucket
-             */
-            for (; i < nvec; i++) {
-                apr_size_t len = vec[i].iov_len;
-                memcpy(buf, (const void *) vec[i].iov_base, len);
-                buf += len;
-            }
-            e->length += total_len;
-            return APR_SUCCESS;
-        }
-        else {
-            /* More complicated case: not all of the data
-             * will fit in the existing heap bucket.  The
-             * total data size is <= APR_BUCKET_BUFF_SIZE,
-             * so we'll need only one additional bucket.
-             */
-            const char *start_buf = buf;
-            for (; i < nvec; i++) {
-                apr_size_t len = vec[i].iov_len;
-                if (len > remaining) {
-                    break;
-                }
-                memcpy(buf, (const void *) vec[i].iov_base, len);
-                buf += len;
-                remaining -= len;
-            }
-            e->length += (buf - start_buf);
-            total_len -= (buf - start_buf);
-
-            if (flush) {
-                apr_status_t rv = flush(b, ctx);
-                if (rv != APR_SUCCESS) {
-                    return rv;
-                }
-            }
-
-            /* Now fall through into the case below to
-             * allocate another heap bucket and copy the
-             * rest of the array.  (Note that i is not
-             * reset to zero here; it holds the index
-             * of the first vector element to be
-             * written to the new bucket.)
-             */
-        }
-    }
-
-    /* Allocate a new heap bucket, and copy the data into it.
-     * The checks above ensure that the amount of data to be
-     * written here is no larger than APR_BUCKET_BUFF_SIZE.
-     */
-    buf = apr_bucket_alloc(APR_BUCKET_BUFF_SIZE, b->bucket_alloc);
-    e = apr_bucket_heap_create(buf, APR_BUCKET_BUFF_SIZE,
-                               apr_bucket_free, b->bucket_alloc);
-    for (; i < nvec; i++) {
-        apr_size_t len = vec[i].iov_len;
-        memcpy(buf, (const void *) vec[i].iov_base, len);
-        buf += len;
-    }
-    e->length = total_len;
-    APR_BRIGADE_INSERT_TAIL(b, e);
-
-    return APR_SUCCESS;
-}
-
-APU_DECLARE(apr_status_t) apr_brigade_puts(apr_bucket_brigade *bb,
-                                           apr_brigade_flush flush, void *ctx,
-                                           const char *str)
-{
-    apr_size_t len = strlen(str);
-    apr_bucket *bkt = APR_BRIGADE_LAST(bb);
-    if (!APR_BRIGADE_EMPTY(bb) && APR_BUCKET_IS_HEAP(bkt)) {
-        /* If there is enough space available in a heap bucket
-         * at the end of the brigade, copy the string directly
-         * into the heap bucket
-         */
-        apr_bucket_heap *h = bkt->data;
-        apr_size_t bytes_avail = h->alloc_len - bkt->length;
-
-        if (bytes_avail >= len) {
-            char *buf = h->base + bkt->start + bkt->length;
-            memcpy(buf, str, len);
-            bkt->length += len;
-            return APR_SUCCESS;
-        }
-    }
-
-    /* If the string could not be copied into an existing heap
-     * bucket, delegate the work to apr_brigade_write(), which
-     * knows how to grow the brigade
-     */
-    return apr_brigade_write(bb, flush, ctx, str, len);
-}
-
-APU_DECLARE_NONSTD(apr_status_t) apr_brigade_putstrs(apr_bucket_brigade *b, 
-                                                     apr_brigade_flush flush,
-                                                     void *ctx, ...)
-{
-    va_list va;
-    apr_status_t rv;
-
-    va_start(va, ctx);
-    rv = apr_brigade_vputstrs(b, flush, ctx, va);
-    va_end(va);
-    return rv;
-}
-
-APU_DECLARE_NONSTD(apr_status_t) apr_brigade_printf(apr_bucket_brigade *b, 
-                                                    apr_brigade_flush flush,
-                                                    void *ctx, 
-                                                    const char *fmt, ...)
-{
-    va_list ap;
-    apr_status_t rv;
-
-    va_start(ap, fmt);
-    rv = apr_brigade_vprintf(b, flush, ctx, fmt, ap);
-    va_end(ap);
-    return rv;
-}
-
-struct brigade_vprintf_data_t {
-    apr_vformatter_buff_t vbuff;
-
-    apr_bucket_brigade *b;  /* associated brigade */
-    apr_brigade_flush *flusher; /* flushing function */
-    void *ctx;
-
-    char *cbuff; /* buffer to flush from */
-};
-
-static apr_status_t brigade_flush(apr_vformatter_buff_t *buff)
-{
-    /* callback function passed to ap_vformatter to be
-     * called when vformatter needs to buff and
-     * buff.curpos > buff.endpos
-     */
-
-    /* "downcast," have really passed a brigade_vprintf_data_t* */
-    struct brigade_vprintf_data_t *vd = (struct brigade_vprintf_data_t*)buff;
-    apr_status_t res = APR_SUCCESS;
-
-    res = apr_brigade_write(vd->b, *vd->flusher, vd->ctx, vd->cbuff,
-                          APR_BUCKET_BUFF_SIZE);
-
-    if(res != APR_SUCCESS) {
-      return -1;
-    }
-
-    vd->vbuff.curpos = vd->cbuff;
-    vd->vbuff.endpos = vd->cbuff + APR_BUCKET_BUFF_SIZE;
-
-    return res;
-}
-
-APU_DECLARE(apr_status_t) apr_brigade_vprintf(apr_bucket_brigade *b,
-                                              apr_brigade_flush flush,
-                                              void *ctx,
-                                              const char *fmt, va_list va)
-{
-    /* the cast, in order of appearance */
-    struct brigade_vprintf_data_t vd;
-    char buf[APR_BUCKET_BUFF_SIZE];
-    apr_size_t written;
-
-    vd.vbuff.curpos = buf;
-    vd.vbuff.endpos = buf + APR_BUCKET_BUFF_SIZE;
-    vd.b = b;
-    vd.flusher = &flush;
-    vd.ctx = ctx;
-    vd.cbuff = buf;
-
-    written = apr_vformatter(brigade_flush, &vd.vbuff, fmt, va);
-
-    if (written == -1) {
-      return -1;
-    }
-
-    /* write out what remains in the buffer */
-    return apr_brigade_write(b, flush, ctx, buf, vd.vbuff.curpos - buf);
-}
-