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