dirplex: Added reparse support.
[ashd.git] / src / ssl-gnutls.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 <stdlib.h>
20 #include <unistd.h>
21 #include <string.h>
22 #include <fcntl.h>
23 #include <dirent.h>
24 #include <sys/socket.h>
25 #include <netinet/in.h>
26 #include <arpa/inet.h>
27 #include <errno.h>
28
29 #ifdef HAVE_CONFIG_H
30 #include <config.h>
31 #endif
32 #include <utils.h>
33 #include <mt.h>
34 #include <mtio.h>
35 #include <req.h>
36 #include <log.h>
37
38 #include "htparser.h"
39
40 #ifdef HAVE_GNUTLS
41
42 #include <gnutls/gnutls.h>
43 #include <gnutls/x509.h>
44
45 struct namedcreds {
46     char **names;
47     gnutls_certificate_credentials_t creds;
48 };
49
50 struct ncredbuf {
51     struct namedcreds **b;
52     size_t s, d;
53 };
54
55 struct sslport {
56     int fd;
57     int sport;
58     gnutls_certificate_credentials_t creds;
59     gnutls_priority_t ciphers;
60     struct namedcreds **ncreds;
61 };
62
63 struct sslconn {
64     int fd;
65     struct sslport *port;
66     struct sockaddr_storage name;
67     gnutls_session_t sess;
68     struct charbuf in;
69 };
70
71 struct savedsess {
72     struct savedsess *next, *prev;
73     gnutls_datum_t key, value;
74 };
75
76 static int numconn = 0, numsess = 0;
77 static struct btree *sessidx = NULL;
78 static struct savedsess *sesslistf = NULL, *sesslistl = NULL;
79
80 static int sesscmp(void *ap, void *bp)
81 {
82     struct savedsess *a = ap, *b = bp;
83     
84     if(a->key.size != b->key.size)
85         return(a->key.size - b->key.size);
86     return(memcmp(a->key.data, b->key.data, a->key.size));
87 }
88
89 static gnutls_datum_t sessdbfetch(void *uudata, gnutls_datum_t key)
90 {
91     struct savedsess *sess, lkey;
92     gnutls_datum_t ret;
93     
94     memset(&ret, 0, sizeof(ret));
95     lkey.key = key;
96     if((sess = btreeget(sessidx, &lkey, sesscmp)) == NULL)
97         return(ret);
98     ret.data = memcpy(gnutls_malloc(ret.size = sess->value.size), sess->value.data, sess->value.size);
99     return(ret);
100 }
101
102 static void freesess(struct savedsess *sess)
103 {
104     bbtreedel(&sessidx, sess, sesscmp);
105     if(sess->next)
106         sess->next->prev = sess->prev;
107     if(sess->prev)
108         sess->prev->next = sess->next;
109     if(sess == sesslistf)
110         sesslistf = sess->next;
111     if(sess == sesslistl)
112         sesslistl = sess->prev;
113     free(sess->key.data);
114     free(sess->value.data);
115     free(sess);
116     numsess--;
117 }
118
119 static int sessdbdel(void *uudata, gnutls_datum_t key)
120 {
121     struct savedsess *sess, lkey;
122     
123     lkey.key = key;
124     if((sess = btreeget(sessidx, &lkey, sesscmp)) == NULL)
125         return(-1);
126     freesess(sess);
127     return(0);
128 }
129
130 static void cleansess(void)
131 {
132     while(numsess > (max(numconn, 1) * 100))
133         freesess(sesslistl);
134 }
135
136 static int sessdbstore(void *uudata, gnutls_datum_t key, gnutls_datum_t value)
137 {
138     static int cc = 0;
139     struct savedsess *sess, lkey;
140     
141     if((value.data == NULL) || (value.size == 0)) {
142         sessdbdel(NULL, key);
143         return(0);
144     }
145     lkey.key = key;
146     if((sess = btreeget(sessidx, &lkey, sesscmp)) == NULL) {
147         omalloc(sess);
148         sess->key.data = memcpy(smalloc(sess->key.size = key.size), key.data, key.size);
149         sess->value.data = memcpy(smalloc(sess->value.size = value.size), value.data, value.size);
150         bbtreeput(&sessidx, sess, sesscmp);
151         sess->prev = NULL;
152         sess->next = sesslistf;
153         if(sesslistf)
154             sesslistf->prev = sess;
155         sesslistf = sess;
156         if(sesslistl == NULL)
157             sesslistl = sess;
158         numsess++;
159     } else {
160         free(sess->value.data);
161         sess->value.data = memcpy(smalloc(sess->value.size = value.size), value.data, value.size);
162         if(sess != sesslistf) {
163             if(sess->next)
164                 sess->next->prev = sess->prev;
165             if(sess->prev)
166                 sess->prev->next = sess->next;
167             if(sess == sesslistl)
168                 sesslistl = sess->prev;
169             sess->prev = NULL;
170             sess->next = sesslistf;
171             if(sesslistf)
172                 sesslistf->prev = sess;
173             sesslistf = sess;
174         }
175     }
176     if(cc++ > 100) {
177         cleansess();
178         cc = 0;
179     }
180     return(0);
181 }
182
183 static int tlsblock(int fd, gnutls_session_t sess, time_t to)
184 {
185     if(gnutls_record_get_direction(sess))
186         return(block(fd, EV_WRITE, to));
187     else
188         return(block(fd, EV_READ, to));
189 }
190
191 static ssize_t sslread(void *cookie, char *buf, size_t len)
192 {
193     struct sslconn *ssl = cookie;
194     ssize_t xf;
195     int ret;
196
197     while(ssl->in.d == 0) {
198         sizebuf(ssl->in, ssl->in.d + 1024);
199         ret = gnutls_record_recv(ssl->sess, ssl->in.b + ssl->in.d, ssl->in.s - ssl->in.d);
200         if((ret == GNUTLS_E_INTERRUPTED) || (ret == GNUTLS_E_AGAIN)) {
201             if(tlsblock(ssl->fd, ssl->sess, 60) == 0) {
202                 errno = ETIMEDOUT;
203                 return(-1);
204             }
205         } else if(ret < 0) {
206             errno = EIO;
207             return(-1);
208         } else if(ret == 0) {
209             return(0);
210         } else {
211             ssl->in.d += ret;
212         }
213     }
214     xf = min(ssl->in.d, len);
215     memcpy(buf, ssl->in.b, xf);
216     memmove(ssl->in.b, ssl->in.b + xf, ssl->in.d -= xf);
217     return(xf);
218 }
219
220 static ssize_t sslwrite(void *cookie, const char *buf, size_t len)
221 {
222     struct sslconn *ssl = cookie;
223     int ret;
224     size_t off;
225     
226     off = 0;
227     while(off < len) {
228         ret = gnutls_record_send(ssl->sess, buf + off, len - off);
229         if((ret == GNUTLS_E_INTERRUPTED) || (ret == GNUTLS_E_AGAIN)) {
230             if(tlsblock(ssl->fd, ssl->sess, 60) == 0) {
231                 if(off == 0) {
232                     errno = ETIMEDOUT;
233                     return(-1);
234                 }
235                 return(off);
236             }
237         } else if(ret < 0) {
238             if(off == 0) {
239                 errno = EIO;
240                 return(-1);
241             }
242             return(off);
243         } else {
244             off += ret;
245         }
246     }
247     return(off);
248 }
249
250 static int sslclose(void *cookie)
251 {
252     struct sslconn *ssl = cookie;
253     
254     buffree(ssl->in);
255     return(0);
256 }
257
258 static cookie_io_functions_t iofuns = {
259     .read = sslread,
260     .write = sslwrite,
261     .close = sslclose,
262 };
263
264 static int initreq(struct conn *conn, struct hthead *req)
265 {
266     struct sslconn *ssl = conn->pdata;
267     struct sockaddr_storage sa;
268     socklen_t salen;
269     char nmbuf[256];
270     
271     headappheader(req, "X-Ash-Address", formathaddress((struct sockaddr *)&ssl->name, sizeof(sa)));
272     if(ssl->name.ss_family == AF_INET) {
273         headappheader(req, "X-Ash-Address", inet_ntop(AF_INET, &((struct sockaddr_in *)&ssl->name)->sin_addr, nmbuf, sizeof(nmbuf)));
274         headappheader(req, "X-Ash-Port", sprintf3("%i", ntohs(((struct sockaddr_in *)&ssl->name)->sin_port)));
275     } else if(ssl->name.ss_family == AF_INET6) {
276         headappheader(req, "X-Ash-Address", inet_ntop(AF_INET6, &((struct sockaddr_in6 *)&ssl->name)->sin6_addr, nmbuf, sizeof(nmbuf)));
277         headappheader(req, "X-Ash-Port", sprintf3("%i", ntohs(((struct sockaddr_in6 *)&ssl->name)->sin6_port)));
278     }
279     salen = sizeof(sa);
280     if(!getsockname(ssl->fd, (struct sockaddr *)&sa, &salen))
281         headappheader(req, "X-Ash-Server-Address", formathaddress((struct sockaddr *)&sa, sizeof(sa)));
282     headappheader(req, "X-Ash-Server-Port", sprintf3("%i", ssl->port->sport));
283     headappheader(req, "X-Ash-Protocol", "https");
284     return(0);
285 }
286
287 static void servessl(struct muth *muth, va_list args)
288 {
289     vavar(int, fd);
290     vavar(struct sockaddr_storage, name);
291     vavar(struct sslport *, pd);
292     struct conn conn;
293     struct sslconn ssl;
294     gnutls_session_t sess;
295     int ret;
296     FILE *in;
297     
298     int setcreds(gnutls_session_t sess)
299     {
300         int i, o, u;
301         unsigned int ntype;
302         char nambuf[256];
303         size_t namlen;
304         
305         for(i = 0; 1; i++) {
306             namlen = sizeof(nambuf);
307             if(gnutls_server_name_get(sess, nambuf, &namlen, &ntype, i) != 0)
308                 break;
309             if(ntype != GNUTLS_NAME_DNS)
310                 continue;
311             for(o = 0; pd->ncreds[o] != NULL; o++) {
312                 for(u = 0; pd->ncreds[o]->names[u] != NULL; u++) {
313                     if(!strcmp(pd->ncreds[o]->names[u], nambuf)) {
314                         gnutls_credentials_set(sess, GNUTLS_CRD_CERTIFICATE, pd->ncreds[o]->creds);
315                         gnutls_certificate_server_set_request(sess, GNUTLS_CERT_REQUEST);
316                         return(0);
317                     }
318                 }
319             }
320         }
321         gnutls_credentials_set(sess, GNUTLS_CRD_CERTIFICATE, pd->creds);
322         gnutls_certificate_server_set_request(sess, GNUTLS_CERT_REQUEST);
323         return(0);
324     }
325
326     numconn++;
327     fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) | O_NONBLOCK);
328     gnutls_init(&sess, GNUTLS_SERVER);
329     gnutls_priority_set(sess, pd->ciphers);
330     gnutls_db_set_retrieve_function(sess, sessdbfetch);
331     gnutls_db_set_store_function(sess, sessdbstore);
332     gnutls_db_set_remove_function(sess, sessdbdel);
333     gnutls_db_set_ptr(sess, NULL);
334     gnutls_handshake_set_post_client_hello_function(sess, setcreds);
335     gnutls_transport_set_ptr(sess, (gnutls_transport_ptr_t)(intptr_t)fd);
336     while((ret = gnutls_handshake(sess)) != 0) {
337         if((ret != GNUTLS_E_INTERRUPTED) && (ret != GNUTLS_E_AGAIN))
338             goto out;
339         if(tlsblock(fd, sess, 60) <= 0)
340             goto out;
341     }
342     memset(&conn, 0, sizeof(conn));
343     memset(&ssl, 0, sizeof(ssl));
344     conn.pdata = &ssl;
345     conn.initreq = initreq;
346     ssl.fd = fd;
347     ssl.port = pd;
348     ssl.name = name;
349     ssl.sess = sess;
350     bufinit(ssl.in);
351     in = fopencookie(&ssl, "r+", iofuns);
352     serve(in, &conn);
353     
354 out:
355     gnutls_deinit(sess);
356     close(fd);
357     numconn--;
358 }
359
360 static void listenloop(struct muth *muth, va_list args)
361 {
362     vavar(struct sslport *, pd);
363     int i, ns, n;
364     struct sockaddr_storage name;
365     socklen_t namelen;
366     
367     fcntl(pd->fd, F_SETFL, fcntl(pd->fd, F_GETFL) | O_NONBLOCK);
368     while(1) {
369         namelen = sizeof(name);
370         if(block(pd->fd, EV_READ, 0) == 0)
371             goto out;
372         n = 0;
373         while(1) {
374             ns = accept(pd->fd, (struct sockaddr *)&name, &namelen);
375             if(ns < 0) {
376                 if(errno == EAGAIN)
377                     break;
378                 if(errno == ECONNABORTED)
379                     continue;
380                 flog(LOG_ERR, "accept: %s", strerror(errno));
381                 goto out;
382             }
383             mustart(servessl, ns, name, pd);
384             if(++n >= 100)
385                 break;
386         }
387     }
388     
389 out:
390     close(pd->fd);
391     free(pd);
392     for(i = 0; i < listeners.d; i++) {
393         if(listeners.b[i] == muth)
394             bufdel(listeners, i);
395     }
396 }
397
398 static gnutls_dh_params_t dhparams(void)
399 {
400     static int inited = 0;
401     static gnutls_dh_params_t pars;
402     int ret;
403     
404     if(!inited) {
405         if(((ret = gnutls_dh_params_init(&pars)) != 0) ||
406            ((ret = gnutls_dh_params_generate2(pars, 2048)) != 0)) {
407             flog(LOG_ERR, "GnuTLS could not generate Diffie-Hellman parameters: %s", gnutls_strerror(ret));
408             exit(1);
409         }
410         inited = 1;
411     }
412     return(pars);
413 }
414
415 static void init(void)
416 {
417     static int inited = 0;
418     int ret;
419     
420     if(inited)
421         return;
422     inited = 1;
423     if((ret = gnutls_global_init()) != 0) {
424         flog(LOG_ERR, "could not initialize GnuTLS: %s", gnutls_strerror(ret));
425         exit(1);
426     }
427 }
428
429 static struct namedcreds *readncreds(char *file)
430 {
431     int i, fd, ret;
432     struct namedcreds *nc;
433     gnutls_x509_crt_t crt;
434     gnutls_x509_privkey_t key;
435     char cn[1024];
436     size_t cnl;
437     gnutls_datum_t d;
438     struct charbuf keybuf;
439     struct charvbuf names;
440     unsigned int type;
441     
442     bufinit(keybuf);
443     bufinit(names);
444     if((fd = open(file, O_RDONLY)) < 0) {
445         flog(LOG_ERR, "ssl: %s: %s", file, strerror(errno));
446         exit(1);
447     }
448     while(1) {
449         sizebuf(keybuf, keybuf.d + 1024);
450         ret = read(fd, keybuf.b + keybuf.d, keybuf.s - keybuf.d);
451         if(ret < 0) {
452             flog(LOG_ERR, "ssl: reading from %s: %s", file, strerror(errno));
453             exit(1);
454         } else if(ret == 0) {
455             break;
456         }
457         keybuf.d += ret;
458     }
459     close(fd);
460     d.data = (unsigned char *)keybuf.b;
461     d.size = keybuf.d;
462     gnutls_x509_crt_init(&crt);
463     if((ret = gnutls_x509_crt_import(crt, &d, GNUTLS_X509_FMT_PEM)) != 0) {
464         flog(LOG_ERR, "ssl: could not load certificate from %s: %s", file, gnutls_strerror(ret));
465         exit(1);
466     }
467     cnl = sizeof(cn) - 1;
468     if((ret = gnutls_x509_crt_get_dn_by_oid(crt, GNUTLS_OID_X520_COMMON_NAME, 0, 0, cn, &cnl)) != 0) {
469         flog(LOG_ERR, "ssl: could not read common name from %s: %s", file, gnutls_strerror(ret));
470         exit(1);
471     }
472     cn[cnl] = 0;
473     bufadd(names, sstrdup(cn));
474     for(i = 0; 1; i++) {
475         cnl = sizeof(cn) - 1;
476         if(gnutls_x509_crt_get_subject_alt_name2(crt, i, cn, &cnl, &type, NULL) < 0)
477             break;
478         cn[cnl] = 0;
479         if(type == GNUTLS_SAN_DNSNAME)
480             bufadd(names, sstrdup(cn));
481     }
482     gnutls_x509_privkey_init(&key);
483     if((ret = gnutls_x509_privkey_import(key, &d, GNUTLS_X509_FMT_PEM)) != 0) {
484         flog(LOG_ERR, "ssl: could not load key from %s: %s", file, gnutls_strerror(ret));
485         exit(1);
486     }
487     buffree(keybuf);
488     bufadd(names, NULL);
489     omalloc(nc);
490     nc->names = names.b;
491     gnutls_certificate_allocate_credentials(&nc->creds);
492     if((ret = gnutls_certificate_set_x509_key(nc->creds, &crt, 1, key)) != 0) {
493         flog(LOG_ERR, "ssl: could not use certificate from %s: %s", file, gnutls_strerror(ret));
494         exit(1);
495     }
496     gnutls_certificate_set_dh_params(nc->creds, dhparams());
497     return(nc);
498 }
499
500 static void readncdir(struct ncredbuf *buf, char *dir)
501 {
502     DIR *d;
503     struct dirent *e;
504     size_t es;
505     
506     if((d = opendir(dir)) == NULL) {
507         flog(LOG_ERR, "ssl: could not read certificate directory %s: %s", dir, strerror(errno));
508         exit(1);
509     }
510     while((e = readdir(d)) != NULL) {
511         if(e->d_name[0] == '.')
512             continue;
513         if((es = strlen(e->d_name)) <= 4)
514             continue;
515         if(strcmp(e->d_name + es - 4, ".crt"))
516             continue;
517         bufadd(*buf, readncreds(sprintf3("%s/%s", dir, e->d_name)));
518     }
519     closedir(d);
520 }
521
522 void handlegnussl(int argc, char **argp, char **argv)
523 {
524     int i, ret, port, fd;
525     gnutls_certificate_credentials_t creds;
526     gnutls_priority_t ciphers;
527     struct ncredbuf ncreds;
528     struct sslport *pd;
529     char *crtfile, *keyfile, *perr;
530     
531     init();
532     port = 443;
533     bufinit(ncreds);
534     gnutls_certificate_allocate_credentials(&creds);
535     keyfile = crtfile = NULL;
536     ciphers = NULL;
537     for(i = 0; i < argc; i++) {
538         if(!strcmp(argp[i], "help")) {
539             printf("ssl handler parameters:\n");
540             printf("\tcert=CERT-FILE  [mandatory]\n");
541             printf("\t\tThe name of the file to read the certificate from.\n");
542             printf("\tkey=KEY-FILE    [same as CERT-FILE]\n");
543             printf("\t\tThe name of the file to read the private key from.\n");
544             printf("\tprio=PRIORITIES [NORMAL]\n");
545             printf("\t\tCiphersuite priorities, as a GnuTLS priority string.\n");
546             printf("\ttrust=CA-FILE   [no default]\n");
547             printf("\t\tThe name of a file to read trusted certificates from.\n");
548             printf("\t\tMay be given multiple times.\n");
549             printf("\tcrl=CRL-FILE    [no default]\n");
550             printf("\t\tThe name of a file to read revocation lists from.\n");
551             printf("\t\tMay be given multiple times.\n");
552             printf("\tncert=CERT-FILE [no default]\n");
553             printf("\t\tThe name of a file to read a named certificate from,\n");
554             printf("\t\tfor use with SNI-enabled clients.\n");
555             printf("\t\tMay be given multiple times.\n");
556             printf("\tncertdir=DIR    [no default]\n");
557             printf("\t\tRead all *.crt files in the given directory as if they\n");
558             printf("\t\twere given with `ncert' options.\n");
559             printf("\t\tMay be given multiple times.\n");
560             printf("\tport=PORT       [443]\n");
561             printf("\t\tThe TCP port to listen on.\n");
562             printf("\n");
563             printf("\tAll X.509 data files must be PEM-encoded.\n");
564             printf("\tIf any certificates were given with `ncert' options, they will be\n");
565             printf("\tused if a client explicitly names one of them with a\n");
566             printf("\tserver-name indication. If a client indicates no server name,\n");
567             printf("\tor if a server-name indication does not match any given\n");
568             printf("\tcertificate, the certificate given with the `cert' option will\n");
569             printf("\tbe used instead.\n");
570             exit(0);
571         } else if(!strcmp(argp[i], "cert")) {
572             crtfile = argv[i];
573         } else if(!strcmp(argp[i], "key")) {
574             keyfile = argv[i];
575         } else if(!strcmp(argp[i], "prio")) {
576             if(ciphers != NULL)
577                 gnutls_priority_deinit(ciphers);
578             ret = gnutls_priority_init(&ciphers, argv[i], (const char **)&perr);
579             if(ret == GNUTLS_E_INVALID_REQUEST) {
580                 flog(LOG_ERR, "ssl: invalid cipher priority string, at `%s'", perr);
581                 exit(1);
582             } else if(ret != 0) {
583                 flog(LOG_ERR, "ssl: could not initialize cipher priorities: %s", gnutls_strerror(ret));
584                 exit(1);
585             }
586         } else if(!strcmp(argp[i], "trust")) {
587             if((ret = gnutls_certificate_set_x509_trust_file(creds, argv[i], GNUTLS_X509_FMT_PEM)) != 0) {
588                 flog(LOG_ERR, "ssl: could not load trust file `%s': %s", argv[i], gnutls_strerror(ret));
589                 exit(1);
590             }
591             for(i = 0; i < ncreds.d; i++) {
592                 if((ret = gnutls_certificate_set_x509_trust_file(ncreds.b[i]->creds, argv[i], GNUTLS_X509_FMT_PEM)) != 0) {
593                     flog(LOG_ERR, "ssl: could not load trust file `%s': %s", argv[i], gnutls_strerror(ret));
594                     exit(1);
595                 }
596             }
597         } else if(!strcmp(argp[i], "crl")) {
598             if((ret = gnutls_certificate_set_x509_crl_file(creds, argv[i], GNUTLS_X509_FMT_PEM)) != 0) {
599                 flog(LOG_ERR, "ssl: could not load CRL file `%s': %s", argv[i], gnutls_strerror(ret));
600                 exit(1);
601             }
602             for(i = 0; i < ncreds.d; i++) {
603                 if((ret = gnutls_certificate_set_x509_crl_file(ncreds.b[i]->creds, argv[i], GNUTLS_X509_FMT_PEM)) != 0) {
604                     flog(LOG_ERR, "ssl: could not load CRL file `%s': %s", argv[i], gnutls_strerror(ret));
605                     exit(1);
606                 }
607             }
608         } else if(!strcmp(argp[i], "port")) {
609             port = atoi(argv[i]);
610         } else if(!strcmp(argp[i], "ncert")) {
611             bufadd(ncreds, readncreds(argv[i]));
612         } else if(!strcmp(argp[i], "ncertdir")) {
613             readncdir(&ncreds, argv[i]);
614         } else {
615             flog(LOG_ERR, "unknown parameter `%s' to ssl handler", argp[i]);
616             exit(1);
617         }
618     }
619     if(crtfile == NULL) {
620         flog(LOG_ERR, "ssl: needs certificate file at the very least");
621         exit(1);
622     }
623     if((fd = listensock6(port)) < 0) {
624         flog(LOG_ERR, "could not listen on IPv6 port (port %i): %s", port, strerror(errno));
625         exit(1);
626     }
627     if(keyfile == NULL)
628         keyfile = crtfile;
629     if((ret = gnutls_certificate_set_x509_key_file(creds, crtfile, keyfile, GNUTLS_X509_FMT_PEM)) != 0) {
630         flog(LOG_ERR, "ssl: could not load certificate or key: %s", gnutls_strerror(ret));
631         exit(1);
632     }
633     if((ciphers == NULL) && ((ret = gnutls_priority_init(&ciphers, "NORMAL", NULL)) != 0)) {
634         flog(LOG_ERR, "ssl: could not initialize cipher priorities: %s", gnutls_strerror(ret));
635         exit(1);
636     }
637     gnutls_certificate_set_dh_params(creds, dhparams());
638     bufadd(ncreds, NULL);
639     omalloc(pd);
640     pd->fd = fd;
641     pd->sport = port;
642     pd->creds = creds;
643     pd->ncreds = ncreds.b;
644     pd->ciphers = ciphers;
645     bufadd(listeners, mustart(listenloop, pd));
646     if((fd = listensock4(port)) < 0) {
647         if(errno != EADDRINUSE) {
648             flog(LOG_ERR, "could not listen on IPv4 port (port %i): %s", port, strerror(errno));
649             exit(1);
650         }
651     } else {
652         omalloc(pd);
653         pd->fd = fd;
654         pd->sport = port;
655         pd->creds = creds;
656         pd->ncreds = ncreds.b;
657         pd->ciphers = ciphers;
658         bufadd(listeners, mustart(listenloop, pd));
659     }
660 }
661
662 #endif