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