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