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 smb_fname
= cp_smb_filename(talloc_tos(), fsp
->fsp_name
);
194 if (smb_fname
== NULL
) {
195 return NT_STATUS_NO_MEMORY
;
198 status
= close_file(smbreq
, fsp
, NORMAL_CLOSE
);
199 if (!NT_STATUS_IS_OK(status
)) {
200 DEBUG(5,("smbd_smb2_close: close_file[%s]: %s\n",
201 fsp_str_dbg(fsp
), nt_errstr(status
)));
205 if (in_flags
& SMB2_CLOSE_FLAGS_FULL_INFORMATION
) {
208 ret
= SMB_VFS_LSTAT(conn
, smb_fname
);
210 ret
= SMB_VFS_STAT(conn
, smb_fname
);
213 flags
= SMB2_CLOSE_FLAGS_FULL_INFORMATION
;
214 dos_attrs
= dos_mode(conn
, smb_fname
);
215 *out_last_write_ts
= smb_fname
->st
.st_ex_mtime
;
216 *out_last_access_ts
= smb_fname
->st
.st_ex_atime
;
217 *out_creation_ts
= get_create_timespec(conn
, NULL
, smb_fname
);
218 *out_change_ts
= get_change_timespec(conn
, NULL
, smb_fname
);
220 if (lp_dos_filetime_resolution(SNUM(conn
))) {
221 dos_filetime_timespec(out_creation_ts
);
222 dos_filetime_timespec(out_last_write_ts
);
223 dos_filetime_timespec(out_last_access_ts
);
224 dos_filetime_timespec(out_change_ts
);
226 if (!(dos_attrs
& FILE_ATTRIBUTE_DIRECTORY
)) {
227 file_size
= get_file_size_stat(&smb_fname
->st
);
230 allocation_size
= SMB_VFS_GET_ALLOC_SIZE(conn
, NULL
, &smb_fname
->st
);
235 *out_allocation_size
= allocation_size
;
236 *out_end_of_file
= file_size
;
237 *out_file_attributes
= dos_attrs
;
242 struct smbd_smb2_close_state
{
243 struct smbd_smb2_request
*smb2req
;
244 struct files_struct
*in_fsp
;
247 struct timespec out_creation_ts
;
248 struct timespec out_last_access_ts
;
249 struct timespec out_last_write_ts
;
250 struct timespec out_change_ts
;
251 uint64_t out_allocation_size
;
252 uint64_t out_end_of_file
;
253 uint32_t out_file_attributes
;
256 static void smbd_smb2_close_do(struct tevent_req
*subreq
);
258 static struct tevent_req
*smbd_smb2_close_send(TALLOC_CTX
*mem_ctx
,
259 struct tevent_context
*ev
,
260 struct smbd_smb2_request
*smb2req
,
261 struct files_struct
*in_fsp
,
264 struct tevent_req
*req
;
265 struct smbd_smb2_close_state
*state
;
268 req
= tevent_req_create(mem_ctx
, &state
,
269 struct smbd_smb2_close_state
);
273 state
->smb2req
= smb2req
;
274 state
->in_fsp
= in_fsp
;
275 state
->in_flags
= in_flags
;
277 if (in_fsp
->num_aio_requests
!= 0) {
279 in_fsp
->deferred_close
= tevent_wait_send(in_fsp
, ev
);
280 if (tevent_req_nomem(in_fsp
->deferred_close
, req
)) {
281 return tevent_req_post(req
, ev
);
283 tevent_req_set_callback(in_fsp
->deferred_close
,
284 smbd_smb2_close_do
, req
);
288 status
= smbd_smb2_close(smb2req
,
292 &state
->out_creation_ts
,
293 &state
->out_last_access_ts
,
294 &state
->out_last_write_ts
,
295 &state
->out_change_ts
,
296 &state
->out_allocation_size
,
297 &state
->out_end_of_file
,
298 &state
->out_file_attributes
);
299 if (tevent_req_nterror(req
, status
)) {
300 return tevent_req_post(req
, ev
);
303 tevent_req_done(req
);
304 return tevent_req_post(req
, ev
);
307 static void smbd_smb2_close_do(struct tevent_req
*subreq
)
309 struct tevent_req
*req
= tevent_req_callback_data(
310 subreq
, struct tevent_req
);
311 struct smbd_smb2_close_state
*state
= tevent_req_data(
312 req
, struct smbd_smb2_close_state
);
316 ret
= tevent_wait_recv(subreq
);
319 DEBUG(10, ("tevent_wait_recv returned %s\n",
322 * Continue anyway, this should never happen
326 status
= smbd_smb2_close(state
->smb2req
,
330 &state
->out_creation_ts
,
331 &state
->out_last_access_ts
,
332 &state
->out_last_write_ts
,
333 &state
->out_change_ts
,
334 &state
->out_allocation_size
,
335 &state
->out_end_of_file
,
336 &state
->out_file_attributes
);
337 if (tevent_req_nterror(req
, status
)) {
340 tevent_req_done(req
);
343 static NTSTATUS
smbd_smb2_close_recv(struct tevent_req
*req
,
345 struct timespec
*out_creation_ts
,
346 struct timespec
*out_last_access_ts
,
347 struct timespec
*out_last_write_ts
,
348 struct timespec
*out_change_ts
,
349 uint64_t *out_allocation_size
,
350 uint64_t *out_end_of_file
,
351 uint32_t *out_file_attributes
)
353 struct smbd_smb2_close_state
*state
=
355 struct smbd_smb2_close_state
);
358 if (tevent_req_is_nterror(req
, &status
)) {
359 tevent_req_received(req
);
363 *out_flags
= state
->out_flags
;
364 *out_creation_ts
= state
->out_creation_ts
;
365 *out_last_access_ts
= state
->out_last_access_ts
;
366 *out_last_write_ts
= state
->out_last_write_ts
;
367 *out_change_ts
= state
->out_change_ts
;
368 *out_allocation_size
= state
->out_allocation_size
;
369 *out_end_of_file
= state
->out_end_of_file
;
370 *out_file_attributes
= state
->out_file_attributes
;
372 tevent_req_received(req
);