?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3:registry: do not use regdb functions during db upgrade
[Samba/gebeck_regimport.git] / source3 / locking / locking.c
blobcaa2b5aef6417418ed87e576b854f169a8e809f0
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 3 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, see <http://www.gnu.org/licenses/>.
20
21 Revision History:
22
23 12 aug 96: Erik.Devriendt@te6.siemens.be
24 added support for shared memory implementation of share mode locking
25
26 May 1997. Jeremy Allison (jallison@whistle.com). Modified share mode
27 locking to deal with multiple share modes per open file.
28
29 September 1997. Jeremy Allison (jallison@whistle.com). Added oplock
30 support.
31
32 rewrtten completely to use new tdb code. Tridge, Dec '99
33
34 Added POSIX locking support. Jeremy Allison (jeremy@valinux.com), Apr. 2000.
35 Added Unix Extensions POSIX locking support. Jeremy Allison Mar 2006.
36 */
37
38 #include "includes.h"
39 #include "system/filesys.h"
40 #include "locking/proto.h"
41 #include "smbd/globals.h"
42 #include "dbwrap/dbwrap.h"
43 #include "dbwrap/dbwrap_open.h"
44 #include "../libcli/security/security.h"
45 #include "serverid.h"
46 #include "messages.h"
47 #include "util_tdb.h"
48 #include "../librpc/gen_ndr/ndr_open_files.h"
49
50 #undef DBGC_CLASS
51 #define DBGC_CLASS DBGC_LOCKING
52
53 #define NO_LOCKING_COUNT (-1)
54
55 /* the locking database handle */
56 static struct db_context *lock_db;
57
58 /****************************************************************************
59 Debugging aids :-).
60 ****************************************************************************/
61
62 const char *lock_type_name(enum brl_type lock_type)
63 {
64 switch (lock_type) {
65 case READ_LOCK:
66 return "READ";
67 case WRITE_LOCK:
68 return "WRITE";
69 case PENDING_READ_LOCK:
70 return "PENDING_READ";
71 case PENDING_WRITE_LOCK:
72 return "PENDING_WRITE";
73 default:
74 return "other";
75 }
76 }
77
78 const char *lock_flav_name(enum brl_flavour lock_flav)
79 {
80 return (lock_flav == WINDOWS_LOCK) ? "WINDOWS_LOCK" : "POSIX_LOCK";
81 }
82
83 /****************************************************************************
84 Utility function called to see if a file region is locked.
85 Called in the read/write codepath.
86 ****************************************************************************/
87
88 void init_strict_lock_struct(files_struct *fsp,
89 uint64_t smblctx,
90 br_off start,
91 br_off size,
92 enum brl_type lock_type,
93 struct lock_struct *plock)
94 {
95 SMB_ASSERT(lock_type == READ_LOCK || lock_type == WRITE_LOCK);
96
97 plock->context.smblctx = smblctx;
98 plock->context.tid = fsp->conn->cnum;
99 plock->context.pid = sconn_server_id(fsp->conn->sconn);
100 plock->start = start;
101 plock->size = size;
102 plock->fnum = fsp->fnum;
103 plock->lock_type = lock_type;
104 plock->lock_flav = lp_posix_cifsu_locktype(fsp);
105 }
106
107 bool strict_lock_default(files_struct *fsp, struct lock_struct *plock)
108 {
109 int strict_locking = lp_strict_locking(fsp->conn->params);
110 bool ret = False;
111
112 if (plock->size == 0) {
113 return True;
114 }
115
116 if (!lp_locking(fsp->conn->params) || !strict_locking) {
117 return True;
118 }
119
120 if (strict_locking == Auto) {
121 if (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type) && (plock->lock_type == READ_LOCK || plock->lock_type == WRITE_LOCK)) {
122 DEBUG(10,("is_locked: optimisation - exclusive oplock on file %s\n", fsp_str_dbg(fsp)));
123 ret = True;
124 } else if ((fsp->oplock_type == LEVEL_II_OPLOCK) &&
125 (plock->lock_type == READ_LOCK)) {
126 DEBUG(10,("is_locked: optimisation - level II oplock on file %s\n", fsp_str_dbg(fsp)));
127 ret = True;
128 } else {
129 struct byte_range_lock *br_lck;
130
131 br_lck = brl_get_locks_readonly(fsp);
132 if (!br_lck) {
133 return True;
134 }
135 ret = brl_locktest(br_lck,
136 plock->context.smblctx,
137 plock->context.pid,
138 plock->start,
139 plock->size,
140 plock->lock_type,
141 plock->lock_flav);
142 }
143 } else {
144 struct byte_range_lock *br_lck;
145
146 br_lck = brl_get_locks_readonly(fsp);
147 if (!br_lck) {
148 return True;
149 }
150 ret = brl_locktest(br_lck,
151 plock->context.smblctx,
152 plock->context.pid,
153 plock->start,
154 plock->size,
155 plock->lock_type,
156 plock->lock_flav);
157 }
158
159 DEBUG(10,("strict_lock_default: flavour = %s brl start=%.0f "
160 "len=%.0f %s for fnum %d file %s\n",
161 lock_flav_name(plock->lock_flav),
162 (double)plock->start, (double)plock->size,
163 ret ? "unlocked" : "locked",
164 plock->fnum, fsp_str_dbg(fsp)));
165
166 return ret;
167 }
168
169 void strict_unlock_default(files_struct *fsp, struct lock_struct *plock)
170 {
171 }
172
173 /****************************************************************************
174 Find out if a lock could be granted - return who is blocking us if we can't.
175 ****************************************************************************/
176
177 NTSTATUS query_lock(files_struct *fsp,
178 uint64_t *psmblctx,
179 uint64_t *pcount,
180 uint64_t *poffset,
181 enum brl_type *plock_type,
182 enum brl_flavour lock_flav)
183 {
184 struct byte_range_lock *br_lck = NULL;
185
186 if (!fsp->can_lock) {
187 return fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
188 }
189
190 if (!lp_locking(fsp->conn->params)) {
191 return NT_STATUS_OK;
192 }
193
194 br_lck = brl_get_locks_readonly(fsp);
195 if (!br_lck) {
196 return NT_STATUS_NO_MEMORY;
197 }
198
199 return brl_lockquery(br_lck,
200 psmblctx,
201 sconn_server_id(fsp->conn->sconn),
202 poffset,
203 pcount,
204 plock_type,
205 lock_flav);
206 }
207
208 static void increment_current_lock_count(files_struct *fsp,
209 enum brl_flavour lock_flav)
210 {
211 if (lock_flav == WINDOWS_LOCK &&
212 fsp->current_lock_count != NO_LOCKING_COUNT) {
213 /* blocking ie. pending, locks also count here,
214 * as this is an efficiency counter to avoid checking
215 * the lock db. on close. JRA. */
216
217 fsp->current_lock_count++;
218 } else {
219 /* Notice that this has had a POSIX lock request.
220 * We can't count locks after this so forget them.
221 */
222 fsp->current_lock_count = NO_LOCKING_COUNT;
223 }
224 }
225
226 static void decrement_current_lock_count(files_struct *fsp,
227 enum brl_flavour lock_flav)
228 {
229 if (lock_flav == WINDOWS_LOCK &&
230 fsp->current_lock_count != NO_LOCKING_COUNT) {
231 SMB_ASSERT(fsp->current_lock_count > 0);
232 fsp->current_lock_count--;
233 }
234 }
235
236 /****************************************************************************
237 Utility function called by locking requests.
238 ****************************************************************************/
239
240 struct byte_range_lock *do_lock(struct messaging_context *msg_ctx,
241 files_struct *fsp,
242 uint64_t smblctx,
243 uint64_t count,
244 uint64_t offset,
245 enum brl_type lock_type,
246 enum brl_flavour lock_flav,
247 bool blocking_lock,
248 NTSTATUS *perr,
249 uint64_t *psmblctx,
250 struct blocking_lock_record *blr)
251 {
252 struct byte_range_lock *br_lck = NULL;
253
254 /* silently return ok on print files as we don't do locking there */
255 if (fsp->print_file) {
256 *perr = NT_STATUS_OK;
257 return NULL;
258 }
259
260 if (!fsp->can_lock) {
261 *perr = fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
262 return NULL;
263 }
264
265 if (!lp_locking(fsp->conn->params)) {
266 *perr = NT_STATUS_OK;
267 return NULL;
268 }
269
270 /* NOTE! 0 byte long ranges ARE allowed and should be stored */
271
272 DEBUG(10,("do_lock: lock flavour %s lock type %s start=%.0f len=%.0f "
273 "blocking_lock=%s requested for fnum %d file %s\n",
274 lock_flav_name(lock_flav), lock_type_name(lock_type),
275 (double)offset, (double)count, blocking_lock ? "true" :
276 "false", fsp->fnum, fsp_str_dbg(fsp)));
277
278 br_lck = brl_get_locks(talloc_tos(), fsp);
279 if (!br_lck) {
280 *perr = NT_STATUS_NO_MEMORY;
281 return NULL;
282 }
283
284 *perr = brl_lock(msg_ctx,
285 br_lck,
286 smblctx,
287 sconn_server_id(fsp->conn->sconn),
288 offset,
289 count,
290 lock_type,
291 lock_flav,
292 blocking_lock,
293 psmblctx,
294 blr);
295
296 DEBUG(10, ("do_lock: returning status=%s\n", nt_errstr(*perr)));
297
298 increment_current_lock_count(fsp, lock_flav);
299 return br_lck;
300 }
301
302 /****************************************************************************
303 Utility function called by unlocking requests.
304 ****************************************************************************/
305
306 NTSTATUS do_unlock(struct messaging_context *msg_ctx,
307 files_struct *fsp,
308 uint64_t smblctx,
309 uint64_t count,
310 uint64_t offset,
311 enum brl_flavour lock_flav)
312 {
313 bool ok = False;
314 struct byte_range_lock *br_lck = NULL;
315
316 if (!fsp->can_lock) {
317 return fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
318 }
319
320 if (!lp_locking(fsp->conn->params)) {
321 return NT_STATUS_OK;
322 }
323
324 DEBUG(10,("do_unlock: unlock start=%.0f len=%.0f requested for fnum %d file %s\n",
325 (double)offset, (double)count, fsp->fnum,
326 fsp_str_dbg(fsp)));
327
328 br_lck = brl_get_locks(talloc_tos(), fsp);
329 if (!br_lck) {
330 return NT_STATUS_NO_MEMORY;
331 }
332
333 ok = brl_unlock(msg_ctx,
334 br_lck,
335 smblctx,
336 sconn_server_id(fsp->conn->sconn),
337 offset,
338 count,
339 lock_flav);
340
341 TALLOC_FREE(br_lck);
342
343 if (!ok) {
344 DEBUG(10,("do_unlock: returning ERRlock.\n" ));
345 return NT_STATUS_RANGE_NOT_LOCKED;
346 }
347
348 decrement_current_lock_count(fsp, lock_flav);
349 return NT_STATUS_OK;
350 }
351
352 /****************************************************************************
353 Cancel any pending blocked locks.
354 ****************************************************************************/
355
356 NTSTATUS do_lock_cancel(files_struct *fsp,
357 uint64 smblctx,
358 uint64_t count,
359 uint64_t offset,
360 enum brl_flavour lock_flav,
361 struct blocking_lock_record *blr)
362 {
363 bool ok = False;
364 struct byte_range_lock *br_lck = NULL;
365
366 if (!fsp->can_lock) {
367 return fsp->is_directory ?
368 NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
369 }
370
371 if (!lp_locking(fsp->conn->params)) {
372 return NT_STATUS_DOS(ERRDOS, ERRcancelviolation);
373 }
374
375 DEBUG(10,("do_lock_cancel: cancel start=%.0f len=%.0f requested for fnum %d file %s\n",
376 (double)offset, (double)count, fsp->fnum,
377 fsp_str_dbg(fsp)));
378
379 br_lck = brl_get_locks(talloc_tos(), fsp);
380 if (!br_lck) {
381 return NT_STATUS_NO_MEMORY;
382 }
383
384 ok = brl_lock_cancel(br_lck,
385 smblctx,
386 sconn_server_id(fsp->conn->sconn),
387 offset,
388 count,
389 lock_flav,
390 blr);
391
392 TALLOC_FREE(br_lck);
393
394 if (!ok) {
395 DEBUG(10,("do_lock_cancel: returning ERRcancelviolation.\n" ));
396 return NT_STATUS_DOS(ERRDOS, ERRcancelviolation);
397 }
398
399 decrement_current_lock_count(fsp, lock_flav);
400 return NT_STATUS_OK;
401 }
402
403 /****************************************************************************
404 Remove any locks on this fd. Called from file_close().
405 ****************************************************************************/
406
407 void locking_close_file(struct messaging_context *msg_ctx,
408 files_struct *fsp,
409 enum file_close_type close_type)
410 {
411 struct byte_range_lock *br_lck;
412
413 if (!lp_locking(fsp->conn->params)) {
414 return;
415 }
416
417 /* If we have not outstanding locks or pending
418 * locks then we don't need to look in the lock db.
419 */
420
421 if (fsp->current_lock_count == 0) {
422 return;
423 }
424
425 br_lck = brl_get_locks(talloc_tos(),fsp);
426
427 if (br_lck) {
428 cancel_pending_lock_requests_by_fid(fsp, br_lck, close_type);
429 brl_close_fnum(msg_ctx, br_lck);
430 TALLOC_FREE(br_lck);
431 }
432 }
433
434 /****************************************************************************
435 Initialise the locking functions.
436 ****************************************************************************/
437
438 static bool locking_init_internal(bool read_only)
439 {
440 brl_init(read_only);
441
442 if (lock_db)
443 return True;
444
445 lock_db = db_open(NULL, lock_path("locking.tdb"),
446 lp_open_files_db_hash_size(),
447 TDB_DEFAULT|TDB_VOLATILE|TDB_CLEAR_IF_FIRST|TDB_INCOMPATIBLE_HASH,
448 read_only?O_RDONLY:O_RDWR|O_CREAT, 0644);
449
450 if (!lock_db) {
451 DEBUG(0,("ERROR: Failed to initialise locking database\n"));
452 return False;
453 }
454
455 if (!posix_locking_init(read_only))
456 return False;
457
458 return True;
459 }
460
461 bool locking_init(void)
462 {
463 return locking_init_internal(false);
464 }
465
466 bool locking_init_readonly(void)
467 {
468 return locking_init_internal(true);
469 }
470
471 /*******************************************************************
472 Deinitialize the share_mode management.
473 ******************************************************************/
474
475 bool locking_end(void)
476 {
477 brl_shutdown();
478 TALLOC_FREE(lock_db);
479 return true;
480 }
481
482 /*******************************************************************
483 Form a static locking key for a dev/inode pair.
484 ******************************************************************/
485
486 static TDB_DATA locking_key(const struct file_id *id, struct file_id *tmp)
487 {
488 *tmp = *id;
489 return make_tdb_data((const uint8_t *)tmp, sizeof(*tmp));
490 }
491
492 /*******************************************************************
493 Print out a share mode.
494 ********************************************************************/
495
496 char *share_mode_str(TALLOC_CTX *ctx, int num, const struct share_mode_entry *e)
497 {
498 return talloc_asprintf(ctx, "share_mode_entry[%d]: %s "
499 "pid = %s, share_access = 0x%x, private_options = 0x%x, "
500 "access_mask = 0x%x, mid = 0x%llx, type= 0x%x, gen_id = %lu, "
501 "uid = %u, flags = %u, file_id %s, name_hash = 0x%x",
502 num,
503 e->op_type == UNUSED_SHARE_MODE_ENTRY ? "UNUSED" : "",
504 procid_str_static(&e->pid),
505 e->share_access, e->private_options,
506 e->access_mask, (unsigned long long)e->op_mid,
507 e->op_type, e->share_file_id,
508 (unsigned int)e->uid, (unsigned int)e->flags,
509 file_id_string_tos(&e->id),
510 (unsigned int)e->name_hash);
511 }
512
513 /*******************************************************************
514 Get all share mode entries for a dev/inode pair.
515 ********************************************************************/
516
517 static bool parse_share_modes(const TDB_DATA dbuf, struct share_mode_lock *lck)
518 {
519 int i;
520 struct server_id *pids;
521 bool *pid_exists;
522 enum ndr_err_code ndr_err;
523 DATA_BLOB blob;
524
525 blob.data = dbuf.dptr;
526 blob.length = dbuf.dsize;
527
528 ndr_err = ndr_pull_struct_blob(
529 &blob, lck, lck,
530 (ndr_pull_flags_fn_t)ndr_pull_share_mode_lock);
531 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
532 DEBUG(1, ("ndr_pull_share_mode_lock failed\n"));
533 return false;
534 }
535
536 lck->modified = false;
537
538 if (DEBUGLEVEL >= 10) {
539 DEBUG(10, ("parse_share_modes:\n"));
540 NDR_PRINT_DEBUG(share_mode_lock, lck);
541 }
542
543 /*
544 * Ensure that each entry has a real process attached.
545 */
546
547 pids = talloc_array(talloc_tos(), struct server_id,
548 lck->num_share_modes);
549 if (pids == NULL) {
550 smb_panic("parse_share_modes: talloc_array failed");
551 }
552 pid_exists = talloc_array(talloc_tos(), bool, lck->num_share_modes);
553 if (pid_exists == NULL) {
554 smb_panic("parse_share_modes: talloc_array failed");
555 }
556
557 for (i=0; i<lck->num_share_modes; i++) {
558 pids[i] = lck->share_modes[i].pid;
559 }
560
561 if (!serverids_exist(pids, lck->num_share_modes, pid_exists)) {
562 smb_panic("parse_share_modes: serverids_exist failed");
563 }
564
565 for (i = 0; i < lck->num_share_modes; i++) {
566 struct share_mode_entry *entry_p = &lck->share_modes[i];
567 if (!pid_exists[i]) {
568 entry_p->op_type = UNUSED_SHARE_MODE_ENTRY;
569 lck->modified = True;
570 }
571 }
572 TALLOC_FREE(pid_exists);
573 TALLOC_FREE(pids);
574
575 return True;
576 }
577
578 static TDB_DATA unparse_share_modes(struct share_mode_lock *lck)
579 {
580 DATA_BLOB blob;
581 enum ndr_err_code ndr_err;
582 uint32_t i;
583
584 if (DEBUGLEVEL >= 10) {
585 DEBUG(10, ("unparse_share_modes:\n"));
586 NDR_PRINT_DEBUG(share_mode_lock, lck);
587 }
588
589 for (i=0; i<lck->num_share_modes; i++) {
590 if (!is_unused_share_mode_entry(&lck->share_modes[i])) {
591 break;
592 }
593 }
594 if (i == lck->num_share_modes) {
595 DEBUG(10, ("No used share mode found\n"));
596 return make_tdb_data(NULL, 0);
597 }
598
599 ndr_err = ndr_push_struct_blob(
600 &blob, lck, lck,
601 (ndr_push_flags_fn_t)ndr_push_share_mode_lock);
602 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
603 smb_panic("ndr_push_share_mode_lock failed");
604 }
605
606 return make_tdb_data(blob.data, blob.length);
607 }
608
609 static int share_mode_lock_destructor(struct share_mode_lock *lck)
610 {
611 NTSTATUS status;
612 TDB_DATA data;
613
614 if (!lck->modified) {
615 return 0;
616 }
617
618 data = unparse_share_modes(lck);
619
620 if (data.dptr == NULL) {
621 if (!lck->fresh) {
622 /* There has been an entry before, delete it */
623
624 status = dbwrap_record_delete(lck->record);
625 if (!NT_STATUS_IS_OK(status)) {
626 char *errmsg;
627
628 DEBUG(0, ("delete_rec returned %s\n",
629 nt_errstr(status)));
630
631 if (asprintf(&errmsg, "could not delete share "
632 "entry: %s\n",
633 nt_errstr(status)) == -1) {
634 smb_panic("could not delete share"
635 "entry");
636 }
637 smb_panic(errmsg);
638 }
639 }
640 goto done;
641 }
642
643 status = dbwrap_record_store(lck->record, data, TDB_REPLACE);
644 if (!NT_STATUS_IS_OK(status)) {
645 char *errmsg;
646
647 DEBUG(0, ("store returned %s\n", nt_errstr(status)));
648
649 if (asprintf(&errmsg, "could not store share mode entry: %s",
650 nt_errstr(status)) == -1) {
651 smb_panic("could not store share mode entry");
652 }
653 smb_panic(errmsg);
654 }
655
656 done:
657
658 return 0;
659 }
660
661 static bool fill_share_mode_lock(struct share_mode_lock *lck,
662 struct file_id id,
663 const char *servicepath,
664 const struct smb_filename *smb_fname,
665 TDB_DATA share_mode_data,
666 const struct timespec *old_write_time)
667 {
668 bool fresh;
669
670 /* Ensure we set every field here as the destructor must be
671 valid even if parse_share_modes fails. */
672
673 lck->servicepath = NULL;
674 lck->base_name = NULL;
675 lck->stream_name = NULL;
676 lck->id = id;
677 lck->num_share_modes = 0;
678 lck->share_modes = NULL;
679 lck->num_delete_tokens = 0;
680 lck->delete_tokens = NULL;
681 ZERO_STRUCT(lck->old_write_time);
682 ZERO_STRUCT(lck->changed_write_time);
683
684 fresh = (share_mode_data.dptr == NULL);
685
686 if (fresh) {
687 bool has_stream;
688 if (smb_fname == NULL || servicepath == NULL
689 || old_write_time == NULL) {
690 return False;
691 }
692
693 has_stream = smb_fname->stream_name != NULL;
694
695 lck->base_name = talloc_strdup(lck, smb_fname->base_name);
696 lck->stream_name = talloc_strdup(lck, smb_fname->stream_name);
697 lck->servicepath = talloc_strdup(lck, servicepath);
698 if (lck->base_name == NULL ||
699 (has_stream && lck->stream_name == NULL) ||
700 lck->servicepath == NULL) {
701 DEBUG(0, ("talloc failed\n"));
702 return False;
703 }
704 lck->old_write_time = *old_write_time;
705 lck->modified = false;
706 } else {
707 if (!parse_share_modes(share_mode_data, lck)) {
708 DEBUG(0, ("Could not parse share modes\n"));
709 return False;
710 }
711 }
712 lck->fresh = fresh;
713
714 return True;
715 }
716
717 struct share_mode_lock *get_share_mode_lock(TALLOC_CTX *mem_ctx,
718 const struct file_id id,
719 const char *servicepath,
720 const struct smb_filename *smb_fname,
721 const struct timespec *old_write_time)
722 {
723 struct share_mode_lock *lck;
724 struct file_id tmp;
725 struct db_record *rec;
726 TDB_DATA key = locking_key(&id, &tmp);
727 TDB_DATA value;
728
729 if (!(lck = talloc(mem_ctx, struct share_mode_lock))) {
730 DEBUG(0, ("talloc failed\n"));
731 return NULL;
732 }
733
734 rec = dbwrap_fetch_locked(lock_db, lck, key);
735 if (rec == NULL) {
736 DEBUG(3, ("Could not lock share entry\n"));
737 TALLOC_FREE(lck);
738 return NULL;
739 }
740
741 value = dbwrap_record_get_value(rec);
742
743 if (!fill_share_mode_lock(lck, id, servicepath, smb_fname,
744 value, old_write_time)) {
745 DEBUG(3, ("fill_share_mode_lock failed\n"));
746 TALLOC_FREE(lck);
747 return NULL;
748 }
749
750 lck->record = rec;
751 talloc_set_destructor(lck, share_mode_lock_destructor);
752
753 return lck;
754 }
755
756 struct share_mode_lock *fetch_share_mode_unlocked(TALLOC_CTX *mem_ctx,
757 const struct file_id id)
758 {
759 struct share_mode_lock *lck;
760 struct file_id tmp;
761 TDB_DATA key = locking_key(&id, &tmp);
762 TDB_DATA data;
763 NTSTATUS status;
764
765 if (!(lck = talloc(mem_ctx, struct share_mode_lock))) {
766 DEBUG(0, ("talloc failed\n"));
767 return NULL;
768 }
769
770 status = dbwrap_fetch(lock_db, lck, key, &data);
771 if (!NT_STATUS_IS_OK(status)) {
772 DEBUG(3, ("Could not fetch share entry\n"));
773 TALLOC_FREE(lck);
774 return NULL;
775 }
776
777 if (!fill_share_mode_lock(lck, id, NULL, NULL, data, NULL)) {
778 DEBUG(10, ("fetch_share_mode_unlocked: no share_mode record "
779 "around (file not open)\n"));
780 TALLOC_FREE(lck);
781 return NULL;
782 }
783
784 return lck;
785 }
786
787 /*******************************************************************
788 Sets the service name and filename for rename.
789 At this point we emit "file renamed" messages to all
790 process id's that have this file open.
791 Based on an initial code idea from SATOH Fumiyasu <fumiya@samba.gr.jp>
792 ********************************************************************/
793
794 bool rename_share_filename(struct messaging_context *msg_ctx,
795 struct share_mode_lock *lck,
796 const char *servicepath,
797 uint32_t orig_name_hash,
798 uint32_t new_name_hash,
799 const struct smb_filename *smb_fname_dst)
800 {
801 size_t sp_len;
802 size_t bn_len;
803 size_t sn_len;
804 size_t msg_len;
805 char *frm = NULL;
806 int i;
807 bool strip_two_chars = false;
808 bool has_stream = smb_fname_dst->stream_name != NULL;
809
810 DEBUG(10, ("rename_share_filename: servicepath %s newname %s\n",
811 servicepath, smb_fname_dst->base_name));
812
813 /*
814 * rename_internal_fsp() and rename_internals() add './' to
815 * head of newname if newname does not contain a '/'.
816 */
817 if (smb_fname_dst->base_name[0] &&
818 smb_fname_dst->base_name[1] &&
819 smb_fname_dst->base_name[0] == '.' &&
820 smb_fname_dst->base_name[1] == '/') {
821 strip_two_chars = true;
822 }
823
824 lck->servicepath = talloc_strdup(lck, servicepath);
825 lck->base_name = talloc_strdup(lck, smb_fname_dst->base_name +
826 (strip_two_chars ? 2 : 0));
827 lck->stream_name = talloc_strdup(lck, smb_fname_dst->stream_name);
828 if (lck->base_name == NULL ||
829 (has_stream && lck->stream_name == NULL) ||
830 lck->servicepath == NULL) {
831 DEBUG(0, ("rename_share_filename: talloc failed\n"));
832 return False;
833 }
834 lck->modified = True;
835
836 sp_len = strlen(lck->servicepath);
837 bn_len = strlen(lck->base_name);
838 sn_len = has_stream ? strlen(lck->stream_name) : 0;
839
840 msg_len = MSG_FILE_RENAMED_MIN_SIZE + sp_len + 1 + bn_len + 1 +
841 sn_len + 1;
842
843 /* Set up the name changed message. */
844 frm = talloc_array(lck, char, msg_len);
845 if (!frm) {
846 return False;
847 }
848
849 push_file_id_24(frm, &lck->id);
850
851 DEBUG(10,("rename_share_filename: msg_len = %u\n", (unsigned int)msg_len ));
852
853 strlcpy(&frm[24],
854 lck->servicepath ? lck->servicepath : "",
855 sp_len+1);
856 strlcpy(&frm[24 + sp_len + 1],
857 lck->base_name ? lck->base_name : "",
858 bn_len+1);
859 strlcpy(&frm[24 + sp_len + 1 + bn_len + 1],
860 lck->stream_name ? lck->stream_name : "",
861 sn_len+1);
862
863 /* Send the messages. */
864 for (i=0; i<lck->num_share_modes; i++) {
865 struct share_mode_entry *se = &lck->share_modes[i];
866 if (!is_valid_share_mode_entry(se)) {
867 continue;
868 }
869
870 /* If this is a hardlink to the inode
871 with a different name, skip this. */
872 if (se->name_hash != orig_name_hash) {
873 continue;
874 }
875
876 se->name_hash = new_name_hash;
877
878 /* But not to ourselves... */
879 if (procid_is_me(&se->pid)) {
880 continue;
881 }
882
883 DEBUG(10,("rename_share_filename: sending rename message to "
884 "pid %s file_id %s sharepath %s base_name %s "
885 "stream_name %s\n",
886 procid_str_static(&se->pid),
887 file_id_string_tos(&lck->id),
888 lck->servicepath, lck->base_name,
889 has_stream ? lck->stream_name : ""));
890
891 messaging_send_buf(msg_ctx, se->pid, MSG_SMB_FILE_RENAME,
892 (uint8 *)frm, msg_len);
893 }
894
895 return True;
896 }
897
898 void get_file_infos(struct file_id id,
899 uint32_t name_hash,
900 bool *delete_on_close,
901 struct timespec *write_time)
902 {
903 struct share_mode_lock *lck;
904
905 if (delete_on_close) {
906 *delete_on_close = false;
907 }
908
909 if (write_time) {
910 ZERO_STRUCTP(write_time);
911 }
912
913 if (!(lck = fetch_share_mode_unlocked(talloc_tos(), id))) {
914 return;
915 }
916
917 if (delete_on_close) {
918 *delete_on_close = is_delete_on_close_set(lck, name_hash);
919 }
920
921 if (write_time) {
922 struct timespec wt;
923
924 wt = lck->changed_write_time;
925 if (null_timespec(wt)) {
926 wt = lck->old_write_time;
927 }
928
929 *write_time = wt;
930 }
931
932 TALLOC_FREE(lck);
933 }
934
935 bool is_valid_share_mode_entry(const struct share_mode_entry *e)
936 {
937 int num_props = 0;
938
939 if (e->op_type == UNUSED_SHARE_MODE_ENTRY) {
940 /* cope with dead entries from the process not
941 existing. These should not be considered valid,
942 otherwise we end up doing zero timeout sharing
943 violation */
944 return False;
945 }
946
947 num_props += ((e->op_type == NO_OPLOCK) ? 1 : 0);
948 num_props += (EXCLUSIVE_OPLOCK_TYPE(e->op_type) ? 1 : 0);
949 num_props += (LEVEL_II_OPLOCK_TYPE(e->op_type) ? 1 : 0);
950
951 SMB_ASSERT(num_props <= 1);
952 return (num_props != 0);
953 }
954
955 bool is_deferred_open_entry(const struct share_mode_entry *e)
956 {
957 return (e->op_type == DEFERRED_OPEN_ENTRY);
958 }
959
960 bool is_unused_share_mode_entry(const struct share_mode_entry *e)
961 {
962 return (e->op_type == UNUSED_SHARE_MODE_ENTRY);
963 }
964
965 /*******************************************************************
966 Fill a share mode entry.
967 ********************************************************************/
968
969 static void fill_share_mode_entry(struct share_mode_entry *e,
970 files_struct *fsp,
971 uid_t uid, uint64_t mid, uint16 op_type)
972 {
973 ZERO_STRUCTP(e);
974 e->pid = sconn_server_id(fsp->conn->sconn);
975 e->share_access = fsp->share_access;
976 e->private_options = fsp->fh->private_options;
977 e->access_mask = fsp->access_mask;
978 e->op_mid = mid;
979 e->op_type = op_type;
980 e->time.tv_sec = fsp->open_time.tv_sec;
981 e->time.tv_usec = fsp->open_time.tv_usec;
982 e->id = fsp->file_id;
983 e->share_file_id = fsp->fh->gen_id;
984 e->uid = (uint32)uid;
985 e->flags = fsp->posix_open ? SHARE_MODE_FLAG_POSIX_OPEN : 0;
986 e->name_hash = fsp->name_hash;
987 }
988
989 static void fill_deferred_open_entry(struct share_mode_entry *e,
990 const struct timeval request_time,
991 struct file_id id,
992 struct server_id pid,
993 uint64_t mid)
994 {
995 ZERO_STRUCTP(e);
996 e->pid = pid;
997 e->op_mid = mid;
998 e->op_type = DEFERRED_OPEN_ENTRY;
999 e->time.tv_sec = request_time.tv_sec;
1000 e->time.tv_usec = request_time.tv_usec;
1001 e->id = id;
1002 e->uid = (uint32)-1;
1003 e->flags = 0;
1004 }
1005
1006 static void add_share_mode_entry(struct share_mode_lock *lck,
1007 const struct share_mode_entry *entry)
1008 {
1009 int i;
1010
1011 for (i=0; i<lck->num_share_modes; i++) {
1012 struct share_mode_entry *e = &lck->share_modes[i];
1013 if (is_unused_share_mode_entry(e)) {
1014 *e = *entry;
1015 break;
1016 }
1017 }
1018
1019 if (i == lck->num_share_modes) {
1020 /* No unused entry found */
1021 ADD_TO_ARRAY(lck, struct share_mode_entry, *entry,
1022 &lck->share_modes, &lck->num_share_modes);
1023 }
1024 lck->modified = True;
1025 }
1026
1027 void set_share_mode(struct share_mode_lock *lck, files_struct *fsp,
1028 uid_t uid, uint64_t mid, uint16 op_type)
1029 {
1030 struct share_mode_entry entry;
1031 fill_share_mode_entry(&entry, fsp, uid, mid, op_type);
1032 add_share_mode_entry(lck, &entry);
1033 }
1034
1035 void add_deferred_open(struct share_mode_lock *lck, uint64_t mid,
1036 struct timeval request_time,
1037 struct server_id pid, struct file_id id)
1038 {
1039 struct share_mode_entry entry;
1040 fill_deferred_open_entry(&entry, request_time, id, pid, mid);
1041 add_share_mode_entry(lck, &entry);
1042 }
1043
1044 /*******************************************************************
1045 Check if two share mode entries are identical, ignoring oplock
1046 and mid info and desired_access. (Removed paranoia test - it's
1047 not automatically a logic error if they are identical. JRA.)
1048 ********************************************************************/
1049
1050 static bool share_modes_identical(struct share_mode_entry *e1,
1051 struct share_mode_entry *e2)
1052 {
1053 /* We used to check for e1->share_access == e2->share_access here
1054 as well as the other fields but 2 different DOS or FCB opens
1055 sharing the same share mode entry may validly differ in
1056 fsp->share_access field. */
1057
1058 return (procid_equal(&e1->pid, &e2->pid) &&
1059 file_id_equal(&e1->id, &e2->id) &&
1060 e1->share_file_id == e2->share_file_id );
1061 }
1062
1063 static bool deferred_open_identical(struct share_mode_entry *e1,
1064 struct share_mode_entry *e2)
1065 {
1066 return (procid_equal(&e1->pid, &e2->pid) &&
1067 (e1->op_mid == e2->op_mid) &&
1068 file_id_equal(&e1->id, &e2->id));
1069 }
1070
1071 static struct share_mode_entry *find_share_mode_entry(struct share_mode_lock *lck,
1072 struct share_mode_entry *entry)
1073 {
1074 int i;
1075
1076 for (i=0; i<lck->num_share_modes; i++) {
1077 struct share_mode_entry *e = &lck->share_modes[i];
1078 if (is_valid_share_mode_entry(entry) &&
1079 is_valid_share_mode_entry(e) &&
1080 share_modes_identical(e, entry)) {
1081 return e;
1082 }
1083 if (is_deferred_open_entry(entry) &&
1084 is_deferred_open_entry(e) &&
1085 deferred_open_identical(e, entry)) {
1086 return e;
1087 }
1088 }
1089 return NULL;
1090 }
1091
1092 /*******************************************************************
1093 Del the share mode of a file for this process. Return the number of
1094 entries left.
1095 ********************************************************************/
1096
1097 bool del_share_mode(struct share_mode_lock *lck, files_struct *fsp)
1098 {
1099 struct share_mode_entry entry, *e;
1100
1101 /* Don't care about the pid owner being correct here - just a search. */
1102 fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
1103
1104 e = find_share_mode_entry(lck, &entry);
1105 if (e == NULL) {
1106 return False;
1107 }
1108
1109 e->op_type = UNUSED_SHARE_MODE_ENTRY;
1110 lck->modified = True;
1111 return True;
1112 }
1113
1114 void del_deferred_open_entry(struct share_mode_lock *lck, uint64_t mid,
1115 struct server_id pid)
1116 {
1117 struct share_mode_entry entry, *e;
1118
1119 fill_deferred_open_entry(&entry, timeval_zero(),
1120 lck->id, pid, mid);
1121
1122 e = find_share_mode_entry(lck, &entry);
1123 if (e == NULL) {
1124 return;
1125 }
1126
1127 e->op_type = UNUSED_SHARE_MODE_ENTRY;
1128 lck->modified = True;
1129 }
1130
1131 /*******************************************************************
1132 Remove an oplock mid and mode entry from a share mode.
1133 ********************************************************************/
1134
1135 bool remove_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
1136 {
1137 struct share_mode_entry entry, *e;
1138
1139 /* Don't care about the pid owner being correct here - just a search. */
1140 fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
1141
1142 e = find_share_mode_entry(lck, &entry);
1143 if (e == NULL) {
1144 return False;
1145 }
1146
1147 if (EXCLUSIVE_OPLOCK_TYPE(e->op_type)) {
1148 /*
1149 * Going from exclusive or batch,
1150 * we always go through FAKE_LEVEL_II
1151 * first.
1152 */
1153 if (!EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) {
1154 smb_panic("remove_share_oplock: logic error");
1155 }
1156 e->op_type = FAKE_LEVEL_II_OPLOCK;
1157 } else {
1158 e->op_type = NO_OPLOCK;
1159 }
1160 lck->modified = True;
1161 return True;
1162 }
1163
1164 /*******************************************************************
1165 Downgrade a oplock type from exclusive to level II.
1166 ********************************************************************/
1167
1168 bool downgrade_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
1169 {
1170 struct share_mode_entry entry, *e;
1171
1172 /* Don't care about the pid owner being correct here - just a search. */
1173 fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
1174
1175 e = find_share_mode_entry(lck, &entry);
1176 if (e == NULL) {
1177 return False;
1178 }
1179
1180 e->op_type = LEVEL_II_OPLOCK;
1181 lck->modified = True;
1182 return True;
1183 }
1184
1185 /****************************************************************************
1186 Check if setting delete on close is allowed on this fsp.
1187 ****************************************************************************/
1188
1189 NTSTATUS can_set_delete_on_close(files_struct *fsp, uint32 dosmode)
1190 {
1191 /*
1192 * Only allow delete on close for writable files.
1193 */
1194
1195 if ((dosmode & FILE_ATTRIBUTE_READONLY) &&
1196 !lp_delete_readonly(SNUM(fsp->conn))) {
1197 DEBUG(10,("can_set_delete_on_close: file %s delete on close "
1198 "flag set but file attribute is readonly.\n",
1199 fsp_str_dbg(fsp)));
1200 return NT_STATUS_CANNOT_DELETE;
1201 }
1202
1203 /*
1204 * Only allow delete on close for writable shares.
1205 */
1206
1207 if (!CAN_WRITE(fsp->conn)) {
1208 DEBUG(10,("can_set_delete_on_close: file %s delete on "
1209 "close flag set but write access denied on share.\n",
1210 fsp_str_dbg(fsp)));
1211 return NT_STATUS_ACCESS_DENIED;
1212 }
1213
1214 /*
1215 * Only allow delete on close for files/directories opened with delete
1216 * intent.
1217 */
1218
1219 if (!(fsp->access_mask & DELETE_ACCESS)) {
1220 DEBUG(10,("can_set_delete_on_close: file %s delete on "
1221 "close flag set but delete access denied.\n",
1222 fsp_str_dbg(fsp)));
1223 return NT_STATUS_ACCESS_DENIED;
1224 }
1225
1226 /* Don't allow delete on close for non-empty directories. */
1227 if (fsp->is_directory) {
1228 SMB_ASSERT(!is_ntfs_stream_smb_fname(fsp->fsp_name));
1229
1230 /* Or the root of a share. */
1231 if (ISDOT(fsp->fsp_name->base_name)) {
1232 DEBUG(10,("can_set_delete_on_close: can't set delete on "
1233 "close for the root of a share.\n"));
1234 return NT_STATUS_ACCESS_DENIED;
1235 }
1236
1237 return can_delete_directory(fsp->conn,
1238 fsp->fsp_name->base_name);
1239 }
1240
1241 return NT_STATUS_OK;
1242 }
1243
1244 /*************************************************************************
1245 Return a talloced copy of a struct security_unix_token. NULL on fail.
1246 (Should this be in locking.c.... ?).
1247 *************************************************************************/
1248
1249 static struct security_unix_token *copy_unix_token(TALLOC_CTX *ctx, const struct security_unix_token *tok)
1250 {
1251 struct security_unix_token *cpy;
1252
1253 cpy = talloc(ctx, struct security_unix_token);
1254 if (!cpy) {
1255 return NULL;
1256 }
1257
1258 cpy->uid = tok->uid;
1259 cpy->gid = tok->gid;
1260 cpy->ngroups = tok->ngroups;
1261 if (tok->ngroups) {
1262 /* Make this a talloc child of cpy. */
1263 cpy->groups = (gid_t *)talloc_memdup(
1264 cpy, tok->groups, tok->ngroups * sizeof(gid_t));
1265 if (!cpy->groups) {
1266 TALLOC_FREE(cpy);
1267 return NULL;
1268 }
1269 }
1270 return cpy;
1271 }
1272
1273 /****************************************************************************
1274 Adds a delete on close token.
1275 ****************************************************************************/
1276
1277 static bool add_delete_on_close_token(struct share_mode_lock *lck,
1278 uint32_t name_hash,
1279 const struct security_unix_token *tok)
1280 {
1281 struct delete_token *tmp, *dtl;
1282
1283 tmp = talloc_realloc(lck, lck->delete_tokens, struct delete_token,
1284 lck->num_delete_tokens+1);
1285 if (tmp == NULL) {
1286 return false;
1287 }
1288 lck->delete_tokens = tmp;
1289 dtl = &lck->delete_tokens[lck->num_delete_tokens];
1290
1291 dtl->name_hash = name_hash;
1292 dtl->delete_token = copy_unix_token(lck->delete_tokens, tok);
1293 if (dtl->delete_token == NULL) {
1294 return false;
1295 }
1296 lck->num_delete_tokens += 1;
1297 lck->modified = true;
1298 return true;
1299 }
1300
1301 /****************************************************************************
1302 Sets the delete on close flag over all share modes on this file.
1303 Modify the share mode entry for all files open
1304 on this device and inode to tell other smbds we have
1305 changed the delete on close flag. This will be noticed
1306 in the close code, the last closer will delete the file
1307 if flag is set.
1308 This makes a copy of any struct security_unix_token into the
1309 lck entry. This function is used when the lock is already granted.
1310 ****************************************************************************/
1311
1312 void set_delete_on_close_lck(files_struct *fsp,
1313 struct share_mode_lock *lck,
1314 bool delete_on_close,
1315 const struct security_unix_token *tok)
1316 {
1317 int i;
1318 bool ret;
1319
1320 if (delete_on_close) {
1321 SMB_ASSERT(tok != NULL);
1322 } else {
1323 SMB_ASSERT(tok == NULL);
1324 }
1325
1326 for (i=0; i<lck->num_delete_tokens; i++) {
1327 struct delete_token *dt = &lck->delete_tokens[i];
1328 if (dt->name_hash == fsp->name_hash) {
1329 lck->modified = true;
1330 if (delete_on_close == false) {
1331 /* Delete this entry. */
1332 TALLOC_FREE(dt->delete_token);
1333 *dt = lck->delete_tokens[
1334 lck->num_delete_tokens-1];
1335 lck->num_delete_tokens -= 1;
1336 return;
1337 }
1338 /* Replace this token with the
1339 given tok. */
1340 TALLOC_FREE(dt->delete_token);
1341 dt->delete_token = copy_unix_token(dt, tok);
1342 SMB_ASSERT(dt->delete_token != NULL);
1343 }
1344 }
1345
1346 if (!delete_on_close) {
1347 /* Nothing to delete - not found. */
1348 return;
1349 }
1350
1351 ret = add_delete_on_close_token(lck, fsp->name_hash, tok);
1352 SMB_ASSERT(ret);
1353 }
1354
1355 bool set_delete_on_close(files_struct *fsp, bool delete_on_close, const struct security_unix_token *tok)
1356 {
1357 struct share_mode_lock *lck;
1358
1359 DEBUG(10,("set_delete_on_close: %s delete on close flag for "
1360 "fnum = %d, file %s\n",
1361 delete_on_close ? "Adding" : "Removing", fsp->fnum,
1362 fsp_str_dbg(fsp)));
1363
1364 lck = get_share_mode_lock(talloc_tos(), fsp->file_id, NULL, NULL,
1365 NULL);
1366 if (lck == NULL) {
1367 return False;
1368 }
1369
1370 set_delete_on_close_lck(fsp, lck, delete_on_close,
1371 delete_on_close ? tok : NULL);
1372
1373 if (fsp->is_directory) {
1374 SMB_ASSERT(!is_ntfs_stream_smb_fname(fsp->fsp_name));
1375 send_stat_cache_delete_message(fsp->conn->sconn->msg_ctx,
1376 fsp->fsp_name->base_name);
1377 }
1378
1379 TALLOC_FREE(lck);
1380
1381 fsp->delete_on_close = delete_on_close;
1382
1383 return True;
1384 }
1385
1386 const struct security_unix_token *get_delete_on_close_token(struct share_mode_lock *lck, uint32_t name_hash)
1387 {
1388 int i;
1389
1390 DEBUG(10,("get_delete_on_close_token: name_hash = 0x%x\n",
1391 (unsigned int)name_hash ));
1392
1393 for (i=0; i<lck->num_delete_tokens; i++) {
1394 struct delete_token *dt = &lck->delete_tokens[i];
1395 DEBUG(10,("get_delete_on_close_token: dtl->name_hash = 0x%x\n",
1396 (unsigned int)dt->name_hash ));
1397 if (dt->name_hash == name_hash) {
1398 return dt->delete_token;
1399 }
1400 }
1401 return NULL;
1402 }
1403
1404 bool is_delete_on_close_set(struct share_mode_lock *lck, uint32_t name_hash)
1405 {
1406 return (get_delete_on_close_token(lck, name_hash) != NULL);
1407 }
1408
1409 bool set_sticky_write_time(struct file_id fileid, struct timespec write_time)
1410 {
1411 struct share_mode_lock *lck;
1412
1413 DEBUG(5,("set_sticky_write_time: %s id=%s\n",
1414 timestring(talloc_tos(),
1415 convert_timespec_to_time_t(write_time)),
1416 file_id_string_tos(&fileid)));
1417
1418 lck = get_share_mode_lock(NULL, fileid, NULL, NULL, NULL);
1419 if (lck == NULL) {
1420 return False;
1421 }
1422
1423 if (timespec_compare(&lck->changed_write_time, &write_time) != 0) {
1424 lck->modified = True;
1425 lck->changed_write_time = write_time;
1426 }
1427
1428 TALLOC_FREE(lck);
1429 return True;
1430 }
1431
1432 bool set_write_time(struct file_id fileid, struct timespec write_time)
1433 {
1434 struct share_mode_lock *lck;
1435
1436 DEBUG(5,("set_write_time: %s id=%s\n",
1437 timestring(talloc_tos(),
1438 convert_timespec_to_time_t(write_time)),
1439 file_id_string_tos(&fileid)));
1440
1441 lck = get_share_mode_lock(NULL, fileid, NULL, NULL, NULL);
1442 if (lck == NULL) {
1443 return False;
1444 }
1445
1446 if (timespec_compare(&lck->old_write_time, &write_time) != 0) {
1447 lck->modified = True;
1448 lck->old_write_time = write_time;
1449 }
1450
1451 TALLOC_FREE(lck);
1452 return True;
1453 }
1454
1455
1456 struct forall_state {
1457 void (*fn)(const struct share_mode_entry *entry,
1458 const char *sharepath,
1459 const char *fname,
1460 void *private_data);
1461 void *private_data;
1462 };
1463
1464 static int traverse_fn(struct db_record *rec, void *_state)
1465 {
1466 struct forall_state *state = (struct forall_state *)_state;
1467 uint32_t i;
1468 TDB_DATA key;
1469 TDB_DATA value;
1470 DATA_BLOB blob;
1471 enum ndr_err_code ndr_err;
1472 struct share_mode_lock *lck;
1473
1474 key = dbwrap_record_get_key(rec);
1475 value = dbwrap_record_get_value(rec);
1476
1477 /* Ensure this is a locking_key record. */
1478 if (key.dsize != sizeof(struct file_id))
1479 return 0;
1480
1481 lck = talloc(talloc_tos(), struct share_mode_lock);
1482 if (lck == NULL) {
1483 return 0;
1484 }
1485
1486 blob.data = value.dptr;
1487 blob.length = value.dsize;
1488
1489 ndr_err = ndr_pull_struct_blob(
1490 &blob, lck, lck,
1491 (ndr_pull_flags_fn_t)ndr_pull_share_mode_lock);
1492 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1493 DEBUG(1, ("ndr_pull_share_mode_lock failed\n"));
1494 return 0;
1495 }
1496 for (i=0; i<lck->num_share_modes; i++) {
1497 state->fn(&lck->share_modes[i],
1498 lck->servicepath, lck->base_name,
1499 state->private_data);
1500 }
1501 TALLOC_FREE(lck);
1502
1503 return 0;
1504 }
1505
1506 /*******************************************************************
1507 Call the specified function on each entry under management by the
1508 share mode system.
1509 ********************************************************************/
1510
1511 int share_mode_forall(void (*fn)(const struct share_mode_entry *, const char *,
1512 const char *, void *),
1513 void *private_data)
1514 {
1515 struct forall_state state;
1516 NTSTATUS status;
1517 int count;
1518
1519 if (lock_db == NULL)
1520 return 0;
1521
1522 state.fn = fn;
1523 state.private_data = private_data;
1524
1525 status = dbwrap_traverse_read(lock_db, traverse_fn, (void *)&state,
1526 &count);
1527
1528 if (!NT_STATUS_IS_OK(status)) {
1529 return -1;
1530 } else {
1531 return count;
1532 }
1533 }
reg import