Merge branch 'v4-0-test' of git://git.samba.org/samba into 4-0-local
[samba.git] / source4 / ntvfs / posix / pvfs_rename.c
1 /* 
2    Unix SMB/CIFS implementation.
3
4    POSIX NTVFS backend - rename
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 3 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, see <http://www.gnu.org/licenses/>.
20 */
21
22 #include "includes.h"
23 #include "vfs_posix.h"
24 #include "librpc/gen_ndr/security.h"
25 #include "param/param.h"
26
27
28 /*
29   do a file rename, and send any notify triggers
30 */
31 NTSTATUS pvfs_do_rename(struct pvfs_state *pvfs, const struct pvfs_filename *name1, 
32                         const char *name2)
33 {
34         const char *r1, *r2;
35         uint32_t mask;
36
37         if (rename(name1->full_name, name2) == -1) {
38                 return pvfs_map_errno(pvfs, errno);
39         }
40
41         if (name1->dos.attrib & FILE_ATTRIBUTE_DIRECTORY) {
42                 mask = FILE_NOTIFY_CHANGE_DIR_NAME;
43         } else {
44                 mask = FILE_NOTIFY_CHANGE_FILE_NAME;
45         }
46         /* 
47            renames to the same directory cause a OLD_NAME->NEW_NAME notify.
48            renames to a different directory are considered a remove/add 
49         */
50         r1 = strrchr_m(name1->full_name, '/');
51         r2 = strrchr_m(name2, '/');
52
53         if ((r1-name1->full_name) != (r2-name2) ||
54             strncmp(name1->full_name, name2, r1-name1->full_name) != 0) {
55                 notify_trigger(pvfs->notify_context, 
56                                NOTIFY_ACTION_REMOVED, 
57                                mask,
58                                name1->full_name);
59                 notify_trigger(pvfs->notify_context, 
60                                NOTIFY_ACTION_ADDED, 
61                                mask,
62                                name2);
63         } else {
64                 notify_trigger(pvfs->notify_context, 
65                                NOTIFY_ACTION_OLD_NAME, 
66                                mask,
67                                name1->full_name);
68                 notify_trigger(pvfs->notify_context, 
69                                NOTIFY_ACTION_NEW_NAME, 
70                                mask,
71                                name2);
72         }
73
74         /* this is a strange one. w2k3 gives an additional event for CHANGE_ATTRIBUTES
75            and CHANGE_CREATION on the new file when renaming files, but not 
76            directories */
77         if ((name1->dos.attrib & FILE_ATTRIBUTE_DIRECTORY) == 0) {
78                 notify_trigger(pvfs->notify_context, 
79                                NOTIFY_ACTION_MODIFIED, 
80                                FILE_NOTIFY_CHANGE_ATTRIBUTES|FILE_NOTIFY_CHANGE_CREATION,
81                                name2);
82         }
83         
84         return NT_STATUS_OK;
85 }
86
87
88 /*
89   resolve a wildcard rename pattern. This works on one component of the name
90 */
91 static const char *pvfs_resolve_wildcard_component(TALLOC_CTX *mem_ctx, 
92                                                    struct smb_iconv_convenience *iconv_convenience,
93                                                    const char *fname, 
94                                                    const char *pattern)
95 {
96         const char *p1, *p2;
97         char *dest, *d;
98
99         /* the length is bounded by the length of the two strings combined */
100         dest = talloc_size(mem_ctx, strlen(fname) + strlen(pattern) + 1);
101         if (dest == NULL) {
102                 return NULL;
103         }
104
105         p1 = fname;
106         p2 = pattern;
107         d = dest;
108
109         while (*p2) {
110                 codepoint_t c1, c2;
111                 size_t c_size1, c_size2;
112                 c1 = next_codepoint(iconv_convenience, p1, &c_size1);
113                 c2 = next_codepoint(iconv_convenience, p2, &c_size2);
114                 if (c2 == '?') {
115                         d += push_codepoint(iconv_convenience, d, c1);
116                 } else if (c2 == '*') {
117                         memcpy(d, p1, strlen(p1));
118                         d += strlen(p1);
119                         break;
120                 } else {
121                         d += push_codepoint(iconv_convenience, d, c2);
122                 }
123
124                 p1 += c_size1;
125                 p2 += c_size2;
126         }
127
128         *d = 0;
129
130         return dest;
131 }
132
133 /*
134   resolve a wildcard rename pattern.
135 */
136 static const char *pvfs_resolve_wildcard(TALLOC_CTX *mem_ctx, 
137                                          const char *fname, 
138                                          const char *pattern)
139 {
140         const char *base1, *base2;
141         const char *ext1, *ext2;
142         struct smb_iconv_convenience *iconv_convenience = lp_iconv_convenience(global_loadparm);
143         char *p;
144
145         /* break into base part plus extension */
146         p = strrchr_m(fname, '.');
147         if (p == NULL) {
148                 ext1 = "";
149                 base1 = fname;
150         } else {
151                 ext1 = talloc_strdup(mem_ctx, p+1);
152                 base1 = talloc_strndup(mem_ctx, fname, p-fname);
153         }
154         if (ext1 == NULL || base1 == NULL) {
155                 return NULL;
156         }
157
158         p = strrchr_m(pattern, '.');
159         if (p == NULL) {
160                 ext2 = "";
161                 base2 = fname;
162         } else {
163                 ext2 = talloc_strdup(mem_ctx, p+1);
164                 base2 = talloc_strndup(mem_ctx, pattern, p-pattern);
165         }
166         if (ext2 == NULL || base2 == NULL) {
167                 return NULL;
168         }
169
170         base1 = pvfs_resolve_wildcard_component(mem_ctx, iconv_convenience, base1, base2);
171         ext1 = pvfs_resolve_wildcard_component(mem_ctx, iconv_convenience, ext1, ext2);
172         if (base1 == NULL || ext1 == NULL) {
173                 return NULL;
174         }
175
176         if (*ext1 == 0) {
177                 return base1;
178         }
179
180         return talloc_asprintf(mem_ctx, "%s.%s", base1, ext1);
181 }
182
183 /*
184   retry an rename after a sharing violation
185 */
186 static void pvfs_retry_rename(struct pvfs_odb_retry *r,
187                               struct ntvfs_module_context *ntvfs,
188                               struct ntvfs_request *req,
189                               void *_io,
190                               void *private_data,
191                               enum pvfs_wait_notice reason)
192 {
193         union smb_rename *io = talloc_get_type(_io, union smb_rename);
194         NTSTATUS status = NT_STATUS_INTERNAL_ERROR;
195
196         talloc_free(r);
197
198         switch (reason) {
199         case PVFS_WAIT_CANCEL:
200 /*TODO*/
201                 status = NT_STATUS_CANCELLED;
202                 break;
203         case PVFS_WAIT_TIMEOUT:
204                 /* if it timed out, then give the failure
205                    immediately */
206 /*TODO*/
207                 status = NT_STATUS_SHARING_VIOLATION;
208                 break;
209         case PVFS_WAIT_EVENT:
210
211                 /* try the open again, which could trigger another retry setup
212                    if it wants to, so we have to unmark the async flag so we
213                    will know if it does a second async reply */
214                 req->async_states->state &= ~NTVFS_ASYNC_STATE_ASYNC;
215
216                 status = pvfs_rename(ntvfs, req, io);
217                 if (req->async_states->state & NTVFS_ASYNC_STATE_ASYNC) {
218                         /* the 2nd try also replied async, so we don't send
219                            the reply yet */
220                         return;
221                 }
222
223                 /* re-mark it async, just in case someone up the chain does
224                    paranoid checking */
225                 req->async_states->state |= NTVFS_ASYNC_STATE_ASYNC;
226                 break;
227         }
228
229         /* send the reply up the chain */
230         req->async_states->status = status;
231         req->async_states->send_fn(req);
232 }
233
234 /*
235   setup for a rename retry after a sharing violation
236   or a non granted oplock
237 */
238 static NTSTATUS pvfs_rename_setup_retry(struct ntvfs_module_context *ntvfs,
239                                         struct ntvfs_request *req,
240                                         union smb_rename *io,
241                                         struct odb_lock *lck,
242                                         NTSTATUS status)
243 {
244         struct pvfs_state *pvfs = ntvfs->private_data;
245         struct timeval end_time;
246
247         if (NT_STATUS_EQUAL(status, NT_STATUS_SHARING_VIOLATION)) {
248                 end_time = timeval_add(&req->statistics.request_time,
249                                        0, pvfs->sharing_violation_delay);
250         } else if (NT_STATUS_EQUAL(status, NT_STATUS_OPLOCK_NOT_GRANTED)) {
251                 end_time = timeval_add(&req->statistics.request_time,
252                                        pvfs->oplock_break_timeout, 0);
253         } else {
254                 return NT_STATUS_INTERNAL_ERROR;
255         }
256
257         return pvfs_odb_retry_setup(ntvfs, req, lck, end_time, io, NULL,
258                                     pvfs_retry_rename);
259 }
260
261 /*
262   rename one file from a wildcard set
263 */
264 static NTSTATUS pvfs_rename_one(struct pvfs_state *pvfs, 
265                                 struct ntvfs_request *req, 
266                                 const char *dir_path,
267                                 const char *fname1,
268                                 const char *fname2,
269                                 uint16_t attrib)
270 {
271         struct pvfs_filename *name1, *name2;
272         TALLOC_CTX *mem_ctx = talloc_new(req);
273         struct odb_lock *lck = NULL;
274         NTSTATUS status;
275
276         /* resolve the wildcard pattern for this name */
277         fname2 = pvfs_resolve_wildcard(mem_ctx, fname1, fname2);
278         if (fname2 == NULL) {
279                 return NT_STATUS_NO_MEMORY;
280         }
281
282         /* get a pvfs_filename source object */
283         status = pvfs_resolve_partial(pvfs, mem_ctx, 
284                                       dir_path, fname1, &name1);
285         if (!NT_STATUS_IS_OK(status)) {
286                 goto failed;
287         }
288
289         /* make sure its matches the given attributes */
290         status = pvfs_match_attrib(pvfs, name1, attrib, 0);
291         if (!NT_STATUS_IS_OK(status)) {
292                 goto failed;
293         }
294
295         status = pvfs_can_rename(pvfs, req, name1, &lck);
296         if (!NT_STATUS_IS_OK(status)) {
297                 talloc_free(lck);
298                 goto failed;
299         }
300
301         /* get a pvfs_filename dest object */
302         status = pvfs_resolve_partial(pvfs, mem_ctx, 
303                                       dir_path, fname2, &name2);
304         if (NT_STATUS_IS_OK(status)) {
305                 status = pvfs_can_delete(pvfs, req, name2, NULL);
306                 if (!NT_STATUS_IS_OK(status)) {
307                         goto failed;
308                 }
309         }
310
311         status = NT_STATUS_OK;
312
313         fname2 = talloc_asprintf(mem_ctx, "%s/%s", dir_path, fname2);
314         if (fname2 == NULL) {
315                 return NT_STATUS_NO_MEMORY;
316         }
317
318         status = pvfs_do_rename(pvfs, name1, fname2);
319
320         if (NT_STATUS_IS_OK(status)) {
321                 status = odb_rename(lck, fname2);
322         }
323
324 failed:
325         talloc_free(mem_ctx);
326         return status;
327 }
328
329
330 /*
331   rename a set of files with wildcards
332 */
333 static NTSTATUS pvfs_rename_wildcard(struct pvfs_state *pvfs, 
334                                      struct ntvfs_request *req, 
335                                      union smb_rename *ren, 
336                                      struct pvfs_filename *name1, 
337                                      struct pvfs_filename *name2)
338 {
339         struct pvfs_dir *dir;
340         NTSTATUS status;
341         off_t ofs = 0;
342         const char *fname, *fname2, *dir_path;
343         uint16_t attrib = ren->rename.in.attrib;
344         int total_renamed = 0;
345
346         /* get list of matching files */
347         status = pvfs_list_start(pvfs, name1, req, &dir);
348         if (!NT_STATUS_IS_OK(status)) {
349                 return status;
350         }
351
352         status = NT_STATUS_NO_SUCH_FILE;
353
354         dir_path = pvfs_list_unix_path(dir);
355
356         /* only allow wildcard renames within a directory */
357         if (strncmp(dir_path, name2->full_name, strlen(dir_path)) != 0 ||
358             name2->full_name[strlen(dir_path)] != '/' ||
359             strchr(name2->full_name + strlen(dir_path) + 1, '/')) {
360                 return NT_STATUS_INVALID_PARAMETER;
361         }
362
363         fname2 = talloc_strdup(name2, name2->full_name + strlen(dir_path) + 1);
364         if (fname2 == NULL) {
365                 return NT_STATUS_NO_MEMORY;
366         }
367
368         while ((fname = pvfs_list_next(dir, &ofs))) {
369                 status = pvfs_rename_one(pvfs, req, 
370                                          dir_path,
371                                          fname, fname2, attrib);
372                 if (NT_STATUS_IS_OK(status)) {
373                         total_renamed++;
374                 }
375         }
376
377         if (total_renamed == 0) {
378                 return status;
379         }
380
381         return NT_STATUS_OK;
382 }
383
384 /*
385   rename a set of files - SMBmv interface
386 */
387 static NTSTATUS pvfs_rename_mv(struct ntvfs_module_context *ntvfs,
388                                struct ntvfs_request *req, union smb_rename *ren)
389 {
390         struct pvfs_state *pvfs = ntvfs->private_data;
391         NTSTATUS status;
392         struct pvfs_filename *name1, *name2;
393         struct odb_lock *lck = NULL;
394
395         /* resolve the cifs name to a posix name */
396         status = pvfs_resolve_name(pvfs, req, ren->rename.in.pattern1, 
397                                    PVFS_RESOLVE_WILDCARD, &name1);
398         if (!NT_STATUS_IS_OK(status)) {
399                 return status;
400         }
401
402         status = pvfs_resolve_name(pvfs, req, ren->rename.in.pattern2, 
403                                    PVFS_RESOLVE_WILDCARD, &name2);
404         if (!NT_STATUS_IS_OK(status)) {
405                 return status;
406         }
407
408         if (name1->has_wildcard || name2->has_wildcard) {
409                 return pvfs_rename_wildcard(pvfs, req, ren, name1, name2);
410         }
411
412         if (!name1->exists) {
413                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
414         }
415
416         if (strcmp(name1->full_name, name2->full_name) == 0) {
417                 return NT_STATUS_OK;
418         }
419
420         if (name2->exists) {
421                 return NT_STATUS_OBJECT_NAME_COLLISION;
422         }
423
424         status = pvfs_match_attrib(pvfs, name1, ren->rename.in.attrib, 0);
425         if (!NT_STATUS_IS_OK(status)) {
426                 return status;
427         }
428
429         status = pvfs_access_check_parent(pvfs, req, name2, SEC_DIR_ADD_FILE);
430         if (!NT_STATUS_IS_OK(status)) {
431                 return status;
432         }
433
434         status = pvfs_can_rename(pvfs, req, name1, &lck);
435         /*
436          * on a sharing violation we need to retry when the file is closed by
437          * the other user, or after 1 second
438          * on a non granted oplock we need to retry when the file is closed by
439          * the other user, or after 30 seconds
440          */
441         if ((NT_STATUS_EQUAL(status, NT_STATUS_SHARING_VIOLATION) ||
442              NT_STATUS_EQUAL(status, NT_STATUS_OPLOCK_NOT_GRANTED)) &&
443             (req->async_states->state & NTVFS_ASYNC_STATE_MAY_ASYNC)) {
444                 return pvfs_rename_setup_retry(pvfs->ntvfs, req, ren, lck, status);
445         }
446
447         if (!NT_STATUS_IS_OK(status)) {
448                 return status;
449         }
450
451         status = pvfs_do_rename(pvfs, name1, name2->full_name);
452         if (NT_STATUS_IS_OK(status)) {
453                 status = odb_rename(lck, name2->full_name);
454         }
455         
456         return NT_STATUS_OK;
457 }
458
459
460 /*
461   rename a set of files - ntrename interface
462 */
463 static NTSTATUS pvfs_rename_nt(struct ntvfs_module_context *ntvfs,
464                                struct ntvfs_request *req, union smb_rename *ren)
465 {
466         struct pvfs_state *pvfs = ntvfs->private_data;
467         NTSTATUS status;
468         struct pvfs_filename *name1, *name2;
469         struct odb_lock *lck = NULL;
470
471         switch (ren->ntrename.in.flags) {
472         case RENAME_FLAG_RENAME:
473         case RENAME_FLAG_HARD_LINK:
474         case RENAME_FLAG_COPY:
475         case RENAME_FLAG_MOVE_CLUSTER_INFORMATION:
476                 break;
477         default:
478                 return NT_STATUS_ACCESS_DENIED;
479         }
480
481         /* resolve the cifs name to a posix name */
482         status = pvfs_resolve_name(pvfs, req, ren->ntrename.in.old_name, 
483                                    PVFS_RESOLVE_WILDCARD, &name1);
484         if (!NT_STATUS_IS_OK(status)) {
485                 return status;
486         }
487
488         status = pvfs_resolve_name(pvfs, req, ren->ntrename.in.new_name, 
489                                    PVFS_RESOLVE_WILDCARD, &name2);
490         if (!NT_STATUS_IS_OK(status)) {
491                 return status;
492         }
493
494         if (name1->has_wildcard || name2->has_wildcard) {
495                 return NT_STATUS_OBJECT_PATH_SYNTAX_BAD;
496         }
497
498         if (!name1->exists) {
499                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
500         }
501
502         if (strcmp(name1->full_name, name2->full_name) == 0) {
503                 return NT_STATUS_OK;
504         }
505
506         if (name2->exists) {
507                 return NT_STATUS_OBJECT_NAME_COLLISION;
508         }
509
510         status = pvfs_match_attrib(pvfs, name1, ren->ntrename.in.attrib, 0);
511         if (!NT_STATUS_IS_OK(status)) {
512                 return status;
513         }
514
515         status = pvfs_can_rename(pvfs, req, name1, &lck);
516         /*
517          * on a sharing violation we need to retry when the file is closed by
518          * the other user, or after 1 second
519          * on a non granted oplock we need to retry when the file is closed by
520          * the other user, or after 30 seconds
521          */
522         if ((NT_STATUS_EQUAL(status, NT_STATUS_SHARING_VIOLATION) ||
523              NT_STATUS_EQUAL(status, NT_STATUS_OPLOCK_NOT_GRANTED)) &&
524             (req->async_states->state & NTVFS_ASYNC_STATE_MAY_ASYNC)) {
525                 return pvfs_rename_setup_retry(pvfs->ntvfs, req, ren, lck, status);
526         }
527         if (!NT_STATUS_IS_OK(status)) {
528                 return status;
529         }
530
531         switch (ren->ntrename.in.flags) {
532         case RENAME_FLAG_RENAME:
533                 status = pvfs_access_check_parent(pvfs, req, name2, SEC_DIR_ADD_FILE);
534                 NT_STATUS_NOT_OK_RETURN(status);
535                 status = pvfs_do_rename(pvfs, name1, name2->full_name);
536                 if (NT_STATUS_IS_OK(status)) {
537                         status = odb_rename(lck, name2->full_name);
538                 }
539                 NT_STATUS_NOT_OK_RETURN(status);
540                 break;
541
542         case RENAME_FLAG_HARD_LINK:
543                 status = pvfs_access_check_parent(pvfs, req, name2, SEC_DIR_ADD_FILE);
544                 NT_STATUS_NOT_OK_RETURN(status);
545                 if (link(name1->full_name, name2->full_name) == -1) {
546                         return pvfs_map_errno(pvfs, errno);
547                 }
548                 break;
549
550         case RENAME_FLAG_COPY:
551                 status = pvfs_access_check_parent(pvfs, req, name2, SEC_DIR_ADD_FILE);
552                 NT_STATUS_NOT_OK_RETURN(status);
553                 return pvfs_copy_file(pvfs, name1, name2);
554
555         case RENAME_FLAG_MOVE_CLUSTER_INFORMATION:
556                 return NT_STATUS_INVALID_PARAMETER;
557
558         default:
559                 return NT_STATUS_ACCESS_DENIED;
560         }
561
562         
563         return NT_STATUS_OK;
564 }
565
566 /*
567   rename a set of files - ntrename interface
568 */
569 NTSTATUS pvfs_rename(struct ntvfs_module_context *ntvfs,
570                      struct ntvfs_request *req, union smb_rename *ren)
571 {
572         switch (ren->generic.level) {
573         case RAW_RENAME_RENAME:
574                 return pvfs_rename_mv(ntvfs, req, ren);
575
576         case RAW_RENAME_NTRENAME:
577                 return pvfs_rename_nt(ntvfs, req, ren);
578
579         default:
580                 break;
581         }
582
583         return NT_STATUS_INVALID_LEVEL;
584 }
585