57e841860ce45760fc9e7b331ab48c40e7179cca
[ira/wip.git] / libcli / named_pipe_auth / npa_tstream.c
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
463         return ret;
464 }
465
466 struct tstream_npa_readv_state {
467         struct tstream_context *stream;
468
469         struct iovec *vector;
470         size_t count;
471
472         /* the header for message mode */
473         uint8_t hdr[2];
474         bool wait_for_hdr;
475
476         int ret;
477 };
478
479 static void tstream_npa_readv_byte_mode_handler(struct tevent_req *subreq);
480 static int tstream_npa_readv_next_vector(struct tstream_context *stream,
481                                          void *private_data,
482                                          TALLOC_CTX *mem_ctx,
483                                          struct iovec **_vector,
484                                          size_t *_count);
485 static void tstream_npa_readv_msg_mode_handler(struct tevent_req *subreq);
486
487 static struct tevent_req *tstream_npa_readv_send(TALLOC_CTX *mem_ctx,
488                                         struct tevent_context *ev,
489                                         struct tstream_context *stream,
490                                         struct iovec *vector,
491                                         size_t count)
492 {
493         struct tevent_req *req;
494         struct tstream_npa_readv_state *state;
495         struct tstream_npa *npas = tstream_context_data(stream, struct tstream_npa);
496         struct tevent_req *subreq;
497         off_t ofs;
498         size_t left;
499         uint8_t *pbase;
500
501         req = tevent_req_create(mem_ctx, &state,
502                                 struct tstream_npa_readv_state);
503         if (!req) {
504                 return NULL;
505         }
506
507         state->stream   = stream;
508         state->ret      = 0;
509
510         if (!npas->unix_stream) {
511                 tevent_req_error(req, ENOTCONN);
512                 goto post;
513         }
514
515         switch (npas->file_type) {
516         case FILE_TYPE_BYTE_MODE_PIPE:
517                 state->vector = vector;
518                 state->count = count;
519
520                 subreq = tstream_readv_send(state,
521                                             ev,
522                                             npas->unix_stream,
523                                             state->vector,
524                                             state->count);
525                 if (tevent_req_nomem(subreq,req)) {
526                         goto post;
527                 }
528                 tevent_req_set_callback(subreq,
529                                         tstream_npa_readv_byte_mode_handler,
530                                         req);
531
532                 return req;
533
534         case FILE_TYPE_MESSAGE_MODE_PIPE:
535                 /*
536                  * we make a copy of the vector and prepend a header
537                  * with the length
538                  */
539                 state->vector   = talloc_array(state, struct iovec, count);
540                 if (tevent_req_nomem(state->vector, req)) {
541                         goto post;
542                 }
543                 memcpy(state->vector, vector, sizeof(struct iovec)*count);
544                 state->count = count;
545
546                 /*
547                  * copy the pending buffer first
548                  */
549                 ofs = 0;
550                 left = npas->pending.iov_len;
551                 pbase = (uint8_t *)npas->pending.iov_base;
552
553                 while (left > 0 && state->count > 0) {
554                         uint8_t *base;
555                         base = (uint8_t *)state->vector[0].iov_base;
556                         if (left < state->vector[0].iov_len) {
557                                 memcpy(base, pbase + ofs, left);
558
559                                 base += left;
560                                 state->vector[0].iov_base = base;
561                                 state->vector[0].iov_len -= left;
562
563                                 ofs += left;
564                                 left = 0;
565                                 TALLOC_FREE(pbase);
566                                 ZERO_STRUCT(npas->pending);
567                                 break;
568                         }
569                         memcpy(base, pbase + ofs, state->vector[0].iov_len);
570
571                         ofs += state->vector[0].iov_len;
572                         left -= state->vector[0].iov_len;
573                         state->vector += 1;
574                         state->count -= 1;
575
576                         if (left == 0) {
577                                 TALLOC_FREE(pbase);
578                                 ZERO_STRUCT(npas->pending);
579                                 break;
580                         }
581                 }
582
583                 if (left > 0) {
584                         memmove(pbase, pbase + ofs, left);
585                         npas->pending.iov_base = pbase;
586                         npas->pending.iov_len = left;
587                         /*
588                          * this cannot fail and even if it
589                          * fails we can handle it
590                          */
591                         pbase = talloc_realloc(npas, pbase, uint8_t, left);
592                         if (pbase) {
593                                 npas->pending.iov_base = pbase;
594                         }
595                         pbase = NULL;
596                 }
597
598                 state->ret += ofs;
599
600                 if (state->count == 0) {
601                         tevent_req_done(req);
602                         goto post;
603                 }
604
605                 ZERO_STRUCT(state->hdr);
606                 state->wait_for_hdr = false;
607
608                 subreq = tstream_readv_pdu_send(state,
609                                                 ev,
610                                                 npas->unix_stream,
611                                                 tstream_npa_readv_next_vector,
612                                                 state);
613                 if (tevent_req_nomem(subreq, req)) {
614                         goto post;
615                 }
616                 tevent_req_set_callback(subreq,
617                                         tstream_npa_readv_msg_mode_handler,
618                                         req);
619
620                 return req;
621         }
622
623         /* this can't happen */
624         tevent_req_error(req, EINVAL);
625         goto post;
626
627  post:
628         tevent_req_post(req, ev);
629         return req;
630 }
631
632 static void tstream_npa_readv_byte_mode_handler(struct tevent_req *subreq)
633 {
634         struct tevent_req *req = tevent_req_callback_data(subreq,
635                                  struct tevent_req);
636         struct tstream_npa_readv_state *state = tevent_req_data(req,
637                                         struct tstream_npa_readv_state);
638         int ret;
639         int sys_errno;
640
641         ret = tstream_readv_recv(subreq, &sys_errno);
642         TALLOC_FREE(subreq);
643         if (ret == -1) {
644                 tevent_req_error(req, sys_errno);
645                 return;
646         }
647
648         state->ret = ret;
649
650         tevent_req_done(req);
651 }
652
653 static int tstream_npa_readv_next_vector(struct tstream_context *unix_stream,
654                                          void *private_data,
655                                          TALLOC_CTX *mem_ctx,
656                                          struct iovec **_vector,
657                                          size_t *_count)
658 {
659         struct tstream_npa_readv_state *state = talloc_get_type_abort(private_data,
660                                         struct tstream_npa_readv_state);
661         struct tstream_npa *npas = tstream_context_data(state->stream,
662                                    struct tstream_npa);
663         struct iovec *vector;
664         size_t count;
665         uint16_t msg_len;
666         size_t left;
667
668         if (state->count == 0) {
669                 *_vector = NULL;
670                 *_count = 0;
671                 return 0;
672         }
673
674         if (!state->wait_for_hdr) {
675                 /* we need to get a message header */
676                 vector = talloc_array(mem_ctx, struct iovec, 1);
677                 if (!vector) {
678                         return -1;
679                 }
680                 ZERO_STRUCT(state->hdr);
681                 vector[0].iov_base = state->hdr;
682                 vector[0].iov_len = sizeof(state->hdr);
683
684                 count = 1;
685
686                 state->wait_for_hdr = true;
687
688                 *_vector = vector;
689                 *_count = count;
690                 return 0;
691         }
692
693         /* and now fill the callers buffers and maybe the pending buffer */
694         state->wait_for_hdr = false;
695
696         msg_len = SVAL(state->hdr, 0);
697
698         if (msg_len == 0) {
699                 errno = EIO;
700                 return -1;
701         }
702
703         state->wait_for_hdr = false;
704
705         /* +1 because we may need to fill the pending buffer */
706         vector = talloc_array(mem_ctx, struct iovec, state->count + 1);
707         if (!vector) {
708                 return -1;
709         }
710
711         count = 0;
712         left = msg_len;
713         while (left > 0 && state->count > 0) {
714                 if (left < state->vector[0].iov_len) {
715                         uint8_t *base;
716                         base = (uint8_t *)state->vector[0].iov_base;
717                         vector[count].iov_base = base;
718                         vector[count].iov_len = left;
719                         count++;
720                         base += left;
721                         state->vector[0].iov_base = base;
722                         state->vector[0].iov_len -= left;
723                         break;
724                 }
725                 vector[count] = state->vector[0];
726                 count++;
727                 left -= state->vector[0].iov_len;
728                 state->vector += 1;
729                 state->count -= 1;
730         }
731
732         if (left > 0) {
733                 /*
734                  * if the message if longer than the buffers the caller
735                  * requested, we need to consume the rest of the message
736                  * into the pending buffer, where the next readv can
737                  * be served from.
738                  */
739                 npas->pending.iov_base = talloc_array(npas, uint8_t, left);
740                 if (!npas->pending.iov_base) {
741                         return -1;
742                 }
743                 npas->pending.iov_len = left;
744
745                 vector[count] = npas->pending;
746                 count++;
747         }
748
749         state->ret += (msg_len - left);
750
751         *_vector = vector;
752         *_count = count;
753         return 0;
754 }
755
756 static void tstream_npa_readv_msg_mode_handler(struct tevent_req *subreq)
757 {
758         struct tevent_req *req = tevent_req_callback_data(subreq,
759                                  struct tevent_req);
760         int ret;
761         int sys_errno;
762
763         ret = tstream_readv_pdu_recv(subreq, &sys_errno);
764         TALLOC_FREE(subreq);
765         if (ret == -1) {
766                 tevent_req_error(req, sys_errno);
767                 return;
768         }
769
770         /*
771          * we do not set state->ret here as ret includes the headr size.
772          * we set it in tstream_npa_readv_pdu_next_vector()
773          */
774
775         tevent_req_done(req);
776 }
777
778 static int tstream_npa_readv_recv(struct tevent_req *req,
779                                    int *perrno)
780 {
781         struct tstream_npa_readv_state *state = tevent_req_data(req,
782                                         struct tstream_npa_readv_state);
783         int ret;
784
785         ret = tsocket_simple_int_recv(req, perrno);
786         if (ret == 0) {
787                 ret = state->ret;
788         }
789
790         tevent_req_received(req);
791         return ret;
792 }
793
794 struct tstream_npa_writev_state {
795         const struct iovec *vector;
796         size_t count;
797
798         /* the header for message mode */
799         uint8_t hdr[2];
800
801         int ret;
802 };
803
804 static void tstream_npa_writev_handler(struct tevent_req *subreq);
805
806 static struct tevent_req *tstream_npa_writev_send(TALLOC_CTX *mem_ctx,
807                                         struct tevent_context *ev,
808                                         struct tstream_context *stream,
809                                         const struct iovec *vector,
810                                         size_t count)
811 {
812         struct tevent_req *req;
813         struct tstream_npa_writev_state *state;
814         struct tstream_npa *npas = tstream_context_data(stream, struct tstream_npa);
815         struct tevent_req *subreq;
816         size_t msg_len;
817         size_t i;
818         struct iovec *new_vector;
819
820         req = tevent_req_create(mem_ctx, &state,
821                                 struct tstream_npa_writev_state);
822         if (!req) {
823                 return NULL;
824         }
825
826         state->ret      = 0;
827
828         if (!npas->unix_stream) {
829                 tevent_req_error(req, ENOTCONN);
830                 goto post;
831         }
832
833         switch (npas->file_type) {
834         case FILE_TYPE_BYTE_MODE_PIPE:
835                 state->vector   = vector;
836                 state->count    = count;
837                 break;
838
839         case FILE_TYPE_MESSAGE_MODE_PIPE:
840                 /*
841                  * we make a copy of the vector and prepend a header
842                  * with the length
843                  */
844                 new_vector      = talloc_array(state, struct iovec, count + 1);
845                 if (tevent_req_nomem(new_vector, req)) {
846                         goto post;
847                 }
848                 new_vector[0].iov_base = state->hdr;
849                 new_vector[0].iov_len = sizeof(state->hdr);
850                 memcpy(new_vector + 1, vector, sizeof(struct iovec)*count);
851
852                 state->vector   = new_vector;
853                 state->count    = count + 1;
854
855                 msg_len = 0;
856                 for (i=0; i < count; i++) {
857                         msg_len += vector[i].iov_len;
858                 }
859
860                 if (msg_len > UINT16_MAX) {
861                         tevent_req_error(req, EMSGSIZE);
862                         goto post;
863                 }
864
865                 SSVAL(state->hdr, 0, msg_len);
866                 break;
867         }
868
869         subreq = tstream_writev_send(state,
870                                      ev,
871                                      npas->unix_stream,
872                                      state->vector,
873                                      state->count);
874         if (tevent_req_nomem(subreq, req)) {
875                 goto post;
876         }
877         tevent_req_set_callback(subreq, tstream_npa_writev_handler, req);
878
879         return req;
880
881  post:
882         tevent_req_post(req, ev);
883         return req;
884 }
885
886 static void tstream_npa_writev_handler(struct tevent_req *subreq)
887 {
888         struct tevent_req *req = tevent_req_callback_data(subreq,
889                                  struct tevent_req);
890         struct tstream_npa_writev_state *state = tevent_req_data(req,
891                                         struct tstream_npa_writev_state);
892         int ret;
893         int sys_errno;
894
895         ret = tstream_writev_recv(subreq, &sys_errno);
896         TALLOC_FREE(subreq);
897         if (ret == -1) {
898                 tevent_req_error(req, sys_errno);
899                 return;
900         }
901
902         state->ret = ret;
903
904         tevent_req_done(req);
905 }
906
907 static int tstream_npa_writev_recv(struct tevent_req *req,
908                                    int *perrno)
909 {
910         struct tstream_npa_writev_state *state = tevent_req_data(req,
911                                         struct tstream_npa_writev_state);
912         int ret;
913
914         ret = tsocket_simple_int_recv(req, perrno);
915         if (ret == 0) {
916                 ret = state->ret;
917         }
918
919         tevent_req_received(req);
920         return ret;
921 }
922
923 struct tstream_npa_disconnect_state {
924         struct tstream_context *stream;
925 };
926
927 static void tstream_npa_disconnect_handler(struct tevent_req *subreq);
928
929 static struct tevent_req *tstream_npa_disconnect_send(TALLOC_CTX *mem_ctx,
930                                                 struct tevent_context *ev,
931                                                 struct tstream_context *stream)
932 {
933         struct tstream_npa *npas = tstream_context_data(stream, struct tstream_npa);
934         struct tevent_req *req;
935         struct tstream_npa_disconnect_state *state;
936         struct tevent_req *subreq;
937
938         req = tevent_req_create(mem_ctx, &state,
939                                 struct tstream_npa_disconnect_state);
940         if (req == NULL) {
941                 return NULL;
942         }
943
944         state->stream = stream;
945
946         if (!npas->unix_stream) {
947                 tevent_req_error(req, ENOTCONN);
948                 goto post;
949         }
950
951         subreq = tstream_disconnect_send(state,
952                                          ev,
953                                          npas->unix_stream);
954         if (tevent_req_nomem(subreq, req)) {
955                 goto post;
956         }
957         tevent_req_set_callback(subreq, tstream_npa_disconnect_handler, req);
958
959         return req;
960
961 post:
962         tevent_req_post(req, ev);
963         return req;
964 }
965
966 static void tstream_npa_disconnect_handler(struct tevent_req *subreq)
967 {
968         struct tevent_req *req = tevent_req_callback_data(subreq,
969                                  struct tevent_req);
970         struct tstream_npa_disconnect_state *state = tevent_req_data(req,
971                                         struct tstream_npa_disconnect_state);
972         struct tstream_context *stream = state->stream;
973         struct tstream_npa *npas = tstream_context_data(stream, struct tstream_npa);
974         int ret;
975         int sys_errno;
976
977         ret = tstream_disconnect_recv(subreq, &sys_errno);
978         TALLOC_FREE(subreq);
979         if (ret == -1) {
980                 tevent_req_error(req, sys_errno);
981                 return;
982         }
983
984         TALLOC_FREE(npas->unix_stream);
985
986         tevent_req_done(req);
987 }
988
989 static int tstream_npa_disconnect_recv(struct tevent_req *req,
990                                        int *perrno)
991 {
992         int ret;
993
994         ret = tsocket_simple_int_recv(req, perrno);
995
996         tevent_req_received(req);
997         return ret;
998 }
999
1000 static const struct tstream_context_ops tstream_npa_ops = {
1001         .name                   = "npa",
1002
1003         .pending_bytes          = tstream_npa_pending_bytes,
1004
1005         .readv_send             = tstream_npa_readv_send,
1006         .readv_recv             = tstream_npa_readv_recv,
1007
1008         .writev_send            = tstream_npa_writev_send,
1009         .writev_recv            = tstream_npa_writev_recv,
1010
1011         .disconnect_send        = tstream_npa_disconnect_send,
1012         .disconnect_recv        = tstream_npa_disconnect_recv,
1013 };
1014
1015 int _tstream_npa_existing_socket(TALLOC_CTX *mem_ctx,
1016                                  int fd,
1017                                  uint16_t file_type,
1018                                  struct tstream_context **_stream,
1019                                  const char *location)
1020 {
1021         struct tstream_context *stream;
1022         struct tstream_npa *npas;
1023         int ret;
1024
1025         switch (file_type) {
1026         case FILE_TYPE_BYTE_MODE_PIPE:
1027                 break;
1028         case FILE_TYPE_MESSAGE_MODE_PIPE:
1029                 break;
1030         default:
1031                 errno = EINVAL;
1032                 return -1;
1033         }
1034
1035         stream = tstream_context_create(mem_ctx,
1036                                         &tstream_npa_ops,
1037                                         &npas,
1038                                         struct tstream_npa,
1039                                         location);
1040         if (!stream) {
1041                 return -1;
1042         }
1043         ZERO_STRUCTP(npas);
1044
1045         npas->file_type = file_type;
1046
1047         ret = tstream_bsd_existing_socket(stream, fd,
1048                                           &npas->unix_stream);
1049         if (ret == -1) {
1050                 int saved_errno = errno;
1051                 talloc_free(stream);
1052                 errno = saved_errno;
1053                 return -1;
1054         }
1055
1056         *_stream = stream;
1057         return 0;
1058 }
1059