agoo 2.5.5 → 2.5.6

data/ext/agoo/con.h

@@ -16,50 +16,58 @@
 
 #define MAX_HEADER_SIZE	8192
 
-struct _Upgraded;
-struct _Req;
-struct _Res;
-struct _Bind;
-struct _Queue;
+struct _agooUpgraded;
+struct _agooReq;
+struct _agooRes;
+struct _agooBind;
+struct _agooQueue;
 
-typedef struct _Con {
-    struct _Con		*next;
-    int			sock;
-    struct _Bind	*bind;
-    struct pollfd	*pp;
-    uint64_t		id;
-    char		buf[MAX_HEADER_SIZE];
-    size_t		bcnt;
+typedef struct _agooConLoop {
+    struct _agooConLoop	*next;
+    struct _agooQueue	pub_queue;
+    pthread_t		thread;
+    int			id;
+    // TBD use mutex for head and tail, volatile also
+    struct _agooRes	*res_head;
+    struct _agooRes	*res_tail;
+
+    pthread_mutex_t	lock;
+    
+} *agooConLoop;
+    
+typedef struct _agooCon {
+    struct _agooCon		*next;
+    int				sock;
+    struct _agooBind		*bind;
+    struct pollfd		*pp;
+    uint64_t			id;
+    char			buf[MAX_HEADER_SIZE];
+    size_t			bcnt;
 
-    ssize_t		mcnt;  // how much has been read so far
-    ssize_t		wcnt;  // how much has been written
+    ssize_t			mcnt;  // how much has been read so far
+    ssize_t			wcnt;  // how much has been written
 
-    double		timeout;
-    bool		closing;
-    bool		dead;
-    volatile bool	hijacked;
-    struct _Req		*req;
-    struct _Res		*res_head;
-    struct _Res		*res_tail;
+    double			timeout;
+    bool			closing;
+    bool			dead;
+    volatile bool		hijacked;
+    struct _agooReq		*req;
+    struct _agooRes		*res_head;
+    struct _agooRes		*res_tail;
 
-    struct _Upgraded	*up; // only set for push connections
-} *Con;
+    struct _agooUpgraded	*up; // only set for push connections
+    agooConLoop			loop;
+} *agooCon;
 
-typedef struct _ConLoop {
-    struct _ConLoop	*next;
-    struct _Queue	pub_queue;
-    pthread_t		thread;
-    int			id;
-} *ConLoop;
-    
-extern Con		con_create(Err err, int sock, uint64_t id, struct _Bind *b);
-extern void		con_destroy(Con c);
-extern const char*	con_header_value(const char *header, int hlen, const char *key, int *vlen);
+extern agooCon		agoo_con_create(agooErr err, int sock, uint64_t id, struct _agooBind *b);
+extern void		agoo_con_destroy(agooCon c);
+extern const char*	agoo_con_header_value(const char *header, int hlen, const char *key, int *vlen);
 
-extern struct _ConLoop*	conloop_create(Err err, int id);
+extern agooConLoop	agoo_conloop_create(agooErr err, int id);
+extern void		agoo_conloop_destroy(agooConLoop loop);
 
-extern bool		con_http_read(Con c);
-extern bool		con_http_write(Con c);
-extern short		con_http_events(Con c);
+extern bool		agoo_con_http_read(agooCon c);
+extern bool		agoo_con_http_write(agooCon c);
+extern short		agoo_con_http_events(agooCon c);
 
-#endif /* AGOO_CON_H */
+#endif // AGOO_CON_H

data/ext/agoo/debug.c

@@ -10,8 +10,8 @@
 
 #include "debug.h"
 
-typedef struct _Rec {
-    struct _Rec	*next;
+typedef struct _rec {
+    struct _rec	*next;
     void	*ptr;
     const char	*type;
     const char	*file;
@@ -21,45 +21,45 @@ typedef struct _Rec {
 static pthread_mutex_t	lock = PTHREAD_MUTEX_INITIALIZER;
 static Rec		recs = NULL;
 
-atomic_int	mem_bind = 0;
-atomic_int	mem_cb = 0;
-atomic_int	mem_con = 0;
-atomic_int	mem_cslot = 0;
-atomic_int	mem_err_stream = 0;
-atomic_int	mem_eval_threads = 0;
-atomic_int	mem_group = 0;
-atomic_int	mem_graphql_arg = 0;
-atomic_int	mem_graphql_directive = 0;
-atomic_int	mem_graphql_field = 0;
-atomic_int	mem_graphql_link = 0;
-atomic_int	mem_graphql_slot = 0;
-atomic_int	mem_graphql_type = 0;
-atomic_int	mem_graphql_value = 0;
-atomic_int	mem_group_path = 0;
-atomic_int	mem_header = 0;
-atomic_int	mem_hook = 0;
-atomic_int	mem_hook_pattern = 0;
-atomic_int	mem_http_slot = 0;
-atomic_int	mem_log_entry = 0;
-atomic_int	mem_log_what = 0;
-atomic_int	mem_log_tid = 0;
-atomic_int	mem_mime_slot = 0;
-atomic_int	mem_page = 0;
-atomic_int	mem_page_msg = 0;
-atomic_int	mem_page_path = 0;
-atomic_int	mem_page_slot = 0;
-atomic_int	mem_pub = 0;
-atomic_int	mem_qitem = 0;
-atomic_int	mem_queue_item = 0;
-atomic_int	mem_rack_logger = 0;
-atomic_int	mem_req = 0;
-atomic_int	mem_res = 0;
-atomic_int	mem_res_body = 0;
-atomic_int	mem_response = 0;
-atomic_int	mem_subject = 0;
-atomic_int	mem_text = 0;
-atomic_int	mem_to_s = 0;
-atomic_int	mem_upgraded = 0;
+atomic_int	mem_bind = AGOO_ATOMIC_INT_INIT(0);
+atomic_int	mem_cb = AGOO_ATOMIC_INT_INIT(0);
+atomic_int	mem_con = AGOO_ATOMIC_INT_INIT(0);
+atomic_int	mem_cslot = AGOO_ATOMIC_INT_INIT(0);
+atomic_int	mem_err_stream = AGOO_ATOMIC_INT_INIT(0);
+atomic_int	mem_eval_threads = AGOO_ATOMIC_INT_INIT(0);
+atomic_int	mem_group = AGOO_ATOMIC_INT_INIT(0);
+atomic_int	mem_graphql_arg = AGOO_ATOMIC_INT_INIT(0);
+atomic_int	mem_graphql_directive = AGOO_ATOMIC_INT_INIT(0);
+atomic_int	mem_graphql_field = AGOO_ATOMIC_INT_INIT(0);
+atomic_int	mem_graphql_link = AGOO_ATOMIC_INT_INIT(0);
+atomic_int	mem_graphql_slot = AGOO_ATOMIC_INT_INIT(0);
+atomic_int	mem_graphql_type = AGOO_ATOMIC_INT_INIT(0);
+atomic_int	mem_graphql_value = AGOO_ATOMIC_INT_INIT(0);
+atomic_int	mem_group_path = AGOO_ATOMIC_INT_INIT(0);
+atomic_int	mem_header = AGOO_ATOMIC_INT_INIT(0);
+atomic_int	mem_hook = AGOO_ATOMIC_INT_INIT(0);
+atomic_int	mem_hook_pattern = AGOO_ATOMIC_INT_INIT(0);
+atomic_int	mem_http_slot = AGOO_ATOMIC_INT_INIT(0);
+atomic_int	mem_log_entry = AGOO_ATOMIC_INT_INIT(0);
+atomic_int	mem_log_what = AGOO_ATOMIC_INT_INIT(0);
+atomic_int	mem_log_tid = AGOO_ATOMIC_INT_INIT(0);
+atomic_int	mem_mime_slot = AGOO_ATOMIC_INT_INIT(0);
+atomic_int	mem_page = AGOO_ATOMIC_INT_INIT(0);
+atomic_int	mem_page_msg = AGOO_ATOMIC_INT_INIT(0);
+atomic_int	mem_page_path = AGOO_ATOMIC_INT_INIT(0);
+atomic_int	mem_page_slot = AGOO_ATOMIC_INT_INIT(0);
+atomic_int	mem_pub = AGOO_ATOMIC_INT_INIT(0);
+atomic_int	mem_qitem = AGOO_ATOMIC_INT_INIT(0);
+atomic_int	mem_queue_item = AGOO_ATOMIC_INT_INIT(0);
+atomic_int	mem_rack_logger = AGOO_ATOMIC_INT_INIT(0);
+atomic_int	mem_req = AGOO_ATOMIC_INT_INIT(0);
+atomic_int	mem_res = AGOO_ATOMIC_INT_INIT(0);
+atomic_int	mem_res_body = AGOO_ATOMIC_INT_INIT(0);
+atomic_int	mem_response = AGOO_ATOMIC_INT_INIT(0);
+atomic_int	mem_subject = AGOO_ATOMIC_INT_INIT(0);
+atomic_int	mem_text = AGOO_ATOMIC_INT_INIT(0);
+atomic_int	mem_to_s = AGOO_ATOMIC_INT_INIT(0);
+atomic_int	mem_upgraded = AGOO_ATOMIC_INT_INIT(0);
 
 #ifdef MEM_DEBUG
 static void
@@ -159,7 +159,7 @@ debug_rreport() {
 
 void
 debug_add(void *ptr, const char *type, const char *file, int line) {
-    Rec	r = (Rec)malloc(sizeof(struct _Rec));
+    Rec	r = (Rec)malloc(sizeof(struct _rec));
     
     r->ptr = ptr;
     r->type = type;

data/ext/agoo/debug.h

@@ -3,7 +3,7 @@
 #ifndef AGOO_DEBUG_H
 #define AGOO_DEBUG_H
 
-#include <stdatomic.h>
+#include "atomic.h"
 
 #ifdef MEM_DEBUG
 #define DEBUG_ALLOC(var, ptr) { atomic_fetch_add(&var, 1); debug_add(ptr, #var, FILE, LINE); }

data/ext/agoo/doc.c

@@ -19,7 +19,7 @@ pttttttttttttttttttttttttttp.p.t\
 ................................";
 
 void
-doc_init(Doc doc, const char *str, int len) {
+agoo_doc_init(agooDoc doc, const char *str, int len) {
     if (0 >= len) {
 	len = (int)strlen(str);
     }
@@ -33,7 +33,7 @@ doc_init(Doc doc, const char *str, int len) {
 }
 
 int
-doc_skip_white(Doc doc) {
+agoo_doc_skip_white(agooDoc doc) {
     const char	*start = doc->cur;
     
     for (; 'w' == char_map[*(uint8_t*)doc->cur]; doc->cur++) {
@@ -42,7 +42,7 @@ doc_skip_white(Doc doc) {
 }
 
 void
-doc_skip_comment(Doc doc) {
+agoo_doc_skip_comment(agooDoc doc) {
     for (; true; doc->cur++) {
 	switch (*doc->cur) {
 	case '\r':
@@ -55,7 +55,7 @@ doc_skip_comment(Doc doc) {
 }
 
 void
-doc_read_token(Doc doc) {
+agoo_doc_read_token(agooDoc doc) {
     if ('t' == char_map[*(uint8_t*)doc->cur] && '9' < *doc->cur) {
 	doc->cur++;
 	for (; 't' == char_map[*(uint8_t*)doc->cur]; doc->cur++) {
@@ -64,11 +64,11 @@ doc_read_token(Doc doc) {
 }
 
 void
-doc_next_token(Doc doc) {
+agoo_doc_next_token(agooDoc doc) {
     while (true) {
-	doc_skip_white(doc);
+	agoo_doc_skip_white(doc);
 	if ('#' == *doc->cur) {
-	    doc_skip_comment(doc);
+	    agoo_doc_skip_comment(doc);
 	} else {
 	    break;
 	}
@@ -77,12 +77,12 @@ doc_next_token(Doc doc) {
 
 // Just find end.
 int
-doc_read_string(Err err, Doc doc) {
+agoo_doc_read_string(agooErr err, agooDoc doc) {
     doc->cur++; // skip first "
     if ('"' == *doc->cur) { // a """ string or an empty string
 	doc->cur++;
 	if ('"' != *doc->cur) {
-	    return ERR_OK; // empty string
+	    return AGOO_ERR_OK; // empty string
 	}
 	doc->cur++;
 	for (; doc->cur < doc->end; doc->cur++) {
@@ -102,13 +102,13 @@ doc_read_string(Err err, Doc doc) {
 	}
     }
     if (doc->end <= doc->cur) {
-	return doc_err(doc, err, "String not terminated");
+	return agoo_doc_err(doc, err, "String not terminated");
     }
-    return ERR_OK;
+    return AGOO_ERR_OK;
 }
 
 int
-doc_err(Doc doc, Err err, const char *fmt, ...) {
+agoo_doc_err(agooDoc doc, agooErr err, const char *fmt, ...) {
     va_list	ap;
     char	msg[248];
     int		line = 0;
@@ -116,14 +116,14 @@ doc_err(Doc doc, Err err, const char *fmt, ...) {
 
     va_start(ap, fmt);
     vsnprintf(msg, sizeof(msg), fmt, ap);
-    doc_location(doc, &line, &col);
+    agoo_doc_location(doc, &line, &col);
     va_end(ap);
 
-    return err_set(err, ERR_PARSE, "%s at %d:%d", msg, line, col);
+    return agoo_err_set(err, AGOO_ERR_PARSE, "%s at %d:%d", msg, line, col);
 }
 
 void
-doc_location(Doc doc, int *linep, int *colp) {
+agoo_doc_location(agooDoc doc, int *linep, int *colp) {
     const char	*s;
     int		line = 1;
     int		col = 1;
@@ -151,9 +151,9 @@ doc_location(Doc doc, int *linep, int *colp) {
 }
 
 gqlValue
-doc_read_value(Err err, Doc doc) {
+agoo_doc_read_value(agooErr err, agooDoc doc) {
     // TBD handle list and object as well as scalars, object is typeless
-    // TBD put this in doc_read_value
+    // TBD put this in agoo_doc_read_value
     return NULL;
 }
 

data/ext/agoo/doc.h

@@ -9,26 +9,26 @@
 
 struct _gqlValue;
 
-typedef struct _Doc {
+typedef struct _agooDoc {
     const char	*str;
     const char	*cur;
     const char	*end;
-} *Doc;
+} *agooDoc;
 
-extern void	doc_init(Doc doc, const char *str, int len);
+extern void	agoo_doc_init(agooDoc doc, const char *str, int len);
 
-extern int	doc_skip_white(Doc doc);
-extern void	doc_skip_comment(Doc doc);
-extern int	doc_read_desc(Err err, Doc doc);
+extern int	agoo_doc_skip_white(agooDoc doc);
+extern void	agoo_doc_skip_comment(agooDoc doc);
+extern int	agoo_doc_read_desc(agooErr err, agooDoc doc);
 
-extern void	doc_next_token(Doc doc);
-extern void	doc_read_token(Doc doc);
+extern void	agoo_doc_next_token(agooDoc doc);
+extern void	agoo_doc_read_token(agooDoc doc);
 
-extern int	doc_read_string(Err err, Doc doc);
+extern int	agoo_doc_read_string(agooErr err, agooDoc doc);
 
-extern int	doc_err(Doc doc, Err err, const char *fmt, ...);
-extern void	doc_location(Doc doc, int *linep, int *colp);
+extern int	agoo_doc_err(agooDoc doc, agooErr err, const char *fmt, ...);
+extern void	agoo_doc_location(agooDoc doc, int *linep, int *colp);
 
-extern struct _gqlValue*	doc_read_value(Err err, Doc doc);
+extern struct _gqlValue*	agoo_doc_read_value(agooErr err, agooDoc doc);
 
 #endif // AGOO_DOC_H

data/ext/agoo/err.c

@@ -11,7 +11,7 @@
 #endif
 
 int
-err_set(Err err, int code, const char *fmt, ...) {
+agoo_err_set(agooErr err, int code, const char *fmt, ...) {
     va_list	ap;
 
     va_start(ap, fmt);
@@ -23,7 +23,7 @@ err_set(Err err, int code, const char *fmt, ...) {
 }
 
 int
-err_no(Err err, const char *fmt, ...) {
+agoo_err_no(agooErr err, const char *fmt, ...) {
     int	cnt = 0;
     
     if (NULL != fmt) {
@@ -45,32 +45,32 @@ err_no(Err err, const char *fmt, ...) {
 }
 
 void
-err_clear(Err err) {
-    err->code = ERR_OK;
+agoo_err_clear(agooErr err) {
+    err->code = AGOO_ERR_OK;
     *err->msg = '\0';
 }
 
 const char*
-err_str(ErrCode code) {
+agoo_err_str(agooErrCode code) {
     const char	*str = NULL;
     
-    if (code < ERR_START) {
+    if (code < AGOO_ERR_START) {
 	str = strerror(code);
     }
     if (NULL == str) {
 	switch (code) {
-	case ERR_PARSE:		str = "parse error";		break;
-	case ERR_READ:		str = "read failed";		break;
-	case ERR_WRITE:		str = "write failed";		break;
-	case ERR_ARG:		str = "invalid argument";	break;
-	case ERR_NOT_FOUND:	str = "not found";		break;
-	case ERR_THREAD:	str = "thread error";		break;
-	case ERR_NETWORK:	str = "network error";		break;
-	case ERR_LOCK:		str = "lock error";		break;
-	case ERR_FREE:		str = "already freed";		break;
-	case ERR_IN_USE:	str = "in use";			break;
-	case ERR_TOO_MANY:	str = "too many";		break;
-	case ERR_TYPE:		str = "type error";		break;
+	case AGOO_ERR_PARSE:	str = "parse error";		break;
+	case AGOO_ERR_READ:	str = "read failed";		break;
+	case AGOO_ERR_WRITE:	str = "write failed";		break;
+	case AGOO_ERR_ARG:	str = "invalid argument";	break;
+	case AGOO_ERR_NOT_FOUND:str = "not found";		break;
+	case AGOO_ERR_THREAD:	str = "thread error";		break;
+	case AGOO_ERR_NETWORK:	str = "network error";		break;
+	case AGOO_ERR_LOCK:	str = "lock error";		break;
+	case AGOO_ERR_FREE:	str = "already freed";		break;
+	case AGOO_ERR_IN_USE:	str = "in use";			break;
+	case AGOO_ERR_TOO_MANY:	str = "too many";		break;
+	case AGOO_ERR_TYPE:	str = "type error";		break;
 	default:		str = "unknown error";		break;
 	}
     }

data/ext/agoo/err.h

@@ -5,41 +5,41 @@
 
 #include <errno.h>
 
-#define ERR_START	300
-#define ERR_INIT	{ 0, { 0 } }
+#define AGOO_ERR_START	300
+#define AGOO_ERR_INIT	{ 0, { 0 } }
 
 typedef enum {
-    ERR_OK	= 0,
-    ERR_MEMORY	= ENOMEM,
-    ERR_DENIED	= EACCES,
-    ERR_IMPL	= ENOSYS,
-    ERR_PARSE	= ERR_START,
-    ERR_READ,
-    ERR_WRITE,
-    ERR_OVERFLOW,
-    ERR_ARG,
-    ERR_NOT_FOUND,
-    ERR_THREAD,
-    ERR_NETWORK,
-    ERR_LOCK,
-    ERR_FREE,
-    ERR_IN_USE,
-    ERR_TOO_MANY,
-    ERR_TYPE,
-    ERR_LAST
-} ErrCode;
+    AGOO_ERR_OK	= 0,
+    AGOO_ERR_MEMORY	= ENOMEM,
+    AGOO_ERR_DENIED	= EACCES,
+    AGOO_ERR_IMPL	= ENOSYS,
+    AGOO_ERR_PARSE	= AGOO_ERR_START,
+    AGOO_ERR_READ,
+    AGOO_ERR_WRITE,
+    AGOO_ERR_OVERFLOW,
+    AGOO_ERR_ARG,
+    AGOO_ERR_NOT_FOUND,
+    AGOO_ERR_THREAD,
+    AGOO_ERR_NETWORK,
+    AGOO_ERR_LOCK,
+    AGOO_ERR_FREE,
+    AGOO_ERR_IN_USE,
+    AGOO_ERR_TOO_MANY,
+    AGOO_ERR_TYPE,
+    AGOO_ERR_LAST
+} agooErrCode;
 
 // The struct used to report errors or status after a function returns. The
 // struct must be initialized before use as most calls that take an err
 // argument will return immediately if an error has already occurred.
-typedef struct _Err {
+typedef struct _agooErr {
     int		code;
     char	msg[256];
-} *Err;
+} *agooErr;
 
-extern int		err_set(Err err, int code, const char *fmt, ...);
-extern int		err_no(Err err, const char *fmt, ...);
-extern const char*	err_str(ErrCode code);
-extern void		err_clear(Err err);
+extern int		agoo_err_set(agooErr err, int code, const char *fmt, ...);
+extern int		agoo_err_no(agooErr err, const char *fmt, ...);
+extern const char*	agoo_err_str(agooErrCode code);
+extern void		agoo_err_clear(agooErr err);
 
 #endif /* AGOO_ERR_H */