New ctrl to set current certificate.
[openssl.git] / demos / bio / server-arg.c
1 /* NOCW */
2 /* demos/bio/server-arg.c */
3
4 /* A minimal program to serve an SSL connection.
5  * It uses blocking.
6  * It use the SSL_CONF API with the command line.
7  *
8  * cc -I../../include server-arg.c -L../.. -lssl -lcrypto -ldl
9  */
10
11 #include <stdio.h>
12 #include <signal.h>
13 #include <openssl/err.h>
14 #include <openssl/ssl.h>
15
16
17 int main(int argc, char *argv[])
18         {
19         char *port = "*:4433";
20         BIO *ssl_bio,*tmp;
21         SSL_CTX *ctx;
22         SSL_CONF_CTX *cctx;
23         char buf[512];
24         BIO *in=NULL;
25         int ret=1,i;
26         char **args = argv + 1;
27         int nargs = argc - 1;
28
29         SSL_load_error_strings();
30
31         /* Add ciphers and message digests */
32         OpenSSL_add_ssl_algorithms();
33
34         ctx=SSL_CTX_new(SSLv23_server_method());
35
36         cctx = SSL_CONF_CTX_new();
37         SSL_CONF_CTX_set_flags(cctx, SSL_CONF_FLAG_SERVER);
38         SSL_CONF_CTX_set_flags(cctx, SSL_CONF_FLAG_CERTIFICATE);
39         SSL_CONF_CTX_set_ssl_ctx(cctx, ctx);
40         while(*args && **args == '-')
41                 {
42                 int rv;
43                 /* Parse standard arguments */
44                 rv = SSL_CONF_cmd_argv(cctx, &nargs, &args);
45                 if (rv == -3)
46                         {
47                         fprintf(stderr, "Missing argument for %s\n", *args);
48                         goto err;
49                         }
50                 if (rv < 0)
51                         {
52                         fprintf(stderr, "Error in command %s\n", *args);
53                         ERR_print_errors_fp(stderr);
54                         goto err;
55                         }
56                 /* If rv > 0 we processed something so proceed to next arg */
57                 if (rv > 0)
58                         continue;
59                 /* Otherwise application specific argument processing */
60                 if (!strcmp(*args, "-port"))
61                         {
62                         port = args[1];
63                         if (port == NULL)
64                                 {
65                                 fprintf(stderr, "Missing -port argument\n");
66                                 goto err;
67                                 }
68                         args += 2;
69                         nargs -= 2;
70                         continue;
71                         }
72                 else
73                         {
74                         fprintf(stderr, "Unknown argument %s\n", *args);
75                         goto err;
76                         }
77                 }
78
79         if (!SSL_CONF_CTX_finish(cctx))
80                 {
81                 fprintf(stderr, "Finish error\n");
82                 ERR_print_errors_fp(stderr);
83                 goto err;
84                 }
85 #if 0
86         /* Demo of how to iterate over all certificates in an SSL_CTX
87          * structure.
88          */
89         {
90         X509 *x;
91         int rv;
92         rv = SSL_CTX_set_current_cert(ctx, SSL_CERT_SET_FIRST);
93         while (rv)
94                 {
95                 X509 *x = SSL_CTX_get0_certificate(ctx);
96                 X509_NAME_print_ex_fp(stdout, X509_get_subject_name(x), 0, XN_FLAG_ONELINE);
97                 printf("\n");
98                 rv = SSL_CTX_set_current_cert(ctx, SSL_CERT_SET_NEXT);
99                 }
100         fflush(stdout);
101         }
102 #endif
103         /* Setup server side SSL bio */
104         ssl_bio=BIO_new_ssl(ctx,0);
105
106         if ((in=BIO_new_accept(port)) == NULL) goto err;
107
108         /* This means that when a new connection is accepted on 'in',
109          * The ssl_bio will be 'duplicated' and have the new socket
110          * BIO push into it.  Basically it means the SSL BIO will be
111          * automatically setup */
112         BIO_set_accept_bios(in,ssl_bio);
113
114 again:
115         /* The first call will setup the accept socket, and the second
116          * will get a socket.  In this loop, the first actual accept
117          * will occur in the BIO_read() function. */
118
119         if (BIO_do_accept(in) <= 0) goto err;
120
121         for (;;)
122                 {
123                 i=BIO_read(in,buf,512);
124                 if (i == 0)
125                         {
126                         /* If we have finished, remove the underlying
127                          * BIO stack so the next time we call any function
128                          * for this BIO, it will attempt to do an
129                          * accept */
130                         printf("Done\n");
131                         tmp=BIO_pop(in);
132                         BIO_free_all(tmp);
133                         goto again;
134                         }
135                 if (i < 0) goto err;
136                 fwrite(buf,1,i,stdout);
137                 fflush(stdout);
138                 }
139
140         ret=0;
141 err:
142         if (ret)
143                 {
144                 ERR_print_errors_fp(stderr);
145                 }
146         if (in != NULL) BIO_free(in);
147         exit(ret);
148         return(!ret);
149         }
150