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