2 Unix SMB/CIFS implementation.
5 Copyright (C) Stefan Metzmacher 2009
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>.
22 #include "smbd/globals.h"
23 #include "../libcli/smb/smb_common.h"
25 static struct tevent_req *smbd_smb2_read_send(TALLOC_CTX *mem_ctx,
26 struct tevent_context *ev,
27 struct smbd_smb2_request *smb2req,
29 uint64_t in_file_id_volatile,
33 uint32_t in_remaining);
34 static NTSTATUS smbd_smb2_read_recv(struct tevent_req *req,
37 uint32_t *out_remaining);
39 static void smbd_smb2_request_read_done(struct tevent_req *subreq);
40 NTSTATUS smbd_smb2_request_process_read(struct smbd_smb2_request *req)
43 const uint8_t *inbody;
44 int i = req->current_idx;
45 size_t expected_body_size = 0x31;
50 uint64_t in_file_id_persistent;
51 uint64_t in_file_id_volatile;
52 uint32_t in_minimum_count;
53 uint32_t in_remaining_bytes;
54 struct tevent_req *subreq;
56 inhdr = (const uint8_t *)req->in.vector[i+0].iov_base;
57 if (req->in.vector[i+1].iov_len != (expected_body_size & 0xFFFFFFFE)) {
58 return smbd_smb2_request_error(req, NT_STATUS_INVALID_PARAMETER);
61 inbody = (const uint8_t *)req->in.vector[i+1].iov_base;
63 body_size = SVAL(inbody, 0x00);
64 if (body_size != expected_body_size) {
65 return smbd_smb2_request_error(req, NT_STATUS_INVALID_PARAMETER);
68 in_smbpid = IVAL(inhdr, SMB2_HDR_PID);
70 in_length = IVAL(inbody, 0x04);
71 in_offset = BVAL(inbody, 0x08);
72 in_file_id_persistent = BVAL(inbody, 0x10);
73 in_file_id_volatile = BVAL(inbody, 0x18);
74 in_minimum_count = IVAL(inbody, 0x20);
75 in_remaining_bytes = IVAL(inbody, 0x28);
77 /* check the max read size */
78 if (in_length > 0x00010000) {
79 DEBUG(0,("here:%s: 0x%08X: 0x%08X\n",
80 __location__, in_length, 0x00010000));
81 return smbd_smb2_request_error(req, NT_STATUS_INVALID_PARAMETER);
84 if (req->compat_chain_fsp) {
86 } else if (in_file_id_persistent != 0) {
87 return smbd_smb2_request_error(req, NT_STATUS_FILE_CLOSED);
90 subreq = smbd_smb2_read_send(req,
91 req->sconn->smb2.event_ctx,
100 return smbd_smb2_request_error(req, NT_STATUS_NO_MEMORY);
102 tevent_req_set_callback(subreq, smbd_smb2_request_read_done, req);
104 if (tevent_req_is_in_progress(subreq)) {
105 return smbd_smb2_request_pending_queue(req);
111 static void smbd_smb2_request_read_done(struct tevent_req *subreq)
113 struct smbd_smb2_request *req = tevent_req_callback_data(subreq,
114 struct smbd_smb2_request);
115 int i = req->current_idx;
119 uint8_t out_data_offset;
120 DATA_BLOB out_data_buffer = data_blob_null;
121 uint32_t out_data_remaining = 0;
123 NTSTATUS error; /* transport error */
125 status = smbd_smb2_read_recv(subreq,
128 &out_data_remaining);
130 if (!NT_STATUS_IS_OK(status)) {
131 error = smbd_smb2_request_error(req, status);
132 if (!NT_STATUS_IS_OK(error)) {
133 smbd_server_connection_terminate(req->sconn,
140 out_data_offset = SMB2_HDR_BODY + 0x10;
142 outhdr = (uint8_t *)req->out.vector[i].iov_base;
144 outbody = data_blob_talloc(req->out.vector, NULL, 0x10);
145 if (outbody.data == NULL) {
146 error = smbd_smb2_request_error(req, NT_STATUS_NO_MEMORY);
147 if (!NT_STATUS_IS_OK(error)) {
148 smbd_server_connection_terminate(req->sconn,
155 SSVAL(outbody.data, 0x00, 0x10 + 1); /* struct size */
156 SCVAL(outbody.data, 0x02,
157 out_data_offset); /* data offset */
158 SCVAL(outbody.data, 0x03, 0); /* reserved */
159 SIVAL(outbody.data, 0x04,
160 out_data_buffer.length); /* data length */
161 SIVAL(outbody.data, 0x08,
162 out_data_remaining); /* data remaining */
163 SIVAL(outbody.data, 0x0C, 0); /* reserved */
165 outdyn = out_data_buffer;
167 error = smbd_smb2_request_done(req, outbody, &outdyn);
168 if (!NT_STATUS_IS_OK(error)) {
169 smbd_server_connection_terminate(req->sconn,
175 struct smbd_smb2_read_state {
176 struct smbd_smb2_request *smb2req;
178 uint32_t out_remaining;
181 static void smbd_smb2_read_pipe_done(struct tevent_req *subreq);
183 static struct tevent_req *smbd_smb2_read_send(TALLOC_CTX *mem_ctx,
184 struct tevent_context *ev,
185 struct smbd_smb2_request *smb2req,
187 uint64_t in_file_id_volatile,
191 uint32_t in_remaining)
193 struct tevent_req *req;
194 struct smbd_smb2_read_state *state;
195 struct smb_request *smbreq;
196 connection_struct *conn = smb2req->tcon->compat_conn;
199 struct lock_struct lock;
201 req = tevent_req_create(mem_ctx, &state,
202 struct smbd_smb2_read_state);
206 state->smb2req = smb2req;
207 state->out_data = data_blob_null;
208 state->out_remaining = 0;
210 DEBUG(10,("smbd_smb2_read: file_id[0x%016llX]\n",
211 (unsigned long long)in_file_id_volatile));
213 smbreq = smbd_smb2_fake_smb_request(smb2req);
214 if (tevent_req_nomem(smbreq, req)) {
215 return tevent_req_post(req, ev);
218 fsp = file_fsp(smbreq, (uint16_t)in_file_id_volatile);
220 tevent_req_nterror(req, NT_STATUS_FILE_CLOSED);
221 return tevent_req_post(req, ev);
223 if (conn != fsp->conn) {
224 tevent_req_nterror(req, NT_STATUS_FILE_CLOSED);
225 return tevent_req_post(req, ev);
227 if (smb2req->session->vuid != fsp->vuid) {
228 tevent_req_nterror(req, NT_STATUS_FILE_CLOSED);
229 return tevent_req_post(req, ev);
232 state->out_data = data_blob_talloc(state, NULL, in_length);
233 if (in_length > 0 && tevent_req_nomem(state->out_data.data, req)) {
234 return tevent_req_post(req, ev);
237 if (IS_IPC(smbreq->conn)) {
238 struct tevent_req *subreq;
240 if (!fsp_is_np(fsp)) {
241 tevent_req_nterror(req, NT_STATUS_FILE_CLOSED);
242 return tevent_req_post(req, ev);
245 subreq = np_read_send(state, smbd_event_context(),
246 fsp->fake_file_handle,
247 state->out_data.data,
248 state->out_data.length);
249 if (tevent_req_nomem(subreq, req)) {
250 return tevent_req_post(req, ev);
252 tevent_req_set_callback(subreq,
253 smbd_smb2_read_pipe_done,
258 if (!CHECK_READ(fsp, smbreq)) {
259 tevent_req_nterror(req, NT_STATUS_ACCESS_DENIED);
260 return tevent_req_post(req, ev);
263 init_strict_lock_struct(fsp,
270 if (!SMB_VFS_STRICT_LOCK(conn, fsp, &lock)) {
271 tevent_req_nterror(req, NT_STATUS_FILE_LOCK_CONFLICT);
272 return tevent_req_post(req, ev);
275 nread = read_file(fsp,
276 (char *)state->out_data.data,
280 SMB_VFS_STRICT_UNLOCK(conn, fsp, &lock);
283 DEBUG(5,("smbd_smb2_read: read_file[%s] nread[%lld]\n",
284 fsp_str_dbg(fsp), (long long)nread));
285 tevent_req_nterror(req, NT_STATUS_ACCESS_DENIED);
286 return tevent_req_post(req, ev);
288 if (nread == 0 && in_length != 0) {
289 DEBUG(5,("smbd_smb2_read: read_file[%s] end of file\n",
291 tevent_req_nterror(req, NT_STATUS_END_OF_FILE);
292 return tevent_req_post(req, ev);
295 state->out_data.length = nread;
296 state->out_remaining = 0;
297 tevent_req_done(req);
298 return tevent_req_post(req, ev);
301 static void smbd_smb2_read_pipe_done(struct tevent_req *subreq)
303 struct tevent_req *req = tevent_req_callback_data(subreq,
305 struct smbd_smb2_read_state *state = tevent_req_data(req,
306 struct smbd_smb2_read_state);
309 bool is_data_outstanding;
311 status = np_read_recv(subreq, &nread, &is_data_outstanding);
313 if (!NT_STATUS_IS_OK(status)) {
314 tevent_req_nterror(req, status);
318 if (nread == 0 && state->out_data.length != 0) {
319 tevent_req_nterror(req, NT_STATUS_END_OF_FILE);
323 state->out_data.length = nread;
324 state->out_remaining = 0;
326 tevent_req_done(req);
329 static NTSTATUS smbd_smb2_read_recv(struct tevent_req *req,
332 uint32_t *out_remaining)
335 struct smbd_smb2_read_state *state = tevent_req_data(req,
336 struct smbd_smb2_read_state);
338 if (tevent_req_is_nterror(req, &status)) {
339 tevent_req_received(req);
343 *out_data = state->out_data;
344 talloc_steal(mem_ctx, out_data->data);
345 *out_remaining = state->out_remaining;
347 tevent_req_received(req);