agoo 2.6.1 → 2.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3c6f7a71837a6983af279098f2d4fb7af4beadc4848c50667981056d383520d4
-  data.tar.gz: 81bce77599f27879083117b4607f9c4ebb7dd1ab751027659ab0ec76ced69c2c
+  metadata.gz: 8a78c4278726e4fc90aad77fa83029fdfa2cbdf84d72796947ae5c22d30165e1
+  data.tar.gz: 8a3eb7eca852c6811270b7a6697a94184675e231f88f7c35848431b8495c166b
 SHA512:
-  metadata.gz: aa1625c81786ebbb3a4b787cc4508a21c122cc387fdc60024d696657b4581f42724e97bf450034d7611cbc2cf02342b93d2de725721a586da01f0af4e2f4d1d3
-  data.tar.gz: 6d8363f8a41c875294f67c955e066c9ca770225ee735c3b8a2bf4dbf1fd6cd1b407655ef6f5ddd5306a722407ca76ba36b5c2d6cd8e2d41bbe81dae3df2ff7aa
+  metadata.gz: bc450f5bd00d4f256ddd31ccd29ad0075093403e41ff9d1bde7f3924796a32600ac9b6032452989f56b84303b44ee4f5663adce6d09eb3908cc2eef38b337f5e
+  data.tar.gz: a66662a930ec96e99ac91a15981add0ea63a484df8d0e488e6915e2f4ca7c55cb939c5775f0619e64dea87f2a9b2fdd6d311bcc31338d72693bc230c45b8fbdc

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # CHANGELOG
 
+### 2.7.0 - 2019-01-29
+
+Static asset header rules functionality added.
+
+- `Agoo::Server.header_rule()` added.
+
+- Assorted code cleanup.
+
 ### 2.6.1 - 2019-01-20
 
 Ruby 2.6.0 compatibility release.

data/ext/agoo/agoo.c

@@ -90,7 +90,6 @@ sig_handler(int sig) {
     exit(0);
 }
 
-
 /* Document-module: Agoo
  *
  * A High Performance HTTP Server that supports the Ruby rack API. The word
@@ -116,4 +115,9 @@ Init_agoo() {
     signal(SIGINT, sig_handler);
     signal(SIGTERM, sig_handler);
     signal(SIGPIPE, SIG_IGN);
+
+    // This causes sleeps and queue pops to return immediately and is can be
+    // called all the time on mac OS with multiple threads. Something seems to
+    // get stuck.
+    signal(SIGVTALRM, SIG_IGN);
 }

data/ext/agoo/bind.c

@@ -15,18 +15,18 @@
 
 agooBind
 agoo_bind_port(agooErr err, int port) {
-    agooBind	b = (agooBind)AGOO_MALLOC(sizeof(struct _agooBind));
+    agooBind	b = (agooBind)AGOO_CALLOC(1, sizeof(struct _agooBind));
 
     if (NULL != b) {
 	char	id[1024];
 	
-	memset(b, 0, sizeof(struct _agooBind));
 	b->port = port;
 	b->family = AF_INET;
 	snprintf(id, sizeof(id) - 1, "http://:%d", port);
 	strcpy(b->scheme, "http");
 	if (NULL == (b->id = AGOO_STRDUP(id))) {
-	    agoo_err_set(err, AGOO_ERR_MEMORY, "strdup of bind id failed.");
+	    AGOO_ERR_MEM(err, "strdup()");
+	    AGOO_FREE(b);
 	    return NULL;
 	}
 	b->kind = AGOO_CON_HTTP;
@@ -62,17 +62,16 @@ url_tcp(agooErr err, const char *url, const char *scheme) {
 	}
 	port = atoi(colon + 1);
     }
-    if (NULL != (b = (agooBind)AGOO_MALLOC(sizeof(struct _agooBind)))) {
+    if (NULL != (b = (agooBind)AGOO_CALLOC(1, sizeof(struct _agooBind)))) {
 	char	id[64];
-	
-	memset(b, 0, sizeof(struct _agooBind));
 
 	b->port = port;
 	b->addr4 = addr;
 	b->family = AF_INET;
 	snprintf(id, sizeof(id), "%s://%s:%d", scheme, inet_ntoa(addr), port);
 	if (NULL == (b->id = AGOO_STRDUP(id))) {
-	    agoo_err_set(err, AGOO_ERR_MEMORY, "strdup of bind id failed.");
+	    AGOO_ERR_MEM(err, "strdup()");
+	    AGOO_FREE(b);
 	    return NULL;
 	}
 	strncpy(b->scheme, scheme, sizeof(b->scheme));
@@ -84,7 +83,7 @@ url_tcp(agooErr err, const char *url, const char *scheme) {
 
 	return b;
     }
-    agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocate memory for a Bind.");
+    AGOO_ERR_MEM(err, "Bind");
     
     return b;
 }
@@ -107,17 +106,16 @@ url_tcp6(agooErr err, const char *url, const char *scheme) {
 	agoo_err_set(err, AGOO_ERR_ARG, "%s bind address is not valid. (%s)", scheme, url);
 	return NULL;
     }
-    if (NULL != (b = (agooBind)AGOO_MALLOC(sizeof(struct _agooBind)))) {
+    if (NULL != (b = (agooBind)AGOO_CALLOC(1, sizeof(struct _agooBind)))) {
 	char	str[INET6_ADDRSTRLEN + 1];
-	
-	memset(b, 0, sizeof(struct _agooBind));
 
 	b->port = port;
 	b->addr6 = addr;
 	b->family = AF_INET6;
 	snprintf(buf, sizeof(buf), "%s://[%s]:%d", scheme, inet_ntop(AF_INET6, &addr, str, INET6_ADDRSTRLEN), port);
 	if (NULL == (b->id = AGOO_STRDUP(buf))) {
-	    agoo_err_set(err, AGOO_ERR_MEMORY, "strdup of bind id failed.");
+	    AGOO_ERR_MEM(err, "strdup()");
+	    AGOO_FREE(b);
 	    return NULL;
 	}	    
 	strncpy(b->scheme, scheme, sizeof(b->scheme));
@@ -129,7 +127,7 @@ url_tcp6(agooErr err, const char *url, const char *scheme) {
 
 	return b;
     }
-    agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocate memory for a Bind.");
+    AGOO_ERR_MEM(err, "Bind");
     
     return b;
 }
@@ -140,20 +138,21 @@ url_named(agooErr err, const char *url) {
 	agoo_err_set(err, AGOO_ERR_ARG, "Named Unix sockets names must not be empty.");
 	return NULL;
     } else {
-	agooBind	b = (agooBind)AGOO_MALLOC(sizeof(struct _agooBind));
+	agooBind	b = (agooBind)AGOO_CALLOC(1, sizeof(struct _agooBind));
 
 	if (NULL != b) {
 	    const char	*fmt = "unix://%s";
 	    char	id[1024];
 	
-	    memset(b, 0, sizeof(struct _agooBind));
 	    if (NULL == (b->name = AGOO_STRDUP(url))) {
-		agoo_err_set(err, AGOO_ERR_MEMORY, "strdup of bind url failed.");
+		AGOO_ERR_MEM(err, "strdup()");
+		AGOO_FREE(b);
 		return NULL;
 	    }
 	    snprintf(id, sizeof(id) - 1, fmt, url);
 	    if (NULL == (b->id = AGOO_STRDUP(id))) {
-		agoo_err_set(err, AGOO_ERR_MEMORY, "strdup of bind id failed.");
+		AGOO_ERR_MEM(err, "strdup()");
+		AGOO_FREE(b);
 		return NULL;
 	    }
 	    strcpy(b->scheme, "unix");
@@ -164,7 +163,7 @@ url_named(agooErr err, const char *url) {
 	}
 	return b;
     }
-    agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocate memory for a Bind.");
+    AGOO_ERR_MEM(err, "Bind");
 
     return NULL;
 }

data/ext/agoo/con.c

@@ -58,10 +58,9 @@ agooCon
 agoo_con_create(agooErr err, int sock, uint64_t id, agooBind b) {
     agooCon	c;
 
-    if (NULL == (c = (agooCon)AGOO_MALLOC(sizeof(struct _agooCon)))) {
-	agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocate memory for a connection.");
+    if (NULL == (c = (agooCon)AGOO_CALLOC(1, sizeof(struct _agooCon)))) {
+	AGOO_ERR_MEM(err, "Connection");
     } else {
-	memset(c, 0, sizeof(struct _agooCon));
 	c->sock = sock;
 	c->id = id;
 	c->timeout = dtime() + CON_TIMEOUT;
@@ -89,6 +88,7 @@ agoo_con_destroy(agooCon c) {
     }
     if (NULL != c->up) {
 	agoo_upgraded_release_con(c->up);
+	
 	c->up = NULL;
     }
     agoo_log_cat(&agoo_con_cat, "Connection %llu closed.", (unsigned long long)c->id);
@@ -955,7 +955,7 @@ process_pub_con(agooPub pub, agooConLoop loop) {
     default:
 	break;
     }
-    agoo_pub_destroy(pub);	
+    agoo_pub_destroy(pub);
 }
 
 short
@@ -1212,20 +1212,27 @@ agoo_conloop_create(agooErr err, int id) {
      agooConLoop	loop;
 
     if (NULL == (loop = (agooConLoop)AGOO_MALLOC(sizeof(struct _agooConLoop)))) {
-	agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocate memory for a connection thread.");
+	AGOO_ERR_MEM(err, "connection thread");
     } else {
 	int	stat;
 	
 	loop->next = NULL;
-	agoo_queue_multi_init(&loop->pub_queue, 256, true, false);
+	if (AGOO_ERR_OK != agoo_queue_multi_init(err, &loop->pub_queue, 256, true, false)) {
+	    AGOO_FREE(loop);
+	    return NULL;
+	}
 	loop->id = id;
 	loop->res_head = NULL;
 	loop->res_tail = NULL;
+	if (0 != pthread_mutex_init(&loop->lock, 0)) {
+	    AGOO_FREE(loop);
+	    agoo_err_no(err, "Failed to initialize loop mutex.");
+	    return NULL;
+	}
 	if (0 != (stat = pthread_create(&loop->thread, NULL, agoo_con_loop, loop))) {
 	    agoo_err_set(err, stat, "Failed to create connection loop. %s", strerror(stat));
 	    return NULL;
 	}
-	pthread_mutex_init(&loop->lock, 0);
     }
     return loop;
 }

data/ext/agoo/debug.c

@@ -34,54 +34,92 @@ static const char	mem_pad[] = "--- This is a memory pad and should not change un
 void
 agoo_alloc(const void *ptr, size_t size, const char *file, int line) {
     Rec		r = (Rec)malloc(sizeof(struct _rec));
-    
-    r->ptr = ptr;
-    r->size = size;
-    r->file = file;
-    r->line = line;
-    pthread_mutex_lock(&lock);
-    r->next = recs;
-    recs = r;
-    pthread_mutex_unlock(&lock);
+
+    if (NULL != r) {
+	r->ptr = ptr;
+	r->size = size;
+	r->file = file;
+	r->line = line;
+	pthread_mutex_lock(&lock);
+	r->next = recs;
+	recs = r;
+	pthread_mutex_unlock(&lock);
+    }
 }
 
 void*
 agoo_malloc(size_t size, const char *file, int line) {
     void	*ptr = malloc(size + sizeof(mem_pad));
-    Rec		r = (Rec)malloc(sizeof(struct _rec));
-
-    strcpy(((char*)ptr) + size, mem_pad);
-    r->ptr = ptr;
-    r->size = size;
-    r->file = file;
-    r->line = line;
-    pthread_mutex_lock(&lock);
-    r->next = recs;
-    recs = r;
-    pthread_mutex_unlock(&lock);
 
+    if (NULL != ptr) {
+	Rec	r = (Rec)malloc(sizeof(struct _rec));
+	
+	if (NULL != r) {
+	    strcpy(((char*)ptr) + size, mem_pad);
+	    r->ptr = ptr;
+	    r->size = size;
+	    r->file = file;
+	    r->line = line;
+	    pthread_mutex_lock(&lock);
+	    r->next = recs;
+	    recs = r;
+	    pthread_mutex_unlock(&lock);
+	} else {
+	    free(ptr);
+	    ptr = NULL;
+	}
+    }
     return ptr;
 }
 
 void*
-agoo_realloc(void *orig, size_t size, const char *file, int line) {
-    void	*ptr = realloc(orig, size + sizeof(mem_pad));
-    Rec		r;
-    
-    strcpy(((char*)ptr) + size, mem_pad);
-    pthread_mutex_lock(&lock);
-    for (r = recs; NULL != r; r = r->next) {
-	if (orig == r->ptr) {
+agoo_calloc(size_t count, size_t size, const char *file, int line) {
+    void	*ptr;
+
+    size *= count;
+    if (NULL != (ptr = malloc(size + sizeof(mem_pad)))) {
+	Rec	r = (Rec)malloc(sizeof(struct _rec));
+	
+	if (NULL != r) {
+	    memset(ptr, 0, size);
+	    strcpy(((char*)ptr) + size, mem_pad);
 	    r->ptr = ptr;
 	    r->size = size;
 	    r->file = file;
 	    r->line = line;
-	    break;
+	    pthread_mutex_lock(&lock);
+	    r->next = recs;
+	    recs = r;
+	    pthread_mutex_unlock(&lock);
+	} else {
+	    free(ptr);
+	    ptr = NULL;
 	}
     }
-    pthread_mutex_unlock(&lock);
-    if (NULL == r) {
-	printf("Realloc at %s:%d (%p) not allocated.\n", file, line, orig);
+    return ptr;
+}
+
+void*
+agoo_realloc(void *orig, size_t size, const char *file, int line) {
+    void	*ptr = realloc(orig, size + sizeof(mem_pad));
+    Rec		r;
+    
+    if (NULL != ptr) {
+	strcpy(((char*)ptr) + size, mem_pad);
+	pthread_mutex_lock(&lock);
+	for (r = recs; NULL != r; r = r->next) {
+	    if (orig == r->ptr) {
+		r->ptr = ptr;
+		r->size = size;
+		r->file = file;
+		r->line = line;
+		break;
+	    }
+	}
+	pthread_mutex_unlock(&lock);
+	if (NULL == r) {
+	    printf("Realloc at %s:%d (%p) not allocated.\n", file, line, orig);
+	}
     }
     return ptr;
 }
@@ -90,19 +128,26 @@ char*
 agoo_strdup(const char *str, const char *file, int line) {
     size_t	size = strlen(str) + 1;
     char	*ptr = (char*)malloc(size + sizeof(mem_pad));
-    Rec		r = (Rec)malloc(sizeof(struct _rec));
-
-    strcpy(ptr, str);
-    strcpy(((char*)ptr) + size, mem_pad);
-    r->ptr = (void*)ptr;
-    r->size = size;
-    r->file = file;
-    r->line = line;
-    pthread_mutex_lock(&lock);
-    r->next = recs;
-    recs = r;
-    pthread_mutex_unlock(&lock);
 
+    if (NULL != ptr) {
+	Rec	r = (Rec)malloc(sizeof(struct _rec));
+	
+	if (NULL != r) {
+	    strcpy(ptr, str);
+	    strcpy(((char*)ptr) + size, mem_pad);
+	    r->ptr = (void*)ptr;
+	    r->size = size;
+	    r->file = file;
+	    r->line = line;
+	    pthread_mutex_lock(&lock);
+	    r->next = recs;
+	    recs = r;
+	    pthread_mutex_unlock(&lock);
+	} else {
+	    free(ptr);
+	    ptr = NULL;
+	}
+    }
     return ptr;
 }
 
@@ -110,20 +155,27 @@ char*
 agoo_strndup(const char *str, size_t len, const char *file, int line) {
     size_t	size = len + 1;
     char	*ptr = (char*)malloc(size + sizeof(mem_pad));
-    Rec		r = (Rec)malloc(sizeof(struct _rec));
-
-    memcpy(ptr, str, len);
-    ptr[len] = '\0';
-    strcpy(((char*)ptr) + size, mem_pad);
-    r->ptr = (void*)ptr;
-    r->size = size;
-    r->file = file;
-    r->line = line;
-    pthread_mutex_lock(&lock);
-    r->next = recs;
-    recs = r;
-    pthread_mutex_unlock(&lock);
 
+    if (NULL != ptr) {
+	Rec	r = (Rec)malloc(sizeof(struct _rec));
+	
+	if (NULL != r) {
+	    memcpy(ptr, str, len);
+	    ptr[len] = '\0';
+	    strcpy(((char*)ptr) + size, mem_pad);
+	    r->ptr = (void*)ptr;
+	    r->size = size;
+	    r->file = file;
+	    r->line = line;
+	    pthread_mutex_lock(&lock);
+	    r->next = recs;
+	    recs = r;
+	    pthread_mutex_unlock(&lock);
+	} else {
+	    free(ptr);
+	    ptr = NULL;
+	}
+    }
     return ptr;
 }
 
@@ -207,10 +259,8 @@ agoo_freed(void *ptr, const char *file, int line) {
 
 void
 agoo_free(void *ptr, const char *file, int line) {
-    if (NULL != ptr) {
-	agoo_freed(ptr, file, line);
-	free(ptr);
-    }
+    agoo_freed(ptr, file, line);
+    free(ptr);
 }
 
 #endif
@@ -228,8 +278,8 @@ update_reps(Rep reps, Rec r) {
 	    break;
 	}
     }
-    if (NULL == rp) {
-	rp = (Rep)malloc(sizeof(struct _rep));
+    if (NULL == rp &&
+	NULL != (rp = (Rep)malloc(sizeof(struct _rep)))) {
 	rp->size = r->size;
 	rp->file = r->file;
 	rp->line = r->line;

data/ext/agoo/debug.h

@@ -8,6 +8,7 @@
 #ifdef MEM_DEBUG
 
 #define AGOO_MALLOC(size) agoo_malloc(size, __FILE__, __LINE__)
+#define AGOO_CALLOC(count, size) agoo_calloc(count, size, __FILE__, __LINE__)
 #define AGOO_ALLOC(ptr, size) agoo_alloc(ptr, size, __FILE__, __LINE__)
 #define AGOO_REALLOC(ptr, size) agoo_realloc(ptr, size, __FILE__, __LINE__)
 #define AGOO_STRDUP(str) agoo_strdup(str, __FILE__, __LINE__)
@@ -18,6 +19,7 @@
 #define AGOO_MEM_CHECK(ptr) agoo_mem_check(ptr, __FILE__, __LINE__)
 
 extern void*	agoo_malloc(size_t size, const char *file, int line);
+extern void*	agoo_calloc(size_t count, size_t size, const char *file, int line);
 extern void*	agoo_realloc(void *ptr, size_t size, const char *file, int line);
 extern char*	agoo_strdup(const char *str, const char *file, int line);
 extern char*	agoo_strndup(const char *str, size_t len, const char *file, int line);
@@ -29,6 +31,7 @@ extern void	agoo_mem_check(void *ptr, const char *file, int line);
 #else
 
 #define AGOO_MALLOC(size) malloc(size)
+#define AGOO_CALLOC(count, size) calloc(count, size)
 #define AGOO_ALLOC(ptr, size) {}
 #define AGOO_REALLOC(ptr, size) realloc(ptr, size)
 #define AGOO_STRDUP(str) strdup(str)