agoo 2.8.4 → 2.9.0

data/ext/agoo/domain.h

@@ -0,0 +1,16 @@
+// Copyright 2019 by Peter Ohler, All Rights Reserved
+
+#ifndef AGOO_DOMAIN_H
+#define AGOO_DOMAIN_H
+
+#include <stdbool.h>
+
+#include "err.h"
+
+extern bool		agoo_domain_use();
+extern int		agoo_domain_add(agooErr err, const char *host, const char *path);
+extern int		agoo_domain_add_regex(agooErr err, const char *host, const char *path);
+extern const char*	agoo_domain_resolve(const char *host, char *buf, size_t blen);
+extern void		agoo_domain_cleanup();
+
+#endif // AGOO_DOMAIN_H

data/ext/agoo/early.c

@@ -0,0 +1,28 @@
+// Copyright (c) 2019, Peter Ohler, All rights reserved.
+
+#include "debug.h"
+#include "early.h"
+
+agooEarly
+agoo_early_create(const char *link) {
+    agooEarly	early = (agooEarly)AGOO_CALLOC(1, sizeof(struct _agooEarly));
+
+    if (NULL != early) {
+	if (NULL == (early->link = AGOO_STRDUP(link))) {
+	    AGOO_FREE(early);
+	    return NULL;
+	}
+    }
+    return early;
+}
+
+void
+agoo_early_destroy(agooEarly early) {
+    if (NULL != early) {
+	if (NULL != early->next) {
+	    agoo_early_destroy(early->next);
+	}
+	AGOO_FREE(early->link);
+	AGOO_FREE(early);
+    }
+}

data/ext/agoo/early.h

@@ -0,0 +1,23 @@
+// Copyright (c) 2019, Peter Ohler, All rights reserved.
+
+#ifndef AGOO_EARLY_H
+#define AGOO_EARLY_H
+
+#include <stdbool.h>
+
+#include "atomic.h"
+#include "con.h"
+#include "text.h"
+
+struct _agooCon;
+
+typedef struct _agooEarly {
+    struct _agooEarly	*next;
+    bool		sent;
+    char		*link;
+} *agooEarly;
+
+extern agooEarly	agoo_early_create(const char *link);
+extern void		agoo_early_destroy(agooEarly early);
+
+#endif // AGOO_EARLY_H

data/ext/agoo/early_hints.c

@@ -0,0 +1,116 @@
+// Copyright (c) 2019, Peter Ohler, All rights reserved.
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+
+#include "debug.h"
+#include "early.h"
+#include "early_hints.h"
+#include "req.h"
+#include "res.h"
+
+static VALUE	eh_class = Qundef;
+
+typedef struct _earlyHints {
+    agooReq	req;
+    agooEarly	links;
+} *EarlyHints;
+
+static void
+eh_free(void *ptr) {
+    if (NULL != ptr) {
+	AGOO_FREE(ptr);
+    }
+}
+
+VALUE
+agoo_early_hints_new(agooReq req) {
+    EarlyHints	eh = (EarlyHints)AGOO_CALLOC(1, sizeof(struct _earlyHints));
+
+    if (NULL == eh) {
+	rb_raise(rb_eNoMemError, "Failed to allocate memory for an early hints object.");
+    }
+    eh->req = req;
+
+    return Data_Wrap_Struct(eh_class, NULL, eh_free, eh);
+}
+
+/* Document-method: call
+ *
+ * call-seq: call(links)
+ *
+ * Write early hints, response with status 103 using the provided headers in
+ * an Array of Array.
+ *
+ * Example:
+ *
+ *    early_hints.call([
+ *                      ["link", "</style.css>; rel=preload; as=style"],
+ *                      ["link", "</script.js>; rel=preload; as=script"],
+ *                     ])
+ */
+static VALUE
+eh_call(VALUE self, VALUE links) {
+    EarlyHints	eh = (EarlyHints)DATA_PTR(self);
+    agooEarly	link;
+    agooEarly	ll = NULL;
+    int		i, cnt;
+    VALUE	lv;
+    VALUE	v;
+    const char	*key;
+    const char	*content;
+
+    if (NULL == eh) {
+	rb_raise(rb_eIOError, "early hints has been closed.");
+    }
+    rb_check_type(links, RUBY_T_ARRAY);
+
+    // Link: </style.css>; rel=preload; as=style
+    cnt = (int)RARRAY_LEN(links);
+    for (i = cnt - 1; 0 <= i; i--) {
+	lv = rb_ary_entry(links, i);
+	switch (rb_type(lv)) {
+	case RUBY_T_STRING:
+	    content = rb_string_value_ptr((VALUE*)&v);
+	    if (NULL == (link = agoo_early_create(content))) {
+		rb_raise(rb_eNoMemError, "out of memory");
+	    }
+	    break;
+	case RUBY_T_ARRAY:
+	    if (2 != RARRAY_LEN(lv)) {
+		rb_raise(rb_eArgError, "early hints call argument must be an array of arrays that have 2 string members.");
+	    }
+	    v = rb_ary_entry(lv, 0);
+	    key = rb_string_value_ptr((VALUE*)&v);
+	    if (0 != strcasecmp("link", key)) {
+		rb_raise(rb_eArgError, "Only a 'Link' header is allowed in early hints. '%s' is not allowed", key);
+	    }
+	    v = rb_ary_entry(lv, 1);
+	    content = rb_string_value_ptr((VALUE*)&v);
+	    if (NULL == (link = agoo_early_create(content))) {
+		rb_raise(rb_eNoMemError, "out of memory");
+	    }
+	    break;
+	default:
+	    rb_raise(rb_eArgError, "early hints call argument must be an array of arrays or an array of strings.");
+	}
+	link->next = ll;
+	ll = link;
+    }
+    agoo_res_add_early(eh->req->res, ll);
+    agoo_early_destroy(ll);
+
+    return Qnil;
+}
+
+/* Document-class: Agoo::EarlyHints
+ *
+ * Used to provide early hints (HTTP 103) responses to requests.
+ */
+void
+early_hints_init(VALUE mod) {
+    eh_class = rb_define_class_under(mod, "EarlyHints", rb_cObject);
+
+    rb_define_method(eh_class, "call", eh_call, 1);
+}

data/ext/agoo/early_hints.h

@@ -0,0 +1,13 @@
+// Copyright (c) 2019, Peter Ohler, All rights reserved.
+
+#ifndef AGOO_EARLY_HINTS_H
+#define AGOO_EARLY_HINTS_H
+
+#include <ruby.h>
+
+struct _agooReq;
+
+extern void	early_hints_init(VALUE mod);
+extern VALUE	agoo_early_hints_new(struct _agooReq *req);
+
+#endif // AGOO_EARLY_HINTS_H

data/ext/agoo/gqleval.c

@@ -54,7 +54,7 @@ err_resp(agooRes res, agooErr err, int status) {
 		   code,
 		   at.year, at.mon, at.day, at.hour, at.min, at.sec, frac);
 
-    agoo_res_set_message(res, agoo_text_create(buf, cnt));
+    agoo_res_message_push(res, agoo_text_create(buf, cnt), true);
 }
 
 static void
@@ -84,7 +84,7 @@ value_resp(agooRes res, gqlValue result, int status, int indent) {
     if (NULL == (text = agoo_text_prepend(text, buf, cnt))) {
 	agoo_log_cat(&agoo_error_cat, "Failed to allocate memory for a response.");
     }
-    agoo_res_set_message(res, text);
+    agoo_res_message_push(res, text, true);
 }
 
 gqlValue

data/ext/agoo/graphql.c

@@ -1647,7 +1647,7 @@ gql_dump_hook(agooReq req) {
     if (NULL == (text = agoo_text_prepend(text, buf, cnt))) {
 	agoo_log_cat(&agoo_error_cat, "Failed to allocate memory for a GraphQL dump.");
     }
-    agoo_res_set_message(req->res, text);
+    agoo_res_message_push(req->res, text, true);
 }
 
 gqlField

data/ext/agoo/page.c

@@ -48,6 +48,7 @@ typedef struct _mimeSlot {
 
 typedef struct _cache {
     Slot		buckets[PAGE_BUCKET_SIZE];
+    Slot		ruckets[PAGE_BUCKET_SIZE];
     MimeSlot		muckets[MIME_BUCKET_SIZE];
     char		*root;
     agooGroup		groups;
@@ -112,6 +113,7 @@ static const char	page_min_fmt[] = "HTTP/1.1 200 OK\r\nContent-Length: %ld\r\n";
 
 static struct _cache	cache = {
     .buckets = {0},
+    .ruckets = {0},
     .muckets = {0},
     .root = NULL,
     .groups = NULL,
@@ -150,6 +152,11 @@ get_bucketp(uint64_t h) {
     return cache.buckets + (PAGE_BUCKET_MASK & (h ^ (h << 5) ^ (h >> 7)));
 }
 
+static Slot*
+get_rucketp(uint64_t h) {
+    return cache.ruckets + (PAGE_BUCKET_MASK & (h ^ (h << 5) ^ (h >> 7)));
+}
+
 static MimeSlot*
 get_mime_bucketp(uint64_t h) {
     return cache.muckets + (MIME_BUCKET_MASK & (h ^ (h << 5) ^ (h >> 7)));
@@ -192,6 +199,24 @@ cache_get(const char *key, int klen) {
     return v;
 }
 
+agooPage
+cache_root_get(const char *key, int klen) {
+    int		len = klen;
+    int64_t	h = calc_hash(key, &len);
+    Slot	*bucket = get_rucketp(h);
+    Slot	s;
+    agooPage	v = NULL;
+
+    for (s = *bucket; NULL != s; s = s->next) {
+	if (h == (int64_t)s->hash && len == (int)s->klen &&
+	    ((0 <= len && len <= MAX_KEY_UNIQ) || 0 == strncmp(s->key, key, klen))) {
+	    v = s->value;
+	    break;
+	}
+    }
+    return v;
+}
+
 int
 mime_set(agooErr err, const char *key, const char *value) {
     int		klen = (int)strlen(key);
@@ -199,7 +224,7 @@ mime_set(agooErr err, const char *key, const char *value) {
     int64_t	h = calc_hash(key, &len);
     MimeSlot	*bucket = get_mime_bucketp(h);
     MimeSlot	s;
-    
+
     if (MAX_MIME_KEY_LEN < len) {
 	return agoo_err_set(err, AGOO_ERR_ARG, "%s is too long for a file extension. Maximum is %d", key, MAX_MIME_KEY_LEN);
     }
@@ -235,19 +260,16 @@ mime_set(agooErr err, const char *key, const char *value) {
 }
 
 static agooPage
-cache_set(const char *key, int klen, agooPage value) {
-    int		len = klen;
-    int64_t	h = calc_hash(key, &len);
-    Slot	*bucket = get_bucketp(h);
+bucket_set(Slot *bucket, int64_t h, const char *key, int klen, agooPage value) {
     Slot	s;
     agooPage	old = NULL;
-    
-    if (MAX_KEY_LEN < len) {
+
+    if (MAX_KEY_LEN < klen) {
 	return value;
     }
     for (s = *bucket; NULL != s; s = s->next) {
-	if (h == (int64_t)s->hash && len == s->klen &&
-	    ((0 <= len && len <= MAX_KEY_UNIQ) || 0 == strncmp(s->key, key, len))) {
+	if (h == (int64_t)s->hash && klen == s->klen &&
+	    ((0 <= klen && klen <= MAX_KEY_UNIQ) || 0 == strncmp(s->key, key, klen))) {
 
 	    old = s->value;
 	    // replace
@@ -260,12 +282,12 @@ cache_set(const char *key, int klen, agooPage value) {
 	return value;
     }
     s->hash = h;
-    s->klen = len;
+    s->klen = klen;
     if (NULL == key) {
 	*s->key = '\0';
     } else {
-	strncpy(s->key, key, len);
-	s->key[len] = '\0';
+	strncpy(s->key, key, klen);
+	s->key[klen] = '\0';
     }
     s->value = value;
     s->next = *bucket;
@@ -274,10 +296,28 @@ cache_set(const char *key, int klen, agooPage value) {
     return old;
 }
 
+static agooPage
+cache_set(const char *key, int klen, agooPage value) {
+    int		len = klen;
+    int64_t	h = calc_hash(key, &len);
+    Slot	*bucket = get_bucketp(h);
+
+    return bucket_set(bucket, h, key, len, value);
+}
+
+static agooPage
+cache_root_set(const char *key, int klen, agooPage value) {
+    int		len = klen;
+    int64_t	h = calc_hash(key, &len);
+    Slot	*bucket = get_rucketp(h);
+
+    return bucket_set(bucket, h, key, len, value);
+}
+
 int
 agoo_pages_init(agooErr err) {
     Mime	m;
-    
+
     memset(&cache, 0, sizeof(struct _cache));
     if (NULL == (cache.root = AGOO_STRDUP("."))) {
 	return agoo_err_set(err, AGOO_ERR_ARG, "out of memory allocating root path");
@@ -330,6 +370,14 @@ agoo_pages_cleanup() {
 	}
 	*sp = NULL;
     }
+    for (sp = cache.ruckets, i = PAGE_BUCKET_SIZE; 0 < i; i--, sp++) {
+	for (s = *sp; NULL != s; s = n) {
+	    n = s->next;
+	    agoo_page_destroy(s->value);
+	    AGOO_FREE(s);
+	}
+	*sp = NULL;
+    }
     for (i = MIME_BUCKET_SIZE; 0 < i; i--, mp++) {
 	for (sm = *mp; NULL != sm; sm = m) {
 	    m = sm->next;
@@ -461,10 +509,10 @@ agoo_page_immutable(agooErr err, const char *path, const char *content, int clen
     int		plen = 0;
     long	hlen = 0;
     HeadRule	hr;
-    
+
     if (NULL == p) {
 	AGOO_ERR_MEM(err, "Page");
-	return NULL;     
+	return NULL;
     }
     if (NULL == path) {
 	p->path = NULL;
@@ -476,7 +524,7 @@ agoo_page_immutable(agooErr err, const char *path, const char *content, int clen
 	plen = (int)strlen(path);
 	if (NULL != cache.root) {
 	    int	rlen = strlen(cache.root);
-	
+
 	    if (0 == strncmp(cache.root, p->path, rlen) && '/' == p->path[rlen]) {
 		rel_path = p->path + rlen + 1;
 	    } else {
@@ -509,7 +557,7 @@ agoo_page_immutable(agooErr err, const char *path, const char *content, int clen
     }
     if (0 < hlen) {
 	bool	has_ct;
-	
+
 	cnt = sprintf(p->resp->text, page_min_fmt, (long)clen); // HTTP/1.1 200 OK\r\nContent-Length: %ld\r\n
 	for (hr = cache.head_rules; NULL != hr; hr = hr->next) {
 	    if (head_rule_match(hr, rel_path, mime)) {
@@ -610,7 +658,7 @@ update_contents(agooPage p) {
 
     if (NULL != cache.root) {
 	int	rlen = strlen(cache.root);
-	
+
 	if (0 == strncmp(cache.root, path, rlen) && '/' == path[rlen]) {
 	    rel_path = path + rlen + 1;
 	}
@@ -628,7 +676,7 @@ update_contents(agooPage p) {
     }
     if (0 < hlen) {
 	bool	has_ct = false;
-	
+
 	cnt = sprintf(t->text, page_min_fmt, size); // HTTP/1.1 200 OK\r\nContent-Length: %ld\r\n
 	for (hr = cache.head_rules; NULL != hr; hr = hr->next) {
 	    if (head_rule_match(hr, rel_path, mime)) {
@@ -722,48 +770,87 @@ page_check(agooErr err, agooPage page) {
 }
 
 agooPage
-agoo_page_get(agooErr err, const char *path, int plen) {
-    agooPage	page;
+agoo_page_get(agooErr err, const char *path, int plen, const char *root) {
+    agooPage	page = NULL;
 
     if (NULL != strstr(path, "../")) {
 	return NULL;
     }
-    if (NULL == (page = cache_get(path, plen))) {
-	if (NULL != cache.root) {
-	    agooPage	old;
-	    char	full_path[2048];
-	    char	*s = stpcpy(full_path, cache.root);
+    if (NULL != root) {
+	char	full_path[2048];
+	char	*s = stpcpy(full_path, root);
 
-	    if ('/' != *cache.root && '/' != *path) {
-		*s++ = '/';
-	    }
-	    if ((int)sizeof(full_path) <= plen + (s - full_path)) {
-		AGOO_ERR_MEM(err, "Page path");
-		return NULL;
-	    }
-	    strncpy(s, path, plen);
-	    s[plen] = '\0';
-	    if (NULL == (page = agoo_page_create(full_path))) {
-		AGOO_ERR_MEM(err, "Page");
-		return NULL;
-	    }
-	    if (!update_contents(page) || NULL == page->resp) {
-		agoo_page_destroy(page);
-		agoo_err_set(err, AGOO_ERR_NOT_FOUND, "not found.");
-		return NULL;
-	    }
-	    if (NULL != (old = cache_set(path, plen, page))) {
-		agoo_page_destroy(old);
+	if (NULL != strstr(path, "../")) {
+	    return NULL;
+	}
+	if ((int)sizeof(full_path) <= plen + (s - full_path)) {
+	    AGOO_ERR_MEM(err, "Page path");
+	    return NULL;
+	}
+	if ('/' != *root && '/' != *(s - 1) && '/' != *path) {
+	    *s++ = '/';
+	}
+	strncpy(s, path, plen);
+	s[plen] = '\0';
+
+	if (NULL == (page = cache_root_get(full_path, plen))) {
+	    if (NULL != cache.root) {
+		agooPage	old;
+
+		if (NULL == (page = agoo_page_create(full_path))) {
+		    AGOO_ERR_MEM(err, "Page");
+		    return NULL;
+		}
+		if (!update_contents(page) || NULL == page->resp) {
+		    agoo_page_destroy(page);
+		    agoo_err_set(err, AGOO_ERR_NOT_FOUND, "not found.");
+		    return NULL;
+		}
+		if (NULL != (old = cache_root_set(full_path, plen, page))) {
+		    agoo_page_destroy(old);
+		}
 	    }
+	} else {
+	    page = page_check(err, page);
 	}
     } else {
-	page = page_check(err, page);
+	if (NULL == (page = cache_get(path, plen))) {
+	    if (NULL != cache.root) {
+		agooPage	old;
+		char	full_path[2048];
+		char	*s = stpcpy(full_path, cache.root);
+
+		if ('/' != *cache.root && '/' != *path) {
+		    *s++ = '/';
+		}
+		if ((int)sizeof(full_path) <= plen + (s - full_path)) {
+		    AGOO_ERR_MEM(err, "Page path");
+		    return NULL;
+		}
+		strncpy(s, path, plen);
+		s[plen] = '\0';
+		if (NULL == (page = agoo_page_create(full_path))) {
+		    AGOO_ERR_MEM(err, "Page");
+		    return NULL;
+		}
+		if (!update_contents(page) || NULL == page->resp) {
+		    agoo_page_destroy(page);
+		    agoo_err_set(err, AGOO_ERR_NOT_FOUND, "not found.");
+		    return NULL;
+		}
+		if (NULL != (old = cache_set(path, plen, page))) {
+		    agoo_page_destroy(old);
+		}
+	    }
+	} else {
+	    page = page_check(err, page);
+	}
     }
     return page;
 }
 
 agooPage
-group_get(agooErr err, const char *path, int plen) {
+agoo_group_get(agooErr err, const char *path, int plen) {
     agooPage	page = NULL;
     agooGroup	g = NULL;
     char	full_path[2048];
@@ -833,7 +920,7 @@ group_get(agooErr err, const char *path, int plen) {
 }
 
 agooGroup
-group_create(const char *path) {
+agoo_group_create(const char *path) {
     agooGroup	g = (agooGroup)AGOO_MALLOC(sizeof(struct _agooGroup));
 
     if (NULL != g) {
@@ -850,7 +937,7 @@ group_create(const char *path) {
 }
 
 agooDir
-group_add(agooErr err, agooGroup g, const char *dir) {
+agoo_group_add(agooErr err, agooGroup g, const char *dir) {
     agooDir	d = (agooDir)AGOO_MALLOC(sizeof(struct _agooDir));
 
     if (NULL != d) {
@@ -877,7 +964,7 @@ agoo_header_rule(agooErr err, const char *path, const char *mime, const char *ke
     }
     if (NULL == (hr->path = AGOO_STRDUP(path)) ||
 	NULL == (hr->key = AGOO_STRDUP(key)) ||
-	NULL == (hr->value = AGOO_STRDUP(value))) {	
+	NULL == (hr->value = AGOO_STRDUP(value))) {
 	goto ERROR;
     }
     if ('*' == *mime && '\0' == mime[1]) {
@@ -888,7 +975,7 @@ agoo_header_rule(agooErr err, const char *path, const char *mime, const char *ke
     hr->len = strlen(hr->key) + strlen(hr->value) + 4;
     hr->next = cache.head_rules;
     cache.head_rules = hr;
-    
+
     return AGOO_ERR_OK;
 
 ERROR: