Add a in-memory cache
[nivanova/samba-autobuild/.git] / source3 / smbd / vfs.c
1 /*
2    Unix SMB/Netbios implementation.
3    Version 1.9.
4    VFS initialisation and support functions
5    Copyright (C) Tim Potter 1999
6    Copyright (C) Alexander Bokovoy 2002
7    Copyright (C) James Peach 2006
8
9    This program is free software; you can redistribute it and/or modify
10    it under the terms of the GNU General Public License as published by
11    the Free Software Foundation; either version 3 of the License, or
12    (at your option) any later version.
13
14    This program is distributed in the hope that it will be useful,
15    but WITHOUT ANY WARRANTY; without even the implied warranty of
16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17    GNU General Public License for more details.
18
19    You should have received a copy of the GNU General Public License
20    along with this program.  If not, see <http://www.gnu.org/licenses/>.
21
22    This work was sponsored by Optifacio Software Services, Inc.
23 */
24
25 #include "includes.h"
26
27 #undef DBGC_CLASS
28 #define DBGC_CLASS DBGC_VFS
29
30 static_decl_vfs;
31
32 struct vfs_init_function_entry {
33         char *name;
34         vfs_op_tuple *vfs_op_tuples;
35         struct vfs_init_function_entry *prev, *next;
36 };
37
38 static struct vfs_init_function_entry *backends = NULL;
39
40 /****************************************************************************
41     maintain the list of available backends
42 ****************************************************************************/
43
44 static struct vfs_init_function_entry *vfs_find_backend_entry(const char *name)
45 {
46         struct vfs_init_function_entry *entry = backends;
47
48         DEBUG(10, ("vfs_find_backend_entry called for %s\n", name));
49  
50         while(entry) {
51                 if (strcmp(entry->name, name)==0) return entry;
52                 entry = entry->next;
53         }
54
55         return NULL;
56 }
57
58 NTSTATUS smb_register_vfs(int version, const char *name, vfs_op_tuple *vfs_op_tuples)
59 {
60         struct vfs_init_function_entry *entry = backends;
61
62         if ((version != SMB_VFS_INTERFACE_VERSION)) {
63                 DEBUG(0, ("Failed to register vfs module.\n"
64                           "The module was compiled against SMB_VFS_INTERFACE_VERSION %d,\n"
65                           "current SMB_VFS_INTERFACE_VERSION is %d.\n"
66                           "Please recompile against the current Samba Version!\n",  
67                           version, SMB_VFS_INTERFACE_VERSION));
68                 return NT_STATUS_OBJECT_TYPE_MISMATCH;
69         }
70
71         if (!name || !name[0] || !vfs_op_tuples) {
72                 DEBUG(0,("smb_register_vfs() called with NULL pointer or empty name!\n"));
73                 return NT_STATUS_INVALID_PARAMETER;
74         }
75
76         if (vfs_find_backend_entry(name)) {
77                 DEBUG(0,("VFS module %s already loaded!\n", name));
78                 return NT_STATUS_OBJECT_NAME_COLLISION;
79         }
80
81         entry = SMB_XMALLOC_P(struct vfs_init_function_entry);
82         entry->name = smb_xstrdup(name);
83         entry->vfs_op_tuples = vfs_op_tuples;
84
85         DLIST_ADD(backends, entry);
86         DEBUG(5, ("Successfully added vfs backend '%s'\n", name));
87         return NT_STATUS_OK;
88 }
89
90 /****************************************************************************
91   initialise default vfs hooks
92 ****************************************************************************/
93
94 static void vfs_init_default(connection_struct *conn)
95 {
96         DEBUG(3, ("Initialising default vfs hooks\n"));
97         vfs_init_custom(conn, DEFAULT_VFS_MODULE_NAME);
98 }
99
100 /****************************************************************************
101   initialise custom vfs hooks
102  ****************************************************************************/
103
104 static inline void vfs_set_operation(struct vfs_ops * vfs, vfs_op_type which,
105                                 struct vfs_handle_struct * handle, void * op)
106 {
107         ((struct vfs_handle_struct **)&vfs->handles)[which] = handle;
108         ((void **)(void *)&vfs->ops)[which] = op;
109 }
110
111 bool vfs_init_custom(connection_struct *conn, const char *vfs_object)
112 {
113         vfs_op_tuple *ops;
114         char *module_path = NULL;
115         char *module_name = NULL;
116         char *module_param = NULL, *p;
117         int i;
118         vfs_handle_struct *handle;
119         struct vfs_init_function_entry *entry;
120         
121         if (!conn||!vfs_object||!vfs_object[0]) {
122                 DEBUG(0,("vfs_init_custon() called with NULL pointer or emtpy vfs_object!\n"));
123                 return False;
124         }
125
126         if(!backends) {
127                 static_init_vfs;
128         }
129
130         DEBUG(3, ("Initialising custom vfs hooks from [%s]\n", vfs_object));
131
132         module_path = smb_xstrdup(vfs_object);
133
134         p = strchr_m(module_path, ':');
135
136         if (p) {
137                 *p = 0;
138                 module_param = p+1;
139                 trim_char(module_param, ' ', ' ');
140         }
141
142         trim_char(module_path, ' ', ' ');
143
144         module_name = smb_xstrdup(module_path);
145
146         if ((module_name[0] == '/') &&
147             (strcmp(module_path, DEFAULT_VFS_MODULE_NAME) != 0)) {
148
149                 /*
150                  * Extract the module name from the path. Just use the base
151                  * name of the last path component.
152                  */
153
154                 SAFE_FREE(module_name);
155                 module_name = smb_xstrdup(strrchr_m(module_path, '/')+1);
156
157                 p = strchr_m(module_name, '.');
158
159                 if (p != NULL) {
160                         *p = '\0';
161                 }
162         }
163
164         /* First, try to load the module with the new module system */
165         if((entry = vfs_find_backend_entry(module_name)) || 
166            (NT_STATUS_IS_OK(smb_probe_module("vfs", module_path)) &&
167                 (entry = vfs_find_backend_entry(module_name)))) {
168
169                 DEBUGADD(5,("Successfully loaded vfs module [%s] with the new modules system\n", vfs_object));
170                 
171                 if ((ops = entry->vfs_op_tuples) == NULL) {
172                         DEBUG(0, ("entry->vfs_op_tuples==NULL for [%s] failed\n", vfs_object));
173                         goto fail;
174                 }
175         } else {
176                 DEBUG(0,("Can't find a vfs module [%s]\n",vfs_object));
177                 goto fail;
178         }
179
180         handle = TALLOC_ZERO_P(conn->mem_ctx,vfs_handle_struct);
181         if (!handle) {
182                 DEBUG(0,("TALLOC_ZERO() failed!\n"));
183                 goto fail;
184         }
185         memcpy(&handle->vfs_next, &conn->vfs, sizeof(struct vfs_ops));
186         handle->conn = conn;
187         if (module_param) {
188                 handle->param = talloc_strdup(conn->mem_ctx, module_param);
189         }
190         DLIST_ADD(conn->vfs_handles, handle);
191
192         for(i=0; ops[i].op != NULL; i++) {
193                 DEBUG(5, ("Checking operation #%d (type %d, layer %d)\n", i, ops[i].type, ops[i].layer));
194                 if(ops[i].layer == SMB_VFS_LAYER_OPAQUE) {
195                         /* If this operation was already made opaque by different module, it
196                          * will be overridden here.
197                          */
198                         DEBUGADD(5, ("Making operation type %d opaque [module %s]\n", ops[i].type, vfs_object));
199                         vfs_set_operation(&conn->vfs_opaque, ops[i].type, handle, ops[i].op);
200                 }
201                 /* Change current VFS disposition*/
202                 DEBUGADD(5, ("Accepting operation type %d from module %s\n", ops[i].type, vfs_object));
203                 vfs_set_operation(&conn->vfs, ops[i].type, handle, ops[i].op);
204         }
205
206         SAFE_FREE(module_path);
207         SAFE_FREE(module_name);
208         return True;
209
210  fail:
211         SAFE_FREE(module_path);
212         SAFE_FREE(module_name);
213         return False;
214 }
215
216 /*****************************************************************
217  Allow VFS modules to extend files_struct with VFS-specific state.
218  This will be ok for small numbers of extensions, but might need to
219  be refactored if it becomes more widely used.
220 ******************************************************************/
221
222 #define EXT_DATA_AREA(e) ((uint8 *)(e) + sizeof(struct vfs_fsp_data))
223
224 void *vfs_add_fsp_extension_notype(vfs_handle_struct *handle, files_struct *fsp, size_t ext_size)
225 {
226         struct vfs_fsp_data *ext;
227         void * ext_data;
228
229         /* Prevent VFS modules adding multiple extensions. */
230         if ((ext_data = vfs_fetch_fsp_extension(handle, fsp))) {
231                 return ext_data;
232         }
233
234         ext = (struct vfs_fsp_data *)TALLOC_ZERO(
235                 handle->conn->mem_ctx, sizeof(struct vfs_fsp_data) + ext_size);
236         if (ext == NULL) {
237                 return NULL;
238         }
239
240         ext->owner = handle;
241         ext->next = fsp->vfs_extension;
242         fsp->vfs_extension = ext;
243         return EXT_DATA_AREA(ext);
244 }
245
246 void vfs_remove_fsp_extension(vfs_handle_struct *handle, files_struct *fsp)
247 {
248         struct vfs_fsp_data *curr;
249         struct vfs_fsp_data *prev;
250
251         for (curr = fsp->vfs_extension, prev = NULL;
252              curr;
253              prev = curr, curr = curr->next) {
254                 if (curr->owner == handle) {
255                     if (prev) {
256                             prev->next = curr->next;
257                     } else {
258                             fsp->vfs_extension = curr->next;
259                     }
260                     TALLOC_FREE(curr);
261                     return;
262                 }
263         }
264 }
265
266 void *vfs_fetch_fsp_extension(vfs_handle_struct *handle, files_struct *fsp)
267 {
268         struct vfs_fsp_data *head;
269
270         for (head = fsp->vfs_extension; head; head = head->next) {
271                 if (head->owner == handle) {
272                         return EXT_DATA_AREA(head);
273                 }
274         }
275
276         return NULL;
277 }
278
279 #undef EXT_DATA_AREA
280
281 /*****************************************************************
282  Generic VFS init.
283 ******************************************************************/
284
285 bool smbd_vfs_init(connection_struct *conn)
286 {
287         const char **vfs_objects;
288         unsigned int i = 0;
289         int j = 0;
290         
291         /* Normal share - initialise with disk access functions */
292         vfs_init_default(conn);
293         vfs_objects = lp_vfs_objects(SNUM(conn));
294
295         /* Override VFS functions if 'vfs object' was not specified*/
296         if (!vfs_objects || !vfs_objects[0])
297                 return True;
298         
299         for (i=0; vfs_objects[i] ;) {
300                 i++;
301         }
302
303         for (j=i-1; j >= 0; j--) {
304                 if (!vfs_init_custom(conn, vfs_objects[j])) {
305                         DEBUG(0, ("smbd_vfs_init: vfs_init_custom failed for %s\n", vfs_objects[j]));
306                         return False;
307                 }
308         }
309         return True;
310 }
311
312 /*******************************************************************
313  Check if directory exists.
314 ********************************************************************/
315
316 bool vfs_directory_exist(connection_struct *conn, const char *dname, SMB_STRUCT_STAT *st)
317 {
318         SMB_STRUCT_STAT st2;
319         bool ret;
320
321         if (!st)
322                 st = &st2;
323
324         if (SMB_VFS_STAT(conn,dname,st) != 0)
325                 return(False);
326
327         ret = S_ISDIR(st->st_mode);
328         if(!ret)
329                 errno = ENOTDIR;
330
331         return ret;
332 }
333
334 /*******************************************************************
335  Check if an object exists in the vfs.
336 ********************************************************************/
337
338 bool vfs_object_exist(connection_struct *conn,const char *fname,SMB_STRUCT_STAT *sbuf)
339 {
340         SMB_STRUCT_STAT st;
341
342         if (!sbuf)
343                 sbuf = &st;
344
345         ZERO_STRUCTP(sbuf);
346
347         if (SMB_VFS_STAT(conn,fname,sbuf) == -1)
348                 return(False);
349         return True;
350 }
351
352 /*******************************************************************
353  Check if a file exists in the vfs.
354 ********************************************************************/
355
356 bool vfs_file_exist(connection_struct *conn, const char *fname,SMB_STRUCT_STAT *sbuf)
357 {
358         SMB_STRUCT_STAT st;
359
360         if (!sbuf)
361                 sbuf = &st;
362
363         ZERO_STRUCTP(sbuf);
364
365         if (SMB_VFS_STAT(conn,fname,sbuf) == -1)
366                 return False;
367         return(S_ISREG(sbuf->st_mode));
368 }
369
370 /****************************************************************************
371  Read data from fsp on the vfs. (note: EINTR re-read differs from vfs_write_data)
372 ****************************************************************************/
373
374 ssize_t vfs_read_data(files_struct *fsp, char *buf, size_t byte_count)
375 {
376         size_t total=0;
377
378         while (total < byte_count)
379         {
380                 ssize_t ret = SMB_VFS_READ(fsp, fsp->fh->fd, buf + total,
381                                         byte_count - total);
382
383                 if (ret == 0) return total;
384                 if (ret == -1) {
385                         if (errno == EINTR)
386                                 continue;
387                         else
388                                 return -1;
389                 }
390                 total += ret;
391         }
392         return (ssize_t)total;
393 }
394
395 ssize_t vfs_pread_data(files_struct *fsp, char *buf,
396                 size_t byte_count, SMB_OFF_T offset)
397 {
398         size_t total=0;
399
400         while (total < byte_count)
401         {
402                 ssize_t ret = SMB_VFS_PREAD(fsp, fsp->fh->fd, buf + total,
403                                         byte_count - total, offset + total);
404
405                 if (ret == 0) return total;
406                 if (ret == -1) {
407                         if (errno == EINTR)
408                                 continue;
409                         else
410                                 return -1;
411                 }
412                 total += ret;
413         }
414         return (ssize_t)total;
415 }
416
417 /****************************************************************************
418  Write data to a fd on the vfs.
419 ****************************************************************************/
420
421 ssize_t vfs_write_data(struct smb_request *req,
422                         files_struct *fsp,
423                         const char *buffer,
424                         size_t N)
425 {
426         size_t total=0;
427         ssize_t ret;
428
429         if (req && req->unread_bytes) {
430                 SMB_ASSERT(req->unread_bytes == N);
431                 /* VFS_RECVFILE must drain the socket
432                  * before returning. */
433                 req->unread_bytes = 0;
434                 return SMB_VFS_RECVFILE(smbd_server_fd(),
435                                         fsp,
436                                         fsp->fh->fd,
437                                         (SMB_OFF_T)-1,
438                                         N);
439         }
440
441         while (total < N) {
442                 ret = SMB_VFS_WRITE(fsp,fsp->fh->fd,buffer + total,N - total);
443
444                 if (ret == -1)
445                         return -1;
446                 if (ret == 0)
447                         return total;
448
449                 total += ret;
450         }
451         return (ssize_t)total;
452 }
453
454 ssize_t vfs_pwrite_data(struct smb_request *req,
455                         files_struct *fsp,
456                         const char *buffer,
457                         size_t N,
458                         SMB_OFF_T offset)
459 {
460         size_t total=0;
461         ssize_t ret;
462
463         if (req && req->unread_bytes) {
464                 SMB_ASSERT(req->unread_bytes == N);
465                 /* VFS_RECVFILE must drain the socket
466                  * before returning. */
467                 req->unread_bytes = 0;
468                 return SMB_VFS_RECVFILE(smbd_server_fd(),
469                                         fsp,
470                                         fsp->fh->fd,
471                                         offset,
472                                         N);
473         }
474
475         while (total < N) {
476                 ret = SMB_VFS_PWRITE(fsp, fsp->fh->fd, buffer + total,
477                                 N - total, offset + total);
478
479                 if (ret == -1)
480                         return -1;
481                 if (ret == 0)
482                         return total;
483
484                 total += ret;
485         }
486         return (ssize_t)total;
487 }
488 /****************************************************************************
489  An allocate file space call using the vfs interface.
490  Allocates space for a file from a filedescriptor.
491  Returns 0 on success, -1 on failure.
492 ****************************************************************************/
493
494 int vfs_allocate_file_space(files_struct *fsp, SMB_BIG_UINT len)
495 {
496         int ret;
497         SMB_STRUCT_STAT st;
498         connection_struct *conn = fsp->conn;
499         SMB_BIG_UINT space_avail;
500         SMB_BIG_UINT bsize,dfree,dsize;
501
502         release_level_2_oplocks_on_change(fsp);
503
504         /*
505          * Actually try and commit the space on disk....
506          */
507
508         DEBUG(10,("vfs_allocate_file_space: file %s, len %.0f\n", fsp->fsp_name, (double)len ));
509
510         if (((SMB_OFF_T)len) < 0) {
511                 DEBUG(0,("vfs_allocate_file_space: %s negative len requested.\n", fsp->fsp_name ));
512                 errno = EINVAL;
513                 return -1;
514         }
515
516         ret = SMB_VFS_FSTAT(fsp,fsp->fh->fd,&st);
517         if (ret == -1)
518                 return ret;
519
520         if (len == (SMB_BIG_UINT)st.st_size)
521                 return 0;
522
523         if (len < (SMB_BIG_UINT)st.st_size) {
524                 /* Shrink - use ftruncate. */
525
526                 DEBUG(10,("vfs_allocate_file_space: file %s, shrink. Current size %.0f\n",
527                                 fsp->fsp_name, (double)st.st_size ));
528
529                 flush_write_cache(fsp, SIZECHANGE_FLUSH);
530                 if ((ret = SMB_VFS_FTRUNCATE(fsp, fsp->fh->fd, (SMB_OFF_T)len)) != -1) {
531                         set_filelen_write_cache(fsp, len);
532                 }
533                 return ret;
534         }
535
536         /* Grow - we need to test if we have enough space. */
537
538         if (!lp_strict_allocate(SNUM(fsp->conn)))
539                 return 0;
540
541         len -= st.st_size;
542         len /= 1024; /* Len is now number of 1k blocks needed. */
543         space_avail = get_dfree_info(conn,fsp->fsp_name,False,&bsize,&dfree,&dsize);
544         if (space_avail == (SMB_BIG_UINT)-1) {
545                 return -1;
546         }
547
548         DEBUG(10,("vfs_allocate_file_space: file %s, grow. Current size %.0f, needed blocks = %.0f, space avail = %.0f\n",
549                         fsp->fsp_name, (double)st.st_size, (double)len, (double)space_avail ));
550
551         if (len > space_avail) {
552                 errno = ENOSPC;
553                 return -1;
554         }
555
556         return 0;
557 }
558
559 /****************************************************************************
560  A vfs set_filelen call.
561  set the length of a file from a filedescriptor.
562  Returns 0 on success, -1 on failure.
563 ****************************************************************************/
564
565 int vfs_set_filelen(files_struct *fsp, SMB_OFF_T len)
566 {
567         int ret;
568
569         release_level_2_oplocks_on_change(fsp);
570         DEBUG(10,("vfs_set_filelen: ftruncate %s to len %.0f\n", fsp->fsp_name, (double)len));
571         flush_write_cache(fsp, SIZECHANGE_FLUSH);
572         if ((ret = SMB_VFS_FTRUNCATE(fsp, fsp->fh->fd, len)) != -1) {
573                 set_filelen_write_cache(fsp, len);
574                 notify_fname(fsp->conn, NOTIFY_ACTION_MODIFIED,
575                              FILE_NOTIFY_CHANGE_SIZE
576                              | FILE_NOTIFY_CHANGE_ATTRIBUTES,
577                              fsp->fsp_name);
578         }
579
580         return ret;
581 }
582
583 /****************************************************************************
584  A vfs fill sparse call.
585  Writes zeros from the end of file to len, if len is greater than EOF.
586  Used only by strict_sync.
587  Returns 0 on success, -1 on failure.
588 ****************************************************************************/
589
590 static char *sparse_buf;
591 #define SPARSE_BUF_WRITE_SIZE (32*1024)
592
593 int vfs_fill_sparse(files_struct *fsp, SMB_OFF_T len)
594 {
595         int ret;
596         SMB_STRUCT_STAT st;
597         SMB_OFF_T offset;
598         size_t total;
599         size_t num_to_write;
600         ssize_t pwrite_ret;
601
602         release_level_2_oplocks_on_change(fsp);
603         ret = SMB_VFS_FSTAT(fsp,fsp->fh->fd,&st);
604         if (ret == -1) {
605                 return ret;
606         }
607
608         if (len <= st.st_size) {
609                 return 0;
610         }
611
612         DEBUG(10,("vfs_fill_sparse: write zeros in file %s from len %.0f to len %.0f (%.0f bytes)\n",
613                 fsp->fsp_name, (double)st.st_size, (double)len, (double)(len - st.st_size)));
614
615         flush_write_cache(fsp, SIZECHANGE_FLUSH);
616
617         if (!sparse_buf) {
618                 sparse_buf = SMB_CALLOC_ARRAY(char, SPARSE_BUF_WRITE_SIZE);
619                 if (!sparse_buf) {
620                         errno = ENOMEM;
621                         return -1;
622                 }
623         }
624
625         offset = st.st_size;
626         num_to_write = len - st.st_size;
627         total = 0;
628
629         while (total < num_to_write) {
630                 size_t curr_write_size = MIN(SPARSE_BUF_WRITE_SIZE, (num_to_write - total));
631
632                 pwrite_ret = SMB_VFS_PWRITE(fsp, fsp->fh->fd, sparse_buf, curr_write_size, offset + total);
633                 if (pwrite_ret == -1) {
634                         DEBUG(10,("vfs_fill_sparse: SMB_VFS_PWRITE for file %s failed with error %s\n",
635                                 fsp->fsp_name, strerror(errno) ));
636                         return -1;
637                 }
638                 if (pwrite_ret == 0) {
639                         return 0;
640                 }
641
642                 total += pwrite_ret;
643         }
644
645         set_filelen_write_cache(fsp, len);
646         return 0;
647 }
648
649 /****************************************************************************
650  Transfer some data (n bytes) between two file_struct's.
651 ****************************************************************************/
652
653 static files_struct *in_fsp;
654 static files_struct *out_fsp;
655
656 static ssize_t read_fn(int fd, void *buf, size_t len)
657 {
658         return SMB_VFS_READ(in_fsp, fd, buf, len);
659 }
660
661 static ssize_t write_fn(int fd, const void *buf, size_t len)
662 {
663         return SMB_VFS_WRITE(out_fsp, fd, buf, len);
664 }
665
666 SMB_OFF_T vfs_transfer_file(files_struct *in, files_struct *out, SMB_OFF_T n)
667 {
668         in_fsp = in;
669         out_fsp = out;
670
671         return transfer_file_internal(in_fsp->fh->fd, out_fsp->fh->fd, n, read_fn, write_fn);
672 }
673
674 /*******************************************************************
675  A vfs_readdir wrapper which just returns the file name.
676 ********************************************************************/
677
678 char *vfs_readdirname(connection_struct *conn, void *p)
679 {
680         SMB_STRUCT_DIRENT *ptr= NULL;
681         char *dname;
682
683         if (!p)
684                 return(NULL);
685
686         ptr = SMB_VFS_READDIR(conn, (DIR *)p);
687         if (!ptr)
688                 return(NULL);
689
690         dname = ptr->d_name;
691
692 #ifdef NEXT2
693         if (telldir(p) < 0)
694                 return(NULL);
695 #endif
696
697 #ifdef HAVE_BROKEN_READDIR_NAME
698         /* using /usr/ucb/cc is BAD */
699         dname = dname - 2;
700 #endif
701
702         return(dname);
703 }
704
705 /*******************************************************************
706  A wrapper for vfs_chdir().
707 ********************************************************************/
708
709 int vfs_ChDir(connection_struct *conn, const char *path)
710 {
711         int res;
712         static char *LastDir = NULL;
713
714         if (!LastDir) {
715                 LastDir = SMB_STRDUP("");
716         }
717
718         if (strcsequal(path,"."))
719                 return(0);
720
721         if (*path == '/' && strcsequal(LastDir,path))
722                 return(0);
723
724         DEBUG(4,("vfs_ChDir to %s\n",path));
725
726         res = SMB_VFS_CHDIR(conn,path);
727         if (!res) {
728                 SAFE_FREE(LastDir);
729                 LastDir = SMB_STRDUP(path);
730         }
731         return(res);
732 }
733
734 /*******************************************************************
735  Return the absolute current directory path - given a UNIX pathname.
736  Note that this path is returned in DOS format, not UNIX
737  format. Note this can be called with conn == NULL.
738 ********************************************************************/
739
740 struct getwd_cache_key {
741         SMB_DEV_T dev;
742         SMB_INO_T ino;
743 };
744
745 char *vfs_GetWd(TALLOC_CTX *ctx, connection_struct *conn)
746 {
747         char s[PATH_MAX+1];
748         SMB_STRUCT_STAT st, st2;
749         char *result;
750         DATA_BLOB cache_value;
751         struct getwd_cache_key key;
752
753         *s = 0;
754
755         if (!lp_getwd_cache()) {
756                 goto nocache;
757         }
758
759         SET_STAT_INVALID(st);
760
761         if (SMB_VFS_STAT(conn, ".",&st) == -1) {
762                 /*
763                  * Known to fail for root: the directory may be NFS-mounted
764                  * and exported with root_squash (so has no root access).
765                  */
766                 DEBUG(1,("vfs_GetWd: couldn't stat \".\" error %s "
767                          "(NFS problem ?)\n", strerror(errno) ));
768                 goto nocache;
769         }
770
771         ZERO_STRUCT(key); /* unlikely, but possible padding */
772         key.dev = st.st_dev;
773         key.ino = st.st_ino;
774
775         if (!memcache_lookup(smbd_memcache(), GETWD_CACHE,
776                              data_blob_const(&key, sizeof(key)),
777                              &cache_value)) {
778                 goto nocache;
779         }
780
781         SMB_ASSERT((cache_value.length > 0)
782                    && (cache_value.data[cache_value.length-1] == '\0'));
783
784         if ((SMB_VFS_STAT(conn, (char *)cache_value.data, &st2) == 0)
785             && (st.st_dev == st2.st_dev) && (st.st_ino == st2.st_ino)
786             && (S_ISDIR(st.st_mode))) {
787                 /*
788                  * Ok, we're done
789                  */
790                 result = talloc_strdup(ctx, (char *)cache_value.data);
791                 if (result == NULL) {
792                         errno = ENOMEM;
793                 }
794                 return result;
795         }
796
797  nocache:
798
799         /*
800          * We don't have the information to hand so rely on traditional
801          * methods. The very slow getcwd, which spawns a process on some
802          * systems, or the not quite so bad getwd.
803          */
804
805         if (!SMB_VFS_GETWD(conn,s)) {
806                 DEBUG(0, ("vfs_GetWd: SMB_VFS_GETWD call failed: %s\n",
807                           strerror(errno)));
808                 return NULL;
809         }
810
811         if (lp_getwd_cache() && VALID_STAT(st)) {
812                 ZERO_STRUCT(key); /* unlikely, but possible padding */
813                 key.dev = st.st_dev;
814                 key.ino = st.st_ino;
815
816                 memcache_add(smbd_memcache(), GETWD_CACHE,
817                              data_blob_const(&key, sizeof(key)),
818                              data_blob_const(s, strlen(s)+1));
819         }
820
821         result = talloc_strdup(ctx, s);
822         if (result == NULL) {
823                 errno = ENOMEM;
824         }
825         return result;
826 }
827
828 /*******************************************************************
829  Reduce a file name, removing .. elements and checking that
830  it is below dir in the heirachy. This uses realpath.
831 ********************************************************************/
832
833 NTSTATUS check_reduced_name(connection_struct *conn, const char *fname)
834 {
835 #ifdef REALPATH_TAKES_NULL
836         bool free_resolved_name = True;
837 #else
838         char resolved_name_buf[PATH_MAX+1];
839         bool free_resolved_name = False;
840 #endif
841         char *resolved_name = NULL;
842         size_t con_path_len = strlen(conn->connectpath);
843         char *p = NULL;
844
845         DEBUG(3,("reduce_name [%s] [%s]\n", fname, conn->connectpath));
846
847 #ifdef REALPATH_TAKES_NULL
848         resolved_name = SMB_VFS_REALPATH(conn,fname,NULL);
849 #else
850         resolved_name = SMB_VFS_REALPATH(conn,fname,resolved_name_buf);
851 #endif
852
853         if (!resolved_name) {
854                 switch (errno) {
855                         case ENOTDIR:
856                                 DEBUG(3,("reduce_name: Component not a directory in getting realpath for %s\n", fname));
857                                 return map_nt_error_from_unix(errno);
858                         case ENOENT:
859                         {
860                                 TALLOC_CTX *tmp_ctx = talloc_stackframe();
861                                 char *tmp_fname = NULL;
862                                 char *last_component = NULL;
863                                 /* Last component didn't exist. Remove it and try and canonicalise the directory. */
864
865                                 tmp_fname = talloc_strdup(tmp_ctx, fname);
866                                 if (!tmp_fname) {
867                                         TALLOC_FREE(tmp_ctx);
868                                         return NT_STATUS_NO_MEMORY;
869                                 }
870                                 p = strrchr_m(tmp_fname, '/');
871                                 if (p) {
872                                         *p++ = '\0';
873                                         last_component = p;
874                                 } else {
875                                         last_component = tmp_fname;
876                                         tmp_fname = talloc_strdup(tmp_ctx,
877                                                         ".");
878                                         if (!tmp_fname) {
879                                                 TALLOC_FREE(tmp_ctx);
880                                                 return NT_STATUS_NO_MEMORY;
881                                         }
882                                 }
883
884 #ifdef REALPATH_TAKES_NULL
885                                 resolved_name = SMB_VFS_REALPATH(conn,tmp_fname,NULL);
886 #else
887                                 resolved_name = SMB_VFS_REALPATH(conn,tmp_fname,resolved_name_buf);
888 #endif
889                                 if (!resolved_name) {
890                                         DEBUG(3,("reduce_name: couldn't get realpath for %s\n", fname));
891                                         TALLOC_FREE(tmp_ctx);
892                                         return map_nt_error_from_unix(errno);
893                                 }
894                                 tmp_fname = talloc_asprintf(tmp_ctx,
895                                                 "%s/%s",
896                                                 resolved_name,
897                                                 last_component);
898                                 if (!tmp_fname) {
899                                         TALLOC_FREE(tmp_ctx);
900                                         return NT_STATUS_NO_MEMORY;
901                                 }
902 #ifdef REALPATH_TAKES_NULL
903                                 SAFE_FREE(resolved_name);
904                                 resolved_name = SMB_STRDUP(tmp_fname);
905                                 if (!resolved_name) {
906                                         DEBUG(0,("reduce_name: malloc fail for %s\n", tmp_fname));
907                                         return NT_STATUS_NO_MEMORY;
908                                 }
909 #else
910                                 safe_strcpy(resolved_name_buf, tmp_fname, PATH_MAX);
911                                 resolved_name = resolved_name_buf;
912 #endif
913                                 TALLOC_FREE(tmp_ctx);
914                                 break;
915                         }
916                         default:
917                                 DEBUG(1,("reduce_name: couldn't get realpath for %s\n", fname));
918                                 return map_nt_error_from_unix(errno);
919                 }
920         }
921
922         DEBUG(10,("reduce_name realpath [%s] -> [%s]\n", fname, resolved_name));
923
924         if (*resolved_name != '/') {
925                 DEBUG(0,("reduce_name: realpath doesn't return absolute paths !\n"));
926                 if (free_resolved_name) {
927                         SAFE_FREE(resolved_name);
928                 }
929                 return NT_STATUS_OBJECT_NAME_INVALID;
930         }
931
932         /* Check for widelinks allowed. */
933         if (!lp_widelinks(SNUM(conn)) && (strncmp(conn->connectpath, resolved_name, con_path_len) != 0)) {
934                 DEBUG(2, ("reduce_name: Bad access attempt: %s is a symlink outside the share path", fname));
935                 if (free_resolved_name) {
936                         SAFE_FREE(resolved_name);
937                 }
938                 return NT_STATUS_ACCESS_DENIED;
939         }
940
941         /* Check if we are allowing users to follow symlinks */
942         /* Patch from David Clerc <David.Clerc@cui.unige.ch>
943                 University of Geneva */
944
945 #ifdef S_ISLNK
946         if (!lp_symlinks(SNUM(conn))) {
947                 SMB_STRUCT_STAT statbuf;
948                 if ( (SMB_VFS_LSTAT(conn,fname,&statbuf) != -1) &&
949                                 (S_ISLNK(statbuf.st_mode)) ) {
950                         if (free_resolved_name) {
951                                 SAFE_FREE(resolved_name);
952                         }
953                         DEBUG(3,("reduce_name: denied: file path name %s is a symlink\n",resolved_name));
954                         return NT_STATUS_ACCESS_DENIED;
955                 }
956         }
957 #endif
958
959         DEBUG(3,("reduce_name: %s reduced to %s\n", fname, resolved_name));
960         if (free_resolved_name) {
961                 SAFE_FREE(resolved_name);
962         }
963         return NT_STATUS_OK;
964 }