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/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
,
33 static NTSTATUS
smbd_smb2_close_recv(struct tevent_req
*req
,
35 struct timespec
*out_creation_ts
,
36 struct timespec
*out_last_access_ts
,
37 struct timespec
*out_last_write_ts
,
38 struct timespec
*out_change_ts
,
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
;
49 uint64_t in_file_id_persistent
;
50 uint64_t in_file_id_volatile
;
51 struct files_struct
*in_fsp
;
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
);
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
);
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
);
87 connection_struct
*conn
= req
->tcon
->compat
;
88 struct timespec out_creation_ts
= { 0, };
89 struct timespec out_last_access_ts
= { 0, };
90 struct timespec out_last_write_ts
= { 0, };
91 struct timespec out_change_ts
= { 0, };
92 uint64_t out_allocation_size
;
93 uint64_t out_end_of_file
;
94 uint32_t out_file_attributes
;
98 status
= smbd_smb2_close_recv(subreq
,
104 &out_allocation_size
,
106 &out_file_attributes
);
108 if (!NT_STATUS_IS_OK(status
)) {
109 error
= smbd_smb2_request_error(req
, status
);
110 if (!NT_STATUS_IS_OK(error
)) {
111 smbd_server_connection_terminate(req
->sconn
,
118 outbody
= data_blob_talloc(req
->out
.vector
, NULL
, 0x3C);
119 if (outbody
.data
== NULL
) {
120 error
= smbd_smb2_request_error(req
, NT_STATUS_NO_MEMORY
);
121 if (!NT_STATUS_IS_OK(error
)) {
122 smbd_server_connection_terminate(req
->sconn
,
129 SSVAL(outbody
.data
, 0x00, 0x3C); /* struct size */
130 SSVAL(outbody
.data
, 0x02, out_flags
);
131 SIVAL(outbody
.data
, 0x04, 0); /* reserved */
132 put_long_date_timespec(conn
->ts_res
,
133 (char *)outbody
.data
+ 0x08, out_creation_ts
);
134 put_long_date_timespec(conn
->ts_res
,
135 (char *)outbody
.data
+ 0x10, out_last_access_ts
);
136 put_long_date_timespec(conn
->ts_res
,
137 (char *)outbody
.data
+ 0x18, out_last_write_ts
);
138 put_long_date_timespec(conn
->ts_res
,
139 (char *)outbody
.data
+ 0x20, out_change_ts
);
140 SBVAL(outbody
.data
, 0x28, out_allocation_size
);
141 SBVAL(outbody
.data
, 0x30, out_end_of_file
);
142 SIVAL(outbody
.data
, 0x38, out_file_attributes
);
144 error
= smbd_smb2_request_done(req
, outbody
, NULL
);
145 if (!NT_STATUS_IS_OK(error
)) {
146 smbd_server_connection_terminate(req
->sconn
,
152 static NTSTATUS
smbd_smb2_close(struct smbd_smb2_request
*req
,
153 struct files_struct
*fsp
,
156 struct timespec
*out_creation_ts
,
157 struct timespec
*out_last_access_ts
,
158 struct timespec
*out_last_write_ts
,
159 struct timespec
*out_change_ts
,
160 uint64_t *out_allocation_size
,
161 uint64_t *out_end_of_file
,
162 uint32_t *out_file_attributes
)
165 struct smb_request
*smbreq
;
166 connection_struct
*conn
= req
->tcon
->compat
;
167 struct smb_filename
*smb_fname
= NULL
;
168 uint64_t allocation_size
= 0;
169 uint64_t file_size
= 0;
170 uint32_t dos_attrs
= 0;
172 bool posix_open
= false;
174 ZERO_STRUCTP(out_creation_ts
);
175 ZERO_STRUCTP(out_last_access_ts
);
176 ZERO_STRUCTP(out_last_write_ts
);
177 ZERO_STRUCTP(out_change_ts
);
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(),
196 if (!NT_STATUS_IS_OK(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
)));
207 if (in_flags
& SMB2_CLOSE_FLAGS_FULL_INFORMATION
) {
210 ret
= SMB_VFS_LSTAT(conn
, smb_fname
);
212 ret
= SMB_VFS_STAT(conn
, smb_fname
);
215 flags
= SMB2_CLOSE_FLAGS_FULL_INFORMATION
;
216 dos_attrs
= dos_mode(conn
, smb_fname
);
217 *out_last_write_ts
= smb_fname
->st
.st_ex_mtime
;
218 *out_last_access_ts
= smb_fname
->st
.st_ex_atime
;
219 *out_creation_ts
= get_create_timespec(conn
, NULL
, smb_fname
);
220 *out_change_ts
= get_change_timespec(conn
, NULL
, smb_fname
);
222 if (lp_dos_filetime_resolution(SNUM(conn
))) {
223 dos_filetime_timespec(out_creation_ts
);
224 dos_filetime_timespec(out_last_write_ts
);
225 dos_filetime_timespec(out_last_access_ts
);
226 dos_filetime_timespec(out_change_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
);
237 *out_allocation_size
= allocation_size
;
238 *out_end_of_file
= file_size
;
239 *out_file_attributes
= dos_attrs
;
244 struct smbd_smb2_close_state
{
245 struct smbd_smb2_request
*smb2req
;
246 struct files_struct
*in_fsp
;
249 struct timespec out_creation_ts
;
250 struct timespec out_last_access_ts
;
251 struct timespec out_last_write_ts
;
252 struct timespec out_change_ts
;
253 uint64_t out_allocation_size
;
254 uint64_t out_end_of_file
;
255 uint32_t out_file_attributes
;
258 static void smbd_smb2_close_do(struct tevent_req
*subreq
);
260 static struct tevent_req
*smbd_smb2_close_send(TALLOC_CTX
*mem_ctx
,
261 struct tevent_context
*ev
,
262 struct smbd_smb2_request
*smb2req
,
263 struct files_struct
*in_fsp
,
266 struct tevent_req
*req
;
267 struct smbd_smb2_close_state
*state
;
270 req
= tevent_req_create(mem_ctx
, &state
,
271 struct smbd_smb2_close_state
);
275 state
->smb2req
= smb2req
;
276 state
->in_fsp
= in_fsp
;
277 state
->in_flags
= in_flags
;
279 if (in_fsp
->num_aio_requests
!= 0) {
281 in_fsp
->deferred_close
= tevent_wait_send(in_fsp
, ev
);
282 if (tevent_req_nomem(in_fsp
->deferred_close
, req
)) {
283 return tevent_req_post(req
, ev
);
285 tevent_req_set_callback(in_fsp
->deferred_close
,
286 smbd_smb2_close_do
, req
);
290 status
= smbd_smb2_close(smb2req
,
294 &state
->out_creation_ts
,
295 &state
->out_last_access_ts
,
296 &state
->out_last_write_ts
,
297 &state
->out_change_ts
,
298 &state
->out_allocation_size
,
299 &state
->out_end_of_file
,
300 &state
->out_file_attributes
);
301 if (tevent_req_nterror(req
, status
)) {
302 return tevent_req_post(req
, ev
);
305 tevent_req_done(req
);
306 return tevent_req_post(req
, ev
);
309 static void smbd_smb2_close_do(struct tevent_req
*subreq
)
311 struct tevent_req
*req
= tevent_req_callback_data(
312 subreq
, struct tevent_req
);
313 struct smbd_smb2_close_state
*state
= tevent_req_data(
314 req
, struct smbd_smb2_close_state
);
318 ret
= tevent_wait_recv(subreq
);
321 DEBUG(10, ("tevent_wait_recv returned %s\n",
324 * Continue anyway, this should never happen
328 status
= smbd_smb2_close(state
->smb2req
,
332 &state
->out_creation_ts
,
333 &state
->out_last_access_ts
,
334 &state
->out_last_write_ts
,
335 &state
->out_change_ts
,
336 &state
->out_allocation_size
,
337 &state
->out_end_of_file
,
338 &state
->out_file_attributes
);
339 if (tevent_req_nterror(req
, status
)) {
342 tevent_req_done(req
);
345 static NTSTATUS
smbd_smb2_close_recv(struct tevent_req
*req
,
347 struct timespec
*out_creation_ts
,
348 struct timespec
*out_last_access_ts
,
349 struct timespec
*out_last_write_ts
,
350 struct timespec
*out_change_ts
,
351 uint64_t *out_allocation_size
,
352 uint64_t *out_end_of_file
,
353 uint32_t *out_file_attributes
)
355 struct smbd_smb2_close_state
*state
=
357 struct smbd_smb2_close_state
);
360 if (tevent_req_is_nterror(req
, &status
)) {
361 tevent_req_received(req
);
365 *out_flags
= state
->out_flags
;
366 *out_creation_ts
= state
->out_creation_ts
;
367 *out_last_access_ts
= state
->out_last_access_ts
;
368 *out_last_write_ts
= state
->out_last_write_ts
;
369 *out_change_ts
= state
->out_change_ts
;
370 *out_allocation_size
= state
->out_allocation_size
;
371 *out_end_of_file
= state
->out_end_of_file
;
372 *out_file_attributes
= state
->out_file_attributes
;
374 tevent_req_received(req
);