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 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    Added Unix Extensions POSIX locking support. Jeremy Allison Mar 2006.
  37 */
  38
  39 #include "includes.h"
  40
  41 #undef DBGC_CLASS
  42 #define DBGC_CLASS DBGC_LOCKING
  43
  44 /* the locking database handle */
  45 static TDB_CONTEXT *tdb;
  46
  47 /****************************************************************************
  48  Debugging aids :-).
  49 ****************************************************************************/
  50
  51 const char *lock_type_name(enum brl_type lock_type)
  52 {
  53         switch (lock_type) {
  54                 case READ_LOCK:
  55                         return "READ";
  56                 case WRITE_LOCK:
  57                         return "WRITE";
  58                 case PENDING_READ_LOCK:
  59                         return "PENDING_READ";
  60                 case PENDING_WRITE_LOCK:
  61                         return "PENDING_WRITE";
  62                 default:
  63                         return "other";
  64         }
  65 }
  66
  67 const char *lock_flav_name(enum brl_flavour lock_flav)
  68 {
  69         return (lock_flav == WINDOWS_LOCK) ? "WINDOWS_LOCK" : "POSIX_LOCK";
  70 }
  71
  72 /****************************************************************************
  73  Utility function called to see if a file region is locked.
  74  Called in the read/write codepath.
  75 ****************************************************************************/
  76
  77 BOOL is_locked(files_struct *fsp,
  78                 uint32 smbpid,
  79                 SMB_BIG_UINT count,
  80                 SMB_BIG_UINT offset,
  81                 enum brl_type lock_type)
  82 {
  83         int strict_locking = lp_strict_locking(fsp->conn->params);
  84         enum brl_flavour lock_flav = lp_posix_cifsu_locktype(fsp);
  85         BOOL ret = True;
  86
  87         if (count == 0) {
  88                 return False;
  89         }
  90
  91         if (!lp_locking(fsp->conn->params) || !strict_locking) {
  92                 return False;
  93         }
  94
  95         if (strict_locking == Auto) {
  96                 if  (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type) && (lock_type == READ_LOCK || lock_type == WRITE_LOCK)) {
  97                         DEBUG(10,("is_locked: optimisation - exclusive oplock on file %s\n", fsp->fsp_name ));
  98                         ret = False;
  99                 } else if ((fsp->oplock_type == LEVEL_II_OPLOCK) &&
 100                            (lock_type == READ_LOCK)) {
 101                         DEBUG(10,("is_locked: optimisation - level II oplock on file %s\n", fsp->fsp_name ));
 102                         ret = False;
 103                 } else {
 104                         struct byte_range_lock *br_lck = brl_get_locks_readonly(NULL, fsp);
 105                         if (!br_lck) {
 106                                 return False;
 107                         }
 108                         ret = !brl_locktest(br_lck,
 109                                         smbpid,
 110                                         procid_self(),
 111                                         offset,
 112                                         count,
 113                                         lock_type,
 114                                         lock_flav);
 115                         TALLOC_FREE(br_lck);
 116                 }
 117         } else {
 118                 struct byte_range_lock *br_lck = brl_get_locks_readonly(NULL, fsp);
 119                 if (!br_lck) {
 120                         return False;
 121                 }
 122                 ret = !brl_locktest(br_lck,
 123                                 smbpid,
 124                                 procid_self(),
 125                                 offset,
 126                                 count,
 127                                 lock_type,
 128                                 lock_flav);
 129                 TALLOC_FREE(br_lck);
 130         }
 131
 132         DEBUG(10,("is_locked: flavour = %s brl start=%.0f len=%.0f %s for fnum %d file %s\n",
 133                         lock_flav_name(lock_flav),
 134                         (double)offset, (double)count, ret ? "locked" : "unlocked",
 135                         fsp->fnum, fsp->fsp_name ));
 136
 137         return ret;
 138 }
 139
 140 /****************************************************************************
 141  Find out if a lock could be granted - return who is blocking us if we can't.
 142 ****************************************************************************/
 143
 144 NTSTATUS query_lock(files_struct *fsp,
 145                         uint32 *psmbpid,
 146                         SMB_BIG_UINT *pcount,
 147                         SMB_BIG_UINT *poffset,
 148                         enum brl_type *plock_type,
 149                         enum brl_flavour lock_flav)
 150 {
 151         struct byte_range_lock *br_lck = NULL;
 152         NTSTATUS status = NT_STATUS_LOCK_NOT_GRANTED;
 153
 154         if (!fsp->can_lock) {
 155                 return fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
 156         }
 157
 158         if (!lp_locking(fsp->conn->params)) {
 159                 return NT_STATUS_OK;
 160         }
 161
 162         br_lck = brl_get_locks_readonly(NULL, fsp);
 163         if (!br_lck) {
 164                 return NT_STATUS_NO_MEMORY;
 165         }
 166
 167         status = brl_lockquery(br_lck,
 168                         psmbpid,
 169                         procid_self(),
 170                         poffset,
 171                         pcount,
 172                         plock_type,
 173                         lock_flav);
 174
 175         TALLOC_FREE(br_lck);
 176         return status;
 177 }
 178
 179 /****************************************************************************
 180  Utility function called by locking requests.
 181 ****************************************************************************/
 182
 183 struct byte_range_lock *do_lock(files_struct *fsp,
 184                         uint32 lock_pid,
 185                         SMB_BIG_UINT count,
 186                         SMB_BIG_UINT offset,
 187                         enum brl_type lock_type,
 188                         enum brl_flavour lock_flav,
 189                         BOOL blocking_lock,
 190                         NTSTATUS *perr)
 191 {
 192         struct byte_range_lock *br_lck = NULL;
 193
 194         if (!fsp->can_lock) {
 195                 *perr = fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
 196                 return NULL;
 197         }
 198
 199         if (!lp_locking(fsp->conn->params)) {
 200                 *perr = NT_STATUS_OK;
 201                 return NULL;
 202         }
 203
 204         /* NOTE! 0 byte long ranges ARE allowed and should be stored  */
 205
 206         DEBUG(10,("do_lock: lock flavour %s lock type %s start=%.0f len=%.0f requested for fnum %d file %s\n",
 207                 lock_flav_name(lock_flav), lock_type_name(lock_type),
 208                 (double)offset, (double)count, fsp->fnum, fsp->fsp_name ));
 209
 210         br_lck = brl_get_locks(NULL, fsp);
 211         if (!br_lck) {
 212                 *perr = NT_STATUS_NO_MEMORY;
 213                 return NULL;
 214         }
 215
 216         *perr = brl_lock(br_lck,
 217                         lock_pid,
 218                         procid_self(),
 219                         offset,
 220                         count,
 221                         lock_type,
 222                         lock_flav,
 223                         blocking_lock);
 224
 225         return br_lck;
 226 }
 227
 228 /****************************************************************************
 229  Utility function called by unlocking requests.
 230 ****************************************************************************/
 231
 232 NTSTATUS do_unlock(files_struct *fsp,
 233                         uint32 lock_pid,
 234                         SMB_BIG_UINT count,
 235                         SMB_BIG_UINT offset,
 236                         enum brl_flavour lock_flav)
 237 {
 238         BOOL ok = False;
 239         struct byte_range_lock *br_lck = NULL;
 240
 241         if (!fsp->can_lock) {
 242                 return fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
 243         }
 244
 245         if (!lp_locking(fsp->conn->params)) {
 246                 return NT_STATUS_OK;
 247         }
 248
 249         DEBUG(10,("do_unlock: unlock start=%.0f len=%.0f requested for fnum %d file %s\n",
 250                   (double)offset, (double)count, fsp->fnum, fsp->fsp_name ));
 251
 252         br_lck = brl_get_locks(NULL, fsp);
 253         if (!br_lck) {
 254                 return NT_STATUS_NO_MEMORY;
 255         }
 256
 257         ok = brl_unlock(br_lck,
 258                         lock_pid,
 259                         procid_self(),
 260                         offset,
 261                         count,
 262                         lock_flav);
 263
 264         TALLOC_FREE(br_lck);
 265
 266         if (!ok) {
 267                 DEBUG(10,("do_unlock: returning ERRlock.\n" ));
 268                 return NT_STATUS_RANGE_NOT_LOCKED;
 269         }
 270
 271         return NT_STATUS_OK;
 272 }
 273
 274 /****************************************************************************
 275  Cancel any pending blocked locks.
 276 ****************************************************************************/
 277
 278 NTSTATUS do_lock_cancel(files_struct *fsp,
 279                         uint32 lock_pid,
 280                         SMB_BIG_UINT count,
 281                         SMB_BIG_UINT offset,
 282                         enum brl_flavour lock_flav)
 283 {
 284         BOOL ok = False;
 285         struct byte_range_lock *br_lck = NULL;
 286
 287         if (!fsp->can_lock) {
 288                 return fsp->is_directory ?
 289                         NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
 290         }
 291
 292         if (!lp_locking(fsp->conn->params)) {
 293                 return NT_STATUS_DOS(ERRDOS, ERRcancelviolation);
 294         }
 295
 296         DEBUG(10,("do_lock_cancel: cancel start=%.0f len=%.0f requested for fnum %d file %s\n",
 297                   (double)offset, (double)count, fsp->fnum, fsp->fsp_name ));
 298
 299         br_lck = brl_get_locks(NULL, fsp);
 300         if (!br_lck) {
 301                 return NT_STATUS_NO_MEMORY;
 302         }
 303
 304         ok = brl_lock_cancel(br_lck,
 305                         lock_pid,
 306                         procid_self(),
 307                         offset,
 308                         count,
 309                         lock_flav);
 310
 311         TALLOC_FREE(br_lck);
 312
 313         if (!ok) {
 314                 DEBUG(10,("do_lock_cancel: returning ERRcancelviolation.\n" ));
 315                 return NT_STATUS_DOS(ERRDOS, ERRcancelviolation);
 316         }
 317
 318         return NT_STATUS_OK;
 319 }
 320
 321 /****************************************************************************
 322  Remove any locks on this fd. Called from file_close().
 323 ****************************************************************************/
 324
 325 void locking_close_file(files_struct *fsp)
 326 {
 327         struct byte_range_lock *br_lck;
 328
 329         if (!lp_locking(fsp->conn->params)) {
 330                 return;
 331         }
 332
 333         br_lck = brl_get_locks(NULL,fsp);
 334
 335         if (br_lck) {
 336                 cancel_pending_lock_requests_by_fid(fsp, br_lck);
 337                 brl_close_fnum(br_lck);
 338                 TALLOC_FREE(br_lck);
 339         }
 340 }
 341
 342 /****************************************************************************
 343  Initialise the locking functions.
 344 ****************************************************************************/
 345
 346 static int open_read_only;
 347
 348 BOOL locking_init(int read_only)
 349 {
 350         brl_init(read_only);
 351
 352         if (tdb)
 353                 return True;
 354
 355         tdb = tdb_open_log(lock_path("locking.tdb"),
 356                         lp_open_files_db_hash_size(),
 357                         TDB_DEFAULT|(read_only?0x0:TDB_CLEAR_IF_FIRST),
 358                         read_only?O_RDONLY:O_RDWR|O_CREAT,
 359                         0644);
 360
 361         if (!tdb) {
 362                 DEBUG(0,("ERROR: Failed to initialise locking database\n"));
 363                 return False;
 364         }
 365
 366         if (!posix_locking_init(read_only))
 367                 return False;
 368
 369         open_read_only = read_only;
 370
 371         return True;
 372 }
 373
 374 /*******************************************************************
 375  Deinitialize the share_mode management.
 376 ******************************************************************/
 377
 378 BOOL locking_end(void)
 379 {
 380         BOOL ret = True;
 381
 382         brl_shutdown(open_read_only);
 383         if (tdb) {
 384                 if (tdb_close(tdb) != 0)
 385                         ret = False;
 386         }
 387
 388         return ret;
 389 }
 390
 391 /*******************************************************************
 392  Form a static locking key for a dev/inode pair.
 393 ******************************************************************/
 394
 395 /* key and data records in the tdb locking database */
 396 struct locking_key {
 397         SMB_DEV_T dev;
 398         SMB_INO_T ino;
 399 };
 400
 401 /*******************************************************************
 402  Form a static locking key for a dev/inode pair.
 403 ******************************************************************/
 404
 405 static TDB_DATA locking_key(SMB_DEV_T dev, SMB_INO_T inode)
 406 {
 407         static struct locking_key key;
 408         TDB_DATA kbuf;
 409
 410         memset(&key, '\0', sizeof(key));
 411         key.dev = dev;
 412         key.ino = inode;
 413         kbuf.dptr = (char *)&key;
 414         kbuf.dsize = sizeof(key);
 415         return kbuf;
 416 }
 417
 418 /*******************************************************************
 419  Print out a share mode.
 420 ********************************************************************/
 421
 422 char *share_mode_str(int num, struct share_mode_entry *e)
 423 {
 424         static pstring share_str;
 425
 426         slprintf(share_str, sizeof(share_str)-1, "share_mode_entry[%d]: %s "
 427                  "pid = %s, share_access = 0x%x, private_options = 0x%x, "
 428                  "access_mask = 0x%x, mid = 0x%x, type= 0x%x, file_id = %lu, "
 429                  "uid = %u, flags = %u, dev = 0x%x, inode = %.0f",
 430                  num,
 431                  e->op_type == UNUSED_SHARE_MODE_ENTRY ? "UNUSED" : "",
 432                  procid_str_static(&e->pid),
 433                  e->share_access, e->private_options,
 434                  e->access_mask, e->op_mid, e->op_type, e->share_file_id,
 435                  (unsigned int)e->uid, (unsigned int)e->flags,
 436                  (unsigned int)e->dev, (double)e->inode );
 437
 438         return share_str;
 439 }
 440
 441 /*******************************************************************
 442  Print out a share mode table.
 443 ********************************************************************/
 444
 445 static void print_share_mode_table(struct locking_data *data)
 446 {
 447         int num_share_modes = data->u.s.num_share_mode_entries;
 448         struct share_mode_entry *shares =
 449                 (struct share_mode_entry *)(data + 1);
 450         int i;
 451
 452         for (i = 0; i < num_share_modes; i++) {
 453                 struct share_mode_entry entry;
 454
 455                 memcpy(&entry, &shares[i], sizeof(struct share_mode_entry));
 456                 DEBUG(10,("print_share_mode_table: %s\n",
 457                           share_mode_str(i, &entry)));
 458         }
 459 }
 460
 461 /*******************************************************************
 462  Get all share mode entries for a dev/inode pair.
 463 ********************************************************************/
 464
 465 static BOOL parse_share_modes(TDB_DATA dbuf, struct share_mode_lock *lck)
 466 {
 467         struct locking_data *data;
 468         int i;
 469
 470         if (dbuf.dsize < sizeof(struct locking_data)) {
 471                 smb_panic("PANIC: parse_share_modes: buffer too short.\n");
 472         }
 473
 474         data = (struct locking_data *)dbuf.dptr;
 475
 476         lck->delete_on_close = data->u.s.delete_on_close;
 477         lck->num_share_modes = data->u.s.num_share_mode_entries;
 478
 479         DEBUG(10, ("parse_share_modes: delete_on_close: %d, "
 480                    "num_share_modes: %d\n",
 481                 lck->delete_on_close,
 482                 lck->num_share_modes));
 483
 484         if ((lck->num_share_modes < 0) || (lck->num_share_modes > 1000000)) {
 485                 DEBUG(0, ("invalid number of share modes: %d\n",
 486                           lck->num_share_modes));
 487                 smb_panic("PANIC: invalid number of share modes");
 488         }
 489
 490         lck->share_modes = NULL;
 491
 492         if (lck->num_share_modes != 0) {
 493
 494                 if (dbuf.dsize < (sizeof(struct locking_data) +
 495                                   (lck->num_share_modes *
 496                                    sizeof(struct share_mode_entry)))) {
 497                         smb_panic("PANIC: parse_share_modes: buffer too short.\n");
 498                 }
 499
 500                 lck->share_modes = (struct share_mode_entry *)
 501                         talloc_memdup(lck, dbuf.dptr+sizeof(*data),
 502                                       lck->num_share_modes *
 503                                       sizeof(struct share_mode_entry));
 504
 505                 if (lck->share_modes == NULL) {
 506                         smb_panic("talloc failed\n");
 507                 }
 508         }
 509
 510         /* Get any delete token. */
 511         if (data->u.s.delete_token_size) {
 512                 char *p = dbuf.dptr + sizeof(*data) +
 513                                 (lck->num_share_modes *
 514                                 sizeof(struct share_mode_entry));
 515
 516                 if ((data->u.s.delete_token_size < sizeof(uid_t) + sizeof(gid_t)) ||
 517                                 ((data->u.s.delete_token_size - sizeof(uid_t)) % sizeof(gid_t)) != 0) {
 518                         DEBUG(0, ("parse_share_modes: invalid token size %d\n",
 519                                 data->u.s.delete_token_size));
 520                         smb_panic("parse_share_modes: invalid token size\n");
 521                 }
 522
 523                 lck->delete_token = TALLOC_P(lck, UNIX_USER_TOKEN);
 524                 if (!lck->delete_token) {
 525                         smb_panic("talloc failed\n");
 526                 }
 527
 528                 /* Copy out the uid and gid. */
 529                 memcpy(&lck->delete_token->uid, p, sizeof(uid_t));
 530                 p += sizeof(uid_t);
 531                 memcpy(&lck->delete_token->gid, p, sizeof(gid_t));
 532                 p += sizeof(gid_t);
 533
 534                 /* Any supplementary groups ? */
 535                 lck->delete_token->ngroups = (data->u.s.delete_token_size > (sizeof(uid_t) + sizeof(gid_t))) ?
 536                                         ((data->u.s.delete_token_size -
 537                                                 (sizeof(uid_t) + sizeof(gid_t)))/sizeof(gid_t)) : 0;
 538
 539                 if (lck->delete_token->ngroups) {
 540                         /* Make this a talloc child of lck->delete_token. */
 541                         lck->delete_token->groups = TALLOC_ARRAY(lck->delete_token, gid_t,
 542                                                         lck->delete_token->ngroups);
 543                         if (!lck->delete_token) {
 544                                 smb_panic("talloc failed\n");
 545                         }
 546
 547                         for (i = 0; i < lck->delete_token->ngroups; i++) {
 548                                 memcpy(&lck->delete_token->groups[i], p, sizeof(gid_t));
 549                                 p += sizeof(gid_t);
 550                         }
 551                 }
 552
 553         } else {
 554                 lck->delete_token = NULL;
 555         }
 556
 557         /* Save off the associated service path and filename. */
 558         lck->servicepath = talloc_strdup(lck, dbuf.dptr + sizeof(*data) +
 559                                         (lck->num_share_modes *
 560                                         sizeof(struct share_mode_entry)) +
 561                                         data->u.s.delete_token_size );
 562         if (lck->servicepath == NULL) {
 563                 smb_panic("talloc_strdup failed\n");
 564         }
 565
 566         lck->filename = talloc_strdup(lck, dbuf.dptr + sizeof(*data) +
 567                                         (lck->num_share_modes *
 568                                         sizeof(struct share_mode_entry)) +
 569                                         data->u.s.delete_token_size +
 570                                         strlen(lck->servicepath) + 1 );
 571         if (lck->filename == NULL) {
 572                 smb_panic("talloc_strdup failed\n");
 573         }
 574
 575         /*
 576          * Ensure that each entry has a real process attached.
 577          */
 578
 579         for (i = 0; i < lck->num_share_modes; i++) {
 580                 struct share_mode_entry *entry_p = &lck->share_modes[i];
 581                 DEBUG(10,("parse_share_modes: %s\n",
 582                           share_mode_str(i, entry_p) ));
 583                 if (!process_exists(entry_p->pid)) {
 584                         DEBUG(10,("parse_share_modes: deleted %s\n",
 585                                   share_mode_str(i, entry_p) ));
 586                         entry_p->op_type = UNUSED_SHARE_MODE_ENTRY;
 587                         lck->modified = True;
 588                 }
 589         }
 590
 591         return True;
 592 }
 593
 594 static TDB_DATA unparse_share_modes(struct share_mode_lock *lck)
 595 {
 596         TDB_DATA result;
 597         int num_valid = 0;
 598         int i;
 599         struct locking_data *data;
 600         ssize_t offset;
 601         ssize_t sp_len;
 602         uint32 delete_token_size;
 603
 604         result.dptr = NULL;
 605         result.dsize = 0;
 606
 607         for (i=0; i<lck->num_share_modes; i++) {
 608                 if (!is_unused_share_mode_entry(&lck->share_modes[i])) {
 609                         num_valid += 1;
 610                 }
 611         }
 612
 613         if (num_valid == 0) {
 614                 return result;
 615         }
 616
 617         sp_len = strlen(lck->servicepath);
 618         delete_token_size = (lck->delete_token ?
 619                         (sizeof(uid_t) + sizeof(gid_t) + (lck->delete_token->ngroups*sizeof(gid_t))) : 0);
 620
 621         result.dsize = sizeof(*data) +
 622                 lck->num_share_modes * sizeof(struct share_mode_entry) +
 623                 delete_token_size +
 624                 sp_len + 1 +
 625                 strlen(lck->filename) + 1;
 626         result.dptr = TALLOC_ARRAY(lck, char, result.dsize);
 627
 628         if (result.dptr == NULL) {
 629                 smb_panic("talloc failed\n");
 630         }
 631
 632         data = (struct locking_data *)result.dptr;
 633         ZERO_STRUCTP(data);
 634         data->u.s.num_share_mode_entries = lck->num_share_modes;
 635         data->u.s.delete_on_close = lck->delete_on_close;
 636         data->u.s.delete_token_size = delete_token_size;
 637         DEBUG(10, ("unparse_share_modes: del: %d, tok = %u, num: %d\n",
 638                 data->u.s.delete_on_close,
 639                 (unsigned int)data->u.s.delete_token_size,
 640                 data->u.s.num_share_mode_entries));
 641         memcpy(result.dptr + sizeof(*data), lck->share_modes,
 642                sizeof(struct share_mode_entry)*lck->num_share_modes);
 643         offset = sizeof(*data) +
 644                 sizeof(struct share_mode_entry)*lck->num_share_modes;
 645
 646         /* Store any delete on close token. */
 647         if (lck->delete_token) {
 648                 char *p = result.dptr + offset;
 649
 650                 memcpy(p, &lck->delete_token->uid, sizeof(uid_t));
 651                 p += sizeof(uid_t);
 652
 653                 memcpy(p, &lck->delete_token->gid, sizeof(gid_t));
 654                 p += sizeof(gid_t);
 655
 656                 for (i = 0; i < lck->delete_token->ngroups; i++) {
 657                         memcpy(p, &lck->delete_token->groups[i], sizeof(gid_t));
 658                         p += sizeof(gid_t);
 659                 }
 660                 offset = p - result.dptr;
 661         }
 662
 663         safe_strcpy(result.dptr + offset, lck->servicepath,
 664                     result.dsize - offset - 1);
 665         offset += sp_len + 1;
 666         safe_strcpy(result.dptr + offset, lck->filename,
 667                     result.dsize - offset - 1);
 668
 669         if (DEBUGLEVEL >= 10) {
 670                 print_share_mode_table(data);
 671         }
 672
 673         return result;
 674 }
 675
 676 static int share_mode_lock_destructor(struct share_mode_lock *lck)
 677 {
 678         TDB_DATA key = locking_key(lck->dev, lck->ino);
 679         TDB_DATA data;
 680
 681         if (!lck->modified) {
 682                 goto done;
 683         }
 684
 685         data = unparse_share_modes(lck);
 686
 687         if (data.dptr == NULL) {
 688                 if (!lck->fresh) {
 689                         /* There has been an entry before, delete it */
 690                         if (tdb_delete(tdb, key) == -1) {
 691                                 smb_panic("Could not delete share entry\n");
 692                         }
 693                 }
 694                 goto done;
 695         }
 696
 697         if (tdb_store(tdb, key, data, TDB_REPLACE) == -1) {
 698                 smb_panic("Could not store share mode entry\n");
 699         }
 700
 701  done:
 702         tdb_chainunlock(tdb, key);
 703
 704         return 0;
 705 }
 706
 707 struct share_mode_lock *get_share_mode_lock(TALLOC_CTX *mem_ctx,
 708                                                 SMB_DEV_T dev, SMB_INO_T ino,
 709                                                 const char *servicepath,
 710                                                 const char *fname)
 711 {
 712         struct share_mode_lock *lck;
 713         TDB_DATA key = locking_key(dev, ino);
 714         TDB_DATA data;
 715
 716         lck = TALLOC_P(mem_ctx, struct share_mode_lock);
 717         if (lck == NULL) {
 718                 DEBUG(0, ("talloc failed\n"));
 719                 return NULL;
 720         }
 721
 722         /* Ensure we set every field here as the destructor must be
 723            valid even if parse_share_modes fails. */
 724
 725         lck->servicepath = NULL;
 726         lck->filename = NULL;
 727         lck->dev = dev;
 728         lck->ino = ino;
 729         lck->num_share_modes = 0;
 730         lck->share_modes = NULL;
 731         lck->delete_token = NULL;
 732         lck->delete_on_close = False;
 733         lck->fresh = False;
 734         lck->modified = False;
 735
 736         if (tdb_chainlock(tdb, key) != 0) {
 737                 DEBUG(3, ("Could not lock share entry\n"));
 738                 TALLOC_FREE(lck);
 739                 return NULL;
 740         }
 741
 742         /* We must set the destructor immediately after the chainlock
 743            ensure the lock is cleaned up on any of the error return
 744            paths below. */
 745
 746         talloc_set_destructor(lck, share_mode_lock_destructor);
 747
 748         data = tdb_fetch(tdb, key);
 749         lck->fresh = (data.dptr == NULL);
 750
 751         if (lck->fresh) {
 752
 753                 if (fname == NULL || servicepath == NULL) {
 754                         TALLOC_FREE(lck);
 755                         return NULL;
 756                 }
 757                 lck->filename = talloc_strdup(lck, fname);
 758                 lck->servicepath = talloc_strdup(lck, servicepath);
 759                 if (lck->filename == NULL || lck->servicepath == NULL) {
 760                         DEBUG(0, ("talloc failed\n"));
 761                         TALLOC_FREE(lck);
 762                         return NULL;
 763                 }
 764         } else {
 765                 if (!parse_share_modes(data, lck)) {
 766                         DEBUG(0, ("Could not parse share modes\n"));
 767                         TALLOC_FREE(lck);
 768                         SAFE_FREE(data.dptr);
 769                         return NULL;
 770                 }
 771         }
 772
 773         SAFE_FREE(data.dptr);
 774
 775         return lck;
 776 }
 777
 778 /*******************************************************************
 779  Sets the service name and filename for rename.
 780  At this point we emit "file renamed" messages to all
 781  process id's that have this file open.
 782  Based on an initial code idea from SATOH Fumiyasu <fumiya@samba.gr.jp>
 783 ********************************************************************/
 784
 785 BOOL rename_share_filename(struct share_mode_lock *lck,
 786                         const char *servicepath,
 787                         const char *newname)
 788 {
 789         size_t sp_len;
 790         size_t fn_len;
 791         size_t msg_len;
 792         char *frm = NULL;
 793         int i;
 794
 795         if (!lck) {
 796                 return False;
 797         }
 798
 799         DEBUG(10, ("rename_share_filename: servicepath %s newname %s\n",
 800                 servicepath, newname));
 801
 802         /*
 803          * rename_internal_fsp() and rename_internals() add './' to
 804          * head of newname if newname does not contain a '/'.
 805          */
 806         while (newname[0] && newname[1] && newname[0] == '.' && newname[1] == '/') {
 807                 newname += 2;
 808         }
 809
 810         lck->servicepath = talloc_strdup(lck, servicepath);
 811         lck->filename = talloc_strdup(lck, newname);
 812         if (lck->filename == NULL || lck->servicepath == NULL) {
 813                 DEBUG(0, ("rename_share_filename: talloc failed\n"));
 814                 return False;
 815         }
 816         lck->modified = True;
 817
 818         sp_len = strlen(lck->servicepath);
 819         fn_len = strlen(lck->filename);
 820
 821         msg_len = MSG_FILE_RENAMED_MIN_SIZE + sp_len + 1 + fn_len + 1;
 822
 823         /* Set up the name changed message. */
 824         frm = TALLOC_ARRAY(lck, char, msg_len);
 825         if (!frm) {
 826                 return False;
 827         }
 828
 829         SDEV_T_VAL(frm,0,lck->dev);
 830         SINO_T_VAL(frm,8,lck->ino);
 831
 832         DEBUG(10,("rename_share_filename: msg_len = %u\n", (unsigned int)msg_len ));
 833
 834         safe_strcpy(&frm[16], lck->servicepath, sp_len);
 835         safe_strcpy(&frm[16 + sp_len + 1], lck->filename, fn_len);
 836
 837         /* Send the messages. */
 838         for (i=0; i<lck->num_share_modes; i++) {
 839                 struct share_mode_entry *se = &lck->share_modes[i];
 840                 if (!is_valid_share_mode_entry(se)) {
 841                         continue;
 842                 }
 843                 /* But not to ourselves... */
 844                 if (procid_is_me(&se->pid)) {
 845                         continue;
 846                 }
 847
 848                 DEBUG(10,("rename_share_filename: sending rename message to pid %s "
 849                         "dev %x, inode  %.0f sharepath %s newname %s\n",
 850                         procid_str_static(&se->pid),
 851                         (unsigned int)lck->dev, (double)lck->ino,
 852                         lck->servicepath, lck->filename ));
 853
 854                 message_send_pid(se->pid, MSG_SMB_FILE_RENAME,
 855                                 frm, msg_len, True);
 856         }
 857
 858         return True;
 859 }
 860
 861 static int pull_delete_on_close_flag(TDB_DATA key, TDB_DATA dbuf,
 862                                      void *private_data)
 863 {
 864         BOOL *result = (BOOL *)private_data;
 865         struct locking_data *data;
 866
 867         if (dbuf.dsize < sizeof(struct locking_data)) {
 868                 smb_panic("PANIC: parse_share_modes: buffer too short.\n");
 869         }
 870
 871         data = (struct locking_data *)dbuf.dptr;
 872
 873         *result = data->u.s.delete_on_close;
 874         return 0;
 875 }
 876
 877 BOOL get_delete_on_close_flag(SMB_DEV_T dev, SMB_INO_T inode)
 878 {
 879         TDB_DATA key = locking_key(dev, inode);
 880         BOOL result = False;
 881
 882         tdb_parse_record(tdb, key, pull_delete_on_close_flag,
 883                          (void *)&result);
 884         return result;
 885 }
 886
 887 BOOL is_valid_share_mode_entry(const struct share_mode_entry *e)
 888 {
 889         int num_props = 0;
 890
 891         num_props += ((e->op_type == NO_OPLOCK) ? 1 : 0);
 892         num_props += (EXCLUSIVE_OPLOCK_TYPE(e->op_type) ? 1 : 0);
 893         num_props += (LEVEL_II_OPLOCK_TYPE(e->op_type) ? 1 : 0);
 894
 895         SMB_ASSERT(num_props <= 1);
 896         return (num_props != 0);
 897 }
 898
 899 BOOL is_deferred_open_entry(const struct share_mode_entry *e)
 900 {
 901         return (e->op_type == DEFERRED_OPEN_ENTRY);
 902 }
 903
 904 BOOL is_unused_share_mode_entry(const struct share_mode_entry *e)
 905 {
 906         return (e->op_type == UNUSED_SHARE_MODE_ENTRY);
 907 }
 908
 909 /*******************************************************************
 910  Fill a share mode entry.
 911 ********************************************************************/
 912
 913 static void fill_share_mode_entry(struct share_mode_entry *e,
 914                                   files_struct *fsp,
 915                                   uid_t uid, uint16 mid, uint16 op_type)
 916 {
 917         ZERO_STRUCTP(e);
 918         e->pid = procid_self();
 919         e->share_access = fsp->share_access;
 920         e->private_options = fsp->fh->private_options;
 921         e->access_mask = fsp->access_mask;
 922         e->op_mid = mid;
 923         e->op_type = op_type;
 924         e->time.tv_sec = fsp->open_time.tv_sec;
 925         e->time.tv_usec = fsp->open_time.tv_usec;
 926         e->dev = fsp->dev;
 927         e->inode = fsp->inode;
 928         e->share_file_id = fsp->fh->file_id;
 929         e->uid = (uint32)uid;
 930         e->flags = fsp->posix_open ? SHARE_MODE_FLAG_POSIX_OPEN : 0;
 931 }
 932
 933 static void fill_deferred_open_entry(struct share_mode_entry *e,
 934                                      const struct timeval request_time,
 935                                      SMB_DEV_T dev, SMB_INO_T ino, uint16 mid)
 936 {
 937         ZERO_STRUCTP(e);
 938         e->pid = procid_self();
 939         e->op_mid = mid;
 940         e->op_type = DEFERRED_OPEN_ENTRY;
 941         e->time.tv_sec = request_time.tv_sec;
 942         e->time.tv_usec = request_time.tv_usec;
 943         e->dev = dev;
 944         e->inode = ino;
 945         e->uid = (uint32)-1;
 946         e->flags = 0;
 947 }
 948
 949 static void add_share_mode_entry(struct share_mode_lock *lck,
 950                                  const struct share_mode_entry *entry)
 951 {
 952         int i;
 953
 954         for (i=0; i<lck->num_share_modes; i++) {
 955                 struct share_mode_entry *e = &lck->share_modes[i];
 956                 if (is_unused_share_mode_entry(e)) {
 957                         *e = *entry;
 958                         break;
 959                 }
 960         }
 961
 962         if (i == lck->num_share_modes) {
 963                 /* No unused entry found */
 964                 ADD_TO_ARRAY(lck, struct share_mode_entry, *entry,
 965                              &lck->share_modes, &lck->num_share_modes);
 966         }
 967         lck->modified = True;
 968 }
 969
 970 void set_share_mode(struct share_mode_lock *lck, files_struct *fsp,
 971                         uid_t uid, uint16 mid, uint16 op_type)
 972 {
 973         struct share_mode_entry entry;
 974         fill_share_mode_entry(&entry, fsp, uid, mid, op_type);
 975         add_share_mode_entry(lck, &entry);
 976 }
 977
 978 void add_deferred_open(struct share_mode_lock *lck, uint16 mid,
 979                        struct timeval request_time,
 980                        SMB_DEV_T dev, SMB_INO_T ino)
 981 {
 982         struct share_mode_entry entry;
 983         fill_deferred_open_entry(&entry, request_time, dev, ino, mid);
 984         add_share_mode_entry(lck, &entry);
 985 }
 986
 987 /*******************************************************************
 988  Check if two share mode entries are identical, ignoring oplock
 989  and mid info and desired_access. (Removed paranoia test - it's
 990  not automatically a logic error if they are identical. JRA.)
 991 ********************************************************************/
 992
 993 static BOOL share_modes_identical(struct share_mode_entry *e1,
 994                                   struct share_mode_entry *e2)
 995 {
 996         /* We used to check for e1->share_access == e2->share_access here
 997            as well as the other fields but 2 different DOS or FCB opens
 998            sharing the same share mode entry may validly differ in
 999            fsp->share_access field. */
1000
1001         return (procid_equal(&e1->pid, &e2->pid) &&
1002                 e1->dev == e2->dev &&
1003                 e1->inode == e2->inode &&
1004                 e1->share_file_id == e2->share_file_id );
1005 }
1006
1007 static BOOL deferred_open_identical(struct share_mode_entry *e1,
1008                                     struct share_mode_entry *e2)
1009 {
1010         return (procid_equal(&e1->pid, &e2->pid) &&
1011                 (e1->op_mid == e2->op_mid) &&
1012                 (e1->dev == e2->dev) &&
1013                 (e1->inode == e2->inode));
1014 }
1015
1016 static struct share_mode_entry *find_share_mode_entry(struct share_mode_lock *lck,
1017                                                       struct share_mode_entry *entry)
1018 {
1019         int i;
1020
1021         for (i=0; i<lck->num_share_modes; i++) {
1022                 struct share_mode_entry *e = &lck->share_modes[i];
1023                 if (is_valid_share_mode_entry(entry) &&
1024                     is_valid_share_mode_entry(e) &&
1025                     share_modes_identical(e, entry)) {
1026                         return e;
1027                 }
1028                 if (is_deferred_open_entry(entry) &&
1029                     is_deferred_open_entry(e) &&
1030                     deferred_open_identical(e, entry)) {
1031                         return e;
1032                 }
1033         }
1034         return NULL;
1035 }
1036
1037 /*******************************************************************
1038  Del the share mode of a file for this process. Return the number of
1039  entries left.
1040 ********************************************************************/
1041
1042 BOOL del_share_mode(struct share_mode_lock *lck, files_struct *fsp)
1043 {
1044         struct share_mode_entry entry, *e;
1045
1046         /* Don't care about the pid owner being correct here - just a search. */
1047         fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
1048
1049         e = find_share_mode_entry(lck, &entry);
1050         if (e == NULL) {
1051                 return False;
1052         }
1053
1054         e->op_type = UNUSED_SHARE_MODE_ENTRY;
1055         lck->modified = True;
1056         return True;
1057 }
1058
1059 void del_deferred_open_entry(struct share_mode_lock *lck, uint16 mid)
1060 {
1061         struct share_mode_entry entry, *e;
1062
1063         fill_deferred_open_entry(&entry, timeval_zero(),
1064                                  lck->dev, lck->ino, mid);
1065
1066         e = find_share_mode_entry(lck, &entry);
1067         if (e == NULL) {
1068                 return;
1069         }
1070
1071         e->op_type = UNUSED_SHARE_MODE_ENTRY;
1072         lck->modified = True;
1073 }
1074
1075 /*******************************************************************
1076  Remove an oplock mid and mode entry from a share mode.
1077 ********************************************************************/
1078
1079 BOOL remove_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
1080 {
1081         struct share_mode_entry entry, *e;
1082
1083         /* Don't care about the pid owner being correct here - just a search. */
1084         fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
1085
1086         e = find_share_mode_entry(lck, &entry);
1087         if (e == NULL) {
1088                 return False;
1089         }
1090
1091         e->op_mid = 0;
1092         e->op_type = NO_OPLOCK;
1093         lck->modified = True;
1094         return True;
1095 }
1096
1097 /*******************************************************************
1098  Downgrade a oplock type from exclusive to level II.
1099 ********************************************************************/
1100
1101 BOOL downgrade_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
1102 {
1103         struct share_mode_entry entry, *e;
1104
1105         /* Don't care about the pid owner being correct here - just a search. */
1106         fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
1107
1108         e = find_share_mode_entry(lck, &entry);
1109         if (e == NULL) {
1110                 return False;
1111         }
1112
1113         e->op_type = LEVEL_II_OPLOCK;
1114         lck->modified = True;
1115         return True;
1116 }
1117
1118 /****************************************************************************
1119  Deal with the internal needs of setting the delete on close flag. Note that
1120  as the tdb locking is recursive, it is safe to call this from within
1121  open_file_ntcreate. JRA.
1122 ****************************************************************************/
1123
1124 NTSTATUS can_set_delete_on_close(files_struct *fsp, BOOL delete_on_close,
1125                                  uint32 dosmode)
1126 {
1127         if (!delete_on_close) {
1128                 return NT_STATUS_OK;
1129         }
1130
1131         /*
1132          * Only allow delete on close for writable files.
1133          */
1134
1135         if ((dosmode & aRONLY) &&
1136             !lp_delete_readonly(SNUM(fsp->conn))) {
1137                 DEBUG(10,("can_set_delete_on_close: file %s delete on close "
1138                           "flag set but file attribute is readonly.\n",
1139                           fsp->fsp_name ));
1140                 return NT_STATUS_CANNOT_DELETE;
1141         }
1142
1143         /*
1144          * Only allow delete on close for writable shares.
1145          */
1146
1147         if (!CAN_WRITE(fsp->conn)) {
1148                 DEBUG(10,("can_set_delete_on_close: file %s delete on "
1149                           "close flag set but write access denied on share.\n",
1150                           fsp->fsp_name ));
1151                 return NT_STATUS_ACCESS_DENIED;
1152         }
1153
1154         /*
1155          * Only allow delete on close for files/directories opened with delete
1156          * intent.
1157          */
1158
1159         if (!(fsp->access_mask & DELETE_ACCESS)) {
1160                 DEBUG(10,("can_set_delete_on_close: file %s delete on "
1161                           "close flag set but delete access denied.\n",
1162                           fsp->fsp_name ));
1163                 return NT_STATUS_ACCESS_DENIED;
1164         }
1165
1166         /* Don't allow delete on close for non-empty directories. */
1167         if (fsp->is_directory) {
1168                 return can_delete_directory(fsp->conn, fsp->fsp_name);
1169         }
1170
1171         return NT_STATUS_OK;
1172 }
1173
1174 /*************************************************************************
1175  Return a talloced copy of a UNIX_USER_TOKEN. NULL on fail.
1176  (Should this be in locking.c.... ?).
1177 *************************************************************************/
1178
1179 static UNIX_USER_TOKEN *copy_unix_token(TALLOC_CTX *ctx, UNIX_USER_TOKEN *tok)
1180 {
1181         UNIX_USER_TOKEN *cpy;
1182
1183         if (tok == NULL) {
1184                 return NULL;
1185         }
1186
1187         cpy = TALLOC_P(ctx, UNIX_USER_TOKEN);
1188         if (!cpy) {
1189                 return NULL;
1190         }
1191
1192         cpy->uid = tok->uid;
1193         cpy->gid = tok->gid;
1194         cpy->ngroups = tok->ngroups;
1195         if (tok->ngroups) {
1196                 /* Make this a talloc child of cpy. */
1197                 cpy->groups = TALLOC_ARRAY(cpy, gid_t, tok->ngroups);
1198                 if (!cpy->groups) {
1199                         return NULL;
1200                 }
1201                 memcpy(cpy->groups, tok->groups, tok->ngroups * sizeof(gid_t));
1202         }
1203         return cpy;
1204 }
1205
1206 /****************************************************************************
1207  Replace the delete on close token.
1208 ****************************************************************************/
1209
1210 void set_delete_on_close_token(struct share_mode_lock *lck, UNIX_USER_TOKEN *tok)
1211 {
1212         /* Ensure there's no token. */
1213         if (lck->delete_token) {
1214                 TALLOC_FREE(lck->delete_token); /* Also deletes groups... */
1215                 lck->delete_token = NULL;
1216         }
1217
1218         /* Copy the new token (can be NULL). */
1219         lck->delete_token = copy_unix_token(lck, tok);
1220         lck->modified = True;
1221 }
1222
1223 /****************************************************************************
1224  Sets the delete on close flag over all share modes on this file.
1225  Modify the share mode entry for all files open
1226  on this device and inode to tell other smbds we have
1227  changed the delete on close flag. This will be noticed
1228  in the close code, the last closer will delete the file
1229  if flag is set.
1230  This makes a copy of any UNIX_USER_TOKEN into the
1231  lck entry. This function is used when the lock is already granted.
1232 ****************************************************************************/
1233
1234 void set_delete_on_close_lck(struct share_mode_lock *lck, BOOL delete_on_close, UNIX_USER_TOKEN *tok)
1235 {
1236         if (lck->delete_on_close != delete_on_close) {
1237                 set_delete_on_close_token(lck, tok);
1238                 lck->delete_on_close = delete_on_close;
1239                 if (delete_on_close) {
1240                         SMB_ASSERT(lck->delete_token != NULL);
1241                 }
1242                 lck->modified = True;
1243         }
1244 }
1245
1246 BOOL set_delete_on_close(files_struct *fsp, BOOL delete_on_close, UNIX_USER_TOKEN *tok)
1247 {
1248         struct share_mode_lock *lck;
1249
1250         DEBUG(10,("set_delete_on_close: %s delete on close flag for "
1251                   "fnum = %d, file %s\n",
1252                   delete_on_close ? "Adding" : "Removing", fsp->fnum,
1253                   fsp->fsp_name ));
1254
1255         if (fsp->is_stat) {
1256                 return True;
1257         }
1258
1259         lck = get_share_mode_lock(NULL, fsp->dev, fsp->inode, NULL, NULL);
1260         if (lck == NULL) {
1261                 return False;
1262         }
1263
1264         set_delete_on_close_lck(lck, delete_on_close, tok);
1265
1266         if (fsp->is_directory) {
1267                 send_stat_cache_delete_message(fsp->fsp_name);
1268         }
1269
1270         TALLOC_FREE(lck);
1271         return True;
1272 }
1273
1274 struct forall_state {
1275         void (*fn)(const struct share_mode_entry *entry,
1276                    const char *sharepath,
1277                    const char *fname,
1278                    void *private_data);
1279         void *private_data;
1280 };
1281
1282 static int traverse_fn(TDB_CONTEXT *the_tdb, TDB_DATA kbuf, TDB_DATA dbuf,
1283                        void *_state)
1284 {
1285         struct forall_state *state = (struct forall_state *)_state;
1286         struct locking_data *data;
1287         struct share_mode_entry *shares;
1288         const char *sharepath;
1289         const char *fname;
1290         int i;
1291
1292         /* Ensure this is a locking_key record. */
1293         if (kbuf.dsize != sizeof(struct locking_key))
1294                 return 0;
1295
1296         data = (struct locking_data *)dbuf.dptr;
1297         shares = (struct share_mode_entry *)(dbuf.dptr + sizeof(*data));
1298         sharepath = dbuf.dptr + sizeof(*data) +
1299                 data->u.s.num_share_mode_entries*sizeof(*shares) +
1300                 data->u.s.delete_token_size;
1301         fname = dbuf.dptr + sizeof(*data) +
1302                 data->u.s.num_share_mode_entries*sizeof(*shares) +
1303                 data->u.s.delete_token_size +
1304                 strlen(sharepath) + 1;
1305
1306         for (i=0;i<data->u.s.num_share_mode_entries;i++) {
1307                 state->fn(&shares[i], sharepath, fname,
1308                           state->private_data);
1309         }
1310         return 0;
1311 }
1312
1313 /*******************************************************************
1314  Call the specified function on each entry under management by the
1315  share mode system.
1316 ********************************************************************/
1317
1318 int share_mode_forall(void (*fn)(const struct share_mode_entry *, const char *,
1319                                  const char *, void *),
1320                       void *private_data)
1321 {
1322         struct forall_state state;
1323
1324         if (tdb == NULL)
1325                 return 0;
1326
1327         state.fn = fn;
1328         state.private_data = private_data;
1329
1330         return tdb_traverse(tdb, traverse_fn, (void *)&state);
1331 }