?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
tevent: call epoll_panic() if EPOLL_CTL_DEL failed
[Samba/gebeck_regimport.git] / source3 / smbd / dir.c
blob525f20ec7f58f6529fbb78ebe1377e81d38433b8
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 };
54
55 struct dptr_struct {
56 struct dptr_struct *next, *prev;
57 int dnum;
58 uint16 spid;
59 struct connection_struct *conn;
60 struct smb_Dir *dir_hnd;
61 bool expect_close;
62 char *wcard;
63 uint32 attr;
64 char *path;
65 bool has_wild; /* Set to true if the wcard entry has MS wildcard characters in it. */
66 bool did_stat; /* Optimisation for non-wcard searches. */
67 bool priv; /* Directory handle opened with privilege. */
68 };
69
70 static struct smb_Dir *OpenDir_fsp(TALLOC_CTX *mem_ctx, connection_struct *conn,
71 files_struct *fsp,
72 const char *mask,
73 uint32 attr);
74
75 #define INVALID_DPTR_KEY (-3)
76
77 /****************************************************************************
78 Make a dir struct.
79 ****************************************************************************/
80
81 bool make_dir_struct(TALLOC_CTX *ctx,
82 char *buf,
83 const char *mask,
84 const char *fname,
85 off_t size,
86 uint32 mode,
87 time_t date,
88 bool uc)
89 {
90 char *p;
91 char *mask2 = talloc_strdup(ctx, mask);
92
93 if (!mask2) {
94 return False;
95 }
96
97 if ((mode & FILE_ATTRIBUTE_DIRECTORY) != 0) {
98 size = 0;
99 }
100
101 memset(buf+1,' ',11);
102 if ((p = strchr_m(mask2,'.')) != NULL) {
103 *p = 0;
104 push_ascii(buf+1,mask2,8, 0);
105 push_ascii(buf+9,p+1,3, 0);
106 *p = '.';
107 } else {
108 push_ascii(buf+1,mask2,11, 0);
109 }
110
111 memset(buf+21,'\0',DIR_STRUCT_SIZE-21);
112 SCVAL(buf,21,mode);
113 srv_put_dos_date(buf,22,date);
114 SSVAL(buf,26,size & 0xFFFF);
115 SSVAL(buf,28,(size >> 16)&0xFFFF);
116 /* We only uppercase if FLAGS2_LONG_PATH_COMPONENTS is zero in the input buf.
117 Strange, but verified on W2K3. Needed for OS/2. JRA. */
118 push_ascii(buf+30,fname,12, uc ? STR_UPPER : 0);
119 DEBUG(8,("put name [%s] from [%s] into dir struct\n",buf+30, fname));
120 return True;
121 }
122
123 /****************************************************************************
124 Initialise the dir bitmap.
125 ****************************************************************************/
126
127 bool init_dptrs(struct smbd_server_connection *sconn)
128 {
129 if (sconn->searches.dptr_bmap) {
130 return true;
131 }
132
133 sconn->searches.dptr_bmap = bitmap_talloc(
134 sconn, MAX_DIRECTORY_HANDLES);
135
136 if (sconn->searches.dptr_bmap == NULL) {
137 return false;
138 }
139
140 return true;
141 }
142
143 /****************************************************************************
144 Idle a dptr - the directory is closed but the control info is kept.
145 ****************************************************************************/
146
147 static void dptr_idle(struct dptr_struct *dptr)
148 {
149 if (dptr->dir_hnd) {
150 DEBUG(4,("Idling dptr dnum %d\n",dptr->dnum));
151 TALLOC_FREE(dptr->dir_hnd);
152 }
153 }
154
155 /****************************************************************************
156 Idle the oldest dptr.
157 ****************************************************************************/
158
159 static void dptr_idleoldest(struct smbd_server_connection *sconn)
160 {
161 struct dptr_struct *dptr;
162
163 /*
164 * Go to the end of the list.
165 */
166 dptr = DLIST_TAIL(sconn->searches.dirptrs);
167
168 if(!dptr) {
169 DEBUG(0,("No dptrs available to idle ?\n"));
170 return;
171 }
172
173 /*
174 * Idle the oldest pointer.
175 */
176
177 for(; dptr; dptr = DLIST_PREV(dptr)) {
178 if (dptr->dir_hnd) {
179 dptr_idle(dptr);
180 return;
181 }
182 }
183 }
184
185 /****************************************************************************
186 Get the struct dptr_struct for a dir index.
187 ****************************************************************************/
188
189 static struct dptr_struct *dptr_get(struct smbd_server_connection *sconn,
190 int key, bool forclose)
191 {
192 struct dptr_struct *dptr;
193
194 for(dptr = sconn->searches.dirptrs; dptr; dptr = dptr->next) {
195 if(dptr->dnum == key) {
196 if (!forclose && !dptr->dir_hnd) {
197 if (sconn->searches.dirhandles_open >= MAX_OPEN_DIRECTORIES)
198 dptr_idleoldest(sconn);
199 DEBUG(4,("dptr_get: Reopening dptr key %d\n",key));
200 if (!(dptr->dir_hnd = OpenDir(
201 NULL, dptr->conn, dptr->path,
202 dptr->wcard, dptr->attr))) {
203 DEBUG(4,("dptr_get: Failed to open %s (%s)\n",dptr->path,
204 strerror(errno)));
205 return NULL;
206 }
207 }
208 DLIST_PROMOTE(sconn->searches.dirptrs,dptr);
209 return dptr;
210 }
211 }
212 return(NULL);
213 }
214
215 /****************************************************************************
216 Get the dir path for a dir index.
217 ****************************************************************************/
218
219 const char *dptr_path(struct smbd_server_connection *sconn, int key)
220 {
221 struct dptr_struct *dptr = dptr_get(sconn, key, false);
222 if (dptr)
223 return(dptr->path);
224 return(NULL);
225 }
226
227 /****************************************************************************
228 Get the dir wcard for a dir index.
229 ****************************************************************************/
230
231 const char *dptr_wcard(struct smbd_server_connection *sconn, int key)
232 {
233 struct dptr_struct *dptr = dptr_get(sconn, key, false);
234 if (dptr)
235 return(dptr->wcard);
236 return(NULL);
237 }
238
239 /****************************************************************************
240 Get the dir attrib for a dir index.
241 ****************************************************************************/
242
243 uint16 dptr_attr(struct smbd_server_connection *sconn, int key)
244 {
245 struct dptr_struct *dptr = dptr_get(sconn, key, false);
246 if (dptr)
247 return(dptr->attr);
248 return(0);
249 }
250
251 /****************************************************************************
252 Close a dptr (internal func).
253 ****************************************************************************/
254
255 static void dptr_close_internal(struct dptr_struct *dptr)
256 {
257 struct smbd_server_connection *sconn = dptr->conn->sconn;
258
259 DEBUG(4,("closing dptr key %d\n",dptr->dnum));
260
261 if (sconn == NULL) {
262 goto done;
263 }
264
265 if (sconn->using_smb2) {
266 goto done;
267 }
268
269 DLIST_REMOVE(sconn->searches.dirptrs, dptr);
270
271 /*
272 * Free the dnum in the bitmap. Remember the dnum value is always
273 * biased by one with respect to the bitmap.
274 */
275
276 if (!bitmap_query(sconn->searches.dptr_bmap, dptr->dnum - 1)) {
277 DEBUG(0,("dptr_close_internal : Error - closing dnum = %d and bitmap not set !\n",
278 dptr->dnum ));
279 }
280
281 bitmap_clear(sconn->searches.dptr_bmap, dptr->dnum - 1);
282
283 done:
284 TALLOC_FREE(dptr->dir_hnd);
285 TALLOC_FREE(dptr);
286 }
287
288 /****************************************************************************
289 Close a dptr given a key.
290 ****************************************************************************/
291
292 void dptr_close(struct smbd_server_connection *sconn, int *key)
293 {
294 struct dptr_struct *dptr;
295
296 if(*key == INVALID_DPTR_KEY)
297 return;
298
299 /* OS/2 seems to use -1 to indicate "close all directories" */
300 if (*key == -1) {
301 struct dptr_struct *next;
302 for(dptr = sconn->searches.dirptrs; dptr; dptr = next) {
303 next = dptr->next;
304 dptr_close_internal(dptr);
305 }
306 *key = INVALID_DPTR_KEY;
307 return;
308 }
309
310 dptr = dptr_get(sconn, *key, true);
311
312 if (!dptr) {
313 DEBUG(0,("Invalid key %d given to dptr_close\n", *key));
314 return;
315 }
316
317 dptr_close_internal(dptr);
318
319 *key = INVALID_DPTR_KEY;
320 }
321
322 /****************************************************************************
323 Close all dptrs for a cnum.
324 ****************************************************************************/
325
326 void dptr_closecnum(connection_struct *conn)
327 {
328 struct dptr_struct *dptr, *next;
329 struct smbd_server_connection *sconn = conn->sconn;
330
331 if (sconn == NULL) {
332 return;
333 }
334
335 for(dptr = sconn->searches.dirptrs; dptr; dptr = next) {
336 next = dptr->next;
337 if (dptr->conn == conn) {
338 dptr_close_internal(dptr);
339 }
340 }
341 }
342
343 /****************************************************************************
344 Idle all dptrs for a cnum.
345 ****************************************************************************/
346
347 void dptr_idlecnum(connection_struct *conn)
348 {
349 struct dptr_struct *dptr;
350 struct smbd_server_connection *sconn = conn->sconn;
351
352 if (sconn == NULL) {
353 return;
354 }
355
356 for(dptr = sconn->searches.dirptrs; dptr; dptr = dptr->next) {
357 if (dptr->conn == conn && dptr->dir_hnd) {
358 dptr_idle(dptr);
359 }
360 }
361 }
362
363 /****************************************************************************
364 Close a dptr that matches a given path, only if it matches the spid also.
365 ****************************************************************************/
366
367 void dptr_closepath(struct smbd_server_connection *sconn,
368 char *path,uint16 spid)
369 {
370 struct dptr_struct *dptr, *next;
371 for(dptr = sconn->searches.dirptrs; dptr; dptr = next) {
372 next = dptr->next;
373 if (spid == dptr->spid && strequal(dptr->path,path))
374 dptr_close_internal(dptr);
375 }
376 }
377
378 /****************************************************************************
379 Try and close the oldest handle not marked for
380 expect close in the hope that the client has
381 finished with that one.
382 ****************************************************************************/
383
384 static void dptr_close_oldest(struct smbd_server_connection *sconn,
385 bool old)
386 {
387 struct dptr_struct *dptr;
388
389 /*
390 * Go to the end of the list.
391 */
392 for(dptr = sconn->searches.dirptrs; dptr && dptr->next; dptr = dptr->next)
393 ;
394
395 if(!dptr) {
396 DEBUG(0,("No old dptrs available to close oldest ?\n"));
397 return;
398 }
399
400 /*
401 * If 'old' is true, close the oldest oldhandle dnum (ie. 1 < dnum < 256) that
402 * does not have expect_close set. If 'old' is false, close
403 * one of the new dnum handles.
404 */
405
406 for(; dptr; dptr = DLIST_PREV(dptr)) {
407 if ((old && (dptr->dnum < 256) && !dptr->expect_close) ||
408 (!old && (dptr->dnum > 255))) {
409 dptr_close_internal(dptr);
410 return;
411 }
412 }
413 }
414
415 /****************************************************************************
416 Safely do an OpenDir as root, ensuring we're in the right place.
417 ****************************************************************************/
418
419 static struct smb_Dir *open_dir_with_privilege(connection_struct *conn,
420 struct smb_request *req,
421 const char *path,
422 const char *wcard,
423 uint32_t attr)
424 {
425 NTSTATUS status;
426 struct smb_Dir *dir_hnd = NULL;
427 struct smb_filename *smb_fname_cwd = NULL;
428 char *saved_dir = vfs_GetWd(talloc_tos(), conn);
429 struct privilege_paths *priv_paths = req->priv_paths;
430 int ret;
431
432 if (saved_dir == NULL) {
433 return NULL;
434 }
435
436 if (vfs_ChDir(conn, path) == -1) {
437 return NULL;
438 }
439
440 /* Now check the stat value is the same. */
441 status = create_synthetic_smb_fname(talloc_tos(), ".",
442 NULL, NULL,
443 &smb_fname_cwd);
444
445 if (!NT_STATUS_IS_OK(status)) {
446 goto out;
447 }
448 ret = SMB_VFS_STAT(conn, smb_fname_cwd);
449 if (ret != 0) {
450 goto out;
451 }
452
453 if (!check_same_stat(&smb_fname_cwd->st, &priv_paths->parent_name.st)) {
454 DEBUG(0,("open_dir_with_privilege: stat mismatch between %s "
455 "and %s\n",
456 path,
457 smb_fname_str_dbg(&priv_paths->parent_name)));
458 goto out;
459 }
460
461 dir_hnd = OpenDir(NULL, conn, ".", wcard, attr);
462
463 out:
464
465 vfs_ChDir(conn, saved_dir);
466 return dir_hnd;
467 }
468
469 /****************************************************************************
470 Create a new dir ptr. If the flag old_handle is true then we must allocate
471 from the bitmap range 0 - 255 as old SMBsearch directory handles are only
472 one byte long. If old_handle is false we allocate from the range
473 256 - MAX_DIRECTORY_HANDLES. We bias the number we return by 1 to ensure
474 a directory handle is never zero.
475 wcard must not be zero.
476 ****************************************************************************/
477
478 NTSTATUS dptr_create(connection_struct *conn,
479 struct smb_request *req,
480 files_struct *fsp,
481 const char *path, bool old_handle, bool expect_close,uint16 spid,
482 const char *wcard, bool wcard_has_wild, uint32 attr, struct dptr_struct **dptr_ret)
483 {
484 struct smbd_server_connection *sconn = conn->sconn;
485 struct dptr_struct *dptr = NULL;
486 struct smb_Dir *dir_hnd;
487
488 if (fsp && fsp->is_directory && fsp->fh->fd != -1) {
489 path = fsp->fsp_name->base_name;
490 }
491
492 DEBUG(5,("dptr_create dir=%s\n", path));
493
494 if (sconn == NULL) {
495 DEBUG(0,("dptr_create: called with fake connection_struct\n"));
496 return NT_STATUS_INTERNAL_ERROR;
497 }
498
499 if (!wcard) {
500 return NT_STATUS_INVALID_PARAMETER;
501 }
502
503 if (fsp) {
504 if (!(fsp->access_mask & SEC_DIR_LIST)) {
505 DEBUG(5,("dptr_create: directory %s "
506 "not open for LIST access\n",
507 path));
508 return NT_STATUS_ACCESS_DENIED;
509 }
510 dir_hnd = OpenDir_fsp(NULL, conn, fsp, wcard, attr);
511 } else {
512 int ret;
513 bool backup_intent = (req && req->priv_paths);
514 struct smb_filename *smb_dname = NULL;
515 NTSTATUS status = create_synthetic_smb_fname(talloc_tos(),
516 path,
517 NULL,
518 NULL,
519 &smb_dname);
520 if (!NT_STATUS_IS_OK(status)) {
521 return status;
522 }
523 if (lp_posix_pathnames()) {
524 ret = SMB_VFS_LSTAT(conn, smb_dname);
525 } else {
526 ret = SMB_VFS_STAT(conn, smb_dname);
527 }
528 if (ret == -1) {
529 return map_nt_error_from_unix(errno);
530 }
531 if (!S_ISDIR(smb_dname->st.st_ex_mode)) {
532 return NT_STATUS_NOT_A_DIRECTORY;
533 }
534 status = smbd_check_access_rights(conn,
535 smb_dname,
536 backup_intent,
537 SEC_DIR_LIST);
538 if (!NT_STATUS_IS_OK(status)) {
539 return status;
540 }
541 if (backup_intent) {
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 bool needslash;
1042
1043 *_smb_fname = NULL;
1044 *_mode = 0;
1045
1046 needslash = ( dirptr->path[strlen(dirptr->path) -1] != '/');
1047
1048 while (true) {
1049 long cur_offset;
1050 long prev_offset;
1051 SMB_STRUCT_STAT sbuf;
1052 char *dname = NULL;
1053 bool isdots;
1054 char *fname = NULL;
1055 char *pathreal = NULL;
1056 struct smb_filename smb_fname;
1057 uint32_t mode = 0;
1058 bool ok;
1059 NTSTATUS status;
1060
1061 cur_offset = dptr_TellDir(dirptr);
1062 prev_offset = cur_offset;
1063 dname = dptr_ReadDirName(ctx, dirptr, &cur_offset, &sbuf);
1064
1065 DEBUG(6,("smbd_dirptr_get_entry: dirptr 0x%lx now at offset %ld\n",
1066 (long)dirptr, cur_offset));
1067
1068 if (dname == NULL) {
1069 return false;
1070 }
1071
1072 isdots = (ISDOT(dname) || ISDOTDOT(dname));
1073 if (dont_descend && !isdots) {
1074 TALLOC_FREE(dname);
1075 continue;
1076 }
1077
1078 /*
1079 * fname may get mangled, dname is never mangled.
1080 * Whenever we're accessing the filesystem we use
1081 * pathreal which is composed from dname.
1082 */
1083
1084 ok = match_fn(ctx, private_data, dname, mask, &fname);
1085 if (!ok) {
1086 TALLOC_FREE(dname);
1087 continue;
1088 }
1089
1090 pathreal = talloc_asprintf(ctx, "%s%s%s",
1091 dirptr->path,
1092 needslash?"/":"",
1093 dname);
1094 if (!pathreal) {
1095 TALLOC_FREE(dname);
1096 TALLOC_FREE(fname);
1097 return false;
1098 }
1099
1100 /* Create smb_fname with NULL stream_name. */
1101 ZERO_STRUCT(smb_fname);
1102 smb_fname.base_name = pathreal;
1103 smb_fname.st = sbuf;
1104
1105 ok = mode_fn(ctx, private_data, &smb_fname, &mode);
1106 if (!ok) {
1107 TALLOC_FREE(dname);
1108 TALLOC_FREE(fname);
1109 TALLOC_FREE(pathreal);
1110 continue;
1111 }
1112
1113 if (!dir_check_ftype(conn, mode, dirtype)) {
1114 DEBUG(5,("[%s] attribs 0x%x didn't match 0x%x\n",
1115 fname, (unsigned int)mode, (unsigned int)dirtype));
1116 TALLOC_FREE(dname);
1117 TALLOC_FREE(fname);
1118 TALLOC_FREE(pathreal);
1119 continue;
1120 }
1121
1122 if (ask_sharemode) {
1123 struct timespec write_time_ts;
1124 struct file_id fileid;
1125
1126 fileid = vfs_file_id_from_sbuf(conn,
1127 &smb_fname.st);
1128 get_file_infos(fileid, 0, NULL, &write_time_ts);
1129 if (!null_timespec(write_time_ts)) {
1130 update_stat_ex_mtime(&smb_fname.st,
1131 write_time_ts);
1132 }
1133 }
1134
1135 DEBUG(3,("smbd_dirptr_get_entry mask=[%s] found %s "
1136 "fname=%s (%s)\n",
1137 mask, smb_fname_str_dbg(&smb_fname),
1138 dname, fname));
1139
1140 DirCacheAdd(dirptr->dir_hnd, dname, cur_offset);
1141
1142 TALLOC_FREE(dname);
1143
1144 status = copy_smb_filename(ctx, &smb_fname, _smb_fname);
1145 TALLOC_FREE(pathreal);
1146 if (!NT_STATUS_IS_OK(status)) {
1147 return false;
1148 }
1149 *_fname = fname;
1150 *_mode = mode;
1151 *_prev_offset = prev_offset;
1152
1153 return true;
1154 }
1155
1156 return false;
1157 }
1158
1159 /****************************************************************************
1160 Get an 8.3 directory entry.
1161 ****************************************************************************/
1162
1163 static bool smbd_dirptr_8_3_match_fn(TALLOC_CTX *ctx,
1164 void *private_data,
1165 const char *dname,
1166 const char *mask,
1167 char **_fname)
1168 {
1169 connection_struct *conn = (connection_struct *)private_data;
1170
1171 if ((strcmp(mask,"*.*") == 0) ||
1172 mask_match_search(dname, mask, false) ||
1173 mangle_mask_match(conn, dname, mask)) {
1174 char mname[13];
1175 const char *fname;
1176
1177 if (!mangle_is_8_3(dname, false, conn->params)) {
1178 bool ok = name_to_8_3(dname, mname, false,
1179 conn->params);
1180 if (!ok) {
1181 return false;
1182 }
1183 fname = mname;
1184 } else {
1185 fname = dname;
1186 }
1187
1188 *_fname = talloc_strdup(ctx, fname);
1189 if (*_fname == NULL) {
1190 return false;
1191 }
1192
1193 return true;
1194 }
1195
1196 return false;
1197 }
1198
1199 static bool smbd_dirptr_8_3_mode_fn(TALLOC_CTX *ctx,
1200 void *private_data,
1201 struct smb_filename *smb_fname,
1202 uint32_t *_mode)
1203 {
1204 connection_struct *conn = (connection_struct *)private_data;
1205
1206 if (!VALID_STAT(smb_fname->st)) {
1207 if ((SMB_VFS_STAT(conn, smb_fname)) != 0) {
1208 DEBUG(5,("smbd_dirptr_8_3_mode_fn: "
1209 "Couldn't stat [%s]. Error "
1210 "= %s\n",
1211 smb_fname_str_dbg(smb_fname),
1212 strerror(errno)));
1213 return false;
1214 }
1215 }
1216
1217 *_mode = dos_mode(conn, smb_fname);
1218 return true;
1219 }
1220
1221 bool get_dir_entry(TALLOC_CTX *ctx,
1222 struct dptr_struct *dirptr,
1223 const char *mask,
1224 uint32_t dirtype,
1225 char **_fname,
1226 off_t *_size,
1227 uint32_t *_mode,
1228 struct timespec *_date,
1229 bool check_descend,
1230 bool ask_sharemode)
1231 {
1232 connection_struct *conn = dirptr->conn;
1233 char *fname = NULL;
1234 struct smb_filename *smb_fname = NULL;
1235 uint32_t mode = 0;
1236 long prev_offset;
1237 bool ok;
1238
1239 ok = smbd_dirptr_get_entry(ctx,
1240 dirptr,
1241 mask,
1242 dirtype,
1243 check_descend,
1244 ask_sharemode,
1245 smbd_dirptr_8_3_match_fn,
1246 smbd_dirptr_8_3_mode_fn,
1247 conn,
1248 &fname,
1249 &smb_fname,
1250 &mode,
1251 &prev_offset);
1252 if (!ok) {
1253 return false;
1254 }
1255
1256 *_fname = talloc_move(ctx, &fname);
1257 *_size = smb_fname->st.st_ex_size;
1258 *_mode = mode;
1259 *_date = smb_fname->st.st_ex_mtime;
1260 TALLOC_FREE(smb_fname);
1261 return true;
1262 }
1263
1264 /*******************************************************************
1265 Check to see if a user can read a file. This is only approximate,
1266 it is used as part of the "hide unreadable" option. Don't
1267 use it for anything security sensitive.
1268 ********************************************************************/
1269
1270 static bool user_can_read_file(connection_struct *conn,
1271 struct smb_filename *smb_fname)
1272 {
1273 /*
1274 * Never hide files from the root user.
1275 * We use (uid_t)0 here not sec_initial_uid()
1276 * as make test uses a single user context.
1277 */
1278
1279 if (get_current_uid(conn) == (uid_t)0) {
1280 return True;
1281 }
1282
1283 return NT_STATUS_IS_OK(smbd_check_access_rights(conn,
1284 smb_fname,
1285 false,
1286 FILE_READ_DATA));
1287 }
1288
1289 /*******************************************************************
1290 Check to see if a user can write a file (and only files, we do not
1291 check dirs on this one). This is only approximate,
1292 it is used as part of the "hide unwriteable" option. Don't
1293 use it for anything security sensitive.
1294 ********************************************************************/
1295
1296 static bool user_can_write_file(connection_struct *conn,
1297 const struct smb_filename *smb_fname)
1298 {
1299 /*
1300 * Never hide files from the root user.
1301 * We use (uid_t)0 here not sec_initial_uid()
1302 * as make test uses a single user context.
1303 */
1304
1305 if (get_current_uid(conn) == (uid_t)0) {
1306 return True;
1307 }
1308
1309 SMB_ASSERT(VALID_STAT(smb_fname->st));
1310
1311 /* Pseudo-open the file */
1312
1313 if(S_ISDIR(smb_fname->st.st_ex_mode)) {
1314 return True;
1315 }
1316
1317 return can_write_to_file(conn, smb_fname);
1318 }
1319
1320 /*******************************************************************
1321 Is a file a "special" type ?
1322 ********************************************************************/
1323
1324 static bool file_is_special(connection_struct *conn,
1325 const struct smb_filename *smb_fname)
1326 {
1327 /*
1328 * Never hide files from the root user.
1329 * We use (uid_t)0 here not sec_initial_uid()
1330 * as make test uses a single user context.
1331 */
1332
1333 if (get_current_uid(conn) == (uid_t)0) {
1334 return False;
1335 }
1336
1337 SMB_ASSERT(VALID_STAT(smb_fname->st));
1338
1339 if (S_ISREG(smb_fname->st.st_ex_mode) ||
1340 S_ISDIR(smb_fname->st.st_ex_mode) ||
1341 S_ISLNK(smb_fname->st.st_ex_mode))
1342 return False;
1343
1344 return True;
1345 }
1346
1347 /*******************************************************************
1348 Should the file be seen by the client?
1349 NOTE: A successful return is no guarantee of the file's existence.
1350 ********************************************************************/
1351
1352 bool is_visible_file(connection_struct *conn, const char *dir_path,
1353 const char *name, SMB_STRUCT_STAT *pst, bool use_veto)
1354 {
1355 bool hide_unreadable = lp_hideunreadable(SNUM(conn));
1356 bool hide_unwriteable = lp_hideunwriteable_files(SNUM(conn));
1357 bool hide_special = lp_hide_special_files(SNUM(conn));
1358 char *entry = NULL;
1359 struct smb_filename *smb_fname_base = NULL;
1360 NTSTATUS status;
1361 bool ret = false;
1362
1363 if ((strcmp(".",name) == 0) || (strcmp("..",name) == 0)) {
1364 return True; /* . and .. are always visible. */
1365 }
1366
1367 /* If it's a vetoed file, pretend it doesn't even exist */
1368 if (use_veto && IS_VETO_PATH(conn, name)) {
1369 DEBUG(10,("is_visible_file: file %s is vetoed.\n", name ));
1370 return False;
1371 }
1372
1373 if (hide_unreadable || hide_unwriteable || hide_special) {
1374 entry = talloc_asprintf(talloc_tos(), "%s/%s", dir_path, name);
1375 if (!entry) {
1376 ret = false;
1377 goto out;
1378 }
1379
1380 /* Create an smb_filename with stream_name == NULL. */
1381 status = create_synthetic_smb_fname(talloc_tos(), entry, NULL,
1382 pst, &smb_fname_base);
1383 if (!NT_STATUS_IS_OK(status)) {
1384 ret = false;
1385 goto out;
1386 }
1387
1388 /* If the file name does not exist, there's no point checking
1389 * the configuration options. We succeed, on the basis that the
1390 * checks *might* have passed if the file was present.
1391 */
1392 if (!VALID_STAT(*pst)) {
1393 if (SMB_VFS_STAT(conn, smb_fname_base) != 0) {
1394 ret = true;
1395 goto out;
1396 } else {
1397 *pst = smb_fname_base->st;
1398 }
1399 }
1400
1401 /* Honour _hide unreadable_ option */
1402 if (hide_unreadable &&
1403 !user_can_read_file(conn, smb_fname_base)) {
1404 DEBUG(10,("is_visible_file: file %s is unreadable.\n",
1405 entry ));
1406 ret = false;
1407 goto out;
1408 }
1409 /* Honour _hide unwriteable_ option */
1410 if (hide_unwriteable && !user_can_write_file(conn,
1411 smb_fname_base)) {
1412 DEBUG(10,("is_visible_file: file %s is unwritable.\n",
1413 entry ));
1414 ret = false;
1415 goto out;
1416 }
1417 /* Honour _hide_special_ option */
1418 if (hide_special && file_is_special(conn, smb_fname_base)) {
1419 DEBUG(10,("is_visible_file: file %s is special.\n",
1420 entry ));
1421 ret = false;
1422 goto out;
1423 }
1424 }
1425
1426 ret = true;
1427 out:
1428 TALLOC_FREE(smb_fname_base);
1429 TALLOC_FREE(entry);
1430 return ret;
1431 }
1432
1433 static int smb_Dir_destructor(struct smb_Dir *dirp)
1434 {
1435 if (dirp->dir) {
1436 #ifdef HAVE_DIRFD
1437 if (dirp->conn->sconn) {
1438 files_struct *fsp = file_find_fd(dirp->conn->sconn,
1439 dirfd(dirp->dir));
1440 if (fsp) {
1441 /* The call below closes the underlying fd. */
1442 fsp->fh->fd = -1;
1443 }
1444 }
1445 #endif
1446 SMB_VFS_CLOSEDIR(dirp->conn,dirp->dir);
1447 }
1448 if (dirp->conn->sconn && !dirp->conn->sconn->using_smb2) {
1449 dirp->conn->sconn->searches.dirhandles_open--;
1450 }
1451 return 0;
1452 }
1453
1454 /*******************************************************************
1455 Open a directory.
1456 ********************************************************************/
1457
1458 struct smb_Dir *OpenDir(TALLOC_CTX *mem_ctx, connection_struct *conn,
1459 const char *name,
1460 const char *mask,
1461 uint32 attr)
1462 {
1463 struct smb_Dir *dirp = talloc_zero(mem_ctx, struct smb_Dir);
1464 struct smbd_server_connection *sconn = conn->sconn;
1465
1466 if (!dirp) {
1467 return NULL;
1468 }
1469
1470 dirp->conn = conn;
1471 dirp->name_cache_size = lp_directory_name_cache_size(SNUM(conn));
1472
1473 dirp->dir_path = talloc_strdup(dirp, name);
1474 if (!dirp->dir_path) {
1475 errno = ENOMEM;
1476 goto fail;
1477 }
1478
1479 if (sconn && !sconn->using_smb2) {
1480 sconn->searches.dirhandles_open++;
1481 }
1482 talloc_set_destructor(dirp, smb_Dir_destructor);
1483
1484 dirp->dir = SMB_VFS_OPENDIR(conn, dirp->dir_path, mask, attr);
1485 if (!dirp->dir) {
1486 DEBUG(5,("OpenDir: Can't open %s. %s\n", dirp->dir_path,
1487 strerror(errno) ));
1488 goto fail;
1489 }
1490
1491 return dirp;
1492
1493 fail:
1494 TALLOC_FREE(dirp);
1495 return NULL;
1496 }
1497
1498 /*******************************************************************
1499 Open a directory from an fsp.
1500 ********************************************************************/
1501
1502 static struct smb_Dir *OpenDir_fsp(TALLOC_CTX *mem_ctx, connection_struct *conn,
1503 files_struct *fsp,
1504 const char *mask,
1505 uint32 attr)
1506 {
1507 struct smb_Dir *dirp = talloc_zero(mem_ctx, struct smb_Dir);
1508 struct smbd_server_connection *sconn = conn->sconn;
1509
1510 if (!dirp) {
1511 return NULL;
1512 }
1513
1514 dirp->conn = conn;
1515 dirp->name_cache_size = lp_directory_name_cache_size(SNUM(conn));
1516
1517 dirp->dir_path = talloc_strdup(dirp, fsp->fsp_name->base_name);
1518 if (!dirp->dir_path) {
1519 errno = ENOMEM;
1520 goto fail;
1521 }
1522
1523 if (sconn && !sconn->using_smb2) {
1524 sconn->searches.dirhandles_open++;
1525 }
1526 talloc_set_destructor(dirp, smb_Dir_destructor);
1527
1528 if (fsp->is_directory && fsp->fh->fd != -1) {
1529 dirp->dir = SMB_VFS_FDOPENDIR(fsp, mask, attr);
1530 if (dirp->dir == NULL) {
1531 DEBUG(10,("OpenDir_fsp: SMB_VFS_FDOPENDIR on %s returned "
1532 "NULL (%s)\n",
1533 dirp->dir_path,
1534 strerror(errno)));
1535 if (errno != ENOSYS) {
1536 return NULL;
1537 }
1538 }
1539 }
1540
1541 if (dirp->dir == NULL) {
1542 /* FDOPENDIR didn't work. Use OPENDIR instead. */
1543 dirp->dir = SMB_VFS_OPENDIR(conn, dirp->dir_path, mask, attr);
1544 }
1545
1546 if (!dirp->dir) {
1547 DEBUG(5,("OpenDir_fsp: Can't open %s. %s\n", dirp->dir_path,
1548 strerror(errno) ));
1549 goto fail;
1550 }
1551
1552 return dirp;
1553
1554 fail:
1555 TALLOC_FREE(dirp);
1556 return NULL;
1557 }
1558
1559
1560 /*******************************************************************
1561 Read from a directory.
1562 Return directory entry, current offset, and optional stat information.
1563 Don't check for veto or invisible files.
1564 ********************************************************************/
1565
1566 const char *ReadDirName(struct smb_Dir *dirp, long *poffset,
1567 SMB_STRUCT_STAT *sbuf, char **ptalloced)
1568 {
1569 const char *n;
1570 char *talloced = NULL;
1571 connection_struct *conn = dirp->conn;
1572
1573 /* Cheat to allow . and .. to be the first entries returned. */
1574 if (((*poffset == START_OF_DIRECTORY_OFFSET) ||
1575 (*poffset == DOT_DOT_DIRECTORY_OFFSET)) && (dirp->file_number < 2))
1576 {
1577 if (dirp->file_number == 0) {
1578 n = ".";
1579 *poffset = dirp->offset = START_OF_DIRECTORY_OFFSET;
1580 } else {
1581 n = "..";
1582 *poffset = dirp->offset = DOT_DOT_DIRECTORY_OFFSET;
1583 }
1584 dirp->file_number++;
1585 *ptalloced = NULL;
1586 return n;
1587 } else if (*poffset == END_OF_DIRECTORY_OFFSET) {
1588 *poffset = dirp->offset = END_OF_DIRECTORY_OFFSET;
1589 return NULL;
1590 } else {
1591 /* A real offset, seek to it. */
1592 SeekDir(dirp, *poffset);
1593 }
1594
1595 while ((n = vfs_readdirname(conn, dirp->dir, sbuf, &talloced))) {
1596 /* Ignore . and .. - we've already returned them. */
1597 if (*n == '.') {
1598 if ((n[1] == '\0') || (n[1] == '.' && n[2] == '\0')) {
1599 TALLOC_FREE(talloced);
1600 continue;
1601 }
1602 }
1603 *poffset = dirp->offset = SMB_VFS_TELLDIR(conn, dirp->dir);
1604 *ptalloced = talloced;
1605 dirp->file_number++;
1606 return n;
1607 }
1608 *poffset = dirp->offset = END_OF_DIRECTORY_OFFSET;
1609 *ptalloced = NULL;
1610 return NULL;
1611 }
1612
1613 /*******************************************************************
1614 Rewind to the start.
1615 ********************************************************************/
1616
1617 void RewindDir(struct smb_Dir *dirp, long *poffset)
1618 {
1619 SMB_VFS_REWINDDIR(dirp->conn, dirp->dir);
1620 dirp->file_number = 0;
1621 dirp->offset = START_OF_DIRECTORY_OFFSET;
1622 *poffset = START_OF_DIRECTORY_OFFSET;
1623 }
1624
1625 /*******************************************************************
1626 Seek a dir.
1627 ********************************************************************/
1628
1629 void SeekDir(struct smb_Dir *dirp, long offset)
1630 {
1631 if (offset != dirp->offset) {
1632 if (offset == START_OF_DIRECTORY_OFFSET) {
1633 RewindDir(dirp, &offset);
1634 /*
1635 * Ok we should really set the file number here
1636 * to 1 to enable ".." to be returned next. Trouble
1637 * is I'm worried about callers using SeekDir(dirp,0)
1638 * as equivalent to RewindDir(). So leave this alone
1639 * for now.
1640 */
1641 } else if (offset == DOT_DOT_DIRECTORY_OFFSET) {
1642 RewindDir(dirp, &offset);
1643 /*
1644 * Set the file number to 2 - we want to get the first
1645 * real file entry (the one we return after "..")
1646 * on the next ReadDir.
1647 */
1648 dirp->file_number = 2;
1649 } else if (offset == END_OF_DIRECTORY_OFFSET) {
1650 ; /* Don't seek in this case. */
1651 } else {
1652 SMB_VFS_SEEKDIR(dirp->conn, dirp->dir, offset);
1653 }
1654 dirp->offset = offset;
1655 }
1656 }
1657
1658 /*******************************************************************
1659 Tell a dir position.
1660 ********************************************************************/
1661
1662 long TellDir(struct smb_Dir *dirp)
1663 {
1664 return(dirp->offset);
1665 }
1666
1667 /*******************************************************************
1668 Add an entry into the dcache.
1669 ********************************************************************/
1670
1671 void DirCacheAdd(struct smb_Dir *dirp, const char *name, long offset)
1672 {
1673 struct name_cache_entry *e;
1674
1675 if (dirp->name_cache_size == 0) {
1676 return;
1677 }
1678
1679 if (dirp->name_cache == NULL) {
1680 dirp->name_cache = talloc_zero_array(
1681 dirp, struct name_cache_entry, dirp->name_cache_size);
1682
1683 if (dirp->name_cache == NULL) {
1684 return;
1685 }
1686 }
1687
1688 dirp->name_cache_index = (dirp->name_cache_index+1) %
1689 dirp->name_cache_size;
1690 e = &dirp->name_cache[dirp->name_cache_index];
1691 TALLOC_FREE(e->name);
1692 e->name = talloc_strdup(dirp, name);
1693 e->offset = offset;
1694 }
1695
1696 /*******************************************************************
1697 Find an entry by name. Leave us at the offset after it.
1698 Don't check for veto or invisible files.
1699 ********************************************************************/
1700
1701 bool SearchDir(struct smb_Dir *dirp, const char *name, long *poffset)
1702 {
1703 int i;
1704 const char *entry = NULL;
1705 char *talloced = NULL;
1706 connection_struct *conn = dirp->conn;
1707
1708 /* Search back in the name cache. */
1709 if (dirp->name_cache_size && dirp->name_cache) {
1710 for (i = dirp->name_cache_index; i >= 0; i--) {
1711 struct name_cache_entry *e = &dirp->name_cache[i];
1712 if (e->name && (conn->case_sensitive ? (strcmp(e->name, name) == 0) : strequal(e->name, name))) {
1713 *poffset = e->offset;
1714 SeekDir(dirp, e->offset);
1715 return True;
1716 }
1717 }
1718 for (i = dirp->name_cache_size - 1; i > dirp->name_cache_index; i--) {
1719 struct name_cache_entry *e = &dirp->name_cache[i];
1720 if (e->name && (conn->case_sensitive ? (strcmp(e->name, name) == 0) : strequal(e->name, name))) {
1721 *poffset = e->offset;
1722 SeekDir(dirp, e->offset);
1723 return True;
1724 }
1725 }
1726 }
1727
1728 /* Not found in the name cache. Rewind directory and start from scratch. */
1729 SMB_VFS_REWINDDIR(conn, dirp->dir);
1730 dirp->file_number = 0;
1731 *poffset = START_OF_DIRECTORY_OFFSET;
1732 while ((entry = ReadDirName(dirp, poffset, NULL, &talloced))) {
1733 if (conn->case_sensitive ? (strcmp(entry, name) == 0) : strequal(entry, name)) {
1734 TALLOC_FREE(talloced);
1735 return True;
1736 }
1737 TALLOC_FREE(talloced);
1738 }
1739 return False;
1740 }
1741
1742 /*****************************************************************
1743 Is this directory empty ?
1744 *****************************************************************/
1745
1746 NTSTATUS can_delete_directory_fsp(files_struct *fsp)
1747 {
1748 NTSTATUS status = NT_STATUS_OK;
1749 long dirpos = 0;
1750 const char *dname = NULL;
1751 const char *dirname = fsp->fsp_name->base_name;
1752 char *talloced = NULL;
1753 SMB_STRUCT_STAT st;
1754 struct connection_struct *conn = fsp->conn;
1755 struct smb_Dir *dir_hnd = OpenDir_fsp(talloc_tos(),
1756 conn,
1757 fsp,
1758 NULL,
1759 0);
1760
1761 if (!dir_hnd) {
1762 return map_nt_error_from_unix(errno);
1763 }
1764
1765 while ((dname = ReadDirName(dir_hnd, &dirpos, &st, &talloced))) {
1766 /* Quick check for "." and ".." */
1767 if (dname[0] == '.') {
1768 if (!dname[1] || (dname[1] == '.' && !dname[2])) {
1769 TALLOC_FREE(talloced);
1770 continue;
1771 }
1772 }
1773
1774 if (!is_visible_file(conn, dirname, dname, &st, True)) {
1775 TALLOC_FREE(talloced);
1776 continue;
1777 }
1778
1779 DEBUG(10,("got name %s - can't delete\n",
1780 dname ));
1781 status = NT_STATUS_DIRECTORY_NOT_EMPTY;
1782 break;
1783 }
1784 TALLOC_FREE(talloced);
1785 TALLOC_FREE(dir_hnd);
1786
1787 return status;
1788 }
reg import