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