path: root/usr/src/cmd/smbsrv/smbd/smbd_nicmon.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
 */

/*
 * smbd NIC monitor.
 */

#include <sys/types.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <signal.h>
#include <stdio.h>
#include <net/if.h>
#include <net/route.h>
#include <sys/sockio.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <pthread.h>
#include <syslog.h>
#include <smbsrv/libsmb.h>
#include "smbd.h"

#define	SMBD_NICMON_ENABLE	"nicmon_enable"
#define	SMBD_NICMON_THROTTLE	100
#define	SMBD_NICMON_DEBOUNCE	2

extern smbd_t smbd;

static boolean_t smbd_nicmon_enabled = B_TRUE;

/* Use this to stop monitoring */
static int eventpipe_write = -1;

/* Use this to refresh service instance */
static char *smbd_nicmon_caller_fmri = NULL;

static void smbd_nicmon_run_check(void);
static int smbd_nicmon_setup_rtsock(int);
static int smbd_nicmon_needscan(int);
static int smbd_nicmon_setup_eventpipe(int *, int *);
static void *smbd_nicmon_daemon(void *);

/*
 * Start the nic monitor thread.
 */
int
smbd_nicmon_start(const char *svc_fmri)
{
	pthread_t	smbd_nicmon_tid;
	int		rc;

	if (smb_nic_init() != SMB_NIC_SUCCESS)
		return (-1);

	rc = pthread_create(&smbd_nicmon_tid, NULL, smbd_nicmon_daemon, NULL);
	if (rc != 0)
		return (-1);

	if (svc_fmri)
		smbd_nicmon_caller_fmri = (char *)svc_fmri;

	smbd_nicmon_run_check();
	return (0);
}

void
smbd_nicmon_stop(void)
{
	uchar_t buf = 1;

	if (eventpipe_write < 0)
		return;

	(void) write(eventpipe_write, &buf, sizeof (buf));
	smbd_nicmon_caller_fmri = NULL;
	smb_nic_fini();
}

int
smbd_nicmon_refresh(void)
{
	if (smb_nic_init() != SMB_NIC_SUCCESS)
		return (-1);

	smbd_nicmon_run_check();
	return (0);
}

/*
 * The monitor is enabled unless it is explicitly
 * disabled by setting smbd/nicmon_enable to false.
 * smbd/nicmon_enable is not defined by default.
 */
static void
smbd_nicmon_run_check(void)
{
	smb_scfhandle_t	*hd;
	uint8_t		status;
	int		rc;

	smbd_nicmon_enabled = B_TRUE;

	if ((hd = smb_smf_scf_init(SMBD_FMRI_PREFIX)) == NULL) {
		syslog(LOG_DEBUG,
		    "smbd_nicmon: smb_smf_scf_init failed");
		return;
	}

	rc = smb_smf_create_service_pgroup(hd, SMBD_PG_NAME);
	if (rc != SMBD_SMF_OK) {
		smb_smf_scf_fini(hd);
		syslog(LOG_DEBUG,
		    "smbd_nicmon: smb_smf_create_service_pgroup failed");
		return;
	}

	rc = smb_smf_get_boolean_property(hd, SMBD_NICMON_ENABLE, &status);
	if (rc == SMBD_SMF_OK && status == 0)
		smbd_nicmon_enabled = B_FALSE;

	smb_smf_scf_fini(hd);
}

/*
 * Setup routing socket for getting RTM messages.
 */
static int
smbd_nicmon_setup_rtsock(int af)
{
	int sd;
	int flags;

	if ((sd = socket(PF_ROUTE, SOCK_RAW, af)) == -1) {
		syslog(LOG_ERR,
		    "smbd_nicmon: routing socket failed: %d", errno);
		return (-1);
	}

	if ((flags = fcntl(sd, F_GETFL, 0)) < 0) {
		syslog(LOG_ERR,
		    "smbd_nicmon: fcntl F_GETFL failed: %d", errno);
		(void) close(sd);
		return (-1);
	}

	if ((fcntl(sd, F_SETFL, flags | O_NONBLOCK)) < 0) {
		syslog(LOG_ERR,
		    "smbd_nicmon: fcntl F_SETFL failed: %d", errno);
		(void) close(sd);
		return (-1);
	}

	return (sd);
}

static int
smbd_nicmon_needscan(int sock)
{
	static uint32_t		throttle;
	struct rt_msghdr	*rtm;
	int64_t			msg[2048 / 8];
	int			need_if_scan = 0;
	int			nbytes;

	/* Read as many messages as possible and try to empty the sockets */
	for (;;) {
		nbytes = read(sock, msg, sizeof (msg));
		if (nbytes <= 0)
			break;

		rtm = (struct rt_msghdr *)msg;
		if (rtm->rtm_version != RTM_VERSION)
			continue;

		if (nbytes < rtm->rtm_msglen) {
			if ((throttle % SMBD_NICMON_THROTTLE) == 0) {
				syslog(LOG_DEBUG,
				    "smbd_nicmon: short read: %d of %d",
				    nbytes, rtm->rtm_msglen);
			}
			++throttle;
			continue;
		}

		switch (rtm->rtm_type) {
		case RTM_NEWADDR:
		case RTM_DELADDR:
		case RTM_IFINFO:
			need_if_scan = 1;
			break;
		default:
			break;
		}
	}

	return (need_if_scan);
}

/*
 * Create pipe for signal delivery and set up signal handlers.
 */
static int
smbd_nicmon_setup_eventpipe(int *read_pipe, int *write_pipe)
{
	int fds[2];

	if ((pipe(fds)) < 0) {
		syslog(LOG_ERR,
		    "smbd_nicmon: event pipe failed: %d", errno);
		return (-1);
	}

	*read_pipe = fds[0];
	*write_pipe = fds[1];
	return (0);
}

/*
 * Create the global routing socket to monitor changes in NIC interfaces.
 * We are only interested in new inerface addition/deletion and changes
 * in UP/DOWN status.
 *
 * Note: only supports AF_INET routing socket.  Need to add AF_INET6 to
 * support IPv6.
 */
/*ARGSUSED*/
static void *
smbd_nicmon_daemon(void *arg)
{
	static uint32_t	throttle;
	static int	rtsock_v4;
	static int	eventpipe_read = -1;
	struct pollfd	pollfds[2];
	int		pollfd_num = 2;
	int		i, nic_changed;
	int		rc;

	if ((rtsock_v4 = smbd_nicmon_setup_rtsock(AF_INET)) == -1)
		return (NULL);

	rc = smbd_nicmon_setup_eventpipe(&eventpipe_read, &eventpipe_write);
	if (rc != 0)
		return (NULL);

	/*
	 * Listen for activity on any of the sockets.
	 * The delay before checking the rtsock will hopefully
	 * smooth things out when there is a lot of activity.
	 */
	for (;;) {
		errno = 0;
		nic_changed = 0;
		pollfds[0].fd = rtsock_v4;
		pollfds[0].events = POLLIN;
		pollfds[1].fd = eventpipe_read;
		pollfds[1].events = POLLIN;

		if (poll(pollfds, pollfd_num, -1) < 0) {
			if (errno == EINTR)
				continue;
			if ((throttle % SMBD_NICMON_THROTTLE) == 0)
				syslog(LOG_DEBUG,
				    "smbd_nicmon: poll failed: %d", errno);
			++throttle;
			break;
		}

		for (i = 0; i < pollfd_num; i++) {
			if ((pollfds[i].fd < 0) ||
			    !(pollfds[i].revents & POLLIN))
				continue;
			if (pollfds[i].fd == rtsock_v4) {
				(void) sleep(SMBD_NICMON_DEBOUNCE);
				nic_changed = smbd_nicmon_needscan(rtsock_v4);
			}
			if (pollfds[i].fd == eventpipe_read)
				goto done;
		}

		/*
		 * If the monitor is enabled and something has changed,
		 * refresh the registered SMF service.
		 */
		if (smbd_nicmon_enabled && nic_changed &&
		    smbd_nicmon_caller_fmri) {
			if (smf_refresh_instance(smbd_nicmon_caller_fmri) != 0)
				syslog(LOG_ERR,
				    "smbd_nicmon: %s refresh failed",
				    smbd_nicmon_caller_fmri);
		}
	}
done:
	(void) close(rtsock_v4);
	(void) close(eventpipe_read);
	(void) close(eventpipe_write);
	eventpipe_write = -1;
	return (NULL);
}