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