source3/locking/locking.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Locking functions
   4    Copyright (C) Andrew Tridgell 1992-2000
   5    Copyright (C) Jeremy Allison 1992-2006
   6    Copyright (C) Volker Lendecke 2005
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20
  21    Revision History:
  22
  23    12 aug 96: Erik.Devriendt@te6.siemens.be
  24    added support for shared memory implementation of share mode locking
  25
  26    May 1997. Jeremy Allison (jallison@whistle.com). Modified share mode
  27    locking to deal with multiple share modes per open file.
  28
  29    September 1997. Jeremy Allison (jallison@whistle.com). Added oplock
  30    support.
  31
  32    rewritten completely to use new tdb code. Tridge, Dec '99
  33
  34    Added POSIX locking support. Jeremy Allison (jeremy@valinux.com), Apr. 2000.
  35    Added Unix Extensions POSIX locking support. Jeremy Allison Mar 2006.
  36 */
  37
  38 #include "includes.h"
  39 #include "system/filesys.h"
  40 #include "locking/proto.h"
  41 #include "smbd/globals.h"
  42 #include "dbwrap/dbwrap.h"
  43 #include "dbwrap/dbwrap_open.h"
  44 #include "../libcli/security/security.h"
  45 #include "serverid.h"
  46 #include "messages.h"
  47 #include "util_tdb.h"
  48 #include "../librpc/gen_ndr/ndr_open_files.h"
  49
  50 #undef DBGC_CLASS
  51 #define DBGC_CLASS DBGC_LOCKING
  52
  53 #define NO_LOCKING_COUNT (-1)
  54
  55 /****************************************************************************
  56  Debugging aids :-).
  57 ****************************************************************************/
  58
  59 const char *lock_type_name(enum brl_type lock_type)
  60 {
  61         switch (lock_type) {
  62                 case READ_LOCK:
  63                         return "READ";
  64                 case WRITE_LOCK:
  65                         return "WRITE";
  66                 case PENDING_READ_LOCK:
  67                         return "PENDING_READ";
  68                 case PENDING_WRITE_LOCK:
  69                         return "PENDING_WRITE";
  70                 default:
  71                         return "other";
  72         }
  73 }
  74
  75 const char *lock_flav_name(enum brl_flavour lock_flav)
  76 {
  77         return (lock_flav == WINDOWS_LOCK) ? "WINDOWS_LOCK" : "POSIX_LOCK";
  78 }
  79
  80 /****************************************************************************
  81  Utility function called to see if a file region is locked.
  82  Called in the read/write codepath.
  83 ****************************************************************************/
  84
  85 void init_strict_lock_struct(files_struct *fsp,
  86                                 uint64_t smblctx,
  87                                 br_off start,
  88                                 br_off size,
  89                                 enum brl_type lock_type,
  90                                 struct lock_struct *plock)
  91 {
  92         SMB_ASSERT(lock_type == READ_LOCK || lock_type == WRITE_LOCK);
  93
  94         plock->context.smblctx = smblctx;
  95         plock->context.tid = fsp->conn->cnum;
  96         plock->context.pid = messaging_server_id(fsp->conn->sconn->msg_ctx);
  97         plock->start = start;
  98         plock->size = size;
  99         plock->fnum = fsp->fnum;
 100         plock->lock_type = lock_type;
 101         plock->lock_flav = lp_posix_cifsu_locktype(fsp);
 102 }
 103
 104 bool strict_lock_default(files_struct *fsp, struct lock_struct *plock)
 105 {
 106         int strict_locking = lp_strict_locking(fsp->conn->params);
 107         bool ret = False;
 108
 109         if (plock->size == 0) {
 110                 return True;
 111         }
 112
 113         if (!lp_locking(fsp->conn->params) || !strict_locking) {
 114                 return True;
 115         }
 116
 117         if (strict_locking == Auto) {
 118                 if  (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type) && (plock->lock_type == READ_LOCK || plock->lock_type == WRITE_LOCK)) {
 119                         DEBUG(10,("is_locked: optimisation - exclusive oplock on file %s\n", fsp_str_dbg(fsp)));
 120                         ret = True;
 121                 } else if ((fsp->oplock_type == LEVEL_II_OPLOCK) &&
 122                            (plock->lock_type == READ_LOCK)) {
 123                         DEBUG(10,("is_locked: optimisation - level II oplock on file %s\n", fsp_str_dbg(fsp)));
 124                         ret = True;
 125                 } else {
 126                         struct byte_range_lock *br_lck;
 127
 128                         br_lck = brl_get_locks_readonly(fsp);
 129                         if (!br_lck) {
 130                                 return True;
 131                         }
 132                         ret = brl_locktest(br_lck,
 133                                         plock->context.smblctx,
 134                                         plock->context.pid,
 135                                         plock->start,
 136                                         plock->size,
 137                                         plock->lock_type,
 138                                         plock->lock_flav);
 139                 }
 140         } else {
 141                 struct byte_range_lock *br_lck;
 142
 143                 br_lck = brl_get_locks_readonly(fsp);
 144                 if (!br_lck) {
 145                         return True;
 146                 }
 147                 ret = brl_locktest(br_lck,
 148                                 plock->context.smblctx,
 149                                 plock->context.pid,
 150                                 plock->start,
 151                                 plock->size,
 152                                 plock->lock_type,
 153                                 plock->lock_flav);
 154         }
 155
 156         DEBUG(10,("strict_lock_default: flavour = %s brl start=%.0f "
 157                         "len=%.0f %s for fnum %llu file %s\n",
 158                         lock_flav_name(plock->lock_flav),
 159                         (double)plock->start, (double)plock->size,
 160                         ret ? "unlocked" : "locked",
 161                         (unsigned long long)plock->fnum, fsp_str_dbg(fsp)));
 162
 163         return ret;
 164 }
 165
 166 void strict_unlock_default(files_struct *fsp, struct lock_struct *plock)
 167 {
 168 }
 169
 170 /****************************************************************************
 171  Find out if a lock could be granted - return who is blocking us if we can't.
 172 ****************************************************************************/
 173
 174 NTSTATUS query_lock(files_struct *fsp,
 175                         uint64_t *psmblctx,
 176                         uint64_t *pcount,
 177                         uint64_t *poffset,
 178                         enum brl_type *plock_type,
 179                         enum brl_flavour lock_flav)
 180 {
 181         struct byte_range_lock *br_lck = NULL;
 182
 183         if (!fsp->can_lock) {
 184                 return fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
 185         }
 186
 187         if (!lp_locking(fsp->conn->params)) {
 188                 return NT_STATUS_OK;
 189         }
 190
 191         br_lck = brl_get_locks_readonly(fsp);
 192         if (!br_lck) {
 193                 return NT_STATUS_NO_MEMORY;
 194         }
 195
 196         return brl_lockquery(br_lck,
 197                         psmblctx,
 198                         messaging_server_id(fsp->conn->sconn->msg_ctx),
 199                         poffset,
 200                         pcount,
 201                         plock_type,
 202                         lock_flav);
 203 }
 204
 205 static void increment_current_lock_count(files_struct *fsp,
 206     enum brl_flavour lock_flav)
 207 {
 208         if (lock_flav == WINDOWS_LOCK &&
 209             fsp->current_lock_count != NO_LOCKING_COUNT) {
 210                 /* blocking ie. pending, locks also count here,
 211                  * as this is an efficiency counter to avoid checking
 212                  * the lock db. on close. JRA. */
 213
 214                 fsp->current_lock_count++;
 215         } else {
 216                 /* Notice that this has had a POSIX lock request.
 217                  * We can't count locks after this so forget them.
 218                  */
 219                 fsp->current_lock_count = NO_LOCKING_COUNT;
 220         }
 221 }
 222
 223 static void decrement_current_lock_count(files_struct *fsp,
 224     enum brl_flavour lock_flav)
 225 {
 226         if (lock_flav == WINDOWS_LOCK &&
 227             fsp->current_lock_count != NO_LOCKING_COUNT) {
 228                 SMB_ASSERT(fsp->current_lock_count > 0);
 229                 fsp->current_lock_count--;
 230         }
 231 }
 232
 233 /****************************************************************************
 234  Utility function called by locking requests.
 235 ****************************************************************************/
 236
 237 struct byte_range_lock *do_lock(struct messaging_context *msg_ctx,
 238                         files_struct *fsp,
 239                         uint64_t smblctx,
 240                         uint64_t count,
 241                         uint64_t offset,
 242                         enum brl_type lock_type,
 243                         enum brl_flavour lock_flav,
 244                         bool blocking_lock,
 245                         NTSTATUS *perr,
 246                         uint64_t *psmblctx,
 247                         struct blocking_lock_record *blr)
 248 {
 249         struct byte_range_lock *br_lck = NULL;
 250
 251         /* silently return ok on print files as we don't do locking there */
 252         if (fsp->print_file) {
 253                 *perr = NT_STATUS_OK;
 254                 return NULL;
 255         }
 256
 257         if (!fsp->can_lock) {
 258                 *perr = fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
 259                 return NULL;
 260         }
 261
 262         if (!lp_locking(fsp->conn->params)) {
 263                 *perr = NT_STATUS_OK;
 264                 return NULL;
 265         }
 266
 267         /* NOTE! 0 byte long ranges ARE allowed and should be stored  */
 268
 269         DEBUG(10,("do_lock: lock flavour %s lock type %s start=%.0f len=%.0f "
 270                 "blocking_lock=%s requested for %s file %s\n",
 271                 lock_flav_name(lock_flav), lock_type_name(lock_type),
 272                 (double)offset, (double)count, blocking_lock ? "true" :
 273                 "false", fsp_fnum_dbg(fsp), fsp_str_dbg(fsp)));
 274
 275         br_lck = brl_get_locks(talloc_tos(), fsp);
 276         if (!br_lck) {
 277                 *perr = NT_STATUS_NO_MEMORY;
 278                 return NULL;
 279         }
 280
 281         *perr = brl_lock(msg_ctx,
 282                         br_lck,
 283                         smblctx,
 284                         messaging_server_id(fsp->conn->sconn->msg_ctx),
 285                         offset,
 286                         count,
 287                         lock_type,
 288                         lock_flav,
 289                         blocking_lock,
 290                         psmblctx,
 291                         blr);
 292
 293         DEBUG(10, ("do_lock: returning status=%s\n", nt_errstr(*perr)));
 294
 295         increment_current_lock_count(fsp, lock_flav);
 296         return br_lck;
 297 }
 298
 299 /****************************************************************************
 300  Utility function called by unlocking requests.
 301 ****************************************************************************/
 302
 303 NTSTATUS do_unlock(struct messaging_context *msg_ctx,
 304                         files_struct *fsp,
 305                         uint64_t smblctx,
 306                         uint64_t count,
 307                         uint64_t offset,
 308                         enum brl_flavour lock_flav)
 309 {
 310         bool ok = False;
 311         struct byte_range_lock *br_lck = NULL;
 312
 313         if (!fsp->can_lock) {
 314                 return fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
 315         }
 316
 317         if (!lp_locking(fsp->conn->params)) {
 318                 return NT_STATUS_OK;
 319         }
 320
 321         DEBUG(10,("do_unlock: unlock start=%.0f len=%.0f requested for %s file %s\n",
 322                   (double)offset, (double)count, fsp_fnum_dbg(fsp),
 323                   fsp_str_dbg(fsp)));
 324
 325         br_lck = brl_get_locks(talloc_tos(), fsp);
 326         if (!br_lck) {
 327                 return NT_STATUS_NO_MEMORY;
 328         }
 329
 330         ok = brl_unlock(msg_ctx,
 331                         br_lck,
 332                         smblctx,
 333                         messaging_server_id(fsp->conn->sconn->msg_ctx),
 334                         offset,
 335                         count,
 336                         lock_flav);
 337
 338         TALLOC_FREE(br_lck);
 339
 340         if (!ok) {
 341                 DEBUG(10,("do_unlock: returning ERRlock.\n" ));
 342                 return NT_STATUS_RANGE_NOT_LOCKED;
 343         }
 344
 345         decrement_current_lock_count(fsp, lock_flav);
 346         return NT_STATUS_OK;
 347 }
 348
 349 /****************************************************************************
 350  Cancel any pending blocked locks.
 351 ****************************************************************************/
 352
 353 NTSTATUS do_lock_cancel(files_struct *fsp,
 354                         uint64 smblctx,
 355                         uint64_t count,
 356                         uint64_t offset,
 357                         enum brl_flavour lock_flav,
 358                         struct blocking_lock_record *blr)
 359 {
 360         bool ok = False;
 361         struct byte_range_lock *br_lck = NULL;
 362
 363         if (!fsp->can_lock) {
 364                 return fsp->is_directory ?
 365                         NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
 366         }
 367
 368         if (!lp_locking(fsp->conn->params)) {
 369                 return NT_STATUS_DOS(ERRDOS, ERRcancelviolation);
 370         }
 371
 372         DEBUG(10,("do_lock_cancel: cancel start=%.0f len=%.0f requested for %s file %s\n",
 373                   (double)offset, (double)count, fsp_fnum_dbg(fsp),
 374                   fsp_str_dbg(fsp)));
 375
 376         br_lck = brl_get_locks(talloc_tos(), fsp);
 377         if (!br_lck) {
 378                 return NT_STATUS_NO_MEMORY;
 379         }
 380
 381         ok = brl_lock_cancel(br_lck,
 382                         smblctx,
 383                         messaging_server_id(fsp->conn->sconn->msg_ctx),
 384                         offset,
 385                         count,
 386                         lock_flav,
 387                         blr);
 388
 389         TALLOC_FREE(br_lck);
 390
 391         if (!ok) {
 392                 DEBUG(10,("do_lock_cancel: returning ERRcancelviolation.\n" ));
 393                 return NT_STATUS_DOS(ERRDOS, ERRcancelviolation);
 394         }
 395
 396         decrement_current_lock_count(fsp, lock_flav);
 397         return NT_STATUS_OK;
 398 }
 399
 400 /****************************************************************************
 401  Remove any locks on this fd. Called from file_close().
 402 ****************************************************************************/
 403
 404 void locking_close_file(struct messaging_context *msg_ctx,
 405                         files_struct *fsp,
 406                         enum file_close_type close_type)
 407 {
 408         struct byte_range_lock *br_lck;
 409
 410         if (!lp_locking(fsp->conn->params)) {
 411                 return;
 412         }
 413
 414         /* If we have not outstanding locks or pending
 415          * locks then we don't need to look in the lock db.
 416          */
 417
 418         if (fsp->current_lock_count == 0) {
 419                 return;
 420         }
 421
 422         br_lck = brl_get_locks(talloc_tos(),fsp);
 423
 424         if (br_lck) {
 425                 cancel_pending_lock_requests_by_fid(fsp, br_lck, close_type);
 426                 brl_close_fnum(msg_ctx, br_lck);
 427                 TALLOC_FREE(br_lck);
 428         }
 429 }
 430
 431 /*******************************************************************
 432  Print out a share mode.
 433 ********************************************************************/
 434
 435 char *share_mode_str(TALLOC_CTX *ctx, int num, const struct share_mode_entry *e)
 436 {
 437         return talloc_asprintf(ctx, "share_mode_entry[%d]: "
 438                  "pid = %s, share_access = 0x%x, private_options = 0x%x, "
 439                  "access_mask = 0x%x, mid = 0x%llx, type= 0x%x, gen_id = %llu, "
 440                  "uid = %u, flags = %u, file_id %s, name_hash = 0x%x",
 441                  num,
 442                  procid_str_static(&e->pid),
 443                  e->share_access, e->private_options,
 444                  e->access_mask, (unsigned long long)e->op_mid,
 445                  e->op_type, (unsigned long long)e->share_file_id,
 446                  (unsigned int)e->uid, (unsigned int)e->flags,
 447                  file_id_string_tos(&e->id),
 448                  (unsigned int)e->name_hash);
 449 }
 450
 451 /*******************************************************************
 452  Fetch a share mode where we know one MUST exist. This call reference
 453  counts it internally to allow for nested lock fetches.
 454 ********************************************************************/
 455
 456 struct share_mode_lock *get_existing_share_mode_lock(TALLOC_CTX *mem_ctx,
 457                                                      const struct file_id id)
 458 {
 459         return get_share_mode_lock(mem_ctx, id, NULL, NULL, NULL);
 460 }
 461
 462 /*******************************************************************
 463  Sets the service name and filename for rename.
 464  At this point we emit "file renamed" messages to all
 465  process id's that have this file open.
 466  Based on an initial code idea from SATOH Fumiyasu <fumiya@samba.gr.jp>
 467 ********************************************************************/
 468
 469 bool rename_share_filename(struct messaging_context *msg_ctx,
 470                         struct share_mode_lock *lck,
 471                         const char *servicepath,
 472                         uint32_t orig_name_hash,
 473                         uint32_t new_name_hash,
 474                         const struct smb_filename *smb_fname_dst)
 475 {
 476         struct share_mode_data *d = lck->data;
 477         size_t sp_len;
 478         size_t bn_len;
 479         size_t sn_len;
 480         size_t msg_len;
 481         char *frm = NULL;
 482         int i;
 483         bool strip_two_chars = false;
 484         bool has_stream = smb_fname_dst->stream_name != NULL;
 485
 486         DEBUG(10, ("rename_share_filename: servicepath %s newname %s\n",
 487                    servicepath, smb_fname_dst->base_name));
 488
 489         /*
 490          * rename_internal_fsp() and rename_internals() add './' to
 491          * head of newname if newname does not contain a '/'.
 492          */
 493         if (smb_fname_dst->base_name[0] &&
 494             smb_fname_dst->base_name[1] &&
 495             smb_fname_dst->base_name[0] == '.' &&
 496             smb_fname_dst->base_name[1] == '/') {
 497                 strip_two_chars = true;
 498         }
 499
 500         d->servicepath = talloc_strdup(d, servicepath);
 501         d->base_name = talloc_strdup(d, smb_fname_dst->base_name +
 502                                        (strip_two_chars ? 2 : 0));
 503         d->stream_name = talloc_strdup(d, smb_fname_dst->stream_name);
 504         if (d->base_name == NULL ||
 505             (has_stream && d->stream_name == NULL) ||
 506             d->servicepath == NULL) {
 507                 DEBUG(0, ("rename_share_filename: talloc failed\n"));
 508                 return False;
 509         }
 510         d->modified = True;
 511
 512         sp_len = strlen(d->servicepath);
 513         bn_len = strlen(d->base_name);
 514         sn_len = has_stream ? strlen(d->stream_name) : 0;
 515
 516         msg_len = MSG_FILE_RENAMED_MIN_SIZE + sp_len + 1 + bn_len + 1 +
 517             sn_len + 1;
 518
 519         /* Set up the name changed message. */
 520         frm = talloc_array(d, char, msg_len);
 521         if (!frm) {
 522                 return False;
 523         }
 524
 525         push_file_id_24(frm, &d->id);
 526
 527         DEBUG(10,("rename_share_filename: msg_len = %u\n", (unsigned int)msg_len ));
 528
 529         strlcpy(&frm[24],
 530                 d->servicepath ? d->servicepath : "",
 531                 sp_len+1);
 532         strlcpy(&frm[24 + sp_len + 1],
 533                 d->base_name ? d->base_name : "",
 534                 bn_len+1);
 535         strlcpy(&frm[24 + sp_len + 1 + bn_len + 1],
 536                 d->stream_name ? d->stream_name : "",
 537                 sn_len+1);
 538
 539         /* Send the messages. */
 540         for (i=0; i<d->num_share_modes; i++) {
 541                 struct share_mode_entry *se = &d->share_modes[i];
 542                 if (!is_valid_share_mode_entry(se)) {
 543                         continue;
 544                 }
 545
 546                 /* If this is a hardlink to the inode
 547                    with a different name, skip this. */
 548                 if (se->name_hash != orig_name_hash) {
 549                         continue;
 550                 }
 551
 552                 se->name_hash = new_name_hash;
 553
 554                 /* But not to ourselves... */
 555                 if (procid_is_me(&se->pid)) {
 556                         continue;
 557                 }
 558
 559                 if (share_mode_stale_pid(d, i)) {
 560                         continue;
 561                 }
 562
 563                 DEBUG(10,("rename_share_filename: sending rename message to "
 564                           "pid %s file_id %s sharepath %s base_name %s "
 565                           "stream_name %s\n",
 566                           procid_str_static(&se->pid),
 567                           file_id_string_tos(&d->id),
 568                           d->servicepath, d->base_name,
 569                         has_stream ? d->stream_name : ""));
 570
 571                 messaging_send_buf(msg_ctx, se->pid, MSG_SMB_FILE_RENAME,
 572                                    (uint8 *)frm, msg_len);
 573         }
 574
 575         return True;
 576 }
 577
 578 void get_file_infos(struct file_id id,
 579                     uint32_t name_hash,
 580                     bool *delete_on_close,
 581                     struct timespec *write_time)
 582 {
 583         struct share_mode_lock *lck;
 584
 585         if (delete_on_close) {
 586                 *delete_on_close = false;
 587         }
 588
 589         if (write_time) {
 590                 ZERO_STRUCTP(write_time);
 591         }
 592
 593         if (!(lck = fetch_share_mode_unlocked(talloc_tos(), id))) {
 594                 return;
 595         }
 596
 597         if (delete_on_close) {
 598                 *delete_on_close = is_delete_on_close_set(lck, name_hash);
 599         }
 600
 601         if (write_time) {
 602                 struct timespec wt;
 603
 604                 wt = lck->data->changed_write_time;
 605                 if (null_timespec(wt)) {
 606                         wt = lck->data->old_write_time;
 607                 }
 608
 609                 *write_time = wt;
 610         }
 611
 612         TALLOC_FREE(lck);
 613 }
 614
 615 bool is_valid_share_mode_entry(const struct share_mode_entry *e)
 616 {
 617         int num_props = 0;
 618
 619         num_props += ((e->op_type == NO_OPLOCK) ? 1 : 0);
 620         num_props += (EXCLUSIVE_OPLOCK_TYPE(e->op_type) ? 1 : 0);
 621         num_props += (LEVEL_II_OPLOCK_TYPE(e->op_type) ? 1 : 0);
 622
 623         if ((num_props > 1) && serverid_exists(&e->pid)) {
 624                 smb_panic("Invalid share mode entry");
 625         }
 626         return (num_props != 0);
 627 }
 628
 629 bool is_deferred_open_entry(const struct share_mode_entry *e)
 630 {
 631         return (e->op_type == DEFERRED_OPEN_ENTRY);
 632 }
 633
 634 /*
 635  * In case d->share_modes[i] conflicts with something or otherwise is
 636  * being used, we need to make sure the corresponding process still
 637  * exists. This routine checks it and potentially removes the entry
 638  * from d->share_modes. Modifies d->num_share_modes, watch out in
 639  * routines iterating over that array.
 640  */
 641 bool share_mode_stale_pid(struct share_mode_data *d, unsigned i)
 642 {
 643         struct share_mode_entry *e;
 644
 645         if (i > d->num_share_modes) {
 646                 DEBUG(1, ("Asking for index %u, only %u around\n",
 647                           i, (unsigned)d->num_share_modes));
 648                 return false;
 649         }
 650         e = &d->share_modes[i];
 651         if (serverid_exists(&e->pid)) {
 652                 DEBUG(10, ("PID %s (index %u out of %u) still exists\n",
 653                            procid_str_static(&e->pid), i,
 654                            (unsigned)d->num_share_modes));
 655                 return false;
 656         }
 657         DEBUG(10, ("PID %s (index %u out of %u) does not exist anymore\n",
 658                    procid_str_static(&e->pid), i,
 659                    (unsigned)d->num_share_modes));
 660         *e = d->share_modes[d->num_share_modes-1];
 661         d->num_share_modes -= 1;
 662
 663         if (d->num_share_modes == 0 &&
 664             d->num_delete_tokens) {
 665                 /*
 666                  * We cannot have any delete tokens
 667                  * if there are no valid share modes.
 668                  */
 669                 TALLOC_FREE(d->delete_tokens);
 670                 d->num_delete_tokens = 0;
 671         }
 672
 673         d->modified = true;
 674         return true;
 675 }
 676
 677 /*******************************************************************
 678  Fill a share mode entry.
 679 ********************************************************************/
 680
 681 static void fill_share_mode_entry(struct share_mode_entry *e,
 682                                   files_struct *fsp,
 683                                   uid_t uid, uint64_t mid, uint16 op_type)
 684 {
 685         ZERO_STRUCTP(e);
 686         e->pid = messaging_server_id(fsp->conn->sconn->msg_ctx);
 687         e->share_access = fsp->share_access;
 688         e->private_options = fsp->fh->private_options;
 689         e->access_mask = fsp->access_mask;
 690         e->op_mid = mid;
 691         e->op_type = op_type;
 692         e->time.tv_sec = fsp->open_time.tv_sec;
 693         e->time.tv_usec = fsp->open_time.tv_usec;
 694         e->id = fsp->file_id;
 695         e->share_file_id = fsp->fh->gen_id;
 696         e->uid = (uint32)uid;
 697         e->flags = fsp->posix_open ? SHARE_MODE_FLAG_POSIX_OPEN : 0;
 698         e->name_hash = fsp->name_hash;
 699 }
 700
 701 static void fill_deferred_open_entry(struct share_mode_entry *e,
 702                                      const struct timeval request_time,
 703                                      struct file_id id,
 704                                      struct server_id pid,
 705                                      uint64_t mid)
 706 {
 707         ZERO_STRUCTP(e);
 708         e->pid = pid;
 709         e->op_mid = mid;
 710         e->op_type = DEFERRED_OPEN_ENTRY;
 711         e->time.tv_sec = request_time.tv_sec;
 712         e->time.tv_usec = request_time.tv_usec;
 713         e->id = id;
 714         e->uid = (uint32)-1;
 715         e->flags = 0;
 716 }
 717
 718 static void add_share_mode_entry(struct share_mode_data *d,
 719                                  const struct share_mode_entry *entry)
 720 {
 721         ADD_TO_ARRAY(d, struct share_mode_entry, *entry,
 722                      &d->share_modes, &d->num_share_modes);
 723         d->modified = True;
 724 }
 725
 726 void set_share_mode(struct share_mode_lock *lck, files_struct *fsp,
 727                     uid_t uid, uint64_t mid, uint16 op_type)
 728 {
 729         struct share_mode_entry entry;
 730         fill_share_mode_entry(&entry, fsp, uid, mid, op_type);
 731         add_share_mode_entry(lck->data, &entry);
 732 }
 733
 734 void add_deferred_open(struct share_mode_lock *lck, uint64_t mid,
 735                        struct timeval request_time,
 736                        struct server_id pid, struct file_id id)
 737 {
 738         struct share_mode_entry entry;
 739         fill_deferred_open_entry(&entry, request_time, id, pid, mid);
 740         add_share_mode_entry(lck->data, &entry);
 741 }
 742
 743 /*******************************************************************
 744  Check if two share mode entries are identical, ignoring oplock
 745  and mid info and desired_access. (Removed paranoia test - it's
 746  not automatically a logic error if they are identical. JRA.)
 747 ********************************************************************/
 748
 749 static bool share_modes_identical(struct share_mode_entry *e1,
 750                                   struct share_mode_entry *e2)
 751 {
 752         /* We used to check for e1->share_access == e2->share_access here
 753            as well as the other fields but 2 different DOS or FCB opens
 754            sharing the same share mode entry may validly differ in
 755            fsp->share_access field. */
 756
 757         return (procid_equal(&e1->pid, &e2->pid) &&
 758                 file_id_equal(&e1->id, &e2->id) &&
 759                 e1->share_file_id == e2->share_file_id );
 760 }
 761
 762 static bool deferred_open_identical(struct share_mode_entry *e1,
 763                                     struct share_mode_entry *e2)
 764 {
 765         return (procid_equal(&e1->pid, &e2->pid) &&
 766                 (e1->op_mid == e2->op_mid) &&
 767                 file_id_equal(&e1->id, &e2->id));
 768 }
 769
 770 static struct share_mode_entry *find_share_mode_entry(struct share_mode_data *d,
 771                                                       struct share_mode_entry *entry)
 772 {
 773         int i;
 774
 775         for (i=0; i<d->num_share_modes; i++) {
 776                 struct share_mode_entry *e = &d->share_modes[i];
 777                 if (is_valid_share_mode_entry(entry) &&
 778                     is_valid_share_mode_entry(e) &&
 779                     share_modes_identical(e, entry)) {
 780                         return e;
 781                 }
 782                 if (is_deferred_open_entry(entry) &&
 783                     is_deferred_open_entry(e) &&
 784                     deferred_open_identical(e, entry)) {
 785                         return e;
 786                 }
 787         }
 788         return NULL;
 789 }
 790
 791 /*******************************************************************
 792  Del the share mode of a file for this process. Return the number of
 793  entries left.
 794 ********************************************************************/
 795
 796 bool del_share_mode(struct share_mode_lock *lck, files_struct *fsp)
 797 {
 798         struct share_mode_entry entry, *e;
 799
 800         /* Don't care about the pid owner being correct here - just a search. */
 801         fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
 802
 803         e = find_share_mode_entry(lck->data, &entry);
 804         if (e == NULL) {
 805                 return False;
 806         }
 807         *e = lck->data->share_modes[lck->data->num_share_modes-1];
 808         lck->data->num_share_modes -= 1;
 809         lck->data->modified = True;
 810         return True;
 811 }
 812
 813 void del_deferred_open_entry(struct share_mode_lock *lck, uint64_t mid,
 814                              struct server_id pid)
 815 {
 816         struct share_mode_entry entry, *e;
 817
 818         fill_deferred_open_entry(&entry, timeval_zero(),
 819                                  lck->data->id, pid, mid);
 820
 821         e = find_share_mode_entry(lck->data, &entry);
 822         if (e == NULL) {
 823                 return;
 824         }
 825         *e = lck->data->share_modes[lck->data->num_share_modes-1];
 826         lck->data->num_share_modes -= 1;
 827         lck->data->modified = True;
 828 }
 829
 830 /*******************************************************************
 831  Remove an oplock mid and mode entry from a share mode.
 832 ********************************************************************/
 833
 834 bool remove_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
 835 {
 836         struct share_mode_entry entry, *e;
 837
 838         /* Don't care about the pid owner being correct here - just a search. */
 839         fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
 840
 841         e = find_share_mode_entry(lck->data, &entry);
 842         if (e == NULL) {
 843                 return False;
 844         }
 845
 846         if (EXCLUSIVE_OPLOCK_TYPE(e->op_type)) {
 847                 /*
 848                  * Going from exclusive or batch,
 849                  * we always go through FAKE_LEVEL_II
 850                  * first.
 851                  */
 852                 if (!EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) {
 853                         smb_panic("remove_share_oplock: logic error");
 854                 }
 855                 e->op_type = FAKE_LEVEL_II_OPLOCK;
 856         } else {
 857                 e->op_type = NO_OPLOCK;
 858         }
 859         lck->data->modified = True;
 860         return True;
 861 }
 862
 863 /*******************************************************************
 864  Downgrade a oplock type from exclusive to level II.
 865 ********************************************************************/
 866
 867 bool downgrade_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
 868 {
 869         struct share_mode_entry entry, *e;
 870
 871         /* Don't care about the pid owner being correct here - just a search. */
 872         fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
 873
 874         e = find_share_mode_entry(lck->data, &entry);
 875         if (e == NULL) {
 876                 return False;
 877         }
 878
 879         e->op_type = LEVEL_II_OPLOCK;
 880         lck->data->modified = True;
 881         return True;
 882 }
 883
 884 /*************************************************************************
 885  Return a talloced copy of a struct security_unix_token. NULL on fail.
 886  (Should this be in locking.c.... ?).
 887 *************************************************************************/
 888
 889 static struct security_unix_token *copy_unix_token(TALLOC_CTX *ctx, const struct security_unix_token *tok)
 890 {
 891         struct security_unix_token *cpy;
 892
 893         cpy = talloc(ctx, struct security_unix_token);
 894         if (!cpy) {
 895                 return NULL;
 896         }
 897
 898         cpy->uid = tok->uid;
 899         cpy->gid = tok->gid;
 900         cpy->ngroups = tok->ngroups;
 901         if (tok->ngroups) {
 902                 /* Make this a talloc child of cpy. */
 903                 cpy->groups = (gid_t *)talloc_memdup(
 904                         cpy, tok->groups, tok->ngroups * sizeof(gid_t));
 905                 if (!cpy->groups) {
 906                         TALLOC_FREE(cpy);
 907                         return NULL;
 908                 }
 909         }
 910         return cpy;
 911 }
 912
 913 /****************************************************************************
 914  Adds a delete on close token.
 915 ****************************************************************************/
 916
 917 static bool add_delete_on_close_token(struct share_mode_data *d,
 918                         uint32_t name_hash,
 919                         const struct security_token *nt_tok,
 920                         const struct security_unix_token *tok)
 921 {
 922         struct delete_token *tmp, *dtl;
 923
 924         tmp = talloc_realloc(d, d->delete_tokens, struct delete_token,
 925                              d->num_delete_tokens+1);
 926         if (tmp == NULL) {
 927                 return false;
 928         }
 929         d->delete_tokens = tmp;
 930         dtl = &d->delete_tokens[d->num_delete_tokens];
 931
 932         dtl->name_hash = name_hash;
 933         dtl->delete_nt_token = dup_nt_token(d->delete_tokens, nt_tok);
 934         if (dtl->delete_nt_token == NULL) {
 935                 return false;
 936         }
 937         dtl->delete_token = copy_unix_token(d->delete_tokens, tok);
 938         if (dtl->delete_token == NULL) {
 939                 return false;
 940         }
 941         d->num_delete_tokens += 1;
 942         d->modified = true;
 943         return true;
 944 }
 945
 946 /****************************************************************************
 947  Sets the delete on close flag over all share modes on this file.
 948  Modify the share mode entry for all files open
 949  on this device and inode to tell other smbds we have
 950  changed the delete on close flag. This will be noticed
 951  in the close code, the last closer will delete the file
 952  if flag is set.
 953  This makes a copy of any struct security_unix_token into the
 954  lck entry. This function is used when the lock is already granted.
 955 ****************************************************************************/
 956
 957 void set_delete_on_close_lck(files_struct *fsp,
 958                         struct share_mode_lock *lck,
 959                         bool delete_on_close,
 960                         const struct security_token *nt_tok,
 961                         const struct security_unix_token *tok)
 962 {
 963         struct share_mode_data *d = lck->data;
 964         int i;
 965         bool ret;
 966
 967         if (delete_on_close) {
 968                 SMB_ASSERT(nt_tok != NULL);
 969                 SMB_ASSERT(tok != NULL);
 970         } else {
 971                 SMB_ASSERT(nt_tok == NULL);
 972                 SMB_ASSERT(tok == NULL);
 973         }
 974
 975         for (i=0; i<d->num_delete_tokens; i++) {
 976                 struct delete_token *dt = &d->delete_tokens[i];
 977                 if (dt->name_hash == fsp->name_hash) {
 978                         d->modified = true;
 979                         if (delete_on_close == false) {
 980                                 /* Delete this entry. */
 981                                 TALLOC_FREE(dt->delete_nt_token);
 982                                 TALLOC_FREE(dt->delete_token);
 983                                 *dt = d->delete_tokens[
 984                                         d->num_delete_tokens-1];
 985                                 d->num_delete_tokens -= 1;
 986                         } else {
 987                                 /* Replace this token with the
 988                                    given tok. */
 989                                 TALLOC_FREE(dt->delete_nt_token);
 990                                 dt->delete_nt_token = dup_nt_token(dt, nt_tok);
 991                                 SMB_ASSERT(dt->delete_nt_token != NULL);
 992                                 TALLOC_FREE(dt->delete_token);
 993                                 dt->delete_token = copy_unix_token(dt, tok);
 994                                 SMB_ASSERT(dt->delete_token != NULL);
 995                         }
 996                         return;
 997                 }
 998         }
 999
1000         if (!delete_on_close) {
1001                 /* Nothing to delete - not found. */
1002                 return;
1003         }
1004
1005         ret = add_delete_on_close_token(lck->data, fsp->name_hash, nt_tok, tok);
1006         SMB_ASSERT(ret);
1007 }
1008
1009 bool set_delete_on_close(files_struct *fsp, bool delete_on_close,
1010                         const struct security_token *nt_tok,
1011                         const struct security_unix_token *tok)
1012 {
1013         struct share_mode_lock *lck;
1014
1015         DEBUG(10,("set_delete_on_close: %s delete on close flag for "
1016                   "%s, file %s\n",
1017                   delete_on_close ? "Adding" : "Removing", fsp_fnum_dbg(fsp),
1018                   fsp_str_dbg(fsp)));
1019
1020         lck = get_existing_share_mode_lock(talloc_tos(), fsp->file_id);
1021         if (lck == NULL) {
1022                 return False;
1023         }
1024
1025         if (delete_on_close) {
1026                 set_delete_on_close_lck(fsp, lck, true,
1027                         nt_tok,
1028                         tok);
1029         } else {
1030                 set_delete_on_close_lck(fsp, lck, false,
1031                         NULL,
1032                         NULL);
1033         }
1034
1035         if (fsp->is_directory) {
1036                 SMB_ASSERT(!is_ntfs_stream_smb_fname(fsp->fsp_name));
1037                 send_stat_cache_delete_message(fsp->conn->sconn->msg_ctx,
1038                                                fsp->fsp_name->base_name);
1039         }
1040
1041         TALLOC_FREE(lck);
1042
1043         fsp->delete_on_close = delete_on_close;
1044
1045         return True;
1046 }
1047
1048 static struct delete_token *find_delete_on_close_token(
1049         struct share_mode_data *d, uint32_t name_hash)
1050 {
1051         uint32_t i;
1052
1053         DEBUG(10, ("find_delete_on_close_token: name_hash = 0x%x\n",
1054                    (unsigned int)name_hash));
1055
1056         for (i=0; i<d->num_delete_tokens; i++) {
1057                 struct delete_token *dt = &d->delete_tokens[i];
1058
1059                 DEBUG(10, ("find__delete_on_close_token: dt->name_hash = 0x%x\n",
1060                            (unsigned int)dt->name_hash ));
1061                 if (dt->name_hash == name_hash) {
1062                         return dt;
1063                 }
1064         }
1065         return NULL;
1066 }
1067
1068 /****************************************************************************
1069  Return the NT token and UNIX token if there's a match. Return true if
1070  found, false if not.
1071 ****************************************************************************/
1072
1073 bool get_delete_on_close_token(struct share_mode_lock *lck,
1074                                         uint32_t name_hash,
1075                                         const struct security_token **pp_nt_tok,
1076                                         const struct security_unix_token **pp_tok)
1077 {
1078         struct delete_token *dt;
1079
1080         dt = find_delete_on_close_token(lck->data, name_hash);
1081         if (dt == NULL) {
1082                 return false;
1083         }
1084         *pp_nt_tok = dt->delete_nt_token;
1085         *pp_tok =  dt->delete_token;
1086         return true;
1087 }
1088
1089 bool is_delete_on_close_set(struct share_mode_lock *lck, uint32_t name_hash)
1090 {
1091         return find_delete_on_close_token(lck->data, name_hash) != NULL;
1092 }
1093
1094 bool set_sticky_write_time(struct file_id fileid, struct timespec write_time)
1095 {
1096         struct share_mode_lock *lck;
1097
1098         DEBUG(5,("set_sticky_write_time: %s id=%s\n",
1099                  timestring(talloc_tos(),
1100                             convert_timespec_to_time_t(write_time)),
1101                  file_id_string_tos(&fileid)));
1102
1103         lck = get_existing_share_mode_lock(talloc_tos(), fileid);
1104         if (lck == NULL) {
1105                 return False;
1106         }
1107
1108         if (timespec_compare(&lck->data->changed_write_time, &write_time) != 0) {
1109                 lck->data->modified = True;
1110                 lck->data->changed_write_time = write_time;
1111         }
1112
1113         TALLOC_FREE(lck);
1114         return True;
1115 }
1116
1117 bool set_write_time(struct file_id fileid, struct timespec write_time)
1118 {
1119         struct share_mode_lock *lck;
1120
1121         DEBUG(5,("set_write_time: %s id=%s\n",
1122                  timestring(talloc_tos(),
1123                             convert_timespec_to_time_t(write_time)),
1124                  file_id_string_tos(&fileid)));
1125
1126         lck = get_existing_share_mode_lock(talloc_tos(), fileid);
1127         if (lck == NULL) {
1128                 return False;
1129         }
1130
1131         if (timespec_compare(&lck->data->old_write_time, &write_time) != 0) {
1132                 lck->data->modified = True;
1133                 lck->data->old_write_time = write_time;
1134         }
1135
1136         TALLOC_FREE(lck);
1137         return True;
1138 }