Initial commit

src/arch.c

@@ -0,0 +1,139 @@
+#include <time.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "arch/db.h"
+#include "fs/notify.h"
+
+/* only way to exit the application properly
+   when in main loop is by signal */
+static void clean_exit(int excode) {
+	
+	time_t t = time(NULL);
+	
+	notify_cleanup();
+	arch_db_close();
+	
+	printf("\nprocess exit at: %s", ctime(&t));
+	exit(excode);
+}
+
+/* signal handler */
+static void sighandl(int sig) {
+	
+	switch(sig) {
+	/* normal exit signals */
+	case SIGTERM :
+	case SIGKILL :
+	case SIGQUIT :
+	case SIGINT  :
+		clean_exit(EXIT_SUCCESS);
+	/* segmentation violation, let user now */
+	case SIGSEGV :
+		fprintf(stderr, "SEGFAULT: o no he didn't\n");
+		clean_exit(EXIT_FAILURE);
+	case SIGUSR1 :
+	case SIGUSR2 :
+		printf("notify stat:\n");
+		notify_stat();
+		/* don't know why, but everything goes bananas if we keep executing */
+		clean_exit(EXIT_SUCCESS);
+	}
+}
+
+void arch_loop() {
+
+	notify_event *event;
+	
+	for(;;) {
+		
+		if (indexer_pending() && !notify_is_ready()) {
+#ifdef __DEBUG__
+        	printf("sched: running indexer\n");
+#endif
+            indexer_run(15);
+            continue;
+        }
+        
+#ifdef __DEBUG__
+        printf("sched: notify block\n");  
+#endif
+
+		event = notify_read(-1);
+		
+		if (event == NULL)
+			continue;
+		
+#ifdef __DEBUG__
+		printf("-- EVENT --\n"
+			   " TYPE: %s\n"
+			   " DIR: %i\n"
+			   " PATH: %s%s\n"
+			   "---------------\n", notify_event_typetostr(event), event->dir, event->path, event->filename);
+#endif
+		
+		switch(event->type) {
+			
+            case NOTIFY_MOVE_TO :
+            	
+                if (event->dir)
+                    indexer_register(event->path, event->filename);
+            case NOTIFY_CREATE :
+            	arch_db_insert(event->path, event->filename, event->dir);
+            	break;
+            case NOTIFY_MOVE_FROM :
+			case NOTIFY_DELETE :
+				arch_db_delete(event->path, event->filename);
+				break;
+		}
+		
+#ifdef __DEBUG__
+		notify_stat();
+#endif
+	}
+}
+
+int main(int argc, char **argv) {
+
+	/* Validate arguments */
+	if (argc != 5) {
+		
+		printf("Usage: %s <Root Directory> <Db user> <Db pass> <Db name>.\n"
+			   "Root Directory - Path to indexroot. All subdirectories will be indexed.\n"
+			   "Db user - Database user\n"
+		       "Db pass - Database password\n"
+		       "Db name - Database to use for indexing\n", argv[0]);
+		
+		return EXIT_FAILURE;
+	}
+
+    /* setup signal handlers */
+	signal(SIGTERM, sighandl);
+	signal(SIGKILL, sighandl);
+	signal(SIGQUIT, sighandl);
+	signal(SIGINT, sighandl);
+	signal(SIGSEGV, sighandl);
+	signal(SIGUSR1, sighandl);
+	signal(SIGUSR2, sighandl);
+
+	/* connect to database */
+	if (!arch_db_init("localhost", argv[2], argv[3], argv[4], "fs"))
+		return EXIT_FAILURE;
+	
+	/* clean database */
+	if (arch_db_truncate() == -1)
+		return EXIT_FAILURE;
+	
+	notify_init();
+	
+	if(notify_add_watch(argv[1]) == -1) {
+		fprintf(stderr, "Invalid path: %s\n", argv[1]);
+		return EXIT_FAILURE;
+	}
+
+    indexer_register(argv[1], NULL);
+    
+	arch_loop();
+	
+	return EXIT_SUCCESS;
+}

src/arch/db.h

@@ -0,0 +1,33 @@
+
+/*
+ * Copyright (C) 2010  Archived
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _ARCH_DB_H
+
+#define _ARCH_DB_H
+
+int arch_db_init(char *host, char *username, char *password, char *database, char *table);
+
+int arch_db_insert(const char *path, const char *filename, const int isdir);
+
+int arch_db_delete(const char *path, const char *filename);
+
+int arch_db_truncate();
+
+void arch_db_close();
+
+#endif /* _DB_DATABASE_H */

src/arch/mysql.c

@@ -0,0 +1,285 @@
+/**
+ * Archived - Inotify based filesystem mirror daemon
+ * 
+ * @authors: pnx, tritomI
+ * 
+ *  
+ *  Copyright (C) 2010  Archived
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <mysql/mysql.h>
+#include <malloc.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <time.h>
+#include <string.h>
+
+#include "db.h"
+
+#define STRSZ(s) (sizeof(char) * strlen(s))
+
+static MYSQL* dbconn;
+static unsigned long dbthread_id;
+static char *dbtable = NULL;
+
+/*
+ * Initialize database connection and connect to database
+ */
+int arch_db_init(char *host, char *username, char *password, char *database, char *table) {
+
+	my_bool reconnect = 1;
+	
+	/* Keep tablename for querys */
+	dbtable = malloc(sizeof(table));
+	strcpy(dbtable,table);
+	
+	/* Init. database */
+	dbconn = mysql_init(NULL);
+	
+	/* Set mysql options */
+	mysql_options(dbconn, MYSQL_OPT_RECONNECT, &reconnect);
+		
+	/* Connect to database */
+	if (!mysql_real_connect(dbconn, host, username, password, database, 0, NULL, 0)) {
+		fprintf(stderr, "%s\n", mysql_error(dbconn));
+		return 0;
+	}
+	
+	/* Fix for mysql versions prior to 5.0.19 */
+	mysql_options(dbconn, MYSQL_OPT_RECONNECT, &reconnect);
+	
+	
+	/* Save mysql thread id */
+	dbthread_id = mysql_thread_id(dbconn);
+	
+#ifdef DB_DEBUG
+	fprintf(stderr, "Mysql init: %li\n", dbthread_id);
+#endif
+	
+	return 1;
+}
+
+/*
+ * Close database connection
+ */
+void arch_db_close() {
+	
+	/* dbtable never free'd */
+	if (dbtable != NULL) {
+		free(dbtable);
+		dbtable = NULL;
+	}
+	
+	mysql_close(dbconn);
+	
+	/* another leak fix */
+	mysql_library_end();
+}
+
+/*
+ * Truncate database table
+ */
+int arch_db_truncate() {
+	
+	int ret;
+	
+	/* Allocate memory big enough for query */
+	char *stmt = (char *) malloc((sizeof(char) * strlen(dbtable)) + 20);
+	
+	/* Create mysql query */
+	if(sprintf(stmt, "TRUNCATE TABLE `%s`", dbtable) < 0) {
+		fprintf(stderr, "Could not create sql statement in notify_db_truncate()\n");
+		return -1;
+	}
+	
+	/* Run mysql query */
+	ret = mysql_query(dbconn, stmt);
+	
+	/* Clean up */
+	free(stmt);
+	
+	/* Make sure query was successfull */
+	if(ret != 0) {
+		fprintf(stderr, "%s\n", mysql_error(dbconn));
+		return -1;
+	}
+	
+	return 0;
+}
+
+/*
+ * Insert into database
+ */
+int arch_db_insert(const char *path, const char *filename, const int isdir) {
+	
+	int ret;
+	char *esc_path;
+	char *esc_filename;
+	long stmt_size;
+	long esc_path_size;
+	long esc_filename_size;
+	
+	char date[25];
+	time_t curtime;
+	struct tm *loctime;
+	
+	/* 
+	 * Allocate memory big enough for query 
+	 * dbtable + path + filename + date + 100 (for base query)
+	 */
+	stmt_size = sizeof(char) * (strlen(dbtable)+
+			strlen(path)+strlen(filename)+sizeof(date)+100);
+	
+	char *stmt = malloc(stmt_size);
+	
+	/* Allocate memory for escaped path / filename */
+	esc_path_size = (sizeof(char) * strlen(path) * 2) + 1;
+	esc_path = malloc(esc_path_size);
+	
+	esc_filename_size = (sizeof(char) * strlen(filename) * 2) + 1;
+	esc_filename = malloc(esc_filename_size);
+	
+	/* For debuging, prints allocated size for malloc's */
+#ifdef DB_DEBUG
+	fprintf(stderr, "==============================================\n");
+	fprintf(stderr, "Dynamic allocated memory in notify_db_insert()\n");
+	fprintf(stderr, "Stmt: %li\n", stmt_size);
+	fprintf(stderr, "Path: %li\n", esc_path_size);
+	fprintf(stderr, "Filename: %li\n", esc_filename_size);
+	fprintf(stderr, "==============================================\n");
+#endif
+	
+	
+	/* Get date */
+	curtime = time(NULL);
+	loctime = localtime(&curtime);
+	strftime(date, 25, "%Y-%m-%d %H:%M:%S", loctime);
+	
+	/* Make sure we got a connection
+	 * This is prob. not needed. 
+	 */
+	if(mysql_ping(dbconn) != 0) {
+		fprintf(stderr, "Lost connection to database. Could not reconnect.\n");
+		return -1;
+	}
+	
+	mysql_real_escape_string(dbconn, esc_path, path, strlen(path));
+	mysql_real_escape_string(dbconn, esc_filename, filename, strlen(filename));
+	
+	/* Create mysql query */
+	sprintf(stmt, "INSERT INTO `%s` (`Path`, `Base`, `Type`, `Status`, `Date`) VALUES('%s','%s','%i','0', '%s')", dbtable, esc_path, esc_filename, isdir, date);
+	
+	/* Run mysql query */
+	ret = mysql_query(dbconn, stmt);
+	
+	/* Clean up */
+	free(stmt);
+	free(esc_path);
+	free(esc_filename);
+	
+	/* Make sure query was successfull */
+	if(ret != 0) {
+		fprintf(stderr, "%s\n", mysql_error(dbconn));
+		return -1;
+	}
+
+#ifdef DB_DEBUG
+	
+	if(dbthread_id != mysql_thread_id(dbconn)) {
+		fprintf(stderr, "Connection was lost. Reconnected. Old_Thread: %li, New_Thread: %li\n", dbthread_id, mysql_thread_id(dbconn));
+	}
+	
+#endif
+	
+	return 0;
+}
+
+/*
+ * Delete row in database
+ */
+int arch_db_delete(const char *path, const char *filename) {
+	
+	int ret;
+	char *esc_path;
+	char *esc_filename;
+	size_t stmt_size;
+	size_t esc_path_size;
+	size_t esc_filename_size;
+	
+	/* 
+	 * Allocate memory big enough for query 
+	 * dbtable + path + filename + date + 100 (for base query)
+	 */
+	stmt_size = STRSZ(dbtable) + 
+			STRSZ(path) + STRSZ(filename) + 100;
+	
+	char *stmt = malloc(stmt_size);
+	
+	/* Allocate memory for escaped path / filename */
+	esc_path_size = (sizeof(char) * strlen(path) * 2) + 1;
+	esc_path = malloc(esc_path_size);
+	
+	esc_filename_size = (sizeof(char) * strlen(filename) * 2) + 1;
+	esc_filename = malloc(esc_filename_size);
+	
+	/* For debuging, prints allocated size for malloc's */
+#ifdef DB_DEBUG
+	fprintf(stderr, "==============================================\n");
+	fprintf(stderr, "Dynamic allocated memory in notify_db_delete()\n");
+	fprintf(stderr, "Stmt: %i\n", (int)stmt_size);
+	fprintf(stderr, "Path: %i\n", (int)esc_path_size);
+	fprintf(stderr, "Filename: %i\n", (int)esc_filename_size);
+	fprintf(stderr, "==============================================\n");
+#endif
+	
+	/* Make sure we got a connection
+	 * This is prob. not needed. 
+	 */
+	if(mysql_ping(dbconn) != 0) {
+		fprintf(stderr, "Lost connection to database. Did reconnection work?\n");
+		return -1;
+	}
+	
+	mysql_real_escape_string(dbconn, esc_path, path, strlen(path));
+	mysql_real_escape_string(dbconn, esc_filename, filename, strlen(filename));
+	
+	/* Create mysql query */
+	sprintf(stmt, "DELETE FROM `%s` WHERE `Path` LIKE '%s%s%%' OR (`Path` = '%s' AND `Base` = '%s');", dbtable, esc_path, esc_filename, esc_path, esc_filename);
+	
+	/* Run mysql query */
+	ret = mysql_query(dbconn, stmt);
+	
+	/* Clean up */
+	free(stmt);
+	free(esc_path);
+	free(esc_filename);
+	
+	/* Make sure query was successfull */
+	if(ret != 0) {
+		fprintf(stderr, "%s\n", mysql_error(dbconn));
+		return -1;
+	}
+	
+#ifdef DB_DEBUG
+	
+	if(dbthread_id != mysql_thread_id(dbconn)) {
+		fprintf(stderr, "Connection was lost. Reconnected. Old_Thread: %li, New_Thread: %li\n", dbthread_id, mysql_thread_id(dbconn));
+	}
+	
+#endif
+
+	return 0;
+}

src/common/debug.h

@@ -0,0 +1,48 @@
+/*
+ * Common Debugging macros and definitions
+ * 
+ * Copyright (C) 2010  Archived
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _COMMON_DEBUG_H
+
+#define _COMMON_DEBUG_H
+
+#define __perror(...) fprintf(stderr, __VA_ARGS__)
+
+#define die(...) \
+	__perror("DIE: " __VA_ARGS__); \
+	exit(1)
+
+#ifdef __DEBUG__
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#define dassert(expr) \
+	((expr) ? \
+		(void) 0 : \
+		__perror("ASSERT: \"" #expr "\" at %s:%i\n", __FILE__, __LINE__))
+
+#define dprint(...) \
+	__perror("DEBUG: " __VA_ARGS__)
+
+#else
+#define dassert(expr)
+#define dprint(...)
+#endif
+
+#endif /* _COMMON_DEBUG_H */

src/common/mem.h

@@ -0,0 +1,12 @@
+
+#ifndef _COMMON_MEM_H
+
+#define _COMMON_MEM_H
+
+#include <malloc.h>
+
+#define sfree(x) \
+	if (x != NULL) \
+		free(x)
+
+#endif /* _COMMON_MEM_H */

src/common/path.c

@@ -0,0 +1,169 @@
+
+/*
+ * Copyright (C) 2010  Archived
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*
+ * the design goal here is to not use buffers because 
+ * path's can be extremely long (slightly overexaggerated but extreme cases are extreme).
+ * so we use funky heap memory based algorithms instead :)
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "debug.h"
+#include "path.h"
+
+/*
+ * allocates and initilizes a path
+ */
+static char* alloc_path(size_t s) {
+	
+	char *ptr;
+		
+	if (s < 1)
+		return NULL;
+		
+	if ((ptr = malloc(s+1)) == NULL)
+		return NULL;
+		
+	*ptr = '/';
+	memset(ptr+1, 0, s);
+		
+	return ptr;
+}
+
+static const char* path_clear(const char *path) {
+	
+	while(*path == '/')
+		path++;
+	
+	return path;
+}
+
+static inline int has_delim(const char *str) {
+	
+	if (str == NULL)
+		return 0;
+	
+	return strchr(str, '/') != NULL;
+}
+
+/*
+ * copy a clean path to buf
+ * NOTE: buffer should be atleast of size pathlen(path)
+ */
+static char* cpy_path(char *buf, const char *path) {
+	
+	if(!*path)
+		return buf;
+	
+	while(*path) {
+		
+		*(buf++) = *path;
+		
+		if (*path == '/')
+			path = path_clear(path);
+		else
+			path++;
+	}
+
+	if (*(buf-1) != '/')
+		*(buf++) = '/';
+	
+	dassert(*buf == 0);
+	
+	return buf;
+}
+
+int abspath(const char *path) {
+	
+	if (*path != '/')
+		return 0;
+	
+	return strstr(path, "/./")  == NULL && 
+		   strstr(path, "/../") == NULL;
+}
+
+size_t pathlen(const char *path) {
+	
+	size_t size = 0;
+	
+	while(*path != 0) {
+		
+		size++;
+		
+		if (*path == '/')
+			path = path_clear(path);
+		else if (*(++path) == 0)
+			size++;
+	}
+	
+	return size;
+}
+
+char* fmt_path(const char *base, const char *name, unsigned char dir) {
+
+	char *ptr, *ret;
+	size_t size;
+	
+	if (base == NULL || !abspath(base) || has_delim(name))
+		return NULL;
+	
+	size = pathlen(base);
+	
+	if (name != NULL) {
+		size += strlen(name);
+		if (dir) size++;
+	}
+	
+	if((ptr = alloc_path(size)) == NULL)
+		return NULL;
+	
+	ret = ptr;
+	
+	ptr = cpy_path(ptr, base);
+	
+	dassert((ptr-ret) == pathlen(base));
+	
+	if (name != NULL) {
+		memcpy(ptr, name, strlen(name));
+		if (dir) *(ptr+strlen(name)) = '/';
+	}
+	
+	return ret;
+}
+
+char* split_path(const char *path) {
+	return NULL;
+}
+
+const char* basename(const char *path) {
+	
+	const char *last = path+strlen(path);
+
+	if (*last == '/')
+		last--;
+	
+	while(path != last) {
+		if(*last == '/')
+			break;
+		last--;
+	}
+	
+	return last;
+}

src/common/path.h

@@ -0,0 +1,40 @@
+/*
+ * -- path.h
+ * 
+ * common path handling routines
+ * 
+ * Copyright (C) 2010  Archived
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _COMMON_PATH_H
+
+#define _COMMON_PATH_H
+
+#include <stdarg.h>
+#include <string.h>
+#include <limits.h>
+
+#ifndef PATH_MAX
+#define PATH_MAX 4096
+#endif
+
+size_t pathlen(const char *path);
+
+char* fmt_path(const char *base, const char *name, unsigned char dir);
+
+const char* basename(const char *path);
+
+#endif /* _COMMON_PATH_H */

src/common/rbtree.c

@@ -0,0 +1,355 @@
+/*
+ * Modified version of Julienne Walker's implementation
+ * http://www.eternallyconfuzzled.com/tuts/datastructures/jsw_tut_rbtree.aspx
+ * 
+ * Copyright (C) 2010  Archived
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ * 
+ * Do not touch anything in this file. it's perfect ;)
+ */
+#include <malloc.h>
+
+#include "debug.h"
+#include "rbtree.h"
+
+#define is_red(n) (n != NULL && n->color == RB_RED)
+#define swap(n,d,q) n->child[n->child[d] == q]
+
+#ifdef __DEBUG__
+int rb_assert(rbnode *node) {
+	
+	int rh, lh;
+	rbnode *ln;
+	rbnode *rn;
+	
+	if (node == NULL) {
+		return 1;
+	}
+	
+	ln = node->child[0];
+	rn = node->child[1];
+		
+	if (is_red(node)) {
+		if (is_red(ln) || is_red(rn)) {
+			die("Double red");
+			return 0;
+		}
+	}
+		
+	lh = rb_assert(ln);
+	rh = rb_assert(rn);
+	
+	if ( (ln != NULL && ln->key >= node->key) &&
+		 (rn != NULL && rn->key <= node->key) ) {
+		die("BST violation");
+		return 0;
+	}
+	
+	if (rh != 0 && lh != 0) {
+		
+		if (rh != lh) {
+			die("Black height violation");
+			return 0;
+		}
+		
+		return (is_red(node)) ? lh : lh+1;
+	}
+	
+	return 0;
+}
+#endif
+
+static rbnode* node_alloc(uint key, void *ptr) {
+	
+	rbnode *n = malloc(sizeof(rbnode));
+	
+	if (n == NULL)
+		return NULL;
+	
+	n->key   = key;
+	n->data  = ptr;
+	n->color = RB_RED;
+	n->child[0] = NULL;
+	n->child[1] = NULL;
+	
+	return n;
+}
+
+static void node_dealloc(rbnode *n, void (*a)(rbnode *)) {
+	
+	if (n == NULL)
+		return;
+	
+	if (a != NULL)
+		a(n);
+	else
+		free(n->data);
+	
+	node_dealloc(n->child[0], a);
+	node_dealloc(n->child[1], a);
+	
+	free(n);
+}
+
+static void _rbwalk(rbnode *n, void (*a)(rbnode *)) {
+	
+	if (n == NULL)
+		return;
+	
+	a(n);
+	
+	_rbwalk(n->child[0], a);
+	_rbwalk(n->child[1], a);
+}
+
+static rbnode* _rbcmp(rbnode *n, void *d, size_t l) {
+	
+	rbnode* r;
+	
+	if (n == NULL)
+		return NULL;
+	
+	if (memcmp(n->data, d, l) == 0)
+		return n;
+	
+	r = _rbcmp(n->child[0], d, l);
+	
+	if (r == NULL)
+		r = _rbcmp(n->child[1], d, l);
+	
+	return r;
+}
+
+static rbnode* rotate_single(rbnode *root, unsigned char dir) {
+	
+	rbnode *save = root->child[!dir];
+	
+	root->child[!dir] = save->child[dir];
+	save->child[dir]  = root;
+	
+	root->color = RB_RED;
+	save->color = RB_BLACK;
+	
+	return save;
+}
+
+static rbnode* rotate_double(rbnode *root, unsigned char dir) {
+	root->child[!dir] = rotate_single(root->child[!dir], !dir);
+	return rotate_single(root, dir);
+}
+
+int rbtree_insert(rbtree *tree, uint key, void *data) {
+	
+	rbnode head = {0};
+	
+	/* grandparent and parent */
+	rbnode *g, *t;
+	
+	/* iterator and parent */
+	rbnode *p, *q;
+	
+	unsigned char dir = 0, dir2, last;
+	
+	/* somewhere in here, there should be dragons */
+	
+	if (tree->root == NULL) {
+		tree->root = node_alloc(key, data);
+		if (tree->root == NULL)
+			return 0;
+	} else {
+		
+		t = &head;
+		g = p = NULL;
+		q = t->child[1] = tree->root;
+		
+		for(;;) {
+			if (q == NULL) {
+				p->child[dir] = q = node_alloc(key, data);
+				if (q == NULL)
+					return 0;
+			} else if (is_red(q->child[0]) && is_red(q->child[1])) {
+				/* color flip case */
+				q->color = RB_RED;
+				q->child[0]->color = RB_BLACK;
+				q->child[1]->color = RB_BLACK;
+			}
+			
+			/* fix red validation */
+			if (is_red(q) && is_red(p)) {
+				dir2 = (t->child[1] == g);
+				if (q == p->child[last])
+					t->child[dir2] = rotate_single(g, !last);
+				else
+					t->child[dir2] = rotate_double(g, !last);
+			}
+			
+			if (q->key == key) 
+				break;
+			
+			last = dir;
+			dir = q->key < key;
+			
+			if (g != NULL)
+				t = g;
+			g = p, p = q;
+			q = q->child[dir];
+		}
+		
+		tree->root = head.child[1];
+	}
+	
+	/* root should be black */
+	tree->root->color = RB_BLACK;
+	
+	return 1;
+}
+
+void* rbtree_delete(rbtree *tree, uint key) {
+	
+	rbnode head = {0};
+	
+	/* helpers*/
+	rbnode *q, *p, *g, *s;
+	
+	/* found item */
+	rbnode *f = NULL;
+	
+	/* pointer to the data member of the node we delete */
+	void *ret = NULL;
+	
+	unsigned char dir = 1, dir2, last;
+	
+	if (rbtree_is_empty(tree))
+		return NULL;
+	
+	q = &head;
+	g = p = NULL;
+	q->child[1] = tree->root;
+	
+	/* more dragons */
+	
+	while(q->child[dir] != NULL) {
+		last = dir;
+		
+		g = p, p = q;
+		q = q->child[dir];
+		dir = q->key < key;
+		
+		if (q->key == key)
+			f = q;
+		
+		if (!is_red(q) && !is_red(q->child[dir])) {
+			if (is_red(q->child[!dir]))
+				p = p->child[last] = rotate_single(q, dir);
+			else if (!is_red(q->child[!dir])) {
+				s = p->child[!last];
+				
+				if (s != NULL) {
+				    /* swap color if both child's are black */
+					if (!is_red(s->child[!last]) && !is_red(s->child[last])) {
+						p->color = RB_BLACK;
+						s->color = q->color = RB_RED;
+					} else {
+						dir2 = (g->child[1] == p);
+						
+						if (is_red(s->child[last]))
+							g->child[dir2] = rotate_double(p, last);
+						else if (is_red(s->child[!last]))
+							g->child[dir2] = rotate_single(p, last);
+						
+						q->color = g->child[dir2]->color = RB_RED;
+						g->child[dir2]->child[0]->color  = RB_BLACK;
+						g->child[dir2]->child[1]->color  = RB_BLACK;
+					}
+				}
+			}
+		}
+	}
+	
+	tree->root = head.child[1];
+	if (tree->root != NULL)
+		tree->root->color = RB_BLACK;
+	
+	/* remove if found */
+	if (f != NULL) {
+		ret = q->data;
+		if (q == tree->root) {
+			tree->root = NULL;
+		} else {
+			if (f != q) {
+				f->key  = q->key;
+				f->data = q->data;
+			}
+			swap(p,1,q) = swap(q, 0, NULL);
+		}
+		free(q);
+	}
+	
+	return ret;
+}
+
+rbnode* rbtree_search(rbtree *tree, uint key) {
+	
+	rbnode *n;
+	
+	if (tree == NULL || tree->root == NULL)
+		return NULL;
+	
+	n = tree->root;
+	
+	while(n != NULL) {
+		
+#ifdef __DEBUG__
+		printf("SEARCH: check %u\n", n->key);
+#endif
+		
+		if (n->key == key)
+			break;
+		
+		n = n->child[n->key < key];
+	}
+	
+	return n;
+}
+
+rbnode* rbtree_cmp_search(rbtree *tree, void *cmpdata, size_t len) {
+	
+	if (tree == NULL)
+		return NULL;
+				
+	return _rbcmp(tree->root, cmpdata, len);
+}
+
+void rbtree_walk(rbtree *tree, void (*action)(rbnode *)) {
+	
+	if (tree == NULL)
+		return;
+			
+	_rbwalk(tree->root, action);
+}
+
+void rbtree_free(rbtree *tree, void (*action)(rbnode *)) {
+		
+	if (tree == NULL)
+		return;
+	
+	node_dealloc(tree->root, action);
+	tree->root = NULL;
+}
+
+inline int rbtree_is_empty(rbtree *tree) {
+
+	return tree == NULL || tree->root == NULL;
+}

src/common/rbtree.h

@@ -0,0 +1,59 @@
+
+/* 
+ * Copyright (C) 2010  Archived
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _COMMON_RBTREE_H
+
+#define _COMMON_RBTREE_H
+
+#define RB_RED   0
+#define RB_BLACK 1
+
+typedef unsigned char color_t;
+typedef unsigned int uint;
+
+/* node definition */
+typedef struct _rbn {
+	uint 		 key;
+	void		*data;
+	struct _rbn *child[2];
+	color_t      color;
+} rbnode;
+
+typedef struct {
+	rbnode *root;
+} rbtree;
+
+#ifdef RB_DEBUG
+int rb_assert(rbnode *node);
+#endif
+
+int rbtree_insert(rbtree *tree, uint key, void *data);
+
+void* rbtree_delete(rbtree *tree, uint key);
+
+rbnode* rbtree_search(rbtree *tree, uint key);
+
+rbnode* rbtree_cmp_search(rbtree *tree, void *cmpdata, size_t len);
+
+void rbtree_walk(rbtree *tree, void (*action)(rbnode *));
+
+void rbtree_free(rbtree *tree, void (*action)(rbnode *));
+
+inline int rbtree_is_empty(rbtree *tree);
+
+#endif /* _COMMON_RBTREE_H */

src/fs/notify.h

@@ -0,0 +1,46 @@
+
+/*
+ * Archived file-system notification
+ * 
+ * Copyright (C) 2010  Archived
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _FS_NOTIFY_H
+
+#define _FS_NOTIFY_H
+
+/* notify event def's and operations */
+#include "notify_event.h"
+
+int notify_init();
+
+void notify_cleanup();
+
+int notify_add_watch(const char *path);
+
+void notify_rm_watch(unsigned int wd);
+
+void notify_rm_watch_path(const char *path);
+
+void notify_print_stat();
+
+notify_event* notify_read();
+
+void notify_stat();
+
+int notify_is_ready();
+
+#endif /* _FS_NOTIFY_H */

src/fs/notify_event.c

@@ -0,0 +1,155 @@
+/*
+ * Copyright (C) 2010  Archived
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <stdio.h>
+#include <malloc.h>
+#include <string.h>
+
+#include "notify_event.h"
+#include "../common/path.h"
+
+#define dealloc_data(ev) \
+	if (ev->path != NULL) \
+		free(ev->path); \
+	if (ev->filename != NULL) \
+		free(ev->filename)
+
+static void init_event(notify_event* ev) {
+	
+	ev->filename = NULL;
+	ev->path 	 = NULL;
+	ev->type 	 = 0;
+	ev->dir 	 = 0;
+}
+
+/*
+ * Create event
+ */
+notify_event* notify_event_new() {
+	
+	notify_event *ev = malloc(sizeof(notify_event));
+	
+	if(ev == NULL)
+		return NULL;
+		
+	init_event(ev);
+	
+	return ev;
+}
+
+/*
+ * Destroy event
+ */
+void notify_event_del(notify_event *event) {
+
+	if(event != NULL)
+		return;
+		
+	dealloc_data(event);
+	free(event);
+}
+
+/*
+ * dealloc memory and set default values
+ */
+void notify_event_clear(notify_event *event) {
+
+	if(event == NULL)
+		return;
+
+	dealloc_data(event);
+	
+	// set init values
+	init_event(event);
+}
+
+/*
+ * Set event path
+ */
+void notify_event_set_path(notify_event *event, const char *path) {
+	
+	char *ptr;
+	
+	if(event == NULL || path == NULL)
+		return;
+	
+	ptr = realloc(event->path, sizeof(char) * (strlen(path)+1));
+	
+	if (ptr == NULL)
+		return;
+	
+	memcpy(ptr, path, strlen(path)+1);
+	
+	event->path = ptr;
+}
+
+/*
+ * Set event filename
+ */
+void notify_event_set_filename(notify_event *event, const char *filename) {
+	
+	char *tmp;
+	
+	if(event == NULL || filename == NULL)
+		return;
+	
+	
+	tmp = realloc(event->filename, sizeof(char) * (strlen(filename)+1));
+	
+	if(tmp == NULL)
+		return;
+	
+	memcpy(tmp, filename, strlen(filename)+1);
+	
+	event->filename = tmp;
+}
+
+/* set directory */
+void notify_event_set_dir(notify_event *event, uint8_t dir) {
+
+	if(event == NULL)
+		return;
+
+	event->dir = dir;
+}
+
+void notify_event_set_type(notify_event *event, uint8_t type) {
+	
+	if(event == NULL)
+		return;
+		
+	event->type = type;
+}
+
+const char* notify_event_typetostr(notify_event *event) {
+	
+	switch(event->type) {
+		case NOTIFY_CREATE :
+			return "CREATE";
+		case NOTIFY_DELETE :
+			return "DELETE";
+			break;
+		case NOTIFY_MOVE_FROM :
+			return "MOVE_FROM";
+			break;
+		case NOTIFY_MOVE_TO :
+			return "MOVE_TO";
+			break;
+		default:
+			return "UNKNOWN";
+	}
+}

src/fs/notify_event.h

@@ -0,0 +1,56 @@
+/*
+ * event data-structure and operation's for notify API
+ * 
+ * Copyright (C) 2010  Archived
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _NOTIFY_EVENT_H
+
+#define _NOTIFY_EVENT_H
+
+#include <stdint.h>
+
+/* event types */
+#define NOTIFY_UNKNOWN 	   (1 << 0)
+#define NOTIFY_CREATE 	   (1 << 1)
+#define NOTIFY_DELETE 	   (1 << 2)
+#define NOTIFY_MOVE_FROM   (1 << 3)
+#define NOTIFY_MOVE_TO     (1 << 4)
+
+typedef struct {
+	uint8_t type; 	/* type of event */
+	uint8_t dir; 	/* non zero if event is triggered on a directory */
+	char *path; 	/* path of the triggered event */
+	char *filename; /* the filename event was triggered on */
+} notify_event;
+
+notify_event* notify_event_new();
+
+void notify_event_del(notify_event *event);
+
+void notify_event_clear(notify_event *event);
+
+void notify_event_set_path(notify_event *event, const char *path);
+
+void notify_event_set_filename(notify_event *event, const char *filename);
+
+void notify_event_set_dir(notify_event *event, uint8_t dir);
+
+void notify_event_set_type(notify_event *event, uint8_t type);
+
+const char* notify_event_typetostr(notify_event *event);
+
+#endif /* _NOTIFY_EVENT_H */

src/fs/notify_inotify.c

@@ -0,0 +1,307 @@
+/*
+ * Copyright (C) 2010  Archived
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+#include <errno.h>
+#include <sys/ioctl.h>
+#include <sys/inotify.h>
+
+/* red black tree for watch descriptors */
+#include "../common/rbtree.h"
+#include "../common/debug.h"
+#include "../common/path.h"
+#include "notify.h"
+
+typedef struct inotify_event inoev;
+
+#define MAXEVENT     0x200
+#define PADEVSIZE    (sizeof(inoev) + 0x40)
+#define INOBUFSIZE   (MAXEVENT*PADEVSIZE)
+
+#define WATCH_MASK (IN_MOVE | IN_CREATE | IN_DELETE | IN_ONLYDIR)
+
+/* Inotify file descriptor */
+static int fd = 0;
+
+/* Available bytes on file descriptor */
+static unsigned int fd_bytes = 0;
+
+/* redblack tree */
+static rbtree tree;
+
+/* inotify queue buffer */
+static char *inobuf = NULL;
+
+/* current event */
+static notify_event event;
+
+static int rmwatch(unsigned int wd) {
+	
+	void *data = rbtree_delete(&tree, wd);
+	
+	if (data == NULL)
+		return 0;
+	
+	dprint("remove watch: %i %s\n", wd, (char*) data);
+	free(data);
+	return 1;
+}
+
+static int addwatch(const char *path, const char *name) {
+	
+	rbnode *node;
+	char   *cpath;
+	int     wd;
+	
+	cpath = fmt_path(path, name, 1);
+	
+	if (cpath == NULL)
+		return -1;
+	
+	wd = inotify_add_watch(fd, cpath, WATCH_MASK);
+	
+	if (wd < 0) {
+		perror("NOTIFY ADD");
+		dprint("%i path %s\n", errno == EBADF, cpath);
+		return -errno;
+	}
+
+	/* we must update to not introduce duplicated wd's (keys) */
+	node = rbtree_search(&tree, wd);
+	
+	if (node == NULL) {
+		dprint("added wd = %i on %s\n", wd, cpath);
+		rbtree_insert(&tree, wd, (void*)cpath);
+	} else {
+		dprint("updated wd = %i from %s to %s\n", wd, (char*)node->data, cpath);
+		free(node->data);
+		node->data = (void*) cpath;
+	}
+	
+	return wd;
+}
+
+/* REF:1 */
+static int proc_event(inoev *iev) {
+
+	rbnode *node;
+	char    buf[4096];
+	uint8_t type = NOTIFY_UNKNOWN;
+
+	if (iev == NULL)
+		return 0;
+	
+	//notify_event_clear(&event);
+	
+#ifdef __DEBUG__
+	fprintf(stderr, "RAW EVENT: %i, %x", iev->wd, iev->mask);
+	if (iev->len)
+		fprintf(stderr, ", %s\n", iev->name);
+	else
+		fprintf(stderr, "\n");
+#endif
+	
+	/* lookup the watch descriptor in rbtree */
+	node = rbtree_search(&tree, iev->wd);
+	
+	if (node == NULL) {
+#ifdef __DEBUG__
+		fprintf(stderr, "-- IGNORING EVENT -- invalid watchdescriptor %i\n", iev->wd);
+		rb_assert(tree.root);
+#endif
+		return 0;
+	}
+
+	notify_event_set_dir(&event, (iev->mask & IN_ISDIR) != 0);
+	
+	/* set path, this is stored in void* node->data */
+	notify_event_set_path(&event, (char*)node->data);
+	notify_event_set_filename(&event, iev->name);
+	
+	iev->mask &= ~IN_ISDIR;
+	
+	switch (iev->mask) {
+			
+		case IN_CREATE :
+						
+			if (event.dir) {
+				dprint("IN_CREATE on directory, adding\n");
+				addwatch(event.path, event.filename);
+			}
+			
+			type = NOTIFY_CREATE;
+			break;
+		case IN_MOVED_TO :
+			
+			if (event.dir) {
+				dprint("IN_CREATE on directory, adding\n");
+				addwatch(event.path, event.filename);
+			}
+					
+			type = NOTIFY_MOVE_TO;
+			break;
+		case IN_MOVED_FROM :
+			/* TODO: clean this */
+			sprintf(buf, "%s%s/", event.path, event.filename);
+			notify_rm_watch_path(buf);
+		case IN_DELETE :
+			type = NOTIFY_DELETE;
+			break;
+		case IN_IGNORED :
+			rmwatch(iev->wd);
+			return 0;
+	}
+	
+	notify_event_set_type(&event, type);
+	
+	return 1;
+}
+
+int notify_init() {
+
+	if (fd > 0) {
+		fprintf(stderr, "inotify already instantiated.");
+		return 0;
+	}
+	
+	fd = inotify_init();
+	
+	if (fd < 1) {
+		perror("NOTIFY INIT");
+		return -1;
+	}
+	
+	dprint("inotify descriptor = %i\n", fd);
+
+	inobuf = malloc(INOBUFSIZE);
+	
+	if (inobuf == NULL) {
+		perror("NOTIFY BUFFER");
+		return -1;
+	}
+	
+	return 1;
+}
+
+void notify_cleanup() {
+	
+	/* free rbtree */
+	rbtree_free(&tree, NULL);
+	
+	if (inobuf != NULL)
+		free(inobuf);
+	
+	fd = 0;
+}
+
+/*
+ * Add inotify watch on path
+ */
+int notify_add_watch(const char *path) {
+	
+	return addwatch(path, NULL);
+}
+
+void notify_rm_watch(unsigned int wd) {
+	inotify_rm_watch(fd, wd);
+}
+
+void notify_rm_watch_path(const char *path) {
+	
+	rbnode *node = rbtree_cmp_search(&tree, (void*)path, strlen(path));
+	
+	if (node == NULL) {
+		dprint("remove watch by path: can't find %s\n", path);
+		return;
+	}
+	
+	dprint("remove watch by path: %i %s\n", node->key, (char*) node->data);
+	notify_rm_watch(node->key);
+}
+
+/*
+ * Get next inotify event
+ */
+notify_event* notify_read() {
+	
+	int			rc;
+	inoev 	   *rev = NULL;
+    static int  offset;
+
+	while(! proc_event(rev)) {
+		
+		if (fd_bytes < 1) {
+		
+			offset = 0;
+
+			fd_bytes = read(fd, inobuf, INOBUFSIZE);
+		
+			if (fd_bytes < 1) {
+			
+				if (fd_bytes == 0) {
+					fprintf(stderr, "NOTIFY READ: EOF\n");
+				} 
+				/* EINTR = call interrupted, silent ignore */
+				else if (errno != EINTR) {
+					perror("NOTIFY READ");
+				}
+			
+				return NULL;
+			}
+		}
+	
+		rev = (inoev *) &inobuf[offset];
+		offset += sizeof(inoev) + rev->len;
+	
+		if (offset >= fd_bytes)
+			fd_bytes = 0;
+	}
+	
+	return &event;
+}
+
+static void print_node(rbnode *node) {
+	printf("%i: %s\n", node->key, (char*) node->data);
+}
+
+void notify_stat() {
+
+#ifdef __DEBUG__
+	rbtree_walk(&tree, print_node);
+#endif
+}
+
+int notify_is_ready() {
+	
+	unsigned int bytes;
+	
+	if (fd_bytes > 1)
+		return 1;
+	
+	if (ioctl(fd, FIONREAD, &bytes) == -1)
+		return 0;
+	
+    dprint("%i bytes ready!\n", bytes);
+    
+	return bytes > 512;
+}
+
+

src/fs/tree.c

@@ -0,0 +1,206 @@
+
+/*
+ * -- tree.c
+ * 
+ * Copyright (C) 2010  Archived
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <unistd.h>
+#include <string.h>
+#include <stdio.h>
+#include <malloc.h>
+#include <errno.h>
+#include <dirent.h>
+
+#include "../common/mem.h"
+#include "../common/path.h"
+#include "tree.h"
+
+#if 0
+  #define pdebug(...) fprintf(stderr, __VA_ARGS__)
+#else
+  #define pdebug(...) 0
+#endif
+
+#define isrefdir(x) (!strcmp(x->d_name, ".") || !strcmp(x->d_name, ".."))
+
+/* REF:1 */
+static int have_perm(const char *base, const char *name) {
+	
+	char buf[1024];
+	
+	sprintf(buf, "%s%s", base, name);
+	
+	return access(buf, R_OK | X_OK) == 0;
+}
+
+struct tree* tree_new(const char *path) {
+	
+	int i;
+	struct tree *t = malloc(sizeof(struct tree));
+	
+	if (t == NULL)
+		return NULL;
+	
+	t->path = fmt_path(path, NULL, 0);
+	
+	if (t->path == NULL) {
+		free(t);
+		return NULL;
+	}
+	
+	t->depth = 0;
+	
+	t->dirs[0] = opendir(t->path);
+	
+	if (!t->dirs[0]) {
+		free(t->path);
+		free(t);
+		return NULL;
+	}
+	
+	t->ent.name = NULL;
+	t->ent.base = NULL;
+	t->ent.dir  = 0;
+	
+	return t;
+}
+
+void tree_del(struct tree *tree) {
+	
+	int i;
+	
+	for(i=0; i < tree->depth; i++)
+		closedir(tree->dirs[i]);
+	
+	if (tree->path != NULL)
+		free(tree->path);
+	
+	free(tree);
+}
+
+/* REF:1 */
+int tree_mvup(struct tree *tree) {
+	
+	char *slash;
+	
+	if (closedir(tree->dirs[tree->depth]) == -1) {
+		perror("TREE");
+		return -1;
+	}
+	
+	if (tree->depth == 0)
+		return 0;
+#if __DEBUG__
+		printf("tree_next_ent: tree depth is: %i \n", tree->depth);
+#endif
+	tree->depth--;
+	
+	slash = tree->path + strlen(tree->path)-1;
+	if (*slash == '/')
+		*slash = 0;
+		
+	slash = strrchr(tree->path, '/');
+	*(slash+1) = 0;
+	
+	tree->path = realloc(tree->path, sizeof(char) * (strlen(tree->path)+1));
+	
+	return 1;
+}
+
+/* REF:1 */
+int tree_mvdown(struct tree *tree, const char *dir) {
+
+	char buf[PATH_MAX];
+	DIR  *ds;
+	
+	if (tree->depth >= MAX_DEPTH-1)
+		return 0;
+
+	sprintf(buf, "%s%s/\0", tree->path, dir);
+	
+	if ((ds = opendir(buf)) == NULL) {
+		if (errno != EACCES)
+			perror("DIROPEN");
+		return 0;
+	}
+	
+	tree->path = realloc(tree->path, sizeof(char) * (strlen(buf)+1));
+	memcpy(tree->path, buf, strlen(buf)+1);
+	
+	tree->dirs[++tree->depth] = ds;
+	
+	return 1;
+}
+
+struct entry* tree_cpy_ent(struct entry *ent) {
+	
+	struct entry *ptr = malloc(sizeof(struct entry));
+	
+	if (ptr == NULL)
+		return NULL;
+	
+	memcpy(ptr, ent, sizeof(struct entry));
+	
+	return ptr;
+}
+
+/*
+ * NOTE: only read from the struct returned and DO NOT free it.
+ * use tree_cpy_ent() if you need to store it.
+ */
+struct entry* tree_next_ent(struct tree *tree) {
+
+	struct dirent *ent = NULL;
+	
+	if (tree == NULL)
+		return NULL;
+	
+	if (tree->ent.dir)
+		tree_mvdown(tree, tree->ent.name);
+	
+	for(;;) {
+		
+		ent = readdir(tree->dirs[tree->depth]);
+
+		if (ent == NULL) {
+			
+			if (tree_mvup(tree))
+				continue;
+			
+			tree_del(tree);
+			return NULL;
+		} else if (isrefdir(ent)) {
+			continue;
+
+		} else if (ent->d_type == 4) {
+
+			if (have_perm(tree->path, ent->d_name))
+				break;
+
+		} else {
+			break;
+		}
+
+	}
+
+	tree->ent.dir  = ent->d_type == 4;
+	tree->ent.base = tree->path;
+	tree->ent.name = &ent->d_name[0];
+
+
+	return &tree->ent;
+}

src/fs/tree.h

@@ -0,0 +1,34 @@
+
+#ifndef _FS_TREE_H
+
+#define _FS_TREE_H
+
+#define MAX_DEPTH 0x20
+
+#include <dirent.h>
+
+struct tree {
+	char *path;
+	DIR  *dirs[MAX_DEPTH];
+	unsigned char depth;
+	/* REF:2 */
+	struct entry {
+		char *name;
+		char *base;
+		unsigned char dir;
+	} ent;
+};
+
+struct tree* tree_new(const char *path);
+
+void tree_del(struct tree *tree);
+
+int tree_mvup(struct tree *tree);
+
+int tree_mvdown(struct tree *tree, const char *dir);
+
+struct entry* tree_cpy_ent(struct entry *ent);
+
+struct entry* tree_next_ent(struct tree *tree);
+
+#endif /* _FS_TREE_H */

src/indexer.c

@@ -0,0 +1,139 @@
+
+/*
+ * Copyright (C) 2010  Archived
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <malloc.h>
+#include <string.h>
+#include "common/debug.h"
+#include "common/path.h"
+#include "arch/db.h"
+#include "fs/notify.h"
+#include "fs/tree.h"
+#include "indexer.h"
+
+static char *stack[256];
+static unsigned char st_size = 0;
+static struct tree *current = NULL;
+
+/* REF:1 */
+static void index_entry(struct entry *ent) {
+
+    static char buf[1024];
+
+    arch_db_insert(ent->base, ent->name, ent->dir);
+    
+    if (ent->dir) {
+        memcpy(buf, ent->base, strlen(ent->base));
+        memcpy(buf + strlen(ent->base), ent->name, strlen(ent->name)+1);
+        notify_add_watch(buf);
+    }
+    
+#ifdef __DEBUG__
+    printf("Index: %s%s\n", ent->base, ent->name);
+#endif
+}
+
+static void add(const char *path) {
+	
+	char *newstr;
+	
+	if (st_size >= 255)
+		return;
+	
+	newstr = malloc(sizeof(char) * (strlen(path)+1));
+	
+	if (newstr == NULL)
+		return;
+	
+	memcpy(newstr, path, strlen(path)+1);
+	
+	stack[st_size] = newstr;
+	
+	st_size++;
+}
+
+/* we only shift the stack when getting the 
+ * next tree, so this will do for now. */
+static int rm() {
+	
+	int i;
+	
+	current = NULL;
+	
+	while(current == NULL) {
+		
+		if (st_size == 0)
+			return 0;
+	
+		current = tree_new(stack[0]);
+		
+		free(stack[0]);
+	
+		st_size--;
+	
+		for(i=0; i < st_size; i++)
+			stack[i] = stack[i+1];
+	}
+	
+	return 1;
+}
+
+void indexer_register(const char *base, const char *name) {
+	
+    char *fullpath = fmt_path(base, name, 1);
+    
+	if (!indexer_pending()) {
+#if __DEBUG__
+		printf("sched: adding current index: %s\n", fullpath);
+#endif
+		current = tree_new(fullpath);
+		free(fullpath);
+		return;
+	}
+	
+#if __DEBUG__
+		printf("sched: scheduling index: %s\n", fullpath);
+#endif
+	
+	add(fullpath);
+}
+
+void indexer_run(unsigned int num) {
+	
+	struct entry *ent;
+	
+	int i;
+	
+	for(i=0; i < num; i++) {
+		
+		ent = tree_next_ent(current);
+		
+		if (ent == NULL) {
+			
+			if (rm())
+				continue;
+			
+			return;
+		}
+		
+        index_entry(ent);
+	}
+}
+
+inline int indexer_pending() {
+	return current != NULL || st_size;
+}

src/indexer.h

@@ -0,0 +1,12 @@
+
+#ifndef _INDEXER_H
+
+#define _INDEXER_H
+
+void indexer_register(const char *base, const char *name);
+
+void indexer_run();
+
+inline int indexer_pending();
+
+#endif /* _INDEXER_H */