nsswitch: Move nss_err_str to its only caller
[ira/wip.git] / libcli / util / 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 <tevent.h>
22 #include "system/filesys.h"
23 #include "../lib/tsocket/tsocket.h"
24 #include "../libcli/util/tstream.h"
25 #include "../lib/util/tevent_ntstatus.h"
26
27 struct tstream_read_pdu_blob_state {
28         /* this structs are owned by the caller */
29         struct {
30                 struct tevent_context *ev;
31                 struct tstream_context *stream;
32                 NTSTATUS (*full_fn)(void *private_data,
33                                     DATA_BLOB blob,
34                                     size_t *packet_size);
35                 void *full_private;
36         } caller;
37
38         DATA_BLOB pdu_blob;
39         struct iovec tmp_vector;
40 };
41
42 static void tstream_read_pdu_blob_done(struct tevent_req *subreq);
43
44 struct tevent_req *tstream_read_pdu_blob_send(TALLOC_CTX *mem_ctx,
45                                 struct tevent_context *ev,
46                                 struct tstream_context *stream,
47                                 size_t initial_read_size,
48                                 NTSTATUS (*full_fn)(void *private_data,
49                                                     DATA_BLOB blob,
50                                                     size_t *packet_size),
51                                 void *full_private)
52 {
53         struct tevent_req *req;
54         struct tstream_read_pdu_blob_state *state;
55         struct tevent_req *subreq;
56         uint8_t *buf;
57
58         req = tevent_req_create(mem_ctx, &state,
59                                 struct tstream_read_pdu_blob_state);
60         if (!req) {
61                 return NULL;
62         }
63
64         state->caller.ev                = ev;
65         state->caller.stream            = stream;
66         state->caller.full_fn           = full_fn;
67         state->caller.full_private      = full_private;
68
69         if (initial_read_size == 0) {
70                 tevent_req_error(req, EINVAL);
71                 return tevent_req_post(req, ev);
72         }
73
74         buf = talloc_array(state, uint8_t, initial_read_size);
75         if (tevent_req_nomem(buf, req)) {
76                 return tevent_req_post(req, ev);
77         }
78         state->pdu_blob.data = buf;
79         state->pdu_blob.length = initial_read_size;
80
81         state->tmp_vector.iov_base = buf;
82         state->tmp_vector.iov_len = initial_read_size;
83
84         subreq = tstream_readv_send(state, ev, stream, &state->tmp_vector, 1);
85         if (tevent_req_nomem(subreq, req)) {
86                 return tevent_req_post(req, ev);
87         }
88         tevent_req_set_callback(subreq, tstream_read_pdu_blob_done, req);
89
90         return req;
91 }
92
93 static void tstream_read_pdu_blob_done(struct tevent_req *subreq)
94 {
95         struct tevent_req *req =
96                 tevent_req_callback_data(subreq,
97                 struct tevent_req);
98         struct tstream_read_pdu_blob_state *state =
99                 tevent_req_data(req,
100                 struct tstream_read_pdu_blob_state);
101         ssize_t ret;
102         int sys_errno;
103         size_t pdu_size;
104         NTSTATUS status;
105         uint8_t *buf;
106
107         ret = tstream_readv_recv(subreq, &sys_errno);
108         TALLOC_FREE(subreq);
109         if (ret == -1) {
110                 status = map_nt_error_from_unix(sys_errno);
111                 tevent_req_nterror(req, status);
112                 return;
113         }
114
115         status = state->caller.full_fn(state->caller.full_private,
116                                        state->pdu_blob, &pdu_size);
117         if (NT_STATUS_IS_OK(status)) {
118                 tevent_req_done(req);
119                 return;
120         } else if (NT_STATUS_EQUAL(status, STATUS_MORE_ENTRIES)) {
121                 /* more to get */
122         } else if (!NT_STATUS_IS_OK(status)) {
123                 tevent_req_nterror(req, status);
124                 return;
125         }
126
127         buf = talloc_realloc(state, state->pdu_blob.data, uint8_t, pdu_size);
128         if (tevent_req_nomem(buf, req)) {
129                 return;
130         }
131         state->pdu_blob.data = buf;
132         state->pdu_blob.length = pdu_size;
133
134         state->tmp_vector.iov_base = buf + state->tmp_vector.iov_len;
135         state->tmp_vector.iov_len = pdu_size - state->tmp_vector.iov_len;
136
137         subreq = tstream_readv_send(state,
138                                     state->caller.ev,
139                                     state->caller.stream,
140                                     &state->tmp_vector,
141                                     1);
142         if (tevent_req_nomem(subreq, req)) {
143                 return;
144         }
145         tevent_req_set_callback(subreq, tstream_read_pdu_blob_done, req);
146 }
147
148 NTSTATUS tstream_read_pdu_blob_recv(struct tevent_req *req,
149                                     TALLOC_CTX *mem_ctx,
150                                     DATA_BLOB *pdu_blob)
151 {
152         struct tstream_read_pdu_blob_state *state = tevent_req_data(req,
153                                         struct tstream_read_pdu_blob_state);
154         NTSTATUS status;
155
156         if (tevent_req_is_nterror(req, &status)) {
157                 tevent_req_received(req);
158                 return status;
159         }
160
161         *pdu_blob = state->pdu_blob;
162         talloc_steal(mem_ctx, pdu_blob->data);
163
164         tevent_req_received(req);
165         return NT_STATUS_OK;
166 }
167