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    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(NULL, 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(NULL, 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(NULL, 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(NULL, 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(NULL, 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(NULL, 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(NULL,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 int open_read_only;
 389
 390 bool locking_init(int read_only)
 391 {
 392         brl_init(read_only);
 393
 394         if (lock_db)
 395                 return True;
 396
 397         lock_db = db_open(NULL, lock_path("locking.tdb"), 0,
 398                           TDB_DEFAULT
 399                           |TDB_VOLATILE
 400                           |(read_only?0x0:TDB_CLEAR_IF_FIRST),
 401                           read_only?O_RDONLY:O_RDWR|O_CREAT, 0644);
 402
 403         if (!lock_db) {
 404                 DEBUG(0,("ERROR: Failed to initialise locking database\n"));
 405                 return False;
 406         }
 407
 408         if (!posix_locking_init(read_only))
 409                 return False;
 410
 411         open_read_only = read_only;
 412
 413         return True;
 414 }
 415
 416 /*******************************************************************
 417  Deinitialize the share_mode management.
 418 ******************************************************************/
 419
 420 bool locking_end(void)
 421 {
 422         brl_shutdown(open_read_only);
 423         if (lock_db) {
 424                 TALLOC_FREE(lock_db);
 425         }
 426         return True;
 427 }
 428
 429 /*******************************************************************
 430  Form a static locking key for a dev/inode pair.
 431 ******************************************************************/
 432
 433 static TDB_DATA locking_key(struct file_id id)
 434 {
 435         static struct file_id key;
 436         TDB_DATA kbuf;
 437         key = id;
 438         kbuf.dptr = (uint8 *)&key;
 439         kbuf.dsize = sizeof(key);
 440         return kbuf;
 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 = talloc_strdup(lck, (const char *)dbuf.dptr + sizeof(*data) +
 589                                         (lck->num_share_modes *
 590                                         sizeof(struct share_mode_entry)) +
 591                                         data->u.s.delete_token_size );
 592         if (lck->servicepath == NULL) {
 593                 smb_panic("parse_share_modes: talloc_strdup failed");
 594         }
 595
 596         lck->filename = talloc_strdup(lck, (const char *)dbuf.dptr + sizeof(*data) +
 597                                         (lck->num_share_modes *
 598                                         sizeof(struct share_mode_entry)) +
 599                                         data->u.s.delete_token_size +
 600                                         strlen(lck->servicepath) + 1 );
 601         if (lck->filename == NULL) {
 602                 smb_panic("parse_share_modes: talloc_strdup failed");
 603         }
 604
 605         /*
 606          * Ensure that each entry has a real process attached.
 607          */
 608
 609         for (i = 0; i < lck->num_share_modes; i++) {
 610                 struct share_mode_entry *entry_p = &lck->share_modes[i];
 611                 char *str = share_mode_str(NULL, i, entry_p);
 612                 DEBUG(10,("parse_share_modes: %s\n",
 613                         str ? str : ""));
 614                 if (!process_exists(entry_p->pid)) {
 615                         DEBUG(10,("parse_share_modes: deleted %s\n",
 616                                 str ? str : ""));
 617                         entry_p->op_type = UNUSED_SHARE_MODE_ENTRY;
 618                         lck->modified = True;
 619                 }
 620                 TALLOC_FREE(str);
 621         }
 622
 623         return True;
 624 }
 625
 626 static TDB_DATA unparse_share_modes(struct share_mode_lock *lck)
 627 {
 628         TDB_DATA result;
 629         int num_valid = 0;
 630         int i;
 631         struct locking_data *data;
 632         ssize_t offset;
 633         ssize_t sp_len;
 634         uint32 delete_token_size;
 635
 636         result.dptr = NULL;
 637         result.dsize = 0;
 638
 639         for (i=0; i<lck->num_share_modes; i++) {
 640                 if (!is_unused_share_mode_entry(&lck->share_modes[i])) {
 641                         num_valid += 1;
 642                 }
 643         }
 644
 645         if (num_valid == 0) {
 646                 return result;
 647         }
 648
 649         sp_len = strlen(lck->servicepath);
 650         delete_token_size = (lck->delete_token ?
 651                         (sizeof(uid_t) + sizeof(gid_t) + (lck->delete_token->ngroups*sizeof(gid_t))) : 0);
 652
 653         result.dsize = sizeof(*data) +
 654                 lck->num_share_modes * sizeof(struct share_mode_entry) +
 655                 delete_token_size +
 656                 sp_len + 1 +
 657                 strlen(lck->filename) + 1;
 658         result.dptr = TALLOC_ARRAY(lck, uint8, result.dsize);
 659
 660         if (result.dptr == NULL) {
 661                 smb_panic("talloc failed");
 662         }
 663
 664         data = (struct locking_data *)result.dptr;
 665         ZERO_STRUCTP(data);
 666         data->u.s.num_share_mode_entries = lck->num_share_modes;
 667         data->u.s.delete_on_close = lck->delete_on_close;
 668         data->u.s.delete_token_size = delete_token_size;
 669         DEBUG(10, ("unparse_share_modes: del: %d, tok = %u, num: %d\n",
 670                 data->u.s.delete_on_close,
 671                 (unsigned int)data->u.s.delete_token_size,
 672                 data->u.s.num_share_mode_entries));
 673         memcpy(result.dptr + sizeof(*data), lck->share_modes,
 674                sizeof(struct share_mode_entry)*lck->num_share_modes);
 675         offset = sizeof(*data) +
 676                 sizeof(struct share_mode_entry)*lck->num_share_modes;
 677
 678         /* Store any delete on close token. */
 679         if (lck->delete_token) {
 680                 uint8 *p = result.dptr + offset;
 681
 682                 memcpy(p, &lck->delete_token->uid, sizeof(uid_t));
 683                 p += sizeof(uid_t);
 684
 685                 memcpy(p, &lck->delete_token->gid, sizeof(gid_t));
 686                 p += sizeof(gid_t);
 687
 688                 for (i = 0; i < lck->delete_token->ngroups; i++) {
 689                         memcpy(p, &lck->delete_token->groups[i], sizeof(gid_t));
 690                         p += sizeof(gid_t);
 691                 }
 692                 offset = p - result.dptr;
 693         }
 694
 695         safe_strcpy((char *)result.dptr + offset, lck->servicepath,
 696                     result.dsize - offset - 1);
 697         offset += sp_len + 1;
 698         safe_strcpy((char *)result.dptr + offset, lck->filename,
 699                     result.dsize - offset - 1);
 700
 701         if (DEBUGLEVEL >= 10) {
 702                 print_share_mode_table(data);
 703         }
 704
 705         return result;
 706 }
 707
 708 static int share_mode_lock_destructor(struct share_mode_lock *lck)
 709 {
 710         NTSTATUS status;
 711         TDB_DATA data;
 712
 713         if (!lck->modified) {
 714                 return 0;
 715         }
 716
 717         data = unparse_share_modes(lck);
 718
 719         if (data.dptr == NULL) {
 720                 if (!lck->fresh) {
 721                         /* There has been an entry before, delete it */
 722
 723                         status = lck->record->delete_rec(lck->record);
 724                         if (!NT_STATUS_IS_OK(status)) {
 725                                 DEBUG(0, ("delete_rec returned %s\n",
 726                                           nt_errstr(status)));
 727                                 smb_panic("could not delete share entry");
 728                         }
 729                 }
 730                 goto done;
 731         }
 732
 733         status = lck->record->store(lck->record, data, TDB_REPLACE);
 734         if (!NT_STATUS_IS_OK(status)) {
 735                 DEBUG(0, ("store returned %s\n", nt_errstr(status)));
 736                 smb_panic("could not store share mode entry");
 737         }
 738
 739  done:
 740
 741         return 0;
 742 }
 743
 744 static bool fill_share_mode_lock(struct share_mode_lock *lck,
 745                                  struct file_id id,
 746                                  const char *servicepath,
 747                                  const char *fname,
 748                                  TDB_DATA share_mode_data)
 749 {
 750         /* Ensure we set every field here as the destructor must be
 751            valid even if parse_share_modes fails. */
 752
 753         lck->servicepath = NULL;
 754         lck->filename = NULL;
 755         lck->id = id;
 756         lck->num_share_modes = 0;
 757         lck->share_modes = NULL;
 758         lck->delete_token = NULL;
 759         lck->delete_on_close = False;
 760         lck->fresh = False;
 761         lck->modified = False;
 762
 763         lck->fresh = (share_mode_data.dptr == NULL);
 764
 765         if (lck->fresh) {
 766                 if (fname == NULL || servicepath == NULL) {
 767                         return False;
 768                 }
 769                 lck->filename = talloc_strdup(lck, fname);
 770                 lck->servicepath = talloc_strdup(lck, servicepath);
 771                 if (lck->filename == NULL || lck->servicepath == NULL) {
 772                         DEBUG(0, ("talloc failed\n"));
 773                         return False;
 774                 }
 775         } else {
 776                 if (!parse_share_modes(share_mode_data, lck)) {
 777                         DEBUG(0, ("Could not parse share modes\n"));
 778                         return False;
 779                 }
 780         }
 781
 782         return True;
 783 }
 784
 785 struct share_mode_lock *get_share_mode_lock(TALLOC_CTX *mem_ctx,
 786                                             struct file_id id,
 787                                             const char *servicepath,
 788                                             const char *fname)
 789 {
 790         struct share_mode_lock *lck;
 791         TDB_DATA key = locking_key(id);
 792
 793         if (!(lck = TALLOC_P(mem_ctx, struct share_mode_lock))) {
 794                 DEBUG(0, ("talloc failed\n"));
 795                 return NULL;
 796         }
 797
 798         if (!(lck->record = lock_db->fetch_locked(lock_db, lck, key))) {
 799                 DEBUG(3, ("Could not lock share entry\n"));
 800                 TALLOC_FREE(lck);
 801                 return NULL;
 802         }
 803
 804         if (!fill_share_mode_lock(lck, id, servicepath, fname,
 805                                   lck->record->value)) {
 806                 DEBUG(3, ("fill_share_mode_lock failed\n"));
 807                 TALLOC_FREE(lck);
 808                 return NULL;
 809         }
 810
 811         talloc_set_destructor(lck, share_mode_lock_destructor);
 812
 813         return lck;
 814 }
 815
 816 struct share_mode_lock *fetch_share_mode_unlocked(TALLOC_CTX *mem_ctx,
 817                                                   struct file_id id,
 818                                                   const char *servicepath,
 819                                                   const char *fname)
 820 {
 821         struct share_mode_lock *lck;
 822         TDB_DATA key = locking_key(id);
 823         TDB_DATA data;
 824
 825         if (!(lck = TALLOC_P(mem_ctx, struct share_mode_lock))) {
 826                 DEBUG(0, ("talloc failed\n"));
 827                 return NULL;
 828         }
 829
 830         if (lock_db->fetch(lock_db, lck, key, &data) == -1) {
 831                 DEBUG(3, ("Could not fetch share entry\n"));
 832                 TALLOC_FREE(lck);
 833                 return NULL;
 834         }
 835
 836         if (!fill_share_mode_lock(lck, id, servicepath, fname, data)) {
 837                 DEBUG(3, ("fill_share_mode_lock failed\n"));
 838                 TALLOC_FREE(lck);
 839                 return NULL;
 840         }
 841
 842         TALLOC_FREE(data.dptr);
 843
 844         return lck;
 845 }
 846
 847 /*******************************************************************
 848  Sets the service name and filename for rename.
 849  At this point we emit "file renamed" messages to all
 850  process id's that have this file open.
 851  Based on an initial code idea from SATOH Fumiyasu <fumiya@samba.gr.jp>
 852 ********************************************************************/
 853
 854 bool rename_share_filename(struct messaging_context *msg_ctx,
 855                         struct share_mode_lock *lck,
 856                         const char *servicepath,
 857                         const char *newname)
 858 {
 859         size_t sp_len;
 860         size_t fn_len;
 861         size_t msg_len;
 862         char *frm = NULL;
 863         int i;
 864
 865         DEBUG(10, ("rename_share_filename: servicepath %s newname %s\n",
 866                 servicepath, newname));
 867
 868         /*
 869          * rename_internal_fsp() and rename_internals() add './' to
 870          * head of newname if newname does not contain a '/'.
 871          */
 872         while (newname[0] && newname[1] && newname[0] == '.' && newname[1] == '/') {
 873                 newname += 2;
 874         }
 875
 876         lck->servicepath = talloc_strdup(lck, servicepath);
 877         lck->filename = talloc_strdup(lck, newname);
 878         if (lck->filename == NULL || lck->servicepath == NULL) {
 879                 DEBUG(0, ("rename_share_filename: talloc failed\n"));
 880                 return False;
 881         }
 882         lck->modified = True;
 883
 884         sp_len = strlen(lck->servicepath);
 885         fn_len = strlen(lck->filename);
 886
 887         msg_len = MSG_FILE_RENAMED_MIN_SIZE + sp_len + 1 + fn_len + 1;
 888
 889         /* Set up the name changed message. */
 890         frm = TALLOC_ARRAY(lck, char, msg_len);
 891         if (!frm) {
 892                 return False;
 893         }
 894
 895         push_file_id_16(frm, &lck->id);
 896
 897         DEBUG(10,("rename_share_filename: msg_len = %u\n", (unsigned int)msg_len ));
 898
 899         safe_strcpy(&frm[16], lck->servicepath, sp_len);
 900         safe_strcpy(&frm[16 + sp_len + 1], lck->filename, fn_len);
 901
 902         /* Send the messages. */
 903         for (i=0; i<lck->num_share_modes; i++) {
 904                 struct share_mode_entry *se = &lck->share_modes[i];
 905                 if (!is_valid_share_mode_entry(se)) {
 906                         continue;
 907                 }
 908                 /* But not to ourselves... */
 909                 if (procid_is_me(&se->pid)) {
 910                         continue;
 911                 }
 912
 913                 DEBUG(10,("rename_share_filename: sending rename message to pid %s "
 914                           "file_id %s sharepath %s newname %s\n",
 915                           procid_str_static(&se->pid),
 916                           file_id_string_tos(&lck->id),
 917                           lck->servicepath, lck->filename ));
 918
 919                 messaging_send_buf(msg_ctx, se->pid, MSG_SMB_FILE_RENAME,
 920                                    (uint8 *)frm, msg_len);
 921         }
 922
 923         return True;
 924 }
 925
 926 bool get_delete_on_close_flag(struct file_id id)
 927 {
 928         bool result;
 929         struct share_mode_lock *lck;
 930
 931         if (!(lck = fetch_share_mode_unlocked(NULL, id, NULL, NULL))) {
 932                 return False;
 933         }
 934         result = lck->delete_on_close;
 935         TALLOC_FREE(lck);
 936         return result;
 937 }
 938
 939 bool is_valid_share_mode_entry(const struct share_mode_entry *e)
 940 {
 941         int num_props = 0;
 942
 943         if (e->op_type == UNUSED_SHARE_MODE_ENTRY) {
 944                 /* cope with dead entries from the process not
 945                    existing. These should not be considered valid,
 946                    otherwise we end up doing zero timeout sharing
 947                    violation */
 948                 return False;
 949         }
 950
 951         num_props += ((e->op_type == NO_OPLOCK) ? 1 : 0);
 952         num_props += (EXCLUSIVE_OPLOCK_TYPE(e->op_type) ? 1 : 0);
 953         num_props += (LEVEL_II_OPLOCK_TYPE(e->op_type) ? 1 : 0);
 954
 955         SMB_ASSERT(num_props <= 1);
 956         return (num_props != 0);
 957 }
 958
 959 bool is_deferred_open_entry(const struct share_mode_entry *e)
 960 {
 961         return (e->op_type == DEFERRED_OPEN_ENTRY);
 962 }
 963
 964 bool is_unused_share_mode_entry(const struct share_mode_entry *e)
 965 {
 966         return (e->op_type == UNUSED_SHARE_MODE_ENTRY);
 967 }
 968
 969 /*******************************************************************
 970  Fill a share mode entry.
 971 ********************************************************************/
 972
 973 static void fill_share_mode_entry(struct share_mode_entry *e,
 974                                   files_struct *fsp,
 975                                   uid_t uid, uint16 mid, uint16 op_type)
 976 {
 977         ZERO_STRUCTP(e);
 978         e->pid = procid_self();
 979         e->share_access = fsp->share_access;
 980         e->private_options = fsp->fh->private_options;
 981         e->access_mask = fsp->access_mask;
 982         e->op_mid = mid;
 983         e->op_type = op_type;
 984         e->time.tv_sec = fsp->open_time.tv_sec;
 985         e->time.tv_usec = fsp->open_time.tv_usec;
 986         e->id = fsp->file_id;
 987         e->share_file_id = fsp->fh->gen_id;
 988         e->uid = (uint32)uid;
 989         e->flags = fsp->posix_open ? SHARE_MODE_FLAG_POSIX_OPEN : 0;
 990 }
 991
 992 static void fill_deferred_open_entry(struct share_mode_entry *e,
 993                                      const struct timeval request_time,
 994                                      struct file_id id, uint16 mid)
 995 {
 996         ZERO_STRUCTP(e);
 997         e->pid = procid_self();
 998         e->op_mid = mid;
 999         e->op_type = DEFERRED_OPEN_ENTRY;
1000         e->time.tv_sec = request_time.tv_sec;
1001         e->time.tv_usec = request_time.tv_usec;
1002         e->id = id;
1003         e->uid = (uint32)-1;
1004         e->flags = 0;
1005 }
1006
1007 static void add_share_mode_entry(struct share_mode_lock *lck,
1008                                  const struct share_mode_entry *entry)
1009 {
1010         int i;
1011
1012         for (i=0; i<lck->num_share_modes; i++) {
1013                 struct share_mode_entry *e = &lck->share_modes[i];
1014                 if (is_unused_share_mode_entry(e)) {
1015                         *e = *entry;
1016                         break;
1017                 }
1018         }
1019
1020         if (i == lck->num_share_modes) {
1021                 /* No unused entry found */
1022                 ADD_TO_ARRAY(lck, struct share_mode_entry, *entry,
1023                              &lck->share_modes, &lck->num_share_modes);
1024         }
1025         lck->modified = True;
1026 }
1027
1028 void set_share_mode(struct share_mode_lock *lck, files_struct *fsp,
1029                         uid_t uid, uint16 mid, uint16 op_type, bool initial_delete_on_close_allowed)
1030 {
1031         struct share_mode_entry entry;
1032         fill_share_mode_entry(&entry, fsp, uid, mid, op_type);
1033         if (initial_delete_on_close_allowed) {
1034                 entry.flags |= SHARE_MODE_ALLOW_INITIAL_DELETE_ON_CLOSE;
1035         }
1036         add_share_mode_entry(lck, &entry);
1037 }
1038
1039 void add_deferred_open(struct share_mode_lock *lck, uint16 mid,
1040                        struct timeval request_time,
1041                        struct file_id id)
1042 {
1043         struct share_mode_entry entry;
1044         fill_deferred_open_entry(&entry, request_time, id, mid);
1045         add_share_mode_entry(lck, &entry);
1046 }
1047
1048 /*******************************************************************
1049  Check if two share mode entries are identical, ignoring oplock
1050  and mid info and desired_access. (Removed paranoia test - it's
1051  not automatically a logic error if they are identical. JRA.)
1052 ********************************************************************/
1053
1054 static bool share_modes_identical(struct share_mode_entry *e1,
1055                                   struct share_mode_entry *e2)
1056 {
1057         /* We used to check for e1->share_access == e2->share_access here
1058            as well as the other fields but 2 different DOS or FCB opens
1059            sharing the same share mode entry may validly differ in
1060            fsp->share_access field. */
1061
1062         return (procid_equal(&e1->pid, &e2->pid) &&
1063                 file_id_equal(&e1->id, &e2->id) &&
1064                 e1->share_file_id == e2->share_file_id );
1065 }
1066
1067 static bool deferred_open_identical(struct share_mode_entry *e1,
1068                                     struct share_mode_entry *e2)
1069 {
1070         return (procid_equal(&e1->pid, &e2->pid) &&
1071                 (e1->op_mid == e2->op_mid) &&
1072                 file_id_equal(&e1->id, &e2->id));
1073 }
1074
1075 static struct share_mode_entry *find_share_mode_entry(struct share_mode_lock *lck,
1076                                                       struct share_mode_entry *entry)
1077 {
1078         int i;
1079
1080         for (i=0; i<lck->num_share_modes; i++) {
1081                 struct share_mode_entry *e = &lck->share_modes[i];
1082                 if (is_valid_share_mode_entry(entry) &&
1083                     is_valid_share_mode_entry(e) &&
1084                     share_modes_identical(e, entry)) {
1085                         return e;
1086                 }
1087                 if (is_deferred_open_entry(entry) &&
1088                     is_deferred_open_entry(e) &&
1089                     deferred_open_identical(e, entry)) {
1090                         return e;
1091                 }
1092         }
1093         return NULL;
1094 }
1095
1096 /*******************************************************************
1097  Del the share mode of a file for this process. Return the number of
1098  entries left.
1099 ********************************************************************/
1100
1101 bool del_share_mode(struct share_mode_lock *lck, files_struct *fsp)
1102 {
1103         struct share_mode_entry entry, *e;
1104
1105         /* Don't care about the pid owner being correct here - just a search. */
1106         fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
1107
1108         e = find_share_mode_entry(lck, &entry);
1109         if (e == NULL) {
1110                 return False;
1111         }
1112
1113         e->op_type = UNUSED_SHARE_MODE_ENTRY;
1114         lck->modified = True;
1115         return True;
1116 }
1117
1118 void del_deferred_open_entry(struct share_mode_lock *lck, uint16 mid)
1119 {
1120         struct share_mode_entry entry, *e;
1121
1122         fill_deferred_open_entry(&entry, timeval_zero(),
1123                                  lck->id, mid);
1124
1125         e = find_share_mode_entry(lck, &entry);
1126         if (e == NULL) {
1127                 return;
1128         }
1129
1130         e->op_type = UNUSED_SHARE_MODE_ENTRY;
1131         lck->modified = True;
1132 }
1133
1134 /*******************************************************************
1135  Remove an oplock mid and mode entry from a share mode.
1136 ********************************************************************/
1137
1138 bool remove_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
1139 {
1140         struct share_mode_entry entry, *e;
1141
1142         /* Don't care about the pid owner being correct here - just a search. */
1143         fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
1144
1145         e = find_share_mode_entry(lck, &entry);
1146         if (e == NULL) {
1147                 return False;
1148         }
1149
1150         e->op_mid = 0;
1151         e->op_type = NO_OPLOCK;
1152         lck->modified = True;
1153         return True;
1154 }
1155
1156 /*******************************************************************
1157  Downgrade a oplock type from exclusive to level II.
1158 ********************************************************************/
1159
1160 bool downgrade_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
1161 {
1162         struct share_mode_entry entry, *e;
1163
1164         /* Don't care about the pid owner being correct here - just a search. */
1165         fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
1166
1167         e = find_share_mode_entry(lck, &entry);
1168         if (e == NULL) {
1169                 return False;
1170         }
1171
1172         e->op_type = LEVEL_II_OPLOCK;
1173         lck->modified = True;
1174         return True;
1175 }
1176
1177 /****************************************************************************
1178  Deal with the internal needs of setting the delete on close flag. Note that
1179  as the tdb locking is recursive, it is safe to call this from within
1180  open_file_ntcreate. JRA.
1181 ****************************************************************************/
1182
1183 NTSTATUS can_set_delete_on_close(files_struct *fsp, bool delete_on_close,
1184                                  uint32 dosmode)
1185 {
1186         if (!delete_on_close) {
1187                 return NT_STATUS_OK;
1188         }
1189
1190         /*
1191          * Only allow delete on close for writable files.
1192          */
1193
1194         if ((dosmode & aRONLY) &&
1195             !lp_delete_readonly(SNUM(fsp->conn))) {
1196                 DEBUG(10,("can_set_delete_on_close: file %s delete on close "
1197                           "flag set but file attribute is readonly.\n",
1198                           fsp->fsp_name ));
1199                 return NT_STATUS_CANNOT_DELETE;
1200         }
1201
1202         /*
1203          * Only allow delete on close for writable shares.
1204          */
1205
1206         if (!CAN_WRITE(fsp->conn)) {
1207                 DEBUG(10,("can_set_delete_on_close: file %s delete on "
1208                           "close flag set but write access denied on share.\n",
1209                           fsp->fsp_name ));
1210                 return NT_STATUS_ACCESS_DENIED;
1211         }
1212
1213         /*
1214          * Only allow delete on close for files/directories opened with delete
1215          * intent.
1216          */
1217
1218         if (!(fsp->access_mask & DELETE_ACCESS)) {
1219                 DEBUG(10,("can_set_delete_on_close: file %s delete on "
1220                           "close flag set but delete access denied.\n",
1221                           fsp->fsp_name ));
1222                 return NT_STATUS_ACCESS_DENIED;
1223         }
1224
1225         /* Don't allow delete on close for non-empty directories. */
1226         if (fsp->is_directory) {
1227                 return can_delete_directory(fsp->conn, fsp->fsp_name);
1228         }
1229
1230         return NT_STATUS_OK;
1231 }
1232
1233 /****************************************************************************
1234  Do we have an open file handle that created this entry ?
1235 ****************************************************************************/
1236
1237 bool can_set_initial_delete_on_close(const struct share_mode_lock *lck)
1238 {
1239         int i;
1240
1241         for (i=0; i<lck->num_share_modes; i++) {
1242                 if (lck->share_modes[i].flags & SHARE_MODE_ALLOW_INITIAL_DELETE_ON_CLOSE) {
1243                         return True;
1244                 }
1245         }
1246         return False;
1247 }
1248
1249 /*************************************************************************
1250  Return a talloced copy of a UNIX_USER_TOKEN. NULL on fail.
1251  (Should this be in locking.c.... ?).
1252 *************************************************************************/
1253
1254 static UNIX_USER_TOKEN *copy_unix_token(TALLOC_CTX *ctx, UNIX_USER_TOKEN *tok)
1255 {
1256         UNIX_USER_TOKEN *cpy;
1257
1258         if (tok == NULL) {
1259                 return NULL;
1260         }
1261
1262         cpy = TALLOC_P(ctx, UNIX_USER_TOKEN);
1263         if (!cpy) {
1264                 return NULL;
1265         }
1266
1267         cpy->uid = tok->uid;
1268         cpy->gid = tok->gid;
1269         cpy->ngroups = tok->ngroups;
1270         if (tok->ngroups) {
1271                 /* Make this a talloc child of cpy. */
1272                 cpy->groups = TALLOC_ARRAY(cpy, gid_t, tok->ngroups);
1273                 if (!cpy->groups) {
1274                         return NULL;
1275                 }
1276                 memcpy(cpy->groups, tok->groups, tok->ngroups * sizeof(gid_t));
1277         }
1278         return cpy;
1279 }
1280
1281 /****************************************************************************
1282  Replace the delete on close token.
1283 ****************************************************************************/
1284
1285 void set_delete_on_close_token(struct share_mode_lock *lck, UNIX_USER_TOKEN *tok)
1286 {
1287         /* Ensure there's no token. */
1288         if (lck->delete_token) {
1289                 TALLOC_FREE(lck->delete_token); /* Also deletes groups... */
1290                 lck->delete_token = NULL;
1291         }
1292
1293         /* Copy the new token (can be NULL). */
1294         lck->delete_token = copy_unix_token(lck, tok);
1295         lck->modified = True;
1296 }
1297
1298 /****************************************************************************
1299  Sets the delete on close flag over all share modes on this file.
1300  Modify the share mode entry for all files open
1301  on this device and inode to tell other smbds we have
1302  changed the delete on close flag. This will be noticed
1303  in the close code, the last closer will delete the file
1304  if flag is set.
1305  This makes a copy of any UNIX_USER_TOKEN into the
1306  lck entry. This function is used when the lock is already granted.
1307 ****************************************************************************/
1308
1309 void set_delete_on_close_lck(struct share_mode_lock *lck, bool delete_on_close, UNIX_USER_TOKEN *tok)
1310 {
1311         if (lck->delete_on_close != delete_on_close) {
1312                 set_delete_on_close_token(lck, tok);
1313                 lck->delete_on_close = delete_on_close;
1314                 if (delete_on_close) {
1315                         SMB_ASSERT(lck->delete_token != NULL);
1316                 }
1317                 lck->modified = True;
1318         }
1319 }
1320
1321 bool set_delete_on_close(files_struct *fsp, bool delete_on_close, UNIX_USER_TOKEN *tok)
1322 {
1323         struct share_mode_lock *lck;
1324
1325         DEBUG(10,("set_delete_on_close: %s delete on close flag for "
1326                   "fnum = %d, file %s\n",
1327                   delete_on_close ? "Adding" : "Removing", fsp->fnum,
1328                   fsp->fsp_name ));
1329
1330         if (fsp->is_stat) {
1331                 return True;
1332         }
1333
1334         lck = get_share_mode_lock(NULL, fsp->file_id, NULL, NULL);
1335         if (lck == NULL) {
1336                 return False;
1337         }
1338
1339         set_delete_on_close_lck(lck, delete_on_close, tok);
1340
1341         if (fsp->is_directory) {
1342                 send_stat_cache_delete_message(fsp->fsp_name);
1343         }
1344
1345         TALLOC_FREE(lck);
1346         return True;
1347 }
1348
1349 /****************************************************************************
1350  Sets the allow initial delete on close flag for this share mode.
1351 ****************************************************************************/
1352
1353 bool set_allow_initial_delete_on_close(struct share_mode_lock *lck, files_struct *fsp, bool delete_on_close)
1354 {
1355         struct share_mode_entry entry, *e;
1356
1357         /* Don't care about the pid owner being correct here - just a search. */
1358         fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
1359
1360         e = find_share_mode_entry(lck, &entry);
1361         if (e == NULL) {
1362                 return False;
1363         }
1364
1365         if (delete_on_close) {
1366                 e->flags |= SHARE_MODE_ALLOW_INITIAL_DELETE_ON_CLOSE;
1367         } else {
1368                 e->flags &= ~SHARE_MODE_ALLOW_INITIAL_DELETE_ON_CLOSE;
1369         }
1370         lck->modified = True;
1371         return True;
1372 }
1373
1374 struct forall_state {
1375         void (*fn)(const struct share_mode_entry *entry,
1376                    const char *sharepath,
1377                    const char *fname,
1378                    void *private_data);
1379         void *private_data;
1380 };
1381
1382 static int traverse_fn(struct db_record *rec, void *_state)
1383 {
1384         struct forall_state *state = (struct forall_state *)_state;
1385         struct locking_data *data;
1386         struct share_mode_entry *shares;
1387         const char *sharepath;
1388         const char *fname;
1389         int i;
1390
1391         /* Ensure this is a locking_key record. */
1392         if (rec->key.dsize != sizeof(struct file_id))
1393                 return 0;
1394
1395         data = (struct locking_data *)rec->value.dptr;
1396         shares = (struct share_mode_entry *)(rec->value.dptr + sizeof(*data));
1397         sharepath = (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         fname = (const char *)rec->value.dptr + sizeof(*data) +
1401                 data->u.s.num_share_mode_entries*sizeof(*shares) +
1402                 data->u.s.delete_token_size +
1403                 strlen(sharepath) + 1;
1404
1405         for (i=0;i<data->u.s.num_share_mode_entries;i++) {
1406                 state->fn(&shares[i], sharepath, fname,
1407                           state->private_data);
1408         }
1409         return 0;
1410 }
1411
1412 /*******************************************************************
1413  Call the specified function on each entry under management by the
1414  share mode system.
1415 ********************************************************************/
1416
1417 int share_mode_forall(void (*fn)(const struct share_mode_entry *, const char *,
1418                                  const char *, void *),
1419                       void *private_data)
1420 {
1421         struct forall_state state;
1422
1423         if (lock_db == NULL)
1424                 return 0;
1425
1426         state.fn = fn;
1427         state.private_data = private_data;
1428
1429         return lock_db->traverse_read(lock_db, traverse_fn, (void *)&state);
1430 }