/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright (c) 1995, 2010, Oracle and/or its affiliates. All rights reserved.
 * Copyright 2015 Nexenta Systems, Inc. All rights reserved.
 */

#include <ctype.h>
#include <dirent.h>
#include <errno.h>
#include <locale.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/socketvar.h>
#include <sys/stat.h>
#include <unistd.h>

#define	MAXLINELEN	4096

/*
 * Usage:
 *	soconfig -d <dir>
 *		Reads input from files in dir.
 *
 *	soconfig -f <file>
 *		Reads input from file. The file is structured as
 *			 <fam> <type> <protocol> <path|module>
 *			 <fam> <type> <protocol>
 *		with the first line registering and the second line
 *		deregistering.
 *
 *	soconfig <fam> <type> <protocol> <path|module>
 *		registers
 *
 *	soconfig <fam> <type> <protocol>
 *		deregisters
 *
 *	soconfig -l
 *		print the in-kernel socket configuration table
 *
 * Filter Operations (Consolidation Private):
 *
 *	soconfig -F <name> <modname> {auto [top | bottom | before:filter |
 *		after:filter] | prog} <fam>:<type>:<proto>,...
 *		configure filter
 *
 *	soconfig -F <name>
 *		unconfigures filter
 */

static int	parse_files_in_dir(const char *dir);

static int	parse_file(char *filename);

static int	split_line(char *line, char *argvec[], int maxargvec);

static int	parse_params(char *famstr, char *typestr, char *protostr,
				char *path, const char *file, int line);

static int	parse_int(char *str);

static void	usage(void);

static int	parse_filter_params(int argc, char **argv);

static int	print_socktable();

int
main(argc, argv)
	int argc;
	char *argv[];
{
	int ret;

	argc--; argv++;

	(void) setlocale(LC_ALL, "");
#if !defined(TEXT_DOMAIN)
#define	TEXT_DOMAIN "SYS_TEST"
#endif
	(void) textdomain(TEXT_DOMAIN);

	if (argc == 1 && strcmp(argv[0], "-l") == 0) {
		ret = print_socktable();
		exit(ret);
	}

	if (argc >= 2 && strcmp(argv[0], "-F") == 0) {
		argc--; argv++;
		ret = parse_filter_params(argc, argv);
		exit(ret);
	}
	if (argc == 2 && strcmp(argv[0], "-d") == 0) {
		ret = parse_files_in_dir(argv[1]);
		exit(ret);
	}
	if (argc == 2 && strcmp(argv[0], "-f") == 0) {
		ret = parse_file(argv[1]);
		exit(ret);
	}
	if (argc == 3) {
		ret = parse_params(argv[0], argv[1], argv[2], NULL, NULL, -1);
		exit(ret);
	}
	if (argc == 4) {
		ret = parse_params(argv[0], argv[1], argv[2], argv[3],
		    NULL, -1);
		exit(ret);
	}
	usage();
	exit(1);
	/* NOTREACHED */
}

static void
usage(void)
{
	fprintf(stderr, gettext(
	    "Usage:	soconfig -d <dir>\n"
	    "\tsoconfig -f <file>\n"
	    "\tsoconfig <fam> <type> <protocol> <path|module>\n"
	    "\tsoconfig <fam> <type> <protocol>\n"
	    "\tsoconfig -l\n"));
}

/*
 * Parse all files in the given directory.
 */
static int
parse_files_in_dir(const char *dirname)
{
	DIR		*dp;
	struct dirent 	*dirp;
	struct stat	stats;
	char		buf[MAXPATHLEN];

	if ((dp = opendir(dirname)) == NULL) {
		fprintf(stderr, gettext("failed to open directory '%s': %s\n"),
		    dirname, strerror(errno));
		return (1);
	}

	while ((dirp = readdir(dp)) != NULL) {
		if (dirp->d_name[0] == '.')
			continue;

		if (snprintf(buf, sizeof (buf), "%s/%s", dirname,
		    dirp->d_name) >= sizeof (buf)) {
			fprintf(stderr,
			    gettext("path name is too long: %s/%s\n"),
			    dirname, dirp->d_name);
			continue;
		}
		if (stat(buf, &stats) == -1) {
			fprintf(stderr,
			    gettext("failed to stat '%s': %s\n"), buf,
			    strerror(errno));
			continue;
		}
		if (!S_ISREG(stats.st_mode))
			continue;

		(void) parse_file(buf);
	}

	closedir(dp);

	return (0);
}

/*
 * Open the specified file and parse each line. Skip comments (everything
 * after a '#'). Return 1 if at least one error was encountered; otherwise 0.
 */
static int
parse_file(char *filename)
{
	char line[MAXLINELEN];
	char pline[MAXLINELEN];
	int argcount;
	char *argvec[20];
	FILE *fp;
	int linecount = 0;
	int numerror = 0;

	fp = fopen(filename, "r");
	if (fp == NULL) {
		perror("soconfig: open");
		fprintf(stderr, "\n");
		usage();
		return (1);
	}

	while (fgets(line, sizeof (line) - 1, fp) != NULL) {
		linecount++;
		strcpy(pline, line);
		argcount = split_line(pline, argvec,
		    sizeof (argvec) / sizeof (argvec[0]));
#ifdef DEBUG
		{
			int i;

			printf("scanned %d args\n", argcount);
			for (i = 0; i < argcount; i++)
				printf("arg[%d]: %s\n", i, argvec[i]);
		}
#endif /* DEBUG */
		switch (argcount) {
		case 0:
			/* Empty line - or comment only line */
			break;
		case 3:
			numerror += parse_params(argvec[0], argvec[1],
			    argvec[2], NULL, filename, linecount);
			break;
		case 4:
			numerror += parse_params(argvec[0], argvec[1],
			    argvec[2], argvec[3], filename, linecount);
			break;
		default:
			numerror++;
			fprintf(stderr,
			    gettext("Malformed line: <%s>\n"), line);
			fprintf(stderr,
			    gettext("\ton line %d in %s\n"), linecount,
			    filename);
			break;
		}
	}
	(void) fclose(fp);

	if (numerror > 0)
		return (1);
	else
		return (0);
}

/*
 * Parse a line splitting it off at whitspace characters.
 * Modifies the content of the string by inserting NULLs.
 */
static int
split_line(char *line, char *argvec[], int maxargvec)
{
	int i = 0;
	char *cp;

	/* Truncate at the beginning of a comment */
	cp = strchr(line, '#');
	if (cp != NULL)
		*cp = '\0';

	/* CONSTCOND */
	while (1) {
		/* Skip any whitespace */
		while (isspace(*line))
			line++;

		if (i >= maxargvec)
			return (i);

		argvec[i] = line;
		if (*line == '\0')
			return (i);
		i++;
		/* Skip until next whitespace */
		while (!isspace(*line) && *line != '\0')
			line++;
		if (*line != '\0') {
			/* Break off argument */
			*line++ = '\0';
		}
	}
	/* NOTREACHED */
}

/*
 * Parse the set of parameters and issues the sockconfig syscall.
 * If line is not -1 it is assumed to be the line number in the file.
 */
static int
parse_params(char *famstr, char *typestr, char *protostr, char *path,
    const char *file, int line)
{
	int cmd, fam, type, protocol;

	fam = parse_int(famstr);
	if (fam == -1) {
		fprintf(stderr, gettext("Bad family number: %s\n"), famstr);
		if (line != -1)
			fprintf(stderr,
			    gettext("\ton line %d in %s\n"), line, file);
		else {
			fprintf(stderr, "\n");
			usage();
		}
		return (1);
	}

	type = parse_int(typestr);
	if (type == -1) {
		fprintf(stderr,
		    gettext("Bad socket type number: %s\n"), typestr);
		if (line != -1)
			fprintf(stderr,
			    gettext("\ton line %d in %s\n"), line, file);
		else {
			fprintf(stderr, "\n");
			usage();
		}
		return (1);
	}

	protocol = parse_int(protostr);
	if (protocol == -1) {
		fprintf(stderr,
		    gettext("Bad protocol number: %s\n"), protostr);
		if (line != -1)
			fprintf(stderr,
			    gettext("\ton line %d in %s\n"), line, file);
		else {
			fprintf(stderr, "\n");
			usage();
		}
		return (1);
	}


	if (path != NULL) {
		struct stat stats;

		if (strncmp(path, "/dev", strlen("/dev")) == 0 &&
		    stat(path, &stats) == -1) {
			perror(path);
			if (line != -1)
				fprintf(stderr,
				    gettext("\ton line %d in %s\n"), line,
				    file);
			else {
				fprintf(stderr, "\n");
				usage();
			}
			return (1);
		}

		cmd = SOCKCONFIG_ADD_SOCK;
	} else {
		cmd = SOCKCONFIG_REMOVE_SOCK;
	}

#ifdef DEBUG
	printf("not calling sockconfig(%d, %d, %d, %d, %s)\n",
	    cmd, fam, type, protocol, path == NULL ? "(null)" : path);
#else
	if (_sockconfig(cmd, fam, type, protocol, path) == -1) {
		char *s;

		switch (errno) {
		case EEXIST:
			s = gettext("Mapping exists");
			break;
		default:
			s = strerror(errno);
			break;
		}

		fprintf(stderr,
		    gettext("warning: socket configuration failed "
		    "for family %d type %d protocol %d: %s\n"),
		    fam, type, protocol, s);
		if (line != -1) {
			fprintf(stderr,
			    gettext("\ton line %d in %s\n"), line, file);
		}
		return (1);
	}
#endif
	return (0);
}

static int
parse_int(char *str)
{
	char *end;
	int res;

	res = strtol(str, &end, 0);
	if (end == str)
		return (-1);
	return (res);
}

/*
 * Add and remove socket filters.
 */
static int
parse_filter_params(int argc, char **argv)
{
	struct sockconfig_filter_props filprop;
	sof_socktuple_t *socktuples;
	size_t tupcnt, nalloc;
	char *hintarg, *socktup, *tupstr;
	int i;

	if (argc == 1) {
		if (_sockconfig(SOCKCONFIG_REMOVE_FILTER, argv[0], 0,
		    0, 0) < 0) {
			switch (errno) {
			case ENXIO:
				fprintf(stderr,
				    gettext("socket filter is not configured "
				    "'%s'\n"), argv[0]);
				break;
			default:
				perror("sockconfig");
				break;
			}
			return (1);
		}
		return (0);
	}

	if (argc < 4 || argc > 5)
		return (1);


	if (strlen(argv[1]) >= MODMAXNAMELEN) {
		fprintf(stderr,
		    gettext("invalid module name '%s': name too long\n"),
		    argv[1]);
		return (1);
	}
	filprop.sfp_modname = argv[1];

	/* Check the attach semantics */
	if (strcmp(argv[2], "auto") == 0) {
		filprop.sfp_autoattach = B_TRUE;
		if (argc == 5) {
			/* placement hint */
			if (strcmp(argv[3], "top") == 0) {
				filprop.sfp_hint = SOF_HINT_TOP;
			} else if (strcmp(argv[3], "bottom") == 0) {
				filprop.sfp_hint = SOF_HINT_BOTTOM;
			} else {
				if (strncmp(argv[3], "before", 6) == 0) {
					filprop.sfp_hint = SOF_HINT_BEFORE;
				} else if (strncmp(argv[3], "after", 5) == 0) {
					filprop.sfp_hint = SOF_HINT_AFTER;
				} else {
					fprintf(stderr,
					    gettext("invalid placement hint "
					    "'%s'\n"), argv[3]);
					return (1);
				}

				hintarg = strchr(argv[3], ':');
				if (hintarg == NULL ||
				    (strlen(++hintarg) == 0) ||
				    (strlen(hintarg) >= FILNAME_MAX)) {
					fprintf(stderr,
					    gettext("invalid placement hint "
					    "argument '%s': name too long\n"),
					    argv[3]);
					return (1);
				}

				filprop.sfp_hintarg = hintarg;
			}
		} else {
			filprop.sfp_hint = SOF_HINT_NONE;
		}
	} else if (strcmp(argv[2], "prog") == 0) {
		filprop.sfp_autoattach = B_FALSE;
		filprop.sfp_hint = SOF_HINT_NONE;
		/* cannot specify placement hint for programmatic filter */
		if (argc == 5) {
			fprintf(stderr,
			    gettext("placement hint specified for programmatic "
			    "filter\n"));
			return (1);
		}
	} else {
		fprintf(stderr, gettext("invalid attach semantic '%s'\n"),
		    argv[2]);
		return (1);
	}

	/* parse the socket tuples */
	nalloc = 4;
	socktuples = calloc(nalloc, sizeof (sof_socktuple_t));
	if (socktuples == NULL) {
		perror("calloc");
		return (1);
	}

	tupcnt = 0;
	tupstr = argv[(argc == 4) ? 3 : 4];
	while ((socktup = strsep(&tupstr, ",")) != NULL) {
		int val;
		char *valstr;

		if (tupcnt == nalloc) {
			sof_socktuple_t *new;

			nalloc *= 2;
			new = realloc(socktuples,
			    nalloc * sizeof (sof_socktuple_t));
			if (new == NULL) {
				perror("realloc");
				free(socktuples);
				return (1);
			}
			socktuples = new;
		}
		i = 0;
		while ((valstr = strsep(&socktup, ":")) != NULL && i < 3) {
			val = parse_int(valstr);
			if (val == -1) {
				fprintf(stderr, gettext("bad socket tuple\n"));
				free(socktuples);
				return (1);
			}
			switch (i) {
			case 0:	socktuples[tupcnt].sofst_family = val; break;
			case 1:	socktuples[tupcnt].sofst_type = val; break;
			case 2:	socktuples[tupcnt].sofst_protocol = val; break;
			}
			i++;
		}
		if (i != 3) {
			fprintf(stderr, gettext("bad socket tuple\n"));
			free(socktuples);
			return (1);
		}
		tupcnt++;
	}
	if (tupcnt == 0) {
		fprintf(stderr, gettext("no socket tuples specified\n"));
		free(socktuples);
		return (1);
	}
	filprop.sfp_socktuple_cnt = tupcnt;
	filprop.sfp_socktuple = socktuples;

	if (_sockconfig(SOCKCONFIG_ADD_FILTER, argv[0], &filprop, 0, 0) < 0) {
		switch (errno) {
		case EINVAL:
			fprintf(stderr,
			    gettext("invalid socket filter configuration\n"));
			break;
		case EEXIST:
			fprintf(stderr,
			    gettext("socket filter is already configured "
			    "'%s'\n"), argv[0]);
			break;
		case ENOSPC:
			fprintf(stderr, gettext("unable to satisfy placement "
			    "constraint\n"));
			break;
		default:
			perror("sockconfig");
			break;
		}
		free(socktuples);
		return (1);
	}
	free(socktuples);
	return (0);
}

/*
 *  Print the in-kernel socket configuration table
 */

static int
print_socktable()
{
	sockconfig_socktable_t sc_table;
	int i;

	(void) memset(&sc_table, 0, sizeof (sockconfig_socktable_t));

	/* get number of entries */
	if (_sockconfig(SOCKCONFIG_GET_SOCKTABLE, &sc_table) == -1) {
		fprintf(stderr,
		    gettext("cannot get in-kernel socket table: %s\n"),
		    strerror(errno));
		return (-1);
	}
	if (sc_table.num_of_entries == 0)
		return (0);

	sc_table.st_entries = calloc(sc_table.num_of_entries,
	    sizeof (sockconfig_socktable_entry_t));
	if (sc_table.st_entries == NULL) {
		fprintf(stderr, gettext("out of memory\n"));
		return (-1);
	}

	/* get socket table entries */
	if (_sockconfig(SOCKCONFIG_GET_SOCKTABLE, &sc_table) == -1) {
		fprintf(stderr,
		    gettext("cannot get in-kernel socket table: %s\n"),
		    strerror(errno));
		return (-1);
	}

	printf("%6s %4s %5s %15s %15s %6s %6s\n",
	    "FAMILY", "TYPE", "PROTO", "STRDEV", "SOCKMOD",
	    "REFS", "FLAGS");
	for (i = 0; i < sc_table.num_of_entries; i++) {
		printf("%6u %4u %5u %15s %15s %6u %#6x\n",
		    sc_table.st_entries[i].se_family,
		    sc_table.st_entries[i].se_type,
		    sc_table.st_entries[i].se_protocol,
		    (strcmp(sc_table.st_entries[i].se_modname,
		    "socktpi") == 0) ?
		    sc_table.st_entries[i].se_strdev : "-",
		    sc_table.st_entries[i].se_modname,
		    sc_table.st_entries[i].se_refcnt,
		    sc_table.st_entries[i].se_flags);
	}
	free(sc_table.st_entries);
	return (0);
}