source3/libsmb/async_smb.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Infrastructure for async SMB client requests
   4    Copyright (C) Volker Lendecke 2008
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18 */
  19
  20 #include "includes.h"
  21 #include "libsmb/libsmb.h"
  22 #include "../lib/async_req/async_sock.h"
  23 #include "../lib/util/tevent_ntstatus.h"
  24 #include "../lib/util/tevent_unix.h"
  25 #include "async_smb.h"
  26 #include "smb_crypt.h"
  27 #include "libsmb/nmblib.h"
  28 #include "read_smb.h"
  29
  30 /**
  31  * Fetch an error out of a NBT packet
  32  * @param[in] buf       The SMB packet
  33  * @retval              The error, converted to NTSTATUS
  34  */
  35
  36 NTSTATUS cli_pull_error(char *buf)
  37 {
  38         uint32_t flags2 = SVAL(buf, smb_flg2);
  39
  40         if (flags2 & FLAGS2_32_BIT_ERROR_CODES) {
  41                 return NT_STATUS(IVAL(buf, smb_rcls));
  42         }
  43
  44         return dos_to_ntstatus(CVAL(buf, smb_rcls), SVAL(buf,smb_err));
  45 }
  46
  47 /**
  48  * Compatibility helper for the sync APIs: Fake NTSTATUS in cli->inbuf
  49  * @param[in] cli       The client connection that just received an error
  50  * @param[in] status    The error to set on "cli"
  51  */
  52
  53 void cli_set_error(struct cli_state *cli, NTSTATUS status)
  54 {
  55         uint32_t flags2 = SVAL(cli->inbuf, smb_flg2);
  56
  57         if (NT_STATUS_IS_DOS(status)) {
  58                 SSVAL(cli->inbuf, smb_flg2,
  59                       flags2 & ~FLAGS2_32_BIT_ERROR_CODES);
  60                 SCVAL(cli->inbuf, smb_rcls, NT_STATUS_DOS_CLASS(status));
  61                 SSVAL(cli->inbuf, smb_err, NT_STATUS_DOS_CODE(status));
  62                 return;
  63         }
  64
  65         SSVAL(cli->inbuf, smb_flg2, flags2 | FLAGS2_32_BIT_ERROR_CODES);
  66         SIVAL(cli->inbuf, smb_rcls, NT_STATUS_V(status));
  67         return;
  68 }
  69
  70 /**
  71  * Figure out if there is an andx command behind the current one
  72  * @param[in] buf       The smb buffer to look at
  73  * @param[in] ofs       The offset to the wct field that is followed by the cmd
  74  * @retval Is there a command following?
  75  */
  76
  77 static bool have_andx_command(const char *buf, uint16_t ofs)
  78 {
  79         uint8_t wct;
  80         size_t buflen = talloc_get_size(buf);
  81
  82         if ((ofs == buflen-1) || (ofs == buflen)) {
  83                 return false;
  84         }
  85
  86         wct = CVAL(buf, ofs);
  87         if (wct < 2) {
  88                 /*
  89                  * Not enough space for the command and a following pointer
  90                  */
  91                 return false;
  92         }
  93         return (CVAL(buf, ofs+1) != 0xff);
  94 }
  95
  96 #define MAX_SMB_IOV 5
  97
  98 struct cli_smb_state {
  99         struct tevent_context *ev;
 100         struct cli_state *cli;
 101         uint8_t header[smb_wct+1]; /* Space for the header including the wct */
 102
 103         /*
 104          * For normal requests, cli_smb_req_send chooses a mid. Secondary
 105          * trans requests need to use the mid of the primary request, so we
 106          * need a place to store it. Assume it's set if != 0.
 107          */
 108         uint16_t mid;
 109
 110         uint16_t *vwv;
 111         uint8_t bytecount_buf[2];
 112
 113         struct iovec iov[MAX_SMB_IOV+3];
 114         int iov_count;
 115
 116         uint8_t *inbuf;
 117         uint32_t seqnum;
 118         int chain_num;
 119         int chain_length;
 120         struct tevent_req **chained_requests;
 121 };
 122
 123 static uint16_t cli_alloc_mid(struct cli_state *cli)
 124 {
 125         int num_pending = talloc_array_length(cli->pending);
 126         uint16_t result;
 127
 128         while (true) {
 129                 int i;
 130
 131                 result = cli->mid++;
 132                 if ((result == 0) || (result == 0xffff)) {
 133                         continue;
 134                 }
 135
 136                 for (i=0; i<num_pending; i++) {
 137                         if (result == cli_smb_req_mid(cli->pending[i])) {
 138                                 break;
 139                         }
 140                 }
 141
 142                 if (i == num_pending) {
 143                         return result;
 144                 }
 145         }
 146 }
 147
 148 void cli_smb_req_unset_pending(struct tevent_req *req)
 149 {
 150         struct cli_smb_state *state = tevent_req_data(
 151                 req, struct cli_smb_state);
 152         struct cli_state *cli = state->cli;
 153         int num_pending = talloc_array_length(cli->pending);
 154         int i;
 155
 156         if (state->mid != 0) {
 157                 /*
 158                  * This is a [nt]trans[2] request which waits
 159                  * for more than one reply.
 160                  */
 161                 return;
 162         }
 163
 164         if (num_pending == 1) {
 165                 /*
 166                  * The pending read_smb tevent_req is a child of
 167                  * cli->pending. So if nothing is pending anymore, we need to
 168                  * delete the socket read fde.
 169                  */
 170                 TALLOC_FREE(cli->pending);
 171                 return;
 172         }
 173
 174         for (i=0; i<num_pending; i++) {
 175                 if (req == cli->pending[i]) {
 176                         break;
 177                 }
 178         }
 179         if (i == num_pending) {
 180                 /*
 181                  * Something's seriously broken. Just returning here is the
 182                  * right thing nevertheless, the point of this routine is to
 183                  * remove ourselves from cli->pending.
 184                  */
 185                 return;
 186         }
 187
 188         /*
 189          * Remove ourselves from the cli->pending array
 190          */
 191         cli->pending[i] = cli->pending[num_pending-1];
 192
 193         /*
 194          * No NULL check here, we're shrinking by sizeof(void *), and
 195          * talloc_realloc just adjusts the size for this.
 196          */
 197         cli->pending = talloc_realloc(NULL, cli->pending, struct tevent_req *,
 198                                       num_pending - 1);
 199         return;
 200 }
 201
 202 static int cli_smb_req_destructor(struct tevent_req *req)
 203 {
 204         struct cli_smb_state *state = tevent_req_data(
 205                 req, struct cli_smb_state);
 206         /*
 207          * Make sure we really remove it from
 208          * the pending array on destruction.
 209          */
 210         state->mid = 0;
 211         cli_smb_req_unset_pending(req);
 212         return 0;
 213 }
 214
 215 static void cli_smb_received(struct tevent_req *subreq);
 216
 217 bool cli_smb_req_set_pending(struct tevent_req *req)
 218 {
 219         struct cli_smb_state *state = tevent_req_data(
 220                 req, struct cli_smb_state);
 221         struct cli_state *cli;
 222         struct tevent_req **pending;
 223         int num_pending;
 224         struct tevent_req *subreq;
 225
 226         cli = state->cli;
 227         num_pending = talloc_array_length(cli->pending);
 228
 229         pending = talloc_realloc(cli, cli->pending, struct tevent_req *,
 230                                  num_pending+1);
 231         if (pending == NULL) {
 232                 return false;
 233         }
 234         pending[num_pending] = req;
 235         cli->pending = pending;
 236         talloc_set_destructor(req, cli_smb_req_destructor);
 237
 238         if (num_pending > 0) {
 239                 return true;
 240         }
 241
 242         /*
 243          * We're the first ones, add the read_smb request that waits for the
 244          * answer from the server
 245          */
 246         subreq = read_smb_send(cli->pending, state->ev, cli->fd);
 247         if (subreq == NULL) {
 248                 cli_smb_req_unset_pending(req);
 249                 return false;
 250         }
 251         tevent_req_set_callback(subreq, cli_smb_received, cli);
 252         return true;
 253 }
 254
 255 /*
 256  * Fetch a smb request's mid. Only valid after the request has been sent by
 257  * cli_smb_req_send().
 258  */
 259 uint16_t cli_smb_req_mid(struct tevent_req *req)
 260 {
 261         struct cli_smb_state *state = tevent_req_data(
 262                 req, struct cli_smb_state);
 263         return SVAL(state->header, smb_mid);
 264 }
 265
 266 void cli_smb_req_set_mid(struct tevent_req *req, uint16_t mid)
 267 {
 268         struct cli_smb_state *state = tevent_req_data(
 269                 req, struct cli_smb_state);
 270         state->mid = mid;
 271 }
 272
 273 static size_t iov_len(const struct iovec *iov, int count)
 274 {
 275         size_t result = 0;
 276         int i;
 277         for (i=0; i<count; i++) {
 278                 result += iov[i].iov_len;
 279         }
 280         return result;
 281 }
 282
 283 static uint8_t *iov_concat(TALLOC_CTX *mem_ctx, const struct iovec *iov,
 284                            int count)
 285 {
 286         size_t len = iov_len(iov, count);
 287         size_t copied;
 288         uint8_t *buf;
 289         int i;
 290
 291         buf = talloc_array(mem_ctx, uint8_t, len);
 292         if (buf == NULL) {
 293                 return NULL;
 294         }
 295         copied = 0;
 296         for (i=0; i<count; i++) {
 297                 memcpy(buf+copied, iov[i].iov_base, iov[i].iov_len);
 298                 copied += iov[i].iov_len;
 299         }
 300         return buf;
 301 }
 302
 303 struct tevent_req *cli_smb_req_create(TALLOC_CTX *mem_ctx,
 304                                       struct event_context *ev,
 305                                       struct cli_state *cli,
 306                                       uint8_t smb_command,
 307                                       uint8_t additional_flags,
 308                                       uint8_t wct, uint16_t *vwv,
 309                                       int iov_count,
 310                                       struct iovec *bytes_iov)
 311 {
 312         struct tevent_req *result;
 313         struct cli_smb_state *state;
 314         struct timeval endtime;
 315
 316         if (iov_count > MAX_SMB_IOV) {
 317                 /*
 318                  * Should not happen :-)
 319                  */
 320                 return NULL;
 321         }
 322
 323         result = tevent_req_create(mem_ctx, &state, struct cli_smb_state);
 324         if (result == NULL) {
 325                 return NULL;
 326         }
 327         state->ev = ev;
 328         state->cli = cli;
 329         state->mid = 0;         /* Set to auto-choose in cli_smb_req_send */
 330         state->chain_num = 0;
 331         state->chained_requests = NULL;
 332
 333         cli_setup_packet_buf(cli, (char *)state->header);
 334         SCVAL(state->header, smb_com, smb_command);
 335         SSVAL(state->header, smb_tid, cli->cnum);
 336         SCVAL(state->header, smb_wct, wct);
 337
 338         state->vwv = vwv;
 339
 340         SSVAL(state->bytecount_buf, 0, iov_len(bytes_iov, iov_count));
 341
 342         state->iov[0].iov_base = (void *)state->header;
 343         state->iov[0].iov_len  = sizeof(state->header);
 344         state->iov[1].iov_base = (void *)state->vwv;
 345         state->iov[1].iov_len  = wct * sizeof(uint16_t);
 346         state->iov[2].iov_base = (void *)state->bytecount_buf;
 347         state->iov[2].iov_len  = sizeof(uint16_t);
 348
 349         if (iov_count != 0) {
 350                 memcpy(&state->iov[3], bytes_iov,
 351                        iov_count * sizeof(*bytes_iov));
 352         }
 353         state->iov_count = iov_count + 3;
 354
 355         if (cli->timeout) {
 356                 endtime = timeval_current_ofs_msec(cli->timeout);
 357                 if (!tevent_req_set_endtime(result, ev, endtime)) {
 358                         tevent_req_nomem(NULL, result);
 359                 }
 360         }
 361         return result;
 362 }
 363
 364 static NTSTATUS cli_signv(struct cli_state *cli, struct iovec *iov, int count,
 365                           uint32_t *seqnum)
 366 {
 367         uint8_t *buf;
 368
 369         /*
 370          * Obvious optimization: Make cli_calculate_sign_mac work with struct
 371          * iovec directly. MD5Update would do that just fine.
 372          */
 373
 374         if ((count <= 0) || (iov[0].iov_len < smb_wct)) {
 375                 return NT_STATUS_INVALID_PARAMETER;
 376         }
 377
 378         buf = iov_concat(talloc_tos(), iov, count);
 379         if (buf == NULL) {
 380                 return NT_STATUS_NO_MEMORY;
 381         }
 382
 383         cli_calculate_sign_mac(cli, (char *)buf, seqnum);
 384         memcpy(iov[0].iov_base, buf, iov[0].iov_len);
 385
 386         TALLOC_FREE(buf);
 387         return NT_STATUS_OK;
 388 }
 389
 390 static void cli_smb_sent(struct tevent_req *subreq);
 391
 392 static NTSTATUS cli_smb_req_iov_send(struct tevent_req *req,
 393                                      struct cli_smb_state *state,
 394                                      struct iovec *iov, int iov_count)
 395 {
 396         struct tevent_req *subreq;
 397         NTSTATUS status;
 398
 399         if (state->cli->fd == -1) {
 400                 return NT_STATUS_CONNECTION_INVALID;
 401         }
 402
 403         if (iov[0].iov_len < smb_wct) {
 404                 return NT_STATUS_INVALID_PARAMETER;
 405         }
 406
 407         if (state->mid != 0) {
 408                 SSVAL(iov[0].iov_base, smb_mid, state->mid);
 409         } else {
 410                 uint16_t mid = cli_alloc_mid(state->cli);
 411                 SSVAL(iov[0].iov_base, smb_mid, mid);
 412         }
 413
 414         smb_setlen((char *)iov[0].iov_base, iov_len(iov, iov_count) - 4);
 415
 416         status = cli_signv(state->cli, iov, iov_count, &state->seqnum);
 417
 418         if (!NT_STATUS_IS_OK(status)) {
 419                 return status;
 420         }
 421
 422         if (cli_encryption_on(state->cli)) {
 423                 char *buf, *enc_buf;
 424
 425                 buf = (char *)iov_concat(talloc_tos(), iov, iov_count);
 426                 if (buf == NULL) {
 427                         return NT_STATUS_NO_MEMORY;
 428                 }
 429                 status = common_encrypt_buffer(state->cli->trans_enc_state,
 430                                                (char *)buf, &enc_buf);
 431                 TALLOC_FREE(buf);
 432                 if (!NT_STATUS_IS_OK(status)) {
 433                         DEBUG(0, ("Error in encrypting client message: %s\n",
 434                                   nt_errstr(status)));
 435                         return status;
 436                 }
 437                 buf = (char *)talloc_memdup(state, enc_buf,
 438                                             smb_len(enc_buf)+4);
 439                 SAFE_FREE(enc_buf);
 440                 if (buf == NULL) {
 441                         return NT_STATUS_NO_MEMORY;
 442                 }
 443                 iov[0].iov_base = (void *)buf;
 444                 iov[0].iov_len = talloc_get_size(buf);
 445                 iov_count = 1;
 446         }
 447         subreq = writev_send(state, state->ev, state->cli->outgoing,
 448                              state->cli->fd, false, iov, iov_count);
 449         if (subreq == NULL) {
 450                 return NT_STATUS_NO_MEMORY;
 451         }
 452         tevent_req_set_callback(subreq, cli_smb_sent, req);
 453         return NT_STATUS_OK;
 454 }
 455
 456 NTSTATUS cli_smb_req_send(struct tevent_req *req)
 457 {
 458         struct cli_smb_state *state = tevent_req_data(
 459                 req, struct cli_smb_state);
 460
 461         return cli_smb_req_iov_send(req, state, state->iov, state->iov_count);
 462 }
 463
 464 struct tevent_req *cli_smb_send(TALLOC_CTX *mem_ctx,
 465                                 struct event_context *ev,
 466                                 struct cli_state *cli,
 467                                 uint8_t smb_command,
 468                                 uint8_t additional_flags,
 469                                 uint8_t wct, uint16_t *vwv,
 470                                 uint32_t num_bytes,
 471                                 const uint8_t *bytes)
 472 {
 473         struct tevent_req *req;
 474         struct iovec iov;
 475         NTSTATUS status;
 476
 477         iov.iov_base = discard_const_p(void, bytes);
 478         iov.iov_len = num_bytes;
 479
 480         req = cli_smb_req_create(mem_ctx, ev, cli, smb_command,
 481                                  additional_flags, wct, vwv, 1, &iov);
 482         if (req == NULL) {
 483                 return NULL;
 484         }
 485
 486         status = cli_smb_req_send(req);
 487         if (!NT_STATUS_IS_OK(status)) {
 488                 tevent_req_nterror(req, status);
 489                 return tevent_req_post(req, ev);
 490         }
 491         return req;
 492 }
 493
 494 static void cli_smb_sent(struct tevent_req *subreq)
 495 {
 496         struct tevent_req *req = tevent_req_callback_data(
 497                 subreq, struct tevent_req);
 498         struct cli_smb_state *state = tevent_req_data(
 499                 req, struct cli_smb_state);
 500         ssize_t nwritten;
 501         int err;
 502
 503         nwritten = writev_recv(subreq, &err);
 504         TALLOC_FREE(subreq);
 505         if (nwritten == -1) {
 506                 if (state->cli->fd != -1) {
 507                         close(state->cli->fd);
 508                         state->cli->fd = -1;
 509                 }
 510                 tevent_req_nterror(req, map_nt_error_from_unix(err));
 511                 return;
 512         }
 513
 514         switch (CVAL(state->header, smb_com)) {
 515         case SMBtranss:
 516         case SMBtranss2:
 517         case SMBnttranss:
 518         case SMBntcancel:
 519                 state->inbuf = NULL;
 520                 tevent_req_done(req);
 521                 return;
 522         case SMBlockingX:
 523                 if ((CVAL(state->header, smb_wct) == 8) &&
 524                     (CVAL(state->vwv+3, 0) == LOCKING_ANDX_OPLOCK_RELEASE)) {
 525                         state->inbuf = NULL;
 526                         tevent_req_done(req);
 527                         return;
 528                 }
 529         }
 530
 531         if (!cli_smb_req_set_pending(req)) {
 532                 tevent_req_nterror(req, NT_STATUS_NO_MEMORY);
 533                 return;
 534         }
 535 }
 536
 537 static void cli_smb_received(struct tevent_req *subreq)
 538 {
 539         struct cli_state *cli = tevent_req_callback_data(
 540                 subreq, struct cli_state);
 541         struct tevent_req *req;
 542         struct cli_smb_state *state;
 543         NTSTATUS status;
 544         uint8_t *inbuf;
 545         ssize_t received;
 546         int num_pending;
 547         int i, err;
 548         uint16_t mid;
 549         bool oplock_break;
 550
 551         received = read_smb_recv(subreq, talloc_tos(), &inbuf, &err);
 552         TALLOC_FREE(subreq);
 553         if (received == -1) {
 554                 if (cli->fd != -1) {
 555                         close(cli->fd);
 556                         cli->fd = -1;
 557                 }
 558                 status = map_nt_error_from_unix(err);
 559                 goto fail;
 560         }
 561
 562         if ((IVAL(inbuf, 4) != 0x424d53ff) /* 0xFF"SMB" */
 563             && (SVAL(inbuf, 4) != 0x45ff)) /* 0xFF"E" */ {
 564                 DEBUG(10, ("Got non-SMB PDU\n"));
 565                 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
 566                 goto fail;
 567         }
 568
 569         if (cli_encryption_on(cli) && (CVAL(inbuf, 0) == 0)) {
 570                 uint16_t enc_ctx_num;
 571
 572                 status = get_enc_ctx_num(inbuf, &enc_ctx_num);
 573                 if (!NT_STATUS_IS_OK(status)) {
 574                         DEBUG(10, ("get_enc_ctx_num returned %s\n",
 575                                    nt_errstr(status)));
 576                         goto fail;
 577                 }
 578
 579                 if (enc_ctx_num != cli->trans_enc_state->enc_ctx_num) {
 580                         DEBUG(10, ("wrong enc_ctx %d, expected %d\n",
 581                                    enc_ctx_num,
 582                                    cli->trans_enc_state->enc_ctx_num));
 583                         status = NT_STATUS_INVALID_HANDLE;
 584                         goto fail;
 585                 }
 586
 587                 status = common_decrypt_buffer(cli->trans_enc_state,
 588                                                (char *)inbuf);
 589                 if (!NT_STATUS_IS_OK(status)) {
 590                         DEBUG(10, ("common_decrypt_buffer returned %s\n",
 591                                    nt_errstr(status)));
 592                         goto fail;
 593                 }
 594         }
 595
 596         mid = SVAL(inbuf, smb_mid);
 597         num_pending = talloc_array_length(cli->pending);
 598
 599         for (i=0; i<num_pending; i++) {
 600                 if (mid == cli_smb_req_mid(cli->pending[i])) {
 601                         break;
 602                 }
 603         }
 604         if (i == num_pending) {
 605                 /* Dump unexpected reply */
 606                 TALLOC_FREE(inbuf);
 607                 goto done;
 608         }
 609
 610         oplock_break = false;
 611
 612         if (mid == 0xffff) {
 613                 /*
 614                  * Paranoia checks that this is really an oplock break request.
 615                  */
 616                 oplock_break = (smb_len(inbuf) == 51); /* hdr + 8 words */
 617                 oplock_break &= ((CVAL(inbuf, smb_flg) & FLAG_REPLY) == 0);
 618                 oplock_break &= (CVAL(inbuf, smb_com) == SMBlockingX);
 619                 oplock_break &= (SVAL(inbuf, smb_vwv6) == 0);
 620                 oplock_break &= (SVAL(inbuf, smb_vwv7) == 0);
 621
 622                 if (!oplock_break) {
 623                         /* Dump unexpected reply */
 624                         TALLOC_FREE(inbuf);
 625                         goto done;
 626                 }
 627         }
 628
 629         req = cli->pending[i];
 630         state = tevent_req_data(req, struct cli_smb_state);
 631
 632         if (!oplock_break /* oplock breaks are not signed */
 633             && !cli_check_sign_mac(cli, (char *)inbuf, state->seqnum+1)) {
 634                 DEBUG(10, ("cli_check_sign_mac failed\n"));
 635                 TALLOC_FREE(inbuf);
 636                 status = NT_STATUS_ACCESS_DENIED;
 637                 close(cli->fd);
 638                 cli->fd = -1;
 639                 goto fail;
 640         }
 641
 642         if (state->chained_requests == NULL) {
 643                 state->inbuf = talloc_move(state, &inbuf);
 644                 talloc_set_destructor(req, NULL);
 645                 cli_smb_req_unset_pending(req);
 646                 state->chain_num = 0;
 647                 state->chain_length = 1;
 648                 tevent_req_done(req);
 649         } else {
 650                 struct tevent_req **chain = talloc_move(
 651                         talloc_tos(), &state->chained_requests);
 652                 int num_chained = talloc_array_length(chain);
 653
 654                 for (i=0; i<num_chained; i++) {
 655                         state = tevent_req_data(chain[i], struct
 656                                                 cli_smb_state);
 657                         state->inbuf = inbuf;
 658                         state->chain_num = i;
 659                         state->chain_length = num_chained;
 660                         tevent_req_done(chain[i]);
 661                 }
 662                 TALLOC_FREE(inbuf);
 663                 TALLOC_FREE(chain);
 664         }
 665  done:
 666         if (talloc_array_length(cli->pending) > 0) {
 667                 /*
 668                  * Set up another read request for the other pending cli_smb
 669                  * requests
 670                  */
 671                 state = tevent_req_data(cli->pending[0], struct cli_smb_state);
 672                 subreq = read_smb_send(cli->pending, state->ev, cli->fd);
 673                 if (subreq == NULL) {
 674                         status = NT_STATUS_NO_MEMORY;
 675                         goto fail;
 676                 }
 677                 tevent_req_set_callback(subreq, cli_smb_received, cli);
 678         }
 679         return;
 680  fail:
 681         /*
 682          * Cancel all pending requests. We don't do a for-loop walking
 683          * cli->pending because that array changes in
 684          * cli_smb_req_destructor().
 685          */
 686         while (talloc_array_length(cli->pending) > 0) {
 687                 req = cli->pending[0];
 688                 talloc_set_destructor(req, NULL);
 689                 cli_smb_req_unset_pending(req);
 690                 tevent_req_nterror(req, status);
 691         }
 692 }
 693
 694 NTSTATUS cli_smb_recv(struct tevent_req *req,
 695                       TALLOC_CTX *mem_ctx, uint8_t **pinbuf,
 696                       uint8_t min_wct, uint8_t *pwct, uint16_t **pvwv,
 697                       uint32_t *pnum_bytes, uint8_t **pbytes)
 698 {
 699         struct cli_smb_state *state = tevent_req_data(
 700                 req, struct cli_smb_state);
 701         NTSTATUS status = NT_STATUS_OK;
 702         uint8_t cmd, wct;
 703         uint16_t num_bytes;
 704         size_t wct_ofs, bytes_offset;
 705         int i;
 706
 707         if (tevent_req_is_nterror(req, &status)) {
 708                 return status;
 709         }
 710
 711         if (state->inbuf == NULL) {
 712                 if (min_wct != 0) {
 713                         return NT_STATUS_INVALID_NETWORK_RESPONSE;
 714                 }
 715                 if (pinbuf) {
 716                         *pinbuf = NULL;
 717                 }
 718                 if (pwct) {
 719                         *pwct = 0;
 720                 }
 721                 if (pvwv) {
 722                         *pvwv = NULL;
 723                 }
 724                 if (pnum_bytes) {
 725                         *pnum_bytes = 0;
 726                 }
 727                 if (pbytes) {
 728                         *pbytes = NULL;
 729                 }
 730                 /* This was a request without a reply */
 731                 return NT_STATUS_OK;
 732         }
 733
 734         wct_ofs = smb_wct;
 735         cmd = CVAL(state->inbuf, smb_com);
 736
 737         for (i=0; i<state->chain_num; i++) {
 738                 if (i < state->chain_num-1) {
 739                         if (cmd == 0xff) {
 740                                 return NT_STATUS_REQUEST_ABORTED;
 741                         }
 742                         if (!is_andx_req(cmd)) {
 743                                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
 744                         }
 745                 }
 746
 747                 if (!have_andx_command((char *)state->inbuf, wct_ofs)) {
 748                         /*
 749                          * This request was not completed because a previous
 750                          * request in the chain had received an error.
 751                          */
 752                         return NT_STATUS_REQUEST_ABORTED;
 753                 }
 754
 755                 wct_ofs = SVAL(state->inbuf, wct_ofs + 3);
 756
 757                 /*
 758                  * Skip the all-present length field. No overflow, we've just
 759                  * put a 16-bit value into a size_t.
 760                  */
 761                 wct_ofs += 4;
 762
 763                 if (wct_ofs+2 > talloc_get_size(state->inbuf)) {
 764                         return NT_STATUS_INVALID_NETWORK_RESPONSE;
 765                 }
 766
 767                 cmd = CVAL(state->inbuf, wct_ofs + 1);
 768         }
 769
 770         status = cli_pull_error((char *)state->inbuf);
 771
 772         cli_set_error(state->cli, status);
 773
 774         if (!have_andx_command((char *)state->inbuf, wct_ofs)) {
 775
 776                 if ((cmd == SMBsesssetupX)
 777                     && NT_STATUS_EQUAL(
 778                             status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
 779                         /*
 780                          * NT_STATUS_MORE_PROCESSING_REQUIRED is a
 781                          * valid return code for session setup
 782                          */
 783                         goto no_err;
 784                 }
 785
 786                 if (NT_STATUS_IS_ERR(status)) {
 787                         /*
 788                          * The last command takes the error code. All
 789                          * further commands down the requested chain
 790                          * will get a NT_STATUS_REQUEST_ABORTED.
 791                          */
 792                         return status;
 793                 }
 794         }
 795
 796 no_err:
 797
 798         wct = CVAL(state->inbuf, wct_ofs);
 799         bytes_offset = wct_ofs + 1 + wct * sizeof(uint16_t);
 800         num_bytes = SVAL(state->inbuf, bytes_offset);
 801
 802         if (wct < min_wct) {
 803                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
 804         }
 805
 806         /*
 807          * wct_ofs is a 16-bit value plus 4, wct is a 8-bit value, num_bytes
 808          * is a 16-bit value. So bytes_offset being size_t should be far from
 809          * wrapping.
 810          */
 811         if ((bytes_offset + 2 > talloc_get_size(state->inbuf))
 812             || (bytes_offset > 0xffff)) {
 813                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
 814         }
 815
 816         if (pwct != NULL) {
 817                 *pwct = wct;
 818         }
 819         if (pvwv != NULL) {
 820                 *pvwv = (uint16_t *)(state->inbuf + wct_ofs + 1);
 821         }
 822         if (pnum_bytes != NULL) {
 823                 *pnum_bytes = num_bytes;
 824         }
 825         if (pbytes != NULL) {
 826                 *pbytes = (uint8_t *)state->inbuf + bytes_offset + 2;
 827         }
 828         if ((mem_ctx != NULL) && (pinbuf != NULL)) {
 829                 if (state->chain_num == state->chain_length-1) {
 830                         *pinbuf = talloc_move(mem_ctx, &state->inbuf);
 831                 } else {
 832                         *pinbuf = state->inbuf;
 833                 }
 834         }
 835
 836         return status;
 837 }
 838
 839 size_t cli_smb_wct_ofs(struct tevent_req **reqs, int num_reqs)
 840 {
 841         size_t wct_ofs;
 842         int i;
 843
 844         wct_ofs = smb_wct - 4;
 845
 846         for (i=0; i<num_reqs; i++) {
 847                 struct cli_smb_state *state;
 848                 state = tevent_req_data(reqs[i], struct cli_smb_state);
 849                 wct_ofs += iov_len(state->iov+1, state->iov_count-1);
 850                 wct_ofs = (wct_ofs + 3) & ~3;
 851         }
 852         return wct_ofs;
 853 }
 854
 855 NTSTATUS cli_smb_chain_send(struct tevent_req **reqs, int num_reqs)
 856 {
 857         struct cli_smb_state *first_state = tevent_req_data(
 858                 reqs[0], struct cli_smb_state);
 859         struct cli_smb_state *last_state = tevent_req_data(
 860                 reqs[num_reqs-1], struct cli_smb_state);
 861         struct cli_smb_state *state;
 862         size_t wct_offset;
 863         size_t chain_padding = 0;
 864         int i, iovlen;
 865         struct iovec *iov = NULL;
 866         struct iovec *this_iov;
 867         NTSTATUS status;
 868
 869         iovlen = 0;
 870         for (i=0; i<num_reqs; i++) {
 871                 state = tevent_req_data(reqs[i], struct cli_smb_state);
 872                 iovlen += state->iov_count;
 873         }
 874
 875         iov = talloc_array(last_state, struct iovec, iovlen);
 876         if (iov == NULL) {
 877                 return NT_STATUS_NO_MEMORY;
 878         }
 879
 880         first_state->chained_requests = (struct tevent_req **)talloc_memdup(
 881                 last_state, reqs, sizeof(*reqs) * num_reqs);
 882         if (first_state->chained_requests == NULL) {
 883                 TALLOC_FREE(iov);
 884                 return NT_STATUS_NO_MEMORY;
 885         }
 886
 887         wct_offset = smb_wct - 4;
 888         this_iov = iov;
 889
 890         for (i=0; i<num_reqs; i++) {
 891                 size_t next_padding = 0;
 892                 uint16_t *vwv;
 893
 894                 state = tevent_req_data(reqs[i], struct cli_smb_state);
 895
 896                 if (i < num_reqs-1) {
 897                         if (!is_andx_req(CVAL(state->header, smb_com))
 898                             || CVAL(state->header, smb_wct) < 2) {
 899                                 TALLOC_FREE(iov);
 900                                 TALLOC_FREE(first_state->chained_requests);
 901                                 return NT_STATUS_INVALID_PARAMETER;
 902                         }
 903                 }
 904
 905                 wct_offset += iov_len(state->iov+1, state->iov_count-1) + 1;
 906                 if ((wct_offset % 4) != 0) {
 907                         next_padding = 4 - (wct_offset % 4);
 908                 }
 909                 wct_offset += next_padding;
 910                 vwv = state->vwv;
 911
 912                 if (i < num_reqs-1) {
 913                         struct cli_smb_state *next_state = tevent_req_data(
 914                                 reqs[i+1], struct cli_smb_state);
 915                         SCVAL(vwv+0, 0, CVAL(next_state->header, smb_com));
 916                         SCVAL(vwv+0, 1, 0);
 917                         SSVAL(vwv+1, 0, wct_offset);
 918                 } else if (is_andx_req(CVAL(state->header, smb_com))) {
 919                         /* properly end the chain */
 920                         SCVAL(vwv+0, 0, 0xff);
 921                         SCVAL(vwv+0, 1, 0xff);
 922                         SSVAL(vwv+1, 0, 0);
 923                 }
 924
 925                 if (i == 0) {
 926                         this_iov[0] = state->iov[0];
 927                 } else {
 928                         /*
 929                          * This one is a bit subtle. We have to add
 930                          * chain_padding bytes between the requests, and we
 931                          * have to also include the wct field of the
 932                          * subsequent requests. We use the subsequent header
 933                          * for the padding, it contains the wct field in its
 934                          * last byte.
 935                          */
 936                         this_iov[0].iov_len = chain_padding+1;
 937                         this_iov[0].iov_base = (void *)&state->header[
 938                                 sizeof(state->header) - this_iov[0].iov_len];
 939                         memset(this_iov[0].iov_base, 0, this_iov[0].iov_len-1);
 940                 }
 941                 memcpy(this_iov+1, state->iov+1,
 942                        sizeof(struct iovec) * (state->iov_count-1));
 943                 this_iov += state->iov_count;
 944                 chain_padding = next_padding;
 945         }
 946
 947         status = cli_smb_req_iov_send(reqs[0], last_state, iov, iovlen);
 948         if (!NT_STATUS_IS_OK(status)) {
 949                 TALLOC_FREE(iov);
 950                 TALLOC_FREE(first_state->chained_requests);
 951                 return status;
 952         }
 953
 954         return NT_STATUS_OK;
 955 }
 956
 957 uint8_t *cli_smb_inbuf(struct tevent_req *req)
 958 {
 959         struct cli_smb_state *state = tevent_req_data(
 960                 req, struct cli_smb_state);
 961         return state->inbuf;
 962 }
 963
 964 bool cli_has_async_calls(struct cli_state *cli)
 965 {
 966         return ((tevent_queue_length(cli->outgoing) != 0)
 967                 || (talloc_array_length(cli->pending) != 0));
 968 }
 969
 970 struct cli_smb_oplock_break_waiter_state {
 971         uint16_t fnum;
 972         uint8_t level;
 973 };
 974
 975 static void cli_smb_oplock_break_waiter_done(struct tevent_req *subreq);
 976
 977 struct tevent_req *cli_smb_oplock_break_waiter_send(TALLOC_CTX *mem_ctx,
 978                                                     struct event_context *ev,
 979                                                     struct cli_state *cli)
 980 {
 981         struct tevent_req *req, *subreq;
 982         struct cli_smb_oplock_break_waiter_state *state;
 983         struct cli_smb_state *smb_state;
 984
 985         req = tevent_req_create(mem_ctx, &state,
 986                                 struct cli_smb_oplock_break_waiter_state);
 987         if (req == NULL) {
 988                 return NULL;
 989         }
 990
 991         /*
 992          * Create a fake SMB request that we will never send out. This is only
 993          * used to be set into the pending queue with the right mid.
 994          */
 995         subreq = cli_smb_req_create(mem_ctx, ev, cli, 0, 0, 0, NULL, 0, NULL);
 996         if (tevent_req_nomem(subreq, req)) {
 997                 return tevent_req_post(req, ev);
 998         }
 999         smb_state = tevent_req_data(subreq, struct cli_smb_state);
1000         SSVAL(smb_state->header, smb_mid, 0xffff);
1001
1002         if (!cli_smb_req_set_pending(subreq)) {
1003                 tevent_req_nterror(req, NT_STATUS_NO_MEMORY);
1004                 return tevent_req_post(req, ev);
1005         }
1006         tevent_req_set_callback(subreq, cli_smb_oplock_break_waiter_done, req);
1007         return req;
1008 }
1009
1010 static void cli_smb_oplock_break_waiter_done(struct tevent_req *subreq)
1011 {
1012         struct tevent_req *req = tevent_req_callback_data(
1013                 subreq, struct tevent_req);
1014         struct cli_smb_oplock_break_waiter_state *state = tevent_req_data(
1015                 req, struct cli_smb_oplock_break_waiter_state);
1016         uint8_t wct;
1017         uint16_t *vwv;
1018         uint32_t num_bytes;
1019         uint8_t *bytes;
1020         uint8_t *inbuf;
1021         NTSTATUS status;
1022
1023         status = cli_smb_recv(subreq, state, &inbuf, 8, &wct, &vwv,
1024                               &num_bytes, &bytes);
1025         TALLOC_FREE(subreq);
1026         if (!NT_STATUS_IS_OK(status)) {
1027                 tevent_req_nterror(req, status);
1028                 return;
1029         }
1030         state->fnum = SVAL(vwv+2, 0);
1031         state->level = CVAL(vwv+3, 1);
1032         tevent_req_done(req);
1033 }
1034
1035 NTSTATUS cli_smb_oplock_break_waiter_recv(struct tevent_req *req,
1036                                           uint16_t *pfnum,
1037                                           uint8_t *plevel)
1038 {
1039         struct cli_smb_oplock_break_waiter_state *state = tevent_req_data(
1040                 req, struct cli_smb_oplock_break_waiter_state);
1041         NTSTATUS status;
1042
1043         if (tevent_req_is_nterror(req, &status)) {
1044                 return status;
1045         }
1046         *pfnum = state->fnum;
1047         *plevel = state->level;
1048         return NT_STATUS_OK;
1049 }
1050
1051
1052 struct cli_session_request_state {
1053         struct tevent_context *ev;
1054         int sock;
1055         uint32 len_hdr;
1056         struct iovec iov[3];
1057         uint8_t nb_session_response;
1058 };
1059
1060 static void cli_session_request_sent(struct tevent_req *subreq);
1061 static void cli_session_request_recvd(struct tevent_req *subreq);
1062
1063 struct tevent_req *cli_session_request_send(TALLOC_CTX *mem_ctx,
1064                                             struct tevent_context *ev,
1065                                             int sock,
1066                                             const struct nmb_name *called,
1067                                             const struct nmb_name *calling)
1068 {
1069         struct tevent_req *req, *subreq;
1070         struct cli_session_request_state *state;
1071
1072         req = tevent_req_create(mem_ctx, &state,
1073                                 struct cli_session_request_state);
1074         if (req == NULL) {
1075                 return NULL;
1076         }
1077         state->ev = ev;
1078         state->sock = sock;
1079
1080         state->iov[1].iov_base = name_mangle(
1081                 state, called->name, called->name_type);
1082         if (tevent_req_nomem(state->iov[1].iov_base, req)) {
1083                 return tevent_req_post(req, ev);
1084         }
1085         state->iov[1].iov_len = name_len(
1086                 (unsigned char *)state->iov[1].iov_base,
1087                 talloc_get_size(state->iov[1].iov_base));
1088
1089         state->iov[2].iov_base = name_mangle(
1090                 state, calling->name, calling->name_type);
1091         if (tevent_req_nomem(state->iov[2].iov_base, req)) {
1092                 return tevent_req_post(req, ev);
1093         }
1094         state->iov[2].iov_len = name_len(
1095                 (unsigned char *)state->iov[2].iov_base,
1096                 talloc_get_size(state->iov[2].iov_base));
1097
1098         _smb_setlen(((char *)&state->len_hdr),
1099                     state->iov[1].iov_len + state->iov[2].iov_len);
1100         SCVAL((char *)&state->len_hdr, 0, 0x81);
1101
1102         state->iov[0].iov_base = &state->len_hdr;
1103         state->iov[0].iov_len = sizeof(state->len_hdr);
1104
1105         subreq = writev_send(state, ev, NULL, sock, true, state->iov, 3);
1106         if (tevent_req_nomem(subreq, req)) {
1107                 return tevent_req_post(req, ev);
1108         }
1109         tevent_req_set_callback(subreq, cli_session_request_sent, req);
1110         return req;
1111 }
1112
1113 static void cli_session_request_sent(struct tevent_req *subreq)
1114 {
1115         struct tevent_req *req = tevent_req_callback_data(
1116                 subreq, struct tevent_req);
1117         struct cli_session_request_state *state = tevent_req_data(
1118                 req, struct cli_session_request_state);
1119         ssize_t ret;
1120         int err;
1121
1122         ret = writev_recv(subreq, &err);
1123         TALLOC_FREE(subreq);
1124         if (ret == -1) {
1125                 tevent_req_error(req, err);
1126                 return;
1127         }
1128         subreq = read_smb_send(state, state->ev, state->sock);
1129         if (tevent_req_nomem(subreq, req)) {
1130                 return;
1131         }
1132         tevent_req_set_callback(subreq, cli_session_request_recvd, req);
1133 }
1134
1135 static void cli_session_request_recvd(struct tevent_req *subreq)
1136 {
1137         struct tevent_req *req = tevent_req_callback_data(
1138                 subreq, struct tevent_req);
1139         struct cli_session_request_state *state = tevent_req_data(
1140                 req, struct cli_session_request_state);
1141         uint8_t *buf;
1142         ssize_t ret;
1143         int err;
1144
1145         ret = read_smb_recv(subreq, talloc_tos(), &buf, &err);
1146         TALLOC_FREE(subreq);
1147
1148         if (ret < 4) {
1149                 ret = -1;
1150                 err = EIO;
1151         }
1152         if (ret == -1) {
1153                 tevent_req_error(req, err);
1154                 return;
1155         }
1156         /*
1157          * In case of an error there is more information in the data
1158          * portion according to RFC1002. We're not subtle enough to
1159          * respond to the different error conditions, so drop the
1160          * error info here.
1161          */
1162         state->nb_session_response = CVAL(buf, 0);
1163         tevent_req_done(req);
1164 }
1165
1166 bool cli_session_request_recv(struct tevent_req *req, int *err, uint8_t *resp)
1167 {
1168         struct cli_session_request_state *state = tevent_req_data(
1169                 req, struct cli_session_request_state);
1170
1171         if (tevent_req_is_unix_error(req, err)) {
1172                 return false;
1173         }
1174         *resp = state->nb_session_response;
1175         return true;
1176 }