1 /* $NetBSD: bufferevent_sock.c,v 1.1.1.2 2015/01/29 06:38:05 spz Exp $ */
2 /*
3 * Copyright (c) 2007-2012 Niels Provos and Nick Mathewson
4 * Copyright (c) 2002-2006 Niels Provos <provos@citi.umich.edu>
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. The name of the author may not be used to endorse or promote products
16 * derived from this software without specific prior written permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29
30 #include <sys/types.h>
31
32 #include "event2/event-config.h"
33 #include <sys/cdefs.h>
34 __RCSID("$NetBSD: bufferevent_sock.c,v 1.1.1.2 2015/01/29 06:38:05 spz Exp $");
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 be_socket_destruct,
96 be_socket_adj_timeouts,
97 be_socket_flush,
98 be_socket_ctrl,
99 };
100
101 #define be_socket_add(ev, t) \
102 _bufferevent_add_event((ev), (t))
103
104 static void
bufferevent_socket_outbuf_cb(struct evbuffer * buf,const struct evbuffer_cb_info * cbinfo,void * arg)105 bufferevent_socket_outbuf_cb(struct evbuffer *buf,
106 const struct evbuffer_cb_info *cbinfo,
107 void *arg)
108 {
109 struct bufferevent *bufev = arg;
110 struct bufferevent_private *bufev_p =
111 EVUTIL_UPCAST(bufev, struct bufferevent_private, bev);
112
113 if (cbinfo->n_added &&
114 (bufev->enabled & EV_WRITE) &&
115 !event_pending(&bufev->ev_write, EV_WRITE, NULL) &&
116 !bufev_p->write_suspended) {
117 /* Somebody added data to the buffer, and we would like to
118 * write, and we were not writing. So, start writing. */
119 if (be_socket_add(&bufev->ev_write, &bufev->timeout_write) == -1) {
120 /* Should we log this? */
121 }
122 }
123 }
124
125 static void
bufferevent_readcb(evutil_socket_t fd,short event,void * arg)126 bufferevent_readcb(evutil_socket_t fd, short event, void *arg)
127 {
128 struct bufferevent *bufev = arg;
129 struct bufferevent_private *bufev_p =
130 EVUTIL_UPCAST(bufev, struct bufferevent_private, bev);
131 struct evbuffer *input;
132 int res = 0;
133 short what = BEV_EVENT_READING;
134 ev_ssize_t howmuch = -1, readmax=-1;
135
136 _bufferevent_incref_and_lock(bufev);
137
138 if (event == EV_TIMEOUT) {
139 /* Note that we only check for event==EV_TIMEOUT. If
140 * event==EV_TIMEOUT|EV_READ, we can safely ignore the
141 * timeout, since a read has occurred */
142 what |= BEV_EVENT_TIMEOUT;
143 goto error;
144 }
145
146 input = bufev->input;
147
148 /*
149 * If we have a high watermark configured then we don't want to
150 * read more data than would make us reach the watermark.
151 */
152 if (bufev->wm_read.high != 0) {
153 howmuch = bufev->wm_read.high - evbuffer_get_length(input);
154 /* we somehow lowered the watermark, stop reading */
155 if (howmuch <= 0) {
156 bufferevent_wm_suspend_read(bufev);
157 goto done;
158 }
159 }
160 readmax = _bufferevent_get_read_max(bufev_p);
161 if (howmuch < 0 || howmuch > readmax) /* The use of -1 for "unlimited"
162 * uglifies this code. XXXX */
163 howmuch = readmax;
164 if (bufev_p->read_suspended)
165 goto done;
166
167 evbuffer_unfreeze(input, 0);
168 res = evbuffer_read(input, fd, (int)howmuch); /* XXXX evbuffer_read would do better to take and return ev_ssize_t */
169 evbuffer_freeze(input, 0);
170
171 if (res == -1) {
172 int err = evutil_socket_geterror(fd);
173 if (EVUTIL_ERR_RW_RETRIABLE(err))
174 goto reschedule;
175 /* error case */
176 what |= BEV_EVENT_ERROR;
177 } else if (res == 0) {
178 /* eof case */
179 what |= BEV_EVENT_EOF;
180 }
181
182 if (res <= 0)
183 goto error;
184
185 _bufferevent_decrement_read_buckets(bufev_p, res);
186
187 /* Invoke the user callback - must always be called last */
188 if (evbuffer_get_length(input) >= bufev->wm_read.low)
189 _bufferevent_run_readcb(bufev);
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);
199
200 done:
201 _bufferevent_decref_and_unlock(bufev);
202 }
203
204 static void
bufferevent_writecb(evutil_socket_t fd,short event,void * arg)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);
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);
250 goto done;
251 }
252 #endif
253 _bufferevent_run_eventcb(bufev,
254 BEV_EVENT_CONNECTED);
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 evbuffer_get_length(bufev->output) <= bufev->wm_write.low) {
300 _bufferevent_run_writecb(bufev);
301 }
302
303 goto done;
304
305 reschedule:
306 if (evbuffer_get_length(bufev->output) == 0) {
307 event_del(&bufev->ev_write);
308 }
309 goto done;
310
311 error:
312 bufferevent_disable(bufev, EV_WRITE);
313 _bufferevent_run_eventcb(bufev, what);
314
315 done:
316 _bufferevent_decref_and_unlock(bufev);
317 }
318
319 struct bufferevent *
bufferevent_socket_new(struct event_base * base,evutil_socket_t fd,int options)320 bufferevent_socket_new(struct event_base *base, evutil_socket_t fd,
321 int options)
322 {
323 struct bufferevent_private *bufev_p;
324 struct bufferevent *bufev;
325
326 #ifdef WIN32
327 if (base && event_base_get_iocp(base))
328 return bufferevent_async_new(base, fd, options);
329 #endif
330
331 if ((bufev_p = mm_calloc(1, sizeof(struct bufferevent_private)))== NULL)
332 return NULL;
333
334 if (bufferevent_init_common(bufev_p, base, &bufferevent_ops_socket,
335 options) < 0) {
336 mm_free(bufev_p);
337 return NULL;
338 }
339 bufev = &bufev_p->bev;
340 evbuffer_set_flags(bufev->output, EVBUFFER_FLAG_DRAINS_TO_FD);
341
342 event_assign(&bufev->ev_read, bufev->ev_base, fd,
343 EV_READ|EV_PERSIST, bufferevent_readcb, bufev);
344 event_assign(&bufev->ev_write, bufev->ev_base, fd,
345 EV_WRITE|EV_PERSIST, bufferevent_writecb, bufev);
346
347 evbuffer_add_cb(bufev->output, bufferevent_socket_outbuf_cb, bufev);
348
349 evbuffer_freeze(bufev->input, 0);
350 evbuffer_freeze(bufev->output, 1);
351
352 return bufev;
353 }
354
355 int
bufferevent_socket_connect(struct bufferevent * bev,struct sockaddr * sa,int socklen)356 bufferevent_socket_connect(struct bufferevent *bev,
357 struct sockaddr *sa, int socklen)
358 {
359 struct bufferevent_private *bufev_p =
360 EVUTIL_UPCAST(bev, struct bufferevent_private, bev);
361
362 evutil_socket_t fd;
363 int r = 0;
364 int result=-1;
365 int ownfd = 0;
366
367 _bufferevent_incref_and_lock(bev);
368
369 if (!bufev_p)
370 goto done;
371
372 fd = bufferevent_getfd(bev);
373 if (fd < 0) {
374 if (!sa)
375 goto done;
376 fd = socket(sa->sa_family, SOCK_STREAM, 0);
377 if (fd < 0)
378 goto done;
379 if (evutil_make_socket_nonblocking(fd)<0)
380 goto done;
381 ownfd = 1;
382 }
383 if (sa) {
384 #ifdef WIN32
385 if (bufferevent_async_can_connect(bev)) {
386 bufferevent_setfd(bev, fd);
387 r = bufferevent_async_connect(bev, fd, sa, socklen);
388 if (r < 0)
389 goto freesock;
390 bufev_p->connecting = 1;
391 result = 0;
392 goto done;
393 } else
394 #endif
395 r = evutil_socket_connect(&fd, sa, socklen);
396 if (r < 0)
397 goto freesock;
398 }
399 #ifdef WIN32
400 /* ConnectEx() isn't always around, even when IOCP is enabled.
401 * Here, we borrow the socket object's write handler to fall back
402 * on a non-blocking connect() when ConnectEx() is unavailable. */
403 if (BEV_IS_ASYNC(bev)) {
404 event_assign(&bev->ev_write, bev->ev_base, fd,
405 EV_WRITE|EV_PERSIST, bufferevent_writecb, bev);
406 }
407 #endif
408 bufferevent_setfd(bev, fd);
409 if (r == 0) {
410 if (! be_socket_enable(bev, EV_WRITE)) {
411 bufev_p->connecting = 1;
412 result = 0;
413 goto done;
414 }
415 } else if (r == 1) {
416 /* The connect succeeded already. How very BSD of it. */
417 result = 0;
418 bufev_p->connecting = 1;
419 event_active(&bev->ev_write, EV_WRITE, 1);
420 } else {
421 /* The connect failed already. How very BSD of it. */
422 bufev_p->connection_refused = 1;
423 bufev_p->connecting = 1;
424 result = 0;
425 event_active(&bev->ev_write, EV_WRITE, 1);
426 }
427
428 goto done;
429
430 freesock:
431 _bufferevent_run_eventcb(bev, BEV_EVENT_ERROR);
432 if (ownfd)
433 evutil_closesocket(fd);
434 /* do something about the error? */
435 done:
436 _bufferevent_decref_and_unlock(bev);
437 return result;
438 }
439
440 static void
bufferevent_connect_getaddrinfo_cb(int result,struct evutil_addrinfo * ai,void * arg)441 bufferevent_connect_getaddrinfo_cb(int result, struct evutil_addrinfo *ai,
442 void *arg)
443 {
444 struct bufferevent *bev = arg;
445 struct bufferevent_private *bev_p =
446 EVUTIL_UPCAST(bev, struct bufferevent_private, bev);
447 int r;
448 BEV_LOCK(bev);
449
450 bufferevent_unsuspend_write(bev, BEV_SUSPEND_LOOKUP);
451 bufferevent_unsuspend_read(bev, BEV_SUSPEND_LOOKUP);
452
453 if (result != 0) {
454 bev_p->dns_error = result;
455 _bufferevent_run_eventcb(bev, BEV_EVENT_ERROR);
456 _bufferevent_decref_and_unlock(bev);
457 if (ai)
458 evutil_freeaddrinfo(ai);
459 return;
460 }
461
462 /* XXX use the other addrinfos? */
463 /* XXX use this return value */
464 r = bufferevent_socket_connect(bev, ai->ai_addr, (int)ai->ai_addrlen);
465 (void)r;
466 _bufferevent_decref_and_unlock(bev);
467 evutil_freeaddrinfo(ai);
468 }
469
470 int
bufferevent_socket_connect_hostname(struct bufferevent * bev,struct evdns_base * evdns_base,int family,const char * hostname,int port)471 bufferevent_socket_connect_hostname(struct bufferevent *bev,
472 struct evdns_base *evdns_base, int family, const char *hostname, int port)
473 {
474 char portbuf[10];
475 struct evutil_addrinfo hint;
476 int err;
477 struct bufferevent_private *bev_p =
478 EVUTIL_UPCAST(bev, struct bufferevent_private, bev);
479
480 if (family != AF_INET && family != AF_INET6 && family != AF_UNSPEC)
481 return -1;
482 if (port < 1 || port > 65535)
483 return -1;
484
485 BEV_LOCK(bev);
486 bev_p->dns_error = 0;
487 BEV_UNLOCK(bev);
488
489 evutil_snprintf(portbuf, sizeof(portbuf), "%d", port);
490
491 memset(&hint, 0, sizeof(hint));
492 hint.ai_family = family;
493 hint.ai_protocol = IPPROTO_TCP;
494 hint.ai_socktype = SOCK_STREAM;
495
496 bufferevent_suspend_write(bev, BEV_SUSPEND_LOOKUP);
497 bufferevent_suspend_read(bev, BEV_SUSPEND_LOOKUP);
498
499 bufferevent_incref(bev);
500 err = evutil_getaddrinfo_async(evdns_base, hostname, portbuf,
501 &hint, bufferevent_connect_getaddrinfo_cb, bev);
502
503 if (err == 0) {
504 return 0;
505 } else {
506 bufferevent_unsuspend_write(bev, BEV_SUSPEND_LOOKUP);
507 bufferevent_unsuspend_read(bev, BEV_SUSPEND_LOOKUP);
508 return -1;
509 }
510 }
511
512 int
bufferevent_socket_get_dns_error(struct bufferevent * bev)513 bufferevent_socket_get_dns_error(struct bufferevent *bev)
514 {
515 int rv;
516 struct bufferevent_private *bev_p =
517 EVUTIL_UPCAST(bev, struct bufferevent_private, bev);
518
519 BEV_LOCK(bev);
520 rv = bev_p->dns_error;
521 BEV_UNLOCK(bev);
522
523 return rv;
524 }
525
526 /*
527 * Create a new buffered event object.
528 *
529 * The read callback is invoked whenever we read new data.
530 * The write callback is invoked whenever the output buffer is drained.
531 * The error callback is invoked on a write/read error or on EOF.
532 *
533 * Both read and write callbacks maybe NULL. The error callback is not
534 * allowed to be NULL and have to be provided always.
535 */
536
537 struct bufferevent *
bufferevent_new(evutil_socket_t fd,bufferevent_data_cb readcb,bufferevent_data_cb writecb,bufferevent_event_cb eventcb,void * cbarg)538 bufferevent_new(evutil_socket_t fd,
539 bufferevent_data_cb readcb, bufferevent_data_cb writecb,
540 bufferevent_event_cb eventcb, void *cbarg)
541 {
542 struct bufferevent *bufev;
543
544 if (!(bufev = bufferevent_socket_new(NULL, fd, 0)))
545 return NULL;
546
547 bufferevent_setcb(bufev, readcb, writecb, eventcb, cbarg);
548
549 return bufev;
550 }
551
552
553 static int
be_socket_enable(struct bufferevent * bufev,short event)554 be_socket_enable(struct bufferevent *bufev, short event)
555 {
556 if (event & EV_READ) {
557 if (be_socket_add(&bufev->ev_read,&bufev->timeout_read) == -1)
558 return -1;
559 }
560 if (event & EV_WRITE) {
561 if (be_socket_add(&bufev->ev_write,&bufev->timeout_write) == -1)
562 return -1;
563 }
564 return 0;
565 }
566
567 static int
be_socket_disable(struct bufferevent * bufev,short event)568 be_socket_disable(struct bufferevent *bufev, short event)
569 {
570 struct bufferevent_private *bufev_p =
571 EVUTIL_UPCAST(bufev, struct bufferevent_private, bev);
572 if (event & EV_READ) {
573 if (event_del(&bufev->ev_read) == -1)
574 return -1;
575 }
576 /* Don't actually disable the write if we are trying to connect. */
577 if ((event & EV_WRITE) && ! bufev_p->connecting) {
578 if (event_del(&bufev->ev_write) == -1)
579 return -1;
580 }
581 return 0;
582 }
583
584 static void
be_socket_destruct(struct bufferevent * bufev)585 be_socket_destruct(struct bufferevent *bufev)
586 {
587 struct bufferevent_private *bufev_p =
588 EVUTIL_UPCAST(bufev, struct bufferevent_private, bev);
589 evutil_socket_t fd;
590 EVUTIL_ASSERT(bufev->be_ops == &bufferevent_ops_socket);
591
592 fd = event_get_fd(&bufev->ev_read);
593
594 event_del(&bufev->ev_read);
595 event_del(&bufev->ev_write);
596
597 if ((bufev_p->options & BEV_OPT_CLOSE_ON_FREE) && fd >= 0)
598 EVUTIL_CLOSESOCKET(fd);
599 }
600
601 static int
be_socket_adj_timeouts(struct bufferevent * bufev)602 be_socket_adj_timeouts(struct bufferevent *bufev)
603 {
604 int r = 0;
605 if (event_pending(&bufev->ev_read, EV_READ, NULL))
606 if (be_socket_add(&bufev->ev_read, &bufev->timeout_read) < 0)
607 r = -1;
608 if (event_pending(&bufev->ev_write, EV_WRITE, NULL)) {
609 if (be_socket_add(&bufev->ev_write, &bufev->timeout_write) < 0)
610 r = -1;
611 }
612 return r;
613 }
614
615 static int
be_socket_flush(struct bufferevent * bev,short iotype,enum bufferevent_flush_mode mode)616 be_socket_flush(struct bufferevent *bev, short iotype,
617 enum bufferevent_flush_mode mode)
618 {
619 return 0;
620 }
621
622
623 static void
be_socket_setfd(struct bufferevent * bufev,evutil_socket_t fd)624 be_socket_setfd(struct bufferevent *bufev, evutil_socket_t fd)
625 {
626 BEV_LOCK(bufev);
627 EVUTIL_ASSERT(bufev->be_ops == &bufferevent_ops_socket);
628
629 event_del(&bufev->ev_read);
630 event_del(&bufev->ev_write);
631
632 event_assign(&bufev->ev_read, bufev->ev_base, fd,
633 EV_READ|EV_PERSIST, bufferevent_readcb, bufev);
634 event_assign(&bufev->ev_write, bufev->ev_base, fd,
635 EV_WRITE|EV_PERSIST, bufferevent_writecb, bufev);
636
637 if (fd >= 0)
638 bufferevent_enable(bufev, bufev->enabled);
639
640 BEV_UNLOCK(bufev);
641 }
642
643 /* XXXX Should non-socket bufferevents support this? */
644 int
bufferevent_priority_set(struct bufferevent * bufev,int priority)645 bufferevent_priority_set(struct bufferevent *bufev, int priority)
646 {
647 int r = -1;
648
649 BEV_LOCK(bufev);
650 if (bufev->be_ops != &bufferevent_ops_socket)
651 goto done;
652
653 if (event_priority_set(&bufev->ev_read, priority) == -1)
654 goto done;
655 if (event_priority_set(&bufev->ev_write, priority) == -1)
656 goto done;
657
658 r = 0;
659 done:
660 BEV_UNLOCK(bufev);
661 return r;
662 }
663
664 /* XXXX Should non-socket bufferevents support this? */
665 int
bufferevent_base_set(struct event_base * base,struct bufferevent * bufev)666 bufferevent_base_set(struct event_base *base, struct bufferevent *bufev)
667 {
668 int res = -1;
669
670 BEV_LOCK(bufev);
671 if (bufev->be_ops != &bufferevent_ops_socket)
672 goto done;
673
674 bufev->ev_base = base;
675
676 res = event_base_set(base, &bufev->ev_read);
677 if (res == -1)
678 goto done;
679
680 res = event_base_set(base, &bufev->ev_write);
681 done:
682 BEV_UNLOCK(bufev);
683 return res;
684 }
685
686 static int
be_socket_ctrl(struct bufferevent * bev,enum bufferevent_ctrl_op op,union bufferevent_ctrl_data * data)687 be_socket_ctrl(struct bufferevent *bev, enum bufferevent_ctrl_op op,
688 union bufferevent_ctrl_data *data)
689 {
690 switch (op) {
691 case BEV_CTRL_SET_FD:
692 be_socket_setfd(bev, data->fd);
693 return 0;
694 case BEV_CTRL_GET_FD:
695 data->fd = event_get_fd(&bev->ev_read);
696 return 0;
697 case BEV_CTRL_GET_UNDERLYING:
698 case BEV_CTRL_CANCEL_ALL:
699 default:
700 return -1;
701 }
702 }
703