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 "lib/util/server_id.h"
  41 #include "locking/proto.h"
  42 #include "smbd/globals.h"
  43 #include "dbwrap/dbwrap.h"
  44 #include "dbwrap/dbwrap_open.h"
  45 #include "../libcli/security/security.h"
  46 #include "serverid.h"
  47 #include "messages.h"
  48 #include "util_tdb.h"
  49 #include "../librpc/gen_ndr/ndr_open_files.h"
  50 #include "librpc/gen_ndr/ndr_file_id.h"
  51 #include "locking/leases_db.h"
  52
  53 #undef DBGC_CLASS
  54 #define DBGC_CLASS DBGC_LOCKING
  55
  56 #define NO_LOCKING_COUNT (-1)
  57
  58 /****************************************************************************
  59  Debugging aids :-).
  60 ****************************************************************************/
  61
  62 const char *lock_type_name(enum brl_type lock_type)
  63 {
  64         switch (lock_type) {
  65                 case READ_LOCK:
  66                         return "READ";
  67                 case WRITE_LOCK:
  68                         return "WRITE";
  69                 case PENDING_READ_LOCK:
  70                         return "PENDING_READ";
  71                 case PENDING_WRITE_LOCK:
  72                         return "PENDING_WRITE";
  73                 default:
  74                         return "other";
  75         }
  76 }
  77
  78 const char *lock_flav_name(enum brl_flavour lock_flav)
  79 {
  80         return (lock_flav == WINDOWS_LOCK) ? "WINDOWS_LOCK" : "POSIX_LOCK";
  81 }
  82
  83 /****************************************************************************
  84  Utility function called to see if a file region is locked.
  85  Called in the read/write codepath.
  86 ****************************************************************************/
  87
  88 void init_strict_lock_struct(files_struct *fsp,
  89                                 uint64_t smblctx,
  90                                 br_off start,
  91                                 br_off size,
  92                                 enum brl_type lock_type,
  93                                 struct lock_struct *plock)
  94 {
  95         SMB_ASSERT(lock_type == READ_LOCK || lock_type == WRITE_LOCK);
  96
  97         plock->context.smblctx = smblctx;
  98         plock->context.tid = fsp->conn->cnum;
  99         plock->context.pid = messaging_server_id(fsp->conn->sconn->msg_ctx);
 100         plock->start = start;
 101         plock->size = size;
 102         plock->fnum = fsp->fnum;
 103         plock->lock_type = lock_type;
 104         plock->lock_flav = lp_posix_cifsu_locktype(fsp);
 105 }
 106
 107 bool strict_lock_check_default(files_struct *fsp, struct lock_struct *plock)
 108 {
 109         struct byte_range_lock *br_lck;
 110         int strict_locking = lp_strict_locking(fsp->conn->params);
 111         bool ret = False;
 112
 113         if (plock->size == 0) {
 114                 return True;
 115         }
 116
 117         if (!lp_locking(fsp->conn->params) || !strict_locking) {
 118                 return True;
 119         }
 120
 121         if (strict_locking == Auto) {
 122                 uint32_t lease_type = fsp_lease_type(fsp);
 123
 124                 if ((lease_type & SMB2_LEASE_READ) &&
 125                      (plock->lock_type == READ_LOCK))
 126                 {
 127                         DBG_DEBUG("optimisation - read lease on file %s\n",
 128                                   fsp_str_dbg(fsp));
 129                         return true;
 130                 }
 131
 132                 if ((lease_type & SMB2_LEASE_WRITE) &&
 133                      (plock->lock_type == WRITE_LOCK))
 134                 {
 135                         DBG_DEBUG("optimisation - write lease on file %s\n",
 136                                   fsp_str_dbg(fsp));
 137                         return true;
 138                 }
 139         }
 140
 141         br_lck = brl_get_locks_readonly(fsp);
 142         if (!br_lck) {
 143                 return true;
 144         }
 145         ret = brl_locktest(br_lck, plock);
 146
 147         if (!ret) {
 148                 /*
 149                  * We got a lock conflict. Retry with rw locks to enable
 150                  * autocleanup. This is the slow path anyway.
 151                  */
 152                 br_lck = brl_get_locks(talloc_tos(), fsp);
 153                 ret = brl_locktest(br_lck, plock);
 154                 TALLOC_FREE(br_lck);
 155         }
 156
 157         DEBUG(10, ("strict_lock_default: flavour = %s brl start=%ju "
 158                    "len=%ju %s for fnum %ju file %s\n",
 159                    lock_flav_name(plock->lock_flav),
 160                    (uintmax_t)plock->start, (uintmax_t)plock->size,
 161                    ret ? "unlocked" : "locked",
 162                    (uintmax_t)plock->fnum, fsp_str_dbg(fsp)));
 163
 164         return ret;
 165 }
 166
 167 /****************************************************************************
 168  Find out if a lock could be granted - return who is blocking us if we can't.
 169 ****************************************************************************/
 170
 171 NTSTATUS query_lock(files_struct *fsp,
 172                         uint64_t *psmblctx,
 173                         uint64_t *pcount,
 174                         uint64_t *poffset,
 175                         enum brl_type *plock_type,
 176                         enum brl_flavour lock_flav)
 177 {
 178         struct byte_range_lock *br_lck = NULL;
 179
 180         if (!fsp->can_lock) {
 181                 return fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
 182         }
 183
 184         if (!lp_locking(fsp->conn->params)) {
 185                 return NT_STATUS_OK;
 186         }
 187
 188         br_lck = brl_get_locks_readonly(fsp);
 189         if (!br_lck) {
 190                 return NT_STATUS_NO_MEMORY;
 191         }
 192
 193         return brl_lockquery(br_lck,
 194                         psmblctx,
 195                         messaging_server_id(fsp->conn->sconn->msg_ctx),
 196                         poffset,
 197                         pcount,
 198                         plock_type,
 199                         lock_flav);
 200 }
 201
 202 static void increment_current_lock_count(files_struct *fsp,
 203     enum brl_flavour lock_flav)
 204 {
 205         if (lock_flav == WINDOWS_LOCK &&
 206             fsp->current_lock_count != NO_LOCKING_COUNT) {
 207                 /* blocking ie. pending, locks also count here,
 208                  * as this is an efficiency counter to avoid checking
 209                  * the lock db. on close. JRA. */
 210
 211                 fsp->current_lock_count++;
 212         } else {
 213                 /* Notice that this has had a POSIX lock request.
 214                  * We can't count locks after this so forget them.
 215                  */
 216                 fsp->current_lock_count = NO_LOCKING_COUNT;
 217         }
 218 }
 219
 220 static void decrement_current_lock_count(files_struct *fsp,
 221     enum brl_flavour lock_flav)
 222 {
 223         if (lock_flav == WINDOWS_LOCK &&
 224             fsp->current_lock_count != NO_LOCKING_COUNT) {
 225                 SMB_ASSERT(fsp->current_lock_count > 0);
 226                 fsp->current_lock_count--;
 227         }
 228 }
 229
 230 /****************************************************************************
 231  Utility function called by locking requests.
 232 ****************************************************************************/
 233
 234 struct byte_range_lock *do_lock(struct messaging_context *msg_ctx,
 235                         files_struct *fsp,
 236                         uint64_t smblctx,
 237                         uint64_t count,
 238                         uint64_t offset,
 239                         enum brl_type lock_type,
 240                         enum brl_flavour lock_flav,
 241                         bool blocking_lock,
 242                         NTSTATUS *perr,
 243                         uint64_t *psmblctx)
 244 {
 245         struct byte_range_lock *br_lck = NULL;
 246
 247         /* silently return ok on print files as we don't do locking there */
 248         if (fsp->print_file) {
 249                 *perr = NT_STATUS_OK;
 250                 return NULL;
 251         }
 252
 253         if (!fsp->can_lock) {
 254                 *perr = fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
 255                 return NULL;
 256         }
 257
 258         if (!lp_locking(fsp->conn->params)) {
 259                 *perr = NT_STATUS_OK;
 260                 return NULL;
 261         }
 262
 263         /* NOTE! 0 byte long ranges ARE allowed and should be stored  */
 264
 265         DEBUG(10,("do_lock: lock flavour %s lock type %s start=%ju len=%ju "
 266                 "blocking_lock=%s requested for %s file %s\n",
 267                 lock_flav_name(lock_flav), lock_type_name(lock_type),
 268                 (uintmax_t)offset, (uintmax_t)count, blocking_lock ? "true" :
 269                 "false", fsp_fnum_dbg(fsp), fsp_str_dbg(fsp)));
 270
 271         br_lck = brl_get_locks(talloc_tos(), fsp);
 272         if (!br_lck) {
 273                 *perr = NT_STATUS_NO_MEMORY;
 274                 return NULL;
 275         }
 276
 277         *perr = brl_lock(msg_ctx,
 278                         br_lck,
 279                         smblctx,
 280                         messaging_server_id(fsp->conn->sconn->msg_ctx),
 281                         offset,
 282                         count,
 283                         lock_type,
 284                         lock_flav,
 285                         blocking_lock,
 286                         psmblctx);
 287
 288         DEBUG(10, ("do_lock: returning status=%s\n", nt_errstr(*perr)));
 289
 290         increment_current_lock_count(fsp, lock_flav);
 291         return br_lck;
 292 }
 293
 294 /****************************************************************************
 295  Utility function called by unlocking requests.
 296 ****************************************************************************/
 297
 298 NTSTATUS do_unlock(struct messaging_context *msg_ctx,
 299                         files_struct *fsp,
 300                         uint64_t smblctx,
 301                         uint64_t count,
 302                         uint64_t offset,
 303                         enum brl_flavour lock_flav)
 304 {
 305         bool ok = False;
 306         struct byte_range_lock *br_lck = NULL;
 307
 308         if (!fsp->can_lock) {
 309                 return fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
 310         }
 311
 312         if (!lp_locking(fsp->conn->params)) {
 313                 return NT_STATUS_OK;
 314         }
 315
 316         DEBUG(10, ("do_unlock: unlock start=%ju len=%ju requested for %s file "
 317                    "%s\n", (uintmax_t)offset, (uintmax_t)count,
 318                    fsp_fnum_dbg(fsp), fsp_str_dbg(fsp)));
 319
 320         br_lck = brl_get_locks(talloc_tos(), fsp);
 321         if (!br_lck) {
 322                 return NT_STATUS_NO_MEMORY;
 323         }
 324
 325         ok = brl_unlock(msg_ctx,
 326                         br_lck,
 327                         smblctx,
 328                         messaging_server_id(fsp->conn->sconn->msg_ctx),
 329                         offset,
 330                         count,
 331                         lock_flav);
 332
 333         TALLOC_FREE(br_lck);
 334
 335         if (!ok) {
 336                 DEBUG(10,("do_unlock: returning ERRlock.\n" ));
 337                 return NT_STATUS_RANGE_NOT_LOCKED;
 338         }
 339
 340         decrement_current_lock_count(fsp, lock_flav);
 341         return NT_STATUS_OK;
 342 }
 343
 344 /****************************************************************************
 345  Cancel any pending blocked locks.
 346 ****************************************************************************/
 347
 348 NTSTATUS do_lock_cancel(files_struct *fsp,
 349                         uint64_t smblctx,
 350                         uint64_t count,
 351                         uint64_t offset,
 352                         enum brl_flavour lock_flav)
 353 {
 354         bool ok = False;
 355         struct byte_range_lock *br_lck = NULL;
 356
 357         if (!fsp->can_lock) {
 358                 return fsp->is_directory ?
 359                         NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
 360         }
 361
 362         if (!lp_locking(fsp->conn->params)) {
 363                 return NT_STATUS_DOS(ERRDOS, ERRcancelviolation);
 364         }
 365
 366         DEBUG(10, ("do_lock_cancel: cancel start=%ju len=%ju requested for "
 367                    "%s file %s\n", (uintmax_t)offset, (uintmax_t)count,
 368                    fsp_fnum_dbg(fsp), fsp_str_dbg(fsp)));
 369
 370         br_lck = brl_get_locks(talloc_tos(), fsp);
 371         if (!br_lck) {
 372                 return NT_STATUS_NO_MEMORY;
 373         }
 374
 375         ok = brl_lock_cancel(br_lck,
 376                         smblctx,
 377                         messaging_server_id(fsp->conn->sconn->msg_ctx),
 378                         offset,
 379                         count,
 380                         lock_flav);
 381
 382         TALLOC_FREE(br_lck);
 383
 384         if (!ok) {
 385                 DEBUG(10,("do_lock_cancel: returning ERRcancelviolation.\n" ));
 386                 return NT_STATUS_DOS(ERRDOS, ERRcancelviolation);
 387         }
 388
 389         decrement_current_lock_count(fsp, lock_flav);
 390         return NT_STATUS_OK;
 391 }
 392
 393 /****************************************************************************
 394  Remove any locks on this fd. Called from file_close().
 395 ****************************************************************************/
 396
 397 void locking_close_file(struct messaging_context *msg_ctx,
 398                         files_struct *fsp,
 399                         enum file_close_type close_type)
 400 {
 401         struct byte_range_lock *br_lck;
 402
 403         if (!lp_locking(fsp->conn->params)) {
 404                 return;
 405         }
 406
 407         /* If we have no outstanding locks or pending
 408          * locks then we don't need to look in the lock db.
 409          */
 410
 411         if (fsp->current_lock_count == 0) {
 412                 return;
 413         }
 414
 415         br_lck = brl_get_locks(talloc_tos(),fsp);
 416
 417         if (br_lck) {
 418                 cancel_pending_lock_requests_by_fid(fsp, br_lck, close_type);
 419                 brl_close_fnum(msg_ctx, br_lck);
 420                 TALLOC_FREE(br_lck);
 421         }
 422 }
 423
 424 /*******************************************************************
 425  Print out a share mode.
 426 ********************************************************************/
 427
 428 char *share_mode_str(TALLOC_CTX *ctx, int num,
 429                      const struct file_id *id,
 430                      const struct share_mode_entry *e)
 431 {
 432         struct server_id_buf tmp;
 433
 434         return talloc_asprintf(ctx, "share_mode_entry[%d]: "
 435                  "pid = %s, share_access = 0x%x, private_options = 0x%x, "
 436                  "access_mask = 0x%x, mid = 0x%llx, type= 0x%x, gen_id = %llu, "
 437                  "uid = %u, flags = %u, file_id %s, name_hash = 0x%x",
 438                  num,
 439                  server_id_str_buf(e->pid, &tmp),
 440                  e->share_access, e->private_options,
 441                  e->access_mask, (unsigned long long)e->op_mid,
 442                  e->op_type, (unsigned long long)e->share_file_id,
 443                  (unsigned int)e->uid, (unsigned int)e->flags,
 444                  file_id_string_tos(id),
 445                  (unsigned int)e->name_hash);
 446 }
 447
 448 /*******************************************************************
 449  Fetch a share mode where we know one MUST exist. This call reference
 450  counts it internally to allow for nested lock fetches.
 451 ********************************************************************/
 452
 453 struct share_mode_lock *get_existing_share_mode_lock(TALLOC_CTX *mem_ctx,
 454                                                      const struct file_id id)
 455 {
 456         return get_share_mode_lock(mem_ctx, id, NULL, NULL, NULL);
 457 }
 458
 459 /*******************************************************************
 460  Sets the service name and filename for rename.
 461  At this point we emit "file renamed" messages to all
 462  process id's that have this file open.
 463  Based on an initial code idea from SATOH Fumiyasu <fumiya@samba.gr.jp>
 464 ********************************************************************/
 465
 466 bool rename_share_filename(struct messaging_context *msg_ctx,
 467                         struct share_mode_lock *lck,
 468                         struct file_id id,
 469                         const char *servicepath,
 470                         uint32_t orig_name_hash,
 471                         uint32_t new_name_hash,
 472                         const struct smb_filename *smb_fname_dst)
 473 {
 474         struct share_mode_data *d = lck->data;
 475         size_t sp_len;
 476         size_t bn_len;
 477         size_t sn_len;
 478         size_t msg_len;
 479         char *frm = NULL;
 480         uint32_t i;
 481         bool strip_two_chars = false;
 482         bool has_stream = smb_fname_dst->stream_name != NULL;
 483         struct server_id self_pid = messaging_server_id(msg_ctx);
 484
 485         DEBUG(10, ("rename_share_filename: servicepath %s newname %s\n",
 486                    servicepath, smb_fname_dst->base_name));
 487
 488         /*
 489          * rename_internal_fsp() and rename_internals() add './' to
 490          * head of newname if newname does not contain a '/'.
 491          */
 492         if (smb_fname_dst->base_name[0] &&
 493             smb_fname_dst->base_name[1] &&
 494             smb_fname_dst->base_name[0] == '.' &&
 495             smb_fname_dst->base_name[1] == '/') {
 496                 strip_two_chars = true;
 497         }
 498
 499         d->servicepath = talloc_strdup(d, servicepath);
 500         d->base_name = talloc_strdup(d, smb_fname_dst->base_name +
 501                                        (strip_two_chars ? 2 : 0));
 502         d->stream_name = talloc_strdup(d, smb_fname_dst->stream_name);
 503         if (d->base_name == NULL ||
 504             (has_stream && d->stream_name == NULL) ||
 505             d->servicepath == NULL) {
 506                 DEBUG(0, ("rename_share_filename: talloc failed\n"));
 507                 return False;
 508         }
 509         d->modified = True;
 510
 511         sp_len = strlen(d->servicepath);
 512         bn_len = strlen(d->base_name);
 513         sn_len = has_stream ? strlen(d->stream_name) : 0;
 514
 515         msg_len = MSG_FILE_RENAMED_MIN_SIZE + sp_len + 1 + bn_len + 1 +
 516             sn_len + 1;
 517
 518         /* Set up the name changed message. */
 519         frm = talloc_array(d, char, msg_len);
 520         if (!frm) {
 521                 return False;
 522         }
 523
 524         push_file_id_24(frm, &id);
 525
 526         DEBUG(10,("rename_share_filename: msg_len = %u\n", (unsigned int)msg_len ));
 527
 528         strlcpy(&frm[24],
 529                 d->servicepath ? d->servicepath : "",
 530                 sp_len+1);
 531         strlcpy(&frm[24 + sp_len + 1],
 532                 d->base_name ? d->base_name : "",
 533                 bn_len+1);
 534         strlcpy(&frm[24 + sp_len + 1 + bn_len + 1],
 535                 d->stream_name ? d->stream_name : "",
 536                 sn_len+1);
 537
 538         /* Send the messages. */
 539         for (i=0; i<d->num_share_modes; i++) {
 540                 struct share_mode_entry *se = &d->share_modes[i];
 541                 struct server_id_buf tmp;
 542
 543                 if (!is_valid_share_mode_entry(se)) {
 544                         continue;
 545                 }
 546
 547                 /* If this is a hardlink to the inode
 548                    with a different name, skip this. */
 549                 if (se->name_hash != orig_name_hash) {
 550                         continue;
 551                 }
 552
 553                 se->name_hash = new_name_hash;
 554
 555                 /* But not to ourselves... */
 556                 if (serverid_equal(&se->pid, &self_pid)) {
 557                         continue;
 558                 }
 559
 560                 if (share_mode_stale_pid(d, i)) {
 561                         continue;
 562                 }
 563
 564                 DEBUG(10,("rename_share_filename: sending rename message to "
 565                           "pid %s file_id %s sharepath %s base_name %s "
 566                           "stream_name %s\n",
 567                           server_id_str_buf(se->pid, &tmp),
 568                           file_id_string_tos(&id),
 569                           d->servicepath, d->base_name,
 570                         has_stream ? d->stream_name : ""));
 571
 572                 messaging_send_buf(msg_ctx, se->pid, MSG_SMB_FILE_RENAME,
 573                                    (uint8_t *)frm, msg_len);
 574         }
 575
 576         for (i=0; i<d->num_leases; i++) {
 577                 /* Update the filename in leases_db. */
 578                 NTSTATUS status;
 579                 struct share_mode_lease *l;
 580
 581                 l = &d->leases[i];
 582
 583                 status = leases_db_rename(&l->client_guid,
 584                                         &l->lease_key,
 585                                         &id,
 586                                         d->servicepath,
 587                                         d->base_name,
 588                                         d->stream_name);
 589                 if (!NT_STATUS_IS_OK(status)) {
 590                         /* Any error recovery possible here ? */
 591                         DEBUG(1,("Failed to rename lease key for "
 592                                 "renamed file %s:%s. %s\n",
 593                                 d->base_name,
 594                                 d->stream_name,
 595                                 nt_errstr(status)));
 596                         continue;
 597                 }
 598         }
 599
 600         return True;
 601 }
 602
 603 void get_file_infos(struct file_id id,
 604                     uint32_t name_hash,
 605                     bool *delete_on_close,
 606                     struct timespec *write_time)
 607 {
 608         struct share_mode_lock *lck;
 609
 610         if (delete_on_close) {
 611                 *delete_on_close = false;
 612         }
 613
 614         if (write_time) {
 615                 ZERO_STRUCTP(write_time);
 616         }
 617
 618         if (!(lck = fetch_share_mode_unlocked(talloc_tos(), id))) {
 619                 return;
 620         }
 621
 622         if (delete_on_close) {
 623                 *delete_on_close = is_delete_on_close_set(lck, name_hash);
 624         }
 625
 626         if (write_time) {
 627                 *write_time = get_share_mode_write_time(lck);
 628         }
 629
 630         TALLOC_FREE(lck);
 631 }
 632
 633 bool is_valid_share_mode_entry(const struct share_mode_entry *e)
 634 {
 635         int num_props = 0;
 636
 637         if (e->stale) {
 638                 return false;
 639         }
 640
 641         num_props += ((e->op_type == NO_OPLOCK) ? 1 : 0);
 642         num_props += (EXCLUSIVE_OPLOCK_TYPE(e->op_type) ? 1 : 0);
 643         num_props += (LEVEL_II_OPLOCK_TYPE(e->op_type) ? 1 : 0);
 644         num_props += (e->op_type == LEASE_OPLOCK);
 645
 646         if ((num_props > 1) && serverid_exists(&e->pid)) {
 647                 smb_panic("Invalid share mode entry");
 648         }
 649         return (num_props != 0);
 650 }
 651
 652 /*
 653  * See if we need to remove a lease being referred to by a
 654  * share mode that is being marked stale or deleted.
 655  */
 656
 657 static void remove_share_mode_lease(struct share_mode_data *d,
 658                                     struct share_mode_entry *e)
 659 {
 660         struct GUID client_guid;
 661         struct smb2_lease_key lease_key;
 662         uint16_t op_type;
 663         uint32_t lease_idx;
 664         uint32_t i;
 665
 666         op_type = e->op_type;
 667         e->op_type = NO_OPLOCK;
 668
 669         d->modified = true;
 670
 671         if (op_type != LEASE_OPLOCK) {
 672                 return;
 673         }
 674
 675         /*
 676          * This used to reference a lease. If there's no other one referencing
 677          * it, remove it.
 678          */
 679
 680         lease_idx = e->lease_idx;
 681         e->lease_idx = UINT32_MAX;
 682
 683         for (i=0; i<d->num_share_modes; i++) {
 684                 if (d->share_modes[i].stale) {
 685                         continue;
 686                 }
 687                 if (e == &d->share_modes[i]) {
 688                         /* Not ourselves. */
 689                         continue;
 690                 }
 691                 if (d->share_modes[i].lease_idx == lease_idx) {
 692                         break;
 693                 }
 694         }
 695         if (i < d->num_share_modes) {
 696                 /*
 697                  * Found another one
 698                  */
 699                 return;
 700         }
 701
 702         memcpy(&client_guid,
 703                 &d->leases[lease_idx].client_guid,
 704                 sizeof(client_guid));
 705         lease_key = d->leases[lease_idx].lease_key;
 706
 707         d->num_leases -= 1;
 708         d->leases[lease_idx] = d->leases[d->num_leases];
 709
 710         /*
 711          * We changed the lease array. Fix all references to it.
 712          */
 713         for (i=0; i<d->num_share_modes; i++) {
 714                 if (d->share_modes[i].lease_idx == d->num_leases) {
 715                         d->share_modes[i].lease_idx = lease_idx;
 716                         d->share_modes[i].lease = &d->leases[lease_idx];
 717                 }
 718         }
 719
 720         {
 721                 NTSTATUS status;
 722
 723                 status = leases_db_del(&client_guid,
 724                                         &lease_key,
 725                                         &e->id);
 726
 727                 DEBUG(10, ("%s: leases_db_del returned %s\n", __func__,
 728                            nt_errstr(status)));
 729         }
 730 }
 731
 732 /*
 733  * In case d->share_modes[i] conflicts with something or otherwise is
 734  * being used, we need to make sure the corresponding process still
 735  * exists.
 736  */
 737 bool share_mode_stale_pid(struct share_mode_data *d, uint32_t idx)
 738 {
 739         struct server_id_buf tmp;
 740         struct share_mode_entry *e;
 741
 742         if (idx > d->num_share_modes) {
 743                 DEBUG(1, ("Asking for index %u, only %u around\n",
 744                           idx, (unsigned)d->num_share_modes));
 745                 return false;
 746         }
 747         e = &d->share_modes[idx];
 748         if (e->stale) {
 749                 /*
 750                  * Checked before
 751                  */
 752                 return true;
 753         }
 754         if (serverid_exists(&e->pid)) {
 755                 DEBUG(10, ("PID %s (index %u out of %u) still exists\n",
 756                            server_id_str_buf(e->pid, &tmp), idx,
 757                            (unsigned)d->num_share_modes));
 758                 return false;
 759         }
 760         DEBUG(10, ("PID %s (index %u out of %u) does not exist anymore\n",
 761                    server_id_str_buf(e->pid, &tmp), idx,
 762                    (unsigned)d->num_share_modes));
 763
 764         e->stale = true;
 765
 766         if (d->num_delete_tokens != 0) {
 767                 uint32_t i, num_stale;
 768
 769                 /*
 770                  * We cannot have any delete tokens
 771                  * if there are no valid share modes.
 772                  */
 773
 774                 num_stale = 0;
 775
 776                 for (i=0; i<d->num_share_modes; i++) {
 777                         if (d->share_modes[i].stale) {
 778                                 num_stale += 1;
 779                         }
 780                 }
 781
 782                 if (num_stale == d->num_share_modes) {
 783                         /*
 784                          * No non-stale share mode found
 785                          */
 786                         TALLOC_FREE(d->delete_tokens);
 787                         d->num_delete_tokens = 0;
 788                 }
 789         }
 790
 791         remove_share_mode_lease(d, e);
 792
 793         d->modified = true;
 794         return true;
 795 }
 796
 797 void remove_stale_share_mode_entries(struct share_mode_data *d)
 798 {
 799         uint32_t i;
 800
 801         i = 0;
 802         while (i < d->num_share_modes) {
 803                 if (d->share_modes[i].stale) {
 804                         struct share_mode_entry *m = d->share_modes;
 805                         m[i] = m[d->num_share_modes-1];
 806                         d->num_share_modes -= 1;
 807                 } else {
 808                         i += 1;
 809                 }
 810         }
 811 }
 812
 813 bool set_share_mode(struct share_mode_lock *lck, struct files_struct *fsp,
 814                     uid_t uid, uint64_t mid, uint16_t op_type,
 815                     uint32_t lease_idx)
 816 {
 817         struct share_mode_data *d = lck->data;
 818         struct share_mode_entry *tmp, *e;
 819         struct share_mode_lease *lease = NULL;
 820
 821         if (lease_idx == UINT32_MAX) {
 822                 lease = NULL;
 823         } else if (lease_idx >= d->num_leases) {
 824                 return false;
 825         } else {
 826                 lease = &d->leases[lease_idx];
 827         }
 828
 829         tmp = talloc_realloc(d, d->share_modes, struct share_mode_entry,
 830                              d->num_share_modes+1);
 831         if (tmp == NULL) {
 832                 return false;
 833         }
 834         d->share_modes = tmp;
 835         e = &d->share_modes[d->num_share_modes];
 836         d->num_share_modes += 1;
 837         d->modified = true;
 838
 839         ZERO_STRUCTP(e);
 840         e->pid = messaging_server_id(fsp->conn->sconn->msg_ctx);
 841         e->share_access = fsp->share_access;
 842         e->private_options = fsp->fh->private_options;
 843         e->access_mask = fsp->access_mask;
 844         e->op_mid = mid;
 845         e->op_type = op_type;
 846         e->lease_idx = lease_idx;
 847         e->lease = lease;
 848         e->time.tv_sec = fsp->open_time.tv_sec;
 849         e->time.tv_usec = fsp->open_time.tv_usec;
 850         e->id = fsp->file_id;
 851         e->share_file_id = fsp->fh->gen_id;
 852         e->uid = (uint32_t)uid;
 853         e->flags = (fsp->posix_flags & FSP_POSIX_FLAGS_OPEN) ?
 854                 SHARE_MODE_FLAG_POSIX_OPEN : 0;
 855         e->name_hash = fsp->name_hash;
 856
 857         return true;
 858 }
 859
 860 struct share_mode_entry *find_share_mode_entry(
 861         struct share_mode_lock *lck, files_struct *fsp)
 862 {
 863         struct share_mode_data *d = lck->data;
 864         struct server_id pid;
 865         uint32_t i;
 866
 867         pid = messaging_server_id(fsp->conn->sconn->msg_ctx);
 868
 869         for (i=0; i<d->num_share_modes; i++) {
 870                 struct share_mode_entry *e = &d->share_modes[i];
 871
 872                 if (!is_valid_share_mode_entry(e)) {
 873                         continue;
 874                 }
 875                 if (!serverid_equal(&pid, &e->pid)) {
 876                         continue;
 877                 }
 878                 if (!file_id_equal(&fsp->file_id, &e->id)) {
 879                         continue;
 880                 }
 881                 if (fsp->fh->gen_id != e->share_file_id) {
 882                         continue;
 883                 }
 884                 return e;
 885         }
 886         return NULL;
 887 }
 888
 889 /*******************************************************************
 890  Del the share mode of a file for this process. Return the number of
 891  entries left.
 892 ********************************************************************/
 893
 894 bool del_share_mode(struct share_mode_lock *lck, files_struct *fsp)
 895 {
 896         struct share_mode_entry *e;
 897
 898         e = find_share_mode_entry(lck, fsp);
 899         if (e == NULL) {
 900                 return False;
 901         }
 902         remove_share_mode_lease(lck->data, e);
 903         *e = lck->data->share_modes[lck->data->num_share_modes-1];
 904         lck->data->num_share_modes -= 1;
 905         lck->data->modified = True;
 906         return True;
 907 }
 908
 909 bool mark_share_mode_disconnected(struct share_mode_lock *lck,
 910                                   struct files_struct *fsp)
 911 {
 912         struct share_mode_entry *e;
 913
 914         if (lck->data->num_share_modes != 1) {
 915                 return false;
 916         }
 917
 918         if (fsp->op == NULL) {
 919                 return false;
 920         }
 921         if (!fsp->op->global->durable) {
 922                 return false;
 923         }
 924
 925         e = find_share_mode_entry(lck, fsp);
 926         if (e == NULL) {
 927                 return false;
 928         }
 929
 930         DEBUG(10, ("Marking share mode entry disconnected for durable handle\n"));
 931
 932         server_id_set_disconnected(&e->pid);
 933
 934         /*
 935          * On reopen the caller needs to check that
 936          * the client comes with the correct handle.
 937          */
 938         e->share_file_id = fsp->op->global->open_persistent_id;
 939
 940         lck->data->modified = true;
 941         return true;
 942 }
 943
 944 /*******************************************************************
 945  Remove an oplock mid and mode entry from a share mode.
 946 ********************************************************************/
 947
 948 bool remove_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
 949 {
 950         struct share_mode_data *d = lck->data;
 951         struct share_mode_entry *e;
 952
 953         e = find_share_mode_entry(lck, fsp);
 954         if (e == NULL) {
 955                 return False;
 956         }
 957
 958         remove_share_mode_lease(d, e);
 959         d->modified = True;
 960         return true;
 961 }
 962
 963 /*******************************************************************
 964  Downgrade a oplock type from exclusive to level II.
 965 ********************************************************************/
 966
 967 bool downgrade_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
 968 {
 969         struct share_mode_entry *e;
 970
 971         e = find_share_mode_entry(lck, fsp);
 972         if (e == NULL) {
 973                 return False;
 974         }
 975
 976         e->op_type = LEVEL_II_OPLOCK;
 977         lck->data->modified = True;
 978         return True;
 979 }
 980
 981 NTSTATUS downgrade_share_lease(struct smbd_server_connection *sconn,
 982                                struct share_mode_lock *lck,
 983                                const struct smb2_lease_key *key,
 984                                uint32_t new_lease_state,
 985                                struct share_mode_lease **_l)
 986 {
 987         struct share_mode_data *d = lck->data;
 988         struct share_mode_lease *l;
 989         uint32_t i;
 990
 991         *_l = NULL;
 992
 993         for (i=0; i<d->num_leases; i++) {
 994                 if (smb2_lease_equal(&sconn->client->connections->smb2.client.guid,
 995                                      key,
 996                                      &d->leases[i].client_guid,
 997                                      &d->leases[i].lease_key)) {
 998                         break;
 999                 }
1000         }
1001         if (i == d->num_leases) {
1002                 DEBUG(10, ("lease not found\n"));
1003                 return NT_STATUS_INVALID_PARAMETER;
1004         }
1005
1006         l = &d->leases[i];
1007
1008         if (!l->breaking) {
1009                 DEBUG(1, ("Attempt to break from %d to %d - but we're not in breaking state\n",
1010                            (int)l->current_state, (int)new_lease_state));
1011                 return NT_STATUS_UNSUCCESSFUL;
1012         }
1013
1014         /*
1015          * Can't upgrade anything: l->breaking_to_requested (and l->current_state)
1016          * must be a strict bitwise superset of new_lease_state
1017          */
1018         if ((new_lease_state & l->breaking_to_requested) != new_lease_state) {
1019                 DEBUG(1, ("Attempt to upgrade from %d to %d - expected %d\n",
1020                            (int)l->current_state, (int)new_lease_state,
1021                            (int)l->breaking_to_requested));
1022                 return NT_STATUS_REQUEST_NOT_ACCEPTED;
1023         }
1024
1025         if (l->current_state != new_lease_state) {
1026                 l->current_state = new_lease_state;
1027                 d->modified = true;
1028         }
1029
1030         if ((new_lease_state & ~l->breaking_to_required) != 0) {
1031                 DEBUG(5, ("lease state %d not fully broken from %d to %d\n",
1032                            (int)new_lease_state,
1033                            (int)l->current_state,
1034                            (int)l->breaking_to_required));
1035                 l->breaking_to_requested = l->breaking_to_required;
1036                 if (l->current_state & (~SMB2_LEASE_READ)) {
1037                         /*
1038                          * Here we break in steps, as windows does
1039                          * see the breaking3 and v2_breaking3 tests.
1040                          */
1041                         l->breaking_to_requested |= SMB2_LEASE_READ;
1042                 }
1043                 d->modified = true;
1044                 *_l = l;
1045                 return NT_STATUS_OPLOCK_BREAK_IN_PROGRESS;
1046         }
1047
1048         DEBUG(10, ("breaking from %d to %d - expected %d\n",
1049                    (int)l->current_state, (int)new_lease_state,
1050                    (int)l->breaking_to_requested));
1051
1052         l->breaking_to_requested = 0;
1053         l->breaking_to_required = 0;
1054         l->breaking = false;
1055
1056         d->modified = true;
1057
1058         return NT_STATUS_OK;
1059 }
1060
1061 /****************************************************************************
1062  Adds a delete on close token.
1063 ****************************************************************************/
1064
1065 static bool add_delete_on_close_token(struct share_mode_data *d,
1066                         uint32_t name_hash,
1067                         const struct security_token *nt_tok,
1068                         const struct security_unix_token *tok)
1069 {
1070         struct delete_token *tmp, *dtl;
1071
1072         tmp = talloc_realloc(d, d->delete_tokens, struct delete_token,
1073                              d->num_delete_tokens+1);
1074         if (tmp == NULL) {
1075                 return false;
1076         }
1077         d->delete_tokens = tmp;
1078         dtl = &d->delete_tokens[d->num_delete_tokens];
1079
1080         dtl->name_hash = name_hash;
1081         dtl->delete_nt_token = dup_nt_token(d->delete_tokens, nt_tok);
1082         if (dtl->delete_nt_token == NULL) {
1083                 return false;
1084         }
1085         dtl->delete_token = copy_unix_token(d->delete_tokens, tok);
1086         if (dtl->delete_token == NULL) {
1087                 return false;
1088         }
1089         d->num_delete_tokens += 1;
1090         d->modified = true;
1091         return true;
1092 }
1093
1094 void reset_delete_on_close_lck(files_struct *fsp,
1095                                struct share_mode_lock *lck)
1096 {
1097         struct share_mode_data *d = lck->data;
1098         uint32_t i;
1099
1100         for (i=0; i<d->num_delete_tokens; i++) {
1101                 struct delete_token *dt = &d->delete_tokens[i];
1102
1103                 if (dt->name_hash == fsp->name_hash) {
1104                         d->modified = true;
1105
1106                         /* Delete this entry. */
1107                         TALLOC_FREE(dt->delete_nt_token);
1108                         TALLOC_FREE(dt->delete_token);
1109                         *dt = d->delete_tokens[d->num_delete_tokens-1];
1110                         d->num_delete_tokens -= 1;
1111                 }
1112         }
1113 }
1114
1115 /****************************************************************************
1116  Sets the delete on close flag over all share modes on this file.
1117  Modify the share mode entry for all files open
1118  on this device and inode to tell other smbds we have
1119  changed the delete on close flag. This will be noticed
1120  in the close code, the last closer will delete the file
1121  if flag is set.
1122  This makes a copy of any struct security_unix_token into the
1123  lck entry. This function is used when the lock is already granted.
1124 ****************************************************************************/
1125
1126 void set_delete_on_close_lck(files_struct *fsp,
1127                         struct share_mode_lock *lck,
1128                         const struct security_token *nt_tok,
1129                         const struct security_unix_token *tok)
1130 {
1131         struct messaging_context *msg_ctx = fsp->conn->sconn->msg_ctx;
1132         struct share_mode_data *d = lck->data;
1133         uint32_t i;
1134         bool ret;
1135         DATA_BLOB fid_blob = {};
1136         enum ndr_err_code ndr_err;
1137
1138         SMB_ASSERT(nt_tok != NULL);
1139         SMB_ASSERT(tok != NULL);
1140
1141         for (i=0; i<d->num_delete_tokens; i++) {
1142                 struct delete_token *dt = &d->delete_tokens[i];
1143                 if (dt->name_hash == fsp->name_hash) {
1144                         d->modified = true;
1145
1146                         /* Replace this token with the given tok. */
1147                         TALLOC_FREE(dt->delete_nt_token);
1148                         dt->delete_nt_token = dup_nt_token(dt, nt_tok);
1149                         SMB_ASSERT(dt->delete_nt_token != NULL);
1150                         TALLOC_FREE(dt->delete_token);
1151                         dt->delete_token = copy_unix_token(dt, tok);
1152                         SMB_ASSERT(dt->delete_token != NULL);
1153
1154                         return;
1155                 }
1156         }
1157
1158         ret = add_delete_on_close_token(lck->data, fsp->name_hash, nt_tok, tok);
1159         SMB_ASSERT(ret);
1160
1161         ndr_err = ndr_push_struct_blob(&fid_blob, talloc_tos(), &fsp->file_id,
1162                                        (ndr_push_flags_fn_t)ndr_push_file_id);
1163         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1164                 DEBUG(10, ("ndr_push_file_id failed: %s\n",
1165                            ndr_errstr(ndr_err)));
1166         }
1167
1168         for (i=0; i<d->num_share_modes; i++) {
1169                 struct share_mode_entry *e = &d->share_modes[i];
1170                 NTSTATUS status;
1171
1172                 status = messaging_send(
1173                         msg_ctx, e->pid, MSG_SMB_NOTIFY_CANCEL_DELETED,
1174                         &fid_blob);
1175
1176                 if (!NT_STATUS_IS_OK(status)) {
1177                         struct server_id_buf tmp;
1178                         DEBUG(10, ("%s: messaging_send to %s returned %s\n",
1179                                    __func__, server_id_str_buf(e->pid, &tmp),
1180                                    nt_errstr(status)));
1181                 }
1182         }
1183
1184         TALLOC_FREE(fid_blob.data);
1185 }
1186
1187 bool set_delete_on_close(files_struct *fsp, bool delete_on_close,
1188                         const struct security_token *nt_tok,
1189                         const struct security_unix_token *tok)
1190 {
1191         struct share_mode_lock *lck;
1192
1193         DEBUG(10,("set_delete_on_close: %s delete on close flag for "
1194                   "%s, file %s\n",
1195                   delete_on_close ? "Adding" : "Removing", fsp_fnum_dbg(fsp),
1196                   fsp_str_dbg(fsp)));
1197
1198         lck = get_existing_share_mode_lock(talloc_tos(), fsp->file_id);
1199         if (lck == NULL) {
1200                 return False;
1201         }
1202
1203         if (delete_on_close) {
1204                 set_delete_on_close_lck(fsp, lck, nt_tok, tok);
1205         } else {
1206                 reset_delete_on_close_lck(fsp, lck);
1207         }
1208
1209         if (fsp->is_directory) {
1210                 SMB_ASSERT(!is_ntfs_stream_smb_fname(fsp->fsp_name));
1211                 send_stat_cache_delete_message(fsp->conn->sconn->msg_ctx,
1212                                                fsp->fsp_name->base_name);
1213         }
1214
1215         TALLOC_FREE(lck);
1216
1217         fsp->delete_on_close = delete_on_close;
1218
1219         return True;
1220 }
1221
1222 static struct delete_token *find_delete_on_close_token(
1223         struct share_mode_data *d, uint32_t name_hash)
1224 {
1225         uint32_t i;
1226
1227         DEBUG(10, ("find_delete_on_close_token: name_hash = 0x%x\n",
1228                    (unsigned int)name_hash));
1229
1230         for (i=0; i<d->num_delete_tokens; i++) {
1231                 struct delete_token *dt = &d->delete_tokens[i];
1232
1233                 DEBUG(10, ("find__delete_on_close_token: dt->name_hash = 0x%x\n",
1234                            (unsigned int)dt->name_hash ));
1235                 if (dt->name_hash == name_hash) {
1236                         return dt;
1237                 }
1238         }
1239         return NULL;
1240 }
1241
1242 /****************************************************************************
1243  Return the NT token and UNIX token if there's a match. Return true if
1244  found, false if not.
1245 ****************************************************************************/
1246
1247 bool get_delete_on_close_token(struct share_mode_lock *lck,
1248                                         uint32_t name_hash,
1249                                         const struct security_token **pp_nt_tok,
1250                                         const struct security_unix_token **pp_tok)
1251 {
1252         struct delete_token *dt;
1253
1254         dt = find_delete_on_close_token(lck->data, name_hash);
1255         if (dt == NULL) {
1256                 return false;
1257         }
1258         *pp_nt_tok = dt->delete_nt_token;
1259         *pp_tok =  dt->delete_token;
1260         return true;
1261 }
1262
1263 bool is_delete_on_close_set(struct share_mode_lock *lck, uint32_t name_hash)
1264 {
1265         return find_delete_on_close_token(lck->data, name_hash) != NULL;
1266 }
1267
1268 bool set_sticky_write_time(struct file_id fileid, struct timespec write_time)
1269 {
1270         struct share_mode_lock *lck;
1271
1272         DEBUG(5,("set_sticky_write_time: %s id=%s\n",
1273                  timestring(talloc_tos(),
1274                             convert_timespec_to_time_t(write_time)),
1275                  file_id_string_tos(&fileid)));
1276
1277         lck = get_existing_share_mode_lock(talloc_tos(), fileid);
1278         if (lck == NULL) {
1279                 return False;
1280         }
1281
1282         if (timespec_compare(&lck->data->changed_write_time, &write_time) != 0) {
1283                 lck->data->modified = True;
1284                 lck->data->changed_write_time = write_time;
1285         }
1286
1287         TALLOC_FREE(lck);
1288         return True;
1289 }
1290
1291 bool set_write_time(struct file_id fileid, struct timespec write_time)
1292 {
1293         struct share_mode_lock *lck;
1294
1295         DEBUG(5,("set_write_time: %s id=%s\n",
1296                  timestring(talloc_tos(),
1297                             convert_timespec_to_time_t(write_time)),
1298                  file_id_string_tos(&fileid)));
1299
1300         lck = get_existing_share_mode_lock(talloc_tos(), fileid);
1301         if (lck == NULL) {
1302                 return False;
1303         }
1304
1305         if (timespec_compare(&lck->data->old_write_time, &write_time) != 0) {
1306                 lck->data->modified = True;
1307                 lck->data->old_write_time = write_time;
1308         }
1309
1310         TALLOC_FREE(lck);
1311         return True;
1312 }
1313
1314 struct timespec get_share_mode_write_time(struct share_mode_lock *lck)
1315 {
1316         struct share_mode_data *d = lck->data;
1317
1318         if (!null_timespec(d->changed_write_time)) {
1319                 return d->changed_write_time;
1320         }
1321         return d->old_write_time;
1322 }