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