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 "locking/share_mode_lock.h"
23 #include "smbd/smbd.h"
24 #include "smbd/globals.h"
25 #include "../libcli/smb/smb_common.h"
27 #include "../lib/util/tevent_ntstatus.h"
28 #include "system/filesys.h"
29 #include "lib/pthreadpool/pthreadpool_tevent.h"
32 #define DBGC_CLASS DBGC_SMB2
34 static struct tevent_req *smbd_smb2_query_directory_send(TALLOC_CTX *mem_ctx,
35 struct tevent_context *ev,
36 struct smbd_smb2_request *smb2req,
37 struct files_struct *in_fsp,
38 uint8_t in_file_info_class,
40 uint32_t in_file_index,
41 uint32_t in_output_buffer_length,
42 const char *in_file_name);
43 static NTSTATUS smbd_smb2_query_directory_recv(struct tevent_req *req,
45 DATA_BLOB *out_output_buffer);
47 static void smbd_smb2_request_find_done(struct tevent_req *subreq);
48 NTSTATUS smbd_smb2_request_process_query_directory(struct smbd_smb2_request *req)
51 const uint8_t *inbody;
52 uint8_t in_file_info_class;
54 uint32_t in_file_index;
55 uint64_t in_file_id_persistent;
56 uint64_t in_file_id_volatile;
57 struct files_struct *in_fsp;
58 uint16_t in_file_name_offset;
59 uint16_t in_file_name_length;
60 DATA_BLOB in_file_name_buffer;
61 char *in_file_name_string;
62 size_t in_file_name_string_size;
63 uint32_t in_output_buffer_length;
64 struct tevent_req *subreq;
67 status = smbd_smb2_request_verify_sizes(req, 0x21);
68 if (!NT_STATUS_IS_OK(status)) {
69 return smbd_smb2_request_error(req, status);
71 inbody = SMBD_SMB2_IN_BODY_PTR(req);
73 in_file_info_class = CVAL(inbody, 0x02);
74 in_flags = CVAL(inbody, 0x03);
75 in_file_index = IVAL(inbody, 0x04);
76 in_file_id_persistent = BVAL(inbody, 0x08);
77 in_file_id_volatile = BVAL(inbody, 0x10);
78 in_file_name_offset = SVAL(inbody, 0x18);
79 in_file_name_length = SVAL(inbody, 0x1A);
80 in_output_buffer_length = IVAL(inbody, 0x1C);
82 if (in_file_name_offset == 0 && in_file_name_length == 0) {
84 } else if (in_file_name_offset !=
85 (SMB2_HDR_BODY + SMBD_SMB2_IN_BODY_LEN(req))) {
86 return smbd_smb2_request_error(req, NT_STATUS_INVALID_PARAMETER);
89 if (in_file_name_length > SMBD_SMB2_IN_DYN_LEN(req)) {
90 return smbd_smb2_request_error(req, NT_STATUS_INVALID_PARAMETER);
93 /* The output header is 8 bytes. */
94 if (in_output_buffer_length <= 8) {
95 return smbd_smb2_request_error(req, NT_STATUS_INVALID_PARAMETER);
98 DEBUG(10,("smbd_smb2_request_find_done: in_output_buffer_length = %u\n",
99 (unsigned int)in_output_buffer_length ));
101 /* Take into account the output header. */
102 in_output_buffer_length -= 8;
104 in_file_name_buffer.data = SMBD_SMB2_IN_DYN_PTR(req);
105 in_file_name_buffer.length = in_file_name_length;
107 ok = convert_string_talloc(req, CH_UTF16, CH_UNIX,
108 in_file_name_buffer.data,
109 in_file_name_buffer.length,
110 &in_file_name_string,
111 &in_file_name_string_size);
113 return smbd_smb2_request_error(req, NT_STATUS_ILLEGAL_CHARACTER);
116 if (in_file_name_buffer.length == 0) {
117 in_file_name_string_size = 0;
120 if (strlen(in_file_name_string) != in_file_name_string_size) {
121 return smbd_smb2_request_error(req, NT_STATUS_OBJECT_NAME_INVALID);
124 in_fsp = file_fsp_smb2(req, in_file_id_persistent, in_file_id_volatile);
125 if (in_fsp == NULL) {
126 return smbd_smb2_request_error(req, NT_STATUS_FILE_CLOSED);
129 subreq = smbd_smb2_query_directory_send(req, req->sconn->ev_ctx,
134 in_output_buffer_length,
135 in_file_name_string);
136 if (subreq == NULL) {
137 return smbd_smb2_request_error(req, NT_STATUS_NO_MEMORY);
139 tevent_req_set_callback(subreq, smbd_smb2_request_find_done, req);
141 return smbd_smb2_request_pending_queue(req, subreq, 500);
144 static void smbd_smb2_request_find_done(struct tevent_req *subreq)
146 struct smbd_smb2_request *req = tevent_req_callback_data(subreq,
147 struct smbd_smb2_request);
150 uint16_t out_output_buffer_offset;
151 DATA_BLOB out_output_buffer = data_blob_null;
153 NTSTATUS error; /* transport error */
155 status = smbd_smb2_query_directory_recv(subreq,
159 if (!NT_STATUS_IS_OK(status)) {
160 error = smbd_smb2_request_error(req, status);
161 if (!NT_STATUS_IS_OK(error)) {
162 smbd_server_connection_terminate(req->xconn,
169 out_output_buffer_offset = SMB2_HDR_BODY + 0x08;
171 outbody = smbd_smb2_generate_outbody(req, 0x08);
172 if (outbody.data == NULL) {
173 error = smbd_smb2_request_error(req, NT_STATUS_NO_MEMORY);
174 if (!NT_STATUS_IS_OK(error)) {
175 smbd_server_connection_terminate(req->xconn,
182 SSVAL(outbody.data, 0x00, 0x08 + 1); /* struct size */
183 SSVAL(outbody.data, 0x02,
184 out_output_buffer_offset); /* output buffer offset */
185 SIVAL(outbody.data, 0x04,
186 out_output_buffer.length); /* output buffer length */
188 DEBUG(10,("smbd_smb2_request_find_done: out_output_buffer.length = %u\n",
189 (unsigned int)out_output_buffer.length ));
191 outdyn = out_output_buffer;
193 error = smbd_smb2_request_done(req, outbody, &outdyn);
194 if (!NT_STATUS_IS_OK(error)) {
195 smbd_server_connection_terminate(req->xconn,
201 static struct tevent_req *fetch_write_time_send(TALLOC_CTX *mem_ctx,
202 struct tevent_context *ev,
203 connection_struct *conn,
206 char *entry_marshall_buf,
208 static NTSTATUS fetch_write_time_recv(struct tevent_req *req);
210 static struct tevent_req *fetch_dos_mode_send(
212 struct tevent_context *ev,
213 struct files_struct *dir_fsp,
214 struct smb_filename **smb_fname,
216 uint8_t *entry_marshall_buf);
218 static NTSTATUS fetch_dos_mode_recv(struct tevent_req *req);
220 struct smbd_smb2_query_directory_state {
221 struct tevent_context *ev;
222 struct smbd_smb2_request *smb2req;
223 uint64_t async_sharemode_count;
224 uint32_t find_async_delay_usec;
225 DATA_BLOB out_output_buffer;
226 struct smb_request *smbreq;
227 int in_output_buffer_length;
228 struct files_struct *fsp;
229 const char *in_file_name;
230 NTSTATUS empty_status;
241 bool async_ask_sharemode;
243 size_t max_async_dosmode_active;
244 uint32_t async_dosmode_active;
248 static bool smb2_query_directory_next_entry(struct tevent_req *req);
249 static void smb2_query_directory_fetch_write_time_done(struct tevent_req *subreq);
250 static void smb2_query_directory_dos_mode_done(struct tevent_req *subreq);
251 static void smb2_query_directory_waited(struct tevent_req *subreq);
253 static struct tevent_req *smbd_smb2_query_directory_send(TALLOC_CTX *mem_ctx,
254 struct tevent_context *ev,
255 struct smbd_smb2_request *smb2req,
256 struct files_struct *fsp,
257 uint8_t in_file_info_class,
259 uint32_t in_file_index,
260 uint32_t in_output_buffer_length,
261 const char *in_file_name)
263 struct smbXsrv_connection *xconn = smb2req->xconn;
264 struct tevent_req *req;
265 struct smbd_smb2_query_directory_state *state;
266 connection_struct *conn = smb2req->tcon->compat;
267 const struct loadparm_substitution *lp_sub =
268 loadparm_s3_global_substitution();
270 bool wcard_has_wild = false;
275 bool posix_dir_handle = (fsp->posix_flags & FSP_POSIX_FLAGS_OPEN);
277 req = tevent_req_create(mem_ctx, &state,
278 struct smbd_smb2_query_directory_state);
284 state->smb2req = smb2req;
285 state->in_output_buffer_length = in_output_buffer_length;
286 state->in_file_name = in_file_name;
287 state->out_output_buffer = data_blob_null;
288 state->dirtype = FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_DIRECTORY;
290 DEBUG(10,("smbd_smb2_query_directory_send: %s - %s\n",
291 fsp_str_dbg(fsp), fsp_fnum_dbg(fsp)));
293 state->smbreq = smbd_smb2_fake_smb_request(smb2req);
294 if (tevent_req_nomem(state->smbreq, req)) {
295 return tevent_req_post(req, ev);
298 if (!fsp->fsp_flags.is_directory) {
299 tevent_req_nterror(req, NT_STATUS_NOT_SUPPORTED);
300 return tevent_req_post(req, ev);
303 if (strcmp(state->in_file_name, "") == 0) {
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);
311 if (strchr_m(state->in_file_name, '/') != NULL) {
312 tevent_req_nterror(req, NT_STATUS_OBJECT_NAME_INVALID);
313 return tevent_req_post(req, ev);
316 p = strptime(state->in_file_name, GMT_FORMAT, &tm);
317 if ((p != NULL) && (*p =='\0')) {
319 * Bogus find that asks for a shadow copy timestamp as a
320 * directory. The correct response is that it does not exist as
323 tevent_req_nterror(req, NT_STATUS_NO_SUCH_FILE);
324 return tevent_req_post(req, ev);
327 if (in_output_buffer_length > xconn->smb2.server.max_trans) {
328 DEBUG(2,("smbd_smb2_query_directory_send: "
329 "client ignored max trans:%s: 0x%08X: 0x%08X\n",
330 __location__, in_output_buffer_length,
331 xconn->smb2.server.max_trans));
332 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
333 return tevent_req_post(req, ev);
336 status = smbd_smb2_request_verify_creditcharge(smb2req,
337 in_output_buffer_length);
339 if (!NT_STATUS_IS_OK(status)) {
340 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
341 return tevent_req_post(req, ev);
344 switch (in_file_info_class) {
345 case SMB2_FIND_DIRECTORY_INFO:
346 state->info_level = SMB_FIND_FILE_DIRECTORY_INFO;
349 case SMB2_FIND_FULL_DIRECTORY_INFO:
350 state->info_level = SMB_FIND_FILE_FULL_DIRECTORY_INFO;
353 case SMB2_FIND_BOTH_DIRECTORY_INFO:
354 state->info_level = SMB_FIND_FILE_BOTH_DIRECTORY_INFO;
357 case SMB2_FIND_NAME_INFO:
358 state->info_level = SMB_FIND_FILE_NAMES_INFO;
361 case SMB2_FIND_ID_BOTH_DIRECTORY_INFO:
362 state->info_level = SMB_FIND_ID_BOTH_DIRECTORY_INFO;
365 case SMB2_FIND_ID_FULL_DIRECTORY_INFO:
366 state->info_level = SMB_FIND_ID_FULL_DIRECTORY_INFO;
370 tevent_req_nterror(req, NT_STATUS_INVALID_INFO_CLASS);
371 return tevent_req_post(req, ev);
374 if (in_flags & SMB2_CONTINUE_FLAG_REOPEN) {
375 struct vfs_open_how how = { .flags = O_RDONLY, };
377 status = fd_close(fsp);
378 if (tevent_req_nterror(req, status)) {
379 return tevent_req_post(req, ev);
383 * fd_close() will close and invalidate the fsp's file
384 * descriptor. So we have to reopen it.
388 how.flags |= O_DIRECTORY;
390 status = fd_openat(conn->cwd_fsp, fsp->fsp_name, fsp, &how);
391 if (tevent_req_nterror(req, status)) {
392 return tevent_req_post(req, ev);
396 if (!state->smbreq->posix_pathnames) {
397 wcard_has_wild = ms_has_wild(state->in_file_name);
400 /* Ensure we've canonicalized any search path if not a wildcard. */
401 if (!wcard_has_wild) {
403 * We still need to do the case processing
404 * to save off the client-supplied last component.
405 * At least we know there's no @GMT normalization
406 * or MS-DFS paths to do in a directory mask.
408 state->in_file_name = get_original_lcomp(state,
412 if (tevent_req_nomem(state->in_file_name, req)) {
413 return tevent_req_post(req, ev);
417 if (fsp->dptr == NULL) {
418 status = dptr_create(conn,
421 false, /* old_handle */
422 false, /* expect_close */
424 state->in_file_name, /* wcard */
427 if (!NT_STATUS_IS_OK(status)) {
428 tevent_req_nterror(req, status);
429 return tevent_req_post(req, ev);
432 state->empty_status = NT_STATUS_NO_SUCH_FILE;
434 state->empty_status = STATUS_NO_MORE_FILES;
437 if (in_flags & SMB2_CONTINUE_FLAG_RESTART) {
438 dptr_SeekDir(fsp->dptr, 0);
441 if (in_flags & SMB2_CONTINUE_FLAG_SINGLE) {
442 state->max_count = 1;
444 state->max_count = UINT16_MAX;
447 #define DIR_ENTRY_SAFETY_MARGIN 4096
449 state->out_output_buffer = data_blob_talloc(state, NULL,
450 in_output_buffer_length + DIR_ENTRY_SAFETY_MARGIN);
451 if (tevent_req_nomem(state->out_output_buffer.data, req)) {
452 return tevent_req_post(req, ev);
455 state->out_output_buffer.length = 0;
456 state->pdata = (char *)state->out_output_buffer.data;
457 state->base_data = state->pdata;
459 * end_data must include the safety margin as it's what is
460 * used to determine if pushed strings have been truncated.
462 state->end_data = state->pdata + in_output_buffer_length + DIR_ENTRY_SAFETY_MARGIN - 1;
464 DEBUG(8,("smbd_smb2_query_directory_send: dirpath=<%s> dontdescend=<%s>, "
465 "in_output_buffer_length = %u\n",
466 fsp->fsp_name->base_name, lp_dont_descend(talloc_tos(), lp_sub, SNUM(conn)),
467 (unsigned int)in_output_buffer_length ));
468 if (in_list(fsp->fsp_name->base_name,lp_dont_descend(talloc_tos(), lp_sub, SNUM(conn)),
469 posix_dir_handle ? true : conn->case_sensitive)) {
470 state->dont_descend = true;
474 * SMB_FIND_FILE_NAMES_INFO doesn't need stat information
476 * This may change when we try to improve the delete on close
477 * handling in future.
479 if (state->info_level != SMB_FIND_FILE_NAMES_INFO) {
480 state->ask_sharemode = lp_smbd_search_ask_sharemode(SNUM(conn));
482 state->async_dosmode = lp_smbd_async_dosmode(SNUM(conn));
485 if (state->ask_sharemode && lp_clustering()) {
486 state->ask_sharemode = false;
487 state->async_ask_sharemode = true;
490 if (state->async_dosmode) {
493 max_threads = pthreadpool_tevent_max_threads(conn->sconn->pool);
494 if (max_threads == 0 || !per_thread_cwd_supported()) {
495 state->async_dosmode = false;
498 state->max_async_dosmode_active = lp_smbd_max_async_dosmode(
500 if (state->max_async_dosmode_active == 0) {
501 state->max_async_dosmode_active = max_threads * 2;
505 if (state->async_dosmode || state->async_ask_sharemode) {
507 * Should we only set async_internal
508 * if we're not the last request in
511 smb2_request_set_async_internal(smb2req, true);
515 * This gets set in autobuild for some tests
517 state->find_async_delay_usec = lp_parm_ulong(SNUM(conn), "smbd",
518 "find async delay usec",
522 stop = smb2_query_directory_next_entry(req);
525 if (!tevent_req_is_in_progress(req)) {
526 return tevent_req_post(req, ev);
529 ok = aio_add_req_to_fsp(fsp, req);
531 DBG_ERR("Could not add req to fsp\n");
532 tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
533 return tevent_req_post(req, ev);
539 static bool smb2_query_directory_next_entry(struct tevent_req *req)
541 struct smbd_smb2_query_directory_state *state = tevent_req_data(
542 req, struct smbd_smb2_query_directory_state);
543 struct smb_filename *smb_fname = NULL; /* relative to fsp !! */
544 bool got_exact_match = false;
545 int off = state->out_output_buffer.length;
546 int space_remaining = state->in_output_buffer_length - off;
547 struct file_id file_id;
549 bool get_dosmode = !state->async_dosmode;
552 SMB_ASSERT(space_remaining >= 0);
554 status = smbd_dirptr_lanman2_entry(state,
557 state->smbreq->flags2,
561 false, /* requires_resume_key */
563 state->ask_sharemode,
565 8, /* align to 8 bytes */
566 false, /* no padding */
573 &state->last_entry_off,
577 off = (int)PTR_DIFF(state->pdata, state->base_data);
579 if (!NT_STATUS_IS_OK(status)) {
580 if (NT_STATUS_EQUAL(status, NT_STATUS_ILLEGAL_CHARACTER)) {
582 * Bad character conversion on name. Ignore this
586 } else if (state->num > 0) {
587 goto last_entry_done;
588 } else if (NT_STATUS_EQUAL(status, STATUS_MORE_ENTRIES)) {
589 tevent_req_nterror(req, NT_STATUS_INFO_LENGTH_MISMATCH);
592 tevent_req_nterror(req, state->empty_status);
597 if (state->async_ask_sharemode &&
598 !S_ISDIR(smb_fname->st.st_ex_mode))
600 struct tevent_req *subreq = NULL;
601 char *buf = state->base_data + state->last_entry_off;
603 subreq = fetch_write_time_send(state,
610 if (tevent_req_nomem(subreq, req)) {
613 tevent_req_set_callback(
615 smb2_query_directory_fetch_write_time_done,
617 state->async_sharemode_count++;
620 if (state->async_dosmode) {
621 struct tevent_req *subreq = NULL;
623 size_t outstanding_aio;
625 buf = (uint8_t *)state->base_data + state->last_entry_off;
627 subreq = fetch_dos_mode_send(state,
633 if (tevent_req_nomem(subreq, req)) {
636 tevent_req_set_callback(subreq,
637 smb2_query_directory_dos_mode_done,
640 state->async_dosmode_active++;
642 outstanding_aio = pthreadpool_tevent_queued_jobs(
643 state->fsp->conn->sconn->pool);
645 if (outstanding_aio > state->max_async_dosmode_active) {
650 TALLOC_FREE(smb_fname);
653 state->out_output_buffer.length = off;
655 if (!state->done && state->num < state->max_count) {
660 SIVAL(state->out_output_buffer.data, state->last_entry_off, 0);
664 if (state->async_sharemode_count > 0) {
665 DBG_DEBUG("Stopping after %"PRIu64" async mtime "
666 "updates\n", state->async_sharemode_count);
670 if (state->async_dosmode_active > 0) {
674 if (state->find_async_delay_usec > 0) {
676 struct tevent_req *subreq = NULL;
679 * Should we only set async_internal
680 * if we're not the last request in
683 smb2_request_set_async_internal(state->smb2req, true);
685 tv = timeval_current_ofs(0, state->find_async_delay_usec);
687 subreq = tevent_wakeup_send(state, state->ev, tv);
688 if (tevent_req_nomem(subreq, req)) {
691 tevent_req_set_callback(subreq,
692 smb2_query_directory_waited,
697 tevent_req_done(req);
701 static void smb2_query_directory_check_next_entry(struct tevent_req *req);
703 static void smb2_query_directory_fetch_write_time_done(struct tevent_req *subreq)
705 struct tevent_req *req = tevent_req_callback_data(
706 subreq, struct tevent_req);
707 struct smbd_smb2_query_directory_state *state = tevent_req_data(
708 req, struct smbd_smb2_query_directory_state);
713 * Make sure we run as the user again
715 ok = change_to_user_and_service_by_fsp(state->fsp);
718 state->async_sharemode_count--;
720 status = fetch_write_time_recv(subreq);
722 if (tevent_req_nterror(req, status)) {
726 smb2_query_directory_check_next_entry(req);
730 static void smb2_query_directory_dos_mode_done(struct tevent_req *subreq)
732 struct tevent_req *req =
733 tevent_req_callback_data(subreq,
735 struct smbd_smb2_query_directory_state *state =
737 struct smbd_smb2_query_directory_state);
742 * Make sure we run as the user again
744 ok = change_to_user_and_service_by_fsp(state->fsp);
747 status = fetch_dos_mode_recv(subreq);
749 if (tevent_req_nterror(req, status)) {
753 state->async_dosmode_active--;
755 smb2_query_directory_check_next_entry(req);
759 static void smb2_query_directory_check_next_entry(struct tevent_req *req)
761 struct smbd_smb2_query_directory_state *state = tevent_req_data(
762 req, struct smbd_smb2_query_directory_state);
767 stop = smb2_query_directory_next_entry(req);
772 if (state->async_sharemode_count > 0 ||
773 state->async_dosmode_active > 0)
778 if (state->find_async_delay_usec > 0) {
780 struct tevent_req *subreq = NULL;
782 tv = timeval_current_ofs(0, state->find_async_delay_usec);
784 subreq = tevent_wakeup_send(state, state->ev, tv);
785 if (tevent_req_nomem(subreq, req)) {
786 tevent_req_post(req, state->ev);
789 tevent_req_set_callback(subreq,
790 smb2_query_directory_waited,
795 tevent_req_done(req);
799 static void smb2_query_directory_waited(struct tevent_req *subreq)
801 struct tevent_req *req = tevent_req_callback_data(
802 subreq, struct tevent_req);
805 ok = tevent_wakeup_recv(subreq);
811 tevent_req_done(req);
814 static NTSTATUS smbd_smb2_query_directory_recv(struct tevent_req *req,
816 DATA_BLOB *out_output_buffer)
819 struct smbd_smb2_query_directory_state *state = tevent_req_data(req,
820 struct smbd_smb2_query_directory_state);
822 if (tevent_req_is_nterror(req, &status)) {
823 tevent_req_received(req);
827 *out_output_buffer = state->out_output_buffer;
828 talloc_steal(mem_ctx, out_output_buffer->data);
830 tevent_req_received(req);
834 struct fetch_write_time_state {
835 connection_struct *conn;
838 char *entry_marshall_buf;
841 static void fetch_write_time_done(struct tevent_req *subreq);
843 static struct tevent_req *fetch_write_time_send(TALLOC_CTX *mem_ctx,
844 struct tevent_context *ev,
845 connection_struct *conn,
848 char *entry_marshall_buf,
851 struct tevent_req *req = NULL;
852 struct fetch_write_time_state *state = NULL;
853 struct tevent_req *subreq = NULL;
858 req = tevent_req_create(mem_ctx, &state, struct fetch_write_time_state);
863 *state = (struct fetch_write_time_state) {
866 .info_level = info_level,
867 .entry_marshall_buf = entry_marshall_buf,
870 subreq = fetch_share_mode_send(state, ev, id, &req_queued);
871 if (tevent_req_nomem(subreq, req)) {
872 return tevent_req_post(req, ev);
874 tevent_req_set_callback(subreq, fetch_write_time_done, req);
882 static void fetch_write_time_done(struct tevent_req *subreq)
884 struct tevent_req *req = tevent_req_callback_data(
885 subreq, struct tevent_req);
886 struct fetch_write_time_state *state = tevent_req_data(
887 req, struct fetch_write_time_state);
888 struct timespec write_time;
889 struct share_mode_lock *lck = NULL;
893 status = fetch_share_mode_recv(subreq, state, &lck);
895 if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) {
896 tevent_req_done(req);
899 if (tevent_req_nterror(req, status)) {
903 write_time = get_share_mode_write_time(lck);
906 if (is_omit_timespec(&write_time)) {
907 tevent_req_done(req);
911 switch (state->info_level) {
912 case SMB_FIND_FILE_DIRECTORY_INFO:
913 case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
914 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
915 case SMB_FIND_ID_FULL_DIRECTORY_INFO:
916 case SMB_FIND_ID_BOTH_DIRECTORY_INFO:
921 DBG_ERR("Unsupported info_level [%d]\n", state->info_level);
922 tevent_req_nterror(req, NT_STATUS_INVALID_LEVEL);
926 put_long_date_full_timespec(state->conn->ts_res,
927 state->entry_marshall_buf + off,
930 tevent_req_done(req);
934 static NTSTATUS fetch_write_time_recv(struct tevent_req *req)
938 if (tevent_req_is_nterror(req, &status)) {
939 tevent_req_received(req);
943 tevent_req_received(req);
947 struct fetch_dos_mode_state {
948 struct files_struct *dir_fsp;
949 struct smb_filename *smb_fname;
951 uint8_t *entry_marshall_buf;
954 static void fetch_dos_mode_done(struct tevent_req *subreq);
956 static struct tevent_req *fetch_dos_mode_send(
958 struct tevent_context *ev,
959 struct files_struct *dir_fsp,
960 struct smb_filename **smb_fname,
962 uint8_t *entry_marshall_buf)
964 struct tevent_req *req = NULL;
965 struct fetch_dos_mode_state *state = NULL;
966 struct tevent_req *subreq = NULL;
968 req = tevent_req_create(mem_ctx, &state, struct fetch_dos_mode_state);
972 *state = (struct fetch_dos_mode_state) {
974 .info_level = info_level,
975 .entry_marshall_buf = entry_marshall_buf,
978 state->smb_fname = talloc_move(state, smb_fname);
980 subreq = dos_mode_at_send(state, ev, dir_fsp, state->smb_fname);
981 if (tevent_req_nomem(subreq, req)) {
982 return tevent_req_post(req, ev);
984 tevent_req_set_callback(subreq, fetch_dos_mode_done, req);
989 static void fetch_dos_mode_done(struct tevent_req *subreq)
991 struct tevent_req *req =
992 tevent_req_callback_data(subreq,
994 struct fetch_dos_mode_state *state =
996 struct fetch_dos_mode_state);
997 uint32_t dfs_dosmode;
999 struct timespec btime_ts = {0};
1004 status = dos_mode_at_recv(subreq, &dosmode);
1005 TALLOC_FREE(subreq);
1006 if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) {
1007 tevent_req_done(req);
1010 if (tevent_req_nterror(req, status)) {
1014 switch (state->info_level) {
1015 case SMB_FIND_ID_BOTH_DIRECTORY_INFO:
1016 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
1017 case SMB_FIND_FILE_DIRECTORY_INFO:
1018 case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
1019 case SMB_FIND_ID_FULL_DIRECTORY_INFO:
1025 DBG_ERR("Unsupported info_level [%u]\n", state->info_level);
1026 tevent_req_nterror(req, NT_STATUS_INVALID_LEVEL);
1031 dfs_dosmode = IVAL(state->entry_marshall_buf, dosmode_off);
1032 if (dfs_dosmode == 0) {
1034 * DOS mode for a DFS link, only overwrite if still set to 0 and
1035 * not already populated by the lower layer for a DFS link in
1036 * smbd_dirptr_lanman2_mode_fn().
1038 SIVAL(state->entry_marshall_buf, dosmode_off, dosmode);
1041 btime_ts = get_create_timespec(state->dir_fsp->conn,
1044 if (lp_dos_filetime_resolution(SNUM(state->dir_fsp->conn))) {
1045 dos_filetime_timespec(&btime_ts);
1048 put_long_date_full_timespec(state->dir_fsp->conn->ts_res,
1049 (char *)state->entry_marshall_buf + btime_off,
1052 tevent_req_done(req);
1056 static NTSTATUS fetch_dos_mode_recv(struct tevent_req *req)
1060 if (tevent_req_is_nterror(req, &status)) {
1061 tevent_req_received(req);
1065 tevent_req_received(req);
1066 return NT_STATUS_OK;