agoo 2.4.0 → 2.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4b76a004b8311f4a6966175ff830f0f38babc63efddde69c39a7b4ccc3d90b4a
-  data.tar.gz: 3356bf438fb1ebdcf6aa9c2d22c3536e5f5fe7c23cd909962effc965d269fc7d
+  metadata.gz: 47d1801dcc95720dc1d86eca4a6e22d44ded5c3c4581493fb8026c9d3ff015d1
+  data.tar.gz: 473dfe0c24f99063efbb328ce857ef8ed77894c347445e2450cced56a5136a3f
 SHA512:
-  metadata.gz: 200da7c5f41b3822cdcb68a0ddd79e7c66a976e33da33245eafa9a66907166be3144874c889c98ac6891a0f2c46746019fcdf100e18df8f6d4a3884355dc7986
-  data.tar.gz: 1753cd691ec0bd0443a5a2d6e7af894ca56d705a9e6c3ebe645f4be7ae2156784bc94b4d3dcf6ecb17a5a4003831991120ebb19cade82435fb0599cf71d605e0
+  metadata.gz: ff2c2178fd44c3f752154835defc23568f37637730d53729f69fe31ab5d89233d4eeabe89f059825b333f4e314e6f25dfffbd0618a4b2006fddc90d11c3be8c4
+  data.tar.gz: 7c556c7fff8bd8f23e6f06332106d2b84b90e7df08b4129fa5fbe6452bc252dd5db90557dc079bd20368e552ad7161844f05ee5f98035d116c0cb8d54e1b0182

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # CHANGELOG
 
+### 2.5.0 - 2018-08-10
+
+The binding release with multiple options for connecting to the server.
+
+- Multiple connection bindings now supported
+
+- Binding to Unix named sockets support added.
+
+- IPv6 now supported.
+
+- Connection address now supported to restrict connection requests.
+
 ### 2.4.0 - 2018-07-04
 
 - Rack hijack now supported.

data/ext/agoo/agoo.c

@@ -12,12 +12,13 @@
 #include "request.h"
 #include "response.h"
 #include "rlog.h"
+#include "rserver.h"
 #include "server.h"
 #include "upgraded.h"
 
 void
 agoo_shutdown() {
-    server_shutdown();
+    rserver_shutdown(Qnil);
     log_close();
 }
 
@@ -47,7 +48,7 @@ ragoo_publish(VALUE self, VALUE subject, VALUE message) {
     const char	*subj = extract_subject(subject, &slen);
 
     rb_check_type(message, T_STRING);
-    queue_push(&the_server.pub_queue, pub_publish(subj, slen, StringValuePtr(message), (int)RSTRING_LEN(message)));
+    queue_push(&the_rserver.pub_queue, pub_publish(subj, slen, StringValuePtr(message), (int)RSTRING_LEN(message)));
 
     return Qnil;
 }
@@ -64,7 +65,7 @@ static VALUE
 ragoo_unsubscribe(VALUE self, VALUE subject) {
     rb_check_type(subject, T_STRING);
 
-    queue_push(&the_server.pub_queue, pub_unsubscribe(NULL, StringValuePtr(subject), (int)RSTRING_LEN(subject)));
+    queue_push(&the_rserver.pub_queue, pub_unsubscribe(NULL, StringValuePtr(subject), (int)RSTRING_LEN(subject)));
 
     return Qnil;
 }

data/ext/agoo/bind.c

@@ -0,0 +1,275 @@
+// Copyright (c) 2018, Peter Ohler, All rights reserved.
+
+#include <netdb.h>
+#include <netinet/tcp.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <sys/un.h>
+#include <unistd.h>
+
+#include "bind.h"
+#include "debug.h"
+#include "log.h"
+
+Bind
+bind_port(Err err, int port) {
+    Bind	b = (Bind)malloc(sizeof(struct _Bind));
+
+    if (NULL != b) {
+	char	id[1024];
+	
+	DEBUG_ALLOC(mem_bind, b);
+	memset(b, 0, sizeof(struct _Bind));
+	b->port = port;
+	b->family = AF_INET;
+	snprintf(id, sizeof(id) - 1, "http://:%d", port);
+	b->id = strdup(id);
+    }
+    return b;
+}
+
+static Bind
+url_tcp(Err err, const char *url) {
+    char		*colon = index(url, ':');
+    struct in_addr	addr = { .s_addr = 0 };
+    int			port;
+    Bind		b;
+    
+    if (NULL == colon) {
+	port = 80;
+    } else if (15 < colon - url) {
+	err_set(err, ERR_ARG, "tcp/http bind address is not valid. (%s)", url);
+	return NULL;
+    } else {
+	char	buf[32];
+
+	strncpy(buf, url, colon - url);
+	buf[colon - url] = '\0';
+	if (0 == inet_aton(buf, &addr)) {
+	    err_set(err, ERR_ARG, "tcp/http bind address is not valid. (%s)", url);
+	    return NULL;
+	}
+	port = atoi(colon + 1);
+    }
+    if (NULL != (b = (Bind)malloc(sizeof(struct _Bind)))) {
+	char	id[64];
+	
+	DEBUG_ALLOC(mem_bind, b);
+	memset(b, 0, sizeof(struct _Bind));
+
+	b->port = port;
+	b->addr4 = addr;
+	b->family = AF_INET;
+	snprintf(id, sizeof(id), "http://%s:%d", inet_ntoa(addr), port);
+	b->id = strdup(id);
+
+	return b;
+    }
+    err_set(err, ERR_MEMORY, "Failed to allocate memory for a Bind.");
+    
+    return b;
+}
+
+static Bind
+url_tcp6(Err err, const char *url) {
+    struct in6_addr	addr;
+    char		*end = index(url, ']');
+    int			port = 80;
+    char		buf[256];
+    Bind		b;
+    
+    if (':' == *(end + 1)) {
+	port = atoi(end + 2);
+    }
+    memcpy(buf, url + 1, end - url - 1);
+    buf[end - url - 1] = '\0';
+    memset(&addr, 0, sizeof(addr));
+    if (0 == inet_pton(AF_INET6, buf, &addr)) {
+	err_set(err, ERR_ARG, "tcp/http bind address is not valid. (%s)", url);
+	return NULL;
+    }
+    if (NULL != (b = (Bind)malloc(sizeof(struct _Bind)))) {
+	char	str[INET6_ADDRSTRLEN + 1];
+	
+	DEBUG_ALLOC(mem_bind, b);
+	memset(b, 0, sizeof(struct _Bind));
+
+	b->port = port;
+	b->addr6 = addr;
+	b->family = AF_INET6;
+	snprintf(buf, sizeof(buf), "http://[%s]:%d", inet_ntop(AF_INET6, &addr, str, INET6_ADDRSTRLEN), port);
+	b->id = strdup(buf);
+
+	return b;
+    }
+    err_set(err, ERR_MEMORY, "Failed to allocate memory for a Bind.");
+    
+    return b;
+}
+
+static Bind
+url_named(Err err, const char *url) {
+    if ('\0' == *url) {
+	err_set(err, ERR_ARG, "Named Unix sockets names must not be empty.");
+	return NULL;
+    } else {
+	Bind	b = (Bind)malloc(sizeof(struct _Bind));
+
+	if (NULL != b) {
+	    const char	*fmt = "unix://%s";
+	    char	id[1024];
+	
+	    DEBUG_ALLOC(mem_bind, b);
+	    memset(b, 0, sizeof(struct _Bind));
+	    b->name = strdup(url);
+	    snprintf(id, sizeof(id) - 1, fmt, url);
+	    b->id = strdup(id);
+	}
+	return b;
+    }
+    err_set(err, ERR_MEMORY, "Failed to allocate memory for a Bind.");
+
+    return NULL;
+}
+
+static Bind
+url_ssl(Err err, const char *url) {
+    // TBD
+    return NULL;
+}
+
+Bind
+bind_url(Err err, const char *url) {
+    if (0 == strncmp("tcp://", url, 6)) {
+	if ('[' == url[6]) {
+	    return url_tcp6(err, url + 6);
+	}
+	return url_tcp(err, url + 6);
+    }
+    if (0 == strncmp("http://", url, 7)) {
+	if ('[' == url[7]) {
+	    return url_tcp6(err, url + 7);
+	}
+	return url_tcp(err, url + 7);
+    }
+    if (0 == strncmp("unix://", url, 7)) {
+	return url_named(err, url + 7);
+    }
+    if (0 == strncmp("https://", url, 8)) {
+	return url_ssl(err, url + 8);
+    }
+    if (0 == strncmp("ssl://", url, 6)) {
+	return url_ssl(err, url + 6);
+    }
+    return NULL;
+}
+
+void
+bind_destroy(Bind b) {
+    DEBUG_FREE(mem_bind, b);
+    free(b->id);
+    free(b->name);
+    free(b->key);
+    free(b->cert);
+    free(b->ca);
+    free(b);
+}
+
+static int
+usual_listen(Err err, Bind b) {
+    int		optval = 1;
+    int	domain = PF_INET;
+
+    if (AF_INET6 == b->family) {
+	domain = PF_INET6;
+    }
+    if (0 >= (b->fd = socket(domain, SOCK_STREAM, IPPROTO_TCP))) {
+	log_cat(&error_cat, "Server failed to open server socket on port %d. %s.", b->port, strerror(errno));
+
+	return err_set(err, errno, "Server failed to open server socket. %s.", strerror(errno));
+    }
+#ifdef OSX_OS 
+    setsockopt(b->fd, SOL_SOCKET, SO_NOSIGPIPE, &optval, sizeof(optval));
+#endif    
+    setsockopt(b->fd, SOL_SOCKET, SO_REUSEPORT, &optval, sizeof(optval));
+    setsockopt(b->fd, IPPROTO_TCP, TCP_NODELAY, &optval, sizeof(optval));
+    if (AF_INET6 == b->family) {
+	struct sockaddr_in6	addr;
+
+	memset(&addr, 0, sizeof(addr));
+	addr.sin6_flowinfo = 0;
+	addr.sin6_family = b->family;
+	addr.sin6_addr = b->addr6;
+	addr.sin6_port = htons(b->port);
+	if (0 > bind(b->fd, (struct sockaddr*)&addr, sizeof(addr))) {
+	    log_cat(&error_cat, "Server failed to bind server socket. %s.", strerror(errno));
+
+	    return err_set(err, errno, "Server failed to bind server socket. %s.", strerror(errno));
+	}
+    } else {
+	struct sockaddr_in	addr;
+
+	memset(&addr, 0, sizeof(addr));
+	addr.sin_family = b->family;
+	addr.sin_addr = b->addr4;
+	addr.sin_port = htons(b->port);
+	if (0 > bind(b->fd, (struct sockaddr*)&addr, sizeof(addr))) {
+	    log_cat(&error_cat, "Server failed to bind server socket. %s.", strerror(errno));
+
+	    return err_set(err, errno, "Server failed to bind server socket. %s.", strerror(errno));
+	}
+    }
+    listen(b->fd, 1000);
+
+    return ERR_OK;
+}
+
+static int
+named_listen(Err err, Bind b) {
+    struct sockaddr_un	addr;
+
+    remove(b->name);
+    if (0 >= (b->fd = socket(AF_UNIX, SOCK_STREAM, 0))) {
+	log_cat(&error_cat, "Server failed to open server socket on %s. %s.", b->name, strerror(errno));
+
+	return err_set(err, errno, "Server failed to open server socket on %s. %s.", b->name, strerror(errno));
+    }
+    memset(&addr, 0, sizeof(addr));
+    addr.sun_family = AF_UNIX;
+    strcpy(addr.sun_path, b->name);
+    if (0 > bind(b->fd, (struct sockaddr*)&addr, sizeof(addr))) {
+	log_cat(&error_cat, "Server failed to bind server socket. %s.", strerror(errno));
+
+	return err_set(err, errno, "Server failed to bind server socket. %s.", strerror(errno));
+    }
+    listen(b->fd, 100);
+
+    return ERR_OK;
+}
+
+static int
+ssl_listen(Err err, Bind b) {
+    // TBD
+    return ERR_OK;
+}
+
+int
+bind_listen(Err err, Bind b) {
+    if (NULL != b->name) {
+	return named_listen(err, b);
+    }
+    if (NULL != b->key) {
+	return ssl_listen(err, b);
+    }
+    return usual_listen(err, b);
+}
+
+void
+bind_close(Bind b) {
+    if (0 != b->fd) {
+	close(b->fd);
+	b->fd = 0;
+    }
+}

data/ext/agoo/bind.h

@@ -0,0 +1,35 @@
+// Copyright (c) 2018, Peter Ohler, All rights reserved.
+
+#ifndef __AGOO_BIND_H__
+#define __AGOO_BIND_H__
+
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+#include "err.h"
+
+typedef struct _Bind {
+    struct _Bind	*next;
+    int			fd;
+    int			port;
+    sa_family_t		family;
+    union {
+	struct in_addr	addr4;
+	struct in6_addr	addr6;
+    };
+    char		*name; // if set then Unix file
+    char		*key;  // if set then SSL
+    char		*cert;
+    char		*ca;
+    char		*id;
+} *Bind;
+
+extern Bind	bind_url(Err err, const char *url);
+extern Bind	bind_port(Err err, int port);
+extern void	bind_destroy(Bind b);
+
+extern int	bind_listen(Err err, Bind b);
+extern void	bind_close(Bind b);
+
+#endif // __AGOO_BIND_H__

data/ext/agoo/con.c

@@ -10,9 +10,11 @@
 #include "dtime.h"
 #include "hook.h"
 #include "http.h"
+#include "page.h"
 #include "pub.h"
 #include "res.h"
 #include "seg.h"
+#include "rserver.h"
 #include "server.h"
 #include "sse.h"
 #include "subject.h"
@@ -152,6 +154,7 @@ page_response(Con c, Page p, char *hend) {
     return false;
 }
 
+// rserver
 static void
 push_error(Upgraded up, const char *msg, int mlen) {
     if (NULL != up && Qnil != up->handler && up->on_error) {
@@ -164,10 +167,9 @@ push_error(Upgraded up, const char *msg, int mlen) {
 	req->msg[mlen] = '\0';
 	req->up = up;
 	req->method = ON_ERROR;
-	req->handler_type = PUSH_HOOK;
-	req->handler = up->handler;
+	req->hook = hook_create(NONE, NULL, (void*)up->handler, PUSH_HOOK, &the_rserver.eval_queue);
 	upgraded_ref(up);
-	queue_push(&the_server.eval_queue, (void*)req);
+	queue_push(&the_rserver.eval_queue, (void*)req);
     }
 }
 
@@ -288,14 +290,14 @@ con_header_read(Con c) {
     }
     mlen = hend - c->buf + 4 + clen;
     if (GET == method &&
-	NULL != (p = group_get(&err, &the_server.pages, path.start, (int)(path.end - path.start)))) {
+	NULL != (p = group_get(&err, path.start, (int)(path.end - path.start)))) {
 	if (page_response(c, p, hend)) {
 	    return bad_request(c, 500, __LINE__);
 	}
 	return -mlen;
     }
     if (GET == method && the_server.root_first &&
-	NULL != (p = page_get(&err, &the_server.pages, path.start, (int)(path.end - path.start)))) {
+	NULL != (p = page_get(&err, path.start, (int)(path.end - path.start)))) {
 	if (page_response(c, p, hend)) {
 	    return bad_request(c, 500, __LINE__);
 	}
@@ -312,7 +314,7 @@ con_header_read(Con c) {
 		}
 		return bad_request(c, 404, __LINE__);
 	    }
-	    if (NULL == (p = page_get(&err, &the_server.pages, path.start, (int)(path.end - path.start)))) {
+	    if (NULL == (p = page_get(&err, path.start, (int)(path.end - path.start)))) {
 		if (NULL != the_server.hook404) {
 		    // There would be too many parameters to pass to a
 		    // separate function so just goto the hook processing.
@@ -354,13 +356,8 @@ HOOKED:
     c->req->header.start = c->req->msg + (b + 2 - c->buf);
     c->req->header.len = (unsigned int)(hend - b - 2);
     c->req->res = NULL;
-    if (NULL != hook) {
-	c->req->handler = (VALUE)hook->handler;
-	c->req->handler_type = hook->type;
-    } else {
-	c->req->handler = Qnil;
-	c->req->handler_type = NO_HOOK;
-    }
+    c->req->hook = hook;
+
     return mlen;
 }
 
@@ -368,7 +365,7 @@ static void
 check_upgrade(Con c) {
     const char	*v;
     int		vlen = 0;
-    
+
     if (NULL == c->req) {
 	return;
     }
@@ -470,7 +467,7 @@ con_http_read(Con c) {
 		check_upgrade(c);
 		req = c->req;
 		c->req = NULL;
-		queue_push(&the_server.eval_queue, (void*)req);
+		queue_push(req->hook->queue, (void*)req);
 		if (mlen < (long)c->bcnt) {
 		    memmove(c->buf, c->buf + mlen, c->bcnt - mlen);
 		    c->bcnt -= mlen;
@@ -508,6 +505,7 @@ con_ws_read(Con c) {
 	    } else {
 		char	msg[1024];
 		int	len = snprintf(msg, sizeof(msg) - 1, "Failed to read WebSocket message. %s.", strerror(errno));
+
 		push_error(c->up, msg, len);
 		log_cat(&warn_cat, "Failed to read WebSocket message. %s.", strerror(errno));
 	    }
@@ -571,7 +569,7 @@ con_ws_read(Con c) {
 		}
 	    }
 	    upgraded_ref(c->up);
-	    queue_push(&the_server.eval_queue, (void*)c->req);
+	    queue_push(&the_rserver.eval_queue, (void*)c->req);
 	    if (mlen < (long)c->bcnt) {
 		memmove(c->buf, c->buf + mlen, c->bcnt - mlen);
 		c->bcnt -= mlen;
@@ -851,7 +849,7 @@ publish_pub(Pub pub) {
     const char	*sub = pub->subject->pattern;
     int	cnt = 0;
     
-    for (up = the_server.up_list; NULL != up; up = up->next) {
+    for (up = the_rserver.up_list; NULL != up; up = up->next) {
 	if (NULL != up->con && upgraded_match(up, sub)) {
 	    Res	res = res_create(up->con);
 
@@ -875,7 +873,7 @@ unsubscribe_pub(Pub pub) {
     if (NULL == pub->up) {
 	Upgraded	up;
 
-	for (up = the_server.up_list; NULL != up; up = up->next) {
+	for (up = the_rserver.up_list; NULL != up; up = up->next) {
 	    upgraded_del_subject(up, pub->subject);
 	}
     } else {
@@ -897,10 +895,9 @@ process_pub_con(Pub pub) {
 	    
 		req->up = up;
 		req->method = ON_EMPTY;
-		req->handler_type = PUSH_HOOK;
-		req->handler = up->handler;
+		req->hook = hook_create(NONE, NULL, (void*)up->handler, PUSH_HOOK, &the_rserver.eval_queue);
 		upgraded_ref(up);
-		queue_push(&the_server.eval_queue, (void*)req);
+		queue_push(&the_rserver.eval_queue, (void*)req);
 	    }
 	}
     }
@@ -967,7 +964,7 @@ poll_setup(Con c, struct pollfd *pp) {
     pp->events = POLLIN;
     pp->revents = 0;
     pp++;
-    pp->fd = queue_listen(&the_server.pub_queue);
+    pp->fd = queue_listen(&the_rserver.pub_queue);
     pp->events = POLLIN;
     pp->revents = 0;
     pp++;
@@ -1063,7 +1060,7 @@ con_loop(void *x) {
 		pend = pa + cnt;
 	    }
 	}
-	while (NULL != (pub = (Pub)queue_pop(&the_server.pub_queue, 0.0))) {
+	while (NULL != (pub = (Pub)queue_pop(&the_rserver.pub_queue, 0.0))) {
 	    process_pub_con(pub);
 	}
 	
@@ -1101,8 +1098,8 @@ con_loop(void *x) {
 	    }
 	    // Check pub_queue if an event is waiting.
 	    if (0 != (pa[1].revents & POLLIN)) {
-		queue_release(&the_server.pub_queue);
-		while (NULL != (pub = (Pub)queue_pop(&the_server.pub_queue, 0.0))) {
+		queue_release(&the_rserver.pub_queue);
+		while (NULL != (pub = (Pub)queue_pop(&the_rserver.pub_queue, 0.0))) {
 		    process_pub_con(pub);
 		}
 	    }