mirror of
https://github.com/samba-team/samba.git
synced 2024-12-23 17:34:34 +03:00
7077ae4042
Signed-off-by: Andreas Schneider <asn@samba.org> Reviewed-by: Joseph Sutton <josephsutton@catalyst.net.nz>
783 lines
20 KiB
C
783 lines
20 KiB
C
/*
|
|
Unix SMB/CIFS implementation.
|
|
Core SMB2 server
|
|
|
|
Copyright (C) Stefan Metzmacher 2009
|
|
Copyright (C) Jeremy Allison 2010
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "includes.h"
|
|
#include "locking/share_mode_lock.h"
|
|
#include "smbd/smbd.h"
|
|
#include "smbd/globals.h"
|
|
#include "../libcli/smb/smb_common.h"
|
|
#include "../lib/util/tevent_ntstatus.h"
|
|
#include "lib/dbwrap/dbwrap_watch.h"
|
|
#include "librpc/gen_ndr/open_files.h"
|
|
#include "messages.h"
|
|
|
|
#undef DBGC_CLASS
|
|
#define DBGC_CLASS DBGC_SMB2
|
|
|
|
struct smbd_smb2_lock_element {
|
|
uint64_t offset;
|
|
uint64_t length;
|
|
uint32_t flags;
|
|
};
|
|
|
|
struct smbd_smb2_lock_state {
|
|
struct tevent_context *ev;
|
|
struct smbd_smb2_request *smb2req;
|
|
struct smb_request *smb1req;
|
|
struct files_struct *fsp;
|
|
bool blocking;
|
|
uint32_t polling_msecs;
|
|
uint32_t retry_msecs;
|
|
uint16_t lock_count;
|
|
struct smbd_lock_element *locks;
|
|
uint8_t lock_sequence_value;
|
|
uint8_t *lock_sequence_element;
|
|
};
|
|
|
|
static struct tevent_req *smbd_smb2_lock_send(TALLOC_CTX *mem_ctx,
|
|
struct tevent_context *ev,
|
|
struct smbd_smb2_request *smb2req,
|
|
struct files_struct *in_fsp,
|
|
uint32_t in_lock_sequence,
|
|
uint16_t in_lock_count,
|
|
struct smbd_smb2_lock_element *in_locks);
|
|
static NTSTATUS smbd_smb2_lock_recv(struct tevent_req *req);
|
|
|
|
static void smbd_smb2_request_lock_done(struct tevent_req *subreq);
|
|
NTSTATUS smbd_smb2_request_process_lock(struct smbd_smb2_request *req)
|
|
{
|
|
const uint8_t *inbody;
|
|
uint16_t in_lock_count;
|
|
uint32_t in_lock_sequence;
|
|
uint64_t in_file_id_persistent;
|
|
uint64_t in_file_id_volatile;
|
|
struct files_struct *in_fsp;
|
|
struct smbd_smb2_lock_element *in_locks;
|
|
struct tevent_req *subreq;
|
|
const uint8_t *lock_buffer;
|
|
uint16_t l;
|
|
NTSTATUS status;
|
|
|
|
status = smbd_smb2_request_verify_sizes(req, 0x30);
|
|
if (!NT_STATUS_IS_OK(status)) {
|
|
return smbd_smb2_request_error(req, status);
|
|
}
|
|
inbody = SMBD_SMB2_IN_BODY_PTR(req);
|
|
|
|
in_lock_count = CVAL(inbody, 0x02);
|
|
if (req->xconn->protocol >= PROTOCOL_SMB2_10) {
|
|
in_lock_sequence = IVAL(inbody, 0x04);
|
|
} else {
|
|
/* 0x04 - 4 bytes reserved */
|
|
in_lock_sequence = 0;
|
|
}
|
|
in_file_id_persistent = BVAL(inbody, 0x08);
|
|
in_file_id_volatile = BVAL(inbody, 0x10);
|
|
|
|
if (in_lock_count < 1) {
|
|
return smbd_smb2_request_error(req, NT_STATUS_INVALID_PARAMETER);
|
|
}
|
|
|
|
if (((in_lock_count - 1) * 0x18) > SMBD_SMB2_IN_DYN_LEN(req)) {
|
|
return smbd_smb2_request_error(req, NT_STATUS_INVALID_PARAMETER);
|
|
}
|
|
|
|
in_locks = talloc_array(req, struct smbd_smb2_lock_element,
|
|
in_lock_count);
|
|
if (in_locks == NULL) {
|
|
return smbd_smb2_request_error(req, NT_STATUS_NO_MEMORY);
|
|
}
|
|
|
|
l = 0;
|
|
lock_buffer = inbody + 0x18;
|
|
|
|
in_locks[l].offset = BVAL(lock_buffer, 0x00);
|
|
in_locks[l].length = BVAL(lock_buffer, 0x08);
|
|
in_locks[l].flags = IVAL(lock_buffer, 0x10);
|
|
/* 0x14 - 4 reserved bytes */
|
|
|
|
status = req->session->status;
|
|
if (NT_STATUS_EQUAL(status, NT_STATUS_NETWORK_SESSION_EXPIRED)) {
|
|
/*
|
|
* We need to catch NT_STATUS_NETWORK_SESSION_EXPIRED
|
|
* for lock requests only.
|
|
*
|
|
* Unlock requests still need to be processed!
|
|
*
|
|
* This means smbd_smb2_request_check_session()
|
|
* can't handle the difference and always
|
|
* allows SMB2_OP_LOCK.
|
|
*/
|
|
if (in_locks[0].flags != SMB2_LOCK_FLAG_UNLOCK) {
|
|
return smbd_smb2_request_error(req, status);
|
|
}
|
|
}
|
|
|
|
lock_buffer = SMBD_SMB2_IN_DYN_PTR(req);
|
|
|
|
for (l=1; l < in_lock_count; l++) {
|
|
in_locks[l].offset = BVAL(lock_buffer, 0x00);
|
|
in_locks[l].length = BVAL(lock_buffer, 0x08);
|
|
in_locks[l].flags = IVAL(lock_buffer, 0x10);
|
|
/* 0x14 - 4 reserved bytes */
|
|
|
|
lock_buffer += 0x18;
|
|
}
|
|
|
|
in_fsp = file_fsp_smb2(req, in_file_id_persistent, in_file_id_volatile);
|
|
if (in_fsp == NULL) {
|
|
return smbd_smb2_request_error(req, NT_STATUS_FILE_CLOSED);
|
|
}
|
|
|
|
subreq = smbd_smb2_lock_send(req, req->sconn->ev_ctx,
|
|
req, in_fsp,
|
|
in_lock_sequence,
|
|
in_lock_count,
|
|
in_locks);
|
|
if (subreq == NULL) {
|
|
return smbd_smb2_request_error(req, NT_STATUS_NO_MEMORY);
|
|
}
|
|
tevent_req_set_callback(subreq, smbd_smb2_request_lock_done, req);
|
|
|
|
return smbd_smb2_request_pending_queue(req, subreq, 500);
|
|
}
|
|
|
|
static void smbd_smb2_request_lock_done(struct tevent_req *subreq)
|
|
{
|
|
struct smbd_smb2_request *smb2req = tevent_req_callback_data(subreq,
|
|
struct smbd_smb2_request);
|
|
DATA_BLOB outbody;
|
|
NTSTATUS status;
|
|
NTSTATUS error; /* transport error */
|
|
|
|
status = smbd_smb2_lock_recv(subreq);
|
|
TALLOC_FREE(subreq);
|
|
if (!NT_STATUS_IS_OK(status)) {
|
|
error = smbd_smb2_request_error(smb2req, status);
|
|
if (!NT_STATUS_IS_OK(error)) {
|
|
smbd_server_connection_terminate(smb2req->xconn,
|
|
nt_errstr(error));
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
|
|
outbody = smbd_smb2_generate_outbody(smb2req, 0x04);
|
|
if (outbody.data == NULL) {
|
|
error = smbd_smb2_request_error(smb2req, NT_STATUS_NO_MEMORY);
|
|
if (!NT_STATUS_IS_OK(error)) {
|
|
smbd_server_connection_terminate(smb2req->xconn,
|
|
nt_errstr(error));
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
|
|
SSVAL(outbody.data, 0x00, 0x04); /* struct size */
|
|
SSVAL(outbody.data, 0x02, 0); /* reserved */
|
|
|
|
error = smbd_smb2_request_done(smb2req, outbody, NULL);
|
|
if (!NT_STATUS_IS_OK(error)) {
|
|
smbd_server_connection_terminate(smb2req->xconn,
|
|
nt_errstr(error));
|
|
return;
|
|
}
|
|
}
|
|
|
|
static void smbd_smb2_lock_cleanup(struct tevent_req *req,
|
|
enum tevent_req_state req_state);
|
|
static void smbd_smb2_lock_try(struct tevent_req *req);
|
|
static void smbd_smb2_lock_retry(struct tevent_req *subreq);
|
|
static bool smbd_smb2_lock_cancel(struct tevent_req *req);
|
|
|
|
static struct tevent_req *smbd_smb2_lock_send(TALLOC_CTX *mem_ctx,
|
|
struct tevent_context *ev,
|
|
struct smbd_smb2_request *smb2req,
|
|
struct files_struct *fsp,
|
|
uint32_t in_lock_sequence,
|
|
uint16_t in_lock_count,
|
|
struct smbd_smb2_lock_element *in_locks)
|
|
{
|
|
struct tevent_req *req;
|
|
struct smbd_smb2_lock_state *state;
|
|
bool isunlock = false;
|
|
uint16_t i;
|
|
struct smbd_lock_element *locks;
|
|
NTSTATUS status;
|
|
bool check_lock_sequence = false;
|
|
uint32_t lock_sequence_bucket = 0;
|
|
|
|
req = tevent_req_create(mem_ctx, &state,
|
|
struct smbd_smb2_lock_state);
|
|
if (req == NULL) {
|
|
return NULL;
|
|
}
|
|
state->ev = ev;
|
|
state->fsp = fsp;
|
|
state->smb2req = smb2req;
|
|
smb2req->subreq = req; /* So we can find this when going async. */
|
|
|
|
tevent_req_set_cleanup_fn(req, smbd_smb2_lock_cleanup);
|
|
|
|
state->smb1req = smbd_smb2_fake_smb_request(smb2req, fsp);
|
|
if (tevent_req_nomem(state->smb1req, req)) {
|
|
return tevent_req_post(req, ev);
|
|
}
|
|
|
|
DEBUG(10,("smbd_smb2_lock_send: %s - %s\n",
|
|
fsp_str_dbg(fsp), fsp_fnum_dbg(fsp)));
|
|
|
|
/*
|
|
* Windows sets check_lock_sequence = true
|
|
* only for resilient and persistent handles.
|
|
*
|
|
* [MS-SMB2] 3.3.5.14 Receiving an SMB2 LOCK Request
|
|
*
|
|
* ... if Open.IsResilient or Open.IsDurable or Open.IsPersistent is
|
|
* TRUE or if Connection.Dialect belongs to the SMB 3.x dialect family
|
|
* and Connection.ServerCapabilities includes
|
|
* SMB2_GLOBAL_CAP_MULTI_CHANNEL bit, the server SHOULD<314>
|
|
* perform lock sequence * verification ...
|
|
|
|
* <314> Section 3.3.5.14: Windows 7 and Windows Server 2008 R2 perform
|
|
* lock sequence verification only when Open.IsResilient is TRUE.
|
|
* Windows 8 through Windows 10 v1909 and Windows Server 2012 through
|
|
* Windows Server v1909 perform lock sequence verification only when
|
|
* Open.IsResilient or Open.IsPersistent is TRUE.
|
|
*
|
|
* Note <314> also applies to all versions (at least) up to
|
|
* Windows Server v2004.
|
|
*
|
|
* Hopefully this will be fixed in future Windows versions and they
|
|
* will avoid Note <314>.
|
|
*
|
|
* We implement what the specification says by default, but
|
|
* allow "smb2 disable lock sequence checking = yes" to
|
|
* behave like Windows again.
|
|
*
|
|
* Note: that we already check the dialect before setting
|
|
* SMB2_CAP_MULTI_CHANNEL in smb2_negprot.c
|
|
*/
|
|
if (smb2req->xconn->smb2.server.capabilities & SMB2_CAP_MULTI_CHANNEL) {
|
|
check_lock_sequence = true;
|
|
}
|
|
if (fsp->op->global->durable) {
|
|
check_lock_sequence = true;
|
|
}
|
|
|
|
if (check_lock_sequence) {
|
|
bool disable_lock_sequence_checking =
|
|
lp_smb2_disable_lock_sequence_checking();
|
|
|
|
if (disable_lock_sequence_checking) {
|
|
check_lock_sequence = false;
|
|
}
|
|
}
|
|
|
|
if (check_lock_sequence) {
|
|
state->lock_sequence_value = in_lock_sequence & 0xF;
|
|
lock_sequence_bucket = in_lock_sequence >> 4;
|
|
}
|
|
if ((lock_sequence_bucket > 0) &&
|
|
(lock_sequence_bucket <= sizeof(fsp->op->global->lock_sequence_array)))
|
|
{
|
|
uint32_t idx = lock_sequence_bucket - 1;
|
|
uint8_t *array = fsp->op->global->lock_sequence_array;
|
|
|
|
state->lock_sequence_element = &array[idx];
|
|
}
|
|
|
|
if (state->lock_sequence_element != NULL) {
|
|
/*
|
|
* The incoming 'state->lock_sequence_value' is masked with 0xF.
|
|
*
|
|
* Note per default '*state->lock_sequence_element'
|
|
* is invalid, a value of 0xFF that can never match on
|
|
* incoming value.
|
|
*/
|
|
if (*state->lock_sequence_element == state->lock_sequence_value)
|
|
{
|
|
DBG_INFO("replayed smb2 lock request detected: "
|
|
"file %s, value %u, bucket %u\n",
|
|
fsp_str_dbg(fsp),
|
|
(unsigned)state->lock_sequence_value,
|
|
(unsigned)lock_sequence_bucket);
|
|
tevent_req_done(req);
|
|
return tevent_req_post(req, ev);
|
|
}
|
|
/*
|
|
* If it's not a replay, mark the element as
|
|
* invalid again.
|
|
*/
|
|
*state->lock_sequence_element = 0xFF;
|
|
}
|
|
|
|
locks = talloc_array(state, struct smbd_lock_element, in_lock_count);
|
|
if (locks == NULL) {
|
|
tevent_req_nterror(req, NT_STATUS_NO_MEMORY);
|
|
return tevent_req_post(req, ev);
|
|
}
|
|
|
|
switch (in_locks[0].flags) {
|
|
case SMB2_LOCK_FLAG_SHARED:
|
|
case SMB2_LOCK_FLAG_EXCLUSIVE:
|
|
if (in_lock_count > 1) {
|
|
tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
|
|
return tevent_req_post(req, ev);
|
|
}
|
|
state->blocking = true;
|
|
break;
|
|
|
|
case SMB2_LOCK_FLAG_SHARED|SMB2_LOCK_FLAG_FAIL_IMMEDIATELY:
|
|
case SMB2_LOCK_FLAG_EXCLUSIVE|SMB2_LOCK_FLAG_FAIL_IMMEDIATELY:
|
|
break;
|
|
|
|
case SMB2_LOCK_FLAG_UNLOCK:
|
|
/* only the first lock gives the UNLOCK bit - see
|
|
MS-SMB2 3.3.5.14 */
|
|
isunlock = true;
|
|
break;
|
|
|
|
default:
|
|
tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
|
|
return tevent_req_post(req, ev);
|
|
}
|
|
|
|
if (!isunlock && (in_lock_count > 1)) {
|
|
|
|
/*
|
|
* 3.3.5.14.2 says we SHOULD fail with INVALID_PARAMETER if we
|
|
* have more than one lock and one of those is blocking.
|
|
*/
|
|
|
|
for (i=0; i<in_lock_count; i++) {
|
|
uint32_t flags = in_locks[i].flags;
|
|
|
|
if ((flags & SMB2_LOCK_FLAG_FAIL_IMMEDIATELY) == 0) {
|
|
tevent_req_nterror(
|
|
req, NT_STATUS_INVALID_PARAMETER);
|
|
return tevent_req_post(req, ev);
|
|
}
|
|
}
|
|
}
|
|
|
|
for (i=0; i<in_lock_count; i++) {
|
|
bool invalid = false;
|
|
bool posix_handle =(fsp->posix_flags & FSP_POSIX_FLAGS_OPEN);
|
|
|
|
switch (in_locks[i].flags) {
|
|
case SMB2_LOCK_FLAG_SHARED:
|
|
case SMB2_LOCK_FLAG_EXCLUSIVE:
|
|
if (isunlock) {
|
|
invalid = true;
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case SMB2_LOCK_FLAG_SHARED|SMB2_LOCK_FLAG_FAIL_IMMEDIATELY:
|
|
case SMB2_LOCK_FLAG_EXCLUSIVE|SMB2_LOCK_FLAG_FAIL_IMMEDIATELY:
|
|
if (isunlock) {
|
|
invalid = true;
|
|
}
|
|
break;
|
|
|
|
case SMB2_LOCK_FLAG_UNLOCK:
|
|
if (!isunlock) {
|
|
tevent_req_nterror(req,
|
|
NT_STATUS_INVALID_PARAMETER);
|
|
return tevent_req_post(req, ev);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
if (isunlock) {
|
|
/*
|
|
* If the first element was a UNLOCK
|
|
* we need to defer the error response
|
|
* to the backend, because we need to process
|
|
* all unlock elements before
|
|
*/
|
|
invalid = true;
|
|
break;
|
|
}
|
|
tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
|
|
return tevent_req_post(req, ev);
|
|
}
|
|
|
|
locks[i].req_guid = smbd_request_guid(smb2req->smb1req, i);
|
|
locks[i].smblctx = fsp->op->global->open_persistent_id;
|
|
locks[i].offset = in_locks[i].offset;
|
|
locks[i].count = in_locks[i].length;
|
|
|
|
if (posix_handle) {
|
|
locks[i].lock_flav = POSIX_LOCK;
|
|
} else {
|
|
locks[i].lock_flav = WINDOWS_LOCK;
|
|
}
|
|
|
|
if (in_locks[i].flags & SMB2_LOCK_FLAG_EXCLUSIVE) {
|
|
if (posix_handle && fsp->fsp_flags.can_write == false) {
|
|
/*
|
|
* Can't get a write lock on a posix
|
|
* read-only handle.
|
|
*/
|
|
DBG_INFO("POSIX write lock requested "
|
|
"on read-only handle for file %s\n",
|
|
fsp_str_dbg(fsp));
|
|
tevent_req_nterror(req,
|
|
NT_STATUS_INVALID_HANDLE);
|
|
return tevent_req_post(req, ev);
|
|
}
|
|
locks[i].brltype = WRITE_LOCK;
|
|
} else if (in_locks[i].flags & SMB2_LOCK_FLAG_SHARED) {
|
|
locks[i].brltype = READ_LOCK;
|
|
} else if (invalid) {
|
|
/*
|
|
* this is an invalid UNLOCK element
|
|
* and the backend needs to test for
|
|
* brltype != UNLOCK_LOCK and return
|
|
* NT_STATUS_INVALID_PARAMETER
|
|
*/
|
|
locks[i].brltype = READ_LOCK;
|
|
} else {
|
|
locks[i].brltype = UNLOCK_LOCK;
|
|
}
|
|
locks[i].lock_flav = WINDOWS_LOCK;
|
|
|
|
DBG_DEBUG("index %"PRIu16" offset=%"PRIu64", count=%"PRIu64", "
|
|
"smblctx = %"PRIu64" type %d\n",
|
|
i,
|
|
locks[i].offset,
|
|
locks[i].count,
|
|
locks[i].smblctx,
|
|
(int)locks[i].brltype);
|
|
}
|
|
|
|
state->locks = locks;
|
|
state->lock_count = in_lock_count;
|
|
|
|
if (isunlock) {
|
|
status = smbd_do_unlocking(
|
|
state->smb1req, fsp, in_lock_count, locks);
|
|
|
|
if (tevent_req_nterror(req, status)) {
|
|
return tevent_req_post(req, ev);
|
|
}
|
|
tevent_req_done(req);
|
|
return tevent_req_post(req, ev);
|
|
}
|
|
|
|
smbd_smb2_lock_try(req);
|
|
if (!tevent_req_is_in_progress(req)) {
|
|
return tevent_req_post(req, ev);
|
|
}
|
|
|
|
tevent_req_defer_callback(req, smb2req->sconn->ev_ctx);
|
|
aio_add_req_to_fsp(state->fsp, req);
|
|
tevent_req_set_cancel_fn(req, smbd_smb2_lock_cancel);
|
|
|
|
return req;
|
|
}
|
|
|
|
static void smbd_smb2_lock_cleanup(struct tevent_req *req,
|
|
enum tevent_req_state req_state)
|
|
{
|
|
struct smbd_smb2_lock_state *state = tevent_req_data(
|
|
req, struct smbd_smb2_lock_state);
|
|
|
|
if (req_state != TEVENT_REQ_DONE) {
|
|
return;
|
|
}
|
|
|
|
if (state->lock_sequence_element != NULL) {
|
|
/*
|
|
* On success we remember the given/incoming
|
|
* value (which was masked with 0xF.
|
|
*/
|
|
*state->lock_sequence_element = state->lock_sequence_value;
|
|
}
|
|
}
|
|
|
|
static void smbd_smb2_lock_update_retry_msecs(
|
|
struct smbd_smb2_lock_state *state)
|
|
{
|
|
/*
|
|
* The default lp_lock_spin_time() is 200ms,
|
|
* we just use half of it to trigger the first retry.
|
|
*
|
|
* v_min is in the range of 0.001 to 10 secs
|
|
* (0.1 secs by default)
|
|
*
|
|
* v_max is in the range of 0.01 to 100 secs
|
|
* (1.0 secs by default)
|
|
*
|
|
* The typical steps are:
|
|
* 0.1, 0.2, 0.3, 0.4, ... 1.0
|
|
*/
|
|
uint32_t v_min = MAX(2, MIN(20000, lp_lock_spin_time()))/2;
|
|
uint32_t v_max = 10 * v_min;
|
|
|
|
if (state->retry_msecs >= v_max) {
|
|
state->retry_msecs = v_max;
|
|
return;
|
|
}
|
|
|
|
state->retry_msecs += v_min;
|
|
}
|
|
|
|
static void smbd_smb2_lock_update_polling_msecs(
|
|
struct smbd_smb2_lock_state *state)
|
|
{
|
|
/*
|
|
* The default lp_lock_spin_time() is 200ms.
|
|
*
|
|
* v_min is in the range of 0.002 to 20 secs
|
|
* (0.2 secs by default)
|
|
*
|
|
* v_max is in the range of 0.02 to 200 secs
|
|
* (2.0 secs by default)
|
|
*
|
|
* The typical steps are:
|
|
* 0.2, 0.4, 0.6, 0.8, ... 2.0
|
|
*/
|
|
uint32_t v_min = MAX(2, MIN(20000, lp_lock_spin_time()));
|
|
uint32_t v_max = 10 * v_min;
|
|
|
|
if (state->polling_msecs >= v_max) {
|
|
state->polling_msecs = v_max;
|
|
return;
|
|
}
|
|
|
|
state->polling_msecs += v_min;
|
|
}
|
|
|
|
static void smbd_smb2_lock_try(struct tevent_req *req)
|
|
{
|
|
struct smbd_smb2_lock_state *state = tevent_req_data(
|
|
req, struct smbd_smb2_lock_state);
|
|
struct share_mode_lock *lck = NULL;
|
|
uint16_t blocker_idx;
|
|
struct server_id blocking_pid = { 0 };
|
|
uint64_t blocking_smblctx;
|
|
NTSTATUS status;
|
|
struct tevent_req *subreq = NULL;
|
|
struct timeval endtime = { 0 };
|
|
|
|
lck = get_existing_share_mode_lock(
|
|
talloc_tos(), state->fsp->file_id);
|
|
if (tevent_req_nomem(lck, req)) {
|
|
return;
|
|
}
|
|
|
|
status = smbd_do_locks_try(
|
|
state->fsp,
|
|
state->lock_count,
|
|
state->locks,
|
|
&blocker_idx,
|
|
&blocking_pid,
|
|
&blocking_smblctx);
|
|
if (NT_STATUS_IS_OK(status)) {
|
|
TALLOC_FREE(lck);
|
|
tevent_req_done(req);
|
|
return;
|
|
}
|
|
if (NT_STATUS_EQUAL(status, NT_STATUS_RETRY)) {
|
|
/*
|
|
* We got NT_STATUS_RETRY,
|
|
* we reset polling_msecs so that
|
|
* that the retries based on LOCK_NOT_GRANTED
|
|
* will later start with small intervals again.
|
|
*/
|
|
state->polling_msecs = 0;
|
|
|
|
/*
|
|
* The backend wasn't able to decide yet.
|
|
* We need to wait even for non-blocking
|
|
* locks.
|
|
*
|
|
* The backend uses blocking_smblctx == UINT64_MAX
|
|
* to indicate that we should use retry timers.
|
|
*
|
|
* It uses blocking_smblctx == 0 to indicate
|
|
* it will use share_mode_wakeup_waiters()
|
|
* to wake us. Note that unrelated changes in
|
|
* locking.tdb may cause retries.
|
|
*/
|
|
|
|
if (blocking_smblctx != UINT64_MAX) {
|
|
SMB_ASSERT(blocking_smblctx == 0);
|
|
goto setup_retry;
|
|
}
|
|
|
|
smbd_smb2_lock_update_retry_msecs(state);
|
|
|
|
DBG_DEBUG("Waiting for a backend decision. "
|
|
"Retry in %"PRIu32" msecs\n",
|
|
state->retry_msecs);
|
|
|
|
/*
|
|
* We completely ignore state->endtime here
|
|
* we we'll wait for a backend decision forever.
|
|
* If the backend is smart enough to implement
|
|
* some NT_STATUS_RETRY logic, it has to
|
|
* switch to any other status after in order
|
|
* to avoid waiting forever.
|
|
*/
|
|
endtime = timeval_current_ofs_msec(state->retry_msecs);
|
|
goto setup_retry;
|
|
}
|
|
if (NT_STATUS_EQUAL(status, NT_STATUS_FILE_LOCK_CONFLICT)) {
|
|
/*
|
|
* This is a bug and will be changed into an assert
|
|
* in future version. We should only
|
|
* ever get NT_STATUS_LOCK_NOT_GRANTED here!
|
|
*/
|
|
static uint64_t _bug_count;
|
|
int _level = (_bug_count++ == 0) ? DBGLVL_ERR: DBGLVL_DEBUG;
|
|
DBG_PREFIX(_level, ("BUG: Got %s mapping to "
|
|
"NT_STATUS_LOCK_NOT_GRANTED\n",
|
|
nt_errstr(status)));
|
|
status = NT_STATUS_LOCK_NOT_GRANTED;
|
|
}
|
|
if (!NT_STATUS_EQUAL(status, NT_STATUS_LOCK_NOT_GRANTED)) {
|
|
TALLOC_FREE(lck);
|
|
tevent_req_nterror(req, status);
|
|
return;
|
|
}
|
|
/*
|
|
* We got LOCK_NOT_GRANTED, make sure
|
|
* a following STATUS_RETRY will start
|
|
* with short intervals again.
|
|
*/
|
|
state->retry_msecs = 0;
|
|
|
|
if (!state->blocking) {
|
|
TALLOC_FREE(lck);
|
|
tevent_req_nterror(req, status);
|
|
return;
|
|
}
|
|
|
|
if (blocking_smblctx == UINT64_MAX) {
|
|
smbd_smb2_lock_update_polling_msecs(state);
|
|
|
|
DBG_DEBUG("Blocked on a posix lock. Retry in %"PRIu32" msecs\n",
|
|
state->polling_msecs);
|
|
|
|
endtime = timeval_current_ofs_msec(state->polling_msecs);
|
|
}
|
|
|
|
setup_retry:
|
|
DBG_DEBUG("Watching share mode lock\n");
|
|
|
|
subreq = share_mode_watch_send(
|
|
state, state->ev, lck, blocking_pid);
|
|
TALLOC_FREE(lck);
|
|
if (tevent_req_nomem(subreq, req)) {
|
|
return;
|
|
}
|
|
tevent_req_set_callback(subreq, smbd_smb2_lock_retry, req);
|
|
|
|
if (!timeval_is_zero(&endtime)) {
|
|
bool ok;
|
|
|
|
ok = tevent_req_set_endtime(subreq,
|
|
state->ev,
|
|
endtime);
|
|
if (!ok) {
|
|
tevent_req_oom(req);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void smbd_smb2_lock_retry(struct tevent_req *subreq)
|
|
{
|
|
struct tevent_req *req = tevent_req_callback_data(
|
|
subreq, struct tevent_req);
|
|
struct smbd_smb2_lock_state *state = tevent_req_data(
|
|
req, struct smbd_smb2_lock_state);
|
|
NTSTATUS status;
|
|
bool ok;
|
|
|
|
/*
|
|
* Make sure we run as the user again
|
|
*/
|
|
ok = change_to_user_and_service_by_fsp(state->fsp);
|
|
if (!ok) {
|
|
tevent_req_nterror(req, NT_STATUS_ACCESS_DENIED);
|
|
return;
|
|
}
|
|
|
|
status = share_mode_watch_recv(subreq, NULL, NULL);
|
|
TALLOC_FREE(subreq);
|
|
if (NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
|
|
/*
|
|
* This is just a trigger for a timed retry.
|
|
*/
|
|
status = NT_STATUS_OK;
|
|
}
|
|
if (tevent_req_nterror(req, status)) {
|
|
return;
|
|
}
|
|
|
|
smbd_smb2_lock_try(req);
|
|
}
|
|
|
|
static NTSTATUS smbd_smb2_lock_recv(struct tevent_req *req)
|
|
{
|
|
return tevent_req_simple_recv_ntstatus(req);
|
|
}
|
|
|
|
/****************************************************************
|
|
Cancel an outstanding blocking lock request.
|
|
*****************************************************************/
|
|
|
|
static bool smbd_smb2_lock_cancel(struct tevent_req *req)
|
|
{
|
|
struct smbd_smb2_request *smb2req = NULL;
|
|
struct smbd_smb2_lock_state *state = tevent_req_data(req,
|
|
struct smbd_smb2_lock_state);
|
|
if (!state) {
|
|
return false;
|
|
}
|
|
|
|
if (!state->smb2req) {
|
|
return false;
|
|
}
|
|
|
|
smb2req = state->smb2req;
|
|
|
|
/*
|
|
* If the request is canceled because of close, logoff or tdis
|
|
* the status is NT_STATUS_RANGE_NOT_LOCKED instead of
|
|
* NT_STATUS_CANCELLED.
|
|
*/
|
|
if (state->fsp->fsp_flags.closing ||
|
|
!NT_STATUS_IS_OK(smb2req->session->status) ||
|
|
!NT_STATUS_IS_OK(smb2req->tcon->status)) {
|
|
tevent_req_nterror(req, NT_STATUS_RANGE_NOT_LOCKED);
|
|
return true;
|
|
}
|
|
|
|
tevent_req_nterror(req, NT_STATUS_CANCELLED);
|
|
return true;
|
|
}
|