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