5b7b08b4760020159b513ee367be2216888922d2
[samba.git] / source3 / smbd / dir.c
1 /* 
2    Unix SMB/Netbios implementation.
3    Version 1.9.
4    Directory handling routines
5    Copyright (C) Andrew Tridgell 1992-1998
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 2 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, write to the Free Software
19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 */
21
22 #include "includes.h"
23
24 extern int DEBUGLEVEL;
25
26 /*
27    This module implements directory related functions for Samba.
28 */
29
30
31
32 static uint32 dircounter = 0;
33
34
35 #define NUMDIRPTRS 256
36
37
38 static struct dptr_struct {
39         int pid;
40         connection_struct *conn;
41         uint32 lastused;
42         void *ptr;
43         BOOL valid;
44         BOOL finished;
45         BOOL expect_close;
46         char *wcard; /* Field only used for trans2_ searches */
47         uint16 attr; /* Field only used for trans2_ searches */
48         char *path;
49 }
50 dirptrs[NUMDIRPTRS];
51
52
53 static int dptrs_open = 0;
54
55 /****************************************************************************
56 initialise the dir array
57 ****************************************************************************/
58 void init_dptrs(void)
59 {
60   static BOOL dptrs_init=False;
61   int i;
62
63   if (dptrs_init) return;
64   for (i=0;i<NUMDIRPTRS;i++)    
65     {
66       dirptrs[i].valid = False;
67       dirptrs[i].wcard = NULL;
68       dirptrs[i].ptr = NULL;
69       string_init(&dirptrs[i].path,"");
70     }
71   dptrs_init = True;
72 }
73
74 /****************************************************************************
75 idle a dptr - the directory is closed but the control info is kept
76 ****************************************************************************/
77 static void dptr_idle(int key)
78 {
79   if (dirptrs[key].valid && dirptrs[key].ptr) {
80     DEBUG(4,("Idling dptr key %d\n",key));
81     dptrs_open--;
82     CloseDir(dirptrs[key].ptr);
83     dirptrs[key].ptr = NULL;
84   }    
85 }
86
87 /****************************************************************************
88 idle the oldest dptr
89 ****************************************************************************/
90 static void dptr_idleoldest(void)
91 {
92   int i;
93   uint32 old=dircounter+1;
94   int oldi= -1;
95   for (i=0;i<NUMDIRPTRS;i++)
96     if (dirptrs[i].valid && dirptrs[i].ptr && dirptrs[i].lastused < old) {
97       old = dirptrs[i].lastused;
98       oldi = i;
99     }
100   if (oldi != -1)
101     dptr_idle(oldi);
102   else
103     DEBUG(0,("No dptrs available to idle??\n"));
104 }
105
106 /****************************************************************************
107 get the dir ptr for a dir index
108 ****************************************************************************/
109 static void *dptr_get(int key,uint32 lastused)
110 {
111         struct dptr_struct *dp = &dirptrs[key];
112
113         if (dp->valid) {
114                 if (lastused) dp->lastused = lastused;
115                 if (!dp->ptr) {
116                         if (dptrs_open >= MAX_OPEN_DIRECTORIES)
117                                 dptr_idleoldest();
118                         DEBUG(4,("Reopening dptr key %d\n",key));
119                         if ((dp->ptr = OpenDir(dp->conn, dp->path, True)))
120                                 dptrs_open++;
121                 }
122                 return(dp->ptr);
123         }
124         return(NULL);
125 }
126
127 /****************************************************************************
128 get the dir path for a dir index
129 ****************************************************************************/
130 char *dptr_path(int key)
131 {
132   if (dirptrs[key].valid)
133     return(dirptrs[key].path);
134   return(NULL);
135 }
136
137 /****************************************************************************
138 get the dir wcard for a dir index (lanman2 specific)
139 ****************************************************************************/
140 char *dptr_wcard(int key)
141 {
142   if (dirptrs[key].valid)
143     return(dirptrs[key].wcard);
144   return(NULL);
145 }
146
147 /****************************************************************************
148 set the dir wcard for a dir index (lanman2 specific)
149 Returns 0 on ok, 1 on fail.
150 ****************************************************************************/
151 BOOL dptr_set_wcard(int key, char *wcard)
152 {
153   if (dirptrs[key].valid) {
154     dirptrs[key].wcard = wcard;
155     return True;
156   }
157   return False;
158 }
159
160 /****************************************************************************
161 set the dir attrib for a dir index (lanman2 specific)
162 Returns 0 on ok, 1 on fail.
163 ****************************************************************************/
164 BOOL dptr_set_attr(int key, uint16 attr)
165 {
166   if (dirptrs[key].valid) {
167     dirptrs[key].attr = attr;
168     return True;
169   }
170   return False;
171 }
172
173 /****************************************************************************
174 get the dir attrib for a dir index (lanman2 specific)
175 ****************************************************************************/
176 uint16 dptr_attr(int key)
177 {
178   if (dirptrs[key].valid)
179     return(dirptrs[key].attr);
180   return(0);
181 }
182
183 /****************************************************************************
184 close a dptr
185 ****************************************************************************/
186 void dptr_close(int key)
187 {
188   /* OS/2 seems to use -1 to indicate "close all directories" */
189   if (key == -1) {
190     int i;
191     for (i=0;i<NUMDIRPTRS;i++) 
192       dptr_close(i);
193     return;
194   }
195
196   if (key < 0 || key >= NUMDIRPTRS) {
197     DEBUG(3,("Invalid key %d given to dptr_close\n",key));
198     return;
199   }
200
201   if (dirptrs[key].valid) {
202     DEBUG(4,("closing dptr key %d\n",key));
203     if (dirptrs[key].ptr) {
204       CloseDir(dirptrs[key].ptr);
205       dptrs_open--;
206     }
207     /* Lanman 2 specific code */
208     if (dirptrs[key].wcard)
209       free(dirptrs[key].wcard);
210     dirptrs[key].valid = False;
211     string_set(&dirptrs[key].path,"");
212   }
213 }
214
215 /****************************************************************************
216 close all dptrs for a cnum
217 ****************************************************************************/
218 void dptr_closecnum(connection_struct *conn)
219 {
220   int i;
221   for (i=0;i<NUMDIRPTRS;i++)
222     if (dirptrs[i].valid && dirptrs[i].conn == conn)
223       dptr_close(i);
224 }
225
226 /****************************************************************************
227 idle all dptrs for a cnum
228 ****************************************************************************/
229 void dptr_idlecnum(connection_struct *conn)
230 {
231   int i;
232   for (i=0;i<NUMDIRPTRS;i++)
233     if (dirptrs[i].valid && dirptrs[i].conn == conn && dirptrs[i].ptr)
234       dptr_idle(i);
235 }
236
237 /****************************************************************************
238 close a dptr that matches a given path, only if it matches the pid also
239 ****************************************************************************/
240 void dptr_closepath(char *path,int pid)
241 {
242   int i;
243   for (i=0;i<NUMDIRPTRS;i++)
244     if (dirptrs[i].valid && pid == dirptrs[i].pid &&
245         strequal(dirptrs[i].path,path))
246       dptr_close(i);
247 }
248
249 /****************************************************************************
250   start a directory listing
251 ****************************************************************************/
252 static BOOL start_dir(connection_struct *conn,char *directory)
253 {
254         DEBUG(5,("start_dir dir=%s\n",directory));
255
256         if (!check_name(directory,conn))
257                 return(False);
258   
259         if (! *directory)
260                 directory = ".";
261
262         conn->dirptr = OpenDir(conn, directory, True);
263         if (conn->dirptr) {    
264                 dptrs_open++;
265                 string_set(&conn->dirpath,directory);
266                 return(True);
267         }
268   
269         return(False);
270 }
271
272
273 /****************************************************************************
274 create a new dir ptr
275 ****************************************************************************/
276 int dptr_create(connection_struct *conn,char *path, BOOL expect_close,int pid)
277 {
278   int i;
279   uint32 old;
280   int oldi;
281
282   if (!start_dir(conn,path))
283     return(-2); /* Code to say use a unix error return code. */
284
285   if (dptrs_open >= MAX_OPEN_DIRECTORIES)
286     dptr_idleoldest();
287
288   for (i=0;i<NUMDIRPTRS;i++)
289     if (!dirptrs[i].valid)
290       break;
291   if (i == NUMDIRPTRS) i = -1;
292
293
294   /* as a 2nd option, grab the oldest not marked for expect_close */
295   if (i == -1) {
296     old=dircounter+1;
297     oldi= -1;
298     for (i=0;i<NUMDIRPTRS;i++)
299       if (!dirptrs[i].expect_close && dirptrs[i].lastused < old) {
300         old = dirptrs[i].lastused;
301         oldi = i;
302       }
303     i = oldi;
304   }
305
306   /* a 3rd option - grab the oldest one */
307   if (i == -1) {
308     old=dircounter+1;
309     oldi= -1;
310     for (i=0;i<NUMDIRPTRS;i++)
311       if (dirptrs[i].lastused < old) {
312         old = dirptrs[i].lastused;
313         oldi = i;
314       }
315     i = oldi;
316   }
317
318   if (i == -1) {
319     DEBUG(0,("Error - all dirptrs in use??\n"));
320     return(-1);
321   }
322
323   if (dirptrs[i].valid)
324     dptr_close(i);
325
326   dirptrs[i].ptr = conn->dirptr;
327   string_set(&dirptrs[i].path,path);
328   dirptrs[i].lastused = dircounter++;
329   dirptrs[i].finished = False;
330   dirptrs[i].conn = conn;
331   dirptrs[i].pid = pid;
332   dirptrs[i].expect_close = expect_close;
333   dirptrs[i].wcard = NULL; /* Only used in lanman2 searches */
334   dirptrs[i].attr = 0; /* Only used in lanman2 searches */
335   dirptrs[i].valid = True;
336
337   DEBUG(3,("creating new dirptr %d for path %s, expect_close = %d\n",
338            i,path,expect_close));  
339
340   return(i);
341 }
342
343 #define DPTR_MASK ((uint32)(((uint32)1)<<31))
344
345 /****************************************************************************
346 fill the 5 byte server reserved dptr field
347 ****************************************************************************/
348 BOOL dptr_fill(char *buf1,unsigned int key)
349 {
350   unsigned char *buf = (unsigned char *)buf1;
351   void *p = dptr_get(key,0);
352   uint32 offset;
353   if (!p) {
354     DEBUG(1,("filling null dirptr %d\n",key));
355     return(False);
356   }
357   offset = TellDir(p);
358   DEBUG(6,("fill on key %ld dirptr 0x%lx now at %d\n",key,
359            (long)p,(int)offset));
360   buf[0] = key;
361   SIVAL(buf,1,offset | DPTR_MASK);
362   return(True);
363 }
364
365
366 /****************************************************************************
367 return True is the offset is at zero
368 ****************************************************************************/
369 BOOL dptr_zero(char *buf)
370 {
371   return((IVAL(buf,1)&~DPTR_MASK) == 0);
372 }
373
374 /****************************************************************************
375 fetch the dir ptr and seek it given the 5 byte server field
376 ****************************************************************************/
377 void *dptr_fetch(char *buf,int *num)
378 {
379   unsigned int key = *(unsigned char *)buf;
380   void *p = dptr_get(key,dircounter++);
381   uint32 offset;
382   if (!p) {
383     DEBUG(3,("fetched null dirptr %d\n",key));
384     return(NULL);
385   }
386   *num = key;
387   offset = IVAL(buf,1)&~DPTR_MASK;
388   SeekDir(p,offset);
389   DEBUG(3,("fetching dirptr %d for path %s at offset %d\n",
390            key,dptr_path(key),offset));
391   return(p);
392 }
393
394 /****************************************************************************
395 fetch the dir ptr.
396 ****************************************************************************/
397 void *dptr_fetch_lanman2(int dptr_num)
398 {
399   void *p = dptr_get(dptr_num,dircounter++);
400
401   if (!p) {
402     DEBUG(3,("fetched null dirptr %d\n",dptr_num));
403     return(NULL);
404   }
405   DEBUG(3,("fetching dirptr %d for path %s\n",dptr_num,dptr_path(dptr_num)));
406   return(p);
407 }
408
409 /****************************************************************************
410 check a filetype for being valid
411 ****************************************************************************/
412 BOOL dir_check_ftype(connection_struct *conn,int mode,SMB_STRUCT_STAT *st,int dirtype)
413 {
414   if (((mode & ~dirtype) & (aHIDDEN | aSYSTEM | aDIR)) != 0)
415     return False;
416   return True;
417 }
418
419 /****************************************************************************
420   get a directory entry
421 ****************************************************************************/
422 BOOL get_dir_entry(connection_struct *conn,char *mask,int dirtype,char *fname,
423                    SMB_OFF_T *size,int *mode,time_t *date,BOOL check_descend)
424 {
425   char *dname;
426   BOOL found = False;
427   SMB_STRUCT_STAT sbuf;
428   pstring path;
429   pstring pathreal;
430   BOOL isrootdir;
431   pstring filename;
432   BOOL needslash;
433
434   *path = *pathreal = *filename = 0;
435
436   isrootdir = (strequal(conn->dirpath,"./") ||
437                strequal(conn->dirpath,".") ||
438                strequal(conn->dirpath,"/"));
439   
440   needslash = 
441         ( conn->dirpath[strlen(conn->dirpath) -1] != '/');
442
443   if (!conn->dirptr)
444     return(False);
445   
446   while (!found)
447     {
448       dname = ReadDirName(conn->dirptr);
449
450       DEBUG(6,("readdir on dirptr 0x%lx now at offset %d\n",
451                (long)conn->dirptr,TellDir(conn->dirptr)));
452       
453       if (dname == NULL) 
454         return(False);
455       
456       pstrcpy(filename,dname);      
457
458       if ((strcmp(filename,mask) == 0) ||
459           (name_map_mangle(filename,True,SNUM(conn)) &&
460            mask_match(filename,mask,False,False)))
461         {
462           if (isrootdir && (strequal(filename,"..") || strequal(filename,".")))
463             continue;
464
465           pstrcpy(fname,filename);
466           *path = 0;
467           pstrcpy(path,conn->dirpath);
468           if(needslash)
469             pstrcat(path,"/");
470           pstrcpy(pathreal,path);
471           pstrcat(path,fname);
472           pstrcat(pathreal,dname);
473           if (dos_stat(pathreal,&sbuf) != 0) 
474             {
475               DEBUG(5,("Couldn't stat 1 [%s]\n",path));
476               continue;
477             }
478
479           if (check_descend &&
480               !strequal(fname,".") && !strequal(fname,".."))
481             continue;
482           
483           *mode = dos_mode(conn,pathreal,&sbuf);
484
485           if (!dir_check_ftype(conn,*mode,&sbuf,dirtype)) {
486             DEBUG(5,("[%s] attribs didn't match %x\n",filename,dirtype));
487             continue;
488           }
489
490           *size = sbuf.st_size;
491           *date = sbuf.st_mtime;
492
493           DEBUG(5,("get_dir_entry found %s fname=%s\n",pathreal,fname));
494           
495           found = True;
496         }
497     }
498
499   return(found);
500 }
501
502
503
504 typedef struct
505 {
506   int pos;
507   int numentries;
508   int mallocsize;
509   char *data;
510   char *current;
511 } Dir;
512
513
514 /*******************************************************************
515 open a directory
516 ********************************************************************/
517 void *OpenDir(connection_struct *conn, char *name, BOOL use_veto)
518 {
519   Dir *dirp;
520   char *n;
521   void *p = dos_opendir(name);
522   int used=0;
523
524   if (!p) return(NULL);
525   dirp = (Dir *)malloc(sizeof(Dir));
526   if (!dirp) {
527     closedir(p);
528     return(NULL);
529   }
530   dirp->pos = dirp->numentries = dirp->mallocsize = 0;
531   dirp->data = dirp->current = NULL;
532
533   while ((n = readdirname(p)))
534   {
535     int l = strlen(n)+1;
536
537     /* If it's a vetoed file, pretend it doesn't even exist */
538     if (use_veto && conn && IS_VETO_PATH(conn, n)) continue;
539
540     if (used + l > dirp->mallocsize) {
541       int s = MAX(used+l,used+2000);
542       char *r;
543       r = (char *)Realloc(dirp->data,s);
544       if (!r) {
545         DEBUG(0,("Out of memory in OpenDir\n"));
546         break;
547       }
548       dirp->data = r;
549       dirp->mallocsize = s;
550       dirp->current = dirp->data;
551     }
552     pstrcpy(dirp->data+used,n);
553     used += l;
554     dirp->numentries++;
555   }
556
557   closedir(p);
558   return((void *)dirp);
559 }
560
561
562 /*******************************************************************
563 close a directory
564 ********************************************************************/
565 void CloseDir(void *p)
566 {
567   Dir *dirp = (Dir *)p;
568   if (!dirp) return;    
569   if (dirp->data) free(dirp->data);
570   free(dirp);
571 }
572
573 /*******************************************************************
574 read from a directory
575 ********************************************************************/
576 char *ReadDirName(void *p)
577 {
578   char *ret;
579   Dir *dirp = (Dir *)p;
580
581   if (!dirp || !dirp->current || dirp->pos >= dirp->numentries) return(NULL);
582
583   ret = dirp->current;
584   dirp->current = skip_string(dirp->current,1);
585   dirp->pos++;
586
587   return(ret);
588 }
589
590
591 /*******************************************************************
592 seek a dir
593 ********************************************************************/
594 BOOL SeekDir(void *p,int pos)
595 {
596   Dir *dirp = (Dir *)p;
597
598   if (!dirp) return(False);
599
600   if (pos < dirp->pos) {
601     dirp->current = dirp->data;
602     dirp->pos = 0;
603   }
604
605   while (dirp->pos < pos && ReadDirName(p)) ;
606
607   return(dirp->pos == pos);
608 }
609
610 /*******************************************************************
611 tell a dir position
612 ********************************************************************/
613 int TellDir(void *p)
614 {
615   Dir *dirp = (Dir *)p;
616
617   if (!dirp) return(-1);
618   
619   return(dirp->pos);
620 }
621
622
623 /* -------------------------------------------------------------------------- **
624  * This section manages a global directory cache.
625  * (It should probably be split into a separate module.  crh)
626  * -------------------------------------------------------------------------- **
627  */
628
629 typedef struct
630   {
631   ubi_dlNode  node;
632   char       *path;
633   char       *name;
634   char       *dname;
635   int         snum;
636   } dir_cache_entry;
637
638 static ubi_dlNewList( dir_cache );
639
640 void DirCacheAdd( char *path, char *name, char *dname, int snum )
641   /* ------------------------------------------------------------------------ **
642    * Add an entry to the directory cache.
643    *
644    *  Input:  path  -
645    *          name  -
646    *          dname -
647    *          snum  -
648    *
649    *  Output: None.
650    *
651    * ------------------------------------------------------------------------ **
652    */
653   {
654   int               pathlen;
655   int               namelen;
656   dir_cache_entry  *entry;
657
658   /* Allocate the structure & string space in one go so that it can be freed
659    * in one call to free().
660    */
661   pathlen = strlen( path ) +1;  /* Bytes required to store path (with nul). */
662   namelen = strlen( name ) +1;  /* Bytes required to store name (with nul). */
663   entry = (dir_cache_entry *)malloc( sizeof( dir_cache_entry )
664                                    + pathlen
665                                    + namelen
666                                    + strlen( dname ) +1 );
667   if( NULL == entry )   /* Not adding to the cache is not fatal,  */
668     return;             /* so just return as if nothing happened. */
669
670   /* Set pointers correctly and load values. */
671   entry->path  = pstrcpy( (char *)&entry[1],       path);
672   entry->name  = pstrcpy( &(entry->path[pathlen]), name);
673   entry->dname = pstrcpy( &(entry->name[namelen]), dname);
674   entry->snum  = snum;
675
676   /* Add the new entry to the linked list. */
677   (void)ubi_dlAddHead( dir_cache, entry );
678   DEBUG( 4, ("Added dir cache entry %s %s -> %s\n", path, name, dname ) );
679
680   /* Free excess cache entries. */
681   while( DIRCACHESIZE < dir_cache->count )
682     free( ubi_dlRemTail( dir_cache ) );
683
684   } /* DirCacheAdd */
685
686
687 char *DirCacheCheck( char *path, char *name, int snum )
688   /* ------------------------------------------------------------------------ **
689    * Search for an entry to the directory cache.
690    *
691    *  Input:  path  -
692    *          name  -
693    *          snum  -
694    *
695    *  Output: The dname string of the located entry, or NULL if the entry was
696    *          not found.
697    *
698    *  Notes:  This uses a linear search, which is is okay because of
699    *          the small size of the cache.  Use a splay tree or hash
700    *          for large caches.
701    *
702    * ------------------------------------------------------------------------ **
703    */
704   {
705   dir_cache_entry *entry;
706
707   for( entry = (dir_cache_entry *)ubi_dlFirst( dir_cache );
708        NULL != entry;
709        entry = (dir_cache_entry *)ubi_dlNext( entry ) )
710     {
711     if( entry->snum == snum
712         && 0 == strcmp( name, entry->name )
713         && 0 == strcmp( path, entry->path ) )
714       {
715       DEBUG(4, ("Got dir cache hit on %s %s -> %s\n",path,name,entry->dname));
716       return( entry->dname );
717       }
718     }
719
720   return(NULL);
721   } /* DirCacheCheck */
722
723 void DirCacheFlush(int snum)
724   /* ------------------------------------------------------------------------ **
725    * Remove all cache entries which have an snum that matches the input.
726    *
727    *  Input:  snum  -
728    *
729    *  Output: None.
730    *
731    * ------------------------------------------------------------------------ **
732    */
733 {
734         dir_cache_entry *entry;
735         ubi_dlNodePtr    next;
736
737         for(entry = (dir_cache_entry *)ubi_dlFirst( dir_cache ); 
738             NULL != entry; )  {
739                 next = ubi_dlNext( entry );
740                 if( entry->snum == snum )
741                         free( ubi_dlRemThis( dir_cache, entry ) );
742                 entry = (dir_cache_entry *)next;
743         }
744 } /* DirCacheFlush */
745
746 /* -------------------------------------------------------------------------- **
747  * End of the section that manages the global directory cache.
748  * -------------------------------------------------------------------------- **
749  */
750
751