source/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
 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 /*
 288   register an open file in the open files database. This implements the share_access
 289   rules
 290
 291   Note that the path is only used by the delete on close logic, not
 292   for comparing with other filenames
 293 */
 294 static NTSTATUS odb_tdb_open_file(struct odb_lock *lck, void *file_handle,
 295                                   uint32_t stream_id, uint32_t share_access,
 296                                   uint32_t access_mask, bool delete_on_close,
 297                                   const char *path,
 298                                   uint32_t oplock_level, uint32_t *oplock_granted)
 299 {
 300         struct odb_context *odb = lck->odb;
 301         struct opendb_entry e;
 302         int i;
 303         struct opendb_file file;
 304         NTSTATUS status;
 305
 306         if (odb->oplocks == false) {
 307                 oplock_level = OPLOCK_NONE;
 308         }
 309
 310         status = odb_pull_record(lck, &file);
 311         if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
 312                 /* initialise a blank structure */
 313                 ZERO_STRUCT(file);
 314                 file.path = path;
 315         } else {
 316                 NT_STATUS_NOT_OK_RETURN(status);
 317         }
 318
 319         /* see if it conflicts */
 320         e.server          = odb->ntvfs_ctx->server_id;
 321         e.file_handle     = file_handle;
 322         e.stream_id       = stream_id;
 323         e.share_access    = share_access;
 324         e.access_mask     = access_mask;
 325         e.delete_on_close = delete_on_close;
 326         e.oplock_level    = OPLOCK_NONE;
 327
 328         /* see if anyone has an oplock, which we need to break */
 329         for (i=0;i<file.num_entries;i++) {
 330                 if (file.entries[i].oplock_level == OPLOCK_BATCH) {
 331                         /* a batch oplock caches close calls, which
 332                            means the client application might have
 333                            already closed the file. We have to allow
 334                            this close to propogate by sending a oplock
 335                            break request and suspending this call
 336                            until the break is acknowledged or the file
 337                            is closed */
 338                         odb_oplock_break_send(odb, &file.entries[i],
 339                                               OPLOCK_BREAK_TO_LEVEL_II/*TODO*/);
 340                         return NT_STATUS_OPLOCK_NOT_GRANTED;
 341                 }
 342         }
 343
 344         if (file.delete_on_close ||
 345             (file.num_entries != 0 && delete_on_close)) {
 346                 /* while delete on close is set, no new opens are allowed */
 347                 return NT_STATUS_DELETE_PENDING;
 348         }
 349
 350         /* check for sharing violations */
 351         for (i=0;i<file.num_entries;i++) {
 352                 status = share_conflict(&file.entries[i], &e);
 353                 NT_STATUS_NOT_OK_RETURN(status);
 354         }
 355
 356         /* we now know the open could succeed, but we need to check
 357            for any exclusive oplocks. We can't grant a second open
 358            till these are broken. Note that we check for batch oplocks
 359            before checking for sharing violations, and check for
 360            exclusive oplocks afterwards. */
 361         for (i=0;i<file.num_entries;i++) {
 362                 if (file.entries[i].oplock_level == OPLOCK_EXCLUSIVE) {
 363                         odb_oplock_break_send(odb, &file.entries[i],
 364                                               OPLOCK_BREAK_TO_NONE/*TODO*/);
 365                         return NT_STATUS_OPLOCK_NOT_GRANTED;
 366                 }
 367         }
 368
 369         /*
 370           possibly grant an exclusive or batch oplock if this is the only client
 371           with the file open. We don't yet grant levelII oplocks.
 372         */
 373         if (oplock_granted != NULL) {
 374                 if ((oplock_level == OPLOCK_BATCH ||
 375                      oplock_level == OPLOCK_EXCLUSIVE) &&
 376                     file.num_entries == 0) {
 377                         (*oplock_granted) = oplock_level;
 378                 } else {
 379                         (*oplock_granted) = OPLOCK_NONE;
 380                 }
 381                 e.oplock_level = (*oplock_granted);
 382         }
 383
 384         /* it doesn't conflict, so add it to the end */
 385         file.entries = talloc_realloc(lck, file.entries, struct opendb_entry,
 386                                       file.num_entries+1);
 387         NT_STATUS_HAVE_NO_MEMORY(file.entries);
 388
 389         file.entries[file.num_entries] = e;
 390         file.num_entries++;
 391
 392         return odb_push_record(lck, &file);
 393 }
 394
 395
 396 /*
 397   register a pending open file in the open files database
 398 */
 399 static NTSTATUS odb_tdb_open_file_pending(struct odb_lock *lck, void *private)
 400 {
 401         struct odb_context *odb = lck->odb;
 402         struct opendb_file file;
 403         NTSTATUS status;
 404
 405         status = odb_pull_record(lck, &file);
 406         NT_STATUS_NOT_OK_RETURN(status);
 407
 408         file.pending = talloc_realloc(lck, file.pending, struct opendb_pending,
 409                                       file.num_pending+1);
 410         NT_STATUS_HAVE_NO_MEMORY(file.pending);
 411
 412         file.pending[file.num_pending].server = odb->ntvfs_ctx->server_id;
 413         file.pending[file.num_pending].notify_ptr = private;
 414
 415         file.num_pending++;
 416
 417         return odb_push_record(lck, &file);
 418 }
 419
 420
 421 /*
 422   remove a opendb entry
 423 */
 424 static NTSTATUS odb_tdb_close_file(struct odb_lock *lck, void *file_handle)
 425 {
 426         struct odb_context *odb = lck->odb;
 427         struct opendb_file file;
 428         int i;
 429         NTSTATUS status;
 430
 431         status = odb_pull_record(lck, &file);
 432         NT_STATUS_NOT_OK_RETURN(status);
 433
 434         /* find the entry, and delete it */
 435         for (i=0;i<file.num_entries;i++) {
 436                 if (file_handle == file.entries[i].file_handle &&
 437                     cluster_id_equal(&odb->ntvfs_ctx->server_id, &file.entries[i].server)) {
 438                         if (file.entries[i].delete_on_close) {
 439                                 file.delete_on_close = true;
 440                         }
 441                         if (i < file.num_entries-1) {
 442                                 memmove(file.entries+i, file.entries+i+1,
 443                                         (file.num_entries - (i+1)) *
 444                                         sizeof(struct opendb_entry));
 445                         }
 446                         break;
 447                 }
 448         }
 449
 450         if (i == file.num_entries) {
 451                 return NT_STATUS_UNSUCCESSFUL;
 452         }
 453
 454         /* send any pending notifications, removing them once sent */
 455         for (i=0;i<file.num_pending;i++) {
 456                 messaging_send_ptr(odb->ntvfs_ctx->msg_ctx, file.pending[i].server,
 457                                    MSG_PVFS_RETRY_OPEN,
 458                                    file.pending[i].notify_ptr);
 459         }
 460         file.num_pending = 0;
 461
 462         file.num_entries--;
 463
 464         return odb_push_record(lck, &file);
 465 }
 466
 467 /*
 468   update the oplock level of the client
 469 */
 470 static NTSTATUS odb_tdb_update_oplock(struct odb_lock *lck, void *file_handle,
 471                                       uint32_t oplock_level)
 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 update 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                         file.entries[i].oplock_level = oplock_level;
 486                         break;
 487                 }
 488         }
 489
 490         if (i == file.num_entries) {
 491                 return NT_STATUS_UNSUCCESSFUL;
 492         }
 493
 494         /* send any pending notifications, removing them once sent */
 495         for (i=0;i<file.num_pending;i++) {
 496                 messaging_send_ptr(odb->ntvfs_ctx->msg_ctx,
 497                                    file.pending[i].server,
 498                                    MSG_PVFS_RETRY_OPEN,
 499                                    file.pending[i].notify_ptr);
 500         }
 501         file.num_pending = 0;
 502
 503         return odb_push_record(lck, &file);
 504 }
 505
 506 /*
 507   send oplocks breaks to none to all level2 holders
 508 */
 509 static NTSTATUS odb_tdb_break_oplocks(struct odb_lock *lck)
 510 {
 511         struct odb_context *odb = lck->odb;
 512         NTSTATUS status;
 513         struct opendb_file file;
 514         int i;
 515         bool modified = true;
 516
 517         status = odb_pull_record(lck, &file);
 518         if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
 519                 return NT_STATUS_OK;
 520         }
 521         NT_STATUS_NOT_OK_RETURN(status);
 522
 523         /* see if anyone has an oplock, which we need to break */
 524         for (i=0;i<file.num_entries;i++) {
 525                 if (file.entries[i].oplock_level == OPLOCK_LEVEL_II) {
 526                         /*
 527                          * there could be multiple level2 oplocks
 528                          * and we just send a break to none to all of them
 529                          * without waiting for a release
 530                          */
 531                         odb_oplock_break_send(odb, &file.entries[i],
 532                                               OPLOCK_BREAK_TO_NONE);
 533                         file.entries[i].oplock_level = OPLOCK_NONE;
 534                         modified = true;
 535                 }
 536         }
 537
 538         if (modified) {
 539                 return odb_push_record(lck, &file);
 540         }
 541         return NT_STATUS_OK;
 542 }
 543
 544 /*
 545   remove a pending opendb entry
 546 */
 547 static NTSTATUS odb_tdb_remove_pending(struct odb_lock *lck, void *private)
 548 {
 549         struct odb_context *odb = lck->odb;
 550         int i;
 551         NTSTATUS status;
 552         struct opendb_file file;
 553
 554         status = odb_pull_record(lck, &file);
 555         NT_STATUS_NOT_OK_RETURN(status);
 556
 557         /* find the entry, and delete it */
 558         for (i=0;i<file.num_pending;i++) {
 559                 if (private == file.pending[i].notify_ptr &&
 560                     cluster_id_equal(&odb->ntvfs_ctx->server_id, &file.pending[i].server)) {
 561                         if (i < file.num_pending-1) {
 562                                 memmove(file.pending+i, file.pending+i+1,
 563                                         (file.num_pending - (i+1)) *
 564                                         sizeof(struct opendb_pending));
 565                         }
 566                         break;
 567                 }
 568         }
 569
 570         if (i == file.num_pending) {
 571                 return NT_STATUS_UNSUCCESSFUL;
 572         }
 573
 574         file.num_pending--;
 575
 576         return odb_push_record(lck, &file);
 577 }
 578
 579
 580 /*
 581   rename the path in a open file
 582 */
 583 static NTSTATUS odb_tdb_rename(struct odb_lock *lck, const char *path)
 584 {
 585         struct opendb_file file;
 586         NTSTATUS status;
 587
 588         status = odb_pull_record(lck, &file);
 589         if (NT_STATUS_EQUAL(NT_STATUS_OBJECT_NAME_NOT_FOUND, status)) {
 590                 /* not having the record at all is OK */
 591                 return NT_STATUS_OK;
 592         }
 593         NT_STATUS_NOT_OK_RETURN(status);
 594
 595         file.path = path;
 596         return odb_push_record(lck, &file);
 597 }
 598
 599 /*
 600   update delete on close flag on an open file
 601 */
 602 static NTSTATUS odb_tdb_set_delete_on_close(struct odb_lock *lck, bool del_on_close)
 603 {
 604         NTSTATUS status;
 605         struct opendb_file file;
 606
 607         status = odb_pull_record(lck, &file);
 608         NT_STATUS_NOT_OK_RETURN(status);
 609
 610         file.delete_on_close = del_on_close;
 611
 612         return odb_push_record(lck, &file);
 613 }
 614
 615 /*
 616   return the current value of the delete_on_close bit, and how many
 617   people still have the file open
 618 */
 619 static NTSTATUS odb_tdb_get_delete_on_close(struct odb_context *odb,
 620                                             DATA_BLOB *key, bool *del_on_close,
 621                                             int *open_count, char **path)
 622 {
 623         NTSTATUS status;
 624         struct opendb_file file;
 625         struct odb_lock *lck;
 626
 627         lck = odb_lock(odb, odb, key);
 628         NT_STATUS_HAVE_NO_MEMORY(lck);
 629
 630         status = odb_pull_record(lck, &file);
 631         if (NT_STATUS_EQUAL(NT_STATUS_OBJECT_NAME_NOT_FOUND, status)) {
 632                 talloc_free(lck);
 633                 (*del_on_close) = false;
 634                 return NT_STATUS_OK;
 635         }
 636         if (!NT_STATUS_IS_OK(status)) {
 637                 talloc_free(lck);
 638                 return status;
 639         }
 640
 641         (*del_on_close) = file.delete_on_close;
 642         if (open_count != NULL) {
 643                 (*open_count) = file.num_entries;
 644         }
 645         if (path != NULL) {
 646                 *path = talloc_strdup(odb, file.path);
 647                 NT_STATUS_HAVE_NO_MEMORY(*path);
 648                 if (file.num_entries == 1 && file.entries[0].delete_on_close) {
 649                         (*del_on_close) = true;
 650                 }
 651         }
 652
 653         talloc_free(lck);
 654
 655         return NT_STATUS_OK;
 656 }
 657
 658
 659 /*
 660   determine if a file can be opened with the given share_access,
 661   create_options and access_mask
 662 */
 663 static NTSTATUS odb_tdb_can_open(struct odb_lock *lck,
 664                                  uint32_t share_access, uint32_t create_options,
 665                                  uint32_t access_mask)
 666 {
 667         struct odb_context *odb = lck->odb;
 668         NTSTATUS status;
 669         struct opendb_file file;
 670         struct opendb_entry e;
 671         int i;
 672
 673         status = odb_pull_record(lck, &file);
 674         if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
 675                 return NT_STATUS_OK;
 676         }
 677         NT_STATUS_NOT_OK_RETURN(status);
 678
 679         if ((create_options & NTCREATEX_OPTIONS_DELETE_ON_CLOSE) &&
 680             file.num_entries != 0) {
 681                 return NT_STATUS_SHARING_VIOLATION;
 682         }
 683
 684         if (file.delete_on_close) {
 685                 return NT_STATUS_DELETE_PENDING;
 686         }
 687
 688         e.server       = odb->ntvfs_ctx->server_id;
 689         e.file_handle  = NULL;
 690         e.stream_id    = 0;
 691         e.share_access = share_access;
 692         e.access_mask  = access_mask;
 693
 694         for (i=0;i<file.num_entries;i++) {
 695                 status = share_conflict(&file.entries[i], &e);
 696                 if (!NT_STATUS_IS_OK(status)) {
 697                         /* note that we discard the error code
 698                            here. We do this as unless we are actually
 699                            doing an open (which comes via a different
 700                            function), we need to return a sharing
 701                            violation */
 702                         return NT_STATUS_SHARING_VIOLATION;
 703                 }
 704         }
 705
 706         return NT_STATUS_OK;
 707 }
 708
 709
 710 static const struct opendb_ops opendb_tdb_ops = {
 711         .odb_init                = odb_tdb_init,
 712         .odb_lock                = odb_tdb_lock,
 713         .odb_get_key             = odb_tdb_get_key,
 714         .odb_open_file           = odb_tdb_open_file,
 715         .odb_open_file_pending   = odb_tdb_open_file_pending,
 716         .odb_close_file          = odb_tdb_close_file,
 717         .odb_remove_pending      = odb_tdb_remove_pending,
 718         .odb_rename              = odb_tdb_rename,
 719         .odb_set_delete_on_close = odb_tdb_set_delete_on_close,
 720         .odb_get_delete_on_close = odb_tdb_get_delete_on_close,
 721         .odb_can_open            = odb_tdb_can_open,
 722         .odb_update_oplock       = odb_tdb_update_oplock,
 723         .odb_break_oplocks       = odb_tdb_break_oplocks
 724 };
 725
 726
 727 void odb_tdb_init_ops(void)
 728 {
 729         odb_set_ops(&opendb_tdb_ops);
 730 }