Fix up the libnet tests.
[samba.git] / source4 / ntvfs / posix / pvfs_open.c
1 /* 
2    Unix SMB/CIFS implementation.
3
4    POSIX NTVFS backend - open and close
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 "system/dir.h"
25 #include "system/time.h"
26 #include "lib/util/dlinklist.h"
27 #include "messaging/messaging.h"
28 #include "librpc/gen_ndr/xattr.h"
29
30 /*
31   find open file handle given fnum
32 */
33 struct pvfs_file *pvfs_find_fd(struct pvfs_state *pvfs,
34                                struct ntvfs_request *req, struct ntvfs_handle *h)
35 {
36         void *p;
37         struct pvfs_file *f;
38
39         p = ntvfs_handle_get_backend_data(h, pvfs->ntvfs);
40         if (!p) return NULL;
41
42         f = talloc_get_type(p, struct pvfs_file);
43         if (!f) return NULL;
44
45         return f;
46 }
47
48 /*
49   cleanup a open directory handle
50 */
51 static int pvfs_dir_handle_destructor(struct pvfs_file_handle *h)
52 {
53         int open_count;
54         char *path = NULL;
55
56         if (h->name->stream_name == NULL && 
57             pvfs_delete_on_close_set(h->pvfs, h, &open_count, &path) &&
58             open_count == 1) {
59                 NTSTATUS status;
60                 status = pvfs_xattr_unlink_hook(h->pvfs, path);
61                 if (!NT_STATUS_IS_OK(status)) {
62                         DEBUG(0,("Warning: xattr unlink hook failed for '%s' - %s\n",
63                                  path, nt_errstr(status)));
64                 }
65                 if (rmdir(path) != 0) {
66                         DEBUG(0,("pvfs_dir_handle_destructor: failed to rmdir '%s' - %s\n", 
67                                  path, strerror(errno)));
68                 }
69         }
70
71         talloc_free(path);
72
73         if (h->have_opendb_entry) {
74                 struct odb_lock *lck;
75                 NTSTATUS status;
76
77                 lck = odb_lock(h, h->pvfs->odb_context, &h->odb_locking_key);
78                 if (lck == NULL) {
79                         DEBUG(0,("Unable to lock opendb for close\n"));
80                         return 0;
81                 }
82
83                 status = odb_close_file(lck, h);
84                 if (!NT_STATUS_IS_OK(status)) {
85                         DEBUG(0,("Unable to remove opendb entry for '%s' - %s\n", 
86                                  h->name->full_name, nt_errstr(status)));
87                 }
88
89                 talloc_free(lck);
90         }
91
92         return 0;
93 }
94
95 /*
96   cleanup a open directory fnum
97 */
98 static int pvfs_dir_fnum_destructor(struct pvfs_file *f)
99 {
100         DLIST_REMOVE(f->pvfs->files.list, f);
101         ntvfs_handle_remove_backend_data(f->ntvfs, f->pvfs->ntvfs);
102
103         return 0;
104 }
105
106 /*
107   setup any EAs and the ACL on newly created files/directories
108 */
109 static NTSTATUS pvfs_open_setup_eas_acl(struct pvfs_state *pvfs,
110                                         struct ntvfs_request *req,
111                                         struct pvfs_filename *name,
112                                         int fd, struct pvfs_file *f,
113                                         union smb_open *io)
114 {
115         NTSTATUS status;
116
117         /* setup any EAs that were asked for */
118         if (io->ntcreatex.in.ea_list) {
119                 status = pvfs_setfileinfo_ea_set(pvfs, name, fd, 
120                                                  io->ntcreatex.in.ea_list->num_eas,
121                                                  io->ntcreatex.in.ea_list->eas);
122                 if (!NT_STATUS_IS_OK(status)) {
123                         return status;
124                 }
125         }
126
127         /* setup an initial sec_desc if requested */
128         if (io->ntcreatex.in.sec_desc) {
129                 union smb_setfileinfo set;
130 /* 
131  * TODO: set the full ACL! 
132  *       - vista denies the creation of the file with NT_STATUS_PRIVILEGE_NOT_HELD,
133  *         when a SACL is present on the sd,
134  *         but the user doesn't have SeSecurityPrivilege
135  *       - w2k3 allows it
136  */
137                 set.set_secdesc.in.file.ntvfs = f->ntvfs;
138                 set.set_secdesc.in.secinfo_flags = SECINFO_DACL;
139                 set.set_secdesc.in.sd = io->ntcreatex.in.sec_desc;
140
141                 status = pvfs_acl_set(pvfs, req, name, fd, SEC_STD_WRITE_DAC, &set);
142         } else {
143                 /* otherwise setup an inherited acl from the parent */
144                 status = pvfs_acl_inherit(pvfs, req, name, fd);
145         }
146
147         return status;
148 }
149
150 /*
151   form the lock context used for opendb locking. Note that we must
152   zero here to take account of possible padding on some architectures
153 */
154 static NTSTATUS pvfs_locking_key(struct pvfs_filename *name, 
155                                  TALLOC_CTX *mem_ctx, DATA_BLOB *key)
156 {
157         struct {
158                 dev_t device;
159                 ino_t inode;
160         } lock_context;
161         ZERO_STRUCT(lock_context);
162
163         lock_context.device = name->st.st_dev;
164         lock_context.inode = name->st.st_ino;
165
166         *key = data_blob_talloc(mem_ctx, &lock_context, sizeof(lock_context));
167         if (key->data == NULL) {
168                 return NT_STATUS_NO_MEMORY;
169         }
170         
171         return NT_STATUS_OK;
172 }
173
174
175 /*
176   open a directory
177 */
178 static NTSTATUS pvfs_open_directory(struct pvfs_state *pvfs, 
179                                     struct ntvfs_request *req, 
180                                     struct pvfs_filename *name, 
181                                     union smb_open *io)
182 {
183         struct pvfs_file *f;
184         struct ntvfs_handle *h;
185         NTSTATUS status;
186         uint32_t create_action;
187         uint32_t access_mask = io->generic.in.access_mask;
188         struct odb_lock *lck;
189         bool del_on_close;
190         uint32_t create_options;
191         uint32_t share_access;
192
193         create_options = io->generic.in.create_options;
194         share_access   = io->generic.in.share_access;
195
196         if (name->stream_name) {
197                 return NT_STATUS_NOT_A_DIRECTORY;
198         }
199
200         /* if the client says it must be a directory, and it isn't,
201            then fail */
202         if (name->exists && !(name->dos.attrib & FILE_ATTRIBUTE_DIRECTORY)) {
203                 return NT_STATUS_NOT_A_DIRECTORY;
204         }
205
206         switch (io->generic.in.open_disposition) {
207         case NTCREATEX_DISP_OPEN_IF:
208                 break;
209
210         case NTCREATEX_DISP_OPEN:
211                 if (!name->exists) {
212                         return NT_STATUS_OBJECT_NAME_NOT_FOUND;
213                 }
214                 break;
215
216         case NTCREATEX_DISP_CREATE:
217                 if (name->exists) {
218                         return NT_STATUS_OBJECT_NAME_COLLISION;
219                 }
220                 break;
221
222         case NTCREATEX_DISP_OVERWRITE_IF:
223         case NTCREATEX_DISP_OVERWRITE:
224         case NTCREATEX_DISP_SUPERSEDE:
225         default:
226                 return NT_STATUS_INVALID_PARAMETER;
227         }
228
229         status = ntvfs_handle_new(pvfs->ntvfs, req, &h);
230         NT_STATUS_NOT_OK_RETURN(status);
231
232         f = talloc(h, struct pvfs_file);
233         if (f == NULL) {
234                 return NT_STATUS_NO_MEMORY;
235         }
236
237         f->handle = talloc(f, struct pvfs_file_handle);
238         if (f->handle == NULL) {
239                 return NT_STATUS_NO_MEMORY;
240         }
241
242         if (name->exists) {
243                 /* check the security descriptor */
244                 status = pvfs_access_check(pvfs, req, name, &access_mask);
245         } else {
246                 status = pvfs_access_check_create(pvfs, req, name, &access_mask);
247         }
248         if (!NT_STATUS_IS_OK(status)) {
249                 return status;
250         }
251
252         f->ntvfs         = h;
253         f->pvfs          = pvfs;
254         f->pending_list  = NULL;
255         f->lock_count    = 0;
256         f->share_access  = io->generic.in.share_access;
257         f->impersonation = io->generic.in.impersonation;
258         f->access_mask   = access_mask;
259         f->brl_handle    = NULL;
260         f->notify_buffer = NULL;
261         f->search        = NULL;
262
263         f->handle->pvfs              = pvfs;
264         f->handle->name              = talloc_steal(f->handle, name);
265         f->handle->fd                = -1;
266         f->handle->odb_locking_key   = data_blob(NULL, 0);
267         f->handle->create_options    = io->generic.in.create_options;
268         f->handle->seek_offset       = 0;
269         f->handle->position          = 0;
270         f->handle->mode              = 0;
271         f->handle->sticky_write_time = false;
272         f->handle->open_completed    = false;
273
274         if ((create_options & NTCREATEX_OPTIONS_DELETE_ON_CLOSE) &&
275             pvfs_directory_empty(pvfs, f->handle->name)) {
276                 del_on_close = true;
277         } else {
278                 del_on_close = false;
279         }
280
281         if (name->exists) {
282                 /* form the lock context used for opendb locking */
283                 status = pvfs_locking_key(name, f->handle, &f->handle->odb_locking_key);
284                 if (!NT_STATUS_IS_OK(status)) {
285                         return status;
286                 }
287
288                 /* get a lock on this file before the actual open */
289                 lck = odb_lock(req, pvfs->odb_context, &f->handle->odb_locking_key);
290                 if (lck == NULL) {
291                         DEBUG(0,("pvfs_open: failed to lock file '%s' in opendb\n",
292                                  name->full_name));
293                         /* we were supposed to do a blocking lock, so something
294                            is badly wrong! */
295                         return NT_STATUS_INTERNAL_DB_CORRUPTION;
296                 }
297                 
298                 /* see if we are allowed to open at the same time as existing opens */
299                 status = odb_open_file(lck, f->handle, f->handle->name->stream_id,
300                                        share_access, access_mask, del_on_close, 
301                                        name->full_name, OPLOCK_NONE, NULL);
302
303                 if (!NT_STATUS_IS_OK(status)) {
304                         talloc_free(lck);
305                         return status;
306                 }
307
308                 f->handle->have_opendb_entry = true;
309         }
310
311         DLIST_ADD(pvfs->files.list, f);
312
313         /* setup destructors to avoid leaks on abnormal termination */
314         talloc_set_destructor(f->handle, pvfs_dir_handle_destructor);
315         talloc_set_destructor(f, pvfs_dir_fnum_destructor);
316
317         if (!name->exists) {
318                 uint32_t attrib = io->generic.in.file_attr | FILE_ATTRIBUTE_DIRECTORY;
319                 mode_t mode = pvfs_fileperms(pvfs, attrib);
320
321                 if (mkdir(name->full_name, mode) == -1) {
322                         return pvfs_map_errno(pvfs,errno);
323                 }
324
325                 pvfs_xattr_unlink_hook(pvfs, name->full_name);
326
327                 status = pvfs_resolve_name(pvfs, req, io->ntcreatex.in.fname, 0, &name);
328                 if (!NT_STATUS_IS_OK(status)) {
329                         goto cleanup_delete;
330                 }
331
332                 status = pvfs_open_setup_eas_acl(pvfs, req, name, -1, f, io);
333                 if (!NT_STATUS_IS_OK(status)) {
334                         goto cleanup_delete;
335                 }
336
337                 /* form the lock context used for opendb locking */
338                 status = pvfs_locking_key(name, f->handle, &f->handle->odb_locking_key);
339                 if (!NT_STATUS_IS_OK(status)) {
340                         return status;
341                 }
342
343                 lck = odb_lock(req, pvfs->odb_context, &f->handle->odb_locking_key);
344                 if (lck == NULL) {
345                         DEBUG(0,("pvfs_open: failed to lock file '%s' in opendb\n",
346                                  name->full_name));
347                         /* we were supposed to do a blocking lock, so something
348                            is badly wrong! */
349                         return NT_STATUS_INTERNAL_DB_CORRUPTION;
350                 }
351
352                 status = odb_open_file(lck, f->handle, f->handle->name->stream_id,
353                                        share_access, access_mask, del_on_close, 
354                                        name->full_name, OPLOCK_NONE, NULL);
355
356                 if (!NT_STATUS_IS_OK(status)) {
357                         goto cleanup_delete;
358                 }
359
360                 f->handle->have_opendb_entry = true;
361
362                 create_action = NTCREATEX_ACTION_CREATED;
363
364                 notify_trigger(pvfs->notify_context, 
365                                NOTIFY_ACTION_ADDED, 
366                                FILE_NOTIFY_CHANGE_DIR_NAME,
367                                name->full_name);
368         } else {
369                 create_action = NTCREATEX_ACTION_EXISTED;
370         }
371
372         if (!name->exists) {
373                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
374         }
375
376         /* the open succeeded, keep this handle permanently */
377         status = ntvfs_handle_set_backend_data(h, pvfs->ntvfs, f);
378         if (!NT_STATUS_IS_OK(status)) {
379                 goto cleanup_delete;
380         }
381
382         f->handle->open_completed = true;
383
384         io->generic.out.oplock_level  = OPLOCK_NONE;
385         io->generic.out.file.ntvfs    = h;
386         io->generic.out.create_action = create_action;
387         io->generic.out.create_time   = name->dos.create_time;
388         io->generic.out.access_time   = name->dos.access_time;
389         io->generic.out.write_time    = name->dos.write_time;
390         io->generic.out.change_time   = name->dos.change_time;
391         io->generic.out.attrib        = name->dos.attrib;
392         io->generic.out.alloc_size    = name->dos.alloc_size;
393         io->generic.out.size          = name->st.st_size;
394         io->generic.out.file_type     = FILE_TYPE_DISK;
395         io->generic.out.ipc_state     = 0;
396         io->generic.out.is_directory  = 1;
397
398         return NT_STATUS_OK;
399
400 cleanup_delete:
401         rmdir(name->full_name);
402         return status;
403 }
404
405 /*
406   destroy a struct pvfs_file_handle
407 */
408 static int pvfs_handle_destructor(struct pvfs_file_handle *h)
409 {
410         int open_count;
411         char *path = NULL;
412
413         /* the write time is no longer sticky */
414         if (h->sticky_write_time) {
415                 NTSTATUS status;
416                 status = pvfs_dosattrib_load(h->pvfs, h->name, h->fd);
417                 if (NT_STATUS_IS_OK(status)) {
418                         h->name->dos.flags &= ~XATTR_ATTRIB_FLAG_STICKY_WRITE_TIME;
419                         pvfs_dosattrib_save(h->pvfs, h->name, h->fd);
420                 }
421         }
422         
423         if ((h->create_options & NTCREATEX_OPTIONS_DELETE_ON_CLOSE) &&
424             h->name->stream_name) {
425                 NTSTATUS status;
426                 status = pvfs_stream_delete(h->pvfs, h->name, h->fd);
427                 if (!NT_STATUS_IS_OK(status)) {
428                         DEBUG(0,("Failed to delete stream '%s' on close of '%s'\n",
429                                  h->name->stream_name, h->name->full_name));
430                 }
431         }
432
433         if (h->fd != -1) {
434                 if (close(h->fd) != 0) {
435                         DEBUG(0,("pvfs_handle_destructor: close(%d) failed for %s - %s\n",
436                                  h->fd, h->name->full_name, strerror(errno)));
437                 }
438                 h->fd = -1;
439         }
440
441         if (h->name->stream_name == NULL && 
442             h->open_completed &&
443             pvfs_delete_on_close_set(h->pvfs, h, &open_count, &path) &&
444             open_count == 1) {
445                 NTSTATUS status;
446                 status = pvfs_xattr_unlink_hook(h->pvfs, path);
447                 if (!NT_STATUS_IS_OK(status)) {
448                         DEBUG(0,("Warning: xattr unlink hook failed for '%s' - %s\n",
449                                  path, nt_errstr(status)));
450                 }
451                 if (unlink(path) != 0) {
452                         DEBUG(0,("pvfs_close: failed to delete '%s' - %s\n", 
453                                  path, strerror(errno)));
454                 } else {
455                         notify_trigger(h->pvfs->notify_context, 
456                                        NOTIFY_ACTION_REMOVED, 
457                                        FILE_NOTIFY_CHANGE_FILE_NAME,
458                                        path);
459                 }
460         }
461
462         talloc_free(path);
463
464         if (h->have_opendb_entry) {
465                 struct odb_lock *lck;
466                 NTSTATUS status;
467
468                 lck = odb_lock(h, h->pvfs->odb_context, &h->odb_locking_key);
469                 if (lck == NULL) {
470                         DEBUG(0,("Unable to lock opendb for close\n"));
471                         return 0;
472                 }
473
474                 status = odb_close_file(lck, h);
475                 if (!NT_STATUS_IS_OK(status)) {
476                         DEBUG(0,("Unable to remove opendb entry for '%s' - %s\n", 
477                                  h->name->full_name, nt_errstr(status)));
478                 }
479
480                 talloc_free(lck);
481         }
482
483         return 0;
484 }
485
486
487 /*
488   destroy a struct pvfs_file
489 */
490 static int pvfs_fnum_destructor(struct pvfs_file *f)
491 {
492         DLIST_REMOVE(f->pvfs->files.list, f);
493         pvfs_lock_close(f->pvfs, f);
494         ntvfs_handle_remove_backend_data(f->ntvfs, f->pvfs->ntvfs);
495
496         return 0;
497 }
498
499
500 /*
501   form the lock context used for byte range locking. This is separate
502   from the locking key used for opendb locking as it needs to take
503   account of file streams (each stream is a separate byte range
504   locking space)
505 */
506 static NTSTATUS pvfs_brl_locking_handle(TALLOC_CTX *mem_ctx,
507                                         struct pvfs_filename *name,
508                                         struct ntvfs_handle *ntvfs,
509                                         struct brl_handle **_h)
510 {
511         DATA_BLOB odb_key, key;
512         NTSTATUS status;
513         struct brl_handle *h;
514
515         status = pvfs_locking_key(name, mem_ctx, &odb_key);
516         NT_STATUS_NOT_OK_RETURN(status);
517
518         if (name->stream_name == NULL) {
519                 key = odb_key;
520         } else {
521                 key = data_blob_talloc(mem_ctx, NULL, 
522                                        odb_key.length + strlen(name->stream_name) + 1);
523                 NT_STATUS_HAVE_NO_MEMORY(key.data);
524                 memcpy(key.data, odb_key.data, odb_key.length);
525                 memcpy(key.data + odb_key.length, 
526                        name->stream_name, strlen(name->stream_name) + 1);
527                 data_blob_free(&odb_key);
528         }
529
530         h = brl_create_handle(mem_ctx, ntvfs, &key);
531         NT_STATUS_HAVE_NO_MEMORY(h);
532
533         *_h = h;
534         return NT_STATUS_OK;
535 }
536
537 /*
538   create a new file
539 */
540 static NTSTATUS pvfs_create_file(struct pvfs_state *pvfs, 
541                                  struct ntvfs_request *req, 
542                                  struct pvfs_filename *name, 
543                                  union smb_open *io)
544 {
545         struct pvfs_file *f;
546         NTSTATUS status;
547         struct ntvfs_handle *h;
548         int flags, fd;
549         struct odb_lock *lck;
550         uint32_t create_options = io->generic.in.create_options;
551         uint32_t share_access = io->generic.in.share_access;
552         uint32_t access_mask = io->generic.in.access_mask;
553         mode_t mode;
554         uint32_t attrib;
555         bool del_on_close;
556         struct pvfs_filename *parent;
557         uint32_t oplock_level = OPLOCK_NONE, oplock_granted;
558
559         if ((io->ntcreatex.in.file_attr & FILE_ATTRIBUTE_READONLY) &&
560             (create_options & NTCREATEX_OPTIONS_DELETE_ON_CLOSE)) {
561                 return NT_STATUS_CANNOT_DELETE;
562         }
563         
564         status = pvfs_access_check_create(pvfs, req, name, &access_mask);
565         NT_STATUS_NOT_OK_RETURN(status);
566
567         /* check that the parent isn't opened with delete on close set */
568         status = pvfs_resolve_parent(pvfs, req, name, &parent);
569         if (NT_STATUS_IS_OK(status)) {
570                 DATA_BLOB locking_key;
571                 status = pvfs_locking_key(parent, req, &locking_key);
572                 NT_STATUS_NOT_OK_RETURN(status);
573                 status = odb_get_delete_on_close(pvfs->odb_context, &locking_key, 
574                                                  &del_on_close, NULL, NULL);
575                 NT_STATUS_NOT_OK_RETURN(status);
576                 if (del_on_close) {
577                         return NT_STATUS_DELETE_PENDING;
578                 }
579         }
580
581         if (access_mask & (SEC_FILE_WRITE_DATA | SEC_FILE_APPEND_DATA)) {
582                 flags = O_RDWR;
583         } else {
584                 flags = O_RDONLY;
585         }
586
587         status = ntvfs_handle_new(pvfs->ntvfs, req, &h);
588         NT_STATUS_NOT_OK_RETURN(status);
589
590         f = talloc(h, struct pvfs_file);
591         NT_STATUS_HAVE_NO_MEMORY(f);
592
593         f->handle = talloc(f, struct pvfs_file_handle);
594         NT_STATUS_HAVE_NO_MEMORY(f->handle);
595
596         attrib = io->ntcreatex.in.file_attr | FILE_ATTRIBUTE_ARCHIVE;
597         mode = pvfs_fileperms(pvfs, attrib);
598
599         /* create the file */
600         fd = open(name->full_name, flags | O_CREAT | O_EXCL, mode);
601         if (fd == -1) {
602                 return pvfs_map_errno(pvfs, errno);
603         }
604
605         pvfs_xattr_unlink_hook(pvfs, name->full_name);
606
607         /* if this was a stream create then create the stream as well */
608         if (name->stream_name) {
609                 status = pvfs_stream_create(pvfs, name, fd);
610                 if (!NT_STATUS_IS_OK(status)) {
611                         close(fd);
612                         return status;
613                 }
614         }
615
616         /* re-resolve the open fd */
617         status = pvfs_resolve_name_fd(pvfs, fd, name);
618         if (!NT_STATUS_IS_OK(status)) {
619                 close(fd);
620                 return status;
621         }
622
623         name->dos.attrib = attrib;
624         status = pvfs_dosattrib_save(pvfs, name, fd);
625         if (!NT_STATUS_IS_OK(status)) {
626                 goto cleanup_delete;
627         }
628
629
630         status = pvfs_open_setup_eas_acl(pvfs, req, name, fd, f, io);
631         if (!NT_STATUS_IS_OK(status)) {
632                 goto cleanup_delete;
633         }
634
635         /* form the lock context used for byte range locking and
636            opendb locking */
637         status = pvfs_locking_key(name, f->handle, &f->handle->odb_locking_key);
638         if (!NT_STATUS_IS_OK(status)) {
639                 goto cleanup_delete;
640         }
641
642         status = pvfs_brl_locking_handle(f, name, h, &f->brl_handle);
643         if (!NT_STATUS_IS_OK(status)) {
644                 goto cleanup_delete;
645         }
646
647         /* grab a lock on the open file record */
648         lck = odb_lock(req, pvfs->odb_context, &f->handle->odb_locking_key);
649         if (lck == NULL) {
650                 DEBUG(0,("pvfs_open: failed to lock file '%s' in opendb\n",
651                          name->full_name));
652                 /* we were supposed to do a blocking lock, so something
653                    is badly wrong! */
654                 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
655                 goto cleanup_delete;
656         }
657
658         if (create_options & NTCREATEX_OPTIONS_DELETE_ON_CLOSE) {
659                 del_on_close = true;
660         } else {
661                 del_on_close = false;
662         }
663
664         if (pvfs->flags & PVFS_FLAG_FAKE_OPLOCKS) {
665                 oplock_level = OPLOCK_NONE;
666         } else if (io->ntcreatex.in.flags & NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK) {
667                 oplock_level = OPLOCK_BATCH;
668         } else if (io->ntcreatex.in.flags & NTCREATEX_FLAGS_REQUEST_OPLOCK) {
669                 oplock_level = OPLOCK_EXCLUSIVE;
670         }
671
672         status = odb_open_file(lck, f->handle, name->stream_id,
673                                share_access, access_mask, del_on_close, 
674                                name->full_name, oplock_level, &oplock_granted);
675         talloc_free(lck);
676         if (!NT_STATUS_IS_OK(status)) {
677                 /* bad news, we must have hit a race - we don't delete the file
678                    here as the most likely scenario is that someone else created 
679                    the file at the same time */
680                 close(fd);
681                 return status;
682         }
683
684         if (pvfs->flags & PVFS_FLAG_FAKE_OPLOCKS) {
685                 oplock_granted = OPLOCK_BATCH;
686         }
687
688         f->ntvfs             = h;
689         f->pvfs              = pvfs;
690         f->pending_list      = NULL;
691         f->lock_count        = 0;
692         f->share_access      = io->generic.in.share_access;
693         f->access_mask       = access_mask;
694         f->impersonation     = io->generic.in.impersonation;
695         f->notify_buffer     = NULL;
696         f->search            = NULL;
697
698         f->handle->pvfs              = pvfs;
699         f->handle->name              = talloc_steal(f->handle, name);
700         f->handle->fd                = fd;
701         f->handle->create_options    = io->generic.in.create_options;
702         f->handle->seek_offset       = 0;
703         f->handle->position          = 0;
704         f->handle->mode              = 0;
705         f->handle->have_opendb_entry = true;
706         f->handle->sticky_write_time = false;
707         f->handle->open_completed    = false;
708
709         DLIST_ADD(pvfs->files.list, f);
710
711         /* setup a destructor to avoid file descriptor leaks on
712            abnormal termination */
713         talloc_set_destructor(f, pvfs_fnum_destructor);
714         talloc_set_destructor(f->handle, pvfs_handle_destructor);
715
716         io->generic.out.oplock_level  = oplock_granted;
717         io->generic.out.file.ntvfs    = f->ntvfs;
718         io->generic.out.create_action = NTCREATEX_ACTION_CREATED;
719         io->generic.out.create_time   = name->dos.create_time;
720         io->generic.out.access_time   = name->dos.access_time;
721         io->generic.out.write_time    = name->dos.write_time;
722         io->generic.out.change_time   = name->dos.change_time;
723         io->generic.out.attrib        = name->dos.attrib;
724         io->generic.out.alloc_size    = name->dos.alloc_size;
725         io->generic.out.size          = name->st.st_size;
726         io->generic.out.file_type     = FILE_TYPE_DISK;
727         io->generic.out.ipc_state     = 0;
728         io->generic.out.is_directory  = 0;
729
730         /* success - keep the file handle */
731         status = ntvfs_handle_set_backend_data(h, pvfs->ntvfs, f);
732         if (!NT_STATUS_IS_OK(status)) {
733                 goto cleanup_delete;
734         }
735
736         f->handle->open_completed = true;
737
738         notify_trigger(pvfs->notify_context, 
739                        NOTIFY_ACTION_ADDED, 
740                        FILE_NOTIFY_CHANGE_FILE_NAME,
741                        name->full_name);
742
743         return NT_STATUS_OK;
744
745 cleanup_delete:
746         close(fd);
747         unlink(name->full_name);
748         return status;
749 }
750
751
752 /*
753   state of a pending open retry
754 */
755 struct pvfs_open_retry {
756         struct ntvfs_module_context *ntvfs;
757         struct ntvfs_request *req;
758         union smb_open *io;
759         struct pvfs_wait *wait_handle;
760         DATA_BLOB odb_locking_key;
761 };
762
763 /* destroy a pending open request */
764 static int pvfs_retry_destructor(struct pvfs_open_retry *r)
765 {
766         struct pvfs_state *pvfs = r->ntvfs->private_data;
767         if (r->odb_locking_key.data) {
768                 struct odb_lock *lck;
769                 lck = odb_lock(r->req, pvfs->odb_context, &r->odb_locking_key);
770                 if (lck != NULL) {
771                         odb_remove_pending(lck, r);
772                 }
773                 talloc_free(lck);
774         }
775         return 0;
776 }
777
778 /*
779   retry an open
780 */
781 static void pvfs_open_retry(void *private, enum pvfs_wait_notice reason)
782 {
783         struct pvfs_open_retry *r = private;
784         struct ntvfs_module_context *ntvfs = r->ntvfs;
785         struct ntvfs_request *req = r->req;
786         union smb_open *io = r->io;
787         NTSTATUS status;
788
789         /* w2k3 ignores SMBntcancel for outstanding open requests. It's probably
790            just a bug in their server, but we better do the same */
791         if (reason == PVFS_WAIT_CANCEL) {
792                 return;
793         }
794
795         talloc_free(r->wait_handle);
796
797         if (reason == PVFS_WAIT_TIMEOUT) {
798                 /* if it timed out, then give the failure
799                    immediately */
800                 talloc_free(r);
801                 req->async_states->status = NT_STATUS_SHARING_VIOLATION;
802                 req->async_states->send_fn(req);
803                 return;
804         }
805
806         /* the pending odb entry is already removed. We use a null locking
807            key to indicate this */
808         data_blob_free(&r->odb_locking_key);
809         talloc_free(r);
810
811         /* try the open again, which could trigger another retry setup
812            if it wants to, so we have to unmark the async flag so we
813            will know if it does a second async reply */
814         req->async_states->state &= ~NTVFS_ASYNC_STATE_ASYNC;
815
816         status = pvfs_open(ntvfs, req, io);
817         if (req->async_states->state & NTVFS_ASYNC_STATE_ASYNC) {
818                 /* the 2nd try also replied async, so we don't send
819                    the reply yet */
820                 return;
821         }
822
823         /* re-mark it async, just in case someone up the chain does
824            paranoid checking */
825         req->async_states->state |= NTVFS_ASYNC_STATE_ASYNC;
826
827         /* send the reply up the chain */
828         req->async_states->status = status;
829         req->async_states->send_fn(req);
830 }
831
832
833 /*
834   special handling for openx DENY_DOS semantics
835
836   This function attempts a reference open using an existing handle. If its allowed,
837   then it returns NT_STATUS_OK, otherwise it returns any other code and normal
838   open processing continues.
839 */
840 static NTSTATUS pvfs_open_deny_dos(struct ntvfs_module_context *ntvfs,
841                                    struct ntvfs_request *req, union smb_open *io,
842                                    struct pvfs_file *f, struct odb_lock *lck)
843 {
844         struct pvfs_state *pvfs = ntvfs->private_data;
845         struct pvfs_file *f2;
846         struct pvfs_filename *name;
847         NTSTATUS status;
848
849         /* search for an existing open with the right parameters. Note
850            the magic ntcreatex options flag, which is set in the
851            generic mapping code. This might look ugly, but its
852            actually pretty much now w2k does it internally as well. 
853            
854            If you look at the BASE-DENYDOS test you will see that a
855            DENY_DOS is a very special case, and in the right
856            circumstances you actually get the _same_ handle back
857            twice, rather than a new handle.
858         */
859         for (f2=pvfs->files.list;f2;f2=f2->next) {
860                 if (f2 != f &&
861                     f2->ntvfs->session_info == req->session_info &&
862                     f2->ntvfs->smbpid == req->smbpid &&
863                     (f2->handle->create_options & 
864                      (NTCREATEX_OPTIONS_PRIVATE_DENY_DOS |
865                       NTCREATEX_OPTIONS_PRIVATE_DENY_FCB)) &&
866                     (f2->access_mask & SEC_FILE_WRITE_DATA) &&
867                     strcasecmp_m(f2->handle->name->original_name, 
868                                io->generic.in.fname)==0) {
869                         break;
870                 }
871         }
872
873         if (!f2) {
874                 return NT_STATUS_SHARING_VIOLATION;
875         }
876
877         /* quite an insane set of semantics ... */
878         if (is_exe_filename(io->generic.in.fname) &&
879             (f2->handle->create_options & NTCREATEX_OPTIONS_PRIVATE_DENY_DOS)) {
880                 return NT_STATUS_SHARING_VIOLATION;
881         }
882
883         /*
884           setup a reference to the existing handle
885          */
886         talloc_free(f->handle);
887         f->handle = talloc_reference(f, f2->handle);
888
889         talloc_free(lck);
890
891         name = f->handle->name;
892
893         io->generic.out.oplock_level  = OPLOCK_NONE;
894         io->generic.out.file.ntvfs    = f->ntvfs;
895         io->generic.out.create_action = NTCREATEX_ACTION_EXISTED;
896         io->generic.out.create_time   = name->dos.create_time;
897         io->generic.out.access_time   = name->dos.access_time;
898         io->generic.out.write_time    = name->dos.write_time;
899         io->generic.out.change_time   = name->dos.change_time;
900         io->generic.out.attrib        = name->dos.attrib;
901         io->generic.out.alloc_size    = name->dos.alloc_size;
902         io->generic.out.size          = name->st.st_size;
903         io->generic.out.file_type     = FILE_TYPE_DISK;
904         io->generic.out.ipc_state     = 0;
905         io->generic.out.is_directory  = 0;
906  
907         status = ntvfs_handle_set_backend_data(f->ntvfs, ntvfs, f);
908         NT_STATUS_NOT_OK_RETURN(status);
909
910         return NT_STATUS_OK;
911 }
912
913
914
915 /*
916   setup for a open retry after a sharing violation
917 */
918 static NTSTATUS pvfs_open_setup_retry(struct ntvfs_module_context *ntvfs,
919                                       struct ntvfs_request *req, 
920                                       union smb_open *io,
921                                       struct pvfs_file *f,
922                                       struct odb_lock *lck)
923 {
924         struct pvfs_state *pvfs = ntvfs->private_data;
925         struct pvfs_open_retry *r;
926         NTSTATUS status;
927         struct timeval end_time;
928
929         if (io->generic.in.create_options & 
930             (NTCREATEX_OPTIONS_PRIVATE_DENY_DOS | NTCREATEX_OPTIONS_PRIVATE_DENY_FCB)) {
931                 /* see if we can satisfy the request using the special DENY_DOS
932                    code */
933                 status = pvfs_open_deny_dos(ntvfs, req, io, f, lck);
934                 if (NT_STATUS_IS_OK(status)) {
935                         return status;
936                 }
937         }
938
939         r = talloc(req, struct pvfs_open_retry);
940         if (r == NULL) {
941                 return NT_STATUS_NO_MEMORY;
942         }
943
944         r->ntvfs = ntvfs;
945         r->req = req;
946         r->io = io;
947         r->odb_locking_key = data_blob_talloc(r, 
948                                               f->handle->odb_locking_key.data, 
949                                               f->handle->odb_locking_key.length);
950
951         end_time = timeval_add(&req->statistics.request_time, 0, pvfs->sharing_violation_delay);
952
953         /* setup a pending lock */
954         status = odb_open_file_pending(lck, r);
955         if (!NT_STATUS_IS_OK(status)) {
956                 return status;
957         }
958
959         talloc_free(lck);
960         talloc_free(f);
961
962         talloc_set_destructor(r, pvfs_retry_destructor);
963
964         r->wait_handle = pvfs_wait_message(pvfs, req, MSG_PVFS_RETRY_OPEN, end_time, 
965                                            pvfs_open_retry, r);
966         if (r->wait_handle == NULL) {
967                 return NT_STATUS_NO_MEMORY;
968         }
969
970         talloc_steal(pvfs, r);
971
972         return NT_STATUS_OK;
973 }
974
975 /*
976   open a file
977 */
978 NTSTATUS pvfs_open(struct ntvfs_module_context *ntvfs,
979                    struct ntvfs_request *req, union smb_open *io)
980 {
981         struct pvfs_state *pvfs = ntvfs->private_data;
982         int flags;
983         struct pvfs_filename *name;
984         struct pvfs_file *f;
985         struct ntvfs_handle *h;
986         NTSTATUS status;
987         int fd;
988         struct odb_lock *lck;
989         uint32_t create_options;
990         uint32_t share_access;
991         uint32_t access_mask;
992         bool del_on_close;
993         bool stream_existed, stream_truncate=false;
994         uint32_t oplock_level = OPLOCK_NONE, oplock_granted;
995
996         /* use the generic mapping code to avoid implementing all the
997            different open calls. */
998         if (io->generic.level != RAW_OPEN_GENERIC &&
999             io->generic.level != RAW_OPEN_NTTRANS_CREATE) {
1000                 return ntvfs_map_open(ntvfs, req, io);
1001         }
1002
1003         /* resolve the cifs name to a posix name */
1004         status = pvfs_resolve_name(pvfs, req, io->ntcreatex.in.fname, 
1005                                    PVFS_RESOLVE_STREAMS, &name);
1006         if (!NT_STATUS_IS_OK(status)) {
1007                 return status;
1008         }
1009
1010         /* directory opens are handled separately */
1011         if ((name->exists && (name->dos.attrib & FILE_ATTRIBUTE_DIRECTORY)) ||
1012             (io->generic.in.create_options & NTCREATEX_OPTIONS_DIRECTORY)) {
1013                 return pvfs_open_directory(pvfs, req, name, io);
1014         }
1015
1016         /* FILE_ATTRIBUTE_DIRECTORY is ignored if the above test for directory
1017            open doesn't match */
1018         io->generic.in.file_attr &= ~FILE_ATTRIBUTE_DIRECTORY;
1019
1020         create_options = io->generic.in.create_options;
1021         share_access   = io->generic.in.share_access;
1022         access_mask    = io->generic.in.access_mask;
1023
1024         /* certain create options are not allowed */
1025         if ((create_options & NTCREATEX_OPTIONS_DELETE_ON_CLOSE) &&
1026             !(access_mask & SEC_STD_DELETE)) {
1027                 return NT_STATUS_INVALID_PARAMETER;
1028         }
1029
1030         flags = 0;
1031
1032         switch (io->generic.in.open_disposition) {
1033         case NTCREATEX_DISP_SUPERSEDE:
1034         case NTCREATEX_DISP_OVERWRITE_IF:
1035                 if (name->stream_name == NULL) {
1036                         flags = O_TRUNC;
1037                 } else {
1038                         stream_truncate = true;
1039                 }
1040                 break;
1041
1042         case NTCREATEX_DISP_OPEN:
1043                 if (!name->stream_exists) {
1044                         return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1045                 }
1046                 flags = 0;
1047                 break;
1048
1049         case NTCREATEX_DISP_OVERWRITE:
1050                 if (!name->stream_exists) {
1051                         return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1052                 }
1053                 if (name->stream_name == NULL) {
1054                         flags = O_TRUNC;
1055                 } else {
1056                         stream_truncate = true;
1057                 }
1058                 break;
1059
1060         case NTCREATEX_DISP_CREATE:
1061                 if (name->stream_exists) {
1062                         return NT_STATUS_OBJECT_NAME_COLLISION;
1063                 }
1064                 flags = 0;
1065                 break;
1066
1067         case NTCREATEX_DISP_OPEN_IF:
1068                 flags = 0;
1069                 break;
1070
1071         default:
1072                 return NT_STATUS_INVALID_PARAMETER;
1073         }
1074
1075         /* handle creating a new file separately */
1076         if (!name->exists) {
1077                 status = pvfs_create_file(pvfs, req, name, io);
1078                 if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_COLLISION)) {
1079                         return status;
1080                 }
1081
1082                 /* we've hit a race - the file was created during this call */
1083                 if (io->generic.in.open_disposition == NTCREATEX_DISP_CREATE) {
1084                         return status;
1085                 }
1086
1087                 /* try re-resolving the name */
1088                 status = pvfs_resolve_name(pvfs, req, io->ntcreatex.in.fname, 0, &name);
1089                 if (!NT_STATUS_IS_OK(status)) {
1090                         return status;
1091                 }
1092                 /* fall through to a normal open */
1093         }
1094
1095         if ((name->dos.attrib & FILE_ATTRIBUTE_READONLY) &&
1096             (create_options & NTCREATEX_OPTIONS_DELETE_ON_CLOSE)) {
1097                 return NT_STATUS_CANNOT_DELETE;
1098         }
1099
1100         /* check the security descriptor */
1101         status = pvfs_access_check(pvfs, req, name, &access_mask);
1102         if (!NT_STATUS_IS_OK(status)) {
1103                 return status;
1104         }
1105
1106         status = ntvfs_handle_new(pvfs->ntvfs, req, &h);
1107         NT_STATUS_NOT_OK_RETURN(status);
1108
1109         f = talloc(h, struct pvfs_file);
1110         if (f == NULL) {
1111                 return NT_STATUS_NO_MEMORY;
1112         }
1113
1114         f->handle = talloc(f, struct pvfs_file_handle);
1115         if (f->handle == NULL) {
1116                 return NT_STATUS_NO_MEMORY;
1117         }
1118
1119         f->ntvfs         = h;
1120         f->pvfs          = pvfs;
1121         f->pending_list  = NULL;
1122         f->lock_count    = 0;
1123         f->share_access  = io->generic.in.share_access;
1124         f->access_mask   = access_mask;
1125         f->impersonation = io->generic.in.impersonation;
1126         f->notify_buffer = NULL;
1127         f->search        = NULL;
1128
1129         f->handle->pvfs              = pvfs;
1130         f->handle->fd                = -1;
1131         f->handle->name              = talloc_steal(f->handle, name);
1132         f->handle->create_options    = io->generic.in.create_options;
1133         f->handle->seek_offset       = 0;
1134         f->handle->position          = 0;
1135         f->handle->mode              = 0;
1136         f->handle->have_opendb_entry = false;
1137         f->handle->sticky_write_time = false;
1138         f->handle->open_completed    = false;
1139
1140         /* form the lock context used for byte range locking and
1141            opendb locking */
1142         status = pvfs_locking_key(name, f->handle, &f->handle->odb_locking_key);
1143         if (!NT_STATUS_IS_OK(status)) {
1144                 return status;
1145         }
1146
1147         status = pvfs_brl_locking_handle(f, name, h, &f->brl_handle);
1148         if (!NT_STATUS_IS_OK(status)) {
1149                 return status;
1150         }
1151
1152         /* get a lock on this file before the actual open */
1153         lck = odb_lock(req, pvfs->odb_context, &f->handle->odb_locking_key);
1154         if (lck == NULL) {
1155                 DEBUG(0,("pvfs_open: failed to lock file '%s' in opendb\n",
1156                          name->full_name));
1157                 /* we were supposed to do a blocking lock, so something
1158                    is badly wrong! */
1159                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
1160         }
1161
1162         DLIST_ADD(pvfs->files.list, f);
1163
1164         /* setup a destructor to avoid file descriptor leaks on
1165            abnormal termination */
1166         talloc_set_destructor(f, pvfs_fnum_destructor);
1167         talloc_set_destructor(f->handle, pvfs_handle_destructor);
1168
1169         /* 
1170          * Only SMB2 takes care of the delete_on_close,
1171          * on existing files
1172          */
1173         if (create_options & NTCREATEX_OPTIONS_DELETE_ON_CLOSE &&
1174             req->ctx->protocol == PROTOCOL_SMB2) {
1175                 del_on_close = true;
1176         } else {
1177                 del_on_close = false;
1178         }
1179
1180         if (pvfs->flags & PVFS_FLAG_FAKE_OPLOCKS) {
1181                 oplock_level = OPLOCK_NONE;
1182         } else if (io->ntcreatex.in.flags & NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK) {
1183                 oplock_level = OPLOCK_BATCH;
1184         } else if (io->ntcreatex.in.flags & NTCREATEX_FLAGS_REQUEST_OPLOCK) {
1185                 oplock_level = OPLOCK_EXCLUSIVE;
1186         }
1187
1188         /* see if we are allowed to open at the same time as existing opens */
1189         status = odb_open_file(lck, f->handle, f->handle->name->stream_id,
1190                                share_access, access_mask, del_on_close,
1191                                name->full_name, oplock_level, &oplock_granted);
1192
1193         /* on a sharing violation we need to retry when the file is closed by 
1194            the other user, or after 1 second */
1195         if (NT_STATUS_EQUAL(status, NT_STATUS_SHARING_VIOLATION) &&
1196             (req->async_states->state & NTVFS_ASYNC_STATE_MAY_ASYNC)) {
1197                 return pvfs_open_setup_retry(ntvfs, req, io, f, lck);
1198         }
1199
1200         if (!NT_STATUS_IS_OK(status)) {
1201                 talloc_free(lck);
1202                 return status;
1203         }
1204
1205         if (pvfs->flags & PVFS_FLAG_FAKE_OPLOCKS) {
1206                 oplock_granted = OPLOCK_BATCH;
1207         }
1208
1209         f->handle->have_opendb_entry = true;
1210
1211         if (access_mask & (SEC_FILE_WRITE_DATA | SEC_FILE_APPEND_DATA)) {
1212                 flags |= O_RDWR;
1213         } else {
1214                 flags |= O_RDONLY;
1215         }
1216
1217         /* do the actual open */
1218         fd = open(f->handle->name->full_name, flags);
1219         if (fd == -1) {
1220                 talloc_free(lck);
1221                 return pvfs_map_errno(f->pvfs, errno);
1222         }
1223
1224         f->handle->fd = fd;
1225
1226         stream_existed = name->stream_exists;
1227
1228         /* if this was a stream create then create the stream as well */
1229         if (!name->stream_exists) {
1230                 status = pvfs_stream_create(pvfs, f->handle->name, fd);
1231                 if (!NT_STATUS_IS_OK(status)) {
1232                         talloc_free(lck);
1233                         return status;
1234                 }
1235                 if (stream_truncate) {
1236                         status = pvfs_stream_truncate(pvfs, f->handle->name, fd, 0);
1237                         if (!NT_STATUS_IS_OK(status)) {
1238                                 talloc_free(lck);
1239                                 return status;
1240                         }
1241                 }
1242         }
1243
1244         /* re-resolve the open fd */
1245         status = pvfs_resolve_name_fd(f->pvfs, fd, f->handle->name);
1246         if (!NT_STATUS_IS_OK(status)) {
1247                 talloc_free(lck);
1248                 return status;
1249         }
1250
1251         if (f->handle->name->stream_id == 0 &&
1252             (io->generic.in.open_disposition == NTCREATEX_DISP_OVERWRITE ||
1253              io->generic.in.open_disposition == NTCREATEX_DISP_OVERWRITE_IF)) {
1254                 /* for overwrite we need to replace file permissions */
1255                 uint32_t attrib = io->ntcreatex.in.file_attr | FILE_ATTRIBUTE_ARCHIVE;
1256                 mode_t mode = pvfs_fileperms(pvfs, attrib);
1257                 if (fchmod(fd, mode) == -1) {
1258                         talloc_free(lck);
1259                         return pvfs_map_errno(pvfs, errno);
1260                 }
1261                 name->dos.attrib = attrib;
1262                 status = pvfs_dosattrib_save(pvfs, name, fd);
1263                 if (!NT_STATUS_IS_OK(status)) {
1264                         talloc_free(lck);
1265                         return status;
1266                 }
1267         }
1268             
1269         talloc_free(lck);
1270
1271         status = ntvfs_handle_set_backend_data(h, ntvfs, f);
1272         NT_STATUS_NOT_OK_RETURN(status);
1273
1274         /* mark the open as having completed fully, so delete on close
1275            can now be used */
1276         f->handle->open_completed     = true;
1277
1278         io->generic.out.oplock_level  = oplock_granted;
1279         io->generic.out.file.ntvfs    = h;
1280         io->generic.out.create_action = stream_existed?
1281                 NTCREATEX_ACTION_EXISTED:NTCREATEX_ACTION_CREATED;
1282         io->generic.out.create_time   = name->dos.create_time;
1283         io->generic.out.access_time   = name->dos.access_time;
1284         io->generic.out.write_time    = name->dos.write_time;
1285         io->generic.out.change_time   = name->dos.change_time;
1286         io->generic.out.attrib        = name->dos.attrib;
1287         io->generic.out.alloc_size    = name->dos.alloc_size;
1288         io->generic.out.size          = name->st.st_size;
1289         io->generic.out.file_type     = FILE_TYPE_DISK;
1290         io->generic.out.ipc_state     = 0;
1291         io->generic.out.is_directory  = 0;
1292
1293         return NT_STATUS_OK;
1294 }
1295
1296
1297 /*
1298   close a file
1299 */
1300 NTSTATUS pvfs_close(struct ntvfs_module_context *ntvfs,
1301                     struct ntvfs_request *req, union smb_close *io)
1302 {
1303         struct pvfs_state *pvfs = ntvfs->private_data;
1304         struct pvfs_file *f;
1305         struct utimbuf unix_times;
1306
1307         if (io->generic.level == RAW_CLOSE_SPLCLOSE) {
1308                 return NT_STATUS_DOS(ERRSRV, ERRerror);
1309         }
1310
1311         if (io->generic.level != RAW_CLOSE_CLOSE) {
1312                 return ntvfs_map_close(ntvfs, req, io);
1313         }
1314
1315         f = pvfs_find_fd(pvfs, req, io->close.in.file.ntvfs);
1316         if (!f) {
1317                 return NT_STATUS_INVALID_HANDLE;
1318         }
1319
1320         if (!null_time(io->close.in.write_time)) {
1321                 unix_times.actime = 0;
1322                 unix_times.modtime = io->close.in.write_time;
1323                 utime(f->handle->name->full_name, &unix_times);
1324         } else if (f->handle->sticky_write_time) {
1325                 unix_times.actime = 0;
1326                 unix_times.modtime = nt_time_to_unix(f->handle->name->dos.write_time);
1327                 utime(f->handle->name->full_name, &unix_times);
1328         }
1329
1330         talloc_free(f);
1331
1332         return NT_STATUS_OK;
1333 }
1334
1335
1336 /*
1337   logoff - close all file descriptors open by a vuid
1338 */
1339 NTSTATUS pvfs_logoff(struct ntvfs_module_context *ntvfs,
1340                      struct ntvfs_request *req)
1341 {
1342         struct pvfs_state *pvfs = ntvfs->private_data;
1343         struct pvfs_file *f, *next;
1344
1345         for (f=pvfs->files.list;f;f=next) {
1346                 next = f->next;
1347                 if (f->ntvfs->session_info == req->session_info) {
1348                         talloc_free(f);
1349                 }
1350         }
1351
1352         return NT_STATUS_OK;
1353 }
1354
1355
1356 /*
1357   exit - close files for the current pid
1358 */
1359 NTSTATUS pvfs_exit(struct ntvfs_module_context *ntvfs,
1360                    struct ntvfs_request *req)
1361 {
1362         struct pvfs_state *pvfs = ntvfs->private_data;
1363         struct pvfs_file *f, *next;
1364
1365         for (f=pvfs->files.list;f;f=next) {
1366                 next = f->next;
1367                 if (f->ntvfs->session_info == req->session_info &&
1368                     f->ntvfs->smbpid == req->smbpid) {
1369                         talloc_free(f);
1370                 }
1371         }
1372
1373         return NT_STATUS_OK;
1374 }
1375
1376
1377 /*
1378   change the delete on close flag on an already open file
1379 */
1380 NTSTATUS pvfs_set_delete_on_close(struct pvfs_state *pvfs,
1381                                   struct ntvfs_request *req, 
1382                                   struct pvfs_file *f, bool del_on_close)
1383 {
1384         struct odb_lock *lck;
1385         NTSTATUS status;
1386
1387         if ((f->handle->name->dos.attrib & FILE_ATTRIBUTE_READONLY) && del_on_close) {
1388                 return NT_STATUS_CANNOT_DELETE;
1389         }
1390         
1391         if ((f->handle->name->dos.attrib & FILE_ATTRIBUTE_DIRECTORY) &&
1392             !pvfs_directory_empty(pvfs, f->handle->name)) {
1393                 return NT_STATUS_DIRECTORY_NOT_EMPTY;
1394         }
1395
1396         if (del_on_close) {
1397                 f->handle->create_options |= NTCREATEX_OPTIONS_DELETE_ON_CLOSE;
1398         } else {
1399                 f->handle->create_options &= ~NTCREATEX_OPTIONS_DELETE_ON_CLOSE;
1400         }
1401         
1402         lck = odb_lock(req, pvfs->odb_context, &f->handle->odb_locking_key);
1403         if (lck == NULL) {
1404                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
1405         }
1406
1407         status = odb_set_delete_on_close(lck, del_on_close);
1408
1409         talloc_free(lck);
1410
1411         return status;
1412 }
1413
1414
1415 /*
1416   determine if a file can be deleted, or if it is prevented by an
1417   already open file
1418 */
1419 NTSTATUS pvfs_can_delete(struct pvfs_state *pvfs, 
1420                          struct ntvfs_request *req,
1421                          struct pvfs_filename *name,
1422                          struct odb_lock **lckp)
1423 {
1424         NTSTATUS status;
1425         DATA_BLOB key;
1426         struct odb_lock *lck;
1427
1428         status = pvfs_locking_key(name, name, &key);
1429         if (!NT_STATUS_IS_OK(status)) {
1430                 return NT_STATUS_NO_MEMORY;
1431         }
1432
1433         lck = odb_lock(req, pvfs->odb_context, &key);
1434         if (lck == NULL) {
1435                 DEBUG(0,("Unable to lock opendb for can_delete\n"));
1436                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
1437         }
1438
1439         status = odb_can_open(lck,
1440                               NTCREATEX_SHARE_ACCESS_READ |
1441                               NTCREATEX_SHARE_ACCESS_WRITE | 
1442                               NTCREATEX_SHARE_ACCESS_DELETE, 
1443                               NTCREATEX_OPTIONS_DELETE_ON_CLOSE, 
1444                               SEC_STD_DELETE);
1445
1446         if (NT_STATUS_IS_OK(status)) {
1447                 status = pvfs_access_check_simple(pvfs, req, name, SEC_STD_DELETE);
1448         }
1449
1450         /*
1451          * if it's a sharing violation or we got no oplock
1452          * only keep the lock if the caller requested access
1453          * to the lock
1454          */
1455         if (NT_STATUS_EQUAL(status, NT_STATUS_SHARING_VIOLATION) ||
1456             NT_STATUS_EQUAL(status, NT_STATUS_OPLOCK_NOT_GRANTED)) {
1457                 if (lckp) {
1458                         *lckp = lck;
1459                 } else {
1460                         talloc_free(lck);
1461                 }
1462         } else if (!NT_STATUS_IS_OK(status)) {
1463                 talloc_free(lck);
1464                 if (lckp) {
1465                         *lckp = NULL;
1466                 }
1467         } else if (lckp) {
1468                 *lckp = lck;
1469         }
1470
1471         return status;
1472 }
1473
1474 /*
1475   determine if a file can be renamed, or if it is prevented by an
1476   already open file
1477 */
1478 NTSTATUS pvfs_can_rename(struct pvfs_state *pvfs, 
1479                          struct ntvfs_request *req,
1480                          struct pvfs_filename *name,
1481                          struct odb_lock **lckp)
1482 {
1483         NTSTATUS status;
1484         DATA_BLOB key;
1485         struct odb_lock *lck;
1486
1487         status = pvfs_locking_key(name, name, &key);
1488         if (!NT_STATUS_IS_OK(status)) {
1489                 return NT_STATUS_NO_MEMORY;
1490         }
1491
1492         lck = odb_lock(req, pvfs->odb_context, &key);
1493         if (lck == NULL) {
1494                 DEBUG(0,("Unable to lock opendb for can_stat\n"));
1495                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
1496         }
1497
1498         status = odb_can_open(lck,
1499                               NTCREATEX_SHARE_ACCESS_READ |
1500                               NTCREATEX_SHARE_ACCESS_WRITE,
1501                               0,
1502                               SEC_STD_DELETE);
1503
1504         /*
1505          * if it's a sharing violation or we got no oplock
1506          * only keep the lock if the caller requested access
1507          * to the lock
1508          */
1509         if (NT_STATUS_EQUAL(status, NT_STATUS_SHARING_VIOLATION) ||
1510             NT_STATUS_EQUAL(status, NT_STATUS_OPLOCK_NOT_GRANTED)) {
1511                 if (lckp) {
1512                         *lckp = lck;
1513                 } else {
1514                         talloc_free(lck);
1515                 }
1516         } else if (!NT_STATUS_IS_OK(status)) {
1517                 talloc_free(lck);
1518                 if (lckp) {
1519                         *lckp = NULL;
1520                 }
1521         } else if (lckp) {
1522                 *lckp = lck;
1523         }
1524
1525         return status;
1526 }
1527
1528 /*
1529   determine if file meta data can be accessed, or if it is prevented by an
1530   already open file
1531 */
1532 NTSTATUS pvfs_can_stat(struct pvfs_state *pvfs, 
1533                        struct ntvfs_request *req,
1534                        struct pvfs_filename *name)
1535 {
1536         NTSTATUS status;
1537         DATA_BLOB key;
1538         struct odb_lock *lck;
1539
1540         status = pvfs_locking_key(name, name, &key);
1541         if (!NT_STATUS_IS_OK(status)) {
1542                 return NT_STATUS_NO_MEMORY;
1543         }
1544
1545         lck = odb_lock(req, pvfs->odb_context, &key);
1546         if (lck == NULL) {
1547                 DEBUG(0,("Unable to lock opendb for can_stat\n"));
1548                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
1549         }
1550
1551         status = odb_can_open(lck,
1552                               NTCREATEX_SHARE_ACCESS_READ |
1553                               NTCREATEX_SHARE_ACCESS_WRITE,
1554                               0, 0);
1555
1556         if (!NT_STATUS_IS_OK(status)) {
1557                 talloc_free(lck);
1558         }
1559
1560         return status;
1561 }
1562
1563
1564 /*
1565   determine if delete on close is set on 
1566 */
1567 bool pvfs_delete_on_close_set(struct pvfs_state *pvfs, struct pvfs_file_handle *h, 
1568                               int *open_count, char **path)
1569 {
1570         NTSTATUS status;
1571         bool del_on_close;
1572
1573         status = odb_get_delete_on_close(pvfs->odb_context, &h->odb_locking_key, 
1574                                          &del_on_close, open_count, path);
1575         if (!NT_STATUS_IS_OK(status)) {
1576                 DEBUG(1,("WARNING: unable to determine delete on close status for open file\n"));
1577                 return false;
1578         }
1579
1580         return del_on_close;
1581 }