/*
 * Copyright (c) 2009-2011, Broadcom Corporation
 * Copyright (c) 2014, QLogic Corporation
 *
 * Written by:  Benjamin Li  (benli@broadcom.com)
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. 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.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *      This product includes software developed by Adam Dunkels.
 * 4. 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.
 *
 * nic_vlan.c - uIP user space stack VLAN utilities
 *
 */
#define _GNU_SOURCE
#include <errno.h>
#include <fcntl.h>
#include <pthread.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/stat.h>

#include <arpa/inet.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>

#include "logger.h"
#include "nic.h"
#include "nic_utils.h"
#include "nic_vlan.h"

/*******************************************************************************
 * Constants
 ******************************************************************************/
#define PFX "vlan"

static const char proc_vlan_config_path[] = "/proc/net/vlan/config";

/*******************************************************************************
 * Resolving Found VLAN's for CNIC
 ******************************************************************************/
int init_vlan_found_handle(struct vlan_found_handle *found_handle,
			   struct vlan_handle *handle)
{
	memset(found_handle, 0, sizeof(*found_handle));

	found_handle->entries = malloc(found_handle->num_of_entries *
				       sizeof(struct vlan_found_entry));
	if (found_handle->entries == NULL) {
		LOG_ERR("Could not allocate space for found entries");
		return -ENOMEM;
	}

	found_handle->handle = handle;
	found_handle->num_of_entries = handle->num_of_entries;

	memset(found_handle->entries, 0, found_handle->num_of_entries *
	       sizeof(struct vlan_found_entry));

	handle->outstanding_found_handles++;

	return 0;
}

void release_vlan_found_handle(struct vlan_found_handle *found_handle)
{
	if (found_handle->entries != NULL) {
		free(found_handle->entries);
		found_handle->entries = NULL;
	}

	found_handle->num_of_entries = 0;

	found_handle->handle->outstanding_found_handles--;

	found_handle->handle = NULL;

}

/*******************************************************************************
 * Resolving VLAN's for CNIC
 ******************************************************************************/
/**
 *  init_vlan_handle() - Used to initialize struct ipv4_route_handle so
 *                            that is can be used
 *  @param handle - Pointer to struct ipv4_route_handle to initialize
 *  @return 0 on success and <0 on failure
 */
void init_vlan_table(struct vlan_handle *handle)
{
	handle->entries = NULL;
	handle->num_of_entries = 0;
}

/**
 *  parse_vlan_table() - Given the raw dump of a Linux vlan table, this
 *                       function will parse the into entries held by
 *                       struct vlan_handle
 *  @param handle - struct vlan_handle used to hold the parsed contents
 *  @param raw    - buffer to parse the contents from
 *  @param raw_size  - size of the buffer in bytes
 *  @return 0 on success, <0 on failure
 */
int parse_vlan_table(struct vlan_handle *handle, char *raw, uint32_t raw_size)
{
	FILE *fp;
	int i;
	char *token;
	size_t size;
	int rc;

	token = raw;

	/*  determine the number of entries */
	while (*token != '\0') {
		if (*token == '\n')
			handle->num_of_entries++;

		token++;
	}

	/*  There are 2 lines which describe the vlan table
	 *  This lines need to be skipped with counting */
	handle->num_of_entries -= 2;

	LOG_INFO("Number of vlan entries: %d", handle->num_of_entries);

	size = handle->num_of_entries * sizeof(struct vlan_entry);
	handle->entries = malloc(size);
	if (handle->entries == NULL) {
		LOG_ERR
		    ("Couldn't malloc space to parse vlan table. entires: %d "
		     "size: %d",
		     handle->num_of_entries, size);
		return -ENOMEM;
	}

	fp = fmemopen(raw, raw_size, "r");
	if (fp == NULL) {
		LOG_ERR("Could not open raw dump of vlan table");
		rc = errno;
		goto fmemopen_error;
	}

	if (fscanf(fp, "%*[^\n]\n") < 0) {	/* Skip the first line. */
		LOG_ERR("Empty or missing line, or read error");
		rc = -EIO;
		goto error;
	}

	if (fscanf(fp, "%*[^\n]\n") < 0) {	/* Skip the second line. */
		LOG_ERR("Empty or missing line, or read error");
		rc = -EIO;
		goto error;
	}

	i = 0;
	/*  Time to parse the routing table */
	while (1) {
		struct vlan_entry *entry = &handle->entries[i];
		int r;

		r = fscanf(fp, "%15s |%hu |%15s",
			   entry->vlan_iface_name,
			   &entry->vlan_id, entry->phy_iface_name);
		if (r != 3) {
			if (feof(fp)) {	/* EOF with no (nonspace) chars read. */
				break;
			}

			LOG_WARN("Parsing error: parsed %d elements", r);
			break;
		}

		i++;

		LOG_DEBUG("Vlan %d: vlan iface:%s vlan id:%d phys iface:%s",
			  i,
			  entry->vlan_iface_name,
			  entry->vlan_id, entry->phy_iface_name);
	}

	fclose(fp);

	return 0;

error:
	fclose(fp);

fmemopen_error:
	if (handle->entries != NULL)
		free(handle->entries);

	return rc;
}

/**
 *  capture_vlan_table() - This function will snapshot the Linux vlan
 *                         routing table for further processing
 *  @param handle - struct vlan_handle used to hold the routing context
 *  @return 0 on success, <0 on failure
 */
int capture_vlan_table(struct vlan_handle *handle)
{
	char *raw = NULL;
	uint32_t raw_size = 0;
	int rc;

	rc = capture_file(&raw, &raw_size, proc_vlan_config_path);
	if (rc != 0)
		goto error;

	rc = parse_vlan_table(handle, raw, raw_size);
	if (rc != 0)
		goto error;

error:
	if (raw != NULL)
		free(raw);

	return rc;
}

/**
 *  release_vlan_table() - This function will free all resources used by
 *                         the handle
 *  @param handle -  struct vlan_handle used to hold the routing context
 */
void release_vlan_table(struct vlan_handle *handle)
{
	if (handle->entries != NULL) {
		free(handle->entries);
		handle->entries = NULL;
	}

	handle->num_of_entries = 0;
}

/**
 *  find_phy_using_vlan_interface() - Given the interface name determine VLAN
 *      tag ID to match either the physical or VLAN interface name
 *  @param vlan_iface_name - VLAN interface used to find the physical
 *                           interface
 *  @param phy_iface_name - returned value is the physical interface name
 *  @param vlan_id - returned value is the VLAN id
 *  @return 1 is returned if the interface is a VLAN, 0 if the interface is not
 *          <0 is returned if there is an error
 */
int find_phy_using_vlan_interface(struct vlan_handle *handle,
				  char *vlan_iface_name,
				  char **phy_iface_name, uint16_t *vlan_id)
{
	int i, rc = 0;

	for (i = 0; i < handle->num_of_entries; i++) {
		struct vlan_entry *entry = &handle->entries[i];

		/*  Compare VLAN interface names to find a match */
		if (strcmp(entry->vlan_iface_name, vlan_iface_name) == 0) {
			*phy_iface_name = entry->phy_iface_name;
			*vlan_id = entry->vlan_id;
			rc = 1;
			break;
		}
	}

	return rc;
}

/**
 *  find_vlans_using_phy_interface() - Given the physical interface name this
 *      function will determine the VLAN interface name and VLAN ID
 *  @param iface_name - physical interface used to find the vlan interface
 *  @param vlan_iface_name - returned value is the VLAN interface name
 *  @return The number of VLAN interfaces found
 */
int find_vlans_using_phy_interface(struct vlan_handle *handle,
				   struct vlan_found_handle *found_handle,
				   char *phy_iface_name)
{
	int i, num_found = 0;

	for (i = 0; i < handle->num_of_entries; i++) {
		struct vlan_entry *entry = &handle->entries[i];

		/*  Compare interface names to find a match */
		if (strcmp(entry->phy_iface_name, phy_iface_name) == 0) {
			found_handle->entries[i].found = VLAN_ENTRY_FOUND;
			num_found++;
		}
	}

	return num_found;
}

/**
 *  valid_vlan() - determine if the vlan value which is passed is valid
 *  @param vlan - vlan value to test
 *  @return 0 - not valid, 1 - valid
 */
int valid_vlan(short int vlan)
{
	/* Allow vlan 1 to connect */
	if (vlan > 0 && vlan < 4095)
		return 1;

	return 0;
}