source: mod_gnutls/src/mod_gnutls.c @ 0475f1bc

debian/masterdebian/stretch-backportsjessie-backportsmsvaupstream
Last change on this file since 0475f1bc was 482f47f, checked in by Paul Querna <chip@…>, 15 years ago

include support for 2.0.xx

  • Property mode set to 100644
File size: 20.5 KB
Line 
1/**
2 *  Copyright 2004-2005 Paul Querna
3 *
4 *  Licensed under the Apache License, Version 2.0 (the "License");
5 *  you may not use this file except in compliance with the License.
6 *  You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 *  Unless required by applicable law or agreed to in writing, software
11 *  distributed under the License is distributed on an "AS IS" BASIS,
12 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 *  See the License for the specific language governing permissions and
14 *  limitations under the License.
15 *
16 */
17
18#include "mod_gnutls.h"
19
20#if APR_HAS_THREADS
21GCRY_THREAD_OPTION_PTHREAD_IMPL;
22#endif
23
24#if MOD_GNUTLS_DEBUG
25static apr_file_t* debug_log_fp;
26#endif
27
28static apr_status_t mod_gnutls_cleanup_pre_config(void *data)
29{
30    gnutls_global_deinit();
31    return APR_SUCCESS;
32}
33
34#if MOD_GNUTLS_DEBUG
35static void gnutls_debug_log_all( int level, const char* str)
36{
37    apr_file_printf(debug_log_fp, "<%d> %s\n", level, str);
38}
39#endif
40
41static int mod_gnutls_hook_pre_config(apr_pool_t * pconf,
42                                      apr_pool_t * plog, apr_pool_t * ptemp)
43{
44
45#if APR_HAS_THREADS
46    /* TODO: Check MPM Type here */
47    gcry_control(GCRYCTL_SET_THREAD_CBS, &gcry_threads_pthread);
48#endif
49
50    gnutls_global_init();
51
52    apr_pool_cleanup_register(pconf, NULL, mod_gnutls_cleanup_pre_config,
53                              apr_pool_cleanup_null);
54
55#if MOD_GNUTLS_DEBUG
56    apr_file_open(&debug_log_fp, "/tmp/gnutls_debug",
57                  APR_APPEND|APR_WRITE|APR_CREATE, APR_OS_DEFAULT, pconf);
58
59    gnutls_global_set_log_level(9);
60    gnutls_global_set_log_function(gnutls_debug_log_all);
61#endif
62
63    return OK;
64}
65
66
67static gnutls_datum load_params(const char* file, server_rec* s, 
68                                apr_pool_t* pool) 
69{
70    gnutls_datum ret = { NULL, 0 };
71    apr_file_t* fp;
72    apr_finfo_t finfo;
73    apr_status_t rv;
74    apr_size_t br = 0;
75
76    rv = apr_file_open(&fp, file, APR_READ|APR_BINARY, APR_OS_DEFAULT, 
77                       pool);
78    if (rv != APR_SUCCESS) {
79        ap_log_error(APLOG_MARK, APLOG_STARTUP, rv, s, 
80                     "GnuTLS failed to load params file at: %s", file);
81        return ret;
82    }
83
84    rv = apr_file_info_get(&finfo, APR_FINFO_SIZE, fp);
85
86    if (rv != APR_SUCCESS) {
87        ap_log_error(APLOG_MARK, APLOG_STARTUP, rv, s, 
88                     "GnuTLS failed to stat params file at: %s", file);
89        return ret;
90    }
91
92    ret.data = apr_palloc(pool, finfo.size+1);
93    rv = apr_file_read_full(fp, ret.data, finfo.size, &br);
94
95    if (rv != APR_SUCCESS) {
96        ap_log_error(APLOG_MARK, APLOG_STARTUP, rv, s, 
97                     "GnuTLS failed to read params file at: %s", file);
98        return ret;
99    }
100
101    ret.data[br] = '\0';
102    ret.size = br;
103
104    return ret;
105}
106
107static int mod_gnutls_hook_post_config(apr_pool_t * p, apr_pool_t * plog,
108                                       apr_pool_t * ptemp,
109                                       server_rec * base_server)
110{
111    int rv;
112    server_rec *s;
113    gnutls_dh_params_t dh_params;
114    gnutls_rsa_params_t rsa_params;
115    mod_gnutls_srvconf_rec *sc;
116    mod_gnutls_srvconf_rec *sc_base;
117    void *data = NULL;
118    int first_run = 0;
119    const char *userdata_key = "mod_gnutls_init";
120         
121    apr_pool_userdata_get(&data, userdata_key, base_server->process->pool);
122    if (data == NULL) {
123        first_run = 1;
124        apr_pool_userdata_set((const void *)1, userdata_key, 
125                              apr_pool_cleanup_null, 
126                              base_server->process->pool);
127    }
128
129
130    if (!first_run) {
131        gnutls_datum pdata;
132        apr_pool_t* tpool;
133        s = base_server;
134        sc_base = (mod_gnutls_srvconf_rec *) ap_get_module_config(s->module_config,
135                                                             &gnutls_module);
136
137        apr_pool_create(&tpool, p);
138
139        gnutls_dh_params_init(&dh_params);
140
141        pdata = load_params(sc_base->dh_params_file, s, tpool);
142
143        if (pdata.size != 0) {
144            rv = gnutls_dh_params_import_pkcs3(dh_params, &pdata, 
145                                               GNUTLS_X509_FMT_PEM);
146            if (rv != 0) {
147                ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s, 
148                             "GnuTLS: Unable to load DH Params: (%d) %s",
149                             rv, gnutls_strerror(rv));
150                exit(rv);
151            }
152        }
153        else {
154            ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s, 
155                         "GnuTLS: Unable to load DH Params."
156                         " Shutting Down.");
157            exit(-1);
158        }
159        apr_pool_clear(tpool);
160
161        gnutls_rsa_params_init(&rsa_params);
162
163        pdata = load_params(sc_base->rsa_params_file, s, tpool);
164
165        if (pdata.size != 0) {
166            rv = gnutls_rsa_params_import_pkcs1(rsa_params, &pdata, 
167                                                GNUTLS_X509_FMT_PEM);
168            if (rv != 0) {
169                ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s, 
170                             "GnuTLS: Unable to load RSA Params: (%d) %s",
171                             rv, gnutls_strerror(rv));
172                exit(rv);
173            }
174        }
175        else {
176            ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s, 
177                         "GnuTLS: Unable to load RSA Params."
178                         " Shutting Down.");
179            exit(-1);
180        }
181
182        apr_pool_destroy(tpool);
183        rv = mod_gnutls_cache_post_config(p, s, sc_base);
184        if (rv != 0) {
185            ap_log_error(APLOG_MARK, APLOG_STARTUP, rv, s, 
186                         "GnuTLS: Post Config for GnuTLSCache Failed."
187                         " Shutting Down.");
188            exit(-1);
189        }
190         
191        for (s = base_server; s; s = s->next) {
192            sc = (mod_gnutls_srvconf_rec *) ap_get_module_config(s->module_config,
193                                                                 &gnutls_module);
194            sc->cache_type = sc_base->cache_type;
195            sc->cache_config = sc_base->cache_config;
196
197            if (sc->cert_file != NULL && sc->key_file != NULL) {
198
199                rv = gnutls_certificate_set_x509_key_file(sc->certs, sc->cert_file,
200                                                 sc->key_file,
201                                                 GNUTLS_X509_FMT_PEM);
202                if (rv != 0) {
203                    ap_log_error(APLOG_MARK, APLOG_EMERG, 0, s,
204                         "[GnuTLS] - Host '%s:%d' has an invalid key or certificate:"
205                         "(%s,%s) (%d) %s",
206                         s->server_hostname, s->port, sc->cert_file, sc->key_file,
207                         rv, gnutls_strerror(rv));
208                }
209                else {
210                    gnutls_certificate_set_rsa_export_params(sc->certs, 
211                                                     rsa_params);
212                    gnutls_certificate_set_dh_params(sc->certs, dh_params);
213                }
214            }
215            else if (sc->enabled == GNUTLS_ENABLED_TRUE) {
216                ap_log_error(APLOG_MARK, APLOG_EMERG, 0, s,
217                             "[GnuTLS] - Host '%s:%d' is missing a "
218                             "Cert and Key File!",
219                         s->server_hostname, s->port);
220            }
221        }
222    } /* first_run */
223
224    ap_add_version_component(p, "mod_gnutls/" MOD_GNUTLS_VERSION);
225
226    return OK;
227}
228
229static void mod_gnutls_hook_child_init(apr_pool_t *p, server_rec *s)
230{
231    apr_status_t rv = APR_SUCCESS;
232    mod_gnutls_srvconf_rec *sc = ap_get_module_config(s->module_config,
233                                                      &gnutls_module);
234
235    if (sc->cache_type != mod_gnutls_cache_none) {
236        rv = mod_gnutls_cache_child_init(p, s, sc);
237        if(rv != APR_SUCCESS) {
238            ap_log_error(APLOG_MARK, APLOG_EMERG, rv, s,
239                             "[GnuTLS] - Failed to run Cache Init");
240        }
241    }
242    else {
243        ap_log_error(APLOG_MARK, APLOG_CRIT, 0, s,
244                     "[GnuTLS] - No Cache Configured. Hint: GnuTLSCache");
245    }
246}
247
248static const char *mod_gnutls_hook_http_scheme(const request_rec * r)
249{
250    mod_gnutls_srvconf_rec *sc =
251        (mod_gnutls_srvconf_rec *) ap_get_module_config(r->server->
252                                                        module_config,
253                                                        &gnutls_module);
254
255    if (sc->enabled == GNUTLS_ENABLED_FALSE) {
256        return NULL;
257    }
258
259    return "https";
260}
261
262static apr_port_t mod_gnutls_hook_default_port(const request_rec * r)
263{
264    mod_gnutls_srvconf_rec *sc =
265        (mod_gnutls_srvconf_rec *) ap_get_module_config(r->server->
266                                                        module_config,
267                                                        &gnutls_module);
268
269    if (sc->enabled == GNUTLS_ENABLED_FALSE) {
270        return 0;
271    }
272
273    return 443;
274}
275
276/* TODO: Complete support for Server Name Indication */
277static int cert_retrieve_fn(gnutls_session_t session, gnutls_retr_st* ret) 
278{
279    char* server_name;
280    int server_type;
281    int data_len = 256;
282    mod_gnutls_handle_t *ctxt;   
283    ctxt = gnutls_transport_get_ptr(session);
284
285    ret->type = GNUTLS_CRT_X509;
286    ret->ncerts = 1;
287    server_name = apr_palloc(ctxt->c->pool, data_len);
288    if (gnutls_server_name_get(ctxt->session, server_name, &data_len, &server_type, 0) == 0) {
289        if (server_type == GNUTLS_NAME_DNS) {
290            ap_log_error(APLOG_MARK, APLOG_INFO, 0,
291                         ctxt->c->base_server,
292                         "GnuTLS: Virtual Host: "
293                         "%s", server_name);
294        }
295    }
296
297    return 0;
298}
299
300static mod_gnutls_handle_t* create_gnutls_handle(apr_pool_t* pool, conn_rec * c)
301{
302    mod_gnutls_handle_t *ctxt;
303    mod_gnutls_srvconf_rec *sc =
304        (mod_gnutls_srvconf_rec *) ap_get_module_config(c->base_server->
305                                                        module_config,
306                                                        &gnutls_module);
307
308    ctxt = apr_pcalloc(pool, sizeof(*ctxt));
309    ctxt->c = c;
310    ctxt->sc = sc;
311    ctxt->status = 0;
312
313    ctxt->input_rc = APR_SUCCESS;
314    ctxt->input_bb = apr_brigade_create(c->pool, c->bucket_alloc);
315    ctxt->input_cbuf.length = 0;
316
317    ctxt->output_rc = APR_SUCCESS;
318    ctxt->output_bb = apr_brigade_create(c->pool, c->bucket_alloc);
319    ctxt->output_blen = 0;
320    ctxt->output_length = 0;
321
322    gnutls_init(&ctxt->session, GNUTLS_SERVER);
323
324    gnutls_protocol_set_priority(ctxt->session, sc->protocol);
325    gnutls_cipher_set_priority(ctxt->session, sc->ciphers);
326    gnutls_compression_set_priority(ctxt->session, sc->compression);
327    gnutls_kx_set_priority(ctxt->session, sc->key_exchange);
328    gnutls_mac_set_priority(ctxt->session, sc->macs);
329    gnutls_certificate_type_set_priority(ctxt->session, sc->cert_types);
330
331    gnutls_credentials_set(ctxt->session, GNUTLS_CRD_CERTIFICATE, sc->certs);
332
333    gnutls_certificate_server_set_request(ctxt->session, GNUTLS_CERT_IGNORE);
334
335    mod_gnutls_cache_session_init(ctxt);
336
337    /* TODO: Finish Support for Server Name Indication */
338    /* gnutls_certificate_server_set_retrieve_function(sc->certs, cert_retrieve_fn); */
339    return ctxt;
340}
341
342static int mod_gnutls_hook_pre_connection(conn_rec * c, void *csd)
343{
344    mod_gnutls_handle_t *ctxt;
345    mod_gnutls_srvconf_rec *sc =
346        (mod_gnutls_srvconf_rec *) ap_get_module_config(c->base_server->
347                                                        module_config,
348                                                        &gnutls_module);
349
350    if (!(sc && (sc->enabled == GNUTLS_ENABLED_TRUE))) {
351        return DECLINED;
352    }
353
354    ctxt = create_gnutls_handle(c->pool, c);
355
356    ap_set_module_config(c->conn_config, &gnutls_module, ctxt);
357
358    gnutls_transport_set_pull_function(ctxt->session,
359                                       mod_gnutls_transport_read);
360    gnutls_transport_set_push_function(ctxt->session,
361                                       mod_gnutls_transport_write);
362    gnutls_transport_set_ptr(ctxt->session, ctxt);
363   
364    ctxt->input_filter = ap_add_input_filter(GNUTLS_INPUT_FILTER_NAME, ctxt, 
365                                             NULL, c);
366    ctxt->output_filter = ap_add_output_filter(GNUTLS_OUTPUT_FILTER_NAME, ctxt,
367                                               NULL, c);
368
369    return OK;
370}
371
372static int mod_gnutls_hook_fixups(request_rec *r)
373{
374    unsigned char sbuf[GNUTLS_MAX_SESSION_ID];
375    char buf[GNUTLS_SESSION_ID_STRING_LEN];
376    const char* tmp;
377    int len;
378    mod_gnutls_handle_t *ctxt;
379    apr_table_t *env = r->subprocess_env;
380
381    ctxt = ap_get_module_config(r->connection->conn_config, &gnutls_module);
382
383    if(!ctxt) {
384        return DECLINED;
385    }
386
387    apr_table_setn(env, "HTTPS", "on");
388
389    apr_table_setn(env, "GNUTLS_VERSION_INTERFACE", MOD_GNUTLS_VERSION);
390    apr_table_setn(env, "GNUTLS_VERSION_LIBRARY", LIBGNUTLS_VERSION);
391
392    apr_table_setn(env, "SSL_PROTOCOL",
393                   gnutls_protocol_get_name(gnutls_protocol_get_version(ctxt->session)));
394
395    apr_table_setn(env, "SSL_CIPHER",
396                   gnutls_cipher_get_name(gnutls_cipher_get(ctxt->session)));
397
398    apr_table_setn(env, "SSL_CLIENT_VERIFY", "NONE");
399
400    tmp = apr_psprintf(r->pool, "%d",
401              8 * gnutls_cipher_get_key_size(gnutls_cipher_get(ctxt->session)));
402
403    apr_table_setn(env, "SSL_CIPHER_USEKEYSIZE", tmp);
404
405    apr_table_setn(env, "SSL_CIPHER_ALGKEYSIZE", tmp);
406
407    len = sizeof(sbuf);
408    gnutls_session_get_id(ctxt->session, sbuf, &len);
409    tmp = mod_gnutls_session_id2sz(sbuf, len, buf, sizeof(buf));
410    apr_table_setn(env, "SSL_SESSION_ID", tmp);
411   
412    return OK;
413}
414
415static const char *gnutls_set_cert_file(cmd_parms * parms, void *dummy,
416                                        const char *arg)
417{
418    mod_gnutls_srvconf_rec *sc =
419        (mod_gnutls_srvconf_rec *) ap_get_module_config(parms->server->
420                                                        module_config,
421                                                        &gnutls_module);
422    sc->cert_file = ap_server_root_relative(parms->pool, arg);
423    return NULL;
424}
425
426static const char *gnutls_set_key_file(cmd_parms * parms, void *dummy,
427                                       const char *arg)
428{
429    mod_gnutls_srvconf_rec *sc =
430        (mod_gnutls_srvconf_rec *) ap_get_module_config(parms->server->
431                                                        module_config,
432                                                        &gnutls_module);
433   
434    sc->key_file = ap_server_root_relative(parms->pool, arg);
435    return NULL;
436}
437
438static const char *gnutls_set_cache(cmd_parms * parms, void *dummy,
439                                       const char *type, const char* arg)
440{
441    const char* err;
442    mod_gnutls_srvconf_rec *sc = ap_get_module_config(parms->server->
443                                                        module_config,
444                                                        &gnutls_module);
445    if ((err = ap_check_cmd_context(parms, GLOBAL_ONLY))) {
446        return err;
447    }
448
449    if (strcasecmp("none", type) == 0) {
450        sc->cache_type = mod_gnutls_cache_none;
451    }
452    else if (strcasecmp("dbm", type) == 0) {
453        sc->cache_type = mod_gnutls_cache_dbm;
454    }
455#if HAVE_APR_MEMCACHE
456    else if (strcasecmp("memcache", type) == 0) {
457        sc->cache_type = mod_gnutls_cache_memcache;
458    }
459#endif
460    else {
461        return "Invalid Type for GnuTLSCache!";
462    }
463
464    if (sc->cache_type == mod_gnutls_cache_dbm) {
465        sc->cache_config = ap_server_root_relative(parms->pool, arg);
466    }
467    else {
468        sc->cache_config = apr_pstrdup(parms->pool, arg);
469    }
470
471    return NULL;
472}
473
474static const char *gnutls_set_enabled(cmd_parms * parms, void *dummy,
475                                      const char *arg)
476{
477    mod_gnutls_srvconf_rec *sc =
478        (mod_gnutls_srvconf_rec *) ap_get_module_config(parms->server->
479                                                        module_config,
480                                                        &gnutls_module);
481    if (!strcasecmp(arg, "On")) {
482        sc->enabled = GNUTLS_ENABLED_TRUE;
483    }
484    else if (!strcasecmp(arg, "Off")) {
485        sc->enabled = GNUTLS_ENABLED_FALSE;
486    }
487    else {
488        return "GnuTLSEnable must be set to 'On' or 'Off'";
489    }
490
491    return NULL;
492}
493
494static const command_rec gnutls_cmds[] = {
495    AP_INIT_TAKE1("GnuTLSCertificateFile", gnutls_set_cert_file,
496                  NULL,
497                  RSRC_CONF,
498                  "SSL Server Key file"),
499    AP_INIT_TAKE1("GnuTLSKeyFile", gnutls_set_key_file,
500                  NULL,
501                  RSRC_CONF,
502                  "SSL Server Certificate file"),
503    AP_INIT_TAKE2("GnuTLSCache", gnutls_set_cache,
504                  NULL,
505                  RSRC_CONF,
506                  "Cache Configuration"),
507    AP_INIT_TAKE1("GnuTLSEnable", gnutls_set_enabled,
508                  NULL, RSRC_CONF,
509                  "Whether this server has GnuTLS Enabled. Default: Off"),
510
511    {NULL}
512};
513
514/* TODO: CACertificateFile & Client Authentication
515 *    AP_INIT_TAKE1("GnuTLSCACertificateFile", ap_set_server_string_slot,
516 *                 (void *) APR_OFFSETOF(gnutls_srvconf_rec, key_file), NULL,
517 *                 RSRC_CONF,
518 *                 "CA"),
519 */
520
521static void gnutls_hooks(apr_pool_t * p)
522{
523    ap_hook_pre_connection(mod_gnutls_hook_pre_connection, NULL, NULL,
524                           APR_HOOK_MIDDLE);
525    ap_hook_post_config(mod_gnutls_hook_post_config, NULL, NULL,
526                        APR_HOOK_MIDDLE);
527    ap_hook_child_init(mod_gnutls_hook_child_init, NULL, NULL,
528                        APR_HOOK_MIDDLE);
529#if USING_2_1_RECENT
530    ap_hook_http_scheme(mod_gnutls_hook_http_scheme, NULL, NULL,
531                        APR_HOOK_MIDDLE);
532#else
533    ap_hook_http_method(mod_gnutls_hook_http_scheme, NULL, NULL,
534                        APR_HOOK_MIDDLE);
535#endif
536    ap_hook_default_port(mod_gnutls_hook_default_port, NULL, NULL,
537                         APR_HOOK_MIDDLE);
538    ap_hook_pre_config(mod_gnutls_hook_pre_config, NULL, NULL,
539                       APR_HOOK_MIDDLE);
540
541    ap_hook_fixups(mod_gnutls_hook_fixups, NULL, NULL, APR_HOOK_MIDDLE);
542
543    /* TODO: HTTP Upgrade Filter */
544    /* ap_register_output_filter ("UPGRADE_FILTER",
545     *          ssl_io_filter_Upgrade, NULL, AP_FTYPE_PROTOCOL + 5);
546     */
547    ap_register_input_filter(GNUTLS_INPUT_FILTER_NAME,
548                             mod_gnutls_filter_input, NULL,
549                             AP_FTYPE_CONNECTION + 5);
550    ap_register_output_filter(GNUTLS_OUTPUT_FILTER_NAME,
551                              mod_gnutls_filter_output, NULL,
552                              AP_FTYPE_CONNECTION + 5);
553}
554
555static void *gnutls_config_server_create(apr_pool_t * p, server_rec * s)
556{
557    int i;
558    mod_gnutls_srvconf_rec *sc = apr_pcalloc(p, sizeof(*sc));
559
560    sc->enabled = GNUTLS_ENABLED_FALSE;
561
562    gnutls_certificate_allocate_credentials(&sc->certs);
563    sc->key_file = NULL;
564    sc->cert_file = NULL;
565    sc->cache_timeout = apr_time_from_sec(3600);
566    sc->cache_type = mod_gnutls_cache_dbm;
567    sc->cache_config = ap_server_root_relative(p, "conf/gnutls_cache");
568
569    /* TODO: Make this Configurable ! */
570    sc->dh_params_file = ap_server_root_relative(p, "conf/dhfile");
571    sc->rsa_params_file = ap_server_root_relative(p, "conf/rsafile");
572
573    /* TODO: Make this Configurable ! */
574    /* meh. mod_ssl uses a flex based parser for this part.. sigh */
575    i = 0;
576    sc->ciphers[i++] = GNUTLS_CIPHER_AES_256_CBC;
577    sc->ciphers[i++] = GNUTLS_CIPHER_AES_128_CBC;
578    sc->ciphers[i++] = GNUTLS_CIPHER_ARCFOUR_128;
579    sc->ciphers[i++] = GNUTLS_CIPHER_3DES_CBC;
580    sc->ciphers[i++] = GNUTLS_CIPHER_ARCFOUR_40;
581    sc->ciphers[i] = 0;
582
583    i = 0;
584    sc->key_exchange[i++] = GNUTLS_KX_RSA;
585    sc->key_exchange[i++] = GNUTLS_KX_RSA_EXPORT;
586    sc->key_exchange[i++] = GNUTLS_KX_DHE_DSS;
587    sc->key_exchange[i++] = GNUTLS_KX_DHE_RSA;
588    sc->key_exchange[i++] = GNUTLS_KX_ANON_DH;
589    sc->key_exchange[i++] = GNUTLS_KX_SRP;
590    sc->key_exchange[i++] = GNUTLS_KX_SRP_RSA;
591    sc->key_exchange[i++] = GNUTLS_KX_SRP_DSS;
592    sc->key_exchange[i] = 0;
593
594    i = 0;
595    sc->macs[i++] = GNUTLS_MAC_SHA;
596    sc->macs[i++] = GNUTLS_MAC_MD5;
597    sc->macs[i++] = GNUTLS_MAC_RMD160;
598    sc->macs[i] = 0;
599
600    i = 0;
601    sc->protocol[i++] = GNUTLS_TLS1_1;
602    sc->protocol[i++] = GNUTLS_TLS1;
603    sc->protocol[i++] = GNUTLS_SSL3;
604    sc->protocol[i] = 0;
605
606    i = 0;
607    sc->compression[i++] = GNUTLS_COMP_NULL;
608    sc->compression[i++] = GNUTLS_COMP_ZLIB;
609    sc->compression[i++] = GNUTLS_COMP_LZO;
610    sc->compression[i] = 0;
611
612    i = 0;
613    sc->cert_types[i++] = GNUTLS_CRT_X509;
614    sc->cert_types[i] = 0;
615 
616    return sc;
617}
618
619
620
621module AP_MODULE_DECLARE_DATA gnutls_module = {
622    STANDARD20_MODULE_STUFF,
623    NULL,
624    NULL,
625    gnutls_config_server_create,
626    NULL,
627/*    gnutls_config_server_merge, */
628    gnutls_cmds,
629    gnutls_hooks
630};
Note: See TracBrowser for help on using the repository browser.