?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
pyldb: Raise proper exception when attempting to assign a string to a dn
[Samba/fernandojvsilva.git] / source3 / smbd / dir.c
blob642fb09362c0c86428e64d3132a404e38acbca01
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 "smbd/globals.h"
23
24 /*
25 This module implements directory related functions for Samba.
26 */
27
28 /* "Special" directory offsets. */
29 #define END_OF_DIRECTORY_OFFSET ((long)-1)
30 #define START_OF_DIRECTORY_OFFSET ((long)0)
31 #define DOT_DOT_DIRECTORY_OFFSET ((long)0x80000000)
32
33 /* Make directory handle internals available. */
34
35 struct name_cache_entry {
36 char *name;
37 long offset;
38 };
39
40 struct smb_Dir {
41 connection_struct *conn;
42 SMB_STRUCT_DIR *dir;
43 long offset;
44 char *dir_path;
45 size_t name_cache_size;
46 struct name_cache_entry *name_cache;
47 unsigned int name_cache_index;
48 unsigned int file_number;
49 };
50
51 struct dptr_struct {
52 struct dptr_struct *next, *prev;
53 int dnum;
54 uint16 spid;
55 struct connection_struct *conn;
56 struct smb_Dir *dir_hnd;
57 bool expect_close;
58 char *wcard;
59 uint32 attr;
60 char *path;
61 bool has_wild; /* Set to true if the wcard entry has MS wildcard characters in it. */
62 bool did_stat; /* Optimisation for non-wcard searches. */
63 };
64
65
66 #define INVALID_DPTR_KEY (-3)
67
68 /****************************************************************************
69 Make a dir struct.
70 ****************************************************************************/
71
72 bool make_dir_struct(TALLOC_CTX *ctx,
73 char *buf,
74 const char *mask,
75 const char *fname,
76 SMB_OFF_T size,
77 uint32 mode,
78 time_t date,
79 bool uc)
80 {
81 char *p;
82 char *mask2 = talloc_strdup(ctx, mask);
83
84 if (!mask2) {
85 return False;
86 }
87
88 if ((mode & aDIR) != 0) {
89 size = 0;
90 }
91
92 memset(buf+1,' ',11);
93 if ((p = strchr_m(mask2,'.')) != NULL) {
94 *p = 0;
95 push_ascii(buf+1,mask2,8, 0);
96 push_ascii(buf+9,p+1,3, 0);
97 *p = '.';
98 } else {
99 push_ascii(buf+1,mask2,11, 0);
100 }
101
102 memset(buf+21,'\0',DIR_STRUCT_SIZE-21);
103 SCVAL(buf,21,mode);
104 srv_put_dos_date(buf,22,date);
105 SSVAL(buf,26,size & 0xFFFF);
106 SSVAL(buf,28,(size >> 16)&0xFFFF);
107 /* We only uppercase if FLAGS2_LONG_PATH_COMPONENTS is zero in the input buf.
108 Strange, but verified on W2K3. Needed for OS/2. JRA. */
109 push_ascii(buf+30,fname,12, uc ? STR_UPPER : 0);
110 DEBUG(8,("put name [%s] from [%s] into dir struct\n",buf+30, fname));
111 return True;
112 }
113
114 /****************************************************************************
115 Initialise the dir bitmap.
116 ****************************************************************************/
117
118 void init_dptrs(void)
119 {
120 if (dptr_bmap)
121 return;
122
123 dptr_bmap = bitmap_allocate(MAX_DIRECTORY_HANDLES);
124
125 if (!dptr_bmap)
126 exit_server("out of memory in init_dptrs");
127 }
128
129 /****************************************************************************
130 Idle a dptr - the directory is closed but the control info is kept.
131 ****************************************************************************/
132
133 static void dptr_idle(struct dptr_struct *dptr)
134 {
135 if (dptr->dir_hnd) {
136 DEBUG(4,("Idling dptr dnum %d\n",dptr->dnum));
137 TALLOC_FREE(dptr->dir_hnd);
138 }
139 }
140
141 /****************************************************************************
142 Idle the oldest dptr.
143 ****************************************************************************/
144
145 static void dptr_idleoldest(void)
146 {
147 struct dptr_struct *dptr;
148
149 /*
150 * Go to the end of the list.
151 */
152 for(dptr = dirptrs; dptr && dptr->next; dptr = dptr->next)
153 ;
154
155 if(!dptr) {
156 DEBUG(0,("No dptrs available to idle ?\n"));
157 return;
158 }
159
160 /*
161 * Idle the oldest pointer.
162 */
163
164 for(; dptr; dptr = dptr->prev) {
165 if (dptr->dir_hnd) {
166 dptr_idle(dptr);
167 return;
168 }
169 }
170 }
171
172 /****************************************************************************
173 Get the struct dptr_struct for a dir index.
174 ****************************************************************************/
175
176 static struct dptr_struct *dptr_get(int key, bool forclose)
177 {
178 struct dptr_struct *dptr;
179
180 for(dptr = dirptrs; dptr; dptr = dptr->next) {
181 if(dptr->dnum == key) {
182 if (!forclose && !dptr->dir_hnd) {
183 if (dirhandles_open >= MAX_OPEN_DIRECTORIES)
184 dptr_idleoldest();
185 DEBUG(4,("dptr_get: Reopening dptr key %d\n",key));
186 if (!(dptr->dir_hnd = OpenDir(
187 NULL, dptr->conn, dptr->path,
188 dptr->wcard, dptr->attr))) {
189 DEBUG(4,("dptr_get: Failed to open %s (%s)\n",dptr->path,
190 strerror(errno)));
191 return False;
192 }
193 }
194 DLIST_PROMOTE(dirptrs,dptr);
195 return dptr;
196 }
197 }
198 return(NULL);
199 }
200
201 /****************************************************************************
202 Get the dir path for a dir index.
203 ****************************************************************************/
204
205 char *dptr_path(int key)
206 {
207 struct dptr_struct *dptr = dptr_get(key, False);
208 if (dptr)
209 return(dptr->path);
210 return(NULL);
211 }
212
213 /****************************************************************************
214 Get the dir wcard for a dir index.
215 ****************************************************************************/
216
217 char *dptr_wcard(int key)
218 {
219 struct dptr_struct *dptr = dptr_get(key, False);
220 if (dptr)
221 return(dptr->wcard);
222 return(NULL);
223 }
224
225 /****************************************************************************
226 Get the dir attrib for a dir index.
227 ****************************************************************************/
228
229 uint16 dptr_attr(int key)
230 {
231 struct dptr_struct *dptr = dptr_get(key, False);
232 if (dptr)
233 return(dptr->attr);
234 return(0);
235 }
236
237 /****************************************************************************
238 Close a dptr (internal func).
239 ****************************************************************************/
240
241 static void dptr_close_internal(struct dptr_struct *dptr)
242 {
243 DEBUG(4,("closing dptr key %d\n",dptr->dnum));
244
245 DLIST_REMOVE(dirptrs, dptr);
246
247 /*
248 * Free the dnum in the bitmap. Remember the dnum value is always
249 * biased by one with respect to the bitmap.
250 */
251
252 if(bitmap_query( dptr_bmap, dptr->dnum - 1) != True) {
253 DEBUG(0,("dptr_close_internal : Error - closing dnum = %d and bitmap not set !\n",
254 dptr->dnum ));
255 }
256
257 bitmap_clear(dptr_bmap, dptr->dnum - 1);
258
259 TALLOC_FREE(dptr->dir_hnd);
260
261 /* Lanman 2 specific code */
262 SAFE_FREE(dptr->wcard);
263 string_set(&dptr->path,"");
264 SAFE_FREE(dptr);
265 }
266
267 /****************************************************************************
268 Close a dptr given a key.
269 ****************************************************************************/
270
271 void dptr_close(int *key)
272 {
273 struct dptr_struct *dptr;
274
275 if(*key == INVALID_DPTR_KEY)
276 return;
277
278 /* OS/2 seems to use -1 to indicate "close all directories" */
279 if (*key == -1) {
280 struct dptr_struct *next;
281 for(dptr = dirptrs; dptr; dptr = next) {
282 next = dptr->next;
283 dptr_close_internal(dptr);
284 }
285 *key = INVALID_DPTR_KEY;
286 return;
287 }
288
289 dptr = dptr_get(*key, True);
290
291 if (!dptr) {
292 DEBUG(0,("Invalid key %d given to dptr_close\n", *key));
293 return;
294 }
295
296 dptr_close_internal(dptr);
297
298 *key = INVALID_DPTR_KEY;
299 }
300
301 /****************************************************************************
302 Close all dptrs for a cnum.
303 ****************************************************************************/
304
305 void dptr_closecnum(connection_struct *conn)
306 {
307 struct dptr_struct *dptr, *next;
308 for(dptr = dirptrs; dptr; dptr = next) {
309 next = dptr->next;
310 if (dptr->conn == conn)
311 dptr_close_internal(dptr);
312 }
313 }
314
315 /****************************************************************************
316 Idle all dptrs for a cnum.
317 ****************************************************************************/
318
319 void dptr_idlecnum(connection_struct *conn)
320 {
321 struct dptr_struct *dptr;
322 for(dptr = dirptrs; dptr; dptr = dptr->next) {
323 if (dptr->conn == conn && dptr->dir_hnd)
324 dptr_idle(dptr);
325 }
326 }
327
328 /****************************************************************************
329 Close a dptr that matches a given path, only if it matches the spid also.
330 ****************************************************************************/
331
332 void dptr_closepath(char *path,uint16 spid)
333 {
334 struct dptr_struct *dptr, *next;
335 for(dptr = dirptrs; dptr; dptr = next) {
336 next = dptr->next;
337 if (spid == dptr->spid && strequal(dptr->path,path))
338 dptr_close_internal(dptr);
339 }
340 }
341
342 /****************************************************************************
343 Try and close the oldest handle not marked for
344 expect close in the hope that the client has
345 finished with that one.
346 ****************************************************************************/
347
348 static void dptr_close_oldest(bool old)
349 {
350 struct dptr_struct *dptr;
351
352 /*
353 * Go to the end of the list.
354 */
355 for(dptr = dirptrs; dptr && dptr->next; dptr = dptr->next)
356 ;
357
358 if(!dptr) {
359 DEBUG(0,("No old dptrs available to close oldest ?\n"));
360 return;
361 }
362
363 /*
364 * If 'old' is true, close the oldest oldhandle dnum (ie. 1 < dnum < 256) that
365 * does not have expect_close set. If 'old' is false, close
366 * one of the new dnum handles.
367 */
368
369 for(; dptr; dptr = dptr->prev) {
370 if ((old && (dptr->dnum < 256) && !dptr->expect_close) ||
371 (!old && (dptr->dnum > 255))) {
372 dptr_close_internal(dptr);
373 return;
374 }
375 }
376 }
377
378 /****************************************************************************
379 Create a new dir ptr. If the flag old_handle is true then we must allocate
380 from the bitmap range 0 - 255 as old SMBsearch directory handles are only
381 one byte long. If old_handle is false we allocate from the range
382 256 - MAX_DIRECTORY_HANDLES. We bias the number we return by 1 to ensure
383 a directory handle is never zero.
384 wcard must not be zero.
385 ****************************************************************************/
386
387 NTSTATUS dptr_create(connection_struct *conn, const char *path, bool old_handle, bool expect_close,uint16 spid,
388 const char *wcard, bool wcard_has_wild, uint32 attr, struct dptr_struct **dptr_ret)
389 {
390 struct dptr_struct *dptr = NULL;
391 struct smb_Dir *dir_hnd;
392 NTSTATUS status;
393
394 DEBUG(5,("dptr_create dir=%s\n", path));
395
396 if (!wcard) {
397 return NT_STATUS_INVALID_PARAMETER;
398 }
399
400 status = check_name(conn,path);
401 if (!NT_STATUS_IS_OK(status)) {
402 return status;
403 }
404
405 dir_hnd = OpenDir(NULL, conn, path, wcard, attr);
406 if (!dir_hnd) {
407 return map_nt_error_from_unix(errno);
408 }
409
410 string_set(&conn->dirpath,path);
411
412 if (dirhandles_open >= MAX_OPEN_DIRECTORIES) {
413 dptr_idleoldest();
414 }
415
416 dptr = SMB_MALLOC_P(struct dptr_struct);
417 if(!dptr) {
418 DEBUG(0,("malloc fail in dptr_create.\n"));
419 TALLOC_FREE(dir_hnd);
420 return NT_STATUS_NO_MEMORY;
421 }
422
423 ZERO_STRUCTP(dptr);
424
425 if(old_handle) {
426
427 /*
428 * This is an old-style SMBsearch request. Ensure the
429 * value we return will fit in the range 1-255.
430 */
431
432 dptr->dnum = bitmap_find(dptr_bmap, 0);
433
434 if(dptr->dnum == -1 || dptr->dnum > 254) {
435
436 /*
437 * Try and close the oldest handle not marked for
438 * expect close in the hope that the client has
439 * finished with that one.
440 */
441
442 dptr_close_oldest(True);
443
444 /* Now try again... */
445 dptr->dnum = bitmap_find(dptr_bmap, 0);
446 if(dptr->dnum == -1 || dptr->dnum > 254) {
447 DEBUG(0,("dptr_create: returned %d: Error - all old dirptrs in use ?\n", dptr->dnum));
448 SAFE_FREE(dptr);
449 TALLOC_FREE(dir_hnd);
450 return NT_STATUS_TOO_MANY_OPENED_FILES;
451 }
452 }
453 } else {
454
455 /*
456 * This is a new-style trans2 request. Allocate from
457 * a range that will return 256 - MAX_DIRECTORY_HANDLES.
458 */
459
460 dptr->dnum = bitmap_find(dptr_bmap, 255);
461
462 if(dptr->dnum == -1 || dptr->dnum < 255) {
463
464 /*
465 * Try and close the oldest handle close in the hope that
466 * the client has finished with that one. This will only
467 * happen in the case of the Win98 client bug where it leaks
468 * directory handles.
469 */
470
471 dptr_close_oldest(False);
472
473 /* Now try again... */
474 dptr->dnum = bitmap_find(dptr_bmap, 255);
475
476 if(dptr->dnum == -1 || dptr->dnum < 255) {
477 DEBUG(0,("dptr_create: returned %d: Error - all new dirptrs in use ?\n", dptr->dnum));
478 SAFE_FREE(dptr);
479 TALLOC_FREE(dir_hnd);
480 return NT_STATUS_TOO_MANY_OPENED_FILES;
481 }
482 }
483 }
484
485 bitmap_set(dptr_bmap, dptr->dnum);
486
487 dptr->dnum += 1; /* Always bias the dnum by one - no zero dnums allowed. */
488
489 string_set(&dptr->path,path);
490 dptr->conn = conn;
491 dptr->dir_hnd = dir_hnd;
492 dptr->spid = spid;
493 dptr->expect_close = expect_close;
494 dptr->wcard = SMB_STRDUP(wcard);
495 if (!dptr->wcard) {
496 bitmap_clear(dptr_bmap, dptr->dnum - 1);
497 SAFE_FREE(dptr);
498 TALLOC_FREE(dir_hnd);
499 return NT_STATUS_NO_MEMORY;
500 }
501 if (lp_posix_pathnames() || (wcard[0] == '.' && wcard[1] == 0)) {
502 dptr->has_wild = True;
503 } else {
504 dptr->has_wild = wcard_has_wild;
505 }
506
507 dptr->attr = attr;
508
509 DLIST_ADD(dirptrs, dptr);
510
511 DEBUG(3,("creating new dirptr %d for path %s, expect_close = %d\n",
512 dptr->dnum,path,expect_close));
513
514 *dptr_ret = dptr;
515
516 return NT_STATUS_OK;
517 }
518
519
520 /****************************************************************************
521 Wrapper functions to access the lower level directory handles.
522 ****************************************************************************/
523
524 int dptr_CloseDir(struct dptr_struct *dptr)
525 {
526 DLIST_REMOVE(dirptrs, dptr);
527 TALLOC_FREE(dptr->dir_hnd);
528 return 0;
529 }
530
531 void dptr_SeekDir(struct dptr_struct *dptr, long offset)
532 {
533 SeekDir(dptr->dir_hnd, offset);
534 }
535
536 long dptr_TellDir(struct dptr_struct *dptr)
537 {
538 return TellDir(dptr->dir_hnd);
539 }
540
541 bool dptr_has_wild(struct dptr_struct *dptr)
542 {
543 return dptr->has_wild;
544 }
545
546 int dptr_dnum(struct dptr_struct *dptr)
547 {
548 return dptr->dnum;
549 }
550
551 /****************************************************************************
552 Return the next visible file name, skipping veto'd and invisible files.
553 ****************************************************************************/
554
555 static const char *dptr_normal_ReadDirName(struct dptr_struct *dptr,
556 long *poffset, SMB_STRUCT_STAT *pst)
557 {
558 /* Normal search for the next file. */
559 const char *name;
560 while ((name = ReadDirName(dptr->dir_hnd, poffset, pst)) != NULL) {
561 if (is_visible_file(dptr->conn, dptr->path, name, pst, True)) {
562 return name;
563 }
564 }
565 return NULL;
566 }
567
568 /****************************************************************************
569 Return the next visible file name, skipping veto'd and invisible files.
570 ****************************************************************************/
571
572 char *dptr_ReadDirName(TALLOC_CTX *ctx,
573 struct dptr_struct *dptr,
574 long *poffset,
575 SMB_STRUCT_STAT *pst)
576 {
577 struct smb_filename *smb_fname_base = NULL;
578 char *name = NULL;
579 char *pathreal = NULL;
580 char *found_name = NULL;
581 int ret;
582 const char *name_temp = NULL;
583 NTSTATUS status;
584
585 SET_STAT_INVALID(*pst);
586
587 if (dptr->has_wild || dptr->did_stat) {
588 name_temp = dptr_normal_ReadDirName(dptr, poffset, pst);
589 name = talloc_strdup(ctx, name_temp);
590 return name;
591 }
592
593 /* If poffset is -1 then we know we returned this name before and we
594 * have no wildcards. We're at the end of the directory. */
595 if (*poffset == END_OF_DIRECTORY_OFFSET) {
596 return NULL;
597 }
598
599 /* We know the stored wcard contains no wildcard characters.
600 * See if we can match with a stat call. If we can't, then set
601 * did_stat to true to ensure we only do this once and keep
602 * searching. */
603
604 dptr->did_stat = true;
605
606 /* First check if it should be visible. */
607 if (!is_visible_file(dptr->conn, dptr->path, dptr->wcard,
608 pst, true))
609 {
610 /* This only returns false if the file was found, but
611 is explicitly not visible. Set us to end of
612 directory, but return NULL as we know we can't ever
613 find it. */
614 goto ret;
615 }
616
617 if (VALID_STAT(*pst)) {
618 name = talloc_strdup(ctx, dptr->wcard);
619 goto ret;
620 }
621
622 pathreal = talloc_asprintf(ctx,
623 "%s/%s",
624 dptr->path,
625 dptr->wcard);
626 if (!pathreal)
627 return NULL;
628
629 /* Create an smb_filename with stream_name == NULL. */
630 status = create_synthetic_smb_fname(ctx, pathreal, NULL, NULL,
631 &smb_fname_base);
632 if (!NT_STATUS_IS_OK(status)) {
633 return NULL;
634 }
635
636 if (SMB_VFS_STAT(dptr->conn, smb_fname_base) == 0) {
637 *pst = smb_fname_base->st;
638 TALLOC_FREE(smb_fname_base);
639 name = talloc_strdup(ctx, dptr->wcard);
640 goto clean;
641 } else {
642 TALLOC_FREE(smb_fname_base);
643 /* If we get any other error than ENOENT or ENOTDIR
644 then the file exists we just can't stat it. */
645 if (errno != ENOENT && errno != ENOTDIR) {
646 name = talloc_strdup(ctx, dptr->wcard);
647 goto clean;
648 }
649 }
650
651 /* Stat failed. We know this is authoratiative if we are
652 * providing case sensitive semantics or the underlying
653 * filesystem is case sensitive.
654 */
655 if (dptr->conn->case_sensitive ||
656 !(dptr->conn->fs_capabilities & FILE_CASE_SENSITIVE_SEARCH))
657 {
658 goto clean;
659 }
660
661 /*
662 * Try case-insensitive stat if the fs has the ability. This avoids
663 * scanning the whole directory.
664 */
665 ret = SMB_VFS_GET_REAL_FILENAME(dptr->conn, dptr->path, dptr->wcard,
666 ctx, &found_name);
667 if (ret == 0) {
668 name = found_name;
669 goto clean;
670 } else if (errno == ENOENT) {
671 /* The case-insensitive lookup was authoritative. */
672 goto clean;
673 }
674
675 TALLOC_FREE(pathreal);
676
677 name_temp = dptr_normal_ReadDirName(dptr, poffset, pst);
678 name = talloc_strdup(ctx, name_temp);
679 return name;
680
681 clean:
682 TALLOC_FREE(pathreal);
683 ret:
684 /* We need to set the underlying dir_hnd offset to -1
685 * also as this function is usually called with the
686 * output from TellDir. */
687 dptr->dir_hnd->offset = *poffset = END_OF_DIRECTORY_OFFSET;
688 return name;
689 }
690
691 /****************************************************************************
692 Search for a file by name, skipping veto'ed and not visible files.
693 ****************************************************************************/
694
695 bool dptr_SearchDir(struct dptr_struct *dptr, const char *name, long *poffset, SMB_STRUCT_STAT *pst)
696 {
697 SET_STAT_INVALID(*pst);
698
699 if (!dptr->has_wild && (dptr->dir_hnd->offset == END_OF_DIRECTORY_OFFSET)) {
700 /* This is a singleton directory and we're already at the end. */
701 *poffset = END_OF_DIRECTORY_OFFSET;
702 return False;
703 }
704
705 return SearchDir(dptr->dir_hnd, name, poffset);
706 }
707
708 /****************************************************************************
709 Add the name we're returning into the underlying cache.
710 ****************************************************************************/
711
712 void dptr_DirCacheAdd(struct dptr_struct *dptr, const char *name, long offset)
713 {
714 DirCacheAdd(dptr->dir_hnd, name, offset);
715 }
716
717 /****************************************************************************
718 Initialize variables & state data at the beginning of all search SMB requests.
719 ****************************************************************************/
720 void dptr_init_search_op(struct dptr_struct *dptr)
721 {
722 SMB_VFS_INIT_SEARCH_OP(dptr->conn, dptr->dir_hnd->dir);
723 }
724
725 /****************************************************************************
726 Fill the 5 byte server reserved dptr field.
727 ****************************************************************************/
728
729 bool dptr_fill(char *buf1,unsigned int key)
730 {
731 unsigned char *buf = (unsigned char *)buf1;
732 struct dptr_struct *dptr = dptr_get(key, False);
733 uint32 offset;
734 if (!dptr) {
735 DEBUG(1,("filling null dirptr %d\n",key));
736 return(False);
737 }
738 offset = (uint32)TellDir(dptr->dir_hnd);
739 DEBUG(6,("fill on key %u dirptr 0x%lx now at %d\n",key,
740 (long)dptr->dir_hnd,(int)offset));
741 buf[0] = key;
742 SIVAL(buf,1,offset);
743 return(True);
744 }
745
746 /****************************************************************************
747 Fetch the dir ptr and seek it given the 5 byte server field.
748 ****************************************************************************/
749
750 struct dptr_struct *dptr_fetch(char *buf,int *num)
751 {
752 unsigned int key = *(unsigned char *)buf;
753 struct dptr_struct *dptr = dptr_get(key, False);
754 uint32 offset;
755 long seekoff;
756
757 if (!dptr) {
758 DEBUG(3,("fetched null dirptr %d\n",key));
759 return(NULL);
760 }
761 *num = key;
762 offset = IVAL(buf,1);
763 if (offset == (uint32)-1) {
764 seekoff = END_OF_DIRECTORY_OFFSET;
765 } else {
766 seekoff = (long)offset;
767 }
768 SeekDir(dptr->dir_hnd,seekoff);
769 DEBUG(3,("fetching dirptr %d for path %s at offset %d\n",
770 key,dptr_path(key),(int)seekoff));
771 return(dptr);
772 }
773
774 /****************************************************************************
775 Fetch the dir ptr.
776 ****************************************************************************/
777
778 struct dptr_struct *dptr_fetch_lanman2(int dptr_num)
779 {
780 struct dptr_struct *dptr = dptr_get(dptr_num, False);
781
782 if (!dptr) {
783 DEBUG(3,("fetched null dirptr %d\n",dptr_num));
784 return(NULL);
785 }
786 DEBUG(3,("fetching dirptr %d for path %s\n",dptr_num,dptr_path(dptr_num)));
787 return(dptr);
788 }
789
790 /****************************************************************************
791 Check that a file matches a particular file type.
792 ****************************************************************************/
793
794 bool dir_check_ftype(connection_struct *conn, uint32 mode, uint32 dirtype)
795 {
796 uint32 mask;
797
798 /* Check the "may have" search bits. */
799 if (((mode & ~dirtype) & (aHIDDEN | aSYSTEM | aDIR)) != 0)
800 return False;
801
802 /* Check the "must have" bits, which are the may have bits shifted eight */
803 /* If must have bit is set, the file/dir can not be returned in search unless the matching
804 file attribute is set */
805 mask = ((dirtype >> 8) & (aDIR|aARCH|aRONLY|aHIDDEN|aSYSTEM)); /* & 0x37 */
806 if(mask) {
807 if((mask & (mode & (aDIR|aARCH|aRONLY|aHIDDEN|aSYSTEM))) == mask) /* check if matching attribute present */
808 return True;
809 else
810 return False;
811 }
812
813 return True;
814 }
815
816 static bool mangle_mask_match(connection_struct *conn,
817 const char *filename,
818 const char *mask)
819 {
820 char mname[13];
821
822 if (!name_to_8_3(filename,mname,False,conn->params)) {
823 return False;
824 }
825 return mask_match_search(mname,mask,False);
826 }
827
828 /****************************************************************************
829 Get an 8.3 directory entry.
830 ****************************************************************************/
831
832 bool get_dir_entry(TALLOC_CTX *ctx,
833 connection_struct *conn,
834 const char *mask,
835 uint32 dirtype,
836 char **pp_fname_out,
837 SMB_OFF_T *size,
838 uint32 *mode,
839 struct timespec *date,
840 bool check_descend,
841 bool ask_sharemode)
842 {
843 char *dname = NULL;
844 bool found = False;
845 SMB_STRUCT_STAT sbuf;
846 char *pathreal = NULL;
847 char *filename = NULL;
848 bool needslash;
849
850 *pp_fname_out = NULL;
851
852 needslash = ( conn->dirpath[strlen(conn->dirpath) -1] != '/');
853
854 if (!conn->dirptr) {
855 return(False);
856 }
857
858 while (!found) {
859 long curoff = dptr_TellDir(conn->dirptr);
860 dname = dptr_ReadDirName(ctx, conn->dirptr, &curoff, &sbuf);
861
862 DEBUG(6,("readdir on dirptr 0x%lx now at offset %ld\n",
863 (long)conn->dirptr,TellDir(conn->dirptr->dir_hnd)));
864
865 if (dname == NULL) {
866 return(False);
867 }
868
869 filename = dname;
870
871 /* notice the special *.* handling. This appears to be the only difference
872 between the wildcard handling in this routine and in the trans2 routines.
873 see masktest for a demo
874 */
875 if ((strcmp(mask,"*.*") == 0) ||
876 mask_match_search(filename,mask,False) ||
877 mangle_mask_match(conn,filename,mask)) {
878 char mname[13];
879 struct smb_filename *smb_fname = NULL;
880 NTSTATUS status;
881
882 if (!mangle_is_8_3(filename, False, conn->params)) {
883 if (!name_to_8_3(filename,mname,False,
884 conn->params)) {
885 TALLOC_FREE(filename);
886 continue;
887 }
888 filename = talloc_strdup(ctx, mname);
889 if (!filename) {
890 return False;
891 }
892 }
893
894 if (needslash) {
895 pathreal = talloc_asprintf(ctx,
896 "%s/%s",
897 conn->dirpath,
898 dname);
899 } else {
900 pathreal = talloc_asprintf(ctx,
901 "%s%s",
902 conn->dirpath,
903 dname);
904 }
905 if (!pathreal) {
906 TALLOC_FREE(filename);
907 return False;
908 }
909
910 /* Create smb_fname with NULL stream_name. */
911 status = create_synthetic_smb_fname(ctx, pathreal,
912 NULL, &sbuf,
913 &smb_fname);
914
915 TALLOC_FREE(pathreal);
916 if (!NT_STATUS_IS_OK(status)) {
917 TALLOC_FREE(filename);
918 return false;
919 }
920
921 if (!VALID_STAT(smb_fname->st)) {
922 if ((SMB_VFS_STAT(conn, smb_fname)) != 0) {
923 DEBUG(5,("Couldn't stat 1 [%s]. Error "
924 "= %s\n",
925 smb_fname_str_dbg(smb_fname),
926 strerror(errno)));
927 TALLOC_FREE(smb_fname);
928 TALLOC_FREE(filename);
929 continue;
930 }
931 }
932
933 *mode = dos_mode(conn, smb_fname);
934
935 if (!dir_check_ftype(conn,*mode,dirtype)) {
936 DEBUG(5,("[%s] attribs 0x%x didn't match 0x%x\n",filename,(unsigned int)*mode,(unsigned int)dirtype));
937 TALLOC_FREE(smb_fname);
938 TALLOC_FREE(filename);
939 continue;
940 }
941
942 *size = smb_fname->st.st_ex_size;
943 *date = smb_fname->st.st_ex_mtime;
944
945 if (ask_sharemode) {
946 struct timespec write_time_ts;
947 struct file_id fileid;
948
949 fileid = vfs_file_id_from_sbuf(conn,
950 &smb_fname->st);
951 get_file_infos(fileid, NULL, &write_time_ts);
952 if (!null_timespec(write_time_ts)) {
953 *date = write_time_ts;
954 }
955 }
956
957 DEBUG(3,("get_dir_entry mask=[%s] found %s "
958 "fname=%s (%s)\n",
959 mask,
960 smb_fname_str_dbg(smb_fname),
961 dname,
962 filename));
963
964 found = True;
965
966 SMB_ASSERT(filename != NULL);
967 *pp_fname_out = filename;
968
969 DirCacheAdd(conn->dirptr->dir_hnd, dname, curoff);
970 TALLOC_FREE(smb_fname);
971 }
972
973 if (!found)
974 TALLOC_FREE(filename);
975 }
976
977 return(found);
978 }
979
980 /*******************************************************************
981 Check to see if a user can read a file. This is only approximate,
982 it is used as part of the "hide unreadable" option. Don't
983 use it for anything security sensitive.
984 ********************************************************************/
985
986 static bool user_can_read_file(connection_struct *conn,
987 struct smb_filename *smb_fname)
988 {
989 /*
990 * If user is a member of the Admin group
991 * we never hide files from them.
992 */
993
994 if (conn->admin_user) {
995 return True;
996 }
997
998 return can_access_file_acl(conn, smb_fname, FILE_READ_DATA);
999 }
1000
1001 /*******************************************************************
1002 Check to see if a user can write a file (and only files, we do not
1003 check dirs on this one). This is only approximate,
1004 it is used as part of the "hide unwriteable" option. Don't
1005 use it for anything security sensitive.
1006 ********************************************************************/
1007
1008 static bool user_can_write_file(connection_struct *conn,
1009 const struct smb_filename *smb_fname)
1010 {
1011 /*
1012 * If user is a member of the Admin group
1013 * we never hide files from them.
1014 */
1015
1016 if (conn->admin_user) {
1017 return True;
1018 }
1019
1020 SMB_ASSERT(VALID_STAT(smb_fname->st));
1021
1022 /* Pseudo-open the file */
1023
1024 if(S_ISDIR(smb_fname->st.st_ex_mode)) {
1025 return True;
1026 }
1027
1028 return can_write_to_file(conn, smb_fname);
1029 }
1030
1031 /*******************************************************************
1032 Is a file a "special" type ?
1033 ********************************************************************/
1034
1035 static bool file_is_special(connection_struct *conn,
1036 const struct smb_filename *smb_fname)
1037 {
1038 /*
1039 * If user is a member of the Admin group
1040 * we never hide files from them.
1041 */
1042
1043 if (conn->admin_user)
1044 return False;
1045
1046 SMB_ASSERT(VALID_STAT(smb_fname->st));
1047
1048 if (S_ISREG(smb_fname->st.st_ex_mode) ||
1049 S_ISDIR(smb_fname->st.st_ex_mode) ||
1050 S_ISLNK(smb_fname->st.st_ex_mode))
1051 return False;
1052
1053 return True;
1054 }
1055
1056 /*******************************************************************
1057 Should the file be seen by the client?
1058 NOTE: A successful return is no guarantee of the file's existence.
1059 ********************************************************************/
1060
1061 bool is_visible_file(connection_struct *conn, const char *dir_path,
1062 const char *name, SMB_STRUCT_STAT *pst, bool use_veto)
1063 {
1064 bool hide_unreadable = lp_hideunreadable(SNUM(conn));
1065 bool hide_unwriteable = lp_hideunwriteable_files(SNUM(conn));
1066 bool hide_special = lp_hide_special_files(SNUM(conn));
1067 char *entry = NULL;
1068 struct smb_filename *smb_fname_base = NULL;
1069 NTSTATUS status;
1070 bool ret = false;
1071
1072 if ((strcmp(".",name) == 0) || (strcmp("..",name) == 0)) {
1073 return True; /* . and .. are always visible. */
1074 }
1075
1076 /* If it's a vetoed file, pretend it doesn't even exist */
1077 if (use_veto && IS_VETO_PATH(conn, name)) {
1078 DEBUG(10,("is_visible_file: file %s is vetoed.\n", name ));
1079 return False;
1080 }
1081
1082 if (hide_unreadable || hide_unwriteable || hide_special) {
1083 entry = talloc_asprintf(talloc_tos(), "%s/%s", dir_path, name);
1084 if (!entry) {
1085 ret = false;
1086 goto out;
1087 }
1088
1089 /* If it's a dfs symlink, ignore _hide xxxx_ options */
1090 if (lp_host_msdfs() &&
1091 lp_msdfs_root(SNUM(conn)) &&
1092 is_msdfs_link(conn, entry, NULL)) {
1093 ret = true;
1094 goto out;
1095 }
1096
1097 /* Create an smb_filename with stream_name == NULL. */
1098 status = create_synthetic_smb_fname(talloc_tos(), entry, NULL,
1099 pst, &smb_fname_base);
1100 if (!NT_STATUS_IS_OK(status)) {
1101 ret = false;
1102 goto out;
1103 }
1104
1105 /* If the file name does not exist, there's no point checking
1106 * the configuration options. We succeed, on the basis that the
1107 * checks *might* have passed if the file was present.
1108 */
1109 if (!VALID_STAT(*pst)) {
1110 if (SMB_VFS_STAT(conn, smb_fname_base) != 0) {
1111 ret = true;
1112 goto out;
1113 } else {
1114 *pst = smb_fname_base->st;
1115 }
1116 }
1117
1118 /* Honour _hide unreadable_ option */
1119 if (hide_unreadable &&
1120 !user_can_read_file(conn, smb_fname_base)) {
1121 DEBUG(10,("is_visible_file: file %s is unreadable.\n",
1122 entry ));
1123 ret = false;
1124 goto out;
1125 }
1126 /* Honour _hide unwriteable_ option */
1127 if (hide_unwriteable && !user_can_write_file(conn,
1128 smb_fname_base)) {
1129 DEBUG(10,("is_visible_file: file %s is unwritable.\n",
1130 entry ));
1131 ret = false;
1132 goto out;
1133 }
1134 /* Honour _hide_special_ option */
1135 if (hide_special && file_is_special(conn, smb_fname_base)) {
1136 DEBUG(10,("is_visible_file: file %s is special.\n",
1137 entry ));
1138 ret = false;
1139 goto out;
1140 }
1141 }
1142
1143 ret = true;
1144 out:
1145 TALLOC_FREE(smb_fname_base);
1146 TALLOC_FREE(entry);
1147 return ret;
1148 }
1149
1150 static int smb_Dir_destructor(struct smb_Dir *dirp)
1151 {
1152 if (dirp->dir) {
1153 SMB_VFS_CLOSEDIR(dirp->conn,dirp->dir);
1154 }
1155 dirhandles_open--;
1156 return 0;
1157 }
1158
1159 /*******************************************************************
1160 Open a directory.
1161 ********************************************************************/
1162
1163 struct smb_Dir *OpenDir(TALLOC_CTX *mem_ctx, connection_struct *conn,
1164 const char *name, const char *mask, uint32 attr)
1165 {
1166 struct smb_Dir *dirp = TALLOC_ZERO_P(mem_ctx, struct smb_Dir);
1167
1168 if (!dirp) {
1169 return NULL;
1170 }
1171
1172 dirp->conn = conn;
1173 dirp->name_cache_size = lp_directory_name_cache_size(SNUM(conn));
1174
1175 dirp->dir_path = talloc_strdup(dirp, name);
1176 if (!dirp->dir_path) {
1177 errno = ENOMEM;
1178 goto fail;
1179 }
1180
1181 dirhandles_open++;
1182 talloc_set_destructor(dirp, smb_Dir_destructor);
1183
1184 dirp->dir = SMB_VFS_OPENDIR(conn, dirp->dir_path, mask, attr);
1185 if (!dirp->dir) {
1186 DEBUG(5,("OpenDir: Can't open %s. %s\n", dirp->dir_path,
1187 strerror(errno) ));
1188 goto fail;
1189 }
1190
1191 return dirp;
1192
1193 fail:
1194 TALLOC_FREE(dirp);
1195 return NULL;
1196 }
1197
1198 /*******************************************************************
1199 Read from a directory.
1200 Return directory entry, current offset, and optional stat information.
1201 Don't check for veto or invisible files.
1202 ********************************************************************/
1203
1204 const char *ReadDirName(struct smb_Dir *dirp, long *poffset,
1205 SMB_STRUCT_STAT *sbuf)
1206 {
1207 const char *n;
1208 connection_struct *conn = dirp->conn;
1209
1210 /* Cheat to allow . and .. to be the first entries returned. */
1211 if (((*poffset == START_OF_DIRECTORY_OFFSET) ||
1212 (*poffset == DOT_DOT_DIRECTORY_OFFSET)) && (dirp->file_number < 2))
1213 {
1214 if (dirp->file_number == 0) {
1215 n = ".";
1216 *poffset = dirp->offset = START_OF_DIRECTORY_OFFSET;
1217 } else {
1218 *poffset = dirp->offset = DOT_DOT_DIRECTORY_OFFSET;
1219 n = "..";
1220 }
1221 dirp->file_number++;
1222 return n;
1223 } else if (*poffset == END_OF_DIRECTORY_OFFSET) {
1224 *poffset = dirp->offset = END_OF_DIRECTORY_OFFSET;
1225 return NULL;
1226 } else {
1227 /* A real offset, seek to it. */
1228 SeekDir(dirp, *poffset);
1229 }
1230
1231 while ((n = vfs_readdirname(conn, dirp->dir, sbuf))) {
1232 /* Ignore . and .. - we've already returned them. */
1233 if (*n == '.') {
1234 if ((n[1] == '\0') || (n[1] == '.' && n[2] == '\0')) {
1235 continue;
1236 }
1237 }
1238 *poffset = dirp->offset = SMB_VFS_TELLDIR(conn, dirp->dir);
1239 dirp->file_number++;
1240 return n;
1241 }
1242 *poffset = dirp->offset = END_OF_DIRECTORY_OFFSET;
1243 return NULL;
1244 }
1245
1246 /*******************************************************************
1247 Rewind to the start.
1248 ********************************************************************/
1249
1250 void RewindDir(struct smb_Dir *dirp, long *poffset)
1251 {
1252 SMB_VFS_REWINDDIR(dirp->conn, dirp->dir);
1253 dirp->file_number = 0;
1254 dirp->offset = START_OF_DIRECTORY_OFFSET;
1255 *poffset = START_OF_DIRECTORY_OFFSET;
1256 }
1257
1258 /*******************************************************************
1259 Seek a dir.
1260 ********************************************************************/
1261
1262 void SeekDir(struct smb_Dir *dirp, long offset)
1263 {
1264 if (offset != dirp->offset) {
1265 if (offset == START_OF_DIRECTORY_OFFSET) {
1266 RewindDir(dirp, &offset);
1267 /*
1268 * Ok we should really set the file number here
1269 * to 1 to enable ".." to be returned next. Trouble
1270 * is I'm worried about callers using SeekDir(dirp,0)
1271 * as equivalent to RewindDir(). So leave this alone
1272 * for now.
1273 */
1274 } else if (offset == DOT_DOT_DIRECTORY_OFFSET) {
1275 RewindDir(dirp, &offset);
1276 /*
1277 * Set the file number to 2 - we want to get the first
1278 * real file entry (the one we return after "..")
1279 * on the next ReadDir.
1280 */
1281 dirp->file_number = 2;
1282 } else if (offset == END_OF_DIRECTORY_OFFSET) {
1283 ; /* Don't seek in this case. */
1284 } else {
1285 SMB_VFS_SEEKDIR(dirp->conn, dirp->dir, offset);
1286 }
1287 dirp->offset = offset;
1288 }
1289 }
1290
1291 /*******************************************************************
1292 Tell a dir position.
1293 ********************************************************************/
1294
1295 long TellDir(struct smb_Dir *dirp)
1296 {
1297 return(dirp->offset);
1298 }
1299
1300 /*******************************************************************
1301 Add an entry into the dcache.
1302 ********************************************************************/
1303
1304 void DirCacheAdd(struct smb_Dir *dirp, const char *name, long offset)
1305 {
1306 struct name_cache_entry *e;
1307
1308 if (dirp->name_cache_size == 0) {
1309 return;
1310 }
1311
1312 if (dirp->name_cache == NULL) {
1313 dirp->name_cache = TALLOC_ZERO_ARRAY(
1314 dirp, struct name_cache_entry, dirp->name_cache_size);
1315
1316 if (dirp->name_cache == NULL) {
1317 return;
1318 }
1319 }
1320
1321 dirp->name_cache_index = (dirp->name_cache_index+1) %
1322 dirp->name_cache_size;
1323 e = &dirp->name_cache[dirp->name_cache_index];
1324 TALLOC_FREE(e->name);
1325 e->name = talloc_strdup(dirp, name);
1326 e->offset = offset;
1327 }
1328
1329 /*******************************************************************
1330 Find an entry by name. Leave us at the offset after it.
1331 Don't check for veto or invisible files.
1332 ********************************************************************/
1333
1334 bool SearchDir(struct smb_Dir *dirp, const char *name, long *poffset)
1335 {
1336 int i;
1337 const char *entry;
1338 connection_struct *conn = dirp->conn;
1339
1340 /* Search back in the name cache. */
1341 if (dirp->name_cache_size && dirp->name_cache) {
1342 for (i = dirp->name_cache_index; i >= 0; i--) {
1343 struct name_cache_entry *e = &dirp->name_cache[i];
1344 if (e->name && (conn->case_sensitive ? (strcmp(e->name, name) == 0) : strequal(e->name, name))) {
1345 *poffset = e->offset;
1346 SeekDir(dirp, e->offset);
1347 return True;
1348 }
1349 }
1350 for (i = dirp->name_cache_size - 1; i > dirp->name_cache_index; i--) {
1351 struct name_cache_entry *e = &dirp->name_cache[i];
1352 if (e->name && (conn->case_sensitive ? (strcmp(e->name, name) == 0) : strequal(e->name, name))) {
1353 *poffset = e->offset;
1354 SeekDir(dirp, e->offset);
1355 return True;
1356 }
1357 }
1358 }
1359
1360 /* Not found in the name cache. Rewind directory and start from scratch. */
1361 SMB_VFS_REWINDDIR(conn, dirp->dir);
1362 dirp->file_number = 0;
1363 *poffset = START_OF_DIRECTORY_OFFSET;
1364 while ((entry = ReadDirName(dirp, poffset, NULL))) {
1365 if (conn->case_sensitive ? (strcmp(entry, name) == 0) : strequal(entry, name)) {
1366 return True;
1367 }
1368 }
1369 return False;
1370 }
1371
1372 /*****************************************************************
1373 Is this directory empty ?
1374 *****************************************************************/
1375
1376 NTSTATUS can_delete_directory(struct connection_struct *conn,
1377 const char *dirname)
1378 {
1379 NTSTATUS status = NT_STATUS_OK;
1380 long dirpos = 0;
1381 const char *dname;
1382 SMB_STRUCT_STAT st;
1383 struct smb_Dir *dir_hnd = OpenDir(talloc_tos(), conn, dirname,
1384 NULL, 0);
1385
1386 if (!dir_hnd) {
1387 return map_nt_error_from_unix(errno);
1388 }
1389
1390 while ((dname = ReadDirName(dir_hnd, &dirpos, &st))) {
1391 /* Quick check for "." and ".." */
1392 if (dname[0] == '.') {
1393 if (!dname[1] || (dname[1] == '.' && !dname[2])) {
1394 continue;
1395 }
1396 }
1397
1398 if (!is_visible_file(conn, dirname, dname, &st, True)) {
1399 continue;
1400 }
1401
1402 DEBUG(10,("can_delete_directory: got name %s - can't delete\n",
1403 dname ));
1404 status = NT_STATUS_DIRECTORY_NOT_EMPTY;
1405 break;
1406 }
1407 TALLOC_FREE(dir_hnd);
1408
1409 return status;
1410 }
fernandojvsilva's samba4 branch