You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@apr.apache.org by wr...@apache.org on 2001/01/19 08:02:02 UTC
cvs commit: apr-util/hooks Makefile.in apr_hooks.c ap_hooks.c
wrowe 01/01/18 23:02:02
Modified: . STATUS aprutil.dsp libaprutil.dsp
buckets Makefile.in apr_brigade.c apr_buckets.c
apr_buckets_eos.c apr_buckets_file.c
apr_buckets_flush.c apr_buckets_heap.c
apr_buckets_mmap.c apr_buckets_pipe.c
apr_buckets_pool.c apr_buckets_refcount.c
apr_buckets_simple.c apr_buckets_socket.c
crypto Makefile.in apr_sha1.c
encoding Makefile.in apr_base64.c
hooks Makefile.in apr_hooks.c
Removed: buckets ap_brigade.c ap_buckets.c ap_buckets_eos.c
ap_buckets_file.c ap_buckets_flush.c
ap_buckets_heap.c ap_buckets_mmap.c
ap_buckets_pipe.c ap_buckets_pool.c
ap_buckets_refcount.c ap_buckets_simple.c
ap_buckets_socket.c
crypto ap_sha1.c
encoding ap_base64.c
hooks ap_hooks.c
Log:
apr-util rename of ap_ symbols to apr_ notation. Part 2 of the change.
Revision Changes Path
1.18 +3 -12 apr-util/STATUS
Index: STATUS
===================================================================
RCS file: /home/cvs/apr-util/STATUS,v
retrieving revision 1.17
retrieving revision 1.18
diff -u -r1.17 -r1.18
--- STATUS 2001/01/19 03:09:53 1.17
+++ STATUS 2001/01/19 07:01:58 1.18
@@ -1,5 +1,5 @@
APRUTIL LIBRARY STATUS: -*-text-*-
-Last modified at [$Date: 2001/01/19 03:09:53 $]
+Last modified at [$Date: 2001/01/19 07:01:58 $]
Release:
...on the 12th as part of Apache 2.0a9 [need specifics here]
@@ -11,6 +11,8 @@
top-level SUBDIRS list, but definitely get it cleaned for the
dev guys. (Greg volunteers)
+ * we distribute 2 (3?) copies of sdbm in apr, and these are -public-?
+ get organized.
RELEASE NON-SHOWSTOPPERS BUT WOULD BE REAL NICE TO WRAP THESE UP:
@@ -46,14 +48,3 @@
Open Issues:
- * Compatibility header to deal with renamed symbols.
- NOTE:
- OtherBill suggests that Apache, APR, and APR-utils all have
- compat headers, and Apache's includes APR-util's which includes
- APR's. OtherBill would like apache-2.0/src/include/ap_compat.h to
- include apr-util/include/apu_compat.h, which itself includes
- apr/include/apr_compat.h. If the user employs apr_compat, and
- only uses features moved to apr, they only need the apr package.
- Status:
- apr-util/include/: Ryan +1, Greg +0, OtherBill +1, David +1
- apache-2.0/src/include/: Greg +1, Ryan -0.5, OtherBill -0.5
1.16 +20 -20 apr-util/aprutil.dsp
Index: aprutil.dsp
===================================================================
RCS file: /home/cvs/apr-util/aprutil.dsp,v
retrieving revision 1.15
retrieving revision 1.16
diff -u -r1.15 -r1.16
--- aprutil.dsp 2001/01/18 23:30:52 1.15
+++ aprutil.dsp 2001/01/19 07:01:58 1.16
@@ -90,51 +90,51 @@
# PROP Default_Filter ""
# Begin Source File
-SOURCE=.\buckets\ap_brigade.c
+SOURCE=.\buckets\apr_brigade.c
# End Source File
# Begin Source File
-SOURCE=.\buckets\ap_buckets.c
+SOURCE=.\buckets\apr_buckets.c
# End Source File
# Begin Source File
-SOURCE=.\buckets\ap_buckets_eos.c
+SOURCE=.\buckets\apr_buckets_eos.c
# End Source File
# Begin Source File
-SOURCE=.\buckets\ap_buckets_file.c
+SOURCE=.\buckets\apr_buckets_file.c
# End Source File
# Begin Source File
-SOURCE=.\buckets\ap_buckets_flush.c
+SOURCE=.\buckets\apr_buckets_flush.c
# End Source File
# Begin Source File
-SOURCE=.\buckets\ap_buckets_heap.c
+SOURCE=.\buckets\apr_buckets_heap.c
# End Source File
# Begin Source File
-SOURCE=.\buckets\ap_buckets_mmap.c
+SOURCE=.\buckets\apr_buckets_mmap.c
# End Source File
# Begin Source File
-SOURCE=.\buckets\ap_buckets_pipe.c
+SOURCE=.\buckets\apr_buckets_pipe.c
# End Source File
# Begin Source File
-SOURCE=.\buckets\ap_buckets_pool.c
+SOURCE=.\buckets\apr_buckets_pool.c
# End Source File
# Begin Source File
-SOURCE=.\buckets\ap_buckets_refcount.c
+SOURCE=.\buckets\apr_buckets_refcount.c
# End Source File
# Begin Source File
-SOURCE=.\buckets\ap_buckets_simple.c
+SOURCE=.\buckets\apr_buckets_simple.c
# End Source File
# Begin Source File
-SOURCE=.\buckets\ap_buckets_socket.c
+SOURCE=.\buckets\apr_buckets_socket.c
# End Source File
# End Group
# Begin Group "crypto"
@@ -142,7 +142,7 @@
# PROP Default_Filter ""
# Begin Source File
-SOURCE=.\crypto\ap_sha1.c
+SOURCE=.\crypto\apr_sha1.c
# End Source File
# End Group
# Begin Group "dbm"
@@ -190,7 +190,7 @@
# PROP Default_Filter ""
# Begin Source File
-SOURCE=.\encoding\ap_base64.c
+SOURCE=.\encoding\apr_base64.c
# End Source File
# End Group
# Begin Group "hooks"
@@ -198,7 +198,7 @@
# PROP Default_Filter ""
# Begin Source File
-SOURCE=.\hooks\ap_hooks.c
+SOURCE=.\hooks\apr_hooks.c
# End Source File
# End Group
# Begin Group "uri"
@@ -281,23 +281,23 @@
# PROP Default_Filter ""
# Begin Source File
-SOURCE=.\include\ap_base64.h
+SOURCE=.\include\apr_base64.h
# End Source File
# Begin Source File
-SOURCE=.\include\ap_buckets.h
+SOURCE=.\include\apr_buckets.h
# End Source File
# Begin Source File
-SOURCE=.\include\ap_hooks.h
+SOURCE=.\include\apr_hooks.h
# End Source File
# Begin Source File
-SOURCE=.\include\ap_ring.h
+SOURCE=.\include\apr_ring.h
# End Source File
# Begin Source File
-SOURCE=.\include\ap_sha1.h
+SOURCE=.\include\apr_sha1.h
# End Source File
# Begin Source File
1.8 +20 -20 apr-util/libaprutil.dsp
Index: libaprutil.dsp
===================================================================
RCS file: /home/cvs/apr-util/libaprutil.dsp,v
retrieving revision 1.7
retrieving revision 1.8
diff -u -r1.7 -r1.8
--- libaprutil.dsp 2001/01/18 23:30:52 1.7
+++ libaprutil.dsp 2001/01/19 07:01:58 1.8
@@ -95,51 +95,51 @@
# PROP Default_Filter ""
# Begin Source File
-SOURCE=.\buckets\ap_brigade.c
+SOURCE=.\buckets\apr_brigade.c
# End Source File
# Begin Source File
-SOURCE=.\buckets\ap_buckets.c
+SOURCE=.\buckets\apr_buckets.c
# End Source File
# Begin Source File
-SOURCE=.\buckets\ap_buckets_eos.c
+SOURCE=.\buckets\apr_buckets_eos.c
# End Source File
# Begin Source File
-SOURCE=.\buckets\ap_buckets_file.c
+SOURCE=.\buckets\apr_buckets_file.c
# End Source File
# Begin Source File
-SOURCE=.\buckets\ap_buckets_flush.c
+SOURCE=.\buckets\apr_buckets_flush.c
# End Source File
# Begin Source File
-SOURCE=.\buckets\ap_buckets_heap.c
+SOURCE=.\buckets\apr_buckets_heap.c
# End Source File
# Begin Source File
-SOURCE=.\buckets\ap_buckets_mmap.c
+SOURCE=.\buckets\apr_buckets_mmap.c
# End Source File
# Begin Source File
-SOURCE=.\buckets\ap_buckets_pipe.c
+SOURCE=.\buckets\apr_buckets_pipe.c
# End Source File
# Begin Source File
-SOURCE=.\buckets\ap_buckets_pool.c
+SOURCE=.\buckets\apr_buckets_pool.c
# End Source File
# Begin Source File
-SOURCE=.\buckets\ap_buckets_refcount.c
+SOURCE=.\buckets\apr_buckets_refcount.c
# End Source File
# Begin Source File
-SOURCE=.\buckets\ap_buckets_simple.c
+SOURCE=.\buckets\apr_buckets_simple.c
# End Source File
# Begin Source File
-SOURCE=.\buckets\ap_buckets_socket.c
+SOURCE=.\buckets\apr_buckets_socket.c
# End Source File
# End Group
# Begin Group "crypto"
@@ -147,7 +147,7 @@
# PROP Default_Filter ""
# Begin Source File
-SOURCE=.\crypto\ap_sha1.c
+SOURCE=.\crypto\apr_sha1.c
# End Source File
# End Group
# Begin Group "dbm"
@@ -195,7 +195,7 @@
# PROP Default_Filter ""
# Begin Source File
-SOURCE=.\encoding\ap_base64.c
+SOURCE=.\encoding\apr_base64.c
# End Source File
# End Group
# Begin Group "hooks"
@@ -203,7 +203,7 @@
# PROP Default_Filter ""
# Begin Source File
-SOURCE=.\hooks\ap_hooks.c
+SOURCE=.\hooks\apr_hooks.c
# End Source File
# End Group
# Begin Group "uri"
@@ -286,23 +286,23 @@
# PROP Default_Filter ""
# Begin Source File
-SOURCE=.\include\ap_base64.h
+SOURCE=.\include\apr_base64.h
# End Source File
# Begin Source File
-SOURCE=.\include\ap_buckets.h
+SOURCE=.\include\apr_buckets.h
# End Source File
# Begin Source File
-SOURCE=.\include\ap_hooks.h
+SOURCE=.\include\apr_hooks.h
# End Source File
# Begin Source File
-SOURCE=.\include\ap_ring.h
+SOURCE=.\include\apr_ring.h
# End Source File
# Begin Source File
-SOURCE=.\include\ap_sha1.h
+SOURCE=.\include\apr_sha1.h
# End Source File
# Begin Source File
1.10 +4 -4 apr-util/buckets/Makefile.in
Index: Makefile.in
===================================================================
RCS file: /home/cvs/apr-util/buckets/Makefile.in,v
retrieving revision 1.9
retrieving revision 1.10
diff -u -r1.9 -r1.10
--- Makefile.in 2001/01/17 04:29:26 1.9
+++ Makefile.in 2001/01/19 07:01:59 1.10
@@ -1,8 +1,8 @@
-TARGETS = ap_buckets_file.lo ap_buckets_pool.lo ap_buckets_flush.lo \
-ap_buckets_refcount.lo ap_buckets_heap.lo ap_buckets_simple.lo ap_buckets.lo \
-ap_buckets_mmap.lo ap_buckets_socket.lo ap_buckets_eos.lo ap_buckets_pipe.lo \
-ap_brigade.lo
+TARGETS = apr_buckets_file.lo apr_buckets_pool.lo apr_buckets_flush.lo \
+apr_buckets_refcount.lo apr_buckets_heap.lo apr_buckets_simple.lo apr_buckets.lo \
+apr_buckets_mmap.lo apr_buckets_socket.lo apr_buckets_eos.lo apr_buckets_pipe.lo \
+apr_brigade.lo
# bring in rules.mk for standard functionality
@INCLUDE_RULES@
1.3 +52 -52 apr-util/buckets/apr_brigade.c
Index: apr_brigade.c
===================================================================
RCS file: /home/cvs/apr-util/buckets/apr_brigade.c,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -r1.2 -r1.3
--- apr_brigade.c 2001/01/17 04:29:26 1.2
+++ apr_brigade.c 2001/01/19 07:01:59 1.3
@@ -66,100 +66,100 @@
#include <sys/uio.h>
#endif
-#include "ap_buckets.h"
+#include "apr_buckets.h"
-static apr_status_t ap_brigade_cleanup(void *data)
+static apr_status_t apr_brigade_cleanup(void *data)
{
- ap_bucket_brigade *b = data;
- ap_bucket *e;
+ apr_bucket_brigade *b = data;
+ apr_bucket *e;
/*
- * Bah! We can't use AP_RING_FOREACH here because this bucket has
+ * 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 (!AP_BRIGADE_EMPTY(b)) {
- e = AP_BRIGADE_FIRST(b);
- AP_BUCKET_REMOVE(e);
- ap_bucket_destroy(e);
+ while (!APR_BRIGADE_EMPTY(b)) {
+ e = APR_BRIGADE_FIRST(b);
+ APR_BUCKET_REMOVE(e);
+ apr_bucket_destroy(e);
}
/*
* We don't need to free(bb) because it's allocated from a pool.
*/
return APR_SUCCESS;
}
-APU_DECLARE(apr_status_t) ap_brigade_destroy(ap_bucket_brigade *b)
+APU_DECLARE(apr_status_t) apr_brigade_destroy(apr_bucket_brigade *b)
{
- apr_kill_cleanup(b->p, b, ap_brigade_cleanup);
- return ap_brigade_cleanup(b);
+ apr_kill_cleanup(b->p, b, apr_brigade_cleanup);
+ return apr_brigade_cleanup(b);
}
-APU_DECLARE(ap_bucket_brigade *) ap_brigade_create(apr_pool_t *p)
+APU_DECLARE(apr_bucket_brigade *) apr_brigade_create(apr_pool_t *p)
{
- ap_bucket_brigade *b;
+ apr_bucket_brigade *b;
b = apr_palloc(p, sizeof(*b));
b->p = p;
- AP_RING_INIT(&b->list, ap_bucket, link);
+ APR_RING_INIT(&b->list, apr_bucket, link);
- apr_register_cleanup(b->p, b, ap_brigade_cleanup, ap_brigade_cleanup);
+ apr_register_cleanup(b->p, b, apr_brigade_cleanup, apr_brigade_cleanup);
return b;
}
-APU_DECLARE(ap_bucket_brigade *) ap_brigade_split(ap_bucket_brigade *b,
- ap_bucket *e)
+APU_DECLARE(apr_bucket_brigade *) apr_brigade_split(apr_bucket_brigade *b,
+ apr_bucket *e)
{
- ap_bucket_brigade *a;
- ap_bucket *f;
+ apr_bucket_brigade *a;
+ apr_bucket *f;
- a = ap_brigade_create(b->p);
+ a = apr_brigade_create(b->p);
/* Return an empty brigade if there is nothing left in
* the first brigade to split off
*/
- if (e != AP_BRIGADE_SENTINEL(b)) {
- f = AP_RING_LAST(&b->list);
- AP_RING_UNSPLICE(e, f, link);
- AP_RING_SPLICE_HEAD(&a->list, e, f, ap_bucket, link);
+ 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);
}
return a;
}
-APU_DECLARE(ap_bucket *) ap_brigade_partition(ap_bucket_brigade *b, apr_off_t point)
+APU_DECLARE(apr_bucket *) apr_brigade_partition(apr_bucket_brigade *b, apr_off_t point)
{
- ap_bucket *e;
+ apr_bucket *e;
const char *s;
apr_size_t len;
if (point < 0)
return NULL;
- AP_BRIGADE_FOREACH(e, b) {
+ APR_BRIGADE_FOREACH(e, b) {
/* bucket is of a known length */
if ((point > e->length) && (e->length != -1)) {
- if (AP_BUCKET_IS_EOS(e))
+ if (APR_BUCKET_IS_EOS(e))
return NULL;
point -= e->length;
}
else if (point == e->length) {
- return AP_BUCKET_NEXT(e);
+ return APR_BUCKET_NEXT(e);
}
else {
/* try to split the bucket natively */
- if (ap_bucket_split(e, point) != APR_ENOTIMPL)
- return AP_BUCKET_NEXT(e);
+ if (apr_bucket_split(e, point) != APR_ENOTIMPL)
+ return APR_BUCKET_NEXT(e);
/* if the bucket cannot be split, we must read from it,
* changing its type to one that can be split */
- if (ap_bucket_read(e, &s, &len, AP_BLOCK_READ) != APR_SUCCESS)
+ if (apr_bucket_read(e, &s, &len, APR_BLOCK_READ) != APR_SUCCESS)
return NULL;
if (point < len) {
- if (ap_bucket_split(e, point) == APR_SUCCESS)
- return AP_BUCKET_NEXT(e);
+ if (apr_bucket_split(e, point) == APR_SUCCESS)
+ return APR_BUCKET_NEXT(e);
else
return NULL;
}
else if (point == len)
- return AP_BUCKET_NEXT(e);
+ return APR_BUCKET_NEXT(e);
else
point -= len;
}
@@ -167,27 +167,27 @@
return NULL;
}
-APU_DECLARE(int) ap_brigade_to_iovec(ap_bucket_brigade *b,
+APU_DECLARE(int) apr_brigade_to_iovec(apr_bucket_brigade *b,
struct iovec *vec, int nvec)
{
- ap_bucket *e;
+ apr_bucket *e;
struct iovec *orig;
apr_size_t iov_len;
orig = vec;
- AP_BRIGADE_FOREACH(e, b) {
+ APR_BRIGADE_FOREACH(e, b) {
if (nvec-- == 0)
break;
- ap_bucket_read(e, (const char **)&vec->iov_base, &iov_len, AP_NONBLOCK_READ);
+ apr_bucket_read(e, (const char **)&vec->iov_base, &iov_len, APR_NONBLOCK_READ);
vec->iov_len = iov_len; /* set indirectly in case size differs */
++vec;
}
return vec - orig;
}
-APU_DECLARE(int) ap_brigade_vputstrs(ap_bucket_brigade *b, va_list va)
+APU_DECLARE(int) apr_brigade_vputstrs(apr_bucket_brigade *b, va_list va)
{
- ap_bucket *r;
+ apr_bucket *r;
const char *x;
int j, k;
apr_size_t i;
@@ -199,54 +199,54 @@
j = strlen(x);
/* XXX: copy or not? let the caller decide? */
- r = ap_bucket_create_heap(x, j, 1, &i);
+ r = apr_bucket_create_heap(x, j, 1, &i);
if (i != j) {
/* Do we need better error reporting? */
return -1;
}
k += i;
- AP_BRIGADE_INSERT_TAIL(b, r);
+ APR_BRIGADE_INSERT_TAIL(b, r);
}
return k;
}
-APU_DECLARE_NONSTD(int) ap_brigade_putstrs(ap_bucket_brigade *b, ...)
+APU_DECLARE_NONSTD(int) apr_brigade_putstrs(apr_bucket_brigade *b, ...)
{
va_list va;
int written;
va_start(va, b);
- written = ap_brigade_vputstrs(b, va);
+ written = apr_brigade_vputstrs(b, va);
va_end(va);
return written;
}
-APU_DECLARE_NONSTD(int) ap_brigade_printf(ap_bucket_brigade *b, const char *fmt, ...)
+APU_DECLARE_NONSTD(int) apr_brigade_printf(apr_bucket_brigade *b, const char *fmt, ...)
{
va_list ap;
int res;
va_start(ap, fmt);
- res = ap_brigade_vprintf(b, fmt, ap);
+ res = apr_brigade_vprintf(b, fmt, ap);
va_end(ap);
return res;
}
-APU_DECLARE(int) ap_brigade_vprintf(ap_bucket_brigade *b, const char *fmt, va_list va)
+APU_DECLARE(int) apr_brigade_vprintf(apr_bucket_brigade *b, const char *fmt, va_list va)
{
/* XXX: This needs to be replaced with a function to printf
* directly into a bucket. I'm being lazy right now. RBB
*/
char buf[4096];
- ap_bucket *r;
+ apr_bucket *r;
int res;
res = apr_vsnprintf(buf, 4096, fmt, va);
- r = ap_bucket_create_heap(buf, strlen(buf), 1, NULL);
- AP_BRIGADE_INSERT_TAIL(b, r);
+ r = apr_bucket_create_heap(buf, strlen(buf), 1, NULL);
+ APR_BRIGADE_INSERT_TAIL(b, r);
return res;
}
1.44 +18 -18 apr-util/buckets/apr_buckets.c
Index: apr_buckets.c
===================================================================
RCS file: /home/cvs/apr-util/buckets/apr_buckets.c,v
retrieving revision 1.43
retrieving revision 1.44
diff -u -r1.43 -r1.44
--- apr_buckets.c 2001/01/18 23:30:54 1.43
+++ apr_buckets.c 2001/01/19 07:02:00 1.44
@@ -66,50 +66,50 @@
#include <sys/uio.h>
#endif
-#include "ap_buckets.h"
+#include "apr_buckets.h"
static apr_array_header_t *bucket_types;
-APU_DECLARE(void) ap_init_bucket_types(apr_pool_t *p)
+APU_DECLARE(void) apr_init_bucket_types(apr_pool_t *p)
{
- bucket_types = apr_make_array(p, 8, sizeof(ap_bucket_type));
+ bucket_types = apr_make_array(p, 8, sizeof(apr_bucket_type_t));
- ap_insert_bucket_type(&ap_eos_type);
- ap_insert_bucket_type(&ap_file_type);
- ap_insert_bucket_type(&ap_heap_type);
+ apr_insert_bucket_type(&apr_bucket_type_eos);
+ apr_insert_bucket_type(&apr_bucket_type_file);
+ apr_insert_bucket_type(&apr_bucket_type_heap);
#if APR_HAS_MMAP
- ap_insert_bucket_type(&ap_mmap_type);
+ apr_insert_bucket_type(&apr_bucket_type_mmap);
#endif
- ap_insert_bucket_type(&ap_pipe_type);
- ap_insert_bucket_type(&ap_immortal_type);
- ap_insert_bucket_type(&ap_transient_type);
- ap_insert_bucket_type(&ap_socket_type);
+ apr_insert_bucket_type(&apr_bucket_type_pipe);
+ apr_insert_bucket_type(&apr_bucket_type_immortal);
+ apr_insert_bucket_type(&apr_bucket_type_transient);
+ apr_insert_bucket_type(&apr_bucket_type_socket);
}
-int ap_insert_bucket_type(const ap_bucket_type *type)
+int apr_insert_bucket_type(const apr_bucket_type_t *type)
{
- const ap_bucket_type **newone;
+ const apr_bucket_type_t **newone;
- newone = (const ap_bucket_type **)apr_push_array(bucket_types);
+ newone = (const apr_bucket_type_t **)apr_push_array(bucket_types);
newone = &type;
return bucket_types->nelts - 1;
}
-APU_DECLARE_NONSTD(apr_status_t) ap_bucket_setaside_notimpl(ap_bucket *data)
+APU_DECLARE_NONSTD(apr_status_t) apr_bucket_setaside_notimpl(apr_bucket *data)
{
return APR_ENOTIMPL;
}
-APU_DECLARE_NONSTD(apr_status_t) ap_bucket_split_notimpl(ap_bucket *data, apr_off_t point)
+APU_DECLARE_NONSTD(apr_status_t) apr_bucket_split_notimpl(apr_bucket *data, apr_off_t point)
{
return APR_ENOTIMPL;
}
-APU_DECLARE_NONSTD(apr_status_t) ap_bucket_copy_notimpl(ap_bucket *e, ap_bucket **c)
+APU_DECLARE_NONSTD(apr_status_t) apr_bucket_copy_notimpl(apr_bucket *e, apr_bucket **c)
{
return APR_ENOTIMPL;
}
-APU_DECLARE_NONSTD(void) ap_bucket_destroy_notimpl(void *data)
+APU_DECLARE_NONSTD(void) apr_bucket_destroy_notimpl(void *data)
{
return;
}
1.18 +13 -13 apr-util/buckets/apr_buckets_eos.c
Index: apr_buckets_eos.c
===================================================================
RCS file: /home/cvs/apr-util/buckets/apr_buckets_eos.c,v
retrieving revision 1.17
retrieving revision 1.18
diff -u -r1.17 -r1.18
--- apr_buckets_eos.c 2000/12/21 18:06:15 1.17
+++ apr_buckets_eos.c 2001/01/19 07:02:00 1.18
@@ -52,43 +52,43 @@
* <http://www.apache.org/>.
*/
-#include "ap_buckets.h"
+#include "apr_buckets.h"
#include <stdlib.h>
-static apr_status_t eos_read(ap_bucket *b, const char **str,
- apr_size_t *len, ap_read_type block)
+static apr_status_t eos_read(apr_bucket *b, const char **str,
+ apr_size_t *len, apr_read_type_e block)
{
*str = NULL;
*len = 0;
return APR_SUCCESS;
}
-static apr_status_t eos_copy(ap_bucket *e, ap_bucket **c)
+static apr_status_t eos_copy(apr_bucket *e, apr_bucket **c)
{
- *c = ap_bucket_create_eos();
+ *c = apr_bucket_create_eos();
return APR_SUCCESS;
}
-APU_DECLARE(ap_bucket *) ap_bucket_make_eos(ap_bucket *b)
+APU_DECLARE(apr_bucket *) apr_bucket_make_eos(apr_bucket *b)
{
b->length = 0;
b->data = NULL;
- b->type = &ap_eos_type;
+ b->type = &apr_bucket_type_eos;
return b;
}
-APU_DECLARE(ap_bucket *) ap_bucket_create_eos(void)
+APU_DECLARE(apr_bucket *) apr_bucket_create_eos(void)
{
- ap_bucket_do_create(ap_bucket_make_eos(b));
+ apr_bucket_do_create(apr_bucket_make_eos(b));
}
-APU_DECLARE_DATA const ap_bucket_type ap_eos_type = {
+APU_DECLARE_DATA const apr_bucket_type_t apr_bucket_type_eos = {
"EOS", 5,
- ap_bucket_destroy_notimpl,
+ apr_bucket_destroy_notimpl,
eos_read,
- ap_bucket_setaside_notimpl,
- ap_bucket_split_notimpl,
+ apr_bucket_setaside_notimpl,
+ apr_bucket_split_notimpl,
eos_copy
};
1.20 +19 -19 apr-util/buckets/apr_buckets_file.c
Index: apr_buckets_file.c
===================================================================
RCS file: /home/cvs/apr-util/buckets/apr_buckets_file.c,v
retrieving revision 1.19
retrieving revision 1.20
diff -u -r1.19 -r1.20
--- apr_buckets_file.c 2001/01/05 18:18:30 1.19
+++ apr_buckets_file.c 2001/01/19 07:02:00 1.20
@@ -56,7 +56,7 @@
#include "apr_general.h"
#include "apr_lib.h"
#include "apr_file_io.h"
-#include "ap_buckets.h"
+#include "apr_buckets.h"
#include <stdlib.h>
/* Allow Apache to use ap_mmap */
@@ -86,12 +86,12 @@
/* XXX: We should obey the block flag */
-static apr_status_t file_read(ap_bucket *e, const char **str,
- apr_size_t *len, ap_read_type block)
+static apr_status_t file_read(apr_bucket *e, const char **str,
+ apr_size_t *len, apr_read_type_e block)
{
- ap_bucket_file *a = (ap_bucket_file *)e->data;
+ apr_bucket_file *a = (apr_bucket_file *)e->data;
apr_file_t *f = (apr_file_t *) a->fd;
- ap_bucket *b = NULL;
+ apr_bucket *b = NULL;
char *buf;
apr_status_t rv;
#if APR_HAS_MMAP
@@ -114,8 +114,8 @@
mm = NULL;
}
if (mm) {
- ap_bucket_make_mmap(e, mm, 0, e->length); /*XXX: check for failure? */
- return ap_bucket_read(e, str, len, block);
+ apr_bucket_make_mmap(e, mm, 0, e->length); /*XXX: check for failure? */
+ return apr_bucket_read(e, str, len, block);
}
else {
#endif
@@ -150,12 +150,12 @@
* Change the current bucket to refer to what we read,
* even if we read nothing because we hit EOF.
*/
- ap_bucket_make_heap(e, buf, *len, 0, NULL); /*XXX: check for failure? */
+ apr_bucket_make_heap(e, buf, *len, 0, NULL); /*XXX: check for failure? */
/* If we have more to read from the file, then create another bucket */
if (*len > 0) {
- b = ap_bucket_create_file(f, 0, e->length);
- AP_BUCKET_INSERT_AFTER(e, b);
+ b = apr_bucket_create_file(f, 0, e->length);
+ APR_BUCKET_INSERT_AFTER(e, b);
}
#if APR_HAS_MMAP
}
@@ -163,10 +163,10 @@
return APR_SUCCESS;
}
-APU_DECLARE(ap_bucket *) ap_bucket_make_file(ap_bucket *b, apr_file_t *fd,
+APU_DECLARE(apr_bucket *) apr_bucket_make_file(apr_bucket *b, apr_file_t *fd,
apr_off_t offset, apr_size_t len)
{
- ap_bucket_file *f;
+ apr_bucket_file *f;
f = malloc(sizeof(*f));
if (f == NULL) {
@@ -176,24 +176,24 @@
f->fd = fd;
f->offset = offset;
- b->type = &ap_file_type;
+ b->type = &apr_bucket_type_file;
b->data = f;
b->length = len;
return b;
}
-APU_DECLARE(ap_bucket *) ap_bucket_create_file(apr_file_t *fd,
+APU_DECLARE(apr_bucket *) apr_bucket_create_file(apr_file_t *fd,
apr_off_t offset, apr_size_t len)
{
- ap_bucket_do_create(ap_bucket_make_file(b, fd, offset, len));
+ apr_bucket_do_create(apr_bucket_make_file(b, fd, offset, len));
}
-APU_DECLARE_DATA const ap_bucket_type ap_file_type = {
+APU_DECLARE_DATA const apr_bucket_type_t apr_bucket_type_file = {
"FILE", 5,
free,
file_read,
- ap_bucket_setaside_notimpl,
- ap_bucket_split_notimpl,
- ap_bucket_copy_notimpl
+ apr_bucket_setaside_notimpl,
+ apr_bucket_split_notimpl,
+ apr_bucket_copy_notimpl
};
1.10 +13 -13 apr-util/buckets/apr_buckets_flush.c
Index: apr_buckets_flush.c
===================================================================
RCS file: /home/cvs/apr-util/buckets/apr_buckets_flush.c,v
retrieving revision 1.9
retrieving revision 1.10
diff -u -r1.9 -r1.10
--- apr_buckets_flush.c 2000/12/21 18:06:15 1.9
+++ apr_buckets_flush.c 2001/01/19 07:02:00 1.10
@@ -52,43 +52,43 @@
* <http://www.apache.org/>.
*/
-#include "ap_buckets.h"
+#include "apr_buckets.h"
#include <stdlib.h>
-static apr_status_t flush_read(ap_bucket *b, const char **str,
- apr_size_t *len, ap_read_type block)
+static apr_status_t flush_read(apr_bucket *b, const char **str,
+ apr_size_t *len, apr_read_type_e block)
{
*str = NULL;
*len = 0;
return APR_SUCCESS;
}
-static apr_status_t flush_copy(ap_bucket *e, ap_bucket **c)
+static apr_status_t flush_copy(apr_bucket *e, apr_bucket **c)
{
- *c = ap_bucket_create_flush();
+ *c = apr_bucket_create_flush();
return APR_SUCCESS;
}
-APU_DECLARE(ap_bucket *) ap_bucket_make_flush(ap_bucket *b)
+APU_DECLARE(apr_bucket *) apr_bucket_make_flush(apr_bucket *b)
{
b->length = 0;
b->data = NULL;
- b->type = &ap_flush_type;
+ b->type = &apr_bucket_type_flush;
return b;
}
-APU_DECLARE(ap_bucket *) ap_bucket_create_flush(void)
+APU_DECLARE(apr_bucket *) apr_bucket_create_flush(void)
{
- ap_bucket_do_create(ap_bucket_make_flush(b));
+ apr_bucket_do_create(apr_bucket_make_flush(b));
}
-APU_DECLARE_DATA const ap_bucket_type ap_flush_type = {
+APU_DECLARE_DATA const apr_bucket_type_t apr_bucket_type_flush = {
"FLUSH", 5,
- ap_bucket_destroy_notimpl,
+ apr_bucket_destroy_notimpl,
flush_read,
- ap_bucket_setaside_notimpl,
- ap_bucket_split_notimpl,
+ apr_bucket_setaside_notimpl,
+ apr_bucket_split_notimpl,
flush_copy
};
1.23 +17 -17 apr-util/buckets/apr_buckets_heap.c
Index: apr_buckets_heap.c
===================================================================
RCS file: /home/cvs/apr-util/buckets/apr_buckets_heap.c,v
retrieving revision 1.22
retrieving revision 1.23
diff -u -r1.22 -r1.23
--- apr_buckets_heap.c 2000/12/29 14:01:52 1.22
+++ apr_buckets_heap.c 2001/01/19 07:02:00 1.23
@@ -52,7 +52,7 @@
* <http://www.apache.org/>.
*/
-#include "ap_buckets.h"
+#include "apr_buckets.h"
#include <stdlib.h>
#if APR_HAVE_STRINGS_H
#include <strings.h>
@@ -72,11 +72,11 @@
((x) >= (y) ? (x) : (y))
#endif
-static apr_status_t heap_read(ap_bucket *b, const char **str,
- apr_size_t *len, ap_read_type block)
+static apr_status_t heap_read(apr_bucket *b, const char **str,
+ apr_size_t *len, apr_read_type_e block)
{
- ap_bucket_shared *s = b->data;
- ap_bucket_heap *h = s->data;
+ apr_bucket_shared *s = b->data;
+ apr_bucket_heap *h = s->data;
*str = h->base + s->start;
*len = s->end - s->start;
@@ -85,9 +85,9 @@
static void heap_destroy(void *data)
{
- ap_bucket_heap *h;
+ apr_bucket_heap *h;
- h = ap_bucket_destroy_shared(data);
+ h = apr_bucket_destroy_shared(data);
if (h == NULL) {
return;
}
@@ -95,10 +95,10 @@
free(h);
}
-APU_DECLARE(ap_bucket *) ap_bucket_make_heap(ap_bucket *b,
+APU_DECLARE(apr_bucket *) apr_bucket_make_heap(apr_bucket *b,
const char *buf, apr_size_t length, int copy, apr_size_t *w)
{
- ap_bucket_heap *h;
+ apr_bucket_heap *h;
h = malloc(sizeof(*h));
if (h == NULL) {
@@ -122,7 +122,7 @@
h->alloc_len = length;
}
- b = ap_bucket_make_shared(b, h, 0, length);
+ b = apr_bucket_make_shared(b, h, 0, length);
if (b == NULL) {
if (copy) {
free(h->base);
@@ -131,7 +131,7 @@
return NULL;
}
- b->type = &ap_heap_type;
+ b->type = &apr_bucket_type_heap;
if (w)
*w = length;
@@ -139,17 +139,17 @@
return b;
}
-APU_DECLARE(ap_bucket *) ap_bucket_create_heap(
+APU_DECLARE(apr_bucket *) apr_bucket_create_heap(
const char *buf, apr_size_t length, int copy, apr_size_t *w)
{
- ap_bucket_do_create(ap_bucket_make_heap(b, buf, length, copy, w));
+ apr_bucket_do_create(apr_bucket_make_heap(b, buf, length, copy, w));
}
-APU_DECLARE_DATA const ap_bucket_type ap_heap_type = {
+APU_DECLARE_DATA const apr_bucket_type_t apr_bucket_type_heap = {
"HEAP", 5,
heap_destroy,
heap_read,
- ap_bucket_setaside_notimpl,
- ap_bucket_split_shared,
- ap_bucket_copy_shared
+ apr_bucket_setaside_notimpl,
+ apr_bucket_split_shared,
+ apr_bucket_copy_shared
};
1.25 +17 -17 apr-util/buckets/apr_buckets_mmap.c
Index: apr_buckets_mmap.c
===================================================================
RCS file: /home/cvs/apr-util/buckets/apr_buckets_mmap.c,v
retrieving revision 1.24
retrieving revision 1.25
diff -u -r1.24 -r1.25
--- apr_buckets_mmap.c 2000/12/21 18:06:15 1.24
+++ apr_buckets_mmap.c 2001/01/19 07:02:00 1.25
@@ -52,14 +52,14 @@
* <http://www.apache.org/>.
*/
-#include "ap_buckets.h"
+#include "apr_buckets.h"
#include <stdlib.h>
-static apr_status_t mmap_read(ap_bucket *b, const char **str,
- apr_size_t *length, ap_read_type block)
+static apr_status_t mmap_read(apr_bucket *b, const char **str,
+ apr_size_t *length, apr_read_type_e block)
{
- ap_bucket_shared *s = b->data;
- ap_bucket_mmap *m = s->data;
+ apr_bucket_shared *s = b->data;
+ apr_bucket_mmap *m = s->data;
apr_status_t ok;
void *addr;
@@ -74,9 +74,9 @@
static void mmap_destroy(void *data)
{
- ap_bucket_mmap *m;
+ apr_bucket_mmap *m;
- m = ap_bucket_destroy_shared(data);
+ m = apr_bucket_destroy_shared(data);
if (m == NULL) {
return;
}
@@ -86,10 +86,10 @@
/*
* XXX: are the start and length arguments useful?
*/
-APU_DECLARE(ap_bucket *) ap_bucket_make_mmap(ap_bucket *b,
+APU_DECLARE(apr_bucket *) apr_bucket_make_mmap(apr_bucket *b,
apr_mmap_t *mm, apr_off_t start, apr_size_t length)
{
- ap_bucket_mmap *m;
+ apr_bucket_mmap *m;
m = malloc(sizeof(*m));
if (m == NULL) {
@@ -97,29 +97,29 @@
}
m->mmap = mm;
- b = ap_bucket_make_shared(b, m, start, start+length);
+ b = apr_bucket_make_shared(b, m, start, start+length);
if (b == NULL) {
free(m);
return NULL;
}
- b->type = &ap_mmap_type;
+ b->type = &apr_bucket_type_mmap;
return b;
}
-APU_DECLARE(ap_bucket *) ap_bucket_create_mmap(
+APU_DECLARE(apr_bucket *) apr_bucket_create_mmap(
apr_mmap_t *mm, apr_off_t start, apr_size_t length)
{
- ap_bucket_do_create(ap_bucket_make_mmap(b, mm, start, length));
+ apr_bucket_do_create(apr_bucket_make_mmap(b, mm, start, length));
}
-APU_DECLARE_DATA const ap_bucket_type ap_mmap_type = {
+APU_DECLARE_DATA const apr_bucket_type_t apr_bucket_type_mmap = {
"MMAP", 5,
mmap_destroy,
mmap_read,
- ap_bucket_setaside_notimpl,
- ap_bucket_split_shared,
- ap_bucket_copy_shared
+ apr_bucket_setaside_notimpl,
+ apr_bucket_split_shared,
+ apr_bucket_copy_shared
};
1.26 +19 -19 apr-util/buckets/apr_buckets_pipe.c
Index: apr_buckets_pipe.c
===================================================================
RCS file: /home/cvs/apr-util/buckets/apr_buckets_pipe.c,v
retrieving revision 1.25
retrieving revision 1.26
diff -u -r1.25 -r1.26
--- apr_buckets_pipe.c 2000/12/22 05:56:37 1.25
+++ apr_buckets_pipe.c 2001/01/19 07:02:00 1.26
@@ -53,19 +53,19 @@
*/
#include "apr_lib.h"
-#include "ap_buckets.h"
+#include "apr_buckets.h"
#include <stdlib.h>
-static apr_status_t pipe_read(ap_bucket *a, const char **str,
- apr_size_t *len, ap_read_type block)
+static apr_status_t pipe_read(apr_bucket *a, const char **str,
+ apr_size_t *len, apr_read_type_e block)
{
apr_file_t *p = a->data;
- ap_bucket *b;
+ apr_bucket *b;
char *buf;
apr_status_t rv;
apr_interval_time_t timeout;
- if (block == AP_NONBLOCK_READ) {
+ if (block == APR_NONBLOCK_READ) {
apr_get_pipe_timeout(p, &timeout);
apr_set_pipe_timeout(p, 0);
}
@@ -75,7 +75,7 @@
*len = HUGE_STRING_LEN;
rv = apr_read(p, buf, len);
- if (block == AP_NONBLOCK_READ) {
+ if (block == APR_NONBLOCK_READ) {
apr_set_pipe_timeout(p, timeout);
}
@@ -88,7 +88,7 @@
* Change the current bucket to refer to what we read,
* even if we read nothing because we hit EOF.
*/
- ap_bucket_make_heap(a, buf, *len, 0, NULL); /* XXX: check for failure? */
+ apr_bucket_make_heap(a, buf, *len, 0, NULL); /* XXX: check for failure? */
/*
* If there's more to read we have to keep the rest of the pipe
* for later. Otherwise, we'll close the pipe.
@@ -102,17 +102,17 @@
* new bucket.
*/
if (*len > 0) {
- b = ap_bucket_create_pipe(p);
- AP_BUCKET_INSERT_AFTER(a, b);
+ b = apr_bucket_create_pipe(p);
+ APR_BUCKET_INSERT_AFTER(a, b);
}
else if (rv == APR_EOF) {
apr_close(p);
- return (block == AP_NONBLOCK_READ) ? APR_EOF : APR_SUCCESS;
+ return (block == APR_NONBLOCK_READ) ? APR_EOF : APR_SUCCESS;
}
return APR_SUCCESS;
}
-APU_DECLARE(ap_bucket *) ap_bucket_make_pipe(ap_bucket *b, apr_file_t *p)
+APU_DECLARE(apr_bucket *) apr_bucket_make_pipe(apr_bucket *b, apr_file_t *p)
{
/*
* A pipe is closed when the end is reached in pipe_read(). If the
@@ -127,23 +127,23 @@
* stream so the bucket(s) that it sets aside will be the heap
* buckets created by pipe_read() above.
*/
- b->type = &ap_pipe_type;
+ b->type = &apr_bucket_type_pipe;
b->length = -1;
b->data = p;
return b;
}
-APU_DECLARE(ap_bucket *) ap_bucket_create_pipe(apr_file_t *p)
+APU_DECLARE(apr_bucket *) apr_bucket_create_pipe(apr_file_t *p)
{
- ap_bucket_do_create(ap_bucket_make_pipe(b, p));
+ apr_bucket_do_create(apr_bucket_make_pipe(b, p));
}
-APU_DECLARE_DATA const ap_bucket_type ap_pipe_type = {
+APU_DECLARE_DATA const apr_bucket_type_t apr_bucket_type_pipe = {
"PIPE", 5,
- ap_bucket_destroy_notimpl,
+ apr_bucket_destroy_notimpl,
pipe_read,
- ap_bucket_setaside_notimpl,
- ap_bucket_split_notimpl,
- ap_bucket_copy_notimpl
+ apr_bucket_setaside_notimpl,
+ apr_bucket_split_notimpl,
+ apr_bucket_copy_notimpl
};
1.9 +24 -24 apr-util/buckets/apr_buckets_pool.c
Index: apr_buckets_pool.c
===================================================================
RCS file: /home/cvs/apr-util/buckets/apr_buckets_pool.c,v
retrieving revision 1.8
retrieving revision 1.9
diff -u -r1.8 -r1.9
--- apr_buckets_pool.c 2000/12/21 18:06:15 1.8
+++ apr_buckets_pool.c 2001/01/19 07:02:00 1.9
@@ -52,32 +52,32 @@
* <http://www.apache.org/>.
*/
-#include "ap_buckets.h"
+#include "apr_buckets.h"
#include <stdlib.h>
static apr_status_t pool_bucket_cleanup(void *data)
{
- ap_bucket_shared *s = data;
- ap_bucket_shared *new;
- ap_bucket_pool *h = s->data;
- ap_bucket *b = h->b;
+ apr_bucket_shared *s = data;
+ apr_bucket_shared *new;
+ apr_bucket_pool *h = s->data;
+ apr_bucket *b = h->b;
apr_size_t w;
- ap_bucket_make_heap(b, h->base, b->length, 1, &w);
+ apr_bucket_make_heap(b, h->base, b->length, 1, &w);
new = b->data;
new->start = s->start;
new->end = s->end;
- ap_bucket_destroy_shared(s);
+ apr_bucket_destroy_shared(s);
return APR_SUCCESS;
}
-static apr_status_t pool_read(ap_bucket *b, const char **str,
- apr_size_t *len, ap_read_type block)
+static apr_status_t pool_read(apr_bucket *b, const char **str,
+ apr_size_t *len, apr_read_type_e block)
{
- ap_bucket_shared *s = b->data;
- ap_bucket_pool *h = s->data;
+ apr_bucket_shared *s = b->data;
+ apr_bucket_pool *h = s->data;
*str = h->base + s->start;
*len = s->end - s->start;
@@ -86,21 +86,21 @@
static void pool_destroy(void *data)
{
- ap_bucket_shared *s = data;
- ap_bucket_pool *h = s->data;
+ apr_bucket_shared *s = data;
+ apr_bucket_pool *h = s->data;
apr_kill_cleanup(h->p, data, pool_bucket_cleanup);
- h = ap_bucket_destroy_shared(data);
+ h = apr_bucket_destroy_shared(data);
if (h == NULL) {
return;
}
free(h);
}
-APU_DECLARE(ap_bucket *) ap_bucket_make_pool(ap_bucket *b,
+APU_DECLARE(apr_bucket *) apr_bucket_make_pool(apr_bucket *b,
const char *buf, apr_size_t length, apr_pool_t *p)
{
- ap_bucket_pool *h;
+ apr_bucket_pool *h;
h = malloc(sizeof(*h));
if (h == NULL) {
@@ -113,30 +113,30 @@
h->base = (char *) buf;
h->p = p;
- b = ap_bucket_make_shared(b, h, 0, length);
+ b = apr_bucket_make_shared(b, h, 0, length);
if (b == NULL) {
free(h);
return NULL;
}
- b->type = &ap_pool_type;
+ b->type = &apr_bucket_type_pool;
h->b = b;
apr_register_cleanup(h->p, b->data, pool_bucket_cleanup, apr_null_cleanup);
return b;
}
-APU_DECLARE(ap_bucket *) ap_bucket_create_pool(
+APU_DECLARE(apr_bucket *) apr_bucket_create_pool(
const char *buf, apr_size_t length, apr_pool_t *p)
{
- ap_bucket_do_create(ap_bucket_make_pool(b, buf, length, p));
+ apr_bucket_do_create(apr_bucket_make_pool(b, buf, length, p));
}
-APU_DECLARE_DATA const ap_bucket_type ap_pool_type = {
+APU_DECLARE_DATA const apr_bucket_type_t apr_bucket_type_pool = {
"POOL", 5,
pool_destroy,
pool_read,
- ap_bucket_setaside_notimpl,
- ap_bucket_split_shared,
- ap_bucket_copy_shared
+ apr_bucket_setaside_notimpl,
+ apr_bucket_split_shared,
+ apr_bucket_copy_shared
};
1.12 +16 -16 apr-util/buckets/apr_buckets_refcount.c
Index: apr_buckets_refcount.c
===================================================================
RCS file: /home/cvs/apr-util/buckets/apr_buckets_refcount.c,v
retrieving revision 1.11
retrieving revision 1.12
diff -u -r1.11 -r1.12
--- apr_buckets_refcount.c 2000/12/21 18:06:15 1.11
+++ apr_buckets_refcount.c 2001/01/19 07:02:00 1.12
@@ -56,19 +56,19 @@
#include "apr_errno.h"
-#include "ap_buckets.h"
+#include "apr_buckets.h"
-APU_DECLARE_NONSTD(apr_status_t) ap_bucket_split_shared(ap_bucket *a, apr_off_t point)
+APU_DECLARE_NONSTD(apr_status_t) apr_bucket_split_shared(apr_bucket *a, apr_off_t point)
{
- ap_bucket *b;
- ap_bucket_shared *ad, *bd;
+ apr_bucket *b;
+ apr_bucket_shared *ad, *bd;
apr_status_t rv;
if (point < 0 || point > a->length) {
return APR_EINVAL;
}
- rv = ap_bucket_copy_shared(a, &b);
+ rv = apr_bucket_copy_shared(a, &b);
if (rv != APR_SUCCESS) {
return rv;
}
@@ -81,16 +81,16 @@
b->length -= point;
bd->start += point;
- AP_BUCKET_INSERT_AFTER(a, b);
+ APR_BUCKET_INSERT_AFTER(a, b);
return APR_SUCCESS;
}
-APU_DECLARE_NONSTD(apr_status_t) ap_bucket_copy_shared(ap_bucket *a, ap_bucket **c)
+APU_DECLARE_NONSTD(apr_status_t) apr_bucket_copy_shared(apr_bucket *a, apr_bucket **c)
{
- ap_bucket *b;
- ap_bucket_shared *ad, *bd;
- ap_bucket_refcount *r;
+ apr_bucket *b;
+ apr_bucket_shared *ad, *bd;
+ apr_bucket_refcount *r;
b = malloc(sizeof(*b));
if (b == NULL) {
@@ -114,10 +114,10 @@
return APR_SUCCESS;
}
-APU_DECLARE(void *) ap_bucket_destroy_shared(void *data)
+APU_DECLARE(void *) apr_bucket_destroy_shared(void *data)
{
- ap_bucket_shared *s = data;
- ap_bucket_refcount *r = s->data;
+ apr_bucket_shared *s = data;
+ apr_bucket_refcount *r = s->data;
free(s);
r->refcount -= 1;
@@ -129,11 +129,11 @@
}
}
-APU_DECLARE(ap_bucket *) ap_bucket_make_shared(ap_bucket *b, void *data,
+APU_DECLARE(apr_bucket *) apr_bucket_make_shared(apr_bucket *b, void *data,
apr_off_t start, apr_off_t end)
{
- ap_bucket_shared *s;
- ap_bucket_refcount *r = data;
+ apr_bucket_shared *s;
+ apr_bucket_refcount *r = data;
s = malloc(sizeof(*s));
if (s == NULL) {
1.19 +29 -29 apr-util/buckets/apr_buckets_simple.c
Index: apr_buckets_simple.c
===================================================================
RCS file: /home/cvs/apr-util/buckets/apr_buckets_simple.c,v
retrieving revision 1.18
retrieving revision 1.19
diff -u -r1.18 -r1.19
--- apr_buckets_simple.c 2001/01/05 18:18:30 1.18
+++ apr_buckets_simple.c 2001/01/19 07:02:00 1.19
@@ -52,17 +52,17 @@
* <http://www.apache.org/>.
*/
-#include "ap_buckets.h"
+#include "apr_buckets.h"
#include <stdlib.h>
/*
- * We can't simplify this function by using an ap_bucket_make function
+ * We can't simplify this function by using an apr_bucket_make function
* because we aren't sure of the exact type of this bucket.
*/
-static apr_status_t simple_copy(ap_bucket *a, ap_bucket **c)
+static apr_status_t simple_copy(apr_bucket *a, apr_bucket **c)
{
- ap_bucket *b;
- ap_bucket_simple *ad, *bd;
+ apr_bucket *b;
+ apr_bucket_simple *ad, *bd;
b = malloc(sizeof(*b));
if (b == NULL) {
@@ -83,10 +83,10 @@
return APR_SUCCESS;
}
-static apr_status_t simple_split(ap_bucket *a, apr_off_t point)
+static apr_status_t simple_split(apr_bucket *a, apr_off_t point)
{
- ap_bucket *b;
- ap_bucket_simple *ad, *bd;
+ apr_bucket *b;
+ apr_bucket_simple *ad, *bd;
apr_status_t rv;
if (point < 0 || point > a->length) {
@@ -106,24 +106,24 @@
b->length -= point;
bd->start += point;
- AP_BUCKET_INSERT_AFTER(a, b);
+ APR_BUCKET_INSERT_AFTER(a, b);
return APR_SUCCESS;
}
-static apr_status_t simple_read(ap_bucket *b, const char **str,
- apr_size_t *len, ap_read_type block)
+static apr_status_t simple_read(apr_bucket *b, const char **str,
+ apr_size_t *len, apr_read_type_e block)
{
- ap_bucket_simple *bd = b->data;
+ apr_bucket_simple *bd = b->data;
*str = bd->start;
*len = bd->end - bd->start;
return APR_SUCCESS;
}
-APU_DECLARE(ap_bucket *) ap_bucket_make_immortal(ap_bucket *b,
+APU_DECLARE(apr_bucket *) apr_bucket_make_immortal(apr_bucket *b,
const char *buf, apr_size_t length)
{
- ap_bucket_simple *bd;
+ apr_bucket_simple *bd;
bd = malloc(sizeof(*bd));
if (bd == NULL) {
@@ -133,17 +133,17 @@
bd->start = buf;
bd->end = buf+length;
- b->type = &ap_immortal_type;
+ b->type = &apr_bucket_type_immortal;
b->length = length;
b->data = bd;
return b;
}
-APU_DECLARE(ap_bucket *) ap_bucket_create_immortal(
+APU_DECLARE(apr_bucket *) apr_bucket_create_immortal(
const char *buf, apr_size_t length)
{
- ap_bucket_do_create(ap_bucket_make_immortal(b, buf, length));
+ apr_bucket_do_create(apr_bucket_make_immortal(b, buf, length));
}
/*
@@ -151,13 +151,13 @@
* usage in various cases, e.g. share buffers in the heap between all
* the buckets that are set aside, or even spool set-aside data to
* disk if it gets too voluminous (but if it does then that's probably
- * a bug elsewhere). There should probably be a ap_brigade_setaside()
+ * a bug elsewhere). There should probably be a apr_brigade_setaside()
* function that co-ordinates the action of all the bucket setaside
* functions to improve memory efficiency.
*/
-static apr_status_t transient_setaside(ap_bucket *b)
+static apr_status_t transient_setaside(apr_bucket *b)
{
- ap_bucket_simple *bd;
+ apr_bucket_simple *bd;
const char *start, *end;
apr_size_t w;
@@ -165,7 +165,7 @@
start = bd->start;
end = bd->end;
/* XXX: handle small heap buckets */
- b = ap_bucket_make_heap(b, start, end-start, 1, &w);
+ b = apr_bucket_make_heap(b, start, end-start, 1, &w);
if (b == NULL || w != end-start) {
return APR_ENOMEM;
}
@@ -173,33 +173,33 @@
return APR_SUCCESS;
}
-APU_DECLARE(ap_bucket *) ap_bucket_make_transient(ap_bucket *b,
+APU_DECLARE(apr_bucket *) apr_bucket_make_transient(apr_bucket *b,
const char *buf, apr_size_t length)
{
- b = ap_bucket_make_immortal(b, buf, length);
+ b = apr_bucket_make_immortal(b, buf, length);
if (b == NULL) {
return NULL;
}
- b->type = &ap_transient_type;
+ b->type = &apr_bucket_type_transient;
return b;
}
-APU_DECLARE(ap_bucket *) ap_bucket_create_transient(
+APU_DECLARE(apr_bucket *) apr_bucket_create_transient(
const char *buf, apr_size_t length)
{
- ap_bucket_do_create(ap_bucket_make_transient(b, buf, length));
+ apr_bucket_do_create(apr_bucket_make_transient(b, buf, length));
}
-const ap_bucket_type ap_immortal_type = {
+const apr_bucket_type_t apr_bucket_type_immortal = {
"IMMORTAL", 5,
free,
simple_read,
- ap_bucket_setaside_notimpl,
+ apr_bucket_setaside_notimpl,
simple_split,
simple_copy
};
-APU_DECLARE_DATA const ap_bucket_type ap_transient_type = {
+APU_DECLARE_DATA const apr_bucket_type_t apr_bucket_type_transient = {
"TRANSIENT", 5,
free,
simple_read,
1.15 +19 -19 apr-util/buckets/apr_buckets_socket.c
Index: apr_buckets_socket.c
===================================================================
RCS file: /home/cvs/apr-util/buckets/apr_buckets_socket.c,v
retrieving revision 1.14
retrieving revision 1.15
diff -u -r1.14 -r1.15
--- apr_buckets_socket.c 2000/12/22 05:56:37 1.14
+++ apr_buckets_socket.c 2001/01/19 07:02:00 1.15
@@ -53,20 +53,20 @@
*/
#include "apr_lib.h"
-#include "ap_buckets.h"
+#include "apr_buckets.h"
#include <stdlib.h>
/* XXX: We should obey the block flag */
-static apr_status_t socket_read(ap_bucket *a, const char **str,
- apr_size_t *len, ap_read_type block)
+static apr_status_t socket_read(apr_bucket *a, const char **str,
+ apr_size_t *len, apr_read_type_e block)
{
apr_socket_t *p = a->data;
- ap_bucket *b;
+ apr_bucket *b;
char *buf;
apr_status_t rv;
apr_int32_t timeout;
- if (block == AP_NONBLOCK_READ) {
+ if (block == APR_NONBLOCK_READ) {
apr_getsocketopt(p, APR_SO_TIMEOUT, &timeout);
apr_setsocketopt(p, APR_SO_TIMEOUT, 0);
}
@@ -76,7 +76,7 @@
*len = HUGE_STRING_LEN;
rv = apr_recv(p, buf, len);
- if (block == AP_NONBLOCK_READ) {
+ if (block == APR_NONBLOCK_READ) {
apr_setsocketopt(p, APR_SO_TIMEOUT, timeout);
}
@@ -89,7 +89,7 @@
* Change the current bucket to refer to what we read,
* even if we read nothing because we hit EOF.
*/
- ap_bucket_make_heap(a, buf, *len, 0, NULL); /* XXX: check for failure? */
+ apr_bucket_make_heap(a, buf, *len, 0, NULL); /* XXX: check for failure? */
/*
* If there's more to read we have to keep the rest of the socket
* for later. XXX: Note that more complicated bucket types that
@@ -106,16 +106,16 @@
* down for reading, but there is no benefit to doing so.
*/
if (*len > 0) {
- b = ap_bucket_create_socket(p);
- AP_BUCKET_INSERT_AFTER(a, b);
+ b = apr_bucket_create_socket(p);
+ APR_BUCKET_INSERT_AFTER(a, b);
}
- else if (rv == APR_EOF && block == AP_NONBLOCK_READ) {
+ else if (rv == APR_EOF && block == APR_NONBLOCK_READ) {
return APR_EOF;
}
return APR_SUCCESS;
}
-APU_DECLARE(ap_bucket *) ap_bucket_make_socket(ap_bucket *b, apr_socket_t *p)
+APU_DECLARE(apr_bucket *) apr_bucket_make_socket(apr_bucket *b, apr_socket_t *p)
{
/*
* XXX: We rely on a cleanup on some pool or other to actually
@@ -125,23 +125,23 @@
* Note that typically the socket is allocated from the connection pool
* so it will disappear when the connection is finished.
*/
- b->type = &ap_socket_type;
+ b->type = &apr_bucket_type_socket;
b->length = -1;
b->data = p;
return b;
}
-APU_DECLARE(ap_bucket *) ap_bucket_create_socket(apr_socket_t *p)
+APU_DECLARE(apr_bucket *) apr_bucket_create_socket(apr_socket_t *p)
{
- ap_bucket_do_create(ap_bucket_make_socket(b, p));
+ apr_bucket_do_create(apr_bucket_make_socket(b, p));
}
-APU_DECLARE_DATA const ap_bucket_type ap_socket_type = {
+APU_DECLARE_DATA const apr_bucket_type_t apr_bucket_type_socket = {
"SOCKET", 5,
- ap_bucket_destroy_notimpl,
+ apr_bucket_destroy_notimpl,
socket_read,
- ap_bucket_setaside_notimpl,
- ap_bucket_split_notimpl,
- ap_bucket_copy_notimpl
+ apr_bucket_setaside_notimpl,
+ apr_bucket_split_notimpl,
+ apr_bucket_copy_notimpl
};
1.5 +1 -1 apr-util/crypto/Makefile.in
Index: Makefile.in
===================================================================
RCS file: /home/cvs/apr-util/crypto/Makefile.in,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -r1.4 -r1.5
--- Makefile.in 2001/01/07 01:35:50 1.4
+++ Makefile.in 2001/01/19 07:02:01 1.5
@@ -1,5 +1,5 @@
-TARGETS = ap_sha1.lo
+TARGETS = apr_sha1.lo
# bring in rules.mk for standard functionality
@INCLUDE_RULES@
1.21 +35 -37 apr-util/crypto/apr_sha1.c
Index: apr_sha1.c
===================================================================
RCS file: /home/cvs/apr-util/crypto/apr_sha1.c,v
retrieving revision 1.20
retrieving revision 1.21
diff -u -r1.20 -r1.21
--- apr_sha1.c 2000/12/21 18:06:17 1.20
+++ apr_sha1.c 2001/01/19 07:02:02 1.21
@@ -55,7 +55,7 @@
/*
* The exported function:
*
- * ap_sha1_base64(const char *clear, int len, char *out);
+ * apr_sha1_base64(const char *clear, int len, char *out);
*
* provides a means to SHA1 crypt/encode a plaintext password in
* a way which makes password files compatible with those commonly
@@ -82,8 +82,8 @@
* This code is hereby placed in the public domain
*/
-#include "ap_sha1.h"
-#include "ap_base64.h"
+#include "apr_sha1.h"
+#include "apr_base64.h"
#include "apr_strings.h"
#include "apr_lib.h"
#if APR_CHARSET_EBCDIC
@@ -122,7 +122,7 @@
#if APR_CHARSET_EBCDIC
static apr_xlate_t *ebcdic2ascii_xlate;
-APU_DECLARE(apr_status_t) ap_SHA1InitEBCDIC(apr_xlate_t *x)
+APU_DECLARE(apr_status_t) apr_SHA1InitEBCDIC(apr_xlate_t *x)
{
apr_status_t rv;
int onoff;
@@ -141,10 +141,8 @@
}
#endif
-typedef unsigned char AP_BYTE;
-
/* do SHA transformation */
-static void sha_transform(AP_SHA1_CTX *sha_info)
+static void sha_transform(apr_sha1_ctx_t *sha_info)
{
int i;
apr_uint32_t temp, A, B, C, D, E, W[80];
@@ -222,11 +220,11 @@
static void maybe_byte_reverse(apr_uint32_t *buffer, int count)
{
int i;
- AP_BYTE ct[4], *cp;
+ apr_byte_t ct[4], *cp;
if (isLittleEndian()) { /* do the swap only if it is little endian */
count /= sizeof(apr_uint32_t);
- cp = (AP_BYTE *) buffer;
+ cp = (apr_byte_t *) buffer;
for (i = 0; i < count; ++i) {
ct[0] = cp[0];
ct[1] = cp[1];
@@ -243,7 +241,7 @@
/* initialize the SHA digest */
-APU_DECLARE(void) ap_SHA1Init(AP_SHA1_CTX *sha_info)
+APU_DECLARE(void) apr_SHA1Init(apr_sha1_ctx_t *sha_info)
{
sha_info->digest[0] = 0x67452301L;
sha_info->digest[1] = 0xefcdab89L;
@@ -257,7 +255,7 @@
/* update the SHA digest */
-APU_DECLARE(void) ap_SHA1Update_binary(AP_SHA1_CTX *sha_info,
+APU_DECLARE(void) apr_SHA1Update_binary(apr_sha1_ctx_t *sha_info,
const unsigned char *buffer,
unsigned int count)
{
@@ -273,7 +271,7 @@
if (i > count) {
i = count;
}
- memcpy(((AP_BYTE *) sha_info->data) + sha_info->local, buffer, i);
+ memcpy(((apr_byte_t *) sha_info->data) + sha_info->local, buffer, i);
count -= i;
buffer += i;
sha_info->local += i;
@@ -296,12 +294,12 @@
sha_info->local = count;
}
-APU_DECLARE(void) ap_SHA1Update(AP_SHA1_CTX *sha_info, const char *buf,
+APU_DECLARE(void) apr_SHA1Update(apr_sha1_ctx_t *sha_info, const char *buf,
unsigned int count)
{
#if APR_CHARSET_EBCDIC
int i;
- const AP_BYTE *buffer = (const AP_BYTE *) buf;
+ const apr_byte_t *buffer = (const apr_byte_t *) buf;
apr_size_t inbytes_left, outbytes_left;
if ((sha_info->count_lo + ((apr_uint32_t) count << 3)) < sha_info->count_lo) {
@@ -317,7 +315,7 @@
}
inbytes_left = outbytes_left = i;
apr_xlate_conv_buffer(ebcdic2ascii_xlate, buffer, &inbytes_left,
- ((AP_BYTE *) sha_info->data) + sha_info->local,
+ ((apr_byte_t *) sha_info->data) + sha_info->local,
&outbytes_left);
count -= i;
buffer += i;
@@ -333,7 +331,7 @@
while (count >= SHA_BLOCKSIZE) {
inbytes_left = outbytes_left = SHA_BLOCKSIZE;
apr_xlate_conv_buffer(ebcdic2ascii_xlate, buffer, &inbytes_left,
- (AP_BYTE *) sha_info->data, &outbytes_left);
+ (apr_byte_t *) sha_info->data, &outbytes_left);
buffer += SHA_BLOCKSIZE;
count -= SHA_BLOCKSIZE;
maybe_byte_reverse(sha_info->data, SHA_BLOCKSIZE);
@@ -341,17 +339,17 @@
}
inbytes_left = outbytes_left = count;
apr_xlate_conv_buffer(ebcdic2ascii_xlate, buffer, &inbytes_left,
- (AP_BYTE *) sha_info->data, &outbytes_left);
+ (apr_byte_t *) sha_info->data, &outbytes_left);
sha_info->local = count;
#else
- ap_SHA1Update_binary(sha_info, (const unsigned char *) buf, count);
+ apr_SHA1Update_binary(sha_info, (const unsigned char *) buf, count);
#endif
}
/* finish computing the SHA digest */
-APU_DECLARE(void) ap_SHA1Final(unsigned char digest[SHA_DIGESTSIZE],
- AP_SHA1_CTX *sha_info)
+APU_DECLARE(void) apr_SHA1Final(unsigned char digest[APR_SHA1_DIGESTSIZE],
+ apr_sha1_ctx_t *sha_info)
{
int count, i, j;
apr_uint32_t lo_bit_count, hi_bit_count, k;
@@ -359,15 +357,15 @@
lo_bit_count = sha_info->count_lo;
hi_bit_count = sha_info->count_hi;
count = (int) ((lo_bit_count >> 3) & 0x3f);
- ((AP_BYTE *) sha_info->data)[count++] = 0x80;
+ ((apr_byte_t *) sha_info->data)[count++] = 0x80;
if (count > SHA_BLOCKSIZE - 8) {
- memset(((AP_BYTE *) sha_info->data) + count, 0, SHA_BLOCKSIZE - count);
+ memset(((apr_byte_t *) sha_info->data) + count, 0, SHA_BLOCKSIZE - count);
maybe_byte_reverse(sha_info->data, SHA_BLOCKSIZE);
sha_transform(sha_info);
- memset((AP_BYTE *) sha_info->data, 0, SHA_BLOCKSIZE - 8);
+ memset((apr_byte_t *) sha_info->data, 0, SHA_BLOCKSIZE - 8);
}
else {
- memset(((AP_BYTE *) sha_info->data) + count, 0,
+ memset(((apr_byte_t *) sha_info->data) + count, 0,
SHA_BLOCKSIZE - 8 - count);
}
maybe_byte_reverse(sha_info->data, SHA_BLOCKSIZE);
@@ -375,7 +373,7 @@
sha_info->data[15] = lo_bit_count;
sha_transform(sha_info);
- for (i = 0, j = 0; j < SHA_DIGESTSIZE; i++) {
+ for (i = 0, j = 0; j < APR_SHA1_DIGESTSIZE; i++) {
k = sha_info->digest[i];
digest[j++] = (unsigned char) ((k >> 24) & 0xff);
digest[j++] = (unsigned char) ((k >> 16) & 0xff);
@@ -385,28 +383,28 @@
}
-APU_DECLARE(void) ap_sha1_base64(const char *clear, int len, char *out)
+APU_DECLARE(void) apr_sha1_base64(const char *clear, int len, char *out)
{
int l;
- AP_SHA1_CTX context;
- AP_BYTE digest[SHA_DIGESTSIZE];
+ apr_sha1_ctx_t context;
+ apr_byte_t digest[APR_SHA1_DIGESTSIZE];
- if (strncmp(clear, AP_SHA1PW_ID, AP_SHA1PW_IDLEN) == 0) {
- clear += AP_SHA1PW_IDLEN;
+ if (strncmp(clear, APR_SHA1PW_ID, APR_SHA1PW_IDLEN) == 0) {
+ clear += APR_SHA1PW_IDLEN;
}
- ap_SHA1Init(&context);
- ap_SHA1Update(&context, clear, len);
- ap_SHA1Final(digest, &context);
+ apr_SHA1Init(&context);
+ apr_SHA1Update(&context, clear, len);
+ apr_SHA1Final(digest, &context);
/* private marker. */
- apr_cpystrn(out, AP_SHA1PW_ID, AP_SHA1PW_IDLEN + 1);
+ apr_cpystrn(out, APR_SHA1PW_ID, APR_SHA1PW_IDLEN + 1);
/* SHA1 hash is always 20 chars */
- l = ap_base64encode_binary(out + AP_SHA1PW_IDLEN, digest, sizeof(digest));
- out[l + AP_SHA1PW_IDLEN] = '\0';
+ l = apr_base64encode_binary(out + APR_SHA1PW_IDLEN, digest, sizeof(digest));
+ out[l + APR_SHA1PW_IDLEN] = '\0';
/*
- * output of base64 encoded SHA1 is always 28 chars + AP_SHA1PW_IDLEN
+ * output of base64 encoded SHA1 is always 28 chars + APR_SHA1PW_IDLEN
*/
}
1.6 +1 -1 apr-util/encoding/Makefile.in
Index: Makefile.in
===================================================================
RCS file: /home/cvs/apr-util/encoding/Makefile.in,v
retrieving revision 1.5
retrieving revision 1.6
diff -u -r1.5 -r1.6
--- Makefile.in 2001/01/07 01:35:50 1.5
+++ Makefile.in 2001/01/19 07:02:02 1.6
@@ -1,5 +1,5 @@
-TARGETS = ap_base64.lo
+TARGETS = apr_base64.lo
# bring in rules.mk for standard functionality
@INCLUDE_RULES@
1.19 +14 -14 apr-util/encoding/apr_base64.c
Index: apr_base64.c
===================================================================
RCS file: /home/cvs/apr-util/encoding/apr_base64.c,v
retrieving revision 1.18
retrieving revision 1.19
diff -u -r1.18 -r1.19
--- apr_base64.c 2000/12/21 18:06:18 1.18
+++ apr_base64.c 2001/01/19 07:02:02 1.19
@@ -57,12 +57,12 @@
*/
/* base64 encoder/decoder. Originally part of main/util.c
- * but moved here so that support/ab and ap_sha1.c could
+ * but moved here so that support/ab and apr_sha1.c could
* use it. This meant removing the apr_palloc()s and adding
* ugly 'len' functions, which is quite a nasty cost.
*/
-#include "ap_base64.h"
+#include "apr_base64.h"
#if APR_CHARSET_EBCDIC
#include "apr_xlate.h"
#endif /* APR_CHARSET_EBCDIC */
@@ -113,7 +113,7 @@
static apr_xlate_t *xlate_to_ebcdic;
static unsigned char os_toascii[256];
-APU_DECLARE(apr_status_t) ap_base64init_ebcdic(apr_xlate_t *to_ascii,
+APU_DECLARE(apr_status_t) apr_base64init_ebcdic(apr_xlate_t *to_ascii,
apr_xlate_t *to_ebcdic)
{
int i;
@@ -149,7 +149,7 @@
}
#endif /*APR_CHARSET_EBCDIC*/
-APU_DECLARE(int) ap_base64decode_len(const char *bufcoded)
+APU_DECLARE(int) apr_base64decode_len(const char *bufcoded)
{
int nbytesdecoded;
register const unsigned char *bufin;
@@ -164,14 +164,14 @@
return nbytesdecoded + 1;
}
-APU_DECLARE(int) ap_base64decode(char *bufplain, const char *bufcoded)
+APU_DECLARE(int) apr_base64decode(char *bufplain, const char *bufcoded)
{
#if APR_CHARSET_EBCDIC
apr_size_t inbytes_left, outbytes_left;
#endif /* APR_CHARSET_EBCDIC */
int len;
- len = ap_base64decode_binary((unsigned char *) bufplain, bufcoded);
+ len = apr_base64decode_binary((unsigned char *) bufplain, bufcoded);
#if APR_CHARSET_EBCDIC
inbytes_left = outbytes_left = len;
apr_xlate_conv_buffer(xlate_to_ebcdic, bufplain, &inbytes_left,
@@ -181,10 +181,10 @@
return len;
}
-/* This is the same as ap_base64decode() except on EBCDIC machines, where
+/* This is the same as apr_base64decode() except on EBCDIC machines, where
* the conversion of the output to ebcdic is left out.
*/
-APU_DECLARE(int) ap_base64decode_binary(unsigned char *bufplain,
+APU_DECLARE(int) apr_base64decode_binary(unsigned char *bufplain,
const char *bufcoded)
{
int nbytesdecoded;
@@ -232,16 +232,16 @@
static const char basis_64[] =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-APU_DECLARE(int) ap_base64encode_len(int len)
+APU_DECLARE(int) apr_base64encode_len(int len)
{
return ((len + 2) / 3 * 4) + 1;
}
-APU_DECLARE(int) ap_base64encode(char *encoded, const char *string, int len)
+APU_DECLARE(int) apr_base64encode(char *encoded, const char *string, int len)
{
#if !APR_CHARSET_EBCDIC
- return ap_base64encode_binary(encoded, (const unsigned char *) string, len);
-#else /* AP_CHARSET_EBCDIC */
+ return apr_base64encode_binary(encoded, (const unsigned char *) string, len);
+#else /* APR_CHARSET_EBCDIC */
int i;
char *p;
@@ -273,10 +273,10 @@
#endif /* APR_CHARSET_EBCDIC */
}
-/* This is the same as ap_base64encode() except on EBCDIC machines, where
+/* This is the same as apr_base64encode() except on EBCDIC machines, where
* the conversion of the input to ascii is left out.
*/
-APU_DECLARE(int) ap_base64encode_binary(char *encoded,
+APU_DECLARE(int) apr_base64encode_binary(char *encoded,
const unsigned char *string, int len)
{
int i;
1.5 +1 -1 apr-util/hooks/Makefile.in
Index: Makefile.in
===================================================================
RCS file: /home/cvs/apr-util/hooks/Makefile.in,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -r1.4 -r1.5
--- Makefile.in 2001/01/07 01:35:51 1.4
+++ Makefile.in 2001/01/19 07:02:02 1.5
@@ -1,5 +1,5 @@
-TARGETS = ap_hooks.lo
+TARGETS = apr_hooks.lo
# bring in rules.mk for standard functionality
@INCLUDE_RULES@
1.29 +27 -27 apr-util/hooks/apr_hooks.c
Index: apr_hooks.c
===================================================================
RCS file: /home/cvs/apr-util/hooks/apr_hooks.c,v
retrieving revision 1.28
retrieving revision 1.29
diff -u -r1.28 -r1.29
--- apr_hooks.c 2001/01/06 20:43:50 1.28
+++ apr_hooks.c 2001/01/19 07:02:02 1.29
@@ -59,9 +59,9 @@
#include "apr_pools.h"
#include "apr_tables.h"
#include "apr.h"
-#include "ap_hooks.h"
+#include "apr_hooks.h"
#include "apr_hash.h"
-#include "ap_generic_hook.h"
+#include "apr_generic_hook.h"
#if APR_HAVE_STRINGS_H
#include <strings.h>
@@ -71,9 +71,9 @@
#define apr_palloc(pool,size) malloc(size)
#endif
-APU_DECLARE_DATA apr_pool_t *ap_global_hook_pool = NULL;
-APU_DECLARE_DATA int ap_debug_module_hooks = 0;
-APU_DECLARE_DATA const char *ap_current_hooking_module = NULL;
+APU_DECLARE_DATA apr_pool_t *apr_global_hook_pool = NULL;
+APU_DECLARE_DATA int apr_debug_module_hooks = 0;
+APU_DECLARE_DATA const char *apr_debug_module_name = NULL;
/* NB: This must echo the LINK_##name structure */
typedef struct
@@ -188,21 +188,21 @@
apr_array_header_t *pNew;
int n;
- apr_create_pool(&p, ap_global_hook_pool);
+ apr_create_pool(&p, apr_global_hook_pool);
pSort=prepare(p,(TSortData *)pHooks->elts,pHooks->nelts);
pSort=tsort(pSort,pHooks->nelts);
- pNew=apr_make_array(ap_global_hook_pool,pHooks->nelts,sizeof(TSortData));
- if(ap_debug_module_hooks)
+ pNew=apr_make_array(apr_global_hook_pool,pHooks->nelts,sizeof(TSortData));
+ if(apr_debug_module_hooks)
printf("Sorting %s:",szName);
for(n=0 ; pSort ; pSort=pSort->pNext,++n) {
TSortData *pHook;
assert(n < pHooks->nelts);
pHook=apr_push_array(pNew);
memcpy(pHook,pSort->pData,sizeof *pHook);
- if(ap_debug_module_hooks)
+ if(apr_debug_module_hooks)
printf(" %s",pHook->szName);
}
- if(ap_debug_module_hooks)
+ if(apr_debug_module_hooks)
fputc('\n',stdout);
return pNew;
}
@@ -214,19 +214,19 @@
apr_array_header_t **paHooks;
} HookSortEntry;
-APU_DECLARE(void) ap_hook_sort_register(const char *szHookName,
+APU_DECLARE(void) apr_hook_sort_register(const char *szHookName,
apr_array_header_t **paHooks)
{
HookSortEntry *pEntry;
if(!s_aHooksToSort)
- s_aHooksToSort=apr_make_array(ap_global_hook_pool,1,sizeof(HookSortEntry));
+ s_aHooksToSort=apr_make_array(apr_global_hook_pool,1,sizeof(HookSortEntry));
pEntry=apr_push_array(s_aHooksToSort);
pEntry->szHookName=szHookName;
pEntry->paHooks=paHooks;
}
-APU_DECLARE(void) ap_sort_hooks()
+APU_DECLARE(void) apr_sort_hooks()
{
int n;
@@ -238,7 +238,7 @@
static apr_hash_t *s_phGenericHooks;
-APU_DECLARE(void) ap_hook_deregister_all(void)
+APU_DECLARE(void) apr_hook_deregister_all(void)
{
int n;
@@ -250,7 +250,7 @@
s_phGenericHooks=NULL;
}
-APU_DECLARE(void) ap_show_hook(const char *szName,const char * const *aszPre,
+APU_DECLARE(void) apr_show_hook(const char *szName,const char * const *aszPre,
const char * const *aszSucc)
{
int nFirst;
@@ -285,9 +285,9 @@
/* Generic hook support */
-AP_DECLARE_EXTERNAL_HOOK(APU,void,_generic,(void))
+APR_DECLARE_EXTERNAL_HOOK(apr,APU,void,_generic,(void))
-APU_DECLARE(apr_array_header_t *) ap_generic_hook_get(const char *szName)
+APU_DECLARE(apr_array_header_t *) apr_generic_hook_get(const char *szName)
{
apr_array_header_t **ppArray;
@@ -299,32 +299,32 @@
return *ppArray;
}
-APU_DECLARE(void) ap_hook_generic(const char *szName,void (*pfn)(void),
+APU_DECLARE(void) apr_hook_generic(const char *szName,void (*pfn)(void),
const char * const *aszPre,
const char * const *aszSucc,int nOrder)
{
- apr_array_header_t *pArray=ap_generic_hook_get(szName);
- LINK__generic *pHook;
+ apr_array_header_t *pArray=apr_generic_hook_get(szName);
+ apr_LINK__generic_t *pHook;
if(!pArray) {
apr_array_header_t **ppArray;
- pArray=apr_make_array(ap_global_hook_pool,1,sizeof(LINK__generic));
+ pArray=apr_make_array(apr_global_hook_pool,1,sizeof(apr_LINK__generic_t));
if(!s_phGenericHooks)
- s_phGenericHooks=apr_make_hash(ap_global_hook_pool);
- ppArray=apr_palloc(ap_global_hook_pool,sizeof *ppArray);
+ s_phGenericHooks=apr_make_hash(apr_global_hook_pool);
+ ppArray=apr_palloc(apr_global_hook_pool,sizeof *ppArray);
*ppArray=pArray;
apr_hash_set(s_phGenericHooks,szName,strlen(szName),ppArray);
- ap_hook_sort_register(szName,ppArray);
+ apr_hook_sort_register(szName,ppArray);
}
pHook=apr_push_array(pArray);
pHook->pFunc=pfn;
pHook->aszPredecessors=aszPre;
pHook->aszSuccessors=aszSucc;
pHook->nOrder=nOrder;
- pHook->szName=ap_current_hooking_module;
- if(ap_debug_module_hooks)
- ap_show_hook(szName,aszPre,aszSucc);
+ pHook->szName=apr_debug_module_name;
+ if(apr_debug_module_hooks)
+ apr_show_hook(szName,aszPre,aszSucc);
}
#if 0