?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3:smbd: use lp_smbd_search_ask_sharemode()
[Samba.git] / source3 / smbd / smb2_query_directory.c
blobcbad1b7cc5765f9da8c0acd5eac43fe9d8f9c21d
1 /*
2 Unix SMB/CIFS implementation.
3 Core SMB2 server
4
5 Copyright (C) Stefan Metzmacher 2009
6
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.
11
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.
16
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/>.
19 */
20
21 #include "includes.h"
22 #include "smbd/smbd.h"
23 #include "smbd/globals.h"
24 #include "../libcli/smb/smb_common.h"
25 #include "trans2.h"
26 #include "../lib/util/tevent_ntstatus.h"
27 #include "system/filesys.h"
28 #include "lib/pthreadpool/pthreadpool_tevent.h"
29
30 #undef DBGC_CLASS
31 #define DBGC_CLASS DBGC_SMB2
32
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,
38 uint8_t in_flags,
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,
43 TALLOC_CTX *mem_ctx,
44 DATA_BLOB *out_output_buffer);
45
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)
48 {
49 NTSTATUS status;
50 const uint8_t *inbody;
51 uint8_t in_file_info_class;
52 uint8_t in_flags;
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;
64 bool ok;
65
66 status = smbd_smb2_request_verify_sizes(req, 0x21);
67 if (!NT_STATUS_IS_OK(status)) {
68 return smbd_smb2_request_error(req, status);
69 }
70 inbody = SMBD_SMB2_IN_BODY_PTR(req);
71
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);
80
81 if (in_file_name_offset == 0 && in_file_name_length == 0) {
82 /* This is ok */
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);
86 }
87
88 if (in_file_name_length > SMBD_SMB2_IN_DYN_LEN(req)) {
89 return smbd_smb2_request_error(req, NT_STATUS_INVALID_PARAMETER);
90 }
91
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);
95 }
96
97 DEBUG(10,("smbd_smb2_request_find_done: in_output_buffer_length = %u\n",
98 (unsigned int)in_output_buffer_length ));
99
100 /* Take into account the output header. */
101 in_output_buffer_length -= 8;
102
103 in_file_name_buffer.data = SMBD_SMB2_IN_DYN_PTR(req);
104 in_file_name_buffer.length = in_file_name_length;
105
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);
111 if (!ok) {
112 return smbd_smb2_request_error(req, NT_STATUS_ILLEGAL_CHARACTER);
113 }
114
115 if (in_file_name_buffer.length == 0) {
116 in_file_name_string_size = 0;
117 }
118
119 if (strlen(in_file_name_string) != in_file_name_string_size) {
120 return smbd_smb2_request_error(req, NT_STATUS_OBJECT_NAME_INVALID);
121 }
122
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);
126 }
127
128 subreq = smbd_smb2_query_directory_send(req, req->ev_ctx,
129 req, in_fsp,
130 in_file_info_class,
131 in_flags,
132 in_file_index,
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);
137 }
138 tevent_req_set_callback(subreq, smbd_smb2_request_find_done, req);
139
140 return smbd_smb2_request_pending_queue(req, subreq, 500);
141 }
142
143 static void smbd_smb2_request_find_done(struct tevent_req *subreq)
144 {
145 struct smbd_smb2_request *req = tevent_req_callback_data(subreq,
146 struct smbd_smb2_request);
147 DATA_BLOB outbody;
148 DATA_BLOB outdyn;
149 uint16_t out_output_buffer_offset;
150 DATA_BLOB out_output_buffer = data_blob_null;
151 NTSTATUS status;
152 NTSTATUS error; /* transport error */
153
154 status = smbd_smb2_query_directory_recv(subreq,
155 req,
156 &out_output_buffer);
157 TALLOC_FREE(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,
162 nt_errstr(error));
163 return;
164 }
165 return;
166 }
167
168 out_output_buffer_offset = SMB2_HDR_BODY + 0x08;
169
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,
175 nt_errstr(error));
176 return;
177 }
178 return;
179 }
180
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 */
186
187 DEBUG(10,("smbd_smb2_request_find_done: out_output_buffer.length = %u\n",
188 (unsigned int)out_output_buffer.length ));
189
190 outdyn = out_output_buffer;
191
192 error = smbd_smb2_request_done(req, outbody, &outdyn);
193 if (!NT_STATUS_IS_OK(error)) {
194 smbd_server_connection_terminate(req->xconn,
195 nt_errstr(error));
196 return;
197 }
198 }
199
200 static struct tevent_req *fetch_write_time_send(TALLOC_CTX *mem_ctx,
201 struct tevent_context *ev,
202 connection_struct *conn,
203 struct file_id id,
204 int info_level,
205 char *entry_marshall_buf,
206 bool *stop);
207 static NTSTATUS fetch_write_time_recv(struct tevent_req *req);
208
209 static struct tevent_req *fetch_dos_mode_send(
210 TALLOC_CTX *mem_ctx,
211 struct smb_vfs_ev_glue *evg,
212 struct files_struct *dir_fsp,
213 struct smb_filename **smb_fname,
214 uint32_t info_level,
215 uint8_t *entry_marshall_buf);
216
217 static NTSTATUS fetch_dos_mode_recv(struct tevent_req *req);
218
219 struct smbd_smb2_query_directory_state {
220 struct smb_vfs_ev_glue *evg;
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;
231 uint32_t info_level;
232 uint32_t max_count;
233 char *pdata;
234 char *base_data;
235 char *end_data;
236 uint32_t num;
237 uint32_t dirtype;
238 bool dont_descend;
239 bool ask_sharemode;
240 bool async_dosmode;
241 bool async_ask_sharemode;
242 int last_entry_off;
243 struct pthreadpool_tevent *tp_chdir_safe;
244 size_t max_async_dosmode_active;
245 uint32_t async_dosmode_active;
246 bool done;
247 };
248
249 static bool smb2_query_directory_next_entry(struct tevent_req *req);
250 static void smb2_query_directory_fetch_write_time_done(struct tevent_req *subreq);
251 static void smb2_query_directory_dos_mode_done(struct tevent_req *subreq);
252 static void smb2_query_directory_waited(struct tevent_req *subreq);
253
254 static struct tevent_req *smbd_smb2_query_directory_send(TALLOC_CTX *mem_ctx,
255 struct tevent_context *ev,
256 struct smbd_smb2_request *smb2req,
257 struct files_struct *fsp,
258 uint8_t in_file_info_class,
259 uint8_t in_flags,
260 uint32_t in_file_index,
261 uint32_t in_output_buffer_length,
262 const char *in_file_name)
263 {
264 struct smbXsrv_connection *xconn = smb2req->xconn;
265 struct tevent_req *req;
266 struct smbd_smb2_query_directory_state *state;
267 connection_struct *conn = smb2req->tcon->compat;
268 NTSTATUS status;
269 bool wcard_has_wild = false;
270 struct tm tm;
271 char *p;
272 bool stop = false;
273 bool ok;
274
275 req = tevent_req_create(mem_ctx, &state,
276 struct smbd_smb2_query_directory_state);
277 if (req == NULL) {
278 return NULL;
279 }
280 state->evg = conn->user_vfs_evg;
281 state->ev = ev;
282 state->tp_chdir_safe = smb_vfs_ev_glue_tp_chdir_safe(state->evg);
283 state->fsp = fsp;
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;
289
290 DEBUG(10,("smbd_smb2_query_directory_send: %s - %s\n",
291 fsp_str_dbg(fsp), fsp_fnum_dbg(fsp)));
292
293 state->smbreq = smbd_smb2_fake_smb_request(smb2req);
294 if (tevent_req_nomem(state->smbreq, req)) {
295 return tevent_req_post(req, ev);
296 }
297
298 if (!fsp->is_directory) {
299 tevent_req_nterror(req, NT_STATUS_NOT_SUPPORTED);
300 return tevent_req_post(req, ev);
301 }
302
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);
306 }
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);
310 }
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);
314 }
315
316 p = strptime(state->in_file_name, GMT_FORMAT, &tm);
317 if ((p != NULL) && (*p =='\0')) {
318 /*
319 * Bogus find that asks for a shadow copy timestamp as a
320 * directory. The correct response is that it does not exist as
321 * a directory.
322 */
323 tevent_req_nterror(req, NT_STATUS_NO_SUCH_FILE);
324 return tevent_req_post(req, ev);
325 }
326
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);
334 }
335
336 status = smbd_smb2_request_verify_creditcharge(smb2req,
337 in_output_buffer_length);
338
339 if (!NT_STATUS_IS_OK(status)) {
340 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
341 return tevent_req_post(req, ev);
342 }
343
344 switch (in_file_info_class) {
345 case SMB2_FIND_DIRECTORY_INFO:
346 state->info_level = SMB_FIND_FILE_DIRECTORY_INFO;
347 break;
348
349 case SMB2_FIND_FULL_DIRECTORY_INFO:
350 state->info_level = SMB_FIND_FILE_FULL_DIRECTORY_INFO;
351 break;
352
353 case SMB2_FIND_BOTH_DIRECTORY_INFO:
354 state->info_level = SMB_FIND_FILE_BOTH_DIRECTORY_INFO;
355 break;
356
357 case SMB2_FIND_NAME_INFO:
358 state->info_level = SMB_FIND_FILE_NAMES_INFO;
359 break;
360
361 case SMB2_FIND_ID_BOTH_DIRECTORY_INFO:
362 state->info_level = SMB_FIND_ID_BOTH_DIRECTORY_INFO;
363 break;
364
365 case SMB2_FIND_ID_FULL_DIRECTORY_INFO:
366 state->info_level = SMB_FIND_ID_FULL_DIRECTORY_INFO;
367 break;
368
369 default:
370 tevent_req_nterror(req, NT_STATUS_INVALID_INFO_CLASS);
371 return tevent_req_post(req, ev);
372 }
373
374 if (in_flags & SMB2_CONTINUE_FLAG_REOPEN) {
375 int flags;
376
377 status = fd_close(fsp);
378 if (tevent_req_nterror(req, status)) {
379 return tevent_req_post(req, ev);
380 }
381
382 /*
383 * fd_close() will close and invalidate the fsp's file
384 * descriptor. So we have to reopen it.
385 */
386
387 flags = O_RDONLY;
388 #ifdef O_DIRECTORY
389 flags |= O_DIRECTORY;
390 #endif
391 status = fd_open(conn, fsp, flags, 0);
392 if (tevent_req_nterror(req, status)) {
393 return tevent_req_post(req, ev);
394 }
395 }
396
397 if (!state->smbreq->posix_pathnames) {
398 wcard_has_wild = ms_has_wild(state->in_file_name);
399 }
400
401 /* Ensure we've canonicalized any search path if not a wildcard. */
402 if (!wcard_has_wild) {
403 struct smb_filename *smb_fname = NULL;
404 const char *fullpath;
405 char tmpbuf[PATH_MAX];
406 char *to_free = NULL;
407 uint32_t ucf_flags = UCF_SAVE_LCOMP |
408 UCF_ALWAYS_ALLOW_WCARD_LCOMP |
409 (state->smbreq->posix_pathnames ?
410 UCF_POSIX_PATHNAMES : 0);
411
412 if (ISDOT(fsp->fsp_name->base_name)) {
413 fullpath = state->in_file_name;
414 } else {
415 size_t len;
416 char *tmp;
417
418 len = full_path_tos(
419 fsp->fsp_name->base_name, state->in_file_name,
420 tmpbuf, sizeof(tmpbuf), &tmp, &to_free);
421 if (len == -1) {
422 tevent_req_oom(req);
423 return tevent_req_post(req, ev);
424 }
425 fullpath = tmp;
426 }
427 status = filename_convert(state,
428 conn,
429 fullpath,
430 ucf_flags,
431 NULL,
432 &wcard_has_wild,
433 &smb_fname);
434
435 TALLOC_FREE(to_free);
436
437 if (tevent_req_nterror(req, status)) {
438 return tevent_req_post(req, ev);
439 }
440
441 state->in_file_name = smb_fname->original_lcomp;
442 }
443
444 if (fsp->dptr == NULL) {
445 status = dptr_create(conn,
446 NULL, /* req */
447 fsp,
448 fsp->fsp_name,
449 false, /* old_handle */
450 false, /* expect_close */
451 0, /* spid */
452 state->in_file_name, /* wcard */
453 wcard_has_wild,
454 state->dirtype,
455 &fsp->dptr);
456 if (!NT_STATUS_IS_OK(status)) {
457 tevent_req_nterror(req, status);
458 return tevent_req_post(req, ev);
459 }
460
461 state->empty_status = NT_STATUS_NO_SUCH_FILE;
462 } else {
463 state->empty_status = STATUS_NO_MORE_FILES;
464 }
465
466 if (in_flags & SMB2_CONTINUE_FLAG_RESTART) {
467 dptr_SeekDir(fsp->dptr, 0);
468 }
469
470 if (in_flags & SMB2_CONTINUE_FLAG_SINGLE) {
471 state->max_count = 1;
472 } else {
473 state->max_count = UINT16_MAX;
474 }
475
476 #define DIR_ENTRY_SAFETY_MARGIN 4096
477
478 state->out_output_buffer = data_blob_talloc(state, NULL,
479 in_output_buffer_length + DIR_ENTRY_SAFETY_MARGIN);
480 if (tevent_req_nomem(state->out_output_buffer.data, req)) {
481 return tevent_req_post(req, ev);
482 }
483
484 state->out_output_buffer.length = 0;
485 state->pdata = (char *)state->out_output_buffer.data;
486 state->base_data = state->pdata;
487 /*
488 * end_data must include the safety margin as it's what is
489 * used to determine if pushed strings have been truncated.
490 */
491 state->end_data = state->pdata + in_output_buffer_length + DIR_ENTRY_SAFETY_MARGIN - 1;
492
493 DEBUG(8,("smbd_smb2_query_directory_send: dirpath=<%s> dontdescend=<%s>, "
494 "in_output_buffer_length = %u\n",
495 fsp->fsp_name->base_name, lp_dont_descend(talloc_tos(), SNUM(conn)),
496 (unsigned int)in_output_buffer_length ));
497 if (in_list(fsp->fsp_name->base_name,lp_dont_descend(talloc_tos(), SNUM(conn)),
498 conn->case_sensitive)) {
499 state->dont_descend = true;
500 }
501
502 /*
503 * SMB_FIND_FILE_NAMES_INFO doesn't need stat information
504 *
505 * This may change when we try to improve the delete on close
506 * handling in future.
507 */
508 if (state->info_level != SMB_FIND_FILE_NAMES_INFO) {
509 state->ask_sharemode = lp_smbd_search_ask_sharemode(SNUM(conn));
510
511 state->async_dosmode = lp_parm_bool(
512 SNUM(conn), "smbd", "async dosmode", false);
513 }
514
515 if (state->ask_sharemode && lp_clustering()) {
516 state->ask_sharemode = false;
517 state->async_ask_sharemode = true;
518 }
519
520 if (state->async_dosmode) {
521 size_t max_threads;
522
523 max_threads = pthreadpool_tevent_max_threads(state->tp_chdir_safe);
524
525 state->max_async_dosmode_active = lp_parm_ulong(
526 SNUM(conn), "smbd", "max async dosmode",
527 max_threads * 2);
528
529 if (state->max_async_dosmode_active == 0) {
530 state->max_async_dosmode_active = 1;
531 }
532 }
533
534 if (state->async_dosmode || state->async_ask_sharemode) {
535 /*
536 * Should we only set async_internal
537 * if we're not the last request in
538 * a compound chain?
539 */
540 smb2_request_set_async_internal(smb2req, true);
541 }
542
543 /*
544 * This gets set in autobuild for some tests
545 */
546 state->find_async_delay_usec = lp_parm_ulong(SNUM(conn), "smbd",
547 "find async delay usec",
548 0);
549
550 while (!stop) {
551 stop = smb2_query_directory_next_entry(req);
552 }
553
554 if (!tevent_req_is_in_progress(req)) {
555 return tevent_req_post(req, ev);
556 }
557
558 ok = aio_add_req_to_fsp(fsp, req);
559 if (!ok) {
560 DBG_ERR("Could not add req to fsp\n");
561 tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
562 return tevent_req_post(req, ev);
563 }
564
565 return req;
566 }
567
568 static bool smb2_query_directory_next_entry(struct tevent_req *req)
569 {
570 struct smbd_smb2_query_directory_state *state = tevent_req_data(
571 req, struct smbd_smb2_query_directory_state);
572 struct smb_filename *smb_fname = NULL; /* relative to fsp !! */
573 bool got_exact_match = false;
574 int off = state->out_output_buffer.length;
575 int space_remaining = state->in_output_buffer_length - off;
576 struct file_id file_id;
577 NTSTATUS status;
578 bool get_dosmode = !state->async_dosmode;
579 bool stop = false;
580
581 SMB_ASSERT(space_remaining >= 0);
582
583 status = smbd_dirptr_lanman2_entry(state,
584 state->fsp->conn,
585 state->fsp->dptr,
586 state->smbreq->flags2,
587 state->in_file_name,
588 state->dirtype,
589 state->info_level,
590 false, /* requires_resume_key */
591 state->dont_descend,
592 state->ask_sharemode,
593 get_dosmode,
594 8, /* align to 8 bytes */
595 false, /* no padding */
596 &state->pdata,
597 state->base_data,
598 state->end_data,
599 space_remaining,
600 &smb_fname,
601 &got_exact_match,
602 &state->last_entry_off,
603 NULL,
604 &file_id);
605
606 off = (int)PTR_DIFF(state->pdata, state->base_data);
607
608 if (!NT_STATUS_IS_OK(status)) {
609 if (NT_STATUS_EQUAL(status, NT_STATUS_ILLEGAL_CHARACTER)) {
610 /*
611 * Bad character conversion on name. Ignore this
612 * entry.
613 */
614 return false;
615 } else if (state->num > 0) {
616 goto last_entry_done;
617 } else if (NT_STATUS_EQUAL(status, STATUS_MORE_ENTRIES)) {
618 tevent_req_nterror(req, NT_STATUS_INFO_LENGTH_MISMATCH);
619 return true;
620 } else {
621 tevent_req_nterror(req, state->empty_status);
622 return true;
623 }
624 }
625
626 if (state->async_ask_sharemode) {
627 struct tevent_req *subreq = NULL;
628 char *buf = state->base_data + state->last_entry_off;
629
630 subreq = fetch_write_time_send(state,
631 state->ev,
632 state->fsp->conn,
633 file_id,
634 state->info_level,
635 buf,
636 &stop);
637 if (tevent_req_nomem(subreq, req)) {
638 return true;
639 }
640 tevent_req_set_callback(
641 subreq,
642 smb2_query_directory_fetch_write_time_done,
643 req);
644 state->async_sharemode_count++;
645 }
646
647 if (state->async_dosmode) {
648 struct tevent_req *subreq = NULL;
649 uint8_t *buf = NULL;
650 size_t outstanding_aio;
651
652 buf = (uint8_t *)state->base_data + state->last_entry_off;
653
654 subreq = fetch_dos_mode_send(state,
655 state->evg,
656 state->fsp,
657 &smb_fname,
658 state->info_level,
659 buf);
660 if (tevent_req_nomem(subreq, req)) {
661 return true;
662 }
663 tevent_req_set_callback(subreq,
664 smb2_query_directory_dos_mode_done,
665 req);
666
667 state->async_dosmode_active++;
668
669 outstanding_aio = pthreadpool_tevent_queued_jobs(
670 state->tp_chdir_safe);
671
672 if (outstanding_aio > state->max_async_dosmode_active) {
673 stop = true;
674 }
675 }
676
677 TALLOC_FREE(smb_fname);
678
679 state->num++;
680 state->out_output_buffer.length = off;
681
682 if (!state->done && state->num < state->max_count) {
683 return stop;
684 }
685
686 last_entry_done:
687 SIVAL(state->out_output_buffer.data, state->last_entry_off, 0);
688
689 state->done = true;
690
691 if (state->async_sharemode_count > 0) {
692 DBG_DEBUG("Stopping after %"PRIu64" async mtime "
693 "updates\n", state->async_sharemode_count);
694 return true;
695 }
696
697 if (state->async_dosmode_active > 0) {
698 return true;
699 }
700
701 if (state->find_async_delay_usec > 0) {
702 struct timeval tv;
703 struct tevent_req *subreq = NULL;
704
705 /*
706 * Should we only set async_internal
707 * if we're not the last request in
708 * a compound chain?
709 */
710 smb2_request_set_async_internal(state->smb2req, true);
711
712 tv = timeval_current_ofs(0, state->find_async_delay_usec);
713
714 subreq = tevent_wakeup_send(state, state->ev, tv);
715 if (tevent_req_nomem(subreq, req)) {
716 return true;
717 }
718 tevent_req_set_callback(subreq,
719 smb2_query_directory_waited,
720 req);
721 return true;
722 }
723
724 tevent_req_done(req);
725 return true;
726 }
727
728 static void smb2_query_directory_check_next_entry(struct tevent_req *req);
729
730 static void smb2_query_directory_fetch_write_time_done(struct tevent_req *subreq)
731 {
732 struct tevent_req *req = tevent_req_callback_data(
733 subreq, struct tevent_req);
734 struct smbd_smb2_query_directory_state *state = tevent_req_data(
735 req, struct smbd_smb2_query_directory_state);
736 NTSTATUS status;
737
738 state->async_sharemode_count--;
739
740 status = fetch_write_time_recv(subreq);
741 TALLOC_FREE(subreq);
742 if (tevent_req_nterror(req, status)) {
743 return;
744 }
745
746 smb2_query_directory_check_next_entry(req);
747 return;
748 }
749
750 static void smb2_query_directory_dos_mode_done(struct tevent_req *subreq)
751 {
752 struct tevent_req *req =
753 tevent_req_callback_data(subreq,
754 struct tevent_req);
755 struct smbd_smb2_query_directory_state *state =
756 tevent_req_data(req,
757 struct smbd_smb2_query_directory_state);
758 NTSTATUS status;
759
760 status = fetch_dos_mode_recv(subreq);
761 TALLOC_FREE(subreq);
762 if (tevent_req_nterror(req, status)) {
763 return;
764 }
765
766 state->async_dosmode_active--;
767
768 smb2_query_directory_check_next_entry(req);
769 return;
770 }
771
772 static void smb2_query_directory_check_next_entry(struct tevent_req *req)
773 {
774 struct smbd_smb2_query_directory_state *state = tevent_req_data(
775 req, struct smbd_smb2_query_directory_state);
776 bool stop = false;
777
778 if (!state->done) {
779 while (!stop) {
780 stop = smb2_query_directory_next_entry(req);
781 }
782 return;
783 }
784
785 if (state->async_sharemode_count > 0 ||
786 state->async_dosmode_active > 0)
787 {
788 return;
789 }
790
791 if (state->find_async_delay_usec > 0) {
792 struct timeval tv;
793 struct tevent_req *subreq = NULL;
794
795 tv = timeval_current_ofs(0, state->find_async_delay_usec);
796
797 subreq = tevent_wakeup_send(state, state->ev, tv);
798 if (tevent_req_nomem(subreq, req)) {
799 tevent_req_post(req, state->ev);
800 return;
801 }
802 tevent_req_set_callback(subreq,
803 smb2_query_directory_waited,
804 req);
805 return;
806 }
807
808 tevent_req_done(req);
809 return;
810 }
811
812 static void smb2_query_directory_waited(struct tevent_req *subreq)
813 {
814 struct tevent_req *req = tevent_req_callback_data(
815 subreq, struct tevent_req);
816 bool ok;
817
818 ok = tevent_wakeup_recv(subreq);
819 TALLOC_FREE(subreq);
820 if (!ok) {
821 tevent_req_oom(req);
822 return;
823 }
824 tevent_req_done(req);
825 }
826
827 static NTSTATUS smbd_smb2_query_directory_recv(struct tevent_req *req,
828 TALLOC_CTX *mem_ctx,
829 DATA_BLOB *out_output_buffer)
830 {
831 NTSTATUS status;
832 struct smbd_smb2_query_directory_state *state = tevent_req_data(req,
833 struct smbd_smb2_query_directory_state);
834
835 if (tevent_req_is_nterror(req, &status)) {
836 tevent_req_received(req);
837 return status;
838 }
839
840 *out_output_buffer = state->out_output_buffer;
841 talloc_steal(mem_ctx, out_output_buffer->data);
842
843 tevent_req_received(req);
844 return NT_STATUS_OK;
845 }
846
847 struct fetch_write_time_state {
848 connection_struct *conn;
849 struct file_id id;
850 int info_level;
851 char *entry_marshall_buf;
852 };
853
854 static void fetch_write_time_done(struct tevent_req *subreq);
855
856 static struct tevent_req *fetch_write_time_send(TALLOC_CTX *mem_ctx,
857 struct tevent_context *ev,
858 connection_struct *conn,
859 struct file_id id,
860 int info_level,
861 char *entry_marshall_buf,
862 bool *stop)
863 {
864 struct tevent_req *req = NULL;
865 struct fetch_write_time_state *state = NULL;
866 struct tevent_req *subreq = NULL;
867 bool req_queued;
868
869 *stop = false;
870
871 req = tevent_req_create(mem_ctx, &state, struct fetch_write_time_state);
872 if (req == NULL) {
873 return NULL;
874 }
875
876 *state = (struct fetch_write_time_state) {
877 .conn = conn,
878 .id = id,
879 .info_level = info_level,
880 .entry_marshall_buf = entry_marshall_buf,
881 };
882
883 subreq = fetch_share_mode_send(state, ev, id, &req_queued);
884 if (tevent_req_nomem(subreq, req)) {
885 return tevent_req_post(req, ev);
886 }
887 tevent_req_set_callback(subreq, fetch_write_time_done, req);
888
889 if (req_queued) {
890 *stop = true;
891 }
892 return req;
893 }
894
895 static void fetch_write_time_done(struct tevent_req *subreq)
896 {
897 struct tevent_req *req = tevent_req_callback_data(
898 subreq, struct tevent_req);
899 struct fetch_write_time_state *state = tevent_req_data(
900 req, struct fetch_write_time_state);
901 struct timespec write_time;
902 struct share_mode_lock *lck = NULL;
903 NTSTATUS status;
904 size_t off;
905
906 status = fetch_share_mode_recv(subreq, state, &lck);
907 TALLOC_FREE(subreq);
908 if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) {
909 tevent_req_done(req);
910 return;
911 }
912 if (!NT_STATUS_IS_OK(status)) {
913 tevent_req_nterror(req, status);
914 return;
915 }
916
917 write_time = get_share_mode_write_time(lck);
918 TALLOC_FREE(lck);
919
920 if (null_timespec(write_time)) {
921 tevent_req_done(req);
922 return;
923 }
924
925 switch (state->info_level) {
926 case SMB_FIND_FILE_DIRECTORY_INFO:
927 case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
928 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
929 case SMB_FIND_ID_FULL_DIRECTORY_INFO:
930 case SMB_FIND_ID_BOTH_DIRECTORY_INFO:
931 off = 24;
932 break;
933
934 default:
935 DBG_ERR("Unsupported info_level [%d]\n", state->info_level);
936 tevent_req_nterror(req, NT_STATUS_INVALID_LEVEL);
937 return;
938 }
939
940 put_long_date_timespec(state->conn->ts_res,
941 state->entry_marshall_buf + off,
942 write_time);
943
944 tevent_req_done(req);
945 return;
946 }
947
948 static NTSTATUS fetch_write_time_recv(struct tevent_req *req)
949 {
950 NTSTATUS status;
951
952 if (tevent_req_is_nterror(req, &status)) {
953 tevent_req_received(req);
954 return status;
955 }
956
957 tevent_req_received(req);
958 return NT_STATUS_OK;
959 }
960
961 struct fetch_dos_mode_state {
962 struct files_struct *dir_fsp;
963 struct smb_filename *smb_fname;
964 uint32_t info_level;
965 uint8_t *entry_marshall_buf;
966 };
967
968 static void fetch_dos_mode_done(struct tevent_req *subreq);
969
970 static struct tevent_req *fetch_dos_mode_send(
971 TALLOC_CTX *mem_ctx,
972 struct smb_vfs_ev_glue *evg,
973 struct files_struct *dir_fsp,
974 struct smb_filename **smb_fname,
975 uint32_t info_level,
976 uint8_t *entry_marshall_buf)
977 {
978 struct tevent_context *ev = smb_vfs_ev_glue_ev_ctx(evg);
979 struct tevent_req *req = NULL;
980 struct fetch_dos_mode_state *state = NULL;
981 struct tevent_req *subreq = NULL;
982
983 req = tevent_req_create(mem_ctx, &state, struct fetch_dos_mode_state);
984 if (req == NULL) {
985 return NULL;
986 }
987 *state = (struct fetch_dos_mode_state) {
988 .dir_fsp = dir_fsp,
989 .info_level = info_level,
990 .entry_marshall_buf = entry_marshall_buf,
991 };
992
993 state->smb_fname = talloc_move(state, smb_fname);
994
995 subreq = dos_mode_at_send(state, evg, dir_fsp, state->smb_fname);
996 if (tevent_req_nomem(subreq, req)) {
997 return tevent_req_post(req, ev);
998 }
999 tevent_req_set_callback(subreq, fetch_dos_mode_done, req);
1000
1001 return req;
1002 }
1003
1004 static void fetch_dos_mode_done(struct tevent_req *subreq)
1005 {
1006 struct tevent_req *req =
1007 tevent_req_callback_data(subreq,
1008 struct tevent_req);
1009 struct fetch_dos_mode_state *state =
1010 tevent_req_data(req,
1011 struct fetch_dos_mode_state);
1012 uint32_t dfs_dosmode;
1013 uint32_t dosmode;
1014 struct timespec btime_ts = {0};
1015 off_t dosmode_off;
1016 off_t btime_off;
1017 NTSTATUS status;
1018
1019 status = dos_mode_at_recv(subreq, &dosmode);
1020 TALLOC_FREE(subreq);
1021 if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) {
1022 tevent_req_done(req);
1023 return;
1024 }
1025 if (!NT_STATUS_IS_OK(status)) {
1026 tevent_req_nterror(req, status);
1027 return;
1028 }
1029
1030 switch (state->info_level) {
1031 case SMB_FIND_ID_BOTH_DIRECTORY_INFO:
1032 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
1033 case SMB_FIND_FILE_DIRECTORY_INFO:
1034 case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
1035 case SMB_FIND_ID_FULL_DIRECTORY_INFO:
1036 btime_off = 8;
1037 dosmode_off = 56;
1038 break;
1039
1040 default:
1041 DBG_ERR("Unsupported info_level [%u]\n", state->info_level);
1042 tevent_req_nterror(req, NT_STATUS_INVALID_LEVEL);
1043 return;
1044 }
1045
1046
1047 dfs_dosmode = IVAL(state->entry_marshall_buf, dosmode_off);
1048 if (dfs_dosmode == 0) {
1049 /*
1050 * DOS mode for a DFS link, only overwrite if still set to 0 and
1051 * not already populated by the lower layer for a DFS link in
1052 * smbd_dirptr_lanman2_mode_fn().
1053 */
1054 SIVAL(state->entry_marshall_buf, dosmode_off, dosmode);
1055 }
1056
1057 btime_ts = get_create_timespec(state->dir_fsp->conn,
1058 NULL,
1059 state->smb_fname);
1060 if (lp_dos_filetime_resolution(SNUM(state->dir_fsp->conn))) {
1061 dos_filetime_timespec(&btime_ts);
1062 }
1063
1064 put_long_date_timespec(state->dir_fsp->conn->ts_res,
1065 (char *)state->entry_marshall_buf + btime_off,
1066 btime_ts);
1067
1068 tevent_req_done(req);
1069 return;
1070 }
1071
1072 static NTSTATUS fetch_dos_mode_recv(struct tevent_req *req)
1073 {
1074 NTSTATUS status;
1075
1076 if (tevent_req_is_nterror(req, &status)) {
1077 tevent_req_received(req);
1078 return status;
1079 }
1080
1081 tevent_req_received(req);
1082 return NT_STATUS_OK;
1083 }
Samba GIT mirror