[mirror_iproute2.git] / lib / color.c

/* SPDX-License-Identifier: GPL-2.0 */
#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <linux/if.h>

#include "color.h"

enum color {
	C_RED,
	C_GREEN,
	C_YELLOW,
	C_BLUE,
	C_MAGENTA,
	C_CYAN,
	C_WHITE,
	C_BOLD_RED,
	C_BOLD_GREEN,
	C_BOLD_YELLOW,
	C_BOLD_BLUE,
	C_BOLD_MAGENTA,
	C_BOLD_CYAN,
	C_BOLD_WHITE,
	C_CLEAR
};

static const char * const color_codes[] = {
	"\e[31m",
	"\e[32m",
	"\e[33m",
	"\e[34m",
	"\e[35m",
	"\e[36m",
	"\e[37m",
	"\e[1;31m",
	"\e[1;32m",
	"\e[1;33m",
	"\e[1;34m",
	"\e[1;35m",
	"\e[1;36m",
	"\e[1;37m",
	"\e[0m",
	NULL,
};

/* light background */
static enum color attr_colors_light[] = {
	C_CYAN,
	C_YELLOW,
	C_MAGENTA,
	C_BLUE,
	C_GREEN,
	C_RED,
	C_CLEAR,
};

/* dark background */
static enum color attr_colors_dark[] = {
	C_BOLD_CYAN,
	C_BOLD_YELLOW,
	C_BOLD_MAGENTA,
	C_BOLD_BLUE,
	C_BOLD_GREEN,
	C_BOLD_RED,
	C_CLEAR
};

static int is_dark_bg;
static int color_is_enabled;

void enable_color(void)
{
	color_is_enabled = 1;
	set_color_palette();
}

void set_color_palette(void)
{
	char *p = getenv("COLORFGBG");

	/*
	 * COLORFGBG environment variable usually contains either two or three
	 * values separated by semicolons; we want the last value in either case.
	 * If this value is 0-6 or 8, background is dark.
	 */
	if (p && (p = strrchr(p, ';')) != NULL
		&& ((p[1] >= '0' && p[1] <= '6') || p[1] == '8')
		&& p[2] == '\0')
		is_dark_bg = 1;
}

void check_if_color_enabled(void)
{
	if (color_is_enabled) {
		fprintf(stderr, "Option \"-json\" conflicts with \"-color\".\n");
		exit(1);
	}
}

int color_fprintf(FILE *fp, enum color_attr attr, const char *fmt, ...)
{
	int ret = 0;
	va_list args;

	va_start(args, fmt);

	if (!color_is_enabled || attr == COLOR_NONE) {
		ret = vfprintf(fp, fmt, args);
		goto end;
	}

	ret += fprintf(fp, "%s", color_codes[is_dark_bg ?
		attr_colors_dark[attr] : attr_colors_light[attr]]);

	ret += vfprintf(fp, fmt, args);
	ret += fprintf(fp, "%s", color_codes[C_CLEAR]);

end:
	va_end(args);
	return ret;
}

enum color_attr ifa_family_color(__u8 ifa_family)
{
	switch (ifa_family) {
	case AF_INET:
		return COLOR_INET;
	case AF_INET6:
		return COLOR_INET6;
	default:
		return COLOR_NONE;
	}
}

enum color_attr oper_state_color(__u8 state)
{
	switch (state) {
	case IF_OPER_UP:
		return COLOR_OPERSTATE_UP;
	case IF_OPER_DOWN:
		return COLOR_OPERSTATE_DOWN;
	default:
		return COLOR_NONE;
	}
}
Commit	Line	Data
6054c1eb	1	/* SPDX-License-Identifier: GPL-2.0 */
d7bd2db5 MN	2	#include <stdio.h>
d7bd2db5 MN	3	#include <stdarg.h>
54eab4c7 PV	4	#include <stdlib.h>
54eab4c7 PV	5	#include <string.h>
a1121aa1 PS	6	#include <sys/socket.h>
	7	#include <sys/types.h>
	8	#include <linux/if.h>
d7bd2db5 MN	9
	10	#include "color.h"
	11
	12	enum color {
	13	C_RED,
	14	C_GREEN,
	15	C_YELLOW,
	16	C_BLUE,
	17	C_MAGENTA,
	18	C_CYAN,
	19	C_WHITE,
54eab4c7 PV	20	C_BOLD_RED,
	21	C_BOLD_GREEN,
	22	C_BOLD_YELLOW,
	23	C_BOLD_BLUE,
	24	C_BOLD_MAGENTA,
	25	C_BOLD_CYAN,
	26	C_BOLD_WHITE,
d7bd2db5 MN	27	C_CLEAR
	28	};
	29
	30	static const char * const color_codes[] = {
	31	"\e[31m",
	32	"\e[32m",
	33	"\e[33m",
	34	"\e[34m",
	35	"\e[35m",
	36	"\e[36m",
	37	"\e[37m",
54eab4c7 PV	38	"\e[1;31m",
	39	"\e[1;32m",
	40	"\e[1;33m",
	41	"\e[1;34m",
	42	"\e[1;35m",
	43	"\e[1;36m",
	44	"\e[1;37m",
d7bd2db5 MN	45	"\e[0m",
	46	NULL,
	47	};
	48
99b89c51 PV	49	/* light background */
99b89c51 PV	50	static enum color attr_colors_light[] = {
d7bd2db5 MN	51	C_CYAN,
	52	C_YELLOW,
	53	C_MAGENTA,
	54	C_BLUE,
	55	C_GREEN,
a1121aa1	56	C_RED,
54eab4c7	57	C_CLEAR,
99b89c51	58	};
54eab4c7	59
99b89c51 PV	60	/* dark background */
99b89c51 PV	61	static enum color attr_colors_dark[] = {
54eab4c7 PV	62	C_BOLD_CYAN,
	63	C_BOLD_YELLOW,
	64	C_BOLD_MAGENTA,
	65	C_BOLD_BLUE,
	66	C_BOLD_GREEN,
	67	C_BOLD_RED,
a1121aa1	68	C_CLEAR
d7bd2db5 MN	69	};
d7bd2db5 MN	70
54eab4c7	71	static int is_dark_bg;
d7bd2db5 MN	72	static int color_is_enabled;
	73
	74	void enable_color(void)
	75	{
	76	color_is_enabled = 1;
54eab4c7 PV	77	set_color_palette();
	78	}
	79
	80	void set_color_palette(void)
	81	{
	82	char *p = getenv("COLORFGBG");
	83
	84	/*
	85	* COLORFGBG environment variable usually contains either two or three
	86	* values separated by semicolons; we want the last value in either case.
	87	* If this value is 0-6 or 8, background is dark.
	88	*/
	89	if (p && (p = strrchr(p, ';')) != NULL
	90	&& ((p[1] >= '0' && p[1] <= '6') \|\| p[1] == '8')
	91	&& p[2] == '\0')
	92	is_dark_bg = 1;
d7bd2db5 MN	93	}
d7bd2db5 MN	94
959f1428 JF	95	void check_if_color_enabled(void)
	96	{
	97	if (color_is_enabled) {
	98	fprintf(stderr, "Option \"-json\" conflicts with \"-color\".\n");
	99	exit(1);
	100	}
	101	}
	102
d7bd2db5 MN	103	int color_fprintf(FILE fp, enum color_attr attr, const char fmt, ...)
	104	{
	105	int ret = 0;
	106	va_list args;
	107
	108	va_start(args, fmt);
	109
4b73d52f	110	if (!color_is_enabled \|\| attr == COLOR_NONE) {
d7bd2db5 MN	111	ret = vfprintf(fp, fmt, args);
	112	goto end;
	113	}
	114
99b89c51 PV	115	ret += fprintf(fp, "%s", color_codes[is_dark_bg ?
	116	attr_colors_dark[attr] : attr_colors_light[attr]]);
	117
d7bd2db5 MN	118	ret += vfprintf(fp, fmt, args);
	119	ret += fprintf(fp, "%s", color_codes[C_CLEAR]);
	120
	121	end:
	122	va_end(args);
	123	return ret;
	124	}
a1121aa1 PS	125
	126	enum color_attr ifa_family_color(__u8 ifa_family)
	127	{
	128	switch (ifa_family) {
	129	case AF_INET:
	130	return COLOR_INET;
	131	case AF_INET6:
	132	return COLOR_INET6;
	133	default:
4b73d52f	134	return COLOR_NONE;
a1121aa1 PS	135	}
	136	}
	137
	138	enum color_attr oper_state_color(__u8 state)
	139	{
	140	switch (state) {
	141	case IF_OPER_UP:
	142	return COLOR_OPERSTATE_UP;
	143	case IF_OPER_DOWN:
	144	return COLOR_OPERSTATE_DOWN;
	145	default:
4b73d52f	146	return COLOR_NONE;
a1121aa1 PS	147	}
a1121aa1 PS	148	}