Remove demos/tunala

[openssl.git] / demos / tunala / sm.c

diff --git a/demos/tunala/sm.c b/demos/tunala/sm.c
deleted file mode 100644 (file)
index 25359e6..0000000
--- a/demos/tunala/sm.c
+++ /dev/null
@@ -1,151 +0,0 @@
-#include "tunala.h"
-
-#ifndef NO_TUNALA
-
-void state_machine_init(state_machine_t *machine)
-{
-       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);
-}
-
-void state_machine_close(state_machine_t *machine)
-{
-       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);
-}
-
-buffer_t *state_machine_get_buffer(state_machine_t *machine, sm_buffer_t type)
-{
-       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;
-}
-
-SSL *state_machine_get_SSL(state_machine_t *machine)
-{
-       return machine->ssl;
-}
-
-int state_machine_set_SSL(state_machine_t *machine, SSL *ssl, int is_server)
-{
-       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);
-}
-
-/* Performs the data-IO loop and returns zero if the machine should close */
-int state_machine_churn(state_machine_t *machine)
-{
-       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;
-}
-
-/* Called when the clean side of the SSL has lost its connection */
-int state_machine_close_clean(state_machine_t *machine)
-{
-       /* 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;
-}
-
-/* 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)
-{
-       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;
-}
-
-#endif /* !defined(NO_TUNALA) */
-