?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Document default of the printing config variable.
[Samba/nascimento.git] / source3 / smbd / dir.c
blob2b996a41cfd8edaf960c6dc1c3c59fd1874aee6d
1 /*
2 Unix SMB/CIFS implementation.
3 Directory handling routines
4 Copyright (C) Andrew Tridgell 1992-1998
5 Copyright (C) Jeremy Allison 2007
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>.
19 */
20
21 #include "includes.h"
22 #include "smbd/globals.h"
23
24 /*
25 This module implements directory related functions for Samba.
26 */
27
28 /* "Special" directory offsets. */
29 #define END_OF_DIRECTORY_OFFSET ((long)-1)
30 #define START_OF_DIRECTORY_OFFSET ((long)0)
31 #define DOT_DOT_DIRECTORY_OFFSET ((long)0x80000000)
32
33 /* Make directory handle internals available. */
34
35 struct name_cache_entry {
36 char *name;
37 long offset;
38 };
39
40 struct smb_Dir {
41 connection_struct *conn;
42 SMB_STRUCT_DIR *dir;
43 long offset;
44 char *dir_path;
45 size_t name_cache_size;
46 struct name_cache_entry *name_cache;
47 unsigned int name_cache_index;
48 unsigned int file_number;
49 };
50
51 struct dptr_struct {
52 struct dptr_struct *next, *prev;
53 int dnum;
54 uint16 spid;
55 struct connection_struct *conn;
56 struct smb_Dir *dir_hnd;
57 bool expect_close;
58 char *wcard;
59 uint32 attr;
60 char *path;
61 bool has_wild; /* Set to true if the wcard entry has MS wildcard characters in it. */
62 bool did_stat; /* Optimisation for non-wcard searches. */
63 };
64
65
66 #define INVALID_DPTR_KEY (-3)
67
68 /****************************************************************************
69 Make a dir struct.
70 ****************************************************************************/
71
72 bool make_dir_struct(TALLOC_CTX *ctx,
73 char *buf,
74 const char *mask,
75 const char *fname,
76 SMB_OFF_T size,
77 uint32 mode,
78 time_t date,
79 bool uc)
80 {
81 char *p;
82 char *mask2 = talloc_strdup(ctx, mask);
83
84 if (!mask2) {
85 return False;
86 }
87
88 if ((mode & aDIR) != 0) {
89 size = 0;
90 }
91
92 memset(buf+1,' ',11);
93 if ((p = strchr_m(mask2,'.')) != NULL) {
94 *p = 0;
95 push_ascii(buf+1,mask2,8, 0);
96 push_ascii(buf+9,p+1,3, 0);
97 *p = '.';
98 } else {
99 push_ascii(buf+1,mask2,11, 0);
100 }
101
102 memset(buf+21,'\0',DIR_STRUCT_SIZE-21);
103 SCVAL(buf,21,mode);
104 srv_put_dos_date(buf,22,date);
105 SSVAL(buf,26,size & 0xFFFF);
106 SSVAL(buf,28,(size >> 16)&0xFFFF);
107 /* We only uppercase if FLAGS2_LONG_PATH_COMPONENTS is zero in the input buf.
108 Strange, but verified on W2K3. Needed for OS/2. JRA. */
109 push_ascii(buf+30,fname,12, uc ? STR_UPPER : 0);
110 DEBUG(8,("put name [%s] from [%s] into dir struct\n",buf+30, fname));
111 return True;
112 }
113
114 /****************************************************************************
115 Initialise the dir bitmap.
116 ****************************************************************************/
117
118 void init_dptrs(void)
119 {
120 if (dptr_bmap)
121 return;
122
123 dptr_bmap = bitmap_allocate(MAX_DIRECTORY_HANDLES);
124
125 if (!dptr_bmap)
126 exit_server("out of memory in init_dptrs");
127 }
128
129 /****************************************************************************
130 Idle a dptr - the directory is closed but the control info is kept.
131 ****************************************************************************/
132
133 static void dptr_idle(struct dptr_struct *dptr)
134 {
135 if (dptr->dir_hnd) {
136 DEBUG(4,("Idling dptr dnum %d\n",dptr->dnum));
137 TALLOC_FREE(dptr->dir_hnd);
138 }
139 }
140
141 /****************************************************************************
142 Idle the oldest dptr.
143 ****************************************************************************/
144
145 static void dptr_idleoldest(void)
146 {
147 struct dptr_struct *dptr;
148
149 /*
150 * Go to the end of the list.
151 */
152 for(dptr = dirptrs; dptr && dptr->next; dptr = dptr->next)
153 ;
154
155 if(!dptr) {
156 DEBUG(0,("No dptrs available to idle ?\n"));
157 return;
158 }
159
160 /*
161 * Idle the oldest pointer.
162 */
163
164 for(; dptr; dptr = dptr->prev) {
165 if (dptr->dir_hnd) {
166 dptr_idle(dptr);
167 return;
168 }
169 }
170 }
171
172 /****************************************************************************
173 Get the struct dptr_struct for a dir index.
174 ****************************************************************************/
175
176 static struct dptr_struct *dptr_get(int key, bool forclose)
177 {
178 struct dptr_struct *dptr;
179
180 for(dptr = dirptrs; dptr; dptr = dptr->next) {
181 if(dptr->dnum == key) {
182 if (!forclose && !dptr->dir_hnd) {
183 if (dirhandles_open >= MAX_OPEN_DIRECTORIES)
184 dptr_idleoldest();
185 DEBUG(4,("dptr_get: Reopening dptr key %d\n",key));
186 if (!(dptr->dir_hnd = OpenDir(
187 NULL, dptr->conn, dptr->path,
188 dptr->wcard, dptr->attr))) {
189 DEBUG(4,("dptr_get: Failed to open %s (%s)\n",dptr->path,
190 strerror(errno)));
191 return False;
192 }
193 }
194 DLIST_PROMOTE(dirptrs,dptr);
195 return dptr;
196 }
197 }
198 return(NULL);
199 }
200
201 /****************************************************************************
202 Get the dir path for a dir index.
203 ****************************************************************************/
204
205 char *dptr_path(int key)
206 {
207 struct dptr_struct *dptr = dptr_get(key, False);
208 if (dptr)
209 return(dptr->path);
210 return(NULL);
211 }
212
213 /****************************************************************************
214 Get the dir wcard for a dir index.
215 ****************************************************************************/
216
217 char *dptr_wcard(int key)
218 {
219 struct dptr_struct *dptr = dptr_get(key, False);
220 if (dptr)
221 return(dptr->wcard);
222 return(NULL);
223 }
224
225 /****************************************************************************
226 Get the dir attrib for a dir index.
227 ****************************************************************************/
228
229 uint16 dptr_attr(int key)
230 {
231 struct dptr_struct *dptr = dptr_get(key, False);
232 if (dptr)
233 return(dptr->attr);
234 return(0);
235 }
236
237 /****************************************************************************
238 Close a dptr (internal func).
239 ****************************************************************************/
240
241 static void dptr_close_internal(struct dptr_struct *dptr)
242 {
243 DEBUG(4,("closing dptr key %d\n",dptr->dnum));
244
245 DLIST_REMOVE(dirptrs, dptr);
246
247 /*
248 * Free the dnum in the bitmap. Remember the dnum value is always
249 * biased by one with respect to the bitmap.
250 */
251
252 if(bitmap_query( dptr_bmap, dptr->dnum - 1) != True) {
253 DEBUG(0,("dptr_close_internal : Error - closing dnum = %d and bitmap not set !\n",
254 dptr->dnum ));
255 }
256
257 bitmap_clear(dptr_bmap, dptr->dnum - 1);
258
259 TALLOC_FREE(dptr->dir_hnd);
260
261 /* Lanman 2 specific code */
262 SAFE_FREE(dptr->wcard);
263 string_set(&dptr->path,"");
264 SAFE_FREE(dptr);
265 }
266
267 /****************************************************************************
268 Close a dptr given a key.
269 ****************************************************************************/
270
271 void dptr_close(int *key)
272 {
273 struct dptr_struct *dptr;
274
275 if(*key == INVALID_DPTR_KEY)
276 return;
277
278 /* OS/2 seems to use -1 to indicate "close all directories" */
279 if (*key == -1) {
280 struct dptr_struct *next;
281 for(dptr = dirptrs; dptr; dptr = next) {
282 next = dptr->next;
283 dptr_close_internal(dptr);
284 }
285 *key = INVALID_DPTR_KEY;
286 return;
287 }
288
289 dptr = dptr_get(*key, True);
290
291 if (!dptr) {
292 DEBUG(0,("Invalid key %d given to dptr_close\n", *key));
293 return;
294 }
295
296 dptr_close_internal(dptr);
297
298 *key = INVALID_DPTR_KEY;
299 }
300
301 /****************************************************************************
302 Close all dptrs for a cnum.
303 ****************************************************************************/
304
305 void dptr_closecnum(connection_struct *conn)
306 {
307 struct dptr_struct *dptr, *next;
308 for(dptr = dirptrs; dptr; dptr = next) {
309 next = dptr->next;
310 if (dptr->conn == conn)
311 dptr_close_internal(dptr);
312 }
313 }
314
315 /****************************************************************************
316 Idle all dptrs for a cnum.
317 ****************************************************************************/
318
319 void dptr_idlecnum(connection_struct *conn)
320 {
321 struct dptr_struct *dptr;
322 for(dptr = dirptrs; dptr; dptr = dptr->next) {
323 if (dptr->conn == conn && dptr->dir_hnd)
324 dptr_idle(dptr);
325 }
326 }
327
328 /****************************************************************************
329 Close a dptr that matches a given path, only if it matches the spid also.
330 ****************************************************************************/
331
332 void dptr_closepath(char *path,uint16 spid)
333 {
334 struct dptr_struct *dptr, *next;
335 for(dptr = dirptrs; dptr; dptr = next) {
336 next = dptr->next;
337 if (spid == dptr->spid && strequal(dptr->path,path))
338 dptr_close_internal(dptr);
339 }
340 }
341
342 /****************************************************************************
343 Try and close the oldest handle not marked for
344 expect close in the hope that the client has
345 finished with that one.
346 ****************************************************************************/
347
348 static void dptr_close_oldest(bool old)
349 {
350 struct dptr_struct *dptr;
351
352 /*
353 * Go to the end of the list.
354 */
355 for(dptr = dirptrs; dptr && dptr->next; dptr = dptr->next)
356 ;
357
358 if(!dptr) {
359 DEBUG(0,("No old dptrs available to close oldest ?\n"));
360 return;
361 }
362
363 /*
364 * If 'old' is true, close the oldest oldhandle dnum (ie. 1 < dnum < 256) that
365 * does not have expect_close set. If 'old' is false, close
366 * one of the new dnum handles.
367 */
368
369 for(; dptr; dptr = dptr->prev) {
370 if ((old && (dptr->dnum < 256) && !dptr->expect_close) ||
371 (!old && (dptr->dnum > 255))) {
372 dptr_close_internal(dptr);
373 return;
374 }
375 }
376 }
377
378 /****************************************************************************
379 Create a new dir ptr. If the flag old_handle is true then we must allocate
380 from the bitmap range 0 - 255 as old SMBsearch directory handles are only
381 one byte long. If old_handle is false we allocate from the range
382 256 - MAX_DIRECTORY_HANDLES. We bias the number we return by 1 to ensure
383 a directory handle is never zero.
384 wcard must not be zero.
385 ****************************************************************************/
386
387 NTSTATUS dptr_create(connection_struct *conn, const char *path, bool old_handle, bool expect_close,uint16 spid,
388 const char *wcard, bool wcard_has_wild, uint32 attr, struct dptr_struct **dptr_ret)
389 {
390 struct dptr_struct *dptr = NULL;
391 struct smb_Dir *dir_hnd;
392 NTSTATUS status;
393
394 DEBUG(5,("dptr_create dir=%s\n", path));
395
396 if (!wcard) {
397 return NT_STATUS_INVALID_PARAMETER;
398 }
399
400 status = check_name(conn,path);
401 if (!NT_STATUS_IS_OK(status)) {
402 return status;
403 }
404
405 dir_hnd = OpenDir(NULL, conn, path, wcard, attr);
406 if (!dir_hnd) {
407 return map_nt_error_from_unix(errno);
408 }
409
410 string_set(&conn->dirpath,path);
411
412 if (dirhandles_open >= MAX_OPEN_DIRECTORIES) {
413 dptr_idleoldest();
414 }
415
416 dptr = SMB_MALLOC_P(struct dptr_struct);
417 if(!dptr) {
418 DEBUG(0,("malloc fail in dptr_create.\n"));
419 TALLOC_FREE(dir_hnd);
420 return NT_STATUS_NO_MEMORY;
421 }
422
423 ZERO_STRUCTP(dptr);
424
425 if(old_handle) {
426
427 /*
428 * This is an old-style SMBsearch request. Ensure the
429 * value we return will fit in the range 1-255.
430 */
431
432 dptr->dnum = bitmap_find(dptr_bmap, 0);
433
434 if(dptr->dnum == -1 || dptr->dnum > 254) {
435
436 /*
437 * Try and close the oldest handle not marked for
438 * expect close in the hope that the client has
439 * finished with that one.
440 */
441
442 dptr_close_oldest(True);
443
444 /* Now try again... */
445 dptr->dnum = bitmap_find(dptr_bmap, 0);
446 if(dptr->dnum == -1 || dptr->dnum > 254) {
447 DEBUG(0,("dptr_create: returned %d: Error - all old dirptrs in use ?\n", dptr->dnum));
448 SAFE_FREE(dptr);
449 TALLOC_FREE(dir_hnd);
450 return NT_STATUS_TOO_MANY_OPENED_FILES;
451 }
452 }
453 } else {
454
455 /*
456 * This is a new-style trans2 request. Allocate from
457 * a range that will return 256 - MAX_DIRECTORY_HANDLES.
458 */
459
460 dptr->dnum = bitmap_find(dptr_bmap, 255);
461
462 if(dptr->dnum == -1 || dptr->dnum < 255) {
463
464 /*
465 * Try and close the oldest handle close in the hope that
466 * the client has finished with that one. This will only
467 * happen in the case of the Win98 client bug where it leaks
468 * directory handles.
469 */
470
471 dptr_close_oldest(False);
472
473 /* Now try again... */
474 dptr->dnum = bitmap_find(dptr_bmap, 255);
475
476 if(dptr->dnum == -1 || dptr->dnum < 255) {
477 DEBUG(0,("dptr_create: returned %d: Error - all new dirptrs in use ?\n", dptr->dnum));
478 SAFE_FREE(dptr);
479 TALLOC_FREE(dir_hnd);
480 return NT_STATUS_TOO_MANY_OPENED_FILES;
481 }
482 }
483 }
484
485 bitmap_set(dptr_bmap, dptr->dnum);
486
487 dptr->dnum += 1; /* Always bias the dnum by one - no zero dnums allowed. */
488
489 string_set(&dptr->path,path);
490 dptr->conn = conn;
491 dptr->dir_hnd = dir_hnd;
492 dptr->spid = spid;
493 dptr->expect_close = expect_close;
494 dptr->wcard = SMB_STRDUP(wcard);
495 if (!dptr->wcard) {
496 bitmap_clear(dptr_bmap, dptr->dnum - 1);
497 SAFE_FREE(dptr);
498 TALLOC_FREE(dir_hnd);
499 return NT_STATUS_NO_MEMORY;
500 }
501 if (lp_posix_pathnames() || (wcard[0] == '.' && wcard[1] == 0)) {
502 dptr->has_wild = True;
503 } else {
504 dptr->has_wild = wcard_has_wild;
505 }
506
507 dptr->attr = attr;
508
509 DLIST_ADD(dirptrs, dptr);
510
511 DEBUG(3,("creating new dirptr %d for path %s, expect_close = %d\n",
512 dptr->dnum,path,expect_close));
513
514 *dptr_ret = dptr;
515
516 return NT_STATUS_OK;
517 }
518
519
520 /****************************************************************************
521 Wrapper functions to access the lower level directory handles.
522 ****************************************************************************/
523
524 int dptr_CloseDir(struct dptr_struct *dptr)
525 {
526 DLIST_REMOVE(dirptrs, dptr);
527 TALLOC_FREE(dptr->dir_hnd);
528 return 0;
529 }
530
531 void dptr_SeekDir(struct dptr_struct *dptr, long offset)
532 {
533 SeekDir(dptr->dir_hnd, offset);
534 }
535
536 long dptr_TellDir(struct dptr_struct *dptr)
537 {
538 return TellDir(dptr->dir_hnd);
539 }
540
541 bool dptr_has_wild(struct dptr_struct *dptr)
542 {
543 return dptr->has_wild;
544 }
545
546 int dptr_dnum(struct dptr_struct *dptr)
547 {
548 return dptr->dnum;
549 }
550
551 /****************************************************************************
552 Return the next visible file name, skipping veto'd and invisible files.
553 ****************************************************************************/
554
555 static const char *dptr_normal_ReadDirName(struct dptr_struct *dptr, long *poffset, SMB_STRUCT_STAT *pst)
556 {
557 /* Normal search for the next file. */
558 const char *name;
559 while ((name = ReadDirName(dptr->dir_hnd, poffset)) != NULL) {
560 if (is_visible_file(dptr->conn, dptr->path, name, pst, True)) {
561 return name;
562 }
563 }
564 return NULL;
565 }
566
567 /****************************************************************************
568 Return the next visible file name, skipping veto'd and invisible files.
569 ****************************************************************************/
570
571 const char *dptr_ReadDirName(TALLOC_CTX *ctx,
572 struct dptr_struct *dptr,
573 long *poffset,
574 SMB_STRUCT_STAT *pst)
575 {
576 SET_STAT_INVALID(*pst);
577
578 if (dptr->has_wild) {
579 return dptr_normal_ReadDirName(dptr, poffset, pst);
580 }
581
582 /* If poffset is -1 then we know we returned this name before and we have
583 no wildcards. We're at the end of the directory. */
584 if (*poffset == END_OF_DIRECTORY_OFFSET) {
585 return NULL;
586 }
587
588 if (!dptr->did_stat) {
589 char *pathreal = NULL;
590
591 /* We know the stored wcard contains no wildcard characters. See if we can match
592 with a stat call. If we can't, then set did_stat to true to
593 ensure we only do this once and keep searching. */
594
595 dptr->did_stat = True;
596
597 /* First check if it should be visible. */
598 if (!is_visible_file(dptr->conn, dptr->path, dptr->wcard, pst, True)) {
599 /* This only returns False if the file was found, but
600 is explicitly not visible. Set us to end of directory,
601 but return NULL as we know we can't ever find it. */
602 dptr->dir_hnd->offset = *poffset = END_OF_DIRECTORY_OFFSET;
603 return NULL;
604 }
605
606 if (VALID_STAT(*pst)) {
607 /* We need to set the underlying dir_hnd offset to -1 also as
608 this function is usually called with the output from TellDir. */
609 dptr->dir_hnd->offset = *poffset = END_OF_DIRECTORY_OFFSET;
610 return dptr->wcard;
611 }
612
613 pathreal = talloc_asprintf(ctx,
614 "%s/%s",
615 dptr->path,
616 dptr->wcard);
617 if (!pathreal) {
618 return NULL;
619 }
620
621 if (SMB_VFS_STAT(dptr->conn,pathreal,pst) == 0) {
622 /* We need to set the underlying dir_hnd offset to -1 also as
623 this function is usually called with the output from TellDir. */
624 dptr->dir_hnd->offset = *poffset = END_OF_DIRECTORY_OFFSET;
625 TALLOC_FREE(pathreal);
626 return dptr->wcard;
627 } else {
628 /* If we get any other error than ENOENT or ENOTDIR
629 then the file exists we just can't stat it. */
630 if (errno != ENOENT && errno != ENOTDIR) {
631 /* We need to set the underlying dir_hdn offset to -1 also as
632 this function is usually called with the output from TellDir. */
633 dptr->dir_hnd->offset = *poffset = END_OF_DIRECTORY_OFFSET;
634 TALLOC_FREE(pathreal);
635 return dptr->wcard;
636 }
637 }
638
639 TALLOC_FREE(pathreal);
640
641 /* Stat failed. We know this is authoratiative if we are
642 * providing case sensitive semantics or the underlying
643 * filesystem is case sensitive.
644 */
645
646 if (dptr->conn->case_sensitive ||
647 !(dptr->conn->fs_capabilities & FILE_CASE_SENSITIVE_SEARCH)) {
648 /* We need to set the underlying dir_hnd offset to -1 also as
649 this function is usually called with the output from TellDir. */
650 dptr->dir_hnd->offset = *poffset = END_OF_DIRECTORY_OFFSET;
651 return NULL;
652 }
653 }
654 return dptr_normal_ReadDirName(dptr, poffset, pst);
655 }
656
657 /****************************************************************************
658 Search for a file by name, skipping veto'ed and not visible files.
659 ****************************************************************************/
660
661 bool dptr_SearchDir(struct dptr_struct *dptr, const char *name, long *poffset, SMB_STRUCT_STAT *pst)
662 {
663 SET_STAT_INVALID(*pst);
664
665 if (!dptr->has_wild && (dptr->dir_hnd->offset == END_OF_DIRECTORY_OFFSET)) {
666 /* This is a singleton directory and we're already at the end. */
667 *poffset = END_OF_DIRECTORY_OFFSET;
668 return False;
669 }
670
671 return SearchDir(dptr->dir_hnd, name, poffset);
672 }
673
674 /****************************************************************************
675 Add the name we're returning into the underlying cache.
676 ****************************************************************************/
677
678 void dptr_DirCacheAdd(struct dptr_struct *dptr, const char *name, long offset)
679 {
680 DirCacheAdd(dptr->dir_hnd, name, offset);
681 }
682
683 /****************************************************************************
684 Fill the 5 byte server reserved dptr field.
685 ****************************************************************************/
686
687 bool dptr_fill(char *buf1,unsigned int key)
688 {
689 unsigned char *buf = (unsigned char *)buf1;
690 struct dptr_struct *dptr = dptr_get(key, False);
691 uint32 offset;
692 if (!dptr) {
693 DEBUG(1,("filling null dirptr %d\n",key));
694 return(False);
695 }
696 offset = (uint32)TellDir(dptr->dir_hnd);
697 DEBUG(6,("fill on key %u dirptr 0x%lx now at %d\n",key,
698 (long)dptr->dir_hnd,(int)offset));
699 buf[0] = key;
700 SIVAL(buf,1,offset);
701 return(True);
702 }
703
704 /****************************************************************************
705 Fetch the dir ptr and seek it given the 5 byte server field.
706 ****************************************************************************/
707
708 struct dptr_struct *dptr_fetch(char *buf,int *num)
709 {
710 unsigned int key = *(unsigned char *)buf;
711 struct dptr_struct *dptr = dptr_get(key, False);
712 uint32 offset;
713 long seekoff;
714
715 if (!dptr) {
716 DEBUG(3,("fetched null dirptr %d\n",key));
717 return(NULL);
718 }
719 *num = key;
720 offset = IVAL(buf,1);
721 if (offset == (uint32)-1) {
722 seekoff = END_OF_DIRECTORY_OFFSET;
723 } else {
724 seekoff = (long)offset;
725 }
726 SeekDir(dptr->dir_hnd,seekoff);
727 DEBUG(3,("fetching dirptr %d for path %s at offset %d\n",
728 key,dptr_path(key),(int)seekoff));
729 return(dptr);
730 }
731
732 /****************************************************************************
733 Fetch the dir ptr.
734 ****************************************************************************/
735
736 struct dptr_struct *dptr_fetch_lanman2(int dptr_num)
737 {
738 struct dptr_struct *dptr = dptr_get(dptr_num, False);
739
740 if (!dptr) {
741 DEBUG(3,("fetched null dirptr %d\n",dptr_num));
742 return(NULL);
743 }
744 DEBUG(3,("fetching dirptr %d for path %s\n",dptr_num,dptr_path(dptr_num)));
745 return(dptr);
746 }
747
748 /****************************************************************************
749 Check that a file matches a particular file type.
750 ****************************************************************************/
751
752 bool dir_check_ftype(connection_struct *conn, uint32 mode, uint32 dirtype)
753 {
754 uint32 mask;
755
756 /* Check the "may have" search bits. */
757 if (((mode & ~dirtype) & (aHIDDEN | aSYSTEM | aDIR)) != 0)
758 return False;
759
760 /* Check the "must have" bits, which are the may have bits shifted eight */
761 /* If must have bit is set, the file/dir can not be returned in search unless the matching
762 file attribute is set */
763 mask = ((dirtype >> 8) & (aDIR|aARCH|aRONLY|aHIDDEN|aSYSTEM)); /* & 0x37 */
764 if(mask) {
765 if((mask & (mode & (aDIR|aARCH|aRONLY|aHIDDEN|aSYSTEM))) == mask) /* check if matching attribute present */
766 return True;
767 else
768 return False;
769 }
770
771 return True;
772 }
773
774 static bool mangle_mask_match(connection_struct *conn,
775 const char *filename,
776 const char *mask)
777 {
778 char mname[13];
779
780 if (!name_to_8_3(filename,mname,False,conn->params)) {
781 return False;
782 }
783 return mask_match_search(mname,mask,False);
784 }
785
786 /****************************************************************************
787 Get an 8.3 directory entry.
788 ****************************************************************************/
789
790 bool get_dir_entry(TALLOC_CTX *ctx,
791 connection_struct *conn,
792 const char *mask,
793 uint32 dirtype,
794 char **pp_fname_out,
795 SMB_OFF_T *size,
796 uint32 *mode,
797 time_t *date,
798 bool check_descend,
799 bool ask_sharemode)
800 {
801 const char *dname = NULL;
802 bool found = False;
803 SMB_STRUCT_STAT sbuf;
804 char *pathreal = NULL;
805 const char *filename = NULL;
806 bool needslash;
807
808 *pp_fname_out = NULL;
809
810 needslash = ( conn->dirpath[strlen(conn->dirpath) -1] != '/');
811
812 if (!conn->dirptr) {
813 return(False);
814 }
815
816 while (!found) {
817 long curoff = dptr_TellDir(conn->dirptr);
818 dname = dptr_ReadDirName(ctx, conn->dirptr, &curoff, &sbuf);
819
820 DEBUG(6,("readdir on dirptr 0x%lx now at offset %ld\n",
821 (long)conn->dirptr,TellDir(conn->dirptr->dir_hnd)));
822
823 if (dname == NULL) {
824 return(False);
825 }
826
827 filename = dname;
828
829 /* notice the special *.* handling. This appears to be the only difference
830 between the wildcard handling in this routine and in the trans2 routines.
831 see masktest for a demo
832 */
833 if ((strcmp(mask,"*.*") == 0) ||
834 mask_match_search(filename,mask,False) ||
835 mangle_mask_match(conn,filename,mask)) {
836 char mname[13];
837
838 if (!mangle_is_8_3(filename, False, conn->params)) {
839 if (!name_to_8_3(filename,mname,False,
840 conn->params)) {
841 continue;
842 }
843 filename = mname;
844 }
845
846 if (needslash) {
847 pathreal = talloc_asprintf(ctx,
848 "%s/%s",
849 conn->dirpath,
850 dname);
851 } else {
852 pathreal = talloc_asprintf(ctx,
853 "%s%s",
854 conn->dirpath,
855 dname);
856 }
857 if (!pathreal) {
858 return False;
859 }
860
861 if (!VALID_STAT(sbuf) && (SMB_VFS_STAT(conn, pathreal, &sbuf)) != 0) {
862 DEBUG(5,("Couldn't stat 1 [%s]. Error = %s\n",
863 pathreal, strerror(errno) ));
864 TALLOC_FREE(pathreal);
865 continue;
866 }
867
868 *mode = dos_mode(conn,pathreal,&sbuf);
869
870 if (!dir_check_ftype(conn,*mode,dirtype)) {
871 DEBUG(5,("[%s] attribs 0x%x didn't match 0x%x\n",filename,(unsigned int)*mode,(unsigned int)dirtype));
872 TALLOC_FREE(pathreal);
873 continue;
874 }
875
876 *size = sbuf.st_size;
877 *date = sbuf.st_mtime;
878
879 if (ask_sharemode) {
880 struct timespec write_time_ts;
881 struct file_id fileid;
882
883 fileid = vfs_file_id_from_sbuf(conn, &sbuf);
884 get_file_infos(fileid, NULL, &write_time_ts);
885 if (!null_timespec(write_time_ts)) {
886 *date = convert_timespec_to_time_t(write_time_ts);
887 }
888 }
889
890 DEBUG(3,("get_dir_entry mask=[%s] found %s "
891 "fname=%s (%s)\n",
892 mask,
893 pathreal,
894 dname,
895 filename));
896
897 found = True;
898
899 *pp_fname_out = talloc_strdup(ctx, filename);
900 if (!*pp_fname_out) {
901 return False;
902 }
903
904 DirCacheAdd(conn->dirptr->dir_hnd, dname, curoff);
905 TALLOC_FREE(pathreal);
906 }
907 }
908
909 return(found);
910 }
911
912 /*******************************************************************
913 Check to see if a user can read a file. This is only approximate,
914 it is used as part of the "hide unreadable" option. Don't
915 use it for anything security sensitive.
916 ********************************************************************/
917
918 static bool user_can_read_file(connection_struct *conn, char *name)
919 {
920 /*
921 * If user is a member of the Admin group
922 * we never hide files from them.
923 */
924
925 if (conn->admin_user) {
926 return True;
927 }
928
929 return can_access_file_acl(conn, name, FILE_READ_DATA);
930 }
931
932 /*******************************************************************
933 Check to see if a user can write a file (and only files, we do not
934 check dirs on this one). This is only approximate,
935 it is used as part of the "hide unwriteable" option. Don't
936 use it for anything security sensitive.
937 ********************************************************************/
938
939 static bool user_can_write_file(connection_struct *conn, char *name, SMB_STRUCT_STAT *pst)
940 {
941 /*
942 * If user is a member of the Admin group
943 * we never hide files from them.
944 */
945
946 if (conn->admin_user) {
947 return True;
948 }
949
950 SMB_ASSERT(VALID_STAT(*pst));
951
952 /* Pseudo-open the file */
953
954 if(S_ISDIR(pst->st_mode)) {
955 return True;
956 }
957
958 return can_write_to_file(conn, name, pst);
959 }
960
961 /*******************************************************************
962 Is a file a "special" type ?
963 ********************************************************************/
964
965 static bool file_is_special(connection_struct *conn, char *name, SMB_STRUCT_STAT *pst)
966 {
967 /*
968 * If user is a member of the Admin group
969 * we never hide files from them.
970 */
971
972 if (conn->admin_user)
973 return False;
974
975 SMB_ASSERT(VALID_STAT(*pst));
976
977 if (S_ISREG(pst->st_mode) || S_ISDIR(pst->st_mode) || S_ISLNK(pst->st_mode))
978 return False;
979
980 return True;
981 }
982
983 /*******************************************************************
984 Should the file be seen by the client ? NOTE: A successful return
985 is no guarantee of the file's existence ... you also have to check
986 whether pst is valid.
987 ********************************************************************/
988
989 bool is_visible_file(connection_struct *conn, const char *dir_path, const char *name, SMB_STRUCT_STAT *pst, bool use_veto)
990 {
991 bool hide_unreadable = lp_hideunreadable(SNUM(conn));
992 bool hide_unwriteable = lp_hideunwriteable_files(SNUM(conn));
993 bool hide_special = lp_hide_special_files(SNUM(conn));
994
995 SET_STAT_INVALID(*pst);
996
997 if ((strcmp(".",name) == 0) || (strcmp("..",name) == 0)) {
998 return True; /* . and .. are always visible. */
999 }
1000
1001 /* If it's a vetoed file, pretend it doesn't even exist */
1002 if (use_veto && IS_VETO_PATH(conn, name)) {
1003 DEBUG(10,("is_visible_file: file %s is vetoed.\n", name ));
1004 return False;
1005 }
1006
1007 if (hide_unreadable || hide_unwriteable || hide_special) {
1008 char *entry = NULL;
1009
1010 if (asprintf(&entry, "%s/%s", dir_path, name) == -1) {
1011 return False;
1012 }
1013
1014 /* If it's a dfs symlink, ignore _hide xxxx_ options */
1015 if (lp_host_msdfs() &&
1016 lp_msdfs_root(SNUM(conn)) &&
1017 is_msdfs_link(conn, entry, NULL)) {
1018 SAFE_FREE(entry);
1019 return True;
1020 }
1021
1022 /* If the file name does not exist, there's no point checking
1023 * the configuration options. We succeed, on the basis that the
1024 * checks *might* have passed if the file was present.
1025 */
1026 if (SMB_VFS_STAT(conn, entry, pst) != 0) {
1027 SAFE_FREE(entry);
1028 return True;
1029 }
1030
1031 /* Honour _hide unreadable_ option */
1032 if (hide_unreadable && !user_can_read_file(conn, entry)) {
1033 DEBUG(10,("is_visible_file: file %s is unreadable.\n", entry ));
1034 SAFE_FREE(entry);
1035 return False;
1036 }
1037 /* Honour _hide unwriteable_ option */
1038 if (hide_unwriteable && !user_can_write_file(conn, entry, pst)) {
1039 DEBUG(10,("is_visible_file: file %s is unwritable.\n", entry ));
1040 SAFE_FREE(entry);
1041 return False;
1042 }
1043 /* Honour _hide_special_ option */
1044 if (hide_special && file_is_special(conn, entry, pst)) {
1045 DEBUG(10,("is_visible_file: file %s is special.\n", entry ));
1046 SAFE_FREE(entry);
1047 return False;
1048 }
1049 SAFE_FREE(entry);
1050 }
1051 return True;
1052 }
1053
1054 static int smb_Dir_destructor(struct smb_Dir *dirp)
1055 {
1056 if (dirp->dir) {
1057 SMB_VFS_CLOSEDIR(dirp->conn,dirp->dir);
1058 }
1059 dirhandles_open--;
1060 return 0;
1061 }
1062
1063 /*******************************************************************
1064 Open a directory.
1065 ********************************************************************/
1066
1067 struct smb_Dir *OpenDir(TALLOC_CTX *mem_ctx, connection_struct *conn,
1068 const char *name, const char *mask, uint32 attr)
1069 {
1070 struct smb_Dir *dirp = TALLOC_ZERO_P(mem_ctx, struct smb_Dir);
1071
1072 if (!dirp) {
1073 return NULL;
1074 }
1075
1076 dirp->conn = conn;
1077 dirp->name_cache_size = lp_directory_name_cache_size(SNUM(conn));
1078
1079 dirp->dir_path = talloc_strdup(dirp, name);
1080 if (!dirp->dir_path) {
1081 errno = ENOMEM;
1082 goto fail;
1083 }
1084
1085 dirhandles_open++;
1086 talloc_set_destructor(dirp, smb_Dir_destructor);
1087
1088 dirp->dir = SMB_VFS_OPENDIR(conn, dirp->dir_path, mask, attr);
1089 if (!dirp->dir) {
1090 DEBUG(5,("OpenDir: Can't open %s. %s\n", dirp->dir_path,
1091 strerror(errno) ));
1092 goto fail;
1093 }
1094
1095 return dirp;
1096
1097 fail:
1098 TALLOC_FREE(dirp);
1099 return NULL;
1100 }
1101
1102 /*******************************************************************
1103 Read from a directory. Also return current offset.
1104 Don't check for veto or invisible files.
1105 ********************************************************************/
1106
1107 const char *ReadDirName(struct smb_Dir *dirp, long *poffset)
1108 {
1109 const char *n;
1110 connection_struct *conn = dirp->conn;
1111
1112 /* Cheat to allow . and .. to be the first entries returned. */
1113 if (((*poffset == START_OF_DIRECTORY_OFFSET) || (*poffset == DOT_DOT_DIRECTORY_OFFSET)) && (dirp->file_number < 2)) {
1114 if (dirp->file_number == 0) {
1115 n = ".";
1116 *poffset = dirp->offset = START_OF_DIRECTORY_OFFSET;
1117 } else {
1118 *poffset = dirp->offset = DOT_DOT_DIRECTORY_OFFSET;
1119 n = "..";
1120 }
1121 dirp->file_number++;
1122 return n;
1123 } else if (*poffset == END_OF_DIRECTORY_OFFSET) {
1124 *poffset = dirp->offset = END_OF_DIRECTORY_OFFSET;
1125 return NULL;
1126 } else {
1127 /* A real offset, seek to it. */
1128 SeekDir(dirp, *poffset);
1129 }
1130
1131 while ((n = vfs_readdirname(conn, dirp->dir))) {
1132 /* Ignore . and .. - we've already returned them. */
1133 if (*n == '.') {
1134 if ((n[1] == '\0') || (n[1] == '.' && n[2] == '\0')) {
1135 continue;
1136 }
1137 }
1138 *poffset = dirp->offset = SMB_VFS_TELLDIR(conn, dirp->dir);
1139 dirp->file_number++;
1140 return n;
1141 }
1142 *poffset = dirp->offset = END_OF_DIRECTORY_OFFSET;
1143 return NULL;
1144 }
1145
1146 /*******************************************************************
1147 Rewind to the start.
1148 ********************************************************************/
1149
1150 void RewindDir(struct smb_Dir *dirp, long *poffset)
1151 {
1152 SMB_VFS_REWINDDIR(dirp->conn, dirp->dir);
1153 dirp->file_number = 0;
1154 dirp->offset = START_OF_DIRECTORY_OFFSET;
1155 *poffset = START_OF_DIRECTORY_OFFSET;
1156 }
1157
1158 /*******************************************************************
1159 Seek a dir.
1160 ********************************************************************/
1161
1162 void SeekDir(struct smb_Dir *dirp, long offset)
1163 {
1164 if (offset != dirp->offset) {
1165 if (offset == START_OF_DIRECTORY_OFFSET) {
1166 RewindDir(dirp, &offset);
1167 /*
1168 * Ok we should really set the file number here
1169 * to 1 to enable ".." to be returned next. Trouble
1170 * is I'm worried about callers using SeekDir(dirp,0)
1171 * as equivalent to RewindDir(). So leave this alone
1172 * for now.
1173 */
1174 } else if (offset == DOT_DOT_DIRECTORY_OFFSET) {
1175 RewindDir(dirp, &offset);
1176 /*
1177 * Set the file number to 2 - we want to get the first
1178 * real file entry (the one we return after "..")
1179 * on the next ReadDir.
1180 */
1181 dirp->file_number = 2;
1182 } else if (offset == END_OF_DIRECTORY_OFFSET) {
1183 ; /* Don't seek in this case. */
1184 } else {
1185 SMB_VFS_SEEKDIR(dirp->conn, dirp->dir, offset);
1186 }
1187 dirp->offset = offset;
1188 }
1189 }
1190
1191 /*******************************************************************
1192 Tell a dir position.
1193 ********************************************************************/
1194
1195 long TellDir(struct smb_Dir *dirp)
1196 {
1197 return(dirp->offset);
1198 }
1199
1200 /*******************************************************************
1201 Add an entry into the dcache.
1202 ********************************************************************/
1203
1204 void DirCacheAdd(struct smb_Dir *dirp, const char *name, long offset)
1205 {
1206 struct name_cache_entry *e;
1207
1208 if (dirp->name_cache_size == 0) {
1209 return;
1210 }
1211
1212 if (dirp->name_cache == NULL) {
1213 dirp->name_cache = TALLOC_ZERO_ARRAY(
1214 dirp, struct name_cache_entry, dirp->name_cache_size);
1215
1216 if (dirp->name_cache == NULL) {
1217 return;
1218 }
1219 }
1220
1221 dirp->name_cache_index = (dirp->name_cache_index+1) %
1222 dirp->name_cache_size;
1223 e = &dirp->name_cache[dirp->name_cache_index];
1224 TALLOC_FREE(e->name);
1225 e->name = talloc_strdup(dirp, name);
1226 e->offset = offset;
1227 }
1228
1229 /*******************************************************************
1230 Find an entry by name. Leave us at the offset after it.
1231 Don't check for veto or invisible files.
1232 ********************************************************************/
1233
1234 bool SearchDir(struct smb_Dir *dirp, const char *name, long *poffset)
1235 {
1236 int i;
1237 const char *entry;
1238 connection_struct *conn = dirp->conn;
1239
1240 /* Search back in the name cache. */
1241 if (dirp->name_cache_size && dirp->name_cache) {
1242 for (i = dirp->name_cache_index; i >= 0; i--) {
1243 struct name_cache_entry *e = &dirp->name_cache[i];
1244 if (e->name && (conn->case_sensitive ? (strcmp(e->name, name) == 0) : strequal(e->name, name))) {
1245 *poffset = e->offset;
1246 SeekDir(dirp, e->offset);
1247 return True;
1248 }
1249 }
1250 for (i = dirp->name_cache_size - 1; i > dirp->name_cache_index; i--) {
1251 struct name_cache_entry *e = &dirp->name_cache[i];
1252 if (e->name && (conn->case_sensitive ? (strcmp(e->name, name) == 0) : strequal(e->name, name))) {
1253 *poffset = e->offset;
1254 SeekDir(dirp, e->offset);
1255 return True;
1256 }
1257 }
1258 }
1259
1260 /* Not found in the name cache. Rewind directory and start from scratch. */
1261 SMB_VFS_REWINDDIR(conn, dirp->dir);
1262 dirp->file_number = 0;
1263 *poffset = START_OF_DIRECTORY_OFFSET;
1264 while ((entry = ReadDirName(dirp, poffset))) {
1265 if (conn->case_sensitive ? (strcmp(entry, name) == 0) : strequal(entry, name)) {
1266 return True;
1267 }
1268 }
1269 return False;
1270 }
1271
1272 /*****************************************************************
1273 Is this directory empty ?
1274 *****************************************************************/
1275
1276 NTSTATUS can_delete_directory(struct connection_struct *conn,
1277 const char *dirname)
1278 {
1279 NTSTATUS status = NT_STATUS_OK;
1280 long dirpos = 0;
1281 const char *dname;
1282 struct smb_Dir *dir_hnd = OpenDir(talloc_tos(), conn, dirname,
1283 NULL, 0);
1284
1285 if (!dir_hnd) {
1286 return map_nt_error_from_unix(errno);
1287 }
1288
1289 while ((dname = ReadDirName(dir_hnd,&dirpos))) {
1290 SMB_STRUCT_STAT st;
1291
1292 /* Quick check for "." and ".." */
1293 if (dname[0] == '.') {
1294 if (!dname[1] || (dname[1] == '.' && !dname[2])) {
1295 continue;
1296 }
1297 }
1298
1299 if (!is_visible_file(conn, dirname, dname, &st, True)) {
1300 continue;
1301 }
1302
1303 DEBUG(10,("can_delete_directory: got name %s - can't delete\n", dname ));
1304 status = NT_STATUS_DIRECTORY_NOT_EMPTY;
1305 break;
1306 }
1307 TALLOC_FREE(dir_hnd);
1308
1309 return status;
1310 }