From 570c17aa3bb6a39030ebefc5618f0c3fa8cf0089 Mon Sep 17 00:00:00 2001 From: Stef Walter Date: Sun, 25 Apr 2004 05:50:07 +0000 Subject: Debugging of simple authentication handler --- common/buffer.c | 257 ++++++++++++++++++++++++++++++++++++++------------------ 1 file changed, 177 insertions(+), 80 deletions(-) (limited to 'common/buffer.c') diff --git a/common/buffer.c b/common/buffer.c index 0bba3bf..db23d79 100644 --- a/common/buffer.c +++ b/common/buffer.c @@ -8,44 +8,106 @@ * Memory Buffer */ +#define BUF_IS_EMPTY(b) ((b)->_pp == (b)->_rp) +#define BUF_IN_JOIN(b) (!BUF_IS_EMPTY(b) && *((b)->_rp - 1) != 0) +#define BUF_NEW_BLOCK(b) ((b)->_pp = (b)->_rp) + +/* TODO: Increase this size to 2048 once we're done debugging */ +#define BUF_INITIAL 80 +#define BUF_DELTA 16 + +#define INTERNAL_DATA(intl) ((void*)(((unsigned char*)(intl)) + sizeof(*(intl)))) + +#define FILL_BETWEEN(b, e, x) memset((b), x, ((char*)(e)) - ((char*)(b))); + /* * LEGEND: - * _al: allocated - * _dt: data + * _ft: first buffer block + * _dt: current buffer block * _rp: read/write point * _pp: parse/begin point */ +typedef struct ha_buffer_internal +{ + char* end; + struct ha_buffer_internal* next; +} +internal_t; + void buffer_bump(ha_buffer_t* buf, int count) { + int allocated; + internal_t* intl; + ASSERT(buf && count); if(ha_buferr(buf)) return; - if(buf->_rp + count >= buf->_dt + buf->_al) + ASSERT(BUF_DELTA < BUF_INITIAL); + + /* Handle this common case first for efficiency */ + if(buf->_rp + (count + BUF_DELTA) < buf->_dt->end) + return; + + /* Now when in joins we let it go closer */ + if(BUF_IN_JOIN(buf) && (buf->_rp + count < buf->_dt->end)) + return; + + /* Okay now we know we have to extend */ + allocated = buf->_dt->end - (char*)(buf->_dt); + ASSERT(allocated > 0 && (allocated % BUF_INITIAL) == 0); + + /* Enlarge the size as much as needed */ + do + { + allocated *= 2; + } + while(allocated < count); + + ASSERT(sizeof(internal_t) < allocated); + intl = (internal_t*)malloc(allocated); + if(!intl) + { + ha_messagex(LOG_CRIT, "out of memory"); + buf->_dt = NULL; + buf->_pp = buf->_rp = NULL; + return; + } + else { - char* old = buf->_dt; - int alloc = buf->_al; - int diff; + void* beg = INTERNAL_DATA(intl); + intl->end = ((char*)(intl) + allocated); + intl->next = NULL; - while((buf->_al + count) > alloc) - alloc *= 2; +#ifdef _DEBUG + FILL_BETWEEN(beg, intl->end, 0xCD); +#endif - buf->_dt = (char*)reallocf(buf->_dt, alloc * sizeof(char)); - if(!buf->_dt) + if(BUF_IN_JOIN(buf)) { - buf->_al = 0; - buf->_rp = buf->_pp = NULL; - ha_messagex(LOG_CRIT, "out of memory"); - return; - } + int diff = buf->_rp - buf->_pp; + + /* Always true in a join */ + ASSERT(buf->_pp < buf->_rp); - buf->_al = alloc; + /* Copy the memory and blank out old */ + memcpy(beg, buf->_pp, diff); +#ifdef _DEBUG + FILL_BETWEEN(buf->_pp, buf->_rp, 0xDD); +#endif + + buf->_pp = beg; + buf->_rp = buf->_pp + diff; + } + else + { + buf->_rp = buf->_pp = INTERNAL_DATA(intl); + } - diff = buf->_dt - old; - buf->_rp += diff; - buf->_pp += diff; + buf->_dt->next = intl; + buf->_dt = intl; } } @@ -53,39 +115,57 @@ void ha_bufinit(ha_buffer_t* buf) { ASSERT(buf); memset(buf, 0, sizeof(*buf)); - ha_bufreset(buf); + + ASSERT(BUF_INITIAL > sizeof(internal_t)); + buf->_ft = (internal_t*)malloc(BUF_INITIAL); + if(buf->_ft) + { + buf->_ft->end = ((char*)(buf->_ft) + BUF_INITIAL); + buf->_ft->next = NULL; + +#ifdef _DEBUG + FILL_BETWEEN(INTERNAL_DATA(buf->_ft), buf->_ft->end, 0xCD); +#endif + + ha_bufreset(buf); + } } void ha_bufreset(ha_buffer_t* buf) { - ASSERT(buf); +#ifdef _DEBUG + internal_t* intl; +#endif - if(!buf->_dt || buf->_al == 0) - { - buf->_dt = (char*)reallocf(buf->_dt, 256 * sizeof(char)); - if(!buf->_dt) - { - buf->_al = 0; - buf->_rp = buf->_pp = NULL; - ha_messagex(LOG_CRIT, "out of memory"); - return; - } + ASSERT(buf); + ASSERT(buf->_ft); - buf->_al = 256; - } +#ifdef _DEBUG + /* Go through all the buffers and set them to 0xCD */ + for(intl = buf->_ft; intl; intl = intl->next) + FILL_BETWEEN(INTERNAL_DATA(intl), intl->end, 0xCD); +#endif - buf->_rp = buf->_dt; - buf->_pp = buf->_dt; + buf->_dt = buf->_ft; + buf->_rp = buf->_pp = (char*)INTERNAL_DATA(buf->_ft); } void ha_buffree(ha_buffer_t* buf) { + internal_t* intl; + internal_t* next; + ASSERT(buf); - if(buf->_dt) - free(buf->_dt); + /* Go through free all the buffers and set them to 0xDD */ + for(intl = buf->_ft; intl; intl = next) + { + next = intl->next; + FILL_BETWEEN(INTERNAL_DATA(intl), intl->end, 0xDD); + free(intl); + } - buf->_al = 0; + buf->_ft = buf->_dt = NULL; buf->_rp = buf->_pp = NULL; } @@ -258,9 +338,8 @@ char* ha_bufmcat(ha_buffer_t* buf, ...) if(ha_buferr(buf)) return NULL; - /* Move up the block pointer if we're not joining strings */ - if(ha_buflen(buf) > 0 && *(buf->_rp - 1) != 0) - buf->_pp = buf->_rp; + if(!BUF_IN_JOIN(buf)) + BUF_NEW_BLOCK(buf); while((str = va_arg(ap, char*)) != NULL) { @@ -298,16 +377,15 @@ char* ha_bufncpy(ha_buffer_t* buf, const char* src, size_t len) if(ha_buferr(buf)) return NULL; - /* Move up the block pointer if we're not joining strings */ - if(ha_buflen(buf) > 0 && *(buf->_rp - 1) != 0) - buf->_pp = buf->_rp; - /* Always add one for the terminating char */ buffer_bump(buf, len + 1); if(ha_buferr(buf)) return NULL; + if(!BUF_IN_JOIN(buf)) + BUF_NEW_BLOCK(buf); + memcpy(buf->_rp, src, len * sizeof(char)); buf->_rp += (len + 1); *(buf->_rp - 1) = 0; @@ -324,17 +402,16 @@ void* ha_bufmalloc(ha_buffer_t* buf, size_t sz) return NULL; /* TODO: Align memory on an appropriate boundary here */ - - /* We're not working with strings so always bump the pointer up */ - buf->_pp = buf->_rp; - buffer_bump(buf, sz); if(ha_buferr(buf)) return NULL; + BUF_NEW_BLOCK(buf); + ret = (void*)buf->_pp; buf->_rp += sz; - return (void*)buf->_pp; + buf->_pp = buf->_rp; + return ret; } void* ha_bufmemdup(ha_buffer_t* buf, const void* src, size_t bytes) @@ -390,6 +467,9 @@ char* ha_bufenc64(ha_buffer_t* buf, const void* source, size_t len) if(ha_buferr(buf)) return NULL; + if(!BUF_IN_JOIN(buf)) + BUF_NEW_BLOCK(buf); + while(2 < len) { input[0] = *src++; @@ -450,6 +530,7 @@ void* ha_bufdec64(ha_buffer_t* buf, const char* src, size_t bytes) int state = 0; int ch; char* pos; + void* ret; size_t done = 0; ASSERT(buf && src); @@ -457,6 +538,8 @@ void* ha_bufdec64(ha_buffer_t* buf, const char* src, size_t bytes) if(ha_buferr(buf)) return NULL; + BUF_NEW_BLOCK(buf); + if(bytes == 0) bytes = ~0; @@ -472,7 +555,7 @@ void* ha_bufdec64(ha_buffer_t* buf, const char* src, size_t bytes) if(pos == 0) /* A non-base64 character. */ break; - buffer_bump(buf, 3); + buffer_bump(buf, 4); if(ha_buferr(buf)) return; @@ -480,8 +563,7 @@ void* ha_bufdec64(ha_buffer_t* buf, const char* src, size_t bytes) switch(state) { case 0: - *(buf->_rp++) = (pos - BASE64C) << 2; - done++; + *(buf->_rp) = (pos - BASE64C) << 2; state = 1; break; @@ -505,18 +587,23 @@ void* ha_bufdec64(ha_buffer_t* buf, const char* src, size_t bytes) state = 0; break; }; - - /* TODO: Validate ending and return error if invalid somehow */ } + if(state != 3) + buf->_rp++; + + /* TODO: Validate ending and return error if invalid somehow */ + /* If we were asked for a specific amount of bytes, then return null */ if(bytes != ~0 && bytes != done) return NULL; - return buf->_pp; + ret = (void*)buf->_pp; + buf->_pp = buf->_rp; + return ret; } -static const char HEXC[] = "0123456789ABCDEF"; +static const char HEXC[] = "0123456789abcdef"; char* ha_bufenchex(ha_buffer_t* buf, const void* source, size_t len) { @@ -530,21 +617,18 @@ char* ha_bufenchex(ha_buffer_t* buf, const void* source, size_t len) if(ha_buferr(buf)) return NULL; + if(!BUF_IN_JOIN(buf)) + BUF_NEW_BLOCK(buf); + while(len > 0) { j = *(src) >> 4 & 0xf; - if(j <= 9) - *(buf->_rp++) = (j + '0'); - else - *(buf->_rp++) = (j + 'a' - 10); + *(buf->_rp++) = HEXC[j]; j = *(src++) & 0xf; - len--; + *(buf->_rp++) = HEXC[j]; - if(j <= 9) - *(buf->_rp++) = (j + '0'); - else - *(buf->_rp++) = (j + 'a' - 10); + len--; } *(buf->_rp++) = 0; @@ -553,10 +637,11 @@ char* ha_bufenchex(ha_buffer_t* buf, const void* source, size_t len) void* ha_bufdechex(ha_buffer_t* buf, const char* src, size_t bytes) { - unsigned short a; - unsigned short b; + unsigned short j; size_t done = 0; + int state = 0; char* pos; + void* ret; ASSERT(buf && src); @@ -573,29 +658,41 @@ void* ha_bufdechex(ha_buffer_t* buf, const char* src, size_t bytes) if(ha_buferr(buf)) return NULL; - while(src[0] && src[1] && done < bytes) + BUF_NEW_BLOCK(buf); + + while(src[0] && done < bytes) { /* Find the position */ - pos = strchr(HEXC, src[0]); + pos = strchr(HEXC, tolower(src[0])); if(pos == 0) break; - a = HEXC - pos; - - pos = strchr(HEXC, src[1]); - if(pos == 0); - break; + j = pos - HEXC; - b = HEXC - pos; + if(!state) + { + *(buf->_rp) = (j & 0xf) << 4; + state = 1; + } + else + { + *(buf->_rp++) |= (j & 0xf); + done++; + state = 0; + } - *(buf->_rp++) = ((a & 0xf) << 4) | (b & 0xf); - src += 2; - done++; + src++; } + /* All bytes have to come in pairs */ + if(state != 0) + return NULL; + /* If we were asked for a specific amount of bytes, then return null */ if(bytes != ~0 && bytes != done) return NULL; - return buf->_pp; + ret = (void*)buf->_pp; + buf->_pp = buf->_rp; + return ret; } -- cgit v1.2.3