server/replay_cache.c

   1 /*
   2  *****************************************************************************
   3  *
   4  * File:    replay_cache.c
   5  *
   6  * Author:  Damien S. Stuart
   7  *
   8  * Purpose: Provides the functions to check for possible replay attacks
   9  *          by using a cache of previously seen digests.  This cache is a
  10  *          simple file by default, but can be made to use a dbm solution
  11  *          (ndbm or gdbm in ndbm compatibility mode) file to store the digest
  12  *          of a previously received SPA packets.
  13  *
  14  * Copyright 2010 Damien Stuart (dstuart@dstuart.org)
  15  *
  16  *  License (GNU Public License):
  17  *
  18  *  This program is free software; you can redistribute it and/or
  19  *  modify it under the terms of the GNU General Public License
  20  *  as published by the Free Software Foundation; either version 2
  21  *  of the License, or (at your option) any later version.
  22  *
  23  *  This program is distributed in the hope that it will be useful,
  24  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  25  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  26  *  GNU General Public License for more details.
  27  *
  28  *  You should have received a copy of the GNU General Public License
  29  *  along with this program; if not, write to the Free Software
  30  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
  31  *  USA
  32  *
  33  *****************************************************************************
  34 */
  35 #include "replay_cache.h"
  36 #include "log_msg.h"
  37 #include "fwknopd_errors.h"
  38 #include "utils.h"
  39
  40 #include <time.h>
  41
  42 #if HAVE_LIBGDBM
  43   #include <gdbm.h>
  44
  45   #define MY_DBM_FETCH(d, k)        gdbm_fetch(d, k)
  46   #define MY_DBM_STORE(d, k, v, m)  gdbm_store(d, k, v, m)
  47   #define MY_DBM_STRERROR(x)        gdbm_strerror(x)
  48   #define MY_DBM_CLOSE(d)           gdbm_close(d)
  49
  50   #define MY_DBM_REPLACE            GDBM_REPLACE
  51   #define MY_DBM_INSERT             GDBM_INSERT
  52
  53 #elif HAVE_LIBNDBM
  54   #include <ndbm.h>
  55
  56   #define MY_DBM_FETCH(d, k)        dbm_fetch(d, k)
  57   #define MY_DBM_STORE(d, k, v, m)  dbm_store(d, k, v, m)
  58   #define MY_DBM_STRERROR(x)        strerror(x)
  59   #define MY_DBM_CLOSE(d)           dbm_close(d)
  60
  61   #define MY_DBM_REPLACE            DBM_REPLACE
  62   #define MY_DBM_INSERT             DBM_INSERT
  63
  64 #else
  65   #if ! USE_FILE_CACHE
  66     #error "File cache method disabled, and No GDBM or NDBM header file found. WTF?"
  67   #endif
  68 #endif
  69
  70 #if HAVE_SYS_SOCKET_H
  71   #include <sys/socket.h>
  72 #endif
  73 #include <arpa/inet.h>
  74
  75 #include <fcntl.h>
  76
  77 #define DATE_LEN 18
  78 #define MAX_DIGEST_SIZE 64
  79
  80 static int
  81 get_raw_digest(char **digest, char *pkt_data)
  82 {
  83     fko_ctx_t    ctx = NULL;
  84     char        *tmp_digest = NULL;
  85     int          res = FKO_SUCCESS;
  86
  87     /* initialize an FKO context with no decryption key just so
  88      * we can get the outer message digest
  89     */
  90     res = fko_new_with_data(&ctx, (char *)pkt_data, NULL);
  91     if(res != FKO_SUCCESS)
  92     {
  93         log_msg(LOG_WARNING, "Error initializing FKO context from SPA data: %s",
  94             fko_errstr(res));
  95         fko_destroy(ctx);
  96         return(SPA_MSG_FKO_CTX_ERROR);
  97     }
  98
  99     res = fko_set_raw_spa_digest_type(ctx, FKO_DEFAULT_DIGEST);
 100     if(res != FKO_SUCCESS)
 101     {
 102         log_msg(LOG_WARNING, "Error setting digest type for SPA data: %s",
 103             fko_errstr(res));
 104         fko_destroy(ctx);
 105         return(SPA_MSG_DIGEST_ERROR);
 106     }
 107
 108     res = fko_set_raw_spa_digest(ctx);
 109     if(res != FKO_SUCCESS)
 110     {
 111         log_msg(LOG_WARNING, "Error setting digest for SPA data: %s",
 112             fko_errstr(res));
 113         fko_destroy(ctx);
 114         return(SPA_MSG_DIGEST_ERROR);
 115     }
 116
 117     res = fko_get_raw_spa_digest(ctx, &tmp_digest);
 118     if(res != FKO_SUCCESS)
 119     {
 120         log_msg(LOG_WARNING, "Error getting digest from SPA data: %s",
 121             fko_errstr(res));
 122         fko_destroy(ctx);
 123         return(SPA_MSG_DIGEST_ERROR);
 124     }
 125
 126     *digest = strdup(tmp_digest);
 127
 128     if (digest == NULL)
 129         return SPA_MSG_ERROR;
 130
 131     fko_destroy(ctx);
 132     return res;
 133 }
 134
 135 /* Rotate the digest file by simply renaming it.
 136 */
 137 static void
 138 rotate_digest_cache_file(fko_srv_options_t *opts)
 139 {
 140 #ifdef NO_DIGEST_CACHE
 141     log_msg(LOG_WARNING, "Digest cache not supported. Nothing to rotate.");
 142 #else
 143     int         res;
 144     char       *new_file = NULL;
 145
 146     log_msg(LOG_INFO, "Rotating digest cache file.");
 147
 148 #if USE_FILE_CACHE
 149     new_file = malloc(strlen(opts->config[CONF_DIGEST_FILE])+5);
 150 #else
 151     new_file = malloc(strlen(opts->config[CONF_DIGEST_DB_FILE])+5);
 152 #endif
 153
 154     if(new_file == NULL)
 155     {
 156         log_msg(LOG_ERR, "rotate_digest_cache_file: Memory allocation error.");
 157         clean_exit(opts, NO_FW_CLEANUP, EXIT_FAILURE);
 158     }
 159
 160     /* The new filename is just the original with a trailing '-old'.
 161     */
 162 #if USE_FILE_CACHE
 163     strlcpy(new_file, opts->config[CONF_DIGEST_FILE],
 164         strlen(opts->config[CONF_DIGEST_FILE])+5);
 165 #else
 166     strlcpy(new_file, opts->config[CONF_DIGEST_DB_FILE],
 167         strlen(opts->config[CONF_DIGEST_DB_FILE])+5);
 168 #endif
 169     strcat(new_file, "-old");
 170
 171 #if USE_FILE_CACHE
 172     res = rename(opts->config[CONF_DIGEST_FILE], new_file);
 173 #else
 174     res = rename(opts->config[CONF_DIGEST_DB_FILE], new_file);
 175 #endif
 176
 177     if(res < 0)
 178         log_msg(LOG_ERR, "Unable to rename digest file: %s to %s: %s",
 179 #if USE_FILE_CACHE
 180             opts->config[CONF_DIGEST_FILE], new_file, strerror(errno)
 181 #else
 182             opts->config[CONF_DIGEST_DB_FILE], new_file, strerror(errno)
 183 #endif
 184         );
 185 #endif /* NO_DIGEST_CACHE */
 186 }
 187
 188 static void
 189 replay_warning(fko_srv_options_t *opts, digest_cache_info_t *digest_info)
 190 {
 191     char        src_ip[INET_ADDRSTRLEN+1] = {0};
 192     char        orig_src_ip[INET_ADDRSTRLEN+1] = {0};
 193     char        created[DATE_LEN];
 194
 195 #if ! USE_FILE_CACHE
 196     char        last_ip[INET_ADDRSTRLEN+1] = {0};
 197     char        first[DATE_LEN], last[DATE_LEN];
 198 #endif
 199
 200     /* Convert the IPs to a human readable form
 201     */
 202     inet_ntop(AF_INET, &(opts->spa_pkt.packet_src_ip),
 203         src_ip, INET_ADDRSTRLEN);
 204     inet_ntop(AF_INET, &(digest_info->src_ip), orig_src_ip, INET_ADDRSTRLEN);
 205
 206 #if ! USE_FILE_CACHE
 207     /* Mark the last_replay time.
 208     */
 209     digest_info->last_replay = time(NULL);
 210
 211     /* Increment the replay count and check to see if it is the first one.
 212     */
 213     if(++(digest_info->replay_count) == 1)
 214     {
 215         /* This is the first replay so make it the same as last_replay
 216         */
 217         digest_info->first_replay = digest_info->last_replay;
 218     }
 219
 220     strftime(first, DATE_LEN, "%D %H:%M:%S", localtime(&(digest_info->first_replay)));
 221     strftime(last, DATE_LEN, "%D %H:%M:%S", localtime(&(digest_info->last_replay)));
 222 #endif
 223
 224     strftime(created, DATE_LEN, "%D %H:%M:%S", localtime(&(digest_info->created)));
 225
 226     log_msg(LOG_WARNING,
 227         "Replay detected from source IP: %s\n"
 228         "        Destination proto/port: %d/%d\n"
 229         "            Original source IP: %s\n"
 230         "       Original dst proto/port: %d/%d\n"
 231 #if USE_FILE_CACHE
 232         "                 Entry created: %s\n",
 233 #else
 234         "                 Entry created: %s\n"
 235         "                  First replay: %s\n"
 236         "                   Last replay: %s\n"
 237         "                  Replay count: %i\n",
 238 #endif
 239         src_ip,
 240         opts->spa_pkt.packet_proto,
 241         opts->spa_pkt.packet_dst_port,
 242         orig_src_ip,
 243         digest_info->proto,
 244         digest_info->dst_port,
 245 #if USE_FILE_CACHE
 246         created
 247 #else
 248         created,
 249         first,
 250         last,
 251         digest_info->replay_count
 252 #endif
 253     );
 254
 255     return;
 256 }
 257
 258 int
 259 replay_cache_init(fko_srv_options_t *opts)
 260 {
 261 #ifdef NO_DIGEST_CACHE
 262     return(-1);
 263 #else
 264
 265     /* If rotation was specified, do it.
 266     */
 267     if(opts->rotate_digest_cache)
 268         rotate_digest_cache_file(opts);
 269
 270 #if USE_FILE_CACHE
 271     return replay_file_cache_init(opts);
 272 #else
 273     return replay_db_cache_init(opts);
 274 #endif
 275
 276 #endif /* NO_DIGEST_CACHE */
 277 }
 278
 279 #if USE_FILE_CACHE
 280 int
 281 replay_file_cache_init(fko_srv_options_t *opts)
 282 {
 283     FILE           *digest_file_ptr = NULL;
 284     unsigned int    num_lines = 0, digest_ctr = 0;
 285     char            line_buf[MAX_LINE_LEN] = {0};
 286     char            src_ip[INET_ADDRSTRLEN+1] = {0};
 287     char            dst_ip[INET_ADDRSTRLEN+1] = {0};
 288     long int        time_tmp;
 289
 290     struct digest_cache_list *digest_elm = NULL;
 291
 292     /* if the file exists, import the previous SPA digests into
 293      * the cache list
 294     */
 295     if (access(opts->config[CONF_DIGEST_FILE], F_OK) == 0)
 296     {
 297         /* Check permissions
 298         */
 299         if (access(opts->config[CONF_DIGEST_FILE], R_OK|W_OK) != 0)
 300         {
 301             log_msg(LOG_WARNING, "Digest file '%s' exists but: '%s'",
 302                 opts->config[CONF_DIGEST_FILE], strerror(errno));
 303             return(-1);
 304         }
 305     }
 306     else
 307     {
 308         /* the file does not exist yet, so it will be created when the first
 309          * successful SPA packet digest is written to disk
 310         */
 311         if ((digest_file_ptr = fopen(opts->config[CONF_DIGEST_FILE], "w")) == NULL)
 312         {
 313             log_msg(LOG_WARNING, "Could not open digest cache: %s",
 314                 opts->config[CONF_DIGEST_FILE]);
 315         }
 316         fprintf(digest_file_ptr,
 317             "# <digest> <proto> <src_ip> <src_port> <dst_ip> <dst_port> <time>\n");
 318         fclose(digest_file_ptr);
 319         return(0);
 320     }
 321
 322     /* File exist, and we have access - create in-memory digest cache
 323     */
 324     if ((digest_file_ptr = fopen(opts->config[CONF_DIGEST_FILE], "r")) == NULL)
 325     {
 326         log_msg(LOG_WARNING, "Could not open digest cache: %s",
 327             opts->config[CONF_DIGEST_FILE]);
 328         return(-1);
 329     }
 330
 331     /* Line format:
 332      * <digest> <proto> <src_ip> <src_port> <dst_ip> <dst_port> <time>
 333      * Example:
 334      * 7XgadOyqv0tF5xG8uhg2iIrheeNKglCWKmxQDgYP1dY 17 127.0.0.1 40305 127.0.0.1 62201 1313283481
 335     */
 336     while ((fgets(line_buf, MAX_LINE_LEN, digest_file_ptr)) != NULL)
 337     {
 338         num_lines++;
 339         line_buf[MAX_LINE_LEN-1] = '\0';
 340
 341         if(IS_EMPTY_LINE(line_buf[0]))
 342             continue;
 343
 344         /* Initialize a digest cache list element, and add it into the list if
 345          * valid.
 346         */
 347         if ((digest_elm = calloc(1, sizeof(struct digest_cache_list))) == NULL)
 348         {
 349             fprintf(stderr, "Could not allocate digest list element\n");
 350             continue;
 351         }
 352         if ((digest_elm->cache_info.digest = calloc(1, MAX_DIGEST_SIZE+1)) == NULL)
 353         {
 354             free(digest_elm);
 355             fprintf(stderr, "Could not allocate digest string\n");
 356             continue;
 357         }
 358         src_ip[0] = '\0';
 359         dst_ip[0] = '\0';
 360
 361         if(sscanf(line_buf, "%s %hhu %s %hu %s %hu %ld",
 362             digest_elm->cache_info.digest,
 363             &(digest_elm->cache_info.proto),
 364             src_ip,
 365             &(digest_elm->cache_info.src_port),
 366             dst_ip,
 367             &(digest_elm->cache_info.dst_port),
 368             &time_tmp) != 7)
 369         {
 370             if(opts->verbose)
 371                 fprintf(stderr,
 372                     "*Skipping invalid digest file entry in %s at line %i.\n - %s",
 373                     opts->config[CONF_DIGEST_FILE], num_lines, line_buf
 374                 );
 375             free(digest_elm->cache_info.digest);
 376             free(digest_elm);
 377             continue;
 378         }
 379         digest_elm->cache_info.created = time_tmp;
 380
 381
 382         if (inet_pton(AF_INET, src_ip, &(digest_elm->cache_info.src_ip)) != 1)
 383         {
 384             free(digest_elm->cache_info.digest);
 385             free(digest_elm);
 386             continue;
 387         }
 388
 389         if (inet_pton(AF_INET, dst_ip, &(digest_elm->cache_info.dst_ip)) != 1)
 390         {
 391             free(digest_elm->cache_info.digest);
 392             free(digest_elm);
 393             continue;
 394         }
 395
 396         digest_elm->next   = opts->digest_cache;
 397         opts->digest_cache = digest_elm;
 398         digest_ctr++;
 399
 400         if(opts->verbose > 3)
 401             fprintf(stderr,
 402                 "DIGEST FILE: %s, VALID LINE: %s",
 403                 opts->config[CONF_DIGEST_FILE], line_buf
 404             );
 405
 406     }
 407
 408     fclose(digest_file_ptr);
 409
 410     return(digest_ctr);
 411 }
 412
 413 #else /* USE_FILE_CACHE */
 414
 415 /* Check for the existence of the replay dbm file, and create it if it does
 416  * not exist.  Returns the number of db entries or -1 on error.
 417 */
 418 int
 419 replay_db_cache_init(fko_srv_options_t *opts)
 420 {
 421 #ifdef NO_DIGEST_CACHE
 422     return(-1);
 423 #else
 424
 425 #ifdef HAVE_LIBGDBM
 426     GDBM_FILE   rpdb;
 427 #elif HAVE_LIBNDBM
 428     DBM        *rpdb;
 429 #endif
 430
 431     datum       db_key, db_ent, db_next_key;
 432     int         db_count = 0;
 433
 434 #ifdef HAVE_LIBGDBM
 435     rpdb = gdbm_open(
 436         opts->config[CONF_DIGEST_DB_FILE], 512, GDBM_WRCREAT, S_IRUSR|S_IWUSR, 0
 437     );
 438 #elif HAVE_LIBNDBM
 439     rpdb = dbm_open(
 440         opts->config[CONF_DIGEST_DB_FILE], O_RDWR|O_CREAT, S_IRUSR|S_IWUSR
 441     );
 442 #endif
 443
 444     if(!rpdb)
 445     {
 446         log_msg(LOG_ERR,
 447             "Unable to open digest cache file: '%s': %s",
 448             opts->config[CONF_DIGEST_DB_FILE],
 449             MY_DBM_STRERROR(errno)
 450         );
 451
 452         return(-1);
 453     }
 454
 455 #ifdef HAVE_LIBGDBM
 456     db_key = gdbm_firstkey(rpdb);
 457
 458     while (db_key.dptr != NULL)
 459     {
 460         db_count++;
 461         db_next_key = gdbm_nextkey(rpdb, db_key);
 462         free(db_key.dptr);
 463         db_key = db_next_key;
 464     }
 465 #elif HAVE_LIBNDBM
 466     for (db_key = dbm_firstkey(rpdb); db_ent.dptr != NULL; db_key = dbm_nextkey(rpdb))
 467         db_count++;
 468 #endif
 469
 470     MY_DBM_CLOSE(rpdb);
 471
 472     return(db_count);
 473 #endif /* NO_DIGEST_CACHE */
 474 }
 475 #endif /* USE_FILE_CACHE */
 476
 477 /* Take an fko context, pull the digest and use it as the key to check the
 478  * replay db (digest cache). Returns 1 if there was a match (a replay),
 479  * 0 for no match, and -1 on error.
 480 */
 481 int
 482 is_replay(fko_srv_options_t *opts, unsigned char *pkt_data)
 483 {
 484 #ifdef NO_DIGEST_CACHE
 485     return(-1);
 486 #else
 487
 488 #if USE_FILE_CACHE
 489     return is_replay_file_cache(opts, pkt_data);
 490 #else
 491     return is_replay_dbm_cache(opts, pkt_data);
 492 #endif
 493 #endif /* NO_DIGEST_CACHE */
 494 }
 495
 496 #if USE_FILE_CACHE
 497 int
 498 is_replay_file_cache(fko_srv_options_t *opts, unsigned char *pkt_data)
 499 {
 500     char       *digest = NULL;
 501     char        src_ip[INET_ADDRSTRLEN+1] = {0};
 502     char        dst_ip[INET_ADDRSTRLEN+1] = {0};
 503     int         res = 0, digest_len = 0;
 504     FILE       *digest_file_ptr = NULL;
 505
 506     struct digest_cache_list *digest_list_ptr = NULL, *digest_elm = NULL;
 507
 508     res = get_raw_digest(&digest, (char *)pkt_data);
 509
 510     if(res != FKO_SUCCESS)
 511     {
 512         if (digest != NULL)
 513             free(digest);
 514         return res;
 515     }
 516
 517     if (digest == NULL)
 518         return SPA_MSG_ERROR;
 519
 520     digest_len = strlen(digest);
 521
 522     /* Check the cache for the SPA packet digest
 523     */
 524     for (digest_list_ptr = opts->digest_cache;
 525             digest_list_ptr != NULL;
 526             digest_list_ptr = digest_list_ptr->next) {
 527
 528         if (strncmp(digest_list_ptr->cache_info.digest, digest, digest_len) == 0) {
 529
 530             replay_warning(opts, &(digest_list_ptr->cache_info));
 531
 532             free(digest);
 533             return(SPA_MSG_REPLAY);
 534         }
 535     }
 536
 537     /* If we make it here, then this is a new SPA packet that needs to be
 538      * added to the cache.  We've already decrypted the data, so we know that
 539      * the contents are valid.
 540     */
 541     if ((digest_elm = calloc(1, sizeof(struct digest_cache_list))) == NULL)
 542     {
 543         log_msg(LOG_WARNING, "Error calloc() returned NULL for digest cache element",
 544             fko_errstr(SPA_MSG_ERROR));
 545
 546         free(digest);
 547         return(SPA_MSG_ERROR);
 548     }
 549     if ((digest_elm->cache_info.digest = calloc(1, digest_len+1)) == NULL)
 550     {
 551         log_msg(LOG_WARNING, "Error calloc() returned NULL for digest cache string",
 552             fko_errstr(SPA_MSG_ERROR));
 553         free(digest_elm);
 554         free(digest);
 555         return(SPA_MSG_ERROR);
 556     }
 557
 558     strlcpy(digest_elm->cache_info.digest, digest, digest_len+1);
 559     digest_elm->cache_info.proto    = opts->spa_pkt.packet_proto;
 560     digest_elm->cache_info.src_ip   = opts->spa_pkt.packet_src_ip;
 561     digest_elm->cache_info.dst_ip   = opts->spa_pkt.packet_dst_ip;
 562     digest_elm->cache_info.src_port = opts->spa_pkt.packet_src_port;
 563     digest_elm->cache_info.dst_port = opts->spa_pkt.packet_dst_port;
 564     digest_elm->cache_info.created = time(NULL);
 565
 566     /* First, add the digest at the head of the in-memory list
 567     */
 568     digest_elm->next = opts->digest_cache;
 569     opts->digest_cache = digest_elm;
 570
 571     /* Now, write the digest to disk
 572     */
 573     if ((digest_file_ptr = fopen(opts->config[CONF_DIGEST_FILE], "a")) == NULL)
 574     {
 575         log_msg(LOG_WARNING, "Could not open digest cache: %s",
 576             opts->config[CONF_DIGEST_FILE]);
 577         free(digest);
 578         return(SPA_MSG_DIGEST_CACHE_ERROR);
 579     }
 580
 581     inet_ntop(AF_INET, &(digest_elm->cache_info.src_ip),
 582         src_ip, INET_ADDRSTRLEN);
 583     inet_ntop(AF_INET, &(digest_elm->cache_info.dst_ip),
 584         dst_ip, INET_ADDRSTRLEN);
 585     fprintf(digest_file_ptr, "%s %d %s %d %s %d %d\n",
 586         digest,
 587         digest_elm->cache_info.proto,
 588         src_ip,
 589         (int) digest_elm->cache_info.src_port,
 590         dst_ip,
 591         digest_elm->cache_info.dst_port,
 592         (int) digest_elm->cache_info.created);
 593
 594     fclose(digest_file_ptr);
 595
 596     free(digest);
 597     return(SPA_MSG_SUCCESS);
 598 }
 599 #endif /* USE_FILE_CACHE */
 600
 601 #if !USE_FILE_CACHE
 602 int
 603 is_replay_dbm_cache(fko_srv_options_t *opts, unsigned char *pkt_data)
 604 {
 605 #ifdef NO_DIGEST_CACHE
 606     return 0;
 607 #else
 608
 609 #ifdef HAVE_LIBGDBM
 610     GDBM_FILE   rpdb;
 611 #elif HAVE_LIBNDBM
 612     DBM        *rpdb;
 613 #endif
 614     datum       db_key, db_ent;
 615
 616     char       *digest = NULL;
 617     int         digest_len, res;
 618
 619     digest_cache_info_t dc_info;
 620
 621     res = get_raw_digest(&digest, (char *)pkt_data);
 622
 623     if(res != FKO_SUCCESS)
 624     {
 625         if (digest != NULL)
 626             free(digest);
 627         return res;
 628     }
 629
 630     if (digest == NULL)
 631         return SPA_MSG_ERROR;
 632
 633     digest_len = strlen(digest);
 634
 635     db_key.dptr = digest;
 636     db_key.dsize = digest_len;
 637
 638     /* Check the db for the key
 639     */
 640 #ifdef HAVE_LIBGDBM
 641     rpdb = gdbm_open(
 642          opts->config[CONF_DIGEST_DB_FILE], 512, GDBM_WRCREAT, S_IRUSR|S_IWUSR, 0
 643     );
 644 #elif HAVE_LIBNDBM
 645     rpdb = dbm_open(opts->config[CONF_DIGEST_DB_FILE], O_RDWR, 0);
 646 #endif
 647
 648     if(!rpdb)
 649     {
 650         log_msg(LOG_WARNING, "Error opening digest_cache: '%s': %s",
 651             opts->config[CONF_DIGEST_DB_FILE],
 652             MY_DBM_STRERROR(errno)
 653         );
 654
 655         free(digest);
 656         return(SPA_MSG_DIGEST_CACHE_ERROR);
 657     }
 658
 659     db_ent = MY_DBM_FETCH(rpdb, db_key);
 660
 661     /* If the datum is not null, we have a match.  Otherwise, we add
 662     * this entry to the cache.
 663     */
 664     if(db_ent.dptr != NULL)
 665     {
 666         replay_warning(opts, (digest_cache_info_t *)db_ent.dptr);
 667
 668         /* Save it back to the digest cache
 669         */
 670         if(MY_DBM_STORE(rpdb, db_key, db_ent, MY_DBM_REPLACE) != 0)
 671             log_msg(LOG_WARNING, "Error updating entry in digest_cache: '%s': %s",
 672                 opts->config[CONF_DIGEST_DB_FILE],
 673                 MY_DBM_STRERROR(errno)
 674             );
 675
 676 #ifdef HAVE_LIBGDBM
 677         free(db_ent.dptr);
 678 #endif
 679
 680         res = SPA_MSG_REPLAY;
 681     } else {
 682         /* This is a new SPA packet that needs to be added to the cache.
 683         */
 684         dc_info.src_ip   = opts->spa_pkt.packet_src_ip;
 685         dc_info.dst_ip   = opts->spa_pkt.packet_dst_ip;
 686         dc_info.src_port = opts->spa_pkt.packet_src_port;
 687         dc_info.dst_port = opts->spa_pkt.packet_dst_port;
 688         dc_info.proto    = opts->spa_pkt.packet_proto;
 689         dc_info.created  = time(NULL);
 690         dc_info.first_replay = dc_info.last_replay = dc_info.replay_count = 0;
 691
 692         db_ent.dsize    = sizeof(digest_cache_info_t);
 693         db_ent.dptr     = (char*)&(dc_info);
 694
 695         if(MY_DBM_STORE(rpdb, db_key, db_ent, MY_DBM_INSERT) != 0)
 696         {
 697             log_msg(LOG_WARNING, "Error adding entry digest_cache: %s",
 698                 MY_DBM_STRERROR(errno)
 699             );
 700
 701             res = SPA_MSG_DIGEST_CACHE_ERROR;
 702         }
 703
 704         res = SPA_MSG_SUCCESS;
 705     }
 706
 707     MY_DBM_CLOSE(rpdb);
 708
 709     free(digest);
 710     return(res);
 711 #endif /* NO_DIGEST_CACHE */
 712 }
 713 #endif /* USE_FILE_CACHE */
 714
 715 #if USE_FILE_CACHE
 716 /* Free replay list memory
 717 */
 718 void
 719 free_replay_list(fko_srv_options_t *opts)
 720 {
 721 #ifdef NO_DIGEST_CACHE
 722     return;
 723 #endif
 724     struct digest_cache_list *digest_list_ptr = NULL, *digest_tmp = NULL;
 725
 726     if (opts->digest_cache == NULL)
 727         return;
 728
 729     digest_list_ptr = opts->digest_cache;
 730     while (digest_list_ptr != NULL)
 731     {
 732         digest_tmp = digest_list_ptr->next;
 733         if (digest_list_ptr->cache_info.digest != NULL
 734                 && digest_list_ptr->cache_info.digest[0] != '\0')
 735         {
 736             free(digest_list_ptr->cache_info.digest);
 737         }
 738         free(digest_list_ptr);
 739         digest_list_ptr = digest_tmp;
 740     }
 741
 742     return;
 743 }
 744 #endif
 745
 746
 747 /***EOF***/