Changeset 7bebb42 in mod_gnutls for src/gnutls_config.c


Ignore:
Timestamp:
Nov 28, 2007, 1:29:21 PM (12 years ago)
Author:
Nokis Mavrogiannopoulos <nmav@…>
Branches:
debian/master, debian/stretch-backports, jessie-backports, master, msva, upstream
Children:
3e6bc31
Parents:
8e33f2d
git-author:
Nikos Mavrogiannopoulos <nmav@…> (11/28/07 13:29:21)
git-committer:
Nokis Mavrogiannopoulos <nmav@…> (11/28/07 13:29:21)
Message:

upgraded to 0.4.0

File:
1 edited

Legend:

Unmodified
Added
Removed
  • src/gnutls_config.c

    r8e33f2d r7bebb42  
    1818#include "mod_gnutls.h"
    1919
    20 static int load_datum_from_file(apr_pool_t* pool,
    21                                 const char* file,
    22                                 gnutls_datum_t* data)
    23 {
    24     apr_file_t* fp;
     20static int load_datum_from_file(apr_pool_t * pool,
     21                                const char *file, gnutls_datum_t * data)
     22{
     23    apr_file_t *fp;
    2524    apr_finfo_t finfo;
    2625    apr_status_t rv;
    2726    apr_size_t br = 0;
    28    
    29     rv = apr_file_open(&fp, file, APR_READ|APR_BINARY, APR_OS_DEFAULT,
    30                        pool);
     27
     28    rv = apr_file_open(&fp, file, APR_READ | APR_BINARY, APR_OS_DEFAULT,
     29                       pool);
    3130    if (rv != APR_SUCCESS) {
    32         return rv;
    33     }
    34    
     31        return rv;
     32    }
     33
    3534    rv = apr_file_info_get(&finfo, APR_FINFO_SIZE, fp);
    36    
     35
    3736    if (rv != APR_SUCCESS) {
    38         return rv;
    39     }
    40    
    41     data->data = apr_palloc(pool, finfo.size+1);
     37        return rv;
     38    }
     39
     40    data->data = apr_palloc(pool, finfo.size + 1);
    4241    rv = apr_file_read_full(fp, data->data, finfo.size, &br);
    43    
     42
    4443    if (rv != APR_SUCCESS) {
    45         return rv;
     44        return rv;
    4645    }
    4746    apr_file_close(fp);
    48    
     47
    4948    data->data[br] = '\0';
    5049    data->size = br;
    51    
     50
    5251    return 0;
    5352}
    5453
     54const char *mgs_set_dh_file(cmd_parms * parms, void *dummy,
     55                            const char *arg)
     56{
     57    mgs_srvconf_rec *sc =
     58        (mgs_srvconf_rec *) ap_get_module_config(parms->server->
     59                                                 module_config,
     60                                                 &gnutls_module);
     61
     62    sc->dh_params_file = ap_server_root_relative(parms->pool, arg);
     63
     64    return NULL;
     65}
     66
     67const char *mgs_set_rsa_export_file(cmd_parms * parms, void *dummy,
     68                                    const char *arg)
     69{
     70    mgs_srvconf_rec *sc =
     71        (mgs_srvconf_rec *) ap_get_module_config(parms->server->
     72                                                 module_config,
     73                                                 &gnutls_module);
     74
     75    sc->rsa_params_file = ap_server_root_relative(parms->pool, arg);
     76
     77    return NULL;
     78}
     79
     80
    5581const char *mgs_set_cert_file(cmd_parms * parms, void *dummy,
    56                                         const char *arg)
     82                              const char *arg)
    5783{
    5884    int ret;
    5985    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);
     86    const char *file;
     87    apr_pool_t *spool;
     88    mgs_srvconf_rec *sc =
     89        (mgs_srvconf_rec *) ap_get_module_config(parms->server->
     90                                                module_config,
     91                                                &gnutls_module);
    6692    apr_pool_create(&spool, parms->pool);
    67    
     93
    6894    file = ap_server_root_relative(spool, arg);
    6995
    7096    if (load_datum_from_file(spool, file, &data) != 0) {
    71         return apr_psprintf(parms->pool, "GnuTLS: Error Reading "
    72                             "Certificate '%s'", file);
    73     }
    74    
     97        return apr_psprintf(parms->pool, "GnuTLS: Error Reading "
     98                            "Certificate '%s'", file);
     99    }
     100
    75101    gnutls_x509_crt_init(&sc->cert_x509);
    76     ret = gnutls_x509_crt_import(sc->cert_x509, &data, GNUTLS_X509_FMT_PEM);
     102    ret =
     103        gnutls_x509_crt_import(sc->cert_x509, &data, GNUTLS_X509_FMT_PEM);
    77104    if (ret != 0) {
    78         return apr_psprintf(parms->pool, "GnuTLS: Failed to Import "
    79                             "Certificate'%s': (%d) %s", file, ret,
    80                             gnutls_strerror(ret));
    81     }
    82    
     105        return apr_psprintf(parms->pool, "GnuTLS: Failed to Import "
     106                            "Certificate'%s': (%d) %s", file, ret,
     107                            gnutls_strerror(ret));
     108    }
     109
    83110    apr_pool_destroy(spool);
    84111    return NULL;
     
    86113
    87114const char *mgs_set_key_file(cmd_parms * parms, void *dummy,
    88                                        const char *arg)
     115                             const char *arg)
    89116{
    90117    int ret;
    91118    gnutls_datum_t data;
    92     const char* file;
    93     apr_pool_t* spool;
    94     mgs_srvconf_rec *sc =
    95         (mgs_srvconf_rec *) ap_get_module_config(parms->server->
    96                                                         module_config,
    97                                                         &gnutls_module);
     119    const char *file;
     120    apr_pool_t *spool;
     121    mgs_srvconf_rec *sc =
     122        (mgs_srvconf_rec *) ap_get_module_config(parms->server->
     123                                                module_config,
     124                                                &gnutls_module);
    98125    apr_pool_create(&spool, parms->pool);
    99    
     126
    100127    file = ap_server_root_relative(spool, arg);
    101    
     128
    102129    if (load_datum_from_file(spool, file, &data) != 0) {
    103         return apr_psprintf(parms->pool, "GnuTLS: Error Reading "
    104                             "Private Key '%s'", file);
    105     }
    106    
     130        return apr_psprintf(parms->pool, "GnuTLS: Error Reading "
     131                            "Private Key '%s'", file);
     132    }
     133
    107134    gnutls_x509_privkey_init(&sc->privkey_x509);
    108     ret = gnutls_x509_privkey_import(sc->privkey_x509, &data, GNUTLS_X509_FMT_PEM);
     135    ret =
     136        gnutls_x509_privkey_import(sc->privkey_x509, &data,
     137                                   GNUTLS_X509_FMT_PEM);
    109138    if (ret != 0) {
    110         return apr_psprintf(parms->pool, "GnuTLS: Failed to Import "
    111                             "Private Key '%s': (%d) %s", file, ret,
    112                             gnutls_strerror(ret));
     139        return apr_psprintf(parms->pool, "GnuTLS: Failed to Import "
     140                            "Private Key '%s': (%d) %s", file, ret,
     141                            gnutls_strerror(ret));
    113142    }
    114143    apr_pool_destroy(spool);
     
    116145}
    117146
     147const char *mgs_set_srp_tpasswd_file(cmd_parms * parms, void *dummy,
     148                                     const char *arg)
     149{
     150    mgs_srvconf_rec *sc =
     151        (mgs_srvconf_rec *) ap_get_module_config(parms->server->
     152                                                 module_config,
     153                                                 &gnutls_module);
     154
     155    sc->srp_tpasswd_file = ap_server_root_relative(parms->pool, arg);
     156
     157    return NULL;
     158}
     159
     160const char *mgs_set_srp_tpasswd_conf_file(cmd_parms * parms, void *dummy,
     161                                          const char *arg)
     162{
     163    mgs_srvconf_rec *sc =
     164        (mgs_srvconf_rec *) ap_get_module_config(parms->server->
     165                                                 module_config,
     166                                                 &gnutls_module);
     167
     168    sc->srp_tpasswd_conf_file = ap_server_root_relative(parms->pool, arg);
     169
     170    return NULL;
     171}
     172
    118173const char *mgs_set_cache(cmd_parms * parms, void *dummy,
    119                                        const char *type, const char* arg)
    120 {
    121     const char* err;
     174                          const char *type, const char *arg)
     175{
     176    const char *err;
    122177    mgs_srvconf_rec *sc = ap_get_module_config(parms->server->
    123                                                         module_config,
    124                                                         &gnutls_module);
     178                                               module_config,
     179                                               &gnutls_module);
    125180    if ((err = ap_check_cmd_context(parms, GLOBAL_ONLY))) {
    126         return err;
     181        return err;
    127182    }
    128183
    129184    if (strcasecmp("none", type) == 0) {
    130         sc->cache_type = mgs_cache_none;
    131     }
    132     else if (strcasecmp("dbm", type) == 0) {
    133         sc->cache_type = mgs_cache_dbm;
     185        sc->cache_type = mgs_cache_none;
     186    } else if (strcasecmp("dbm", type) == 0) {
     187        sc->cache_type = mgs_cache_dbm;
    134188    }
    135189#if HAVE_APR_MEMCACHE
    136190    else if (strcasecmp("memcache", type) == 0) {
    137         sc->cache_type = mgs_cache_memcache;
     191        sc->cache_type = mgs_cache_memcache;
    138192    }
    139193#endif
    140194    else {
    141         return "Invalid Type for GnuTLSCache!";
     195        return "Invalid Type for GnuTLSCache!";
    142196    }
    143197
    144198    if (sc->cache_type == mgs_cache_dbm) {
    145         sc->cache_config = ap_server_root_relative(parms->pool, arg);
    146     }
    147     else {
    148         sc->cache_config = apr_pstrdup(parms->pool, arg);
     199        sc->cache_config = ap_server_root_relative(parms->pool, arg);
     200    } else {
     201        sc->cache_config = apr_pstrdup(parms->pool, arg);
    149202    }
    150203
     
    153206
    154207const char *mgs_set_cache_timeout(cmd_parms * parms, void *dummy,
    155                                             const char *arg)
     208                                  const char *arg)
    156209{
    157210    int argint;
    158211    mgs_srvconf_rec *sc =
    159     (mgs_srvconf_rec *) ap_get_module_config(parms->server->
    160                                                     module_config,
    161                                                     &gnutls_module);
    162    
     212        (mgs_srvconf_rec *) ap_get_module_config(parms->server->
     213                                                module_config,
     214                                                &gnutls_module);
     215
    163216    argint = atoi(arg);
    164    
     217
    165218    if (argint < 0) {
    166         return "GnuTLSCacheTimeout: Invalid argument";
    167     }
    168     else if (argint == 0) {
    169         sc->cache_timeout = 0;
    170     }
    171     else {
    172         sc->cache_timeout = apr_time_from_sec(argint);
    173     }
    174    
     219        return "GnuTLSCacheTimeout: Invalid argument";
     220    } else if (argint == 0) {
     221        sc->cache_timeout = 0;
     222    } else {
     223        sc->cache_timeout = apr_time_from_sec(argint);
     224    }
     225
    175226    return NULL;
    176227}
    177228
    178229const char *mgs_set_client_verify(cmd_parms * parms, void *dummy,
    179                                             const char *arg)
     230                                  const char *arg)
    180231{
    181232    int mode;
    182233
    183234    if (strcasecmp("none", arg) == 0 || strcasecmp("ignore", arg) == 0) {
    184         mode = GNUTLS_CERT_IGNORE;
    185     }
    186     else if (strcasecmp("optional", arg) == 0 || strcasecmp("request", arg) == 0) {
    187         mode = GNUTLS_CERT_REQUEST;
    188     }
    189     else if (strcasecmp("require", arg) == 0) {
    190         mode = GNUTLS_CERT_REQUIRE;
    191     }
    192     else {
    193         return "GnuTLSClientVerify: Invalid argument";
    194     }
    195    
     235        mode = GNUTLS_CERT_IGNORE;
     236    } else if (strcasecmp("optional", arg) == 0
     237               || strcasecmp("request", arg) == 0) {
     238        mode = GNUTLS_CERT_REQUEST;
     239    } else if (strcasecmp("require", arg) == 0) {
     240        mode = GNUTLS_CERT_REQUIRE;
     241    } else {
     242        return "GnuTLSClientVerify: Invalid argument";
     243    }
     244
    196245    /* This was set from a directory context */
    197246    if (parms->path) {
    198         mgs_dirconf_rec *dc = (mgs_dirconf_rec *)dummy;
    199         dc->client_verify_mode = mode;
    200     }
    201     else {
    202         mgs_srvconf_rec *sc =
    203         (mgs_srvconf_rec *) ap_get_module_config(parms->server->
    204                                                         module_config,
    205                                                         &gnutls_module);       
    206         sc->client_verify_mode = mode;
     247        mgs_dirconf_rec *dc = (mgs_dirconf_rec *) dummy;
     248        dc->client_verify_mode = mode;
     249    } else {
     250        mgs_srvconf_rec *sc =
     251            (mgs_srvconf_rec *) ap_get_module_config(parms->server->
     252                                                     module_config,
     253                                                     &gnutls_module);
     254        sc->client_verify_mode = mode;
    207255    }
    208256
     
    211259
    212260const char *mgs_set_client_ca_file(cmd_parms * parms, void *dummy,
    213                                             const char *arg)
     261                                   const char *arg)
    214262{
    215263    int rv;
    216     const char* file;
    217     apr_pool_t* spool;
     264    const char *file;
     265    apr_pool_t *spool;
    218266    gnutls_datum_t data;
    219267
    220     mgs_srvconf_rec *sc = 
    221         (mgs_srvconf_rec *) ap_get_module_config(parms->server->
    222                                                         module_config,
    223                                                         &gnutls_module);       
     268    mgs_srvconf_rec *sc =
     269        (mgs_srvconf_rec *) ap_get_module_config(parms->server->
     270                                                module_config,
     271                                                 &gnutls_module);
    224272    apr_pool_create(&spool, parms->pool);
    225273
    226274    file = ap_server_root_relative(spool, arg);
    227275
    228     sc->ca_list_size = 16;
    229 
    230     load_datum_from_file(spool, file, &data);
    231 
    232     rv = gnutls_x509_crt_list_import(sc->ca_list, &sc->ca_list_size,
    233                                      &data, GNUTLS_X509_FMT_PEM,
    234                                      GNUTLS_X509_CRT_LIST_IMPORT_FAIL_IF_EXCEED);
     276    if (load_datum_from_file(spool, file, &data) != 0) {
     277        return apr_psprintf(parms->pool, "GnuTLS: Error Reading "
     278                            "Client CA File '%s'", file);
     279    }
     280
     281    sc->ca_list_size = MAX_CA_CRTS;
     282    rv = gnutls_x509_crt_list_import(sc->ca_list, &sc->ca_list_size,
     283                                     &data, GNUTLS_X509_FMT_PEM,
     284                                     GNUTLS_X509_CRT_LIST_IMPORT_FAIL_IF_EXCEED);
    235285    if (rv < 0) {
    236         return apr_psprintf(parms->pool, "GnuTLS: Failed to load "
    237                             "Client CA File '%s': (%d) %s", file, rv,
    238                             gnutls_strerror(rv));   
     286        return apr_psprintf(parms->pool, "GnuTLS: Failed to load "
     287                            "Client CA File '%s': (%d) %s", file, rv,
     288                            gnutls_strerror(rv));
    239289    }
    240290
     
    244294
    245295const char *mgs_set_enabled(cmd_parms * parms, void *dummy,
    246                                       const char *arg)
    247 {
    248     mgs_srvconf_rec *sc =
    249         (mgs_srvconf_rec *) ap_get_module_config(parms->server->
    250                                                         module_config,
    251                                                         &gnutls_module);
     296                            const char *arg)
     297{
     298    mgs_srvconf_rec *sc =
     299        (mgs_srvconf_rec *) ap_get_module_config(parms->server->
     300                                                module_config,
     301                                                &gnutls_module);
    252302    if (!strcasecmp(arg, "On")) {
    253         sc->enabled = GNUTLS_ENABLED_TRUE;
    254     }
    255     else if (!strcasecmp(arg, "Off")) {
    256         sc->enabled = GNUTLS_ENABLED_FALSE;
    257     }
    258     else {
    259         return "GnuTLSEnable must be set to 'On' or 'Off'";
     303        sc->enabled = GNUTLS_ENABLED_TRUE;
     304    } else if (!strcasecmp(arg, "Off")) {
     305        sc->enabled = GNUTLS_ENABLED_FALSE;
     306    } else {
     307        return "GnuTLSEnable must be set to 'On' or 'Off'";
     308    }
     309
     310    return NULL;
     311}
     312
     313const char *mgs_set_export_certificates_enabled(cmd_parms * parms, void *dummy,
     314                            const char *arg)
     315{
     316    mgs_srvconf_rec *sc =
     317        (mgs_srvconf_rec *) ap_get_module_config(parms->server->
     318                                                 module_config,
     319                                                 &gnutls_module);
     320    if (!strcasecmp(arg, "On")) {
     321        sc->export_certificates_enabled = GNUTLS_ENABLED_TRUE;
     322    } else if (!strcasecmp(arg, "Off")) {
     323        sc->export_certificates_enabled = GNUTLS_ENABLED_FALSE;
     324    } else {
     325        return "GnuTLSExportCertificates must be set to 'On' or 'Off'";
     326    }
     327
     328    return NULL;
     329}
     330
     331
     332const char *mgs_set_priorities(cmd_parms * parms, void *dummy, const char *arg)
     333{
     334    int ret;
     335    char *err;
     336    mgs_srvconf_rec *sc =
     337        (mgs_srvconf_rec *) ap_get_module_config(parms->server->
     338                                                 module_config,
     339                                                 &gnutls_module);
     340
     341
     342    ret = gnutls_priority_init( &sc->priorities, arg, &err);
     343    if (ret < 0) {
     344      if (ret == GNUTLS_E_INVALID_REQUEST)
     345        return apr_psprintf(parms->pool, "GnuTLS: Syntax error parsing priorities string at: %s", err);
     346      return "Error setting priorities";
    260347    }
    261348
     
    265352void *mgs_config_server_create(apr_pool_t * p, server_rec * s)
    266353{
    267     int i;
    268354    mgs_srvconf_rec *sc = apr_pcalloc(p, sizeof(*sc));
    269    
     355
    270356    sc->enabled = GNUTLS_ENABLED_FALSE;
    271    
     357
    272358    gnutls_certificate_allocate_credentials(&sc->certs);
     359    gnutls_anon_allocate_server_credentials(&sc->anon_creds);
     360    gnutls_srp_allocate_server_credentials(&sc->srp_creds);
     361
     362    sc->srp_tpasswd_conf_file = NULL;
     363    sc->srp_tpasswd_file = NULL;
    273364    sc->privkey_x509 = NULL;
    274365    sc->cert_x509 = NULL;
     
    276367    sc->cache_type = mgs_cache_dbm;
    277368    sc->cache_config = ap_server_root_relative(p, "conf/gnutls_cache");
    278    
    279     /* TODO: Make this Configurable. But it isn't configurable in mod_ssl? */
     369
    280370    sc->dh_params_file = ap_server_root_relative(p, "conf/dhfile");
    281371    sc->rsa_params_file = ap_server_root_relative(p, "conf/rsafile");
    282    
    283     /* Finish SSL Client Certificate Support */
     372
    284373    sc->client_verify_mode = GNUTLS_CERT_IGNORE;
    285    
    286     /* TODO: Make this Configurable ! */
    287     /* mod_ssl uses a flex based parser for this part.. sigh */
    288     i = 0;
    289     sc->ciphers[i++] = GNUTLS_CIPHER_AES_256_CBC;
    290     sc->ciphers[i++] = GNUTLS_CIPHER_AES_128_CBC;
    291     sc->ciphers[i++] = GNUTLS_CIPHER_ARCFOUR_128;
    292     sc->ciphers[i++] = GNUTLS_CIPHER_3DES_CBC;
    293     sc->ciphers[i++] = GNUTLS_CIPHER_ARCFOUR_40;
    294     sc->ciphers[i] = 0;
    295    
    296     i = 0;
    297     sc->key_exchange[i++] = GNUTLS_KX_RSA;
    298     sc->key_exchange[i++] = GNUTLS_KX_RSA_EXPORT;
    299     sc->key_exchange[i++] = GNUTLS_KX_DHE_DSS;
    300     sc->key_exchange[i++] = GNUTLS_KX_DHE_RSA;
    301     sc->key_exchange[i++] = GNUTLS_KX_ANON_DH;
    302     sc->key_exchange[i++] = GNUTLS_KX_SRP;
    303     sc->key_exchange[i++] = GNUTLS_KX_SRP_RSA;
    304     sc->key_exchange[i++] = GNUTLS_KX_SRP_DSS;
    305     sc->key_exchange[i] = 0;
    306    
    307     i = 0;
    308     sc->macs[i++] = GNUTLS_MAC_SHA;
    309     sc->macs[i++] = GNUTLS_MAC_MD5;
    310     sc->macs[i++] = GNUTLS_MAC_RMD160;
    311     sc->macs[i] = 0;
    312    
    313     i = 0;
    314     sc->protocol[i++] = GNUTLS_TLS1_1;
    315     sc->protocol[i++] = GNUTLS_TLS1;
    316     sc->protocol[i++] = GNUTLS_SSL3;
    317     sc->protocol[i] = 0;
    318    
    319     i = 0;
    320     sc->compression[i++] = GNUTLS_COMP_NULL;
    321     sc->compression[i++] = GNUTLS_COMP_ZLIB;
    322     sc->compression[i++] = GNUTLS_COMP_LZO;
    323     sc->compression[i] = 0;
    324    
    325     i = 0;
    326     sc->cert_types[i++] = GNUTLS_CRT_X509;
    327     sc->cert_types[i] = 0;
    328    
     374
    329375    return sc;
    330376}
    331377
    332 void *mgs_config_dir_merge(apr_pool_t *p, void *basev, void *addv)
     378void *mgs_config_dir_merge(apr_pool_t * p, void *basev, void *addv)
    333379{
    334380    mgs_dirconf_rec *new;
    335     mgs_dirconf_rec *base = (mgs_dirconf_rec *) basev;
     381/*    mgs_dirconf_rec *base = (mgs_dirconf_rec *) basev; */
    336382    mgs_dirconf_rec *add = (mgs_dirconf_rec *) addv;
    337    
     383
    338384    new = (mgs_dirconf_rec *) apr_pcalloc(p, sizeof(mgs_dirconf_rec));
    339385    new->lua_bytecode = apr_pstrmemdup(p, add->lua_bytecode,
    340                                        add->lua_bytecode_len);
     386                                       add->lua_bytecode_len);
    341387    new->lua_bytecode_len = add->lua_bytecode_len;
    342388    new->client_verify_mode = add->client_verify_mode;
     
    344390}
    345391
    346 void *mgs_config_dir_create(apr_pool_t *p, char *dir)
     392void *mgs_config_dir_create(apr_pool_t * p, char *dir)
    347393{
    348394    mgs_dirconf_rec *dc = apr_palloc(p, sizeof(*dc));
    349    
     395
    350396    dc->client_verify_mode = -1;
    351397    dc->lua_bytecode = NULL;
     
    353399    return dc;
    354400}
    355 
Note: See TracChangeset for help on using the changeset viewer.