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