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 2018 Nexenta Systems, Inc.  All rights reserved.
24  */
25 
26 /*
27  * General Structures Layout
28  * -------------------------
29  *
30  * This is a simplified diagram showing the relationship between most of the
31  * main structures.
32  *
33  * +-------------------+
34  * |     SMB_INFO      |
35  * +-------------------+
36  *          |
37  *          |
38  *          v
39  * +-------------------+       +-------------------+      +-------------------+
40  * |     SESSION       |<----->|     SESSION       |......|      SESSION      |
41  * +-------------------+       +-------------------+      +-------------------+
42  *   |          |
43  *   |          |
44  *   |          v
45  *   |  +-------------------+     +-------------------+   +-------------------+
46  *   |  |       USER        |<--->|       USER        |...|       USER        |
47  *   |  +-------------------+     +-------------------+   +-------------------+
48  *   |
49  *   |
50  *   v
51  * +-------------------+       +-------------------+      +-------------------+
52  * |       TREE        |<----->|       TREE        |......|       TREE        |
53  * +-------------------+       +-------------------+      +-------------------+
54  *      |         |
55  *      |         |
56  *      |         v
57  *      |     +-------+       +-------+      +-------+
58  *      |     | OFILE |<----->| OFILE |......| OFILE |
59  *      |     +-------+       +-------+      +-------+
60  *      |
61  *      |
62  *      v
63  *  +-------+       +------+      +------+
64  *  | ODIR  |<----->| ODIR |......| ODIR |
65  *  +-------+       +------+      +------+
66  *
67  *
68  * Odir State Machine
69  * ------------------
70  *
71  *    +-------------------------+
72  *    |  SMB_ODIR_STATE_OPEN    |<----------- open / creation
73  *    +-------------------------+
74  *	    |            ^
75  *	    | (first)    | (last)
76  *	    | lookup     | release
77  *	    v            |
78  *    +-------------------------+
79  *    | SMB_ODIR_STATE_IN_USE   |----
80  *    +-------------------------+   | lookup / release / read
81  *	    |                ^-------
82  *	    | close
83  *	    |
84  *	    v
85  *    +-------------------------+
86  *    | SMB_ODIR_STATE_CLOSING  |----
87  *    +-------------------------+   | close / release / read
88  *	    |                ^-------
89  *	    | (last) release
90  *	    |
91  *	    v
92  *    +-------------------------+
93  *    | SMB_ODIR_STATE_CLOSED   |----------> deletion
94  *    +-------------------------+
95  *
96  *
97  * SMB_ODIR_STATE_OPEN
98  * - the odir exists in the list of odirs of its tree
99  * - lookup is valid in this state. It will place a hold on the odir
100  *   by incrementing the reference count and the odir will transition
101  *   to SMB_ODIR_STATE_IN_USE
102  * - read/close/release not valid in this state
103  *
104  * SMB_ODIR_STATE_IN_USE
105  * - the odir exists in the list of odirs of its tree.
106  * - lookup is valid in this state. It will place a hold on the odir
107  *   by incrementing the reference count.
108  * - if the last hold is released the odir will transition
109  *   back to SMB_ODIR_STATE_OPEN
110  * - if a close is received the odir will transition to
111  *   SMB_ODIR_STATE_CLOSING.
112  *
113  * SMB_ODIR_STATE_CLOSING
114  * - the odir exists in the list of odirs of its tree.
115  * - lookup will fail in this state.
116  * - when the last hold is released the odir will transition
117  *   to SMB_ODIR_STATE_CLOSED.
118  *
119  * SMB_ODIR_STATE_CLOSED
120  * - the odir exists in the list of odirs of its tree.
121  * - there are no users of the odir (refcnt == 0)
122  * - the odir is being removed from the tree's list and deleted.
123  * - lookup will fail in this state.
124  * - read/close/release not valid in this state
125  *
126  * Comments
127  * --------
128  *    The state machine of the odir structures is controlled by 3 elements:
129  *      - The list of odirs of the tree it belongs to.
130  *      - The mutex embedded in the structure itself.
131  *      - The reference count.
132  *
133  *    There's a mutex embedded in the odir structure used to protect its fields
134  *    and there's a lock embedded in the list of odirs of a tree. To
135  *    increment or to decrement the reference count the mutex must be entered.
136  *    To insert the odir into the list of odirs of the tree and to remove
137  *    the odir from it, the lock must be entered in RW_WRITER mode.
138  *
139  *    In order to avoid deadlocks, when both (mutex and lock of the odir
140  *    list) have to be entered, the lock must be entered first.
141  *
142  *
143  * Odir Interface
144  * ---------------
145  * smb_odir_open(char *pathname)
146  *	Create an odir representing the directory specified in pathname and
147  *	add it into the tree's list of odirs.
148  *	Returns NT status.
149  *
150  * smb_odir_openfh(smb_ofile_t *of)
151  *	Create an odir representing the directory specified by the
152  *	existing open handle (from a prior open of the directory).
153  *	Returns NT status.
154  *
155  * smb_odir_openat(smb_node_t *unode)
156  *	Create an odir representing the extended attribute directory
157  *	associated with the file (or directory) represented by unode
158  *	and add it into the tree's list of odirs.
159  *	Returns NT status.
160  *
161  * smb_odir_t *odir = smb_tree_lookup_odir(..., odid)
162  *	Find the odir corresponding to the specified odid in the tree's
163  *	list of odirs. Place a hold on the odir.
164  *
165  * smb_odir_read(..., smb_odirent_t *odirent)
166  *	Find the next directory entry in the odir and return it in odirent.
167  *
168  * smb_odir_read_fileinfo(..., smb_fileinfo_t *)
169  *	Find the next directory entry in the odir. Return the details of
170  *	the directory entry in smb_fileinfo_t. (See odir internals below)
171  *
172  * smb_odir_read_streaminfo(..., smb_streaminfo_t *)
173  *	Find the next named stream entry in the odir. Return the details of
174  *	the named stream in smb_streaminfo_t.
175  *
176  * smb_odir_close(smb_odir_t *odir)
177  *  Close the odir.
178  *  The caller of close must have a hold on the odir being closed.
179  *  The hold should be released after closing.
180  *
181  * smb_odir_release(smb_odir_t *odir)
182  *	Release the hold on the odir, obtained by lookup.
183  *
184  *
185  * Odir Internals
186  * --------------
187  * The odir object represent an open directory search. Each read operation
188  * provides the caller with a structure containing information  pertaining
189  * to the next directory entry that matches the search criteria, namely
190  * the filename or match pattern and, in the case of smb_odir_read_fileinfo(),
191  * the search attributes.
192  *
193  * The odir maintains a buffer (d_buf) of directory entries read from
194  * the filesystem via a vop_readdir. The buffer is populated when a read
195  * request (smb_odir_next_odirent) finds that the buffer is empty or that
196  * the end of the buffer has been reached, and also when a new client request
197  * (find next) begins.
198  *
199  * The data in d_buf (that which is returned from the file system) can
200  * be in one of two formats. If the file system supports extended directory
201  * entries we request that the data be returned as edirent_t structures. If
202  * it does not the data will be returned as dirent64_t structures. For
203  * convenience, when the next directory entry is read from d_buf by
204  * smb_odir_next_odirent it is translated into an smb_odirent_t.
205  *
206  * smb_odir_read_fileinfo
207  * The processing required to obtain the information to populate the caller's
208  * smb_fileinfo_t differs depending upon whether the directory search is for a
209  * single specified filename or for multiple files matching a search pattern.
210  * Thus smb_odir_read_fileinfo uses two static functions:
211  * smb_odir_single_fileinfo - obtains the smb_fileinfo_t info for the single
212  * filename as specified in smb_odir_open request.
213  * smb_odir_wildcard_fileinfo - obtains the smb_fileinfo_t info for the filename
214  * returned from the smb_odir_next_odirent. This is called in a loop until
215  * an entry matching the search criteria is found or no more entries exist.
216  *
217  * If a directory entry is a VLNK, the name returned in the smb_fileinfo_t
218  * is the name of the directory entry but the attributes are the attribites
219  * of the file that is the target of the link. If the link target cannot
220  * be found the attributes returned are the attributes of the link itself.
221  *
222  * smb_odir_read_streaminfo
223  * In order for an odir to provide information about stream files it
224  * must be opened with smb_odir_openat(). smb_odir_read_streaminfo() can
225  * then be used to obtain the name and size of named stream files.
226  *
227  * Resuming a Search
228  * -----------------
229  * A directory search often consists of multiple client requests: an initial
230  * find_first request followed by zero or more find_next requests and a
231  * find_close request.
232  * The find_first request will open and lookup the odir, read its desired
233  * number of entries from the odir, then release the odir and return.
234  * A find_next request will lookup the odir and read its desired number of
235  * entries from the odir, then release the odir and return.
236  * At the end of the search the find_close request will close the odir.
237  *
238  * In order to be able to resume a directory search (find_next) the odir
239  * provides the capability for the caller to save one or more resume points
240  * (cookies) at the end of a request, and to specify which resume point
241  * (cookie) to restart from at the beginning of the next search.
242  *	smb_odir_save_cookie(..., cookie)
243  *	smb_odir_resume_at(smb_odir_resume_t *resume)
244  * A search can be resumed at a specified resume point (cookie), the resume
245  * point (cookie) stored at a specified index in the d_cookies array, or
246  * a specified filename. The latter (specified filename) is not yet supported.
247  *
248  * See smb_search, smb_find, smb_find_unique, and smb_trans2_find for details
249  */
250 
251 #include <smbsrv/smb_kproto.h>
252 #include <smbsrv/smb_fsops.h>
253 #include <smbsrv/smb_share.h>
254 #include <sys/extdirent.h>
255 
256 /* static functions */
257 static smb_odir_t *smb_odir_create(smb_request_t *, smb_node_t *,
258     const char *, uint16_t, uint16_t, cred_t *);
259 static int smb_odir_single_fileinfo(smb_request_t *, smb_odir_t *,
260     smb_fileinfo_t *);
261 static int smb_odir_wildcard_fileinfo(smb_request_t *, smb_odir_t *,
262     smb_odirent_t *, smb_fileinfo_t *);
263 static int smb_odir_next_odirent(smb_odir_t *, smb_odirent_t *);
264 static boolean_t smb_odir_lookup_link(smb_request_t *, smb_odir_t *,
265     char *, smb_node_t **);
266 static boolean_t smb_odir_match_name(smb_odir_t *, smb_odirent_t *);
267 static void smb_odir_delete(void *);
268 
269 
270 /*
271  * smb_odir_openpath
272  *
273  * Create an odir representing the directory specified in pathname.
274  *
275  * Returns:
276  *    NT Status
277  */
278 uint32_t
smb_odir_openpath(smb_request_t * sr,char * path,uint16_t sattr,uint32_t flags,smb_odir_t ** odp)279 smb_odir_openpath(smb_request_t *sr, char *path, uint16_t sattr,
280 	uint32_t flags, smb_odir_t **odp)
281 {
282 	int		rc;
283 	smb_tree_t	*tree;
284 	smb_node_t	*dnode;
285 	char		pattern[MAXNAMELEN];
286 	uint16_t	odid;
287 	cred_t		*cr;
288 
289 	ASSERT(sr);
290 	ASSERT(sr->sr_magic == SMB_REQ_MAGIC);
291 	ASSERT(sr->tid_tree);
292 	ASSERT(sr->tid_tree->t_magic == SMB_TREE_MAGIC);
293 	*odp = NULL;
294 
295 	tree = sr->tid_tree;
296 
297 	if (sr->session->dialect < NT_LM_0_12)
298 		smb_convert_wildcards(path);
299 
300 	rc = smb_pathname_reduce(sr, sr->user_cr, path,
301 	    tree->t_snode, tree->t_snode, &dnode, pattern);
302 	if (rc != 0)
303 		return (smb_errno2status(rc));
304 
305 	if (!smb_node_is_dir(dnode)) {
306 		smb_node_release(dnode);
307 		return (NT_STATUS_OBJECT_PATH_NOT_FOUND);
308 	}
309 
310 	if (smb_fsop_access(sr, sr->user_cr, dnode, FILE_LIST_DIRECTORY) != 0) {
311 		smb_node_release(dnode);
312 		return (NT_STATUS_ACCESS_DENIED);
313 	}
314 
315 	if (smb_idpool_alloc(&tree->t_odid_pool, &odid)) {
316 		smb_node_release(dnode);
317 		return (NT_STATUS_TOO_MANY_OPENED_FILES);
318 	}
319 
320 	if (flags & SMB_ODIR_OPENF_BACKUP_INTENT)
321 		cr = smb_user_getprivcred(sr->uid_user);
322 	else
323 		cr = sr->uid_user->u_cred;
324 
325 	*odp = smb_odir_create(sr, dnode, pattern, sattr, odid, cr);
326 	smb_node_release(dnode);
327 
328 	return (0);
329 }
330 
331 /*
332  * smb_odir_openfh
333  *
334  * Create an odir representing the directory already opened on "of".
335  *
336  * Returns:
337  *    NT status
338  */
339 uint32_t
smb_odir_openfh(smb_request_t * sr,const char * pattern,uint16_t sattr,smb_odir_t ** odp)340 smb_odir_openfh(smb_request_t *sr, const char *pattern, uint16_t sattr,
341 	smb_odir_t **odp)
342 {
343 	smb_ofile_t	*of = sr->fid_ofile;
344 
345 	*odp = NULL;
346 
347 	if (of->f_node == NULL || !smb_node_is_dir(of->f_node))
348 		return (NT_STATUS_INVALID_PARAMETER);
349 
350 	if ((of->f_granted_access & FILE_LIST_DIRECTORY) == 0)
351 		return (NT_STATUS_ACCESS_DENIED);
352 
353 	*odp = smb_odir_create(sr, of->f_node, pattern, sattr, 0, of->f_cr);
354 
355 	return (0);
356 }
357 
358 /*
359  * smb_odir_openat
360  *
361  * Create an odir representing the extended attribute directory
362  * associated with the file (or directory) represented by unode.
363  *
364  * Returns:
365  *    NT status
366  */
367 uint32_t
smb_odir_openat(smb_request_t * sr,smb_node_t * unode,smb_odir_t ** odp)368 smb_odir_openat(smb_request_t *sr, smb_node_t *unode, smb_odir_t **odp)
369 {
370 	char		pattern[SMB_STREAM_PREFIX_LEN + 2];
371 	vnode_t		*xattr_dvp;
372 	cred_t		*cr;
373 	smb_node_t	*xattr_dnode;
374 	int		rc;
375 
376 	ASSERT(sr);
377 	ASSERT(sr->sr_magic == SMB_REQ_MAGIC);
378 	ASSERT(unode);
379 	ASSERT(unode->n_magic == SMB_NODE_MAGIC);
380 	*odp = NULL;
381 
382 	if (SMB_TREE_CONTAINS_NODE(sr, unode) == 0 ||
383 	    SMB_TREE_HAS_ACCESS(sr, ACE_LIST_DIRECTORY) == 0)
384 		return (NT_STATUS_ACCESS_DENIED);
385 
386 	cr = zone_kcred();
387 
388 	/* find the xattrdir vnode */
389 	rc = smb_vop_lookup_xattrdir(unode->vp, &xattr_dvp, LOOKUP_XATTR, cr);
390 	if (rc != 0)
391 		return (smb_errno2status(rc));
392 
393 	/* lookup the xattrdir's smb_node */
394 	xattr_dnode = smb_node_lookup(sr, NULL, cr, xattr_dvp, XATTR_DIR,
395 	    unode, NULL);
396 	VN_RELE(xattr_dvp);
397 	if (xattr_dnode == NULL)
398 		return (NT_STATUS_NO_MEMORY);
399 
400 	(void) snprintf(pattern, sizeof (pattern), "%s*", SMB_STREAM_PREFIX);
401 	*odp = smb_odir_create(sr, xattr_dnode, pattern,
402 	    SMB_SEARCH_ATTRIBUTES, 0, cr);
403 
404 	smb_node_release(xattr_dnode);
405 	return (0);
406 }
407 
408 /*
409  * smb_odir_hold
410  *
411  * A hold will only be granted if the odir is open or in_use.
412  */
413 boolean_t
smb_odir_hold(smb_odir_t * od)414 smb_odir_hold(smb_odir_t *od)
415 {
416 	ASSERT(od);
417 	ASSERT(od->d_magic == SMB_ODIR_MAGIC);
418 
419 	mutex_enter(&od->d_mutex);
420 
421 	switch (od->d_state) {
422 	case SMB_ODIR_STATE_OPEN:
423 		od->d_refcnt++;
424 		od->d_state = SMB_ODIR_STATE_IN_USE;
425 		break;
426 	case SMB_ODIR_STATE_IN_USE:
427 		od->d_refcnt++;
428 		break;
429 	case SMB_ODIR_STATE_CLOSING:
430 	case SMB_ODIR_STATE_CLOSED:
431 	default:
432 		mutex_exit(&od->d_mutex);
433 		return (B_FALSE);
434 	}
435 
436 	mutex_exit(&od->d_mutex);
437 	return (B_TRUE);
438 }
439 
440 /*
441  * If the odir is in SMB_ODIR_STATE_CLOSING and this release results in
442  * a refcnt of 0, change the state to SMB_ODIR_STATE_CLOSED and post the
443  * object for deletion.  Object deletion is deferred to avoid modifying
444  * a list while an iteration may be in progress.
445  */
446 void
smb_odir_release(smb_odir_t * od)447 smb_odir_release(smb_odir_t *od)
448 {
449 	smb_tree_t *tree = od->d_tree;
450 
451 	SMB_ODIR_VALID(od);
452 
453 	mutex_enter(&od->d_mutex);
454 	ASSERT(od->d_refcnt > 0);
455 
456 	switch (od->d_state) {
457 	case SMB_ODIR_STATE_OPEN:
458 		break;
459 	case SMB_ODIR_STATE_IN_USE:
460 		od->d_refcnt--;
461 		if (od->d_refcnt == 0)
462 			od->d_state = SMB_ODIR_STATE_OPEN;
463 		break;
464 	case SMB_ODIR_STATE_CLOSING:
465 		od->d_refcnt--;
466 		if (od->d_refcnt == 0) {
467 			od->d_state = SMB_ODIR_STATE_CLOSED;
468 			smb_llist_post(&tree->t_odir_list, od,
469 			    smb_odir_delete);
470 		}
471 		break;
472 	case SMB_ODIR_STATE_CLOSED:
473 	default:
474 		break;
475 	}
476 
477 	mutex_exit(&od->d_mutex);
478 }
479 
480 /*
481  * smb_odir_close
482  */
483 void
smb_odir_close(smb_odir_t * od)484 smb_odir_close(smb_odir_t *od)
485 {
486 	ASSERT(od);
487 	ASSERT(od->d_magic == SMB_ODIR_MAGIC);
488 
489 	mutex_enter(&od->d_mutex);
490 	ASSERT(od->d_refcnt > 0);
491 	switch (od->d_state) {
492 	case SMB_ODIR_STATE_OPEN:
493 		break;
494 	case SMB_ODIR_STATE_IN_USE:
495 		od->d_state = SMB_ODIR_STATE_CLOSING;
496 		break;
497 	case SMB_ODIR_STATE_CLOSING:
498 	case SMB_ODIR_STATE_CLOSED:
499 	default:
500 		break;
501 	}
502 	mutex_exit(&od->d_mutex);
503 }
504 
505 /*
506  * smb_odir_read
507  *
508  * Find the next directory entry matching the search pattern.
509  * No search attribute matching is performed.
510  *
511  * Returns:
512  *  0 - success.
513  *      - If a matching entry was found eof will be B_FALSE and
514  *        odirent will be populated.
515  * ENOENT
516  *      - If we've scanned to the end, eof will be B_TRUE.
517  * errno - other errors
518  */
519 int
smb_odir_read(smb_request_t * sr,smb_odir_t * od,smb_odirent_t * odirent,boolean_t * eof)520 smb_odir_read(smb_request_t *sr, smb_odir_t *od,
521     smb_odirent_t *odirent, boolean_t *eof)
522 {
523 	int		rc;
524 
525 	ASSERT(sr);
526 	ASSERT(sr->sr_magic == SMB_REQ_MAGIC);
527 	ASSERT(od);
528 	ASSERT(od->d_magic == SMB_ODIR_MAGIC);
529 	ASSERT(odirent);
530 
531 	mutex_enter(&od->d_mutex);
532 	ASSERT(od->d_refcnt > 0);
533 
534 	switch (od->d_state) {
535 	case SMB_ODIR_STATE_IN_USE:
536 	case SMB_ODIR_STATE_CLOSING:
537 		break;
538 	case SMB_ODIR_STATE_OPEN:
539 	case SMB_ODIR_STATE_CLOSED:
540 	default:
541 		mutex_exit(&od->d_mutex);
542 		return (EBADF);
543 	}
544 
545 	for (;;) {
546 		if ((rc = smb_odir_next_odirent(od, odirent)) != 0)
547 			break;
548 		if (smb_odir_match_name(od, odirent))
549 			break;
550 	}
551 
552 	mutex_exit(&od->d_mutex);
553 
554 	switch (rc) {
555 	case 0:
556 		*eof = B_FALSE;
557 		return (0);
558 	case ENOENT:
559 		*eof = B_TRUE;
560 		/* FALLTHROUGH */
561 	default:
562 		return (rc);
563 	}
564 }
565 
566 /*
567  * smb_odir_read_fileinfo
568  *
569  * Find the next directory entry matching the search pattern
570  * and attributes: od->d_pattern and od->d_sattr.
571  *
572  * If the search pattern specifies a single filename call
573  * smb_odir_single_fileinfo to get the file attributes and
574  * populate the caller's smb_fileinfo_t.
575  *
576  * If the search pattern contains wildcards call smb_odir_next_odirent
577  * to get the next directory entry then. Repeat until a matching
578  * filename is found. Call smb_odir_wildcard_fileinfo to get the
579  * file attributes and populate the caller's smb_fileinfo_t.
580  * This is repeated until a file matching the search criteria is found.
581  *
582  * Returns:
583  *  0 - success.
584  *      - If a matching entry was found eof will be B_FALSE and
585  *        fileinfo will be populated.
586  * ENOENT
587  *      - If at end of dir, eof will be B_TRUE.
588  * errno - other error
589  */
590 int
smb_odir_read_fileinfo(smb_request_t * sr,smb_odir_t * od,smb_fileinfo_t * fileinfo,uint16_t * eof)591 smb_odir_read_fileinfo(smb_request_t *sr, smb_odir_t *od,
592     smb_fileinfo_t *fileinfo, uint16_t *eof)
593 {
594 	int		rc, errnum;
595 	smb_odirent_t	*odirent;
596 
597 	ASSERT(sr);
598 	ASSERT(sr->sr_magic == SMB_REQ_MAGIC);
599 	ASSERT(od);
600 	ASSERT(od->d_magic == SMB_ODIR_MAGIC);
601 	ASSERT(fileinfo);
602 
603 	mutex_enter(&od->d_mutex);
604 	ASSERT(od->d_refcnt > 0);
605 
606 	switch (od->d_state) {
607 	case SMB_ODIR_STATE_IN_USE:
608 	case SMB_ODIR_STATE_CLOSING:
609 		break;
610 	case SMB_ODIR_STATE_OPEN:
611 	case SMB_ODIR_STATE_CLOSED:
612 	default:
613 		mutex_exit(&od->d_mutex);
614 		return (EBADF);
615 	}
616 
617 	if ((od->d_flags & SMB_ODIR_FLAG_WILDCARDS) == 0) {
618 		if (od->d_eof)
619 			rc = ENOENT;
620 		else
621 			rc = smb_odir_single_fileinfo(sr, od, fileinfo);
622 		od->d_eof = B_TRUE;
623 	} else {
624 		odirent = kmem_alloc(sizeof (smb_odirent_t), KM_SLEEP);
625 		for (;;) {
626 			bzero(fileinfo, sizeof (smb_fileinfo_t));
627 			if ((rc = smb_odir_next_odirent(od, odirent)) != 0)
628 				break;
629 
630 			/* skip non utf8 filename */
631 			if (u8_validate(odirent->od_name,
632 			    strlen(odirent->od_name), NULL,
633 			    U8_VALIDATE_ENTIRE, &errnum) < 0)
634 				continue;
635 
636 			if (!smb_odir_match_name(od, odirent))
637 				continue;
638 
639 			rc = smb_odir_wildcard_fileinfo(sr, od, odirent,
640 			    fileinfo);
641 			if (rc == 0)
642 				break;
643 		}
644 		kmem_free(odirent, sizeof (smb_odirent_t));
645 	}
646 	mutex_exit(&od->d_mutex);
647 
648 	switch (rc) {
649 	case 0:
650 		*eof = 0;
651 		return (0);
652 	case ENOENT:
653 		*eof = 1;	/* per. FindFirst, FindNext spec. */
654 		/* FALLTHROUGH */
655 	default:
656 		return (rc);
657 	}
658 }
659 
660 /*
661  * smb_odir_read_streaminfo
662  *
663  * Find the next directory entry whose name begins with SMB_STREAM_PREFIX,
664  * and thus represents an NTFS named stream.
665  * No search attribute matching is performed.
666  * No case conflict name mangling is required for NTFS named stream names.
667  *
668  * Returns:
669  *  0 - success.
670  *      - If a matching entry was found eof will be B_FALSE and
671  *        sinfo will be populated.
672  *      - If there are no matching entries eof will be B_TRUE.
673  * errno - error
674  */
675 int
smb_odir_read_streaminfo(smb_request_t * sr,smb_odir_t * od,smb_streaminfo_t * sinfo,boolean_t * eof)676 smb_odir_read_streaminfo(smb_request_t *sr, smb_odir_t *od,
677     smb_streaminfo_t *sinfo, boolean_t *eof)
678 {
679 	int		rc;
680 	cred_t		*kcr;
681 	smb_odirent_t	*odirent;
682 	smb_node_t	*fnode;
683 	smb_attr_t	attr;
684 
685 	ASSERT(sr);
686 	ASSERT(sr->sr_magic == SMB_REQ_MAGIC);
687 	ASSERT(od);
688 	ASSERT(od->d_magic == SMB_ODIR_MAGIC);
689 	ASSERT(sinfo);
690 
691 	kcr = zone_kcred();
692 
693 	mutex_enter(&od->d_mutex);
694 	ASSERT(od->d_refcnt > 0);
695 
696 	switch (od->d_state) {
697 	case SMB_ODIR_STATE_IN_USE:
698 	case SMB_ODIR_STATE_CLOSING:
699 		break;
700 	case SMB_ODIR_STATE_OPEN:
701 	case SMB_ODIR_STATE_CLOSED:
702 	default:
703 		mutex_exit(&od->d_mutex);
704 		return (EBADF);
705 	}
706 
707 	/* Check that odir represents an xattr directory */
708 	if (!(od->d_flags & SMB_ODIR_FLAG_XATTR)) {
709 		*eof = B_TRUE;
710 		mutex_exit(&od->d_mutex);
711 		return (0);
712 	}
713 
714 	odirent = kmem_alloc(sizeof (smb_odirent_t), KM_SLEEP);
715 	bzero(&attr, sizeof (attr));
716 
717 	for (;;) {
718 		bzero(sinfo, sizeof (smb_streaminfo_t));
719 		if ((rc = smb_odir_next_odirent(od, odirent)) != 0)
720 			break;
721 
722 		if (strncmp(odirent->od_name, SMB_STREAM_PREFIX,
723 		    SMB_STREAM_PREFIX_LEN)) {
724 			continue;
725 		}
726 
727 		rc = smb_fsop_lookup(sr, od->d_cred, 0, od->d_tree->t_snode,
728 		    od->d_dnode, odirent->od_name, &fnode);
729 		if (rc == 0) {
730 			/*
731 			 * We just need the file sizes, and don't want
732 			 * EACCES failures here, so use kcred and pass
733 			 * NULL as the sr to skip sr->fid-ofile checks.
734 			 */
735 			attr.sa_mask = SMB_AT_SIZE | SMB_AT_ALLOCSZ;
736 			rc = smb_node_getattr(NULL, fnode, kcr, NULL, &attr);
737 			smb_node_release(fnode);
738 		}
739 
740 		if (rc == 0) {
741 			(void) strlcpy(sinfo->si_name,
742 			    odirent->od_name + SMB_STREAM_PREFIX_LEN,
743 			    sizeof (sinfo->si_name));
744 			sinfo->si_size = attr.sa_vattr.va_size;
745 			sinfo->si_alloc_size = attr.sa_allocsz;
746 			break;
747 		}
748 	}
749 	mutex_exit(&od->d_mutex);
750 
751 	kmem_free(odirent, sizeof (smb_odirent_t));
752 
753 	switch (rc) {
754 	case 0:
755 		*eof = B_FALSE;
756 		return (0);
757 	case ENOENT:
758 		*eof = B_TRUE;
759 		return (0);
760 	default:
761 		return (rc);
762 	}
763 }
764 
765 /*
766  * smb_odir_save_cookie
767  *
768  * Callers can save up to SMB_MAX_SEARCH cookies in the odir
769  * to be used as resume points for a 'find next' request.
770  */
771 void
smb_odir_save_cookie(smb_odir_t * od,int idx,uint32_t cookie)772 smb_odir_save_cookie(smb_odir_t *od, int idx, uint32_t cookie)
773 {
774 	ASSERT(od);
775 	ASSERT(od->d_magic == SMB_ODIR_MAGIC);
776 	ASSERT(idx >= 0 && idx < SMB_MAX_SEARCH);
777 
778 	mutex_enter(&od->d_mutex);
779 	od->d_cookies[idx] = cookie;
780 	mutex_exit(&od->d_mutex);
781 }
782 
783 /*
784  * smb_odir_save_fname
785  *
786  * Save a filename / offset pair, which are basically a
787  * one entry cache.  See smb_com_trans2_find_next2.
788  */
789 void
smb_odir_save_fname(smb_odir_t * od,uint32_t cookie,const char * fname)790 smb_odir_save_fname(smb_odir_t *od, uint32_t cookie, const char *fname)
791 {
792 	ASSERT(od);
793 	ASSERT(od->d_magic == SMB_ODIR_MAGIC);
794 
795 	mutex_enter(&od->d_mutex);
796 
797 	od->d_last_cookie = cookie;
798 	bzero(od->d_last_name, MAXNAMELEN);
799 	if (fname != NULL)
800 		(void) strlcpy(od->d_last_name, fname, MAXNAMELEN);
801 
802 	mutex_exit(&od->d_mutex);
803 }
804 
805 /*
806  * smb_odir_resume_at
807  *
808  * If SMB_ODIR_FLAG_WILDCARDS is not set, and we're rewinding,
809  * assume we're no longer at EOF.
810  *
811  * Wildcard searching can be resumed from:
812  * - the cookie saved at a specified index (SMBsearch, SMBfind).
813  * - a specified cookie (SMB_trans2_find)
814  * - a specified filename (SMB_trans2_find) - NOT SUPPORTED.
815  *   Defaults to continuing from where the last search ended.
816  *
817  * Continuation from where the last search ended (SMB_trans2_find)
818  * is implemented by saving the last cookie at a specific index (0)
819  * smb_odir_resume_at indicates a new request, so reset od->d_bufptr
820  * and d_eof to force a vop_readdir.
821  */
822 void
smb_odir_resume_at(smb_odir_t * od,smb_odir_resume_t * resume)823 smb_odir_resume_at(smb_odir_t *od, smb_odir_resume_t *resume)
824 {
825 	uint64_t save_offset;
826 
827 	ASSERT(od);
828 	ASSERT(od->d_magic == SMB_ODIR_MAGIC);
829 	ASSERT(resume);
830 
831 	if ((od->d_flags & SMB_ODIR_FLAG_WILDCARDS) == 0) {
832 		if (resume->or_type == SMB_ODIR_RESUME_COOKIE)
833 			od->d_eof = B_FALSE;
834 		return;
835 	}
836 	mutex_enter(&od->d_mutex);
837 
838 	save_offset = od->d_offset;
839 	switch (resume->or_type) {
840 
841 	default:
842 	case SMB_ODIR_RESUME_CONT:
843 		/* Continue where we left off. */
844 		break;
845 
846 	case SMB_ODIR_RESUME_IDX:
847 		/*
848 		 * This is used only by the (ancient) SMB_SEARCH.
849 		 * Modern clients use trans2 FindFirst, FindNext.
850 		 */
851 		ASSERT(resume->or_idx >= 0);
852 		ASSERT(resume->or_idx < SMB_MAX_SEARCH);
853 
854 		if ((resume->or_idx < 0) ||
855 		    (resume->or_idx >= SMB_MAX_SEARCH)) {
856 			resume->or_idx = 0;
857 		}
858 		od->d_offset = od->d_cookies[resume->or_idx];
859 		break;
860 
861 	case SMB_ODIR_RESUME_COOKIE:
862 		od->d_offset = resume->or_cookie;
863 		break;
864 
865 	case SMB_ODIR_RESUME_FNAME:
866 		/*
867 		 * If the name matches the last one saved,
868 		 * use the offset that was saved with it in
869 		 * the odir.  Otherwise use the cookie value
870 		 * in the resume data from the client.
871 		 */
872 		if (strcmp(resume->or_fname, od->d_last_name) &&
873 		    od->d_last_cookie != 0) {
874 			od->d_offset = od->d_last_cookie;
875 		} else if (resume->or_cookie != 0) {
876 			od->d_offset = resume->or_cookie;
877 		} /* else continue where we left off */
878 		break;
879 	}
880 
881 	if (od->d_offset != save_offset) {
882 		/* Force a vop_readdir to refresh d_buf */
883 		od->d_bufptr = NULL;
884 		od->d_eof = B_FALSE;
885 	}
886 
887 	mutex_exit(&od->d_mutex);
888 }
889 
890 
891 /* *** static functions *** */
892 
893 /*
894  * smb_odir_create
895  * Allocate and populate an odir obect and add it to the tree's list.
896  */
897 static smb_odir_t *
smb_odir_create(smb_request_t * sr,smb_node_t * dnode,const char * pattern,uint16_t sattr,uint16_t odid,cred_t * cr)898 smb_odir_create(smb_request_t *sr, smb_node_t *dnode,
899 	const char *pattern, uint16_t sattr, uint16_t odid, cred_t *cr)
900 {
901 	smb_odir_t	*od;
902 	smb_tree_t	*tree;
903 
904 	ASSERT(sr);
905 	ASSERT(sr->sr_magic == SMB_REQ_MAGIC);
906 	ASSERT(sr->tid_tree);
907 	ASSERT(sr->tid_tree->t_magic == SMB_TREE_MAGIC);
908 	ASSERT(dnode);
909 	ASSERT(dnode->n_magic == SMB_NODE_MAGIC);
910 
911 	tree = sr->tid_tree;
912 
913 	od = kmem_cache_alloc(smb_cache_odir, KM_SLEEP);
914 	bzero(od, sizeof (smb_odir_t));
915 
916 	mutex_init(&od->d_mutex, NULL, MUTEX_DEFAULT, NULL);
917 
918 	/*
919 	 * Return this to the caller as if they had done
920 	 * smb_tree_lookup_odir() to obtain the odir.
921 	 */
922 	od->d_refcnt = 1;
923 	od->d_state = SMB_ODIR_STATE_IN_USE;
924 	od->d_magic = SMB_ODIR_MAGIC;
925 	od->d_opened_by_pid = sr->smb_pid;
926 	od->d_session = tree->t_session;
927 	od->d_cred = cr;
928 	/*
929 	 * grab a ref for od->d_user
930 	 * released in  smb_odir_delete()
931 	 */
932 	smb_user_hold_internal(sr->uid_user);
933 	od->d_user = sr->uid_user;
934 	od->d_tree = tree;
935 	od->d_dnode = dnode;
936 	smb_node_ref(dnode);
937 	od->d_odid = odid;
938 	od->d_sattr = sattr;
939 	(void) strlcpy(od->d_pattern, pattern, sizeof (od->d_pattern));
940 	od->d_flags = 0;
941 	if (smb_contains_wildcards(od->d_pattern))
942 		od->d_flags |= SMB_ODIR_FLAG_WILDCARDS;
943 	if (vfs_has_feature(dnode->vp->v_vfsp, VFSFT_DIRENTFLAGS))
944 		od->d_flags |= SMB_ODIR_FLAG_EDIRENT;
945 	if (smb_tree_has_feature(tree, SMB_TREE_CASEINSENSITIVE))
946 		od->d_flags |= SMB_ODIR_FLAG_IGNORE_CASE;
947 	if (smb_tree_has_feature(tree, SMB_TREE_SHORTNAMES))
948 		od->d_flags |= SMB_ODIR_FLAG_SHORTNAMES;
949 	if (SMB_TREE_SUPPORTS_CATIA(sr))
950 		od->d_flags |= SMB_ODIR_FLAG_CATIA;
951 	if (SMB_TREE_SUPPORTS_ABE(sr))
952 		od->d_flags |= SMB_ODIR_FLAG_ABE;
953 	if (dnode->flags & NODE_XATTR_DIR)
954 		od->d_flags |= SMB_ODIR_FLAG_XATTR;
955 	od->d_eof = B_FALSE;
956 
957 	smb_llist_enter(&tree->t_odir_list, RW_WRITER);
958 	smb_llist_insert_tail(&tree->t_odir_list, od);
959 	smb_llist_exit(&tree->t_odir_list);
960 
961 	atomic_inc_32(&tree->t_session->s_dir_cnt);
962 	return (od);
963 }
964 
965 /*
966  * Set a new pattern, attributes, and rewind.
967  */
968 void
smb_odir_reopen(smb_odir_t * od,const char * pattern,uint16_t sattr)969 smb_odir_reopen(smb_odir_t *od, const char *pattern, uint16_t sattr)
970 {
971 
972 	SMB_ODIR_VALID(od);
973 
974 	mutex_enter(&od->d_mutex);
975 	od->d_sattr = sattr;
976 	(void) strlcpy(od->d_pattern, pattern, sizeof (od->d_pattern));
977 	if (smb_contains_wildcards(od->d_pattern))
978 		od->d_flags |= SMB_ODIR_FLAG_WILDCARDS;
979 	else
980 		od->d_flags &= ~SMB_ODIR_FLAG_WILDCARDS;
981 
982 	/* Internal smb_odir_resume_at */
983 	od->d_offset = 0;
984 	od->d_bufptr = NULL;
985 	od->d_eof = B_FALSE;
986 
987 	mutex_exit(&od->d_mutex);
988 }
989 
990 /*
991  * Delete an odir.
992  *
993  * Remove the odir from the tree list before freeing resources
994  * associated with the odir.
995  */
996 static void
smb_odir_delete(void * arg)997 smb_odir_delete(void *arg)
998 {
999 	smb_tree_t	*tree;
1000 	smb_odir_t	*od = (smb_odir_t *)arg;
1001 
1002 	SMB_ODIR_VALID(od);
1003 	ASSERT(od->d_refcnt == 0);
1004 	ASSERT(od->d_state == SMB_ODIR_STATE_CLOSED);
1005 
1006 	tree = od->d_tree;
1007 	smb_llist_enter(&tree->t_odir_list, RW_WRITER);
1008 	smb_llist_remove(&tree->t_odir_list, od);
1009 	if (od->d_odid != 0)
1010 		smb_idpool_free(&tree->t_odid_pool, od->d_odid);
1011 	atomic_dec_32(&tree->t_session->s_dir_cnt);
1012 	smb_llist_exit(&tree->t_odir_list);
1013 
1014 	/*
1015 	 * This odir is no longer on t_odir_list, however...
1016 	 *
1017 	 * This is called via smb_llist_post, which means it may run
1018 	 * BEFORE smb_odir_release drops d_mutex (if another thread
1019 	 * flushes the delete queue before we do).  Synchronize.
1020 	 */
1021 	mutex_enter(&od->d_mutex);
1022 	mutex_exit(&od->d_mutex);
1023 
1024 	od->d_magic = 0;
1025 	smb_node_release(od->d_dnode);
1026 	smb_user_release(od->d_user);
1027 	mutex_destroy(&od->d_mutex);
1028 	kmem_cache_free(smb_cache_odir, od);
1029 }
1030 
1031 /*
1032  * smb_odir_next_odirent
1033  *
1034  * Find the next directory entry in d_buf. If d_bufptr is NULL (buffer
1035  * is empty or we've reached the end of it), read the next set of
1036  * entries from the file system (vop_readdir).
1037  *
1038  * File systems which support VFSFT_EDIRENT_FLAGS will return the
1039  * directory entries as a buffer of edirent_t structure. Others will
1040  * return a buffer of dirent64_t structures.  For simplicity translate
1041  * the data into an smb_odirent_t structure.
1042  * The ed_name/d_name in d_buf is NULL terminated by the file system.
1043  *
1044  * Some file systems can have directories larger than SMB_MAXDIRSIZE.
1045  * If the odirent offset >= SMB_MAXDIRSIZE return ENOENT and set d_eof
1046  * to true to stop subsequent calls to smb_vop_readdir.
1047  *
1048  * Returns:
1049  *      0 - success. odirent is populated with the next directory entry
1050  * ENOENT - no more directory entries
1051  *  errno - error
1052  */
1053 static int
smb_odir_next_odirent(smb_odir_t * od,smb_odirent_t * odirent)1054 smb_odir_next_odirent(smb_odir_t *od, smb_odirent_t *odirent)
1055 {
1056 	int		rc;
1057 	int		reclen;
1058 	int		eof;
1059 	dirent64_t	*dp;
1060 	edirent_t	*edp;
1061 	char		*np;
1062 	uint32_t	rddir_flags = 0;
1063 
1064 	ASSERT(MUTEX_HELD(&od->d_mutex));
1065 
1066 	bzero(odirent, sizeof (smb_odirent_t));
1067 
1068 	if (od->d_flags & SMB_ODIR_FLAG_ABE)
1069 		rddir_flags |= SMB_ABE;
1070 	if (od->d_flags & SMB_ODIR_FLAG_EDIRENT)
1071 		rddir_flags |= SMB_EDIRENT;
1072 
1073 	if (od->d_bufptr != NULL) {
1074 		if (od->d_flags & SMB_ODIR_FLAG_EDIRENT)
1075 			reclen = od->d_edp->ed_reclen;
1076 		else
1077 			reclen = od->d_dp->d_reclen;
1078 
1079 		if (reclen == 0) {
1080 			od->d_bufptr = NULL;
1081 		} else {
1082 			od->d_bufptr += reclen;
1083 			if (od->d_bufptr >= od->d_buf + od->d_bufsize)
1084 				od->d_bufptr = NULL;
1085 		}
1086 	}
1087 
1088 	if (od->d_bufptr == NULL) {
1089 		if (od->d_eof)
1090 			return (ENOENT);
1091 
1092 		od->d_bufsize = sizeof (od->d_buf);
1093 
1094 		rc = smb_vop_readdir(od->d_dnode->vp, od->d_offset,
1095 		    od->d_buf, &od->d_bufsize, &eof, rddir_flags, od->d_cred);
1096 
1097 		if ((rc == 0) && (od->d_bufsize == 0))
1098 			rc = ENOENT;
1099 
1100 		if (rc != 0) {
1101 			od->d_bufptr = NULL;
1102 			od->d_bufsize = 0;
1103 			return (rc);
1104 		}
1105 
1106 		od->d_eof = (eof != 0);
1107 		od->d_bufptr = od->d_buf;
1108 	}
1109 
1110 	if (od->d_flags & SMB_ODIR_FLAG_EDIRENT)
1111 		od->d_offset = od->d_edp->ed_off;
1112 	else
1113 		od->d_offset = od->d_dp->d_off;
1114 
1115 	if (od->d_offset >= SMB_MAXDIRSIZE) {
1116 		od->d_bufptr = NULL;
1117 		od->d_bufsize = 0;
1118 		od->d_eof = B_TRUE;
1119 		return (ENOENT);
1120 	}
1121 
1122 	if (od->d_flags & SMB_ODIR_FLAG_EDIRENT) {
1123 		edp = od->d_edp;
1124 		odirent->od_ino = edp->ed_ino;
1125 		odirent->od_eflags = edp->ed_eflags;
1126 		np = edp->ed_name;
1127 	} else {
1128 		dp = od->d_dp;
1129 		odirent->od_ino = dp->d_ino;
1130 		odirent->od_eflags = 0;
1131 		np =  dp->d_name;
1132 	}
1133 
1134 	if ((od->d_flags & SMB_ODIR_FLAG_CATIA) &&
1135 	    ((od->d_flags & SMB_ODIR_FLAG_XATTR) == 0)) {
1136 		smb_vop_catia_v4tov5(np, odirent->od_name,
1137 		    sizeof (odirent->od_name));
1138 	} else {
1139 		(void) strlcpy(odirent->od_name, np,
1140 		    sizeof (odirent->od_name));
1141 	}
1142 
1143 	return (0);
1144 }
1145 
1146 /*
1147  * smb_odir_single_fileinfo
1148  *
1149  * Lookup the file identified by od->d_pattern.
1150  *
1151  * If the looked up file is a link, we attempt to lookup the link target
1152  * to use its attributes in place of those of the files's.
1153  * If we fail to lookup the target of the link we use the original
1154  * file's attributes.
1155  * Check if the attributes match the search attributes.
1156  *
1157  * Returns: 0 - success
1158  *     ENOENT - no match
1159  *      errno - error
1160  */
1161 static int
smb_odir_single_fileinfo(smb_request_t * sr,smb_odir_t * od,smb_fileinfo_t * fileinfo)1162 smb_odir_single_fileinfo(smb_request_t *sr, smb_odir_t *od,
1163     smb_fileinfo_t *fileinfo)
1164 {
1165 	int		rc;
1166 	smb_node_t	*fnode, *tgt_node;
1167 	smb_attr_t	attr;
1168 	ino64_t		fid;
1169 	char		*name;
1170 	boolean_t	case_conflict = B_FALSE;
1171 	int		lookup_flags, flags = 0;
1172 	vnode_t		*vp;
1173 
1174 	ASSERT(sr);
1175 	ASSERT(sr->sr_magic == SMB_REQ_MAGIC);
1176 	ASSERT(od);
1177 	ASSERT(od->d_magic == SMB_ODIR_MAGIC);
1178 
1179 	ASSERT(MUTEX_HELD(&od->d_mutex));
1180 	bzero(fileinfo, sizeof (smb_fileinfo_t));
1181 
1182 	rc = smb_fsop_lookup(sr, od->d_cred, 0, od->d_tree->t_snode,
1183 	    od->d_dnode, od->d_pattern, &fnode);
1184 	if (rc != 0)
1185 		return (rc);
1186 
1187 	/*
1188 	 * If case sensitive, do a case insensitive smb_vop_lookup to
1189 	 * check for case conflict
1190 	 */
1191 	if (od->d_flags & SMB_ODIR_FLAG_IGNORE_CASE) {
1192 		lookup_flags = SMB_IGNORE_CASE;
1193 		if (od->d_flags & SMB_ODIR_FLAG_CATIA)
1194 			lookup_flags |= SMB_CATIA;
1195 
1196 		rc = smb_vop_lookup(od->d_dnode->vp, fnode->od_name, &vp,
1197 		    NULL, lookup_flags, &flags, od->d_tree->t_snode->vp,
1198 		    NULL, od->d_cred);
1199 		if (rc != 0)
1200 			return (rc);
1201 		VN_RELE(vp);
1202 
1203 		if (flags & ED_CASE_CONFLICT)
1204 			case_conflict = B_TRUE;
1205 	}
1206 
1207 	bzero(&attr, sizeof (attr));
1208 	attr.sa_mask = SMB_AT_ALL;
1209 	rc = smb_node_getattr(NULL, fnode, zone_kcred(), NULL, &attr);
1210 	if (rc != 0) {
1211 		smb_node_release(fnode);
1212 		return (rc);
1213 	}
1214 
1215 
1216 	/* follow link to get target node & attr */
1217 	if (smb_node_is_symlink(fnode) &&
1218 	    smb_odir_lookup_link(sr, od, fnode->od_name, &tgt_node)) {
1219 		smb_node_release(fnode);
1220 		fnode = tgt_node;
1221 		attr.sa_mask = SMB_AT_ALL;
1222 		rc = smb_node_getattr(NULL, fnode, zone_kcred(), NULL, &attr);
1223 		if (rc != 0) {
1224 			smb_node_release(fnode);
1225 			return (rc);
1226 		}
1227 	}
1228 
1229 	/* check search attributes */
1230 	if (!smb_sattr_check(attr.sa_dosattr, od->d_sattr)) {
1231 		smb_node_release(fnode);
1232 		return (ENOENT);
1233 	}
1234 
1235 	name = fnode->od_name;
1236 	if (od->d_flags & SMB_ODIR_FLAG_SHORTNAMES) {
1237 		fid = attr.sa_vattr.va_nodeid;
1238 		if (case_conflict || smb_needs_mangled(name)) {
1239 			smb_mangle(name, fid, fileinfo->fi_shortname,
1240 			    SMB_SHORTNAMELEN);
1241 		}
1242 		if (case_conflict)
1243 			name = fileinfo->fi_shortname;
1244 	}
1245 
1246 	(void) strlcpy(fileinfo->fi_name, name, sizeof (fileinfo->fi_name));
1247 
1248 	fileinfo->fi_dosattr = attr.sa_dosattr;
1249 	fileinfo->fi_nodeid = attr.sa_vattr.va_nodeid;
1250 	fileinfo->fi_size = attr.sa_vattr.va_size;
1251 	fileinfo->fi_alloc_size = attr.sa_allocsz;
1252 	fileinfo->fi_atime = attr.sa_vattr.va_atime;
1253 	fileinfo->fi_mtime = attr.sa_vattr.va_mtime;
1254 	fileinfo->fi_ctime = attr.sa_vattr.va_ctime;
1255 	if (attr.sa_crtime.tv_sec)
1256 		fileinfo->fi_crtime = attr.sa_crtime;
1257 	else
1258 		fileinfo->fi_crtime = attr.sa_vattr.va_mtime;
1259 
1260 	smb_node_release(fnode);
1261 	return (0);
1262 }
1263 
1264 /*
1265  * smb_odir_wildcard_fileinfo
1266  *
1267  * odirent contains a directory entry, obtained from a vop_readdir.
1268  * If a case conflict is identified the filename is mangled and the
1269  * shortname is used as 'name', in place of odirent->od_name.
1270  *
1271  * If the looked up file is a link, we attempt to lookup the link target
1272  * to use its attributes in place of those of the files's.
1273  * If we fail to lookup the target of the link we use the original
1274  * file's attributes.
1275  * Check if the attributes match the search attributes.
1276  *
1277  * Although some file systems can have directories larger than
1278  * SMB_MAXDIRSIZE smb_odir_next_odirent ensures that no offset larger
1279  * than SMB_MAXDIRSIZE is returned.  It is therefore safe to use the
1280  * offset as the cookie (uint32_t).
1281  *
1282  * Returns: 0 - success
1283  *     ENOENT - no match, proceed to next entry
1284  *      errno - error
1285  */
1286 static int
smb_odir_wildcard_fileinfo(smb_request_t * sr,smb_odir_t * od,smb_odirent_t * odirent,smb_fileinfo_t * fileinfo)1287 smb_odir_wildcard_fileinfo(smb_request_t *sr, smb_odir_t *od,
1288     smb_odirent_t *odirent, smb_fileinfo_t *fileinfo)
1289 {
1290 	int		rc;
1291 	cred_t		*cr;
1292 	smb_node_t	*fnode, *tgt_node;
1293 	smb_attr_t	attr;
1294 	char		*name;
1295 	boolean_t	case_conflict;
1296 
1297 	ASSERT(sr);
1298 	ASSERT(sr->sr_magic == SMB_REQ_MAGIC);
1299 	ASSERT(od);
1300 	ASSERT(od->d_magic == SMB_ODIR_MAGIC);
1301 
1302 	ASSERT(MUTEX_HELD(&od->d_mutex));
1303 	bzero(fileinfo, sizeof (smb_fileinfo_t));
1304 
1305 	rc = smb_fsop_lookup(sr, od->d_cred, SMB_CASE_SENSITIVE,
1306 	    od->d_tree->t_snode, od->d_dnode, odirent->od_name, &fnode);
1307 	if (rc != 0)
1308 		return (rc);
1309 
1310 	/* follow link to get target node & attr */
1311 	if (smb_node_is_symlink(fnode) &&
1312 	    smb_odir_lookup_link(sr, od, odirent->od_name, &tgt_node)) {
1313 		smb_node_release(fnode);
1314 		fnode = tgt_node;
1315 	}
1316 
1317 	/* skip system files */
1318 	if (smb_node_is_system(fnode)) {
1319 		smb_node_release(fnode);
1320 		return (ENOENT);
1321 	}
1322 
1323 	/*
1324 	 * Windows directory listings return not only names, but
1325 	 * also some attributes.  In Unix, you need some access to
1326 	 * get those attributes.  Which credential should we use to
1327 	 * get those?  If we're doing Access Based Enumeration (ABE)
1328 	 * we want this getattr to fail, which will cause the caller
1329 	 * to skip this entry.  If we're NOT doing ABE, we normally
1330 	 * want to show all the directory entries (including their
1331 	 * attributes) so we want this getattr to succeed!
1332 	 */
1333 	if (smb_tree_has_feature(od->d_tree, SMB_TREE_ABE))
1334 		cr = od->d_cred;
1335 	else
1336 		cr = zone_kcred();
1337 
1338 	bzero(&attr, sizeof (attr));
1339 	attr.sa_mask = SMB_AT_ALL;
1340 	rc = smb_node_getattr(NULL, fnode, cr, NULL, &attr);
1341 	if (rc != 0) {
1342 		smb_node_release(fnode);
1343 		return (rc);
1344 	}
1345 
1346 	/* check search attributes */
1347 	if (!smb_sattr_check(attr.sa_dosattr, od->d_sattr)) {
1348 		smb_node_release(fnode);
1349 		return (ENOENT);
1350 	}
1351 
1352 	name = odirent->od_name;
1353 	if (od->d_flags & SMB_ODIR_FLAG_SHORTNAMES) {
1354 		case_conflict = ((od->d_flags & SMB_ODIR_FLAG_IGNORE_CASE) &&
1355 		    (odirent->od_eflags & ED_CASE_CONFLICT));
1356 		if (case_conflict || smb_needs_mangled(name)) {
1357 			smb_mangle(name, odirent->od_ino,
1358 			    fileinfo->fi_shortname, SMB_SHORTNAMELEN);
1359 		}
1360 		if (case_conflict)
1361 			name = fileinfo->fi_shortname;
1362 	}
1363 
1364 	(void) strlcpy(fileinfo->fi_name, name, sizeof (fileinfo->fi_name));
1365 
1366 	fileinfo->fi_cookie = (uint32_t)od->d_offset;
1367 	fileinfo->fi_dosattr = attr.sa_dosattr;
1368 	fileinfo->fi_nodeid = attr.sa_vattr.va_nodeid;
1369 	fileinfo->fi_size = attr.sa_vattr.va_size;
1370 	fileinfo->fi_alloc_size = attr.sa_allocsz;
1371 	fileinfo->fi_atime = attr.sa_vattr.va_atime;
1372 	fileinfo->fi_mtime = attr.sa_vattr.va_mtime;
1373 	fileinfo->fi_ctime = attr.sa_vattr.va_ctime;
1374 	if (attr.sa_crtime.tv_sec)
1375 		fileinfo->fi_crtime = attr.sa_crtime;
1376 	else
1377 		fileinfo->fi_crtime = attr.sa_vattr.va_mtime;
1378 
1379 	smb_node_release(fnode);
1380 	return (0);
1381 }
1382 
1383 /*
1384  * smb_odir_lookup_link
1385  *
1386  * If the file is a symlink we lookup the object to which the
1387  * symlink refers so that we can return its attributes.
1388  * This can cause a problem if a symlink in a sub-directory
1389  * points to a parent directory (some UNIX GUI's create a symlink
1390  * in $HOME/.desktop that points to the user's home directory).
1391  * Some Windows applications (e.g. virus scanning) loop/hang
1392  * trying to follow this recursive path and there is little
1393  * we can do because the path is constructed on the client.
1394  * smb_dirsymlink_enable allows an end-user to disable
1395  * symlinks to directories. Symlinks to other object types
1396  * should be unaffected.
1397  *
1398  * Returns: B_TRUE  - followed link. tgt_node and tgt_attr set
1399  *          B_FALSE - link not followed
1400  */
1401 static boolean_t
smb_odir_lookup_link(smb_request_t * sr,smb_odir_t * od,char * fname,smb_node_t ** tgt_node)1402 smb_odir_lookup_link(smb_request_t *sr, smb_odir_t *od,
1403     char *fname, smb_node_t **tgt_node)
1404 {
1405 	int rc;
1406 	uint32_t flags = SMB_FOLLOW_LINKS | SMB_CASE_SENSITIVE;
1407 
1408 	rc = smb_fsop_lookup(sr, od->d_cred, flags,
1409 	    od->d_tree->t_snode, od->d_dnode, fname, tgt_node);
1410 	if (rc != 0) {
1411 		*tgt_node = NULL;
1412 		return (B_FALSE);
1413 	}
1414 
1415 	if (smb_node_is_dir(*tgt_node) && (!smb_dirsymlink_enable)) {
1416 		smb_node_release(*tgt_node);
1417 		*tgt_node = NULL;
1418 		return (B_FALSE);
1419 	}
1420 
1421 	return (B_TRUE);
1422 }
1423 
1424 /*
1425  * smb_odir_match_name
1426  *
1427  * Check if the directory entry name matches the search pattern:
1428  * - Don't match reserved dos filenames.
1429  * - Check if odirent->od_name matches od->d_pattern.
1430  * - If shortnames are supported, generate the shortname from
1431  *   odirent->od_name and check if it matches od->d_pattern.
1432  */
1433 static boolean_t
smb_odir_match_name(smb_odir_t * od,smb_odirent_t * odirent)1434 smb_odir_match_name(smb_odir_t *od, smb_odirent_t *odirent)
1435 {
1436 	char	*name = odirent->od_name;
1437 	char	shortname[SMB_SHORTNAMELEN];
1438 	ino64_t	ino = odirent->od_ino;
1439 	boolean_t ci = (od->d_flags & SMB_ODIR_FLAG_IGNORE_CASE) != 0;
1440 
1441 	if (smb_is_reserved_dos_name(name))
1442 		return (B_FALSE);
1443 
1444 	if (smb_match(od->d_pattern, name, ci))
1445 		return (B_TRUE);
1446 
1447 	if (od->d_flags & SMB_ODIR_FLAG_SHORTNAMES) {
1448 		smb_mangle(name, ino, shortname, SMB_SHORTNAMELEN);
1449 		if (smb_match(od->d_pattern, shortname, ci))
1450 			return (B_TRUE);
1451 	}
1452 
1453 	return (B_FALSE);
1454 }
1455