2 * Copyright (c) 2009-2012 Niels Provos and Nick Mathewson
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
7 * 1. Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
12 * 3. The name of the author may not be used to endorse or promote products
13 * derived from this software without specific prior written permission.
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 #include <sys/types.h>
29 #include "event2/event-config.h"
31 #ifdef _EVENT_HAVE_SYS_TIME_H
39 #ifdef _EVENT_HAVE_STDARG_H
42 #ifdef _EVENT_HAVE_UNISTD_H
50 #include "event2/bufferevent.h"
51 #include "event2/bufferevent_struct.h"
52 #include "event2/bufferevent_ssl.h"
53 #include "event2/buffer.h"
54 #include "event2/event.h"
56 #include "mm-internal.h"
57 #include "bufferevent-internal.h"
58 #include "log-internal.h"
60 #include <openssl/bio.h>
61 #include <openssl/ssl.h>
62 #include <openssl/err.h>
65 * Define an OpenSSL bio that targets a bufferevent.
68 /* --------------------
69 A BIO is an OpenSSL abstraction that handles reading and writing data. The
70 library will happily speak SSL over anything that implements a BIO
73 Here we define a BIO implementation that directs its output to a
74 bufferevent. We'll want to use this only when none of OpenSSL's built-in
75 IO mechanisms work for us.
76 -------------------- */
78 /* every BIO type needs its own integer type value. */
79 #define BIO_TYPE_LIBEVENT 57
80 /* ???? Arguably, we should set BIO_TYPE_FILTER or BIO_TYPE_SOURCE_SINK on
88 printf("Error was %d\n", val
);
90 while ((err
= ERR_get_error()))x
{
91 const char *msg
= (const char*)ERR_reason_error_string(err
);
92 const char *lib
= (const char*)ERR_lib_error_string(err
);
93 const char *func
= (const char*)ERR_func_error_string(err
);
95 printf("%s in %s %s\n", msg
, lib
, func
);
99 #define print_err(v) ((void)0)
102 /* Called to initialize a new BIO */
104 bio_bufferevent_new(BIO
*b
)
108 b
->ptr
= NULL
; /* We'll be putting the bufferevent in this field.*/
113 /* Called to uninitialize the BIO. */
115 bio_bufferevent_free(BIO
*b
)
120 if (b
->init
&& b
->ptr
)
121 bufferevent_free(b
->ptr
);
129 /* Called to extract data from the BIO. */
131 bio_bufferevent_read(BIO
*b
, char *out
, int outlen
)
134 struct evbuffer
*input
;
136 BIO_clear_retry_flags(b
);
143 input
= bufferevent_get_input(b
->ptr
);
144 if (evbuffer_get_length(input
) == 0) {
145 /* If there's no data to read, say so. */
146 BIO_set_retry_read(b
);
149 r
= evbuffer_remove(input
, out
, outlen
);
155 /* Called to write data info the BIO */
157 bio_bufferevent_write(BIO
*b
, const char *in
, int inlen
)
159 struct bufferevent
*bufev
= b
->ptr
;
160 struct evbuffer
*output
;
163 BIO_clear_retry_flags(b
);
168 output
= bufferevent_get_output(bufev
);
169 outlen
= evbuffer_get_length(output
);
171 /* Copy only as much data onto the output buffer as can fit under the
172 * high-water mark. */
173 if (bufev
->wm_write
.high
&& bufev
->wm_write
.high
<= (outlen
+inlen
)) {
174 if (bufev
->wm_write
.high
<= outlen
) {
175 /* If no data can fit, we'll need to retry later. */
176 BIO_set_retry_write(b
);
179 inlen
= bufev
->wm_write
.high
- outlen
;
182 EVUTIL_ASSERT(inlen
> 0);
183 evbuffer_add(output
, in
, inlen
);
187 /* Called to handle various requests */
189 bio_bufferevent_ctrl(BIO
*b
, int cmd
, long num
, void *ptr
)
191 struct bufferevent
*bufev
= b
->ptr
;
195 case BIO_CTRL_GET_CLOSE
:
198 case BIO_CTRL_SET_CLOSE
:
199 b
->shutdown
= (int)num
;
201 case BIO_CTRL_PENDING
:
202 ret
= evbuffer_get_length(bufferevent_get_input(bufev
)) != 0;
204 case BIO_CTRL_WPENDING
:
205 ret
= evbuffer_get_length(bufferevent_get_output(bufev
)) != 0;
207 /* XXXX These two are given a special-case treatment because
208 * of cargo-cultism. I should come up with a better reason. */
220 /* Called to write a string to the BIO */
222 bio_bufferevent_puts(BIO
*b
, const char *s
)
224 return bio_bufferevent_write(b
, s
, strlen(s
));
227 /* Method table for the bufferevent BIO */
228 static BIO_METHOD methods_bufferevent
= {
229 BIO_TYPE_LIBEVENT
, "bufferevent",
230 bio_bufferevent_write
,
231 bio_bufferevent_read
,
232 bio_bufferevent_puts
,
233 NULL
/* bio_bufferevent_gets */,
234 bio_bufferevent_ctrl
,
236 bio_bufferevent_free
,
237 NULL
/* callback_ctrl */,
240 /* Return the method table for the bufferevents BIO */
242 BIO_s_bufferevent(void)
244 return &methods_bufferevent
;
247 /* Create a new BIO to wrap communication around a bufferevent. If close_flag
248 * is true, the bufferevent will be freed when the BIO is closed. */
250 BIO_new_bufferevent(struct bufferevent
*bufferevent
, int close_flag
)
255 if (!(result
= BIO_new(BIO_s_bufferevent())))
258 result
->ptr
= bufferevent
;
259 result
->shutdown
= close_flag
? 1 : 0;
263 /* --------------------
264 Now, here's the OpenSSL-based implementation of bufferevent.
266 The implementation comes in two flavors: one that connects its SSL object
267 to an underlying bufferevent using a BIO_bufferevent, and one that has the
268 SSL object connect to a socket directly. The latter should generally be
269 faster, except on Windows, where your best bet is using a
272 (OpenSSL supports many other BIO types, too. But we can't use any unless
273 we have a good way to get notified when they become readable/writable.)
274 -------------------- */
276 struct bio_data_counts
{
277 unsigned long n_written
;
278 unsigned long n_read
;
281 struct bufferevent_openssl
{
282 /* Shared fields with common bufferevent implementation code.
283 If we were set up with an underlying bufferevent, we use the
284 events here as timers only. If we have an SSL, then we use
285 the events as socket events.
287 struct bufferevent_private bev
;
288 /* An underlying bufferevent that we're directing our output to.
289 If it's NULL, then we're connected to an fd, not an evbuffer. */
290 struct bufferevent
*underlying
;
291 /* The SSL object doing our encryption. */
294 /* A callback that's invoked when data arrives on our outbuf so we
295 know to write data to the SSL. */
296 struct evbuffer_cb_entry
*outbuf_cb
;
298 /* A count of how much data the bios have read/written total. Used
299 for rate-limiting. */
300 struct bio_data_counts counts
;
302 /* If this value is greater than 0, then the last SSL_write blocked,
303 * and we need to try it again with this many bytes. */
304 ev_ssize_t last_write
;
307 ev_uint32_t errors
[NUM_ERRORS
];
309 /* When we next get available space, we should say "read" instead of
310 "write". This can happen if there's a renegotiation during a read
312 unsigned read_blocked_on_write
: 1;
313 /* When we next get data, we should say "write" instead of "read". */
314 unsigned write_blocked_on_read
: 1;
316 unsigned allow_dirty_shutdown
: 1;
318 unsigned fd_is_set
: 1;
320 unsigned n_errors
: 2;
322 /* Are we currently connecting, accepting, or doing IO? */
326 static int be_openssl_enable(struct bufferevent
*, short);
327 static int be_openssl_disable(struct bufferevent
*, short);
328 static void be_openssl_destruct(struct bufferevent
*);
329 static int be_openssl_adj_timeouts(struct bufferevent
*);
330 static int be_openssl_flush(struct bufferevent
*bufev
,
331 short iotype
, enum bufferevent_flush_mode mode
);
332 static int be_openssl_ctrl(struct bufferevent
*, enum bufferevent_ctrl_op
, union bufferevent_ctrl_data
*);
334 const struct bufferevent_ops bufferevent_ops_openssl
= {
336 evutil_offsetof(struct bufferevent_openssl
, bev
.bev
),
340 be_openssl_adj_timeouts
,
345 /* Given a bufferevent, return a pointer to the bufferevent_openssl that
346 * contains it, if any. */
347 static inline struct bufferevent_openssl
*
348 upcast(struct bufferevent
*bev
)
350 struct bufferevent_openssl
*bev_o
;
351 if (bev
->be_ops
!= &bufferevent_ops_openssl
)
353 bev_o
= (void*)( ((char*)bev
) -
354 evutil_offsetof(struct bufferevent_openssl
, bev
.bev
));
355 EVUTIL_ASSERT(bev_o
->bev
.bev
.be_ops
== &bufferevent_ops_openssl
);
360 put_error(struct bufferevent_openssl
*bev_ssl
, unsigned long err
)
362 if (bev_ssl
->n_errors
== NUM_ERRORS
)
364 /* The error type according to openssl is "unsigned long", but
365 openssl never uses more than 32 bits of it. It _can't_ use more
366 than 32 bits of it, since it needs to report errors on systems
367 where long is only 32 bits.
369 bev_ssl
->errors
[bev_ssl
->n_errors
++] = (ev_uint32_t
) err
;
372 /* Have the base communications channel (either the underlying bufferevent or
373 * ev_read and ev_write) start reading. Take the read-blocked-on-write flag
376 start_reading(struct bufferevent_openssl
*bev_ssl
)
378 if (bev_ssl
->underlying
) {
379 bufferevent_unsuspend_read(bev_ssl
->underlying
,
380 BEV_SUSPEND_FILT_READ
);
383 struct bufferevent
*bev
= &bev_ssl
->bev
.bev
;
385 r
= _bufferevent_add_event(&bev
->ev_read
, &bev
->timeout_read
);
386 if (r
== 0 && bev_ssl
->read_blocked_on_write
)
387 r
= _bufferevent_add_event(&bev
->ev_write
,
388 &bev
->timeout_write
);
393 /* Have the base communications channel (either the underlying bufferevent or
394 * ev_read and ev_write) start writing. Take the write-blocked-on-read flag
397 start_writing(struct bufferevent_openssl
*bev_ssl
)
400 if (bev_ssl
->underlying
) {
403 struct bufferevent
*bev
= &bev_ssl
->bev
.bev
;
404 r
= _bufferevent_add_event(&bev
->ev_write
, &bev
->timeout_write
);
405 if (!r
&& bev_ssl
->write_blocked_on_read
)
406 r
= _bufferevent_add_event(&bev
->ev_read
,
413 stop_reading(struct bufferevent_openssl
*bev_ssl
)
415 if (bev_ssl
->write_blocked_on_read
)
417 if (bev_ssl
->underlying
) {
418 bufferevent_suspend_read(bev_ssl
->underlying
,
419 BEV_SUSPEND_FILT_READ
);
421 struct bufferevent
*bev
= &bev_ssl
->bev
.bev
;
422 event_del(&bev
->ev_read
);
427 stop_writing(struct bufferevent_openssl
*bev_ssl
)
429 if (bev_ssl
->read_blocked_on_write
)
431 if (bev_ssl
->underlying
) {
434 struct bufferevent
*bev
= &bev_ssl
->bev
.bev
;
435 event_del(&bev
->ev_write
);
440 set_rbow(struct bufferevent_openssl
*bev_ssl
)
442 if (!bev_ssl
->underlying
)
443 stop_reading(bev_ssl
);
444 bev_ssl
->read_blocked_on_write
= 1;
445 return start_writing(bev_ssl
);
449 set_wbor(struct bufferevent_openssl
*bev_ssl
)
451 if (!bev_ssl
->underlying
)
452 stop_writing(bev_ssl
);
453 bev_ssl
->write_blocked_on_read
= 1;
454 return start_reading(bev_ssl
);
458 clear_rbow(struct bufferevent_openssl
*bev_ssl
)
460 struct bufferevent
*bev
= &bev_ssl
->bev
.bev
;
462 bev_ssl
->read_blocked_on_write
= 0;
463 if (!(bev
->enabled
& EV_WRITE
))
464 stop_writing(bev_ssl
);
465 if (bev
->enabled
& EV_READ
)
466 r
= start_reading(bev_ssl
);
472 clear_wbor(struct bufferevent_openssl
*bev_ssl
)
474 struct bufferevent
*bev
= &bev_ssl
->bev
.bev
;
476 bev_ssl
->write_blocked_on_read
= 0;
477 if (!(bev
->enabled
& EV_READ
))
478 stop_reading(bev_ssl
);
479 if (bev
->enabled
& EV_WRITE
)
480 r
= start_writing(bev_ssl
);
485 conn_closed(struct bufferevent_openssl
*bev_ssl
, int errcode
, int ret
)
487 int event
= BEV_EVENT_ERROR
;
488 int dirty_shutdown
= 0;
492 case SSL_ERROR_ZERO_RETURN
:
493 /* Possibly a clean shutdown. */
494 if (SSL_get_shutdown(bev_ssl
->ssl
) & SSL_RECEIVED_SHUTDOWN
)
495 event
= BEV_EVENT_EOF
;
499 case SSL_ERROR_SYSCALL
:
500 /* IO error; possibly a dirty shutdown. */
501 if (ret
== 0 && ERR_peek_error() == 0)
505 /* Protocol error. */
507 case SSL_ERROR_WANT_X509_LOOKUP
:
508 /* XXXX handle this. */
511 case SSL_ERROR_WANT_READ
:
512 case SSL_ERROR_WANT_WRITE
:
513 case SSL_ERROR_WANT_CONNECT
:
514 case SSL_ERROR_WANT_ACCEPT
:
516 /* should be impossible; treat as normal error. */
517 event_warnx("BUG: Unexpected OpenSSL error code %d", errcode
);
521 while ((err
= ERR_get_error())) {
522 put_error(bev_ssl
, err
);
525 if (dirty_shutdown
&& bev_ssl
->allow_dirty_shutdown
)
526 event
= BEV_EVENT_EOF
;
528 stop_reading(bev_ssl
);
529 stop_writing(bev_ssl
);
531 _bufferevent_run_eventcb(&bev_ssl
->bev
.bev
, event
);
535 init_bio_counts(struct bufferevent_openssl
*bev_ssl
)
537 bev_ssl
->counts
.n_written
=
538 BIO_number_written(SSL_get_wbio(bev_ssl
->ssl
));
539 bev_ssl
->counts
.n_read
=
540 BIO_number_read(SSL_get_rbio(bev_ssl
->ssl
));
544 decrement_buckets(struct bufferevent_openssl
*bev_ssl
)
546 unsigned long num_w
= BIO_number_written(SSL_get_wbio(bev_ssl
->ssl
));
547 unsigned long num_r
= BIO_number_read(SSL_get_rbio(bev_ssl
->ssl
));
548 /* These next two subtractions can wrap around. That's okay. */
549 unsigned long w
= num_w
- bev_ssl
->counts
.n_written
;
550 unsigned long r
= num_r
- bev_ssl
->counts
.n_read
;
552 _bufferevent_decrement_write_buckets(&bev_ssl
->bev
, w
);
554 _bufferevent_decrement_read_buckets(&bev_ssl
->bev
, r
);
555 bev_ssl
->counts
.n_written
= num_w
;
556 bev_ssl
->counts
.n_read
= num_r
;
559 /* returns -1 on internal error, 0 on stall, 1 on progress */
561 do_read(struct bufferevent_openssl
*bev_ssl
, int n_to_read
)
564 struct bufferevent
*bev
= &bev_ssl
->bev
.bev
;
565 struct evbuffer
*input
= bev
->input
;
566 int r
, n
, i
, n_used
= 0, blocked
= 0, atmost
;
567 struct evbuffer_iovec space
[2];
569 atmost
= _bufferevent_get_read_max(&bev_ssl
->bev
);
570 if (n_to_read
> atmost
)
573 n
= evbuffer_reserve_space(input
, n_to_read
, space
, 2);
577 for (i
=0; i
<n
; ++i
) {
578 if (bev_ssl
->bev
.read_suspended
)
580 r
= SSL_read(bev_ssl
->ssl
, space
[i
].iov_base
, space
[i
].iov_len
);
582 if (bev_ssl
->read_blocked_on_write
)
583 if (clear_rbow(bev_ssl
) < 0)
586 space
[i
].iov_len
= r
;
587 decrement_buckets(bev_ssl
);
589 int err
= SSL_get_error(bev_ssl
->ssl
, r
);
592 case SSL_ERROR_WANT_READ
:
593 /* Can't read until underlying has more data. */
594 if (bev_ssl
->read_blocked_on_write
)
595 if (clear_rbow(bev_ssl
) < 0)
598 case SSL_ERROR_WANT_WRITE
:
599 /* This read operation requires a write, and the
600 * underlying is full */
601 if (!bev_ssl
->read_blocked_on_write
)
602 if (set_rbow(bev_ssl
) < 0)
606 conn_closed(bev_ssl
, err
, r
);
610 break; /* out of the loop */
615 evbuffer_commit_space(input
, space
, n_used
);
616 if (bev_ssl
->underlying
)
617 BEV_RESET_GENERIC_READ_TIMEOUT(bev
);
620 return blocked
? 0 : 1;
624 do_write(struct bufferevent_openssl
*bev_ssl
, int atmost
)
626 int i
, r
, n
, n_written
= 0, blocked
=0;
627 struct bufferevent
*bev
= &bev_ssl
->bev
.bev
;
628 struct evbuffer
*output
= bev
->output
;
629 struct evbuffer_iovec space
[8];
631 if (bev_ssl
->last_write
> 0)
632 atmost
= bev_ssl
->last_write
;
634 atmost
= _bufferevent_get_write_max(&bev_ssl
->bev
);
636 n
= evbuffer_peek(output
, atmost
, NULL
, space
, 8);
642 for (i
=0; i
< n
; ++i
) {
643 if (bev_ssl
->bev
.write_suspended
)
646 /* SSL_write will (reasonably) return 0 if we tell it to
647 send 0 data. Skip this case so we don't interpret the
648 result as an error */
649 if (space
[i
].iov_len
== 0)
652 r
= SSL_write(bev_ssl
->ssl
, space
[i
].iov_base
,
655 if (bev_ssl
->write_blocked_on_read
)
656 if (clear_wbor(bev_ssl
) < 0)
659 bev_ssl
->last_write
= -1;
660 decrement_buckets(bev_ssl
);
662 int err
= SSL_get_error(bev_ssl
->ssl
, r
);
665 case SSL_ERROR_WANT_WRITE
:
666 /* Can't read until underlying has more data. */
667 if (bev_ssl
->write_blocked_on_read
)
668 if (clear_wbor(bev_ssl
) < 0)
670 bev_ssl
->last_write
= space
[i
].iov_len
;
672 case SSL_ERROR_WANT_READ
:
673 /* This read operation requires a write, and the
674 * underlying is full */
675 if (!bev_ssl
->write_blocked_on_read
)
676 if (set_wbor(bev_ssl
) < 0)
678 bev_ssl
->last_write
= space
[i
].iov_len
;
681 conn_closed(bev_ssl
, err
, r
);
682 bev_ssl
->last_write
= -1;
690 evbuffer_drain(output
, n_written
);
691 if (bev_ssl
->underlying
)
692 BEV_RESET_GENERIC_WRITE_TIMEOUT(bev
);
694 if (evbuffer_get_length(output
) <= bev
->wm_write
.low
)
695 _bufferevent_run_writecb(bev
);
697 return blocked
? 0 : 1;
700 #define WRITE_FRAME 15000
702 #define READ_DEFAULT 4096
704 /* Try to figure out how many bytes to read; return 0 if we shouldn't be
707 bytes_to_read(struct bufferevent_openssl
*bev
)
709 struct evbuffer
*input
= bev
->bev
.bev
.input
;
710 struct event_watermark
*wm
= &bev
->bev
.bev
.wm_read
;
711 int result
= READ_DEFAULT
;
713 /* XXX 99% of this is generic code that nearly all bufferevents will
716 if (bev
->write_blocked_on_read
) {
720 if (! (bev
->bev
.bev
.enabled
& EV_READ
)) {
724 if (bev
->bev
.read_suspended
) {
729 if (evbuffer_get_length(input
) >= wm
->high
) {
733 result
= wm
->high
- evbuffer_get_length(input
);
735 result
= READ_DEFAULT
;
738 /* Respect the rate limit */
739 limit
= _bufferevent_get_read_max(&bev
->bev
);
740 if (result
> limit
) {
748 /* Things look readable. If write is blocked on read, write till it isn't.
749 * Read from the underlying buffer until we block or we hit our high-water
753 consider_reading(struct bufferevent_openssl
*bev_ssl
)
759 while (bev_ssl
->write_blocked_on_read
) {
760 r
= do_write(bev_ssl
, WRITE_FRAME
);
764 if (bev_ssl
->write_blocked_on_read
)
767 n_to_read
= bytes_to_read(bev_ssl
);
770 if (do_read(bev_ssl
, n_to_read
) <= 0)
775 /* Read all pending data. This won't hit the network
776 * again, and will (most importantly) put us in a state
777 * where we don't need to read anything else until the
778 * socket is readable again. It'll potentially make us
779 * overrun our read high-watermark (somewhat
780 * regrettable). The damage to the rate-limit has
781 * already been done, since OpenSSL went and read a
782 * whole SSL record anyway. */
783 n_to_read
= SSL_pending(bev_ssl
->ssl
);
785 /* XXX This if statement is actually a bad bug, added to avoid
788 * The bad bug: It can potentially cause resource unfairness
789 * by reading too much data from the underlying bufferevent;
790 * it can potentially cause read looping if the underlying
791 * bufferevent is a bufferevent_pair and deferred callbacks
794 * The worse bug: If we didn't do this, then we would
795 * potentially not read any more from bev_ssl->underlying
796 * until more data arrived there, which could lead to us
799 if (!n_to_read
&& bev_ssl
->underlying
)
800 n_to_read
= bytes_to_read(bev_ssl
);
803 if (read_data
== 1) {
804 struct bufferevent
*bev
= &bev_ssl
->bev
.bev
;
805 struct evbuffer
*input
= bev
->input
;
807 if (evbuffer_get_length(input
) >= bev
->wm_read
.low
) {
808 _bufferevent_run_readcb(bev
);
812 if (!bev_ssl
->underlying
) {
813 /* Should be redundant, but let's avoid busy-looping */
814 if (bev_ssl
->bev
.read_suspended
||
815 !(bev_ssl
->bev
.bev
.enabled
& EV_READ
)) {
816 event_del(&bev_ssl
->bev
.bev
.ev_read
);
822 consider_writing(struct bufferevent_openssl
*bev_ssl
)
825 struct evbuffer
*output
= bev_ssl
->bev
.bev
.output
;
826 struct evbuffer
*target
= NULL
;
827 struct event_watermark
*wm
= NULL
;
829 while (bev_ssl
->read_blocked_on_write
) {
830 r
= do_read(bev_ssl
, 1024); /* XXXX 1024 is a hack */
834 struct bufferevent
*bev
= &bev_ssl
->bev
.bev
;
835 struct evbuffer
*input
= bev
->input
;
837 if (evbuffer_get_length(input
) >= bev
->wm_read
.low
) {
838 _bufferevent_run_readcb(bev
);
842 if (bev_ssl
->read_blocked_on_write
)
844 if (bev_ssl
->underlying
) {
845 target
= bev_ssl
->underlying
->output
;
846 wm
= &bev_ssl
->underlying
->wm_write
;
848 while ((bev_ssl
->bev
.bev
.enabled
& EV_WRITE
) &&
849 (! bev_ssl
->bev
.write_suspended
) &&
850 evbuffer_get_length(output
) &&
851 (!target
|| (! wm
->high
|| evbuffer_get_length(target
) < wm
->high
))) {
854 n_to_write
= wm
->high
- evbuffer_get_length(target
);
856 n_to_write
= WRITE_FRAME
;
857 r
= do_write(bev_ssl
, n_to_write
);
862 if (!bev_ssl
->underlying
) {
863 if (evbuffer_get_length(output
) == 0) {
864 event_del(&bev_ssl
->bev
.bev
.ev_write
);
865 } else if (bev_ssl
->bev
.write_suspended
||
866 !(bev_ssl
->bev
.bev
.enabled
& EV_WRITE
)) {
867 /* Should be redundant, but let's avoid busy-looping */
868 event_del(&bev_ssl
->bev
.bev
.ev_write
);
874 be_openssl_readcb(struct bufferevent
*bev_base
, void *ctx
)
876 struct bufferevent_openssl
*bev_ssl
= ctx
;
877 consider_reading(bev_ssl
);
881 be_openssl_writecb(struct bufferevent
*bev_base
, void *ctx
)
883 struct bufferevent_openssl
*bev_ssl
= ctx
;
884 consider_writing(bev_ssl
);
888 be_openssl_eventcb(struct bufferevent
*bev_base
, short what
, void *ctx
)
890 struct bufferevent_openssl
*bev_ssl
= ctx
;
893 if (what
& BEV_EVENT_EOF
) {
894 if (bev_ssl
->allow_dirty_shutdown
)
895 event
= BEV_EVENT_EOF
;
897 event
= BEV_EVENT_ERROR
;
898 } else if (what
& BEV_EVENT_TIMEOUT
) {
899 /* We sure didn't set this. Propagate it to the user. */
901 } else if (what
& BEV_EVENT_ERROR
) {
902 /* An error occurred on the connection. Propagate it to the user. */
904 } else if (what
& BEV_EVENT_CONNECTED
) {
905 /* Ignore it. We're saying SSL_connect() already, which will
909 _bufferevent_run_eventcb(&bev_ssl
->bev
.bev
, event
);
913 be_openssl_readeventcb(evutil_socket_t fd
, short what
, void *ptr
)
915 struct bufferevent_openssl
*bev_ssl
= ptr
;
916 _bufferevent_incref_and_lock(&bev_ssl
->bev
.bev
);
917 if (what
& EV_TIMEOUT
) {
918 _bufferevent_run_eventcb(&bev_ssl
->bev
.bev
,
919 BEV_EVENT_TIMEOUT
|BEV_EVENT_READING
);
921 consider_reading(bev_ssl
);
922 _bufferevent_decref_and_unlock(&bev_ssl
->bev
.bev
);
926 be_openssl_writeeventcb(evutil_socket_t fd
, short what
, void *ptr
)
928 struct bufferevent_openssl
*bev_ssl
= ptr
;
929 _bufferevent_incref_and_lock(&bev_ssl
->bev
.bev
);
930 if (what
& EV_TIMEOUT
) {
931 _bufferevent_run_eventcb(&bev_ssl
->bev
.bev
,
932 BEV_EVENT_TIMEOUT
|BEV_EVENT_WRITING
);
934 consider_writing(bev_ssl
);
935 _bufferevent_decref_and_unlock(&bev_ssl
->bev
.bev
);
939 set_open_callbacks(struct bufferevent_openssl
*bev_ssl
, evutil_socket_t fd
)
941 if (bev_ssl
->underlying
) {
942 bufferevent_setcb(bev_ssl
->underlying
,
943 be_openssl_readcb
, be_openssl_writecb
, be_openssl_eventcb
,
947 struct bufferevent
*bev
= &bev_ssl
->bev
.bev
;
948 int rpending
=0, wpending
=0, r1
=0, r2
=0;
949 if (fd
< 0 && bev_ssl
->fd_is_set
)
950 fd
= event_get_fd(&bev
->ev_read
);
951 if (bev_ssl
->fd_is_set
) {
952 rpending
= event_pending(&bev
->ev_read
, EV_READ
, NULL
);
953 wpending
= event_pending(&bev
->ev_write
, EV_WRITE
, NULL
);
954 event_del(&bev
->ev_read
);
955 event_del(&bev
->ev_write
);
957 event_assign(&bev
->ev_read
, bev
->ev_base
, fd
,
958 EV_READ
|EV_PERSIST
, be_openssl_readeventcb
, bev_ssl
);
959 event_assign(&bev
->ev_write
, bev
->ev_base
, fd
,
960 EV_WRITE
|EV_PERSIST
, be_openssl_writeeventcb
, bev_ssl
);
962 r1
= _bufferevent_add_event(&bev
->ev_read
, &bev
->timeout_read
);
964 r2
= _bufferevent_add_event(&bev
->ev_write
, &bev
->timeout_write
);
966 bev_ssl
->fd_is_set
= 1;
968 return (r1
<0 || r2
<0) ? -1 : 0;
973 do_handshake(struct bufferevent_openssl
*bev_ssl
)
977 switch (bev_ssl
->state
) {
979 case BUFFEREVENT_SSL_OPEN
:
982 case BUFFEREVENT_SSL_CONNECTING
:
983 case BUFFEREVENT_SSL_ACCEPTING
:
984 r
= SSL_do_handshake(bev_ssl
->ssl
);
987 decrement_buckets(bev_ssl
);
991 bev_ssl
->state
= BUFFEREVENT_SSL_OPEN
;
992 set_open_callbacks(bev_ssl
, -1); /* XXXX handle failure */
993 /* Call do_read and do_write as needed */
994 bufferevent_enable(&bev_ssl
->bev
.bev
, bev_ssl
->bev
.bev
.enabled
);
995 _bufferevent_run_eventcb(&bev_ssl
->bev
.bev
,
996 BEV_EVENT_CONNECTED
);
999 int err
= SSL_get_error(bev_ssl
->ssl
, r
);
1002 case SSL_ERROR_WANT_WRITE
:
1003 if (!bev_ssl
->underlying
) {
1004 stop_reading(bev_ssl
);
1005 return start_writing(bev_ssl
);
1008 case SSL_ERROR_WANT_READ
:
1009 if (!bev_ssl
->underlying
) {
1010 stop_writing(bev_ssl
);
1011 return start_reading(bev_ssl
);
1015 conn_closed(bev_ssl
, err
, r
);
1022 be_openssl_handshakecb(struct bufferevent
*bev_base
, void *ctx
)
1024 struct bufferevent_openssl
*bev_ssl
= ctx
;
1025 do_handshake(bev_ssl
);/* XXX handle failure */
1029 be_openssl_handshakeeventcb(evutil_socket_t fd
, short what
, void *ptr
)
1031 struct bufferevent_openssl
*bev_ssl
= ptr
;
1033 _bufferevent_incref_and_lock(&bev_ssl
->bev
.bev
);
1034 if (what
& EV_TIMEOUT
) {
1035 _bufferevent_run_eventcb(&bev_ssl
->bev
.bev
, BEV_EVENT_TIMEOUT
);
1037 do_handshake(bev_ssl
);/* XXX handle failure */
1038 _bufferevent_decref_and_unlock(&bev_ssl
->bev
.bev
);
1042 set_handshake_callbacks(struct bufferevent_openssl
*bev_ssl
, evutil_socket_t fd
)
1044 if (bev_ssl
->underlying
) {
1045 bufferevent_setcb(bev_ssl
->underlying
,
1046 be_openssl_handshakecb
, be_openssl_handshakecb
,
1049 return do_handshake(bev_ssl
);
1051 struct bufferevent
*bev
= &bev_ssl
->bev
.bev
;
1053 if (fd
< 0 && bev_ssl
->fd_is_set
)
1054 fd
= event_get_fd(&bev
->ev_read
);
1055 if (bev_ssl
->fd_is_set
) {
1056 event_del(&bev
->ev_read
);
1057 event_del(&bev
->ev_write
);
1059 event_assign(&bev
->ev_read
, bev
->ev_base
, fd
,
1060 EV_READ
|EV_PERSIST
, be_openssl_handshakeeventcb
, bev_ssl
);
1061 event_assign(&bev
->ev_write
, bev
->ev_base
, fd
,
1062 EV_WRITE
|EV_PERSIST
, be_openssl_handshakeeventcb
, bev_ssl
);
1064 r1
= _bufferevent_add_event(&bev
->ev_read
, &bev
->timeout_read
);
1065 r2
= _bufferevent_add_event(&bev
->ev_write
, &bev
->timeout_write
);
1066 bev_ssl
->fd_is_set
= 1;
1068 return (r1
<0 || r2
<0) ? -1 : 0;
1073 bufferevent_ssl_renegotiate(struct bufferevent
*bev
)
1075 struct bufferevent_openssl
*bev_ssl
= upcast(bev
);
1078 if (SSL_renegotiate(bev_ssl
->ssl
) < 0)
1080 bev_ssl
->state
= BUFFEREVENT_SSL_CONNECTING
;
1081 if (set_handshake_callbacks(bev_ssl
, -1) < 0)
1083 if (!bev_ssl
->underlying
)
1084 return do_handshake(bev_ssl
);
1089 be_openssl_outbuf_cb(struct evbuffer
*buf
,
1090 const struct evbuffer_cb_info
*cbinfo
, void *arg
)
1092 struct bufferevent_openssl
*bev_ssl
= arg
;
1094 /* XXX need to hold a reference here. */
1096 if (cbinfo
->n_added
&& bev_ssl
->state
== BUFFEREVENT_SSL_OPEN
) {
1097 if (cbinfo
->orig_size
== 0)
1098 r
= _bufferevent_add_event(&bev_ssl
->bev
.bev
.ev_write
,
1099 &bev_ssl
->bev
.bev
.timeout_write
);
1100 consider_writing(bev_ssl
);
1102 /* XXX Handle r < 0 */
1108 be_openssl_enable(struct bufferevent
*bev
, short events
)
1110 struct bufferevent_openssl
*bev_ssl
= upcast(bev
);
1113 if (bev_ssl
->state
!= BUFFEREVENT_SSL_OPEN
)
1116 if (events
& EV_READ
)
1117 r1
= start_reading(bev_ssl
);
1118 if (events
& EV_WRITE
)
1119 r2
= start_writing(bev_ssl
);
1121 if (bev_ssl
->underlying
) {
1122 if (events
& EV_READ
)
1123 BEV_RESET_GENERIC_READ_TIMEOUT(bev
);
1124 if (events
& EV_WRITE
)
1125 BEV_RESET_GENERIC_WRITE_TIMEOUT(bev
);
1127 if (events
& EV_READ
)
1128 consider_reading(bev_ssl
);
1129 if (events
& EV_WRITE
)
1130 consider_writing(bev_ssl
);
1132 return (r1
< 0 || r2
< 0) ? -1 : 0;
1136 be_openssl_disable(struct bufferevent
*bev
, short events
)
1138 struct bufferevent_openssl
*bev_ssl
= upcast(bev
);
1139 if (bev_ssl
->state
!= BUFFEREVENT_SSL_OPEN
)
1142 if (events
& EV_READ
)
1143 stop_reading(bev_ssl
);
1144 if (events
& EV_WRITE
)
1145 stop_writing(bev_ssl
);
1147 if (bev_ssl
->underlying
) {
1148 if (events
& EV_READ
)
1149 BEV_DEL_GENERIC_READ_TIMEOUT(bev
);
1150 if (events
& EV_WRITE
)
1151 BEV_DEL_GENERIC_WRITE_TIMEOUT(bev
);
1157 be_openssl_destruct(struct bufferevent
*bev
)
1159 struct bufferevent_openssl
*bev_ssl
= upcast(bev
);
1161 if (bev_ssl
->underlying
) {
1162 _bufferevent_del_generic_timeout_cbs(bev
);
1164 event_del(&bev
->ev_read
);
1165 event_del(&bev
->ev_write
);
1168 if (bev_ssl
->bev
.options
& BEV_OPT_CLOSE_ON_FREE
) {
1169 if (bev_ssl
->underlying
) {
1170 if (BEV_UPCAST(bev_ssl
->underlying
)->refcnt
< 2) {
1171 event_warnx("BEV_OPT_CLOSE_ON_FREE set on an "
1172 "bufferevent with too few references");
1174 bufferevent_free(bev_ssl
->underlying
);
1175 bev_ssl
->underlying
= NULL
;
1178 evutil_socket_t fd
= -1;
1179 BIO
*bio
= SSL_get_wbio(bev_ssl
->ssl
);
1181 fd
= BIO_get_fd(bio
, NULL
);
1183 evutil_closesocket(fd
);
1185 SSL_free(bev_ssl
->ssl
);
1187 if (bev_ssl
->underlying
) {
1188 if (bev_ssl
->underlying
->errorcb
== be_openssl_eventcb
)
1189 bufferevent_setcb(bev_ssl
->underlying
,
1190 NULL
,NULL
,NULL
,NULL
);
1191 bufferevent_unsuspend_read(bev_ssl
->underlying
,
1192 BEV_SUSPEND_FILT_READ
);
1198 be_openssl_adj_timeouts(struct bufferevent
*bev
)
1200 struct bufferevent_openssl
*bev_ssl
= upcast(bev
);
1202 if (bev_ssl
->underlying
)
1203 return _bufferevent_generic_adj_timeouts(bev
);
1206 if (event_pending(&bev
->ev_read
, EV_READ
, NULL
))
1207 r1
= _bufferevent_add_event(&bev
->ev_read
, &bev
->timeout_read
);
1208 if (event_pending(&bev
->ev_write
, EV_WRITE
, NULL
))
1209 r2
= _bufferevent_add_event(&bev
->ev_write
, &bev
->timeout_write
);
1210 return (r1
<0 || r2
<0) ? -1 : 0;
1215 be_openssl_flush(struct bufferevent
*bufev
,
1216 short iotype
, enum bufferevent_flush_mode mode
)
1218 /* XXXX Implement this. */
1223 be_openssl_ctrl(struct bufferevent
*bev
,
1224 enum bufferevent_ctrl_op op
, union bufferevent_ctrl_data
*data
)
1226 struct bufferevent_openssl
*bev_ssl
= upcast(bev
);
1228 case BEV_CTRL_SET_FD
:
1229 if (bev_ssl
->underlying
)
1233 bio
= BIO_new_socket(data
->fd
, 0);
1234 SSL_set_bio(bev_ssl
->ssl
, bio
, bio
);
1235 bev_ssl
->fd_is_set
= 1;
1237 if (bev_ssl
->state
== BUFFEREVENT_SSL_OPEN
)
1238 return set_open_callbacks(bev_ssl
, data
->fd
);
1240 return set_handshake_callbacks(bev_ssl
, data
->fd
);
1242 case BEV_CTRL_GET_FD
:
1243 if (bev_ssl
->underlying
)
1245 if (!bev_ssl
->fd_is_set
)
1247 data
->fd
= event_get_fd(&bev
->ev_read
);
1249 case BEV_CTRL_GET_UNDERLYING
:
1250 if (!bev_ssl
->underlying
)
1252 data
->ptr
= bev_ssl
->underlying
;
1254 case BEV_CTRL_CANCEL_ALL
:
1261 bufferevent_openssl_get_ssl(struct bufferevent
*bufev
)
1263 struct bufferevent_openssl
*bev_ssl
= upcast(bufev
);
1266 return bev_ssl
->ssl
;
1269 static struct bufferevent
*
1270 bufferevent_openssl_new_impl(struct event_base
*base
,
1271 struct bufferevent
*underlying
,
1274 enum bufferevent_ssl_state state
,
1277 struct bufferevent_openssl
*bev_ssl
= NULL
;
1278 struct bufferevent_private
*bev_p
= NULL
;
1279 int tmp_options
= options
& ~BEV_OPT_THREADSAFE
;
1281 if (underlying
!= NULL
&& fd
>= 0)
1282 return NULL
; /* Only one can be set. */
1284 if (!(bev_ssl
= mm_calloc(1, sizeof(struct bufferevent_openssl
))))
1287 bev_p
= &bev_ssl
->bev
;
1289 if (bufferevent_init_common(bev_p
, base
,
1290 &bufferevent_ops_openssl
, tmp_options
) < 0)
1293 /* Don't explode if we decide to realloc a chunk we're writing from in
1294 * the output buffer. */
1295 SSL_set_mode(ssl
, SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER
);
1297 bev_ssl
->underlying
= underlying
;
1300 bev_ssl
->outbuf_cb
= evbuffer_add_cb(bev_p
->bev
.output
,
1301 be_openssl_outbuf_cb
, bev_ssl
);
1303 if (options
& BEV_OPT_THREADSAFE
)
1304 bufferevent_enable_locking(&bev_ssl
->bev
.bev
, NULL
);
1307 _bufferevent_init_generic_timeout_cbs(&bev_ssl
->bev
.bev
);
1308 bufferevent_incref(underlying
);
1311 bev_ssl
->state
= state
;
1312 bev_ssl
->last_write
= -1;
1314 init_bio_counts(bev_ssl
);
1317 case BUFFEREVENT_SSL_ACCEPTING
:
1318 SSL_set_accept_state(bev_ssl
->ssl
);
1319 if (set_handshake_callbacks(bev_ssl
, fd
) < 0)
1322 case BUFFEREVENT_SSL_CONNECTING
:
1323 SSL_set_connect_state(bev_ssl
->ssl
);
1324 if (set_handshake_callbacks(bev_ssl
, fd
) < 0)
1327 case BUFFEREVENT_SSL_OPEN
:
1328 if (set_open_callbacks(bev_ssl
, fd
) < 0)
1336 bufferevent_setwatermark(underlying
, EV_READ
, 0, 0);
1337 bufferevent_enable(underlying
, EV_READ
|EV_WRITE
);
1338 if (state
== BUFFEREVENT_SSL_OPEN
)
1339 bufferevent_suspend_read(underlying
,
1340 BEV_SUSPEND_FILT_READ
);
1342 bev_ssl
->bev
.bev
.enabled
= EV_READ
|EV_WRITE
;
1343 if (bev_ssl
->fd_is_set
) {
1344 if (state
!= BUFFEREVENT_SSL_OPEN
)
1345 if (event_add(&bev_ssl
->bev
.bev
.ev_read
, NULL
) < 0)
1347 if (event_add(&bev_ssl
->bev
.bev
.ev_write
, NULL
) < 0)
1352 return &bev_ssl
->bev
.bev
;
1355 bufferevent_free(&bev_ssl
->bev
.bev
);
1359 struct bufferevent
*
1360 bufferevent_openssl_filter_new(struct event_base
*base
,
1361 struct bufferevent
*underlying
,
1363 enum bufferevent_ssl_state state
,
1366 /* We don't tell the BIO to close the bufferevent; we do it ourselves
1367 * on be_openssl_destruct */
1368 int close_flag
= 0; /* options & BEV_OPT_CLOSE_ON_FREE; */
1372 if (!(bio
= BIO_new_bufferevent(underlying
, close_flag
)))
1375 SSL_set_bio(ssl
, bio
, bio
);
1377 return bufferevent_openssl_new_impl(
1378 base
, underlying
, -1, ssl
, state
, options
);
1381 struct bufferevent
*
1382 bufferevent_openssl_socket_new(struct event_base
*base
,
1385 enum bufferevent_ssl_state state
,
1388 /* Does the SSL already have an fd? */
1389 BIO
*bio
= SSL_get_wbio(ssl
);
1393 have_fd
= BIO_get_fd(bio
, NULL
);
1396 /* The SSL is already configured with an fd. */
1398 /* We should learn the fd from the SSL. */
1399 fd
= (evutil_socket_t
) have_fd
;
1400 } else if (have_fd
== (long)fd
) {
1401 /* We already know the fd from the SSL; do nothing */
1403 /* We specified an fd different from that of the SSL.
1404 This is probably an error on our part. Fail. */
1407 (void) BIO_set_close(bio
, 0);
1409 /* The SSL isn't configured with a BIO with an fd. */
1411 /* ... and we have an fd we want to use. */
1412 bio
= BIO_new_socket(fd
, 0);
1413 SSL_set_bio(ssl
, bio
, bio
);
1415 /* Leave the fd unset. */
1419 return bufferevent_openssl_new_impl(
1420 base
, NULL
, fd
, ssl
, state
, options
);
1424 bufferevent_get_openssl_error(struct bufferevent
*bev
)
1426 unsigned long err
= 0;
1427 struct bufferevent_openssl
*bev_ssl
;
1429 bev_ssl
= upcast(bev
);
1430 if (bev_ssl
&& bev_ssl
->n_errors
) {
1431 err
= bev_ssl
->errors
[--bev_ssl
->n_errors
];