source: mod_gnutls/src/gnutls_config.c @ 7d1ab49

debian/masterdebian/stretch-backportsjessie-backportsmsvaupstream
Last change on this file since 7d1ab49 was 7d1ab49, checked in by Daniel Kahn Gillmor <dkg@…>, 7 years ago

restore GnuTLSExportCertificate directive

It looks to me like this option was mistakenly removed when the the
RSA-EXPORT configuration parameters were ripped out, possibly due to
confusion over the term Export.

GnuTLSExportCertificate is a useful configuration directive, and some
users might be relying on it.

  • Property mode set to 100644
File size: 20.5 KB
Line 
1/**
2 *  Copyright 2004-2005 Paul Querna
3 *  Copyright 2008 Nikos Mavrogiannopoulos
4 *  Copyright 2011 Dash Shendy
5 *
6 *  Licensed under the Apache License, Version 2.0 (the "License");
7 *  you may not use this file except in compliance with the License.
8 *  You may obtain a copy of the License at
9 *
10 *      http://www.apache.org/licenses/LICENSE-2.0
11 *
12 *  Unless required by applicable law or agreed to in writing, software
13 *  distributed under the License is distributed on an "AS IS" BASIS,
14 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 *  See the License for the specific language governing permissions and
16 *  limitations under the License.
17 *
18 */
19
20#include "mod_gnutls.h"
21
22static int load_datum_from_file(apr_pool_t * pool,
23        const char *file, gnutls_datum_t * data) {
24    apr_file_t *fp;
25    apr_finfo_t finfo;
26    apr_status_t rv;
27    apr_size_t br = 0;
28
29    rv = apr_file_open(&fp, file, APR_READ | APR_BINARY,
30            APR_OS_DEFAULT, pool);
31    if (rv != APR_SUCCESS) {
32        return rv;
33    }
34
35    rv = apr_file_info_get(&finfo, APR_FINFO_SIZE, fp);
36
37    if (rv != APR_SUCCESS) {
38        return rv;
39    }
40
41    data->data = apr_palloc(pool, finfo.size + 1);
42    rv = apr_file_read_full(fp, data->data, finfo.size, &br);
43
44    if (rv != APR_SUCCESS) {
45        return rv;
46    }
47    apr_file_close(fp);
48
49    data->data[br] = '\0';
50    data->size = br;
51
52    return 0;
53}
54
55const char *mgs_set_dh_file(cmd_parms * parms, void *dummy,
56        const char *arg) {
57    int ret;
58    gnutls_datum_t data;
59    const char *file;
60    apr_pool_t *spool;
61    mgs_srvconf_rec *sc =
62            (mgs_srvconf_rec *) ap_get_module_config(parms->server->
63            module_config,
64            &gnutls_module);
65
66    apr_pool_create(&spool, parms->pool);
67
68    file = ap_server_root_relative(spool, arg);
69
70    if (load_datum_from_file(spool, file, &data) != 0) {
71        return apr_psprintf(parms->pool, "GnuTLS: Error Reading "
72                "DH params '%s'", file);
73    }
74
75    ret = gnutls_dh_params_init(&sc->dh_params);
76    if (ret < 0) {
77        return apr_psprintf(parms->pool,
78                "GnuTLS: Failed to initialize"
79                ": (%d) %s", ret,
80                gnutls_strerror(ret));
81    }
82
83    ret =
84            gnutls_dh_params_import_pkcs3(sc->dh_params, &data,
85            GNUTLS_X509_FMT_PEM);
86    if (ret < 0) {
87        return apr_psprintf(parms->pool,
88                "GnuTLS: Failed to Import "
89                "DH params '%s': (%d) %s", file, ret,
90                gnutls_strerror(ret));
91    }
92
93    apr_pool_destroy(spool);
94
95    return NULL;
96}
97
98const char *mgs_set_cert_file(cmd_parms * parms, void *dummy, const char *arg) {
99
100    int ret;
101    gnutls_datum_t data;
102    const char *file;
103    apr_pool_t *spool;
104
105    mgs_srvconf_rec *sc = (mgs_srvconf_rec *) ap_get_module_config(parms->server->module_config, &gnutls_module);
106    apr_pool_create(&spool, parms->pool);
107
108    file = ap_server_root_relative(spool, arg);
109
110    if (load_datum_from_file(spool, file, &data) != 0) {
111                apr_pool_destroy(spool);
112        return apr_psprintf(parms->pool, "GnuTLS: Error Reading Certificate '%s'", file);
113    }
114
115    sc->certs_x509_chain_num = MAX_CHAIN_SIZE;
116    ret = gnutls_x509_crt_list_import(sc->certs_x509_chain, &sc->certs_x509_chain_num, &data, GNUTLS_X509_FMT_PEM, 0);
117    if (ret < 0) {
118                apr_pool_destroy(spool);
119        return apr_psprintf(parms->pool, "GnuTLS: Failed to Import Certificate '%s': (%d) %s", file, ret, gnutls_strerror(ret));
120    }
121   
122        apr_pool_destroy(spool);
123    return NULL;
124
125}
126
127const char *mgs_set_key_file(cmd_parms * parms, void *dummy, const char *arg) {
128
129    int ret;
130    gnutls_datum_t data;
131    const char *file;
132    apr_pool_t *spool;
133    const char *out;
134
135        mgs_srvconf_rec *sc = (mgs_srvconf_rec *) ap_get_module_config(parms->server->module_config, &gnutls_module);
136   
137        apr_pool_create(&spool, parms->pool);
138
139    file = ap_server_root_relative(spool, arg);
140
141    if (load_datum_from_file(spool, file, &data) != 0) {
142        out = apr_psprintf(parms->pool, "GnuTLS: Error Reading Private Key '%s'", file);
143                apr_pool_destroy(spool);
144        return out;
145    }
146
147    ret = gnutls_x509_privkey_init(&sc->privkey_x509);
148
149    if (ret < 0) {
150                apr_pool_destroy(spool);
151        return apr_psprintf(parms->pool, "GnuTLS: Failed to initialize: (%d) %s", ret, gnutls_strerror(ret));
152    }
153
154    ret = gnutls_x509_privkey_import(sc->privkey_x509, &data, GNUTLS_X509_FMT_PEM);
155
156    if (ret < 0) {
157        ret = gnutls_x509_privkey_import_pkcs8(sc->privkey_x509, &data, GNUTLS_X509_FMT_PEM, NULL, GNUTLS_PKCS_PLAIN);
158        }
159
160    if (ret < 0) {
161        out = apr_psprintf(parms->pool, "GnuTLS: Failed to Import Private Key '%s': (%d) %s", file, ret, gnutls_strerror(ret));
162                apr_pool_destroy(spool);
163        return out;
164    }
165
166    apr_pool_destroy(spool);
167
168    return NULL;
169}
170
171const char *mgs_set_pgpcert_file(cmd_parms * parms, void *dummy,
172        const char *arg) {
173    int ret;
174    gnutls_datum_t data;
175    const char *file;
176    apr_pool_t *spool;
177    mgs_srvconf_rec *sc =
178            (mgs_srvconf_rec *) ap_get_module_config(parms->server->
179            module_config,
180            &gnutls_module);
181    apr_pool_create(&spool, parms->pool);
182
183    file = ap_server_root_relative(spool, arg);
184
185    if (load_datum_from_file(spool, file, &data) != 0) {
186        return apr_psprintf(parms->pool, "GnuTLS: Error Reading "
187                "Certificate '%s'", file);
188    }
189
190    ret = gnutls_openpgp_crt_init(&sc->cert_pgp);
191    if (ret < 0) {
192        return apr_psprintf(parms->pool, "GnuTLS: Failed to Init "
193                "PGP Certificate: (%d) %s", ret,
194                gnutls_strerror(ret));
195    }
196
197    ret =
198            gnutls_openpgp_crt_import(sc->cert_pgp, &data,
199            GNUTLS_OPENPGP_FMT_BASE64);
200    if (ret < 0) {
201        return apr_psprintf(parms->pool,
202                "GnuTLS: Failed to Import "
203                "PGP Certificate '%s': (%d) %s", file,
204                ret, gnutls_strerror(ret));
205    }
206
207    apr_pool_destroy(spool);
208    return NULL;
209}
210
211const char *mgs_set_pgpkey_file(cmd_parms * parms, void *dummy,
212        const char *arg) {
213    int ret;
214    gnutls_datum_t data;
215    const char *file;
216    apr_pool_t *spool;
217    mgs_srvconf_rec *sc =
218            (mgs_srvconf_rec *) ap_get_module_config(parms->server->
219            module_config,
220            &gnutls_module);
221    apr_pool_create(&spool, parms->pool);
222
223    file = ap_server_root_relative(spool, arg);
224
225    if (load_datum_from_file(spool, file, &data) != 0) {
226        return apr_psprintf(parms->pool, "GnuTLS: Error Reading "
227                "Private Key '%s'", file);
228    }
229
230    ret = gnutls_openpgp_privkey_init(&sc->privkey_pgp);
231    if (ret < 0) {
232        return apr_psprintf(parms->pool,
233                "GnuTLS: Failed to initialize"
234                ": (%d) %s", ret,
235                gnutls_strerror(ret));
236    }
237
238    ret =
239            gnutls_openpgp_privkey_import(sc->privkey_pgp, &data,
240            GNUTLS_OPENPGP_FMT_BASE64, NULL,
241            0);
242    if (ret != 0) {
243        return apr_psprintf(parms->pool,
244                "GnuTLS: Failed to Import "
245                "PGP Private Key '%s': (%d) %s", file,
246                ret, gnutls_strerror(ret));
247    }
248    apr_pool_destroy(spool);
249    return NULL;
250}
251
252const char *mgs_set_tickets(cmd_parms * parms, void *dummy,
253        const char *arg) {
254    mgs_srvconf_rec *sc =
255            (mgs_srvconf_rec *) ap_get_module_config(parms->server->
256            module_config,
257            &gnutls_module);
258
259    sc->tickets = 0;
260    if (strcasecmp("on", arg) == 0) {
261        sc->tickets = 1;
262    }
263
264    return NULL;
265}
266
267
268#ifdef ENABLE_SRP
269
270const char *mgs_set_srp_tpasswd_file(cmd_parms * parms, void *dummy,
271        const char *arg) {
272    mgs_srvconf_rec *sc =
273            (mgs_srvconf_rec *) ap_get_module_config(parms->server->
274            module_config,
275            &gnutls_module);
276
277    sc->srp_tpasswd_file = ap_server_root_relative(parms->pool, arg);
278
279    return NULL;
280}
281
282const char *mgs_set_srp_tpasswd_conf_file(cmd_parms * parms, void *dummy,
283        const char *arg) {
284    mgs_srvconf_rec *sc =
285            (mgs_srvconf_rec *) ap_get_module_config(parms->server->
286            module_config,
287            &gnutls_module);
288
289    sc->srp_tpasswd_conf_file =
290            ap_server_root_relative(parms->pool, arg);
291
292    return NULL;
293}
294
295#endif
296
297const char *mgs_set_cache(cmd_parms * parms, void *dummy,
298        const char *type, const char *arg) {
299    const char *err;
300    mgs_srvconf_rec *sc =
301            ap_get_module_config(parms->server->module_config,
302            &gnutls_module);
303    if ((err = ap_check_cmd_context(parms, GLOBAL_ONLY))) {
304        return err;
305    }
306
307    if (strcasecmp("none", type) == 0) {
308        sc->cache_type = mgs_cache_none;
309        sc->cache_config = NULL;
310        return NULL;
311    } else if (strcasecmp("dbm", type) == 0) {
312        sc->cache_type = mgs_cache_dbm;
313    } else if (strcasecmp("gdbm", type) == 0) {
314        sc->cache_type = mgs_cache_gdbm;
315    }
316#if HAVE_APR_MEMCACHE
317    else if (strcasecmp("memcache", type) == 0) {
318        sc->cache_type = mgs_cache_memcache;
319    }
320#endif
321    else {
322        return "Invalid Type for GnuTLSCache!";
323    }
324
325    if (arg == NULL)
326        return "Invalid argument 2 for GnuTLSCache!";
327
328    if (sc->cache_type == mgs_cache_dbm
329            || sc->cache_type == mgs_cache_gdbm) {
330        sc->cache_config =
331                ap_server_root_relative(parms->pool, arg);
332    } else {
333        sc->cache_config = apr_pstrdup(parms->pool, arg);
334    }
335
336    return NULL;
337}
338
339const char *mgs_set_cache_timeout(cmd_parms * parms, void *dummy,
340        const char *arg) {
341    int argint;
342    const char *err;
343    mgs_srvconf_rec *sc =
344            (mgs_srvconf_rec *) ap_get_module_config(parms->server->
345            module_config,
346            &gnutls_module);
347
348    if ((err = ap_check_cmd_context(parms, GLOBAL_ONLY))) {
349        return err;
350    }
351
352    argint = atoi(arg);
353
354    if (argint < 0) {
355        return "GnuTLSCacheTimeout: Invalid argument";
356    } else if (argint == 0) {
357        sc->cache_timeout = 0;
358    } else {
359        sc->cache_timeout = apr_time_from_sec(argint);
360    }
361
362    return NULL;
363}
364
365const char *mgs_set_client_verify(cmd_parms * parms, void *dummy,
366        const char *arg) {
367    int mode;
368
369    if (strcasecmp("none", arg) == 0 || strcasecmp("ignore", arg) == 0) {
370        mode = GNUTLS_CERT_IGNORE;
371    } else if (strcasecmp("optional", arg) == 0
372            || strcasecmp("request", arg) == 0) {
373        mode = GNUTLS_CERT_REQUEST;
374    } else if (strcasecmp("require", arg) == 0) {
375        mode = GNUTLS_CERT_REQUIRE;
376    } else {
377        return "GnuTLSClientVerify: Invalid argument";
378    }
379
380    /* This was set from a directory context */
381    if (parms->path) {
382        mgs_dirconf_rec *dc = (mgs_dirconf_rec *) dummy;
383        dc->client_verify_mode = mode;
384    } else {
385        mgs_srvconf_rec *sc =
386                (mgs_srvconf_rec *)
387                ap_get_module_config(parms->server->module_config,
388                &gnutls_module);
389        sc->client_verify_mode = mode;
390    }
391
392    return NULL;
393}
394
395#define INIT_CA_SIZE 128
396
397const char *mgs_set_client_ca_file(cmd_parms * parms, void *dummy,
398        const char *arg) {
399    int rv;
400    const char *file;
401    apr_pool_t *spool;
402    gnutls_datum_t data;
403
404    mgs_srvconf_rec *sc =
405            (mgs_srvconf_rec *) ap_get_module_config(parms->server->
406            module_config,
407            &gnutls_module);
408    apr_pool_create(&spool, parms->pool);
409
410    file = ap_server_root_relative(spool, arg);
411
412    if (load_datum_from_file(spool, file, &data) != 0) {
413        return apr_psprintf(parms->pool, "GnuTLS: Error Reading "
414                "Client CA File '%s'", file);
415    }
416
417    sc->ca_list_size = INIT_CA_SIZE;
418    sc->ca_list = malloc(sc->ca_list_size * sizeof (*sc->ca_list));
419    if (sc->ca_list == NULL) {
420        return apr_psprintf(parms->pool,
421                "mod_gnutls: Memory allocation error");
422    }
423
424    rv = gnutls_x509_crt_list_import(sc->ca_list, &sc->ca_list_size,
425            &data, GNUTLS_X509_FMT_PEM,
426            GNUTLS_X509_CRT_LIST_IMPORT_FAIL_IF_EXCEED);
427    if (rv < 0 && rv != GNUTLS_E_SHORT_MEMORY_BUFFER) {
428        return apr_psprintf(parms->pool, "GnuTLS: Failed to load "
429                "Client CA File '%s': (%d) %s", file,
430                rv, gnutls_strerror(rv));
431    }
432
433    if (INIT_CA_SIZE < sc->ca_list_size) {
434        sc->ca_list =
435                realloc(sc->ca_list,
436                sc->ca_list_size * sizeof (*sc->ca_list));
437        if (sc->ca_list == NULL) {
438            return apr_psprintf(parms->pool,
439                    "mod_gnutls: Memory allocation error");
440        }
441
442        /* re-read */
443        rv = gnutls_x509_crt_list_import(sc->ca_list,
444                &sc->ca_list_size, &data,
445                GNUTLS_X509_FMT_PEM, 0);
446
447        if (rv < 0) {
448            return apr_psprintf(parms->pool,
449                    "GnuTLS: Failed to load "
450                    "Client CA File '%s': (%d) %s",
451                    file, rv, gnutls_strerror(rv));
452        }
453    }
454
455    apr_pool_destroy(spool);
456    return NULL;
457}
458
459const char *mgs_set_keyring_file(cmd_parms * parms, void *dummy,
460        const char *arg) {
461    int rv;
462    const char *file;
463    apr_pool_t *spool;
464    gnutls_datum_t data;
465
466    mgs_srvconf_rec *sc =
467            (mgs_srvconf_rec *) ap_get_module_config(parms->server->
468            module_config,
469            &gnutls_module);
470    apr_pool_create(&spool, parms->pool);
471
472    file = ap_server_root_relative(spool, arg);
473
474    if (load_datum_from_file(spool, file, &data) != 0) {
475        return apr_psprintf(parms->pool, "GnuTLS: Error Reading "
476                "Keyring File '%s'", file);
477    }
478
479    rv = gnutls_openpgp_keyring_init(&sc->pgp_list);
480    if (rv < 0) {
481        return apr_psprintf(parms->pool,
482                "GnuTLS: Failed to initialize"
483                "keyring: (%d) %s", rv,
484                gnutls_strerror(rv));
485    }
486
487    rv = gnutls_openpgp_keyring_import(sc->pgp_list, &data,
488            GNUTLS_OPENPGP_FMT_BASE64);
489    if (rv < 0) {
490        return apr_psprintf(parms->pool, "GnuTLS: Failed to load "
491                "Keyring File '%s': (%d) %s", file, rv,
492                gnutls_strerror(rv));
493    }
494
495    apr_pool_destroy(spool);
496    return NULL;
497}
498
499const char *mgs_set_proxy_engine(cmd_parms * parms, void *dummy,
500        const char *arg) {
501   
502    mgs_srvconf_rec *sc =(mgs_srvconf_rec *) 
503            ap_get_module_config(parms->server->module_config, &gnutls_module);
504   
505    if (!strcasecmp(arg, "On")) {
506        sc->proxy_enabled = GNUTLS_ENABLED_TRUE;
507    } else if (!strcasecmp(arg, "Off")) {
508        sc->proxy_enabled = GNUTLS_ENABLED_FALSE;
509    } else {
510        return "SSLProxyEngine must be set to 'On' or 'Off'";
511    }
512
513    return NULL;
514}
515
516const char *mgs_set_enabled(cmd_parms * parms, void *dummy,
517        const char *arg) {
518    mgs_srvconf_rec *sc =
519            (mgs_srvconf_rec *) ap_get_module_config(parms->server->
520            module_config,
521            &gnutls_module);
522    if (!strcasecmp(arg, "On")) {
523        sc->enabled = GNUTLS_ENABLED_TRUE;
524    } else if (!strcasecmp(arg, "Off")) {
525        sc->enabled = GNUTLS_ENABLED_FALSE;
526    } else {
527        return "GnuTLSEnable must be set to 'On' or 'Off'";
528    }
529
530    return NULL;
531}
532
533const char *mgs_set_export_certificates_enabled(cmd_parms * parms, void *dummy, const char *arg) {
534    mgs_srvconf_rec *sc = (mgs_srvconf_rec *) ap_get_module_config(parms->server->module_config, &gnutls_module);
535    if (!strcasecmp(arg, "On")) {
536        sc->export_certificates_enabled = GNUTLS_ENABLED_TRUE;
537    } else if (!strcasecmp(arg, "Off")) {
538        sc->export_certificates_enabled = GNUTLS_ENABLED_FALSE;
539    } else {
540        return
541        "GnuTLSExportCertificates must be set to 'On' or 'Off'";
542    }
543
544    return NULL;
545}
546
547const char *mgs_set_priorities(cmd_parms * parms, void *dummy, const char *arg) {
548
549        int ret;
550    const char *err;
551
552    mgs_srvconf_rec *sc = (mgs_srvconf_rec *) 
553                                                  ap_get_module_config(parms->server->module_config, &gnutls_module);
554
555    ret = gnutls_priority_init(&sc->priorities, arg, &err);
556
557    if (ret < 0) {
558        if (ret == GNUTLS_E_INVALID_REQUEST) {
559            return apr_psprintf(parms->pool, 
560                                                                "GnuTLS: Syntax error parsing priorities string at: %s", err);
561                }
562        return "Error setting priorities";
563    }
564
565    return NULL;
566}
567
568static mgs_srvconf_rec *_mgs_config_server_create(apr_pool_t * p, char** err) {
569    mgs_srvconf_rec *sc = apr_pcalloc(p, sizeof (*sc));
570    int ret;
571
572    sc->enabled = GNUTLS_ENABLED_UNSET;
573
574    ret = gnutls_certificate_allocate_credentials(&sc->certs);
575    if (ret < 0) {
576        *err = apr_psprintf(p, "GnuTLS: Failed to initialize"
577                            ": (%d) %s", ret,
578                            gnutls_strerror(ret));
579        return NULL;
580    }
581
582    ret = gnutls_anon_allocate_server_credentials(&sc->anon_creds);
583    if (ret < 0) {
584        *err = apr_psprintf(p, "GnuTLS: Failed to initialize"
585                            ": (%d) %s", ret,
586                            gnutls_strerror(ret));
587        return NULL;
588    }
589#ifdef ENABLE_SRP
590    ret = gnutls_srp_allocate_server_credentials(&sc->srp_creds);
591    if (ret < 0) {
592        *err =  apr_psprintf(p, "GnuTLS: Failed to initialize"
593                             ": (%d) %s", ret,
594                             gnutls_strerror(ret));
595        return NULL;
596    }
597
598    sc->srp_tpasswd_conf_file = NULL;
599    sc->srp_tpasswd_file = NULL;
600#endif
601
602    sc->privkey_x509 = NULL;
603        /* Initialize all Certificate Chains */
604    /* FIXME: how do we indicate that this is unset for a merge? (that
605     * is, how can a subordinate server override the chain by setting
606     * an empty one?  what would that even look like in the
607     * configuration?) */
608        sc->certs_x509_chain = malloc(MAX_CHAIN_SIZE * sizeof (*sc->certs_x509_chain));
609    sc->certs_x509_chain_num = 0;
610    sc->cache_timeout = -1; /* -1 means "unset" */
611    sc->cache_type = mgs_cache_unset;
612    sc->cache_config = NULL;
613    sc->tickets = GNUTLS_ENABLED_UNSET;
614    sc->priorities = NULL;
615    sc->dh_params = NULL;
616    sc->proxy_enabled = GNUTLS_ENABLED_UNSET;
617    sc->export_certificates_enabled = GNUTLS_ENABLED_UNSET;
618   
619/* this relies on GnuTLS never changing the gnutls_certificate_request_t enum to define -1 */
620    sc->client_verify_mode = -1; 
621
622    return sc;
623}
624
625void *mgs_config_server_create(apr_pool_t * p, server_rec * s) {
626    char *err = NULL;
627    mgs_srvconf_rec *sc = _mgs_config_server_create(p, &err);
628    if (sc) return sc; else return err;
629}
630
631#define gnutls_srvconf_merge(t, unset) sc->t = (add->t == unset) ? base->t : add->t
632#define gnutls_srvconf_assign(t) sc->t = add->t
633
634void *mgs_config_server_merge(apr_pool_t *p, void *BASE, void *ADD) {
635    int i;
636    char *err = NULL;
637    mgs_srvconf_rec *base = (mgs_srvconf_rec *)BASE;
638    mgs_srvconf_rec *add = (mgs_srvconf_rec *)ADD;
639    mgs_srvconf_rec *sc = _mgs_config_server_create(p, &err);
640    if (NULL == sc) return err;
641
642    gnutls_srvconf_merge(enabled, GNUTLS_ENABLED_UNSET);
643    gnutls_srvconf_merge(tickets, GNUTLS_ENABLED_UNSET);
644    gnutls_srvconf_merge(proxy_enabled, GNUTLS_ENABLED_UNSET);
645    gnutls_srvconf_merge(export_certificates_enabled, GNUTLS_ENABLED_UNSET);
646    gnutls_srvconf_merge(client_verify_mode, -1);
647    gnutls_srvconf_merge(srp_tpasswd_file, NULL);
648    gnutls_srvconf_merge(srp_tpasswd_conf_file, NULL);
649    gnutls_srvconf_merge(privkey_x509, NULL);
650    gnutls_srvconf_merge(priorities, NULL);
651    gnutls_srvconf_merge(dh_params, NULL);
652
653    /* FIXME: the following items are pre-allocated, and should be
654     * properly disposed of before assigning in order to avoid leaks;
655     * so at the moment, we can't actually have them in the config.
656     * what happens during de-allocation?
657
658     * This is probably leaky.
659     */
660    gnutls_srvconf_assign(certs);
661    gnutls_srvconf_assign(anon_creds);
662    gnutls_srvconf_assign(srp_creds);
663    gnutls_srvconf_assign(certs_x509_chain);
664    gnutls_srvconf_assign(certs_x509_chain_num);
665
666    /* how do these get transferred cleanly before the data from ADD
667     * goes away? */
668    gnutls_srvconf_assign(cert_cn);
669    for (i = 0; i < MAX_CERT_SAN; i++)
670        gnutls_srvconf_assign(cert_san[i]);
671    gnutls_srvconf_assign(ca_list);
672    gnutls_srvconf_assign(ca_list_size);
673    gnutls_srvconf_assign(cert_pgp);
674    gnutls_srvconf_assign(pgp_list);
675    gnutls_srvconf_assign(privkey_pgp);
676
677    return sc;
678}
679
680#undef gnutls_srvconf_merge
681#undef gnutls_srvconf_assign
682
683void *mgs_config_dir_merge(apr_pool_t * p, void *basev, void *addv) {
684    mgs_dirconf_rec *new;
685    /*    mgs_dirconf_rec *base = (mgs_dirconf_rec *) basev; */
686    mgs_dirconf_rec *add = (mgs_dirconf_rec *) addv;
687
688    new = (mgs_dirconf_rec *) apr_pcalloc(p, sizeof (mgs_dirconf_rec));
689    new->client_verify_mode = add->client_verify_mode;
690    return new;
691}
692
693void *mgs_config_dir_create(apr_pool_t * p, char *dir) {
694    mgs_dirconf_rec *dc = apr_palloc(p, sizeof (*dc));
695    dc->client_verify_mode = -1;
696    return dc;
697}
698
Note: See TracBrowser for help on using the repository browser.