s3:smbd: don't use async dosmode if per-thread cwd is not available
[samba.git] / source3 / smbd / smb2_query_directory.c
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->sconn->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 tevent_context *ev,
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 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;
230         uint32_t info_level;
231         uint32_t max_count;
232         char *pdata;
233         char *base_data;
234         char *end_data;
235         uint32_t num;
236         uint32_t dirtype;
237         bool dont_descend;
238         bool ask_sharemode;
239         bool async_dosmode;
240         bool async_ask_sharemode;
241         int last_entry_off;
242         size_t max_async_dosmode_active;
243         uint32_t async_dosmode_active;
244         bool done;
245 };
246
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);
251
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,
257                                               uint8_t in_flags,
258                                               uint32_t in_file_index,
259                                               uint32_t in_output_buffer_length,
260                                               const char *in_file_name)
261 {
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;
266         NTSTATUS status;
267         bool wcard_has_wild = false;
268         struct tm tm;
269         char *p;
270         bool stop = false;
271         bool ok;
272
273         req = tevent_req_create(mem_ctx, &state,
274                                 struct smbd_smb2_query_directory_state);
275         if (req == NULL) {
276                 return NULL;
277         }
278         state->ev = ev;
279         state->fsp = fsp;
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;
285
286         DEBUG(10,("smbd_smb2_query_directory_send: %s - %s\n",
287                   fsp_str_dbg(fsp), fsp_fnum_dbg(fsp)));
288
289         state->smbreq = smbd_smb2_fake_smb_request(smb2req);
290         if (tevent_req_nomem(state->smbreq, req)) {
291                 return tevent_req_post(req, ev);
292         }
293
294         if (!fsp->is_directory) {
295                 tevent_req_nterror(req, NT_STATUS_NOT_SUPPORTED);
296                 return tevent_req_post(req, ev);
297         }
298
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);
302         }
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);
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
312         p = strptime(state->in_file_name, GMT_FORMAT, &tm);
313         if ((p != NULL) && (*p =='\0')) {
314                 /*
315                  * Bogus find that asks for a shadow copy timestamp as a
316                  * directory. The correct response is that it does not exist as
317                  * a directory.
318                  */
319                 tevent_req_nterror(req, NT_STATUS_NO_SUCH_FILE);
320                 return tevent_req_post(req, ev);
321         }
322
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);
330         }
331
332         status = smbd_smb2_request_verify_creditcharge(smb2req,
333                                         in_output_buffer_length);
334
335         if (!NT_STATUS_IS_OK(status)) {
336                 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
337                 return tevent_req_post(req, ev);
338         }
339
340         switch (in_file_info_class) {
341         case SMB2_FIND_DIRECTORY_INFO:
342                 state->info_level = SMB_FIND_FILE_DIRECTORY_INFO;
343                 break;
344
345         case SMB2_FIND_FULL_DIRECTORY_INFO:
346                 state->info_level = SMB_FIND_FILE_FULL_DIRECTORY_INFO;
347                 break;
348
349         case SMB2_FIND_BOTH_DIRECTORY_INFO:
350                 state->info_level = SMB_FIND_FILE_BOTH_DIRECTORY_INFO;
351                 break;
352
353         case SMB2_FIND_NAME_INFO:
354                 state->info_level = SMB_FIND_FILE_NAMES_INFO;
355                 break;
356
357         case SMB2_FIND_ID_BOTH_DIRECTORY_INFO:
358                 state->info_level = SMB_FIND_ID_BOTH_DIRECTORY_INFO;
359                 break;
360
361         case SMB2_FIND_ID_FULL_DIRECTORY_INFO:
362                 state->info_level = SMB_FIND_ID_FULL_DIRECTORY_INFO;
363                 break;
364
365         default:
366                 tevent_req_nterror(req, NT_STATUS_INVALID_INFO_CLASS);
367                 return tevent_req_post(req, ev);
368         }
369
370         if (in_flags & SMB2_CONTINUE_FLAG_REOPEN) {
371                 int flags;
372
373                 status = fd_close(fsp);
374                 if (tevent_req_nterror(req, status)) {
375                         return tevent_req_post(req, ev);
376                 }
377
378                 /*
379                  * fd_close() will close and invalidate the fsp's file
380                  * descriptor. So we have to reopen it.
381                  */
382
383                 flags = O_RDONLY;
384 #ifdef O_DIRECTORY
385                 flags |= O_DIRECTORY;
386 #endif
387                 status = fd_open(conn, fsp, flags, 0);
388                 if (tevent_req_nterror(req, status)) {
389                         return tevent_req_post(req, ev);
390                 }
391         }
392
393         if (!state->smbreq->posix_pathnames) {
394                 wcard_has_wild = ms_has_wild(state->in_file_name);
395         }
396
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);
407
408                 if (ISDOT(fsp->fsp_name->base_name)) {
409                         fullpath = state->in_file_name;
410                 } else {
411                         size_t len;
412                         char *tmp;
413
414                         len = full_path_tos(
415                                 fsp->fsp_name->base_name, state->in_file_name,
416                                 tmpbuf, sizeof(tmpbuf), &tmp, &to_free);
417                         if (len == -1) {
418                                 tevent_req_oom(req);
419                                 return tevent_req_post(req, ev);
420                         }
421                         fullpath = tmp;
422                 }
423                 status = filename_convert(state,
424                                 conn,
425                                 fullpath,
426                                 ucf_flags,
427                                 NULL,
428                                 &wcard_has_wild,
429                                 &smb_fname);
430
431                 TALLOC_FREE(to_free);
432
433                 if (tevent_req_nterror(req, status)) {
434                         return tevent_req_post(req, ev);
435                 }
436
437                 state->in_file_name = smb_fname->original_lcomp;
438         }
439
440         if (fsp->dptr == NULL) {
441                 status = dptr_create(conn,
442                                      NULL, /* req */
443                                      fsp,
444                                      fsp->fsp_name,
445                                      false, /* old_handle */
446                                      false, /* expect_close */
447                                      0, /* spid */
448                                      state->in_file_name, /* wcard */
449                                      wcard_has_wild,
450                                      state->dirtype,
451                                      &fsp->dptr);
452                 if (!NT_STATUS_IS_OK(status)) {
453                         tevent_req_nterror(req, status);
454                         return tevent_req_post(req, ev);
455                 }
456
457                 state->empty_status = NT_STATUS_NO_SUCH_FILE;
458         } else {
459                 state->empty_status = STATUS_NO_MORE_FILES;
460         }
461
462         if (in_flags & SMB2_CONTINUE_FLAG_RESTART) {
463                 dptr_SeekDir(fsp->dptr, 0);
464         }
465
466         if (in_flags & SMB2_CONTINUE_FLAG_SINGLE) {
467                 state->max_count = 1;
468         } else {
469                 state->max_count = UINT16_MAX;
470         }
471
472 #define DIR_ENTRY_SAFETY_MARGIN 4096
473
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);
478         }
479
480         state->out_output_buffer.length = 0;
481         state->pdata = (char *)state->out_output_buffer.data;
482         state->base_data = state->pdata;
483         /*
484          * end_data must include the safety margin as it's what is
485          * used to determine if pushed strings have been truncated.
486          */
487         state->end_data = state->pdata + in_output_buffer_length + DIR_ENTRY_SAFETY_MARGIN - 1;
488
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;
496         }
497
498         /*
499          * SMB_FIND_FILE_NAMES_INFO doesn't need stat information
500          *
501          * This may change when we try to improve the delete on close
502          * handling in future.
503          */
504         if (state->info_level != SMB_FIND_FILE_NAMES_INFO) {
505                 state->ask_sharemode = lp_smbd_search_ask_sharemode(SNUM(conn));
506
507                 state->async_dosmode = lp_smbd_async_dosmode(SNUM(conn));
508         }
509
510         if (state->ask_sharemode && lp_clustering()) {
511                 state->ask_sharemode = false;
512                 state->async_ask_sharemode = true;
513         }
514
515         if (state->async_dosmode) {
516                 size_t max_threads;
517
518                 max_threads = pthreadpool_tevent_max_threads(conn->sconn->pool);
519                 if (max_threads == 0 || !per_thread_cwd_supported()) {
520                         state->async_dosmode = false;
521                 }
522
523                 state->max_async_dosmode_active = lp_smbd_max_async_dosmode(
524                                                         SNUM(conn));
525                 if (state->max_async_dosmode_active == 0) {
526                         state->max_async_dosmode_active = max_threads * 2;
527                 }
528         }
529
530         if (state->async_dosmode || state->async_ask_sharemode) {
531                 /*
532                  * Should we only set async_internal
533                  * if we're not the last request in
534                  * a compound chain?
535                  */
536                 smb2_request_set_async_internal(smb2req, true);
537         }
538
539         /*
540          * This gets set in autobuild for some tests
541          */
542         state->find_async_delay_usec = lp_parm_ulong(SNUM(conn), "smbd",
543                                                      "find async delay usec",
544                                                      0);
545
546         while (!stop) {
547                 stop = smb2_query_directory_next_entry(req);
548         }
549
550         if (!tevent_req_is_in_progress(req)) {
551                 return tevent_req_post(req, ev);
552         }
553
554         ok = aio_add_req_to_fsp(fsp, req);
555         if (!ok) {
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);
559         }
560
561         return req;
562 }
563
564 static bool smb2_query_directory_next_entry(struct tevent_req *req)
565 {
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;
573         NTSTATUS status;
574         bool get_dosmode = !state->async_dosmode;
575         bool stop = false;
576
577         SMB_ASSERT(space_remaining >= 0);
578
579         status = smbd_dirptr_lanman2_entry(state,
580                                            state->fsp->conn,
581                                            state->fsp->dptr,
582                                            state->smbreq->flags2,
583                                            state->in_file_name,
584                                            state->dirtype,
585                                            state->info_level,
586                                            false, /* requires_resume_key */
587                                            state->dont_descend,
588                                            state->ask_sharemode,
589                                            get_dosmode,
590                                            8, /* align to 8 bytes */
591                                            false, /* no padding */
592                                            &state->pdata,
593                                            state->base_data,
594                                            state->end_data,
595                                            space_remaining,
596                                            &smb_fname,
597                                            &got_exact_match,
598                                            &state->last_entry_off,
599                                            NULL,
600                                            &file_id);
601
602         off = (int)PTR_DIFF(state->pdata, state->base_data);
603
604         if (!NT_STATUS_IS_OK(status)) {
605                 if (NT_STATUS_EQUAL(status, NT_STATUS_ILLEGAL_CHARACTER)) {
606                         /*
607                          * Bad character conversion on name. Ignore this
608                          * entry.
609                          */
610                         return false;
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);
615                         return true;
616                 } else {
617                         tevent_req_nterror(req, state->empty_status);
618                         return true;
619                 }
620         }
621
622         if (state->async_ask_sharemode) {
623                 struct tevent_req *subreq = NULL;
624                 char *buf = state->base_data + state->last_entry_off;
625
626                 subreq = fetch_write_time_send(state,
627                                                state->ev,
628                                                state->fsp->conn,
629                                                file_id,
630                                                state->info_level,
631                                                buf,
632                                                &stop);
633                 if (tevent_req_nomem(subreq, req)) {
634                         return true;
635                 }
636                 tevent_req_set_callback(
637                         subreq,
638                         smb2_query_directory_fetch_write_time_done,
639                         req);
640                 state->async_sharemode_count++;
641         }
642
643         if (state->async_dosmode) {
644                 struct tevent_req *subreq = NULL;
645                 uint8_t *buf = NULL;
646                 size_t outstanding_aio;
647
648                 buf = (uint8_t *)state->base_data + state->last_entry_off;
649
650                 subreq = fetch_dos_mode_send(state,
651                                              state->ev,
652                                              state->fsp,
653                                              &smb_fname,
654                                              state->info_level,
655                                              buf);
656                 if (tevent_req_nomem(subreq, req)) {
657                         return true;
658                 }
659                 tevent_req_set_callback(subreq,
660                                         smb2_query_directory_dos_mode_done,
661                                         req);
662
663                 state->async_dosmode_active++;
664
665                 outstanding_aio = pthreadpool_tevent_queued_jobs(
666                                         state->fsp->conn->sconn->pool);
667
668                 if (outstanding_aio > state->max_async_dosmode_active) {
669                         stop = true;
670                 }
671         }
672
673         TALLOC_FREE(smb_fname);
674
675         state->num++;
676         state->out_output_buffer.length = off;
677
678         if (!state->done && state->num < state->max_count) {
679                 return stop;
680         }
681
682 last_entry_done:
683         SIVAL(state->out_output_buffer.data, state->last_entry_off, 0);
684
685         state->done = true;
686
687         if (state->async_sharemode_count > 0) {
688                 DBG_DEBUG("Stopping after %"PRIu64" async mtime "
689                           "updates\n", state->async_sharemode_count);
690                 return true;
691         }
692
693         if (state->async_dosmode_active > 0) {
694                 return true;
695         }
696
697         if (state->find_async_delay_usec > 0) {
698                 struct timeval tv;
699                 struct tevent_req *subreq = NULL;
700
701                 /*
702                  * Should we only set async_internal
703                  * if we're not the last request in
704                  * a compound chain?
705                  */
706                 smb2_request_set_async_internal(state->smb2req, true);
707
708                 tv = timeval_current_ofs(0, state->find_async_delay_usec);
709
710                 subreq = tevent_wakeup_send(state, state->ev, tv);
711                 if (tevent_req_nomem(subreq, req)) {
712                         return true;
713                 }
714                 tevent_req_set_callback(subreq,
715                                         smb2_query_directory_waited,
716                                         req);
717                 return true;
718         }
719
720         tevent_req_done(req);
721         return true;
722 }
723
724 static void smb2_query_directory_check_next_entry(struct tevent_req *req);
725
726 static void smb2_query_directory_fetch_write_time_done(struct tevent_req *subreq)
727 {
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);
732         NTSTATUS status;
733
734         state->async_sharemode_count--;
735
736         status = fetch_write_time_recv(subreq);
737         TALLOC_FREE(subreq);
738         if (tevent_req_nterror(req, status)) {
739                 return;
740         }
741
742         smb2_query_directory_check_next_entry(req);
743         return;
744 }
745
746 static void smb2_query_directory_dos_mode_done(struct tevent_req *subreq)
747 {
748         struct tevent_req *req =
749                 tevent_req_callback_data(subreq,
750                 struct tevent_req);
751         struct smbd_smb2_query_directory_state *state =
752                 tevent_req_data(req,
753                 struct smbd_smb2_query_directory_state);
754         NTSTATUS status;
755
756         status = fetch_dos_mode_recv(subreq);
757         TALLOC_FREE(subreq);
758         if (tevent_req_nterror(req, status)) {
759                 return;
760         }
761
762         state->async_dosmode_active--;
763
764         smb2_query_directory_check_next_entry(req);
765         return;
766 }
767
768 static void smb2_query_directory_check_next_entry(struct tevent_req *req)
769 {
770         struct smbd_smb2_query_directory_state *state = tevent_req_data(
771                 req, struct smbd_smb2_query_directory_state);
772         bool stop = false;
773
774         if (!state->done) {
775                 while (!stop) {
776                         stop = smb2_query_directory_next_entry(req);
777                 }
778                 return;
779         }
780
781         if (state->async_sharemode_count > 0 ||
782             state->async_dosmode_active > 0)
783         {
784                 return;
785         }
786
787         if (state->find_async_delay_usec > 0) {
788                 struct timeval tv;
789                 struct tevent_req *subreq = NULL;
790
791                 tv = timeval_current_ofs(0, state->find_async_delay_usec);
792
793                 subreq = tevent_wakeup_send(state, state->ev, tv);
794                 if (tevent_req_nomem(subreq, req)) {
795                         tevent_req_post(req, state->ev);
796                         return;
797                 }
798                 tevent_req_set_callback(subreq,
799                                         smb2_query_directory_waited,
800                                         req);
801                 return;
802         }
803
804         tevent_req_done(req);
805         return;
806 }
807
808 static void smb2_query_directory_waited(struct tevent_req *subreq)
809 {
810         struct tevent_req *req = tevent_req_callback_data(
811                 subreq, struct tevent_req);
812         bool ok;
813
814         ok = tevent_wakeup_recv(subreq);
815         TALLOC_FREE(subreq);
816         if (!ok) {
817                 tevent_req_oom(req);
818                 return;
819         }
820         tevent_req_done(req);
821 }
822
823 static NTSTATUS smbd_smb2_query_directory_recv(struct tevent_req *req,
824                                     TALLOC_CTX *mem_ctx,
825                                     DATA_BLOB *out_output_buffer)
826 {
827         NTSTATUS status;
828         struct smbd_smb2_query_directory_state *state = tevent_req_data(req,
829                                              struct smbd_smb2_query_directory_state);
830
831         if (tevent_req_is_nterror(req, &status)) {
832                 tevent_req_received(req);
833                 return status;
834         }
835
836         *out_output_buffer = state->out_output_buffer;
837         talloc_steal(mem_ctx, out_output_buffer->data);
838
839         tevent_req_received(req);
840         return NT_STATUS_OK;
841 }
842
843 struct fetch_write_time_state {
844         connection_struct *conn;
845         struct file_id id;
846         int info_level;
847         char *entry_marshall_buf;
848 };
849
850 static void fetch_write_time_done(struct tevent_req *subreq);
851
852 static struct tevent_req *fetch_write_time_send(TALLOC_CTX *mem_ctx,
853                                                 struct tevent_context *ev,
854                                                 connection_struct *conn,
855                                                 struct file_id id,
856                                                 int info_level,
857                                                 char *entry_marshall_buf,
858                                                 bool *stop)
859 {
860         struct tevent_req *req = NULL;
861         struct fetch_write_time_state *state = NULL;
862         struct tevent_req *subreq = NULL;
863         bool req_queued;
864
865         *stop = false;
866
867         req = tevent_req_create(mem_ctx, &state, struct fetch_write_time_state);
868         if (req == NULL) {
869                 return NULL;
870         }
871
872         *state = (struct fetch_write_time_state) {
873                 .conn = conn,
874                 .id = id,
875                 .info_level = info_level,
876                 .entry_marshall_buf = entry_marshall_buf,
877         };
878
879         subreq = fetch_share_mode_send(state, ev, id, &req_queued);
880         if (tevent_req_nomem(subreq, req)) {
881                 return tevent_req_post(req, ev);
882         }
883         tevent_req_set_callback(subreq, fetch_write_time_done, req);
884
885         if (req_queued) {
886                 *stop = true;
887         }
888         return req;
889 }
890
891 static void fetch_write_time_done(struct tevent_req *subreq)
892 {
893         struct tevent_req *req = tevent_req_callback_data(
894                 subreq, struct tevent_req);
895         struct fetch_write_time_state *state = tevent_req_data(
896                 req, struct fetch_write_time_state);
897         struct timespec write_time;
898         struct share_mode_lock *lck = NULL;
899         NTSTATUS status;
900         size_t off;
901
902         status = fetch_share_mode_recv(subreq, state, &lck);
903         TALLOC_FREE(subreq);
904         if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) {
905                 tevent_req_done(req);
906                 return;
907         }
908         if (!NT_STATUS_IS_OK(status)) {
909                 tevent_req_nterror(req, status);
910                 return;
911         }
912
913         write_time = get_share_mode_write_time(lck);
914         TALLOC_FREE(lck);
915
916         if (null_timespec(write_time)) {
917                 tevent_req_done(req);
918                 return;
919         }
920
921         switch (state->info_level) {
922         case SMB_FIND_FILE_DIRECTORY_INFO:
923         case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
924         case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
925         case SMB_FIND_ID_FULL_DIRECTORY_INFO:
926         case SMB_FIND_ID_BOTH_DIRECTORY_INFO:
927                 off = 24;
928                 break;
929
930         default:
931                 DBG_ERR("Unsupported info_level [%d]\n", state->info_level);
932                 tevent_req_nterror(req, NT_STATUS_INVALID_LEVEL);
933                 return;
934         }
935
936         put_long_date_timespec(state->conn->ts_res,
937                                state->entry_marshall_buf + off,
938                                write_time);
939
940         tevent_req_done(req);
941         return;
942 }
943
944 static NTSTATUS fetch_write_time_recv(struct tevent_req *req)
945 {
946         NTSTATUS status;
947
948         if (tevent_req_is_nterror(req, &status)) {
949                 tevent_req_received(req);
950                 return status;
951         }
952
953         tevent_req_received(req);
954         return NT_STATUS_OK;
955 }
956
957 struct fetch_dos_mode_state {
958         struct files_struct *dir_fsp;
959         struct smb_filename *smb_fname;
960         uint32_t info_level;
961         uint8_t *entry_marshall_buf;
962 };
963
964 static void fetch_dos_mode_done(struct tevent_req *subreq);
965
966 static struct tevent_req *fetch_dos_mode_send(
967                         TALLOC_CTX *mem_ctx,
968                         struct tevent_context *ev,
969                         struct files_struct *dir_fsp,
970                         struct smb_filename **smb_fname,
971                         uint32_t info_level,
972                         uint8_t *entry_marshall_buf)
973 {
974         struct tevent_req *req = NULL;
975         struct fetch_dos_mode_state *state = NULL;
976         struct tevent_req *subreq = NULL;
977
978         req = tevent_req_create(mem_ctx, &state, struct fetch_dos_mode_state);
979         if (req == NULL) {
980                 return NULL;
981         }
982         *state = (struct fetch_dos_mode_state) {
983                 .dir_fsp = dir_fsp,
984                 .info_level = info_level,
985                 .entry_marshall_buf = entry_marshall_buf,
986         };
987
988         state->smb_fname = talloc_move(state, smb_fname);
989
990         subreq = dos_mode_at_send(state, ev, dir_fsp, state->smb_fname);
991         if (tevent_req_nomem(subreq, req)) {
992                 return tevent_req_post(req, ev);
993         }
994         tevent_req_set_callback(subreq, fetch_dos_mode_done, req);
995
996         return req;
997 }
998
999 static void fetch_dos_mode_done(struct tevent_req *subreq)
1000 {
1001         struct tevent_req *req =
1002                 tevent_req_callback_data(subreq,
1003                 struct tevent_req);
1004         struct fetch_dos_mode_state *state =
1005                 tevent_req_data(req,
1006                 struct fetch_dos_mode_state);
1007         uint32_t dfs_dosmode;
1008         uint32_t dosmode;
1009         struct timespec btime_ts = {0};
1010         off_t dosmode_off;
1011         off_t btime_off;
1012         NTSTATUS status;
1013
1014         status = dos_mode_at_recv(subreq, &dosmode);
1015         TALLOC_FREE(subreq);
1016         if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) {
1017                 tevent_req_done(req);
1018                 return;
1019         }
1020         if (!NT_STATUS_IS_OK(status)) {
1021                 tevent_req_nterror(req, status);
1022                 return;
1023         }
1024
1025         switch (state->info_level) {
1026         case SMB_FIND_ID_BOTH_DIRECTORY_INFO:
1027         case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
1028         case SMB_FIND_FILE_DIRECTORY_INFO:
1029         case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
1030         case SMB_FIND_ID_FULL_DIRECTORY_INFO:
1031                 btime_off = 8;
1032                 dosmode_off = 56;
1033                 break;
1034
1035         default:
1036                 DBG_ERR("Unsupported info_level [%u]\n", state->info_level);
1037                 tevent_req_nterror(req, NT_STATUS_INVALID_LEVEL);
1038                 return;
1039         }
1040
1041
1042         dfs_dosmode = IVAL(state->entry_marshall_buf, dosmode_off);
1043         if (dfs_dosmode == 0) {
1044                 /*
1045                  * DOS mode for a DFS link, only overwrite if still set to 0 and
1046                  * not already populated by the lower layer for a DFS link in
1047                  * smbd_dirptr_lanman2_mode_fn().
1048                  */
1049                 SIVAL(state->entry_marshall_buf, dosmode_off, dosmode);
1050         }
1051
1052         btime_ts = get_create_timespec(state->dir_fsp->conn,
1053                                        NULL,
1054                                        state->smb_fname);
1055         if (lp_dos_filetime_resolution(SNUM(state->dir_fsp->conn))) {
1056                 dos_filetime_timespec(&btime_ts);
1057         }
1058
1059         put_long_date_timespec(state->dir_fsp->conn->ts_res,
1060                                (char *)state->entry_marshall_buf + btime_off,
1061                                btime_ts);
1062
1063         tevent_req_done(req);
1064         return;
1065 }
1066
1067 static NTSTATUS fetch_dos_mode_recv(struct tevent_req *req)
1068 {
1069         NTSTATUS status;
1070
1071         if (tevent_req_is_nterror(req, &status)) {
1072                 tevent_req_received(req);
1073                 return status;
1074         }
1075
1076         tevent_req_received(req);
1077         return NT_STATUS_OK;
1078 }