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