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                     uint32_t share_access,
 798                     uint32_t access_mask)
 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 = share_access;
 816         e->private_options = fsp->fh->private_options;
 817         e->access_mask = access_mask;
 818         e->op_mid = mid;
 819         e->op_type = op_type;
 820
 821         if (op_type == LEASE_OPLOCK) {
 822                 const struct GUID *client_guid = fsp_client_guid(fsp);
 823                 e->client_guid = *client_guid;
 824                 e->lease_key = fsp->lease->lease.lease_key;
 825         }
 826
 827         e->time.tv_sec = fsp->open_time.tv_sec;
 828         e->time.tv_usec = fsp->open_time.tv_usec;
 829         e->share_file_id = fsp->fh->gen_id;
 830         e->uid = (uint32_t)uid;
 831         e->flags = (fsp->posix_flags & FSP_POSIX_FLAGS_OPEN) ?
 832                 SHARE_MODE_FLAG_POSIX_OPEN : 0;
 833         e->name_hash = fsp->name_hash;
 834
 835         return true;
 836 }
 837
 838 static struct share_mode_entry *find_share_mode_entry(
 839         struct share_mode_lock *lck, files_struct *fsp)
 840 {
 841         struct share_mode_data *d = lck->data;
 842         struct server_id pid;
 843         uint32_t i;
 844
 845         pid = messaging_server_id(fsp->conn->sconn->msg_ctx);
 846
 847         for (i=0; i<d->num_share_modes; i++) {
 848                 struct share_mode_entry *e = &d->share_modes[i];
 849
 850                 if (!is_valid_share_mode_entry(e)) {
 851                         continue;
 852                 }
 853                 if (!serverid_equal(&pid, &e->pid)) {
 854                         continue;
 855                 }
 856                 if (fsp->fh->gen_id != e->share_file_id) {
 857                         continue;
 858                 }
 859                 return e;
 860         }
 861         return NULL;
 862 }
 863
 864 /*******************************************************************
 865  Del the share mode of a file for this process.
 866 ********************************************************************/
 867
 868 bool del_share_mode(struct share_mode_lock *lck, files_struct *fsp)
 869 {
 870         struct share_mode_entry *e;
 871
 872         e = find_share_mode_entry(lck, fsp);
 873         if (e == NULL) {
 874                 return False;
 875         }
 876         remove_share_mode_lease(lck->data, e);
 877         *e = lck->data->share_modes[lck->data->num_share_modes-1];
 878         lck->data->num_share_modes -= 1;
 879         lck->data->modified = True;
 880         return True;
 881 }
 882
 883 bool mark_share_mode_disconnected(struct share_mode_lock *lck,
 884                                   struct files_struct *fsp)
 885 {
 886         struct share_mode_entry *e;
 887
 888         if (lck->data->num_share_modes != 1) {
 889                 return false;
 890         }
 891
 892         if (fsp->op == NULL) {
 893                 return false;
 894         }
 895         if (!fsp->op->global->durable) {
 896                 return false;
 897         }
 898
 899         e = find_share_mode_entry(lck, fsp);
 900         if (e == NULL) {
 901                 return false;
 902         }
 903
 904         DEBUG(10, ("Marking share mode entry disconnected for durable handle\n"));
 905
 906         server_id_set_disconnected(&e->pid);
 907
 908         /*
 909          * On reopen the caller needs to check that
 910          * the client comes with the correct handle.
 911          */
 912         e->share_file_id = fsp->op->global->open_persistent_id;
 913
 914         lck->data->modified = true;
 915         return true;
 916 }
 917
 918 /*******************************************************************
 919  Remove an oplock mid and mode entry from a share mode.
 920 ********************************************************************/
 921
 922 bool remove_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
 923 {
 924         struct share_mode_data *d = lck->data;
 925         struct share_mode_entry *e;
 926
 927         e = find_share_mode_entry(lck, fsp);
 928         if (e == NULL) {
 929                 return False;
 930         }
 931
 932         remove_share_mode_lease(d, e);
 933         d->modified = True;
 934         return true;
 935 }
 936
 937 /*******************************************************************
 938  Downgrade a oplock type from exclusive to level II.
 939 ********************************************************************/
 940
 941 bool downgrade_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
 942 {
 943         struct share_mode_entry *e;
 944
 945         e = find_share_mode_entry(lck, fsp);
 946         if (e == NULL) {
 947                 return False;
 948         }
 949
 950         e->op_type = LEVEL_II_OPLOCK;
 951         lck->data->flags |= SHARE_MODE_HAS_READ_LEASE;
 952         lck->data->modified = True;
 953         return True;
 954 }
 955
 956 /****************************************************************************
 957  Adds a delete on close token.
 958 ****************************************************************************/
 959
 960 static bool add_delete_on_close_token(struct share_mode_data *d,
 961                         uint32_t name_hash,
 962                         const struct security_token *nt_tok,
 963                         const struct security_unix_token *tok)
 964 {
 965         struct delete_token *tmp, *dtl;
 966
 967         tmp = talloc_realloc(d, d->delete_tokens, struct delete_token,
 968                              d->num_delete_tokens+1);
 969         if (tmp == NULL) {
 970                 return false;
 971         }
 972         d->delete_tokens = tmp;
 973         dtl = &d->delete_tokens[d->num_delete_tokens];
 974
 975         dtl->name_hash = name_hash;
 976         dtl->delete_nt_token = dup_nt_token(d->delete_tokens, nt_tok);
 977         if (dtl->delete_nt_token == NULL) {
 978                 return false;
 979         }
 980         dtl->delete_token = copy_unix_token(d->delete_tokens, tok);
 981         if (dtl->delete_token == NULL) {
 982                 return false;
 983         }
 984         d->num_delete_tokens += 1;
 985         d->modified = true;
 986         return true;
 987 }
 988
 989 void reset_delete_on_close_lck(files_struct *fsp,
 990                                struct share_mode_lock *lck)
 991 {
 992         struct share_mode_data *d = lck->data;
 993         uint32_t i;
 994
 995         for (i=0; i<d->num_delete_tokens; i++) {
 996                 struct delete_token *dt = &d->delete_tokens[i];
 997
 998                 if (dt->name_hash == fsp->name_hash) {
 999                         d->modified = true;
1000
1001                         /* Delete this entry. */
1002                         TALLOC_FREE(dt->delete_nt_token);
1003                         TALLOC_FREE(dt->delete_token);
1004                         *dt = d->delete_tokens[d->num_delete_tokens-1];
1005                         d->num_delete_tokens -= 1;
1006                 }
1007         }
1008 }
1009
1010 /****************************************************************************
1011  Sets the delete on close flag over all share modes on this file.
1012  Modify the share mode entry for all files open
1013  on this device and inode to tell other smbds we have
1014  changed the delete on close flag. This will be noticed
1015  in the close code, the last closer will delete the file
1016  if flag is set.
1017  This makes a copy of any struct security_unix_token into the
1018  lck entry. This function is used when the lock is already granted.
1019 ****************************************************************************/
1020
1021 void set_delete_on_close_lck(files_struct *fsp,
1022                         struct share_mode_lock *lck,
1023                         const struct security_token *nt_tok,
1024                         const struct security_unix_token *tok)
1025 {
1026         struct messaging_context *msg_ctx = fsp->conn->sconn->msg_ctx;
1027         struct share_mode_data *d = lck->data;
1028         uint32_t i;
1029         bool ret;
1030         DATA_BLOB fid_blob = {};
1031         enum ndr_err_code ndr_err;
1032
1033         SMB_ASSERT(nt_tok != NULL);
1034         SMB_ASSERT(tok != NULL);
1035
1036         for (i=0; i<d->num_delete_tokens; i++) {
1037                 struct delete_token *dt = &d->delete_tokens[i];
1038                 if (dt->name_hash == fsp->name_hash) {
1039                         d->modified = true;
1040
1041                         /* Replace this token with the given tok. */
1042                         TALLOC_FREE(dt->delete_nt_token);
1043                         dt->delete_nt_token = dup_nt_token(dt, nt_tok);
1044                         SMB_ASSERT(dt->delete_nt_token != NULL);
1045                         TALLOC_FREE(dt->delete_token);
1046                         dt->delete_token = copy_unix_token(dt, tok);
1047                         SMB_ASSERT(dt->delete_token != NULL);
1048
1049                         return;
1050                 }
1051         }
1052
1053         ret = add_delete_on_close_token(lck->data, fsp->name_hash, nt_tok, tok);
1054         SMB_ASSERT(ret);
1055
1056         ndr_err = ndr_push_struct_blob(&fid_blob, talloc_tos(), &fsp->file_id,
1057                                        (ndr_push_flags_fn_t)ndr_push_file_id);
1058         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1059                 DEBUG(10, ("ndr_push_file_id failed: %s\n",
1060                            ndr_errstr(ndr_err)));
1061         }
1062
1063         for (i=0; i<d->num_share_modes; i++) {
1064                 struct share_mode_entry *e = &d->share_modes[i];
1065                 NTSTATUS status;
1066
1067                 status = messaging_send(
1068                         msg_ctx, e->pid, MSG_SMB_NOTIFY_CANCEL_DELETED,
1069                         &fid_blob);
1070
1071                 if (!NT_STATUS_IS_OK(status)) {
1072                         struct server_id_buf tmp;
1073                         DEBUG(10, ("%s: messaging_send to %s returned %s\n",
1074                                    __func__, server_id_str_buf(e->pid, &tmp),
1075                                    nt_errstr(status)));
1076                 }
1077         }
1078
1079         TALLOC_FREE(fid_blob.data);
1080 }
1081
1082 bool set_delete_on_close(files_struct *fsp, bool delete_on_close,
1083                         const struct security_token *nt_tok,
1084                         const struct security_unix_token *tok)
1085 {
1086         struct share_mode_lock *lck;
1087
1088         DEBUG(10,("set_delete_on_close: %s delete on close flag for "
1089                   "%s, file %s\n",
1090                   delete_on_close ? "Adding" : "Removing", fsp_fnum_dbg(fsp),
1091                   fsp_str_dbg(fsp)));
1092
1093         lck = get_existing_share_mode_lock(talloc_tos(), fsp->file_id);
1094         if (lck == NULL) {
1095                 return False;
1096         }
1097
1098         if (delete_on_close) {
1099                 set_delete_on_close_lck(fsp, lck, nt_tok, tok);
1100         } else {
1101                 reset_delete_on_close_lck(fsp, lck);
1102         }
1103
1104         if (fsp->is_directory) {
1105                 SMB_ASSERT(!is_ntfs_stream_smb_fname(fsp->fsp_name));
1106                 send_stat_cache_delete_message(fsp->conn->sconn->msg_ctx,
1107                                                fsp->fsp_name->base_name);
1108         }
1109
1110         TALLOC_FREE(lck);
1111
1112         fsp->delete_on_close = delete_on_close;
1113
1114         return True;
1115 }
1116
1117 static struct delete_token *find_delete_on_close_token(
1118         struct share_mode_data *d, uint32_t name_hash)
1119 {
1120         uint32_t i;
1121
1122         DEBUG(10, ("find_delete_on_close_token: name_hash = 0x%x\n",
1123                    (unsigned int)name_hash));
1124
1125         for (i=0; i<d->num_delete_tokens; i++) {
1126                 struct delete_token *dt = &d->delete_tokens[i];
1127
1128                 DEBUG(10, ("find__delete_on_close_token: dt->name_hash = 0x%x\n",
1129                            (unsigned int)dt->name_hash ));
1130                 if (dt->name_hash == name_hash) {
1131                         return dt;
1132                 }
1133         }
1134         return NULL;
1135 }
1136
1137 /****************************************************************************
1138  Return the NT token and UNIX token if there's a match. Return true if
1139  found, false if not.
1140 ****************************************************************************/
1141
1142 bool get_delete_on_close_token(struct share_mode_lock *lck,
1143                                         uint32_t name_hash,
1144                                         const struct security_token **pp_nt_tok,
1145                                         const struct security_unix_token **pp_tok)
1146 {
1147         struct delete_token *dt;
1148
1149         dt = find_delete_on_close_token(lck->data, name_hash);
1150         if (dt == NULL) {
1151                 return false;
1152         }
1153         *pp_nt_tok = dt->delete_nt_token;
1154         *pp_tok =  dt->delete_token;
1155         return true;
1156 }
1157
1158 bool is_delete_on_close_set(struct share_mode_lock *lck, uint32_t name_hash)
1159 {
1160         return find_delete_on_close_token(lck->data, name_hash) != NULL;
1161 }
1162
1163 bool set_sticky_write_time(struct file_id fileid, struct timespec write_time)
1164 {
1165         struct share_mode_lock *lck;
1166
1167         DEBUG(5,("set_sticky_write_time: %s id=%s\n",
1168                  timestring(talloc_tos(),
1169                             convert_timespec_to_time_t(write_time)),
1170                  file_id_string_tos(&fileid)));
1171
1172         lck = get_existing_share_mode_lock(talloc_tos(), fileid);
1173         if (lck == NULL) {
1174                 return False;
1175         }
1176
1177         if (timespec_compare(&lck->data->changed_write_time, &write_time) != 0) {
1178                 lck->data->modified = True;
1179                 lck->data->changed_write_time = write_time;
1180         }
1181
1182         TALLOC_FREE(lck);
1183         return True;
1184 }
1185
1186 bool set_write_time(struct file_id fileid, struct timespec write_time)
1187 {
1188         struct share_mode_lock *lck;
1189
1190         DEBUG(5,("set_write_time: %s id=%s\n",
1191                  timestring(talloc_tos(),
1192                             convert_timespec_to_time_t(write_time)),
1193                  file_id_string_tos(&fileid)));
1194
1195         lck = get_existing_share_mode_lock(talloc_tos(), fileid);
1196         if (lck == NULL) {
1197                 return False;
1198         }
1199
1200         if (timespec_compare(&lck->data->old_write_time, &write_time) != 0) {
1201                 lck->data->modified = True;
1202                 lck->data->old_write_time = write_time;
1203         }
1204
1205         TALLOC_FREE(lck);
1206         return True;
1207 }
1208
1209 struct timespec get_share_mode_write_time(struct share_mode_lock *lck)
1210 {
1211         struct share_mode_data *d = lck->data;
1212
1213         if (!null_timespec(d->changed_write_time)) {
1214                 return d->changed_write_time;
1215         }
1216         return d->old_write_time;
1217 }
1218
1219 bool file_has_open_streams(files_struct *fsp)
1220 {
1221         struct share_mode_lock *lock = NULL;
1222         struct share_mode_data *d = NULL;
1223         uint32_t i;
1224
1225         lock = get_existing_share_mode_lock(talloc_tos(), fsp->file_id);
1226         if (lock == NULL) {
1227                 return false;
1228         }
1229         d = lock->data;
1230
1231         for (i = 0; i < d->num_share_modes; i++) {
1232                 struct share_mode_entry *e = &d->share_modes[i];
1233
1234                 if (share_mode_stale_pid(d, i)) {
1235                         continue;
1236                 }
1237
1238                 if (e->private_options &
1239                     NTCREATEX_OPTIONS_PRIVATE_STREAM_BASEOPEN)
1240                 {
1241                         TALLOC_FREE(lock);
1242                         return true;
1243                 }
1244         }
1245
1246         TALLOC_FREE(lock);
1247         return false;
1248 }
1249
1250 /*
1251  * Walk share mode entries, looking at every lease only once
1252  */
1253
1254 bool share_mode_forall_leases(
1255         struct share_mode_lock *lck,
1256         bool (*fn)(struct share_mode_lock *lck,
1257                    struct share_mode_entry *e,
1258                    void *private_data),
1259         void *private_data)
1260 {
1261         struct share_mode_data *d = lck->data;
1262         uint32_t *leases = NULL;
1263         uint32_t num_leases = 0;
1264         uint32_t i;
1265
1266         leases = talloc_array(talloc_tos(), uint32_t, d->num_share_modes);
1267         if (leases == NULL) {
1268                 return false;
1269         }
1270
1271         for (i=0; i<d->num_share_modes; i++) {
1272                 struct share_mode_entry *e = &d->share_modes[i];
1273                 uint32_t j;
1274                 bool ok, stop;
1275
1276                 ok = is_valid_share_mode_entry(e);
1277                 if (!ok) {
1278                         continue;
1279                 }
1280
1281                 if (e->op_type != LEASE_OPLOCK) {
1282                         continue;
1283                 }
1284
1285                 /*
1286                  * See if we have already seen "e"'s lease. This is
1287                  * O(n^2). If we sort "leases", we can get this down
1288                  * to O(n).
1289                  */
1290
1291                 for (j=0; j<num_leases; j++) {
1292                         uint32_t idx = leases[j];
1293                         struct share_mode_entry *l = &d->share_modes[idx];
1294
1295                         if (smb2_lease_equal(&e->client_guid,
1296                                              &e->lease_key,
1297                                              &l->client_guid,
1298                                              &l->lease_key)) {
1299                                 break;
1300                         }
1301                 }
1302                 if (j < num_leases) {
1303                         /*
1304                          * Don't look at "e"'s lease, we've already
1305                          * seen it.
1306                          */
1307                         continue;
1308                 }
1309
1310                 stop = fn(lck, e, private_data);
1311                 if (stop) {
1312                         TALLOC_FREE(leases);
1313                         return true;
1314                 }
1315
1316                 leases[num_leases] = i;
1317                 num_leases += 1;
1318         }
1319
1320         TALLOC_FREE(leases);
1321         return true;
1322 }