?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
In the struct smb_Dir destructor, use the fsp back pointer to release resources.
[Samba.git] / source3 / smbd / dir.c
blob7bca6bfd3d4908e05f464a92d7bc8f5f6461e354
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 bool backup_intent = (req && req->priv_paths);
516 struct smb_filename *smb_dname = NULL;
517 NTSTATUS status = create_synthetic_smb_fname(talloc_tos(),
518 path,
519 NULL,
520 NULL,
521 &smb_dname);
522 if (!NT_STATUS_IS_OK(status)) {
523 return status;
524 }
525 if (lp_posix_pathnames()) {
526 ret = SMB_VFS_LSTAT(conn, smb_dname);
527 } else {
528 ret = SMB_VFS_STAT(conn, smb_dname);
529 }
530 if (ret == -1) {
531 return map_nt_error_from_unix(errno);
532 }
533 if (!S_ISDIR(smb_dname->st.st_ex_mode)) {
534 return NT_STATUS_NOT_A_DIRECTORY;
535 }
536 status = smbd_check_access_rights(conn,
537 smb_dname,
538 backup_intent,
539 SEC_DIR_LIST);
540 if (!NT_STATUS_IS_OK(status)) {
541 return status;
542 }
543 if (backup_intent) {
544 dir_hnd = open_dir_with_privilege(conn,
545 req,
546 path,
547 wcard,
548 attr);
549 } else {
550 dir_hnd = OpenDir(NULL, conn, path, wcard, attr);
551 }
552 }
553
554 if (!dir_hnd) {
555 return map_nt_error_from_unix(errno);
556 }
557
558 if (sconn->searches.dirhandles_open >= MAX_OPEN_DIRECTORIES) {
559 dptr_idleoldest(sconn);
560 }
561
562 dptr = talloc(NULL, struct dptr_struct);
563 if(!dptr) {
564 DEBUG(0,("talloc fail in dptr_create.\n"));
565 TALLOC_FREE(dir_hnd);
566 return NT_STATUS_NO_MEMORY;
567 }
568
569 ZERO_STRUCTP(dptr);
570
571 dptr->path = talloc_strdup(dptr, path);
572 if (!dptr->path) {
573 TALLOC_FREE(dptr);
574 TALLOC_FREE(dir_hnd);
575 return NT_STATUS_NO_MEMORY;
576 }
577 dptr->conn = conn;
578 dptr->dir_hnd = dir_hnd;
579 dptr->spid = spid;
580 dptr->expect_close = expect_close;
581 dptr->wcard = talloc_strdup(dptr, wcard);
582 if (!dptr->wcard) {
583 TALLOC_FREE(dptr);
584 TALLOC_FREE(dir_hnd);
585 return NT_STATUS_NO_MEMORY;
586 }
587 if (lp_posix_pathnames() || (wcard[0] == '.' && wcard[1] == 0)) {
588 dptr->has_wild = True;
589 } else {
590 dptr->has_wild = wcard_has_wild;
591 }
592
593 dptr->attr = attr;
594
595 if (sconn->using_smb2) {
596 goto done;
597 }
598
599 if(old_handle) {
600
601 /*
602 * This is an old-style SMBsearch request. Ensure the
603 * value we return will fit in the range 1-255.
604 */
605
606 dptr->dnum = bitmap_find(sconn->searches.dptr_bmap, 0);
607
608 if(dptr->dnum == -1 || dptr->dnum > 254) {
609
610 /*
611 * Try and close the oldest handle not marked for
612 * expect close in the hope that the client has
613 * finished with that one.
614 */
615
616 dptr_close_oldest(sconn, true);
617
618 /* Now try again... */
619 dptr->dnum = bitmap_find(sconn->searches.dptr_bmap, 0);
620 if(dptr->dnum == -1 || dptr->dnum > 254) {
621 DEBUG(0,("dptr_create: returned %d: Error - all old dirptrs in use ?\n", dptr->dnum));
622 TALLOC_FREE(dptr);
623 TALLOC_FREE(dir_hnd);
624 return NT_STATUS_TOO_MANY_OPENED_FILES;
625 }
626 }
627 } else {
628
629 /*
630 * This is a new-style trans2 request. Allocate from
631 * a range that will return 256 - MAX_DIRECTORY_HANDLES.
632 */
633
634 dptr->dnum = bitmap_find(sconn->searches.dptr_bmap, 255);
635
636 if(dptr->dnum == -1 || dptr->dnum < 255) {
637
638 /*
639 * Try and close the oldest handle close in the hope that
640 * the client has finished with that one. This will only
641 * happen in the case of the Win98 client bug where it leaks
642 * directory handles.
643 */
644
645 dptr_close_oldest(sconn, false);
646
647 /* Now try again... */
648 dptr->dnum = bitmap_find(sconn->searches.dptr_bmap, 255);
649
650 if(dptr->dnum == -1 || dptr->dnum < 255) {
651 DEBUG(0,("dptr_create: returned %d: Error - all new dirptrs in use ?\n", dptr->dnum));
652 TALLOC_FREE(dptr);
653 TALLOC_FREE(dir_hnd);
654 return NT_STATUS_TOO_MANY_OPENED_FILES;
655 }
656 }
657 }
658
659 bitmap_set(sconn->searches.dptr_bmap, dptr->dnum);
660
661 dptr->dnum += 1; /* Always bias the dnum by one - no zero dnums allowed. */
662
663 DLIST_ADD(sconn->searches.dirptrs, dptr);
664
665 done:
666 DEBUG(3,("creating new dirptr %d for path %s, expect_close = %d\n",
667 dptr->dnum,path,expect_close));
668
669 *dptr_ret = dptr;
670
671 return NT_STATUS_OK;
672 }
673
674
675 /****************************************************************************
676 Wrapper functions to access the lower level directory handles.
677 ****************************************************************************/
678
679 void dptr_CloseDir(files_struct *fsp)
680 {
681 if (fsp->dptr) {
682 /*
683 * Ugly hack. We have defined fdopendir to return ENOSYS if dirfd also isn't
684 * present. I hate Solaris. JRA.
685 */
686 #ifdef HAVE_DIRFD
687 if (fsp->fh->fd != -1 &&
688 fsp->dptr->dir_hnd &&
689 dirfd(fsp->dptr->dir_hnd->dir)) {
690 /* The call below closes the underlying fd. */
691 fsp->fh->fd = -1;
692 }
693 #endif
694 dptr_close_internal(fsp->dptr);
695 fsp->dptr = NULL;
696 }
697 }
698
699 void dptr_SeekDir(struct dptr_struct *dptr, long offset)
700 {
701 SeekDir(dptr->dir_hnd, offset);
702 }
703
704 long dptr_TellDir(struct dptr_struct *dptr)
705 {
706 return TellDir(dptr->dir_hnd);
707 }
708
709 bool dptr_has_wild(struct dptr_struct *dptr)
710 {
711 return dptr->has_wild;
712 }
713
714 int dptr_dnum(struct dptr_struct *dptr)
715 {
716 return dptr->dnum;
717 }
718
719 bool dptr_get_priv(struct dptr_struct *dptr)
720 {
721 return dptr->priv;
722 }
723
724 void dptr_set_priv(struct dptr_struct *dptr)
725 {
726 dptr->priv = true;
727 }
728
729 /****************************************************************************
730 Return the next visible file name, skipping veto'd and invisible files.
731 ****************************************************************************/
732
733 static const char *dptr_normal_ReadDirName(struct dptr_struct *dptr,
734 long *poffset, SMB_STRUCT_STAT *pst,
735 char **ptalloced)
736 {
737 /* Normal search for the next file. */
738 const char *name;
739 char *talloced = NULL;
740
741 while ((name = ReadDirName(dptr->dir_hnd, poffset, pst, &talloced))
742 != NULL) {
743 if (is_visible_file(dptr->conn, dptr->path, name, pst, True)) {
744 *ptalloced = talloced;
745 return name;
746 }
747 TALLOC_FREE(talloced);
748 }
749 return NULL;
750 }
751
752 /****************************************************************************
753 Return the next visible file name, skipping veto'd and invisible files.
754 ****************************************************************************/
755
756 char *dptr_ReadDirName(TALLOC_CTX *ctx,
757 struct dptr_struct *dptr,
758 long *poffset,
759 SMB_STRUCT_STAT *pst)
760 {
761 struct smb_filename smb_fname_base;
762 char *name = NULL;
763 const char *name_temp = NULL;
764 char *talloced = NULL;
765 char *pathreal = NULL;
766 char *found_name = NULL;
767 int ret;
768
769 SET_STAT_INVALID(*pst);
770
771 if (dptr->has_wild || dptr->did_stat) {
772 name_temp = dptr_normal_ReadDirName(dptr, poffset, pst,
773 &talloced);
774 if (name_temp == NULL) {
775 return NULL;
776 }
777 if (talloced != NULL) {
778 return talloc_move(ctx, &talloced);
779 }
780 return talloc_strdup(ctx, name_temp);
781 }
782
783 /* If poffset is -1 then we know we returned this name before and we
784 * have no wildcards. We're at the end of the directory. */
785 if (*poffset == END_OF_DIRECTORY_OFFSET) {
786 return NULL;
787 }
788
789 /* We know the stored wcard contains no wildcard characters.
790 * See if we can match with a stat call. If we can't, then set
791 * did_stat to true to ensure we only do this once and keep
792 * searching. */
793
794 dptr->did_stat = true;
795
796 /* First check if it should be visible. */
797 if (!is_visible_file(dptr->conn, dptr->path, dptr->wcard,
798 pst, true))
799 {
800 /* This only returns false if the file was found, but
801 is explicitly not visible. Set us to end of
802 directory, but return NULL as we know we can't ever
803 find it. */
804 goto ret;
805 }
806
807 if (VALID_STAT(*pst)) {
808 name = talloc_strdup(ctx, dptr->wcard);
809 goto ret;
810 }
811
812 pathreal = talloc_asprintf(ctx,
813 "%s/%s",
814 dptr->path,
815 dptr->wcard);
816 if (!pathreal)
817 return NULL;
818
819 /* Create an smb_filename with stream_name == NULL. */
820 ZERO_STRUCT(smb_fname_base);
821 smb_fname_base.base_name = pathreal;
822
823 if (SMB_VFS_STAT(dptr->conn, &smb_fname_base) == 0) {
824 *pst = smb_fname_base.st;
825 name = talloc_strdup(ctx, dptr->wcard);
826 goto clean;
827 } else {
828 /* If we get any other error than ENOENT or ENOTDIR
829 then the file exists we just can't stat it. */
830 if (errno != ENOENT && errno != ENOTDIR) {
831 name = talloc_strdup(ctx, dptr->wcard);
832 goto clean;
833 }
834 }
835
836 /* Stat failed. We know this is authoratiative if we are
837 * providing case sensitive semantics or the underlying
838 * filesystem is case sensitive.
839 */
840 if (dptr->conn->case_sensitive ||
841 !(dptr->conn->fs_capabilities & FILE_CASE_SENSITIVE_SEARCH))
842 {
843 goto clean;
844 }
845
846 /*
847 * Try case-insensitive stat if the fs has the ability. This avoids
848 * scanning the whole directory.
849 */
850 ret = SMB_VFS_GET_REAL_FILENAME(dptr->conn, dptr->path, dptr->wcard,
851 ctx, &found_name);
852 if (ret == 0) {
853 name = found_name;
854 goto clean;
855 } else if (errno == ENOENT) {
856 /* The case-insensitive lookup was authoritative. */
857 goto clean;
858 }
859
860 TALLOC_FREE(pathreal);
861
862 name_temp = dptr_normal_ReadDirName(dptr, poffset, pst, &talloced);
863 if (name_temp == NULL) {
864 return NULL;
865 }
866 if (talloced != NULL) {
867 return talloc_move(ctx, &talloced);
868 }
869 return talloc_strdup(ctx, name_temp);
870
871 clean:
872 TALLOC_FREE(pathreal);
873 ret:
874 /* We need to set the underlying dir_hnd offset to -1
875 * also as this function is usually called with the
876 * output from TellDir. */
877 dptr->dir_hnd->offset = *poffset = END_OF_DIRECTORY_OFFSET;
878 return name;
879 }
880
881 /****************************************************************************
882 Search for a file by name, skipping veto'ed and not visible files.
883 ****************************************************************************/
884
885 bool dptr_SearchDir(struct dptr_struct *dptr, const char *name, long *poffset, SMB_STRUCT_STAT *pst)
886 {
887 SET_STAT_INVALID(*pst);
888
889 if (!dptr->has_wild && (dptr->dir_hnd->offset == END_OF_DIRECTORY_OFFSET)) {
890 /* This is a singleton directory and we're already at the end. */
891 *poffset = END_OF_DIRECTORY_OFFSET;
892 return False;
893 }
894
895 return SearchDir(dptr->dir_hnd, name, poffset);
896 }
897
898 /****************************************************************************
899 Add the name we're returning into the underlying cache.
900 ****************************************************************************/
901
902 void dptr_DirCacheAdd(struct dptr_struct *dptr, const char *name, long offset)
903 {
904 DirCacheAdd(dptr->dir_hnd, name, offset);
905 }
906
907 /****************************************************************************
908 Initialize variables & state data at the beginning of all search SMB requests.
909 ****************************************************************************/
910 void dptr_init_search_op(struct dptr_struct *dptr)
911 {
912 SMB_VFS_INIT_SEARCH_OP(dptr->conn, dptr->dir_hnd->dir);
913 }
914
915 /****************************************************************************
916 Fill the 5 byte server reserved dptr field.
917 ****************************************************************************/
918
919 bool dptr_fill(struct smbd_server_connection *sconn,
920 char *buf1,unsigned int key)
921 {
922 unsigned char *buf = (unsigned char *)buf1;
923 struct dptr_struct *dptr = dptr_get(sconn, key, false);
924 uint32 offset;
925 if (!dptr) {
926 DEBUG(1,("filling null dirptr %d\n",key));
927 return(False);
928 }
929 offset = (uint32)TellDir(dptr->dir_hnd);
930 DEBUG(6,("fill on key %u dirptr 0x%lx now at %d\n",key,
931 (long)dptr->dir_hnd,(int)offset));
932 buf[0] = key;
933 SIVAL(buf,1,offset);
934 return(True);
935 }
936
937 /****************************************************************************
938 Fetch the dir ptr and seek it given the 5 byte server field.
939 ****************************************************************************/
940
941 struct dptr_struct *dptr_fetch(struct smbd_server_connection *sconn,
942 char *buf, int *num)
943 {
944 unsigned int key = *(unsigned char *)buf;
945 struct dptr_struct *dptr = dptr_get(sconn, key, false);
946 uint32 offset;
947 long seekoff;
948
949 if (!dptr) {
950 DEBUG(3,("fetched null dirptr %d\n",key));
951 return(NULL);
952 }
953 *num = key;
954 offset = IVAL(buf,1);
955 if (offset == (uint32)-1) {
956 seekoff = END_OF_DIRECTORY_OFFSET;
957 } else {
958 seekoff = (long)offset;
959 }
960 SeekDir(dptr->dir_hnd,seekoff);
961 DEBUG(3,("fetching dirptr %d for path %s at offset %d\n",
962 key, dptr->path, (int)seekoff));
963 return(dptr);
964 }
965
966 /****************************************************************************
967 Fetch the dir ptr.
968 ****************************************************************************/
969
970 struct dptr_struct *dptr_fetch_lanman2(struct smbd_server_connection *sconn,
971 int dptr_num)
972 {
973 struct dptr_struct *dptr = dptr_get(sconn, dptr_num, false);
974
975 if (!dptr) {
976 DEBUG(3,("fetched null dirptr %d\n",dptr_num));
977 return(NULL);
978 }
979 DEBUG(3,("fetching dirptr %d for path %s\n",dptr_num,dptr->path));
980 return(dptr);
981 }
982
983 /****************************************************************************
984 Check that a file matches a particular file type.
985 ****************************************************************************/
986
987 bool dir_check_ftype(connection_struct *conn, uint32 mode, uint32 dirtype)
988 {
989 uint32 mask;
990
991 /* Check the "may have" search bits. */
992 if (((mode & ~dirtype) & (FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_DIRECTORY)) != 0)
993 return False;
994
995 /* Check the "must have" bits, which are the may have bits shifted eight */
996 /* If must have bit is set, the file/dir can not be returned in search unless the matching
997 file attribute is set */
998 mask = ((dirtype >> 8) & (FILE_ATTRIBUTE_DIRECTORY|FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM)); /* & 0x37 */
999 if(mask) {
1000 if((mask & (mode & (FILE_ATTRIBUTE_DIRECTORY|FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM))) == mask) /* check if matching attribute present */
1001 return True;
1002 else
1003 return False;
1004 }
1005
1006 return True;
1007 }
1008
1009 static bool mangle_mask_match(connection_struct *conn,
1010 const char *filename,
1011 const char *mask)
1012 {
1013 char mname[13];
1014
1015 if (!name_to_8_3(filename,mname,False,conn->params)) {
1016 return False;
1017 }
1018 return mask_match_search(mname,mask,False);
1019 }
1020
1021 bool smbd_dirptr_get_entry(TALLOC_CTX *ctx,
1022 struct dptr_struct *dirptr,
1023 const char *mask,
1024 uint32_t dirtype,
1025 bool dont_descend,
1026 bool ask_sharemode,
1027 bool (*match_fn)(TALLOC_CTX *ctx,
1028 void *private_data,
1029 const char *dname,
1030 const char *mask,
1031 char **_fname),
1032 bool (*mode_fn)(TALLOC_CTX *ctx,
1033 void *private_data,
1034 struct smb_filename *smb_fname,
1035 uint32_t *_mode),
1036 void *private_data,
1037 char **_fname,
1038 struct smb_filename **_smb_fname,
1039 uint32_t *_mode,
1040 long *_prev_offset)
1041 {
1042 connection_struct *conn = dirptr->conn;
1043 size_t slashlen;
1044 size_t pathlen;
1045
1046 *_smb_fname = NULL;
1047 *_mode = 0;
1048
1049 pathlen = strlen(dirptr->path);
1050 slashlen = ( dirptr->path[pathlen-1] != '/') ? 1 : 0;
1051
1052 while (true) {
1053 long cur_offset;
1054 long prev_offset;
1055 SMB_STRUCT_STAT sbuf;
1056 char *dname = NULL;
1057 bool isdots;
1058 char *fname = NULL;
1059 char *pathreal = NULL;
1060 struct smb_filename smb_fname;
1061 uint32_t mode = 0;
1062 bool ok;
1063 NTSTATUS status;
1064
1065 cur_offset = dptr_TellDir(dirptr);
1066 prev_offset = cur_offset;
1067 dname = dptr_ReadDirName(ctx, dirptr, &cur_offset, &sbuf);
1068
1069 DEBUG(6,("smbd_dirptr_get_entry: dirptr 0x%lx now at offset %ld\n",
1070 (long)dirptr, cur_offset));
1071
1072 if (dname == NULL) {
1073 return false;
1074 }
1075
1076 isdots = (ISDOT(dname) || ISDOTDOT(dname));
1077 if (dont_descend && !isdots) {
1078 TALLOC_FREE(dname);
1079 continue;
1080 }
1081
1082 /*
1083 * fname may get mangled, dname is never mangled.
1084 * Whenever we're accessing the filesystem we use
1085 * pathreal which is composed from dname.
1086 */
1087
1088 ok = match_fn(ctx, private_data, dname, mask, &fname);
1089 if (!ok) {
1090 TALLOC_FREE(dname);
1091 continue;
1092 }
1093
1094 /*
1095 * This used to be
1096 * pathreal = talloc_asprintf(ctx, "%s%s%s", dirptr->path,
1097 * needslash?"/":"", dname);
1098 * but this was measurably slower than doing the memcpy.
1099 */
1100
1101 pathreal = talloc_array(
1102 ctx, char,
1103 pathlen + slashlen + talloc_get_size(dname));
1104 if (!pathreal) {
1105 TALLOC_FREE(dname);
1106 TALLOC_FREE(fname);
1107 return false;
1108 }
1109
1110 memcpy(pathreal, dirptr->path, pathlen);
1111 pathreal[pathlen] = '/';
1112 memcpy(pathreal + slashlen + pathlen, dname,
1113 talloc_get_size(dname));
1114
1115 /* Create smb_fname with NULL stream_name. */
1116 ZERO_STRUCT(smb_fname);
1117 smb_fname.base_name = pathreal;
1118 smb_fname.st = sbuf;
1119
1120 ok = mode_fn(ctx, private_data, &smb_fname, &mode);
1121 if (!ok) {
1122 TALLOC_FREE(dname);
1123 TALLOC_FREE(fname);
1124 TALLOC_FREE(pathreal);
1125 continue;
1126 }
1127
1128 if (!dir_check_ftype(conn, mode, dirtype)) {
1129 DEBUG(5,("[%s] attribs 0x%x didn't match 0x%x\n",
1130 fname, (unsigned int)mode, (unsigned int)dirtype));
1131 TALLOC_FREE(dname);
1132 TALLOC_FREE(fname);
1133 TALLOC_FREE(pathreal);
1134 continue;
1135 }
1136
1137 if (ask_sharemode) {
1138 struct timespec write_time_ts;
1139 struct file_id fileid;
1140
1141 fileid = vfs_file_id_from_sbuf(conn,
1142 &smb_fname.st);
1143 get_file_infos(fileid, 0, NULL, &write_time_ts);
1144 if (!null_timespec(write_time_ts)) {
1145 update_stat_ex_mtime(&smb_fname.st,
1146 write_time_ts);
1147 }
1148 }
1149
1150 DEBUG(3,("smbd_dirptr_get_entry mask=[%s] found %s "
1151 "fname=%s (%s)\n",
1152 mask, smb_fname_str_dbg(&smb_fname),
1153 dname, fname));
1154
1155 DirCacheAdd(dirptr->dir_hnd, dname, cur_offset);
1156
1157 TALLOC_FREE(dname);
1158
1159 status = copy_smb_filename(ctx, &smb_fname, _smb_fname);
1160 TALLOC_FREE(pathreal);
1161 if (!NT_STATUS_IS_OK(status)) {
1162 return false;
1163 }
1164 *_fname = fname;
1165 *_mode = mode;
1166 *_prev_offset = prev_offset;
1167
1168 return true;
1169 }
1170
1171 return false;
1172 }
1173
1174 /****************************************************************************
1175 Get an 8.3 directory entry.
1176 ****************************************************************************/
1177
1178 static bool smbd_dirptr_8_3_match_fn(TALLOC_CTX *ctx,
1179 void *private_data,
1180 const char *dname,
1181 const char *mask,
1182 char **_fname)
1183 {
1184 connection_struct *conn = (connection_struct *)private_data;
1185
1186 if ((strcmp(mask,"*.*") == 0) ||
1187 mask_match_search(dname, mask, false) ||
1188 mangle_mask_match(conn, dname, mask)) {
1189 char mname[13];
1190 const char *fname;
1191
1192 if (!mangle_is_8_3(dname, false, conn->params)) {
1193 bool ok = name_to_8_3(dname, mname, false,
1194 conn->params);
1195 if (!ok) {
1196 return false;
1197 }
1198 fname = mname;
1199 } else {
1200 fname = dname;
1201 }
1202
1203 *_fname = talloc_strdup(ctx, fname);
1204 if (*_fname == NULL) {
1205 return false;
1206 }
1207
1208 return true;
1209 }
1210
1211 return false;
1212 }
1213
1214 static bool smbd_dirptr_8_3_mode_fn(TALLOC_CTX *ctx,
1215 void *private_data,
1216 struct smb_filename *smb_fname,
1217 uint32_t *_mode)
1218 {
1219 connection_struct *conn = (connection_struct *)private_data;
1220
1221 if (!VALID_STAT(smb_fname->st)) {
1222 if ((SMB_VFS_STAT(conn, smb_fname)) != 0) {
1223 DEBUG(5,("smbd_dirptr_8_3_mode_fn: "
1224 "Couldn't stat [%s]. Error "
1225 "= %s\n",
1226 smb_fname_str_dbg(smb_fname),
1227 strerror(errno)));
1228 return false;
1229 }
1230 }
1231
1232 *_mode = dos_mode(conn, smb_fname);
1233 return true;
1234 }
1235
1236 bool get_dir_entry(TALLOC_CTX *ctx,
1237 struct dptr_struct *dirptr,
1238 const char *mask,
1239 uint32_t dirtype,
1240 char **_fname,
1241 off_t *_size,
1242 uint32_t *_mode,
1243 struct timespec *_date,
1244 bool check_descend,
1245 bool ask_sharemode)
1246 {
1247 connection_struct *conn = dirptr->conn;
1248 char *fname = NULL;
1249 struct smb_filename *smb_fname = NULL;
1250 uint32_t mode = 0;
1251 long prev_offset;
1252 bool ok;
1253
1254 ok = smbd_dirptr_get_entry(ctx,
1255 dirptr,
1256 mask,
1257 dirtype,
1258 check_descend,
1259 ask_sharemode,
1260 smbd_dirptr_8_3_match_fn,
1261 smbd_dirptr_8_3_mode_fn,
1262 conn,
1263 &fname,
1264 &smb_fname,
1265 &mode,
1266 &prev_offset);
1267 if (!ok) {
1268 return false;
1269 }
1270
1271 *_fname = talloc_move(ctx, &fname);
1272 *_size = smb_fname->st.st_ex_size;
1273 *_mode = mode;
1274 *_date = smb_fname->st.st_ex_mtime;
1275 TALLOC_FREE(smb_fname);
1276 return true;
1277 }
1278
1279 /*******************************************************************
1280 Check to see if a user can read a file. This is only approximate,
1281 it is used as part of the "hide unreadable" option. Don't
1282 use it for anything security sensitive.
1283 ********************************************************************/
1284
1285 static bool user_can_read_file(connection_struct *conn,
1286 struct smb_filename *smb_fname)
1287 {
1288 /*
1289 * Never hide files from the root user.
1290 * We use (uid_t)0 here not sec_initial_uid()
1291 * as make test uses a single user context.
1292 */
1293
1294 if (get_current_uid(conn) == (uid_t)0) {
1295 return True;
1296 }
1297
1298 return NT_STATUS_IS_OK(smbd_check_access_rights(conn,
1299 smb_fname,
1300 false,
1301 FILE_READ_DATA));
1302 }
1303
1304 /*******************************************************************
1305 Check to see if a user can write a file (and only files, we do not
1306 check dirs on this one). This is only approximate,
1307 it is used as part of the "hide unwriteable" option. Don't
1308 use it for anything security sensitive.
1309 ********************************************************************/
1310
1311 static bool user_can_write_file(connection_struct *conn,
1312 const struct smb_filename *smb_fname)
1313 {
1314 /*
1315 * Never hide files from the root user.
1316 * We use (uid_t)0 here not sec_initial_uid()
1317 * as make test uses a single user context.
1318 */
1319
1320 if (get_current_uid(conn) == (uid_t)0) {
1321 return True;
1322 }
1323
1324 SMB_ASSERT(VALID_STAT(smb_fname->st));
1325
1326 /* Pseudo-open the file */
1327
1328 if(S_ISDIR(smb_fname->st.st_ex_mode)) {
1329 return True;
1330 }
1331
1332 return can_write_to_file(conn, smb_fname);
1333 }
1334
1335 /*******************************************************************
1336 Is a file a "special" type ?
1337 ********************************************************************/
1338
1339 static bool file_is_special(connection_struct *conn,
1340 const struct smb_filename *smb_fname)
1341 {
1342 /*
1343 * Never hide files from the root user.
1344 * We use (uid_t)0 here not sec_initial_uid()
1345 * as make test uses a single user context.
1346 */
1347
1348 if (get_current_uid(conn) == (uid_t)0) {
1349 return False;
1350 }
1351
1352 SMB_ASSERT(VALID_STAT(smb_fname->st));
1353
1354 if (S_ISREG(smb_fname->st.st_ex_mode) ||
1355 S_ISDIR(smb_fname->st.st_ex_mode) ||
1356 S_ISLNK(smb_fname->st.st_ex_mode))
1357 return False;
1358
1359 return True;
1360 }
1361
1362 /*******************************************************************
1363 Should the file be seen by the client?
1364 NOTE: A successful return is no guarantee of the file's existence.
1365 ********************************************************************/
1366
1367 bool is_visible_file(connection_struct *conn, const char *dir_path,
1368 const char *name, SMB_STRUCT_STAT *pst, bool use_veto)
1369 {
1370 bool hide_unreadable = lp_hideunreadable(SNUM(conn));
1371 bool hide_unwriteable = lp_hideunwriteable_files(SNUM(conn));
1372 bool hide_special = lp_hide_special_files(SNUM(conn));
1373 char *entry = NULL;
1374 struct smb_filename *smb_fname_base = NULL;
1375 NTSTATUS status;
1376 bool ret = false;
1377
1378 if ((strcmp(".",name) == 0) || (strcmp("..",name) == 0)) {
1379 return True; /* . and .. are always visible. */
1380 }
1381
1382 /* If it's a vetoed file, pretend it doesn't even exist */
1383 if (use_veto && IS_VETO_PATH(conn, name)) {
1384 DEBUG(10,("is_visible_file: file %s is vetoed.\n", name ));
1385 return False;
1386 }
1387
1388 if (hide_unreadable || hide_unwriteable || hide_special) {
1389 entry = talloc_asprintf(talloc_tos(), "%s/%s", dir_path, name);
1390 if (!entry) {
1391 ret = false;
1392 goto out;
1393 }
1394
1395 /* Create an smb_filename with stream_name == NULL. */
1396 status = create_synthetic_smb_fname(talloc_tos(), entry, NULL,
1397 pst, &smb_fname_base);
1398 if (!NT_STATUS_IS_OK(status)) {
1399 ret = false;
1400 goto out;
1401 }
1402
1403 /* If the file name does not exist, there's no point checking
1404 * the configuration options. We succeed, on the basis that the
1405 * checks *might* have passed if the file was present.
1406 */
1407 if (!VALID_STAT(*pst)) {
1408 if (SMB_VFS_STAT(conn, smb_fname_base) != 0) {
1409 ret = true;
1410 goto out;
1411 } else {
1412 *pst = smb_fname_base->st;
1413 }
1414 }
1415
1416 /* Honour _hide unreadable_ option */
1417 if (hide_unreadable &&
1418 !user_can_read_file(conn, smb_fname_base)) {
1419 DEBUG(10,("is_visible_file: file %s is unreadable.\n",
1420 entry ));
1421 ret = false;
1422 goto out;
1423 }
1424 /* Honour _hide unwriteable_ option */
1425 if (hide_unwriteable && !user_can_write_file(conn,
1426 smb_fname_base)) {
1427 DEBUG(10,("is_visible_file: file %s is unwritable.\n",
1428 entry ));
1429 ret = false;
1430 goto out;
1431 }
1432 /* Honour _hide_special_ option */
1433 if (hide_special && file_is_special(conn, smb_fname_base)) {
1434 DEBUG(10,("is_visible_file: file %s is special.\n",
1435 entry ));
1436 ret = false;
1437 goto out;
1438 }
1439 }
1440
1441 ret = true;
1442 out:
1443 TALLOC_FREE(smb_fname_base);
1444 TALLOC_FREE(entry);
1445 return ret;
1446 }
1447
1448 static int smb_Dir_destructor(struct smb_Dir *dirp)
1449 {
1450 if (dirp->dir != NULL) {
1451 SMB_VFS_CLOSEDIR(dirp->conn,dirp->dir);
1452 if (dirp->fsp != NULL) {
1453 /*
1454 * The SMB_VFS_CLOSEDIR above
1455 * closes the underlying fd inside
1456 * dirp->fsp.
1457 */
1458 dirp->fsp->fh->fd = -1;
1459 if (dirp->fsp->dptr != NULL) {
1460 SMB_ASSERT(dirp->fsp->dptr->dir_hnd == dirp);
1461 dirp->fsp->dptr->dir_hnd = NULL;
1462 }
1463 dirp->fsp = NULL;
1464 }
1465 }
1466 if (dirp->conn->sconn && !dirp->conn->sconn->using_smb2) {
1467 dirp->conn->sconn->searches.dirhandles_open--;
1468 }
1469 return 0;
1470 }
1471
1472 /*******************************************************************
1473 Open a directory.
1474 ********************************************************************/
1475
1476 struct smb_Dir *OpenDir(TALLOC_CTX *mem_ctx, connection_struct *conn,
1477 const char *name,
1478 const char *mask,
1479 uint32 attr)
1480 {
1481 struct smb_Dir *dirp = talloc_zero(mem_ctx, struct smb_Dir);
1482 struct smbd_server_connection *sconn = conn->sconn;
1483
1484 if (!dirp) {
1485 return NULL;
1486 }
1487
1488 dirp->conn = conn;
1489 dirp->name_cache_size = lp_directory_name_cache_size(SNUM(conn));
1490
1491 dirp->dir_path = talloc_strdup(dirp, name);
1492 if (!dirp->dir_path) {
1493 errno = ENOMEM;
1494 goto fail;
1495 }
1496
1497 if (sconn && !sconn->using_smb2) {
1498 sconn->searches.dirhandles_open++;
1499 }
1500 talloc_set_destructor(dirp, smb_Dir_destructor);
1501
1502 dirp->dir = SMB_VFS_OPENDIR(conn, dirp->dir_path, mask, attr);
1503 if (!dirp->dir) {
1504 DEBUG(5,("OpenDir: Can't open %s. %s\n", dirp->dir_path,
1505 strerror(errno) ));
1506 goto fail;
1507 }
1508
1509 return dirp;
1510
1511 fail:
1512 TALLOC_FREE(dirp);
1513 return NULL;
1514 }
1515
1516 /*******************************************************************
1517 Open a directory from an fsp.
1518 ********************************************************************/
1519
1520 static struct smb_Dir *OpenDir_fsp(TALLOC_CTX *mem_ctx, connection_struct *conn,
1521 files_struct *fsp,
1522 const char *mask,
1523 uint32 attr)
1524 {
1525 struct smb_Dir *dirp = talloc_zero(mem_ctx, struct smb_Dir);
1526 struct smbd_server_connection *sconn = conn->sconn;
1527
1528 if (!dirp) {
1529 return NULL;
1530 }
1531
1532 dirp->conn = conn;
1533 dirp->name_cache_size = lp_directory_name_cache_size(SNUM(conn));
1534
1535 dirp->dir_path = talloc_strdup(dirp, fsp->fsp_name->base_name);
1536 if (!dirp->dir_path) {
1537 errno = ENOMEM;
1538 goto fail;
1539 }
1540
1541 if (sconn && !sconn->using_smb2) {
1542 sconn->searches.dirhandles_open++;
1543 }
1544 talloc_set_destructor(dirp, smb_Dir_destructor);
1545
1546 if (fsp->is_directory && fsp->fh->fd != -1) {
1547 dirp->dir = SMB_VFS_FDOPENDIR(fsp, mask, attr);
1548 if (dirp->dir != NULL) {
1549 dirp->fsp = fsp;
1550 } else {
1551 DEBUG(10,("OpenDir_fsp: SMB_VFS_FDOPENDIR on %s returned "
1552 "NULL (%s)\n",
1553 dirp->dir_path,
1554 strerror(errno)));
1555 if (errno != ENOSYS) {
1556 return NULL;
1557 }
1558 }
1559 }
1560
1561 if (dirp->dir == NULL) {
1562 /* FDOPENDIR didn't work. Use OPENDIR instead. */
1563 dirp->dir = SMB_VFS_OPENDIR(conn, dirp->dir_path, mask, attr);
1564 }
1565
1566 if (!dirp->dir) {
1567 DEBUG(5,("OpenDir_fsp: Can't open %s. %s\n", dirp->dir_path,
1568 strerror(errno) ));
1569 goto fail;
1570 }
1571
1572 return dirp;
1573
1574 fail:
1575 TALLOC_FREE(dirp);
1576 return NULL;
1577 }
1578
1579
1580 /*******************************************************************
1581 Read from a directory.
1582 Return directory entry, current offset, and optional stat information.
1583 Don't check for veto or invisible files.
1584 ********************************************************************/
1585
1586 const char *ReadDirName(struct smb_Dir *dirp, long *poffset,
1587 SMB_STRUCT_STAT *sbuf, char **ptalloced)
1588 {
1589 const char *n;
1590 char *talloced = NULL;
1591 connection_struct *conn = dirp->conn;
1592
1593 /* Cheat to allow . and .. to be the first entries returned. */
1594 if (((*poffset == START_OF_DIRECTORY_OFFSET) ||
1595 (*poffset == DOT_DOT_DIRECTORY_OFFSET)) && (dirp->file_number < 2))
1596 {
1597 if (dirp->file_number == 0) {
1598 n = ".";
1599 *poffset = dirp->offset = START_OF_DIRECTORY_OFFSET;
1600 } else {
1601 n = "..";
1602 *poffset = dirp->offset = DOT_DOT_DIRECTORY_OFFSET;
1603 }
1604 dirp->file_number++;
1605 *ptalloced = NULL;
1606 return n;
1607 } else if (*poffset == END_OF_DIRECTORY_OFFSET) {
1608 *poffset = dirp->offset = END_OF_DIRECTORY_OFFSET;
1609 return NULL;
1610 } else {
1611 /* A real offset, seek to it. */
1612 SeekDir(dirp, *poffset);
1613 }
1614
1615 while ((n = vfs_readdirname(conn, dirp->dir, sbuf, &talloced))) {
1616 /* Ignore . and .. - we've already returned them. */
1617 if (*n == '.') {
1618 if ((n[1] == '\0') || (n[1] == '.' && n[2] == '\0')) {
1619 TALLOC_FREE(talloced);
1620 continue;
1621 }
1622 }
1623 *poffset = dirp->offset = SMB_VFS_TELLDIR(conn, dirp->dir);
1624 *ptalloced = talloced;
1625 dirp->file_number++;
1626 return n;
1627 }
1628 *poffset = dirp->offset = END_OF_DIRECTORY_OFFSET;
1629 *ptalloced = NULL;
1630 return NULL;
1631 }
1632
1633 /*******************************************************************
1634 Rewind to the start.
1635 ********************************************************************/
1636
1637 void RewindDir(struct smb_Dir *dirp, long *poffset)
1638 {
1639 SMB_VFS_REWINDDIR(dirp->conn, dirp->dir);
1640 dirp->file_number = 0;
1641 dirp->offset = START_OF_DIRECTORY_OFFSET;
1642 *poffset = START_OF_DIRECTORY_OFFSET;
1643 }
1644
1645 /*******************************************************************
1646 Seek a dir.
1647 ********************************************************************/
1648
1649 void SeekDir(struct smb_Dir *dirp, long offset)
1650 {
1651 if (offset != dirp->offset) {
1652 if (offset == START_OF_DIRECTORY_OFFSET) {
1653 RewindDir(dirp, &offset);
1654 /*
1655 * Ok we should really set the file number here
1656 * to 1 to enable ".." to be returned next. Trouble
1657 * is I'm worried about callers using SeekDir(dirp,0)
1658 * as equivalent to RewindDir(). So leave this alone
1659 * for now.
1660 */
1661 } else if (offset == DOT_DOT_DIRECTORY_OFFSET) {
1662 RewindDir(dirp, &offset);
1663 /*
1664 * Set the file number to 2 - we want to get the first
1665 * real file entry (the one we return after "..")
1666 * on the next ReadDir.
1667 */
1668 dirp->file_number = 2;
1669 } else if (offset == END_OF_DIRECTORY_OFFSET) {
1670 ; /* Don't seek in this case. */
1671 } else {
1672 SMB_VFS_SEEKDIR(dirp->conn, dirp->dir, offset);
1673 }
1674 dirp->offset = offset;
1675 }
1676 }
1677
1678 /*******************************************************************
1679 Tell a dir position.
1680 ********************************************************************/
1681
1682 long TellDir(struct smb_Dir *dirp)
1683 {
1684 return(dirp->offset);
1685 }
1686
1687 /*******************************************************************
1688 Add an entry into the dcache.
1689 ********************************************************************/
1690
1691 void DirCacheAdd(struct smb_Dir *dirp, const char *name, long offset)
1692 {
1693 struct name_cache_entry *e;
1694
1695 if (dirp->name_cache_size == 0) {
1696 return;
1697 }
1698
1699 if (dirp->name_cache == NULL) {
1700 dirp->name_cache = talloc_zero_array(
1701 dirp, struct name_cache_entry, dirp->name_cache_size);
1702
1703 if (dirp->name_cache == NULL) {
1704 return;
1705 }
1706 }
1707
1708 dirp->name_cache_index = (dirp->name_cache_index+1) %
1709 dirp->name_cache_size;
1710 e = &dirp->name_cache[dirp->name_cache_index];
1711 TALLOC_FREE(e->name);
1712 e->name = talloc_strdup(dirp, name);
1713 e->offset = offset;
1714 }
1715
1716 /*******************************************************************
1717 Find an entry by name. Leave us at the offset after it.
1718 Don't check for veto or invisible files.
1719 ********************************************************************/
1720
1721 bool SearchDir(struct smb_Dir *dirp, const char *name, long *poffset)
1722 {
1723 int i;
1724 const char *entry = NULL;
1725 char *talloced = NULL;
1726 connection_struct *conn = dirp->conn;
1727
1728 /* Search back in the name cache. */
1729 if (dirp->name_cache_size && dirp->name_cache) {
1730 for (i = dirp->name_cache_index; i >= 0; i--) {
1731 struct name_cache_entry *e = &dirp->name_cache[i];
1732 if (e->name && (conn->case_sensitive ? (strcmp(e->name, name) == 0) : strequal(e->name, name))) {
1733 *poffset = e->offset;
1734 SeekDir(dirp, e->offset);
1735 return True;
1736 }
1737 }
1738 for (i = dirp->name_cache_size - 1; i > dirp->name_cache_index; i--) {
1739 struct name_cache_entry *e = &dirp->name_cache[i];
1740 if (e->name && (conn->case_sensitive ? (strcmp(e->name, name) == 0) : strequal(e->name, name))) {
1741 *poffset = e->offset;
1742 SeekDir(dirp, e->offset);
1743 return True;
1744 }
1745 }
1746 }
1747
1748 /* Not found in the name cache. Rewind directory and start from scratch. */
1749 SMB_VFS_REWINDDIR(conn, dirp->dir);
1750 dirp->file_number = 0;
1751 *poffset = START_OF_DIRECTORY_OFFSET;
1752 while ((entry = ReadDirName(dirp, poffset, NULL, &talloced))) {
1753 if (conn->case_sensitive ? (strcmp(entry, name) == 0) : strequal(entry, name)) {
1754 TALLOC_FREE(talloced);
1755 return True;
1756 }
1757 TALLOC_FREE(talloced);
1758 }
1759 return False;
1760 }
1761
1762 /*****************************************************************
1763 Is this directory empty ?
1764 *****************************************************************/
1765
1766 NTSTATUS can_delete_directory_fsp(files_struct *fsp)
1767 {
1768 NTSTATUS status = NT_STATUS_OK;
1769 long dirpos = 0;
1770 const char *dname = NULL;
1771 const char *dirname = fsp->fsp_name->base_name;
1772 char *talloced = NULL;
1773 SMB_STRUCT_STAT st;
1774 struct connection_struct *conn = fsp->conn;
1775 struct smb_Dir *dir_hnd = OpenDir_fsp(talloc_tos(),
1776 conn,
1777 fsp,
1778 NULL,
1779 0);
1780
1781 if (!dir_hnd) {
1782 return map_nt_error_from_unix(errno);
1783 }
1784
1785 while ((dname = ReadDirName(dir_hnd, &dirpos, &st, &talloced))) {
1786 /* Quick check for "." and ".." */
1787 if (dname[0] == '.') {
1788 if (!dname[1] || (dname[1] == '.' && !dname[2])) {
1789 TALLOC_FREE(talloced);
1790 continue;
1791 }
1792 }
1793
1794 if (!is_visible_file(conn, dirname, dname, &st, True)) {
1795 TALLOC_FREE(talloced);
1796 continue;
1797 }
1798
1799 DEBUG(10,("got name %s - can't delete\n",
1800 dname ));
1801 status = NT_STATUS_DIRECTORY_NOT_EMPTY;
1802 break;
1803 }
1804 TALLOC_FREE(talloced);
1805 TALLOC_FREE(dir_hnd);
1806
1807 return status;
1808 }
Samba GIT mirror