agoo 2.5.5 → 2.5.6

data/ext/agoo/sse.c

@@ -15,14 +15,14 @@ Connection: keep-alive\r\n\
 \r\n\
 retry: 5\n\n";
 
-Text
-sse_upgrade(Req req, Text t) {
+agooText
+agoo_sse_upgrade(agooReq req, agooText t) {
     t->len = 0; // reset
-    return text_append(t, up, sizeof(up) - 1);
+    return agoo_text_append(t, up, sizeof(up) - 1);
 }
 
-Text
-sse_expand(Text t) {
-    t = text_prepend(t, prefix, sizeof(prefix) - 1);
-    return text_append(t, suffix, sizeof(suffix) - 1);
+agooText
+agoo_sse_expand(agooText t) {
+    t = agoo_text_prepend(t, prefix, sizeof(prefix) - 1);
+    return agoo_text_append(t, suffix, sizeof(suffix) - 1);
 }

data/ext/agoo/sse.h

@@ -3,10 +3,10 @@
 #ifndef AGOO_SSE_H
 #define AGOO_SSE_H
 
-struct _Req;
-struct _Text;
+struct _agooReq;
+struct _agooText;
 
-extern struct _Text*	sse_upgrade(struct _Req *req, struct _Text *t);
-extern struct _Text*	sse_expand(struct _Text *t);
+extern struct _agooText*	agoo_sse_upgrade(struct _agooReq *req, struct _agooText *t);
+extern struct _agooText*	agoo_sse_expand(struct _agooText *t);
 
 #endif // AGOO_SSE_H

data/ext/agoo/subject.c

@@ -7,9 +7,9 @@
 #include "debug.h"
 #include "subject.h"
 
-Subject
-subject_create(const char *pattern, int plen) {
-    Subject	subject = (Subject)malloc(sizeof(struct _Subject) - 7 + plen);
+agooSubject
+agoo_subject_create(const char *pattern, int plen) {
+    agooSubject	subject = (agooSubject)malloc(sizeof(struct _agooSubject) - 7 + plen);
 
     if (NULL != subject) {
 	DEBUG_ALLOC(mem_subject, subject);
@@ -21,13 +21,13 @@ subject_create(const char *pattern, int plen) {
 }
 
 void
-subject_destroy(Subject subject) {
+agoo_subject_destroy(agooSubject subject) {
     DEBUG_FREE(mem_subject, subject);
     free(subject);
 }
 
 bool
-subject_check(Subject subj, const char *subject) {
+agoo_subject_check(agooSubject subj, const char *subject) {
     const char	*pat = subj->pattern;
 
     for (; '\0' != *pat && '\0' != *subject; subject++) {

data/ext/agoo/subject.h

@@ -5,13 +5,13 @@
 
 #include <stdbool.h>
 
-typedef struct _Subject {
-    struct _Subject	*next;
+typedef struct _agooSubject {
+    struct _agooSubject	*next;
     char		pattern[8];
-} *Subject;
+} *agooSubject;
 
-extern Subject	subject_create(const char *pattern, int plen);
-extern void	subject_destroy(Subject subject);
-extern bool	subject_check(Subject subj, const char *subject);
+extern agooSubject	agoo_subject_create(const char *pattern, int plen);
+extern void		agoo_subject_destroy(agooSubject subject);
+extern bool		agoo_subject_check(agooSubject subj, const char *subject);
 
 #endif // AGOO_SUBJECT_H

data/ext/agoo/text.c

@@ -7,9 +7,9 @@
 #include "debug.h"
 #include "text.h"
 
-Text
-text_create(const char *str, int len) {
-    Text	t = (Text)malloc(sizeof(struct _Text) - TEXT_MIN_SIZE + len + 1);
+agooText
+agoo_text_create(const char *str, int len) {
+    agooText	t = (agooText)malloc(sizeof(struct _agooText) - AGOO_TEXT_MIN_SIZE + len + 1);
 
     if (NULL != t) {
 	DEBUG_ALLOC(mem_text, t)
@@ -23,9 +23,9 @@ text_create(const char *str, int len) {
     return t;
 }
 
-Text
-text_dup(Text t0) {
-    Text	t = (Text)malloc(sizeof(struct _Text) - TEXT_MIN_SIZE + t0->alen + 1);
+agooText
+agoo_text_dup(agooText t0) {
+    agooText	t = (agooText)malloc(sizeof(struct _agooText) - AGOO_TEXT_MIN_SIZE + t0->alen + 1);
 
     if (NULL != t) {
 	DEBUG_ALLOC(mem_text, t)
@@ -38,9 +38,9 @@ text_dup(Text t0) {
     return t;
 }
 
-Text
-text_allocate(int len) {
-    Text	t = (Text)malloc(sizeof(struct _Text) - TEXT_MIN_SIZE + len + 1);
+agooText
+agoo_text_allocate(int len) {
+    agooText	t = (agooText)malloc(sizeof(struct _agooText) - AGOO_TEXT_MIN_SIZE + len + 1);
 
     if (NULL != t) {
 	DEBUG_ALLOC(mem_text, t)
@@ -54,30 +54,30 @@ text_allocate(int len) {
 }
 
 void
-text_ref(Text t) {
+agoo_text_ref(agooText t) {
     atomic_fetch_add(&t->ref_cnt, 1);
 }
 
 void
-text_release(Text t) {
+agoo_text_release(agooText t) {
     if (1 >= atomic_fetch_sub(&t->ref_cnt, 1)) {
 	DEBUG_FREE(mem_text, t);
 	free(t);
     }
 }
 
-Text
-text_append(Text t, const char *s, int len) {
+agooText
+agoo_text_append(agooText t, const char *s, int len) {
     if (0 >= len) {
 	len = (int)strlen(s);
     }
     if (t->alen <= t->len + len) {
 	long	new_len = t->alen + len + t->alen / 2;
-	size_t	size = sizeof(struct _Text) - TEXT_MIN_SIZE + new_len + 1;
+	size_t	size = sizeof(struct _agooText) - AGOO_TEXT_MIN_SIZE + new_len + 1;
 #ifdef MEM_DEBUG
-	Text	t0 = t;
+	agooText	t0 = t;
 #endif	
-	if (NULL == (t = (Text)realloc(t, size))) {
+	if (NULL == (t = (agooText)realloc(t, size))) {
 	    return NULL;
 	}
 	DEBUG_REALLOC(mem_text, t0, t);
@@ -90,19 +90,19 @@ text_append(Text t, const char *s, int len) {
     return t;
 }
 
-Text
-text_prepend(Text t, const char *s, int len) {
+agooText
+agoo_text_prepend(agooText t, const char *s, int len) {
     if (0 >= len) {
 	len = (int)strlen(s);
     }
     if (t->alen <= t->len + len) {
 	long	new_len = t->alen + len + t->alen / 2;
-	size_t	size = sizeof(struct _Text) - TEXT_MIN_SIZE + new_len + 1;
+	size_t	size = sizeof(struct _agooText) - AGOO_TEXT_MIN_SIZE + new_len + 1;
 #ifdef MEM_DEBUG
-	Text	t0 = t;
+	agooText	t0 = t;
 #endif	
 
-	if (NULL == (t = (Text)realloc(t, size))) {
+	if (NULL == (t = (agooText)realloc(t, size))) {
 	    return NULL;
 	}
 	DEBUG_REALLOC(mem_text, t0, t);

data/ext/agoo/text.h

@@ -3,25 +3,26 @@
 #ifndef AGOO_TEXT_H
 #define AGOO_TEXT_H
 
-#include <stdatomic.h>
 #include <stdbool.h>
 
-#define TEXT_MIN_SIZE	8
+#include "atomic.h"
 
-typedef struct _Text {
+#define AGOO_TEXT_MIN_SIZE	8
+
+typedef struct _agooText {
     long	len; // length of valid text
     long	alen; // size of allocated text
     atomic_int	ref_cnt;
     bool	bin;
-    char	text[TEXT_MIN_SIZE];
-} *Text;
+    char	text[AGOO_TEXT_MIN_SIZE];
+} *agooText;
 
-extern Text	text_create(const char *str, int len);
-extern Text	text_dup(Text t);
-extern Text	text_allocate(int len);
-extern void	text_ref(Text t);
-extern void	text_release(Text t);
-extern Text	text_append(Text t, const char *s, int len);
-extern Text	text_prepend(Text t, const char *s, int len);
+extern agooText	agoo_text_create(const char *str, int len);
+extern agooText	agoo_text_dup(agooText t);
+extern agooText	agoo_text_allocate(int len);
+extern void	agoo_text_ref(agooText t);
+extern void	agoo_text_release(agooText t);
+extern agooText	agoo_text_append(agooText t, const char *s, int len);
+extern agooText	agoo_text_prepend(agooText t, const char *s, int len);
 
-#endif /* AGOO_TEXT_H */
+#endif // AGOO_TEXT_H

data/ext/agoo/upgraded.c

@@ -11,14 +11,14 @@
 #include "upgraded.h"
 
 static void
-destroy(Upgraded up) {
-    Subject	subject;
+destroy(agooUpgraded up) {
+    agooSubject	subject;
 
     if (NULL != up->on_destroy) {
 	up->on_destroy(up);
     }
     if (NULL == up->prev) {
-	the_server.up_list = up->next;
+	agoo_server.up_list = up->next;
 	if (NULL != up->next) {
 	    up->next->prev = NULL;
 	}
@@ -30,40 +30,40 @@ destroy(Upgraded up) {
     }
     while (NULL != (subject = up->subjects)) {
 	up->subjects = up->subjects->next;
-	subject_destroy(subject);
+	agoo_subject_destroy(subject);
     }
     DEBUG_FREE(mem_upgraded, up);
     free(up);
 }
 
 void
-upgraded_release(Upgraded up) {
-    pthread_mutex_lock(&the_server.up_lock);
+agoo_upgraded_release(agooUpgraded up) {
+    pthread_mutex_lock(&agoo_server.up_lock);
     if (atomic_fetch_sub(&up->ref_cnt, 1) <= 1) {
 	destroy(up);
     }    
-    pthread_mutex_unlock(&the_server.up_lock);
+    pthread_mutex_unlock(&agoo_server.up_lock);
 }
 
 void
-upgraded_release_con(Upgraded up) {
-    pthread_mutex_lock(&the_server.up_lock);
+agoo_upgraded_release_con(agooUpgraded up) {
+    pthread_mutex_lock(&agoo_server.up_lock);
     up->con = NULL;
     if (atomic_fetch_sub(&up->ref_cnt, 1) <= 1) {
 	destroy(up);
     }
-    pthread_mutex_unlock(&the_server.up_lock);
+    pthread_mutex_unlock(&agoo_server.up_lock);
 }
 
 // Called from the con_loop thread, no need to lock, this steals the subject
 // so the pub subject should set to NULL
 void
-upgraded_add_subject(Upgraded up, Subject subject) {
-    Subject	s;
+agoo_upgraded_add_subject(agooUpgraded up, agooSubject subject) {
+    agooSubject	s;
 
     for (s = up->subjects; NULL != s; s = s->next) {
 	if (0 == strcmp(subject->pattern, s->pattern)) {
-	    subject_destroy(subject);
+	    agoo_subject_destroy(subject);
 	    return;
 	}
     }
@@ -72,15 +72,15 @@ upgraded_add_subject(Upgraded up, Subject subject) {
 }
 
 void
-upgraded_del_subject(Upgraded up, Subject subject) {
+agoo_upgraded_del_subject(agooUpgraded up, agooSubject subject) {
     if (NULL == subject) {
 	while (NULL != (subject = up->subjects)) {
 	    up->subjects = up->subjects->next;
-	    subject_destroy(subject);
+	    agoo_subject_destroy(subject);
 	}
     } else {
-	Subject	s;
-	Subject	prev = NULL;
+	agooSubject	s;
+	agooSubject	prev = NULL;
 
 	for (s = up->subjects; NULL != s; s = s->next) {
 	    if (0 == strcmp(subject->pattern, s->pattern)) {
@@ -89,7 +89,7 @@ upgraded_del_subject(Upgraded up, Subject subject) {
 		} else {
 		    prev->next = s->next;
 		}
-		subject_destroy(s);
+		agoo_subject_destroy(s);
 		break;
 	    }
 	    prev = s;
@@ -98,11 +98,11 @@ upgraded_del_subject(Upgraded up, Subject subject) {
 }
 
 bool
-upgraded_match(Upgraded up, const char *subject) {
-    Subject	s;
+agoo_upgraded_match(agooUpgraded up, const char *subject) {
+    agooSubject	s;
 
     for (s = up->subjects; NULL != s; s = s->next) {
-	if (subject_check(s, subject)) {
+	if (agoo_subject_check(s, subject)) {
 	    return true;
 	}
     }
@@ -110,15 +110,15 @@ upgraded_match(Upgraded up, const char *subject) {
 }
 
 void
-upgraded_ref(Upgraded up) {
+agoo_upgraded_ref(agooUpgraded up) {
     atomic_fetch_add(&up->ref_cnt, 1);
 }
 
 bool
-upgraded_write(Upgraded up, const char *message, size_t mlen, bool bin, bool inc_ref) {
-    Pub	p;
+agoo_upgraded_write(agooUpgraded up, const char *message, size_t mlen, bool bin, bool inc_ref) {
+    agooPub	p;
 
-    if (0 < the_server.max_push_pending && the_server.max_push_pending <= atomic_load(&up->pending)) {
+    if (0 < agoo_server.max_push_pending && agoo_server.max_push_pending <= (long)atomic_load(&up->pending)) {
 	atomic_fetch_sub(&up->ref_cnt, 1);
 	// Too many pending messages.
 	return false;
@@ -126,57 +126,58 @@ upgraded_write(Upgraded up, const char *message, size_t mlen, bool bin, bool inc
     if (inc_ref) {
 	atomic_fetch_add(&up->ref_cnt, 1);
     }
-    p = pub_write(up, message, mlen, bin);
+    p = agoo_pub_write(up, message, mlen, bin);
     atomic_fetch_add(&up->pending, 1);
-    server_publish(p);
+    agoo_server_publish(p);
 
     return true;
 }
 
 void
-upgraded_subscribe(Upgraded up, const char *subject, int slen, bool inc_ref) {
+agoo_upgraded_subscribe(agooUpgraded up, const char *subject, int slen, bool inc_ref) {
     if (inc_ref) {
 	atomic_fetch_add(&up->ref_cnt, 1);
     }
     atomic_fetch_add(&up->pending, 1);
-    server_publish(pub_subscribe(up, subject, slen));
+    agoo_server_publish(agoo_pub_subscribe(up, subject, slen));
 }
 
 void
-upgraded_unsubscribe(Upgraded up, const char *subject, int slen, bool inc_ref) {
+agoo_upgraded_unsubscribe(agooUpgraded up, const char *subject, int slen, bool inc_ref) {
     if (inc_ref) {
 	atomic_fetch_add(&up->ref_cnt, 1);
     }
     atomic_fetch_add(&up->pending, 1);
-    server_publish(pub_unsubscribe(up, subject, slen));
+    agoo_server_publish(agoo_pub_unsubscribe(up, subject, slen));
 }
 
 void
-upgraded_close(Upgraded up, bool inc_ref) {
+agoo_upgraded_close(agooUpgraded up, bool inc_ref) {
     if (inc_ref) {
 	atomic_fetch_add(&up->ref_cnt, 1);
     }
     atomic_fetch_add(&up->pending, 1);
-    server_publish(pub_close(up));
+    agoo_server_publish(agoo_pub_close(up));
 }
 
 int
-upgraded_pending(Upgraded up) {
-    return atomic_load(&up->pending);
+agoo_upgraded_pending(agooUpgraded up) {
+    return (int)(long)atomic_load(&up->pending);
 }
 
-Upgraded
-upgraded_create(Con c, void * ctx, void *env) {
-    Upgraded	up = (Upgraded)malloc(sizeof(struct _Upgraded));
+agooUpgraded
+agoo_upgraded_create(agooCon c, void * ctx, void *env) {
+    agooUpgraded	up = (agooUpgraded)malloc(sizeof(struct _agooUpgraded));
 
     if (NULL != up) {
 	DEBUG_ALLOC(mem_upgraded, up);
-	memset(up, 0, sizeof(struct _Upgraded));
+	memset(up, 0, sizeof(struct _agooUpgraded));
 	up->con = c;
 	up->ctx = ctx;
 	up->env = env;
 	atomic_init(&up->pending, 0);
-	atomic_init(&up->ref_cnt, 1); // start with 1 for the Con reference
+	atomic_init(&up->ref_cnt, 0);
+	atomic_store(&up->ref_cnt, 1); // start with 1 for the Con reference
     }
     return up;
 }

data/ext/agoo/upgraded.h

@@ -4,48 +4,49 @@
 #define AGOO_UPGRADED_H
 
 #include <pthread.h>
-#include <stdatomic.h>
 #include <stdint.h>
 #include <stdbool.h>
 
-struct _Con;
-struct _Subject;
-
-typedef struct _Upgraded {
-    struct _Upgraded	*next;
-    struct _Upgraded	*prev;
-    struct _Con		*con;
-    atomic_int		pending;
-    atomic_int		ref_cnt;
-    struct _Subject	*subjects;
-
-    void		*ctx;
-    void		*wrap;
-    void		*env;
-
-    bool		on_empty;
-    bool		on_close;
-    bool		on_shut;
-    bool		on_msg;
-    bool		on_error;
-    void		(*on_destroy)(struct _Upgraded *up);
-} *Upgraded;
-
-extern Upgraded	upgraded_create(struct _Con *c, void * ctx, void *env);
-
-extern void	upgraded_release(Upgraded up);
-extern void	upgraded_release_con(Upgraded up);
-
-extern void	upgraded_ref(Upgraded up);
-
-extern void	upgraded_add_subject(Upgraded up, struct _Subject *subject);
-extern void	upgraded_del_subject(Upgraded up, struct _Subject *subject);
-extern bool	upgraded_match(Upgraded up, const char *subject);
-
-extern bool	upgraded_write(Upgraded up, const char *message, size_t mlen, bool bin, bool inc_ref);
-extern void	upgraded_subscribe(Upgraded up, const char *subject, int slen, bool inc_ref);
-extern void	upgraded_unsubscribe(Upgraded up, const char *subject, int slen, bool inc_ref);
-extern void	upgraded_close(Upgraded up, bool inc_ref);
-extern int	upgraded_pending(Upgraded up);
+#include "atomic.h"
+
+struct _agooCon;
+struct _agooSubject;
+
+typedef struct _agooUpgraded {
+    struct _agooUpgraded	*next;
+    struct _agooUpgraded	*prev;
+    struct _agooCon		*con;
+    atomic_int			pending;
+    atomic_int			ref_cnt;
+    struct _agooSubject		*subjects;
+
+    void			*ctx;
+    void			*wrap;
+    void			*env;
+
+    bool			on_empty;
+    bool			on_close;
+    bool			on_shut;
+    bool			on_msg;
+    bool			on_error;
+    void			(*on_destroy)(struct _agooUpgraded *up);
+} *agooUpgraded;
+
+extern agooUpgraded	agoo_upgraded_create(struct _agooCon *c, void * ctx, void *env);
+
+extern void		agoo_upgraded_release(agooUpgraded up);
+extern void		agoo_upgraded_release_con(agooUpgraded up);
+
+extern void		agoo_upgraded_ref(agooUpgraded up);
+
+extern void		agoo_upgraded_add_subject(agooUpgraded up, struct _agooSubject *subject);
+extern void		agoo_upgraded_del_subject(agooUpgraded up, struct _agooSubject *subject);
+extern bool		agoo_upgraded_match(agooUpgraded up, const char *subject);
+
+extern bool		agoo_upgraded_write(agooUpgraded up, const char *message, size_t mlen, bool bin, bool inc_ref);
+extern void		agoo_upgraded_subscribe(agooUpgraded up, const char *subject, int slen, bool inc_ref);
+extern void		agoo_upgraded_unsubscribe(agooUpgraded up, const char *subject, int slen, bool inc_ref);
+extern void		agoo_upgraded_close(agooUpgraded up, bool inc_ref);
+extern int		agoo_upgraded_pending(agooUpgraded up);
 
 #endif // AGOO_UPGRADED_H