r3133: - more consistent error checking in rename and setfileinfo
[gd/samba-autobuild/.git] / source4 / ntvfs / posix / pvfs_resolve.c
1 /* 
2    Unix SMB/CIFS implementation.
3
4    POSIX NTVFS backend - filename resolution
5
6    Copyright (C) Andrew Tridgell 2004
7
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 2 of the License, or
11    (at your option) any later version.
12    
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17    
18    You should have received a copy of the GNU General Public License
19    along with this program; if not, write to the Free Software
20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 */
22
23 /*
24   this is the core code for converting a filename from the format as
25   given by a client to a posix filename, including any case-matching
26   required, and checks for legal characters
27 */
28
29
30 #include "include/includes.h"
31 #include "vfs_posix.h"
32
33 /*
34   compare two filename components. This is where the name mangling hook will go
35 */
36 static int component_compare(struct pvfs_state *pvfs, const char *comp, const char *name)
37 {
38         int ret;
39
40         ret = StrCaseCmp(comp, name);
41
42         if (ret != 0) {
43                 char *shortname = pvfs_short_name_component(pvfs, name);
44                 if (shortname) {
45                         ret = StrCaseCmp(comp, shortname);
46                         talloc_free(shortname);
47                 }
48         }
49
50         return ret;
51 }
52
53 /*
54   search for a filename in a case insensitive fashion
55
56   TODO: add a cache for previously resolved case-insensitive names
57   TODO: add mangled name support
58 */
59 static NTSTATUS pvfs_case_search(struct pvfs_state *pvfs, struct pvfs_filename *name)
60 {
61         /* break into a series of components */
62         int num_components;
63         char **components;
64         char *p, *partial_name;
65         int i;
66
67         /* break up the full name info pathname components */
68         num_components=2;
69         p = name->full_name + strlen(pvfs->base_directory) + 1;
70
71         for (;*p;p++) {
72                 if (*p == '/') {
73                         num_components++;
74                 }
75         }
76
77         components = talloc_array_p(name, char *, num_components);
78         p = name->full_name + strlen(pvfs->base_directory);
79         *p++ = 0;
80
81         components[0] = name->full_name;
82
83         for (i=1;i<num_components;i++) {
84                 components[i] = p;
85                 p = strchr(p, '/');
86                 if (p) *p++ = 0;
87                 if (pvfs_is_reserved_name(pvfs, components[i])) {
88                         return NT_STATUS_ACCESS_DENIED;
89                 }
90         }
91
92         partial_name = talloc_strdup(name, components[0]);
93         if (!partial_name) {
94                 return NT_STATUS_NO_MEMORY;
95         }
96
97         /* for each component, check if it exists as-is, and if not then
98            do a directory scan */
99         for (i=1;i<num_components;i++) {
100                 char *test_name;
101                 DIR *dir;
102                 struct dirent *de;
103                 char *long_component;
104
105                 /* possibly remap from the short name cache */
106                 long_component = pvfs_mangled_lookup(pvfs, name, components[i]);
107                 if (long_component) {
108                         components[i] = long_component;
109                 }
110
111                 test_name = talloc_asprintf(name, "%s/%s", partial_name, components[i]);
112                 if (!test_name) {
113                         return NT_STATUS_NO_MEMORY;
114                 }
115
116                 /* check if this component exists as-is */
117                 if (stat(test_name, &name->st) == 0) {
118                         if (i<num_components-1 && !S_ISDIR(name->st.st_mode)) {
119                                 return NT_STATUS_NOT_A_DIRECTORY;
120                         }
121                         talloc_free(partial_name);
122                         partial_name = test_name;
123                         if (i == num_components - 1) {
124                                 name->exists = True;
125                         }
126                         continue;
127                 }
128                 
129                 dir = opendir(partial_name);
130                 if (!dir) {
131                         return pvfs_map_errno(pvfs, errno);
132                 }
133
134                 while ((de = readdir(dir))) {
135                         if (component_compare(pvfs, components[i], de->d_name) == 0) {
136                                 break;
137                         }
138                 }
139
140                 if (!de) {
141                         if (i < num_components-1) {
142                                 closedir(dir);
143                                 return NT_STATUS_OBJECT_PATH_NOT_FOUND;
144                         }
145                 } else {
146                         components[i] = talloc_strdup(name, de->d_name);
147                 }
148                 test_name = talloc_asprintf(name, "%s/%s", partial_name, components[i]);
149                 talloc_free(partial_name);
150                 partial_name = test_name;
151
152                 closedir(dir);
153         }
154
155         if (!name->exists) {
156                 if (stat(partial_name, &name->st) == 0) {
157                         name->exists = True;
158                 }
159         }
160
161         talloc_free(name->full_name);
162         name->full_name = partial_name;
163
164         if (name->exists) {
165                 return pvfs_fill_dos_info(pvfs, name);
166         }
167
168         return NT_STATUS_OK;
169 }
170
171
172 /*
173   convert a CIFS pathname to a unix pathname. Note that this does NOT
174   take into account case insensitivity, and in fact does not access
175   the filesystem at all. It is merely a reformatting and charset
176   checking routine.
177
178   errors are returned if the filename is illegal given the flags
179 */
180 static NTSTATUS pvfs_unix_path(struct pvfs_state *pvfs, const char *cifs_name,
181                                uint_t flags, struct pvfs_filename *name)
182 {
183         char *ret, *p;
184         size_t len;
185
186         name->original_name = talloc_strdup(name, cifs_name);
187         name->stream_name = NULL;
188         name->has_wildcard = False;
189
190         while (*cifs_name == '\\') {
191                 cifs_name++;
192         }
193
194         if (*cifs_name == 0) {
195                 name->full_name = talloc_asprintf(name, "%s/.", pvfs->base_directory);
196                 if (name->full_name == NULL) {
197                         return NT_STATUS_NO_MEMORY;
198                 }
199                 return NT_STATUS_OK;
200         }
201
202         ret = talloc_asprintf(name, "%s/%s", pvfs->base_directory, cifs_name);
203         if (ret == NULL) {
204                 return NT_STATUS_NO_MEMORY;
205         }
206
207         p = ret + strlen(pvfs->base_directory) + 1;
208
209         len = strlen(cifs_name);
210         if (len>0 && p[len-1] == '\\') {
211                 p[len-1] = 0;
212                 len--;
213         }
214         if (len>1 && p[len-1] == '.' && p[len-2] == '\\') {
215                 return NT_STATUS_OBJECT_NAME_INVALID;
216         }
217
218         /* now do an in-place conversion of '\' to '/', checking
219            for legal characters */
220         while (*p) {
221                 size_t c_size;
222                 codepoint_t c = next_codepoint(p, &c_size);
223                 switch (c) {
224                 case '\\':
225                         if (name->has_wildcard) {
226                                 /* wildcards are only allowed in the last part
227                                    of a name */
228                                 return NT_STATUS_ILLEGAL_CHARACTER;
229                         }
230                         *p = '/';
231                         break;
232                 case ':':
233                         if (!(flags & PVFS_RESOLVE_STREAMS)) {
234                                 return NT_STATUS_ILLEGAL_CHARACTER;
235                         }
236                         name->stream_name = talloc_strdup(name, p+1);
237                         if (name->stream_name == NULL) {
238                                 return NT_STATUS_NO_MEMORY;
239                         }
240                         *p-- = 0;
241                         break;
242                 case '*':
243                 case '>':
244                 case '<':
245                 case '?':
246                 case '"':
247                         if (flags & PVFS_RESOLVE_NO_WILDCARD) {
248                                 return NT_STATUS_ILLEGAL_CHARACTER;
249                         }
250                         name->has_wildcard = True;
251                         break;
252                 case '/':
253                 case '|':
254                         return NT_STATUS_ILLEGAL_CHARACTER;
255                 }
256
257                 p += c_size;
258         }
259
260         name->full_name = ret;
261
262         return NT_STATUS_OK;
263 }
264
265
266 /*
267   resolve a name from relative client format to a struct pvfs_filename
268   the memory for the filename is made as a talloc child of 'name'
269
270   flags include:
271      PVFS_RESOLVE_NO_WILDCARD = wildcards are considered illegal characters
272      PVFS_RESOLVE_STREAMS     = stream names are allowed
273
274      TODO: ../ collapsing, and outside share checking
275 */
276 NTSTATUS pvfs_resolve_name(struct pvfs_state *pvfs, TALLOC_CTX *mem_ctx,
277                            const char *cifs_name,
278                            uint_t flags, struct pvfs_filename **name)
279 {
280         NTSTATUS status;
281
282         *name = talloc_p(mem_ctx, struct pvfs_filename);
283         if (*name == NULL) {
284                 return NT_STATUS_NO_MEMORY;
285         }
286
287         (*name)->exists = False;
288
289         /* do the basic conversion to a unix formatted path,
290            also checking for allowable characters */
291         status = pvfs_unix_path(pvfs, cifs_name, flags, *name);
292         if (!NT_STATUS_IS_OK(status)) {
293                 return status;
294         }
295
296         /* if it has a wildcard then no point doing a stat() */
297         if ((*name)->has_wildcard) {
298                 return NT_STATUS_OK;
299         }
300
301         /* if we can stat() the full name now then we are done */
302         if (stat((*name)->full_name, &(*name)->st) == 0) {
303                 (*name)->exists = True;
304                 return pvfs_fill_dos_info(pvfs, *name);
305         }
306
307         /* the filesystem might be case insensitive, in which
308            case a search is pointless */
309         if (pvfs->flags & PVFS_FLAG_CI_FILESYSTEM) {
310                 return NT_STATUS_OK;
311         }
312
313         /* search for a matching filename */
314         status = pvfs_case_search(pvfs, *name);
315
316         return status;
317 }
318
319
320 /*
321   do a partial resolve, returning a pvfs_filename structure given a
322   base path and a relative component. It is an error if the file does
323   not exist. No case-insensitive matching is done.
324
325   this is used in places like directory searching where we need a pvfs_filename
326   to pass to a function, but already know the unix base directory and component
327 */
328 NTSTATUS pvfs_resolve_partial(struct pvfs_state *pvfs, TALLOC_CTX *mem_ctx,
329                               const char *unix_dir, const char *fname,
330                               struct pvfs_filename **name)
331 {
332         NTSTATUS status;
333
334         *name = talloc_p(mem_ctx, struct pvfs_filename);
335         if (*name == NULL) {
336                 return NT_STATUS_NO_MEMORY;
337         }
338
339         (*name)->full_name = talloc_asprintf(*name, "%s/%s", unix_dir, fname);
340         if ((*name)->full_name == NULL) {
341                 return NT_STATUS_NO_MEMORY;
342         }
343
344         if (stat((*name)->full_name, &(*name)->st) == -1) {
345                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
346         }
347
348         (*name)->exists = True;
349         (*name)->has_wildcard = False;
350         (*name)->original_name = talloc_strdup(*name, fname);
351         (*name)->stream_name = NULL;
352
353         status = pvfs_fill_dos_info(pvfs, *name);
354
355         return status;
356 }
357
358
359 /*
360   fill in the pvfs_filename info for an open file, given the current
361   info for a (possibly) non-open file. This is used by places that need
362   to update the pvfs_filename stat information, and by pvfs_open()
363 */
364 NTSTATUS pvfs_resolve_name_fd(struct pvfs_state *pvfs, int fd,
365                               struct pvfs_filename *name)
366 {
367         dev_t device;
368         ino_t inode;
369
370         if (name->exists) {
371                 device = name->st.st_dev;
372                 inode = name->st.st_ino;
373         }
374
375         if (fstat(fd, &name->st) == -1) {
376                 return NT_STATUS_INVALID_HANDLE;
377         }
378
379         if (name->exists &&
380             (device != name->st.st_dev || inode != name->st.st_ino)) {
381                 /* the file we are looking at has changed! this could
382                  be someone trying to exploit a race
383                  condition. Certainly we don't want to continue
384                  operating on this file */
385                 DEBUG(0,("pvfs: WARNING: file '%s' changed during resole - failing\n",
386                          name->full_name));
387                 return NT_STATUS_UNEXPECTED_IO_ERROR;
388         }
389
390         name->exists = True;
391         
392         return pvfs_fill_dos_info(pvfs, name);
393 }