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