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"
27 #include "system/filesys.h"
28 #include "lib/pthreadpool/pthreadpool_tevent.h"
31 #define DBGC_CLASS DBGC_SMB2
33 static struct tevent_req
*smbd_smb2_query_directory_send(TALLOC_CTX
*mem_ctx
,
34 struct tevent_context
*ev
,
35 struct smbd_smb2_request
*smb2req
,
36 struct files_struct
*in_fsp
,
37 uint8_t in_file_info_class
,
39 uint32_t in_file_index
,
40 uint32_t in_output_buffer_length
,
41 const char *in_file_name
);
42 static NTSTATUS
smbd_smb2_query_directory_recv(struct tevent_req
*req
,
44 DATA_BLOB
*out_output_buffer
);
46 static void smbd_smb2_request_find_done(struct tevent_req
*subreq
);
47 NTSTATUS
smbd_smb2_request_process_query_directory(struct smbd_smb2_request
*req
)
50 const uint8_t *inbody
;
51 uint8_t in_file_info_class
;
53 uint32_t in_file_index
;
54 uint64_t in_file_id_persistent
;
55 uint64_t in_file_id_volatile
;
56 struct files_struct
*in_fsp
;
57 uint16_t in_file_name_offset
;
58 uint16_t in_file_name_length
;
59 DATA_BLOB in_file_name_buffer
;
60 char *in_file_name_string
;
61 size_t in_file_name_string_size
;
62 uint32_t in_output_buffer_length
;
63 struct tevent_req
*subreq
;
66 status
= smbd_smb2_request_verify_sizes(req
, 0x21);
67 if (!NT_STATUS_IS_OK(status
)) {
68 return smbd_smb2_request_error(req
, status
);
70 inbody
= SMBD_SMB2_IN_BODY_PTR(req
);
72 in_file_info_class
= CVAL(inbody
, 0x02);
73 in_flags
= CVAL(inbody
, 0x03);
74 in_file_index
= IVAL(inbody
, 0x04);
75 in_file_id_persistent
= BVAL(inbody
, 0x08);
76 in_file_id_volatile
= BVAL(inbody
, 0x10);
77 in_file_name_offset
= SVAL(inbody
, 0x18);
78 in_file_name_length
= SVAL(inbody
, 0x1A);
79 in_output_buffer_length
= IVAL(inbody
, 0x1C);
81 if (in_file_name_offset
== 0 && in_file_name_length
== 0) {
83 } else if (in_file_name_offset
!=
84 (SMB2_HDR_BODY
+ SMBD_SMB2_IN_BODY_LEN(req
))) {
85 return smbd_smb2_request_error(req
, NT_STATUS_INVALID_PARAMETER
);
88 if (in_file_name_length
> SMBD_SMB2_IN_DYN_LEN(req
)) {
89 return smbd_smb2_request_error(req
, NT_STATUS_INVALID_PARAMETER
);
92 /* The output header is 8 bytes. */
93 if (in_output_buffer_length
<= 8) {
94 return smbd_smb2_request_error(req
, NT_STATUS_INVALID_PARAMETER
);
97 DEBUG(10,("smbd_smb2_request_find_done: in_output_buffer_length = %u\n",
98 (unsigned int)in_output_buffer_length
));
100 /* Take into account the output header. */
101 in_output_buffer_length
-= 8;
103 in_file_name_buffer
.data
= SMBD_SMB2_IN_DYN_PTR(req
);
104 in_file_name_buffer
.length
= in_file_name_length
;
106 ok
= convert_string_talloc(req
, CH_UTF16
, CH_UNIX
,
107 in_file_name_buffer
.data
,
108 in_file_name_buffer
.length
,
109 &in_file_name_string
,
110 &in_file_name_string_size
);
112 return smbd_smb2_request_error(req
, NT_STATUS_ILLEGAL_CHARACTER
);
115 if (in_file_name_buffer
.length
== 0) {
116 in_file_name_string_size
= 0;
119 if (strlen(in_file_name_string
) != in_file_name_string_size
) {
120 return smbd_smb2_request_error(req
, NT_STATUS_OBJECT_NAME_INVALID
);
123 in_fsp
= file_fsp_smb2(req
, in_file_id_persistent
, in_file_id_volatile
);
124 if (in_fsp
== NULL
) {
125 return smbd_smb2_request_error(req
, NT_STATUS_FILE_CLOSED
);
128 subreq
= smbd_smb2_query_directory_send(req
, req
->sconn
->ev_ctx
,
133 in_output_buffer_length
,
134 in_file_name_string
);
135 if (subreq
== NULL
) {
136 return smbd_smb2_request_error(req
, NT_STATUS_NO_MEMORY
);
138 tevent_req_set_callback(subreq
, smbd_smb2_request_find_done
, req
);
140 return smbd_smb2_request_pending_queue(req
, subreq
, 500);
143 static void smbd_smb2_request_find_done(struct tevent_req
*subreq
)
145 struct smbd_smb2_request
*req
= tevent_req_callback_data(subreq
,
146 struct smbd_smb2_request
);
149 uint16_t out_output_buffer_offset
;
150 DATA_BLOB out_output_buffer
= data_blob_null
;
152 NTSTATUS error
; /* transport error */
154 status
= smbd_smb2_query_directory_recv(subreq
,
158 if (!NT_STATUS_IS_OK(status
)) {
159 error
= smbd_smb2_request_error(req
, status
);
160 if (!NT_STATUS_IS_OK(error
)) {
161 smbd_server_connection_terminate(req
->xconn
,
168 out_output_buffer_offset
= SMB2_HDR_BODY
+ 0x08;
170 outbody
= smbd_smb2_generate_outbody(req
, 0x08);
171 if (outbody
.data
== NULL
) {
172 error
= smbd_smb2_request_error(req
, NT_STATUS_NO_MEMORY
);
173 if (!NT_STATUS_IS_OK(error
)) {
174 smbd_server_connection_terminate(req
->xconn
,
181 SSVAL(outbody
.data
, 0x00, 0x08 + 1); /* struct size */
182 SSVAL(outbody
.data
, 0x02,
183 out_output_buffer_offset
); /* output buffer offset */
184 SIVAL(outbody
.data
, 0x04,
185 out_output_buffer
.length
); /* output buffer length */
187 DEBUG(10,("smbd_smb2_request_find_done: out_output_buffer.length = %u\n",
188 (unsigned int)out_output_buffer
.length
));
190 outdyn
= out_output_buffer
;
192 error
= smbd_smb2_request_done(req
, outbody
, &outdyn
);
193 if (!NT_STATUS_IS_OK(error
)) {
194 smbd_server_connection_terminate(req
->xconn
,
200 static struct tevent_req
*fetch_write_time_send(TALLOC_CTX
*mem_ctx
,
201 struct tevent_context
*ev
,
202 connection_struct
*conn
,
205 char *entry_marshall_buf
,
207 static NTSTATUS
fetch_write_time_recv(struct tevent_req
*req
);
209 static struct tevent_req
*fetch_dos_mode_send(
211 struct tevent_context
*ev
,
212 struct files_struct
*dir_fsp
,
213 struct smb_filename
**smb_fname
,
215 uint8_t *entry_marshall_buf
);
217 static NTSTATUS
fetch_dos_mode_recv(struct tevent_req
*req
);
219 struct smbd_smb2_query_directory_state
{
220 struct tevent_context
*ev
;
221 struct smbd_smb2_request
*smb2req
;
222 uint64_t async_sharemode_count
;
223 uint32_t find_async_delay_usec
;
224 DATA_BLOB out_output_buffer
;
225 struct smb_request
*smbreq
;
226 int in_output_buffer_length
;
227 struct files_struct
*fsp
;
228 const char *in_file_name
;
229 NTSTATUS empty_status
;
240 bool async_ask_sharemode
;
242 size_t max_async_dosmode_active
;
243 uint32_t async_dosmode_active
;
247 static bool smb2_query_directory_next_entry(struct tevent_req
*req
);
248 static void smb2_query_directory_fetch_write_time_done(struct tevent_req
*subreq
);
249 static void smb2_query_directory_dos_mode_done(struct tevent_req
*subreq
);
250 static void smb2_query_directory_waited(struct tevent_req
*subreq
);
252 static struct tevent_req
*smbd_smb2_query_directory_send(TALLOC_CTX
*mem_ctx
,
253 struct tevent_context
*ev
,
254 struct smbd_smb2_request
*smb2req
,
255 struct files_struct
*fsp
,
256 uint8_t in_file_info_class
,
258 uint32_t in_file_index
,
259 uint32_t in_output_buffer_length
,
260 const char *in_file_name
)
262 struct smbXsrv_connection
*xconn
= smb2req
->xconn
;
263 struct tevent_req
*req
;
264 struct smbd_smb2_query_directory_state
*state
;
265 connection_struct
*conn
= smb2req
->tcon
->compat
;
267 bool wcard_has_wild
= false;
273 req
= tevent_req_create(mem_ctx
, &state
,
274 struct smbd_smb2_query_directory_state
);
280 state
->smb2req
= smb2req
;
281 state
->in_output_buffer_length
= in_output_buffer_length
;
282 state
->in_file_name
= in_file_name
;
283 state
->out_output_buffer
= data_blob_null
;
284 state
->dirtype
= FILE_ATTRIBUTE_HIDDEN
| FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_DIRECTORY
;
286 DEBUG(10,("smbd_smb2_query_directory_send: %s - %s\n",
287 fsp_str_dbg(fsp
), fsp_fnum_dbg(fsp
)));
289 state
->smbreq
= smbd_smb2_fake_smb_request(smb2req
);
290 if (tevent_req_nomem(state
->smbreq
, req
)) {
291 return tevent_req_post(req
, ev
);
294 if (!fsp
->is_directory
) {
295 tevent_req_nterror(req
, NT_STATUS_NOT_SUPPORTED
);
296 return tevent_req_post(req
, ev
);
299 if (strcmp(state
->in_file_name
, "") == 0) {
300 tevent_req_nterror(req
, NT_STATUS_OBJECT_NAME_INVALID
);
301 return tevent_req_post(req
, ev
);
303 if (strchr_m(state
->in_file_name
, '\\') != NULL
) {
304 tevent_req_nterror(req
, NT_STATUS_OBJECT_NAME_INVALID
);
305 return tevent_req_post(req
, ev
);
307 if (strchr_m(state
->in_file_name
, '/') != NULL
) {
308 tevent_req_nterror(req
, NT_STATUS_OBJECT_NAME_INVALID
);
309 return tevent_req_post(req
, ev
);
312 p
= strptime(state
->in_file_name
, GMT_FORMAT
, &tm
);
313 if ((p
!= NULL
) && (*p
=='\0')) {
315 * Bogus find that asks for a shadow copy timestamp as a
316 * directory. The correct response is that it does not exist as
319 tevent_req_nterror(req
, NT_STATUS_NO_SUCH_FILE
);
320 return tevent_req_post(req
, ev
);
323 if (in_output_buffer_length
> xconn
->smb2
.server
.max_trans
) {
324 DEBUG(2,("smbd_smb2_query_directory_send: "
325 "client ignored max trans:%s: 0x%08X: 0x%08X\n",
326 __location__
, in_output_buffer_length
,
327 xconn
->smb2
.server
.max_trans
));
328 tevent_req_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
329 return tevent_req_post(req
, ev
);
332 status
= smbd_smb2_request_verify_creditcharge(smb2req
,
333 in_output_buffer_length
);
335 if (!NT_STATUS_IS_OK(status
)) {
336 tevent_req_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
337 return tevent_req_post(req
, ev
);
340 switch (in_file_info_class
) {
341 case SMB2_FIND_DIRECTORY_INFO
:
342 state
->info_level
= SMB_FIND_FILE_DIRECTORY_INFO
;
345 case SMB2_FIND_FULL_DIRECTORY_INFO
:
346 state
->info_level
= SMB_FIND_FILE_FULL_DIRECTORY_INFO
;
349 case SMB2_FIND_BOTH_DIRECTORY_INFO
:
350 state
->info_level
= SMB_FIND_FILE_BOTH_DIRECTORY_INFO
;
353 case SMB2_FIND_NAME_INFO
:
354 state
->info_level
= SMB_FIND_FILE_NAMES_INFO
;
357 case SMB2_FIND_ID_BOTH_DIRECTORY_INFO
:
358 state
->info_level
= SMB_FIND_ID_BOTH_DIRECTORY_INFO
;
361 case SMB2_FIND_ID_FULL_DIRECTORY_INFO
:
362 state
->info_level
= SMB_FIND_ID_FULL_DIRECTORY_INFO
;
366 tevent_req_nterror(req
, NT_STATUS_INVALID_INFO_CLASS
);
367 return tevent_req_post(req
, ev
);
370 if (in_flags
& SMB2_CONTINUE_FLAG_REOPEN
) {
373 status
= fd_close(fsp
);
374 if (tevent_req_nterror(req
, status
)) {
375 return tevent_req_post(req
, ev
);
379 * fd_close() will close and invalidate the fsp's file
380 * descriptor. So we have to reopen it.
385 flags
|= O_DIRECTORY
;
387 status
= fd_open(conn
, fsp
, flags
, 0);
388 if (tevent_req_nterror(req
, status
)) {
389 return tevent_req_post(req
, ev
);
393 if (!state
->smbreq
->posix_pathnames
) {
394 wcard_has_wild
= ms_has_wild(state
->in_file_name
);
397 /* Ensure we've canonicalized any search path if not a wildcard. */
398 if (!wcard_has_wild
) {
399 struct smb_filename
*smb_fname
= NULL
;
400 const char *fullpath
;
401 char tmpbuf
[PATH_MAX
];
402 char *to_free
= NULL
;
403 uint32_t ucf_flags
= UCF_SAVE_LCOMP
|
404 UCF_ALWAYS_ALLOW_WCARD_LCOMP
|
405 (state
->smbreq
->posix_pathnames
?
406 UCF_POSIX_PATHNAMES
: 0);
408 if (ISDOT(fsp
->fsp_name
->base_name
)) {
409 fullpath
= state
->in_file_name
;
415 fsp
->fsp_name
->base_name
, state
->in_file_name
,
416 tmpbuf
, sizeof(tmpbuf
), &tmp
, &to_free
);
419 return tevent_req_post(req
, ev
);
423 status
= filename_convert(state
,
431 TALLOC_FREE(to_free
);
433 if (tevent_req_nterror(req
, status
)) {
434 return tevent_req_post(req
, ev
);
437 state
->in_file_name
= smb_fname
->original_lcomp
;
440 if (fsp
->dptr
== NULL
) {
441 status
= dptr_create(conn
,
445 false, /* old_handle */
446 false, /* expect_close */
448 state
->in_file_name
, /* wcard */
452 if (!NT_STATUS_IS_OK(status
)) {
453 tevent_req_nterror(req
, status
);
454 return tevent_req_post(req
, ev
);
457 state
->empty_status
= NT_STATUS_NO_SUCH_FILE
;
459 state
->empty_status
= STATUS_NO_MORE_FILES
;
462 if (in_flags
& SMB2_CONTINUE_FLAG_RESTART
) {
463 dptr_SeekDir(fsp
->dptr
, 0);
466 if (in_flags
& SMB2_CONTINUE_FLAG_SINGLE
) {
467 state
->max_count
= 1;
469 state
->max_count
= UINT16_MAX
;
472 #define DIR_ENTRY_SAFETY_MARGIN 4096
474 state
->out_output_buffer
= data_blob_talloc(state
, NULL
,
475 in_output_buffer_length
+ DIR_ENTRY_SAFETY_MARGIN
);
476 if (tevent_req_nomem(state
->out_output_buffer
.data
, req
)) {
477 return tevent_req_post(req
, ev
);
480 state
->out_output_buffer
.length
= 0;
481 state
->pdata
= (char *)state
->out_output_buffer
.data
;
482 state
->base_data
= state
->pdata
;
484 * end_data must include the safety margin as it's what is
485 * used to determine if pushed strings have been truncated.
487 state
->end_data
= state
->pdata
+ in_output_buffer_length
+ DIR_ENTRY_SAFETY_MARGIN
- 1;
489 DEBUG(8,("smbd_smb2_query_directory_send: dirpath=<%s> dontdescend=<%s>, "
490 "in_output_buffer_length = %u\n",
491 fsp
->fsp_name
->base_name
, lp_dont_descend(talloc_tos(), SNUM(conn
)),
492 (unsigned int)in_output_buffer_length
));
493 if (in_list(fsp
->fsp_name
->base_name
,lp_dont_descend(talloc_tos(), SNUM(conn
)),
494 conn
->case_sensitive
)) {
495 state
->dont_descend
= true;
499 * SMB_FIND_FILE_NAMES_INFO doesn't need stat information
501 * This may change when we try to improve the delete on close
502 * handling in future.
504 if (state
->info_level
!= SMB_FIND_FILE_NAMES_INFO
) {
505 state
->ask_sharemode
= lp_smbd_search_ask_sharemode(SNUM(conn
));
507 state
->async_dosmode
= lp_smbd_async_dosmode(SNUM(conn
));
510 if (state
->ask_sharemode
&& lp_clustering()) {
511 state
->ask_sharemode
= false;
512 state
->async_ask_sharemode
= true;
515 if (state
->async_dosmode
) {
518 max_threads
= pthreadpool_tevent_max_threads(conn
->sconn
->pool
);
519 if (max_threads
== 0 || !per_thread_cwd_supported()) {
520 state
->async_dosmode
= false;
523 state
->max_async_dosmode_active
= lp_smbd_max_async_dosmode(
525 if (state
->max_async_dosmode_active
== 0) {
526 state
->max_async_dosmode_active
= max_threads
* 2;
530 if (state
->async_dosmode
|| state
->async_ask_sharemode
) {
532 * Should we only set async_internal
533 * if we're not the last request in
536 smb2_request_set_async_internal(smb2req
, true);
540 * This gets set in autobuild for some tests
542 state
->find_async_delay_usec
= lp_parm_ulong(SNUM(conn
), "smbd",
543 "find async delay usec",
547 stop
= smb2_query_directory_next_entry(req
);
550 if (!tevent_req_is_in_progress(req
)) {
551 return tevent_req_post(req
, ev
);
554 ok
= aio_add_req_to_fsp(fsp
, req
);
556 DBG_ERR("Could not add req to fsp\n");
557 tevent_req_nterror(req
, NT_STATUS_INTERNAL_ERROR
);
558 return tevent_req_post(req
, ev
);
564 static bool smb2_query_directory_next_entry(struct tevent_req
*req
)
566 struct smbd_smb2_query_directory_state
*state
= tevent_req_data(
567 req
, struct smbd_smb2_query_directory_state
);
568 struct smb_filename
*smb_fname
= NULL
; /* relative to fsp !! */
569 bool got_exact_match
= false;
570 int off
= state
->out_output_buffer
.length
;
571 int space_remaining
= state
->in_output_buffer_length
- off
;
572 struct file_id file_id
;
574 bool get_dosmode
= !state
->async_dosmode
;
577 SMB_ASSERT(space_remaining
>= 0);
579 status
= smbd_dirptr_lanman2_entry(state
,
582 state
->smbreq
->flags2
,
586 false, /* requires_resume_key */
588 state
->ask_sharemode
,
590 8, /* align to 8 bytes */
591 false, /* no padding */
598 &state
->last_entry_off
,
602 off
= (int)PTR_DIFF(state
->pdata
, state
->base_data
);
604 if (!NT_STATUS_IS_OK(status
)) {
605 if (NT_STATUS_EQUAL(status
, NT_STATUS_ILLEGAL_CHARACTER
)) {
607 * Bad character conversion on name. Ignore this
611 } else if (state
->num
> 0) {
612 goto last_entry_done
;
613 } else if (NT_STATUS_EQUAL(status
, STATUS_MORE_ENTRIES
)) {
614 tevent_req_nterror(req
, NT_STATUS_INFO_LENGTH_MISMATCH
);
617 tevent_req_nterror(req
, state
->empty_status
);
622 if (state
->async_ask_sharemode
) {
623 struct tevent_req
*subreq
= NULL
;
624 char *buf
= state
->base_data
+ state
->last_entry_off
;
626 subreq
= fetch_write_time_send(state
,
633 if (tevent_req_nomem(subreq
, req
)) {
636 tevent_req_set_callback(
638 smb2_query_directory_fetch_write_time_done
,
640 state
->async_sharemode_count
++;
643 if (state
->async_dosmode
) {
644 struct tevent_req
*subreq
= NULL
;
646 size_t outstanding_aio
;
648 buf
= (uint8_t *)state
->base_data
+ state
->last_entry_off
;
650 subreq
= fetch_dos_mode_send(state
,
656 if (tevent_req_nomem(subreq
, req
)) {
659 tevent_req_set_callback(subreq
,
660 smb2_query_directory_dos_mode_done
,
663 state
->async_dosmode_active
++;
665 outstanding_aio
= pthreadpool_tevent_queued_jobs(
666 state
->fsp
->conn
->sconn
->pool
);
668 if (outstanding_aio
> state
->max_async_dosmode_active
) {
673 TALLOC_FREE(smb_fname
);
676 state
->out_output_buffer
.length
= off
;
678 if (!state
->done
&& state
->num
< state
->max_count
) {
683 SIVAL(state
->out_output_buffer
.data
, state
->last_entry_off
, 0);
687 if (state
->async_sharemode_count
> 0) {
688 DBG_DEBUG("Stopping after %"PRIu64
" async mtime "
689 "updates\n", state
->async_sharemode_count
);
693 if (state
->async_dosmode_active
> 0) {
697 if (state
->find_async_delay_usec
> 0) {
699 struct tevent_req
*subreq
= NULL
;
702 * Should we only set async_internal
703 * if we're not the last request in
706 smb2_request_set_async_internal(state
->smb2req
, true);
708 tv
= timeval_current_ofs(0, state
->find_async_delay_usec
);
710 subreq
= tevent_wakeup_send(state
, state
->ev
, tv
);
711 if (tevent_req_nomem(subreq
, req
)) {
714 tevent_req_set_callback(subreq
,
715 smb2_query_directory_waited
,
720 tevent_req_done(req
);
724 static void smb2_query_directory_check_next_entry(struct tevent_req
*req
);
726 static void smb2_query_directory_fetch_write_time_done(struct tevent_req
*subreq
)
728 struct tevent_req
*req
= tevent_req_callback_data(
729 subreq
, struct tevent_req
);
730 struct smbd_smb2_query_directory_state
*state
= tevent_req_data(
731 req
, struct smbd_smb2_query_directory_state
);
736 * Make sure we run as the user again
738 ok
= change_to_user_by_fsp(state
->fsp
);
741 state
->async_sharemode_count
--;
743 status
= fetch_write_time_recv(subreq
);
745 if (tevent_req_nterror(req
, status
)) {
749 smb2_query_directory_check_next_entry(req
);
753 static void smb2_query_directory_dos_mode_done(struct tevent_req
*subreq
)
755 struct tevent_req
*req
=
756 tevent_req_callback_data(subreq
,
758 struct smbd_smb2_query_directory_state
*state
=
760 struct smbd_smb2_query_directory_state
);
765 * Make sure we run as the user again
767 ok
= change_to_user_by_fsp(state
->fsp
);
770 status
= fetch_dos_mode_recv(subreq
);
772 if (tevent_req_nterror(req
, status
)) {
776 state
->async_dosmode_active
--;
778 smb2_query_directory_check_next_entry(req
);
782 static void smb2_query_directory_check_next_entry(struct tevent_req
*req
)
784 struct smbd_smb2_query_directory_state
*state
= tevent_req_data(
785 req
, struct smbd_smb2_query_directory_state
);
790 stop
= smb2_query_directory_next_entry(req
);
795 if (state
->async_sharemode_count
> 0 ||
796 state
->async_dosmode_active
> 0)
801 if (state
->find_async_delay_usec
> 0) {
803 struct tevent_req
*subreq
= NULL
;
805 tv
= timeval_current_ofs(0, state
->find_async_delay_usec
);
807 subreq
= tevent_wakeup_send(state
, state
->ev
, tv
);
808 if (tevent_req_nomem(subreq
, req
)) {
809 tevent_req_post(req
, state
->ev
);
812 tevent_req_set_callback(subreq
,
813 smb2_query_directory_waited
,
818 tevent_req_done(req
);
822 static void smb2_query_directory_waited(struct tevent_req
*subreq
)
824 struct tevent_req
*req
= tevent_req_callback_data(
825 subreq
, struct tevent_req
);
828 ok
= tevent_wakeup_recv(subreq
);
834 tevent_req_done(req
);
837 static NTSTATUS
smbd_smb2_query_directory_recv(struct tevent_req
*req
,
839 DATA_BLOB
*out_output_buffer
)
842 struct smbd_smb2_query_directory_state
*state
= tevent_req_data(req
,
843 struct smbd_smb2_query_directory_state
);
845 if (tevent_req_is_nterror(req
, &status
)) {
846 tevent_req_received(req
);
850 *out_output_buffer
= state
->out_output_buffer
;
851 talloc_steal(mem_ctx
, out_output_buffer
->data
);
853 tevent_req_received(req
);
857 struct fetch_write_time_state
{
858 connection_struct
*conn
;
861 char *entry_marshall_buf
;
864 static void fetch_write_time_done(struct tevent_req
*subreq
);
866 static struct tevent_req
*fetch_write_time_send(TALLOC_CTX
*mem_ctx
,
867 struct tevent_context
*ev
,
868 connection_struct
*conn
,
871 char *entry_marshall_buf
,
874 struct tevent_req
*req
= NULL
;
875 struct fetch_write_time_state
*state
= NULL
;
876 struct tevent_req
*subreq
= NULL
;
881 req
= tevent_req_create(mem_ctx
, &state
, struct fetch_write_time_state
);
886 *state
= (struct fetch_write_time_state
) {
889 .info_level
= info_level
,
890 .entry_marshall_buf
= entry_marshall_buf
,
893 subreq
= fetch_share_mode_send(state
, ev
, id
, &req_queued
);
894 if (tevent_req_nomem(subreq
, req
)) {
895 return tevent_req_post(req
, ev
);
897 tevent_req_set_callback(subreq
, fetch_write_time_done
, req
);
905 static void fetch_write_time_done(struct tevent_req
*subreq
)
907 struct tevent_req
*req
= tevent_req_callback_data(
908 subreq
, struct tevent_req
);
909 struct fetch_write_time_state
*state
= tevent_req_data(
910 req
, struct fetch_write_time_state
);
911 struct timespec write_time
;
912 struct share_mode_lock
*lck
= NULL
;
916 status
= fetch_share_mode_recv(subreq
, state
, &lck
);
918 if (NT_STATUS_EQUAL(status
, NT_STATUS_NOT_FOUND
)) {
919 tevent_req_done(req
);
922 if (!NT_STATUS_IS_OK(status
)) {
923 tevent_req_nterror(req
, status
);
927 write_time
= get_share_mode_write_time(lck
);
930 if (null_timespec(write_time
)) {
931 tevent_req_done(req
);
935 switch (state
->info_level
) {
936 case SMB_FIND_FILE_DIRECTORY_INFO
:
937 case SMB_FIND_FILE_FULL_DIRECTORY_INFO
:
938 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO
:
939 case SMB_FIND_ID_FULL_DIRECTORY_INFO
:
940 case SMB_FIND_ID_BOTH_DIRECTORY_INFO
:
945 DBG_ERR("Unsupported info_level [%d]\n", state
->info_level
);
946 tevent_req_nterror(req
, NT_STATUS_INVALID_LEVEL
);
950 put_long_date_timespec(state
->conn
->ts_res
,
951 state
->entry_marshall_buf
+ off
,
954 tevent_req_done(req
);
958 static NTSTATUS
fetch_write_time_recv(struct tevent_req
*req
)
962 if (tevent_req_is_nterror(req
, &status
)) {
963 tevent_req_received(req
);
967 tevent_req_received(req
);
971 struct fetch_dos_mode_state
{
972 struct files_struct
*dir_fsp
;
973 struct smb_filename
*smb_fname
;
975 uint8_t *entry_marshall_buf
;
978 static void fetch_dos_mode_done(struct tevent_req
*subreq
);
980 static struct tevent_req
*fetch_dos_mode_send(
982 struct tevent_context
*ev
,
983 struct files_struct
*dir_fsp
,
984 struct smb_filename
**smb_fname
,
986 uint8_t *entry_marshall_buf
)
988 struct tevent_req
*req
= NULL
;
989 struct fetch_dos_mode_state
*state
= NULL
;
990 struct tevent_req
*subreq
= NULL
;
992 req
= tevent_req_create(mem_ctx
, &state
, struct fetch_dos_mode_state
);
996 *state
= (struct fetch_dos_mode_state
) {
998 .info_level
= info_level
,
999 .entry_marshall_buf
= entry_marshall_buf
,
1002 state
->smb_fname
= talloc_move(state
, smb_fname
);
1004 subreq
= dos_mode_at_send(state
, ev
, dir_fsp
, state
->smb_fname
);
1005 if (tevent_req_nomem(subreq
, req
)) {
1006 return tevent_req_post(req
, ev
);
1008 tevent_req_set_callback(subreq
, fetch_dos_mode_done
, req
);
1013 static void fetch_dos_mode_done(struct tevent_req
*subreq
)
1015 struct tevent_req
*req
=
1016 tevent_req_callback_data(subreq
,
1018 struct fetch_dos_mode_state
*state
=
1019 tevent_req_data(req
,
1020 struct fetch_dos_mode_state
);
1021 uint32_t dfs_dosmode
;
1023 struct timespec btime_ts
= {0};
1028 status
= dos_mode_at_recv(subreq
, &dosmode
);
1029 TALLOC_FREE(subreq
);
1030 if (NT_STATUS_EQUAL(status
, NT_STATUS_NOT_FOUND
)) {
1031 tevent_req_done(req
);
1034 if (!NT_STATUS_IS_OK(status
)) {
1035 tevent_req_nterror(req
, status
);
1039 switch (state
->info_level
) {
1040 case SMB_FIND_ID_BOTH_DIRECTORY_INFO
:
1041 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO
:
1042 case SMB_FIND_FILE_DIRECTORY_INFO
:
1043 case SMB_FIND_FILE_FULL_DIRECTORY_INFO
:
1044 case SMB_FIND_ID_FULL_DIRECTORY_INFO
:
1050 DBG_ERR("Unsupported info_level [%u]\n", state
->info_level
);
1051 tevent_req_nterror(req
, NT_STATUS_INVALID_LEVEL
);
1056 dfs_dosmode
= IVAL(state
->entry_marshall_buf
, dosmode_off
);
1057 if (dfs_dosmode
== 0) {
1059 * DOS mode for a DFS link, only overwrite if still set to 0 and
1060 * not already populated by the lower layer for a DFS link in
1061 * smbd_dirptr_lanman2_mode_fn().
1063 SIVAL(state
->entry_marshall_buf
, dosmode_off
, dosmode
);
1066 btime_ts
= get_create_timespec(state
->dir_fsp
->conn
,
1069 if (lp_dos_filetime_resolution(SNUM(state
->dir_fsp
->conn
))) {
1070 dos_filetime_timespec(&btime_ts
);
1073 put_long_date_timespec(state
->dir_fsp
->conn
->ts_res
,
1074 (char *)state
->entry_marshall_buf
+ btime_off
,
1077 tevent_req_done(req
);
1081 static NTSTATUS
fetch_dos_mode_recv(struct tevent_req
*req
)
1085 if (tevent_req_is_nterror(req
, &status
)) {
1086 tevent_req_received(req
);
1090 tevent_req_received(req
);
1091 return NT_STATUS_OK
;