agoo 2.5.1 → 2.5.2

data/ext/agoo/log.h

@@ -58,11 +58,14 @@ typedef struct _LogEntry {
     char		*whatp;
     char		what[104];
     volatile bool	ready;
+    char		*tidp;
+    char		tid[40];
 } *LogEntry;
 	
 struct _Log {
     LogCat		cats;
     char		dir[1024];
+    char		app[16];
     FILE		*file;    // current output file
     int			max_files;
     int			max_size;
@@ -102,7 +105,7 @@ extern struct _LogCat	resp_cat;
 extern struct _LogCat	eval_cat;
 extern struct _LogCat	push_cat;
 
-extern void	log_init();
+extern void	log_init(const char *app);
 extern void	open_log_file();
 
 extern void	log_close();
@@ -115,7 +118,8 @@ extern LogCat	log_cat_find(const char *label);
 
 // Function to call to make a log entry.
 extern void	log_cat(LogCat cat, const char *fmt, ...);
-extern void	log_catv(LogCat cat, const char *fmt, va_list ap);
+extern void	log_tid_cat(LogCat cat, const char *tid, const char *fmt, ...);
+extern void	log_catv(LogCat cat, const char *tid, const char *fmt, va_list ap);
 
 extern void	log_start(bool with_pid);
 

data/ext/agoo/page.c

@@ -275,7 +275,11 @@ pages_init() {
 void
 pages_set_root(const char *root) {
     free(cache.root);
-    cache.root = strdup(root);
+    if (NULL == root) {
+	cache.root = NULL;
+    } else {
+	cache.root = strdup(root);
+    }
 }
 
 static void
@@ -380,7 +384,7 @@ page_immutable(Err err, const char *path, const char *content, int clen) {
 	p->path = NULL;
     } else {
 	p->path = strdup(path);
-	plen = strlen(path);
+	plen = (int)strlen(path);
 	DEBUG_ALLOC(mem_page_path, p->path);
     }
     p->mtime = 0;
@@ -466,7 +470,7 @@ update_contents(Page p) {
 	fclose(f);
 	return false;
     }
-    if (0 >= (size = ftell(f))) {
+    if (0 > (size = ftell(f))) {
 	fclose(f);
 	return false;
     }
@@ -506,7 +510,7 @@ update_contents(Page p) {
 
 static void
 page_remove(Page p) {
-    int		len = strlen(p->path);
+    int		len = (int)strlen(p->path);
     int64_t	h = calc_hash(p->path, &len);
     Slot	*bucket = get_bucketp(h);
     Slot	s;
@@ -561,30 +565,32 @@ page_get(Err err, const char *path, int plen) {
 	return NULL;
     }
     if (NULL == (page = cache_get(path, plen))) {
-	Page	old;
-	char	full_path[2048];
-	char	*s = stpcpy(full_path, cache.root);
+	if (NULL != cache.root) {
+	    Page	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)) {
-	    err_set(err, ERR_MEMORY, "Failed to allocate memory for page path.");
-	    return NULL;
-	}
-	strncpy(s, path, plen);
-	s[plen] = '\0';
-	if (NULL == (page = page_create(full_path))) {
-	    err_set(err, ERR_MEMORY, "Failed to allocate memory for Page.");
-	    return NULL;
-	}
-	if (!update_contents(page) || NULL == page->resp) {
-	    page_destroy(page);
-	    err_set(err, ERR_NOT_FOUND, "not found.");
-	    return NULL;
-	}
-	if (NULL != (old = cache_set(path, plen, page))) {
-	    page_destroy(old);
+	    if ('/' != *cache.root && '/' != *path) {
+		*s++ = '/';
+	    }
+	    if ((int)sizeof(full_path) <= plen + (s - full_path)) {
+		err_set(err, ERR_MEMORY, "Failed to allocate memory for page path.");
+		return NULL;
+	    }
+	    strncpy(s, path, plen);
+	    s[plen] = '\0';
+	    if (NULL == (page = page_create(full_path))) {
+		err_set(err, ERR_MEMORY, "Failed to allocate memory for Page.");
+		return NULL;
+	    }
+	    if (!update_contents(page) || NULL == page->resp) {
+		page_destroy(page);
+		err_set(err, ERR_NOT_FOUND, "not found.");
+		return NULL;
+	    }
+	    if (NULL != (old = cache_set(path, plen, page))) {
+		page_destroy(old);
+	    }
 	}
     } else {
 	page = page_check(err, page);
@@ -597,7 +603,7 @@ group_get(Err err, const char *path, int plen) {
     Page	page = NULL;
     Group	g = NULL;
     char	full_path[2048];
-    char	*s;
+    char	*s = NULL;
     Dir		d;
 
     if (NULL != strstr(path, "../")) {
@@ -619,7 +625,7 @@ group_get(Err err, const char *path, int plen) {
 	strncpy(s, path + g->plen, plen - g->plen);
 	s += plen - g->plen;
 	*s = '\0';
-	if (NULL != (page = cache_get(full_path, s - full_path))) {
+	if (NULL != (page = cache_get(full_path, (int)(s - full_path)))) {
 	    break;
 	}
     }
@@ -639,7 +645,7 @@ group_get(Err err, const char *path, int plen) {
 	if (NULL == d) {
 	    return NULL;
 	}
-	plen = s - full_path;
+	plen = (int)(s - full_path);
 	path = full_path;
 	if (NULL == (page = cache_get(path, plen))) {
 	    Page	old;
@@ -671,7 +677,7 @@ group_create(const char *path) {
 	g->next = cache.groups;
 	cache.groups = g;
 	g->path = strdup(path);
-	g->plen = strlen(path);
+	g->plen = (int)strlen(path);
 	DEBUG_ALLOC(mem_group_path, g->path);
 	g->dirs = NULL;
     }
@@ -687,7 +693,7 @@ group_add(Group g, const char *dir) {
 	d->next = g->dirs;
 	g->dirs = d;
 	d->path = strdup(dir);
-	d->plen = strlen(dir);
+	d->plen = (int)strlen(dir);
 	DEBUG_ALLOC(mem_dir_path, d->path);
     }
 }

data/ext/agoo/pub.c

@@ -98,6 +98,22 @@ pub_write(Upgraded up, const char *message, size_t mlen, bool bin) {
     return p;
 }
 
+Pub
+pub_dup(Pub src) {
+    Pub	p = (Pub)malloc(sizeof(struct _Pub));
+
+    if (NULL != p) {
+	DEBUG_ALLOC(mem_pub, p);
+	p->next = NULL;
+	p->kind = src->kind;
+	p->up = src->up;
+	p->subject = subject_create(src->subject->pattern, strlen(src->subject->pattern));
+	p->msg = src->msg;
+	text_ref(p->msg);
+    }
+    return p;
+}
+
 void
 pub_destroy(Pub pub) {
     if (NULL != pub->msg) {

data/ext/agoo/pub.h

@@ -34,6 +34,7 @@ extern Pub	pub_subscribe(struct _Upgraded *up, const char *subject, int slen);
 extern Pub	pub_unsubscribe(struct _Upgraded *up, const char *subject, int slen);
 extern Pub	pub_publish(const char *subject, int slen, const char *message, size_t mlen);
 extern Pub	pub_write(struct _Upgraded *up, const char *message, size_t mlen, bool bin);
+extern Pub	pub_dup(Pub src);
 extern void	pub_destroy(Pub pub);
 
 #endif // __AGOO_PUB_H__

data/ext/agoo/queue.h

@@ -5,6 +5,7 @@
 
 #include <stdatomic.h>
 #include <stdbool.h>
+#include <stdlib.h>
 
 typedef void	*QItem;
 

data/ext/agoo/req.c

@@ -0,0 +1,95 @@
+// Copyright (c) 2018, Peter Ohler, All rights reserved.
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#include "con.h"
+#include "debug.h"
+#include "server.h"
+#include "req.h"
+
+Req
+req_create(size_t mlen) {
+    size_t	size = mlen + sizeof(struct _Req) - 7;
+    Req		req = (Req)malloc(size);
+    
+    if (NULL != req) {
+	DEBUG_ALLOC(mem_req, req);
+	memset(req, 0, size);
+	req->env = the_server.env_nil_value;
+	req->mlen = mlen;
+	req->hook = NULL;
+    }
+    return req;
+}
+
+void
+req_destroy(Req req) {
+    DEBUG_FREE(mem_req, req);
+    if (NULL != req->hook && PUSH_HOOK == req->hook->type) {
+	free(req->hook);
+    }
+    free(req);
+}
+
+const char*
+req_host(Req r, int *lenp) {
+    const char	*host;
+    const char	*colon;
+
+    if (NULL == (host = con_header_value(r->header.start, r->header.len, "Host", lenp))) {
+	return NULL;
+    }
+    for (colon = host + *lenp - 1; host < colon; colon--) {
+	if (':' == *colon) {
+	    break;
+	}
+    }
+    if (host < colon) {
+	*lenp = (int)(colon - host);
+    }
+    return host;
+}
+
+int
+req_port(Req r) {
+    int		len;
+    const char	*host;
+    const char	*colon;
+    
+    if (NULL == (host = con_header_value(r->header.start, r->header.len, "Host", &len))) {
+	return 0;
+    }
+    for (colon = host + len - 1; host < colon; colon--) {
+	if (':' == *colon) {
+	    break;
+	}
+    }
+    if (host == colon) {
+	return 0;
+    }
+    return (int)strtol(colon + 1, NULL, 10);
+}
+
+const char*
+req_query_value(Req r, const char *key, int klen, int *vlenp) {
+    const char	*value;
+
+    if (NULL != (value = strstr(r->query.start, key))) {
+	char	*end;
+
+	if (0 >= klen) {
+	    klen = strlen(key);
+	}
+	value += klen + 1;
+	if (NULL == (end = index(value, '&'))) {
+	    *vlenp = strlen(value);
+	} else {
+	    *vlenp = (int)(end - value);
+	}
+    }
+    return value;
+}
+

data/ext/agoo/req.h

@@ -0,0 +1,48 @@
+// Copyright (c) 2018, Peter Ohler, All rights reserved.
+
+#ifndef __AGOO_REQ_H__
+#define __AGOO_REQ_H__
+
+#include <stdint.h>
+
+#include "hook.h"
+#include "kinds.h"
+
+struct _Server;
+struct _Upgraded;
+struct _Res;
+
+typedef enum {
+    UP_NONE	= '\0',
+    UP_WS	= 'W',
+    UP_SSE	= 'S',
+} Upgrade;
+
+typedef struct _Str {
+    char		*start;
+    unsigned int	len;
+} *Str;
+
+typedef struct _Req {
+    Method		method;
+    struct _Res		*res;
+
+    Upgrade		upgrade;
+    struct _Upgraded	*up;
+    struct _Str		path;
+    struct _Str		query;
+    struct _Str		header;
+    struct _Str		body;
+    void		*env;
+    Hook		hook;
+    size_t		mlen;   // allocated msg length
+    char		msg[8]; // expanded to be full message
+} *Req;
+
+extern Req		req_create(size_t mlen);
+extern void		req_destroy(Req req);
+extern const char*	req_host(Req r, int *lenp);
+extern int		req_port(Req r);
+extern const char*	req_query_value(Req r, const char *key, int klen, int *vlenp);
+
+#endif // __AGOO_REQ_H__

data/ext/agoo/request.c

@@ -1,6 +1,7 @@
 // Copyright (c) 2018, Peter Ohler, All rights reserved.
 
 #include <stdio.h>
+#include <stdlib.h>
 #include <ctype.h>
 
 #include "debug.h"
@@ -8,6 +9,7 @@
 #include "error_stream.h"
 #include "rack_logger.h"
 #include "request.h"
+#include "res.h"
 
 static VALUE	req_class = Qundef;
 
@@ -59,21 +61,6 @@ static const char	websocket_val[] = "websocket";
 static const char	accept_key[] = "Accept";
 static const char	event_stream_val[] = "text/event-stream";
 
-Req
-request_create(size_t mlen) {
-    size_t	size = mlen + sizeof(struct _Req) - 7;
-    Req		req = (Req)malloc(size);
-    
-    if (NULL != req) {
-	DEBUG_ALLOC(mem_req, req);
-	memset(req, 0, size);
-	req->env = Qnil;
-	req->mlen = mlen;
-	req->hook = NULL;
-    }
-    return req;
-}
-
 static VALUE
 req_method(Req r) {
     VALUE	m;
@@ -185,23 +172,14 @@ static VALUE
 req_server_name(Req r) {
     int		len;
     const char	*host;
-    const char	*colon;
 
     if (NULL == r) {
 	rb_raise(rb_eArgError, "Request is no longer valid.");
     }
-    if (NULL == (host = con_header_value(r->header.start, r->header.len, "Host", &len))) {
+    if (NULL == (host = req_host(r, &len))) {
 	return rb_str_new2("unknown");
     }
-    for (colon = host + len - 1; host < colon; colon--) {
-	if (':' == *colon) {
-	    break;
-	}
-    }
-    if (host == colon) {
-	return rb_str_new(host, len);
-    }
-    return rb_str_new(host, colon - host);
+    return rb_str_new(host, len);
 }
 
 /* Document-method: server_name
@@ -381,6 +359,7 @@ rack_run_once(VALUE self) {
     return Qfalse;
 }
 
+// TBD req.c
 static void
 add_header_value(VALUE hh, const char *key, int klen, const char *val, int vlen) {
     if (sizeof(content_type) - 1 == klen && 0 == strncasecmp(key, content_type, sizeof(content_type) - 1)) {
@@ -413,6 +392,7 @@ add_header_value(VALUE hh, const char *key, int klen, const char *val, int vlen)
     }
 }
 
+// TBD req.c
 static void
 fill_headers(Req r, VALUE hash) {
     char	*h = r->header.start;
@@ -551,7 +531,7 @@ rack_logger(VALUE self) {
  */
 VALUE
 request_env(Req req, VALUE self) {
-    if (Qnil == req->env) {
+    if (Qnil == (VALUE)req->env) {
 	volatile VALUE	env = rb_hash_new();
     
 	// As described by
@@ -586,9 +566,9 @@ request_env(Req req, VALUE self) {
 	rb_hash_aset(env, rack_hijack_val, self);
 	rb_hash_aset(env, rack_hijack_io_val, Qnil);
 
-	req->env = env;
+	req->env = (void*)env;
     }
-    return req->env;
+    return (VALUE)req->env;
 }
 
 /* Document-method: to_h
@@ -644,18 +624,10 @@ call(VALUE self) {
     args[0] = INT2NUM(r->res->con->sock);
 
     io = rb_class_new_instance(1, args, rb_cIO);
-    rb_hash_aset(r->env, rack_hijack_io_val, io);
+    rb_hash_aset((VALUE)r->env, rack_hijack_io_val, io);
     
     return io;
 }
-void
-request_destroy(Req req) {
-    DEBUG_FREE(mem_req, req);
-    if (NULL != req->hook && PUSH_HOOK == req->hook->type) {
-	free(req->hook);
-    }
-    free(req);
-}
 
 VALUE
 request_wrap(Req req) {