Return an error if no recipient type matches.
[openssl.git] / demos / tunala / sm.c
1 #include "tunala.h"
2
3 #ifndef NO_TUNALA
4
5 void state_machine_init(state_machine_t *machine)
6 {
7         machine->ssl = NULL;
8         machine->bio_intossl = machine->bio_fromssl = NULL;
9         buffer_init(&machine->clean_in);
10         buffer_init(&machine->clean_out);
11         buffer_init(&machine->dirty_in);
12         buffer_init(&machine->dirty_out);
13 }
14
15 void state_machine_close(state_machine_t *machine)
16 {
17         if(machine->ssl)
18                 SSL_free(machine->ssl);
19 /* SSL_free seems to decrement the reference counts already so doing this goes
20  * kaboom. */
21 #if 0
22         if(machine->bio_intossl)
23                 BIO_free(machine->bio_intossl);
24         if(machine->bio_fromssl)
25                 BIO_free(machine->bio_fromssl);
26 #endif
27         buffer_close(&machine->clean_in);
28         buffer_close(&machine->clean_out);
29         buffer_close(&machine->dirty_in);
30         buffer_close(&machine->dirty_out);
31         state_machine_init(machine);
32 }
33
34 buffer_t *state_machine_get_buffer(state_machine_t *machine, sm_buffer_t type)
35 {
36         switch(type) {
37         case SM_CLEAN_IN:
38                 return &machine->clean_in;
39         case SM_CLEAN_OUT:
40                 return &machine->clean_out;
41         case SM_DIRTY_IN:
42                 return &machine->dirty_in;
43         case SM_DIRTY_OUT:
44                 return &machine->dirty_out;
45         default:
46                 break;
47         }
48         /* Should never get here */
49         abort();
50         return NULL;
51 }
52
53 SSL *state_machine_get_SSL(state_machine_t *machine)
54 {
55         return machine->ssl;
56 }
57
58 int state_machine_set_SSL(state_machine_t *machine, SSL *ssl, int is_server)
59 {
60         if(machine->ssl)
61                 /* Shouldn't ever be set twice */
62                 abort();
63         machine->ssl = ssl;
64         /* Create the BIOs to handle the dirty side of the SSL */
65         if((machine->bio_intossl = BIO_new(BIO_s_mem())) == NULL)
66                 abort();
67         if((machine->bio_fromssl = BIO_new(BIO_s_mem())) == NULL)
68                 abort();
69         /* Hook up the BIOs on the dirty side of the SSL */
70         SSL_set_bio(machine->ssl, machine->bio_intossl, machine->bio_fromssl);
71         if(is_server)
72                 SSL_set_accept_state(machine->ssl);
73         else
74                 SSL_set_connect_state(machine->ssl);
75         /* If we're the first one to generate traffic - do it now otherwise we
76          * go into the next select empty-handed and our peer will not send data
77          * but will similarly wait for us. */
78         return state_machine_churn(machine);
79 }
80
81 /* Performs the data-IO loop and returns zero if the machine should close */
82 int state_machine_churn(state_machine_t *machine)
83 {
84         unsigned int loop;
85         if(machine->ssl == NULL) {
86                 if(buffer_empty(&machine->clean_out))
87                         /* Time to close this state-machine altogether */
88                         return 0;
89                 else
90                         /* Still buffered data on the clean side to go out */
91                         return 1;
92         }
93         /* Do this loop twice to cover any dependencies about which precise
94          * order of reads and writes is required. */
95         for(loop = 0; loop < 2; loop++) {
96                 buffer_to_SSL(&machine->clean_in, machine->ssl);
97                 buffer_to_BIO(&machine->dirty_in, machine->bio_intossl);
98                 buffer_from_SSL(&machine->clean_out, machine->ssl);
99                 buffer_from_BIO(&machine->dirty_out, machine->bio_fromssl);
100         }
101         /* We close on the SSL side if the info callback noticed some problems
102          * or an SSL shutdown was underway and shutdown traffic had all been
103          * sent. */
104         if(SSL_get_app_data(machine->ssl) || (SSL_get_shutdown(machine->ssl) &&
105                                 buffer_empty(&machine->dirty_out))) {
106                 /* Great, we can seal off the dirty side completely */
107                 if(!state_machine_close_dirty(machine))
108                         return 0;
109         }
110         /* Either the SSL is alive and well, or the closing process still has
111          * outgoing data waiting to be sent */
112         return 1;
113 }
114
115 /* Called when the clean side of the SSL has lost its connection */
116 int state_machine_close_clean(state_machine_t *machine)
117 {
118         /* Well, first thing to do is null out the clean-side buffers - they're
119          * no use any more. */
120         buffer_close(&machine->clean_in);
121         buffer_close(&machine->clean_out);
122         /* And start an SSL shutdown */
123         if(machine->ssl)
124                 SSL_shutdown(machine->ssl);
125         /* This is an "event", so flush the SSL of any generated traffic */
126         state_machine_churn(machine);
127         if(buffer_empty(&machine->dirty_in) &&
128                         buffer_empty(&machine->dirty_out))
129                 return 0;
130         return 1;
131 }
132
133 /* Called when the dirty side of the SSL has lost its connection. This is pretty
134  * terminal as all that can be left to do is send any buffered output on the
135  * clean side - after that, we're done. */
136 int state_machine_close_dirty(state_machine_t *machine)
137 {
138         buffer_close(&machine->dirty_in);
139         buffer_close(&machine->dirty_out);
140         buffer_close(&machine->clean_in);
141         if(machine->ssl)
142                 SSL_free(machine->ssl);
143         machine->ssl = NULL;
144         machine->bio_intossl = machine->bio_fromssl = NULL;
145         if(buffer_empty(&machine->clean_out))
146                 return 0;
147         return 1;
148 }
149
150 #endif /* !defined(NO_TUNALA) */
151