@@ -1,3 +1,8 @@

+Sun Feb 29 18:28:22 CET 2004 (tk)

+---------------------------------

+  * clamd, configure: enabled support for on-access scanning under Linux and

+		      FreeBSD. Tested with Dazuko 2.0.0.

+

 Sat Feb 28 23:06:43 CET 2004 (tk)

 ---------------------------------

   * config parser: fixed segfault with empty argument for numerical option

@@ -81,7 +81,7 @@ dnl there is now a CREATE_PREFIX_TARGET_H in this file as a shorthand for

 dnl PREFIX_CONFIG_H from a target.h file, however w/o the target.h ever created

 dnl (the prefix is a bit different, since we add an extra -target- and -host-)

 dnl 

-dnl @version: $Id: aclocal.m4,v 1.24 2004/02/23 17:24:52 kojm Exp $

+dnl @version: $Id: aclocal.m4,v 1.25 2004/02/29 17:29:09 kojm Exp $

 dnl @author Guido Draheim <guidod@gmx.de>                 STATUS: used often

 AC_DEFUN([AC_CREATE_TARGET_H],

@@ -4041,7 +4041,7 @@ dnl      AC_COMPILE_CHECK_SIZEOF(ptrdiff_t, $headers)

 dnl      AC_COMPILE_CHECK_SIZEOF(off_t, $headers)

 dnl

 dnl @author Kaveh Ghazi <ghazi@caip.rutgers.edu>

-dnl @version $Id: aclocal.m4,v 1.24 2004/02/23 17:24:52 kojm Exp $

+dnl @version $Id: aclocal.m4,v 1.25 2004/02/29 17:29:09 kojm Exp $

 dnl

 AC_DEFUN([AC_COMPILE_CHECK_SIZEOF],

 [changequote(<<, >>)dnl

@@ -42,9 +42,12 @@ clamd_SOURCES = \

     others.h \

     clamuko.c \

     clamuko.h \

-    dazuko.h \

+    dazukoio_compat12.c \

+    dazukoio_compat12.h \

     dazukoio.c \

     dazukoio.h \

+    dazuko_xp.h \

+    dazukoio_xp.h \

     tests.c \

     tests.h

@@ -141,9 +141,12 @@ install_sh = @install_sh@

 @BUILD_CLAMD_TRUE@    others.h \

 @BUILD_CLAMD_TRUE@    clamuko.c \

 @BUILD_CLAMD_TRUE@    clamuko.h \

-@BUILD_CLAMD_TRUE@    dazuko.h \

+@BUILD_CLAMD_TRUE@    dazukoio_compat12.c \

+@BUILD_CLAMD_TRUE@    dazukoio_compat12.h \

 @BUILD_CLAMD_TRUE@    dazukoio.c \

 @BUILD_CLAMD_TRUE@    dazukoio.h \

+@BUILD_CLAMD_TRUE@    dazuko_xp.h \

+@BUILD_CLAMD_TRUE@    dazukoio_xp.h \

 @BUILD_CLAMD_TRUE@    tests.c \

 @BUILD_CLAMD_TRUE@    tests.h

@@ -166,8 +169,8 @@ PROGRAMS = $(sbin_PROGRAMS)

 @BUILD_CLAMD_TRUE@	localserver.$(OBJEXT) session.$(OBJEXT) \

 @BUILD_CLAMD_TRUE@	thrmgr.$(OBJEXT) server-th.$(OBJEXT) \

 @BUILD_CLAMD_TRUE@	scanner.$(OBJEXT) others.$(OBJEXT) \

-@BUILD_CLAMD_TRUE@	clamuko.$(OBJEXT) dazukoio.$(OBJEXT) \

-@BUILD_CLAMD_TRUE@	tests.$(OBJEXT)

+@BUILD_CLAMD_TRUE@	clamuko.$(OBJEXT) dazukoio_compat12.$(OBJEXT) \

+@BUILD_CLAMD_TRUE@	dazukoio.$(OBJEXT) tests.$(OBJEXT)

 clamd_OBJECTS = $(am_clamd_OBJECTS)

 @BUILD_CLAMD_TRUE@clamd_DEPENDENCIES = ../clamscan/getopt.o

 @BUILD_CLAMD_FALSE@clamd_DEPENDENCIES =

@@ -179,6 +182,7 @@ depcomp = $(SHELL) $(top_srcdir)/depcomp

 am__depfiles_maybe = depfiles

 @AMDEP_TRUE@DEP_FILES = ./$(DEPDIR)/cfgfile.Po ./$(DEPDIR)/clamd.Po \

 @AMDEP_TRUE@	./$(DEPDIR)/clamuko.Po ./$(DEPDIR)/dazukoio.Po \

+@AMDEP_TRUE@	./$(DEPDIR)/dazukoio_compat12.Po \

 @AMDEP_TRUE@	./$(DEPDIR)/localserver.Po ./$(DEPDIR)/options.Po \

 @AMDEP_TRUE@	./$(DEPDIR)/others.Po ./$(DEPDIR)/scanner.Po \

 @AMDEP_TRUE@	./$(DEPDIR)/server-th.Po ./$(DEPDIR)/session.Po \

@@ -246,6 +250,7 @@ distclean-compile:

 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/clamd.Po@am__quote@

 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/clamuko.Po@am__quote@

 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/dazukoio.Po@am__quote@

+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/dazukoio_compat12.Po@am__quote@

 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/localserver.Po@am__quote@

 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/options.Po@am__quote@

 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/others.Po@am__quote@

@@ -37,7 +37,7 @@

 #include "clamuko.h"

 #include "defaults.h"

-struct access_t acc;

+struct dazuko_access *acc;

 void clamuko_exit(int sig)

 {

@@ -45,13 +45,15 @@ void clamuko_exit(int sig)

     logg("*Clamuko: clamuko_exit(), signal %d\n", sig);

     if(clamuko_scanning) {

-	logg("*Clamuko: stopped while scanning %s\n", acc.filename);

-	acc.deny = 0;

+	logg("*Clamuko: stopped while scanning %s\n", acc->filename);

+	acc->deny = 0;

 	dazukoReturnAccess(&acc); /* is it needed ? */

     }

-    dazukoUnregister();

-    clamuko_running = 0;

+    if(dazukoUnregister())

+	logg("!Can't unregister with Dazuko\n");

+

+    /* clamuko_running = 0; */

     logg("Clamuko stopped.\n");

 }

@@ -68,7 +70,7 @@ void *clamukoth(void *arg)

 	struct stat sb;

-    clamuko_running = 1;

+    /* clamuko_running = 1; */

     clamuko_scanning = 0;

     /* ignore all signals except SIGUSR1 */

@@ -84,9 +86,9 @@ void *clamukoth(void *arg)

 #endif

     /* register */

-    if(dazukoRegister()) {

+    if(dazukoRegister("ClamAV", "r+")) {

 	logg("!Clamuko: Can't register with Dazuko\n");

-	clamuko_running = 0;

+	/* clamuko_running = 0; */

 	return NULL;

     } else

 	logg("Clamuko: Correctly registered with Dazuko.\n");

@@ -94,35 +96,34 @@ void *clamukoth(void *arg)

     /* access mask */

     if(cfgopt(tharg->copt, "ClamukoScanOnOpen")) {

 	logg("Clamuko: Scan-on-open mode activated.\n");

-	mask |= ON_OPEN;

+	mask |= DAZUKO_ON_OPEN;

     }

     if(cfgopt(tharg->copt, "ClamukoScanOnClose")) {

 	logg("Clamuko: Scan-on-close mode activated.\n");

-	mask |= ON_CLOSE;

+	mask |= DAZUKO_ON_CLOSE;

     }

     if(cfgopt(tharg->copt, "ClamukoScanOnExec")) {

 	logg("Clamuko: Scan-on-exec mode activated.\n");

-	mask |= ON_EXEC;

+	mask |= DAZUKO_ON_EXEC;

     }

     if(!mask) {

 	logg("!Access mask is not configured properly.\n");

-	clamuko_running = 0;

+	/* clamuko_running = 0; */

 	return NULL;

     }

     if(dazukoSetAccessMask(mask)) {

 	logg("!Clamuko: Can't set access mask in Dazuko.\n");

-	clamuko_running = 0;

+	/* clamuko_running = 0; */

 	return NULL;

     }

-

     if((pt = cfgopt(tharg->copt, "ClamukoIncludePath"))) {

 	while(pt) {

 	    if((dazukoAddIncludePath(pt->strarg))) {

 		logg("!Clamuko: Dazuko -> Can't include path %s\n", pt->strarg);

-		clamuko_running = 0;

+		/* clamuko_running = 0; */

 		return NULL;

 	    } else

 		logg("Clamuko: Included path %s\n", pt->strarg);

@@ -131,7 +132,7 @@ void *clamukoth(void *arg)

 	}

     } else {

 	logg("!Clamuko: please include at least one path.\n");

-	clamuko_running = 0;

+	/* clamuko_running = 0; */

 	return NULL;

     }

@@ -139,7 +140,7 @@ void *clamukoth(void *arg)

 	while(pt) {

 	    if((dazukoAddExcludePath(pt->strarg))) {

 		logg("!Clamuko: Dazuko -> Can't exclude path %s\n", pt->strarg);

-		clamuko_running = 0;

+		/* clamuko_running = 0; */

 		return NULL;

 	    } else

 		logg("Clamuko: Excluded path %s\n", pt->strarg);

@@ -179,25 +180,25 @@ void *clamukoth(void *arg)

 	    scan = 1;

 	    if(sizelimit) {

-		stat(acc.filename, &sb);

+		stat(acc->filename, &sb);

 		if(sb.st_size > sizelimit) {

 		    scan = 0;

-		    logg("*Clamuko: %s skipped (too big)\n", acc.filename);

+		    logg("*Clamuko: %s skipped (too big)\n", acc->filename);

 		}

 	    }

-	    if(scan && cl_scanfile(acc.filename, &virname, NULL, tharg->root, tharg->limits, options) == CL_VIRUS) {

-		logg("Clamuko: %s: %s FOUND\n", acc.filename, virname);

-		virusaction(acc.filename, virname, tharg->copt);

-		acc.deny = 1;

+	    if(scan && cl_scanfile(acc->filename, &virname, NULL, tharg->root, tharg->limits, options) == CL_VIRUS) {

+		logg("Clamuko: %s: %s FOUND\n", acc->filename, virname);

+		virusaction(acc->filename, virname, tharg->copt);

+		acc->deny = 1;

 	    } else

-		acc.deny = 0;

+		acc->deny = 0;

 	    if(dazukoReturnAccess(&acc)) {

 		logg("!Can't return access to Dazuko.\n");

 		logg("Clamuko stopped.\n");

 		dazukoUnregister();

-		clamuko_running = 0;

+		/* clamuko_running = 0; */

 		clamuko_scanning = 0;

 		return NULL;

 	    }

@@ -207,7 +208,7 @@ void *clamukoth(void *arg)

     }

     /* can't be ;) */

-    clamuko_running = 0;

+    /* clamuko_running = 0; */

     return NULL;

 }

@@ -21,7 +21,8 @@

 #ifndef __CLAMUKO_H

 #define __CLAMUKO_H

-short int clamuko_running, clamuko_scanning;

+/* short int clamuko_running, clamuko_scanning; */

+short int clamuko_scanning;

 void *clamukoth(void *arg);

 #endif

@@ -1,147 +1,898 @@

-/* Dazuko Interface. Interace with Dazuko for file access control.

-   Copyright (C) 2002 H+BEDV Datentechnik GmbH

-   Written by John Ogness <jogness@antivir.de>

-

-   This library is free software; you can redistribute it and/or

-   modify it under the terms of the GNU Lesser General Public

-   License as published by the Free Software Foundation; either

-   version 2.1 of the License, or (at your option) any later version.

-

-   This library is distributed in the hope that it will be useful,

-   but WITHOUT ANY WARRANTY; without even the implied warranty of

-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

-   Lesser General Public License for more details.

-

-   You should have received a copy of the GNU Lesser General Public

-   License along with this library; if not, write to the Free Software

-   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

-*/

-

 #if HAVE_CONFIG_H

 #include "clamav-config.h"

 #endif

 #ifdef CLAMUKO

+/* Dazuko Interface. Interace with Dazuko for file access control.

+   Written by John Ogness <jogness@antivir.de>

+   Copyright (c) 2002, 2003 H+BEDV Datentechnik GmbH

+   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.

+

+   3. Neither the name of Dazuko nor the names of its contributors may be used

+   to endorse or promote products derived from this software without specific

+   prior written permission.

+

+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT OWNER 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 <stdio.h>

 #include <stdlib.h>

 #include <sys/types.h>

-#include <sys/stat.h>

 #include <fcntl.h>

 #include <string.h>

 #include <unistd.h>

-#include <sys/ioctl.h>

+#include "dazukoio_xp.h"

 #include "dazukoio.h"

-int	_DAZUKO_DEVICE;

-int	_DAZUKO_DEV_MAJOR;

+#if !defined(NO_COMPAT12)

+#include "dazukoio_compat12.h"

+#endif

+

+#define ITOA_SIZE	32

-int dazukoRegister(void)

+dazuko_id_t	*_GLOBAL_DAZUKO = NULL;

+

+#if !defined(NO_COMPAT12)

+char		_GLOBAL_DAZUKO_COMPAT12 = 0;

+#endif

+

+static inline char char_to_hex(char c)

 {

-	char	buffer[10];

+	/* ugly, but fast */

+

+	switch (c)

+	{

+		case '1': return 1;

+		case '2': return 2;

+		case '3': return 3;

+		case '4': return 4;

+		case '5': return 5;

+		case '6': return 6;

+		case '7': return 7;

+		case '8': return 8;

+		case '9': return 9;

+		case 'a': case 'A': return 10;

+		case 'b': case 'B': return 11;

+		case 'c': case 'C': return 12;

+		case 'd': case 'D': return 13;

+		case 'e': case 'E': return 14;

+		case 'f': case 'F': return 15;

+	}

+

+	return 0;

+}

+

+static void unescape_string(char *string)

+{

+	char	*p;

+

+	for (p=string ; *p ; p++)

+	{

+		/* check if we have \x */

+		if ((*p == '\\') && (*(p+1) == 'x'))

+		{

+			/* this is not cheap, but it should not occur often */

+

+			/* check if we have two more values following \x */

+			if (*(p+2) && *(p+3))

+			{

+				*p = char_to_hex(*(p+2));

+				*p <<= 4;

+				*p |= char_to_hex(*(p+3));

+

+				memmove(p + 1, p + 4, strlen(p+4) + 1);

+			}

+		}

+	}

+}

+

+static int get_value(const char *key, const char *string, char *buffer, size_t buffer_size)

+{

+	const char	*p1;

+	const char	*p2;

+	size_t		size;

+

+	if (buffer == NULL || buffer_size < 1)

+		return -1;

+

+	buffer[0] = 0;

-	_DAZUKO_DEVICE = open("/dev/dazuko", 0);

-	if (_DAZUKO_DEVICE < 0)

+	if (key == NULL || string == NULL)

 		return -1;

-	bzero(buffer, sizeof(buffer));

-	if (read(_DAZUKO_DEVICE, buffer, sizeof(buffer)-1) < 1)

+	p1 = strstr(string, key);

+	if (p1 == NULL)

+		return -1;

+

+	p1 += strlen(key);

+

+	for (p2=p1 ; *p2 && *p2!='\n' ; p2++)

+		continue;

+

+	size = p2 - p1;

+	if (size >= buffer_size)

+		size = buffer_size - 1;

+

+	memcpy(buffer, p1, size);

+

+	buffer[size] = 0;

+

+	return 0;

+}

+

+int dazukoRegister(const char *groupName, const char *mode)

+{

+	return dazukoRegister_TS(&_GLOBAL_DAZUKO, groupName, mode);

+}

+

+int dazukoRegister_TS(dazuko_id_t **dazuko_id, const char *groupName, const char *mode)

+{

+	struct dazuko_request	*request;

+	char			buffer[ITOA_SIZE];

+	char			regMode[3];

+	dazuko_id_t		*temp_id;

+	ssize_t			size;

+	int			write_mode = 0;

+#if !defined(NO_COMPAT12)

+	int			compat12_ret;

+#endif

+

+	if (dazuko_id == NULL)

+		return -1;

+

+	/* set default group name if one was not given */

+	if (groupName == NULL)

+		groupName = "_GENERIC";

+

+	/* set default mode if one was not given */

+	if (mode == NULL)

+		mode = "r";

+

+	if (strcasecmp(mode, "r") == 0)

+	{

+		strncpy(regMode, "R", sizeof(regMode));

+		write_mode = 0;

+	}

+	else if (strcasecmp(mode, "r+") == 0 || strcasecmp(mode, "rw") == 0)

+	{

+		strncpy(regMode, "RW", sizeof(regMode));

+		write_mode = 1;

+	}

+	else

 	{

-		close(_DAZUKO_DEVICE);

 		return -1;

 	}

-	_DAZUKO_DEV_MAJOR = atoi(buffer);

+	regMode[sizeof(regMode) - 1] = 0;

+

+#if !defined(NO_COMPAT12)

+	if (_GLOBAL_DAZUKO_COMPAT12)

+	{

+		compat12_ret = dazukoRegister_TS_compat12_wrapper(dazuko_id, groupName);

+

+		if (compat12_ret == 0)

+			(*dazuko_id)->write_mode = write_mode;

+

+		return compat12_ret;

+	}

+#endif

+

+	/* create temporary id */

+	temp_id = (dazuko_id_t *)malloc(sizeof(*temp_id));

+	if (temp_id == NULL)

+		return -1;

+

+	memset(temp_id, 0, sizeof(*temp_id));

+

+	/* open device */

+	temp_id->device = open("/dev/dazuko", O_RDWR);

+	if (temp_id->device < 0)

+	{

+		free(temp_id);

+		return -1;

+	}

+

+	/* read device major number */

+	memset(buffer, 0, sizeof(buffer));

+	if (read(temp_id->device, buffer, sizeof(buffer)-1) < 1)

+	{

+		close(temp_id->device);

+		free(temp_id);

+		return -1;

+	}

+

+	temp_id->dev_major = atoi(buffer);

+	if (temp_id->dev_major < 0)

+	{

+		close(temp_id->device);

+		free(temp_id);

+		return -1;

+	}

+

+	request = (struct dazuko_request *)malloc(sizeof(*request));

+	if (request == NULL)

+	{

+		close(temp_id->device);

+		free(temp_id);

+		return -1;

+	}

+

+	memset(request, 0, sizeof(*request));

+

+	request->type[0] = REGISTER;

+

+	size = 1 + 2 + 1 + strlen(regMode); /* \nRM=mode */

+	size = 1 + 2 + 1 + strlen(groupName); /* \nGN=groupName */

+	size += 1; /* \0 */

+

+	request->buffer = (char *)malloc(size);

+	if (request->buffer == NULL)

+	{

+		close(temp_id->device);

+		free(temp_id);

+		free(request);

+		return -1;

+	}

+	snprintf(request->buffer, size, "\nRM=%s\nGN=%s", regMode, groupName);

+	request->buffer[size - 1] = 0;

+

+	request->buffer_size = strlen(request->buffer) + 1;

+

+	size = 4096;

+	request->reply_buffer = (char *)malloc(size);

+	if (request->reply_buffer == NULL)

+	{

+		close(temp_id->device);

+		free(temp_id);

+		free(request->buffer);

+		free(request);

+		return -1;

+	}

+	memset(request->reply_buffer, 0, size);

+	request->reply_buffer_size = size;

+

+	snprintf(buffer, sizeof(buffer), "\nRA=%lu", (unsigned long)request);

+	buffer[sizeof(buffer)-1] = 0;

+	size = strlen(buffer) + 1;

+

+	if (write(temp_id->device, buffer, size) != size)

+	{

+		close(temp_id->device);

+		free(temp_id);

+		free(request->buffer);

+		free(request->reply_buffer);

+		free(request);

+

+#if !defined(NO_COMPAT12)

+		/* we try compat12 mode */

+		compat12_ret = dazukoRegister_TS_compat12_wrapper(dazuko_id, groupName);

+		if (compat12_ret == 0)

+		{

+			(*dazuko_id)->write_mode = write_mode;

+			_GLOBAL_DAZUKO_COMPAT12 = 1;

+		}

+

+		return compat12_ret;

+#else

+		return -1;

+#endif

+	}

+

+	if (get_value("\nID=", request->reply_buffer, buffer, sizeof(buffer)) != 0)

+	{

+		close(temp_id->device);

+		free(temp_id);

+		free(request->buffer);

+		free(request->reply_buffer);

+		free(request);

+

+#if !defined(NO_COMPAT12)

+		/* we try compat12 mode */

+		compat12_ret = dazukoRegister_TS_compat12_wrapper(dazuko_id, groupName);

+		if (compat12_ret == 0)

+		{

+			(*dazuko_id)->write_mode = write_mode;

+			_GLOBAL_DAZUKO_COMPAT12 = 1;

+		}

+

+		return compat12_ret;

+#else

+		return -1;

+#endif

+	}

+

+	temp_id->id = atoi(buffer);

+

+	if (temp_id->id < 0)

+	{

+		free(request->buffer);

+		free(request->reply_buffer);

+		free(request);

+

+		return -1;

+	}

+

+	temp_id->write_mode = write_mode;

+

+	free(request->buffer);

+	free(request->reply_buffer);

+	free(request);

+

+	*dazuko_id = temp_id;

 	return 0;

 }

 int dazukoSetAccessMask(unsigned long accessMask)

 {

-	struct option_t	opt;

+	return dazukoSetAccessMask_TS(_GLOBAL_DAZUKO, accessMask);

+}

+

+int dazukoSetAccessMask_TS(dazuko_id_t *dazuko_id, unsigned long accessMask)

+{

+	struct dazuko_request	*request;

+	ssize_t			size;

+	char			buffer[ITOA_SIZE];

+

+	if (dazuko_id == NULL)

+		return -1;

+

+#if !defined(NO_COMPAT12)

+	if (_GLOBAL_DAZUKO_COMPAT12)

+		return dazukoSetAccessMask_TS_compat12(dazuko_id, accessMask);

+#endif

+

+	if (dazuko_id->device < 0 || dazuko_id->dev_major < 0 || dazuko_id->id < 0)

+		return -1;

+

+	request = (struct dazuko_request *)malloc(sizeof(*request));

+	if (request == NULL)

+		return -1;

+

+	memset(request, 0, sizeof(*request));

+

+	request->type[0] = SET_ACCESS_MASK;

+

+	size = 1 + 2 + 1 + ITOA_SIZE; /* \nID=id */

+	size += 1 + 2 + 1 + ITOA_SIZE; /* \nAM=accessMask */

+	size += 1; /* \0 */

+

+	request->buffer = (char *)malloc(size);

+	if (request->buffer == NULL)

+	{

+		free(request);

+		return -1;

+	}

+	snprintf(request->buffer, size, "\nID=%d\nAM=%lu", dazuko_id->id, accessMask);

+	request->buffer[size - 1] = 0;

-	bzero(&opt, sizeof(opt));

+	request->buffer_size = strlen(request->buffer) + 1;

-	opt.command = SET_ACCESS_MASK;

-	opt.buffer[0] = (char)accessMask;

-	opt.buffer_length = 1;

+	snprintf(buffer, sizeof(buffer), "\nRA=%lu", (unsigned long)request);

+	buffer[sizeof(buffer)-1] = 0;

+	size = strlen(buffer) + 1;

-	if (ioctl(_DAZUKO_DEVICE, _IOW(_DAZUKO_DEV_MAJOR, IOCTL_SET_OPTION, void *), &opt) != 0)

+	if (write(dazuko_id->device, buffer, size) != size)

+	{

+		free(request->buffer);

+		free(request);

 		return -1;

+	}

+

+	free(request->buffer);

+	free(request);

 	return 0;

 }

-int dazuko_set_path(const char *path, int command)

+static int dazuko_set_path(dazuko_id_t *dazuko_id, const char *path, int type)

 {

-	struct option_t	opt;

+	struct dazuko_request	*request;

+	ssize_t			size;

+	char			buffer[ITOA_SIZE];

+

+	if (dazuko_id == NULL)

+		return -1;

+

+	if (dazuko_id->device < 0 || dazuko_id->dev_major < 0 || dazuko_id->id < 0)

+		return -1;

 	if (path == NULL)

 		return -1;

-	bzero(&opt, sizeof(opt));

+	request = (struct dazuko_request *)malloc(sizeof(*request));

+	if (request == NULL)

+		return -1;

+

+	memset(request, 0, sizeof(*request));

+

+	request->type[0] = type;

-	opt.command = command;

-	strncpy(opt.buffer, path, sizeof(opt.buffer) - 1);

-	opt.buffer_length = strlen(opt.buffer) + 1;

+	size = 1 + 2 + 1 + ITOA_SIZE; /* \nID=id */

+	size += 1 + 2 + 1 + strlen(path); /* \nPT=path */

+	size += 1; /* \0 */

-	if (ioctl(_DAZUKO_DEVICE, _IOW(_DAZUKO_DEV_MAJOR, IOCTL_SET_OPTION, void *), &opt) != 0)

+	request->buffer = (char *)malloc(size);

+	if (request->buffer == NULL)

+	{

+		free(request);

 		return -1;

+	}

+	snprintf(request->buffer, size, "\nID=%d\nPT=%s", dazuko_id->id, path);

+	request->buffer[size - 1] = 0;

+

+	request->buffer_size = strlen(request->buffer) + 1;

+

+	snprintf(buffer, sizeof(buffer), "\nRA=%lu", (unsigned long)request);

+	buffer[sizeof(buffer)-1] = 0;

+	size = strlen(buffer) + 1;

+

+	if (write(dazuko_id->device, buffer, size) != size)

+	{

+		free(request->buffer);

+		free(request);

+		return -1;

+	}

+

+	free(request->buffer);

+	free(request);

 	return 0;

 }

 int dazukoAddIncludePath(const char *path)

 {

-	return dazuko_set_path(path, ADD_INCLUDE_PATH);

+	return dazukoAddIncludePath_TS(_GLOBAL_DAZUKO, path);

+}

+

+int dazukoAddIncludePath_TS(dazuko_id_t *dazuko_id, const char *path)

+{

+#if !defined(NO_COMPAT12)

+	if (_GLOBAL_DAZUKO_COMPAT12)

+		return dazukoAddIncludePath_TS_compat12(dazuko_id, path);

+#endif

+

+	return dazuko_set_path(dazuko_id, path, ADD_INCLUDE_PATH);

 }

 int dazukoAddExcludePath(const char *path)

 {

-	return dazuko_set_path(path, ADD_EXCLUDE_PATH);

+	return dazukoAddExcludePath_TS(_GLOBAL_DAZUKO, path);

+}

+

+int dazukoAddExcludePath_TS(dazuko_id_t *dazuko_id, const char *path)

+{

+#if !defined(NO_COMPAT12)

+	if (_GLOBAL_DAZUKO_COMPAT12)

+		return dazukoAddExcludePath_TS_compat12(dazuko_id, path);

+#endif

+

+	return dazuko_set_path(dazuko_id, path, ADD_EXCLUDE_PATH);

 }

 int dazukoRemoveAllPaths(void)

 {

-	struct option_t	opt;

+	return dazukoRemoveAllPaths_TS(_GLOBAL_DAZUKO);

+}

-	bzero(&opt, sizeof(opt));

+int dazukoRemoveAllPaths_TS(dazuko_id_t *dazuko_id)

+{

+	struct dazuko_request	*request;

+	ssize_t			size;

+	char			buffer[ITOA_SIZE];

+

+	if (dazuko_id == NULL)

+		return -1;

+

+#if !defined(NO_COMPAT12)

+	if (_GLOBAL_DAZUKO_COMPAT12)

+		return dazukoRemoveAllPaths_TS_compat12(dazuko_id);

+#endif

+

+	if (dazuko_id->device < 0 || dazuko_id->dev_major < 0 || dazuko_id->id < 0)

+		return -1;

+

+	request = (struct dazuko_request *)malloc(sizeof(*request));

+	if (request == NULL)

+		return -1;

+

+	memset(request, 0, sizeof(*request));

+

+	request->type[0] = REMOVE_ALL_PATHS;

+

+	size = 1 + 2 + 1 + ITOA_SIZE; /* \nID=id */

+	size += 1; /* \0 */

+

+	request->buffer = (char *)malloc(size);

+	if (request->buffer == NULL)

+	{

+		free(request);

+		return -1;

+	}

+	snprintf(request->buffer, size, "\nID=%d", dazuko_id->id);

+	request->buffer[size - 1] = 0;

-	opt.command = REMOVE_ALL_PATHS;

-	opt.buffer_length = 0;

+	request->buffer_size = strlen(request->buffer) + 1;

-	if (ioctl(_DAZUKO_DEVICE, _IOW(_DAZUKO_DEV_MAJOR, IOCTL_SET_OPTION, void *), &opt) != 0)

+	snprintf(buffer, sizeof(buffer), "\nRA=%lu", (unsigned long)request);

+	buffer[sizeof(buffer)-1] = 0;

+	size = strlen(buffer) + 1;

+

+	if (write(dazuko_id->device, buffer, size) != size)

+	{

+		free(request->buffer);

+		free(request);

 		return -1;

+	}

+

+	free(request->buffer);

+	free(request);

 	return 0;

+}

+int dazukoGetAccess(struct dazuko_access **acc)

+{

+	return dazukoGetAccess_TS(_GLOBAL_DAZUKO, acc);

 }

-int dazukoGetAccess(struct access_t *acc)

+int dazukoGetAccess_TS(dazuko_id_t *dazuko_id, struct dazuko_access **acc)

 {

+	struct dazuko_request	*request;

+	struct dazuko_access	*temp_acc;

+	ssize_t			size;

+	size_t			filename_size;

+	char			buffer[ITOA_SIZE];

+#if !defined(NO_COMPAT12)

+	int			compat12_ret;

+#endif

+

+	if (dazuko_id == NULL)

+		return -1;

+

+#if !defined(NO_COMPAT12)

+	if (_GLOBAL_DAZUKO_COMPAT12)

+	{

+		compat12_ret = dazukoGetAccess_TS_compat12_wrapper(dazuko_id, acc);

+

+		if (compat12_ret == 0 && !(dazuko_id->write_mode))

+		{