/*	$NetBSD: ifconfig.c,v 1.34 1997/04/21 01:17:58 lukem Exp $	*/

/*-
 * SPDX-License-Identifier: BSD-4-Clause
 *
 * Copyright (c) 1997 Jason R. Thorpe.
 * 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 for the NetBSD Project
 *	by Jason R. Thorpe.
 * 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.
 */

/*
 * Copyright (c) 1983, 1993
 *	The Regents of the University of California.  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.
 * 4. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``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 REGENTS OR CONTRIBUTORS 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.
 */

#include <sys/param.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <sys/sysctl.h>
#include <sys/time.h>

#include <net/if.h>
#include <net/if_dl.h>
#include <net/if_types.h>
#include <net/if_media.h>
#include <net/route.h>

#include <ctype.h>
#include <err.h>
#include <errno.h>
#include <fcntl.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include <libifconfig.h>

#include "ifconfig.h"

static void domediaopt(if_ctx *, const char *, bool);
static ifmedia_t get_media_subtype(ifmedia_t, const char *);
static ifmedia_t get_media_mode(ifmedia_t, const char *);
static ifmedia_t get_media_options(ifmedia_t, const char *);
static void print_media(ifmedia_t, bool);
static void print_media_ifconfig(ifmedia_t);

static void
media_status(if_ctx *ctx)
{
	struct ifmediareq *ifmr;

	if (ifconfig_media_get_mediareq(lifh, ctx->ifname, &ifmr) == -1)
		return;

	if (ifmr->ifm_count == 0) {
		warnx("%s: no media types?", ctx->ifname);
		goto free;
	}

	printf("\tmedia: ");
	print_media(ifmr->ifm_current, true);
	if (ifmr->ifm_active != ifmr->ifm_current) {
		putchar(' ');
		putchar('(');
		print_media(ifmr->ifm_active, false);
		putchar(')');
	}

	putchar('\n');

	if (ifmr->ifm_status & IFM_AVALID) {
		struct ifdownreason ifdr;
		const char *status;

		status = ifconfig_media_get_status(ifmr);
		printf("\tstatus: %s", status);
		if (strcmp(status, "no carrier") == 0 &&
		    ifconfig_media_get_downreason(lifh, ctx->ifname, &ifdr) == 0) {
			switch (ifdr.ifdr_reason) {
			case IFDR_REASON_MSG:
				printf(" (%s)", ifdr.ifdr_msg);
				break;
			case IFDR_REASON_VENDOR:
				printf(" (vendor code %d)",
				    ifdr.ifdr_vendor);
				break;
			default:
				break;
			}
		}
		putchar('\n');
	}

	if (ctx->args->supmedia) {
		printf("\tsupported media:\n");
		for (int i = 0; i < ifmr->ifm_count; ++i) {
			printf("\t\t");
			print_media_ifconfig(ifmr->ifm_ulist[i]);
			putchar('\n');
		}
	}
free:
	free(ifmr);
}

struct ifmediareq *
ifmedia_getstate(if_ctx *ctx)
{
	static struct ifmediareq *ifmr = NULL;

	if (ifmr != NULL)
		return (ifmr);

	if (ifconfig_media_get_mediareq(lifh, ctx->ifname, &ifmr) == -1)
		errc(1, ifconfig_err_errno(lifh),
		    "%s: ifconfig_media_get_mediareq", ctx->ifname);

	if (ifmr->ifm_count == 0)
		errx(1, "%s: no media types?", ctx->ifname);

	return (ifmr);
}

static void
setifmediacallback(if_ctx *ctx, void *arg)
{
	struct ifmediareq *ifmr = (struct ifmediareq *)arg;
	static bool did_it = false;
	struct ifreq ifr = {};

	if (!did_it) {
		ifr.ifr_media = ifmr->ifm_current;
		if (ioctl_ctx_ifr(ctx, SIOCSIFMEDIA, &ifr) < 0)
			err(1, "SIOCSIFMEDIA (media)");
		free(ifmr);
		did_it = true;
	}
}

static void
setmedia(if_ctx *ctx, const char *val, int d __unused)
{
	struct ifmediareq *ifmr;
	int subtype;

	ifmr = ifmedia_getstate(ctx);

	/*
	 * We are primarily concerned with the top-level type.
	 * However, "current" may be only IFM_NONE, so we just look
	 * for the top-level type in the first "supported type"
	 * entry.
	 *
	 * (I'm assuming that all supported media types for a given
	 * interface will be the same top-level type..)
	 */
	subtype = get_media_subtype(ifmr->ifm_ulist[0], val);

	ifmr->ifm_current = (ifmr->ifm_current & IFM_IMASK) |
	    IFM_TYPE(ifmr->ifm_ulist[0]) | subtype;

	callback_register(setifmediacallback, (void *)ifmr);
}

static void
setmediaopt(if_ctx *ctx, const char *val, int d __unused)
{

	domediaopt(ctx, val, false);
}

static void
unsetmediaopt(if_ctx *ctx, const char *val, int d __unused)
{

	domediaopt(ctx, val, true);
}

static void
domediaopt(if_ctx *ctx, const char *val, bool clear)
{
	struct ifmediareq *ifmr;
	ifmedia_t options;

	ifmr = ifmedia_getstate(ctx);

	options = get_media_options(ifmr->ifm_ulist[0], val);

	if (clear)
		ifmr->ifm_current &= ~options;
	else {
		if (options & IFM_HDX) {
			ifmr->ifm_current &= ~IFM_FDX;
			options &= ~IFM_HDX;
		}
		ifmr->ifm_current |= options;
	}
	callback_register(setifmediacallback, (void *)ifmr);
}

static void
setmediainst(if_ctx *ctx, const char *val, int d __unused)
{
	struct ifmediareq *ifmr;
	int inst;

	ifmr = ifmedia_getstate(ctx);

	inst = atoi(val);
	if (inst < 0 || inst > (int)IFM_INST_MAX)
		errx(1, "invalid media instance: %s", val);

	ifmr->ifm_current = (ifmr->ifm_current & ~IFM_IMASK) | inst << IFM_ISHIFT;

	callback_register(setifmediacallback, (void *)ifmr);
}

static void
setmediamode(if_ctx *ctx, const char *val, int d __unused)
{
	struct ifmediareq *ifmr;
	int mode;

	ifmr = ifmedia_getstate(ctx);

	mode = get_media_mode(ifmr->ifm_ulist[0], val);

	ifmr->ifm_current = (ifmr->ifm_current & ~IFM_MMASK) | mode;

	callback_register(setifmediacallback, (void *)ifmr);
}

static ifmedia_t
get_media_subtype(ifmedia_t media, const char *val)
{
	ifmedia_t subtype;

	subtype = ifconfig_media_lookup_subtype(media, val);
	if (subtype != INVALID_IFMEDIA)
		return (subtype);
	switch (errno) {
	case EINVAL:
		errx(EXIT_FAILURE, "unknown media type 0x%x", media);
	case ENOENT:
		errx(EXIT_FAILURE, "unknown media subtype: %s", val);
	default:
		err(EXIT_FAILURE, "ifconfig_media_lookup_subtype");
	}
	/*NOTREACHED*/
}

static ifmedia_t
get_media_mode(ifmedia_t media, const char *val)
{
	ifmedia_t mode;

	mode = ifconfig_media_lookup_mode(media, val);
	if (mode != INVALID_IFMEDIA)
		return (mode);
	switch (errno) {
	case EINVAL:
		errx(EXIT_FAILURE, "unknown media type 0x%x", media);
	case ENOENT:
		return (INVALID_IFMEDIA);
	default:
		err(EXIT_FAILURE, "ifconfig_media_lookup_subtype");
	}
	/*NOTREACHED*/
}

static ifmedia_t
get_media_options(ifmedia_t media, const char *val)
{
	ifmedia_t *options;
	const char **optnames;
	char *opts, *opt;
	size_t nopts;
	int rval;

	/*
	 * We muck with the string, so copy it.
	 */
	opts = strdup(val);
	if (opts == NULL)
		err(EXIT_FAILURE, "strdup");

	/*
	 * Split the comma-delimited list into separate strings.
	 */
	nopts = 0;
	for (opt = opts; (opt = strtok(opt, ",")) != NULL; opt = NULL)
		++nopts;
	if (nopts == 0) {
		free(opts);
		return (0);
	}
	optnames = calloc(nopts, sizeof(*optnames));
	if (optnames == NULL)
		err(EXIT_FAILURE, "calloc");
	opt = opts;
	for (size_t i = 0; i < nopts; ++i) {
		optnames[i] = opt;
		opt = strchr(opt, '\0') + 1;
	}

	/*
	 * Look up the options in the user-provided list.
	 */
	options = ifconfig_media_lookup_options(media, optnames, nopts);
	if (options == NULL)
		err(EXIT_FAILURE, "ifconfig_media_lookup_options");
	rval = 0;
	for (size_t i = 0; i < nopts; ++i) {
		if (options[i] == INVALID_IFMEDIA)
			errx(EXIT_FAILURE, "unknown option: %s", optnames[i]);
		rval |= options[i];
	}
	free(options);
	free(optnames);
	free(opts);
	return (rval);
}

static void
print_media(ifmedia_t media, bool print_toptype)
{
	const char *val, **options;

	val = ifconfig_media_get_type(media);
	if (val == NULL) {
		printf("<unknown type>");
		return;
	} else if (print_toptype) {
		printf("%s", val);
	}

	val = ifconfig_media_get_subtype(media);
	if (val == NULL) {
		printf("<unknown subtype>");
		return;
	}

	if (print_toptype)
		putchar(' ');

	printf("%s", val);

	if (print_toptype) {
		val = ifconfig_media_get_mode(media);
		if (val != NULL && strcasecmp("autoselect", val) != 0)
			printf(" mode %s", val);
	}

	options = ifconfig_media_get_options(media);
	if (options != NULL && options[0] != NULL) {
		printf(" <%s", options[0]);
		for (size_t i = 1; options[i] != NULL; ++i)
			printf(",%s", options[i]);
		printf(">");
	}
	free(options);

	if (print_toptype && IFM_INST(media) != 0)
		printf(" instance %d", IFM_INST(media));
}

static void
print_media_ifconfig(ifmedia_t media)
{
	const char *val, **options;

	val = ifconfig_media_get_type(media);
	if (val == NULL) {
		printf("<unknown type>");
		return;
	}

	/*
	 * Don't print the top-level type; it's not like we can
	 * change it, or anything.
	 */

	val = ifconfig_media_get_subtype(media);
	if (val == NULL) {
		printf("<unknown subtype>");
		return;
	}

	printf("media %s", val);

	val = ifconfig_media_get_mode(media);
	if (val != NULL)
		printf(" mode %s", val);

	options = ifconfig_media_get_options(media);
	if (options != NULL && options[0] != NULL) {
		printf(" mediaopt %s", options[0]);
		for (size_t i = 1; options[i] != NULL; ++i)
			printf(",%s", options[i]);
	}
	free(options);

	if (IFM_INST(media) != 0)
		printf(" instance %d", IFM_INST(media));
}

/**********************************************************************
 * ...until here.
 **********************************************************************/

static struct cmd media_cmds[] = {
	DEF_CMD_ARG("media",	setmedia),
	DEF_CMD_ARG("mode",	setmediamode),
	DEF_CMD_ARG("mediaopt",	setmediaopt),
	DEF_CMD_ARG("-mediaopt",unsetmediaopt),
	DEF_CMD_ARG("inst",	setmediainst),
	DEF_CMD_ARG("instance",	setmediainst),
};
static struct afswtch af_media = {
	.af_name	= "af_media",
	.af_af		= AF_UNSPEC,
	.af_other_status = media_status,
};

static __constructor void
ifmedia_ctor(void)
{
	for (size_t i = 0; i < nitems(media_cmds);  i++)
		cmd_register(&media_cmds[i]);
	af_register(&af_media);
}