source3/locking/locking.c

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