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