?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
clean up lib64 linking paths the same way as lib
[Samba/gebeck_regimport.git] / source3 / smbd / dir.c
blobb4a8f942c248d29d4cc68b5f0c5ed10ab0a0177c
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,
556 long *poffset, SMB_STRUCT_STAT *pst)
557 {
558 /* Normal search for the next file. */
559 const char *name;
560 while ((name = ReadDirName(dptr->dir_hnd, poffset, pst)) != NULL) {
561 if (is_visible_file(dptr->conn, dptr->path, name, pst, True)) {
562 return name;
563 }
564 }
565 return NULL;
566 }
567
568 /****************************************************************************
569 Return the next visible file name, skipping veto'd and invisible files.
570 ****************************************************************************/
571
572 const char *dptr_ReadDirName(TALLOC_CTX *ctx,
573 struct dptr_struct *dptr,
574 long *poffset,
575 SMB_STRUCT_STAT *pst)
576 {
577 char *name = NULL;
578 char *pathreal = NULL;
579 SET_STAT_INVALID(*pst);
580
581 if (dptr->has_wild || dptr->did_stat) {
582 return dptr_normal_ReadDirName(dptr, poffset, pst);
583 }
584
585 /* If poffset is -1 then we know we returned this name before and we
586 * have no wildcards. We're at the end of the directory. */
587 if (*poffset == END_OF_DIRECTORY_OFFSET) {
588 return NULL;
589 }
590
591 /* We know the stored wcard contains no wildcard characters.
592 * See if we can match with a stat call. If we can't, then set
593 * did_stat to true to ensure we only do this once and keep
594 * searching. */
595
596 dptr->did_stat = true;
597
598 /* First check if it should be visible. */
599 if (!is_visible_file(dptr->conn, dptr->path, dptr->wcard,
600 pst, true))
601 {
602 /* This only returns false if the file was found, but
603 is explicitly not visible. Set us to end of
604 directory, but return NULL as we know we can't ever
605 find it. */
606 goto ret;
607 }
608
609 if (VALID_STAT(*pst)) {
610 name = dptr->wcard;
611 goto ret;
612 }
613
614 pathreal = talloc_asprintf(ctx,
615 "%s/%s",
616 dptr->path,
617 dptr->wcard);
618 if (!pathreal)
619 return NULL;
620
621 if (SMB_VFS_STAT(dptr->conn, pathreal, pst) == 0) {
622 name = dptr->wcard;
623 goto clean;
624 } else {
625 /* If we get any other error than ENOENT or ENOTDIR
626 then the file exists we just can't stat it. */
627 if (errno != ENOENT && errno != ENOTDIR) {
628 name = dptr->wcard;
629 goto clean;
630 }
631 }
632
633 /* Stat failed. We know this is authoratiative if we are
634 * providing case sensitive semantics or the underlying
635 * filesystem is case sensitive.
636 */
637 if (dptr->conn->case_sensitive ||
638 !(dptr->conn->fs_capabilities & FILE_CASE_SENSITIVE_SEARCH))
639 {
640 goto clean;
641 }
642
643 TALLOC_FREE(pathreal);
644
645 return dptr_normal_ReadDirName(dptr, poffset, pst);
646
647 clean:
648 TALLOC_FREE(pathreal);
649 ret:
650 /* We need to set the underlying dir_hnd offset to -1
651 * also as this function is usually called with the
652 * output from TellDir. */
653 dptr->dir_hnd->offset = *poffset = END_OF_DIRECTORY_OFFSET;
654 return name;
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 Initialize variables & state data at the beginning of all search SMB requests.
685 ****************************************************************************/
686 void dptr_init_search_op(struct dptr_struct *dptr)
687 {
688 SMB_VFS_INIT_SEARCH_OP(dptr->conn, dptr->dir_hnd->dir);
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)
927 {
928 /*
929 * If user is a member of the Admin group
930 * we never hide files from them.
931 */
932
933 if (conn->admin_user) {
934 return True;
935 }
936
937 return can_access_file_acl(conn, name, FILE_READ_DATA);
938 }
939
940 /*******************************************************************
941 Check to see if a user can write a file (and only files, we do not
942 check dirs on this one). This is only approximate,
943 it is used as part of the "hide unwriteable" option. Don't
944 use it for anything security sensitive.
945 ********************************************************************/
946
947 static bool user_can_write_file(connection_struct *conn, char *name, SMB_STRUCT_STAT *pst)
948 {
949 /*
950 * If user is a member of the Admin group
951 * we never hide files from them.
952 */
953
954 if (conn->admin_user) {
955 return True;
956 }
957
958 SMB_ASSERT(VALID_STAT(*pst));
959
960 /* Pseudo-open the file */
961
962 if(S_ISDIR(pst->st_mode)) {
963 return True;
964 }
965
966 return can_write_to_file(conn, name, pst);
967 }
968
969 /*******************************************************************
970 Is a file a "special" type ?
971 ********************************************************************/
972
973 static bool file_is_special(connection_struct *conn, char *name, SMB_STRUCT_STAT *pst)
974 {
975 /*
976 * If user is a member of the Admin group
977 * we never hide files from them.
978 */
979
980 if (conn->admin_user)
981 return False;
982
983 SMB_ASSERT(VALID_STAT(*pst));
984
985 if (S_ISREG(pst->st_mode) || S_ISDIR(pst->st_mode) || S_ISLNK(pst->st_mode))
986 return False;
987
988 return True;
989 }
990
991 /*******************************************************************
992 Should the file be seen by the client?
993 NOTE: A successful return is no guarantee of the file's existence.
994 ********************************************************************/
995
996 bool is_visible_file(connection_struct *conn, const char *dir_path,
997 const char *name, SMB_STRUCT_STAT *pst, bool use_veto)
998 {
999 bool hide_unreadable = lp_hideunreadable(SNUM(conn));
1000 bool hide_unwriteable = lp_hideunwriteable_files(SNUM(conn));
1001 bool hide_special = lp_hide_special_files(SNUM(conn));
1002
1003 if ((strcmp(".",name) == 0) || (strcmp("..",name) == 0)) {
1004 return True; /* . and .. are always visible. */
1005 }
1006
1007 /* If it's a vetoed file, pretend it doesn't even exist */
1008 if (use_veto && IS_VETO_PATH(conn, name)) {
1009 DEBUG(10,("is_visible_file: file %s is vetoed.\n", name ));
1010 return False;
1011 }
1012
1013 if (hide_unreadable || hide_unwriteable || hide_special) {
1014 char *entry = NULL;
1015
1016 if (asprintf(&entry, "%s/%s", dir_path, name) == -1) {
1017 return False;
1018 }
1019
1020 /* If it's a dfs symlink, ignore _hide xxxx_ options */
1021 if (lp_host_msdfs() &&
1022 lp_msdfs_root(SNUM(conn)) &&
1023 is_msdfs_link(conn, entry, NULL)) {
1024 SAFE_FREE(entry);
1025 return True;
1026 }
1027
1028 /* If the file name does not exist, there's no point checking
1029 * the configuration options. We succeed, on the basis that the
1030 * checks *might* have passed if the file was present.
1031 */
1032 if (!VALID_STAT(*pst) && (SMB_VFS_STAT(conn, entry, pst) != 0))
1033 {
1034 SAFE_FREE(entry);
1035 return True;
1036 }
1037
1038 /* Honour _hide unreadable_ option */
1039 if (hide_unreadable && !user_can_read_file(conn, entry)) {
1040 DEBUG(10,("is_visible_file: file %s is unreadable.\n",
1041 entry ));
1042 SAFE_FREE(entry);
1043 return False;
1044 }
1045 /* Honour _hide unwriteable_ option */
1046 if (hide_unwriteable && !user_can_write_file(conn, entry, pst)) {
1047 DEBUG(10,("is_visible_file: file %s is unwritable.\n",
1048 entry ));
1049 SAFE_FREE(entry);
1050 return False;
1051 }
1052 /* Honour _hide_special_ option */
1053 if (hide_special && file_is_special(conn, entry, pst)) {
1054 DEBUG(10,("is_visible_file: file %s is special.\n",
1055 entry ));
1056 SAFE_FREE(entry);
1057 return False;
1058 }
1059 SAFE_FREE(entry);
1060 }
1061 return True;
1062 }
1063
1064 static int smb_Dir_destructor(struct smb_Dir *dirp)
1065 {
1066 if (dirp->dir) {
1067 SMB_VFS_CLOSEDIR(dirp->conn,dirp->dir);
1068 }
1069 dirhandles_open--;
1070 return 0;
1071 }
1072
1073 /*******************************************************************
1074 Open a directory.
1075 ********************************************************************/
1076
1077 struct smb_Dir *OpenDir(TALLOC_CTX *mem_ctx, connection_struct *conn,
1078 const char *name, const char *mask, uint32 attr)
1079 {
1080 struct smb_Dir *dirp = TALLOC_ZERO_P(mem_ctx, struct smb_Dir);
1081
1082 if (!dirp) {
1083 return NULL;
1084 }
1085
1086 dirp->conn = conn;
1087 dirp->name_cache_size = lp_directory_name_cache_size(SNUM(conn));
1088
1089 dirp->dir_path = talloc_strdup(dirp, name);
1090 if (!dirp->dir_path) {
1091 errno = ENOMEM;
1092 goto fail;
1093 }
1094
1095 dirhandles_open++;
1096 talloc_set_destructor(dirp, smb_Dir_destructor);
1097
1098 dirp->dir = SMB_VFS_OPENDIR(conn, dirp->dir_path, mask, attr);
1099 if (!dirp->dir) {
1100 DEBUG(5,("OpenDir: Can't open %s. %s\n", dirp->dir_path,
1101 strerror(errno) ));
1102 goto fail;
1103 }
1104
1105 return dirp;
1106
1107 fail:
1108 TALLOC_FREE(dirp);
1109 return NULL;
1110 }
1111
1112 /*******************************************************************
1113 Read from a directory.
1114 Return directory entry, current offset, and optional stat information.
1115 Don't check for veto or invisible files.
1116 ********************************************************************/
1117
1118 const char *ReadDirName(struct smb_Dir *dirp, long *poffset,
1119 SMB_STRUCT_STAT *sbuf)
1120 {
1121 const char *n;
1122 connection_struct *conn = dirp->conn;
1123
1124 /* Cheat to allow . and .. to be the first entries returned. */
1125 if (((*poffset == START_OF_DIRECTORY_OFFSET) ||
1126 (*poffset == DOT_DOT_DIRECTORY_OFFSET)) && (dirp->file_number < 2))
1127 {
1128 if (dirp->file_number == 0) {
1129 n = ".";
1130 *poffset = dirp->offset = START_OF_DIRECTORY_OFFSET;
1131 } else {
1132 *poffset = dirp->offset = DOT_DOT_DIRECTORY_OFFSET;
1133 n = "..";
1134 }
1135 dirp->file_number++;
1136 return n;
1137 } else if (*poffset == END_OF_DIRECTORY_OFFSET) {
1138 *poffset = dirp->offset = END_OF_DIRECTORY_OFFSET;
1139 return NULL;
1140 } else {
1141 /* A real offset, seek to it. */
1142 SeekDir(dirp, *poffset);
1143 }
1144
1145 while ((n = vfs_readdirname(conn, dirp->dir, sbuf))) {
1146 /* Ignore . and .. - we've already returned them. */
1147 if (*n == '.') {
1148 if ((n[1] == '\0') || (n[1] == '.' && n[2] == '\0')) {
1149 continue;
1150 }
1151 }
1152 *poffset = dirp->offset = SMB_VFS_TELLDIR(conn, dirp->dir);
1153 dirp->file_number++;
1154 return n;
1155 }
1156 *poffset = dirp->offset = END_OF_DIRECTORY_OFFSET;
1157 return NULL;
1158 }
1159
1160 /*******************************************************************
1161 Rewind to the start.
1162 ********************************************************************/
1163
1164 void RewindDir(struct smb_Dir *dirp, long *poffset)
1165 {
1166 SMB_VFS_REWINDDIR(dirp->conn, dirp->dir);
1167 dirp->file_number = 0;
1168 dirp->offset = START_OF_DIRECTORY_OFFSET;
1169 *poffset = START_OF_DIRECTORY_OFFSET;
1170 }
1171
1172 /*******************************************************************
1173 Seek a dir.
1174 ********************************************************************/
1175
1176 void SeekDir(struct smb_Dir *dirp, long offset)
1177 {
1178 if (offset != dirp->offset) {
1179 if (offset == START_OF_DIRECTORY_OFFSET) {
1180 RewindDir(dirp, &offset);
1181 /*
1182 * Ok we should really set the file number here
1183 * to 1 to enable ".." to be returned next. Trouble
1184 * is I'm worried about callers using SeekDir(dirp,0)
1185 * as equivalent to RewindDir(). So leave this alone
1186 * for now.
1187 */
1188 } else if (offset == DOT_DOT_DIRECTORY_OFFSET) {
1189 RewindDir(dirp, &offset);
1190 /*
1191 * Set the file number to 2 - we want to get the first
1192 * real file entry (the one we return after "..")
1193 * on the next ReadDir.
1194 */
1195 dirp->file_number = 2;
1196 } else if (offset == END_OF_DIRECTORY_OFFSET) {
1197 ; /* Don't seek in this case. */
1198 } else {
1199 SMB_VFS_SEEKDIR(dirp->conn, dirp->dir, offset);
1200 }
1201 dirp->offset = offset;
1202 }
1203 }
1204
1205 /*******************************************************************
1206 Tell a dir position.
1207 ********************************************************************/
1208
1209 long TellDir(struct smb_Dir *dirp)
1210 {
1211 return(dirp->offset);
1212 }
1213
1214 /*******************************************************************
1215 Add an entry into the dcache.
1216 ********************************************************************/
1217
1218 void DirCacheAdd(struct smb_Dir *dirp, const char *name, long offset)
1219 {
1220 struct name_cache_entry *e;
1221
1222 if (dirp->name_cache_size == 0) {
1223 return;
1224 }
1225
1226 if (dirp->name_cache == NULL) {
1227 dirp->name_cache = TALLOC_ZERO_ARRAY(
1228 dirp, struct name_cache_entry, dirp->name_cache_size);
1229
1230 if (dirp->name_cache == NULL) {
1231 return;
1232 }
1233 }
1234
1235 dirp->name_cache_index = (dirp->name_cache_index+1) %
1236 dirp->name_cache_size;
1237 e = &dirp->name_cache[dirp->name_cache_index];
1238 TALLOC_FREE(e->name);
1239 e->name = talloc_strdup(dirp, name);
1240 e->offset = offset;
1241 }
1242
1243 /*******************************************************************
1244 Find an entry by name. Leave us at the offset after it.
1245 Don't check for veto or invisible files.
1246 ********************************************************************/
1247
1248 bool SearchDir(struct smb_Dir *dirp, const char *name, long *poffset)
1249 {
1250 int i;
1251 const char *entry;
1252 connection_struct *conn = dirp->conn;
1253
1254 /* Search back in the name cache. */
1255 if (dirp->name_cache_size && dirp->name_cache) {
1256 for (i = dirp->name_cache_index; i >= 0; i--) {
1257 struct name_cache_entry *e = &dirp->name_cache[i];
1258 if (e->name && (conn->case_sensitive ? (strcmp(e->name, name) == 0) : strequal(e->name, name))) {
1259 *poffset = e->offset;
1260 SeekDir(dirp, e->offset);
1261 return True;
1262 }
1263 }
1264 for (i = dirp->name_cache_size - 1; i > dirp->name_cache_index; i--) {
1265 struct name_cache_entry *e = &dirp->name_cache[i];
1266 if (e->name && (conn->case_sensitive ? (strcmp(e->name, name) == 0) : strequal(e->name, name))) {
1267 *poffset = e->offset;
1268 SeekDir(dirp, e->offset);
1269 return True;
1270 }
1271 }
1272 }
1273
1274 /* Not found in the name cache. Rewind directory and start from scratch. */
1275 SMB_VFS_REWINDDIR(conn, dirp->dir);
1276 dirp->file_number = 0;
1277 *poffset = START_OF_DIRECTORY_OFFSET;
1278 while ((entry = ReadDirName(dirp, poffset, NULL))) {
1279 if (conn->case_sensitive ? (strcmp(entry, name) == 0) : strequal(entry, name)) {
1280 return True;
1281 }
1282 }
1283 return False;
1284 }
1285
1286 /*****************************************************************
1287 Is this directory empty ?
1288 *****************************************************************/
1289
1290 NTSTATUS can_delete_directory(struct connection_struct *conn,
1291 const char *dirname)
1292 {
1293 NTSTATUS status = NT_STATUS_OK;
1294 long dirpos = 0;
1295 const char *dname;
1296 SMB_STRUCT_STAT st;
1297 struct smb_Dir *dir_hnd = OpenDir(talloc_tos(), conn, dirname,
1298 NULL, 0);
1299
1300 if (!dir_hnd) {
1301 return map_nt_error_from_unix(errno);
1302 }
1303
1304 while ((dname = ReadDirName(dir_hnd, &dirpos, &st))) {
1305 /* Quick check for "." and ".." */
1306 if (dname[0] == '.') {
1307 if (!dname[1] || (dname[1] == '.' && !dname[2])) {
1308 continue;
1309 }
1310 }
1311
1312 if (!is_visible_file(conn, dirname, dname, &st, True)) {
1313 continue;
1314 }
1315
1316 DEBUG(10,("can_delete_directory: got name %s - can't delete\n",
1317 dname ));
1318 status = NT_STATUS_DIRECTORY_NOT_EMPTY;
1319 break;
1320 }
1321 TALLOC_FREE(dir_hnd);
1322
1323 return status;
1324 }
reg import