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