Merge branch 'master' of git://git.samba.org/samba
[ira/wip.git] / lib / tsocket / tsocket_helpers.c
1 /*
2    Unix SMB/CIFS implementation.
3
4    Copyright (C) Stefan Metzmacher 2009
5
6      ** NOTE! The following LGPL license applies to the tsocket
7      ** library. This does NOT imply that all of Samba is released
8      ** under the LGPL
9
10    This library is free software; you can redistribute it and/or
11    modify it under the terms of the GNU Lesser General Public
12    License as published by the Free Software Foundation; either
13    version 3 of the License, or (at your option) any later version.
14
15    This library is distributed in the hope that it will be useful,
16    but WITHOUT ANY WARRANTY; without even the implied warranty of
17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18    Lesser General Public License for more details.
19
20    You should have received a copy of the GNU Lesser General Public
21    License along with this library; if not, see <http://www.gnu.org/licenses/>.
22 */
23
24 #include "replace.h"
25 #include "system/filesys.h"
26 #include "tsocket.h"
27 #include "tsocket_internal.h"
28
29 struct tdgram_sendto_queue_state {
30         /* this structs are owned by the caller */
31         struct {
32                 struct tevent_context *ev;
33                 struct tdgram_context *dgram;
34                 const uint8_t *buf;
35                 size_t len;
36                 const struct tsocket_address *dst;
37         } caller;
38         ssize_t ret;
39 };
40
41 static void tdgram_sendto_queue_trigger(struct tevent_req *req,
42                                          void *private_data);
43 static void tdgram_sendto_queue_done(struct tevent_req *subreq);
44
45 struct tevent_req *tdgram_sendto_queue_send(TALLOC_CTX *mem_ctx,
46                                             struct tevent_context *ev,
47                                             struct tdgram_context *dgram,
48                                             struct tevent_queue *queue,
49                                             const uint8_t *buf,
50                                             size_t len,
51                                             struct tsocket_address *dst)
52 {
53         struct tevent_req *req;
54         struct tdgram_sendto_queue_state *state;
55         bool ok;
56
57         req = tevent_req_create(mem_ctx, &state,
58                                 struct tdgram_sendto_queue_state);
59         if (!req) {
60                 return NULL;
61         }
62
63         state->caller.ev        = ev;
64         state->caller.dgram     = dgram;
65         state->caller.buf       = buf;
66         state->caller.len       = len;
67         state->caller.dst       = dst;
68         state->ret              = -1;
69
70         ok = tevent_queue_add(queue,
71                               ev,
72                               req,
73                               tdgram_sendto_queue_trigger,
74                               NULL);
75         if (!ok) {
76                 tevent_req_nomem(NULL, req);
77                 goto post;
78         }
79
80         return req;
81
82  post:
83         tevent_req_post(req, ev);
84         return req;
85 }
86
87 static void tdgram_sendto_queue_trigger(struct tevent_req *req,
88                                          void *private_data)
89 {
90         struct tdgram_sendto_queue_state *state = tevent_req_data(req,
91                                         struct tdgram_sendto_queue_state);
92         struct tevent_req *subreq;
93
94         subreq = tdgram_sendto_send(state,
95                                     state->caller.ev,
96                                     state->caller.dgram,
97                                     state->caller.buf,
98                                     state->caller.len,
99                                     state->caller.dst);
100         if (tevent_req_nomem(subreq, req)) {
101                 return;
102         }
103         tevent_req_set_callback(subreq, tdgram_sendto_queue_done, req);
104 }
105
106 static void tdgram_sendto_queue_done(struct tevent_req *subreq)
107 {
108         struct tevent_req *req = tevent_req_callback_data(subreq,
109                                  struct tevent_req);
110         struct tdgram_sendto_queue_state *state = tevent_req_data(req,
111                                         struct tdgram_sendto_queue_state);
112         ssize_t ret;
113         int sys_errno;
114
115         ret = tdgram_sendto_recv(subreq, &sys_errno);
116         talloc_free(subreq);
117         if (ret == -1) {
118                 tevent_req_error(req, sys_errno);
119                 return;
120         }
121         state->ret = ret;
122
123         tevent_req_done(req);
124 }
125
126 ssize_t tdgram_sendto_queue_recv(struct tevent_req *req, int *perrno)
127 {
128         struct tdgram_sendto_queue_state *state = tevent_req_data(req,
129                                         struct tdgram_sendto_queue_state);
130         ssize_t ret;
131
132         ret = tsocket_simple_int_recv(req, perrno);
133         if (ret == 0) {
134                 ret = state->ret;
135         }
136
137         tevent_req_received(req);
138         return ret;
139 }
140
141 struct tstream_readv_pdu_state {
142         /* this structs are owned by the caller */
143         struct {
144                 struct tevent_context *ev;
145                 struct tstream_context *stream;
146                 tstream_readv_pdu_next_vector_t next_vector_fn;
147                 void *next_vector_private;
148         } caller;
149
150         /*
151          * Each call to the callback resets iov and count
152          * the callback allocated the iov as child of our state,
153          * that means we are allowed to modify and free it.
154          *
155          * we should call the callback every time we filled the given
156          * vector and ask for a new vector. We return if the callback
157          * ask for 0 bytes.
158          */
159         struct iovec *vector;
160         size_t count;
161
162         /*
163          * the total number of bytes we read,
164          * the return value of the _recv function
165          */
166         int total_read;
167 };
168
169 static void tstream_readv_pdu_ask_for_next_vector(struct tevent_req *req);
170 static void tstream_readv_pdu_readv_done(struct tevent_req *subreq);
171
172 struct tevent_req *tstream_readv_pdu_send(TALLOC_CTX *mem_ctx,
173                                 struct tevent_context *ev,
174                                 struct tstream_context *stream,
175                                 tstream_readv_pdu_next_vector_t next_vector_fn,
176                                 void *next_vector_private)
177 {
178         struct tevent_req *req;
179         struct tstream_readv_pdu_state *state;
180
181         req = tevent_req_create(mem_ctx, &state,
182                                 struct tstream_readv_pdu_state);
183         if (!req) {
184                 return NULL;
185         }
186
187         state->caller.ev                        = ev;
188         state->caller.stream                    = stream;
189         state->caller.next_vector_fn            = next_vector_fn;
190         state->caller.next_vector_private       = next_vector_private;
191
192         state->vector           = NULL;
193         state->count            = 0;
194         state->total_read       = 0;
195
196         tstream_readv_pdu_ask_for_next_vector(req);
197         if (!tevent_req_is_in_progress(req)) {
198                 goto post;
199         }
200
201         return req;
202
203  post:
204         return tevent_req_post(req, ev);
205 }
206
207 static void tstream_readv_pdu_ask_for_next_vector(struct tevent_req *req)
208 {
209         struct tstream_readv_pdu_state *state = tevent_req_data(req,
210                                             struct tstream_readv_pdu_state);
211         int ret;
212         size_t to_read = 0;
213         size_t i;
214         struct tevent_req *subreq;
215
216         TALLOC_FREE(state->vector);
217         state->count = 0;
218
219         ret = state->caller.next_vector_fn(state->caller.stream,
220                                            state->caller.next_vector_private,
221                                            state, &state->vector, &state->count);
222         if (ret == -1) {
223                 tevent_req_error(req, errno);
224                 return;
225         }
226
227         if (state->count == 0) {
228                 tevent_req_done(req);
229                 return;
230         }
231
232         for (i=0; i < state->count; i++) {
233                 size_t tmp = to_read;
234                 tmp += state->vector[i].iov_len;
235
236                 if (tmp < to_read) {
237                         tevent_req_error(req, EMSGSIZE);
238                         return;
239                 }
240
241                 to_read = tmp;
242         }
243
244         /*
245          * this is invalid the next vector function should have
246          * reported count == 0.
247          */
248         if (to_read == 0) {
249                 tevent_req_error(req, EINVAL);
250                 return;
251         }
252
253         if (state->total_read + to_read < state->total_read) {
254                 tevent_req_error(req, EMSGSIZE);
255                 return;
256         }
257
258         subreq = tstream_readv_send(state,
259                                     state->caller.ev,
260                                     state->caller.stream,
261                                     state->vector,
262                                     state->count);
263         if (tevent_req_nomem(subreq, req)) {
264                 return;
265         }
266         tevent_req_set_callback(subreq, tstream_readv_pdu_readv_done, req);
267 }
268
269 static void tstream_readv_pdu_readv_done(struct tevent_req *subreq)
270 {
271         struct tevent_req *req = tevent_req_callback_data(subreq,
272                                  struct tevent_req);
273         struct tstream_readv_pdu_state *state = tevent_req_data(req,
274                                             struct tstream_readv_pdu_state);
275         int ret;
276         int sys_errno;
277
278         ret = tstream_readv_recv(subreq, &sys_errno);
279         if (ret == -1) {
280                 tevent_req_error(req, sys_errno);
281                 return;
282         }
283
284         state->total_read += ret;
285
286         /* ask the callback for a new vector we should fill */
287         tstream_readv_pdu_ask_for_next_vector(req);
288 }
289
290 int tstream_readv_pdu_recv(struct tevent_req *req, int *perrno)
291 {
292         struct tstream_readv_pdu_state *state = tevent_req_data(req,
293                                             struct tstream_readv_pdu_state);
294         int ret;
295
296         ret = tsocket_simple_int_recv(req, perrno);
297         if (ret == 0) {
298                 ret = state->total_read;
299         }
300
301         tevent_req_received(req);
302         return ret;
303 }
304
305 struct tstream_readv_pdu_queue_state {
306         /* this structs are owned by the caller */
307         struct {
308                 struct tevent_context *ev;
309                 struct tstream_context *stream;
310                 tstream_readv_pdu_next_vector_t next_vector_fn;
311                 void *next_vector_private;
312         } caller;
313         int ret;
314 };
315
316 static void tstream_readv_pdu_queue_trigger(struct tevent_req *req,
317                                          void *private_data);
318 static void tstream_readv_pdu_queue_done(struct tevent_req *subreq);
319
320 struct tevent_req *tstream_readv_pdu_queue_send(TALLOC_CTX *mem_ctx,
321                                 struct tevent_context *ev,
322                                 struct tstream_context *stream,
323                                 struct tevent_queue *queue,
324                                 tstream_readv_pdu_next_vector_t next_vector_fn,
325                                 void *next_vector_private)
326 {
327         struct tevent_req *req;
328         struct tstream_readv_pdu_queue_state *state;
329         bool ok;
330
331         req = tevent_req_create(mem_ctx, &state,
332                                 struct tstream_readv_pdu_queue_state);
333         if (!req) {
334                 return NULL;
335         }
336
337         state->caller.ev                        = ev;
338         state->caller.stream                    = stream;
339         state->caller.next_vector_fn            = next_vector_fn;
340         state->caller.next_vector_private       = next_vector_private;
341         state->ret                              = -1;
342
343         ok = tevent_queue_add(queue,
344                               ev,
345                               req,
346                               tstream_readv_pdu_queue_trigger,
347                               NULL);
348         if (!ok) {
349                 tevent_req_nomem(NULL, req);
350                 goto post;
351         }
352
353         return req;
354
355  post:
356         return tevent_req_post(req, ev);
357 }
358
359 static void tstream_readv_pdu_queue_trigger(struct tevent_req *req,
360                                          void *private_data)
361 {
362         struct tstream_readv_pdu_queue_state *state = tevent_req_data(req,
363                                         struct tstream_readv_pdu_queue_state);
364         struct tevent_req *subreq;
365
366         subreq = tstream_readv_pdu_send(state,
367                                         state->caller.ev,
368                                         state->caller.stream,
369                                         state->caller.next_vector_fn,
370                                         state->caller.next_vector_private);
371         if (tevent_req_nomem(subreq, req)) {
372                 return;
373         }
374         tevent_req_set_callback(subreq, tstream_readv_pdu_queue_done ,req);
375 }
376
377 static void tstream_readv_pdu_queue_done(struct tevent_req *subreq)
378 {
379         struct tevent_req *req = tevent_req_callback_data(subreq,
380                                  struct tevent_req);
381         struct tstream_readv_pdu_queue_state *state = tevent_req_data(req,
382                                         struct tstream_readv_pdu_queue_state);
383         int ret;
384         int sys_errno;
385
386         ret = tstream_readv_pdu_recv(subreq, &sys_errno);
387         talloc_free(subreq);
388         if (ret == -1) {
389                 tevent_req_error(req, sys_errno);
390                 return;
391         }
392         state->ret = ret;
393
394         tevent_req_done(req);
395 }
396
397 int tstream_readv_pdu_queue_recv(struct tevent_req *req, int *perrno)
398 {
399         struct tstream_readv_pdu_queue_state *state = tevent_req_data(req,
400                                         struct tstream_readv_pdu_queue_state);
401         int ret;
402
403         ret = tsocket_simple_int_recv(req, perrno);
404         if (ret == 0) {
405                 ret = state->ret;
406         }
407
408         tevent_req_received(req);
409         return ret;
410 }
411
412 struct tstream_writev_queue_state {
413         /* this structs are owned by the caller */
414         struct {
415                 struct tevent_context *ev;
416                 struct tstream_context *stream;
417                 const struct iovec *vector;
418                 size_t count;
419         } caller;
420         int ret;
421 };
422
423 static void tstream_writev_queue_trigger(struct tevent_req *req,
424                                          void *private_data);
425 static void tstream_writev_queue_done(struct tevent_req *subreq);
426
427 struct tevent_req *tstream_writev_queue_send(TALLOC_CTX *mem_ctx,
428                                              struct tevent_context *ev,
429                                              struct tstream_context *stream,
430                                              struct tevent_queue *queue,
431                                              const struct iovec *vector,
432                                              size_t count)
433 {
434         struct tevent_req *req;
435         struct tstream_writev_queue_state *state;
436         bool ok;
437
438         req = tevent_req_create(mem_ctx, &state,
439                                 struct tstream_writev_queue_state);
440         if (!req) {
441                 return NULL;
442         }
443
444         state->caller.ev        = ev;
445         state->caller.stream    = stream;
446         state->caller.vector    = vector;
447         state->caller.count     = count;
448         state->ret              = -1;
449
450         ok = tevent_queue_add(queue,
451                               ev,
452                               req,
453                               tstream_writev_queue_trigger,
454                               NULL);
455         if (!ok) {
456                 tevent_req_nomem(NULL, req);
457                 goto post;
458         }
459
460         return req;
461
462  post:
463         return tevent_req_post(req, ev);
464 }
465
466 static void tstream_writev_queue_trigger(struct tevent_req *req,
467                                          void *private_data)
468 {
469         struct tstream_writev_queue_state *state = tevent_req_data(req,
470                                         struct tstream_writev_queue_state);
471         struct tevent_req *subreq;
472
473         subreq = tstream_writev_send(state,
474                                      state->caller.ev,
475                                      state->caller.stream,
476                                      state->caller.vector,
477                                      state->caller.count);
478         if (tevent_req_nomem(subreq, req)) {
479                 return;
480         }
481         tevent_req_set_callback(subreq, tstream_writev_queue_done ,req);
482 }
483
484 static void tstream_writev_queue_done(struct tevent_req *subreq)
485 {
486         struct tevent_req *req = tevent_req_callback_data(subreq,
487                                  struct tevent_req);
488         struct tstream_writev_queue_state *state = tevent_req_data(req,
489                                         struct tstream_writev_queue_state);
490         int ret;
491         int sys_errno;
492
493         ret = tstream_writev_recv(subreq, &sys_errno);
494         talloc_free(subreq);
495         if (ret == -1) {
496                 tevent_req_error(req, sys_errno);
497                 return;
498         }
499         state->ret = ret;
500
501         tevent_req_done(req);
502 }
503
504 int tstream_writev_queue_recv(struct tevent_req *req, int *perrno)
505 {
506         struct tstream_writev_queue_state *state = tevent_req_data(req,
507                                         struct tstream_writev_queue_state);
508         int ret;
509
510         ret = tsocket_simple_int_recv(req, perrno);
511         if (ret == 0) {
512                 ret = state->ret;
513         }
514
515         tevent_req_received(req);
516         return ret;
517 }
518