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