source/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-2000
   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 2 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, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21
  22    Revision History:
  23
  24    12 aug 96: Erik.Devriendt@te6.siemens.be
  25    added support for shared memory implementation of share mode locking
  26
  27    May 1997. Jeremy Allison (jallison@whistle.com). Modified share mode
  28    locking to deal with multiple share modes per open file.
  29
  30    September 1997. Jeremy Allison (jallison@whistle.com). Added oplock
  31    support.
  32
  33    rewrtten completely to use new tdb code. Tridge, Dec '99
  34
  35    Added POSIX locking support. Jeremy Allison (jeremy@valinux.com), Apr. 2000.
  36 */
  37
  38 #include "includes.h"
  39 uint16 global_smbpid;
  40
  41 #undef DBGC_CLASS
  42 #define DBGC_CLASS DBGC_LOCKING
  43
  44 /* the locking database handle */
  45 static TDB_CONTEXT *tdb;
  46
  47 struct locking_data {
  48         union {
  49                 struct {
  50                         int num_share_mode_entries;
  51                         BOOL delete_on_close;
  52                 } s;
  53                 struct share_mode_entry dummy; /* Needed for alignment. */
  54         } u;
  55         /* the following two entries are implicit
  56            struct share_mode_entry modes[num_share_mode_entries];
  57            char file_name[];
  58         */
  59 };
  60
  61 /****************************************************************************
  62  Debugging aid :-).
  63 ****************************************************************************/
  64
  65 static const char *lock_type_name(enum brl_type lock_type)
  66 {
  67         return (lock_type == READ_LOCK) ? "READ" : "WRITE";
  68 }
  69
  70 /****************************************************************************
  71  Utility function called to see if a file region is locked.
  72 ****************************************************************************/
  73
  74 BOOL is_locked(files_struct *fsp,connection_struct *conn,
  75                SMB_BIG_UINT count,SMB_BIG_UINT offset,
  76                enum brl_type lock_type)
  77 {
  78         int snum = SNUM(conn);
  79         int strict_locking = lp_strict_locking(snum);
  80         BOOL ret;
  81
  82         if (count == 0)
  83                 return(False);
  84
  85         if (!lp_locking(snum) || !strict_locking)
  86                 return(False);
  87
  88         if (strict_locking == Auto) {
  89                 if  (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type) && (lock_type == READ_LOCK || lock_type == WRITE_LOCK)) {
  90                         DEBUG(10,("is_locked: optimisation - exclusive oplock on file %s\n", fsp->fsp_name ));
  91                         ret = 0;
  92                 } else if ((fsp->oplock_type == LEVEL_II_OPLOCK) &&
  93                            (lock_type == READ_LOCK)) {
  94                         DEBUG(10,("is_locked: optimisation - level II oplock on file %s\n", fsp->fsp_name ));
  95                         ret = 0;
  96                 } else {
  97                         ret = !brl_locktest(fsp->dev, fsp->inode, fsp->fnum,
  98                                      global_smbpid, procid_self(), conn->cnum,
  99                                      offset, count, lock_type);
 100                 }
 101         } else {
 102                 ret = !brl_locktest(fsp->dev, fsp->inode, fsp->fnum,
 103                                 global_smbpid, procid_self(), conn->cnum,
 104                                 offset, count, lock_type);
 105         }
 106
 107         DEBUG(10,("is_locked: brl start=%.0f len=%.0f %s for file %s\n",
 108                         (double)offset, (double)count, ret ? "locked" : "unlocked",
 109                         fsp->fsp_name ));
 110
 111         /*
 112          * There is no lock held by an SMB daemon, check to
 113          * see if there is a POSIX lock from a UNIX or NFS process.
 114          */
 115
 116         if(!ret && lp_posix_locking(snum)) {
 117                 ret = is_posix_locked(fsp, offset, count, lock_type);
 118
 119                 DEBUG(10,("is_locked: posix start=%.0f len=%.0f %s for file %s\n",
 120                                 (double)offset, (double)count, ret ? "locked" : "unlocked",
 121                                 fsp->fsp_name ));
 122         }
 123
 124         return ret;
 125 }
 126
 127 /****************************************************************************
 128  Utility function called by locking requests.
 129 ****************************************************************************/
 130
 131 static NTSTATUS do_lock(files_struct *fsp,connection_struct *conn, uint16 lock_pid,
 132                  SMB_BIG_UINT count,SMB_BIG_UINT offset,enum brl_type lock_type, BOOL *my_lock_ctx)
 133 {
 134         NTSTATUS status = NT_STATUS_LOCK_NOT_GRANTED;
 135
 136         if (!lp_locking(SNUM(conn)))
 137                 return NT_STATUS_OK;
 138
 139         /* NOTE! 0 byte long ranges ARE allowed and should be stored  */
 140
 141         DEBUG(10,("do_lock: lock type %s start=%.0f len=%.0f requested for file %s\n",
 142                   lock_type_name(lock_type), (double)offset, (double)count, fsp->fsp_name ));
 143
 144         if (OPEN_FSP(fsp) && fsp->can_lock && (fsp->conn == conn)) {
 145                 status = brl_lock(fsp->dev, fsp->inode, fsp->fnum,
 146                                   lock_pid, procid_self(), conn->cnum,
 147                                   offset, count,
 148                                   lock_type, my_lock_ctx);
 149
 150                 if (NT_STATUS_IS_OK(status) && lp_posix_locking(SNUM(conn))) {
 151
 152                         /*
 153                          * Try and get a POSIX lock on this range.
 154                          * Note that this is ok if it is a read lock
 155                          * overlapping on a different fd. JRA.
 156                          */
 157
 158                         if (!set_posix_lock(fsp, offset, count, lock_type)) {
 159                                 if (errno == EACCES || errno == EAGAIN)
 160                                         status = NT_STATUS_FILE_LOCK_CONFLICT;
 161                                 else
 162                                         status = map_nt_error_from_unix(errno);
 163
 164                                 /*
 165                                  * We failed to map - we must now remove the brl
 166                                  * lock entry.
 167                                  */
 168                                 (void)brl_unlock(fsp->dev, fsp->inode, fsp->fnum,
 169                                                                 lock_pid, procid_self(), conn->cnum,
 170                                                                 offset, count, False,
 171                                                                 NULL, NULL);
 172                         }
 173                 }
 174         }
 175
 176         return status;
 177 }
 178
 179 /****************************************************************************
 180  Utility function called by locking requests. This is *DISGUSTING*. It also
 181  appears to be "What Windows Does" (tm). Andrew, ever wonder why Windows 2000
 182  is so slow on the locking tests...... ? This is the reason. Much though I hate
 183  it, we need this. JRA.
 184 ****************************************************************************/
 185
 186 NTSTATUS do_lock_spin(files_struct *fsp,connection_struct *conn, uint16 lock_pid,
 187                  SMB_BIG_UINT count,SMB_BIG_UINT offset,enum brl_type lock_type, BOOL *my_lock_ctx)
 188 {
 189         int j, maxj = lp_lock_spin_count();
 190         int sleeptime = lp_lock_sleep_time();
 191         NTSTATUS status, ret;
 192
 193         if (maxj <= 0)
 194                 maxj = 1;
 195
 196         ret = NT_STATUS_OK; /* to keep dumb compilers happy */
 197
 198         for (j = 0; j < maxj; j++) {
 199                 status = do_lock(fsp, conn, lock_pid, count, offset, lock_type, my_lock_ctx);
 200                 if (!NT_STATUS_EQUAL(status, NT_STATUS_LOCK_NOT_GRANTED) &&
 201                     !NT_STATUS_EQUAL(status, NT_STATUS_FILE_LOCK_CONFLICT)) {
 202                         return status;
 203                 }
 204                 /* if we do fail then return the first error code we got */
 205                 if (j == 0) {
 206                         ret = status;
 207                         /* Don't spin if we blocked ourselves. */
 208                         if (*my_lock_ctx)
 209                                 return ret;
 210                 }
 211                 if (sleeptime)
 212                         sys_usleep(sleeptime);
 213         }
 214         return ret;
 215 }
 216
 217 /* Struct passed to brl_unlock. */
 218 struct posix_unlock_data_struct {
 219         files_struct *fsp;
 220         SMB_BIG_UINT offset;
 221         SMB_BIG_UINT count;
 222 };
 223
 224 /****************************************************************************
 225  Function passed to brl_unlock to allow POSIX unlock to be done first.
 226 ****************************************************************************/
 227
 228 static void posix_unlock(void *pre_data)
 229 {
 230         struct posix_unlock_data_struct *pdata = (struct posix_unlock_data_struct *)pre_data;
 231
 232         if (lp_posix_locking(SNUM(pdata->fsp->conn)))
 233                 release_posix_lock(pdata->fsp, pdata->offset, pdata->count);
 234 }
 235
 236 /****************************************************************************
 237  Utility function called by unlocking requests.
 238 ****************************************************************************/
 239
 240 NTSTATUS do_unlock(files_struct *fsp,connection_struct *conn, uint16 lock_pid,
 241                    SMB_BIG_UINT count,SMB_BIG_UINT offset)
 242 {
 243         BOOL ok = False;
 244         struct posix_unlock_data_struct posix_data;
 245
 246         if (!lp_locking(SNUM(conn)))
 247                 return NT_STATUS_OK;
 248
 249         if (!OPEN_FSP(fsp) || !fsp->can_lock || (fsp->conn != conn)) {
 250                 return NT_STATUS_INVALID_HANDLE;
 251         }
 252
 253         DEBUG(10,("do_unlock: unlock start=%.0f len=%.0f requested for file %s\n",
 254                   (double)offset, (double)count, fsp->fsp_name ));
 255
 256         /*
 257          * Remove the existing lock record from the tdb lockdb
 258          * before looking at POSIX locks. If this record doesn't
 259          * match then don't bother looking to remove POSIX locks.
 260          */
 261
 262         posix_data.fsp = fsp;
 263         posix_data.offset = offset;
 264         posix_data.count = count;
 265
 266         ok = brl_unlock(fsp->dev, fsp->inode, fsp->fnum,
 267                         lock_pid, procid_self(), conn->cnum, offset, count,
 268                         False, posix_unlock, (void *)&posix_data);
 269
 270         if (!ok) {
 271                 DEBUG(10,("do_unlock: returning ERRlock.\n" ));
 272                 return NT_STATUS_RANGE_NOT_LOCKED;
 273         }
 274         return NT_STATUS_OK;
 275 }
 276
 277 /****************************************************************************
 278  Remove any locks on this fd. Called from file_close().
 279 ****************************************************************************/
 280
 281 void locking_close_file(files_struct *fsp)
 282 {
 283         struct process_id pid = procid_self();
 284
 285         if (!lp_locking(SNUM(fsp->conn)))
 286                 return;
 287
 288         /*
 289          * Just release all the brl locks, no need to release individually.
 290          */
 291
 292         brl_close(fsp->dev, fsp->inode, pid, fsp->conn->cnum, fsp->fnum);
 293
 294         if(lp_posix_locking(SNUM(fsp->conn))) {
 295
 296                 /*
 297                  * Release all the POSIX locks.
 298                  */
 299                 posix_locking_close_file(fsp);
 300
 301         }
 302 }
 303
 304 /****************************************************************************
 305  Initialise the locking functions.
 306 ****************************************************************************/
 307
 308 static int open_read_only;
 309
 310 BOOL locking_init(int read_only)
 311 {
 312         brl_init(read_only);
 313
 314         if (tdb)
 315                 return True;
 316
 317         tdb = tdb_open_log(lock_path("locking.tdb"),
 318                         SMB_OPEN_DATABASE_TDB_HASH_SIZE, TDB_DEFAULT|(read_only?0x0:TDB_CLEAR_IF_FIRST),
 319                         read_only?O_RDONLY:O_RDWR|O_CREAT,
 320                         0644);
 321
 322         if (!tdb) {
 323                 DEBUG(0,("ERROR: Failed to initialise locking database\n"));
 324                 return False;
 325         }
 326
 327         if (!posix_locking_init(read_only))
 328                 return False;
 329
 330         open_read_only = read_only;
 331
 332         return True;
 333 }
 334
 335 /*******************************************************************
 336  Deinitialize the share_mode management.
 337 ******************************************************************/
 338
 339 BOOL locking_end(void)
 340 {
 341         BOOL ret = True;
 342
 343         brl_shutdown(open_read_only);
 344         if (tdb) {
 345                 if (tdb_close(tdb) != 0)
 346                         ret = False;
 347         }
 348
 349         return ret;
 350 }
 351
 352 /*******************************************************************
 353  Form a static locking key for a dev/inode pair.
 354 ******************************************************************/
 355
 356 /* key and data records in the tdb locking database */
 357 struct locking_key {
 358         SMB_DEV_T dev;
 359         SMB_INO_T ino;
 360 };
 361
 362 /*******************************************************************
 363  Form a static locking key for a dev/inode pair.
 364 ******************************************************************/
 365
 366 static TDB_DATA locking_key(SMB_DEV_T dev, SMB_INO_T inode)
 367 {
 368         static struct locking_key key;
 369         TDB_DATA kbuf;
 370
 371         memset(&key, '\0', sizeof(key));
 372         key.dev = dev;
 373         key.ino = inode;
 374         kbuf.dptr = (char *)&key;
 375         kbuf.dsize = sizeof(key);
 376         return kbuf;
 377 }
 378
 379 /*******************************************************************
 380  Print out a share mode.
 381 ********************************************************************/
 382
 383 char *share_mode_str(int num, struct share_mode_entry *e)
 384 {
 385         static pstring share_str;
 386
 387         slprintf(share_str, sizeof(share_str)-1, "share_mode_entry[%d]: "
 388                  "pid = %s, share_access = 0x%x, private_options = 0x%x, "
 389                  "access_mask = 0x%x, mid = 0x%x, type= 0x%x, file_id = %lu, "
 390                  "dev = 0x%x, inode = %.0f",
 391                  num, procid_str_static(&e->pid),
 392                  e->share_access, e->private_options,
 393                  e->access_mask, e->op_mid, e->op_type, e->share_file_id,
 394                  (unsigned int)e->dev, (double)e->inode );
 395
 396         return share_str;
 397 }
 398
 399 /*******************************************************************
 400  Print out a share mode table.
 401 ********************************************************************/
 402
 403 static void print_share_mode_table(struct locking_data *data)
 404 {
 405         int num_share_modes = data->u.s.num_share_mode_entries;
 406         struct share_mode_entry *shares =
 407                 (struct share_mode_entry *)(data + 1);
 408         int i;
 409
 410         for (i = 0; i < num_share_modes; i++) {
 411                 struct share_mode_entry *entry_p = &shares[i];
 412                 DEBUG(10,("print_share_mode_table: %s\n",
 413                           share_mode_str(i, entry_p)));
 414         }
 415 }
 416
 417 /*******************************************************************
 418  Get all share mode entries for a dev/inode pair.
 419 ********************************************************************/
 420
 421 static BOOL parse_share_modes(TDB_DATA dbuf, struct share_mode_lock *lck)
 422 {
 423         struct locking_data *data;
 424         int i;
 425
 426         if (dbuf.dsize < sizeof(struct locking_data)) {
 427                 DEBUG(0, ("parse_share_modes: buffer too short\n"));
 428                 return False;
 429         }
 430
 431         data = (struct locking_data *)dbuf.dptr;
 432
 433         lck->delete_on_close = data->u.s.delete_on_close;
 434         lck->num_share_modes = data->u.s.num_share_mode_entries;
 435
 436         DEBUG(10, ("parse_share_modes: delete_on_close: %d, "
 437                    "num_share_modes: %d\n", lck->delete_on_close,
 438                    lck->num_share_modes));
 439
 440         if ((lck->num_share_modes < 0) || (lck->num_share_modes > 1000000)) {
 441                 DEBUG(0, ("invalid number of share modes: %d\n",
 442                           lck->num_share_modes));
 443                 return False;
 444         }
 445
 446         lck->share_modes = NULL;
 447
 448         if (lck->num_share_modes != 0) {
 449
 450                 if (dbuf.dsize < (sizeof(struct locking_data) +
 451                                   (lck->num_share_modes *
 452                                    sizeof(struct share_mode_entry)))) {
 453                         DEBUG(0, ("parse_share_modes: buffer too short\n"));
 454                         return False;
 455                 }
 456
 457                 lck->share_modes = talloc_memdup(lck, dbuf.dptr+sizeof(*data),
 458                                                  lck->num_share_modes *
 459                                                  sizeof(struct share_mode_entry));
 460
 461                 if (lck->share_modes == NULL) {
 462                         DEBUG(0, ("talloc failed\n"));
 463                         return False;
 464                 }
 465         }
 466
 467         /* Save off the associated service path and filename. */
 468         lck->servicepath = talloc_strdup(lck, dbuf.dptr + sizeof(*data) +
 469                                       (lck->num_share_modes *
 470                                       sizeof(struct share_mode_entry)));
 471
 472         lck->filename = talloc_strdup(lck, dbuf.dptr + sizeof(*data) +
 473                                       (lck->num_share_modes *
 474                                       sizeof(struct share_mode_entry)) +
 475                                       strlen(lck->servicepath) + 1 );
 476
 477         /*
 478          * Ensure that each entry has a real process attached.
 479          */
 480
 481         for (i = 0; i < lck->num_share_modes; i++) {
 482                 struct share_mode_entry *entry_p = &lck->share_modes[i];
 483                 DEBUG(10,("parse_share_modes: %s\n",
 484                           share_mode_str(i, entry_p) ));
 485                 if (!process_exists(entry_p->pid)) {
 486                         DEBUG(10,("parse_share_modes: deleted %s\n",
 487                                   share_mode_str(i, entry_p) ));
 488                         entry_p->op_type = UNUSED_SHARE_MODE_ENTRY;
 489                         lck->modified = True;
 490                 }
 491         }
 492
 493         return True;
 494 }
 495
 496 static TDB_DATA unparse_share_modes(struct share_mode_lock *lck)
 497 {
 498         TDB_DATA result;
 499         int num_valid = 0;
 500         int i;
 501         struct locking_data *data;
 502         ssize_t offset;
 503         ssize_t sp_len;
 504
 505         result.dptr = NULL;
 506         result.dsize = 0;
 507
 508         for (i=0; i<lck->num_share_modes; i++) {
 509                 if (!is_unused_share_mode_entry(&lck->share_modes[i])) {
 510                         num_valid += 1;
 511                 }
 512         }
 513
 514         if (num_valid == 0) {
 515                 return result;
 516         }
 517
 518         sp_len = strlen(lck->servicepath);
 519
 520         result.dsize = sizeof(*data) +
 521                 lck->num_share_modes * sizeof(struct share_mode_entry) +
 522                 sp_len + 1 +
 523                 strlen(lck->filename) + 1;
 524         result.dptr = talloc_size(lck, result.dsize);
 525
 526         if (result.dptr == NULL) {
 527                 smb_panic("talloc failed\n");
 528         }
 529
 530         data = (struct locking_data *)result.dptr;
 531         ZERO_STRUCTP(data);
 532         data->u.s.num_share_mode_entries = lck->num_share_modes;
 533         data->u.s.delete_on_close = lck->delete_on_close;
 534         DEBUG(10, ("unparse_share_modes: del: %d, num: %d\n",
 535                    data->u.s.delete_on_close,
 536                    data->u.s.num_share_mode_entries));
 537         memcpy(result.dptr + sizeof(*data), lck->share_modes,
 538                sizeof(struct share_mode_entry)*lck->num_share_modes);
 539         offset = sizeof(*data) +
 540                 sizeof(struct share_mode_entry)*lck->num_share_modes;
 541         safe_strcpy(result.dptr + offset, lck->servicepath,
 542                     result.dsize - offset - 1);
 543         offset += sp_len + 1;
 544         safe_strcpy(result.dptr + offset, lck->filename,
 545                     result.dsize - offset - 1);
 546         print_share_mode_table(data);
 547         return result;
 548 }
 549
 550 static int share_mode_lock_destructor(void *p)
 551 {
 552         struct share_mode_lock *lck =
 553                 talloc_get_type_abort(p, struct share_mode_lock);
 554         TDB_DATA key = locking_key(lck->dev, lck->ino);
 555         TDB_DATA data;
 556
 557         if (!lck->modified) {
 558                 goto done;
 559         }
 560
 561         data = unparse_share_modes(lck);
 562
 563         if (data.dptr == NULL) {
 564                 if (!lck->fresh) {
 565                         /* There has been an entry before, delete it */
 566                         if (tdb_delete(tdb, key) == -1) {
 567                                 smb_panic("Could not delete share entry\n");
 568                         }
 569                 }
 570                 goto done;
 571         }
 572
 573         if (tdb_store(tdb, key, data, TDB_REPLACE) == -1) {
 574                 smb_panic("Could not store share mode entry\n");
 575         }
 576
 577  done:
 578         tdb_chainunlock(tdb, key);
 579
 580         return 0;
 581 }
 582
 583 struct share_mode_lock *get_share_mode_lock(TALLOC_CTX *mem_ctx,
 584                                                 SMB_DEV_T dev, SMB_INO_T ino,
 585                                                 const char *servicepath,
 586                                                 const char *fname)
 587 {
 588         struct share_mode_lock *lck;
 589         TDB_DATA key = locking_key(dev, ino);
 590         TDB_DATA data;
 591
 592         lck = TALLOC_P(mem_ctx, struct share_mode_lock);
 593         if (lck == NULL) {
 594                 DEBUG(0, ("talloc failed\n"));
 595                 return NULL;
 596         }
 597
 598         /* Ensure we set every field here as the destructor must be
 599            valid even if parse_share_modes fails. */
 600
 601         lck->servicepath = NULL;
 602         lck->filename = NULL;
 603         lck->dev = dev;
 604         lck->ino = ino;
 605         lck->num_share_modes = 0;
 606         lck->share_modes = NULL;
 607         lck->delete_on_close = False;
 608         lck->fresh = False;
 609         lck->modified = False;
 610
 611         if (tdb_chainlock(tdb, key) != 0) {
 612                 DEBUG(3, ("Could not lock share entry\n"));
 613                 talloc_free(lck);
 614                 return NULL;
 615         }
 616
 617         /* We must set the destructor immediately after the chainlock
 618            ensure the lock is cleaned up on any of the error return
 619            paths below. */
 620
 621         talloc_set_destructor(lck, share_mode_lock_destructor);
 622
 623         data = tdb_fetch(tdb, key);
 624         lck->fresh = (data.dptr == NULL);
 625
 626         if (lck->fresh) {
 627
 628                 if (fname == NULL || servicepath == NULL) {
 629                         DEBUG(0, ("New file, but no filename or servicepath supplied\n"));
 630                         talloc_free(lck);
 631                         return NULL;
 632                 }
 633                 lck->filename = talloc_strdup(lck, fname);
 634                 lck->servicepath = talloc_strdup(lck, servicepath);
 635                 if (lck->filename == NULL || lck->servicepath == NULL) {
 636                         DEBUG(0, ("talloc failed\n"));
 637                         talloc_free(lck);
 638                         return NULL;
 639                 }
 640         } else {
 641                 if (!parse_share_modes(data, lck)) {
 642                         DEBUG(0, ("Could not parse share modes\n"));
 643                         talloc_free(lck);
 644                         SAFE_FREE(data.dptr);
 645                         return NULL;
 646                 }
 647         }
 648
 649         SAFE_FREE(data.dptr);
 650
 651         return lck;
 652 }
 653
 654 /*******************************************************************
 655  Sets the service name and filename for rename.
 656  At this point we emit "file renamed" messages to all
 657  process id's that have this file open.
 658  Based on an initial code idea from SATOH Fumiyasu <fumiya@samba.gr.jp>
 659 ********************************************************************/
 660
 661 BOOL rename_share_filename(struct share_mode_lock *lck,
 662                         const char *servicepath,
 663                         const char *newname)
 664 {
 665         size_t sp_len;
 666         size_t fn_len;
 667         size_t msg_len;
 668         char *frm = NULL;
 669         int i;
 670
 671         if (!lck) {
 672                 return False;
 673         }
 674
 675         DEBUG(10, ("rename_share_filename: servicepath %s newname %s\n",
 676                 servicepath, newname));
 677
 678         /*
 679          * rename_internal_fsp() and rename_internals() add './' to
 680          * head of newname if newname does not contain a '/'.
 681          */
 682         while (newname[0] && newname[1] && newname[0] == '.' && newname[1] == '/') {
 683                 newname += 2;
 684         }
 685
 686         lck->servicepath = talloc_strdup(lck, servicepath);
 687         lck->filename = talloc_strdup(lck, newname);
 688         if (lck->filename == NULL || lck->servicepath == NULL) {
 689                 DEBUG(0, ("rename_share_filename: talloc failed\n"));
 690                 return False;
 691         }
 692         lck->modified = True;
 693
 694         sp_len = strlen(lck->servicepath);
 695         fn_len = strlen(lck->filename);
 696
 697         msg_len = MSG_FILE_RENAMED_MIN_SIZE + sp_len + 1 + fn_len + 1;
 698
 699         /* Set up the name changed message. */
 700         frm = TALLOC(lck, msg_len);
 701         if (!frm) {
 702                 return False;
 703         }
 704
 705         SDEV_T_VAL(frm,0,lck->dev);
 706         SINO_T_VAL(frm,8,lck->ino);
 707
 708         DEBUG(10,("rename_share_filename: msg_len = %d\n", msg_len ));
 709
 710         safe_strcpy(&frm[16], lck->servicepath, sp_len);
 711         safe_strcpy(&frm[16 + sp_len + 1], lck->filename, fn_len);
 712
 713         /* Send the messages. */
 714         for (i=0; i<lck->num_share_modes; i++) {
 715                 struct share_mode_entry *se = &lck->share_modes[i];
 716                 if (!is_valid_share_mode_entry(se)) {
 717                         continue;
 718                 }
 719                 /* But not to ourselves... */
 720                 if (procid_is_me(&se->pid)) {
 721                         continue;
 722                 }
 723
 724                 DEBUG(10,("rename_share_filename: sending rename message to pid %u "
 725                         "dev %x, inode  %.0f sharepath %s newname %s\n",
 726                         (unsigned int)procid_to_pid(&se->pid),
 727                         (unsigned int)lck->dev, (double)lck->ino,
 728                         lck->servicepath, lck->filename ));
 729
 730                 become_root();
 731                 message_send_pid(se->pid, MSG_SMB_FILE_RENAME,
 732                                 frm, msg_len, True);
 733                 unbecome_root();
 734         }
 735
 736         return True;
 737 }
 738
 739 BOOL get_delete_on_close_flag(SMB_DEV_T dev, SMB_INO_T inode)
 740 {
 741         BOOL result;
 742         struct share_mode_lock *lck = get_share_mode_lock(NULL, dev, inode, NULL, NULL);
 743         if (!lck) {
 744                 return False;
 745         }
 746         result = lck->delete_on_close;
 747         talloc_free(lck);
 748         return result;
 749 }
 750
 751 BOOL is_valid_share_mode_entry(const struct share_mode_entry *e)
 752 {
 753         int num_props = 0;
 754
 755         num_props += ((e->op_type == NO_OPLOCK) ? 1 : 0);
 756         num_props += (EXCLUSIVE_OPLOCK_TYPE(e->op_type) ? 1 : 0);
 757         num_props += (LEVEL_II_OPLOCK_TYPE(e->op_type) ? 1 : 0);
 758
 759         SMB_ASSERT(num_props <= 1);
 760         return (num_props != 0);
 761 }
 762
 763 BOOL is_deferred_open_entry(const struct share_mode_entry *e)
 764 {
 765         return (e->op_type == DEFERRED_OPEN_ENTRY);
 766 }
 767
 768 BOOL is_unused_share_mode_entry(const struct share_mode_entry *e)
 769 {
 770         return (e->op_type == UNUSED_SHARE_MODE_ENTRY);
 771 }
 772
 773 /*******************************************************************
 774  Fill a share mode entry.
 775 ********************************************************************/
 776
 777 static void fill_share_mode_entry(struct share_mode_entry *e,
 778                                   files_struct *fsp,
 779                                   uint16 mid, uint16 op_type)
 780 {
 781         ZERO_STRUCTP(e);
 782         e->pid = procid_self();
 783         e->share_access = fsp->share_access;
 784         e->private_options = fsp->fh->private_options;
 785         e->access_mask = fsp->access_mask;
 786         e->op_mid = mid;
 787         e->op_type = op_type;
 788         e->time.tv_sec = fsp->open_time.tv_sec;
 789         e->time.tv_usec = fsp->open_time.tv_usec;
 790         e->share_file_id = fsp->file_id;
 791         e->dev = fsp->dev;
 792         e->inode = fsp->inode;
 793 }
 794
 795 static void fill_deferred_open_entry(struct share_mode_entry *e,
 796                                      const struct timeval request_time,
 797                                      SMB_DEV_T dev, SMB_INO_T ino, uint16 mid)
 798 {
 799         ZERO_STRUCTP(e);
 800         e->pid = procid_self();
 801         e->op_mid = mid;
 802         e->op_type = DEFERRED_OPEN_ENTRY;
 803         e->time.tv_sec = request_time.tv_sec;
 804         e->time.tv_usec = request_time.tv_usec;
 805         e->dev = dev;
 806         e->inode = ino;
 807 }
 808
 809 static void add_share_mode_entry(struct share_mode_lock *lck,
 810                                  const struct share_mode_entry *entry)
 811 {
 812         int i;
 813
 814         for (i=0; i<lck->num_share_modes; i++) {
 815                 struct share_mode_entry *e = &lck->share_modes[i];
 816                 if (is_unused_share_mode_entry(e)) {
 817                         *e = *entry;
 818                         break;
 819                 }
 820         }
 821
 822         if (i == lck->num_share_modes) {
 823                 /* No unused entry found */
 824                 ADD_TO_ARRAY(lck, struct share_mode_entry, *entry,
 825                              &lck->share_modes, &lck->num_share_modes);
 826         }
 827         lck->modified = True;
 828 }
 829
 830 void set_share_mode(struct share_mode_lock *lck, files_struct *fsp,
 831                     uint16 mid, uint16 op_type)
 832 {
 833         struct share_mode_entry entry;
 834         fill_share_mode_entry(&entry, fsp, mid, op_type);
 835         add_share_mode_entry(lck, &entry);
 836 }
 837
 838 void add_deferred_open(struct share_mode_lock *lck, uint16 mid,
 839                        struct timeval request_time,
 840                        SMB_DEV_T dev, SMB_INO_T ino)
 841 {
 842         struct share_mode_entry entry;
 843         fill_deferred_open_entry(&entry, request_time, dev, ino, mid);
 844         add_share_mode_entry(lck, &entry);
 845 }
 846
 847 /*******************************************************************
 848  Check if two share mode entries are identical, ignoring oplock
 849  and mid info and desired_access.
 850 ********************************************************************/
 851
 852 static BOOL share_modes_identical(struct share_mode_entry *e1,
 853                                   struct share_mode_entry *e2)
 854 {
 855 #if 1 /* JRA PARANOIA TEST - REMOVE LATER */
 856         if (procid_equal(&e1->pid, &e2->pid) &&
 857             e1->share_file_id == e2->share_file_id &&
 858             e1->dev == e2->dev &&
 859             e1->inode == e2->inode &&
 860             (e1->share_access) != (e2->share_access)) {
 861                 DEBUG(0,("PANIC: share_modes_identical: share_mode "
 862                          "mismatch (e1 = 0x%x, e2 = 0x%x). Logic error.\n",
 863                          (unsigned int)e1->share_access,
 864                          (unsigned int)e2->share_access ));
 865                 smb_panic("PANIC: share_modes_identical logic error.\n");
 866         }
 867 #endif
 868
 869         return (procid_equal(&e1->pid, &e2->pid) &&
 870                 (e1->share_access) == (e2->share_access) &&
 871                 e1->dev == e2->dev &&
 872                 e1->inode == e2->inode &&
 873                 e1->share_file_id == e2->share_file_id );
 874 }
 875
 876 static BOOL deferred_open_identical(struct share_mode_entry *e1,
 877                                     struct share_mode_entry *e2)
 878 {
 879         return (procid_equal(&e1->pid, &e2->pid) &&
 880                 (e1->op_mid == e2->op_mid) &&
 881                 (e1->dev == e2->dev) &&
 882                 (e1->inode == e2->inode));
 883 }
 884
 885 static struct share_mode_entry *find_share_mode_entry(struct share_mode_lock *lck,
 886                                                       struct share_mode_entry *entry)
 887 {
 888         int i;
 889
 890         for (i=0; i<lck->num_share_modes; i++) {
 891                 struct share_mode_entry *e = &lck->share_modes[i];
 892                 if (is_valid_share_mode_entry(entry) &&
 893                     is_valid_share_mode_entry(e) &&
 894                     share_modes_identical(e, entry)) {
 895                         return e;
 896                 }
 897                 if (is_deferred_open_entry(entry) &&
 898                     is_deferred_open_entry(e) &&
 899                     deferred_open_identical(e, entry)) {
 900                         return e;
 901                 }
 902         }
 903         return NULL;
 904 }
 905
 906 /*******************************************************************
 907  Del the share mode of a file for this process. Return the number of
 908  entries left.
 909 ********************************************************************/
 910
 911 BOOL del_share_mode(struct share_mode_lock *lck, files_struct *fsp)
 912 {
 913         struct share_mode_entry entry, *e;
 914
 915         fill_share_mode_entry(&entry, fsp, 0, 0);
 916
 917         e = find_share_mode_entry(lck, &entry);
 918         if (e == NULL) {
 919                 return False;
 920         }
 921
 922         e->op_type = UNUSED_SHARE_MODE_ENTRY;
 923         lck->modified = True;
 924         return True;
 925 }
 926
 927 void del_deferred_open_entry(struct share_mode_lock *lck, uint16 mid)
 928 {
 929         struct share_mode_entry entry, *e;
 930
 931         fill_deferred_open_entry(&entry, timeval_zero(),
 932                                  lck->dev, lck->ino, mid);
 933
 934         e = find_share_mode_entry(lck, &entry);
 935         if (e == NULL) {
 936                 return;
 937         }
 938
 939         e->op_type = UNUSED_SHARE_MODE_ENTRY;
 940         lck->modified = True;
 941 }
 942
 943 /*******************************************************************
 944  Remove an oplock mid and mode entry from a share mode.
 945 ********************************************************************/
 946
 947 BOOL remove_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
 948 {
 949         struct share_mode_entry entry, *e;
 950
 951         fill_share_mode_entry(&entry, fsp, 0, 0);
 952
 953         e = find_share_mode_entry(lck, &entry);
 954         if (e == NULL) {
 955                 return False;
 956         }
 957
 958         e->op_mid = 0;
 959         e->op_type = NO_OPLOCK;
 960         lck->modified = True;
 961         return True;
 962 }
 963
 964 /*******************************************************************
 965  Downgrade a oplock type from exclusive to level II.
 966 ********************************************************************/
 967
 968 BOOL downgrade_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
 969 {
 970         struct share_mode_entry entry, *e;
 971
 972         fill_share_mode_entry(&entry, fsp, 0, 0);
 973
 974         e = find_share_mode_entry(lck, &entry);
 975         if (e == NULL) {
 976                 return False;
 977         }
 978
 979         e->op_type = LEVEL_II_OPLOCK;
 980         lck->modified = True;
 981         return True;
 982 }
 983
 984
 985 /*******************************************************************
 986  We've just told all the smbd's that our level2 or fake level2 has been
 987  written to.
 988 ********************************************************************/
 989 BOOL remove_all_share_oplocks(struct share_mode_lock *lck, files_struct *fsp)
 990 {
 991         int i;
 992         for (i=0; i<lck->num_share_modes; i++) {
 993                 struct share_mode_entry *e = &lck->share_modes[i];
 994                 if (!is_valid_share_mode_entry(e)) {
 995                         continue;
 996                 }
 997                 if (e->op_type == NO_OPLOCK) {
 998                         continue;
 999                 }
1000                 e->op_type = NO_OPLOCK;
1001                 lck->modified = True;
1002         }
1003         return True;
1004 }
1005
1006 /****************************************************************************
1007  Deal with the internal needs of setting the delete on close flag. Note that
1008  as the tdb locking is recursive, it is safe to call this from within
1009  open_file_shared. JRA.
1010 ****************************************************************************/
1011
1012 NTSTATUS can_set_delete_on_close(files_struct *fsp, BOOL delete_on_close,
1013                                  uint32 dosmode)
1014 {
1015         if (!delete_on_close) {
1016                 return NT_STATUS_OK;
1017         }
1018
1019         /*
1020          * Only allow delete on close for writable files.
1021          */
1022
1023         if ((dosmode & aRONLY) &&
1024             !lp_delete_readonly(SNUM(fsp->conn))) {
1025                 DEBUG(10,("can_set_delete_on_close: file %s delete on close "
1026                           "flag set but file attribute is readonly.\n",
1027                           fsp->fsp_name ));
1028                 return NT_STATUS_CANNOT_DELETE;
1029         }
1030
1031         /*
1032          * Only allow delete on close for writable shares.
1033          */
1034
1035         if (!CAN_WRITE(fsp->conn)) {
1036                 DEBUG(10,("can_set_delete_on_close: file %s delete on "
1037                           "close flag set but write access denied on share.\n",
1038                           fsp->fsp_name ));
1039                 return NT_STATUS_ACCESS_DENIED;
1040         }
1041
1042         /*
1043          * Only allow delete on close for files/directories opened with delete
1044          * intent.
1045          */
1046
1047         if (!(fsp->access_mask & DELETE_ACCESS)) {
1048                 DEBUG(10,("can_set_delete_on_close: file %s delete on "
1049                           "close flag set but delete access denied.\n",
1050                           fsp->fsp_name ));
1051                 return NT_STATUS_ACCESS_DENIED;
1052         }
1053
1054         return NT_STATUS_OK;
1055 }
1056
1057 /****************************************************************************
1058  Sets the delete on close flag over all share modes on this file.
1059  Modify the share mode entry for all files open
1060  on this device and inode to tell other smbds we have
1061  changed the delete on close flag. This will be noticed
1062  in the close code, the last closer will delete the file
1063  if flag is set.
1064 ****************************************************************************/
1065
1066 BOOL set_delete_on_close(files_struct *fsp, BOOL delete_on_close)
1067 {
1068         struct share_mode_lock *lck;
1069
1070         DEBUG(10,("set_delete_on_close: %s delete on close flag for "
1071                   "fnum = %d, file %s\n",
1072                   delete_on_close ? "Adding" : "Removing", fsp->fnum,
1073                   fsp->fsp_name ));
1074
1075         if (fsp->is_stat) {
1076                 return True;
1077         }
1078
1079         lck = get_share_mode_lock(NULL, fsp->dev, fsp->inode, NULL, NULL);
1080         if (lck == NULL) {
1081                 return False;
1082         }
1083         if (lck->delete_on_close != delete_on_close) {
1084                 lck->delete_on_close = delete_on_close;
1085                 lck->modified = True;
1086         }
1087
1088         talloc_free(lck);
1089         return True;
1090 }
1091
1092 static int traverse_fn(TDB_CONTEXT *the_tdb, TDB_DATA kbuf, TDB_DATA dbuf,
1093                        void *state)
1094 {
1095         struct locking_data *data;
1096         struct share_mode_entry *shares;
1097         const char *sharepath;
1098         const char *fname;
1099         int i;
1100         void (*traverse_callback)(struct share_mode_entry *, const char *, const char *) = state;
1101
1102         /* Ensure this is a locking_key record. */
1103         if (kbuf.dsize != sizeof(struct locking_key))
1104                 return 0;
1105
1106         data = (struct locking_data *)dbuf.dptr;
1107         shares = (struct share_mode_entry *)(dbuf.dptr + sizeof(*data));
1108         sharepath = dbuf.dptr + sizeof(*data) +
1109                 data->u.s.num_share_mode_entries*sizeof(*shares);
1110         fname = dbuf.dptr + sizeof(*data) +
1111                 data->u.s.num_share_mode_entries*sizeof(*shares) +
1112                 strlen(sharepath) + 1;
1113
1114         for (i=0;i<data->u.s.num_share_mode_entries;i++) {
1115                 traverse_callback(&shares[i], sharepath, fname);
1116         }
1117         return 0;
1118 }
1119
1120 /*******************************************************************
1121  Call the specified function on each entry under management by the
1122  share mode system.
1123 ********************************************************************/
1124
1125 int share_mode_forall(void (*fn)(const struct share_mode_entry *, const char *, const char *))
1126 {
1127         if (tdb == NULL)
1128                 return 0;
1129         return tdb_traverse(tdb, traverse_fn, fn);
1130 }