#include "../libcli/smb/smb_common.h"
#include "trans2.h"
#include "../lib/util/tevent_ntstatus.h"
+#include "../librpc/gen_ndr/open_files.h"
+#include "source3/lib/dbwrap/dbwrap_watch.h"
+#include "messages.h"
static struct tevent_req *smbd_smb2_setinfo_send(TALLOC_CTX *mem_ctx,
struct tevent_context *ev,
static void smbd_smb2_request_setinfo_done(struct tevent_req *subreq);
NTSTATUS smbd_smb2_request_process_setinfo(struct smbd_smb2_request *req)
{
+ struct smbXsrv_connection *xconn = req->xconn;
NTSTATUS status;
const uint8_t *inbody;
- int i = req->current_idx;
uint8_t in_info_type;
uint8_t in_file_info_class;
uint16_t in_input_buffer_offset;
if (!NT_STATUS_IS_OK(status)) {
return smbd_smb2_request_error(req, status);
}
- inbody = (const uint8_t *)req->in.vector[i+1].iov_base;
+ inbody = SMBD_SMB2_IN_BODY_PTR(req);
in_info_type = CVAL(inbody, 0x02);
in_file_info_class = CVAL(inbody, 0x03);
if (in_input_buffer_offset == 0 && in_input_buffer_length == 0) {
/* This is ok */
} else if (in_input_buffer_offset !=
- (SMB2_HDR_BODY + req->in.vector[i+1].iov_len)) {
+ (SMB2_HDR_BODY + SMBD_SMB2_IN_BODY_LEN(req))) {
return smbd_smb2_request_error(req, NT_STATUS_INVALID_PARAMETER);
}
- if (in_input_buffer_length > req->in.vector[i+2].iov_len) {
+ if (in_input_buffer_length > SMBD_SMB2_IN_DYN_LEN(req)) {
return smbd_smb2_request_error(req, NT_STATUS_INVALID_PARAMETER);
}
- in_input_buffer.data = (uint8_t *)req->in.vector[i+2].iov_base;
+ in_input_buffer.data = SMBD_SMB2_IN_DYN_PTR(req);
in_input_buffer.length = in_input_buffer_length;
- if (in_input_buffer.length > req->sconn->smb2.max_trans) {
+ if (in_input_buffer.length > xconn->smb2.server.max_trans) {
DEBUG(2,("smbd_smb2_request_process_setinfo: "
"client ignored max trans: %s: 0x%08X: 0x%08X\n",
__location__, (unsigned)in_input_buffer.length,
- (unsigned)req->sconn->smb2.max_trans));
+ (unsigned)xconn->smb2.server.max_trans));
return smbd_smb2_request_error(req, NT_STATUS_INVALID_PARAMETER);
}
if (!NT_STATUS_IS_OK(status)) {
error = smbd_smb2_request_error(req, status);
if (!NT_STATUS_IS_OK(error)) {
- smbd_server_connection_terminate(req->sconn,
+ smbd_server_connection_terminate(req->xconn,
nt_errstr(error));
return;
}
return;
}
- outbody = data_blob_talloc(req->out.vector, NULL, 0x02);
+ outbody = smbd_smb2_generate_outbody(req, 0x02);
if (outbody.data == NULL) {
error = smbd_smb2_request_error(req, NT_STATUS_NO_MEMORY);
if (!NT_STATUS_IS_OK(error)) {
- smbd_server_connection_terminate(req->sconn,
+ smbd_server_connection_terminate(req->xconn,
nt_errstr(error));
return;
}
error = smbd_smb2_request_done(req, outbody, NULL);
if (!NT_STATUS_IS_OK(error)) {
- smbd_server_connection_terminate(req->sconn,
+ smbd_server_connection_terminate(req->xconn,
nt_errstr(error));
return;
}
}
+struct defer_rename_state {
+ struct tevent_req *req;
+ struct smbd_smb2_request *smb2req;
+ struct tevent_context *ev;
+ struct files_struct *fsp;
+ char *data;
+ int data_size;
+};
+
+static int defer_rename_state_destructor(struct defer_rename_state *rename_state)
+{
+ SAFE_FREE(rename_state->data);
+ return 0;
+}
+
+static void defer_rename_done(struct tevent_req *subreq);
+
+static struct tevent_req *delay_rename_for_lease_break(struct tevent_req *req,
+ struct smbd_smb2_request *smb2req,
+ struct tevent_context *ev,
+ struct files_struct *fsp,
+ struct share_mode_lock *lck,
+ char *data,
+ int data_size)
+
+{
+ struct tevent_req *subreq;
+ uint32_t i;
+ struct share_mode_data *d = lck->data;
+ struct defer_rename_state *rename_state;
+ bool delay = false;
+ struct timeval timeout;
+
+ if (fsp->oplock_type != LEASE_OPLOCK) {
+ return NULL;
+ }
+
+ for (i=0; i<d->num_share_modes; i++) {
+ struct share_mode_entry *e = &d->share_modes[i];
+ struct share_mode_lease *l = NULL;
+ uint32_t e_lease_type = get_lease_type(d, e);
+ uint32_t break_to;
+
+ if (e->op_type != LEASE_OPLOCK) {
+ continue;
+ }
+
+ l = &d->leases[e->lease_idx];
+
+ if (smb2_lease_equal(fsp_client_guid(fsp),
+ &fsp->lease->lease.lease_key,
+ &l->client_guid,
+ &l->lease_key)) {
+ continue;
+ }
+
+ if (share_mode_stale_pid(d, i)) {
+ continue;
+ }
+
+ if (!(e_lease_type & SMB2_LEASE_HANDLE)) {
+ continue;
+ }
+
+ delay = true;
+ break_to = (e_lease_type & ~SMB2_LEASE_HANDLE);
+
+ send_break_message(fsp->conn->sconn->msg_ctx, e, break_to);
+ }
+
+ if (!delay) {
+ return NULL;
+ }
+
+ /* Setup a watch on this record. */
+ rename_state = talloc_zero(req, struct defer_rename_state);
+ if (rename_state == NULL) {
+ return NULL;
+ }
+
+ rename_state->req = req;
+ rename_state->smb2req = smb2req;
+ rename_state->ev = ev;
+ rename_state->fsp = fsp;
+ rename_state->data = data;
+ rename_state->data_size = data_size;
+
+ talloc_set_destructor(rename_state, defer_rename_state_destructor);
+
+ subreq = dbwrap_watched_watch_send(
+ rename_state,
+ ev,
+ lck->data->record,
+ (struct server_id){0});
+
+ if (subreq == NULL) {
+ exit_server("Could not watch share mode record for rename\n");
+ }
+
+ tevent_req_set_callback(subreq, defer_rename_done, rename_state);
+
+ timeout = timeval_set(OPLOCK_BREAK_TIMEOUT*2, 0);
+ if (!tevent_req_set_endtime(subreq,
+ ev,
+ timeval_sum(&smb2req->request_time, &timeout))) {
+ exit_server("Could not set rename timeout\n");
+ }
+
+ return subreq;
+}
+
+static void defer_rename_done(struct tevent_req *subreq)
+{
+ struct defer_rename_state *state = tevent_req_callback_data(
+ subreq, struct defer_rename_state);
+ NTSTATUS status;
+ struct share_mode_lock *lck;
+ int ret_size = 0;
+ bool ok;
+
+ status = dbwrap_watched_watch_recv(subreq, state->req, NULL, NULL,
+ NULL);
+ TALLOC_FREE(subreq);
+ if (!NT_STATUS_IS_OK(status)) {
+ DEBUG(5, ("dbwrap_record_watch_recv returned %s\n",
+ nt_errstr(status)));
+ tevent_req_nterror(state->req, status);
+ return;
+ }
+
+ /*
+ * Make sure we run as the user again
+ */
+ ok = change_to_user(state->smb2req->tcon->compat,
+ state->smb2req->session->compat->vuid);
+ if (!ok) {
+ tevent_req_nterror(state->req, NT_STATUS_ACCESS_DENIED);
+ return;
+ }
+
+ ok = set_current_service(state->smb2req->tcon->compat, 0, true);
+ if (!ok) {
+ tevent_req_nterror(state->req, NT_STATUS_ACCESS_DENIED);
+ return;
+ }
+
+ /* Do we still need to wait ? */
+ lck = get_existing_share_mode_lock(state->req, state->fsp->file_id);
+ if (lck == NULL) {
+ tevent_req_nterror(state->req, NT_STATUS_UNSUCCESSFUL);
+ return;
+ }
+ subreq = delay_rename_for_lease_break(state->req,
+ state->smb2req,
+ state->ev,
+ state->fsp,
+ lck,
+ state->data,
+ state->data_size);
+ if (subreq) {
+ /* Yep - keep waiting. */
+ state->data = NULL;
+ TALLOC_FREE(state);
+ TALLOC_FREE(lck);
+ return;
+ }
+
+ /* Do the rename under the lock. */
+ status = smbd_do_setfilepathinfo(state->fsp->conn,
+ state->smb2req->smb1req,
+ state,
+ SMB2_FILE_RENAME_INFORMATION_INTERNAL,
+ state->fsp,
+ state->fsp->fsp_name,
+ &state->data,
+ state->data_size,
+ &ret_size);
+
+ TALLOC_FREE(lck);
+ SAFE_FREE(state->data);
+
+ if (!NT_STATUS_IS_OK(status)) {
+ tevent_req_nterror(state->req, status);
+ return;
+ }
+
+ tevent_req_done(state->req);
+}
+
struct smbd_smb2_setinfo_state {
struct smbd_smb2_request *smb2req;
};
struct smbd_smb2_setinfo_state *state = NULL;
struct smb_request *smbreq = NULL;
connection_struct *conn = smb2req->tcon->compat;
+ struct share_mode_lock *lck = NULL;
NTSTATUS status;
req = tevent_req_create(mem_ctx, &state,
memcpy(data, in_input_buffer.data, data_size);
}
+ if (file_info_level == SMB2_FILE_RENAME_INFORMATION_INTERNAL) {
+ struct tevent_req *subreq;
+
+ lck = get_existing_share_mode_lock(mem_ctx,
+ fsp->file_id);
+ if (lck == NULL) {
+ SAFE_FREE(data);
+ tevent_req_nterror(req,
+ NT_STATUS_UNSUCCESSFUL);
+ return tevent_req_post(req, ev);
+ }
+
+ subreq = delay_rename_for_lease_break(req,
+ smb2req,
+ ev,
+ fsp,
+ lck,
+ data,
+ data_size);
+ if (subreq) {
+ /* Wait for lease break response. */
+
+ /* Ensure we can't be closed in flight. */
+ if (!aio_add_req_to_fsp(fsp, req)) {
+ TALLOC_FREE(lck);
+ tevent_req_nterror(req, NT_STATUS_NO_MEMORY);
+ return tevent_req_post(req, ev);
+ }
+
+ TALLOC_FREE(lck);
+ return req;
+ }
+ }
+
status = smbd_do_setfilepathinfo(conn, smbreq, state,
file_info_level,
fsp,
&data,
data_size,
&ret_size);
+ TALLOC_FREE(lck);
SAFE_FREE(data);
if (!NT_STATUS_IS_OK(status)) {
if (NT_STATUS_EQUAL(status, NT_STATUS_INVALID_LEVEL)) {
break;
}
+ case 0x02:/* SMB2_SETINFO_FS */
+ {
+ uint16_t file_info_level = in_file_info_class + 1000;
+
+ status = smbd_do_setfsinfo(conn, smbreq, state,
+ file_info_level,
+ fsp,
+ &in_input_buffer);
+ if (!NT_STATUS_IS_OK(status)) {
+ if (NT_STATUS_EQUAL(status, NT_STATUS_INVALID_LEVEL)) {
+ status = NT_STATUS_INVALID_INFO_CLASS;
+ }
+ tevent_req_nterror(req, status);
+ return tevent_req_post(req, ev);
+ }
+ break;
+ }
+
case 0x03:/* SMB2_SETINFO_SECURITY */
{
if (!CAN_WRITE(conn)) {
return tevent_req_post(req, ev);
}
- status = set_sd(fsp,
+ status = set_sd_blob(fsp,
in_input_buffer.data,
in_input_buffer.length,
- in_additional_information);
+ in_additional_information &
+ SMB_SUPPORTED_SECINFO_FLAGS);
if (!NT_STATUS_IS_OK(status)) {
tevent_req_nterror(req, status);
return tevent_req_post(req, ev);