The Tor Browser / file comparison

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

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

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:1bd09906d74d
1 /*
2 * Copyright (c) 2007-2012 Niels Provos and Nick Mathewson
3 * Copyright (c) 2002-2006 Niels Provos <provos@citi.umich.edu>
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 <sys/types.h>
30
31 #include "event2/event-config.h"
32
33 #ifdef _EVENT_HAVE_SYS_TIME_H
34 #include <sys/time.h>
35 #endif
36
37 #include <errno.h>
38 #include <stdio.h>
39 #include <stdlib.h>
40 #include <string.h>
41 #ifdef _EVENT_HAVE_STDARG_H
42 #include <stdarg.h>
43 #endif
44 #ifdef _EVENT_HAVE_UNISTD_H
45 #include <unistd.h>
46 #endif
47
48 #ifdef WIN32
49 #include <winsock2.h>
50 #include <ws2tcpip.h>
51 #endif
52
53 #ifdef _EVENT_HAVE_SYS_SOCKET_H
54 #include <sys/socket.h>
55 #endif
56 #ifdef _EVENT_HAVE_NETINET_IN_H
57 #include <netinet/in.h>
58 #endif
59 #ifdef _EVENT_HAVE_NETINET_IN6_H
60 #include <netinet/in6.h>
61 #endif
62
63 #include "event2/util.h"
64 #include "event2/bufferevent.h"
65 #include "event2/buffer.h"
66 #include "event2/bufferevent_struct.h"
67 #include "event2/bufferevent_compat.h"
68 #include "event2/event.h"
69 #include "log-internal.h"
70 #include "mm-internal.h"
71 #include "bufferevent-internal.h"
72 #include "util-internal.h"
73 #ifdef WIN32
74 #include "iocp-internal.h"
75 #endif
76
77 /* prototypes */
78 static int be_socket_enable(struct bufferevent *, short);
79 static int be_socket_disable(struct bufferevent *, short);
80 static void be_socket_destruct(struct bufferevent *);
81 static int be_socket_adj_timeouts(struct bufferevent *);
82 static int be_socket_flush(struct bufferevent *, short, enum bufferevent_flush_mode);
83 static int be_socket_ctrl(struct bufferevent *, enum bufferevent_ctrl_op, union bufferevent_ctrl_data *);
84
85 static void be_socket_setfd(struct bufferevent *, evutil_socket_t);
86
87 const struct bufferevent_ops bufferevent_ops_socket = {
88 "socket",
89 evutil_offsetof(struct bufferevent_private, bev),
90 be_socket_enable,
91 be_socket_disable,
92 be_socket_destruct,
93 be_socket_adj_timeouts,
94 be_socket_flush,
95 be_socket_ctrl,
96 };
97
98 #define be_socket_add(ev, t) \
99 _bufferevent_add_event((ev), (t))
100
101 static void
102 bufferevent_socket_outbuf_cb(struct evbuffer *buf,
103 const struct evbuffer_cb_info *cbinfo,
104 void *arg)
105 {
106 struct bufferevent *bufev = arg;
107 struct bufferevent_private *bufev_p =
108 EVUTIL_UPCAST(bufev, struct bufferevent_private, bev);
109
110 if (cbinfo->n_added &&
111 (bufev->enabled & EV_WRITE) &&
112 !event_pending(&bufev->ev_write, EV_WRITE, NULL) &&
113 !bufev_p->write_suspended) {
114 /* Somebody added data to the buffer, and we would like to
115 * write, and we were not writing. So, start writing. */
116 if (be_socket_add(&bufev->ev_write, &bufev->timeout_write) == -1) {
117 /* Should we log this? */
118 }
119 }
120 }
121
122 static void
123 bufferevent_readcb(evutil_socket_t fd, short event, void *arg)
124 {
125 struct bufferevent *bufev = arg;
126 struct bufferevent_private *bufev_p =
127 EVUTIL_UPCAST(bufev, struct bufferevent_private, bev);
128 struct evbuffer *input;
129 int res = 0;
130 short what = BEV_EVENT_READING;
131 ev_ssize_t howmuch = -1, readmax=-1;
132
133 _bufferevent_incref_and_lock(bufev);
134
135 if (event == EV_TIMEOUT) {
136 /* Note that we only check for event==EV_TIMEOUT. If
137 * event==EV_TIMEOUT|EV_READ, we can safely ignore the
138 * timeout, since a read has occurred */
139 what |= BEV_EVENT_TIMEOUT;
140 goto error;
141 }
142
143 input = bufev->input;
144
145 /*
146 * If we have a high watermark configured then we don't want to
147 * read more data than would make us reach the watermark.
148 */
149 if (bufev->wm_read.high != 0) {
150 howmuch = bufev->wm_read.high - evbuffer_get_length(input);
151 /* we somehow lowered the watermark, stop reading */
152 if (howmuch <= 0) {
153 bufferevent_wm_suspend_read(bufev);
154 goto done;
155 }
156 }
157 readmax = _bufferevent_get_read_max(bufev_p);
158 if (howmuch < 0 || howmuch > readmax) /* The use of -1 for "unlimited"
159 * uglifies this code. XXXX */
160 howmuch = readmax;
161 if (bufev_p->read_suspended)
162 goto done;
163
164 evbuffer_unfreeze(input, 0);
165 res = evbuffer_read(input, fd, (int)howmuch); /* XXXX evbuffer_read would do better to take and return ev_ssize_t */
166 evbuffer_freeze(input, 0);
167
168 if (res == -1) {
169 int err = evutil_socket_geterror(fd);
170 if (EVUTIL_ERR_RW_RETRIABLE(err))
171 goto reschedule;
172 /* error case */
173 what |= BEV_EVENT_ERROR;
174 } else if (res == 0) {
175 /* eof case */
176 what |= BEV_EVENT_EOF;
177 }
178
179 if (res <= 0)
180 goto error;
181
182 _bufferevent_decrement_read_buckets(bufev_p, res);
183
184 /* Invoke the user callback - must always be called last */
185 if (evbuffer_get_length(input) >= bufev->wm_read.low)
186 _bufferevent_run_readcb(bufev);
187
188 goto done;
189
190 reschedule:
191 goto done;
192
193 error:
194 bufferevent_disable(bufev, EV_READ);
195 _bufferevent_run_eventcb(bufev, what);
196
197 done:
198 _bufferevent_decref_and_unlock(bufev);
199 }
200
201 static void
202 bufferevent_writecb(evutil_socket_t fd, short event, void *arg)
203 {
204 struct bufferevent *bufev = arg;
205 struct bufferevent_private *bufev_p =
206 EVUTIL_UPCAST(bufev, struct bufferevent_private, bev);
207 int res = 0;
208 short what = BEV_EVENT_WRITING;
209 int connected = 0;
210 ev_ssize_t atmost = -1;
211
212 _bufferevent_incref_and_lock(bufev);
213
214 if (event == EV_TIMEOUT) {
215 /* Note that we only check for event==EV_TIMEOUT. If
216 * event==EV_TIMEOUT|EV_WRITE, we can safely ignore the
217 * timeout, since a read has occurred */
218 what |= BEV_EVENT_TIMEOUT;
219 goto error;
220 }
221 if (bufev_p->connecting) {
222 int c = evutil_socket_finished_connecting(fd);
223 /* we need to fake the error if the connection was refused
224 * immediately - usually connection to localhost on BSD */
225 if (bufev_p->connection_refused) {
226 bufev_p->connection_refused = 0;
227 c = -1;
228 }
229
230 if (c == 0)
231 goto done;
232
233 bufev_p->connecting = 0;
234 if (c < 0) {
235 event_del(&bufev->ev_write);
236 event_del(&bufev->ev_read);
237 _bufferevent_run_eventcb(bufev, BEV_EVENT_ERROR);
238 goto done;
239 } else {
240 connected = 1;
241 #ifdef WIN32
242 if (BEV_IS_ASYNC(bufev)) {
243 event_del(&bufev->ev_write);
244 bufferevent_async_set_connected(bufev);
245 _bufferevent_run_eventcb(bufev,
246 BEV_EVENT_CONNECTED);
247 goto done;
248 }
249 #endif
250 _bufferevent_run_eventcb(bufev,
251 BEV_EVENT_CONNECTED);
252 if (!(bufev->enabled & EV_WRITE) ||
253 bufev_p->write_suspended) {
254 event_del(&bufev->ev_write);
255 goto done;
256 }
257 }
258 }
259
260 atmost = _bufferevent_get_write_max(bufev_p);
261
262 if (bufev_p->write_suspended)
263 goto done;
264
265 if (evbuffer_get_length(bufev->output)) {
266 evbuffer_unfreeze(bufev->output, 1);
267 res = evbuffer_write_atmost(bufev->output, fd, atmost);
268 evbuffer_freeze(bufev->output, 1);
269 if (res == -1) {
270 int err = evutil_socket_geterror(fd);
271 if (EVUTIL_ERR_RW_RETRIABLE(err))
272 goto reschedule;
273 what |= BEV_EVENT_ERROR;
274 } else if (res == 0) {
275 /* eof case
276 XXXX Actually, a 0 on write doesn't indicate
277 an EOF. An ECONNRESET might be more typical.
278 */
279 what |= BEV_EVENT_EOF;
280 }
281 if (res <= 0)
282 goto error;
283
284 _bufferevent_decrement_write_buckets(bufev_p, res);
285 }
286
287 if (evbuffer_get_length(bufev->output) == 0) {
288 event_del(&bufev->ev_write);
289 }
290
291 /*
292 * Invoke the user callback if our buffer is drained or below the
293 * low watermark.
294 */
295 if ((res || !connected) &&
296 evbuffer_get_length(bufev->output) <= bufev->wm_write.low) {
297 _bufferevent_run_writecb(bufev);
298 }
299
300 goto done;
301
302 reschedule:
303 if (evbuffer_get_length(bufev->output) == 0) {
304 event_del(&bufev->ev_write);
305 }
306 goto done;
307
308 error:
309 bufferevent_disable(bufev, EV_WRITE);
310 _bufferevent_run_eventcb(bufev, what);
311
312 done:
313 _bufferevent_decref_and_unlock(bufev);
314 }
315
316 struct bufferevent *
317 bufferevent_socket_new(struct event_base *base, evutil_socket_t fd,
318 int options)
319 {
320 struct bufferevent_private *bufev_p;
321 struct bufferevent *bufev;
322
323 #ifdef WIN32
324 if (base && event_base_get_iocp(base))
325 return bufferevent_async_new(base, fd, options);
326 #endif
327
328 if ((bufev_p = mm_calloc(1, sizeof(struct bufferevent_private)))== NULL)
329 return NULL;
330
331 if (bufferevent_init_common(bufev_p, base, &bufferevent_ops_socket,
332 options) < 0) {
333 mm_free(bufev_p);
334 return NULL;
335 }
336 bufev = &bufev_p->bev;
337 evbuffer_set_flags(bufev->output, EVBUFFER_FLAG_DRAINS_TO_FD);
338
339 event_assign(&bufev->ev_read, bufev->ev_base, fd,
340 EV_READ|EV_PERSIST, bufferevent_readcb, bufev);
341 event_assign(&bufev->ev_write, bufev->ev_base, fd,
342 EV_WRITE|EV_PERSIST, bufferevent_writecb, bufev);
343
344 evbuffer_add_cb(bufev->output, bufferevent_socket_outbuf_cb, bufev);
345
346 evbuffer_freeze(bufev->input, 0);
347 evbuffer_freeze(bufev->output, 1);
348
349 return bufev;
350 }
351
352 int
353 bufferevent_socket_connect(struct bufferevent *bev,
354 struct sockaddr *sa, int socklen)
355 {
356 struct bufferevent_private *bufev_p =
357 EVUTIL_UPCAST(bev, struct bufferevent_private, bev);
358
359 evutil_socket_t fd;
360 int r = 0;
361 int result=-1;
362 int ownfd = 0;
363
364 _bufferevent_incref_and_lock(bev);
365
366 if (!bufev_p)
367 goto done;
368
369 fd = bufferevent_getfd(bev);
370 if (fd < 0) {
371 if (!sa)
372 goto done;
373 fd = socket(sa->sa_family, SOCK_STREAM, 0);
374 if (fd < 0)
375 goto done;
376 if (evutil_make_socket_nonblocking(fd)<0)
377 goto done;
378 ownfd = 1;
379 }
380 if (sa) {
381 #ifdef WIN32
382 if (bufferevent_async_can_connect(bev)) {
383 bufferevent_setfd(bev, fd);
384 r = bufferevent_async_connect(bev, fd, sa, socklen);
385 if (r < 0)
386 goto freesock;
387 bufev_p->connecting = 1;
388 result = 0;
389 goto done;
390 } else
391 #endif
392 r = evutil_socket_connect(&fd, sa, socklen);
393 if (r < 0)
394 goto freesock;
395 }
396 #ifdef WIN32
397 /* ConnectEx() isn't always around, even when IOCP is enabled.
398 * Here, we borrow the socket object's write handler to fall back
399 * on a non-blocking connect() when ConnectEx() is unavailable. */
400 if (BEV_IS_ASYNC(bev)) {
401 event_assign(&bev->ev_write, bev->ev_base, fd,
402 EV_WRITE|EV_PERSIST, bufferevent_writecb, bev);
403 }
404 #endif
405 bufferevent_setfd(bev, fd);
406 if (r == 0) {
407 if (! be_socket_enable(bev, EV_WRITE)) {
408 bufev_p->connecting = 1;
409 result = 0;
410 goto done;
411 }
412 } else if (r == 1) {
413 /* The connect succeeded already. How very BSD of it. */
414 result = 0;
415 bufev_p->connecting = 1;
416 event_active(&bev->ev_write, EV_WRITE, 1);
417 } else {
418 /* The connect failed already. How very BSD of it. */
419 bufev_p->connection_refused = 1;
420 bufev_p->connecting = 1;
421 result = 0;
422 event_active(&bev->ev_write, EV_WRITE, 1);
423 }
424
425 goto done;
426
427 freesock:
428 _bufferevent_run_eventcb(bev, BEV_EVENT_ERROR);
429 if (ownfd)
430 evutil_closesocket(fd);
431 /* do something about the error? */
432 done:
433 _bufferevent_decref_and_unlock(bev);
434 return result;
435 }
436
437 static void
438 bufferevent_connect_getaddrinfo_cb(int result, struct evutil_addrinfo *ai,
439 void *arg)
440 {
441 struct bufferevent *bev = arg;
442 struct bufferevent_private *bev_p =
443 EVUTIL_UPCAST(bev, struct bufferevent_private, bev);
444 int r;
445 BEV_LOCK(bev);
446
447 bufferevent_unsuspend_write(bev, BEV_SUSPEND_LOOKUP);
448 bufferevent_unsuspend_read(bev, BEV_SUSPEND_LOOKUP);
449
450 if (result != 0) {
451 bev_p->dns_error = result;
452 _bufferevent_run_eventcb(bev, BEV_EVENT_ERROR);
453 _bufferevent_decref_and_unlock(bev);
454 if (ai)
455 evutil_freeaddrinfo(ai);
456 return;
457 }
458
459 /* XXX use the other addrinfos? */
460 /* XXX use this return value */
461 r = bufferevent_socket_connect(bev, ai->ai_addr, (int)ai->ai_addrlen);
462 (void)r;
463 _bufferevent_decref_and_unlock(bev);
464 evutil_freeaddrinfo(ai);
465 }
466
467 int
468 bufferevent_socket_connect_hostname(struct bufferevent *bev,
469 struct evdns_base *evdns_base, int family, const char *hostname, int port)
470 {
471 char portbuf[10];
472 struct evutil_addrinfo hint;
473 int err;
474 struct bufferevent_private *bev_p =
475 EVUTIL_UPCAST(bev, struct bufferevent_private, bev);
476
477 if (family != AF_INET && family != AF_INET6 && family != AF_UNSPEC)
478 return -1;
479 if (port < 1 || port > 65535)
480 return -1;
481
482 BEV_LOCK(bev);
483 bev_p->dns_error = 0;
484 BEV_UNLOCK(bev);
485
486 evutil_snprintf(portbuf, sizeof(portbuf), "%d", port);
487
488 memset(&hint, 0, sizeof(hint));
489 hint.ai_family = family;
490 hint.ai_protocol = IPPROTO_TCP;
491 hint.ai_socktype = SOCK_STREAM;
492
493 bufferevent_suspend_write(bev, BEV_SUSPEND_LOOKUP);
494 bufferevent_suspend_read(bev, BEV_SUSPEND_LOOKUP);
495
496 bufferevent_incref(bev);
497 err = evutil_getaddrinfo_async(evdns_base, hostname, portbuf,
498 &hint, bufferevent_connect_getaddrinfo_cb, bev);
499
500 if (err == 0) {
501 return 0;
502 } else {
503 bufferevent_unsuspend_write(bev, BEV_SUSPEND_LOOKUP);
504 bufferevent_unsuspend_read(bev, BEV_SUSPEND_LOOKUP);
505 return -1;
506 }
507 }
508
509 int
510 bufferevent_socket_get_dns_error(struct bufferevent *bev)
511 {
512 int rv;
513 struct bufferevent_private *bev_p =
514 EVUTIL_UPCAST(bev, struct bufferevent_private, bev);
515
516 BEV_LOCK(bev);
517 rv = bev_p->dns_error;
518 BEV_LOCK(bev);
519
520 return rv;
521 }
522
523 /*
524 * Create a new buffered event object.
525 *
526 * The read callback is invoked whenever we read new data.
527 * The write callback is invoked whenever the output buffer is drained.
528 * The error callback is invoked on a write/read error or on EOF.
529 *
530 * Both read and write callbacks maybe NULL. The error callback is not
531 * allowed to be NULL and have to be provided always.
532 */
533
534 struct bufferevent *
535 bufferevent_new(evutil_socket_t fd,
536 bufferevent_data_cb readcb, bufferevent_data_cb writecb,
537 bufferevent_event_cb eventcb, void *cbarg)
538 {
539 struct bufferevent *bufev;
540
541 if (!(bufev = bufferevent_socket_new(NULL, fd, 0)))
542 return NULL;
543
544 bufferevent_setcb(bufev, readcb, writecb, eventcb, cbarg);
545
546 return bufev;
547 }
548
549
550 static int
551 be_socket_enable(struct bufferevent *bufev, short event)
552 {
553 if (event & EV_READ) {
554 if (be_socket_add(&bufev->ev_read,&bufev->timeout_read) == -1)
555 return -1;
556 }
557 if (event & EV_WRITE) {
558 if (be_socket_add(&bufev->ev_write,&bufev->timeout_write) == -1)
559 return -1;
560 }
561 return 0;
562 }
563
564 static int
565 be_socket_disable(struct bufferevent *bufev, short event)
566 {
567 struct bufferevent_private *bufev_p =
568 EVUTIL_UPCAST(bufev, struct bufferevent_private, bev);
569 if (event & EV_READ) {
570 if (event_del(&bufev->ev_read) == -1)
571 return -1;
572 }
573 /* Don't actually disable the write if we are trying to connect. */
574 if ((event & EV_WRITE) && ! bufev_p->connecting) {
575 if (event_del(&bufev->ev_write) == -1)
576 return -1;
577 }
578 return 0;
579 }
580
581 static void
582 be_socket_destruct(struct bufferevent *bufev)
583 {
584 struct bufferevent_private *bufev_p =
585 EVUTIL_UPCAST(bufev, struct bufferevent_private, bev);
586 evutil_socket_t fd;
587 EVUTIL_ASSERT(bufev->be_ops == &bufferevent_ops_socket);
588
589 fd = event_get_fd(&bufev->ev_read);
590
591 event_del(&bufev->ev_read);
592 event_del(&bufev->ev_write);
593
594 if ((bufev_p->options & BEV_OPT_CLOSE_ON_FREE) && fd >= 0)
595 EVUTIL_CLOSESOCKET(fd);
596 }
597
598 static int
599 be_socket_adj_timeouts(struct bufferevent *bufev)
600 {
601 int r = 0;
602 if (event_pending(&bufev->ev_read, EV_READ, NULL))
603 if (be_socket_add(&bufev->ev_read, &bufev->timeout_read) < 0)
604 r = -1;
605 if (event_pending(&bufev->ev_write, EV_WRITE, NULL)) {
606 if (be_socket_add(&bufev->ev_write, &bufev->timeout_write) < 0)
607 r = -1;
608 }
609 return r;
610 }
611
612 static int
613 be_socket_flush(struct bufferevent *bev, short iotype,
614 enum bufferevent_flush_mode mode)
615 {
616 return 0;
617 }
618
619
620 static void
621 be_socket_setfd(struct bufferevent *bufev, evutil_socket_t fd)
622 {
623 BEV_LOCK(bufev);
624 EVUTIL_ASSERT(bufev->be_ops == &bufferevent_ops_socket);
625
626 event_del(&bufev->ev_read);
627 event_del(&bufev->ev_write);
628
629 event_assign(&bufev->ev_read, bufev->ev_base, fd,
630 EV_READ|EV_PERSIST, bufferevent_readcb, bufev);
631 event_assign(&bufev->ev_write, bufev->ev_base, fd,
632 EV_WRITE|EV_PERSIST, bufferevent_writecb, bufev);
633
634 if (fd >= 0)
635 bufferevent_enable(bufev, bufev->enabled);
636
637 BEV_UNLOCK(bufev);
638 }
639
640 /* XXXX Should non-socket bufferevents support this? */
641 int
642 bufferevent_priority_set(struct bufferevent *bufev, int priority)
643 {
644 int r = -1;
645
646 BEV_LOCK(bufev);
647 if (bufev->be_ops != &bufferevent_ops_socket)
648 goto done;
649
650 if (event_priority_set(&bufev->ev_read, priority) == -1)
651 goto done;
652 if (event_priority_set(&bufev->ev_write, priority) == -1)
653 goto done;
654
655 r = 0;
656 done:
657 BEV_UNLOCK(bufev);
658 return r;
659 }
660
661 /* XXXX Should non-socket bufferevents support this? */
662 int
663 bufferevent_base_set(struct event_base *base, struct bufferevent *bufev)
664 {
665 int res = -1;
666
667 BEV_LOCK(bufev);
668 if (bufev->be_ops != &bufferevent_ops_socket)
669 goto done;
670
671 bufev->ev_base = base;
672
673 res = event_base_set(base, &bufev->ev_read);
674 if (res == -1)
675 goto done;
676
677 res = event_base_set(base, &bufev->ev_write);
678 done:
679 BEV_UNLOCK(bufev);
680 return res;
681 }
682
683 static int
684 be_socket_ctrl(struct bufferevent *bev, enum bufferevent_ctrl_op op,
685 union bufferevent_ctrl_data *data)
686 {
687 switch (op) {
688 case BEV_CTRL_SET_FD:
689 be_socket_setfd(bev, data->fd);
690 return 0;
691 case BEV_CTRL_GET_FD:
692 data->fd = event_get_fd(&bev->ev_read);
693 return 0;
694 case BEV_CTRL_GET_UNDERLYING:
695 case BEV_CTRL_CANCEL_ALL:
696 default:
697 return -1;
698 }
699 }

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial