?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
messages_ctdb: Handle async msgs for nested event contexts
[Samba.git] / source3 / locking / locking.c
blob4e9f1bbc681e30144a1b4eb04ef458e8524e6a83
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 rewritten 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 "system/filesys.h"
40 #include "lib/util/server_id.h"
41 #include "locking/proto.h"
42 #include "smbd/globals.h"
43 #include "dbwrap/dbwrap.h"
44 #include "dbwrap/dbwrap_open.h"
45 #include "../libcli/security/security.h"
46 #include "serverid.h"
47 #include "messages.h"
48 #include "util_tdb.h"
49 #include "../librpc/gen_ndr/ndr_open_files.h"
50 #include "librpc/gen_ndr/ndr_file_id.h"
51 #include "locking/leases_db.h"
52
53 #undef DBGC_CLASS
54 #define DBGC_CLASS DBGC_LOCKING
55
56 #define NO_LOCKING_COUNT (-1)
57
58 /****************************************************************************
59 Debugging aids :-).
60 ****************************************************************************/
61
62 const char *lock_type_name(enum brl_type lock_type)
63 {
64 switch (lock_type) {
65 case READ_LOCK:
66 return "READ";
67 case WRITE_LOCK:
68 return "WRITE";
69 case PENDING_READ_LOCK:
70 return "PENDING_READ";
71 case PENDING_WRITE_LOCK:
72 return "PENDING_WRITE";
73 default:
74 return "other";
75 }
76 }
77
78 const char *lock_flav_name(enum brl_flavour lock_flav)
79 {
80 return (lock_flav == WINDOWS_LOCK) ? "WINDOWS_LOCK" : "POSIX_LOCK";
81 }
82
83 /****************************************************************************
84 Utility function called to see if a file region is locked.
85 Called in the read/write codepath.
86 ****************************************************************************/
87
88 void init_strict_lock_struct(files_struct *fsp,
89 uint64_t smblctx,
90 br_off start,
91 br_off size,
92 enum brl_type lock_type,
93 struct lock_struct *plock)
94 {
95 SMB_ASSERT(lock_type == READ_LOCK || lock_type == WRITE_LOCK);
96
97 plock->context.smblctx = smblctx;
98 plock->context.tid = fsp->conn->cnum;
99 plock->context.pid = messaging_server_id(fsp->conn->sconn->msg_ctx);
100 plock->start = start;
101 plock->size = size;
102 plock->fnum = fsp->fnum;
103 plock->lock_type = lock_type;
104 plock->lock_flav = lp_posix_cifsu_locktype(fsp);
105 }
106
107 bool strict_lock_check_default(files_struct *fsp, struct lock_struct *plock)
108 {
109 struct byte_range_lock *br_lck;
110 int strict_locking = lp_strict_locking(fsp->conn->params);
111 bool ret = False;
112
113 if (plock->size == 0) {
114 return True;
115 }
116
117 if (!lp_locking(fsp->conn->params) || !strict_locking) {
118 return True;
119 }
120
121 if (strict_locking == Auto) {
122 uint32_t lease_type = fsp_lease_type(fsp);
123
124 if ((lease_type & SMB2_LEASE_READ) &&
125 (plock->lock_type == READ_LOCK))
126 {
127 DBG_DEBUG("optimisation - read lease on file %s\n",
128 fsp_str_dbg(fsp));
129 return true;
130 }
131
132 if ((lease_type & SMB2_LEASE_WRITE) &&
133 (plock->lock_type == WRITE_LOCK))
134 {
135 DBG_DEBUG("optimisation - write lease on file %s\n",
136 fsp_str_dbg(fsp));
137 return true;
138 }
139 }
140
141 br_lck = brl_get_locks_readonly(fsp);
142 if (!br_lck) {
143 return true;
144 }
145 ret = brl_locktest(br_lck, plock);
146
147 if (!ret) {
148 /*
149 * We got a lock conflict. Retry with rw locks to enable
150 * autocleanup. This is the slow path anyway.
151 */
152 br_lck = brl_get_locks(talloc_tos(), fsp);
153 ret = brl_locktest(br_lck, plock);
154 TALLOC_FREE(br_lck);
155 }
156
157 DEBUG(10, ("strict_lock_default: flavour = %s brl start=%ju "
158 "len=%ju %s for fnum %ju file %s\n",
159 lock_flav_name(plock->lock_flav),
160 (uintmax_t)plock->start, (uintmax_t)plock->size,
161 ret ? "unlocked" : "locked",
162 (uintmax_t)plock->fnum, fsp_str_dbg(fsp)));
163
164 return ret;
165 }
166
167 /****************************************************************************
168 Find out if a lock could be granted - return who is blocking us if we can't.
169 ****************************************************************************/
170
171 NTSTATUS query_lock(files_struct *fsp,
172 uint64_t *psmblctx,
173 uint64_t *pcount,
174 uint64_t *poffset,
175 enum brl_type *plock_type,
176 enum brl_flavour lock_flav)
177 {
178 struct byte_range_lock *br_lck = NULL;
179
180 if (!fsp->can_lock) {
181 return fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
182 }
183
184 if (!lp_locking(fsp->conn->params)) {
185 return NT_STATUS_OK;
186 }
187
188 br_lck = brl_get_locks_readonly(fsp);
189 if (!br_lck) {
190 return NT_STATUS_NO_MEMORY;
191 }
192
193 return brl_lockquery(br_lck,
194 psmblctx,
195 messaging_server_id(fsp->conn->sconn->msg_ctx),
196 poffset,
197 pcount,
198 plock_type,
199 lock_flav);
200 }
201
202 static void increment_current_lock_count(files_struct *fsp,
203 enum brl_flavour lock_flav)
204 {
205 if (lock_flav == WINDOWS_LOCK &&
206 fsp->current_lock_count != NO_LOCKING_COUNT) {
207 /* blocking ie. pending, locks also count here,
208 * as this is an efficiency counter to avoid checking
209 * the lock db. on close. JRA. */
210
211 fsp->current_lock_count++;
212 } else {
213 /* Notice that this has had a POSIX lock request.
214 * We can't count locks after this so forget them.
215 */
216 fsp->current_lock_count = NO_LOCKING_COUNT;
217 }
218 }
219
220 static void decrement_current_lock_count(files_struct *fsp,
221 enum brl_flavour lock_flav)
222 {
223 if (lock_flav == WINDOWS_LOCK &&
224 fsp->current_lock_count != NO_LOCKING_COUNT) {
225 SMB_ASSERT(fsp->current_lock_count > 0);
226 fsp->current_lock_count--;
227 }
228 }
229
230 /****************************************************************************
231 Utility function called by locking requests.
232 ****************************************************************************/
233
234 struct byte_range_lock *do_lock(struct messaging_context *msg_ctx,
235 files_struct *fsp,
236 uint64_t smblctx,
237 uint64_t count,
238 uint64_t offset,
239 enum brl_type lock_type,
240 enum brl_flavour lock_flav,
241 bool blocking_lock,
242 NTSTATUS *perr,
243 uint64_t *psmblctx)
244 {
245 struct byte_range_lock *br_lck = NULL;
246
247 /* silently return ok on print files as we don't do locking there */
248 if (fsp->print_file) {
249 *perr = NT_STATUS_OK;
250 return NULL;
251 }
252
253 if (!fsp->can_lock) {
254 *perr = fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
255 return NULL;
256 }
257
258 if (!lp_locking(fsp->conn->params)) {
259 *perr = NT_STATUS_OK;
260 return NULL;
261 }
262
263 /* NOTE! 0 byte long ranges ARE allowed and should be stored */
264
265 DEBUG(10,("do_lock: lock flavour %s lock type %s start=%ju len=%ju "
266 "blocking_lock=%s requested for %s file %s\n",
267 lock_flav_name(lock_flav), lock_type_name(lock_type),
268 (uintmax_t)offset, (uintmax_t)count, blocking_lock ? "true" :
269 "false", fsp_fnum_dbg(fsp), fsp_str_dbg(fsp)));
270
271 br_lck = brl_get_locks(talloc_tos(), fsp);
272 if (!br_lck) {
273 *perr = NT_STATUS_NO_MEMORY;
274 return NULL;
275 }
276
277 *perr = brl_lock(msg_ctx,
278 br_lck,
279 smblctx,
280 messaging_server_id(fsp->conn->sconn->msg_ctx),
281 offset,
282 count,
283 lock_type,
284 lock_flav,
285 blocking_lock,
286 psmblctx);
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=%ju len=%ju requested for %s file "
317 "%s\n", (uintmax_t)offset, (uintmax_t)count,
318 fsp_fnum_dbg(fsp), 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 messaging_server_id(fsp->conn->sconn->msg_ctx),
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_t smblctx,
350 uint64_t count,
351 uint64_t offset,
352 enum brl_flavour lock_flav)
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=%ju len=%ju requested for "
367 "%s file %s\n", (uintmax_t)offset, (uintmax_t)count,
368 fsp_fnum_dbg(fsp), 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 messaging_server_id(fsp->conn->sconn->msg_ctx),
378 offset,
379 count,
380 lock_flav);
381
382 TALLOC_FREE(br_lck);
383
384 if (!ok) {
385 DEBUG(10,("do_lock_cancel: returning ERRcancelviolation.\n" ));
386 return NT_STATUS_DOS(ERRDOS, ERRcancelviolation);
387 }
388
389 decrement_current_lock_count(fsp, lock_flav);
390 return NT_STATUS_OK;
391 }
392
393 /****************************************************************************
394 Remove any locks on this fd. Called from file_close().
395 ****************************************************************************/
396
397 void locking_close_file(struct messaging_context *msg_ctx,
398 files_struct *fsp,
399 enum file_close_type close_type)
400 {
401 struct byte_range_lock *br_lck;
402
403 if (!lp_locking(fsp->conn->params)) {
404 return;
405 }
406
407 /* If we have no outstanding locks or pending
408 * locks then we don't need to look in the lock db.
409 */
410
411 if (fsp->current_lock_count == 0) {
412 return;
413 }
414
415 br_lck = brl_get_locks(talloc_tos(),fsp);
416
417 if (br_lck) {
418 cancel_pending_lock_requests_by_fid(fsp, br_lck, close_type);
419 brl_close_fnum(msg_ctx, br_lck);
420 TALLOC_FREE(br_lck);
421 }
422 }
423
424 /*******************************************************************
425 Print out a share mode.
426 ********************************************************************/
427
428 char *share_mode_str(TALLOC_CTX *ctx, int num, const struct share_mode_entry *e)
429 {
430 struct server_id_buf tmp;
431
432 return talloc_asprintf(ctx, "share_mode_entry[%d]: "
433 "pid = %s, share_access = 0x%x, private_options = 0x%x, "
434 "access_mask = 0x%x, mid = 0x%llx, type= 0x%x, gen_id = %llu, "
435 "uid = %u, flags = %u, file_id %s, name_hash = 0x%x",
436 num,
437 server_id_str_buf(e->pid, &tmp),
438 e->share_access, e->private_options,
439 e->access_mask, (unsigned long long)e->op_mid,
440 e->op_type, (unsigned long long)e->share_file_id,
441 (unsigned int)e->uid, (unsigned int)e->flags,
442 file_id_string_tos(&e->id),
443 (unsigned int)e->name_hash);
444 }
445
446 /*******************************************************************
447 Fetch a share mode where we know one MUST exist. This call reference
448 counts it internally to allow for nested lock fetches.
449 ********************************************************************/
450
451 struct share_mode_lock *get_existing_share_mode_lock(TALLOC_CTX *mem_ctx,
452 const struct file_id id)
453 {
454 return get_share_mode_lock(mem_ctx, id, NULL, NULL, NULL);
455 }
456
457 /*******************************************************************
458 Sets the service name and filename for rename.
459 At this point we emit "file renamed" messages to all
460 process id's that have this file open.
461 Based on an initial code idea from SATOH Fumiyasu <fumiya@samba.gr.jp>
462 ********************************************************************/
463
464 bool rename_share_filename(struct messaging_context *msg_ctx,
465 struct share_mode_lock *lck,
466 struct file_id id,
467 const char *servicepath,
468 uint32_t orig_name_hash,
469 uint32_t new_name_hash,
470 const struct smb_filename *smb_fname_dst)
471 {
472 struct share_mode_data *d = lck->data;
473 size_t sp_len;
474 size_t bn_len;
475 size_t sn_len;
476 size_t msg_len;
477 char *frm = NULL;
478 uint32_t i;
479 bool strip_two_chars = false;
480 bool has_stream = smb_fname_dst->stream_name != NULL;
481 struct server_id self_pid = messaging_server_id(msg_ctx);
482
483 DEBUG(10, ("rename_share_filename: servicepath %s newname %s\n",
484 servicepath, smb_fname_dst->base_name));
485
486 /*
487 * rename_internal_fsp() and rename_internals() add './' to
488 * head of newname if newname does not contain a '/'.
489 */
490 if (smb_fname_dst->base_name[0] &&
491 smb_fname_dst->base_name[1] &&
492 smb_fname_dst->base_name[0] == '.' &&
493 smb_fname_dst->base_name[1] == '/') {
494 strip_two_chars = true;
495 }
496
497 d->servicepath = talloc_strdup(d, servicepath);
498 d->base_name = talloc_strdup(d, smb_fname_dst->base_name +
499 (strip_two_chars ? 2 : 0));
500 d->stream_name = talloc_strdup(d, smb_fname_dst->stream_name);
501 if (d->base_name == NULL ||
502 (has_stream && d->stream_name == NULL) ||
503 d->servicepath == NULL) {
504 DEBUG(0, ("rename_share_filename: talloc failed\n"));
505 return False;
506 }
507 d->modified = True;
508
509 sp_len = strlen(d->servicepath);
510 bn_len = strlen(d->base_name);
511 sn_len = has_stream ? strlen(d->stream_name) : 0;
512
513 msg_len = MSG_FILE_RENAMED_MIN_SIZE + sp_len + 1 + bn_len + 1 +
514 sn_len + 1;
515
516 /* Set up the name changed message. */
517 frm = talloc_array(d, char, msg_len);
518 if (!frm) {
519 return False;
520 }
521
522 push_file_id_24(frm, &id);
523
524 DEBUG(10,("rename_share_filename: msg_len = %u\n", (unsigned int)msg_len ));
525
526 strlcpy(&frm[24],
527 d->servicepath ? d->servicepath : "",
528 sp_len+1);
529 strlcpy(&frm[24 + sp_len + 1],
530 d->base_name ? d->base_name : "",
531 bn_len+1);
532 strlcpy(&frm[24 + sp_len + 1 + bn_len + 1],
533 d->stream_name ? d->stream_name : "",
534 sn_len+1);
535
536 /* Send the messages. */
537 for (i=0; i<d->num_share_modes; i++) {
538 struct share_mode_entry *se = &d->share_modes[i];
539 struct server_id_buf tmp;
540
541 if (!is_valid_share_mode_entry(se)) {
542 continue;
543 }
544
545 /* If this is a hardlink to the inode
546 with a different name, skip this. */
547 if (se->name_hash != orig_name_hash) {
548 continue;
549 }
550
551 se->name_hash = new_name_hash;
552
553 /* But not to ourselves... */
554 if (serverid_equal(&se->pid, &self_pid)) {
555 continue;
556 }
557
558 if (share_mode_stale_pid(d, i)) {
559 continue;
560 }
561
562 DEBUG(10,("rename_share_filename: sending rename message to "
563 "pid %s file_id %s sharepath %s base_name %s "
564 "stream_name %s\n",
565 server_id_str_buf(se->pid, &tmp),
566 file_id_string_tos(&id),
567 d->servicepath, d->base_name,
568 has_stream ? d->stream_name : ""));
569
570 messaging_send_buf(msg_ctx, se->pid, MSG_SMB_FILE_RENAME,
571 (uint8_t *)frm, msg_len);
572 }
573
574 for (i=0; i<d->num_leases; i++) {
575 /* Update the filename in leases_db. */
576 NTSTATUS status;
577 struct share_mode_lease *l;
578
579 l = &d->leases[i];
580
581 status = leases_db_rename(&l->client_guid,
582 &l->lease_key,
583 &id,
584 d->servicepath,
585 d->base_name,
586 d->stream_name);
587 if (!NT_STATUS_IS_OK(status)) {
588 /* Any error recovery possible here ? */
589 DEBUG(1,("Failed to rename lease key for "
590 "renamed file %s:%s. %s\n",
591 d->base_name,
592 d->stream_name,
593 nt_errstr(status)));
594 continue;
595 }
596 }
597
598 return True;
599 }
600
601 void get_file_infos(struct file_id id,
602 uint32_t name_hash,
603 bool *delete_on_close,
604 struct timespec *write_time)
605 {
606 struct share_mode_lock *lck;
607
608 if (delete_on_close) {
609 *delete_on_close = false;
610 }
611
612 if (write_time) {
613 ZERO_STRUCTP(write_time);
614 }
615
616 if (!(lck = fetch_share_mode_unlocked(talloc_tos(), id))) {
617 return;
618 }
619
620 if (delete_on_close) {
621 *delete_on_close = is_delete_on_close_set(lck, name_hash);
622 }
623
624 if (write_time) {
625 *write_time = get_share_mode_write_time(lck);
626 }
627
628 TALLOC_FREE(lck);
629 }
630
631 bool is_valid_share_mode_entry(const struct share_mode_entry *e)
632 {
633 int num_props = 0;
634
635 if (e->stale) {
636 return false;
637 }
638
639 num_props += ((e->op_type == NO_OPLOCK) ? 1 : 0);
640 num_props += (EXCLUSIVE_OPLOCK_TYPE(e->op_type) ? 1 : 0);
641 num_props += (LEVEL_II_OPLOCK_TYPE(e->op_type) ? 1 : 0);
642 num_props += (e->op_type == LEASE_OPLOCK);
643
644 if ((num_props > 1) && serverid_exists(&e->pid)) {
645 smb_panic("Invalid share mode entry");
646 }
647 return (num_props != 0);
648 }
649
650 /*
651 * See if we need to remove a lease being referred to by a
652 * share mode that is being marked stale or deleted.
653 */
654
655 static void remove_share_mode_lease(struct share_mode_data *d,
656 struct share_mode_entry *e)
657 {
658 struct GUID client_guid;
659 struct smb2_lease_key lease_key;
660 uint16_t op_type;
661 uint32_t lease_idx;
662 uint32_t i;
663
664 op_type = e->op_type;
665 e->op_type = NO_OPLOCK;
666
667 d->modified = true;
668
669 if (op_type != LEASE_OPLOCK) {
670 return;
671 }
672
673 /*
674 * This used to reference a lease. If there's no other one referencing
675 * it, remove it.
676 */
677
678 lease_idx = e->lease_idx;
679 e->lease_idx = UINT32_MAX;
680
681 for (i=0; i<d->num_share_modes; i++) {
682 if (d->share_modes[i].stale) {
683 continue;
684 }
685 if (e == &d->share_modes[i]) {
686 /* Not ourselves. */
687 continue;
688 }
689 if (d->share_modes[i].lease_idx == lease_idx) {
690 break;
691 }
692 }
693 if (i < d->num_share_modes) {
694 /*
695 * Found another one
696 */
697 return;
698 }
699
700 memcpy(&client_guid,
701 &d->leases[lease_idx].client_guid,
702 sizeof(client_guid));
703 lease_key = d->leases[lease_idx].lease_key;
704
705 d->num_leases -= 1;
706 d->leases[lease_idx] = d->leases[d->num_leases];
707
708 /*
709 * We changed the lease array. Fix all references to it.
710 */
711 for (i=0; i<d->num_share_modes; i++) {
712 if (d->share_modes[i].lease_idx == d->num_leases) {
713 d->share_modes[i].lease_idx = lease_idx;
714 d->share_modes[i].lease = &d->leases[lease_idx];
715 }
716 }
717
718 {
719 NTSTATUS status;
720
721 status = leases_db_del(&client_guid,
722 &lease_key,
723 &e->id);
724
725 DEBUG(10, ("%s: leases_db_del returned %s\n", __func__,
726 nt_errstr(status)));
727 }
728 }
729
730 /*
731 * In case d->share_modes[i] conflicts with something or otherwise is
732 * being used, we need to make sure the corresponding process still
733 * exists.
734 */
735 bool share_mode_stale_pid(struct share_mode_data *d, uint32_t idx)
736 {
737 struct server_id_buf tmp;
738 struct share_mode_entry *e;
739
740 if (idx > d->num_share_modes) {
741 DEBUG(1, ("Asking for index %u, only %u around\n",
742 idx, (unsigned)d->num_share_modes));
743 return false;
744 }
745 e = &d->share_modes[idx];
746 if (e->stale) {
747 /*
748 * Checked before
749 */
750 return true;
751 }
752 if (serverid_exists(&e->pid)) {
753 DEBUG(10, ("PID %s (index %u out of %u) still exists\n",
754 server_id_str_buf(e->pid, &tmp), idx,
755 (unsigned)d->num_share_modes));
756 return false;
757 }
758 DEBUG(10, ("PID %s (index %u out of %u) does not exist anymore\n",
759 server_id_str_buf(e->pid, &tmp), idx,
760 (unsigned)d->num_share_modes));
761
762 e->stale = true;
763
764 if (d->num_delete_tokens != 0) {
765 uint32_t i, num_stale;
766
767 /*
768 * We cannot have any delete tokens
769 * if there are no valid share modes.
770 */
771
772 num_stale = 0;
773
774 for (i=0; i<d->num_share_modes; i++) {
775 if (d->share_modes[i].stale) {
776 num_stale += 1;
777 }
778 }
779
780 if (num_stale == d->num_share_modes) {
781 /*
782 * No non-stale share mode found
783 */
784 TALLOC_FREE(d->delete_tokens);
785 d->num_delete_tokens = 0;
786 }
787 }
788
789 remove_share_mode_lease(d, e);
790
791 d->modified = true;
792 return true;
793 }
794
795 void remove_stale_share_mode_entries(struct share_mode_data *d)
796 {
797 uint32_t i;
798
799 i = 0;
800 while (i < d->num_share_modes) {
801 if (d->share_modes[i].stale) {
802 struct share_mode_entry *m = d->share_modes;
803 m[i] = m[d->num_share_modes-1];
804 d->num_share_modes -= 1;
805 } else {
806 i += 1;
807 }
808 }
809 }
810
811 bool set_share_mode(struct share_mode_lock *lck, struct files_struct *fsp,
812 uid_t uid, uint64_t mid, uint16_t op_type,
813 uint32_t lease_idx)
814 {
815 struct share_mode_data *d = lck->data;
816 struct share_mode_entry *tmp, *e;
817 struct share_mode_lease *lease = NULL;
818
819 if (lease_idx == UINT32_MAX) {
820 lease = NULL;
821 } else if (lease_idx >= d->num_leases) {
822 return false;
823 } else {
824 lease = &d->leases[lease_idx];
825 }
826
827 tmp = talloc_realloc(d, d->share_modes, struct share_mode_entry,
828 d->num_share_modes+1);
829 if (tmp == NULL) {
830 return false;
831 }
832 d->share_modes = tmp;
833 e = &d->share_modes[d->num_share_modes];
834 d->num_share_modes += 1;
835 d->modified = true;
836
837 ZERO_STRUCTP(e);
838 e->pid = messaging_server_id(fsp->conn->sconn->msg_ctx);
839 e->share_access = fsp->share_access;
840 e->private_options = fsp->fh->private_options;
841 e->access_mask = fsp->access_mask;
842 e->op_mid = mid;
843 e->op_type = op_type;
844 e->lease_idx = lease_idx;
845 e->lease = lease;
846 e->time.tv_sec = fsp->open_time.tv_sec;
847 e->time.tv_usec = fsp->open_time.tv_usec;
848 e->id = fsp->file_id;
849 e->share_file_id = fsp->fh->gen_id;
850 e->uid = (uint32_t)uid;
851 e->flags = (fsp->posix_flags & FSP_POSIX_FLAGS_OPEN) ?
852 SHARE_MODE_FLAG_POSIX_OPEN : 0;
853 e->name_hash = fsp->name_hash;
854
855 return true;
856 }
857
858 struct share_mode_entry *find_share_mode_entry(
859 struct share_mode_lock *lck, files_struct *fsp)
860 {
861 struct share_mode_data *d = lck->data;
862 struct server_id pid;
863 int i;
864
865 pid = messaging_server_id(fsp->conn->sconn->msg_ctx);
866
867 for (i=0; i<d->num_share_modes; i++) {
868 struct share_mode_entry *e = &d->share_modes[i];
869
870 if (!is_valid_share_mode_entry(e)) {
871 continue;
872 }
873 if (!serverid_equal(&pid, &e->pid)) {
874 continue;
875 }
876 if (!file_id_equal(&fsp->file_id, &e->id)) {
877 continue;
878 }
879 if (fsp->fh->gen_id != e->share_file_id) {
880 continue;
881 }
882 return e;
883 }
884 return NULL;
885 }
886
887 /*******************************************************************
888 Del the share mode of a file for this process. Return the number of
889 entries left.
890 ********************************************************************/
891
892 bool del_share_mode(struct share_mode_lock *lck, files_struct *fsp)
893 {
894 struct share_mode_entry *e;
895
896 e = find_share_mode_entry(lck, fsp);
897 if (e == NULL) {
898 return False;
899 }
900 remove_share_mode_lease(lck->data, e);
901 *e = lck->data->share_modes[lck->data->num_share_modes-1];
902 lck->data->num_share_modes -= 1;
903 lck->data->modified = True;
904 return True;
905 }
906
907 bool mark_share_mode_disconnected(struct share_mode_lock *lck,
908 struct files_struct *fsp)
909 {
910 struct share_mode_entry *e;
911
912 if (lck->data->num_share_modes != 1) {
913 return false;
914 }
915
916 if (fsp->op == NULL) {
917 return false;
918 }
919 if (!fsp->op->global->durable) {
920 return false;
921 }
922
923 e = find_share_mode_entry(lck, fsp);
924 if (e == NULL) {
925 return false;
926 }
927
928 DEBUG(10, ("Marking share mode entry disconnected for durable handle\n"));
929
930 server_id_set_disconnected(&e->pid);
931
932 /*
933 * On reopen the caller needs to check that
934 * the client comes with the correct handle.
935 */
936 e->share_file_id = fsp->op->global->open_persistent_id;
937
938 lck->data->modified = true;
939 return true;
940 }
941
942 /*******************************************************************
943 Remove an oplock mid and mode entry from a share mode.
944 ********************************************************************/
945
946 bool remove_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
947 {
948 struct share_mode_data *d = lck->data;
949 struct share_mode_entry *e;
950
951 e = find_share_mode_entry(lck, fsp);
952 if (e == NULL) {
953 return False;
954 }
955
956 remove_share_mode_lease(d, e);
957 d->modified = True;
958 return true;
959 }
960
961 /*******************************************************************
962 Downgrade a oplock type from exclusive to level II.
963 ********************************************************************/
964
965 bool downgrade_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
966 {
967 struct share_mode_entry *e;
968
969 e = find_share_mode_entry(lck, fsp);
970 if (e == NULL) {
971 return False;
972 }
973
974 e->op_type = LEVEL_II_OPLOCK;
975 lck->data->modified = True;
976 return True;
977 }
978
979 NTSTATUS downgrade_share_lease(struct smbd_server_connection *sconn,
980 struct share_mode_lock *lck,
981 const struct smb2_lease_key *key,
982 uint32_t new_lease_state,
983 struct share_mode_lease **_l)
984 {
985 struct share_mode_data *d = lck->data;
986 struct share_mode_lease *l;
987 uint32_t i;
988
989 *_l = NULL;
990
991 for (i=0; i<d->num_leases; i++) {
992 if (smb2_lease_equal(&sconn->client->connections->smb2.client.guid,
993 key,
994 &d->leases[i].client_guid,
995 &d->leases[i].lease_key)) {
996 break;
997 }
998 }
999 if (i == d->num_leases) {
1000 DEBUG(10, ("lease not found\n"));
1001 return NT_STATUS_INVALID_PARAMETER;
1002 }
1003
1004 l = &d->leases[i];
1005
1006 if (!l->breaking) {
1007 DEBUG(1, ("Attempt to break from %d to %d - but we're not in breaking state\n",
1008 (int)l->current_state, (int)new_lease_state));
1009 return NT_STATUS_UNSUCCESSFUL;
1010 }
1011
1012 /*
1013 * Can't upgrade anything: l->breaking_to_requested (and l->current_state)
1014 * must be a strict bitwise superset of new_lease_state
1015 */
1016 if ((new_lease_state & l->breaking_to_requested) != new_lease_state) {
1017 DEBUG(1, ("Attempt to upgrade from %d to %d - expected %d\n",
1018 (int)l->current_state, (int)new_lease_state,
1019 (int)l->breaking_to_requested));
1020 return NT_STATUS_REQUEST_NOT_ACCEPTED;
1021 }
1022
1023 if (l->current_state != new_lease_state) {
1024 l->current_state = new_lease_state;
1025 d->modified = true;
1026 }
1027
1028 if ((new_lease_state & ~l->breaking_to_required) != 0) {
1029 DEBUG(5, ("lease state %d not fully broken from %d to %d\n",
1030 (int)new_lease_state,
1031 (int)l->current_state,
1032 (int)l->breaking_to_required));
1033 l->breaking_to_requested = l->breaking_to_required;
1034 if (l->current_state & (~SMB2_LEASE_READ)) {
1035 /*
1036 * Here we break in steps, as windows does
1037 * see the breaking3 and v2_breaking3 tests.
1038 */
1039 l->breaking_to_requested |= SMB2_LEASE_READ;
1040 }
1041 d->modified = true;
1042 *_l = l;
1043 return NT_STATUS_OPLOCK_BREAK_IN_PROGRESS;
1044 }
1045
1046 DEBUG(10, ("breaking from %d to %d - expected %d\n",
1047 (int)l->current_state, (int)new_lease_state,
1048 (int)l->breaking_to_requested));
1049
1050 l->breaking_to_requested = 0;
1051 l->breaking_to_required = 0;
1052 l->breaking = false;
1053
1054 d->modified = true;
1055
1056 return NT_STATUS_OK;
1057 }
1058
1059 /****************************************************************************
1060 Adds a delete on close token.
1061 ****************************************************************************/
1062
1063 static bool add_delete_on_close_token(struct share_mode_data *d,
1064 uint32_t name_hash,
1065 const struct security_token *nt_tok,
1066 const struct security_unix_token *tok)
1067 {
1068 struct delete_token *tmp, *dtl;
1069
1070 tmp = talloc_realloc(d, d->delete_tokens, struct delete_token,
1071 d->num_delete_tokens+1);
1072 if (tmp == NULL) {
1073 return false;
1074 }
1075 d->delete_tokens = tmp;
1076 dtl = &d->delete_tokens[d->num_delete_tokens];
1077
1078 dtl->name_hash = name_hash;
1079 dtl->delete_nt_token = dup_nt_token(d->delete_tokens, nt_tok);
1080 if (dtl->delete_nt_token == NULL) {
1081 return false;
1082 }
1083 dtl->delete_token = copy_unix_token(d->delete_tokens, tok);
1084 if (dtl->delete_token == NULL) {
1085 return false;
1086 }
1087 d->num_delete_tokens += 1;
1088 d->modified = true;
1089 return true;
1090 }
1091
1092 void reset_delete_on_close_lck(files_struct *fsp,
1093 struct share_mode_lock *lck)
1094 {
1095 struct share_mode_data *d = lck->data;
1096 uint32_t i;
1097
1098 for (i=0; i<d->num_delete_tokens; i++) {
1099 struct delete_token *dt = &d->delete_tokens[i];
1100
1101 if (dt->name_hash == fsp->name_hash) {
1102 d->modified = true;
1103
1104 /* Delete this entry. */
1105 TALLOC_FREE(dt->delete_nt_token);
1106 TALLOC_FREE(dt->delete_token);
1107 *dt = d->delete_tokens[d->num_delete_tokens-1];
1108 d->num_delete_tokens -= 1;
1109 }
1110 }
1111 }
1112
1113 /****************************************************************************
1114 Sets the delete on close flag over all share modes on this file.
1115 Modify the share mode entry for all files open
1116 on this device and inode to tell other smbds we have
1117 changed the delete on close flag. This will be noticed
1118 in the close code, the last closer will delete the file
1119 if flag is set.
1120 This makes a copy of any struct security_unix_token into the
1121 lck entry. This function is used when the lock is already granted.
1122 ****************************************************************************/
1123
1124 void set_delete_on_close_lck(files_struct *fsp,
1125 struct share_mode_lock *lck,
1126 const struct security_token *nt_tok,
1127 const struct security_unix_token *tok)
1128 {
1129 struct messaging_context *msg_ctx = fsp->conn->sconn->msg_ctx;
1130 struct share_mode_data *d = lck->data;
1131 uint32_t i;
1132 bool ret;
1133 DATA_BLOB fid_blob = {};
1134 enum ndr_err_code ndr_err;
1135
1136 SMB_ASSERT(nt_tok != NULL);
1137 SMB_ASSERT(tok != NULL);
1138
1139 for (i=0; i<d->num_delete_tokens; i++) {
1140 struct delete_token *dt = &d->delete_tokens[i];
1141 if (dt->name_hash == fsp->name_hash) {
1142 d->modified = true;
1143
1144 /* Replace this token with the given tok. */
1145 TALLOC_FREE(dt->delete_nt_token);
1146 dt->delete_nt_token = dup_nt_token(dt, nt_tok);
1147 SMB_ASSERT(dt->delete_nt_token != NULL);
1148 TALLOC_FREE(dt->delete_token);
1149 dt->delete_token = copy_unix_token(dt, tok);
1150 SMB_ASSERT(dt->delete_token != NULL);
1151
1152 return;
1153 }
1154 }
1155
1156 ret = add_delete_on_close_token(lck->data, fsp->name_hash, nt_tok, tok);
1157 SMB_ASSERT(ret);
1158
1159 ndr_err = ndr_push_struct_blob(&fid_blob, talloc_tos(), &fsp->file_id,
1160 (ndr_push_flags_fn_t)ndr_push_file_id);
1161 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1162 DEBUG(10, ("ndr_push_file_id failed: %s\n",
1163 ndr_errstr(ndr_err)));
1164 }
1165
1166 for (i=0; i<d->num_share_modes; i++) {
1167 struct share_mode_entry *e = &d->share_modes[i];
1168 NTSTATUS status;
1169
1170 status = messaging_send(
1171 msg_ctx, e->pid, MSG_SMB_NOTIFY_CANCEL_DELETED,
1172 &fid_blob);
1173
1174 if (!NT_STATUS_IS_OK(status)) {
1175 struct server_id_buf tmp;
1176 DEBUG(10, ("%s: messaging_send to %s returned %s\n",
1177 __func__, server_id_str_buf(e->pid, &tmp),
1178 nt_errstr(status)));
1179 }
1180 }
1181
1182 TALLOC_FREE(fid_blob.data);
1183 }
1184
1185 bool set_delete_on_close(files_struct *fsp, bool delete_on_close,
1186 const struct security_token *nt_tok,
1187 const struct security_unix_token *tok)
1188 {
1189 struct share_mode_lock *lck;
1190
1191 DEBUG(10,("set_delete_on_close: %s delete on close flag for "
1192 "%s, file %s\n",
1193 delete_on_close ? "Adding" : "Removing", fsp_fnum_dbg(fsp),
1194 fsp_str_dbg(fsp)));
1195
1196 lck = get_existing_share_mode_lock(talloc_tos(), fsp->file_id);
1197 if (lck == NULL) {
1198 return False;
1199 }
1200
1201 if (delete_on_close) {
1202 set_delete_on_close_lck(fsp, lck, nt_tok, tok);
1203 } else {
1204 reset_delete_on_close_lck(fsp, lck);
1205 }
1206
1207 if (fsp->is_directory) {
1208 SMB_ASSERT(!is_ntfs_stream_smb_fname(fsp->fsp_name));
1209 send_stat_cache_delete_message(fsp->conn->sconn->msg_ctx,
1210 fsp->fsp_name->base_name);
1211 }
1212
1213 TALLOC_FREE(lck);
1214
1215 fsp->delete_on_close = delete_on_close;
1216
1217 return True;
1218 }
1219
1220 static struct delete_token *find_delete_on_close_token(
1221 struct share_mode_data *d, uint32_t name_hash)
1222 {
1223 uint32_t i;
1224
1225 DEBUG(10, ("find_delete_on_close_token: name_hash = 0x%x\n",
1226 (unsigned int)name_hash));
1227
1228 for (i=0; i<d->num_delete_tokens; i++) {
1229 struct delete_token *dt = &d->delete_tokens[i];
1230
1231 DEBUG(10, ("find__delete_on_close_token: dt->name_hash = 0x%x\n",
1232 (unsigned int)dt->name_hash ));
1233 if (dt->name_hash == name_hash) {
1234 return dt;
1235 }
1236 }
1237 return NULL;
1238 }
1239
1240 /****************************************************************************
1241 Return the NT token and UNIX token if there's a match. Return true if
1242 found, false if not.
1243 ****************************************************************************/
1244
1245 bool get_delete_on_close_token(struct share_mode_lock *lck,
1246 uint32_t name_hash,
1247 const struct security_token **pp_nt_tok,
1248 const struct security_unix_token **pp_tok)
1249 {
1250 struct delete_token *dt;
1251
1252 dt = find_delete_on_close_token(lck->data, name_hash);
1253 if (dt == NULL) {
1254 return false;
1255 }
1256 *pp_nt_tok = dt->delete_nt_token;
1257 *pp_tok = dt->delete_token;
1258 return true;
1259 }
1260
1261 bool is_delete_on_close_set(struct share_mode_lock *lck, uint32_t name_hash)
1262 {
1263 return find_delete_on_close_token(lck->data, name_hash) != NULL;
1264 }
1265
1266 bool set_sticky_write_time(struct file_id fileid, struct timespec write_time)
1267 {
1268 struct share_mode_lock *lck;
1269
1270 DEBUG(5,("set_sticky_write_time: %s id=%s\n",
1271 timestring(talloc_tos(),
1272 convert_timespec_to_time_t(write_time)),
1273 file_id_string_tos(&fileid)));
1274
1275 lck = get_existing_share_mode_lock(talloc_tos(), fileid);
1276 if (lck == NULL) {
1277 return False;
1278 }
1279
1280 if (timespec_compare(&lck->data->changed_write_time, &write_time) != 0) {
1281 lck->data->modified = True;
1282 lck->data->changed_write_time = write_time;
1283 }
1284
1285 TALLOC_FREE(lck);
1286 return True;
1287 }
1288
1289 bool set_write_time(struct file_id fileid, struct timespec write_time)
1290 {
1291 struct share_mode_lock *lck;
1292
1293 DEBUG(5,("set_write_time: %s id=%s\n",
1294 timestring(talloc_tos(),
1295 convert_timespec_to_time_t(write_time)),
1296 file_id_string_tos(&fileid)));
1297
1298 lck = get_existing_share_mode_lock(talloc_tos(), fileid);
1299 if (lck == NULL) {
1300 return False;
1301 }
1302
1303 if (timespec_compare(&lck->data->old_write_time, &write_time) != 0) {
1304 lck->data->modified = True;
1305 lck->data->old_write_time = write_time;
1306 }
1307
1308 TALLOC_FREE(lck);
1309 return True;
1310 }
1311
1312 struct timespec get_share_mode_write_time(struct share_mode_lock *lck)
1313 {
1314 struct share_mode_data *d = lck->data;
1315
1316 if (!null_timespec(d->changed_write_time)) {
1317 return d->changed_write_time;
1318 }
1319 return d->old_write_time;
1320 }
Samba GIT mirror