/*

 * 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 2008 Sun Microsystems, Inc.  All rights reserved.

 * Use is subject to license terms.

 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include <sys/types.h>

#include <sys/stat.h>

#include <sys/ioccom.h>

#include <stdio.h>

#include <string.h>

#include <strings.h>

#include <stdlib.h>

#include <unistd.h>

#include <stdarg.h>

#include <fcntl.h>

#include <wait.h>

#include <signal.h>

#include <libscf.h>

#include <limits.h>

#include <priv_utils.h>

#include <door.h>

#include <errno.h>

#include <syslog.h>

#include <pthread.h>

#include <time.h>

#include <libscf.h>

#include <zone.h>

#include <tzfile.h>

#include <libgen.h>

#include <pwd.h>

#include <grp.h>

#include <smbsrv/smb_door_svc.h>

#include <smbsrv/smb_ioctl.h>

#include <smbsrv/libsmb.h>

#include <smbsrv/libsmbns.h>

#include <smbsrv/libsmbrdr.h>

#include <smbsrv/libmlsvc.h>

#include "smbd.h"

#define	DRV_DEVICE_PATH	"/devices/pseudo/smbsrv@0:smbsrv"

#define	SMB_VARRUN_DIR "/var/run/smb"

#define	SMB_CCACHE SMB_VARRUN_DIR "/ccache"

#define	SMB_DBDIR "/var/smb"

static int smbd_daemonize_init(void);

static void smbd_daemonize_fini(int, int);

static int smbd_kernel_bind(void);

static void smbd_kernel_unbind(void);

static int smbd_already_running(void);

static void smbd_remove_ccache(void);

static int smbd_service_init(void);

static void smbd_service_fini(void);

static int smbd_setup_options(int argc, char *argv[]);

static void smbd_usage(FILE *fp);

static void smbd_report(const char *fmt, ...);

static void smbd_sig_handler(int sig);

static int smbd_localtime_init(void);

static void *smbd_localtime_monitor(void *arg);

extern time_t altzone;

static pthread_t localtime_thr;

static int smbd_refresh_init(void);

static void smbd_refresh_fini(void);

static void *smbd_refresh_monitor(void *);

static pthread_t refresh_thr;

static pthread_cond_t refresh_cond;

static pthread_mutex_t refresh_mutex;

static smbd_t smbd;

/*

 * smbd user land daemon

 *

 * Use SMF error codes only on return or exit.

 */

int

main(int argc, char *argv[])

{

	struct sigaction act;

	sigset_t set;

	uid_t uid;

	int pfd = -1;

	smbd.s_pname = basename(argv[0]);

	openlog(smbd.s_pname, LOG_PID | LOG_NOWAIT, LOG_DAEMON);

	if (smbd_setup_options(argc, argv) != 0)

		return (SMF_EXIT_ERR_FATAL);

	if ((uid = getuid()) != smbd.s_uid) {

		smbd_report("user %d: %s", uid, strerror(EPERM));

		return (SMF_EXIT_ERR_FATAL);

	}

	if (getzoneid() != GLOBAL_ZONEID) {

		smbd_report("non-global zones are not supported");

		return (SMF_EXIT_ERR_FATAL);

	}

	if (is_system_labeled()) {

		smbd_report("Trusted Extensions not supported");

		return (SMF_EXIT_ERR_FATAL);

	}

	if (smbd_already_running())

		return (SMF_EXIT_OK);

	(void) sigfillset(&set);

	(void) sigdelset(&set, SIGABRT);

	(void) sigfillset(&act.sa_mask);

	act.sa_handler = smbd_sig_handler;

	act.sa_flags = 0;

	(void) sigaction(SIGTERM, &act, NULL);

	(void) sigaction(SIGHUP, &act, NULL);

	(void) sigaction(SIGINT, &act, NULL);

	(void) sigaction(SIGPIPE, &act, NULL);

	(void) sigdelset(&set, SIGTERM);

	(void) sigdelset(&set, SIGHUP);

	(void) sigdelset(&set, SIGINT);

	(void) sigdelset(&set, SIGPIPE);

	if (smbd.s_fg) {

		(void) sigdelset(&set, SIGTSTP);

		(void) sigdelset(&set, SIGTTIN);

		(void) sigdelset(&set, SIGTTOU);

		if (smbd_service_init() != 0) {

			smbd_report("service initialization failed");

			exit(SMF_EXIT_ERR_FATAL);

		}

	} else {

		/*

		 * "pfd" is a pipe descriptor -- any fatal errors

		 * during subsequent initialization of the child

		 * process should be written to this pipe and the

		 * parent will report this error as the exit status.

		 */

		pfd = smbd_daemonize_init();

		if (smbd_service_init() != 0) {

			smbd_report("daemon initialization failed");

			exit(SMF_EXIT_ERR_FATAL);

		}

		smbd_daemonize_fini(pfd, SMF_EXIT_OK);

	}

	(void) atexit(smbd_service_fini);

	while (!smbd.s_shutdown_flag) {

		(void) sigsuspend(&set);

		switch (smbd.s_sigval) {

		case 0:

			break;

		case SIGPIPE:

			break;

		case SIGHUP:

			/* Refresh config was triggered */

			if (smbd.s_fg)

				smbd_report("reconfiguration requested");

			(void) pthread_cond_signal(&refresh_cond);

			break;

		default:

			/*

			 * Typically SIGINT or SIGTERM.

			 */

			smbd.s_shutdown_flag = 1;

			break;

		}

		smbd.s_sigval = 0;

	}

	smbd_service_fini();

	closelog();

	return (SMF_EXIT_OK);

}

/*

 * This function will fork off a child process,

 * from which only the child will return.

 *

 * Use SMF error codes only on exit.

 */

static int

smbd_daemonize_init(void)

{

	int status, pfds[2];

	sigset_t set, oset;

	pid_t pid;

	int rc;

	/*

	 * Reset privileges to the minimum set required. We continue

	 * to run as root to create and access files in /var.

	 */

	rc = __init_daemon_priv(PU_RESETGROUPS | PU_LIMITPRIVS,

	    smbd.s_uid, smbd.s_gid,

	    PRIV_NET_MAC_AWARE, PRIV_NET_PRIVADDR, PRIV_PROC_AUDIT,

	    PRIV_SYS_DEVICES, PRIV_SYS_SMB, NULL);

	if (rc != 0) {

		smbd_report("insufficient privileges");

		exit(SMF_EXIT_ERR_FATAL);

	}

	/*

	 * Block all signals prior to the fork and leave them blocked in the

	 * parent so we don't get in a situation where the parent gets SIGINT

	 * and returns non-zero exit status and the child is actually running.

	 * In the child, restore the signal mask once we've done our setsid().

	 */

	(void) sigfillset(&set);

	(void) sigdelset(&set, SIGABRT);

	(void) sigprocmask(SIG_BLOCK, &set, &oset);

	if (pipe(pfds) == -1) {

		smbd_report("unable to create pipe");

		exit(SMF_EXIT_ERR_FATAL);

	}

	closelog();

	if ((pid = fork()) == -1) {

		openlog(smbd.s_pname, LOG_PID | LOG_NOWAIT, LOG_DAEMON);

		smbd_report("unable to fork");

		closelog();

		exit(SMF_EXIT_ERR_FATAL);

	}

	/*

	 * If we're the parent process, wait for either the child to send us

	 * the appropriate exit status over the pipe or for the read to fail

	 * (presumably with 0 for EOF if our child terminated abnormally).

	 * If the read fails, exit with either the child's exit status if it

	 * exited or with SMF_EXIT_ERR_FATAL if it died from a fatal signal.

	 */

	if (pid != 0) {

		(void) close(pfds[1]);

		if (read(pfds[0], &status, sizeof (status)) == sizeof (status))

			_exit(status);

		if (waitpid(pid, &status, 0) == pid && WIFEXITED(status))

			_exit(WEXITSTATUS(status));

		_exit(SMF_EXIT_ERR_FATAL);

	}

	openlog(smbd.s_pname, LOG_PID | LOG_NOWAIT, LOG_DAEMON);

	smbd.s_pid = getpid();

	(void) setsid();

	(void) sigprocmask(SIG_SETMASK, &oset, NULL);

	(void) chdir("/");

	(void) umask(022);

	(void) close(pfds[0]);

	return (pfds[1]);

}

static void

smbd_daemonize_fini(int fd, int exit_status)

{

	/*

	 * Now that we're running, if a pipe fd was specified, write an exit

	 * status to it to indicate that our parent process can safely detach.

	 * Then proceed to loading the remaining non-built-in modules.

	 */

	if (fd >= 0)

		(void) write(fd, &exit_status, sizeof (exit_status));

	(void) close(fd);

	if ((fd = open("/dev/null", O_RDWR)) >= 0) {

		(void) fcntl(fd, F_DUP2FD, STDIN_FILENO);

		(void) fcntl(fd, F_DUP2FD, STDOUT_FILENO);

		(void) fcntl(fd, F_DUP2FD, STDERR_FILENO);

		(void) close(fd);

	}

	__fini_daemon_priv(PRIV_PROC_FORK, PRIV_PROC_EXEC, PRIV_PROC_SESSION,

	    PRIV_FILE_LINK_ANY, PRIV_PROC_INFO, NULL);

}

static int

smbd_service_init(void)

{

	static char *dir[] = {

		SMB_DBDIR,		/* smbpasswd */

		SMB_VARRUN_DIR		/* KRB credential cache */

	};

	int door_id;

	int rc;

	uint32_t mode;

	char resource_domain[SMB_PI_MAX_DOMAIN];

	int i;

	smbd.s_drv_fd = -1;

	for (i = 0; i < (sizeof (dir)/sizeof (dir[0])); ++i) {

		errno = 0;

		if ((mkdir(dir[i], 0700) < 0) && (errno != EEXIST)) {

			smbd_report("mkdir %s: %s", dir[i], strerror(errno));

			return (1);

		}

	}

	/*

	 * Set KRB5CCNAME (for the SMB credential cache) in the environment.

	 */

	if (putenv("KRB5CCNAME=" SMB_CCACHE) != 0) {

		smbd_report("unable to set KRB5CCNAME");

		return (1);

	}

	(void) oem_language_set("english");

	if (!nt_builtin_init()) {

		smbd_report("out of memory");

		return (1);

	}

	(void) smb_nicmon_start();

	if (dns_msgid_init() != 0) {

		smbd_report("DNS message id initialization failed");

		return (1);

	}

	smbrdr_init();

	if (smb_netbios_start() != 0)

		smbd_report("NetBIOS services failed to start");

	else

		smbd_report("NetBIOS services started");

	if (smb_netlogon_init() != 0) {

		smbd_report("netlogon initialization failed");

		return (1);

	}

	(void) smb_getdomainname(resource_domain, SMB_PI_MAX_DOMAIN);

	(void) utf8_strupr(resource_domain);

	mode = smb_config_get_secmode();

	if (mode == SMB_SECMODE_DOMAIN)

		(void) locate_resource_pdc(resource_domain);

	/* Get the ID map client handle */

	if ((rc = smb_idmap_start()) != 0) {

		smbd_report("no idmap handle");

		return (rc);

	}

	if ((rc = nt_domain_init(resource_domain, mode)) != 0) {

		if (rc == SMB_DOMAIN_NOMACHINE_SID) {

			smbd_report(

			    "no machine SID: check idmap configuration");

			return (rc);

		}

	}

	ads_init();

	if ((rc = mlsvc_init()) != 0) {

		smbd_report("msrpc initialization failed");

		return (rc);

	}

	if (smb_lmshrd_srv_start() != 0) {

		smbd_report("share initialization failed");

	}

	/* XXX following will get removed */

	(void) smb_doorsrv_start();

	if ((rc = smb_door_srv_start()) != 0)

		return (rc);

	if ((rc = smbd_refresh_init()) != 0)

		return (rc);

	/* Call dyndns update - Just in case its configured to refresh DNS */

	if (smb_config_getbool(SMB_CI_DYNDNS_ENABLE))

		(void) dyndns_update();

	if ((rc = smbd_kernel_bind()) != 0)

		smbd_report("kernel bind error: %s", strerror(errno));

	(void) smbd_localtime_init();

	if ((door_id = smb_winpipe_doorsvc_start()) == -1) {

		smbd_report("winpipe initialization failed %s",

		    strerror(errno));

		return (rc);

	} else {

		if (ioctl(smbd.s_drv_fd, SMB_IOC_WINPIPE, &door_id) < 0)

			smbd_report("winpipe ioctl: %s", strerror(errno));

	}

	(void) smb_lgrp_start();

	return (lmshare_start());

}

static void

smbd_remove_ccache(void)

{

	if ((remove(SMB_CCACHE) < 0) && (errno != ENOENT))

		smbd_report("failed to remove SMB ccache");

}

/*

 * Close the kernel service and shutdown smbd services.

 * This function is registered with atexit(): ensure that anything

 * called from here is safe to be called multiple times.

 */

static void

smbd_service_fini(void)

{

	smb_winpipe_doorsvc_stop();

	nt_builtin_fini();

	smbd_refresh_fini();

	smbd_kernel_unbind();

	smb_door_srv_stop();

	smb_doorsrv_stop();

	smb_lmshrd_srv_stop();

	lmshare_stop();

	smb_nicmon_stop();

	smb_idmap_stop();

	smb_lgrp_stop();

	smbd_remove_ccache();

}

/*

 * smbd_refresh_init()

 *

 * SMB service refresh thread initialization.  This thread waits for a

 * refresh event and updates the daemon's view of the configuration

 * before going back to sleep.

 */

static int

smbd_refresh_init()

{

	pthread_attr_t tattr;

	pthread_condattr_t cattr;

	int rc;

	(void) pthread_condattr_init(&cattr);

	(void) pthread_cond_init(&refresh_cond, &cattr);

	(void) pthread_condattr_destroy(&cattr);

	(void) pthread_mutex_init(&refresh_mutex, NULL);

	(void) pthread_attr_init(&tattr);

	(void) pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_DETACHED);

	rc = pthread_create(&refresh_thr, &tattr, smbd_refresh_monitor, 0);

	(void) pthread_attr_destroy(&tattr);

	return (rc);

}

/*

 * smbd_refresh_fini()

 *

 * Stop the refresh thread.

 */

static void

smbd_refresh_fini()

{

	(void) pthread_cancel(refresh_thr);

	(void) pthread_cond_destroy(&refresh_cond);

	(void) pthread_mutex_destroy(&refresh_mutex);

}

/*

 * smbd_refresh_monitor()

 *

 * Wait for a refresh event. When this thread wakes up, update the

 * smbd configuration from the SMF config information then go back to