Changes in src/gnutls_config.c [fd82e59:1d9cfaf] in mod_gnutls


Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • src/gnutls_config.c

    rfd82e59 r1d9cfaf  
    2020#include "mod_gnutls.h"
    2121#include "apr_lib.h"
     22#include <gnutls/abstract.h>
     23
     24#define INIT_CA_SIZE 128
    2225
    2326#ifdef APLOG_USE_MODULE
     
    2528#endif
    2629
     30static int pin_callback(void *user, int attempt, const char *token_url,
     31                        const char *token_label, unsigned int flags,
     32                        char *pin, size_t pin_max)
     33{
     34    mgs_srvconf_rec *sc = user;
     35
     36    if (sc->pin == NULL || flags & GNUTLS_PIN_FINAL_TRY ||
     37        flags & GNUTLS_PIN_WRONG) {
     38        return -1;
     39    }
     40
     41    if (token_label && strcmp(token_label, "SRK") == 0) {
     42         snprintf(pin, pin_max, "%s", sc->srk_pin);
     43    } else {
     44         snprintf(pin, pin_max, "%s", sc->pin);
     45    }
     46    return 0;
     47}
     48
    2749static int load_datum_from_file(apr_pool_t * pool,
    28         const char *file, gnutls_datum_t * data) {
     50                                const char *file, gnutls_datum_t * data)
     51{
    2952    apr_file_t *fp;
    3053    apr_finfo_t finfo;
     
    3356
    3457    rv = apr_file_open(&fp, file, APR_READ | APR_BINARY,
    35             APR_OS_DEFAULT, pool);
     58                       APR_OS_DEFAULT, pool);
    3659    if (rv != APR_SUCCESS) {
    37         return rv;
     60        return rv;
    3861    }
    3962
     
    4164
    4265    if (rv != APR_SUCCESS) {
    43         return rv;
     66        return rv;
    4467    }
    4568
     
    4871
    4972    if (rv != APR_SUCCESS) {
    50         return rv;
     73        return rv;
    5174    }
    5275    apr_file_close(fp);
     
    5881}
    5982
    60 const char *mgs_set_dh_file(cmd_parms * parms, void *dummy __attribute__((unused)),
    61         const char *arg) {
     83/* 2048-bit group parameters from SRP specification */
     84const char static_dh_params[] = "-----BEGIN DH PARAMETERS-----\n"
     85        "MIIBBwKCAQCsa9tBMkqam/Fm3l4TiVgvr3K2ZRmH7gf8MZKUPbVgUKNzKcu0oJnt\n"
     86        "gZPgdXdnoT3VIxKrSwMxDc1/SKnaBP1Q6Ag5ae23Z7DPYJUXmhY6s2YaBfvV+qro\n"
     87        "KRipli8Lk7hV+XmT7Jde6qgNdArb9P90c1nQQdXDPqcdKB5EaxR3O8qXtDoj+4AW\n"
     88        "dr0gekNsZIHx0rkHhxdGGludMuaI+HdIVEUjtSSw1X1ep3onddLs+gMs+9v1L7N4\n"
     89        "YWAnkATleuavh05zA85TKZzMBBx7wwjYKlaY86jQw4JxrjX46dv7tpS1yAPYn3rk\n"
     90        "Nd4jbVJfVHWbZeNy/NaO8g+nER+eSv9zAgEC\n"
     91        "-----END DH PARAMETERS-----\n";
     92
     93int mgs_load_files(apr_pool_t * p, server_rec * s)
     94{
     95    apr_pool_t *spool;
     96    const char *file;
     97    gnutls_datum_t data;
    6298    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     }
     99    mgs_srvconf_rec *sc =
     100        (mgs_srvconf_rec *) ap_get_module_config(s->module_config,
     101                                                 &gnutls_module);
     102
     103    apr_pool_create(&spool, p);
     104
     105    sc->cert_pgp = apr_pcalloc(p, sizeof(sc->cert_pgp[0]));
     106    sc->cert_crt_pgp = apr_pcalloc(p, sizeof(sc->cert_crt_pgp[0]));
     107    sc->certs_x509_chain =
     108        apr_pcalloc(p, MAX_CHAIN_SIZE * sizeof(sc->certs_x509_chain[0]));
     109    sc->certs_x509_crt_chain =
     110        apr_pcalloc(p,
     111                    MAX_CHAIN_SIZE * sizeof(sc->certs_x509_crt_chain[0]));
     112
     113    ret = gnutls_certificate_allocate_credentials(&sc->certs);
     114    if (ret < 0) {
     115        ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
     116                     "GnuTLS: Failed to initialize" ": (%d) %s", ret,
     117                     gnutls_strerror(ret));
     118        ret = -1;
     119        goto cleanup;
     120    }
     121
     122    ret = gnutls_anon_allocate_server_credentials(&sc->anon_creds);
     123    if (ret < 0) {
     124        ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
     125                     "GnuTLS: Failed to initialize" ": (%d) %s", ret,
     126                     gnutls_strerror(ret));
     127        ret = -1;
     128        goto cleanup;
     129    }
     130
     131    /* Load SRP parameters */
     132#ifdef ENABLE_SRP
     133    ret = gnutls_srp_allocate_server_credentials(&sc->srp_creds);
     134    if (ret < 0) {
     135        ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
     136                     "GnuTLS: Failed to initialize" ": (%d) %s", ret,
     137                     gnutls_strerror(ret));
     138        ret = -1;
     139        goto cleanup;
     140    }
     141
     142    if (sc->srp_tpasswd_conf_file != NULL && sc->srp_tpasswd_file != NULL) {
     143        ret = gnutls_srp_set_server_credentials_file
     144            (sc->srp_creds, sc->srp_tpasswd_file,
     145             sc->srp_tpasswd_conf_file);
     146
     147        if (ret < 0 && sc->enabled == GNUTLS_ENABLED_TRUE) {
     148            ap_log_error(APLOG_MARK, APLOG_STARTUP, 0,
     149                         s,
     150                         "GnuTLS: Host '%s:%d' is missing a "
     151                         "SRP password or conf File!",
     152                         s->server_hostname, s->port);
     153            ret = -1;
     154            goto cleanup;
     155        }
     156    }
     157#endif
    79158
    80159    ret = gnutls_dh_params_init(&sc->dh_params);
    81160    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 
     161            ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
     162                         "GnuTLS: Failed to initialize"
     163                         ": (%d) %s", ret, gnutls_strerror(ret));
     164            ret = -1;
     165            goto cleanup;
     166    }
     167
     168    /* Load DH parameters */
     169    if (sc->dh_file) {
     170        if (load_datum_from_file(spool, sc->dh_file, &data) != 0) {
     171            ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
     172                         "GnuTLS: Error Reading " "DH params '%s'", sc->dh_file);
     173            ret = -1;
     174            goto cleanup;
     175        }
     176
     177
     178        ret =
     179            gnutls_dh_params_import_pkcs3(sc->dh_params, &data,
     180                                          GNUTLS_X509_FMT_PEM);
     181        if (ret < 0) {
     182            ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
     183                         "GnuTLS: Failed to Import "
     184                         "DH params '%s': (%d) %s", sc->dh_file, ret,
     185                         gnutls_strerror(ret));
     186            ret = -1;
     187            goto cleanup;
     188        }
     189    } else {
     190        gnutls_datum_t pdata = {
     191            (void *) static_dh_params,
     192            sizeof(static_dh_params)
     193        };
     194
     195        ret = gnutls_dh_params_import_pkcs3(sc->dh_params, &pdata, GNUTLS_X509_FMT_PEM);
     196        if (ret < 0) {
     197            ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
     198                    "GnuTLS: Unable to generate or load DH Params: (%d) %s",
     199                    ret, gnutls_strerror(ret));
     200            ret = -1;
     201            goto cleanup;
     202        }
     203    }
     204
     205    if (sc->x509_cert_file != NULL) {
     206        unsigned int chain_num, i;
     207        unsigned format = GNUTLS_X509_FMT_PEM;
     208
     209        /* Load X.509 certificate */
     210        if (strncmp(sc->x509_cert_file, "pkcs11:", 7) == 0) {
     211            gnutls_pkcs11_obj_t obj;
     212
     213            file = sc->x509_cert_file;
     214
     215            ret = gnutls_pkcs11_obj_init(&obj);
     216            if (ret < 0) {
     217                ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
     218                             "GnuTLS: Error Initializing PKCS #11 object");
     219                ret = -1;
     220                goto cleanup;
     221            }
     222
     223            gnutls_pkcs11_obj_set_pin_function(obj, pin_callback, sc);
     224
     225            ret = gnutls_pkcs11_obj_import_url(obj, file, GNUTLS_PKCS11_OBJ_FLAG_LOGIN);
     226            if (ret < 0) {
     227                ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
     228                             "GnuTLS: Error Importing PKCS #11 object: '%s': %s",
     229                             file, gnutls_strerror(ret));
     230                ret = -1;
     231                goto cleanup;
     232            }
     233
     234            format = GNUTLS_X509_FMT_DER;
     235            ret = gnutls_pkcs11_obj_export2(obj, &data);
     236            if (ret < 0) {
     237                ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
     238                             "GnuTLS: Error Exporting a PKCS #11 object: '%s': %s",
     239                             file, gnutls_strerror(ret));
     240                ret = -1;
     241                goto cleanup;
     242            }
     243
     244            gnutls_pkcs11_obj_deinit(obj);
     245        } else {
     246            file = ap_server_root_relative(spool, sc->x509_cert_file);
     247
     248            ret = gnutls_load_file(file, &data);
     249            if (ret < 0) {
     250                ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
     251                             "GnuTLS: Error Reading Certificate '%s': %s",
     252                             file, gnutls_strerror(ret));
     253                ret = -1;
     254                goto cleanup;
     255            }
     256        }
     257
     258        ret =
     259            gnutls_x509_crt_list_import2(&sc->certs_x509_crt_chain,
     260                                        &chain_num, &data, format,
     261                                        GNUTLS_X509_CRT_LIST_FAIL_IF_UNSORTED);
     262        gnutls_free(data.data);
     263        sc->certs_x509_chain_num = chain_num;
     264
     265        if (ret < 0) {
     266            ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
     267                         "GnuTLS: Failed to Import Certificate Chain '%s': (%d) %s",
     268                         file, ret, gnutls_strerror(ret));
     269            ret = -1;
     270            goto cleanup;
     271        }
     272
     273        for (i = 0; i < chain_num; i++) {
     274            ret =
     275                gnutls_pcert_import_x509(&sc->certs_x509_chain[i],
     276                                         sc->certs_x509_crt_chain[i], 0);
     277            if (ret < 0) {
     278                ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
     279                             "GnuTLS: Failed to Import pCertificate '%s': (%d) %s",
     280                             file, ret, gnutls_strerror(ret));
     281                ret = -1;
     282                goto cleanup;
     283            }
     284        }
     285        sc->certs_x509_chain_num = chain_num;
     286    }
     287
     288    if (sc->x509_key_file) {
     289        ret = gnutls_privkey_init(&sc->privkey_x509);
     290        if (ret < 0) {
     291            ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
     292                         "GnuTLS: Failed to initialize: (%d) %s", ret,
     293                         gnutls_strerror(ret));
     294            ret = -1;
     295            goto cleanup;
     296        }
     297
     298        if (gnutls_url_is_supported(sc->x509_key_file) != 0) {
     299            file = sc->x509_key_file;
     300
     301            gnutls_privkey_set_pin_function(sc->privkey_x509, pin_callback,
     302                                            sc);
     303
     304            ret = gnutls_privkey_import_url(sc->privkey_x509, file, 0);
     305
     306            if (ret < 0) {
     307                ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
     308                             "GnuTLS: Failed to Import Private Key URL '%s': (%d) %s",
     309                             file, ret, gnutls_strerror(ret));
     310                ret = -1;
     311                goto cleanup;
     312            }
     313        } else {
     314            file = ap_server_root_relative(spool, sc->x509_key_file);
     315
     316            if (load_datum_from_file(spool, file, &data) != 0) {
     317                ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
     318                             "GnuTLS: Error Reading Private Key '%s'",
     319                             file);
     320                ret = -1;
     321                goto cleanup;
     322            }
     323
     324            ret =
     325                gnutls_privkey_import_x509_raw(sc->privkey_x509, &data,
     326                                               GNUTLS_X509_FMT_PEM, sc->pin,
     327                                               0);
     328
     329            if (ret < 0) {
     330                ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
     331                             "GnuTLS: Failed to Import Private Key '%s': (%d) %s",
     332                             file, ret, gnutls_strerror(ret));
     333                ret = -1;
     334                goto cleanup;
     335            }
     336        }
     337    }
     338
     339    /* Load the X.509 CA file */
     340    if (sc->x509_ca_file) {
     341        if (load_datum_from_file(spool, sc->x509_ca_file, &data) != 0) {
     342            ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
     343                         "GnuTLS: Error Reading " "Client CA File '%s'",
     344                         sc->x509_ca_file);
     345            ret = -1;
     346            goto cleanup;
     347        }
     348
     349        ret = gnutls_x509_crt_list_import2(&sc->ca_list, &sc->ca_list_size,
     350                                         &data, GNUTLS_X509_FMT_PEM, 0);
     351        if (ret < 0) {
     352            ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
     353                         "GnuTLS: Failed to load "
     354                         "Client CA File '%s': (%d) %s", sc->x509_ca_file,
     355                         ret, gnutls_strerror(ret));
     356            ret = -1;
     357            goto cleanup;
     358        }
     359    }
     360
     361    if (sc->pgp_cert_file) {
     362        if (load_datum_from_file(spool, sc->pgp_cert_file, &data) != 0) {
     363            ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
     364                         "GnuTLS: Error Reading " "Certificate '%s'",
     365                         sc->pgp_cert_file);
     366            ret = -1;
     367            goto cleanup;
     368        }
     369
     370        ret = gnutls_openpgp_crt_init(&sc->cert_crt_pgp[0]);
     371        if (ret < 0) {
     372            ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
     373                         "GnuTLS: Failed to Init "
     374                         "PGP Certificate: (%d) %s", ret,
     375                         gnutls_strerror(ret));
     376            ret = -1;
     377            goto cleanup;
     378        }
     379
     380        ret =
     381            gnutls_openpgp_crt_import(sc->cert_crt_pgp[0], &data,
     382                                      GNUTLS_OPENPGP_FMT_BASE64);
     383        if (ret < 0) {
     384            ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
     385                         "GnuTLS: Failed to Import "
     386                         "PGP Certificate: (%d) %s", ret,
     387                         gnutls_strerror(ret));
     388            ret = -1;
     389            goto cleanup;
     390        }
     391
     392        ret =
     393            gnutls_pcert_import_openpgp(sc->cert_pgp, sc->cert_crt_pgp[0],
     394                                        0);
     395        if (ret < 0) {
     396            ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
     397                         "GnuTLS: Failed to Import "
     398                         "PGP pCertificate: (%d) %s", ret,
     399                         gnutls_strerror(ret));
     400            ret = -1;
     401            goto cleanup;
     402        }
     403    }
     404
     405    /* Load the PGP key file */
     406    if (sc->pgp_key_file) {
     407        if (load_datum_from_file(spool, sc->pgp_key_file, &data) != 0) {
     408            ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
     409                         "GnuTLS: Error Reading " "Private Key '%s'",
     410                         sc->pgp_key_file);
     411            ret = -1;
     412            goto cleanup;
     413        }
     414
     415        ret = gnutls_privkey_init(&sc->privkey_pgp);
     416        if (ret < 0) {
     417            ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
     418                         "GnuTLS: Failed to initialize"
     419                         ": (%d) %s", ret, gnutls_strerror(ret));
     420            ret = -1;
     421            goto cleanup;
     422        }
     423
     424        ret =
     425            gnutls_privkey_import_openpgp_raw(sc->privkey_pgp, &data,
     426                                              GNUTLS_OPENPGP_FMT_BASE64,
     427                                              NULL, NULL);
     428        if (ret != 0) {
     429            ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
     430                         "GnuTLS: Failed to Import "
     431                         "PGP Private Key '%s': (%d) %s",
     432                         sc->pgp_key_file, ret, gnutls_strerror(ret));
     433            ret = -1;
     434            goto cleanup;
     435        }
     436    }
     437
     438    /* Load the keyring file */
     439    if (sc->pgp_ring_file) {
     440        if (load_datum_from_file(spool, sc->pgp_ring_file, &data) != 0) {
     441            ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
     442                         "GnuTLS: Error Reading " "Keyring File '%s'",
     443                         sc->pgp_ring_file);
     444            ret = -1;
     445            goto cleanup;
     446        }
     447
     448        ret = gnutls_openpgp_keyring_init(&sc->pgp_list);
     449        if (ret < 0) {
     450            ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
     451                         "GnuTLS: Failed to initialize"
     452                         "keyring: (%d) %s", ret, gnutls_strerror(ret));
     453            ret = -1;
     454            goto cleanup;
     455        }
     456
     457        ret = gnutls_openpgp_keyring_import(sc->pgp_list, &data,
     458                                           GNUTLS_OPENPGP_FMT_BASE64);
     459        if (ret < 0) {
     460            ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
     461                         "GnuTLS: Failed to load "
     462                         "Keyring File '%s': (%d) %s", sc->pgp_ring_file,
     463                         ret, gnutls_strerror(ret));
     464            ret = -1;
     465            goto cleanup;
     466        }
     467    }
     468
     469    if (sc->priorities_str) {
     470        const char *err;
     471        ret = gnutls_priority_init(&sc->priorities, sc->priorities_str, &err);
     472
     473        if (ret < 0) {
     474            if (ret == GNUTLS_E_INVALID_REQUEST) {
     475                ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
     476                             "GnuTLS: Syntax error parsing priorities string at: %s",
     477                             err);
     478            } else {
     479                ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
     480                             "GnuTLS: error parsing priorities string");
     481
     482            }
     483            ret = -1;
     484            goto cleanup;
     485        }
     486    }
     487
     488    ret = 0;
     489  cleanup:
    98490    apr_pool_destroy(spool);
    99491
     492    return ret;
     493}
     494
     495int mgs_pkcs11_reinit(server_rec * base_server)
     496{
     497    int ret;
     498    server_rec *s;
     499    mgs_srvconf_rec *sc;
     500
     501    gnutls_pkcs11_reinit();
     502
     503    for (s = base_server; s; s = s->next) {
     504        sc = (mgs_srvconf_rec *) ap_get_module_config(s->module_config, &gnutls_module);
     505
     506            /* gnutls caches the session in a private key, so we need to open
     507             * a new one */
     508            if (sc->x509_key_file && gnutls_url_is_supported(sc->x509_key_file) != 0) {
     509                gnutls_privkey_deinit(sc->privkey_x509);
     510
     511                ret = gnutls_privkey_init(&sc->privkey_x509);
     512                if (ret < 0) {
     513                    ap_log_error(APLOG_MARK, APLOG_EMERG, 0, s,
     514                                 "GnuTLS: Failed to initialize: (%d) %s", ret,
     515                                 gnutls_strerror(ret));
     516                    goto fail;
     517                }
     518
     519                gnutls_privkey_set_pin_function(sc->privkey_x509, pin_callback, sc);
     520
     521                ret = gnutls_privkey_import_url(sc->privkey_x509, sc->x509_key_file, 0);
     522                if (ret < 0) {
     523                    ap_log_error(APLOG_MARK, APLOG_EMERG, 0, s,
     524                             "GnuTLS: Failed to Re-Import Private Key URL '%s': (%d) %s",
     525                             sc->x509_key_file, ret, gnutls_strerror(ret));
     526                    goto fail;
     527                }
     528            }
     529    }
     530
     531    return 0;
     532
     533 fail:
     534    gnutls_privkey_deinit(sc->privkey_x509);
     535    return -1;
     536}
     537
     538const char *mgs_set_dh_file(cmd_parms * parms, void *dummy __attribute__((unused)),
     539        const char *arg) {
     540    mgs_srvconf_rec *sc =
     541        (mgs_srvconf_rec *) ap_get_module_config(parms->server->
     542                                                 module_config,
     543                                                 &gnutls_module);
     544
     545    sc->dh_file = ap_server_root_relative(parms->pool, arg);
     546
    100547    return NULL;
    101548}
     
    103550const char *mgs_set_cert_file(cmd_parms * parms, void *dummy __attribute__((unused)), const char *arg) {
    104551
    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);
     552    mgs_srvconf_rec *sc =
     553        (mgs_srvconf_rec *) ap_get_module_config(parms->
     554                                                 server->module_config,
     555                                                 &gnutls_module);
     556
     557    sc->x509_cert_file = apr_pstrdup(parms->pool, arg);
     558
    128559    return NULL;
    129560
     
    132563const char *mgs_set_key_file(cmd_parms * parms, void *dummy __attribute__((unused)), const char *arg) {
    133564
    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);
     565    mgs_srvconf_rec *sc =
     566        (mgs_srvconf_rec *) ap_get_module_config(parms->
     567                                                 server->module_config,
     568                                                 &gnutls_module);
     569
     570    sc->x509_key_file = apr_pstrdup(parms->pool, arg);
    172571
    173572    return NULL;
     
    176575const char *mgs_set_pgpcert_file(cmd_parms * parms, void *dummy __attribute__((unused)),
    177576        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);
     577    mgs_srvconf_rec *sc =
     578        (mgs_srvconf_rec *) ap_get_module_config(parms->server->
     579                                                 module_config,
     580                                                 &gnutls_module);
     581
     582    sc->pgp_cert_file = ap_server_root_relative(parms->pool, arg);
     583
    213584    return NULL;
    214585}
     
    216587const char *mgs_set_pgpkey_file(cmd_parms * parms, void *dummy __attribute__((unused)),
    217588        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);
     589    mgs_srvconf_rec *sc =
     590        (mgs_srvconf_rec *) ap_get_module_config(parms->server->
     591                                                 module_config,
     592                                                 &gnutls_module);
     593
     594    sc->pgp_key_file = ap_server_root_relative(parms->pool, arg);
     595
    254596    return NULL;
    255597}
     
    258600        const char *arg) {
    259601    mgs_srvconf_rec *sc =
    260             (mgs_srvconf_rec *) ap_get_module_config(parms->server->
    261             module_config,
    262             &gnutls_module);
     602        (mgs_srvconf_rec *) ap_get_module_config(parms->server->
     603                                                module_config,
     604                                                &gnutls_module);
    263605
    264606    sc->tickets = 0;
    265607    if (strcasecmp("on", arg) == 0) {
    266         sc->tickets = 1;
     608        sc->tickets = 1;
    267609    }
    268610
     
    276618        const char *arg) {
    277619    mgs_srvconf_rec *sc =
    278             (mgs_srvconf_rec *) ap_get_module_config(parms->server->
    279             module_config,
    280             &gnutls_module);
     620        (mgs_srvconf_rec *) ap_get_module_config(parms->server->
     621                                                module_config,
     622                                                &gnutls_module);
    281623
    282624    sc->srp_tpasswd_file = ap_server_root_relative(parms->pool, arg);
     
    288630        const char *arg) {
    289631    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);
     632        (mgs_srvconf_rec *) ap_get_module_config(parms->server->
     633                                                 module_config,
     634                                                 &gnutls_module);
     635
     636    sc->srp_tpasswd_conf_file = ap_server_root_relative(parms->pool, arg);
    296637
    297638    return NULL;
     
    304645    const char *err;
    305646    mgs_srvconf_rec *sc =
    306             ap_get_module_config(parms->server->module_config,
    307             &gnutls_module);
     647        ap_get_module_config(parms->server->module_config,
     648                             &gnutls_module);
    308649    if ((err = ap_check_cmd_context(parms, GLOBAL_ONLY))) {
    309         return err;
     650        return err;
    310651    }
    311652
    312653    if (strcasecmp("none", type) == 0) {
    313         sc->cache_type = mgs_cache_none;
    314         sc->cache_config = NULL;
    315         return NULL;
     654        sc->cache_type = mgs_cache_none;
     655        sc->cache_config = NULL;
     656        return NULL;
    316657    } else if (strcasecmp("dbm", type) == 0) {
    317         sc->cache_type = mgs_cache_dbm;
     658        sc->cache_type = mgs_cache_dbm;
    318659    } else if (strcasecmp("gdbm", type) == 0) {
    319         sc->cache_type = mgs_cache_gdbm;
     660        sc->cache_type = mgs_cache_gdbm;
    320661    }
    321662#if HAVE_APR_MEMCACHE
    322663    else if (strcasecmp("memcache", type) == 0) {
    323         sc->cache_type = mgs_cache_memcache;
     664        sc->cache_type = mgs_cache_memcache;
    324665    }
    325666#endif
    326667    else {
    327         return "Invalid Type for GnuTLSCache!";
     668        return "Invalid Type for GnuTLSCache!";
    328669    }
    329670
    330671    if (arg == NULL)
    331         return "Invalid argument 2 for GnuTLSCache!";
     672        return "Invalid argument 2 for GnuTLSCache!";
    332673
    333674    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);
     675        || sc->cache_type == mgs_cache_gdbm) {
     676        sc->cache_config = ap_server_root_relative(parms->pool, arg);
    337677    } else {
    338         sc->cache_config = apr_pstrdup(parms->pool, arg);
     678        sc->cache_config = apr_pstrdup(parms->pool, arg);
    339679    }
    340680
     
    347687    const char *err;
    348688    mgs_srvconf_rec *sc =
    349             (mgs_srvconf_rec *) ap_get_module_config(parms->server->
    350             module_config,
    351             &gnutls_module);
     689        (mgs_srvconf_rec *) ap_get_module_config(parms->server->
     690                                                module_config,
     691                                                &gnutls_module);
    352692
    353693    if ((err = ap_check_cmd_context(parms, GLOBAL_ONLY))) {
    354         return err;
     694        return err;
    355695    }
    356696
     
    358698
    359699    if (argint < 0) {
    360         return "GnuTLSCacheTimeout: Invalid argument";
     700        return "GnuTLSCacheTimeout: Invalid argument";
    361701    } else if (argint == 0) {
    362         sc->cache_timeout = 0;
     702        sc->cache_timeout = 0;
    363703    } else {
    364         sc->cache_timeout = apr_time_from_sec(argint);
     704        sc->cache_timeout = apr_time_from_sec(argint);
    365705    }
    366706
     
    373713
    374714    if (strcasecmp("cartel", arg) == 0) {
    375         sc->client_verify_method = mgs_cvm_cartel;
     715        sc->client_verify_method = mgs_cvm_cartel;
    376716    } else if (strcasecmp("msva", arg) == 0) {
    377717#ifdef ENABLE_MSVA
    378         sc->client_verify_method = mgs_cvm_msva;
     718        sc->client_verify_method = mgs_cvm_msva;
    379719#else
    380         return "GnuTLSClientVerifyMethod: msva is not supported";
     720        return "GnuTLSClientVerifyMethod: msva is not supported";
    381721#endif
    382722    } else {
    383         return "GnuTLSClientVerifyMethod: Invalid argument";
     723        return "GnuTLSClientVerifyMethod: Invalid argument";
    384724    }
    385725
     
    393733
    394734    if (strcasecmp("none", arg) == 0 || strcasecmp("ignore", arg) == 0) {
    395         mode = GNUTLS_CERT_IGNORE;
     735        mode = GNUTLS_CERT_IGNORE;
    396736    } else if (strcasecmp("optional", arg) == 0
    397             || strcasecmp("request", arg) == 0) {
    398         mode = GNUTLS_CERT_REQUEST;
     737               || strcasecmp("request", arg) == 0) {
     738        mode = GNUTLS_CERT_REQUEST;
    399739    } else if (strcasecmp("require", arg) == 0) {
    400         mode = GNUTLS_CERT_REQUIRE;
     740        mode = GNUTLS_CERT_REQUIRE;
    401741    } else {
    402         return "GnuTLSClientVerify: Invalid argument";
     742        return "GnuTLSClientVerify: Invalid argument";
    403743    }
    404744
     
    408748        dc->client_verify_mode = mode;
    409749    } else {
    410         mgs_srvconf_rec *sc =
    411                 (mgs_srvconf_rec *)
    412                 ap_get_module_config(parms->server->module_config,
    413                 &gnutls_module);
    414         sc->client_verify_mode = mode;
    415     }
    416 
    417     return NULL;
    418 }
    419 
    420 #define INIT_CA_SIZE 128
     750        mgs_srvconf_rec *sc = (mgs_srvconf_rec *)
     751            ap_get_module_config(parms->server->module_config,
     752                                 &gnutls_module);
     753        sc->client_verify_mode = mode;
     754    }
     755
     756    return NULL;
     757}
    421758
    422759const char *mgs_set_client_ca_file(cmd_parms * parms, void *dummy __attribute__((unused)),
    423760        const char *arg) {
    424     int rv;
    425     const char *file;
    426     apr_pool_t *spool;
    427     gnutls_datum_t data;
    428 
    429     mgs_srvconf_rec *sc =
    430             (mgs_srvconf_rec *) ap_get_module_config(parms->server->
    431             module_config,
    432             &gnutls_module);
    433     apr_pool_create(&spool, parms->pool);
    434 
    435     file = ap_server_root_relative(spool, arg);
    436 
    437     if (load_datum_from_file(spool, file, &data) != 0) {
    438         return apr_psprintf(parms->pool, "GnuTLS: Error Reading "
    439                 "Client CA File '%s'", file);
    440     }
    441 
    442     sc->ca_list_size = INIT_CA_SIZE;
    443     sc->ca_list = malloc(sc->ca_list_size * sizeof (*sc->ca_list));
    444     if (sc->ca_list == NULL) {
    445         return apr_psprintf(parms->pool,
    446                 "mod_gnutls: Memory allocation error");
    447     }
    448 
    449     rv = gnutls_x509_crt_list_import(sc->ca_list, &sc->ca_list_size,
    450             &data, GNUTLS_X509_FMT_PEM,
    451             GNUTLS_X509_CRT_LIST_IMPORT_FAIL_IF_EXCEED);
    452     if (rv < 0 && rv != GNUTLS_E_SHORT_MEMORY_BUFFER) {
    453         return apr_psprintf(parms->pool, "GnuTLS: Failed to load "
    454                 "Client CA File '%s': (%d) %s", file,
    455                 rv, gnutls_strerror(rv));
    456     }
    457 
    458     if (INIT_CA_SIZE < sc->ca_list_size) {
    459         sc->ca_list =
    460                 realloc(sc->ca_list,
    461                 sc->ca_list_size * sizeof (*sc->ca_list));
    462         if (sc->ca_list == NULL) {
    463             return apr_psprintf(parms->pool,
    464                     "mod_gnutls: Memory allocation error");
    465         }
    466 
    467         /* re-read */
    468         rv = gnutls_x509_crt_list_import(sc->ca_list,
    469                 &sc->ca_list_size, &data,
    470                 GNUTLS_X509_FMT_PEM, 0);
    471 
    472         if (rv < 0) {
    473             return apr_psprintf(parms->pool,
    474                     "GnuTLS: Failed to load "
    475                     "Client CA File '%s': (%d) %s",
    476                     file, rv, gnutls_strerror(rv));
    477         }
    478     }
    479 
    480     apr_pool_destroy(spool);
     761    mgs_srvconf_rec *sc =
     762        (mgs_srvconf_rec *) ap_get_module_config(parms->server->
     763                                                 module_config,
     764                                                 &gnutls_module);
     765
     766    sc->x509_ca_file = ap_server_root_relative(parms->pool, arg);
     767
    481768    return NULL;
    482769}
     
    484771const char *mgs_set_keyring_file(cmd_parms * parms, void *dummy __attribute__((unused)),
    485772        const char *arg) {
    486     int rv;
    487     const char *file;
    488     apr_pool_t *spool;
    489     gnutls_datum_t data;
    490 
    491     mgs_srvconf_rec *sc =
    492             (mgs_srvconf_rec *) ap_get_module_config(parms->server->
    493             module_config,
    494             &gnutls_module);
    495     apr_pool_create(&spool, parms->pool);
    496 
    497     file = ap_server_root_relative(spool, arg);
    498 
    499     if (load_datum_from_file(spool, file, &data) != 0) {
    500         return apr_psprintf(parms->pool, "GnuTLS: Error Reading "
    501                 "Keyring File '%s'", file);
    502     }
    503 
    504     rv = gnutls_openpgp_keyring_init(&sc->pgp_list);
    505     if (rv < 0) {
    506         return apr_psprintf(parms->pool,
    507                 "GnuTLS: Failed to initialize"
    508                 "keyring: (%d) %s", rv,
    509                 gnutls_strerror(rv));
    510     }
    511 
    512     rv = gnutls_openpgp_keyring_import(sc->pgp_list, &data,
    513             GNUTLS_OPENPGP_FMT_BASE64);
    514     if (rv < 0) {
    515         return apr_psprintf(parms->pool, "GnuTLS: Failed to load "
    516                 "Keyring File '%s': (%d) %s", file, rv,
    517                 gnutls_strerror(rv));
    518     }
    519 
    520     apr_pool_destroy(spool);
     773    mgs_srvconf_rec *sc =
     774        (mgs_srvconf_rec *) ap_get_module_config(parms->server->
     775                                                 module_config,
     776                                                 &gnutls_module);
     777
     778    sc->pgp_ring_file = ap_server_root_relative(parms->pool, arg);
     779
    521780    return NULL;
    522781}
     
    525784        const char *arg) {
    526785
    527     mgs_srvconf_rec *sc =(mgs_srvconf_rec *)
    528             ap_get_module_config(parms->server->module_config, &gnutls_module);
     786    mgs_srvconf_rec *sc = (mgs_srvconf_rec *)
     787        ap_get_module_config(parms->server->module_config, &gnutls_module);
    529788
    530789    if (!strcasecmp(arg, "On")) {
    531         sc->proxy_enabled = GNUTLS_ENABLED_TRUE;
     790        sc->proxy_enabled = GNUTLS_ENABLED_TRUE;
    532791    } else if (!strcasecmp(arg, "Off")) {
    533         sc->proxy_enabled = GNUTLS_ENABLED_FALSE;
     792        sc->proxy_enabled = GNUTLS_ENABLED_FALSE;
    534793    } else {
    535         return "SSLProxyEngine must be set to 'On' or 'Off'";
     794        return "SSLProxyEngine must be set to 'On' or 'Off'";
    536795    }
    537796
     
    542801        const char *arg) {
    543802    mgs_srvconf_rec *sc =
    544             (mgs_srvconf_rec *) ap_get_module_config(parms->server->
    545             module_config,
    546             &gnutls_module);
     803        (mgs_srvconf_rec *) ap_get_module_config(parms->server->
     804                                                module_config,
     805                                                &gnutls_module);
    547806    if (!strcasecmp(arg, "On")) {
    548         sc->enabled = GNUTLS_ENABLED_TRUE;
     807        sc->enabled = GNUTLS_ENABLED_TRUE;
    549808    } else if (!strcasecmp(arg, "Off")) {
    550         sc->enabled = GNUTLS_ENABLED_FALSE;
     809        sc->enabled = GNUTLS_ENABLED_FALSE;
    551810    } else {
    552         return "GnuTLSEnable must be set to 'On' or 'Off'";
     811        return "GnuTLSEnable must be set to 'On' or 'Off'";
    553812    }
    554813
     
    559818    mgs_srvconf_rec *sc = (mgs_srvconf_rec *) ap_get_module_config(parms->server->module_config, &gnutls_module);
    560819    if (!strcasecmp(arg, "On")) {
    561         sc->export_certificates_size = 16 * 1024;
     820        sc->export_certificates_size = 16 * 1024;
    562821    } else if (!strcasecmp(arg, "Off")) {
    563         sc->export_certificates_size = 0;
     822        sc->export_certificates_size = 0;
    564823    } else {
    565         char* endptr;
    566         sc->export_certificates_size = strtol(arg, &endptr, 10);
    567         while (apr_isspace(*endptr)) endptr++;
    568         if (*endptr == '\0' || *endptr == 'b' || *endptr == 'B') {
    569             ;
    570         } else if (*endptr == 'k' || *endptr == 'K') {
    571             sc->export_certificates_size *= 1024;
    572         } else {
    573             return "GnuTLSExportCertificates must be set to a size (in bytes) or 'On' or 'Off'";
    574         }
     824        char *endptr;
     825        sc->export_certificates_size = strtol(arg, &endptr, 10);
     826        while (apr_isspace(*endptr))
     827            endptr++;
     828        if (*endptr == '\0' || *endptr == 'b' || *endptr == 'B') {
     829            ;
     830        } else if (*endptr == 'k' || *endptr == 'K') {
     831            sc->export_certificates_size *= 1024;
     832        } else {
     833            return
     834                "GnuTLSExportCertificates must be set to a size (in bytes) or 'On' or 'Off'";
     835        }
    575836    }
    576837
     
    580841const char *mgs_set_priorities(cmd_parms * parms, void *dummy __attribute__((unused)), const char *arg) {
    581842
    582         int ret;
    583     const char *err;
    584 
    585843    mgs_srvconf_rec *sc = (mgs_srvconf_rec *)
    586                                                   ap_get_module_config(parms->server->module_config, &gnutls_module);
    587 
    588     ret = gnutls_priority_init(&sc->priorities, arg, &err);
    589 
    590     if (ret < 0) {
    591         if (ret == GNUTLS_E_INVALID_REQUEST) {
    592             return apr_psprintf(parms->pool,
    593                                                                 "GnuTLS: Syntax error parsing priorities string at: %s", err);
    594                 }
    595         return "Error setting priorities";
    596     }
    597 
    598     return NULL;
    599 }
    600 
    601 static mgs_srvconf_rec *_mgs_config_server_create(apr_pool_t * p, char** err) {
    602     mgs_srvconf_rec *sc = apr_pcalloc(p, sizeof (*sc));
    603     int ret;
     844        ap_get_module_config(parms->server->module_config, &gnutls_module);
     845
     846    sc->priorities_str = apr_pstrdup(parms->pool, arg);
     847
     848    return NULL;
     849}
     850
     851const char *mgs_set_pin(cmd_parms * parms, void *dummy, const char *arg)
     852{
     853
     854    mgs_srvconf_rec *sc = (mgs_srvconf_rec *)
     855        ap_get_module_config(parms->server->module_config, &gnutls_module);
     856
     857    sc->pin = apr_pstrdup(parms->pool, arg);
     858
     859    return NULL;
     860}
     861
     862const char *mgs_set_srk_pin(cmd_parms * parms, void *dummy, const char *arg)
     863{
     864
     865    mgs_srvconf_rec *sc = (mgs_srvconf_rec *)
     866        ap_get_module_config(parms->server->module_config, &gnutls_module);
     867
     868    sc->srk_pin = apr_pstrdup(parms->pool, arg);
     869
     870    return NULL;
     871}
     872
     873static mgs_srvconf_rec *_mgs_config_server_create(apr_pool_t * p,
     874                                                  char **err)
     875{
     876    mgs_srvconf_rec *sc = apr_pcalloc(p, sizeof(*sc));
    604877
    605878    sc->enabled = GNUTLS_ENABLED_UNSET;
    606879
    607     ret = gnutls_certificate_allocate_credentials(&sc->certs);
    608     if (ret < 0) {
    609         *err = apr_psprintf(p, "GnuTLS: Failed to initialize"
    610                             ": (%d) %s", ret,
    611                             gnutls_strerror(ret));
    612         return NULL;
    613     }
    614 
    615     ret = gnutls_anon_allocate_server_credentials(&sc->anon_creds);
    616     if (ret < 0) {
    617         *err = apr_psprintf(p, "GnuTLS: Failed to initialize"
    618                             ": (%d) %s", ret,
    619                             gnutls_strerror(ret));
    620         return NULL;
    621     }
    622 #ifdef ENABLE_SRP
    623     ret = gnutls_srp_allocate_server_credentials(&sc->srp_creds);
    624     if (ret < 0) {
    625         *err =  apr_psprintf(p, "GnuTLS: Failed to initialize"
    626                              ": (%d) %s", ret,
    627                              gnutls_strerror(ret));
    628         return NULL;
    629     }
    630 
    631     sc->srp_tpasswd_conf_file = NULL;
    632     sc->srp_tpasswd_file = NULL;
    633 #endif
    634880
    635881    sc->privkey_x509 = NULL;
    636         /* Initialize all Certificate Chains */
    637     /* FIXME: how do we indicate that this is unset for a merge? (that
    638      * is, how can a subordinate server override the chain by setting
    639      * an empty one?  what would that even look like in the
    640      * configuration?) */
    641         sc->certs_x509_chain = malloc(MAX_CHAIN_SIZE * sizeof (*sc->certs_x509_chain));
     882    sc->privkey_pgp = NULL;
    642883    sc->certs_x509_chain_num = 0;
    643     sc->cache_timeout = -1; /* -1 means "unset" */
     884    sc->cache_timeout = -1;     /* -1 means "unset" */
    644885    sc->cache_type = mgs_cache_unset;
    645886    sc->cache_config = NULL;
     
    661902    char *err = NULL;
    662903    mgs_srvconf_rec *sc = _mgs_config_server_create(p, &err);
    663     if (sc) return sc; else return err;
     904    if (sc)
     905        return sc;
     906    else
     907        return err;
    664908}
    665909
     
    667911#define gnutls_srvconf_assign(t) sc->t = add->t
    668912
    669 void *mgs_config_server_merge(apr_pool_t *p, void *BASE, void *ADD) {
     913void *mgs_config_server_merge(apr_pool_t * p, void *BASE, void *ADD)
     914{
    670915    int i;
    671916    char *err = NULL;
    672     mgs_srvconf_rec *base = (mgs_srvconf_rec *)BASE;
    673     mgs_srvconf_rec *add = (mgs_srvconf_rec *)ADD;
     917    mgs_srvconf_rec *base = (mgs_srvconf_rec *) BASE;
     918    mgs_srvconf_rec *add = (mgs_srvconf_rec *) ADD;
    674919    mgs_srvconf_rec *sc = _mgs_config_server_create(p, &err);
    675     if (NULL == sc) return err;
     920    if (NULL == sc)
     921        return err;
    676922
    677923    gnutls_srvconf_merge(enabled, GNUTLS_ENABLED_UNSET);
     
    683929    gnutls_srvconf_merge(srp_tpasswd_file, NULL);
    684930    gnutls_srvconf_merge(srp_tpasswd_conf_file, NULL);
    685     gnutls_srvconf_merge(privkey_x509, NULL);
    686     gnutls_srvconf_merge(priorities, NULL);
    687     gnutls_srvconf_merge(dh_params, NULL);
     931    gnutls_srvconf_merge(x509_cert_file, NULL);
     932
     933    gnutls_srvconf_merge(x509_key_file, NULL);
     934    gnutls_srvconf_merge(x509_ca_file, NULL);
     935    gnutls_srvconf_merge(pin, NULL);
     936    gnutls_srvconf_merge(pgp_cert_file, NULL);
     937    gnutls_srvconf_merge(pgp_key_file, NULL);
     938    gnutls_srvconf_merge(pgp_ring_file, NULL);
     939    gnutls_srvconf_merge(dh_file, NULL);
     940    gnutls_srvconf_merge(priorities_str, NULL);
    688941
    689942    /* FIXME: the following items are pre-allocated, and should be
    690943     * properly disposed of before assigning in order to avoid leaks;
    691944     * so at the moment, we can't actually have them in the config.
    692      * what happens during de-allocation?
    693 
    694      * This is probably leaky.
    695      */
     945     * what happens during de-allocation? */
     946    gnutls_srvconf_assign(ca_list);
     947    gnutls_srvconf_assign(ca_list_size);
     948    gnutls_srvconf_assign(cert_pgp);
     949    gnutls_srvconf_assign(cert_crt_pgp);
     950    gnutls_srvconf_assign(pgp_list);
    696951    gnutls_srvconf_assign(certs);
    697952    gnutls_srvconf_assign(anon_creds);
    698953    gnutls_srvconf_assign(srp_creds);
    699954    gnutls_srvconf_assign(certs_x509_chain);
     955    gnutls_srvconf_assign(certs_x509_crt_chain);
    700956    gnutls_srvconf_assign(certs_x509_chain_num);
    701957
     
    704960    gnutls_srvconf_assign(cert_cn);
    705961    for (i = 0; i < MAX_CERT_SAN; i++)
    706         gnutls_srvconf_assign(cert_san[i]);
    707     gnutls_srvconf_assign(ca_list);
    708     gnutls_srvconf_assign(ca_list_size);
    709     gnutls_srvconf_assign(cert_pgp);
    710     gnutls_srvconf_assign(pgp_list);
    711     gnutls_srvconf_assign(privkey_pgp);
     962        gnutls_srvconf_assign(cert_san[i]);
    712963
    713964    return sc;
     
    724975    mgs_dirconf_rec *add = (mgs_dirconf_rec *) addv;
    725976
    726     new = (mgs_dirconf_rec *) apr_pcalloc(p, sizeof (mgs_dirconf_rec));
     977    new = (mgs_dirconf_rec *) apr_pcalloc(p, sizeof(mgs_dirconf_rec));
    727978    new->client_verify_mode = add->client_verify_mode;
    728979    return new;
     
    735986    return dc;
    736987}
    737 
Note: See TracChangeset for help on using the changeset viewer.