@@ -76,10 +76,12 @@ void *clamukoth(void *arg)

     /* ignore all signals except SIGUSR1 */

     sigfillset(&sigset);

     sigdelset(&sigset, SIGUSR1);

+    sigdelset(&sigset, SIGSEGV);

     pthread_sigmask(SIG_SETMASK, &sigset, NULL);

     act.sa_handler = clamuko_exit;

     sigfillset(&(act.sa_mask));

     sigaction(SIGUSR1, &act, NULL);

+    sigaction(SIGSEGV, &act, NULL);

 #ifdef C_LINUX

     logg("*Clamuko: Started in process %d\n", getpid());

deleted file mode 100644

@@ -1,58 +0,0 @@

-/* Dazuko. Allow file access control for 3rd-party applications.

-   Copyright (C) 2002 H+BEDV Datentechnik GmbH

-   Written by Martin Ritter <mritter@antivir.de>

-              John Ogness <jogness@antivir.de>

-

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

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

-   as published by the Free Software Foundation; either version 2

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

-

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

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

-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

-   GNU General Public License for more details.

-

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

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

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

-*/

-

-#ifdef CLAMUKO

-

-#ifndef DAZUKO_H

-#define DAZUKO_H

-

-//#define VERSION				"1.1.0"

-#define	DEVICE_NAME			"dazuko"

-#define DAZUKO_FILENAME_MAX_LENGTH	4095

-

-/* ioctl values */

-#define	IOCTL_SET_OPTION	0

-#define	IOCTL_GET_AN_ACCESS	1

-#define	IOCTL_RETURN_ACCESS	2

-

-/* event types */

-#define	ON_OPEN			1

-#define	ON_CLOSE		2

-#define	ON_EXEC 		4

-

-struct access_t

-{

-	int	deny;		/* set to deny file access */

-	int	event;		/* ON_OPEN, etc */

-	int	o_flags;	/* access flags */

-	int	o_mode;		/* access mode */

-	int	uid;		/* user id */

-	int	pid;		/* user process id */

-	char	filename[DAZUKO_FILENAME_MAX_LENGTH];	/* accessed file */

-};

-

-/* various set option commands */

-#define SET_ACCESS_MASK		0

-#define ADD_INCLUDE_PATH	1

-#define ADD_EXCLUDE_PATH	2

-#define REMOVE_ALL_PATHS	4

-

-#endif

-#endif

new file mode 100644

@@ -0,0 +1,237 @@

+#if HAVE_CONFIG_H

+#include "clamav-config.h"

+#endif

+

+#ifdef CLAMUKO

+

+/* DazukoXP. Allow cross platform file access control for 3rd-party applications.

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

+*/

+

+#ifndef DAZUKO_XP_H

+#define DAZUKO_XP_H

+

+#define VERSION	"2.0.0"

+

+#include "dazukoio_xp.h"

+

+/* various requests */

+#define SET_ACCESS_MASK		0

+#define ADD_INCLUDE_PATH	1

+#define ADD_EXCLUDE_PATH	2

+#define REGISTER		3

+#define REMOVE_ALL_PATHS	4

+#define UNREGISTER		5

+#define GET_AN_ACCESS		6

+#define RETURN_AN_ACCESS	7

+

+/* slot states */

+#define	DAZUKO_FREE	0	/* the daemon is not ready */

+#define	DAZUKO_READY	1	/* a daemon waits for something to do */

+#define	DAZUKO_WAITING	2	/* a request is waiting to be served */

+#define	DAZUKO_WORKING	3	/* daemon is currently in action */

+#define	DAZUKO_DONE	4	/* daemon response is available */

+#define	DAZUKO_BROKEN	5	/* invalid state (interrupt from ready,waiting) */

+

+

+/*********************************************************

+ * structures that MUST be implemented by platform-layer *

+ *********************************************************/

+

+/*

+struct xp_file;

+struct xp_mutex;

+struct xp_atomic;

+struct xp_file_struct;

+struct xp_queue;

+struct xp_rwlock;

+*/

+

+

+/******************************************

+ * structures available to platform-layer *

+ ******************************************/

+

+struct daemon_id

+{

+	int	pid;

+	int	unique;

+};

+

+struct event_properties

+{

+	int	flags;

+	char	set_flags;

+	int	mode;

+	char	set_mode;

+	int	uid;

+	char	set_uid;

+	int	pid;

+	char	set_pid;

+};

+

+struct file_properties

+{

+	unsigned long	size;

+	char		set_size;

+	int		uid;

+	char		set_uid;

+	int		gid;

+	char		set_gid;

+	int		mode;

+	char		set_mode;

+	int		device_type;

+	char		set_device_type;

+};

+

+struct slot

+{

+	/* A representation of a daemon. It holds

+	 * all information about the daemon, the

+	 * file that is scanned, and the state of

+	 * the scanning process. */

+

+	int			id;		

+	struct daemon_id	did;		/* identifier for our daemon */

+	int			write_mode;

+	int			state;

+	int			response;

+	int			event;

+	int			filenamelength;	/* not including terminator */

+	char			*filename;

+	struct event_properties	event_p;

+	struct file_properties	file_p;

+	struct xp_mutex		mutex;

+};

+

+struct dazuko_file_struct

+{

+	/* A structure designed for simple and

+	 * intelligent memory management when

+	 * doing filename lookups in the kernel. */

+

+	int			should_scan;		/* already know we need to scan? */

+	char			*filename;		/* filename */

+	int			filename_length;	/* length of filename */

+	struct file_properties	file_p;			/* properties of file */

+	struct xp_file_struct	*extra_data;		/* extra platform-dependant data */

+};

+

+

+/********************************************************

+ * functions that MUST be implemented by platform-layer *

+ ********************************************************/

+

+/* mutex */

+int xp_init_mutex(struct xp_mutex *mutex);

+int xp_down(struct xp_mutex *mutex);

+int xp_up(struct xp_mutex *mutex);

+int xp_destroy_mutex(struct xp_mutex *mutex);

+

+/* read-write lock */

+int xp_init_rwlock(struct xp_rwlock *rwlock);

+int xp_write_lock(struct xp_rwlock *rwlock);

+int xp_write_unlock(struct xp_rwlock *rwlock);

+int xp_read_lock(struct xp_rwlock *rlock);

+int xp_read_unlock(struct xp_rwlock *rlock);

+int xp_destroy_rwlock(struct xp_rwlock *rwlock);

+

+/* wait-notify queue */

+int xp_init_queue(struct xp_queue *queue);

+int xp_wait_until_condition(struct xp_queue *queue, int (*cfunction)(void *), void *cparam, int allow_interrupt);

+int xp_notify(struct xp_queue *queue);

+int xp_destroy_queue(struct xp_queue *queue);

+

+/* memory */

+void* xp_malloc(size_t size);

+int xp_free(void *ptr);

+int xp_copyin(const void *user_src, void *kernel_dest, size_t size);

+int xp_copyout(const void *kernel_src, void *user_dest, size_t size);

+int xp_verify_user_writable(const void *user_ptr, size_t size);

+int xp_verify_user_readable(const void *user_ptr, size_t size);

+

+/* path attribute */

+int xp_is_absolute_path(const char *path);

+

+/* atomic */

+int xp_atomic_set(struct xp_atomic *atomic, int value);

+int xp_atomic_inc(struct xp_atomic *atomic);

+int xp_atomic_dec(struct xp_atomic *atomic);

+int xp_atomic_read(struct xp_atomic *atomic);

+

+/* file descriptor */

+int xp_copy_file(struct xp_file *dest, struct xp_file *src);

+int xp_compare_file(struct xp_file *file1, struct xp_file *file2);

+

+/* system hook */

+int xp_sys_hook(void);

+int xp_sys_unhook(void);

+

+/* file structure */

+int xp_file_struct_check(struct dazuko_file_struct *dfs);

+int xp_file_struct_check_cleanup(struct dazuko_file_struct *dfs);

+

+/* output */

+int xp_print(const char *fmt, ...);

+

+/* debug */

+#ifdef DEBUG

+#define DPRINT(fmt) xp_print fmt

+#else

+#define DPRINT(fmt)

+#endif

+

+

+/*****************************************

+ * functions available to platform-layer *

+ *****************************************/

+

+int dazuko_is_our_daemon(int pid);

+int dazuko_get_value(const char *key, const char *string, char **value);

+int dazuko_register_daemon(struct daemon_id *did, const char *reg_name, int string_length, int write_mode);

+int dazuko_unregister_daemon(struct daemon_id *did);

+int dazuko_handle_user_request(struct dazuko_request *user_request, int pid);

+int dazuko_handle_user_request_compat12(void *ptr, int cmd, int pid);

+int get_ready_slot_condition(void *param);

+int dazuko_get_filename_length(char *filename);

+int dazuko_state_error(struct slot *s, int current_state);

+void dazuko_bzero(void *p, int len);

+int dazuko_sys_check(unsigned long event, int daemon_is_allowed, int pid);

+int dazuko_sys_pre(unsigned long event, struct dazuko_file_struct *kfs, struct event_properties *event_p);

+int dazuko_sys_post(unsigned long event, struct dazuko_file_struct *kfs, struct xp_file *file, struct event_properties *event_p);

+int dazuko_init(void);

+int dazuko_exit(void);

+

+#endif

+

+#endif

new file mode 100644

Binary files /dev/null and b/clamd/dazukoio.o differ

new file mode 100644

@@ -0,0 +1,395 @@

+#if HAVE_CONFIG_H

+#include "clamav-config.h"

+#endif

+

+#ifdef CLAMUKO

+

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

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

+

+   Copyright (c) 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_compat12.h"

+

+int dazukoRegister_TS_compat12_wrapper(struct dazuko_id **dazuko_id, const char *groupName)

+{

+	int			ret;

+	struct dazuko_id	*temp_id;

+

+	if (dazuko_id == NULL)

+		return -1;

+

+	temp_id = (struct dazuko_id *)malloc(sizeof(*temp_id));

+	if (temp_id == NULL)

+		return -1;

+

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

+

+	temp_id->device = -1;

+	temp_id->dev_major = -1;

+

+	ret = dazukoRegister_TS_compat12(temp_id, groupName);

+

+	if (ret == 0)

+		*dazuko_id = temp_id;

+	else

+		free(temp_id);

+

+	return ret;

+}

+

+int dazukoRegister_TS_compat12(struct dazuko_id *dazuko, const char *groupName)

+{

+	struct option_compat12	*opt;

+	char			buffer[10];

+	int			err = 0;

+

+	if (dazuko == NULL)

+		return -1;

+

+	if (groupName == NULL)

+		groupName = "_GENERIC";

+

+	if (dazuko->device < 0)

+	{

+

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

+		if (dazuko->device < 0)

+			return -1;

+

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

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

+		{

+			close(dazuko->device);

+			dazuko->device = -1;

+			return -1;

+		}

+		dazuko->dev_major = atoi(buffer);

+	}

+

+	opt = (struct option_compat12 *)malloc(sizeof(struct option_compat12));

+	if (opt == NULL)

+	{

+		close(dazuko->device);

+		dazuko->device = -1;

+		dazuko->dev_major = -1;

+		return -1;

+	}

+

+	memset(opt, 0, sizeof(struct option_compat12));

+

+	opt->command = REGISTER;

+	strncpy(opt->buffer, groupName, sizeof(opt->buffer) - 1);

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

+

+	if (ioctl(dazuko->device, _IOW(dazuko->dev_major, IOCTL_SET_OPTION, void *), opt) != 0)

+	{

+		/* if this fails, it could be a really old version */

+

+		/*

+		close(dazuko->device);

+		dazuko->device = -1;

+		dazuko->dev_major = -1;

+		err = -1;

+		*/

+	}

+

+	free(opt);

+

+	return err;

+}

+

+int dazukoSetAccessMask_TS_compat12(struct dazuko_id *dazuko, unsigned long accessMask)

+{

+	struct option_compat12	*opt;

+	int			err = 0;

+

+	if (dazuko == NULL)

+		return -1;

+

+	if (dazuko->device < 0 || dazuko->dev_major < 0)

+		return -1;

+

+	opt = (struct option_compat12 *)malloc(sizeof(struct option_compat12));

+	if (opt == NULL)

+		return -1;

+

+	memset(opt, 0, sizeof(struct option_compat12));

+

+	opt->command = SET_ACCESS_MASK;

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

+	opt->buffer_length = 1;

+

+	if (ioctl(dazuko->device, _IOW(dazuko->dev_major, IOCTL_SET_OPTION, void *), opt) != 0)

+		err = -1;

+

+	free(opt);

+

+	return err;

+}

+

+int dazuko_set_path_compat12(struct dazuko_id *dazuko, const char *path, int command)

+{

+	struct option_compat12	*opt;

+	int			err = 0;

+

+	if (dazuko == NULL)

+		return -1;

+

+	if (path == NULL)

+		return -1;

+

+	if (dazuko->device < 0 || dazuko->dev_major < 0)

+		return -1;

+

+	opt = (struct option_compat12 *)malloc(sizeof(struct option_compat12));

+	if (opt == NULL)

+		return -1;

+

+	memset(opt, 0, sizeof(struct option_compat12));

+

+	opt->command = command;

+	strncpy(opt->buffer, path, sizeof(opt->buffer) - 1);

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

+

+	if (ioctl(dazuko->device, _IOW(dazuko->dev_major, IOCTL_SET_OPTION, void *), opt) != 0)

+		err = -1;

+

+	free(opt);

+

+	return err;

+}

+

+int dazukoAddIncludePath_TS_compat12(struct dazuko_id *dazuko, const char *path)

+{

+	return dazuko_set_path_compat12(dazuko, path, ADD_INCLUDE_PATH);

+}

+

+int dazukoAddExcludePath_TS_compat12(struct dazuko_id *dazuko, const char *path)

+{

+	return dazuko_set_path_compat12(dazuko, path, ADD_EXCLUDE_PATH);

+}

+

+int dazukoRemoveAllPaths_TS_compat12(struct dazuko_id *dazuko)

+{

+	struct option_compat12	*opt;

+	int			err = 0;

+

+	if (dazuko == NULL)

+		return -1;

+

+	if (dazuko->device < 0 || dazuko->dev_major < 0)

+		return -1;

+

+	opt = (struct option_compat12 *)malloc(sizeof(struct option_compat12));

+	if (opt == NULL)

+		return -1;

+

+	memset(opt, 0, sizeof(struct option_compat12));

+

+	opt->command = REMOVE_ALL_PATHS;

+	opt->buffer_length = 0;

+

+	if (ioctl(dazuko->device, _IOW(dazuko->dev_major, IOCTL_SET_OPTION, void *), opt) != 0)

+		err = -1;

+

+	free(opt);

+

+	return err;

+

+}

+

+int dazukoGetAccess_TS_compat12_wrapper(struct dazuko_id *dazuko, struct dazuko_access **acc)

+{

+	struct access_compat12	acc_compat12;

+	struct dazuko_access	*temp_acc;

+	int			ret;

+

+	if (acc == NULL)

+		return -1;

+

+	*acc = NULL;

+

+	temp_acc = (struct dazuko_access *)malloc(sizeof(*temp_acc));

+	if (temp_acc == NULL)

+		return -1;

+

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

+

+	ret = dazukoGetAccess_TS_compat12(dazuko, &acc_compat12);

+

+	if (ret == 0)

+	{

+		temp_acc->deny = acc_compat12.deny;

+		temp_acc->event = acc_compat12.event;

+		temp_acc->set_event = 1;

+		temp_acc->flags = acc_compat12.o_flags;

+		temp_acc->set_flags = 1;

+		temp_acc->mode = acc_compat12.o_mode;

+		temp_acc->set_mode = 1;

+		temp_acc->uid = acc_compat12.uid;

+		temp_acc->set_uid = 1;

+		temp_acc->pid = acc_compat12.pid;

+		temp_acc->set_pid = 1;

+		temp_acc->filename = strdup(acc_compat12.filename);

+		temp_acc->set_filename = 1;

+

+		*acc = temp_acc;

+	}

+	else

+	{

+		free(temp_acc);

+	}

+

+	return ret;

+}

+

+int dazukoGetAccess_TS_compat12(struct dazuko_id *dazuko, struct access_compat12 *acc)

+{

+	if (dazuko == NULL)

+		return -1;

+

+	if (acc == NULL)

+		return -1;

+

+	if (dazuko->device < 0 || dazuko->dev_major < 0)

+		return -1;

+

+	memset(acc, 0, sizeof(struct access_compat12));

+

+	if (ioctl(dazuko->device, _IOR(dazuko->dev_major, IOCTL_GET_AN_ACCESS, struct access_compat12 *), acc) != 0)

+		return -1;

+

+	return 0;

+}

+

+int dazukoReturnAccess_TS_compat12_wrapper(struct dazuko_id *dazuko, struct dazuko_access **acc, int return_access, int free_access)

+{

+	struct access_compat12	acc_compat12;

+	int			ret = 0;

+

+	if (acc == NULL)

+		return -1;

+

+	if (*acc == NULL)

+		return -1;

+

+	if (return_access)

+	{

+		memset(&acc_compat12, 0, sizeof(acc_compat12));

+

+		acc_compat12.deny = (*acc)->deny;

+		acc_compat12.event = (*acc)->event;

+		acc_compat12.o_flags = (*acc)->flags;

+		acc_compat12.o_mode = (*acc)->mode;

+		acc_compat12.uid = (*acc)->uid;

+		acc_compat12.pid = (*acc)->pid;

+		if ((*acc)->filename != NULL)

+		{

+			strncpy(acc_compat12.filename, (*acc)->filename, sizeof(acc_compat12.filename) - 1);

+			acc_compat12.filename[sizeof(acc_compat12.filename) - 1] = 0;

+		}

+

+		ret = dazukoReturnAccess_TS_compat12(dazuko, &acc_compat12);

+	}

+

+	if (free_access && ret == 0)

+	{

+		if ((*acc)->filename != NULL)

+			free((*acc)->filename);

+		free(*acc);

+		*acc = NULL;

+	}

+

+	return ret;

+}

+

+int dazukoReturnAccess_TS_compat12(struct dazuko_id *dazuko, struct access_compat12 *acc)

+{

+	if (dazuko == NULL)

+		return -1;

+

+	if (acc == NULL)

+		return -1;

+

+	if (dazuko->device < 0 || dazuko->dev_major < 0)

+		return -1;

+

+	if (ioctl(dazuko->device, _IOW(dazuko->dev_major, IOCTL_RETURN_ACCESS, struct access_compat12 *), acc) != 0)

+		return -1;

+

+	return 0;

+}

+

+int dazukoUnregister_TS_compat12_wrapper(struct dazuko_id **dazuko_id)

+{

+	int	ret;

+

+	if (dazuko_id == NULL)

+		return -1;

+

+	ret = dazukoUnregister_TS_compat12(*dazuko_id);

+

+	if (ret == 0)

+	{

+		free(*dazuko_id);

+		*dazuko_id = NULL;

+	}

+

+	return ret;

+}

+

+int dazukoUnregister_TS_compat12(struct dazuko_id *dazuko)

+{

+	int		error = -1;

+

+	if (dazuko == NULL)

+		return -1;

+

+	if (dazuko->device >= 0)

+		error = close(dazuko->device);

+

+	dazuko->device = -1;

+	dazuko->dev_major = -1;

+

+	return error;

+}

+

+#endif

new file mode 100644

@@ -0,0 +1,63 @@

+#if HAVE_CONFIG_H

+#include "clamav-config.h"

+#endif

+

+#ifdef CLAMUKO

+

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

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

+

+   Copyright (c) 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.

+*/

+

+#ifndef DAZUKOIO_COMPAT12_H

+#define DAZUKOIO_COMPAT12_H

+

+#include "dazukoio_xp.h"

+#include "dazukoio.h"

+

+int dazukoRegister_TS_compat12_wrapper(struct dazuko_id **dazuko_id, const char *groupName);

+int dazukoRegister_TS_compat12(struct dazuko_id *dazuko, const char *groupName);

+int dazukoSetAccessMask_TS_compat12(struct dazuko_id *dazuko, unsigned long accessMask);

+int dazuko_set_path_compat12(struct dazuko_id *dazuko, const char *path, int command);

+int dazukoAddIncludePath_TS_compat12(struct dazuko_id *dazuko, const char *path);

+int dazukoAddExcludePath_TS_compat12(struct dazuko_id *dazuko, const char *path);

+int dazukoRemoveAllPaths_TS_compat12(struct dazuko_id *dazuko);

+int dazukoGetAccess_TS_compat12_wrapper(struct dazuko_id *dazuko, struct dazuko_access **acc);

+int dazukoGetAccess_TS_compat12(struct dazuko_id *dazuko, struct access_compat12 *acc);

+int dazukoReturnAccess_TS_compat12_wrapper(struct dazuko_id *dazuko, struct dazuko_access **acc, int return_access, int free_access);

+int dazukoReturnAccess_TS_compat12(struct dazuko_id *dazuko, struct access_compat12 *acc);

+int dazukoUnregister_TS_compat12_wrapper(struct dazuko_id **dazuko_id);

+int dazukoUnregister_TS_compat12(struct dazuko_id *dazuko);

+

+#endif

+

+#endif

new file mode 100644

Binary files /dev/null and b/clamd/dazukoio_compat12.o differ

new file mode 100644

@@ -0,0 +1,100 @@

+/* DazukoXP 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.

+*/

+

+#ifndef DAZUKOIO_XP_H

+#define DAZUKOIO_XP_H

+

+/* various requests */

+#define SET_ACCESS_MASK		0

+#define ADD_INCLUDE_PATH	1

+#define ADD_EXCLUDE_PATH	2

+#define REGISTER		3

+#define REMOVE_ALL_PATHS	4

+#define UNREGISTER		5

+#define GET_AN_ACCESS		6

+#define RETURN_AN_ACCESS	7

+

+/* this is just a large number to "guarentee"

+   to contain the full filename */

+#define DAZUKO_FILENAME_MAX_LENGTH	6144

+

+/* this is the hard-limit file length restriction from

+   the 1.x series */

+#define DAZUKO_FILENAME_MAX_LENGTH_COMPAT12	4095

+

+struct dazuko_request

+{

+	char	type[2];

+	int	buffer_size;

+	char	*buffer;

+	int	reply_buffer_size;

+	char	*reply_buffer;

+	int	reply_buffer_size_used;

+};

+

+struct dazuko_id

+{

+	int	device;

+	int	dev_major;

+	int	id;

+	int	write_mode;

+};

+

+/* compat12 ioctls */

+

+#define	IOCTL_SET_OPTION	0

+#define	IOCTL_GET_AN_ACCESS	1

+#define	IOCTL_RETURN_ACCESS	2

+

+/* compat12 structures */

+

+struct access_compat12

+{

+	int	deny;		/* set to deny file access */

+	int	event;		/* ON_OPEN, etc */

+	int	o_flags;	/* access flags */

+	int	o_mode;		/* access mode */

+	int	uid;		/* user id */

+	int	pid;		/* user process id */

+	char	filename[DAZUKO_FILENAME_MAX_LENGTH_COMPAT12];	/* accessed file */

+};