source3/smbd/smb2_ioctl_network_fs.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Core SMB2 server
   4
   5    Copyright (C) Stefan Metzmacher 2009
   6    Copyright (C) David Disseldorp 2012
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 #include "includes.h"
  23 #include "smbd/smbd.h"
  24 #include "smbd/globals.h"
  25 #include "../libcli/smb/smb_common.h"
  26 #include "../libcli/security/security.h"
  27 #include "../lib/util/tevent_ntstatus.h"
  28 #include "../lib/ccan/build_assert/build_assert.h"
  29 #include "include/ntioctl.h"
  30 #include "../librpc/ndr/libndr.h"
  31 #include "librpc/gen_ndr/ndr_ioctl.h"
  32 #include "smb2_ioctl_private.h"
  33
  34 #define COPYCHUNK_MAX_CHUNKS    256             /* 2k8r2 & win8 = 256 */
  35 #define COPYCHUNK_MAX_CHUNK_LEN 1048576         /* 2k8r2 & win8 = 1048576 */
  36 #define COPYCHUNK_MAX_TOTAL_LEN 16777216        /* 2k8r2 & win8 = 16777216 */
  37 static void copychunk_pack_limits(struct srv_copychunk_rsp *cc_rsp)
  38 {
  39         cc_rsp->chunks_written = COPYCHUNK_MAX_CHUNKS;
  40         cc_rsp->chunk_bytes_written = COPYCHUNK_MAX_CHUNK_LEN;
  41         cc_rsp->total_bytes_written = COPYCHUNK_MAX_TOTAL_LEN;
  42 }
  43
  44 static NTSTATUS copychunk_check_limits(struct srv_copychunk_copy *cc_copy)
  45 {
  46         uint32_t i;
  47         uint32_t total_len = 0;
  48
  49         if (cc_copy->chunk_count > COPYCHUNK_MAX_CHUNKS) {
  50                 return NT_STATUS_INVALID_PARAMETER;
  51         }
  52
  53         for (i = 0; i < cc_copy->chunk_count; i++) {
  54                 if (cc_copy->chunks[i].length > COPYCHUNK_MAX_CHUNK_LEN) {
  55                         return NT_STATUS_INVALID_PARAMETER;
  56                 }
  57                 total_len += cc_copy->chunks[i].length;
  58         }
  59         if (total_len > COPYCHUNK_MAX_TOTAL_LEN) {
  60                 return NT_STATUS_INVALID_PARAMETER;
  61         }
  62
  63         return NT_STATUS_OK;
  64 }
  65
  66 struct fsctl_srv_copychunk_state {
  67         struct connection_struct *conn;
  68         uint32_t dispatch_count;
  69         uint32_t recv_count;
  70         uint32_t bad_recv_count;
  71         NTSTATUS status;
  72         off_t total_written;
  73         struct files_struct *src_fsp;
  74         struct files_struct *dst_fsp;
  75         enum {
  76                 COPYCHUNK_OUT_EMPTY = 0,
  77                 COPYCHUNK_OUT_LIMITS,
  78                 COPYCHUNK_OUT_RSP,
  79         } out_data;
  80 };
  81 static void fsctl_srv_copychunk_vfs_done(struct tevent_req *subreq);
  82
  83 static NTSTATUS copychunk_check_handles(uint32_t ctl_code,
  84                                         struct files_struct *src_fsp,
  85                                         struct files_struct *dst_fsp,
  86                                         struct smb_request *smb1req)
  87 {
  88         /*
  89          * [MS-SMB2] 3.3.5.15.6 Handling a Server-Side Data Copy Request
  90          * The server MUST fail the request with STATUS_ACCESS_DENIED if any of
  91          * the following are true:
  92          * - The Open.GrantedAccess of the destination file does not include
  93          *   FILE_WRITE_DATA or FILE_APPEND_DATA.
  94          */
  95         if (!CHECK_WRITE(dst_fsp)) {
  96                 DEBUG(5, ("copy chunk no write on dest handle (%s).\n",
  97                         smb_fname_str_dbg(dst_fsp->fsp_name) ));
  98                 return NT_STATUS_ACCESS_DENIED;
  99         }
 100         /*
 101          * - The Open.GrantedAccess of the destination file does not include
 102          *   FILE_READ_DATA, and the CtlCode is FSCTL_SRV_COPYCHUNK.
 103          */
 104         if ((ctl_code == FSCTL_SRV_COPYCHUNK)
 105           && !CHECK_READ(dst_fsp, smb1req)) {
 106                 DEBUG(5, ("copy chunk no read on dest handle (%s).\n",
 107                         smb_fname_str_dbg(dst_fsp->fsp_name) ));
 108                 return NT_STATUS_ACCESS_DENIED;
 109         }
 110         /*
 111          * - The Open.GrantedAccess of the source file does not include
 112          *   FILE_READ_DATA access.
 113          */
 114         if (!CHECK_READ(src_fsp, smb1req)) {
 115                 DEBUG(5, ("copy chunk no read on src handle (%s).\n",
 116                         smb_fname_str_dbg(src_fsp->fsp_name) ));
 117                 return NT_STATUS_ACCESS_DENIED;
 118         }
 119
 120         if (src_fsp->is_directory) {
 121                 DEBUG(5, ("copy chunk no read on src directory handle (%s).\n",
 122                         smb_fname_str_dbg(src_fsp->fsp_name) ));
 123                 return NT_STATUS_ACCESS_DENIED;
 124         }
 125
 126         if (dst_fsp->is_directory) {
 127                 DEBUG(5, ("copy chunk no read on dst directory handle (%s).\n",
 128                         smb_fname_str_dbg(dst_fsp->fsp_name) ));
 129                 return NT_STATUS_ACCESS_DENIED;
 130         }
 131
 132         if (IS_IPC(src_fsp->conn) || IS_IPC(dst_fsp->conn)) {
 133                 DEBUG(5, ("copy chunk no access on IPC$ handle.\n"));
 134                 return NT_STATUS_ACCESS_DENIED;
 135         }
 136
 137         if (IS_PRINT(src_fsp->conn) || IS_PRINT(dst_fsp->conn)) {
 138                 DEBUG(5, ("copy chunk no access on PRINT handle.\n"));
 139                 return NT_STATUS_ACCESS_DENIED;
 140         }
 141
 142         return NT_STATUS_OK;
 143 }
 144
 145 static struct tevent_req *fsctl_srv_copychunk_send(TALLOC_CTX *mem_ctx,
 146                                                    struct tevent_context *ev,
 147                                                    uint32_t ctl_code,
 148                                                    struct files_struct *dst_fsp,
 149                                                    DATA_BLOB *in_input,
 150                                                    size_t in_max_output,
 151                                                    struct smbd_smb2_request *smb2req)
 152 {
 153         struct tevent_req *req;
 154         struct srv_copychunk_copy cc_copy;
 155         enum ndr_err_code ndr_ret;
 156         uint64_t src_persistent_h;
 157         uint64_t src_volatile_h;
 158         int i;
 159         struct srv_copychunk *chunk;
 160         struct fsctl_srv_copychunk_state *state;
 161
 162         /* handler for both copy-chunk variants */
 163         SMB_ASSERT((ctl_code == FSCTL_SRV_COPYCHUNK)
 164                 || (ctl_code == FSCTL_SRV_COPYCHUNK_WRITE));
 165
 166         req = tevent_req_create(mem_ctx, &state,
 167                                 struct fsctl_srv_copychunk_state);
 168         if (req == NULL) {
 169                 return NULL;
 170         }
 171         state->conn = dst_fsp->conn;
 172
 173         if (in_max_output < sizeof(struct srv_copychunk_rsp)) {
 174                 DEBUG(3, ("max output %d not large enough to hold copy chunk "
 175                           "response %lu\n", (int)in_max_output,
 176                           (unsigned long)sizeof(struct srv_copychunk_rsp)));
 177                 state->status = NT_STATUS_INVALID_PARAMETER;
 178                 tevent_req_nterror(req, state->status);
 179                 return tevent_req_post(req, ev);
 180         }
 181
 182         ndr_ret = ndr_pull_struct_blob(in_input, mem_ctx, &cc_copy,
 183                         (ndr_pull_flags_fn_t)ndr_pull_srv_copychunk_copy);
 184         if (ndr_ret != NDR_ERR_SUCCESS) {
 185                 DEBUG(0, ("failed to unmarshall copy chunk req\n"));
 186                 state->status = NT_STATUS_INVALID_PARAMETER;
 187                 tevent_req_nterror(req, state->status);
 188                 return tevent_req_post(req, ev);
 189         }
 190
 191         /* persistent/volatile keys sent as the resume key */
 192         src_persistent_h = BVAL(cc_copy.source_key, 0);
 193         src_volatile_h = BVAL(cc_copy.source_key, 8);
 194         state->src_fsp = file_fsp_get(smb2req, src_persistent_h, src_volatile_h);
 195         if (state->src_fsp == NULL) {
 196                 DEBUG(3, ("invalid resume key in copy chunk req\n"));
 197                 state->status = NT_STATUS_OBJECT_NAME_NOT_FOUND;
 198                 tevent_req_nterror(req, state->status);
 199                 return tevent_req_post(req, ev);
 200         }
 201
 202         state->dst_fsp = dst_fsp;
 203
 204         state->status = copychunk_check_handles(ctl_code,
 205                                                 state->src_fsp,
 206                                                 state->dst_fsp,
 207                                                 smb2req->smb1req);
 208         if (!NT_STATUS_IS_OK(state->status)) {
 209                 tevent_req_nterror(req, state->status);
 210                 return tevent_req_post(req, ev);
 211         }
 212
 213         state->status = copychunk_check_limits(&cc_copy);
 214         if (tevent_req_nterror(req, state->status)) {
 215                 DEBUG(3, ("copy chunk req exceeds limits\n"));
 216                 state->out_data = COPYCHUNK_OUT_LIMITS;
 217                 return tevent_req_post(req, ev);
 218         }
 219
 220         /* any errors from here onwards should carry copychunk response data */
 221         state->out_data = COPYCHUNK_OUT_RSP;
 222
 223         for (i = 0; i < cc_copy.chunk_count; i++) {
 224                 struct tevent_req *vfs_subreq;
 225                 chunk = &cc_copy.chunks[i];
 226                 vfs_subreq = SMB_VFS_COPY_CHUNK_SEND(dst_fsp->conn,
 227                                                      state, ev,
 228                                                      state->src_fsp,
 229                                                      chunk->source_off,
 230                                                      state->dst_fsp,
 231                                                      chunk->target_off,
 232                                                      chunk->length);
 233                 if (vfs_subreq == NULL) {
 234                         DEBUG(0, ("VFS copy chunk send failed\n"));
 235                         state->status = NT_STATUS_NO_MEMORY;
 236                         if (state->dispatch_count == 0) {
 237                                 /* nothing dispatched, return immediately */
 238                                 tevent_req_nterror(req, state->status);
 239                                 return tevent_req_post(req, ev);
 240                         } else {
 241                                 /*
 242                                  * wait for dispatched to complete before
 243                                  * returning error.
 244                                  */
 245                                 break;
 246                         }
 247                 }
 248                 tevent_req_set_callback(vfs_subreq,
 249                                         fsctl_srv_copychunk_vfs_done, req);
 250                 state->dispatch_count++;
 251         }
 252
 253         return req;
 254 }
 255
 256 static void fsctl_srv_copychunk_vfs_done(struct tevent_req *subreq)
 257 {
 258         struct tevent_req *req = tevent_req_callback_data(
 259                 subreq, struct tevent_req);
 260         struct fsctl_srv_copychunk_state *state = tevent_req_data(req,
 261                                         struct fsctl_srv_copychunk_state);
 262         off_t chunk_nwritten;
 263         NTSTATUS status;
 264
 265         state->recv_count++;
 266         status = SMB_VFS_COPY_CHUNK_RECV(state->conn, subreq,
 267                                          &chunk_nwritten);
 268         TALLOC_FREE(subreq);
 269         if (NT_STATUS_IS_OK(status)) {
 270                 DEBUG(10, ("good copy chunk recv %u of %u\n",
 271                            (unsigned int)state->recv_count,
 272                            (unsigned int)state->dispatch_count));
 273                 state->total_written += chunk_nwritten;
 274         } else {
 275                 DEBUG(0, ("bad status in copy chunk recv %u of %u: %s\n",
 276                           (unsigned int)state->recv_count,
 277                           (unsigned int)state->dispatch_count,
 278                           nt_errstr(status)));
 279                 state->bad_recv_count++;
 280                 /* may overwrite previous failed status */
 281                 state->status = status;
 282         }
 283
 284         if (state->recv_count != state->dispatch_count) {
 285                 /*
 286                  * Wait for all VFS copy_chunk requests to complete, even
 287                  * if an error is received for a specific chunk.
 288                  */
 289                 return;
 290         }
 291
 292         if (!tevent_req_nterror(req, state->status)) {
 293                 tevent_req_done(req);
 294         }
 295 }
 296
 297 static NTSTATUS fsctl_srv_copychunk_recv(struct tevent_req *req,
 298                                          struct srv_copychunk_rsp *cc_rsp,
 299                                          bool *pack_rsp)
 300 {
 301         struct fsctl_srv_copychunk_state *state = tevent_req_data(req,
 302                                         struct fsctl_srv_copychunk_state);
 303         NTSTATUS status;
 304
 305         switch (state->out_data) {
 306         case COPYCHUNK_OUT_EMPTY:
 307                 *pack_rsp = false;
 308                 break;
 309         case COPYCHUNK_OUT_LIMITS:
 310                 /* 2.2.32.1 - send back our maximum transfer size limits */
 311                 copychunk_pack_limits(cc_rsp);
 312                 *pack_rsp = true;
 313                 break;
 314         case COPYCHUNK_OUT_RSP:
 315                 cc_rsp->chunks_written = state->recv_count - state->bad_recv_count;
 316                 cc_rsp->chunk_bytes_written = 0;
 317                 cc_rsp->total_bytes_written = state->total_written;
 318                 *pack_rsp = true;
 319                 break;
 320         default:        /* not reached */
 321                 assert(1);
 322                 break;
 323         }
 324         status = state->status;
 325         tevent_req_received(req);
 326
 327         return status;
 328 }
 329
 330 static NTSTATUS fsctl_validate_neg_info(TALLOC_CTX *mem_ctx,
 331                                         struct tevent_context *ev,
 332                                         struct smbXsrv_connection *conn,
 333                                         DATA_BLOB *in_input,
 334                                         uint32_t in_max_output,
 335                                         DATA_BLOB *out_output,
 336                                         bool *disconnect)
 337 {
 338         uint32_t in_capabilities;
 339         DATA_BLOB in_guid_blob;
 340         struct GUID in_guid;
 341         uint16_t in_security_mode;
 342         uint16_t in_num_dialects;
 343         uint16_t i;
 344         DATA_BLOB out_guid_blob;
 345         NTSTATUS status;
 346
 347         if (in_input->length < 0x18) {
 348                 return NT_STATUS_INVALID_PARAMETER;
 349         }
 350
 351         in_capabilities = IVAL(in_input->data, 0x00);
 352         in_guid_blob = data_blob_const(in_input->data + 0x04, 16);
 353         in_security_mode = SVAL(in_input->data, 0x14);
 354         in_num_dialects = SVAL(in_input->data, 0x16);
 355
 356         if (in_input->length < (0x18 + in_num_dialects*2)) {
 357                 return NT_STATUS_INVALID_PARAMETER;
 358         }
 359
 360         if (in_max_output < 0x18) {
 361                 return NT_STATUS_BUFFER_TOO_SMALL;
 362         }
 363
 364         status = GUID_from_ndr_blob(&in_guid_blob, &in_guid);
 365         if (!NT_STATUS_IS_OK(status)) {
 366                 return status;
 367         }
 368
 369         if (in_num_dialects != conn->smb2.client.num_dialects) {
 370                 *disconnect = true;
 371                 return NT_STATUS_ACCESS_DENIED;
 372         }
 373
 374         for (i=0; i < in_num_dialects; i++) {
 375                 uint16_t v = SVAL(in_input->data, 0x18 + i*2);
 376
 377                 if (conn->smb2.client.dialects[i] != v) {
 378                         *disconnect = true;
 379                         return NT_STATUS_ACCESS_DENIED;
 380                 }
 381         }
 382
 383         if (GUID_compare(&in_guid, &conn->smb2.client.guid) != 0) {
 384                 *disconnect = true;
 385                 return NT_STATUS_ACCESS_DENIED;
 386         }
 387
 388         if (in_security_mode != conn->smb2.client.security_mode) {
 389                 *disconnect = true;
 390                 return NT_STATUS_ACCESS_DENIED;
 391         }
 392
 393         if (in_capabilities != conn->smb2.client.capabilities) {
 394                 *disconnect = true;
 395                 return NT_STATUS_ACCESS_DENIED;
 396         }
 397
 398         status = GUID_to_ndr_blob(&conn->smb2.server.guid, mem_ctx,
 399                                   &out_guid_blob);
 400         if (!NT_STATUS_IS_OK(status)) {
 401                 return status;
 402         }
 403
 404         *out_output = data_blob_talloc(mem_ctx, NULL, 0x18);
 405         if (out_output->data == NULL) {
 406                 return NT_STATUS_NO_MEMORY;
 407         }
 408
 409         SIVAL(out_output->data, 0x00, conn->smb2.server.capabilities);
 410         memcpy(out_output->data+0x04, out_guid_blob.data, 16);
 411         SIVAL(out_output->data, 0x14, conn->smb2.server.security_mode);
 412         SIVAL(out_output->data, 0x16, conn->smb2.server.dialect);
 413
 414         return NT_STATUS_OK;
 415 }
 416
 417 static NTSTATUS fsctl_srv_req_resume_key(TALLOC_CTX *mem_ctx,
 418                                          struct tevent_context *ev,
 419                                          struct files_struct *fsp,
 420                                          uint32_t in_max_output,
 421                                          DATA_BLOB *out_output)
 422 {
 423         struct req_resume_key_rsp rkey_rsp;
 424         enum ndr_err_code ndr_ret;
 425         DATA_BLOB output;
 426
 427         if (fsp == NULL) {
 428                 return NT_STATUS_FILE_CLOSED;
 429         }
 430
 431         ZERO_STRUCT(rkey_rsp);
 432         /* combine persistent and volatile handles for the resume key */
 433         SBVAL(rkey_rsp.resume_key, 0, fsp->op->global->open_persistent_id);
 434         SBVAL(rkey_rsp.resume_key, 8, fsp->op->global->open_volatile_id);
 435
 436         ndr_ret = ndr_push_struct_blob(&output, mem_ctx, &rkey_rsp,
 437                         (ndr_push_flags_fn_t)ndr_push_req_resume_key_rsp);
 438         if (ndr_ret != NDR_ERR_SUCCESS) {
 439                 return NT_STATUS_INTERNAL_ERROR;
 440         }
 441
 442         if (in_max_output < output.length) {
 443                 DEBUG(1, ("max output %u too small for resume key rsp %ld\n",
 444                           (unsigned int)in_max_output, (long int)output.length));
 445                 return NT_STATUS_INVALID_PARAMETER;
 446         }
 447         *out_output = output;
 448
 449         return NT_STATUS_OK;
 450 }
 451
 452 static void smb2_ioctl_network_fs_copychunk_done(struct tevent_req *subreq);
 453
 454 struct tevent_req *smb2_ioctl_network_fs(uint32_t ctl_code,
 455                                          struct tevent_context *ev,
 456                                          struct tevent_req *req,
 457                                          struct smbd_smb2_ioctl_state *state)
 458 {
 459         struct tevent_req *subreq;
 460         NTSTATUS status;
 461
 462         switch (ctl_code) {
 463         /*
 464          * [MS-SMB2] 2.2.31
 465          * FSCTL_SRV_COPYCHUNK is issued when a handle has
 466          * FILE_READ_DATA and FILE_WRITE_DATA access to the file;
 467          * FSCTL_SRV_COPYCHUNK_WRITE is issued when a handle only has
 468          * FILE_WRITE_DATA access.
 469          */
 470         case FSCTL_SRV_COPYCHUNK_WRITE: /* FALL THROUGH */
 471         case FSCTL_SRV_COPYCHUNK:
 472                 subreq = fsctl_srv_copychunk_send(state, ev,
 473                                                   ctl_code,
 474                                                   state->fsp,
 475                                                   &state->in_input,
 476                                                   state->in_max_output,
 477                                                   state->smb2req);
 478                 if (tevent_req_nomem(subreq, req)) {
 479                         return tevent_req_post(req, ev);
 480                 }
 481                 tevent_req_set_callback(subreq,
 482                                         smb2_ioctl_network_fs_copychunk_done,
 483                                         req);
 484                 return req;
 485                 break;
 486         case FSCTL_VALIDATE_NEGOTIATE_INFO:
 487                 status = fsctl_validate_neg_info(state, ev,
 488                                                  state->smbreq->sconn->conn,
 489                                                  &state->in_input,
 490                                                  state->in_max_output,
 491                                                  &state->out_output,
 492                                                  &state->disconnect);
 493                 if (!tevent_req_nterror(req, status)) {
 494                         tevent_req_done(req);
 495                 }
 496                 return tevent_req_post(req, ev);
 497                 break;
 498         case FSCTL_SRV_REQUEST_RESUME_KEY:
 499                 status = fsctl_srv_req_resume_key(state, ev, state->fsp,
 500                                                   state->in_max_output,
 501                                                   &state->out_output);
 502                 if (!tevent_req_nterror(req, status)) {
 503                         tevent_req_done(req);
 504                 }
 505                 return tevent_req_post(req, ev);
 506                 break;
 507         default: {
 508                 uint8_t *out_data = NULL;
 509                 uint32_t out_data_len = 0;
 510
 511                 if (state->fsp == NULL) {
 512                         status = NT_STATUS_NOT_SUPPORTED;
 513                 } else {
 514                         status = SMB_VFS_FSCTL(state->fsp,
 515                                                state,
 516                                                ctl_code,
 517                                                state->smbreq->flags2,
 518                                                state->in_input.data,
 519                                                state->in_input.length,
 520                                                &out_data,
 521                                                state->in_max_output,
 522                                                &out_data_len);
 523                         state->out_output = data_blob_const(out_data, out_data_len);
 524                         if (NT_STATUS_IS_OK(status)) {
 525                                 tevent_req_done(req);
 526                                 return tevent_req_post(req, ev);
 527                         }
 528                 }
 529
 530                 if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_SUPPORTED)) {
 531                         if (IS_IPC(state->smbreq->conn)) {
 532                                 status = NT_STATUS_FS_DRIVER_REQUIRED;
 533                         } else {
 534                                 status = NT_STATUS_INVALID_DEVICE_REQUEST;
 535                         }
 536                 }
 537
 538                 tevent_req_nterror(req, status);
 539                 return tevent_req_post(req, ev);
 540                 break;
 541         }
 542         }
 543
 544         tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
 545         return tevent_req_post(req, ev);
 546 }
 547
 548 static void smb2_ioctl_network_fs_copychunk_done(struct tevent_req *subreq)
 549 {
 550         struct tevent_req *req = tevent_req_callback_data(subreq,
 551                                                           struct tevent_req);
 552         struct smbd_smb2_ioctl_state *ioctl_state = tevent_req_data(req,
 553                                                 struct smbd_smb2_ioctl_state);
 554         struct srv_copychunk_rsp cc_rsp;
 555         NTSTATUS status;
 556         bool pack_rsp = false;
 557
 558         ZERO_STRUCT(cc_rsp);
 559         status = fsctl_srv_copychunk_recv(subreq, &cc_rsp, &pack_rsp);
 560         TALLOC_FREE(subreq);
 561         if (pack_rsp == true) {
 562                 enum ndr_err_code ndr_ret;
 563                 ndr_ret = ndr_push_struct_blob(&ioctl_state->out_output,
 564                                                ioctl_state,
 565                                                &cc_rsp,
 566                                 (ndr_push_flags_fn_t)ndr_push_srv_copychunk_rsp);
 567                 if (ndr_ret != NDR_ERR_SUCCESS) {
 568                         status = NT_STATUS_INTERNAL_ERROR;
 569                 }
 570         }
 571
 572         if (!tevent_req_nterror(req, status)) {
 573                 tevent_req_done(req);
 574         }
 575 }