reformat, update README

README.md

@@ -0,0 +1,36 @@
+# Selene - A SSL/TLS library
+
+Selene has a few goals that makes it different from a more traditional 
+SSL libraries:
+
+* Completely Asynchronous: Selene does no IO itself, it only provides
+notifications to the user that IO should be done.
+
+* Asynchronous Callbacks: Callback functions provide their own callback
+to notify Selene when the user has finished an operation.
+
+* Test Driven: A test framework to test all code paths.
+
+* Plugable Backends for Cryptography: Currently only focusing
+on OpenSSL, but others are possible.
+
+* Liberal License: Under the Apache License, version 2.0.
+
+Selene is named after the [Greek Goddess of the Moon](http://en.wikipedia.org/wiki/Selene),
+because I am terrible at naming projects.
+
+# Status
+
+A prototype backend (openssl-threaded) was used to validate the basics
+of the selene_* API.  I am currently slowly working on the native Selene
+TLS backend, which only uses OpenSSL for cryptographic operations, but
+not the actual protocol parsing.
+
+# Hacking Notes:
+
+* All contributors must sign an [Apache Software Foundation CLA](http://www.apache.org/licenses/icla.txt),
+and agree that Selene may be moved to the ASF at a future date.
+* External Functions and types are prefixed with selene_*
+* Internal Functions and types are prefixed with sln_*
+* Style: [Google C++ Style Guide](http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml), even though this is C. Use `clang-format -style=Google` on all source code.
+* Write test cases for all code paths, including errors.

include/private/sln_arrays.h

@@ -21,10 +21,11 @@
 #define _sln_arrays_h_
 
 int aln_is_empty_array(const sln_array_header_t *a);
-sln_array_header_t* sln_array_make(selene_alloc_t *alloc, int nelts, int elt_size);
+sln_array_header_t *sln_array_make(selene_alloc_t *alloc, int nelts,
+                                   int elt_size);
 void sln_array_clear(sln_array_header_t *arr);
-void* sln_array_pop(sln_array_header_t *arr);
-void* sln_array_push(sln_array_header_t *arr);
+void *sln_array_pop(sln_array_header_t *arr);
+void *sln_array_push(sln_array_header_t *arr);
 void sln_array_destroy(sln_array_header_t *arr);
 
 /** A helper macro for accessing a member of an APR array.
@@ -35,7 +36,7 @@ void sln_array_destroy(sln_array_header_t *arr);
  *
  * @return the item at index i
  */
-#define SLN_ARRAY_IDX(ary,i,type) (((type *)(ary)->elts)[i])
+#define SLN_ARRAY_IDX(ary, i, type) (((type *)(ary)->elts)[i])
 
 /** A helper macro for pushing elements into an APR array.
  *
@@ -44,6 +45,6 @@ void sln_array_destroy(sln_array_header_t *arr);
  *
  * @return the location where the new object should be placed
  */
-#define SLN_ARRAY_PUSH(ary,type) (*((type *)sln_array_push(ary)))
+#define SLN_ARRAY_PUSH(ary, type) (*((type *)sln_array_push(ary)))
 
 #endif

include/private/sln_assert.h

@@ -27,43 +27,51 @@
 
 #ifdef WANT_SLN_ASSERTS
 
-  #include <assert.h>
+#include <assert.h>
 
-  #define SLN_ASSERT(exp) assert(exp)
+#define SLN_ASSERT(exp) assert(exp)
 
-  #define SLN_ASSERT_RANGE(start, end, target) SLN_ASSERT(target > start); SLN_ASSERT(target < end);
+#define SLN_ASSERT_RANGE(start, end, target) \
+  SLN_ASSERT(target > start);                \
+  SLN_ASSERT(target < end);
 
-  #define SLN_ASSERT_ENUM(type, target) SLN_ASSERT_RANGE(type ## __UNUSED0, type ## __MAX, target)
+#define SLN_ASSERT_ENUM(type, target) \
+  SLN_ASSERT_RANGE(type##__UNUSED0, type##__MAX, target)
 
-  #define SLN_ASSERT_FLAGS(type, value) SLN_ASSERT((type | (value)) == (value))
+#define SLN_ASSERT_FLAGS(type, value) SLN_ASSERT((type | (value)) == (value))
 
-  #define SLN_ASSERT_CONF(conf) do { \
-    SLN_ASSERT(conf != NULL); \
-    SLN_ASSERT_RANGE(SELENE_CS__UNUSED0-1, SELENE_CS__MAX, conf->ciphers.used) \
-    SLN_ASSERT_FLAGS(conf->protocols, SELENE_PROTOCOL_SSL30|SELENE_PROTOCOL_TLS10|SELENE_PROTOCOL_TLS11|SELENE_PROTOCOL_TLS12); \
+#define SLN_ASSERT_CONF(conf)                                                \
+  do {                                                                       \
+    SLN_ASSERT(conf != NULL);                                                \
+    SLN_ASSERT_RANGE(SELENE_CS__UNUSED0 - 1, SELENE_CS__MAX,                 \
+                     conf->ciphers.used)                                     \
+        SLN_ASSERT_FLAGS(conf->protocols,                                    \
+                         SELENE_PROTOCOL_SSL30 | SELENE_PROTOCOL_TLS10 |     \
+                             SELENE_PROTOCOL_TLS11 | SELENE_PROTOCOL_TLS12); \
   } while (0);
 
-  #define SLN_ASSERT_CONTEXT(ctxt) do { \
-    SLN_ASSERT(ctxt != NULL); \
-    SLN_ASSERT_CONF(ctxt->conf); \
-    SLN_ASSERT_ENUM(SLN_STATE, ctxt->state); \
-    SLN_ASSERT_ENUM(SLN_LOG, ctxt->log_level); \
-    SLN_ASSERT(ctxt->log_msg_len >= 0); \
-    SLN_ASSERT(ctxt->log_msg_len <= 2048); \
+#define SLN_ASSERT_CONTEXT(ctxt)                   \
+  do {                                             \
+    SLN_ASSERT(ctxt != NULL);                      \
+    SLN_ASSERT_CONF(ctxt->conf);                   \
+    SLN_ASSERT_ENUM(SLN_STATE, ctxt->state);       \
+    SLN_ASSERT_ENUM(SLN_LOG, ctxt->log_level);     \
+    SLN_ASSERT(ctxt->log_msg_len >= 0);            \
+    SLN_ASSERT(ctxt->log_msg_len <= 2048);         \
     SLN_ASSERT_ENUM(SLN_LOG, ctxt->log_msg_level); \
   } while (0);
 
 #else /* !WANT_SLN_ASSERTS */
 
-  #define SLN_ASSERT(exp)
+#define SLN_ASSERT(exp)
 
-  #define SLN_ASSERT_RANGE(start, end, target)
+#define SLN_ASSERT_RANGE(start, end, target)
 
-  #define SLN_ASSERT_ENUM(type, target)
+#define SLN_ASSERT_ENUM(type, target)
 
-  #define SLN_ASSERT_CONF(conf)
+#define SLN_ASSERT_CONF(conf)
 
-  #define SLN_ASSERT_CONTEXT(ctxt)
+#define SLN_ASSERT_CONTEXT(ctxt)
 
 #endif
 

include/private/sln_backends.h

@@ -22,29 +22,20 @@
 #include "sln_types.h"
 #include "sln_buckets.h"
 
-selene_error_t*
-sln_backend_create(selene_t *s, sln_backend_e be);
+selene_error_t* sln_backend_create(selene_t* s, sln_backend_e be);
 
-selene_error_t* 
-sln_backend_initialize(void);
+selene_error_t* sln_backend_initialize(void);
 
-void
-sln_backend_terminate(void);
+void sln_backend_terminate(void);
 
-selene_error_t*
-sln_parser_initilize();
+selene_error_t* sln_parser_initilize();
 
-void
-sln_parser_terminate();
+void sln_parser_terminate();
 
-selene_error_t*
-sln_parser_create(selene_t *s);
+selene_error_t* sln_parser_create(selene_t* s);
 
-selene_error_t*
-sln_parser_start(selene_t *s);
+selene_error_t* sln_parser_start(selene_t* s);
 
-selene_error_t*
-sln_parser_destroy(selene_t *s);
+selene_error_t* sln_parser_destroy(selene_t* s);
 
 #endif
-

include/private/sln_brigades.h

@@ -22,91 +22,85 @@
 #include "sln_types.h"
 #include "sln_buckets.h"
 
-selene_error_t*
-sln_iobb_create(selene_alloc_t *alloc, sln_iobb_t *iobb);
+selene_error_t *sln_iobb_create(selene_alloc_t *alloc, sln_iobb_t *iobb);
 
-void
-sln_iobb_destroy(sln_iobb_t *iobb);
+void sln_iobb_destroy(sln_iobb_t *iobb);
 
-selene_error_t*
-sln_brigade_create(selene_alloc_t *alloc, sln_brigade_t **bb);
+selene_error_t *sln_brigade_create(selene_alloc_t *alloc, sln_brigade_t **bb);
 
 /* Destroys the brigade, and all member buckets */
-void
-sln_brigade_destroy(sln_brigade_t *bb);
+void sln_brigade_destroy(sln_brigade_t *bb);
 
 /* Cleans out all member buckets, but leaves the brigade intact */
-void
-sln_brigade_clear(sln_brigade_t *bb);
+void sln_brigade_clear(sln_brigade_t *bb);
 
 /* Length of the entire brigade */
-size_t
-sln_brigade_size(sln_brigade_t *bb);
+size_t sln_brigade_size(sln_brigade_t *bb);
 
 /* Number of buckets inside this brigade */
-int
-sln_brigade_bucket_count(sln_brigade_t *bb);
+int sln_brigade_bucket_count(sln_brigade_t *bb);
 
 /**
  * Flatten a section of a brigade into an existing buffer.
  *
- * If there is not enough data to fullfill the request, up to length is copied into the buffer.
+ * If there is not enough data to fullfill the request, up to length is copied
+ *into the buffer.
  */
-selene_error_t*
-sln_brigade_pread_bytes(sln_brigade_t *bb, size_t offset, size_t length, char *buffer, size_t *len);
-
+selene_error_t *sln_brigade_pread_bytes(sln_brigade_t *bb, size_t offset,
+                                        size_t length, char *buffer,
+                                        size_t *len);
 
 /**
  * Flatten from the front of the brigade, into a buffer.
  * Buckets up to this point are consumed.
  */
-selene_error_t*
-sln_brigade_flatten(sln_brigade_t *bb, char *c, size_t *len);
+selene_error_t *sln_brigade_flatten(sln_brigade_t *bb, char *c, size_t *len);
 
 /**
  * Chomp cuts off the front of a brigade.
  */
-selene_error_t*
-sln_brigade_chomp(sln_brigade_t *bb, size_t len);
+selene_error_t *sln_brigade_chomp(sln_brigade_t *bb, size_t len);
 
 /**
  * Duplicate a section of a brigade, into the tail of another brigade.
  *
- * Note: Bucket's data are reference counted and should not be modified in place.
+ * Note: Bucket's data are reference counted and should not be modified in
+ *place.
  */
-selene_error_t*
-sln_brigade_copy_into(sln_brigade_t *source_bb, size_t offset, size_t point, sln_brigade_t *into_bb);
+selene_error_t *sln_brigade_copy_into(sln_brigade_t *source_bb, size_t offset,
+                                      size_t point, sln_brigade_t *into_bb);
 
-#define SLN_BRIGADE_SENTINEL(b) SLN_RING_SENTINEL(&(b)->list, sln_bucket_t, link)
+#define SLN_BRIGADE_SENTINEL(b) \
+  SLN_RING_SENTINEL(&(b)->list, sln_bucket_t, link)
 #define SLN_BRIGADE_EMPTY(b) SLN_RING_EMPTY(&(b)->list, sln_bucket_t, link)
 #define SLN_BRIGADE_FIRST(b) SLN_RING_FIRST(&(b)->list)
 #define SLN_BRIGADE_LAST(b) SLN_RING_LAST(&(b)->list)
 
-#define SLN_BRIGADE_INSERT_TAIL(b, e) \
-  do { \
-    sln_bucket_t *sln__b = (e); \
+#define SLN_BRIGADE_INSERT_TAIL(b, e)                             \
+  do {                                                            \
+    sln_bucket_t *sln__b = (e);                                   \
     SLN_RING_INSERT_TAIL(&(b)->list, sln__b, sln_bucket_t, link); \
-    SLN_BRIGADE_CHECK_CONSISTENCY((b)); \
+    SLN_BRIGADE_CHECK_CONSISTENCY((b));                           \
   } while (0)
 
-#define SLN_BRIGADE_INSERT_HEAD(b, e) \
-  do { \
-    sln_bucket_t *sln__b = (e); \
+#define SLN_BRIGADE_INSERT_HEAD(b, e)                             \
+  do {                                                            \
+    sln_bucket_t *sln__b = (e);                                   \
     SLN_RING_INSERT_HEAD(&(b)->list, sln__b, sln_bucket_t, link); \
-    SLN_BRIGADE_CHECK_CONSISTENCY((b)); \
+    SLN_BRIGADE_CHECK_CONSISTENCY((b));                           \
   } while (0)
 
-#define SLN_BRIGADE_CONCAT(a, b) \
-  do { \
+#define SLN_BRIGADE_CONCAT(a, b)                                 \
+  do {                                                           \
     SLN_RING_CONCAT(&(a)->list, &(b)->list, sln_bucket_t, link); \
-    SLN_BRIGADE_CHECK_CONSISTENCY((a)); \
+    SLN_BRIGADE_CHECK_CONSISTENCY((a));                          \
   } while (0)
 
 #define SLN_BRIGADE_DEBUG
 
 #ifdef SLN_BRIGADE_DEBUG
-#define SLN_BRIGADE_CHECK_CONSISTENCY(b) \
-  do { \
+#define SLN_BRIGADE_CHECK_CONSISTENCY(b)                        \
+  do {                                                          \
     SLN_RING_CHECK_CONSISTENCY(&(b)->list, sln_bucket_t, link); \
   } while (0)
 #else