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