source: mod_gnutls/src/gnutls_config.c @ 2aaf4f5

debian/masterdebian/stretch-backportsjessie-backportsupstream
Last change on this file since 2aaf4f5 was 2aaf4f5, checked in by Daniel Kahn Gillmor <dkg@…>, 6 years ago

implement GnuTLSExportCertificates control over max exported cert size

This patchset implements the proposed modification to
GnuTLSExportCertificates, allowing server administrators to choose the
maximum size of the exported certs.

Some advantages:

  • avoids large buffers on the stack
  • more configurable for server admins who expect to use larger certs
  • better visibilty for users when a too-large-cert is encountered

This also increases the default maximum exported size from 10KiB to
16KiB.

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