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 (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
23  * Copyright 2017 Nexenta Systems, Inc.  All rights reserved.
24  */
25 
26 #include <sys/types.h>
27 #include <sys/sockio.h>
28 #include <sys/socket.h>
29 #include <sys/utsname.h>
30 
31 #include <stdarg.h>
32 #include <unistd.h>
33 #include <stdlib.h>
34 #include <time.h>
35 #include <synch.h>
36 #include <syslog.h>
37 #include <string.h>
38 #include <strings.h>
39 #include <errno.h>
40 #include <net/if.h>
41 #include <netdb.h>
42 #include <netinet/in.h>
43 #include <arpa/nameser.h>
44 #include <resolv.h>
45 
46 #include <smbsrv/smbinfo.h>
47 #include <smbsrv/netbios.h>
48 #include <smbsrv/libsmb.h>
49 #include <assert.h>
50 
51 static mutex_t seqnum_mtx;
52 
53 /*
54  * IPC connection information that may be passed to the SMB Redirector.
55  */
56 typedef struct {
57 	char	user[SMB_USERNAME_MAXLEN];
58 	uint8_t	passwd[SMBAUTH_HASH_SZ];
59 } smb_ipc_t;
60 
61 static smb_ipc_t	ipc_info;
62 static smb_ipc_t	ipc_orig_info;
63 static rwlock_t		smb_ipc_lock;
64 
65 /*
66  * These three parameters are all related:
67  *	skc_initial_credits
68  *	skc_maximum_credits
69  *	skc_maxworkers	(max worker threads)
70  * They must be in non-decreasing order.  Get the values in order:
71  *	maxworkers, maximum_credits, initial_credits
72  * enforcing maximum values and relations as we go.  Then in the
73  * opposite order check minimum values and relations.
74  *
75  * smb_config_getnum puts a zero in the &citem if it fails getting
76  * the parameter value.  When fetch parameters for which zero is OK,
77  * the return code is intentionally ignored.
78  */
79 void
80 smb_load_kconfig(smb_kmod_cfg_t *kcfg)
81 {
82 	struct utsname uts;
83 	int64_t citem;
84 	int rc;
85 
86 	bzero(kcfg, sizeof (smb_kmod_cfg_t));
87 
88 	/*
89 	 * skc_maxworkers (max. no. of taskq worker threads)
90 	 */
91 	rc = smb_config_getnum(SMB_CI_MAX_WORKERS, &citem);
92 	if (rc != SMBD_SMF_OK)
93 		citem = SMB_PI_MAX_WORKERS_DEF;
94 	if (citem > SMB_PI_MAX_WORKERS_MAX)
95 		citem = SMB_PI_MAX_WORKERS_MAX;
96 	kcfg->skc_maxworkers = (uint32_t)citem;
97 
98 	/*
99 	 * The largest number of credits we let a single client have.
100 	 * It never makes sense for this to be > max_workers
101 	 */
102 	rc = smb_config_getnum(SMB_CI_MAXIMUM_CREDITS, &citem);
103 	if (rc != SMBD_SMF_OK)
104 		citem = SMB_PI_MAXIMUM_CREDITS_DEF;
105 	if (citem > SMB_PI_MAXIMUM_CREDITS_MAX)
106 		citem = SMB_PI_MAXIMUM_CREDITS_MAX;
107 	kcfg->skc_maximum_credits = (uint16_t)citem;
108 	if (kcfg->skc_maximum_credits > kcfg->skc_maxworkers)
109 		kcfg->skc_maximum_credits = (uint16_t)kcfg->skc_maxworkers;
110 
111 	/*
112 	 * The number of credits we give a client initially.
113 	 * Should be enough for a "light" workload, as the
114 	 * client will request additional credits when the
115 	 * workload increases.  Must be <= maximum_credits.
116 	 */
117 	rc = smb_config_getnum(SMB_CI_INITIAL_CREDITS, &citem);
118 	if (rc != SMBD_SMF_OK)
119 		citem = SMB_PI_INITIAL_CREDITS_DEF;
120 	if (citem > SMB_PI_INITIAL_CREDITS_MAX)
121 		citem = SMB_PI_INITIAL_CREDITS_MAX;
122 	kcfg->skc_initial_credits = (uint16_t)citem;
123 	if (kcfg->skc_initial_credits > kcfg->skc_maximum_credits)
124 		kcfg->skc_initial_credits = kcfg->skc_maximum_credits;
125 
126 	/*
127 	 * Now enforce minimums, smaller to larger.
128 	 */
129 	if (kcfg->skc_initial_credits < SMB_PI_INITIAL_CREDITS_MIN)
130 		kcfg->skc_initial_credits = SMB_PI_INITIAL_CREDITS_MIN;
131 
132 	if (kcfg->skc_maximum_credits < SMB_PI_MAXIMUM_CREDITS_MIN)
133 		kcfg->skc_maximum_credits = SMB_PI_MAXIMUM_CREDITS_MIN;
134 	if (kcfg->skc_maximum_credits < kcfg->skc_initial_credits)
135 		kcfg->skc_maximum_credits = kcfg->skc_initial_credits;
136 
137 	if (kcfg->skc_maxworkers < SMB_PI_MAX_WORKERS_MIN)
138 		kcfg->skc_maxworkers = SMB_PI_MAX_WORKERS_MIN;
139 	if (kcfg->skc_maxworkers < kcfg->skc_maximum_credits)
140 		kcfg->skc_maxworkers = kcfg->skc_maximum_credits;
141 
142 	(void) smb_config_getnum(SMB_CI_KEEPALIVE, &citem);
143 	kcfg->skc_keepalive = (uint32_t)citem;
144 	if ((kcfg->skc_keepalive != 0) &&
145 	    (kcfg->skc_keepalive < SMB_PI_KEEP_ALIVE_MIN))
146 		kcfg->skc_keepalive = SMB_PI_KEEP_ALIVE_MIN;
147 
148 	(void) smb_config_getnum(SMB_CI_MAX_CONNECTIONS, &citem);
149 	kcfg->skc_maxconnections = (uint32_t)citem;
150 	kcfg->skc_restrict_anon = smb_config_getbool(SMB_CI_RESTRICT_ANON);
151 	kcfg->skc_signing_enable = smb_config_getbool(SMB_CI_SIGNING_ENABLE);
152 	kcfg->skc_signing_required = smb_config_getbool(SMB_CI_SIGNING_REQD);
153 	kcfg->skc_netbios_enable = smb_config_getbool(SMB_CI_NETBIOS_ENABLE);
154 	kcfg->skc_ipv6_enable = smb_config_getbool(SMB_CI_IPV6_ENABLE);
155 	kcfg->skc_print_enable = smb_config_getbool(SMB_CI_PRINT_ENABLE);
156 	kcfg->skc_oplock_enable = smb_config_getbool(SMB_CI_OPLOCK_ENABLE);
157 	kcfg->skc_sync_enable = smb_config_getbool(SMB_CI_SYNC_ENABLE);
158 	kcfg->skc_traverse_mounts = smb_config_getbool(SMB_CI_TRAVERSE_MOUNTS);
159 	kcfg->skc_max_protocol = smb_config_get_max_protocol();
160 	kcfg->skc_min_protocol = smb_config_get_min_protocol();
161 	kcfg->skc_secmode = smb_config_get_secmode();
162 	kcfg->skc_encrypt = smb_config_get_require(SMB_CI_ENCRYPT);
163 
164 	(void) smb_getdomainname(kcfg->skc_nbdomain,
165 	    sizeof (kcfg->skc_nbdomain));
166 	(void) smb_getfqdomainname(kcfg->skc_fqdn,
167 	    sizeof (kcfg->skc_fqdn));
168 	(void) smb_getnetbiosname(kcfg->skc_hostname,
169 	    sizeof (kcfg->skc_hostname));
170 	(void) smb_config_getstr(SMB_CI_SYS_CMNT, kcfg->skc_system_comment,
171 	    sizeof (kcfg->skc_system_comment));
172 	smb_config_get_version(&kcfg->skc_version);
173 	kcfg->skc_execflags = smb_config_get_execinfo(NULL, NULL, 0);
174 	if (smb_config_get_localuuid(kcfg->skc_machine_uuid) < 0) {
175 		syslog(LOG_ERR, "smb_load_kconfig: no machine_uuid");
176 		uuid_generate_time(kcfg->skc_machine_uuid);
177 	}
178 	/* skc_negtok, skc_negtok_len: see smbd_authsvc.c */
179 
180 	(void) uname(&uts);
181 	(void) snprintf(kcfg->skc_native_os, sizeof (kcfg->skc_native_os),
182 	    "%s %s %s", uts.sysname, uts.release, uts.version);
183 
184 	(void) strlcpy(kcfg->skc_native_lm, "Native SMB service",
185 	    sizeof (kcfg->skc_native_lm));
186 }
187 
188 /*
189  * Get the current system NetBIOS name.  The hostname is truncated at
190  * the first `.` or 15 bytes, whichever occurs first, and converted
191  * to uppercase (by smb_gethostname).  Text that appears after the
192  * first '.' is considered to be part of the NetBIOS scope.
193  *
194  * Returns 0 on success, otherwise -1 to indicate an error.
195  */
196 int
197 smb_getnetbiosname(char *buf, size_t buflen)
198 {
199 	if (smb_gethostname(buf, buflen, SMB_CASE_UPPER) != 0)
200 		return (-1);
201 
202 	if (buflen >= NETBIOS_NAME_SZ)
203 		buf[NETBIOS_NAME_SZ - 1] = '\0';
204 
205 	return (0);
206 }
207 
208 /*
209  * Get the SAM account of the current system.
210  * Returns 0 on success, otherwise, -1 to indicate an error.
211  */
212 int
213 smb_getsamaccount(char *buf, size_t buflen)
214 {
215 	if (smb_getnetbiosname(buf, buflen - 1) != 0)
216 		return (-1);
217 
218 	(void) strlcat(buf, "$", buflen);
219 	return (0);
220 }
221 
222 /*
223  * Get the current system node name.  The returned name is guaranteed
224  * to be null-terminated (gethostname may not null terminate the name).
225  * If the hostname has been fully-qualified for some reason, the domain
226  * part will be removed.  The returned hostname is converted to the
227  * specified case (lower, upper, or preserved).
228  *
229  * If gethostname fails, the returned buffer will contain an empty
230  * string.
231  */
232 int
233 smb_gethostname(char *buf, size_t buflen, smb_caseconv_t which)
234 {
235 	char *p;
236 
237 	if (buf == NULL || buflen == 0)
238 		return (-1);
239 
240 	if (gethostname(buf, buflen) != 0) {
241 		*buf = '\0';
242 		return (-1);
243 	}
244 
245 	buf[buflen - 1] = '\0';
246 
247 	if ((p = strchr(buf, '.')) != NULL)
248 		*p = '\0';
249 
250 	switch (which) {
251 	case SMB_CASE_LOWER:
252 		(void) smb_strlwr(buf);
253 		break;
254 
255 	case SMB_CASE_UPPER:
256 		(void) smb_strupr(buf);
257 		break;
258 
259 	case SMB_CASE_PRESERVE:
260 	default:
261 		break;
262 	}
263 
264 	return (0);
265 }
266 
267 /*
268  * Obtain the fully-qualified name for this machine in lower case.  If
269  * the hostname is fully-qualified, accept it.  Otherwise, try to find an
270  * appropriate domain name to append to the hostname.
271  */
272 int
273 smb_getfqhostname(char *buf, size_t buflen)
274 {
275 	char hostname[MAXHOSTNAMELEN];
276 	char domain[MAXHOSTNAMELEN];
277 
278 	hostname[0] = '\0';
279 	domain[0] = '\0';
280 
281 	if (smb_gethostname(hostname, MAXHOSTNAMELEN,
282 	    SMB_CASE_LOWER) != 0)
283 		return (-1);
284 
285 	if (smb_getfqdomainname(domain, MAXHOSTNAMELEN) != 0)
286 		return (-1);
287 
288 	if (hostname[0] == '\0')
289 		return (-1);
290 
291 	if (domain[0] == '\0') {
292 		(void) strlcpy(buf, hostname, buflen);
293 		return (0);
294 	}
295 
296 	(void) snprintf(buf, buflen, "%s.%s", hostname, domain);
297 	return (0);
298 }
299 
300 /*
301  * smb_getdomainname
302  *
303  * Returns NETBIOS name of the domain if the system is in domain
304  * mode. Or returns workgroup name if the system is in workgroup
305  * mode.
306  */
307 int
308 smb_getdomainname(char *buf, size_t buflen)
309 {
310 	int rc;
311 
312 	if (buf == NULL || buflen == 0)
313 		return (-1);
314 
315 	*buf = '\0';
316 	rc = smb_config_getstr(SMB_CI_DOMAIN_NAME, buf, buflen);
317 
318 	if ((rc != SMBD_SMF_OK) || (*buf == '\0'))
319 		return (-1);
320 
321 	return (0);
322 }
323 
324 /*
325  * smb_getfqdomainname
326  *
327  * In the system is in domain mode, the dns_domain property value
328  * is returned. Otherwise, it returns the local domain obtained via
329  * resolver.
330  *
331  * Returns 0 upon success.  Otherwise, returns -1.
332  */
333 int
334 smb_getfqdomainname(char *buf, size_t buflen)
335 {
336 	struct __res_state res_state;
337 	int rc;
338 
339 	if (buf == NULL || buflen == 0)
340 		return (-1);
341 
342 	*buf = '\0';
343 	if (smb_config_get_secmode() == SMB_SECMODE_DOMAIN) {
344 		rc = smb_config_getstr(SMB_CI_DOMAIN_FQDN, buf, buflen);
345 
346 		if ((rc != SMBD_SMF_OK) || (*buf == '\0'))
347 			return (-1);
348 	} else {
349 		bzero(&res_state, sizeof (struct __res_state));
350 		if (res_ninit(&res_state))
351 			return (-1);
352 
353 		if (*res_state.defdname == '\0') {
354 			res_ndestroy(&res_state);
355 			return (-1);
356 		}
357 
358 		(void) strlcpy(buf, res_state.defdname, buflen);
359 		res_ndestroy(&res_state);
360 		rc = 0;
361 	}
362 
363 	return (rc);
364 }
365 
366 
367 /*
368  * smb_set_machine_passwd
369  *
370  * This function should be used when setting the machine password property.
371  * The associated sequence number is incremented.
372  */
373 static int
374 smb_set_machine_passwd(char *passwd)
375 {
376 	int64_t num;
377 	int rc = -1;
378 
379 	if (smb_config_set(SMB_CI_MACHINE_PASSWD, passwd) != SMBD_SMF_OK)
380 		return (-1);
381 
382 	(void) mutex_lock(&seqnum_mtx);
383 	(void) smb_config_getnum(SMB_CI_KPASSWD_SEQNUM, &num);
384 	if (smb_config_setnum(SMB_CI_KPASSWD_SEQNUM, ++num)
385 	    == SMBD_SMF_OK)
386 		rc = 0;
387 	(void) mutex_unlock(&seqnum_mtx);
388 	return (rc);
389 }
390 
391 static int
392 smb_get_machine_passwd(uint8_t *buf, size_t buflen)
393 {
394 	char pwd[SMB_PASSWD_MAXLEN + 1];
395 	int rc;
396 
397 	if (buflen < SMBAUTH_HASH_SZ)
398 		return (-1);
399 
400 	rc = smb_config_getstr(SMB_CI_MACHINE_PASSWD, pwd, sizeof (pwd));
401 	if ((rc != SMBD_SMF_OK) || *pwd == '\0')
402 		return (-1);
403 
404 	if (smb_auth_ntlm_hash(pwd, buf) != 0)
405 		return (-1);
406 
407 	return (rc);
408 }
409 
410 /*
411  * Set up IPC connection credentials.
412  */
413 void
414 smb_ipc_init(void)
415 {
416 	int rc;
417 
418 	(void) rw_wrlock(&smb_ipc_lock);
419 	bzero(&ipc_info, sizeof (smb_ipc_t));
420 	bzero(&ipc_orig_info, sizeof (smb_ipc_t));
421 
422 	(void) smb_getsamaccount(ipc_info.user, SMB_USERNAME_MAXLEN);
423 	rc = smb_get_machine_passwd(ipc_info.passwd, SMBAUTH_HASH_SZ);
424 	if (rc != 0)
425 		*ipc_info.passwd = 0;
426 	(void) rw_unlock(&smb_ipc_lock);
427 
428 }
429 
430 /*
431  * Set the IPC username and password hash in memory.  If the domain
432  * join succeeds, the credentials will be committed for use with
433  * authenticated IPC.  Otherwise, they should be rolled back.
434  */
435 void
436 smb_ipc_set(char *plain_user, uint8_t *passwd_hash)
437 {
438 	(void) rw_wrlock(&smb_ipc_lock);
439 	(void) strlcpy(ipc_info.user, plain_user, sizeof (ipc_info.user));
440 	(void) memcpy(ipc_info.passwd, passwd_hash, SMBAUTH_HASH_SZ);
441 	(void) rw_unlock(&smb_ipc_lock);
442 
443 }
444 
445 /*
446  * Save the host credentials to be used for authenticated IPC.
447  * The credentials are also saved to the original IPC info as
448  * rollback data in case the join domain process fails later.
449  */
450 void
451 smb_ipc_commit(void)
452 {
453 	(void) rw_wrlock(&smb_ipc_lock);
454 	(void) smb_getsamaccount(ipc_info.user, SMB_USERNAME_MAXLEN);
455 	(void) smb_get_machine_passwd(ipc_info.passwd, SMBAUTH_HASH_SZ);
456 	(void) memcpy(&ipc_orig_info, &ipc_info, sizeof (smb_ipc_t));
457 	(void) rw_unlock(&smb_ipc_lock);
458 }
459 
460 /*
461  * Restore the original credentials
462  */
463 void
464 smb_ipc_rollback(void)
465 {
466 	(void) rw_wrlock(&smb_ipc_lock);
467 	(void) strlcpy(ipc_info.user, ipc_orig_info.user,
468 	    sizeof (ipc_info.user));
469 	(void) memcpy(ipc_info.passwd, ipc_orig_info.passwd,
470 	    sizeof (ipc_info.passwd));
471 	(void) rw_unlock(&smb_ipc_lock);
472 }
473 
474 void
475 smb_ipc_get_user(char *buf, size_t buflen)
476 {
477 	(void) rw_rdlock(&smb_ipc_lock);
478 	(void) strlcpy(buf, ipc_info.user, buflen);
479 	(void) rw_unlock(&smb_ipc_lock);
480 }
481 
482 void
483 smb_ipc_get_passwd(uint8_t *buf, size_t buflen)
484 {
485 	if (buflen < SMBAUTH_HASH_SZ)
486 		return;
487 
488 	(void) rw_rdlock(&smb_ipc_lock);
489 	(void) memcpy(buf, ipc_info.passwd, SMBAUTH_HASH_SZ);
490 	(void) rw_unlock(&smb_ipc_lock);
491 }
492 
493 /*
494  * smb_match_netlogon_seqnum
495  *
496  * A sequence number is associated with each machine password property
497  * update and the netlogon credential chain setup. If the
498  * sequence numbers don't match, a NETLOGON credential chain
499  * establishment is required.
500  *
501  * Returns 0 if kpasswd_seqnum equals to netlogon_seqnum. Otherwise,
502  * returns -1.
503  */
504 boolean_t
505 smb_match_netlogon_seqnum(void)
506 {
507 	int64_t setpasswd_seqnum;
508 	int64_t netlogon_seqnum;
509 
510 	(void) mutex_lock(&seqnum_mtx);
511 	(void) smb_config_getnum(SMB_CI_KPASSWD_SEQNUM, &setpasswd_seqnum);
512 	(void) smb_config_getnum(SMB_CI_NETLOGON_SEQNUM, &netlogon_seqnum);
513 	(void) mutex_unlock(&seqnum_mtx);
514 	return (setpasswd_seqnum == netlogon_seqnum);
515 }
516 
517 /*
518  * smb_setdomainprops
519  *
520  * This function should be called after joining an AD to
521  * set all the domain related SMF properties.
522  *
523  * The kpasswd_domain property is the AD domain to which the system
524  * is joined via kclient. If this function is invoked by the SMB
525  * daemon, fqdn should be set to NULL.
526  */
527 int
528 smb_setdomainprops(char *fqdn, char *server, char *passwd)
529 {
530 	if (server == NULL || passwd == NULL)
531 		return (-1);
532 
533 	if ((*server == '\0') || (*passwd == '\0'))
534 		return (-1);
535 
536 	if (fqdn && (smb_config_set(SMB_CI_KPASSWD_DOMAIN, fqdn) != 0))
537 		return (-1);
538 
539 	if (smb_config_set(SMB_CI_KPASSWD_SRV, server) != 0)
540 		return (-1);
541 
542 	if (smb_set_machine_passwd(passwd) != 0) {
543 		syslog(LOG_ERR, "smb_setdomainprops: failed to set"
544 		    " machine account password");
545 		return (-1);
546 	}
547 
548 	/*
549 	 * If we successfully create a trust account, we mark
550 	 * ourselves as a domain member in the environment so
551 	 * that we use the SAMLOGON version of the NETLOGON
552 	 * PDC location protocol.
553 	 */
554 	(void) smb_config_setbool(SMB_CI_DOMAIN_MEMB, B_TRUE);
555 
556 	return (0);
557 }
558 
559 /*
560  * smb_update_netlogon_seqnum
561  *
562  * This function should only be called upon a successful netlogon
563  * credential chain establishment to set the sequence number of the
564  * netlogon to match with that of the kpasswd.
565  */
566 void
567 smb_update_netlogon_seqnum(void)
568 {
569 	int64_t num;
570 
571 	(void) mutex_lock(&seqnum_mtx);
572 	(void) smb_config_getnum(SMB_CI_KPASSWD_SEQNUM, &num);
573 	(void) smb_config_setnum(SMB_CI_NETLOGON_SEQNUM, num);
574 	(void) mutex_unlock(&seqnum_mtx);
575 }
576 
577 
578 /*
579  * Temporary fbt for dtrace until user space sdt enabled.
580  */
581 void
582 smb_tracef(const char *fmt, ...)
583 {
584 	va_list ap;
585 	char buf[128];
586 
587 	va_start(ap, fmt);
588 	(void) vsnprintf(buf, 128, fmt, ap);
589 	va_end(ap);
590 
591 	smb_trace(buf);
592 }
593 
594 /*
595  * Temporary fbt for dtrace until user space sdt enabled.
596  *
597  * This function is designed to be used with dtrace, i.e. see:
598  * usr/src/cmd/smbsrv/dtrace/smbd-all.d
599  *
600  * Outside of dtrace, the messages passed to this function usually
601  * lack sufficient context to be useful, so we don't log them.
602  */
603 /* ARGSUSED */
604 void
605 smb_trace(const char *s)
606 {
607 }
608 
609 /*
610  * smb_tonetbiosname
611  *
612  * Creates a NetBIOS name based on the given name and suffix.
613  * NetBIOS name is 15 capital characters, padded with space if needed
614  * and the 16th byte is the suffix.
615  */
616 void
617 smb_tonetbiosname(char *name, char *nb_name, char suffix)
618 {
619 	char tmp_name[NETBIOS_NAME_SZ];
620 	smb_wchar_t wtmp_name[NETBIOS_NAME_SZ];
621 	int len;
622 	size_t rc;
623 
624 	len = 0;
625 	rc = smb_mbstowcs(wtmp_name, (const char *)name, NETBIOS_NAME_SZ);
626 
627 	if (rc != (size_t)-1) {
628 		wtmp_name[NETBIOS_NAME_SZ - 1] = 0;
629 		rc = ucstooem(tmp_name, wtmp_name, NETBIOS_NAME_SZ,
630 		    OEM_CPG_850);
631 		if (rc > 0)
632 			len = strlen(tmp_name);
633 	}
634 
635 	(void) memset(nb_name, ' ', NETBIOS_NAME_SZ - 1);
636 	if (len) {
637 		(void) smb_strupr(tmp_name);
638 		(void) memcpy(nb_name, tmp_name, len);
639 	}
640 	nb_name[NETBIOS_NAME_SZ - 1] = suffix;
641 }
642 
643 int
644 smb_get_nameservers(smb_inaddr_t *ips, int sz)
645 {
646 	union res_sockaddr_union set[MAXNS];
647 	int i, cnt;
648 	struct __res_state res_state;
649 	char ipstr[INET6_ADDRSTRLEN];
650 
651 	if (ips == NULL)
652 		return (0);
653 
654 	bzero(&res_state, sizeof (struct __res_state));
655 	if (res_ninit(&res_state) < 0)
656 		return (0);
657 
658 	cnt = res_getservers(&res_state, set, MAXNS);
659 	for (i = 0; i < cnt; i++) {
660 		if (i >= sz)
661 			break;
662 		ips[i].a_family = AF_INET;
663 		bcopy(&set[i].sin.sin_addr, &ips[i].a_ipv4, NS_INADDRSZ);
664 		if (inet_ntop(AF_INET, &ips[i].a_ipv4, ipstr,
665 		    INET_ADDRSTRLEN)) {
666 			syslog(LOG_DEBUG, "Found %s name server\n", ipstr);
667 			continue;
668 		}
669 		ips[i].a_family = AF_INET6;
670 		bcopy(&set[i].sin.sin_addr, &ips[i].a_ipv6, NS_IN6ADDRSZ);
671 		if (inet_ntop(AF_INET6, &ips[i].a_ipv6, ipstr,
672 		    INET6_ADDRSTRLEN)) {
673 			syslog(LOG_DEBUG, "Found %s name server\n", ipstr);
674 		}
675 	}
676 	res_ndestroy(&res_state);
677 	return (i);
678 }
679 
680 /*
681  * smb_gethostbyname
682  *
683  * Looks up a host by the given name. The host entry can come
684  * from any of the sources for hosts specified in the
685  * /etc/nsswitch.conf and the NetBIOS cache.
686  *
687  * XXX Invokes nbt_name_resolve API once the NBTD is integrated
688  * to look in the NetBIOS cache if getipnodebyname fails.
689  *
690  * Caller should invoke freehostent to free the returned hostent.
691  */
692 struct hostent *
693 smb_gethostbyname(const char *name, int *err_num)
694 {
695 	struct hostent *h;
696 
697 	h = getipnodebyname(name, AF_INET, 0, err_num);
698 	if ((h == NULL) || h->h_length != INADDRSZ)
699 		h = getipnodebyname(name, AF_INET6, AI_DEFAULT, err_num);
700 	return (h);
701 }
702 
703 /*
704  * smb_gethostbyaddr
705  *
706  * Looks up a host by the given IP address. The host entry can come
707  * from any of the sources for hosts specified in the
708  * /etc/nsswitch.conf and the NetBIOS cache.
709  *
710  * XXX Invokes nbt API to resolve name by IP once the NBTD is integrated
711  * to look in the NetBIOS cache if getipnodebyaddr fails.
712  *
713  * Caller should invoke freehostent to free the returned hostent.
714  */
715 struct hostent *
716 smb_gethostbyaddr(const char *addr, int len, int type, int *err_num)
717 {
718 	struct hostent *h;
719 
720 	h = getipnodebyaddr(addr, len, type, err_num);
721 
722 	return (h);
723 }
724