Line data Source code
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 49703 : 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 : struct tevent_queue_entry *e;
56 :
57 49703 : req = tevent_req_create(mem_ctx, &state,
58 : struct tdgram_sendto_queue_state);
59 49703 : if (!req) {
60 0 : return NULL;
61 : }
62 :
63 49703 : state->caller.ev = ev;
64 49703 : state->caller.dgram = dgram;
65 49703 : state->caller.buf = buf;
66 49703 : state->caller.len = len;
67 49703 : state->caller.dst = dst;
68 49703 : state->ret = -1;
69 :
70 : /*
71 : * we use tevent_queue_add_optimize_empty() with allow_direct
72 : * in order to optimize for the empty queue case.
73 : */
74 49703 : e = tevent_queue_add_optimize_empty(
75 : queue,
76 : ev,
77 : req,
78 : tdgram_sendto_queue_trigger,
79 : NULL);
80 49703 : if (tevent_req_nomem(e, req)) {
81 0 : return tevent_req_post(req, ev);
82 : }
83 49703 : if (!tevent_req_is_in_progress(req)) {
84 0 : return tevent_req_post(req, ev);
85 : }
86 :
87 49703 : return req;
88 : }
89 :
90 49703 : static void tdgram_sendto_queue_trigger(struct tevent_req *req,
91 : void *private_data)
92 : {
93 49703 : struct tdgram_sendto_queue_state *state = tevent_req_data(req,
94 : struct tdgram_sendto_queue_state);
95 : struct tevent_req *subreq;
96 :
97 49703 : subreq = tdgram_sendto_send(state,
98 : state->caller.ev,
99 : state->caller.dgram,
100 : state->caller.buf,
101 : state->caller.len,
102 : state->caller.dst);
103 49703 : if (tevent_req_nomem(subreq, req)) {
104 0 : return;
105 : }
106 49703 : tevent_req_set_callback(subreq, tdgram_sendto_queue_done, req);
107 : }
108 :
109 49703 : static void tdgram_sendto_queue_done(struct tevent_req *subreq)
110 : {
111 49703 : struct tevent_req *req = tevent_req_callback_data(subreq,
112 : struct tevent_req);
113 49703 : struct tdgram_sendto_queue_state *state = tevent_req_data(req,
114 : struct tdgram_sendto_queue_state);
115 : ssize_t ret;
116 : int sys_errno;
117 :
118 49703 : ret = tdgram_sendto_recv(subreq, &sys_errno);
119 49703 : talloc_free(subreq);
120 49703 : if (ret == -1) {
121 0 : tevent_req_error(req, sys_errno);
122 0 : return;
123 : }
124 49703 : state->ret = ret;
125 :
126 49703 : tevent_req_done(req);
127 : }
128 :
129 48443 : ssize_t tdgram_sendto_queue_recv(struct tevent_req *req, int *perrno)
130 : {
131 48443 : struct tdgram_sendto_queue_state *state = tevent_req_data(req,
132 : struct tdgram_sendto_queue_state);
133 : ssize_t ret;
134 :
135 48443 : ret = tsocket_simple_int_recv(req, perrno);
136 48443 : if (ret == 0) {
137 48443 : ret = state->ret;
138 : }
139 :
140 48443 : tevent_req_received(req);
141 48443 : return ret;
142 : }
143 :
144 : struct tstream_readv_pdu_state {
145 : /* this structs are owned by the caller */
146 : struct {
147 : struct tevent_context *ev;
148 : struct tstream_context *stream;
149 : tstream_readv_pdu_next_vector_t next_vector_fn;
150 : void *next_vector_private;
151 : } caller;
152 :
153 : /*
154 : * Each call to the callback resets iov and count
155 : * the callback allocated the iov as child of our state,
156 : * that means we are allowed to modify and free it.
157 : *
158 : * we should call the callback every time we filled the given
159 : * vector and ask for a new vector. We return if the callback
160 : * ask for 0 bytes.
161 : */
162 : struct iovec *vector;
163 : size_t count;
164 :
165 : /*
166 : * the total number of bytes we read,
167 : * the return value of the _recv function
168 : */
169 : int total_read;
170 : };
171 :
172 : static void tstream_readv_pdu_ask_for_next_vector(struct tevent_req *req);
173 : static void tstream_readv_pdu_readv_done(struct tevent_req *subreq);
174 :
175 1958820 : struct tevent_req *tstream_readv_pdu_send(TALLOC_CTX *mem_ctx,
176 : struct tevent_context *ev,
177 : struct tstream_context *stream,
178 : tstream_readv_pdu_next_vector_t next_vector_fn,
179 : void *next_vector_private)
180 : {
181 : struct tevent_req *req;
182 : struct tstream_readv_pdu_state *state;
183 :
184 1958820 : req = tevent_req_create(mem_ctx, &state,
185 : struct tstream_readv_pdu_state);
186 1958820 : if (!req) {
187 0 : return NULL;
188 : }
189 :
190 1958820 : state->caller.ev = ev;
191 1958820 : state->caller.stream = stream;
192 1958820 : state->caller.next_vector_fn = next_vector_fn;
193 1958820 : state->caller.next_vector_private = next_vector_private;
194 :
195 1958820 : state->vector = NULL;
196 1958820 : state->count = 0;
197 1958820 : state->total_read = 0;
198 :
199 1958820 : tstream_readv_pdu_ask_for_next_vector(req);
200 1958820 : if (!tevent_req_is_in_progress(req)) {
201 0 : goto post;
202 : }
203 :
204 1958820 : return req;
205 :
206 0 : post:
207 0 : return tevent_req_post(req, ev);
208 : }
209 :
210 5780617 : static void tstream_readv_pdu_ask_for_next_vector(struct tevent_req *req)
211 : {
212 5780617 : struct tstream_readv_pdu_state *state = tevent_req_data(req,
213 : struct tstream_readv_pdu_state);
214 : int ret;
215 5780617 : size_t to_read = 0;
216 : size_t i;
217 : struct tevent_req *subreq;
218 5780617 : bool optimize = false;
219 5780617 : bool save_optimize = false;
220 :
221 5780617 : if (state->count > 0) {
222 : /*
223 : * This is not the first time we asked for a vector,
224 : * which means parts of the pdu already arrived.
225 : *
226 : * In this case it make sense to enable
227 : * a syscall/performance optimization if the
228 : * low level tstream implementation supports it.
229 : */
230 3821797 : optimize = true;
231 : }
232 :
233 5780617 : TALLOC_FREE(state->vector);
234 5780617 : state->count = 0;
235 :
236 5780617 : ret = state->caller.next_vector_fn(state->caller.stream,
237 : state->caller.next_vector_private,
238 : state, &state->vector, &state->count);
239 5780617 : if (ret == -1) {
240 0 : tevent_req_error(req, errno);
241 0 : return;
242 : }
243 :
244 5780617 : if (state->count == 0) {
245 1917851 : tevent_req_done(req);
246 1917843 : return;
247 : }
248 :
249 7993845 : for (i=0; i < state->count; i++) {
250 4131079 : size_t tmp = to_read;
251 4131079 : tmp += state->vector[i].iov_len;
252 :
253 4131079 : if (tmp < to_read) {
254 0 : tevent_req_error(req, EMSGSIZE);
255 0 : return;
256 : }
257 :
258 4131079 : to_read = tmp;
259 : }
260 :
261 : /*
262 : * this is invalid the next vector function should have
263 : * reported count == 0.
264 : */
265 3862766 : if (to_read == 0) {
266 0 : tevent_req_error(req, EINVAL);
267 0 : return;
268 : }
269 :
270 3862766 : if (state->total_read + to_read < state->total_read) {
271 0 : tevent_req_error(req, EMSGSIZE);
272 0 : return;
273 : }
274 :
275 3862766 : if (optimize) {
276 : /*
277 : * If the low level stream is a bsd socket
278 : * we will get syscall optimization.
279 : *
280 : * If it is not a bsd socket
281 : * tstream_bsd_optimize_readv() just returns.
282 : */
283 1903946 : save_optimize = tstream_bsd_optimize_readv(state->caller.stream,
284 : true);
285 : }
286 3862766 : subreq = tstream_readv_send(state,
287 : state->caller.ev,
288 : state->caller.stream,
289 : state->vector,
290 : state->count);
291 3862766 : if (optimize) {
292 1903946 : tstream_bsd_optimize_readv(state->caller.stream,
293 : save_optimize);
294 : }
295 3862766 : if (tevent_req_nomem(subreq, req)) {
296 0 : return;
297 : }
298 3862766 : tevent_req_set_callback(subreq, tstream_readv_pdu_readv_done, req);
299 : }
300 :
301 3862423 : static void tstream_readv_pdu_readv_done(struct tevent_req *subreq)
302 : {
303 3862423 : struct tevent_req *req = tevent_req_callback_data(subreq,
304 : struct tevent_req);
305 3862423 : struct tstream_readv_pdu_state *state = tevent_req_data(req,
306 : struct tstream_readv_pdu_state);
307 : int ret;
308 : int sys_errno;
309 :
310 3862423 : ret = tstream_readv_recv(subreq, &sys_errno);
311 3862423 : TALLOC_FREE(subreq);
312 3862423 : if (ret == -1) {
313 40626 : tevent_req_error(req, sys_errno);
314 40227 : return;
315 : }
316 :
317 3821797 : state->total_read += ret;
318 :
319 : /* ask the callback for a new vector we should fill */
320 3821797 : tstream_readv_pdu_ask_for_next_vector(req);
321 : }
322 :
323 1958477 : int tstream_readv_pdu_recv(struct tevent_req *req, int *perrno)
324 : {
325 1958477 : struct tstream_readv_pdu_state *state = tevent_req_data(req,
326 : struct tstream_readv_pdu_state);
327 : int ret;
328 :
329 1958477 : ret = tsocket_simple_int_recv(req, perrno);
330 1958477 : if (ret == 0) {
331 1917851 : ret = state->total_read;
332 : }
333 :
334 1958477 : tevent_req_received(req);
335 1958477 : return ret;
336 : }
337 :
338 : struct tstream_readv_pdu_queue_state {
339 : /* this structs are owned by the caller */
340 : struct {
341 : struct tevent_context *ev;
342 : struct tstream_context *stream;
343 : tstream_readv_pdu_next_vector_t next_vector_fn;
344 : void *next_vector_private;
345 : } caller;
346 : int ret;
347 : };
348 :
349 : static void tstream_readv_pdu_queue_trigger(struct tevent_req *req,
350 : void *private_data);
351 : static void tstream_readv_pdu_queue_done(struct tevent_req *subreq);
352 :
353 144702 : struct tevent_req *tstream_readv_pdu_queue_send(TALLOC_CTX *mem_ctx,
354 : struct tevent_context *ev,
355 : struct tstream_context *stream,
356 : struct tevent_queue *queue,
357 : tstream_readv_pdu_next_vector_t next_vector_fn,
358 : void *next_vector_private)
359 : {
360 : struct tevent_req *req;
361 : struct tstream_readv_pdu_queue_state *state;
362 : struct tevent_queue_entry *e;
363 :
364 144702 : req = tevent_req_create(mem_ctx, &state,
365 : struct tstream_readv_pdu_queue_state);
366 144702 : if (!req) {
367 0 : return NULL;
368 : }
369 :
370 144702 : state->caller.ev = ev;
371 144702 : state->caller.stream = stream;
372 144702 : state->caller.next_vector_fn = next_vector_fn;
373 144702 : state->caller.next_vector_private = next_vector_private;
374 144702 : state->ret = -1;
375 :
376 : /*
377 : * we use tevent_queue_add_optimize_empty() with allow_direct
378 : * in order to optimize for the empty queue case.
379 : */
380 144702 : e = tevent_queue_add_optimize_empty(
381 : queue,
382 : ev,
383 : req,
384 : tstream_readv_pdu_queue_trigger,
385 : NULL);
386 144702 : if (tevent_req_nomem(e, req)) {
387 0 : return tevent_req_post(req, ev);
388 : }
389 144702 : if (!tevent_req_is_in_progress(req)) {
390 0 : return tevent_req_post(req, ev);
391 : }
392 :
393 144702 : return req;
394 : }
395 :
396 144702 : static void tstream_readv_pdu_queue_trigger(struct tevent_req *req,
397 : void *private_data)
398 : {
399 144702 : struct tstream_readv_pdu_queue_state *state = tevent_req_data(req,
400 : struct tstream_readv_pdu_queue_state);
401 : struct tevent_req *subreq;
402 :
403 144702 : subreq = tstream_readv_pdu_send(state,
404 : state->caller.ev,
405 : state->caller.stream,
406 : state->caller.next_vector_fn,
407 : state->caller.next_vector_private);
408 144702 : if (tevent_req_nomem(subreq, req)) {
409 0 : return;
410 : }
411 144702 : tevent_req_set_callback(subreq, tstream_readv_pdu_queue_done ,req);
412 : }
413 :
414 144702 : static void tstream_readv_pdu_queue_done(struct tevent_req *subreq)
415 : {
416 144702 : struct tevent_req *req = tevent_req_callback_data(subreq,
417 : struct tevent_req);
418 144702 : struct tstream_readv_pdu_queue_state *state = tevent_req_data(req,
419 : struct tstream_readv_pdu_queue_state);
420 : int ret;
421 : int sys_errno;
422 :
423 144702 : ret = tstream_readv_pdu_recv(subreq, &sys_errno);
424 144702 : talloc_free(subreq);
425 144702 : if (ret == -1) {
426 6 : tevent_req_error(req, sys_errno);
427 6 : return;
428 : }
429 144696 : state->ret = ret;
430 :
431 144696 : tevent_req_done(req);
432 : }
433 :
434 144702 : int tstream_readv_pdu_queue_recv(struct tevent_req *req, int *perrno)
435 : {
436 144702 : struct tstream_readv_pdu_queue_state *state = tevent_req_data(req,
437 : struct tstream_readv_pdu_queue_state);
438 : int ret;
439 :
440 144702 : ret = tsocket_simple_int_recv(req, perrno);
441 144702 : if (ret == 0) {
442 144696 : ret = state->ret;
443 : }
444 :
445 144702 : tevent_req_received(req);
446 144702 : return ret;
447 : }
448 :
449 : struct tstream_writev_queue_state {
450 : /* this structs are owned by the caller */
451 : struct {
452 : struct tevent_context *ev;
453 : struct tstream_context *stream;
454 : const struct iovec *vector;
455 : size_t count;
456 : } caller;
457 : int ret;
458 : };
459 :
460 : static void tstream_writev_queue_trigger(struct tevent_req *req,
461 : void *private_data);
462 : static void tstream_writev_queue_done(struct tevent_req *subreq);
463 :
464 1756862 : struct tevent_req *tstream_writev_queue_send(TALLOC_CTX *mem_ctx,
465 : struct tevent_context *ev,
466 : struct tstream_context *stream,
467 : struct tevent_queue *queue,
468 : const struct iovec *vector,
469 : size_t count)
470 : {
471 : struct tevent_req *req;
472 : struct tstream_writev_queue_state *state;
473 : struct tevent_queue_entry *e;
474 :
475 1756862 : req = tevent_req_create(mem_ctx, &state,
476 : struct tstream_writev_queue_state);
477 1756862 : if (!req) {
478 0 : return NULL;
479 : }
480 :
481 1756862 : state->caller.ev = ev;
482 1756862 : state->caller.stream = stream;
483 1756862 : state->caller.vector = vector;
484 1756862 : state->caller.count = count;
485 1756862 : state->ret = -1;
486 :
487 : /*
488 : * we use tevent_queue_add_optimize_empty() with allow_direct
489 : * in order to optimize for the empty queue case.
490 : */
491 1756862 : e = tevent_queue_add_optimize_empty(
492 : queue,
493 : ev,
494 : req,
495 : tstream_writev_queue_trigger,
496 : NULL);
497 1756862 : if (tevent_req_nomem(e, req)) {
498 0 : return tevent_req_post(req, ev);
499 : }
500 1756862 : if (!tevent_req_is_in_progress(req)) {
501 0 : return tevent_req_post(req, ev);
502 : }
503 :
504 1756862 : return req;
505 : }
506 :
507 1756856 : static void tstream_writev_queue_trigger(struct tevent_req *req,
508 : void *private_data)
509 : {
510 1756856 : struct tstream_writev_queue_state *state = tevent_req_data(req,
511 : struct tstream_writev_queue_state);
512 : struct tevent_req *subreq;
513 :
514 1756856 : subreq = tstream_writev_send(state,
515 : state->caller.ev,
516 : state->caller.stream,
517 : state->caller.vector,
518 : state->caller.count);
519 1756856 : if (tevent_req_nomem(subreq, req)) {
520 0 : return;
521 : }
522 1756856 : tevent_req_set_callback(subreq, tstream_writev_queue_done ,req);
523 : }
524 :
525 1756842 : static void tstream_writev_queue_done(struct tevent_req *subreq)
526 : {
527 1756842 : struct tevent_req *req = tevent_req_callback_data(subreq,
528 : struct tevent_req);
529 1756842 : struct tstream_writev_queue_state *state = tevent_req_data(req,
530 : struct tstream_writev_queue_state);
531 : int ret;
532 : int sys_errno;
533 :
534 1756842 : ret = tstream_writev_recv(subreq, &sys_errno);
535 1756842 : talloc_free(subreq);
536 1756842 : if (ret == -1) {
537 12 : tevent_req_error(req, sys_errno);
538 12 : return;
539 : }
540 1756830 : state->ret = ret;
541 :
542 1756830 : tevent_req_done(req);
543 : }
544 :
545 1756842 : int tstream_writev_queue_recv(struct tevent_req *req, int *perrno)
546 : {
547 1756842 : struct tstream_writev_queue_state *state = tevent_req_data(req,
548 : struct tstream_writev_queue_state);
549 : int ret;
550 :
551 1756842 : ret = tsocket_simple_int_recv(req, perrno);
552 1756842 : if (ret == 0) {
553 1756830 : ret = state->ret;
554 : }
555 :
556 1756842 : tevent_req_received(req);
557 1756842 : return ret;
558 : }
559 :
|