Changeset 42307a9 in mod_gnutls for src/gnutls_cache.c


Ignore:
Timestamp:
Apr 6, 2005, 12:52:25 AM (15 years ago)
Author:
Paul Querna <chip@…>
Branches:
debian/master, debian/stretch-backports, jessie-backports, master, msva, upstream
Children:
6af4f74
Parents:
fcb122d
Message:
  • remove anno creds
  • initial attempt at Server Name Extension
  • change to adding 'mod_gnutls' to the server sig instead of GnuTLS/
  • fix for EOF/EOC/EOS buckets
  • 'general' code cleanups
File:
1 edited

Legend:

Unmodified
Added
Removed
  • src/gnutls_cache.c

    rfcb122d r42307a9  
    3333#endif
    3434
    35 #define GNUTLS_SESSION_ID_STRING_LEN \
    36     ((GNUTLS_MAX_SESSION_ID + 1) * 2)
     35
    3736#define MC_TAG "mod_gnutls:"
    3837#define MC_TAG_LEN \
     
    4140
    4241static char *gnutls_session_id2sz(unsigned char *id, int idlen,
    43                         char *str, int strsize)
     42                               char *str, int strsize)
    4443{
    4544    char *cp;
     
    4746 
    4847    cp = apr_cpystrn(str, MC_TAG, MC_TAG_LEN);
     48    for (n = 0; n < idlen && n < GNUTLS_MAX_SESSION_ID; n++) {
     49        apr_snprintf(cp, strsize - (cp-str), "%02X", id[n]);
     50        cp += 2;
     51    }
     52    *cp = '\0';
     53    return str;
     54}
     55
     56char *mod_gnutls_session_id2sz(unsigned char *id, int idlen,
     57                               char *str, int strsize)
     58{
     59    char *cp;
     60    int n;
     61   
     62    cp = str;
    4963    for (n = 0; n < idlen && n < GNUTLS_MAX_SESSION_ID; n++) {
    5064        apr_snprintf(cp, strsize - (cp-str), "%02X", id[n]);
     
    104118
    105119        rv = apr_parse_addr_port(&host_str, &scope_id, &port, split, p);
    106         if(rv != APR_SUCCESS) {
     120        if (rv != APR_SUCCESS) {
    107121            ap_log_error(APLOG_MARK, APLOG_CRIT, rv, s,
    108122                         "[gnutls_cache] Failed to Parse Server: '%s'", split);
     
    110124        }
    111125
    112         if(host_str == NULL) {
     126        if (host_str == NULL) {
    113127            ap_log_error(APLOG_MARK, APLOG_CRIT, rv, s,
    114128                         "[gnutls_cache] Failed to Parse Server, "
     
    129143                                        600,
    130144                                        &st);
    131         if(rv != APR_SUCCESS) {
     145        if (rv != APR_SUCCESS) {
    132146            ap_log_error(APLOG_MARK, APLOG_CRIT, rv, s,
    133147                         "[gnutls_cache] Failed to Create Server: %s:%d",
     
    137151
    138152        rv = apr_memcache_add_server(mc, st);
    139         if(rv != APR_SUCCESS) {
     153        if (rv != APR_SUCCESS) {
    140154            ap_log_error(APLOG_MARK, APLOG_CRIT, rv, s,
    141155                         "[gnutls_cache] Failed to Add Server: %s:%d",
     
    162176        return -1;
    163177
    164     timeout = ctxt->sc->cache_timeout;
    165 
    166     rv = apr_memcache_set(mc,  strkey, data.data, data.size, timeout, 0);
    167 
    168     if(rv != APR_SUCCESS) {
     178    timeout = apr_time_sec(ctxt->sc->cache_timeout);
     179
     180    rv = apr_memcache_set(mc, strkey, data.data, data.size, timeout, 0);
     181
     182    if (rv != APR_SUCCESS) {
    169183        ap_log_error(APLOG_MARK, APLOG_CRIT, rv,
    170184                     ctxt->c->base_server,
     
    188202
    189203    strkey = gnutls_session_id2sz(key.data, key.size, buf, sizeof(buf));
    190     if(!strkey) {
     204    if (!strkey) {
    191205        return data;
    192206    }
     
    195209                           &value, &value_len, NULL);
    196210
    197     if(rv != APR_SUCCESS) {
     211    if (rv != APR_SUCCESS) {
    198212        ap_log_error(APLOG_MARK, APLOG_DEBUG, rv,
    199213                     ctxt->c->base_server,
     
    230244    rv = apr_memcache_delete(mc, strkey, 0);
    231245
    232     if(rv != APR_SUCCESS) {
     246    if (rv != APR_SUCCESS) {
    233247        ap_log_error(APLOG_MARK, APLOG_DEBUG, rv,
    234248                     ctxt->c->base_server,
     
    249263    apr_status_t rv;
    250264    apr_dbm_t *dbm;
     265    apr_datum_t *keylist;
     266    apr_datum_t dbmkey;
     267    apr_datum_t dbmval;
     268    apr_time_t ex;
     269    apr_time_t dtime;
     270    apr_pool_t* spool;
     271    int i = 0;
     272    int keyidx = 0;
     273    int should_delete = 0;
     274
     275    apr_pool_create(&spool, ctxt->c->pool);
     276    ex = apr_time_now();
     277   
     278    rv = apr_dbm_open(&dbm, ctxt->sc->cache_config, APR_DBM_READONLY,
     279                      SSL_DBM_FILE_MODE, spool);
     280    if (rv != APR_SUCCESS) {
     281        ap_log_error(APLOG_MARK, APLOG_NOTICE, rv,
     282                     ctxt->c->base_server,
     283                     "[gnutls_cache] error opening cache searcher '%s'",
     284                     ctxt->sc->cache_config);
     285        return -1;
     286    }
     287
     288#define KEYMAX 128
     289
     290    keylist = apr_palloc(spool, sizeof(dbmkey)*KEYMAX);
     291
     292    apr_dbm_firstkey(dbm, &dbmkey);
     293    while (dbmkey.dptr != NULL) {
     294        apr_dbm_fetch(dbm, dbmkey, &dbmval);
     295        if (dbmval.dptr != NULL) {
     296            if (dbmval.dsize >= sizeof(apr_time_t)) {
     297                memcpy(&dtime, dbmval.dptr, sizeof(apr_time_t));
     298                if (dtime < ex) {
     299                    should_delete = 1;
     300                }
     301            }
     302            else {
     303                should_delete = 1;
     304            }
     305           
     306            if (should_delete == 1) {
     307                should_delete = 0;
     308                keylist[keyidx].dptr = apr_palloc(spool, dbmkey.dsize) ;
     309                memcpy(keylist[keyidx].dptr, dbmkey.dptr, dbmkey.dsize);
     310                keylist[keyidx].dsize = dbmkey.dsize;
     311                keyidx++;
     312                if (keyidx == KEYMAX) {
     313                    break;
     314                }
     315            }
     316           
     317        }
     318        apr_dbm_nextkey(dbm, &dbmkey);
     319    }
     320    apr_dbm_close(dbm);
    251321
    252322    rv = apr_dbm_open(&dbm, ctxt->sc->cache_config,
    253                       APR_DBM_RWCREATE, SSL_DBM_FILE_MODE, ctxt->c->pool);
    254     if (rv != APR_SUCCESS) {
    255         ap_log_error(APLOG_MARK, APLOG_NOTICE, rv,
    256                      ctxt->c->base_server,
    257                      "[gnutls_cache] error opening cache '%s'",
    258                      ctxt->sc->cache_config);
    259         return -1;
    260     }
     323                  APR_DBM_RWCREATE, SSL_DBM_FILE_MODE, spool);
     324    if (rv != APR_SUCCESS) {
     325        ap_log_error(APLOG_MARK, APLOG_NOTICE, rv,
     326                 ctxt->c->base_server,
     327                 "[gnutls_cache] error opening cache writer '%s'",
     328                 ctxt->sc->cache_config);
     329        return -1;
     330    }
     331
     332    for (i = 0; i < keyidx; i++) {
     333        apr_dbm_delete(dbm, keylist[i]);
     334    }
     335
    261336    apr_dbm_close(dbm);
    262 
     337    apr_pool_destroy(spool);
     338   
    263339    return 0;
    264340}
     
    276352    dbmkey.dsize = key.size;
    277353
     354    dbm_cache_expire(ctxt);
     355
    278356    rv = apr_dbm_open(&dbm, ctxt->sc->cache_config,
    279357                      APR_DBM_RWCREATE, SSL_DBM_FILE_MODE, ctxt->c->pool);
     
    287365
    288366    rv = apr_dbm_fetch(dbm, dbmkey, &dbmval);
    289 
     367   
    290368    if (rv != APR_SUCCESS) {
    291369        apr_dbm_close(dbm);
     
    297375        return data;
    298376    }
    299 
    300     data.data = gnutls_malloc(dbmval.dsize - sizeof(apr_time_t));
    301     if (data.data == NULL)
    302         return data;
     377    apr_dbm_close(dbm);
    303378
    304379    data.size = dbmval.dsize - sizeof(apr_time_t);
     380
     381    data.data = gnutls_malloc(data.size);
     382    if (data.data == NULL) {
     383        return data;
     384    }
     385   
    305386    memcpy(data.data, dbmval.dptr+sizeof(apr_time_t), data.size);
    306387
    307     apr_dbm_close(dbm);
    308388    return data;
    309389}
     
    317397    mod_gnutls_handle_t *ctxt = baton;
    318398    apr_status_t rv;
    319     apr_time_t timeout;
     399    apr_time_t expiry;
    320400   
    321401    dbmkey.dptr  = (char *)key.data;
     
    323403
    324404    /* create DBM value */
    325     dbmval.dsize = data.size;
    326     dbmval.dptr  = (char *)malloc(dbmval.dsize+sizeof(apr_time_t));
    327 
     405    dbmval.dsize = data.size + sizeof(apr_time_t);
     406    dbmval.dptr  = (char *)malloc(dbmval.dsize);
     407
     408    expiry = apr_time_now() + ctxt->sc->cache_timeout;
     409
     410    memcpy((char *)dbmval.dptr, &expiry, sizeof(apr_time_t));
    328411    memcpy((char *)dbmval.dptr+sizeof(apr_time_t),
    329412           data.data, data.size);
     413
     414    dbm_cache_expire(ctxt);
    330415
    331416    rv = apr_dbm_open(&dbm, ctxt->sc->cache_config,
     
    341426
    342427    rv = apr_dbm_store(dbm, dbmkey, dbmval);
    343 
     428   
    344429    if (rv != APR_SUCCESS) {
    345430        ap_log_error(APLOG_MARK, APLOG_NOTICE, rv,
     
    369454    dbmkey.dsize = key.size;
    370455
     456    dbm_cache_expire(ctxt);
     457   
    371458    rv = apr_dbm_open(&dbm, ctxt->sc->cache_config,
    372459                      APR_DBM_RWCREATE, SSL_DBM_FILE_MODE, ctxt->c->pool);
     
    384471        ap_log_error(APLOG_MARK, APLOG_NOTICE, rv,
    385472                     ctxt->c->base_server,
    386                      "[gnutls_cache] error storing in cache '%s'",
     473                     "[gnutls_cache] error deleting from cache '%s'",
    387474                     ctxt->sc->cache_config);
    388475        apr_dbm_close(dbm);
     
    395482}
    396483
    397 static int dbm_cache_child_init(apr_pool_t *p, server_rec *s,
     484static int dbm_cache_post_config(apr_pool_t *p, server_rec *s,
    398485                                mod_gnutls_srvconf_rec *sc)
    399486{
     
    435522{
    436523    if (sc->cache_type == mod_gnutls_cache_dbm) {
    437         return dbm_cache_child_init(p, s, sc);
     524        return dbm_cache_post_config(p, s, sc);
    438525    }
    439526    return 0;
     
    458545int mod_gnutls_cache_session_init(mod_gnutls_handle_t *ctxt)
    459546{
    460     printf("Type: %d Params: %s\n",ctxt->sc->cache_type, ctxt->sc->cache_config);
    461547    if (ctxt->sc->cache_type == mod_gnutls_cache_dbm) {
    462548        gnutls_db_set_retrieve_function(ctxt->session, dbm_cache_fetch);
     
    473559    }
    474560#endif
    475     else {
    476         assert(1);
    477         /* No Session Cache is Available. Opps. */
    478     }
    479     return 0;
    480 }
     561
     562    return 0;
     563}
Note: See TracChangeset for help on using the changeset viewer.