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