agoo 2.5.7 → 2.6.0

data/ext/agoo/log.c

@@ -15,6 +15,7 @@
 #include "debug.h"
 #include "dtime.h"
 #include "log.h"
+#include "sectime.h"
 
 // lower gives faster response but burns more CPU. This is a reasonable compromise.
 #define RETRY_SECS	0.0001
@@ -183,12 +184,14 @@ classic_write(agooLogEntry e, FILE *file) {
 	min = t % 3600 / 60;
 	sec = t % 60;
     } else {
-	struct tm	*tm = gmtime(&t);
+	struct _agooTime	at;
 
-	hour = tm->tm_hour;
-	min = tm->tm_min;
-	sec = tm->tm_sec;
-	sprintf(agoo_log.day_buf, "%04d/%02d/%02d ", tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday);
+	agoo_sectime(t, &at);
+
+	hour = at.hour;
+	min = at.min;
+	sec = at.sec;
+	sprintf(agoo_log.day_buf, "%04d/%02d/%02d ", at.year, at.mon, at.day);
 	agoo_log.day_start = t - (hour * 3600 + min * 60 + sec);
 	agoo_log.day_end = agoo_log.day_start + 86400;
     }
@@ -325,12 +328,10 @@ loop(void *ctx) {
 		}
 	    }
 	    if (NULL != e->whatp) {
-		free(e->whatp);
-		DEBUG_FREE(mem_agoo_log_what, e->whatp)
+		AGOO_FREE(e->whatp);
 	    }
 	    if (NULL != e->tidp) {
-		free(e->tidp);
-		DEBUG_FREE(mem_agoo_log_tid, e->tidp)
+		AGOO_FREE(e->tidp);
 	    }
 	    e->ready = false;
 	}
@@ -391,8 +392,7 @@ agoo_log_close() {
 	agoo_log.file = NULL;
     }
     if (NULL != agoo_log.q) {
-	DEBUG_FREE(mem_agoo_log_entry, agoo_log.q);
-	free(agoo_log.q);
+	AGOO_FREE(agoo_log.q);
 	agoo_log.q = NULL;
 	agoo_log.end = NULL;
     }
@@ -449,8 +449,8 @@ agoo_log_cat_find(const char *label) {
 }
 
 #ifdef CLOCK_REALTIME
-static int64_t
-now_nano() {
+int64_t
+agoo_now_nano() {
     struct timespec	ts;
 	    
     clock_gettime(CLOCK_REALTIME, &ts);
@@ -458,8 +458,8 @@ now_nano() {
     return (int64_t)ts.tv_sec * 1000000000LL + (int64_t)ts.tv_nsec;
 }
 #else
-static int64_t
-now_nano() {
+int64_t
+agoo_now_nano() {
     struct timeval	tv;
     struct timezone	tz;
 
@@ -476,23 +476,21 @@ set_entry(agooLogEntry e, agooLogCat cat, const char *tid, const char *fmt, va_l
     va_copy(ap2, ap);
 
     e->cat = cat;
-    e->when = now_nano();
+    e->when = agoo_now_nano();
     e->whatp = NULL;
     if ((int)sizeof(e->what) <= (cnt = vsnprintf(e->what, sizeof(e->what), fmt, ap))) {
-	e->whatp = (char*)malloc(cnt + 1);
+	e->whatp = (char*)AGOO_MALLOC(cnt + 1);
 
-	DEBUG_ALLOC(mem_log_what, e->whatp)
-    
-	    if (NULL != e->whatp) {
-		vsnprintf(e->whatp, cnt + 1, fmt, ap2);
-	    }
+	if (NULL != e->whatp) {
+	    vsnprintf(e->whatp, cnt + 1, fmt, ap2);
+	}
     }
     if (NULL != tid) {
 	e->tidp = NULL;
 	if (strlen(tid) < sizeof(e->tid)) {
 	    strcpy(e->tid, tid);
 	} else {
-	    if (NULL != (e->tidp = strdup(tid))) {
+	    if (NULL != (e->tidp = AGOO_STRDUP(tid))) {
 		*e->tid = '\0';
 	    }
 	}
@@ -617,8 +615,7 @@ agoo_log_init(const char *app) {
     *agoo_log.day_buf = '\0';
     agoo_log.thread = 0;
 
-    agoo_log.q = (agooLogEntry)malloc(sizeof(struct _agooLogEntry) * qsize);
-    DEBUG_ALLOC(mem_log_entry, agoo_log.q)
+    agoo_log.q = (agooLogEntry)AGOO_MALLOC(sizeof(struct _agooLogEntry) * qsize);
     agoo_log.end = agoo_log.q + qsize;
     memset(agoo_log.q, 0, sizeof(struct _agooLogEntry) * qsize);
     atomic_init(&agoo_log.head, agoo_log.q);

data/ext/agoo/log.h

@@ -124,5 +124,6 @@ extern void		agoo_log_catv(agooLogCat cat, const char *tid, const char *fmt, va_
 extern int		agoo_log_start(agooErr err, bool with_pid);
 
 extern agooColor	find_color(const char *name);
+extern int64_t		agoo_now_nano();
 
 #endif /* AGOO_LOG_H */

data/ext/agoo/page.c

@@ -195,16 +195,14 @@ mime_set(agooErr err, const char *key, const char *value) {
 	if (h == (int64_t)s->hash && len == s->klen &&
 	    ((0 <= len && len <= MAX_KEY_UNIQ) || 0 == strncmp(s->key, key, len))) {
 
-	    DEBUG_FREE(mem_mime_slot, s->value);
-	    free(s->value);
-	    s->value = strdup(value);
+	    AGOO_FREE(s->value);
+	    s->value = AGOO_STRDUP(value);
 	    return AGOO_ERR_OK;
 	}
     }
-    if (NULL == (s = (MimeSlot)malloc(sizeof(struct _mimeSlot)))) {
+    if (NULL == (s = (MimeSlot)AGOO_MALLOC(sizeof(struct _mimeSlot)))) {
 	return agoo_err_set(err, AGOO_ERR_ARG, "out of memory adding %s", key);
     }
-    DEBUG_ALLOC(mem_mime_slot, s);
     s->hash = h;
     s->klen = len;
     if (NULL == key) {
@@ -212,7 +210,7 @@ mime_set(agooErr err, const char *key, const char *value) {
     } else {
 	strcpy(s->key, key);
     }
-    s->value = strdup(value);
+    s->value = AGOO_STRDUP(value);
     s->next = *bucket;
     *bucket = s;
 
@@ -241,10 +239,9 @@ cache_set(const char *key, int klen, agooPage value) {
 	    return old;
 	}
     }
-    if (NULL == (s = (Slot)malloc(sizeof(struct _slot)))) {
+    if (NULL == (s = (Slot)AGOO_MALLOC(sizeof(struct _slot)))) {
 	return value;
     }
-    DEBUG_ALLOC(mem_page_slot, s)
     s->hash = h;
     s->klen = len;
     if (NULL == key) {
@@ -266,7 +263,7 @@ agoo_pages_init() {
     struct _agooErr	err = AGOO_ERR_INIT;
     
     memset(&cache, 0, sizeof(struct _cache));
-    cache.root = strdup(".");
+    cache.root = AGOO_STRDUP(".");
     for (m = mime_map; NULL != m->suffix; m++) {
 	mime_set(&err, m->suffix, m->type);
     }
@@ -274,11 +271,11 @@ agoo_pages_init() {
 
 void
 agoo_pages_set_root(const char *root) {
-    free(cache.root);
+    AGOO_FREE(cache.root);
     if (NULL == root) {
 	cache.root = NULL;
     } else {
-	cache.root = strdup(root);
+	cache.root = AGOO_STRDUP(root);
     }
 }
 
@@ -288,10 +285,8 @@ agoo_page_destroy(agooPage p) {
 	agoo_text_release(p->resp);
 	p->resp = NULL;
     }
-    DEBUG_FREE(mem_page_path, p->path);
-    DEBUG_FREE(mem_page, p);
-    free(p->path);
-    free(p);
+    AGOO_FREE(p->path);
+    AGOO_FREE(p);
 }
 
 void
@@ -307,21 +302,20 @@ agoo_pages_cleanup() {
     for (i = PAGE_BUCKET_SIZE; 0 < i; i--, sp++) {
 	for (s = *sp; NULL != s; s = n) {
 	    n = s->next;
-	    DEBUG_FREE(mem_page_slot, s);
 	    agoo_page_destroy(s->value);
-	    free(s);
+	    AGOO_FREE(s);
 	}
 	*sp = NULL;
     }
     for (i = MIME_BUCKET_SIZE; 0 < i; i--, mp++) {
 	for (sm = *mp; NULL != sm; sm = m) {
 	    m = sm->next;
-	    DEBUG_FREE(mem_mime_slot, sm);
-	    free(sm);
+	    AGOO_FREE(sm->value);
+	    AGOO_FREE(sm);
 	}
 	*mp = NULL;
     }
-    free(cache.root);
+    AGOO_FREE(cache.root);
 }
 
 static const char*
@@ -349,16 +343,14 @@ path_mime(const char *path) {
 // allocations.
 agooPage
 agoo_page_create(const char *path) {
-    agooPage	p = (agooPage)malloc(sizeof(struct _agooPage));
+    agooPage	p = (agooPage)AGOO_MALLOC(sizeof(struct _agooPage));
 
     if (NULL != p) {
-	DEBUG_ALLOC(mem_page, p);
 	p->resp = NULL;
 	if (NULL == path) {
 	    p->path = NULL;
 	} else {
-	    p->path = strdup(path);
-	    DEBUG_ALLOC(mem_page_path, p->path);
+	    p->path = AGOO_STRDUP(path);
 	}
 	p->mtime = 0;
 	p->last_check = 0.0;
@@ -369,7 +361,7 @@ agoo_page_create(const char *path) {
 
 agooPage
 agoo_page_immutable(agooErr err, const char *path, const char *content, int clen) {
-    agooPage	p = (agooPage)malloc(sizeof(struct _agooPage));
+    agooPage	p = (agooPage)AGOO_MALLOC(sizeof(struct _agooPage));
     const char	*mime = path_mime(path);
     long	msize;
     int		cnt;
@@ -379,13 +371,11 @@ agoo_page_immutable(agooErr err, const char *path, const char *content, int clen
 	agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocate memory for page.");
 	return NULL;     
     }
-    DEBUG_ALLOC(mem_page, p);
     if (NULL == path) {
 	p->path = NULL;
     } else {
-	p->path = strdup(path);
+	p->path = AGOO_STRDUP(path);
 	plen = (int)strlen(path);
-	DEBUG_ALLOC(mem_page_path, p->path);
     }
     p->mtime = 0;
     p->last_check = 0.0;
@@ -401,8 +391,7 @@ agoo_page_immutable(agooErr err, const char *path, const char *content, int clen
     // padding. Then add the content length.
     msize = sizeof(page_fmt) + 60 + clen;
     if (NULL == (p->resp = agoo_text_allocate((int)msize))) {
-	DEBUG_FREE(mem_page, p);
-	free(p);
+	AGOO_FREE(p);
 	agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocate memory for page content.");
 	return NULL;
     }
@@ -532,9 +521,8 @@ agoo_page_remove(agooPage p) {
 	    } else {
 		prev->next = s->next;
 	    }
-	    DEBUG_FREE(mem_page_slot, s);
 	    agoo_page_destroy(s->value);
-	    free(s);
+	    AGOO_FREE(s);
 
 	    break;
 	}
@@ -677,15 +665,13 @@ group_get(agooErr err, const char *path, int plen) {
 
 agooGroup
 group_create(const char *path) {
-    agooGroup	g = (agooGroup)malloc(sizeof(struct _agooGroup));
+    agooGroup	g = (agooGroup)AGOO_MALLOC(sizeof(struct _agooGroup));
 
     if (NULL != g) {
-	DEBUG_ALLOC(mem_group, g);
 	g->next = cache.groups;
 	cache.groups = g;
-	g->path = strdup(path);
+	g->path = AGOO_STRDUP(path);
 	g->plen = (int)strlen(path);
-	DEBUG_ALLOC(mem_group_path, g->path);
 	g->dirs = NULL;
     }
     return g;
@@ -693,14 +679,12 @@ group_create(const char *path) {
 
 void
 group_add(agooGroup g, const char *dir) {
-    agooDir	d = (agooDir)malloc(sizeof(struct _agooDir));
+    agooDir	d = (agooDir)AGOO_MALLOC(sizeof(struct _agooDir));
 
     if (NULL != d) {
-	DEBUG_ALLOC(mem_dir, d);
 	d->next = g->dirs;
 	g->dirs = d;
-	d->path = strdup(dir);
+	d->path = AGOO_STRDUP(dir);
 	d->plen = (int)strlen(dir);
-	DEBUG_ALLOC(mem_dir_path, d->path);
     }
 }

data/ext/agoo/pub.c

@@ -12,10 +12,9 @@
 
 agooPub
 agoo_pub_close(agooUpgraded up) {
-    agooPub	p = (agooPub)malloc(sizeof(struct _agooPub));
+    agooPub	p = (agooPub)AGOO_MALLOC(sizeof(struct _agooPub));
 
     if (NULL != p) {
-	DEBUG_ALLOC(mem_pub, p);
 	p->next = NULL;
 	p->kind = AGOO_PUB_CLOSE;
 	p->up = up;
@@ -27,10 +26,9 @@ agoo_pub_close(agooUpgraded up) {
 
 agooPub
 agoo_pub_subscribe(agooUpgraded up, const char *subject, int slen) {
-    agooPub	p = (agooPub)malloc(sizeof(struct _agooPub));
+    agooPub	p = (agooPub)AGOO_MALLOC(sizeof(struct _agooPub));
 
     if (NULL != p) {
-	DEBUG_ALLOC(mem_pub, p);
 	p->next = NULL;
 	p->kind = AGOO_PUB_SUB;
 	p->up = up;
@@ -42,10 +40,9 @@ agoo_pub_subscribe(agooUpgraded up, const char *subject, int slen) {
 
 agooPub
 agoo_pub_unsubscribe(agooUpgraded up, const char *subject, int slen) {
-    agooPub	p = (agooPub)malloc(sizeof(struct _agooPub));
+    agooPub	p = (agooPub)AGOO_MALLOC(sizeof(struct _agooPub));
 
     if (NULL != p) {
-	DEBUG_ALLOC(mem_pub, p);
 	p->next = NULL;
 	p->kind = AGOO_PUB_UN;
 	p->up = up;
@@ -61,17 +58,16 @@ agoo_pub_unsubscribe(agooUpgraded up, const char *subject, int slen) {
 
 agooPub
 agoo_pub_publish(const char *subject, int slen, const char *message, size_t mlen) {
-    agooPub	p = (agooPub)malloc(sizeof(struct _agooPub));
+    agooPub	p = (agooPub)AGOO_MALLOC(sizeof(struct _agooPub));
 
     if (NULL != p) {
-	DEBUG_ALLOC(mem_pub, p);
 	p->next = NULL;
 	p->kind = AGOO_PUB_MSG;
 	p->up = NULL;
 	p->subject = agoo_subject_create(subject, slen);
-	// Allocate an extra 24 bytes so the message can be expanded in place
+	// Allocate an extra 32 bytes so the message can be expanded in place
 	// if a WebSocket or SSE write.
-	p->msg = agoo_text_append(agoo_text_allocate((int)mlen + 24), message, (int)mlen);
+	p->msg = agoo_text_append(agoo_text_allocate((int)mlen + 32), message, (int)mlen);
 	agoo_text_ref(p->msg);
     }
     return p;
@@ -81,17 +77,16 @@ 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.
-    agooPub	p = (agooPub)malloc(sizeof(struct _agooPub));
+    agooPub	p = (agooPub)AGOO_MALLOC(sizeof(struct _agooPub));
 
     if (NULL != p) {
-	DEBUG_ALLOC(mem_pub, p);
 	p->next = NULL;
 	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 = agoo_text_append(agoo_text_allocate((int)mlen + 16), message, (int)mlen);
+	// Allocate an extra 32 bytes so the message can be expanded in place
+	// if a WebSocket or SSE write.
+	p->msg = agoo_text_append(agoo_text_allocate((int)mlen + 32), message, (int)mlen);
 	p->msg->bin = bin;
 	agoo_text_ref(p->msg);
     }
@@ -100,16 +95,24 @@ agoo_pub_write(agooUpgraded up, const char *message, size_t mlen, bool bin) {
 
 agooPub
 agoo_pub_dup(agooPub src) {
-    agooPub	p = (agooPub)malloc(sizeof(struct _agooPub));
+    agooPub	p = (agooPub)AGOO_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 = agoo_subject_create(src->subject->pattern, strlen(src->subject->pattern));
+	if (NULL != p->up) {
+	    agoo_upgraded_ref(p->up);
+	}
+	if (NULL == src->subject) {
+	    p->subject = NULL;
+	} else {
+	    p->subject = agoo_subject_create(src->subject->pattern, strlen(src->subject->pattern));
+	}
 	p->msg = src->msg;
-	agoo_text_ref(p->msg);
+	if (NULL != p->msg) {
+	    agoo_text_ref(p->msg);
+	}
     }
     return p;
 }
@@ -125,7 +128,6 @@ agoo_pub_destroy(agooPub pub) {
     if (NULL != pub->up) {
 	agoo_upgraded_release(pub->up);
     }
-    DEBUG_FREE(mem_pub, pub);
-    free(pub);
+    AGOO_FREE(pub);
 }
 

data/ext/agoo/queue.c

@@ -36,8 +36,7 @@ agoo_queue_multi_init(agooQueue q, size_t qsize, bool multi_push, bool multi_pop
     if (qsize < 4) {
 	qsize = 4;
     }
-    q->q = (agooQItem*)malloc(sizeof(agooQItem) * qsize);
-    DEBUG_ALLOC(mem_qitem, q->q)
+    q->q = (agooQItem*)AGOO_MALLOC(sizeof(agooQItem) * qsize);
     q->end = q->q + qsize;
 
     memset(q->q, 0, sizeof(agooQItem) * qsize);
@@ -55,8 +54,7 @@ agoo_queue_multi_init(agooQueue q, size_t qsize, bool multi_push, bool multi_pop
 
 void
 agoo_queue_cleanup(agooQueue q) {
-    DEBUG_FREE(mem_qitem, q->q)
-    free(q->q);
+    AGOO_FREE(q->q);
     q->q = NULL;
     q->end = NULL;
     if (0 < q->wsock) {

data/ext/agoo/ready.c

@@ -13,6 +13,7 @@
 #include <poll.h>
 #endif
 
+#include "debug.h"
 #include "dtime.h"
 #include "log.h"
 #include "ready.h"
@@ -55,7 +56,7 @@ struct _agooReady {
 static Link
 link_create(agooErr err, int fd, void *ctx, agooHandler handler) {
     // TBD use block allocator
-    Link	link = (Link)malloc(sizeof(struct _link));
+    Link	link = (Link)AGOO_MALLOC(sizeof(struct _link));
 
     if (NULL == link) {
 	agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocate memory for a connection link.");
@@ -72,7 +73,7 @@ link_create(agooErr err, int fd, void *ctx, agooHandler handler) {
 
 agooReady
 agoo_ready_create(agooErr err) {
-    agooReady	ready = (agooReady)malloc(sizeof(struct _agooReady));
+    agooReady	ready = (agooReady)AGOO_MALLOC(sizeof(struct _agooReady));
 
     if (NULL == ready) {
 	agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocate memory for a connection manager.");
@@ -90,7 +91,7 @@ agoo_ready_create(agooErr err) {
 	{
 	    size_t	size = sizeof(struct pollfd) * INITIAL_POLL_SIZE;
 
-	    ready->pa = (struct pollfd*)malloc(size);
+	    ready->pa = (struct pollfd*)AGOO_MALLOC(size);
 	    ready->pend = ready->pa + INITIAL_POLL_SIZE;
 	    memset(ready->pa, 0, size);
 	}
@@ -108,14 +109,14 @@ agoo_ready_destroy(agooReady ready) {
 	if (NULL != link->handler->destroy) {
 	    link->handler->destroy(link->ctx);
 	}
-	free(link);
+	AGOO_FREE(link);
     }
 #if HAVE_SYS_EPOLL_H
     close(ready->epoll_fd);
 #else
-    free(ready->pa);
+    AGOO_FREE(ready->pa);
 #endif
-    free(ready);
+    AGOO_FREE(ready);
 }
 
 int
@@ -155,7 +156,7 @@ agoo_ready_add(agooErr		err,
 	size_t	cnt = (ready->pend - ready->pa) * 2;
 	size_t	size = cnt * sizeof(struct pollfd);
 	
-	if (NULL == (ready->pa = (struct pollfd*)realloc(ready->pa, size))) {
+	if (NULL == (ready->pa = (struct pollfd*)AGOO_REALLOC(ready->pa, size))) {
 	    agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocate memory for a connection pool.");
 	    agoo_log_cat(&agoo_error_cat, "Out of memory.");
 	    agoo_log_close();
@@ -196,8 +197,7 @@ ready_remove(agooReady ready, Link link) {
     if (NULL != link->handler->destroy) {
 	link->handler->destroy(link->ctx);
     }
-    //DEBUG_FREE(mem_???, c);
-    free(link);
+    AGOO_FREE(link);
     ready->lcnt--;
 }