smbd_main.c revision a4b239dfde5f1d873c730c047e87e5714ebddbb7
/*
* 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
* 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 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#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 <atomic.h>
#include <libscf.h>
#include <limits.h>
#include <priv_utils.h>
#include <door.h>
#include <errno.h>
#include <pthread.h>
#include <time.h>
#include <libscf.h>
#include <zone.h>
#include <libgen.h>
#include <pwd.h>
#include <grp.h>
#include <smbsrv/smb_door_svc.h>
#include <smbsrv/smb_ioctl.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"
extern void *smbd_nbt_listener(void *);
extern void *smbd_tcp_listener(void *);
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 int smbd_service_init(void);
static void smbd_service_fini(void);
static void smbd_report(const char *fmt, ...);
static void smbd_sig_handler(int sig);
static int32_t smbd_gmtoff(void);
static int smbd_localtime_init(void);
static void *smbd_localtime_monitor(void *arg);
static pthread_t localtime_thr;
static int smbd_refresh_init(void);
static void smbd_refresh_fini(void);
static void *smbd_refresh_monitor(void *);
static void smbd_refresh_dc(void);
static int smbd_start_listeners(void);
static void smbd_stop_listeners(void);
static pthread_t refresh_thr;
static pthread_cond_t refresh_cond;
static pthread_mutex_t refresh_mutex;
/*
* smbd user land daemon
*
* Use SMF error codes only on return or exit.
*/
int
{
int pfd = -1;
return (SMF_EXIT_ERR_FATAL);
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);
if (smbd_service_init() != 0) {
smbd_report("service initialization failed");
}
} 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");
}
}
(void) atexit(smbd_service_fini);
while (!smbd.s_shutting_down) {
(void) sigsuspend(&set);
switch (sigval) {
case 0:
case SIGPIPE:
break;
case SIGHUP:
(void) pthread_cond_signal(&refresh_cond);
break;
default:
/*
* Typically SIGINT or SIGTERM.
*/
break;
}
}
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 rc;
/*
* Reset privileges to the minimum set required. We continue
* to run as root to create and access files in /var.
*/
if (rc != 0) {
smbd_report("insufficient privileges");
}
/*
* 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);
smbd_report("unable to create pipe");
}
closelog();
smbd_report("unable to fork");
closelog();
}
/*
* 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) setsid();
(void) chdir("/");
(void) umask(022);
return (pfds[1]);
}
static void
{
/*
* 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)
}
}
/*
* smbd_service_init
*/
static int
smbd_service_init(void)
{
int rc;
char nb_domain[NETBIOS_NAME_SZ];
return (1);
}
if (rc == -1)
else
smbd_report("unable to set KRB5CCNAME");
return (1);
}
(void) oem_language_set("english");
if (!smb_wka_init()) {
smbd_report("out of memory");
return (1);
}
if (smb_nicmon_start(SMBD_DEFAULT_INSTANCE_FMRI) != 0)
smbd_report("NIC monitoring failed to start");
(void) dyndns_start();
smbrdr_init();
if (smb_netbios_start() != 0)
smbd_report("NetBIOS services failed to start");
else
smbd_report("NetBIOS services started");
(void) utf8_strupr(nb_domain);
/* Get the ID map client handle */
if ((rc = smb_idmap_start()) != 0) {
smbd_report("no idmap handle");
return (rc);
}
if (rc == SMB_DOMAIN_NOMACHINE_SID) {
"no machine SID: check idmap configuration");
return (rc);
}
}
smb_ads_init();
if ((rc = mlsvc_init()) != 0) {
smbd_report("msrpc initialization failed");
return (rc);
}
if (smbd_locate_dc_start() != 0)
if (smbd.s_door_srv < 0)
return (rc);
if ((rc = smbd_refresh_init()) != 0)
return (rc);
(void) smbd_localtime_init();
if (smbd.s_door_opipe < 0) {
smbd_report("opipe initialization failed %s",
return (rc);
}
(void) smb_lgrp_start();
if ((rc = smb_shr_start()) != 0) {
return (rc);
}
if (smbd.s_door_lmshr < 0) {
smbd_report("share initialization failed");
}
if ((rc = smbd_kernel_bind()) != 0) {
return (rc);
}
if ((rc = smb_shr_load()) != 0) {
smbd_report("failed to start loading shares: %s",
return (rc);
}
return (0);
}
/*
* 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_wka_fini();
smb_shr_stop();
dyndns_stop();
smb_pwd_fini();
}
/*
* 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
{
int rc;
(void) pthread_condattr_init(&cattr);
(void) pthread_condattr_destroy(&cattr);
(void) pthread_attr_init(&tattr);
(void) pthread_attr_destroy(&tattr);
return (rc);
}
/*
* smbd_refresh_fini()
*
* Stop the refresh thread.
*/
static void
{
(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
* wait for the next refresh.
*/
/*ARGSUSED*/
static void *
smbd_refresh_monitor(void *arg)
{
while (!smbd.s_shutting_down) {
(void) pthread_mutex_lock(&refresh_mutex);
(!smbd.s_shutting_down))
(void) pthread_mutex_unlock(&refresh_mutex);
if (smbd.s_shutting_down) {
}
/*
* We've been woken up by a refresh event so go do
* what is necessary.
*/
/*
* Start the dyndns thread, if required.
* Clear the DNS zones for the existing interfaces
* before updating the NIC interface list.
*/
(void) dyndns_start();
/* re-initialize NIC table */
if (smb_nic_init() != 0)
smbd_report("failed to get NIC information");
if (smbd_set_netlogon_cred()) {
/*
* Restart required because the domain changed
* or the credential chain setup failed.
*/
if (smb_smf_restart_service() != 0) {
"unable to restart smb service. "
"information.");
}
break;
}
if (smbd_kernel_bind()) {
smbd_report("kernel bind error: %s",
} else {
(void) smb_shr_load();
}
continue;
}
(void) smb_shr_load();
smbd_report("configuration update ioctl: %s",
}
}
return (NULL);
}
/*
* Update DC information on a refresh.
*/
static void
smbd_refresh_dc(void)
{
char fqdomain[MAXHOSTNAMELEN];
if (smb_config_get_secmode() != SMB_SECMODE_DOMAIN)
return;
return;
smbd_report("DC discovery failed");
}
void
smbd_set_secmode(int secmode)
{
switch (secmode) {
case SMB_SECMODE_WORKGRP:
case SMB_SECMODE_DOMAIN:
(void) smb_config_set_secmode(secmode);
break;
default:
(void) smb_smf_maintenance_mode();
}
}
/*
* 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)
{
int door;
return (0);
return (0);
return (1);
}
return (0);
}
/*
* smbd_kernel_bind
*
* This function open the smbsrv device and start the kernel service.
*/
static int
smbd_kernel_bind(void)
{
int rc;
return (errno);
}
return (errno);
}
return (errno);
}
return (errno);
}
rc = smbd_start_listeners();
if (rc == 0) {
return (0);
}
return (rc);
}
/*
* smbd_kernel_unbind
*/
static void
smbd_kernel_unbind(void)
{
}
}
int
{
}
/*
* Initialization of the localtime thread.
* Returns 0 on success, an error number if thread creation fails.
*/
int
smbd_localtime_init(void)
{
int rc;
(void) pthread_attr_init(&tattr);
(void) pthread_attr_destroy(&tattr);
return (rc);
}
/*
* Local time thread to kernel land.
* Send local gmtoff to kernel module one time at startup
* and each time it changes (up to twice a year).
* Local gmtoff is checked once every 15 minutes and
* since some timezones are aligned on half and qtr hour boundaries,
* once an hour would likely suffice.
*/
/*ARGSUSED*/
static void *
smbd_localtime_monitor(void *arg)
{
int timeout;
for (;;) {
gmtoff = smbd_gmtoff();
smbd_report("localtime ioctl: %s",
}
}
/*
* Align the next iteration on a fifteen minute boundary.
*/
}
/*NOTREACHED*/
return (NULL);
}
/*
* smbd_gmtoff
*
* Determine offset from GMT. If daylight saving time use altzone,
* otherwise use timezone.
*/
static int32_t
smbd_gmtoff(void)
{
return (gmtoff);
}
static void
smbd_sig_handler(int sigval)
{
(void) pthread_cond_signal(&refresh_cond);
}
(void) pthread_cond_signal(&refresh_cond);
}
}
/*
* Set up configuration options and parse the command line.
* This function will determine if we will run as a daemon
* or in the foreground.
*
* Failure to find a uid or gid results in using the default (0).
*/
static int
{
int c;
switch (c) {
case 'f':
break;
case ':':
case '?':
default:
return (-1);
}
}
return (0);
}
static void
{
static char *help[] = {
"-f run program in foreground"
};
int i;
}
static void
smbd_report(const char *fmt, ...)
{
char buf[128];
return;
}
static int
smbd_start_listeners(void)
{
int rc1;
int rc2;
(void) pthread_attr_init(&tattr);
if (!smbd.s_nbt_listener_running) {
if (rc1 != 0)
smbd_report("unable to start NBT service");
else
}
if (!smbd.s_tcp_listener_running) {
if (rc2 != 0)
smbd_report("unable to start TCP service");
else
}
(void) pthread_attr_destroy(&tattr);
if (rc1 != 0)
return (rc1);
return (rc2);
}
static void
smbd_stop_listeners(void)
{
void *status;
if (smbd.s_nbt_listener_running) {
}
if (smbd.s_tcp_listener_running) {
}
}
/*
* Enable libumem debugging by default on DEBUG builds.
*/
#ifdef DEBUG
const char *
_umem_debug_init(void)
{
return ("default,verbose"); /* $UMEM_DEBUG setting */
}
const char *
_umem_logging_init(void)
{
return ("fail,contents"); /* $UMEM_LOGGING setting */
}
#endif