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