agoo 2.5.5 → 2.5.6

data/ext/agoo/page.h

@@ -9,38 +9,38 @@
 #include "err.h"
 #include "text.h"
 
-typedef struct _Page {
-    Text		resp;
+typedef struct _agooPage {
+    agooText		resp;
     char		*path;
     time_t		mtime;
     double		last_check;
     bool		immutable;
-} *Page;
+} *agooPage;
 
-typedef struct _Dir {
-    struct _Dir		*next;
+typedef struct _agooDir {
+    struct _agooDir	*next;
     char		*path;
     int			plen;
-} *Dir;
+} *agooDir;
 
-typedef struct _Group {
-    struct _Group	*next;
+typedef struct _agooGroup {
+    struct _agooGroup	*next;
     char		*path;
     int			plen;
-    Dir			dirs;
-} *Group;
+    agooDir		dirs;
+} *agooGroup;
 
-extern void	pages_init();
-extern void	pages_set_root(const char *root);
-extern void	pages_cleanup();
+extern void		agoo_pages_init();
+extern void		agoo_pages_set_root(const char *root);
+extern void		agoo_pages_cleanup();
 
-extern Group	group_create(const char *path);
-extern void	group_add(Group g, const char *dir);
-extern Page	group_get(Err err, const char *path, int plen);
+extern agooGroup	group_create(const char *path);
+extern void		group_add(agooGroup g, const char *dir);
+extern agooPage		group_get(agooErr err, const char *path, int plen);
 
-extern Page	page_create(const char *path);
-extern Page	page_immutable(Err err, const char *path, const char *content, int clen);
-extern Page	page_get(Err err, const char *path, int plen);
-extern int	mime_set(Err err, const char *key, const char *value);
+extern agooPage		agoo_page_create(const char *path);
+extern agooPage		agoo_page_immutable(agooErr err, const char *path, const char *content, int clen);
+extern agooPage		agoo_page_get(agooErr err, const char *path, int plen);
+extern int		mime_set(agooErr err, const char *key, const char *value);
 
-#endif /* AGOO_PAGE_H */
+#endif // AGOO_PAGE_H

data/ext/agoo/pub.c

@@ -10,14 +10,14 @@
 #include "text.h"
 #include "upgraded.h"
 
-Pub
-pub_close(Upgraded up) {
-    Pub	p = (Pub)malloc(sizeof(struct _Pub));
+agooPub
+agoo_pub_close(agooUpgraded up) {
+    agooPub	p = (agooPub)malloc(sizeof(struct _agooPub));
 
     if (NULL != p) {
 	DEBUG_ALLOC(mem_pub, p);
 	p->next = NULL;
-	p->kind = PUB_CLOSE;
+	p->kind = AGOO_PUB_CLOSE;
 	p->up = up;
 	p->subject = NULL;
 	p->msg = NULL;
@@ -25,32 +25,32 @@ pub_close(Upgraded up) {
     return p;
 }
 
-Pub
-pub_subscribe(Upgraded up, const char *subject, int slen) {
-    Pub	p = (Pub)malloc(sizeof(struct _Pub));
+agooPub
+agoo_pub_subscribe(agooUpgraded up, const char *subject, int slen) {
+    agooPub	p = (agooPub)malloc(sizeof(struct _agooPub));
 
     if (NULL != p) {
 	DEBUG_ALLOC(mem_pub, p);
 	p->next = NULL;
-	p->kind = PUB_SUB;
+	p->kind = AGOO_PUB_SUB;
 	p->up = up;
-	p->subject = subject_create(subject, slen);
+	p->subject = agoo_subject_create(subject, slen);
 	p->msg = NULL;
     }
     return p;
 }
 
-Pub
-pub_unsubscribe(Upgraded up, const char *subject, int slen) {
-    Pub	p = (Pub)malloc(sizeof(struct _Pub));
+agooPub
+agoo_pub_unsubscribe(agooUpgraded up, const char *subject, int slen) {
+    agooPub	p = (agooPub)malloc(sizeof(struct _agooPub));
 
     if (NULL != p) {
 	DEBUG_ALLOC(mem_pub, p);
 	p->next = NULL;
-	p->kind = PUB_UN;
+	p->kind = AGOO_PUB_UN;
 	p->up = up;
 	if (NULL != subject) {
-	    p->subject = subject_create(subject, slen);
+	    p->subject = agoo_subject_create(subject, slen);
 	} else {
 	    p->subject = NULL;
 	}
@@ -59,71 +59,71 @@ pub_unsubscribe(Upgraded up, const char *subject, int slen) {
     return p;
 }
 
-Pub
-pub_publish(const char *subject, int slen, const char *message, size_t mlen) {
-    Pub	p = (Pub)malloc(sizeof(struct _Pub));
+agooPub
+agoo_pub_publish(const char *subject, int slen, const char *message, size_t mlen) {
+    agooPub	p = (agooPub)malloc(sizeof(struct _agooPub));
 
     if (NULL != p) {
 	DEBUG_ALLOC(mem_pub, p);
 	p->next = NULL;
-	p->kind = PUB_MSG;
+	p->kind = AGOO_PUB_MSG;
 	p->up = NULL;
-	p->subject = subject_create(subject, slen);
+	p->subject = agoo_subject_create(subject, slen);
 	// Allocate an extra 24 bytes so the message can be expanded in place
 	// if a WebSocket or SSE write.
-	p->msg = text_append(text_allocate((int)mlen + 24), message, (int)mlen);
-	text_ref(p->msg);
+	p->msg = agoo_text_append(agoo_text_allocate((int)mlen + 24), message, (int)mlen);
+	agoo_text_ref(p->msg);
     }
     return p;
 }
 
-Pub
-pub_write(Upgraded up, const char *message, size_t mlen, bool bin) {
+agooPub
+agoo_pub_write(agooUpgraded up, const char *message, size_t mlen, bool bin) {
     // Allocate an extra 16 bytes so the message can be expanded in place if a
     // WebSocket write.
-    Pub	p = (Pub)malloc(sizeof(struct _Pub));
+    agooPub	p = (agooPub)malloc(sizeof(struct _agooPub));
 
     if (NULL != p) {
 	DEBUG_ALLOC(mem_pub, p);
 	p->next = NULL;
-	p->kind = PUB_WRITE;
+	p->kind = AGOO_PUB_WRITE;
 	p->up = up;
 	p->subject = NULL;
 	// Allocate an extra 16 bytes so the message can be expanded in place
 	// if a WebSocket write.
-	p->msg = text_append(text_allocate((int)mlen + 16), message, (int)mlen);
+	p->msg = agoo_text_append(agoo_text_allocate((int)mlen + 16), message, (int)mlen);
 	p->msg->bin = bin;
-	text_ref(p->msg);
+	agoo_text_ref(p->msg);
     }
     return p;
 }
 
-Pub
-pub_dup(Pub src) {
-    Pub	p = (Pub)malloc(sizeof(struct _Pub));
+agooPub
+agoo_pub_dup(agooPub src) {
+    agooPub	p = (agooPub)malloc(sizeof(struct _agooPub));
 
     if (NULL != p) {
 	DEBUG_ALLOC(mem_pub, p);
 	p->next = NULL;
 	p->kind = src->kind;
 	p->up = src->up;
-	p->subject = subject_create(src->subject->pattern, strlen(src->subject->pattern));
+	p->subject = agoo_subject_create(src->subject->pattern, strlen(src->subject->pattern));
 	p->msg = src->msg;
-	text_ref(p->msg);
+	agoo_text_ref(p->msg);
     }
     return p;
 }
 
 void
-pub_destroy(Pub pub) {
+agoo_pub_destroy(agooPub pub) {
     if (NULL != pub->msg) {
-	text_release(pub->msg);
+	agoo_text_release(pub->msg);
     }
     if (NULL != pub->subject) {
-	subject_destroy(pub->subject);
+	agoo_subject_destroy(pub->subject);
     }
     if (NULL != pub->up) {
-	upgraded_release(pub->up);
+	agoo_upgraded_release(pub->up);
     }
     DEBUG_FREE(mem_pub, pub);
     free(pub);

data/ext/agoo/pub.h

@@ -7,34 +7,34 @@
 #include <stdint.h>
 #include <stdlib.h>
 
-struct _Text;
-struct _Upgraded;
-struct _Subject;
+struct _agooText;
+struct _agooUpgraded;
+struct _agooSubject;
 
 typedef enum {
-    PUB_SUB	= 'S',
-    PUB_CLOSE	= 'C',
-    PUB_UN	= 'U',
-    PUB_MSG	= 'M',
-    PUB_WRITE	= 'W',
-} PubKind;
+    AGOO_PUB_SUB	= 'S',
+    AGOO_PUB_CLOSE	= 'C',
+    AGOO_PUB_UN		= 'U',
+    AGOO_PUB_MSG	= 'M',
+    AGOO_PUB_WRITE	= 'W',
+} agooPubKind;
 
 // Generated by extened handlers and placed on the pub_queue to be pulled off
 // in the con_loop.
-typedef struct _Pub {
-    struct _Pub		*next;
-    PubKind		kind;
-    struct _Upgraded	*up;
-    struct _Subject	*subject;
-    struct _Text	*msg;
-} *Pub;
+typedef struct _agooPub {
+    struct _agooPub		*next;
+    agooPubKind			kind;
+    struct _agooUpgraded	*up;
+    struct _agooSubject		*subject;
+    struct _agooText		*msg;
+} *agooPub;
 
-extern Pub	pub_close(struct _Upgraded *up);
-extern Pub	pub_subscribe(struct _Upgraded *up, const char *subject, int slen);
-extern Pub	pub_unsubscribe(struct _Upgraded *up, const char *subject, int slen);
-extern Pub	pub_publish(const char *subject, int slen, const char *message, size_t mlen);
-extern Pub	pub_write(struct _Upgraded *up, const char *message, size_t mlen, bool bin);
-extern Pub	pub_dup(Pub src);
-extern void	pub_destroy(Pub pub);
+extern agooPub	agoo_pub_close(struct _agooUpgraded *up);
+extern agooPub	agoo_pub_subscribe(struct _agooUpgraded *up, const char *subject, int slen);
+extern agooPub	agoo_pub_unsubscribe(struct _agooUpgraded *up, const char *subject, int slen);
+extern agooPub	agoo_pub_publish(const char *subject, int slen, const char *message, size_t mlen);
+extern agooPub	agoo_pub_write(struct _agooUpgraded *up, const char *message, size_t mlen, bool bin);
+extern agooPub	agoo_pub_dup(agooPub src);
+extern void	agoo_pub_destroy(agooPub pub);
 
 #endif // AGOO_PUB_H

data/ext/agoo/queue.c

@@ -27,25 +27,25 @@
 // 
 
 void
-queue_init(Queue q, size_t qsize) {
-    queue_multi_init(q, qsize, false, false);
+agoo_queue_init(agooQueue q, size_t qsize) {
+    agoo_queue_multi_init(q, qsize, false, false);
 }
 
 void
-queue_multi_init(Queue q, size_t qsize, bool multi_push, bool multi_pop) {
+agoo_queue_multi_init(agooQueue q, size_t qsize, bool multi_push, bool multi_pop) {
     if (qsize < 4) {
 	qsize = 4;
     }
-    q->q = (QItem*)malloc(sizeof(QItem) * qsize);
+    q->q = (agooQItem*)malloc(sizeof(agooQItem) * qsize);
     DEBUG_ALLOC(mem_qitem, q->q)
     q->end = q->q + qsize;
 
-    memset(q->q, 0, sizeof(QItem) * qsize);
-    q->head = q->q;
-    q->tail = q->q + 1;
-    atomic_flag_clear(&q->push_lock);
-    atomic_flag_clear(&q->pop_lock);
-    q->wait_state = 0;
+    memset(q->q, 0, sizeof(agooQItem) * qsize);
+    atomic_init(&q->head, q->q);
+    atomic_init(&q->tail, q->q + 1);
+    agoo_atomic_flag_init(&q->push_lock);
+    agoo_atomic_flag_init(&q->pop_lock);
+    atomic_init(&q->wait_state, 0);
     q->multi_push = multi_push;
     q->multi_pop = multi_pop;
     // Create when/if needed.
@@ -54,7 +54,7 @@ queue_multi_init(Queue q, size_t qsize, bool multi_push, bool multi_pop) {
 }
 
 void
-queue_cleanup(Queue q) {
+agoo_queue_cleanup(agooQueue q) {
     DEBUG_FREE(mem_qitem, q->q)
     free(q->q);
     q->q = NULL;
@@ -68,8 +68,8 @@ queue_cleanup(Queue q) {
 }
 
 void
-queue_push(Queue q, QItem item) {
-    QItem	*tail;
+agoo_queue_push(agooQueue q, agooQItem item) {
+    agooQItem	*tail;
 
     if (q->multi_push) {
 	while (atomic_flag_test_and_set(&q->push_lock)) {
@@ -77,11 +77,11 @@ queue_push(Queue q, QItem item) {
 	}
     }
     // Wait for head to move on.
-    while (atomic_load(&q->head) == q->tail) {
+    while (atomic_load(&q->head) == atomic_load(&q->tail)) {
 	dsleep(RETRY_SECS);
     }
-    *q->tail = item;
-    tail = q->tail + 1;
+    *(agooQItem*)atomic_load(&q->tail) = item;
+    tail = (agooQItem*)atomic_load(&q->tail) + 1;
 
     if (q->end <= tail) {
 	tail = q->q;
@@ -90,39 +90,39 @@ queue_push(Queue q, QItem item) {
     if (q->multi_push) {
 	atomic_flag_clear(&q->push_lock);
     }
-    if (0 != q->wsock && WAITING == atomic_load(&q->wait_state)) {
+    if (0 != q->wsock && WAITING == (long)atomic_load(&q->wait_state)) {
 	if (write(q->wsock, ".", 1)) {}
 	atomic_store(&q->wait_state, NOTIFIED);
     }
 }
 
 void
-queue_wakeup(Queue q) {
+agoo_queue_wakeup(agooQueue q) {
     if (0 != q->wsock) {
 	if (write(q->wsock, ".", 1)) {}
     }
 }
 
-QItem
-queue_pop(Queue q, double timeout) {
-    QItem	item;
-    QItem	*next;
+agooQItem
+agoo_queue_pop(agooQueue q, double timeout) {
+    agooQItem	item;
+    agooQItem	*next;
     
     if (q->multi_pop) {
 	while (atomic_flag_test_and_set(&q->pop_lock)) {
 	    dsleep(RETRY_SECS);
 	}
     }
-    item = *q->head;
+    item = *(agooQItem*)atomic_load(&q->head);
 
     if (NULL != item) {
-	*q->head = NULL;
+	*(agooQItem*)atomic_load(&q->head) = NULL;
 	if (q->multi_pop) {
 	    atomic_flag_clear(&q->pop_lock);
 	}
 	return item;
     }
-    next = q->head + 1;
+    next = (agooQItem*)atomic_load(&q->head) + 1;
 
     if (q->end <= next) {
 	next = q->q;
@@ -137,17 +137,16 @@ queue_pop(Queue q, double timeout) {
 	    }
 	    return NULL;
 	}
-	pa.fd = queue_listen(q);
+	pa.fd = agoo_queue_listen(q);
 	pa.events = POLLIN;
 	pa.revents = 0;
 	if (0 < poll(&pa, 1, WAIT_MSECS)) {
-	    queue_release(q);
+	    agoo_queue_release(q);
 	}
     }
     atomic_store(&q->head, next);
-
-    item = *q->head;
-    *q->head = NULL;
+    item = *next;
+    *next = NULL;
     if (q->multi_pop) {
 	atomic_flag_clear(&q->pop_lock);
     }
@@ -156,21 +155,21 @@ queue_pop(Queue q, double timeout) {
 
 // Called by the popper usually.
 bool
-queue_empty(Queue q) {
-    QItem	*head = atomic_load(&q->head);
-    QItem	*next = head + 1;
+agoo_queue_empty(agooQueue q) {
+    agooQItem	*head = atomic_load(&q->head);
+    agooQItem	*next = head + 1;
 
     if (q->end <= next) {
 	next = q->q;
     }
-    if (NULL == *head && q->tail == next) {
+    if (NULL == *head && atomic_load(&q->tail) == next) {
 	return true;
     }
     return false;
 }
 
 int
-queue_listen(Queue q) {
+agoo_queue_listen(agooQueue q) {
     if (0 == q->rsock) {
 	int	fd[2];
 
@@ -187,7 +186,7 @@ queue_listen(Queue q) {
 }
 
 void
-queue_release(Queue q) {
+agoo_queue_release(agooQueue q) {
     char	buf[8];
 
     // clear pipe
@@ -197,9 +196,9 @@ queue_release(Queue q) {
 }
 
 int
-queue_count(Queue q) {
+agoo_queue_count(agooQueue q) {
     int	size = (int)(q->end - q->q);
     
-    return (q->tail - q->head + size) % size;
+    return ((agooQItem*)atomic_load(&q->tail) - (agooQItem*)atomic_load(&q->head) + size) % size;
 }