agoo 2.5.5 → 2.5.6

data/ext/agoo/log.h

@@ -5,124 +5,124 @@
 
 #include <pthread.h>
 #include <stdarg.h>
-#include <stdatomic.h>
 #include <stdbool.h>
 #include <stdint.h>
 #include <stdio.h>
 
+#include "atomic.h"
 #include "err.h"
 
 typedef enum {
-    FATAL	= 0,
-    ERROR	= 1,
-    WARN	= 2,
-    INFO	= 3,
-    DEBUG	= 4,
-    UNKNOWN	= 5,
-} LogLevel;
-
-typedef struct _Color {
+    AGOO_FATAL		= 0,
+    AGOO_ERROR		= 1,
+    AGOO_WARN		= 2,
+    AGOO_INFO		= 3,
+    AGOO_DEBUG		= 4,
+    AGOO_UNKNOWN	= 5,
+} agooLogLevel;
+
+typedef struct _agooColor {
     const char	*name;
     const char	*ansi;
-} *Color;
-
-#define BLACK		"black"
-#define RED		"red"
-#define GREEN		"green"
-#define YELLOW		"yellow"
-#define BLUE		"blue"
-#define MAGENTA		"magenta"
-#define CYAN		"cyan"
-#define WHITE		"white"
-#define GRAY		"gray"
-#define DARK_RED	"dark_red"
-#define DARK_GREEN	"dark_green"
-#define BROWN		"brown"
-#define DARK_BLUE	"dark_blue"
-#define PURPLE		"purple"
-#define DARK_CYAN	"dark_cyan"
-
-typedef struct _Log	*Log;
-
-typedef struct _LogCat {
-    struct _LogCat	*next;
+} *agooColor;
+
+#define AGOO_BLACK	"black"
+#define AGOO_RED	"red"
+#define AGOO_GREEN	"green"
+#define AGOO_YELLOW	"yellow"
+#define AGOO_BLUE	"blue"
+#define AGOO_MAGENTA	"magenta"
+#define AGOO_CYAN	"cyan"
+#define AGOO_WHITE	"white"
+#define AGOO_GRAY	"gray"
+#define AGOO_DARK_RED	"dark_red"
+#define AGOO_DARK_GREEN	"dark_green"
+#define AGOO_BROWN	"brown"
+#define AGOO_DARK_BLUE	"dark_blue"
+#define AGOO_PURPLE	"purple"
+#define AGOO_DARK_CYAN	"dark_cyan"
+
+typedef struct _agooLog	*agooLog;
+
+typedef struct _agooLogCat {
+    struct _agooLogCat	*next;
     char		label[32];
-    Color		color;
+    agooColor		color;
     int			level;
     bool		on;
-} *LogCat;
+} *agooLogCat;
 
-typedef struct _LogEntry {
-    LogCat		cat;
+typedef struct _agooLogEntry {
+    agooLogCat		cat;
     int64_t		when; // nano UTC
     char		*whatp;
     char		what[104];
     volatile bool	ready;
     char		*tidp;
     char		tid[40];
-} *LogEntry;
+} *agooLogEntry;
 	
-struct _Log {
-    LogCat		cats;
-    char		dir[1024];
-    char		app[16];
-    FILE		*file;    // current output file
-    int			max_files;
-    int			max_size;
-    long		size;     // current file size
-    pthread_t		thread;
-    volatile bool	done;
-    bool		console;  // if true print log message to stdout
-    bool		classic;  // classic in stdout
-    bool		colorize; // color in stdout
-    bool		with_pid;
-    int			zone;     // timezone offset from GMT in seconds
-    int64_t		day_start;
-    int64_t		day_end;
-    char		day_buf[16];
-
-    LogEntry		q;
-    LogEntry		end;
-    _Atomic(LogEntry)	head;
-    _Atomic(LogEntry)	tail;
-    atomic_flag		push_lock;
-    atomic_int		wait_state;
-    int			rsock;
-    int			wsock;
-
-    void		(*on_error)(Err err);
+struct _agooLog {
+    agooLogCat			cats;
+    char			dir[1024];
+    char			app[16];
+    FILE			*file;    // current output file
+    int				max_files;
+    int				max_size;
+    long			size;     // current file size
+    pthread_t			thread;
+    volatile bool		done;
+    bool			console;  // if true print log message to stdout
+    bool			classic;  // classic in stdout
+    bool			colorize; // color in stdout
+    bool			with_pid;
+    int				zone;     // timezone offset from GMT in seconds
+    int64_t			day_start;
+    int64_t			day_end;
+    char			day_buf[16];
+
+    agooLogEntry		q;
+    agooLogEntry		end;
+    _Atomic(agooLogEntry)	head;
+    _Atomic(agooLogEntry)	tail;
+    atomic_flag			push_lock;
+    atomic_int			wait_state;
+    int				rsock;
+    int				wsock;
+
+    void			(*on_error)(agooErr err);
 };
 
-extern struct _Log	the_log;
-extern struct _LogCat	fatal_cat;
-extern struct _LogCat	error_cat;
-extern struct _LogCat	warn_cat;
-extern struct _LogCat	info_cat;
-extern struct _LogCat	debug_cat;
-extern struct _LogCat	con_cat;
-extern struct _LogCat	req_cat;
-extern struct _LogCat	resp_cat;
-extern struct _LogCat	eval_cat;
-extern struct _LogCat	push_cat;
-
-extern void	log_init(const char *app);
-extern void	open_log_file();
-
-extern void	log_close();
-extern bool	log_flush(double timeout);
-extern void	log_rotate();
-
-extern void	log_cat_reg(LogCat cat, const char *label, LogLevel level, const char *color, bool on);
-extern void	log_cat_on(const char *label, bool on);
-extern LogCat	log_cat_find(const char *label);
+extern struct _agooLog		agoo_log;
+extern struct _agooLogCat	agoo_fatal_cat;
+extern struct _agooLogCat	agoo_error_cat;
+extern struct _agooLogCat	agoo_warn_cat;
+extern struct _agooLogCat	agoo_info_cat;
+extern struct _agooLogCat	agoo_debug_cat;
+extern struct _agooLogCat	agoo_con_cat;
+extern struct _agooLogCat	agoo_req_cat;
+extern struct _agooLogCat	agoo_resp_cat;
+extern struct _agooLogCat	agoo_eval_cat;
+extern struct _agooLogCat	agoo_push_cat;
+
+extern void		agoo_log_init(const char *app);
+extern void		agoo_log_open_file();
+
+extern void		agoo_log_close();
+extern bool		agoo_log_flush(double timeout);
+extern void		agoo_log_rotate();
+
+extern void		agoo_log_cat_reg(agooLogCat cat, const char *label, agooLogLevel level, const char *color, bool on);
+extern void		agoo_log_cat_on(const char *label, bool on);
+extern agooLogCat	agoo_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_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		agoo_log_cat(agooLogCat cat, const char *fmt, ...);
+extern void		agoo_log_tid_cat(agooLogCat cat, const char *tid, const char *fmt, ...);
+extern void		agoo_log_catv(agooLogCat cat, const char *tid, const char *fmt, va_list ap);
 
-extern void	log_start(bool with_pid);
+extern int		agoo_log_start(agooErr err, bool with_pid);
 
-extern Color	find_color(const char *name);
+extern agooColor	find_color(const char *name);
 
 #endif /* AGOO_LOG_H */

data/ext/agoo/method.h

@@ -4,23 +4,23 @@
 #define AGOO_METHOD_H
 
 typedef enum {
-    CONNECT	= 'C',
-    DELETE	= 'D',
-    GET		= 'G',
-    HEAD	= 'H',
-    OPTIONS	= 'O',
-    POST	= 'P',
-    PUT		= 'U',
-    PATCH	= 'T',
-    ALL		= 'A',
-    NONE	= '\0',
+    AGOO_CONNECT	= 'C',
+    AGOO_DELETE		= 'D',
+    AGOO_GET		= 'G',
+    AGOO_HEAD		= 'H',
+    AGOO_OPTIONS	= 'O',
+    AGOO_POST		= 'P',
+    AGOO_PUT		= 'U',
+    AGOO_PATCH		= 'T',
+    AGOO_ALL		= 'A',
+    AGOO_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
-    ON_ERROR	= 'F', // use for on_error callback
-} Method;
+    AGOO_ON_MSG		= 'M', // use for on_message callback
+    AGOO_ON_BIN		= 'B', // use for on_message callback with binary (ASCII8BIT)
+    AGOO_ON_CLOSE	= 'X', // use for on_close callback
+    AGOO_ON_SHUTDOWN	= 'S', // use for on_shotdown callback
+    AGOO_ON_EMPTY	= 'E', // use for on_drained callback
+    AGOO_ON_ERROR	= 'F', // use for on_error callback
+} agooMethod;
 
 #endif // AGOO_METHOD_H

data/ext/agoo/page.c

@@ -21,36 +21,36 @@
 #define MIME_BUCKET_SIZE	64
 #define MIME_BUCKET_MASK	63
 
-typedef struct _Slot {
-    struct _Slot	*next;
+typedef struct _slot {
+    struct _slot	*next;
     char		key[MAX_KEY_LEN + 1];
-    Page		value;
+    agooPage		value;
     uint64_t		hash;
     int			klen;
 } *Slot;
 
-typedef struct _MimeSlot {
-    struct _MimeSlot	*next;
+typedef struct _mimeSlot {
+    struct _mimeSlot	*next;
     char		key[MAX_MIME_KEY_LEN + 1];
     char		*value;
     uint64_t		hash;
     int			klen;
 } *MimeSlot;
 
-typedef struct _Cache {
+typedef struct _cache {
     Slot		buckets[PAGE_BUCKET_SIZE];
     MimeSlot		muckets[MIME_BUCKET_SIZE];
     char		*root;
-    Group		groups;
+    agooGroup		groups;
 } *Cache;
 
-typedef struct _Mime {
+typedef struct _mime {
     const char	*suffix;
     const char	*type;
 } *Mime;
 
 // These are used for the initial load.
-static struct _Mime	mime_map[] = {
+static struct _mime	mime_map[] = {
     { "asc", "text/plain" },
     { "avi", "video/x-msvideo" },
     { "bin", "application/octet-stream" },
@@ -99,7 +99,7 @@ static struct _Mime	mime_map[] = {
 
 static const char	page_fmt[] = "HTTP/1.1 200 OK\r\nContent-Type: %s\r\nContent-Length: %ld\r\n\r\n";
 
-static struct _Cache	cache = {
+static struct _cache	cache = {
     .buckets = {0},
     .muckets = {0},
     .root = NULL,
@@ -162,13 +162,13 @@ mime_get(const char *key) {
     return v;
 }
 
-Page
+agooPage
 cache_get(const char *key, int klen) {
     int		len = klen;
     int64_t	h = calc_hash(key, &len);
     Slot	*bucket = get_bucketp(h);
     Slot	s;
-    Page	v = NULL;
+    agooPage	v = NULL;
 
     for (s = *bucket; NULL != s; s = s->next) {
 	if (h == (int64_t)s->hash && len == (int)s->klen &&
@@ -181,7 +181,7 @@ cache_get(const char *key, int klen) {
 }
 
 int
-mime_set(Err err, const char *key, const char *value) {
+mime_set(agooErr err, const char *key, const char *value) {
     int		klen = (int)strlen(key);
     int		len = klen;
     int64_t	h = calc_hash(key, &len);
@@ -189,7 +189,7 @@ mime_set(Err err, const char *key, const char *value) {
     MimeSlot	s;
     
     if (MAX_MIME_KEY_LEN < len) {
-	return err_set(err, ERR_ARG, "%s is too long for a file extension. Maximum is %d", key, MAX_MIME_KEY_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);
     }
     for (s = *bucket; NULL != s; s = s->next) {
 	if (h == (int64_t)s->hash && len == s->klen &&
@@ -198,11 +198,11 @@ mime_set(Err err, const char *key, const char *value) {
 	    DEBUG_FREE(mem_mime_slot, s->value);
 	    free(s->value);
 	    s->value = strdup(value);
-	    return ERR_OK;
+	    return AGOO_ERR_OK;
 	}
     }
-    if (NULL == (s = (MimeSlot)malloc(sizeof(struct _MimeSlot)))) {
-	return err_set(err, ERR_ARG, "out of memory adding %s", key);
+    if (NULL == (s = (MimeSlot)malloc(sizeof(struct _mimeSlot)))) {
+	return agoo_err_set(err, AGOO_ERR_ARG, "out of memory adding %s", key);
     }
     DEBUG_ALLOC(mem_mime_slot, s);
     s->hash = h;
@@ -216,16 +216,16 @@ mime_set(Err err, const char *key, const char *value) {
     s->next = *bucket;
     *bucket = s;
 
-    return ERR_OK;
+    return AGOO_ERR_OK;
 }
 
-static Page
-cache_set(const char *key, int klen, Page 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);
     Slot	s;
-    Page	old = NULL;
+    agooPage	old = NULL;
     
     if (MAX_KEY_LEN < len) {
 	return value;
@@ -241,7 +241,7 @@ cache_set(const char *key, int klen, Page value) {
 	    return old;
 	}
     }
-    if (NULL == (s = (Slot)malloc(sizeof(struct _Slot)))) {
+    if (NULL == (s = (Slot)malloc(sizeof(struct _slot)))) {
 	return value;
     }
     DEBUG_ALLOC(mem_page_slot, s)
@@ -261,11 +261,11 @@ cache_set(const char *key, int klen, Page value) {
 }
 
 void
-pages_init() {
+agoo_pages_init() {
     Mime	m;
-    struct _Err	err = ERR_INIT;
+    struct _agooErr	err = AGOO_ERR_INIT;
     
-    memset(&cache, 0, sizeof(struct _Cache));
+    memset(&cache, 0, sizeof(struct _cache));
     cache.root = strdup(".");
     for (m = mime_map; NULL != m->suffix; m++) {
 	mime_set(&err, m->suffix, m->type);
@@ -273,7 +273,7 @@ pages_init() {
 }
 
 void
-pages_set_root(const char *root) {
+agoo_pages_set_root(const char *root) {
     free(cache.root);
     if (NULL == root) {
 	cache.root = NULL;
@@ -283,9 +283,9 @@ pages_set_root(const char *root) {
 }
 
 static void
-page_destroy(Page p) {
+agoo_page_destroy(agooPage p) {
     if (NULL != p->resp) {
-	text_release(p->resp);
+	agoo_text_release(p->resp);
 	p->resp = NULL;
     }
     DEBUG_FREE(mem_page_path, p->path);
@@ -295,7 +295,7 @@ page_destroy(Page p) {
 }
 
 void
-pages_cleanup() {
+agoo_pages_cleanup() {
     Slot	*sp = cache.buckets;
     Slot	s;
     Slot	n;
@@ -308,7 +308,7 @@ pages_cleanup() {
 	for (s = *sp; NULL != s; s = n) {
 	    n = s->next;
 	    DEBUG_FREE(mem_page_slot, s);
-	    page_destroy(s->value);
+	    agoo_page_destroy(s->value);
 	    free(s);
 	}
 	*sp = NULL;
@@ -347,9 +347,9 @@ path_mime(const char *path) {
 
 // The page resp points to the page resp msg to save memory and reduce
 // allocations.
-Page
-page_create(const char *path) {
-    Page	p = (Page)malloc(sizeof(struct _Page));
+agooPage
+agoo_page_create(const char *path) {
+    agooPage	p = (agooPage)malloc(sizeof(struct _agooPage));
 
     if (NULL != p) {
 	DEBUG_ALLOC(mem_page, p);
@@ -367,16 +367,16 @@ page_create(const char *path) {
     return p;
 }
 
-Page
-page_immutable(Err err, const char *path, const char *content, int clen) {
-    Page	p = (Page)malloc(sizeof(struct _Page));
+agooPage
+agoo_page_immutable(agooErr err, const char *path, const char *content, int clen) {
+    agooPage	p = (agooPage)malloc(sizeof(struct _agooPage));
     const char	*mime = path_mime(path);
     long	msize;
     int		cnt;
     int		plen = 0;
     
     if (NULL == p) {
-	err_set(err, ERR_MEMORY, "Failed to allocate memory for page.");
+	agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocate memory for page.");
 	return NULL;     
     }
     DEBUG_ALLOC(mem_page, p);
@@ -400,10 +400,10 @@ page_immutable(Err err, const char *path, const char *content, int clen) {
     // Format size plus space for the length, the mime type, and some
     // padding. Then add the content length.
     msize = sizeof(page_fmt) + 60 + clen;
-    if (NULL == (p->resp = text_allocate((int)msize))) {
+    if (NULL == (p->resp = agoo_text_allocate((int)msize))) {
 	DEBUG_FREE(mem_page, p);
 	free(p);
-	err_set(err, ERR_MEMORY, "Failed to allocate memory for page content.");
+	agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocate memory for page content.");
 	return NULL;
     }
     cnt = sprintf(p->resp->text, page_fmt, mime, (long)clen);
@@ -411,7 +411,7 @@ page_immutable(Err err, const char *path, const char *content, int clen) {
     memcpy(p->resp->text + cnt, content, clen);
     p->resp->text[msize] = '\0';
     p->resp->len = msize;
-    text_ref(p->resp);
+    agoo_text_ref(p->resp);
 
     cache_set(path, plen, p);
 
@@ -419,18 +419,23 @@ page_immutable(Err err, const char *path, const char *content, int clen) {
 }
 
 static bool
-update_contents(Page p) {
+close_return_false(FILE *f) {
+    fclose(f);
+    return false;
+}
+
+static bool
+update_contents(agooPage p) {
     const char	*mime = path_mime(p->path);
     int		plen = (int)strlen(p->path);
-    FILE	*f;
     long	size;
     struct stat	fattr;
     long	msize;
     int		cnt;
     struct stat	fs;
-    Text	t;
+    agooText	t;
+    FILE	*f = fopen(p->path, "rb");
     
-    f = fopen(p->path, "rb");
     // On linux a directory is opened by fopen (sometimes? all the time?) so
     // fstat is called to get the file mode and verify it is a regular file or
     // a symlink.
@@ -467,28 +472,25 @@ update_contents(Page p) {
 	mime = "text/html";
     }
     if (0 != fseek(f, 0, SEEK_END)) {
-	fclose(f);
-	return false;
+	return close_return_false(f);
     }
     if (0 > (size = ftell(f))) {
-	fclose(f);
-	return false;
+	return close_return_false(f);
     }
     rewind(f);
 
     // Format size plus space for the length, the mime type, and some
     // padding. Then add the content length.
     msize = sizeof(page_fmt) + 60 + size;
-    if (NULL == (t = text_allocate((int)msize))) {
-	return false;
+    if (NULL == (t = agoo_text_allocate((int)msize))) {
+	return close_return_false(f);
     }
     cnt = sprintf(t->text, page_fmt, mime, size);
     msize = cnt + size;
     if (0 < size) {
 	if (size != (long)fread(t->text + cnt, 1, size, f)) {
-	    fclose(f);
-	    text_release(t);
-	    return false;
+	    agoo_text_release(t);
+	    return close_return_false(f);
 	}
     }
     fclose(f);
@@ -500,18 +502,18 @@ update_contents(Page p) {
 	p->mtime = 0;
     }
     if (NULL != p->resp) {
-	text_release(p->resp);
+	agoo_text_release(p->resp);
 	p->resp = NULL;
     }
     p->resp = t;
-    text_ref(p->resp);
+    agoo_text_ref(p->resp);
     p->last_check = dtime();
 
     return true;
 }
 
 static void
-page_remove(Page p) {
+agoo_page_remove(agooPage p) {
     int		len = (int)strlen(p->path);
     int64_t	h = calc_hash(p->path, &len);
     Slot	*bucket = get_bucketp(h);
@@ -528,7 +530,7 @@ page_remove(Page p) {
 		prev->next = s->next;
 	    }
 	    DEBUG_FREE(mem_page_slot, s);
-	    page_destroy(s->value);
+	    agoo_page_destroy(s->value);
 	    free(s);
 
 	    break;
@@ -537,8 +539,8 @@ page_remove(Page p) {
     }
 }
 
-static Page
-page_check(Err err, Page page) {
+static agooPage
+page_check(agooErr err, agooPage page) {
     if (!page->immutable) {
 	double	now = dtime();
 
@@ -548,8 +550,8 @@ page_check(Err err, Page page) {
 	    if (0 == stat(page->path, &fattr) && page->mtime != fattr.st_mtime) {
 		update_contents(page);
 		if (NULL == page->resp) {
-		    page_remove(page);
-		    err_set(err, ERR_NOT_FOUND, "not found.");
+		    agoo_page_remove(page);
+		    agoo_err_set(err, AGOO_ERR_NOT_FOUND, "not found.");
 		    return NULL;
 		}
 	    }
@@ -559,16 +561,16 @@ page_check(Err err, Page page) {
     return page;
 }
 
-Page
-page_get(Err err, const char *path, int plen) {
-    Page	page;
+agooPage
+agoo_page_get(agooErr err, const char *path, int plen) {
+    agooPage	page;
 
     if (NULL != strstr(path, "../")) {
 	return NULL;
     }
     if (NULL == (page = cache_get(path, plen))) {
 	if (NULL != cache.root) {
-	    Page	old;
+	    agooPage	old;
 	    char	full_path[2048];
 	    char	*s = stpcpy(full_path, cache.root);
 
@@ -576,22 +578,22 @@ page_get(Err err, const char *path, int plen) {
 		*s++ = '/';
 	    }
 	    if ((int)sizeof(full_path) <= plen + (s - full_path)) {
-		err_set(err, ERR_MEMORY, "Failed to allocate memory for page path.");
+		agoo_err_set(err, AGOO_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.");
+	    if (NULL == (page = agoo_page_create(full_path))) {
+		agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocate memory for agooPage.");
 		return NULL;
 	    }
 	    if (!update_contents(page) || NULL == page->resp) {
-		page_destroy(page);
-		err_set(err, ERR_NOT_FOUND, "not found.");
+		agoo_page_destroy(page);
+		agoo_err_set(err, AGOO_ERR_NOT_FOUND, "not found.");
 		return NULL;
 	    }
 	    if (NULL != (old = cache_set(path, plen, page))) {
-		page_destroy(old);
+		agoo_page_destroy(old);
 	    }
 	}
     } else {
@@ -600,13 +602,13 @@ page_get(Err err, const char *path, int plen) {
     return page;
 }
 
-Page
-group_get(Err err, const char *path, int plen) {
-    Page	page = NULL;
-    Group	g = NULL;
+agooPage
+group_get(agooErr err, const char *path, int plen) {
+    agooPage	page = NULL;
+    agooGroup	g = NULL;
     char	full_path[2048];
     char	*s = NULL;
-    Dir		d;
+    agooDir	d;
 
     if (NULL != strstr(path, "../")) {
 	return NULL;
@@ -650,19 +652,19 @@ group_get(Err err, const char *path, int plen) {
 	plen = (int)(s - full_path);
 	path = full_path;
 	if (NULL == (page = cache_get(path, plen))) {
-	    Page	old;
+	    agooPage	old;
 
-	    if (NULL == (page = page_create(path))) {
-		err_set(err, ERR_MEMORY, "Failed to allocate memory for Page.");
+	    if (NULL == (page = agoo_page_create(path))) {
+		agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocate memory for agooPage.");
 		return NULL;
 	    }
 	    if (!update_contents(page) || NULL == page->resp) {
-		page_destroy(page);
-		err_set(err, ERR_NOT_FOUND, "not found.");
+		agoo_page_destroy(page);
+		agoo_err_set(err, AGOO_ERR_NOT_FOUND, "not found.");
 		return NULL;
 	    }
 	    if (NULL != (old = cache_set(path, plen, page))) {
-		page_destroy(old);
+		agoo_page_destroy(old);
 	    }
 	}
 	return page;
@@ -670,9 +672,9 @@ group_get(Err err, const char *path, int plen) {
     return page_check(err, page);
 }
 
-Group
+agooGroup
 group_create(const char *path) {
-    Group	g = (Group)malloc(sizeof(struct _Group));
+    agooGroup	g = (agooGroup)malloc(sizeof(struct _agooGroup));
 
     if (NULL != g) {
 	DEBUG_ALLOC(mem_group, g);
@@ -687,8 +689,8 @@ group_create(const char *path) {
 }
 
 void
-group_add(Group g, const char *dir) {
-    Dir	d = (Dir)malloc(sizeof(struct _Dir));
+group_add(agooGroup g, const char *dir) {
+    agooDir	d = (agooDir)malloc(sizeof(struct _agooDir));
 
     if (NULL != d) {
 	DEBUG_ALLOC(mem_dir, d);