source: mod_gnutls/src/gnutls_config.c @ e02dd8c

debian/masterdebian/stretch-backportsjessie-backportsmsvaupstream
Last change on this file since e02dd8c was e02dd8c, checked in by Nikos Mavrogiannopoulos <nmav@…>, 9 years ago

indented code

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