source3/locking/locking.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Locking functions
   4    Copyright (C) Andrew Tridgell 1992-2000
   5    Copyright (C) Jeremy Allison 1992-2006
   6    Copyright (C) Volker Lendecke 2005
   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    Revision History:
  22
  23    12 aug 96: Erik.Devriendt@te6.siemens.be
  24    added support for shared memory implementation of share mode locking
  25
  26    May 1997. Jeremy Allison (jallison@whistle.com). Modified share mode
  27    locking to deal with multiple share modes per open file.
  28
  29    September 1997. Jeremy Allison (jallison@whistle.com). Added oplock
  30    support.
  31
  32    rewritten completely to use new tdb code. Tridge, Dec '99
  33
  34    Added POSIX locking support. Jeremy Allison (jeremy@valinux.com), Apr. 2000.
  35    Added Unix Extensions POSIX locking support. Jeremy Allison Mar 2006.
  36 */
  37
  38 #include "includes.h"
  39 #include "system/filesys.h"
  40 #include "locking/proto.h"
  41 #include "smbd/globals.h"
  42 #include "dbwrap/dbwrap.h"
  43 #include "dbwrap/dbwrap_open.h"
  44 #include "../libcli/security/security.h"
  45 #include "serverid.h"
  46 #include "messages.h"
  47 #include "util_tdb.h"
  48 #include "../librpc/gen_ndr/ndr_open_files.h"
  49
  50 #undef DBGC_CLASS
  51 #define DBGC_CLASS DBGC_LOCKING
  52
  53 #define NO_LOCKING_COUNT (-1)
  54
  55 /* the locking database handle */
  56 static struct db_context *lock_db;
  57
  58 /****************************************************************************
  59  Debugging aids :-).
  60 ****************************************************************************/
  61
  62 const char *lock_type_name(enum brl_type lock_type)
  63 {
  64         switch (lock_type) {
  65                 case READ_LOCK:
  66                         return "READ";
  67                 case WRITE_LOCK:
  68                         return "WRITE";
  69                 case PENDING_READ_LOCK:
  70                         return "PENDING_READ";
  71                 case PENDING_WRITE_LOCK:
  72                         return "PENDING_WRITE";
  73                 default:
  74                         return "other";
  75         }
  76 }
  77
  78 const char *lock_flav_name(enum brl_flavour lock_flav)
  79 {
  80         return (lock_flav == WINDOWS_LOCK) ? "WINDOWS_LOCK" : "POSIX_LOCK";
  81 }
  82
  83 /****************************************************************************
  84  Utility function called to see if a file region is locked.
  85  Called in the read/write codepath.
  86 ****************************************************************************/
  87
  88 void init_strict_lock_struct(files_struct *fsp,
  89                                 uint64_t smblctx,
  90                                 br_off start,
  91                                 br_off size,
  92                                 enum brl_type lock_type,
  93                                 struct lock_struct *plock)
  94 {
  95         SMB_ASSERT(lock_type == READ_LOCK || lock_type == WRITE_LOCK);
  96
  97         plock->context.smblctx = smblctx;
  98         plock->context.tid = fsp->conn->cnum;
  99         plock->context.pid = messaging_server_id(fsp->conn->sconn->msg_ctx);
 100         plock->start = start;
 101         plock->size = size;
 102         plock->fnum = fsp->fnum;
 103         plock->lock_type = lock_type;
 104         plock->lock_flav = lp_posix_cifsu_locktype(fsp);
 105 }
 106
 107 bool strict_lock_default(files_struct *fsp, struct lock_struct *plock)
 108 {
 109         int strict_locking = lp_strict_locking(fsp->conn->params);
 110         bool ret = False;
 111
 112         if (plock->size == 0) {
 113                 return True;
 114         }
 115
 116         if (!lp_locking(fsp->conn->params) || !strict_locking) {
 117                 return True;
 118         }
 119
 120         if (strict_locking == Auto) {
 121                 if  (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type) && (plock->lock_type == READ_LOCK || plock->lock_type == WRITE_LOCK)) {
 122                         DEBUG(10,("is_locked: optimisation - exclusive oplock on file %s\n", fsp_str_dbg(fsp)));
 123                         ret = True;
 124                 } else if ((fsp->oplock_type == LEVEL_II_OPLOCK) &&
 125                            (plock->lock_type == READ_LOCK)) {
 126                         DEBUG(10,("is_locked: optimisation - level II oplock on file %s\n", fsp_str_dbg(fsp)));
 127                         ret = True;
 128                 } else {
 129                         struct byte_range_lock *br_lck;
 130
 131                         br_lck = brl_get_locks_readonly(fsp);
 132                         if (!br_lck) {
 133                                 return True;
 134                         }
 135                         ret = brl_locktest(br_lck,
 136                                         plock->context.smblctx,
 137                                         plock->context.pid,
 138                                         plock->start,
 139                                         plock->size,
 140                                         plock->lock_type,
 141                                         plock->lock_flav);
 142                 }
 143         } else {
 144                 struct byte_range_lock *br_lck;
 145
 146                 br_lck = brl_get_locks_readonly(fsp);
 147                 if (!br_lck) {
 148                         return True;
 149                 }
 150                 ret = brl_locktest(br_lck,
 151                                 plock->context.smblctx,
 152                                 plock->context.pid,
 153                                 plock->start,
 154                                 plock->size,
 155                                 plock->lock_type,
 156                                 plock->lock_flav);
 157         }
 158
 159         DEBUG(10,("strict_lock_default: flavour = %s brl start=%.0f "
 160                         "len=%.0f %s for fnum %d file %s\n",
 161                         lock_flav_name(plock->lock_flav),
 162                         (double)plock->start, (double)plock->size,
 163                         ret ? "unlocked" : "locked",
 164                         plock->fnum, fsp_str_dbg(fsp)));
 165
 166         return ret;
 167 }
 168
 169 void strict_unlock_default(files_struct *fsp, struct lock_struct *plock)
 170 {
 171 }
 172
 173 /****************************************************************************
 174  Find out if a lock could be granted - return who is blocking us if we can't.
 175 ****************************************************************************/
 176
 177 NTSTATUS query_lock(files_struct *fsp,
 178                         uint64_t *psmblctx,
 179                         uint64_t *pcount,
 180                         uint64_t *poffset,
 181                         enum brl_type *plock_type,
 182                         enum brl_flavour lock_flav)
 183 {
 184         struct byte_range_lock *br_lck = NULL;
 185
 186         if (!fsp->can_lock) {
 187                 return fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
 188         }
 189
 190         if (!lp_locking(fsp->conn->params)) {
 191                 return NT_STATUS_OK;
 192         }
 193
 194         br_lck = brl_get_locks_readonly(fsp);
 195         if (!br_lck) {
 196                 return NT_STATUS_NO_MEMORY;
 197         }
 198
 199         return brl_lockquery(br_lck,
 200                         psmblctx,
 201                         messaging_server_id(fsp->conn->sconn->msg_ctx),
 202                         poffset,
 203                         pcount,
 204                         plock_type,
 205                         lock_flav);
 206 }
 207
 208 static void increment_current_lock_count(files_struct *fsp,
 209     enum brl_flavour lock_flav)
 210 {
 211         if (lock_flav == WINDOWS_LOCK &&
 212             fsp->current_lock_count != NO_LOCKING_COUNT) {
 213                 /* blocking ie. pending, locks also count here,
 214                  * as this is an efficiency counter to avoid checking
 215                  * the lock db. on close. JRA. */
 216
 217                 fsp->current_lock_count++;
 218         } else {
 219                 /* Notice that this has had a POSIX lock request.
 220                  * We can't count locks after this so forget them.
 221                  */
 222                 fsp->current_lock_count = NO_LOCKING_COUNT;
 223         }
 224 }
 225
 226 static void decrement_current_lock_count(files_struct *fsp,
 227     enum brl_flavour lock_flav)
 228 {
 229         if (lock_flav == WINDOWS_LOCK &&
 230             fsp->current_lock_count != NO_LOCKING_COUNT) {
 231                 SMB_ASSERT(fsp->current_lock_count > 0);
 232                 fsp->current_lock_count--;
 233         }
 234 }
 235
 236 /****************************************************************************
 237  Utility function called by locking requests.
 238 ****************************************************************************/
 239
 240 struct byte_range_lock *do_lock(struct messaging_context *msg_ctx,
 241                         files_struct *fsp,
 242                         uint64_t smblctx,
 243                         uint64_t count,
 244                         uint64_t offset,
 245                         enum brl_type lock_type,
 246                         enum brl_flavour lock_flav,
 247                         bool blocking_lock,
 248                         NTSTATUS *perr,
 249                         uint64_t *psmblctx,
 250                         struct blocking_lock_record *blr)
 251 {
 252         struct byte_range_lock *br_lck = NULL;
 253
 254         /* silently return ok on print files as we don't do locking there */
 255         if (fsp->print_file) {
 256                 *perr = NT_STATUS_OK;
 257                 return NULL;
 258         }
 259
 260         if (!fsp->can_lock) {
 261                 *perr = fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
 262                 return NULL;
 263         }
 264
 265         if (!lp_locking(fsp->conn->params)) {
 266                 *perr = NT_STATUS_OK;
 267                 return NULL;
 268         }
 269
 270         /* NOTE! 0 byte long ranges ARE allowed and should be stored  */
 271
 272         DEBUG(10,("do_lock: lock flavour %s lock type %s start=%.0f len=%.0f "
 273                 "blocking_lock=%s requested for fnum %d file %s\n",
 274                 lock_flav_name(lock_flav), lock_type_name(lock_type),
 275                 (double)offset, (double)count, blocking_lock ? "true" :
 276                 "false", fsp->fnum, fsp_str_dbg(fsp)));
 277
 278         br_lck = brl_get_locks(talloc_tos(), fsp);
 279         if (!br_lck) {
 280                 *perr = NT_STATUS_NO_MEMORY;
 281                 return NULL;
 282         }
 283
 284         *perr = brl_lock(msg_ctx,
 285                         br_lck,
 286                         smblctx,
 287                         messaging_server_id(fsp->conn->sconn->msg_ctx),
 288                         offset,
 289                         count,
 290                         lock_type,
 291                         lock_flav,
 292                         blocking_lock,
 293                         psmblctx,
 294                         blr);
 295
 296         DEBUG(10, ("do_lock: returning status=%s\n", nt_errstr(*perr)));
 297
 298         increment_current_lock_count(fsp, lock_flav);
 299         return br_lck;
 300 }
 301
 302 /****************************************************************************
 303  Utility function called by unlocking requests.
 304 ****************************************************************************/
 305
 306 NTSTATUS do_unlock(struct messaging_context *msg_ctx,
 307                         files_struct *fsp,
 308                         uint64_t smblctx,
 309                         uint64_t count,
 310                         uint64_t offset,
 311                         enum brl_flavour lock_flav)
 312 {
 313         bool ok = False;
 314         struct byte_range_lock *br_lck = NULL;
 315
 316         if (!fsp->can_lock) {
 317                 return fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
 318         }
 319
 320         if (!lp_locking(fsp->conn->params)) {
 321                 return NT_STATUS_OK;
 322         }
 323
 324         DEBUG(10,("do_unlock: unlock start=%.0f len=%.0f requested for fnum %d file %s\n",
 325                   (double)offset, (double)count, fsp->fnum,
 326                   fsp_str_dbg(fsp)));
 327
 328         br_lck = brl_get_locks(talloc_tos(), fsp);
 329         if (!br_lck) {
 330                 return NT_STATUS_NO_MEMORY;
 331         }
 332
 333         ok = brl_unlock(msg_ctx,
 334                         br_lck,
 335                         smblctx,
 336                         messaging_server_id(fsp->conn->sconn->msg_ctx),
 337                         offset,
 338                         count,
 339                         lock_flav);
 340
 341         TALLOC_FREE(br_lck);
 342
 343         if (!ok) {
 344                 DEBUG(10,("do_unlock: returning ERRlock.\n" ));
 345                 return NT_STATUS_RANGE_NOT_LOCKED;
 346         }
 347
 348         decrement_current_lock_count(fsp, lock_flav);
 349         return NT_STATUS_OK;
 350 }
 351
 352 /****************************************************************************
 353  Cancel any pending blocked locks.
 354 ****************************************************************************/
 355
 356 NTSTATUS do_lock_cancel(files_struct *fsp,
 357                         uint64 smblctx,
 358                         uint64_t count,
 359                         uint64_t offset,
 360                         enum brl_flavour lock_flav,
 361                         struct blocking_lock_record *blr)
 362 {
 363         bool ok = False;
 364         struct byte_range_lock *br_lck = NULL;
 365
 366         if (!fsp->can_lock) {
 367                 return fsp->is_directory ?
 368                         NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
 369         }
 370
 371         if (!lp_locking(fsp->conn->params)) {
 372                 return NT_STATUS_DOS(ERRDOS, ERRcancelviolation);
 373         }
 374
 375         DEBUG(10,("do_lock_cancel: cancel start=%.0f len=%.0f requested for fnum %d file %s\n",
 376                   (double)offset, (double)count, fsp->fnum,
 377                   fsp_str_dbg(fsp)));
 378
 379         br_lck = brl_get_locks(talloc_tos(), fsp);
 380         if (!br_lck) {
 381                 return NT_STATUS_NO_MEMORY;
 382         }
 383
 384         ok = brl_lock_cancel(br_lck,
 385                         smblctx,
 386                         messaging_server_id(fsp->conn->sconn->msg_ctx),
 387                         offset,
 388                         count,
 389                         lock_flav,
 390                         blr);
 391
 392         TALLOC_FREE(br_lck);
 393
 394         if (!ok) {
 395                 DEBUG(10,("do_lock_cancel: returning ERRcancelviolation.\n" ));
 396                 return NT_STATUS_DOS(ERRDOS, ERRcancelviolation);
 397         }
 398
 399         decrement_current_lock_count(fsp, lock_flav);
 400         return NT_STATUS_OK;
 401 }
 402
 403 /****************************************************************************
 404  Remove any locks on this fd. Called from file_close().
 405 ****************************************************************************/
 406
 407 void locking_close_file(struct messaging_context *msg_ctx,
 408                         files_struct *fsp,
 409                         enum file_close_type close_type)
 410 {
 411         struct byte_range_lock *br_lck;
 412
 413         if (!lp_locking(fsp->conn->params)) {
 414                 return;
 415         }
 416
 417         /* If we have not outstanding locks or pending
 418          * locks then we don't need to look in the lock db.
 419          */
 420
 421         if (fsp->current_lock_count == 0) {
 422                 return;
 423         }
 424
 425         br_lck = brl_get_locks(talloc_tos(),fsp);
 426
 427         if (br_lck) {
 428                 cancel_pending_lock_requests_by_fid(fsp, br_lck, close_type);
 429                 brl_close_fnum(msg_ctx, br_lck);
 430                 TALLOC_FREE(br_lck);
 431         }
 432 }
 433
 434 /****************************************************************************
 435  Initialise the locking functions.
 436 ****************************************************************************/
 437
 438 static bool locking_init_internal(bool read_only)
 439 {
 440         brl_init(read_only);
 441
 442         if (lock_db)
 443                 return True;
 444
 445         lock_db = db_open(NULL, lock_path("locking.tdb"),
 446                           lp_open_files_db_hash_size(),
 447                           TDB_DEFAULT|TDB_VOLATILE|TDB_CLEAR_IF_FIRST|TDB_INCOMPATIBLE_HASH,
 448                           read_only?O_RDONLY:O_RDWR|O_CREAT, 0644);
 449
 450         if (!lock_db) {
 451                 DEBUG(0,("ERROR: Failed to initialise locking database\n"));
 452                 return False;
 453         }
 454
 455         if (!posix_locking_init(read_only))
 456                 return False;
 457
 458         return True;
 459 }
 460
 461 bool locking_init(void)
 462 {
 463         return locking_init_internal(false);
 464 }
 465
 466 bool locking_init_readonly(void)
 467 {
 468         return locking_init_internal(true);
 469 }
 470
 471 /*******************************************************************
 472  Deinitialize the share_mode management.
 473 ******************************************************************/
 474
 475 bool locking_end(void)
 476 {
 477         brl_shutdown();
 478         TALLOC_FREE(lock_db);
 479         return true;
 480 }
 481
 482 /*******************************************************************
 483  Form a static locking key for a dev/inode pair.
 484 ******************************************************************/
 485
 486 static TDB_DATA locking_key(const struct file_id *id, struct file_id *tmp)
 487 {
 488         *tmp = *id;
 489         return make_tdb_data((const uint8_t *)tmp, sizeof(*tmp));
 490 }
 491
 492 /*******************************************************************
 493  Print out a share mode.
 494 ********************************************************************/
 495
 496 char *share_mode_str(TALLOC_CTX *ctx, int num, const struct share_mode_entry *e)
 497 {
 498         return talloc_asprintf(ctx, "share_mode_entry[%d]: "
 499                  "pid = %s, share_access = 0x%x, private_options = 0x%x, "
 500                  "access_mask = 0x%x, mid = 0x%llx, type= 0x%x, gen_id = %llu, "
 501                  "uid = %u, flags = %u, file_id %s, name_hash = 0x%x",
 502                  num,
 503                  procid_str_static(&e->pid),
 504                  e->share_access, e->private_options,
 505                  e->access_mask, (unsigned long long)e->op_mid,
 506                  e->op_type, (unsigned long long)e->share_file_id,
 507                  (unsigned int)e->uid, (unsigned int)e->flags,
 508                  file_id_string_tos(&e->id),
 509                  (unsigned int)e->name_hash);
 510 }
 511
 512 /*******************************************************************
 513  Get all share mode entries for a dev/inode pair.
 514 ********************************************************************/
 515
 516 static struct share_mode_data *parse_share_modes(TALLOC_CTX *mem_ctx,
 517                                                  const TDB_DATA dbuf)
 518 {
 519         struct share_mode_data *d;
 520         int i;
 521         struct server_id *pids;
 522         bool *pid_exists;
 523         enum ndr_err_code ndr_err;
 524         DATA_BLOB blob;
 525
 526         d = talloc_zero(mem_ctx, struct share_mode_data);
 527         if (d == NULL) {
 528                 DEBUG(0, ("talloc failed\n"));
 529                 goto fail;
 530         }
 531
 532         blob.data = dbuf.dptr;
 533         blob.length = dbuf.dsize;
 534
 535         ndr_err = ndr_pull_struct_blob(
 536                 &blob, d, d, (ndr_pull_flags_fn_t)ndr_pull_share_mode_data);
 537         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 538                 DEBUG(1, ("ndr_pull_share_mode_lock failed\n"));
 539                 goto fail;
 540         }
 541
 542         d->modified = false;
 543         d->fresh = false;
 544
 545         if (DEBUGLEVEL >= 10) {
 546                 DEBUG(10, ("parse_share_modes:\n"));
 547                 NDR_PRINT_DEBUG(share_mode_data, d);
 548         }
 549
 550         /*
 551          * Ensure that each entry has a real process attached.
 552          */
 553
 554         pids = talloc_array(talloc_tos(), struct server_id,
 555                             d->num_share_modes);
 556         if (pids == NULL) {
 557                 DEBUG(0, ("talloc failed\n"));
 558                 goto fail;
 559         }
 560         pid_exists = talloc_array(talloc_tos(), bool, d->num_share_modes);
 561         if (pid_exists == NULL) {
 562                 DEBUG(0, ("talloc failed\n"));
 563                 goto fail;
 564         }
 565
 566         for (i=0; i<d->num_share_modes; i++) {
 567                 pids[i] = d->share_modes[i].pid;
 568         }
 569         if (!serverids_exist(pids, d->num_share_modes, pid_exists)) {
 570                 DEBUG(0, ("serverid_exists failed\n"));
 571                 goto fail;
 572         }
 573
 574         i = 0;
 575         while (i < d->num_share_modes) {
 576                 struct share_mode_entry *e = &d->share_modes[i];
 577                 if (!pid_exists[i]) {
 578                         *e = d->share_modes[d->num_share_modes-1];
 579                         d->num_share_modes -= 1;
 580                         d->modified = True;
 581                         continue;
 582                 }
 583                 i += 1;
 584         }
 585         TALLOC_FREE(pid_exists);
 586         TALLOC_FREE(pids);
 587         return d;
 588 fail:
 589         TALLOC_FREE(d);
 590         return NULL;
 591 }
 592
 593 static TDB_DATA unparse_share_modes(struct share_mode_data *d)
 594 {
 595         DATA_BLOB blob;
 596         enum ndr_err_code ndr_err;
 597
 598         if (DEBUGLEVEL >= 10) {
 599                 DEBUG(10, ("unparse_share_modes:\n"));
 600                 NDR_PRINT_DEBUG(share_mode_data, d);
 601         }
 602
 603         if (d->num_share_modes == 0) {
 604                 DEBUG(10, ("No used share mode found\n"));
 605                 return make_tdb_data(NULL, 0);
 606         }
 607
 608         ndr_err = ndr_push_struct_blob(
 609                 &blob, d, d, (ndr_push_flags_fn_t)ndr_push_share_mode_data);
 610         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 611                 smb_panic("ndr_push_share_mode_lock failed");
 612         }
 613
 614         return make_tdb_data(blob.data, blob.length);
 615 }
 616
 617 static int share_mode_data_destructor(struct share_mode_data *d)
 618 {
 619         NTSTATUS status;
 620         TDB_DATA data;
 621
 622         if (!d->modified) {
 623                 return 0;
 624         }
 625
 626         data = unparse_share_modes(d);
 627
 628         if (data.dptr == NULL) {
 629                 if (!d->fresh) {
 630                         /* There has been an entry before, delete it */
 631
 632                         status = dbwrap_record_delete(d->record);
 633                         if (!NT_STATUS_IS_OK(status)) {
 634                                 char *errmsg;
 635
 636                                 DEBUG(0, ("delete_rec returned %s\n",
 637                                           nt_errstr(status)));
 638
 639                                 if (asprintf(&errmsg, "could not delete share "
 640                                              "entry: %s\n",
 641                                              nt_errstr(status)) == -1) {
 642                                         smb_panic("could not delete share"
 643                                                   "entry");
 644                                 }
 645                                 smb_panic(errmsg);
 646                         }
 647                 }
 648                 goto done;
 649         }
 650
 651         status = dbwrap_record_store(d->record, data, TDB_REPLACE);
 652         if (!NT_STATUS_IS_OK(status)) {
 653                 char *errmsg;
 654
 655                 DEBUG(0, ("store returned %s\n", nt_errstr(status)));
 656
 657                 if (asprintf(&errmsg, "could not store share mode entry: %s",
 658                              nt_errstr(status)) == -1) {
 659                         smb_panic("could not store share mode entry");
 660                 }
 661                 smb_panic(errmsg);
 662         }
 663
 664  done:
 665
 666         return 0;
 667 }
 668
 669 static struct share_mode_data *fresh_share_mode_lock(
 670         TALLOC_CTX *mem_ctx, const char *servicepath,
 671         const struct smb_filename *smb_fname,
 672         const struct timespec *old_write_time)
 673 {
 674         struct share_mode_data *d;
 675
 676         if ((servicepath == NULL) || (smb_fname == NULL) ||
 677             (old_write_time == NULL)) {
 678                 return NULL;
 679         }
 680
 681         d = talloc_zero(mem_ctx, struct share_mode_data);
 682         if (d == NULL) {
 683                 goto fail;
 684         }
 685         d->base_name = talloc_strdup(d, smb_fname->base_name);
 686         if (d->base_name == NULL) {
 687                 goto fail;
 688         }
 689         if (smb_fname->stream_name != NULL) {
 690                 d->stream_name = talloc_strdup(d, smb_fname->stream_name);
 691                 if (d->stream_name == NULL) {
 692                         goto fail;
 693                 }
 694         }
 695         d->servicepath = talloc_strdup(d, servicepath);
 696         if (d->servicepath == NULL) {
 697                 goto fail;
 698         }
 699         d->old_write_time = *old_write_time;
 700         d->modified = false;
 701         d->fresh = true;
 702         return d;
 703 fail:
 704         DEBUG(0, ("talloc failed\n"));
 705         TALLOC_FREE(d);
 706         return NULL;
 707 }
 708
 709 struct share_mode_lock *get_share_mode_lock_fresh(TALLOC_CTX *mem_ctx,
 710                                                   const struct file_id id,
 711                                                   const char *servicepath,
 712                                                   const struct smb_filename *smb_fname,
 713                                                   const struct timespec *old_write_time)
 714 {
 715         struct share_mode_lock *lck;
 716         struct share_mode_data *d;
 717         struct file_id tmp;
 718         struct db_record *rec;
 719         TDB_DATA key = locking_key(&id, &tmp);
 720         TDB_DATA value;
 721
 722         rec = dbwrap_fetch_locked(lock_db, mem_ctx, key);
 723         if (rec == NULL) {
 724                 DEBUG(3, ("Could not lock share entry\n"));
 725                 return NULL;
 726         }
 727
 728         value = dbwrap_record_get_value(rec);
 729
 730         if (value.dptr == NULL) {
 731                 d = fresh_share_mode_lock(mem_ctx, servicepath, smb_fname,
 732                                           old_write_time);
 733         } else {
 734                 d = parse_share_modes(mem_ctx, value);
 735         }
 736
 737         if (d == NULL) {
 738                 DEBUG(1, ("Could not get share mode lock\n"));
 739                 TALLOC_FREE(rec);
 740                 return NULL;
 741         }
 742         d->id = id;
 743         d->record = talloc_move(d, &rec);
 744         talloc_set_destructor(d, share_mode_data_destructor);
 745
 746         lck = talloc(mem_ctx, struct share_mode_lock);
 747         if (lck == NULL) {
 748                 DEBUG(1, ("talloc failed\n"));
 749                 TALLOC_FREE(d);
 750                 return NULL;
 751         }
 752         lck->data = talloc_move(lck, &d);
 753         return lck;
 754 }
 755
 756 struct share_mode_lock *get_share_mode_lock(TALLOC_CTX *mem_ctx,
 757                                             const struct file_id id)
 758 {
 759         return get_share_mode_lock_fresh(mem_ctx, id, NULL, NULL, NULL);
 760 }
 761
 762 struct share_mode_lock *fetch_share_mode_unlocked(TALLOC_CTX *mem_ctx,
 763                                                   const struct file_id id)
 764 {
 765         struct share_mode_lock *lck;
 766         struct file_id tmp;
 767         TDB_DATA key = locking_key(&id, &tmp);
 768         TDB_DATA data;
 769         NTSTATUS status;
 770
 771         status = dbwrap_fetch(lock_db, talloc_tos(), key, &data);
 772         if (!NT_STATUS_IS_OK(status)) {
 773                 DEBUG(3, ("Could not fetch share entry\n"));
 774                 return NULL;
 775         }
 776         if (data.dptr == NULL) {
 777                 return NULL;
 778         }
 779         lck = talloc(mem_ctx, struct share_mode_lock);
 780         if (lck == NULL) {
 781                 TALLOC_FREE(data.dptr);
 782                 return NULL;
 783         }
 784         lck->data = parse_share_modes(mem_ctx, data);
 785         TALLOC_FREE(data.dptr);
 786         if (lck->data == NULL) {
 787                 TALLOC_FREE(lck);
 788                 return NULL;
 789         }
 790         return lck;
 791 }
 792
 793 /*******************************************************************
 794  Sets the service name and filename for rename.
 795  At this point we emit "file renamed" messages to all
 796  process id's that have this file open.
 797  Based on an initial code idea from SATOH Fumiyasu <fumiya@samba.gr.jp>
 798 ********************************************************************/
 799
 800 bool rename_share_filename(struct messaging_context *msg_ctx,
 801                         struct share_mode_lock *lck,
 802                         const char *servicepath,
 803                         uint32_t orig_name_hash,
 804                         uint32_t new_name_hash,
 805                         const struct smb_filename *smb_fname_dst)
 806 {
 807         struct share_mode_data *d = lck->data;
 808         size_t sp_len;
 809         size_t bn_len;
 810         size_t sn_len;
 811         size_t msg_len;
 812         char *frm = NULL;
 813         int i;
 814         bool strip_two_chars = false;
 815         bool has_stream = smb_fname_dst->stream_name != NULL;
 816
 817         DEBUG(10, ("rename_share_filename: servicepath %s newname %s\n",
 818                    servicepath, smb_fname_dst->base_name));
 819
 820         /*
 821          * rename_internal_fsp() and rename_internals() add './' to
 822          * head of newname if newname does not contain a '/'.
 823          */
 824         if (smb_fname_dst->base_name[0] &&
 825             smb_fname_dst->base_name[1] &&
 826             smb_fname_dst->base_name[0] == '.' &&
 827             smb_fname_dst->base_name[1] == '/') {
 828                 strip_two_chars = true;
 829         }
 830
 831         d->servicepath = talloc_strdup(d, servicepath);
 832         d->base_name = talloc_strdup(d, smb_fname_dst->base_name +
 833                                        (strip_two_chars ? 2 : 0));
 834         d->stream_name = talloc_strdup(d, smb_fname_dst->stream_name);
 835         if (d->base_name == NULL ||
 836             (has_stream && d->stream_name == NULL) ||
 837             d->servicepath == NULL) {
 838                 DEBUG(0, ("rename_share_filename: talloc failed\n"));
 839                 return False;
 840         }
 841         d->modified = True;
 842
 843         sp_len = strlen(d->servicepath);
 844         bn_len = strlen(d->base_name);
 845         sn_len = has_stream ? strlen(d->stream_name) : 0;
 846
 847         msg_len = MSG_FILE_RENAMED_MIN_SIZE + sp_len + 1 + bn_len + 1 +
 848             sn_len + 1;
 849
 850         /* Set up the name changed message. */
 851         frm = talloc_array(d, char, msg_len);
 852         if (!frm) {
 853                 return False;
 854         }
 855
 856         push_file_id_24(frm, &d->id);
 857
 858         DEBUG(10,("rename_share_filename: msg_len = %u\n", (unsigned int)msg_len ));
 859
 860         strlcpy(&frm[24],
 861                 d->servicepath ? d->servicepath : "",
 862                 sp_len+1);
 863         strlcpy(&frm[24 + sp_len + 1],
 864                 d->base_name ? d->base_name : "",
 865                 bn_len+1);
 866         strlcpy(&frm[24 + sp_len + 1 + bn_len + 1],
 867                 d->stream_name ? d->stream_name : "",
 868                 sn_len+1);
 869
 870         /* Send the messages. */
 871         for (i=0; i<d->num_share_modes; i++) {
 872                 struct share_mode_entry *se = &d->share_modes[i];
 873                 if (!is_valid_share_mode_entry(se)) {
 874                         continue;
 875                 }
 876
 877                 /* If this is a hardlink to the inode
 878                    with a different name, skip this. */
 879                 if (se->name_hash != orig_name_hash) {
 880                         continue;
 881                 }
 882
 883                 se->name_hash = new_name_hash;
 884
 885                 /* But not to ourselves... */
 886                 if (procid_is_me(&se->pid)) {
 887                         continue;
 888                 }
 889
 890                 DEBUG(10,("rename_share_filename: sending rename message to "
 891                           "pid %s file_id %s sharepath %s base_name %s "
 892                           "stream_name %s\n",
 893                           procid_str_static(&se->pid),
 894                           file_id_string_tos(&d->id),
 895                           d->servicepath, d->base_name,
 896                         has_stream ? d->stream_name : ""));
 897
 898                 messaging_send_buf(msg_ctx, se->pid, MSG_SMB_FILE_RENAME,
 899                                    (uint8 *)frm, msg_len);
 900         }
 901
 902         return True;
 903 }
 904
 905 void get_file_infos(struct file_id id,
 906                     uint32_t name_hash,
 907                     bool *delete_on_close,
 908                     struct timespec *write_time)
 909 {
 910         struct share_mode_lock *lck;
 911
 912         if (delete_on_close) {
 913                 *delete_on_close = false;
 914         }
 915
 916         if (write_time) {
 917                 ZERO_STRUCTP(write_time);
 918         }
 919
 920         if (!(lck = fetch_share_mode_unlocked(talloc_tos(), id))) {
 921                 return;
 922         }
 923
 924         if (delete_on_close) {
 925                 *delete_on_close = is_delete_on_close_set(lck, name_hash);
 926         }
 927
 928         if (write_time) {
 929                 struct timespec wt;
 930
 931                 wt = lck->data->changed_write_time;
 932                 if (null_timespec(wt)) {
 933                         wt = lck->data->old_write_time;
 934                 }
 935
 936                 *write_time = wt;
 937         }
 938
 939         TALLOC_FREE(lck);
 940 }
 941
 942 bool is_valid_share_mode_entry(const struct share_mode_entry *e)
 943 {
 944         int num_props = 0;
 945
 946         num_props += ((e->op_type == NO_OPLOCK) ? 1 : 0);
 947         num_props += (EXCLUSIVE_OPLOCK_TYPE(e->op_type) ? 1 : 0);
 948         num_props += (LEVEL_II_OPLOCK_TYPE(e->op_type) ? 1 : 0);
 949
 950         SMB_ASSERT(num_props <= 1);
 951         return (num_props != 0);
 952 }
 953
 954 bool is_deferred_open_entry(const struct share_mode_entry *e)
 955 {
 956         return (e->op_type == DEFERRED_OPEN_ENTRY);
 957 }
 958
 959 /*******************************************************************
 960  Fill a share mode entry.
 961 ********************************************************************/
 962
 963 static void fill_share_mode_entry(struct share_mode_entry *e,
 964                                   files_struct *fsp,
 965                                   uid_t uid, uint64_t mid, uint16 op_type)
 966 {
 967         ZERO_STRUCTP(e);
 968         e->pid = messaging_server_id(fsp->conn->sconn->msg_ctx);
 969         e->share_access = fsp->share_access;
 970         e->private_options = fsp->fh->private_options;
 971         e->access_mask = fsp->access_mask;
 972         e->op_mid = mid;
 973         e->op_type = op_type;
 974         e->time.tv_sec = fsp->open_time.tv_sec;
 975         e->time.tv_usec = fsp->open_time.tv_usec;
 976         e->id = fsp->file_id;
 977         e->share_file_id = fsp->fh->gen_id;
 978         e->uid = (uint32)uid;
 979         e->flags = fsp->posix_open ? SHARE_MODE_FLAG_POSIX_OPEN : 0;
 980         e->name_hash = fsp->name_hash;
 981 }
 982
 983 static void fill_deferred_open_entry(struct share_mode_entry *e,
 984                                      const struct timeval request_time,
 985                                      struct file_id id,
 986                                      struct server_id pid,
 987                                      uint64_t mid)
 988 {
 989         ZERO_STRUCTP(e);
 990         e->pid = pid;
 991         e->op_mid = mid;
 992         e->op_type = DEFERRED_OPEN_ENTRY;
 993         e->time.tv_sec = request_time.tv_sec;
 994         e->time.tv_usec = request_time.tv_usec;
 995         e->id = id;
 996         e->uid = (uint32)-1;
 997         e->flags = 0;
 998 }
 999
1000 static void add_share_mode_entry(struct share_mode_data *d,
1001                                  const struct share_mode_entry *entry)
1002 {
1003         ADD_TO_ARRAY(d, struct share_mode_entry, *entry,
1004                      &d->share_modes, &d->num_share_modes);
1005         d->modified = True;
1006 }
1007
1008 void set_share_mode(struct share_mode_lock *lck, files_struct *fsp,
1009                     uid_t uid, uint64_t mid, uint16 op_type)
1010 {
1011         struct share_mode_entry entry;
1012         fill_share_mode_entry(&entry, fsp, uid, mid, op_type);
1013         add_share_mode_entry(lck->data, &entry);
1014 }
1015
1016 void add_deferred_open(struct share_mode_lock *lck, uint64_t mid,
1017                        struct timeval request_time,
1018                        struct server_id pid, struct file_id id)
1019 {
1020         struct share_mode_entry entry;
1021         fill_deferred_open_entry(&entry, request_time, id, pid, mid);
1022         add_share_mode_entry(lck->data, &entry);
1023 }
1024
1025 /*******************************************************************
1026  Check if two share mode entries are identical, ignoring oplock
1027  and mid info and desired_access. (Removed paranoia test - it's
1028  not automatically a logic error if they are identical. JRA.)
1029 ********************************************************************/
1030
1031 static bool share_modes_identical(struct share_mode_entry *e1,
1032                                   struct share_mode_entry *e2)
1033 {
1034         /* We used to check for e1->share_access == e2->share_access here
1035            as well as the other fields but 2 different DOS or FCB opens
1036            sharing the same share mode entry may validly differ in
1037            fsp->share_access field. */
1038
1039         return (procid_equal(&e1->pid, &e2->pid) &&
1040                 file_id_equal(&e1->id, &e2->id) &&
1041                 e1->share_file_id == e2->share_file_id );
1042 }
1043
1044 static bool deferred_open_identical(struct share_mode_entry *e1,
1045                                     struct share_mode_entry *e2)
1046 {
1047         return (procid_equal(&e1->pid, &e2->pid) &&
1048                 (e1->op_mid == e2->op_mid) &&
1049                 file_id_equal(&e1->id, &e2->id));
1050 }
1051
1052 static struct share_mode_entry *find_share_mode_entry(struct share_mode_data *d,
1053                                                       struct share_mode_entry *entry)
1054 {
1055         int i;
1056
1057         for (i=0; i<d->num_share_modes; i++) {
1058                 struct share_mode_entry *e = &d->share_modes[i];
1059                 if (is_valid_share_mode_entry(entry) &&
1060                     is_valid_share_mode_entry(e) &&
1061                     share_modes_identical(e, entry)) {
1062                         return e;
1063                 }
1064                 if (is_deferred_open_entry(entry) &&
1065                     is_deferred_open_entry(e) &&
1066                     deferred_open_identical(e, entry)) {
1067                         return e;
1068                 }
1069         }
1070         return NULL;
1071 }
1072
1073 /*******************************************************************
1074  Del the share mode of a file for this process. Return the number of
1075  entries left.
1076 ********************************************************************/
1077
1078 bool del_share_mode(struct share_mode_lock *lck, files_struct *fsp)
1079 {
1080         struct share_mode_entry entry, *e;
1081
1082         /* Don't care about the pid owner being correct here - just a search. */
1083         fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
1084
1085         e = find_share_mode_entry(lck->data, &entry);
1086         if (e == NULL) {
1087                 return False;
1088         }
1089         *e = lck->data->share_modes[lck->data->num_share_modes-1];
1090         lck->data->num_share_modes -= 1;
1091         lck->data->modified = True;
1092         return True;
1093 }
1094
1095 void del_deferred_open_entry(struct share_mode_lock *lck, uint64_t mid,
1096                              struct server_id pid)
1097 {
1098         struct share_mode_entry entry, *e;
1099
1100         fill_deferred_open_entry(&entry, timeval_zero(),
1101                                  lck->data->id, pid, mid);
1102
1103         e = find_share_mode_entry(lck->data, &entry);
1104         if (e == NULL) {
1105                 return;
1106         }
1107         *e = lck->data->share_modes[lck->data->num_share_modes-1];
1108         lck->data->num_share_modes -= 1;
1109         lck->data->modified = True;
1110 }
1111
1112 /*******************************************************************
1113  Remove an oplock mid and mode entry from a share mode.
1114 ********************************************************************/
1115
1116 bool remove_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
1117 {
1118         struct share_mode_entry entry, *e;
1119
1120         /* Don't care about the pid owner being correct here - just a search. */
1121         fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
1122
1123         e = find_share_mode_entry(lck->data, &entry);
1124         if (e == NULL) {
1125                 return False;
1126         }
1127
1128         if (EXCLUSIVE_OPLOCK_TYPE(e->op_type)) {
1129                 /*
1130                  * Going from exclusive or batch,
1131                  * we always go through FAKE_LEVEL_II
1132                  * first.
1133                  */
1134                 if (!EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) {
1135                         smb_panic("remove_share_oplock: logic error");
1136                 }
1137                 e->op_type = FAKE_LEVEL_II_OPLOCK;
1138         } else {
1139                 e->op_type = NO_OPLOCK;
1140         }
1141         lck->data->modified = True;
1142         return True;
1143 }
1144
1145 /*******************************************************************
1146  Downgrade a oplock type from exclusive to level II.
1147 ********************************************************************/
1148
1149 bool downgrade_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
1150 {
1151         struct share_mode_entry entry, *e;
1152
1153         /* Don't care about the pid owner being correct here - just a search. */
1154         fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
1155
1156         e = find_share_mode_entry(lck->data, &entry);
1157         if (e == NULL) {
1158                 return False;
1159         }
1160
1161         e->op_type = LEVEL_II_OPLOCK;
1162         lck->data->modified = True;
1163         return True;
1164 }
1165
1166 /*************************************************************************
1167  Return a talloced copy of a struct security_unix_token. NULL on fail.
1168  (Should this be in locking.c.... ?).
1169 *************************************************************************/
1170
1171 static struct security_unix_token *copy_unix_token(TALLOC_CTX *ctx, const struct security_unix_token *tok)
1172 {
1173         struct security_unix_token *cpy;
1174
1175         cpy = talloc(ctx, struct security_unix_token);
1176         if (!cpy) {
1177                 return NULL;
1178         }
1179
1180         cpy->uid = tok->uid;
1181         cpy->gid = tok->gid;
1182         cpy->ngroups = tok->ngroups;
1183         if (tok->ngroups) {
1184                 /* Make this a talloc child of cpy. */
1185                 cpy->groups = (gid_t *)talloc_memdup(
1186                         cpy, tok->groups, tok->ngroups * sizeof(gid_t));
1187                 if (!cpy->groups) {
1188                         TALLOC_FREE(cpy);
1189                         return NULL;
1190                 }
1191         }
1192         return cpy;
1193 }
1194
1195 /****************************************************************************
1196  Adds a delete on close token.
1197 ****************************************************************************/
1198
1199 static bool add_delete_on_close_token(struct share_mode_data *d,
1200                         uint32_t name_hash,
1201                         const struct security_unix_token *tok)
1202 {
1203         struct delete_token *tmp, *dtl;
1204
1205         tmp = talloc_realloc(d, d->delete_tokens, struct delete_token,
1206                              d->num_delete_tokens+1);
1207         if (tmp == NULL) {
1208                 return false;
1209         }
1210         d->delete_tokens = tmp;
1211         dtl = &d->delete_tokens[d->num_delete_tokens];
1212
1213         dtl->name_hash = name_hash;
1214         dtl->delete_token = copy_unix_token(d->delete_tokens, tok);
1215         if (dtl->delete_token == NULL) {
1216                 return false;
1217         }
1218         d->num_delete_tokens += 1;
1219         d->modified = true;
1220         return true;
1221 }
1222
1223 /****************************************************************************
1224  Sets the delete on close flag over all share modes on this file.
1225  Modify the share mode entry for all files open
1226  on this device and inode to tell other smbds we have
1227  changed the delete on close flag. This will be noticed
1228  in the close code, the last closer will delete the file
1229  if flag is set.
1230  This makes a copy of any struct security_unix_token into the
1231  lck entry. This function is used when the lock is already granted.
1232 ****************************************************************************/
1233
1234 void set_delete_on_close_lck(files_struct *fsp,
1235                         struct share_mode_lock *lck,
1236                         bool delete_on_close,
1237                         const struct security_unix_token *tok)
1238 {
1239         struct share_mode_data *d = lck->data;
1240         int i;
1241         bool ret;
1242
1243         if (delete_on_close) {
1244                 SMB_ASSERT(tok != NULL);
1245         } else {
1246                 SMB_ASSERT(tok == NULL);
1247         }
1248
1249         for (i=0; i<d->num_delete_tokens; i++) {
1250                 struct delete_token *dt = &d->delete_tokens[i];
1251                 if (dt->name_hash == fsp->name_hash) {
1252                         d->modified = true;
1253                         if (delete_on_close == false) {
1254                                 /* Delete this entry. */
1255                                 TALLOC_FREE(dt->delete_token);
1256                                 *dt = d->delete_tokens[
1257                                         d->num_delete_tokens-1];
1258                                 d->num_delete_tokens -= 1;
1259                                 return;
1260                         }
1261                         /* Replace this token with the
1262                            given tok. */
1263                         TALLOC_FREE(dt->delete_token);
1264                         dt->delete_token = copy_unix_token(dt, tok);
1265                         SMB_ASSERT(dt->delete_token != NULL);
1266                 }
1267         }
1268
1269         if (!delete_on_close) {
1270                 /* Nothing to delete - not found. */
1271                 return;
1272         }
1273
1274         ret = add_delete_on_close_token(lck->data, fsp->name_hash, tok);
1275         SMB_ASSERT(ret);
1276 }
1277
1278 bool set_delete_on_close(files_struct *fsp, bool delete_on_close, const struct security_unix_token *tok)
1279 {
1280         struct share_mode_lock *lck;
1281
1282         DEBUG(10,("set_delete_on_close: %s delete on close flag for "
1283                   "fnum = %d, file %s\n",
1284                   delete_on_close ? "Adding" : "Removing", fsp->fnum,
1285                   fsp_str_dbg(fsp)));
1286
1287         lck = get_share_mode_lock(talloc_tos(), fsp->file_id);
1288         if (lck == NULL) {
1289                 return False;
1290         }
1291
1292         set_delete_on_close_lck(fsp, lck, delete_on_close,
1293                         delete_on_close ? tok : NULL);
1294
1295         if (fsp->is_directory) {
1296                 SMB_ASSERT(!is_ntfs_stream_smb_fname(fsp->fsp_name));
1297                 send_stat_cache_delete_message(fsp->conn->sconn->msg_ctx,
1298                                                fsp->fsp_name->base_name);
1299         }
1300
1301         TALLOC_FREE(lck);
1302
1303         fsp->delete_on_close = delete_on_close;
1304
1305         return True;
1306 }
1307
1308 const struct security_unix_token *get_delete_on_close_token(struct share_mode_lock *lck, uint32_t name_hash)
1309 {
1310         int i;
1311
1312         DEBUG(10,("get_delete_on_close_token: name_hash = 0x%x\n",
1313                         (unsigned int)name_hash ));
1314
1315         for (i=0; i<lck->data->num_delete_tokens; i++) {
1316                 struct delete_token *dt = &lck->data->delete_tokens[i];
1317                 DEBUG(10,("get_delete_on_close_token: dtl->name_hash = 0x%x\n",
1318                                 (unsigned int)dt->name_hash ));
1319                 if (dt->name_hash == name_hash) {
1320                         return dt->delete_token;
1321                 }
1322         }
1323         return NULL;
1324 }
1325
1326 bool is_delete_on_close_set(struct share_mode_lock *lck, uint32_t name_hash)
1327 {
1328         return (get_delete_on_close_token(lck, name_hash) != NULL);
1329 }
1330
1331 bool set_sticky_write_time(struct file_id fileid, struct timespec write_time)
1332 {
1333         struct share_mode_lock *lck;
1334
1335         DEBUG(5,("set_sticky_write_time: %s id=%s\n",
1336                  timestring(talloc_tos(),
1337                             convert_timespec_to_time_t(write_time)),
1338                  file_id_string_tos(&fileid)));
1339
1340         lck = get_share_mode_lock(talloc_tos(), fileid);
1341         if (lck == NULL) {
1342                 return False;
1343         }
1344
1345         if (timespec_compare(&lck->data->changed_write_time, &write_time) != 0) {
1346                 lck->data->modified = True;
1347                 lck->data->changed_write_time = write_time;
1348         }
1349
1350         TALLOC_FREE(lck);
1351         return True;
1352 }
1353
1354 bool set_write_time(struct file_id fileid, struct timespec write_time)
1355 {
1356         struct share_mode_lock *lck;
1357
1358         DEBUG(5,("set_write_time: %s id=%s\n",
1359                  timestring(talloc_tos(),
1360                             convert_timespec_to_time_t(write_time)),
1361                  file_id_string_tos(&fileid)));
1362
1363         lck = get_share_mode_lock(talloc_tos(), fileid);
1364         if (lck == NULL) {
1365                 return False;
1366         }
1367
1368         if (timespec_compare(&lck->data->old_write_time, &write_time) != 0) {
1369                 lck->data->modified = True;
1370                 lck->data->old_write_time = write_time;
1371         }
1372
1373         TALLOC_FREE(lck);
1374         return True;
1375 }
1376
1377
1378 struct forall_state {
1379         void (*fn)(const struct share_mode_entry *entry,
1380                    const char *sharepath,
1381                    const char *fname,
1382                    void *private_data);
1383         void *private_data;
1384 };
1385
1386 static int traverse_fn(struct db_record *rec, void *_state)
1387 {
1388         struct forall_state *state = (struct forall_state *)_state;
1389         uint32_t i;
1390         TDB_DATA key;
1391         TDB_DATA value;
1392         DATA_BLOB blob;
1393         enum ndr_err_code ndr_err;
1394         struct share_mode_data *d;
1395
1396         key = dbwrap_record_get_key(rec);
1397         value = dbwrap_record_get_value(rec);
1398
1399         /* Ensure this is a locking_key record. */
1400         if (key.dsize != sizeof(struct file_id))
1401                 return 0;
1402
1403         d = talloc(talloc_tos(), struct share_mode_data);
1404         if (d == NULL) {
1405                 return 0;
1406         }
1407
1408         blob.data = value.dptr;
1409         blob.length = value.dsize;
1410
1411         ndr_err = ndr_pull_struct_blob(
1412                 &blob, d, d, (ndr_pull_flags_fn_t)ndr_pull_share_mode_data);
1413         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1414                 DEBUG(1, ("ndr_pull_share_mode_lock failed\n"));
1415                 return 0;
1416         }
1417         for (i=0; i<d->num_share_modes; i++) {
1418                 state->fn(&d->share_modes[i],
1419                           d->servicepath, d->base_name,
1420                           state->private_data);
1421         }
1422         TALLOC_FREE(d);
1423
1424         return 0;
1425 }
1426
1427 /*******************************************************************
1428  Call the specified function on each entry under management by the
1429  share mode system.
1430 ********************************************************************/
1431
1432 int share_mode_forall(void (*fn)(const struct share_mode_entry *, const char *,
1433                                  const char *, void *),
1434                       void *private_data)
1435 {
1436         struct forall_state state;
1437         NTSTATUS status;
1438         int count;
1439
1440         if (lock_db == NULL)
1441                 return 0;
1442
1443         state.fn = fn;
1444         state.private_data = private_data;
1445
1446         status = dbwrap_traverse_read(lock_db, traverse_fn, (void *)&state,
1447                                       &count);
1448
1449         if (!NT_STATUS_IS_OK(status)) {
1450                 return -1;
1451         } else {
1452                 return count;
1453         }
1454 }