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