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