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