?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
libcli/smb: pass smbXcli_tcon to smb2cli_create*()
[Samba/gebeck_regimport.git] / source3 / libsmb / cli_np_tstream.c
blob7482f9da6236f377a2f7881d6a6017b1e443511e
1 /*
2 Unix SMB/CIFS implementation.
3
4 Copyright (C) Stefan Metzmacher 2010
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 "system/network.h"
22 #include "libsmb/libsmb.h"
23 #include "libsmb/smb2cli.h"
24 #include "../libcli/smb/smbXcli_base.h"
25 #include "../lib/util/tevent_ntstatus.h"
26 #include "../lib/tsocket/tsocket.h"
27 #include "../lib/tsocket/tsocket_internal.h"
28 #include "cli_np_tstream.h"
29
30 static const struct tstream_context_ops tstream_cli_np_ops;
31
32 /*
33 * Windows uses 4280 (the max xmit/recv size negotiated on DCERPC).
34 * This is fits into the max_xmit negotiated at the SMB layer.
35 *
36 * On the sending side they may use SMBtranss if the request does not
37 * fit into a single SMBtrans call.
38 *
39 * Windows uses 1024 as max data size of a SMBtrans request and then
40 * possibly reads the rest of the DCERPC fragment (up to 3256 bytes)
41 * via a SMBreadX.
42 *
43 * For now we just ask for the full 4280 bytes (max data size) in the SMBtrans
44 * request to get the whole fragment at once (like samba 3.5.x and below did.
45 *
46 * It is important that we use do SMBwriteX with the size of a full fragment,
47 * otherwise we may get NT_STATUS_PIPE_BUSY on the SMBtrans request
48 * from NT4 servers. (See bug #8195)
49 */
50 #define TSTREAM_CLI_NP_MAX_BUF_SIZE 4280
51
52 struct tstream_cli_np {
53 struct cli_state *cli;
54 const char *npipe;
55 bool is_smb1;
56 uint16_t fnum;
57 uint64_t fid_persistent;
58 uint64_t fid_volatile;
59 unsigned int default_timeout;
60
61 struct {
62 bool active;
63 struct tevent_req *read_req;
64 struct tevent_req *write_req;
65 uint16_t setup[2];
66 } trans;
67
68 struct {
69 off_t ofs;
70 size_t left;
71 uint8_t *buf;
72 } read, write;
73 };
74
75 static int tstream_cli_np_destructor(struct tstream_cli_np *cli_nps)
76 {
77 NTSTATUS status;
78
79 if (!cli_state_is_connected(cli_nps->cli)) {
80 return 0;
81 }
82
83 /*
84 * TODO: do not use a sync call with a destructor!!!
85 *
86 * This only happens, if a caller does talloc_free(),
87 * while the everything was still ok.
88 *
89 * If we get an unexpected failure within a normal
90 * operation, we already do an async cli_close_send()/_recv().
91 *
92 * Once we've fixed all callers to call
93 * tstream_disconnect_send()/_recv(), this will
94 * never be called.
95 */
96 if (cli_nps->is_smb1) {
97 status = cli_close(cli_nps->cli, cli_nps->fnum);
98 } else {
99 status = smb2cli_close(cli_nps->cli->conn,
100 cli_nps->cli->timeout,
101 cli_nps->cli->smb2.session,
102 cli_nps->cli->smb2.tid, 0,
103 cli_nps->fid_persistent,
104 cli_nps->fid_volatile);
105 }
106 if (!NT_STATUS_IS_OK(status)) {
107 DEBUG(1, ("tstream_cli_np_destructor: cli_close "
108 "failed on pipe %s. Error was %s\n",
109 cli_nps->npipe, nt_errstr(status)));
110 }
111 /*
112 * We can't do much on failure
113 */
114 return 0;
115 }
116
117 struct tstream_cli_np_open_state {
118 struct cli_state *cli;
119 bool is_smb1;
120 uint16_t fnum;
121 uint64_t fid_persistent;
122 uint64_t fid_volatile;
123 const char *npipe;
124 };
125
126 static void tstream_cli_np_open_done(struct tevent_req *subreq);
127
128 struct tevent_req *tstream_cli_np_open_send(TALLOC_CTX *mem_ctx,
129 struct tevent_context *ev,
130 struct cli_state *cli,
131 const char *npipe)
132 {
133 struct tevent_req *req;
134 struct tstream_cli_np_open_state *state;
135 struct tevent_req *subreq;
136
137 req = tevent_req_create(mem_ctx, &state,
138 struct tstream_cli_np_open_state);
139 if (!req) {
140 return NULL;
141 }
142 state->cli = cli;
143
144 state->npipe = talloc_strdup(state, npipe);
145 if (tevent_req_nomem(state->npipe, req)) {
146 return tevent_req_post(req, ev);
147 }
148
149 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
150 state->is_smb1 = true;
151 }
152
153 if (state->is_smb1) {
154 const char *smb1_npipe;
155
156 /*
157 * Windows and newer Samba versions allow
158 * the pipe name without leading backslash,
159 * but we should better behave like windows clients
160 */
161 smb1_npipe = talloc_asprintf(state, "\\%s", state->npipe);
162 if (tevent_req_nomem(smb1_npipe, req)) {
163 return tevent_req_post(req, ev);
164 }
165
166 subreq = cli_ntcreate_send(state, ev, cli,
167 smb1_npipe,
168 0,
169 DESIRED_ACCESS_PIPE,
170 0,
171 FILE_SHARE_READ|FILE_SHARE_WRITE,
172 FILE_OPEN,
173 0,
174 0);
175 } else {
176 subreq = smb2cli_create_send(state, ev, cli->conn,
177 cli->timeout, cli->smb2.session,
178 cli->smb2.tcon,
179 npipe,
180 SMB2_OPLOCK_LEVEL_NONE,
181 SMB2_IMPERSONATION_IMPERSONATION,
182 DESIRED_ACCESS_PIPE,
183 0, /* file_attributes */
184 FILE_SHARE_READ|FILE_SHARE_WRITE,
185 FILE_OPEN,
186 0, /* create_options */
187 NULL); /* blobs */
188 }
189 if (tevent_req_nomem(subreq, req)) {
190 return tevent_req_post(req, ev);
191 }
192 tevent_req_set_callback(subreq, tstream_cli_np_open_done, req);
193
194 return req;
195 }
196
197 static void tstream_cli_np_open_done(struct tevent_req *subreq)
198 {
199 struct tevent_req *req =
200 tevent_req_callback_data(subreq, struct tevent_req);
201 struct tstream_cli_np_open_state *state =
202 tevent_req_data(req, struct tstream_cli_np_open_state);
203 NTSTATUS status;
204
205 if (state->is_smb1) {
206 status = cli_ntcreate_recv(subreq, &state->fnum);
207 } else {
208 status = smb2cli_create_recv(subreq,
209 &state->fid_persistent,
210 &state->fid_volatile);
211 }
212 TALLOC_FREE(subreq);
213 if (!NT_STATUS_IS_OK(status)) {
214 tevent_req_nterror(req, status);
215 return;
216 }
217
218 tevent_req_done(req);
219 }
220
221 NTSTATUS _tstream_cli_np_open_recv(struct tevent_req *req,
222 TALLOC_CTX *mem_ctx,
223 struct tstream_context **_stream,
224 const char *location)
225 {
226 struct tstream_cli_np_open_state *state =
227 tevent_req_data(req, struct tstream_cli_np_open_state);
228 struct tstream_context *stream;
229 struct tstream_cli_np *cli_nps;
230 NTSTATUS status;
231
232 if (tevent_req_is_nterror(req, &status)) {
233 tevent_req_received(req);
234 return status;
235 }
236
237 stream = tstream_context_create(mem_ctx,
238 &tstream_cli_np_ops,
239 &cli_nps,
240 struct tstream_cli_np,
241 location);
242 if (!stream) {
243 tevent_req_received(req);
244 return NT_STATUS_NO_MEMORY;
245 }
246 ZERO_STRUCTP(cli_nps);
247
248 cli_nps->cli = state->cli;
249 cli_nps->npipe = talloc_move(cli_nps, &state->npipe);
250 cli_nps->is_smb1 = state->is_smb1;
251 cli_nps->fnum = state->fnum;
252 cli_nps->fid_persistent = state->fid_persistent;
253 cli_nps->fid_volatile = state->fid_volatile;
254 cli_nps->default_timeout = cli_set_timeout(state->cli, 0);
255 cli_set_timeout(state->cli, cli_nps->default_timeout);
256
257 talloc_set_destructor(cli_nps, tstream_cli_np_destructor);
258
259 cli_nps->trans.active = false;
260 cli_nps->trans.read_req = NULL;
261 cli_nps->trans.write_req = NULL;
262 SSVAL(cli_nps->trans.setup+0, 0, TRANSACT_DCERPCCMD);
263 SSVAL(cli_nps->trans.setup+1, 0, cli_nps->fnum);
264
265 *_stream = stream;
266 tevent_req_received(req);
267 return NT_STATUS_OK;
268 }
269
270 static ssize_t tstream_cli_np_pending_bytes(struct tstream_context *stream)
271 {
272 struct tstream_cli_np *cli_nps = tstream_context_data(stream,
273 struct tstream_cli_np);
274
275 if (!cli_state_is_connected(cli_nps->cli)) {
276 errno = ENOTCONN;
277 return -1;
278 }
279
280 return cli_nps->read.left;
281 }
282
283 bool tstream_is_cli_np(struct tstream_context *stream)
284 {
285 struct tstream_cli_np *cli_nps =
286 talloc_get_type(_tstream_context_data(stream),
287 struct tstream_cli_np);
288
289 if (!cli_nps) {
290 return false;
291 }
292
293 return true;
294 }
295
296 NTSTATUS tstream_cli_np_use_trans(struct tstream_context *stream)
297 {
298 struct tstream_cli_np *cli_nps = tstream_context_data(stream,
299 struct tstream_cli_np);
300
301 if (cli_nps->trans.read_req) {
302 return NT_STATUS_PIPE_BUSY;
303 }
304
305 if (cli_nps->trans.write_req) {
306 return NT_STATUS_PIPE_BUSY;
307 }
308
309 if (cli_nps->trans.active) {
310 return NT_STATUS_PIPE_BUSY;
311 }
312
313 cli_nps->trans.active = true;
314
315 return NT_STATUS_OK;
316 }
317
318 unsigned int tstream_cli_np_set_timeout(struct tstream_context *stream,
319 unsigned int timeout)
320 {
321 struct tstream_cli_np *cli_nps = tstream_context_data(stream,
322 struct tstream_cli_np);
323
324 if (!cli_state_is_connected(cli_nps->cli)) {
325 return cli_nps->default_timeout;
326 }
327
328 return cli_set_timeout(cli_nps->cli, timeout);
329 }
330
331 struct cli_state *tstream_cli_np_get_cli_state(struct tstream_context *stream)
332 {
333 struct tstream_cli_np *cli_nps = tstream_context_data(stream,
334 struct tstream_cli_np);
335
336 return cli_nps->cli;
337 }
338
339 struct tstream_cli_np_writev_state {
340 struct tstream_context *stream;
341 struct tevent_context *ev;
342
343 struct iovec *vector;
344 size_t count;
345
346 int ret;
347
348 struct {
349 int val;
350 const char *location;
351 } error;
352 };
353
354 static int tstream_cli_np_writev_state_destructor(struct tstream_cli_np_writev_state *state)
355 {
356 struct tstream_cli_np *cli_nps =
357 tstream_context_data(state->stream,
358 struct tstream_cli_np);
359
360 cli_nps->trans.write_req = NULL;
361
362 return 0;
363 }
364
365 static void tstream_cli_np_writev_write_next(struct tevent_req *req);
366
367 static struct tevent_req *tstream_cli_np_writev_send(TALLOC_CTX *mem_ctx,
368 struct tevent_context *ev,
369 struct tstream_context *stream,
370 const struct iovec *vector,
371 size_t count)
372 {
373 struct tevent_req *req;
374 struct tstream_cli_np_writev_state *state;
375 struct tstream_cli_np *cli_nps = tstream_context_data(stream,
376 struct tstream_cli_np);
377
378 req = tevent_req_create(mem_ctx, &state,
379 struct tstream_cli_np_writev_state);
380 if (!req) {
381 return NULL;
382 }
383 state->stream = stream;
384 state->ev = ev;
385 state->ret = 0;
386
387 talloc_set_destructor(state, tstream_cli_np_writev_state_destructor);
388
389 if (!cli_state_is_connected(cli_nps->cli)) {
390 tevent_req_error(req, ENOTCONN);
391 return tevent_req_post(req, ev);
392 }
393
394 /*
395 * we make a copy of the vector so we can change the structure
396 */
397 state->vector = talloc_array(state, struct iovec, count);
398 if (tevent_req_nomem(state->vector, req)) {
399 return tevent_req_post(req, ev);
400 }
401 memcpy(state->vector, vector, sizeof(struct iovec) * count);
402 state->count = count;
403
404 tstream_cli_np_writev_write_next(req);
405 if (!tevent_req_is_in_progress(req)) {
406 return tevent_req_post(req, ev);
407 }
408
409 return req;
410 }
411
412 static void tstream_cli_np_readv_trans_start(struct tevent_req *req);
413 static void tstream_cli_np_writev_write_done(struct tevent_req *subreq);
414
415 static void tstream_cli_np_writev_write_next(struct tevent_req *req)
416 {
417 struct tstream_cli_np_writev_state *state =
418 tevent_req_data(req,
419 struct tstream_cli_np_writev_state);
420 struct tstream_cli_np *cli_nps =
421 tstream_context_data(state->stream,
422 struct tstream_cli_np);
423 struct tevent_req *subreq;
424 size_t i;
425 size_t left = 0;
426
427 for (i=0; i < state->count; i++) {
428 left += state->vector[i].iov_len;
429 }
430
431 if (left == 0) {
432 TALLOC_FREE(cli_nps->write.buf);
433 tevent_req_done(req);
434 return;
435 }
436
437 cli_nps->write.ofs = 0;
438 cli_nps->write.left = MIN(left, TSTREAM_CLI_NP_MAX_BUF_SIZE);
439 cli_nps->write.buf = talloc_realloc(cli_nps, cli_nps->write.buf,
440 uint8_t, cli_nps->write.left);
441 if (tevent_req_nomem(cli_nps->write.buf, req)) {
442 return;
443 }
444
445 /*
446 * copy the pending buffer first
447 */
448 while (cli_nps->write.left > 0 && state->count > 0) {
449 uint8_t *base = (uint8_t *)state->vector[0].iov_base;
450 size_t len = MIN(cli_nps->write.left, state->vector[0].iov_len);
451
452 memcpy(cli_nps->write.buf + cli_nps->write.ofs, base, len);
453
454 base += len;
455 state->vector[0].iov_base = base;
456 state->vector[0].iov_len -= len;
457
458 cli_nps->write.ofs += len;
459 cli_nps->write.left -= len;
460
461 if (state->vector[0].iov_len == 0) {
462 state->vector += 1;
463 state->count -= 1;
464 }
465
466 state->ret += len;
467 }
468
469 if (cli_nps->trans.active && state->count == 0) {
470 cli_nps->trans.active = false;
471 cli_nps->trans.write_req = req;
472 return;
473 }
474
475 if (cli_nps->trans.read_req && state->count == 0) {
476 cli_nps->trans.write_req = req;
477 tstream_cli_np_readv_trans_start(cli_nps->trans.read_req);
478 return;
479 }
480
481 if (cli_nps->is_smb1) {
482 subreq = cli_write_andx_send(state, state->ev, cli_nps->cli,
483 cli_nps->fnum,
484 8, /* 8 means message mode. */
485 cli_nps->write.buf,
486 0, /* offset */
487 cli_nps->write.ofs); /* size */
488 } else {
489 subreq = smb2cli_write_send(state, state->ev,
490 cli_nps->cli->conn,
491 cli_nps->cli->timeout,
492 cli_nps->cli->smb2.session,
493 cli_nps->cli->smb2.tid,
494 cli_nps->write.ofs, /* length */
495 0, /* offset */
496 cli_nps->fid_persistent,
497 cli_nps->fid_volatile,
498 0, /* remaining_bytes */
499 0, /* flags */
500 cli_nps->write.buf);
501 }
502 if (tevent_req_nomem(subreq, req)) {
503 return;
504 }
505 tevent_req_set_callback(subreq,
506 tstream_cli_np_writev_write_done,
507 req);
508 }
509
510 static void tstream_cli_np_writev_disconnect_now(struct tevent_req *req,
511 int error,
512 const char *location);
513
514 static void tstream_cli_np_writev_write_done(struct tevent_req *subreq)
515 {
516 struct tevent_req *req =
517 tevent_req_callback_data(subreq, struct tevent_req);
518 struct tstream_cli_np_writev_state *state =
519 tevent_req_data(req, struct tstream_cli_np_writev_state);
520 struct tstream_cli_np *cli_nps =
521 tstream_context_data(state->stream,
522 struct tstream_cli_np);
523 size_t written;
524 NTSTATUS status;
525
526 if (cli_nps->is_smb1) {
527 status = cli_write_andx_recv(subreq, &written);
528 } else {
529 status = smb2cli_write_recv(subreq);
530 written = cli_nps->write.ofs; // TODO: get the value from the server
531 }
532 TALLOC_FREE(subreq);
533 if (!NT_STATUS_IS_OK(status)) {
534 tstream_cli_np_writev_disconnect_now(req, EIO, __location__);
535 return;
536 }
537
538 if (written != cli_nps->write.ofs) {
539 tstream_cli_np_writev_disconnect_now(req, EIO, __location__);
540 return;
541 }
542
543 tstream_cli_np_writev_write_next(req);
544 }
545
546 static void tstream_cli_np_writev_disconnect_done(struct tevent_req *subreq);
547
548 static void tstream_cli_np_writev_disconnect_now(struct tevent_req *req,
549 int error,
550 const char *location)
551 {
552 struct tstream_cli_np_writev_state *state =
553 tevent_req_data(req,
554 struct tstream_cli_np_writev_state);
555 struct tstream_cli_np *cli_nps =
556 tstream_context_data(state->stream,
557 struct tstream_cli_np);
558 struct tevent_req *subreq;
559
560 state->error.val = error;
561 state->error.location = location;
562
563 if (!cli_state_is_connected(cli_nps->cli)) {
564 /* return the original error */
565 _tevent_req_error(req, state->error.val, state->error.location);
566 return;
567 }
568
569 if (cli_nps->is_smb1) {
570 subreq = cli_close_send(state, state->ev, cli_nps->cli,
571 cli_nps->fnum);
572 } else {
573 subreq = smb2cli_close_send(state, state->ev,
574 cli_nps->cli->conn,
575 cli_nps->cli->timeout,
576 cli_nps->cli->smb2.session,
577 cli_nps->cli->smb2.tid,
578 0, /* flags */
579 cli_nps->fid_persistent,
580 cli_nps->fid_volatile);
581 }
582 if (subreq == NULL) {
583 /* return the original error */
584 _tevent_req_error(req, state->error.val, state->error.location);
585 return;
586 }
587 tevent_req_set_callback(subreq,
588 tstream_cli_np_writev_disconnect_done,
589 req);
590 }
591
592 static void tstream_cli_np_writev_disconnect_done(struct tevent_req *subreq)
593 {
594 struct tevent_req *req =
595 tevent_req_callback_data(subreq, struct tevent_req);
596 struct tstream_cli_np_writev_state *state =
597 tevent_req_data(req, struct tstream_cli_np_writev_state);
598 struct tstream_cli_np *cli_nps =
599 tstream_context_data(state->stream, struct tstream_cli_np);
600
601 if (cli_nps->is_smb1) {
602 cli_close_recv(subreq);
603 } else {
604 smb2cli_close_recv(subreq);
605 }
606 TALLOC_FREE(subreq);
607
608 cli_nps->cli = NULL;
609
610 /* return the original error */
611 _tevent_req_error(req, state->error.val, state->error.location);
612 }
613
614 static int tstream_cli_np_writev_recv(struct tevent_req *req,
615 int *perrno)
616 {
617 struct tstream_cli_np_writev_state *state =
618 tevent_req_data(req,
619 struct tstream_cli_np_writev_state);
620 int ret;
621
622 ret = tsocket_simple_int_recv(req, perrno);
623 if (ret == 0) {
624 ret = state->ret;
625 }
626
627 tevent_req_received(req);
628 return ret;
629 }
630
631 struct tstream_cli_np_readv_state {
632 struct tstream_context *stream;
633 struct tevent_context *ev;
634
635 struct iovec *vector;
636 size_t count;
637
638 int ret;
639
640 struct {
641 struct tevent_immediate *im;
642 } trans;
643
644 struct {
645 int val;
646 const char *location;
647 } error;
648 };
649
650 static int tstream_cli_np_readv_state_destructor(struct tstream_cli_np_readv_state *state)
651 {
652 struct tstream_cli_np *cli_nps =
653 tstream_context_data(state->stream,
654 struct tstream_cli_np);
655
656 cli_nps->trans.read_req = NULL;
657
658 return 0;
659 }
660
661 static void tstream_cli_np_readv_read_next(struct tevent_req *req);
662
663 static struct tevent_req *tstream_cli_np_readv_send(TALLOC_CTX *mem_ctx,
664 struct tevent_context *ev,
665 struct tstream_context *stream,
666 struct iovec *vector,
667 size_t count)
668 {
669 struct tevent_req *req;
670 struct tstream_cli_np_readv_state *state;
671 struct tstream_cli_np *cli_nps =
672 tstream_context_data(stream, struct tstream_cli_np);
673
674 req = tevent_req_create(mem_ctx, &state,
675 struct tstream_cli_np_readv_state);
676 if (!req) {
677 return NULL;
678 }
679 state->stream = stream;
680 state->ev = ev;
681 state->ret = 0;
682
683 talloc_set_destructor(state, tstream_cli_np_readv_state_destructor);
684
685 if (!cli_state_is_connected(cli_nps->cli)) {
686 tevent_req_error(req, ENOTCONN);
687 return tevent_req_post(req, ev);
688 }
689
690 /*
691 * we make a copy of the vector so we can change the structure
692 */
693 state->vector = talloc_array(state, struct iovec, count);
694 if (tevent_req_nomem(state->vector, req)) {
695 return tevent_req_post(req, ev);
696 }
697 memcpy(state->vector, vector, sizeof(struct iovec) * count);
698 state->count = count;
699
700 tstream_cli_np_readv_read_next(req);
701 if (!tevent_req_is_in_progress(req)) {
702 return tevent_req_post(req, ev);
703 }
704
705 return req;
706 }
707
708 static void tstream_cli_np_readv_read_done(struct tevent_req *subreq);
709
710 static void tstream_cli_np_readv_read_next(struct tevent_req *req)
711 {
712 struct tstream_cli_np_readv_state *state =
713 tevent_req_data(req,
714 struct tstream_cli_np_readv_state);
715 struct tstream_cli_np *cli_nps =
716 tstream_context_data(state->stream,
717 struct tstream_cli_np);
718 struct tevent_req *subreq;
719
720 /*
721 * copy the pending buffer first
722 */
723 while (cli_nps->read.left > 0 && state->count > 0) {
724 uint8_t *base = (uint8_t *)state->vector[0].iov_base;
725 size_t len = MIN(cli_nps->read.left, state->vector[0].iov_len);
726
727 memcpy(base, cli_nps->read.buf + cli_nps->read.ofs, len);
728
729 base += len;
730 state->vector[0].iov_base = base;
731 state->vector[0].iov_len -= len;
732
733 cli_nps->read.ofs += len;
734 cli_nps->read.left -= len;
735
736 if (state->vector[0].iov_len == 0) {
737 state->vector += 1;
738 state->count -= 1;
739 }
740
741 state->ret += len;
742 }
743
744 if (cli_nps->read.left == 0) {
745 TALLOC_FREE(cli_nps->read.buf);
746 }
747
748 if (state->count == 0) {
749 tevent_req_done(req);
750 return;
751 }
752
753 if (cli_nps->trans.active) {
754 cli_nps->trans.active = false;
755 cli_nps->trans.read_req = req;
756 return;
757 }
758
759 if (cli_nps->trans.write_req) {
760 cli_nps->trans.read_req = req;
761 tstream_cli_np_readv_trans_start(req);
762 return;
763 }
764
765 if (cli_nps->is_smb1) {
766 subreq = cli_read_andx_send(state, state->ev, cli_nps->cli,
767 cli_nps->fnum,
768 0, /* offset */
769 TSTREAM_CLI_NP_MAX_BUF_SIZE);
770 } else {
771 subreq = smb2cli_read_send(state, state->ev,
772 cli_nps->cli->conn,
773 cli_nps->cli->timeout,
774 cli_nps->cli->smb2.session,
775 cli_nps->cli->smb2.tid,
776 TSTREAM_CLI_NP_MAX_BUF_SIZE, /* length */
777 0, /* offset */
778 cli_nps->fid_persistent,
779 cli_nps->fid_volatile,
780 0, /* minimum_count */
781 0); /* remaining_bytes */
782 }
783 if (tevent_req_nomem(subreq, req)) {
784 return;
785 }
786 tevent_req_set_callback(subreq,
787 tstream_cli_np_readv_read_done,
788 req);
789 }
790
791 static void tstream_cli_np_readv_trans_done(struct tevent_req *subreq);
792
793 static void tstream_cli_np_readv_trans_start(struct tevent_req *req)
794 {
795 struct tstream_cli_np_readv_state *state =
796 tevent_req_data(req,
797 struct tstream_cli_np_readv_state);
798 struct tstream_cli_np *cli_nps =
799 tstream_context_data(state->stream,
800 struct tstream_cli_np);
801 struct tevent_req *subreq;
802
803 state->trans.im = tevent_create_immediate(state);
804 if (tevent_req_nomem(state->trans.im, req)) {
805 return;
806 }
807
808 if (cli_nps->is_smb1) {
809 subreq = cli_trans_send(state, state->ev,
810 cli_nps->cli,
811 SMBtrans,
812 "\\PIPE\\",
813 0, 0, 0,
814 cli_nps->trans.setup, 2,
815 0,
816 NULL, 0, 0,
817 cli_nps->write.buf,
818 cli_nps->write.ofs,
819 TSTREAM_CLI_NP_MAX_BUF_SIZE);
820 } else {
821 DATA_BLOB in_input_buffer = data_blob_null;
822 DATA_BLOB in_output_buffer = data_blob_null;
823
824 in_input_buffer = data_blob_const(cli_nps->write.buf,
825 cli_nps->write.ofs);
826
827 subreq = smb2cli_ioctl_send(state, state->ev,
828 cli_nps->cli->conn,
829 cli_nps->cli->timeout,
830 cli_nps->cli->smb2.session,
831 cli_nps->cli->smb2.tid,
832 cli_nps->fid_persistent,
833 cli_nps->fid_volatile,
834 FSCTL_NAMED_PIPE_READ_WRITE,
835 0, /* in_max_input_length */
836 &in_input_buffer,
837 /* in_max_output_length */
838 TSTREAM_CLI_NP_MAX_BUF_SIZE,
839 &in_output_buffer,
840 SMB2_IOCTL_FLAG_IS_FSCTL);
841 }
842 if (tevent_req_nomem(subreq, req)) {
843 return;
844 }
845 tevent_req_set_callback(subreq,
846 tstream_cli_np_readv_trans_done,
847 req);
848 }
849
850 static void tstream_cli_np_readv_disconnect_now(struct tevent_req *req,
851 int error,
852 const char *location);
853 static void tstream_cli_np_readv_trans_next(struct tevent_context *ctx,
854 struct tevent_immediate *im,
855 void *private_data);
856
857 static void tstream_cli_np_readv_trans_done(struct tevent_req *subreq)
858 {
859 struct tevent_req *req =
860 tevent_req_callback_data(subreq, struct tevent_req);
861 struct tstream_cli_np_readv_state *state =
862 tevent_req_data(req, struct tstream_cli_np_readv_state);
863 struct tstream_cli_np *cli_nps =
864 tstream_context_data(state->stream, struct tstream_cli_np);
865 uint8_t *rcvbuf;
866 uint32_t received;
867 NTSTATUS status;
868
869 if (cli_nps->is_smb1) {
870 status = cli_trans_recv(subreq, state, NULL, NULL, 0, NULL,
871 NULL, 0, NULL,
872 &rcvbuf, 0, &received);
873 } else {
874 DATA_BLOB out_input_buffer = data_blob_null;
875 DATA_BLOB out_output_buffer = data_blob_null;
876
877 status = smb2cli_ioctl_recv(subreq, state,
878 &out_input_buffer,
879 &out_output_buffer);
880
881 /* Note that rcvbuf is not a talloc pointer here */
882 rcvbuf = out_output_buffer.data;
883 received = out_output_buffer.length;
884 }
885 TALLOC_FREE(subreq);
886 if (NT_STATUS_EQUAL(status, NT_STATUS_BUFFER_TOO_SMALL)) {
887 status = NT_STATUS_OK;
888 }
889 if (!NT_STATUS_IS_OK(status)) {
890 tstream_cli_np_readv_disconnect_now(req, EIO, __location__);
891 return;
892 }
893
894 if (received > TSTREAM_CLI_NP_MAX_BUF_SIZE) {
895 tstream_cli_np_readv_disconnect_now(req, EIO, __location__);
896 return;
897 }
898
899 if (received == 0) {
900 tstream_cli_np_readv_disconnect_now(req, EPIPE, __location__);
901 return;
902 }
903
904 cli_nps->read.ofs = 0;
905 cli_nps->read.left = received;
906 cli_nps->read.buf = talloc_array(cli_nps, uint8_t, received);
907 if (cli_nps->read.buf == NULL) {
908 TALLOC_FREE(subreq);
909 tevent_req_nomem(cli_nps->read.buf, req);
910 return;
911 }
912 memcpy(cli_nps->read.buf, rcvbuf, received);
913
914 if (cli_nps->trans.write_req == NULL) {
915 tstream_cli_np_readv_read_next(req);
916 return;
917 }
918
919 tevent_schedule_immediate(state->trans.im, state->ev,
920 tstream_cli_np_readv_trans_next, req);
921
922 tevent_req_done(cli_nps->trans.write_req);
923 }
924
925 static void tstream_cli_np_readv_trans_next(struct tevent_context *ctx,
926 struct tevent_immediate *im,
927 void *private_data)
928 {
929 struct tevent_req *req =
930 talloc_get_type_abort(private_data,
931 struct tevent_req);
932
933 tstream_cli_np_readv_read_next(req);
934 }
935
936 static void tstream_cli_np_readv_read_done(struct tevent_req *subreq)
937 {
938 struct tevent_req *req =
939 tevent_req_callback_data(subreq, struct tevent_req);
940 struct tstream_cli_np_readv_state *state =
941 tevent_req_data(req, struct tstream_cli_np_readv_state);
942 struct tstream_cli_np *cli_nps =
943 tstream_context_data(state->stream, struct tstream_cli_np);
944 uint8_t *rcvbuf;
945 ssize_t received;
946 NTSTATUS status;
947
948 /*
949 * We must free subreq in this function as there is
950 * a timer event attached to it.
951 */
952
953 if (cli_nps->is_smb1) {
954 status = cli_read_andx_recv(subreq, &received, &rcvbuf);
955 } else {
956 uint32_t data_length = 0;
957 status = smb2cli_read_recv(subreq, state, &rcvbuf, &data_length);
958 received = data_length;
959 }
960 /*
961 * We can't TALLOC_FREE(subreq) as usual here, as rcvbuf still is a
962 * child of that.
963 */
964 if (NT_STATUS_EQUAL(status, NT_STATUS_BUFFER_TOO_SMALL)) {
965 /*
966 * NT_STATUS_BUFFER_TOO_SMALL means that there's
967 * more data to read when the named pipe is used
968 * in message mode (which is the case here).
969 *
970 * But we hide this from the caller.
971 */
972 status = NT_STATUS_OK;
973 }
974 if (!NT_STATUS_IS_OK(status)) {
975 TALLOC_FREE(subreq);
976 tstream_cli_np_readv_disconnect_now(req, EIO, __location__);
977 return;
978 }
979
980 if (received > TSTREAM_CLI_NP_MAX_BUF_SIZE) {
981 TALLOC_FREE(subreq);
982 tstream_cli_np_readv_disconnect_now(req, EIO, __location__);
983 return;
984 }
985
986 if (received == 0) {
987 TALLOC_FREE(subreq);
988 tstream_cli_np_readv_disconnect_now(req, EPIPE, __location__);
989 return;
990 }
991
992 cli_nps->read.ofs = 0;
993 cli_nps->read.left = received;
994 cli_nps->read.buf = talloc_array(cli_nps, uint8_t, received);
995 if (cli_nps->read.buf == NULL) {
996 TALLOC_FREE(subreq);
997 tevent_req_nomem(cli_nps->read.buf, req);
998 return;
999 }
1000 memcpy(cli_nps->read.buf, rcvbuf, received);
1001 TALLOC_FREE(subreq);
1002
1003 tstream_cli_np_readv_read_next(req);
1004 }
1005
1006 static void tstream_cli_np_readv_disconnect_done(struct tevent_req *subreq);
1007
1008 static void tstream_cli_np_readv_error(struct tevent_req *req);
1009
1010 static void tstream_cli_np_readv_disconnect_now(struct tevent_req *req,
1011 int error,
1012 const char *location)
1013 {
1014 struct tstream_cli_np_readv_state *state =
1015 tevent_req_data(req,
1016 struct tstream_cli_np_readv_state);
1017 struct tstream_cli_np *cli_nps =
1018 tstream_context_data(state->stream,
1019 struct tstream_cli_np);
1020 struct tevent_req *subreq;
1021
1022 state->error.val = error;
1023 state->error.location = location;
1024
1025 if (!cli_state_is_connected(cli_nps->cli)) {
1026 /* return the original error */
1027 tstream_cli_np_readv_error(req);
1028 return;
1029 }
1030
1031 if (cli_nps->is_smb1) {
1032 subreq = cli_close_send(state, state->ev, cli_nps->cli,
1033 cli_nps->fnum);
1034 } else {
1035 subreq = smb2cli_close_send(state, state->ev,
1036 cli_nps->cli->conn,
1037 cli_nps->cli->timeout,
1038 cli_nps->cli->smb2.session,
1039 cli_nps->cli->smb2.tid,
1040 0, /* flags */
1041 cli_nps->fid_persistent,
1042 cli_nps->fid_volatile);
1043 }
1044 if (subreq == NULL) {
1045 /* return the original error */
1046 tstream_cli_np_readv_error(req);
1047 return;
1048 }
1049 tevent_req_set_callback(subreq,
1050 tstream_cli_np_readv_disconnect_done,
1051 req);
1052 }
1053
1054 static void tstream_cli_np_readv_disconnect_done(struct tevent_req *subreq)
1055 {
1056 struct tevent_req *req =
1057 tevent_req_callback_data(subreq, struct tevent_req);
1058 struct tstream_cli_np_readv_state *state =
1059 tevent_req_data(req, struct tstream_cli_np_readv_state);
1060 struct tstream_cli_np *cli_nps =
1061 tstream_context_data(state->stream, struct tstream_cli_np);
1062
1063 if (cli_nps->is_smb1) {
1064 cli_close_recv(subreq);
1065 } else {
1066 smb2cli_close_recv(subreq);
1067 }
1068 TALLOC_FREE(subreq);
1069
1070 cli_nps->cli = NULL;
1071
1072 tstream_cli_np_readv_error(req);
1073 }
1074
1075 static void tstream_cli_np_readv_error_trigger(struct tevent_context *ctx,
1076 struct tevent_immediate *im,
1077 void *private_data);
1078
1079 static void tstream_cli_np_readv_error(struct tevent_req *req)
1080 {
1081 struct tstream_cli_np_readv_state *state =
1082 tevent_req_data(req,
1083 struct tstream_cli_np_readv_state);
1084 struct tstream_cli_np *cli_nps =
1085 tstream_context_data(state->stream,
1086 struct tstream_cli_np);
1087
1088 if (cli_nps->trans.write_req == NULL) {
1089 /* return the original error */
1090 _tevent_req_error(req, state->error.val, state->error.location);
1091 return;
1092 }
1093
1094 if (state->trans.im == NULL) {
1095 /* return the original error */
1096 _tevent_req_error(req, state->error.val, state->error.location);
1097 return;
1098 }
1099
1100 tevent_schedule_immediate(state->trans.im, state->ev,
1101 tstream_cli_np_readv_error_trigger, req);
1102
1103 /* return the original error for writev */
1104 _tevent_req_error(cli_nps->trans.write_req,
1105 state->error.val, state->error.location);
1106 }
1107
1108 static void tstream_cli_np_readv_error_trigger(struct tevent_context *ctx,
1109 struct tevent_immediate *im,
1110 void *private_data)
1111 {
1112 struct tevent_req *req =
1113 talloc_get_type_abort(private_data,
1114 struct tevent_req);
1115 struct tstream_cli_np_readv_state *state =
1116 tevent_req_data(req,
1117 struct tstream_cli_np_readv_state);
1118
1119 /* return the original error */
1120 _tevent_req_error(req, state->error.val, state->error.location);
1121 }
1122
1123 static int tstream_cli_np_readv_recv(struct tevent_req *req,
1124 int *perrno)
1125 {
1126 struct tstream_cli_np_readv_state *state =
1127 tevent_req_data(req, struct tstream_cli_np_readv_state);
1128 int ret;
1129
1130 ret = tsocket_simple_int_recv(req, perrno);
1131 if (ret == 0) {
1132 ret = state->ret;
1133 }
1134
1135 tevent_req_received(req);
1136 return ret;
1137 }
1138
1139 struct tstream_cli_np_disconnect_state {
1140 struct tstream_context *stream;
1141 };
1142
1143 static void tstream_cli_np_disconnect_done(struct tevent_req *subreq);
1144
1145 static struct tevent_req *tstream_cli_np_disconnect_send(TALLOC_CTX *mem_ctx,
1146 struct tevent_context *ev,
1147 struct tstream_context *stream)
1148 {
1149 struct tstream_cli_np *cli_nps = tstream_context_data(stream,
1150 struct tstream_cli_np);
1151 struct tevent_req *req;
1152 struct tstream_cli_np_disconnect_state *state;
1153 struct tevent_req *subreq;
1154
1155 req = tevent_req_create(mem_ctx, &state,
1156 struct tstream_cli_np_disconnect_state);
1157 if (req == NULL) {
1158 return NULL;
1159 }
1160
1161 state->stream = stream;
1162
1163 if (!cli_state_is_connected(cli_nps->cli)) {
1164 tevent_req_error(req, ENOTCONN);
1165 return tevent_req_post(req, ev);
1166 }
1167
1168 if (cli_nps->is_smb1) {
1169 subreq = cli_close_send(state, ev, cli_nps->cli,
1170 cli_nps->fnum);
1171 } else {
1172 subreq = smb2cli_close_send(state, ev, cli_nps->cli->conn,
1173 cli_nps->cli->timeout,
1174 cli_nps->cli->smb2.session,
1175 cli_nps->cli->smb2.tid,
1176 0, /* flags */
1177 cli_nps->fid_persistent,
1178 cli_nps->fid_volatile);
1179 }
1180 if (tevent_req_nomem(subreq, req)) {
1181 return tevent_req_post(req, ev);
1182 }
1183 tevent_req_set_callback(subreq, tstream_cli_np_disconnect_done, req);
1184
1185 return req;
1186 }
1187
1188 static void tstream_cli_np_disconnect_done(struct tevent_req *subreq)
1189 {
1190 struct tevent_req *req = tevent_req_callback_data(subreq,
1191 struct tevent_req);
1192 struct tstream_cli_np_disconnect_state *state =
1193 tevent_req_data(req, struct tstream_cli_np_disconnect_state);
1194 struct tstream_cli_np *cli_nps =
1195 tstream_context_data(state->stream, struct tstream_cli_np);
1196 NTSTATUS status;
1197
1198 if (cli_nps->is_smb1) {
1199 status = cli_close_recv(subreq);
1200 } else {
1201 status = smb2cli_close_recv(subreq);
1202 }
1203 TALLOC_FREE(subreq);
1204 if (!NT_STATUS_IS_OK(status)) {
1205 tevent_req_error(req, EIO);
1206 return;
1207 }
1208
1209 cli_nps->cli = NULL;
1210
1211 tevent_req_done(req);
1212 }
1213
1214 static int tstream_cli_np_disconnect_recv(struct tevent_req *req,
1215 int *perrno)
1216 {
1217 int ret;
1218
1219 ret = tsocket_simple_int_recv(req, perrno);
1220
1221 tevent_req_received(req);
1222 return ret;
1223 }
1224
1225 static const struct tstream_context_ops tstream_cli_np_ops = {
1226 .name = "cli_np",
1227
1228 .pending_bytes = tstream_cli_np_pending_bytes,
1229
1230 .readv_send = tstream_cli_np_readv_send,
1231 .readv_recv = tstream_cli_np_readv_recv,
1232
1233 .writev_send = tstream_cli_np_writev_send,
1234 .writev_recv = tstream_cli_np_writev_recv,
1235
1236 .disconnect_send = tstream_cli_np_disconnect_send,
1237 .disconnect_recv = tstream_cli_np_disconnect_recv,
1238 };
reg import