Completed implementation of ldap/ntlm/simple handlers

1 files changed, 90 insertions, 92 deletions

diff --git a/daemon/httpauthd.h b/daemon/httpauthd.h
index 536dfdc..b710444 100644
--- a/daemon/httpauthd.h
+++ b/daemon/httpauthd.h
@@ -16,31 +16,14 @@ typedef struct ha_buffer
 }
 ha_buffer_t;
 
+/* Initializes a buffer */
 void ha_bufinit(ha_buffer_t* buf);
-void ha_buffree(ha_buffer_t* buf);
-void ha_bufreset(ha_buffer_t* buf);
-
-/* Buffer input functions */
-int ha_readline(int fd, ha_buffer_t* buf);
-char* ha_parseline(ha_buffer_t* buf, int trim);
-char* ha_parseword(ha_buffer_t* buf, const char* delims);
-
-/* Buffer output functions */
-void ha_bufnext(ha_buffer_t* buf);
-void ha_bufcat(ha_buffer_t* buf, ...);
 
-/* Buffer encoding functions */
-void ha_bufenc64(ha_buffer_t* buf, const const char* src, size_t len);
-void ha_bufdec64(ha_buffer_t* buf, const char* src, size_t len);
-
-void ha_bufenchex(ha_buffer_t* buf, const unsigned char* src, size_t len);
-void ha_bufdechex(ha_buffer_t* buf, const char* src, size_t len);
-
-/* Memory allocation functions */
-void* ha_bufmalloc(ha_buffer_t* buf, size_t sz);
+/* Frees all memory associated with a buffer */
+void ha_buffree(ha_buffer_t* buf);
 
-#define ha_bufskip(buf)  \
-  ((buf)->_pp = (buf)->_rp)
+/* Resets a buffer for later reuse */
+void ha_bufreset(ha_buffer_t* buf);
 
 #define ha_buflen(buf)  \
   ((buf)->_rp - (buf)->_pp)
@@ -51,32 +34,87 @@ void* ha_bufmalloc(ha_buffer_t* buf, size_t sz);
 #define ha_bufdata(buf)  \
   ((buf)->_pp)
 
+#define ha_buferr(buf)   \
+  ((buf)->_dt == NULL)
+
+/* Buffer input functions ------------------------------------------------ */
+
+/* Read a line from an input handle */
+int ha_bufreadline(int fd, ha_buffer_t* buf);
+
+/* Parse the current line */
+char* ha_bufparseline(ha_buffer_t* buf, int trim);
+
+/* Parse a word from the current block */
+char* ha_bufparseword(ha_buffer_t* buf, const char* delims);
+
+#define ha_bufskip(buf)  \
+  ((buf)->_pp = (buf)->_rp)
+
 #define ha_bufeat(buf)   \
   ((!ha_buferr(buf) && ha_buflen(buf) > 0) ? ++((buf)->_pp) : (buf)->_pp)
 
-#define ha_buferr(buf)   \
-  ((buf)->_dt == NULL)
+/* Buffer output functions ----------------------------------------------- */
+
+/* Adds multiple strings together */
+char* ha_bufmcat(ha_buffer_t* buf, ...);
+
+/* Copies a string to the buffer */
+char* ha_bufcpy(ha_buffer_t* buf, const char* src);
+
+/* Copies a portion of a string to the buffer */
+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)
+
+#define ha_bufcat ha_bufcpy
+
+/* Buffer allocation functions ------------------------------------------- */
+
+/* Memory allocation */
+void* ha_bufmalloc(ha_buffer_t* buf, size_t bytes);
+
+void* ha_bufmemdup(ha_buffer_t* buf, const void* src, size_t bytes);
+
+/* Buffer Encoding Functions --------------------------------------------- */
+
+/* Encode an array of bytes in base 64 */
+char* ha_bufenc64(ha_buffer_t* buf, const void* src, size_t bytes);
+
+/* Decode an array of bytes from base 64 */
+void* ha_bufdec64(ha_buffer_t* buf, const char* src, size_t bytes);
+
+/* Encode an array of bytes in hex */
+char* ha_bufenchex(ha_buffer_t* buf, const void* src, size_t bytes);
+
+/* Decode an array of bytes in hex */
+void* ha_bufdechex(ha_buffer_t* buf, const char* src, size_t bytes);
+
 
 
 /* -----------------------------------------------------------------------
  * HTTP Auth Handlers
  */
 
-typedef struct ha_context_t;
+struct ha_context;
+struct ha_request;
+struct ha_response;
 
 /*
  * This function initializes the handler. It gets called
  * after the configuration gets loaded so if a config func
  * is registered it'll get called before this.
  */
-typedef int (*auth_init_t)(ha_context_t* ctx);
+typedef int (*auth_init_t)(struct ha_context* ctx);
 
 /*
  * This function is called when the app exits. All threads
  * should have completed at this point, so it's not necessary
  * to be thread safe in here
  */
-typedef void (*auth_destroy_t)(ha_context_t* ctx);
+typedef void (*auth_destroy_t)(struct ha_context* ctx);
 
 /*
  * Called once for each configuration parameter. This is
@@ -84,15 +122,15 @@ typedef void (*auth_destroy_t)(ha_context_t* ctx);
  * always be lower case. White space will always be trimmed
  * from the value.
  */
-typedef int (*auth_config_t)(ha_context_t* ctx, const char* name, const char* value);
+typedef int (*auth_config_t)(struct ha_context* ctx, const char* name, const char* value);
 
 /*
  * Called for each authentication request that is designated
  * for this handler. Note that all data access in this
  * function must be thread-safe.
  */
-typedef int (*auth_process_t)(ha_context_t* ctx, ha_request_t* req,
-                              ha_response_t* resp, ha_buffer_t* mem);
+typedef int (*auth_process_t)(struct ha_context* ctx, struct ha_request* req,
+                              struct ha_response* resp, ha_buffer_t* mem);
 
 /* An authentication handler */
 typedef struct ha_handler
@@ -131,7 +169,7 @@ ha_handler_t;
 struct ha_options;
 
 /* Context passed to the handler functions below */
-typdef struct ha_context
+typedef struct ha_context
 {
   const char* name;       /* A name assigned by the configuration file */
   ha_handler_t* handler;  /* The original handler structure */
@@ -152,7 +190,7 @@ ha_context_t;
  * should be no need to change it unless we're
  * adding or removing commands
  */
-#define MAX_ARGS        2
+#define MAX_ARGS        6
 
 /*
  * The maximum number of pertinent headers to read
@@ -183,6 +221,10 @@ ha_header_t;
 #define REQTYPE_QUIT    1
 #define REQTYPE_AUTH    2
 
+#define AUTH_ARG_CONN   0
+#define AUTH_ARG_METHOD 1
+#define AUTH_ARG_URI    2
+
 /* A single request from client */
 typedef struct ha_request
 {
@@ -220,13 +262,6 @@ void ha_addheader(ha_response_t* resp, const char* name, const char* data);
 int ha_confbool(const char* name, const char* conf, int* value);
 int ha_confint(const char* name, const char* conf, int min, int max, int* value);
 
-/* A little hashing */
-#ifndef MD5_LEN
-  #define MD5_LEN 16
-#endif
-
-void ha_md5string(const char* data, unsigned char* hash);
-
 /* -----------------------------------------------------------------------
  * Error Handling
  */
@@ -244,54 +279,8 @@ void ha_messagex(int level, const char* msg, ...);
 #define HA_TYPE_BASIC   1 << 1
 #define HA_PREFIX_BASIC "Basic "
 
-typedef struct ha_basic_header
-{
-  const char* user;
-  const char* password;
-  unsigned char key[MD5_LEN];
-}
-ha_basic_header_t;
-
-int ha_parsebasic(char* header, ha_buffer_t* buf, ha_basic_header_t* rec);
-
-
 #define HA_TYPE_DIGEST  1 << 2
 #define HA_PREFIX_DIGEST "Digest "
-#define HA_DIGEST_NONCE_LEN MD5_LEN * 2
-
-/* Parsed Digest response from the client */
-typedef struct ha_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* message_qop;
-  const char* nc;
-  unsigned char key[MD5_LEN];
-}
-ha_digest_header_t;
-
-/* Kept by the server for validating the client */
-typedef struct ha_digest_record
-{
-  unsigned char nonce[HA_DIGEST_NONCE_LEN];
-  unsigned char userhash[MD5_LEN];
-  unsigned char ha1[MD5_LEN];
-  unsigned int nc;
-}
-ha_digest_record_t;
-
-int ha_digestparse(char* header, ha_buffer_t* buf, ha_digest_header_t* rec);
-int ha_digestcheck(const char* realm, const char* method, const char* uri,
-                   ha_buffer_t* buf, ha_digest_header_t* header, ha_digest_record_t* rec);
-
 
 #define HA_TYPE_NTLM    1 << 3
 #define HA_PREFIX_NTLM  "NTLM "
@@ -301,21 +290,22 @@ int ha_digestcheck(const char* realm, const char* method, const char* uri,
  * URI Parse Support
  */
 
-struct ha_uri_t
+typedef struct ha_uri
 {
-  /* Note: We only support HTTP uris */
+  const char* scheme;
   const char* user;
   const char* pw;
   const char* host;
   unsigned short port;
   const char* path;
   const char* query;
-  const char* bookmark;
-};
-
+  const char* fragment;
+}
+ha_uri_t;
 
-char* ha_uriformat(const ha_uri_t* uri, ha_buffer_t* buf);
-int ha_uriparse(const char* str, ha_uri_t* uri);
+char* ha_uriformat(ha_buffer_t* buf, const ha_uri_t* uri);
+int ha_uriparse(ha_buffer_t* buf, const char* suri, ha_uri_t* uri);
+int ha_uricmp(ha_uri_t* one, ha_uri_t* two);
 
 
 /* -----------------------------------------------------------------------
@@ -325,4 +315,12 @@ int ha_uriparse(const char* str, ha_uri_t* uri);
 void ha_lock();
 void ha_unlock();
 
+
+/* -----------------------------------------------------------------------
+ * Miscellaneous
+ */
+
+int ha_genrandom(unsigned char* data, size_t len);
+
+
 #endif /* __HTTPAUTHD_H__ */