/*

 *  Copyright (C) 2013-2024 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 *)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 *)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_safer_strdup(key);

                    tableItem->value = value;

                    return value;

                }

            table->flags &= ~TABLE_HAS_DELETED_ENTRIES;

        }

        table->tableLast = table->tableLast->next =

            (tableEntry *)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_safer_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);

}