source: branches/samba-3.5.x/lib/tsocket/tsocket_helpers.c

Last change on this file was 480, checked in by Silvan Scherrer, 15 years ago

Samba Server 3.5: trunk update to 3.5.4
File size: 12.7 KB
Line 
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
29struct 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
41static void tdgram_sendto_queue_trigger(struct tevent_req *req,
42 void *private_data);
43static void tdgram_sendto_queue_done(struct tevent_req *subreq);
44
45struct 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
87static 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
106static 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
126ssize_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
141struct 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
169static void tstream_readv_pdu_ask_for_next_vector(struct tevent_req *req);
170static void tstream_readv_pdu_readv_done(struct tevent_req *subreq);
171
172struct 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
207static 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
269static 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
290int 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
305struct 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
316static void tstream_readv_pdu_queue_trigger(struct tevent_req *req,
317 void *private_data);
318static void tstream_readv_pdu_queue_done(struct tevent_req *subreq);
319
320struct 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
359static 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
377static 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
397int 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
412struct 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
423static void tstream_writev_queue_trigger(struct tevent_req *req,
424 void *private_data);
425static void tstream_writev_queue_done(struct tevent_req *subreq);
426
427struct 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
466static 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
484static 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
504int 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
Note: See TracBrowser for help on using the repository browser.