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