?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
waf: Fix bug #8801 - build s3fs manpages.
[Samba/gebeck_regimport.git] / libcli / named_pipe_auth / npa_tstream.c
blobc2eb7bf7148d73f14992e9dcd0ad46f2d5bd3abf
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/smb/smb_constants.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 } caller;
43
44 const char *unix_path;
45 struct tsocket_address *unix_laddr;
46 struct tsocket_address *unix_raddr;
47 struct tstream_context *unix_stream;
48
49 struct named_pipe_auth_req auth_req;
50 DATA_BLOB auth_req_blob;
51 struct iovec auth_req_iov;
52
53 struct named_pipe_auth_rep auth_rep;
54 DATA_BLOB auth_rep_blob;
55 };
56
57 static void tstream_npa_connect_unix_done(struct tevent_req *subreq);
58
59 struct tevent_req *tstream_npa_connect_send(TALLOC_CTX *mem_ctx,
60 struct tevent_context *ev,
61 const char *directory,
62 const char *npipe,
63 const struct tsocket_address *client,
64 const char *client_name_in,
65 const struct tsocket_address *server,
66 const char *server_name,
67 const struct auth_session_info_transport *session_info)
68 {
69 struct tevent_req *req;
70 struct tstream_npa_connect_state *state;
71 struct tevent_req *subreq;
72 int ret;
73 enum ndr_err_code ndr_err;
74 char *lower_case_npipe;
75 struct named_pipe_auth_req_info4 *info4;
76
77 req = tevent_req_create(mem_ctx, &state,
78 struct tstream_npa_connect_state);
79 if (!req) {
80 return NULL;
81 }
82
83 state->caller.ev = ev;
84
85 lower_case_npipe = strlower_talloc(state, npipe);
86 if (tevent_req_nomem(lower_case_npipe, req)) {
87 goto post;
88 }
89
90 state->unix_path = talloc_asprintf(state, "%s/%s",
91 directory,
92 lower_case_npipe);
93 talloc_free(lower_case_npipe);
94 if (tevent_req_nomem(state->unix_path, req)) {
95 goto post;
96 }
97
98 ret = tsocket_address_unix_from_path(state,
99 "",
100 &state->unix_laddr);
101 if (ret == -1) {
102 tevent_req_error(req, errno);
103 goto post;
104 }
105
106 ret = tsocket_address_unix_from_path(state,
107 state->unix_path,
108 &state->unix_raddr);
109 if (ret == -1) {
110 tevent_req_error(req, errno);
111 goto post;
112 }
113
114 ZERO_STRUCT(state->auth_req);
115
116 if (!server) {
117 tevent_req_error(req, EINVAL);
118 goto post;
119 }
120
121 state->auth_req.level = 4;
122 info4 = &state->auth_req.info.info4;
123
124 info4->client_name = client_name_in;
125 info4->client_addr = tsocket_address_inet_addr_string(client, state);
126 if (!info4->client_addr) {
127 /* errno might be EINVAL */
128 tevent_req_error(req, errno);
129 goto post;
130 }
131 info4->client_port = tsocket_address_inet_port(client);
132 if (!info4->client_name) {
133 info4->client_name = info4->client_addr;
134 }
135
136 info4->server_addr = tsocket_address_inet_addr_string(server, state);
137 if (!info4->server_addr) {
138 /* errno might be EINVAL */
139 tevent_req_error(req, errno);
140 goto post;
141 }
142 info4->server_port = tsocket_address_inet_port(server);
143 if (!info4->server_name) {
144 info4->server_name = info4->server_addr;
145 }
146
147 info4->session_info = discard_const_p(struct auth_session_info_transport, session_info);
148
149 if (DEBUGLVL(10)) {
150 NDR_PRINT_DEBUG(named_pipe_auth_req, &state->auth_req);
151 }
152
153 ndr_err = ndr_push_struct_blob(&state->auth_req_blob,
154 state, &state->auth_req,
155 (ndr_push_flags_fn_t)ndr_push_named_pipe_auth_req);
156 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
157 tevent_req_error(req, EINVAL);
158 goto post;
159 }
160
161 state->auth_req_iov.iov_base = (char *) state->auth_req_blob.data;
162 state->auth_req_iov.iov_len = state->auth_req_blob.length;
163
164 subreq = tstream_unix_connect_send(state,
165 state->caller.ev,
166 state->unix_laddr,
167 state->unix_raddr);
168 if (tevent_req_nomem(subreq, req)) {
169 goto post;
170 }
171 tevent_req_set_callback(subreq, tstream_npa_connect_unix_done, req);
172
173 return req;
174
175 post:
176 tevent_req_post(req, ev);
177 return req;
178 }
179
180 static void tstream_npa_connect_writev_done(struct tevent_req *subreq);
181
182 static void tstream_npa_connect_unix_done(struct tevent_req *subreq)
183 {
184 struct tevent_req *req =
185 tevent_req_callback_data(subreq,
186 struct tevent_req);
187 struct tstream_npa_connect_state *state =
188 tevent_req_data(req,
189 struct tstream_npa_connect_state);
190 int ret;
191 int sys_errno;
192
193 ret = tstream_unix_connect_recv(subreq, &sys_errno,
194 state, &state->unix_stream);
195 TALLOC_FREE(subreq);
196 if (ret == -1) {
197 tevent_req_error(req, sys_errno);
198 return;
199 }
200
201 subreq = tstream_writev_send(state,
202 state->caller.ev,
203 state->unix_stream,
204 &state->auth_req_iov, 1);
205 if (tevent_req_nomem(subreq, req)) {
206 return;
207 }
208 tevent_req_set_callback(subreq, tstream_npa_connect_writev_done, req);
209 }
210
211 static int tstream_npa_connect_next_vector(struct tstream_context *unix_stream,
212 void *private_data,
213 TALLOC_CTX *mem_ctx,
214 struct iovec **_vector,
215 size_t *_count);
216 static void tstream_npa_connect_readv_done(struct tevent_req *subreq);
217
218 static void tstream_npa_connect_writev_done(struct tevent_req *subreq)
219 {
220 struct tevent_req *req =
221 tevent_req_callback_data(subreq,
222 struct tevent_req);
223 struct tstream_npa_connect_state *state =
224 tevent_req_data(req,
225 struct tstream_npa_connect_state);
226 int ret;
227 int sys_errno;
228
229 ret = tstream_writev_recv(subreq, &sys_errno);
230 TALLOC_FREE(subreq);
231 if (ret == -1) {
232 tevent_req_error(req, sys_errno);
233 return;
234 }
235
236 state->auth_rep_blob = data_blob_const(NULL, 0);
237
238 subreq = tstream_readv_pdu_send(state, state->caller.ev,
239 state->unix_stream,
240 tstream_npa_connect_next_vector,
241 state);
242 if (tevent_req_nomem(subreq, req)) {
243 return;
244 }
245 tevent_req_set_callback(subreq, tstream_npa_connect_readv_done, req);
246 }
247
248 static int tstream_npa_connect_next_vector(struct tstream_context *unix_stream,
249 void *private_data,
250 TALLOC_CTX *mem_ctx,
251 struct iovec **_vector,
252 size_t *_count)
253 {
254 struct tstream_npa_connect_state *state = talloc_get_type_abort(private_data,
255 struct tstream_npa_connect_state);
256 struct iovec *vector;
257 size_t count;
258 off_t ofs = 0;
259
260 if (state->auth_rep_blob.length == 0) {
261 state->auth_rep_blob = data_blob_talloc(state, NULL, 4);
262 if (!state->auth_rep_blob.data) {
263 return -1;
264 }
265 } else if (state->auth_rep_blob.length == 4) {
266 uint32_t msg_len;
267
268 ofs = 4;
269
270 msg_len = RIVAL(state->auth_rep_blob.data, 0);
271
272 if (msg_len > 0x00FFFFFF) {
273 errno = EMSGSIZE;
274 return -1;
275 }
276
277 if (msg_len == 0) {
278 errno = EMSGSIZE;
279 return -1;
280 }
281
282 msg_len += ofs;
283
284 state->auth_rep_blob.data = talloc_realloc(state,
285 state->auth_rep_blob.data,
286 uint8_t, msg_len);
287 if (!state->auth_rep_blob.data) {
288 return -1;
289 }
290 state->auth_rep_blob.length = msg_len;
291 } else {
292 *_vector = NULL;
293 *_count = 0;
294 return 0;
295 }
296
297 /* we need to get a message header */
298 vector = talloc_array(mem_ctx, struct iovec, 1);
299 if (!vector) {
300 return -1;
301 }
302 vector[0].iov_base = (char *) (state->auth_rep_blob.data + ofs);
303 vector[0].iov_len = state->auth_rep_blob.length - ofs;
304 count = 1;
305
306 *_vector = vector;
307 *_count = count;
308 return 0;
309 }
310
311 static void tstream_npa_connect_readv_done(struct tevent_req *subreq)
312 {
313 struct tevent_req *req =
314 tevent_req_callback_data(subreq,
315 struct tevent_req);
316 struct tstream_npa_connect_state *state =
317 tevent_req_data(req,
318 struct tstream_npa_connect_state);
319 int ret;
320 int sys_errno;
321 enum ndr_err_code ndr_err;
322
323 ret = tstream_readv_pdu_recv(subreq, &sys_errno);
324 TALLOC_FREE(subreq);
325 if (ret == -1) {
326 tevent_req_error(req, sys_errno);
327 return;
328 }
329
330 DEBUG(10,("name_pipe_auth_rep(client)[%u]\n",
331 (uint32_t)state->auth_rep_blob.length));
332 dump_data(11, state->auth_rep_blob.data, state->auth_rep_blob.length);
333
334 ndr_err = ndr_pull_struct_blob(
335 &state->auth_rep_blob, state,
336 &state->auth_rep,
337 (ndr_pull_flags_fn_t)ndr_pull_named_pipe_auth_rep);
338
339 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
340 DEBUG(0, ("ndr_pull_named_pipe_auth_rep failed: %s\n",
341 ndr_map_error2string(ndr_err)));
342 tevent_req_error(req, EIO);
343 return;
344 }
345
346 if (DEBUGLVL(10)) {
347 NDR_PRINT_DEBUG(named_pipe_auth_rep, &state->auth_rep);
348 }
349
350 if (state->auth_rep.length < 16) {
351 DEBUG(0, ("req invalid length: %u < 16\n",
352 state->auth_rep.length));
353 tevent_req_error(req, EIO);
354 return;
355 }
356
357 if (strcmp(NAMED_PIPE_AUTH_MAGIC, state->auth_rep.magic) != 0) {
358 DEBUG(0, ("req invalid magic: %s != %s\n",
359 state->auth_rep.magic, NAMED_PIPE_AUTH_MAGIC));
360 tevent_req_error(req, EIO);
361 return;
362 }
363
364 if (!NT_STATUS_IS_OK(state->auth_rep.status)) {
365 DEBUG(0, ("req failed: %s\n",
366 nt_errstr(state->auth_rep.status)));
367 tevent_req_error(req, EACCES);
368 return;
369 }
370
371 if (state->auth_rep.level != state->auth_req.level) {
372 DEBUG(0, ("req invalid level: %u != %u\n",
373 state->auth_rep.level, state->auth_req.level));
374 tevent_req_error(req, EIO);
375 return;
376 }
377
378 tevent_req_done(req);
379 }
380
381 int _tstream_npa_connect_recv(struct tevent_req *req,
382 int *perrno,
383 TALLOC_CTX *mem_ctx,
384 struct tstream_context **_stream,
385 uint16_t *_file_type,
386 uint16_t *_device_state,
387 uint64_t *_allocation_size,
388 const char *location)
389 {
390 struct tstream_npa_connect_state *state =
391 tevent_req_data(req,
392 struct tstream_npa_connect_state);
393 struct tstream_context *stream;
394 struct tstream_npa *npas;
395 uint16_t device_state = 0;
396 uint64_t allocation_size = 0;
397
398 if (tevent_req_is_unix_error(req, perrno)) {
399 tevent_req_received(req);
400 return -1;
401 }
402
403 stream = tstream_context_create(mem_ctx,
404 &tstream_npa_ops,
405 &npas,
406 struct tstream_npa,
407 location);
408 if (!stream) {
409 *perrno = ENOMEM;
410 tevent_req_received(req);
411 return -1;
412 }
413 ZERO_STRUCTP(npas);
414
415 npas->unix_stream = talloc_move(stream, &state->unix_stream);
416 switch (state->auth_rep.level) {
417 case 4:
418 npas->file_type = state->auth_rep.info.info4.file_type;
419 device_state = state->auth_rep.info.info4.device_state;
420 allocation_size = state->auth_rep.info.info4.allocation_size;
421 break;
422 }
423
424 *_stream = stream;
425 *_file_type = npas->file_type;
426 *_device_state = device_state;
427 *_allocation_size = allocation_size;
428 tevent_req_received(req);
429 return 0;
430 }
431
432 static ssize_t tstream_npa_pending_bytes(struct tstream_context *stream)
433 {
434 struct tstream_npa *npas = tstream_context_data(stream,
435 struct tstream_npa);
436 ssize_t ret;
437
438 if (!npas->unix_stream) {
439 errno = ENOTCONN;
440 return -1;
441 }
442
443 switch (npas->file_type) {
444 case FILE_TYPE_BYTE_MODE_PIPE:
445 ret = tstream_pending_bytes(npas->unix_stream);
446 break;
447
448 case FILE_TYPE_MESSAGE_MODE_PIPE:
449 ret = npas->pending.iov_len;
450 break;
451
452 default:
453 ret = -1;
454 }
455
456 return ret;
457 }
458
459 struct tstream_npa_readv_state {
460 struct tstream_context *stream;
461
462 struct iovec *vector;
463 size_t count;
464
465 /* the header for message mode */
466 uint8_t hdr[2];
467 bool wait_for_hdr;
468
469 int ret;
470 };
471
472 static void tstream_npa_readv_byte_mode_handler(struct tevent_req *subreq);
473 static int tstream_npa_readv_next_vector(struct tstream_context *stream,
474 void *private_data,
475 TALLOC_CTX *mem_ctx,
476 struct iovec **_vector,
477 size_t *_count);
478 static void tstream_npa_readv_msg_mode_handler(struct tevent_req *subreq);
479
480 static struct tevent_req *tstream_npa_readv_send(TALLOC_CTX *mem_ctx,
481 struct tevent_context *ev,
482 struct tstream_context *stream,
483 struct iovec *vector,
484 size_t count)
485 {
486 struct tevent_req *req;
487 struct tstream_npa_readv_state *state;
488 struct tstream_npa *npas = tstream_context_data(stream, struct tstream_npa);
489 struct tevent_req *subreq;
490 off_t ofs;
491 size_t left;
492 uint8_t *pbase;
493
494 req = tevent_req_create(mem_ctx, &state,
495 struct tstream_npa_readv_state);
496 if (!req) {
497 return NULL;
498 }
499
500 state->stream = stream;
501 state->ret = 0;
502
503 if (!npas->unix_stream) {
504 tevent_req_error(req, ENOTCONN);
505 goto post;
506 }
507
508 switch (npas->file_type) {
509 case FILE_TYPE_BYTE_MODE_PIPE:
510 state->vector = vector;
511 state->count = count;
512
513 subreq = tstream_readv_send(state,
514 ev,
515 npas->unix_stream,
516 state->vector,
517 state->count);
518 if (tevent_req_nomem(subreq,req)) {
519 goto post;
520 }
521 tevent_req_set_callback(subreq,
522 tstream_npa_readv_byte_mode_handler,
523 req);
524
525 return req;
526
527 case FILE_TYPE_MESSAGE_MODE_PIPE:
528 /*
529 * we make a copy of the vector and prepend a header
530 * with the length
531 */
532 state->vector = talloc_array(state, struct iovec, count);
533 if (tevent_req_nomem(state->vector, req)) {
534 goto post;
535 }
536 memcpy(state->vector, vector, sizeof(struct iovec)*count);
537 state->count = count;
538
539 /*
540 * copy the pending buffer first
541 */
542 ofs = 0;
543 left = npas->pending.iov_len;
544 pbase = (uint8_t *)npas->pending.iov_base;
545
546 while (left > 0 && state->count > 0) {
547 uint8_t *base;
548 base = (uint8_t *)state->vector[0].iov_base;
549 if (left < state->vector[0].iov_len) {
550 memcpy(base, pbase + ofs, left);
551
552 base += left;
553 state->vector[0].iov_base = (char *) base;
554 state->vector[0].iov_len -= left;
555
556 ofs += left;
557 left = 0;
558 TALLOC_FREE(pbase);
559 ZERO_STRUCT(npas->pending);
560 break;
561 }
562 memcpy(base, pbase + ofs, state->vector[0].iov_len);
563
564 ofs += state->vector[0].iov_len;
565 left -= state->vector[0].iov_len;
566 state->vector += 1;
567 state->count -= 1;
568
569 if (left == 0) {
570 TALLOC_FREE(pbase);
571 ZERO_STRUCT(npas->pending);
572 break;
573 }
574 }
575
576 if (left > 0) {
577 memmove(pbase, pbase + ofs, left);
578 npas->pending.iov_base = (char *) pbase;
579 npas->pending.iov_len = left;
580 /*
581 * this cannot fail and even if it
582 * fails we can handle it
583 */
584 pbase = talloc_realloc(npas, pbase, uint8_t, left);
585 if (pbase) {
586 npas->pending.iov_base = (char *) pbase;
587 }
588 pbase = NULL;
589 }
590
591 state->ret += ofs;
592
593 if (state->count == 0) {
594 tevent_req_done(req);
595 goto post;
596 }
597
598 ZERO_STRUCT(state->hdr);
599 state->wait_for_hdr = false;
600
601 subreq = tstream_readv_pdu_send(state,
602 ev,
603 npas->unix_stream,
604 tstream_npa_readv_next_vector,
605 state);
606 if (tevent_req_nomem(subreq, req)) {
607 goto post;
608 }
609 tevent_req_set_callback(subreq,
610 tstream_npa_readv_msg_mode_handler,
611 req);
612
613 return req;
614 }
615
616 /* this can't happen */
617 tevent_req_error(req, EINVAL);
618 goto post;
619
620 post:
621 tevent_req_post(req, ev);
622 return req;
623 }
624
625 static void tstream_npa_readv_byte_mode_handler(struct tevent_req *subreq)
626 {
627 struct tevent_req *req = tevent_req_callback_data(subreq,
628 struct tevent_req);
629 struct tstream_npa_readv_state *state = tevent_req_data(req,
630 struct tstream_npa_readv_state);
631 int ret;
632 int sys_errno;
633
634 ret = tstream_readv_recv(subreq, &sys_errno);
635 TALLOC_FREE(subreq);
636 if (ret == -1) {
637 tevent_req_error(req, sys_errno);
638 return;
639 }
640
641 state->ret = ret;
642
643 tevent_req_done(req);
644 }
645
646 static int tstream_npa_readv_next_vector(struct tstream_context *unix_stream,
647 void *private_data,
648 TALLOC_CTX *mem_ctx,
649 struct iovec **_vector,
650 size_t *_count)
651 {
652 struct tstream_npa_readv_state *state = talloc_get_type_abort(private_data,
653 struct tstream_npa_readv_state);
654 struct tstream_npa *npas = tstream_context_data(state->stream,
655 struct tstream_npa);
656 struct iovec *vector;
657 size_t count;
658 uint16_t msg_len;
659 size_t left;
660
661 if (state->count == 0) {
662 *_vector = NULL;
663 *_count = 0;
664 return 0;
665 }
666
667 if (!state->wait_for_hdr) {
668 /* we need to get a message header */
669 vector = talloc_array(mem_ctx, struct iovec, 1);
670 if (!vector) {
671 return -1;
672 }
673 ZERO_STRUCT(state->hdr);
674 vector[0].iov_base = (char *) state->hdr;
675 vector[0].iov_len = sizeof(state->hdr);
676
677 count = 1;
678
679 state->wait_for_hdr = true;
680
681 *_vector = vector;
682 *_count = count;
683 return 0;
684 }
685
686 /* and now fill the callers buffers and maybe the pending buffer */
687 state->wait_for_hdr = false;
688
689 msg_len = SVAL(state->hdr, 0);
690
691 if (msg_len == 0) {
692 errno = EIO;
693 return -1;
694 }
695
696 state->wait_for_hdr = false;
697
698 /* +1 because we may need to fill the pending buffer */
699 vector = talloc_array(mem_ctx, struct iovec, state->count + 1);
700 if (!vector) {
701 return -1;
702 }
703
704 count = 0;
705 left = msg_len;
706 while (left > 0 && state->count > 0) {
707 if (left < state->vector[0].iov_len) {
708 uint8_t *base;
709 base = (uint8_t *)state->vector[0].iov_base;
710 vector[count].iov_base = (char *) base;
711 vector[count].iov_len = left;
712 count++;
713 base += left;
714 state->vector[0].iov_base = (char *) base;
715 state->vector[0].iov_len -= left;
716 break;
717 }
718 vector[count] = state->vector[0];
719 count++;
720 left -= state->vector[0].iov_len;
721 state->vector += 1;
722 state->count -= 1;
723 }
724
725 if (left > 0) {
726 /*
727 * if the message is longer than the buffers the caller
728 * requested, we need to consume the rest of the message
729 * into the pending buffer, where the next readv can
730 * be served from.
731 */
732 npas->pending.iov_base = talloc_array(npas, char, left);
733 if (!npas->pending.iov_base) {
734 return -1;
735 }
736 npas->pending.iov_len = left;
737
738 vector[count] = npas->pending;
739 count++;
740 }
741
742 state->ret += (msg_len - left);
743
744 *_vector = vector;
745 *_count = count;
746 return 0;
747 }
748
749 static void tstream_npa_readv_msg_mode_handler(struct tevent_req *subreq)
750 {
751 struct tevent_req *req = tevent_req_callback_data(subreq,
752 struct tevent_req);
753 int ret;
754 int sys_errno;
755
756 ret = tstream_readv_pdu_recv(subreq, &sys_errno);
757 TALLOC_FREE(subreq);
758 if (ret == -1) {
759 tevent_req_error(req, sys_errno);
760 return;
761 }
762
763 /*
764 * we do not set state->ret here as ret includes the headr size.
765 * we set it in tstream_npa_readv_pdu_next_vector()
766 */
767
768 tevent_req_done(req);
769 }
770
771 static int tstream_npa_readv_recv(struct tevent_req *req,
772 int *perrno)
773 {
774 struct tstream_npa_readv_state *state = tevent_req_data(req,
775 struct tstream_npa_readv_state);
776 int ret;
777
778 ret = tsocket_simple_int_recv(req, perrno);
779 if (ret == 0) {
780 ret = state->ret;
781 }
782
783 tevent_req_received(req);
784 return ret;
785 }
786
787 struct tstream_npa_writev_state {
788 const struct iovec *vector;
789 size_t count;
790
791 /* the header for message mode */
792 bool hdr_used;
793 uint8_t hdr[2];
794
795 int ret;
796 };
797
798 static void tstream_npa_writev_handler(struct tevent_req *subreq);
799
800 static struct tevent_req *tstream_npa_writev_send(TALLOC_CTX *mem_ctx,
801 struct tevent_context *ev,
802 struct tstream_context *stream,
803 const struct iovec *vector,
804 size_t count)
805 {
806 struct tevent_req *req;
807 struct tstream_npa_writev_state *state;
808 struct tstream_npa *npas = tstream_context_data(stream, struct tstream_npa);
809 struct tevent_req *subreq;
810 size_t msg_len;
811 size_t i;
812 struct iovec *new_vector;
813
814 req = tevent_req_create(mem_ctx, &state,
815 struct tstream_npa_writev_state);
816 if (!req) {
817 return NULL;
818 }
819
820 state->ret = 0;
821
822 if (!npas->unix_stream) {
823 tevent_req_error(req, ENOTCONN);
824 goto post;
825 }
826
827 switch (npas->file_type) {
828 case FILE_TYPE_BYTE_MODE_PIPE:
829 state->hdr_used = false;
830 state->vector = vector;
831 state->count = count;
832 break;
833
834 case FILE_TYPE_MESSAGE_MODE_PIPE:
835 /*
836 * we make a copy of the vector and prepend a header
837 * with the length
838 */
839 new_vector = talloc_array(state, struct iovec, count + 1);
840 if (tevent_req_nomem(new_vector, req)) {
841 goto post;
842 }
843 new_vector[0].iov_base = (char *) state->hdr;
844 new_vector[0].iov_len = sizeof(state->hdr);
845 memcpy(new_vector + 1, vector, sizeof(struct iovec)*count);
846
847 state->hdr_used = true;
848 state->vector = new_vector;
849 state->count = count + 1;
850
851 msg_len = 0;
852 for (i=0; i < count; i++) {
853 msg_len += vector[i].iov_len;
854 }
855
856 if (msg_len > UINT16_MAX) {
857 tevent_req_error(req, EMSGSIZE);
858 goto post;
859 }
860
861 SSVAL(state->hdr, 0, msg_len);
862 break;
863 }
864
865 subreq = tstream_writev_send(state,
866 ev,
867 npas->unix_stream,
868 state->vector,
869 state->count);
870 if (tevent_req_nomem(subreq, req)) {
871 goto post;
872 }
873 tevent_req_set_callback(subreq, tstream_npa_writev_handler, req);
874
875 return req;
876
877 post:
878 tevent_req_post(req, ev);
879 return req;
880 }
881
882 static void tstream_npa_writev_handler(struct tevent_req *subreq)
883 {
884 struct tevent_req *req = tevent_req_callback_data(subreq,
885 struct tevent_req);
886 struct tstream_npa_writev_state *state = tevent_req_data(req,
887 struct tstream_npa_writev_state);
888 int ret;
889 int sys_errno;
890
891 ret = tstream_writev_recv(subreq, &sys_errno);
892 TALLOC_FREE(subreq);
893 if (ret == -1) {
894 tevent_req_error(req, sys_errno);
895 return;
896 }
897
898 /*
899 * in message mode we need to hide the length
900 * of the hdr from the caller
901 */
902 if (state->hdr_used) {
903 ret -= sizeof(state->hdr);
904 }
905
906 state->ret = ret;
907
908 tevent_req_done(req);
909 }
910
911 static int tstream_npa_writev_recv(struct tevent_req *req,
912 int *perrno)
913 {
914 struct tstream_npa_writev_state *state = tevent_req_data(req,
915 struct tstream_npa_writev_state);
916 int ret;
917
918 ret = tsocket_simple_int_recv(req, perrno);
919 if (ret == 0) {
920 ret = state->ret;
921 }
922
923 tevent_req_received(req);
924 return ret;
925 }
926
927 struct tstream_npa_disconnect_state {
928 struct tstream_context *stream;
929 };
930
931 static void tstream_npa_disconnect_handler(struct tevent_req *subreq);
932
933 static struct tevent_req *tstream_npa_disconnect_send(TALLOC_CTX *mem_ctx,
934 struct tevent_context *ev,
935 struct tstream_context *stream)
936 {
937 struct tstream_npa *npas = tstream_context_data(stream, struct tstream_npa);
938 struct tevent_req *req;
939 struct tstream_npa_disconnect_state *state;
940 struct tevent_req *subreq;
941
942 req = tevent_req_create(mem_ctx, &state,
943 struct tstream_npa_disconnect_state);
944 if (req == NULL) {
945 return NULL;
946 }
947
948 state->stream = stream;
949
950 if (!npas->unix_stream) {
951 tevent_req_error(req, ENOTCONN);
952 goto post;
953 }
954
955 subreq = tstream_disconnect_send(state,
956 ev,
957 npas->unix_stream);
958 if (tevent_req_nomem(subreq, req)) {
959 goto post;
960 }
961 tevent_req_set_callback(subreq, tstream_npa_disconnect_handler, req);
962
963 return req;
964
965 post:
966 tevent_req_post(req, ev);
967 return req;
968 }
969
970 static void tstream_npa_disconnect_handler(struct tevent_req *subreq)
971 {
972 struct tevent_req *req = tevent_req_callback_data(subreq,
973 struct tevent_req);
974 struct tstream_npa_disconnect_state *state = tevent_req_data(req,
975 struct tstream_npa_disconnect_state);
976 struct tstream_context *stream = state->stream;
977 struct tstream_npa *npas = tstream_context_data(stream, struct tstream_npa);
978 int ret;
979 int sys_errno;
980
981 ret = tstream_disconnect_recv(subreq, &sys_errno);
982 TALLOC_FREE(subreq);
983 if (ret == -1) {
984 tevent_req_error(req, sys_errno);
985 return;
986 }
987
988 TALLOC_FREE(npas->unix_stream);
989
990 tevent_req_done(req);
991 }
992
993 static int tstream_npa_disconnect_recv(struct tevent_req *req,
994 int *perrno)
995 {
996 int ret;
997
998 ret = tsocket_simple_int_recv(req, perrno);
999
1000 tevent_req_received(req);
1001 return ret;
1002 }
1003
1004 static const struct tstream_context_ops tstream_npa_ops = {
1005 .name = "npa",
1006
1007 .pending_bytes = tstream_npa_pending_bytes,
1008
1009 .readv_send = tstream_npa_readv_send,
1010 .readv_recv = tstream_npa_readv_recv,
1011
1012 .writev_send = tstream_npa_writev_send,
1013 .writev_recv = tstream_npa_writev_recv,
1014
1015 .disconnect_send = tstream_npa_disconnect_send,
1016 .disconnect_recv = tstream_npa_disconnect_recv,
1017 };
1018
1019 int _tstream_npa_existing_socket(TALLOC_CTX *mem_ctx,
1020 int fd,
1021 uint16_t file_type,
1022 struct tstream_context **_stream,
1023 const char *location)
1024 {
1025 struct tstream_context *stream;
1026 struct tstream_npa *npas;
1027 int ret;
1028
1029 switch (file_type) {
1030 case FILE_TYPE_BYTE_MODE_PIPE:
1031 break;
1032 case FILE_TYPE_MESSAGE_MODE_PIPE:
1033 break;
1034 default:
1035 errno = EINVAL;
1036 return -1;
1037 }
1038
1039 stream = tstream_context_create(mem_ctx,
1040 &tstream_npa_ops,
1041 &npas,
1042 struct tstream_npa,
1043 location);
1044 if (!stream) {
1045 return -1;
1046 }
1047 ZERO_STRUCTP(npas);
1048
1049 npas->file_type = file_type;
1050
1051 ret = tstream_bsd_existing_socket(stream, fd,
1052 &npas->unix_stream);
1053 if (ret == -1) {
1054 int saved_errno = errno;
1055 talloc_free(stream);
1056 errno = saved_errno;
1057 return -1;
1058 }
1059
1060 *_stream = stream;
1061 return 0;
1062 }
1063
1064
1065 struct tstream_npa_accept_state {
1066 struct tevent_context *ev;
1067 struct tstream_context *plain;
1068 uint16_t file_type;
1069 uint16_t device_state;
1070 uint64_t alloc_size;
1071
1072 DATA_BLOB npa_blob;
1073 struct iovec out_iov;
1074
1075 /* results */
1076 NTSTATUS accept_status;
1077 struct tsocket_address *client;
1078 char *client_name;
1079 struct tsocket_address *server;
1080 char *server_name;
1081 struct auth_session_info_transport *session_info;
1082 };
1083
1084 static int tstream_npa_accept_next_vector(struct tstream_context *unix_stream,
1085 void *private_data,
1086 TALLOC_CTX *mem_ctx,
1087 struct iovec **_vector,
1088 size_t *_count);
1089 static void tstream_npa_accept_existing_reply(struct tevent_req *subreq);
1090 static void tstream_npa_accept_existing_done(struct tevent_req *subreq);
1091
1092 struct tevent_req *tstream_npa_accept_existing_send(TALLOC_CTX *mem_ctx,
1093 struct tevent_context *ev,
1094 struct tstream_context *plain,
1095 uint16_t file_type,
1096 uint16_t device_state,
1097 uint64_t allocation_size)
1098 {
1099 struct tstream_npa_accept_state *state;
1100 struct tevent_req *req, *subreq;
1101
1102 req = tevent_req_create(mem_ctx, &state,
1103 struct tstream_npa_accept_state);
1104 if (req == NULL) {
1105 return NULL;
1106 }
1107
1108 switch (file_type) {
1109 case FILE_TYPE_BYTE_MODE_PIPE:
1110 break;
1111 case FILE_TYPE_MESSAGE_MODE_PIPE:
1112 break;
1113 default:
1114 tevent_req_error(req, EINVAL);
1115 goto post;
1116 }
1117
1118 ZERO_STRUCTP(state);
1119
1120 state->ev = ev;
1121 state->plain = plain;
1122 state->file_type = file_type;
1123 state->device_state = device_state;
1124 state->alloc_size = allocation_size;
1125
1126 /*
1127 * The named pipe pdu's have the length as 8 byte (initial_read_size),
1128 * named_pipe_full_request provides the pdu length then.
1129 */
1130 subreq = tstream_readv_pdu_send(state, ev, plain,
1131 tstream_npa_accept_next_vector,
1132 state);
1133 if (tevent_req_nomem(subreq, req)) {
1134 goto post;
1135 }
1136
1137 tevent_req_set_callback(subreq,
1138 tstream_npa_accept_existing_reply, req);
1139
1140 return req;
1141
1142 post:
1143 tevent_req_post(req, ev);
1144 return req;
1145 }
1146
1147 static int tstream_npa_accept_next_vector(struct tstream_context *unix_stream,
1148 void *private_data,
1149 TALLOC_CTX *mem_ctx,
1150 struct iovec **_vector,
1151 size_t *_count)
1152 {
1153 struct tstream_npa_accept_state *state =
1154 talloc_get_type_abort(private_data,
1155 struct tstream_npa_accept_state);
1156 struct iovec *vector;
1157 size_t count;
1158 off_t ofs = 0;
1159
1160 if (state->npa_blob.length == 0) {
1161 state->npa_blob = data_blob_talloc(state, NULL, 4);
1162 if (!state->npa_blob.data) {
1163 return -1;
1164 }
1165 } else if (state->npa_blob.length == 4) {
1166 uint32_t msg_len;
1167
1168 ofs = 4;
1169
1170 msg_len = RIVAL(state->npa_blob.data, 0);
1171
1172 if (msg_len > 0x00FFFFFF) {
1173 errno = EMSGSIZE;
1174 return -1;
1175 }
1176
1177 if (msg_len == 0) {
1178 errno = EMSGSIZE;
1179 return -1;
1180 }
1181
1182 msg_len += ofs;
1183
1184 state->npa_blob.data = talloc_realloc(state,
1185 state->npa_blob.data,
1186 uint8_t, msg_len);
1187 if (!state->npa_blob.data) {
1188 return -1;
1189 }
1190 state->npa_blob.length = msg_len;
1191 } else {
1192 if (memcmp(&state->npa_blob.data[4],
1193 NAMED_PIPE_AUTH_MAGIC, 4) != 0) {
1194 DEBUG(0, ("Wrong protocol\n"));
1195 #if defined(EPROTONOSUPPORT)
1196 errno = EPROTONOSUPPORT;
1197 #elif defined(EPROTO)
1198 errno = EPROTO;
1199 #else
1200 errno = EINVAL;
1201 #endif
1202 return -1;
1203 }
1204 *_vector = NULL;
1205 *_count = 0;
1206 return 0;
1207 }
1208
1209 /* we need to get a message header */
1210 vector = talloc_array(mem_ctx, struct iovec, 1);
1211 if (!vector) {
1212 return -1;
1213 }
1214 vector[0].iov_base = (char *) (state->npa_blob.data + ofs);
1215 vector[0].iov_len = state->npa_blob.length - ofs;
1216 count = 1;
1217
1218 *_vector = vector;
1219 *_count = count;
1220 return 0;
1221 }
1222
1223 static void tstream_npa_accept_existing_reply(struct tevent_req *subreq)
1224 {
1225 struct tevent_req *req =
1226 tevent_req_callback_data(subreq, struct tevent_req);
1227 struct tstream_npa_accept_state *state =
1228 tevent_req_data(req, struct tstream_npa_accept_state);
1229 struct named_pipe_auth_req *pipe_request;
1230 struct named_pipe_auth_rep pipe_reply;
1231 struct named_pipe_auth_req_info4 i4;
1232 enum ndr_err_code ndr_err;
1233 DATA_BLOB out;
1234 int sys_errno;
1235 int ret;
1236
1237 ret = tstream_readv_pdu_recv(subreq, &sys_errno);
1238 TALLOC_FREE(subreq);
1239 if (ret == -1) {
1240 tevent_req_error(req, sys_errno);
1241 return;
1242 }
1243
1244 DEBUG(10, ("Received packet of length %lu\n",
1245 (long)state->npa_blob.length));
1246 dump_data(11, state->npa_blob.data, state->npa_blob.length);
1247
1248 ZERO_STRUCT(pipe_reply);
1249 pipe_reply.level = 0;
1250 pipe_reply.status = NT_STATUS_INTERNAL_ERROR;
1251 /*
1252 * TODO: check it's a root (uid == 0) pipe
1253 */
1254
1255 pipe_request = talloc(state, struct named_pipe_auth_req);
1256 if (!pipe_request) {
1257 DEBUG(0, ("Out of memory!\n"));
1258 goto reply;
1259 }
1260
1261 /* parse the passed credentials */
1262 ndr_err = ndr_pull_struct_blob_all(
1263 &state->npa_blob, pipe_request, pipe_request,
1264 (ndr_pull_flags_fn_t)ndr_pull_named_pipe_auth_req);
1265 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1266 pipe_reply.status = ndr_map_error2ntstatus(ndr_err);
1267 DEBUG(2, ("Could not unmarshall named_pipe_auth_req: %s\n",
1268 nt_errstr(pipe_reply.status)));
1269 goto reply;
1270 }
1271
1272 if (DEBUGLVL(10)) {
1273 NDR_PRINT_DEBUG(named_pipe_auth_req, pipe_request);
1274 }
1275
1276 ZERO_STRUCT(i4);
1277
1278 if (pipe_request->level != 4) {
1279 DEBUG(0, ("Unknown level %u\n", pipe_request->level));
1280 pipe_reply.level = 0;
1281 pipe_reply.status = NT_STATUS_INVALID_LEVEL;
1282 goto reply;
1283 }
1284
1285 pipe_reply.level = 4;
1286 pipe_reply.status = NT_STATUS_OK;
1287 pipe_reply.info.info4.file_type = state->file_type;
1288 pipe_reply.info.info4.device_state = state->device_state;
1289 pipe_reply.info.info4.allocation_size = state->alloc_size;
1290
1291 i4 = pipe_request->info.info4;
1292 if (i4.server_addr == NULL) {
1293 pipe_reply.status = NT_STATUS_INVALID_ADDRESS;
1294 DEBUG(2, ("Missing server address\n"));
1295 goto reply;
1296 }
1297 if (i4.client_addr == NULL) {
1298 pipe_reply.status = NT_STATUS_INVALID_ADDRESS;
1299 DEBUG(2, ("Missing client address\n"));
1300 goto reply;
1301 }
1302
1303 state->server_name = discard_const_p(char,
1304 talloc_move(state, &i4.server_name));
1305 ret = tsocket_address_inet_from_strings(state, "ip",
1306 i4.server_addr,
1307 i4.server_port,
1308 &state->server);
1309 if (ret != 0) {
1310 DEBUG(2, ("Invalid server address[%s:%u] - %s\n",
1311 i4.server_addr, i4.server_port,
1312 strerror(errno)));
1313 pipe_reply.status = NT_STATUS_INVALID_ADDRESS;
1314 goto reply;
1315 }
1316
1317 state->client_name = discard_const_p(char,
1318 talloc_move(state, &i4.client_name));
1319 ret = tsocket_address_inet_from_strings(state, "ip",
1320 i4.client_addr,
1321 i4.client_port,
1322 &state->client);
1323 if (ret != 0) {
1324 DEBUG(2, ("Invalid server address[%s:%u] - %s\n",
1325 i4.client_addr, i4.client_port,
1326 strerror(errno)));
1327 pipe_reply.status = NT_STATUS_INVALID_ADDRESS;
1328 goto reply;
1329 }
1330
1331 state->session_info = talloc_move(state, &i4.session_info);
1332 reply:
1333 /* create the output */
1334 ndr_err = ndr_push_struct_blob(&out, state, &pipe_reply,
1335 (ndr_push_flags_fn_t)ndr_push_named_pipe_auth_rep);
1336 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1337 DEBUG(2, ("Error encoding structure: %s",
1338 ndr_map_error2string(ndr_err)));
1339 tevent_req_error(req, EIO);
1340 return;
1341 }
1342
1343 DEBUG(10, ("named_pipe_auth reply[%u]\n", (unsigned)out.length));
1344 dump_data(11, out.data, out.length);
1345
1346 if (DEBUGLVL(10)) {
1347 NDR_PRINT_DEBUG(named_pipe_auth_rep, &pipe_reply);
1348 }
1349
1350 state->accept_status = pipe_reply.status;
1351
1352 state->out_iov.iov_base = (char *) out.data;
1353 state->out_iov.iov_len = out.length;
1354
1355 subreq = tstream_writev_send(state, state->ev,
1356 state->plain,
1357 &state->out_iov, 1);
1358 if (tevent_req_nomem(subreq, req)) {
1359 DEBUG(0, ("no memory for tstream_writev_send"));
1360 return;
1361 }
1362
1363 tevent_req_set_callback(subreq, tstream_npa_accept_existing_done, req);
1364 }
1365
1366 static void tstream_npa_accept_existing_done(struct tevent_req *subreq)
1367 {
1368 struct tevent_req *req =
1369 tevent_req_callback_data(subreq, struct tevent_req);
1370 int sys_errno;
1371 int ret;
1372
1373 ret = tstream_writev_recv(subreq, &sys_errno);
1374 TALLOC_FREE(subreq);
1375 if (ret == -1) {
1376 tevent_req_error(req, sys_errno);
1377 return;
1378 }
1379
1380 tevent_req_done(req);
1381 }
1382
1383 int _tstream_npa_accept_existing_recv(struct tevent_req *req,
1384 int *perrno,
1385 TALLOC_CTX *mem_ctx,
1386 struct tstream_context **stream,
1387 struct tsocket_address **client,
1388 char **_client_name,
1389 struct tsocket_address **server,
1390 char **server_name,
1391 struct auth_session_info_transport **session_info,
1392 const char *location)
1393 {
1394 struct tstream_npa_accept_state *state =
1395 tevent_req_data(req, struct tstream_npa_accept_state);
1396 struct tstream_npa *npas;
1397 int ret;
1398
1399 ret = tsocket_simple_int_recv(req, perrno);
1400 if (ret != 0) {
1401 DEBUG(2, ("Failed to accept named pipe conection: %s\n",
1402 strerror(*perrno)));
1403 tevent_req_received(req);
1404 return -1;
1405 }
1406
1407 if (!NT_STATUS_IS_OK(state->accept_status)) {
1408 #if defined(EPROTONOSUPPORT)
1409 *perrno = EPROTONOSUPPORT;
1410 #elif defined(EPROTO)
1411 *perrno = EPROTO;
1412 #else
1413 *perrno = EINVAL;
1414 #endif
1415 DEBUG(2, ("Failed to accept named pipe conection: %s => %s\n",
1416 nt_errstr(state->accept_status),
1417 strerror(*perrno)));
1418 tevent_req_received(req);
1419 return -1;
1420 }
1421
1422 *stream = tstream_context_create(mem_ctx,
1423 &tstream_npa_ops,
1424 &npas,
1425 struct tstream_npa,
1426 location);
1427 if (!*stream) {
1428 *perrno = ENOMEM;
1429 tevent_req_received(req);
1430 return -1;
1431 }
1432 ZERO_STRUCTP(npas);
1433 npas->unix_stream = state->plain;
1434 npas->file_type = state->file_type;
1435
1436 *client = talloc_move(mem_ctx, &state->client);
1437 *_client_name = talloc_move(mem_ctx, &state->client_name);
1438 *server = talloc_move(mem_ctx, &state->server);
1439 *server_name = talloc_move(mem_ctx, &state->server_name);
1440 *session_info = talloc_move(mem_ctx, &state->session_info);
1441
1442 tevent_req_received(req);
1443 return 0;
1444 }
reg import