/*
 * Copyright(c) 2012-2013 Intel Corporation. All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms and conditions of the GNU General Public License,
 * version 2, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope 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 St - Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Maintained at www.Open-FCoE.org
 */

#include "libopenfcoe.h"

#define SYSFS_HOST_DIR	   "/sys/class/fc_host"
#define SYSFS_HBA_DIR	   "/sys/class/net"

int mac2str(const u_int8_t *mac, char *dst, size_t size)
{
	if (dst && size > MAC_ADDR_STRLEN) {
		snprintf(dst, size, "%02X:%02X:%02X:%02X:%02X:%02X",
			 mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
		return 0;
	}
	return -1;
}

int str2mac(const char *src, u_int8_t *mac, size_t size)
{
	int i = 0;
	int rc = -1;

	if (size < 6)
		goto out_err;

	if (!src)
		goto out_err;

	if (strlen(src) != MAC_ADDR_STRLEN)
		goto out_err;

	memset(mac, 0, size);
	for (i = 0; i < 6; i++, mac++)
		if (1 != sscanf(&src[i * 3], "%02hhX", mac))
			goto out_err;
	rc = 0;
out_err:
	return rc;
}

static char *safe_makepath(char *path, size_t path_sz,
		char *dname, char *fname)
{
	size_t dsz = sizeof(dname);
	size_t fsz = strlen(fname);
	char *cp = path;

	if ((dsz + fsz + 2) > path_sz) {
		fprintf(stderr,
			"error: no room to expand pathname (%d+%d > %d)\n",
			(int)dsz, (int)fsz, (int)path_sz);
		return NULL;
	}

	memcpy(cp, dname, dsz);
	cp += dsz;

	*cp++ = '/';

	memcpy(cp, fname, fsz);
	cp += fsz;

	*cp = '\0';

	return path;
}

static int add_fcoe_fcf_device(struct dirent *dp, void *arg)
{
	struct fcoe_ctlr_device *ctlr = (struct fcoe_ctlr_device *)arg;
	struct fcoe_fcf_device *fcf;

	if (!strstr(dp->d_name, "fcf") ||
	    (!strcmp(dp->d_name, "fcf_dev_loss_tmo")))
		return 0;

	fcf = malloc(sizeof(struct fcoe_fcf_device));
	if (!fcf)
		return -ENOMEM;

	memset(fcf, 0, sizeof(struct fcoe_fcf_device));

	/* Save the path */
	if (safe_makepath(fcf->path, sizeof(fcf->path),
				ctlr->path, dp->d_name) == NULL)
		goto fail;

	/* Use the index from the logical enumeration */
	fcf->index = atoi(dp->d_name + sizeof("fcf_") - 1);

	/* Save the fcf in the fcport's table */
	if (sa_table_insert(&ctlr->fcfs, fcf->index,
			    fcf) < 0) {
		fprintf(stderr, "%s: insert of fcf %d failed\n",
			__func__, fcf->index);
		goto fail;
	}

	return 0;

fail:
	free(fcf);
	return -ENOENT;
}

static void read_fcoe_fcf_device(void *ep, UNUSED void *arg)
{
	struct fcoe_fcf_device *fcf = (struct fcoe_fcf_device *)ep;
	char buf[MAX_STR_LEN];

	sa_sys_read_line(fcf->path, "state", buf, sizeof(buf));
	sa_enum_encode(fcf_state_table, buf, &fcf->state);
	sa_sys_read_u32(fcf->path, "dev_loss_tmo", &fcf->dev_loss_tmo);
	sa_sys_read_u64(fcf->path, "fabric_name", &fcf->fabric_name);
	sa_sys_read_u64(fcf->path, "switch_name", &fcf->switch_name);
	sa_sys_read_u32(fcf->path, "fc_map", &fcf->fc_map);
	sa_sys_read_u32(fcf->path, "vfid", &fcf->vfid);

	sa_sys_read_line(fcf->path, "mac", buf, MAX_STR_LEN);
	str2mac(buf, &fcf->mac[0], MAC_ADDR_LEN);

	sa_sys_read_u32(fcf->path, "priority", &fcf->priority);
	sa_sys_read_u32(fcf->path, "fka_period", &fcf->fka_period);
	sa_sys_read_u32(fcf->path, "selected", &fcf->selected);
	sa_sys_read_u32(fcf->path, "vlan_id", &fcf->vlan_id);
}

static void read_fcoe_fcf(void *ep, UNUSED void *arg)
{
	struct fcoe_ctlr_device *ctlr = (struct fcoe_ctlr_device *)ep;

	/* Iterate through the ctlr and add any fcfs */
	sa_dir_read(ctlr->path, add_fcoe_fcf_device, ctlr);

	/* Populate each fabric */
	sa_table_iterate(&ctlr->fcfs, read_fcoe_fcf_device, NULL);
}

static void free_fcoe_fcf_device(void *ep, UNUSED void *arg)
{
	struct fcoe_fcf_device *fcf = (struct fcoe_fcf_device *)ep;

	free(fcf);
}

#define SYSFS_MOUNT "/sys"
#define FCOE_CTLR_DEVICE_DIR SYSFS_MOUNT "/bus/fcoe/devices/"

static int find_fchost(struct dirent *dp, void *arg)
{
	char *fchost = arg;

	if (strstr(dp->d_name, "host")) {
		strncpy(fchost, dp->d_name, MAX_STR_LEN);
		return 1;
	}

	return 0;
}

static int read_fcoe_ctlr_device(struct dirent *dp, void *arg)
{
	struct sa_table *ctlrs = arg;
	struct fcoe_ctlr_device *ctlr;
	char buf[MAX_STR_LEN];
	char lesb_path[MAX_STR_LEN];
	char hpath[MAX_STR_LEN];
	char fchost[MAX_STR_LEN];
	char *cp, *ifname;
	int rc;

	if (strncmp(dp->d_name, "ctlr_", 5))
		return 0;

	ctlr = malloc(sizeof(struct fcoe_ctlr_device));
	if (!ctlr)
		return 0; /* Must return 0 or loop will break */

	memset(ctlr, 0, sizeof(struct fcoe_ctlr_device));
	sa_table_init(&ctlr->fcfs);

	/* Save the path */
	snprintf(ctlr->path, sizeof(ctlr->path),
		 FCOE_CTLR_DEVICE_DIR "%s", dp->d_name);

	/* Use the index from the logical enumeration */
	ctlr->index = atoi(dp->d_name + sizeof("ctlr_") - 1);

	rc = sa_dir_read(ctlr->path, find_fchost, fchost);
	if (!rc)
		goto fail;

	rc = snprintf(hpath, MAX_STR_LEN, "%s/%s/", SYSFS_FCHOST, fchost);
	if (rc < 0 || rc >= MAX_STR_LEN)
		goto fail;

	rc = sa_sys_read_line(hpath, "symbolic_name", buf, sizeof(buf));

	/* Skip the HBA if it isn't Open-FCoE */
	cp = strstr(buf, " over ");
	if (!cp)
		goto fail;

	ifname = get_ifname_from_symbolic_name(buf);
	strncpy(ctlr->ifname, ifname, IFNAMSIZ-1);

	/* Get fcf device loss timeout */
	sa_sys_read_u32(ctlr->path, "fcf_dev_loss_tmo",
			&ctlr->fcf_dev_loss_tmo);

	sa_sys_read_line(ctlr->path, "mode", buf, sizeof(buf));
	sa_enum_encode(fip_conn_type_table, buf, &ctlr->mode);

	if (safe_makepath(lesb_path, sizeof(lesb_path),
				ctlr->path, "lesb") == NULL)
		goto fail;

	/* Get LESB statistics */
	sa_sys_read_u32(lesb_path, "link_fail",
			&ctlr->lesb_link_fail);
	sa_sys_read_u32(lesb_path, "vlink_fail",
			&ctlr->lesb_vlink_fail);
	sa_sys_read_u32(lesb_path, "miss_fka",
			&ctlr->lesb_miss_fka);
	sa_sys_read_u32(lesb_path, "symb_err",
			&ctlr->lesb_symb_err);
	sa_sys_read_u32(lesb_path, "err_block",
			&ctlr->lesb_err_block);
	sa_sys_read_u32(lesb_path, "fcs_error",
			&ctlr->lesb_fcs_error);

	/* Save the ctlr in the supplied table */
	if (sa_table_insert(ctlrs, ctlr->index, ctlr) < 0) {
		fprintf(stderr, "%s: insert of ctlr %d failed\n",
			__func__, ctlr->index);
		goto fail;
	}

	return 0;

fail:
	free(ctlr);
	return -ENOENT;
}

void read_fcoe_ctlr(struct sa_table *ctlrs)
{
	sa_dir_read(FCOE_CTLR_DEVICE_DIR, read_fcoe_ctlr_device, ctlrs);
	sa_table_iterate(ctlrs, read_fcoe_fcf, NULL);
}

void free_fcoe_ctlr_device(void *ep, UNUSED void *arg)
{
	struct fcoe_ctlr_device *ctlr = (struct fcoe_ctlr_device *)ep;

	sa_table_iterate(&ctlr->fcfs, free_fcoe_fcf_device, NULL);

	free(ctlr);
}