static int
smbd_authsock_create(void)
{
int sock = -1;
sock = socket(AF_UNIX, SOCK_STREAM, 0);
if (sock < 0) {
smbd_report("authsvc, socket create failed, %d", errno);
return (errno);
}
(void) unlink(smbauth_sockname.sun_path);
if (bind(sock, (struct sockaddr *)&smbauth_sockname,
sizeof (smbauth_sockname)) < 0) {
smbd_report("authsvc, socket bind failed, %d", errno);
(void) close(sock);
return (errno);
}
if (listen(sock, SOMAXCONN) < 0) {
smbd_report("authsvc, socket listen failed, %d", errno);
(void) close(sock);
return (errno);
}
smbd.s_authsvc_sock = sock;
return (0);
}
/*
* Shutdown smbd and smbsrv kernel services.
*
* Called only by the main thread.
*/
static void
smbd_service_fini(void)
{
smbd.s_shutting_down = B_TRUE;
smbd_report("service shutting down");
smb_kmod_stop();
smb_logon_abort();
smb_lgrp_stop();
smbd_pipesvc_stop();
smbd_door_stop();
smbd_spool_stop();
smbd_kernel_unbind();
smbd_share_stop();
smb_shr_stop();
dyndns_stop();
smbd_nicmon_stop();
smb_ccache_remove(SMB_CCACHE_PATH);
smb_pwd_fini();
smb_domain_fini();
mlsvc_fini();
smb_netbios_stop();
smbd_cups_fini();
smbd.s_initialized = B_FALSE;
smbd_report("service terminated");
closelog();
}
/*
* smbd_kernel_bind
*
* If smbsrv is already bound, reload the configuration and update smbsrv.
* Otherwise, open the smbsrv device and start the kernel service.
*/
static int
smbd_kernel_bind(void)
{
smb_kmod_cfg_t cfg;
int rc;
if (smbd.s_kbound) {
smb_load_kconfig(&cfg);
rc = smb_kmod_setcfg(&cfg);
if (rc < 0)
smbd_report("kernel configuration update failed: %s",
strerror(errno));
return (rc);
}
if (smb_kmod_isbound())
smbd_kernel_unbind();
if ((rc = smb_kmod_bind()) == 0) {
rc = smbd_kernel_start();
if (rc != 0)
smb_kmod_unbind();
else
smbd.s_kbound = B_TRUE;
}
if (rc != 0)
smbd_report("kernel bind error: %s", strerror(errno));
return (rc);
}
static int
smbd_kernel_start(void)
{
smb_kmod_cfg_t cfg;
int rc;
smb_load_kconfig(&cfg);
rc = smb_kmod_setcfg(&cfg);
if (rc != 0) {
smbd_report("kernel config ioctl error: %s", strerror(rc));
return (rc);
}
rc = smb_kmod_setgmtoff(smbd_gmtoff());
if (rc != 0) {
smbd_report("kernel gmtoff ioctl error: %s", strerror(rc));
return (rc);
}
rc = smb_kmod_start(smbd.s_door_opipe, smbd.s_door_lmshr,
smbd.s_door_srv);
if (rc != 0) {
smbd_report("kernel start ioctl error: %s", strerror(rc));
return (rc);
}
return (0);
}
/*
* We want to adjust a few things in the standard configuration
* passed to the "fake" version of the smbsrv kernel module.
*
* Reduce the maximum number of connections and workers, just for
* convenience while debugging. (Don't want hundreds of threads.)
*/
static void
fksmbd_adjust_config(smb_ioc_header_t *ioc_hdr)
{
smb_ioc_cfg_t *ioc = (smb_ioc_cfg_t *)ioc_hdr;
char *s;
ioc->maxconnections = 10;
ioc->maxworkers = 20;
smbd_report("maxconnections=%d, maxworkers=%d",
ioc->maxconnections, ioc->maxworkers);
if ((s = getenv("SMB_MAX_PROTOCOL")) != NULL) {
switch (s[0]) {
case '1':
ioc->max_protocol = SMB_VERS_1;
break;
case '2':
ioc->max_protocol = SMB_VERS_2_1;
break;
case '3':
ioc->max_protocol = SMB_VERS_3_0;
break;
default:
smbd_report("env SMB_MAX_PROTOCOL invalid");
break;
}
}
smbd_report("max_protocol=0x%x", ioc->max_protocol);
if ((s = getenv("SMB_SIGNING")) != NULL) {
ioc->signing_enable = 0;
ioc->signing_required = 0;
switch (s[0]) {
case 'e':
ioc->signing_enable = 1;
break;
case 'r':
ioc->signing_enable = 1;
ioc->signing_required = 1;
break;
default:
smbd_report("env SMB_SIGNING invalid");
break;
}
}
smbd_report("signing: enable=%d, required=%d",
ioc->signing_enable, ioc->signing_required);
}
/*
* If the door has already been opened by another process (non-zero pid
* in target), we assume that another smbd is already running. If there
* is a race here, it will be caught later when smbsrv is opened because
* only one process is allowed to open the device at a time.
*/
static int
smbd_already_running(void)
{
door_info_t info;
char *door_name;
int door;
door_name = getenv("SMBD_DOOR_NAME");
if (door_name == NULL)
door_name = SMBD_DOOR_NAME;
if ((door = open(door_name, O_RDONLY)) < 0)
return (0);
if (door_info(door, &info) < 0)
return (0);
if (info.di_target > 0) {
smbd_report("already running: pid %ld\n", info.di_target);
(void) close(door);
return (1);
}
(void) close(door);
return (0);
}
/*ARGSUSED*/
static void *
smbd_localtime_monitor(void *arg)
{
struct tm local_tm;
time_t secs;
int32_t gmtoff, last_gmtoff = -1;
int timeout;
int error;
smbd_online_wait("smbd_localtime_monitor");
for (;;) {
gmtoff = smbd_gmtoff();
if ((last_gmtoff != gmtoff) && smbd.s_kbound) {
error = smb_kmod_setgmtoff(gmtoff);
if (error != 0)
smbd_report("localtime set failed: %s",
strerror(error));
}
/*
* Align the next iteration on a fifteen minute boundary.
*/
secs = time(0);
(void) localtime_r(&secs, &local_tm);
timeout = ((15 - (local_tm.tm_min % 15)) * SECSPERMIN);
(void) sleep(timeout);
last_gmtoff = gmtoff;
}
/*NOTREACHED*/
return (NULL);
}
/*
* Shutdown smbd and smbsrv kernel services.
*
* Shutdown will not begin until initialization has completed.
* Only one thread is allowed to perform the shutdown. Other
* threads will be blocked on fini_in_progress until the process
* has exited.
*/
static void
smbd_service_fini(void)
{
static uint_t fini_in_progress;
(void) mutex_lock(&smbd_service_mutex);
while (!smbd.s_initialized)
(void) cond_wait(&smbd_service_cv, &smbd_service_mutex);
if (atomic_swap_uint(&fini_in_progress, 1) != 0) {
while (fini_in_progress)
(void) cond_wait(&smbd_service_cv, &smbd_service_mutex);
/*NOTREACHED*/
}
smbd.s_shutting_down = B_TRUE;
smbd_report("service shutting down");
smb_kmod_stop();
smb_logon_abort();
smb_lgrp_stop();
smbd_opipe_stop();
smbd_door_stop();
smbd_refresh_fini();
smbd_kernel_unbind();
smbd_share_stop();
smb_shr_stop();
dyndns_stop();
smbd_nicmon_stop();
smb_ccache_remove(SMB_CCACHE_PATH);
smb_pwd_fini();
smb_domain_fini();
mlsvc_fini();
smb_netbios_stop();
smbd_cups_fini();
smbd.s_initialized = B_FALSE;
smbd_report("service terminated");
(void) mutex_unlock(&smbd_service_mutex);
exit((smbd.s_fatal_error) ? SMF_EXIT_ERR_FATAL : SMF_EXIT_OK);
}
/*
* Called when SMF sends us a SIGHUP. Update the smbd configuration
* from SMF and check for changes that require service reconfiguration.
*/
static void
smbd_refresh_handler()
{
int new_debug;
if (smbd.s_shutting_down)
return;
smbd.s_refreshes++;
new_debug = smb_config_get_debug();
if (smbd.s_debug || new_debug)
smbd_report("debug=%d", new_debug);
smbd.s_debug = new_debug;
smbd_spool_stop();
smbd_dc_monitor_refresh();
smb_ccache_remove(SMB_CCACHE_PATH);
/*
* Clear the DNS zones for the existing interfaces
* before updating the NIC interface list.
*/
dyndns_clear_zones();
if (smbd_nicmon_refresh() != 0)
smbd_report("NIC monitor refresh failed");
smb_netbios_name_reconfig();
smb_browser_reconfig();
dyndns_update_zones();
/* This reloads the in-kernel config. */
(void) smbd_kernel_bind();
smbd_load_shares();
smbd_load_printers();
smbd_spool_start();
}
static void
smbd_authsvc_flood(void)
{
static uint_t count;
static time_t last_report;
time_t now = time(NULL);
count++;
if (last_report + 60 < now) {
last_report = now;
smbd_report("authsvc: flooded %u", count);
count = 0;
}
}
/*
* Launches a thread to populate the share cache by share information
* stored in sharemgr
*/
static void
smbd_load_shares(void)
{
pthread_t tid;
pthread_attr_t attr;
int rc;
(void) pthread_attr_init(&attr);
(void) pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
rc = pthread_create(&tid, &attr, smb_shr_load, NULL);
(void) pthread_attr_destroy(&attr);
if (rc != 0)
smbd_report("unable to load disk shares: %s", strerror(errno));
}
static void
smbd_localtime_init(void)
{
pthread_attr_t attr;
int rc;
(void) pthread_attr_init(&attr);
(void) pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
rc = pthread_create(&smbd.s_localtime_tid, &attr,
smbd_localtime_monitor, NULL);
(void) pthread_attr_destroy(&attr);
if (rc != 0)
smbd_report("unable to monitor localtime: %s", strerror(errno));
}
/*ARGSUSED*/
static void *
smbd_refresh_monitor(void *arg)
{
smbd_online_wait("smbd_refresh_monitor");
while (!smbd.s_shutting_down) {
(void) sleep(SMBD_REFRESH_INTERVAL);
(void) pthread_mutex_lock(&refresh_mutex);
while ((atomic_swap_uint(&smbd.s_refreshes, 0) == 0) &&
(!smbd.s_shutting_down))
(void) pthread_cond_wait(&refresh_cond, &refresh_mutex);
(void) pthread_mutex_unlock(&refresh_mutex);
if (smbd.s_shutting_down) {
smbd_service_fini();
/*NOTREACHED*/
}
(void) mutex_lock(&smbd_service_mutex);
smbd_dc_monitor_refresh();
smb_ccache_remove(SMB_CCACHE_PATH);
/*
* Clear the DNS zones for the existing interfaces
* before updating the NIC interface list.
*/
dyndns_clear_zones();
if (smbd_nicmon_refresh() != 0)
smbd_report("NIC monitor refresh failed");
smb_netbios_name_reconfig();
smb_browser_reconfig();
dyndns_update_zones();
(void) smbd_kernel_bind();
smbd_load_shares();
smbd_load_printers();
(void) mutex_unlock(&smbd_service_mutex);
}
smbd.s_refresh_tid = 0;
return (NULL);
}
/*
* Create the Dynamic DNS publisher thread.
*/
static void
smbd_dyndns_init(void)
{
pthread_t tid;
pthread_attr_t attr;
int rc;
dyndns_start();
(void) pthread_attr_init(&attr);
(void) pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
rc = pthread_create(&tid, &attr, dyndns_publisher, NULL);
(void) pthread_attr_destroy(&attr);
if (rc != 0)
smbd_report("unable to start dyndns publisher: %s",
strerror(errno));
}
/*
* If the door has already been opened by another process (non-zero pid
* in target), we assume that another smbd is already running. If there
* is a race here, it will be caught later when smbsrv is opened because
* only one process is allowed to open the device at a time.
*/
static int
smbd_already_running(void)
{
door_info_t info;
int door;
if ((door = open(SMBD_DOOR_NAME, O_RDONLY)) < 0)
return (0);
if (door_info(door, &info) < 0)
return (0);
if (info.di_target > 0) {
smbd_report("already running: pid %ld\n", info.di_target);
(void) close(door);
return (1);
}
(void) close(door);
return (0);
}
/*
* 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(&smbd.s_refresh_tid, &tattr, smbd_refresh_monitor,
NULL);
(void) pthread_attr_destroy(&tattr);
if (rc != 0)
smbd_report("unable to start refresh monitor: %s",
strerror(errno));
return (rc);
}
/*
* smbd_service_init
*/
static int
smbd_service_init(void)
{
static struct dir {
char *name;
int perm;
} dir[] = {
{ SMB_DBDIR, 0700 },
{ SMB_CVOL, 0755 },
{ SMB_SYSROOT, 0755 },
{ SMB_SYSTEM32, 0755 },
{ SMB_VSS, 0755 },
{ SMB_PIPE_DIR, 0755 },
};
int rc, i;
smbd.s_pid = getpid();
/*
* Stop for a debugger attach here, which is after the
* fork() etc. in smb_daemonize_init()
*/
if (smbd.s_dbg_stop) {
smbd_report("pid %d stop for debugger attach", smbd.s_pid);
(void) kill(smbd.s_pid, SIGSTOP);
}
smbd_report("smbd starting, pid %d", smbd.s_pid);
for (i = 0; i < sizeof (dir)/sizeof (dir[0]); ++i) {
if ((mkdir(dir[i].name, dir[i].perm) < 0) &&
(errno != EEXIST)) {
smbd_report("mkdir %s: %s", dir[i].name,
strerror(errno));
return (-1);
}
}
if ((rc = smb_ccache_init(SMB_VARRUN_DIR, SMB_CCACHE_FILE)) != 0) {
if (rc == -1)
smbd_report("mkdir %s: %s", SMB_VARRUN_DIR,
strerror(errno));
else
smbd_report("unable to set KRB5CCNAME");
return (-1);
}
smb_codepage_init();
rc = smbd_cups_init();
if (smb_config_getbool(SMB_CI_PRINT_ENABLE))
smbd_report("print service %savailable", (rc == 0) ? "" : "un");
if (smbd_nicmon_start(SMBD_DEFAULT_INSTANCE_FMRI) != 0)
smbd_report("NIC monitor failed to start");
smbd_dyndns_init();
smb_ipc_init();
if (smb_config_getbool(SMB_CI_NETBIOS_ENABLE) == 0)
smbd_report("NetBIOS services disabled");
else if (smb_netbios_start() != 0)
smbd_report("NetBIOS services failed to start");
else
smbd_report("NetBIOS services started");
smbd.s_secmode = smb_config_get_secmode();
if ((rc = smb_domain_init(smbd.s_secmode)) != 0) {
if (rc == SMB_DOMAIN_NOMACHINE_SID) {
smbd_report(
"no machine SID: check idmap configuration");
return (-1);
}
}
if (smbd_dc_monitor_init() != 0)
smbd_report("DC monitor initialization failed %s",
strerror(errno));
if (smbd_pipesvc_start() != 0) {
smbd_report("pipesvc initialization failed");
return (-1);
}
smbd.s_door_srv = smbd_door_start();
if (smbd.s_door_srv < 0) {
smbd_report("door initialization failed %s", strerror(errno));
return (-1);
}
dyndns_update_zones();
smbd_localtime_init();
(void) smb_lgrp_start();
smb_pwd_init(B_TRUE);
if (smb_shr_start() != 0) {
smbd_report("share initialization failed: %s", strerror(errno));
return (-1);
}
smbd.s_door_lmshr = smbd_share_start();
if (smbd.s_door_lmshr < 0)
smbd_report("share initialization failed");
/* Open the driver, load the kernel config. */
if (smbd_kernel_bind() != 0) {
return (-1);
}
smbd_load_shares();
smbd_load_printers();
smbd_spool_start();
smbd.s_initialized = B_TRUE;
smbd_report("service initialized");
return (0);
}
/*
* smbd_service_init
*/
static int
smbd_service_init(void)
{
static struct dir {
char *name;
int perm;
} dir[] = {
{ SMB_DBDIR, 0700 },
{ SMB_CVOL, 0755 },
{ SMB_SYSROOT, 0755 },
{ SMB_SYSTEM32, 0755 },
{ SMB_VSS, 0755 }
};
int rc, i;
(void) mutex_lock(&smbd_service_mutex);
smbd.s_pid = getpid();
for (i = 0; i < sizeof (dir)/sizeof (dir[0]); ++i) {
if ((mkdir(dir[i].name, dir[i].perm) < 0) &&
(errno != EEXIST)) {
smbd_report("mkdir %s: %s", dir[i].name,
strerror(errno));
(void) mutex_unlock(&smbd_service_mutex);
return (-1);
}
}
if ((rc = smb_ccache_init(SMB_VARRUN_DIR, SMB_CCACHE_FILE)) != 0) {
if (rc == -1)
smbd_report("mkdir %s: %s", SMB_VARRUN_DIR,
strerror(errno));
else
smbd_report("unable to set KRB5CCNAME");
(void) mutex_unlock(&smbd_service_mutex);
return (-1);
}
smbd.s_loghd = smb_log_create(SMBD_LOGSIZE, SMBD_LOGNAME);
smb_codepage_init();
rc = smbd_cups_init();
if (smb_config_getbool(SMB_CI_PRINT_ENABLE))
smbd_report("print service %savailable", (rc == 0) ? "" : "un");
if (smbd_nicmon_start(SMBD_DEFAULT_INSTANCE_FMRI) != 0)
smbd_report("NIC monitor failed to start");
smbd_dyndns_init();
smb_ipc_init();
if (smb_netbios_start() != 0)
smbd_report("NetBIOS services failed to start");
else
smbd_report("NetBIOS services started");
smbd.s_secmode = smb_config_get_secmode();
if ((rc = smb_domain_init(smbd.s_secmode)) != 0) {
if (rc == SMB_DOMAIN_NOMACHINE_SID) {
smbd_report(
"no machine SID: check idmap configuration");
(void) mutex_unlock(&smbd_service_mutex);
return (-1);
}
}
if (smbd_dc_monitor_init() != 0)
smbd_report("DC monitor initialization failed %s",
strerror(errno));
if (mlsvc_init() != 0) {
smbd_report("msrpc initialization failed");
(void) mutex_unlock(&smbd_service_mutex);
return (-1);
}
smbd.s_door_srv = smbd_door_start();
smbd.s_door_opipe = smbd_opipe_start();
if (smbd.s_door_srv < 0 || smbd.s_door_opipe < 0) {
smbd_report("door initialization failed %s", strerror(errno));
(void) mutex_unlock(&smbd_service_mutex);
return (-1);
}
if (smbd_refresh_init() != 0) {
(void) mutex_unlock(&smbd_service_mutex);
return (-1);
}
dyndns_update_zones();
smbd_localtime_init();
(void) smb_lgrp_start();
smb_pwd_init(B_TRUE);
if (smb_shr_start() != 0) {
smbd_report("share initialization failed: %s", strerror(errno));
(void) mutex_unlock(&smbd_service_mutex);
return (-1);
}
smbd.s_door_lmshr = smbd_share_start();
if (smbd.s_door_lmshr < 0)
smbd_report("share initialization failed");
if (smbd_kernel_bind() != 0) {
(void) mutex_unlock(&smbd_service_mutex);
return (-1);
}
smbd_load_shares();
smbd_load_printers();
smbd.s_initialized = B_TRUE;
smbd_report("service initialized");
(void) cond_signal(&smbd_service_cv);
(void) mutex_unlock(&smbd_service_mutex);
return (0);
}
/*
* 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 = smb_init_daemon_priv(PU_RESETGROUPS, smbd.s_uid, smbd.s_gid);
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);
(void) setsid();
(void) sigprocmask(SIG_SETMASK, &oset, NULL);
(void) chdir("/");
(void) umask(022);
(void) close(pfds[0]);
return (pfds[1]);
}
/*
* 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;
uint_t sigval;
struct rlimit rl;
int orig_limit;
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);
/*
* Raise the file descriptor limit to accommodate simultaneous user
* authentications/file access.
*/
if ((getrlimit(RLIMIT_NOFILE, &rl) == 0) &&
(rl.rlim_cur < rl.rlim_max)) {
orig_limit = rl.rlim_cur;
rl.rlim_cur = rl.rlim_max;
if (setrlimit(RLIMIT_NOFILE, &rl) != 0)
smbd_report("Failed to raise file descriptor limit"
" from %d to %d", orig_limit, rl.rlim_cur);
}
(void) sigfillset(&set);
(void) sigdelset(&set, SIGABRT);
(void) sigfillset(&act.sa_mask);
act.sa_handler = smbd_sig_handler;
act.sa_flags = 0;
(void) sigaction(SIGABRT, &act, NULL);
(void) sigaction(SIGTERM, &act, NULL);
(void) sigaction(SIGHUP, &act, NULL);
(void) sigaction(SIGINT, &act, NULL);
(void) sigaction(SIGPIPE, &act, NULL);
(void) sigaction(SIGUSR1, &act, NULL);
(void) sigdelset(&set, SIGTERM);
(void) sigdelset(&set, SIGHUP);
(void) sigdelset(&set, SIGINT);
(void) sigdelset(&set, SIGPIPE);
(void) sigdelset(&set, SIGUSR1);
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(smb_kmod_stop);
while (!smbd.s_shutting_down) {
if (smbd.s_sigval == 0 && smbd.s_refreshes == 0)
(void) sigsuspend(&set);
sigval = atomic_swap_uint(&smbd.s_sigval, 0);
switch (sigval) {
case 0:
case SIGPIPE:
case SIGABRT:
break;
case SIGHUP:
syslog(LOG_DEBUG, "refresh requested");
(void) pthread_cond_signal(&refresh_cond);
break;
case SIGUSR1:
smb_log_dumpall();
break;
default:
/*
* Typically SIGINT or SIGTERM.
*/
smbd.s_shutting_down = B_TRUE;
break;
}
}
smbd_service_fini();
closelog();
return ((smbd.s_fatal_error) ? SMF_EXIT_ERR_FATAL : SMF_EXIT_OK);
}
krb5_error_code
_krb5_override_service_locator(
void *arg0,
enum locate_service_type svc,
const char *realm,
int socktype,
int family,
int (*cbfunc)(void *, int, struct sockaddr *),
void *cbdata)
{
_NOTE(ARGUNUSED(arg0))
smb_domainex_t dxi;
int rc = KRB5_PLUGIN_NO_HANDLE;
short port;
/*
* Is this a service we want to override?
*/
switch (svc) {
case locate_service_kdc:
case locate_service_master_kdc:
port = htons(KRB5_DEFAULT_PORT);
break;
case locate_service_kadmin:
port = htons(DEFAULT_KADM5_PORT);
break;
case locate_service_kpasswd:
port = htons(DEFAULT_KPASSWD_PORT);
break;
case locate_service_krb524:
default:
return (rc);
}
/*
* What's my domain? Note: have to get this in a way
* that works while join domain is underway.
*/
if (!smb_domain_getinfo(&dxi)) {
smbd_report("_krb5_override_service_locator "
"failed getting domain info");
return (KRB5_ERR_HOST_REALM_UNKNOWN);
}
/*
* Is this a realm we want to override?
*/
if (0 != strcasecmp(realm, dxi.d_primary.di_fqname)) {
syslog(LOG_DEBUG, "_krb5_override_service_locator, "
"realm=%s, fqdn=%s", realm, dxi.d_primary.di_fqname);
return (rc);
}
/*
* Yes, this is our domain. Have a DC?
*/
if (dxi.d_dci.dc_name[0] == '\0' ||
dxi.d_dci.dc_addr.a_family == 0)
return (KRB5_REALM_CANT_RESOLVE);
switch (family) {
case AF_UNSPEC:
break; /* OK */
case AF_INET:
case AF_INET6:
if (family == dxi.d_dci.dc_addr.a_family)
break; /* OK */
/* else fallthrough */
default:
return (KRB5_ERR_NO_SERVICE);
}
/*
* Provide the service address we have.
*/
switch (dxi.d_dci.dc_addr.a_family) {
case AF_INET: {
struct sockaddr_in sin;
(void) memset(&sin, 0, sizeof (sin));
sin.sin_family = AF_INET;
sin.sin_port = port;
(void) memcpy(&sin.sin_addr, &dxi.d_dci.dc_addr.a_ipv4,
sizeof (sin.sin_addr));
rc = cbfunc(cbdata, socktype, (struct sockaddr *)&sin);
/* rc from cbfunc is special. */
if (rc)
rc = ENOMEM;
break;
}
case AF_INET6: {
struct sockaddr_in6 sin6;
(void) memset(&sin6, 0, sizeof (sin6));
sin6.sin6_family = AF_INET6;
sin6.sin6_port = port;
(void) memcpy(&sin6.sin6_addr, &dxi.d_dci.dc_addr.a_ipv6,
sizeof (sin6.sin6_addr));
rc = cbfunc(cbdata, socktype, (struct sockaddr *)&sin6);
/* rc from cbfunc is special. */
if (rc)
rc = ENOMEM;
break;
}
default:
rc = KRB5_ERR_NO_SERVICE;
break;
}
return (rc);
}
static void *
smbd_authsvc_work(void *arg)
{
authsvc_context_t *ctx = arg;
smb_lsa_msg_hdr_t hdr;
int sock = ctx->ctx_socket;
int len, rc;
if (setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO,
(char *)&send_tmo, sizeof (send_tmo)) != 0) {
smbd_report("authsvc_work: set set timeout: %m");
goto out;
}
if (setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO,
(char *)&recv_tmo, sizeof (recv_tmo)) != 0) {
smbd_report("authsvc_work: set recv timeout: %m");
goto out;
}
for (;;) {
len = recv(sock, &hdr, sizeof (hdr), MSG_WAITALL);
if (len <= 0) {
/* normal termination */
break;
}
if (len != sizeof (hdr)) {
smbd_report("authsvc_work: read header failed");
break;
}
if (hdr.lmh_msglen > smbd_authsvc_bufsize) {
smbd_report("authsvc_work: msg too large");
break;
}
if (hdr.lmh_msglen > 0) {
len = recv(sock, ctx->ctx_irawbuf, hdr.lmh_msglen,
MSG_WAITALL);
if (len != hdr.lmh_msglen) {
smbd_report("authsvc_work: read mesg failed");
break;
}
}
ctx->ctx_irawtype = hdr.lmh_msgtype;
ctx->ctx_irawlen = hdr.lmh_msglen;
ctx->ctx_orawlen = smbd_authsvc_bufsize;
ctx->ctx_ibodylen = smbd_authsvc_bufsize;
ctx->ctx_obodylen = smbd_authsvc_bufsize;
/*
* The real work happens here.
*/
rc = smbd_authsvc_dispatch(ctx);
if (rc)
break;
hdr.lmh_msgtype = ctx->ctx_orawtype;
hdr.lmh_msglen = ctx->ctx_orawlen;
len = send(sock, &hdr, sizeof (hdr), 0);
if (len != sizeof (hdr)) {
smbd_report("authsvc_work: send failed");
break;
}
if (ctx->ctx_orawlen > 0) {
len = send(sock, ctx->ctx_orawbuf,
ctx->ctx_orawlen, 0);
if (len != ctx->ctx_orawlen) {
smbd_report("authsvc_work: send failed");
break;
}
}
}
out:
if (ctx->ctx_mh_fini)
(ctx->ctx_mh_fini)(ctx);
smbd_authctx_destroy(ctx);
(void) mutex_lock(&smbd_authsvc_mutex);
smbd_authsvc_thrcnt--;
(void) mutex_unlock(&smbd_authsvc_mutex);
return (NULL); /* implied pthread_exit() */
}
static void *
smbd_authsvc_listen(void *arg)
{
authsvc_context_t *ctx;
pthread_attr_t attr;
pthread_t tid;
socklen_t slen;
int ls, ns, rc;
_NOTE(ARGUNUSED(arg))
(void) pthread_attr_init(&attr);
(void) pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
ls = smbd.s_authsvc_sock;
for (;;) {
slen = 0;
ns = accept(ls, NULL, &slen);
if (ns < 0) {
switch (errno) {
case ECONNABORTED:
continue;
case EINTR:
/* normal termination */
goto out;
default:
smbd_report("authsvc, socket accept failed,"
" %d", errno);
goto out;
}
}
/*
* Limit the number of auth. sockets
* (and the threads that service them).
*/
(void) mutex_lock(&smbd_authsvc_mutex);
if (smbd_authsvc_thrcnt >= smbd_authsvc_maxthread) {
(void) mutex_unlock(&smbd_authsvc_mutex);
(void) close(ns);
smbd_authsvc_flood();
continue;
}
smbd_authsvc_thrcnt++;
if (smbd_authsvc_hiwat < smbd_authsvc_thrcnt)
smbd_authsvc_hiwat = smbd_authsvc_thrcnt;
(void) mutex_unlock(&smbd_authsvc_mutex);
ctx = smbd_authctx_create();
if (ctx == NULL) {
smbd_report("authsvc, can't allocate context");
(void) mutex_lock(&smbd_authsvc_mutex);
smbd_authsvc_thrcnt--;
(void) mutex_unlock(&smbd_authsvc_mutex);
(void) close(ns);
goto out;
}
ctx->ctx_socket = ns;
rc = pthread_create(&tid, &attr, smbd_authsvc_work, ctx);
if (rc) {
smbd_report("authsvc, thread create failed, %d", rc);
(void) mutex_lock(&smbd_authsvc_mutex);
smbd_authsvc_thrcnt--;
(void) mutex_unlock(&smbd_authsvc_mutex);
smbd_authctx_destroy(ctx);
goto out;
}
ctx = NULL; /* given to the new thread */
}
out:
(void) pthread_attr_destroy(&attr);
smbd_authsock_destroy();
return (NULL);
}
/*
* Handle a security blob we've received from the client.
* Incoming type: LSA_MTYPE_ESFIRST
* Outgoing types: LSA_MTYPE_ES_CONT, LSA_MTYPE_ES_DONE,
* LSA_MTYPE_ERROR
*/
static int
smbd_authsvc_esfirst(authsvc_context_t *ctx)
{
const spnego_mech_handler_t *mh;
int idx, pref, rc;
int best_pref = 1000;
int best_mhidx = -1;
/*
* NTLMSSP header is 8+, SPNEGO is 10+
*/
if (ctx->ctx_irawlen < 8) {
smbd_report("authsvc: short blob");
return (NT_STATUS_INVALID_PARAMETER);
}
/*
* We could have "Raw NTLMSSP" here intead of SPNEGO.
*/
if (bcmp(ctx->ctx_irawbuf, "NTLMSSP", 8) == 0) {
rc = smbd_raw_ntlmssp_esfirst(ctx);
return (rc);
}
/*
* Parse the SPNEGO token, check its type.
*/
rc = spnegoInitFromBinary(ctx->ctx_irawbuf,
ctx->ctx_irawlen, &ctx->ctx_itoken);
if (rc != 0) {
smbd_report("authsvc: spnego parse failed");
return (NT_STATUS_INVALID_PARAMETER);
}
rc = spnegoGetTokenType(ctx->ctx_itoken, &ctx->ctx_itoktype);
if (rc != 0) {
smbd_report("authsvc: spnego get token type failed");
return (NT_STATUS_INVALID_PARAMETER);
}
if (ctx->ctx_itoktype != SPNEGO_TOKEN_INIT) {
smbd_report("authsvc: spnego wrong token type %d",
ctx->ctx_itoktype);
return (NT_STATUS_INVALID_PARAMETER);
}
/*
* Figure out which mech type to use. We want to use the
* first of the client's supported mechanisms that we also
* support. Unfortunately, the spnego code does not have an
* interface to walk the token's mech list, so we have to
* ask about each mech type we know and keep track of which
* was earliest in the token's mech list.
*
* Also, skip the Kerberos mechanisms in workgroup mode.
*/
idx = 0;
mh = mech_table;
if (smb_config_get_secmode() != SMB_SECMODE_DOMAIN) {
idx = MECH_TBL_IDX_NTLMSSP;
mh = &mech_table[idx];
}
for (; mh->mh_init != NULL; idx++, mh++) {
if (spnegoIsMechTypeAvailable(ctx->ctx_itoken,
mh->mh_oid, &pref) != 0)
continue;
if (pref < best_pref) {
best_pref = pref;
best_mhidx = idx;
}
}
if (best_mhidx == -1) {
smbd_report("authsvc: no supported spnego mechanism");
return (NT_STATUS_INVALID_PARAMETER);
}
/* Found a mutually agreeable mech. */
mh = &mech_table[best_mhidx];
ctx->ctx_mech_oid = mh->mh_oid;
ctx->ctx_mh_work = mh->mh_work;
ctx->ctx_mh_fini = mh->mh_fini;
rc = mh->mh_init(ctx);
if (rc != 0) {
smbd_report("authsvc: mech init failed");
return (rc);
}
/*
* Common to LSA_MTYPE_ESFIRST, LSA_MTYPE_ESNEXT
*/
rc = smbd_authsvc_escmn(ctx);
return (rc);
}
/*
* Use SMF error codes only on return or exit.
*/
int
main(int argc, char *argv[])
{
sigset_t set;
uid_t uid;
int pfd = -1;
int sigval;
struct rlimit rl;
int orig_limit;
#ifdef FKSMBD
fksmbd_init();
#endif
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) {
#ifdef FKSMBD
/* Can't manipulate privileges in daemonize. */
if (smbd.s_fg == 0) {
smbd.s_fg = 1;
smbd_report("user %d (forced -f)", uid);
}
#else /* FKSMBD */
smbd_report("user %d: %s", uid, strerror(EPERM));
return (SMF_EXIT_ERR_FATAL);
#endif /* FKSMBD */
}
if (is_system_labeled()) {
smbd_report("Trusted Extensions not supported");
return (SMF_EXIT_ERR_FATAL);
}
if (smbd_already_running())
return (SMF_EXIT_OK);
/*
* Raise the file descriptor limit to accommodate simultaneous user
* authentications/file access.
*/
if ((getrlimit(RLIMIT_NOFILE, &rl) == 0) &&
(rl.rlim_cur < rl.rlim_max)) {
orig_limit = rl.rlim_cur;
rl.rlim_cur = rl.rlim_max;
if (setrlimit(RLIMIT_NOFILE, &rl) != 0)
smbd_report("Failed to raise file descriptor limit"
" from %d to %d", orig_limit, rl.rlim_cur);
}
/*
* Block async signals in all threads.
*/
(void) sigemptyset(&set);
(void) sigaddset(&set, SIGHUP);
(void) sigaddset(&set, SIGINT);
(void) sigaddset(&set, SIGQUIT);
(void) sigaddset(&set, SIGPIPE);
(void) sigaddset(&set, SIGTERM);
(void) sigaddset(&set, SIGUSR1);
(void) sigaddset(&set, SIGUSR2);
(void) sigprocmask(SIG_SETMASK, &set, NULL);
if (smbd.s_fg) {
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);
}
while (!smbd.s_shutting_down) {
sigval = sigwait(&set);
switch (sigval) {
case -1:
syslog(LOG_DEBUG, "sigwait failed: %s",
strerror(errno));
break;
case SIGPIPE:
break;
case SIGHUP:
syslog(LOG_DEBUG, "refresh requested");
smbd_refresh_handler();
break;
case SIGUSR1:
syslog(LOG_DEBUG, "SIGUSR1 ignored");
break;
default:
/*
* Typically SIGINT or SIGTERM.
*/
smbd.s_shutting_down = B_TRUE;
break;
}
}
/*
* Allow termination signals while shutting down.
*/
(void) sigemptyset(&set);
if (smbd.s_fg) {
(void) sigaddset(&set, SIGHUP);
(void) sigaddset(&set, SIGINT);
}
(void) sigaddset(&set, SIGTERM);
(void) sigprocmask(SIG_UNBLOCK, &set, NULL);
smbd_service_fini();
return ((smbd.s_fatal_error) ? SMF_EXIT_ERR_FATAL : SMF_EXIT_OK);
}
