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