- added request parameter to ha_message...

- combined ha_request and ha_response

22 files changed, 3777 insertions, 3771 deletions

diff --git a/common/buffer.c b/common/buffer.c
index 5a77922..07fa059 100644
--- a/common/buffer.c
+++ b/common/buffer.c
@@ -31,399 +31,399 @@
 
 typedef struct ha_buffer_internal
 {
-  char* end;
-  struct ha_buffer_internal* next;
+    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;
-
-  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
-  {
-    void* beg = INTERNAL_DATA(intl);
-    intl->end = ((char*)(intl) + allocated);
-    intl->next = NULL;
+    int allocated;
+    internal_t* intl;
+
+    ASSERT(buf && count);
+
+    if(ha_buferr(buf))
+        return;
+
+    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(NULL, LOG_CRIT, "out of memory");
+        buf->_dt = NULL;
+        buf->_pp = buf->_rp = NULL;
+        return;
+    }
+    else
+    {
+        void* beg = INTERNAL_DATA(intl);
+        intl->end = ((char*)(intl) + allocated);
+        intl->next = NULL;
 
 #ifdef _DEBUG
-    FILL_BETWEEN(beg, intl->end, 0xCD);
+        FILL_BETWEEN(beg, intl->end, 0xCD);
 #endif
 
-    if(BUF_IN_JOIN(buf))
-    {
-      int diff = buf->_rp - buf->_pp;
+        if(BUF_IN_JOIN(buf))
+        {
+            int diff = buf->_rp - buf->_pp;
 
-      /* Always true in a join */
-      ASSERT(buf->_pp < buf->_rp);
+            /* Always true in a join */
+            ASSERT(buf->_pp < buf->_rp);
 
-      /* Copy the memory and blank out old */
-      memcpy(beg, buf->_pp, diff);
+            /* Copy the memory and blank out old */
+            memcpy(beg, buf->_pp, diff);
 #ifdef _DEBUG
-      FILL_BETWEEN(buf->_pp, buf->_rp, 0xDD);
+            FILL_BETWEEN(buf->_pp, buf->_rp, 0xDD);
 #endif
 
-      buf->_pp = beg;
-      buf->_rp = buf->_pp + diff;
-    }
-    else
-    {
-      buf->_rp = buf->_pp = INTERNAL_DATA(intl);
-    }
+            buf->_pp = beg;
+            buf->_rp = buf->_pp + diff;
+        }
+        else
+        {
+            buf->_rp = buf->_pp = INTERNAL_DATA(intl);
+        }
 
-    buf->_dt->next = intl;
-    buf->_dt = intl;
-  }
+        buf->_dt->next = intl;
+        buf->_dt = intl;
+    }
 }
 
 void ha_bufinit(ha_buffer_t* buf)
 {
-  ASSERT(buf);
-  memset(buf, 0, sizeof(*buf));
+    ASSERT(buf);
+    memset(buf, 0, sizeof(*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;
+    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);
+        FILL_BETWEEN(INTERNAL_DATA(buf->_ft), buf->_ft->end, 0xCD);
 #endif
 
-    ha_bufreset(buf);
-  }
+        ha_bufreset(buf);
+    }
 }
 
 void ha_bufreset(ha_buffer_t* buf)
 {
 #ifdef _DEBUG
-  internal_t* intl;
+    internal_t* intl;
 #endif
 
-  ASSERT(buf);
-  ASSERT(buf->_ft);
+    ASSERT(buf);
+    ASSERT(buf->_ft);
 
 #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);
+    /* 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->_dt = buf->_ft;
-  buf->_rp = buf->_pp = (char*)INTERNAL_DATA(buf->_ft);
+    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;
+    internal_t* intl;
+    internal_t* next;
 
-  ASSERT(buf);
+    ASSERT(buf);
 
-  /* 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);
-  }
+    /* 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->_ft = buf->_dt = NULL;
-  buf->_rp = buf->_pp = NULL;
+    buf->_ft = buf->_dt = NULL;
+    buf->_rp = buf->_pp = NULL;
 }
 
 
 int ha_bufreadline(int fd, ha_buffer_t* buf)
 {
-  int l;
-
-  ASSERT(buf);
-  ASSERT(fd != -1);
+    int l;
 
-  if(ha_buferr(buf))
-    return 0;
+    ASSERT(buf);
+    ASSERT(fd != -1);
 
-  for(;;)
-  {
-    buffer_bump(buf, 1);
-    l = read(fd, (void*)buf->_rp, sizeof(char));
-
-    /* We got a character */
-    if(l == 1)
-    {
-      /* Skip junky CRLFs */
-      if(*(buf->_rp) == '\r')
-      {
-        *(buf->_rp) = ' ';
-        continue;
-      }
-
-      /* End of line */
-      else if(*(buf->_rp) == '\n')
-      {
-        buf->_rp++;
-        break;
-      }
-
-      /* All other characters */
-      else
-      {
-        buf->_rp++;
-      }
-    }
-
-    /* If it's the end of file then return that */
-    else if(l == 0)
-      return 0;
-
-    /* Transient errors */
-    else if(l == -1 && errno == EAGAIN)
-      continue;
+    if(ha_buferr(buf))
+        return 0;
 
-    /* Fatal errors */
-    else if(l == -1)
+    for(;;)
     {
-      if(errno != EINTR)
-        ha_message(LOG_ERR, "couldn't read data");
-
-      return 0;
+        buffer_bump(buf, 1);
+        l = read(fd, (void*)buf->_rp, sizeof(char));
+
+        /* We got a character */
+        if(l == 1)
+        {
+            /* Skip junky CRLFs */
+            if(*(buf->_rp) == '\r')
+            {
+                *(buf->_rp) = ' ';
+                continue;
+            }
+
+            /* End of line */
+            else if(*(buf->_rp) == '\n')
+            {
+                buf->_rp++;
+                break;
+            }
+
+            /* All other characters */
+            else
+            {
+                buf->_rp++;
+            }
+        }
+
+        /* If it's the end of file then return that */
+        else if(l == 0)
+            return 0;
+
+        /* Transient errors */
+        else if(l == -1 && errno == EAGAIN)
+            continue;
+
+        /* Fatal errors */
+        else if(l == -1)
+        {
+            if(errno != EINTR)
+                ha_message(NULL, LOG_ERR, "couldn't read data");
+
+            return 0;
+        }
     }
-  }
 
-  return 1;
+    return 1;
 }
 
 char* ha_bufparseword(ha_buffer_t* buf, const char* delims)
 {
-  char* word = NULL;
+    char* word = NULL;
 
-  ASSERT(buf && delims);
+    ASSERT(buf && delims);
 
-  if(ha_buferr(buf))
-    return NULL;
-
-  /* Knock out any previous delims */
-  while(buf->_pp < buf->_rp && strchr(delims, *(buf->_pp)))
-    buf->_pp++;
+    if(ha_buferr(buf))
+        return NULL;
 
-  /* If at end of buffer or end of line return null */
-  if(buf->_pp == buf->_rp || *(buf->_pp) == '\n')
-    return NULL;
+    /* Knock out any previous delims */
+    while(buf->_pp < buf->_rp && strchr(delims, *(buf->_pp)))
+        buf->_pp++;
 
-  /* We do this before we stash away a pointer */
-  buffer_bump(buf, 1);
+    /* If at end of buffer or end of line return null */
+    if(buf->_pp == buf->_rp || *(buf->_pp) == '\n')
+        return NULL;
 
-  word = buf->_pp;
+    /* We do this before we stash away a pointer */
+    buffer_bump(buf, 1);
 
-  while(!strchr(delims, *(buf->_pp)))
-  {
-    buf->_pp++;
+    word = buf->_pp;
 
-    /* At the end of the buffer */
-    if(buf->_pp == buf->_rp)
+    while(!strchr(delims, *(buf->_pp)))
     {
-      *(buf->_rp) = 0;
-      buf->_rp++;
-      break;
+        buf->_pp++;
+
+        /* At the end of the buffer */
+        if(buf->_pp == buf->_rp)
+        {
+            *(buf->_rp) = 0;
+            buf->_rp++;
+            break;
+        }
+
+        /* At the end of a line */
+        else if(*(buf->_pp) == '\n')
+            break;
     }
 
-    /* At the end of a line */
-    else if(*(buf->_pp) == '\n')
-      break;
-  }
-
-  /* Now null terminate what we found */
-  *(buf->_pp) = 0;
-  buf->_pp++;
+    /* Now null terminate what we found */
+    *(buf->_pp) = 0;
+    buf->_pp++;
 
-  /* We don't return empty strings */
-  if(word[0] == 0)
-    return NULL;
+    /* We don't return empty strings */
+    if(word[0] == 0)
+        return NULL;
 
-  return word;
+    return word;
 }
 
 char* ha_bufparseline(ha_buffer_t* buf, int trim)
 {
-  char* t;
-  char* line = NULL;
+    char* t;
+    char* line = NULL;
 
-  ASSERT(buf);
+    ASSERT(buf);
 
-  if(ha_buferr(buf))
-    return NULL;
+    if(ha_buferr(buf))
+        return NULL;
 
-  if(trim)
-  {
-    /* Knock out any previous whitespace */
-    while(buf->_pp < buf->_rp && isblank(*(buf->_pp)))
-      buf->_pp++;
-  }
+    if(trim)
+    {
+        /* Knock out any previous whitespace */
+        while(buf->_pp < buf->_rp && isblank(*(buf->_pp)))
+            buf->_pp++;
+    }
 
-  if(buf->_pp == buf->_rp)
-    return NULL;
+    if(buf->_pp == buf->_rp)
+        return NULL;
 
-  /* We do this before we stash away a pointer */
-  buffer_bump(buf, 1);
+    /* We do this before we stash away a pointer */
+    buffer_bump(buf, 1);
 
-  line = buf->_pp;
+    line = buf->_pp;
 
-  t = (char*)memchr(buf->_pp, '\n', ha_buflen(buf));
-  if(t == NULL)
-  {
-    t = (buf->_rp);
-    buf->_rp++;
-  }
+    t = (char*)memchr(buf->_pp, '\n', ha_buflen(buf));
+    if(t == NULL)
+    {
+        t = (buf->_rp);
+        buf->_rp++;
+    }
 
-  *t = 0;
-  buf->_pp = t + 1;
+    *t = 0;
+    buf->_pp = t + 1;
 
-  if(trim)
-    line = trim_space(line);
+    if(trim)
+        line = trim_space(line);
 
-  /* We don't return empty strings */
-  if(line[0] == 0)
-    return NULL;
+    /* We don't return empty strings */
+    if(line[0] == 0)
+        return NULL;
 
-  return line;
+    return line;
 }
 
 char* ha_bufmcat(ha_buffer_t* buf, ...)
 {
-  const char* str;
-  va_list ap;
+    const char* str;
+    va_list ap;
 
-  ASSERT(buf);
+    ASSERT(buf);
 
-  va_start(ap, buf);
+    va_start(ap, buf);
 
-  if(ha_buferr(buf))
-    return NULL;
+    if(ha_buferr(buf))
+        return NULL;
 
-  if(!BUF_IN_JOIN(buf))
-    BUF_NEW_BLOCK(buf);
+    if(!BUF_IN_JOIN(buf))
+        BUF_NEW_BLOCK(buf);
 
-  while((str = va_arg(ap, char*)) != NULL)
-  {
-    int len = strlen(str);
+    while((str = va_arg(ap, char*)) != NULL)
+    {
+        int len = strlen(str);
 
-    /* Always add one for the terminating char */
-    buffer_bump(buf, len + 1);
+        /* Always add one for the terminating char */
+        buffer_bump(buf, len + 1);
 
-    if(ha_buferr(buf))
-      return NULL;
+        if(ha_buferr(buf))
+            return NULL;
 
-    /* _rp always points to the next write point */
-    strcpy(buf->_rp, str);
-    buf->_rp += len;
-  }
+        /* _rp always points to the next write point */
+        strcpy(buf->_rp, str);
+        buf->_rp += len;
+    }
 
-  buf->_rp++;
-  return buf->_pp;
+    buf->_rp++;
+    return buf->_pp;
 }
 
 char* ha_bufcpy(ha_buffer_t* buf, const char* src)
 {
-  size_t len;
+    size_t len;
 
-  ASSERT(buf && src);
+    ASSERT(buf && src);
 
-  len = strlen(src);
-  return ha_bufncpy(buf, src, len);
+    len = strlen(src);
+    return ha_bufncpy(buf, src, len);
 }
 
 char* ha_bufncpy(ha_buffer_t* buf, const char* src, size_t len)
 {
-  ASSERT(buf && src);
+    ASSERT(buf && src);
 
-  if(ha_buferr(buf))
-    return NULL;
+    if(ha_buferr(buf))
+        return NULL;
 
-  /* Always add one for the terminating char */
-  buffer_bump(buf, len + 1);
+    /* Always add one for the terminating char */
+    buffer_bump(buf, len + 1);
 
-  if(ha_buferr(buf))
-    return NULL;
+    if(ha_buferr(buf))
+        return NULL;
 
-  if(!BUF_IN_JOIN(buf))
-    BUF_NEW_BLOCK(buf);
+    if(!BUF_IN_JOIN(buf))
+        BUF_NEW_BLOCK(buf);
 
-  memcpy(buf->_rp, src, len * sizeof(char));
-  buf->_rp += (len + 1);
-  *(buf->_rp - 1) = 0;
-  return buf->_pp;
+    memcpy(buf->_rp, src, len * sizeof(char));
+    buf->_rp += (len + 1);
+    *(buf->_rp - 1) = 0;
+    return buf->_pp;
 }
 
 void* ha_bufmalloc(ha_buffer_t* buf, size_t sz)
 {
-  void* ret;
+    void* ret;
 
-  ASSERT(buf && sz);
+    ASSERT(buf && sz);
 
-  if(ha_buferr(buf))
-    return NULL;
+    if(ha_buferr(buf))
+        return NULL;
 
-  /* TODO: Align memory on an appropriate boundary here */
-  buffer_bump(buf, sz);
+    /* TODO: Align memory on an appropriate boundary here */
+    buffer_bump(buf, sz);
 
-  if(ha_buferr(buf))
-    return NULL;
+    if(ha_buferr(buf))
+        return NULL;
 
-  BUF_NEW_BLOCK(buf);
-  ret = (void*)buf->_pp;
-  buf->_rp += sz;
-  buf->_pp = buf->_rp;
-  return ret;
+    BUF_NEW_BLOCK(buf);
+    ret = (void*)buf->_pp;
+    buf->_rp += sz;
+    buf->_pp = buf->_rp;
+    return ret;
 }
 
 void* ha_bufmemdup(ha_buffer_t* buf, const void* src, size_t bytes)
 {
-  void* mem;
+    void* mem;
 
-  ASSERT(buf && src && bytes);
+    ASSERT(buf && src && bytes);
 
-  if((mem = ha_bufmalloc(buf, bytes)) != NULL)
-    memcpy(mem, src, bytes);
+    if((mem = ha_bufmalloc(buf, bytes)) != NULL)
+        memcpy(mem, src, bytes);
 
-  return mem;
+    return mem;
 }
 
 /*
@@ -457,251 +457,251 @@ static const char PAD64C = '=';
 
 char* ha_bufenc64(ha_buffer_t* buf, const void* source, size_t len)
 {
-  unsigned char input[3];
-  unsigned char output[4];
-  unsigned char* src = (unsigned char*)source;
-  size_t i;
+    unsigned char input[3];
+    unsigned char output[4];
+    unsigned char* src = (unsigned char*)source;
+    size_t i;
 
-  ASSERT(buf && source && len);
-
-  if(ha_buferr(buf))
-    return NULL;
-
-  if(!BUF_IN_JOIN(buf))
-    BUF_NEW_BLOCK(buf);
-
-  while(2 < len)
-  {
-    input[0] = *src++;
-    input[1] = *src++;
-    input[2] = *src++;
-    len -= 3;
-
-    output[0] = input[0] >> 2;
-    output[1] = ((input[0] & 0x03) << 4) + (input[1] >> 4);
-    output[2] = ((input[1] & 0x0f) << 2) + (input[2] >> 6);
-    output[3] = input[2] & 0x3f;
-
-    /* This also accounts for the null terminator */
-    buffer_bump(buf, 5);
+    ASSERT(buf && source && len);
 
     if(ha_buferr(buf))
-      return NULL;
-
-    *(buf->_rp++) = BASE64C[output[0]];
-    *(buf->_rp++) = BASE64C[output[1]];
-    *(buf->_rp++) = BASE64C[output[2]];
-    *(buf->_rp++) = BASE64C[output[3]];
-  }
+        return NULL;
 
-  /* Now we worry about padding. */
-  if(0 != len)
-   {
-    /* Get what's left. */
-    input[0] = input[1] = input[2] = '\0';
-    for(i = 0; i < len; i++)
-      input[i] = *src++;
+    if(!BUF_IN_JOIN(buf))
+        BUF_NEW_BLOCK(buf);
 
-    output[0] = input[0] >> 2;
-    output[1] = ((input[0] & 0x03) << 4) + (input[1] >> 4);
-    output[2] = ((input[1] & 0x0f) << 2) + (input[2] >> 6);
-
-    /* This also accounts for the null terminator */
-    buffer_bump(buf, 5);
-
-    if(ha_buferr(buf))
-      return NULL;
+    while(2 < len)
+    {
+        input[0] = *src++;
+        input[1] = *src++;
+        input[2] = *src++;
+        len -= 3;
+
+        output[0] = input[0] >> 2;
+        output[1] = ((input[0] & 0x03) << 4) + (input[1] >> 4);
+        output[2] = ((input[1] & 0x0f) << 2) + (input[2] >> 6);
+        output[3] = input[2] & 0x3f;
+
+        /* This also accounts for the null terminator */
+        buffer_bump(buf, 5);
+
+        if(ha_buferr(buf))
+            return NULL;
+
+        *(buf->_rp++) = BASE64C[output[0]];
+        *(buf->_rp++) = BASE64C[output[1]];
+        *(buf->_rp++) = BASE64C[output[2]];
+        *(buf->_rp++) = BASE64C[output[3]];
+    }
 
-    *(buf->_rp++) = BASE64C[output[0]];
-    *(buf->_rp++) = BASE64C[output[1]];
-    if(len == 1)
-      *(buf->_rp++) = PAD64C;
-    else
-      *(buf->_rp++) = BASE64C[output[2]];
-    *(buf->_rp++) = PAD64C;
-  }
+    /* Now we worry about padding. */
+    if(0 != len)
+    {
+        /* Get what's left. */
+        input[0] = input[1] = input[2] = '\0';
+        for(i = 0; i < len; i++)
+            input[i] = *src++;
+
+        output[0] = input[0] >> 2;
+        output[1] = ((input[0] & 0x03) << 4) + (input[1] >> 4);
+        output[2] = ((input[1] & 0x0f) << 2) + (input[2] >> 6);
+
+        /* This also accounts for the null terminator */
+        buffer_bump(buf, 5);
+
+        if(ha_buferr(buf))
+            return NULL;
+
+        *(buf->_rp++) = BASE64C[output[0]];
+        *(buf->_rp++) = BASE64C[output[1]];
+        if(len == 1)
+            *(buf->_rp++) = PAD64C;
+        else
+            *(buf->_rp++) = BASE64C[output[2]];
+        *(buf->_rp++) = PAD64C;
+    }
 
-  *(buf->_rp++) = '\0';
-  return buf->_pp;
+    *(buf->_rp++) = '\0';
+    return buf->_pp;
 }
 
 void* ha_bufdec64(ha_buffer_t* buf, const char* src, size_t* bytes)
 {
-  int state = 0;
-  int ch;
-  char* pos;
-  void* ret;
-  size_t todo = 0;
-  size_t done = 0;
-
-  ASSERT(buf && src);
-
-  if(ha_buferr(buf))
-    return NULL;
-
-  BUF_NEW_BLOCK(buf);
+    int state = 0;
+    int ch;
+    char* pos;
+    void* ret;
+    size_t todo = 0;
+    size_t done = 0;
 
-  if(!bytes || *bytes == 0)
-    todo = ~0;
-  else
-    todo = *bytes;
+    ASSERT(buf && src);
 
-  while((ch = *src++) != '\0' && done < todo)
-  {
-    if(isspace(ch))        /* Skip whitespace anywhere. */
-      continue;
-
-    if(ch == PAD64C)
-      break;
-
-    pos = strchr(BASE64C, ch);
-    if(pos == 0)           /* A non-base64 character. */
-      break;
+    if(ha_buferr(buf))
+        return NULL;
 
-    buffer_bump(buf, 4);
+    BUF_NEW_BLOCK(buf);
 
-    if(ha_buferr(buf))
-      return NULL;
+    if(!bytes || *bytes == 0)
+        todo = ~0;
+    else
+        todo = *bytes;
 
-    switch(state)
+    while((ch = *src++) != '\0' && done < todo)
     {
-    case 0:
-      *(buf->_rp) = (pos - BASE64C) << 2;
-      state = 1;
-      break;
-
-    case 1:
-      *(buf->_rp++) |= (pos - BASE64C) >> 4;
-      done++;
-      *(buf->_rp) = ((pos - BASE64C) & 0x0f) << 4;
-      state = 2;
-      break;
-
-    case 2:
-      *(buf->_rp++) |= (pos - BASE64C) >> 2;
-      done++;
-      *(buf->_rp) = ((pos - BASE64C) & 0x03) << 6;
-      state = 3;
-      break;
-
-    case 3:
-      *(buf->_rp++) |= (pos - BASE64C);
-      done++;
-      state = 0;
-      break;
-    };
-  }
-
-  if(state != 3)
-    buf->_rp++;
+        if(isspace(ch))        /* Skip whitespace anywhere. */
+            continue;
+
+        if(ch == PAD64C)
+            break;
+
+        pos = strchr(BASE64C, ch);
+        if(pos == 0)           /* A non-base64 character. */
+            break;
+
+        buffer_bump(buf, 4);
+
+        if(ha_buferr(buf))
+            return NULL;
+
+        switch(state)
+        {
+        case 0:
+            *(buf->_rp) = (pos - BASE64C) << 2;
+            state = 1;
+            break;
+
+        case 1:
+            *(buf->_rp++) |= (pos - BASE64C) >> 4;
+            done++;
+            *(buf->_rp) = ((pos - BASE64C) & 0x0f) << 4;
+            state = 2;
+            break;
+
+        case 2:
+            *(buf->_rp++) |= (pos - BASE64C) >> 2;
+            done++;
+            *(buf->_rp) = ((pos - BASE64C) & 0x03) << 6;
+            state = 3;
+            break;
+
+        case 3:
+            *(buf->_rp++) |= (pos - BASE64C);
+            done++;
+            state = 0;
+            break;
+        };
+    }
+
+    if(state != 3)
+        buf->_rp++;
 
-  /* TODO: Validate ending and return error if invalid somehow */
+    /* TODO: Validate ending and return error if invalid somehow */
 
-  /* We always null terminate anyway */
-  *(buf->_rp++) = 0;
+    /* We always null terminate anyway */
+    *(buf->_rp++) = 0;
 
-  if(bytes)
-    *bytes = done;
+    if(bytes)
+        *bytes = done;
 
-  ret = (void*)buf->_pp;
-  buf->_pp = buf->_rp;
-  return ret;
+    ret = (void*)buf->_pp;
+    buf->_pp = buf->_rp;
+    return ret;
 }
 
 static const char HEXC[] = "0123456789abcdef";
 
 char* ha_bufenchex(ha_buffer_t* buf, const void* source, size_t len)
 {
-  unsigned char* src = (unsigned char*)source;
-  unsigned char j;
+    unsigned char* src = (unsigned char*)source;
+    unsigned char j;
 
-  ASSERT(buf && source && len);
+    ASSERT(buf && source && len);
 
-  buffer_bump(buf, (len * 2) + 1);
+    buffer_bump(buf, (len * 2) + 1);
 
-  if(ha_buferr(buf))
-    return NULL;
+    if(ha_buferr(buf))
+        return NULL;
 
-  if(!BUF_IN_JOIN(buf))
-    BUF_NEW_BLOCK(buf);
+    if(!BUF_IN_JOIN(buf))
+        BUF_NEW_BLOCK(buf);
 
-  while(len > 0)
-  {
-    j = *(src) >> 4 & 0xf;
-    *(buf->_rp++) = HEXC[j];
+    while(len > 0)
+    {
+        j = *(src) >> 4 & 0xf;
+        *(buf->_rp++) = HEXC[j];
 
-    j = *(src++) & 0xf;
-    *(buf->_rp++) = HEXC[j];
+        j = *(src++) & 0xf;
+        *(buf->_rp++) = HEXC[j];
 
-    len--;
-  }
+        len--;
+    }
 
-  *(buf->_rp++) = 0;
-  return buf->_pp;
+    *(buf->_rp++) = 0;
+    return buf->_pp;
 }
 
 void* ha_bufdechex(ha_buffer_t* buf, const char* src, size_t* bytes)
 {
-  unsigned short j;
-  int state = 0;
-  char* pos;
-  void* ret;
-  size_t done = 0;
-  size_t todo = 0;
-
-  ASSERT(buf && src);
-
-  if(bytes && *bytes != 0)
-  {
-    buffer_bump(buf, *bytes + 1);
-    todo = *bytes;
-  }
-  else
-  {
-    todo = ~0;
-    buffer_bump(buf, (strlen(src) / 2) + 1);
-  }
-
-  if(ha_buferr(buf))
-    return NULL;
-
-  BUF_NEW_BLOCK(buf);
-
-  while(src[0] && done < todo)
-  {
-    /* Find the position */
-    pos = strchr(HEXC, tolower(src[0]));
-    if(pos == 0)
-      break;
-
-    j = pos - HEXC;
-
-    if(!state)
+    unsigned short j;
+    int state = 0;
+    char* pos;
+    void* ret;
+    size_t done = 0;
+    size_t todo = 0;
+
+    ASSERT(buf && src);
+
+    if(bytes && *bytes != 0)
     {
-      *(buf->_rp) = (j & 0xf) << 4;
-      state = 1;
+        buffer_bump(buf, *bytes + 1);
+        todo = *bytes;
     }
     else
     {
-      *(buf->_rp++) |= (j & 0xf);
-      done++;
-      state = 0;
+        todo = ~0;
+        buffer_bump(buf, (strlen(src) / 2) + 1);
     }
 
-    src++;
-  }
+    if(ha_buferr(buf))
+        return NULL;
+
+    BUF_NEW_BLOCK(buf);
+
+    while(src[0] && done < todo)
+    {
+        /* Find the position */
+        pos = strchr(HEXC, tolower(src[0]));
+        if(pos == 0)
+        break;
+
+        j = pos - HEXC;
+
+        if(!state)
+        {
+            *(buf->_rp) = (j & 0xf) << 4;
+            state = 1;
+        }
+        else
+        {
+            *(buf->_rp++) |= (j & 0xf);
+            done++;
+            state = 0;
+        }
+
+        src++;
+    }
 
-  /* We always null terminate anyway */
-  *(buf->_rp++) = 0;
+    /* We always null terminate anyway */
+    *(buf->_rp++) = 0;
 
-  /* All bytes have to come in pairs */
-  if(state != 0)
-    return NULL;
+    /* All bytes have to come in pairs */
+    if(state != 0)
+        return NULL;
 
-  if(bytes)
-    *bytes = done;
+    if(bytes)
+        *bytes = done;
 
-  ret = (void*)buf->_pp;
-  buf->_pp = buf->_rp;
-  return ret;
+    ret = (void*)buf->_pp;
+    buf->_pp = buf->_rp;
+    return ret;
 }
diff --git a/common/compat.c b/common/compat.c
index 5618ee5..daddbd2 100644
--- a/common/compat.c
+++ b/common/compat.c
@@ -19,25 +19,25 @@ void* reallocf(void* ptr, size_t size)
 #ifndef HAVE_STRLWR
 char* strlwr(char* s)
 {
-  char* t = s;
-  while(*t)
-  {
-    *t = tolower(*t);
-    t++;
-  }
-  return s;
+    char* t = s;
+    while(*t)
+    {
+        *t = tolower(*t);
+        t++;
+    }
+    return s;
 }
 #endif
 
 #ifndef HAVE_STRUPR
 char* strupr(char* s)
 {
-  char* t = s;
-  while(*t)
-  {
-    *t = toupper(*t);
-    t++;
-  }
-  return s;
+    char* t = s;
+    while(*t)
+    {
+        *t = toupper(*t);
+        t++;
+    }
+    return s;
 }
 #endif
diff --git a/common/compat.h b/common/compat.h
index bb7311c..c7f86cc 100644
--- a/common/compat.h
+++ b/common/compat.h
@@ -10,7 +10,7 @@
 #include <sys/types.h>
 
 #ifndef HAVE_STDARG_H
-#error ERROR: Must have a working stdarg.h header
+#   error ERROR: Must have a working stdarg.h header
 #else
 #include <stdarg.h>
 #endif
@@ -23,13 +23,13 @@ void* reallocf(void* p, size_t sz);
 
 /* TODO: Move this logic to configure */
 #if HAVE_ERR_MUTEX == 1
-# define HA_MUTEX_TYPE PTHREAD_MUTEX_ERRORCHECK_NP
+#   define HA_MUTEX_TYPE PTHREAD_MUTEX_ERRORCHECK_NP
 #else
-# if HAVE_ERR_MUTEX == 2
-#   define HA_MUTEX_TYPE PTHREAD_MUTEX_ERRORCHECK
-# else
-#   error "Need error checking mutex functionality"
-# endif
+#   if HAVE_ERR_MUTEX == 2
+#       define HA_MUTEX_TYPE PTHREAD_MUTEX_ERRORCHECK
+#   else
+#       error "Need error checking mutex functionality"
+#   endif
 #endif
 
 #ifndef HAVE_STRLWR
diff --git a/common/hash.c b/common/hash.c
index 5f3308c..3ff3982 100644
--- a/common/hash.c
+++ b/common/hash.c
@@ -9,7 +9,7 @@
  * 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
+ *         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,
@@ -27,9 +27,9 @@
 #endif
 
 #ifdef HSH_COPYKEYS
-  #define KEY_DATA(he) (void*)(((unsigned char*)(he)) + sizeof(*(he)))
+    #define KEY_DATA(he) (void*)(((unsigned char*)(he)) + sizeof(*(he)))
 #else
-  #define KEY_DATA(he)  ((he)->key)
+    #define KEY_DATA(he)    ((he)->key)
 #endif
 
 /*
@@ -45,15 +45,15 @@ typedef struct hsh_entry_t hsh_entry_t;
 
 struct hsh_entry_t
 {
-  hsh_entry_t* next;
-  unsigned int hash;
+    hsh_entry_t* next;
+    unsigned int hash;
 #ifndef HSH_COPYKEYS
-  const void* key;
-  size_t klen;
+    const void* key;
+    size_t klen;
 #endif
-  const void* val;
+    const void* val;
 #ifdef HSH_TIMESTAMP
-  time_t stamp;
+    time_t stamp;
 #endif
 };
 
@@ -66,10 +66,10 @@ struct hsh_entry_t
  */
 struct hsh_index_t
 {
-  hsh_t* ht;
-  hsh_entry_t* ths;
-  hsh_entry_t* next;
-  unsigned int index;
+    hsh_t* ht;
+    hsh_entry_t* ths;
+    hsh_entry_t* next;
+    unsigned int index;
 };
 
 /*
@@ -81,15 +81,15 @@ struct hsh_index_t
  */
 struct hsh_t
 {
-  hsh_entry_t** array;
-  hsh_index_t iterator;  /* For hsh_first(...) */
-  unsigned int count;
-  unsigned int max;
+    hsh_entry_t** array;
+    hsh_index_t iterator;    /* For hsh_first(...) */
+    unsigned int count;
+    unsigned int max;
 #ifdef HSH_COPYKEYS
-  unsigned int klen;
+    unsigned int klen;
 #endif
 #ifdef HSH_CALLBACKS
-  hsh_table_calls_t calls;
+    hsh_table_calls_t calls;
 #endif
 };
 
@@ -106,47 +106,47 @@ static hsh_memory_calls_t* g_memory_calls = NULL;
 
 static void* int_malloc(size_t len)
 {
-  if(g_memory_calls)
-    return (g_memory_calls->f_alloc)(g_memory_calls->arg, len);
-  else
-    return malloc(len);
+    if(g_memory_calls)
+        return (g_memory_calls->f_alloc)(g_memory_calls->arg, len);
+    else
+        return malloc(len);
 }
 
 static void* int_calloc(size_t len)
 {
-  void* p = int_malloc(len);
-  memset(p, 0, len);
-  return p;
+    void* p = int_malloc(len);
+    memset(p, 0, len);
+    return p;
 }
 
 static void int_free(void* ptr)
 {
-  if(g_memory_calls)
-  {
-    /* We allow for gc type memory allocation with a null free */
-    if(g_memory_calls->f_free)
-      (g_memory_calls->f_free)(g_memory_calls->arg, ptr);
-  }
-  else
-    free(ptr);
+    if(g_memory_calls)
+    {
+        /* We allow for gc type memory allocation with a null free */
+        if(g_memory_calls->f_free)
+            (g_memory_calls->f_free)(g_memory_calls->arg, ptr);
+    }
+    else
+        free(ptr);
 }
 
 void hsh_set_memory_calls(hsh_memory_calls_t* hmc)
 {
-  if(hmc == NULL)
-  {
-    g_memory_calls = NULL;
-  }
-  else
-  {
-    memcpy(&g_memory_calls_cpy, hmc, sizeof(g_memory_calls_cpy));
-    g_memory_calls = &g_memory_calls_cpy;
-  }
+    if(hmc == NULL)
+    {
+        g_memory_calls = NULL;
+    }
+    else
+    {
+        memcpy(&g_memory_calls_cpy, hmc, sizeof(g_memory_calls_cpy));
+        g_memory_calls = &g_memory_calls_cpy;
+    }
 }
 
 void hsh_set_table_calls(hsh_t* ht, hsh_table_calls_t* htc)
 {
-  memcpy(&(ht->calls), htc, sizeof(ht->calls));
+    memcpy(&(ht->calls), htc, sizeof(ht->calls));
 }
 
 #else
@@ -163,7 +163,7 @@ void hsh_set_table_calls(hsh_t* ht, hsh_table_calls_t* htc)
 
 static hsh_entry_t** alloc_array(hsh_t* ht, unsigned int max)
 {
-  return int_calloc(sizeof(*(ht->array)) * (max + 1));
+    return int_calloc(sizeof(*(ht->array)) * (max + 1));
 }
 
 #ifdef HSH_COPYKEYS
@@ -172,41 +172,41 @@ hsh_t* hsh_create(size_t klen)
 hsh_t* hsh_create()
 #endif
 {
-  hsh_t* ht = int_malloc(sizeof(hsh_t));
-  if(ht)
-  {
-    ht->count = 0;
-    ht->max = INITIAL_MAX;
-    ht->array = alloc_array(ht, ht->max);
+    hsh_t* ht = int_malloc(sizeof(hsh_t));
+    if(ht)
+    {
+        ht->count = 0;
+        ht->max = INITIAL_MAX;
+        ht->array = alloc_array(ht, ht->max);
 #ifdef HSH_COPYKEYS
-    ht->klen = klen;
+        ht->klen = klen;
 #endif
-    if(!ht->array)
-    {
-      int_free(ht);
-      return NULL;
+        if(!ht->array)
+        {
+            int_free(ht);
+            return NULL;
+        }
     }
-  }
-  return ht;
+    return ht;
 }
 
 void hsh_free(hsh_t* ht)
 {
-  hsh_index_t* hi;
+    hsh_index_t* hi;
 
-  for(hi = hsh_first(ht); hi; hi = hsh_next(hi))
-  {
+    for(hi = hsh_first(ht); hi; hi = hsh_next(hi))
+    {
 #ifdef HSH_CALLBACKS
-    if(hi->ths->val && ht->calls.f_freeval)
-      (ht->calls.f_freeval)(ht->calls.arg, (void*)hi->ths->val);
+        if(hi->ths->val && ht->calls.f_freeval)
+            (ht->calls.f_freeval)(ht->calls.arg, (void*)hi->ths->val);
 #endif
-    int_free(hi->ths);
-  }
+        int_free(hi->ths);
+    }
 
-  if(ht->array)
-    int_free(ht->array);
+    if(ht->array)
+        int_free(ht->array);
 
-  int_free(ht);
+    int_free(ht);
 }
 
 /*
@@ -215,27 +215,27 @@ void hsh_free(hsh_t* ht)
 
 hsh_index_t* hsh_next(hsh_index_t* hi)
 {
-  hi->ths = hi->next;
-  while(!hi->ths)
-  {
-    if(hi->index > hi->ht->max)
-      return NULL;
-
-    hi->ths = hi->ht->array[hi->index++];
-  }
-  hi->next = hi->ths->next;
-  return hi;
+    hi->ths = hi->next;
+    while(!hi->ths)
+    {
+        if(hi->index > hi->ht->max)
+            return NULL;
+
+        hi->ths = hi->ht->array[hi->index++];
+    }
+    hi->next = hi->ths->next;
+    return hi;
 }
 
 hsh_index_t* hsh_first(hsh_t* ht)
 {
-  hsh_index_t* hi = &ht->iterator;
+    hsh_index_t* hi = &ht->iterator;
 
-  hi->ht = ht;
-  hi->index = 0;
-  hi->ths = NULL;
-  hi->next = NULL;
-  return hsh_next(hi);
+    hi->ht = ht;
+    hi->index = 0;
+    hi->ths = NULL;
+    hi->next = NULL;
+    return hsh_next(hi);
 }
 
 #ifdef HSH_COPYKEYS
@@ -244,15 +244,15 @@ void* hsh_this(hsh_index_t* hi, const void** key)
 void* hsh_this(hsh_index_t* hi, const void** key, size_t* klen)
 #endif
 {
-  if(key)
-    *key = KEY_DATA(hi->ths);
+    if(key)
+        *key = KEY_DATA(hi->ths);
 
 #ifndef HSH_COPYKEYS
-  if(klen)
-    *klen = hi->ths->klen;
+    if(klen)
+        *klen = hi->ths->klen;
 #endif
 
-  return (void*)hi->ths->val;
+    return (void*)hi->ths->val;
 }
 
 
@@ -262,29 +262,29 @@ void* hsh_this(hsh_index_t* hi, const void** key, size_t* klen)
 
 static int expand_array(hsh_t* ht)
 {
-  hsh_index_t* hi;
-  hsh_entry_t** new_array;
-  unsigned int new_max;
+    hsh_index_t* hi;
+    hsh_entry_t** new_array;
+    unsigned int new_max;
 
-  new_max = ht->max * 2 + 1;
-  new_array = alloc_array(ht, new_max);
+    new_max = ht->max * 2 + 1;
+    new_array = alloc_array(ht, new_max);
 
-  if(!new_array)
-    return 0;
+    if(!new_array)
+        return 0;
 
-  for(hi = hsh_first(ht); hi; hi = hsh_next(hi))
-  {
-    unsigned int i = hi->ths->hash & new_max;
-    hi->ths->next = new_array[i];
-    new_array[i] = hi->ths;
-  }
+    for(hi = hsh_first(ht); hi; hi = hsh_next(hi))
+    {
+        unsigned int i = hi->ths->hash & new_max;
+        hi->ths->next = new_array[i];
+        new_array[i] = hi->ths;
+    }
 
-  if(ht->array)
-    free(ht->array);
+    if(ht->array)
+        free(ht->array);
 
-  ht->array = new_array;
-  ht->max = new_max;
-  return 1;
+    ht->array = new_array;
+    ht->max = new_max;
+    return 1;
 }
 
 /*
@@ -302,283 +302,283 @@ static hsh_entry_t** find_entry(hsh_t* ht, const void* key, const void* val)
 static hsh_entry_t** find_entry(hsh_t* ht, const void* key, size_t klen, const void* val)
 #endif
 {
-  hsh_entry_t** hep;
-  hsh_entry_t* he;
-  const unsigned char* p;
-  unsigned int hash;
-  size_t i;
+    hsh_entry_t** hep;
+    hsh_entry_t* he;
+    const unsigned char* p;
+    unsigned int hash;
+    size_t i;
 
 #ifdef HSH_COPYKEYS
-  size_t klen = ht->klen;
+    size_t klen = ht->klen;
 #endif
 
-  /*
-   * This is the popular `times 33' hash algorithm which is used by
-   * perl and also appears in Berkeley DB. This is one of the best
-   * known hash functions for strings because it is both computed
-   * very fast and distributes very well.
-   *
-   * The originator may be Dan Bernstein but the code in Berkeley DB
-   * cites Chris Torek as the source. The best citation I have found
-   * is "Chris Torek, Hash function for text in C, Usenet message
-   * <27038@mimsy.umd.edu> in comp.lang.c , October, 1990." in Rich
-   * Salz's USENIX 1992 paper about INN which can be found at
-   * <http://citeseer.nj.nec.com/salz92internetnews.html>.
-   *
-   * The magic of number 33, i.e. why it works better than many other
-   * constants, prime or not, has never been adequately explained by
-   * anyone. So I try an explanation: if one experimentally tests all
-   * multipliers between 1 and 256 (as I did while writing a low-level
-   * data structure library some time ago) one detects that even
-   * numbers are not useable at all. The remaining 128 odd numbers
-   * (except for the number 1) work more or less all equally well.
-   * They all distribute in an acceptable way and this way fill a hash
-   * table with an average percent of approx. 86%.
-   *
-   * If one compares the chi^2 values of the variants (see
-   * Bob Jenkins ``Hashing Frequently Asked Questions'' at
-   * http://burtleburtle.net/bob/hash/hashfaq.html for a description
-   * of chi^2), the number 33 not even has the best value. But the
-   * number 33 and a few other equally good numbers like 17, 31, 63,
-   * 127 and 129 have nevertheless a great advantage to the remaining
-   * numbers in the large set of possible multipliers: their multiply
-   * operation can be replaced by a faster operation based on just one
-   * shift plus either a single addition or subtraction operation. And
-   * because a hash function has to both distribute good _and_ has to
-   * be very fast to compute, those few numbers should be preferred.
-   *
-   *                  -- Ralf S. Engelschall <rse@engelschall.com>
-   */
-  hash = 0;
+    /*
+     * This is the popular `times 33' hash algorithm which is used by
+     * perl and also appears in Berkeley DB. This is one of the best
+     * known hash functions for strings because it is both computed
+     * very fast and distributes very well.
+     *
+     * The originator may be Dan Bernstein but the code in Berkeley DB
+     * cites Chris Torek as the source. The best citation I have found
+     * is "Chris Torek, Hash function for text in C, Usenet message
+     * <27038@mimsy.umd.edu> in comp.lang.c , October, 1990." in Rich
+     * Salz's USENIX 1992 paper about INN which can be found at
+     * <http://citeseer.nj.nec.com/salz92internetnews.html>.
+     *
+     * The magic of number 33, i.e. why it works better than many other
+     * constants, prime or not, has never been adequately explained by
+     * anyone. So I try an explanation: if one experimentally tests all
+     * multipliers between 1 and 256 (as I did while writing a low-level
+     * data structure library some time ago) one detects that even
+     * numbers are not useable at all. The remaining 128 odd numbers
+     * (except for the number 1) work more or less all equally well.
+     * They all distribute in an acceptable way and this way fill a hash
+     * table with an average percent of approx. 86%.
+     *
+     * If one compares the chi^2 values of the variants (see
+     * Bob Jenkins ``Hashing Frequently Asked Questions'' at
+     * http://burtleburtle.net/bob/hash/hashfaq.html for a description
+     * of chi^2), the number 33 not even has the best value. But the
+     * number 33 and a few other equally good numbers like 17, 31, 63,
+     * 127 and 129 have nevertheless a great advantage to the remaining
+     * numbers in the large set of possible multipliers: their multiply
+     * operation can be replaced by a faster operation based on just one
+     * shift plus either a single addition or subtraction operation. And
+     * because a hash function has to both distribute good _and_ has to
+     * be very fast to compute, those few numbers should be preferred.
+     *
+     *                        -- Ralf S. Engelschall <rse@engelschall.com>
+     */
+    hash = 0;
 
 #ifndef HSH_COPYKEYS
-  if(klen == HSH_KEY_STRING)
-  {
-    for(p = key; *p; p++)
-      hash = hash * 33 + *p;
-
-    klen = p - (const unsigned char *)key;
-  }
-  else
+    if(klen == HSH_KEY_STRING)
+    {
+        for(p = key; *p; p++)
+            hash = hash * 33 + *p;
+
+        klen = p - (const unsigned char *)key;
+    }
+    else
 #endif
-  {
-    for(p = key, i = klen; i; i--, p++)
-      hash = hash * 33 + *p;
-  }
-
-  /* scan linked list */
-  for(hep = &ht->array[hash & ht->max], he = *hep;
-      he; hep = &he->next, he = *hep)
-  {
-   if(he->hash == hash &&
+    {
+        for(p = key, i = klen; i; i--, p++)
+            hash = hash * 33 + *p;
+    }
+
+    /* scan linked list */
+    for(hep = &ht->array[hash & ht->max], he = *hep;
+            he; hep = &he->next, he = *hep)
+    {
+     if(he->hash == hash &&
 #ifndef HSH_COPYKEYS
-      he->klen == klen &&
+            he->klen == klen &&
 #endif
-      memcmp(KEY_DATA(he), key, klen) == 0)
-     break;
-  }
+            memcmp(KEY_DATA(he), key, klen) == 0)
+         break;
+    }
 
-  if(he || !val)
-    return hep;
+    if(he || !val)
+        return hep;
 
-  /* add a new entry for non-NULL val */
+    /* add a new entry for non-NULL val */
 #ifdef HSH_COPYKEYS
-  he = int_malloc(sizeof(*he) + klen);
+    he = int_malloc(sizeof(*he) + klen);
 #else
-  he = int_malloc(sizeof(*he));
+    he = int_malloc(sizeof(*he));
 #endif
 
-  if(he)
-  {
+    if(he)
+    {
 #ifdef HSH_COPYKEYS
-    /* Key data points past end of entry */
-    memcpy(KEY_DATA(he), key, klen);
+        /* Key data points past end of entry */
+        memcpy(KEY_DATA(he), key, klen);
 #else
-    /* Key points to external data */
-    he->key = key;
-    he->klen = klen;
+        /* Key points to external data */
+        he->key = key;
+        he->klen = klen;
 #endif
 
-    he->next = NULL;
-    he->hash = hash;
-    he->val  = val;
+        he->next = NULL;
+        he->hash = hash;
+        he->val    = val;
 
 #ifdef HSH_TIMESTAMP
-    he->stamp = 0;
+        he->stamp = 0;
 #endif
 
-    *hep = he;
-    ht->count++;
-  }
+        *hep = he;
+        ht->count++;
+    }
 
-  return hep;
+    return hep;
 }
 
 #ifdef HSH_COPYKEYS
 void* hsh_get(hsh_t* ht, const void *key)
 {
-    hsh_entry_t** he = find_entry(ht, key, NULL);
+        hsh_entry_t** he = find_entry(ht, key, NULL);
 #else
 void* hsh_get(hsh_t* ht, const void *key, size_t klen)
 {
-    hsh_entry_t** he = find_entry(ht, key, klen, NULL);
+        hsh_entry_t** he = find_entry(ht, key, klen, NULL);
 #endif
 
-    if(he && *he)
-      return (void*)((*he)->val);
-    else
-      return NULL;
+        if(he && *he)
+            return (void*)((*he)->val);
+        else
+            return NULL;
 }
 
 #ifdef HSH_COPYKEYS
 int hsh_set(hsh_t* ht, const void* key, void* val)
 {
-  hsh_entry_t** hep = find_entry(ht, key, val);
+    hsh_entry_t** hep = find_entry(ht, key, val);
 #else
 int hsh_set(hsh_t* ht, const void* key, size_t klen, void* val)
 {
-  hsh_entry_t** hep = find_entry(ht, key, klen, val);
+    hsh_entry_t** hep = find_entry(ht, key, klen, val);
 #endif
 
-  if(hep && *hep)
-  {
+    if(hep && *hep)
+    {
 #ifdef HSH_CALLBACKS
-    if((*hep)->val && (*hep)->val != val && ht->calls.f_freeval)
-      (ht->calls.f_freeval)(ht->calls.arg, (void*)((*hep)->val));
+        if((*hep)->val && (*hep)->val != val && ht->calls.f_freeval)
+           (ht->calls.f_freeval)(ht->calls.arg, (void*)((*hep)->val));
 #endif
 
-    /* replace entry */
-    (*hep)->val = val;
+        /* replace entry */
+        (*hep)->val = val;
 
 #ifdef HSH_TIMESTAMP
-    /* Update or set the timestamp */
-    (*hep)->stamp = time(NULL);
+        /* Update or set the timestamp */
+        (*hep)->stamp = time(NULL);
 #endif
 
-    /* check that the collision rate isn't too high */
-    if(ht->count > ht->max)
-    {
-      if(!expand_array(ht))
-        return 0;
-    }
+        /* check that the collision rate isn't too high */
+        if(ht->count > ht->max)
+        {
+            if(!expand_array(ht))
+                return 0;
+        }
 
-    return 1;
-  }
+        return 1;
+    }
 
-  return 0;
+    return 0;
 }
 
 #ifdef HSH_COPYKEYS
 void* hsh_rem(hsh_t* ht, const void* key)
 {
-  hsh_entry_t** hep = find_entry(ht, key, NULL);
+    hsh_entry_t** hep = find_entry(ht, key, NULL);
 #else
 void* hsh_rem(hsh_t* ht, const void* key, size_t klen)
 {
-  hsh_entry_t** hep = find_entry(ht, key, klen, NULL);
+    hsh_entry_t** hep = find_entry(ht, key, klen, NULL);
 #endif
-  void* val = NULL;
-
-  if(hep && *hep)
-  {
-    hsh_entry_t* old = *hep;
-    *hep = (*hep)->next;
-    --ht->count;
-    val = (void*)old->val;
-    free(old);
-  }
-
-  return val;
+    void* val = NULL;
+
+    if(hep && *hep)
+    {
+        hsh_entry_t* old = *hep;
+        *hep = (*hep)->next;
+        --ht->count;
+        val = (void*)old->val;
+        free(old);
+    }
+
+    return val;
 }
 
 unsigned int hsh_count(hsh_t* ht)
 {
-  return ht->count;
+    return ht->count;
 }
 
 #ifdef HSH_TIMESTAMP
 int hsh_purge(hsh_t* ht, time_t stamp)
 {
-  hsh_index_t* hi;
-  int r = 0;
-  void* val;
+    hsh_index_t* hi;
+    int r = 0;
+    void* val;
 
-  for(hi = hsh_first(ht); hi; hi = hsh_next(hi))
-  {
-    if(hi->ths->stamp < stamp)
+    for(hi = hsh_first(ht); hi; hi = hsh_next(hi))
     {
-      /* No need to check for errors as we're deleting */
+        if(hi->ths->stamp < stamp)
+        {
+            /* No need to check for errors as we're deleting */
 #ifdef HSH_COPYKEYS
-      val = hsh_rem(ht, KEY_DATA(hi->ths));
+            val = hsh_rem(ht, KEY_DATA(hi->ths));
 #else
-      val = hsh_rem(ht, hi->ths->key, hi->ths->klen);
+            val = hsh_rem(ht, hi->ths->key, hi->ths->klen);
 #endif
 
 #ifdef HSH_CALLBACKS
-      if(val && ht->calls.f_freeval)
-        (ht->calls.f_freeval)(ht->calls.arg, val);
+            if(val && ht->calls.f_freeval)
+                (ht->calls.f_freeval)(ht->calls.arg, val);
 #endif
 
-      r++;
+            r++;
+        }
     }
-  }
 
-  return r;
+    return r;
 }
 
 #ifdef HSH_COPYKEYS
 void hsh_touch(hsh_t* ht, const void* key)
 {
-  hsh_entry_t** hep = find_entry(ht, key, NULL);
+    hsh_entry_t** hep = find_entry(ht, key, NULL);
 #else
 void hsh_touch(hsh_t* ht, const void* key, size_t* klen)
 {
-  hsh_entry_t** hep = find_entry(ht, key, klen, NULL);
+    hsh_entry_t** hep = find_entry(ht, key, klen, NULL);
 #endif
 
-  if(hep && *hep)
-    ((*hep)->stamp) = time(NULL);
+    if(hep && *hep)
+        ((*hep)->stamp) = time(NULL);
 }
 
 int hsh_bump(hsh_t* ht)
 {
-  hsh_index_t* hi;
-  void* key = NULL;
-  void* val = NULL;
-  time_t least = 0;
+    hsh_index_t* hi;
+    void* key = NULL;
+    void* val = NULL;
+    time_t least = 0;
 #ifndef HSH_COPYKEYS
-  size_t klen = 0;
+    size_t klen = 0;
 #endif
 
-  for(hi = hsh_first(ht); hi; hi = hsh_next(hi))
-  {
-    if(least == 0 || hi->ths->stamp < least)
+    for(hi = hsh_first(ht); hi; hi = hsh_next(hi))
     {
-      least = hi->ths->stamp;
-      key = KEY_DATA(hi->ths);
+        if(least == 0 || hi->ths->stamp < least)
+        {
+            least = hi->ths->stamp;
+            key = KEY_DATA(hi->ths);
 #ifndef HSH_COPYKEYS
-      klen = hi->this->klen;
+            klen = hi->this->klen;
 #endif
+        }
     }
-  }
 
-  if(key)
-  {
+    if(key)
+    {
 #ifdef HSH_COPYKEYS
-    val = hsh_rem(ht, key);
+        val = hsh_rem(ht, key);
 #else
-    val = hsh_rem(ht, key, klen);
+        val = hsh_rem(ht, key, klen);
 #endif
 
 #ifdef HSH_CALLBACKS
-    if(val && ht->calls.f_freeval)
-      (ht->calls.f_freeval)(ht->calls.arg, (void*)val);
+        if(val && ht->calls.f_freeval)
+            (ht->calls.f_freeval)(ht->calls.arg, (void*)val);
 #endif
 
-    return 1;
-  }
+        return 1;
+    }
 
-  return 0;
+    return 0;
 }
 
 #endif /* HSH_TIMESTAMP */
diff --git a/common/md5.c b/common/md5.c
index 2f92bec..00058ef 100644
--- a/common/md5.c
+++ b/common/md5.c
@@ -24,13 +24,13 @@ void md5_transform(unsigned int buf[4], unsigned int const in[16]);
 void
 byteSwap(unsigned int *buf, unsigned words)
 {
-        unsigned char *p = (unsigned char *)buf;
+    unsigned char *p = (unsigned char *)buf;
 
-        do {
-                *buf++ = (unsigned int)((unsigned)p[3] << 8 | p[2]) << 16 |
-                        ((unsigned)p[1] << 8 | p[0]);
-                p += 4;
-        } while (--words);
+    do {
+        *buf++ = (unsigned int)((unsigned)p[3] << 8 | p[2]) << 16 |
+            ((unsigned)p[1] << 8 | p[0]);
+        p += 4;
+    } while (--words);
 }
 #else
 #define byteSwap(buf,words)
@@ -43,13 +43,13 @@ byteSwap(unsigned int *buf, unsigned words)
 void
 md5_init(md5_ctx_t* ctx)
 {
-        ctx->buf[0] = 0x67452301;
-        ctx->buf[1] = 0xefcdab89;
-        ctx->buf[2] = 0x98badcfe;
-        ctx->buf[3] = 0x10325476;
+    ctx->buf[0] = 0x67452301;
+    ctx->buf[1] = 0xefcdab89;
+    ctx->buf[2] = 0x98badcfe;
+    ctx->buf[3] = 0x10325476;
 
-        ctx->bytes[0] = 0;
-        ctx->bytes[1] = 0;
+    ctx->bytes[0] = 0;
+    ctx->bytes[1] = 0;
 }
 
 /*
@@ -59,38 +59,38 @@ md5_init(md5_ctx_t* ctx)
 void
 md5_update(md5_ctx_t* ctx, const void* b, unsigned len)
 {
-        unsigned int t;
-        const unsigned char* buf = (const unsigned char*)b;
-
-        /* Update byte count */
-
-        t = ctx->bytes[0];
-        if ((ctx->bytes[0] = t + len) < t)
-                ctx->bytes[1]++;        /* Carry from low to high */
-
-        t = 64 - (t & 0x3f);    /* Space available in ctx->in (at least 1) */
-        if (t > len) {
-                memcpy((unsigned char *)ctx->in + 64 - t, buf, len);
-                return;
-        }
-        /* First chunk is an odd size */
-        memcpy((unsigned char *)ctx->in + 64 - t, buf, t);
+    unsigned int t;
+    const unsigned char* buf = (const unsigned char*)b;
+
+    /* Update byte count */
+
+    t = ctx->bytes[0];
+    if ((ctx->bytes[0] = t + len) < t)
+        ctx->bytes[1]++;    /* Carry from low to high */
+
+    t = 64 - (t & 0x3f);    /* Space available in ctx->in (at least 1) */
+    if (t > len) {
+        memcpy((unsigned char *)ctx->in + 64 - t, buf, len);
+        return;
+    }
+    /* First chunk is an odd size */
+    memcpy((unsigned char *)ctx->in + 64 - t, buf, t);
+    byteSwap(ctx->in, 16);
+    md5_transform(ctx->buf, ctx->in);
+    buf += t;
+    len -= t;
+
+    /* Process data in 64-byte chunks */
+    while (len >= 64) {
+        memcpy(ctx->in, buf, 64);
         byteSwap(ctx->in, 16);
         md5_transform(ctx->buf, ctx->in);
-        buf += t;
-        len -= t;
-
-        /* Process data in 64-byte chunks */
-        while (len >= 64) {
-                memcpy(ctx->in, buf, 64);
-                byteSwap(ctx->in, 16);
-                md5_transform(ctx->buf, ctx->in);
-                buf += 64;
-                len -= 64;
-        }
-
-        /* Handle any remaining bytes of data. */
-        memcpy(ctx->in, buf, len);
+        buf += 64;
+        len -= 64;
+    }
+
+    /* Handle any remaining bytes of data. */
+    memcpy(ctx->in, buf, len);
 }
 
 /*
@@ -100,33 +100,33 @@ md5_update(md5_ctx_t* ctx, const void* b, unsigned len)
 void
 md5_final(unsigned char digest[16], md5_ctx_t* ctx)
 {
-        int count = ctx->bytes[0] & 0x3f;       /* Number of bytes in ctx->in */
-        unsigned char *p = (unsigned char *)ctx->in + count;
-
-        /* Set the first char of padding to 0x80.  There is always room. */
-        *p++ = 0x80;
-
-        /* Bytes of padding needed to make 56 bytes (-8..55) */
-        count = 56 - 1 - count;
-
-        if (count < 0) {        /* Padding forces an extra block */
-                memset(p, 0, (unsigned int)count + 8);
-                byteSwap(ctx->in, 16);
-                md5_transform(ctx->buf, ctx->in);
-                p = (unsigned char *)ctx->in;
-                count = 56;
-        }
-        memset(p, 0, (unsigned int)count);
-        byteSwap(ctx->in, 14);
-
-        /* Append length in bits and transform */
-        ctx->in[14] = ctx->bytes[0] << 3;
-        ctx->in[15] = ctx->bytes[1] << 3 | ctx->bytes[0] >> 29;
-        md5_transform(ctx->buf, ctx->in);
+    int count = ctx->bytes[0] & 0x3f;       /* Number of bytes in ctx->in */
+    unsigned char *p = (unsigned char *)ctx->in + count;
+
+    /* Set the first char of padding to 0x80.  There is always room. */
+    *p++ = 0x80;
 
-        byteSwap(ctx->buf, 4);
-        memcpy(digest, ctx->buf, 16);
-        memset(ctx, 0, sizeof(ctx));    /* In case it's sensitive */
+    /* Bytes of padding needed to make 56 bytes (-8..55) */
+    count = 56 - 1 - count;
+
+    if (count < 0) {    /* Padding forces an extra block */
+        memset(p, 0, (unsigned int)count + 8);
+        byteSwap(ctx->in, 16);
+        md5_transform(ctx->buf, ctx->in);
+        p = (unsigned char *)ctx->in;
+        count = 56;
+    }
+    memset(p, 0, (unsigned int)count);
+    byteSwap(ctx->in, 14);
+
+    /* Append length in bits and transform */
+    ctx->in[14] = ctx->bytes[0] << 3;
+    ctx->in[15] = ctx->bytes[1] << 3 | ctx->bytes[0] >> 29;
+    md5_transform(ctx->buf, ctx->in);
+
+    byteSwap(ctx->buf, 4);
+    memcpy(digest, ctx->buf, 16);
+    memset(ctx, 0, sizeof(ctx));    /* In case it's sensitive */
 }
 
 void
@@ -156,7 +156,7 @@ md5_strcmp(unsigned char digest[MD5_LEN], const char* str)
 
 /* This is the central step in the MD5 algorithm. */
 #define MD5STEP(f,w,x,y,z,in,s) \
-         (w += f(x,y,z) + in, w = (w<<s | w>>(32-s)) + x)
+     (w += f(x,y,z) + in, w = (w<<s | w>>(32-s)) + x)
 
 /*
  * The core of the MD5 algorithm, this alters an existing MD5 hash to
@@ -166,83 +166,83 @@ md5_strcmp(unsigned char digest[MD5_LEN], const char* str)
 void
 md5_transform(unsigned int buf[4], unsigned int const in[16])
 {
-        register unsigned int a, b, c, d;
-
-        a = buf[0];
-        b = buf[1];
-        c = buf[2];
-        d = buf[3];
-
-        MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);
-        MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
-        MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);
-        MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
-        MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
-        MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12);
-        MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17);
-        MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22);
-        MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7);
-        MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
-        MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
-        MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);
-        MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);
-        MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);
-        MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);
-        MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);
-
-        MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);
-        MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9);
-        MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);
-        MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
-        MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5);
-        MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);
-        MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
-        MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
-        MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
-        MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);
-        MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
-        MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);
-        MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
-        MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
-        MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);
-        MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
-
-        MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);
-        MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11);
-        MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
-        MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);
-        MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);
-        MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
-        MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
-        MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
-        MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
-        MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
-        MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
-        MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);
-        MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
-        MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
-        MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
-        MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
-
-        MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);
-        MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);
-        MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
-        MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);
-        MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);
-        MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
-        MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
-        MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);
-        MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
-        MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
-        MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);
-        MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
-        MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);
-        MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
-        MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
-        MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);
-
-        buf[0] += a;
-        buf[1] += b;
-        buf[2] += c;
-        buf[3] += d;
+    register unsigned int a, b, c, d;
+
+    a = buf[0];
+    b = buf[1];
+    c = buf[2];
+    d = buf[3];
+
+    MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);
+    MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
+    MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);
+    MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
+    MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
+    MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12);
+    MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17);
+    MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22);
+    MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7);
+    MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
+    MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
+    MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);
+    MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);
+    MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);
+    MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);
+    MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);
+
+    MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);
+    MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9);
+    MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);
+    MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
+    MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5);
+    MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);
+    MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
+    MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
+    MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
+    MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);
+    MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
+    MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);
+    MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
+    MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
+    MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);
+    MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
+
+    MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);
+    MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11);
+    MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
+    MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);
+    MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);
+    MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
+    MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
+    MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
+    MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
+    MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
+    MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
+    MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);
+    MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
+    MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
+    MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
+    MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
+
+    MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);
+    MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);
+    MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
+    MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);
+    MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);
+    MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
+    MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
+    MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);
+    MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
+    MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
+    MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);
+    MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
+    MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);
+    MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
+    MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
+    MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);
+
+    buf[0] += a;
+    buf[1] += b;
+    buf[2] += c;
+    buf[3] += d;
 }
diff --git a/common/md5.h b/common/md5.h
index de431da..d503f11 100644
--- a/common/md5.h
+++ b/common/md5.h
@@ -32,9 +32,9 @@ extern "C" {
 
 typedef struct md5_ctx
 {
-  unsigned int buf[4];
-  unsigned int bytes[2];
-  unsigned int in[16];
+    unsigned int buf[4];
+    unsigned int bytes[2];
+    unsigned int in[16];
 }
 md5_ctx_t;
 
diff --git a/common/sha1.c b/common/sha1.c
index a40732e..0666837 100644
--- a/common/sha1.c
+++ b/common/sha1.c
@@ -1,6 +1,6 @@
 /*
- *  Fetched from ftp://ftp.funet.fi/pub/crypt/hash/sha/sha1.c on May 4, 1999
- *  Modified by EPG May 6, 1999
+ *    Fetched from ftp://ftp.funet.fi/pub/crypt/hash/sha/sha1.c on May 4, 1999
+ *    Modified by EPG May 6, 1999
  */
 
 /*
@@ -23,12 +23,12 @@ void SHA1Transform(ulong state[5], const uchar buffer[64]);
 /* I got the idea of expanding during the round function from SSLeay */
 #ifdef LITTLE_ENDIAN
 #define blk0(i) (block->l[i] = (rol(block->l[i],24)&0xFF00FF00) \
-    |(rol(block->l[i],8)&0x00FF00FF))
+        |(rol(block->l[i],8)&0x00FF00FF))
 #else
 #define blk0(i) block->l[i]
 #endif
 #define blk(i) (block->l[i&15] = rol(block->l[(i+13)&15]^block->l[(i+8)&15] \
-    ^block->l[(i+2)&15]^block->l[i&15],1))
+        ^block->l[(i+2)&15]^block->l[i&15],1))
 
 /* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */
 #define R0(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk0(i)+0x5A827999+rol(v,5);w=rol(w,30);
@@ -42,54 +42,54 @@ void SHA1Transform(ulong state[5], const uchar buffer[64]);
 
 void SHA1Transform(ulong state[5], const uchar buffer[64])
 {
-  ulong a, b, c, d, e;
-  typedef union {
-    uchar c[64];
-    ulong l[16];
-  } CHAR64LONG16;
-  CHAR64LONG16* block;
+    ulong a, b, c, d, e;
+    typedef union {
+        uchar c[64];
+        ulong l[16];
+    } CHAR64LONG16;
+    CHAR64LONG16* block;
 #ifdef SHA1HANDSOFF
-  static uchar workspace[64];
-  block = (CHAR64LONG16*)workspace;
-  memcpy(block, buffer, 64);
+    static uchar workspace[64];
+    block = (CHAR64LONG16*)workspace;
+    memcpy(block, buffer, 64);
 #else
-  block = (CHAR64LONG16*)buffer;
+    block = (CHAR64LONG16*)buffer;
 #endif
-  /* Copy context->state[] to working vars */
-  a = state[0];
-  b = state[1];
-  c = state[2];
-  d = state[3];
-  e = state[4];
-  /* 4 rounds of 20 operations each. Loop unrolled. */
-  R0(a,b,c,d,e, 0); R0(e,a,b,c,d, 1); R0(d,e,a,b,c, 2); R0(c,d,e,a,b, 3);
-  R0(b,c,d,e,a, 4); R0(a,b,c,d,e, 5); R0(e,a,b,c,d, 6); R0(d,e,a,b,c, 7);
-  R0(c,d,e,a,b, 8); R0(b,c,d,e,a, 9); R0(a,b,c,d,e,10); R0(e,a,b,c,d,11);
-  R0(d,e,a,b,c,12); R0(c,d,e,a,b,13); R0(b,c,d,e,a,14); R0(a,b,c,d,e,15);
-  R1(e,a,b,c,d,16); R1(d,e,a,b,c,17); R1(c,d,e,a,b,18); R1(b,c,d,e,a,19);
-  R2(a,b,c,d,e,20); R2(e,a,b,c,d,21); R2(d,e,a,b,c,22); R2(c,d,e,a,b,23);
-  R2(b,c,d,e,a,24); R2(a,b,c,d,e,25); R2(e,a,b,c,d,26); R2(d,e,a,b,c,27);
-  R2(c,d,e,a,b,28); R2(b,c,d,e,a,29); R2(a,b,c,d,e,30); R2(e,a,b,c,d,31);
-  R2(d,e,a,b,c,32); R2(c,d,e,a,b,33); R2(b,c,d,e,a,34); R2(a,b,c,d,e,35);
-  R2(e,a,b,c,d,36); R2(d,e,a,b,c,37); R2(c,d,e,a,b,38); R2(b,c,d,e,a,39);
-  R3(a,b,c,d,e,40); R3(e,a,b,c,d,41); R3(d,e,a,b,c,42); R3(c,d,e,a,b,43);
-  R3(b,c,d,e,a,44); R3(a,b,c,d,e,45); R3(e,a,b,c,d,46); R3(d,e,a,b,c,47);
-  R3(c,d,e,a,b,48); R3(b,c,d,e,a,49); R3(a,b,c,d,e,50); R3(e,a,b,c,d,51);
-  R3(d,e,a,b,c,52); R3(c,d,e,a,b,53); R3(b,c,d,e,a,54); R3(a,b,c,d,e,55);
-  R3(e,a,b,c,d,56); R3(d,e,a,b,c,57); R3(c,d,e,a,b,58); R3(b,c,d,e,a,59);
-  R4(a,b,c,d,e,60); R4(e,a,b,c,d,61); R4(d,e,a,b,c,62); R4(c,d,e,a,b,63);
-  R4(b,c,d,e,a,64); R4(a,b,c,d,e,65); R4(e,a,b,c,d,66); R4(d,e,a,b,c,67);
-  R4(c,d,e,a,b,68); R4(b,c,d,e,a,69); R4(a,b,c,d,e,70); R4(e,a,b,c,d,71);
-  R4(d,e,a,b,c,72); R4(c,d,e,a,b,73); R4(b,c,d,e,a,74); R4(a,b,c,d,e,75);
-  R4(e,a,b,c,d,76); R4(d,e,a,b,c,77); R4(c,d,e,a,b,78); R4(b,c,d,e,a,79);
-  /* Add the working vars back into context.state[] */
-  state[0] += a;
-  state[1] += b;
-  state[2] += c;
-  state[3] += d;
-  state[4] += e;
-  /* Wipe variables */
-  a = b = c = d = e = 0;
+    /* Copy context->state[] to working vars */
+    a = state[0];
+    b = state[1];
+    c = state[2];
+    d = state[3];
+    e = state[4];
+    /* 4 rounds of 20 operations each. Loop unrolled. */
+    R0(a,b,c,d,e, 0); R0(e,a,b,c,d, 1); R0(d,e,a,b,c, 2); R0(c,d,e,a,b, 3);
+    R0(b,c,d,e,a, 4); R0(a,b,c,d,e, 5); R0(e,a,b,c,d, 6); R0(d,e,a,b,c, 7);
+    R0(c,d,e,a,b, 8); R0(b,c,d,e,a, 9); R0(a,b,c,d,e,10); R0(e,a,b,c,d,11);
+    R0(d,e,a,b,c,12); R0(c,d,e,a,b,13); R0(b,c,d,e,a,14); R0(a,b,c,d,e,15);
+    R1(e,a,b,c,d,16); R1(d,e,a,b,c,17); R1(c,d,e,a,b,18); R1(b,c,d,e,a,19);
+    R2(a,b,c,d,e,20); R2(e,a,b,c,d,21); R2(d,e,a,b,c,22); R2(c,d,e,a,b,23);
+    R2(b,c,d,e,a,24); R2(a,b,c,d,e,25); R2(e,a,b,c,d,26); R2(d,e,a,b,c,27);
+    R2(c,d,e,a,b,28); R2(b,c,d,e,a,29); R2(a,b,c,d,e,30); R2(e,a,b,c,d,31);
+    R2(d,e,a,b,c,32); R2(c,d,e,a,b,33); R2(b,c,d,e,a,34); R2(a,b,c,d,e,35);
+    R2(e,a,b,c,d,36); R2(d,e,a,b,c,37); R2(c,d,e,a,b,38); R2(b,c,d,e,a,39);
+    R3(a,b,c,d,e,40); R3(e,a,b,c,d,41); R3(d,e,a,b,c,42); R3(c,d,e,a,b,43);
+    R3(b,c,d,e,a,44); R3(a,b,c,d,e,45); R3(e,a,b,c,d,46); R3(d,e,a,b,c,47);
+    R3(c,d,e,a,b,48); R3(b,c,d,e,a,49); R3(a,b,c,d,e,50); R3(e,a,b,c,d,51);
+    R3(d,e,a,b,c,52); R3(c,d,e,a,b,53); R3(b,c,d,e,a,54); R3(a,b,c,d,e,55);
+    R3(e,a,b,c,d,56); R3(d,e,a,b,c,57); R3(c,d,e,a,b,58); R3(b,c,d,e,a,59);
+    R4(a,b,c,d,e,60); R4(e,a,b,c,d,61); R4(d,e,a,b,c,62); R4(c,d,e,a,b,63);
+    R4(b,c,d,e,a,64); R4(a,b,c,d,e,65); R4(e,a,b,c,d,66); R4(d,e,a,b,c,67);
+    R4(c,d,e,a,b,68); R4(b,c,d,e,a,69); R4(a,b,c,d,e,70); R4(e,a,b,c,d,71);
+    R4(d,e,a,b,c,72); R4(c,d,e,a,b,73); R4(b,c,d,e,a,74); R4(a,b,c,d,e,75);
+    R4(e,a,b,c,d,76); R4(d,e,a,b,c,77); R4(c,d,e,a,b,78); R4(b,c,d,e,a,79);
+    /* Add the working vars back into context.state[] */
+    state[0] += a;
+    state[1] += b;
+    state[2] += c;
+    state[3] += d;
+    state[4] += e;
+    /* Wipe variables */
+    a = b = c = d = e = 0;
 }
 
 
@@ -97,13 +97,13 @@ void SHA1Transform(ulong state[5], const uchar buffer[64])
 
 void sha1_init(sha1_ctx_t* context)
 {
-  /* SHA1 initialization constants */
-  context->state[0] = 0x67452301;
-  context->state[1] = 0xEFCDAB89;
-  context->state[2] = 0x98BADCFE;
-  context->state[3] = 0x10325476;
-  context->state[4] = 0xC3D2E1F0;
-  context->count[0] = context->count[1] = 0;
+    /* SHA1 initialization constants */
+    context->state[0] = 0x67452301;
+    context->state[1] = 0xEFCDAB89;
+    context->state[2] = 0x98BADCFE;
+    context->state[3] = 0x10325476;
+    context->state[4] = 0xC3D2E1F0;
+    context->count[0] = context->count[1] = 0;
 }
 
 
@@ -111,22 +111,22 @@ void sha1_init(sha1_ctx_t* context)
 
 void sha1_update(sha1_ctx_t* context, const void* d, unsigned int len)
 {
-  unsigned int i, j;
-  const uchar* data = (uchar*)d;
-
-  j = (context->count[0] >> 3) & 63;
-  if ((context->count[0] += len << 3) < (len << 3)) context->count[1]++;
-  context->count[1] += (len >> 29);
-  if ((j + len) > 63) {
-    memcpy(&context->buffer[j], data, (i = 64-j));
-    SHA1Transform(context->state, context->buffer);
-    for ( ; i + 63 < len; i += 64) {
-      SHA1Transform(context->state, &data[i]);
+    unsigned int i, j;
+    const uchar* data = (uchar*)d;
+
+    j = (context->count[0] >> 3) & 63;
+    if ((context->count[0] += len << 3) < (len << 3)) context->count[1]++;
+    context->count[1] += (len >> 29);
+    if ((j + len) > 63) {
+        memcpy(&context->buffer[j], data, (i = 64-j));
+        SHA1Transform(context->state, context->buffer);
+        for ( ; i + 63 < len; i += 64) {
+            SHA1Transform(context->state, &data[i]);
+        }
+        j = 0;
     }
-    j = 0;
-  }
-  else i = 0;
-  memcpy(&context->buffer[j], &data[i], len - i);
+    else i = 0;
+    memcpy(&context->buffer[j], &data[i], len - i);
 }
 
 
@@ -134,30 +134,30 @@ void sha1_update(sha1_ctx_t* context, const void* d, unsigned int len)
 
 void sha1_final(uchar digest[20], sha1_ctx_t* context)
 {
-  ulong i;
-  uchar finalcount[8];
-
-  for (i = 0; i < 8; i++) {
-    finalcount[i] = (uchar)((context->count[(i >= 4 ? 0 : 1)]
-			     >> ((3-(i & 3)) * 8) ) & 255);  /* Endian independent */
-  }
-  sha1_update(context, (uchar *)"\200", 1);
-  while ((context->count[0] & 504) != 448) {
-    sha1_update(context, (uchar *)"\0", 1);
-  }
-  sha1_update(context, finalcount, 8);  /* Should cause a SHA1Transform() */
-  for (i = 0; i < 20; i++) {
-    digest[i] = (uchar)
-      ((context->state[i>>2] >> ((3-(i & 3)) * 8) ) & 255);
-  }
-  /* Wipe variables */
-  i = 0;
-  memset(context->buffer, 0, 64);
-  memset(context->state, 0, 20);
-  memset(context->count, 0, 8);
-  memset(&finalcount, 0, 8);
-#ifdef SHA1HANDSOFF  /* make SHA1Transform overwrite it's own static vars */
-  SHA1Transform(context->state, context->buffer);
+    ulong i;
+    uchar finalcount[8];
+
+    for (i = 0; i < 8; i++) {
+        finalcount[i] = (uchar)((context->count[(i >= 4 ? 0 : 1)]
+			         >> ((3-(i & 3)) * 8) ) & 255);    /* Endian independent */
+    }
+    sha1_update(context, (uchar *)"\200", 1);
+    while ((context->count[0] & 504) != 448) {
+        sha1_update(context, (uchar *)"\0", 1);
+    }
+    sha1_update(context, finalcount, 8);    /* Should cause a SHA1Transform() */
+    for (i = 0; i < 20; i++) {
+        digest[i] = (uchar)
+            ((context->state[i>>2] >> ((3-(i & 3)) * 8) ) & 255);
+    }
+    /* Wipe variables */
+    i = 0;
+    memset(context->buffer, 0, 64);
+    memset(context->state, 0, 20);
+    memset(context->count, 0, 8);
+    memset(&finalcount, 0, 8);
+#ifdef SHA1HANDSOFF    /* make SHA1Transform overwrite it's own static vars */
+    SHA1Transform(context->state, context->buffer);
 #endif
 }
 
diff --git a/daemon/Makefile.am b/daemon/Makefile.am
index 5ad8665..c669f04 100644
--- a/daemon/Makefile.am
+++ b/daemon/Makefile.am
@@ -1,7 +1,7 @@
 
 sbin_PROGRAMS = httpauthd
 
-httpauthd_SOURCES = httpauthd.c httpauthd.h usuals.h compat.h compat.c \
+httpauthd_SOURCES = httpauthd.c httpauthd.h usuals.h compat.h compat.c bd.h bd.c\
 	buffer.c misc.c basic.h basic.c ntlm.c hash.c hash.h ntlmssp.h ntlmssp.c \
     md5.c md5.h sha1.c sha1.h digest.h digest.c ldap.c defaults.h simple.c \
     ../common/sock_any.c ../common/sock_any.h ../common/stringx.c\
diff --git a/daemon/basic.c b/daemon/basic.c
index fc0a096..6b41a36 100644
--- a/daemon/basic.c
+++ b/daemon/basic.c
@@ -6,39 +6,39 @@
 
 int basic_parse(const char* header, ha_buffer_t* buf, basic_header_t* rec)
 {
-  char* t;
-  ASSERT(header && buf && rec);
+    char* t;
+    ASSERT(header && buf && rec);
 
-  memset(rec, 0, sizeof(*rec));
+    memset(rec, 0, sizeof(*rec));
 
-  /*
-   * Authorization header is in this format:
-   *
-   * "Basic " B64(user ":" password)
-   */
+    /*
+     * Authorization header is in this format:
+     *
+     * "Basic " B64(user ":" password)
+     */
 
-  header = trim_start(header);
-  header = (const char*)ha_bufdec64(buf, header, NULL);
+    header = trim_start(header);
+    header = (const char*)ha_bufdec64(buf, header, NULL);
 
-  if(!header)
-    return ha_buferr(buf) ? HA_CRITERROR : HA_FALSE;
+    if(!header)
+        return ha_buferr(buf) ? HA_CRITERROR : HA_FALSE;
 
 
-  /* We have a cache key at this point so hash it */
-  md5_string(rec->key, header);
+    /* We have a cache key at this point so hash it */
+    md5_string(rec->key, header);
 
 
-  /* Parse the user. We need it in any case */
-  t = strchr(header, ':');
-  if(t != NULL)
-  {
-    /* Break the string in half */
-    *t = 0;
+    /* Parse the user. We need it in any case */
+    t = strchr(header, ':');
+    if(t != NULL)
+    {
+        /* Break the string in half */
+        *t = 0;
 
-    rec->user = header;
-    rec->password = t + 1;
-  }
+        rec->user = header;
+        rec->password = t + 1;
+    }
 
-  return HA_OK;
+    return HA_OK;
 }
 
diff --git a/daemon/basic.h b/daemon/basic.h
index c28dc1e..775a3a7 100644
--- a/daemon/basic.h
+++ b/daemon/basic.h
@@ -6,9 +6,9 @@
 
 typedef struct basic_header
 {
-  const char* user;
-  const char* password;
-  unsigned char key[MD5_LEN];
+    const char* user;
+    const char* password;
+    unsigned char key[MD5_LEN];
 }
 basic_header_t;
 
diff --git a/daemon/bd.c b/daemon/bd.c
index 916c453..6cd7b6b 100644
--- a/daemon/bd.c
+++ b/daemon/bd.c
@@ -25,8 +25,8 @@ static unsigned char g_digest_secret[DIGEST_SECRET_LEN];
 
 static void free_hash_object(void* arg, void* val)
 {
-  if(val && val != BASIC_ESTABLISHED)
-    free(val);
+    if(val && val != BASIC_ESTABLISHED)
+        free(val);
 }
 
 static digest_record_t* get_cached_digest(bd_context_t* ctx, ha_context_t* c,
@@ -92,7 +92,7 @@ static int save_cached_digest(bd_context_t* ctx, ha_context_t* c,
 
     if(!r)
     {
-        ha_messagex(LOG_CRIT, "out of memory");
+        ha_messagex(NULL, LOG_CRIT, "out of memory");
         return HA_CRITERROR;
     }
 
@@ -120,22 +120,21 @@ static int add_cached_basic(bd_context_t* ctx, ha_context_t* c,
 
     if(!r)
     {
-        ha_messagex(LOG_CRIT, "out of memory");
+        ha_messagex(NULL, LOG_CRIT, "out of memory");
         return HA_CRITERROR;
     }
 
     return HA_OK;
 }
 
-static int do_basic_response(bd_context_t* ctx, const char* header,
-                             const ha_request_t* req, ha_response_t* resp)
+static int do_basic_response(ha_request_t* rq, bd_context_t* ctx, const char* header)
 {
     basic_header_t basic;
     int ret = HA_FALSE;
 
-    ASSERT(header && resp && req);
+    ASSERT(header && rq);
 
-    if((ret = basic_parse(header, req->buf, &basic)) < 0)
+    if((ret = basic_parse(header, rq->buf, &basic)) < 0)
         return ret;
 
     /* Past this point we don't return directly */
@@ -143,7 +142,7 @@ static int do_basic_response(bd_context_t* ctx, const char* header,
     /* Check and see if this connection is in the cache */
     if(have_cached_basic(ctx, basic.key))
     {
-        ha_messagex(LOG_NOTICE, "bd: validated basic user against cache: %s",
+        ha_messagex(rq, LOG_NOTICE, "validated basic user against cache: %s",
                     basic.user);
         ret = HA_OK;
         goto finally;
@@ -153,42 +152,41 @@ static int do_basic_response(bd_context_t* ctx, const char* header,
     if(!basic.user || !basic.user[0] ||
        !basic.password || !basic.password[0])
     {
-        ha_messagex(LOG_NOTICE, "bd: no valid basic auth info");
+        ha_messagex(rq, LOG_NOTICE, "no valid basic auth info");
         ret = HA_FALSE;
         goto finally;
     }
 
     ASSERT(ctx->f_validate_basic);
-    ret = ctx->f_validate_basic(req, basic.user, basic.password);
+    ret = ctx->f_validate_basic(rq, basic.user, basic.password);
 
 finally:
 
     if(ret == HA_OK)
     {
-        resp->code = HA_SERVER_OK;
-        resp->detail = basic.user;
+        rq->resp_code = HA_SERVER_OK;
+        rq->resp_detail = basic.user;
 
         /* We put this connection into the successful connections */
-        ret = add_cached_basic(ctx, req->context, basic.key);
+        ret = add_cached_basic(ctx, rq->context, basic.key);
     }
 
     return ret;
 }
 
-static int do_digest_challenge(bd_context_t* ctx, const ha_request_t* req,
-                               ha_response_t* resp, int stale)
+static int do_digest_challenge(ha_request_t* rq, bd_context_t* ctx, int stale)
 {
     unsigned char nonce[DIGEST_NONCE_LEN];
     const char* nonce_str;
     const char* header;
 
-    ASSERT(ctx && resp && req);
+    ASSERT(ctx && rq);
 
 #ifdef _DEBUG
-    if(req->context->digest_debugnonce)
+    if(rq->context->digest_debugnonce)
     {
-        nonce_str = req->context->digest_debugnonce;
-        ha_messagex(LOG_WARNING, "bd: using debug nonce. security non-existant.");
+        nonce_str = rq->context->digest_debugnonce;
+        ha_messagex(rq, LOG_WARNING, "using debug nonce. security non-existant.");
     }
     else
 #endif
@@ -196,28 +194,27 @@ static int do_digest_challenge(bd_context_t* ctx, const ha_request_t* req,
         unsigned char nonce[DIGEST_NONCE_LEN];
         digest_makenonce(nonce, g_digest_secret, NULL);
 
-        nonce_str = ha_bufenchex(req->buf, nonce, DIGEST_NONCE_LEN);
+        nonce_str = ha_bufenchex(rq->buf, nonce, DIGEST_NONCE_LEN);
         if(!nonce_str)
-        return HA_CRITERROR;
+            return HA_CRITERROR;
     }
 
     /* Now generate a message to send */
-    header = digest_challenge(req->buf, nonce_str, req->context->realm,
-                              req->digest_domain, stale);
+    header = digest_challenge(rq->buf, nonce_str, rq->context->realm,
+                              rq->digest_domain, stale);
 
     if(!header)
         return HA_CRITERROR;
 
     /* And append it nicely */
-    resp->code = HA_SERVER_DECLINE;
-    ha_addheader(resp, "WWW-Authenticate", header);
+    rq->resp_code = HA_SERVER_DECLINE;
+    ha_addheader(rq, "WWW-Authenticate", header);
 
-    ha_messagex(LOG_DEBUG, "bd: created digest challenge with nonce: %s", nonce_str);
+    ha_messagex(rq, LOG_DEBUG, "created digest challenge with nonce: %s", nonce_str);
     return HA_OK;
 }
 
-static int do_digest_response(bd_context_t* ctx, const char* header,
-                              const ha_request_t* req, ha_response_t* resp)
+static int do_digest_response(ha_request_t* rq, bd_context_t* ctx, const char* header)
 {
     unsigned char nonce[DIGEST_NONCE_LEN];
     digest_header_t dg;
@@ -228,26 +225,26 @@ static int do_digest_response(bd_context_t* ctx, const char* header,
     int stale = 0;
     int r;
 
-    ASSERT(ctx && header && req && resp);
+    ASSERT(ctx && header && rq);
 
     /* We use this below to send a default response */
-    resp->code = -1;
+    rq->resp_code = -1;
 
-    if((r = digest_parse(header, req->buf, &dg, nonce)) < 0)
+    if((r = digest_parse(header, rq->buf, &dg, nonce)) < 0)
         return r;
 
 #ifdef _DEBUG
-    if(req->context->digest_debugnonce)
+    if(rq->context->digest_debugnonce)
     {
-        if(dg.nonce && strcmp(dg.nonce, req->context->digest_debugnonce) != 0)
+        if(dg.nonce && strcmp(dg.nonce, rq->context->digest_debugnonce) != 0)
         {
             ret = HA_FALSE;
-            ha_messagex(LOG_WARNING, "bd: digest response contains invalid nonce");
+            ha_messagex(rq, LOG_WARNING, "digest response contains invalid nonce");
             goto finally;
         }
 
         /* Do a rough hash into the real nonce, for use as a key */
-        md5_string(nonce, req->context->digest_debugnonce);
+        md5_string(nonce, rq->context->digest_debugnonce);
 
         /* Debug nonce's never expire */
         expiry = time(NULL);
@@ -259,18 +256,18 @@ static int do_digest_response(bd_context_t* ctx, const char* header,
         if(r != HA_OK)
         {
             if(r == HA_FALSE)
-                ha_messagex(LOG_WARNING, "bd: digest response contains invalid nonce");
+                ha_messagex(rq, LOG_WARNING, "digest response contains invalid nonce");
 
             goto finally;
         }
     }
 
-    rec = get_cached_digest(ctx, req->context, nonce);
+    rec = get_cached_digest(ctx, rq->context, nonce);
 
     /* Check to see if we're stale */
-    if((expiry + req->context->cache_timeout) <= time(NULL))
+    if((expiry + rq->context->cache_timeout) <= time(NULL))
     {
-        ha_messagex(LOG_INFO, "bd: nonce expired, sending stale challenge: %s",
+        ha_messagex(rq, LOG_INFO, "nonce expired, sending stale challenge: %s",
                     dg.username);
 
         stale = 1;
@@ -279,7 +276,7 @@ static int do_digest_response(bd_context_t* ctx, const char* header,
 
     if(!rec)
     {
-        ha_messagex(LOG_INFO, "bd: no record in cache, creating one: %s", dg.username);
+        ha_messagex(rq, LOG_INFO, "no record in cache, creating one: %s", dg.username);
 
         /*
          * If we're valid but don't have a record in the
@@ -294,7 +291,7 @@ static int do_digest_response(bd_context_t* ctx, const char* header,
         }
 
         ASSERT(ctx->f_complete_digest);
-        r = ctx->f_complete_digest(req, dg.username, rec->ha1);
+        r = ctx->f_complete_digest(rq, dg.username, rec->ha1);
         if(r != HA_OK)
         {
             ret = r;
@@ -308,32 +305,32 @@ static int do_digest_response(bd_context_t* ctx, const char* header,
         rec->nc++;
     }
 
-    ret = digest_check(&dg, rec, req->context, req->buf,
-                       req->args[AUTH_ARG_METHOD], req->args[AUTH_ARG_URI]);
+    ret = digest_check(&dg, rec, rq->context, rq->buf,
+                       rq->req_args[AUTH_ARG_METHOD], rq->req_args[AUTH_ARG_URI]);
 
     if(ret == HA_BADREQ)
     {
         ret = HA_FALSE;
-        resp->code = HA_SERVER_BADREQ;
+        rq->resp_code = HA_SERVER_BADREQ;
     }
 
     else if(ret == HA_OK)
     {
-        resp->code = HA_SERVER_OK;
-        resp->detail = dg.username;
+        rq->resp_code = HA_SERVER_OK;
+        rq->resp_detail = dg.username;
 
         /* Figure out if we need a new nonce */
-        if((expiry + (req->context->cache_timeout -
-                     (req->context->cache_timeout / 8))) < time(NULL))
+        if((expiry + (rq->context->cache_timeout -
+                     (rq->context->cache_timeout / 8))) < time(NULL))
         {
-            ha_messagex(LOG_INFO, "bd: nonce almost expired, creating new one: %s",
+            ha_messagex(rq, LOG_INFO, "nonce almost expired, creating new one: %s",
                         dg.username);
 
             digest_makenonce(nonce, g_digest_secret, NULL);
             stale = 1;
         }
 
-        t = digest_respond(req->buf, &dg, rec, stale ? nonce : NULL);
+        t = digest_respond(rq->buf, &dg, rec, stale ? nonce : NULL);
         if(!t)
         {
             ret = HA_CRITERROR;
@@ -341,12 +338,12 @@ static int do_digest_response(bd_context_t* ctx, const char* header,
         }
 
         if(t[0])
-            ha_addheader(resp, "Authentication-Info", t);
+            ha_addheader(rq, "Authentication-Info", t);
 
-        ha_messagex(LOG_NOTICE, "bd: validated digest user: %s", dg.username);
+        ha_messagex(rq, LOG_NOTICE, "validated digest user: %s", dg.username);
 
         /* Put the connection into the cache */
-        if((r = save_cached_digest(ctx, req->context, rec)) < 0)
+        if((r = save_cached_digest(ctx, rq->context, rec)) < 0)
             ret = r;
 
         rec = NULL;
@@ -359,8 +356,8 @@ finally:
         free(rec);
 
     /* If nobody above responded then challenge the client again */
-    if(resp->code == -1)
-        return do_digest_challenge(ctx, req, resp, stale);
+    if(rq->resp_code == -1)
+        return do_digest_challenge(rq, ctx, stale);
 
     return ret;
 }
@@ -375,7 +372,7 @@ int bd_init(ha_context_t* context)
     /* Global initialization */
     if(!context)
     {
-        ha_messagex(LOG_DEBUG, "bd: generating secret");
+        ha_messagex(NULL, LOG_DEBUG, "generating secret");
         return ha_genrandom(g_digest_secret, DIGEST_SECRET_LEN);
     }
 
@@ -390,15 +387,15 @@ int bd_init(ha_context_t* context)
         /* Make sure there are some types of authentication we can do */
         if(!(context->allowed_types & (HA_TYPE_BASIC | HA_TYPE_DIGEST)))
         {
-            ha_messagex(LOG_ERR, "bd: module configured, but does not implement any "
-                                 "configured authentication type.");
+            ha_messagex(NULL, LOG_ERR, "module configured, but does not implement any "
+                                       "configured authentication type.");
             return HA_FAILED;
         }
 
         /* The cache for digest records and basic */
         if(!(ctx->cache = hsh_create(MD5_LEN)))
         {
-            ha_messagex(LOG_CRIT, "out of memory");
+            ha_messagex(NULL, LOG_CRIT, "out of memory");
             return HA_CRITERROR;
         }
 
@@ -406,7 +403,7 @@ int bd_init(ha_context_t* context)
         htc.arg = NULL;
         hsh_set_table_calls(ctx->cache, &htc);
 
-        ha_messagex(LOG_INFO, "ldap: initialized handler");
+        ha_messagex(NULL, LOG_INFO, "initialized handler");
     }
 
     return HA_OK;
@@ -428,54 +425,54 @@ void bd_destroy(ha_context_t* context)
     if(ctx->cache)
         hsh_free(ctx->cache);
 
-    ha_messagex(LOG_INFO, "bd: uninitialized handler");
+    ha_messagex(NULL, LOG_INFO, "uninitialized handler");
 }
 
-int bd_process(const ha_request_t* req, ha_response_t* resp)
+int bd_process(ha_request_t* rq)
 {
-    bd_context_t* ctx = (bd_context_t*)req->context->ctx_data;
+    bd_context_t* ctx = (bd_context_t*)rq->context->ctx_data;
     time_t t = time(NULL);
     const char* header = NULL;
     int ret, r;
 
-    ASSERT(req && resp);
-    ASSERT(req->args[AUTH_ARG_METHOD]);
-    ASSERT(req->args[AUTH_ARG_URI]);
+    ASSERT(rq);
+    ASSERT(rq->req_args[AUTH_ARG_METHOD]);
+    ASSERT(rq->req_args[AUTH_ARG_URI]);
 
     ha_lock(NULL);
 
         /* Purge out stale connection stuff. */
-        r = hsh_purge(ctx->cache, t - req->context->cache_timeout);
+        r = hsh_purge(ctx->cache, t - rq->context->cache_timeout);
 
     ha_unlock(NULL);
 
     if(r > 0)
-        ha_messagex(LOG_DEBUG, "ldap: purged cache records: %d", r);
+        ha_messagex(rq, LOG_DEBUG, "purged cache records: %d", r);
 
     /* We use this below to detect whether to send a default response */
-    resp->code = -1;
+    rq->resp_code = -1;
 
     /* Check the headers and see if we got a response thingy */
-    if(req->context->allowed_types & HA_TYPE_DIGEST)
+    if(rq->context->allowed_types & HA_TYPE_DIGEST)
     {
-        header = ha_getheader(req, "Authorization", HA_PREFIX_DIGEST);
+        header = ha_getheader(rq, "Authorization", HA_PREFIX_DIGEST);
         if(header)
         {
-            ha_messagex(LOG_DEBUG, "ldap: processing digest auth header");
-            ret = do_digest_response(ctx, header, req, resp);
+            ha_messagex(rq, LOG_DEBUG, "processing digest auth header");
+            ret = do_digest_response(rq, ctx, header);
             if(ret < 0)
                 return ret;
         }
     }
 
     /* Or a basic authentication */
-    if(!header && req->context->allowed_types & HA_TYPE_BASIC)
+    if(!header && rq->context->allowed_types & HA_TYPE_BASIC)
     {
-        header = ha_getheader(req, "Authorization", HA_PREFIX_BASIC);
+        header = ha_getheader(rq, "Authorization", HA_PREFIX_BASIC);
         if(header)
         {
-            ha_messagex(LOG_DEBUG, "bd: processing basic auth header");
-            ret = do_basic_response(ctx, header, req, resp);
+            ha_messagex(rq, LOG_DEBUG, "processing basic auth header");
+            ret = do_basic_response(rq, ctx, header);
             if(ret < 0)
                 return ret;
         }
@@ -483,24 +480,24 @@ int bd_process(const ha_request_t* req, ha_response_t* resp)
 
 
     /* Send a default response if that's what we need */
-    if(resp->code == -1)
+    if(rq->resp_code == -1)
     {
-        resp->code = HA_SERVER_DECLINE;
+        rq->resp_code = HA_SERVER_DECLINE;
 
-        if(req->context->allowed_types & HA_TYPE_BASIC)
+        if(rq->context->allowed_types & HA_TYPE_BASIC)
         {
-            ha_bufmcat(req->buf, "BASIC realm=\"", req->context->realm , "\"", NULL);
+            ha_bufmcat(rq->buf, "BASIC realm=\"", rq->context->realm , "\"", NULL);
 
-            if(ha_buferr(req->buf))
+            if(ha_buferr(rq->buf))
                 return HA_CRITERROR;
 
-            ha_addheader(resp, "WWW-Authenticate", ha_bufdata(req->buf));
-            ha_messagex(LOG_DEBUG, "bd: sent basic auth request");
+            ha_addheader(rq, "WWW-Authenticate", ha_bufdata(rq->buf));
+            ha_messagex(rq, LOG_DEBUG, "sent basic auth request");
         }
 
-        if(req->context->allowed_types & HA_TYPE_DIGEST)
+        if(rq->context->allowed_types & HA_TYPE_DIGEST)
         {
-            ret = do_digest_challenge(ctx, req, resp, 0);
+            ret = do_digest_challenge(rq, ctx, 0);
             if(ret < 0)
                 return ret;
         }
diff --git a/daemon/bd.h b/daemon/bd.h
index 450c8e1..272e09a 100644
--- a/daemon/bd.h
+++ b/daemon/bd.h
@@ -17,8 +17,8 @@
  * HA_OK: completed successfully
  * HA_FAILED: error retrieving hash (should have logged error)
  */
-typedef int (*bd_complete_digest)(const ha_request_t* req,
-                const char* user, unsigned char* ha1);
+typedef int (*bd_complete_digest)(ha_request_t* rq,
+                                  const char* user, unsigned char* ha1);
 
 /*
  * A callback for validating a given user's password.
@@ -28,8 +28,8 @@ typedef int (*bd_complete_digest)(const ha_request_t* req,
  * HA_FALSE: invalid password
  * HA_FAILED: error validating (should have logged error)
  */
-typedef int (*bd_validate_basic)(const ha_request_t* req,
-                const char* user, const char* password);
+typedef int (*bd_validate_basic)(ha_request_t* rq,
+                                 const char* user, const char* password);
 
 /* ----------------------------------------------------------------------------------
  *  Base Context
@@ -66,6 +66,6 @@ void bd_destroy(ha_context_t* context);
  * The base/digest processer for requests. Call this from your
  * 'derived' handler process function.
  */
-int bd_process(const ha_request_t* req, ha_response_t* resp);
+int bd_process(ha_request_t* rq);
 
 #endif /* BD_H */
diff --git a/daemon/digest.c b/daemon/digest.c
index 405a661..099bf31 100644
--- a/daemon/digest.c
+++ b/daemon/digest.c
@@ -12,103 +12,103 @@ static unsigned int g_digest_unique = 0;
 
 typedef struct internal_nonce
 {
-  unsigned char hash[MD5_LEN];
-  time_t tm;
-  unsigned int unique;
+    unsigned char hash[MD5_LEN];
+    time_t tm;
+    unsigned int unique;
 }
 internal_nonce_t;
 
 void digest_makenonce(unsigned char* nonce, unsigned char* secret, unsigned char* old)
 {
-  internal_nonce_t in;
-  md5_ctx_t md5;
-
-  ASSERT(nonce && secret);
-  ASSERT(sizeof(internal_nonce_t) == DIGEST_NONCE_LEN);
-
-  if(old)
-  {
-    internal_nonce_t* nold = (internal_nonce_t*)old;
-    in.tm = nold->tm;
-    in.unique = nold->unique;
-  }
-  else
-  {
-    in.tm = time(NULL);
-    ha_lock(NULL);
-      in.unique = g_digest_unique++;
-    ha_unlock(NULL);
-  }
-
-  md5_init(&md5);
-  md5_update(&md5, secret, DIGEST_SECRET_LEN);
-  md5_update(&md5, &(in.tm), sizeof(in.tm));
-  md5_update(&md5, &(in.unique), sizeof(in.unique));
-  md5_final(in.hash, &md5);
-
-  memcpy(nonce, &in, DIGEST_NONCE_LEN);
+    internal_nonce_t in;
+    md5_ctx_t md5;
+
+    ASSERT(nonce && secret);
+    ASSERT(sizeof(internal_nonce_t) == DIGEST_NONCE_LEN);
+
+    if(old)
+    {
+        internal_nonce_t* nold = (internal_nonce_t*)old;
+        in.tm = nold->tm;
+        in.unique = nold->unique;
+    }
+    else
+    {
+        in.tm = time(NULL);
+        ha_lock(NULL);
+            in.unique = g_digest_unique++;
+        ha_unlock(NULL);
+    }
+
+    md5_init(&md5);
+    md5_update(&md5, secret, DIGEST_SECRET_LEN);
+    md5_update(&md5, &(in.tm), sizeof(in.tm));
+    md5_update(&md5, &(in.unique), sizeof(in.unique));
+    md5_final(in.hash, &md5);
+
+    memcpy(nonce, &in, DIGEST_NONCE_LEN);
 }
 
 int digest_checknonce(unsigned char* nonce, unsigned char* secret, time_t* tm)
 {
-  internal_nonce_t in;
+    internal_nonce_t in;
 
-  ASSERT(nonce && secret);
-  ASSERT(sizeof(internal_nonce_t) == DIGEST_NONCE_LEN);
+    ASSERT(nonce && secret);
+    ASSERT(sizeof(internal_nonce_t) == DIGEST_NONCE_LEN);
 
-  digest_makenonce((unsigned char*)&in, secret, nonce);
+    digest_makenonce((unsigned char*)&in, secret, nonce);
 
-  if(memcmp((unsigned char*)&in, nonce, DIGEST_SECRET_LEN) == 0)
-  {
-    if(tm)
-      *tm = in.tm;
+    if(memcmp((unsigned char*)&in, nonce, DIGEST_SECRET_LEN) == 0)
+    {
+        if(tm)
+            *tm = in.tm;
 
-    return HA_OK;
-  }
+        return HA_OK;
+    }
 
-  return HA_FALSE;
+    return HA_FALSE;
 }
 
 digest_record_t* digest_makerec(unsigned char* nonce, const char* user)
 {
-  digest_record_t* rec = (digest_record_t*)malloc(sizeof(*rec));
+    digest_record_t* rec = (digest_record_t*)malloc(sizeof(*rec));
 
-  ASSERT(nonce && user);
+    ASSERT(nonce && user);
 
-  if(!rec)
-  {
-    ha_messagex(LOG_CRIT, "out of memory");
-    return NULL;
-  }
+    if(!rec)
+    {
+        ha_messagex(NULL, LOG_CRIT, "out of memory");
+        return NULL;
+    }
 
-  memset(rec, 0, sizeof(*rec));
-  memcpy(rec->nonce, nonce, DIGEST_NONCE_LEN);
+    memset(rec, 0, sizeof(*rec));
+    memcpy(rec->nonce, nonce, DIGEST_NONCE_LEN);
 
-  md5_string(rec->userhash, user);
-  return rec;
+    md5_string(rec->userhash, user);
+    return rec;
 }
 
 const char* digest_challenge(ha_buffer_t* buf, const char* nonce_str,
                              const char* realm, const char* domains, int stale)
 {
-  ASSERT(buf && realm && nonce_str);
+    ASSERT(buf && realm && nonce_str);
 
-  ha_bufmcat(buf, HA_PREFIX_DIGEST, " realm=\"", realm, "\", nonce=\"",
-              nonce_str, "\", qop=\"auth\", algorithm=\"MD5\"", NULL);
+    ha_bufmcat(buf, HA_PREFIX_DIGEST, " realm=\"", realm, "\", nonce=\"",
+               nonce_str, "\", qop=\"auth\", algorithm=\"MD5\"", NULL);
 
-  if(domains)
-  {
-    ha_bufjoin(buf);
-    ha_bufmcat(buf, ", domain=\"", domains, "\"", NULL);
-  }
+    if(domains)
+    {
+        ha_bufjoin(buf);
+        ha_bufmcat(buf, ", domain=\"", domains, "\"", NULL);
+    }
 
-  if(stale)
-  {
-    ha_bufjoin(buf);
-    ha_bufcat(buf, ", stale=true");
-  }
+    if(stale)
+    {
+        ha_bufjoin(buf);
+        ha_bufcat(buf, ", stale=true");
+    }
 
-  return ha_bufdata(buf);
+    return ha_bufdata(buf);
 }
 
 /*
@@ -130,316 +130,396 @@ const char* digest_challenge(ha_buffer_t* buf, const char* nonce_str,
 int digest_parse(char* header, ha_buffer_t* buf, digest_header_t* rec,
                    unsigned char* nonce)
 {
-  char next;
-  char* key;
-  char* value;
-
-  ASSERT(header && buf && rec);
-
-  header = ha_bufcpy(buf, header);
-
-  if(!header)
-    return HA_CRITERROR;
-
-  memset(rec, 0, sizeof(*rec));
-
-  while(header[0])
-  {
-    /* find key */
-    header = (char*)trim_start(header);
-    key = header;
+    char next;
+    char* key;
+    char* value;
 
-    while(header[0] && header[0] != '=' && header[0] != ',' &&
-          !isspace(header[0]))
-      header++;
+    ASSERT(header && buf && rec);
 
-    /* null terminate and move on */
-    next = header[0];
-    header[0] = '\0';
-    header++;
+    header = ha_bufcpy(buf, header);
 
-    if(!next)
-      break;
-
-    if(isspace(header[0]))
-    {
-      header = (char*)trim_start(header);
-      next = header[0];
-    }
+    if(!header)
+        return HA_CRITERROR;
 
-    /* find value */
+    memset(rec, 0, sizeof(*rec));
 
-    if(next == '=')
+    while(header[0])
     {
-      header = (char*)trim_start(header);
+        /* find key */
+        header = (char*)trim_start(header);
+        key = header;
 
-      if(header[0] == '\"')          /* quoted string */
-      {
-        header++;
-        value = header;
-
-        while(header[0] && header[0] != '\"')
-          header++;
+        while(header[0] && header[0] != '=' && header[0] != ',' &&
+              !isspace(header[0]))
+            header++;
 
+        /* null terminate and move on */
         next = header[0];
-        header[0] = 0;
+        header[0] = '\0';
         header++;
-      }
 
-      else                          /* token */
-      {
-        value = header;
+        if(!next)
+            break;
+
+        if(isspace(header[0]))
+        {
+            header = (char*)trim_start(header);
+            next = header[0];
+        }
 
-        while(header[0] && header[0] != ',' && !isspace(header[0]))
-          header++;
+        /* find value */
 
-        next = header[0];
-        header[0] = 0;
-        header++;
-      }
-
-      if(next != ',')
-      {
-        while(header[0] && header[0] != ',')
-          header++;
-
-        if(header[0])
-          header++;
-      }
-
-      if(!strcasecmp(key, "username"))
-        rec->username = value;
-      else if(!strcasecmp(key, "realm"))
-        rec->realm = value;
-      else if (!strcasecmp(key, "nonce"))
-        rec->nonce = value;
-      else if (!strcasecmp(key, "uri"))
-        rec->uri = value;
-      else if (!strcasecmp(key, "response"))
-        rec->digest = value;
-      else if (!strcasecmp(key, "algorithm"))
-        rec->algorithm = value;
-      else if (!strcasecmp(key, "cnonce"))
-        rec->cnonce = value;
-      else if (!strcasecmp(key, "opaque"))
-        rec->opaque = value;
-      else if (!strcasecmp(key, "qop"))
-        rec->qop = value;
-      else if (!strcasecmp(key, "nc"))
-        rec->nc = value;
+        if(next == '=')
+        {
+            header = (char*)trim_start(header);
+
+            if(header[0] == '\"')          /* quoted string */
+            {
+                header++;
+                value = header;
+
+                while(header[0] && header[0] != '\"')
+                    header++;
+
+                next = header[0];
+                header[0] = 0;
+                header++;
+            }
+
+            else                          /* token */
+            {
+                value = header;
+
+                while(header[0] && header[0] != ',' && !isspace(header[0]))
+                    header++;
+
+                next = header[0];
+                header[0] = 0;
+                header++;
+            }
+
+            if(next != ',')
+            {
+                while(header[0] && header[0] != ',')
+                    header++;
+
+                if(header[0])
+                    header++;
+            }
+
+            if(!strcasecmp(key, "username"))
+                rec->username = value;
+            else if(!strcasecmp(key, "realm"))
+                rec->realm = value;
+            else if (!strcasecmp(key, "nonce"))
+                rec->nonce = value;
+            else if (!strcasecmp(key, "uri"))
+                rec->uri = value;
+            else if (!strcasecmp(key, "response"))
+                rec->digest = value;
+            else if (!strcasecmp(key, "algorithm"))
+                rec->algorithm = value;
+            else if (!strcasecmp(key, "cnonce"))
+                rec->cnonce = value;
+            else if (!strcasecmp(key, "opaque"))
+                rec->opaque = value;
+            else if (!strcasecmp(key, "qop"))
+                rec->qop = value;
+            else if (!strcasecmp(key, "nc"))
+                rec->nc = value;
+        }
     }
-  }
 
-  if(nonce)
-  {
-    memset(nonce, 0, DIGEST_NONCE_LEN);
-
-    if(rec->nonce)
+    if(nonce)
     {
-      size_t len = DIGEST_NONCE_LEN;
-      void* d = ha_bufdechex(buf, rec->nonce, &len);
+        memset(nonce, 0, DIGEST_NONCE_LEN);
+
+        if(rec->nonce)
+        {
+            size_t len = DIGEST_NONCE_LEN;
+            void* d = ha_bufdechex(buf, rec->nonce, &len);
 
-      if(d && len == DIGEST_NONCE_LEN)
-        memcpy(nonce, d, DIGEST_NONCE_LEN);
+            if(d && len == DIGEST_NONCE_LEN)
+                memcpy(nonce, d, DIGEST_NONCE_LEN);
+        }
     }
-  }
 
-  return HA_OK;
+    return HA_OK;
 }
 
 int digest_check(digest_header_t* dg, digest_record_t* rec, const ha_context_t* ctx,
                  ha_buffer_t* buf, const char* method, const char* uri)
 {
-  unsigned char hash[MD5_LEN];
-  md5_ctx_t md5;
-  const char* digest;
-  const char* t;
-
-  ASSERT(ctx && method && buf && dg && rec);
-
-  /* TODO: Many of these should somehow communicate BAD REQ back to the client */
-
-  /* Check for digest */
-  if(!dg->digest || !dg->digest[0])
-  {
-    ha_messagex(LOG_WARNING, "digest response missing digest");
-    return HA_BADREQ;
-  }
-
-  /* Username */
-  if(!dg->username || !dg->username[0])
-  {
-    ha_messagex(LOG_WARNING, "digest response missing username");
-    return HA_BADREQ;
-  }
-
-  if(md5_strcmp(rec->userhash, dg->username) != 0)
-  {
-    ha_messagex(LOG_ERR, "digest response contains invalid username");
-    return HA_FALSE;
-  }
-
-  /* The realm */
-  if(!dg->realm)
-  {
-    ha_messagex(LOG_WARNING, "digest response contains missing realm");
-    return HA_BADREQ;
-  }
-
-  if(strcmp(dg->realm, ctx->realm) != 0)
-  {
-    ha_messagex(LOG_ERR, "digest response contains invalid realm: %s", dg->realm);
-    return HA_FALSE;
-  }
+    unsigned char hash[MD5_LEN];
+    md5_ctx_t md5;
+    const char* digest;
+    const char* t;
 
-  /* Components in the new RFC */
-  if(dg->qop)
-  {
-    /*
-     * We only support 'auth' qop. We don't have access to the data
-     * and wouldn't be able to support anything else.
-     */
-    if(strcmp(dg->qop, "auth") != 0)
+    ASSERT(ctx && method && buf && dg && rec);
+
+    /* TODO: This stuff should probably go into bd.c */
+
+    /* Check for digest */
+    if(!dg->digest || !dg->digest[0])
     {
-      ha_messagex(LOG_WARNING, "digest response contains unknown or unsupported qop: '%s'",
-                  dg->qop ? dg->qop : "");
-      return HA_BADREQ;
+        ha_messagex(NULL, LOG_WARNING, "digest response missing digest");
+        return HA_BADREQ;
     }
 
-    /* The cnonce */
-    if(!dg->cnonce || !dg->cnonce[0])
+    /* Username */
+    if(!dg->username || !dg->username[0])
     {
-      ha_messagex(LOG_WARNING, "digest response is missing cnonce value");
-      return HA_BADREQ;
+        ha_messagex(NULL, LOG_WARNING, "digest response missing username");
+        return HA_BADREQ;
+    }
+
+    if(md5_strcmp(rec->userhash, dg->username) != 0)
+    {
+        ha_messagex(NULL, LOG_ERR, "digest response contains invalid username");
+        return HA_FALSE;
     }
 
-    if(!ctx->digest_ignorenc)
+    /* The realm */
+    if(!dg->realm)
     {
-      /* The nonce count */
-      if(!dg->nc || !dg->nc[0])
-      {
-        ha_messagex(LOG_WARNING, "digest response is missing nc value");
+        ha_messagex(NULL, LOG_WARNING, "digest response contains missing realm");
         return HA_BADREQ;
-      }
+    }
 
-      /* Validate the nc */
-      else
-      {
-        char* e;
-        long nc = strtol(dg->nc, &e, 16);
+    if(strcmp(dg->realm, ctx->realm) != 0)
+    {
+        ha_messagex(NULL, LOG_ERR, "digest response contains invalid realm: %s", dg->realm);
+        return HA_FALSE;
+    }
 
-        if(*e)
+    /* Components in the new RFC */
+    if(dg->qop)
+    {
+        /*
+         * We only support 'auth' qop. We don't have access to the data
+         * and wouldn't be able to support anything else.
+         */
+        if(strcmp(dg->qop, "auth") != 0)
         {
-          ha_messagex(LOG_ERR, "digest response has invalid nc value: %s", dg->nc);
-          return HA_BADREQ;
+            ha_messagex(NULL, LOG_WARNING, "digest response contains unknown or unsupported qop: '%s'",
+                        dg->qop ? dg->qop : "");
+            return HA_BADREQ;
         }
 
-        /* If we didn't a nc then save it away */
-        if(!*e && rec->nc == 0)
-            rec->nc = nc;
+        /* The cnonce */
+        if(!dg->cnonce || !dg->cnonce[0])
+        {
+            ha_messagex(NULL, LOG_WARNING, "digest response is missing cnonce value");
+            return HA_BADREQ;
+        }
 
-        if(*e || nc != rec->nc)
+        if(!ctx->digest_ignorenc)
         {
-          ha_messagex(LOG_WARNING, "digest response has wrong nc value. "
-                                   "possible replay attack: %s", dg->nc);
-          return HA_FALSE;
+            /* The nonce count */
+            if(!dg->nc || !dg->nc[0])
+            {
+                ha_messagex(NULL, LOG_WARNING, "digest response is missing nc value");
+                return HA_BADREQ;
+            }
+
+            /* Validate the nc */
+            else
+            {
+                char* e;
+                long nc = strtol(dg->nc, &e, 16);
+
+                if(*e)
+                {
+                    ha_messagex(NULL, LOG_ERR, "digest response has invalid nc value: %s", dg->nc);
+                    return HA_BADREQ;
+                }
+
+                /* If we didn't a nc then save it away */
+                if(!*e && rec->nc == 0)
+                    rec->nc = nc;
+
+                if(*e || nc != rec->nc)
+                {
+                    ha_messagex(NULL, LOG_WARNING, "digest response has wrong nc value. "
+                                             "possible replay attack: %s", dg->nc);
+                    return HA_FALSE;
+                }
+            }
         }
-      }
     }
-  }
-
-  /* The algorithm */
-  if(dg->algorithm && strcasecmp(dg->algorithm, "MD5") != 0)
-  {
-    ha_messagex(LOG_WARNING, "digest response contains unknown or unsupported algorithm: '%s'",
-                dg->algorithm ? dg->algorithm : "");
-    return HA_BADREQ;
-  }
-
-  /* Request URI */
-  if(!dg->uri)
-  {
-    ha_messagex(LOG_WARNING, "digest response is missing uri");
-    return HA_BADREQ;
-  }
-
-  if(!ctx->digest_ignoreuri && strcmp(dg->uri, uri) != 0)
-  {
-    ha_uri_t d_uri;
-    ha_uri_t s_uri;
-
-    if(ha_uriparse(buf, dg->uri, &d_uri) < 0)
+
+    /* The algorithm */
+    if(dg->algorithm && strcasecmp(dg->algorithm, "MD5") != 0)
     {
-      if(ha_buferr(buf))
-        return HA_CRITERROR;
+        ha_messagex(NULL, LOG_WARNING, "digest response contains unknown or unsupported algorithm: '%s'",
+                    dg->algorithm ? dg->algorithm : "");
+        return HA_BADREQ;
+    }
 
-      ha_messagex(LOG_WARNING, "digest response constains invalid uri: %s", dg->uri);
-      return HA_BADREQ;
+    /* Request URI */
+    if(!dg->uri)
+    {
+        ha_messagex(NULL, LOG_WARNING, "digest response is missing uri");
+        return HA_BADREQ;
     }
 
-    if(ha_uriparse(buf, uri, &s_uri) < 0)
+    if(!ctx->digest_ignoreuri && strcmp(dg->uri, uri) != 0)
     {
-      if(ha_buferr(buf))
+        ha_uri_t d_uri;
+        ha_uri_t s_uri;
+
+        if(ha_uriparse(buf, dg->uri, &d_uri) < 0)
+        {
+            if(ha_buferr(buf))
+                return HA_CRITERROR;
+
+            ha_messagex(NULL, LOG_WARNING, "digest response constains invalid uri: %s", dg->uri);
+            return HA_BADREQ;
+        }
+
+        if(ha_uriparse(buf, uri, &s_uri) < 0)
+        {
+            if(ha_buferr(buf))
+                return HA_CRITERROR;
+
+            ha_messagex(NULL, LOG_ERR, "server sent us an invalid uri");
+            return HA_BADREQ;
+        }
+
+        if(ha_uricmp(&d_uri, &s_uri) != 0)
+        {
+            ha_messagex(NULL, LOG_ERR, "digest response contains wrong uri: %s "
+                                 "(should be %s)", dg->uri, uri);
+            return HA_FALSE;
+        }
+    }
+
+    /*
+     * nonce: should have already been validated by the caller who
+     * found this nice rec structure to pass us.
+     *
+     * opaque: We also don't use opaque. The caller should have validated it
+     * if it's used there.
+     */
+
+    /*
+     * Now we validate the digest response
+     */
+
+    /* Encode ha1 */
+    t = ha_bufenchex(buf, rec->ha1, MD5_LEN);
+
+    if(t == NULL)
+        return HA_CRITERROR;
+
+    /* Encode ha2 */
+    md5_init(&md5);
+    md5_update(&md5, method, strlen(method));
+    md5_update(&md5, ":", 1);
+    md5_update(&md5, dg->uri, strlen(dg->uri));
+    md5_final(hash, &md5);
+
+    ha_bufenchex(buf, hash, MD5_LEN);
+
+    if(!ha_bufdata(buf))
         return HA_CRITERROR;
 
-      ha_messagex(LOG_ERR, "server sent us an invalid uri");
-      return HA_BADREQ;
+
+    /* Old style digest (RFC 2069) */
+    if(!dg->qop)
+    {
+        md5_init(&md5);
+        md5_update(&md5, t, MD5_LEN * 2);                /* ha1 */
+        md5_update(&md5, ":", 1);
+        md5_update(&md5, dg->nonce, strlen(dg->nonce));  /* nonce */
+        md5_update(&md5, ":", 1);
+        md5_update(&md5, ha_bufdata(buf), MD5_LEN * 2);  /* ha1 */
+        md5_final(hash, &md5);
+    }
+
+    /* New style 'auth' digest (RFC 2617) */
+    else
+    {
+        md5_init(&md5);
+        md5_update(&md5, t, MD5_LEN * 2);                  /* ha1 */
+        md5_update(&md5, ":", 1);
+        md5_update(&md5, dg->nonce, strlen(dg->nonce));    /* nonce */
+        md5_update(&md5, ":", 1);
+        md5_update(&md5, dg->nc, strlen(dg->nc));          /* nc */
+        md5_update(&md5, ":", 1);
+        md5_update(&md5, dg->cnonce, strlen(dg->cnonce));  /* cnonce */
+        md5_update(&md5, ":", 1);
+        md5_update(&md5, dg->qop, strlen(dg->qop));        /* qop */
+        md5_update(&md5, ":", 1);
+        md5_update(&md5, ha_bufdata(buf), MD5_LEN * 2);    /* ha2 */
+        md5_final(hash, &md5);
     }
 
-    if(ha_uricmp(&d_uri, &s_uri) != 0)
+    /* Encode the digest */
+    digest = ha_bufenchex(buf, hash, MD5_LEN);
+
+    if(digest == NULL)
+        return HA_CRITERROR;
+
+    if(strcasecmp(dg->digest, digest) != 0)
     {
-      ha_messagex(LOG_ERR, "digest response contains wrong uri: %s "
-                           "(should be %s)", dg->uri, uri);
-      return HA_FALSE;
+        ha_messagex(NULL, LOG_WARNING, "digest authentication failed for user: %s", dg->username);
+        return HA_FALSE;
     }
-  }
 
-  /*
-   * nonce: should have already been validated by the caller who
-   * found this nice rec structure to pass us.
-   *
-   * opaque: We also don't use opaque. The caller should have validated it
-   * if it's used there.
-   */
+    return HA_OK;
+}
 
-  /*
-   * Now we validate the digest response
-   */
+const char* digest_respond(ha_buffer_t* buf, digest_header_t* dg,
+                           digest_record_t* rec, unsigned char* next)
+{
+    unsigned char hash[MD5_LEN];
+    md5_ctx_t md5;
+    const char* nextnonce = NULL;
+    const char* t;
 
-  /* Encode ha1 */
-  t = ha_bufenchex(buf, rec->ha1, MD5_LEN);
+    ASSERT(buf && dg && rec);
 
-  if(t == NULL)
-    return HA_CRITERROR;
+    /* This makes a new buffer */
+    ha_bufcpy(buf, "");
 
-  /* Encode ha2 */
-  md5_init(&md5);
-  md5_update(&md5, method, strlen(method));
-  md5_update(&md5, ":", 1);
-  md5_update(&md5, dg->uri, strlen(dg->uri));
-  md5_final(hash, &md5);
+    if(next)
+    {
+        nextnonce = ha_bufenc64(buf, next, DIGEST_NONCE_LEN);
 
-  ha_bufenchex(buf, hash, MD5_LEN);
+        if(nextnonce == NULL)
+            return NULL;
+    }
 
-  if(!ha_bufdata(buf))
-    return HA_CRITERROR;
+    /* For older clients RFC 2069 */
+    if(!dg->qop)
+    {
+        if(nextnonce)
+            ha_bufmcat(buf, "nextnonce=\"", nextnonce, "\"", NULL);
+
+        return ha_bufdata(buf);
+    }
+
+    /* Otherwise we do the whole song and dance */
 
+    /* Encode ha1 */
+    t = ha_bufenchex(buf, rec->ha1, MD5_LEN);
 
-  /* Old style digest (RFC 2069) */
-  if(!dg->qop)
-  {
+    if(t == NULL)
+        return NULL;
+
+    /* Encode ha2 */
     md5_init(&md5);
-    md5_update(&md5, t, MD5_LEN * 2);                /* ha1 */
-    md5_update(&md5, ":", 1);
-    md5_update(&md5, dg->nonce, strlen(dg->nonce));  /* nonce */
     md5_update(&md5, ":", 1);
-    md5_update(&md5, ha_bufdata(buf), MD5_LEN * 2);  /* ha1 */
+    md5_update(&md5, dg->uri, strlen(dg->uri));
     md5_final(hash, &md5);
-  }
 
-  /* New style 'auth' digest (RFC 2617) */
-  else
-  {
+    ha_bufenchex(buf, hash, MD5_LEN);
+
+    if(!ha_bufdata(buf))
+        return NULL;
+
+    /* New style 'auth' digest (RFC 2617) */
     md5_init(&md5);
     md5_update(&md5, t, MD5_LEN * 2);                  /* ha1 */
     md5_update(&md5, ":", 1);
@@ -453,119 +533,39 @@ int digest_check(digest_header_t* dg, digest_record_t* rec, const ha_context_t*
     md5_update(&md5, ":", 1);
     md5_update(&md5, ha_bufdata(buf), MD5_LEN * 2);    /* ha2 */
     md5_final(hash, &md5);
-  }
 
-  /* Encode the digest */
-  digest = ha_bufenchex(buf, hash, MD5_LEN);
+    /* Encode the digest */
+    t = ha_bufenchex(buf, hash, MD5_LEN);
 
-  if(digest == NULL)
-    return HA_CRITERROR;
+    if(t == NULL)
+        return NULL;
 
-  if(strcasecmp(dg->digest, digest) != 0)
-  {
-    ha_messagex(LOG_WARNING, "digest authentication failed for user: %s", dg->username);
-    return HA_FALSE;
-  }
-
-  return HA_OK;
-}
-
-const char* digest_respond(ha_buffer_t* buf, digest_header_t* dg,
-                           digest_record_t* rec, unsigned char* next)
-{
-  unsigned char hash[MD5_LEN];
-  md5_ctx_t md5;
-  const char* nextnonce = NULL;
-  const char* t;
-
-  ASSERT(buf && dg && rec);
+    ha_bufmcat(buf, "rspauth=\"", t, "\"",
+                    ", qop=", dg->qop,
+                    ", nc=", dg->nc,
+                    ", cnonce=\"", dg->cnonce, "\"", NULL);
 
-  /* This makes a new buffer */
-  ha_bufcpy(buf, "");
-
-  if(next)
-  {
-    nextnonce = ha_bufenc64(buf, next, DIGEST_NONCE_LEN);
-
-    if(nextnonce == NULL)
-      return NULL;
-  }
-
-  /* For older clients RFC 2069 */
-  if(!dg->qop)
-  {
     if(nextnonce)
-      ha_bufmcat(buf, "nextnonce=\"", nextnonce, "\"", NULL);
+    {
+        ha_bufjoin(buf);
+        ha_bufmcat(buf, ", nextnonce=\"", nextnonce, "\"", NULL);
+    }
 
     return ha_bufdata(buf);
-  }
-
-  /* Otherwise we do the whole song and dance */
-
-  /* Encode ha1 */
-  t = ha_bufenchex(buf, rec->ha1, MD5_LEN);
-
-  if(t == NULL)
-    return NULL;
-
-  /* Encode ha2 */
-  md5_init(&md5);
-  md5_update(&md5, ":", 1);
-  md5_update(&md5, dg->uri, strlen(dg->uri));
-  md5_final(hash, &md5);
-
-  ha_bufenchex(buf, hash, MD5_LEN);
-
-  if(!ha_bufdata(buf))
-    return NULL;
-
-  /* New style 'auth' digest (RFC 2617) */
-  md5_init(&md5);
-  md5_update(&md5, t, MD5_LEN * 2);                  /* ha1 */
-  md5_update(&md5, ":", 1);
-  md5_update(&md5, dg->nonce, strlen(dg->nonce));    /* nonce */
-  md5_update(&md5, ":", 1);
-  md5_update(&md5, dg->nc, strlen(dg->nc));          /* nc */
-  md5_update(&md5, ":", 1);
-  md5_update(&md5, dg->cnonce, strlen(dg->cnonce));  /* cnonce */
-  md5_update(&md5, ":", 1);
-  md5_update(&md5, dg->qop, strlen(dg->qop));        /* qop */
-  md5_update(&md5, ":", 1);
-  md5_update(&md5, ha_bufdata(buf), MD5_LEN * 2);    /* ha2 */
-  md5_final(hash, &md5);
-
-  /* Encode the digest */
-  t = ha_bufenchex(buf, hash, MD5_LEN);
-
-  if(t == NULL)
-    return NULL;
-
-  ha_bufmcat(buf, "rspauth=\"", t, "\"",
-                 ", qop=", dg->qop,
-                 ", nc=", dg->nc,
-                 ", cnonce=\"", dg->cnonce, "\"", NULL);
-
-  if(nextnonce)
-  {
-    ha_bufjoin(buf);
-    ha_bufmcat(buf, ", nextnonce=\"", nextnonce, "\"", NULL);
-  }
-
-  return ha_bufdata(buf);
 }
 
 void digest_makeha1(unsigned char* digest, const char* user,
                     const char* realm, const char* password)
 {
-  md5_ctx_t md5;
+    md5_ctx_t md5;
 
-  ASSERT(digest && user && realm && password);
+    ASSERT(digest && user && realm && password);
 
-  md5_init(&md5);
-  md5_update(&md5, user, strlen(user));
-  md5_update(&md5, ":", 1);
-  md5_update(&md5, realm, strlen(realm));
-  md5_update(&md5, ":", 1);
-  md5_update(&md5, password, strlen(password));
-  md5_final(digest, &md5);
+    md5_init(&md5);
+    md5_update(&md5, user, strlen(user));
+    md5_update(&md5, ":", 1);
+    md5_update(&md5, realm, strlen(realm));
+    md5_update(&md5, ":", 1);
+    md5_update(&md5, password, strlen(password));
+    md5_final(digest, &md5);
 }
diff --git a/daemon/digest.h b/daemon/digest.h
index 8b3ecdf..f763133 100644
--- a/daemon/digest.h
+++ b/daemon/digest.h
@@ -10,28 +10,28 @@
 /* Parsed Digest response from the client */
 typedef struct digest_header
 {
-  const char* scheme;
-  const char* realm;
-  const char* username;
-  const char* nonce;
-  const char* uri;
-  const char* method;
-  const char* digest;
-  const char* algorithm;
-  const char* cnonce;
-  const char* opaque;
-  const char* qop;
-  const char* nc;
+    const char* scheme;
+    const char* realm;
+    const char* username;
+    const char* nonce;
+    const char* uri;
+    const char* method;
+    const char* digest;
+    const char* algorithm;
+    const char* cnonce;
+    const char* opaque;
+    const char* qop;
+    const char* nc;
 }
 digest_header_t;
 
 /* Kept by the server for validating the client */
 typedef struct digest_record
 {
-  unsigned char nonce[DIGEST_NONCE_LEN];
-  unsigned char userhash[MD5_LEN];
-  unsigned char ha1[MD5_LEN];
-  unsigned int nc;
+    unsigned char nonce[DIGEST_NONCE_LEN];
+    unsigned char userhash[MD5_LEN];
+    unsigned char ha1[MD5_LEN];
+    unsigned int nc;
 }
 digest_record_t;
 
diff --git a/daemon/httpauthd.c b/daemon/httpauthd.c
index c238a1a..17ed15c 100644
--- a/daemon/httpauthd.c
+++ b/daemon/httpauthd.c
@@ -36,15 +36,15 @@ extern ha_handler_t ntlm_handler;
 /* This is the list of all available handlers */
 ha_handler_t* g_handlerlist[] =
 {
-  &simple_handler,
-  &ldap_handler,
-  &ntlm_handler
+    &simple_handler,
+    &ldap_handler,
+    &ntlm_handler
 };
 
 typedef struct httpauth_loaded
 {
-  ha_context_t ctx;
-  struct httpauth_loaded* next;
+    ha_context_t ctx;
+    struct httpauth_loaded* next;
 }
 httpauth_loaded_t;
 
@@ -58,34 +58,34 @@ httpauth_loaded_t* g_handlers = NULL;
 /* A command definition. Used in parsing */
 typedef struct httpauth_command
 {
-  const char* name;
-  int code;
-  int word_args;          /* Arguments to be parsed as words */
-  int rest_arg;           /* Parse remainder as one arg? */
-  const char** headers;   /* Headers needed/allowed */
+    const char* name;
+    int code;
+    int word_args;          /* Arguments to be parsed as words */
+    int rest_arg;           /* Parse remainder as one arg? */
+    const char** headers;   /* Headers needed/allowed */
 }
 httpauth_command_t;
 
 /* The various valid headers for the auth command */
 const char* kAuthHeaders[] =
 {
-  "Authorization",
-  NULL
+    "Authorization",
+    NULL
 };
 
 /* The command definitions */
 const httpauth_command_t kCommands[] =
 {
-  { "auth", REQTYPE_AUTH, 3, 0, kAuthHeaders },
-  { "set",  REQTYPE_SET,  1, 1, NULL         },
-  { "quit", REQTYPE_QUIT, 0, 0, NULL         },
-  { NULL,   -1,           0, 0, NULL         }
+    { "auth", REQTYPE_AUTH, 3, 0, kAuthHeaders },
+    { "set",  REQTYPE_SET,  1, 1, NULL         },
+    { "quit", REQTYPE_QUIT, 0, 0, NULL         },
+    { NULL,   -1,           0, 0, NULL         }
 };
 
 typedef struct httpauth_thread
 {
-  pthread_t tid;
-  int fd;
+    pthread_t tid;
+    int fd;
 }
 httpauth_thread_t;
 
@@ -126,9 +126,8 @@ static int usage();
 static void writepid(const char* pid);
 static void* httpauth_thread(void* arg);
 static int httpauth_processor(int ifd, int ofd);
-static int httpauth_respond(int ofd, int scode, int ccode, const char* msg);
-static int process_auth(ha_request_t* req, ha_response_t* resp,
-                        ha_buffer_t* outb);
+static int httpauth_respond(ha_request_t* rq, int ofd, int scode, int ccode, const char* msg);
+static int process_auth(ha_request_t* rq);
 static int config_parse(const char* file, ha_buffer_t* buf);
 static void on_quit(int signal);
 
@@ -138,990 +137,984 @@ static void on_quit(int signal);
 
 int main(int argc, char* argv[])
 {
-  const char* conf = DEFAULT_CONFIG;
-  const char* pidfile = NULL;
-  httpauth_thread_t* threads = NULL;
-  httpauth_loaded_t* h;
-  char peername[MAXPATHLEN];
-  struct sockaddr_any sany;
-  int daemonize = 1;
-  ha_buffer_t cbuf;
-  int r, i, sock;
-  int ch = 0;
-
-  /* Keep note of the main thread */
-  g_mainthread = pthread_self();
-
-  /* Create the main mutex */
-  if(pthread_mutexattr_init(&g_mutexattr) != 0 ||
-     pthread_mutexattr_settype(&g_mutexattr, HA_MUTEX_TYPE) ||
-     pthread_mutex_init(&g_mutex, &g_mutexattr) != 0)
-    errx(1, "threading problem. can't create mutex");
-
-  /* Parse the arguments nicely */
+    const char* conf = DEFAULT_CONFIG;
+    const char* pidfile = NULL;
+    httpauth_thread_t* threads = NULL;
+    httpauth_loaded_t* h;
+    char peername[MAXPATHLEN];
+    struct sockaddr_any sany;
+    int daemonize = 1;
+    ha_buffer_t cbuf;
+    int r, i, sock;
+    int ch = 0;
+
+    /* Keep note of the main thread */
+    g_mainthread = pthread_self();
+
+    /* Create the main mutex */
+    if(pthread_mutexattr_init(&g_mutexattr) != 0 ||
+       pthread_mutexattr_settype(&g_mutexattr, HA_MUTEX_TYPE) ||
+       pthread_mutex_init(&g_mutex, &g_mutexattr) != 0)
+        errx(1, "threading problem. can't create mutex");
+
+    /* Parse the arguments nicely */
 	while((ch = getopt(argc, argv, "d:f:p:X")) != -1)
 	{
 		switch(ch)
 		{
 		/*  Don't daemonize  */
-    case 'd':
-      {
-        char* t;
-
-        daemonize = 0;
-        g_debuglevel = strtol(optarg, &t, 10);
-        if(*t || g_debuglevel > 4)
-          errx(1, "invalid debug log level");
-        g_debuglevel += LOG_ERR;
-      }
-      break;
-
-    /* The configuration file */
-    case 'f':
-      conf = optarg;
-      break;
-
-    /* Write out a pid file */
-    case 'p':
-      pidfile = optarg;
-      break;
-
-    /* Process console input instead */
+        case 'd':
+        {
+            char* t;
+            daemonize = 0;
+            g_debuglevel = strtol(optarg, &t, 10);
+            if(*t || g_debuglevel > 4)
+                errx(1, "invalid debug log level");
+            g_debuglevel += LOG_ERR;
+        }
+        break;
+
+        /* The configuration file */
+        case 'f':
+            conf = optarg;
+            break;
+
+        /* Write out a pid file */
+        case 'p':
+            pidfile = optarg;
+            break;
+
+        /* Process console input instead */
 		case 'X':
-      g_console = 1;
-      daemonize = 0;
-			break;
+            g_console = 1;
+            daemonize = 0;
+            break;
 
-    /* Usage information */
-		case '?':
-		default:
-			return usage();
-			break;
-		}
-	}
+        /* Usage information */
+        case '?':
+        default:
+            return usage();
+            break;
+        }
+    }
 
-	argc -= optind;
-	argv += optind;
+    argc -= optind;
+    argv += optind;
 
-  if(argc != 0)
-    return usage();
+    if(argc != 0)
+        return usage();
 
-  ha_messagex(LOG_DEBUG, "starting up...");
+    ha_messagex(NULL, LOG_DEBUG, "starting up...");
 
-  /* From here on out we need to quit in an orderly fashion */
+    /* From here on out we need to quit in an orderly fashion */
 
-  /* Run global initialization on all handlers */
-  for(i = 0; i < countof(g_handlerlist); i++)
-  {
-    if(g_handlerlist[i]->f_init)
+    /* Run global initialization on all handlers */
+    for(i = 0; i < countof(g_handlerlist); i++)
     {
-      if((r = (g_handlerlist[i]->f_init)(NULL)) == -1)
-        goto finally;
+        if(g_handlerlist[i]->f_init)
+        {
+            if((r = (g_handlerlist[i]->f_init)(NULL)) == -1)
+                goto finally;
+        }
     }
-  }
 
-  /* Initialize our configuration buffer */
-  ha_bufinit(&cbuf);
+    /* Initialize our configuration buffer */
+    ha_bufinit(&cbuf);
 
 
-  /* Parse the configuration */
-  config_parse(conf, &cbuf);
+    /* Parse the configuration */
+    config_parse(conf, &cbuf);
 
 
-  if(!g_console)
-  {
-    /* Create the thread buffers */
-    threads = (httpauth_thread_t*)calloc(g_maxthreads, sizeof(httpauth_thread_t));
-    if(!threads)
-      errx(1, "out of memory");
+    if(!g_console)
+    {
+        /* Create the thread buffers */
+        threads = (httpauth_thread_t*)calloc(g_maxthreads, sizeof(httpauth_thread_t));
+        if(!threads)
+            errx(1, "out of memory");
 
-    /* Get the socket type */
-    if(sock_any_pton(g_socket, &sany, DEFAULT_PORT) == -1)
-      errx(1, "invalid socket name or ip: %s", g_socket);
+        /* TODO: Import the new sock_any from clamsmtp */
+        /* Get the socket type */
+        if(sock_any_pton(g_socket, &sany, DEFAULT_PORT) == -1)
+            errx(1, "invalid socket name or ip: %s", g_socket);
 
-    /* Create the socket */
-    sock = socket(SANY_TYPE(sany), SOCK_STREAM, 0);
-    if(sock < 0)
-      err(1, "couldn't open socket");
+        /* Create the socket */
+        sock = socket(SANY_TYPE(sany), SOCK_STREAM, 0);
+        if(sock < 0)
+            err(1, "couldn't open socket");
 
-    /* Unlink the socket file if it exists */
-    /* TODO: Is this safe? */
-    unlink(g_socket);
+        /* Unlink the socket file if it exists */
+        /* TODO: Is this safe? */
+        unlink(g_socket);
 
-    if(bind(sock, &SANY_ADDR(sany), SANY_LEN(sany)) != 0)
-      err(1, "couldn't bind to address: %s", g_socket);
+        if(bind(sock, &SANY_ADDR(sany), SANY_LEN(sany)) != 0)
+            err(1, "couldn't bind to address: %s", g_socket);
 
-    /* Let 5 connections queue up */
-    if(listen(sock, 5) != 0)
-      err(1, "couldn't listen on socket");
+        /* Let 5 connections queue up */
+        if(listen(sock, 5) != 0)
+            err(1, "couldn't listen on socket");
 
-    ha_messagex(LOG_DEBUG, "created socket: %s", g_socket);
-  }
+        ha_messagex(NULL, LOG_DEBUG, "created socket: %s", g_socket);
+    }
 
-  /* Initialize all the handlers */
-  for(h = g_handlers; h; h = h->next)
-  {
-    if(h->ctx.handler->f_init)
+    /* Initialize all the handlers */
+    for(h = g_handlers; h; h = h->next)
     {
-      if((r = (h->ctx.handler->f_init)(&(h->ctx))) == -1)
-        goto finally;
+        if(h->ctx.handler->f_init)
+        {
+            if((r = (h->ctx.handler->f_init)(&(h->ctx))) == -1)
+                goto finally;
+        }
     }
-  }
-
-
-  /* This is for debugging the internal processes */
-  if(g_console)
-  {
-    ha_messagex(LOG_DEBUG, "processing from console");
-    r = httpauth_processor(0, 1);
-    goto finally;
-  }
 
 
-  /* This is the daemon section of the code */
-  else
-  {
-    if(daemonize)
+    /* This is for debugging the internal processes */
+    if(g_console)
     {
-      /* Fork a daemon nicely here */
-      if(daemon(0, 0) == -1)
-      {
-        ha_message(LOG_ERR, "couldn't run httpauth as daemon");
-        exit(1);
-      }
-
-      ha_messagex(LOG_DEBUG, "running as a daemon");
-      g_daemonized = 1;
+        ha_messagex(NULL, LOG_DEBUG, "processing from console");
+        r = httpauth_processor(0, 1);
+        goto finally;
     }
 
-    writepid(pidfile);
 
-    /* Handle some signals */
-    signal(SIGPIPE, SIG_IGN);
-    signal(SIGHUP, SIG_IGN);
-    signal(SIGINT,  on_quit);
-    signal(SIGTERM, on_quit);
+    /* This is the daemon section of the code */
+    else
+    {
+        if(daemonize)
+        {
+            /* Fork a daemon nicely here */
+            if(daemon(0, 0) == -1)
+            {
+                ha_message(NULL, LOG_ERR, "couldn't run httpauth as daemon");
+                exit(1);
+            }
 
-    siginterrupt(SIGINT, 1);
-    siginterrupt(SIGTERM, 1);
+            ha_messagex(NULL, LOG_DEBUG, "running as a daemon");
+            g_daemonized = 1;
+        }
 
-    /* Open the system log */
-    openlog("httpauthd", 0, LOG_AUTHPRIV);
+        writepid(pidfile);
 
-    ha_messagex(LOG_DEBUG, "accepting connections");
+        /* Handle some signals */
+        signal(SIGPIPE, SIG_IGN);
+        signal(SIGHUP, SIG_IGN);
+        signal(SIGINT,  on_quit);
+        signal(SIGTERM, on_quit);
 
-    /* Now loop and accept the connections */
-    while(!g_quit)
-    {
-      int fd;
+        siginterrupt(SIGINT, 1);
+        siginterrupt(SIGTERM, 1);
 
-      fd = accept(sock, NULL, NULL);
-      if(fd == -1)
-      {
-        switch(errno)
-        {
-        case EINTR:
-        case EAGAIN:
-          break;
+        /* Open the system log */
+        openlog("httpauthd", 0, LOG_AUTHPRIV);
 
-        case ECONNABORTED:
-          ha_message(LOG_ERR, "couldn't accept a connection");
-          break;
+        ha_messagex(NULL, LOG_DEBUG, "accepting connections");
 
-        default:
-          ha_message(LOG_ERR, "couldn't accept a connection");
-          g_quit = 1;
-          break;
-        };
+        /* Now loop and accept the connections */
+        while(!g_quit)
+        {
+            int fd;
 
-        if(g_quit)
-          break;
+            fd = accept(sock, NULL, NULL);
+            if(fd == -1)
+            {
+                switch(errno)
+                {
+                case EINTR:
+                case EAGAIN:
+                    break;
+
+                case ECONNABORTED:
+                    ha_message(NULL, LOG_ERR, "couldn't accept a connection");
+                    break;
+
+                default:
+                    ha_message(NULL, LOG_ERR, "couldn't accept a connection");
+                    g_quit = 1;
+                    break;
+                };
+
+                if(g_quit)
+                    break;
+
+                continue;
+            }
 
-        continue;
-      }
+            memset(&sany, 0, sizeof(sany));
+            SANY_LEN(sany) = sizeof(sany);
 
-      memset(&sany, 0, sizeof(sany));
-      SANY_LEN(sany) = sizeof(sany);
+            /* TODO: Move this code into the thread */
+            /* Get the peer name */
+            if(getpeername(fd, &SANY_ADDR(sany), &SANY_LEN(sany)) == -1 ||
+               sock_any_ntop(&sany, peername, MAXPATHLEN, SANY_OPT_NOPORT) == -1)
+                ha_messagex(NULL, LOG_WARNING, "%d: couldn't get peer address", fd);
+            else
+                ha_messagex(NULL, LOG_INFO, "%d: accepted connection from: %s", fd, peername);
 
-      /* Get the peer name */
-      if(getpeername(fd, &SANY_ADDR(sany), &SANY_LEN(sany)) == -1 ||
-         sock_any_ntop(&sany, peername, MAXPATHLEN, SANY_OPT_NOPORT) == -1)
-        ha_messagex(LOG_WARNING, "%d: couldn't get peer address", fd);
-      else
-        ha_messagex(LOG_INFO, "%d: accepted connection from: %s", fd, peername);
+            /* Look for thread and also clean up others */
+            for(i = 0; i < g_maxthreads; i++)
+            {
+                /* Clean up quit threads */
+                if(threads[i].tid != 0)
+                {
+                    if(threads[i].fd == -1)
+                    {
+                        ha_messagex(NULL, LOG_DEBUG, "cleaning up completed thread");
+                        pthread_join(threads[i].tid, NULL);
+                        threads[i].tid = 0;
+                    }
+                }
+
+                /* Start a new thread if neccessary */
+                if(fd != -1 && threads[i].tid == 0)
+                {
+                    threads[i].fd = fd;
+                    r = pthread_create(&(threads[i].tid), NULL, httpauth_thread,
+                                       (void*)(threads + i));
+                    if(r != 0)
+                    {
+                        errno = r;
+                        ha_message(NULL, LOG_ERR, "couldn't create thread");
+                        g_quit = 1;
+                        break;
+                    }
+
+                    ha_messagex(NULL, LOG_DEBUG, "%d: created thread for connection", fd);
+                    fd = -1;
+                    break;
+                }
+            }
 
-      /* Look for thread and also clean up others */
-      for(i = 0; i < g_maxthreads; i++)
-      {
-        /* Clean up quit threads */
-        if(threads[i].tid != 0)
-        {
-          if(threads[i].fd == -1)
-          {
-            ha_messagex(LOG_DEBUG, "cleaning up completed thread");
-            pthread_join(threads[i].tid, NULL);
-            threads[i].tid = 0;
-          }
+            /* Check to make sure we have a thread */
+            if(fd != -1)
+            {
+                ha_messagex(NULL, LOG_ERR, "too many connections open (max %d)", g_maxthreads);
+                httpauth_respond(NULL, fd, HA_SERVER_ERROR, 0, "too many connections");
+                shutdown(fd, SHUT_RDWR);
+            }
         }
 
-        /* Start a new thread if neccessary */
-        if(fd != -1 && threads[i].tid == 0)
+        ha_messagex(NULL, LOG_INFO, "waiting for threads to quit");
+
+        /* Quit all threads here */
+        for(i = 0; i < g_maxthreads; i++)
         {
-          threads[i].fd = fd;
-          r = pthread_create(&(threads[i].tid), NULL, httpauth_thread,
-                             (void*)(threads + i));
-          if(r != 0)
-          {
-            errno = r;
-            ha_message(LOG_ERR, "couldn't create thread");
-            g_quit = 1;
-            break;
-          }
+            /* Clean up quit threads */
+            if(threads[i].tid != 0)
+            {
+                if(threads[i].fd != -1)
+                    shutdown(threads[i].fd, SHUT_RDWR);
 
-          ha_messagex(LOG_DEBUG, "%d: created thread for connection", fd);
-          fd = -1;
-          break;
+                pthread_join(threads[i].tid, NULL);
+            }
         }
-      }
-
-      /* Check to make sure we have a thread */
-      if(fd != -1)
-      {
-        ha_messagex(LOG_ERR, "too many connections open (max %d)", g_maxthreads);
-        httpauth_respond(fd, HA_SERVER_ERROR, 0, "too many connections");
-        shutdown(fd, SHUT_RDWR);
-      }
-    }
-
-    ha_messagex(LOG_INFO, "waiting for threads to quit");
 
-    /* Quit all threads here */
-    for(i = 0; i < g_maxthreads; i++)
-    {
-      /* Clean up quit threads */
-      if(threads[i].tid != 0)
-      {
-        if(threads[i].fd != -1)
-          shutdown(threads[i].fd, SHUT_RDWR);
-
-        pthread_join(threads[i].tid, NULL);
-      }
+        r = 0;
     }
 
-    r = 0;
-  }
-
 finally:
 
-  ha_messagex(LOG_DEBUG, "performing cleanup...");
+    ha_messagex(NULL, LOG_DEBUG, "performing cleanup...");
 
-  /* Uninitialize all the handlers */
-  for(h = g_handlers; h; h = h->next)
-  {
-    if(h->ctx.handler->f_destroy)
-      (h->ctx.handler->f_destroy)(&(h->ctx));
-  }
-
-  /* Run global destroy for all handlers */
-  for(i = 0; i < countof(g_handlerlist); i++)
-  {
-    if(g_handlerlist[i]->f_destroy)
-      (g_handlerlist[i]->f_destroy)(NULL);
-  }
+    /* Uninitialize all the handlers */
+    for(h = g_handlers; h; h = h->next)
+    {
+        if(h->ctx.handler->f_destroy)
+            (h->ctx.handler->f_destroy)(&(h->ctx));
+    }
 
-  /* Clean up memory and stuff */
-  ha_buffree(&cbuf);
+    /* Run global destroy for all handlers */
+    for(i = 0; i < countof(g_handlerlist); i++)
+    {
+        if(g_handlerlist[i]->f_destroy)
+           (g_handlerlist[i]->f_destroy)(NULL);
+    }
 
-  /* Close the mutex */
-  pthread_mutex_destroy(&g_mutex);
-  pthread_mutexattr_destroy(&g_mutexattr);
+    /* Clean up memory and stuff */
+    ha_buffree(&cbuf);
 
-  ha_messagex(LOG_DEBUG, "stopped");
+    /* Close the mutex */
+    pthread_mutex_destroy(&g_mutex);
+    pthread_mutexattr_destroy(&g_mutexattr);
 
-  return r == -1 ? 1 : 0;
+    ha_messagex(NULL, LOG_DEBUG, "stopped");
+    return r == -1 ? 1 : 0;
 }
 
 static void on_quit(int signal)
 {
-  g_quit = 1;
-  fprintf(stderr, "httpauthd: got signal to quit\n");
+    g_quit = 1;
+    fprintf(stderr, "httpauthd: got signal to quit\n");
 }
 
 static int usage()
 {
-  fprintf(stderr, "usage: httpauthd [-d level] [-X] [-p pidfile] [-f conffile]\n");
-  return 2;
+    fprintf(stderr, "usage: httpauthd [-d level] [-X] [-p pidfile] [-f conffile]\n");
+    return 2;
 }
 
 static void writepid(const char* pidfile)
 {
-  FILE* f = fopen(pidfile, "w");
-  if(f == NULL)
-  {
-    warnx("couldn't open pid file: %s", pidfile);
-  }
-  else
-  {
-    fprintf(f, "%d\n", (int)getpid());
-
-    if(ferror(f))
-      warnx("couldn't write to pid file: %s", pidfile);
-
-    fclose(f);
-  }
+    FILE* f = fopen(pidfile, "w");
+    if(f == NULL)
+    {
+        warnx("couldn't open pid file: %s", pidfile);
+    }
+    else
+    {
+        fprintf(f, "%d\n", (int)getpid());
+
+        if(ferror(f))
+            warnx("couldn't write to pid file: %s", pidfile);
+
+        fclose(f);
+    }
 }
 
 static void* httpauth_thread(void* arg)
 {
-  httpauth_thread_t* thread = (httpauth_thread_t*)arg;
-  int r;
+    httpauth_thread_t* thread = (httpauth_thread_t*)arg;
+    int r;
 
-  siginterrupt(SIGINT, 1);
-  siginterrupt(SIGTERM, 1);
-
-  ASSERT(thread);
-  ASSERT(thread->fd != -1);
+    siginterrupt(SIGINT, 1);
+    siginterrupt(SIGTERM, 1);
 
-  /* call the processor */
-  r = httpauth_processor(thread->fd, thread->fd);
+    ASSERT(thread);
+    ASSERT(thread->fd != -1);
 
-  ha_messagex(LOG_INFO, "%d: closed connection", thread->fd);
+    /* call the processor */
+    r = httpauth_processor(thread->fd, thread->fd);
 
-  /* mark this as done */
-  thread->fd = -1;
+    /* TODO: Move this to more appropriate place (where we have a req) */
+    ha_messagex(NULL, LOG_INFO, "%d: closed connection", thread->fd);
 
-  return (void*)r;
+    /* mark this as done */
+    thread->fd = -1;
+    return (void*)r;
 }
 
 /* -----------------------------------------------------------------------
  * Logging
  */
 
-void log_request(ha_request_t* req, ha_buffer_t* buf, int fd)
+void log_request(ha_request_t* rq)
 {
-  const httpauth_command_t* cmd;
-  const char* t;
-  const char* t2;
-  int i;
+    const httpauth_command_t* cmd;
+    const char* t;
+    const char* t2;
+    int i;
 
-  if(g_debuglevel < LOG_DEBUG)
-    return;
+    if(g_debuglevel < LOG_DEBUG)
+        return;
 
-  if(req->type == REQTYPE_IGNORE || req->type == -1)
-    return;
+    if(rq->req_type == REQTYPE_IGNORE || rq->req_type == -1)
+        return;
 
-  ha_bufcpy(buf, "");
+    ha_bufcpy(rq->buf, "");
 
-  for(i = 0; i < HA_MAX_ARGS; i++)
-  {
-    if(req->args[i])
+    for(i = 0; i < HA_MAX_ARGS; i++)
     {
-      ha_bufjoin(buf);
-      ha_bufmcat(buf, ha_buflen(buf) > 0 ? ", " : "", req->args[i], NULL);
+        if(rq->req_args[i])
+        {
+            ha_bufjoin(rq->buf);
+            ha_bufmcat(rq->buf, ha_buflen(rq->buf) > 0 ? ", " : "", rq->req_args[i], NULL);
+        }
     }
-  }
 
-  t = ha_bufdata(buf);
+    t = ha_bufdata(rq->buf);
+    t2 = NULL;
 
-  t2 = NULL;
-
-  /* Figure out which command it is */
-  for(cmd = kCommands; cmd->name; cmd++)
-  {
-    if(cmd->code == req->type)
+    /* Figure out which command it is */
+    for(cmd = kCommands; cmd->name; cmd++)
     {
-      t2 = cmd->name;
-      break;
+        if(cmd->code == rq->req_type)
+        {
+            t2 = cmd->name;
+            break;
+        }
     }
-  }
 
-  ASSERT(t2);
+    ASSERT(t2);
 
-  ha_messagex(LOG_DEBUG, "%d: received request: "
-                         "[ type: %s / args: %s ]", fd, t2, t);
+    ha_messagex(rq, LOG_DEBUG, "received request: [ type: %s / args: %s ]", t2, t);
 
-  for(i = 0; i < HA_MAX_HEADERS; i++)
-  {
-    if(req->headers[i].name)
+    for(i = 0; i < HA_MAX_HEADERS; i++)
     {
-      ASSERT(req->headers[i].data);
-      ha_messagex(LOG_DEBUG, "%d: received header: [ %s: %s ]", fd,
-              req->headers[i].name, req->headers[i].data);
+        if(rq->req_headers[i].name)
+        {
+            ASSERT(rq->req_headers[i].data);
+            ha_messagex(rq, LOG_DEBUG, "received header: [ %s: %s ]",
+                        rq->req_headers[i].name, rq->req_headers[i].data);
+        }
     }
-  }
 }
 
-void log_response(ha_response_t* resp, int fd)
+void log_response(ha_request_t* rq)
 {
-  int i;
+    int i;
 
-  if(g_debuglevel < LOG_DEBUG)
-    return;
+    if(g_debuglevel < LOG_DEBUG)
+        return;
 
-  ha_messagex(LOG_DEBUG, "%d: sending response: "
-                         "[ code: 200 / ccode: %d / detail: %s ]", fd,
-                         resp->code, resp->detail ? resp->detail : "");
+    ha_messagex(rq, LOG_DEBUG, "sending response: [ code: 200 / ccode: %d / detail: %s ]",
+                rq->resp_code, rq->resp_detail ? rq->resp_detail : "");
 
-  for(i = 0; i < HA_MAX_HEADERS; i++)
-  {
-    if(resp->headers[i].name)
+    for(i = 0; i < HA_MAX_HEADERS; i++)
     {
-      ASSERT(resp->headers[i].data);
-      ha_messagex(LOG_DEBUG, "%d: sending header: [ %s: %s ]", fd,
-              resp->headers[i].name, resp->headers[i].data);
+        if(rq->resp_headers[i].name)
+        {
+            ASSERT(rq->resp_headers[i].data);
+            ha_messagex(rq, LOG_DEBUG, "sending header: [ %s: %s ]",
+                        rq->resp_headers[i].name, rq->resp_headers[i].data);
+        }
     }
-  }
 }
 
-void log_respcode(int code, const char* msg, int fd)
+void log_respcode(ha_request_t* rq, int code, const char* msg)
 {
-  if(g_debuglevel < LOG_DEBUG)
-    return;
+    if(g_debuglevel < LOG_DEBUG)
+        return;
 
-  ha_messagex(LOG_DEBUG, "%d: sending response: "
-                         "[ code: %d / detail: %s ]", fd, code, msg ? msg : "");
+    ha_messagex(rq, LOG_DEBUG, "sending response: [ code: %d / detail: %s ]",
+                code, msg ? msg : "");
 }
 
 /* -----------------------------------------------------------------------
  * Command Parsing and Handling
  */
 
-static int httpauth_read(int ifd, ha_request_t* req,
-                         ha_buffer_t* buf)
+static int httpauth_read(ha_request_t* rq, int ifd)
 {
-  const httpauth_command_t* cmd;
-  char* t;
-  int i, r;
-  int more = 1;
+    const httpauth_command_t* cmd;
+    char* t;
+    int i, r;
+    int more = 1;
 
-  ASSERT(req && buf);
-  ASSERT(ifd != -1);
+    ASSERT(r);
+    ASSERT(ifd != -1);
 
-  /* Clean up the request header */
-  req->type = -1;
-  memset(req->args, 0, sizeof(req->args));
-  memset(req->headers, 0, sizeof(req->headers));
+    /* Clean up the request header */
+    rq->req_type = -1;
+    memset(rq->req_args, 0, sizeof(rq->req_args));
+    memset(rq->req_headers, 0, sizeof(rq->req_headers));
 
 
-  /* This guarantees a bit of memory allocated, and resets buffer */
-  ha_bufreset(buf);
+    /* This guarantees a bit of memory allocated, and resets buffer */
+    ha_bufreset(rq->buf);
 
-  r = ha_bufreadline(ifd, buf);
-  if(r == -1)
-    return -1;
+    r = ha_bufreadline(ifd, rq->buf);
+    if(r == -1)
+        return -1;
 
-  /* Check if this is the last line */
-  if(r == 0)
-    more = 0;
+    /* Check if this is the last line */
+    if(r == 0)
+        more = 0;
 
-  /* Check to see if we got anything */
-  if(ha_buflen(buf) == 0)
-  {
-    req->type = REQTYPE_IGNORE;
-    return more;
-  }
+    /* Check to see if we got anything */
+    if(ha_buflen(rq->buf) == 0)
+    {
+        rq->req_type = REQTYPE_IGNORE;
+        return more;
+    }
 
-  /* Find the first space in the line */
-  t = ha_bufparseword(buf, " \t");
+    /* Find the first space in the line */
+    t = ha_bufparseword(rq->buf, " \t");
 
-  if(t)
-  {
-    /* Figure out which command it is */
-    for(cmd = kCommands; cmd->name; cmd++)
+    if(t)
     {
-      if(strcasecmp(t, cmd->name) == 0)
-      {
-        req->type = cmd->code;
-        break;
-      }
+        /* Figure out which command it is */
+        for(cmd = kCommands; cmd->name; cmd++)
+        {
+            if(strcasecmp(t, cmd->name) == 0)
+            {
+                rq->req_type = cmd->code;
+                break;
+            }
+        }
     }
-  }
-
-  else
-  {
-    req->type = REQTYPE_IGNORE;
-    return more;
-  }
 
-  /* Check for invalid command */
-  if(req->type == -1)
-    return more;
+    else
+    {
+        rq->req_type = REQTYPE_IGNORE;
+        return more;
+    }
 
-  /* Now parse the arguments if any */
-  for(i = 0; i < cmd->word_args; i++)
-    req->args[i] = ha_bufparseword(buf, " \t");
+    /* Check for invalid command */
+    if(rq->req_type == -1)
+        return more;
 
-  /* Does it want the rest as one argument? */
-  if(cmd->rest_arg)
-    req->args[i] = ha_bufparseline(buf, 1);
+    /* Now parse the arguments if any */
+    for(i = 0; i < cmd->word_args; i++)
+        rq->req_args[i] = ha_bufparseword(rq->buf, " \t");
 
+    /* Does it want the rest as one argument? */
+    if(cmd->rest_arg)
+        rq->req_args[i] = ha_bufparseline(rq->buf, 1);
 
-  /* Now skip anything else we have in the buffer */
-  ha_bufskip(buf);
 
+    /* Now skip anything else we have in the buffer */
+    ha_bufskip(rq->buf);
 
-  /* If we need headers, then read them now */
-  if(cmd->headers)
-  {
-    const char** head;  /* For iterating through valid headers */
-    int valid = 0;      /* The last header was valid */
-    i = 0;              /* The header we're working with */
 
-    for(;;)
+    /* If we need headers, then read them now */
+    if(cmd->headers)
     {
-      /* Make sure we have more data */
-      if(!more)
-        break;
-
-      r = ha_bufreadline(ifd, buf);
-      if(r == -1)
-        return -1;
-
-      /* Check if this is the last line */
-      if(r == 0)
-        more = 0;
-
-      /* An empty line is the end of the headers */
-      if(ha_buflen(buf) == 0)
-        break;
+        const char** head;  /* For iterating through valid headers */
+        int valid = 0;      /* The last header was valid */
+        i = 0;              /* The header we're working with */
 
-      /* Check if the header starts with a space */
-      if(isspace(ha_bufchar(buf)))
-      {
-        /* Skip all the spaces */
-        while(ha_buflen(buf) > 0 && isspace(ha_bufchar(buf)))
-          ha_bufeat(buf);
+        for(;;)
+        {
+            /* Make sure we have more data */
+            if(!more)
+                break;
 
-        /* An empty line is the end of the headers
-            even if that line has spaces on it */
-        if(ha_buflen(buf) == 0)
-          break;
+            r = ha_bufreadline(ifd, rq->buf);
+            if(r == -1)
+                return -1;
 
-        /* A header that has data on it but started
-          with a space continues the previous header */
-        if(valid && i > 0)
-        {
-          t = ha_bufparseline(buf, 0);
-          if(t)
-          {
-            char* t2 = (char*)req->headers[i - 1].data + strlen(req->headers[i - 1].data);
-
-            /* Fill the area between the end of the last
-              valid header and this with spaces */
-            memset(t2, ' ', t - t2);
-          }
-        }
-      }
-      else
-      {
-        if(i < HA_MAX_HEADERS)
-        {
-          t = ha_bufparseword(buf, ":");
+            /* Check if this is the last line */
+            if(r == 0)
+                more = 0;
 
-          if(t)
-          {
-            for(head = cmd->headers; ; head++)
-            {
-              if(!(*head))
-              {
-                t = NULL;
+            /* An empty line is the end of the headers */
+            if(ha_buflen(rq->buf) == 0)
                 break;
-              }
 
-              if(strcasecmp(t, *head) == 0)
-                break;
+            /* Check if the header starts with a space */
+            if(isspace(ha_bufchar(rq->buf)))
+            {
+                /* Skip all the spaces */
+                while(ha_buflen(rq->buf) > 0 && isspace(ha_bufchar(rq->buf)))
+                    ha_bufeat(rq->buf);
+
+                /* An empty line is the end of the headers
+                   even if that line has spaces on it */
+                if(ha_buflen(rq->buf) == 0)
+                    break;
+
+                /* A header that has data on it but started
+                   with a space continues the previous header */
+                if(valid && i > 0)
+                {
+                    t = ha_bufparseline(rq->buf, 0);
+                    if(t)
+                    {
+                        char* t2 = (char*)rq->req_headers[i - 1].data + strlen(rq->req_headers[i - 1].data);
+
+                        /* Fill the area between the end of the last
+                           valid header and this with spaces */
+                        memset(t2, ' ', t - t2);
+                    }
+                }
+            }
+            else
+            {
+                if(i < HA_MAX_HEADERS)
+                {
+                    t = ha_bufparseword(rq->buf, ":");
+
+                    if(t)
+                    {
+                        for(head = cmd->headers; ; head++)
+                        {
+                            if(!(*head))
+                            {
+                                t = NULL;
+                                break;
+                            }
+
+                            if(strcasecmp(t, *head) == 0)
+                                break;
+                        }
+                    }
+
+                    if(t)
+                    {
+                        rq->req_headers[i].name = t;
+                        rq->req_headers[i].data = ha_bufparseline(rq->buf, 1);
+                        i++;
+                    }
+
+                    valid = (t != NULL) ? 1 : 0;
+                }
             }
-          }
-
-          if(t)
-          {
-            req->headers[i].name = t;
-            req->headers[i].data = ha_bufparseline(buf, 1);
-            i++;
-          }
 
-          valid = (t != NULL) ? 1 : 0;
+            ha_bufskip(rq->buf);
         }
-      }
-
-      ha_bufskip(buf);
     }
-  }
 
-  return more;
+    return more;
 }
 
-static int write_data(int ofd, const char* data)
+static int write_data(ha_request_t* rq, int ofd, const char* data)
 {
-  int r;
+    int r;
 
-  ASSERT(data);
-  ASSERT(ofd != -1);
+    ASSERT(data);
+    ASSERT(ofd != -1);
 
-  while(*data != 0)
-  {
-    r = write(ofd, data, strlen(data));
+    while(*data != 0)
+    {
+        r = write(ofd, data, strlen(data));
 
-    if(r > 0)
-      data += r;
+        if(r > 0)
+            data += r;
 
-    else if(r == -1)
-    {
-      if(errno == EAGAIN)
-        continue;
+        else if(r == -1)
+        {
+            if(errno == EAGAIN)
+                continue;
 
-      /* The other end closed. no message */
-      if(errno != EPIPE)
-        ha_message(LOG_ERR, "couldn't write data");
+            /* The other end closed. no message */
+            if(errno != EPIPE)
+                ha_message(rq, LOG_ERR, "couldn't write data");
 
-      return HA_CRITERROR;
+            return HA_CRITERROR;
+        }
     }
-  }
 
-  return 0;
+    return 0;
 }
 
-static int httpauth_respond(int ofd, int scode, int ccode, const char* msg)
+static int httpauth_respond(ha_request_t* rq, int ofd, int scode, int ccode, const char* msg)
 {
-  char num[16];
+    char num[16];
 
-  ASSERT(ofd != -1);
-  ASSERT(scode > 99 && scode < 1000);
-  ASSERT(ccode == 0 || (ccode > 99 && ccode < 1000));
+    ASSERT(ofd != -1);
+    ASSERT(scode > 99 && scode < 1000);
+    ASSERT(ccode == 0 || (ccode > 99 && ccode < 1000));
 
-  /* Can only have a client code when server code is 200 */
-  ASSERT(ccode == 0 || scode == HA_SERVER_OK);
+    /* Can only have a client code when server code is 200 */
+    ASSERT(ccode == 0 || scode == HA_SERVER_OK);
 
-  sprintf(num, "%d ", scode);
+    sprintf(num, "%d ", scode);
 
-  if(write_data(ofd, num) < 0)
-    return HA_CRITERROR;
+    if(write_data(rq, ofd, num) < 0)
+        return HA_CRITERROR;
 
-  if(ccode != 0)
-  {
-    sprintf(num, "%d ", ccode);
+    if(ccode != 0)
+    {
+        sprintf(num, "%d ", ccode);
 
-    if(write_data(ofd, num) < 0)
-      return HA_CRITERROR;
-  }
+        if(write_data(rq, ofd, num) < 0)
+            return HA_CRITERROR;
+    }
 
-  if(!msg)
-  {
-    switch(scode)
+    if(!msg)
     {
-    case HA_SERVER_ACCEPTED:
-      msg = "Accepted";
-      break;
-    case HA_SERVER_ERROR:
-      msg = "Internal Error ";
-      break;
-    case HA_SERVER_BADREQ:
-      msg = "Bad Request ";
-      break;
-    case HA_SERVER_DECLINE:
-      msg = "Unauthorized ";
-      break;
-    default:
-      msg = NULL;
-      break;
-    };
-  }
+        switch(scode)
+        {
+        case HA_SERVER_ACCEPTED:
+            msg = "Accepted";
+            break;
+        case HA_SERVER_ERROR:
+            msg = "Internal Error ";
+            break;
+        case HA_SERVER_BADREQ:
+            msg = "Bad Request ";
+            break;
+        case HA_SERVER_DECLINE:
+            msg = "Unauthorized ";
+            break;
+        default:
+            msg = NULL;
+            break;
+        };
+    }
 
-  if(msg && write_data(ofd, msg) < 0)
-    return HA_CRITERROR;
+    if(msg && write_data(rq, ofd, msg) < 0)
+        return HA_CRITERROR;
 
-  /* When the client code is 0, then caller should log */
-  if(ccode == 0)
-    log_respcode(scode, msg, ofd);
+    /* When the client code is 0, then caller should log */
+    if(ccode == 0)
+        log_respcode(rq, scode, msg);
 
-  return write_data(ofd, "\n");
+    return write_data(rq, ofd, "\n");
 }
 
 const char kHeaderDelimiter[] = ": ";
 
-static int httpauth_write(int ofd, ha_response_t* resp)
+static int httpauth_write(ha_request_t* rq, int ofd)
 {
-	int i;
-  int wrote = 0;
+    int i;
+    int wrote = 0;
 
-  ASSERT(ofd != -1);
-  ASSERT(resp);
+    ASSERT(ofd != -1);
+    ASSERT(rq);
 
-  if(httpauth_respond(ofd, HA_SERVER_OK, resp->code, resp->detail) < 0)
-    return HA_CRITERROR;
+    if(httpauth_respond(rq, ofd, HA_SERVER_OK, rq->resp_code, rq->resp_detail) < 0)
+        return HA_CRITERROR;
 
-  for(i = 0; i < HA_MAX_HEADERS; i++)
-  {
-	  if(resp->headers[i].name)
+    for(i = 0; i < HA_MAX_HEADERS; i++)
     {
-      if(write_data(ofd, resp->headers[i].name) == -1 ||
-         write_data(ofd, kHeaderDelimiter) == -1 ||
-         write_data(ofd, resp->headers[i].data) == -1 ||
-         write_data(ofd, "\n") == -1)
-        return -1;
+        if(rq->resp_headers[i].name)
+        {
+            if(write_data(rq, ofd, rq->resp_headers[i].name) == -1 ||
+               write_data(rq, ofd, kHeaderDelimiter) == -1 ||
+               write_data(rq, ofd, rq->resp_headers[i].data) == -1 ||
+               write_data(rq, ofd, "\n") == -1)
+                return -1;
 
-      wrote = 1;
+            wrote = 1;
+        }
     }
-  }
 
-  if(write_data(ofd, "\n") == -1)
-    return -1;
+    if(write_data(rq, ofd, "\n") == -1)
+        return -1;
 
-  log_response(resp, ofd);
+    log_response(rq);
 
-  return 0;
+    return 0;
 }
 
-static int httpauth_error(int ofd, int r)
+static int httpauth_error(ha_request_t* rq, int ofd, int r)
 {
-  int scode = 0;
-  const char* msg = NULL;
+    int scode = 0;
+    const char* msg = NULL;
 
-  ASSERT(r < 0);
+    ASSERT(r < 0);
 
-  switch(r)
-  {
-  case HA_BADREQ:
-    scode = HA_SERVER_BADREQ;
-    break;
+    switch(r)
+    {
+    case HA_BADREQ:
+        scode = HA_SERVER_BADREQ;
+        break;
 
-  case HA_CRITERROR:
-    msg = "Critical Error";
-    /* fall through */
+    case HA_CRITERROR:
+        msg = "Critical Error";
+        /* fall through */
 
-  case HA_FAILED:
-    scode = HA_SERVER_ERROR;
-    break;
+    case HA_FAILED:
+        scode = HA_SERVER_ERROR;
+        break;
 
-  default:
-    ASSERT(0 && "invalid error code");
-    break;
-  }
+    default:
+        ASSERT(0 && "invalid error code");
+        break;
+    };
 
-  return httpauth_respond(ofd, scode, 0, msg);
+    return httpauth_respond(rq, ofd, scode, 0, msg);
 }
 
-static int httpauth_ready(int ofd, ha_buffer_t* buf)
+static int httpauth_ready(ha_request_t* rq, int ofd)
 {
-  const char* t;
-  httpauth_loaded_t* h;
+    const char* t;
+    httpauth_loaded_t* h;
 
-  ASSERT(ofd != -1);
-  ASSERT(buf);
+    ASSERT(ofd != -1);
+    ASSERT(rq);
 
-  /* We send a ready banner to our client */
+    /* We send a ready banner to our client */
 
-  if(ha_buferr(buf))
-    return httpauth_error(ofd, HA_CRITERROR);
-
-  else
-    return httpauth_respond(ofd, HA_SERVER_READY, 0, "HTTPAUTH/1.0");
+    if(ha_buferr(rq->buf))
+        return httpauth_error(rq, ofd, HA_CRITERROR);
 
+    else
+        return httpauth_respond(rq, ofd, HA_SERVER_READY, 0, "HTTPAUTH/1.0");
 }
 
-static int httpauth_auth(int ofd, ha_request_t* req, ha_response_t* resp)
+static int httpauth_auth(ha_request_t* rq, int ofd)
 {
-  int r;
-
-  ASSERT(req && resp);
-
-  if(!req->context)
-  {
-    ha_messagex(LOG_ERR, "no auth handler set");
-    return httpauth_respond(ofd, HA_SERVER_BADREQ, 0, "No Auth Handler Set");
-  }
-
-  /* Clear out our response */
-  resp->code = -1;
-  resp->detail = NULL;
-  memset(resp->headers, 0, sizeof(resp->headers));
-  ASSERT(resp->buf != NULL);
-
-  /* Check our connection argument */
-  if(!req->args[AUTH_ARG_CONN] || !(req->args[AUTH_ARG_CONN][0]))
-  {
-    ha_messagex(LOG_ERR, "missing connection ID in request");
-    return httpauth_respond(ofd, HA_SERVER_BADREQ, 0, "Missing Connection ID");
-  }
-
-  /* Check our uri argument */
-  if(!req->args[AUTH_ARG_URI] || !(req->args[AUTH_ARG_URI][0]))
-  {
-    ha_messagex(LOG_ERR, "missing URI in request");
-    return httpauth_respond(ofd, HA_SERVER_BADREQ, 0, "Missing URI");
-  }
-
-  /* Check our connection arguments */
-  if(!req->args[AUTH_ARG_METHOD] || !(req->args[AUTH_ARG_METHOD][0]))
-  {
-    ha_messagex(LOG_ERR, "missing HTTP method in request");
-    return httpauth_respond(ofd, HA_SERVER_BADREQ, 0, "Missing HTTP Method");
-  }
-
-  ASSERT(req->context->handler && req->context->handler->f_process);
-  r = (req->context->handler->f_process)(req, resp);
-  if(r < 0)
-    return r;
-
-  if(httpauth_write(ofd, resp) < 0)
-    return HA_CRITERROR;
-
-  return HA_OK;
+    int r;
+
+    ASSERT(rq);
+
+    if(!rq->context)
+    {
+        ha_messagex(rq, LOG_ERR, "no auth handler set");
+        return httpauth_respond(rq, ofd, HA_SERVER_BADREQ, 0, "No Auth Handler Set");
+    }
+
+    /* Clear out our response */
+    rq->resp_code = -1;
+    rq->resp_detail = NULL;
+    memset(rq->resp_headers, 0, sizeof(rq->resp_headers));
+
+    /* Check our connection argument */
+    if(!rq->req_args[AUTH_ARG_CONN] || !(rq->req_args[AUTH_ARG_CONN][0]))
+    {
+        ha_messagex(rq, LOG_ERR, "missing connection ID in request");
+        return httpauth_respond(rq, ofd, HA_SERVER_BADREQ, 0, "Missing Connection ID");
+    }
+
+    /* Check our uri argument */
+    if(!rq->req_args[AUTH_ARG_URI] || !(rq->req_args[AUTH_ARG_URI][0]))
+    {
+        ha_messagex(rq, LOG_ERR, "missing URI in request");
+        return httpauth_respond(rq, ofd, HA_SERVER_BADREQ, 0, "Missing URI");
+    }
+
+    /* Check our connection arguments */
+    if(!rq->req_args[AUTH_ARG_METHOD] || !(rq->req_args[AUTH_ARG_METHOD][0]))
+    {
+        ha_messagex(rq, LOG_ERR, "missing HTTP method in request");
+        return httpauth_respond(rq, ofd, HA_SERVER_BADREQ, 0, "Missing HTTP Method");
+    }
+
+    ASSERT(rq->context->handler && rq->context->handler->f_process);
+    r = (rq->context->handler->f_process)(rq);
+    if(r < 0)
+        return r;
+
+    if(httpauth_write(rq, ofd) < 0)
+        return HA_CRITERROR;
+
+    return HA_OK;
 }
 
-static int httpauth_set(int ofd, ha_request_t* req)
+static int httpauth_set(ha_request_t* rq, int ofd)
 {
-  httpauth_loaded_t* h;
-  const char* name = req->args[0];
-  const char* value = req->args[1];
-
-  ASSERT(req);
-
-  /* Check our name argument */
-  if(!name || !*name)
-  {
-    ha_messagex(LOG_ERR, "missing name in SET request");
-    return HA_BADREQ;
-  }
-
-  if(strcasecmp(name, "Domain") == 0)
-  {
-    req->digest_domain = value ? value : "";
-  }
-
-  else if(strcasecmp(name, "Handler") == 0)
-  {
-    if(!value || !*value)
+    httpauth_loaded_t* h;
+    const char* name = rq->req_args[0];
+    const char* value = rq->req_args[1];
+
+    /* Check our name argument */
+    if(!name || !*name)
     {
-      ha_messagex(LOG_ERR, "no auth handler specified in SET request.");
-      return HA_BADREQ;
+        ha_messagex(rq, LOG_ERR, "missing name in SET request");
+        return HA_BADREQ;
     }
 
-    /* Find a handler for this type */
-    for(h = g_handlers; h; h = h->next)
+    if(strcasecmp(name, "Domain") == 0)
     {
-      if(strcasecmp(h->ctx.name, value) == 0)
-      {
-        req->context = &(h->ctx);
-        value = NULL;
-        break;
-      }
+        rq->digest_domain = value ? value : "";
     }
 
-    if(value != NULL)
+    else if(strcasecmp(name, "Handler") == 0)
     {
-      ha_messagex(LOG_ERR, "unknown authentication type: %s", req->args[0]);
-      return httpauth_respond(ofd, HA_SERVER_BADREQ, 0, "Unknown Auth Handler");
+        if(!value || !*value)
+        {
+            ha_messagex(rq, LOG_ERR, "no auth handler specified in SET request.");
+            return HA_BADREQ;
+        }
+
+        /* Find a handler for this type */
+        for(h = g_handlers; h; h = h->next)
+        {
+            if(strcasecmp(h->ctx.name, value) == 0)
+            {
+                rq->context = &(h->ctx);
+                value = NULL;
+                break;
+            }
+        }
+
+        if(value != NULL)
+        {
+            ha_messagex(rq, LOG_ERR, "unknown authentication type: %s", rq->req_args[0]);
+            return httpauth_respond(rq, ofd, HA_SERVER_BADREQ, 0, "Unknown Auth Handler");
+        }
     }
-  }
 
-  else
-  {
-    ha_messagex(LOG_ERR, "bad option in SET request");
-    return HA_BADREQ;
-  }
+    else
+    {
+        ha_messagex(rq, LOG_ERR, "bad option in SET request");
+        return HA_BADREQ;
+    }
 
-  return httpauth_respond(ofd, HA_SERVER_ACCEPTED, 0, NULL);
+    return httpauth_respond(rq, ofd, HA_SERVER_ACCEPTED, 0, NULL);
 }
 
 
 static int httpauth_processor(int ifd, int ofd)
 {
-  ha_buffer_t buf;
-  ha_request_t req;
-  ha_response_t resp;
-  int result = -1;
-  int r;
+    ha_buffer_t buf;
+    ha_request_t rq;
+    int result = -1;
+    int r;
 
-  ASSERT(ifd != -1);
-  ASSERT(ofd != -1);
+    ASSERT(ifd != -1);
+    ASSERT(ofd != -1);
 
-  /* Initialize the memory buffers */
-  ha_bufinit(&buf);
+    /* Initialize the memory buffers */
+    ha_bufinit(&buf);
 
-  memset(&req, 0, sizeof(req));
-  memset(&resp, 0, sizeof(resp));
+    memset(&rq, 0, sizeof(rq));
 
-  /* Set up some context stuff */
-  req.digest_domain = "";
-  req.buf = &buf;
-  resp.buf = &buf;
+    /* Set up some context stuff */
+    rq.digest_domain = "";
+    rq.buf = &buf;
 
 
-  if(httpauth_ready(ofd, &buf) == -1)
-  {
-    result = 1;
-    goto finally;
-  }
+    if(httpauth_ready(&rq, ofd) == -1)
+    {
+        result = 1;
+        goto finally;
+    }
 
-  /* Now loop and handle the commands */
-  while(result == -1)
-  {
-    ha_bufreset(&buf);
+    /* Now loop and handle the commands */
+    while(result == -1)
+    {
+        ha_bufreset(&buf);
 
-    r = httpauth_read(ifd, &req, &buf);
+        r = httpauth_read(&rq, ifd);
 
-    if(ha_buferr(&buf))
-      r = HA_CRITERROR;
+        if(ha_buferr(&buf))
+            r = HA_CRITERROR;
 
-    if(r < 0)
-    {
-      httpauth_error(ofd, r);
-      result = 1;
-      break;
-    }
+        if(r < 0)
+        {
+            httpauth_error(&rq, ofd, r);
+            result = 1;
+            break;
+        }
 
-    log_request(&req, &buf, ifd);
+        log_request(&rq);
 
-    if(r == 0)
-      result = 0;
+        if(r == 0)
+            result = 0;
 
-    switch(req.type)
-    {
-    case REQTYPE_AUTH:
-      r = httpauth_auth(ofd, &req, &resp);
-      break;
+        switch(rq.req_type)
+        {
+        case REQTYPE_AUTH:
+            r = httpauth_auth(&rq, ofd);
+            break;
 
-    case REQTYPE_SET:
-      r = httpauth_set(ofd, &req);
-      break;
+        case REQTYPE_SET:
+            r = httpauth_set(&rq, ofd);
+            break;
 
-    case REQTYPE_QUIT:
-      r = HA_OK;
-      result = 0;
-      break;
+        case REQTYPE_QUIT:
+            r = HA_OK;
+            result = 0;
+            break;
 
-    case REQTYPE_IGNORE:
-      r = HA_FALSE;
-      break;
+        case REQTYPE_IGNORE:
+            r = HA_FALSE;
+            break;
 
-    default:
-      ha_messagex(LOG_WARNING, "%d: received unknown command from client", ifd);
-      r = httpauth_respond(ofd, HA_SERVER_BADREQ, 0, "Unknown command");
-      break;
-    };
+        default:
+            ha_messagex(&rq, LOG_WARNING, "received unknown command from client");
+            r = httpauth_respond(&rq, ofd, HA_SERVER_BADREQ, 0, "Unknown command");
+            break;
+        };
 
-    if(ha_buferr(&buf))
-      r = HA_CRITERROR;
+        if(ha_buferr(&buf))
+            r = HA_CRITERROR;
 
-    if(r < 0)
-    {
-      httpauth_error(ofd, r);
+        if(r < 0)
+        {
+            httpauth_error(&rq, ofd, r);
 
-      if(r == HA_CRITERROR)
-        result = 1;
+            if(r == HA_CRITERROR)
+                result = 1;
+        }
     }
-  }
 
-  if(ifd == ofd)
-    shutdown(ofd, SHUT_RDWR);
-  else
-    close(ofd);
+    if(ifd == ofd)
+    {
+        shutdown(ofd, SHUT_RDWR);
+        close(ofd);
+    }
+    else
+    {
+        close(ifd);
+        close(ofd);
+    }
 
 finally:
-  ha_buffree(&buf);
-
-  return result;
+    ha_buffree(&buf);
+    return result;
 }
 
 /* -----------------------------------------------------------------------
@@ -1129,335 +1122,335 @@ finally:
  */
 
 static ha_context_t* config_addhandler(ha_buffer_t* buf, const char* alias,
-                                ha_handler_t* handler, const ha_context_t* defaults)
+                                       ha_handler_t* handler, const ha_context_t* defaults)
 {
-  httpauth_loaded_t* loaded;
-  int len;
+    httpauth_loaded_t* loaded;
+    int len;
 
-  ASSERT(buf && alias && handler && defaults);
+    ASSERT(buf && alias && handler && defaults);
 
-  len = sizeof(httpauth_loaded_t) + handler->context_size;
+    len = sizeof(httpauth_loaded_t) + handler->context_size;
 
-  loaded = (httpauth_loaded_t*)ha_bufmalloc(buf, len);
-  if(!loaded)
-    errx(1, "out of memory");
+    loaded = (httpauth_loaded_t*)ha_bufmalloc(buf, len);
+    if(!loaded)
+        errx(1, "out of memory");
 
 
-  memset(loaded, 0, len);
+    memset(loaded, 0, len);
 
-  /* Setup the options from the defaults */
-  memcpy(&(loaded->ctx), defaults, sizeof(ha_context_t));
+    /* Setup the options from the defaults */
+    memcpy(&(loaded->ctx), defaults, sizeof(ha_context_t));
 
 
-  if(handler->context_size)
-  {
-    void* mem = ((unsigned char*)(loaded)) + sizeof(httpauth_loaded_t);
-
-    /* Initialize the defaults properly */
-    if(handler->context_default)
-      memcpy(mem, handler->context_default, handler->context_size);
+    if(handler->context_size)
+    {
+        void* mem = ((unsigned char*)(loaded)) + sizeof(httpauth_loaded_t);
 
-    loaded->ctx.ctx_data = mem;
-  }
+        /* Initialize the defaults properly */
+        if(handler->context_default)
+            memcpy(mem, handler->context_default, handler->context_size);
 
-  else
-  {
-    loaded->ctx.ctx_data = NULL;
-  }
+        loaded->ctx.ctx_data = mem;
+    }
 
-  loaded->ctx.name = (char*)alias;
-  loaded->ctx.handler = handler;
+    else
+    {
+        loaded->ctx.ctx_data = NULL;
+    }
 
-  if(!g_handlers)
-  {
-    g_handlers = loaded;
-  }
-  else
-  {
-    httpauth_loaded_t* l = g_handlers;
+    loaded->ctx.name = (char*)alias;
+    loaded->ctx.handler = handler;
 
-    for(;;)
+    if(!g_handlers)
+    {
+        g_handlers = loaded;
+    }
+    else
     {
-      if(strcasecmp(alias, l->ctx.name) == 0)
-        errx(1, "duplicate handler section for '%s'", alias);
+        httpauth_loaded_t* l = g_handlers;
 
-      if(!(l->next))
-        break;
+        for(;;)
+        {
+            if(strcasecmp(alias, l->ctx.name) == 0)
+                errx(1, "duplicate handler section for '%s'", alias);
 
-      l = l->next;
-    }
+            if(!(l->next))
+                break;
 
-    l->next = loaded;
-  }
+            l = l->next;
+        }
 
-  ha_messagex(LOG_DEBUG, "configuration: handler: %s (%s)", alias, handler->type);
-  return &(loaded->ctx);
+        l->next = loaded;
+    }
+
+    ha_messagex(NULL, LOG_DEBUG, "configuration: handler: %s (%s)", alias, handler->type);
+    return &(loaded->ctx);
 }
 
 #define VALID_ALIAS_CHARS "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWYZ_-."
 
 static int config_parse(const char* file, ha_buffer_t* buf)
 {
-  ha_context_t defaults;
-  ha_context_t* ctx = NULL;
-  int line = 0;
-  int fd;
-  char* t;
-  char* name;
-  char* value;
-  int more = 1;
-  int recog;
-  int r, i;
-
-  ASSERT(file && buf);
-
-  /* Open the configuration file */
-  fd = open(file, O_RDONLY);
-  if(fd == -1)
-    err(1, "couldn't open configuration file: %s", file);
-
-  /* These are the default options for the contexts */
-  memset(&defaults, 0, sizeof(defaults));
-  defaults.allowed_types = 0xFFFFFFFF;        /* All types by default */
-  defaults.cache_timeout = DEFAULT_TIMEOUT;   /* Timeout for cache */
-  defaults.cache_max = DEFAULT_CACHEMAX;
-  defaults.realm = "";
-
-  /* Read each line and process */
-  while(more)
-  {
-    ha_bufskip(buf);
-
-    if((more = ha_bufreadline(fd, buf)) == -1)
-      return -1;
-
-    line++;
-
-    /* Eat all white space at beginning of line */
-    while(ha_buflen(buf) && isspace(ha_bufchar(buf)))
-      ha_bufeat(buf);
-
-    /* Skip blank lines */
-    if(ha_buflen(buf) == 0)
-      continue;
-
-    /* Skip comment lines */
-    if(ha_bufchar(buf) == '#')
-      continue;
-
-    /* Check for a handler */
-    if(ha_bufchar(buf) == '[')
+    ha_context_t defaults;
+    ha_context_t* ctx = NULL;
+    int line = 0;
+    int fd;
+    char* t;
+    char* name;
+    char* value;
+    int more = 1;
+    int recog;
+    int r, i;
+
+    ASSERT(file && buf);
+
+    /* Open the configuration file */
+    fd = open(file, O_RDONLY);
+    if(fd == -1)
+        err(1, "couldn't open configuration file: %s", file);
+
+    /* These are the default options for the contexts */
+    memset(&defaults, 0, sizeof(defaults));
+    defaults.allowed_types = 0xFFFFFFFF;        /* All types by default */
+    defaults.cache_timeout = DEFAULT_TIMEOUT;   /* Timeout for cache */
+    defaults.cache_max = DEFAULT_CACHEMAX;
+    defaults.realm = "";
+
+    /* Read each line and process */
+    while(more)
     {
-      ha_handler_t* handler = NULL;
-      const char* x;
+        ha_bufskip(buf);
 
-      ha_bufeat(buf);
-      name = ha_bufparseline(buf, 1);
+        if((more = ha_bufreadline(fd, buf)) == -1)
+            return -1;
 
-      if(!name || name[strlen(name) - 1] != ']')
-        errx(1, "handler section invalid (line %d)", line);
+        line++;
 
+        /* Eat all white space at beginning of line */
+        while(ha_buflen(buf) && isspace(ha_bufchar(buf)))
+            ha_bufeat(buf);
 
-      /* remove the bracket */
-      name[strlen(name) - 1] = 0;
+        /* Skip blank lines */
+        if(ha_buflen(buf) == 0)
+            continue;
 
-      /*
-       * Take out any colon found, past which would
-       * be an aliased name
-       */
-      t = strchr(name, ':');
-      if(t != NULL)
-      {
-        *t = 0;
-        t++;
+        /* Skip comment lines */
+        if(ha_bufchar(buf) == '#')
+            continue;
 
-        /* Rid of whitespace on ends */
-        t = trim_space(t);
+        /* Check for a handler */
+        if(ha_bufchar(buf) == '[')
+        {
+            ha_handler_t* handler = NULL;
+            const char* x;
 
-        /* Validate the alias name */
-        if(!*t || strspn(t, VALID_ALIAS_CHARS) != strlen(t))
-          errx(1, "invalid name for handler: %s", t);
-      }
+            ha_bufeat(buf);
+            name = ha_bufparseline(buf, 1);
 
-      /* Rid of whitespace */
-      name = trim_space(name);
+            if(!name || name[strlen(name) - 1] != ']')
+                errx(1, "handler section invalid (line %d)", line);
 
-      /* Look for a handler with this type */
-      for(i = 0; i < countof(g_handlerlist); i++)
-      {
-        if(g_handlerlist[i] && g_handlerlist[i]->type &&
-           strcasecmp(name, g_handlerlist[i]->type) == 0)
-        {
-          handler = g_handlerlist[i];
-          break;
-        }
-      }
 
-      if(handler == NULL)
-        errx(1, "unknown handler type '%s' (line %d)", name, line);
+            /* remove the bracket */
+            name[strlen(name) - 1] = 0;
 
-      /* If we had a last handler then add it to handlers */
-      ctx = config_addhandler(buf, t ? t : name, handler, &defaults);
+            /*
+             * Take out any colon found, past which would
+             * be an aliased name
+             */
+            t = strchr(name, ':');
+            if(t != NULL)
+            {
+                *t = 0;
+                t++;
 
-      /* Rest doesn't apply to handler headers */
-      continue;
-    }
+                /* Rid of whitespace on ends */
+                t = trim_space(t);
 
+                /* Validate the alias name */
+                if(!*t || strspn(t, VALID_ALIAS_CHARS) != strlen(t))
+                    errx(1, "invalid name for handler: %s", t);
+            }
 
-    /* Parse out the name */
-    name = ha_bufparseword(buf, ":");
-    if(!name || !name[0])
-      errx(1, "configuration file invalid (line %d)", line);
+            /* Rid of whitespace */
+            name = trim_space(name);
 
-    strlwr(name);
+            /* Look for a handler with this type */
+            for(i = 0; i < countof(g_handlerlist); i++)
+            {
+                if(g_handlerlist[i] && g_handlerlist[i]->type &&
+                   strcasecmp(name, g_handlerlist[i]->type) == 0)
+                {
+                    handler = g_handlerlist[i];
+                    break;
+                }
+            }
 
-    /* And get the rest of the line */
-    value = ha_bufparseline(buf, 1);
-    if(value == NULL)
-      errx(1, "configuration missing value at (line %d)", line);
+            if(handler == NULL)
+                errx(1, "unknown handler type '%s' (line %d)", name, line);
 
+            /* If we had a last handler then add it to handlers */
+            ctx = config_addhandler(buf, t ? t : name, handler, &defaults);
 
-    recog = 0;
+            /* Rest doesn't apply to handler headers */
+            continue;
+        }
 
-    /* Is this the global section? */
-    if(!ctx)
-    {
-      /* Look and see if that's a name we want */
-      if(strcmp("socket", name) == 0)
-      {
-        g_socket = value;
-        recog = 1;
-      }
-
-      else if(strcmp("maxthreads", name) == 0)
-      {
-        if(ha_confint(name, value, 1, 256, &g_maxthreads) == -1)
-          exit(1);
-        recog = 1;
-      }
-    }
 
-    /* Otherwise we're in a handler */
-    else
-    {
-      if(ctx->handler->f_config)
-      {
-        r = (ctx->handler->f_config)(ctx, name, value);
-        if(r < 0)
-          return r;
+        /* Parse out the name */
+        name = ha_bufparseword(buf, ":");
+        if(!name || !name[0])
+            errx(1, "configuration file invalid (line %d)", line);
 
-        if(!recog && r == HA_OK)
-          recog = 1;
-      }
-    }
+        strlwr(name);
 
-    /* Options that are legal in both global and internal sections */
-    if(!recog)
-    {
-      ha_context_t* opts = ctx ? ctx : &defaults;
-      ASSERT(opts);
-
-      if(strcmp(name, "cachetimeout") == 0)
-      {
-        int v;
-        if(ha_confint(name, value, 0, 86400, &v) < 0)
-          exit(1); /* Message already printed */
-
-        opts->cache_timeout = v;
-        recog = 1;
-      }
-
-      else if(strcmp(name, "cachemax") == 0)
-      {
-        int v;
-        if(ha_confint(name, value, 0, 0x7FFFFFFF, &v) < 0)
-          exit(1); /* Message already printed */
-
-        opts->cache_max = v;
-        recog = 1;
-      }
-
-      else if(strcmp(name, "authtypes") == 0)
-      {
-        int types = 0;
-        char* t;
-
-        strlwr(value);
-
-        /* Split the line into tokens at the spaces */
-        while(*value)
-        {
-          value = trim_space(value);
-          t = value;
+        /* And get the rest of the line */
+        value = ha_bufparseline(buf, 1);
+        if(value == NULL)
+            errx(1, "configuration missing value at (line %d)", line);
 
-          while(*t && !isspace(*t))
-            t++;
 
-          if(strncmp(value, "basic", 5) == 0)
-            types |= HA_TYPE_BASIC;
+        recog = 0;
 
-          else if(strncmp(value, "digest", 6) == 0)
-            types |= HA_TYPE_DIGEST;
+        /* Is this the global section? */
+        if(!ctx)
+        {
+            /* Look and see if that's a name we want */
+            if(strcmp("socket", name) == 0)
+            {
+                g_socket = value;
+                recog = 1;
+            }
 
-          else if(strncmp(value, "ntlm", 4) == 0)
-            types |= HA_TYPE_NTLM;
+            else if(strcmp("maxthreads", name) == 0)
+            {
+                if(ha_confint(name, value, 1, 256, &g_maxthreads) == -1)
+                    exit(1);
+                recog = 1;
+            }
+        }
 
-          else
-            errx(1, "invalid type for '%s': %s (line %d)", name, value, line);
+        /* Otherwise we're in a handler */
+        else
+        {
+            if(ctx->handler->f_config)
+            {
+                r = (ctx->handler->f_config)(ctx, name, value);
+                if(r < 0)
+                    return r;
 
-          value = t;
+                if(!recog && r == HA_OK)
+                    recog = 1;
+            }
         }
 
-        if(types == 0)
-          errx(1, "no authentication types for '%s' (line %d)", name, line);
+        /* Options that are legal in both global and internal sections */
+        if(!recog)
+        {
+            ha_context_t* opts = ctx ? ctx : &defaults;
+            ASSERT(opts);
 
-        opts->allowed_types = types;
-        recog = 1;
-      }
+            if(strcmp(name, "cachetimeout") == 0)
+            {
+                int v;
+                if(ha_confint(name, value, 0, 86400, &v) < 0)
+                    exit(1); /* Message already printed */
 
-      else if(strcmp(name, "realm") == 0)
-      {
-        opts->realm = value;
-        recog = 1;
-      }
+                opts->cache_timeout = v;
+                    recog = 1;
+            }
 
-      else if(strcmp(name, "digestignoreuri") == 0)
-      {
-        int v;
-        if(ha_confbool(name, value, &v) < 0)
-          exit(1); /* Message already printed */
+            else if(strcmp(name, "cachemax") == 0)
+            {
+                int v;
+                if(ha_confint(name, value, 0, 0x7FFFFFFF, &v) < 0)
+                    exit(1); /* Message already printed */
 
-        opts->digest_ignoreuri = v;
-        recog = 1;
-      }
+                opts->cache_max = v;
+                recog = 1;
+            }
 
-      else if(strcmp(name, "digestignorenc") == 0)
-      {
-        int v;
-        if(ha_confbool(name, value, &v) < 0)
-          exit(1); /* Message already printed */
+            else if(strcmp(name, "authtypes") == 0)
+            {
+                int types = 0;
+                char* t;
 
-        opts->digest_ignorenc = v;
-        recog = 1;
-      }
+                strlwr(value);
+
+                /* Split the line into tokens at the spaces */
+                while(*value)
+                {
+                    value = trim_space(value);
+                    t = value;
+
+                    while(*t && !isspace(*t))
+                        t++;
+
+                    if(strncmp(value, "basic", 5) == 0)
+                        types |= HA_TYPE_BASIC;
+
+                    else if(strncmp(value, "digest", 6) == 0)
+                        types |= HA_TYPE_DIGEST;
+
+                    else if(strncmp(value, "ntlm", 4) == 0)
+                        types |= HA_TYPE_NTLM;
+
+                    else
+                        errx(1, "invalid type for '%s': %s (line %d)", name, value, line);
+
+                    value = t;
+                }
+
+                if(types == 0)
+                    errx(1, "no authentication types for '%s' (line %d)", name, line);
+
+                opts->allowed_types = types;
+                recog = 1;
+            }
+
+            else if(strcmp(name, "realm") == 0)
+            {
+                opts->realm = value;
+                recog = 1;
+            }
+
+            else if(strcmp(name, "digestignoreuri") == 0)
+            {
+                int v;
+                if(ha_confbool(name, value, &v) < 0)
+                    exit(1); /* Message already printed */
+
+                opts->digest_ignoreuri = v;
+                recog = 1;
+            }
+
+            else if(strcmp(name, "digestignorenc") == 0)
+            {
+                int v;
+                if(ha_confbool(name, value, &v) < 0)
+                    exit(1); /* Message already printed */
+
+                opts->digest_ignorenc = v;
+                recog = 1;
+            }
 
 #ifdef _DEBUG
-      else if(strcmp(name, "digestdebugnonce") == 0)
-      {
-        opts->digest_debugnonce = value;
-        recog = 1;
-      }
+            else if(strcmp(name, "digestdebugnonce") == 0)
+            {
+                opts->digest_debugnonce = value;
+                recog = 1;
+            }
 #endif
-    }
+        }
 
-    if(!recog)
-      errx(1, "unrecognized configuration setting '%s' (line %d)", name, line);
-    else
-      ha_messagex(LOG_DEBUG, "configuration: setting: [ %s: %s ]", name, value);
-  }
+        if(!recog)
+            errx(1, "unrecognized configuration setting '%s' (line %d)", name, line);
+        else
+            ha_messagex(NULL, LOG_DEBUG, "configuration: setting: [ %s: %s ]", name, value);
+    }
 
-  if(!g_handlers)
-    ha_messagex(LOG_WARNING, "configuration: no handlers found in configuration file");
+    if(!g_handlers)
+        ha_messagex(NULL, LOG_WARNING, "configuration: no handlers found in configuration file");
 
-  return 0;
+    return 0;
 }
diff --git a/daemon/httpauthd.h b/daemon/httpauthd.h
index 84a30cd..39bf94e 100644
--- a/daemon/httpauthd.h
+++ b/daemon/httpauthd.h
@@ -2,6 +2,8 @@
 #ifndef __HTTPAUTHD_H__
 #define __HTTPAUTHD_H__
 
+#include <syslog.h>
+
 /* -----------------------------------------------------------------------
  * Memory Buffers
  */
@@ -11,10 +13,10 @@ struct ha_buffer_internal;
 /* A buffer which owns memory */
 typedef struct ha_buffer
 {
-  struct ha_buffer_internal* _ft;
-  struct ha_buffer_internal* _dt;
-  char* _pp;
-  char* _rp;
+    struct ha_buffer_internal* _ft;
+    struct ha_buffer_internal* _dt;
+    char* _pp;
+    char* _rp;
 }
 ha_buffer_t;
 
@@ -28,16 +30,16 @@ void ha_buffree(ha_buffer_t* buf);
 void ha_bufreset(ha_buffer_t* buf);
 
 #define ha_buflen(buf)  \
-  ((buf)->_rp - (buf)->_pp)
+    ((buf)->_rp - (buf)->_pp)
 
 #define ha_bufchar(buf)  \
-  ((!ha_buferr(buf) && ha_buflen(buf) > 0) ? *((buf)->_pp) : '\0' )
+    ((!ha_buferr(buf) && ha_buflen(buf) > 0) ? *((buf)->_pp) : '\0' )
 
 #define ha_bufdata(buf)  \
-  ((buf)->_pp)
+    ((buf)->_pp)
 
 #define ha_buferr(buf)   \
-  ((buf)->_dt == NULL)
+    ((buf)->_dt == NULL)
 
 /* Buffer input functions ------------------------------------------------ */
 
@@ -51,10 +53,10 @@ char* ha_bufparseline(ha_buffer_t* buf, int trim);
 char* ha_bufparseword(ha_buffer_t* buf, const char* delims);
 
 #define ha_bufskip(buf)  \
-  ((buf)->_pp = (buf)->_rp)
+    ((buf)->_pp = (buf)->_rp)
 
 #define ha_bufeat(buf)   \
-  ((!ha_buferr(buf) && ha_buflen(buf) > 0) ? ++((buf)->_pp) : (buf)->_pp)
+    ((!ha_buferr(buf) && ha_buflen(buf) > 0) ? ++((buf)->_pp) : (buf)->_pp)
 
 /* Buffer output functions ----------------------------------------------- */
 
@@ -69,7 +71,7 @@ char* ha_bufncpy(ha_buffer_t* buf, const char* src, size_t len);
 
 /* Opens up the end of the current block so it can be joined by more data */
 #define ha_bufjoin(buf) \
-  ((buf)->_rp && ((buf)->_rp != (buf)->_pp) ? (buf)->_rp-- : (buf)->_rp)
+    ((buf)->_rp && ((buf)->_rp != (buf)->_pp) ? (buf)->_rp-- : (buf)->_rp)
 
 #define ha_bufcat ha_bufcpy
 
@@ -102,7 +104,6 @@ void* ha_bufdechex(ha_buffer_t* buf, const char* src, size_t* bytes);
 
 struct ha_context;
 struct ha_request;
-struct ha_response;
 
 /*
  * This function initializes the handler. It gets called
@@ -131,18 +132,18 @@ typedef int (*auth_config_t)(struct ha_context* ctx, const char* name, const cha
  * for this handler. Note that all data access in this
  * function must be thread-safe.
  */
-typedef int (*auth_process_t)(const struct ha_request* req, struct ha_response* resp);
+typedef int (*auth_process_t)(struct ha_request* rq);
 
 /* An authentication handler */
 typedef struct ha_handler
 {
-  const char* type;
-  auth_init_t f_init;           /* #1 Called to initialize handler */
-  auth_destroy_t f_destroy;     /* #3 Called when exiting */
-  auth_config_t f_config;       /* #0 Called for each config param */
-  auth_process_t f_process;     /* #2 Called for each auth request */
-  const void* context_default;  /* The default context */
-  const size_t context_size;    /* Bytes of extra context needed */
+    const char* type;
+    auth_init_t f_init;           /* #1 Called to initialize handler */
+    auth_destroy_t f_destroy;     /* #3 Called when exiting */
+    auth_config_t f_config;       /* #0 Called for each config param */
+    auth_process_t f_process;     /* #2 Called for each auth request */
+    const void* context_default;  /* The default context */
+    const size_t context_size;    /* Bytes of extra context needed */
 }
 ha_handler_t;
 
@@ -177,22 +178,22 @@ ha_handler_t;
 /* Context passed to the handler functions above */
 typedef struct ha_context
 {
-  const char* name;                   /* A name assigned by the configuration file */
-  const ha_handler_t* handler;        /* The original handler structure */
-  void* ctx_data;                     /* Handler specific data */
-
-  /* Context specific options */
-  unsigned int allowed_types;
-  int cache_timeout;
-  int cache_max;
-
-  /* For basic and digest auth: */
-  const char* realm;
-
-  /* For digest auth: */
-  unsigned int digest_ignoreuri : 1;
-  unsigned int digest_ignorenc : 1;
-  const char* digest_debugnonce;
+    const char* name;                   /* A name assigned by the configuration file */
+    const ha_handler_t* handler;        /* The original handler structure */
+    void* ctx_data;                     /* Handler specific data */
+
+    /* Context specific options */
+    unsigned int allowed_types;
+    int cache_timeout;
+    int cache_max;
+
+    /* For basic and digest auth: */
+    const char* realm;
+
+    /* For digest auth: */
+    unsigned int digest_ignoreuri : 1;
+    unsigned int digest_ignorenc : 1;
+    const char* digest_debugnonce;
 }
 ha_context_t;
 
@@ -228,8 +229,8 @@ ha_context_t;
 /* A single header in memory */
 typedef struct ha_header
 {
-  const char* name;
-  const char* data;
+    const char* name;
+    const char* data;
 }
 ha_header_t;
 
@@ -243,19 +244,25 @@ ha_header_t;
 #define AUTH_ARG_METHOD 1
 #define AUTH_ARG_URI    2
 
-/* A single request from client */
+/* A single request from client along with response */
 typedef struct ha_request
 {
-  int type;
-  const char* args[HA_MAX_ARGS];
-  ha_header_t headers[HA_MAX_HEADERS];
+    unsigned int id;                            /* Unique connection identifier */
+
+    int req_type;                               /* The command type */
+    const char* req_args[HA_MAX_ARGS];          /* Arguments for the command */
+    ha_header_t req_headers[HA_MAX_HEADERS];    /* Headers for command */
+
+    /* Additional request info */
+    ha_context_t* context;
+    const char* digest_domain;
 
-  /* Additional request info */
-  ha_context_t* context;
-  const char* digest_domain;
+    /* The buffer in use */
+    ha_buffer_t* buf;
 
-  /* The buffer in use */
-  ha_buffer_t* buf;
+    int resp_code;                              /* The response code */
+    const char* resp_detail;                    /* The details for response */
+    ha_header_t resp_headers[HA_MAX_HEADERS];   /* Headers for the response */
 }
 ha_request_t;
 
@@ -267,22 +274,12 @@ ha_request_t;
 #define HA_SERVER_BADREQ   400
 #define HA_SERVER_BUSY     500
 
-/* A response to the client */
-typedef struct ha_response
-{
-  int code;
-  const char* detail;
-  ha_header_t headers[HA_MAX_HEADERS];
-  ha_buffer_t* buf;
-}
-ha_response_t;
-
 /* Request functions */
-const ha_header_t* ha_findheader(const ha_request_t* req, const char* name);
-const char* ha_getheader(const ha_request_t* req, const char* name, const char* prefix);
+const ha_header_t* ha_findheader(const ha_request_t* rq, const char* name);
+const char* ha_getheader(const ha_request_t* rq, const char* name, const char* prefix);
 
 /* Response functions */
-void ha_addheader(ha_response_t* resp, const char* name, const char* data);
+void ha_addheader(ha_request_t* rq, const char* name, const char* data);
 
 /* Configuration functions */
 int ha_confbool(const char* name, const char* conf, int* value);
@@ -292,8 +289,8 @@ int ha_confint(const char* name, const char* conf, int min, int max, int* value)
  * Error Handling
  */
 
-void ha_message(int level, const char* msg, ...);
-void ha_messagex(int level, const char* msg, ...);
+void ha_message(const ha_request_t* rq, int level, const char* msg, ...);
+void ha_messagex(const ha_request_t* rq, int level, const char* msg, ...);
 
 
 /* -----------------------------------------------------------------------
@@ -318,14 +315,14 @@ void ha_messagex(int level, const char* msg, ...);
 
 typedef struct ha_uri
 {
-  const char* scheme;
-  const char* user;
-  const char* pw;
-  const char* host;
-  unsigned short port;
-  const char* path;
-  const char* query;
-  const char* fragment;
+    const char* scheme;
+    const char* user;
+    const char* pw;
+    const char* host;
+    unsigned short port;
+    const char* path;
+    const char* query;
+    const char* fragment;
 }
 ha_uri_t;
 
diff --git a/daemon/ldap.c b/daemon/ldap.c
index e0349fb..719ac0d 100644
--- a/daemon/ldap.c
+++ b/daemon/ldap.c
@@ -72,8 +72,8 @@ typedef struct ldap_context
 ldap_context_t;
 
 /* Forward declarations for callbacks */
-static int complete_digest(const ha_request_t* req, const char* user, unsigned char* ha1);
-static int validate_basic(const ha_request_t* req, const char* user, const char* password);
+static int complete_digest(ha_request_t* rq, const char* user, unsigned char* ha1);
+static int validate_basic(ha_request_t* rq, const char* user, const char* password);
 
 /* The defaults for the context */
 static const ldap_context_t ldap_defaults =
@@ -101,20 +101,20 @@ static const ldap_context_t ldap_defaults =
  * Internal Functions
  */
 
-static int report_ldap(const char* msg, int code)
+static int report_ldap(const ha_request_t* rq, const char* msg, int code)
 {
     ASSERT(code != LDAP_SUCCESS);
 
     switch(code)
     {
     case LDAP_NO_MEMORY:
-        ha_messagex(LOG_CRIT, "out of memory");
+        ha_messagex(NULL, LOG_CRIT, "out of memory");
         return HA_CRITERROR;
 
     default:
         if(!msg)
             msg = "error";
-        ha_messagex(LOG_ERR, "ldap: %s: %s", msg, ldap_err2string(code));
+        ha_messagex(rq, LOG_ERR, "%s: %s", msg, ldap_err2string(code));
         return HA_FAILED;
     };
 }
@@ -159,49 +159,49 @@ static const char* escape_ldap(ha_buffer_t* buf, const char* str)
     return ha_bufdata(buf);
 }
 
-static const char* substitute_params(ldap_context_t* ctx, const ha_request_t* req,
+static const char* substitute_params(const ha_request_t* rq, ldap_context_t* ctx,
                                      const char* user, const char* str)
 {
     const char* t;
 
-    ASSERT(ctx && req && user && str);
+    ASSERT(ctx && rq && user && str);
 
     /* TODO: We need to be escaping the user and realm properly */
     /* This starts a new block to join */
-    ha_bufcpy(req->buf, "");
+    ha_bufcpy(rq->buf, "");
 
     while(str[0])
     {
         t = strchr(str, '%');
         if(!t)
         {
-            ha_bufjoin(req->buf);
-            ha_bufcpy(req->buf, str);
+            ha_bufjoin(rq->buf);
+            ha_bufcpy(rq->buf, str);
             break;
         }
 
-        ha_bufjoin(req->buf);
-        ha_bufncpy(req->buf, str, t - str);
+        ha_bufjoin(rq->buf);
+        ha_bufncpy(rq->buf, str, t - str);
 
         t++;
 
         switch(t[0])
         {
         case 'u':
-            ha_bufjoin(req->buf);
-            escape_ldap(req->buf, user);
+            ha_bufjoin(rq->buf);
+            escape_ldap(rq->buf, user);
             t++;
             break;
 
         case 'r':
-            ha_bufjoin(req->buf);
-            escape_ldap(req->buf, req->context->realm);
+            ha_bufjoin(rq->buf);
+            escape_ldap(rq->buf, rq->context->realm);
             t++;
             break;
 
         case '%':
-            ha_bufjoin(req->buf);
-            ha_bufcpy(req->buf, "%");
+            ha_bufjoin(rq->buf);
+            ha_bufcpy(rq->buf, "%");
             t++;
             break;
         };
@@ -209,7 +209,7 @@ static const char* substitute_params(ldap_context_t* ctx, const ha_request_t* re
         str = t;
     }
 
-    return ha_bufdata(req->buf);
+    return ha_bufdata(rq->buf);
 }
 
 static const char* make_password_md5(ha_buffer_t* buf, const char* clearpw)
@@ -295,17 +295,17 @@ static const char* find_cleartext_password(ha_buffer_t* buf, const char** pws)
     return NULL;
 }
 
-static int parse_ldap_ha1(ha_buffer_t* buf, struct berval* bv, unsigned char* ha1)
+static int parse_ldap_ha1(const ha_request_t* rq, struct berval* bv, unsigned char* ha1)
 {
     size_t len;
     void* d;
 
-    ASSERT(buf && bv && ha1);
+    ASSERT(rq && bv && ha1);
 
     /* Raw binary */
     if(bv->bv_len == MD5_LEN)
     {
-        ha_messagex(LOG_DEBUG, "ldap: found ha1 in raw binary format");
+        ha_messagex(rq, LOG_DEBUG, "found ha1 in raw binary format");
         memcpy(ha1, bv->bv_val, MD5_LEN);
         return HA_OK;
     }
@@ -314,11 +314,11 @@ static int parse_ldap_ha1(ha_buffer_t* buf, struct berval* bv, unsigned char* ha
     else if(bv->bv_len == (MD5_LEN * 2))
     {
         len = MD5_LEN;
-        d = ha_bufdechex(buf, bv->bv_val, &len);
+        d = ha_bufdechex(rq->buf, bv->bv_val, &len);
 
         if(d && len == MD5_LEN)
         {
-            ha_messagex(LOG_DEBUG, "ldap: found ha1 in hex encoded format");
+            ha_messagex(rq, LOG_DEBUG, "found ha1 in hex encoded format");
             memcpy(ha1, d, MD5_LEN);
             return HA_OK;
         }
@@ -328,21 +328,21 @@ static int parse_ldap_ha1(ha_buffer_t* buf, struct berval* bv, unsigned char* ha
     else
     {
         len = MD5_LEN;
-        d = ha_bufdec64(buf, bv->bv_val, &len);
+        d = ha_bufdec64(rq->buf, bv->bv_val, &len);
 
         if(d && len == MD5_LEN)
         {
-            ha_messagex(LOG_DEBUG, "ldap: found ha1 in b64 encoded format");
-            memcpy(ha1, ha_bufdata(buf), MD5_LEN);
+            ha_messagex(rq, LOG_DEBUG, "found ha1 in b64 encoded format");
+            memcpy(ha1, ha_bufdata(rq->buf), MD5_LEN);
             return HA_OK;
         }
     }
 
-    return ha_buferr(buf) ? HA_CRITERROR : HA_FALSE;
+    return ha_buferr(rq->buf) ? HA_CRITERROR : HA_FALSE;
 }
 
-static int validate_ldap_password(ldap_context_t* ctx, LDAP* ld, LDAPMessage* entry,
-                                  ha_buffer_t* buf, const char* user, const char* clearpw)
+static int validate_ldap_password(const ha_request_t* rq, ldap_context_t* ctx, LDAP* ld,
+                                  LDAPMessage* entry, const char* user, const char* clearpw)
 {
     char** pws;
     char** t;
@@ -352,7 +352,7 @@ static int validate_ldap_password(ldap_context_t* ctx, LDAP* ld, LDAPMessage* en
     int res = HA_FALSE;
     int unknown = 0;
 
-    ASSERT(entry && ld && ctx && clearpw);
+    ASSERT(entry && ld && ctx && clearpw && rq);
 
     ASSERT(ctx->pw_attr);
     pws = ldap_get_values(ld, entry, ctx->pw_attr);
@@ -371,7 +371,7 @@ static int validate_ldap_password(ldap_context_t* ctx, LDAP* ld, LDAPMessage* en
                 break;
 
             case LDAP_PW_MD5:
-                p = make_password_md5(buf, clearpw);
+                p = make_password_md5(rq->buf, clearpw);
                 break;
 
             case LDAP_PW_CRYPT:
@@ -382,7 +382,7 @@ static int validate_ldap_password(ldap_context_t* ctx, LDAP* ld, LDAPMessage* en
                 break;
 
             case LDAP_PW_SHA:
-                p = make_password_sha(buf, clearpw);
+                p = make_password_sha(rq->buf, clearpw);
                 break;
 
             case LDAP_PW_UNKNOWN:
@@ -402,7 +402,7 @@ static int validate_ldap_password(ldap_context_t* ctx, LDAP* ld, LDAPMessage* en
 
             if(strcmp(pw, p) == 0)
             {
-                ha_messagex(LOG_DEBUG, "ldap: successful validate against password");
+                ha_messagex(rq, LOG_DEBUG, "successful validate against password");
                 res = HA_OK;
                 break;
             }
@@ -412,13 +412,13 @@ static int validate_ldap_password(ldap_context_t* ctx, LDAP* ld, LDAPMessage* en
     }
 
     if(res == HA_FALSE && unknown)
-        ha_messagex(LOG_ERR, "ldap: server does not contain any compatible passwords for user: %s", user);
+        ha_messagex(rq, LOG_ERR, "server does not contain any compatible passwords for user: %s", user);
 
     return res;
 }
 
-static int validate_ldap_ha1(ldap_context_t* ctx, LDAP* ld, LDAPMessage* entry,
-                             ha_buffer_t* buf, const char* user, const char* realm,
+static int validate_ldap_ha1(const ha_request_t* rq, ldap_context_t* ctx, LDAP* ld,
+                             LDAPMessage* entry, const char* user, const char* realm,
                              const char* clearpw)
 {
     struct berval** ha1s;
@@ -428,7 +428,7 @@ static int validate_ldap_ha1(ldap_context_t* ctx, LDAP* ld, LDAPMessage* entry,
     int r, first = 1;
     int res = HA_FALSE;
 
-    ASSERT(ctx && ld && entry && buf && user && clearpw);
+    ASSERT(ctx && ld && entry && rq && user && clearpw);
 
     if(!ctx->ha1_attr)
         return HA_FALSE;
@@ -441,7 +441,7 @@ static int validate_ldap_ha1(ldap_context_t* ctx, LDAP* ld, LDAPMessage* entry,
 
         for(b = ha1s ; *b; b++)
         {
-            r = parse_ldap_ha1(buf, *b, k);
+            r = parse_ldap_ha1(rq, *b, k);
             if(r < 0)
             {
                 res = r;
@@ -451,7 +451,7 @@ static int validate_ldap_ha1(ldap_context_t* ctx, LDAP* ld, LDAPMessage* entry,
             if(r == HA_FALSE)
             {
                 if(first)
-                    ha_messagex(LOG_ERR, "ldap: server contains invalid HA1 digest hash for user: %s", user);
+                    ha_messagex(rq, LOG_ERR, "server contains invalid HA1 digest hash for user: %s", user);
 
                 first = 0;
                 continue;
@@ -459,7 +459,7 @@ static int validate_ldap_ha1(ldap_context_t* ctx, LDAP* ld, LDAPMessage* entry,
 
             if(memcmp(key, k, MD5_LEN) == 0)
             {
-                ha_messagex(LOG_DEBUG, "ldap: successful validate against ha1");
+                ha_messagex(rq, LOG_DEBUG, "successful validate against ha1");
                 res = HA_OK;
                 break;
             }
@@ -471,7 +471,7 @@ static int validate_ldap_ha1(ldap_context_t* ctx, LDAP* ld, LDAPMessage* entry,
     return res;
 }
 
-static LDAP* get_ldap_connection(ldap_context_t* ctx)
+static LDAP* get_ldap_connection(const ha_request_t* rq, ldap_context_t* ctx)
 {
     LDAP* ld;
     int i, r;
@@ -483,7 +483,7 @@ static LDAP* get_ldap_connection(ldap_context_t* ctx)
         /* An open connection in the pool */
         if(ctx->pool[i])
         {
-            ha_messagex(LOG_DEBUG, "ldap: using cached connection");
+            ha_messagex(rq, LOG_DEBUG, "using cached connection");
             ld = ctx->pool[i];
             ctx->pool[i] = NULL;
             return ld;
@@ -492,14 +492,14 @@ static LDAP* get_ldap_connection(ldap_context_t* ctx)
 
     if(ctx->pool_mark >= ctx->ldap_max)
     {
-        ha_messagex(LOG_ERR, "ldap: too many open connections");
+        ha_messagex(rq, LOG_ERR, "too many open connections");
         return NULL;
     }
 
     ld = ldap_init(ctx->servers, ctx->port);
     if(!ld)
     {
-        ha_message(LOG_ERR, "ldap: couldn't initialize connection");
+        ha_message(rq, LOG_ERR, "couldn't initialize connection");
         return NULL;
     }
 
@@ -509,25 +509,25 @@ static LDAP* get_ldap_connection(ldap_context_t* ctx)
                                ctx->password ? ctx->password : "");
         if(r != LDAP_SUCCESS)
         {
-            report_ldap("ldap: couldn't bind to LDAP server", r);
+            report_ldap(rq, "couldn't bind to LDAP server", r);
             ldap_unbind_s(ld);
             return NULL;
         }
     }
 
     ctx->pool_mark++;
-    ha_messagex(LOG_DEBUG, "ldap: opened new connection (total %d)", ctx->pool_mark);
+    ha_messagex(rq, LOG_DEBUG, "opened new connection (total %d)", ctx->pool_mark);
     return ld;
 }
 
-static void discard_ldap_connection(ldap_context_t* ctx, LDAP* ld)
+static void discard_ldap_connection(const ha_request_t* rq, ldap_context_t* ctx, LDAP* ld)
 {
     ldap_unbind_s(ld);
     ctx->pool_mark--;
-    ha_messagex(LOG_DEBUG, "ldap: discarding connection (total %d)", ctx->pool_mark);
+    ha_messagex(rq, LOG_DEBUG, "discarding connection (total %d)", ctx->pool_mark);
 }
 
-static void save_ldap_connection(ldap_context_t* ctx, LDAP* ld)
+static void save_ldap_connection(const ha_request_t* rq, ldap_context_t* ctx, LDAP* ld)
 {
     int i, e;
 
@@ -544,7 +544,7 @@ static void save_ldap_connection(ldap_context_t* ctx, LDAP* ld)
     case LDAP_SERVER_DOWN:
     case LDAP_LOCAL_ERROR:
     case LDAP_NO_MEMORY:
-        discard_ldap_connection(ctx, ld);
+        discard_ldap_connection(rq, ctx, ld);
         break;
 
     default:
@@ -553,7 +553,7 @@ static void save_ldap_connection(ldap_context_t* ctx, LDAP* ld)
             /* An open connection in the pool */
             if(!ctx->pool[i])
             {
-                ha_messagex(LOG_DEBUG, "ldap: caching connection for later use");
+                ha_messagex(rq, LOG_DEBUG, "caching connection for later use");
                 ctx->pool[i] = ld;
                 ld = NULL;
                 break;
@@ -563,7 +563,7 @@ static void save_ldap_connection(ldap_context_t* ctx, LDAP* ld)
     };
 }
 
-static int retrieve_user_entry(ldap_context_t* ctx, const ha_request_t* req, LDAP* ld,
+static int retrieve_user_entry(const ha_request_t* rq, ldap_context_t* ctx, LDAP* ld,
                                const char* user, const char** dn,
                                LDAPMessage** entry, LDAPMessage** result)
 {
@@ -574,12 +574,12 @@ static int retrieve_user_entry(ldap_context_t* ctx, const ha_request_t* req, LDA
     int scope;
     int r;
 
-    ASSERT(ctx && req && ld && user && dn && entry && result);
+    ASSERT(ctx && rq && ld && user && dn && entry && result);
 
     if(ctx->filter)
     {
         /* Filters can also have %u and %r */
-        filter = substitute_params(ctx, req, user, ctx->filter);
+        filter = substitute_params(rq, ctx, user, ctx->filter);
         if(!filter)
             return HA_CRITERROR;
     }
@@ -598,7 +598,7 @@ static int retrieve_user_entry(ldap_context_t* ctx, const ha_request_t* req, LDA
     base = *dn ? *dn : ctx->base;
     scope = *dn ? LDAP_SCOPE_BASE : ctx->scope;
 
-    ha_messagex(LOG_DEBUG, "ldap: performing search: [ base: %s / scope: %d / filter: %s ]",
+    ha_messagex(rq, LOG_DEBUG, "performing search: [ base: %s / scope: %d / filter: %s ]",
                 base, scope, filter);
 
     r = ldap_search_st(ld, base, scope, filter, (char**)attrs, 0, &tv, result);
@@ -607,11 +607,11 @@ static int retrieve_user_entry(ldap_context_t* ctx, const ha_request_t* req, LDA
     {
         if(r == LDAP_NO_SUCH_OBJECT)
         {
-            ha_messagex(LOG_WARNING, "ldap: user not found in LDAP: %s", user);
+            ha_messagex(rq, LOG_WARNING, "user not found in %s", user);
             return HA_FALSE;
         }
 
-        return report_ldap("couldn't search LDAP server", r);
+        return report_ldap(rq, "couldn't search LDAP server", r);
     }
 
 
@@ -623,25 +623,25 @@ static int retrieve_user_entry(ldap_context_t* ctx, const ha_request_t* req, LDA
         if(!(*dn))
         {
             *dn = ldap_get_dn(ld, *entry);
-            ha_messagex(LOG_DEBUG, "ldap: found entry for user: %s", *dn);
+            ha_messagex(rq, LOG_DEBUG, "found entry for user: %s", *dn);
         }
         return HA_OK;
 
     case 0:
-        ha_messagex(LOG_WARNING, "ldap: user not found in LDAP: %s", user);
+        ha_messagex(rq, LOG_WARNING, "user not found in %s", user);
         break;
 
     default:
-        ha_messagex(LOG_WARNING, "ldap: more than one user found for filter: %s", filter);
+        ha_messagex(rq, LOG_WARNING, "more than one user found for filter: %s", filter);
         break;
     };
 
     return HA_FALSE;
 }
 
-static int complete_digest(const ha_request_t* req, const char* user, unsigned char* ha1)
+static int complete_digest(ha_request_t* rq, const char* user, unsigned char* ha1)
 {
-    ldap_context_t* ctx = (ldap_context_t*)req->context->ctx_data;
+    ldap_context_t* ctx = (ldap_context_t*)rq->context->ctx_data;
     LDAP* ld = NULL;                /* freed in finally */
     LDAPMessage* results = NULL;    /* freed in finally */
     LDAPMessage* entry = NULL;      /* no need to free */
@@ -651,9 +651,9 @@ static int complete_digest(const ha_request_t* req, const char* user, unsigned c
     const char* dn = NULL;
     int r;
 
-    ASSERT(req && ha1 && user);
+    ASSERT(rq && ha1 && user);
 
-    ld = get_ldap_connection(ctx);
+    ld = get_ldap_connection(rq, ctx);
     if(!ld)
     {
         ret = HA_FAILED;
@@ -668,18 +668,18 @@ static int complete_digest(const ha_request_t* req, const char* user, unsigned c
     if(ctx->dnmap)
     {
         /* The map can have %u and %r to denote user and realm */
-        dn = substitute_params(ctx, req, user, ctx->dnmap);
+        dn = substitute_params(rq, ctx, user, ctx->dnmap);
         if(!dn)
         {
             ret = HA_FAILED;
             goto finally;
         }
 
-        ha_messagex(LOG_INFO, "ldap: mapped %s to %s", user, dn);
+        ha_messagex(rq, LOG_INFO, "mapped %s to %s", user, dn);
     }
 
     /* Okay now we contact the LDAP server. */
-    r = retrieve_user_entry(ctx, req, ld, user, &dn, &entry, &results);
+    r = retrieve_user_entry(rq, ctx, ld, user, &dn, &entry, &results);
     if(r != HA_OK)
     {
         ret = r;
@@ -694,15 +694,15 @@ static int complete_digest(const ha_request_t* req, const char* user, unsigned c
     {
         if(*ha1s)
         {
-            ret = parse_ldap_ha1(req->buf, *ha1s, ha1);
+            ret = parse_ldap_ha1(rq, *ha1s, ha1);
             if(ret != HA_OK)
             {
                 if(ret == HA_FALSE)
-                    ha_messagex(LOG_ERR, "ldap: server contains invalid HA1 for user: %s", user);
+                    ha_messagex(rq, LOG_ERR, "server contains invalid HA1 for user: %s", user);
             }
         }
 
-        ha_messagex(LOG_DEBUG, "ldap: using HA1 from ldap");
+        ha_messagex(rq, LOG_DEBUG, "using HA1 from ldap");
         ldap_value_free_len(ha1s);
         goto finally;
     }
@@ -713,11 +713,11 @@ static int complete_digest(const ha_request_t* req, const char* user, unsigned c
     if(pws)
     {
         /* Find a cleartext password */
-        const char* t = find_cleartext_password(req->buf, (const char**)pws);
+        const char* t = find_cleartext_password(rq->buf, (const char**)pws);
 
         if(t)
         {
-            digest_makeha1(ha1, user, req->context->realm, t);
+            digest_makeha1(ha1, user, rq->context->realm, t);
             ret = HA_OK;
         }
 
@@ -725,17 +725,17 @@ static int complete_digest(const ha_request_t* req, const char* user, unsigned c
 
         if(ret == HA_OK)
         {
-            ha_messagex(LOG_DEBUG, "ldap: using clear password from ldap");
+            ha_messagex(rq, LOG_DEBUG, "using clear password from ldap");
             goto finally;
         }
     }
 
-    ha_messagex(LOG_ERR, "ldap: server contains no clear password or HA1 for user: %s", user);
+    ha_messagex(rq, LOG_ERR, "server contains no clear password or HA1 for user: %s", user);
 
 finally:
 
     if(ld)
-        save_ldap_connection(ctx, ld);
+        save_ldap_connection(rq, ctx, ld);
 
     if(results)
         ldap_msgfree(results);
@@ -743,9 +743,9 @@ finally:
     return ret;
 }
 
-static int validate_basic(const ha_request_t* req, const char* user, const char* password)
+static int validate_basic(ha_request_t* rq, const char* user, const char* password)
 {
-    ldap_context_t* ctx = (ldap_context_t*)req->context->ctx_data;
+    ldap_context_t* ctx = (ldap_context_t*)rq->context->ctx_data;
     LDAP* ld = NULL;
     LDAPMessage* entry = NULL;
     LDAPMessage* results = NULL;
@@ -754,9 +754,9 @@ static int validate_basic(const ha_request_t* req, const char* user, const char*
     int found = 0;
     int r;
 
-    ASSERT(req && user && password);
+    ASSERT(rq && user && password);
 
-    ld = get_ldap_connection(ctx);
+    ld = get_ldap_connection(rq, ctx);
     if(!ld)
     {
         ret = HA_FAILED;
@@ -772,14 +772,14 @@ static int validate_basic(const ha_request_t* req, const char* user, const char*
     if(ctx->dnmap)
     {
         /* The map can have %u and %r to denote user and realm */
-        dn = substitute_params(ctx, req, user, ctx->dnmap);
+        dn = substitute_params(rq, ctx, user, ctx->dnmap);
         if(!dn)
         {
             ret = HA_CRITERROR;
             goto finally;
         }
 
-        ha_messagex(LOG_INFO, "ldap: mapped %s to %s", user, dn);
+        ha_messagex(rq, LOG_INFO, "mapped %s to %s", user, dn);
     }
 
 
@@ -800,7 +800,7 @@ static int validate_basic(const ha_request_t* req, const char* user, const char*
 
     if(!ctx->dobind || !dn || ctx->filter)
     {
-        r = retrieve_user_entry(ctx, req, ld, user, &dn, &entry, &results);
+        r = retrieve_user_entry(rq, ctx, ld, user, &dn, &entry, &results);
         if(r != HA_OK)
         {
             ret = r;
@@ -818,17 +818,17 @@ static int validate_basic(const ha_request_t* req, const char* user, const char*
         if(r != LDAP_SUCCESS)
         {
             if(r == LDAP_INVALID_CREDENTIALS)
-                ha_messagex(LOG_WARNING, "ldap: basic authentication (via bind) failed for user: %s",
+                ha_messagex(rq, LOG_WARNING, "basic authentication (via bind) failed for user: %s",
                                 user);
 
             else
-                report_ldap("couldn't bind to LDAP server", r);
+                report_ldap(rq, "couldn't bind to LDAP server", r);
 
             goto finally;
         }
 
         /* It worked! */
-        ha_messagex(LOG_NOTICE, "ldap: validated basic user using bind: %s", user);
+        ha_messagex(rq, LOG_NOTICE, "validated basic user using bind: %s", user);
         found = 1;
 
         /* Now we have to rebind the connection back to the main user */
@@ -836,10 +836,10 @@ static int validate_basic(const ha_request_t* req, const char* user, const char*
                                ctx->password ? ctx->password : "");
         if(r != LDAP_SUCCESS)
         {
-            report_ldap("ldap: couldn't rebind LDAP connection back to auth credentials", r);
+            report_ldap(rq, "couldn't rebind LDAP connection back to auth credentials", r);
 
             /* Discard the connection since it's useless to us */
-            discard_ldap_connection(ctx, ld);
+            discard_ldap_connection(rq, ctx, ld);
             ld = NULL;
         }
     }
@@ -848,27 +848,27 @@ static int validate_basic(const ha_request_t* req, const char* user, const char*
     /* Otherwise we compare the password attribute */
     else
     {
-        ret = validate_ldap_password(ctx, ld, entry, req->buf, user, password);
+        ret = validate_ldap_password(rq, ctx, ld, entry, user, password);
         if(ret == HA_FALSE)
-        ret = validate_ldap_ha1(ctx, ld, entry, req->buf, user,
-                                req->context->realm, password);
+        ret = validate_ldap_ha1(rq, ctx, ld, entry, user,
+                                rq->context->realm, password);
 
         if(ret == HA_OK)
         {
-            ha_messagex(LOG_NOTICE, "ldap: validated basic user password/ha1: %s", user);
+            ha_messagex(rq, LOG_NOTICE, "validated basic user password/ha1: %s", user);
             found = 1;
         }
 
         else
         {
-            ha_messagex(LOG_WARNING, "ldap: invalid, unreadable or unrecognized password for user: %s", user);
+            ha_messagex(rq, LOG_WARNING, "invalid, unreadable or unrecognized password for user: %s", user);
         }
     }
 
 finally:
 
     if(ld)
-        save_ldap_connection(ctx, ld);
+        save_ldap_connection(rq, ctx, ld);
 
     if(results)
         ldap_msgfree(results);
@@ -946,7 +946,7 @@ int ldap_config(ha_context_t* context, const char* name, const char* value)
             ctx->scope = LDAP_SCOPE_ONELEVEL;
         else
         {
-            ha_messagex(LOG_ERR, "invalid value for '%s' (must be 'sub', 'base' or 'one')", name);
+            ha_messagex(NULL, LOG_ERR, "invalid value for '%s' (must be 'sub', 'base' or 'one')", name);
             return HA_FAILED;
         }
 
@@ -987,14 +987,14 @@ int ldap_inithand(ha_context_t* context)
         /* Check for mandatory configuration */
         if(!ctx->servers)
         {
-            ha_messagex(LOG_ERR, "ldap: configuration incomplete. "
+            ha_messagex(NULL, LOG_ERR, "configuration incomplete. "
                            "Must have LDAPServers.");
             return HA_FAILED;
         }
 
         if(!ctx->dnmap && (!ctx->filter || !ctx->base))
         {
-            ha_messagex(LOG_ERR, "ldap: configuration incomplete. "
+            ha_messagex(NULL, LOG_ERR, "configuration incomplete. "
                                  "When not using LDAPDNMap must specify LDAPBase and LDAPFilter.");
             return HA_FAILED;
         }
@@ -1010,12 +1010,12 @@ int ldap_inithand(ha_context_t* context)
         ctx->pool = (LDAP**)malloc(sizeof(LDAP*) * ctx->ldap_max);
         if(!ctx->pool)
         {
-            ha_messagex(LOG_CRIT, "out of memory");
+            ha_messagex(NULL, LOG_CRIT, "out of memory");
             return HA_CRITERROR;
         }
 
         memset(ctx->pool, 0, sizeof(LDAP*) * ctx->ldap_max);
-        ha_messagex(LOG_INFO, "ldap: initialized handler");
+        ha_messagex(NULL, LOG_INFO, "initialized handler");
     }
 
     return HA_OK;
@@ -1046,7 +1046,7 @@ void ldap_destroy(ha_context_t* context)
     }
 
     bd_destroy(context);
-    ha_messagex(LOG_INFO, "ldap: uninitialized handler");
+    ha_messagex(NULL, LOG_INFO, "uninitialized ldap handler");
 }
 
 
diff --git a/daemon/misc.c b/daemon/misc.c
index 8e361be..f48d801 100644
--- a/daemon/misc.c
+++ b/daemon/misc.c
@@ -20,60 +20,71 @@ extern pthread_mutex_t g_mutex;
 const char kMsgDelimiter[] = ": ";
 #define MAX_MSGLEN  128
 
-void ha_messagex(int level, const char* msg, ...)
+static void vmessage(const ha_request_t* rq, int level, int err,
+                     const char* msg, va_list ap)
 {
-  va_list ap;
-  va_start(ap, msg);
+    size_t len;
+    char* m;
+    int e = errno;
+    int x;
 
-  ASSERT(msg);
+    if(g_daemonized)
+    {
+        if(level >= LOG_DEBUG)
+            return;
+    }
+    else
+    {
+        if(g_debuglevel < level)
+            return;
+    }
+
+    ASSERT(msg);
 
-  /* Either to syslog or stderr */
-  if(g_daemonized)
-  {
-    if(level < LOG_DEBUG)
-      vsyslog(level, msg, ap);
-  }
+    len = strlen(msg) + 20 + MAX_MSGLEN;
+    m = (char*)alloca(len);
 
-  else
-  {
-    if(g_debuglevel >= level)
-      vwarnx(msg, ap);
-  }
+    if(m)
+    {
+        if(rq)
+            snprintf(m, len, "%06X: %s%s", rq->id, msg, err ? ": " : "");
+        else
+            snprintf(m, len, "%s%s", msg, err ? ": " : "");
 
-  va_end(ap);
+        if(err)
+        {
+            /* TODO: strerror_r doesn't want to work for us
+            strerror_r(e, m + strlen(m), MAX_MSGLEN); */
+            strncat(m, strerror(e), len);
+        }
+
+        m[len - 1] = 0;
+        msg = m;
+    }
+
+    /* Either to syslog or stderr */
+    if(g_daemonized)
+        vsyslog(level, msg, ap);
+    else
+        vwarnx(msg, ap);
 }
 
-void ha_message(int level, const char* msg, ...)
+void ha_messagex(const ha_request_t* rq, int level, const char* msg, ...)
 {
-  va_list ap;
-  va_start(ap, msg);
-
-  ASSERT(msg);
+    va_list ap;
 
-  /* Either to syslog or stderr */
-  if(g_daemonized)
-  {
-    if(level < LOG_DEBUG)
-    {
-      char* m = (char*)alloca(strlen(msg) + MAX_MSGLEN + sizeof(kMsgDelimiter));
+    va_start(ap, msg);
+    vmessage(rq, level, 0, msg, ap);
+    va_end(ap);
+}
 
-      if(m)
-      {
-        strcpy(m, msg);
-        strcat(m, kMsgDelimiter);
-        strerror_r(errno, m + strlen(m), MAX_MSGLEN);
-      }
+void ha_message(const ha_request_t* rq, int level, const char* msg, ...)
+{
+    va_list ap;
 
-      vsyslog(LOG_ERR, m ? m : msg, ap);
-    }
-  }
-  else
-  {
-    if(g_debuglevel >= level)
-      vwarn(msg, ap);
-  }
-
-  va_end(ap);
+    va_start(ap, msg);
+    vmessage(rq, level, 1, msg, ap);
+    va_end(ap);
 }
 
 
@@ -81,67 +92,67 @@ void ha_message(int level, const char* msg, ...)
  * Header Functionality
  */
 
-const ha_header_t* ha_findheader(const ha_request_t* req, const char* name)
+const ha_header_t* ha_findheader(const ha_request_t* rq, const char* name)
 {
-  int i;
+    int i;
 
-  ASSERT(req && name);
+    ASSERT(rq && name);
 
-  for(i = 0; i < HA_MAX_HEADERS; i++)
-  {
-    if(req->headers[i].name)
+    for(i = 0; i < HA_MAX_HEADERS; i++)
     {
-      if(strcasecmp(req->headers[i].name, name) == 0)
-        return &(req->headers[i]);
+        if(rq->req_headers[i].name)
+        {
+            if(strcasecmp(rq->req_headers[i].name, name) == 0)
+                return &(rq->req_headers[i]);
+        }
     }
-  }
 
-  return NULL;
+    return NULL;
 }
 
-const char* ha_getheader(const ha_request_t* req, const char* name, const char* prefix)
+const char* ha_getheader(const ha_request_t* rq, const char* name, const char* prefix)
 {
-  int i, l;
+    int i, l;
 
-  ASSERT(req && name);
+    ASSERT(rq && name);
 
-  for(i = 0; i < HA_MAX_HEADERS; i++)
-  {
-    if(req->headers[i].name)
+    for(i = 0; i < HA_MAX_HEADERS; i++)
     {
-      if(strcasecmp(req->headers[i].name, name) == 0)
-      {
-        if(!prefix)
-          return req->headers[i].data;
+        if(rq->req_headers[i].name)
+        {
+            if(strcasecmp(rq->req_headers[i].name, name) == 0)
+            {
+                if(!prefix)
+                    return rq->req_headers[i].data;
 
-        l = strlen(prefix);
+                l = strlen(prefix);
 
-        if(strncasecmp(prefix, req->headers[i].data, l) == 0)
-          return req->headers[i].data + l;
-      }
+                if(strncasecmp(prefix, rq->req_headers[i].data, l) == 0)
+                    return rq->req_headers[i].data + l;
+            }
+        }
     }
-  }
 
-  return NULL;
+    return NULL;
 }
 
-void ha_addheader(ha_response_t* resp, const char* name, const char* data)
+void ha_addheader(ha_request_t* rq, const char* name, const char* data)
 {
-  int i = 0;
+    int i = 0;
 
-  ASSERT(resp && name && data);
+    ASSERT(rq && name && data);
 
-  for(i = 0; i < HA_MAX_HEADERS; i++)
-  {
-    if(!(resp->headers[i].name))
+    for(i = 0; i < HA_MAX_HEADERS; i++)
     {
-      resp->headers[i].name = name;
-      resp->headers[i].data = data;
-      return;
+        if(!(rq->resp_headers[i].name))
+        {
+            rq->resp_headers[i].name = name;
+            rq->resp_headers[i].data = data;
+            return;
+        }
     }
-  }
 
-  ha_messagex(LOG_WARNING, "too many headers in response. discarding '%s'", name);
+    ha_messagex(rq, LOG_WARNING, "too many headers in response. discarding '%s'", name);
 }
 
 
@@ -151,51 +162,51 @@ void ha_addheader(ha_response_t* resp, const char* name, const char* data)
 
 void ha_lock(pthread_mutex_t* mtx)
 {
-  int r;
+    int r;
 
 #ifdef _DEBUG
-  int wait = 0;
+    int wait = 0;
 #endif
 
-  if(!mtx)
-    mtx = &g_mutex;
+    if(!mtx)
+        mtx = &g_mutex;
 
 #ifdef _DEBUG
-  r = pthread_mutex_trylock(mtx);
-  if(r == EBUSY)
-  {
-    wait = 1;
-    ha_message(LOG_DEBUG, "thread will block: %d", pthread_self());
-    r = pthread_mutex_lock(mtx);
-  }
+    r = pthread_mutex_trylock(mtx);
+    if(r == EBUSY)
+    {
+        wait = 1;
+        ha_message(NULL, LOG_DEBUG, "thread will block: %d", pthread_self());
+        r = pthread_mutex_lock(mtx);
+    }
 
 #else
-  r = pthread_mutex_lock(mtx);
+    r = pthread_mutex_lock(mtx);
 
 #endif
 
-  if(r != 0)
-  {
-    errno = r;
-    ha_message(LOG_CRIT, "threading problem. couldn't lock mutex");
-  }
+    if(r != 0)
+    {
+        errno = r;
+        ha_message(NULL, LOG_CRIT, "threading problem. couldn't lock mutex");
+    }
 
 #ifdef _DEBUG
-  else if(wait)
-  {
-    ha_message(LOG_DEBUG, "thread unblocked: %d", pthread_self());
-  }
+    else if(wait)
+    {
+        ha_message(NULL, LOG_DEBUG, "thread unblocked: %d", pthread_self());
+    }
 #endif
 }
 
 void ha_unlock(pthread_mutex_t* mtx)
 {
-  int r = pthread_mutex_unlock(mtx ? mtx : &g_mutex);
-  if(r != 0)
-  {
-    errno = r;
-    ha_message(LOG_CRIT, "threading problem. couldn't unlock mutex");
-  }
+    int r = pthread_mutex_unlock(mtx ? mtx : &g_mutex);
+    if(r != 0)
+    {
+        errno = r;
+        ha_message(NULL, LOG_CRIT, "threading problem. couldn't unlock mutex");
+    }
 }
 
 
@@ -205,51 +216,51 @@ void ha_unlock(pthread_mutex_t* mtx)
 
 int ha_confbool(const char* name, const char* conf, int* value)
 {
-  ASSERT(name && value);
-
-  if(conf == NULL ||
-     conf[0] == 0 ||
-     strcasecmp(conf, "0") == 0 ||
-     strcasecmp(conf, "no") == 0 ||
-     strcasecmp(conf, "false") == 0 ||
-     strcasecmp(conf, "f") == 0 ||
-     strcasecmp(conf, "off") == 0)
-  {
-    *value = 0;
-    return HA_OK;
-  }
-
-  if(strcasecmp(conf, "1") == 0 ||
-     strcasecmp(conf, "yes") == 0 ||
-     strcasecmp(conf, "true") == 0 ||
-     strcasecmp(conf, "t") == 0 ||
-     strcasecmp(conf, "on") == 0)
-  {
-    *value = 1;
-    return HA_OK;
-  }
+    ASSERT(name && value);
+
+    if(conf == NULL ||
+       conf[0] == 0 ||
+       strcasecmp(conf, "0") == 0 ||
+       strcasecmp(conf, "no") == 0 ||
+       strcasecmp(conf, "false") == 0 ||
+       strcasecmp(conf, "f") == 0 ||
+       strcasecmp(conf, "off") == 0)
+    {
+        *value = 0;
+        return HA_OK;
+    }
 
-  ha_messagex(LOG_ERR, "invalid configuration value '%s': must be 'on' or 'off'.", name);
-  return HA_FAILED;
+    if(strcasecmp(conf, "1") == 0 ||
+       strcasecmp(conf, "yes") == 0 ||
+       strcasecmp(conf, "true") == 0 ||
+       strcasecmp(conf, "t") == 0 ||
+       strcasecmp(conf, "on") == 0)
+    {
+        *value = 1;
+        return HA_OK;
+    }
+
+    ha_messagex(NULL, LOG_ERR, "invalid configuration value '%s': must be 'on' or 'off'.", name);
+    return HA_FAILED;
 }
 
 int ha_confint(const char* name, const char* conf, int min, int max, int* value)
 {
-  char* p;
+    char* p;
 
-  ASSERT(name && conf && value);
-  ASSERT(min <= max);
+    ASSERT(name && conf && value);
+    ASSERT(min <= max);
 
-  errno = 0;
-  *value = strtol(conf, &p, 10);
+    errno = 0;
+    *value = strtol(conf, &p, 10);
 
-  if(*p || errno == ERANGE || (*value < min) || (*value > max))
-  {
-    ha_messagex(LOG_ERR, "invalid configuration value '%s': must be a number between %d and %d", name, min, max);
-    return HA_FAILED;
-  }
+    if(*p || errno == ERANGE || (*value < min) || (*value > max))
+    {
+        ha_messagex(NULL, LOG_ERR, "invalid configuration value '%s': must be a number between %d and %d", name, min, max);
+        return HA_FAILED;
+    }
 
-  return HA_OK;
+    return HA_OK;
 }
 
 
@@ -259,366 +270,366 @@ int ha_confint(const char* name, const char* conf, int min, int max, int* value)
 
 char* ha_uriformat(ha_buffer_t* buf, const ha_uri_t* uri)
 {
-  ASSERT(buf && uri);
+    ASSERT(buf && uri);
 
-  /* This creates a new block */
-  ha_bufcpy(buf, "");
+    /* This creates a new block */
+    ha_bufcpy(buf, "");
+
+    if(uri->host)
+    {
+        const char* l = "";
+        const char* r = "";
 
-  if(uri->host)
-  {
-    const char* l = "";
-    const char* r = "";
+        ha_bufmcat(buf, uri->scheme ? uri->scheme : "http",
+                   "://", NULL);
 
-    ha_bufmcat(buf, uri->scheme ? uri->scheme : "http",
-                    "://", NULL);
+        if(uri->user)
+        {
+            ha_bufjoin(buf);
+            ha_bufmcat(buf, uri->user,
+                       uri->pw ? ":" : "",
+                       uri->pw ? uri->pw : "",
+                       "@", NULL);
+        }
 
-    if(uri->user)
+        if(strchr(uri->host, ':')) /* v6 ip */
+        {
+            l = "[";
+            r = "]";
+        }
+
+        ha_bufjoin(buf);
+        ha_bufmcat(buf, l, uri->host, r, NULL);
+    }
+
+    if(uri->path)
     {
-      ha_bufjoin(buf);
-      ha_bufmcat(buf, uri->user,
-                      uri->pw ? ":" : "",
-                      uri->pw ? uri->pw : "",
-                      "@", NULL);
+        ha_bufjoin(buf);
+        ha_bufmcat(buf, "/", uri->path);
     }
 
-    if(strchr(uri->host, ':')) /* v6 ip */
+    if(uri->query)
     {
-      l = "[";
-      r = "]";
+        ha_bufjoin(buf);
+        ha_bufmcat(buf, "?", uri->query);
     }
 
-    ha_bufjoin(buf);
-    ha_bufmcat(buf, l, uri->host, r, NULL);
-  }
-
-  if(uri->path)
-  {
-    ha_bufjoin(buf);
-    ha_bufmcat(buf, "/", uri->path);
-  }
-
-  if(uri->query)
-  {
-    ha_bufjoin(buf);
-    ha_bufmcat(buf, "?", uri->query);
-  }
-
-  if(uri->fragment)
-  {
-    ha_bufjoin(buf);
-    ha_bufmcat(buf, "#", uri->fragment);
-  }
-
-  return ha_bufdata(buf);
+    if(uri->fragment)
+    {
+        ha_bufjoin(buf);
+        ha_bufmcat(buf, "#", uri->fragment);
+    }
+
+    return ha_bufdata(buf);
 }
 
 int ha_uriparse(ha_buffer_t* buf, const char* suri, ha_uri_t* uri)
 {
-  char* s;
-  char* s1;
-  char* hostinfo;
-  char* endstr;
-  char* str;
-  int port;
-  int v6_offset1 = 0;
-
-  ASSERT(buf && suri && uri);
+    char* s;
+    char* s1;
+    char* hostinfo;
+    char* endstr;
+    char* str;
+    int port;
+    int v6_offset1 = 0;
 
-  /* TODO: We need to http decode the uri */
+    ASSERT(buf && suri && uri);
 
-  /* Copy the memory */
-  str = ha_bufcpy(buf, suri);
+    /* TODO: We need to http decode the uri */
 
-  if(!str)
-    return HA_CRITERROR;
+    /* Copy the memory */
+    str = ha_bufcpy(buf, suri);
 
-  /* Initialize the structure */
-  memset(uri, 0, sizeof(*uri));
+    if(!str)
+        return HA_CRITERROR;
 
-  /*
-   * We assume the processor has a branch predictor like most --
-   * it assumes forward branches are untaken and backwards are taken.  That's
-   * the reason for the gotos.  -djg
-   */
-
-  if(str[0] == '/')
-  {
-deal_with_path:
-    *str == 0;
-    ++str;
+    /* Initialize the structure */
+    memset(uri, 0, sizeof(*uri));
 
     /*
-     * we expect uri to point to first character of path ... remember
-     * that the path could be empty -- http://foobar?query for example
+     * We assume the processor has a branch predictor like most --
+     * it assumes forward branches are untaken and backwards are taken.  That's
+     * the reason for the gotos.  -djg
      */
-    s = str;
-    while(*s && *s != '?' && *s != '#')
-      ++s;
-
-    if(s != str)
-      uri->path = str;
 
-    if(*s == 0)
-      return HA_OK;
-
-    if(*s == '?')
+    if(str[0] == '/')
     {
-      *s = 0;
-      ++s;
-      uri->query = s;
+deal_with_path:
+        *str == 0;
+        ++str;
 
-      s1 = strchr(s, '#');
-      if(s1)
-      {
-        *s1 = 0;
-        ++s1;
-        uri->fragment = s1;
-      }
+        /*
+         * we expect uri to point to first character of path ... remember
+         * that the path could be empty -- http://foobar?query for example
+         */
+        s = str;
+        while(*s && *s != '?' && *s != '#')
+            ++s;
 
-      return HA_OK;
-    }
+        if(s != str)
+            uri->path = str;
 
-    *s = 0;
-    ++s;
+        if(*s == 0)
+            return HA_OK;
 
-    /* otherwise it's a fragment */
-    uri->fragment = s;
-    return HA_OK;
-  }
+        if(*s == '?')
+        {
+            *s = 0;
+            ++s;
+            uri->query = s;
+
+            s1 = strchr(s, '#');
+            if(s1)
+            {
+                *s1 = 0;
+                ++s1;
+                uri->fragment = s1;
+            }
+
+            return HA_OK;
+        }
+
+        *s = 0;
+        ++s;
 
-  /* find the scheme: */
-  s = str;
+        /* otherwise it's a fragment */
+        uri->fragment = s;
+        return HA_OK;
+    }
 
-  while(*s && *s != ':' && *s != '/' && *s != '?' && *s != '#')
-    s++;
+    /* find the scheme: */
+    s = str;
 
-  /* scheme must be non-empty and followed by :// */
-  if(s == str || s[0] != ':' || s[1] != '/' || s[2] != '/')
-    goto deal_with_path;        /* backwards predicted taken! */
+    while(*s && *s != ':' && *s != '/' && *s != '?' && *s != '#')
+        s++;
 
-  uri->scheme = str;
-  *s = 0;
-  s += 3;
+    /* scheme must be non-empty and followed by :// */
+    if(s == str || s[0] != ':' || s[1] != '/' || s[2] != '/')
+        goto deal_with_path;        /* backwards predicted taken! */
 
-  hostinfo = s;
+    uri->scheme = str;
+    *s = 0;
+    s += 3;
 
-  while(*s && *s != '/' && *s != '?' && *s != '#')
-    ++s;
+    hostinfo = s;
 
-  str = s;        /* whatever follows hostinfo is start of uri */
+    while(*s && *s != '/' && *s != '?' && *s != '#')
+        ++s;
 
-  /*
-   * If there's a username:password@host:port, the @ we want is the last @...
-   * too bad there's no memrchr()... For the C purists, note that hostinfo
-   * is definately not the first character of the original uri so therefore
-   * &hostinfo[-1] < &hostinfo[0] ... and this loop is valid C.
-   */
-  do
-  {
-    --s;
-  }
-  while(s >= hostinfo && *s != '@');
+    str = s;        /* whatever follows hostinfo is start of uri */
 
-  if(s < hostinfo)
-  {
-    /* again we want the common case to be fall through */
-deal_with_host:
     /*
-     * We expect hostinfo to point to the first character of
-     * the hostname.  If there's a port it is the first colon,
-     * except with IPv6.
+     * If there's a username:password@host:port, the @ we want is the last @...
+     * too bad there's no memrchr()... For the C purists, note that hostinfo
+     * is definately not the first character of the original uri so therefore
+     * &hostinfo[-1] < &hostinfo[0] ... and this loop is valid C.
      */
-    if(*hostinfo == '[')
+    do
     {
-      v6_offset1 = 1;
-
-      s = str;
-      for(;;)
-      {
         --s;
+    }
+    while(s >= hostinfo && *s != '@');
 
-        if(s < hostinfo)
+    if(s < hostinfo)
+    {
+        /* again we want the common case to be fall through */
+deal_with_host:
+        /*
+         * We expect hostinfo to point to the first character of
+         * the hostname.  If there's a port it is the first colon,
+         * except with IPv6.
+         */
+        if(*hostinfo == '[')
         {
-          s = NULL; /* no port */
-          break;
+            v6_offset1 = 1;
+
+            s = str;
+            for(;;)
+            {
+                --s;
+
+                if(s < hostinfo)
+                {
+                    s = NULL; /* no port */
+                    break;
+                }
+
+                else if(*s == ']')
+                {
+                    *s = 0;
+                    s = NULL; /* no port */;
+                    break;
+                }
+
+                else if(*s == ':')
+                {
+                    *s = 0;
+                    ++s;    /* found a port */
+                    break;
+                }
+            }
         }
 
-        else if(*s == ']')
+        else
         {
-          *s = 0;
-          s = NULL; /* no port */;
-          break;
+            s = memchr(hostinfo, ':', str - hostinfo);
+            if(s)
+            {
+                *s = 0;
+                ++s;
+            }
         }
 
-        else if(*s == ':')
+        uri->host = hostinfo + v6_offset1;
+
+        if(s == NULL)
         {
-          *s = 0;
-          ++s;    /* found a port */
-          break;
+            /* we expect the common case to have no port */
+            goto deal_with_path;
         }
-      }
-    }
 
-    else
-    {
-      s = memchr(hostinfo, ':', str - hostinfo);
-      if(s)
-      {
-        *s = 0;
-        ++s;
-      }
+        if(str != s)
+        {
+            port = strtol(s, &endstr, 10);
+            uri->port = port;
+            if(*endstr != '\0')
+                return HA_FAILED;
+        }
+
+        goto deal_with_path;
     }
 
-    uri->host = hostinfo + v6_offset1;
+    /* Remove the @ symbol */
+    *s = 0;
 
-    if(s == NULL)
+    /* first colon delimits username:password */
+    s1 = memchr(hostinfo, ':', s - hostinfo);
+    if(s1)
     {
-      /* we expect the common case to have no port */
-      goto deal_with_path;
-    }
+        *s1 = 0;
+        ++s1;
 
-    if(str != s)
+        uri->user = hostinfo;
+        uri->pw = s1;
+    }
+    else
     {
-      port = strtol(s, &endstr, 10);
-      uri->port = port;
-      if(*endstr != '\0')
-        return HA_FAILED;
+        str = hostinfo;
     }
 
-    goto deal_with_path;
-  }
-
-  /* Remove the @ symbol */
-  *s = 0;
-
-  /* first colon delimits username:password */
-  s1 = memchr(hostinfo, ':', s - hostinfo);
-  if(s1)
-  {
-    *s1 = 0;
-    ++s1;
-
-    uri->user = hostinfo;
-    uri->pw = s1;
-  }
-  else
-  {
-    str = hostinfo;
-  }
-
-  hostinfo = s + 1;
-  goto deal_with_host;
+    hostinfo = s + 1;
+    goto deal_with_host;
 }
 
-int uri_cmp_part_s(const char* s1, const char* s2, const char* def, int cs)
+static int uri_cmp_part_s(const char* s1, const char* s2, const char* def, int cs)
 {
-  if(def)
-  {
-    if(s1 && strcmp(def, s1) == 0)
-      s1 = NULL;
-    if(s2 && strcmp(def, s2) == 0)
-      s2 = NULL;
-  }
-
-  if(!s1 && !s2)
-    return 0;
+    if(def)
+    {
+        if(s1 && strcmp(def, s1) == 0)
+            s1 = NULL;
+        if(s2 && strcmp(def, s2) == 0)
+            s2 = NULL;
+    }
+
+    if(!s1 && !s2)
+        return 0;
 
-  if(!s1)
-    return -1;
+    if(!s1)
+        return -1;
 
-  if(!s2)
-    return 1;
+    if(!s2)
+        return 1;
 
-  return cs ? strcasecmp(s1, s2) : strcmp(s1, s2);
+    return cs ? strcasecmp(s1, s2) : strcmp(s1, s2);
 }
 
-int uri_cmp_part_n(int n1, int n2, int def)
+static int uri_cmp_part_n(int n1, int n2, int def)
 {
-  if(def)
-  {
-    if(n1 == def)
-      n1 = 0;
-    if(n2 == def)
-      n2 = 0;
-  }
-
-  if(n1 == n2)
-    return 0;
+    if(def)
+    {
+        if(n1 == def)
+            n1 = 0;
+        if(n2 == def)
+            n2 = 0;
+    }
+
+    if(n1 == n2)
+        return 0;
 
-  else if(n1 < n2)
-    return -1;
+    else if(n1 < n2)
+        return -1;
 
-  else if(n2 > n1)
-    return 1;
+    else if(n2 > n1)
+        return 1;
 
-  /* Not reached */
-  ASSERT(0);
+    /* Not reached */
+    ASSERT(0);
 }
 
 int ha_uricmp(ha_uri_t* one, ha_uri_t* two)
 {
-  int r;
+    int r;
 
-  ASSERT(one && two);
+    ASSERT(one && two);
 
-  /* We don't compare user or password */
+    /* We don't compare user or password */
 
-  /* The scheme */
-  if((r = uri_cmp_part_s(one->scheme, two->scheme, "http", 0)) != 0 ||
-     (r = uri_cmp_part_s(one->host, two->host, NULL, 1)) != 0 != 0 ||
-     (r = uri_cmp_part_n(one->port, two->port, 80)) != 0 ||
-     (r = uri_cmp_part_s(one->path, two->path, NULL, 0)) != 0 ||
-     (r = uri_cmp_part_s(one->query, two->query, NULL, 0)) != 0 ||
-     (r = uri_cmp_part_s(one->fragment, two->fragment, NULL, 0)))
-    return r;
+    /* The scheme */
+    if((r = uri_cmp_part_s(one->scheme, two->scheme, "http", 0)) != 0 ||
+       (r = uri_cmp_part_s(one->host, two->host, NULL, 1)) != 0 != 0 ||
+       (r = uri_cmp_part_n(one->port, two->port, 80)) != 0 ||
+       (r = uri_cmp_part_s(one->path, two->path, NULL, 0)) != 0 ||
+       (r = uri_cmp_part_s(one->query, two->query, NULL, 0)) != 0 ||
+       (r = uri_cmp_part_s(one->fragment, two->fragment, NULL, 0)))
+        return r;
 
-  return 0;
+    return 0;
 }
 
 int ha_genrandom(unsigned char* data, size_t len)
 {
-  int r, dd;
-
-  ASSERT(data && len > 0);
-
-  dd = open("/dev/urandom", O_RDONLY);
-  if(dd == -1)
-  {
-    ha_message(LOG_ERR, "couldn't open /dev/urandom");
-    return HA_FAILED;
-  }
+    int r, dd;
 
-  for(;;)
-  {
-    r = read(dd, data, len);
+    ASSERT(data && len > 0);
 
-    if(r == -1)
+    dd = open("/dev/urandom", O_RDONLY);
+    if(dd == -1)
     {
-      switch(errno)
-      {
-      case EINTR:
-      case EAGAIN:
-        continue;
-
-      default:
-        ha_message(LOG_ERR, "couldn't read random bytes from /dev/urandom");
-        break;
-      }
-
-      break;
+        ha_message(NULL, LOG_ERR, "couldn't open /dev/urandom");
+        return HA_FAILED;
     }
 
-    else if(r >= 0)
+    for(;;)
     {
-      if(r >= len)
-        break;
+        r = read(dd, data, len);
+
+        if(r == -1)
+        {
+            switch(errno)
+            {
+            case EINTR:
+            case EAGAIN:
+                continue;
+
+            default:
+                ha_message(NULL, LOG_ERR, "couldn't read random bytes from /dev/urandom");
+                break;
+            };
+
+            break;
+        }
 
-      len -= r;
-      data += r;
+        else if(r >= 0)
+        {
+            if(r >= len)
+                break;
+
+            len -= r;
+            data += r;
+        }
     }
-  }
 
-  close(dd);
-  return r == -1 ? HA_FAILED : HA_OK;
+    close(dd);
+    return r == -1 ? HA_FAILED : HA_OK;
 }
 
diff --git a/daemon/ntlm.c b/daemon/ntlm.c
index 031e19d..63d4580 100644
--- a/daemon/ntlm.c
+++ b/daemon/ntlm.c
@@ -19,7 +19,7 @@
  */
 
 #define NTLM_HASH_KEY_LEN MD5_LEN
-#define NTLM_ESTABLISHED  (void*)1
+#define NTLM_ESTABLISHED    (void*)1
 
 
 /* -------------------------------------------------------------------------------
@@ -29,9 +29,9 @@
 /* A pending connection */
 typedef struct ntlm_connection
 {
-  void* handle;
-  char nonce[NONCE_LEN];
-  unsigned int flags;
+    void* handle;
+    char nonce[NONCE_LEN];
+    unsigned int flags;
 }
 ntlm_connection_t;
 
@@ -39,16 +39,16 @@ ntlm_connection_t;
 /* The main context */
 typedef struct ntlm_context
 {
-  /* Settings ---------------------------------------------------------- */
-  const char* server;       /* Server to authenticate against */
-  const char* domain;       /* NTLM domain to authenticate against */
-  const char* backup;       /* Backup server if primary is down */
-  int pending_max;          /* Maximum number of connections at once */
-  int pending_timeout;      /* Timeout for authentication (in seconds) */
-
-  /* Context ----------------------------------------------------------- */
-  hsh_t* pending;        /* Pending connections */
-  hsh_t* established;    /* Established connections */
+    /* Settings ---------------------------------------------------------- */
+    const char* server;             /* Server to authenticate against */
+    const char* domain;             /* NTLM domain to authenticate against */
+    const char* backup;             /* Backup server if primary is down */
+    int pending_max;                    /* Maximum number of connections at once */
+    int pending_timeout;            /* Timeout for authentication (in seconds) */
+
+    /* Context ----------------------------------------------------------- */
+    hsh_t* pending;                /* Pending connections */
+    hsh_t* established;        /* Established connections */
 }
 ntlm_context_t;
 
@@ -56,8 +56,8 @@ ntlm_context_t;
 /* The default context settings */
 static const ntlm_context_t ntlm_defaults =
 {
-  NULL, NULL, NULL, DEFAULT_PENDING_MAX, DEFAULT_PENDING_TIMEOUT,
-  NULL, NULL
+    NULL, NULL, NULL, DEFAULT_PENDING_MAX, DEFAULT_PENDING_TIMEOUT,
+    NULL, NULL
 };
 
 
@@ -70,467 +70,467 @@ static pthread_mutexattr_t g_smblib_mutexattr;
  * Internal Functions
  */
 
-static ntlm_connection_t* makeconnection(ntlm_context_t* ctx)
+static ntlm_connection_t* makeconnection(ha_request_t* rq, ntlm_context_t* ctx)
 {
-  ntlm_connection_t* conn;
-
-  ASSERT(ctx);
-
-  conn = (ntlm_connection_t*)malloc(sizeof(ntlm_connection_t));
-  if(!conn)
-  {
-    ha_messagex(LOG_CRIT, "out of memory");
-    return NULL;
-  }
-
-  memset(conn, 0, sizeof(*conn));
-
-  /*
-   * Open a connection to to the domain controller. I don't think
-   * we can cache these connections or use them again as opening
-   * a connection here results in an nonce being generated.
-   */
-  conn->handle = ntlmssp_connect(ctx->server, ctx->backup,
-                                 ctx->domain, conn->nonce);
-  if(!conn->handle)
-  {
-    ha_messagex(LOG_ERR, "ntlm: couldn't connect to the domain server %s (backup: %s)",
-             ctx->server, ctx->backup ? ctx->backup : "none");
-    free(conn);
-    return NULL;
-  }
+    ntlm_connection_t* conn;
+
+    ASSERT(ctx);
+
+    conn = (ntlm_connection_t*)malloc(sizeof(ntlm_connection_t));
+    if(!conn)
+    {
+        ha_messagex(NULL, LOG_CRIT, "out of memory");
+        return NULL;
+    }
+
+    memset(conn, 0, sizeof(*conn));
+
+    /*
+     * Open a connection to to the domain controller. I don't think
+     * we can cache these connections or use them again as opening
+     * a connection here results in an nonce being generated.
+     */
+    conn->handle = ntlmssp_connect(ctx->server, ctx->backup,
+                                                                 ctx->domain, conn->nonce);
+    if(!conn->handle)
+    {
+        ha_messagex(rq, LOG_ERR, "couldn't connect to the domain server %s (backup: %s)",
+                    ctx->server, ctx->backup ? ctx->backup : "none");
+        free(conn);
+        return NULL;
+    }
 
-  ha_messagex(LOG_INFO, "ntlm: established connection to server");
-  return conn;
+    ha_messagex(rq, LOG_INFO, "established connection to server");
+    return conn;
 }
 
-static void freeconnection(ntlm_connection_t* conn)
+static void freeconnection(ha_request_t* rq, ntlm_connection_t* conn)
 {
-  ASSERT(conn);
+    ASSERT(conn);
 
-  if(conn->handle)
-  {
-    ha_messagex(LOG_DEBUG, "ntlm: disconnected from server");
-    ntlmssp_disconnect(conn->handle);
-    conn->handle = NULL;
-  }
+    if(conn->handle)
+    {
+        ha_messagex(rq, LOG_DEBUG, "disconnected from server");
+        ntlmssp_disconnect(conn->handle);
+        conn->handle = NULL;
+    }
 
-  free(conn);
+    free(conn);
 }
 
 static void free_hash_object(void* arg, void* val)
 {
-  if(val)
-  {
-    ASSERT(val != NTLM_ESTABLISHED);
-    freeconnection((ntlm_connection_t*)val);
-  }
+    if(val)
+    {
+        ASSERT(val != NTLM_ESTABLISHED);
+        freeconnection(NULL, (ntlm_connection_t*)val);
+    }
 }
 
 static ntlm_connection_t* getpending(ntlm_context_t* ctx, const void* key)
 {
-  ntlm_connection_t* ret;
+    ntlm_connection_t* ret;
 
-  ASSERT(ctx && key);
+    ASSERT(ctx && key);
 
-  ha_lock(NULL);
+    ha_lock(NULL);
 
-    ret = (ntlm_connection_t*)hsh_rem(ctx->pending, key);
+        ret = (ntlm_connection_t*)hsh_rem(ctx->pending, key);
 
-  ha_unlock(NULL);
+    ha_unlock(NULL);
 
-  return ret;
+    return ret;
 }
 
 static int putpending(ntlm_context_t* ctx, const void* key, ntlm_connection_t* conn)
 {
-  int r = 0;
+    int r = 0;
 
-  ASSERT(ctx && key && conn);
-  ASSERT(conn->handle);
+    ASSERT(ctx && key && conn);
+    ASSERT(conn->handle);
 
-  if(!hsh_get(ctx->pending, key))
-  {
-    ha_lock(NULL);
+    if(!hsh_get(ctx->pending, key))
+    {
+        ha_lock(NULL);
 
-      if(!hsh_set(ctx->pending, key, (void*)conn))
-      {
-        free_hash_object(NULL, conn);
-        ha_messagex(LOG_ERR, "out of memory");
-        r = -1;
-      }
+            if(!hsh_set(ctx->pending, key, (void*)conn))
+            {
+                free_hash_object(NULL, conn);
+                ha_messagex(NULL, LOG_ERR, "out of memory");
+                r = -1;
+            }
 
-    ha_unlock(NULL);
-  }
+        ha_unlock(NULL);
+    }
 
-  return r;
+    return r;
 }
 
-int ntlm_auth_basic(ntlm_context_t* ctx, char* key, const char* header,
-                    ha_response_t* resp, ha_buffer_t* buf)
+int ntlm_auth_basic(ha_request_t* rq, ntlm_context_t* ctx, char* key,
+                    const char* header)
 {
-  ntlm_connection_t* conn;
-  char* t;
-  basic_header_t basic;
-  const char* domain = NULL;
-  int found = 0;
-  int r;
-
-  ASSERT(ctx && key && header && resp && buf);
-
-  /*
-   * We're doing basic authentication on the connection
-   * which invalidates any NTLM authentication we've started
-   * or done on this connection.
-   */
-  conn = getpending(ctx, key);
-  if(conn)
-  {
-    ha_messagex(LOG_WARNING, "ntlm: basic auth killed a pending ntlm auth in progress");
-    freeconnection(conn);
-  }
-
-  if((r = basic_parse(header, buf, &basic)) < 0)
-    return r;
-
-  /* Check and see if this connection is in the cache */
-  ha_lock(NULL);
-
-    if(hsh_get(ctx->established, basic.key) == NTLM_ESTABLISHED)
-      found = 1;
-
-  ha_unlock(NULL);
-
-  if(found)
-    ha_messagex(LOG_NOTICE, "ntlm: validated basic user against cache: %s", basic.user);
+    ntlm_connection_t* conn;
+    char* t;
+    basic_header_t basic;
+    const char* domain = NULL;
+    int found = 0;
+    int r;
 
-  else
-  {
-    /* Try to find a domain in the user */
-    if((t = strchr(basic.user, '\\')) != NULL ||
-       (t = strchr(basic.user, '/')) != NULL)
-    {
-      /* Break at the domain */
-      domain = basic.user;
-      basic.user = t + 1;
-      *t = 0;
-
-      /* Make sure this is our domain */
-      if(strcasecmp(domain, ctx->domain) != 0)
-         domain = NULL;
-    }
+    ASSERT(ctx && key && header && rq);
 
-    if(!domain)
+    /*
+     * We're doing basic authentication on the connection
+     * which invalidates any NTLM authentication we've started
+     * or done on this connection.
+     */
+    conn = getpending(ctx, key);
+    if(conn)
     {
-      /* Use the default domain if none specified */
-      domain = ctx->domain;
+        ha_messagex(rq, LOG_WARNING, "basic auth killed a pending ntlm auth in progress");
+        freeconnection(rq, conn);
     }
 
-    /* Make sure above did not fail */
-    if(basic.user && basic.user[0] && basic.password &&
-       domain && domain[0])
-    {
-      ha_messagex(LOG_DEBUG, "ntlm: checking user against server: %s", basic.user);
-
-      /* We need to lock to go into smblib */
-      ha_lock(&g_smblib_mutex);
-
-        /* Found in smbval/valid.h */
-        if(ntlmssp_validuser(basic.user, basic.password, ctx->server,
-                             ctx->backup, domain) == NTV_NO_ERROR)
-        {
-           /* If valid then we return */
-           found = 1;
-        }
-
-      ha_unlock(&g_smblib_mutex);
-    }
-
-    if(found)
-      ha_messagex(LOG_NOTICE, "ntlm: validated basic user against server: %s", basic.user);
-  }
-
-  if(found)
-  {
-    int r;
-    resp->code = HA_SERVER_OK;
-    resp->detail = basic.user;
+    if((r = basic_parse(header, rq->buf, &basic)) < 0)
+        return r;
 
+    /* Check and see if this connection is in the cache */
     ha_lock(NULL);
 
-      /* We put this connection into the successful connections */
-      r = hsh_set(ctx->established, basic.key, NTLM_ESTABLISHED);
+        if(hsh_get(ctx->established, basic.key) == NTLM_ESTABLISHED)
+            found = 1;
 
     ha_unlock(NULL);
 
-    if(!r)
-    {
-      ha_messagex(LOG_CRIT, "out of memory");
-      return HA_CRITERROR;
-    }
-
-    return HA_OK;
-  }
-
-  return HA_FALSE;
-}
+    if(found)
+        ha_messagex(rq, LOG_NOTICE, "validated basic user against cache: %s", basic.user);
 
-int ntlm_auth_ntlm(ntlm_context_t* ctx, void* key, const char* header,
-                   ha_response_t* resp, ha_buffer_t* buf)
-{
-  ntlmssp_info_rec ntlmssp;
-  ntlm_connection_t* conn = NULL;
-  unsigned int flags = 0;
-  int ret = HA_FALSE;
-  size_t len = 0;
-  void* d;
-  int r;
-
-  ASSERT(ctx && key && header && resp && buf);
-
-  /*
-   * Retrieve and remove the connection from the pending bag.
-   * We add it back again below if that's necessary.
-   */
-  conn = getpending(ctx, key);
-
-  /*
-   * We use the flags from an already established connection
-   * if we've been pending and stuff
-   */
-
-  if(conn && conn->flags)
-    flags = conn->flags;
-
-  /*
-   * First we figure out what kind of message the client
-   * is sending us.
-   */
-
-  d = ha_bufdec64(buf, header, &len);
-
-  if(!d || len == 0)
-    goto finally;
-
-  r = ntlmssp_decode_msg(&ntlmssp, d, len, &flags);
-  if(r != 0)
-  {
-    ha_messagex(LOG_WARNING, "ntlm: decoding NTLMSSP message failed (error %d)", r);
-    resp->code = HA_SERVER_BADREQ;
-    goto finally;
-  }
-
-
-  switch(ntlmssp.msg_type)
-  {
-
-  /* An initial NTLM request? */
-  case 1:
+    else
     {
-      /* Win9x doesn't seem to send a domain or host */
-      int win9x = !ntlmssp.host[0] && !ntlmssp.domain[0];
-
-      /*
-       * If we already have a connection to the domain controller
-       * then we're in trouble. Basically this is the second
-       * type 1 message we've received over this connection.
-       *
-       * TODO: Eventually what we want to do here is wait for the
-       * other authentication request to complete, or something
-       * like that.
-       */
-      if(conn)
-      {
-        /*
-         * In this case we also add the connection back into the
-         * pending stack so that the correct request will complete
-         * properly when it comes through.
-         */
-        r = putpending(ctx, key, conn);
-        conn = NULL;
-
-        if(r < 0)
+        /* Try to find a domain in the user */
+        if((t = strchr(basic.user, '\\')) != NULL ||
+           (t = strchr(basic.user, '/')) != NULL)
         {
-          ret = HA_CRITERROR;
+            /* Break at the domain */
+            domain = basic.user;
+            basic.user = t + 1;
+            *t = 0;
+
+            /* Make sure this is our domain */
+            if(strcasecmp(domain, ctx->domain) != 0)
+                 domain = NULL;
         }
-        else
+
+        if(!domain)
         {
-          ha_messagex(LOG_ERR, "ntlm: received out of order NTLM request from client");
-          resp->code = HA_SERVER_BADREQ;
+            /* Use the default domain if none specified */
+            domain = ctx->domain;
         }
 
-        goto finally;
-      }
-
+        /* Make sure above did not fail */
+        if(basic.user && basic.user[0] && basic.password &&
+             domain && domain[0])
+        {
+            ha_messagex(rq, LOG_DEBUG, "checking user against server: %s", basic.user);
 
-      /*
-       * Check how many connections we have to the domain controller
-       * and if too many then cut off here.
-       */
-      if(ctx->pending_max != -1)
-      {
-        ha_lock(NULL);
+            /* We need to lock to go into smblib */
+            ha_lock(&g_smblib_mutex);
 
-          if(hsh_count(ctx->pending) >= ctx->pending_max)
-            hsh_bump(ctx->pending);
+                /* Found in smbval/valid.h */
+                if(ntlmssp_validuser(basic.user, basic.password, ctx->server,
+                                     ctx->backup, domain) == NTV_NO_ERROR)
+                {
+                     /* If valid then we return */
+                     found = 1;
+                }
 
-        ha_unlock(NULL);
-      }
+            ha_unlock(&g_smblib_mutex);
+        }
 
+        if(found)
+            ha_messagex(rq, LOG_NOTICE, "validated basic user against server: %s", basic.user);
+    }
 
-      /*
-       * Open a connection to to the domain controller. I don't think
-       * we can cache these connections or use them again as opening
-       * a connection here results in an nonce being generated.
-       */
-      conn = makeconnection(ctx);
+    if(found)
+    {
+        int r;
+        rq->resp_code = HA_SERVER_OK;
+        rq->resp_detail = basic.user;
 
-      if(!conn)
-      {
-        ret = HA_FAILED;
-        goto finally;
-      }
-
-      /* Save away any flags given us by ntlm_decode_msg */
-      conn->flags = flags;
-
-      /* Start building the header */
-      ha_bufcpy(buf, HA_PREFIX_NTLM);
-
-      if(win9x)
-      {
-        struct ntlm_msg2_win9x msg_win9x;
-        ntlmssp_encode_msg2_win9x(conn->nonce, &msg_win9x, (char*)ctx->domain, flags);
-        ha_bufjoin(buf);
-        ha_bufenc64(buf, (unsigned char*)&msg_win9x, sizeof(msg_win9x));
-      }
-      else
-      {
-        struct ntlm_msg2 msg;
-        ntlmssp_encode_msg2(conn->nonce, &msg);
-        ha_bufjoin(buf);
-        ha_bufenc64(buf, (unsigned char*)&msg, sizeof(msg));
-      }
-
-      if(ha_buferr(buf))
-        goto finally;
+        ha_lock(NULL);
 
-      /*
-       * TODO: Our callers need to be able to keep alive
-       * connections that have authentication going on.
-       */
+            /* We put this connection into the successful connections */
+            r = hsh_set(ctx->established, basic.key, NTLM_ESTABLISHED);
 
-      /* Cache this connection in our pending set ... */
-      r = putpending(ctx, key, conn);
+        ha_unlock(NULL);
 
-      /*
-       * By marking this as null, the cleanup code
-       * won't free the connection since it's been
-       * cached above.
-       */
-      conn = NULL;
+        if(!r)
+        {
+            ha_messagex(NULL, LOG_CRIT, "out of memory");
+            return HA_CRITERROR;
+        }
 
-      if(r < 0)
-      {
-        ret = HA_CRITERROR;
-      }
-      else
-      {
-        ha_messagex(LOG_DEBUG, "ntlm: sending ntlm challenge");
-        ha_addheader(resp, "WWW-Authenticate", ha_bufdata(buf));
-        resp->code = HA_SERVER_DECLINE;
-      }
-      goto finally;
+        return HA_OK;
     }
 
-  /* A response to a challenge */
-  case 3:
-    {
-      /*
-       * We need to have a connection at this point or this whole thing
-       * has come in in the wrong order. Actually it's a client error
-       * for stuff to come in wrong. But since some web servers also
-       * kill keep-alives and stuff, we forgive and just ask the client
-       * for the authentication info again.
-       */
-      if(!conn || !conn->handle)
-      {
-        ha_messagex(LOG_WARNING, "ntlm: received out of order NTLM response from client");
-        resp->code = HA_SERVER_BADREQ;
-        goto finally;
-      }
+    return HA_FALSE;
+}
 
-      if(!ntlmssp.user)
-      {
-        ha_messagex(LOG_WARNING, "ntlm: received NTLM response without user name");
-        resp->code = HA_SERVER_BADREQ;
-        goto finally;
-      }
+int ntlm_auth_ntlm(ha_request_t* rq, ntlm_context_t* ctx, void* key,
+                   const char* header)
+{
+    ntlmssp_info_rec ntlmssp;
+    ntlm_connection_t* conn = NULL;
+    unsigned int flags = 0;
+    int ret = HA_FALSE;
+    size_t len = 0;
+    void* d;
+    int r;
 
-      /* We have to lock while going into smblib */
-      ha_lock(&g_smblib_mutex);
+    ASSERT(ctx && key && header && rq);
 
-        /* Now authenticate them against the DC */
-        r = ntlmssp_auth(conn->handle, ntlmssp.user, ntlmssp.nt, 1,
-                      ntlmssp.domain[0] ? (char*)ntlmssp.domain : (char*)ctx->domain);
+    /*
+     * Retrieve and remove the connection from the pending bag.
+     * We add it back again below if that's necessary.
+     */
+    conn = getpending(ctx, key);
 
-      ha_unlock(&g_smblib_mutex);
+    /*
+     * We use the flags from an already established connection
+     * if we've been pending and stuff
+     */
 
-      /* The connection gets disconnected below */
+    if(conn && conn->flags)
+        flags = conn->flags;
 
-      if(r == NTV_LOGON_ERROR)
-      {
-        /*
-         * Note that we don't set a code here. This causes our
-         * caller to put in all the proper headers for us.
-         */
-        ha_messagex(LOG_WARNING, "ntlm: failed NTLM logon for user '%s'", ntlmssp.user);
-        ret = HA_FALSE;
-      }
+    /*
+     * First we figure out what kind of message the client
+     * is sending us.
+     */
 
-      /* A successful login ends here */
-      else
-      {
-        int r;
-        resp->detail = ntlmssp.user;
-        ha_messagex(LOG_NOTICE, "ntlm: validated ntlm user against server", ntlmssp.user);
+    d = ha_bufdec64(rq->buf, header, &len);
 
-        ha_lock(NULL);
+    if(!d || len == 0)
+        goto finally;
 
-          /* We put this connection into the successful connections */
-          r = hsh_set(ctx->established, key, NTLM_ESTABLISHED);
+    r = ntlmssp_decode_msg(&ntlmssp, d, len, &flags);
+    if(r != 0)
+    {
+        ha_messagex(rq, LOG_WARNING, "decoding NTLMSSP message failed (error %d)", r);
+        rq->resp_code = HA_SERVER_BADREQ;
+        goto finally;
+    }
 
-        ha_unlock(NULL);
 
-        if(!r)
+    switch(ntlmssp.msg_type)
+    {
+
+    /* An initial NTLM request? */
+    case 1:
         {
-          ha_messagex(LOG_CRIT, "out of memory");
-          ret = HA_CRITERROR;
+            /* Win9x doesn't seem to send a domain or host */
+            int win9x = !ntlmssp.host[0] && !ntlmssp.domain[0];
+
+            /*
+             * If we already have a connection to the domain controller
+             * then we're in trouble. Basically this is the second
+             * type 1 message we've received over this connection.
+             *
+             * TODO: Eventually what we want to do here is wait for the
+             * other authentication request to complete, or something
+             * like that.
+             */
+            if(conn)
+            {
+                /*
+                 * In this case we also add the connection back into the
+                 * pending stack so that the correct request will complete
+                 * properly when it comes through.
+                 */
+                r = putpending(ctx, key, conn);
+                conn = NULL;
+
+                if(r < 0)
+                {
+                    ret = HA_CRITERROR;
+                }
+                else
+                {
+                    ha_messagex(rq, LOG_ERR, "received out of order NTLM request from client");
+                    rq->resp_code = HA_SERVER_BADREQ;
+                }
+
+                goto finally;
+            }
+
+
+            /*
+             * Check how many connections we have to the domain controller
+             * and if too many then cut off here.
+             */
+            if(ctx->pending_max != -1)
+            {
+                ha_lock(NULL);
+
+                    if(hsh_count(ctx->pending) >= ctx->pending_max)
+                        hsh_bump(ctx->pending);
+
+                ha_unlock(NULL);
+            }
+
+
+            /*
+             * Open a connection to to the domain controller. I don't think
+             * we can cache these connections or use them again as opening
+             * a connection here results in an nonce being generated.
+             */
+            conn = makeconnection(rq, ctx);
+
+            if(!conn)
+            {
+                ret = HA_FAILED;
+                goto finally;
+            }
+
+            /* Save away any flags given us by ntlm_decode_msg */
+            conn->flags = flags;
+
+            /* Start building the header */
+            ha_bufcpy(rq->buf, HA_PREFIX_NTLM);
+
+            if(win9x)
+            {
+                struct ntlm_msg2_win9x msg_win9x;
+                ntlmssp_encode_msg2_win9x(conn->nonce, &msg_win9x, (char*)ctx->domain, flags);
+                ha_bufjoin(rq->buf);
+                ha_bufenc64(rq->buf, (unsigned char*)&msg_win9x, sizeof(msg_win9x));
+            }
+            else
+            {
+                struct ntlm_msg2 msg;
+                ntlmssp_encode_msg2(conn->nonce, &msg);
+                ha_bufjoin(rq->buf);
+                ha_bufenc64(rq->buf, (unsigned char*)&msg, sizeof(msg));
+            }
+
+            if(ha_buferr(rq->buf))
+                goto finally;
+
+            /*
+             * TODO: Our callers need to be able to keep alive
+             * connections that have authentication going on.
+             */
+
+            /* Cache this connection in our pending set ... */
+            r = putpending(ctx, key, conn);
+
+            /*
+             * By marking this as null, the cleanup code
+             * won't free the connection since it's been
+             * cached above.
+             */
+            conn = NULL;
+
+            if(r < 0)
+            {
+                ret = HA_CRITERROR;
+            }
+            else
+            {
+                ha_messagex(rq, LOG_DEBUG, "sending ntlm challenge");
+                ha_addheader(rq, "WWW-Authenticate", ha_bufdata(rq->buf));
+                rq->resp_code = HA_SERVER_DECLINE;
+            }
+            goto finally;
         }
-        else
+
+    /* A response to a challenge */
+    case 3:
         {
-          ret = HA_OK;
+            /*
+             * We need to have a connection at this point or this whole thing
+             * has come in in the wrong order. Actually it's a client error
+             * for stuff to come in wrong. But since some web servers also
+             * kill keep-alives and stuff, we forgive and just ask the client
+             * for the authentication info again.
+             */
+            if(!conn || !conn->handle)
+            {
+                ha_messagex(rq, LOG_WARNING, "received out of order NTLM response from client");
+                rq->resp_code = HA_SERVER_BADREQ;
+                goto finally;
+            }
+
+            if(!ntlmssp.user)
+            {
+                ha_messagex(rq, LOG_WARNING, "received NTLM response without user name");
+                rq->resp_code = HA_SERVER_BADREQ;
+                goto finally;
+            }
+
+            /* We have to lock while going into smblib */
+            ha_lock(&g_smblib_mutex);
+
+                /* Now authenticate them against the DC */
+                r = ntlmssp_auth(conn->handle, ntlmssp.user, ntlmssp.nt, 1,
+                                 ntlmssp.domain[0] ? (char*)ntlmssp.domain : (char*)ctx->domain);
+
+            ha_unlock(&g_smblib_mutex);
+
+            /* The connection gets disconnected below */
+
+            if(r == NTV_LOGON_ERROR)
+            {
+                /*
+                 * Note that we don't set a code here. This causes our
+                 * caller to put in all the proper headers for us.
+                 */
+                ha_messagex(rq, LOG_WARNING, "failed NTLM logon for user '%s'", ntlmssp.user);
+                ret = HA_FALSE;
+            }
+
+            /* A successful login ends here */
+            else
+            {
+                int r;
+                rq->resp_detail = ntlmssp.user;
+                ha_messagex(rq, LOG_NOTICE, "validated ntlm user against server", ntlmssp.user);
+
+                ha_lock(NULL);
+
+                    /* We put this connection into the successful connections */
+                    r = hsh_set(ctx->established, key, NTLM_ESTABLISHED);
+
+                ha_unlock(NULL);
+
+                if(!r)
+                {
+                    ha_messagex(NULL, LOG_CRIT, "out of memory");
+                    ret = HA_CRITERROR;
+                }
+                else
+                {
+                    ret = HA_OK;
+                }
+            }
+
+            goto finally;
         }
-      }
-
-      goto finally;
-    }
 
-  default:
-    ha_messagex(LOG_WARNING, "ntlm: received invalid NTLM message (type %d)", ntlmssp.msg_type);
-    resp->code = HA_SERVER_BADREQ;
-    goto finally;
-  };
+    default:
+        ha_messagex(rq, LOG_WARNING, "received invalid NTLM message (type %d)", ntlmssp.msg_type);
+        rq->resp_code = HA_SERVER_BADREQ;
+        goto finally;
+    };
 
 
 finally:
-  if(ha_buferr(buf))
-    ret = HA_CRITERROR;
+    if(ha_buferr(rq->buf))
+        ret = HA_CRITERROR;
 
-  if(conn)
-    freeconnection(conn);
+    if(conn)
+        freeconnection(rq, conn);
 
-  return ret;
+    return ret;
 }
 
 
@@ -540,245 +540,245 @@ finally:
 
 int ntlm_config(ha_context_t* context, const char* name, const char* value)
 {
-  ntlm_context_t* ctx = (ntlm_context_t*)(context->ctx_data);
+    ntlm_context_t* ctx = (ntlm_context_t*)(context->ctx_data);
 
-  ASSERT(name && value && value[0]);
+    ASSERT(name && value && value[0]);
 
-  if(strcmp(name, "ntlmserver") == 0)
-  {
-    ctx->server = value;
-    return HA_OK;
-  }
+    if(strcmp(name, "ntlmserver") == 0)
+    {
+        ctx->server = value;
+        return HA_OK;
+    }
 
-  else if(strcmp(name, "ntlmbackup") == 0)
-  {
-    ctx->backup = value;
-    return HA_OK;
-  }
+    else if(strcmp(name, "ntlmbackup") == 0)
+    {
+        ctx->backup = value;
+        return HA_OK;
+    }
 
-  else if(strcmp(name, "ntlmdomain") == 0)
-  {
-    ctx->domain = value;
-    return HA_OK;
-  }
+    else if(strcmp(name, "ntlmdomain") == 0)
+    {
+        ctx->domain = value;
+        return HA_OK;
+    }
 
-  else if(strcmp(name, "pendingmax") == 0)
-  {
-    return ha_confint(name, value, 1, 256, &(ctx->pending_max));
-  }
+    else if(strcmp(name, "pendingmax") == 0)
+    {
+        return ha_confint(name, value, 1, 256, &(ctx->pending_max));
+    }
 
-  else if(strcmp(name, "pendingtimeout") == 0)
-  {
-    return ha_confint(name, value, 1, 86400, &(ctx->pending_timeout));
-  }
+    else if(strcmp(name, "pendingtimeout") == 0)
+    {
+        return ha_confint(name, value, 1, 86400, &(ctx->pending_timeout));
+    }
 
-  return HA_FALSE;
+    return HA_FALSE;
 }
 
 int ntlm_init(ha_context_t* context)
 {
-  /* Per context initialization */
-  if(context)
-  {
-    ntlm_context_t* ctx = (ntlm_context_t*)(context->ctx_data);
-    hsh_table_calls_t htc;
+    /* Per context initialization */
+    if(context)
+    {
+        ntlm_context_t* ctx = (ntlm_context_t*)(context->ctx_data);
+        hsh_table_calls_t htc;
 
-    ASSERT(ctx);
+        ASSERT(ctx);
 
-    /* Make sure there are some types of authentication we can do */
-    if(!(context->allowed_types & (HA_TYPE_BASIC | HA_TYPE_NTLM)))
-    {
-      ha_messagex(LOG_ERR, "NTLM module configured, but does not implement any "
-                           "configured authentication type.");
-      return HA_FAILED;
-    }
+        /* Make sure there are some types of authentication we can do */
+        if(!(context->allowed_types & (HA_TYPE_BASIC | HA_TYPE_NTLM)))
+        {
+            ha_messagex(NULL, LOG_ERR, "NTLM module configured, but does not implement any "
+                                       "configured authentication type.");
+            return HA_FAILED;
+        }
 
-    /* Check for mandatory configuration */
-    if(!(ctx->server) || !(ctx->domain))
-    {
-      ha_messagex(LOG_ERR, "NTLM configuration incomplete. "
-                           "Must have NTLMServer and NTLMDomain configured.");
-      return HA_FAILED;
-    }
+        /* Check for mandatory configuration */
+        if(!(ctx->server) || !(ctx->domain))
+        {
+            ha_messagex(NULL, LOG_ERR, "NTLM configuration incomplete. "
+                                       "Must have NTLMServer and NTLMDomain configured.");
+            return HA_FAILED;
+        }
 
-    ASSERT(!ctx->pending);
-    ASSERT(!ctx->established);
+        ASSERT(!ctx->pending);
+        ASSERT(!ctx->established);
 
-    /* Initialize our tables */
-    if(!(ctx->pending = hsh_create(NTLM_HASH_KEY_LEN)) ||
-       !(ctx->established = hsh_create(NTLM_HASH_KEY_LEN)))
-    {
-      ha_messagex(LOG_CRIT, "out of memory");
-      return HA_CRITERROR;
-    }
+        /* Initialize our tables */
+        if(!(ctx->pending = hsh_create(NTLM_HASH_KEY_LEN)) ||
+           !(ctx->established = hsh_create(NTLM_HASH_KEY_LEN)))
+        {
+            ha_messagex(NULL, LOG_CRIT, "out of memory");
+            return HA_CRITERROR;
+        }
 
-    htc.f_freeval = free_hash_object;
-    htc.arg = NULL;
-    hsh_set_table_calls(ctx->pending, &htc);
+        htc.f_freeval = free_hash_object;
+        htc.arg = NULL;
+        hsh_set_table_calls(ctx->pending, &htc);
 
-    ha_messagex(LOG_INFO, "ntlm: initialized handler");
-  }
+        ha_messagex(NULL, LOG_INFO, "initialized ntlm handler");
+    }
 
-  /* Global Initialization */
-  else
-  {
-    /* Create the smblib mutex */
-    if(pthread_mutexattr_init(&g_smblib_mutexattr) != 0 ||
-       pthread_mutexattr_settype(&g_smblib_mutexattr, HA_MUTEX_TYPE) ||
-       pthread_mutex_init(&g_smblib_mutex, &g_smblib_mutexattr) != 0)
+    /* Global Initialization */
+    else
     {
-      ha_messagex(LOG_CRIT, "threading problem. can't create mutex");
-      return HA_CRITERROR;
+        /* Create the smblib mutex */
+        if(pthread_mutexattr_init(&g_smblib_mutexattr) != 0 ||
+           pthread_mutexattr_settype(&g_smblib_mutexattr, HA_MUTEX_TYPE) ||
+           pthread_mutex_init(&g_smblib_mutex, &g_smblib_mutexattr) != 0)
+        {
+            ha_messagex(NULL, LOG_CRIT, "threading problem. can't create mutex");
+            return HA_CRITERROR;
+        }
     }
-  }
 
-  return HA_OK;
+    return HA_OK;
 }
 
 void ntlm_destroy(ha_context_t* context)
 {
-  /* Per context destroy */
-  if(context)
-  {
-    /* Note: We don't need to be thread safe here anymore */
-    ntlm_context_t* ctx = (ntlm_context_t*)(context->ctx_data);
+    /* Per context destroy */
+    if(context)
+    {
+        /* Note: We don't need to be thread safe here anymore */
+        ntlm_context_t* ctx = (ntlm_context_t*)(context->ctx_data);
 
-    if(ctx->pending)
-      hsh_free(ctx->pending);
+        if(ctx->pending)
+        hsh_free(ctx->pending);
 
-    if(ctx->established)
-      hsh_free(ctx->established);
+        if(ctx->established)
+            hsh_free(ctx->established);
 
-    ha_messagex(LOG_INFO, "ntlm: uninitialized handler");
-  }
+        ha_messagex(NULL, LOG_INFO, "uninitialized handler");
+    }
 
-  /* Global Destroy */
-  else
-  {
-    /* Close the mutex */
-    pthread_mutex_destroy(&g_smblib_mutex);
-    pthread_mutexattr_destroy(&g_smblib_mutexattr);
-  }
+    /* Global Destroy */
+    else
+    {
+        /* Close the mutex */
+        pthread_mutex_destroy(&g_smblib_mutex);
+        pthread_mutexattr_destroy(&g_smblib_mutexattr);
+    }
 }
 
-int ntlm_process(const ha_request_t* req, ha_response_t* resp)
+int ntlm_process(ha_request_t* rq)
 {
-  ntlm_context_t* ctx = (ntlm_context_t*)(req->context->ctx_data);
-  void* ntlm_connection_t = NULL;
-  unsigned char key[NTLM_HASH_KEY_LEN];
-  const char* header = NULL;
-  time_t t = time(NULL);
-  int ret, r;
+    ntlm_context_t* ctx = (ntlm_context_t*)(rq->context->ctx_data);
+    void* ntlm_connection_t = NULL;
+    unsigned char key[NTLM_HASH_KEY_LEN];
+    const char* header = NULL;
+    time_t t = time(NULL);
+    int ret, r;
 
-  ASSERT(req && resp);
-  ASSERT(req->args[AUTH_ARG_CONN]);
+    ASSERT(rq);
+    ASSERT(rq->req_args[AUTH_ARG_CONN]);
 
-  resp->code = -1;
+    rq->resp_code = -1;
 
-  /* Hash the unique key */
-  md5_string(key, req->args[AUTH_ARG_CONN]);
+    /* Hash the unique key */
+    md5_string(key, rq->req_args[AUTH_ARG_CONN]);
 
 
-  ha_lock(NULL);
+    ha_lock(NULL);
 
-    /*
-     * Purge out stale connection stuff. This includes
-     * authenticated connections which have expired as
-     * well as half open connections which expire.
-     */
-    r = hsh_purge(ctx->pending, t - ctx->pending_timeout);
-    r += hsh_purge(ctx->established, t - req->context->cache_timeout);
+        /*
+         * Purge out stale connection stuff. This includes
+         * authenticated connections which have expired as
+         * well as half open connections which expire.
+         */
+        r = hsh_purge(ctx->pending, t - ctx->pending_timeout);
+        r += hsh_purge(ctx->established, t - rq->context->cache_timeout);
 
-  ha_unlock(NULL);
+    ha_unlock(NULL);
 
-  if(r > 0)
-    ha_messagex(LOG_DEBUG, "ntlm: purged info from cache: %d", r);
+    if(r > 0)
+        ha_messagex(rq, LOG_DEBUG, "purged info from cache: %d", r);
 
-  /* Look for a NTLM header */
-  if(req->context->allowed_types & HA_TYPE_NTLM)
-  {
-    header = ha_getheader(req, "Authorization", HA_PREFIX_NTLM);
-    if(header)
+    /* Look for a NTLM header */
+    if(rq->context->allowed_types & HA_TYPE_NTLM)
     {
-      /* Trim off for decoding */
-      header = trim_start(header);
+        header = ha_getheader(rq, "Authorization", HA_PREFIX_NTLM);
+        if(header)
+        {
+            /* Trim off for decoding */
+            header = trim_start(header);
 
-      ha_messagex(LOG_DEBUG, "ntlm: processing ntlm auth header");
-      ret = ntlm_auth_ntlm(ctx, key, header, resp, req->buf);
-      if(ret < 0)
-        return ret;
+            ha_messagex(rq, LOG_DEBUG, "processing ntlm auth header");
+            ret = ntlm_auth_ntlm(rq, ctx, key, header);
+            if(ret < 0)
+                return ret;
+        }
     }
-  }
-
-  /* If basic is enabled, and no NTLM */
-  if(!header && req->context->allowed_types & HA_TYPE_BASIC)
-  {
-    /* Look for a Basic header */
-    header = ha_getheader(req, "Authorization", HA_PREFIX_BASIC);
-    if(header)
+
+    /* If basic is enabled, and no NTLM */
+    if(!header && rq->context->allowed_types & HA_TYPE_BASIC)
     {
-      /* Trim off for decoding */
-      header = trim_start(header);
+        /* Look for a Basic header */
+        header = ha_getheader(rq, "Authorization", HA_PREFIX_BASIC);
+        if(header)
+        {
+            /* Trim off for decoding */
+            header = trim_start(header);
 
-      ha_messagex(LOG_DEBUG, "ntlm: processing basic auth header");
-      ret = ntlm_auth_basic(ctx, key, header, resp, req->buf);
-      if(ret < 0)
-        return ret;
+            ha_messagex(rq, LOG_DEBUG, "processing basic auth header");
+            ret = ntlm_auth_basic(rq, ctx, key, header);
+            if(ret < 0)
+                return ret;
+        }
     }
-  }
 
-  /* The authorization header was not found */
-  else
-  {
-    ha_lock(NULL);
-
-      /*
-       * NTLM trusts a connection after it's been authenticated
-       * so just pass success for those. Note that we do this
-       * in the absence of a authorization header so that we
-       * allow connections to be re-authenticated.
-       */
+    /* The authorization header was not found */
+    else
+    {
+        ha_lock(NULL);
 
-      if(hsh_get(ctx->established, key) == NTLM_ESTABLISHED)
-      {
-        hsh_touch(ctx->established, key);
-        resp->code = HA_SERVER_OK;
-      }
+        /*
+         * NTLM trusts a connection after it's been authenticated
+         * so just pass success for those. Note that we do this
+         * in the absence of a authorization header so that we
+         * allow connections to be re-authenticated.
+         */
 
-    ha_unlock(NULL);
+        if(hsh_get(ctx->established, key) == NTLM_ESTABLISHED)
+        {
+            hsh_touch(ctx->established, key);
+            rq->resp_code = HA_SERVER_OK;
+        }
 
-    if(resp->code == HA_SERVER_OK)
-      ha_messagex(LOG_NOTICE, "ntlm: validated user against connection cache");
+        ha_unlock(NULL);
 
-    /* TODO: We need to be able to retrieve the user here somehow */
-  }
+        if(rq->resp_code == HA_SERVER_OK)
+            ha_messagex(rq, LOG_NOTICE, "validated user against connection cache");
 
+        /* TODO: We need to be able to retrieve the user here somehow */
+    }
 
-  /* If nobody's set any other response then... */
-  if(resp->code != -1)
-  {
-    /* If authentication failed tell the browser about it */
-    resp->code = HA_SERVER_DECLINE;
 
-    if(req->context->allowed_types & HA_TYPE_NTLM)
+    /* If nobody's set any other response then... */
+    if(rq->resp_code != -1)
     {
-      ha_addheader(resp, "WWW-Authenticate", HA_PREFIX_NTLM);
-      ha_messagex(LOG_DEBUG, "ntlm: sent ntlm auth request");
-    }
+        /* If authentication failed tell the browser about it */
+        rq->resp_code = HA_SERVER_DECLINE;
 
-    if(req->context->allowed_types & HA_TYPE_BASIC)
-    {
-      ha_bufmcat(req->buf, HA_PREFIX_BASIC, "realm=\"", req->context->realm, "\"", NULL);
+        if(rq->context->allowed_types & HA_TYPE_NTLM)
+        {
+            ha_addheader(rq, "WWW-Authenticate", HA_PREFIX_NTLM);
+            ha_messagex(rq, LOG_DEBUG, "sent ntlm auth request");
+        }
 
-      if(ha_buferr(req->buf))
-        return HA_CRITERROR;
+        if(rq->context->allowed_types & HA_TYPE_BASIC)
+        {
+            ha_bufmcat(rq->buf, HA_PREFIX_BASIC, "realm=\"", rq->context->realm, "\"", NULL);
 
-      ha_addheader(resp, "WWW-Authenticate", ha_bufdata(req->buf));
-      ha_messagex(LOG_DEBUG, "ntlm: sent basic auth request");
+            if(ha_buferr(rq->buf))
+                return HA_CRITERROR;
+
+            ha_addheader(rq, "WWW-Authenticate", ha_bufdata(rq->buf));
+            ha_messagex(rq, LOG_DEBUG, "sent basic auth request");
+        }
     }
-  }
 
-  return ret;
+    return ret;
 }
 
 
@@ -789,12 +789,12 @@ int ntlm_process(const ha_request_t* req, ha_response_t* resp)
 
 ha_handler_t ntlm_handler =
 {
-  "NTLM",                  /* The type */
-  ntlm_init,               /* Initialization function */
-  ntlm_destroy,            /* Uninitialization routine */
-  ntlm_config,             /* Config routine */
-  ntlm_process,            /* Processing routine */
-  &ntlm_defaults,           /* Default settings */
-  sizeof(ntlm_context_t)
+    "NTLM",                  /* The type */
+    ntlm_init,               /* Initialization function */
+    ntlm_destroy,            /* Uninitialization routine */
+    ntlm_config,             /* Config routine */
+    ntlm_process,            /* Processing routine */
+    &ntlm_defaults,           /* Default settings */
+    sizeof(ntlm_context_t)
 };
 
diff --git a/daemon/simple.c b/daemon/simple.c
index d570a25..bda60c3 100644
--- a/daemon/simple.c
+++ b/daemon/simple.c
@@ -20,17 +20,17 @@
 
 typedef struct simple_context
 {
-  /* Base Handler ------------------------------------------------------ */
-  bd_context_t bd;
+    /* Base Handler ------------------------------------------------------ */
+    bd_context_t bd;
 
-  /* Settings ---------------------------------------------------------- */
-  const char* filename;           /* The file name with the user names */
+    /* Settings ---------------------------------------------------------- */
+    const char* filename;           /* The file name with the user names */
 }
 simple_context_t;
 
 /* Forward declarations for callbacks */
-static int complete_digest(const ha_request_t* req, const char* user, unsigned char* ha1);
-static int validate_basic(const ha_request_t* req, const char* user, const char* password);
+static int complete_digest(ha_request_t* rq, const char* user, unsigned char* ha1);
+static int validate_basic(ha_request_t* rq, const char* user, const char* password);
 
 /* The defaults for the context */
 static const simple_context_t simple_defaults =
@@ -43,9 +43,9 @@ static const simple_context_t simple_defaults =
  * Internal Functions
  */
 
-static int complete_digest(const ha_request_t* req, const char* user, unsigned char* ha1)
+static int complete_digest(ha_request_t* rq, const char* user, unsigned char* ha1)
 {
-    simple_context_t* ctx = (simple_context_t*)req->context->ctx_data;
+    simple_context_t* ctx = (simple_context_t*)rq->context->ctx_data;
     FILE* f;
     char* t;
     char* t2;
@@ -53,13 +53,13 @@ static int complete_digest(const ha_request_t* req, const char* user, unsigned c
     char line[SIMPLE_MAXLINE];
     int ret = HA_FALSE;
 
-    ASSERT(ctx && req && user && user[0]);
-    ha_messagex(LOG_DEBUG, "searching password file for user's ha1: %s", user);
+    ASSERT(ctx && rq && user && user[0]);
+    ha_messagex(rq, LOG_DEBUG, "searching password file for user's ha1: %s", user);
 
     f = fopen(ctx->filename, "r");
     if(!f)
     {
-        ha_message(LOG_ERR, "simple: can't open file for basic auth: %s", ctx->filename);
+        ha_message(rq, LOG_ERR, "can't open file for basic auth: %s", ctx->filename);
         return HA_FAILED;
     }
 
@@ -75,7 +75,7 @@ static int complete_digest(const ha_request_t* req, const char* user, unsigned c
 
         if(ferror(f))
         {
-            ha_message(LOG_ERR, "simple: error reading basic password file");
+            ha_message(rq, LOG_ERR, "error reading basic password file");
             ret = HA_FAILED;
             break;
         }
@@ -98,15 +98,15 @@ static int complete_digest(const ha_request_t* req, const char* user, unsigned c
                     t2++;
 
                     /* Check the realm */
-                    if(strcmp(t, req->context->realm) == 0)
+                    if(strcmp(t, rq->context->realm) == 0)
                     {
                         len = MD5_LEN;
 
                         /* Now try and decode the ha1  */
-                        t = ha_bufdechex(req->buf, t2, &len);
+                        t = ha_bufdechex(rq->buf, t2, &len);
                         if(t && len == MD5_LEN)
                         {
-                            ha_messagex(LOG_DEBUG, "simple: found ha1 for user: %s", user);
+                            ha_messagex(rq, LOG_DEBUG, "found ha1 for user: %s", user);
                             memcpy(ha1, t, MD5_LEN);
                             ret = HA_OK;
                             break;
@@ -115,22 +115,22 @@ static int complete_digest(const ha_request_t* req, const char* user, unsigned c
                 }
 
                 if(!t2 || ret != HA_OK)
-                    ha_messagex(LOG_WARNING, "simple: user '%s' found in file, but password not in digest format", user);
+                    ha_messagex(rq, LOG_WARNING, "user '%s' found in file, but password not in digest format", user);
             }
         }
     }
 
     fclose(f);
 
-    if(ha_buferr(req->buf))
+    if(ha_buferr(rq->buf))
         return HA_CRITERROR;
 
     return ret;
 }
 
-static int validate_basic(const ha_request_t* req, const char* user, const char* password)
+static int validate_basic(ha_request_t* rq, const char* user, const char* password)
 {
-    simple_context_t* ctx = (simple_context_t*)req->context->ctx_data;
+    simple_context_t* ctx = (simple_context_t*)rq->context->ctx_data;
     FILE* f;
     char line[SIMPLE_MAXLINE];
     unsigned char ha1[MD5_LEN];
@@ -139,18 +139,18 @@ static int validate_basic(const ha_request_t* req, const char* user, const char*
     size_t len;
     int ret = HA_FALSE;
 
-    ASSERT(ctx && req);
+    ASSERT(ctx && rq);
     ASSERT(user && user[0] && password);
-    ha_messagex(LOG_DEBUG, "simple: validating user against password file: %s", user);
+    ha_messagex(rq, LOG_DEBUG, "validating user against password file: %s", user);
 
     f = fopen(ctx->filename, "r");
     if(!f)
     {
-        ha_message(LOG_ERR, "simple: can't open file for basic auth: %s", ctx->filename);
+        ha_message(rq, LOG_ERR, "can't open file for basic auth: %s", ctx->filename);
         return HA_FAILED;
     }
 
-    digest_makeha1(ha1, user, req->context->realm, password);
+    digest_makeha1(ha1, user, rq->context->realm, password);
 
     /*
      * Note: There should be no returns or jumps between
@@ -164,7 +164,7 @@ static int validate_basic(const ha_request_t* req, const char* user, const char*
 
         if(ferror(f))
         {
-            ha_message(LOG_ERR, "simple: error reading basic password file");
+            ha_message(rq, LOG_ERR, "error reading basic password file");
             ret = HA_FAILED;
             break;
         }
@@ -192,7 +192,7 @@ static int validate_basic(const ha_request_t* req, const char* user, const char*
 
                 if(strcmp(t2, t) == 0)
                 {
-                    ha_messagex(LOG_DEBUG, "simple: found valid crypt password for user: %s", user);
+                    ha_messagex(rq, LOG_DEBUG, "found valid crypt password for user: %s", user);
                     ret = HA_OK;
                     break;
                 }
@@ -205,22 +205,22 @@ static int validate_basic(const ha_request_t* req, const char* user, const char*
                     t2++;
 
                     /* Check the realm */
-                    if(strcmp(t, req->context->realm) == 0)
+                    if(strcmp(t, rq->context->realm) == 0)
                     {
                         len = MD5_LEN;
 
                         /* Now try antd decode the ha1  */
-                        t = ha_bufdechex(req->buf, t2, &len);
+                        t = ha_bufdechex(rq->buf, t2, &len);
                         if(t && len == MD5_LEN && memcmp(ha1, t, MD5_LEN) == 0)
                         {
-                            ha_messagex(LOG_DEBUG, "simple: found valid ha1 for user: %s", user);
+                            ha_messagex(rq, LOG_DEBUG, "found valid ha1 for user: %s", user);
                             ret = HA_OK;
                             break;
                         }
                     }
                 }
 
-                if(ha_buferr(req->buf))
+                if(ha_buferr(rq->buf))
                     break;
             }
         }
@@ -228,7 +228,7 @@ static int validate_basic(const ha_request_t* req, const char* user, const char*
 
     fclose(f);
 
-    if(ha_buferr(req->buf))
+    if(ha_buferr(rq->buf))
         return HA_CRITERROR;
 
     return ret;
@@ -270,21 +270,21 @@ int simple_init(ha_context_t* context)
         /* Check to make sure the file exists */
         if(!ctx->filename)
         {
-            ha_messagex(LOG_ERR, "simple: configuration incomplete. "
-                                 "Must have a PasswordFile configured.");
+            ha_messagex(NULL, LOG_ERR, "configuration incomplete. "
+                                       "Must have a PasswordFile configured.");
             return HA_FAILED;
         }
 
         fd = open(ctx->filename, O_RDONLY);
         if(fd == -1)
         {
-            ha_message(LOG_ERR, "simple: can't open file for authentication: %s", ctx->filename);
+            ha_message(NULL, LOG_ERR, "can't open file for authentication: %s", ctx->filename);
             return HA_FAILED;
         }
 
         close(fd);
 
-        ha_messagex(LOG_INFO, "simple: initialized handler");
+        ha_messagex(NULL, LOG_INFO, "initialized simple handler");
     }
 
     return HA_OK;
@@ -297,12 +297,12 @@ int simple_init(ha_context_t* context)
 
 ha_handler_t simple_handler =
 {
-  "SIMPLE",                /* The type */
-  simple_init,             /* Initialization function */
-  bd_destroy,              /* Uninitialization routine */
-  simple_config,           /* Config routine */
-  bd_process,              /* Processing routine */
-  NULL,                    /* A default context */
-  sizeof(simple_context_t) /* Size of the context */
+    "SIMPLE",                /* The type */
+    simple_init,             /* Initialization function */
+    bd_destroy,              /* Uninitialization routine */
+    simple_config,           /* Config routine */
+    bd_process,              /* Processing routine */
+    NULL,                    /* A default context */
+    sizeof(simple_context_t) /* Size of the context */
 };
 
diff --git a/daemon/usuals.h b/daemon/usuals.h
index e14ecf5..97d355b 100644
--- a/daemon/usuals.h
+++ b/daemon/usuals.h
@@ -29,10 +29,10 @@
 #define countof(x) (sizeof(x) / sizeof(x[0]))
 
 #ifdef _DEBUG
-  #include "assert.h"
-  #define ASSERT assert
+    #include "assert.h"
+    #define ASSERT assert
 #else
-  #define ASSERT
+    #define ASSERT
 #endif
 
 #endif /* __USUALS_H__ */
diff --git a/doc/protocol.txt b/doc/protocol.txt
index b6bc0ba..c409c8c 100644
--- a/doc/protocol.txt
+++ b/doc/protocol.txt
@@ -19,15 +19,12 @@ will be accepted on the connection.
 
 REQUESTS -------------------------------------------------------------------
 
-AUTH authmethod connid method uri
+AUTH connid method uri
 
   The AUTH command asks the daemon to perform authentication
   for a given set of header from the client. None of the
   arguments should contain spaces.
 
-  authmethod: is the authentication method. Methods are
-       defined by the daemon in it's config file.
-
   connid: a unique string identifying the connection from
        the client. This is only important when NTLM is
        being used. If not, pass a random string.
@@ -44,6 +41,15 @@ AUTH authmethod connid method uri
   Headers should be specified on one line, not 'wrapped' as is
   permissible in HTTP.
 
+SET name value
+
+  Sets a given value for the connection. Examples are listed below:
+
+  Handler: The name of handler to use for authentication (as
+  		configured in httpauthd.conf).
+
+  Domain: The domains for digest authentication.
+
 QUIT
 
   This closes the connection to the daemon.
@@ -64,6 +70,8 @@ The codes are similar to HTTP:
   200 Successful Request
     (detail is described below)
 
+  202 Accepted
+
   4xx Request Error
     (detail is an error message)