/*
 * Copyright (c) 2011 Radim Vansa
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/**
 * @addtogroup libnic
 * @{
 */
/**
 * @file
 * @brief Wake-on-LAN support
 */

#include "nic_wol_virtues.h"
#include "nic.h"
#include <assert.h>
#include <errno.h>

/*
 * Hash table helper functions
 */

static size_t nic_wv_key_hash(const void *key)
{
	const nic_wv_id_t *k = key;
	return *k;
}

static size_t nic_wv_hash(const ht_link_t *item)
{
	nic_wol_virtue_t *virtue = (nic_wol_virtue_t *) item;
	return virtue->id;
}

static bool nic_wv_key_equal(const void *key, const ht_link_t *item)
{
	const nic_wv_id_t *k = key;
	const nic_wol_virtue_t *virtue = (const nic_wol_virtue_t *) item;
	return (virtue->id == *k);
}

/**
 * Initializes the WOL virtues structure
 *
 * @param wvs
 *
 * @return EOK		On success
 * @return ENOMEM	On not enough memory
 */
errno_t nic_wol_virtues_init(nic_wol_virtues_t *wvs)
{
	memset(wvs, 0, sizeof(nic_wol_virtues_t));
	wvs->table_operations.hash = nic_wv_hash;
	wvs->table_operations.key_hash = nic_wv_key_hash;
	wvs->table_operations.key_equal = nic_wv_key_equal;
	wvs->table_operations.equal = 0;
	wvs->table_operations.remove_callback = 0;

	if (!hash_table_create(&wvs->table, 0, 0, &wvs->table_operations)) {
		return ENOMEM;
	}
	size_t i;
	for (i = 0; i < NIC_WV_MAX; ++i) {
		wvs->caps_max[i] = -1;
	}
	wvs->next_id = 0;
	return EOK;
}

/**
 * Reinitializes the structure, destroying all virtues. The next_id is not
 * changed (some apps could still hold the filter IDs).
 *
 * @param wvs
 */
void nic_wol_virtues_clear(nic_wol_virtues_t *wvs)
{
	hash_table_clear(&wvs->table);
	nic_wv_type_t type;
	for (type = NIC_WV_NONE; type < NIC_WV_MAX; ++type) {
		nic_wol_virtue_t *virtue = wvs->lists[type];
		while (virtue != NULL) {
			nic_wol_virtue_t *next = virtue->next;
			free(virtue->data);
			free(virtue);
			virtue = next;
		}
		wvs->lists_sizes[type] = 0;
	}
}

/**
 * Verifies that the arguments for the WOL virtues are correct.
 *
 * @param type		Type of the virtue
 * @param data		Data argument for the virtue
 * @param length	Length of the data
 *
 * @return EOK		The arguments are correct
 * @return EINVAL	The arguments are incorrect
 * @return ENOTSUP	This type is unknown
 */
errno_t nic_wol_virtues_verify(nic_wv_type_t type, const void *data, size_t length)
{
	switch (type) {
	case NIC_WV_ARP_REQUEST:
	case NIC_WV_BROADCAST:
	case NIC_WV_LINK_CHANGE:
		return EOK;
	case NIC_WV_DESTINATION:
		return length == sizeof (nic_address_t) ? EOK : EINVAL;
	case NIC_WV_DIRECTED_IPV4:
		return length == sizeof (nic_wv_ipv4_data_t) ? EOK : EINVAL;
	case NIC_WV_DIRECTED_IPV6:
		return length == sizeof (nic_wv_ipv6_data_t) ? EOK : EINVAL;
	case NIC_WV_FULL_MATCH:
		return length % 2 == 0 ? EOK : EINVAL;
	case NIC_WV_MAGIC_PACKET:
		return data == NULL || length == sizeof (nic_wv_magic_packet_data_t) ?
		    EOK : EINVAL;
	default:
		return ENOTSUP;
	}
}

/**
 * Adds the virtue to the list of known virtues, activating it.
 *
 * @param wvs
 * @param virtue	The virtue structure
 *
 * @return EOK		On success
 * @return ENOTSUP	If the virtue type is not supported
 * @return EINVAL	If the virtue type is a single-filter and there's already
 * 					a virtue of this type defined, or there is something wrong
 * 					with the data
 * @return ENOMEM	Not enough memory to activate the virtue
 */
errno_t nic_wol_virtues_add(nic_wol_virtues_t *wvs, nic_wol_virtue_t *virtue)
{
	if (!nic_wv_is_multi(virtue->type) &&
	    wvs->lists[virtue->type] != NULL) {
		return EINVAL;
	}
	do {
		virtue->id = wvs->next_id++;
	} while (NULL != hash_table_find(&wvs->table, &virtue->id));
	hash_table_insert(&wvs->table, &virtue->item);
	virtue->next = wvs->lists[virtue->type];
	wvs->lists[virtue->type] = virtue;
	wvs->lists_sizes[virtue->type]++;
	return EOK;
}

/**
 * Removes the virtue from the list of virtues, but NOT deallocating the
 * nic_wol_virtue structure.
 *
 * @param wvs
 * @param id	Identifier of the removed virtue
 *
 * @return Removed virtue structure or NULL if not found.
 */
nic_wol_virtue_t *nic_wol_virtues_remove(nic_wol_virtues_t *wvs, nic_wv_id_t id)
{
	nic_wol_virtue_t *virtue =
	    (nic_wol_virtue_t *) hash_table_find(&wvs->table, &id);
	if (virtue == NULL) {
		return NULL;
	}

	/* Remove from filter_table */
	hash_table_remove_item(&wvs->table, &virtue->item);

	/* Remove from filter_types */
	assert(wvs->lists[virtue->type] != NULL);
	if (wvs->lists[virtue->type] == virtue) {
		wvs->lists[virtue->type] = virtue->next;
	} else {
		nic_wol_virtue_t *wv = wvs->lists[virtue->type];
		while (wv->next != virtue) {
			wv = wv->next;
			assert(wv != NULL);
		}
		wv->next = virtue->next;
	}
	wvs->lists_sizes[virtue->type]--;

	virtue->next = NULL;
	return virtue;
}

/**
 * Searches the filters table for a filter with specified ID
 *
 * @param wvs
 * @param id	Identifier of the searched virtue
 *
 * @return Requested filter or NULL if not found.
 */
const nic_wol_virtue_t *nic_wol_virtues_find(const nic_wol_virtues_t *wvs,
    nic_wv_id_t id)
{
	/*
	 * The hash_table_find cannot be const, because it would require the
	 * returned link to be const as well. But in this case, when we're returning
	 * constant virtue the retyping is correct.
	 */
	ht_link_t *virtue = hash_table_find(&((nic_wol_virtues_t *) wvs)->table, &id);
	return (const nic_wol_virtue_t *) virtue;
}

/**
 * Fill identifiers of current wol virtues of the specified type into the list.
 * If the type is set to NIC_WV_NONE, all virtues are used.
 *
 * @param		wvs
 * @param[in]	type		Type of the virtues or NIC_WV_NONE
 * @param[out]	id_list		The new vector of filter IDs. Can be NULL.
 * @param[out]	count		Number of IDs in the filter_list. Can be NULL.
 *
 * @return EOK		If it completes successfully
 * @return EINVAL	If the filter type is invalid
 */
errno_t nic_wol_virtues_list(const nic_wol_virtues_t *wvs, nic_wv_type_t type,
    size_t max_count, nic_wv_id_t *id_list, size_t *id_count)
{
	size_t count = 0;
	if (type == NIC_WV_NONE) {
		size_t i;
		for (i = NIC_WV_NONE; i < NIC_WV_MAX; ++i) {
			if (id_list != NULL) {
				nic_wol_virtue_t *virtue = wvs->lists[i];
				while (virtue != NULL) {
					if (count < max_count) {
						id_list[count] = virtue->id;
					}
					++count;
					virtue = virtue->next;
				}
			} else {
				count += wvs->lists_sizes[i];
			}
		}
	} else if (type >= NIC_WV_MAX) {
		return EINVAL;
	} else {
		if (id_list != NULL) {
			nic_wol_virtue_t *virtue = wvs->lists[type];
			while (virtue != NULL) {
				if (count < max_count) {
					id_list[count] = virtue->id;
				}
				++count;
				virtue = virtue->next;
			}
		} else {
			count = wvs->lists_sizes[type];
		}
	}
	if (id_count != NULL) {
		*id_count = count;
	}
	return EOK;
}

/** @}
 */
