agoo 2.5.5 → 2.5.6

data/ext/agoo/ready.h

@@ -0,0 +1,41 @@
+// Copyright (c) 2018, Peter Ohler, All rights reserved.
+
+#ifndef AGOO_READY_H
+#define AGOO_READY_H
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <sys/types.h>
+
+#include "err.h"
+
+typedef enum {
+    AGOO_READY_NONE	= '\0',
+    AGOO_READY_IN	= 'i',
+    AGOO_READY_OUT	= 'o',
+    AGOO_READY_BOTH	= 'b',
+} agooReadyIO;
+
+typedef struct _agooReady	*agooReady;
+
+typedef struct _agooHandler {
+    agooReadyIO	(*io)(void *ctx);
+    // return false to remove connection
+    bool	(*check)(void *ctx, double now);
+    bool	(*read)(agooReady ready, void *ctx);
+    bool	(*write)(void *ctx);
+    void	(*error)(void *ctx);
+    void	(*destroy)(void *ctx);
+} *agooHandler;
+
+extern agooReady	agoo_ready_create(agooErr err);
+extern void		agoo_ready_destroy(agooReady ready);
+extern int		agoo_ready_add(agooErr		err,
+				       agooReady	ready,
+				       int		fd,
+				       agooHandler	handler,
+				       void		*ctx);
+extern int		agoo_ready_go(agooErr err, agooReady ready);
+extern void		agoo_ready_iterate(agooReady ready, void (*cb)(void *ctx, void *arg), void *arg);
+
+#endif // AGOO_READY_H

data/ext/agoo/req.c

@@ -10,15 +10,15 @@
 #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);
+agooReq
+agoo_req_create(size_t mlen) {
+    size_t	size = mlen + sizeof(struct _agooReq) - 7;
+    agooReq	req = (agooReq)malloc(size);
     
     if (NULL != req) {
 	DEBUG_ALLOC(mem_req, req);
 	memset(req, 0, size);
-	req->env = the_server.env_nil_value;
+	req->env = agoo_server.env_nil_value;
 	req->mlen = mlen;
 	req->hook = NULL;
     }
@@ -26,7 +26,7 @@ req_create(size_t mlen) {
 }
 
 void
-req_destroy(Req req) {
+agoo_req_destroy(agooReq req) {
     DEBUG_FREE(mem_req, req);
     if (NULL != req->hook && PUSH_HOOK == req->hook->type) {
 	free(req->hook);
@@ -35,11 +35,11 @@ req_destroy(Req req) {
 }
 
 const char*
-req_host(Req r, int *lenp) {
+agoo_req_host(agooReq r, int *lenp) {
     const char	*host;
     const char	*colon;
 
-    if (NULL == (host = con_header_value(r->header.start, r->header.len, "Host", lenp))) {
+    if (NULL == (host = agoo_con_header_value(r->header.start, r->header.len, "Host", lenp))) {
 	return NULL;
     }
     for (colon = host + *lenp - 1; host < colon; colon--) {
@@ -54,12 +54,12 @@ req_host(Req r, int *lenp) {
 }
 
 int
-req_port(Req r) {
+agoo_req_port(agooReq r) {
     int		len;
     const char	*host;
     const char	*colon;
     
-    if (NULL == (host = con_header_value(r->header.start, r->header.len, "Host", &len))) {
+    if (NULL == (host = agoo_con_header_value(r->header.start, r->header.len, "Host", &len))) {
 	return 0;
     }
     for (colon = host + len - 1; host < colon; colon--) {
@@ -74,7 +74,7 @@ req_port(Req r) {
 }
 
 const char*
-req_query_value(Req r, const char *key, int klen, int *vlenp) {
+agoo_req_query_value(agooReq r, const char *key, int klen, int *vlenp) {
     const char	*value;
 
     if (NULL != (value = strstr(r->query.start, key))) {

data/ext/agoo/req.h

@@ -8,41 +8,40 @@
 #include "hook.h"
 #include "kinds.h"
 
-struct _Server;
-struct _Upgraded;
-struct _Res;
+struct _agooUpgraded;
+struct _agooRes;
 
 typedef enum {
-    UP_NONE	= '\0',
-    UP_WS	= 'W',
-    UP_SSE	= 'S',
-} Upgrade;
+    AGOO_UP_NONE	= '\0',
+    AGOO_UP_WS		= 'W',
+    AGOO_UP_SSE		= 'S',
+} agooUpgrade;
 
-typedef struct _Str {
+typedef struct _agooStr {
     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);
+} *agooStr;
+
+typedef struct _agooReq {
+    agooMethod			method;
+    struct _agooRes		*res;
+
+    agooUpgrade			upgrade;
+    struct _agooUpgraded	*up;
+    struct _agooStr		path;
+    struct _agooStr		query;
+    struct _agooStr		header;
+    struct _agooStr		body;
+    void			*env;
+    agooHook			hook;
+    size_t			mlen;   // allocated msg length
+    char			msg[8]; // expanded to be full message
+} *agooReq;
+
+extern agooReq		agoo_req_create(size_t mlen);
+extern void		agoo_req_destroy(agooReq req);
+extern const char*	agoo_req_host(agooReq r, int *lenp);
+extern int		agoo_req_port(agooReq r);
+extern const char*	agoo_req_query_value(agooReq r, const char *key, int klen, int *vlenp);
 
 #endif // AGOO_REQ_H

data/ext/agoo/request.c

@@ -62,21 +62,21 @@ static const char	accept_key[] = "Accept";
 static const char	event_stream_val[] = "text/event-stream";
 
 static VALUE
-req_method(Req r) {
+req_method(agooReq r) {
     VALUE	m;
 
     if (NULL == r) {
 	rb_raise(rb_eArgError, "Request is no longer valid.");
     }
     switch (r->method) {
-    case CONNECT:	m = connect_val;	break;
-    case DELETE:	m = delete_val;		break;
-    case GET:		m = get_val;		break;
-    case HEAD:		m = head_val;		break;
-    case OPTIONS:	m = options_val;	break;
-    case POST:		m = post_val;		break;
-    case PUT:		m = put_val;		break;
-    case PATCH:		m = patch_val;		break;
+    case AGOO_CONNECT:	m = connect_val;	break;
+    case AGOO_DELETE:	m = delete_val;		break;
+    case AGOO_GET:	m = get_val;		break;
+    case AGOO_HEAD:	m = head_val;		break;
+    case AGOO_OPTIONS:	m = options_val;	break;
+    case AGOO_POST:	m = post_val;		break;
+    case AGOO_PUT:	m = put_val;		break;
+    case AGOO_PATCH:	m = patch_val;		break;
     default:		m = Qnil;		break;
     }
     return m;
@@ -90,11 +90,11 @@ req_method(Req r) {
  */
 static VALUE
 method(VALUE self) {
-    return req_method((Req)DATA_PTR(self));
+    return req_method((agooReq)DATA_PTR(self));
 }
 
 static VALUE
-req_script_name(Req r) {
+req_script_name(agooReq r) {
     // The logic is a bit tricky here and for path_info. If the HTTP path is /
     // then the script_name must be empty and the path_info will be /. All
     // other cases are handled with the full path in script_name and path_info
@@ -115,11 +115,11 @@ req_script_name(Req r) {
  */
 static VALUE
 script_name(VALUE self) {
-    return req_script_name((Req)DATA_PTR(self));
+    return req_script_name((agooReq)DATA_PTR(self));
 }
 
 static VALUE
-req_path_info(Req r) {
+req_path_info(agooReq r) {
     if (NULL == r) {
 	rb_raise(rb_eArgError, "Request is no longer valid.");
     }
@@ -143,11 +143,11 @@ req_path_info(Req r) {
  */
 static VALUE
 path_info(VALUE self) {
-    return req_path_info((Req)DATA_PTR(self));
+    return req_path_info((agooReq)DATA_PTR(self));
 }
 
 static VALUE
-req_query_string(Req r) {
+req_query_string(agooReq r) {
     if (NULL == r) {
 	rb_raise(rb_eArgError, "Request is no longer valid.");
     }
@@ -165,18 +165,18 @@ req_query_string(Req r) {
  */
 static VALUE
 query_string(VALUE self) {
-    return req_query_string((Req)DATA_PTR(self));
+    return req_query_string((agooReq)DATA_PTR(self));
 }
 
 static VALUE
-req_server_name(Req r) {
+req_server_name(agooReq r) {
     int		len;
     const char	*host;
 
     if (NULL == r) {
 	rb_raise(rb_eArgError, "Request is no longer valid.");
     }
-    if (NULL == (host = req_host(r, &len))) {
+    if (NULL == (host = agoo_req_host(r, &len))) {
 	return rb_str_new2("unknown");
     }
     return rb_str_new(host, len);
@@ -190,11 +190,11 @@ req_server_name(Req r) {
  */
 static VALUE
 server_name(VALUE self) {
-    return req_server_name((Req)DATA_PTR(self));
+    return req_server_name((agooReq)DATA_PTR(self));
 }
 
 static VALUE
-req_server_port(Req r) {
+req_server_port(agooReq r) {
     int		len;
     const char	*host;
     const char	*colon;
@@ -202,7 +202,7 @@ req_server_port(Req r) {
     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 = agoo_con_header_value(r->header.start, r->header.len, "Host", &len))) {
 	return Qnil;
     }
     for (colon = host + len - 1; host < colon; colon--) {
@@ -224,14 +224,14 @@ req_server_port(Req r) {
  */
 static VALUE
 server_port(VALUE self) {
-    return req_server_port((Req)DATA_PTR(self));
+    return req_server_port((agooReq)DATA_PTR(self));
 }
 
 static VALUE
-req_rack_upgrade(Req r) {
+req_rack_upgrade(agooReq r) {
     switch (r->upgrade) {
-    case UP_WS:		return websocket_sym;
-    case UP_SSE:	return sse_sym;
+    case AGOO_UP_WS:	return websocket_sym;
+    case AGOO_UP_SSE:	return sse_sym;
     default:		return Qnil;
     }
 }
@@ -244,7 +244,7 @@ req_rack_upgrade(Req r) {
  */
 static VALUE
 rack_upgrade(VALUE self) {
-    return req_rack_upgrade((Req)DATA_PTR(self));
+    return req_rack_upgrade((agooReq)DATA_PTR(self));
 }
 
 /* Document-method: rack_version
@@ -259,7 +259,7 @@ rack_version(VALUE self) {
 }
 
 static VALUE
-req_rack_url_scheme(Req r) {
+req_rack_url_scheme(agooReq r) {
     // TBD http or https when ssl is supported
     return http_val;
 }
@@ -272,11 +272,11 @@ req_rack_url_scheme(Req r) {
  */
 static VALUE
 rack_url_scheme(VALUE self) {
-    return req_rack_url_scheme((Req)DATA_PTR(self));
+    return req_rack_url_scheme((agooReq)DATA_PTR(self));
 }
 
 static VALUE
-req_rack_input(Req r) {
+req_rack_input(agooReq r) {
     if (NULL == r) {
 	rb_raise(rb_eArgError, "Request is no longer valid.");
     }
@@ -295,11 +295,11 @@ req_rack_input(Req r) {
  */
 static VALUE
 rack_input(VALUE self) {
-    return req_rack_input((Req)DATA_PTR(self));
+    return req_rack_input((agooReq)DATA_PTR(self));
 }
 
 static VALUE
-req_rack_errors(Req r) {
+req_rack_errors(agooReq r) {
     return error_stream_new();
 }
 
@@ -312,15 +312,15 @@ req_rack_errors(Req r) {
  */
 static VALUE
 rack_errors(VALUE self) {
-    return req_rack_errors((Req)DATA_PTR(self));
+    return req_rack_errors((agooReq)DATA_PTR(self));
 }
 
 static VALUE
-req_rack_multithread(Req r) {
+req_rack_multithread(agooReq r) {
     if (NULL == r) {
 	rb_raise(rb_eArgError, "Request is no longer valid.");
     }
-    if (1 < the_server.thread_cnt) {
+    if (1 < agoo_server.thread_cnt) {
 	return Qtrue;
     }
     return Qfalse;
@@ -334,7 +334,7 @@ req_rack_multithread(Req r) {
  */
 static VALUE
 rack_multithread(VALUE self) {
-    return req_rack_multithread((Req)DATA_PTR(self));
+    return req_rack_multithread((agooReq)DATA_PTR(self));
 }
 
 /* Document-method: rack_multiprocess
@@ -394,7 +394,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) {
+fill_headers(agooReq r, VALUE hash) {
     char	*h = r->header.start;
     char	*end = h + r->header.len + 1; // +1 for last \r
     char	*key = h;
@@ -448,7 +448,7 @@ fill_headers(Req r, VALUE hash) {
 	    } else if (sizeof(accept_key) - 1 == klen && 0 == strncasecmp(key, accept_key, sizeof(accept_key) - 1)) {
 		if (sizeof(event_stream_val) - 1 == vend - val &&
 		    0 == strncasecmp(val, event_stream_val, sizeof(event_stream_val) - 1)) {
-		    r->upgrade = UP_SSE;
+		    r->upgrade = AGOO_UP_SSE;
 		}
 	    }
 	    key = h + 1;
@@ -461,7 +461,7 @@ fill_headers(Req r, VALUE hash) {
 	}
     }
     if (upgrade && ws) {
-	r->upgrade = UP_WS;
+	r->upgrade = AGOO_UP_WS;
     }
 }
 
@@ -473,7 +473,7 @@ fill_headers(Req r, VALUE hash) {
  */
 static VALUE
 headers(VALUE self) {
-    Req			r = DATA_PTR(self);
+    agooReq		r = DATA_PTR(self);
     volatile VALUE	h;
 
     if (NULL == r) {
@@ -494,7 +494,7 @@ headers(VALUE self) {
  */
 static VALUE
 body(VALUE self) {
-    Req		r = DATA_PTR(self);
+    agooReq	r = DATA_PTR(self);
 
     if (NULL == r) {
 	rb_raise(rb_eArgError, "Request is no longer valid.");
@@ -506,7 +506,7 @@ body(VALUE self) {
 }
 
 static VALUE
-req_rack_logger(Req req) {
+req_rack_logger(agooReq req) {
     return rack_logger_new();
 }
 
@@ -521,7 +521,7 @@ req_rack_logger(Req req) {
  */
 static VALUE
 rack_logger(VALUE self) {
-    return req_rack_logger((Req)DATA_PTR(self));
+    return req_rack_logger((agooReq)DATA_PTR(self));
 }
 
 /* Document-class: Agoo::Request
@@ -530,7 +530,7 @@ rack_logger(VALUE self) {
  * request is a more efficient encapsulation of the rack environment.
  */
 VALUE
-request_env(Req req, VALUE self) {
+request_env(agooReq req, VALUE self) {
     if (Qnil == (VALUE)req->env) {
 	volatile VALUE	env = rb_hash_new();
     
@@ -580,7 +580,7 @@ request_env(Req req, VALUE self) {
  */
 static VALUE
 to_h(VALUE self) {
-    Req		r = DATA_PTR(self);
+    agooReq	r = DATA_PTR(self);
 
     if (NULL == r) {
 	rb_raise(rb_eArgError, "Request is no longer valid.");
@@ -609,7 +609,7 @@ to_s(VALUE self) {
  */
 static VALUE
 call(VALUE self) {
-    Req			r = DATA_PTR(self);
+    agooReq		r = DATA_PTR(self);
     VALUE		args[1];
     volatile VALUE	io;
 
@@ -630,7 +630,7 @@ call(VALUE self) {
 }
 
 VALUE
-request_wrap(Req req) {
+request_wrap(agooReq req) {
     // freed from the C side of things
     return Data_Wrap_Struct(req_class, NULL, NULL, req);
 }