xref: /titanic_52/usr/src/cmd/smbsrv/smbd/smbd_main.c (revision b9bd317cda1afb3a01f4812de73e8cec888cbbd7)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25 
26 #pragma ident	"%Z%%M%	%I%	%E% SMI"
27 
28 #include <sys/types.h>
29 #include <sys/stat.h>
30 #include <sys/ioccom.h>
31 #include <stdio.h>
32 #include <string.h>
33 #include <strings.h>
34 #include <stdlib.h>
35 #include <unistd.h>
36 #include <stdarg.h>
37 #include <fcntl.h>
38 #include <wait.h>
39 #include <signal.h>
40 #include <libscf.h>
41 #include <limits.h>
42 #include <priv_utils.h>
43 #include <door.h>
44 #include <errno.h>
45 #include <syslog.h>
46 #include <pthread.h>
47 #include <time.h>
48 #include <libscf.h>
49 #include <zone.h>
50 #include <tzfile.h>
51 #include <libgen.h>
52 #include <pwd.h>
53 #include <grp.h>
54 
55 #include <smbsrv/smb_door_svc.h>
56 #include <smbsrv/smb_ioctl.h>
57 #include <smbsrv/libsmb.h>
58 #include <smbsrv/libsmbns.h>
59 #include <smbsrv/libsmbrdr.h>
60 #include <smbsrv/libmlsvc.h>
61 
62 #include "smbd.h"
63 
64 #define	DRV_DEVICE_PATH	"/devices/pseudo/smbsrv@0:smbsrv"
65 #define	SMB_DBDIR "/var/smb"
66 
67 extern void *smbd_nbt_listener(void *);
68 extern void *smbd_tcp_listener(void *);
69 
70 static int smbd_daemonize_init(void);
71 static void smbd_daemonize_fini(int, int);
72 
73 static int smbd_kernel_bind(void);
74 static void smbd_kernel_unbind(void);
75 static int smbd_already_running(void);
76 
77 static int smbd_service_init(void);
78 static void smbd_service_fini(void);
79 
80 static int smbd_setup_options(int argc, char *argv[]);
81 static void smbd_usage(FILE *fp);
82 static void smbd_report(const char *fmt, ...);
83 
84 static void smbd_sig_handler(int sig);
85 
86 static int smbd_localtime_init(void);
87 static void *smbd_localtime_monitor(void *arg);
88 
89 static pthread_t localtime_thr;
90 
91 static int smbd_refresh_init(void);
92 static void smbd_refresh_fini(void);
93 static void *smbd_refresh_monitor(void *);
94 static pthread_t nbt_listener;
95 static pthread_t tcp_listener;
96 static pthread_t refresh_thr;
97 static pthread_cond_t refresh_cond;
98 static pthread_mutex_t refresh_mutex;
99 
100 smbd_t smbd;
101 
102 /*
103  * smbd user land daemon
104  *
105  * Use SMF error codes only on return or exit.
106  */
107 int
108 main(int argc, char *argv[])
109 {
110 	struct sigaction	act;
111 	sigset_t		set;
112 	uid_t			uid;
113 	int			pfd = -1;
114 
115 	smbd.s_pname = basename(argv[0]);
116 	openlog(smbd.s_pname, LOG_PID | LOG_NOWAIT, LOG_DAEMON);
117 
118 	if (smbd_setup_options(argc, argv) != 0)
119 		return (SMF_EXIT_ERR_FATAL);
120 
121 	if ((uid = getuid()) != smbd.s_uid) {
122 		smbd_report("user %d: %s", uid, strerror(EPERM));
123 		return (SMF_EXIT_ERR_FATAL);
124 	}
125 
126 	if (getzoneid() != GLOBAL_ZONEID) {
127 		smbd_report("non-global zones are not supported");
128 		return (SMF_EXIT_ERR_FATAL);
129 	}
130 
131 	if (is_system_labeled()) {
132 		smbd_report("Trusted Extensions not supported");
133 		return (SMF_EXIT_ERR_FATAL);
134 	}
135 
136 	if (smbd_already_running())
137 		return (SMF_EXIT_OK);
138 
139 	(void) sigfillset(&set);
140 	(void) sigdelset(&set, SIGABRT);
141 
142 	(void) sigfillset(&act.sa_mask);
143 	act.sa_handler = smbd_sig_handler;
144 	act.sa_flags = 0;
145 
146 	(void) sigaction(SIGTERM, &act, NULL);
147 	(void) sigaction(SIGHUP, &act, NULL);
148 	(void) sigaction(SIGINT, &act, NULL);
149 	(void) sigaction(SIGPIPE, &act, NULL);
150 
151 	(void) sigdelset(&set, SIGTERM);
152 	(void) sigdelset(&set, SIGHUP);
153 	(void) sigdelset(&set, SIGINT);
154 	(void) sigdelset(&set, SIGPIPE);
155 
156 	if (smbd.s_fg) {
157 		(void) sigdelset(&set, SIGTSTP);
158 		(void) sigdelset(&set, SIGTTIN);
159 		(void) sigdelset(&set, SIGTTOU);
160 
161 		if (smbd_service_init() != 0) {
162 			smbd_report("service initialization failed");
163 			exit(SMF_EXIT_ERR_FATAL);
164 		}
165 	} else {
166 		/*
167 		 * "pfd" is a pipe descriptor -- any fatal errors
168 		 * during subsequent initialization of the child
169 		 * process should be written to this pipe and the
170 		 * parent will report this error as the exit status.
171 		 */
172 		pfd = smbd_daemonize_init();
173 
174 		if (smbd_service_init() != 0) {
175 			smbd_report("daemon initialization failed");
176 			exit(SMF_EXIT_ERR_FATAL);
177 		}
178 
179 		smbd_daemonize_fini(pfd, SMF_EXIT_OK);
180 	}
181 
182 	(void) atexit(smbd_service_fini);
183 
184 	while (!smbd.s_shutdown_flag) {
185 		(void) sigsuspend(&set);
186 
187 		switch (smbd.s_sigval) {
188 		case 0:
189 			break;
190 
191 		case SIGPIPE:
192 			break;
193 
194 		case SIGHUP:
195 			/* Refresh config was triggered */
196 			if (smbd.s_fg)
197 				smbd_report("reconfiguration requested");
198 			(void) pthread_cond_signal(&refresh_cond);
199 			break;
200 
201 		default:
202 			/*
203 			 * Typically SIGINT or SIGTERM.
204 			 */
205 			smbd.s_shutdown_flag = 1;
206 			break;
207 		}
208 
209 		smbd.s_sigval = 0;
210 	}
211 
212 	smbd_service_fini();
213 	closelog();
214 	return (SMF_EXIT_OK);
215 }
216 
217 /*
218  * This function will fork off a child process,
219  * from which only the child will return.
220  *
221  * Use SMF error codes only on exit.
222  */
223 static int
224 smbd_daemonize_init(void)
225 {
226 	int status, pfds[2];
227 	sigset_t set, oset;
228 	pid_t pid;
229 	int rc;
230 
231 	/*
232 	 * Reset privileges to the minimum set required. We continue
233 	 * to run as root to create and access files in /var.
234 	 */
235 	rc = __init_daemon_priv(PU_RESETGROUPS | PU_LIMITPRIVS,
236 	    smbd.s_uid, smbd.s_gid,
237 	    PRIV_NET_MAC_AWARE, PRIV_NET_PRIVADDR, PRIV_PROC_AUDIT,
238 	    PRIV_SYS_DEVICES, PRIV_SYS_SMB, NULL);
239 
240 	if (rc != 0) {
241 		smbd_report("insufficient privileges");
242 		exit(SMF_EXIT_ERR_FATAL);
243 	}
244 
245 	/*
246 	 * Block all signals prior to the fork and leave them blocked in the
247 	 * parent so we don't get in a situation where the parent gets SIGINT
248 	 * and returns non-zero exit status and the child is actually running.
249 	 * In the child, restore the signal mask once we've done our setsid().
250 	 */
251 	(void) sigfillset(&set);
252 	(void) sigdelset(&set, SIGABRT);
253 	(void) sigprocmask(SIG_BLOCK, &set, &oset);
254 
255 	if (pipe(pfds) == -1) {
256 		smbd_report("unable to create pipe");
257 		exit(SMF_EXIT_ERR_FATAL);
258 	}
259 
260 	closelog();
261 
262 	if ((pid = fork()) == -1) {
263 		openlog(smbd.s_pname, LOG_PID | LOG_NOWAIT, LOG_DAEMON);
264 		smbd_report("unable to fork");
265 		closelog();
266 		exit(SMF_EXIT_ERR_FATAL);
267 	}
268 
269 	/*
270 	 * If we're the parent process, wait for either the child to send us
271 	 * the appropriate exit status over the pipe or for the read to fail
272 	 * (presumably with 0 for EOF if our child terminated abnormally).
273 	 * If the read fails, exit with either the child's exit status if it
274 	 * exited or with SMF_EXIT_ERR_FATAL if it died from a fatal signal.
275 	 */
276 	if (pid != 0) {
277 		(void) close(pfds[1]);
278 
279 		if (read(pfds[0], &status, sizeof (status)) == sizeof (status))
280 			_exit(status);
281 
282 		if (waitpid(pid, &status, 0) == pid && WIFEXITED(status))
283 			_exit(WEXITSTATUS(status));
284 
285 		_exit(SMF_EXIT_ERR_FATAL);
286 	}
287 
288 	openlog(smbd.s_pname, LOG_PID | LOG_NOWAIT, LOG_DAEMON);
289 	smbd.s_pid = getpid();
290 	(void) setsid();
291 	(void) sigprocmask(SIG_SETMASK, &oset, NULL);
292 	(void) chdir("/");
293 	(void) umask(022);
294 	(void) close(pfds[0]);
295 
296 	return (pfds[1]);
297 }
298 
299 static void
300 smbd_daemonize_fini(int fd, int exit_status)
301 {
302 	/*
303 	 * Now that we're running, if a pipe fd was specified, write an exit
304 	 * status to it to indicate that our parent process can safely detach.
305 	 * Then proceed to loading the remaining non-built-in modules.
306 	 */
307 	if (fd >= 0)
308 		(void) write(fd, &exit_status, sizeof (exit_status));
309 
310 	(void) close(fd);
311 
312 	if ((fd = open("/dev/null", O_RDWR)) >= 0) {
313 		(void) fcntl(fd, F_DUP2FD, STDIN_FILENO);
314 		(void) fcntl(fd, F_DUP2FD, STDOUT_FILENO);
315 		(void) fcntl(fd, F_DUP2FD, STDERR_FILENO);
316 		(void) close(fd);
317 	}
318 
319 	__fini_daemon_priv(PRIV_PROC_FORK, PRIV_PROC_EXEC, PRIV_PROC_SESSION,
320 	    PRIV_FILE_LINK_ANY, PRIV_PROC_INFO, NULL);
321 }
322 
323 /*
324  * smbd_service_init
325  */
326 static int
327 smbd_service_init(void)
328 {
329 	int	rc;
330 	char	resource_domain[SMB_PI_MAX_DOMAIN];
331 	char	fqdn[MAXHOSTNAMELEN];
332 
333 	smbd.s_drv_fd = -1;
334 
335 	if ((mkdir(SMB_DBDIR, 0700) < 0) && (errno != EEXIST)) {
336 		smbd_report("mkdir %s: %s", SMB_DBDIR, strerror(errno));
337 		return (1);
338 	}
339 
340 	if ((rc = smb_ccache_init(SMB_VARRUN_DIR, SMB_CCACHE_FILE)) != 0) {
341 		if (rc == -1)
342 			smbd_report("mkdir %s: %s", SMB_VARRUN_DIR,
343 			    strerror(errno));
344 		else
345 			smbd_report("unable to set KRB5CCNAME");
346 		return (1);
347 	}
348 
349 
350 	(void) oem_language_set("english");
351 
352 	if (!smb_wka_init()) {
353 		smbd_report("out of memory");
354 		return (1);
355 	}
356 
357 	if (smb_nicmon_start(SMBD_DEFAULT_INSTANCE_FMRI) != 0)
358 		smbd_report("NIC monitoring failed to start");
359 
360 	if (dns_msgid_init() != 0) {
361 		smbd_report("DNS message id initialization failed");
362 		return (1);
363 	}
364 
365 	smbrdr_init();
366 
367 	if (smb_netbios_start() != 0)
368 		smbd_report("NetBIOS services failed to start");
369 	else
370 		smbd_report("NetBIOS services started");
371 
372 	if (smb_netlogon_init() != 0) {
373 		smbd_report("netlogon initialization failed");
374 		return (1);
375 	}
376 
377 	(void) smb_getdomainname(resource_domain, SMB_PI_MAX_DOMAIN);
378 	(void) utf8_strupr(resource_domain);
379 
380 	/* Get the ID map client handle */
381 	if ((rc = smb_idmap_start()) != 0) {
382 		smbd_report("no idmap handle");
383 		return (rc);
384 	}
385 
386 	smbd.s_secmode = smb_config_get_secmode();
387 	if ((rc = nt_domain_init(resource_domain, smbd.s_secmode)) != 0) {
388 		if (rc == SMB_DOMAIN_NOMACHINE_SID) {
389 			smbd_report(
390 			    "no machine SID: check idmap configuration");
391 			return (rc);
392 		}
393 	}
394 
395 	ads_init();
396 	if ((rc = mlsvc_init()) != 0) {
397 		smbd_report("msrpc initialization failed");
398 		return (rc);
399 	}
400 
401 	if (smbd.s_secmode == SMB_SECMODE_DOMAIN) {
402 		if (!smb_match_netlogon_seqnum())
403 			smb_set_netlogon_cred();
404 		else
405 			(void) smbd_locate_dc(resource_domain, "");
406 
407 		(void) lsa_query_primary_domain_info();
408 	}
409 
410 	smbd.s_door_lmshr = smb_share_dsrv_start();
411 	if (smbd.s_door_lmshr < 0) {
412 		smbd_report("share initialization failed");
413 	}
414 
415 	smbd.s_door_srv = smb_door_srv_start();
416 	if (smbd.s_door_srv < 0)
417 		return (rc);
418 
419 	if ((rc = smbd_refresh_init()) != 0)
420 		return (rc);
421 
422 	if (smb_getfqdomainname(fqdn, MAXHOSTNAMELEN) == 0)
423 		(void) dyndns_update_core(fqdn);
424 
425 	(void) smbd_localtime_init();
426 
427 	smbd.s_door_winpipe = smb_winpipe_doorsvc_start();
428 	if (smbd.s_door_winpipe < 0) {
429 		smbd_report("winpipe initialization failed %s",
430 		    strerror(errno));
431 		return (rc);
432 	}
433 
434 	(void) smb_lgrp_start();
435 
436 	(void) smb_pwd_init();
437 
438 	rc = smbd_kernel_bind();
439 	if (rc != 0) {
440 		smbd_report("kernel bind error: %s", strerror(errno));
441 		return (rc);
442 	}
443 
444 	return (lmshare_start());
445 }
446 
447 /*
448  * Close the kernel service and shutdown smbd services.
449  * This function is registered with atexit(): ensure that anything
450  * called from here is safe to be called multiple times.
451  */
452 static void
453 smbd_service_fini(void)
454 {
455 	smb_winpipe_doorsvc_stop();
456 	smb_wka_fini();
457 	smbd_refresh_fini();
458 	smbd_kernel_unbind();
459 	smb_door_srv_stop();
460 	smb_share_dsrv_stop();
461 	lmshare_stop();
462 	smb_nicmon_stop();
463 	smb_idmap_stop();
464 	smb_lgrp_stop();
465 	smb_ccache_remove(SMB_CCACHE_PATH);
466 	smb_pwd_fini();
467 
468 }
469 
470 
471 /*
472  * smbd_refresh_init()
473  *
474  * SMB service refresh thread initialization.  This thread waits for a
475  * refresh event and updates the daemon's view of the configuration
476  * before going back to sleep.
477  */
478 static int
479 smbd_refresh_init()
480 {
481 	pthread_attr_t		tattr;
482 	pthread_condattr_t	cattr;
483 	int			rc;
484 
485 	(void) pthread_condattr_init(&cattr);
486 	(void) pthread_cond_init(&refresh_cond, &cattr);
487 	(void) pthread_condattr_destroy(&cattr);
488 
489 	(void) pthread_mutex_init(&refresh_mutex, NULL);
490 
491 	(void) pthread_attr_init(&tattr);
492 	(void) pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_DETACHED);
493 	rc = pthread_create(&refresh_thr, &tattr, smbd_refresh_monitor, 0);
494 	(void) pthread_attr_destroy(&tattr);
495 
496 	return (rc);
497 }
498 
499 /*
500  * smbd_refresh_fini()
501  *
502  * Stop the refresh thread.
503  */
504 static void
505 smbd_refresh_fini()
506 {
507 	(void) pthread_cancel(refresh_thr);
508 
509 	(void) pthread_cond_destroy(&refresh_cond);
510 	(void) pthread_mutex_destroy(&refresh_mutex);
511 }
512 
513 /*
514  * smbd_refresh_monitor()
515  *
516  * Wait for a refresh event. When this thread wakes up, update the
517  * smbd configuration from the SMF config information then go back to
518  * wait for the next refresh.
519  */
520 /*ARGSUSED*/
521 static void *
522 smbd_refresh_monitor(void *arg)
523 {
524 	smb_io_t	smb_io;
525 	size_t		len;
526 	char		*new_dom;
527 	int		new_secmod;
528 	char		*old_dom;
529 	char		fqdn[MAXHOSTNAMELEN];
530 	int		rc = 0;
531 
532 	bzero(&smb_io, sizeof (smb_io));
533 	smb_io.sio_version = SMB_IOC_VERSION;
534 
535 	(void) pthread_mutex_lock(&refresh_mutex);
536 	while (pthread_cond_wait(&refresh_cond, &refresh_mutex) == 0) {
537 		/*
538 		 * We've been woken up by a refresh event so go do
539 		 * what is necessary.
540 		 */
541 		ads_refresh();
542 		smb_ccache_remove(SMB_CCACHE_PATH);
543 
544 		if ((rc = smb_getfqdomainname(fqdn, MAXHOSTNAMELEN)) != 0)
545 			smbd_report("failed to get fully qualified domainname");
546 
547 		if (rc == 0)
548 			/* Clear rev zone before creating if list */
549 			if (dyndns_clear_rev_zone(fqdn) != 0)
550 				smbd_report("failed to clear DNS reverse "
551 				    "lookup zone");
552 
553 		/* re-initialize NIC table */
554 		if (smb_nic_init() != 0)
555 			smbd_report("failed to get NIC information");
556 
557 		smb_netbios_name_reconfig();
558 		smb_browser_reconfig();
559 
560 		if (rc == 0)
561 			if (dyndns_update_core(fqdn) != 0)
562 				smbd_report("failed to update dynamic DNS");
563 
564 		smb_set_netlogon_cred();
565 
566 		smb_load_kconfig(&smb_io.sio_data.cfg);
567 		new_dom = smb_io.sio_data.cfg.skc_resource_domain;
568 		old_dom = smbd.s_kcfg.skc_resource_domain;
569 		len = strlen(old_dom);
570 		new_secmod = smb_config_get_secmode();
571 		if ((len != strlen(new_dom)) ||
572 		    (strncasecmp(new_dom, old_dom, len)) ||
573 		    (new_secmod != smbd.s_secmode) ||
574 		    (smbd.s_drv_fd == -1)) {
575 			/*
576 			 * The active sessions have to be disconnected.
577 			 */
578 			smbd_kernel_unbind();
579 			if (smbd_kernel_bind()) {
580 				smbd_report("kernel bind error: %s",
581 				    strerror(errno));
582 			}
583 			continue;
584 		}
585 
586 		bcopy(&smb_io.sio_data.cfg, &smbd.s_kcfg, sizeof (smbd.s_kcfg));
587 		if (ioctl(smbd.s_drv_fd, SMB_IOC_CONFIG, &smb_io) < 0) {
588 			smbd_report("configuration update ioctl: %s",
589 			    strerror(errno));
590 		}
591 	}
592 	return (NULL);
593 }
594 
595 
596 /*
597  * If the door has already been opened by another process (non-zero pid
598  * in target), we assume that another smbd is already running.  If there
599  * is a race here, it will be caught later when smbsrv is opened because
600  * only one process is allowed to open the device at a time.
601  */
602 static int
603 smbd_already_running(void)
604 {
605 	door_info_t info;
606 	int door;
607 
608 	if ((door = open(SMB_DR_SVC_NAME, O_RDONLY)) < 0)
609 		return (0);
610 
611 	if (door_info(door, &info) < 0)
612 		return (0);
613 
614 	if (info.di_target > 0) {
615 		smbd_report("already running: pid %ld\n", info.di_target);
616 		(void) close(door);
617 		return (1);
618 	}
619 
620 	(void) close(door);
621 	return (0);
622 }
623 
624 /*
625  * smbd_kernel_bind
626  *
627  * This function open the smbsrv device and start the kernel service.
628  */
629 static int
630 smbd_kernel_bind(void)
631 {
632 	smb_io_t	smb_io;
633 	int		rc;
634 
635 	bzero(&smb_io, sizeof (smb_io));
636 	smb_io.sio_version = SMB_IOC_VERSION;
637 
638 	if (smbd.s_drv_fd != -1)
639 		(void) close(smbd.s_drv_fd);
640 
641 	if ((smbd.s_drv_fd = open(DRV_DEVICE_PATH, 0)) < 0) {
642 		smbd.s_drv_fd = -1;
643 		return (errno);
644 	}
645 	smb_load_kconfig(&smbd.s_kcfg);
646 	bcopy(&smbd.s_kcfg, &smb_io.sio_data.cfg, sizeof (smb_io.sio_data.cfg));
647 	if (ioctl(smbd.s_drv_fd, SMB_IOC_CONFIG, &smb_io) < 0) {
648 		(void) close(smbd.s_drv_fd);
649 		smbd.s_drv_fd = -1;
650 		return (errno);
651 	}
652 	smb_io.sio_data.gmtoff = (uint32_t)(-altzone);
653 	if (ioctl(smbd.s_drv_fd, SMB_IOC_GMTOFF, &smb_io) < 0) {
654 		(void) close(smbd.s_drv_fd);
655 		smbd.s_drv_fd = -1;
656 		return (errno);
657 	}
658 	smb_io.sio_data.start.winpipe = smbd.s_door_winpipe;
659 	smb_io.sio_data.start.lmshrd = smbd.s_door_lmshr;
660 	smb_io.sio_data.start.udoor = smbd.s_door_srv;
661 	if (ioctl(smbd.s_drv_fd, SMB_IOC_START, &smb_io) < 0) {
662 		(void) close(smbd.s_drv_fd);
663 		smbd.s_drv_fd = -1;
664 		return (errno);
665 	}
666 
667 	rc = pthread_create(&nbt_listener, NULL, smbd_nbt_listener, NULL);
668 	if (rc == 0) {
669 		rc = pthread_create(&tcp_listener, NULL, smbd_tcp_listener,
670 		    NULL);
671 		if (rc == 0) {
672 			smbd.s_kbound = B_TRUE;
673 			return (0);
674 		}
675 	}
676 
677 	rc = pthread_create(&nbt_listener, NULL, smbd_nbt_listener, NULL);
678 	if (rc == 0) {
679 		rc = pthread_create(&tcp_listener, NULL, smbd_tcp_listener,
680 		    NULL);
681 		if (rc == 0) {
682 			smbd.s_kbound = B_TRUE;
683 			return (0);
684 		}
685 	}
686 	(void) close(smbd.s_drv_fd);
687 	smbd.s_drv_fd = -1;
688 	return (rc);
689 }
690 
691 /*
692  * smbd_kernel_unbind
693  */
694 static void
695 smbd_kernel_unbind(void)
696 {
697 	if (smbd.s_drv_fd != -1) {
698 		(void) close(smbd.s_drv_fd);
699 		smbd.s_drv_fd = -1;
700 		smbd.s_kbound = B_FALSE;
701 	}
702 }
703 
704 /*
705  * Initialization of the localtime thread.
706  * Returns 0 on success, an error number if thread creation fails.
707  */
708 
709 int
710 smbd_localtime_init(void)
711 {
712 	pthread_attr_t tattr;
713 	int rc;
714 
715 	(void) pthread_attr_init(&tattr);
716 	(void) pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_DETACHED);
717 	rc = pthread_create(&localtime_thr, &tattr, smbd_localtime_monitor, 0);
718 	(void) pthread_attr_destroy(&tattr);
719 	return (rc);
720 }
721 
722 /*
723  * Local time thread to kernel land.
724  * Send local gmtoff to kernel module one time at startup
725  * and each time it changes (up to twice a year).
726  * Local gmtoff is checked once every 15 minutes and
727  * since some timezones are aligned on half and qtr hour boundaries,
728  * once an hour would likely suffice.
729  */
730 
731 /*ARGSUSED*/
732 static void *
733 smbd_localtime_monitor(void *arg)
734 {
735 	struct tm local_tm;
736 	time_t secs, gmtoff;
737 	time_t last_gmtoff = -1;
738 	int timeout;
739 
740 	for (;;) {
741 		gmtoff = -altzone;
742 
743 		if ((last_gmtoff != gmtoff) && (smbd.s_drv_fd != -1)) {
744 			if (ioctl(smbd.s_drv_fd, SMB_IOC_GMTOFF, &gmtoff) < 0) {
745 				smbd_report("localtime ioctl: %s",
746 				    strerror(errno));
747 			}
748 		}
749 
750 		/*
751 		 * Align the next iteration on a fifteen minute boundary.
752 		 */
753 		secs = time(0);
754 		(void) localtime_r(&secs, &local_tm);
755 		timeout = ((15 - (local_tm.tm_min % 15)) * SECSPERMIN);
756 		(void) sleep(timeout);
757 
758 		last_gmtoff = gmtoff;
759 	}
760 
761 	/*NOTREACHED*/
762 	return (NULL);
763 }
764 
765 static void
766 smbd_sig_handler(int sigval)
767 {
768 	if (smbd.s_sigval == 0)
769 		smbd.s_sigval = sigval;
770 }
771 
772 /*
773  * Set up configuration options and parse the command line.
774  * This function will determine if we will run as a daemon
775  * or in the foreground.
776  *
777  * Failure to find a uid or gid results in using the default (0).
778  */
779 static int
780 smbd_setup_options(int argc, char *argv[])
781 {
782 	struct passwd *pwd;
783 	struct group *grp;
784 	int c;
785 
786 	if ((pwd = getpwnam("root")) != NULL)
787 		smbd.s_uid = pwd->pw_uid;
788 
789 	if ((grp = getgrnam("sys")) != NULL)
790 		smbd.s_gid = grp->gr_gid;
791 
792 	smbd.s_fg = smb_config_get_fg_flag();
793 
794 	while ((c = getopt(argc, argv, ":f")) != -1) {
795 		switch (c) {
796 		case 'f':
797 			smbd.s_fg = 1;
798 			break;
799 
800 		case ':':
801 		case '?':
802 		default:
803 			smbd_usage(stderr);
804 			return (-1);
805 		}
806 	}
807 
808 	return (0);
809 }
810 
811 static void
812 smbd_usage(FILE *fp)
813 {
814 	static char *help[] = {
815 		"-f  run program in foreground"
816 	};
817 
818 	int i;
819 
820 	(void) fprintf(fp, "Usage: %s [-f]\n", smbd.s_pname);
821 
822 	for (i = 0; i < sizeof (help)/sizeof (help[0]); ++i)
823 		(void) fprintf(fp, "    %s\n", help[i]);
824 }
825 
826 static void
827 smbd_report(const char *fmt, ...)
828 {
829 	char buf[128];
830 	va_list ap;
831 
832 	if (fmt == NULL)
833 		return;
834 
835 	va_start(ap, fmt);
836 	(void) vsnprintf(buf, 128, fmt, ap);
837 	va_end(ap);
838 
839 	(void) fprintf(stderr, "smbd: %s\n", buf);
840 }
841 
842 /*
843  * Enable libumem debugging by default on DEBUG builds.
844  */
845 #ifdef DEBUG
846 const char *
847 _umem_debug_init(void)
848 {
849 	return ("default,verbose"); /* $UMEM_DEBUG setting */
850 }
851 
852 const char *
853 _umem_logging_init(void)
854 {
855 	return ("fail,contents"); /* $UMEM_LOGGING setting */
856 }
857 #endif
858