/*

  *  Copyright (C) 2013-2019 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
  *  Copyright (C) 2007-2013 Sourcefire, Inc.

  *
  *  Authors: Nigel Horne

  *
  *  This program is free software; you can redistribute it and/or modify

  *  it under the terms of the GNU General Public License version 2 as
  *  published by the Free Software Foundation.

  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software

  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
  *  MA 02110-1301, USA.

  *
  * TODO: Allow individual items to be updated or removed
  *
  * It is up to the caller to create a mutex for the table if needed

  */
 

 #if HAVE_CONFIG_H
 #include "clamav-config.h"
 #endif
 

 #include <stdlib.h>
 #include <string.h>

 #ifdef HAVE_STRINGS_H

 #include <strings.h>

 #endif

 #include <assert.h>
 

 #include "clamav.h"

 #include "table.h"
 #include "others.h"
 
 struct table *
 tableCreate(void)
 {

     return (struct table *)cli_calloc(1, sizeof(struct table));

 }
 

 void tableDestroy(table_t *table)

 {

     tableEntry *tableItem;

     assert(table != NULL);

     tableItem = table->tableHead;

     while (tableItem) {
         tableEntry *tableNext = tableItem->next;

         if (tableItem->key)
             free(tableItem->key);
         free(tableItem);

         tableItem = tableNext;
     }

     free(table);

 }
 
 /*
  * Returns the value, or -1 for failure
  */

 int tableInsert(table_t *table, const char *key, int value)

 {

     const int v = tableFind(table, key);

     if (v > 0)                            /* duplicate key */
         return (v == value) ? value : -1; /* allow real dups */

     assert(value != -1); /* that would confuse us */

     if (table->tableHead == NULL)
         table->tableLast = table->tableHead = (tableEntry *)cli_malloc(sizeof(tableEntry));
     else {
         /*

 		 * Re-use deleted items
 		 */

         if (table->flags & TABLE_HAS_DELETED_ENTRIES) {
             tableEntry *tableItem;

             assert(table->tableHead != NULL);

             for (tableItem = table->tableHead; tableItem; tableItem = tableItem->next)
                 if (tableItem->key == NULL) {
                     /* This item has been deleted */
                     tableItem->key   = cli_strdup(key);
                     tableItem->value = value;
                     return value;
                 }

             table->flags &= ~TABLE_HAS_DELETED_ENTRIES;
         }

         table->tableLast = table->tableLast->next =
             (tableEntry *)cli_malloc(sizeof(tableEntry));
     }

     if (table->tableLast == NULL) {

         cli_dbgmsg("tableInsert: Unable to allocate memory for table\n");

         return -1;

     }

     table->tableLast->next  = NULL;
     table->tableLast->key   = cli_strdup(key);
     table->tableLast->value = value;

     return value;

 }
 
 /*

  * Returns the value - -1 for not found. This means the value of a valid key
  *	can't be -1 :-(

  *
  * Linear search. Since tables are rarely more than 3 or 4 in size, and never

  *	reach double figures, there's no need for optimization

  */

 int tableFind(const table_t *table, const char *key)

 {

     const tableEntry *tableItem;
 #ifdef CL_DEBUG
     int cost;

 #endif

     assert(table != NULL);

     if (key == NULL)
         return -1; /* not treated as a fatal error */

 #ifdef CL_DEBUG
     cost = 0;

 #endif

     for (tableItem = table->tableHead; tableItem; tableItem = tableItem->next) {
 #ifdef CL_DEBUG
         cost++;

 #endif

         if (tableItem->key && (strcasecmp(tableItem->key, key) == 0)) {
 #ifdef CL_DEBUG
             cli_dbgmsg("tableFind: Cost of '%s' = %d\n", key, cost);

 #endif

             return tableItem->value;
         }
     }

     return -1; /* not found */

 }

 
 /*
  * Change a value in the table. If the key isn't in the table insert it
  * Returns -1 for error, otherwise the new value
  */

 int tableUpdate(table_t *table, const char *key, int new_value)

 {

     tableEntry *tableItem;

     assert(table != NULL);

     if (key == NULL)
         return -1; /* not treated as a fatal error */

     for (tableItem = table->tableHead; tableItem; tableItem = tableItem->next)
         if (tableItem->key && (strcasecmp(tableItem->key, key) == 0)) {
             tableItem->value = new_value;
             return new_value;
         }

     /* not found */
     return tableInsert(table, key, new_value);

 }

 
 /*
  * Remove an item from the table
  */

 void tableRemove(table_t *table, const char *key)

 {

     tableEntry *tableItem;

     assert(table != NULL);

     if (key == NULL)
         return; /* not treated as a fatal error */

     for (tableItem = table->tableHead; tableItem; tableItem = tableItem->next)
         if (tableItem->key && (strcasecmp(tableItem->key, key) == 0)) {
             free(tableItem->key);
             tableItem->key = NULL;
             table->flags |= TABLE_HAS_DELETED_ENTRIES;
             /* don't break, duplicate keys are allowed */
         }

 }
 

 void tableIterate(table_t *table, void (*callback)(char *key, int value, void *arg), void *arg)

 {

     tableEntry *tableItem;

     if (table == NULL)
         return;

     for (tableItem = table->tableHead; tableItem; tableItem = tableItem->next)
         if (tableItem->key) /* check node has not been deleted */
             (*callback)(tableItem->key, tableItem->value, arg);

 }