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
 250         /* silently return ok on print files as we don't do locking there */
 251         if (fsp->print_file) {
 252                 *perr = NT_STATUS_OK;
 253                 return NULL;
 254         }
 255
 256         if (!fsp->can_lock) {
 257                 *perr = fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
 258                 return NULL;
 259         }
 260
 261         if (!lp_locking(fsp->conn->params)) {
 262                 *perr = NT_STATUS_OK;
 263                 return NULL;
 264         }
 265
 266         /* NOTE! 0 byte long ranges ARE allowed and should be stored  */
 267
 268         DEBUG(10,("do_lock: lock flavour %s lock type %s start=%ju len=%ju "
 269                 "blocking_lock=%s requested for %s file %s\n",
 270                 lock_flav_name(lock_flav), lock_type_name(lock_type),
 271                 (uintmax_t)offset, (uintmax_t)count, blocking_lock ? "true" :
 272                 "false", fsp_fnum_dbg(fsp), fsp_str_dbg(fsp)));
 273
 274         br_lck = brl_get_locks(talloc_tos(), fsp);
 275         if (!br_lck) {
 276                 *perr = NT_STATUS_NO_MEMORY;
 277                 return NULL;
 278         }
 279
 280         *perr = brl_lock(msg_ctx,
 281                         br_lck,
 282                         smblctx,
 283                         messaging_server_id(fsp->conn->sconn->msg_ctx),
 284                         offset,
 285                         count,
 286                         lock_type,
 287                         lock_flav,
 288                         blocking_lock,
 289                         psmblctx);
 290
 291         DEBUG(10, ("do_lock: returning status=%s\n", nt_errstr(*perr)));
 292
 293         increment_current_lock_count(fsp, lock_flav);
 294         return br_lck;
 295 }
 296
 297 /****************************************************************************
 298  Utility function called by unlocking requests.
 299 ****************************************************************************/
 300
 301 NTSTATUS do_unlock(struct messaging_context *msg_ctx,
 302                         files_struct *fsp,
 303                         uint64_t smblctx,
 304                         uint64_t count,
 305                         uint64_t offset,
 306                         enum brl_flavour lock_flav)
 307 {
 308         bool ok = False;
 309         struct byte_range_lock *br_lck = NULL;
 310
 311         if (!fsp->can_lock) {
 312                 return fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
 313         }
 314
 315         if (!lp_locking(fsp->conn->params)) {
 316                 return NT_STATUS_OK;
 317         }
 318
 319         DEBUG(10, ("do_unlock: unlock start=%ju len=%ju requested for %s file "
 320                    "%s\n", (uintmax_t)offset, (uintmax_t)count,
 321                    fsp_fnum_dbg(fsp), fsp_str_dbg(fsp)));
 322
 323         br_lck = brl_get_locks(talloc_tos(), fsp);
 324         if (!br_lck) {
 325                 return NT_STATUS_NO_MEMORY;
 326         }
 327
 328         ok = brl_unlock(msg_ctx,
 329                         br_lck,
 330                         smblctx,
 331                         messaging_server_id(fsp->conn->sconn->msg_ctx),
 332                         offset,
 333                         count,
 334                         lock_flav);
 335
 336         TALLOC_FREE(br_lck);
 337
 338         if (!ok) {
 339                 DEBUG(10,("do_unlock: returning ERRlock.\n" ));
 340                 return NT_STATUS_RANGE_NOT_LOCKED;
 341         }
 342
 343         decrement_current_lock_count(fsp, lock_flav);
 344         return NT_STATUS_OK;
 345 }
 346
 347 /****************************************************************************
 348  Cancel any pending blocked locks.
 349 ****************************************************************************/
 350
 351 NTSTATUS do_lock_cancel(files_struct *fsp,
 352                         uint64_t smblctx,
 353                         uint64_t count,
 354                         uint64_t offset,
 355                         enum brl_flavour lock_flav)
 356 {
 357         bool ok = False;
 358         struct byte_range_lock *br_lck = NULL;
 359
 360         if (!fsp->can_lock) {
 361                 return fsp->is_directory ?
 362                         NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
 363         }
 364
 365         if (!lp_locking(fsp->conn->params)) {
 366                 return NT_STATUS_DOS(ERRDOS, ERRcancelviolation);
 367         }
 368
 369         DEBUG(10, ("do_lock_cancel: cancel start=%ju len=%ju requested for "
 370                    "%s file %s\n", (uintmax_t)offset, (uintmax_t)count,
 371                    fsp_fnum_dbg(fsp), fsp_str_dbg(fsp)));
 372
 373         br_lck = brl_get_locks(talloc_tos(), fsp);
 374         if (!br_lck) {
 375                 return NT_STATUS_NO_MEMORY;
 376         }
 377
 378         ok = brl_lock_cancel(br_lck,
 379                         smblctx,
 380                         messaging_server_id(fsp->conn->sconn->msg_ctx),
 381                         offset,
 382                         count,
 383                         lock_flav);
 384
 385         TALLOC_FREE(br_lck);
 386
 387         if (!ok) {
 388                 DEBUG(10,("do_lock_cancel: returning ERRcancelviolation.\n" ));
 389                 return NT_STATUS_DOS(ERRDOS, ERRcancelviolation);
 390         }
 391
 392         decrement_current_lock_count(fsp, lock_flav);
 393         return NT_STATUS_OK;
 394 }
 395
 396 /****************************************************************************
 397  Remove any locks on this fd. Called from file_close().
 398 ****************************************************************************/
 399
 400 void locking_close_file(struct messaging_context *msg_ctx,
 401                         files_struct *fsp,
 402                         enum file_close_type close_type)
 403 {
 404         struct byte_range_lock *br_lck;
 405
 406         if (!lp_locking(fsp->conn->params)) {
 407                 return;
 408         }
 409
 410         /* If we have no outstanding locks or pending
 411          * locks then we don't need to look in the lock db.
 412          */
 413
 414         if (fsp->current_lock_count == 0) {
 415                 return;
 416         }
 417
 418         br_lck = brl_get_locks(talloc_tos(),fsp);
 419
 420         if (br_lck) {
 421                 cancel_pending_lock_requests_by_fid(fsp, br_lck, close_type);
 422                 brl_close_fnum(msg_ctx, 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 /*******************************************************************
 463  Sets the service name and filename for rename.
 464  At this point we emit "file renamed" messages to all
 465  process id's that have this file open.
 466  Based on an initial code idea from SATOH Fumiyasu <fumiya@samba.gr.jp>
 467 ********************************************************************/
 468
 469 bool rename_share_filename(struct messaging_context *msg_ctx,
 470                         struct share_mode_lock *lck,
 471                         struct file_id id,
 472                         const char *servicepath,
 473                         uint32_t orig_name_hash,
 474                         uint32_t new_name_hash,
 475                         const struct smb_filename *smb_fname_dst)
 476 {
 477         struct share_mode_data *d = lck->data;
 478         size_t sp_len;
 479         size_t bn_len;
 480         size_t sn_len;
 481         size_t msg_len;
 482         char *frm = NULL;
 483         uint32_t i;
 484         bool strip_two_chars = false;
 485         bool has_stream = smb_fname_dst->stream_name != NULL;
 486         struct server_id self_pid = messaging_server_id(msg_ctx);
 487
 488         DEBUG(10, ("rename_share_filename: servicepath %s newname %s\n",
 489                    servicepath, smb_fname_dst->base_name));
 490
 491         /*
 492          * rename_internal_fsp() and rename_internals() add './' to
 493          * head of newname if newname does not contain a '/'.
 494          */
 495         if (smb_fname_dst->base_name[0] &&
 496             smb_fname_dst->base_name[1] &&
 497             smb_fname_dst->base_name[0] == '.' &&
 498             smb_fname_dst->base_name[1] == '/') {
 499                 strip_two_chars = true;
 500         }
 501
 502         d->servicepath = talloc_strdup(d, servicepath);
 503         d->base_name = talloc_strdup(d, smb_fname_dst->base_name +
 504                                        (strip_two_chars ? 2 : 0));
 505         d->stream_name = talloc_strdup(d, smb_fname_dst->stream_name);
 506         if (d->base_name == NULL ||
 507             (has_stream && d->stream_name == NULL) ||
 508             d->servicepath == NULL) {
 509                 DEBUG(0, ("rename_share_filename: talloc failed\n"));
 510                 return False;
 511         }
 512         d->modified = True;
 513
 514         sp_len = strlen(d->servicepath);
 515         bn_len = strlen(d->base_name);
 516         sn_len = has_stream ? strlen(d->stream_name) : 0;
 517
 518         msg_len = MSG_FILE_RENAMED_MIN_SIZE + sp_len + 1 + bn_len + 1 +
 519             sn_len + 1;
 520
 521         /* Set up the name changed message. */
 522         frm = talloc_array(d, char, msg_len);
 523         if (!frm) {
 524                 return False;
 525         }
 526
 527         push_file_id_24(frm, &id);
 528
 529         DEBUG(10,("rename_share_filename: msg_len = %u\n", (unsigned int)msg_len ));
 530
 531         strlcpy(&frm[24],
 532                 d->servicepath ? d->servicepath : "",
 533                 sp_len+1);
 534         strlcpy(&frm[24 + sp_len + 1],
 535                 d->base_name ? d->base_name : "",
 536                 bn_len+1);
 537         strlcpy(&frm[24 + sp_len + 1 + bn_len + 1],
 538                 d->stream_name ? d->stream_name : "",
 539                 sn_len+1);
 540
 541         /* Send the messages. */
 542         for (i=0; i<d->num_share_modes; i++) {
 543                 struct share_mode_entry *se = &d->share_modes[i];
 544                 struct server_id_buf tmp;
 545
 546                 if (!is_valid_share_mode_entry(se)) {
 547                         continue;
 548                 }
 549
 550                 /* If this is a hardlink to the inode
 551                    with a different name, skip this. */
 552                 if (se->name_hash != orig_name_hash) {
 553                         continue;
 554                 }
 555
 556                 se->name_hash = new_name_hash;
 557
 558                 /* But not to ourselves... */
 559                 if (serverid_equal(&se->pid, &self_pid)) {
 560                         continue;
 561                 }
 562
 563                 if (share_mode_stale_pid(d, i)) {
 564                         continue;
 565                 }
 566
 567                 DEBUG(10,("rename_share_filename: sending rename message to "
 568                           "pid %s file_id %s sharepath %s base_name %s "
 569                           "stream_name %s\n",
 570                           server_id_str_buf(se->pid, &tmp),
 571                           file_id_string_tos(&id),
 572                           d->servicepath, d->base_name,
 573                         has_stream ? d->stream_name : ""));
 574
 575                 messaging_send_buf(msg_ctx, se->pid, MSG_SMB_FILE_RENAME,
 576                                    (uint8_t *)frm, msg_len);
 577         }
 578
 579         for (i=0; i<d->num_leases; i++) {
 580                 /* Update the filename in leases_db. */
 581                 NTSTATUS status;
 582                 struct share_mode_lease *l;
 583
 584                 l = &d->leases[i];
 585
 586                 status = leases_db_rename(&l->client_guid,
 587                                         &l->lease_key,
 588                                         &id,
 589                                         d->servicepath,
 590                                         d->base_name,
 591                                         d->stream_name);
 592                 if (!NT_STATUS_IS_OK(status)) {
 593                         /* Any error recovery possible here ? */
 594                         DEBUG(1,("Failed to rename lease key for "
 595                                 "renamed file %s:%s. %s\n",
 596                                 d->base_name,
 597                                 d->stream_name,
 598                                 nt_errstr(status)));
 599                         continue;
 600                 }
 601         }
 602
 603         return True;
 604 }
 605
 606 void get_file_infos(struct file_id id,
 607                     uint32_t name_hash,
 608                     bool *delete_on_close,
 609                     struct timespec *write_time)
 610 {
 611         struct share_mode_lock *lck;
 612
 613         if (delete_on_close) {
 614                 *delete_on_close = false;
 615         }
 616
 617         if (write_time) {
 618                 ZERO_STRUCTP(write_time);
 619         }
 620
 621         if (!(lck = fetch_share_mode_unlocked(talloc_tos(), id))) {
 622                 return;
 623         }
 624
 625         if (delete_on_close) {
 626                 *delete_on_close = is_delete_on_close_set(lck, name_hash);
 627         }
 628
 629         if (write_time) {
 630                 *write_time = get_share_mode_write_time(lck);
 631         }
 632
 633         TALLOC_FREE(lck);
 634 }
 635
 636 bool is_valid_share_mode_entry(const struct share_mode_entry *e)
 637 {
 638         int num_props = 0;
 639
 640         if (e->stale) {
 641                 return false;
 642         }
 643
 644         num_props += ((e->op_type == NO_OPLOCK) ? 1 : 0);
 645         num_props += (EXCLUSIVE_OPLOCK_TYPE(e->op_type) ? 1 : 0);
 646         num_props += (LEVEL_II_OPLOCK_TYPE(e->op_type) ? 1 : 0);
 647         num_props += (e->op_type == LEASE_OPLOCK);
 648
 649         if ((num_props > 1) && serverid_exists(&e->pid)) {
 650                 smb_panic("Invalid share mode entry");
 651         }
 652         return (num_props != 0);
 653 }
 654
 655 /*
 656  * See if we need to remove a lease being referred to by a
 657  * share mode that is being marked stale or deleted.
 658  */
 659
 660 static void remove_share_mode_lease(struct share_mode_data *d,
 661                                     struct share_mode_entry *e)
 662 {
 663         struct GUID client_guid;
 664         struct smb2_lease_key lease_key;
 665         uint16_t op_type;
 666         uint32_t lease_idx;
 667         uint32_t i;
 668
 669         op_type = e->op_type;
 670         e->op_type = NO_OPLOCK;
 671
 672         d->modified = true;
 673
 674         if (op_type != LEASE_OPLOCK) {
 675                 return;
 676         }
 677
 678         /*
 679          * This used to reference a lease. If there's no other one referencing
 680          * it, remove it.
 681          */
 682
 683         lease_idx = e->lease_idx;
 684         e->lease_idx = UINT32_MAX;
 685
 686         for (i=0; i<d->num_share_modes; i++) {
 687                 if (d->share_modes[i].stale) {
 688                         continue;
 689                 }
 690                 if (e == &d->share_modes[i]) {
 691                         /* Not ourselves. */
 692                         continue;
 693                 }
 694                 if (d->share_modes[i].lease_idx == lease_idx) {
 695                         break;
 696                 }
 697         }
 698         if (i < d->num_share_modes) {
 699                 /*
 700                  * Found another one
 701                  */
 702                 return;
 703         }
 704
 705         memcpy(&client_guid,
 706                 &d->leases[lease_idx].client_guid,
 707                 sizeof(client_guid));
 708         lease_key = d->leases[lease_idx].lease_key;
 709
 710         d->num_leases -= 1;
 711         d->leases[lease_idx] = d->leases[d->num_leases];
 712
 713         /*
 714          * We changed the lease array. Fix all references to it.
 715          */
 716         for (i=0; i<d->num_share_modes; i++) {
 717                 if (d->share_modes[i].lease_idx == d->num_leases) {
 718                         d->share_modes[i].lease_idx = lease_idx;
 719                 }
 720         }
 721
 722         {
 723                 NTSTATUS status;
 724
 725                 status = leases_db_del(&client_guid,
 726                                         &lease_key,
 727                                         &d->id);
 728
 729                 DEBUG(10, ("%s: leases_db_del returned %s\n", __func__,
 730                            nt_errstr(status)));
 731         }
 732 }
 733
 734 /*
 735  * In case d->share_modes[i] conflicts with something or otherwise is
 736  * being used, we need to make sure the corresponding process still
 737  * exists.
 738  */
 739 bool share_mode_stale_pid(struct share_mode_data *d, uint32_t idx)
 740 {
 741         struct server_id_buf tmp;
 742         struct share_mode_entry *e;
 743
 744         if (idx > d->num_share_modes) {
 745                 DBG_WARNING("Asking for index %"PRIu32", "
 746                             "only %"PRIu32" around\n",
 747                             idx,
 748                             d->num_share_modes);
 749                 return false;
 750         }
 751         e = &d->share_modes[idx];
 752         if (e->stale) {
 753                 /*
 754                  * Checked before
 755                  */
 756                 return true;
 757         }
 758         if (serverid_exists(&e->pid)) {
 759                 DBG_DEBUG("PID %s (index %"PRIu32" out of %"PRIu32") "
 760                           "still exists\n",
 761                           server_id_str_buf(e->pid, &tmp),
 762                           idx,
 763                           d->num_share_modes);
 764                 return false;
 765         }
 766         DBG_DEBUG("PID %s (index %"PRIu32" out of %"PRIu32") "
 767                   "does not exist anymore\n",
 768                   server_id_str_buf(e->pid, &tmp),
 769                   idx,
 770                   d->num_share_modes);
 771
 772         e->stale = true;
 773
 774         if (d->num_delete_tokens != 0) {
 775                 uint32_t i;
 776
 777                 for (i=0; i<d->num_share_modes; i++) {
 778                         bool valid = !d->share_modes[i].stale;
 779                         if (valid) {
 780                                 break;
 781                         }
 782                 }
 783
 784                 if (i == d->num_share_modes) {
 785                         /*
 786                          * No valid (non-stale) share mode found, all
 787                          * who might have set the delete token are
 788                          * gone.
 789                          */
 790                         TALLOC_FREE(d->delete_tokens);
 791                         d->num_delete_tokens = 0;
 792                 }
 793         }
 794
 795         remove_share_mode_lease(d, e);
 796
 797         d->modified = true;
 798         return true;
 799 }
 800
 801 void remove_stale_share_mode_entries(struct share_mode_data *d)
 802 {
 803         uint32_t i;
 804
 805         i = 0;
 806         while (i < d->num_share_modes) {
 807                 if (d->share_modes[i].stale) {
 808                         struct share_mode_entry *m = d->share_modes;
 809                         m[i] = m[d->num_share_modes-1];
 810                         d->num_share_modes -= 1;
 811                         continue;
 812                 }
 813                 i += 1;
 814         }
 815 }
 816
 817 bool set_share_mode(struct share_mode_lock *lck, struct files_struct *fsp,
 818                     uid_t uid, uint64_t mid, uint16_t op_type,
 819                     uint32_t lease_idx)
 820 {
 821         struct share_mode_data *d = lck->data;
 822         struct share_mode_entry *tmp, *e;
 823
 824         if ((lease_idx != UINT32_MAX) &&
 825             (lease_idx >= d->num_leases)) {
 826                 return false;
 827         }
 828
 829         tmp = talloc_realloc(d, d->share_modes, struct share_mode_entry,
 830                              d->num_share_modes+1);
 831         if (tmp == NULL) {
 832                 return false;
 833         }
 834         d->share_modes = tmp;
 835         e = &d->share_modes[d->num_share_modes];
 836         d->num_share_modes += 1;
 837         d->modified = true;
 838
 839         ZERO_STRUCTP(e);
 840         e->pid = messaging_server_id(fsp->conn->sconn->msg_ctx);
 841         e->share_access = fsp->share_access;
 842         e->private_options = fsp->fh->private_options;
 843         e->access_mask = fsp->access_mask;
 844         e->op_mid = mid;
 845         e->op_type = op_type;
 846         e->lease_idx = lease_idx;
 847         if (lease_idx != UINT32_MAX) {
 848                 e->client_guid = lck->data->leases[lease_idx].client_guid;
 849                 e->lease_key = lck->data->leases[lease_idx].lease_key;
 850         }
 851         e->time.tv_sec = fsp->open_time.tv_sec;
 852         e->time.tv_usec = fsp->open_time.tv_usec;
 853         e->share_file_id = fsp->fh->gen_id;
 854         e->uid = (uint32_t)uid;
 855         e->flags = (fsp->posix_flags & FSP_POSIX_FLAGS_OPEN) ?
 856                 SHARE_MODE_FLAG_POSIX_OPEN : 0;
 857         e->name_hash = fsp->name_hash;
 858
 859         return true;
 860 }
 861
 862 struct share_mode_entry *find_share_mode_entry(
 863         struct share_mode_lock *lck, files_struct *fsp)
 864 {
 865         struct share_mode_data *d = lck->data;
 866         struct server_id pid;
 867         uint32_t i;
 868
 869         pid = messaging_server_id(fsp->conn->sconn->msg_ctx);
 870
 871         for (i=0; i<d->num_share_modes; i++) {
 872                 struct share_mode_entry *e = &d->share_modes[i];
 873
 874                 if (!is_valid_share_mode_entry(e)) {
 875                         continue;
 876                 }
 877                 if (!serverid_equal(&pid, &e->pid)) {
 878                         continue;
 879                 }
 880                 if (fsp->fh->gen_id != e->share_file_id) {
 881                         continue;
 882                 }
 883                 return e;
 884         }
 885         return NULL;
 886 }
 887
 888 /*******************************************************************
 889  Del the share mode of a file for this process.
 890 ********************************************************************/
 891
 892 bool del_share_mode(struct share_mode_lock *lck, files_struct *fsp)
 893 {
 894         struct share_mode_entry *e;
 895
 896         e = find_share_mode_entry(lck, fsp);
 897         if (e == NULL) {
 898                 return False;
 899         }
 900         remove_share_mode_lease(lck->data, e);
 901         *e = lck->data->share_modes[lck->data->num_share_modes-1];
 902         lck->data->num_share_modes -= 1;
 903         lck->data->modified = True;
 904         return True;
 905 }
 906
 907 bool mark_share_mode_disconnected(struct share_mode_lock *lck,
 908                                   struct files_struct *fsp)
 909 {
 910         struct share_mode_entry *e;
 911
 912         if (lck->data->num_share_modes != 1) {
 913                 return false;
 914         }
 915
 916         if (fsp->op == NULL) {
 917                 return false;
 918         }
 919         if (!fsp->op->global->durable) {
 920                 return false;
 921         }
 922
 923         e = find_share_mode_entry(lck, fsp);
 924         if (e == NULL) {
 925                 return false;
 926         }
 927
 928         DEBUG(10, ("Marking share mode entry disconnected for durable handle\n"));
 929
 930         server_id_set_disconnected(&e->pid);
 931
 932         /*
 933          * On reopen the caller needs to check that
 934          * the client comes with the correct handle.
 935          */
 936         e->share_file_id = fsp->op->global->open_persistent_id;
 937
 938         lck->data->modified = true;
 939         return true;
 940 }
 941
 942 /*******************************************************************
 943  Remove an oplock mid and mode entry from a share mode.
 944 ********************************************************************/
 945
 946 bool remove_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
 947 {
 948         struct share_mode_data *d = lck->data;
 949         struct share_mode_entry *e;
 950
 951         e = find_share_mode_entry(lck, fsp);
 952         if (e == NULL) {
 953                 return False;
 954         }
 955
 956         remove_share_mode_lease(d, e);
 957         d->modified = True;
 958         return true;
 959 }
 960
 961 /*******************************************************************
 962  Downgrade a oplock type from exclusive to level II.
 963 ********************************************************************/
 964
 965 bool downgrade_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
 966 {
 967         struct share_mode_entry *e;
 968
 969         e = find_share_mode_entry(lck, fsp);
 970         if (e == NULL) {
 971                 return False;
 972         }
 973
 974         e->op_type = LEVEL_II_OPLOCK;
 975         lck->data->modified = True;
 976         return True;
 977 }
 978
 979 /****************************************************************************
 980  Adds a delete on close token.
 981 ****************************************************************************/
 982
 983 static bool add_delete_on_close_token(struct share_mode_data *d,
 984                         uint32_t name_hash,
 985                         const struct security_token *nt_tok,
 986                         const struct security_unix_token *tok)
 987 {
 988         struct delete_token *tmp, *dtl;
 989
 990         tmp = talloc_realloc(d, d->delete_tokens, struct delete_token,
 991                              d->num_delete_tokens+1);
 992         if (tmp == NULL) {
 993                 return false;
 994         }
 995         d->delete_tokens = tmp;
 996         dtl = &d->delete_tokens[d->num_delete_tokens];
 997
 998         dtl->name_hash = name_hash;
 999         dtl->delete_nt_token = dup_nt_token(d->delete_tokens, nt_tok);
1000         if (dtl->delete_nt_token == NULL) {
1001                 return false;
1002         }
1003         dtl->delete_token = copy_unix_token(d->delete_tokens, tok);
1004         if (dtl->delete_token == NULL) {
1005                 return false;
1006         }
1007         d->num_delete_tokens += 1;
1008         d->modified = true;
1009         return true;
1010 }
1011
1012 void reset_delete_on_close_lck(files_struct *fsp,
1013                                struct share_mode_lock *lck)
1014 {
1015         struct share_mode_data *d = lck->data;
1016         uint32_t i;
1017
1018         for (i=0; i<d->num_delete_tokens; i++) {
1019                 struct delete_token *dt = &d->delete_tokens[i];
1020
1021                 if (dt->name_hash == fsp->name_hash) {
1022                         d->modified = true;
1023
1024                         /* Delete this entry. */
1025                         TALLOC_FREE(dt->delete_nt_token);
1026                         TALLOC_FREE(dt->delete_token);
1027                         *dt = d->delete_tokens[d->num_delete_tokens-1];
1028                         d->num_delete_tokens -= 1;
1029                 }
1030         }
1031 }
1032
1033 /****************************************************************************
1034  Sets the delete on close flag over all share modes on this file.
1035  Modify the share mode entry for all files open
1036  on this device and inode to tell other smbds we have
1037  changed the delete on close flag. This will be noticed
1038  in the close code, the last closer will delete the file
1039  if flag is set.
1040  This makes a copy of any struct security_unix_token into the
1041  lck entry. This function is used when the lock is already granted.
1042 ****************************************************************************/
1043
1044 void set_delete_on_close_lck(files_struct *fsp,
1045                         struct share_mode_lock *lck,
1046                         const struct security_token *nt_tok,
1047                         const struct security_unix_token *tok)
1048 {
1049         struct messaging_context *msg_ctx = fsp->conn->sconn->msg_ctx;
1050         struct share_mode_data *d = lck->data;
1051         uint32_t i;
1052         bool ret;
1053         DATA_BLOB fid_blob = {};
1054         enum ndr_err_code ndr_err;
1055
1056         SMB_ASSERT(nt_tok != NULL);
1057         SMB_ASSERT(tok != NULL);
1058
1059         for (i=0; i<d->num_delete_tokens; i++) {
1060                 struct delete_token *dt = &d->delete_tokens[i];
1061                 if (dt->name_hash == fsp->name_hash) {
1062                         d->modified = true;
1063
1064                         /* Replace this token with the given tok. */
1065                         TALLOC_FREE(dt->delete_nt_token);
1066                         dt->delete_nt_token = dup_nt_token(dt, nt_tok);
1067                         SMB_ASSERT(dt->delete_nt_token != NULL);
1068                         TALLOC_FREE(dt->delete_token);
1069                         dt->delete_token = copy_unix_token(dt, tok);
1070                         SMB_ASSERT(dt->delete_token != NULL);
1071
1072                         return;
1073                 }
1074         }
1075
1076         ret = add_delete_on_close_token(lck->data, fsp->name_hash, nt_tok, tok);
1077         SMB_ASSERT(ret);
1078
1079         ndr_err = ndr_push_struct_blob(&fid_blob, talloc_tos(), &fsp->file_id,
1080                                        (ndr_push_flags_fn_t)ndr_push_file_id);
1081         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1082                 DEBUG(10, ("ndr_push_file_id failed: %s\n",
1083                            ndr_errstr(ndr_err)));
1084         }
1085
1086         for (i=0; i<d->num_share_modes; i++) {
1087                 struct share_mode_entry *e = &d->share_modes[i];
1088                 NTSTATUS status;
1089
1090                 status = messaging_send(
1091                         msg_ctx, e->pid, MSG_SMB_NOTIFY_CANCEL_DELETED,
1092                         &fid_blob);
1093
1094                 if (!NT_STATUS_IS_OK(status)) {
1095                         struct server_id_buf tmp;
1096                         DEBUG(10, ("%s: messaging_send to %s returned %s\n",
1097                                    __func__, server_id_str_buf(e->pid, &tmp),
1098                                    nt_errstr(status)));
1099                 }
1100         }
1101
1102         TALLOC_FREE(fid_blob.data);
1103 }
1104
1105 bool set_delete_on_close(files_struct *fsp, bool delete_on_close,
1106                         const struct security_token *nt_tok,
1107                         const struct security_unix_token *tok)
1108 {
1109         struct share_mode_lock *lck;
1110
1111         DEBUG(10,("set_delete_on_close: %s delete on close flag for "
1112                   "%s, file %s\n",
1113                   delete_on_close ? "Adding" : "Removing", fsp_fnum_dbg(fsp),
1114                   fsp_str_dbg(fsp)));
1115
1116         lck = get_existing_share_mode_lock(talloc_tos(), fsp->file_id);
1117         if (lck == NULL) {
1118                 return False;
1119         }
1120
1121         if (delete_on_close) {
1122                 set_delete_on_close_lck(fsp, lck, nt_tok, tok);
1123         } else {
1124                 reset_delete_on_close_lck(fsp, lck);
1125         }
1126
1127         if (fsp->is_directory) {
1128                 SMB_ASSERT(!is_ntfs_stream_smb_fname(fsp->fsp_name));
1129                 send_stat_cache_delete_message(fsp->conn->sconn->msg_ctx,
1130                                                fsp->fsp_name->base_name);
1131         }
1132
1133         TALLOC_FREE(lck);
1134
1135         fsp->delete_on_close = delete_on_close;
1136
1137         return True;
1138 }
1139
1140 static struct delete_token *find_delete_on_close_token(
1141         struct share_mode_data *d, uint32_t name_hash)
1142 {
1143         uint32_t i;
1144
1145         DEBUG(10, ("find_delete_on_close_token: name_hash = 0x%x\n",
1146                    (unsigned int)name_hash));
1147
1148         for (i=0; i<d->num_delete_tokens; i++) {
1149                 struct delete_token *dt = &d->delete_tokens[i];
1150
1151                 DEBUG(10, ("find__delete_on_close_token: dt->name_hash = 0x%x\n",
1152                            (unsigned int)dt->name_hash ));
1153                 if (dt->name_hash == name_hash) {
1154                         return dt;
1155                 }
1156         }
1157         return NULL;
1158 }
1159
1160 /****************************************************************************
1161  Return the NT token and UNIX token if there's a match. Return true if
1162  found, false if not.
1163 ****************************************************************************/
1164
1165 bool get_delete_on_close_token(struct share_mode_lock *lck,
1166                                         uint32_t name_hash,
1167                                         const struct security_token **pp_nt_tok,
1168                                         const struct security_unix_token **pp_tok)
1169 {
1170         struct delete_token *dt;
1171
1172         dt = find_delete_on_close_token(lck->data, name_hash);
1173         if (dt == NULL) {
1174                 return false;
1175         }
1176         *pp_nt_tok = dt->delete_nt_token;
1177         *pp_tok =  dt->delete_token;
1178         return true;
1179 }
1180
1181 bool is_delete_on_close_set(struct share_mode_lock *lck, uint32_t name_hash)
1182 {
1183         return find_delete_on_close_token(lck->data, name_hash) != NULL;
1184 }
1185
1186 bool set_sticky_write_time(struct file_id fileid, struct timespec write_time)
1187 {
1188         struct share_mode_lock *lck;
1189
1190         DEBUG(5,("set_sticky_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->changed_write_time, &write_time) != 0) {
1201                 lck->data->modified = True;
1202                 lck->data->changed_write_time = write_time;
1203         }
1204
1205         TALLOC_FREE(lck);
1206         return True;
1207 }
1208
1209 bool set_write_time(struct file_id fileid, struct timespec write_time)
1210 {
1211         struct share_mode_lock *lck;
1212
1213         DEBUG(5,("set_write_time: %s id=%s\n",
1214                  timestring(talloc_tos(),
1215                             convert_timespec_to_time_t(write_time)),
1216                  file_id_string_tos(&fileid)));
1217
1218         lck = get_existing_share_mode_lock(talloc_tos(), fileid);
1219         if (lck == NULL) {
1220                 return False;
1221         }
1222
1223         if (timespec_compare(&lck->data->old_write_time, &write_time) != 0) {
1224                 lck->data->modified = True;
1225                 lck->data->old_write_time = write_time;
1226         }
1227
1228         TALLOC_FREE(lck);
1229         return True;
1230 }
1231
1232 struct timespec get_share_mode_write_time(struct share_mode_lock *lck)
1233 {
1234         struct share_mode_data *d = lck->data;
1235
1236         if (!null_timespec(d->changed_write_time)) {
1237                 return d->changed_write_time;
1238         }
1239         return d->old_write_time;
1240 }
1241
1242 bool file_has_open_streams(files_struct *fsp)
1243 {
1244         struct share_mode_lock *lock = NULL;
1245         struct share_mode_data *d = NULL;
1246         uint32_t i;
1247
1248         lock = get_existing_share_mode_lock(talloc_tos(), fsp->file_id);
1249         if (lock == NULL) {
1250                 return false;
1251         }
1252         d = lock->data;
1253
1254         for (i = 0; i < d->num_share_modes; i++) {
1255                 struct share_mode_entry *e = &d->share_modes[i];
1256
1257                 if (share_mode_stale_pid(d, i)) {
1258                         continue;
1259                 }
1260
1261                 if (e->private_options &
1262                     NTCREATEX_OPTIONS_PRIVATE_STREAM_BASEOPEN)
1263                 {
1264                         TALLOC_FREE(lock);
1265                         return true;
1266                 }
1267         }
1268
1269         TALLOC_FREE(lock);
1270         return false;
1271 }