/*
 * Copyright 2004-2010, François Revol, <revol@free.fr>.
 * Distributed under the terms of the MIT License.
 */

/*
 * websearchfs - a bookmark-populated virtual filesystem using DuckDuckGo results.
 */

#define _BUILDING_fs 1

#include <sys/param.h>
#include <sys/stat.h>
#include <malloc.h>
#include <KernelExport.h>
//#include <NodeMonitor.h>
#include <stddef.h>
#include <stdio.h>
#include <signal.h>
#include <string.h>
#include <fs_query.h>
#include "query.h"
#include "websearchfs.h"
#include "vnidpool.h"
#include "duckduckgo_request.h"
#include "settings.h"

/* just publish fake entries; for debugging */
//#define NO_SEARCH

#define PFS "websearchfs: "

#define TRACE_WEBSEARCHFS
#ifdef TRACE_WEVSEARCHFS
#	define TRACE(x...) fprintf(stderr, PFS x)
#else
#	define TRACE(x...)
#endif


/* needed to get /bin/df tell the mountpoint... */
#define ALLOW_DIR_OPEN

int32 refcount = 0;


extern struct attr_entry root_folder_attrs[];
extern struct attr_entry folders_attrs[];
extern struct attr_entry bookmark_attrs[];
extern struct attr_entry fake_bookmark_attrs[]; /* for debugging */
extern struct attr_entry template_1_attrs[];
extern struct attr_entry text_attrs[];
extern struct attr_entry mailto_me_bookmark_attrs[];

extern char *readmestr;

static fs_volume_ops sWebSearchFSVolumeOps;
static fs_vnode_ops sWebSearchFSVnodeOps;


static int websearchfs_create_gen(fs_volume *_volume, fs_node *dir, const char *name, int omode, int perms, ino_t *vnid, fs_node **node, struct attr_entry *iattrs, bool mkdir, bool uniq);
static int websearchfs_free_vnode(fs_volume *_volume, fs_node *node);

static void fill_default_stat(struct stat *st, nspace_id nsid, ino_t vnid, mode_t mode)
{
	time_t tm = time(NULL);
	st->st_dev = nsid;
	st->st_ino = vnid;
	st->st_mode = mode;
	st->st_nlink = 1;
	st->st_uid = 0;
	st->st_gid = 0;
	st->st_size = 0LL;
	st->st_blksize = 1024;
	st->st_atime = tm;
	st->st_mtime = tm;
	st->st_ctime = tm;
	st->st_crtime = tm;
}

/**	Publishes some entries in the root vnode: a query template, the readme file, and a People file of the author.
 */
static int websearchfs_publish_static_entries(fs_volume *_volume)
{
	fs_nspace *ns = (fs_nspace *)_volume->private_volume;
	status_t err = B_OK;
	fs_node *dir = ns->root;
	fs_node *n;// *dummy;
	//char ename[WEBSEARCHFS_NAME_LEN];
	//char *p;
	//int i;
	TRACE("websearchfs_publish_static_entries(%" B_PRId32 ")\n", ns->nsid);
	if (!ns || !dir)
		return EINVAL;

	err = websearchfs_create_gen(_volume, dir, "Search the Web", 0, 0444, NULL, &n, template_1_attrs, false, true);
	if (err)
		return err;
	n->is_perm = 1;

	err = websearchfs_create_gen(_volume, dir, "README", 0, 0444, NULL, &n, text_attrs, false, true);
	if (err)
		return err;
	n->is_perm = 1;
	n->data = readmestr;
	n->data_size = strlen(n->data);// + 1;

	err = websearchfs_create_gen(_volume, dir, "Author", 0, 0444, NULL, &n, mailto_me_bookmark_attrs, false, true);
	if (err)
		return err;
	n->is_perm = 1;

	return B_OK;

/*
err:
	TRACE("push_result_to_query: error 0x%08"B_PRIx32"\n", err);
	return err;
*/
}

static status_t websearchfs_mount(fs_volume *_vol, const char *devname, uint32 flags,
		const char *parms, ino_t *vnid)
{
	fs_nspace *ns;
	fs_node *root;
	int err;
	TRACE("mount(%p, %s, 0x%08" B_PRIx32 ", %s, , )\n", _vol, devname, flags, parms);

	/* only allow a single mount */
	if (atomic_add(&refcount, 1))
		return EALREADY;

	err = load_settings();

	ns = malloc(sizeof(fs_nspace));
	if (!ns)
		return B_NO_MEMORY;
	memset(ns, 0, sizeof(fs_nspace));
	ns->nsid = _vol->id;

	err = vnidpool_alloc(&ns->vnids, MAX_VNIDS);
	if (err < 0)
		return err;
	err = vnidpool_get(ns->vnids, &ns->rootid);
	if (err < 0)
		return err;
	atomic_add(&ns->nodecount, 1);

	new_lock(&(ns->l), "websearchfs main lock");

	ns->nodes = NULL;

	/* create root dir */
	err = B_NO_MEMORY;
	root = malloc(sizeof(fs_node));
	ns->root = root;
	if (root) {
		memset(root, 0, sizeof(fs_node));
		strcpy(root->name, ".");
		root->is_perm = 1;
		root->vnid = ns->rootid;
		fill_default_stat(&root->st, ns->nsid, ns->rootid, 0777 | S_IFDIR);
		root->attrs_indirect = root_folder_attrs;
		new_lock(&(root->l), "websearchfs root dir");
		TRACE("mount: root->l @ %p\n", &root->l);

		_vol->private_volume = ns;
		_vol->ops = &sWebSearchFSVolumeOps;
		*vnid = ns->rootid;
		ns->nodes = root; // sll_insert
		err = publish_vnode(_vol, *vnid, root, &sWebSearchFSVnodeOps, S_IFDIR, 0);
		if (err == B_OK) {
			websearchfs_publish_static_entries(_vol);
			TRACE("mount() OK, nspace@ %p, id %" B_PRId32 ", root@ %p, id %" B_PRId64 "\n", ns, ns->nsid, root, ns->rootid);
			return B_OK;
		}
		free_lock(&root->l);
		free(root);
	}
	free_lock(&ns->l);
	free(ns);
	atomic_add(&refcount, -1);
	return err;
}

static status_t websearchfs_unmount(fs_volume *_volume)
{
	fs_nspace *ns = (fs_nspace *)_volume->private_volume;
	status_t err;
	struct fs_node *node;
	TRACE("unmount(%" B_PRId32 ")\n", ns->nsid);
	err = LOCK(&ns->l);
	if (err)
		return err;
	/* anything in still in use ? */
	for (node = ns->nodes; node; node = ns->nodes) {
		ns->nodes = node->nlnext; /* better cache that before we free node */
		websearchfs_free_vnode(_volume, node);
	}

	// Unlike in BeOS, we need to put the reference to our root node ourselves
	put_vnode(_volume, ns->rootid);

	free_lock(&ns->l);
	vnidpool_free(ns->vnids);
	free(ns);

	atomic_add(&refcount, -1);

	return B_OK;
}

static int compare_fs_node_by_vnid(fs_node *node, ino_t *id)
{
	return !(node->vnid == *id);
}

static int websearchfs_free_vnode(fs_volume *_volume, fs_node *node)
{
	fs_nspace *ns = (fs_nspace *)_volume->private_volume;
	TRACE("%s(%" B_PRId32 ", %" B_PRId64 ")\n", __FUNCTION__, ns->nsid, node->vnid);
	free_lock(&node->l);
	atomic_add(&ns->nodecount, -1);
	vnidpool_put(ns->vnids, node->vnid);
	if (node->request)
		duckduckgo_request_free(node->request);
	free(node->result);
	free(node);
	return 0;
}

static status_t websearchfs_remove_vnode(fs_volume *_volume, fs_vnode *_node, bool reenter)
{
	fs_nspace *ns = (fs_nspace *)_volume->private_volume;
	fs_node *node = (fs_node *)_node->private_node;
	status_t err = B_OK;
	TRACE("%s(%" B_PRId32 ", %" B_PRId64 ", %s)\n", __FUNCTION__, ns->nsid, node->vnid, reenter?"r":"!r");
	if (!reenter)
		err = LOCK(&ns->l);
	if (err)
		return err;
	if (node->vnid == ns->rootid) {
		TRACE("asked to remove the root node!!\n");
	}
TRACE("SLL_REMOVE(ns->nodes %p, nlnext, %p)\n", ns->nodes, node);
	//LOCK(&node->l);
	err = SLL_REMOVE(ns->nodes, nlnext, node);
	/* query dirs must be removed from the query list too */
TRACE("SLL_REMOVE(ns->queries %p, qnext, %p)\n", ns->nodes, node);
	err = SLL_REMOVE(ns->queries, qnext, node);
	if (node->parent) {
		LOCK(&node->parent->l);
TRACE("SLL_REMOVE(node->parent->children %p, next, %p)\n", node->parent->children, node);
		SLL_REMOVE(node->parent->children, next, node);
		UNLOCK(&node->parent->l);
	}
	websearchfs_free_vnode(_volume, node);
	if (!reenter)
		UNLOCK(&ns->l);
	return err;
}

static status_t websearchfs_read_vnode(fs_volume *_volume, ino_t vnid, fs_vnode *_node, int* _type, uint32* _flags, bool reenter)
{
	fs_nspace *ns = (fs_nspace *)_volume->private_volume;
	fs_node *n;
	status_t err = B_OK;
	TRACE("%s(%" B_PRId32 ", %" B_PRId64 ", %s)\n", __FUNCTION__, _volume->id, vnid, reenter?"r":"!r");
	if (!reenter)
		err = LOCK(&ns->l);
	if (err)
		return err;
	n = (fs_node *)SLL_FIND(ns->nodes, nlnext, (sll_compare_func)compare_fs_node_by_vnid, (void *)&vnid);
	if (n) {
		_node->private_node = n;
		_node->ops = &sWebSearchFSVnodeOps;
		*_type = n->st.st_mode & ~S_IUMSK; /*XXX: S_IFMT ?*/
		*_flags = 0;

	} else
		err = ENOENT;
	if (!reenter)
		UNLOCK(&ns->l);
	return err;
}

static status_t websearchfs_release_vnode(fs_volume *_volume, fs_vnode *_node, bool reenter)
{
	fs_node *node = (fs_node *)_node->private_node;
	TRACE("%s(%" B_PRId32 ", %" B_PRId64 ", %s)\n", __FUNCTION__, _volume->id, node->vnid, reenter?"r":"!r");
	return B_OK;
}

static int compare_fs_node_by_name(fs_node *node, char *name)
{
	//return memcmp(node->name, name, WEBSEARCHFS__NAME_LEN);
	//TRACE("find_by_name: '%s' <> '%s'\n", node->name, name);
	return strncmp(node->name, name, WEBSEARCHFS_NAME_LEN);
}

static status_t websearchfs_get_vnode_name(fs_volume *_volume, fs_vnode *_node, char *buffer, size_t len)
{
	fs_nspace *ns = (fs_nspace *)_volume->private_volume;
	fs_node *node = (fs_node *)_node->private_node;

	TRACE("get_vnode_name(%" B_PRId32 ", %" B_PRId64 ", )\n", ns->nsid, (int64)(node?node->vnid:-1));
	strlcpy(buffer, node->name, MIN(WEBSEARCHFS_NAME_LEN, len));
	return B_OK;
}


static status_t websearchfs_walk(fs_volume *_volume, fs_vnode *_base, const char *file, ino_t *vnid)
{
	fs_nspace *ns = (fs_nspace *)_volume->private_volume;
	fs_node *base = _base->private_node;
	fs_node *n, *dummy;
	status_t err = B_OK;
	TRACE("walk(%" B_PRId32 ", %" B_PRId64 ", %s)\n", ns->nsid, (int64)(base?base->vnid:-1), file);
	err = LOCK(&base->l);
	if (err)
		return err;
	if (!file) {
		err = EINVAL;
	} else if (!strcmp(file, "..")) {
		if (base && base->parent) {
			*vnid = base->parent->vnid; // XXX: LOCK(&base->l) ?
			//*type = S_IFDIR;
		} else
			err = EINVAL;
	} else if (!strcmp(file, ".")) { /* root dir */
		if (base) { // XXX: LOCK(&base->l) ?
			*vnid = base->vnid;
			//*type = S_IFDIR;
		} else
			err = EINVAL;
	} else if (base) { /* child of dir */
		n = (fs_node *)SLL_FIND(base->children, next,
								(sll_compare_func)compare_fs_node_by_name, (void *)file);
		if (n) {
			*vnid = n->vnid;
			//*type = n->st.st_type & ~S_IUMSK; /*XXX: S_IFMT ?*/
		} else
			err = ENOENT;
	} else
		err = ENOENT;
	if (err == B_OK) {
		if (get_vnode(_volume, *vnid, (void **)&dummy) != B_OK) /* inc ref count */
			err = EINVAL;
	}
	UNLOCK(&base->l);
	TRACE("walk() -> error 0x%08" B_PRIx32 "\n", err);
	return err;
}

static status_t websearchfs_opendir(fs_volume *_volume, fs_vnode *_node, void **cookie)
{
	fs_nspace *ns = (fs_nspace *)_volume->private_volume;
	fs_node *node = (fs_node *)_node->private_node;
	status_t err = B_OK;
	fs_dir_cookie *c;
	TRACE("opendir(%" B_PRId32 ", %" B_PRId64 ")\n", ns->nsid, node->vnid);
	if (!node)
		return EINVAL;
	if (!S_ISDIR(node->st.st_mode))
		return B_NOT_A_DIRECTORY;
	err = LOCK(&node->l);
	if (err)
		return err;
	c = malloc(sizeof(fs_dir_cookie));
	if (c) {
		memset(c, 0, sizeof(fs_dir_cookie));
		c->omode = O_RDONLY;
		c->type = S_IFDIR;
		c->node = node;
		c->dir_current = 0;
		*cookie = (void *)c;
		SLL_INSERT(node->opened, next, c);
		UNLOCK(&node->l);
		return B_OK;
	} else
		err = B_NO_MEMORY;
	UNLOCK(&node->l);
	return err;
}

static status_t websearchfs_closedir(fs_volume *_volume, fs_vnode *_node, void *_cookie)
{
	fs_nspace *ns = (fs_nspace *)_volume->private_volume;
	fs_node *node = (fs_node *)_node->private_node;
	fs_dir_cookie *cookie = (fs_dir_cookie *)_cookie;
	status_t err = B_OK;
//	node = cookie->node; // work around VFS bug
	TRACE("closedir(%" B_PRId32 ", %" B_PRId64 ", %p)\n", ns->nsid, node->vnid, cookie);
	err = LOCK(&node->l);
	if (err)
		return err;

	SLL_REMOVE(node->opened, next, cookie);
	UNLOCK(&node->l);

	return err;
}

static status_t websearchfs_rewinddir(fs_volume *_volume, fs_vnode *_node, void *_cookie)
{
	fs_nspace *ns = (fs_nspace *)_volume->private_volume;
	fs_node *node = (fs_node *)_node->private_node;
	fs_dir_cookie *cookie = (fs_dir_cookie *)_cookie;
	TRACE("rewinddir(%" B_PRId32 ", %" B_PRId64 ")\n", ns->nsid, node->vnid);
	cookie->dir_current = 0;
	return B_OK;
}

static status_t websearchfs_readdir(fs_volume *_volume, fs_vnode *_node, void *_cookie,
	struct dirent *buf, size_t bufsize, uint32 *num)
{
	fs_nspace *ns = (fs_nspace *)_volume->private_volume;
	fs_node *node = (fs_node *)_node->private_node;
	fs_dir_cookie *cookie = (fs_dir_cookie *)_cookie;
	fs_node *n = NULL;
	fs_node *parent = node->parent;
	int index;
	TRACE("readdir(%" B_PRId32 ", %" B_PRId64 ") @ %d\n", ns->nsid, node->vnid,
		cookie->dir_current);
	if (!node || !cookie || !num || !*num || !buf
		|| (bufsize < (sizeof(dirent_t) + WEBSEARCHFS_NAME_LEN)))
		return EINVAL;
	LOCK(&node->l);
	if (cookie->dir_current == 0) { /* .. */
		TRACE("readdir: giving ..\n");
		/* the VFS will correct that anyway */
		buf->d_dev = ns->nsid;
		buf->d_pdev = ns->nsid;
		buf->d_ino = parent?parent->vnid:ns->rootid;
		buf->d_pino = (parent && parent->parent)?parent->parent->vnid:ns->rootid;
		strcpy(buf->d_name, "..");
		buf->d_reclen = offsetof(struct dirent, d_name)+strlen(buf->d_name)+1;
		cookie->dir_current++;
		*num = 1;
	} else if (cookie->dir_current == 1) { /* . */
		TRACE("readdir: giving .\n");
		/* the VFS will correct that anyway */
		buf->d_dev = ns->nsid;
		buf->d_pdev = ns->nsid;
		buf->d_ino = node->vnid;
		buf->d_pino = parent?parent->vnid:ns->rootid;
		strcpy(buf->d_name, ".");
		buf->d_reclen = offsetof(struct dirent, d_name)+strlen(buf->d_name)+1;
		cookie->dir_current++;
		*num = 1;
	} else {
		index = cookie->dir_current-2;
		for (n = node->children; n && index; n = n->next, index--); //XXX: care about n->hidden || n->deleted
		if (n) {
			TRACE("readdir: giving ino %" B_PRId64 ", %s\n", n->vnid, n->name);
			buf->d_dev = ns->nsid;
			buf->d_pdev = ns->nsid;
			buf->d_ino = n->vnid;
			buf->d_pino = node->vnid;
			strcpy(buf->d_name, n->name);
			buf->d_reclen = offsetof(struct dirent, d_name)+strlen(buf->d_name)+1;
			cookie->dir_current++;
			*num = 1;
		} else {
			*num = 0;
		}
	}
	UNLOCK(&node->l);
	return B_OK;
}

static status_t websearchfs_free_dircookie(fs_volume *_volume, fs_vnode *_node, void *_cookie)
{
	fs_nspace *ns = (fs_nspace *)_volume->private_volume;
	fs_node *node = (fs_node *)_node->private_node;
	fs_dir_cookie *cookie = (fs_dir_cookie *)_cookie;
	status_t err = B_OK;
//	node = cookie->node; // work around VFS bug
	TRACE("freedircookie(%" B_PRId32 ", %" B_PRId64 ", %p)\n", ns->nsid, node?node->vnid:(int64)0, (void *)cookie);
	err = LOCK(&node->l);
	if (err)
		return err;
	err = SLL_REMOVE(node->opened, next, cookie); /* just to make sure */
	UNLOCK(&node->l);
	free(cookie);
	return B_OK;
}

static status_t websearchfs_rstat(fs_volume *_volume, fs_vnode *_node, struct stat *st)
{
	fs_nspace *ns = (fs_nspace *)_volume->private_volume;
	fs_node *node = (fs_node *)_node->private_node;
	status_t err = B_OK;
	if (!node || !st)
		return EINVAL;
	err = LOCK(&node->l);
	if (err)
		return err;
	memcpy(st, &node->st, sizeof(struct stat));
	st->st_dev = ns->nsid;
	st->st_ino = node->vnid;
	if (node->data_size)
		st->st_size = node->data_size;
	//st->st_size = 0LL;
	UNLOCK(&node->l);
	return err;
}

static status_t websearchfs_rfsstat(fs_volume *_volume, struct fs_info *info)
{
	fs_nspace *ns = (fs_nspace *)_volume->private_volume;
	info->block_size = 1024; // websearchfs_BUFF_SIZE;
	info->io_size = 1024; // WEBSEARCHFS_BUFF_SIZE;
	info->total_blocks=0;
	info->free_blocks=0;
	info->total_nodes=MAX_VNIDS;
	info->free_nodes=ns->nodecount;
	info->dev=ns->nsid;
	info->root=ns->rootid;
	info->flags=/*B_FS_IS_SHARED|*/B_FS_IS_PERSISTENT|B_FS_HAS_MIME|B_FS_HAS_ATTR|B_FS_HAS_QUERY;
	strcpy (info->device_name, "");
	strcpy (info->volume_name, "Web Search");
	strcpy (info->fsh_name, WEBSEARCHFS_NAME);
	return B_OK;
}

static status_t websearchfs_open(fs_volume *_volume, fs_vnode *_node, int omode, void **cookie)
{
	fs_nspace *ns = (fs_nspace *)_volume->private_volume;
	fs_node *node = (fs_node *)_node->private_node;
	status_t err = B_OK;
	//fs_node *dummy;
	fs_file_cookie *fc;
	TRACE("open(%" B_PRId32 ", %" B_PRId64 ", 0x%x)\n", ns->nsid, node->vnid, omode);
	if (!node || !cookie)
		return EINVAL;

//	err = LOCK(&ns->l);
//	if (err)
//		return err;
	err = LOCK(&node->l);
	if (err)
		goto err_n_l;
	err = EEXIST;
#ifndef ALLOW_DIR_OPEN
	err = EINVAL;//EISDIR;
	if (S_ISDIR(node->st.st_mode))
		goto err_malloc;
#endif
	err = B_NO_MEMORY;
	fc = malloc(sizeof(fs_file_cookie));
	if (!fc)
		goto err_malloc;
	memset(fc, 0, sizeof(fs_file_cookie));
	fc->node = node;
	fc->omode = omode;
	fc->type = S_IFREG;
	err = SLL_INSERT(node->opened, next, fc);
	if (err)
		goto err_linsert;
/*	err = get_vnode(ns->nsid, node->vnid, &dummy);
	if (err)
		goto err_getvn;*/
	//*vnid = node->vnid;
	*cookie = (void *)fc;
	err = B_OK;
	goto all_ok;
//err_:
//	put_vnode(ns->nsid, node->nsid);
//err_getvn:
//	SLL_REMOVE(node->opened, next, fc);
err_linsert:
	free(fc);
err_malloc:
all_ok:
	UNLOCK(&node->l);
err_n_l:
//	UNLOCK(&ns->l);
	return err;
}

static status_t websearchfs_close(fs_volume *_volume, fs_vnode *_node, void *_cookie)
{
	fs_nspace *ns = (fs_nspace *)_volume->private_volume;
	fs_node *node = (fs_node *)_node->private_node;
	fs_file_cookie *cookie = (fs_file_cookie *)_cookie;
	status_t err;
	TRACE("close(%" B_PRId32 ", %" B_PRId64 ")\n", ns->nsid, node->vnid);
	if (!ns || !node || !cookie)
		return EINVAL;
	err = LOCK(&node->l);
	if (err)
		return err;
	SLL_REMOVE(node->opened, next, cookie);

//all_ok:
//err_n_l:
	UNLOCK(&node->l);
	return err;
}

static status_t websearchfs_free_cookie(fs_volume *_volume, fs_vnode *_node, void *_cookie)
{
	fs_nspace *ns = (fs_nspace *)_volume->private_volume;
	fs_node *node = (fs_node *)_node->private_node;
	fs_file_cookie *cookie = (fs_file_cookie *)_cookie;
	status_t err = B_OK;
	TRACE("freecookie(%" B_PRId32 ", %" B_PRId64 ")\n", ns->nsid, node->vnid);
	err = LOCK(&node->l);
	if (err)
		return err;
	err = SLL_REMOVE(node->opened, next, cookie); /* just to make sure */
//	if (err)
//		goto err_n_l;
	if (/*!node->is_perm &&*/ false) { /* not yet */
		err = remove_vnode(_volume, node->vnid);
		ns->root->st.st_mtime = time(NULL);
#if 0
		notify_listener(B_ENTRY_REMOVED, ns->nsid, ns->rootid, 0LL, node->vnid, NULL);
		notify_listener(B_STAT_CHANGED, ns->nsid, 0LL, 0LL, ns->rootid, NULL);
#endif
	}
	UNLOCK(&node->l);
	free(cookie);
//	err = B_OK;
//err_n_l:
	return err;
}

static status_t websearchfs_read(fs_volume *_volume, fs_vnode *_node, void *_cookie, off_t pos, void *buf, size_t *len)
{
	fs_nspace *ns = (fs_nspace *)_volume->private_volume;
	fs_node *node = (fs_node *)_node->private_node;
	status_t err = B_OK;
	TRACE("read(%" B_PRId32 ", %" B_PRId64 ", %jd, %zu)\n", ns->nsid, node->vnid, pos, *len);
	if (pos < 0 || (size_t)pos > node->data_size)
		err = EFPOS;
	if (err || node->data_size == 0 || !node->data) {
		*len = 0;
		return err;
	}
	*len = MIN(*len, node->data_size - (long)pos);
	memcpy(buf, ((char *)node->data) + pos, *len);
	return B_OK;
}

static status_t websearchfs_write(fs_volume *_volume, fs_vnode *_node, void *_cookie, off_t pos, const void *buf, size_t *len)
{
	fs_node *node = (fs_node *)_node->private_node;
	TRACE("write(%" B_PRId32 ", %" B_PRId64 ", %jd, %zu)\n", _volume->id, node->vnid, pos, *len);
	*len = 0;
	return ENOSYS;
}

static status_t websearchfs_wstat(fs_volume *_volume, fs_vnode *_node, const struct stat *st, uint32 mask)
{
	fs_node *node = (fs_node *)_node->private_node;
	TRACE("wstat(%" B_PRId32 ", %" B_PRId64 ", , 0x%08" B_PRIx32 ")\n", _volume->id, node->vnid, mask);
	return ENOSYS;
}

static status_t websearchfs_wfsstat(fs_volume *_volume, const struct fs_info *info, uint32 mask)
{
	TRACE("wfsstat(%" B_PRId32 ", , 0x%08" B_PRIx32 ")\n", _volume->id, mask);
	return ENOSYS;
}

/* this one returns the created fs_node to caller (for use by query engine) */
/**
 * @param dir the dir's fs_node we mkdir in
 * @param name name to mkdir (basename is uniq is set)
 * @param perms create with those permissions
 * @param node make this point to the fs_node if !NULL
 * @param iattr indirect attributes to set if desired (must be statically allocated)
 * @param mkdir create a directory instead of a file
 * @param uniq choose an unique name, appending a number if required
 */
static int websearchfs_create_gen(fs_volume *_volume, fs_node *dir, const char *name, int omode, int perms, ino_t *vnid, fs_node **node, struct attr_entry *iattrs, bool mkdir, bool uniq)
{
	fs_nspace *ns = (fs_nspace *)_volume->private_volume;
	//fs_node *dir = (fs_node *)_dir->private_node;
	char newname[WEBSEARCHFS_NAME_LEN];
	status_t err;
	fs_node *n;
	int i;
	TRACE("create_gen(%" B_PRId32 ", %" B_PRId64 ", '%s', 0x%08x, %c, %c)\n", ns->nsid, dir->vnid, name, omode, mkdir?'t':'f', uniq?'t':'f');

	if (strlen(name) > WEBSEARCHFS_NAME_LEN-1)
		return ENAMETOOLONG;
	err = LOCK(&dir->l);
	if (err < 0)
		return err;
	err = ENOTDIR;
	if (!S_ISDIR(dir->st.st_mode))
		goto err_l;
	n = (fs_node *)SLL_FIND(dir->children, next,
							(sll_compare_func)compare_fs_node_by_name, (void *)name);
	err = EEXIST;
	if (n && (omode & O_EXCL) && !uniq) /* already existing entry in there! */
		goto err_l;

	strncpy(newname, name, WEBSEARCHFS_NAME_LEN);
	newname[WEBSEARCHFS_NAME_LEN-1] = '\0';

	for (i = 1; uniq && n && i < 5000; i++) { /* uniquify the name */
		//sprintf("%"#(WEBSEARCHFS_NAME_LEN-8)"s %05d", name, i);
		strncpy(newname, name, 56);
		newname[56] = '\0';
		sprintf(newname+strlen(newname), " %05d", i);
		n = (fs_node *)SLL_FIND(dir->children, next,
								(sll_compare_func)compare_fs_node_by_name, (void *)newname);
	}
	if (n && (uniq || mkdir)) /* still there! */
		goto err_l;
	name = newname;

	if (n) { /* already exists, so return it */
		if (node)
			*node = n;
		if (vnid)
			*vnid = n->vnid;
		err = B_OK;
		goto done;
	}
	err = ENOMEM;
	n = malloc(sizeof(fs_node));
	if (!n)
		goto err_l;
	memset(n, 0, sizeof(fs_node));
	err = vnidpool_get(ns->vnids, &n->vnid);
	if (err < B_OK)
		goto err_m;
	atomic_add(&ns->nodecount, 1);
	strcpy(n->name, name);
	//n->is_perm = 1;
	fill_default_stat(&n->st, ns->nsid, n->vnid, (perms & ~S_IFMT) | (mkdir?S_IFDIR:S_IFREG));

	new_lock(&(n->l), mkdir?"websearchfs dir":"websearchfs file");

	err = LOCK(&ns->l);
	if (err)
		goto err_nl;
	err = SLL_INSERT(ns->nodes, nlnext, n);
	if (err)
		goto err_lns;
	/* _TAIL so they are in order */
	err = SLL_INSERT(dir->children, next, n);
	if (err)
		goto err_insnl;
//	err = new_vnode(ns->nsid, n->vnid, n);
//	if (err)
//		goto err_ins;
	n->parent = dir;
	dir->st.st_nlink++;
	UNLOCK(&ns->l);
	n->attrs_indirect = iattrs;
	notify_entry_created(ns->nsid, dir->vnid, name, n->vnid);
	/* dosfs doesn't do that one but I believe it should */
	notify_stat_changed(B_STAT_CHANGED, -1, ns->nsid, -1);
	/* give node to caller if it wants it */
	if (node)
		*node = n;
	if (vnid)
		*vnid = n->vnid;
	goto done;

err_insnl:
	SLL_REMOVE(ns->nodes, nlnext, n);
err_lns:
	UNLOCK(&ns->l);
err_nl:
	free_lock(&n->l);
	atomic_add(&ns->nodecount, -1);
err_m:
	free(n);
err_l:
done:
	UNLOCK(&dir->l);
	return err;
}

static status_t websearchfs_create(fs_volume *_volume, fs_vnode *_dir, const char *name, int omode, int perms, void **cookie, ino_t *vnid)
{
	fs_nspace *ns = (fs_nspace *)_volume->private_volume;
	fs_node *dir = (fs_node *)_dir->private_node;
	status_t err;
	fs_node *n;
	struct fs_vnode child = { NULL, &sWebSearchFSVnodeOps };
	TRACE("create(%" B_PRId32 ", %" B_PRId64 ", '%s', 0x%08x)\n", ns->nsid, dir->vnid, name, omode);
	/* don't let ppl mess our fs up */
	return ENOSYS;

	err = websearchfs_create_gen(_volume, dir, name, omode, perms, vnid, &n, NULL, false, false);
	if (err)
		return err;

	child.private_node = (void *)n;
	err = websearchfs_open(_volume, &child, omode, cookie);
	return err;
}

static int websearchfs_unlink_gen(fs_volume *_volume, fs_node *dir, const char *name)
{
	fs_nspace *ns = (fs_nspace *)_volume->private_volume;
	status_t err;
	fs_node *n;
	TRACE("unlink(%" B_PRId32 ", %" B_PRId64 ", %s)\n", ns->nsid, dir->vnid, name);
	//dprintf(PFS"unlink(%" B_PRId32 ", %" B_PRId64 ", %s)\n", ns->nsid, dir->vnid, name);
	err = LOCK(&dir->l);
	if (err)
		return err;
	err = ENOENT;
	/* no need to check for S_ISDIR */
	n = (fs_node *)SLL_FIND(dir->children, next,
							(sll_compare_func)compare_fs_node_by_name, (void *)name);
	if (n) {
		if (n->children)
			err = ENOTEMPTY;
		else if (n->is_perm)
			err = EROFS;
		//else if (S_ISDIR(n->st.st_mode))
		//	err = EISDIR;
		else if (n->vnid == ns->rootid)
			err = EACCES;
		else {
			SLL_REMOVE(dir->children, next, n);
			notify_entry_removed(ns->nsid, dir->vnid, name, n->vnid);
			//notify_listener(B_STAT_CHANGED, ns->nsid, 0LL, 0LL, dir->vnid, NULL);
			remove_vnode(_volume, n->vnid);
			err = B_OK;
		}
	}
	UNLOCK(&dir->l);
	return err;
}

static status_t websearchfs_unlink(fs_volume *_volume, fs_vnode *_dir, const char *name)
{
	//fs_nspace *ns = (fs_nspace *)_volume->private_volume;
	//fs_node *dir = (fs_node *)_dir->private_node;
	return websearchfs_unlink_gen(_volume, (fs_node *)_dir->private_node, name);
}

static status_t websearchfs_rmdir(fs_volume *_volume, fs_vnode *_dir, const char *name)
{
	//fs_nspace *ns = (fs_nspace *)_volume->private_volume;
	fs_node *dir = (fs_node *)_dir->private_node;
	TRACE("rmdir(%" B_PRId32 ", %" B_PRId64 ", %s)\n", _volume->id, dir->vnid, name);
	return websearchfs_unlink(_volume, _dir, name);
}

static int websearchfs_unlink_node_rec(fs_volume *_volume, fs_node *node)
{
	fs_nspace *ns = (fs_nspace *)_volume->private_volume;
	status_t err;
	fs_node *n;
	TRACE("websearchfs_unlink_node_rec(%" B_PRId32 ", %" B_PRId64 ":%s)\n", ns->nsid, node->vnid, node->name);
	if (!ns || !node)
		return EINVAL;
	// kill_request();
	LOCK(&node->l);
	while (1) {
		n = node->children;
		if (!n)
			break;
		UNLOCK(&node->l);
		err = websearchfs_unlink_node_rec(_volume, n);
		LOCK(&node->l);
	}
	UNLOCK(&node->l);
	err = websearchfs_unlink_gen(_volume, node->parent, node->name);
	return err;
}

static status_t websearchfs_access(fs_volume *_volume, fs_vnode *_node, int mode)
{
	fs_nspace *ns = (fs_nspace *)_volume->private_volume;
	fs_node *node = (fs_node *)_node->private_node;
	TRACE("access(%" B_PRId32 ", %" B_PRId64 ", 0x%x)\n", ns->nsid, node->vnid, mode);
	return B_OK;
}


static status_t websearchfs_mkdir(fs_volume *_volume, fs_vnode *_dir, const char *name, int perms)
{
	fs_nspace *ns = (fs_nspace *)_volume->private_volume;
	fs_node *dir = (fs_node *)_dir->private_node;
	TRACE("mkdir(%" B_PRId32 ", %" B_PRId64 ", '%s', 0x%08x)\n", ns->nsid, dir->vnid, name, perms);
	return websearchfs_create_gen(_volume, dir, name, O_EXCL, perms, NULL, NULL, folders_attrs, true, false);
}

/* attr stuff */

static status_t websearchfs_open_attrdir(fs_volume *_volume, fs_vnode *_node, void **cookie)
{
	fs_nspace *ns = (fs_nspace *)_volume->private_volume;
	fs_node *node = (fs_node *)_node->private_node;
	status_t err = B_OK;
	fs_attr_dir_cookie *c;
	TRACE("open_attrdir(%" B_PRId32 ", %" B_PRId64 ")\n", ns->nsid, node->vnid);
	if (!node)
		return EINVAL;
	err = LOCK(&node->l);
	if (err)
		return err;
	c = malloc(sizeof(fs_attr_dir_cookie));
	if (c) {
		memset(c, 0, sizeof(fs_attr_dir_cookie));
		c->omode = O_RDONLY;
		c->type = S_ATTR_DIR;
		c->node = node;
		c->dir_current = 0;
		*cookie = (void *)c;
		SLL_INSERT(node->opened, next, c);
		UNLOCK(&node->l);
		return B_OK;
	} else
		err = B_NO_MEMORY;
	UNLOCK(&node->l);
	return err;
}

static status_t websearchfs_close_attrdir(fs_volume *_volume, fs_vnode *_node, void *_cookie)
{
	fs_nspace *ns = (fs_nspace *)_volume->private_volume;
	fs_node *node = (fs_node *)_node->private_node;
	fs_attr_dir_cookie *cookie = (fs_attr_dir_cookie *)_cookie;
	status_t err = B_OK;
	TRACE("close_attrdir(%" B_PRId32 ", %" B_PRId64 ")\n", ns->nsid, node->vnid);
	err = LOCK(&node->l);
	if (err)
		return err;
	SLL_REMOVE(node->opened, next, cookie);
	UNLOCK(&node->l);
	return err;
}

static status_t websearchfs_free_attrdircookie(fs_volume *_volume, fs_vnode *_node, void *_cookie)
{
	fs_nspace *ns = (fs_nspace *)_volume->private_volume;
	fs_node *node = (fs_node *)_node->private_node;
	fs_attr_dir_cookie *cookie = (fs_attr_dir_cookie *)_cookie;
	status_t err = B_OK;
	TRACE("free_attrdircookie(%" B_PRId32 ", %" B_PRId64 ")\n", ns->nsid, node->vnid);
	err = LOCK(&node->l);
	if (err)
		return err;
	SLL_REMOVE(node->opened, next, cookie); /* just to make sure */
	UNLOCK(&node->l);
	free(cookie);
	return B_OK;
}

static status_t websearchfs_rewind_attrdir(fs_volume *_volume, fs_vnode *_node, void *_cookie)
{
	fs_nspace *ns = (fs_nspace *)_volume->private_volume;
	fs_node *node = (fs_node *)_node->private_node;
	fs_attr_dir_cookie *cookie = (fs_attr_dir_cookie *)_cookie;
	TRACE("rewind_attrdir(%" B_PRId32 ", %" B_PRId64 ")\n", ns->nsid, node->vnid);
	cookie->dir_current = 0;
	return B_OK;
}

static status_t websearchfs_read_attrdir(fs_volume *_volume, fs_vnode *_node, void *_cookie,
	struct dirent *buf, size_t bufsize, uint32 *num)
{
	fs_nspace *ns = (fs_nspace *)_volume->private_volume;
	fs_node *node = (fs_node *)_node->private_node;
	fs_file_cookie *cookie = (fs_file_cookie *)_cookie;
	//fs_node *n = NULL;
	//fs_node *parent = node->parent;
	attr_entry *ae = NULL;
	int i;
	int count_indirect;
	TRACE("read_attrdir(%" B_PRId32 ", %" B_PRId64 ") @ %d\n", ns->nsid, node->vnid,
		cookie->dir_current);
	if (!node || !cookie || !num || !*num || !buf
		|| (bufsize < (sizeof(dirent_t) + WEBSEARCHFS_NAME_LEN)))
		return EINVAL;
	LOCK(&node->l);
	for (i = 0, count_indirect = 0; node->attrs_indirect && !ae && node->attrs_indirect[i].name;
		i++, count_indirect++) {
		if (i == cookie->dir_current)
			ae = &node->attrs_indirect[i];
	}
	for (i = 0; !ae && i < 10 && node->attrs[i].name; i++) {
		if (i + count_indirect == cookie->dir_current)
			ae = &node->attrs[i];
	}

	if (ae) {
		TRACE("read_attrdir: giving %s\n", ae->name);
		buf->d_dev = ns->nsid;
		buf->d_pdev = ns->nsid;
		buf->d_ino = node->vnid;
		buf->d_pino = node->parent?node->parent->vnid:ns->rootid;
		strcpy(buf->d_name, ae->name);
		buf->d_reclen = offsetof(struct dirent, d_name)+strlen(buf->d_name)+1;
		cookie->dir_current++;
		*num = 1;
	} else
		*num = 0;

	UNLOCK(&node->l);
	return B_OK;
}

/* Haiku and BeOs differ in the way the handle attributes at the vfs layer.
   BeOS uses atomic calls on the vnode,
   Haiku retains the open/close/read/write semantics for attributes (loosing atomicity).
   Here we don't care much though, open is used for both to factorize attribute lookup. <- TODO
   _h suffixed funcs are for Haiku API, _b are for BeOS.
 */

/* for Haiku, but also used by BeOS calls to factorize code */
static status_t websearchfs_open_attr_h(fs_volume *_volume, fs_vnode *_node, const char *name, int omode, void **cookie)
{
	fs_nspace *ns = (fs_nspace *)_volume->private_volume;
	fs_node *node = (fs_node *)_node->private_node;
	status_t err = B_OK;
	//fs_node *dummy;
	fs_file_cookie *fc;
	attr_entry *ae = NULL;
	int i;
	TRACE("open_attr(%" B_PRId32 ", %" B_PRId64 ", %s, 0x%x)\n", ns->nsid, node->vnid, name, omode);
	if (!node || !name || !cookie)
		return EINVAL;

	err = LOCK(&node->l);
	if (err)
		goto err_n_l;

	/* lookup attribute */
	for (i = 0; node->attrs_indirect && !ae && node->attrs_indirect[i].name; i++)
		if (!strcmp(name, node->attrs_indirect[i].name))
			ae = &node->attrs_indirect[i];
	for (i = 0; !ae && i < 10 && node->attrs[i].name; i++)
		if (!strcmp(name, node->attrs[i].name))
			ae = &node->attrs[i];

	/* should check omode */
	err = ENOENT;
	if (!ae)
		goto err_malloc;
	err = EEXIST;

	err = B_NO_MEMORY;
	fc = malloc(sizeof(fs_file_cookie));
	if (!fc)
		goto err_malloc;
	memset(fc, 0, sizeof(fs_file_cookie));
	fc->node = node;
	fc->omode = omode;
	fc->type = S_ATTR;
	fc->attr = ae;
	err = SLL_INSERT(node->opened, next, fc);
	if (err)
		goto err_linsert;

	*cookie = (void *)fc;
	err = B_OK;
	goto all_ok;
//err_:
//	put_vnode(ns->nsid, node->nsid);
//err_getvn:
//	SLL_REMOVE(node->opened, next, fc);
err_linsert:
	free(fc);
err_malloc:
all_ok:
	UNLOCK(&node->l);
err_n_l:
//	UNLOCK(&ns->l);
	return err;
}

static status_t websearchfs_close_attr_h(fs_volume *_volume, fs_vnode *_node, void *_cookie)
{
	fs_nspace *ns = (fs_nspace *)_volume->private_volume;
	fs_node *node = (fs_node *)_node->private_node;
	fs_file_cookie *cookie = (fs_file_cookie *)_cookie;
	status_t err;
	TRACE("close_attr(%" B_PRId32 ", %" B_PRId64 ":%s)\n", ns->nsid, node->vnid,
		cookie->attr ? cookie->attr->name : "?");
	if (!ns || !node || !cookie)
		return EINVAL;
	err = LOCK(&node->l);
	if (err)
		return err;
	SLL_REMOVE(node->opened, next, cookie);

//all_ok:
//err_n_l:
	UNLOCK(&node->l);
	return err;
}

static status_t websearchfs_free_attr_cookie_h(fs_volume *_volume, fs_vnode *_node, void *_cookie)
{
	fs_nspace *ns = (fs_nspace *)_volume->private_volume;
	fs_node *node = (fs_node *)_node->private_node;
	fs_file_cookie *cookie = (fs_file_cookie *)_cookie;
	status_t err = B_OK;
	TRACE("free_attrcookie(%" B_PRId32 ", %" B_PRId64 ":%s)\n", ns->nsid, node->vnid,
		cookie->attr ? cookie->attr->name : "?");
	err = LOCK(&node->l);
	if (err)
		return err;
	err = SLL_REMOVE(node->opened, next, cookie); /* just to make sure */
//	if (err)
//		goto err_n_l;
	UNLOCK(&node->l);
	free(cookie);
//	err = B_OK;
//err_n_l:
	return err;
}

static status_t websearchfs_read_attr_stat(fs_volume *_volume, fs_vnode *_node, void *_cookie,
	struct stat *st)
{
	fs_nspace *ns = (fs_nspace *)_volume->private_volume;
	fs_node *node = (fs_node *)_node->private_node;
	fs_file_cookie *cookie = (fs_file_cookie *)_cookie;
	status_t err = B_OK;
	attr_entry *ae = cookie->attr;
	TRACE("stat_attr(%" B_PRId32 ", %" B_PRId64 ":%s)\n", ns->nsid, node->vnid, ae->name);
	if (!node || !st || !cookie || !cookie->attr)
		return EINVAL;
	memcpy(st, &node->st, sizeof(struct stat));
	st->st_type = ae->type;
	st->st_size = ae->size;
	err = B_OK;
	return err;
}

static status_t websearchfs_read_attr(fs_volume *_volume, fs_vnode *_node, void *_cookie,
	off_t pos, void *buf, size_t *len)
{
	fs_nspace *ns = (fs_nspace *)_volume->private_volume;
	fs_node *node = (fs_node *)_node->private_node;
	fs_file_cookie *cookie = (fs_file_cookie *)_cookie;
	status_t err = B_OK;
	attr_entry *ae = cookie->attr;
	TRACE("read_attr(%" B_PRId32 ", %" B_PRId64 ":%s)\n", ns->nsid, node->vnid, ae->name);
	if (!node || !cookie || !len || !*len)
		return EINVAL;

	err = LOCK(&node->l);

	if (ae && (pos < 0 || (size_t)pos < ae->size)) {
		memcpy(buf, (char *)ae->value + pos, MIN(*len, ae->size-pos));
		*len = MIN(*len, ae->size-pos);
		err = B_OK;
	} else {
		*len = 0;
		err = ENOENT;
	}

	UNLOCK(&node->l);
	return err;
}


/* query stuff */

static int compare_fs_node_by_recent_query_string(fs_node *node, char *query)
{
	time_t tm = time(NULL);
	//return memcmp(node->name, name, WEBSEARCHFS_NAME_LEN);
	TRACE("find_by_recent_query_string: '%s' <> '%s'\n", \
			node->request?node->request->query_string:NULL, query);
	if (!node->request || !node->request->query_string)
		return -1;
	/* reject if older than 5 min */
	if (node->st.st_crtime + 60 * 5 < tm)
		return -1;
	return strcmp(node->request->query_string, query);
}

static status_t websearchfs_open_query(fs_volume *_volume, const char *query, uint32 flags,
					port_id port, uint32 token, void **cookie)
{
	fs_nspace *ns = (fs_nspace *)_volume->private_volume;
	status_t err = B_OK;
	fs_query_cookie *c;
	fs_node *qn, *dummy;
	const char *p;
	char *q;
	char *qstring = NULL;
	char qname[WEBSEARCHFS_NAME_LEN];
	bool accepted = true;
	bool reused = false;
	//int i;
	TRACE("open_query(%" B_PRId32 ", '%s', 0x%08" B_PRIx32 ", %" B_PRId32 ", %" B_PRId32 ")\n",
		ns->nsid, query, flags, port, token);
//	if (flags & B_LIVE_QUERY)
//		return ENOSYS; /* no live query yet, they are live enough anyway */
	//return ENOSYS;
	if (!query || !cookie)
		return EINVAL;

	// filter out queries that aren't for us, we don't want to trigger DuckDuckGo searches when
	// apps check for mails, ... :)

	err = B_NO_MEMORY;
	c = malloc(sizeof(fs_query_cookie));
	if (!c)
		return err;
	memset(c, 0, sizeof(fs_query_cookie));
	c->omode = O_RDONLY;
	c->type = S_IFQUERY;
	c->dir_current = 0;

	err = ENOSYS;
	if (strncmp(query, "((name==\"*", 10))
		accepted = false;
	else {
		qstring = query_unescape_string(query + 10, &p, '"');
		if (!qstring)
			accepted = false;
		else if (!p)
			accepted = false;
		else if (strcmp(p, "\")&&(BEOS:TYPE==\"application/x-vnd.Be-bookmark\"))"))
			accepted = false;
		else {
			//if (qstring[0] == '*')
			//	strcpy(qstring+1, qstring);
			//if (qstring[strlen(qstring)-1] == '*')
			//	qstring[strlen(qstring)-1] = '\0';
			if (!query_strip_bracketed_Cc(qstring))
				goto err_qs;
		}
	}

	if (!accepted) {
		free(qstring);
		/* return an empty cookie */
		*cookie = (void *)c;
		return B_OK;
	}
	TRACE("open_query: QUERY: '%s'\n", qstring);
	/* reuse query if it's not too old */
	LOCK(&ns->l);
	qn = SLL_FIND(ns->queries, qnext,
				(sll_compare_func)compare_fs_node_by_recent_query_string, (void *)qstring);
	UNLOCK(&ns->l);
	reused = (qn != NULL);
	if (reused) {
		TRACE("open_query: reusing %" B_PRId32 ":%" B_PRId64 "\n", ns->nsid, qn->vnid);
		err = get_vnode(_volume, qn->vnid, (void **)&dummy); /* inc ref count */
		if (err)
			goto err_mkdir;
		/* wait for the query to complete */
		while (!qn->qcompleted)
			snooze(10000);
		goto reuse;
	}

	/* stripped name for folder */
	strncpy(qname, qstring, WEBSEARCHFS_NAME_LEN);
	qname[WEBSEARCHFS_NAME_LEN-1] = '\0';

	/* strip out slashes */
	q = qname;
	while ((q = strchr(q, '/')))
		strcpy(q, q + 1);

	/* should get/put_vnode(ns->root); around that I think... */
	err = websearchfs_create_gen(_volume, ns->root, qname, 0, 0755, NULL, &qn, folders_attrs, true, true);
	if (err)
		goto err_qs;

	err = get_vnode(_volume, qn->vnid, (void **)&dummy); /* inc ref count */
	if (err)
		goto err_mkdir;

//#ifndef NO_SEARCH

	/* let's ask DuckDuckGo */
	err = duckduckgo_request_open(qstring, _volume, qn, &qn->request);
	if (err)
		goto err_gn;

	TRACE("open_query: request_open done\n");
#ifndef NO_SEARCH
	err = duckduckgo_request_process(qn->request);
	if (err)
		goto err_gro;
	TRACE("open_query: request_process done\n");

#else
	/* fake entries */
	for (i = 0; i < 10; i++) {
		err = websearchfs_create_gen(_volume, qn, "B", 0, 0644, NULL, &n, fake_bookmark_attrs, false, true);
		/* fake that to test sorting */
		*(int32 *)&n->attrs[1].value = i + 1; // hack
		n->attrs[0].type = 'LONG';
		n->attrs[0].value = &n->attrs[1].value;
		n->attrs[0].size = sizeof(int32);
		n->attrs[0].name = "WEBSEARCH:order";
		notify_attribute_changed(ns->nsid, -1, n->vnid, n->attrs[0].name, B_ATTR_CHANGED);
		if (err)
			goto err_gn;
	}
#endif /*NO_SEARCH*/
	//
	//err = duckduckgo_request_close(q->request);

	LOCK(&ns->l);
	SLL_INSERT(ns->queries, qnext, qn);
	UNLOCK(&ns->l);
reuse:
	/* put the chocolate on the cookie */
	c->node = qn;
	LOCK(&qn->l);
	SLL_INSERT(qn->opened, next, c);
	UNLOCK(&qn->l);
	qn->qcompleted = 1; /* tell other cookies we're done */
	*cookie = (void *)c;
	free(qstring);
	return B_OK;

//err_grp:
err_gro:
	if (qn->request)
		duckduckgo_request_close(qn->request);
err_gn:
	put_vnode(_volume, qn->vnid);
err_mkdir:
	if (!reused)
		websearchfs_unlink_gen(_volume, ns->root, qn->name);
err_qs:
	free(qstring);
//err_m:
	free(c);
	TRACE("open_query: error 0x%08" B_PRIx32 "\n", err);
	return err;
}

static status_t websearchfs_close_query(fs_volume *_volume, void *_cookie)
{
	fs_nspace *ns = (fs_nspace *)_volume->private_volume;
	fs_query_cookie *cookie = (fs_query_cookie *)_cookie;
	status_t err;
	fs_node *q;
	TRACE("close_query(%" B_PRId32 ", %" B_PRId64 ")\n", ns->nsid,
		cookie->node ? cookie->node->vnid : (int64)0);
	//return ENOSYS;
	q = cookie->node;
	if (!q)
		return B_OK;
	// kill_request();
	LOCK(&q->l);
	SLL_REMOVE(q->opened, next, cookie);
	if (q->request /*&& !q->opened*/) {
		err = duckduckgo_request_close(q->request);
	}
	UNLOCK(&q->l);
	/* if last cookie on the query and sync_unlink, trash all */
	if (sync_unlink_queries && !q->opened)
		err = websearchfs_unlink_node_rec(_volume, q);
	err = put_vnode(_volume, q->vnid);
	return err;
}

#ifdef __HAIKU__
/* protos are different... */
static status_t websearchfs_free_query_cookie(fs_volume *_volume, void *_cookie)
{
	fs_query_cookie *cookie = (fs_query_cookie *)_cookie;
	status_t err = B_OK;
	fs_node *q;
	TRACE("free_query_cookie(%" B_PRId32 ")\n", _volume->id);
	q = cookie->node;
	if (!q)
		goto no_node;
	err = LOCK(&q->l);
	if (err)
		return err;
	err = SLL_REMOVE(q->opened, next, cookie); /* just to make sure */
	if (q->request /*&& !q->opened*/) {
		err = duckduckgo_request_close(q->request);
	}
//	if (err)
//		goto err_n_l;
	UNLOCK(&q->l);
no_node:
	free(cookie);
	return B_OK;
}
#endif

static status_t websearchfs_read_query(fs_volume *_volume, void *_cookie, struct dirent *buf,
	size_t bufsize, uint32 *num)
{
	fs_nspace *ns = (fs_nspace *)_volume->private_volume;
	fs_query_cookie *cookie = (fs_query_cookie *)_cookie;
	fs_node *n = NULL;
	fs_node *node = cookie->node;
	int index;
	TRACE("read_query(%" B_PRId32 ", %" B_PRId64 ") @ %d\n", ns->nsid, node ? node->vnid : (int64)0,
		cookie->dir_current);
	if (!cookie || !num || !*num || !buf || (bufsize < (sizeof(dirent_t) + WEBSEARCHFS_NAME_LEN)))
		return EINVAL;
	if (!node) {
		/* a query we don't care about, just return no entries to please apps */
		*num = 0;
		return B_OK;
	}
	//return ENOSYS;
	LOCK(&node->l);
	index = cookie->dir_current;
	for (n = node->children; n && index; n = n->next, index--);
	if (n) {
		TRACE("read_query: giving ino %" PRId64 ", %s\n", n->vnid, n->name);
		buf->d_dev = ns->nsid;
		buf->d_pdev = ns->nsid;
		buf->d_ino = n->vnid;
		buf->d_pino = node->vnid;
		strcpy(buf->d_name, n->name);
		buf->d_reclen = offsetof(struct dirent, d_name)+strlen(buf->d_name)+1;
		cookie->dir_current++;
		*num = 1;
	} else {
		*num = 0;
	}
	UNLOCK(&node->l);
	return B_OK;
}

int websearchfs_push_result_to_query(struct duckduckgo_request *request,
	struct duckduckgo_result *result)
{
	status_t err = B_OK;
	fs_volume *_volume = request->volume;
	fs_nspace *ns = (fs_nspace *)_volume->private_volume;
	fs_node *qn = request->query_node;
	fs_node *n;
	char ename[WEBSEARCHFS_NAME_LEN];
	char *p;
	int i;
	TRACE("push_result_to_query(%" B_PRId32 ", %" B_PRId64 ", %ld:'%s')\n", ns->nsid, qn->vnid, result->id, result->name);
	//dprintf(PFS"push_result_to_query(%" B_PRId32 ", %" B_PRId64 ", %ld:'%s')\n", ns->nsid, qn->vnid, result->id, result->name);
	//return ENOSYS;
	if (!ns || !qn)
		return EINVAL;

	// filter out queries that aren't for us, we don't want to trigger DuckDuckGo searches when
	// apps check for mails, ... :)

	/* stripped name for folder */
	strncpy(ename, result->name, WEBSEARCHFS_NAME_LEN);
	ename[WEBSEARCHFS_NAME_LEN-1] = '\0';
	/* strip out slashes */
	p = ename;
	while ((p = strchr(p, '/')))
		*p++ = '_';

	err = websearchfs_create_gen(_volume, qn, ename, 0, 0644, NULL, &n, bookmark_attrs, false, true);
	if (err)
		return err;
	LOCK(&n->l);
	n->result = result;
	i = 0;
	n->attrs[i].type = 'CSTR';
	n->attrs[i].value = result->name;
	n->attrs[i].size = strlen(result->name)+1;
	n->attrs[i].name = "META:title";
	notify_attribute_changed(ns->nsid, -1, n->vnid, n->attrs[i].name, B_ATTR_CREATED);
	i++;
	n->attrs[i].type = 'CSTR';
	n->attrs[i].value = result->url;
	n->attrs[i].size = strlen(result->url)+1;
	n->attrs[i].name = "META:url";
	notify_attribute_changed(ns->nsid, -1, n->vnid, n->attrs[i].name, B_ATTR_CREATED);
	i++;
	n->attrs[i].type = 'CSTR';
	n->attrs[i].value = request->query_string;
	n->attrs[i].size = strlen(request->query_string)+1;
	n->attrs[i].name = "META:keyw";
	notify_attribute_changed(ns->nsid, -1, n->vnid, n->attrs[i].name, B_ATTR_CREATED);
	i++;
	n->attrs[i].type = 'LONG';
	n->attrs[i].value = &result->id;
	n->attrs[i].size = sizeof(int32);
	n->attrs[i].name = "WEBSEARCH:order";
	notify_attribute_changed(ns->nsid, -1, n->vnid, n->attrs[i].name, B_ATTR_CREATED);
	i++;
	if (result->snipset[0]) {
		n->attrs[i].type = 'CSTR';
		n->attrs[i].value = result->snipset;
		n->attrs[i].size = strlen(result->snipset)+1;
		n->attrs[i].name = "WEBSEARCH:excerpt";
		notify_attribute_changed(ns->nsid, -1, n->vnid, n->attrs[i].name, B_ATTR_CREATED);
		i++;
	}
	if (result->cache_url[0]) {
		n->attrs[i].type = 'CSTR';
		n->attrs[i].value = result->cache_url;
		n->attrs[i].size = strlen(result->cache_url)+1;
		n->attrs[i].name = "WEBSEARCH:cache_url";
		notify_attribute_changed(ns->nsid, -1, n->vnid, n->attrs[i].name, B_ATTR_CREATED);
		i++;
	}
	if (result->similar_url[0]) {
		n->attrs[i].type = 'CSTR';
		n->attrs[i].value = result->similar_url;
		n->attrs[i].size = strlen(result->similar_url)+1;
		n->attrs[i].name = "WEBSEARCH:similar_url";
		notify_attribute_changed(ns->nsid, -1, n->vnid, n->attrs[i].name, B_ATTR_CREATED);
		i++;
	}
	UNLOCK(&n->l);
	return B_OK;

	TRACE("push_result_to_query: error 0x%08" B_PRIx32 "\n", err);
	return err;
}

//	#pragma mark -

static status_t
websearchfs_std_ops(int32 op, ...)
{
	switch (op) {
		case B_MODULE_INIT:
			TRACE("std_ops(INIT)\n");
			return B_OK;
		case B_MODULE_UNINIT:
			TRACE("std_ops(UNINIT)\n");
			return B_OK;
		default:
			return B_ERROR;
	}
}


static fs_volume_ops sWebSearchFSVolumeOps = {
	&websearchfs_unmount,
	&websearchfs_rfsstat,
	&websearchfs_wfsstat,
	NULL,			// no sync!
	&websearchfs_read_vnode,

	/* index directory & index operations */
	NULL,	// &websearchfs_open_index_dir
	NULL,	// &websearchfs_close_index_dir
	NULL,	// &websearchfs_free_index_dir_cookie
	NULL,	// &websearchfs_read_index_dir
	NULL,	// &websearchfs_rewind_index_dir

	NULL,	// &websearchfs_create_index
	NULL,	// &websearchfs_remove_index
	NULL,	// &websearchfs_stat_index

	/* query operations */
	&websearchfs_open_query,
	&websearchfs_close_query,
	&websearchfs_free_query_cookie,
	&websearchfs_read_query,
	NULL,	// &websearchfs_rewind_query,
};


static fs_vnode_ops sWebSearchFSVnodeOps = {
	/* vnode operations */
	&websearchfs_walk,
	&websearchfs_get_vnode_name, //NULL, // fs_get_vnode_name
	&websearchfs_release_vnode,
	&websearchfs_remove_vnode,

	/* VM file access */
	NULL, 	// &websearchfs_can_page
	NULL,	// &websearchfs_read_pages
	NULL, 	// &websearchfs_write_pages

	NULL,	// io()
	NULL,	// cancel_io()

	NULL,	// &websearchfs_get_file_map,

	NULL, 	// &websearchfs_ioctl
	NULL,	// &websearchfs_setflags,
	NULL,	// &websearchfs_select
	NULL,	// &websearchfs_deselect
	NULL, 	// &websearchfs_fsync

	NULL,	// &websearchfs_readlink,
	NULL,	// &websearchfs_symlink,

	NULL,	// &websearchfs_link,
	&websearchfs_unlink,
	NULL,	// &websearchfs_rename,

	&websearchfs_access,
	&websearchfs_rstat,
	&websearchfs_wstat,
	NULL,	// fs_preallocate

	/* file operations */
	&websearchfs_create,
	&websearchfs_open,
	&websearchfs_close,
	&websearchfs_free_cookie,
	&websearchfs_read,
	&websearchfs_write,

	/* directory operations */
	&websearchfs_mkdir,
	&websearchfs_rmdir,
	&websearchfs_opendir,
	&websearchfs_closedir,
	&websearchfs_free_dircookie,
	&websearchfs_readdir,
	&websearchfs_rewinddir,

	/* attribute directory operations */
	&websearchfs_open_attrdir,
	&websearchfs_close_attrdir,
	&websearchfs_free_attrdircookie,
	&websearchfs_read_attrdir,
	&websearchfs_rewind_attrdir,

	/* attribute operations */
	NULL,	// &websearchfs_create_attr
	&websearchfs_open_attr_h,
	&websearchfs_close_attr_h,
	&websearchfs_free_attr_cookie_h,
	&websearchfs_read_attr,
	NULL,	// &websearchfs_write_attr_h,

	&websearchfs_read_attr_stat,
	NULL,	// &websearchfs_write_attr_stat
	NULL,	// &websearchfs_rename_attr
	NULL,	// &websearchfs_remove_attr
};

file_system_module_info sWebSearchFSModule = {
	{
		"file_systems/websearchfs" B_CURRENT_FS_API_VERSION,
		0,
		websearchfs_std_ops,
	},

	"websearchfs",					// short_name
	WEBSEARCHFS_PRETTY_NAME,		// pretty_name
	0,//B_DISK_SYSTEM_SUPPORTS_WRITING, // DDM flags

	// scanning
	NULL,	// fs_identify_partition,
	NULL,	// fs_scan_partition,
	NULL,	// fs_free_identify_partition_cookie,
	NULL,	// free_partition_content_cookie()

	&websearchfs_mount,
};

module_info *modules[] = {
	(module_info *)&sWebSearchFSModule,
	NULL,
};