Changeset e183628 in mod_gnutls for src/gnutls_config.c


Ignore:
Timestamp:
Sep 19, 2011, 11:58:43 PM (8 years ago)
Author:
Dash Shendy <neuromancer@…>
Branches:
debian/master, debian/stretch-backports, jessie-backports, master, msva, upstream
Children:
c7c2ad2
Parents:
6223319
Message:

Updated Copyright Headers & Formatting

File:
1 edited

Legend:

Unmodified
Added
Removed
  • src/gnutls_config.c

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