?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3-netapi: implement NetShutdownInit_r and NetShutdownAbort_r.
[Samba.git] / libcli / named_pipe_auth / npa_tstream.c
blobfdb55c7e826dedd08ed00d341eb6522fc05b248a
1 /*
2 Unix SMB/CIFS implementation.
3
4 Copyright (C) Stefan Metzmacher 2009
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 "../util/tevent_unix.h"
23 #include "../lib/tsocket/tsocket.h"
24 #include "../lib/tsocket/tsocket_internal.h"
25 #include "../librpc/gen_ndr/ndr_named_pipe_auth.h"
26 #include "../libcli/named_pipe_auth/npa_tstream.h"
27 #include "libcli/raw/smb.h"
28
29 static const struct tstream_context_ops tstream_npa_ops;
30
31 struct tstream_npa {
32 struct tstream_context *unix_stream;
33
34 uint16_t file_type;
35
36 struct iovec pending;
37 };
38
39 struct tstream_npa_connect_state {
40 struct {
41 struct tevent_context *ev;
42 struct smb_iconv_convenience *smb_iconv_c;
43 } caller;
44
45 const char *unix_path;
46 struct tsocket_address *unix_laddr;
47 struct tsocket_address *unix_raddr;
48 struct tstream_context *unix_stream;
49
50 struct named_pipe_auth_req auth_req;
51 DATA_BLOB auth_req_blob;
52 struct iovec auth_req_iov;
53
54 struct named_pipe_auth_rep auth_rep;
55 DATA_BLOB auth_rep_blob;
56 };
57
58 static void tstream_npa_connect_unix_done(struct tevent_req *subreq);
59
60 struct tevent_req *tstream_npa_connect_send(TALLOC_CTX *mem_ctx,
61 struct tevent_context *ev,
62 struct smb_iconv_convenience *smb_iconv_c,
63 const char *directory,
64 const char *npipe,
65 const struct tsocket_address *client,
66 const char *client_name_in,
67 const struct tsocket_address *server,
68 const char *server_name,
69 const struct netr_SamInfo3 *info3,
70 DATA_BLOB session_key)
71 {
72 struct tevent_req *req;
73 struct tstream_npa_connect_state *state;
74 struct tevent_req *subreq;
75 int ret;
76 enum ndr_err_code ndr_err;
77
78 req = tevent_req_create(mem_ctx, &state,
79 struct tstream_npa_connect_state);
80 if (!req) {
81 return NULL;
82 }
83
84 state->caller.ev = ev;
85 state->caller.smb_iconv_c = smb_iconv_c;
86
87 state->unix_path = talloc_asprintf(state, "%s/%s",
88 directory,
89 npipe);
90 if (tevent_req_nomem(state->unix_path, req)) {
91 goto post;
92 }
93
94 ret = tsocket_address_unix_from_path(state,
95 "",
96 &state->unix_laddr);
97 if (ret == -1) {
98 tevent_req_error(req, errno);
99 goto post;
100 }
101
102 ret = tsocket_address_unix_from_path(state,
103 state->unix_path,
104 &state->unix_raddr);
105 if (ret == -1) {
106 tevent_req_error(req, errno);
107 goto post;
108 }
109
110 ZERO_STRUCT(state->auth_req);
111 if (client) {
112 struct named_pipe_auth_req_info2 *info2;
113
114 if (!server) {
115 tevent_req_error(req, EINVAL);
116 goto post;
117 }
118
119 state->auth_req.level = 2;
120 info2 = &state->auth_req.info.info2;
121
122 info2->client_name = client_name_in;
123 info2->client_addr = tsocket_address_inet_addr_string(client, state);
124 if (!info2->client_addr) {
125 /* errno might be EINVAL */
126 tevent_req_error(req, errno);
127 goto post;
128 }
129 info2->client_port = tsocket_address_inet_port(client);
130 if (!info2->client_name) {
131 info2->client_name = info2->client_addr;
132 }
133
134 info2->server_addr = tsocket_address_inet_addr_string(server, state);
135 if (!info2->server_addr) {
136 /* errno might be EINVAL */
137 tevent_req_error(req, errno);
138 goto post;
139 }
140 info2->server_port = tsocket_address_inet_port(server);
141 if (!info2->server_name) {
142 info2->server_name = info2->server_addr;
143 }
144
145 info2->sam_info3 = discard_const_p(struct netr_SamInfo3, info3);
146 info2->session_key_length = session_key.length;
147 info2->session_key = session_key.data;
148 } else if (info3) {
149 state->auth_req.level = 1;
150 state->auth_req.info.info1 = *info3;
151 } else {
152 state->auth_req.level = 0;
153 }
154
155 if (DEBUGLVL(10)) {
156 NDR_PRINT_DEBUG(named_pipe_auth_req, &state->auth_req);
157 }
158
159 ndr_err = ndr_push_struct_blob(&state->auth_req_blob,
160 state, smb_iconv_c, &state->auth_req,
161 (ndr_push_flags_fn_t)ndr_push_named_pipe_auth_req);
162 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
163 tevent_req_error(req, EINVAL);
164 goto post;
165 }
166
167 state->auth_req_iov.iov_base = state->auth_req_blob.data;
168 state->auth_req_iov.iov_len = state->auth_req_blob.length;
169
170 subreq = tstream_unix_connect_send(state,
171 state->caller.ev,
172 state->unix_laddr,
173 state->unix_raddr);
174 if (tevent_req_nomem(subreq, req)) {
175 goto post;
176 }
177 tevent_req_set_callback(subreq, tstream_npa_connect_unix_done, req);
178
179 return req;
180
181 post:
182 tevent_req_post(req, ev);
183 return req;
184 }
185
186 static void tstream_npa_connect_writev_done(struct tevent_req *subreq);
187
188 static void tstream_npa_connect_unix_done(struct tevent_req *subreq)
189 {
190 struct tevent_req *req =
191 tevent_req_callback_data(subreq,
192 struct tevent_req);
193 struct tstream_npa_connect_state *state =
194 tevent_req_data(req,
195 struct tstream_npa_connect_state);
196 int ret;
197 int sys_errno;
198
199 ret = tstream_unix_connect_recv(subreq, &sys_errno,
200 state, &state->unix_stream);
201 TALLOC_FREE(subreq);
202 if (ret == -1) {
203 tevent_req_error(req, sys_errno);
204 return;
205 }
206
207 subreq = tstream_writev_send(state,
208 state->caller.ev,
209 state->unix_stream,
210 &state->auth_req_iov, 1);
211 if (tevent_req_nomem(subreq, req)) {
212 return;
213 }
214 tevent_req_set_callback(subreq, tstream_npa_connect_writev_done, req);
215 }
216
217 static int tstream_npa_connect_next_vector(struct tstream_context *unix_stream,
218 void *private_data,
219 TALLOC_CTX *mem_ctx,
220 struct iovec **_vector,
221 size_t *_count);
222 static void tstream_npa_connect_readv_done(struct tevent_req *subreq);
223
224 static void tstream_npa_connect_writev_done(struct tevent_req *subreq)
225 {
226 struct tevent_req *req =
227 tevent_req_callback_data(subreq,
228 struct tevent_req);
229 struct tstream_npa_connect_state *state =
230 tevent_req_data(req,
231 struct tstream_npa_connect_state);
232 int ret;
233 int sys_errno;
234
235 ret = tstream_writev_recv(subreq, &sys_errno);
236 TALLOC_FREE(subreq);
237 if (ret == -1) {
238 tevent_req_error(req, sys_errno);
239 return;
240 }
241
242 state->auth_rep_blob = data_blob_const(NULL, 0);
243
244 subreq = tstream_readv_pdu_send(state, state->caller.ev,
245 state->unix_stream,
246 tstream_npa_connect_next_vector,
247 state);
248 if (tevent_req_nomem(subreq, req)) {
249 return;
250 }
251 tevent_req_set_callback(subreq, tstream_npa_connect_readv_done, req);
252 }
253
254 static int tstream_npa_connect_next_vector(struct tstream_context *unix_stream,
255 void *private_data,
256 TALLOC_CTX *mem_ctx,
257 struct iovec **_vector,
258 size_t *_count)
259 {
260 struct tstream_npa_connect_state *state = talloc_get_type_abort(private_data,
261 struct tstream_npa_connect_state);
262 struct iovec *vector;
263 size_t count;
264 off_t ofs = 0;
265
266 if (state->auth_rep_blob.length == 0) {
267 state->auth_rep_blob = data_blob_talloc(state, NULL, 4);
268 if (!state->auth_rep_blob.data) {
269 return -1;
270 }
271 } else if (state->auth_rep_blob.length == 4) {
272 uint32_t msg_len;
273
274 ofs = 4;
275
276 msg_len = RIVAL(state->auth_rep_blob.data, 0);
277
278 if (msg_len > 0x00FFFFFF) {
279 errno = EMSGSIZE;
280 return -1;
281 }
282
283 if (msg_len == 0) {
284 errno = EMSGSIZE;
285 return -1;
286 }
287
288 msg_len += ofs;
289
290 state->auth_rep_blob.data = talloc_realloc(state,
291 state->auth_rep_blob.data,
292 uint8_t, msg_len);
293 if (!state->auth_rep_blob.data) {
294 return -1;
295 }
296 state->auth_rep_blob.length = msg_len;
297 } else {
298 *_vector = NULL;
299 *_count = 0;
300 return 0;
301 }
302
303 /* we need to get a message header */
304 vector = talloc_array(mem_ctx, struct iovec, 1);
305 if (!vector) {
306 return -1;
307 }
308 vector[0].iov_base = state->auth_rep_blob.data + ofs;
309 vector[0].iov_len = state->auth_rep_blob.length - ofs;
310 count = 1;
311
312 *_vector = vector;
313 *_count = count;
314 return 0;
315 }
316
317 static void tstream_npa_connect_readv_done(struct tevent_req *subreq)
318 {
319 struct tevent_req *req =
320 tevent_req_callback_data(subreq,
321 struct tevent_req);
322 struct tstream_npa_connect_state *state =
323 tevent_req_data(req,
324 struct tstream_npa_connect_state);
325 int ret;
326 int sys_errno;
327 enum ndr_err_code ndr_err;
328
329 ret = tstream_readv_pdu_recv(subreq, &sys_errno);
330 TALLOC_FREE(subreq);
331 if (ret == -1) {
332 tevent_req_error(req, sys_errno);
333 return;
334 }
335
336 DEBUG(10,("name_pipe_auth_rep(client)[%u]\n",
337 (uint32_t)state->auth_rep_blob.length));
338 dump_data(11, state->auth_rep_blob.data, state->auth_rep_blob.length);
339
340 ndr_err = ndr_pull_struct_blob(
341 &state->auth_rep_blob, state,
342 state->caller.smb_iconv_c, &state->auth_rep,
343 (ndr_pull_flags_fn_t)ndr_pull_named_pipe_auth_rep);
344
345 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
346 DEBUG(0, ("ndr_pull_named_pipe_auth_rep failed: %s\n",
347 ndr_map_error2string(ndr_err)));
348 tevent_req_error(req, EIO);
349 return;
350 }
351
352 if (DEBUGLVL(10)) {
353 NDR_PRINT_DEBUG(named_pipe_auth_rep, &state->auth_rep);
354 }
355
356 if (state->auth_rep.length < 16) {
357 DEBUG(0, ("req invalid length: %u < 16\n",
358 state->auth_rep.length));
359 tevent_req_error(req, EIO);
360 return;
361 }
362
363 if (strcmp(NAMED_PIPE_AUTH_MAGIC, state->auth_rep.magic) != 0) {
364 DEBUG(0, ("req invalid magic: %s != %s\n",
365 state->auth_rep.magic, NAMED_PIPE_AUTH_MAGIC));
366 tevent_req_error(req, EIO);
367 return;
368 }
369
370 if (!NT_STATUS_IS_OK(state->auth_rep.status)) {
371 DEBUG(0, ("req failed: %s\n",
372 nt_errstr(state->auth_rep.status)));
373 tevent_req_error(req, EACCES);
374 return;
375 }
376
377 if (state->auth_rep.level != state->auth_req.level) {
378 DEBUG(0, ("req invalid level: %u != %u\n",
379 state->auth_rep.level, state->auth_req.level));
380 tevent_req_error(req, EIO);
381 return;
382 }
383
384 tevent_req_done(req);
385 }
386
387 int _tstream_npa_connect_recv(struct tevent_req *req,
388 int *perrno,
389 TALLOC_CTX *mem_ctx,
390 struct tstream_context **_stream,
391 uint16_t *_file_type,
392 uint16_t *_device_state,
393 uint64_t *_allocation_size,
394 const char *location)
395 {
396 struct tstream_npa_connect_state *state =
397 tevent_req_data(req,
398 struct tstream_npa_connect_state);
399 struct tstream_context *stream;
400 struct tstream_npa *npas;
401 uint16_t device_state = 0;
402 uint64_t allocation_size = 0;
403
404 if (tevent_req_is_unix_error(req, perrno)) {
405 tevent_req_received(req);
406 return -1;
407 }
408
409 stream = tstream_context_create(mem_ctx,
410 &tstream_npa_ops,
411 &npas,
412 struct tstream_npa,
413 location);
414 if (!stream) {
415 return -1;
416 }
417 ZERO_STRUCTP(npas);
418
419 npas->unix_stream = talloc_move(stream, &state->unix_stream);
420 switch (state->auth_rep.level) {
421 case 0:
422 case 1:
423 npas->file_type = FILE_TYPE_BYTE_MODE_PIPE;
424 device_state = 0x00ff;
425 allocation_size = 2048;
426 break;
427 case 2:
428 npas->file_type = state->auth_rep.info.info2.file_type;
429 device_state = state->auth_rep.info.info2.device_state;
430 allocation_size = state->auth_rep.info.info2.allocation_size;
431 break;
432 }
433
434 *_stream = stream;
435 *_file_type = npas->file_type;
436 *_device_state = device_state;
437 *_allocation_size = allocation_size;
438 tevent_req_received(req);
439 return 0;
440 }
441
442 static ssize_t tstream_npa_pending_bytes(struct tstream_context *stream)
443 {
444 struct tstream_npa *npas = tstream_context_data(stream,
445 struct tstream_npa);
446 ssize_t ret;
447
448 if (!npas->unix_stream) {
449 errno = ENOTCONN;
450 return -1;
451 }
452
453 switch (npas->file_type) {
454 case FILE_TYPE_BYTE_MODE_PIPE:
455 ret = tstream_pending_bytes(npas->unix_stream);
456 break;
457
458 case FILE_TYPE_MESSAGE_MODE_PIPE:
459 ret = npas->pending.iov_len;
460 break;
461
462 default:
463 ret = -1;
464 }
465
466 return ret;
467 }
468
469 struct tstream_npa_readv_state {
470 struct tstream_context *stream;
471
472 struct iovec *vector;
473 size_t count;
474
475 /* the header for message mode */
476 uint8_t hdr[2];
477 bool wait_for_hdr;
478
479 int ret;
480 };
481
482 static void tstream_npa_readv_byte_mode_handler(struct tevent_req *subreq);
483 static int tstream_npa_readv_next_vector(struct tstream_context *stream,
484 void *private_data,
485 TALLOC_CTX *mem_ctx,
486 struct iovec **_vector,
487 size_t *_count);
488 static void tstream_npa_readv_msg_mode_handler(struct tevent_req *subreq);
489
490 static struct tevent_req *tstream_npa_readv_send(TALLOC_CTX *mem_ctx,
491 struct tevent_context *ev,
492 struct tstream_context *stream,
493 struct iovec *vector,
494 size_t count)
495 {
496 struct tevent_req *req;
497 struct tstream_npa_readv_state *state;
498 struct tstream_npa *npas = tstream_context_data(stream, struct tstream_npa);
499 struct tevent_req *subreq;
500 off_t ofs;
501 size_t left;
502 uint8_t *pbase;
503
504 req = tevent_req_create(mem_ctx, &state,
505 struct tstream_npa_readv_state);
506 if (!req) {
507 return NULL;
508 }
509
510 state->stream = stream;
511 state->ret = 0;
512
513 if (!npas->unix_stream) {
514 tevent_req_error(req, ENOTCONN);
515 goto post;
516 }
517
518 switch (npas->file_type) {
519 case FILE_TYPE_BYTE_MODE_PIPE:
520 state->vector = vector;
521 state->count = count;
522
523 subreq = tstream_readv_send(state,
524 ev,
525 npas->unix_stream,
526 state->vector,
527 state->count);
528 if (tevent_req_nomem(subreq,req)) {
529 goto post;
530 }
531 tevent_req_set_callback(subreq,
532 tstream_npa_readv_byte_mode_handler,
533 req);
534
535 return req;
536
537 case FILE_TYPE_MESSAGE_MODE_PIPE:
538 /*
539 * we make a copy of the vector and prepend a header
540 * with the length
541 */
542 state->vector = talloc_array(state, struct iovec, count);
543 if (tevent_req_nomem(state->vector, req)) {
544 goto post;
545 }
546 memcpy(state->vector, vector, sizeof(struct iovec)*count);
547 state->count = count;
548
549 /*
550 * copy the pending buffer first
551 */
552 ofs = 0;
553 left = npas->pending.iov_len;
554 pbase = (uint8_t *)npas->pending.iov_base;
555
556 while (left > 0 && state->count > 0) {
557 uint8_t *base;
558 base = (uint8_t *)state->vector[0].iov_base;
559 if (left < state->vector[0].iov_len) {
560 memcpy(base, pbase + ofs, left);
561
562 base += left;
563 state->vector[0].iov_base = base;
564 state->vector[0].iov_len -= left;
565
566 ofs += left;
567 left = 0;
568 TALLOC_FREE(pbase);
569 ZERO_STRUCT(npas->pending);
570 break;
571 }
572 memcpy(base, pbase + ofs, state->vector[0].iov_len);
573
574 ofs += state->vector[0].iov_len;
575 left -= state->vector[0].iov_len;
576 state->vector += 1;
577 state->count -= 1;
578
579 if (left == 0) {
580 TALLOC_FREE(pbase);
581 ZERO_STRUCT(npas->pending);
582 break;
583 }
584 }
585
586 if (left > 0) {
587 memmove(pbase, pbase + ofs, left);
588 npas->pending.iov_base = pbase;
589 npas->pending.iov_len = left;
590 /*
591 * this cannot fail and even if it
592 * fails we can handle it
593 */
594 pbase = talloc_realloc(npas, pbase, uint8_t, left);
595 if (pbase) {
596 npas->pending.iov_base = pbase;
597 }
598 pbase = NULL;
599 }
600
601 state->ret += ofs;
602
603 if (state->count == 0) {
604 tevent_req_done(req);
605 goto post;
606 }
607
608 ZERO_STRUCT(state->hdr);
609 state->wait_for_hdr = false;
610
611 subreq = tstream_readv_pdu_send(state,
612 ev,
613 npas->unix_stream,
614 tstream_npa_readv_next_vector,
615 state);
616 if (tevent_req_nomem(subreq, req)) {
617 goto post;
618 }
619 tevent_req_set_callback(subreq,
620 tstream_npa_readv_msg_mode_handler,
621 req);
622
623 return req;
624 }
625
626 /* this can't happen */
627 tevent_req_error(req, EINVAL);
628 goto post;
629
630 post:
631 tevent_req_post(req, ev);
632 return req;
633 }
634
635 static void tstream_npa_readv_byte_mode_handler(struct tevent_req *subreq)
636 {
637 struct tevent_req *req = tevent_req_callback_data(subreq,
638 struct tevent_req);
639 struct tstream_npa_readv_state *state = tevent_req_data(req,
640 struct tstream_npa_readv_state);
641 int ret;
642 int sys_errno;
643
644 ret = tstream_readv_recv(subreq, &sys_errno);
645 TALLOC_FREE(subreq);
646 if (ret == -1) {
647 tevent_req_error(req, sys_errno);
648 return;
649 }
650
651 state->ret = ret;
652
653 tevent_req_done(req);
654 }
655
656 static int tstream_npa_readv_next_vector(struct tstream_context *unix_stream,
657 void *private_data,
658 TALLOC_CTX *mem_ctx,
659 struct iovec **_vector,
660 size_t *_count)
661 {
662 struct tstream_npa_readv_state *state = talloc_get_type_abort(private_data,
663 struct tstream_npa_readv_state);
664 struct tstream_npa *npas = tstream_context_data(state->stream,
665 struct tstream_npa);
666 struct iovec *vector;
667 size_t count;
668 uint16_t msg_len;
669 size_t left;
670
671 if (state->count == 0) {
672 *_vector = NULL;
673 *_count = 0;
674 return 0;
675 }
676
677 if (!state->wait_for_hdr) {
678 /* we need to get a message header */
679 vector = talloc_array(mem_ctx, struct iovec, 1);
680 if (!vector) {
681 return -1;
682 }
683 ZERO_STRUCT(state->hdr);
684 vector[0].iov_base = state->hdr;
685 vector[0].iov_len = sizeof(state->hdr);
686
687 count = 1;
688
689 state->wait_for_hdr = true;
690
691 *_vector = vector;
692 *_count = count;
693 return 0;
694 }
695
696 /* and now fill the callers buffers and maybe the pending buffer */
697 state->wait_for_hdr = false;
698
699 msg_len = SVAL(state->hdr, 0);
700
701 if (msg_len == 0) {
702 errno = EIO;
703 return -1;
704 }
705
706 state->wait_for_hdr = false;
707
708 /* +1 because we may need to fill the pending buffer */
709 vector = talloc_array(mem_ctx, struct iovec, state->count + 1);
710 if (!vector) {
711 return -1;
712 }
713
714 count = 0;
715 left = msg_len;
716 while (left > 0 && state->count > 0) {
717 if (left < state->vector[0].iov_len) {
718 uint8_t *base;
719 base = (uint8_t *)state->vector[0].iov_base;
720 vector[count].iov_base = base;
721 vector[count].iov_len = left;
722 count++;
723 base += left;
724 state->vector[0].iov_base = base;
725 state->vector[0].iov_len -= left;
726 break;
727 }
728 vector[count] = state->vector[0];
729 count++;
730 left -= state->vector[0].iov_len;
731 state->vector += 1;
732 state->count -= 1;
733 }
734
735 if (left > 0) {
736 /*
737 * if the message if longer than the buffers the caller
738 * requested, we need to consume the rest of the message
739 * into the pending buffer, where the next readv can
740 * be served from.
741 */
742 npas->pending.iov_base = talloc_array(npas, uint8_t, left);
743 if (!npas->pending.iov_base) {
744 return -1;
745 }
746 npas->pending.iov_len = left;
747
748 vector[count] = npas->pending;
749 count++;
750 }
751
752 state->ret += (msg_len - left);
753
754 *_vector = vector;
755 *_count = count;
756 return 0;
757 }
758
759 static void tstream_npa_readv_msg_mode_handler(struct tevent_req *subreq)
760 {
761 struct tevent_req *req = tevent_req_callback_data(subreq,
762 struct tevent_req);
763 int ret;
764 int sys_errno;
765
766 ret = tstream_readv_pdu_recv(subreq, &sys_errno);
767 TALLOC_FREE(subreq);
768 if (ret == -1) {
769 tevent_req_error(req, sys_errno);
770 return;
771 }
772
773 /*
774 * we do not set state->ret here as ret includes the headr size.
775 * we set it in tstream_npa_readv_pdu_next_vector()
776 */
777
778 tevent_req_done(req);
779 }
780
781 static int tstream_npa_readv_recv(struct tevent_req *req,
782 int *perrno)
783 {
784 struct tstream_npa_readv_state *state = tevent_req_data(req,
785 struct tstream_npa_readv_state);
786 int ret;
787
788 ret = tsocket_simple_int_recv(req, perrno);
789 if (ret == 0) {
790 ret = state->ret;
791 }
792
793 tevent_req_received(req);
794 return ret;
795 }
796
797 struct tstream_npa_writev_state {
798 const struct iovec *vector;
799 size_t count;
800
801 /* the header for message mode */
802 uint8_t hdr[2];
803
804 int ret;
805 };
806
807 static void tstream_npa_writev_handler(struct tevent_req *subreq);
808
809 static struct tevent_req *tstream_npa_writev_send(TALLOC_CTX *mem_ctx,
810 struct tevent_context *ev,
811 struct tstream_context *stream,
812 const struct iovec *vector,
813 size_t count)
814 {
815 struct tevent_req *req;
816 struct tstream_npa_writev_state *state;
817 struct tstream_npa *npas = tstream_context_data(stream, struct tstream_npa);
818 struct tevent_req *subreq;
819 size_t msg_len;
820 size_t i;
821 struct iovec *new_vector;
822
823 req = tevent_req_create(mem_ctx, &state,
824 struct tstream_npa_writev_state);
825 if (!req) {
826 return NULL;
827 }
828
829 state->ret = 0;
830
831 if (!npas->unix_stream) {
832 tevent_req_error(req, ENOTCONN);
833 goto post;
834 }
835
836 switch (npas->file_type) {
837 case FILE_TYPE_BYTE_MODE_PIPE:
838 state->vector = vector;
839 state->count = count;
840 break;
841
842 case FILE_TYPE_MESSAGE_MODE_PIPE:
843 /*
844 * we make a copy of the vector and prepend a header
845 * with the length
846 */
847 new_vector = talloc_array(state, struct iovec, count + 1);
848 if (tevent_req_nomem(new_vector, req)) {
849 goto post;
850 }
851 new_vector[0].iov_base = state->hdr;
852 new_vector[0].iov_len = sizeof(state->hdr);
853 memcpy(new_vector + 1, vector, sizeof(struct iovec)*count);
854
855 state->vector = new_vector;
856 state->count = count + 1;
857
858 msg_len = 0;
859 for (i=0; i < count; i++) {
860 msg_len += vector[i].iov_len;
861 }
862
863 if (msg_len > UINT16_MAX) {
864 tevent_req_error(req, EMSGSIZE);
865 goto post;
866 }
867
868 SSVAL(state->hdr, 0, msg_len);
869 break;
870 }
871
872 subreq = tstream_writev_send(state,
873 ev,
874 npas->unix_stream,
875 state->vector,
876 state->count);
877 if (tevent_req_nomem(subreq, req)) {
878 goto post;
879 }
880 tevent_req_set_callback(subreq, tstream_npa_writev_handler, req);
881
882 return req;
883
884 post:
885 tevent_req_post(req, ev);
886 return req;
887 }
888
889 static void tstream_npa_writev_handler(struct tevent_req *subreq)
890 {
891 struct tevent_req *req = tevent_req_callback_data(subreq,
892 struct tevent_req);
893 struct tstream_npa_writev_state *state = tevent_req_data(req,
894 struct tstream_npa_writev_state);
895 int ret;
896 int sys_errno;
897
898 ret = tstream_writev_recv(subreq, &sys_errno);
899 TALLOC_FREE(subreq);
900 if (ret == -1) {
901 tevent_req_error(req, sys_errno);
902 return;
903 }
904
905 state->ret = ret;
906
907 tevent_req_done(req);
908 }
909
910 static int tstream_npa_writev_recv(struct tevent_req *req,
911 int *perrno)
912 {
913 struct tstream_npa_writev_state *state = tevent_req_data(req,
914 struct tstream_npa_writev_state);
915 int ret;
916
917 ret = tsocket_simple_int_recv(req, perrno);
918 if (ret == 0) {
919 ret = state->ret;
920 }
921
922 tevent_req_received(req);
923 return ret;
924 }
925
926 struct tstream_npa_disconnect_state {
927 struct tstream_context *stream;
928 };
929
930 static void tstream_npa_disconnect_handler(struct tevent_req *subreq);
931
932 static struct tevent_req *tstream_npa_disconnect_send(TALLOC_CTX *mem_ctx,
933 struct tevent_context *ev,
934 struct tstream_context *stream)
935 {
936 struct tstream_npa *npas = tstream_context_data(stream, struct tstream_npa);
937 struct tevent_req *req;
938 struct tstream_npa_disconnect_state *state;
939 struct tevent_req *subreq;
940
941 req = tevent_req_create(mem_ctx, &state,
942 struct tstream_npa_disconnect_state);
943 if (req == NULL) {
944 return NULL;
945 }
946
947 state->stream = stream;
948
949 if (!npas->unix_stream) {
950 tevent_req_error(req, ENOTCONN);
951 goto post;
952 }
953
954 subreq = tstream_disconnect_send(state,
955 ev,
956 npas->unix_stream);
957 if (tevent_req_nomem(subreq, req)) {
958 goto post;
959 }
960 tevent_req_set_callback(subreq, tstream_npa_disconnect_handler, req);
961
962 return req;
963
964 post:
965 tevent_req_post(req, ev);
966 return req;
967 }
968
969 static void tstream_npa_disconnect_handler(struct tevent_req *subreq)
970 {
971 struct tevent_req *req = tevent_req_callback_data(subreq,
972 struct tevent_req);
973 struct tstream_npa_disconnect_state *state = tevent_req_data(req,
974 struct tstream_npa_disconnect_state);
975 struct tstream_context *stream = state->stream;
976 struct tstream_npa *npas = tstream_context_data(stream, struct tstream_npa);
977 int ret;
978 int sys_errno;
979
980 ret = tstream_disconnect_recv(subreq, &sys_errno);
981 TALLOC_FREE(subreq);
982 if (ret == -1) {
983 tevent_req_error(req, sys_errno);
984 return;
985 }
986
987 TALLOC_FREE(npas->unix_stream);
988
989 tevent_req_done(req);
990 }
991
992 static int tstream_npa_disconnect_recv(struct tevent_req *req,
993 int *perrno)
994 {
995 int ret;
996
997 ret = tsocket_simple_int_recv(req, perrno);
998
999 tevent_req_received(req);
1000 return ret;
1001 }
1002
1003 static const struct tstream_context_ops tstream_npa_ops = {
1004 .name = "npa",
1005
1006 .pending_bytes = tstream_npa_pending_bytes,
1007
1008 .readv_send = tstream_npa_readv_send,
1009 .readv_recv = tstream_npa_readv_recv,
1010
1011 .writev_send = tstream_npa_writev_send,
1012 .writev_recv = tstream_npa_writev_recv,
1013
1014 .disconnect_send = tstream_npa_disconnect_send,
1015 .disconnect_recv = tstream_npa_disconnect_recv,
1016 };
1017
1018 int _tstream_npa_existing_socket(TALLOC_CTX *mem_ctx,
1019 int fd,
1020 uint16_t file_type,
1021 struct tstream_context **_stream,
1022 const char *location)
1023 {
1024 struct tstream_context *stream;
1025 struct tstream_npa *npas;
1026 int ret;
1027
1028 switch (file_type) {
1029 case FILE_TYPE_BYTE_MODE_PIPE:
1030 break;
1031 case FILE_TYPE_MESSAGE_MODE_PIPE:
1032 break;
1033 default:
1034 errno = EINVAL;
1035 return -1;
1036 }
1037
1038 stream = tstream_context_create(mem_ctx,
1039 &tstream_npa_ops,
1040 &npas,
1041 struct tstream_npa,
1042 location);
1043 if (!stream) {
1044 return -1;
1045 }
1046 ZERO_STRUCTP(npas);
1047
1048 npas->file_type = file_type;
1049
1050 ret = tstream_bsd_existing_socket(stream, fd,
1051 &npas->unix_stream);
1052 if (ret == -1) {
1053 int saved_errno = errno;
1054 talloc_free(stream);
1055 errno = saved_errno;
1056 return -1;
1057 }
1058
1059 *_stream = stream;
1060 return 0;
1061 }
1062
Samba GIT mirror