?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Convert uint64 to uint64_t
[Samba.git] / source3 / locking / locking.c
blob7b8bc8425fa9557d81ee3e119b239391753db3c8
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 if (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type) &&
122 (plock->lock_type == READ_LOCK ||
123 plock->lock_type == WRITE_LOCK)) {
124 DEBUG(10, ("is_locked: optimisation - exclusive oplock "
125 "on file %s\n", fsp_str_dbg(fsp)));
126 return true;
127 }
128 if ((fsp->oplock_type == LEVEL_II_OPLOCK) &&
129 (plock->lock_type == READ_LOCK)) {
130 DEBUG(10, ("is_locked: optimisation - level II oplock "
131 "on file %s\n", fsp_str_dbg(fsp)));
132 return true;
133 }
134 }
135
136 br_lck = brl_get_locks_readonly(fsp);
137 if (!br_lck) {
138 return true;
139 }
140 ret = brl_locktest(br_lck, plock);
141
142 if (!ret) {
143 /*
144 * We got a lock conflict. Retry with rw locks to enable
145 * autocleanup. This is the slow path anyway.
146 */
147 br_lck = brl_get_locks(talloc_tos(), fsp);
148 ret = brl_locktest(br_lck, plock);
149 TALLOC_FREE(br_lck);
150 }
151
152 DEBUG(10, ("strict_lock_default: flavour = %s brl start=%ju "
153 "len=%ju %s for fnum %ju file %s\n",
154 lock_flav_name(plock->lock_flav),
155 (uintmax_t)plock->start, (uintmax_t)plock->size,
156 ret ? "unlocked" : "locked",
157 (uintmax_t)plock->fnum, fsp_str_dbg(fsp)));
158
159 return ret;
160 }
161
162 void strict_unlock_default(files_struct *fsp, struct lock_struct *plock)
163 {
164 }
165
166 /****************************************************************************
167 Find out if a lock could be granted - return who is blocking us if we can't.
168 ****************************************************************************/
169
170 NTSTATUS query_lock(files_struct *fsp,
171 uint64_t *psmblctx,
172 uint64_t *pcount,
173 uint64_t *poffset,
174 enum brl_type *plock_type,
175 enum brl_flavour lock_flav)
176 {
177 struct byte_range_lock *br_lck = NULL;
178
179 if (!fsp->can_lock) {
180 return fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
181 }
182
183 if (!lp_locking(fsp->conn->params)) {
184 return NT_STATUS_OK;
185 }
186
187 br_lck = brl_get_locks_readonly(fsp);
188 if (!br_lck) {
189 return NT_STATUS_NO_MEMORY;
190 }
191
192 return brl_lockquery(br_lck,
193 psmblctx,
194 messaging_server_id(fsp->conn->sconn->msg_ctx),
195 poffset,
196 pcount,
197 plock_type,
198 lock_flav);
199 }
200
201 static void increment_current_lock_count(files_struct *fsp,
202 enum brl_flavour lock_flav)
203 {
204 if (lock_flav == WINDOWS_LOCK &&
205 fsp->current_lock_count != NO_LOCKING_COUNT) {
206 /* blocking ie. pending, locks also count here,
207 * as this is an efficiency counter to avoid checking
208 * the lock db. on close. JRA. */
209
210 fsp->current_lock_count++;
211 } else {
212 /* Notice that this has had a POSIX lock request.
213 * We can't count locks after this so forget them.
214 */
215 fsp->current_lock_count = NO_LOCKING_COUNT;
216 }
217 }
218
219 static void decrement_current_lock_count(files_struct *fsp,
220 enum brl_flavour lock_flav)
221 {
222 if (lock_flav == WINDOWS_LOCK &&
223 fsp->current_lock_count != NO_LOCKING_COUNT) {
224 SMB_ASSERT(fsp->current_lock_count > 0);
225 fsp->current_lock_count--;
226 }
227 }
228
229 /****************************************************************************
230 Utility function called by locking requests.
231 ****************************************************************************/
232
233 struct byte_range_lock *do_lock(struct messaging_context *msg_ctx,
234 files_struct *fsp,
235 uint64_t smblctx,
236 uint64_t count,
237 uint64_t offset,
238 enum brl_type lock_type,
239 enum brl_flavour lock_flav,
240 bool blocking_lock,
241 NTSTATUS *perr,
242 uint64_t *psmblctx)
243 {
244 struct byte_range_lock *br_lck = NULL;
245
246 /* silently return ok on print files as we don't do locking there */
247 if (fsp->print_file) {
248 *perr = NT_STATUS_OK;
249 return NULL;
250 }
251
252 if (!fsp->can_lock) {
253 *perr = fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
254 return NULL;
255 }
256
257 if (!lp_locking(fsp->conn->params)) {
258 *perr = NT_STATUS_OK;
259 return NULL;
260 }
261
262 /* NOTE! 0 byte long ranges ARE allowed and should be stored */
263
264 DEBUG(10,("do_lock: lock flavour %s lock type %s start=%ju len=%ju "
265 "blocking_lock=%s requested for %s file %s\n",
266 lock_flav_name(lock_flav), lock_type_name(lock_type),
267 (uintmax_t)offset, (uintmax_t)count, blocking_lock ? "true" :
268 "false", fsp_fnum_dbg(fsp), fsp_str_dbg(fsp)));
269
270 br_lck = brl_get_locks(talloc_tos(), fsp);
271 if (!br_lck) {
272 *perr = NT_STATUS_NO_MEMORY;
273 return NULL;
274 }
275
276 *perr = brl_lock(msg_ctx,
277 br_lck,
278 smblctx,
279 messaging_server_id(fsp->conn->sconn->msg_ctx),
280 offset,
281 count,
282 lock_type,
283 lock_flav,
284 blocking_lock,
285 psmblctx);
286
287 DEBUG(10, ("do_lock: returning status=%s\n", nt_errstr(*perr)));
288
289 increment_current_lock_count(fsp, lock_flav);
290 return br_lck;
291 }
292
293 /****************************************************************************
294 Utility function called by unlocking requests.
295 ****************************************************************************/
296
297 NTSTATUS do_unlock(struct messaging_context *msg_ctx,
298 files_struct *fsp,
299 uint64_t smblctx,
300 uint64_t count,
301 uint64_t offset,
302 enum brl_flavour lock_flav)
303 {
304 bool ok = False;
305 struct byte_range_lock *br_lck = NULL;
306
307 if (!fsp->can_lock) {
308 return fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
309 }
310
311 if (!lp_locking(fsp->conn->params)) {
312 return NT_STATUS_OK;
313 }
314
315 DEBUG(10, ("do_unlock: unlock start=%ju len=%ju requested for %s file "
316 "%s\n", (uintmax_t)offset, (uintmax_t)count,
317 fsp_fnum_dbg(fsp), fsp_str_dbg(fsp)));
318
319 br_lck = brl_get_locks(talloc_tos(), fsp);
320 if (!br_lck) {
321 return NT_STATUS_NO_MEMORY;
322 }
323
324 ok = brl_unlock(msg_ctx,
325 br_lck,
326 smblctx,
327 messaging_server_id(fsp->conn->sconn->msg_ctx),
328 offset,
329 count,
330 lock_flav);
331
332 TALLOC_FREE(br_lck);
333
334 if (!ok) {
335 DEBUG(10,("do_unlock: returning ERRlock.\n" ));
336 return NT_STATUS_RANGE_NOT_LOCKED;
337 }
338
339 decrement_current_lock_count(fsp, lock_flav);
340 return NT_STATUS_OK;
341 }
342
343 /****************************************************************************
344 Cancel any pending blocked locks.
345 ****************************************************************************/
346
347 NTSTATUS do_lock_cancel(files_struct *fsp,
348 uint64_t smblctx,
349 uint64_t count,
350 uint64_t offset,
351 enum brl_flavour lock_flav)
352 {
353 bool ok = False;
354 struct byte_range_lock *br_lck = NULL;
355
356 if (!fsp->can_lock) {
357 return fsp->is_directory ?
358 NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
359 }
360
361 if (!lp_locking(fsp->conn->params)) {
362 return NT_STATUS_DOS(ERRDOS, ERRcancelviolation);
363 }
364
365 DEBUG(10, ("do_lock_cancel: cancel start=%ju len=%ju requested for "
366 "%s file %s\n", (uintmax_t)offset, (uintmax_t)count,
367 fsp_fnum_dbg(fsp), fsp_str_dbg(fsp)));
368
369 br_lck = brl_get_locks(talloc_tos(), fsp);
370 if (!br_lck) {
371 return NT_STATUS_NO_MEMORY;
372 }
373
374 ok = brl_lock_cancel(br_lck,
375 smblctx,
376 messaging_server_id(fsp->conn->sconn->msg_ctx),
377 offset,
378 count,
379 lock_flav);
380
381 TALLOC_FREE(br_lck);
382
383 if (!ok) {
384 DEBUG(10,("do_lock_cancel: returning ERRcancelviolation.\n" ));
385 return NT_STATUS_DOS(ERRDOS, ERRcancelviolation);
386 }
387
388 decrement_current_lock_count(fsp, lock_flav);
389 return NT_STATUS_OK;
390 }
391
392 /****************************************************************************
393 Remove any locks on this fd. Called from file_close().
394 ****************************************************************************/
395
396 void locking_close_file(struct messaging_context *msg_ctx,
397 files_struct *fsp,
398 enum file_close_type close_type)
399 {
400 struct byte_range_lock *br_lck;
401
402 if (!lp_locking(fsp->conn->params)) {
403 return;
404 }
405
406 /* If we have no outstanding locks or pending
407 * locks then we don't need to look in the lock db.
408 */
409
410 if (fsp->current_lock_count == 0) {
411 return;
412 }
413
414 br_lck = brl_get_locks(talloc_tos(),fsp);
415
416 if (br_lck) {
417 cancel_pending_lock_requests_by_fid(fsp, br_lck, close_type);
418 brl_close_fnum(msg_ctx, br_lck);
419 TALLOC_FREE(br_lck);
420 }
421 }
422
423 /*******************************************************************
424 Print out a share mode.
425 ********************************************************************/
426
427 char *share_mode_str(TALLOC_CTX *ctx, int num, const struct share_mode_entry *e)
428 {
429 struct server_id_buf tmp;
430
431 return talloc_asprintf(ctx, "share_mode_entry[%d]: "
432 "pid = %s, share_access = 0x%x, private_options = 0x%x, "
433 "access_mask = 0x%x, mid = 0x%llx, type= 0x%x, gen_id = %llu, "
434 "uid = %u, flags = %u, file_id %s, name_hash = 0x%x",
435 num,
436 server_id_str_buf(e->pid, &tmp),
437 e->share_access, e->private_options,
438 e->access_mask, (unsigned long long)e->op_mid,
439 e->op_type, (unsigned long long)e->share_file_id,
440 (unsigned int)e->uid, (unsigned int)e->flags,
441 file_id_string_tos(&e->id),
442 (unsigned int)e->name_hash);
443 }
444
445 /*******************************************************************
446 Fetch a share mode where we know one MUST exist. This call reference
447 counts it internally to allow for nested lock fetches.
448 ********************************************************************/
449
450 struct share_mode_lock *get_existing_share_mode_lock(TALLOC_CTX *mem_ctx,
451 const struct file_id id)
452 {
453 return get_share_mode_lock(mem_ctx, id, NULL, NULL, NULL);
454 }
455
456 /*******************************************************************
457 Sets the service name and filename for rename.
458 At this point we emit "file renamed" messages to all
459 process id's that have this file open.
460 Based on an initial code idea from SATOH Fumiyasu <fumiya@samba.gr.jp>
461 ********************************************************************/
462
463 bool rename_share_filename(struct messaging_context *msg_ctx,
464 struct share_mode_lock *lck,
465 struct file_id id,
466 const char *servicepath,
467 uint32_t orig_name_hash,
468 uint32_t new_name_hash,
469 const struct smb_filename *smb_fname_dst)
470 {
471 struct share_mode_data *d = lck->data;
472 size_t sp_len;
473 size_t bn_len;
474 size_t sn_len;
475 size_t msg_len;
476 char *frm = NULL;
477 uint32_t i;
478 bool strip_two_chars = false;
479 bool has_stream = smb_fname_dst->stream_name != NULL;
480 struct server_id self_pid = messaging_server_id(msg_ctx);
481
482 DEBUG(10, ("rename_share_filename: servicepath %s newname %s\n",
483 servicepath, smb_fname_dst->base_name));
484
485 /*
486 * rename_internal_fsp() and rename_internals() add './' to
487 * head of newname if newname does not contain a '/'.
488 */
489 if (smb_fname_dst->base_name[0] &&
490 smb_fname_dst->base_name[1] &&
491 smb_fname_dst->base_name[0] == '.' &&
492 smb_fname_dst->base_name[1] == '/') {
493 strip_two_chars = true;
494 }
495
496 d->servicepath = talloc_strdup(d, servicepath);
497 d->base_name = talloc_strdup(d, smb_fname_dst->base_name +
498 (strip_two_chars ? 2 : 0));
499 d->stream_name = talloc_strdup(d, smb_fname_dst->stream_name);
500 if (d->base_name == NULL ||
501 (has_stream && d->stream_name == NULL) ||
502 d->servicepath == NULL) {
503 DEBUG(0, ("rename_share_filename: talloc failed\n"));
504 return False;
505 }
506 d->modified = True;
507
508 sp_len = strlen(d->servicepath);
509 bn_len = strlen(d->base_name);
510 sn_len = has_stream ? strlen(d->stream_name) : 0;
511
512 msg_len = MSG_FILE_RENAMED_MIN_SIZE + sp_len + 1 + bn_len + 1 +
513 sn_len + 1;
514
515 /* Set up the name changed message. */
516 frm = talloc_array(d, char, msg_len);
517 if (!frm) {
518 return False;
519 }
520
521 push_file_id_24(frm, &id);
522
523 DEBUG(10,("rename_share_filename: msg_len = %u\n", (unsigned int)msg_len ));
524
525 strlcpy(&frm[24],
526 d->servicepath ? d->servicepath : "",
527 sp_len+1);
528 strlcpy(&frm[24 + sp_len + 1],
529 d->base_name ? d->base_name : "",
530 bn_len+1);
531 strlcpy(&frm[24 + sp_len + 1 + bn_len + 1],
532 d->stream_name ? d->stream_name : "",
533 sn_len+1);
534
535 /* Send the messages. */
536 for (i=0; i<d->num_share_modes; i++) {
537 struct share_mode_entry *se = &d->share_modes[i];
538 struct server_id_buf tmp;
539
540 if (!is_valid_share_mode_entry(se)) {
541 continue;
542 }
543
544 /* If this is a hardlink to the inode
545 with a different name, skip this. */
546 if (se->name_hash != orig_name_hash) {
547 continue;
548 }
549
550 se->name_hash = new_name_hash;
551
552 /* But not to ourselves... */
553 if (serverid_equal(&se->pid, &self_pid)) {
554 continue;
555 }
556
557 if (share_mode_stale_pid(d, i)) {
558 continue;
559 }
560
561 DEBUG(10,("rename_share_filename: sending rename message to "
562 "pid %s file_id %s sharepath %s base_name %s "
563 "stream_name %s\n",
564 server_id_str_buf(se->pid, &tmp),
565 file_id_string_tos(&id),
566 d->servicepath, d->base_name,
567 has_stream ? d->stream_name : ""));
568
569 messaging_send_buf(msg_ctx, se->pid, MSG_SMB_FILE_RENAME,
570 (uint8_t *)frm, msg_len);
571 }
572
573 for (i=0; i<d->num_leases; i++) {
574 /* Update the filename in leases_db. */
575 NTSTATUS status;
576 struct share_mode_lease *l;
577
578 l = &d->leases[i];
579
580 status = leases_db_rename(&l->client_guid,
581 &l->lease_key,
582 &id,
583 d->servicepath,
584 d->base_name,
585 d->stream_name);
586 if (!NT_STATUS_IS_OK(status)) {
587 /* Any error recovery possible here ? */
588 DEBUG(1,("Failed to rename lease key for "
589 "renamed file %s:%s. %s\n",
590 d->base_name,
591 d->stream_name,
592 nt_errstr(status)));
593 continue;
594 }
595 }
596
597 return True;
598 }
599
600 void get_file_infos(struct file_id id,
601 uint32_t name_hash,
602 bool *delete_on_close,
603 struct timespec *write_time)
604 {
605 struct share_mode_lock *lck;
606
607 if (delete_on_close) {
608 *delete_on_close = false;
609 }
610
611 if (write_time) {
612 ZERO_STRUCTP(write_time);
613 }
614
615 if (!(lck = fetch_share_mode_unlocked(talloc_tos(), id))) {
616 return;
617 }
618
619 if (delete_on_close) {
620 *delete_on_close = is_delete_on_close_set(lck, name_hash);
621 }
622
623 if (write_time) {
624 *write_time = get_share_mode_write_time(lck);
625 }
626
627 TALLOC_FREE(lck);
628 }
629
630 bool is_valid_share_mode_entry(const struct share_mode_entry *e)
631 {
632 int num_props = 0;
633
634 if (e->stale) {
635 return false;
636 }
637
638 num_props += ((e->op_type == NO_OPLOCK) ? 1 : 0);
639 num_props += (EXCLUSIVE_OPLOCK_TYPE(e->op_type) ? 1 : 0);
640 num_props += (LEVEL_II_OPLOCK_TYPE(e->op_type) ? 1 : 0);
641 num_props += (e->op_type == LEASE_OPLOCK);
642
643 if ((num_props > 1) && serverid_exists(&e->pid)) {
644 smb_panic("Invalid share mode entry");
645 }
646 return (num_props != 0);
647 }
648
649 /*
650 * See if we need to remove a lease being referred to by a
651 * share mode that is being marked stale or deleted.
652 */
653
654 static void remove_share_mode_lease(struct share_mode_data *d,
655 struct share_mode_entry *e)
656 {
657 struct GUID client_guid;
658 struct smb2_lease_key lease_key;
659 uint16_t op_type;
660 uint32_t lease_idx;
661 uint32_t i;
662
663 op_type = e->op_type;
664 e->op_type = NO_OPLOCK;
665
666 d->modified = true;
667
668 if (op_type != LEASE_OPLOCK) {
669 return;
670 }
671
672 /*
673 * This used to reference a lease. If there's no other one referencing
674 * it, remove it.
675 */
676
677 lease_idx = e->lease_idx;
678 e->lease_idx = UINT32_MAX;
679
680 for (i=0; i<d->num_share_modes; i++) {
681 if (d->share_modes[i].stale) {
682 continue;
683 }
684 if (e == &d->share_modes[i]) {
685 /* Not ourselves. */
686 continue;
687 }
688 if (d->share_modes[i].lease_idx == lease_idx) {
689 break;
690 }
691 }
692 if (i < d->num_share_modes) {
693 /*
694 * Found another one
695 */
696 return;
697 }
698
699 memcpy(&client_guid,
700 &d->leases[lease_idx].client_guid,
701 sizeof(client_guid));
702 lease_key = d->leases[lease_idx].lease_key;
703
704 d->num_leases -= 1;
705 d->leases[lease_idx] = d->leases[d->num_leases];
706
707 /*
708 * We changed the lease array. Fix all references to it.
709 */
710 for (i=0; i<d->num_share_modes; i++) {
711 if (d->share_modes[i].lease_idx == d->num_leases) {
712 d->share_modes[i].lease_idx = lease_idx;
713 d->share_modes[i].lease = &d->leases[lease_idx];
714 }
715 }
716
717 {
718 NTSTATUS status;
719
720 status = leases_db_del(&client_guid,
721 &lease_key,
722 &e->id);
723
724 DEBUG(10, ("%s: leases_db_del returned %s\n", __func__,
725 nt_errstr(status)));
726 }
727 }
728
729 /*
730 * In case d->share_modes[i] conflicts with something or otherwise is
731 * being used, we need to make sure the corresponding process still
732 * exists.
733 */
734 bool share_mode_stale_pid(struct share_mode_data *d, uint32_t idx)
735 {
736 struct server_id_buf tmp;
737 struct share_mode_entry *e;
738
739 if (idx > d->num_share_modes) {
740 DEBUG(1, ("Asking for index %u, only %u around\n",
741 idx, (unsigned)d->num_share_modes));
742 return false;
743 }
744 e = &d->share_modes[idx];
745 if (e->stale) {
746 /*
747 * Checked before
748 */
749 return true;
750 }
751 if (serverid_exists(&e->pid)) {
752 DEBUG(10, ("PID %s (index %u out of %u) still exists\n",
753 server_id_str_buf(e->pid, &tmp), idx,
754 (unsigned)d->num_share_modes));
755 return false;
756 }
757 DEBUG(10, ("PID %s (index %u out of %u) does not exist anymore\n",
758 server_id_str_buf(e->pid, &tmp), idx,
759 (unsigned)d->num_share_modes));
760
761 e->stale = true;
762
763 if (d->num_delete_tokens != 0) {
764 uint32_t i, num_stale;
765
766 /*
767 * We cannot have any delete tokens
768 * if there are no valid share modes.
769 */
770
771 num_stale = 0;
772
773 for (i=0; i<d->num_share_modes; i++) {
774 if (d->share_modes[i].stale) {
775 num_stale += 1;
776 }
777 }
778
779 if (num_stale == d->num_share_modes) {
780 /*
781 * No non-stale share mode found
782 */
783 TALLOC_FREE(d->delete_tokens);
784 d->num_delete_tokens = 0;
785 }
786 }
787
788 remove_share_mode_lease(d, e);
789
790 d->modified = true;
791 return true;
792 }
793
794 void remove_stale_share_mode_entries(struct share_mode_data *d)
795 {
796 uint32_t i;
797
798 i = 0;
799 while (i < d->num_share_modes) {
800 if (d->share_modes[i].stale) {
801 struct share_mode_entry *m = d->share_modes;
802 m[i] = m[d->num_share_modes-1];
803 d->num_share_modes -= 1;
804 } else {
805 i += 1;
806 }
807 }
808 }
809
810 bool set_share_mode(struct share_mode_lock *lck, struct files_struct *fsp,
811 uid_t uid, uint64_t mid, uint16_t op_type,
812 uint32_t lease_idx)
813 {
814 struct share_mode_data *d = lck->data;
815 struct share_mode_entry *tmp, *e;
816 struct share_mode_lease *lease = NULL;
817
818 if (lease_idx == UINT32_MAX) {
819 lease = NULL;
820 } else if (lease_idx >= d->num_leases) {
821 return false;
822 } else {
823 lease = &d->leases[lease_idx];
824 }
825
826 tmp = talloc_realloc(d, d->share_modes, struct share_mode_entry,
827 d->num_share_modes+1);
828 if (tmp == NULL) {
829 return false;
830 }
831 d->share_modes = tmp;
832 e = &d->share_modes[d->num_share_modes];
833 d->num_share_modes += 1;
834 d->modified = true;
835
836 ZERO_STRUCTP(e);
837 e->pid = messaging_server_id(fsp->conn->sconn->msg_ctx);
838 e->share_access = fsp->share_access;
839 e->private_options = fsp->fh->private_options;
840 e->access_mask = fsp->access_mask;
841 e->op_mid = mid;
842 e->op_type = op_type;
843 e->lease_idx = lease_idx;
844 e->lease = lease;
845 e->time.tv_sec = fsp->open_time.tv_sec;
846 e->time.tv_usec = fsp->open_time.tv_usec;
847 e->id = fsp->file_id;
848 e->share_file_id = fsp->fh->gen_id;
849 e->uid = (uint32_t)uid;
850 e->flags = fsp->posix_open ? SHARE_MODE_FLAG_POSIX_OPEN : 0;
851 e->name_hash = fsp->name_hash;
852
853 return true;
854 }
855
856 static struct share_mode_entry *find_share_mode_entry(
857 struct share_mode_lock *lck, files_struct *fsp)
858 {
859 struct share_mode_data *d = lck->data;
860 struct server_id pid;
861 int i;
862
863 pid = messaging_server_id(fsp->conn->sconn->msg_ctx);
864
865 for (i=0; i<d->num_share_modes; i++) {
866 struct share_mode_entry *e = &d->share_modes[i];
867
868 if (!is_valid_share_mode_entry(e)) {
869 continue;
870 }
871 if (!serverid_equal(&pid, &e->pid)) {
872 continue;
873 }
874 if (!file_id_equal(&fsp->file_id, &e->id)) {
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 }
Samba GIT mirror