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                 }
 717         }
 718
 719         {
 720                 NTSTATUS status;
 721
 722                 status = leases_db_del(&client_guid,
 723                                         &lease_key,
 724                                         &d->id);
 725
 726                 DEBUG(10, ("%s: leases_db_del returned %s\n", __func__,
 727                            nt_errstr(status)));
 728         }
 729 }
 730
 731 /*
 732  * In case d->share_modes[i] conflicts with something or otherwise is
 733  * being used, we need to make sure the corresponding process still
 734  * exists.
 735  */
 736 bool share_mode_stale_pid(struct share_mode_data *d, uint32_t idx)
 737 {
 738         struct server_id_buf tmp;
 739         struct share_mode_entry *e;
 740
 741         if (idx > d->num_share_modes) {
 742                 DBG_WARNING("Asking for index %"PRIu32", "
 743                             "only %"PRIu32" around\n",
 744                             idx,
 745                             d->num_share_modes);
 746                 return false;
 747         }
 748         e = &d->share_modes[idx];
 749         if (e->stale) {
 750                 /*
 751                  * Checked before
 752                  */
 753                 return true;
 754         }
 755         if (serverid_exists(&e->pid)) {
 756                 DBG_DEBUG("PID %s (index %"PRIu32" out of %"PRIu32") "
 757                           "still exists\n",
 758                           server_id_str_buf(e->pid, &tmp),
 759                           idx,
 760                           d->num_share_modes);
 761                 return false;
 762         }
 763         DBG_DEBUG("PID %s (index %"PRIu32" out of %"PRIu32") "
 764                   "does not exist anymore\n",
 765                   server_id_str_buf(e->pid, &tmp),
 766                   idx,
 767                   d->num_share_modes);
 768
 769         e->stale = true;
 770
 771         if (d->num_delete_tokens != 0) {
 772                 uint32_t i, num_stale;
 773
 774                 /*
 775                  * We cannot have any delete tokens
 776                  * if there are no valid share modes.
 777                  */
 778
 779                 num_stale = 0;
 780
 781                 for (i=0; i<d->num_share_modes; i++) {
 782                         if (d->share_modes[i].stale) {
 783                                 num_stale += 1;
 784                         }
 785                 }
 786
 787                 if (num_stale == d->num_share_modes) {
 788                         /*
 789                          * No non-stale share mode found
 790                          */
 791                         TALLOC_FREE(d->delete_tokens);
 792                         d->num_delete_tokens = 0;
 793                 }
 794         }
 795
 796         remove_share_mode_lease(d, e);
 797
 798         d->modified = true;
 799         return true;
 800 }
 801
 802 void remove_stale_share_mode_entries(struct share_mode_data *d)
 803 {
 804         uint32_t i;
 805
 806         i = 0;
 807         while (i < d->num_share_modes) {
 808                 if (d->share_modes[i].stale) {
 809                         struct share_mode_entry *m = d->share_modes;
 810                         m[i] = m[d->num_share_modes-1];
 811                         d->num_share_modes -= 1;
 812                 } else {
 813                         i += 1;
 814                 }
 815         }
 816 }
 817
 818 bool set_share_mode(struct share_mode_lock *lck, struct files_struct *fsp,
 819                     uid_t uid, uint64_t mid, uint16_t op_type,
 820                     uint32_t lease_idx)
 821 {
 822         struct share_mode_data *d = lck->data;
 823         struct share_mode_entry *tmp, *e;
 824
 825         if ((lease_idx != UINT32_MAX) &&
 826             (lease_idx >= d->num_leases)) {
 827                 return false;
 828         }
 829
 830         tmp = talloc_realloc(d, d->share_modes, struct share_mode_entry,
 831                              d->num_share_modes+1);
 832         if (tmp == NULL) {
 833                 return false;
 834         }
 835         d->share_modes = tmp;
 836         e = &d->share_modes[d->num_share_modes];
 837         d->num_share_modes += 1;
 838         d->modified = true;
 839
 840         ZERO_STRUCTP(e);
 841         e->pid = messaging_server_id(fsp->conn->sconn->msg_ctx);
 842         e->share_access = fsp->share_access;
 843         e->private_options = fsp->fh->private_options;
 844         e->access_mask = fsp->access_mask;
 845         e->op_mid = mid;
 846         e->op_type = op_type;
 847         e->lease_idx = lease_idx;
 848         e->time.tv_sec = fsp->open_time.tv_sec;
 849         e->time.tv_usec = fsp->open_time.tv_usec;
 850         e->share_file_id = fsp->fh->gen_id;
 851         e->uid = (uint32_t)uid;
 852         e->flags = (fsp->posix_flags & FSP_POSIX_FLAGS_OPEN) ?
 853                 SHARE_MODE_FLAG_POSIX_OPEN : 0;
 854         e->name_hash = fsp->name_hash;
 855
 856         return true;
 857 }
 858
 859 struct share_mode_entry *find_share_mode_entry(
 860         struct share_mode_lock *lck, files_struct *fsp)
 861 {
 862         struct share_mode_data *d = lck->data;
 863         struct server_id pid;
 864         uint32_t i;
 865
 866         pid = messaging_server_id(fsp->conn->sconn->msg_ctx);
 867
 868         for (i=0; i<d->num_share_modes; i++) {
 869                 struct share_mode_entry *e = &d->share_modes[i];
 870
 871                 if (!is_valid_share_mode_entry(e)) {
 872                         continue;
 873                 }
 874                 if (!serverid_equal(&pid, &e->pid)) {
 875                         continue;
 876                 }
 877                 if (fsp->fh->gen_id != e->share_file_id) {
 878                         continue;
 879                 }
 880                 return e;
 881         }
 882         return NULL;
 883 }
 884
 885 /*******************************************************************
 886  Del the share mode of a file for this process. Return the number of
 887  entries left.
 888 ********************************************************************/
 889
 890 bool del_share_mode(struct share_mode_lock *lck, files_struct *fsp)
 891 {
 892         struct share_mode_entry *e;
 893
 894         e = find_share_mode_entry(lck, fsp);
 895         if (e == NULL) {
 896                 return False;
 897         }
 898         remove_share_mode_lease(lck->data, e);
 899         *e = lck->data->share_modes[lck->data->num_share_modes-1];
 900         lck->data->num_share_modes -= 1;
 901         lck->data->modified = True;
 902         return True;
 903 }
 904
 905 bool mark_share_mode_disconnected(struct share_mode_lock *lck,
 906                                   struct files_struct *fsp)
 907 {
 908         struct share_mode_entry *e;
 909
 910         if (lck->data->num_share_modes != 1) {
 911                 return false;
 912         }
 913
 914         if (fsp->op == NULL) {
 915                 return false;
 916         }
 917         if (!fsp->op->global->durable) {
 918                 return false;
 919         }
 920
 921         e = find_share_mode_entry(lck, fsp);
 922         if (e == NULL) {
 923                 return false;
 924         }
 925
 926         DEBUG(10, ("Marking share mode entry disconnected for durable handle\n"));
 927
 928         server_id_set_disconnected(&e->pid);
 929
 930         /*
 931          * On reopen the caller needs to check that
 932          * the client comes with the correct handle.
 933          */
 934         e->share_file_id = fsp->op->global->open_persistent_id;
 935
 936         lck->data->modified = true;
 937         return true;
 938 }
 939
 940 /*******************************************************************
 941  Remove an oplock mid and mode entry from a share mode.
 942 ********************************************************************/
 943
 944 bool remove_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
 945 {
 946         struct share_mode_data *d = lck->data;
 947         struct share_mode_entry *e;
 948
 949         e = find_share_mode_entry(lck, fsp);
 950         if (e == NULL) {
 951                 return False;
 952         }
 953
 954         remove_share_mode_lease(d, e);
 955         d->modified = True;
 956         return true;
 957 }
 958
 959 /*******************************************************************
 960  Downgrade a oplock type from exclusive to level II.
 961 ********************************************************************/
 962
 963 bool downgrade_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
 964 {
 965         struct share_mode_entry *e;
 966
 967         e = find_share_mode_entry(lck, fsp);
 968         if (e == NULL) {
 969                 return False;
 970         }
 971
 972         e->op_type = LEVEL_II_OPLOCK;
 973         lck->data->modified = True;
 974         return True;
 975 }
 976
 977 NTSTATUS downgrade_share_lease(struct smbd_server_connection *sconn,
 978                                struct share_mode_lock *lck,
 979                                const struct smb2_lease_key *key,
 980                                uint32_t new_lease_state,
 981                                struct share_mode_lease **_l)
 982 {
 983         struct share_mode_data *d = lck->data;
 984         struct share_mode_lease *l;
 985         uint32_t i;
 986
 987         *_l = NULL;
 988
 989         for (i=0; i<d->num_leases; i++) {
 990                 if (smb2_lease_equal(&sconn->client->connections->smb2.client.guid,
 991                                      key,
 992                                      &d->leases[i].client_guid,
 993                                      &d->leases[i].lease_key)) {
 994                         break;
 995                 }
 996         }
 997         if (i == d->num_leases) {
 998                 DEBUG(10, ("lease not found\n"));
 999                 return NT_STATUS_INVALID_PARAMETER;
1000         }
1001
1002         l = &d->leases[i];
1003
1004         if (!l->breaking) {
1005                 DEBUG(1, ("Attempt to break from %d to %d - but we're not in breaking state\n",
1006                            (int)l->current_state, (int)new_lease_state));
1007                 return NT_STATUS_UNSUCCESSFUL;
1008         }
1009
1010         /*
1011          * Can't upgrade anything: l->breaking_to_requested (and l->current_state)
1012          * must be a strict bitwise superset of new_lease_state
1013          */
1014         if ((new_lease_state & l->breaking_to_requested) != new_lease_state) {
1015                 DEBUG(1, ("Attempt to upgrade from %d to %d - expected %d\n",
1016                            (int)l->current_state, (int)new_lease_state,
1017                            (int)l->breaking_to_requested));
1018                 return NT_STATUS_REQUEST_NOT_ACCEPTED;
1019         }
1020
1021         if (l->current_state != new_lease_state) {
1022                 l->current_state = new_lease_state;
1023                 d->modified = true;
1024         }
1025
1026         if ((new_lease_state & ~l->breaking_to_required) != 0) {
1027                 DEBUG(5, ("lease state %d not fully broken from %d to %d\n",
1028                            (int)new_lease_state,
1029                            (int)l->current_state,
1030                            (int)l->breaking_to_required));
1031                 l->breaking_to_requested = l->breaking_to_required;
1032                 if (l->current_state & (~SMB2_LEASE_READ)) {
1033                         /*
1034                          * Here we break in steps, as windows does
1035                          * see the breaking3 and v2_breaking3 tests.
1036                          */
1037                         l->breaking_to_requested |= SMB2_LEASE_READ;
1038                 }
1039                 d->modified = true;
1040                 *_l = l;
1041                 return NT_STATUS_OPLOCK_BREAK_IN_PROGRESS;
1042         }
1043
1044         DEBUG(10, ("breaking from %d to %d - expected %d\n",
1045                    (int)l->current_state, (int)new_lease_state,
1046                    (int)l->breaking_to_requested));
1047
1048         l->breaking_to_requested = 0;
1049         l->breaking_to_required = 0;
1050         l->breaking = false;
1051
1052         d->modified = true;
1053
1054         return NT_STATUS_OK;
1055 }
1056
1057 /****************************************************************************
1058  Adds a delete on close token.
1059 ****************************************************************************/
1060
1061 static bool add_delete_on_close_token(struct share_mode_data *d,
1062                         uint32_t name_hash,
1063                         const struct security_token *nt_tok,
1064                         const struct security_unix_token *tok)
1065 {
1066         struct delete_token *tmp, *dtl;
1067
1068         tmp = talloc_realloc(d, d->delete_tokens, struct delete_token,
1069                              d->num_delete_tokens+1);
1070         if (tmp == NULL) {
1071                 return false;
1072         }
1073         d->delete_tokens = tmp;
1074         dtl = &d->delete_tokens[d->num_delete_tokens];
1075
1076         dtl->name_hash = name_hash;
1077         dtl->delete_nt_token = dup_nt_token(d->delete_tokens, nt_tok);
1078         if (dtl->delete_nt_token == NULL) {
1079                 return false;
1080         }
1081         dtl->delete_token = copy_unix_token(d->delete_tokens, tok);
1082         if (dtl->delete_token == NULL) {
1083                 return false;
1084         }
1085         d->num_delete_tokens += 1;
1086         d->modified = true;
1087         return true;
1088 }
1089
1090 void reset_delete_on_close_lck(files_struct *fsp,
1091                                struct share_mode_lock *lck)
1092 {
1093         struct share_mode_data *d = lck->data;
1094         uint32_t i;
1095
1096         for (i=0; i<d->num_delete_tokens; i++) {
1097                 struct delete_token *dt = &d->delete_tokens[i];
1098
1099                 if (dt->name_hash == fsp->name_hash) {
1100                         d->modified = true;
1101
1102                         /* Delete this entry. */
1103                         TALLOC_FREE(dt->delete_nt_token);
1104                         TALLOC_FREE(dt->delete_token);
1105                         *dt = d->delete_tokens[d->num_delete_tokens-1];
1106                         d->num_delete_tokens -= 1;
1107                 }
1108         }
1109 }
1110
1111 /****************************************************************************
1112  Sets the delete on close flag over all share modes on this file.
1113  Modify the share mode entry for all files open
1114  on this device and inode to tell other smbds we have
1115  changed the delete on close flag. This will be noticed
1116  in the close code, the last closer will delete the file
1117  if flag is set.
1118  This makes a copy of any struct security_unix_token into the
1119  lck entry. This function is used when the lock is already granted.
1120 ****************************************************************************/
1121
1122 void set_delete_on_close_lck(files_struct *fsp,
1123                         struct share_mode_lock *lck,
1124                         const struct security_token *nt_tok,
1125                         const struct security_unix_token *tok)
1126 {
1127         struct messaging_context *msg_ctx = fsp->conn->sconn->msg_ctx;
1128         struct share_mode_data *d = lck->data;
1129         uint32_t i;
1130         bool ret;
1131         DATA_BLOB fid_blob = {};
1132         enum ndr_err_code ndr_err;
1133
1134         SMB_ASSERT(nt_tok != NULL);
1135         SMB_ASSERT(tok != NULL);
1136
1137         for (i=0; i<d->num_delete_tokens; i++) {
1138                 struct delete_token *dt = &d->delete_tokens[i];
1139                 if (dt->name_hash == fsp->name_hash) {
1140                         d->modified = true;
1141
1142                         /* Replace this token with the given tok. */
1143                         TALLOC_FREE(dt->delete_nt_token);
1144                         dt->delete_nt_token = dup_nt_token(dt, nt_tok);
1145                         SMB_ASSERT(dt->delete_nt_token != NULL);
1146                         TALLOC_FREE(dt->delete_token);
1147                         dt->delete_token = copy_unix_token(dt, tok);
1148                         SMB_ASSERT(dt->delete_token != NULL);
1149
1150                         return;
1151                 }
1152         }
1153
1154         ret = add_delete_on_close_token(lck->data, fsp->name_hash, nt_tok, tok);
1155         SMB_ASSERT(ret);
1156
1157         ndr_err = ndr_push_struct_blob(&fid_blob, talloc_tos(), &fsp->file_id,
1158                                        (ndr_push_flags_fn_t)ndr_push_file_id);
1159         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1160                 DEBUG(10, ("ndr_push_file_id failed: %s\n",
1161                            ndr_errstr(ndr_err)));
1162         }
1163
1164         for (i=0; i<d->num_share_modes; i++) {
1165                 struct share_mode_entry *e = &d->share_modes[i];
1166                 NTSTATUS status;
1167
1168                 status = messaging_send(
1169                         msg_ctx, e->pid, MSG_SMB_NOTIFY_CANCEL_DELETED,
1170                         &fid_blob);
1171
1172                 if (!NT_STATUS_IS_OK(status)) {
1173                         struct server_id_buf tmp;
1174                         DEBUG(10, ("%s: messaging_send to %s returned %s\n",
1175                                    __func__, server_id_str_buf(e->pid, &tmp),
1176                                    nt_errstr(status)));
1177                 }
1178         }
1179
1180         TALLOC_FREE(fid_blob.data);
1181 }
1182
1183 bool set_delete_on_close(files_struct *fsp, bool delete_on_close,
1184                         const struct security_token *nt_tok,
1185                         const struct security_unix_token *tok)
1186 {
1187         struct share_mode_lock *lck;
1188
1189         DEBUG(10,("set_delete_on_close: %s delete on close flag for "
1190                   "%s, file %s\n",
1191                   delete_on_close ? "Adding" : "Removing", fsp_fnum_dbg(fsp),
1192                   fsp_str_dbg(fsp)));
1193
1194         lck = get_existing_share_mode_lock(talloc_tos(), fsp->file_id);
1195         if (lck == NULL) {
1196                 return False;
1197         }
1198
1199         if (delete_on_close) {
1200                 set_delete_on_close_lck(fsp, lck, nt_tok, tok);
1201         } else {
1202                 reset_delete_on_close_lck(fsp, lck);
1203         }
1204
1205         if (fsp->is_directory) {
1206                 SMB_ASSERT(!is_ntfs_stream_smb_fname(fsp->fsp_name));
1207                 send_stat_cache_delete_message(fsp->conn->sconn->msg_ctx,
1208                                                fsp->fsp_name->base_name);
1209         }
1210
1211         TALLOC_FREE(lck);
1212
1213         fsp->delete_on_close = delete_on_close;
1214
1215         return True;
1216 }
1217
1218 static struct delete_token *find_delete_on_close_token(
1219         struct share_mode_data *d, uint32_t name_hash)
1220 {
1221         uint32_t i;
1222
1223         DEBUG(10, ("find_delete_on_close_token: name_hash = 0x%x\n",
1224                    (unsigned int)name_hash));
1225
1226         for (i=0; i<d->num_delete_tokens; i++) {
1227                 struct delete_token *dt = &d->delete_tokens[i];
1228
1229                 DEBUG(10, ("find__delete_on_close_token: dt->name_hash = 0x%x\n",
1230                            (unsigned int)dt->name_hash ));
1231                 if (dt->name_hash == name_hash) {
1232                         return dt;
1233                 }
1234         }
1235         return NULL;
1236 }
1237
1238 /****************************************************************************
1239  Return the NT token and UNIX token if there's a match. Return true if
1240  found, false if not.
1241 ****************************************************************************/
1242
1243 bool get_delete_on_close_token(struct share_mode_lock *lck,
1244                                         uint32_t name_hash,
1245                                         const struct security_token **pp_nt_tok,
1246                                         const struct security_unix_token **pp_tok)
1247 {
1248         struct delete_token *dt;
1249
1250         dt = find_delete_on_close_token(lck->data, name_hash);
1251         if (dt == NULL) {
1252                 return false;
1253         }
1254         *pp_nt_tok = dt->delete_nt_token;
1255         *pp_tok =  dt->delete_token;
1256         return true;
1257 }
1258
1259 bool is_delete_on_close_set(struct share_mode_lock *lck, uint32_t name_hash)
1260 {
1261         return find_delete_on_close_token(lck->data, name_hash) != NULL;
1262 }
1263
1264 bool set_sticky_write_time(struct file_id fileid, struct timespec write_time)
1265 {
1266         struct share_mode_lock *lck;
1267
1268         DEBUG(5,("set_sticky_write_time: %s id=%s\n",
1269                  timestring(talloc_tos(),
1270                             convert_timespec_to_time_t(write_time)),
1271                  file_id_string_tos(&fileid)));
1272
1273         lck = get_existing_share_mode_lock(talloc_tos(), fileid);
1274         if (lck == NULL) {
1275                 return False;
1276         }
1277
1278         if (timespec_compare(&lck->data->changed_write_time, &write_time) != 0) {
1279                 lck->data->modified = True;
1280                 lck->data->changed_write_time = write_time;
1281         }
1282
1283         TALLOC_FREE(lck);
1284         return True;
1285 }
1286
1287 bool set_write_time(struct file_id fileid, struct timespec write_time)
1288 {
1289         struct share_mode_lock *lck;
1290
1291         DEBUG(5,("set_write_time: %s id=%s\n",
1292                  timestring(talloc_tos(),
1293                             convert_timespec_to_time_t(write_time)),
1294                  file_id_string_tos(&fileid)));
1295
1296         lck = get_existing_share_mode_lock(talloc_tos(), fileid);
1297         if (lck == NULL) {
1298                 return False;
1299         }
1300
1301         if (timespec_compare(&lck->data->old_write_time, &write_time) != 0) {
1302                 lck->data->modified = True;
1303                 lck->data->old_write_time = write_time;
1304         }
1305
1306         TALLOC_FREE(lck);
1307         return True;
1308 }
1309
1310 struct timespec get_share_mode_write_time(struct share_mode_lock *lck)
1311 {
1312         struct share_mode_data *d = lck->data;
1313
1314         if (!null_timespec(d->changed_write_time)) {
1315                 return d->changed_write_time;
1316         }
1317         return d->old_write_time;
1318 }
1319
1320 bool file_has_open_streams(files_struct *fsp)
1321 {
1322         struct share_mode_lock *lock = NULL;
1323         struct share_mode_data *d = NULL;
1324         uint32_t i;
1325
1326         lock = get_existing_share_mode_lock(talloc_tos(), fsp->file_id);
1327         if (lock == NULL) {
1328                 return false;
1329         }
1330         d = lock->data;
1331
1332         for (i = 0; i < d->num_share_modes; i++) {
1333                 struct share_mode_entry *e = &d->share_modes[i];
1334
1335                 if (share_mode_stale_pid(d, i)) {
1336                         continue;
1337                 }
1338
1339                 if (e->private_options &
1340                     NTCREATEX_OPTIONS_PRIVATE_STREAM_BASEOPEN)
1341                 {
1342                         TALLOC_FREE(lock);
1343                         return true;
1344                 }
1345         }
1346
1347         TALLOC_FREE(lock);
1348         return false;
1349 }