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);
734 state->async_sharemode_count--;
736 status = fetch_write_time_recv(subreq);
738 if (tevent_req_nterror(req, status)) {
742 smb2_query_directory_check_next_entry(req);
746 static void smb2_query_directory_dos_mode_done(struct tevent_req *subreq)
748 struct tevent_req *req =
749 tevent_req_callback_data(subreq,
751 struct smbd_smb2_query_directory_state *state =
753 struct smbd_smb2_query_directory_state);
758 * Make sure we run as the user again
760 ok = change_to_user_by_fsp(state->fsp);
763 status = fetch_dos_mode_recv(subreq);
765 if (tevent_req_nterror(req, status)) {
769 state->async_dosmode_active--;
771 smb2_query_directory_check_next_entry(req);
775 static void smb2_query_directory_check_next_entry(struct tevent_req *req)
777 struct smbd_smb2_query_directory_state *state = tevent_req_data(
778 req, struct smbd_smb2_query_directory_state);
783 stop = smb2_query_directory_next_entry(req);
788 if (state->async_sharemode_count > 0 ||
789 state->async_dosmode_active > 0)
794 if (state->find_async_delay_usec > 0) {
796 struct tevent_req *subreq = NULL;
798 tv = timeval_current_ofs(0, state->find_async_delay_usec);
800 subreq = tevent_wakeup_send(state, state->ev, tv);
801 if (tevent_req_nomem(subreq, req)) {
802 tevent_req_post(req, state->ev);
805 tevent_req_set_callback(subreq,
806 smb2_query_directory_waited,
811 tevent_req_done(req);
815 static void smb2_query_directory_waited(struct tevent_req *subreq)
817 struct tevent_req *req = tevent_req_callback_data(
818 subreq, struct tevent_req);
821 ok = tevent_wakeup_recv(subreq);
827 tevent_req_done(req);
830 static NTSTATUS smbd_smb2_query_directory_recv(struct tevent_req *req,
832 DATA_BLOB *out_output_buffer)
835 struct smbd_smb2_query_directory_state *state = tevent_req_data(req,
836 struct smbd_smb2_query_directory_state);
838 if (tevent_req_is_nterror(req, &status)) {
839 tevent_req_received(req);
843 *out_output_buffer = state->out_output_buffer;
844 talloc_steal(mem_ctx, out_output_buffer->data);
846 tevent_req_received(req);
850 struct fetch_write_time_state {
851 connection_struct *conn;
854 char *entry_marshall_buf;
857 static void fetch_write_time_done(struct tevent_req *subreq);
859 static struct tevent_req *fetch_write_time_send(TALLOC_CTX *mem_ctx,
860 struct tevent_context *ev,
861 connection_struct *conn,
864 char *entry_marshall_buf,
867 struct tevent_req *req = NULL;
868 struct fetch_write_time_state *state = NULL;
869 struct tevent_req *subreq = NULL;
874 req = tevent_req_create(mem_ctx, &state, struct fetch_write_time_state);
879 *state = (struct fetch_write_time_state) {
882 .info_level = info_level,
883 .entry_marshall_buf = entry_marshall_buf,
886 subreq = fetch_share_mode_send(state, ev, id, &req_queued);
887 if (tevent_req_nomem(subreq, req)) {
888 return tevent_req_post(req, ev);
890 tevent_req_set_callback(subreq, fetch_write_time_done, req);
898 static void fetch_write_time_done(struct tevent_req *subreq)
900 struct tevent_req *req = tevent_req_callback_data(
901 subreq, struct tevent_req);
902 struct fetch_write_time_state *state = tevent_req_data(
903 req, struct fetch_write_time_state);
904 struct timespec write_time;
905 struct share_mode_lock *lck = NULL;
909 status = fetch_share_mode_recv(subreq, state, &lck);
911 if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) {
912 tevent_req_done(req);
915 if (!NT_STATUS_IS_OK(status)) {
916 tevent_req_nterror(req, status);
920 write_time = get_share_mode_write_time(lck);
923 if (null_timespec(write_time)) {
924 tevent_req_done(req);
928 switch (state->info_level) {
929 case SMB_FIND_FILE_DIRECTORY_INFO:
930 case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
931 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
932 case SMB_FIND_ID_FULL_DIRECTORY_INFO:
933 case SMB_FIND_ID_BOTH_DIRECTORY_INFO:
938 DBG_ERR("Unsupported info_level [%d]\n", state->info_level);
939 tevent_req_nterror(req, NT_STATUS_INVALID_LEVEL);
943 put_long_date_timespec(state->conn->ts_res,
944 state->entry_marshall_buf + off,
947 tevent_req_done(req);
951 static NTSTATUS fetch_write_time_recv(struct tevent_req *req)
955 if (tevent_req_is_nterror(req, &status)) {
956 tevent_req_received(req);
960 tevent_req_received(req);
964 struct fetch_dos_mode_state {
965 struct files_struct *dir_fsp;
966 struct smb_filename *smb_fname;
968 uint8_t *entry_marshall_buf;
971 static void fetch_dos_mode_done(struct tevent_req *subreq);
973 static struct tevent_req *fetch_dos_mode_send(
975 struct tevent_context *ev,
976 struct files_struct *dir_fsp,
977 struct smb_filename **smb_fname,
979 uint8_t *entry_marshall_buf)
981 struct tevent_req *req = NULL;
982 struct fetch_dos_mode_state *state = NULL;
983 struct tevent_req *subreq = NULL;
985 req = tevent_req_create(mem_ctx, &state, struct fetch_dos_mode_state);
989 *state = (struct fetch_dos_mode_state) {
991 .info_level = info_level,
992 .entry_marshall_buf = entry_marshall_buf,
995 state->smb_fname = talloc_move(state, smb_fname);
997 subreq = dos_mode_at_send(state, ev, dir_fsp, state->smb_fname);
998 if (tevent_req_nomem(subreq, req)) {
999 return tevent_req_post(req, ev);
1001 tevent_req_set_callback(subreq, fetch_dos_mode_done, req);
1006 static void fetch_dos_mode_done(struct tevent_req *subreq)
1008 struct tevent_req *req =
1009 tevent_req_callback_data(subreq,
1011 struct fetch_dos_mode_state *state =
1012 tevent_req_data(req,
1013 struct fetch_dos_mode_state);
1014 uint32_t dfs_dosmode;
1016 struct timespec btime_ts = {0};
1021 status = dos_mode_at_recv(subreq, &dosmode);
1022 TALLOC_FREE(subreq);
1023 if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) {
1024 tevent_req_done(req);
1027 if (!NT_STATUS_IS_OK(status)) {
1028 tevent_req_nterror(req, status);
1032 switch (state->info_level) {
1033 case SMB_FIND_ID_BOTH_DIRECTORY_INFO:
1034 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
1035 case SMB_FIND_FILE_DIRECTORY_INFO:
1036 case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
1037 case SMB_FIND_ID_FULL_DIRECTORY_INFO:
1043 DBG_ERR("Unsupported info_level [%u]\n", state->info_level);
1044 tevent_req_nterror(req, NT_STATUS_INVALID_LEVEL);
1049 dfs_dosmode = IVAL(state->entry_marshall_buf, dosmode_off);
1050 if (dfs_dosmode == 0) {
1052 * DOS mode for a DFS link, only overwrite if still set to 0 and
1053 * not already populated by the lower layer for a DFS link in
1054 * smbd_dirptr_lanman2_mode_fn().
1056 SIVAL(state->entry_marshall_buf, dosmode_off, dosmode);
1059 btime_ts = get_create_timespec(state->dir_fsp->conn,
1062 if (lp_dos_filetime_resolution(SNUM(state->dir_fsp->conn))) {
1063 dos_filetime_timespec(&btime_ts);
1066 put_long_date_timespec(state->dir_fsp->conn->ts_res,
1067 (char *)state->entry_marshall_buf + btime_off,
1070 tevent_req_done(req);
1074 static NTSTATUS fetch_dos_mode_recv(struct tevent_req *req)
1078 if (tevent_req_is_nterror(req, &status)) {
1079 tevent_req_received(req);
1083 tevent_req_received(req);
1084 return NT_STATUS_OK;