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