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