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