Admin Control Panel v2.0

✎ Editing: kavsamba_common.c ← Back

/*  
 * $Id:
 *
 * This source file is a part of a Kaspersky Antivirus For Samba Servers.
 * Copyright (C) Kaspersky Lab, 1997-2004
 * See License.txt for details
 *
 */

#include "includes.h"

// Samba project tends to remove global includes since api version 28
#if defined SMB_VFS_INTERFACE_VERSION && SMB_VFS_INTERFACE_VERSION > 27
#include "auth.h"
#include "smbd/globals.h"
#include "system/syslog.h"
#endif

#if defined SMB_VFS_INTERFACE_VERSION && SMB_VFS_INTERFACE_VERSION >= 30
#include "../lib/tsocket/tsocket.h"
#endif

#include "kavsamba_common.h"
#include "oas/small/protocol_request.h"
#include "oas/small/protocol_handler.h"
#include "oas/small/protocol_transport_impl.h"
#include "oas/small/protocol_transport_oper.h"
#include "oas/small/protocol_alloc.h"

samba_conn daemon_connect = {filename: NULL, sock: -1, dir_in_open: 0};
struct connection_struct* smbd_connect;

#if defined SMB_VFS_INTERFACE_VERSION && SMB_VFS_INTERFACE_VERSION < 9
extern fstring remote_machine;
static const char * get_remote_machine_name(void)
{
	return remote_machine;
}
#endif

static ProtocolCallbacks  remote_callbacks = 
{
		check_file:		NULL,
		notify_file:	NULL,
		samba_connect:	NULL,
		check_file_result:	samba_file_checked,
		shutdown:		NULL
};

static TransportBuffer snd_data;
static TransportBuffer rcv_data;
void init_stuff()
{
	ProtocolAllocator fm;
	fm.alloc = malloc;
	fm.free = free;
	SetProtocolAllocator(&fm);
	ProtocolCallbacksInit(&remote_callbacks);

TransportBufferInit(&snd_data);
	TransportBufferInit(&rcv_data);
}
//TransportBufferFinit(&snd_data);
//TransportBufferFinit(&rcv_data);

static void handle_error(const char* err_string)
{
	DEBUG(0,(err_string, strerror(errno)));
	syslog(LOG_CRIT, err_string, strerror(errno));
	close(daemon_connect.sock);
	daemon_connect.sock = -1;
}

int kav_connect(void)
{
	struct  sockaddr_un     smb_addr;
	int			err;

DEBUG(2, ("kav_connect uid=%d euid=%d\n", getuid(), geteuid()));
	
	if (!smbd_connect) return 0;

daemon_connect.sock = socket(AF_UNIX,SOCK_STREAM,0);
	memset((char *)&smb_addr, 0, sizeof(smb_addr));

smb_addr.sun_family=AF_UNIX;
	strncpy(smb_addr.sun_path,smb_default_sock,sizeof(smb_addr.sun_path));
	err = connect(daemon_connect.sock,(struct sockaddr *)&smb_addr,sizeof(smb_addr));

if (err)
	{
		handle_error("Can't connect to the kavsamba daemon(err=%s)\n");
		return 0;
	}

#if defined SMB_VFS_INTERFACE_VERSION && SMB_VFS_INTERFACE_VERSION <= 22
	const char* user = smbd_connect->user;
#else
	const char* user = get_current_username();
#endif

#if defined SMB_VFS_INTERFACE_VERSION && SMB_VFS_INTERFACE_VERSION <= 27
	const char* addr = smbd_connect->client_address;
#elif defined SMB_VFS_INTERFACE_VERSION && SMB_VFS_INTERFACE_VERSION == 28
	const char* addr = smbd_connect->sconn ? smbd_connect->sconn->client_id.addr : NULL;
#elif defined SMB_VFS_INTERFACE_VERSION && SMB_VFS_INTERFACE_VERSION >= 30
	const char* addr = smbd_connect->sconn ? tsocket_address_inet_addr_string(smbd_connect->sconn->remote_address, talloc_tos()) : NULL;
#endif

DEBUG(2, ("Sending fd %d user %s addr %s host %s\n", daemon_connect.sock, user, 
		addr, get_remote_machine_name()));
	PackedBuffer packet = MakeSambaConnectReq(daemon_connect.sock,
		user, addr, get_remote_machine_name());
	TransportBufferAddPacket(&snd_data, &packet);
	FinitPackedBuffer(&packet);
#if defined SMB_VFS_INTERFACE_VERSION && SMB_VFS_INTERFACE_VERSION >= 30
	TALLOC_FREE(addr);
#endif
	if (SendBuffer(daemon_connect.sock, &snd_data) == -1)
	{
		handle_error("Can't send data to the kavsamba daemon(err=%s)\n");
		return 0;
	}
	return 1;
}

int kav_connected()
{
	if (daemon_connect.sock == -1) return 0;
	return 1;
}

void free_daemon( samba_conn * conn)
{
	conn->sock = -1;
	conn->check_result = FILE_ACCESS_DENY;
	conn->file_result = FILE_ACCESS_DENY;
	conn->flags = 0;
	conn->written = 0;
	conn->last_open = 0;
}

int kav_disconnect(void)
{
	close(daemon_connect.sock);
	free_daemon(&daemon_connect);
	return 1;
}

enum FileAccessType kav_check_file(const char* filename, enum FileOpType file_op, int flags, dev_t dev, ino_t ino)
{
	int	reconnect = 0;
	if (!smbd_connect) return FILE_ACCESS_DENY;

again:
	if (daemon_connect.sock == -1)
	{
		if (!kav_connect()) return FILE_ACCESS_DENY;
	}

daemon_connect.check_result = FILE_ACCESS_DENY;

#if defined SMB_VFS_INTERFACE_VERSION && SMB_VFS_INTERFACE_VERSION <= 22
	uid_t uid = smbd_connect->uid;
	gid_t gid = smbd_connect->gid;
#elif defined SMB_VFS_INTERFACE_VERSION && SMB_VFS_INTERFACE_VERSION <= 27
	uid_t uid = smbd_connect->server_info->utok.uid;
	gid_t gid = smbd_connect->server_info->utok.gid;
#elif defined SMB_VFS_INTERFACE_VERSION && SMB_VFS_INTERFACE_VERSION == 28
	uid_t uid = smbd_connect->session_info->utok.uid;
	gid_t gid = smbd_connect->session_info->utok.gid;
#else
	uid_t uid = smbd_connect->session_info->unix_token->uid;
	gid_t gid = smbd_connect->session_info->unix_token->gid;
#endif

//	DEBUG(2, ("Sending fd %d uid %d pid %d filename %s file_op %d flags %d dev %lld ino %lld host %s\n", daemon_connect.sock, 
//		uid, getpid(), filename, file_op, flags, dev, ino, get_remote_machine_name()));
	PackedBuffer packet = MakeCheckFileReqHost(uid, gid, getpid(), daemon_connect.sock,
		filename, file_op, flags, dev, ino, get_remote_machine_name());
	TransportBufferAddPacket(&snd_data, &packet);
	FinitPackedBuffer(&packet);
	if (SendBuffer(daemon_connect.sock, &snd_data) == -1)
	{
		kav_disconnect();
		reconnect++;
		if (reconnect<2) goto again;

handle_error("Can't send data to the kavsamba daemon(err=%s)\n");
		return FILE_ACCESS_DENY;
	}

TransportBufferEntry answer;
	do
	{
		if (ReceiveData(daemon_connect.sock, &rcv_data) == -1)
		{
			kav_disconnect();
			reconnect++;
			if (reconnect<2) goto again;

handle_error("Can't receive data from the kavsamba daemon(err=%s)\n");
			return FILE_ACCESS_DENY;
		}
	} while (!TransportBufferGetNextPacket(&rcv_data, &answer));
	ProtocolData* answer_packet = (ProtocolData*)answer.begin;
	ProcessProtocolRequest(answer_packet, NULL);

return daemon_connect.check_result;
}

enum FileAccessType kav_notify_file(const char * filename, enum FileNotifyType file_op, dev_t dev, ino_t ino)
{
	int	reconnect = 0;
	if (!smbd_connect) return FILE_ACCESS_DENY;

again:
	if (daemon_connect.sock == -1)
	{
		if (!kav_connect()) return FILE_ACCESS_DENY;
	}

//	DEBUG(2, ("Sending fd %d filename %s file_op %d dev %lld ino %lld\n", daemon_connect.sock, 
//		filename, file_op, dev, ino));
	PackedBuffer packet;
    if(MakeNotifyFileReq(&packet, filename, file_op, dev, ino)) {
    	TransportBufferAddPacket(&snd_data, &packet);
    	FinitPackedBuffer(&packet);
    }
	if (SendBuffer(daemon_connect.sock, &snd_data) == -1)
	{
		kav_disconnect();
		reconnect++;
		if (reconnect<2) goto again;

handle_error("Can't send data to the kavsamba daemon(err=%s)\n");
		return FILE_ACCESS_DENY;
	}
	
    return FILE_ACCESS_ACCEPT;
}

void samba_file_checked(void* context, const CheckFileResultInfoData* data)
{
	DEBUG(2, ("Got answer file_checked = %d\n", data->result));
	daemon_connect.check_result = data->result;
}

Cancel