2000-11-01 23:11:19 +00:00
|
|
|
#include "tunala.h"
|
|
|
|
|
|
|
|
#ifndef NO_TUNALA
|
|
|
|
|
2015-01-21 23:55:44 +00:00
|
|
|
void state_machine_init(state_machine_t * machine)
|
2000-11-01 23:11:19 +00:00
|
|
|
{
|
2015-01-21 23:55:44 +00:00
|
|
|
machine->ssl = NULL;
|
|
|
|
machine->bio_intossl = machine->bio_fromssl = NULL;
|
|
|
|
buffer_init(&machine->clean_in);
|
|
|
|
buffer_init(&machine->clean_out);
|
|
|
|
buffer_init(&machine->dirty_in);
|
|
|
|
buffer_init(&machine->dirty_out);
|
2000-11-01 23:11:19 +00:00
|
|
|
}
|
|
|
|
|
2015-01-21 23:55:44 +00:00
|
|
|
void state_machine_close(state_machine_t * machine)
|
2000-11-01 23:11:19 +00:00
|
|
|
{
|
2015-01-21 23:55:44 +00:00
|
|
|
if (machine->ssl)
|
|
|
|
SSL_free(machine->ssl);
|
|
|
|
/*
|
|
|
|
* SSL_free seems to decrement the reference counts already so doing this
|
|
|
|
* goes kaboom.
|
|
|
|
*/
|
|
|
|
# if 0
|
|
|
|
if (machine->bio_intossl)
|
|
|
|
BIO_free(machine->bio_intossl);
|
|
|
|
if (machine->bio_fromssl)
|
|
|
|
BIO_free(machine->bio_fromssl);
|
|
|
|
# endif
|
|
|
|
buffer_close(&machine->clean_in);
|
|
|
|
buffer_close(&machine->clean_out);
|
|
|
|
buffer_close(&machine->dirty_in);
|
|
|
|
buffer_close(&machine->dirty_out);
|
|
|
|
state_machine_init(machine);
|
2000-11-01 23:11:19 +00:00
|
|
|
}
|
|
|
|
|
2015-01-21 23:55:44 +00:00
|
|
|
buffer_t *state_machine_get_buffer(state_machine_t * machine,
|
|
|
|
sm_buffer_t type)
|
2000-11-01 23:11:19 +00:00
|
|
|
{
|
2015-01-21 23:55:44 +00:00
|
|
|
switch (type) {
|
|
|
|
case SM_CLEAN_IN:
|
|
|
|
return &machine->clean_in;
|
|
|
|
case SM_CLEAN_OUT:
|
|
|
|
return &machine->clean_out;
|
|
|
|
case SM_DIRTY_IN:
|
|
|
|
return &machine->dirty_in;
|
|
|
|
case SM_DIRTY_OUT:
|
|
|
|
return &machine->dirty_out;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* Should never get here */
|
|
|
|
abort();
|
|
|
|
return NULL;
|
2000-11-01 23:11:19 +00:00
|
|
|
}
|
|
|
|
|
2015-01-21 23:55:44 +00:00
|
|
|
SSL *state_machine_get_SSL(state_machine_t * machine)
|
2000-11-01 23:11:19 +00:00
|
|
|
{
|
2015-01-21 23:55:44 +00:00
|
|
|
return machine->ssl;
|
2000-11-01 23:11:19 +00:00
|
|
|
}
|
|
|
|
|
2015-01-21 23:55:44 +00:00
|
|
|
int state_machine_set_SSL(state_machine_t * machine, SSL *ssl, int is_server)
|
2000-11-01 23:11:19 +00:00
|
|
|
{
|
2015-01-21 23:55:44 +00:00
|
|
|
if (machine->ssl)
|
|
|
|
/* Shouldn't ever be set twice */
|
|
|
|
abort();
|
|
|
|
machine->ssl = ssl;
|
|
|
|
/* Create the BIOs to handle the dirty side of the SSL */
|
|
|
|
if ((machine->bio_intossl = BIO_new(BIO_s_mem())) == NULL)
|
|
|
|
abort();
|
|
|
|
if ((machine->bio_fromssl = BIO_new(BIO_s_mem())) == NULL)
|
|
|
|
abort();
|
|
|
|
/* Hook up the BIOs on the dirty side of the SSL */
|
|
|
|
SSL_set_bio(machine->ssl, machine->bio_intossl, machine->bio_fromssl);
|
|
|
|
if (is_server)
|
|
|
|
SSL_set_accept_state(machine->ssl);
|
|
|
|
else
|
|
|
|
SSL_set_connect_state(machine->ssl);
|
|
|
|
/*
|
|
|
|
* If we're the first one to generate traffic - do it now otherwise we go
|
|
|
|
* into the next select empty-handed and our peer will not send data but
|
|
|
|
* will similarly wait for us.
|
|
|
|
*/
|
|
|
|
return state_machine_churn(machine);
|
2000-11-01 23:11:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Performs the data-IO loop and returns zero if the machine should close */
|
2015-01-21 23:55:44 +00:00
|
|
|
int state_machine_churn(state_machine_t * machine)
|
2000-11-01 23:11:19 +00:00
|
|
|
{
|
2015-01-21 23:55:44 +00:00
|
|
|
unsigned int loop;
|
|
|
|
if (machine->ssl == NULL) {
|
|
|
|
if (buffer_empty(&machine->clean_out))
|
|
|
|
/* Time to close this state-machine altogether */
|
|
|
|
return 0;
|
|
|
|
else
|
|
|
|
/* Still buffered data on the clean side to go out */
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Do this loop twice to cover any dependencies about which precise order
|
|
|
|
* of reads and writes is required.
|
|
|
|
*/
|
|
|
|
for (loop = 0; loop < 2; loop++) {
|
|
|
|
buffer_to_SSL(&machine->clean_in, machine->ssl);
|
|
|
|
buffer_to_BIO(&machine->dirty_in, machine->bio_intossl);
|
|
|
|
buffer_from_SSL(&machine->clean_out, machine->ssl);
|
|
|
|
buffer_from_BIO(&machine->dirty_out, machine->bio_fromssl);
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* We close on the SSL side if the info callback noticed some problems or
|
|
|
|
* an SSL shutdown was underway and shutdown traffic had all been sent.
|
|
|
|
*/
|
|
|
|
if (SSL_get_app_data(machine->ssl) || (SSL_get_shutdown(machine->ssl) &&
|
|
|
|
buffer_empty(&machine->dirty_out)))
|
|
|
|
{
|
|
|
|
/* Great, we can seal off the dirty side completely */
|
|
|
|
if (!state_machine_close_dirty(machine))
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Either the SSL is alive and well, or the closing process still has
|
|
|
|
* outgoing data waiting to be sent
|
|
|
|
*/
|
|
|
|
return 1;
|
2000-11-01 23:11:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Called when the clean side of the SSL has lost its connection */
|
2015-01-21 23:55:44 +00:00
|
|
|
int state_machine_close_clean(state_machine_t * machine)
|
2000-11-01 23:11:19 +00:00
|
|
|
{
|
2015-01-21 23:55:44 +00:00
|
|
|
/*
|
|
|
|
* Well, first thing to do is null out the clean-side buffers - they're
|
|
|
|
* no use any more.
|
|
|
|
*/
|
|
|
|
buffer_close(&machine->clean_in);
|
|
|
|
buffer_close(&machine->clean_out);
|
|
|
|
/* And start an SSL shutdown */
|
|
|
|
if (machine->ssl)
|
|
|
|
SSL_shutdown(machine->ssl);
|
|
|
|
/* This is an "event", so flush the SSL of any generated traffic */
|
|
|
|
state_machine_churn(machine);
|
|
|
|
if (buffer_empty(&machine->dirty_in) && buffer_empty(&machine->dirty_out))
|
|
|
|
return 0;
|
|
|
|
return 1;
|
2000-11-01 23:11:19 +00:00
|
|
|
}
|
|
|
|
|
2015-01-21 23:55:44 +00:00
|
|
|
/*
|
|
|
|
* Called when the dirty side of the SSL has lost its connection. This is
|
|
|
|
* pretty terminal as all that can be left to do is send any buffered output
|
|
|
|
* on the clean side - after that, we're done.
|
|
|
|
*/
|
|
|
|
int state_machine_close_dirty(state_machine_t * machine)
|
2000-11-01 23:11:19 +00:00
|
|
|
{
|
2015-01-21 23:55:44 +00:00
|
|
|
buffer_close(&machine->dirty_in);
|
|
|
|
buffer_close(&machine->dirty_out);
|
|
|
|
buffer_close(&machine->clean_in);
|
|
|
|
if (machine->ssl)
|
|
|
|
SSL_free(machine->ssl);
|
|
|
|
machine->ssl = NULL;
|
|
|
|
machine->bio_intossl = machine->bio_fromssl = NULL;
|
|
|
|
if (buffer_empty(&machine->clean_out))
|
|
|
|
return 0;
|
|
|
|
return 1;
|
2000-11-01 23:11:19 +00:00
|
|
|
}
|
|
|
|
|
2015-01-21 23:55:44 +00:00
|
|
|
#endif /* !defined(NO_TUNALA) */
|