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