granicus.if.org Git - libevent/blob - bufferevent_sock.c

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