src/chxj_dbm.c

   1 /*
   2  * Copyright (C) 2005-2011 Atsushi Konno All rights reserved.
   3  * Copyright (C) 2005 QSDN,Inc. All rights reserved.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17 #include "mod_chxj.h"
  18 #include "chxj_cookie.h"
  19 #include "chxj_dbm.h"
  20 #include "chxj_url_encode.h"
  21 #include "chxj_apply_convrule.h"
  22 #include "chxj_str_util.h"
  23
  24 #include "ap_release.h"
  25
  26 #include "apu.h"
  27 #include "apr_uuid.h"
  28 #include "apr_md5.h"
  29 #include "apr_base64.h"
  30 #include "apr_uri.h"
  31
  32 #include <unistd.h>
  33
  34 int
  35 chxj_save_cookie_dbm(request_rec *r, mod_chxj_config *m, const char *cookie_id, const char *store_string)
  36 {
  37   apr_status_t        retval;
  38   apr_datum_t         dbmkey;
  39   apr_datum_t         dbmval;
  40   apr_dbm_t           *f;
  41   apr_file_t          *file;
  42
  43   DBG(r, "REQ[%X] start chxj_save_cookie_dbm() cookie_id:[%s]", TO_ADDR(r), cookie_id);
  44
  45   file = chxj_cookie_db_lock(r);
  46   if (! file) {
  47     ERR(r, "%s:%d REQ[%X] mod_chxj: Can't lock cookie db", __FILE__,__LINE__,TO_ADDR(r));
  48     DBG(r, "REQ[%X] end chxj_save_cookie_dbm() cookie_id:[%s]", TO_ADDR(r), cookie_id);
  49     return CHXJ_FALSE;
  50   }
  51
  52   retval = apr_dbm_open_ex(&f,
  53                            (m->cookie_dbm_type) ? m->cookie_dbm_type : "default",
  54                            chxj_cookie_db_name_create(r, m->cookie_db_dir),
  55                            APR_DBM_RWCREATE,
  56                            APR_OS_DEFAULT,
  57                            r->pool);
  58   if (retval != APR_SUCCESS) {
  59     char errstr[256];
  60     ERR(r, "%s:%d could not open dbm (type %s) auth file: %s(%d:%s)",
  61             __FILE__,
  62             __LINE__,
  63             (m->cookie_dbm_type) ? m->cookie_dbm_type : "default",
  64             chxj_cookie_db_name_create(r,m->cookie_db_dir),
  65             retval,
  66             apr_strerror(retval, errstr, 255));
  67     chxj_cookie_db_unlock(r, file);
  68     DBG(r, "REQ[%X] end chxj_save_cookie_dbm() cookie_id:[%s]", TO_ADDR(r), cookie_id);
  69     return CHXJ_FALSE;
  70   }
  71
  72
  73   /*
  74    * create key
  75    */
  76
  77   dbmkey.dptr  = apr_pstrdup(r->pool, cookie_id);
  78   dbmkey.dsize = strlen(cookie_id);
  79   dbmval.dptr  = apr_pstrdup(r->pool, store_string);
  80   dbmval.dsize = strlen(store_string);
  81
  82   /*
  83    * store to db
  84    */
  85   retval = apr_dbm_store(f, dbmkey, dbmval);
  86   if (retval != APR_SUCCESS) {
  87     char errstr[256];
  88     ERR(r, "%s:%d Cannot store Cookie data to DBM file `%s' tye:[%s] (%d:%s) key:[%s] val:[%s]",
  89             __FILE__,
  90             __LINE__,
  91             chxj_cookie_db_name_create(r, m->cookie_db_dir),
  92             (m->cookie_dbm_type) ? m->cookie_dbm_type : "default",
  93             retval,
  94             apr_strerror(retval, errstr, 255),
  95             dbmkey.dptr,
  96             dbmval.dptr);
  97     apr_dbm_close(f);
  98     chxj_cookie_db_unlock(r, file);
  99     DBG(r, "REQ[%X] end chxj_save_cookie_dbm() cookie_id:[%s]", TO_ADDR(r), cookie_id);
 100     return CHXJ_FALSE;
 101   }
 102
 103   apr_dbm_close(f);
 104   chxj_cookie_db_unlock(r, file);
 105   DBG(r, "REQ[%X] end chxj_save_cookie_dbm() cookie_id:[%s]", TO_ADDR(r), cookie_id);
 106   return CHXJ_TRUE;
 107 }
 108
 109
 110 void
 111 chxj_cookie_db_unlock(request_rec *r, apr_file_t *file)
 112 {
 113   apr_status_t rv;
 114
 115   rv = apr_file_unlock(file);
 116   if (rv != APR_SUCCESS) {
 117     ERR(r, "cookie lock file open failed.");
 118     return;
 119   }
 120
 121   apr_file_close(file);
 122 }
 123
 124
 125 apr_file_t *
 126 chxj_cookie_db_lock(request_rec *r)
 127 {
 128   apr_file_t       *file;
 129   apr_status_t     rv;
 130   mod_chxj_config  *dconf;
 131
 132   dconf = (mod_chxj_config*)chxj_get_module_config(r->per_dir_config, &chxj_module);
 133
 134   rv = apr_file_open(&file,
 135                      chxj_cookie_db_lock_name_create(r, dconf->cookie_db_dir),
 136                      APR_CREATE|APR_WRITE,
 137                      APR_OS_DEFAULT,
 138                      r->pool);
 139   if (rv != APR_SUCCESS) {
 140     ERR(r, "cookie lock file open failed.");
 141     return NULL;
 142   }
 143
 144   rv = apr_file_lock(file,APR_FLOCK_EXCLUSIVE);
 145   if (rv != APR_SUCCESS) {
 146     ERR(r, "cookie lock file open failed.");
 147     apr_file_close(file);
 148     return NULL;
 149   }
 150
 151   return file;
 152 }
 153
 154
 155 char *
 156 chxj_cookie_db_name_create(request_rec *r, const char *dir)
 157 {
 158   char *dst;
 159
 160   if (!dir) {
 161     dst = apr_pstrdup(r->pool, DEFAULT_COOKIE_DB_DIR);
 162   }
 163   else {
 164     dst = apr_pstrdup(r->pool, dir);
 165   }
 166
 167   if (dst[strlen(dst)-1] != '/') {
 168     dst = apr_pstrcat(r->pool, dst, "/", COOKIE_DB_NAME, NULL);
 169   }
 170   else {
 171     dst = apr_pstrcat(r->pool, dst, COOKIE_DB_NAME, NULL);
 172   }
 173
 174   return dst;
 175 }
 176
 177
 178 char *
 179 chxj_cookie_db_lock_name_create(request_rec *r, const char *dir)
 180 {
 181   char *dst;
 182   DBG(r, "REQ[%X] start  chxj_cookie_db_lock_name_create()", TO_ADDR(r));
 183
 184   if (!dir) {
 185     dst = apr_pstrdup(r->pool, DEFAULT_COOKIE_DB_DIR);
 186   }
 187   else {
 188     dst = apr_pstrdup(r->pool, dir);
 189   }
 190   if (dst[strlen(dst)-1] != '/') {
 191     dst = apr_pstrcat(r->pool, dst, "/", COOKIE_DB_LOCK_NAME, NULL);
 192   }
 193   else {
 194     dst = apr_pstrcat(r->pool, dst, COOKIE_DB_LOCK_NAME, NULL);
 195   }
 196   DBG(r, "REQ[%X] end  chxj_cookie_db_lock_name_create()", TO_ADDR(r));
 197   return dst;
 198 }
 199
 200
 201
 202 char *
 203 chxj_cookie_expire_db_name_create(request_rec *r, const char *dir)
 204 {
 205   char *dst;
 206
 207   if (!dir) {
 208     dst = apr_pstrdup(r->pool, DEFAULT_COOKIE_DB_DIR);
 209   }
 210   else {
 211     dst = apr_pstrdup(r->pool, dir);
 212   }
 213
 214   if (dst[strlen(dst)-1] != '/') {
 215     dst = apr_pstrcat(r->pool, dst, "/", COOKIE_EXPIRE_DB_NAME, NULL);
 216   }
 217   else {
 218     dst = apr_pstrcat(r->pool, dst, COOKIE_EXPIRE_DB_NAME, NULL);
 219   }
 220
 221   return dst;
 222 }
 223
 224
 225 char *
 226 chxj_cookie_expire_db_lock_name_create(request_rec *r, const char *dir)
 227 {
 228   char *dst;
 229
 230   if (!dir) {
 231     dst = apr_pstrdup(r->pool, DEFAULT_COOKIE_DB_DIR);
 232   }
 233   else {
 234     dst = apr_pstrdup(r->pool, dir);
 235   }
 236   if (dst[strlen(dst)-1] != '/') {
 237     dst = apr_pstrcat(r->pool, dst, "/", COOKIE_EXPIRE_DB_LOCK_NAME, NULL);
 238   }
 239   else {
 240     dst = apr_pstrcat(r->pool, dst, COOKIE_EXPIRE_DB_LOCK_NAME, NULL);
 241   }
 242
 243   return dst;
 244 }
 245
 246
 247 apr_file_t *
 248 chxj_cookie_expire_db_lock(request_rec *r)
 249 {
 250   apr_file_t       *file;
 251   apr_status_t     rv;
 252   mod_chxj_config  *dconf;
 253
 254   dconf = (mod_chxj_config *)chxj_get_module_config(r->per_dir_config, &chxj_module);
 255
 256   rv = apr_file_open(&file,
 257                      chxj_cookie_expire_db_lock_name_create(r, dconf->cookie_db_dir),
 258                      APR_CREATE|APR_WRITE,
 259                      APR_OS_DEFAULT,
 260                      r->pool);
 261   if (rv != APR_SUCCESS) {
 262     ERR(r, "cookie lock file open failed.");
 263     return NULL;
 264   }
 265
 266   rv = apr_file_lock(file,APR_FLOCK_EXCLUSIVE);
 267   if (rv != APR_SUCCESS) {
 268     ERR(r, "cookie lock file open failed.");
 269     apr_file_close(file);
 270     return NULL;
 271   }
 272
 273   return file;
 274 }
 275
 276
 277 void
 278 chxj_cookie_expire_db_unlock(request_rec *r, apr_file_t *file)
 279 {
 280   apr_status_t rv;
 281
 282   rv = apr_file_unlock(file);
 283   if (rv != APR_SUCCESS) {
 284     ERR(r, "cookie lock file open failed.");
 285     return;
 286   }
 287
 288   apr_file_close(file);
 289 }
 290
 291 int
 292 chxj_update_cookie_dbm(request_rec *r, mod_chxj_config *m, const char *cookie_id, const char *store_string)
 293 {
 294   apr_dbm_t           *f;
 295   apr_file_t          *file;
 296   apr_datum_t         dbmkey;
 297   apr_datum_t         dbmval;
 298   apr_status_t        retval;
 299
 300   DBG(r, "start chxj_update_cookie_dbm() cookie_id:[%s]", cookie_id);
 301
 302   file = chxj_cookie_db_lock(r);
 303   if (! file) {
 304     ERR(r, "mod_chxj: Can't lock cookie db");
 305     DBG(r, "end   chxj_update_cookie_dbm() cookie_id:[%s]", cookie_id);
 306     return CHXJ_FALSE;
 307   }
 308
 309   retval = apr_dbm_open_ex(&f,
 310                            (m->cookie_dbm_type) ? m->cookie_dbm_type : "default",
 311                            chxj_cookie_db_name_create(r, m->cookie_db_dir),
 312                            APR_DBM_RWCREATE,
 313                            APR_OS_DEFAULT,
 314                            r->pool);
 315   if (retval != APR_SUCCESS) {
 316     ERR(r, "could not open dbm (type %s) auth file: %s",
 317             (m->cookie_dbm_type) ? m->cookie_dbm_type : "default",
 318             chxj_cookie_db_name_create(r,m->cookie_db_dir));
 319     chxj_cookie_db_unlock(r, file);
 320     DBG(r, "end   chxj_update_cookie_dbm() cookie_id:[%s]", cookie_id);
 321     return CHXJ_FALSE;
 322   }
 323
 324
 325   /*
 326    * create key
 327    */
 328
 329   dbmkey.dptr  = apr_pstrdup(r->pool, cookie_id);
 330   dbmkey.dsize = strlen(cookie_id);
 331
 332   /*
 333    * create val
 334    */
 335   dbmval.dptr  = apr_pstrdup(r->pool, store_string);
 336   dbmval.dsize = strlen(store_string);
 337
 338   /*
 339    * store to db
 340    */
 341   retval = apr_dbm_store(f, dbmkey, dbmval);
 342   if (retval != APR_SUCCESS) {
 343     char errstr[256];
 344     ERR(r, "%s:%d Cannot store Cookie data to DBM file `%s' tye:[%s] (%d:%s) key:[%s] val:[%s]",
 345             __FILE__,
 346             __LINE__,
 347             chxj_cookie_db_name_create(r, m->cookie_db_dir),
 348             (m->cookie_dbm_type) ? m->cookie_dbm_type : "default",
 349             retval,
 350             apr_strerror(retval, errstr, 255),
 351             dbmkey.dptr,
 352             dbmval.dptr);
 353     apr_dbm_close(f);
 354     chxj_cookie_db_unlock(r, file);
 355     DBG(r, "end   chxj_update_cookie_dbm() cookie_id:[%s]", cookie_id);
 356     return CHXJ_FALSE;
 357   }
 358   apr_dbm_close(f);
 359   chxj_cookie_db_unlock(r, file);
 360   DBG(r, "end   chxj_update_cookie_dbm() cookie_id:[%s]", cookie_id);
 361   return CHXJ_TRUE;
 362 }
 363
 364
 365 char *
 366 chxj_load_cookie_dbm(request_rec *r, mod_chxj_config *m, const char *cookie_id)
 367 {
 368   char                    *load_string = NULL;
 369   apr_status_t            retval;
 370   apr_dbm_t               *f;
 371   apr_file_t              *file;
 372   apr_datum_t             dbmval;
 373   apr_datum_t             dbmkey;
 374
 375   DBG(r, "REQ[%X] start chxj_load_cookie_dbm() cookie_id:[%s]", TO_ADDR(r), cookie_id);
 376   file = chxj_cookie_db_lock(r);
 377   if (! file) {
 378     ERR(r, "REQ[%X] mod_chxj: Can't lock cookie db", TO_ADDR(r));
 379     DBG(r, "REQ[%X] end   chxj_load_cookie_dbm() cookie_id:[%s]", TO_ADDR(r), cookie_id);
 380     return NULL;
 381   }
 382
 383   retval = apr_dbm_open_ex(&f,
 384                            (m->cookie_dbm_type) ? m->cookie_dbm_type : "default",
 385                            chxj_cookie_db_name_create(r, m->cookie_db_dir),
 386                            APR_DBM_RWCREATE,
 387                            APR_OS_DEFAULT,
 388                            r->pool);
 389   if (retval != APR_SUCCESS) {
 390     char errstr[256];
 391     ERR(r,
 392          "%s:%d could not open dbm (type %s) auth file: %s (%d:%s)",
 393          __FILE__,
 394          __LINE__,
 395           (m->cookie_dbm_type) ? m->cookie_dbm_type : "default",
 396          chxj_cookie_db_name_create(r, m->cookie_db_dir),
 397          retval,
 398          apr_strerror(retval, errstr, 255));
 399     chxj_cookie_db_unlock(r, file);
 400     DBG(r, "TO_REQ[%X] end   chxj_load_cookie_dbm() cookie_id:[%s]", TO_ADDR(r), cookie_id);
 401     return NULL;
 402   }
 403
 404   /*
 405    * create key
 406    */
 407   dbmkey.dptr  = apr_pstrdup(r->pool, cookie_id);
 408   dbmkey.dsize = strlen(dbmkey.dptr);
 409
 410   if (apr_dbm_exists(f, dbmkey)) {
 411     retval = apr_dbm_fetch(f, dbmkey, &dbmval);
 412     if (retval != APR_SUCCESS) {
 413       char errstr[256];
 414       ERR(r,
 415           "%s:%d could not fetch dbm (type %s) auth file: %s(%d:%s)",
 416           __FILE__,
 417           __LINE__,
 418           (m->cookie_dbm_type) ? m->cookie_dbm_type : "default",
 419           chxj_cookie_db_name_create(r, m->cookie_db_dir),
 420           retval,
 421           apr_strerror(retval, errstr, 255));
 422       apr_dbm_close(f);
 423       chxj_cookie_db_unlock(r, file);
 424       DBG(r, "REQ[%X] end   chxj_load_cookie_dbm() cookie_id:[%s]", TO_ADDR(r), cookie_id);
 425       return NULL;
 426     }
 427     load_string = apr_palloc(r->pool, dbmval.dsize+1);
 428
 429     memset(load_string, 0, dbmval.dsize+1);
 430     memcpy(load_string, dbmval.dptr, dbmval.dsize);
 431   }
 432   else {
 433     DBG(r, "REQ[%X] Not Found cookie_id:[%s]", TO_ADDR(r), cookie_id);
 434     load_string = apr_pstrdup(r->pool, "");
 435   }
 436   apr_dbm_close(f);
 437   chxj_cookie_db_unlock(r, file);
 438   DBG(r, "REQ[%X] end   chxj_load_cookie_dbm() cookie_id:[%s]", TO_ADDR(r), cookie_id);
 439   return load_string;
 440 }
 441
 442
 443 int
 444 chxj_delete_cookie_dbm(request_rec *r, mod_chxj_config *m, const char *cookie_id)
 445 {
 446   apr_status_t      retval;
 447   apr_file_t        *file;
 448   apr_datum_t       dbmkey;
 449   apr_dbm_t         *f;
 450
 451   DBG(r, "start chxj_delete_cookie_dbm() cookie_id:[%s]", cookie_id);
 452   file = chxj_cookie_db_lock(r);
 453   if (! file) {
 454     ERR(r, "mod_chxj: Can't lock cookie db");
 455     DBG(r, "end   chxj_delete_cookie_dbm() cookie_id:[%s]", cookie_id);
 456     return CHXJ_FALSE;
 457   }
 458
 459   retval = apr_dbm_open_ex(&f,
 460                            (m->cookie_dbm_type) ? m->cookie_dbm_type : "default",
 461                            chxj_cookie_db_name_create(r, m->cookie_db_dir),
 462                            APR_DBM_RWCREATE,
 463                            APR_OS_DEFAULT,
 464                            r->pool);
 465   if (retval != APR_SUCCESS) {
 466     ERR(r,
 467          "could not open dbm (type %s) auth file: %s",
 468          (m->cookie_dbm_type) ? m->cookie_dbm_type : "default",
 469          chxj_cookie_db_name_create(r,m->cookie_db_dir));
 470     chxj_cookie_db_unlock(r, file);
 471     DBG(r, "end   chxj_delete_cookie_dbm() cookie_id:[%s]", cookie_id);
 472     return CHXJ_FALSE;
 473   }
 474
 475   /*
 476    * create key
 477    */
 478   dbmkey.dptr  = apr_pstrdup(r->pool, cookie_id);
 479   dbmkey.dsize = strlen(dbmkey.dptr);
 480   if (apr_dbm_exists(f, dbmkey)) {
 481     apr_dbm_delete(f, dbmkey);
 482   }
 483   apr_dbm_close(f);
 484   chxj_cookie_db_unlock(r, file);
 485   DBG(r, "end   chxj_delete_cookie_dbm() cookie_id:[%s]", cookie_id);
 486   return CHXJ_TRUE;
 487 }
 488
 489
 490 int
 491 chxj_save_cookie_expire_dbm(request_rec *r, mod_chxj_config *m, const char *cookie_id)
 492 {
 493   apr_status_t            retval;
 494   char                    *store_string;
 495   apr_file_t              *file;
 496   apr_datum_t             dbmkey;
 497   apr_datum_t             dbmval;
 498   apr_dbm_t               *f;
 499
 500   DBG(r, "start chxj_save_cookie_expire_dbm() cookie_id:[%s]", cookie_id);
 501   file = chxj_cookie_expire_db_lock(r);
 502   if (! file) {
 503     ERR(r, "mod_chxj: Can't lock cookie db");
 504     DBG(r, "end   chxj_save_cookie_expire_dbm() cookie_id:[%s]", cookie_id);
 505     return CHXJ_FALSE;
 506   }
 507
 508   retval = apr_dbm_open_ex(&f,
 509                            (m->cookie_dbm_type) ? m->cookie_dbm_type : "default",
 510                            chxj_cookie_expire_db_name_create(r, m->cookie_db_dir),
 511                            APR_DBM_RWCREATE,
 512                            APR_OS_DEFAULT,
 513                            r->pool);
 514   if (retval != APR_SUCCESS) {
 515     ERR(r, "could not open dbm (type %s) auth file: %s",
 516             (m->cookie_dbm_type) ? m->cookie_dbm_type : "default",
 517             chxj_cookie_expire_db_name_create(r,m->cookie_db_dir));
 518     chxj_cookie_expire_db_unlock(r, file);
 519     DBG(r, "end   chxj_save_cookie_expire_dbm() cookie_id:[%s]", cookie_id);
 520     return CHXJ_FALSE;
 521   }
 522   /*
 523    * create key
 524    */
 525
 526   dbmkey.dptr  = apr_pstrdup(r->pool, cookie_id);
 527   dbmkey.dsize = strlen(cookie_id);
 528
 529   /*
 530    * create val
 531    */
 532
 533   store_string = apr_psprintf(r->pool, "%d", (int)time(NULL));
 534   dbmval.dptr  = store_string;
 535   dbmval.dsize = strlen(store_string);
 536
 537   /*
 538    * store to db
 539    */
 540   retval = apr_dbm_store(f, dbmkey, dbmval);
 541   if (retval != APR_SUCCESS) {
 542     ERR(r, "Cannot store Cookie data to DBM file `%s'",
 543             chxj_cookie_db_name_create(r, m->cookie_db_dir));
 544     DBG(r, "end   chxj_save_cookie_expire_dbm() cookie_id:[%s]", cookie_id);
 545     apr_dbm_close(f);
 546     chxj_cookie_expire_db_unlock(r, file);
 547     return CHXJ_FALSE;
 548   }
 549
 550
 551   apr_dbm_close(f);
 552   chxj_cookie_expire_db_unlock(r, file);
 553   DBG(r, "end   chxj_save_cookie_expire_dbm() cookie_id:[%s]", cookie_id);
 554
 555   return CHXJ_TRUE;
 556 }
 557
 558
 559 int
 560 chxj_delete_cookie_expire_dbm(request_rec *r, mod_chxj_config *m, const char *cookie_id)
 561 {
 562   apr_status_t      retval;
 563   apr_datum_t       dbmkey;
 564   apr_dbm_t         *f;
 565   apr_file_t        *file;
 566
 567   DBG(r, "start chxj_delete_cookie_expire_dbm() cookie_id:[%s]", cookie_id);
 568   file = chxj_cookie_expire_db_lock(r);
 569   if (! file) {
 570     ERR(r, "mod_chxj: Can't lock cookie db");
 571     DBG(r, "end   chxj_delete_cookie_expire_dbm() cookie_id:[%s]", cookie_id);
 572     return CHXJ_FALSE;
 573   }
 574   retval = apr_dbm_open_ex(&f,
 575                            (m->cookie_dbm_type) ? m->cookie_dbm_type : "default",
 576                            chxj_cookie_expire_db_name_create(r, m->cookie_db_dir),
 577                            APR_DBM_RWCREATE,
 578                            APR_OS_DEFAULT,
 579                            r->pool);
 580   if (retval != APR_SUCCESS) {
 581     ERR(r,
 582          "could not open dbm (type %s) auth file: %s",
 583          (m->cookie_dbm_type) ? m->cookie_dbm_type : "default",
 584          chxj_cookie_expire_db_name_create(r,m->cookie_db_dir));
 585     chxj_cookie_expire_db_unlock(r, file);
 586     DBG(r, "end   chxj_delete_cookie_expire_dbm() cookie_id:[%s]", cookie_id);
 587     return CHXJ_FALSE;
 588   }
 589
 590   /*
 591  *    * create key
 592  *       */
 593   dbmkey.dptr  = apr_pstrdup(r->pool, cookie_id);
 594   dbmkey.dsize = strlen(dbmkey.dptr);
 595   if (apr_dbm_exists(f, dbmkey)) {
 596     apr_dbm_delete(f, dbmkey);
 597   }
 598   apr_dbm_close(f);
 599   chxj_cookie_expire_db_unlock(r, file);
 600   DBG(r, "end   chxj_delete_cookie_expire_dbm() cookie_id:[%s]", cookie_id);
 601
 602   return CHXJ_TRUE;
 603 }
 604
 605
 606 int
 607 chxj_cookie_expire_gc_dbm(request_rec *r, mod_chxj_config *m)
 608 {
 609   apr_status_t      retval;
 610   apr_datum_t       dbmkey;
 611   apr_datum_t       dbmval;
 612   apr_dbm_t         *f;
 613   apr_file_t        *file;
 614   time_t            now_time;
 615
 616   DBG(r, "start chxj_cookie_expire_gc_dbm()");
 617
 618   file = chxj_cookie_expire_db_lock(r);
 619   if (! file) {
 620     ERR(r, "mod_chxj: Can't lock cookie db");
 621     DBG(r, "end   chxj_cookie_expire_gc_dbm()");
 622     return CHXJ_FALSE;
 623   }
 624
 625   retval = apr_dbm_open_ex(&f,
 626                            (m->cookie_dbm_type) ? m->cookie_dbm_type : "default",
 627                            chxj_cookie_expire_db_name_create(r, m->cookie_db_dir),
 628                            APR_DBM_RWCREATE,
 629                            APR_OS_DEFAULT,
 630                            r->pool);
 631   if (retval != APR_SUCCESS) {
 632     ERR(r,
 633          "could not open dbm (type %s) auth file: %s",
 634          (m->cookie_dbm_type) ? m->cookie_dbm_type : "default",
 635          chxj_cookie_expire_db_name_create(r,m->cookie_db_dir));
 636     chxj_cookie_expire_db_unlock(r, file);
 637     DBG(r, "end   chxj_cookie_expire_gc_dbm()");
 638     return CHXJ_FALSE;
 639   }
 640
 641   /*
 642    * create key
 643    */
 644   memset(&dbmkey, 0, sizeof(apr_datum_t));
 645
 646   now_time = time(NULL);
 647
 648   retval = apr_dbm_firstkey(f, &dbmkey);
 649   if (retval == APR_SUCCESS) {
 650     DBG(r, "firstkey=[%.*s]", (int)dbmkey.dsize, dbmkey.dptr);
 651     do {
 652       char* tmp;
 653       char* old_cookie_id;
 654       int   val_time;
 655       int   cmp_time;
 656
 657       retval = apr_dbm_fetch(f, dbmkey, &dbmval);
 658       if (retval != APR_SUCCESS) {
 659         break;
 660       }
 661       tmp = apr_palloc(r->pool, dbmval.dsize+1);
 662       memset(tmp, 0, dbmval.dsize+1);
 663       memcpy(tmp, dbmval.dptr, dbmval.dsize);
 664
 665
 666       val_time = atoi(tmp);
 667
 668       if (m->cookie_timeout == 0)
 669         cmp_time = now_time - DEFAULT_COOKIE_TIMEOUT;
 670       else
 671         cmp_time = now_time - m->cookie_timeout;
 672
 673       DBG(r, "m->cookie_timeout=[%d]", (int)m->cookie_timeout);
 674       DBG(r, "key=[%.*s] cmp_time=[%d] val_time=[%d]", (int)dbmkey.dsize, dbmkey.dptr, cmp_time, val_time);
 675       if (cmp_time >= val_time) {
 676         apr_dbm_delete(f, dbmkey);
 677
 678         old_cookie_id = apr_palloc(r->pool, dbmkey.dsize+1);
 679         memset(old_cookie_id, 0, dbmkey.dsize+1);
 680         memcpy(old_cookie_id, dbmkey.dptr, dbmkey.dsize);
 681
 682         chxj_delete_cookie(r,old_cookie_id);
 683         DBG(r, "detect timeout cookie [%s]", old_cookie_id);
 684       }
 685
 686       retval = apr_dbm_nextkey(f, &dbmkey);
 687     } while(retval == APR_SUCCESS && dbmkey.dptr != NULL);
 688   }
 689
 690   apr_dbm_close(f);
 691   chxj_cookie_expire_db_unlock(r, file);
 692   DBG(r, "end   chxj_cookie_expire_gc_dbm()");
 693   return CHXJ_TRUE;
 694 }
 695
 696
 697 cookie_lock_t *
 698 chxj_cookie_lock_dbm(request_rec *r, mod_chxj_config *UNUSED(m))
 699 {
 700   cookie_lock_t *ret = apr_palloc(r->pool, sizeof(*ret));
 701   ret->file = chxj_cookie_db_lock(r);
 702   return ret;
 703 }
 704
 705
 706 int
 707 chxj_cookie_unlock_dbm(request_rec *r, cookie_lock_t *lock, mod_chxj_config *UNUSED(m))
 708 {
 709   chxj_cookie_expire_db_unlock(r, lock->file);
 710   return 1; /* allways true */
 711 }
 712 /*
 713  * vim:ts=2 et
 714  */