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