source/locking/locking.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Locking functions
   4    Copyright (C) Andrew Tridgell 1992-2000
   5    Copyright (C) Jeremy Allison 1992-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 BOOL get_delete_on_close_flag(SMB_DEV_T dev, SMB_INO_T inode)
 862 {
 863         BOOL result;
 864         struct share_mode_lock *lck = get_share_mode_lock(NULL, dev, inode, NULL, NULL);
 865         if (!lck) {
 866                 return False;
 867         }
 868         result = lck->delete_on_close;
 869         TALLOC_FREE(lck);
 870         return result;
 871 }
 872
 873 BOOL is_valid_share_mode_entry(const struct share_mode_entry *e)
 874 {
 875         int num_props = 0;
 876
 877         num_props += ((e->op_type == NO_OPLOCK) ? 1 : 0);
 878         num_props += (EXCLUSIVE_OPLOCK_TYPE(e->op_type) ? 1 : 0);
 879         num_props += (LEVEL_II_OPLOCK_TYPE(e->op_type) ? 1 : 0);
 880
 881         SMB_ASSERT(num_props <= 1);
 882         return (num_props != 0);
 883 }
 884
 885 BOOL is_deferred_open_entry(const struct share_mode_entry *e)
 886 {
 887         return (e->op_type == DEFERRED_OPEN_ENTRY);
 888 }
 889
 890 BOOL is_unused_share_mode_entry(const struct share_mode_entry *e)
 891 {
 892         return (e->op_type == UNUSED_SHARE_MODE_ENTRY);
 893 }
 894
 895 /*******************************************************************
 896  Fill a share mode entry.
 897 ********************************************************************/
 898
 899 static void fill_share_mode_entry(struct share_mode_entry *e,
 900                                   files_struct *fsp,
 901                                   uid_t uid, uint16 mid, uint16 op_type)
 902 {
 903         ZERO_STRUCTP(e);
 904         e->pid = procid_self();
 905         e->share_access = fsp->share_access;
 906         e->private_options = fsp->fh->private_options;
 907         e->access_mask = fsp->access_mask;
 908         e->op_mid = mid;
 909         e->op_type = op_type;
 910         e->time.tv_sec = fsp->open_time.tv_sec;
 911         e->time.tv_usec = fsp->open_time.tv_usec;
 912         e->dev = fsp->dev;
 913         e->inode = fsp->inode;
 914         e->share_file_id = fsp->fh->file_id;
 915         e->uid = (uint32)uid;
 916         e->flags = fsp->posix_open ? SHARE_MODE_FLAG_POSIX_OPEN : 0;
 917 }
 918
 919 static void fill_deferred_open_entry(struct share_mode_entry *e,
 920                                      const struct timeval request_time,
 921                                      SMB_DEV_T dev, SMB_INO_T ino, uint16 mid)
 922 {
 923         ZERO_STRUCTP(e);
 924         e->pid = procid_self();
 925         e->op_mid = mid;
 926         e->op_type = DEFERRED_OPEN_ENTRY;
 927         e->time.tv_sec = request_time.tv_sec;
 928         e->time.tv_usec = request_time.tv_usec;
 929         e->dev = dev;
 930         e->inode = ino;
 931         e->uid = (uint32)-1;
 932         e->flags = 0;
 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         /* Don't allow delete on close for non-empty directories. */
1153         if (fsp->is_directory) {
1154                 long offset = 0;
1155                 NTSTATUS status;
1156                 SMB_STRUCT_STAT st;
1157                 struct dptr_struct *dirptr;
1158                 const char *name;
1159
1160                 status = dptr_create(fsp->conn,
1161                                         fsp->fsp_name,
1162                                         False,
1163                                         True,
1164                                         0,
1165                                         "*",
1166                                         True,
1167                                         0,
1168                                         &dirptr);
1169                 if (!NT_STATUS_IS_OK(status)) {
1170                         return status;
1171                 }
1172
1173                 /* Read 3 entries. Ignore first 2 (they're . and .. ) */
1174                 name = dptr_ReadDirName(dirptr, &offset, &st);
1175                 if (!name) {
1176                         dptr_CloseDir(dirptr);
1177                         return NT_STATUS_ACCESS_DENIED;
1178                 }
1179                 name = dptr_ReadDirName(dirptr, &offset, &st);
1180                 if (!name) {
1181                         dptr_CloseDir(dirptr);
1182                         return NT_STATUS_ACCESS_DENIED;
1183                 }
1184                 name = dptr_ReadDirName(dirptr, &offset, &st);
1185                 dptr_CloseDir(dirptr);
1186                 if (name) {
1187                         DEBUG(10,("can_set_delete_on_close: got name %s - can't delete\n", name ));
1188                         return NT_STATUS_DIRECTORY_NOT_EMPTY;
1189                 }
1190         }
1191
1192         return NT_STATUS_OK;
1193 }
1194
1195 /*************************************************************************
1196  Return a talloced copy of a UNIX_USER_TOKEN. NULL on fail.
1197  (Should this be in locking.c.... ?).
1198 *************************************************************************/
1199
1200 static UNIX_USER_TOKEN *copy_unix_token(TALLOC_CTX *ctx, UNIX_USER_TOKEN *tok)
1201 {
1202         UNIX_USER_TOKEN *cpy;
1203
1204         if (tok == NULL) {
1205                 return NULL;
1206         }
1207
1208         cpy = TALLOC_P(ctx, UNIX_USER_TOKEN);
1209         if (!cpy) {
1210                 return NULL;
1211         }
1212
1213         cpy->uid = tok->uid;
1214         cpy->gid = tok->gid;
1215         cpy->ngroups = tok->ngroups;
1216         if (tok->ngroups) {
1217                 /* Make this a talloc child of cpy. */
1218                 cpy->groups = TALLOC_ARRAY(cpy, gid_t, tok->ngroups);
1219                 if (!cpy->groups) {
1220                         return NULL;
1221                 }
1222                 memcpy(cpy->groups, tok->groups, tok->ngroups * sizeof(gid_t));
1223         }
1224         return cpy;
1225 }
1226
1227 /****************************************************************************
1228  Replace the delete on close token.
1229 ****************************************************************************/
1230
1231 void set_delete_on_close_token(struct share_mode_lock *lck, UNIX_USER_TOKEN *tok)
1232 {
1233         /* Ensure there's no token. */
1234         if (lck->delete_token) {
1235                 TALLOC_FREE(lck->delete_token); /* Also deletes groups... */
1236                 lck->delete_token = NULL;
1237         }
1238
1239         /* Copy the new token (can be NULL). */
1240         lck->delete_token = copy_unix_token(lck, tok);
1241         lck->modified = True;
1242 }
1243
1244 /****************************************************************************
1245  Sets the delete on close flag over all share modes on this file.
1246  Modify the share mode entry for all files open
1247  on this device and inode to tell other smbds we have
1248  changed the delete on close flag. This will be noticed
1249  in the close code, the last closer will delete the file
1250  if flag is set.
1251  This makes a copy of any UNIX_USER_TOKEN into the
1252  lck entry. This function is used when the lock is already granted.
1253 ****************************************************************************/
1254
1255 void set_delete_on_close_lck(struct share_mode_lock *lck, BOOL delete_on_close, UNIX_USER_TOKEN *tok)
1256 {
1257         if (lck->delete_on_close != delete_on_close) {
1258                 set_delete_on_close_token(lck, tok);
1259                 lck->delete_on_close = delete_on_close;
1260                 if (delete_on_close) {
1261                         SMB_ASSERT(lck->delete_token != NULL);
1262                 }
1263                 lck->modified = True;
1264         }
1265 }
1266
1267 BOOL set_delete_on_close(files_struct *fsp, BOOL delete_on_close, UNIX_USER_TOKEN *tok)
1268 {
1269         struct share_mode_lock *lck;
1270
1271         DEBUG(10,("set_delete_on_close: %s delete on close flag for "
1272                   "fnum = %d, file %s\n",
1273                   delete_on_close ? "Adding" : "Removing", fsp->fnum,
1274                   fsp->fsp_name ));
1275
1276         if (fsp->is_stat) {
1277                 return True;
1278         }
1279
1280         lck = get_share_mode_lock(NULL, fsp->dev, fsp->inode, NULL, NULL);
1281         if (lck == NULL) {
1282                 return False;
1283         }
1284
1285         set_delete_on_close_lck(lck, delete_on_close, tok);
1286
1287         if (fsp->is_directory) {
1288                 send_stat_cache_delete_message(fsp->fsp_name);
1289         }
1290
1291         TALLOC_FREE(lck);
1292         return True;
1293 }
1294
1295 struct forall_state {
1296         void (*fn)(const struct share_mode_entry *entry,
1297                    const char *sharepath,
1298                    const char *fname,
1299                    void *private_data);
1300         void *private_data;
1301 };
1302
1303 static int traverse_fn(TDB_CONTEXT *the_tdb, TDB_DATA kbuf, TDB_DATA dbuf,
1304                        void *_state)
1305 {
1306         struct forall_state *state = (struct forall_state *)_state;
1307         struct locking_data *data;
1308         struct share_mode_entry *shares;
1309         const char *sharepath;
1310         const char *fname;
1311         int i;
1312
1313         /* Ensure this is a locking_key record. */
1314         if (kbuf.dsize != sizeof(struct locking_key))
1315                 return 0;
1316
1317         data = (struct locking_data *)dbuf.dptr;
1318         shares = (struct share_mode_entry *)(dbuf.dptr + sizeof(*data));
1319         sharepath = dbuf.dptr + sizeof(*data) +
1320                 data->u.s.num_share_mode_entries*sizeof(*shares) +
1321                 data->u.s.delete_token_size;
1322         fname = dbuf.dptr + sizeof(*data) +
1323                 data->u.s.num_share_mode_entries*sizeof(*shares) +
1324                 data->u.s.delete_token_size +
1325                 strlen(sharepath) + 1;
1326
1327         for (i=0;i<data->u.s.num_share_mode_entries;i++) {
1328                 state->fn(&shares[i], sharepath, fname,
1329                           state->private_data);
1330         }
1331         return 0;
1332 }
1333
1334 /*******************************************************************
1335  Call the specified function on each entry under management by the
1336  share mode system.
1337 ********************************************************************/
1338
1339 int share_mode_forall(void (*fn)(const struct share_mode_entry *, const char *,
1340                                  const char *, void *),
1341                       void *private_data)
1342 {
1343         struct forall_state state;
1344
1345         if (tdb == NULL)
1346                 return 0;
1347
1348         state.fn = fn;
1349         state.private_data = private_data;
1350
1351         return tdb_traverse(tdb, traverse_fn, (void *)&state);
1352 }