Convert wb_resp_read to tevent_req
[ira/wip.git] / source3 / lib / wb_reqtrans.c
1 /*
2    Unix SMB/CIFS implementation.
3
4    Async transfer of winbindd_request and _response structs
5
6    Copyright (C) Volker Lendecke 2008
7
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 3 of the License, or
11    (at your option) any later version.
12
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17
18    You should have received a copy of the GNU General Public License
19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
20 */
21
22 #include "includes.h"
23 #include "wbc_async.h"
24
25 #undef DBGC_CLASS
26 #define DBGC_CLASS DBGC_WINBIND
27
28 struct req_read_state {
29         struct winbindd_request *wb_req;
30         size_t max_extra_data;
31 };
32
33 bool async_req_is_wbcerr(struct async_req *req, wbcErr *pwbc_err)
34 {
35         enum async_req_state state;
36         uint64_t error;
37         if (!async_req_is_error(req, &state, &error)) {
38                 *pwbc_err = WBC_ERR_SUCCESS;
39                 return false;
40         }
41
42         switch (state) {
43         case ASYNC_REQ_USER_ERROR:
44                 *pwbc_err = error;
45                 break;
46         case ASYNC_REQ_TIMED_OUT:
47                 *pwbc_err = WBC_ERR_UNKNOWN_FAILURE;
48                 break;
49         case ASYNC_REQ_NO_MEMORY:
50                 *pwbc_err = WBC_ERR_NO_MEMORY;
51                 break;
52         default:
53                 *pwbc_err = WBC_ERR_UNKNOWN_FAILURE;
54                 break;
55         }
56         return true;
57 }
58
59 wbcErr map_wbc_err_from_errno(int error)
60 {
61         switch(error) {
62         case EPERM:
63         case EACCES:
64                 return WBC_ERR_AUTH_ERROR;
65         case ENOMEM:
66                 return WBC_ERR_NO_MEMORY;
67         case EIO:
68         default:
69                 return WBC_ERR_UNKNOWN_FAILURE;
70         }
71 }
72
73 wbcErr async_req_simple_recv_wbcerr(struct async_req *req)
74 {
75         wbcErr wbc_err;
76
77         if (async_req_is_wbcerr(req, &wbc_err)) {
78                 return wbc_err;
79         }
80
81         return WBC_ERR_SUCCESS;
82 }
83
84 bool tevent_req_is_wbcerr(struct tevent_req *req, wbcErr *pwbc_err)
85 {
86         enum tevent_req_state state;
87         uint64_t error;
88         if (!tevent_req_is_error(req, &state, &error)) {
89                 *pwbc_err = WBC_ERR_SUCCESS;
90                 return false;
91         }
92
93         switch (state) {
94         case TEVENT_REQ_USER_ERROR:
95                 *pwbc_err = error;
96                 break;
97         case TEVENT_REQ_TIMED_OUT:
98                 *pwbc_err = WBC_ERR_UNKNOWN_FAILURE;
99                 break;
100         case TEVENT_REQ_NO_MEMORY:
101                 *pwbc_err = WBC_ERR_NO_MEMORY;
102                 break;
103         default:
104                 *pwbc_err = WBC_ERR_UNKNOWN_FAILURE;
105                 break;
106         }
107         return true;
108 }
109
110 wbcErr tevent_req_simple_recv_wbcerr(struct tevent_req *req)
111 {
112         wbcErr wbc_err;
113
114         if (tevent_req_is_wbcerr(req, &wbc_err)) {
115                 return wbc_err;
116         }
117
118         return WBC_ERR_SUCCESS;
119 }
120
121 static ssize_t wb_req_more(uint8_t *buf, size_t buflen, void *private_data);
122 static void wb_req_read_done(struct tevent_req *subreq);
123
124 struct tevent_req *wb_req_read_send(TALLOC_CTX *mem_ctx,
125                                     struct tevent_context *ev,
126                                     int fd, size_t max_extra_data)
127 {
128         struct tevent_req *result, *subreq;
129         struct req_read_state *state;
130
131         result = tevent_req_create(mem_ctx, &state, struct req_read_state);
132         if (result == NULL) {
133                 return NULL;
134         }
135         state->max_extra_data = max_extra_data;
136
137         subreq = read_packet_send(state, ev, fd, 4, wb_req_more, state);
138         if (subreq == NULL) {
139                 goto nomem;
140         }
141
142         tevent_req_set_callback(subreq, wb_req_read_done, result);
143         return result;
144  nomem:
145         TALLOC_FREE(result);
146         return NULL;
147 }
148
149 static ssize_t wb_req_more(uint8_t *buf, size_t buflen, void *private_data)
150 {
151         struct req_read_state *state = talloc_get_type_abort(
152                 private_data, struct req_read_state);
153         struct winbindd_request *req = (struct winbindd_request *)buf;
154
155         if (buflen == 4) {
156                 if (req->length != sizeof(struct winbindd_request)) {
157                         DEBUG(0, ("wb_req_read_len: Invalid request size "
158                                   "received: %d (expected %d)\n",
159                                   (int)req->length,
160                                   (int)sizeof(struct winbindd_request)));
161                         return -1;
162                 }
163                 return sizeof(struct winbindd_request) - 4;
164         }
165
166         if ((state->max_extra_data != 0)
167             && (req->extra_len > state->max_extra_data)) {
168                 DEBUG(3, ("Got request with %d bytes extra data on "
169                           "unprivileged socket\n", (int)req->extra_len));
170                 return -1;
171         }
172
173         return req->extra_len;
174 }
175
176 static void wb_req_read_done(struct tevent_req *subreq)
177 {
178         struct tevent_req *req = tevent_req_callback_data(
179                 subreq, struct tevent_req);
180         struct req_read_state *state = tevent_req_data(
181                 req, struct req_read_state);
182         int err;
183         ssize_t ret;
184         uint8_t *buf;
185
186         ret = read_packet_recv(subreq, state, &buf, &err);
187         TALLOC_FREE(subreq);
188         if (ret == -1) {
189                 tevent_req_error(req, map_wbc_err_from_errno(err));
190                 return;
191         }
192
193         state->wb_req = (struct winbindd_request *)buf;
194
195         if (state->wb_req->extra_len != 0) {
196                 state->wb_req->extra_data.data =
197                         (char *)buf + sizeof(struct winbindd_request);
198         } else {
199                 state->wb_req->extra_data.data = NULL;
200         }
201         tevent_req_done(req);
202 }
203
204 wbcErr wb_req_read_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
205                         struct winbindd_request **preq)
206 {
207         struct req_read_state *state = tevent_req_data(
208                 req, struct req_read_state);
209         wbcErr wbc_err;
210
211         if (tevent_req_is_wbcerr(req, &wbc_err)) {
212                 return wbc_err;
213         }
214         *preq = talloc_move(mem_ctx, &state->wb_req);
215         return WBC_ERR_SUCCESS;
216 }
217
218 struct req_write_state {
219         struct iovec iov[2];
220 };
221
222 static void wb_req_write_done(struct tevent_req *subreq);
223
224 struct tevent_req *wb_req_write_send(TALLOC_CTX *mem_ctx,
225                                      struct tevent_context *ev,
226                                      struct tevent_queue *queue, int fd,
227                                      struct winbindd_request *wb_req)
228 {
229         struct tevent_req *result, *subreq;
230         struct req_write_state *state;
231         int count = 1;
232
233         result = tevent_req_create(mem_ctx, &state, struct req_write_state);
234         if (result == NULL) {
235                 return NULL;
236         }
237
238         state->iov[0].iov_base = wb_req;
239         state->iov[0].iov_len = sizeof(struct winbindd_request);
240
241         if (wb_req->extra_len != 0) {
242                 state->iov[1].iov_base = wb_req->extra_data.data;
243                 state->iov[1].iov_len = wb_req->extra_len;
244                 count = 2;
245         }
246
247         subreq = writev_send(state, ev, queue, fd, state->iov, count);
248         if (subreq == NULL) {
249                 goto fail;
250         }
251         tevent_req_set_callback(subreq, wb_req_write_done, result);
252         return result;
253
254  fail:
255         TALLOC_FREE(result);
256         return NULL;
257 }
258
259 static void wb_req_write_done(struct tevent_req *subreq)
260 {
261         struct tevent_req *req = tevent_req_callback_data(
262                 subreq, struct tevent_req);
263         int err;
264         ssize_t ret;
265
266         ret = writev_recv(subreq, &err);
267         TALLOC_FREE(subreq);
268         if (ret < 0) {
269                 tevent_req_error(req, map_wbc_err_from_errno(err));
270                 return;
271         }
272         tevent_req_done(req);
273 }
274
275 wbcErr wb_req_write_recv(struct tevent_req *req)
276 {
277         return tevent_req_simple_recv_wbcerr(req);
278 }
279
280 struct resp_read_state {
281         struct winbindd_response *wb_resp;
282 };
283
284 static ssize_t wb_resp_more(uint8_t *buf, size_t buflen, void *private_data);
285 static void wb_resp_read_done(struct tevent_req *subreq);
286
287 struct tevent_req *wb_resp_read_send(TALLOC_CTX *mem_ctx,
288                                      struct tevent_context *ev, int fd)
289 {
290         struct tevent_req *result, *subreq;
291         struct resp_read_state *state;
292
293         result = tevent_req_create(mem_ctx, &state, struct resp_read_state);
294         if (result == NULL) {
295                 return NULL;
296         }
297
298         subreq = read_packet_send(state, ev, fd, 4, wb_resp_more, state);
299         if (subreq == NULL) {
300                 goto nomem;
301         }
302         tevent_req_set_callback(subreq, wb_resp_read_done, result);
303         return result;
304
305  nomem:
306         TALLOC_FREE(result);
307         return NULL;
308 }
309
310 static ssize_t wb_resp_more(uint8_t *buf, size_t buflen, void *private_data)
311 {
312         struct winbindd_response *resp = (struct winbindd_response *)buf;
313
314         if (buflen == 4) {
315                 if (resp->length < sizeof(struct winbindd_response)) {
316                         DEBUG(0, ("wb_resp_read_len: Invalid response size "
317                                   "received: %d (expected at least%d)\n",
318                                   (int)resp->length,
319                                   (int)sizeof(struct winbindd_response)));
320                         return -1;
321                 }
322         }
323         return resp->length - buflen;
324 }
325
326 static void wb_resp_read_done(struct tevent_req *subreq)
327 {
328         struct tevent_req *req = tevent_req_callback_data(
329                 subreq, struct tevent_req);
330         struct resp_read_state *state = tevent_req_data(
331                 req, struct resp_read_state);
332         uint8_t *buf;
333         int err;
334         ssize_t ret;
335
336         ret = read_packet_recv(subreq, state, &buf, &err);
337         TALLOC_FREE(subreq);
338         if (ret == -1) {
339                 tevent_req_error(req, map_wbc_err_from_errno(err));
340                 return;
341         }
342
343         state->wb_resp = (struct winbindd_response *)buf;
344
345         if (state->wb_resp->length > sizeof(struct winbindd_response)) {
346                 state->wb_resp->extra_data.data =
347                         (char *)buf + sizeof(struct winbindd_response);
348         } else {
349                 state->wb_resp->extra_data.data = NULL;
350         }
351         tevent_req_done(req);
352 }
353
354 wbcErr wb_resp_read_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
355                          struct winbindd_response **presp)
356 {
357         struct resp_read_state *state = tevent_req_data(
358                 req, struct resp_read_state);
359         wbcErr wbc_err;
360
361         if (tevent_req_is_wbcerr(req, &wbc_err)) {
362                 return wbc_err;
363         }
364         *presp = talloc_move(mem_ctx, &state->wb_resp);
365         return WBC_ERR_SUCCESS;
366 }
367
368 struct resp_write_state {
369         struct iovec iov[2];
370 };
371
372 static void wb_resp_write_done(struct tevent_req *subreq);
373
374 struct async_req *wb_resp_write_send(TALLOC_CTX *mem_ctx,
375                                     struct tevent_context *ev, int fd,
376                                     struct winbindd_response *wb_resp)
377 {
378         struct async_req *result;
379         struct tevent_req *subreq;
380         struct resp_write_state *state;
381         int count = 1;
382
383         if (!async_req_setup(mem_ctx, &result, &state,
384                              struct resp_write_state)) {
385                 return NULL;
386         }
387
388         state->iov[0].iov_base = wb_resp;
389         state->iov[0].iov_len = sizeof(struct winbindd_response);
390
391         if (wb_resp->length > sizeof(struct winbindd_response)) {
392                 state->iov[1].iov_base = wb_resp->extra_data.data;
393                 state->iov[1].iov_len =
394                         wb_resp->length - sizeof(struct winbindd_response);
395                 count = 2;
396         }
397
398         subreq = writev_send(state, ev, NULL, fd, state->iov, count);
399         if (subreq == NULL) {
400                 goto fail;
401         }
402         tevent_req_set_callback(subreq, wb_resp_write_done, result);
403         return result;
404
405  fail:
406         TALLOC_FREE(result);
407         return NULL;
408 }
409
410 static void wb_resp_write_done(struct tevent_req *subreq)
411 {
412         struct async_req *req =
413                 tevent_req_callback_data(subreq, struct async_req);
414         int err;
415         ssize_t ret;
416
417         ret = writev_recv(subreq, &err);
418         TALLOC_FREE(subreq);
419         if (ret < 0) {
420                 async_req_error(req, map_wbc_err_from_errno(err));
421                 return;
422         }
423         async_req_done(req);
424 }
425
426 wbcErr wb_resp_write_recv(struct async_req *req)
427 {
428         return async_req_simple_recv_wbcerr(req);
429 }