?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
smbd: Use "share_mode_data->id", not "share_mode_entry->id"
[Samba.git] / source3 / locking / locking.c
blob2b5c7c7885ffc4895b0bc56e936a4396e0b16ede
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 d->share_modes[i].lease = &d->leases[lease_idx];
717 }
718 }
719
720 {
721 NTSTATUS status;
722
723 status = leases_db_del(&client_guid,
724 &lease_key,
725 &d->id);
726
727 DEBUG(10, ("%s: leases_db_del returned %s\n", __func__,
728 nt_errstr(status)));
729 }
730 }
731
732 /*
733 * In case d->share_modes[i] conflicts with something or otherwise is
734 * being used, we need to make sure the corresponding process still
735 * exists.
736 */
737 bool share_mode_stale_pid(struct share_mode_data *d, uint32_t idx)
738 {
739 struct server_id_buf tmp;
740 struct share_mode_entry *e;
741
742 if (idx > d->num_share_modes) {
743 DEBUG(1, ("Asking for index %u, only %u around\n",
744 idx, (unsigned)d->num_share_modes));
745 return false;
746 }
747 e = &d->share_modes[idx];
748 if (e->stale) {
749 /*
750 * Checked before
751 */
752 return true;
753 }
754 if (serverid_exists(&e->pid)) {
755 DEBUG(10, ("PID %s (index %u out of %u) still exists\n",
756 server_id_str_buf(e->pid, &tmp), idx,
757 (unsigned)d->num_share_modes));
758 return false;
759 }
760 DEBUG(10, ("PID %s (index %u out of %u) does not exist anymore\n",
761 server_id_str_buf(e->pid, &tmp), idx,
762 (unsigned)d->num_share_modes));
763
764 e->stale = true;
765
766 if (d->num_delete_tokens != 0) {
767 uint32_t i, num_stale;
768
769 /*
770 * We cannot have any delete tokens
771 * if there are no valid share modes.
772 */
773
774 num_stale = 0;
775
776 for (i=0; i<d->num_share_modes; i++) {
777 if (d->share_modes[i].stale) {
778 num_stale += 1;
779 }
780 }
781
782 if (num_stale == d->num_share_modes) {
783 /*
784 * No non-stale share mode found
785 */
786 TALLOC_FREE(d->delete_tokens);
787 d->num_delete_tokens = 0;
788 }
789 }
790
791 remove_share_mode_lease(d, e);
792
793 d->modified = true;
794 return true;
795 }
796
797 void remove_stale_share_mode_entries(struct share_mode_data *d)
798 {
799 uint32_t i;
800
801 i = 0;
802 while (i < d->num_share_modes) {
803 if (d->share_modes[i].stale) {
804 struct share_mode_entry *m = d->share_modes;
805 m[i] = m[d->num_share_modes-1];
806 d->num_share_modes -= 1;
807 } else {
808 i += 1;
809 }
810 }
811 }
812
813 bool set_share_mode(struct share_mode_lock *lck, struct files_struct *fsp,
814 uid_t uid, uint64_t mid, uint16_t op_type,
815 uint32_t lease_idx)
816 {
817 struct share_mode_data *d = lck->data;
818 struct share_mode_entry *tmp, *e;
819 struct share_mode_lease *lease = NULL;
820
821 if (lease_idx == UINT32_MAX) {
822 lease = NULL;
823 } else if (lease_idx >= d->num_leases) {
824 return false;
825 } else {
826 lease = &d->leases[lease_idx];
827 }
828
829 tmp = talloc_realloc(d, d->share_modes, struct share_mode_entry,
830 d->num_share_modes+1);
831 if (tmp == NULL) {
832 return false;
833 }
834 d->share_modes = tmp;
835 e = &d->share_modes[d->num_share_modes];
836 d->num_share_modes += 1;
837 d->modified = true;
838
839 ZERO_STRUCTP(e);
840 e->pid = messaging_server_id(fsp->conn->sconn->msg_ctx);
841 e->share_access = fsp->share_access;
842 e->private_options = fsp->fh->private_options;
843 e->access_mask = fsp->access_mask;
844 e->op_mid = mid;
845 e->op_type = op_type;
846 e->lease_idx = lease_idx;
847 e->lease = lease;
848 e->time.tv_sec = fsp->open_time.tv_sec;
849 e->time.tv_usec = fsp->open_time.tv_usec;
850 e->id = fsp->file_id;
851 e->share_file_id = fsp->fh->gen_id;
852 e->uid = (uint32_t)uid;
853 e->flags = (fsp->posix_flags & FSP_POSIX_FLAGS_OPEN) ?
854 SHARE_MODE_FLAG_POSIX_OPEN : 0;
855 e->name_hash = fsp->name_hash;
856
857 return true;
858 }
859
860 struct share_mode_entry *find_share_mode_entry(
861 struct share_mode_lock *lck, files_struct *fsp)
862 {
863 struct share_mode_data *d = lck->data;
864 struct server_id pid;
865 uint32_t i;
866
867 pid = messaging_server_id(fsp->conn->sconn->msg_ctx);
868
869 for (i=0; i<d->num_share_modes; i++) {
870 struct share_mode_entry *e = &d->share_modes[i];
871
872 if (!is_valid_share_mode_entry(e)) {
873 continue;
874 }
875 if (!serverid_equal(&pid, &e->pid)) {
876 continue;
877 }
878 if (!file_id_equal(&fsp->file_id, &e->id)) {
879 continue;
880 }
881 if (fsp->fh->gen_id != e->share_file_id) {
882 continue;
883 }
884 return e;
885 }
886 return NULL;
887 }
888
889 /*******************************************************************
890 Del the share mode of a file for this process. Return the number of
891 entries left.
892 ********************************************************************/
893
894 bool del_share_mode(struct share_mode_lock *lck, files_struct *fsp)
895 {
896 struct share_mode_entry *e;
897
898 e = find_share_mode_entry(lck, fsp);
899 if (e == NULL) {
900 return False;
901 }
902 remove_share_mode_lease(lck->data, e);
903 *e = lck->data->share_modes[lck->data->num_share_modes-1];
904 lck->data->num_share_modes -= 1;
905 lck->data->modified = True;
906 return True;
907 }
908
909 bool mark_share_mode_disconnected(struct share_mode_lock *lck,
910 struct files_struct *fsp)
911 {
912 struct share_mode_entry *e;
913
914 if (lck->data->num_share_modes != 1) {
915 return false;
916 }
917
918 if (fsp->op == NULL) {
919 return false;
920 }
921 if (!fsp->op->global->durable) {
922 return false;
923 }
924
925 e = find_share_mode_entry(lck, fsp);
926 if (e == NULL) {
927 return false;
928 }
929
930 DEBUG(10, ("Marking share mode entry disconnected for durable handle\n"));
931
932 server_id_set_disconnected(&e->pid);
933
934 /*
935 * On reopen the caller needs to check that
936 * the client comes with the correct handle.
937 */
938 e->share_file_id = fsp->op->global->open_persistent_id;
939
940 lck->data->modified = true;
941 return true;
942 }
943
944 /*******************************************************************
945 Remove an oplock mid and mode entry from a share mode.
946 ********************************************************************/
947
948 bool remove_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
949 {
950 struct share_mode_data *d = lck->data;
951 struct share_mode_entry *e;
952
953 e = find_share_mode_entry(lck, fsp);
954 if (e == NULL) {
955 return False;
956 }
957
958 remove_share_mode_lease(d, e);
959 d->modified = True;
960 return true;
961 }
962
963 /*******************************************************************
964 Downgrade a oplock type from exclusive to level II.
965 ********************************************************************/
966
967 bool downgrade_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
968 {
969 struct share_mode_entry *e;
970
971 e = find_share_mode_entry(lck, fsp);
972 if (e == NULL) {
973 return False;
974 }
975
976 e->op_type = LEVEL_II_OPLOCK;
977 lck->data->modified = True;
978 return True;
979 }
980
981 NTSTATUS downgrade_share_lease(struct smbd_server_connection *sconn,
982 struct share_mode_lock *lck,
983 const struct smb2_lease_key *key,
984 uint32_t new_lease_state,
985 struct share_mode_lease **_l)
986 {
987 struct share_mode_data *d = lck->data;
988 struct share_mode_lease *l;
989 uint32_t i;
990
991 *_l = NULL;
992
993 for (i=0; i<d->num_leases; i++) {
994 if (smb2_lease_equal(&sconn->client->connections->smb2.client.guid,
995 key,
996 &d->leases[i].client_guid,
997 &d->leases[i].lease_key)) {
998 break;
999 }
1000 }
1001 if (i == d->num_leases) {
1002 DEBUG(10, ("lease not found\n"));
1003 return NT_STATUS_INVALID_PARAMETER;
1004 }
1005
1006 l = &d->leases[i];
1007
1008 if (!l->breaking) {
1009 DEBUG(1, ("Attempt to break from %d to %d - but we're not in breaking state\n",
1010 (int)l->current_state, (int)new_lease_state));
1011 return NT_STATUS_UNSUCCESSFUL;
1012 }
1013
1014 /*
1015 * Can't upgrade anything: l->breaking_to_requested (and l->current_state)
1016 * must be a strict bitwise superset of new_lease_state
1017 */
1018 if ((new_lease_state & l->breaking_to_requested) != new_lease_state) {
1019 DEBUG(1, ("Attempt to upgrade from %d to %d - expected %d\n",
1020 (int)l->current_state, (int)new_lease_state,
1021 (int)l->breaking_to_requested));
1022 return NT_STATUS_REQUEST_NOT_ACCEPTED;
1023 }
1024
1025 if (l->current_state != new_lease_state) {
1026 l->current_state = new_lease_state;
1027 d->modified = true;
1028 }
1029
1030 if ((new_lease_state & ~l->breaking_to_required) != 0) {
1031 DEBUG(5, ("lease state %d not fully broken from %d to %d\n",
1032 (int)new_lease_state,
1033 (int)l->current_state,
1034 (int)l->breaking_to_required));
1035 l->breaking_to_requested = l->breaking_to_required;
1036 if (l->current_state & (~SMB2_LEASE_READ)) {
1037 /*
1038 * Here we break in steps, as windows does
1039 * see the breaking3 and v2_breaking3 tests.
1040 */
1041 l->breaking_to_requested |= SMB2_LEASE_READ;
1042 }
1043 d->modified = true;
1044 *_l = l;
1045 return NT_STATUS_OPLOCK_BREAK_IN_PROGRESS;
1046 }
1047
1048 DEBUG(10, ("breaking from %d to %d - expected %d\n",
1049 (int)l->current_state, (int)new_lease_state,
1050 (int)l->breaking_to_requested));
1051
1052 l->breaking_to_requested = 0;
1053 l->breaking_to_required = 0;
1054 l->breaking = false;
1055
1056 d->modified = true;
1057
1058 return NT_STATUS_OK;
1059 }
1060
1061 /****************************************************************************
1062 Adds a delete on close token.
1063 ****************************************************************************/
1064
1065 static bool add_delete_on_close_token(struct share_mode_data *d,
1066 uint32_t name_hash,
1067 const struct security_token *nt_tok,
1068 const struct security_unix_token *tok)
1069 {
1070 struct delete_token *tmp, *dtl;
1071
1072 tmp = talloc_realloc(d, d->delete_tokens, struct delete_token,
1073 d->num_delete_tokens+1);
1074 if (tmp == NULL) {
1075 return false;
1076 }
1077 d->delete_tokens = tmp;
1078 dtl = &d->delete_tokens[d->num_delete_tokens];
1079
1080 dtl->name_hash = name_hash;
1081 dtl->delete_nt_token = dup_nt_token(d->delete_tokens, nt_tok);
1082 if (dtl->delete_nt_token == NULL) {
1083 return false;
1084 }
1085 dtl->delete_token = copy_unix_token(d->delete_tokens, tok);
1086 if (dtl->delete_token == NULL) {
1087 return false;
1088 }
1089 d->num_delete_tokens += 1;
1090 d->modified = true;
1091 return true;
1092 }
1093
1094 void reset_delete_on_close_lck(files_struct *fsp,
1095 struct share_mode_lock *lck)
1096 {
1097 struct share_mode_data *d = lck->data;
1098 uint32_t i;
1099
1100 for (i=0; i<d->num_delete_tokens; i++) {
1101 struct delete_token *dt = &d->delete_tokens[i];
1102
1103 if (dt->name_hash == fsp->name_hash) {
1104 d->modified = true;
1105
1106 /* Delete this entry. */
1107 TALLOC_FREE(dt->delete_nt_token);
1108 TALLOC_FREE(dt->delete_token);
1109 *dt = d->delete_tokens[d->num_delete_tokens-1];
1110 d->num_delete_tokens -= 1;
1111 }
1112 }
1113 }
1114
1115 /****************************************************************************
1116 Sets the delete on close flag over all share modes on this file.
1117 Modify the share mode entry for all files open
1118 on this device and inode to tell other smbds we have
1119 changed the delete on close flag. This will be noticed
1120 in the close code, the last closer will delete the file
1121 if flag is set.
1122 This makes a copy of any struct security_unix_token into the
1123 lck entry. This function is used when the lock is already granted.
1124 ****************************************************************************/
1125
1126 void set_delete_on_close_lck(files_struct *fsp,
1127 struct share_mode_lock *lck,
1128 const struct security_token *nt_tok,
1129 const struct security_unix_token *tok)
1130 {
1131 struct messaging_context *msg_ctx = fsp->conn->sconn->msg_ctx;
1132 struct share_mode_data *d = lck->data;
1133 uint32_t i;
1134 bool ret;
1135 DATA_BLOB fid_blob = {};
1136 enum ndr_err_code ndr_err;
1137
1138 SMB_ASSERT(nt_tok != NULL);
1139 SMB_ASSERT(tok != NULL);
1140
1141 for (i=0; i<d->num_delete_tokens; i++) {
1142 struct delete_token *dt = &d->delete_tokens[i];
1143 if (dt->name_hash == fsp->name_hash) {
1144 d->modified = true;
1145
1146 /* Replace this token with the given tok. */
1147 TALLOC_FREE(dt->delete_nt_token);
1148 dt->delete_nt_token = dup_nt_token(dt, nt_tok);
1149 SMB_ASSERT(dt->delete_nt_token != NULL);
1150 TALLOC_FREE(dt->delete_token);
1151 dt->delete_token = copy_unix_token(dt, tok);
1152 SMB_ASSERT(dt->delete_token != NULL);
1153
1154 return;
1155 }
1156 }
1157
1158 ret = add_delete_on_close_token(lck->data, fsp->name_hash, nt_tok, tok);
1159 SMB_ASSERT(ret);
1160
1161 ndr_err = ndr_push_struct_blob(&fid_blob, talloc_tos(), &fsp->file_id,
1162 (ndr_push_flags_fn_t)ndr_push_file_id);
1163 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1164 DEBUG(10, ("ndr_push_file_id failed: %s\n",
1165 ndr_errstr(ndr_err)));
1166 }
1167
1168 for (i=0; i<d->num_share_modes; i++) {
1169 struct share_mode_entry *e = &d->share_modes[i];
1170 NTSTATUS status;
1171
1172 status = messaging_send(
1173 msg_ctx, e->pid, MSG_SMB_NOTIFY_CANCEL_DELETED,
1174 &fid_blob);
1175
1176 if (!NT_STATUS_IS_OK(status)) {
1177 struct server_id_buf tmp;
1178 DEBUG(10, ("%s: messaging_send to %s returned %s\n",
1179 __func__, server_id_str_buf(e->pid, &tmp),
1180 nt_errstr(status)));
1181 }
1182 }
1183
1184 TALLOC_FREE(fid_blob.data);
1185 }
1186
1187 bool set_delete_on_close(files_struct *fsp, bool delete_on_close,
1188 const struct security_token *nt_tok,
1189 const struct security_unix_token *tok)
1190 {
1191 struct share_mode_lock *lck;
1192
1193 DEBUG(10,("set_delete_on_close: %s delete on close flag for "
1194 "%s, file %s\n",
1195 delete_on_close ? "Adding" : "Removing", fsp_fnum_dbg(fsp),
1196 fsp_str_dbg(fsp)));
1197
1198 lck = get_existing_share_mode_lock(talloc_tos(), fsp->file_id);
1199 if (lck == NULL) {
1200 return False;
1201 }
1202
1203 if (delete_on_close) {
1204 set_delete_on_close_lck(fsp, lck, nt_tok, tok);
1205 } else {
1206 reset_delete_on_close_lck(fsp, lck);
1207 }
1208
1209 if (fsp->is_directory) {
1210 SMB_ASSERT(!is_ntfs_stream_smb_fname(fsp->fsp_name));
1211 send_stat_cache_delete_message(fsp->conn->sconn->msg_ctx,
1212 fsp->fsp_name->base_name);
1213 }
1214
1215 TALLOC_FREE(lck);
1216
1217 fsp->delete_on_close = delete_on_close;
1218
1219 return True;
1220 }
1221
1222 static struct delete_token *find_delete_on_close_token(
1223 struct share_mode_data *d, uint32_t name_hash)
1224 {
1225 uint32_t i;
1226
1227 DEBUG(10, ("find_delete_on_close_token: name_hash = 0x%x\n",
1228 (unsigned int)name_hash));
1229
1230 for (i=0; i<d->num_delete_tokens; i++) {
1231 struct delete_token *dt = &d->delete_tokens[i];
1232
1233 DEBUG(10, ("find__delete_on_close_token: dt->name_hash = 0x%x\n",
1234 (unsigned int)dt->name_hash ));
1235 if (dt->name_hash == name_hash) {
1236 return dt;
1237 }
1238 }
1239 return NULL;
1240 }
1241
1242 /****************************************************************************
1243 Return the NT token and UNIX token if there's a match. Return true if
1244 found, false if not.
1245 ****************************************************************************/
1246
1247 bool get_delete_on_close_token(struct share_mode_lock *lck,
1248 uint32_t name_hash,
1249 const struct security_token **pp_nt_tok,
1250 const struct security_unix_token **pp_tok)
1251 {
1252 struct delete_token *dt;
1253
1254 dt = find_delete_on_close_token(lck->data, name_hash);
1255 if (dt == NULL) {
1256 return false;
1257 }
1258 *pp_nt_tok = dt->delete_nt_token;
1259 *pp_tok = dt->delete_token;
1260 return true;
1261 }
1262
1263 bool is_delete_on_close_set(struct share_mode_lock *lck, uint32_t name_hash)
1264 {
1265 return find_delete_on_close_token(lck->data, name_hash) != NULL;
1266 }
1267
1268 bool set_sticky_write_time(struct file_id fileid, struct timespec write_time)
1269 {
1270 struct share_mode_lock *lck;
1271
1272 DEBUG(5,("set_sticky_write_time: %s id=%s\n",
1273 timestring(talloc_tos(),
1274 convert_timespec_to_time_t(write_time)),
1275 file_id_string_tos(&fileid)));
1276
1277 lck = get_existing_share_mode_lock(talloc_tos(), fileid);
1278 if (lck == NULL) {
1279 return False;
1280 }
1281
1282 if (timespec_compare(&lck->data->changed_write_time, &write_time) != 0) {
1283 lck->data->modified = True;
1284 lck->data->changed_write_time = write_time;
1285 }
1286
1287 TALLOC_FREE(lck);
1288 return True;
1289 }
1290
1291 bool set_write_time(struct file_id fileid, struct timespec write_time)
1292 {
1293 struct share_mode_lock *lck;
1294
1295 DEBUG(5,("set_write_time: %s id=%s\n",
1296 timestring(talloc_tos(),
1297 convert_timespec_to_time_t(write_time)),
1298 file_id_string_tos(&fileid)));
1299
1300 lck = get_existing_share_mode_lock(talloc_tos(), fileid);
1301 if (lck == NULL) {
1302 return False;
1303 }
1304
1305 if (timespec_compare(&lck->data->old_write_time, &write_time) != 0) {
1306 lck->data->modified = True;
1307 lck->data->old_write_time = write_time;
1308 }
1309
1310 TALLOC_FREE(lck);
1311 return True;
1312 }
1313
1314 struct timespec get_share_mode_write_time(struct share_mode_lock *lck)
1315 {
1316 struct share_mode_data *d = lck->data;
1317
1318 if (!null_timespec(d->changed_write_time)) {
1319 return d->changed_write_time;
1320 }
1321 return d->old_write_time;
1322 }
Samba GIT mirror