python3: Encode ashd-wsgi3 output headers with utf-8 instead of latin-1.
[ashd.git] / src / ssl-openssl.c
1 /*
2     ashd - A Sane HTTP Daemon
3     Copyright (C) 2008  Fredrik Tolf <fredrik@dolda2000.com>
4
5     This program is free software: you can redistribute it and/or modify
6     it under the terms of the GNU General Public License as published by
7     the Free Software Foundation, either version 3 of the License, or
8     (at your option) any later version.
9
10     This program is distributed in the hope that it will be useful,
11     but WITHOUT ANY WARRANTY; without even the implied warranty of
12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13     GNU General Public License for more details.
14
15     You should have received a copy of the GNU General Public License
16     along with this program.  If not, see <http://www.gnu.org/licenses/>.
17 */
18
19 #include <fcntl.h>
20 #include <unistd.h>
21 #include <string.h>
22 #include <sys/socket.h>
23 #include <netinet/in.h>
24 #include <arpa/inet.h>
25
26 #ifdef HAVE_CONFIG_H
27 #include <config.h>
28 #endif
29 #include <utils.h>
30 #include <mt.h>
31 #include <mtio.h>
32 #include <req.h>
33 #include <log.h>
34 #include <bufio.h>
35
36 #include "htparser.h"
37
38 #ifdef HAVE_OPENSSL
39
40 #include <openssl/ssl.h>
41 #include <openssl/err.h>
42
43 struct sslport {
44     int fd, sport;
45     SSL_CTX *ctx;
46 };
47
48 struct sslconn {
49     struct sslport *port;
50     int fd;
51     SSL *ssl;
52     struct sockaddr *name;
53     socklen_t namelen;
54 };
55
56 static int tlsblock(int fd, int err, int to)
57 {
58     if(err == SSL_ERROR_WANT_READ) {
59         if(block(fd, EV_READ, to) <= 0)
60             return(1);
61         return(0);
62     } else if(err == SSL_ERROR_WANT_WRITE) {
63         if(block(fd, EV_WRITE, to) <= 0)
64             return(1);
65         return(0);
66     } else {
67         return(1);
68     }
69 }
70
71 static ssize_t sslread(void *cookie, void *buf, size_t len)
72 {
73     struct sslconn *sdat = cookie;
74     int ret, err, nb;
75     size_t off;
76     
77     off = 0;
78     while(off < len) {
79         nb = ((len - off) > INT_MAX) ? INT_MAX : (len - off);
80         if((ret = SSL_read(sdat->ssl, buf, nb)) <= 0) {
81             if(off > 0)
82                 return(off);
83             err = SSL_get_error(sdat->ssl, ret);
84             if(err == SSL_ERROR_ZERO_RETURN) {
85                 return(0);
86             } else if((err == SSL_ERROR_WANT_READ) || (err == SSL_ERROR_WANT_WRITE)) {
87                 if(tlsblock(sdat->fd, err, 60)) {
88                     errno = ETIMEDOUT;
89                     return(-1);
90                 }
91             } else {
92                 if(err != SSL_ERROR_SYSCALL)
93                     errno = EPROTO;
94                 return(-1);
95             }
96         } else {
97             off += ret;
98         }
99     }
100     return(off);
101 }
102
103 static ssize_t sslwrite(void *cookie, const void *buf, size_t len)
104 {
105     struct sslconn *sdat = cookie;
106     int ret, err, nb;
107     size_t off;
108     
109     off = 0;
110     while(off < len) {
111         nb = ((len - off) > INT_MAX) ? INT_MAX : (len - off);
112         if((ret = SSL_write(sdat->ssl, buf, nb)) <= 0) {
113             if(off > 0)
114                 return(off);
115             err = SSL_get_error(sdat->ssl, ret);
116             if((err == SSL_ERROR_WANT_READ) || (err == SSL_ERROR_WANT_WRITE)) {
117                 if(tlsblock(sdat->fd, err, 60)) {
118                     errno = ETIMEDOUT;
119                     return(-1);
120                 }
121             } else {
122                 if(err != SSL_ERROR_SYSCALL)
123                     errno = EIO;
124                 return(-1);
125             }
126         } else {
127             off += ret;
128         }
129     }
130     return(off);
131 }
132
133 static int sslclose(void *cookie)
134 {
135     return(0);
136 }
137
138 static struct bufioops iofuns = {
139     .read = sslread,
140     .write = sslwrite,
141     .close = sslclose,
142 };
143
144 static int initreq(struct conn *conn, struct hthead *req)
145 {
146     struct sslconn *sdat = conn->pdata;
147     struct sockaddr_storage sa;
148     socklen_t salen;
149     
150     headappheader(req, "X-Ash-Address", formathaddress(sdat->name, sdat->namelen));
151     if(sdat->name->sa_family == AF_INET)
152         headappheader(req, "X-Ash-Port", sprintf3("%i", ntohs(((struct sockaddr_in *)sdat->name)->sin_port)));
153     else if(sdat->name->sa_family == AF_INET6)
154         headappheader(req, "X-Ash-Port", sprintf3("%i", ntohs(((struct sockaddr_in6 *)sdat->name)->sin6_port)));
155     salen = sizeof(sa);
156     if(!getsockname(sdat->fd, (struct sockaddr *)&sa, &salen))
157         headappheader(req, "X-Ash-Server-Address", formathaddress((struct sockaddr *)&sa, salen));
158     headappheader(req, "X-Ash-Server-Port", sprintf3("%i", sdat->port->sport));
159     headappheader(req, "X-Ash-Protocol", "https");
160     return(0);
161 }
162
163 static void servessl(struct muth *muth, va_list args)
164 {
165     vavar(int, fd);
166     vavar(struct sockaddr_storage, name);
167     vavar(struct sslport *, pd);
168     int ret;
169     SSL *ssl;
170     struct conn conn;
171     struct sslconn sdat;
172     
173     fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) | O_NONBLOCK);
174     ssl = SSL_new(pd->ctx);
175     SSL_set_fd(ssl, fd);
176     while((ret = SSL_accept(ssl)) <= 0) {
177         if(tlsblock(fd, SSL_get_error(ssl, ret), 60))
178             goto out;
179     }
180     memset(&conn, 0, sizeof(conn));
181     memset(&sdat, 0, sizeof(sdat));
182     conn.pdata = &sdat;
183     conn.initreq = initreq;
184     sdat.port = pd;
185     sdat.fd = fd;
186     sdat.ssl = ssl;
187     sdat.name = (struct sockaddr *)&name;
188     sdat.namelen = sizeof(name);
189     serve(bioopen(&sdat, &iofuns), fd, &conn);
190     while((ret = SSL_shutdown(ssl)) < 0) {
191         if(tlsblock(fd, SSL_get_error(ssl, ret), 60))
192             goto out;
193     }
194 out:
195     SSL_free(ssl);
196     close(fd);
197 }
198
199 static void listenloop(struct muth *muth, va_list args)
200 {
201     vavar(struct sslport *, pd);
202     int i, ns, n;
203     struct sockaddr_storage name;
204     socklen_t namelen;
205     
206     fcntl(pd->fd, F_SETFL, fcntl(pd->fd, F_GETFL) | O_NONBLOCK);
207     while(1) {
208         namelen = sizeof(name);
209         if(block(pd->fd, EV_READ, 0) == 0)
210             goto out;
211         for(n = 0; n < 100; n++) {
212             if((ns = accept(pd->fd, (struct sockaddr *)&name, &namelen)) < 0) {
213                 if(errno == EAGAIN)
214                     break;
215                 if(errno == ECONNABORTED)
216                     continue;
217                 flog(LOG_ERR, "accept: %s", strerror(errno));
218                 goto out;
219             }
220             mustart(servessl, ns, name, pd);
221         }
222     }
223     
224 out:
225     close(pd->fd);
226     free(pd);
227     for(i = 0; i < listeners.d; i++) {
228         if(listeners.b[i] == muth)
229             bufdel(listeners, i);
230     }
231 }
232
233 void handleossl(int argc, char **argp, char **argv)
234 {
235     int i, port, fd;
236     SSL_CTX *ctx;
237     char *crtfile, *keyfile;
238     struct sslport *pd;
239     
240     ctx = SSL_CTX_new(TLS_server_method());
241     if(!ctx) {
242         flog(LOG_ERR, "ssl: could not create context: %s", ERR_error_string(ERR_get_error(), NULL));
243         exit(1);
244     }
245     port = 443;
246     for(i = 0; i < argc; i++) {
247         if(!strcmp(argp[i], "help")) {
248             printf("ssl handler parameters:\n");
249             printf("\tcert=CERT-FILE  [mandatory]\n");
250             printf("\t\tThe name of the file to read the certificate from.\n");
251             printf("\tkey=KEY-FILE    [same as CERT-FILE]\n");
252             printf("\t\tThe name of the file to read the private key from.\n");
253             printf("\tport=PORT       [443]\n");
254             printf("\t\tThe TCP port to listen on.\n");
255             exit(0);
256         } else if(!strcmp(argp[i], "cert")) {
257             crtfile = argv[i];
258         } else if(!strcmp(argp[i], "key")) {
259             keyfile = argv[i];
260         } else if(!strcmp(argp[i], "port")) {
261             port = atoi(argv[i]);
262         } else {
263             flog(LOG_ERR, "unknown parameter `%s' to ssl handler", argp[i]);
264             exit(1);
265         }
266     }
267     if(crtfile == NULL) {
268         flog(LOG_ERR, "ssl: needs certificate file at the very least");
269         exit(1);
270     }
271     if(keyfile == NULL)
272         keyfile = crtfile;
273     if(SSL_CTX_use_certificate_file(ctx, crtfile, SSL_FILETYPE_PEM) <= 0) {
274         flog(LOG_ERR, "ssl: could not load certificate: %s", ERR_error_string(ERR_get_error(), NULL));
275         exit(1);
276     }
277     if(SSL_CTX_use_PrivateKey_file(ctx, keyfile, SSL_FILETYPE_PEM) <= 0) {
278         flog(LOG_ERR, "ssl: could not load certificate: %s", ERR_error_string(ERR_get_error(), NULL));
279         exit(1);
280     }
281     if(!SSL_CTX_check_private_key(ctx)) {
282         flog(LOG_ERR, "ssl: key and certificate do not match");
283         exit(1);
284     }
285     if((fd = listensock6(port)) < 0) {
286         flog(LOG_ERR, "could not listen on IPv65 port (port %i): %s", port, strerror(errno));
287         exit(1);
288     }
289     omalloc(pd);
290     pd->fd = fd;
291     pd->sport = port;
292     pd->ctx = ctx;
293     bufadd(listeners, mustart(listenloop, pd));
294     if((fd = listensock4(port)) < 0) {
295         if(errno != EADDRINUSE) {
296             flog(LOG_ERR, "could not listen on IPv4 port (port %i): Is", port, strerror(errno));
297             exit(1);
298         }
299     } else {
300         omalloc(pd);
301         pd->fd = fd;
302         pd->sport = port;
303         pd->ctx = ctx;
304         bufadd(listeners, mustart(listenloop, pd));
305     }
306 }
307
308 #endif