Removing obsolete cached files after cached->nscd renaming.

Approved by:	re (kensmith), brooks (mentor)

38 files changed, 0 insertions, 10161 deletions

diff --git a/usr.sbin/cached/Makefile b/usr.sbin/cached/Makefile
deleted file mode 100644
index 4dfd514..0000000
--- a/usr.sbin/cached/Makefile
+++ /dev/null
@@ -1,16 +0,0 @@
-# $FreeBSD$
-
-PROG=	cached
-MAN=	cached.conf.5 cached.8
-
-WARNS?=	2
-SRCS=	agent.c cached.c cachedcli.c cachelib.c cacheplcs.c debug.c log.c \
-	config.c query.c mp_ws_query.c mp_rs_query.c singletons.c protocol.c \
-	parser.c
-CFLAGS+= -DCONFIG_PATH="\"${PREFIX}/etc/cached.conf\""
-DPADD=	${LIBM} ${LIBPTHREAD} ${LIBUTIL}
-LDADD=	-lm -lpthread -lutil
-
-.PATH: ${.CURDIR}/agents
-.include "${.CURDIR}/agents/Makefile.inc"
-.include <bsd.prog.mk>
diff --git a/usr.sbin/cached/agent.c b/usr.sbin/cached/agent.c
deleted file mode 100644
index 2d58ef1..0000000
--- a/usr.sbin/cached/agent.c
+++ /dev/null
@@ -1,127 +0,0 @@
-/*-
- * Copyright (c) 2005 Michael Bushkov <bushman@rsu.ru>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- */
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-
-#include <assert.h>
-#include <string.h>
-#include <stdlib.h>
-#include "agent.h"
-#include "debug.h"
-
-static int
-agent_cmp_func(const void *a1, const void *a2)
-{
-   	struct agent const *ap1 = *((struct agent const **)a1);
-	struct agent const *ap2 = *((struct agent const **)a2);
-	int res;
-
-	res = strcmp(ap1->name, ap2->name);
-	if (res == 0) {
-		if (ap1->type == ap2->type)
-			res = 0;
-		else if (ap1->type < ap2->type)
-			res = -1;
-		else
-			res = 1;
-	}
-
-	return (res);
-}
-
-struct agent_table *
-init_agent_table()
-{
-   	struct agent_table	*retval;
-
-	TRACE_IN(init_agent_table);
-	retval = (struct agent_table *)malloc(sizeof(struct agent_table));
-	assert(retval != NULL);
-	memset(retval, 0, sizeof(struct agent_table));
-
-	TRACE_OUT(init_agent_table);
-	return (retval);
-}
-
-void
-register_agent(struct agent_table *at, struct agent *a)
-{
-	struct agent **new_agents;
-    	size_t new_agents_num;
-
-	TRACE_IN(register_agent);
-	assert(at != NULL);
-	assert(a != NULL);
-	new_agents_num = at->agents_num + 1;
-	new_agents = (struct agent **)malloc(sizeof(struct agent *) *
-		new_agents_num);
-	assert(new_agents != NULL);
-	memcpy(new_agents, at->agents, at->agents_num * sizeof(struct agent *));
-	new_agents[new_agents_num - 1] = a;
-	qsort(new_agents, new_agents_num, sizeof(struct agent *),
-		agent_cmp_func);
-
-	free(at->agents);
-	at->agents = new_agents;
-	at->agents_num = new_agents_num;
-    	TRACE_OUT(register_agent);
-}
-
-struct agent *
-find_agent(struct agent_table *at, const char *name, enum agent_type type)
-{
-	struct agent **res;
-	struct agent model, *model_p;
-
-	TRACE_IN(find_agent);
-	model.name = (char *)name;
-	model.type = type;
-	model_p = &model;
-	res = bsearch(&model_p, at->agents, at->agents_num,
-		sizeof(struct agent *), agent_cmp_func);
-
-	TRACE_OUT(find_agent);
-	return ( res == NULL ? NULL : *res);
-}
-
-void
-destroy_agent_table(struct agent_table *at)
-{
-    	size_t i;
-
-	TRACE_IN(destroy_agent_table);
-	assert(at != NULL);
-	for (i = 0; i < at->agents_num; ++i) {
-		free(at->agents[i]->name);
-		free(at->agents[i]);
-	}
-
-	free(at->agents);
-	free(at);
-	TRACE_OUT(destroy_agent_table);
-}
diff --git a/usr.sbin/cached/agent.h b/usr.sbin/cached/agent.h
deleted file mode 100644
index 5dc368d..0000000
--- a/usr.sbin/cached/agent.h
+++ /dev/null
@@ -1,72 +0,0 @@
-/*-
- * Copyright (c) 2005 Michael Bushkov <bushman@rsu.ru>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * $FreeBSD$
- */
-
-#ifndef __CACHED_AGENT_H__
-#define __CACHED_AGENT_H__
-
-/*
- * Agents are used to perform the actual lookups from the caching daemon.
- * There are two types of daemons: for common requests and for multipart
- * requests.
- * All agents are stored in the agents table, which is the singleton.
- */
-
-enum agent_type {
-    COMMON_AGENT = 0,
-    MULTIPART_AGENT = 1
-};
-
-struct agent {
-   	char	*name;
-    	enum agent_type type;
-};
-
-struct common_agent {
-    	struct agent	parent;
-	int (*lookup_func)(const char *, size_t, char **, size_t *);
-};
-
-struct multipart_agent {
-    	struct agent	parent;
-	void *(*mp_init_func)();
-    	int (*mp_lookup_func)(char **, size_t *, void *);
-	void (*mp_destroy_func)(void *);
-};
-
-struct agent_table {
-   	struct agent	**agents;
-	size_t		agents_num;
-};
-
-extern struct agent_table *init_agent_table();
-extern void register_agent(struct agent_table *, struct agent *);
-extern struct agent *find_agent(struct agent_table *, const char *,
-	enum agent_type);
-extern void destroy_agent_table(struct agent_table *);
-
-#endif
diff --git a/usr.sbin/cached/agents/Makefile.inc b/usr.sbin/cached/agents/Makefile.inc
deleted file mode 100644
index 1be32e1..0000000
--- a/usr.sbin/cached/agents/Makefile.inc
+++ /dev/null
@@ -1,3 +0,0 @@
-# $FreeBSD$
-
-SRCS += passwd.c group.c services.c
diff --git a/usr.sbin/cached/agents/group.c b/usr.sbin/cached/agents/group.c
deleted file mode 100644
index b9190be..0000000
--- a/usr.sbin/cached/agents/group.c
+++ /dev/null
@@ -1,262 +0,0 @@
-/*-
- * Copyright (c) 2005 Michael Bushkov <bushman@rsu.ru>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- */
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-
-#include <sys/param.h>
-#include <sys/types.h>
-#include <assert.h>
-#include <nsswitch.h>
-#include <grp.h>
-#include <string.h>
-#include <stdlib.h>
-#include "../debug.h"
-#include "passwd.h"
-
-static int group_marshal_func(struct group *, char *, size_t *);
-static int group_lookup_func(const char *, size_t, char **, size_t *);
-static void *group_mp_init_func();
-static int group_mp_lookup_func(char **, size_t *, void *);
-static void group_mp_destroy_func(void *);
-
-static int
-group_marshal_func(struct group *grp, char *buffer, size_t *buffer_size)
-{
-	struct group new_grp;
-	size_t desired_size, size, mem_size;
-	char *p, **mem;
-
-	TRACE_IN(group_marshal_func);
-	desired_size = ALIGNBYTES + sizeof(struct group) + sizeof(char *);
-
-	if (grp->gr_name != NULL)
-		desired_size += strlen(grp->gr_name) + 1;
-	if (grp->gr_passwd != NULL)
-		desired_size += strlen(grp->gr_passwd) + 1;
-
-	if (grp->gr_mem != NULL) {
-		mem_size = 0;
-		for (mem = grp->gr_mem; *mem; ++mem) {
-			desired_size += strlen(*mem) + 1;
-			++mem_size;
-		}
-
-		desired_size += ALIGNBYTES + (mem_size + 1) * sizeof(char *);
-	}
-
-	if ((desired_size > *buffer_size) || (buffer == NULL)) {
-		*buffer_size = desired_size;
-		TRACE_OUT(group_marshal_func);
-		return (NS_RETURN);
-	}
-
-	memcpy(&new_grp, grp, sizeof(struct group));
-	memset(buffer, 0, desired_size);
-
-	*buffer_size = desired_size;
-	p = buffer + sizeof(struct group) + sizeof(char *);
-	memcpy(buffer + sizeof(struct group), &p, sizeof(char *));
-	p = (char *)ALIGN(p);
-
-	if (new_grp.gr_name != NULL) {
-		size = strlen(new_grp.gr_name);
-		memcpy(p, new_grp.gr_name, size);
-		new_grp.gr_name = p;
-		p += size + 1;
-	}
-
-	if (new_grp.gr_passwd != NULL) {
-		size = strlen(new_grp.gr_passwd);
-		memcpy(p, new_grp.gr_passwd, size);
-		new_grp.gr_passwd = p;
-		p += size + 1;
-	}
-
-	if (new_grp.gr_mem != NULL) {
-		p = (char *)ALIGN(p);
-		memcpy(p, new_grp.gr_mem, sizeof(char *) * mem_size);
-		new_grp.gr_mem = (char **)p;
-		p += sizeof(char *) * (mem_size + 1);
-
-		for (mem = new_grp.gr_mem; *mem; ++mem) {
-			size = strlen(*mem);
-			memcpy(p, *mem, size);
-			*mem = p;
-			p += size + 1;
-		}
-	}
-
-	memcpy(buffer, &new_grp, sizeof(struct group));
-	TRACE_OUT(group_marshal_func);
-	return (NS_SUCCESS);
-}
-
-static int
-group_lookup_func(const char *key, size_t key_size, char **buffer,
-	size_t *buffer_size)
-{
-	enum nss_lookup_type lookup_type;
-	char	*name;
-	size_t	size;
-	gid_t	gid;
-
-	struct group *result;
-
-	TRACE_IN(group_lookup_func);
-	assert(buffer != NULL);
-	assert(buffer_size != NULL);
-
-	if (key_size < sizeof(enum nss_lookup_type)) {
-		TRACE_OUT(group_lookup_func);
-		return (NS_UNAVAIL);
-	}
-	memcpy(&lookup_type, key, sizeof(enum nss_lookup_type));
-
-	switch (lookup_type) {
-	case nss_lt_name:
-		size = key_size - sizeof(enum nss_lookup_type)	+ 1;
-		name = (char *)malloc(size);
-		assert(name != NULL);
-		memset(name, 0, size);
-		memcpy(name, key + sizeof(enum nss_lookup_type), size - 1);
-		break;
-	case nss_lt_id:
-		if (key_size < sizeof(enum nss_lookup_type) +
-			sizeof(gid_t)) {
-			TRACE_OUT(passwd_lookup_func);
-			return (NS_UNAVAIL);
-		}
-
-		memcpy(&gid, key + sizeof(enum nss_lookup_type), sizeof(gid_t));
-		break;
-	default:
-		TRACE_OUT(group_lookup_func);
-		return (NS_UNAVAIL);
-	}
-
-	switch (lookup_type) {
-	case nss_lt_name:
-		TRACE_STR(name);
-		result = getgrnam(name);
-		free(name);
-		break;
-	case nss_lt_id:
-		result = getgrgid(gid);
-		break;
-	default:
-		/* SHOULD NOT BE REACHED */
-		break;
-	}
-
-	if (result != NULL) {
-		group_marshal_func(result, NULL, buffer_size);
-		*buffer = (char *)malloc(*buffer_size);
-		assert(*buffer != NULL);
-		group_marshal_func(result, *buffer, buffer_size);
-	}
-
-	TRACE_OUT(group_lookup_func);
-	return (result == NULL ? NS_NOTFOUND : NS_SUCCESS);
-}
-
-static void *
-group_mp_init_func()
-{
-	TRACE_IN(group_mp_init_func);
-	setgrent();
-	TRACE_OUT(group_mp_init_func);
-
-	return (NULL);
-}
-
-static int
-group_mp_lookup_func(char **buffer, size_t *buffer_size, void *mdata)
-{
-	struct group *result;
-
-	TRACE_IN(group_mp_lookup_func);
-	result = getgrent();
-	if (result != NULL) {
-		group_marshal_func(result, NULL, buffer_size);
-		*buffer = (char *)malloc(*buffer_size);
-		assert(*buffer != NULL);
-		group_marshal_func(result, *buffer, buffer_size);
-	}
-
-	TRACE_OUT(group_mp_lookup_func);
-	return (result == NULL ? NS_NOTFOUND : NS_SUCCESS);
-}
-
-static void
-group_mp_destroy_func(void *mdata)
-{
-	TRACE_IN(group_mp_destroy_func);
-	TRACE_OUT(group_mp_destroy_func);
-}
-
-struct agent *
-init_group_agent()
-{
-	struct common_agent	*retval;
-
-	TRACE_IN(init_group_agent);
-	retval = (struct common_agent *)malloc(sizeof(struct common_agent));
-	assert(retval != NULL);
-	memset(retval, 0, sizeof(struct common_agent));
-
-	retval->parent.name = strdup("group");
-	assert(retval->parent.name != NULL);
-
-	retval->parent.type = COMMON_AGENT;
-	retval->lookup_func = group_lookup_func;
-
-	TRACE_OUT(init_group_agent);
-	return ((struct agent *)retval);
-}
-
-struct agent *
-init_group_mp_agent()
-{
-	struct multipart_agent	*retval;
-
-	TRACE_IN(init_group_mp_agent);
-	retval = (struct multipart_agent *)malloc(
-		sizeof(struct multipart_agent));
-	assert(retval != NULL);
-	memset(retval, 0, sizeof(struct multipart_agent));
-
-	retval->parent.name = strdup("group");
-	retval->parent.type = MULTIPART_AGENT;
-	retval->mp_init_func = group_mp_init_func;
-	retval->mp_lookup_func = group_mp_lookup_func;
-	retval->mp_destroy_func = group_mp_destroy_func;
-	assert(retval->parent.name != NULL);
-
-	TRACE_OUT(init_group_mp_agent);
-	return ((struct agent *)retval);
-}
diff --git a/usr.sbin/cached/agents/group.h b/usr.sbin/cached/agents/group.h
deleted file mode 100644
index e6c7397..0000000
--- a/usr.sbin/cached/agents/group.h
+++ /dev/null
@@ -1,32 +0,0 @@
-/*-
- * Copyright (c) 2005 Michael Bushkov <bushman@rsu.ru>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * $FreeBSD$
- */
-
-#include "../agent.h"
-
-extern struct agent *init_group_agent();
-extern struct agent *init_group_mp_agent();
diff --git a/usr.sbin/cached/agents/passwd.c b/usr.sbin/cached/agents/passwd.c
deleted file mode 100644
index 50c55ba..0000000
--- a/usr.sbin/cached/agents/passwd.c
+++ /dev/null
@@ -1,269 +0,0 @@
-/*-
- * Copyright (c) 2005 Michael Bushkov <bushman@rsu.ru>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- */
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-
-#include <sys/types.h>
-#include <assert.h>
-#include <nsswitch.h>
-#include <pwd.h>
-#include <string.h>
-#include <stdlib.h>
-#include "../debug.h"
-#include "passwd.h"
-
-static int passwd_marshal_func(struct passwd *, char *, size_t *);
-static int passwd_lookup_func(const char *, size_t, char **, size_t *);
-static void *passwd_mp_init_func();
-static int passwd_mp_lookup_func(char **, size_t *, void *);
-static void passwd_mp_destroy_func(void *mdata);
-
-static int
-passwd_marshal_func(struct passwd *pwd, char *buffer, size_t *buffer_size)
-{
-	char		*p;
-	struct passwd	new_pwd;
-	size_t		desired_size, size;
-
-	TRACE_IN(passwd_marshal_func);
-	desired_size = sizeof(struct passwd) + sizeof(char *) +
-		strlen(pwd->pw_name) + 1;
-	if (pwd->pw_passwd != NULL)
-		desired_size += strlen(pwd->pw_passwd) + 1;
-	if (pwd->pw_class != NULL)
-		desired_size += strlen(pwd->pw_class) + 1;
-	if (pwd->pw_gecos != NULL)
-		desired_size += strlen(pwd->pw_gecos) + 1;
-	if (pwd->pw_dir != NULL)
-		desired_size += strlen(pwd->pw_dir) + 1;
-	if (pwd->pw_shell != NULL)
-		desired_size += strlen(pwd->pw_shell) + 1;
-
-	if ((*buffer_size < desired_size) || (buffer == NULL)) {
-		*buffer_size = desired_size;
-		TRACE_OUT(passwd_marshal_func);
-		return (NS_RETURN);
-	}
-
-	memcpy(&new_pwd, pwd, sizeof(struct passwd));
-	memset(buffer, 0, desired_size);
-
-	*buffer_size = desired_size;
-	p = buffer + sizeof(struct passwd) + sizeof(char *);
-	memcpy(buffer + sizeof(struct passwd), &p, sizeof(char *));
-
-	if (new_pwd.pw_name != NULL) {
-		size = strlen(new_pwd.pw_name);
-		memcpy(p, new_pwd.pw_name, size);
-		new_pwd.pw_name = p;
-		p += size + 1;
-	}
-
-	if (new_pwd.pw_passwd != NULL) {
-		size = strlen(new_pwd.pw_passwd);
-		memcpy(p, new_pwd.pw_passwd, size);
-		new_pwd.pw_passwd = p;
-		p += size + 1;
-	}
-
-	if (new_pwd.pw_class != NULL) {
-		size = strlen(new_pwd.pw_class);
-		memcpy(p, new_pwd.pw_class, size);
-		new_pwd.pw_class = p;
-		p += size + 1;
-	}
-
-	if (new_pwd.pw_gecos != NULL) {
-		size = strlen(new_pwd.pw_gecos);
-		memcpy(p, new_pwd.pw_gecos, size);
-		new_pwd.pw_gecos = p;
-		p += size + 1;
-	}
-
-	if (new_pwd.pw_dir != NULL) {
-		size = strlen(new_pwd.pw_dir);
-		memcpy(p, new_pwd.pw_dir, size);
-		new_pwd.pw_dir = p;
-		p += size + 1;
-	}
-
-	if (new_pwd.pw_shell != NULL) {
-		size = strlen(new_pwd.pw_shell);
-		memcpy(p, new_pwd.pw_shell, size);
-		new_pwd.pw_shell = p;
-		p += size + 1;
-	}
-
-	memcpy(buffer, &new_pwd, sizeof(struct passwd));
-	TRACE_OUT(passwd_marshal_func);
-	return (NS_SUCCESS);
-}
-
-static int
-passwd_lookup_func(const char *key, size_t key_size, char **buffer,
-	size_t *buffer_size)
-{
-	enum nss_lookup_type lookup_type;
-	char	*login;
-	size_t	size;
-	uid_t	uid;
-
-	struct passwd *result;
-
-	TRACE_IN(passwd_lookup_func);
-	assert(buffer != NULL);
-	assert(buffer_size != NULL);
-
-	if (key_size < sizeof(enum nss_lookup_type)) {
-		TRACE_OUT(passwd_lookup_func);
-		return (NS_UNAVAIL);
-	}
-	memcpy(&lookup_type, key, sizeof(enum nss_lookup_type));
-
-	switch (lookup_type) {
-	case nss_lt_name:
-		size = key_size - sizeof(enum nss_lookup_type)	+ 1;
-		login = (char *)malloc(size);
-		assert(login != NULL);
-		memset(login, 0, size);
-		memcpy(login, key + sizeof(enum nss_lookup_type), size - 1);
-		break;
-	case nss_lt_id:
-		if (key_size < sizeof(enum nss_lookup_type) +
-			sizeof(uid_t)) {
-			TRACE_OUT(passwd_lookup_func);
-			return (NS_UNAVAIL);
-		}
-
-		memcpy(&uid, key + sizeof(enum nss_lookup_type), sizeof(uid_t));
-		break;
-	default:
-		TRACE_OUT(passwd_lookup_func);
-		return (NS_UNAVAIL);
-	}
-
-	switch (lookup_type) {
-	case nss_lt_name:
-		result = getpwnam(login);
-		free(login);
-		break;
-	case nss_lt_id:
-		result = getpwuid(uid);
-		break;
-	default:
-		/* SHOULD NOT BE REACHED */
-		break;
-	}
-
-	if (result != NULL) {
-		passwd_marshal_func(result, NULL, buffer_size);
-		*buffer = (char *)malloc(*buffer_size);
-		assert(*buffer != NULL);
-		passwd_marshal_func(result, *buffer, buffer_size);
-	}
-
-	TRACE_OUT(passwd_lookup_func);
-	return (result == NULL ? NS_NOTFOUND : NS_SUCCESS);
-}
-
-static void *
-passwd_mp_init_func()
-{
-	TRACE_IN(passwd_mp_init_func);
-	setpwent();
-	TRACE_OUT(passwd_mp_init_func);
-
-	return (NULL);
-}
-
-static int
-passwd_mp_lookup_func(char **buffer, size_t *buffer_size, void *mdata)
-{
-	struct passwd	*result;
-
-	TRACE_IN(passwd_mp_lookup_func);
-	result = getpwent();
-	if (result != NULL) {
-		passwd_marshal_func(result, NULL, buffer_size);
-		*buffer = (char *)malloc(*buffer_size);
-		assert(*buffer != NULL);
-		passwd_marshal_func(result, *buffer, buffer_size);
-	}
-
-	TRACE_OUT(passwd_mp_lookup_func);
-	return (result == NULL ? NS_NOTFOUND : NS_SUCCESS);
-}
-
-static void
-passwd_mp_destroy_func(void *mdata)
-{
-	TRACE_IN(passwd_mp_destroy_func);
-	TRACE_OUT(passwd_mp_destroy_func);
-}
-
-struct agent *
-init_passwd_agent()
-{
-	struct common_agent	*retval;
-
-	TRACE_IN(init_passwd_agent);
-	retval = (struct common_agent *)malloc(sizeof(struct common_agent));
-	assert(retval != NULL);
-	memset(retval, 0, sizeof(struct common_agent));
-
-	retval->parent.name = strdup("passwd");
-	assert(retval->parent.name != NULL);
-
-	retval->parent.type = COMMON_AGENT;
-	retval->lookup_func = passwd_lookup_func;
-
-	TRACE_OUT(init_passwd_agent);
-	return ((struct agent *)retval);
-}
-
-struct agent *
-init_passwd_mp_agent()
-{
-	struct multipart_agent	*retval;
-
-	TRACE_IN(init_passwd_mp_agent);
-	retval = (struct multipart_agent *)malloc(
-		sizeof(struct multipart_agent));
-	assert(retval != NULL);
-	memset(retval, 0, sizeof(struct multipart_agent));
-
-	retval->parent.name = strdup("passwd");
-	retval->parent.type = MULTIPART_AGENT;
-	retval->mp_init_func = passwd_mp_init_func;
-	retval->mp_lookup_func = passwd_mp_lookup_func;
-	retval->mp_destroy_func = passwd_mp_destroy_func;
-	assert(retval->parent.name != NULL);
-
-	TRACE_OUT(init_passwd_mp_agent);
-	return ((struct agent *)retval);
-}
diff --git a/usr.sbin/cached/agents/passwd.h b/usr.sbin/cached/agents/passwd.h
deleted file mode 100644
index 956a50d..0000000
--- a/usr.sbin/cached/agents/passwd.h
+++ /dev/null
@@ -1,32 +0,0 @@
-/*-
- * Copyright (c) 2005 Michael Bushkov <bushman@rsu.ru>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * $FreeBSD$
- */
-
-#include "../agent.h"
-
-extern struct agent *init_passwd_agent();
-extern struct agent *init_passwd_mp_agent();
diff --git a/usr.sbin/cached/agents/services.c b/usr.sbin/cached/agents/services.c
deleted file mode 100644
index b0a2eb9..0000000
--- a/usr.sbin/cached/agents/services.c
+++ /dev/null
@@ -1,284 +0,0 @@
-/*-
- * Copyright (c) 2005 Michael Bushkov <bushman@rsu.ru>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- */
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-
-#include <sys/param.h>
-#include <sys/types.h>
-#include <assert.h>
-#include <nsswitch.h>
-#include <netdb.h>
-#include <string.h>
-#include <stdlib.h>
-#include "../debug.h"
-#include "services.h"
-
-static int services_marshal_func(struct servent *, char *, size_t *);
-static int services_lookup_func(const char *, size_t, char **, size_t *);
-static void *services_mp_init_func();
-static int services_mp_lookup_func(char **, size_t *, void *);
-static void services_mp_destroy_func(void *);
-
-static int
-services_marshal_func(struct servent *serv, char *buffer, size_t *buffer_size)
-{
-	struct servent	new_serv;
-	size_t	desired_size;
-	char	**alias;
-	char	*p;
-	size_t	size;
-	size_t	aliases_size;
-
-	TRACE_IN(services_marshal_func);
-	desired_size = ALIGNBYTES + sizeof(struct servent) + sizeof(char *);
-	if (serv->s_name != NULL)
-		desired_size += strlen(serv->s_name) + 1;
-	if (serv->s_proto != NULL)
-		desired_size += strlen(serv->s_proto) + 1;
-
-	aliases_size = 0;
-	if (serv->s_aliases != NULL) {
-		for (alias = serv->s_aliases; *alias; ++alias) {
-			desired_size += strlen(*alias) + 1;
-			++aliases_size;
-		}
-
-		desired_size += ALIGNBYTES + sizeof(char *) *
-		    (aliases_size + 1);
-	}
-
-	if ((*buffer_size < desired_size) || (buffer == NULL)) {
-		*buffer_size = desired_size;
-		TRACE_OUT(services_marshal_func);
-		return (NS_RETURN);
-	}
-
-	memcpy(&new_serv, serv, sizeof(struct servent));
-	memset(buffer, 0, desired_size);
-
-	*buffer_size = desired_size;
-	p = buffer + sizeof(struct servent) + sizeof(char *);
-	memcpy(buffer + sizeof(struct servent), &p, sizeof(char *));
-	p = (char *)ALIGN(p);
-
-	if (new_serv.s_name != NULL) {
-		size = strlen(new_serv.s_name);
-		memcpy(p, new_serv.s_name, size);
-		new_serv.s_name = p;
-		p += size + 1;
-	}
-
-	if (new_serv.s_proto != NULL) {
-		size = strlen(new_serv.s_proto);
-		memcpy(p, new_serv.s_proto, size);
-		new_serv.s_proto = p;
-		p += size + 1;
-	}
-
-	if (new_serv.s_aliases != NULL) {
-		p = (char *)ALIGN(p);
-		memcpy(p, new_serv.s_aliases, sizeof(char *) * aliases_size);
-		new_serv.s_aliases = (char **)p;
-		p += sizeof(char *) * (aliases_size + 1);
-
-		for (alias = new_serv.s_aliases; *alias; ++alias) {
-			size = strlen(*alias);
-			memcpy(p, *alias, size);
-			*alias = p;
-			p += size + 1;
-		}
-	}
-
-	memcpy(buffer, &new_serv, sizeof(struct servent));
-	TRACE_OUT(services_marshal_func);
-	return (NS_SUCCESS);
-}
-
-static int
-services_lookup_func(const char *key, size_t key_size, char **buffer,
-	size_t *buffer_size)
-{
-	enum nss_lookup_type lookup_type;
-	char	*name = NULL;
-	char	*proto = NULL;
-	size_t	size, size2;
-	int	port;
-
-	struct servent *result;
-
-	TRACE_IN(services_lookup_func);
-
-	assert(buffer != NULL);
-	assert(buffer_size != NULL);
-
-	if (key_size < sizeof(enum nss_lookup_type)) {
-		TRACE_OUT(passwd_lookup_func);
-		return (NS_UNAVAIL);
-	}
-	memcpy(&lookup_type, key, sizeof(enum nss_lookup_type));
-
-	switch (lookup_type) {
-	case nss_lt_name:
-		size = key_size - sizeof(enum nss_lookup_type);
-		name = (char *)malloc(size + 1);
-		assert(name != NULL);
-		memset(name, 0, size + 1);
-		memcpy(name, key + sizeof(enum nss_lookup_type), size);
-
-		size2 = strlen(name) + 1;
-
-		if (size2 < size)
-			proto = name + size2;
-		else
-			proto = NULL;
-		break;
-	case nss_lt_id:
-		if (key_size < sizeof(enum nss_lookup_type) +
-			sizeof(int)) {
-			TRACE_OUT(passwd_lookup_func);
-			return (NS_UNAVAIL);
-		}
-
-		memcpy(&port, key + sizeof(enum nss_lookup_type),
-			sizeof(int));
-
-		size = key_size - sizeof(enum nss_lookup_type) - sizeof(int);
-		if (size > 0) {
-			proto = (char *)malloc(size + 1);
-			assert(proto != NULL);
-			memset(proto, size + 1, 0);
-			memcpy(proto, key + sizeof(enum nss_lookup_type) +
-				sizeof(int), size);
-		}
-		break;
-	default:
-		TRACE_OUT(passwd_lookup_func);
-		return (NS_UNAVAIL);
-	}
-
-	switch (lookup_type) {
-	case nss_lt_name:
-		result = getservbyname(name, proto);
-		free(name);
-		break;
-	case nss_lt_id:
-		result = getservbyport(port, proto);
-		free(proto);
-		break;
-	default:
-		/* SHOULD NOT BE REACHED */
-		break;
-	}
-
-	if (result != NULL) {
-		services_marshal_func(result, NULL, buffer_size);
-		*buffer = (char *)malloc(*buffer_size);
-		assert(*buffer != NULL);
-		services_marshal_func(result, *buffer, buffer_size);
-	}
-
-	TRACE_OUT(services_lookup_func);
-	return (result == NULL ? NS_NOTFOUND : NS_SUCCESS);
-}
-
-static void *
-services_mp_init_func()
-{
-	TRACE_IN(services_mp_init_func);
-	setservent(0);
-	TRACE_OUT(services_mp_init_func);
-
-	return (NULL);
-}
-
-static int
-services_mp_lookup_func(char **buffer, size_t *buffer_size, void *mdata)
-{
-	struct servent *result;
-
-	TRACE_IN(services_mp_lookup_func);
-	result = getservent();
-	if (result != NULL) {
-		services_marshal_func(result, NULL, buffer_size);
-		*buffer = (char *)malloc(*buffer_size);
-		assert(*buffer != NULL);
-		services_marshal_func(result, *buffer, buffer_size);
-	}
-
-	TRACE_OUT(services_mp_lookup_func);
-	return (result == NULL ? NS_NOTFOUND : NS_SUCCESS);
-}
-
-static void
-services_mp_destroy_func(void *mdata)
-{
-	TRACE_IN(services_mp_destroy_func);
-	TRACE_OUT(services_mp_destroy_func);
-}
-
-struct agent *
-init_services_agent()
-{
-	struct common_agent	*retval;
-	TRACE_IN(init_services_agent);
-
-	retval = (struct common_agent *)malloc(sizeof(struct common_agent));
-	assert(retval != NULL);
-	memset(retval, 0, sizeof(struct common_agent));
-
-	retval->parent.name = strdup("services");
-	assert(retval->parent.name != NULL);
-
-	retval->parent.type = COMMON_AGENT;
-	retval->lookup_func = services_lookup_func;
-
-	TRACE_OUT(init_services_agent);
-	return ((struct agent *)retval);
-}
-
-struct agent *
-init_services_mp_agent()
-{
-	struct multipart_agent	*retval;
-
-	TRACE_IN(init_services_mp_agent);
-	retval = (struct multipart_agent *)malloc(
-		sizeof(struct multipart_agent));
-	assert(retval != NULL);
-	memset(retval, 0, sizeof(struct multipart_agent));
-
-	retval->parent.name = strdup("services");
-	retval->parent.type = MULTIPART_AGENT;
-	retval->mp_init_func = services_mp_init_func;
-	retval->mp_lookup_func = services_mp_lookup_func;
-	retval->mp_destroy_func = services_mp_destroy_func;
-	assert(retval->parent.name != NULL);
-
-	TRACE_OUT(init_services_mp_agent);
-	return ((struct agent *)retval);
-}
diff --git a/usr.sbin/cached/agents/services.h b/usr.sbin/cached/agents/services.h
deleted file mode 100644
index 0b77c87..0000000
--- a/usr.sbin/cached/agents/services.h
+++ /dev/null
@@ -1,32 +0,0 @@
-/*-
- * Copyright (c) 2005 Michael Bushkov <bushman@rsu.ru>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * $FreeBSD$
- */
-
-#include "../agent.h"
-
-extern struct agent *init_services_agent();
-extern struct agent *init_services_mp_agent();
diff --git a/usr.sbin/cached/cached.8 b/usr.sbin/cached/cached.8
deleted file mode 100644
index 519338e..0000000
--- a/usr.sbin/cached/cached.8
+++ /dev/null
@@ -1,165 +0,0 @@
-.\" Copyright (c) 2005 Michael Bushkov <bushman@rsu.ru>
-.\" All rights reserved.
-.\"
-.\" Redistribution and use in source and binary forms, with or without
-.\" modification, are permitted provided that the following conditions
-.\" are met:
-.\" 1. Redistributions of source code must retain the above copyright
-.\"    notice, this list of conditions and the following disclaimer.
-.\" 2. Redistributions in binary form must reproduce the above copyright
-.\"    notice, this list of conditions and the following disclaimer in the
-.\"    documentation and/or other materials provided with the distribution.
-.\"
-.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
-.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-.\" ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
-.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
-.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
-.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
-.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
-.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
-.\" SUCH DAMAGE.
-.\"
-.\" $FreeBSD$
-.\"
-.Dd October 20, 2005
-.Dt CACHED 8
-.Os
-.Sh NAME
-.Nm cached
-.Nd "caching server daemon"
-.Sh SYNOPSIS
-.Nm
-.Op Fl dnst
-.Op Fl i Ar cachename
-.Op Fl I Ar cachename
-.Sh DESCRIPTION
-The
-.Nm
-utility
-is the system caching daemon.
-It can cache almost all types of data and is basically intended to be used
-with the
-.Nm nsswitch
-subsystem.
-The cache is actually per-user.
-This means that each user can work only with the
-cached data that were cached by themselves, and cannot poison the
-cache of other users.
-The
-.Nm
-utility supports two types of caching:
-.Bl -tag -width ".Sy Type"
-.It Sy Type
-.Sy Description
-.It Common caching
-Each cached element is the key+value pair.
-This type of caching supports policies which are applied when maximum
-number of cached elements is exceeded.
-Three policies are available:
-.Cm FIFO
-(first in - first out),
-.Cm LRU
-(least recently used) and
-.Cm LFU
-(least frequently used).
-This type of caching is used with the
-.Fn getXXXbyname
-family of functions.
-.It Multipart caching
-Each cached element is the part of the elements sequence.
-This type of caching is intended to be used with the
-.Fn getXXXent
-family of functions.
-.El
-.Pp
-The
-.Nm
-utility is able not only to cache elements, but to perform the actual nsswitch
-lookups by itself.
-To enable this feature, use the
-.Va perform-actual-lookups
-parameter in
-.Xr cached.conf 5 .
-.Pp
-The
-.Nm
-utility recognizes the following runtime options:
-.Bl -tag -width indent
-.\" .It Fl d
-.\" XXX Document me!
-.It Fl n
-Do not daemonize;
-.Nm
-will not fork or disconnect itself from the terminal.
-.It Fl s
-Single-threaded mode.
-Forces using only one thread for all processing purposes (it overrides
-the
-.Va threads
-parameter in the
-.Xr cached.conf 5
-file).
-.It Fl t
-Trace mode.
-All trace messages will be written to stdout.
-This mode is usually used with
-.Fl n
-and
-.Fl s
-flags are used for debugging purposes.
-.It Fl i Ar cachename
-Invalidates personal cache.
-When specified,
-.Nm
-acts as the administration tool.
-It asks the already running
-.Nm
-to invalidate the specified part of the cache of the
-calling user.
-For example, sometimes you may want to invalidate your
-.Dq Li hosts
-cache.
-You can specify
-.Dq Li all
-as the
-.Ar cachename
-to invalidate your personal cache as a whole.
-You cannot use this option for the
-.Ar cachename
-for which the
-.Va perform-actual-lookups
-option is enabled.
-.It Fl I Ar cachename
-Invalidates the cache for every user.
-When specified,
-.Nm
-acts as the administration tool.
-It asks the already
-running
-.Nm
-to invalidate the specified part of the cache for
-every user.
-You can specify
-.Dq Li all
-as the
-.Ar cachename
-to invalidate the whole cache.
-Only the root can use this option.
-.El
-.Sh FILES
-.Bl -tag -width ".Pa /etc/cached.conf" -compact
-.It Pa /etc/cached.conf
-The default configuration file.
-.El
-.Sh SEE ALSO
-.Xr nsdispatch 3 ,
-.Xr cached.conf 5 ,
-.Xr nsswitch.conf 5
-.Sh AUTHORS
-.An Michael Bushkov Aq bushman@rsu.ru
-.Sh BUGS
-Please send bug reports and suggestions to
-.Aq bushman@rsu.ru .
diff --git a/usr.sbin/cached/cached.c b/usr.sbin/cached/cached.c
deleted file mode 100644
index 3a8e97c..0000000
--- a/usr.sbin/cached/cached.c
+++ /dev/null
@@ -1,885 +0,0 @@
-/*-
- * Copyright (c) 2005 Michael Bushkov <bushman@rsu.ru>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in thereg
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- */
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-
-#include <sys/types.h>
-#include <sys/event.h>
-#include <sys/socket.h>
-#include <sys/time.h>
-#include <sys/param.h>
-#include <sys/un.h>
-#include <assert.h>
-#include <err.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <libutil.h>
-#include <pthread.h>
-#include <signal.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-
-#include "agents/passwd.h"
-#include "agents/group.h"
-#include "agents/services.h"
-#include "cachedcli.h"
-#include "cachelib.h"
-#include "config.h"
-#include "debug.h"
-#include "log.h"
-#include "parser.h"
-#include "query.h"
-#include "singletons.h"
-
-#ifndef CONFIG_PATH
-#define CONFIG_PATH "/etc/cached.conf"
-#endif
-#define DEFAULT_CONFIG_PATH	"cached.conf"
-
-#define MAX_SOCKET_IO_SIZE	4096
-
-struct processing_thread_args {
-	cache	the_cache;
-	struct configuration	*the_configuration;
-	struct runtime_env		*the_runtime_env;
-};
-
-static void accept_connection(struct kevent *, struct runtime_env *,
-	struct configuration *);
-static void destroy_cache_(cache);
-static void destroy_runtime_env(struct runtime_env *);
-static cache init_cache_(struct configuration *);
-static struct runtime_env *init_runtime_env(struct configuration *);
-static void print_version_info(void);
-static void processing_loop(cache, struct runtime_env *,
-	struct configuration *);
-static void process_socket_event(struct kevent *, struct runtime_env *,
-	struct configuration *);
-static void process_timer_event(struct kevent *, struct runtime_env *,
-	struct configuration *);
-static void *processing_thread(void *);
-static void usage(void);
-
-void get_time_func(struct timeval *);
-
-static void
-print_version_info(void)
-{
-	TRACE_IN(print_version_info);
-	printf("cached v0.2 (20 Oct 2005)\nwas developed during SoC 2005\n");
-	TRACE_OUT(print_version_info);
-}
-
-static void
-usage(void)
-{
-	fprintf(stderr,
-	    "usage: cached [-dnst] [-i cachename] [-I cachename]\n");
-	exit(1);
-}
-
-static cache
-init_cache_(struct configuration *config)
-{
-	struct cache_params params;
-	cache retval;
-
-	struct configuration_entry *config_entry;
-	size_t	size, i;
-	int res;
-
-	TRACE_IN(init_cache_);
-
-	memset(&params, 0, sizeof(struct cache_params));
-	params.get_time_func = get_time_func;
-	retval = init_cache(&params);
-
-	size = configuration_get_entries_size(config);
-	for (i = 0; i < size; ++i) {
-		config_entry = configuration_get_entry(config, i);
-	    	/*
-	    	 * We should register common entries now - multipart entries
-	    	 * would be registered automatically during the queries.
-	    	 */
-		res = register_cache_entry(retval, (struct cache_entry_params *)
-			&config_entry->positive_cache_params);
-		config_entry->positive_cache_entry = find_cache_entry(retval,
-			config_entry->positive_cache_params.entry_name);
-		assert(config_entry->positive_cache_entry !=
-			INVALID_CACHE_ENTRY);
-
-		res = register_cache_entry(retval, (struct cache_entry_params *)
-			&config_entry->negative_cache_params);
-		config_entry->negative_cache_entry = find_cache_entry(retval,
-			config_entry->negative_cache_params.entry_name);
-		assert(config_entry->negative_cache_entry !=
-			INVALID_CACHE_ENTRY);
-	}
-
-	LOG_MSG_2("cache", "cache was successfully initialized");
-	TRACE_OUT(init_cache_);
-	return (retval);
-}
-
-static void
-destroy_cache_(cache the_cache)
-{
-	TRACE_IN(destroy_cache_);
-	destroy_cache(the_cache);
-	TRACE_OUT(destroy_cache_);
-}
-
-/*
- * Socket and kqueues are prepared here. We have one global queue for both
- * socket and timers events.
- */
-static struct runtime_env *
-init_runtime_env(struct configuration *config)
-{
-	int serv_addr_len;
-	struct sockaddr_un serv_addr;
-
-	struct kevent eventlist;
-	struct timespec timeout;
-
-	struct runtime_env *retval;
-
-	TRACE_IN(init_runtime_env);
-	retval = (struct runtime_env *)malloc(sizeof(struct runtime_env));
-	assert(retval != NULL);
-	memset(retval, 0, sizeof(struct runtime_env));
-
-	retval->sockfd = socket(PF_LOCAL, SOCK_STREAM, 0);
-
-	if (config->force_unlink == 1)
-		unlink(config->socket_path);
-
-	memset(&serv_addr, 0, sizeof(struct sockaddr_un));
-	serv_addr.sun_family = PF_LOCAL;
-	strncpy(serv_addr.sun_path, config->socket_path,
-		sizeof(serv_addr.sun_path));
-	serv_addr_len = sizeof(serv_addr.sun_family) +
-		strlen(serv_addr.sun_path) + 1;
-
-	if (bind(retval->sockfd, (struct sockaddr *)&serv_addr,
-		serv_addr_len) == -1) {
-		close(retval->sockfd);
-		free(retval);
-
-		LOG_ERR_2("runtime environment", "can't bind socket to path: "
-			"%s", config->socket_path);
-		TRACE_OUT(init_runtime_env);
-		return (NULL);
-	}
-	LOG_MSG_2("runtime environment", "using socket %s",
-		config->socket_path);
-
-	/*
-	 * Here we're marking socket as non-blocking and setting its backlog
-	 * to the maximum value
-	 */
-	chmod(config->socket_path, config->socket_mode);
-	listen(retval->sockfd, -1);
-	fcntl(retval->sockfd, F_SETFL, O_NONBLOCK);
-
-	retval->queue = kqueue();
-	assert(retval->queue != -1);
-
-	EV_SET(&eventlist, retval->sockfd, EVFILT_READ, EV_ADD | EV_ONESHOT,
-		0, 0, 0);
-	memset(&timeout, 0, sizeof(struct timespec));
-	kevent(retval->queue, &eventlist, 1, NULL, 0, &timeout);
-
-	LOG_MSG_2("runtime environment", "successfully initialized");
-	TRACE_OUT(init_runtime_env);
-	return (retval);
-}
-
-static void
-destroy_runtime_env(struct runtime_env *env)
-{
-	TRACE_IN(destroy_runtime_env);
-	close(env->queue);
-	close(env->sockfd);
-	free(env);
-	TRACE_OUT(destroy_runtime_env);
-}
-
-static void
-accept_connection(struct kevent *event_data, struct runtime_env *env,
-	struct configuration *config)
-{
-	struct kevent	eventlist[2];
-	struct timespec	timeout;
-	struct query_state	*qstate;
-
-	int	fd;
-	int	res;
-
-	uid_t	euid;
-	gid_t	egid;
-
-	TRACE_IN(accept_connection);
-	fd = accept(event_data->ident, NULL, NULL);
-	if (fd == -1) {
-		LOG_ERR_2("accept_connection", "error %d during accept()",
-		    errno);
-		TRACE_OUT(accept_connection);
-		return;
-	}
-
-	if (getpeereid(fd, &euid, &egid) != 0) {
-		LOG_ERR_2("accept_connection", "error %d during getpeereid()",
-			errno);
-		TRACE_OUT(accept_connection);
-		return;
-	}
-
-	qstate = init_query_state(fd, sizeof(int), euid, egid);
-	if (qstate == NULL) {
-		LOG_ERR_2("accept_connection", "can't init query_state");
-		TRACE_OUT(accept_connection);
-		return;
-	}
-
-	memset(&timeout, 0, sizeof(struct timespec));
-	EV_SET(&eventlist[0], fd, EVFILT_TIMER, EV_ADD | EV_ONESHOT,
-		0, qstate->timeout.tv_sec * 1000, qstate);
-	EV_SET(&eventlist[1], fd, EVFILT_READ, EV_ADD | EV_ONESHOT,
-		NOTE_LOWAT, qstate->kevent_watermark, qstate);
-	res = kevent(env->queue, eventlist, 2, NULL, 0, &timeout);
-	if (res < 0)
-		LOG_ERR_2("accept_connection", "kevent error");
-
-	TRACE_OUT(accept_connection);
-}
-
-static void
-process_socket_event(struct kevent *event_data, struct runtime_env *env,
-	struct configuration *config)
-{
-	struct kevent	eventlist[2];
-	struct timeval	query_timeout;
-	struct timespec	kevent_timeout;
-	int	nevents;
-	int	eof_res, res;
-	ssize_t	io_res;
-	struct query_state *qstate;
-
-	TRACE_IN(process_socket_event);
-	eof_res = event_data->flags & EV_EOF ? 1 : 0;
-	res = 0;
-
-	memset(&kevent_timeout, 0, sizeof(struct timespec));
-	EV_SET(&eventlist[0], event_data->ident, EVFILT_TIMER, EV_DELETE,
-		0, 0, NULL);
-	nevents = kevent(env->queue, eventlist, 1, NULL, 0, &kevent_timeout);
-	if (nevents == -1) {
-		if (errno == ENOENT) {
-			/* the timer is already handling this event */
-			TRACE_OUT(process_socket_event);
-			return;
-		} else {
-			/* some other error happened */
-			LOG_ERR_2("process_socket_event", "kevent error, errno"
-				" is %d", errno);
-			TRACE_OUT(process_socket_event);
-			return;
-		}
-	}
-	qstate = (struct query_state *)event_data->udata;
-
-	/*
-	 * If the buffer that is to be send/received is too large,
-	 * we send it implicitly, by using query_io_buffer_read and
-	 * query_io_buffer_write functions in the query_state. These functions
-	 * use the temporary buffer, which is later send/received in parts.
-	 * The code below implements buffer splitting/mergind for send/receive
-	 * operations. It also does the actual socket IO operations.
-	 */
-	if (((qstate->use_alternate_io == 0) &&
-		(qstate->kevent_watermark <= event_data->data)) ||
-		((qstate->use_alternate_io != 0) &&
-		(qstate->io_buffer_watermark <= event_data->data))) {
-		if (qstate->use_alternate_io != 0) {
-			switch (qstate->io_buffer_filter) {
-			case EVFILT_READ:
-				io_res = query_socket_read(qstate,
-					qstate->io_buffer_p,
-					qstate->io_buffer_watermark);
-				if (io_res < 0) {
-					qstate->use_alternate_io = 0;
-					qstate->process_func = NULL;
-				} else {
-					qstate->io_buffer_p += io_res;
-					if (qstate->io_buffer_p ==
-					    	qstate->io_buffer +
-						qstate->io_buffer_size) {
-						qstate->io_buffer_p =
-						    qstate->io_buffer;
-						qstate->use_alternate_io = 0;
-					}
-				}
-			break;
-			default:
-			break;
-			}
-		}
-
-		if (qstate->use_alternate_io == 0) {
-			do {
-				res = qstate->process_func(qstate);
-			} while ((qstate->kevent_watermark == 0) &&
-					(qstate->process_func != NULL) &&
-					(res == 0));
-
-			if (res != 0)
-				qstate->process_func = NULL;
-		}
-
-		if ((qstate->use_alternate_io != 0) &&
-			(qstate->io_buffer_filter == EVFILT_WRITE)) {
-			io_res = query_socket_write(qstate, qstate->io_buffer_p,
-				qstate->io_buffer_watermark);
-			if (io_res < 0) {
-				qstate->use_alternate_io = 0;
-				qstate->process_func = NULL;
-			} else
-				qstate->io_buffer_p += io_res;
-		}
-	} else {
-		/* assuming that socket was closed */
-		qstate->process_func = NULL;
-		qstate->use_alternate_io = 0;
-	}
-
-	if (((qstate->process_func == NULL) &&
-	    	(qstate->use_alternate_io == 0)) ||
-		(eof_res != 0) || (res != 0)) {
-		destroy_query_state(qstate);
-		close(event_data->ident);
-		TRACE_OUT(process_socket_event);
-		return;
-	}
-
-	/* updating the query_state lifetime variable */
-	get_time_func(&query_timeout);
-	query_timeout.tv_usec = 0;
-	query_timeout.tv_sec -= qstate->creation_time.tv_sec;
-	if (query_timeout.tv_sec > qstate->timeout.tv_sec)
-		query_timeout.tv_sec = 0;
-	else
-		query_timeout.tv_sec = qstate->timeout.tv_sec -
-			query_timeout.tv_sec;
-
-	if ((qstate->use_alternate_io != 0) && (qstate->io_buffer_p ==
-		qstate->io_buffer + qstate->io_buffer_size))
-		qstate->use_alternate_io = 0;
-
-	if (qstate->use_alternate_io == 0) {
-		/*
-		 * If we must send/receive the large block of data,
-		 * we should prepare the query_state's io_XXX fields.
-		 * We should also substitute its write_func and read_func
-		 * with the query_io_buffer_write and query_io_buffer_read,
-		 * which will allow us to implicitly send/receive this large
-		 * buffer later (in the subsequent calls to the
-		 * process_socket_event).
-		 */
-		if (qstate->kevent_watermark > MAX_SOCKET_IO_SIZE) {
-			if (qstate->io_buffer != NULL)
-				free(qstate->io_buffer);
-
-			qstate->io_buffer = (char *)malloc(
-				qstate->kevent_watermark);
-			assert(qstate->io_buffer != NULL);
-			memset(qstate->io_buffer, 0, qstate->kevent_watermark);
-
-			qstate->io_buffer_p = qstate->io_buffer;
-			qstate->io_buffer_size = qstate->kevent_watermark;
-			qstate->io_buffer_filter = qstate->kevent_filter;
-
-			qstate->write_func = query_io_buffer_write;
-			qstate->read_func = query_io_buffer_read;
-
-			if (qstate->kevent_filter == EVFILT_READ)
-				qstate->use_alternate_io = 1;
-
-			qstate->io_buffer_watermark = MAX_SOCKET_IO_SIZE;
-			EV_SET(&eventlist[1], event_data->ident,
-				qstate->kevent_filter, EV_ADD | EV_ONESHOT,
-				NOTE_LOWAT, MAX_SOCKET_IO_SIZE, qstate);
-		} else {
-			EV_SET(&eventlist[1], event_data->ident,
-		    		qstate->kevent_filter, EV_ADD | EV_ONESHOT,
-		    		NOTE_LOWAT, qstate->kevent_watermark, qstate);
-		}
-	} else {
-		if (qstate->io_buffer + qstate->io_buffer_size -
-		    	qstate->io_buffer_p <
-			MAX_SOCKET_IO_SIZE) {
-			qstate->io_buffer_watermark = qstate->io_buffer +
-				qstate->io_buffer_size - qstate->io_buffer_p;
-			EV_SET(&eventlist[1], event_data->ident,
-			    	qstate->io_buffer_filter,
-				EV_ADD | EV_ONESHOT, NOTE_LOWAT,
-				qstate->io_buffer_watermark,
-				qstate);
-		} else {
-			qstate->io_buffer_watermark = MAX_SOCKET_IO_SIZE;
-			EV_SET(&eventlist[1], event_data->ident,
-		    		qstate->io_buffer_filter, EV_ADD | EV_ONESHOT,
-		    		NOTE_LOWAT, MAX_SOCKET_IO_SIZE, qstate);
-		}
-	}
-	EV_SET(&eventlist[0], event_data->ident, EVFILT_TIMER,
-		EV_ADD | EV_ONESHOT, 0, query_timeout.tv_sec * 1000, qstate);
-	kevent(env->queue, eventlist, 2, NULL, 0, &kevent_timeout);
-
-	TRACE_OUT(process_socket_event);
-}
-
-/*
- * This routine is called if timer event has been signaled in the kqueue. It
- * just closes the socket and destroys the query_state.
- */
-static void
-process_timer_event(struct kevent *event_data, struct runtime_env *env,
-	struct configuration *config)
-{
-	struct query_state	*qstate;
-
-	TRACE_IN(process_timer_event);
-	qstate = (struct query_state *)event_data->udata;
-	destroy_query_state(qstate);
-	close(event_data->ident);
-	TRACE_OUT(process_timer_event);
-}
-
-/*
- * Processing loop is the basic processing routine, that forms a body of each
- * procssing thread
- */
-static void
-processing_loop(cache the_cache, struct runtime_env *env,
-	struct configuration *config)
-{
-	struct timespec timeout;
-	const int eventlist_size = 1;
-	struct kevent eventlist[eventlist_size];
-	int nevents, i;
-
-	TRACE_MSG("=> processing_loop");
-	memset(&timeout, 0, sizeof(struct timespec));
-	memset(&eventlist, 0, sizeof(struct kevent) * eventlist_size);
-
-	for (;;) {
-		nevents = kevent(env->queue, NULL, 0, eventlist,
-	    		eventlist_size, NULL);
-		/*
-		 * we can only receive 1 event on success
-		 */
-		if (nevents == 1) {
-			struct kevent *event_data;
-			event_data = &eventlist[0];
-
-			if (event_data->ident == env->sockfd) {
-				for (i = 0; i < event_data->data; ++i)
-				    accept_connection(event_data, env, config);
-
-				EV_SET(eventlist, s_runtime_env->sockfd,
-				    EVFILT_READ, EV_ADD | EV_ONESHOT,
-				    0, 0, 0);
-				memset(&timeout, 0,
-				    sizeof(struct timespec));
-				kevent(s_runtime_env->queue, eventlist,
-				    1, NULL, 0, &timeout);
-
-			} else {
-				switch (event_data->filter) {
-				case EVFILT_READ:
-				case EVFILT_WRITE:
-					process_socket_event(event_data,
-						env, config);
-					break;
-				case EVFILT_TIMER:
-					process_timer_event(event_data,
-						env, config);
-					break;
-				default:
-					break;
-				}
-			}
-		} else {
-			/* this branch shouldn't be currently executed */
-		}
-	}
-
-	TRACE_MSG("<= processing_loop");
-}
-
-/*
- * Wrapper above the processing loop function. It sets the thread signal mask
- * to avoid SIGPIPE signals (which can happen if the client works incorrectly).
- */
-static void *
-processing_thread(void *data)
-{
-	struct processing_thread_args	*args;
-	sigset_t new;
-
-	TRACE_MSG("=> processing_thread");
-	args = (struct processing_thread_args *)data;
-
-	sigemptyset(&new);
-	sigaddset(&new, SIGPIPE);
-	if (pthread_sigmask(SIG_BLOCK, &new, NULL) != 0)
-		LOG_ERR_1("processing thread",
-			"thread can't block the SIGPIPE signal");
-
-	processing_loop(args->the_cache, args->the_runtime_env,
-		args->the_configuration);
-	free(args);
-	TRACE_MSG("<= processing_thread");
-
-	return (NULL);
-}
-
-void
-get_time_func(struct timeval *time)
-{
-	struct timespec res;
-	memset(&res, 0, sizeof(struct timespec));
-	clock_gettime(CLOCK_MONOTONIC, &res);
-
-	time->tv_sec = res.tv_sec;
-	time->tv_usec = 0;
-}
-
-/*
- * The idea of _nss_cache_cycle_prevention_function is that nsdispatch will
- * search for this symbol in the executable. This symbol is the attribute of
- * the caching daemon. So, if it exists, nsdispatch won't try to connect to
- * the caching daemon and will just ignore the 'cache' source in the
- * nsswitch.conf. This method helps to avoid cycles and organize
- * self-performing requests.
- */
-void
-_nss_cache_cycle_prevention_function(void)
-{
-}
-
-int
-main(int argc, char *argv[])
-{
-	struct processing_thread_args *thread_args;
-	pthread_t *threads;
-
-	struct pidfh *pidfile;
-	pid_t pid;
-
-	char const *config_file;
-	char const *error_str;
-	int error_line;
-	int i, res;
-
-	int trace_mode_enabled;
-	int force_single_threaded;
-	int do_not_daemonize;
-	int clear_user_cache_entries, clear_all_cache_entries;
-	char *user_config_entry_name, *global_config_entry_name;
-	int show_statistics;
-	int daemon_mode, interactive_mode;
-
-
-	/* by default all debug messages are omitted */
-	TRACE_OFF();
-
-	/* startup output */
-	print_version_info();
-
-	/* parsing command line arguments */
-	trace_mode_enabled = 0;
-	force_single_threaded = 0;
-	do_not_daemonize = 0;
-	clear_user_cache_entries = 0;
-	clear_all_cache_entries = 0;
-	show_statistics = 0;
-	user_config_entry_name = NULL;
-	global_config_entry_name = NULL;
-	while ((res = getopt(argc, argv, "nstdi:I:")) != -1) {
-		switch (res) {
-		case 'n':
-			do_not_daemonize = 1;
-			break;
-		case 's':
-			force_single_threaded = 1;
-			break;
-		case 't':
-			trace_mode_enabled = 1;
-			break;
-		case 'i':
-			clear_user_cache_entries = 1;
-			if (optarg != NULL)
-				if (strcmp(optarg, "all") != 0)
-					user_config_entry_name = strdup(optarg);
-			break;
-		case 'I':
-			clear_all_cache_entries = 1;
-			if (optarg != NULL)
-				if (strcmp(optarg, "all") != 0)
-					global_config_entry_name =
-						strdup(optarg);
-			break;
-		case 'd':
-			show_statistics = 1;
-			break;
-		case '?':
-		default:
-			usage();
-			/* NOT REACHED */
-		}
-	}
-
-	daemon_mode = do_not_daemonize | force_single_threaded |
-		trace_mode_enabled;
-	interactive_mode = clear_user_cache_entries | clear_all_cache_entries |
-		show_statistics;
-
-	if ((daemon_mode != 0) && (interactive_mode != 0)) {
-		LOG_ERR_1("main", "daemon mode and interactive_mode arguments "
-			"can't be used together");
-		usage();
-	}
-
-	if (interactive_mode != 0) {
-		FILE *pidfin = fopen(DEFAULT_PIDFILE_PATH, "r");
-		char pidbuf[256];
-
-		struct cached_connection_params connection_params;
-		cached_connection connection;
-
-		int result;
-
-		if (pidfin == NULL)
-			errx(EXIT_FAILURE, "There is no daemon running.");
-
-		memset(pidbuf, 0, sizeof(pidbuf));
-		fread(pidbuf, sizeof(pidbuf) - 1, 1, pidfin);
-		fclose(pidfin);
-
-		if (ferror(pidfin) != 0)
-			errx(EXIT_FAILURE, "Can't read from pidfile.");
-
-		if (sscanf(pidbuf, "%d", &pid) != 1)
-			errx(EXIT_FAILURE, "Invalid pidfile.");
-		LOG_MSG_1("main", "daemon PID is %d", pid);
-
-
-		memset(&connection_params, 0,
-			sizeof(struct cached_connection_params));
-		connection_params.socket_path = DEFAULT_SOCKET_PATH;
-		connection = open_cached_connection__(&connection_params);
-		if (connection == INVALID_CACHED_CONNECTION)
-			errx(EXIT_FAILURE, "Can't connect to the daemon.");
-
-		if (clear_user_cache_entries != 0) {
-			result = cached_transform__(connection,
-				user_config_entry_name, TT_USER);
-			if (result != 0)
-				LOG_MSG_1("main",
-					"user cache transformation failed");
-			else
-				LOG_MSG_1("main",
-					"user cache_transformation "
-					"succeeded");
-		}
-
-		if (clear_all_cache_entries != 0) {
-			if (geteuid() != 0)
-				errx(EXIT_FAILURE, "Only root can initiate "
-					"global cache transformation.");
-
-			result = cached_transform__(connection,
-				global_config_entry_name, TT_ALL);
-			if (result != 0)
-				LOG_MSG_1("main",
-					"global cache transformation "
-					"failed");
-			else
-				LOG_MSG_1("main",
-					"global cache transformation "
-					"succeeded");
-		}
-
-		close_cached_connection__(connection);
-
-		free(user_config_entry_name);
-		free(global_config_entry_name);
-		return (EXIT_SUCCESS);
-	}
-
-	pidfile = pidfile_open(DEFAULT_PIDFILE_PATH, 0644, &pid);
-	if (pidfile == NULL) {
-		if (errno == EEXIST)
-			errx(EXIT_FAILURE, "Daemon already running, pid: %d.",
-				pid);
-		warn("Cannot open or create pidfile");
-	}
-
-	if (trace_mode_enabled == 1)
-		TRACE_ON();
-
-	/* blocking the main thread from receiving SIGPIPE signal */
-	sigblock(sigmask(SIGPIPE));
-
-	/* daemonization */
-	if (do_not_daemonize == 0) {
-		res = daemon(0, trace_mode_enabled == 0 ? 0 : 1);
-		if (res != 0) {
-			LOG_ERR_1("main", "can't daemonize myself: %s",
-		    		strerror(errno));
-			pidfile_remove(pidfile);
-			goto fin;
-		} else
-			LOG_MSG_1("main", "successfully daemonized");
-	}
-
-	pidfile_write(pidfile);
-
-	s_agent_table = init_agent_table();
-	register_agent(s_agent_table, init_passwd_agent());
-	register_agent(s_agent_table, init_passwd_mp_agent());
-	register_agent(s_agent_table, init_group_agent());
-	register_agent(s_agent_table, init_group_mp_agent());
-	register_agent(s_agent_table, init_services_agent());
-	register_agent(s_agent_table, init_services_mp_agent());
-	LOG_MSG_1("main", "request agents registered successfully");
-
-	/*
- 	 * Hosts agent can't work properly until we have access to the
-	 * appropriate dtab structures, which are used in nsdispatch
-	 * calls
-	 *
-	 register_agent(s_agent_table, init_hosts_agent());
-	*/
-
-	/* configuration initialization */
-	s_configuration = init_configuration();
-	fill_configuration_defaults(s_configuration);
-
-	error_str = NULL;
-	error_line = 0;
-	config_file = CONFIG_PATH;
-
-	res = parse_config_file(s_configuration, config_file, &error_str,
-		&error_line);
-	if ((res != 0) && (error_str == NULL)) {
-		config_file = DEFAULT_CONFIG_PATH;
-		res = parse_config_file(s_configuration, config_file,
-			&error_str, &error_line);
-	}
-
-	if (res != 0) {
-		if (error_str != NULL) {
-		LOG_ERR_1("main", "error in configuration file(%s, %d): %s\n",
-			config_file, error_line, error_str);
-		} else {
-		LOG_ERR_1("main", "no configuration file found "
-		    	"- was looking for %s and %s",
-			CONFIG_PATH, DEFAULT_CONFIG_PATH);
-		}
-		destroy_configuration(s_configuration);
-		return (-1);
-	}
-
-	if (force_single_threaded == 1)
-		s_configuration->threads_num = 1;
-
-	/* cache initialization */
-	s_cache = init_cache_(s_configuration);
-	if (s_cache == NULL) {
-		LOG_ERR_1("main", "can't initialize the cache");
-		destroy_configuration(s_configuration);
-		return (-1);
-	}
-
-	/* runtime environment initialization */
-	s_runtime_env = init_runtime_env(s_configuration);
-	if (s_runtime_env == NULL) {
-		LOG_ERR_1("main", "can't initialize the runtime environment");
-		destroy_configuration(s_configuration);
-		destroy_cache_(s_cache);
-		return (-1);
-	}
-
-	if (s_configuration->threads_num > 1) {
-		threads = (pthread_t *)malloc(sizeof(pthread_t) *
-			s_configuration->threads_num);
-		memset(threads, 0, sizeof(pthread_t) *
-	    		s_configuration->threads_num);
-		for (i = 0; i < s_configuration->threads_num; ++i) {
-			thread_args = (struct processing_thread_args *)malloc(
-				sizeof(struct processing_thread_args));
-			thread_args->the_cache = s_cache;
-			thread_args->the_runtime_env = s_runtime_env;
-			thread_args->the_configuration = s_configuration;
-
-			LOG_MSG_1("main", "thread #%d was successfully created",
-				i);
-			pthread_create(&threads[i], NULL, processing_thread,
-				thread_args);
-
-			thread_args = NULL;
-		}
-
-		for (i = 0; i < s_configuration->threads_num; ++i)
-			pthread_join(threads[i], NULL);
-	} else {
-		LOG_MSG_1("main", "working in single-threaded mode");
-		processing_loop(s_cache, s_runtime_env, s_configuration);
-	}
-
-fin:
-	/* runtime environment destruction */
-	destroy_runtime_env(s_runtime_env);
-
-	/* cache destruction */
-	destroy_cache_(s_cache);
-
-	/* configuration destruction */
-	destroy_configuration(s_configuration);
-
-	/* agents table destruction */
-	destroy_agent_table(s_agent_table);
-
-	pidfile_remove(pidfile);
-	return (EXIT_SUCCESS);
-}
diff --git a/usr.sbin/cached/cached.conf.5 b/usr.sbin/cached/cached.conf.5
deleted file mode 100644
index 6e5bec1..0000000
--- a/usr.sbin/cached/cached.conf.5
+++ /dev/null
@@ -1,148 +0,0 @@
-.\" Copyright (c) 2005 Michael Bushkov <bushman@rsu.ru>
-.\" All rights reserved.
-.\"
-.\" Redistribution and use in source and binary forms, with or without
-.\" modification, are permitted provided that the following conditions
-.\" are met:
-.\" 1. Redistributions of source code must retain the above copyright
-.\"    notice, this list of conditions and the following disclaimer.
-.\" 2. Redistributions in binary form must reproduce the above copyright
-.\"    notice, this list of conditions and the following disclaimer in the
-.\"    documentation and/or other materials provided with the distribution.
-.\"
-.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
-.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-.\" ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
-.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
-.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
-.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
-.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
-.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
-.\" SUCH DAMAGE.
-.\"
-.\" $FreeBSD$
-.\"
-.Dd April 30, 2006
-.Dt CACHED.CONF 5
-.Os
-.Sh NAME
-.Nm cached.conf
-.Nd "caching daemon configuration file"
-.Sh DESCRIPTION
-The
-.Nm
-file
-is used by the
-.Xr cached 8
-daemon and is read on its startup.
-Its syntax is mostly similar to the
-.Pa nscd.conf
-syntax in
-.Tn Linux
-and
-.Tn Solaris .
-It has some differences, though \[em] see them below.
-.Pp
-Each line specifies either an attribute and a
-.Ar value ,
-or an attribute, a
-.Ar cachename
-and a
-.Ar value .
-Usual cachenames are
-.Dq Li passwd ,
-.Dq Li groups ,
-.Dq Li hosts ,
-.Dq Li services ,
-.Dq Li protocols
-and
-.Dq Li rpc .
-You can also use any other
-.Ar cachename
-(for example, if some third-party
-application uses nsswitch).
-.Bl -tag -width indent
-.It Va threads Op Ar value
-Number of threads, which would listen for connections and process requests.
-The minimum is 1.
-The default value is 8.
-.It Va enable-cache Oo Ar cachename Oc Op Cm yes | no
-Enables or disables the cache for specified
-.Ar cachename .
-.It Va positive-time-to-live Oo Ar cachename Oc Op Ar value
-Sets the TTL (time-to-live) for the specified cache in seconds.
-Larger values can increase system's performance, but they also can affect
-the cache coherence.
-The default value is 3600.
-.It Va positive-policy Oo Ar cachename Oc Op Cm fifo | lru | lfu
-The policy that is applied to erase some of the cache elements, when the
-size limit of the given
-.Ar cachename
-is exceeded.
-Possible policies are:
-.Cm fifo
-(first-in-first-out),
-.Cm lru
-(least-recently-used), and
-.Cm lfu
-(least-frequently-used).
-The default policy is
-.Cm lru .
-.It Va negative-time-to-live Oo Ar cachename Oc Op Ar value
-The TTL of the negative cached elements in seconds.
-The larger values can significantly increase system performance in some
-environments (when dealing with files with UIDs, which are not in system
-databases, for example).
-This number should be kept low to avoid the cache coherence problems.
-The default value is 60.
-.It Va negative-policy Oo Ar cachename Oc Op Cm fifo | lru | lfu
-The same as the positive-policy, but this one is applied to the negative
-elements of the given
-.Ar cachename .
-The default policy is fifo.
-.It Va suggested-size Oo Ar cachename Oc Op Ar value
-This is the internal hash table size.
-The value should be a prime number for optimum performance.
-You should only change this value when the number of cached elements is
-significantly (in 5-10 times) greater then the default hash table size (255).
-.It Va keep-hot-count Oo Ar cachename Oc Op Ar value
-The size limit of the cache with the given
-.Ar cachename .
-When it is exceeded, the policy will be applied.
-The default value is 2048.
-.It Va perform-actual-lookups Oo Ar cachename Oc Op Cm yes | no
-If enabled, the
-.Xr cached 8
-does not simply receive and cache the NSS-requests results, but performs
-all the lookups by itself and only returns the responses.
-If this feature is enabled, then for the given
-.Ar cachename
-.Xr cached 8
-will act similarly to the NSCD.
-.Pp
-.Sy NOTE :
-this feature is currently experimental \[em] it supports only
-.Dq Li passwd ,
-.Dq Li groups
-and
-.Dq Li services
-cachenames.
-.El
-.Sh NOTES
-You can use the
-.Ql #
-symbol at the beginning of the line for comments.
-.Sh FILES
-.Bl -tag -width ".Pa /etc/cached.conf" -compact
-.It Pa /etc/cached.conf
-.El
-.Sh SEE ALSO
-.Xr cached 8
-.Sh AUTHORS
-.An Michael Bushkov
-.Aq bushman@rsu.ru
-.Sh BUGS
-Please send bug reports and suggestions to
-.Aq bushman@rsu.ru .
diff --git a/usr.sbin/cached/cachedcli.c b/usr.sbin/cached/cachedcli.c
deleted file mode 100644
index c78c875..0000000
--- a/usr.sbin/cached/cachedcli.c
+++ /dev/null
@@ -1,284 +0,0 @@
-/*-
- * Copyright (c) 2005 Michael Bushkov <bushman@rsu.ru>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- */
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <sys/event.h>
-#include <sys/uio.h>
-#include <sys/un.h>
-#include <assert.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-
-#include "debug.h"
-#include "cachedcli.h"
-#include "protocol.h"
-
-#define DEFAULT_CACHED_IO_TIMEOUT	4
-
-static int safe_write(struct cached_connection_ *, const void *, size_t);
-static int safe_read(struct cached_connection_ *, void *, size_t);
-static int send_credentials(struct cached_connection_ *, int);
-
-static int
-safe_write(struct cached_connection_ *connection, const void *data,
-	size_t data_size)
-{
-	struct kevent eventlist;
-	int	nevents;
-	size_t result;
-	ssize_t s_result;
-	struct timespec	timeout;
-
-	if (data_size == 0)
-		return (0);
-
-	timeout.tv_sec = DEFAULT_CACHED_IO_TIMEOUT;
-	timeout.tv_nsec = 0;
-	result = 0;
-	do {
-		nevents = kevent(connection->write_queue, NULL, 0, &eventlist,
-	    		1, &timeout);
-		if ((nevents == 1) && (eventlist.filter == EVFILT_WRITE)) {
-			s_result = write(connection->sockfd, data + result,
-				eventlist.data < data_size - result ?
-		    		eventlist.data : data_size - result);
-			if (s_result == -1)
-				return (-1);
-			else
-				result += s_result;
-
-			if (eventlist.flags & EV_EOF)
-				return (result < data_size ? -1 : 0);
-		} else
-			return (-1);
-	} while (result < data_size);
-
-	return (0);
-}
-
-static int
-safe_read(struct cached_connection_ *connection, void *data, size_t data_size)
-{
-	struct kevent eventlist;
-	size_t result;
-	ssize_t s_result;
-	struct timespec timeout;
-	int nevents;
-
-	if (data_size == 0)
-		return (0);
-
-	timeout.tv_sec = DEFAULT_CACHED_IO_TIMEOUT;
-	timeout.tv_nsec = 0;
-	result = 0;
-	do {
-		nevents = kevent(connection->read_queue, NULL, 0, &eventlist, 1,
-			&timeout);
-		if ((nevents == 1) && (eventlist.filter == EVFILT_READ)) {
-			s_result = read(connection->sockfd, data + result,
-			eventlist.data <= data_size - result ? eventlist.data :
-				data_size - result);
-			if (s_result == -1)
-				return (-1);
-			else
-				result += s_result;
-
-			if (eventlist.flags & EV_EOF)
-				return (result < data_size ? -1 : 0);
-		} else
-			return (-1);
-	} while (result < data_size);
-
-	return (0);
-}
-
-static int
-send_credentials(struct cached_connection_ *connection, int type)
-{
-	struct kevent eventlist;
-	int nevents;
-	ssize_t result;
-	int res;
-
-	struct msghdr	cred_hdr;
-	struct iovec	iov;
-
-	struct {
-		struct cmsghdr	hdr;
-		struct cmsgcred	creds;
-	} cmsg;
-
-	TRACE_IN(send_credentials);
-	memset(&cmsg, 0, sizeof(cmsg));
-	cmsg.hdr.cmsg_len = sizeof(cmsg);
-	cmsg.hdr.cmsg_level = SOL_SOCKET;
-	cmsg.hdr.cmsg_type = SCM_CREDS;
-
-	memset(&cred_hdr, 0, sizeof(struct msghdr));
-	cred_hdr.msg_iov = &iov;
-	cred_hdr.msg_iovlen = 1;
-	cred_hdr.msg_control = &cmsg;
-	cred_hdr.msg_controllen = sizeof(cmsg);
-
-	iov.iov_base = &type;
-	iov.iov_len = sizeof(int);
-
-	EV_SET(&eventlist, connection->sockfd, EVFILT_WRITE, EV_ADD,
-		NOTE_LOWAT, sizeof(int), NULL);
-	res = kevent(connection->write_queue, &eventlist, 1, NULL, 0, NULL);
-
-	nevents = kevent(connection->write_queue, NULL, 0, &eventlist, 1, NULL);
-	if ((nevents == 1) && (eventlist.filter == EVFILT_WRITE)) {
-		result = (sendmsg(connection->sockfd, &cred_hdr, 0) == -1) ? -1
-	    		: 0;
-		EV_SET(&eventlist, connection->sockfd, EVFILT_WRITE, EV_ADD,
-			0, 0, NULL);
-		kevent(connection->write_queue, &eventlist, 1, NULL, 0, NULL);
-		TRACE_OUT(send_credentials);
-		return (result);
-	} else {
-		TRACE_OUT(send_credentials);
-		return (-1);
-	}
-}
-
-struct cached_connection_ *
-open_cached_connection__(struct cached_connection_params const *params)
-{
-	struct cached_connection_ *retval;
-	struct kevent eventlist;
-	struct sockaddr_un	client_address;
-	int client_address_len, client_socket;
-	int res;
-
-	TRACE_IN(open_cached_connection);
-	assert(params != NULL);
-
-	client_socket = socket(PF_LOCAL, SOCK_STREAM, 0);
-	client_address.sun_family = PF_LOCAL;
-	strncpy(client_address.sun_path, params->socket_path,
-		sizeof(client_address.sun_path));
-	client_address_len = sizeof(client_address.sun_family) +
-		strlen(client_address.sun_path) + 1;
-
-	res = connect(client_socket, (struct sockaddr *)&client_address,
-		client_address_len);
-	if (res == -1) {
-		close(client_socket);
-		TRACE_OUT(open_cached_connection);
-		return (NULL);
-	}
-	fcntl(client_socket, F_SETFL, O_NONBLOCK);
-
-	retval = malloc(sizeof(struct cached_connection_));
-	assert(retval != NULL);
-	memset(retval, 0, sizeof(struct cached_connection_));
-
-	retval->sockfd = client_socket;
-
-	retval->write_queue = kqueue();
-	assert(retval->write_queue != -1);
-
-	EV_SET(&eventlist, retval->sockfd, EVFILT_WRITE, EV_ADD,
-		0, 0, NULL);
-	res = kevent(retval->write_queue, &eventlist, 1, NULL, 0, NULL);
-
-	retval->read_queue = kqueue();
-	assert(retval->read_queue != -1);
-
-	EV_SET(&eventlist, retval->sockfd, EVFILT_READ, EV_ADD,
-		0, 0, NULL);
-	res = kevent(retval->read_queue, &eventlist, 1, NULL, 0, NULL);
-
-	TRACE_OUT(open_cached_connection);
-	return (retval);
-}
-
-void
-close_cached_connection__(struct cached_connection_ *connection)
-{
-
-	TRACE_IN(close_cached_connection);
-	assert(connection != NULL);
-
-	close(connection->sockfd);
-	close(connection->read_queue);
-	close(connection->write_queue);
-	free(connection);
-	TRACE_OUT(close_cached_connection);
-}
-
-int
-cached_transform__(struct cached_connection_ *connection,
-	const char *entry_name, int transformation_type)
-{
-	size_t name_size;
-	int error_code;
-	int result;
-
-	TRACE_IN(cached_transform);
-
-	error_code = -1;
-	result = 0;
-	result = send_credentials(connection, CET_TRANSFORM_REQUEST);
-	if (result != 0)
-		goto fin;
-
-	if (entry_name != NULL)
-		name_size = strlen(entry_name);
-	else
-		name_size = 0;
-
-	result = safe_write(connection, &name_size, sizeof(size_t));
-	if (result != 0)
-		goto fin;
-
-	result = safe_write(connection, &transformation_type, sizeof(int));
-	if (result != 0)
-		goto fin;
-
-	if (entry_name != NULL) {
-		result = safe_write(connection, entry_name, name_size);
-		if (result != 0)
-			goto fin;
-	}
-
-	result = safe_read(connection, &error_code, sizeof(int));
-	if (result != 0)
-		error_code = -1;
-
-fin:
-	TRACE_OUT(cached_transform);
-	return (error_code);
-}
diff --git a/usr.sbin/cached/cachedcli.h b/usr.sbin/cached/cachedcli.h
deleted file mode 100644
index 58d9ccc..0000000
--- a/usr.sbin/cached/cachedcli.h
+++ /dev/null
@@ -1,57 +0,0 @@
-/*-
- * Copyright (c) 2004 Michael Bushkov <bushman@rsu.ru>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * $FreeBSD$
- */
-
-#ifndef __CACHED_CACHEDCLI_H__
-#define __CACHED_CACHEDCLI_H__
-
-struct cached_connection_params {
-	char	*socket_path;
-	struct	timeval	timeout;
-};
-
-struct cached_connection_ {
-	int	sockfd;
-	int read_queue;
-	int write_queue;
-};
-
-/* simple abstractions for not to write "struct" every time */
-typedef struct cached_connection_		*cached_connection;
-typedef struct cached_connection_		*cached_mp_write_session;
-typedef struct cached_connection_		*cached_mp_read_session;
-
-#define	INVALID_CACHED_CONNECTION	(NULL)
-
-/* initialization/destruction routines */
-extern	cached_connection	open_cached_connection__(
-	struct cached_connection_params const *);
-extern	void	close_cached_connection__(cached_connection);
-
-extern	int cached_transform__(cached_connection, const char *, int);
-
-#endif
diff --git a/usr.sbin/cached/cachelib.c b/usr.sbin/cached/cachelib.c
deleted file mode 100644
index 4f771cc..0000000
--- a/usr.sbin/cached/cachelib.c
+++ /dev/null
@@ -1,1234 +0,0 @@
-/*-
- * Copyright (c) 2005 Michael Bushkov <bushman@rsu.ru>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- */
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-
-#include <sys/time.h>
-#include <assert.h>
-#include <stdlib.h>
-#include <string.h>
-#include "cachelib.h"
-#include "debug.h"
-
-#define INITIAL_ENTRIES_CAPACITY 32
-#define ENTRIES_CAPACITY_STEP 32
-
-#define STRING_SIMPLE_HASH_BODY(in_var, var, a, M)		\
-	for ((var) = 0; *(in_var) != '\0'; ++(in_var))		\
-		(var) = ((a)*(var) + *(in_var)) % (M)
-
-#define STRING_SIMPLE_MP2_HASH_BODY(in_var, var, a, M)		\
-	for ((var) = 0; *(in_var) != 0; ++(in_var))		\
-		(var) = ((a)*(var) + *(in_var)) & (M - 1)
-
-static int cache_elemsize_common_continue_func(struct cache_common_entry_ *,
-	struct cache_policy_item_ *);
-static int cache_lifetime_common_continue_func(struct cache_common_entry_ *,
-	struct cache_policy_item_ *);
-static void clear_cache_entry(struct cache_entry_ *);
-static void destroy_cache_entry(struct cache_entry_ *);
-static void destroy_cache_mp_read_session(struct cache_mp_read_session_ *);
-static void destroy_cache_mp_write_session(struct cache_mp_write_session_ *);
-static int entries_bsearch_cmp_func(const void *, const void *);
-static int entries_qsort_cmp_func(const void *, const void *);
-static struct cache_entry_ ** find_cache_entry_p(struct cache_ *,
-	const char *);
-static void flush_cache_entry(struct cache_entry_ *);
-static void flush_cache_policy(struct cache_common_entry_ *,
-	struct cache_policy_ *, struct cache_policy_ *,
-		int (*)(struct cache_common_entry_ *,
-		struct cache_policy_item_ *));
-static int ht_items_cmp_func(const void *, const void *);
-static int ht_items_fixed_size_left_cmp_func(const void *, const void *);
-static hashtable_index_t ht_item_hash_func(const void *, size_t);
-
-/*
- * Hashing and comparing routines, that are used with the hash tables
- */
-static int
-ht_items_cmp_func(const void *p1, const void *p2)
-{
-    	struct cache_ht_item_data_ *hp1, *hp2;
-	size_t min_size;
-	int result;
-
-	hp1 = (struct cache_ht_item_data_ *)p1;
-	hp2 = (struct cache_ht_item_data_ *)p2;
-
-	assert(hp1->key != NULL);
-	assert(hp2->key != NULL);
-
-	if (hp1->key_size != hp2->key_size) {
-		min_size = (hp1->key_size < hp2->key_size) ? hp1->key_size :
-			hp2->key_size;
-		result = memcmp(hp1->key, hp2->key, min_size);
-
-		if (result == 0)
-			return ((hp1->key_size < hp2->key_size) ? -1 : 1);
-		else
-			return (result);
-	} else
-		return (memcmp(hp1->key, hp2->key, hp1->key_size));
-}
-
-static int
-ht_items_fixed_size_left_cmp_func(const void *p1, const void *p2)
-{
-    	struct cache_ht_item_data_ *hp1, *hp2;
-	size_t min_size;
-	int result;
-
-	hp1 = (struct cache_ht_item_data_ *)p1;
-	hp2 = (struct cache_ht_item_data_ *)p2;
-
-	assert(hp1->key != NULL);
-	assert(hp2->key != NULL);
-
-	if (hp1->key_size != hp2->key_size) {
-		min_size = (hp1->key_size < hp2->key_size) ? hp1->key_size :
-			hp2->key_size;
-		result = memcmp(hp1->key, hp2->key, min_size);
-
-		if (result == 0)
-			if (min_size == hp1->key_size)
-			    return (0);
-			else
-			    return ((hp1->key_size < hp2->key_size) ? -1 : 1);
-		else
-			return (result);
-	} else
-		return (memcmp(hp1->key, hp2->key, hp1->key_size));
-}
-
-static hashtable_index_t
-ht_item_hash_func(const void *p, size_t cache_entries_size)
-{
-    	struct cache_ht_item_data_ *hp;
-	size_t i;
-
-	hashtable_index_t retval;
-
-	hp = (struct cache_ht_item_data_ *)p;
-	assert(hp->key != NULL);
-
-	retval = 0;
-	for (i = 0; i < hp->key_size; ++i)
-	    retval = (127 * retval + (unsigned char)hp->key[i]) %
-		cache_entries_size;
-
-	return retval;
-}
-
-HASHTABLE_GENERATE(cache_ht_, cache_ht_item_, struct cache_ht_item_data_, data,
-	ht_item_hash_func, ht_items_cmp_func);
-
-/*
- * Routines to sort and search the entries by name
- */
-static int
-entries_bsearch_cmp_func(const void *key, const void *ent)
-{
-
-	assert(key != NULL);
-	assert(ent != NULL);
-
-	return (strcmp((char const *)key,
-		(*(struct cache_entry_ const **)ent)->name));
-}
-
-static int
-entries_qsort_cmp_func(const void *e1, const void *e2)
-{
-
-	assert(e1 != NULL);
-	assert(e2 != NULL);
-
-	return (strcmp((*(struct cache_entry_ const **)e1)->name,
-		(*(struct cache_entry_ const **)e2)->name));
-}
-
-static struct cache_entry_ **
-find_cache_entry_p(struct cache_ *the_cache, const char *entry_name)
-{
-
-	return ((struct cache_entry_ **)(bsearch(entry_name, the_cache->entries,
-		the_cache->entries_size, sizeof(struct cache_entry_ *),
-		entries_bsearch_cmp_func)));
-}
-
-static void
-destroy_cache_mp_write_session(struct cache_mp_write_session_ *ws)
-{
-
-	struct cache_mp_data_item_	*data_item;
-
-	TRACE_IN(destroy_cache_mp_write_session);
-	assert(ws != NULL);
-	while (!TAILQ_EMPTY(&ws->items)) {
-		data_item = TAILQ_FIRST(&ws->items);
-		TAILQ_REMOVE(&ws->items, data_item, entries);
-		free(data_item->value);
-		free(data_item);
-	}
-
-	free(ws);
-	TRACE_OUT(destroy_cache_mp_write_session);
-}
-
-static void
-destroy_cache_mp_read_session(struct cache_mp_read_session_ *rs)
-{
-
-	TRACE_IN(destroy_cache_mp_read_session);
-	assert(rs != NULL);
-	free(rs);
-	TRACE_OUT(destroy_cache_mp_read_session);
-}
-
-static void
-destroy_cache_entry(struct cache_entry_ *entry)
-{
-	struct cache_common_entry_	*common_entry;
-	struct cache_mp_entry_		*mp_entry;
-	struct cache_mp_read_session_	*rs;
-	struct cache_mp_write_session_	*ws;
-	struct cache_ht_item_ *ht_item;
-	struct cache_ht_item_data_ *ht_item_data;
-
-	TRACE_IN(destroy_cache_entry);
-	assert(entry != NULL);
-
-	if (entry->params->entry_type == CET_COMMON) {
-		common_entry = (struct cache_common_entry_ *)entry;
-
-		HASHTABLE_FOREACH(&(common_entry->items), ht_item) {
-			HASHTABLE_ENTRY_FOREACH(ht_item, data, ht_item_data)
-			{
-				free(ht_item_data->key);
-				free(ht_item_data->value);
-			}
-			HASHTABLE_ENTRY_CLEAR(ht_item, data);
-		}
-
-		HASHTABLE_DESTROY(&(common_entry->items), data);
-
-		/* FIFO policy is always first */
-		destroy_cache_fifo_policy(common_entry->policies[0]);
-		switch (common_entry->common_params.policy) {
-		case CPT_LRU:
-			destroy_cache_lru_policy(common_entry->policies[1]);
-			break;
-		case CPT_LFU:
-			destroy_cache_lfu_policy(common_entry->policies[1]);
-			break;
-		default:
-		break;
-		}
-		free(common_entry->policies);
-	} else {
-		mp_entry = (struct cache_mp_entry_ *)entry;
-
-		while (!TAILQ_EMPTY(&mp_entry->ws_head)) {
-			ws = TAILQ_FIRST(&mp_entry->ws_head);
-			TAILQ_REMOVE(&mp_entry->ws_head, ws, entries);
-			destroy_cache_mp_write_session(ws);
-		}
-
-		while (!TAILQ_EMPTY(&mp_entry->rs_head)) {
-			rs = TAILQ_FIRST(&mp_entry->rs_head);
-			TAILQ_REMOVE(&mp_entry->rs_head, rs, entries);
-			destroy_cache_mp_read_session(rs);
-		}
-
-		if (mp_entry->completed_write_session != NULL)
-			destroy_cache_mp_write_session(
-				mp_entry->completed_write_session);
-
-		if (mp_entry->pending_write_session != NULL)
-			destroy_cache_mp_write_session(
-				mp_entry->pending_write_session);
-	}
-
-	free(entry->name);
-	free(entry);
-	TRACE_OUT(destroy_cache_entry);
-}
-
-static void
-clear_cache_entry(struct cache_entry_ *entry)
-{
-	struct cache_mp_entry_		*mp_entry;
-	struct cache_common_entry_	*common_entry;
-	struct cache_ht_item_ *ht_item;
-	struct cache_ht_item_data_ *ht_item_data;
-	struct cache_policy_ *policy;
-	struct cache_policy_item_ *item, *next_item;
-	size_t entry_size;
-	int i;
-
-	if (entry->params->entry_type == CET_COMMON) {
-		common_entry = (struct cache_common_entry_ *)entry;
-
-		entry_size = 0;
-		HASHTABLE_FOREACH(&(common_entry->items), ht_item) {
-			HASHTABLE_ENTRY_FOREACH(ht_item, data, ht_item_data)
-			{
-				free(ht_item_data->key);
-				free(ht_item_data->value);
-			}
-			entry_size += HASHTABLE_ENTRY_SIZE(ht_item, data);
-			HASHTABLE_ENTRY_CLEAR(ht_item, data);
-		}
-
-		common_entry->items_size -= entry_size;
-		for (i = 0; i < common_entry->policies_size; ++i) {
-			policy = common_entry->policies[i];
-
-			next_item = NULL;
-			item = policy->get_first_item_func(policy);
-			while (item != NULL) {
-				next_item = policy->get_next_item_func(policy,
-			    		item);
-				policy->remove_item_func(policy, item);
-				policy->destroy_item_func(item);
-				item = next_item;
-			}
-		}
-	} else {
-		mp_entry = (struct cache_mp_entry_ *)entry;
-
-		if (mp_entry->rs_size == 0) {
-			if (mp_entry->completed_write_session != NULL) {
-				destroy_cache_mp_write_session(
-					mp_entry->completed_write_session);
-				mp_entry->completed_write_session = NULL;
-			}
-
-			memset(&mp_entry->creation_time, 0,
-				sizeof(struct timeval));
-			memset(&mp_entry->last_request_time, 0,
-				sizeof(struct timeval));
-		}
-	}
-}
-
-/*
- * When passed to the flush_cache_policy, ensures that all old elements are
- * deleted.
- */
-static int
-cache_lifetime_common_continue_func(struct cache_common_entry_ *entry,
-	struct cache_policy_item_ *item)
-{
-
-	return ((item->last_request_time.tv_sec - item->creation_time.tv_sec >
-		entry->common_params.max_lifetime.tv_sec) ? 1: 0);
-}
-
-/*
- * When passed to the flush_cache_policy, ensures that all elements, that
- * exceed the size limit, are deleted.
- */
-static int
-cache_elemsize_common_continue_func(struct cache_common_entry_ *entry,
-	struct cache_policy_item_ *item)
-{
-
-	return ((entry->items_size > entry->common_params.satisf_elemsize) ? 1
-    		: 0);
-}
-
-/*
- * Removes the elements from the cache entry, while the continue_func returns 1.
- */
-static void
-flush_cache_policy(struct cache_common_entry_ *entry,
-	struct cache_policy_ *policy,
-	struct cache_policy_ *connected_policy,
-	int (*continue_func)(struct cache_common_entry_ *,
-		struct cache_policy_item_ *))
-{
-	struct cache_policy_item_ *item, *next_item, *connected_item;
-	struct cache_ht_item_ *ht_item;
-	struct cache_ht_item_data_ *ht_item_data, ht_key;
-	hashtable_index_t hash;
-
-	assert(policy != NULL);
-
-	next_item = NULL;
-	item = policy->get_first_item_func(policy);
-	while ((item != NULL) && (continue_func(entry, item) == 1)) {
-		next_item = policy->get_next_item_func(policy, item);
-
-		connected_item = item->connected_item;
-		policy->remove_item_func(policy, item);
-
-		memset(&ht_key, 0, sizeof(struct cache_ht_item_data_));
-		ht_key.key = item->key;
-		ht_key.key_size = item->key_size;
-
-		hash = HASHTABLE_CALCULATE_HASH(cache_ht_, &entry->items,
-			&ht_key);
-		assert(hash >= 0);
-		assert(hash < HASHTABLE_ENTRIES_COUNT(&entry->items));
-
-		ht_item = HASHTABLE_GET_ENTRY(&(entry->items), hash);
-		ht_item_data = HASHTABLE_ENTRY_FIND(cache_ht_, ht_item,
-			&ht_key);
-		assert(ht_item_data != NULL);
-		free(ht_item_data->key);
-		free(ht_item_data->value);
-		HASHTABLE_ENTRY_REMOVE(cache_ht_, ht_item, ht_item_data);
-		--entry->items_size;
-
-		policy->destroy_item_func(item);
-
-		if (connected_item != NULL) {
-			connected_policy->remove_item_func(connected_policy,
-				connected_item);
-			connected_policy->destroy_item_func(connected_item);
-		}
-
-		item = next_item;
-	}
-}
-
-static void
-flush_cache_entry(struct cache_entry_ *entry)
-{
-	struct cache_mp_entry_		*mp_entry;
-	struct cache_common_entry_	*common_entry;
-	struct cache_policy_ *policy, *connected_policy;
-
-	connected_policy = NULL;
-	if (entry->params->entry_type == CET_COMMON) {
-		common_entry = (struct cache_common_entry_ *)entry;
-		if ((common_entry->common_params.max_lifetime.tv_sec != 0) ||
-		    (common_entry->common_params.max_lifetime.tv_usec != 0)) {
-
-			policy = common_entry->policies[0];
-			if (common_entry->policies_size > 1)
-				connected_policy = common_entry->policies[1];
-
-			flush_cache_policy(common_entry, policy,
-				connected_policy,
-				cache_lifetime_common_continue_func);
-		}
-
-
-		if ((common_entry->common_params.max_elemsize != 0) &&
-			common_entry->items_size >
-			common_entry->common_params.max_elemsize) {
-
-			if (common_entry->policies_size > 1) {
-				policy = common_entry->policies[1];
-				connected_policy = common_entry->policies[0];
-			} else {
-				policy = common_entry->policies[0];
-				connected_policy = NULL;
-			}
-
-			flush_cache_policy(common_entry, policy,
-				connected_policy,
-				cache_elemsize_common_continue_func);
-		}
-	} else {
-		mp_entry = (struct cache_mp_entry_ *)entry;
-
-		if ((mp_entry->mp_params.max_lifetime.tv_sec != 0)
-			|| (mp_entry->mp_params.max_lifetime.tv_usec != 0)) {
-
-			if (mp_entry->last_request_time.tv_sec -
-				mp_entry->last_request_time.tv_sec >
-				mp_entry->mp_params.max_lifetime.tv_sec)
-				clear_cache_entry(entry);
-		}
-	}
-}
-
-struct cache_ *
-init_cache(struct cache_params const *params)
-{
-	struct cache_ *retval;
-
-	TRACE_IN(init_cache);
-	assert(params != NULL);
-
-	retval = (struct cache_ *)malloc(sizeof(struct cache_));
-	assert(retval != NULL);
-	memset(retval, 0, sizeof(struct cache_));
-
-	assert(params != NULL);
-	memcpy(&retval->params, params, sizeof(struct cache_params));
-
-	retval->entries = (struct cache_entry_ **)malloc(
-		sizeof(struct cache_entry_ *) * INITIAL_ENTRIES_CAPACITY);
-	assert(retval->entries != NULL);
-	memset(retval->entries, 0, sizeof(sizeof(struct cache_entry_ *)
-		* INITIAL_ENTRIES_CAPACITY));
-
-	retval->entries_capacity = INITIAL_ENTRIES_CAPACITY;
-	retval->entries_size = 0;
-
-	TRACE_OUT(init_cache);
-	return (retval);
-}
-
-void
-destroy_cache(struct cache_ *the_cache)
-{
-
-	TRACE_IN(destroy_cache);
-	assert(the_cache != NULL);
-
-	if (the_cache->entries != NULL) {
-		size_t i;
-		for (i = 0; i < the_cache->entries_size; ++i)
-			destroy_cache_entry(the_cache->entries[i]);
-
-		free(the_cache->entries);
-	}
-
-	free(the_cache);
-	TRACE_OUT(destroy_cache);
-}
-
-int
-register_cache_entry(struct cache_ *the_cache,
-	struct cache_entry_params const *params)
-{
-	int policies_size;
-	size_t entry_name_size;
-	struct cache_common_entry_	*new_common_entry;
-	struct cache_mp_entry_		*new_mp_entry;
-
-	TRACE_IN(register_cache_entry);
-	assert(the_cache != NULL);
-
-	if (find_cache_entry(the_cache, params->entry_name) != NULL) {
-		TRACE_OUT(register_cache_entry);
-		return (-1);
-	}
-
-	if (the_cache->entries_size == the_cache->entries_capacity) {
-		struct cache_entry_ **new_entries;
-		size_t	new_capacity;
-
-		new_capacity = the_cache->entries_capacity +
-			ENTRIES_CAPACITY_STEP;
-		new_entries = (struct cache_entry_ **)malloc(
-			sizeof(struct cache_entry_ *) * new_capacity);
-		assert(new_entries != NULL);
-
-		memset(new_entries, 0, sizeof(struct cache_entry_ *) *
-		    new_capacity);
-		memcpy(new_entries, the_cache->entries,
-			sizeof(struct cache_entry_ *)
-			* the_cache->entries_size);
-
-		free(the_cache->entries);
-		the_cache->entries = new_entries;
-	}
-
-	entry_name_size = strlen(params->entry_name);
-	switch (params->entry_type)
-	{
-	case CET_COMMON:
-		new_common_entry = (struct cache_common_entry_ *)malloc(
-			sizeof(struct cache_common_entry_));
-		assert(new_common_entry != NULL);
-		memset(new_common_entry, 0, sizeof(struct cache_common_entry_));
-
-		memcpy(&new_common_entry->common_params, params,
-			sizeof(struct common_cache_entry_params));
-		new_common_entry->params =
-		  (struct cache_entry_params *)&new_common_entry->common_params;
-
-		new_common_entry->common_params.entry_name = (char *)malloc(
-			entry_name_size+1);
-		assert(new_common_entry->common_params.entry_name != NULL);
-		memset(new_common_entry->common_params.entry_name, 0,
-			entry_name_size + 1);
-		strncpy(new_common_entry->common_params.entry_name,
-			params->entry_name, entry_name_size);
-		new_common_entry->name =
-			new_common_entry->common_params.entry_name;
-
-		HASHTABLE_INIT(&(new_common_entry->items),
-			struct cache_ht_item_data_, data,
-			new_common_entry->common_params.cache_entries_size);
-
-		if (new_common_entry->common_params.policy == CPT_FIFO)
-			policies_size = 1;
-		else
-			policies_size = 2;
-
-		new_common_entry->policies = (struct cache_policy_ **)malloc(
-			sizeof(struct cache_policy_ *) * policies_size);
-		assert(new_common_entry->policies != NULL);
-		memset(new_common_entry->policies, 0,
-			sizeof(struct cache_policy_ *) * policies_size);
-
-		new_common_entry->policies_size = policies_size;
-		new_common_entry->policies[0] = init_cache_fifo_policy();
-
-		if (policies_size > 1) {
-			switch (new_common_entry->common_params.policy) {
-			case CPT_LRU:
-				new_common_entry->policies[1] =
-					init_cache_lru_policy();
-			break;
-			case CPT_LFU:
-				new_common_entry->policies[1] =
-					init_cache_lfu_policy();
-			break;
-			default:
-			break;
-			}
-		}
-
-		new_common_entry->get_time_func =
-			the_cache->params.get_time_func;
-		the_cache->entries[the_cache->entries_size++] =
-			(struct cache_entry_ *)new_common_entry;
-		break;
-	case CET_MULTIPART:
-		new_mp_entry = (struct cache_mp_entry_ *)malloc(
-			sizeof(struct cache_mp_entry_));
-		assert(new_mp_entry != NULL);
-		memset(new_mp_entry, 0, sizeof(struct cache_mp_entry_));
-
-		memcpy(&new_mp_entry->mp_params, params,
-			sizeof(struct mp_cache_entry_params));
-		new_mp_entry->params =
-			(struct cache_entry_params *)&new_mp_entry->mp_params;
-
-		new_mp_entry->mp_params.entry_name = (char *)malloc(
-			entry_name_size+1);
-		assert(new_mp_entry->mp_params.entry_name != NULL);
-		memset(new_mp_entry->mp_params.entry_name, 0,
-			entry_name_size + 1);
-		strncpy(new_mp_entry->mp_params.entry_name, params->entry_name,
-			entry_name_size);
-		new_mp_entry->name = new_mp_entry->mp_params.entry_name;
-
-		TAILQ_INIT(&new_mp_entry->ws_head);
-		TAILQ_INIT(&new_mp_entry->rs_head);
-
-		new_mp_entry->get_time_func = the_cache->params.get_time_func;
-		the_cache->entries[the_cache->entries_size++] =
-			(struct cache_entry_ *)new_mp_entry;
-		break;
-	}
-
-
-	qsort(the_cache->entries, the_cache->entries_size,
-		sizeof(struct cache_entry_ *), entries_qsort_cmp_func);
-
-	TRACE_OUT(register_cache_entry);
-	return (0);
-}
-
-int
-unregister_cache_entry(struct cache_ *the_cache, const char *entry_name)
-{
-	struct cache_entry_ **del_ent;
-
-	TRACE_IN(unregister_cache_entry);
-	assert(the_cache != NULL);
-
-	del_ent = find_cache_entry_p(the_cache, entry_name);
-	if (del_ent != NULL) {
-		destroy_cache_entry(*del_ent);
-		--the_cache->entries_size;
-
-		memmove(del_ent, del_ent + 1,
-			(&(the_cache->entries[--the_cache->entries_size]) -
-	    		del_ent) * sizeof(struct cache_entry_ *));
-
-		TRACE_OUT(unregister_cache_entry);
-		return (0);
-	} else {
-		TRACE_OUT(unregister_cache_entry);
-		return (-1);
-	}
-}
-
-struct cache_entry_ *
-find_cache_entry(struct cache_ *the_cache, const char *entry_name)
-{
-	struct cache_entry_ **result;
-
-	TRACE_IN(find_cache_entry);
-	result = find_cache_entry_p(the_cache, entry_name);
-
-	if (result == NULL) {
-		TRACE_OUT(find_cache_entry);
-		return (NULL);
-	} else {
-		TRACE_OUT(find_cache_entry);
-		return (*result);
-	}
-}
-
-/*
- * Tries to read the element with the specified key from the cache. If the
- * value_size is too small, it will be filled with the proper number, and
- * the user will need to call cache_read again with the value buffer, that
- * is large enough.
- * Function returns 0 on success, -1 on error, and -2 if the value_size is too
- * small.
- */
-int
-cache_read(struct cache_entry_ *entry, const char *key, size_t key_size,
-	char *value, size_t *value_size)
-{
-	struct cache_common_entry_	*common_entry;
-	struct cache_ht_item_data_	item_data, *find_res;
-	struct cache_ht_item_		*item;
-	hashtable_index_t	hash;
-	struct cache_policy_item_ *connected_item;
-
-	TRACE_IN(cache_read);
-	assert(entry != NULL);
-	assert(key != NULL);
-	assert(value_size != NULL);
-	assert(entry->params->entry_type == CET_COMMON);
-
-	common_entry = (struct cache_common_entry_ *)entry;
-
-	memset(&item_data, 0, sizeof(struct cache_ht_item_data_));
-	/* can't avoid the cast here */
-	item_data.key = (char *)key;
-	item_data.key_size = key_size;
-
-	hash = HASHTABLE_CALCULATE_HASH(cache_ht_, &common_entry->items,
-		&item_data);
-	assert(hash >= 0);
-	assert(hash < HASHTABLE_ENTRIES_COUNT(&common_entry->items));
-
-	item = HASHTABLE_GET_ENTRY(&(common_entry->items), hash);
-	find_res = HASHTABLE_ENTRY_FIND(cache_ht_, item, &item_data);
-	if (find_res == NULL) {
-		TRACE_OUT(cache_read);
-		return (-1);
-	}
-
-	if ((common_entry->common_params.max_lifetime.tv_sec != 0) ||
-		(common_entry->common_params.max_lifetime.tv_usec != 0)) {
-
-		if (find_res->fifo_policy_item->last_request_time.tv_sec -
-			find_res->fifo_policy_item->creation_time.tv_sec >
-			common_entry->common_params.max_lifetime.tv_sec) {
-
-			free(find_res->key);
-			free(find_res->value);
-
-			connected_item =
-			    find_res->fifo_policy_item->connected_item;
-			if (connected_item != NULL) {
-				common_entry->policies[1]->remove_item_func(
-					common_entry->policies[1],
-			    		connected_item);
-				common_entry->policies[1]->destroy_item_func(
-					connected_item);
-			}
-
-			common_entry->policies[0]->remove_item_func(
-				common_entry->policies[0],
-					find_res->fifo_policy_item);
-			common_entry->policies[0]->destroy_item_func(
-				find_res->fifo_policy_item);
-
-			HASHTABLE_ENTRY_REMOVE(cache_ht_, item, find_res);
-			--common_entry->items_size;
-		}
-	}
-
-	if ((*value_size < find_res->value_size) || (value == NULL)) {
-		*value_size = find_res->value_size;
-		TRACE_OUT(cache_read);
-		return (-2);
-	}
-
-	*value_size = find_res->value_size;
-	memcpy(value, find_res->value, find_res->value_size);
-
-	++find_res->fifo_policy_item->request_count;
-	common_entry->get_time_func(
-		&find_res->fifo_policy_item->last_request_time);
-	common_entry->policies[0]->update_item_func(common_entry->policies[0],
-		find_res->fifo_policy_item);
-
-	if (find_res->fifo_policy_item->connected_item != NULL) {
-		connected_item = find_res->fifo_policy_item->connected_item;
-		memcpy(&connected_item->last_request_time,
-			&find_res->fifo_policy_item->last_request_time,
-			sizeof(struct timeval));
-		connected_item->request_count =
-			find_res->fifo_policy_item->request_count;
-
-		common_entry->policies[1]->update_item_func(
-			common_entry->policies[1], connected_item);
-	}
-
-	TRACE_OUT(cache_read);
-	return (0);
-}
-
-/*
- * Writes the value with the specified key into the cache entry.
- * Functions returns 0 on success, and -1 on error.
- */
-int
-cache_write(struct cache_entry_ *entry, const char *key, size_t key_size,
-    	char const *value, size_t value_size)
-{
-	struct cache_common_entry_	*common_entry;
-	struct cache_ht_item_data_	item_data, *find_res;
-	struct cache_ht_item_		*item;
-	hashtable_index_t	hash;
-
-	struct cache_policy_		*policy, *connected_policy;
-	struct cache_policy_item_	*policy_item;
-	struct cache_policy_item_	*connected_policy_item;
-
-	TRACE_IN(cache_write);
-	assert(entry != NULL);
-	assert(key != NULL);
-	assert(value != NULL);
-	assert(entry->params->entry_type == CET_COMMON);
-
-	common_entry = (struct cache_common_entry_ *)entry;
-
-	memset(&item_data, 0, sizeof(struct cache_ht_item_data_));
-	/* can't avoid the cast here */
-	item_data.key = (char *)key;
-	item_data.key_size = key_size;
-
-	hash = HASHTABLE_CALCULATE_HASH(cache_ht_, &common_entry->items,
-		&item_data);
-	assert(hash >= 0);
-	assert(hash < HASHTABLE_ENTRIES_COUNT(&common_entry->items));
-
-	item = HASHTABLE_GET_ENTRY(&(common_entry->items), hash);
-	find_res = HASHTABLE_ENTRY_FIND(cache_ht_, item, &item_data);
-	if (find_res != NULL) {
-		TRACE_OUT(cache_write);
-		return (-1);
-	}
-
-	item_data.key = (char *)malloc(key_size);
-	memcpy(item_data.key, key, key_size);
-
-	item_data.value = (char *)malloc(value_size);
-	assert(item_data.value != NULL);
-
-	memcpy(item_data.value, value, value_size);
-	item_data.value_size = value_size;
-
-	policy_item = common_entry->policies[0]->create_item_func();
-	policy_item->key = item_data.key;
-	policy_item->key_size = item_data.key_size;
-	common_entry->get_time_func(&policy_item->creation_time);
-
-	if (common_entry->policies_size > 1) {
-		connected_policy_item =
-			common_entry->policies[1]->create_item_func();
-		memcpy(&connected_policy_item->creation_time,
-			&policy_item->creation_time,
-			sizeof(struct timeval));
-		connected_policy_item->key = policy_item->key;
-		connected_policy_item->key_size = policy_item->key_size;
-
-		connected_policy_item->connected_item = policy_item;
-		policy_item->connected_item = connected_policy_item;
-	}
-
-	item_data.fifo_policy_item = policy_item;
-
-	common_entry->policies[0]->add_item_func(common_entry->policies[0],
-		policy_item);
-	if (common_entry->policies_size > 1)
-		common_entry->policies[1]->add_item_func(
-			common_entry->policies[1], connected_policy_item);
-
-	HASHTABLE_ENTRY_STORE(cache_ht_, item, &item_data);
-	++common_entry->items_size;
-
-	if ((common_entry->common_params.max_elemsize != 0) &&
-		(common_entry->items_size >
-		common_entry->common_params.max_elemsize)) {
-		if (common_entry->policies_size > 1) {
-			policy = common_entry->policies[1];
-			connected_policy = common_entry->policies[0];
-		} else {
-			policy = common_entry->policies[0];
-			connected_policy = NULL;
-		}
-
-		flush_cache_policy(common_entry, policy, connected_policy,
-			cache_elemsize_common_continue_func);
-	}
-
-	TRACE_OUT(cache_write);
-	return (0);
-}
-
-/*
- * Initializes the write session for the specified multipart entry. This
- * session then should be filled with data either committed or abandoned by
- * using close_cache_mp_write_session or abandon_cache_mp_write_session
- * respectively.
- * Returns NULL on errors (when there are too many opened write sessions for
- * the entry).
- */
-struct cache_mp_write_session_ *
-open_cache_mp_write_session(struct cache_entry_ *entry)
-{
-	struct cache_mp_entry_	*mp_entry;
-	struct cache_mp_write_session_	*retval;
-
-	TRACE_IN(open_cache_mp_write_session);
-	assert(entry != NULL);
-	assert(entry->params->entry_type == CET_MULTIPART);
-	mp_entry = (struct cache_mp_entry_ *)entry;
-
-	if ((mp_entry->mp_params.max_sessions > 0) &&
-		(mp_entry->ws_size == mp_entry->mp_params.max_sessions)) {
-		TRACE_OUT(open_cache_mp_write_session);
-		return (NULL);
-	}
-
-	retval = (struct cache_mp_write_session_ *)malloc(
-		sizeof(struct cache_mp_write_session_));
-	assert(retval != NULL);
-	memset(retval, 0, sizeof(struct cache_mp_write_session_));
-
-	TAILQ_INIT(&retval->items);
-	retval->parent_entry = mp_entry;
-
-	TAILQ_INSERT_HEAD(&mp_entry->ws_head, retval, entries);
-	++mp_entry->ws_size;
-
-	TRACE_OUT(open_cache_mp_write_session);
-	return (retval);
-}
-
-/*
- * Writes data to the specified session. Return 0 on success and -1 on errors
- * (when write session size limit is exceeded).
- */
-int
-cache_mp_write(struct cache_mp_write_session_ *ws, char *data,
-	size_t data_size)
-{
-	struct cache_mp_data_item_	*new_item;
-
-	TRACE_IN(cache_mp_write);
-	assert(ws != NULL);
-	assert(ws->parent_entry != NULL);
-	assert(ws->parent_entry->params->entry_type == CET_MULTIPART);
-
-	if ((ws->parent_entry->mp_params.max_elemsize > 0) &&
-		(ws->parent_entry->mp_params.max_elemsize == ws->items_size)) {
-		TRACE_OUT(cache_mp_write);
-		return (-1);
-	}
-
-	new_item = (struct cache_mp_data_item_ *)malloc(
-		sizeof(struct cache_mp_data_item_));
-	assert(new_item != NULL);
-	memset(new_item, 0, sizeof(struct cache_mp_data_item_));
-
-	new_item->value = (char *)malloc(data_size);
-	assert(new_item->value != NULL);
-	memcpy(new_item->value, data, data_size);
-	new_item->value_size = data_size;
-
-	TAILQ_INSERT_TAIL(&ws->items, new_item, entries);
-	++ws->items_size;
-
-	TRACE_OUT(cache_mp_write);
-	return (0);
-}
-
-/*
- * Abandons the write session and frees all the connected resources.
- */
-void
-abandon_cache_mp_write_session(struct cache_mp_write_session_ *ws)
-{
-
-	TRACE_IN(abandon_cache_mp_write_session);
-	assert(ws != NULL);
-	assert(ws->parent_entry != NULL);
-	assert(ws->parent_entry->params->entry_type == CET_MULTIPART);
-
-	TAILQ_REMOVE(&ws->parent_entry->ws_head, ws, entries);
-	--ws->parent_entry->ws_size;
-
-	destroy_cache_mp_write_session(ws);
-	TRACE_OUT(abandon_cache_mp_write_session);
-}
-
-/*
- * Commits the session to the entry, for which it was created.
- */
-void
-close_cache_mp_write_session(struct cache_mp_write_session_ *ws)
-{
-
-	TRACE_IN(close_cache_mp_write_session);
-	assert(ws != NULL);
-	assert(ws->parent_entry != NULL);
-	assert(ws->parent_entry->params->entry_type == CET_MULTIPART);
-
-	TAILQ_REMOVE(&ws->parent_entry->ws_head, ws, entries);
-	--ws->parent_entry->ws_size;
-
-	if (ws->parent_entry->completed_write_session == NULL) {
-		/*
-		 * If there is no completed session yet, this will be the one
-		 */
-		ws->parent_entry->get_time_func(
-	    		&ws->parent_entry->creation_time);
-		ws->parent_entry->completed_write_session = ws;
-	} else {
-		/*
-		 * If there is a completed session, then we'll save our session
-		 * as a pending session. If there is already a pending session,
-		 * it would be destroyed.
-		 */
-		if (ws->parent_entry->pending_write_session != NULL)
-			destroy_cache_mp_write_session(
-				ws->parent_entry->pending_write_session);
-
-		ws->parent_entry->pending_write_session = ws;
-	}
-	TRACE_OUT(close_cache_mp_write_session);
-}
-
-/*
- * Opens read session for the specified entry. Returns NULL on errors (when
- * there are no data in the entry, or the data are obsolete).
- */
-struct cache_mp_read_session_ *
-open_cache_mp_read_session(struct cache_entry_ *entry)
-{
-	struct cache_mp_entry_			*mp_entry;
-	struct cache_mp_read_session_	*retval;
-
-	TRACE_IN(open_cache_mp_read_session);
-	assert(entry != NULL);
-	assert(entry->params->entry_type == CET_MULTIPART);
-	mp_entry = (struct cache_mp_entry_ *)entry;
-
-	if (mp_entry->completed_write_session == NULL) {
-		TRACE_OUT(open_cache_mp_read_session);
-		return (NULL);
-	}
-
-	if ((mp_entry->mp_params.max_lifetime.tv_sec != 0)
-		|| (mp_entry->mp_params.max_lifetime.tv_usec != 0)) {
-		if (mp_entry->last_request_time.tv_sec -
-			mp_entry->last_request_time.tv_sec >
-			mp_entry->mp_params.max_lifetime.tv_sec) {
-			flush_cache_entry(entry);
-			TRACE_OUT(open_cache_mp_read_session);
-			return (NULL);
-		}
-	}
-
-	retval = (struct cache_mp_read_session_ *)malloc(
-		sizeof(struct cache_mp_read_session_));
-	assert(retval != NULL);
-	memset(retval, 0, sizeof(struct cache_mp_read_session_));
-
-	retval->parent_entry = mp_entry;
-	retval->current_item = TAILQ_FIRST(
-		&mp_entry->completed_write_session->items);
-
-	TAILQ_INSERT_HEAD(&mp_entry->rs_head, retval, entries);
-	++mp_entry->rs_size;
-
-	mp_entry->get_time_func(&mp_entry->last_request_time);
-	TRACE_OUT(open_cache_mp_read_session);
-	return (retval);
-}
-
-/*
- * Reads the data from the read session - step by step.
- * Returns 0 on success, -1 on error (when there are no more data), and -2 if
- * the data_size is too small.  In the last case, data_size would be filled
- * the proper value.
- */
-int
-cache_mp_read(struct cache_mp_read_session_ *rs, char *data, size_t *data_size)
-{
-
-	TRACE_IN(cache_mp_read);
-	assert(rs != NULL);
-
-	if (rs->current_item == NULL) {
-		TRACE_OUT(cache_mp_read);
-		return (-1);
-	}
-
-	if (rs->current_item->value_size > *data_size) {
-		*data_size = rs->current_item->value_size;
-		if (data == NULL) {
-			TRACE_OUT(cache_mp_read);
-			return (0);
-		}
-
-		TRACE_OUT(cache_mp_read);
-		return (-2);
-	}
-
-	*data_size = rs->current_item->value_size;
-	memcpy(data, rs->current_item->value, rs->current_item->value_size);
-	rs->current_item = TAILQ_NEXT(rs->current_item, entries);
-
-	TRACE_OUT(cache_mp_read);
-	return (0);
-}
-
-/*
- * Closes the read session. If there are no more read sessions and there is
- * a pending write session, it will be committed and old
- * completed_write_session will be destroyed.
- */
-void
-close_cache_mp_read_session(struct cache_mp_read_session_ *rs)
-{
-
-	TRACE_IN(close_cache_mp_read_session);
-	assert(rs != NULL);
-	assert(rs->parent_entry != NULL);
-
-	TAILQ_REMOVE(&rs->parent_entry->rs_head, rs, entries);
-	--rs->parent_entry->rs_size;
-
-	if ((rs->parent_entry->rs_size == 0) &&
-		(rs->parent_entry->pending_write_session != NULL)) {
-		destroy_cache_mp_write_session(
-			rs->parent_entry->completed_write_session);
-		rs->parent_entry->completed_write_session =
-			rs->parent_entry->pending_write_session;
-		rs->parent_entry->pending_write_session = NULL;
-	}
-
-	destroy_cache_mp_read_session(rs);
-	TRACE_OUT(close_cache_mp_read_session);
-}
-
-int
-transform_cache_entry(struct cache_entry_ *entry,
-	enum cache_transformation_t transformation)
-{
-
-	TRACE_IN(transform_cache_entry);
-	switch (transformation) {
-	case CTT_CLEAR:
-		clear_cache_entry(entry);
-		TRACE_OUT(transform_cache_entry);
-		return (0);
-	case CTT_FLUSH:
-		flush_cache_entry(entry);
-		TRACE_OUT(transform_cache_entry);
-		return (0);
-	default:
-		TRACE_OUT(transform_cache_entry);
-		return (-1);
-	}
-}
-
-int
-transform_cache_entry_part(struct cache_entry_ *entry,
-	enum cache_transformation_t transformation, const char *key_part,
-	size_t key_part_size, enum part_position_t part_position)
-{
-	struct cache_common_entry_ *common_entry;
-	struct cache_ht_item_ *ht_item;
-	struct cache_ht_item_data_ *ht_item_data, ht_key;
-
-	struct cache_policy_item_ *item, *connected_item;
-
-	TRACE_IN(transform_cache_entry_part);
-	if (entry->params->entry_type != CET_COMMON) {
-		TRACE_OUT(transform_cache_entry_part);
-		return (-1);
-	}
-
-	if (transformation != CTT_CLEAR) {
-		TRACE_OUT(transform_cache_entry_part);
-		return (-1);
-	}
-
-	memset(&ht_key, 0, sizeof(struct cache_ht_item_data_));
-	ht_key.key = (char *)key_part;	/* can't avoid casting here */
-	ht_key.key_size = key_part_size;
-
-	common_entry = (struct cache_common_entry_ *)entry;
-	HASHTABLE_FOREACH(&(common_entry->items), ht_item) {
-		do {
-			ht_item_data = HASHTABLE_ENTRY_FIND_SPECIAL(cache_ht_,
-				ht_item, &ht_key,
-				ht_items_fixed_size_left_cmp_func);
-
-			if (ht_item_data != NULL) {
-			    item = ht_item_data->fifo_policy_item;
-			    connected_item = item->connected_item;
-
-			    common_entry->policies[0]->remove_item_func(
-				common_entry->policies[0],
-				item);
-
-			    free(ht_item_data->key);
-			    free(ht_item_data->value);
-			    HASHTABLE_ENTRY_REMOVE(cache_ht_, ht_item,
-				ht_item_data);
-			    --common_entry->items_size;
-
-			    common_entry->policies[0]->destroy_item_func(
-				item);
-			    if (common_entry->policies_size == 2) {
-				common_entry->policies[1]->remove_item_func(
-				    common_entry->policies[1],
-				    connected_item);
-				common_entry->policies[1]->destroy_item_func(
-				    connected_item);
-			    }
-			}
-		} while (ht_item_data != NULL);
-	}
-
-	TRACE_OUT(transform_cache_entry_part);
-	return (0);
-}
diff --git a/usr.sbin/cached/cachelib.h b/usr.sbin/cached/cachelib.h
deleted file mode 100644
index d67e830..0000000
--- a/usr.sbin/cached/cachelib.h
+++ /dev/null
@@ -1,281 +0,0 @@
-/*-
- * Copyright (c) 2005 Michael Bushkov <bushman@rsu.ru>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * $FreeBSD$
- */
-
-#ifndef __CACHED_CACHELIB_H__
-#define __CACHED_CACHELIB_H__
-
-#include <sys/queue.h>
-#include <sys/time.h>
-#include <stdlib.h>
-#include "hashtable.h"
-#include "cacheplcs.h"
-
-enum cache_entry_t	{
-	CET_COMMON = 0,	/* cache item is atomic */
-	CET_MULTIPART	/* cache item is formed part by part */
-};
-
-enum cache_transformation_t {
-	CTT_FLUSH = 0,	/* flush the cache - delete all obsolete items */
-	CTT_CLEAR = 1	/* delete all items in the cache */
-};
-
-/* cache deletion policy type enum */
-enum cache_policy_t {
-	CPT_FIFO = 0, 	/* first-in first-out */
-	CPT_LRU = 1,	/* least recently used */
-	CPT_LFU = 2 	/* least frequently used */
-};
-
-/* multipart sessions can be used for reading and writing */
-enum cache_mp_session_t {
-	CMPT_READ_SESSION,
-	CMPT_WRITE_SESSION
-};
-
-/*
- * When doing partial transformations of entries (which are applied for
- * elements with keys, that contain specified buffer in its left or
- * right part), this enum will show the needed position of the key part.
- */
-enum part_position_t {
-	KPPT_LEFT,
-	KPPT_RIGHT
-};
-
-/* num_levels attribute is obsolete, i think - user can always emulate it
- * by using one entry.
- * get_time_func is needed to have the clocks-independent counter
- */
-struct cache_params
-{
-	void	(*get_time_func)(struct timeval *);
-};
-
-/*
- * base structure - normal_cache_entry_params and multipart_cache_entry_params
- * are "inherited" from it
- */
-struct cache_entry_params
-{
-	enum cache_entry_t entry_type;
-	char	*entry_name;
-};
-
-/* params, used for most entries */
-struct common_cache_entry_params
-{
-	/* inherited fields */
-	enum cache_entry_t	entry_type;
-
-	/* unique fields */
-	char	*entry_name;
-	size_t	cache_entries_size;
-
-	size_t	max_elemsize;		/* if 0 then no check is made */
-	size_t	satisf_elemsize;	/* if entry size is exceeded,
-					 * this number of elements will be left,
-					 * others will be deleted */
-	struct timeval	max_lifetime;	/* if 0 then no check is made */
-	enum cache_policy_t policy;	/* policy used for transformations */
-};
-
-/* params, used for multipart entries */
-struct	mp_cache_entry_params
-{
-	/* inherited fields */
-	enum cache_entry_t entry_type;
-	char	*entry_name;
-
-	/* unique fields */
-	size_t	max_elemsize;	/* if 0 then no check is made */
-	size_t	max_sessions;	/* maximum number of active sessions */
-
-	struct timeval	max_lifetime;	/* maximum elements lifetime */
-};
-
-struct cache_ht_item_data_
-{
-    	/* key is the bytes sequence only - not the null-terminated string */
-	char	*key;
-    	size_t	key_size;
-
-	char	*value;
-	size_t	value_size;
-
-	struct cache_policy_item_ *fifo_policy_item;
-};
-
-struct cache_ht_item_
-{
-	HASHTABLE_ENTRY_HEAD(ht_item_, struct cache_ht_item_data_) data;
-};
-
-struct cache_entry_
-{
-	char	*name;
-	struct cache_entry_params *params;
-};
-
-struct cache_common_entry_
-{
-	char	*name;
-	struct cache_entry_params *params;
-
-	struct common_cache_entry_params common_params;
-
-	HASHTABLE_HEAD(cache_ht_, cache_ht_item_) items;
-	size_t items_size;
-
-	/*
-	 * Entry always has the FIFO policy, that is used to eliminate old
-	 * elements (the ones, with lifetime more than max_lifetime). Besides,
-	 * user can specify another policy to be applied, when there are too
-	 * many elements in the entry. So policies_size can be 1 or 2.
-	 */
-	struct cache_policy_ **policies;
-	size_t policies_size;
-
-	void	(*get_time_func)(struct timeval *);
-};
-
-struct cache_mp_data_item_ {
-	char	*value;
-	size_t	value_size;
-
-	TAILQ_ENTRY(cache_mp_data_item_) entries;
-};
-
-struct cache_mp_write_session_
-{
-	struct cache_mp_entry_	*parent_entry;
-
-	/*
-	 * All items are accumulated in this queue. When the session is
-	 * committed, they all will be copied to the multipart entry.
-	 */
-	TAILQ_HEAD(cache_mp_data_item_head, cache_mp_data_item_) items;
-	size_t	items_size;
-
-	TAILQ_ENTRY(cache_mp_write_session_) entries;
-};
-
-struct cache_mp_read_session_
-{
-	struct cache_mp_entry_ *parent_entry;
-	struct cache_mp_data_item_ *current_item;
-
-	TAILQ_ENTRY(cache_mp_read_session_) entries;
-};
-
-struct cache_mp_entry_
-{
-	char	*name;
-	struct cache_entry_params *params;
-
-	struct mp_cache_entry_params mp_params;
-
-	/* All opened write sessions */
-	TAILQ_HEAD(write_sessions_head, cache_mp_write_session_) ws_head;
-	size_t	ws_size;
-
-	/* All opened read sessions */
-	TAILQ_HEAD(read_sessions_head, cache_mp_read_session_) rs_head;
-	size_t	rs_size;
-
-	/*
-	 * completed_write_session is the committed write sessions. All read
-	 * sessions use data from it. If the completed_write_session is out of
-	 * date, but still in use by some of the read sessions, the newly
-	 * committed write session is stored in the pending_write_session.
-	 * In such a case, completed_write_session will be substituted with
-	 * pending_write_session as soon as it won't be used by any of
-	 * the read sessions.
-	 */
-	struct cache_mp_write_session_	*completed_write_session;
-	struct cache_mp_write_session_	*pending_write_session;
-	struct timeval	creation_time;
-	struct timeval	last_request_time;
-
-	void	(*get_time_func)(struct timeval *);
-};
-
-struct cache_
-{
-	struct cache_params params;
-
-	struct cache_entry_ **entries;
-	size_t	entries_capacity;
-	size_t	entries_size;
-};
-
-/* simple abstractions - for not to write "struct" every time */
-typedef struct cache_		*cache;
-typedef struct cache_entry_	*cache_entry;
-typedef struct cache_mp_write_session_	*cache_mp_write_session;
-typedef struct cache_mp_read_session_	*cache_mp_read_session;
-
-#define INVALID_CACHE		(NULL)
-#define INVALID_CACHE_ENTRY	(NULL)
-#define INVALID_CACHE_MP_WRITE_SESSION	(NULL)
-#define INVALID_CACHE_MP_READ_SESSION	(NULL)
-
-/*
- * NOTE: all cache operations are thread-unsafe. You must ensure thread-safety
- * externally, by yourself.
- */
-
-/* cache initialization/destruction routines */
-extern cache init_cache(struct cache_params const *);
-extern void destroy_cache(cache);
-
-/* cache entries manipulation routines */
-extern int register_cache_entry(cache, struct cache_entry_params const *);
-extern int unregister_cache_entry(cache, const char *);
-extern cache_entry find_cache_entry(cache, const char *);
-
-/* read/write operations used on common entries */
-extern int cache_read(cache_entry, const char *, size_t, char *, size_t *);
-extern int cache_write(cache_entry, const char *, size_t, char const *, size_t);
-
-/* read/write operations used on multipart entries */
-extern cache_mp_write_session open_cache_mp_write_session(cache_entry);
-extern int cache_mp_write(cache_mp_write_session, char *, size_t);
-extern void abandon_cache_mp_write_session(cache_mp_write_session);
-extern void close_cache_mp_write_session(cache_mp_write_session);
-
-extern cache_mp_read_session open_cache_mp_read_session(cache_entry);
-extern int cache_mp_read(cache_mp_read_session, char *, size_t *);
-extern void close_cache_mp_read_session(cache_mp_read_session);
-
-/* transformation routines */
-extern int transform_cache_entry(cache_entry, enum cache_transformation_t);
-extern int transform_cache_entry_part(cache_entry, enum cache_transformation_t,
-	const char *, size_t, enum part_position_t);
-
-#endif
diff --git a/usr.sbin/cached/cacheplcs.c b/usr.sbin/cached/cacheplcs.c
deleted file mode 100644
index a7ee38d..0000000
--- a/usr.sbin/cached/cacheplcs.c
+++ /dev/null
@@ -1,590 +0,0 @@
-/*-
- * Copyright (c) 2005 Michael Bushkov <bushman@rsu.ru>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- */
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-
-#include <assert.h>
-#include <string.h>
-#include "cacheplcs.h"
-#include "debug.h"
-
-static void cache_fifo_policy_update_item(struct cache_policy_ *,
-	struct cache_policy_item_ *);
-static void cache_lfu_policy_add_item(struct cache_policy_ *,
-	struct cache_policy_item_ *);
-static struct cache_policy_item_ * cache_lfu_policy_create_item(void);
-static void cache_lfu_policy_destroy_item(struct cache_policy_item_ *);
-static struct cache_policy_item_ *cache_lfu_policy_get_first_item(
-	struct cache_policy_ *);
-static struct cache_policy_item_ *cache_lfu_policy_get_last_item(
-	struct cache_policy_ *);
-static struct cache_policy_item_ *cache_lfu_policy_get_next_item(
-	struct cache_policy_ *, struct cache_policy_item_ *);
-static struct cache_policy_item_ *cache_lfu_policy_get_prev_item(
-	struct cache_policy_ *, struct cache_policy_item_ *);
-static void cache_lfu_policy_remove_item(struct cache_policy_ *,
-	struct cache_policy_item_ *);
-static void cache_lfu_policy_update_item(struct cache_policy_ *,
-	struct cache_policy_item_ *);
-static void cache_lru_policy_update_item(struct cache_policy_ *,
-	struct cache_policy_item_ *);
-static void cache_queue_policy_add_item(struct cache_policy_ *,
-	struct cache_policy_item_ *);
-static struct cache_policy_item_ * cache_queue_policy_create_item();
-static void cache_queue_policy_destroy_item(struct cache_policy_item_ *);
-static struct cache_policy_item_ *cache_queue_policy_get_first_item(
-	struct cache_policy_ *);
-static struct cache_policy_item_ *cache_queue_policy_get_last_item(
-	struct cache_policy_ *);
-static struct cache_policy_item_ *cache_queue_policy_get_next_item(
-	struct cache_policy_ *, struct cache_policy_item_ *);
-static struct cache_policy_item_ *cache_queue_policy_get_prev_item(
-	struct cache_policy_ *, struct cache_policy_item_ *);
-static void cache_queue_policy_remove_item(struct cache_policy_ *,
-	struct cache_policy_item_ *);
-static void destroy_cache_queue_policy(struct cache_queue_policy_ *);
-static struct cache_queue_policy_ *init_cache_queue_policy(void);
-
-/*
- * All cache_queue_policy_XXX functions below will be used to fill
- * the cache_queue_policy structure. They implement the most functionality of
- * LRU and FIFO policies. LRU and FIFO policies are actually the
- * cache_queue_policy_ with cache_update_item function changed.
- */
-static struct cache_policy_item_ *
-cache_queue_policy_create_item()
-{
-	struct cache_queue_policy_item_ *retval;
-
-	TRACE_IN(cache_queue_policy_create_item);
-	retval = (struct cache_queue_policy_item_ *)malloc(
-		sizeof(struct cache_queue_policy_item_));
-	assert(retval != NULL);
-	memset(retval, 0, sizeof(struct cache_queue_policy_item_));
-
-	TRACE_OUT(cache_queue_policy_create_item);
-	return ((struct cache_policy_item_ *)retval);
-}
-
-static void
-cache_queue_policy_destroy_item(struct cache_policy_item_ *item)
-{
-
-	TRACE_IN(cache_queue_policy_destroy_item);
-	assert(item != NULL);
-	free(item);
-	TRACE_OUT(cache_queue_policy_destroy_item);
-}
-
-static void
-cache_queue_policy_add_item(struct cache_policy_ *policy,
-	struct cache_policy_item_ *item)
-{
-	struct cache_queue_policy_ *queue_policy;
-	struct cache_queue_policy_item_ *queue_item;
-
-	TRACE_IN(cache_queue_policy_add_item);
-	queue_policy = (struct cache_queue_policy_ *)policy;
-	queue_item = (struct cache_queue_policy_item_ *)item;
-	TAILQ_INSERT_TAIL(&queue_policy->head, queue_item, entries);
-	TRACE_OUT(cache_queue_policy_add_item);
-}
-
-static void
-cache_queue_policy_remove_item(struct cache_policy_ *policy,
-	struct cache_policy_item_ *item)
-{
-	struct cache_queue_policy_ *queue_policy;
-	struct cache_queue_policy_item_	*queue_item;
-
-	TRACE_IN(cache_queue_policy_remove_item);
-	queue_policy = (struct cache_queue_policy_ *)policy;
-	queue_item = (struct cache_queue_policy_item_ *)item;
-	TAILQ_REMOVE(&queue_policy->head, queue_item, entries);
-	TRACE_OUT(cache_queue_policy_remove_item);
-}
-
-static struct cache_policy_item_ *
-cache_queue_policy_get_first_item(struct cache_policy_ *policy)
-{
-	struct cache_queue_policy_ *queue_policy;
-
-	TRACE_IN(cache_queue_policy_get_first_item);
-	queue_policy = (struct cache_queue_policy_ *)policy;
-	TRACE_OUT(cache_queue_policy_get_first_item);
-	return ((struct cache_policy_item_ *)TAILQ_FIRST(&queue_policy->head));
-}
-
-static struct cache_policy_item_ *
-cache_queue_policy_get_last_item(struct cache_policy_ *policy)
-{
-	struct cache_queue_policy_ *queue_policy;
-
-	TRACE_IN(cache_queue_policy_get_last_item);
-	queue_policy = (struct cache_queue_policy_ *)policy;
-	TRACE_OUT(cache_queue_policy_get_last_item);
-	return ((struct cache_policy_item_ *)TAILQ_LAST(&queue_policy->head,
-		cache_queue_policy_head_));
-}
-
-static struct cache_policy_item_ *
-cache_queue_policy_get_next_item(struct cache_policy_ *policy,
-	struct cache_policy_item_ *item)
-{
-	struct cache_queue_policy_ *queue_policy;
-	struct cache_queue_policy_item_	*queue_item;
-
-	TRACE_IN(cache_queue_policy_get_next_item);
-	queue_policy = (struct cache_queue_policy_ *)policy;
-	queue_item = (struct cache_queue_policy_item_ *)item;
-
-	TRACE_OUT(cache_queue_policy_get_next_item);
-	return ((struct cache_policy_item_ *)TAILQ_NEXT(queue_item, entries));
-}
-
-static struct cache_policy_item_ *
-cache_queue_policy_get_prev_item(struct cache_policy_ *policy,
-	struct cache_policy_item_ *item)
-{
-	struct cache_queue_policy_ *queue_policy;
-	struct cache_queue_policy_item_	*queue_item;
-
-	TRACE_IN(cache_queue_policy_get_prev_item);
-	queue_policy = (struct cache_queue_policy_ *)policy;
-	queue_item = (struct cache_queue_policy_item_ *)item;
-
-	TRACE_OUT(cache_queue_policy_get_prev_item);
-	return ((struct cache_policy_item_ *)TAILQ_PREV(queue_item,
-		cache_queue_policy_head_, entries));
-}
-
-/*
- * Initializes cache_queue_policy_ by filling the structure with the functions
- * pointers, defined above
- */
-static struct cache_queue_policy_ *
-init_cache_queue_policy(void)
-{
-	struct cache_queue_policy_	*retval;
-
-	TRACE_IN(init_cache_queue_policy);
-	retval = (struct cache_queue_policy_ *)malloc(
-		sizeof(struct cache_queue_policy_));
-	assert(retval != NULL);
-	memset(retval, 0, sizeof(struct cache_queue_policy_));
-
-	retval->parent_data.create_item_func = cache_queue_policy_create_item;
-	retval->parent_data.destroy_item_func = cache_queue_policy_destroy_item;
-
-	retval->parent_data.add_item_func = cache_queue_policy_add_item;
-	retval->parent_data.remove_item_func = cache_queue_policy_remove_item;
-
-	retval->parent_data.get_first_item_func =
-		cache_queue_policy_get_first_item;
-	retval->parent_data.get_last_item_func =
-		cache_queue_policy_get_last_item;
-	retval->parent_data.get_next_item_func =
-		cache_queue_policy_get_next_item;
-	retval->parent_data.get_prev_item_func =
-		cache_queue_policy_get_prev_item;
-
-	TAILQ_INIT(&retval->head);
-	TRACE_OUT(init_cache_queue_policy);
-	return (retval);
-}
-
-static void
-destroy_cache_queue_policy(struct cache_queue_policy_ *queue_policy)
-{
-	struct cache_queue_policy_item_	*queue_item;
-
-	TRACE_IN(destroy_cache_queue_policy);
-	while (!TAILQ_EMPTY(&queue_policy->head)) {
-		queue_item = TAILQ_FIRST(&queue_policy->head);
-		TAILQ_REMOVE(&queue_policy->head, queue_item, entries);
-		cache_queue_policy_destroy_item(
-			(struct cache_policy_item_ *)queue_item);
-	}
-	free(queue_policy);
-	TRACE_OUT(destroy_cache_queue_policy);
-}
-
-/*
- * Makes cache_queue_policy_ behave like FIFO policy - we don't do anything,
- * when the cache element is updated. So it always stays in its initial
- * position in the queue - that is exactly the FIFO functionality.
- */
-static void
-cache_fifo_policy_update_item(struct cache_policy_ *policy,
-	struct cache_policy_item_ *item)
-{
-
-	TRACE_IN(cache_fifo_policy_update_item);
-	/* policy and item arguments are ignored */
-	TRACE_OUT(cache_fifo_policy_update_item);
-}
-
-struct cache_policy_ *
-init_cache_fifo_policy()
-{
-	struct cache_queue_policy_ *retval;
-
-	TRACE_IN(init_cache_fifo_policy);
-	retval = init_cache_queue_policy();
-	retval->parent_data.update_item_func = cache_fifo_policy_update_item;
-
-	TRACE_OUT(init_cache_fifo_policy);
-	return ((struct cache_policy_ *)retval);
-}
-
-void
-destroy_cache_fifo_policy(struct cache_policy_ *policy)
-{
-	struct cache_queue_policy_	*queue_policy;
-
-	TRACE_IN(destroy_cache_fifo_policy);
-	queue_policy = (struct cache_queue_policy_ *)policy;
-	destroy_cache_queue_policy(queue_policy);
-	TRACE_OUT(destroy_cache_fifo_policy);
-}
-
-/*
- * Makes cache_queue_policy_ behave like LRU policy. On each update, cache
- * element is moved to the end of the queue - so it would be deleted in last
- * turn. That is exactly the LRU policy functionality.
- */
-static void
-cache_lru_policy_update_item(struct cache_policy_ *policy,
-	struct cache_policy_item_ *item)
-{
-	struct cache_queue_policy_ *queue_policy;
-	struct cache_queue_policy_item_ *queue_item;
-
-	TRACE_IN(cache_lru_policy_update_item);
-	queue_policy = (struct cache_queue_policy_ *)policy;
-	queue_item = (struct cache_queue_policy_item_ *)item;
-
-	TAILQ_REMOVE(&queue_policy->head, queue_item, entries);
-	TAILQ_INSERT_TAIL(&queue_policy->head, queue_item, entries);
-	TRACE_OUT(cache_lru_policy_update_item);
-}
-
-struct cache_policy_ *
-init_cache_lru_policy()
-{
-	struct cache_queue_policy_ *retval;
-
-	TRACE_IN(init_cache_lru_policy);
-	retval = init_cache_queue_policy();
-	retval->parent_data.update_item_func = cache_lru_policy_update_item;
-
-	TRACE_OUT(init_cache_lru_policy);
-	return ((struct cache_policy_ *)retval);
-}
-
-void
-destroy_cache_lru_policy(struct cache_policy_ *policy)
-{
-	struct cache_queue_policy_	*queue_policy;
-
-	TRACE_IN(destroy_cache_lru_policy);
-	queue_policy = (struct cache_queue_policy_ *)policy;
-	destroy_cache_queue_policy(queue_policy);
-	TRACE_OUT(destroy_cache_lru_policy);
-}
-
-/*
- * LFU (least frequently used) policy implementation differs much from the
- * LRU and FIFO (both based on cache_queue_policy_). Almost all cache_policy_
- * functions are implemented specifically for this policy. The idea of this
- * policy is to represent frequency (real number) as the integer number and
- * use it as the index in the array. Each array's element is
- * the list of elements. For example, if we have the 100-elements
- * array for this policy, the elements with frequency 0.1 (calls per-second)
- * would be in 10th element of the array.
- */
-static struct cache_policy_item_ *
-cache_lfu_policy_create_item(void)
-{
-	struct cache_lfu_policy_item_ *retval;
-
-	TRACE_IN(cache_lfu_policy_create_item);
-	retval = (struct cache_lfu_policy_item_ *)malloc(
-		sizeof(struct cache_lfu_policy_item_));
-	assert(retval != NULL);
-	memset(retval, 0, sizeof(struct cache_lfu_policy_item_));
-
-	TRACE_OUT(cache_lfu_policy_create_item);
-	return ((struct cache_policy_item_ *)retval);
-}
-
-static void
-cache_lfu_policy_destroy_item(struct cache_policy_item_ *item)
-{
-
-	TRACE_IN(cache_lfu_policy_destroy_item);
-	assert(item != NULL);
-	free(item);
-	TRACE_OUT(cache_lfu_policy_destroy_item);
-}
-
-/*
- * When placed in the LFU policy queue for the first time, the maximum
- * frequency is assigned to the element
- */
-static void
-cache_lfu_policy_add_item(struct cache_policy_ *policy,
-	struct cache_policy_item_ *item)
-{
-	struct cache_lfu_policy_ *lfu_policy;
-	struct cache_lfu_policy_item_ *lfu_item;
-
-	TRACE_IN(cache_lfu_policy_add_item);
-	lfu_policy = (struct cache_lfu_policy_ *)policy;
-	lfu_item = (struct cache_lfu_policy_item_ *)item;
-
-	lfu_item->frequency = CACHELIB_MAX_FREQUENCY - 1;
-	TAILQ_INSERT_HEAD(&(lfu_policy->groups[CACHELIB_MAX_FREQUENCY - 1]),
-		lfu_item, entries);
-	TRACE_OUT(cache_lfu_policy_add_item);
-}
-
-/*
- * On each update the frequency of the element is recalculated and, if it
- * changed, the element would be moved to the another place in the array.
- */
-static void
-cache_lfu_policy_update_item(struct cache_policy_ *policy,
-	struct cache_policy_item_ *item)
-{
-	struct cache_lfu_policy_ *lfu_policy;
-	struct cache_lfu_policy_item_ *lfu_item;
-	int index;
-
-	TRACE_IN(cache_lfu_policy_update_item);
-	lfu_policy = (struct cache_lfu_policy_ *)policy;
-	lfu_item = (struct cache_lfu_policy_item_ *)item;
-
-	/*
-	 * We calculate the square of the request_count to avoid grouping of
-	 * all elements at the start of the array (for example, if array size is
-	 * 100 and most of its elements has frequency below the 0.01, they
-	 * all would be grouped in the first array's position). Other
-	 * techniques should be used here later to ensure, that elements are
-	 * equally distributed  in the array and not grouped in its beginning.
-	 */
-	if (lfu_item->parent_data.last_request_time.tv_sec !=
-		lfu_item->parent_data.creation_time.tv_sec) {
-		index = ((double)lfu_item->parent_data.request_count *
-			(double)lfu_item->parent_data.request_count /
-			(lfu_item->parent_data.last_request_time.tv_sec -
-			    lfu_item->parent_data.creation_time.tv_sec + 1)) *
-			    CACHELIB_MAX_FREQUENCY;
-		if (index >= CACHELIB_MAX_FREQUENCY)
-			index = CACHELIB_MAX_FREQUENCY - 1;
-	} else
-		index = CACHELIB_MAX_FREQUENCY - 1;
-
-	TAILQ_REMOVE(&(lfu_policy->groups[lfu_item->frequency]), lfu_item,
-		entries);
-	lfu_item->frequency = index;
-	TAILQ_INSERT_HEAD(&(lfu_policy->groups[index]), lfu_item, entries);
-
-	TRACE_OUT(cache_lfu_policy_update_item);
-}
-
-static void
-cache_lfu_policy_remove_item(struct cache_policy_ *policy,
-	struct cache_policy_item_ *item)
-{
-	struct cache_lfu_policy_ *lfu_policy;
-	struct cache_lfu_policy_item_ *lfu_item;
-
-	TRACE_IN(cache_lfu_policy_remove_item);
-	lfu_policy = (struct cache_lfu_policy_ *)policy;
-	lfu_item = (struct cache_lfu_policy_item_ *)item;
-
-	TAILQ_REMOVE(&(lfu_policy->groups[lfu_item->frequency]), lfu_item,
-		entries);
-	TRACE_OUT(cache_lfu_policy_remove_item);
-}
-
-static struct cache_policy_item_ *
-cache_lfu_policy_get_first_item(struct cache_policy_ *policy)
-{
-	struct cache_lfu_policy_ *lfu_policy;
-	struct cache_lfu_policy_item_ *lfu_item;
-	int i;
-
-	TRACE_IN(cache_lfu_policy_get_first_item);
-	lfu_item = NULL;
-	lfu_policy = (struct cache_lfu_policy_ *)policy;
-	for (i = 0; i < CACHELIB_MAX_FREQUENCY; ++i)
-		if (!TAILQ_EMPTY(&(lfu_policy->groups[i]))) {
-			lfu_item = TAILQ_FIRST(&(lfu_policy->groups[i]));
-			break;
-		}
-
-	TRACE_OUT(cache_lfu_policy_get_first_item);
-	return ((struct cache_policy_item_ *)lfu_item);
-}
-
-static struct cache_policy_item_ *
-cache_lfu_policy_get_last_item(struct cache_policy_ *policy)
-{
-	struct cache_lfu_policy_ *lfu_policy;
-	struct cache_lfu_policy_item_ *lfu_item;
-	int i;
-
-	TRACE_IN(cache_lfu_policy_get_last_item);
-	lfu_item = NULL;
-	lfu_policy = (struct cache_lfu_policy_ *)policy;
-	for (i = CACHELIB_MAX_FREQUENCY - 1; i >= 0; --i)
-		if (!TAILQ_EMPTY(&(lfu_policy->groups[i]))) {
-			lfu_item = TAILQ_LAST(&(lfu_policy->groups[i]),
-				cache_lfu_policy_group_);
-			break;
-		}
-
-	TRACE_OUT(cache_lfu_policy_get_last_item);
-	return ((struct cache_policy_item_ *)lfu_item);
-}
-
-static struct cache_policy_item_ *
-cache_lfu_policy_get_next_item(struct cache_policy_ *policy,
-	struct cache_policy_item_ *item)
-{
-	struct cache_lfu_policy_ *lfu_policy;
-	struct cache_lfu_policy_item_ *lfu_item;
-	int i;
-
-	TRACE_IN(cache_lfu_policy_get_next_item);
-	lfu_policy = (struct cache_lfu_policy_ *)policy;
-	lfu_item = TAILQ_NEXT((struct cache_lfu_policy_item_ *)item, entries);
-	if (lfu_item == NULL)
-	{
-		for (i = ((struct cache_lfu_policy_item_ *)item)->frequency + 1;
-			i < CACHELIB_MAX_FREQUENCY; ++i) {
-			if (!TAILQ_EMPTY(&(lfu_policy->groups[i]))) {
-			    lfu_item = TAILQ_FIRST(&(lfu_policy->groups[i]));
-			    break;
-			}
-		}
-	}
-
-	TRACE_OUT(cache_lfu_policy_get_next_item);
-	return ((struct cache_policy_item_ *)lfu_item);
-}
-
-static struct cache_policy_item_ *
-cache_lfu_policy_get_prev_item(struct cache_policy_ *policy,
-	struct cache_policy_item_ *item)
-{
-	struct cache_lfu_policy_ *lfu_policy;
-	struct cache_lfu_policy_item_ *lfu_item;
-	int i;
-
-	TRACE_IN(cache_lfu_policy_get_prev_item);
-	lfu_policy = (struct cache_lfu_policy_ *)policy;
-	lfu_item = TAILQ_PREV((struct cache_lfu_policy_item_ *)item,
-		cache_lfu_policy_group_, entries);
-	if (lfu_item == NULL)
-	{
-		for (i = ((struct cache_lfu_policy_item_ *)item)->frequency - 1;
-			i >= 0; --i)
-			if (!TAILQ_EMPTY(&(lfu_policy->groups[i]))) {
-				lfu_item = TAILQ_LAST(&(lfu_policy->groups[i]),
-					cache_lfu_policy_group_);
-				break;
-		}
-	}
-
-	TRACE_OUT(cache_lfu_policy_get_prev_item);
-	return ((struct cache_policy_item_ *)lfu_item);
-}
-
-/*
- * Initializes the cache_policy_ structure by filling it with appropriate
- * functions pointers
- */
-struct cache_policy_ *
-init_cache_lfu_policy()
-{
-	int i;
-	struct cache_lfu_policy_ *retval;
-
-	TRACE_IN(init_cache_lfu_policy);
-	retval = (struct cache_lfu_policy_ *)malloc(
-		sizeof(struct cache_lfu_policy_));
-	assert(retval != NULL);
-	memset(retval, 0, sizeof(struct cache_lfu_policy_));
-
-	retval->parent_data.create_item_func = cache_lfu_policy_create_item;
-	retval->parent_data.destroy_item_func = cache_lfu_policy_destroy_item;
-
-	retval->parent_data.add_item_func = cache_lfu_policy_add_item;
-	retval->parent_data.update_item_func = cache_lfu_policy_update_item;
-	retval->parent_data.remove_item_func = cache_lfu_policy_remove_item;
-
-	retval->parent_data.get_first_item_func =
-		cache_lfu_policy_get_first_item;
-	retval->parent_data.get_last_item_func =
-		cache_lfu_policy_get_last_item;
-	retval->parent_data.get_next_item_func =
-		cache_lfu_policy_get_next_item;
-	retval->parent_data.get_prev_item_func =
-		cache_lfu_policy_get_prev_item;
-
-	for (i = 0; i < CACHELIB_MAX_FREQUENCY; ++i)
-		TAILQ_INIT(&(retval->groups[i]));
-
-	TRACE_OUT(init_cache_lfu_policy);
-	return ((struct cache_policy_ *)retval);
-}
-
-void
-destroy_cache_lfu_policy(struct cache_policy_ *policy)
-{
-	int i;
-	struct cache_lfu_policy_ *lfu_policy;
-	struct cache_lfu_policy_item_ *lfu_item;
-
-	TRACE_IN(destroy_cache_lfu_policy);
-	lfu_policy = (struct cache_lfu_policy_ *)policy;
-	for (i = 0; i < CACHELIB_MAX_FREQUENCY; ++i) {
-		while (!TAILQ_EMPTY(&(lfu_policy->groups[i]))) {
-			lfu_item = TAILQ_FIRST(&(lfu_policy->groups[i]));
-			TAILQ_REMOVE(&(lfu_policy->groups[i]), lfu_item,
-				entries);
-			cache_lfu_policy_destroy_item(
-				(struct cache_policy_item_ *)lfu_item);
-		}
-	}
-	free(policy);
-	TRACE_OUT(destroy_cache_lfu_policy);
-}
diff --git a/usr.sbin/cached/cacheplcs.h b/usr.sbin/cached/cacheplcs.h
deleted file mode 100644
index 36997f5..0000000
--- a/usr.sbin/cached/cacheplcs.h
+++ /dev/null
@@ -1,137 +0,0 @@
-/*-
- * Copyright (c) 2005 Michael Bushkov <bushman@rsu.ru>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * $FreeBSD$
- */
-
-#ifndef __CACHED_CACHEPLCS_H__
-#define __CACHED_CACHEPLCS_H__
-
-#include <sys/queue.h>
-#include <sys/time.h>
-#include <stdlib.h>
-
-/* common policy definitions */
-#define CACHELIB_MAX_FREQUENCY 100
-
-/*
- * cache_policy_item_ represents some abstract cache element in the policy
- * queue. connected_item pointers to the corresponding cache_policy_item_ in
- * another policy queue.
- */
-struct cache_policy_item_
-{
-	char	*key;
-    	size_t	key_size;
-
-	size_t	request_count;
-	struct timeval last_request_time;
-	struct timeval creation_time;
-
-	struct cache_policy_item_ *connected_item;
-};
-
-/*
- * cache_policy_ represents an abstract policy queue. It can be customized by
- * setting appropriate function pointers
- */
-struct cache_policy_
-{
-	struct cache_policy_item_* (*create_item_func)();
-	void (*destroy_item_func)(struct cache_policy_item_ *);
-
-	void (*add_item_func)(struct cache_policy_ *,
-		struct cache_policy_item_ *);
-	void (*remove_item_func)(struct cache_policy_ *,
-		struct cache_policy_item_ *);
-	void (*update_item_func)(struct cache_policy_ *,
-		struct cache_policy_item_ *);
-
-	struct cache_policy_item_ *(*get_first_item_func)(
-		struct cache_policy_ *);
-	struct cache_policy_item_ *(*get_last_item_func)(
-		struct cache_policy_ *);
-	struct cache_policy_item_ *(*get_next_item_func)(
-		struct cache_policy_ *, struct cache_policy_item_ *);
-	struct cache_policy_item_ *(*get_prev_item_func)(
-		struct cache_policy_ *, struct cache_policy_item_ *);
-};
-
-/*
- * LFU cache policy item "inherited" from cache_policy_item_ structure
- */
-struct cache_lfu_policy_item_
-{
-	struct cache_policy_item_ parent_data;
-	int	frequency;
-
-	TAILQ_ENTRY(cache_lfu_policy_item_) entries;
-};
-
-TAILQ_HEAD(cache_lfu_policy_group_, cache_lfu_policy_item_);
-
-/*
- * LFU policy queue "inherited" from cache_policy_.
- */
-struct cache_lfu_policy_
-{
-	struct cache_policy_ parent_data;
-	struct cache_lfu_policy_group_ groups[CACHELIB_MAX_FREQUENCY];
-};
-
-/*
- * LRU and FIFO policies item "inherited" from cache_policy_item_
- */
-struct cache_queue_policy_item_
-{
-	struct cache_policy_item_ parent_data;
-	TAILQ_ENTRY(cache_queue_policy_item_) entries;
-};
-
-/*
- * LRU and FIFO policies "inherited" from cache_policy_
- */
-struct cache_queue_policy_
-{
-	struct cache_policy_ parent_data;
-	TAILQ_HEAD(cache_queue_policy_head_, cache_queue_policy_item_) head;
-};
-
-typedef struct cache_queue_policy_ cache_fifo_policy_;
-typedef struct cache_queue_policy_ cache_lru_policy_;
-
-/* fifo policy routines */
-extern struct cache_policy_ *init_cache_fifo_policy();
-extern void destroy_cache_fifo_policy(struct cache_policy_ *);
-
-/* lru policy routines */
-extern struct cache_policy_ *init_cache_lru_policy();
-extern void destroy_cache_lru_policy(struct cache_policy_ *);
-
-/* lfu policy routines */
-extern struct cache_policy_ *init_cache_lfu_policy();
-extern void destroy_cache_lfu_policy(struct cache_policy_ *);
-
-#endif
diff --git a/usr.sbin/cached/config.c b/usr.sbin/cached/config.c
deleted file mode 100644
index bc3eb49..0000000
--- a/usr.sbin/cached/config.c
+++ /dev/null
@@ -1,588 +0,0 @@
-/*-
- * Copyright (c) 2005 Michael Bushkov <bushman@rsu.ru>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- */
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-
-#include <assert.h>
-#include <math.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include "config.h"
-#include "debug.h"
-#include "log.h"
-
-/*
- * Default entries, which always exist in the configuration
- */
-const char *c_default_entries[6] = {
-	NSDB_PASSWD,
-	NSDB_GROUP,
-	NSDB_HOSTS,
-	NSDB_SERVICES,
-	NSDB_PROTOCOLS,
-	NSDB_RPC
-	};
-
-static int configuration_entry_cmp(const void *, const void *);
-static int configuration_entry_sort_cmp(const void *, const void *);
-static int configuration_entry_cache_mp_sort_cmp(const void *, const void *);
-static int configuration_entry_cache_mp_cmp(const void *, const void *);
-static int configuration_entry_cache_mp_part_cmp(const void *, const void *);
-static struct configuration_entry *create_configuration_entry(const char *,
-	struct timeval const *, struct timeval const *,
-	struct common_cache_entry_params const *,
-	struct common_cache_entry_params const *,
-	struct mp_cache_entry_params const *);
-
-static int
-configuration_entry_sort_cmp(const void *e1, const void *e2)
-{
-	return (strcmp((*((struct configuration_entry **)e1))->name,
-		(*((struct configuration_entry **)e2))->name
-		));
-}
-
-static int
-configuration_entry_cmp(const void *e1, const void *e2)
-{
-	return (strcmp((const char *)e1,
-		(*((struct configuration_entry **)e2))->name
-		));
-}
-
-static int
-configuration_entry_cache_mp_sort_cmp(const void *e1, const void *e2)
-{
-	return (strcmp((*((cache_entry *)e1))->params->entry_name,
-		(*((cache_entry *)e2))->params->entry_name
-		));
-}
-
-static int
-configuration_entry_cache_mp_cmp(const void *e1, const void *e2)
-{
-	return (strcmp((const char *)e1,
-		(*((cache_entry *)e2))->params->entry_name
-		));
-}
-
-static int
-configuration_entry_cache_mp_part_cmp(const void *e1, const void *e2)
-{
-	return (strncmp((const char *)e1,
-		(*((cache_entry *)e2))->params->entry_name,
-		strlen((const char *)e1)
-		));
-}
-
-static struct configuration_entry *
-create_configuration_entry(const char *name,
-	struct timeval const *common_timeout,
-	struct timeval const *mp_timeout,
-	struct common_cache_entry_params const *positive_params,
-	struct common_cache_entry_params const *negative_params,
-	struct mp_cache_entry_params const *mp_params)
-{
-	struct configuration_entry *retval;
-	size_t	size;
-	int res;
-
-	TRACE_IN(create_configuration_entry);
-	assert(name != NULL);
-	assert(positive_params != NULL);
-	assert(negative_params != NULL);
-	assert(mp_params != NULL);
-
-	retval = (struct configuration_entry *)malloc(
-		sizeof(struct configuration_entry));
-	assert(retval != NULL);
-	memset(retval, 0, sizeof(struct configuration_entry));
-
-	res = pthread_mutex_init(&retval->positive_cache_lock, NULL);
-	if (res != 0) {
-		free(retval);
-		LOG_ERR_2("create_configuration_entry",
-			"can't create positive cache lock");
-		TRACE_OUT(create_configuration_entry);
-		return (NULL);
-	}
-
-	res = pthread_mutex_init(&retval->negative_cache_lock, NULL);
-	if (res != 0) {
-		pthread_mutex_destroy(&retval->positive_cache_lock);
-		free(retval);
-		LOG_ERR_2("create_configuration_entry",
-			"can't create negative cache lock");
-		TRACE_OUT(create_configuration_entry);
-		return (NULL);
-	}
-
-	res = pthread_mutex_init(&retval->mp_cache_lock, NULL);
-	if (res != 0) {
-		pthread_mutex_destroy(&retval->positive_cache_lock);
-		pthread_mutex_destroy(&retval->negative_cache_lock);
-		free(retval);
-		LOG_ERR_2("create_configuration_entry",
-			"can't create negative cache lock");
-		TRACE_OUT(create_configuration_entry);
-		return (NULL);
-	}
-
-	memcpy(&retval->positive_cache_params, positive_params,
-		sizeof(struct common_cache_entry_params));
-	memcpy(&retval->negative_cache_params, negative_params,
-		sizeof(struct common_cache_entry_params));
-	memcpy(&retval->mp_cache_params, mp_params,
-		sizeof(struct mp_cache_entry_params));
-
-	size = strlen(name);
-	retval->name = (char *)malloc(size + 1);
-	assert(retval->name != NULL);
-	memset(retval->name, 0, size + 1);
-	memcpy(retval->name, name, size);
-
-	memcpy(&retval->common_query_timeout, common_timeout,
-		sizeof(struct timeval));
-	memcpy(&retval->mp_query_timeout, mp_timeout,
-		sizeof(struct timeval));
-
-	asprintf(&retval->positive_cache_params.entry_name, "%s+", name);
-	assert(retval->positive_cache_params.entry_name != NULL);
-
-	asprintf(&retval->negative_cache_params.entry_name, "%s-", name);
-	assert(retval->negative_cache_params.entry_name != NULL);
-
-	asprintf(&retval->mp_cache_params.entry_name, "%s*", name);
-	assert(retval->mp_cache_params.entry_name != NULL);
-
-	TRACE_OUT(create_configuration_entry);
-	return (retval);
-}
-
-/*
- * Creates configuration entry and fills it with default values
- */
-struct configuration_entry *
-create_def_configuration_entry(const char *name)
-{
-	struct common_cache_entry_params positive_params, negative_params;
-	struct mp_cache_entry_params mp_params;
-	struct timeval default_common_timeout, default_mp_timeout;
-
-	struct configuration_entry *res = NULL;
-
-	TRACE_IN(create_def_configuration_entry);
-	memset(&positive_params, 0,
-		sizeof(struct common_cache_entry_params));
-	positive_params.entry_type = CET_COMMON;
-	positive_params.cache_entries_size = DEFAULT_CACHE_HT_SIZE;
-	positive_params.max_elemsize = DEFAULT_POSITIVE_ELEMENTS_SIZE;
-	positive_params.satisf_elemsize = DEFAULT_POSITIVE_ELEMENTS_SIZE / 2;
-	positive_params.max_lifetime.tv_sec = DEFAULT_POSITIVE_LIFETIME;
-	positive_params.policy = CPT_LRU;
-
-	memcpy(&negative_params, &positive_params,
-		sizeof(struct common_cache_entry_params));
-	negative_params.max_elemsize = DEFAULT_NEGATIVE_ELEMENTS_SIZE;
-	negative_params.satisf_elemsize = DEFAULT_NEGATIVE_ELEMENTS_SIZE / 2;
-	negative_params.max_lifetime.tv_sec = DEFAULT_NEGATIVE_LIFETIME;
-	negative_params.policy = CPT_FIFO;
-
-	memset(&default_common_timeout, 0, sizeof(struct timeval));
-	default_common_timeout.tv_sec = DEFAULT_COMMON_ENTRY_TIMEOUT;
-
-	memset(&default_mp_timeout, 0, sizeof(struct timeval));
-	default_mp_timeout.tv_sec = DEFAULT_MP_ENTRY_TIMEOUT;
-
-	memset(&mp_params, 0,
-		sizeof(struct mp_cache_entry_params));
-	mp_params.entry_type = CET_MULTIPART;
-	mp_params.max_elemsize = DEFAULT_MULTIPART_ELEMENTS_SIZE;
-	mp_params.max_sessions = DEFAULT_MULITPART_SESSIONS_SIZE;
-	mp_params.max_lifetime.tv_sec = DEFAULT_MULITPART_LIFETIME;
-
-	res = create_configuration_entry(name, &default_common_timeout,
-		&default_mp_timeout, &positive_params, &negative_params,
-		&mp_params);
-
-	TRACE_OUT(create_def_configuration_entry);
-	return (res);
-}
-
-void
-destroy_configuration_entry(struct configuration_entry *entry)
-{
-	TRACE_IN(destroy_configuration_entry);
-	assert(entry != NULL);
-	pthread_mutex_destroy(&entry->positive_cache_lock);
-	pthread_mutex_destroy(&entry->negative_cache_lock);
-	pthread_mutex_destroy(&entry->mp_cache_lock);
-	free(entry->name);
-	free(entry->positive_cache_params.entry_name);
-	free(entry->negative_cache_params.entry_name);
-	free(entry->mp_cache_params.entry_name);
-	free(entry->mp_cache_entries);
-	free(entry);
-	TRACE_OUT(destroy_configuration_entry);
-}
-
-int
-add_configuration_entry(struct configuration *config,
-	struct configuration_entry *entry)
-{
-	TRACE_IN(add_configuration_entry);
-	assert(entry != NULL);
-	assert(entry->name != NULL);
-	if (configuration_find_entry(config, entry->name) != NULL) {
-		TRACE_OUT(add_configuration_entry);
-		return (-1);
-	}
-
-	if (config->entries_size == config->entries_capacity) {
-		struct configuration_entry **new_entries;
-
-		config->entries_capacity *= 2;
-		new_entries = (struct configuration_entry **)malloc(
-			sizeof(struct configuration_entry *) *
-			config->entries_capacity);
-		assert(new_entries != NULL);
-		memset(new_entries, 0, sizeof(struct configuration_entry *) *
-			config->entries_capacity);
-		memcpy(new_entries, config->entries,
-			sizeof(struct configuration_entry *) *
-		        config->entries_size);
-
-		free(config->entries);
-		config->entries = new_entries;
-	}
-
-	config->entries[config->entries_size++] = entry;
-	qsort(config->entries, config->entries_size,
-		sizeof(struct configuration_entry *),
-		configuration_entry_sort_cmp);
-
-	TRACE_OUT(add_configuration_entry);
-	return (0);
-}
-
-size_t
-configuration_get_entries_size(struct configuration *config)
-{
-	TRACE_IN(configuration_get_entries_size);
-	assert(config != NULL);
-	TRACE_OUT(configuration_get_entries_size);
-	return (config->entries_size);
-}
-
-struct configuration_entry *
-configuration_get_entry(struct configuration *config, size_t index)
-{
-	TRACE_IN(configuration_get_entry);
-	assert(config != NULL);
-	assert(index < config->entries_size);
-	TRACE_OUT(configuration_get_entry);
-	return (config->entries[index]);
-}
-
-struct configuration_entry *
-configuration_find_entry(struct configuration *config,
-	const char *name)
-{
-	struct configuration_entry	**retval;
-
-	TRACE_IN(configuration_find_entry);
-
-	retval = bsearch(name, config->entries, config->entries_size,
-		sizeof(struct configuration_entry *), configuration_entry_cmp);
-	TRACE_OUT(configuration_find_entry);
-
-	return ((retval != NULL) ? *retval : NULL);
-}
-
-/*
- * All multipart cache entries are stored in the configuration_entry in the
- * sorted array (sorted by names). The 3 functions below manage this array.
- */
-
-int
-configuration_entry_add_mp_cache_entry(struct configuration_entry *config_entry,
-	cache_entry c_entry)
-{
-	cache_entry *new_mp_entries, *old_mp_entries;
-
-	TRACE_IN(configuration_entry_add_mp_cache_entry);
-	++config_entry->mp_cache_entries_size;
-	new_mp_entries = (cache_entry *)malloc(sizeof(cache_entry) *
-		config_entry->mp_cache_entries_size);
-	assert(new_mp_entries != NULL);
-	new_mp_entries[0] = c_entry;
-
-	if (config_entry->mp_cache_entries_size - 1 > 0) {
-		memcpy(new_mp_entries + 1,
-		    config_entry->mp_cache_entries,
-		    (config_entry->mp_cache_entries_size - 1) *
-		    sizeof(cache_entry));
-	}
-
-	old_mp_entries = config_entry->mp_cache_entries;
-	config_entry->mp_cache_entries = new_mp_entries;
-	free(old_mp_entries);
-
-	qsort(config_entry->mp_cache_entries,
-		config_entry->mp_cache_entries_size,
-		sizeof(cache_entry),
-		configuration_entry_cache_mp_sort_cmp);
-
-	TRACE_OUT(configuration_entry_add_mp_cache_entry);
-	return (0);
-}
-
-cache_entry
-configuration_entry_find_mp_cache_entry(
-	struct configuration_entry *config_entry, const char *mp_name)
-{
-	cache_entry *result;
-
-	TRACE_IN(configuration_entry_find_mp_cache_entry);
-	result = bsearch(mp_name, config_entry->mp_cache_entries,
-		config_entry->mp_cache_entries_size,
-		sizeof(cache_entry), configuration_entry_cache_mp_cmp);
-
-	if (result == NULL) {
-		TRACE_OUT(configuration_entry_find_mp_cache_entry);
-		return (NULL);
-	} else {
-		TRACE_OUT(configuration_entry_find_mp_cache_entry);
-		return (*result);
-	}
-}
-
-/*
- * Searches for all multipart entries with names starting with mp_name.
- * Needed for cache flushing.
- */
-int
-configuration_entry_find_mp_cache_entries(
-	struct configuration_entry *config_entry, const char *mp_name,
-	cache_entry **start, cache_entry **finish)
-{
-	cache_entry *result;
-
-	TRACE_IN(configuration_entry_find_mp_cache_entries);
-	result = bsearch(mp_name, config_entry->mp_cache_entries,
-		config_entry->mp_cache_entries_size,
-		sizeof(cache_entry), configuration_entry_cache_mp_part_cmp);
-
-	if (result == NULL) {
-		TRACE_OUT(configuration_entry_find_mp_cache_entries);
-		return (-1);
-	}
-
-	*start = result;
-	*finish = result + 1;
-
-	while (*start != config_entry->mp_cache_entries) {
-	    if (configuration_entry_cache_mp_part_cmp(mp_name, *start - 1) == 0)
-		*start = *start - 1;
-	    else
-		break;
-	}
-
-	while (*finish != config_entry->mp_cache_entries +
-		config_entry->mp_cache_entries_size) {
-
-	    if (configuration_entry_cache_mp_part_cmp(
-		mp_name, *finish) == 0)
-	    	*finish = *finish + 1;
-	    else
-		break;
-	}
-
-	TRACE_OUT(configuration_entry_find_mp_cache_entries);
-	return (0);
-}
-
-/*
- * Configuration entry uses rwlock to handle access to its fields.
- */
-void
-configuration_lock_rdlock(struct configuration *config)
-{
-    TRACE_IN(configuration_lock_rdlock);
-    pthread_rwlock_rdlock(&config->rwlock);
-    TRACE_OUT(configuration_lock_rdlock);
-}
-
-void
-configuration_lock_wrlock(struct configuration *config)
-{
-    TRACE_IN(configuration_lock_wrlock);
-    pthread_rwlock_wrlock(&config->rwlock);
-    TRACE_OUT(configuration_lock_wrlock);
-}
-
-void
-configuration_unlock(struct configuration *config)
-{
-    TRACE_IN(configuration_unlock);
-    pthread_rwlock_unlock(&config->rwlock);
-    TRACE_OUT(configuration_unlock);
-}
-
-/*
- * Configuration entry uses 3 mutexes to handle cache operations. They are
- * acquired by configuration_lock_entry and configuration_unlock_entry
- * functions.
- */
-void
-configuration_lock_entry(struct configuration_entry *entry,
-	enum config_entry_lock_type lock_type)
-{
-	TRACE_IN(configuration_lock_entry);
-	assert(entry != NULL);
-
-	switch (lock_type) {
-	case CELT_POSITIVE:
-		pthread_mutex_lock(&entry->positive_cache_lock);
-		break;
-	case CELT_NEGATIVE:
-		pthread_mutex_lock(&entry->negative_cache_lock);
-		break;
-	case CELT_MULTIPART:
-		pthread_mutex_lock(&entry->mp_cache_lock);
-		break;
-	default:
-		/* should be unreachable */
-		break;
-	}
-	TRACE_OUT(configuration_lock_entry);
-}
-
-void
-configuration_unlock_entry(struct configuration_entry *entry,
-	enum config_entry_lock_type lock_type)
-{
-	TRACE_IN(configuration_unlock_entry);
-	assert(entry != NULL);
-
-	switch (lock_type) {
-	case CELT_POSITIVE:
-		pthread_mutex_unlock(&entry->positive_cache_lock);
-		break;
-	case CELT_NEGATIVE:
-		pthread_mutex_unlock(&entry->negative_cache_lock);
-		break;
-	case CELT_MULTIPART:
-		pthread_mutex_unlock(&entry->mp_cache_lock);
-		break;
-	default:
-		/* should be unreachable */
-		break;
-	}
-	TRACE_OUT(configuration_unlock_entry);
-}
-
-struct configuration *
-init_configuration(void)
-{
-	struct configuration	*retval;
-
-	TRACE_IN(init_configuration);
-	retval = (struct configuration *)malloc(sizeof(struct configuration));
-	assert(retval != NULL);
-	memset(retval, 0, sizeof(struct configuration));
-
-	retval->entries_capacity = INITIAL_ENTRIES_CAPACITY;
-	retval->entries = (struct configuration_entry **)malloc(
-		sizeof(struct configuration_entry *) *
-		retval->entries_capacity);
-	assert(retval->entries != NULL);
-	memset(retval->entries, 0, sizeof(struct configuration_entry *) *
-		retval->entries_capacity);
-
-	pthread_rwlock_init(&retval->rwlock, NULL);
-
-	TRACE_OUT(init_configuration);
-	return (retval);
-}
-
-void
-fill_configuration_defaults(struct configuration *config)
-{
-	size_t	len, i;
-
-	TRACE_IN(fill_configuration_defaults);
-	assert(config != NULL);
-
-	if (config->socket_path != NULL)
-		free(config->socket_path);
-
-	len = strlen(DEFAULT_SOCKET_PATH);
-	config->socket_path = (char *)malloc(len + 1);
-	assert(config->socket_path != NULL);
-	memset(config->socket_path, 0, len + 1);
-	memcpy(config->socket_path, DEFAULT_SOCKET_PATH, len);
-
-	len = strlen(DEFAULT_PIDFILE_PATH);
-	config->pidfile_path = (char *)malloc(len + 1);
-	assert(config->pidfile_path != NULL);
-	memset(config->pidfile_path, 0, len + 1);
-	memcpy(config->pidfile_path, DEFAULT_PIDFILE_PATH, len);
-
-	config->socket_mode =  S_IFSOCK | S_IRUSR | S_IWUSR |
-		S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
-	config->force_unlink = 1;
-
-	config->query_timeout = DEFAULT_QUERY_TIMEOUT;
-	config->threads_num = DEFAULT_THREADS_NUM;
-
-	for (i = 0; i < config->entries_size; ++i)
-		destroy_configuration_entry(config->entries[i]);
-	config->entries_size = 0;
-
-	TRACE_OUT(fill_configuration_defaults);
-}
-
-void
-destroy_configuration(struct configuration *config)
-{
-	int	i;
-	TRACE_IN(destroy_configuration);
-	assert(config != NULL);
-	free(config->pidfile_path);
-	free(config->socket_path);
-
-	for (i = 0; i < config->entries_size; ++i)
-		destroy_configuration_entry(config->entries[i]);
-	free(config->entries);
-
-	pthread_rwlock_destroy(&config->rwlock);
-	free(config);
-	TRACE_OUT(destroy_configuration);
-}
diff --git a/usr.sbin/cached/config.h b/usr.sbin/cached/config.h
deleted file mode 100644
index b54dc9b..0000000
--- a/usr.sbin/cached/config.h
+++ /dev/null
@@ -1,156 +0,0 @@
-/*-
- * Copyright (c) 2005 Michael Bushkov <bushman@rsu.ru>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * $FreeBSD$
- */
-
-#ifndef __CACHED_CONFIG_H__
-#define __CACHED_CONFIG_H__
-
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <pthread.h>
-#include <nsswitch.h>
-#include <unistd.h>
-#include "cachelib.h"
-
-#define DEFAULT_QUERY_TIMEOUT		8
-#define DEFAULT_THREADS_NUM		8
-
-#define DEFAULT_COMMON_ENTRY_TIMEOUT	10
-#define DEFAULT_MP_ENTRY_TIMEOUT	60
-#define DEFAULT_CACHE_HT_SIZE		257
-
-#define INITIAL_ENTRIES_CAPACITY	8
-#define DEFAULT_SOCKET_PATH		"/var/run/cached"
-#define DEFAULT_PIDFILE_PATH		"/var/run/cached.pid"
-
-#define DEFAULT_POSITIVE_ELEMENTS_SIZE	(2048)
-#define DEFAULT_POSITIVE_LIFETIME 	(3600)
-
-#define DEFAULT_NEGATIVE_ELEMENTS_SIZE	(2048)
-#define DEFAULT_NEGATIVE_LIFETIME	(60)
-
-#define DEFAULT_MULTIPART_ELEMENTS_SIZE	(1024 * 8)
-#define DEFAULT_MULITPART_SESSIONS_SIZE	(1024)
-#define DEFAULT_MULITPART_LIFETIME	(3600)
-
-extern const char *c_default_entries[6];
-
-/*
- * Configuration entry represents the details of each cache entry in the
- * config file (i.e. passwd or group). Its purpose also is to acquire locks
- * of three different types (for usual read/write caching, for multipart
- * caching and for caching of the negative results) for that cache entry.
- */
-struct configuration_entry {
-	struct common_cache_entry_params positive_cache_params;
-	struct common_cache_entry_params negative_cache_params;
-	struct mp_cache_entry_params mp_cache_params;
-
-	/*
-	 * configuration_entry holds pointers for all actual cache_entries,
-	 * which are used for it. There is one for positive caching, one for
-	 * for negative caching, and several (one per each euid/egid) for
-	 * multipart caching.
-	 */
-	cache_entry positive_cache_entry;
-	cache_entry negative_cache_entry;
-
-	cache_entry *mp_cache_entries;
-	size_t mp_cache_entries_size;
-
-	struct timeval common_query_timeout;
-	struct timeval mp_query_timeout;
-
-	char	*name;
-	pthread_mutex_t positive_cache_lock;
-	pthread_mutex_t negative_cache_lock;
-	pthread_mutex_t mp_cache_lock;
-
-	int	perform_actual_lookups;
-	int	enabled;
-};
-
-/*
- * Contains global configuration options and array of all configuration entries
- */
-struct configuration {
-	char	*pidfile_path;
-	char	*socket_path;
-
-	struct configuration_entry **entries;
-	size_t	entries_capacity;
-	size_t	entries_size;
-
-	pthread_rwlock_t rwlock;
-
-	mode_t	socket_mode;
-	int	force_unlink;
-	int	query_timeout;
-
-	int	threads_num;
-};
-
-enum config_entry_lock_type {
-	CELT_POSITIVE,
-	CELT_NEGATIVE,
-	CELT_MULTIPART
-};
-
-extern struct configuration *init_configuration(void);
-extern void destroy_configuration(struct configuration *);
-extern void fill_configuration_defaults(struct configuration *);
-
-extern int add_configuration_entry(struct configuration *,
-	struct configuration_entry *);
-extern struct configuration_entry *create_def_configuration_entry(
-	const char *);
-extern void destroy_configuration_entry(struct configuration_entry *);
-extern size_t configuration_get_entries_size(struct configuration *);
-extern struct configuration_entry *configuration_get_entry(
-	struct configuration *, size_t);
-extern struct configuration_entry *configuration_find_entry(
-	struct configuration *, const char *);
-
-extern int configuration_entry_add_mp_cache_entry(struct configuration_entry *,
-	cache_entry);
-extern cache_entry configuration_entry_find_mp_cache_entry(
-	struct configuration_entry *,
-	const char *);
-extern int configuration_entry_find_mp_cache_entries(
-	struct configuration_entry *, const char *, cache_entry **,
-	cache_entry **);
-
-extern void configuration_lock_rdlock(struct configuration *config);
-extern void configuration_lock_wrlock(struct configuration *config);
-extern void configuration_unlock(struct configuration *config);
-
-extern void configuration_lock_entry(struct configuration_entry *,
-	enum config_entry_lock_type);
-extern void configuration_unlock_entry(struct configuration_entry *,
-	enum config_entry_lock_type);
-
-#endif
diff --git a/usr.sbin/cached/debug.c b/usr.sbin/cached/debug.c
deleted file mode 100644
index 420c517..0000000
--- a/usr.sbin/cached/debug.c
+++ /dev/null
@@ -1,149 +0,0 @@
-/*-
- * Copyright (c) 2004 Michael Bushkov <bushman@rsu.ru>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- */
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-
-#include <stdio.h>
-#include "debug.h"
-
-static	int	trace_level = 0;
-static	int	trace_level_bk = 0;
-
-void
-__trace_in(const char *s, const char *f, int l)
-{
-	int i;
-	if (trace_level < TRACE_WANTED)
-	{
-		for (i = 0; i < trace_level; ++i)
-			printf("\t");
-
-		printf("=> %s\n", s);
-	}
-
-	++trace_level;
-}
-
-void
-__trace_point(const char *f, int l)
-{
-	int i;
-
-	if (trace_level < TRACE_WANTED)
-	{
-		for (i = 0; i < trace_level - 1; ++i)
-			printf("\t");
-
-		printf("= %s: %d\n", f, l);
-	}
-}
-
-void
-__trace_msg(const char *msg, const char *f, int l)
-{
-	int i;
-
-	if (trace_level < TRACE_WANTED)
-	{
-		for (i = 0; i < trace_level - 1; ++i)
-			printf("\t");
-
-		printf("= MSG %s, %s: %d\n", msg, f, l);
-	}
-}
-
-void
-__trace_ptr(const char *desc, const void *p, const char *f, int l)
-{
-	int i;
-
-	if (trace_level < TRACE_WANTED)
-	{
-		for (i = 0; i < trace_level - 1; ++i)
-			printf("\t");
-
-		printf("= PTR %s: %p, %s: %d\n", desc, p, f, l);
-	}
-}
-
-void
-__trace_int(const char *desc, int i, const char *f, int l)
-{
-	int j;
-
-	if (trace_level < TRACE_WANTED)
-	{
-		for (j = 0; j < trace_level - 1; ++j)
-			printf("\t");
-
-		printf("= INT %s: %i, %s: %d\n",desc, i, f, l);
-	}
-}
-
-void
-__trace_str(const char *desc, const char *s, const char *f, int l)
-{
-	int i;
-
-	if (trace_level < TRACE_WANTED)
-	{
-		for (i = 0; i < trace_level - 1; ++i)
-			printf("\t");
-
-		printf("= STR %s: '%s', %s: %d\n", desc, s, f, l);
-	}
-}
-
-void
-__trace_out(const char *s, const char *f, int l)
-{
-	int i;
-
-	--trace_level;
-	if (trace_level < TRACE_WANTED)
-	{
-		for (i = 0; i < trace_level; ++i)
-			printf("\t");
-
-		printf("<= %s\n", s);
-	}
-}
-
-void
-__trace_on()
-{
-	trace_level = trace_level_bk;
-	trace_level_bk = 0;
-}
-
-void
-__trace_off()
-{
-	trace_level_bk = trace_level;
-	trace_level = 1024;
-}
diff --git a/usr.sbin/cached/debug.h b/usr.sbin/cached/debug.h
deleted file mode 100644
index 320e10f..0000000
--- a/usr.sbin/cached/debug.h
+++ /dev/null
@@ -1,67 +0,0 @@
-/*-
- * Copyright (c) 2004 Michael Bushkov <bushman@rsu.ru>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * $FreeBSD$
- */
-
-#ifndef __CACHED_DEBUG_H__
-#define __CACHED_DEBUG_H__
-
-#define TRACE_WANTED 32
-
-/* #ifndef NDEBUG */
-#if 0
-#define TRACE_IN(x)	__trace_in(#x, __FILE__, __LINE__)
-#define TRACE_POINT()	__trace_point(__FILE__, __LINE__)
-#define TRACE_MSG(x)	__trace_msg(x, __FILE__, __LINE__)
-#define TRACE_PTR(p)	__trace_ptr(#p, p, __FILE__, __LINE__)
-#define TRACE_INT(i)	__trace_int(#i, i, __FILE__, __LINE__)
-#define TRACE_STR(s)	__trace_str(#s, s, __FILE__, __LINE__)
-#define TRACE_OUT(x)	__trace_out(#x, __FILE__, __LINE__)
-#define TRACE_ON()	__trace_on()
-#define TRACE_OFF()	__trace_off()
-#else
-#define TRACE_IN(x)
-#define TRACE_POINT()
-#define TRACE_MSG(x)
-#define TRACE_PTR(p)
-#define TRACE_INT(i)
-#define TRACE_STR(s)
-#define TRACE_OUT(x)
-#define TRACE_ON()
-#define TRACE_OFF()
-#endif
-
-extern void __trace_in(const char *, const char *, int);
-extern void __trace_point(const char *, int);
-extern void __trace_msg(const char *, const char *, int);
-extern void __trace_ptr(const char *, const void *, const char *, int);
-extern void __trace_int(const char *, int, const char *, int);
-extern void __trace_str(const char *, const char *, const char *, int);
-extern void __trace_out(const char *, const char *, int);
-extern void __trace_on();
-extern void __trace_off();
-
-#endif
diff --git a/usr.sbin/cached/hashtable.h b/usr.sbin/cached/hashtable.h
deleted file mode 100644
index 86dad9f..0000000
--- a/usr.sbin/cached/hashtable.h
+++ /dev/null
@@ -1,218 +0,0 @@
-/*-
- * Copyright (c) 2005 Michael Bushkov <bushman@rsu.ru>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * $FreeBSD$
- */
-
-#ifndef __CACHELIB_HASHTABLE_H__
-#define __CACHELIB_HASHTABLE_H__
-
-#include <search.h>
-#include <string.h>
-
-#define HASHTABLE_INITIAL_ENTRIES_CAPACITY 8
-typedef int hashtable_index_t;
-
-/*
- * This file contains queue.h-like macro definitions for hash tables.
- * Hash table is organized as an array of the specified size of the user
- * defined (with HASTABLE_ENTRY_HEAD) structures. Each hash table
- * entry (user defined structure) stores its elements in the sorted array.
- * You can place elements into the hash table, retrieve elements with
- * specified key, traverse through all elements, and delete them.
- * New elements are placed into the hash table by using the compare and
- * hashing functions, provided by the user.
- */
-
-/*
- * Defines the hash table entry structure, that uses specified type of
- * elements.
- */
-#define HASHTABLE_ENTRY_HEAD(name, type) struct name {			\
-	type	*values;						\
-	size_t capacity;						\
-	size_t size;							\
-}
-
-/*
- * Defines the hash table structure, which uses the specified type of entries.
- * The only restriction for entries is that is that they should have the field,
- * defined with HASHTABLE_ENTRY_HEAD macro.
- */
-#define HASHTABLE_HEAD(name, entry) struct name {			\
-	struct entry	*entries;					\
-	size_t		entries_size;					\
-}
-
-#define HASHTABLE_ENTRIES_COUNT(table) ((table)->entries_size)
-
-/*
- * Unlike most of queue.h data types, hash tables can not be initialized
- * statically - so there is no HASHTABLE_HEAD_INITIALIZED macro.
- */
-#define HASHTABLE_INIT(table, type, field, _entries_size)		\
-	do {								\
-		hashtable_index_t var;					\
-		(table)->entries = (void *)malloc(			\
-			sizeof(*(table)->entries) * (_entries_size));	\
-		memset((table)->entries, 0, 				\
-			sizeof(*(table)->entries) * (_entries_size));	\
-		(table)->entries_size = (_entries_size);		\
-		for (var = 0; var < HASHTABLE_ENTRIES_COUNT(table); ++var) {\
-			(table)->entries[var].field.capacity = 		\
-				HASHTABLE_INITIAL_ENTRIES_CAPACITY;	\
-			(table)->entries[var].field.size = 0;		\
-			(table)->entries[var].field.values = (type *)malloc(\
-				sizeof(type) * 				\
-		    		HASHTABLE_INITIAL_ENTRIES_CAPACITY);	\
-			assert((table)->entries[var].field.values != NULL);\
-		}							\
-	} while (0)
-
-/*
- * All initialized hashtables should be destroyed with this macro.
- */
-#define HASHTABLE_DESTROY(table, field)					\
-	do {								\
-		hashtable_index_t var;					\
-		for (var = 0; var < HASHTABLE_ENTRIES_COUNT(table); ++var) {\
-			free((table)->entries[var].field.values);	\
-		}							\
-	} while (0)
-
-#define HASHTABLE_GET_ENTRY(table, hash)	(&((table)->entries[hash]))
-
-/*
- * Traverses through all hash table entries
- */
-#define HASHTABLE_FOREACH(table, var)					\
-	for ((var) = &((table)->entries[0]);				\
-		(var) < &((table)->entries[HASHTABLE_ENTRIES_COUNT(table)]);\
-		++(var))
-
-/*
- * Traverses through all elements of the specified hash table entry
- */
-#define HASHTABLE_ENTRY_FOREACH(entry, field, var)			\
-	for ((var) = &((entry)->field.values[0]);			\
-		(var) < &((entry)->field.values[(entry)->field.size]);	\
-		++(var))
-
-#define HASHTABLE_ENTRY_CLEAR(entry, field)				\
-	((entry)->field.size = 0)
-
-#define HASHTABLE_ENTRY_SIZE(entry, field)				\
-	((entry)->field.size)
-
-#define HASHTABLE_ENTRY_CAPACITY(entry, field)				\
-	((entry)->field.capacity)
-
-#define HASHTABLE_ENTRY_CAPACITY_INCREASE(entry, field, type)		\
-	(entry)->field.capacity *= 2;					\
-	(entry)->field.values = (type *)realloc((entry)->field.values, 	\
-		(entry)->field.capacity * sizeof(type));
-
-#define HASHTABLE_ENTRY_CAPACITY_DECREASE(entry, field, type)		\
-	(entry)->field.capacity /= 2;					\
-	(entry)->field.values = (type *)realloc((entry)->field.values, 	\
-		(entry)->field.capacity * sizeof(type));
-
-/*
- * Generates prototypes for the hash table functions
- */
-#define HASHTABLE_PROTOTYPE(name, entry_, type)				\
-hashtable_index_t name##_CALCULATE_HASH(struct name *, type *);		\
-void name##_ENTRY_STORE(struct entry_*, type *);			\
-type *name##_ENTRY_FIND(struct entry_*, type *);			\
-type *name##_ENTRY_FIND_SPECIAL(struct entry_ *, type *,		\
-	int (*) (const void *, const void *));				\
-void name##_ENTRY_REMOVE(struct entry_*, type *);
-
-/*
- * Generates implementations of the hash table functions
- */
-#define HASHTABLE_GENERATE(name, entry_, type, field, HASH, CMP)	\
-hashtable_index_t name##_CALCULATE_HASH(struct name *table, type *data)	\
-{									\
-									\
-	return HASH(data, table->entries_size);				\
-}									\
-									\
-void name##_ENTRY_STORE(struct entry_ *the_entry, type *data)		\
-{									\
-									\
-	if (the_entry->field.size == the_entry->field.capacity)		\
-		HASHTABLE_ENTRY_CAPACITY_INCREASE(the_entry, field, type);\
-									\
-	memcpy(&(the_entry->field.values[the_entry->field.size++]),	\
-		data,							\
-		sizeof(type));						\
-	qsort(the_entry->field.values, the_entry->field.size, 		\
-		sizeof(type), CMP);					\
-}									\
-									\
-type *name##_ENTRY_FIND(struct entry_ *the_entry, type *key)		\
-{									\
-									\
-	return ((type *)bsearch(key, the_entry->field.values,	 	\
-		the_entry->field.size, sizeof(type), CMP));		\
-}									\
-									\
-type *name##_ENTRY_FIND_SPECIAL(struct entry_ *the_entry, type *key,	\
-	int (*compar) (const void *, const void *))			\
-{									\
-	return ((type *)bsearch(key, the_entry->field.values,	 	\
-		the_entry->field.size, sizeof(type), compar));		\
-}									\
-									\
-void name##_ENTRY_REMOVE(struct entry_ *the_entry, type *del_elm)	\
-{									\
-									\
-	memmove(del_elm, del_elm + 1, 					\
-		(&the_entry->field.values[--the_entry->field.size] - del_elm) *\
-		sizeof(type));						\
-}
-
-/*
- * Macro definitions below wrap the functions, generaed with
- * HASHTABLE_GENERATE macro. You should use them and avoid using generated
- * functions directly.
- */
-#define HASHTABLE_CALCULATE_HASH(name, table, data)			\
-	(name##_CALCULATE_HASH((table), data))
-
-#define HASHTABLE_ENTRY_STORE(name, entry, data)			\
-	name##_ENTRY_STORE((entry), data)
-
-#define HASHTABLE_ENTRY_FIND(name, entry, key)				\
-	(name##_ENTRY_FIND((entry), (key)))
-
-#define HASHTABLE_ENTRY_FIND_SPECIAL(name, entry, key, cmp)		\
-	(name##_ENTRY_FIND_SPECIAL((entry), (key), (cmp)))
-
-#define HASHTABLE_ENTRY_REMOVE(name, entry, del_elm)			\
-	name##_ENTRY_REMOVE((entry), (del_elm))
-
-#endif
diff --git a/usr.sbin/cached/log.c b/usr.sbin/cached/log.c
deleted file mode 100644
index 053930a..0000000
--- a/usr.sbin/cached/log.c
+++ /dev/null
@@ -1,78 +0,0 @@
-/*-
- * Copyright (c) 2005 Michael Bushkov <bushman@rsu.ru>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- */
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-
-#include <assert.h>
-#include <stdarg.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <syslog.h>
-#include "log.h"
-
-void
-__log_msg(int level, const char *sender, const char *message, ...)
-{
-	va_list ap;
-	char	*fmessage;
-
-	fmessage = NULL;
-	va_start(ap, message);
-	vasprintf(&fmessage, message, ap);
-	va_end(ap);
-	assert(fmessage != NULL);
-
-	printf("M%d from %s: %s\n", level, sender, fmessage);
-#ifndef NO_SYSLOG
-	if (level == 0)
-		syslog(LOG_INFO, "cached message (from %s): %s", sender,
-		fmessage);
-#endif
-	free(fmessage);
-}
-
-void
-__log_err(int level, const char *sender, const char *error, ...)
-{
-	va_list ap;
-	char	*ferror;
-
-	ferror = NULL;
-	va_start(ap, error);
-	vasprintf(&ferror, error, ap);
-	va_end(ap);
-	assert(ferror != NULL);
-
-	printf("E%d from %s: %s\n", level, sender, ferror);
-
-#ifndef NO_SYSLOG
-	if (level == 0)
-		syslog(LOG_ERR, "cached error (from %s): %s", sender, ferror);
-#endif
-	free(ferror);
-}
diff --git a/usr.sbin/cached/log.h b/usr.sbin/cached/log.h
deleted file mode 100644
index 8d665a4..0000000
--- a/usr.sbin/cached/log.h
+++ /dev/null
@@ -1,43 +0,0 @@
-/*-
- * Copyright (c) 2005 Michael Bushkov <bushman@rsu.ru>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * $FreeBSD$
- */
-
-#ifndef __CACHED_LOG_H__
-#define __CACHED_LOG_H__
-
-#define LOG_MSG_1(sender, msg, ...) __log_msg(1, sender, msg, ##__VA_ARGS__)
-#define LOG_MSG_2(sender, msg, ...) __log_msg(2, sender, msg, ##__VA_ARGS__)
-#define LOG_MSG_3(sender, msg, ...) __log_msg(3, sedner, msg, ##__VA_ARGS__)
-
-#define LOG_ERR_1(sender, err, ...) __log_err(1, sender, err, ##__VA_ARGS__)
-#define LOG_ERR_2(sender, err, ...) __log_err(2, sender, err, ##__VA_ARGS__)
-#define LOG_ERR_3(sender, err, ...) __log_err(3, sender, err, ##__VA_ARGS__)
-
-extern void __log_msg(int, const char *, const char *, ...);
-extern void __log_err(int, const char *, const char *, ...);
-
-#endif
diff --git a/usr.sbin/cached/mp_rs_query.c b/usr.sbin/cached/mp_rs_query.c
deleted file mode 100644
index ae0f3bb..0000000
--- a/usr.sbin/cached/mp_rs_query.c
+++ /dev/null
@@ -1,537 +0,0 @@
-/*-
- * Copyright (c) 2005 Michael Bushkov <bushman@rsu.ru>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- */
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-
-#include <sys/socket.h>
-#include <sys/time.h>
-#include <sys/types.h>
-#include <sys/event.h>
-#include <assert.h>
-#include <errno.h>
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-
-#include "cachelib.h"
-#include "config.h"
-#include "debug.h"
-#include "log.h"
-#include "query.h"
-#include "mp_rs_query.h"
-#include "mp_ws_query.h"
-#include "singletons.h"
-
-static int on_mp_read_session_close_notification(struct query_state *);
-static void on_mp_read_session_destroy(struct query_state *);
-static int on_mp_read_session_mapper(struct query_state *);
-/* int on_mp_read_session_request_read1(struct query_state *); */
-static int on_mp_read_session_request_read2(struct query_state *);
-static int on_mp_read_session_request_process(struct query_state *);
-static int on_mp_read_session_response_write1(struct query_state *);
-static int on_mp_read_session_read_request_process(struct query_state *);
-static int on_mp_read_session_read_response_write1(struct query_state *);
-static int on_mp_read_session_read_response_write2(struct query_state *);
-
-/*
- * This function is used as the query_state's destroy_func to make the
- * proper cleanup in case of errors.
- */
-static void
-on_mp_read_session_destroy(struct query_state *qstate)
-{
-	TRACE_IN(on_mp_read_session_destroy);
-	finalize_comm_element(&qstate->request);
-	finalize_comm_element(&qstate->response);
-
-	if (qstate->mdata != NULL) {
-		configuration_lock_entry(qstate->config_entry, CELT_MULTIPART);
-		close_cache_mp_read_session(
-	    		(cache_mp_read_session)qstate->mdata);
-		configuration_unlock_entry(qstate->config_entry,
-			CELT_MULTIPART);
-	}
-	TRACE_OUT(on_mp_read_session_destroy);
-}
-
-/*
- * The functions below are used to process multipart read session initiation
- * requests.
- * - on_mp_read_session_request_read1 and on_mp_read_session_request_read2 read
- *   the request itself
- * - on_mp_read_session_request_process processes it
- * - on_mp_read_session_response_write1 sends the response
- */
-int
-on_mp_read_session_request_read1(struct query_state *qstate)
-{
-	struct cache_mp_read_session_request	*c_mp_rs_request;
-	ssize_t	result;
-
-	TRACE_IN(on_mp_read_session_request_read1);
-	if (qstate->kevent_watermark == 0)
-		qstate->kevent_watermark = sizeof(size_t);
-	else {
-		init_comm_element(&qstate->request,
-	    		CET_MP_READ_SESSION_REQUEST);
-		c_mp_rs_request = get_cache_mp_read_session_request(
-	    		&qstate->request);
-
-		result = qstate->read_func(qstate,
-	    		&c_mp_rs_request->entry_length, sizeof(size_t));
-
-		if (result != sizeof(size_t)) {
-			TRACE_OUT(on_mp_read_session_request_read1);
-			return (-1);
-		}
-
-		if (BUFSIZE_INVALID(c_mp_rs_request->entry_length)) {
-			TRACE_OUT(on_mp_read_session_request_read1);
-			return (-1);
-		}
-
-		c_mp_rs_request->entry = (char *)malloc(
-			c_mp_rs_request->entry_length + 1);
-		assert(c_mp_rs_request->entry != NULL);
-		memset(c_mp_rs_request->entry, 0,
-			c_mp_rs_request->entry_length + 1);
-
-		qstate->kevent_watermark = c_mp_rs_request->entry_length;
-		qstate->process_func = on_mp_read_session_request_read2;
-	}
-	TRACE_OUT(on_mp_read_session_request_read1);
-	return (0);
-}
-
-static int
-on_mp_read_session_request_read2(struct query_state *qstate)
-{
-	struct cache_mp_read_session_request	*c_mp_rs_request;
-	ssize_t	result;
-
-	TRACE_IN(on_mp_read_session_request_read2);
-	c_mp_rs_request = get_cache_mp_read_session_request(&qstate->request);
-
-	result = qstate->read_func(qstate, c_mp_rs_request->entry,
-		c_mp_rs_request->entry_length);
-
-	if (result != qstate->kevent_watermark) {
-		LOG_ERR_3("on_mp_read_session_request_read2",
-			"read failed");
-		TRACE_OUT(on_mp_read_session_request_read2);
-		return (-1);
-	}
-
-	qstate->kevent_watermark = 0;
-	qstate->process_func = on_mp_read_session_request_process;
-	TRACE_OUT(on_mp_read_session_request_read2);
-	return (0);
-}
-
-static int
-on_mp_read_session_request_process(struct query_state *qstate)
-{
-	struct cache_mp_read_session_request	*c_mp_rs_request;
-	struct cache_mp_read_session_response	*c_mp_rs_response;
-	cache_mp_read_session	rs;
-	cache_entry	c_entry;
-	char	*dec_cache_entry_name;
-
-	char *buffer;
-	size_t buffer_size;
-	cache_mp_write_session ws;
-	struct agent	*lookup_agent;
-	struct multipart_agent *mp_agent;
-	void *mdata;
-	int res;
-
-	TRACE_IN(on_mp_read_session_request_process);
-	init_comm_element(&qstate->response, CET_MP_READ_SESSION_RESPONSE);
-	c_mp_rs_response = get_cache_mp_read_session_response(
-		&qstate->response);
-	c_mp_rs_request = get_cache_mp_read_session_request(&qstate->request);
-
-	qstate->config_entry = configuration_find_entry(
-		s_configuration, c_mp_rs_request->entry);
-	if (qstate->config_entry == NULL) {
-		c_mp_rs_response->error_code = ENOENT;
-
-		LOG_ERR_2("read_session_request",
-			"can't find configuration entry '%s'."
-			" aborting request", c_mp_rs_request->entry);
-		goto fin;
-	}
-
-	if (qstate->config_entry->enabled == 0) {
-		c_mp_rs_response->error_code = EACCES;
-
-		LOG_ERR_2("read_session_request",
-			"configuration entry '%s' is disabled",
-			c_mp_rs_request->entry);
-		goto fin;
-	}
-
-	if (qstate->config_entry->perform_actual_lookups != 0)
-		dec_cache_entry_name = strdup(
-			qstate->config_entry->mp_cache_params.entry_name);
-	else {
-#ifdef NS_CACHED_EID_CHECKING
-		if (check_query_eids(qstate) != 0) {
-			c_mp_rs_response->error_code = EPERM;
-			goto fin;
-		}
-#endif
-
-		asprintf(&dec_cache_entry_name, "%s%s", qstate->eid_str,
-			qstate->config_entry->mp_cache_params.entry_name);
-	}
-
-	assert(dec_cache_entry_name != NULL);
-
-	configuration_lock_rdlock(s_configuration);
-	c_entry = find_cache_entry(s_cache, dec_cache_entry_name);
-	configuration_unlock(s_configuration);
-
-	if ((c_entry == INVALID_CACHE) &&
-	   (qstate->config_entry->perform_actual_lookups != 0))
-		c_entry = register_new_mp_cache_entry(qstate,
-			dec_cache_entry_name);
-
-	free(dec_cache_entry_name);
-
-	if (c_entry != INVALID_CACHE_ENTRY) {
-		configuration_lock_entry(qstate->config_entry, CELT_MULTIPART);
-		rs = open_cache_mp_read_session(c_entry);
-		configuration_unlock_entry(qstate->config_entry,
-			CELT_MULTIPART);
-
-		if ((rs == INVALID_CACHE_MP_READ_SESSION) &&
-		   (qstate->config_entry->perform_actual_lookups != 0)) {
-			lookup_agent = find_agent(s_agent_table,
-				c_mp_rs_request->entry, MULTIPART_AGENT);
-
-			if ((lookup_agent != NULL) &&
-			(lookup_agent->type == MULTIPART_AGENT)) {
-				mp_agent = (struct multipart_agent *)
-					lookup_agent;
-				mdata = mp_agent->mp_init_func();
-
-				/*
-				 * Multipart agents read the whole snapshot
-				 * of the data at one time.
-				 */
-				configuration_lock_entry(qstate->config_entry,
-					CELT_MULTIPART);
-				ws = open_cache_mp_write_session(c_entry);
-				configuration_unlock_entry(qstate->config_entry,
-					CELT_MULTIPART);
-				if (ws != NULL) {
-				    do {
-					buffer = NULL;
-					res = mp_agent->mp_lookup_func(&buffer,
-						&buffer_size,
-						mdata);
-
-					if ((res & NS_TERMINATE) &&
-					   (buffer != NULL)) {
-						configuration_lock_entry(
-							qstate->config_entry,
-						   	CELT_MULTIPART);
-						if (cache_mp_write(ws, buffer,
-						    buffer_size) != 0) {
-							abandon_cache_mp_write_session(ws);
-							ws = NULL;
-						}
-						configuration_unlock_entry(
-							qstate->config_entry,
-							CELT_MULTIPART);
-
-						free(buffer);
-						buffer = NULL;
-					} else {
-						configuration_lock_entry(
-							qstate->config_entry,
-							CELT_MULTIPART);
-						close_cache_mp_write_session(ws);
-						configuration_unlock_entry(
-							qstate->config_entry,
-							CELT_MULTIPART);
-
-						free(buffer);
-						buffer = NULL;
-					}
-				    } while ((res & NS_TERMINATE) &&
-				    	    (ws != NULL));
-				}
-
-				configuration_lock_entry(qstate->config_entry,
-					CELT_MULTIPART);
-				rs = open_cache_mp_read_session(c_entry);
-				configuration_unlock_entry(qstate->config_entry,
-					CELT_MULTIPART);
-			}
-		}
-
-		if (rs == INVALID_CACHE_MP_READ_SESSION)
-			c_mp_rs_response->error_code = -1;
-		else {
-		    qstate->mdata = rs;
-		    qstate->destroy_func = on_mp_read_session_destroy;
-
-		    configuration_lock_entry(qstate->config_entry,
-			CELT_MULTIPART);
-		    if ((qstate->config_entry->mp_query_timeout.tv_sec != 0) ||
-		    (qstate->config_entry->mp_query_timeout.tv_usec != 0))
-			memcpy(&qstate->timeout,
-			    &qstate->config_entry->mp_query_timeout,
-			    sizeof(struct timeval));
-		    configuration_unlock_entry(qstate->config_entry,
-			CELT_MULTIPART);
-		}
-	} else
-		c_mp_rs_response->error_code = -1;
-
-fin:
-	qstate->process_func = on_mp_read_session_response_write1;
-	qstate->kevent_watermark = sizeof(int);
-	qstate->kevent_filter = EVFILT_WRITE;
-
-	TRACE_OUT(on_mp_read_session_request_process);
-	return (0);
-}
-
-static int
-on_mp_read_session_response_write1(struct query_state *qstate)
-{
-	struct cache_mp_read_session_response	*c_mp_rs_response;
-	ssize_t	result;
-
-	TRACE_IN(on_mp_read_session_response_write1);
-	c_mp_rs_response = get_cache_mp_read_session_response(
-		&qstate->response);
-	result = qstate->write_func(qstate, &c_mp_rs_response->error_code,
-		sizeof(int));
-
-	if (result != sizeof(int)) {
-		LOG_ERR_3("on_mp_read_session_response_write1",
-			"write failed");
-		TRACE_OUT(on_mp_read_session_response_write1);
-		return (-1);
-	}
-
-	if (c_mp_rs_response->error_code == 0) {
-		qstate->kevent_watermark = sizeof(int);
-		qstate->process_func = on_mp_read_session_mapper;
-		qstate->kevent_filter = EVFILT_READ;
-	} else {
-		qstate->kevent_watermark = 0;
-		qstate->process_func = NULL;
-	}
-	TRACE_OUT(on_mp_read_session_response_write1);
-	return (0);
-}
-
-/*
- * Mapper function is used to avoid multiple connections for each session
- * write or read requests. After processing the request, it does not close
- * the connection, but waits for the next request.
- */
-static int
-on_mp_read_session_mapper(struct query_state *qstate)
-{
-	ssize_t	result;
-	int elem_type;
-
-	TRACE_IN(on_mp_read_session_mapper);
-	if (qstate->kevent_watermark == 0) {
-		qstate->kevent_watermark = sizeof(int);
-	} else {
-		result = qstate->read_func(qstate, &elem_type, sizeof(int));
-		if (result != sizeof(int)) {
-			LOG_ERR_3("on_mp_read_session_mapper",
-				"read failed");
-			TRACE_OUT(on_mp_read_session_mapper);
-			return (-1);
-		}
-
-		switch (elem_type) {
-		case CET_MP_READ_SESSION_READ_REQUEST:
-			qstate->kevent_watermark = 0;
-			qstate->process_func =
-				on_mp_read_session_read_request_process;
-			break;
-		case CET_MP_READ_SESSION_CLOSE_NOTIFICATION:
-			qstate->kevent_watermark = 0;
-			qstate->process_func =
-				on_mp_read_session_close_notification;
-			break;
-		default:
-			qstate->kevent_watermark = 0;
-			qstate->process_func = NULL;
-			LOG_ERR_3("on_mp_read_session_mapper",
-				"unknown element type");
-			TRACE_OUT(on_mp_read_session_mapper);
-			return (-1);
-		}
-	}
-	TRACE_OUT(on_mp_read_session_mapper);
-	return (0);
-}
-
-/*
- * The functions below are used to process multipart read sessions read
- * requests. User doesn't have to pass any kind of data, besides the
- * request identificator itself. So we don't need any XXX_read functions and
- * start with the XXX_process function.
- * - on_mp_read_session_read_request_process processes it
- * - on_mp_read_session_read_response_write1 and
- *   on_mp_read_session_read_response_write2 sends the response
- */
-static int
-on_mp_read_session_read_request_process(struct query_state *qstate)
-{
-	struct cache_mp_read_session_read_response	*read_response;
-
-	TRACE_IN(on_mp_read_session_response_process);
-	init_comm_element(&qstate->response, CET_MP_READ_SESSION_READ_RESPONSE);
-	read_response = get_cache_mp_read_session_read_response(
-		&qstate->response);
-
-	configuration_lock_entry(qstate->config_entry, CELT_MULTIPART);
-	read_response->error_code = cache_mp_read(
-		(cache_mp_read_session)qstate->mdata, NULL,
-		&read_response->data_size);
-
-	if (read_response->error_code == 0) {
-		read_response->data = (char *)malloc(read_response->data_size);
-		assert(read_response != NULL);
-		read_response->error_code = cache_mp_read(
-			(cache_mp_read_session)qstate->mdata,
-	    		read_response->data,
-			&read_response->data_size);
-	}
-	configuration_unlock_entry(qstate->config_entry, CELT_MULTIPART);
-
-	if (read_response->error_code == 0)
-		qstate->kevent_watermark = sizeof(size_t) + sizeof(int);
-	else
-		qstate->kevent_watermark = sizeof(int);
-	qstate->process_func = on_mp_read_session_read_response_write1;
-	qstate->kevent_filter = EVFILT_WRITE;
-
-	TRACE_OUT(on_mp_read_session_response_process);
-	return (0);
-}
-
-static int
-on_mp_read_session_read_response_write1(struct query_state *qstate)
-{
-	struct cache_mp_read_session_read_response	*read_response;
-	ssize_t	result;
-
-	TRACE_IN(on_mp_read_session_read_response_write1);
-	read_response = get_cache_mp_read_session_read_response(
-		&qstate->response);
-
-	result = qstate->write_func(qstate, &read_response->error_code,
-		sizeof(int));
-	if (read_response->error_code == 0) {
-		result += qstate->write_func(qstate, &read_response->data_size,
-			sizeof(size_t));
-		if (result != qstate->kevent_watermark) {
-			TRACE_OUT(on_mp_read_session_read_response_write1);
-			LOG_ERR_3("on_mp_read_session_read_response_write1",
-				"write failed");
-			return (-1);
-		}
-
-		qstate->kevent_watermark = read_response->data_size;
-		qstate->process_func = on_mp_read_session_read_response_write2;
-	} else {
-		if (result != qstate->kevent_watermark) {
-			LOG_ERR_3("on_mp_read_session_read_response_write1",
-				"write failed");
-			TRACE_OUT(on_mp_read_session_read_response_write1);
-			return (-1);
-		}
-
-		qstate->kevent_watermark = 0;
-		qstate->process_func = NULL;
-	}
-
-	TRACE_OUT(on_mp_read_session_read_response_write1);
-	return (0);
-}
-
-static int
-on_mp_read_session_read_response_write2(struct query_state *qstate)
-{
-	struct cache_mp_read_session_read_response *read_response;
-	ssize_t	result;
-
-	TRACE_IN(on_mp_read_session_read_response_write2);
-	read_response = get_cache_mp_read_session_read_response(
-		&qstate->response);
-	result = qstate->write_func(qstate, read_response->data,
-		read_response->data_size);
-	if (result != qstate->kevent_watermark) {
-		LOG_ERR_3("on_mp_read_session_read_response_write2",
-			"write failed");
-		TRACE_OUT(on_mp_read_session_read_response_write2);
-		return (-1);
-	}
-
-	finalize_comm_element(&qstate->request);
-	finalize_comm_element(&qstate->response);
-
-	qstate->kevent_watermark = sizeof(int);
-	qstate->process_func = on_mp_read_session_mapper;
-	qstate->kevent_filter = EVFILT_READ;
-
-	TRACE_OUT(on_mp_read_session_read_response_write2);
-	return (0);
-}
-
-/*
- * Handles session close notification by calling close_cache_mp_read_session
- * function.
- */
-static int
-on_mp_read_session_close_notification(struct query_state *qstate)
-{
-
-	TRACE_IN(on_mp_read_session_close_notification);
-	configuration_lock_entry(qstate->config_entry, CELT_MULTIPART);
-	close_cache_mp_read_session((cache_mp_read_session)qstate->mdata);
-	configuration_unlock_entry(qstate->config_entry, CELT_MULTIPART);
-	qstate->mdata = NULL;
-	qstate->kevent_watermark = 0;
-	qstate->process_func = NULL;
-	TRACE_OUT(on_mp_read_session_close_notification);
-	return (0);
-}
diff --git a/usr.sbin/cached/mp_rs_query.h b/usr.sbin/cached/mp_rs_query.h
deleted file mode 100644
index f468afa..0000000
--- a/usr.sbin/cached/mp_rs_query.h
+++ /dev/null
@@ -1,34 +0,0 @@
-/*-
- * Copyright (c) 2005 Michael Bushkov <bushman@rsu.ru>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * $FreeBSD$
- */
-
-#ifndef __CACHED_MP_RS_QUERY_H__
-#define __CACHED_MP_RS_QUERY_H__
-
-extern int on_mp_read_session_request_read1(struct query_state *);
-
-#endif
diff --git a/usr.sbin/cached/mp_ws_query.c b/usr.sbin/cached/mp_ws_query.c
deleted file mode 100644
index d7aeb49..0000000
--- a/usr.sbin/cached/mp_ws_query.c
+++ /dev/null
@@ -1,548 +0,0 @@
-/*-
- * Copyright (c) 2005 Michael Bushkov <bushman@rsu.ru>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- */
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-
-#include <sys/socket.h>
-#include <sys/time.h>
-#include <sys/types.h>
-#include <sys/event.h>
-#include <assert.h>
-#include <errno.h>
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-
-#include "cachelib.h"
-#include "config.h"
-#include "debug.h"
-#include "log.h"
-#include "query.h"
-#include "mp_ws_query.h"
-#include "singletons.h"
-
-static int on_mp_write_session_abandon_notification(struct query_state *);
-static int on_mp_write_session_close_notification(struct query_state *);
-static void on_mp_write_session_destroy(struct query_state *);
-static int on_mp_write_session_mapper(struct query_state *);
-/* int on_mp_write_session_request_read1(struct query_state *); */
-static int on_mp_write_session_request_read2(struct query_state *);
-static int on_mp_write_session_request_process(struct query_state *);
-static int on_mp_write_session_response_write1(struct query_state *);
-static int on_mp_write_session_write_request_read1(struct query_state *);
-static int on_mp_write_session_write_request_read2(struct query_state *);
-static int on_mp_write_session_write_request_process(struct query_state *);
-static int on_mp_write_session_write_response_write1(struct query_state *);
-
-/*
- * This function is used as the query_state's destroy_func to make the
- * proper cleanup in case of errors.
- */
-static void
-on_mp_write_session_destroy(struct query_state *qstate)
-{
-
-	TRACE_IN(on_mp_write_session_destroy);
-	finalize_comm_element(&qstate->request);
-	finalize_comm_element(&qstate->response);
-
-	if (qstate->mdata != NULL) {
-		configuration_lock_entry(qstate->config_entry, CELT_MULTIPART);
-		abandon_cache_mp_write_session(
-	    		(cache_mp_write_session)qstate->mdata);
-		configuration_unlock_entry(qstate->config_entry,
-			CELT_MULTIPART);
-	}
-	TRACE_OUT(on_mp_write_session_destroy);
-}
-
-/*
- * The functions below are used to process multipart write session initiation
- * requests.
- * - on_mp_write_session_request_read1 and on_mp_write_session_request_read2
- *   read the request itself
- * - on_mp_write_session_request_process processes it
- * - on_mp_write_session_response_write1 sends the response
- */
-int
-on_mp_write_session_request_read1(struct query_state *qstate)
-{
-	struct cache_mp_write_session_request	*c_mp_ws_request;
-	ssize_t	result;
-
-	TRACE_IN(on_mp_write_session_request_read1);
-	if (qstate->kevent_watermark == 0)
-		qstate->kevent_watermark = sizeof(size_t);
-	else {
-		init_comm_element(&qstate->request,
-	    		CET_MP_WRITE_SESSION_REQUEST);
-		c_mp_ws_request = get_cache_mp_write_session_request(
-	    		&qstate->request);
-
-		result = qstate->read_func(qstate,
-	    		&c_mp_ws_request->entry_length, sizeof(size_t));
-
-		if (result != sizeof(size_t)) {
-			LOG_ERR_3("on_mp_write_session_request_read1",
-				"read failed");
-			TRACE_OUT(on_mp_write_session_request_read1);
-			return (-1);
-		}
-
-		if (BUFSIZE_INVALID(c_mp_ws_request->entry_length)) {
-			LOG_ERR_3("on_mp_write_session_request_read1",
-				"invalid entry_length value");
-			TRACE_OUT(on_mp_write_session_request_read1);
-			return (-1);
-		}
-
-		c_mp_ws_request->entry = (char *)malloc(
-			c_mp_ws_request->entry_length + 1);
-		assert(c_mp_ws_request->entry != NULL);
-		memset(c_mp_ws_request->entry, 0,
-			c_mp_ws_request->entry_length + 1);
-
-		qstate->kevent_watermark = c_mp_ws_request->entry_length;
-		qstate->process_func = on_mp_write_session_request_read2;
-	}
-	TRACE_OUT(on_mp_write_session_request_read1);
-	return (0);
-}
-
-static int
-on_mp_write_session_request_read2(struct query_state *qstate)
-{
-	struct cache_mp_write_session_request	*c_mp_ws_request;
-	ssize_t	result;
-
-	TRACE_IN(on_mp_write_session_request_read2);
-	c_mp_ws_request = get_cache_mp_write_session_request(&qstate->request);
-
-	result = qstate->read_func(qstate, c_mp_ws_request->entry,
-		c_mp_ws_request->entry_length);
-
-	if (result != qstate->kevent_watermark) {
-		LOG_ERR_3("on_mp_write_session_request_read2",
-			"read failed");
-		TRACE_OUT(on_mp_write_session_request_read2);
-		return (-1);
-	}
-
-	qstate->kevent_watermark = 0;
-	qstate->process_func = on_mp_write_session_request_process;
-
-	TRACE_OUT(on_mp_write_session_request_read2);
-	return (0);
-}
-
-static int
-on_mp_write_session_request_process(struct query_state *qstate)
-{
-	struct cache_mp_write_session_request	*c_mp_ws_request;
-	struct cache_mp_write_session_response	*c_mp_ws_response;
-	cache_mp_write_session	ws;
-	cache_entry	c_entry;
-	char	*dec_cache_entry_name;
-
-	TRACE_IN(on_mp_write_session_request_process);
-	init_comm_element(&qstate->response, CET_MP_WRITE_SESSION_RESPONSE);
-	c_mp_ws_response = get_cache_mp_write_session_response(
-		&qstate->response);
-	c_mp_ws_request = get_cache_mp_write_session_request(&qstate->request);
-
-	qstate->config_entry = configuration_find_entry(
-		s_configuration, c_mp_ws_request->entry);
-	if (qstate->config_entry == NULL) {
-		c_mp_ws_response->error_code = ENOENT;
-
-		LOG_ERR_2("write_session_request",
-			"can't find configuration entry '%s'. "
-	    		"aborting request", c_mp_ws_request->entry);
-	    	goto fin;
-	}
-
-	if (qstate->config_entry->enabled == 0) {
-		c_mp_ws_response->error_code = EACCES;
-
-		LOG_ERR_2("write_session_request",
-			"configuration entry '%s' is disabled",
-			c_mp_ws_request->entry);
-		goto fin;
-	}
-
-	if (qstate->config_entry->perform_actual_lookups != 0) {
-		c_mp_ws_response->error_code = EOPNOTSUPP;
-
-		LOG_ERR_2("write_session_request",
-			"entry '%s' performs lookups by itself: "
-			"can't write to it", c_mp_ws_request->entry);
-		goto fin;
-	} else {
-#ifdef NS_CACHED_EID_CHECKING
-		if (check_query_eids(qstate) != 0) {
-			c_mp_ws_response->error_code = EPERM;
-			goto fin;
-		}
-#endif
-	}
-
-	/*
-	 * All multipart entries are separated by their name decorations.
-	 * For one configuration entry there will be a lot of multipart
-	 * cache entries - each with its own decorated name.
-	 */
-	asprintf(&dec_cache_entry_name, "%s%s", qstate->eid_str,
-		qstate->config_entry->mp_cache_params.entry_name);
-	assert(dec_cache_entry_name != NULL);
-
-	configuration_lock_rdlock(s_configuration);
-	c_entry = find_cache_entry(s_cache,
-		dec_cache_entry_name);
-	configuration_unlock(s_configuration);
-
-	if (c_entry == INVALID_CACHE_ENTRY)
-		c_entry = register_new_mp_cache_entry(qstate,
-			dec_cache_entry_name);
-
-	free(dec_cache_entry_name);
-
-	assert(c_entry != NULL);
-	configuration_lock_entry(qstate->config_entry, CELT_MULTIPART);
-	ws = open_cache_mp_write_session(c_entry);
-	if (ws == INVALID_CACHE_MP_WRITE_SESSION)
-		c_mp_ws_response->error_code = -1;
-	else {
-		qstate->mdata = ws;
-		qstate->destroy_func = on_mp_write_session_destroy;
-
-		if ((qstate->config_entry->mp_query_timeout.tv_sec != 0) ||
-		    (qstate->config_entry->mp_query_timeout.tv_usec != 0))
-			memcpy(&qstate->timeout,
-				&qstate->config_entry->mp_query_timeout,
-				sizeof(struct timeval));
-	}
-	configuration_unlock_entry(qstate->config_entry, CELT_MULTIPART);
-
-fin:
-	qstate->process_func = on_mp_write_session_response_write1;
-	qstate->kevent_watermark = sizeof(int);
-	qstate->kevent_filter = EVFILT_WRITE;
-
-	TRACE_OUT(on_mp_write_session_request_process);
-	return (0);
-}
-
-static int
-on_mp_write_session_response_write1(struct query_state *qstate)
-{
-	struct cache_mp_write_session_response	*c_mp_ws_response;
-	ssize_t	result;
-
-	TRACE_IN(on_mp_write_session_response_write1);
-	c_mp_ws_response = get_cache_mp_write_session_response(
-		&qstate->response);
-	result = qstate->write_func(qstate, &c_mp_ws_response->error_code,
-		sizeof(int));
-	if (result != sizeof(int)) {
-		LOG_ERR_3("on_mp_write_session_response_write1",
-			"write failed");
-		TRACE_OUT(on_mp_write_session_response_write1);
-		return (-1);
-	}
-
-	if (c_mp_ws_response->error_code == 0) {
-		qstate->kevent_watermark = sizeof(int);
-		qstate->process_func = on_mp_write_session_mapper;
-		qstate->kevent_filter = EVFILT_READ;
-	} else {
-		qstate->kevent_watermark = 0;
-		qstate->process_func = NULL;
-	}
-	TRACE_OUT(on_mp_write_session_response_write1);
-	return (0);
-}
-
-/*
- * Mapper function is used to avoid multiple connections for each session
- * write or read requests. After processing the request, it does not close
- * the connection, but waits for the next request.
- */
-static int
-on_mp_write_session_mapper(struct query_state *qstate)
-{
-	ssize_t	result;
-	int		elem_type;
-
-	TRACE_IN(on_mp_write_session_mapper);
-	if (qstate->kevent_watermark == 0) {
-		qstate->kevent_watermark = sizeof(int);
-	} else {
-		result = qstate->read_func(qstate, &elem_type, sizeof(int));
-		if (result != sizeof(int)) {
-			LOG_ERR_3("on_mp_write_session_mapper",
-				"read failed");
-			TRACE_OUT(on_mp_write_session_mapper);
-			return (-1);
-		}
-
-		switch (elem_type) {
-		case CET_MP_WRITE_SESSION_WRITE_REQUEST:
-			qstate->kevent_watermark = sizeof(size_t);
-			qstate->process_func =
-				on_mp_write_session_write_request_read1;
-			break;
-		case CET_MP_WRITE_SESSION_ABANDON_NOTIFICATION:
-			qstate->kevent_watermark = 0;
-			qstate->process_func =
-				on_mp_write_session_abandon_notification;
-			break;
-		case CET_MP_WRITE_SESSION_CLOSE_NOTIFICATION:
-			qstate->kevent_watermark = 0;
-			qstate->process_func =
-				on_mp_write_session_close_notification;
-			break;
-		default:
-			qstate->kevent_watermark = 0;
-			qstate->process_func = NULL;
-			LOG_ERR_2("on_mp_write_session_mapper",
-				"unknown element type");
-			TRACE_OUT(on_mp_write_session_mapper);
-			return (-1);
-		}
-	}
-	TRACE_OUT(on_mp_write_session_mapper);
-	return (0);
-}
-
-/*
- * The functions below are used to process multipart write sessions write
- * requests.
- * - on_mp_write_session_write_request_read1 and
- *   on_mp_write_session_write_request_read2 read the request itself
- * - on_mp_write_session_write_request_process processes it
- * - on_mp_write_session_write_response_write1 sends the response
- */
-static int
-on_mp_write_session_write_request_read1(struct query_state *qstate)
-{
-	struct cache_mp_write_session_write_request	*write_request;
-	ssize_t	result;
-
-	TRACE_IN(on_mp_write_session_write_request_read1);
-	init_comm_element(&qstate->request,
-		CET_MP_WRITE_SESSION_WRITE_REQUEST);
-	write_request = get_cache_mp_write_session_write_request(
-		&qstate->request);
-
-	result = qstate->read_func(qstate, &write_request->data_size,
-		sizeof(size_t));
-
-	if (result != sizeof(size_t)) {
-		LOG_ERR_3("on_mp_write_session_write_request_read1",
-			"read failed");
-		TRACE_OUT(on_mp_write_session_write_request_read1);
-		return (-1);
-	}
-
-	if (BUFSIZE_INVALID(write_request->data_size)) {
-		LOG_ERR_3("on_mp_write_session_write_request_read1",
-			"invalid data_size value");
-		TRACE_OUT(on_mp_write_session_write_request_read1);
-		return (-1);
-	}
-
-	write_request->data = (char *)malloc(write_request->data_size);
-	assert(write_request->data != NULL);
-	memset(write_request->data, 0, write_request->data_size);
-
-	qstate->kevent_watermark = write_request->data_size;
-	qstate->process_func = on_mp_write_session_write_request_read2;
-	TRACE_OUT(on_mp_write_session_write_request_read1);
-	return (0);
-}
-
-static int
-on_mp_write_session_write_request_read2(struct query_state *qstate)
-{
-	struct cache_mp_write_session_write_request	*write_request;
-	ssize_t	result;
-
-	TRACE_IN(on_mp_write_session_write_request_read2);
-	write_request = get_cache_mp_write_session_write_request(
-		&qstate->request);
-
-	result = qstate->read_func(qstate, write_request->data,
-		write_request->data_size);
-
-	if (result != qstate->kevent_watermark) {
-		LOG_ERR_3("on_mp_write_session_write_request_read2",
-			"read failed");
-		TRACE_OUT(on_mp_write_session_write_request_read2);
-		return (-1);
-	}
-
-	qstate->kevent_watermark = 0;
-	qstate->process_func = on_mp_write_session_write_request_process;
-	TRACE_OUT(on_mp_write_session_write_request_read2);
-	return (0);
-}
-
-static int
-on_mp_write_session_write_request_process(struct query_state *qstate)
-{
-	struct cache_mp_write_session_write_request	*write_request;
-	struct cache_mp_write_session_write_response	*write_response;
-
-	TRACE_IN(on_mp_write_session_write_request_process);
-	init_comm_element(&qstate->response,
-		CET_MP_WRITE_SESSION_WRITE_RESPONSE);
-	write_response = get_cache_mp_write_session_write_response(
-		&qstate->response);
-	write_request = get_cache_mp_write_session_write_request(
-		&qstate->request);
-
-	configuration_lock_entry(qstate->config_entry, CELT_MULTIPART);
-	write_response->error_code = cache_mp_write(
-		(cache_mp_write_session)qstate->mdata,
-		write_request->data,
-		write_request->data_size);
-	configuration_unlock_entry(qstate->config_entry, CELT_MULTIPART);
-
-	qstate->kevent_watermark = sizeof(int);
-	qstate->process_func = on_mp_write_session_write_response_write1;
-	qstate->kevent_filter = EVFILT_WRITE;
-
-	TRACE_OUT(on_mp_write_session_write_request_process);
-	return (0);
-}
-
-static int
-on_mp_write_session_write_response_write1(struct query_state *qstate)
-{
-	struct cache_mp_write_session_write_response	*write_response;
-	ssize_t	result;
-
-	TRACE_IN(on_mp_write_session_write_response_write1);
-	write_response = get_cache_mp_write_session_write_response(
-		&qstate->response);
-	result = qstate->write_func(qstate, &write_response->error_code,
-		sizeof(int));
-	if (result != sizeof(int)) {
-		LOG_ERR_3("on_mp_write_session_write_response_write1",
-			"write failed");
-		TRACE_OUT(on_mp_write_session_write_response_write1);
-		return (-1);
-	}
-
-	if (write_response->error_code == 0) {
-		finalize_comm_element(&qstate->request);
-		finalize_comm_element(&qstate->response);
-
-		qstate->kevent_watermark = sizeof(int);
-		qstate->process_func = on_mp_write_session_mapper;
-		qstate->kevent_filter = EVFILT_READ;
-	} else {
-		qstate->kevent_watermark = 0;
-		qstate->process_func = 0;
-	}
-
-	TRACE_OUT(on_mp_write_session_write_response_write1);
-	return (0);
-}
-
-/*
- * Handles abandon notifications. Destroys the session by calling the
- * abandon_cache_mp_write_session.
- */
-static int
-on_mp_write_session_abandon_notification(struct query_state *qstate)
-{
-	TRACE_IN(on_mp_write_session_abandon_notification);
-	configuration_lock_entry(qstate->config_entry, CELT_MULTIPART);
-	abandon_cache_mp_write_session((cache_mp_write_session)qstate->mdata);
-	configuration_unlock_entry(qstate->config_entry, CELT_MULTIPART);
-	qstate->mdata = INVALID_CACHE_MP_WRITE_SESSION;
-
-	qstate->kevent_watermark = 0;
-	qstate->process_func = NULL;
-	TRACE_OUT(on_mp_write_session_abandon_notification);
-	return (0);
-}
-
-/*
- * Handles close notifications. Commits the session by calling
- * the close_cache_mp_write_session.
- */
-static int
-on_mp_write_session_close_notification(struct query_state *qstate)
-{
-	TRACE_IN(on_mp_write_session_close_notification);
-	configuration_lock_entry(qstate->config_entry, CELT_MULTIPART);
-	close_cache_mp_write_session((cache_mp_write_session)qstate->mdata);
-	configuration_unlock_entry(qstate->config_entry, CELT_MULTIPART);
-	qstate->mdata = INVALID_CACHE_MP_WRITE_SESSION;
-
-	qstate->kevent_watermark = 0;
-	qstate->process_func = NULL;
-	TRACE_OUT(on_mp_write_session_close_notification);
-	return (0);
-}
-
-cache_entry register_new_mp_cache_entry(struct query_state *qstate,
-	const char *dec_cache_entry_name)
-{
-	cache_entry c_entry;
-	char *en_bkp;
-
-	TRACE_IN(register_new_mp_cache_entry);
-	c_entry = INVALID_CACHE_ENTRY;
-	configuration_lock_entry(qstate->config_entry, CELT_MULTIPART);
-
-	configuration_lock_wrlock(s_configuration);
-	en_bkp = qstate->config_entry->mp_cache_params.entry_name;
-	qstate->config_entry->mp_cache_params.entry_name =
-		(char *)dec_cache_entry_name;
-	register_cache_entry(s_cache, (struct cache_entry_params *)
-		&qstate->config_entry->mp_cache_params);
-	qstate->config_entry->mp_cache_params.entry_name = en_bkp;
-	configuration_unlock(s_configuration);
-
-	configuration_lock_rdlock(s_configuration);
-	c_entry = find_cache_entry(s_cache,
-		dec_cache_entry_name);
-	configuration_unlock(s_configuration);
-
-	configuration_entry_add_mp_cache_entry(qstate->config_entry,
-		c_entry);
-
-	configuration_unlock_entry(qstate->config_entry,
-		CELT_MULTIPART);
-
-	TRACE_OUT(register_new_mp_cache_entry);
-	return (c_entry);
-}
diff --git a/usr.sbin/cached/mp_ws_query.h b/usr.sbin/cached/mp_ws_query.h
deleted file mode 100644
index ba77665..0000000
--- a/usr.sbin/cached/mp_ws_query.h
+++ /dev/null
@@ -1,36 +0,0 @@
-/*-
- * Copyright (c) 2005 Michael Bushkov <bushman@rsu.ru>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * $FreeBSD$
- */
-
-#ifndef __CACHED_MP_WS_QUERY_H__
-#define __CACHED_MP_WS_QUERY_H__
-
-extern int on_mp_write_session_request_read1(struct query_state *);
-extern cache_entry register_new_mp_cache_entry(struct query_state *,
-	const char *);
-
-#endif
diff --git a/usr.sbin/cached/parser.c b/usr.sbin/cached/parser.c
deleted file mode 100644
index b877efa..0000000
--- a/usr.sbin/cached/parser.c
+++ /dev/null
@@ -1,474 +0,0 @@
-/*-
- * Copyright (c) 2005 Michael Bushkov <bushman@rsu.ru>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- */
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-
-#include <assert.h>
-#include <stdio.h>
-#include <string.h>
-#include "config.h"
-#include "debug.h"
-#include "log.h"
-#include "parser.h"
-
-static void enable_cache(struct configuration *,const char *, int);
-static struct configuration_entry *find_create_entry(struct configuration *,
-	const char *);
-static int get_number(const char *, int, int);
-static enum cache_policy_t get_policy(const char *);
-static int get_yesno(const char *);
-static int check_cachename(const char *);
-static void check_files(struct configuration *, const char *, int);
-static void set_keep_hot_count(struct configuration *, const char *, int);
-static void set_negative_policy(struct configuration *, const char *,
-	enum cache_policy_t);
-static void set_negative_time_to_live(struct configuration *,
-	const char *, int);
-static void set_positive_policy(struct configuration *, const char *,
-	enum cache_policy_t);
-static void set_perform_actual_lookups(struct configuration *, const char *,
-	int);
-static void set_positive_time_to_live(struct configuration *,
-	const char *, int);
-static void set_suggested_size(struct configuration *, const char *,
-	int size);
-static void set_threads_num(struct configuration *, int);
-static int strbreak(char *, char **, int);
-
-static int
-strbreak(char *str, char **fields, int fields_size)
-{
-	char	*c = str;
-	int	i, num;
-
-	TRACE_IN(strbreak);
-	num = 0;
-	for (i = 0;
-	     ((*fields =
-	     	strsep(i < fields_size ? &c : NULL, "\n\t ")) != NULL);
-	     ++i)
-		if ((*(*fields)) != '\0') {
-			++fields;
-			++num;
-		}
-
-	TRACE_OUT(strbreak);
-	return (num);
-}
-
-/*
- * Tries to find the configuration entry with the specified name. If search
- * fails, the new entry with the default parameters will be created.
- */
-static struct configuration_entry *
-find_create_entry(struct configuration *config,
-	const char *entry_name)
-{
-	struct configuration_entry *entry = NULL;
-	int res;
-
-	TRACE_IN(find_create_entry);
-	entry = configuration_find_entry(config, entry_name);
-	if (entry == NULL) {
-		entry = create_def_configuration_entry(entry_name);
-		assert( entry != NULL);
-		res = add_configuration_entry(config, entry);
-		assert(res == 0);
-	}
-
-	TRACE_OUT(find_create_entry);
-	return (entry);
-}
-
-/*
- * The vast majority of the functions below corresponds to the particular
- * keywords in the configuration file.
- */
-static void
-enable_cache(struct configuration *config, const char *entry_name, int flag)
-{
-	struct configuration_entry	*entry;
-
-	TRACE_IN(enable_cache);
-	entry = find_create_entry(config, entry_name);
-	entry->enabled = flag;
-	TRACE_OUT(enable_cache);
-}
-
-static void
-set_positive_time_to_live(struct configuration *config,
-	const char *entry_name, int ttl)
-{
-	struct configuration_entry *entry;
-	struct timeval lifetime;
-
-	TRACE_IN(set_positive_time_to_live);
-	assert(ttl >= 0);
-	assert(entry_name != NULL);
-	memset(&lifetime, 0, sizeof(struct timeval));
-	lifetime.tv_sec = ttl;
-
-	entry = find_create_entry(config, entry_name);
-	memcpy(&entry->positive_cache_params.max_lifetime,
-		&lifetime, sizeof(struct timeval));
-	memcpy(&entry->mp_cache_params.max_lifetime,
-		&lifetime, sizeof(struct timeval));
-
-	TRACE_OUT(set_positive_time_to_live);
-}
-
-static void
-set_negative_time_to_live(struct configuration *config,
-	const char *entry_name, int nttl)
-{
-	struct configuration_entry *entry;
-	struct timeval lifetime;
-
-	TRACE_IN(set_negative_time_to_live);
-	assert(nttl > 0);
-	assert(entry_name != NULL);
-	memset(&lifetime, 0, sizeof(struct timeval));
-	lifetime.tv_sec = nttl;
-
-	entry = find_create_entry(config, entry_name);
-	assert(entry != NULL);
-	memcpy(&entry->negative_cache_params.max_lifetime,
-		&lifetime, sizeof(struct timeval));
-
-	TRACE_OUT(set_negative_time_to_live);
-}
-
-/*
- * Hot count is actually the elements size limit.
- */
-static void
-set_keep_hot_count(struct configuration *config,
-	const char *entry_name, int count)
-{
-	struct configuration_entry *entry;
-
-	TRACE_IN(set_keep_hot_count);
-	assert(count >= 0);
-	assert(entry_name != NULL);
-
-	entry = find_create_entry(config, entry_name);
-	assert(entry != NULL);
-	entry->positive_cache_params.max_elemsize = count;
-
-	entry = find_create_entry(config, entry_name);
-	assert(entry != NULL);
-	entry->negative_cache_params.max_elemsize = count;
-
-	TRACE_OUT(set_keep_hot_count);
-}
-
-static void
-set_positive_policy(struct configuration *config,
-	const char *entry_name, enum cache_policy_t policy)
-{
-	struct configuration_entry *entry;
-
-	TRACE_IN(set_positive_policy);
-	assert(entry_name != NULL);
-
-	entry = find_create_entry(config, entry_name);
-	assert(entry != NULL);
-	entry->positive_cache_params.policy = policy;
-
-	TRACE_OUT(set_positive_policy);
-}
-
-static void
-set_negative_policy(struct configuration *config,
-	const char *entry_name, enum cache_policy_t policy)
-{
-	struct configuration_entry *entry;
-
-	TRACE_IN(set_negative_policy);
-	assert(entry_name != NULL);
-
-	entry = find_create_entry(config, entry_name);
-	assert(entry != NULL);
-	entry->negative_cache_params.policy = policy;
-
-	TRACE_OUT(set_negative_policy);
-}
-
-static void
-set_perform_actual_lookups(struct configuration *config,
-	const char *entry_name, int flag)
-{
-	struct configuration_entry *entry;
-
-	TRACE_IN(set_perform_actual_lookups);
-	assert(entry_name != NULL);
-
-	entry = find_create_entry(config, entry_name);
-	assert(entry != NULL);
-	entry->perform_actual_lookups = flag;
-
-	TRACE_OUT(set_perform_actual_lookups);
-}
-
-static void
-set_suggested_size(struct configuration *config,
-	const char *entry_name, int size)
-{
-	struct configuration_entry	*entry;
-
-	TRACE_IN(set_suggested_size);
-	assert(config != NULL);
-	assert(entry_name != NULL);
-	assert(size > 0);
-
-	entry = find_create_entry(config, entry_name);
-	assert(entry != NULL);
-	entry->positive_cache_params.cache_entries_size = size;
-	entry->negative_cache_params.cache_entries_size = size;
-
-	TRACE_OUT(set_suggested_size);
-}
-
-static void
-check_files(struct configuration *config, const char *entry_name, int flag)
-{
-
-	TRACE_IN(check_files);
-	assert(entry_name != NULL);
-	TRACE_OUT(check_files);
-}
-
-static int
-get_yesno(const char *str)
-{
-
-	if (strcmp(str, "yes") == 0)
-		return (1);
-	else if (strcmp(str, "no") == 0)
-		return (0);
-	else
-		return (-1);
-}
-
-static int
-get_number(const char *str, int low, int max)
-{
-
-	char *end = NULL;
-	int res = 0;
-
-	if (str[0] == '\0')
-		return (-1);
-
-	res = strtol(str, &end, 10);
-	if (*end != '\0')
-		return (-1);
-	else
-		if (((res >= low) || (low == -1)) &&
-			((res <= max) || (max == -1)))
-			return (res);
-		else
-			return (-2);
-}
-
-static enum cache_policy_t
-get_policy(const char *str)
-{
-
-	if (strcmp(str, "fifo") == 0)
-		return (CPT_FIFO);
-	else if (strcmp(str, "lru") == 0)
-		return (CPT_LRU);
-	else if (strcmp(str, "lfu") == 0)
-		return (CPT_LFU);
-
-	return (-1);
-}
-
-static int
-check_cachename(const char *str)
-{
-
-	assert(str != NULL);
-	return ((strlen(str) > 0) ? 0 : -1);
-}
-
-static void
-set_threads_num(struct configuration *config, int value)
-{
-
-	assert(config != NULL);
-	config->threads_num = value;
-}
-
-/*
- * The main configuration routine. Its implementation is hugely inspired by the
- * the same routine implementation in Solaris NSCD.
- */
-int
-parse_config_file(struct configuration *config,
-	const char *fname, char const **error_str, int *error_line)
-{
-	FILE	*fin;
-	char	buffer[255];
-	char	*fields[128];
-	int	field_count, line_num, value;
-	int	res;
-
-	TRACE_IN(parse_config_file);
-	assert(config != NULL);
-	assert(fname != NULL);
-
-	fin = fopen(fname, "r");
-	if (fin == NULL) {
-		TRACE_OUT(parse_config_file);
-		return (-1);
-	}
-
-	res = 0;
-	line_num = 0;
-	memset(buffer, 0, sizeof(buffer));
-	while ((res == 0) && (fgets(buffer, sizeof(buffer) - 1, fin) != NULL)) {
-		field_count = strbreak(buffer, fields, sizeof(fields));
-		++line_num;
-
-		if (field_count == 0)
-			continue;
-
-		switch (fields[0][0]) {
-		case '#':
-		case '\0':
-			continue;
-		case 'e':
-			if ((field_count == 3) &&
-			(strcmp(fields[0], "enable-cache") == 0) &&
-			(check_cachename(fields[1]) == 0) &&
-			((value = get_yesno(fields[2])) != -1)) {
-				enable_cache(config, fields[1], value);
-				continue;
-			}
-			break;
-		case 'd':
-			if ((field_count == 2) &&
-			(strcmp(fields[0], "debug-level") == 0) &&
-			((value = get_number(fields[1], 0, 10)) != -1)) {
-				continue;
-			}
-			break;
-		case 'p':
-			if ((field_count == 3) &&
-			(strcmp(fields[0], "positive-time-to-live") == 0) &&
-			(check_cachename(fields[1]) == 0) &&
-			((value = get_number(fields[2], 0, -1)) != -1)) {
-				set_positive_time_to_live(config,
-					fields[1], value);
-				continue;
-			} else if ((field_count == 3) &&
-			(strcmp(fields[0], "positive-policy") == 0) &&
-			(check_cachename(fields[1]) == 0) &&
-			((value = get_policy(fields[2])) != -1)) {
-				set_positive_policy(config, fields[1], value);
-				continue;
-			} else if ((field_count == 3) &&
-			(strcmp(fields[0], "perform-actual-lookups") == 0) &&
-			(check_cachename(fields[1]) == 0) &&
-			((value = get_yesno(fields[2])) != -1)) {
-				set_perform_actual_lookups(config, fields[1],
-					value);
-				continue;
-			}
-			break;
-		case 'n':
-			if ((field_count == 3) &&
-			(strcmp(fields[0], "negative-time-to-live") == 0) &&
-			(check_cachename(fields[1]) == 0) &&
-			((value = get_number(fields[2], 0, -1)) != -1)) {
-				set_negative_time_to_live(config,
-					fields[1], value);
-				continue;
-			} else if ((field_count == 3) &&
-			(strcmp(fields[0], "negative-policy") == 0) &&
-			(check_cachename(fields[1]) == 0) &&
-			((value = get_policy(fields[2])) != -1)) {
-				set_negative_policy(config,
-					fields[1], value);
-				continue;
-			}
-			break;
-		case 's':
-			if ((field_count == 3) &&
-			(strcmp(fields[0], "suggested-size") == 0) &&
-			(check_cachename(fields[1]) == 0) &&
-			((value = get_number(fields[2], 1, -1)) != -1)) {
-				set_suggested_size(config, fields[1], value);
-				continue;
-			}
-			break;
-		case 't':
-			if ((field_count == 2) &&
-			(strcmp(fields[0], "threads") == 0) &&
-			((value = get_number(fields[1], 1, -1)) != -1)) {
-				set_threads_num(config, value);
-				continue;
-			}
-			break;
-		case 'k':
-			if ((field_count == 3) &&
-			(strcmp(fields[0], "keep-hot-count") == 0) &&
-			(check_cachename(fields[1]) == 0) &&
-			((value = get_number(fields[2], 0, -1)) != -1)) {
-				set_keep_hot_count(config,
-					fields[1], value);
-				continue;
-			}
-			break;
-		case 'c':
-			if ((field_count == 3) &&
-			(strcmp(fields[0], "check-files") == 0) &&
-			(check_cachename(fields[1]) == 0) &&
-			((value = get_yesno(fields[2])) != -1)) {
-				check_files(config,
-					fields[1], value);
-				continue;
-			}
-			break;
-		default:
-			break;
-		}
-
-		LOG_ERR_2("config file parser", "error in file "
-			"%s on line %d", fname, line_num);
-		*error_str = "syntax error";
-		*error_line = line_num;
-		res = -1;
-	}
-	fclose(fin);
-
-	TRACE_OUT(parse_config_file);
-	return (res);
-}
diff --git a/usr.sbin/cached/parser.h b/usr.sbin/cached/parser.h
deleted file mode 100644
index 54cc898..0000000
--- a/usr.sbin/cached/parser.h
+++ /dev/null
@@ -1,35 +0,0 @@
-/*-
- * Copyright (c) 2005 Michael Bushkov <bushman@rsu.ru>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * $FreeBSD$
- */
-
-#ifndef __CACHED_PARSER_H__
-#define __CACHED_PARSER_H__
-
-extern int parse_config_file(struct configuration *,
-	const char *, char const **, int *);
-
-#endif
diff --git a/usr.sbin/cached/protocol.c b/usr.sbin/cached/protocol.c
deleted file mode 100644
index 08cea92..0000000
--- a/usr.sbin/cached/protocol.c
+++ /dev/null
@@ -1,550 +0,0 @@
-/*-
- * Copyright (c) 2005 Michael Bushkov <bushman@rsu.ru>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- */
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-
-#include <assert.h>
-#include <stdlib.h>
-#include <string.h>
-#include "debug.h"
-#include "log.h"
-#include "protocol.h"
-
-/*
- * Initializes the comm_element with any given type of data
- */
-void
-init_comm_element(struct comm_element *element, enum comm_element_t type)
-{
-
-	TRACE_IN(init_comm_element);
-	memset(element, 0, sizeof(struct comm_element));
-
-	switch (type) {
-	case CET_WRITE_REQUEST:
-		init_cache_write_request(&element->c_write_request);
-		break;
-	case CET_WRITE_RESPONSE:
-		init_cache_write_response(&element->c_write_response);
-		break;
-	case CET_READ_REQUEST:
-		init_cache_read_request(&element->c_read_request);
-		break;
-	case CET_READ_RESPONSE:
-		init_cache_read_response(&element->c_read_response);
-		break;
-	case CET_TRANSFORM_REQUEST:
-		init_cache_transform_request(&element->c_transform_request);
-		break;
-	case CET_TRANSFORM_RESPONSE:
-		init_cache_transform_response(&element->c_transform_response);
-		break;
-	case CET_MP_WRITE_SESSION_REQUEST:
-		init_cache_mp_write_session_request(&element->c_mp_ws_request);
-		break;
-	case CET_MP_WRITE_SESSION_RESPONSE:
-		init_cache_mp_write_session_response(&element->c_mp_ws_response);
-		break;
-	case CET_MP_WRITE_SESSION_WRITE_REQUEST:
-		init_cache_mp_write_session_write_request(
-			&element->c_mp_ws_write_request);
-		break;
-	case CET_MP_WRITE_SESSION_WRITE_RESPONSE:
-		init_cache_mp_write_session_write_response(
-			&element->c_mp_ws_write_response);
-		break;
-	case CET_MP_READ_SESSION_REQUEST:
-		init_cache_mp_read_session_request(&element->c_mp_rs_request);
-		break;
-	case CET_MP_READ_SESSION_RESPONSE:
-		init_cache_mp_read_session_response(&element->c_mp_rs_response);
-		break;
-	case CET_MP_READ_SESSION_READ_RESPONSE:
-		init_cache_mp_read_session_read_response(
-			&element->c_mp_rs_read_response);
-		break;
-	case CET_UNDEFINED:
-		break;
-	default:
-		LOG_ERR_2("init_comm_element", "invalid communication element");
-		TRACE_OUT(init_comm_element);
-	return;
-	}
-
-	element->type = type;
-	TRACE_OUT(init_comm_element);
-}
-
-void
-finalize_comm_element(struct comm_element *element)
-{
-
-	TRACE_IN(finalize_comm_element);
-	switch (element->type) {
-	case CET_WRITE_REQUEST:
-		finalize_cache_write_request(&element->c_write_request);
-		break;
-	case CET_WRITE_RESPONSE:
-		finalize_cache_write_response(&element->c_write_response);
-		break;
-	case CET_READ_REQUEST:
-		finalize_cache_read_request(&element->c_read_request);
-		break;
-	case CET_READ_RESPONSE:
-		finalize_cache_read_response(&element->c_read_response);
-		break;
-	case CET_TRANSFORM_REQUEST:
-		finalize_cache_transform_request(&element->c_transform_request);
-		break;
-	case CET_TRANSFORM_RESPONSE:
-		finalize_cache_transform_response(
-			&element->c_transform_response);
-		break;
-	case CET_MP_WRITE_SESSION_REQUEST:
-		finalize_cache_mp_write_session_request(
-			&element->c_mp_ws_request);
-		break;
-	case CET_MP_WRITE_SESSION_RESPONSE:
-		finalize_cache_mp_write_session_response(
-			&element->c_mp_ws_response);
-		break;
-	case CET_MP_WRITE_SESSION_WRITE_REQUEST:
-		finalize_cache_mp_write_session_write_request(
-			&element->c_mp_ws_write_request);
-		break;
-	case CET_MP_WRITE_SESSION_WRITE_RESPONSE:
-		finalize_cache_mp_write_session_write_response(
-			&element->c_mp_ws_write_response);
-		break;
-	case CET_MP_READ_SESSION_REQUEST:
-		finalize_cache_mp_read_session_request(
-			&element->c_mp_rs_request);
-		break;
-	case CET_MP_READ_SESSION_RESPONSE:
-		finalize_cache_mp_read_session_response(
-			&element->c_mp_rs_response);
-		break;
-	case CET_MP_READ_SESSION_READ_RESPONSE:
-		finalize_cache_mp_read_session_read_response(
-			&element->c_mp_rs_read_response);
-		break;
-	case CET_UNDEFINED:
-		break;
-	default:
-	break;
-	}
-
-	element->type = CET_UNDEFINED;
-	TRACE_OUT(finalize_comm_element);
-}
-
-void
-init_cache_write_request(struct cache_write_request *write_request)
-{
-
-	TRACE_IN(init_cache_write_request);
-	memset(write_request, 0, sizeof(struct cache_write_request));
-	TRACE_OUT(init_cache_write_request);
-}
-
-void
-finalize_cache_write_request(struct cache_write_request *write_request)
-{
-
-	TRACE_IN(finalize_cache_write_request);
-	free(write_request->entry);
-	free(write_request->cache_key);
-	free(write_request->data);
-	TRACE_OUT(finalize_cache_write_request);
-}
-
-struct cache_write_request *
-get_cache_write_request(struct comm_element *element)
-{
-
-	TRACE_IN(get_cache_write_request);
-	assert(element->type == CET_WRITE_REQUEST);
-	TRACE_OUT(get_cache_write_request);
-	return (&element->c_write_request);
-}
-
-void
-init_cache_write_response(struct cache_write_response *write_response)
-{
-
-	TRACE_IN(init_cache_write_response);
-	memset(write_response, 0, sizeof(struct cache_write_response));
-	TRACE_OUT(init_cache_write_response);
-}
-
-void
-finalize_cache_write_response(struct cache_write_response *write_response)
-{
-
-	TRACE_IN(finalize_cache_write_response);
-	TRACE_OUT(finalize_cache_write_response);
-}
-
-struct cache_write_response *
-get_cache_write_response(struct comm_element *element)
-{
-
-	TRACE_IN(get_cache_write_response);
-	assert(element->type == CET_WRITE_RESPONSE);
-	TRACE_OUT(get_cache_write_response);
-	return (&element->c_write_response);
-}
-
-void
-init_cache_read_request(struct cache_read_request *read_request)
-{
-
-	TRACE_IN(init_cache_read_request);
-	memset(read_request, 0, sizeof(struct cache_read_request));
-	TRACE_OUT(init_cache_read_request);
-}
-
-void
-finalize_cache_read_request(struct cache_read_request *read_request)
-{
-
-	TRACE_IN(finalize_cache_read_request);
-	free(read_request->entry);
-	free(read_request->cache_key);
-	TRACE_OUT(finalize_cache_read_request);
-}
-
-struct cache_read_request *
-get_cache_read_request(struct comm_element *element)
-{
-
-	TRACE_IN(get_cache_read_request);
-	assert(element->type == CET_READ_REQUEST);
-	TRACE_OUT(get_cache_read_request);
-	return (&element->c_read_request);
-}
-
-void
-init_cache_read_response(struct cache_read_response *read_response)
-{
-
-	TRACE_IN(init_cache_read_response);
-	memset(read_response, 0, sizeof(struct cache_read_response));
-	TRACE_OUT(init_cache_read_response);
-}
-
-void
-finalize_cache_read_response(struct cache_read_response *read_response)
-{
-
-	TRACE_IN(finalize_cache_read_response);
-	free(read_response->data);
-	TRACE_OUT(finalize_cache_read_response);
-}
-
-struct cache_read_response *
-get_cache_read_response(struct comm_element *element)
-{
-
-	TRACE_IN(get_cache_read_response);
-	assert(element->type == CET_READ_RESPONSE);
-	TRACE_OUT(get_cache_read_response);
-	return (&element->c_read_response);
-}
-
-void
-init_cache_transform_request(struct cache_transform_request *transform_request)
-{
-
-	TRACE_IN(init_cache_transform_request);
-	memset(transform_request, 0, sizeof(struct cache_transform_request));
-	TRACE_OUT(init_cache_transform_request);
-}
-
-void
-finalize_cache_transform_request(
-	struct cache_transform_request *transform_request)
-{
-
-	TRACE_IN(finalize_cache_transform_request);
-	free(transform_request->entry);
-	TRACE_OUT(finalize_cache_transform_request);
-}
-
-struct cache_transform_request *
-get_cache_transform_request(struct comm_element *element)
-{
-
-	TRACE_IN(get_cache_transform_request);
-	assert(element->type == CET_TRANSFORM_REQUEST);
-	TRACE_OUT(get_cache_transform_request);
-	return (&element->c_transform_request);
-}
-
-void
-init_cache_transform_response(
-	struct cache_transform_response *transform_response)
-{
-
-	TRACE_IN(init_cache_transform_request);
-	memset(transform_response, 0, sizeof(struct cache_transform_response));
-	TRACE_OUT(init_cache_transform_request);
-}
-
-void
-finalize_cache_transform_response(
-	struct cache_transform_response *transform_response)
-{
-
-	TRACE_IN(finalize_cache_transform_response);
-	TRACE_OUT(finalize_cache_transform_response);
-}
-
-struct cache_transform_response *
-get_cache_transform_response(struct comm_element *element)
-{
-
-	TRACE_IN(get_cache_transform_response);
-	assert(element->type == CET_TRANSFORM_RESPONSE);
-	TRACE_OUT(get_cache_transform_response);
-	return (&element->c_transform_response);
-}
-
-
-void
-init_cache_mp_write_session_request(
-	struct cache_mp_write_session_request *mp_ws_request)
-{
-
-	TRACE_IN(init_cache_mp_write_session_request);
-	memset(mp_ws_request, 0,
-    		sizeof(struct cache_mp_write_session_request));
-	TRACE_OUT(init_cache_mp_write_session_request);
-}
-
-void
-finalize_cache_mp_write_session_request(
-	struct cache_mp_write_session_request *mp_ws_request)
-{
-
-	TRACE_IN(finalize_cache_mp_write_session_request);
-	free(mp_ws_request->entry);
-	TRACE_OUT(finalize_cache_mp_write_session_request);
-}
-
-struct cache_mp_write_session_request *
-get_cache_mp_write_session_request(struct comm_element *element)
-{
-
-	TRACE_IN(get_cache_mp_write_session_request);
-	assert(element->type == CET_MP_WRITE_SESSION_REQUEST);
-	TRACE_OUT(get_cache_mp_write_session_request);
-	return (&element->c_mp_ws_request);
-}
-
-void
-init_cache_mp_write_session_response(
-	struct cache_mp_write_session_response *mp_ws_response)
-{
-
-	TRACE_IN(init_cache_mp_write_session_response);
-	memset(mp_ws_response, 0,
-    		sizeof(struct cache_mp_write_session_response));
-	TRACE_OUT(init_cache_mp_write_session_response);
-}
-
-void
-finalize_cache_mp_write_session_response(
-	struct cache_mp_write_session_response *mp_ws_response)
-{
-
-	TRACE_IN(finalize_cache_mp_write_session_response);
-	TRACE_OUT(finalize_cache_mp_write_session_response);
-}
-
-struct cache_mp_write_session_response *
-get_cache_mp_write_session_response(struct comm_element *element)
-{
-
-	TRACE_IN(get_cache_mp_write_session_response);
-	assert(element->type == CET_MP_WRITE_SESSION_RESPONSE);
-	TRACE_OUT(get_cache_mp_write_session_response);
-	return (&element->c_mp_ws_response);
-}
-
-void
-init_cache_mp_write_session_write_request(
-	struct cache_mp_write_session_write_request *mp_ws_write_request)
-{
-
-	TRACE_IN(init_cache_mp_write_session_write_request);
-	memset(mp_ws_write_request, 0,
-		sizeof(struct cache_mp_write_session_write_request));
-	TRACE_OUT(init_cache_mp_write_session_write_response);
-}
-
-void
-finalize_cache_mp_write_session_write_request(
-	struct cache_mp_write_session_write_request *mp_ws_write_request)
-{
-
-	TRACE_IN(finalize_cache_mp_write_session_write_request);
-	free(mp_ws_write_request->data);
-	TRACE_OUT(finalize_cache_mp_write_session_write_request);
-}
-
-struct cache_mp_write_session_write_request *
-get_cache_mp_write_session_write_request(struct comm_element *element)
-{
-
-	TRACE_IN(get_cache_mp_write_session_write_request);
-	assert(element->type == CET_MP_WRITE_SESSION_WRITE_REQUEST);
-	TRACE_OUT(get_cache_mp_write_session_write_request);
-	return (&element->c_mp_ws_write_request);
-}
-
-void
-init_cache_mp_write_session_write_response(
-	struct cache_mp_write_session_write_response *mp_ws_write_response)
-{
-
-	TRACE_IN(init_cache_mp_write_session_write_response);
-	memset(mp_ws_write_response, 0,
-		sizeof(struct cache_mp_write_session_write_response));
-	TRACE_OUT(init_cache_mp_write_session_write_response);
-}
-
-void
-finalize_cache_mp_write_session_write_response(
-	struct cache_mp_write_session_write_response *mp_ws_write_response)
-{
-
-	TRACE_IN(finalize_cache_mp_write_session_write_response);
-	TRACE_OUT(finalize_cache_mp_write_session_write_response);
-}
-
-struct cache_mp_write_session_write_response *
-get_cache_mp_write_session_write_response(struct comm_element *element)
-{
-
-	TRACE_IN(get_cache_mp_write_session_write_response);
-	assert(element->type == CET_MP_WRITE_SESSION_WRITE_RESPONSE);
-	TRACE_OUT(get_cache_mp_write_session_write_response);
-	return (&element->c_mp_ws_write_response);
-}
-
-void
-init_cache_mp_read_session_request(
-	struct cache_mp_read_session_request *mp_rs_request)
-{
-
-	TRACE_IN(init_cache_mp_read_session_request);
-	memset(mp_rs_request, 0, sizeof(struct cache_mp_read_session_request));
-	TRACE_OUT(init_cache_mp_read_session_request);
-}
-
-void
-finalize_cache_mp_read_session_request(
-	struct cache_mp_read_session_request *mp_rs_request)
-{
-
-	TRACE_IN(finalize_cache_mp_read_session_request);
-	free(mp_rs_request->entry);
-	TRACE_OUT(finalize_cache_mp_read_session_request);
-}
-
-struct cache_mp_read_session_request *
-get_cache_mp_read_session_request(struct comm_element *element)
-{
-
-	TRACE_IN(get_cache_mp_read_session_request);
-	assert(element->type == CET_MP_READ_SESSION_REQUEST);
-	TRACE_OUT(get_cache_mp_read_session_request);
-	return (&element->c_mp_rs_request);
-}
-
-void
-init_cache_mp_read_session_response(
-	struct cache_mp_read_session_response *mp_rs_response)
-{
-
-	TRACE_IN(init_cache_mp_read_session_response);
-	memset(mp_rs_response, 0,
-    		sizeof(struct cache_mp_read_session_response));
-	TRACE_OUT(init_cache_mp_read_session_response);
-}
-
-void
-finalize_cache_mp_read_session_response(
-	struct cache_mp_read_session_response *mp_rs_response)
-{
-
-	TRACE_IN(finalize_cache_mp_read_session_response);
-	TRACE_OUT(finalize_cache_mp_read_session_response);
-}
-
-struct cache_mp_read_session_response *
-get_cache_mp_read_session_response(struct comm_element *element)
-{
-
-	TRACE_IN(get_cache_mp_read_session_response);
-	assert(element->type == CET_MP_READ_SESSION_RESPONSE);
-	TRACE_OUT(get_cache_mp_read_session_response);
-	return (&element->c_mp_rs_response);
-}
-
-void
-init_cache_mp_read_session_read_response(
-	struct cache_mp_read_session_read_response *mp_ws_read_response)
-{
-
-	TRACE_IN(init_cache_mp_read_session_read_response);
-	memset(mp_ws_read_response, 0,
-		sizeof(struct cache_mp_read_session_read_response));
-	TRACE_OUT(init_cache_mp_read_session_read_response);
-}
-
-void
-finalize_cache_mp_read_session_read_response(
-	struct cache_mp_read_session_read_response *mp_rs_read_response)
-{
-
-	TRACE_IN(finalize_cache_mp_read_session_read_response);
-	free(mp_rs_read_response->data);
-	TRACE_OUT(finalize_cache_mp_read_session_read_response);
-}
-
-struct cache_mp_read_session_read_response *
-get_cache_mp_read_session_read_response(struct comm_element *element)
-{
-
-	TRACE_IN(get_cache_mp_read_session_read_response);
-	assert(element->type == CET_MP_READ_SESSION_READ_RESPONSE);
-	TRACE_OUT(get_cache_mp_read_session_read_response);
-	return (&element->c_mp_rs_read_response);
-}
diff --git a/usr.sbin/cached/protocol.h b/usr.sbin/cached/protocol.h
deleted file mode 100644
index 7fadbfc..0000000
--- a/usr.sbin/cached/protocol.h
+++ /dev/null
@@ -1,265 +0,0 @@
-/*-
- * Copyright (c) 2005 Michael Bushkov <bushman@rsu.ru>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * $FreeBSD$
- */
-
-#ifndef __CACHED_PROTOCOL_H__
-#define __CACHED_PROTOCOL_H__
-
-#include <stdlib.h>
-
-/* maximum buffer size to receive - larger buffers are not allowed */
-#define MAX_BUFFER_SIZE (1 << 20)
-
-/* buffer size correctness checking routine */
-#define BUFSIZE_CORRECT(x) (((x) > 0) && ((x) < MAX_BUFFER_SIZE))
-#define BUFSIZE_INVALID(x) (!BUFSIZE_CORRECT(x))
-
-/* structures below represent the data that are sent/received by the daemon */
-struct cache_write_request
-{
-	char	*entry;
-	char	*cache_key;
-	char	*data;
-
-	size_t	entry_length;
-	size_t	cache_key_size;
-	size_t	data_size;
-};
-
-struct cache_write_response
-{
-	int	error_code;
-};
-
-struct cache_read_request
-{
-	char	*entry;
-	char	*cache_key;
-
-	size_t	entry_length;
-	size_t	cache_key_size;
-};
-
-struct cache_read_response
-{
-	char	*data;			// ignored if error_code is not 0
-	size_t	data_size;		// ignored if error_code is not 0
-
-	int	error_code;
-};
-
-enum transformation_type {
-	TT_USER = 0,	// tranform only the entries of the caller
-	TT_ALL = 1	// transform all entries
-};
-
-struct cache_transform_request
-{
-	char	*entry; 		// ignored if entry_length is 0
-	size_t	entry_length;
-
-	int	transformation_type;
-};
-
-struct cache_transform_response
-{
-	int	error_code;
-};
-
-struct cache_mp_write_session_request {
-	char	*entry;
-	size_t	entry_length;
-};
-
-struct cache_mp_write_session_response {
-	int	error_code;
-};
-
-struct cache_mp_write_session_write_request {
-	char	*data;
-	size_t	data_size;
-};
-
-struct cache_mp_write_session_write_response {
-	int	error_code;
-};
-
-struct cache_mp_read_session_request {
-	char	*entry;
-	size_t	entry_length;
-};
-
-struct cache_mp_read_session_response {
-	int	error_code;
-};
-
-struct cache_mp_read_session_read_response {
-	char	*data;
-	size_t	data_size;
-
-	int	error_code;
-};
-
-
-enum comm_element_t {
-	CET_UNDEFINED 	= 0,
-	CET_WRITE_REQUEST = 1,
-	CET_WRITE_RESPONSE = 2,
-	CET_READ_REQUEST = 3,
-	CET_READ_RESPONSE = 4,
-	CET_TRANSFORM_REQUEST = 5,
-	CET_TRANSFORM_RESPONSE = 6,
-	CET_MP_WRITE_SESSION_REQUEST = 7,
-	CET_MP_WRITE_SESSION_RESPONSE = 8,
-	CET_MP_WRITE_SESSION_WRITE_REQUEST = 9,
-	CET_MP_WRITE_SESSION_WRITE_RESPONSE = 10,
-	CET_MP_WRITE_SESSION_CLOSE_NOTIFICATION = 11,
-	CET_MP_WRITE_SESSION_ABANDON_NOTIFICATION = 12,
-	CET_MP_READ_SESSION_REQUEST = 13,
-	CET_MP_READ_SESSION_RESPONSE = 14,
-	CET_MP_READ_SESSION_READ_REQUEST = 15,
-	CET_MP_READ_SESSION_READ_RESPONSE = 16,
-	CET_MP_READ_SESSION_CLOSE_NOTIFICATION = 17,
-	CET_MAX = 18
-};
-
-/*
- * The comm_element is used as the holder of any known (defined above) data
- * type that is to be sent/received.
- */
-struct comm_element
-{
-	union {
-	struct cache_write_request c_write_request;
-	struct cache_write_response c_write_response;
-	struct cache_read_request c_read_request;
-	struct cache_read_response c_read_response;
-	struct cache_transform_request c_transform_request;
-	struct cache_transform_response c_transform_response;
-
-	struct cache_mp_write_session_request c_mp_ws_request;
-	struct cache_mp_write_session_response c_mp_ws_response;
-	struct cache_mp_write_session_write_request c_mp_ws_write_request;
-	struct cache_mp_write_session_write_response c_mp_ws_write_response;
-
-	struct cache_mp_read_session_request c_mp_rs_request;
-	struct cache_mp_read_session_response c_mp_rs_response;
-	struct cache_mp_read_session_read_response c_mp_rs_read_response;
-	};
-	enum comm_element_t type;
-};
-
-extern void init_comm_element(struct comm_element *, enum comm_element_t type);
-extern void finalize_comm_element(struct comm_element *);
-
-/*
- * For each type of data, there is three functions (init/finalize/get), that
- * used with comm_element structure
- */
-extern void init_cache_write_request(struct cache_write_request *);
-extern void finalize_cache_write_request(struct cache_write_request *);
-extern struct cache_write_request *get_cache_write_request(
-	struct comm_element *);
-
-extern void init_cache_write_response(struct cache_write_response *);
-extern void finalize_cache_write_response(struct cache_write_response *);
-extern struct cache_write_response *get_cache_write_response(
-	struct comm_element *);
-
-extern void init_cache_read_request(struct cache_read_request *);
-extern void finalize_cache_read_request(struct cache_read_request *);
-extern struct cache_read_request *get_cache_read_request(
-	struct comm_element *);
-
-extern void init_cache_read_response(struct cache_read_response *);
-extern void finalize_cache_read_response(struct cache_read_response *);
-extern struct cache_read_response *get_cache_read_response(
-	struct comm_element *);
-
-extern void init_cache_transform_request(struct cache_transform_request *);
-extern void finalize_cache_transform_request(struct cache_transform_request *);
-extern struct cache_transform_request *get_cache_transform_request(
-	struct comm_element *);
-
-extern void init_cache_transform_response(struct cache_transform_response *);
-extern void finalize_cache_transform_response(
-	struct cache_transform_response *);
-extern struct cache_transform_response *get_cache_transform_response(
-	struct comm_element *);
-
-extern void init_cache_mp_write_session_request(
-	struct cache_mp_write_session_request *);
-extern void finalize_cache_mp_write_session_request(
-	struct cache_mp_write_session_request *);
-extern struct cache_mp_write_session_request *
-    	get_cache_mp_write_session_request(
-	struct comm_element *);
-
-extern void init_cache_mp_write_session_response(
-	struct cache_mp_write_session_response *);
-extern void finalize_cache_mp_write_session_response(
-	struct cache_mp_write_session_response *);
-extern struct cache_mp_write_session_response *
-	get_cache_mp_write_session_response(struct comm_element *);
-
-extern void init_cache_mp_write_session_write_request(
-	struct cache_mp_write_session_write_request *);
-extern void finalize_cache_mp_write_session_write_request(
-	struct cache_mp_write_session_write_request *);
-extern struct cache_mp_write_session_write_request *
-	get_cache_mp_write_session_write_request(struct comm_element *);
-
-extern void init_cache_mp_write_session_write_response(
-	struct cache_mp_write_session_write_response *);
-extern void finalize_cache_mp_write_session_write_response(
-	struct cache_mp_write_session_write_response *);
-extern struct cache_mp_write_session_write_response *
-	get_cache_mp_write_session_write_response(struct comm_element *);
-
-extern void init_cache_mp_read_session_request(
-	struct cache_mp_read_session_request *);
-extern void finalize_cache_mp_read_session_request(
-	struct cache_mp_read_session_request *);
-extern struct cache_mp_read_session_request *get_cache_mp_read_session_request(
-	struct comm_element *);
-
-extern void init_cache_mp_read_session_response(
-	struct cache_mp_read_session_response *);
-extern void finalize_cache_mp_read_session_response(
-	struct cache_mp_read_session_response *);
-extern struct cache_mp_read_session_response *
-    	get_cache_mp_read_session_response(
-	struct comm_element *);
-
-extern void init_cache_mp_read_session_read_response(
-	struct cache_mp_read_session_read_response *);
-extern void finalize_cache_mp_read_session_read_response(
-	struct cache_mp_read_session_read_response *);
-extern struct cache_mp_read_session_read_response *
-	get_cache_mp_read_session_read_response(struct comm_element *);
-
-#endif
diff --git a/usr.sbin/cached/query.c b/usr.sbin/cached/query.c
deleted file mode 100644
index 947e93f..0000000
--- a/usr.sbin/cached/query.c
+++ /dev/null
@@ -1,1280 +0,0 @@
-/*-
- * Copyright (c) 2005 Michael Bushkov <bushman@rsu.ru>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- */
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <sys/time.h>
-#include <sys/event.h>
-#include <assert.h>
-#include <errno.h>
-#include <nsswitch.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include "config.h"
-#include "debug.h"
-#include "query.h"
-#include "log.h"
-#include "mp_ws_query.h"
-#include "mp_rs_query.h"
-#include "singletons.h"
-
-static const char negative_data[1] = { 0 };
-
-extern	void get_time_func(struct timeval *);
-
-static 	void clear_config_entry(struct configuration_entry *);
-static 	void clear_config_entry_part(struct configuration_entry *,
-	const char *, size_t);
-
-static	int on_query_startup(struct query_state *);
-static	void on_query_destroy(struct query_state *);
-
-static	int on_read_request_read1(struct query_state *);
-static	int on_read_request_read2(struct query_state *);
-static	int on_read_request_process(struct query_state *);
-static	int on_read_response_write1(struct query_state *);
-static	int on_read_response_write2(struct query_state *);
-
-static	int on_rw_mapper(struct query_state *);
-
-static	int on_transform_request_read1(struct query_state *);
-static	int on_transform_request_read2(struct query_state *);
-static	int on_transform_request_process(struct query_state *);
-static	int on_transform_response_write1(struct query_state *);
-
-static	int on_write_request_read1(struct query_state *);
-static	int on_write_request_read2(struct query_state *);
-static	int on_negative_write_request_process(struct query_state *);
-static	int on_write_request_process(struct query_state *);
-static	int on_write_response_write1(struct query_state *);
-
-/*
- * Clears the specified configuration entry (clears the cache for positive and
- * and negative entries) and also for all multipart entries.
- */
-static void
-clear_config_entry(struct configuration_entry *config_entry)
-{
-	size_t i;
-
-	TRACE_IN(clear_config_entry);
-	configuration_lock_entry(config_entry, CELT_POSITIVE);
-	if (config_entry->positive_cache_entry != NULL)
-		transform_cache_entry(
-			config_entry->positive_cache_entry,
-			CTT_CLEAR);
-	configuration_unlock_entry(config_entry, CELT_POSITIVE);
-
-	configuration_lock_entry(config_entry, CELT_NEGATIVE);
-	if (config_entry->negative_cache_entry != NULL)
-		transform_cache_entry(
-			config_entry->negative_cache_entry,
-			CTT_CLEAR);
-	configuration_unlock_entry(config_entry, CELT_NEGATIVE);
-
-	configuration_lock_entry(config_entry, CELT_MULTIPART);
-	for (i = 0; i < config_entry->mp_cache_entries_size; ++i)
-		transform_cache_entry(
-			config_entry->mp_cache_entries[i],
-			CTT_CLEAR);
-	configuration_unlock_entry(config_entry, CELT_MULTIPART);
-
-	TRACE_OUT(clear_config_entry);
-}
-
-/*
- * Clears the specified configuration entry by deleting only the elements,
- * that are owned by the user with specified eid_str.
- */
-static void
-clear_config_entry_part(struct configuration_entry *config_entry,
-	const char *eid_str, size_t eid_str_length)
-{
-	cache_entry *start, *finish, *mp_entry;
-	TRACE_IN(clear_config_entry_part);
-	configuration_lock_entry(config_entry, CELT_POSITIVE);
-	if (config_entry->positive_cache_entry != NULL)
-		transform_cache_entry_part(
-			config_entry->positive_cache_entry,
-			CTT_CLEAR, eid_str, eid_str_length, KPPT_LEFT);
-	configuration_unlock_entry(config_entry, CELT_POSITIVE);
-
-	configuration_lock_entry(config_entry, CELT_NEGATIVE);
-	if (config_entry->negative_cache_entry != NULL)
-		transform_cache_entry_part(
-			config_entry->negative_cache_entry,
-			CTT_CLEAR, eid_str, eid_str_length, KPPT_LEFT);
-	configuration_unlock_entry(config_entry, CELT_NEGATIVE);
-
-	configuration_lock_entry(config_entry, CELT_MULTIPART);
-	if (configuration_entry_find_mp_cache_entries(config_entry,
-		eid_str, &start, &finish) == 0) {
-		for (mp_entry = start; mp_entry != finish; ++mp_entry)
-			transform_cache_entry(*mp_entry, CTT_CLEAR);
-	}
-	configuration_unlock_entry(config_entry, CELT_MULTIPART);
-
-	TRACE_OUT(clear_config_entry_part);
-}
-
-/*
- * This function is assigned to the query_state structue on its creation.
- * It's main purpose is to receive credentials from the client.
- */
-static int
-on_query_startup(struct query_state *qstate)
-{
-	struct msghdr	cred_hdr;
-	struct iovec	iov;
-	struct cmsgcred *cred;
-	int elem_type;
-
-	struct {
-		struct cmsghdr	hdr;
-		char cred[CMSG_SPACE(sizeof(struct cmsgcred))];
-	} cmsg;
-
-	TRACE_IN(on_query_startup);
-	assert(qstate != NULL);
-
-	memset(&cred_hdr, 0, sizeof(struct msghdr));
-	cred_hdr.msg_iov = &iov;
-	cred_hdr.msg_iovlen = 1;
-	cred_hdr.msg_control = (caddr_t)&cmsg;
-	cred_hdr.msg_controllen = CMSG_LEN(sizeof(struct cmsgcred));
-
-	memset(&iov, 0, sizeof(struct iovec));
-	iov.iov_base = &elem_type;
-	iov.iov_len = sizeof(int);
-
-	if (recvmsg(qstate->sockfd, &cred_hdr, 0) == -1) {
-		TRACE_OUT(on_query_startup);
-		return (-1);
-	}
-
-	if (cmsg.hdr.cmsg_len < CMSG_LEN(sizeof(struct cmsgcred))
-		|| cmsg.hdr.cmsg_level != SOL_SOCKET
-		|| cmsg.hdr.cmsg_type != SCM_CREDS) {
-		TRACE_OUT(on_query_startup);
-		return (-1);
-	}
-
-	cred = (struct cmsgcred *)CMSG_DATA(&cmsg);
-	qstate->uid = cred->cmcred_uid;
-	qstate->gid = cred->cmcred_gid;
-
-#if defined(NS_CACHED_EID_CHECKING) || defined(NS_STRICT_CACHED_EID_CHECKING)
-/*
- * This check is probably a bit redundant - per-user cache is always separated
- * by the euid/egid pair
- */
-	if (check_query_eids(qstate) != 0) {
-#ifdef NS_STRICT_CACHED_EID_CHECKING
-		TRACE_OUT(on_query_startup);
-		return (-1);
-#else
-		if ((elem_type != CET_READ_REQUEST) &&
-			(elem_type != CET_MP_READ_SESSION_REQUEST) &&
-			(elem_type != CET_WRITE_REQUEST) &&
-			(elem_type != CET_MP_WRITE_SESSION_REQUEST)) {
-			TRACE_OUT(on_query_startup);
-			return (-1);
-		}
-#endif
-	}
-#endif
-
-	switch (elem_type) {
-	case CET_WRITE_REQUEST:
-		qstate->process_func = on_write_request_read1;
-		break;
-	case CET_READ_REQUEST:
-		qstate->process_func = on_read_request_read1;
-		break;
-	case CET_TRANSFORM_REQUEST:
-		qstate->process_func = on_transform_request_read1;
-		break;
-	case CET_MP_WRITE_SESSION_REQUEST:
-		qstate->process_func = on_mp_write_session_request_read1;
-		break;
-	case CET_MP_READ_SESSION_REQUEST:
-		qstate->process_func = on_mp_read_session_request_read1;
-		break;
-	default:
-		TRACE_OUT(on_query_startup);
-		return (-1);
-	}
-
-	qstate->kevent_watermark = 0;
-	TRACE_OUT(on_query_startup);
-	return (0);
-}
-
-/*
- * on_rw_mapper is used to process multiple read/write requests during
- * one connection session. It's never called in the beginning (on query_state
- * creation) as it does not process the multipart requests and does not
- * receive credentials
- */
-static int
-on_rw_mapper(struct query_state *qstate)
-{
-	ssize_t	result;
-	int	elem_type;
-
-	TRACE_IN(on_rw_mapper);
-	if (qstate->kevent_watermark == 0) {
-		qstate->kevent_watermark = sizeof(int);
-	} else {
-		result = qstate->read_func(qstate, &elem_type, sizeof(int));
-		if (result != sizeof(int)) {
-			TRACE_OUT(on_rw_mapper);
-			return (-1);
-		}
-
-		switch (elem_type) {
-		case CET_WRITE_REQUEST:
-			qstate->kevent_watermark = sizeof(size_t);
-			qstate->process_func = on_write_request_read1;
-		break;
-		case CET_READ_REQUEST:
-			qstate->kevent_watermark = sizeof(size_t);
-			qstate->process_func = on_read_request_read1;
-		break;
-		default:
-			TRACE_OUT(on_rw_mapper);
-			return (-1);
-		break;
-		}
-	}
-	TRACE_OUT(on_rw_mapper);
-	return (0);
-}
-
-/*
- * The default query_destroy function
- */
-static void
-on_query_destroy(struct query_state *qstate)
-{
-
-	TRACE_IN(on_query_destroy);
-	finalize_comm_element(&qstate->response);
-	finalize_comm_element(&qstate->request);
-	TRACE_OUT(on_query_destroy);
-}
-
-/*
- * The functions below are used to process write requests.
- * - on_write_request_read1 and on_write_request_read2 read the request itself
- * - on_write_request_process processes it (if the client requests to
- *    cache the negative result, the on_negative_write_request_process is used)
- * - on_write_response_write1 sends the response
- */
-static int
-on_write_request_read1(struct query_state *qstate)
-{
-	struct cache_write_request	*write_request;
-	ssize_t	result;
-
-	TRACE_IN(on_write_request_read1);
-	if (qstate->kevent_watermark == 0)
-		qstate->kevent_watermark = sizeof(size_t) * 3;
-	else {
-		init_comm_element(&qstate->request, CET_WRITE_REQUEST);
-		write_request = get_cache_write_request(&qstate->request);
-
-		result = qstate->read_func(qstate, &write_request->entry_length,
-	    		sizeof(size_t));
-		result += qstate->read_func(qstate,
-	    		&write_request->cache_key_size, sizeof(size_t));
-		result += qstate->read_func(qstate,
-	    		&write_request->data_size, sizeof(size_t));
-
-		if (result != sizeof(size_t) * 3) {
-			TRACE_OUT(on_write_request_read1);
-			return (-1);
-		}
-
-		if (BUFSIZE_INVALID(write_request->entry_length) ||
-			BUFSIZE_INVALID(write_request->cache_key_size) ||
-			(BUFSIZE_INVALID(write_request->data_size) &&
-			(write_request->data_size != 0))) {
-			TRACE_OUT(on_write_request_read1);
-			return (-1);
-		}
-
-		write_request->entry = (char *)malloc(
-			write_request->entry_length + 1);
-		assert(write_request->entry != NULL);
-		memset(write_request->entry, 0,
-			write_request->entry_length + 1);
-
-		write_request->cache_key = (char *)malloc(
-			write_request->cache_key_size +
-			qstate->eid_str_length);
-		assert(write_request->cache_key != NULL);
-		memcpy(write_request->cache_key, qstate->eid_str,
-			qstate->eid_str_length);
-		memset(write_request->cache_key + qstate->eid_str_length, 0,
-			write_request->cache_key_size);
-
-		if (write_request->data_size != 0) {
-			write_request->data = (char *)malloc(
-				write_request->data_size);
-			assert(write_request->data != NULL);
-			memset(write_request->data, 0,
-				write_request->data_size);
-		}
-
-		qstate->kevent_watermark = write_request->entry_length +
-			write_request->cache_key_size +
-			write_request->data_size;
-		qstate->process_func = on_write_request_read2;
-	}
-
-	TRACE_OUT(on_write_request_read1);
-	return (0);
-}
-
-static int
-on_write_request_read2(struct query_state *qstate)
-{
-	struct cache_write_request	*write_request;
-	ssize_t	result;
-
-	TRACE_IN(on_write_request_read2);
-	write_request = get_cache_write_request(&qstate->request);
-
-	result = qstate->read_func(qstate, write_request->entry,
-		write_request->entry_length);
-	result += qstate->read_func(qstate, write_request->cache_key +
-		qstate->eid_str_length, write_request->cache_key_size);
-	if (write_request->data_size != 0)
-		result += qstate->read_func(qstate, write_request->data,
-			write_request->data_size);
-
-	if (result != qstate->kevent_watermark) {
-		TRACE_OUT(on_write_request_read2);
-		return (-1);
-	}
-	write_request->cache_key_size += qstate->eid_str_length;
-
-	qstate->kevent_watermark = 0;
-	if (write_request->data_size != 0)
-		qstate->process_func = on_write_request_process;
-	else
-	    	qstate->process_func = on_negative_write_request_process;
-	TRACE_OUT(on_write_request_read2);
-	return (0);
-}
-
-static	int
-on_write_request_process(struct query_state *qstate)
-{
-	struct cache_write_request	*write_request;
-	struct cache_write_response	*write_response;
-	cache_entry c_entry;
-
-	TRACE_IN(on_write_request_process);
-	init_comm_element(&qstate->response, CET_WRITE_RESPONSE);
-	write_response = get_cache_write_response(&qstate->response);
-	write_request = get_cache_write_request(&qstate->request);
-
-	qstate->config_entry = configuration_find_entry(
-		s_configuration, write_request->entry);
-
-	if (qstate->config_entry == NULL) {
-		write_response->error_code = ENOENT;
-
-		LOG_ERR_2("write_request", "can't find configuration"
-		    " entry '%s'. aborting request", write_request->entry);
-		goto fin;
-	}
-
-	if (qstate->config_entry->enabled == 0) {
-		write_response->error_code = EACCES;
-
-		LOG_ERR_2("write_request",
-			"configuration entry '%s' is disabled",
-			write_request->entry);
-		goto fin;
-	}
-
-	if (qstate->config_entry->perform_actual_lookups != 0) {
-		write_response->error_code = EOPNOTSUPP;
-
-		LOG_ERR_2("write_request",
-			"entry '%s' performs lookups by itself: "
-			"can't write to it", write_request->entry);
-		goto fin;
-	}
-
-	configuration_lock_rdlock(s_configuration);
-	c_entry = find_cache_entry(s_cache,
-    		qstate->config_entry->positive_cache_params.entry_name);
-	configuration_unlock(s_configuration);
-	if (c_entry != NULL) {
-		configuration_lock_entry(qstate->config_entry, CELT_POSITIVE);
-		qstate->config_entry->positive_cache_entry = c_entry;
-		write_response->error_code = cache_write(c_entry,
-			write_request->cache_key,
-	    		write_request->cache_key_size,
-	    		write_request->data,
-			write_request->data_size);
-		configuration_unlock_entry(qstate->config_entry, CELT_POSITIVE);
-
-		if ((qstate->config_entry->common_query_timeout.tv_sec != 0) ||
-		    (qstate->config_entry->common_query_timeout.tv_usec != 0))
-			memcpy(&qstate->timeout,
-				&qstate->config_entry->common_query_timeout,
-				sizeof(struct timeval));
-
-	} else
-		write_response->error_code = -1;
-
-fin:
-	qstate->kevent_filter = EVFILT_WRITE;
-	qstate->kevent_watermark = sizeof(int);
-	qstate->process_func = on_write_response_write1;
-
-	TRACE_OUT(on_write_request_process);
-	return (0);
-}
-
-static int
-on_negative_write_request_process(struct query_state *qstate)
-{
-	struct cache_write_request	*write_request;
-	struct cache_write_response	*write_response;
-	cache_entry c_entry;
-
-	TRACE_IN(on_negative_write_request_process);
-	init_comm_element(&qstate->response, CET_WRITE_RESPONSE);
-	write_response = get_cache_write_response(&qstate->response);
-	write_request = get_cache_write_request(&qstate->request);
-
-	qstate->config_entry = configuration_find_entry	(
-		s_configuration, write_request->entry);
-
-	if (qstate->config_entry == NULL) {
-		write_response->error_code = ENOENT;
-
-		LOG_ERR_2("negative_write_request",
-			"can't find configuration"
-		   	" entry '%s'. aborting request", write_request->entry);
-		goto fin;
-	}
-
-	if (qstate->config_entry->enabled == 0) {
-		write_response->error_code = EACCES;
-
-		LOG_ERR_2("negative_write_request",
-			"configuration entry '%s' is disabled",
-			write_request->entry);
-		goto fin;
-	}
-
-	if (qstate->config_entry->perform_actual_lookups != 0) {
-		write_response->error_code = EOPNOTSUPP;
-
-		LOG_ERR_2("negative_write_request",
-			"entry '%s' performs lookups by itself: "
-			"can't write to it", write_request->entry);
-		goto fin;
-	} else {
-#ifdef NS_CACHED_EID_CHECKING
-		if (check_query_eids(qstate) != 0) {
-			write_response->error_code = EPERM;
-			goto fin;
-		}
-#endif
-	}
-
-	configuration_lock_rdlock(s_configuration);
-	c_entry = find_cache_entry(s_cache,
-    		qstate->config_entry->negative_cache_params.entry_name);
-	configuration_unlock(s_configuration);
-	if (c_entry != NULL) {
-		configuration_lock_entry(qstate->config_entry, CELT_NEGATIVE);
-		qstate->config_entry->negative_cache_entry = c_entry;
-		write_response->error_code = cache_write(c_entry,
-			write_request->cache_key,
-	    		write_request->cache_key_size,
-	    		negative_data,
-			sizeof(negative_data));
-		configuration_unlock_entry(qstate->config_entry, CELT_NEGATIVE);
-
-		if ((qstate->config_entry->common_query_timeout.tv_sec != 0) ||
-		    (qstate->config_entry->common_query_timeout.tv_usec != 0))
-			memcpy(&qstate->timeout,
-				&qstate->config_entry->common_query_timeout,
-				sizeof(struct timeval));
-	} else
-		write_response->error_code = -1;
-
-fin:
-	qstate->kevent_filter = EVFILT_WRITE;
-	qstate->kevent_watermark = sizeof(int);
-	qstate->process_func = on_write_response_write1;
-
-	TRACE_OUT(on_negative_write_request_process);
-	return (0);
-}
-
-static int
-on_write_response_write1(struct query_state *qstate)
-{
-	struct cache_write_response	*write_response;
-	ssize_t	result;
-
-	TRACE_IN(on_write_response_write1);
-	write_response = get_cache_write_response(&qstate->response);
-	result = qstate->write_func(qstate, &write_response->error_code,
-		sizeof(int));
-	if (result != sizeof(int)) {
-		TRACE_OUT(on_write_response_write1);
-		return (-1);
-	}
-
-	finalize_comm_element(&qstate->request);
-	finalize_comm_element(&qstate->response);
-
-	qstate->kevent_watermark = sizeof(int);
-	qstate->kevent_filter = EVFILT_READ;
-	qstate->process_func = on_rw_mapper;
-
-	TRACE_OUT(on_write_response_write1);
-	return (0);
-}
-
-/*
- * The functions below are used to process read requests.
- * - on_read_request_read1 and on_read_request_read2 read the request itself
- * - on_read_request_process processes it
- * - on_read_response_write1 and on_read_response_write2 send the response
- */
-static int
-on_read_request_read1(struct query_state *qstate)
-{
-	struct cache_read_request *read_request;
-	ssize_t	result;
-
-	TRACE_IN(on_read_request_read1);
-	if (qstate->kevent_watermark == 0)
-		qstate->kevent_watermark = sizeof(size_t) * 2;
-	else {
-		init_comm_element(&qstate->request, CET_READ_REQUEST);
-		read_request = get_cache_read_request(&qstate->request);
-
-		result = qstate->read_func(qstate,
-	    		&read_request->entry_length, sizeof(size_t));
-		result += qstate->read_func(qstate,
-	    		&read_request->cache_key_size, sizeof(size_t));
-
-		if (result != sizeof(size_t) * 2) {
-			TRACE_OUT(on_read_request_read1);
-			return (-1);
-		}
-
-		if (BUFSIZE_INVALID(read_request->entry_length) ||
-			BUFSIZE_INVALID(read_request->cache_key_size)) {
-			TRACE_OUT(on_read_request_read1);
-			return (-1);
-		}
-
-		read_request->entry = (char *)malloc(
-			read_request->entry_length + 1);
-		assert(read_request->entry != NULL);
-		memset(read_request->entry, 0, read_request->entry_length + 1);
-
-		read_request->cache_key = (char *)malloc(
-			read_request->cache_key_size +
-			qstate->eid_str_length);
-		assert(read_request->cache_key != NULL);
-		memcpy(read_request->cache_key, qstate->eid_str,
-			qstate->eid_str_length);
-		memset(read_request->cache_key + qstate->eid_str_length, 0,
-			read_request->cache_key_size);
-
-		qstate->kevent_watermark = read_request->entry_length +
-			read_request->cache_key_size;
-		qstate->process_func = on_read_request_read2;
-	}
-
-	TRACE_OUT(on_read_request_read1);
-	return (0);
-}
-
-static int
-on_read_request_read2(struct query_state *qstate)
-{
-	struct cache_read_request	*read_request;
-	ssize_t	result;
-
-	TRACE_IN(on_read_request_read2);
-	read_request = get_cache_read_request(&qstate->request);
-
-	result = qstate->read_func(qstate, read_request->entry,
-		read_request->entry_length);
-	result += qstate->read_func(qstate,
-		read_request->cache_key + qstate->eid_str_length,
-		read_request->cache_key_size);
-
-	if (result != qstate->kevent_watermark) {
-		TRACE_OUT(on_read_request_read2);
-		return (-1);
-	}
-	read_request->cache_key_size += qstate->eid_str_length;
-
-	qstate->kevent_watermark = 0;
-	qstate->process_func = on_read_request_process;
-
-	TRACE_OUT(on_read_request_read2);
-	return (0);
-}
-
-static int
-on_read_request_process(struct query_state *qstate)
-{
-	struct cache_read_request *read_request;
-	struct cache_read_response *read_response;
-	cache_entry	c_entry, neg_c_entry;
-
-	struct agent	*lookup_agent;
-	struct common_agent *c_agent;
-	int res;
-
-	TRACE_IN(on_read_request_process);
-	init_comm_element(&qstate->response, CET_READ_RESPONSE);
-	read_response = get_cache_read_response(&qstate->response);
-	read_request = get_cache_read_request(&qstate->request);
-
-	qstate->config_entry = configuration_find_entry(
-		s_configuration, read_request->entry);
-	if (qstate->config_entry == NULL) {
-		read_response->error_code = ENOENT;
-
-		LOG_ERR_2("read_request",
-			"can't find configuration "
-	    		"entry '%s'. aborting request", read_request->entry);
-	    	goto fin;
-	}
-
-	if (qstate->config_entry->enabled == 0) {
-		read_response->error_code = EACCES;
-
-		LOG_ERR_2("read_request",
-			"configuration entry '%s' is disabled",
-			read_request->entry);
-		goto fin;
-	}
-
-	/*
-	 * if we perform lookups by ourselves, then we don't need to separate
-	 * cache entries by euid and egid
-	 */
-	if (qstate->config_entry->perform_actual_lookups != 0)
-		memset(read_request->cache_key, 0, qstate->eid_str_length);
-	else {
-#ifdef NS_CACHED_EID_CHECKING
-		if (check_query_eids(qstate) != 0) {
-		/* if the lookup is not self-performing, we check for clients euid/egid */
-			read_response->error_code = EPERM;
-			goto fin;
-		}
-#endif
-	}
-
-	configuration_lock_rdlock(s_configuration);
-	c_entry = find_cache_entry(s_cache,
-    		qstate->config_entry->positive_cache_params.entry_name);
-	neg_c_entry = find_cache_entry(s_cache,
-		qstate->config_entry->negative_cache_params.entry_name);
-	configuration_unlock(s_configuration);
-	if ((c_entry != NULL) && (neg_c_entry != NULL)) {
-		configuration_lock_entry(qstate->config_entry, CELT_POSITIVE);
-		qstate->config_entry->positive_cache_entry = c_entry;
-		read_response->error_code = cache_read(c_entry,
-	    		read_request->cache_key,
-	    		read_request->cache_key_size, NULL,
-	    		&read_response->data_size);
-
-		if (read_response->error_code == -2) {
-			read_response->data = (char *)malloc(
-		    		read_response->data_size);
-			assert(read_response != NULL);
-			read_response->error_code = cache_read(c_entry,
-				read_request->cache_key,
-		    		read_request->cache_key_size,
-		    		read_response->data,
-		    		&read_response->data_size);
-		}
-		configuration_unlock_entry(qstate->config_entry, CELT_POSITIVE);
-
-		configuration_lock_entry(qstate->config_entry, CELT_NEGATIVE);
-		qstate->config_entry->negative_cache_entry = neg_c_entry;
-		if (read_response->error_code == -1) {
-			read_response->error_code = cache_read(neg_c_entry,
-				read_request->cache_key,
-				read_request->cache_key_size, NULL,
-				&read_response->data_size);
-
-			if (read_response->error_code == -2) {
-				read_response->error_code = 0;
-				read_response->data = NULL;
-				read_response->data_size = 0;
-			}
-		}
-		configuration_unlock_entry(qstate->config_entry, CELT_NEGATIVE);
-
-		if ((read_response->error_code == -1) &&
-			(qstate->config_entry->perform_actual_lookups != 0)) {
-			free(read_response->data);
-			read_response->data = NULL;
-			read_response->data_size = 0;
-
-			lookup_agent = find_agent(s_agent_table,
-				read_request->entry, COMMON_AGENT);
-
-			if ((lookup_agent != NULL) &&
-			(lookup_agent->type == COMMON_AGENT)) {
-				c_agent = (struct common_agent *)lookup_agent;
-				res = c_agent->lookup_func(
-					read_request->cache_key +
-						qstate->eid_str_length,
-					read_request->cache_key_size -
-						qstate->eid_str_length,
-					&read_response->data,
-					&read_response->data_size);
-
-				if (res == NS_SUCCESS) {
-					read_response->error_code = 0;
-					configuration_lock_entry(
-						qstate->config_entry,
-						CELT_POSITIVE);
-					cache_write(c_entry,
-						read_request->cache_key,
-	    					read_request->cache_key_size,
-	    					read_response->data,
-						read_response->data_size);
-					configuration_unlock_entry(
-						qstate->config_entry,
-						CELT_POSITIVE);
-				} else if ((res == NS_NOTFOUND) ||
-					  (res == NS_RETURN)) {
-					configuration_lock_entry(
-						  qstate->config_entry,
-						  CELT_NEGATIVE);
-					cache_write(neg_c_entry,
-						read_request->cache_key,
-						read_request->cache_key_size,
-						negative_data,
-						sizeof(negative_data));
-					configuration_unlock_entry(
-						  qstate->config_entry,
-						  CELT_NEGATIVE);
-
-					read_response->error_code = 0;
-					read_response->data = NULL;
-					read_response->data_size = 0;
-				}
-			}
-		}
-
-		if ((qstate->config_entry->common_query_timeout.tv_sec != 0) ||
-		    (qstate->config_entry->common_query_timeout.tv_usec != 0))
-			memcpy(&qstate->timeout,
-				&qstate->config_entry->common_query_timeout,
-				sizeof(struct timeval));
-	} else
-		read_response->error_code = -1;
-
-fin:
-	qstate->kevent_filter = EVFILT_WRITE;
-	if (read_response->error_code == 0)
-		qstate->kevent_watermark = sizeof(int) + sizeof(size_t);
-	else
-		qstate->kevent_watermark = sizeof(int);
-	qstate->process_func = on_read_response_write1;
-
-	TRACE_OUT(on_read_request_process);
-	return (0);
-}
-
-static int
-on_read_response_write1(struct query_state *qstate)
-{
-	struct cache_read_response	*read_response;
-	ssize_t	result;
-
-	TRACE_IN(on_read_response_write1);
-	read_response = get_cache_read_response(&qstate->response);
-
-	result = qstate->write_func(qstate, &read_response->error_code,
-		sizeof(int));
-
-	if (read_response->error_code == 0) {
-		result += qstate->write_func(qstate, &read_response->data_size,
-			sizeof(size_t));
-		if (result != qstate->kevent_watermark) {
-			TRACE_OUT(on_read_response_write1);
-			return (-1);
-		}
-
-		qstate->kevent_watermark = read_response->data_size;
-		qstate->process_func = on_read_response_write2;
-	} else {
-		if (result != qstate->kevent_watermark) {
-			TRACE_OUT(on_read_response_write1);
-			return (-1);
-		}
-
-		qstate->kevent_watermark = 0;
-		qstate->process_func = NULL;
-	}
-
-	TRACE_OUT(on_read_response_write1);
-	return (0);
-}
-
-static int
-on_read_response_write2(struct query_state *qstate)
-{
-	struct cache_read_response	*read_response;
-	ssize_t	result;
-
-	TRACE_IN(on_read_response_write2);
-	read_response = get_cache_read_response(&qstate->response);
-	if (read_response->data_size > 0) {
-		result = qstate->write_func(qstate, read_response->data,
-			read_response->data_size);
-		if (result != qstate->kevent_watermark) {
-			TRACE_OUT(on_read_response_write2);
-			return (-1);
-		}
-	}
-
-	finalize_comm_element(&qstate->request);
-	finalize_comm_element(&qstate->response);
-
-	qstate->kevent_watermark = sizeof(int);
-	qstate->kevent_filter = EVFILT_READ;
-	qstate->process_func = on_rw_mapper;
-	TRACE_OUT(on_read_response_write2);
-	return (0);
-}
-
-/*
- * The functions below are used to process write requests.
- * - on_transform_request_read1 and on_transform_request_read2 read the
- *   request itself
- * - on_transform_request_process processes it
- * - on_transform_response_write1 sends the response
- */
-static int
-on_transform_request_read1(struct query_state *qstate)
-{
-	struct cache_transform_request *transform_request;
-	ssize_t	result;
-
-	TRACE_IN(on_transform_request_read1);
-	if (qstate->kevent_watermark == 0)
-		qstate->kevent_watermark = sizeof(size_t) + sizeof(int);
-	else {
-		init_comm_element(&qstate->request, CET_TRANSFORM_REQUEST);
-		transform_request =
-			get_cache_transform_request(&qstate->request);
-
-		result = qstate->read_func(qstate,
-	    		&transform_request->entry_length, sizeof(size_t));
-		result += qstate->read_func(qstate,
-	    		&transform_request->transformation_type, sizeof(int));
-
-		if (result != sizeof(size_t) + sizeof(int)) {
-			TRACE_OUT(on_transform_request_read1);
-			return (-1);
-		}
-
-		if ((transform_request->transformation_type != TT_USER) &&
-		    (transform_request->transformation_type != TT_ALL)) {
-			TRACE_OUT(on_transform_request_read1);
-			return (-1);
-		}
-
-		if (transform_request->entry_length != 0) {
-			if (BUFSIZE_INVALID(transform_request->entry_length)) {
-				TRACE_OUT(on_transform_request_read1);
-				return (-1);
-			}
-
-			transform_request->entry = (char *)malloc(
-				transform_request->entry_length + 1);
-			assert(transform_request->entry != NULL);
-			memset(transform_request->entry, 0,
-				transform_request->entry_length + 1);
-
-			qstate->process_func = on_transform_request_read2;
-		} else
-			qstate->process_func = on_transform_request_process;
-
-		qstate->kevent_watermark = transform_request->entry_length;
-	}
-
-	TRACE_OUT(on_transform_request_read1);
-	return (0);
-}
-
-static int
-on_transform_request_read2(struct query_state *qstate)
-{
-	struct cache_transform_request	*transform_request;
-	ssize_t	result;
-
-	TRACE_IN(on_transform_request_read2);
-	transform_request = get_cache_transform_request(&qstate->request);
-
-	result = qstate->read_func(qstate, transform_request->entry,
-		transform_request->entry_length);
-
-	if (result != qstate->kevent_watermark) {
-		TRACE_OUT(on_transform_request_read2);
-		return (-1);
-	}
-
-	qstate->kevent_watermark = 0;
-	qstate->process_func = on_transform_request_process;
-
-	TRACE_OUT(on_transform_request_read2);
-	return (0);
-}
-
-static int
-on_transform_request_process(struct query_state *qstate)
-{
-	struct cache_transform_request *transform_request;
-	struct cache_transform_response *transform_response;
-	struct configuration_entry *config_entry;
-	size_t	i, size;
-
-	TRACE_IN(on_transform_request_process);
-	init_comm_element(&qstate->response, CET_TRANSFORM_RESPONSE);
-	transform_response = get_cache_transform_response(&qstate->response);
-	transform_request = get_cache_transform_request(&qstate->request);
-
-	switch (transform_request->transformation_type) {
-	case TT_USER:
-		if (transform_request->entry == NULL) {
-			size = configuration_get_entries_size(s_configuration);
-			for (i = 0; i < size; ++i) {
-			    config_entry = configuration_get_entry(
-				s_configuration, i);
-
-			    if (config_entry->perform_actual_lookups == 0)
-			    	clear_config_entry_part(config_entry,
-				    qstate->eid_str, qstate->eid_str_length);
-			}
-		} else {
-			qstate->config_entry = configuration_find_entry(
-				s_configuration, transform_request->entry);
-
-			if (qstate->config_entry == NULL) {
-				LOG_ERR_2("transform_request",
-					"can't find configuration"
-		   			" entry '%s'. aborting request",
-					transform_request->entry);
-				transform_response->error_code = -1;
-				goto fin;
-			}
-
-			if (qstate->config_entry->perform_actual_lookups != 0) {
-				LOG_ERR_2("transform_request",
-					"can't transform the cache entry %s"
-					", because it ised for actual lookups",
-					transform_request->entry);
-				transform_response->error_code = -1;
-				goto fin;
-			}
-
-			clear_config_entry_part(qstate->config_entry,
-				qstate->eid_str, qstate->eid_str_length);
-		}
-		break;
-	case TT_ALL:
-		if (qstate->euid != 0)
-			transform_response->error_code = -1;
-		else {
-			if (transform_request->entry == NULL) {
-				size = configuration_get_entries_size(
-					s_configuration);
-				for (i = 0; i < size; ++i) {
-				    clear_config_entry(
-					configuration_get_entry(
-						s_configuration, i));
-				}
-			} else {
-				qstate->config_entry = configuration_find_entry(
-					s_configuration,
-					transform_request->entry);
-
-				if (qstate->config_entry == NULL) {
-					LOG_ERR_2("transform_request",
-						"can't find configuration"
-		   				" entry '%s'. aborting request",
-						transform_request->entry);
-					transform_response->error_code = -1;
-					goto fin;
-				}
-
-				clear_config_entry(qstate->config_entry);
-			}
-		}
-		break;
-	default:
-		transform_response->error_code = -1;
-	}
-
-fin:
-	qstate->kevent_watermark = 0;
-	qstate->process_func = on_transform_response_write1;
-	TRACE_OUT(on_transform_request_process);
-	return (0);
-}
-
-static int
-on_transform_response_write1(struct query_state *qstate)
-{
-	struct cache_transform_response	*transform_response;
-	ssize_t	result;
-
-	TRACE_IN(on_transform_response_write1);
-	transform_response = get_cache_transform_response(&qstate->response);
-	result = qstate->write_func(qstate, &transform_response->error_code,
-		sizeof(int));
-	if (result != sizeof(int)) {
-		TRACE_OUT(on_transform_response_write1);
-		return (-1);
-	}
-
-	finalize_comm_element(&qstate->request);
-	finalize_comm_element(&qstate->response);
-
-	qstate->kevent_watermark = 0;
-	qstate->process_func = NULL;
-	TRACE_OUT(on_transform_response_write1);
-	return (0);
-}
-
-/*
- * Checks if the client's euid and egid do not differ from its uid and gid.
- * Returns 0 on success.
- */
-int
-check_query_eids(struct query_state *qstate)
-{
-
-	return ((qstate->uid != qstate->euid) || (qstate->gid != qstate->egid) ? -1 : 0);
-}
-
-/*
- * Uses the qstate fields to process an "alternate" read - when the buffer is
- * too large to be received during one socket read operation
- */
-ssize_t
-query_io_buffer_read(struct query_state *qstate, void *buf, size_t nbytes)
-{
-	ssize_t	result;
-
-	TRACE_IN(query_io_buffer_read);
-	if ((qstate->io_buffer_size == 0) || (qstate->io_buffer == NULL))
-		return (-1);
-
-	if (nbytes < qstate->io_buffer + qstate->io_buffer_size -
-			qstate->io_buffer_p)
-		result = nbytes;
-	else
-		result = qstate->io_buffer + qstate->io_buffer_size -
-			qstate->io_buffer_p;
-
-	memcpy(buf, qstate->io_buffer_p, result);
-	qstate->io_buffer_p += result;
-
-	if (qstate->io_buffer_p == qstate->io_buffer + qstate->io_buffer_size) {
-		free(qstate->io_buffer);
-		qstate->io_buffer = NULL;
-
-		qstate->write_func = query_socket_write;
-		qstate->read_func = query_socket_read;
-	}
-
-	TRACE_OUT(query_io_buffer_read);
-	return (result);
-}
-
-/*
- * Uses the qstate fields to process an "alternate" write - when the buffer is
- * too large to be sent during one socket write operation
- */
-ssize_t
-query_io_buffer_write(struct query_state *qstate, const void *buf,
-	size_t nbytes)
-{
-	ssize_t	result;
-
-	TRACE_IN(query_io_buffer_write);
-	if ((qstate->io_buffer_size == 0) || (qstate->io_buffer == NULL))
-		return (-1);
-
-	if (nbytes < qstate->io_buffer + qstate->io_buffer_size -
-			qstate->io_buffer_p)
-		result = nbytes;
-	else
-		result = qstate->io_buffer + qstate->io_buffer_size -
-		qstate->io_buffer_p;
-
-	memcpy(qstate->io_buffer_p, buf, result);
-	qstate->io_buffer_p += result;
-
-	if (qstate->io_buffer_p == qstate->io_buffer + qstate->io_buffer_size) {
-		qstate->use_alternate_io = 1;
-		qstate->io_buffer_p = qstate->io_buffer;
-
-		qstate->write_func = query_socket_write;
-		qstate->read_func = query_socket_read;
-	}
-
-	TRACE_OUT(query_io_buffer_write);
-	return (result);
-}
-
-/*
- * The default "read" function, which reads data directly from socket
- */
-ssize_t
-query_socket_read(struct query_state *qstate, void *buf, size_t nbytes)
-{
-	ssize_t	result;
-
-	TRACE_IN(query_socket_read);
-	if (qstate->socket_failed != 0) {
-		TRACE_OUT(query_socket_read);
-		return (-1);
-	}
-
-	result = read(qstate->sockfd, buf, nbytes);
-	if ((result == -1) || (result < nbytes))
-		qstate->socket_failed = 1;
-
-	TRACE_OUT(query_socket_read);
-	return (result);
-}
-
-/*
- * The default "write" function, which writes data directly to socket
- */
-ssize_t
-query_socket_write(struct query_state *qstate, const void *buf, size_t nbytes)
-{
-	ssize_t	result;
-
-	TRACE_IN(query_socket_write);
-	if (qstate->socket_failed != 0) {
-		TRACE_OUT(query_socket_write);
-		return (-1);
-	}
-
-	result = write(qstate->sockfd, buf, nbytes);
-	if ((result == -1) || (result < nbytes))
-		qstate->socket_failed = 1;
-
-	TRACE_OUT(query_socket_write);
-	return (result);
-}
-
-/*
- * Initializes the query_state structure by filling it with the default values.
- */
-struct query_state *
-init_query_state(int sockfd, size_t kevent_watermark, uid_t euid, gid_t egid)
-{
-	struct query_state	*retval;
-
-	TRACE_IN(init_query_state);
-	retval = (struct query_state *)malloc(sizeof(struct query_state));
-	assert(retval != NULL);
-	memset(retval, 0, sizeof(struct query_state));
-
-	retval->sockfd = sockfd;
-	retval->kevent_filter = EVFILT_READ;
-	retval->kevent_watermark = kevent_watermark;
-
-	retval->euid = euid;
-	retval->egid = egid;
-	retval->uid = retval->gid = -1;
-
-	if (asprintf(&retval->eid_str, "%d_%d_", retval->euid,
-		retval->egid) == -1) {
-		free(retval);
-		return (NULL);
-	}
-	retval->eid_str_length = strlen(retval->eid_str);
-
-	init_comm_element(&retval->request, CET_UNDEFINED);
-	init_comm_element(&retval->response, CET_UNDEFINED);
-	retval->process_func = on_query_startup;
-	retval->destroy_func = on_query_destroy;
-
-	retval->write_func = query_socket_write;
-	retval->read_func = query_socket_read;
-
-	get_time_func(&retval->creation_time);
-	memcpy(&retval->timeout, &s_configuration->query_timeout,
-		sizeof(struct timeval));
-
-	TRACE_OUT(init_query_state);
-	return (retval);
-}
-
-void
-destroy_query_state(struct query_state *qstate)
-{
-
-	TRACE_IN(destroy_query_state);
-	if (qstate->eid_str != NULL)
-	    free(qstate->eid_str);
-
-	if (qstate->io_buffer != NULL)
-		free(qstate->io_buffer);
-
-	qstate->destroy_func(qstate);
-	free(qstate);
-	TRACE_OUT(destroy_query_state);
-}
diff --git a/usr.sbin/cached/query.h b/usr.sbin/cached/query.h
deleted file mode 100644
index 5c4e918..0000000
--- a/usr.sbin/cached/query.h
+++ /dev/null
@@ -1,110 +0,0 @@
-/*-
- * Copyright (c) 2005 Michael Bushkov <bushman@rsu.ru>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * $FreeBSD$
- */
-
-#ifndef __CACHED_QUERY_H__
-#define __CACHED_QUERY_H__
-
-#include <sys/types.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include "cachelib.h"
-#include "config.h"
-#include "protocol.h"
-
-struct query_state;
-struct configuration;
-struct configuration_entry;
-
-typedef	int (*query_process_func)(struct query_state *);
-typedef void (*query_destroy_func)(struct query_state *);
-typedef ssize_t (*query_read_func)(struct query_state *, void *, size_t);
-typedef ssize_t (*query_write_func)(struct query_state *, const void *,
-	size_t);
-
-/*
- * The query state structure contains the information to process all types of
- * requests and to send all types of responses.
- */
-struct query_state {
-	struct timeval creation_time;
-	struct timeval timeout;
-
-	struct comm_element request;
-	struct comm_element response;
-	struct configuration_entry *config_entry;
-	void	*mdata;
-
-	query_process_func process_func;	/* called on each event */
-	query_destroy_func destroy_func;	/* called on destroy */
-
-	/*
-	 * By substituting these functions we can opaquely send and received
-	 * very large buffers
-	 */
-	query_write_func write_func;		/* data write function */
-	query_read_func read_func;		/* data read function */
-
-	char	*eid_str;	/* the user-identifying string (euid_egid_) */
-	size_t	eid_str_length;
-
-	uid_t	euid;	/* euid of the caller, received via getpeereid */
-	uid_t	uid;	/* uid of the caller, received via credentials */
-	gid_t	egid;	/* egid of the caller, received via getpeereid */
-	gid_t	gid;	/* gid of the caller received via credentials */
-
-	size_t	io_buffer_size;
-	size_t	io_buffer_watermark;
-	size_t	kevent_watermark;	/* bytes to be sent/received */
-	int	sockfd;			/* the unix socket to read/write */
-	int	kevent_filter;	/* EVFILT_READ or EVFILT_WRITE */
-	int socket_failed; /* set to 1 if the socket doesn't work correctly */
-
-	/*
-	 * These fields are used to opaquely proceed sending/receiving of
-	 * the large buffers
-	 */
-	char	*io_buffer;
-	char	*io_buffer_p;
-	int	io_buffer_filter;
-	int	use_alternate_io;
-};
-
-extern int check_query_eids(struct query_state *);
-
-extern ssize_t query_io_buffer_read(struct query_state *, void *, size_t);
-extern ssize_t query_io_buffer_write(struct query_state *, const void *,
-	size_t);
-
-extern ssize_t query_socket_read(struct query_state *, void *, size_t);
-extern ssize_t query_socket_write(struct query_state *, const void *,
-	size_t);
-
-extern struct query_state *init_query_state(int, size_t, uid_t, gid_t);
-extern void destroy_query_state(struct query_state *);
-
-#endif
diff --git a/usr.sbin/cached/singletons.c b/usr.sbin/cached/singletons.c
deleted file mode 100644
index 669d12b..0000000
--- a/usr.sbin/cached/singletons.c
+++ /dev/null
@@ -1,36 +0,0 @@
-/*-
- * Copyright (c) 2005 Michael Bushkov <bushman@rsu.ru>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- */
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-
-#include "singletons.h"
-
-struct configuration *s_configuration = NULL;
-cache s_cache = INVALID_CACHE;
-struct runtime_env *s_runtime_env = NULL;
-struct agent_table *s_agent_table = NULL;
diff --git a/usr.sbin/cached/singletons.h b/usr.sbin/cached/singletons.h
deleted file mode 100644
index 918519c..0000000
--- a/usr.sbin/cached/singletons.h
+++ /dev/null
@@ -1,47 +0,0 @@
-/*-
- * Copyright (c) 2005 Michael Bushkov <bushman@rsu.ru>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * $FreeBSD$
- */
-
-#ifndef __CACHED_SINGLETONS_H__
-#define __CACHED_SINGLETONS_H__
-
-#include "cachelib.h"
-#include "config.h"
-#include "agent.h"
-
-struct runtime_env {
-	int	queue;
-	int	sockfd;
-	int	finished;	/* for future use */
-};
-
-extern struct configuration *s_configuration;
-extern cache s_cache;
-extern struct runtime_env *s_runtime_env;
-extern struct agent_table *s_agent_table;
-
-#endif