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"
26 #include "../lib/util/tevent_ntstatus.h"
28 static struct tevent_req
*smbd_smb2_find_send(TALLOC_CTX
*mem_ctx
,
29 struct tevent_context
*ev
,
30 struct smbd_smb2_request
*smb2req
,
31 struct files_struct
*in_fsp
,
32 uint8_t in_file_info_class
,
34 uint32_t in_file_index
,
35 uint32_t in_output_buffer_length
,
36 const char *in_file_name
);
37 static NTSTATUS
smbd_smb2_find_recv(struct tevent_req
*req
,
39 DATA_BLOB
*out_output_buffer
);
41 static void smbd_smb2_request_find_done(struct tevent_req
*subreq
);
42 NTSTATUS
smbd_smb2_request_process_find(struct smbd_smb2_request
*req
)
45 const uint8_t *inbody
;
46 uint8_t in_file_info_class
;
48 uint32_t in_file_index
;
49 uint64_t in_file_id_persistent
;
50 uint64_t in_file_id_volatile
;
51 struct files_struct
*in_fsp
;
52 uint16_t in_file_name_offset
;
53 uint16_t in_file_name_length
;
54 DATA_BLOB in_file_name_buffer
;
55 char *in_file_name_string
;
56 size_t in_file_name_string_size
;
57 uint32_t in_output_buffer_length
;
58 struct tevent_req
*subreq
;
61 status
= smbd_smb2_request_verify_sizes(req
, 0x21);
62 if (!NT_STATUS_IS_OK(status
)) {
63 return smbd_smb2_request_error(req
, status
);
65 inbody
= SMBD_SMB2_IN_BODY_PTR(req
);
67 in_file_info_class
= CVAL(inbody
, 0x02);
68 in_flags
= CVAL(inbody
, 0x03);
69 in_file_index
= IVAL(inbody
, 0x04);
70 in_file_id_persistent
= BVAL(inbody
, 0x08);
71 in_file_id_volatile
= BVAL(inbody
, 0x10);
72 in_file_name_offset
= SVAL(inbody
, 0x18);
73 in_file_name_length
= SVAL(inbody
, 0x1A);
74 in_output_buffer_length
= IVAL(inbody
, 0x1C);
76 if (in_file_name_offset
== 0 && in_file_name_length
== 0) {
78 } else if (in_file_name_offset
!=
79 (SMB2_HDR_BODY
+ SMBD_SMB2_IN_BODY_LEN(req
))) {
80 return smbd_smb2_request_error(req
, NT_STATUS_INVALID_PARAMETER
);
83 if (in_file_name_length
> SMBD_SMB2_IN_DYN_LEN(req
)) {
84 return smbd_smb2_request_error(req
, NT_STATUS_INVALID_PARAMETER
);
87 /* The output header is 8 bytes. */
88 if (in_output_buffer_length
<= 8) {
89 return smbd_smb2_request_error(req
, NT_STATUS_INVALID_PARAMETER
);
92 DEBUG(10,("smbd_smb2_request_find_done: in_output_buffer_length = %u\n",
93 (unsigned int)in_output_buffer_length
));
95 /* Take into account the output header. */
96 in_output_buffer_length
-= 8;
98 in_file_name_buffer
.data
= SMBD_SMB2_IN_DYN_PTR(req
);
99 in_file_name_buffer
.length
= in_file_name_length
;
101 ok
= convert_string_talloc(req
, CH_UTF16
, CH_UNIX
,
102 in_file_name_buffer
.data
,
103 in_file_name_buffer
.length
,
104 &in_file_name_string
,
105 &in_file_name_string_size
);
107 return smbd_smb2_request_error(req
, NT_STATUS_ILLEGAL_CHARACTER
);
110 if (in_file_name_buffer
.length
== 0) {
111 in_file_name_string_size
= 0;
114 if (strlen(in_file_name_string
) != in_file_name_string_size
) {
115 return smbd_smb2_request_error(req
, NT_STATUS_OBJECT_NAME_INVALID
);
118 in_fsp
= file_fsp_smb2(req
, in_file_id_persistent
, in_file_id_volatile
);
119 if (in_fsp
== NULL
) {
120 return smbd_smb2_request_error(req
, NT_STATUS_FILE_CLOSED
);
123 subreq
= smbd_smb2_find_send(req
, req
->sconn
->ev_ctx
,
128 in_output_buffer_length
,
129 in_file_name_string
);
130 if (subreq
== NULL
) {
131 return smbd_smb2_request_error(req
, NT_STATUS_NO_MEMORY
);
133 tevent_req_set_callback(subreq
, smbd_smb2_request_find_done
, req
);
135 return smbd_smb2_request_pending_queue(req
, subreq
, 500);
138 static void smbd_smb2_request_find_done(struct tevent_req
*subreq
)
140 struct smbd_smb2_request
*req
= tevent_req_callback_data(subreq
,
141 struct smbd_smb2_request
);
144 uint16_t out_output_buffer_offset
;
145 DATA_BLOB out_output_buffer
= data_blob_null
;
147 NTSTATUS error
; /* transport error */
149 status
= smbd_smb2_find_recv(subreq
,
153 if (!NT_STATUS_IS_OK(status
)) {
154 error
= smbd_smb2_request_error(req
, status
);
155 if (!NT_STATUS_IS_OK(error
)) {
156 smbd_server_connection_terminate(req
->sconn
,
163 out_output_buffer_offset
= SMB2_HDR_BODY
+ 0x08;
165 outbody
= data_blob_talloc(req
->out
.vector
, NULL
, 0x08);
166 if (outbody
.data
== NULL
) {
167 error
= smbd_smb2_request_error(req
, NT_STATUS_NO_MEMORY
);
168 if (!NT_STATUS_IS_OK(error
)) {
169 smbd_server_connection_terminate(req
->sconn
,
176 SSVAL(outbody
.data
, 0x00, 0x08 + 1); /* struct size */
177 SSVAL(outbody
.data
, 0x02,
178 out_output_buffer_offset
); /* output buffer offset */
179 SIVAL(outbody
.data
, 0x04,
180 out_output_buffer
.length
); /* output buffer length */
182 DEBUG(10,("smbd_smb2_request_find_done: out_output_buffer.length = %u\n",
183 (unsigned int)out_output_buffer
.length
));
185 outdyn
= out_output_buffer
;
187 error
= smbd_smb2_request_done(req
, outbody
, &outdyn
);
188 if (!NT_STATUS_IS_OK(error
)) {
189 smbd_server_connection_terminate(req
->sconn
,
195 struct smbd_smb2_find_state
{
196 struct smbd_smb2_request
*smb2req
;
197 DATA_BLOB out_output_buffer
;
200 static struct tevent_req
*smbd_smb2_find_send(TALLOC_CTX
*mem_ctx
,
201 struct tevent_context
*ev
,
202 struct smbd_smb2_request
*smb2req
,
203 struct files_struct
*fsp
,
204 uint8_t in_file_info_class
,
206 uint32_t in_file_index
,
207 uint32_t in_output_buffer_length
,
208 const char *in_file_name
)
210 struct tevent_req
*req
;
211 struct smbd_smb2_find_state
*state
;
212 struct smb_request
*smbreq
;
213 connection_struct
*conn
= smb2req
->tcon
->compat
;
215 NTSTATUS empty_status
;
221 int last_entry_off
= 0;
224 uint32_t dirtype
= FILE_ATTRIBUTE_HIDDEN
| FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_DIRECTORY
;
225 bool dont_descend
= false;
226 bool ask_sharemode
= true;
231 req
= tevent_req_create(mem_ctx
, &state
,
232 struct smbd_smb2_find_state
);
236 state
->smb2req
= smb2req
;
237 state
->out_output_buffer
= data_blob_null
;
239 DEBUG(10,("smbd_smb2_find_send: %s - %s\n",
240 fsp_str_dbg(fsp
), fsp_fnum_dbg(fsp
)));
242 smbreq
= smbd_smb2_fake_smb_request(smb2req
);
243 if (tevent_req_nomem(smbreq
, req
)) {
244 return tevent_req_post(req
, ev
);
247 if (!fsp
->is_directory
) {
248 tevent_req_nterror(req
, NT_STATUS_NOT_SUPPORTED
);
249 return tevent_req_post(req
, ev
);
252 if (strcmp(in_file_name
, "") == 0) {
253 tevent_req_nterror(req
, NT_STATUS_OBJECT_NAME_INVALID
);
254 return tevent_req_post(req
, ev
);
256 if (strchr_m(in_file_name
, '\\') != NULL
) {
257 tevent_req_nterror(req
, NT_STATUS_OBJECT_NAME_INVALID
);
258 return tevent_req_post(req
, ev
);
260 if (strchr_m(in_file_name
, '/') != NULL
) {
261 tevent_req_nterror(req
, NT_STATUS_OBJECT_NAME_INVALID
);
262 return tevent_req_post(req
, ev
);
265 p
= strptime(in_file_name
, GMT_FORMAT
, &tm
);
266 if ((p
!= NULL
) && (*p
=='\0')) {
268 * Bogus find that asks for a shadow copy timestamp as a
269 * directory. The correct response is that it does not exist as
272 tevent_req_nterror(req
, NT_STATUS_NO_SUCH_FILE
);
273 return tevent_req_post(req
, ev
);
276 if (in_output_buffer_length
> smb2req
->sconn
->smb2
.max_trans
) {
277 DEBUG(2,("smbd_smb2_find_send: "
278 "client ignored max trans:%s: 0x%08X: 0x%08X\n",
279 __location__
, in_output_buffer_length
,
280 smb2req
->sconn
->smb2
.max_trans
));
281 tevent_req_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
282 return tevent_req_post(req
, ev
);
285 status
= smbd_smb2_request_verify_creditcharge(smb2req
,
286 in_output_buffer_length
);
288 if (!NT_STATUS_IS_OK(status
)) {
289 tevent_req_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
290 return tevent_req_post(req
, ev
);
293 switch (in_file_info_class
) {
294 case SMB2_FIND_DIRECTORY_INFO
:
295 info_level
= SMB_FIND_FILE_DIRECTORY_INFO
;
298 case SMB2_FIND_FULL_DIRECTORY_INFO
:
299 info_level
= SMB_FIND_FILE_FULL_DIRECTORY_INFO
;
302 case SMB2_FIND_BOTH_DIRECTORY_INFO
:
303 info_level
= SMB_FIND_FILE_BOTH_DIRECTORY_INFO
;
306 case SMB2_FIND_NAME_INFO
:
307 info_level
= SMB_FIND_FILE_NAMES_INFO
;
310 case SMB2_FIND_ID_BOTH_DIRECTORY_INFO
:
311 info_level
= SMB_FIND_ID_BOTH_DIRECTORY_INFO
;
314 case SMB2_FIND_ID_FULL_DIRECTORY_INFO
:
315 info_level
= SMB_FIND_ID_FULL_DIRECTORY_INFO
;
319 tevent_req_nterror(req
, NT_STATUS_INVALID_INFO_CLASS
);
320 return tevent_req_post(req
, ev
);
323 if (in_flags
& SMB2_CONTINUE_FLAG_REOPEN
) {
327 wcard_has_wild
= ms_has_wild(in_file_name
);
329 /* Ensure we've canonicalized any search path if not a wildcard. */
330 if (!wcard_has_wild
) {
331 struct smb_filename
*smb_fname
= NULL
;
332 const char *fullpath
;
334 if (ISDOT(fsp
->fsp_name
->base_name
)) {
335 fullpath
= in_file_name
;
337 fullpath
= talloc_asprintf(state
,
339 fsp
->fsp_name
->base_name
,
342 if (tevent_req_nomem(fullpath
, req
)) {
343 return tevent_req_post(req
, ev
);
345 status
= filename_convert(state
,
347 false, /* Not a DFS path. */
349 UCF_SAVE_LCOMP
| UCF_ALWAYS_ALLOW_WCARD_LCOMP
,
353 if (!NT_STATUS_IS_OK(status
)) {
354 tevent_req_nterror(req
, status
);
355 return tevent_req_post(req
, ev
);
358 in_file_name
= smb_fname
->original_lcomp
;
361 if (fsp
->dptr
== NULL
) {
362 status
= dptr_create(conn
,
365 fsp
->fsp_name
->base_name
,
366 false, /* old_handle */
367 false, /* expect_close */
369 in_file_name
, /* wcard */
373 if (!NT_STATUS_IS_OK(status
)) {
374 tevent_req_nterror(req
, status
);
375 return tevent_req_post(req
, ev
);
378 empty_status
= NT_STATUS_NO_SUCH_FILE
;
380 empty_status
= STATUS_NO_MORE_FILES
;
383 if (in_flags
& SMB2_CONTINUE_FLAG_RESTART
) {
384 dptr_SeekDir(fsp
->dptr
, 0);
387 if (in_flags
& SMB2_CONTINUE_FLAG_SINGLE
) {
390 max_count
= UINT16_MAX
;
393 #define DIR_ENTRY_SAFETY_MARGIN 4096
395 state
->out_output_buffer
= data_blob_talloc(state
, NULL
,
396 in_output_buffer_length
+ DIR_ENTRY_SAFETY_MARGIN
);
397 if (tevent_req_nomem(state
->out_output_buffer
.data
, req
)) {
398 return tevent_req_post(req
, ev
);
401 state
->out_output_buffer
.length
= 0;
402 pdata
= (char *)state
->out_output_buffer
.data
;
405 * end_data must include the safety margin as it's what is
406 * used to determine if pushed strings have been truncated.
408 end_data
= pdata
+ in_output_buffer_length
+ DIR_ENTRY_SAFETY_MARGIN
- 1;
413 DEBUG(8,("smbd_smb2_find_send: dirpath=<%s> dontdescend=<%s>, "
414 "in_output_buffer_length = %u\n",
415 fsp
->fsp_name
->base_name
, lp_dontdescend(talloc_tos(), SNUM(conn
)),
416 (unsigned int)in_output_buffer_length
));
417 if (in_list(fsp
->fsp_name
->base_name
,lp_dontdescend(talloc_tos(), SNUM(conn
)),
418 conn
->case_sensitive
)) {
422 ask_sharemode
= lp_parm_bool(SNUM(conn
),
423 "smbd", "search ask sharemode",
428 bool got_exact_match
= false;
429 bool out_of_space
= false;
430 int space_remaining
= in_output_buffer_length
- off
;
432 SMB_ASSERT(space_remaining
>= 0);
434 ok
= smbd_dirptr_lanman2_entry(state
,
441 false, /* requires_resume_key */
444 8, /* align to 8 bytes */
445 false, /* no padding */
455 off
= (int)PTR_DIFF(pdata
, base_data
);
459 SIVAL(state
->out_output_buffer
.data
, last_entry_off
, 0);
460 tevent_req_done(req
);
461 return tevent_req_post(req
, ev
);
462 } else if (out_of_space
) {
463 tevent_req_nterror(req
, NT_STATUS_INFO_LENGTH_MISMATCH
);
464 return tevent_req_post(req
, ev
);
466 tevent_req_nterror(req
, empty_status
);
467 return tevent_req_post(req
, ev
);
472 state
->out_output_buffer
.length
= off
;
474 if (num
< max_count
) {
478 SIVAL(state
->out_output_buffer
.data
, last_entry_off
, 0);
479 tevent_req_done(req
);
480 return tevent_req_post(req
, ev
);
483 tevent_req_nterror(req
, NT_STATUS_INTERNAL_ERROR
);
484 return tevent_req_post(req
, ev
);
487 static NTSTATUS
smbd_smb2_find_recv(struct tevent_req
*req
,
489 DATA_BLOB
*out_output_buffer
)
492 struct smbd_smb2_find_state
*state
= tevent_req_data(req
,
493 struct smbd_smb2_find_state
);
495 if (tevent_req_is_nterror(req
, &status
)) {
496 tevent_req_received(req
);
500 *out_output_buffer
= state
->out_output_buffer
;
501 talloc_steal(mem_ctx
, out_output_buffer
->data
);
503 tevent_req_received(req
);