The Tor Browser / file comparison

comparison: ipc/chromium/src/third_party/libevent/bufferevent_async.c

ipc/chromium/src/third_party/libevent/bufferevent_async.c

branch
TOR_BUG_9701
changeset 11
deefc01c0e14
equal deleted inserted replaced
-1:000000000000 0:4bf8514f5626
1 /*
2 * Copyright (c) 2009-2012 Niels Provos and Nick Mathewson
3 *
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * 3. The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29 #include "event2/event-config.h"
30
31 #ifdef _EVENT_HAVE_SYS_TIME_H
32 #include <sys/time.h>
33 #endif
34
35 #include <errno.h>
36 #include <stdio.h>
37 #include <stdlib.h>
38 #include <string.h>
39 #ifdef _EVENT_HAVE_STDARG_H
40 #include <stdarg.h>
41 #endif
42 #ifdef _EVENT_HAVE_UNISTD_H
43 #include <unistd.h>
44 #endif
45
46 #ifdef WIN32
47 #include <winsock2.h>
48 #include <ws2tcpip.h>
49 #endif
50
51 #include <sys/queue.h>
52
53 #include "event2/util.h"
54 #include "event2/bufferevent.h"
55 #include "event2/buffer.h"
56 #include "event2/bufferevent_struct.h"
57 #include "event2/event.h"
58 #include "event2/util.h"
59 #include "event-internal.h"
60 #include "log-internal.h"
61 #include "mm-internal.h"
62 #include "bufferevent-internal.h"
63 #include "util-internal.h"
64 #include "iocp-internal.h"
65
66 #ifndef SO_UPDATE_CONNECT_CONTEXT
67 /* Mingw is sometimes missing this */
68 #define SO_UPDATE_CONNECT_CONTEXT 0x7010
69 #endif
70
71 /* prototypes */
72 static int be_async_enable(struct bufferevent *, short);
73 static int be_async_disable(struct bufferevent *, short);
74 static void be_async_destruct(struct bufferevent *);
75 static int be_async_flush(struct bufferevent *, short, enum bufferevent_flush_mode);
76 static int be_async_ctrl(struct bufferevent *, enum bufferevent_ctrl_op, union bufferevent_ctrl_data *);
77
78 struct bufferevent_async {
79 struct bufferevent_private bev;
80 struct event_overlapped connect_overlapped;
81 struct event_overlapped read_overlapped;
82 struct event_overlapped write_overlapped;
83 size_t read_in_progress;
84 size_t write_in_progress;
85 unsigned ok : 1;
86 unsigned read_added : 1;
87 unsigned write_added : 1;
88 };
89
90 const struct bufferevent_ops bufferevent_ops_async = {
91 "socket_async",
92 evutil_offsetof(struct bufferevent_async, bev.bev),
93 be_async_enable,
94 be_async_disable,
95 be_async_destruct,
96 _bufferevent_generic_adj_timeouts,
97 be_async_flush,
98 be_async_ctrl,
99 };
100
101 static inline struct bufferevent_async *
102 upcast(struct bufferevent *bev)
103 {
104 struct bufferevent_async *bev_a;
105 if (bev->be_ops != &bufferevent_ops_async)
106 return NULL;
107 bev_a = EVUTIL_UPCAST(bev, struct bufferevent_async, bev.bev);
108 return bev_a;
109 }
110
111 static inline struct bufferevent_async *
112 upcast_connect(struct event_overlapped *eo)
113 {
114 struct bufferevent_async *bev_a;
115 bev_a = EVUTIL_UPCAST(eo, struct bufferevent_async, connect_overlapped);
116 EVUTIL_ASSERT(BEV_IS_ASYNC(&bev_a->bev.bev));
117 return bev_a;
118 }
119
120 static inline struct bufferevent_async *
121 upcast_read(struct event_overlapped *eo)
122 {
123 struct bufferevent_async *bev_a;
124 bev_a = EVUTIL_UPCAST(eo, struct bufferevent_async, read_overlapped);
125 EVUTIL_ASSERT(BEV_IS_ASYNC(&bev_a->bev.bev));
126 return bev_a;
127 }
128
129 static inline struct bufferevent_async *
130 upcast_write(struct event_overlapped *eo)
131 {
132 struct bufferevent_async *bev_a;
133 bev_a = EVUTIL_UPCAST(eo, struct bufferevent_async, write_overlapped);
134 EVUTIL_ASSERT(BEV_IS_ASYNC(&bev_a->bev.bev));
135 return bev_a;
136 }
137
138 static void
139 bev_async_del_write(struct bufferevent_async *beva)
140 {
141 struct bufferevent *bev = &beva->bev.bev;
142
143 if (beva->write_added) {
144 beva->write_added = 0;
145 event_base_del_virtual(bev->ev_base);
146 }
147 }
148
149 static void
150 bev_async_del_read(struct bufferevent_async *beva)
151 {
152 struct bufferevent *bev = &beva->bev.bev;
153
154 if (beva->read_added) {
155 beva->read_added = 0;
156 event_base_del_virtual(bev->ev_base);
157 }
158 }
159
160 static void
161 bev_async_add_write(struct bufferevent_async *beva)
162 {
163 struct bufferevent *bev = &beva->bev.bev;
164
165 if (!beva->write_added) {
166 beva->write_added = 1;
167 event_base_add_virtual(bev->ev_base);
168 }
169 }
170
171 static void
172 bev_async_add_read(struct bufferevent_async *beva)
173 {
174 struct bufferevent *bev = &beva->bev.bev;
175
176 if (!beva->read_added) {
177 beva->read_added = 1;
178 event_base_add_virtual(bev->ev_base);
179 }
180 }
181
182 static void
183 bev_async_consider_writing(struct bufferevent_async *beva)
184 {
185 size_t at_most;
186 int limit;
187 struct bufferevent *bev = &beva->bev.bev;
188
189 /* Don't write if there's a write in progress, or we do not
190 * want to write, or when there's nothing left to write. */
191 if (beva->write_in_progress || beva->bev.connecting)
192 return;
193 if (!beva->ok || !(bev->enabled&EV_WRITE) ||
194 !evbuffer_get_length(bev->output)) {
195 bev_async_del_write(beva);
196 return;
197 }
198
199 at_most = evbuffer_get_length(bev->output);
200
201 /* This is safe so long as bufferevent_get_write_max never returns
202 * more than INT_MAX. That's true for now. XXXX */
203 limit = (int)_bufferevent_get_write_max(&beva->bev);
204 if (at_most >= (size_t)limit && limit >= 0)
205 at_most = limit;
206
207 if (beva->bev.write_suspended) {
208 bev_async_del_write(beva);
209 return;
210 }
211
212 /* XXXX doesn't respect low-water mark very well. */
213 bufferevent_incref(bev);
214 if (evbuffer_launch_write(bev->output, at_most,
215 &beva->write_overlapped)) {
216 bufferevent_decref(bev);
217 beva->ok = 0;
218 _bufferevent_run_eventcb(bev, BEV_EVENT_ERROR);
219 } else {
220 beva->write_in_progress = at_most;
221 _bufferevent_decrement_write_buckets(&beva->bev, at_most);
222 bev_async_add_write(beva);
223 }
224 }
225
226 static void
227 bev_async_consider_reading(struct bufferevent_async *beva)
228 {
229 size_t cur_size;
230 size_t read_high;
231 size_t at_most;
232 int limit;
233 struct bufferevent *bev = &beva->bev.bev;
234
235 /* Don't read if there is a read in progress, or we do not
236 * want to read. */
237 if (beva->read_in_progress || beva->bev.connecting)
238 return;
239 if (!beva->ok || !(bev->enabled&EV_READ)) {
240 bev_async_del_read(beva);
241 return;
242 }
243
244 /* Don't read if we're full */
245 cur_size = evbuffer_get_length(bev->input);
246 read_high = bev->wm_read.high;
247 if (read_high) {
248 if (cur_size >= read_high) {
249 bev_async_del_read(beva);
250 return;
251 }
252 at_most = read_high - cur_size;
253 } else {
254 at_most = 16384; /* FIXME totally magic. */
255 }
256
257 /* XXXX This over-commits. */
258 /* XXXX see also not above on cast on _bufferevent_get_write_max() */
259 limit = (int)_bufferevent_get_read_max(&beva->bev);
260 if (at_most >= (size_t)limit && limit >= 0)
261 at_most = limit;
262
263 if (beva->bev.read_suspended) {
264 bev_async_del_read(beva);
265 return;
266 }
267
268 bufferevent_incref(bev);
269 if (evbuffer_launch_read(bev->input, at_most, &beva->read_overlapped)) {
270 beva->ok = 0;
271 _bufferevent_run_eventcb(bev, BEV_EVENT_ERROR);
272 bufferevent_decref(bev);
273 } else {
274 beva->read_in_progress = at_most;
275 _bufferevent_decrement_read_buckets(&beva->bev, at_most);
276 bev_async_add_read(beva);
277 }
278
279 return;
280 }
281
282 static void
283 be_async_outbuf_callback(struct evbuffer *buf,
284 const struct evbuffer_cb_info *cbinfo,
285 void *arg)
286 {
287 struct bufferevent *bev = arg;
288 struct bufferevent_async *bev_async = upcast(bev);
289
290 /* If we added data to the outbuf and were not writing before,
291 * we may want to write now. */
292
293 _bufferevent_incref_and_lock(bev);
294
295 if (cbinfo->n_added)
296 bev_async_consider_writing(bev_async);
297
298 _bufferevent_decref_and_unlock(bev);
299 }
300
301 static void
302 be_async_inbuf_callback(struct evbuffer *buf,
303 const struct evbuffer_cb_info *cbinfo,
304 void *arg)
305 {
306 struct bufferevent *bev = arg;
307 struct bufferevent_async *bev_async = upcast(bev);
308
309 /* If we drained data from the inbuf and were not reading before,
310 * we may want to read now */
311
312 _bufferevent_incref_and_lock(bev);
313
314 if (cbinfo->n_deleted)
315 bev_async_consider_reading(bev_async);
316
317 _bufferevent_decref_and_unlock(bev);
318 }
319
320 static int
321 be_async_enable(struct bufferevent *buf, short what)
322 {
323 struct bufferevent_async *bev_async = upcast(buf);
324
325 if (!bev_async->ok)
326 return -1;
327
328 if (bev_async->bev.connecting) {
329 /* Don't launch anything during connection attempts. */
330 return 0;
331 }
332
333 if (what & EV_READ)
334 BEV_RESET_GENERIC_READ_TIMEOUT(buf);
335 if (what & EV_WRITE)
336 BEV_RESET_GENERIC_WRITE_TIMEOUT(buf);
337
338 /* If we newly enable reading or writing, and we aren't reading or
339 writing already, consider launching a new read or write. */
340
341 if (what & EV_READ)
342 bev_async_consider_reading(bev_async);
343 if (what & EV_WRITE)
344 bev_async_consider_writing(bev_async);
345 return 0;
346 }
347
348 static int
349 be_async_disable(struct bufferevent *bev, short what)
350 {
351 struct bufferevent_async *bev_async = upcast(bev);
352 /* XXXX If we disable reading or writing, we may want to consider
353 * canceling any in-progress read or write operation, though it might
354 * not work. */
355
356 if (what & EV_READ) {
357 BEV_DEL_GENERIC_READ_TIMEOUT(bev);
358 bev_async_del_read(bev_async);
359 }
360 if (what & EV_WRITE) {
361 BEV_DEL_GENERIC_WRITE_TIMEOUT(bev);
362 bev_async_del_write(bev_async);
363 }
364
365 return 0;
366 }
367
368 static void
369 be_async_destruct(struct bufferevent *bev)
370 {
371 struct bufferevent_async *bev_async = upcast(bev);
372 struct bufferevent_private *bev_p = BEV_UPCAST(bev);
373 evutil_socket_t fd;
374
375 EVUTIL_ASSERT(!upcast(bev)->write_in_progress &&
376 !upcast(bev)->read_in_progress);
377
378 bev_async_del_read(bev_async);
379 bev_async_del_write(bev_async);
380
381 fd = _evbuffer_overlapped_get_fd(bev->input);
382 if (bev_p->options & BEV_OPT_CLOSE_ON_FREE) {
383 /* XXXX possible double-close */
384 evutil_closesocket(fd);
385 }
386 /* delete this in case non-blocking connect was used */
387 if (event_initialized(&bev->ev_write)) {
388 event_del(&bev->ev_write);
389 _bufferevent_del_generic_timeout_cbs(bev);
390 }
391 }
392
393 /* GetQueuedCompletionStatus doesn't reliably yield WSA error codes, so
394 * we use WSAGetOverlappedResult to translate. */
395 static void
396 bev_async_set_wsa_error(struct bufferevent *bev, struct event_overlapped *eo)
397 {
398 DWORD bytes, flags;
399 evutil_socket_t fd;
400
401 fd = _evbuffer_overlapped_get_fd(bev->input);
402 WSAGetOverlappedResult(fd, &eo->overlapped, &bytes, FALSE, &flags);
403 }
404
405 static int
406 be_async_flush(struct bufferevent *bev, short what,
407 enum bufferevent_flush_mode mode)
408 {
409 return 0;
410 }
411
412 static void
413 connect_complete(struct event_overlapped *eo, ev_uintptr_t key,
414 ev_ssize_t nbytes, int ok)
415 {
416 struct bufferevent_async *bev_a = upcast_connect(eo);
417 struct bufferevent *bev = &bev_a->bev.bev;
418 evutil_socket_t sock;
419
420 BEV_LOCK(bev);
421
422 EVUTIL_ASSERT(bev_a->bev.connecting);
423 bev_a->bev.connecting = 0;
424 sock = _evbuffer_overlapped_get_fd(bev_a->bev.bev.input);
425 /* XXXX Handle error? */
426 setsockopt(sock, SOL_SOCKET, SO_UPDATE_CONNECT_CONTEXT, NULL, 0);
427
428 if (ok)
429 bufferevent_async_set_connected(bev);
430 else
431 bev_async_set_wsa_error(bev, eo);
432
433 _bufferevent_run_eventcb(bev,
434 ok? BEV_EVENT_CONNECTED : BEV_EVENT_ERROR);
435
436 event_base_del_virtual(bev->ev_base);
437
438 _bufferevent_decref_and_unlock(bev);
439 }
440
441 static void
442 read_complete(struct event_overlapped *eo, ev_uintptr_t key,
443 ev_ssize_t nbytes, int ok)
444 {
445 struct bufferevent_async *bev_a = upcast_read(eo);
446 struct bufferevent *bev = &bev_a->bev.bev;
447 short what = BEV_EVENT_READING;
448 ev_ssize_t amount_unread;
449 BEV_LOCK(bev);
450 EVUTIL_ASSERT(bev_a->read_in_progress);
451
452 amount_unread = bev_a->read_in_progress - nbytes;
453 evbuffer_commit_read(bev->input, nbytes);
454 bev_a->read_in_progress = 0;
455 if (amount_unread)
456 _bufferevent_decrement_read_buckets(&bev_a->bev, -amount_unread);
457
458 if (!ok)
459 bev_async_set_wsa_error(bev, eo);
460
461 if (bev_a->ok) {
462 if (ok && nbytes) {
463 BEV_RESET_GENERIC_READ_TIMEOUT(bev);
464 if (evbuffer_get_length(bev->input) >= bev->wm_read.low)
465 _bufferevent_run_readcb(bev);
466 bev_async_consider_reading(bev_a);
467 } else if (!ok) {
468 what |= BEV_EVENT_ERROR;
469 bev_a->ok = 0;
470 _bufferevent_run_eventcb(bev, what);
471 } else if (!nbytes) {
472 what |= BEV_EVENT_EOF;
473 bev_a->ok = 0;
474 _bufferevent_run_eventcb(bev, what);
475 }
476 }
477
478 _bufferevent_decref_and_unlock(bev);
479 }
480
481 static void
482 write_complete(struct event_overlapped *eo, ev_uintptr_t key,
483 ev_ssize_t nbytes, int ok)
484 {
485 struct bufferevent_async *bev_a = upcast_write(eo);
486 struct bufferevent *bev = &bev_a->bev.bev;
487 short what = BEV_EVENT_WRITING;
488 ev_ssize_t amount_unwritten;
489
490 BEV_LOCK(bev);
491 EVUTIL_ASSERT(bev_a->write_in_progress);
492
493 amount_unwritten = bev_a->write_in_progress - nbytes;
494 evbuffer_commit_write(bev->output, nbytes);
495 bev_a->write_in_progress = 0;
496
497 if (amount_unwritten)
498 _bufferevent_decrement_write_buckets(&bev_a->bev,
499 -amount_unwritten);
500
501
502 if (!ok)
503 bev_async_set_wsa_error(bev, eo);
504
505 if (bev_a->ok) {
506 if (ok && nbytes) {
507 BEV_RESET_GENERIC_WRITE_TIMEOUT(bev);
508 if (evbuffer_get_length(bev->output) <=
509 bev->wm_write.low)
510 _bufferevent_run_writecb(bev);
511 bev_async_consider_writing(bev_a);
512 } else if (!ok) {
513 what |= BEV_EVENT_ERROR;
514 bev_a->ok = 0;
515 _bufferevent_run_eventcb(bev, what);
516 } else if (!nbytes) {
517 what |= BEV_EVENT_EOF;
518 bev_a->ok = 0;
519 _bufferevent_run_eventcb(bev, what);
520 }
521 }
522
523 _bufferevent_decref_and_unlock(bev);
524 }
525
526 struct bufferevent *
527 bufferevent_async_new(struct event_base *base,
528 evutil_socket_t fd, int options)
529 {
530 struct bufferevent_async *bev_a;
531 struct bufferevent *bev;
532 struct event_iocp_port *iocp;
533
534 options |= BEV_OPT_THREADSAFE;
535
536 if (!(iocp = event_base_get_iocp(base)))
537 return NULL;
538
539 if (fd >= 0 && event_iocp_port_associate(iocp, fd, 1)<0) {
540 int err = GetLastError();
541 /* We may have alrady associated this fd with a port.
542 * Let's hope it's this port, and that the error code
543 * for doing this neer changes. */
544 if (err != ERROR_INVALID_PARAMETER)
545 return NULL;
546 }
547
548 if (!(bev_a = mm_calloc(1, sizeof(struct bufferevent_async))))
549 return NULL;
550
551 bev = &bev_a->bev.bev;
552 if (!(bev->input = evbuffer_overlapped_new(fd))) {
553 mm_free(bev_a);
554 return NULL;
555 }
556 if (!(bev->output = evbuffer_overlapped_new(fd))) {
557 evbuffer_free(bev->input);
558 mm_free(bev_a);
559 return NULL;
560 }
561
562 if (bufferevent_init_common(&bev_a->bev, base, &bufferevent_ops_async,
563 options)<0)
564 goto err;
565
566 evbuffer_add_cb(bev->input, be_async_inbuf_callback, bev);
567 evbuffer_add_cb(bev->output, be_async_outbuf_callback, bev);
568
569 event_overlapped_init(&bev_a->connect_overlapped, connect_complete);
570 event_overlapped_init(&bev_a->read_overlapped, read_complete);
571 event_overlapped_init(&bev_a->write_overlapped, write_complete);
572
573 bev_a->ok = fd >= 0;
574 if (bev_a->ok)
575 _bufferevent_init_generic_timeout_cbs(bev);
576
577 return bev;
578 err:
579 bufferevent_free(&bev_a->bev.bev);
580 return NULL;
581 }
582
583 void
584 bufferevent_async_set_connected(struct bufferevent *bev)
585 {
586 struct bufferevent_async *bev_async = upcast(bev);
587 bev_async->ok = 1;
588 _bufferevent_init_generic_timeout_cbs(bev);
589 /* Now's a good time to consider reading/writing */
590 be_async_enable(bev, bev->enabled);
591 }
592
593 int
594 bufferevent_async_can_connect(struct bufferevent *bev)
595 {
596 const struct win32_extension_fns *ext =
597 event_get_win32_extension_fns();
598
599 if (BEV_IS_ASYNC(bev) &&
600 event_base_get_iocp(bev->ev_base) &&
601 ext && ext->ConnectEx)
602 return 1;
603
604 return 0;
605 }
606
607 int
608 bufferevent_async_connect(struct bufferevent *bev, evutil_socket_t fd,
609 const struct sockaddr *sa, int socklen)
610 {
611 BOOL rc;
612 struct bufferevent_async *bev_async = upcast(bev);
613 struct sockaddr_storage ss;
614 const struct win32_extension_fns *ext =
615 event_get_win32_extension_fns();
616
617 EVUTIL_ASSERT(ext && ext->ConnectEx && fd >= 0 && sa != NULL);
618
619 /* ConnectEx() requires that the socket be bound to an address
620 * with bind() before using, otherwise it will fail. We attempt
621 * to issue a bind() here, taking into account that the error
622 * code is set to WSAEINVAL when the socket is already bound. */
623 memset(&ss, 0, sizeof(ss));
624 if (sa->sa_family == AF_INET) {
625 struct sockaddr_in *sin = (struct sockaddr_in *)&ss;
626 sin->sin_family = AF_INET;
627 sin->sin_addr.s_addr = INADDR_ANY;
628 } else if (sa->sa_family == AF_INET6) {
629 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)&ss;
630 sin6->sin6_family = AF_INET6;
631 sin6->sin6_addr = in6addr_any;
632 } else {
633 /* Well, the user will have to bind() */
634 return -1;
635 }
636 if (bind(fd, (struct sockaddr *)&ss, sizeof(ss)) < 0 &&
637 WSAGetLastError() != WSAEINVAL)
638 return -1;
639
640 event_base_add_virtual(bev->ev_base);
641 bufferevent_incref(bev);
642 rc = ext->ConnectEx(fd, sa, socklen, NULL, 0, NULL,
643 &bev_async->connect_overlapped.overlapped);
644 if (rc || WSAGetLastError() == ERROR_IO_PENDING)
645 return 0;
646
647 event_base_del_virtual(bev->ev_base);
648 bufferevent_decref(bev);
649
650 return -1;
651 }
652
653 static int
654 be_async_ctrl(struct bufferevent *bev, enum bufferevent_ctrl_op op,
655 union bufferevent_ctrl_data *data)
656 {
657 switch (op) {
658 case BEV_CTRL_GET_FD:
659 data->fd = _evbuffer_overlapped_get_fd(bev->input);
660 return 0;
661 case BEV_CTRL_SET_FD: {
662 struct event_iocp_port *iocp;
663
664 if (data->fd == _evbuffer_overlapped_get_fd(bev->input))
665 return 0;
666 if (!(iocp = event_base_get_iocp(bev->ev_base)))
667 return -1;
668 if (event_iocp_port_associate(iocp, data->fd, 1) < 0)
669 return -1;
670 _evbuffer_overlapped_set_fd(bev->input, data->fd);
671 _evbuffer_overlapped_set_fd(bev->output, data->fd);
672 return 0;
673 }
674 case BEV_CTRL_CANCEL_ALL: {
675 struct bufferevent_async *bev_a = upcast(bev);
676 evutil_socket_t fd = _evbuffer_overlapped_get_fd(bev->input);
677 if (fd != (evutil_socket_t)INVALID_SOCKET &&
678 (bev_a->bev.options & BEV_OPT_CLOSE_ON_FREE)) {
679 closesocket(fd);
680 }
681 bev_a->ok = 0;
682 return 0;
683 }
684 case BEV_CTRL_GET_UNDERLYING:
685 default:
686 return -1;
687 }
688 }
689
690

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial