s3:smbd: s/struct timed_event/struct tevent_timer
[Samba/gebeck_regimport.git] / source3 / smbd / smb2_close.c
blobee168c546609f19512f5bb868b53156d4f35eb07
1 /*
2 Unix SMB/CIFS implementation.
3 Core SMB2 server
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/>.
21 #include "includes.h"
22 #include "smbd/smbd.h"
23 #include "smbd/globals.h"
24 #include "../libcli/smb/smb_common.h"
25 #include "../lib/util/tevent_ntstatus.h"
26 #include "lib/tevent_wait.h"
28 static struct tevent_req *smbd_smb2_close_send(TALLOC_CTX *mem_ctx,
29 struct tevent_context *ev,
30 struct smbd_smb2_request *smb2req,
31 struct files_struct *in_fsp,
32 uint16_t in_flags);
33 static NTSTATUS smbd_smb2_close_recv(struct tevent_req *req,
34 uint16_t *out_flags,
35 NTTIME *out_creation_time,
36 NTTIME *out_last_access_time,
37 NTTIME *out_last_write_time,
38 NTTIME *out_change_time,
39 uint64_t *out_allocation_size,
40 uint64_t *out_end_of_file,
41 uint32_t *out_file_attributes);
43 static void smbd_smb2_request_close_done(struct tevent_req *subreq);
45 NTSTATUS smbd_smb2_request_process_close(struct smbd_smb2_request *req)
47 const uint8_t *inbody;
48 uint16_t in_flags;
49 uint64_t in_file_id_persistent;
50 uint64_t in_file_id_volatile;
51 struct files_struct *in_fsp;
52 NTSTATUS status;
53 struct tevent_req *subreq;
55 status = smbd_smb2_request_verify_sizes(req, 0x18);
56 if (!NT_STATUS_IS_OK(status)) {
57 return smbd_smb2_request_error(req, status);
59 inbody = SMBD_SMB2_IN_BODY_PTR(req);
61 in_flags = SVAL(inbody, 0x02);
62 in_file_id_persistent = BVAL(inbody, 0x08);
63 in_file_id_volatile = BVAL(inbody, 0x10);
65 in_fsp = file_fsp_smb2(req, in_file_id_persistent, in_file_id_volatile);
66 if (in_fsp == NULL) {
67 return smbd_smb2_request_error(req, NT_STATUS_FILE_CLOSED);
70 subreq = smbd_smb2_close_send(req, req->sconn->ev_ctx,
71 req, in_fsp, in_flags);
72 if (subreq == NULL) {
73 return smbd_smb2_request_error(req, NT_STATUS_NO_MEMORY);
75 tevent_req_set_callback(subreq, smbd_smb2_request_close_done, req);
77 return smbd_smb2_request_pending_queue(req, subreq, 500);
80 static void smbd_smb2_request_close_done(struct tevent_req *subreq)
82 struct smbd_smb2_request *req =
83 tevent_req_callback_data(subreq,
84 struct smbd_smb2_request);
85 DATA_BLOB outbody;
86 uint16_t out_flags;
87 NTTIME out_creation_time;
88 NTTIME out_last_access_time;
89 NTTIME out_last_write_time;
90 NTTIME out_change_time;
91 uint64_t out_allocation_size;
92 uint64_t out_end_of_file;
93 uint32_t out_file_attributes;
94 NTSTATUS status;
95 NTSTATUS error;
97 status = smbd_smb2_close_recv(subreq,
98 &out_flags,
99 &out_creation_time,
100 &out_last_access_time,
101 &out_last_write_time,
102 &out_change_time,
103 &out_allocation_size,
104 &out_end_of_file,
105 &out_file_attributes);
106 TALLOC_FREE(subreq);
107 if (!NT_STATUS_IS_OK(status)) {
108 error = smbd_smb2_request_error(req, status);
109 if (!NT_STATUS_IS_OK(error)) {
110 smbd_server_connection_terminate(req->sconn,
111 nt_errstr(error));
112 return;
114 return;
117 outbody = data_blob_talloc(req->out.vector, NULL, 0x3C);
118 if (outbody.data == NULL) {
119 error = smbd_smb2_request_error(req, NT_STATUS_NO_MEMORY);
120 if (!NT_STATUS_IS_OK(error)) {
121 smbd_server_connection_terminate(req->sconn,
122 nt_errstr(error));
123 return;
125 return;
128 SSVAL(outbody.data, 0x00, 0x3C); /* struct size */
129 SSVAL(outbody.data, 0x02, out_flags);
130 SIVAL(outbody.data, 0x04, 0); /* reserved */
131 SBVAL(outbody.data, 0x08, out_creation_time);
132 SBVAL(outbody.data, 0x10, out_last_access_time);
133 SBVAL(outbody.data, 0x18, out_last_write_time);
134 SBVAL(outbody.data, 0x20, out_change_time);
135 SBVAL(outbody.data, 0x28, out_allocation_size);
136 SBVAL(outbody.data, 0x30, out_end_of_file);
137 SIVAL(outbody.data, 0x38, out_file_attributes);
139 error = smbd_smb2_request_done(req, outbody, NULL);
140 if (!NT_STATUS_IS_OK(error)) {
141 smbd_server_connection_terminate(req->sconn,
142 nt_errstr(error));
143 return;
147 static NTSTATUS smbd_smb2_close(struct smbd_smb2_request *req,
148 struct files_struct *fsp,
149 uint16_t in_flags,
150 uint16_t *out_flags,
151 NTTIME *out_creation_time,
152 NTTIME *out_last_access_time,
153 NTTIME *out_last_write_time,
154 NTTIME *out_change_time,
155 uint64_t *out_allocation_size,
156 uint64_t *out_end_of_file,
157 uint32_t *out_file_attributes)
159 NTSTATUS status;
160 struct smb_request *smbreq;
161 connection_struct *conn = req->tcon->compat;
162 struct smb_filename *smb_fname = NULL;
163 struct timespec mdate_ts, adate_ts, cdate_ts, create_date_ts;
164 uint64_t allocation_size = 0;
165 uint64_t file_size = 0;
166 uint32_t dos_attrs = 0;
167 uint16_t flags = 0;
168 bool posix_open = false;
170 ZERO_STRUCT(create_date_ts);
171 ZERO_STRUCT(adate_ts);
172 ZERO_STRUCT(mdate_ts);
173 ZERO_STRUCT(cdate_ts);
175 *out_flags = 0;
176 *out_creation_time = 0;
177 *out_last_access_time = 0;
178 *out_last_write_time = 0;
179 *out_change_time = 0;
180 *out_allocation_size = 0;
181 *out_end_of_file = 0;
182 *out_file_attributes = 0;
184 DEBUG(10,("smbd_smb2_close: %s - %s\n",
185 fsp_str_dbg(fsp), fsp_fnum_dbg(fsp)));
187 smbreq = smbd_smb2_fake_smb_request(req);
188 if (smbreq == NULL) {
189 return NT_STATUS_NO_MEMORY;
192 posix_open = fsp->posix_open;
193 status = copy_smb_filename(talloc_tos(),
194 fsp->fsp_name,
195 &smb_fname);
196 if (!NT_STATUS_IS_OK(status)) {
197 return status;
200 status = close_file(smbreq, fsp, NORMAL_CLOSE);
201 if (!NT_STATUS_IS_OK(status)) {
202 DEBUG(5,("smbd_smb2_close: close_file[%s]: %s\n",
203 fsp_str_dbg(fsp), nt_errstr(status)));
204 return status;
207 if (in_flags & SMB2_CLOSE_FLAGS_FULL_INFORMATION) {
208 int ret;
209 if (posix_open) {
210 ret = SMB_VFS_LSTAT(conn, smb_fname);
211 } else {
212 ret = SMB_VFS_STAT(conn, smb_fname);
214 if (ret == 0) {
215 flags = SMB2_CLOSE_FLAGS_FULL_INFORMATION;
216 dos_attrs = dos_mode(conn, smb_fname);
217 mdate_ts = smb_fname->st.st_ex_mtime;
218 adate_ts = smb_fname->st.st_ex_atime;
219 create_date_ts = get_create_timespec(conn, NULL, smb_fname);
220 cdate_ts = get_change_timespec(conn, NULL, smb_fname);
222 if (lp_dos_filetime_resolution(SNUM(conn))) {
223 dos_filetime_timespec(&create_date_ts);
224 dos_filetime_timespec(&mdate_ts);
225 dos_filetime_timespec(&adate_ts);
226 dos_filetime_timespec(&cdate_ts);
228 if (!(dos_attrs & FILE_ATTRIBUTE_DIRECTORY)) {
229 file_size = get_file_size_stat(&smb_fname->st);
232 allocation_size = SMB_VFS_GET_ALLOC_SIZE(conn, NULL, &smb_fname->st);
236 *out_flags = flags;
238 round_timespec(conn->ts_res, &create_date_ts);
239 unix_timespec_to_nt_time(out_creation_time, create_date_ts);
241 round_timespec(conn->ts_res, &adate_ts);
242 unix_timespec_to_nt_time(out_last_access_time, adate_ts);
244 round_timespec(conn->ts_res, &mdate_ts);
245 unix_timespec_to_nt_time(out_last_write_time, mdate_ts);
247 round_timespec(conn->ts_res, &cdate_ts);
248 unix_timespec_to_nt_time(out_change_time, cdate_ts);
250 *out_allocation_size = allocation_size;
251 *out_end_of_file = file_size;
252 *out_file_attributes = dos_attrs;
254 return NT_STATUS_OK;
257 struct smbd_smb2_close_state {
258 struct smbd_smb2_request *smb2req;
259 struct files_struct *in_fsp;
260 uint16_t in_flags;
261 uint16_t out_flags;
262 NTTIME out_creation_time;
263 NTTIME out_last_access_time;
264 NTTIME out_last_write_time;
265 NTTIME out_change_time;
266 uint64_t out_allocation_size;
267 uint64_t out_end_of_file;
268 uint32_t out_file_attributes;
271 static void smbd_smb2_close_do(struct tevent_req *subreq);
273 static struct tevent_req *smbd_smb2_close_send(TALLOC_CTX *mem_ctx,
274 struct tevent_context *ev,
275 struct smbd_smb2_request *smb2req,
276 struct files_struct *in_fsp,
277 uint16_t in_flags)
279 struct tevent_req *req;
280 struct smbd_smb2_close_state *state;
281 NTSTATUS status;
283 req = tevent_req_create(mem_ctx, &state,
284 struct smbd_smb2_close_state);
285 if (req == NULL) {
286 return NULL;
288 state->smb2req = smb2req;
289 state->in_fsp = in_fsp;
290 state->in_flags = in_flags;
292 if (in_fsp->num_aio_requests != 0) {
294 in_fsp->deferred_close = tevent_wait_send(in_fsp, ev);
295 if (tevent_req_nomem(in_fsp->deferred_close, req)) {
296 return tevent_req_post(req, ev);
298 tevent_req_set_callback(in_fsp->deferred_close,
299 smbd_smb2_close_do, req);
300 return req;
303 status = smbd_smb2_close(smb2req,
304 state->in_fsp,
305 state->in_flags,
306 &state->out_flags,
307 &state->out_creation_time,
308 &state->out_last_access_time,
309 &state->out_last_write_time,
310 &state->out_change_time,
311 &state->out_allocation_size,
312 &state->out_end_of_file,
313 &state->out_file_attributes);
314 if (tevent_req_nterror(req, status)) {
315 return tevent_req_post(req, ev);
318 tevent_req_done(req);
319 return tevent_req_post(req, ev);
322 static void smbd_smb2_close_do(struct tevent_req *subreq)
324 struct tevent_req *req = tevent_req_callback_data(
325 subreq, struct tevent_req);
326 struct smbd_smb2_close_state *state = tevent_req_data(
327 req, struct smbd_smb2_close_state);
328 NTSTATUS status;
329 int ret;
331 ret = tevent_wait_recv(subreq);
332 TALLOC_FREE(subreq);
333 if (ret != 0) {
334 DEBUG(10, ("tevent_wait_recv returned %s\n",
335 strerror(ret)));
337 * Continue anyway, this should never happen
341 status = smbd_smb2_close(state->smb2req,
342 state->in_fsp,
343 state->in_flags,
344 &state->out_flags,
345 &state->out_creation_time,
346 &state->out_last_access_time,
347 &state->out_last_write_time,
348 &state->out_change_time,
349 &state->out_allocation_size,
350 &state->out_end_of_file,
351 &state->out_file_attributes);
352 if (tevent_req_nterror(req, status)) {
353 return;
355 tevent_req_done(req);
358 static NTSTATUS smbd_smb2_close_recv(struct tevent_req *req,
359 uint16_t *out_flags,
360 NTTIME *out_creation_time,
361 NTTIME *out_last_access_time,
362 NTTIME *out_last_write_time,
363 NTTIME *out_change_time,
364 uint64_t *out_allocation_size,
365 uint64_t *out_end_of_file,
366 uint32_t *out_file_attributes)
368 struct smbd_smb2_close_state *state =
369 tevent_req_data(req,
370 struct smbd_smb2_close_state);
371 NTSTATUS status;
373 if (tevent_req_is_nterror(req, &status)) {
374 tevent_req_received(req);
375 return status;
378 *out_flags = state->out_flags;
379 *out_creation_time = state->out_creation_time;
380 *out_last_access_time = state->out_last_access_time;
381 *out_last_write_time = state->out_last_write_time;
382 *out_change_time = state->out_change_time;
383 *out_allocation_size = state->out_allocation_size;
384 *out_end_of_file = state->out_end_of_file;
385 *out_file_attributes = state->out_file_attributes;
387 tevent_req_received(req);
388 return NT_STATUS_OK;