?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Revert "s3-printing: reload shares after pcap cache fill"
[Samba.git] / source3 / smbd / dir.c
blobfe8e24315535f8fca27da440849a56a3b1b0b76e
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 bool init_dptrs(struct smbd_server_connection *sconn)
119 {
120 if (sconn->smb1.searches.dptr_bmap) {
121 return true;
122 }
123
124 sconn->smb1.searches.dptr_bmap = bitmap_allocate(MAX_DIRECTORY_HANDLES);
125
126 if (sconn->smb1.searches.dptr_bmap == NULL) {
127 return false;
128 }
129
130 return true;
131 }
132
133 /****************************************************************************
134 Idle a dptr - the directory is closed but the control info is kept.
135 ****************************************************************************/
136
137 static void dptr_idle(struct dptr_struct *dptr)
138 {
139 if (dptr->dir_hnd) {
140 DEBUG(4,("Idling dptr dnum %d\n",dptr->dnum));
141 TALLOC_FREE(dptr->dir_hnd);
142 }
143 }
144
145 /****************************************************************************
146 Idle the oldest dptr.
147 ****************************************************************************/
148
149 static void dptr_idleoldest(struct smbd_server_connection *sconn)
150 {
151 struct dptr_struct *dptr;
152
153 /*
154 * Go to the end of the list.
155 */
156 for(dptr = sconn->smb1.searches.dirptrs; dptr && dptr->next; dptr = dptr->next)
157 ;
158
159 if(!dptr) {
160 DEBUG(0,("No dptrs available to idle ?\n"));
161 return;
162 }
163
164 /*
165 * Idle the oldest pointer.
166 */
167
168 for(; dptr; dptr = dptr->prev) {
169 if (dptr->dir_hnd) {
170 dptr_idle(dptr);
171 return;
172 }
173 }
174 }
175
176 /****************************************************************************
177 Get the struct dptr_struct for a dir index.
178 ****************************************************************************/
179
180 static struct dptr_struct *dptr_get(struct smbd_server_connection *sconn,
181 int key, bool forclose)
182 {
183 struct dptr_struct *dptr;
184
185 for(dptr = sconn->smb1.searches.dirptrs; dptr; dptr = dptr->next) {
186 if(dptr->dnum == key) {
187 if (!forclose && !dptr->dir_hnd) {
188 if (sconn->smb1.searches.dirhandles_open >= MAX_OPEN_DIRECTORIES)
189 dptr_idleoldest(sconn);
190 DEBUG(4,("dptr_get: Reopening dptr key %d\n",key));
191 if (!(dptr->dir_hnd = OpenDir(
192 NULL, dptr->conn, dptr->path,
193 dptr->wcard, dptr->attr))) {
194 DEBUG(4,("dptr_get: Failed to open %s (%s)\n",dptr->path,
195 strerror(errno)));
196 return False;
197 }
198 }
199 DLIST_PROMOTE(sconn->smb1.searches.dirptrs,dptr);
200 return dptr;
201 }
202 }
203 return(NULL);
204 }
205
206 /****************************************************************************
207 Get the dir path for a dir index.
208 ****************************************************************************/
209
210 char *dptr_path(struct smbd_server_connection *sconn, int key)
211 {
212 struct dptr_struct *dptr = dptr_get(sconn, key, false);
213 if (dptr)
214 return(dptr->path);
215 return(NULL);
216 }
217
218 /****************************************************************************
219 Get the dir wcard for a dir index.
220 ****************************************************************************/
221
222 char *dptr_wcard(struct smbd_server_connection *sconn, int key)
223 {
224 struct dptr_struct *dptr = dptr_get(sconn, key, false);
225 if (dptr)
226 return(dptr->wcard);
227 return(NULL);
228 }
229
230 /****************************************************************************
231 Get the dir attrib for a dir index.
232 ****************************************************************************/
233
234 uint16 dptr_attr(struct smbd_server_connection *sconn, int key)
235 {
236 struct dptr_struct *dptr = dptr_get(sconn, key, false);
237 if (dptr)
238 return(dptr->attr);
239 return(0);
240 }
241
242 /****************************************************************************
243 Close a dptr (internal func).
244 ****************************************************************************/
245
246 static void dptr_close_internal(struct dptr_struct *dptr)
247 {
248 struct smbd_server_connection *sconn = dptr->conn->sconn;
249
250 DEBUG(4,("closing dptr key %d\n",dptr->dnum));
251
252 if (sconn == NULL) {
253 goto done;
254 }
255
256 DLIST_REMOVE(sconn->smb1.searches.dirptrs, dptr);
257
258 /*
259 * Free the dnum in the bitmap. Remember the dnum value is always
260 * biased by one with respect to the bitmap.
261 */
262
263 if(bitmap_query(sconn->smb1.searches.dptr_bmap, dptr->dnum - 1) != true) {
264 DEBUG(0,("dptr_close_internal : Error - closing dnum = %d and bitmap not set !\n",
265 dptr->dnum ));
266 }
267
268 bitmap_clear(sconn->smb1.searches.dptr_bmap, dptr->dnum - 1);
269
270 done:
271 TALLOC_FREE(dptr->dir_hnd);
272
273 /* Lanman 2 specific code */
274 SAFE_FREE(dptr->wcard);
275 string_set(&dptr->path,"");
276 SAFE_FREE(dptr);
277 }
278
279 /****************************************************************************
280 Close a dptr given a key.
281 ****************************************************************************/
282
283 void dptr_close(struct smbd_server_connection *sconn, int *key)
284 {
285 struct dptr_struct *dptr;
286
287 if(*key == INVALID_DPTR_KEY)
288 return;
289
290 /* OS/2 seems to use -1 to indicate "close all directories" */
291 if (*key == -1) {
292 struct dptr_struct *next;
293 for(dptr = sconn->smb1.searches.dirptrs; dptr; dptr = next) {
294 next = dptr->next;
295 dptr_close_internal(dptr);
296 }
297 *key = INVALID_DPTR_KEY;
298 return;
299 }
300
301 dptr = dptr_get(sconn, *key, true);
302
303 if (!dptr) {
304 DEBUG(0,("Invalid key %d given to dptr_close\n", *key));
305 return;
306 }
307
308 dptr_close_internal(dptr);
309
310 *key = INVALID_DPTR_KEY;
311 }
312
313 /****************************************************************************
314 Close all dptrs for a cnum.
315 ****************************************************************************/
316
317 void dptr_closecnum(connection_struct *conn)
318 {
319 struct dptr_struct *dptr, *next;
320 struct smbd_server_connection *sconn = conn->sconn;
321
322 if (sconn == NULL) {
323 return;
324 }
325
326 for(dptr = sconn->smb1.searches.dirptrs; dptr; dptr = next) {
327 next = dptr->next;
328 if (dptr->conn == conn) {
329 dptr_close_internal(dptr);
330 }
331 }
332 }
333
334 /****************************************************************************
335 Idle all dptrs for a cnum.
336 ****************************************************************************/
337
338 void dptr_idlecnum(connection_struct *conn)
339 {
340 struct dptr_struct *dptr;
341 struct smbd_server_connection *sconn = conn->sconn;
342
343 if (sconn == NULL) {
344 return;
345 }
346
347 for(dptr = sconn->smb1.searches.dirptrs; dptr; dptr = dptr->next) {
348 if (dptr->conn == conn && dptr->dir_hnd) {
349 dptr_idle(dptr);
350 }
351 }
352 }
353
354 /****************************************************************************
355 Close a dptr that matches a given path, only if it matches the spid also.
356 ****************************************************************************/
357
358 void dptr_closepath(struct smbd_server_connection *sconn,
359 char *path,uint16 spid)
360 {
361 struct dptr_struct *dptr, *next;
362 for(dptr = sconn->smb1.searches.dirptrs; dptr; dptr = next) {
363 next = dptr->next;
364 if (spid == dptr->spid && strequal(dptr->path,path))
365 dptr_close_internal(dptr);
366 }
367 }
368
369 /****************************************************************************
370 Try and close the oldest handle not marked for
371 expect close in the hope that the client has
372 finished with that one.
373 ****************************************************************************/
374
375 static void dptr_close_oldest(struct smbd_server_connection *sconn,
376 bool old)
377 {
378 struct dptr_struct *dptr;
379
380 /*
381 * Go to the end of the list.
382 */
383 for(dptr = sconn->smb1.searches.dirptrs; dptr && dptr->next; dptr = dptr->next)
384 ;
385
386 if(!dptr) {
387 DEBUG(0,("No old dptrs available to close oldest ?\n"));
388 return;
389 }
390
391 /*
392 * If 'old' is true, close the oldest oldhandle dnum (ie. 1 < dnum < 256) that
393 * does not have expect_close set. If 'old' is false, close
394 * one of the new dnum handles.
395 */
396
397 for(; dptr; dptr = dptr->prev) {
398 if ((old && (dptr->dnum < 256) && !dptr->expect_close) ||
399 (!old && (dptr->dnum > 255))) {
400 dptr_close_internal(dptr);
401 return;
402 }
403 }
404 }
405
406 /****************************************************************************
407 Create a new dir ptr. If the flag old_handle is true then we must allocate
408 from the bitmap range 0 - 255 as old SMBsearch directory handles are only
409 one byte long. If old_handle is false we allocate from the range
410 256 - MAX_DIRECTORY_HANDLES. We bias the number we return by 1 to ensure
411 a directory handle is never zero.
412 wcard must not be zero.
413 ****************************************************************************/
414
415 NTSTATUS dptr_create(connection_struct *conn, const char *path, bool old_handle, bool expect_close,uint16 spid,
416 const char *wcard, bool wcard_has_wild, uint32 attr, struct dptr_struct **dptr_ret)
417 {
418 struct smbd_server_connection *sconn = conn->sconn;
419 struct dptr_struct *dptr = NULL;
420 struct smb_Dir *dir_hnd;
421 NTSTATUS status;
422
423 DEBUG(5,("dptr_create dir=%s\n", path));
424
425 if (sconn == NULL) {
426 DEBUG(0,("dptr_create: called with fake connection_struct\n"));
427 return NT_STATUS_INTERNAL_ERROR;
428 }
429
430 if (!wcard) {
431 return NT_STATUS_INVALID_PARAMETER;
432 }
433
434 status = check_name(conn,path);
435 if (!NT_STATUS_IS_OK(status)) {
436 return status;
437 }
438
439 dir_hnd = OpenDir(NULL, conn, path, wcard, attr);
440 if (!dir_hnd) {
441 return map_nt_error_from_unix(errno);
442 }
443
444 if (sconn->smb1.searches.dirhandles_open >= MAX_OPEN_DIRECTORIES) {
445 dptr_idleoldest(sconn);
446 }
447
448 dptr = SMB_MALLOC_P(struct dptr_struct);
449 if(!dptr) {
450 DEBUG(0,("malloc fail in dptr_create.\n"));
451 TALLOC_FREE(dir_hnd);
452 return NT_STATUS_NO_MEMORY;
453 }
454
455 ZERO_STRUCTP(dptr);
456
457 if(old_handle) {
458
459 /*
460 * This is an old-style SMBsearch request. Ensure the
461 * value we return will fit in the range 1-255.
462 */
463
464 dptr->dnum = bitmap_find(sconn->smb1.searches.dptr_bmap, 0);
465
466 if(dptr->dnum == -1 || dptr->dnum > 254) {
467
468 /*
469 * Try and close the oldest handle not marked for
470 * expect close in the hope that the client has
471 * finished with that one.
472 */
473
474 dptr_close_oldest(sconn, true);
475
476 /* Now try again... */
477 dptr->dnum = bitmap_find(sconn->smb1.searches.dptr_bmap, 0);
478 if(dptr->dnum == -1 || dptr->dnum > 254) {
479 DEBUG(0,("dptr_create: returned %d: Error - all old dirptrs in use ?\n", dptr->dnum));
480 SAFE_FREE(dptr);
481 TALLOC_FREE(dir_hnd);
482 return NT_STATUS_TOO_MANY_OPENED_FILES;
483 }
484 }
485 } else {
486
487 /*
488 * This is a new-style trans2 request. Allocate from
489 * a range that will return 256 - MAX_DIRECTORY_HANDLES.
490 */
491
492 dptr->dnum = bitmap_find(sconn->smb1.searches.dptr_bmap, 255);
493
494 if(dptr->dnum == -1 || dptr->dnum < 255) {
495
496 /*
497 * Try and close the oldest handle close in the hope that
498 * the client has finished with that one. This will only
499 * happen in the case of the Win98 client bug where it leaks
500 * directory handles.
501 */
502
503 dptr_close_oldest(sconn, false);
504
505 /* Now try again... */
506 dptr->dnum = bitmap_find(sconn->smb1.searches.dptr_bmap, 255);
507
508 if(dptr->dnum == -1 || dptr->dnum < 255) {
509 DEBUG(0,("dptr_create: returned %d: Error - all new dirptrs in use ?\n", dptr->dnum));
510 SAFE_FREE(dptr);
511 TALLOC_FREE(dir_hnd);
512 return NT_STATUS_TOO_MANY_OPENED_FILES;
513 }
514 }
515 }
516
517 bitmap_set(sconn->smb1.searches.dptr_bmap, dptr->dnum);
518
519 dptr->dnum += 1; /* Always bias the dnum by one - no zero dnums allowed. */
520
521 string_set(&dptr->path,path);
522 dptr->conn = conn;
523 dptr->dir_hnd = dir_hnd;
524 dptr->spid = spid;
525 dptr->expect_close = expect_close;
526 dptr->wcard = SMB_STRDUP(wcard);
527 if (!dptr->wcard) {
528 bitmap_clear(sconn->smb1.searches.dptr_bmap, dptr->dnum - 1);
529 SAFE_FREE(dptr);
530 TALLOC_FREE(dir_hnd);
531 return NT_STATUS_NO_MEMORY;
532 }
533 if (lp_posix_pathnames() || (wcard[0] == '.' && wcard[1] == 0)) {
534 dptr->has_wild = True;
535 } else {
536 dptr->has_wild = wcard_has_wild;
537 }
538
539 dptr->attr = attr;
540
541 DLIST_ADD(sconn->smb1.searches.dirptrs, dptr);
542
543 DEBUG(3,("creating new dirptr %d for path %s, expect_close = %d\n",
544 dptr->dnum,path,expect_close));
545
546 *dptr_ret = dptr;
547
548 return NT_STATUS_OK;
549 }
550
551
552 /****************************************************************************
553 Wrapper functions to access the lower level directory handles.
554 ****************************************************************************/
555
556 int dptr_CloseDir(struct dptr_struct *dptr)
557 {
558 dptr_close_internal(dptr);
559 return 0;
560 }
561
562 void dptr_SeekDir(struct dptr_struct *dptr, long offset)
563 {
564 SeekDir(dptr->dir_hnd, offset);
565 }
566
567 long dptr_TellDir(struct dptr_struct *dptr)
568 {
569 return TellDir(dptr->dir_hnd);
570 }
571
572 bool dptr_has_wild(struct dptr_struct *dptr)
573 {
574 return dptr->has_wild;
575 }
576
577 int dptr_dnum(struct dptr_struct *dptr)
578 {
579 return dptr->dnum;
580 }
581
582 /****************************************************************************
583 Return the next visible file name, skipping veto'd and invisible files.
584 ****************************************************************************/
585
586 static const char *dptr_normal_ReadDirName(struct dptr_struct *dptr,
587 long *poffset, SMB_STRUCT_STAT *pst,
588 char **ptalloced)
589 {
590 /* Normal search for the next file. */
591 const char *name;
592 char *talloced = NULL;
593
594 while ((name = ReadDirName(dptr->dir_hnd, poffset, pst, &talloced))
595 != NULL) {
596 if (is_visible_file(dptr->conn, dptr->path, name, pst, True)) {
597 *ptalloced = talloced;
598 return name;
599 }
600 TALLOC_FREE(talloced);
601 }
602 return NULL;
603 }
604
605 /****************************************************************************
606 Return the next visible file name, skipping veto'd and invisible files.
607 ****************************************************************************/
608
609 char *dptr_ReadDirName(TALLOC_CTX *ctx,
610 struct dptr_struct *dptr,
611 long *poffset,
612 SMB_STRUCT_STAT *pst)
613 {
614 struct smb_filename smb_fname_base;
615 char *name = NULL;
616 const char *name_temp = NULL;
617 char *talloced = NULL;
618 char *pathreal = NULL;
619 char *found_name = NULL;
620 int ret;
621
622 SET_STAT_INVALID(*pst);
623
624 if (dptr->has_wild || dptr->did_stat) {
625 name_temp = dptr_normal_ReadDirName(dptr, poffset, pst,
626 &talloced);
627 if (name_temp == NULL) {
628 return NULL;
629 }
630 if (talloced != NULL) {
631 return talloc_move(ctx, &talloced);
632 }
633 return talloc_strdup(ctx, name_temp);
634 }
635
636 /* If poffset is -1 then we know we returned this name before and we
637 * have no wildcards. We're at the end of the directory. */
638 if (*poffset == END_OF_DIRECTORY_OFFSET) {
639 return NULL;
640 }
641
642 /* We know the stored wcard contains no wildcard characters.
643 * See if we can match with a stat call. If we can't, then set
644 * did_stat to true to ensure we only do this once and keep
645 * searching. */
646
647 dptr->did_stat = true;
648
649 /* First check if it should be visible. */
650 if (!is_visible_file(dptr->conn, dptr->path, dptr->wcard,
651 pst, true))
652 {
653 /* This only returns false if the file was found, but
654 is explicitly not visible. Set us to end of
655 directory, but return NULL as we know we can't ever
656 find it. */
657 goto ret;
658 }
659
660 if (VALID_STAT(*pst)) {
661 name = talloc_strdup(ctx, dptr->wcard);
662 goto ret;
663 }
664
665 pathreal = talloc_asprintf(ctx,
666 "%s/%s",
667 dptr->path,
668 dptr->wcard);
669 if (!pathreal)
670 return NULL;
671
672 /* Create an smb_filename with stream_name == NULL. */
673 ZERO_STRUCT(smb_fname_base);
674 smb_fname_base.base_name = pathreal;
675
676 if (SMB_VFS_STAT(dptr->conn, &smb_fname_base) == 0) {
677 *pst = smb_fname_base.st;
678 name = talloc_strdup(ctx, dptr->wcard);
679 goto clean;
680 } else {
681 /* If we get any other error than ENOENT or ENOTDIR
682 then the file exists we just can't stat it. */
683 if (errno != ENOENT && errno != ENOTDIR) {
684 name = talloc_strdup(ctx, dptr->wcard);
685 goto clean;
686 }
687 }
688
689 /* Stat failed. We know this is authoratiative if we are
690 * providing case sensitive semantics or the underlying
691 * filesystem is case sensitive.
692 */
693 if (dptr->conn->case_sensitive ||
694 !(dptr->conn->fs_capabilities & FILE_CASE_SENSITIVE_SEARCH))
695 {
696 goto clean;
697 }
698
699 /*
700 * Try case-insensitive stat if the fs has the ability. This avoids
701 * scanning the whole directory.
702 */
703 ret = SMB_VFS_GET_REAL_FILENAME(dptr->conn, dptr->path, dptr->wcard,
704 ctx, &found_name);
705 if (ret == 0) {
706 name = found_name;
707 goto clean;
708 } else if (errno == ENOENT) {
709 /* The case-insensitive lookup was authoritative. */
710 goto clean;
711 }
712
713 TALLOC_FREE(pathreal);
714
715 name_temp = dptr_normal_ReadDirName(dptr, poffset, pst, &talloced);
716 if (name_temp == NULL) {
717 return NULL;
718 }
719 if (talloced != NULL) {
720 return talloc_move(ctx, &talloced);
721 }
722 return talloc_strdup(ctx, name_temp);
723
724 clean:
725 TALLOC_FREE(pathreal);
726 ret:
727 /* We need to set the underlying dir_hnd offset to -1
728 * also as this function is usually called with the
729 * output from TellDir. */
730 dptr->dir_hnd->offset = *poffset = END_OF_DIRECTORY_OFFSET;
731 return name;
732 }
733
734 /****************************************************************************
735 Search for a file by name, skipping veto'ed and not visible files.
736 ****************************************************************************/
737
738 bool dptr_SearchDir(struct dptr_struct *dptr, const char *name, long *poffset, SMB_STRUCT_STAT *pst)
739 {
740 SET_STAT_INVALID(*pst);
741
742 if (!dptr->has_wild && (dptr->dir_hnd->offset == END_OF_DIRECTORY_OFFSET)) {
743 /* This is a singleton directory and we're already at the end. */
744 *poffset = END_OF_DIRECTORY_OFFSET;
745 return False;
746 }
747
748 return SearchDir(dptr->dir_hnd, name, poffset);
749 }
750
751 /****************************************************************************
752 Add the name we're returning into the underlying cache.
753 ****************************************************************************/
754
755 void dptr_DirCacheAdd(struct dptr_struct *dptr, const char *name, long offset)
756 {
757 DirCacheAdd(dptr->dir_hnd, name, offset);
758 }
759
760 /****************************************************************************
761 Initialize variables & state data at the beginning of all search SMB requests.
762 ****************************************************************************/
763 void dptr_init_search_op(struct dptr_struct *dptr)
764 {
765 SMB_VFS_INIT_SEARCH_OP(dptr->conn, dptr->dir_hnd->dir);
766 }
767
768 /****************************************************************************
769 Fill the 5 byte server reserved dptr field.
770 ****************************************************************************/
771
772 bool dptr_fill(struct smbd_server_connection *sconn,
773 char *buf1,unsigned int key)
774 {
775 unsigned char *buf = (unsigned char *)buf1;
776 struct dptr_struct *dptr = dptr_get(sconn, key, false);
777 uint32 offset;
778 if (!dptr) {
779 DEBUG(1,("filling null dirptr %d\n",key));
780 return(False);
781 }
782 offset = (uint32)TellDir(dptr->dir_hnd);
783 DEBUG(6,("fill on key %u dirptr 0x%lx now at %d\n",key,
784 (long)dptr->dir_hnd,(int)offset));
785 buf[0] = key;
786 SIVAL(buf,1,offset);
787 return(True);
788 }
789
790 /****************************************************************************
791 Fetch the dir ptr and seek it given the 5 byte server field.
792 ****************************************************************************/
793
794 struct dptr_struct *dptr_fetch(struct smbd_server_connection *sconn,
795 char *buf, int *num)
796 {
797 unsigned int key = *(unsigned char *)buf;
798 struct dptr_struct *dptr = dptr_get(sconn, key, false);
799 uint32 offset;
800 long seekoff;
801
802 if (!dptr) {
803 DEBUG(3,("fetched null dirptr %d\n",key));
804 return(NULL);
805 }
806 *num = key;
807 offset = IVAL(buf,1);
808 if (offset == (uint32)-1) {
809 seekoff = END_OF_DIRECTORY_OFFSET;
810 } else {
811 seekoff = (long)offset;
812 }
813 SeekDir(dptr->dir_hnd,seekoff);
814 DEBUG(3,("fetching dirptr %d for path %s at offset %d\n",
815 key, dptr->path, (int)seekoff));
816 return(dptr);
817 }
818
819 /****************************************************************************
820 Fetch the dir ptr.
821 ****************************************************************************/
822
823 struct dptr_struct *dptr_fetch_lanman2(struct smbd_server_connection *sconn,
824 int dptr_num)
825 {
826 struct dptr_struct *dptr = dptr_get(sconn, dptr_num, false);
827
828 if (!dptr) {
829 DEBUG(3,("fetched null dirptr %d\n",dptr_num));
830 return(NULL);
831 }
832 DEBUG(3,("fetching dirptr %d for path %s\n",dptr_num,dptr->path));
833 return(dptr);
834 }
835
836 /****************************************************************************
837 Check that a file matches a particular file type.
838 ****************************************************************************/
839
840 bool dir_check_ftype(connection_struct *conn, uint32 mode, uint32 dirtype)
841 {
842 uint32 mask;
843
844 /* Check the "may have" search bits. */
845 if (((mode & ~dirtype) & (aHIDDEN | aSYSTEM | aDIR)) != 0)
846 return False;
847
848 /* Check the "must have" bits, which are the may have bits shifted eight */
849 /* If must have bit is set, the file/dir can not be returned in search unless the matching
850 file attribute is set */
851 mask = ((dirtype >> 8) & (aDIR|aARCH|aRONLY|aHIDDEN|aSYSTEM)); /* & 0x37 */
852 if(mask) {
853 if((mask & (mode & (aDIR|aARCH|aRONLY|aHIDDEN|aSYSTEM))) == mask) /* check if matching attribute present */
854 return True;
855 else
856 return False;
857 }
858
859 return True;
860 }
861
862 static bool mangle_mask_match(connection_struct *conn,
863 const char *filename,
864 const char *mask)
865 {
866 char mname[13];
867
868 if (!name_to_8_3(filename,mname,False,conn->params)) {
869 return False;
870 }
871 return mask_match_search(mname,mask,False);
872 }
873
874 bool smbd_dirptr_get_entry(TALLOC_CTX *ctx,
875 struct dptr_struct *dirptr,
876 const char *mask,
877 uint32_t dirtype,
878 bool dont_descend,
879 bool ask_sharemode,
880 bool (*match_fn)(TALLOC_CTX *ctx,
881 void *private_data,
882 const char *dname,
883 const char *mask,
884 char **_fname),
885 bool (*mode_fn)(TALLOC_CTX *ctx,
886 void *private_data,
887 struct smb_filename *smb_fname,
888 uint32_t *_mode),
889 void *private_data,
890 char **_fname,
891 struct smb_filename **_smb_fname,
892 uint32_t *_mode,
893 long *_prev_offset)
894 {
895 connection_struct *conn = dirptr->conn;
896 bool needslash;
897
898 *_smb_fname = NULL;
899 *_mode = 0;
900
901 needslash = ( dirptr->path[strlen(dirptr->path) -1] != '/');
902
903 while (true) {
904 long cur_offset;
905 long prev_offset;
906 SMB_STRUCT_STAT sbuf;
907 char *dname = NULL;
908 bool isdots;
909 char *fname = NULL;
910 char *pathreal = NULL;
911 struct smb_filename smb_fname;
912 uint32_t mode = 0;
913 bool ok;
914 NTSTATUS status;
915
916 cur_offset = dptr_TellDir(dirptr);
917 prev_offset = cur_offset;
918 dname = dptr_ReadDirName(ctx, dirptr, &cur_offset, &sbuf);
919
920 DEBUG(6,("smbd_dirptr_get_entry: dirptr 0x%lx now at offset %ld\n",
921 (long)dirptr, cur_offset));
922
923 if (dname == NULL) {
924 return false;
925 }
926
927 isdots = (ISDOT(dname) || ISDOTDOT(dname));
928 if (dont_descend && !isdots) {
929 TALLOC_FREE(dname);
930 continue;
931 }
932
933 /*
934 * fname may get mangled, dname is never mangled.
935 * Whenever we're accessing the filesystem we use
936 * pathreal which is composed from dname.
937 */
938
939 ok = match_fn(ctx, private_data, dname, mask, &fname);
940 if (!ok) {
941 TALLOC_FREE(dname);
942 continue;
943 }
944
945 pathreal = talloc_asprintf(ctx, "%s%s%s",
946 dirptr->path,
947 needslash?"/":"",
948 dname);
949 if (!pathreal) {
950 TALLOC_FREE(dname);
951 TALLOC_FREE(fname);
952 return false;
953 }
954
955 /* Create smb_fname with NULL stream_name. */
956 ZERO_STRUCT(smb_fname);
957 smb_fname.base_name = pathreal;
958 smb_fname.st = sbuf;
959
960 ok = mode_fn(ctx, private_data, &smb_fname, &mode);
961 if (!ok) {
962 TALLOC_FREE(dname);
963 TALLOC_FREE(fname);
964 TALLOC_FREE(pathreal);
965 continue;
966 }
967
968 if (!dir_check_ftype(conn, mode, dirtype)) {
969 DEBUG(5,("[%s] attribs 0x%x didn't match 0x%x\n",
970 fname, (unsigned int)mode, (unsigned int)dirtype));
971 TALLOC_FREE(dname);
972 TALLOC_FREE(fname);
973 TALLOC_FREE(pathreal);
974 continue;
975 }
976
977 if (ask_sharemode) {
978 struct timespec write_time_ts;
979 struct file_id fileid;
980
981 fileid = vfs_file_id_from_sbuf(conn,
982 &smb_fname.st);
983 get_file_infos(fileid, NULL, &write_time_ts);
984 if (!null_timespec(write_time_ts)) {
985 update_stat_ex_mtime(&smb_fname.st,
986 write_time_ts);
987 }
988 }
989
990 DEBUG(3,("smbd_dirptr_get_entry mask=[%s] found %s "
991 "fname=%s (%s)\n",
992 mask, smb_fname_str_dbg(&smb_fname),
993 dname, fname));
994
995 DirCacheAdd(dirptr->dir_hnd, dname, cur_offset);
996
997 TALLOC_FREE(dname);
998
999 status = copy_smb_filename(ctx, &smb_fname, _smb_fname);
1000 TALLOC_FREE(pathreal);
1001 if (!NT_STATUS_IS_OK(status)) {
1002 return false;
1003 }
1004 *_fname = fname;
1005 *_mode = mode;
1006 *_prev_offset = prev_offset;
1007
1008 return true;
1009 }
1010
1011 return false;
1012 }
1013
1014 /****************************************************************************
1015 Get an 8.3 directory entry.
1016 ****************************************************************************/
1017
1018 static bool smbd_dirptr_8_3_match_fn(TALLOC_CTX *ctx,
1019 void *private_data,
1020 const char *dname,
1021 const char *mask,
1022 char **_fname)
1023 {
1024 connection_struct *conn = (connection_struct *)private_data;
1025
1026 if ((strcmp(mask,"*.*") == 0) ||
1027 mask_match_search(dname, mask, false) ||
1028 mangle_mask_match(conn, dname, mask)) {
1029 char mname[13];
1030 const char *fname;
1031
1032 if (!mangle_is_8_3(dname, false, conn->params)) {
1033 bool ok = name_to_8_3(dname, mname, false,
1034 conn->params);
1035 if (!ok) {
1036 return false;
1037 }
1038 fname = mname;
1039 } else {
1040 fname = dname;
1041 }
1042
1043 *_fname = talloc_strdup(ctx, fname);
1044 if (*_fname == NULL) {
1045 return false;
1046 }
1047
1048 return true;
1049 }
1050
1051 return false;
1052 }
1053
1054 static bool smbd_dirptr_8_3_mode_fn(TALLOC_CTX *ctx,
1055 void *private_data,
1056 struct smb_filename *smb_fname,
1057 uint32_t *_mode)
1058 {
1059 connection_struct *conn = (connection_struct *)private_data;
1060
1061 if (!VALID_STAT(smb_fname->st)) {
1062 if ((SMB_VFS_STAT(conn, smb_fname)) != 0) {
1063 DEBUG(5,("smbd_dirptr_8_3_mode_fn: "
1064 "Couldn't stat [%s]. Error "
1065 "= %s\n",
1066 smb_fname_str_dbg(smb_fname),
1067 strerror(errno)));
1068 return false;
1069 }
1070 }
1071
1072 *_mode = dos_mode(conn, smb_fname);
1073 return true;
1074 }
1075
1076 bool get_dir_entry(TALLOC_CTX *ctx,
1077 struct dptr_struct *dirptr,
1078 const char *mask,
1079 uint32_t dirtype,
1080 char **_fname,
1081 SMB_OFF_T *_size,
1082 uint32_t *_mode,
1083 struct timespec *_date,
1084 bool check_descend,
1085 bool ask_sharemode)
1086 {
1087 connection_struct *conn = dirptr->conn;
1088 char *fname = NULL;
1089 struct smb_filename *smb_fname = NULL;
1090 uint32_t mode = 0;
1091 long prev_offset;
1092 bool ok;
1093
1094 ok = smbd_dirptr_get_entry(ctx,
1095 dirptr,
1096 mask,
1097 dirtype,
1098 check_descend,
1099 ask_sharemode,
1100 smbd_dirptr_8_3_match_fn,
1101 smbd_dirptr_8_3_mode_fn,
1102 conn,
1103 &fname,
1104 &smb_fname,
1105 &mode,
1106 &prev_offset);
1107 if (!ok) {
1108 return false;
1109 }
1110
1111 *_fname = talloc_move(ctx, &fname);
1112 *_size = smb_fname->st.st_ex_size;
1113 *_mode = mode;
1114 *_date = smb_fname->st.st_ex_mtime;
1115 TALLOC_FREE(smb_fname);
1116 return true;
1117 }
1118
1119 /*******************************************************************
1120 Check to see if a user can read a file. This is only approximate,
1121 it is used as part of the "hide unreadable" option. Don't
1122 use it for anything security sensitive.
1123 ********************************************************************/
1124
1125 static bool user_can_read_file(connection_struct *conn,
1126 struct smb_filename *smb_fname)
1127 {
1128 /*
1129 * If user is a member of the Admin group
1130 * we never hide files from them.
1131 */
1132
1133 if (conn->admin_user) {
1134 return True;
1135 }
1136
1137 return can_access_file_acl(conn, smb_fname, FILE_READ_DATA);
1138 }
1139
1140 /*******************************************************************
1141 Check to see if a user can write a file (and only files, we do not
1142 check dirs on this one). This is only approximate,
1143 it is used as part of the "hide unwriteable" option. Don't
1144 use it for anything security sensitive.
1145 ********************************************************************/
1146
1147 static bool user_can_write_file(connection_struct *conn,
1148 const struct smb_filename *smb_fname)
1149 {
1150 /*
1151 * If user is a member of the Admin group
1152 * we never hide files from them.
1153 */
1154
1155 if (conn->admin_user) {
1156 return True;
1157 }
1158
1159 SMB_ASSERT(VALID_STAT(smb_fname->st));
1160
1161 /* Pseudo-open the file */
1162
1163 if(S_ISDIR(smb_fname->st.st_ex_mode)) {
1164 return True;
1165 }
1166
1167 return can_write_to_file(conn, smb_fname);
1168 }
1169
1170 /*******************************************************************
1171 Is a file a "special" type ?
1172 ********************************************************************/
1173
1174 static bool file_is_special(connection_struct *conn,
1175 const struct smb_filename *smb_fname)
1176 {
1177 /*
1178 * If user is a member of the Admin group
1179 * we never hide files from them.
1180 */
1181
1182 if (conn->admin_user)
1183 return False;
1184
1185 SMB_ASSERT(VALID_STAT(smb_fname->st));
1186
1187 if (S_ISREG(smb_fname->st.st_ex_mode) ||
1188 S_ISDIR(smb_fname->st.st_ex_mode) ||
1189 S_ISLNK(smb_fname->st.st_ex_mode))
1190 return False;
1191
1192 return True;
1193 }
1194
1195 /*******************************************************************
1196 Should the file be seen by the client?
1197 NOTE: A successful return is no guarantee of the file's existence.
1198 ********************************************************************/
1199
1200 bool is_visible_file(connection_struct *conn, const char *dir_path,
1201 const char *name, SMB_STRUCT_STAT *pst, bool use_veto)
1202 {
1203 bool hide_unreadable = lp_hideunreadable(SNUM(conn));
1204 bool hide_unwriteable = lp_hideunwriteable_files(SNUM(conn));
1205 bool hide_special = lp_hide_special_files(SNUM(conn));
1206 char *entry = NULL;
1207 struct smb_filename *smb_fname_base = NULL;
1208 NTSTATUS status;
1209 bool ret = false;
1210
1211 if ((strcmp(".",name) == 0) || (strcmp("..",name) == 0)) {
1212 return True; /* . and .. are always visible. */
1213 }
1214
1215 /* If it's a vetoed file, pretend it doesn't even exist */
1216 if (use_veto && IS_VETO_PATH(conn, name)) {
1217 DEBUG(10,("is_visible_file: file %s is vetoed.\n", name ));
1218 return False;
1219 }
1220
1221 if (hide_unreadable || hide_unwriteable || hide_special) {
1222 entry = talloc_asprintf(talloc_tos(), "%s/%s", dir_path, name);
1223 if (!entry) {
1224 ret = false;
1225 goto out;
1226 }
1227
1228 /* If it's a dfs symlink, ignore _hide xxxx_ options */
1229 if (lp_host_msdfs() &&
1230 lp_msdfs_root(SNUM(conn)) &&
1231 is_msdfs_link(conn, entry, NULL)) {
1232 ret = true;
1233 goto out;
1234 }
1235
1236 /* Create an smb_filename with stream_name == NULL. */
1237 status = create_synthetic_smb_fname(talloc_tos(), entry, NULL,
1238 pst, &smb_fname_base);
1239 if (!NT_STATUS_IS_OK(status)) {
1240 ret = false;
1241 goto out;
1242 }
1243
1244 /* If the file name does not exist, there's no point checking
1245 * the configuration options. We succeed, on the basis that the
1246 * checks *might* have passed if the file was present.
1247 */
1248 if (!VALID_STAT(*pst)) {
1249 if (SMB_VFS_STAT(conn, smb_fname_base) != 0) {
1250 ret = true;
1251 goto out;
1252 } else {
1253 *pst = smb_fname_base->st;
1254 }
1255 }
1256
1257 /* Honour _hide unreadable_ option */
1258 if (hide_unreadable &&
1259 !user_can_read_file(conn, smb_fname_base)) {
1260 DEBUG(10,("is_visible_file: file %s is unreadable.\n",
1261 entry ));
1262 ret = false;
1263 goto out;
1264 }
1265 /* Honour _hide unwriteable_ option */
1266 if (hide_unwriteable && !user_can_write_file(conn,
1267 smb_fname_base)) {
1268 DEBUG(10,("is_visible_file: file %s is unwritable.\n",
1269 entry ));
1270 ret = false;
1271 goto out;
1272 }
1273 /* Honour _hide_special_ option */
1274 if (hide_special && file_is_special(conn, smb_fname_base)) {
1275 DEBUG(10,("is_visible_file: file %s is special.\n",
1276 entry ));
1277 ret = false;
1278 goto out;
1279 }
1280 }
1281
1282 ret = true;
1283 out:
1284 TALLOC_FREE(smb_fname_base);
1285 TALLOC_FREE(entry);
1286 return ret;
1287 }
1288
1289 static int smb_Dir_destructor(struct smb_Dir *dirp)
1290 {
1291 if (dirp->dir) {
1292 SMB_VFS_CLOSEDIR(dirp->conn,dirp->dir);
1293 }
1294 if (dirp->conn->sconn) {
1295 dirp->conn->sconn->smb1.searches.dirhandles_open--;
1296 }
1297 return 0;
1298 }
1299
1300 /*******************************************************************
1301 Open a directory.
1302 ********************************************************************/
1303
1304 struct smb_Dir *OpenDir(TALLOC_CTX *mem_ctx, connection_struct *conn,
1305 const char *name, const char *mask, uint32 attr)
1306 {
1307 struct smb_Dir *dirp = TALLOC_ZERO_P(mem_ctx, struct smb_Dir);
1308 struct smbd_server_connection *sconn = conn->sconn;
1309
1310 if (!dirp) {
1311 return NULL;
1312 }
1313
1314 dirp->conn = conn;
1315 dirp->name_cache_size = lp_directory_name_cache_size(SNUM(conn));
1316
1317 dirp->dir_path = talloc_strdup(dirp, name);
1318 if (!dirp->dir_path) {
1319 errno = ENOMEM;
1320 goto fail;
1321 }
1322
1323 if (sconn) {
1324 sconn->smb1.searches.dirhandles_open++;
1325 }
1326 talloc_set_destructor(dirp, smb_Dir_destructor);
1327
1328 dirp->dir = SMB_VFS_OPENDIR(conn, dirp->dir_path, mask, attr);
1329 if (!dirp->dir) {
1330 DEBUG(5,("OpenDir: Can't open %s. %s\n", dirp->dir_path,
1331 strerror(errno) ));
1332 goto fail;
1333 }
1334
1335 return dirp;
1336
1337 fail:
1338 TALLOC_FREE(dirp);
1339 return NULL;
1340 }
1341
1342 /*******************************************************************
1343 Read from a directory.
1344 Return directory entry, current offset, and optional stat information.
1345 Don't check for veto or invisible files.
1346 ********************************************************************/
1347
1348 const char *ReadDirName(struct smb_Dir *dirp, long *poffset,
1349 SMB_STRUCT_STAT *sbuf, char **ptalloced)
1350 {
1351 const char *n;
1352 char *talloced = NULL;
1353 connection_struct *conn = dirp->conn;
1354
1355 /* Cheat to allow . and .. to be the first entries returned. */
1356 if (((*poffset == START_OF_DIRECTORY_OFFSET) ||
1357 (*poffset == DOT_DOT_DIRECTORY_OFFSET)) && (dirp->file_number < 2))
1358 {
1359 if (dirp->file_number == 0) {
1360 n = ".";
1361 *poffset = dirp->offset = START_OF_DIRECTORY_OFFSET;
1362 } else {
1363 n = "..";
1364 *poffset = dirp->offset = DOT_DOT_DIRECTORY_OFFSET;
1365 }
1366 dirp->file_number++;
1367 *ptalloced = NULL;
1368 return n;
1369 } else if (*poffset == END_OF_DIRECTORY_OFFSET) {
1370 *poffset = dirp->offset = END_OF_DIRECTORY_OFFSET;
1371 return NULL;
1372 } else {
1373 /* A real offset, seek to it. */
1374 SeekDir(dirp, *poffset);
1375 }
1376
1377 while ((n = vfs_readdirname(conn, dirp->dir, sbuf, &talloced))) {
1378 /* Ignore . and .. - we've already returned them. */
1379 if (*n == '.') {
1380 if ((n[1] == '\0') || (n[1] == '.' && n[2] == '\0')) {
1381 TALLOC_FREE(talloced);
1382 continue;
1383 }
1384 }
1385 *poffset = dirp->offset = SMB_VFS_TELLDIR(conn, dirp->dir);
1386 *ptalloced = talloced;
1387 dirp->file_number++;
1388 return n;
1389 }
1390 *poffset = dirp->offset = END_OF_DIRECTORY_OFFSET;
1391 *ptalloced = NULL;
1392 return NULL;
1393 }
1394
1395 /*******************************************************************
1396 Rewind to the start.
1397 ********************************************************************/
1398
1399 void RewindDir(struct smb_Dir *dirp, long *poffset)
1400 {
1401 SMB_VFS_REWINDDIR(dirp->conn, dirp->dir);
1402 dirp->file_number = 0;
1403 dirp->offset = START_OF_DIRECTORY_OFFSET;
1404 *poffset = START_OF_DIRECTORY_OFFSET;
1405 }
1406
1407 /*******************************************************************
1408 Seek a dir.
1409 ********************************************************************/
1410
1411 void SeekDir(struct smb_Dir *dirp, long offset)
1412 {
1413 if (offset != dirp->offset) {
1414 if (offset == START_OF_DIRECTORY_OFFSET) {
1415 RewindDir(dirp, &offset);
1416 /*
1417 * Ok we should really set the file number here
1418 * to 1 to enable ".." to be returned next. Trouble
1419 * is I'm worried about callers using SeekDir(dirp,0)
1420 * as equivalent to RewindDir(). So leave this alone
1421 * for now.
1422 */
1423 } else if (offset == DOT_DOT_DIRECTORY_OFFSET) {
1424 RewindDir(dirp, &offset);
1425 /*
1426 * Set the file number to 2 - we want to get the first
1427 * real file entry (the one we return after "..")
1428 * on the next ReadDir.
1429 */
1430 dirp->file_number = 2;
1431 } else if (offset == END_OF_DIRECTORY_OFFSET) {
1432 ; /* Don't seek in this case. */
1433 } else {
1434 SMB_VFS_SEEKDIR(dirp->conn, dirp->dir, offset);
1435 }
1436 dirp->offset = offset;
1437 }
1438 }
1439
1440 /*******************************************************************
1441 Tell a dir position.
1442 ********************************************************************/
1443
1444 long TellDir(struct smb_Dir *dirp)
1445 {
1446 return(dirp->offset);
1447 }
1448
1449 /*******************************************************************
1450 Add an entry into the dcache.
1451 ********************************************************************/
1452
1453 void DirCacheAdd(struct smb_Dir *dirp, const char *name, long offset)
1454 {
1455 struct name_cache_entry *e;
1456
1457 if (dirp->name_cache_size == 0) {
1458 return;
1459 }
1460
1461 if (dirp->name_cache == NULL) {
1462 dirp->name_cache = TALLOC_ZERO_ARRAY(
1463 dirp, struct name_cache_entry, dirp->name_cache_size);
1464
1465 if (dirp->name_cache == NULL) {
1466 return;
1467 }
1468 }
1469
1470 dirp->name_cache_index = (dirp->name_cache_index+1) %
1471 dirp->name_cache_size;
1472 e = &dirp->name_cache[dirp->name_cache_index];
1473 TALLOC_FREE(e->name);
1474 e->name = talloc_strdup(dirp, name);
1475 e->offset = offset;
1476 }
1477
1478 /*******************************************************************
1479 Find an entry by name. Leave us at the offset after it.
1480 Don't check for veto or invisible files.
1481 ********************************************************************/
1482
1483 bool SearchDir(struct smb_Dir *dirp, const char *name, long *poffset)
1484 {
1485 int i;
1486 const char *entry = NULL;
1487 char *talloced = NULL;
1488 connection_struct *conn = dirp->conn;
1489
1490 /* Search back in the name cache. */
1491 if (dirp->name_cache_size && dirp->name_cache) {
1492 for (i = dirp->name_cache_index; i >= 0; i--) {
1493 struct name_cache_entry *e = &dirp->name_cache[i];
1494 if (e->name && (conn->case_sensitive ? (strcmp(e->name, name) == 0) : strequal(e->name, name))) {
1495 *poffset = e->offset;
1496 SeekDir(dirp, e->offset);
1497 return True;
1498 }
1499 }
1500 for (i = dirp->name_cache_size - 1; i > dirp->name_cache_index; i--) {
1501 struct name_cache_entry *e = &dirp->name_cache[i];
1502 if (e->name && (conn->case_sensitive ? (strcmp(e->name, name) == 0) : strequal(e->name, name))) {
1503 *poffset = e->offset;
1504 SeekDir(dirp, e->offset);
1505 return True;
1506 }
1507 }
1508 }
1509
1510 /* Not found in the name cache. Rewind directory and start from scratch. */
1511 SMB_VFS_REWINDDIR(conn, dirp->dir);
1512 dirp->file_number = 0;
1513 *poffset = START_OF_DIRECTORY_OFFSET;
1514 while ((entry = ReadDirName(dirp, poffset, NULL, &talloced))) {
1515 if (conn->case_sensitive ? (strcmp(entry, name) == 0) : strequal(entry, name)) {
1516 TALLOC_FREE(talloced);
1517 return True;
1518 }
1519 TALLOC_FREE(talloced);
1520 }
1521 return False;
1522 }
1523
1524 /*****************************************************************
1525 Is this directory empty ?
1526 *****************************************************************/
1527
1528 NTSTATUS can_delete_directory(struct connection_struct *conn,
1529 const char *dirname)
1530 {
1531 NTSTATUS status = NT_STATUS_OK;
1532 long dirpos = 0;
1533 const char *dname = NULL;
1534 char *talloced = NULL;
1535 SMB_STRUCT_STAT st;
1536 struct smb_Dir *dir_hnd = OpenDir(talloc_tos(), conn, dirname,
1537 NULL, 0);
1538
1539 if (!dir_hnd) {
1540 return map_nt_error_from_unix(errno);
1541 }
1542
1543 while ((dname = ReadDirName(dir_hnd, &dirpos, &st, &talloced))) {
1544 /* Quick check for "." and ".." */
1545 if (dname[0] == '.') {
1546 if (!dname[1] || (dname[1] == '.' && !dname[2])) {
1547 TALLOC_FREE(talloced);
1548 continue;
1549 }
1550 }
1551
1552 if (!is_visible_file(conn, dirname, dname, &st, True)) {
1553 TALLOC_FREE(talloced);
1554 continue;
1555 }
1556
1557 DEBUG(10,("can_delete_directory: got name %s - can't delete\n",
1558 dname ));
1559 status = NT_STATUS_DIRECTORY_NOT_EMPTY;
1560 break;
1561 }
1562 TALLOC_FREE(talloced);
1563 TALLOC_FREE(dir_hnd);
1564
1565 return status;
1566 }
Samba GIT mirror