?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s4/selftest: Enable samba.tests.samba_tool.sites for py3
[Samba.git] / source3 / locking / locking.c
blobb2681208cb878fcd599f7abeb06e9e7c14e9ad0b
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,
429 const struct file_id *id,
430 const struct share_mode_entry *e)
431 {
432 struct server_id_buf tmp;
433
434 return talloc_asprintf(ctx, "share_mode_entry[%d]: "
435 "pid = %s, share_access = 0x%x, private_options = 0x%x, "
436 "access_mask = 0x%x, mid = 0x%llx, type= 0x%x, gen_id = %llu, "
437 "uid = %u, flags = %u, file_id %s, name_hash = 0x%x",
438 num,
439 server_id_str_buf(e->pid, &tmp),
440 e->share_access, e->private_options,
441 e->access_mask, (unsigned long long)e->op_mid,
442 e->op_type, (unsigned long long)e->share_file_id,
443 (unsigned int)e->uid, (unsigned int)e->flags,
444 file_id_string_tos(id),
445 (unsigned int)e->name_hash);
446 }
447
448 /*******************************************************************
449 Fetch a share mode where we know one MUST exist. This call reference
450 counts it internally to allow for nested lock fetches.
451 ********************************************************************/
452
453 struct share_mode_lock *get_existing_share_mode_lock(TALLOC_CTX *mem_ctx,
454 const struct file_id id)
455 {
456 return get_share_mode_lock(mem_ctx, id, NULL, NULL, NULL);
457 }
458
459 /*******************************************************************
460 Sets the service name and filename for rename.
461 At this point we emit "file renamed" messages to all
462 process id's that have this file open.
463 Based on an initial code idea from SATOH Fumiyasu <fumiya@samba.gr.jp>
464 ********************************************************************/
465
466 bool rename_share_filename(struct messaging_context *msg_ctx,
467 struct share_mode_lock *lck,
468 struct file_id id,
469 const char *servicepath,
470 uint32_t orig_name_hash,
471 uint32_t new_name_hash,
472 const struct smb_filename *smb_fname_dst)
473 {
474 struct share_mode_data *d = lck->data;
475 size_t sp_len;
476 size_t bn_len;
477 size_t sn_len;
478 size_t msg_len;
479 char *frm = NULL;
480 uint32_t i;
481 bool strip_two_chars = false;
482 bool has_stream = smb_fname_dst->stream_name != NULL;
483 struct server_id self_pid = messaging_server_id(msg_ctx);
484
485 DEBUG(10, ("rename_share_filename: servicepath %s newname %s\n",
486 servicepath, smb_fname_dst->base_name));
487
488 /*
489 * rename_internal_fsp() and rename_internals() add './' to
490 * head of newname if newname does not contain a '/'.
491 */
492 if (smb_fname_dst->base_name[0] &&
493 smb_fname_dst->base_name[1] &&
494 smb_fname_dst->base_name[0] == '.' &&
495 smb_fname_dst->base_name[1] == '/') {
496 strip_two_chars = true;
497 }
498
499 d->servicepath = talloc_strdup(d, servicepath);
500 d->base_name = talloc_strdup(d, smb_fname_dst->base_name +
501 (strip_two_chars ? 2 : 0));
502 d->stream_name = talloc_strdup(d, smb_fname_dst->stream_name);
503 if (d->base_name == NULL ||
504 (has_stream && d->stream_name == NULL) ||
505 d->servicepath == NULL) {
506 DEBUG(0, ("rename_share_filename: talloc failed\n"));
507 return False;
508 }
509 d->modified = True;
510
511 sp_len = strlen(d->servicepath);
512 bn_len = strlen(d->base_name);
513 sn_len = has_stream ? strlen(d->stream_name) : 0;
514
515 msg_len = MSG_FILE_RENAMED_MIN_SIZE + sp_len + 1 + bn_len + 1 +
516 sn_len + 1;
517
518 /* Set up the name changed message. */
519 frm = talloc_array(d, char, msg_len);
520 if (!frm) {
521 return False;
522 }
523
524 push_file_id_24(frm, &id);
525
526 DEBUG(10,("rename_share_filename: msg_len = %u\n", (unsigned int)msg_len ));
527
528 strlcpy(&frm[24],
529 d->servicepath ? d->servicepath : "",
530 sp_len+1);
531 strlcpy(&frm[24 + sp_len + 1],
532 d->base_name ? d->base_name : "",
533 bn_len+1);
534 strlcpy(&frm[24 + sp_len + 1 + bn_len + 1],
535 d->stream_name ? d->stream_name : "",
536 sn_len+1);
537
538 /* Send the messages. */
539 for (i=0; i<d->num_share_modes; i++) {
540 struct share_mode_entry *se = &d->share_modes[i];
541 struct server_id_buf tmp;
542
543 if (!is_valid_share_mode_entry(se)) {
544 continue;
545 }
546
547 /* If this is a hardlink to the inode
548 with a different name, skip this. */
549 if (se->name_hash != orig_name_hash) {
550 continue;
551 }
552
553 se->name_hash = new_name_hash;
554
555 /* But not to ourselves... */
556 if (serverid_equal(&se->pid, &self_pid)) {
557 continue;
558 }
559
560 if (share_mode_stale_pid(d, i)) {
561 continue;
562 }
563
564 DEBUG(10,("rename_share_filename: sending rename message to "
565 "pid %s file_id %s sharepath %s base_name %s "
566 "stream_name %s\n",
567 server_id_str_buf(se->pid, &tmp),
568 file_id_string_tos(&id),
569 d->servicepath, d->base_name,
570 has_stream ? d->stream_name : ""));
571
572 messaging_send_buf(msg_ctx, se->pid, MSG_SMB_FILE_RENAME,
573 (uint8_t *)frm, msg_len);
574 }
575
576 for (i=0; i<d->num_leases; i++) {
577 /* Update the filename in leases_db. */
578 NTSTATUS status;
579 struct share_mode_lease *l;
580
581 l = &d->leases[i];
582
583 status = leases_db_rename(&l->client_guid,
584 &l->lease_key,
585 &id,
586 d->servicepath,
587 d->base_name,
588 d->stream_name);
589 if (!NT_STATUS_IS_OK(status)) {
590 /* Any error recovery possible here ? */
591 DEBUG(1,("Failed to rename lease key for "
592 "renamed file %s:%s. %s\n",
593 d->base_name,
594 d->stream_name,
595 nt_errstr(status)));
596 continue;
597 }
598 }
599
600 return True;
601 }
602
603 void get_file_infos(struct file_id id,
604 uint32_t name_hash,
605 bool *delete_on_close,
606 struct timespec *write_time)
607 {
608 struct share_mode_lock *lck;
609
610 if (delete_on_close) {
611 *delete_on_close = false;
612 }
613
614 if (write_time) {
615 ZERO_STRUCTP(write_time);
616 }
617
618 if (!(lck = fetch_share_mode_unlocked(talloc_tos(), id))) {
619 return;
620 }
621
622 if (delete_on_close) {
623 *delete_on_close = is_delete_on_close_set(lck, name_hash);
624 }
625
626 if (write_time) {
627 *write_time = get_share_mode_write_time(lck);
628 }
629
630 TALLOC_FREE(lck);
631 }
632
633 bool is_valid_share_mode_entry(const struct share_mode_entry *e)
634 {
635 int num_props = 0;
636
637 if (e->stale) {
638 return false;
639 }
640
641 num_props += ((e->op_type == NO_OPLOCK) ? 1 : 0);
642 num_props += (EXCLUSIVE_OPLOCK_TYPE(e->op_type) ? 1 : 0);
643 num_props += (LEVEL_II_OPLOCK_TYPE(e->op_type) ? 1 : 0);
644 num_props += (e->op_type == LEASE_OPLOCK);
645
646 if ((num_props > 1) && serverid_exists(&e->pid)) {
647 smb_panic("Invalid share mode entry");
648 }
649 return (num_props != 0);
650 }
651
652 /*
653 * See if we need to remove a lease being referred to by a
654 * share mode that is being marked stale or deleted.
655 */
656
657 static void remove_share_mode_lease(struct share_mode_data *d,
658 struct share_mode_entry *e)
659 {
660 struct GUID client_guid;
661 struct smb2_lease_key lease_key;
662 uint16_t op_type;
663 uint32_t lease_idx;
664 uint32_t i;
665
666 op_type = e->op_type;
667 e->op_type = NO_OPLOCK;
668
669 d->modified = true;
670
671 if (op_type != LEASE_OPLOCK) {
672 return;
673 }
674
675 /*
676 * This used to reference a lease. If there's no other one referencing
677 * it, remove it.
678 */
679
680 lease_idx = e->lease_idx;
681 e->lease_idx = UINT32_MAX;
682
683 for (i=0; i<d->num_share_modes; i++) {
684 if (d->share_modes[i].stale) {
685 continue;
686 }
687 if (e == &d->share_modes[i]) {
688 /* Not ourselves. */
689 continue;
690 }
691 if (d->share_modes[i].lease_idx == lease_idx) {
692 break;
693 }
694 }
695 if (i < d->num_share_modes) {
696 /*
697 * Found another one
698 */
699 return;
700 }
701
702 memcpy(&client_guid,
703 &d->leases[lease_idx].client_guid,
704 sizeof(client_guid));
705 lease_key = d->leases[lease_idx].lease_key;
706
707 d->num_leases -= 1;
708 d->leases[lease_idx] = d->leases[d->num_leases];
709
710 /*
711 * We changed the lease array. Fix all references to it.
712 */
713 for (i=0; i<d->num_share_modes; i++) {
714 if (d->share_modes[i].lease_idx == d->num_leases) {
715 d->share_modes[i].lease_idx = lease_idx;
716 }
717 }
718
719 {
720 NTSTATUS status;
721
722 status = leases_db_del(&client_guid,
723 &lease_key,
724 &d->id);
725
726 DEBUG(10, ("%s: leases_db_del returned %s\n", __func__,
727 nt_errstr(status)));
728 }
729 }
730
731 /*
732 * In case d->share_modes[i] conflicts with something or otherwise is
733 * being used, we need to make sure the corresponding process still
734 * exists.
735 */
736 bool share_mode_stale_pid(struct share_mode_data *d, uint32_t idx)
737 {
738 struct server_id_buf tmp;
739 struct share_mode_entry *e;
740
741 if (idx > d->num_share_modes) {
742 DBG_WARNING("Asking for index %"PRIu32", "
743 "only %"PRIu32" around\n",
744 idx,
745 d->num_share_modes);
746 return false;
747 }
748 e = &d->share_modes[idx];
749 if (e->stale) {
750 /*
751 * Checked before
752 */
753 return true;
754 }
755 if (serverid_exists(&e->pid)) {
756 DBG_DEBUG("PID %s (index %"PRIu32" out of %"PRIu32") "
757 "still exists\n",
758 server_id_str_buf(e->pid, &tmp),
759 idx,
760 d->num_share_modes);
761 return false;
762 }
763 DBG_DEBUG("PID %s (index %"PRIu32" out of %"PRIu32") "
764 "does not exist anymore\n",
765 server_id_str_buf(e->pid, &tmp),
766 idx,
767 d->num_share_modes);
768
769 e->stale = true;
770
771 if (d->num_delete_tokens != 0) {
772 uint32_t i, num_stale;
773
774 /*
775 * We cannot have any delete tokens
776 * if there are no valid share modes.
777 */
778
779 num_stale = 0;
780
781 for (i=0; i<d->num_share_modes; i++) {
782 if (d->share_modes[i].stale) {
783 num_stale += 1;
784 }
785 }
786
787 if (num_stale == d->num_share_modes) {
788 /*
789 * No non-stale share mode found
790 */
791 TALLOC_FREE(d->delete_tokens);
792 d->num_delete_tokens = 0;
793 }
794 }
795
796 remove_share_mode_lease(d, e);
797
798 d->modified = true;
799 return true;
800 }
801
802 void remove_stale_share_mode_entries(struct share_mode_data *d)
803 {
804 uint32_t i;
805
806 i = 0;
807 while (i < d->num_share_modes) {
808 if (d->share_modes[i].stale) {
809 struct share_mode_entry *m = d->share_modes;
810 m[i] = m[d->num_share_modes-1];
811 d->num_share_modes -= 1;
812 } else {
813 i += 1;
814 }
815 }
816 }
817
818 bool set_share_mode(struct share_mode_lock *lck, struct files_struct *fsp,
819 uid_t uid, uint64_t mid, uint16_t op_type,
820 uint32_t lease_idx)
821 {
822 struct share_mode_data *d = lck->data;
823 struct share_mode_entry *tmp, *e;
824
825 if ((lease_idx != UINT32_MAX) &&
826 (lease_idx >= d->num_leases)) {
827 return false;
828 }
829
830 tmp = talloc_realloc(d, d->share_modes, struct share_mode_entry,
831 d->num_share_modes+1);
832 if (tmp == NULL) {
833 return false;
834 }
835 d->share_modes = tmp;
836 e = &d->share_modes[d->num_share_modes];
837 d->num_share_modes += 1;
838 d->modified = true;
839
840 ZERO_STRUCTP(e);
841 e->pid = messaging_server_id(fsp->conn->sconn->msg_ctx);
842 e->share_access = fsp->share_access;
843 e->private_options = fsp->fh->private_options;
844 e->access_mask = fsp->access_mask;
845 e->op_mid = mid;
846 e->op_type = op_type;
847 e->lease_idx = lease_idx;
848 e->time.tv_sec = fsp->open_time.tv_sec;
849 e->time.tv_usec = fsp->open_time.tv_usec;
850 e->share_file_id = fsp->fh->gen_id;
851 e->uid = (uint32_t)uid;
852 e->flags = (fsp->posix_flags & FSP_POSIX_FLAGS_OPEN) ?
853 SHARE_MODE_FLAG_POSIX_OPEN : 0;
854 e->name_hash = fsp->name_hash;
855
856 return true;
857 }
858
859 struct share_mode_entry *find_share_mode_entry(
860 struct share_mode_lock *lck, files_struct *fsp)
861 {
862 struct share_mode_data *d = lck->data;
863 struct server_id pid;
864 uint32_t i;
865
866 pid = messaging_server_id(fsp->conn->sconn->msg_ctx);
867
868 for (i=0; i<d->num_share_modes; i++) {
869 struct share_mode_entry *e = &d->share_modes[i];
870
871 if (!is_valid_share_mode_entry(e)) {
872 continue;
873 }
874 if (!serverid_equal(&pid, &e->pid)) {
875 continue;
876 }
877 if (fsp->fh->gen_id != e->share_file_id) {
878 continue;
879 }
880 return e;
881 }
882 return NULL;
883 }
884
885 /*******************************************************************
886 Del the share mode of a file for this process. Return the number of
887 entries left.
888 ********************************************************************/
889
890 bool del_share_mode(struct share_mode_lock *lck, files_struct *fsp)
891 {
892 struct share_mode_entry *e;
893
894 e = find_share_mode_entry(lck, fsp);
895 if (e == NULL) {
896 return False;
897 }
898 remove_share_mode_lease(lck->data, e);
899 *e = lck->data->share_modes[lck->data->num_share_modes-1];
900 lck->data->num_share_modes -= 1;
901 lck->data->modified = True;
902 return True;
903 }
904
905 bool mark_share_mode_disconnected(struct share_mode_lock *lck,
906 struct files_struct *fsp)
907 {
908 struct share_mode_entry *e;
909
910 if (lck->data->num_share_modes != 1) {
911 return false;
912 }
913
914 if (fsp->op == NULL) {
915 return false;
916 }
917 if (!fsp->op->global->durable) {
918 return false;
919 }
920
921 e = find_share_mode_entry(lck, fsp);
922 if (e == NULL) {
923 return false;
924 }
925
926 DEBUG(10, ("Marking share mode entry disconnected for durable handle\n"));
927
928 server_id_set_disconnected(&e->pid);
929
930 /*
931 * On reopen the caller needs to check that
932 * the client comes with the correct handle.
933 */
934 e->share_file_id = fsp->op->global->open_persistent_id;
935
936 lck->data->modified = true;
937 return true;
938 }
939
940 /*******************************************************************
941 Remove an oplock mid and mode entry from a share mode.
942 ********************************************************************/
943
944 bool remove_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
945 {
946 struct share_mode_data *d = lck->data;
947 struct share_mode_entry *e;
948
949 e = find_share_mode_entry(lck, fsp);
950 if (e == NULL) {
951 return False;
952 }
953
954 remove_share_mode_lease(d, e);
955 d->modified = True;
956 return true;
957 }
958
959 /*******************************************************************
960 Downgrade a oplock type from exclusive to level II.
961 ********************************************************************/
962
963 bool downgrade_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
964 {
965 struct share_mode_entry *e;
966
967 e = find_share_mode_entry(lck, fsp);
968 if (e == NULL) {
969 return False;
970 }
971
972 e->op_type = LEVEL_II_OPLOCK;
973 lck->data->modified = True;
974 return True;
975 }
976
977 NTSTATUS downgrade_share_lease(struct smbd_server_connection *sconn,
978 struct share_mode_lock *lck,
979 const struct smb2_lease_key *key,
980 uint32_t new_lease_state,
981 struct share_mode_lease **_l)
982 {
983 struct share_mode_data *d = lck->data;
984 struct share_mode_lease *l;
985 uint32_t i;
986
987 *_l = NULL;
988
989 for (i=0; i<d->num_leases; i++) {
990 if (smb2_lease_equal(&sconn->client->connections->smb2.client.guid,
991 key,
992 &d->leases[i].client_guid,
993 &d->leases[i].lease_key)) {
994 break;
995 }
996 }
997 if (i == d->num_leases) {
998 DEBUG(10, ("lease not found\n"));
999 return NT_STATUS_INVALID_PARAMETER;
1000 }
1001
1002 l = &d->leases[i];
1003
1004 if (!l->breaking) {
1005 DEBUG(1, ("Attempt to break from %d to %d - but we're not in breaking state\n",
1006 (int)l->current_state, (int)new_lease_state));
1007 return NT_STATUS_UNSUCCESSFUL;
1008 }
1009
1010 /*
1011 * Can't upgrade anything: l->breaking_to_requested (and l->current_state)
1012 * must be a strict bitwise superset of new_lease_state
1013 */
1014 if ((new_lease_state & l->breaking_to_requested) != new_lease_state) {
1015 DEBUG(1, ("Attempt to upgrade from %d to %d - expected %d\n",
1016 (int)l->current_state, (int)new_lease_state,
1017 (int)l->breaking_to_requested));
1018 return NT_STATUS_REQUEST_NOT_ACCEPTED;
1019 }
1020
1021 if (l->current_state != new_lease_state) {
1022 l->current_state = new_lease_state;
1023 d->modified = true;
1024 }
1025
1026 if ((new_lease_state & ~l->breaking_to_required) != 0) {
1027 DEBUG(5, ("lease state %d not fully broken from %d to %d\n",
1028 (int)new_lease_state,
1029 (int)l->current_state,
1030 (int)l->breaking_to_required));
1031 l->breaking_to_requested = l->breaking_to_required;
1032 if (l->current_state & (~SMB2_LEASE_READ)) {
1033 /*
1034 * Here we break in steps, as windows does
1035 * see the breaking3 and v2_breaking3 tests.
1036 */
1037 l->breaking_to_requested |= SMB2_LEASE_READ;
1038 }
1039 d->modified = true;
1040 *_l = l;
1041 return NT_STATUS_OPLOCK_BREAK_IN_PROGRESS;
1042 }
1043
1044 DEBUG(10, ("breaking from %d to %d - expected %d\n",
1045 (int)l->current_state, (int)new_lease_state,
1046 (int)l->breaking_to_requested));
1047
1048 l->breaking_to_requested = 0;
1049 l->breaking_to_required = 0;
1050 l->breaking = false;
1051
1052 d->modified = true;
1053
1054 return NT_STATUS_OK;
1055 }
1056
1057 /****************************************************************************
1058 Adds a delete on close token.
1059 ****************************************************************************/
1060
1061 static bool add_delete_on_close_token(struct share_mode_data *d,
1062 uint32_t name_hash,
1063 const struct security_token *nt_tok,
1064 const struct security_unix_token *tok)
1065 {
1066 struct delete_token *tmp, *dtl;
1067
1068 tmp = talloc_realloc(d, d->delete_tokens, struct delete_token,
1069 d->num_delete_tokens+1);
1070 if (tmp == NULL) {
1071 return false;
1072 }
1073 d->delete_tokens = tmp;
1074 dtl = &d->delete_tokens[d->num_delete_tokens];
1075
1076 dtl->name_hash = name_hash;
1077 dtl->delete_nt_token = dup_nt_token(d->delete_tokens, nt_tok);
1078 if (dtl->delete_nt_token == NULL) {
1079 return false;
1080 }
1081 dtl->delete_token = copy_unix_token(d->delete_tokens, tok);
1082 if (dtl->delete_token == NULL) {
1083 return false;
1084 }
1085 d->num_delete_tokens += 1;
1086 d->modified = true;
1087 return true;
1088 }
1089
1090 void reset_delete_on_close_lck(files_struct *fsp,
1091 struct share_mode_lock *lck)
1092 {
1093 struct share_mode_data *d = lck->data;
1094 uint32_t i;
1095
1096 for (i=0; i<d->num_delete_tokens; i++) {
1097 struct delete_token *dt = &d->delete_tokens[i];
1098
1099 if (dt->name_hash == fsp->name_hash) {
1100 d->modified = true;
1101
1102 /* Delete this entry. */
1103 TALLOC_FREE(dt->delete_nt_token);
1104 TALLOC_FREE(dt->delete_token);
1105 *dt = d->delete_tokens[d->num_delete_tokens-1];
1106 d->num_delete_tokens -= 1;
1107 }
1108 }
1109 }
1110
1111 /****************************************************************************
1112 Sets the delete on close flag over all share modes on this file.
1113 Modify the share mode entry for all files open
1114 on this device and inode to tell other smbds we have
1115 changed the delete on close flag. This will be noticed
1116 in the close code, the last closer will delete the file
1117 if flag is set.
1118 This makes a copy of any struct security_unix_token into the
1119 lck entry. This function is used when the lock is already granted.
1120 ****************************************************************************/
1121
1122 void set_delete_on_close_lck(files_struct *fsp,
1123 struct share_mode_lock *lck,
1124 const struct security_token *nt_tok,
1125 const struct security_unix_token *tok)
1126 {
1127 struct messaging_context *msg_ctx = fsp->conn->sconn->msg_ctx;
1128 struct share_mode_data *d = lck->data;
1129 uint32_t i;
1130 bool ret;
1131 DATA_BLOB fid_blob = {};
1132 enum ndr_err_code ndr_err;
1133
1134 SMB_ASSERT(nt_tok != NULL);
1135 SMB_ASSERT(tok != NULL);
1136
1137 for (i=0; i<d->num_delete_tokens; i++) {
1138 struct delete_token *dt = &d->delete_tokens[i];
1139 if (dt->name_hash == fsp->name_hash) {
1140 d->modified = true;
1141
1142 /* Replace this token with the given tok. */
1143 TALLOC_FREE(dt->delete_nt_token);
1144 dt->delete_nt_token = dup_nt_token(dt, nt_tok);
1145 SMB_ASSERT(dt->delete_nt_token != NULL);
1146 TALLOC_FREE(dt->delete_token);
1147 dt->delete_token = copy_unix_token(dt, tok);
1148 SMB_ASSERT(dt->delete_token != NULL);
1149
1150 return;
1151 }
1152 }
1153
1154 ret = add_delete_on_close_token(lck->data, fsp->name_hash, nt_tok, tok);
1155 SMB_ASSERT(ret);
1156
1157 ndr_err = ndr_push_struct_blob(&fid_blob, talloc_tos(), &fsp->file_id,
1158 (ndr_push_flags_fn_t)ndr_push_file_id);
1159 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1160 DEBUG(10, ("ndr_push_file_id failed: %s\n",
1161 ndr_errstr(ndr_err)));
1162 }
1163
1164 for (i=0; i<d->num_share_modes; i++) {
1165 struct share_mode_entry *e = &d->share_modes[i];
1166 NTSTATUS status;
1167
1168 status = messaging_send(
1169 msg_ctx, e->pid, MSG_SMB_NOTIFY_CANCEL_DELETED,
1170 &fid_blob);
1171
1172 if (!NT_STATUS_IS_OK(status)) {
1173 struct server_id_buf tmp;
1174 DEBUG(10, ("%s: messaging_send to %s returned %s\n",
1175 __func__, server_id_str_buf(e->pid, &tmp),
1176 nt_errstr(status)));
1177 }
1178 }
1179
1180 TALLOC_FREE(fid_blob.data);
1181 }
1182
1183 bool set_delete_on_close(files_struct *fsp, bool delete_on_close,
1184 const struct security_token *nt_tok,
1185 const struct security_unix_token *tok)
1186 {
1187 struct share_mode_lock *lck;
1188
1189 DEBUG(10,("set_delete_on_close: %s delete on close flag for "
1190 "%s, file %s\n",
1191 delete_on_close ? "Adding" : "Removing", fsp_fnum_dbg(fsp),
1192 fsp_str_dbg(fsp)));
1193
1194 lck = get_existing_share_mode_lock(talloc_tos(), fsp->file_id);
1195 if (lck == NULL) {
1196 return False;
1197 }
1198
1199 if (delete_on_close) {
1200 set_delete_on_close_lck(fsp, lck, nt_tok, tok);
1201 } else {
1202 reset_delete_on_close_lck(fsp, lck);
1203 }
1204
1205 if (fsp->is_directory) {
1206 SMB_ASSERT(!is_ntfs_stream_smb_fname(fsp->fsp_name));
1207 send_stat_cache_delete_message(fsp->conn->sconn->msg_ctx,
1208 fsp->fsp_name->base_name);
1209 }
1210
1211 TALLOC_FREE(lck);
1212
1213 fsp->delete_on_close = delete_on_close;
1214
1215 return True;
1216 }
1217
1218 static struct delete_token *find_delete_on_close_token(
1219 struct share_mode_data *d, uint32_t name_hash)
1220 {
1221 uint32_t i;
1222
1223 DEBUG(10, ("find_delete_on_close_token: name_hash = 0x%x\n",
1224 (unsigned int)name_hash));
1225
1226 for (i=0; i<d->num_delete_tokens; i++) {
1227 struct delete_token *dt = &d->delete_tokens[i];
1228
1229 DEBUG(10, ("find__delete_on_close_token: dt->name_hash = 0x%x\n",
1230 (unsigned int)dt->name_hash ));
1231 if (dt->name_hash == name_hash) {
1232 return dt;
1233 }
1234 }
1235 return NULL;
1236 }
1237
1238 /****************************************************************************
1239 Return the NT token and UNIX token if there's a match. Return true if
1240 found, false if not.
1241 ****************************************************************************/
1242
1243 bool get_delete_on_close_token(struct share_mode_lock *lck,
1244 uint32_t name_hash,
1245 const struct security_token **pp_nt_tok,
1246 const struct security_unix_token **pp_tok)
1247 {
1248 struct delete_token *dt;
1249
1250 dt = find_delete_on_close_token(lck->data, name_hash);
1251 if (dt == NULL) {
1252 return false;
1253 }
1254 *pp_nt_tok = dt->delete_nt_token;
1255 *pp_tok = dt->delete_token;
1256 return true;
1257 }
1258
1259 bool is_delete_on_close_set(struct share_mode_lock *lck, uint32_t name_hash)
1260 {
1261 return find_delete_on_close_token(lck->data, name_hash) != NULL;
1262 }
1263
1264 bool set_sticky_write_time(struct file_id fileid, struct timespec write_time)
1265 {
1266 struct share_mode_lock *lck;
1267
1268 DEBUG(5,("set_sticky_write_time: %s id=%s\n",
1269 timestring(talloc_tos(),
1270 convert_timespec_to_time_t(write_time)),
1271 file_id_string_tos(&fileid)));
1272
1273 lck = get_existing_share_mode_lock(talloc_tos(), fileid);
1274 if (lck == NULL) {
1275 return False;
1276 }
1277
1278 if (timespec_compare(&lck->data->changed_write_time, &write_time) != 0) {
1279 lck->data->modified = True;
1280 lck->data->changed_write_time = write_time;
1281 }
1282
1283 TALLOC_FREE(lck);
1284 return True;
1285 }
1286
1287 bool set_write_time(struct file_id fileid, struct timespec write_time)
1288 {
1289 struct share_mode_lock *lck;
1290
1291 DEBUG(5,("set_write_time: %s id=%s\n",
1292 timestring(talloc_tos(),
1293 convert_timespec_to_time_t(write_time)),
1294 file_id_string_tos(&fileid)));
1295
1296 lck = get_existing_share_mode_lock(talloc_tos(), fileid);
1297 if (lck == NULL) {
1298 return False;
1299 }
1300
1301 if (timespec_compare(&lck->data->old_write_time, &write_time) != 0) {
1302 lck->data->modified = True;
1303 lck->data->old_write_time = write_time;
1304 }
1305
1306 TALLOC_FREE(lck);
1307 return True;
1308 }
1309
1310 struct timespec get_share_mode_write_time(struct share_mode_lock *lck)
1311 {
1312 struct share_mode_data *d = lck->data;
1313
1314 if (!null_timespec(d->changed_write_time)) {
1315 return d->changed_write_time;
1316 }
1317 return d->old_write_time;
1318 }
1319
1320 bool file_has_open_streams(files_struct *fsp)
1321 {
1322 struct share_mode_lock *lock = NULL;
1323 struct share_mode_data *d = NULL;
1324 uint32_t i;
1325
1326 lock = get_existing_share_mode_lock(talloc_tos(), fsp->file_id);
1327 if (lock == NULL) {
1328 return false;
1329 }
1330 d = lock->data;
1331
1332 for (i = 0; i < d->num_share_modes; i++) {
1333 struct share_mode_entry *e = &d->share_modes[i];
1334
1335 if (share_mode_stale_pid(d, i)) {
1336 continue;
1337 }
1338
1339 if (e->private_options &
1340 NTCREATEX_OPTIONS_PRIVATE_STREAM_BASEOPEN)
1341 {
1342 TALLOC_FREE(lock);
1343 return true;
1344 }
1345 }
1346
1347 TALLOC_FREE(lock);
1348 return false;
1349 }
Samba GIT mirror