agoo 1.2.2 → 2.0.0

data/ext/agoo/subscription.h

@@ -0,0 +1,18 @@
+// Copyright (c) 2018, Peter Ohler, All rights reserved.
+
+#ifndef __AGOO_SUBSCRIPTION_H__
+#define __AGOO_SUBSCRIPTION_H__
+
+#include <ruby.h>
+
+typedef struct _Subscription {
+    VALUE		self;
+    uint64_t		cid;
+    uint64_t		id;
+    VALUE		handler;
+} *Subscription;
+
+extern void	subscription_init(VALUE mod);
+extern VALUE	subscription_new(uint64_t cid, uint64_t id, VALUE handler);
+
+#endif // __AGOO_SUBSCRIPTION_H__

data/ext/agoo/text.c

@@ -12,9 +12,10 @@ text_create(const char *str, int len) {
     Text	t = (Text)malloc(sizeof(struct _Text) - TEXT_MIN_SIZE + len + 1);
 
     if (NULL != t) {
-	DEBUG_ALLOC(mem_text)
+	DEBUG_ALLOC(mem_text, t)
 	t->len = len;
 	t->alen = len;
+	t->bin = false;
 	atomic_init(&t->ref_cnt, 0);
 	memcpy(t->text, str, len);
 	t->text[len] = '\0';
@@ -27,9 +28,10 @@ text_allocate(int len) {
     Text	t = (Text)malloc(sizeof(struct _Text) - TEXT_MIN_SIZE + len + 1);
 
     if (NULL != t) {
-	DEBUG_ALLOC(mem_text)
+	DEBUG_ALLOC(mem_text, t)
 	t->len = 0;
 	t->alen = len;
+	t->bin = false;
 	atomic_init(&t->ref_cnt, 0);
 	*t->text = '\0';
     }
@@ -44,7 +46,7 @@ text_ref(Text t) {
 void
 text_release(Text t) {
     if (1 >= atomic_fetch_sub(&t->ref_cnt, 1)) {
-	DEBUG_FREE(mem_text)
+	DEBUG_FREE(mem_text, t)
 	free(t);
     }
 }
@@ -61,7 +63,6 @@ text_append(Text t, const char *s, int len) {
 	if (NULL == (t = (Text)realloc(t, size))) {
 	    return NULL;
 	}
-	DEBUG_ALLOC(mem_text)
 	t->alen = new_len;
     }
     memcpy(t->text + t->len, s, len);
@@ -70,3 +71,24 @@ text_append(Text t, const char *s, int len) {
 
     return t;
 }
+
+Text
+text_prepend(Text t, const char *s, int len) {
+    if (0 >= len) {
+	len = (int)strlen(s);
+    }
+    if (t->alen <= t->len + len) {
+	long	new_len = t->alen + t->alen / 2;
+	size_t	size = sizeof(struct _Text) - TEXT_MIN_SIZE + new_len + 1;
+
+	if (NULL == (t = (Text)realloc(t, size))) {
+	    return NULL;
+	}
+	t->alen = new_len;
+    }
+    memmove(t->text + len, t->text, t->len + 1);
+    memcpy(t->text, s, len);
+    t->len += len;
+
+    return t;
+}

data/ext/agoo/text.h

@@ -12,6 +12,7 @@ typedef struct _Text {
     long	len; // length of valid text
     long	alen; // size of allocated text
     atomic_int	ref_cnt;
+    bool	bin;
     char	text[TEXT_MIN_SIZE];
 } *Text;
 
@@ -20,5 +21,6 @@ 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);
 
 #endif /* __AGOO_TEXT_H__ */

data/ext/agoo/types.h

@@ -11,8 +11,21 @@ typedef enum {
     OPTIONS	= 'O',
     POST	= 'P',
     PUT		= 'U',
+    PATCH	= 'T',
     ALL		= 'A',
     NONE	= '\0',
+
+    ON_MSG	= 'M', // use for on_message callback
+    ON_BIN	= 'B', // use for on_message callback with binary (ASCII8BIT)
+    ON_CLOSE	= 'X', // use for on_close callback
+    ON_SHUTDOWN	= 'S', // use for on_shotdown callback
+    ON_EMPTY	= 'E', // use for on_drained callback
 } Method;
 
+typedef enum {
+    CON_HTTP	= 'H',
+    CON_WS	= 'W',
+    CON_SSE	= 'S',
+} ConKind;
+
 #endif // __AGOO_TYPES_H__

data/ext/agoo/upgraded.c

@@ -0,0 +1,148 @@
+// Copyright (c) 2018, Peter Ohler, All rights reserved.
+
+#include <stdio.h>
+
+#include <ruby/encoding.h>
+
+#include "pub.h"
+#include "server.h"
+#include "upgraded.h"
+
+static VALUE	upgraded_mod = Qundef;
+
+static ID	cid_id = 0;
+static ID	sid_id = 0;
+static ID	on_open_id = 0;
+static ID	to_s_id = 0;
+
+/* Document-method: write
+ *
+ * call-seq: write(msg)
+ *
+ * Writes a message to the WebSocket or SSe connection.
+ */
+static VALUE
+up_write(VALUE self, VALUE msg) {
+    uint64_t	cid = RB_FIX2ULONG(rb_ivar_get(self, cid_id));
+    Pub		p;
+
+    if (!the_server.active) {
+	rb_raise(rb_eIOError, "Server shutdown.");
+    }
+    if (0 < the_server.max_push_pending) {
+	int	pending = cc_get_pending(&the_server.con_cache, cid);
+
+	if (the_server.max_push_pending <= pending) {
+	    rb_raise(rb_eIOError, "Too many writes pending. Try again later.");
+	}
+    }
+    if (T_STRING == rb_type(msg)) {
+	if (RB_ENCODING_IS_ASCII8BIT(msg)) {
+	    p = pub_write(cid, StringValuePtr(msg), RSTRING_LEN(msg), true);
+	} else {
+	    p = pub_write(cid, StringValuePtr(msg), RSTRING_LEN(msg), false);
+	}
+    } else {
+	volatile VALUE	rs = rb_funcall(msg, to_s_id, 0);
+	
+	p = pub_write(cid, StringValuePtr(rs), RSTRING_LEN(rs), false);
+    }
+    cc_pending_inc(&the_server.con_cache, cid);
+    queue_push(&the_server.pub_queue, p);
+
+    return Qnil;
+}
+
+/* Document-method: subscribe
+ *
+ * call-seq: subscribe(subject)
+ *
+ * Subscribes to messages published on the specified subject. (not implemented
+ * yet)
+ */
+static VALUE
+up_subscribe(VALUE self, VALUE subject) {
+
+    // printf("*** subscribe called\n");
+
+    // increment _sid
+    // create subscription
+    // push pub onto server pub_queue
+    // TBD create subscription object and return it
+
+    return Qnil;
+}
+
+/* Document-method: close
+ *
+ * call-seq: close()
+ *
+ * Closes the connections associated with the handler.
+ */
+static VALUE
+up_close(VALUE self) {
+    uint64_t	cid = RB_FIX2ULONG(rb_ivar_get(self, cid_id));
+
+    if (!the_server.active) {
+	rb_raise(rb_eIOError, "Server shutdown.");
+    }
+    queue_push(&the_server.pub_queue, pub_close(cid));
+
+    return Qnil;
+}
+
+/* Document-method: pending
+ *
+ * call-seq: pending()
+ *
+ * Returns the number of pending WebSocket or SSE writes. If the connection is
+ * closed then -1 is returned.
+ */
+static VALUE
+pending(VALUE self) {
+    uint64_t	cid = RB_FIX2ULONG(rb_ivar_get(self, cid_id));
+
+    if (!the_server.active) {
+	rb_raise(rb_eIOError, "Server shutdown.");
+    }
+    return INT2NUM(cc_get_pending(&the_server.con_cache, cid));
+}
+
+void
+upgraded_extend(uint64_t cid, VALUE obj) {
+    if (!the_server.active) {
+	rb_raise(rb_eIOError, "Server shutdown.");
+    }
+    rb_ivar_set(obj, cid_id, ULONG2NUM(cid));
+    rb_ivar_set(obj, sid_id, ULONG2NUM(0)); // used as counter for subscription id
+    rb_extend_object(obj, upgraded_mod);
+    if (rb_respond_to(obj, on_open_id)) {
+	rb_funcall(obj, on_open_id, 0);
+    }
+    cc_set_handler(&the_server.con_cache, cid, obj,
+		   rb_respond_to(obj, rb_intern("on_drained")),
+		   rb_respond_to(obj, rb_intern("on_close")),
+		   rb_respond_to(obj, rb_intern("on_shutdown")),
+		   rb_respond_to(obj, rb_intern("on_message")));
+    rb_funcall(obj, rb_intern("to_s"), 0);
+}
+
+/* Document-module: Agoo::Upgraded
+ *
+ * Adds methods to a handler of WebSocket and SSe connections.
+ */
+void
+upgraded_init(VALUE mod) {
+    upgraded_mod = rb_define_module_under(mod, "Upgraded");
+
+    rb_define_method(upgraded_mod, "write", up_write, 1);
+    rb_define_method(upgraded_mod, "subscribe", up_subscribe, 1);
+    rb_define_method(upgraded_mod, "close", up_close, 0);
+    rb_define_method(upgraded_mod, "pending", pending, 0);
+
+    cid_id = rb_intern("_cid");
+    sid_id = rb_intern("_sid");
+    on_open_id = rb_intern("on_open");
+    to_s_id = rb_intern("to_s");
+    
+}

data/ext/agoo/upgraded.h

@@ -0,0 +1,13 @@
+// Copyright (c) 2018, Peter Ohler, All rights reserved.
+
+#ifndef __AGOO_UPGRADED_H__
+#define __AGOO_UPGRADED_H__
+
+#include <stdint.h>
+
+#include <ruby.h>
+
+extern void	upgraded_init(VALUE mod);
+extern void	upgraded_extend(uint64_t cid, VALUE obj);
+
+#endif // __AGOO_UPGRADED_H__

data/ext/agoo/websocket.c

@@ -0,0 +1,248 @@
+// Copyright (c) 2018, Peter Ohler, All rights reserved.
+
+#include <stdint.h>
+
+#include "base64.h"
+#include "con.h"
+#include "debug.h"
+#include "request.h"
+#include "sha1.h"
+#include "text.h"
+#include "websocket.h"
+
+#define MAX_KEY_LEN	1024
+
+static const char	up_con[] = "Upgrade: websocket\r\nConnection: Upgrade\r\n";
+static const char	ws_magic[] = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+static const char	ws_protocol[] = "Sec-WebSocket-Protocol: ";
+static const char	ws_accept[] = "Sec-WebSocket-Accept: ";
+
+//static const uint8_t	close_msg[] = "\x88\x02\x03\xE8";
+
+Text
+ws_add_headers(Req req, Text t) {
+    int		klen = 0;
+    const char	*key;
+    
+    t = text_append(t, up_con, sizeof(up_con) - 1);
+    if (NULL != (key = con_header_value(req->header.start, req->header.len, "Sec-WebSocket-Key", &klen)) &&
+	klen + sizeof(ws_magic) < MAX_KEY_LEN) {
+	char		buf[MAX_KEY_LEN];
+	unsigned char	sha[32];
+	int		len = klen + sizeof(ws_magic) - 1;
+
+	strncpy(buf, key, klen);
+	strcpy(buf + klen, ws_magic);
+	sha1((unsigned char*)buf, len, sha);
+	len = b64_to(sha, SHA1_DIGEST_SIZE, buf);
+
+	t = text_append(t, ws_accept, sizeof(ws_accept) - 1);
+	t = text_append(t, buf, len);
+	t = text_append(t, "\r\n", 2);
+    }
+    if (NULL != (key = con_header_value(req->header.start, req->header.len, "Sec-WebSocket-Protocol", &klen))) {
+	t = text_append(t, ws_protocol, sizeof(ws_protocol) - 1);
+	t = text_append(t, key, klen);
+	t = text_append(t, "\r\n", 2);
+    }
+    return t;
+}
+
+Text
+ws_expand(Text t) {
+    uint8_t	buf[16];
+    uint8_t	*b = buf;
+    uint8_t	opcode = t->bin ? WS_OP_BIN : WS_OP_TEXT;
+
+    *b++ = 0x80 | (uint8_t)opcode;
+    // send unmasked
+    if (125 >= t->len) {
+	*b++ = (uint8_t)t->len;
+    } else if (0xFFFF >= t->len) {
+	*b++ = (uint8_t)0x7E;
+	*b++ = (uint8_t)((t->len >> 8) & 0xFF);
+	*b++ = (uint8_t)(t->len & 0xFF);
+    } else {
+	int	i;
+
+	*b++ = (uint8_t)0x7F;
+	for (i = 56; 0 <= i; i -= 8) {
+	    *b++ = (uint8_t)((t->len >> i) & 0xFF);
+	}
+    }
+    return text_prepend(t, (const char*)buf, (int)(b - buf));
+}
+
+size_t
+ws_decode(char *buf, size_t mlen) {
+    uint8_t	*b = (uint8_t*)buf;
+    bool	is_masked;
+    uint8_t	*payload;
+    uint64_t	plen;
+    
+    b++; // op
+    is_masked = 0x80 & *b;
+    plen = 0x7F & *b;
+    b++;
+    if (126 == plen) {
+	plen = *b++;
+	plen = (plen << 8) | *b++;
+    } else if (127 == plen) {
+	plen = *b++;
+	plen = (plen << 8) | *b++;
+	plen = (plen << 8) | *b++;
+	plen = (plen << 8) | *b++;
+	plen = (plen << 8) | *b++;
+	plen = (plen << 8) | *b++;
+	plen = (plen << 8) | *b++;
+	plen = (plen << 8) | *b++;
+    }
+    if (is_masked) {
+	uint8_t		mask[4];
+	uint64_t	i;
+	
+	for (i = 0; i < 4; i++, b++) {
+	    mask[i] = *b;
+	}
+	payload = b;
+	for (i = 0; i < plen; i++, b++) {
+	    *b = *b ^ mask[i % 4];
+	}
+    } else {
+	payload = b;
+	b += plen;
+    }
+    memmove(buf, payload, plen);
+    buf[plen] = '\0';
+
+    return plen;
+}
+
+// if -1 then err, 0 not ready yet, positive is completed length
+long
+ws_calc_len(Con c, uint8_t *buf, size_t cnt) {
+    uint8_t	*b = buf;
+    bool	is_masked;
+    uint64_t	plen;
+
+    if (0 == (0x80 & *b)) {
+	log_cat(&error_cat, "FIN must be 1. Websocket continuation not implemented on connection %llu.", c->id);
+	return -1;
+    }
+    b++;
+    is_masked = 0x80 & *b;
+    plen = 0x7F & *b;
+    if (cnt < 3) {
+	return 0; // not read yet
+    }
+    b++;
+    if (126 == plen) {
+	if (cnt < 5) {
+	    return 0; // not read yet
+	}
+	plen = *b++;
+	plen = (plen << 8) | *b++;
+    } else if (127 == plen) {
+	if (c->bcnt < 11) {
+	    return 0; // not read yet
+	}
+	plen = *b++;
+	plen = (plen << 8) | *b++;
+	plen = (plen << 8) | *b++;
+	plen = (plen << 8) | *b++;
+	plen = (plen << 8) | *b++;
+	plen = (plen << 8) | *b++;
+	plen = (plen << 8) | *b++;
+	plen = (plen << 8) | *b++;
+    }
+    return (long)(b - buf) + (is_masked ? 4 : 0) + plen;
+}
+
+// Return true on error otherwise false.
+bool
+ws_create_req(Con c, long mlen) {
+    uint8_t	op = 0x0F & *c->buf;
+    
+    if (NULL == (c->req = request_create(mlen))) {
+	log_cat(&error_cat, "Out of memory attempting to allocate request.");
+	return true;
+    }
+    if (NULL == c->slot || Qnil == c->slot->handler) {
+	return true;
+    }
+    memset(c->req, 0, sizeof(struct _Req));
+    if ((long)c->bcnt <= mlen) {
+	memcpy(c->req->msg, c->buf, c->bcnt);
+	if ((long)c->bcnt < mlen) {
+	    memset(c->req->msg + c->bcnt, 0, mlen - c->bcnt);
+	}
+    } else {
+	memcpy(c->req->msg, c->buf, mlen);
+    }
+    c->req->msg[mlen] = '\0';
+    c->req->mlen = mlen;
+    c->req->method = (WS_OP_BIN == op) ? ON_BIN : ON_MSG;
+    c->req->upgrade = UP_NONE;
+    c->req->cid = c->id;
+    c->req->res = NULL;
+    c->req->handler_type = PUSH_HOOK;
+    if (c->slot->on_msg) {
+	c->req->handler = c->slot->handler;
+    } else {
+	c->req->handler = Qnil;
+    }
+    return false;
+}
+
+void
+ws_req_close(Con c) {
+    if (NULL != c->slot && Qnil != c->slot->handler && c->slot->on_close) {
+	Req	req = request_create(0);
+	    
+	req->cid = c->id;
+	req->method = ON_CLOSE;
+	req->handler_type = PUSH_HOOK;
+	req->handler = c->slot->handler;
+	queue_push(&the_server.eval_queue, (void*)req);
+    }
+}
+
+void
+ws_ping(Con c) {
+    Res	res;
+    
+    if (NULL == (res = res_create())) {
+	log_cat(&error_cat, "Memory allocation of response failed on connection %llu.", c->id);
+    } else {
+	DEBUG_ALLOC(mem_res, res)
+	if (NULL == c->res_tail) {
+	    c->res_head = res;
+	} else {
+	    c->res_tail->next = res;
+	}
+	c->res_tail = res;
+	res->close = false;
+	res->con_kind = CON_WS;
+	res->ping = true;
+    }
+}
+
+void
+ws_pong(Con c) {
+    Res	res;
+    
+    if (NULL == (res = res_create())) {
+	log_cat(&error_cat, "Memory allocation of response failed on connection %llu.", c->id);
+    } else {
+	DEBUG_ALLOC(mem_res, res)
+	if (NULL == c->res_tail) {
+	    c->res_head = res;
+	} else {
+	    c->res_tail->next = res;
+	}
+	c->res_tail = res;
+	res->close = false;
+	res->con_kind = CON_WS;
+	res->pong = true;
+    }
+}