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