opendb_tdb: attribute only opens doesn't conflict with BATCH oplocks
[bbaumbach/samba-autobuild/.git] / source4 / ntvfs / common / opendb_tdb.c
1 /* 
2    Unix SMB/CIFS implementation.
3
4    Copyright (C) Andrew Tridgell 2004
5    Copyright (C) Stefan Metzmacher 2008
6
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 3 of the License, or
10    (at your option) any later version.
11    
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16    
17    You should have received a copy of the GNU General Public License
18    along with this program.  If not, see <http://www.gnu.org/licenses/>.
19 */
20
21 /*
22   this is the open files database, tdb backend. It implements shared
23   storage of what files are open between server instances, and
24   implements the rules of shared access to files.
25
26   The caller needs to provide a file_key, which specifies what file
27   they are talking about. This needs to be a unique key across all
28   filesystems, and is usually implemented in terms of a device/inode
29   pair.
30
31   Before any operations can be performed the caller needs to establish
32   a lock on the record associated with file_key. That is done by
33   calling odb_lock(). The caller releases this lock by calling
34   talloc_free() on the returned handle.
35
36   All other operations on a record are done by passing the odb_lock()
37   handle back to this module. The handle contains internal
38   information about what file_key is being operated on.
39 */
40
41 #include "includes.h"
42 #include "system/filesys.h"
43 #include "lib/tdb/include/tdb.h"
44 #include "messaging/messaging.h"
45 #include "tdb_wrap.h"
46 #include "lib/messaging/irpc.h"
47 #include "librpc/gen_ndr/ndr_opendb.h"
48 #include "ntvfs/ntvfs.h"
49 #include "ntvfs/common/ntvfs_common.h"
50 #include "cluster/cluster.h"
51 #include "param/param.h"
52
53 struct odb_context {
54         struct tdb_wrap *w;
55         struct ntvfs_context *ntvfs_ctx;
56         bool oplocks;
57 };
58
59 /*
60   an odb lock handle. You must obtain one of these using odb_lock() before doing
61   any other operations. 
62 */
63 struct odb_lock {
64         struct odb_context *odb;
65         TDB_DATA key;
66 };
67
68 /*
69   Open up the openfiles.tdb database. Close it down using
70   talloc_free(). We need the messaging_ctx to allow for pending open
71   notifications.
72 */
73 static struct odb_context *odb_tdb_init(TALLOC_CTX *mem_ctx, 
74                                         struct ntvfs_context *ntvfs_ctx)
75 {
76         struct odb_context *odb;
77
78         odb = talloc(mem_ctx, struct odb_context);
79         if (odb == NULL) {
80                 return NULL;
81         }
82
83         odb->w = cluster_tdb_tmp_open(odb, ntvfs_ctx->lp_ctx, "openfiles.tdb", TDB_DEFAULT);
84         if (odb->w == NULL) {
85                 talloc_free(odb);
86                 return NULL;
87         }
88
89         odb->ntvfs_ctx = ntvfs_ctx;
90
91         /* leave oplocks disabled by default until the code is working */
92         odb->oplocks = lp_parm_bool(ntvfs_ctx->lp_ctx, NULL, "opendb", "oplocks", false);
93
94         return odb;
95 }
96
97 /*
98   destroy a lock on the database
99 */
100 static int odb_lock_destructor(struct odb_lock *lck)
101 {
102         tdb_chainunlock(lck->odb->w->tdb, lck->key);
103         return 0;
104 }
105
106 /*
107   get a lock on a entry in the odb. This call returns a lock handle,
108   which the caller should unlock using talloc_free().
109 */
110 static struct odb_lock *odb_tdb_lock(TALLOC_CTX *mem_ctx,
111                                      struct odb_context *odb, DATA_BLOB *file_key)
112 {
113         struct odb_lock *lck;
114
115         lck = talloc(mem_ctx, struct odb_lock);
116         if (lck == NULL) {
117                 return NULL;
118         }
119
120         lck->odb = talloc_reference(lck, odb);
121         lck->key.dptr = talloc_memdup(lck, file_key->data, file_key->length);
122         lck->key.dsize = file_key->length;
123         if (lck->key.dptr == NULL) {
124                 talloc_free(lck);
125                 return NULL;
126         }
127
128         if (tdb_chainlock(odb->w->tdb, lck->key) != 0) {
129                 talloc_free(lck);
130                 return NULL;
131         }
132
133         talloc_set_destructor(lck, odb_lock_destructor);
134         
135         return lck;
136 }
137
138 static DATA_BLOB odb_tdb_get_key(TALLOC_CTX *mem_ctx, struct odb_lock *lck)
139 {
140         return data_blob_talloc(mem_ctx, lck->key.dptr, lck->key.dsize);
141 }
142
143
144 /*
145   determine if two odb_entry structures conflict
146
147   return NT_STATUS_OK on no conflict
148 */
149 static NTSTATUS share_conflict(struct opendb_entry *e1, struct opendb_entry *e2)
150 {
151         /* if either open involves no read.write or delete access then
152            it can't conflict */
153         if (!(e1->access_mask & (SEC_FILE_WRITE_DATA |
154                                  SEC_FILE_APPEND_DATA |
155                                  SEC_FILE_READ_DATA |
156                                  SEC_FILE_EXECUTE |
157                                  SEC_STD_DELETE))) {
158                 return NT_STATUS_OK;
159         }
160         if (!(e2->access_mask & (SEC_FILE_WRITE_DATA |
161                                  SEC_FILE_APPEND_DATA |
162                                  SEC_FILE_READ_DATA |
163                                  SEC_FILE_EXECUTE |
164                                  SEC_STD_DELETE))) {
165                 return NT_STATUS_OK;
166         }
167
168         /* data IO access masks. This is skipped if the two open handles
169            are on different streams (as in that case the masks don't
170            interact) */
171         if (e1->stream_id != e2->stream_id) {
172                 return NT_STATUS_OK;
173         }
174
175 #define CHECK_MASK(am, right, sa, share) \
176         if (((am) & (right)) && !((sa) & (share))) return NT_STATUS_SHARING_VIOLATION
177
178         CHECK_MASK(e1->access_mask, SEC_FILE_WRITE_DATA | SEC_FILE_APPEND_DATA,
179                    e2->share_access, NTCREATEX_SHARE_ACCESS_WRITE);
180         CHECK_MASK(e2->access_mask, SEC_FILE_WRITE_DATA | SEC_FILE_APPEND_DATA,
181                    e1->share_access, NTCREATEX_SHARE_ACCESS_WRITE);
182         
183         CHECK_MASK(e1->access_mask, SEC_FILE_READ_DATA | SEC_FILE_EXECUTE,
184                    e2->share_access, NTCREATEX_SHARE_ACCESS_READ);
185         CHECK_MASK(e2->access_mask, SEC_FILE_READ_DATA | SEC_FILE_EXECUTE,
186                    e1->share_access, NTCREATEX_SHARE_ACCESS_READ);
187
188         CHECK_MASK(e1->access_mask, SEC_STD_DELETE,
189                    e2->share_access, NTCREATEX_SHARE_ACCESS_DELETE);
190         CHECK_MASK(e2->access_mask, SEC_STD_DELETE,
191                    e1->share_access, NTCREATEX_SHARE_ACCESS_DELETE);
192 #undef CHECK_MASK
193         return NT_STATUS_OK;
194 }
195
196 /*
197   pull a record, translating from the db format to the opendb_file structure defined
198   in opendb.idl
199 */
200 static NTSTATUS odb_pull_record(struct odb_lock *lck, struct opendb_file *file)
201 {
202         struct odb_context *odb = lck->odb;
203         TDB_DATA dbuf;
204         DATA_BLOB blob;
205         enum ndr_err_code ndr_err;
206
207         dbuf = tdb_fetch(odb->w->tdb, lck->key);
208         if (dbuf.dptr == NULL) {
209                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
210         }
211
212         blob.data = dbuf.dptr;
213         blob.length = dbuf.dsize;
214
215         ndr_err = ndr_pull_struct_blob(&blob, lck, lp_iconv_convenience(lck->odb->ntvfs_ctx->lp_ctx), file, (ndr_pull_flags_fn_t)ndr_pull_opendb_file);
216         free(dbuf.dptr);
217         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
218                 return ndr_map_error2ntstatus(ndr_err);
219         }
220
221         return NT_STATUS_OK;
222 }
223
224 /*
225   push a record, translating from the opendb_file structure defined in opendb.idl
226 */
227 static NTSTATUS odb_push_record(struct odb_lock *lck, struct opendb_file *file)
228 {
229         struct odb_context *odb = lck->odb;
230         TDB_DATA dbuf;
231         DATA_BLOB blob;
232         enum ndr_err_code ndr_err;
233         int ret;
234
235         if (file->num_entries == 0) {
236                 ret = tdb_delete(odb->w->tdb, lck->key);
237                 if (ret != 0) {
238                         return NT_STATUS_INTERNAL_DB_CORRUPTION;
239                 }
240                 return NT_STATUS_OK;
241         }
242
243         ndr_err = ndr_push_struct_blob(&blob, lck, lp_iconv_convenience(lck->odb->ntvfs_ctx->lp_ctx), file, (ndr_push_flags_fn_t)ndr_push_opendb_file);
244         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
245                 return ndr_map_error2ntstatus(ndr_err);
246         }
247
248         dbuf.dptr = blob.data;
249         dbuf.dsize = blob.length;
250                 
251         ret = tdb_store(odb->w->tdb, lck->key, dbuf, TDB_REPLACE);
252         data_blob_free(&blob);
253         if (ret != 0) {
254                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
255         }
256
257         return NT_STATUS_OK;
258 }
259
260 /*
261   send an oplock break to a client
262 */
263 static NTSTATUS odb_oplock_break_send(struct odb_context *odb,
264                                       struct opendb_entry *e,
265                                       uint8_t level)
266 {
267         NTSTATUS status;
268         struct opendb_oplock_break op_break;
269         DATA_BLOB blob;
270
271         ZERO_STRUCT(op_break);
272
273         /* tell the server handling this open file about the need to send the client
274            a break */
275         op_break.file_handle    = e->file_handle;
276         op_break.level          = level;
277
278         blob = data_blob_const(&op_break, sizeof(op_break));
279
280         status = messaging_send(odb->ntvfs_ctx->msg_ctx, e->server,
281                                 MSG_NTVFS_OPLOCK_BREAK, &blob);
282         NT_STATUS_NOT_OK_RETURN(status);
283
284         return NT_STATUS_OK;
285 }
286
287 static bool access_attributes_only(uint32_t access_mask,
288                                    uint32_t open_disposition)
289 {
290         switch (open_disposition) {
291         case NTCREATEX_DISP_SUPERSEDE:
292         case NTCREATEX_DISP_OVERWRITE_IF:
293         case NTCREATEX_DISP_OVERWRITE:
294                 return false;
295         default:
296                 break;
297         }
298 #define CHECK_MASK(m,g) ((m) && (((m) & ~(g))==0) && (((m) & (g)) != 0))
299         return CHECK_MASK(access_mask,
300                           SEC_STD_SYNCHRONIZE |
301                           SEC_FILE_READ_ATTRIBUTE |
302                           SEC_FILE_WRITE_ATTRIBUTE);
303 #undef CHECK_MASK
304 }
305
306 /*
307   register an open file in the open files database. This implements the share_access
308   rules
309
310   Note that the path is only used by the delete on close logic, not
311   for comparing with other filenames
312 */
313 static NTSTATUS odb_tdb_open_file(struct odb_lock *lck, void *file_handle,
314                                   uint32_t stream_id, uint32_t share_access, 
315                                   uint32_t access_mask, bool delete_on_close,
316                                   const char *path, 
317                                   uint32_t oplock_level, uint32_t *oplock_granted)
318 {
319         struct odb_context *odb = lck->odb;
320         struct opendb_entry e;
321         int i;
322         struct opendb_file file;
323         NTSTATUS status;
324         uint32_t open_disposition = 0;
325         bool attrs_only = false;
326
327         if (odb->oplocks == false) {
328                 oplock_level = OPLOCK_NONE;
329         }
330
331         status = odb_pull_record(lck, &file);
332         if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
333                 /* initialise a blank structure */
334                 ZERO_STRUCT(file);
335                 file.path = path;
336         } else {
337                 NT_STATUS_NOT_OK_RETURN(status);
338         }
339
340         /* see if it conflicts */
341         e.server          = odb->ntvfs_ctx->server_id;
342         e.file_handle     = file_handle;
343         e.stream_id       = stream_id;
344         e.share_access    = share_access;
345         e.access_mask     = access_mask;
346         e.delete_on_close = delete_on_close;
347         e.oplock_level    = OPLOCK_NONE;
348                 
349         /* see if anyone has an oplock, which we need to break */
350         for (i=0;i<file.num_entries;i++) {
351                 if (file.entries[i].oplock_level == OPLOCK_BATCH) {
352                         /* if this is an attribute only access
353                          * it doesn't conflict with a BACTCH oplock
354                          * but we'll not grant the oplock below
355                          */
356                         attrs_only = access_attributes_only(access_mask,
357                                                             open_disposition);
358                         if (attrs_only) {
359                                 break;
360                         }
361                         /* a batch oplock caches close calls, which
362                            means the client application might have
363                            already closed the file. We have to allow
364                            this close to propogate by sending a oplock
365                            break request and suspending this call
366                            until the break is acknowledged or the file
367                            is closed */
368                         odb_oplock_break_send(odb, &file.entries[i],
369                                               OPLOCK_BREAK_TO_LEVEL_II/*TODO*/);
370                         return NT_STATUS_OPLOCK_NOT_GRANTED;
371                 }
372         }
373
374         if (file.delete_on_close || 
375             (file.num_entries != 0 && delete_on_close)) {
376                 /* while delete on close is set, no new opens are allowed */
377                 return NT_STATUS_DELETE_PENDING;
378         }
379
380         /* check for sharing violations */
381         for (i=0;i<file.num_entries;i++) {
382                 status = share_conflict(&file.entries[i], &e);
383                 NT_STATUS_NOT_OK_RETURN(status);
384         }
385
386         /* we now know the open could succeed, but we need to check
387            for any exclusive oplocks. We can't grant a second open
388            till these are broken. Note that we check for batch oplocks
389            before checking for sharing violations, and check for
390            exclusive oplocks afterwards. */
391         for (i=0;i<file.num_entries;i++) {
392                 if (file.entries[i].oplock_level == OPLOCK_EXCLUSIVE) {
393                         odb_oplock_break_send(odb, &file.entries[i],
394                                               OPLOCK_BREAK_TO_NONE/*TODO*/);
395                         return NT_STATUS_OPLOCK_NOT_GRANTED;
396                 }
397         }
398
399         /*
400           possibly grant an exclusive, batch or level2 oplock
401         */
402         if (oplock_granted) {
403                 if (attrs_only) {
404                         e.oplock_level  = OPLOCK_NONE;
405                         *oplock_granted = NO_OPLOCK_RETURN;
406                 } else if (oplock_level == OPLOCK_EXCLUSIVE) {
407                         if (file.num_entries == 0) {
408                                 e.oplock_level  = OPLOCK_EXCLUSIVE;
409                                 *oplock_granted = EXCLUSIVE_OPLOCK_RETURN;
410                         } else {
411                                 e.oplock_level  = OPLOCK_NONE;
412                                 *oplock_granted = NO_OPLOCK_RETURN;
413                         }
414                 } else if (oplock_level == OPLOCK_BATCH) {
415                         if (file.num_entries == 0) {
416                                 e.oplock_level  = OPLOCK_BATCH;
417                                 *oplock_granted = BATCH_OPLOCK_RETURN;
418                         } else {
419                                 e.oplock_level  = OPLOCK_LEVEL_II;
420                                 *oplock_granted = LEVEL_II_OPLOCK_RETURN;
421                         }
422                 } else if (oplock_level == OPLOCK_LEVEL_II) {
423                         e.oplock_level  = OPLOCK_LEVEL_II;
424                         *oplock_granted = LEVEL_II_OPLOCK_RETURN;
425                 } else {
426                         e.oplock_level  = OPLOCK_NONE;
427                         *oplock_granted = NO_OPLOCK_RETURN;
428                 }
429         }
430
431         /* it doesn't conflict, so add it to the end */
432         file.entries = talloc_realloc(lck, file.entries, struct opendb_entry, 
433                                       file.num_entries+1);
434         NT_STATUS_HAVE_NO_MEMORY(file.entries);
435
436         file.entries[file.num_entries] = e;
437         file.num_entries++;
438
439         return odb_push_record(lck, &file);
440 }
441
442
443 /*
444   register a pending open file in the open files database
445 */
446 static NTSTATUS odb_tdb_open_file_pending(struct odb_lock *lck, void *private)
447 {
448         struct odb_context *odb = lck->odb;
449         struct opendb_file file;
450         NTSTATUS status;
451                 
452         status = odb_pull_record(lck, &file);
453         NT_STATUS_NOT_OK_RETURN(status);
454
455         file.pending = talloc_realloc(lck, file.pending, struct opendb_pending, 
456                                       file.num_pending+1);
457         NT_STATUS_HAVE_NO_MEMORY(file.pending);
458
459         file.pending[file.num_pending].server = odb->ntvfs_ctx->server_id;
460         file.pending[file.num_pending].notify_ptr = private;
461
462         file.num_pending++;
463
464         return odb_push_record(lck, &file);
465 }
466
467
468 /*
469   remove a opendb entry
470 */
471 static NTSTATUS odb_tdb_close_file(struct odb_lock *lck, void *file_handle)
472 {
473         struct odb_context *odb = lck->odb;
474         struct opendb_file file;
475         int i;
476         NTSTATUS status;
477
478         status = odb_pull_record(lck, &file);
479         NT_STATUS_NOT_OK_RETURN(status);
480
481         /* find the entry, and delete it */
482         for (i=0;i<file.num_entries;i++) {
483                 if (file_handle == file.entries[i].file_handle &&
484                     cluster_id_equal(&odb->ntvfs_ctx->server_id, &file.entries[i].server)) {
485                         if (file.entries[i].delete_on_close) {
486                                 file.delete_on_close = true;
487                         }
488                         if (i < file.num_entries-1) {
489                                 memmove(file.entries+i, file.entries+i+1, 
490                                         (file.num_entries - (i+1)) * 
491                                         sizeof(struct opendb_entry));
492                         }
493                         break;
494                 }
495         }
496
497         if (i == file.num_entries) {
498                 return NT_STATUS_UNSUCCESSFUL;
499         }
500
501         /* send any pending notifications, removing them once sent */
502         for (i=0;i<file.num_pending;i++) {
503                 messaging_send_ptr(odb->ntvfs_ctx->msg_ctx, file.pending[i].server, 
504                                    MSG_PVFS_RETRY_OPEN, 
505                                    file.pending[i].notify_ptr);
506         }
507         file.num_pending = 0;
508
509         file.num_entries--;
510         
511         return odb_push_record(lck, &file);
512 }
513
514 /*
515   update the oplock level of the client
516 */
517 static NTSTATUS odb_tdb_update_oplock(struct odb_lock *lck, void *file_handle,
518                                       uint32_t oplock_level)
519 {
520         struct odb_context *odb = lck->odb;
521         struct opendb_file file;
522         int i;
523         NTSTATUS status;
524
525         status = odb_pull_record(lck, &file);
526         NT_STATUS_NOT_OK_RETURN(status);
527
528         /* find the entry, and update it */
529         for (i=0;i<file.num_entries;i++) {
530                 if (file_handle == file.entries[i].file_handle &&
531                     cluster_id_equal(&odb->ntvfs_ctx->server_id, &file.entries[i].server)) {
532                         file.entries[i].oplock_level = oplock_level;
533                         break;
534                 }
535         }
536
537         if (i == file.num_entries) {
538                 return NT_STATUS_UNSUCCESSFUL;
539         }
540
541         /* send any pending notifications, removing them once sent */
542         for (i=0;i<file.num_pending;i++) {
543                 messaging_send_ptr(odb->ntvfs_ctx->msg_ctx,
544                                    file.pending[i].server,
545                                    MSG_PVFS_RETRY_OPEN,
546                                    file.pending[i].notify_ptr);
547         }
548         file.num_pending = 0;
549
550         return odb_push_record(lck, &file);
551 }
552
553 /*
554   send oplocks breaks to none to all level2 holders
555 */
556 static NTSTATUS odb_tdb_break_oplocks(struct odb_lock *lck)
557 {
558         struct odb_context *odb = lck->odb;
559         NTSTATUS status;
560         struct opendb_file file;
561         int i;
562         bool modified = true;
563
564         status = odb_pull_record(lck, &file);
565         if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
566                 return NT_STATUS_OK;
567         }
568         NT_STATUS_NOT_OK_RETURN(status);
569
570         /* see if anyone has an oplock, which we need to break */
571         for (i=0;i<file.num_entries;i++) {
572                 if (file.entries[i].oplock_level == OPLOCK_LEVEL_II) {
573                         /*
574                          * there could be multiple level2 oplocks
575                          * and we just send a break to none to all of them
576                          * without waiting for a release
577                          */
578                         odb_oplock_break_send(odb, &file.entries[i],
579                                               OPLOCK_BREAK_TO_NONE);
580                         file.entries[i].oplock_level = OPLOCK_NONE;
581                         modified = true;
582                 }
583         }
584
585         if (modified) {
586                 return odb_push_record(lck, &file);
587         }
588         return NT_STATUS_OK;
589 }
590
591 /*
592   remove a pending opendb entry
593 */
594 static NTSTATUS odb_tdb_remove_pending(struct odb_lock *lck, void *private)
595 {
596         struct odb_context *odb = lck->odb;
597         int i;
598         NTSTATUS status;
599         struct opendb_file file;
600
601         status = odb_pull_record(lck, &file);
602         NT_STATUS_NOT_OK_RETURN(status);
603
604         /* find the entry, and delete it */
605         for (i=0;i<file.num_pending;i++) {
606                 if (private == file.pending[i].notify_ptr &&
607                     cluster_id_equal(&odb->ntvfs_ctx->server_id, &file.pending[i].server)) {
608                         if (i < file.num_pending-1) {
609                                 memmove(file.pending+i, file.pending+i+1, 
610                                         (file.num_pending - (i+1)) * 
611                                         sizeof(struct opendb_pending));
612                         }
613                         break;
614                 }
615         }
616
617         if (i == file.num_pending) {
618                 return NT_STATUS_UNSUCCESSFUL;
619         }
620
621         file.num_pending--;
622         
623         return odb_push_record(lck, &file);
624 }
625
626
627 /*
628   rename the path in a open file
629 */
630 static NTSTATUS odb_tdb_rename(struct odb_lock *lck, const char *path)
631 {
632         struct opendb_file file;
633         NTSTATUS status;
634
635         status = odb_pull_record(lck, &file);
636         if (NT_STATUS_EQUAL(NT_STATUS_OBJECT_NAME_NOT_FOUND, status)) {
637                 /* not having the record at all is OK */
638                 return NT_STATUS_OK;
639         }
640         NT_STATUS_NOT_OK_RETURN(status);
641
642         file.path = path;
643         return odb_push_record(lck, &file);
644 }
645
646 /*
647   update delete on close flag on an open file
648 */
649 static NTSTATUS odb_tdb_set_delete_on_close(struct odb_lock *lck, bool del_on_close)
650 {
651         NTSTATUS status;
652         struct opendb_file file;
653
654         status = odb_pull_record(lck, &file);
655         NT_STATUS_NOT_OK_RETURN(status);
656
657         file.delete_on_close = del_on_close;
658
659         return odb_push_record(lck, &file);
660 }
661
662 /*
663   return the current value of the delete_on_close bit, and how many
664   people still have the file open
665 */
666 static NTSTATUS odb_tdb_get_delete_on_close(struct odb_context *odb, 
667                                             DATA_BLOB *key, bool *del_on_close, 
668                                             int *open_count, char **path)
669 {
670         NTSTATUS status;
671         struct opendb_file file;
672         struct odb_lock *lck;
673
674         lck = odb_lock(odb, odb, key);
675         NT_STATUS_HAVE_NO_MEMORY(lck);
676
677         status = odb_pull_record(lck, &file);
678         if (NT_STATUS_EQUAL(NT_STATUS_OBJECT_NAME_NOT_FOUND, status)) {
679                 talloc_free(lck);
680                 (*del_on_close) = false;
681                 return NT_STATUS_OK;
682         }
683         if (!NT_STATUS_IS_OK(status)) {
684                 talloc_free(lck);
685                 return status;
686         }
687
688         (*del_on_close) = file.delete_on_close;
689         if (open_count != NULL) {
690                 (*open_count) = file.num_entries;
691         }
692         if (path != NULL) {
693                 *path = talloc_strdup(odb, file.path);
694                 NT_STATUS_HAVE_NO_MEMORY(*path);
695                 if (file.num_entries == 1 && file.entries[0].delete_on_close) {
696                         (*del_on_close) = true;
697                 }
698         }
699
700         talloc_free(lck);
701
702         return NT_STATUS_OK;
703 }
704
705
706 /*
707   determine if a file can be opened with the given share_access,
708   create_options and access_mask
709 */
710 static NTSTATUS odb_tdb_can_open(struct odb_lock *lck,
711                                  uint32_t share_access, uint32_t create_options, 
712                                  uint32_t access_mask)
713 {
714         struct odb_context *odb = lck->odb;
715         NTSTATUS status;
716         struct opendb_file file;
717         struct opendb_entry e;
718         int i;
719
720         status = odb_pull_record(lck, &file);
721         if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
722                 return NT_STATUS_OK;
723         }
724         NT_STATUS_NOT_OK_RETURN(status);
725
726         if ((create_options & NTCREATEX_OPTIONS_DELETE_ON_CLOSE) && 
727             file.num_entries != 0) {
728                 return NT_STATUS_SHARING_VIOLATION;
729         }
730
731         if (file.delete_on_close) {
732                 return NT_STATUS_DELETE_PENDING;
733         }
734
735         e.server       = odb->ntvfs_ctx->server_id;
736         e.file_handle  = NULL;
737         e.stream_id    = 0;
738         e.share_access = share_access;
739         e.access_mask  = access_mask;
740                 
741         for (i=0;i<file.num_entries;i++) {
742                 status = share_conflict(&file.entries[i], &e);
743                 if (!NT_STATUS_IS_OK(status)) {
744                         /* note that we discard the error code
745                            here. We do this as unless we are actually
746                            doing an open (which comes via a different
747                            function), we need to return a sharing
748                            violation */
749                         return NT_STATUS_SHARING_VIOLATION;
750                 }
751         }
752
753         return NT_STATUS_OK;
754 }
755
756
757 static const struct opendb_ops opendb_tdb_ops = {
758         .odb_init                = odb_tdb_init,
759         .odb_lock                = odb_tdb_lock,
760         .odb_get_key             = odb_tdb_get_key,
761         .odb_open_file           = odb_tdb_open_file,
762         .odb_open_file_pending   = odb_tdb_open_file_pending,
763         .odb_close_file          = odb_tdb_close_file,
764         .odb_remove_pending      = odb_tdb_remove_pending,
765         .odb_rename              = odb_tdb_rename,
766         .odb_set_delete_on_close = odb_tdb_set_delete_on_close,
767         .odb_get_delete_on_close = odb_tdb_get_delete_on_close,
768         .odb_can_open            = odb_tdb_can_open,
769         .odb_update_oplock       = odb_tdb_update_oplock,
770         .odb_break_oplocks       = odb_tdb_break_oplocks
771 };
772
773
774 void odb_tdb_init_ops(void)
775 {
776         odb_set_ops(&opendb_tdb_ops);
777 }