xref: /titanic_51/usr/src/lib/smbsrv/libsmb/common/smb_domain.c (revision 7f11fd00fc23e2af7ae21cc8837a2b86380dcfa7)
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 2009 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  *
25  * Copyright 2014 Nexenta Systems, Inc.  All rights reserved.
26  */
27 
28 /*
29  * This file defines the domain environment values and the domain
30  * database interface. The database is a single linked list of
31  * structures containing domain type, name and SID information.
32  */
33 
34 #include <sys/types.h>
35 #include <sys/stat.h>
36 #include <sys/list.h>
37 #include <stdio.h>
38 #include <strings.h>
39 #include <string.h>
40 #include <unistd.h>
41 #include <stdlib.h>
42 #include <synch.h>
43 #include <pwd.h>
44 #include <grp.h>
45 #include <assert.h>
46 
47 #include <smbsrv/smbinfo.h>
48 #include <smbsrv/string.h>
49 #include <smbsrv/smb_sid.h>
50 #include <smbsrv/libsmb.h>
51 
52 #define	SMB_DOMAINS_FILE	"domains"
53 
54 #define	SMB_DCACHE_UPDATE_WAIT	45	/* seconds */
55 
56 /*
57  * Domain cache states
58  */
59 #define	SMB_DCACHE_STATE_NONE		0
60 #define	SMB_DCACHE_STATE_READY		1
61 #define	SMB_DCACHE_STATE_UPDATING	2
62 #define	SMB_DCACHE_STATE_DESTROYING	3
63 
64 /*
65  * Cache lock modes
66  */
67 #define	SMB_DCACHE_RDLOCK	0
68 #define	SMB_DCACHE_WRLOCK	1
69 
70 typedef struct smb_domain_cache {
71 	list_t		dc_cache;
72 	rwlock_t	dc_cache_lck;
73 	mutex_t		dc_mtx;
74 	cond_t		dc_cv;
75 	uint32_t	dc_state;
76 	uint32_t	dc_nops;
77 	smb_dcinfo_t	dc_dci;
78 } smb_domain_cache_t;
79 
80 static smb_domain_cache_t smb_dcache;
81 
82 static uint32_t smb_domain_add(smb_domain_type_t, smb_domain_t *);
83 static uint32_t smb_domain_add_local(void);
84 static uint32_t smb_domain_add_primary(uint32_t);
85 static void smb_domain_unlink(void);
86 
87 static void smb_dcache_create(void);
88 static void smb_dcache_destroy(void);
89 static uint32_t smb_dcache_lock(int);
90 static void smb_dcache_unlock(void);
91 static void smb_dcache_remove(smb_domain_t *);
92 static uint32_t smb_dcache_add(smb_domain_t *);
93 static boolean_t smb_dcache_getdc(smb_dcinfo_t *);
94 static void smb_dcache_setdc(const smb_dcinfo_t *);
95 static boolean_t smb_dcache_wait(void);
96 static uint32_t smb_dcache_updating(void);
97 static void smb_dcache_ready(void);
98 
99 /*
100  * domain cache one time initialization. This function should
101  * only be called during service startup.
102  *
103  * Returns 0 on success and an error code on failure.
104  */
105 int
106 smb_domain_init(uint32_t secmode)
107 {
108 	smb_domain_t di;
109 	int rc;
110 
111 	smb_dcache_create();
112 
113 	if ((rc = smb_domain_add_local()) != 0)
114 		return (rc);
115 
116 	smb_domain_set_basic_info(NT_BUILTIN_DOMAIN_SIDSTR, "BUILTIN", "", &di);
117 	(void) smb_domain_add(SMB_DOMAIN_BUILTIN, &di);
118 
119 	return (smb_domain_add_primary(secmode));
120 }
121 
122 /*
123  * Destroys the cache upon service termination
124  */
125 void
126 smb_domain_fini(void)
127 {
128 	smb_dcache_destroy();
129 	smb_domain_unlink();
130 }
131 
132 /*
133  * Add a domain structure to domain cache. There is no checking
134  * for duplicates.
135  */
136 static uint32_t
137 smb_domain_add(smb_domain_type_t type, smb_domain_t *di)
138 {
139 	uint32_t res;
140 
141 	if ((di == NULL) || (di->di_sid == NULL))
142 		return (SMB_DOMAIN_INVALID_ARG);
143 
144 	if ((res = smb_dcache_lock(SMB_DCACHE_WRLOCK)) == SMB_DOMAIN_SUCCESS) {
145 		di->di_type = type;
146 		res = smb_dcache_add(di);
147 		smb_dcache_unlock();
148 	}
149 
150 	return (res);
151 }
152 
153 /*
154  * Lookup a domain by its name. The passed name is the NETBIOS or fully
155  * qualified DNS name or non-qualified DNS name.
156  *
157  * If the requested domain is found and given 'di' pointer is not NULL
158  * it'll be filled with the domain information and B_TRUE is returned.
159  * If the caller only needs to check a domain existence it can pass
160  * NULL for 'di' and just check the return value.
161  *
162  * If the domain is not in the cache B_FALSE is returned.
163  */
164 boolean_t
165 smb_domain_lookup_name(char *name, smb_domain_t *di)
166 {
167 	boolean_t found = B_FALSE;
168 	smb_domain_t *dcnode;
169 	char *p;
170 
171 	bzero(di, sizeof (smb_domain_t));
172 
173 	if (name == NULL || *name == '\0')
174 		return (B_FALSE);
175 
176 	if (smb_dcache_lock(SMB_DCACHE_RDLOCK) != SMB_DOMAIN_SUCCESS)
177 		return (B_FALSE);
178 
179 	dcnode = list_head(&smb_dcache.dc_cache);
180 	while (dcnode) {
181 		found = (smb_strcasecmp(dcnode->di_nbname, name, 0) == 0) ||
182 		    (smb_strcasecmp(dcnode->di_fqname, name, 0) == 0);
183 
184 		if (found) {
185 			if (di)
186 				*di = *dcnode;
187 			break;
188 		}
189 
190 		if ((p = strchr(dcnode->di_fqname, '.')) != NULL) {
191 			*p = '\0';
192 			found = (smb_strcasecmp(dcnode->di_fqname, name,
193 			    0) == 0);
194 			*p = '.';
195 			if (found) {
196 				if (di)
197 					*di = *dcnode;
198 				break;
199 			}
200 		}
201 
202 		dcnode = list_next(&smb_dcache.dc_cache, dcnode);
203 	}
204 
205 	smb_dcache_unlock();
206 	return (found);
207 }
208 
209 /*
210  * Lookup a domain by its SID.
211  *
212  * If the requested domain is found and given 'di' pointer is not NULL
213  * it'll be filled with the domain information and B_TRUE is returned.
214  * If the caller only needs to check a domain existence it can pass
215  * NULL for 'di' and just check the return value.
216  *
217  * If the domain is not in the cache B_FALSE is returned.
218  */
219 boolean_t
220 smb_domain_lookup_sid(smb_sid_t *sid, smb_domain_t *di)
221 {
222 	boolean_t found = B_FALSE;
223 	smb_domain_t *dcnode;
224 	char sidstr[SMB_SID_STRSZ];
225 
226 	bzero(di, sizeof (smb_domain_t));
227 
228 	if (sid == NULL)
229 		return (B_FALSE);
230 
231 	smb_sid_tostr(sid, sidstr);
232 
233 	if (smb_dcache_lock(SMB_DCACHE_RDLOCK) != SMB_DOMAIN_SUCCESS)
234 		return (B_FALSE);
235 
236 	dcnode = list_head(&smb_dcache.dc_cache);
237 	while (dcnode) {
238 		found = (strcmp(dcnode->di_sid, sidstr) == 0);
239 		if (found) {
240 			if (di)
241 				*di = *dcnode;
242 			break;
243 		}
244 
245 		dcnode = list_next(&smb_dcache.dc_cache, dcnode);
246 	}
247 
248 	smb_dcache_unlock();
249 	return (found);
250 }
251 
252 /*
253  * Lookup a domain by its type.
254  *
255  * If the requested domain is found and given 'di' pointer is not NULL
256  * it'll be filled with the domain information and B_TRUE is returned.
257  * If the caller only needs to check a domain existence it can pass
258  * NULL for 'di' and just check the return value.
259  *
260  * If the domain is not in the cache B_FALSE is returned.
261  */
262 boolean_t
263 smb_domain_lookup_type(smb_domain_type_t type, smb_domain_t *di)
264 {
265 	boolean_t found = B_FALSE;
266 	smb_domain_t *dcnode;
267 
268 	bzero(di, sizeof (smb_domain_t));
269 
270 	if (smb_dcache_lock(SMB_DCACHE_RDLOCK) != SMB_DOMAIN_SUCCESS)
271 		return (B_FALSE);
272 
273 	dcnode = list_head(&smb_dcache.dc_cache);
274 	while (dcnode) {
275 		if (dcnode->di_type == type) {
276 			found = B_TRUE;
277 			if (di)
278 				*di = *dcnode;
279 			break;
280 		}
281 
282 		dcnode = list_next(&smb_dcache.dc_cache, dcnode);
283 	}
284 
285 	smb_dcache_unlock();
286 	return (found);
287 }
288 
289 /*
290  * Returns primary domain information plus the name of
291  * the selected domain controller.
292  */
293 boolean_t
294 smb_domain_getinfo(smb_domainex_t *dxi)
295 {
296 	boolean_t rv;
297 
298 	/* Note: this waits for the dcache lock. */
299 	rv = smb_domain_lookup_type(SMB_DOMAIN_PRIMARY, &dxi->d_primary);
300 	if (rv)
301 		rv = smb_dcache_getdc(&dxi->d_dci);
302 
303 	return (rv);
304 }
305 
306 /*
307  * Get the name of the current DC (if any)
308  * Does NOT block.
309  */
310 void
311 smb_domain_current_dc(smb_dcinfo_t *dci)
312 {
313 	(void) smb_dcache_getdc(dci);
314 }
315 
316 /*
317  * Transfer the cache to updating state.
318  * In this state any request for reading the cache would
319  * be blocked until the update is finished.
320  */
321 uint32_t
322 smb_domain_start_update(void)
323 {
324 	return (smb_dcache_updating());
325 }
326 
327 /*
328  * Transfer the cache from updating to ready state.
329  */
330 void
331 smb_domain_end_update(void)
332 {
333 	smb_dcache_ready();
334 }
335 
336 /*
337  * Updates the cache with given information for the primary
338  * domain, possible trusted domains and the selected domain
339  * controller.
340  *
341  * Before adding the new entries existing entries of type
342  * primary and trusted will be removed from cache.
343  */
344 void
345 smb_domain_update(smb_domainex_t *dxi)
346 {
347 	smb_domain_t *dcnode;
348 	int i;
349 
350 	if (smb_dcache_lock(SMB_DCACHE_WRLOCK) != SMB_DOMAIN_SUCCESS)
351 		return;
352 
353 	dcnode = list_head(&smb_dcache.dc_cache);
354 	while (dcnode) {
355 		if ((dcnode->di_type == SMB_DOMAIN_PRIMARY) ||
356 		    (dcnode->di_type == SMB_DOMAIN_TRUSTED)) {
357 			smb_dcache_remove(dcnode);
358 			dcnode = list_head(&smb_dcache.dc_cache);
359 		} else {
360 			dcnode = list_next(&smb_dcache.dc_cache, dcnode);
361 		}
362 	}
363 
364 	if (smb_dcache_add(&dxi->d_primary) == SMB_DOMAIN_SUCCESS) {
365 		for (i = 0; i < dxi->d_trusted.td_num; i++)
366 			(void) smb_dcache_add(&dxi->d_trusted.td_domains[i]);
367 
368 		smb_dcache_setdc(&dxi->d_dci);
369 	}
370 
371 	smb_dcache_unlock();
372 }
373 
374 /*
375  * Write the list of domains to /var/run/smb/domains.
376  */
377 void
378 smb_domain_save(void)
379 {
380 	char		fname[MAXPATHLEN];
381 	char		tag;
382 	smb_domain_t	*domain;
383 	FILE		*fp;
384 	struct passwd	*pwd;
385 	struct group	*grp;
386 	uid_t		uid;
387 	gid_t		gid;
388 
389 	(void) snprintf(fname, MAXPATHLEN, "%s/%s",
390 	    SMB_VARRUN_DIR, SMB_DOMAINS_FILE);
391 
392 	if ((fp = fopen(fname, "w")) == NULL)
393 		return;
394 
395 	pwd = getpwnam("root");
396 	grp = getgrnam("sys");
397 	uid = (pwd == NULL) ? 0 : pwd->pw_uid;
398 	gid = (grp == NULL) ? 3 : grp->gr_gid;
399 
400 	(void) lockf(fileno(fp), F_LOCK, 0);
401 	(void) fchmod(fileno(fp), 0600);
402 	(void) fchown(fileno(fp), uid, gid);
403 
404 	if (smb_dcache_lock(SMB_DCACHE_RDLOCK) != SMB_DOMAIN_SUCCESS)
405 		return;
406 
407 	domain = list_head(&smb_dcache.dc_cache);
408 	while (domain) {
409 		switch (domain->di_type) {
410 		case SMB_DOMAIN_PRIMARY:
411 			tag = '*';
412 			break;
413 
414 		case SMB_DOMAIN_TRUSTED:
415 		case SMB_DOMAIN_UNTRUSTED:
416 			tag = '-';
417 			break;
418 
419 		case SMB_DOMAIN_LOCAL:
420 			tag = '.';
421 			break;
422 		default:
423 			domain = list_next(&smb_dcache.dc_cache, domain);
424 			continue;
425 		}
426 
427 		(void) fprintf(fp, "[%c] [%s] [%s]\n",
428 		    tag, domain->di_nbname, domain->di_sid);
429 
430 		domain = list_next(&smb_dcache.dc_cache, domain);
431 	}
432 
433 	smb_dcache_unlock();
434 	(void) lockf(fileno(fp), F_ULOCK, 0);
435 	(void) fclose(fp);
436 }
437 
438 /*
439  * List the domains in /var/run/smb/domains.
440  */
441 void
442 smb_domain_show(void)
443 {
444 	char buf[MAXPATHLEN];
445 	char *p;
446 	FILE *fp;
447 
448 	(void) snprintf(buf, MAXPATHLEN, "%s/%s",
449 	    SMB_VARRUN_DIR, SMB_DOMAINS_FILE);
450 
451 	if ((fp = fopen(buf, "r")) != NULL) {
452 		(void) lockf(fileno(fp), F_LOCK, 0);
453 
454 		while (fgets(buf, MAXPATHLEN, fp) != NULL) {
455 			if ((p = strchr(buf, '\n')) != NULL)
456 				*p = '\0';
457 			(void) printf("%s\n", buf);
458 		}
459 
460 		(void) lockf(fileno(fp), F_ULOCK, 0);
461 		(void) fclose(fp);
462 	}
463 }
464 
465 void
466 smb_domain_set_basic_info(char *sid, char *nb_domain, char *fq_domain,
467     smb_domain_t *di)
468 {
469 	if (sid == NULL || nb_domain == NULL || fq_domain == NULL ||
470 	    di == NULL)
471 		return;
472 
473 	(void) strlcpy(di->di_sid, sid, SMB_SID_STRSZ);
474 	(void) strlcpy(di->di_nbname, nb_domain, NETBIOS_NAME_SZ);
475 	(void) smb_strupr(di->di_nbname);
476 	(void) strlcpy(di->di_fqname, fq_domain, MAXHOSTNAMELEN);
477 	di->di_binsid = NULL;
478 }
479 
480 void
481 smb_domain_set_dns_info(char *sid, char *nb_domain, char *fq_domain,
482     char *forest, char *guid, smb_domain_t *di)
483 {
484 	if (di == NULL || forest == NULL || guid == NULL)
485 		return;
486 
487 	smb_domain_set_basic_info(sid, nb_domain, fq_domain, di);
488 	(void) strlcpy(di->di_u.di_dns.ddi_forest, forest, MAXHOSTNAMELEN);
489 	(void) strlcpy(di->di_u.di_dns.ddi_guid, guid,
490 	    UUID_PRINTABLE_STRING_LENGTH);
491 }
492 
493 void
494 smb_domain_set_trust_info(char *sid, char *nb_domain, char *fq_domain,
495     uint32_t trust_dir, uint32_t trust_type, uint32_t trust_attrs,
496     smb_domain_t *di)
497 {
498 	smb_domain_trust_t *ti;
499 
500 	if (di == NULL)
501 		return;
502 
503 	di->di_type = SMB_DOMAIN_TRUSTED;
504 	ti = &di->di_u.di_trust;
505 	smb_domain_set_basic_info(sid, nb_domain, fq_domain, di);
506 	ti->dti_trust_direction = trust_dir;
507 	ti->dti_trust_type = trust_type;
508 	ti->dti_trust_attrs = trust_attrs;
509 }
510 
511 /*
512  * Remove the /var/run/smb/domains file.
513  */
514 static void
515 smb_domain_unlink(void)
516 {
517 	char fname[MAXPATHLEN];
518 
519 	(void) snprintf(fname, MAXPATHLEN, "%s/%s",
520 	    SMB_VARRUN_DIR, SMB_DOMAINS_FILE);
521 	(void) unlink(fname);
522 }
523 
524 /*
525  * Add an entry for the local domain to the domain cache
526  */
527 static uint32_t
528 smb_domain_add_local(void)
529 {
530 	char *lsidstr;
531 	char hostname[NETBIOS_NAME_SZ];
532 	char fq_name[MAXHOSTNAMELEN];
533 	smb_domain_t di;
534 
535 	if ((lsidstr = smb_config_get_localsid()) == NULL)
536 		return (SMB_DOMAIN_NOMACHINE_SID);
537 
538 	if (smb_getnetbiosname(hostname, NETBIOS_NAME_SZ) != 0) {
539 		free(lsidstr);
540 		return (SMB_DOMAIN_NOMACHINE_SID);
541 	}
542 
543 	*fq_name = '\0';
544 	(void) smb_getfqhostname(fq_name, MAXHOSTNAMELEN);
545 	smb_domain_set_basic_info(lsidstr, hostname, fq_name, &di);
546 	(void) smb_domain_add(SMB_DOMAIN_LOCAL, &di);
547 
548 	free(lsidstr);
549 	return (SMB_DOMAIN_SUCCESS);
550 }
551 
552 /*
553  * Add an entry for the primary domain to the domain cache
554  */
555 static uint32_t
556 smb_domain_add_primary(uint32_t secmode)
557 {
558 	char sidstr[SMB_SID_STRSZ];
559 	char fq_name[MAXHOSTNAMELEN];
560 	char nb_name[NETBIOS_NAME_SZ];
561 	smb_domain_t di;
562 	int rc;
563 
564 	if (secmode != SMB_SECMODE_DOMAIN)
565 		return (SMB_DOMAIN_SUCCESS);
566 
567 	rc = smb_config_getstr(SMB_CI_DOMAIN_SID, sidstr, sizeof (sidstr));
568 	if (rc != SMBD_SMF_OK)
569 		return (SMB_DOMAIN_NODOMAIN_SID);
570 
571 	rc = smb_config_getstr(SMB_CI_DOMAIN_NAME, nb_name, NETBIOS_NAME_SZ);
572 	if ((rc != SMBD_SMF_OK) || (*nb_name == '\0'))
573 		return (SMB_DOMAIN_NODOMAIN_NAME);
574 
575 	(void) smb_getfqdomainname(fq_name, MAXHOSTNAMELEN);
576 	smb_domain_set_basic_info(sidstr, nb_name, fq_name, &di);
577 	(void) smb_domain_add(SMB_DOMAIN_PRIMARY, &di);
578 	return (SMB_DOMAIN_SUCCESS);
579 }
580 
581 /*
582  * Initialize the domain cache.
583  * This function does not populate the cache.
584  */
585 static void
586 smb_dcache_create(void)
587 {
588 	(void) mutex_lock(&smb_dcache.dc_mtx);
589 	if (smb_dcache.dc_state != SMB_DCACHE_STATE_NONE) {
590 		(void) mutex_unlock(&smb_dcache.dc_mtx);
591 		return;
592 	}
593 
594 	list_create(&smb_dcache.dc_cache, sizeof (smb_domain_t),
595 	    offsetof(smb_domain_t, di_lnd));
596 
597 	smb_dcache.dc_nops = 0;
598 	bzero(&smb_dcache.dc_dci, sizeof (smb_dcache.dc_dci));
599 	smb_dcache.dc_state = SMB_DCACHE_STATE_READY;
600 	(void) mutex_unlock(&smb_dcache.dc_mtx);
601 }
602 
603 /*
604  * Removes and frees all the cache entries
605  */
606 static void
607 smb_dcache_flush(void)
608 {
609 	smb_domain_t *di;
610 
611 	(void) rw_wrlock(&smb_dcache.dc_cache_lck);
612 	while ((di = list_head(&smb_dcache.dc_cache)) != NULL)
613 		smb_dcache_remove(di);
614 	(void) rw_unlock(&smb_dcache.dc_cache_lck);
615 }
616 
617 /*
618  * Destroys the cache.
619  */
620 static void
621 smb_dcache_destroy(void)
622 {
623 	(void) mutex_lock(&smb_dcache.dc_mtx);
624 	if ((smb_dcache.dc_state == SMB_DCACHE_STATE_READY) ||
625 	    (smb_dcache.dc_state == SMB_DCACHE_STATE_UPDATING)) {
626 		smb_dcache.dc_state = SMB_DCACHE_STATE_DESTROYING;
627 		while (smb_dcache.dc_nops > 0)
628 			(void) cond_wait(&smb_dcache.dc_cv,
629 			    &smb_dcache.dc_mtx);
630 
631 		smb_dcache_flush();
632 		list_destroy(&smb_dcache.dc_cache);
633 
634 		smb_dcache.dc_state = SMB_DCACHE_STATE_NONE;
635 	}
636 	(void) mutex_unlock(&smb_dcache.dc_mtx);
637 }
638 
639 /*
640  * Lock the cache with the specified mode.
641  * If the cache is in updating state and a read lock is
642  * requested, the lock won't be granted until either the
643  * update is finished or SMB_DCACHE_UPDATE_WAIT has passed.
644  *
645  * Whenever a lock is granted, the number of inflight cache
646  * operations is incremented.
647  */
648 static uint32_t
649 smb_dcache_lock(int mode)
650 {
651 	(void) mutex_lock(&smb_dcache.dc_mtx);
652 	switch (smb_dcache.dc_state) {
653 	case SMB_DCACHE_STATE_NONE:
654 	case SMB_DCACHE_STATE_DESTROYING:
655 		(void) mutex_unlock(&smb_dcache.dc_mtx);
656 		return (SMB_DOMAIN_INTERNAL_ERR);
657 
658 	case SMB_DCACHE_STATE_UPDATING:
659 		if (mode == SMB_DCACHE_RDLOCK) {
660 			/*
661 			 * Read operations should wait until the update
662 			 * is completed.
663 			 */
664 			if (!smb_dcache_wait()) {
665 				(void) mutex_unlock(&smb_dcache.dc_mtx);
666 				return (SMB_DOMAIN_INTERNAL_ERR);
667 			}
668 		}
669 
670 	default:
671 		smb_dcache.dc_nops++;
672 		break;
673 	}
674 	(void) mutex_unlock(&smb_dcache.dc_mtx);
675 
676 	/*
677 	 * Lock has to be taken outside the mutex otherwise
678 	 * there could be a deadlock
679 	 */
680 	if (mode == SMB_DCACHE_RDLOCK)
681 		(void) rw_rdlock(&smb_dcache.dc_cache_lck);
682 	else
683 		(void) rw_wrlock(&smb_dcache.dc_cache_lck);
684 
685 	return (SMB_DOMAIN_SUCCESS);
686 }
687 
688 /*
689  * Decrement the number of inflight operations and then unlock.
690  */
691 static void
692 smb_dcache_unlock(void)
693 {
694 	(void) mutex_lock(&smb_dcache.dc_mtx);
695 	assert(smb_dcache.dc_nops > 0);
696 	smb_dcache.dc_nops--;
697 	(void) cond_broadcast(&smb_dcache.dc_cv);
698 	(void) mutex_unlock(&smb_dcache.dc_mtx);
699 
700 	(void) rw_unlock(&smb_dcache.dc_cache_lck);
701 }
702 
703 static uint32_t
704 smb_dcache_add(smb_domain_t *di)
705 {
706 	smb_domain_t *dcnode;
707 
708 	if ((dcnode = malloc(sizeof (smb_domain_t))) == NULL)
709 		return (SMB_DOMAIN_NO_MEMORY);
710 
711 	*dcnode = *di;
712 	dcnode->di_binsid = smb_sid_fromstr(dcnode->di_sid);
713 	if (dcnode->di_binsid == NULL) {
714 		free(dcnode);
715 		return (SMB_DOMAIN_NO_MEMORY);
716 	}
717 
718 	list_insert_tail(&smb_dcache.dc_cache, dcnode);
719 	return (SMB_DOMAIN_SUCCESS);
720 }
721 
722 static void
723 smb_dcache_remove(smb_domain_t *di)
724 {
725 	list_remove(&smb_dcache.dc_cache, di);
726 	smb_sid_free(di->di_binsid);
727 	free(di);
728 }
729 
730 static void
731 smb_dcache_setdc(const smb_dcinfo_t *dci)
732 {
733 	(void) mutex_lock(&smb_dcache.dc_mtx);
734 	smb_dcache.dc_dci = *dci; /* struct assignment! */
735 	(void) mutex_unlock(&smb_dcache.dc_mtx);
736 }
737 
738 /*
739  * Return B_TRUE if we have DC information.
740  */
741 static boolean_t
742 smb_dcache_getdc(smb_dcinfo_t *dci)
743 {
744 	(void) mutex_lock(&smb_dcache.dc_mtx);
745 	*dci = smb_dcache.dc_dci; /* struct assignment! */
746 	(void) mutex_unlock(&smb_dcache.dc_mtx);
747 	return (dci->dc_name[0] != '\0');
748 }
749 
750 /*
751  * Waits for SMB_DCACHE_UPDATE_WAIT seconds if cache is in
752  * UPDATING state. Upon wake up returns true if cache is
753  * ready to be used, otherwise it returns false.
754  */
755 static boolean_t
756 smb_dcache_wait(void)
757 {
758 	timestruc_t to;
759 	int err;
760 
761 	to.tv_sec = SMB_DCACHE_UPDATE_WAIT;
762 	to.tv_nsec = 0;
763 	while (smb_dcache.dc_state == SMB_DCACHE_STATE_UPDATING) {
764 		err = cond_reltimedwait(&smb_dcache.dc_cv,
765 		    &smb_dcache.dc_mtx, &to);
766 		if (err == ETIME)
767 			break;
768 	}
769 
770 	return (smb_dcache.dc_state == SMB_DCACHE_STATE_READY);
771 }
772 
773 /*
774  * Transfers the cache into UPDATING state, this will ensure
775  * any read access to the cache will be stalled until the
776  * update is finished. This is to avoid providing incomplete,
777  * inconsistent or stale information.
778  *
779  * If another thread is already updating the cache, other
780  * callers will wait until cache is no longer in UPDATING
781  * state. The return code is decided based on the new
782  * state of the cache.
783  */
784 static uint32_t
785 smb_dcache_updating(void)
786 {
787 	uint32_t rc;
788 
789 	(void) mutex_lock(&smb_dcache.dc_mtx);
790 	switch (smb_dcache.dc_state) {
791 	case SMB_DCACHE_STATE_READY:
792 		smb_dcache.dc_state = SMB_DCACHE_STATE_UPDATING;
793 		rc = SMB_DOMAIN_SUCCESS;
794 		break;
795 
796 	case SMB_DCACHE_STATE_UPDATING:
797 		while (smb_dcache.dc_state == SMB_DCACHE_STATE_UPDATING)
798 			(void) cond_wait(&smb_dcache.dc_cv,
799 			    &smb_dcache.dc_mtx);
800 
801 		if (smb_dcache.dc_state == SMB_DCACHE_STATE_READY) {
802 			smb_dcache.dc_state = SMB_DCACHE_STATE_UPDATING;
803 			rc = SMB_DOMAIN_SUCCESS;
804 		} else {
805 			rc = SMB_DOMAIN_NO_CACHE;
806 		}
807 		break;
808 
809 	case SMB_DCACHE_STATE_NONE:
810 	case SMB_DCACHE_STATE_DESTROYING:
811 		rc = SMB_DOMAIN_NO_CACHE;
812 		break;
813 
814 	default:
815 		break;
816 	}
817 
818 	(void) mutex_unlock(&smb_dcache.dc_mtx);
819 	return (rc);
820 }
821 
822 /*
823  * Transfers the cache from UPDATING to READY state.
824  *
825  * Nothing will happen if the cache is no longer available
826  * or it is being destroyed.
827  */
828 static void
829 smb_dcache_ready(void)
830 {
831 	(void) mutex_lock(&smb_dcache.dc_mtx);
832 	switch (smb_dcache.dc_state) {
833 	case SMB_DCACHE_STATE_UPDATING:
834 		smb_dcache.dc_state = SMB_DCACHE_STATE_READY;
835 		(void) cond_broadcast(&smb_dcache.dc_cv);
836 		break;
837 
838 	case SMB_DCACHE_STATE_NONE:
839 	case SMB_DCACHE_STATE_DESTROYING:
840 		break;
841 
842 	default:
843 		assert(0);
844 	}
845 	(void) mutex_unlock(&smb_dcache.dc_mtx);
846 }
847