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