/* Licensed to the Apache Software Foundation (ASF) under one or more

* contributor license agreements. See the NOTICE file distributed with

* this work for additional information regarding copyright ownership.

* The ASF licenses this file to You under the Apache License, Version 2.0

* (the "License"); you may not use this file except in compliance with

* the License. You may obtain a copy of the License at

*

* http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

/* _ _

* _ __ ___ ___ __| | ___ ___| | mod_ssl

* | '_ ` _ \ / _ \ / _` | / __/ __| | Apache Interface to OpenSSL

* | | | | | | (_) | (_| | \__ \__ \ |

* |_| |_| |_|\___/ \__,_|___|___/___/_|

* |_____|

* ssl_engine_io.c

* I/O Functions

*/

/* ``MY HACK: This universe.

Just one little problem:

core keeps dumping.''

-- Unknown */

#include "ssl_private.h"

#include "apr_date.h"

/* _________________________________________________________________

**

** I/O Hooks

** _________________________________________________________________

*/

/* This file is designed to be the bridge between OpenSSL and httpd.

* However, we really don't expect anyone (let alone ourselves) to

* remember what is in this file. So, first, a quick overview.

*

* In this file, you will find:

* - ssl_io_filter_input (Apache input filter)

* - ssl_io_filter_output (Apache output filter)

*

* - bio_filter_in_* (OpenSSL input filter)

* - bio_filter_out_* (OpenSSL output filter)

*

* The input chain is roughly:

*

* ssl_io_filter_input->ssl_io_input_read->SSL_read->...

* ...->bio_filter_in_read->ap_get_brigade/next-httpd-filter

*

* In mortal terminology, we do the following:

* - Receive a request for data to the SSL input filter

* - Call a helper function once we know we should perform a read

* - Call OpenSSL's SSL_read()

* - SSL_read() will then call bio_filter_in_read

* - bio_filter_in_read will then try to fetch data from the next httpd filter

* - bio_filter_in_read will flatten that data and return it to SSL_read

* - SSL_read will then decrypt the data

* - ssl_io_input_read will then receive decrypted data as a char* and

* ensure that there were no read errors

* - The char* is placed in a brigade and returned

*

* Since connection-level input filters in httpd need to be able to

* handle AP_MODE_GETLINE calls (namely identifying LF-terminated strings),

* ssl_io_input_getline which will handle this special case.

*

* Due to AP_MODE_GETLINE and AP_MODE_SPECULATIVE, we may sometimes have

* 'leftover' decoded data which must be setaside for the next read. That

* is currently handled by the char_buffer_{read|write} functions. So,

* ssl_io_input_read may be able to fulfill reads without invoking

* SSL_read().

*

* Note that the filter context of ssl_io_filter_input and bio_filter_in_*

* are shared as bio_filter_in_ctx_t.

*

* Note that the filter is by choice limited to reading at most

* AP_IOBUFSIZE (8192 bytes) per call.

*

*/

/* this custom BIO allows us to hook SSL_write directly into

* an apr_bucket_brigade and use transient buckets with the SSL

* malloc-ed buffer, rather than copying into a mem BIO.

* also allows us to pass the brigade as data is being written

* rather than buffering up the entire response in the mem BIO.

*

* when SSL needs to flush (e.g. SSL_accept()), it will call BIO_flush()

* which will trigger a call to bio_filter_out_ctrl() -> bio_filter_out_flush().

* so we only need to flush the output ourselves if we receive an

* EOS or FLUSH bucket. this was not possible with the mem BIO where we

* had to flush all over the place not really knowing when it was required

* to do so.

*/

typedef struct {

SSL *pssl;

BIO *pbioRead;

BIO *pbioWrite;

ap_filter_t *pInputFilter;

ap_filter_t *pOutputFilter;

SSLConnRec *config;

} ssl_filter_ctx_t;

typedef struct {

ssl_filter_ctx_t *filter_ctx;

conn_rec *c;

apr_bucket_brigade *bb; /* Brigade used as a buffer. */

apr_status_t rc;

} bio_filter_out_ctx_t;

static bio_filter_out_ctx_t *bio_filter_out_ctx_new(ssl_filter_ctx_t *filter_ctx,

conn_rec *c)

{

bio_filter_out_ctx_t *outctx = apr_palloc(c->pool, sizeof(*outctx));

outctx->filter_ctx = filter_ctx;

outctx->c = c;

outctx->bb = apr_brigade_create(c->pool, c->bucket_alloc);

return outctx;

}

/* Pass an output brigade down the filter stack; returns 1 on success

* or -1 on failure. */

static int bio_filter_out_pass(bio_filter_out_ctx_t *outctx)

{

AP_DEBUG_ASSERT(!APR_BRIGADE_EMPTY(outctx->bb));

outctx->rc = ap_pass_brigade(outctx->filter_ctx->pOutputFilter->next,

outctx->bb);

/* Fail if the connection was reset: */

if (outctx->rc == APR_SUCCESS && outctx->c->aborted) {

outctx->rc = APR_ECONNRESET;

}

return (outctx->rc == APR_SUCCESS) ? 1 : -1;

}

/* Send a FLUSH bucket down the output filter stack; returns 1 on

* success, -1 on failure. */

static int bio_filter_out_flush(BIO *bio)

{

bio_filter_out_ctx_t *outctx = (bio_filter_out_ctx_t *)(bio->ptr);

apr_bucket *e;

AP_DEBUG_ASSERT(APR_BRIGADE_EMPTY(outctx->bb));

e = apr_bucket_flush_create(outctx->bb->bucket_alloc);

APR_BRIGADE_INSERT_TAIL(outctx->bb, e);

return bio_filter_out_pass(outctx);

}

static int bio_filter_create(BIO *bio)

{

bio->shutdown = 1;

bio->init = 1;

bio->num = -1;

bio->ptr = NULL;

return 1;

}

static int bio_filter_destroy(BIO *bio)

{

if (bio == NULL) {

return 0;

}

/* nothing to free here.

* apache will destroy the bucket brigade for us

*/

return 1;

}

static int bio_filter_out_read(BIO *bio, char *out, int outl)

{

/* this is never called */

return -1;

}

static int bio_filter_out_write(BIO *bio, const char *in, int inl)

{

bio_filter_out_ctx_t *outctx = (bio_filter_out_ctx_t *)(bio->ptr);

apr_bucket *e;

/* Abort early if the client has initiated a renegotiation. */

if (outctx->filter_ctx->config->reneg_state == RENEG_ABORT) {

outctx->rc = APR_ECONNABORTED;

return -1;

}

/* when handshaking we'll have a small number of bytes.

* max size SSL will pass us here is about 16k.

* (16413 bytes to be exact)

*/

BIO_clear_retry_flags(bio);

/* Use a transient bucket for the output data - any downstream

* filter must setaside if necessary. */

e = apr_bucket_transient_create(in, inl, outctx->bb->bucket_alloc);

APR_BRIGADE_INSERT_TAIL(outctx->bb, e);

if (bio_filter_out_pass(outctx) < 0) {

return -1;

}

return inl;

}

static long bio_filter_out_ctrl(BIO *bio, int cmd, long num, void *ptr)

{

long ret = 1;

bio_filter_out_ctx_t *outctx = (bio_filter_out_ctx_t *)(bio->ptr);

switch (cmd) {

case BIO_CTRL_RESET:

case BIO_CTRL_EOF:

case BIO_C_SET_BUF_MEM_EOF_RETURN:

ap_log_cerror(APLOG_MARK, APLOG_TRACE4, 0, outctx->c,

"output bio: unhandled control %d", cmd);

ret = 0;

break;

case BIO_CTRL_WPENDING:

case BIO_CTRL_PENDING:

case BIO_CTRL_INFO:

ret = 0;

break;

case BIO_CTRL_GET_CLOSE:

ret = (long)bio->shutdown;

break;

case BIO_CTRL_SET_CLOSE:

bio->shutdown = (int)num;

break;

case BIO_CTRL_FLUSH:

ret = bio_filter_out_flush(bio);

break;

case BIO_CTRL_DUP:

ret = 1;

break;

/* N/A */

case BIO_C_SET_BUF_MEM:

case BIO_C_GET_BUF_MEM_PTR:

/* we don't care */

case BIO_CTRL_PUSH:

case BIO_CTRL_POP:

default:

ret = 0;

break;

}

return ret;

}

static int bio_filter_out_gets(BIO *bio, char *buf, int size)

{

/* this is never called */

return -1;

}

static int bio_filter_out_puts(BIO *bio, const char *str)

{

/* this is never called */

return -1;

}

static BIO_METHOD bio_filter_out_method = {

BIO_TYPE_MEM,

"APR output filter",

bio_filter_out_write,

bio_filter_out_read, /* read is never called */

bio_filter_out_puts, /* puts is never called */

bio_filter_out_gets, /* gets is never called */

bio_filter_out_ctrl,

bio_filter_create,

bio_filter_destroy,

NULL

};

typedef struct {

int length;

char *value;

} char_buffer_t;

typedef struct {

SSL *ssl;

BIO *bio_out;

ap_filter_t *f;

apr_status_t rc;

ap_input_mode_t mode;

apr_read_type_e block;

apr_bucket_brigade *bb;

char_buffer_t cbuf;

apr_pool_t *pool;

char buffer[AP_IOBUFSIZE];

ssl_filter_ctx_t *filter_ctx;

} bio_filter_in_ctx_t;

/*

* this char_buffer api might seem silly, but we don't need to copy

* any of this data and we need to remember the length.

*/

/* Copy up to INL bytes from the char_buffer BUFFER into IN. Note

* that due to the strange way this API is designed/used, the

* char_buffer object is used to cache a segment of inctx->buffer, and

* then this function called to copy (part of) that segment to the

* beginning of inctx->buffer. So the segments to copy cannot be

* presumed to be non-overlapping, and memmove must be used. */

static int char_buffer_read(char_buffer_t *buffer, char *in, int inl)

{

if (!buffer->length) {

return 0;

}

if (buffer->length > inl) {

/* we have have enough to fill the caller's buffer */

memmove(in, buffer->value, inl);

buffer->value += inl;

buffer->length -= inl;

}

else {

/* swallow remainder of the buffer */

memmove(in, buffer->value, buffer->length);

inl = buffer->length;

buffer->value = NULL;

buffer->length = 0;

}

return inl;

}

static int char_buffer_write(char_buffer_t *buffer, char *in, int inl)

{

buffer->value = in;

buffer->length = inl;

return inl;

}

/* This function will read from a brigade and discard the read buckets as it

* proceeds. It will read at most *len bytes.

*/

static apr_status_t brigade_consume(apr_bucket_brigade *bb,

apr_read_type_e block,

char *c, apr_size_t *len)

{

apr_size_t actual = 0;

apr_status_t status = APR_SUCCESS;

while (!APR_BRIGADE_EMPTY(bb)) {

apr_bucket *b = APR_BRIGADE_FIRST(bb);

const char *str;

apr_size_t str_len;

apr_size_t consume;

/* Justin points out this is an http-ism that might

* not fit if brigade_consume is added to APR. Perhaps

* apr_bucket_read(eos_bucket) should return APR_EOF?

* Then this becomes mainline instead of a one-off.

*/

if (APR_BUCKET_IS_EOS(b)) {

status = APR_EOF;

break;

}

/* The reason I'm not offering brigade_consume yet

* across to apr-util is that the following call

* illustrates how borked that API really is. For

* this sort of case (caller provided buffer) it

* would be much more trivial for apr_bucket_consume

* to do all the work that follows, based on the

* particular characteristics of the bucket we are

* consuming here.

*/

status = apr_bucket_read(b, &str, &str_len, block);

if (status != APR_SUCCESS) {

if (APR_STATUS_IS_EOF(status)) {

/* This stream bucket was consumed */

apr_bucket_delete(b);

continue;

}

break;

}

if (str_len > 0) {

/* Do not block once some data has been consumed */

block = APR_NONBLOCK_READ;

/* Assure we don't overflow. */

consume = (str_len + actual > *len) ? *len - actual : str_len;

memcpy(c, str, consume);

c += consume;

actual += consume;

if (consume >= b->length) {

/* This physical bucket was consumed */

apr_bucket_delete(b);

}

else {

/* Only part of this physical bucket was consumed */

b->start += consume;

b->length -= consume;

}

}

else if (b->length == 0) {

apr_bucket_delete(b);

}

/* This could probably be actual == *len, but be safe from stray

* photons. */

if (actual >= *len) {

break;

}

}

*len = actual;

return status;

}

/*

* this is the function called by SSL_read()

*/

static int bio_filter_in_read(BIO *bio, char *in, int inlen)

{

apr_size_t inl = inlen;

bio_filter_in_ctx_t *inctx = (bio_filter_in_ctx_t *)(bio->ptr);

apr_read_type_e block = inctx->block;

inctx->rc = APR_SUCCESS;

/* OpenSSL catches this case, so should we. */

if (!in)

return 0;

/* Abort early if the client has initiated a renegotiation. */

if (inctx->filter_ctx->config->reneg_state == RENEG_ABORT) {

inctx->rc = APR_ECONNABORTED;

return -1;

}

/* In theory, OpenSSL should flush as necessary, but it is known

* not to do so correctly in some cases; see PR 46952.

*

* Historically, this flush call was performed only for an SSLv2

* connection or for a proxy connection. Calling _out_flush

* should be very cheap in cases where it is unnecessary (and no

* output is buffered) so the performance impact of doing it

* unconditionally should be minimal.

*/

if (bio_filter_out_flush(inctx->bio_out) < 0) {

bio_filter_out_ctx_t *outctx = inctx->bio_out->ptr;

inctx->rc = outctx->rc;

return -1;

}

BIO_clear_retry_flags(bio);

if (!inctx->bb) {

inctx->rc = APR_EOF;

return -1;

}

if (APR_BRIGADE_EMPTY(inctx->bb)) {

inctx->rc = ap_get_brigade(inctx->f->next, inctx->bb,

AP_MODE_READBYTES, block,

inl);

/* If the read returns EAGAIN or success with an empty

* brigade, return an error after setting the retry flag;

* SSL_read() will then return -1, and SSL_get_error() will

* indicate SSL_ERROR_WANT_READ. */

if (APR_STATUS_IS_EAGAIN(inctx->rc) || APR_STATUS_IS_EINTR(inctx->rc)

|| (inctx->rc == APR_SUCCESS && APR_BRIGADE_EMPTY(inctx->bb))) {

BIO_set_retry_read(bio);

return -1;

}

if (inctx->rc != APR_SUCCESS) {

/* Unexpected errors discard the brigade */

apr_brigade_cleanup(inctx->bb);

inctx->bb = NULL;

return -1;

}

}

inctx->rc = brigade_consume(inctx->bb, block, in, &inl);

if (inctx->rc == APR_SUCCESS) {

return (int)inl;

}

if (APR_STATUS_IS_EAGAIN(inctx->rc)

|| APR_STATUS_IS_EINTR(inctx->rc)) {

BIO_set_retry_read(bio);

return (int)inl;

}

/* Unexpected errors and APR_EOF clean out the brigade.

* Subsequent calls will return APR_EOF.

*/

apr_brigade_cleanup(inctx->bb);

inctx->bb = NULL;

if (APR_STATUS_IS_EOF(inctx->rc) && inl) {

/* Provide the results of this read pass,

* without resetting the BIO retry_read flag

*/

return (int)inl;

}

return -1;

}

static BIO_METHOD bio_filter_in_method = {

BIO_TYPE_MEM,

"APR input filter",

NULL, /* write is never called */

bio_filter_in_read,

NULL, /* puts is never called */

NULL, /* gets is never called */

NULL, /* ctrl is never called */

bio_filter_create,

bio_filter_destroy,

NULL

};

static apr_status_t ssl_io_input_read(bio_filter_in_ctx_t *inctx,

char *buf,

apr_size_t *len)

{

apr_size_t wanted = *len;

apr_size_t bytes = 0;

int rc;

*len = 0;

/* If we have something leftover from last time, try that first. */

if ((bytes = char_buffer_read(&inctx->cbuf, buf, wanted))) {

*len = bytes;

if (inctx->mode == AP_MODE_SPECULATIVE) {

/* We want to rollback this read. */

if (inctx->cbuf.length > 0) {

inctx->cbuf.value -= bytes;

inctx->cbuf.length += bytes;

} else {

char_buffer_write(&inctx->cbuf, buf, (int)bytes);

}

return APR_SUCCESS;

}

/* This could probably be *len == wanted, but be safe from stray

* photons.

*/

if (*len >= wanted) {

return APR_SUCCESS;

}

if (inctx->mode == AP_MODE_GETLINE) {

if (memchr(buf, APR_ASCII_LF, *len)) {

return APR_SUCCESS;

}

}

else {

/* Down to a nonblock pattern as we have some data already

*/

inctx->block = APR_NONBLOCK_READ;

}

}

while (1) {

if (!inctx->filter_ctx->pssl) {

/* Ensure a non-zero error code is returned */

if (inctx->rc == APR_SUCCESS) {

inctx->rc = APR_EGENERAL;

}

break;

}

/* SSL_read may not read because we haven't taken enough data

* from the stack. This is where we want to consider all of

* the blocking and SPECULATIVE semantics

*/

rc = SSL_read(inctx->filter_ctx->pssl, buf + bytes, wanted - bytes);

if (rc > 0) {

*len += rc;

if (inctx->mode == AP_MODE_SPECULATIVE) {

/* We want to rollback this read. */

char_buffer_write(&inctx->cbuf, buf, rc);

}

return inctx->rc;

}

else if (rc == 0) {

/* If EAGAIN, we will loop given a blocking read,

* otherwise consider ourselves at EOF.

*/

if (APR_STATUS_IS_EAGAIN(inctx->rc)

|| APR_STATUS_IS_EINTR(inctx->rc)) {

/* Already read something, return APR_SUCCESS instead.

* On win32 in particular, but perhaps on other kernels,

* a blocking call isn't 'always' blocking.

*/

if (*len > 0) {

inctx->rc = APR_SUCCESS;

break;

}

if (inctx->block == APR_NONBLOCK_READ) {

break;

}

}

else {

if (*len > 0) {

inctx->rc = APR_SUCCESS;

}

else {

inctx->rc = APR_EOF;

}

break;

}

}

else /* (rc < 0) */ {

int ssl_err = SSL_get_error(inctx->filter_ctx->pssl, rc);

conn_rec *c = (conn_rec*)SSL_get_app_data(inctx->filter_ctx->pssl);

if (ssl_err == SSL_ERROR_WANT_READ) {

/*

* If OpenSSL wants to read more, and we were nonblocking,

* report as an EAGAIN. Otherwise loop, pulling more

* data from network filter.

*

* (This is usually the case when the client forces an SSL

* renegotiation which is handled implicitly by OpenSSL.)

*/

inctx->rc = APR_EAGAIN;

if (*len > 0) {

inctx->rc = APR_SUCCESS;

break;

}

if (inctx->block == APR_NONBLOCK_READ) {

break;

}

continue; /* Blocking and nothing yet? Try again. */

}

else if (ssl_err == SSL_ERROR_SYSCALL) {

if (APR_STATUS_IS_EAGAIN(inctx->rc)

|| APR_STATUS_IS_EINTR(inctx->rc)) {

/* Already read something, return APR_SUCCESS instead. */

if (*len > 0) {

inctx->rc = APR_SUCCESS;

break;

}

if (inctx->block == APR_NONBLOCK_READ) {

break;

}

continue; /* Blocking and nothing yet? Try again. */

}

else {

ap_log_cerror(APLOG_MARK, APLOG_INFO, inctx->rc, c,

"SSL input filter read failed.");

}

}

else /* if (ssl_err == SSL_ERROR_SSL) */ {

/*

* Log SSL errors and any unexpected conditions.

*/

ap_log_cerror(APLOG_MARK, APLOG_INFO, inctx->rc, c,

"SSL library error %d reading data", ssl_err);

ssl_log_ssl_error(SSLLOG_MARK, APLOG_INFO, mySrvFromConn(c));

}

if (inctx->rc == APR_SUCCESS) {

inctx->rc = APR_EGENERAL;

}

break;

}

}

return inctx->rc;

}

/* Read a line of input from the SSL input layer into buffer BUF of

* length *LEN; updating *len to reflect the length of the line

* including the LF character. */

static apr_status_t ssl_io_input_getline(bio_filter_in_ctx_t *inctx,

char *buf,

apr_size_t *len)

{

const char *pos = NULL;

apr_status_t status;

apr_size_t tmplen = *len, buflen = *len, offset = 0;

*len = 0;

/*

* in most cases we get all the headers on the first SSL_read.

* however, in certain cases SSL_read will only get a partial

* chunk of the headers, so we try to read until LF is seen.

*/

while (tmplen > 0) {

status = ssl_io_input_read(inctx, buf + offset, &tmplen);

if (status != APR_SUCCESS) {

if (APR_STATUS_IS_EAGAIN(status) && (*len > 0)) {

/* Save the part of the line we already got */

char_buffer_write(&inctx->cbuf, buf, *len);

}

return status;

}

*len += tmplen;

if ((pos = memchr(buf, APR_ASCII_LF, *len))) {

break;

}

offset += tmplen;

tmplen = buflen - offset;

}

if (pos) {

char *value;

int length;

apr_size_t bytes = pos - buf;

bytes += 1;

value = buf + bytes;

length = *len - bytes;

char_buffer_write(&inctx->cbuf, value, length);

*len = bytes;

}

return APR_SUCCESS;

}

static apr_status_t ssl_filter_write(ap_filter_t *f,

const char *data,

apr_size_t len)

{

ssl_filter_ctx_t *filter_ctx = f->ctx;

bio_filter_out_ctx_t *outctx;

int res;

/* write SSL */

if (filter_ctx->pssl == NULL) {

return APR_EGENERAL;

}

outctx = (bio_filter_out_ctx_t *)filter_ctx->pbioWrite->ptr;

res = SSL_write(filter_ctx->pssl, (unsigned char *)data, len);

if (res < 0) {

int ssl_err = SSL_get_error(filter_ctx->pssl, res);

conn_rec *c = (conn_rec*)SSL_get_app_data(outctx->filter_ctx->pssl);

if (ssl_err == SSL_ERROR_WANT_WRITE) {

/*

* If OpenSSL wants to write more, and we were nonblocking,

* report as an EAGAIN. Otherwise loop, pushing more

* data at the network filter.

*

* (This is usually the case when the client forces an SSL

* renegotiation which is handled implicitly by OpenSSL.)

*/

outctx->rc = APR_EAGAIN;

}

else if (ssl_err == SSL_ERROR_SYSCALL) {

ap_log_cerror(APLOG_MARK, APLOG_INFO, outctx->rc, c,

"SSL output filter write failed.");

}

else /* if (ssl_err == SSL_ERROR_SSL) */ {

/*

* Log SSL errors

*/

ap_log_cerror(APLOG_MARK, APLOG_INFO, outctx->rc, c,

"SSL library error %d writing data", ssl_err);

ssl_log_ssl_error(SSLLOG_MARK, APLOG_INFO, mySrvFromConn(c));

}

if (outctx->rc == APR_SUCCESS) {

outctx->rc = APR_EGENERAL;

}

}

else if ((apr_size_t)res != len) {

conn_rec *c = f->c;

char *reason = "reason unknown";

/* XXX: probably a better way to determine this */

if (SSL_total_renegotiations(filter_ctx->pssl)) {

reason = "likely due to failed renegotiation";

}

ap_log_cerror(APLOG_MARK, APLOG_INFO, outctx->rc, c,

"failed to write %" APR_SSIZE_T_FMT

" of %" APR_SIZE_T_FMT " bytes (%s)",

len - (apr_size_t)res, len, reason);

outctx->rc = APR_EGENERAL;

}

return outctx->rc;

}

/* Just use a simple request. Any request will work for this, because

* we use a flag in the conn_rec->conn_vector now. The fake request just

* gets the request back to the Apache core so that a response can be sent.

*

* To avoid calling back for more data from the socket, use an HTTP/0.9

* request, and tack on an EOS bucket.

*/

#define HTTP_ON_HTTPS_PORT \

"GET /" CRLF

#define HTTP_ON_HTTPS_PORT_BUCKET(alloc) \

apr_bucket_immortal_create(HTTP_ON_HTTPS_PORT, \

sizeof(HTTP_ON_HTTPS_PORT) - 1, \

alloc)

/* Custom apr_status_t error code, used when a plain HTTP request is

* recevied on an SSL port. */

#define MODSSL_ERROR_HTTP_ON_HTTPS (APR_OS_START_USERERR + 0)

/* Custom apr_status_t error code, used when the proxy cannot

* establish an outgoing SSL connection. */

#define MODSSL_ERROR_BAD_GATEWAY (APR_OS_START_USERERR + 1)

static void ssl_io_filter_disable(SSLConnRec *sslconn, ap_filter_t *f)

{

bio_filter_in_ctx_t *inctx = f->ctx;

SSL_free(inctx->ssl);

sslconn->ssl = NULL;

inctx->ssl = NULL;

inctx->filter_ctx->pssl = NULL;

}

static apr_status_t ssl_io_filter_error(ap_filter_t *f,

apr_bucket_brigade *bb,

apr_status_t status)

{

SSLConnRec *sslconn = myConnConfig(f->c);

apr_bucket *bucket;

switch (status) {

case MODSSL_ERROR_HTTP_ON_HTTPS:

/* log the situation */

ap_log_cerror(APLOG_MARK, APLOG_INFO, 0, f->c,

"SSL handshake failed: HTTP spoken on HTTPS port; "

"trying to send HTML error page");

ssl_log_ssl_error(SSLLOG_MARK, APLOG_INFO, sslconn->server);

sslconn->non_ssl_request = 1;

ssl_io_filter_disable(sslconn, f);

/* fake the request line */

bucket = HTTP_ON_HTTPS_PORT_BUCKET(f->c->bucket_alloc);

break;

case MODSSL_ERROR_BAD_GATEWAY:

bucket = ap_bucket_error_create(HTTP_BAD_REQUEST, NULL,

f->c->pool,

f->c->bucket_alloc);

ap_log_cerror(APLOG_MARK, APLOG_INFO, 0, f->c,

"SSL handshake failed: sending 502");

break;

default:

return status;

}

APR_BRIGADE_INSERT_TAIL(bb, bucket);

bucket = apr_bucket_eos_create(f->c->bucket_alloc);

APR_BRIGADE_INSERT_TAIL(bb, bucket);

return APR_SUCCESS;

}

static const char ssl_io_filter[] = "SSL/TLS Filter";

static const char ssl_io_buffer[] = "SSL/TLS Buffer";

static const char ssl_io_coalesce[] = "SSL/TLS Coalescing Filter";

/*

* Close the SSL part of the socket connection

* (called immediately _before_ the socket is closed)

* or called with

*/

static void ssl_filter_io_shutdown(ssl_filter_ctx_t *filter_ctx,

conn_rec *c, int abortive)

{

SSL *ssl = filter_ctx->pssl;

const char *type = "";

SSLConnRec *sslconn = myConnConfig(c);

int shutdown_type;

int loglevel = APLOG_DEBUG;

if (!ssl) {

return;

}

/*

* Now close the SSL layer of the connection. We've to take

* the TLSv1 standard into account here:

*

* | 7.2.1. Closure alerts

* |

* | The client and the server must share knowledge that the connection is

* | ending in order to avoid a truncation attack. Either party may

* | initiate the exchange of closing messages.

* |

* | close_notify

* | This message notifies the recipient that the sender will not send

* | any more messages on this connection. The session becomes

* | unresumable if any connection is terminated without proper

* | close_notify messages with level equal to warning.

* |

* | Either party may initiate a close by sending a close_notify alert.

* | Any data received after a closure alert is ignored.

* |

* | Each party is required to send a close_notify alert before closing

* | the write side of the connection. It is required that the other party

* | respond with a close_notify alert of its own and close down the

* | connection immediately, discarding any pending writes. It is not

* | required for the initiator of the close to wait for the responding

* | close_notify alert before closing the read side of the connection.

*

* This means we've to send a close notify message, but haven't to wait

* for the close notify of the client. Actually we cannot wait for the

* close notify of the client because some clients (including Netscape

* 4.x) don't send one, so we would hang.

*/

/*

* exchange close notify messages, but allow the user

* to force the type of handshake via SetEnvIf directive

*/

if (abortive) {

shutdown_type = SSL_SENT_SHUTDOWN|SSL_RECEIVED_SHUTDOWN;

type = "abortive";

loglevel = APLOG_INFO;

}

else switch (sslconn->shutdown_type) {

case SSL_SHUTDOWN_TYPE_UNCLEAN:

/* perform no close notify handshake at all

(violates the SSL/TLS standard!) */

shutdown_type = SSL_SENT_SHUTDOWN|SSL_RECEIVED_SHUTDOWN;

type = "unclean";

break;

case SSL_SHUTDOWN_TYPE_ACCURATE:

/* send close notify and wait for clients close notify

(standard compliant, but usually causes connection hangs) */

shutdown_type = 0;

type = "accurate";

break;

default:

/*

* case SSL_SHUTDOWN_TYPE_UNSET:

* case SSL_SHUTDOWN_TYPE_STANDARD:

*/

/* send close notify, but don't wait for clients close notify

(standard compliant and safe, so it's the DEFAULT!) */

shutdown_type = SSL_RECEIVED_SHUTDOWN;

type = "standard";

break;

}

SSL_set_shutdown(ssl, shutdown_type);

SSL_smart_shutdown(ssl);

/* and finally log the fact that we've closed the connection */

if (APLOG_CS_IS_LEVEL(c, mySrvFromConn(c), loglevel)) {

ap_log_cserror(APLOG_MARK, loglevel, 0, c, mySrvFromConn(c),

"Connection closed to child %ld with %s shutdown "

"(server %s)",

c->id, type,

ssl_util_vhostid(c->pool, mySrvFromConn(c)));

}

/* deallocate the SSL connection */

if (sslconn->client_cert) {

X509_free(sslconn->client_cert);

sslconn->client_cert = NULL;

}

SSL_free(ssl);

sslconn->ssl = NULL;

filter_ctx->pssl = NULL; /* so filters know we've been shutdown */

if (abortive) {

/* prevent any further I/O */

c->aborted = 1;

}

}