[thirdparty/iw.git] / reg.c

#include <net/if.h>
#include <errno.h>
#include <string.h>
#include <stdbool.h>

#include <netlink/genl/genl.h>
#include <netlink/genl/family.h>
#include <netlink/genl/ctrl.h>
#include <netlink/msg.h>
#include <netlink/attr.h>

#include "nl80211.h"
#include "iw.h"

#define MHZ_TO_KHZ(freq) ((freq) * 1000)
#define KHZ_TO_MHZ(freq) ((freq) / 1000)
#define DBI_TO_MBI(gain) ((gain) * 100)
#define MBI_TO_DBI(gain) ((gain) / 100)
#define DBM_TO_MBM(gain) ((gain) * 100)
#define MBM_TO_DBM(gain) ((gain) / 100)

static bool isalpha_upper(char letter)
{
	if (letter >= 65 && letter <= 90)
		return true;
	return false;
}

static bool is_alpha2(char *alpha2)
{
	if (isalpha_upper(alpha2[0]) && isalpha_upper(alpha2[1]))
		return true;
	return false;
}

static bool is_world_regdom(char *alpha2)
{
	/* ASCII 0 */
	if (alpha2[0] == 48 && alpha2[1] == 48)
		return true;
	return false;
}

char *reg_initiator_to_string(__u8 initiator)
{
	switch (initiator) {
	case NL80211_REGDOM_SET_BY_CORE:
		return "the wireless core upon initialization";
	case NL80211_REGDOM_SET_BY_USER:
		return "a user";
	case NL80211_REGDOM_SET_BY_DRIVER:
		return "a driver";
	case NL80211_REGDOM_SET_BY_COUNTRY_IE:
		return "a country IE";
	default:
		return "BUG";
	}
}

static int handle_reg_set(struct nl80211_state *state,
			  struct nl_cb *cb,
			  struct nl_msg *msg,
			  int argc, char **argv)
{
	char alpha2[3];

	if (argc < 1)
		return 1;

	if (!is_alpha2(argv[0]) && !is_world_regdom(argv[0])) {
		fprintf(stderr, "not a valid ISO/IEC 3166-1 alpha2\n");
		fprintf(stderr, "Special non-alpha2 usable entries:\n");
		fprintf(stderr, "\t00\tWorld Regulatory domain\n");
		return 2;
	}

	alpha2[0] = argv[0][0];
	alpha2[1] = argv[0][1];
	alpha2[2] = '\0';

	argc--;
	argv++;

	if (argc)
		return 1;

	NLA_PUT_STRING(msg, NL80211_ATTR_REG_ALPHA2, alpha2);

	return 0;
 nla_put_failure:
	return -ENOBUFS;
}
COMMAND(reg, set, "<ISO/IEC 3166-1 alpha2>",
	NL80211_CMD_REQ_SET_REG, 0, CIB_NONE, handle_reg_set);

static int print_reg_handler(struct nl_msg *msg, void *arg)

{
#define PARSE_FLAG(nl_flag, string_value)  do { \
		if ((flags & nl_flag)) { \
			printf(", %s", string_value); \
		} \
	} while (0)
	struct nlattr *tb_msg[NL80211_ATTR_MAX + 1];
	struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
	char *alpha2;
	struct nlattr *nl_rule;
	int rem_rule;
	static struct nla_policy reg_rule_policy[NL80211_FREQUENCY_ATTR_MAX + 1] = {
		[NL80211_ATTR_REG_RULE_FLAGS]           = { .type = NLA_U32 },
		[NL80211_ATTR_FREQ_RANGE_START]         = { .type = NLA_U32 },
		[NL80211_ATTR_FREQ_RANGE_END]           = { .type = NLA_U32 },
		[NL80211_ATTR_FREQ_RANGE_MAX_BW]        = { .type = NLA_U32 },
		[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN]  = { .type = NLA_U32 },
		[NL80211_ATTR_POWER_RULE_MAX_EIRP]      = { .type = NLA_U32 },
	};

	nla_parse(tb_msg, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
		genlmsg_attrlen(gnlh, 0), NULL);

	if (!tb_msg[NL80211_ATTR_REG_ALPHA2]) {
		printf("No alpha2\n");
		return NL_SKIP;
	}

	if (!tb_msg[NL80211_ATTR_REG_RULES]) {
		printf("No reg rules\n");
		return NL_SKIP;
	}

	alpha2 = nla_data(tb_msg[NL80211_ATTR_REG_ALPHA2]);
	printf("country %s:\n", alpha2);

	nla_for_each_nested(nl_rule, tb_msg[NL80211_ATTR_REG_RULES], rem_rule) {
		struct nlattr *tb_rule[NL80211_FREQUENCY_ATTR_MAX + 1];
		__u32 flags, start_freq_khz, end_freq_khz, max_bw_khz, max_ant_gain_mbi, max_eirp_mbm;

		nla_parse(tb_rule, NL80211_FREQUENCY_ATTR_MAX, nla_data(nl_rule), nla_len(nl_rule), reg_rule_policy);

		flags = nla_get_u32(tb_rule[NL80211_ATTR_REG_RULE_FLAGS]);
		start_freq_khz = nla_get_u32(tb_rule[NL80211_ATTR_FREQ_RANGE_START]);
		end_freq_khz = nla_get_u32(tb_rule[NL80211_ATTR_FREQ_RANGE_END]);
		max_bw_khz = nla_get_u32(tb_rule[NL80211_ATTR_FREQ_RANGE_MAX_BW]);
		max_ant_gain_mbi = nla_get_u32(tb_rule[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN]);
		max_eirp_mbm = nla_get_u32(tb_rule[NL80211_ATTR_POWER_RULE_MAX_EIRP]);


		printf("\t(%d - %d @ %d), (",
			KHZ_TO_MHZ(start_freq_khz), KHZ_TO_MHZ(end_freq_khz), KHZ_TO_MHZ(max_bw_khz));

		if (MBI_TO_DBI(max_ant_gain_mbi))
			printf("%d", MBI_TO_DBI(max_ant_gain_mbi));
		else
			printf("N/A");

		printf(", %d)", MBM_TO_DBM(max_eirp_mbm));

		if (!flags) {
			printf("\n");
			continue;
		}

		/* Sync this output format to match that of dbparse.py from wireless-regdb.git */
		PARSE_FLAG(NL80211_RRF_NO_OFDM, "NO-OFDM");
		PARSE_FLAG(NL80211_RRF_NO_CCK, "NO-CCK");
		PARSE_FLAG(NL80211_RRF_NO_INDOOR, "NO-INDOOR");
		PARSE_FLAG(NL80211_RRF_NO_OUTDOOR, "NO-OUTDOOR");
		PARSE_FLAG(NL80211_RRF_DFS, "DFS");
		PARSE_FLAG(NL80211_RRF_PTP_ONLY, "PTP-ONLY");
		PARSE_FLAG(NL80211_RRF_PASSIVE_SCAN, "PASSIVE-SCAN");
		PARSE_FLAG(NL80211_RRF_NO_IBSS, "NO-IBSS");

		printf("\n");
	}
	return NL_OK;
#undef PARSE_FLAG
}

static int handle_reg_get(struct nl80211_state *state,
			  struct nl_cb *cb,
			  struct nl_msg *msg,
			  int argc, char **argv)
{
	nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, print_reg_handler, NULL);
	return 0;
}
COMMAND(reg, get, NULL, NL80211_CMD_GET_REG, 0, CIB_NONE, handle_reg_get);
Commit	Line	Data
14a0380d LR	1	#include <net/if.h>
	2	#include <errno.h>
	3	#include <string.h>
ffc08bcb	4	#include <stdbool.h>
14a0380d LR	5
	6	#include <netlink/genl/genl.h>
	7	#include <netlink/genl/family.h>
	8	#include <netlink/genl/ctrl.h>
	9	#include <netlink/msg.h>
	10	#include <netlink/attr.h>
	11
f408e01b	12	#include "nl80211.h"
14a0380d LR	13	#include "iw.h"
14a0380d LR	14
7ab65227 LR	15	#define MHZ_TO_KHZ(freq) ((freq) * 1000)
	16	#define KHZ_TO_MHZ(freq) ((freq) / 1000)
	17	#define DBI_TO_MBI(gain) ((gain) * 100)
	18	#define MBI_TO_DBI(gain) ((gain) / 100)
	19	#define DBM_TO_MBM(gain) ((gain) * 100)
	20	#define MBM_TO_DBM(gain) ((gain) / 100)
	21
ffc08bcb	22	static bool isalpha_upper(char letter)
14a0380d LR	23	{
14a0380d LR	24	if (letter >= 65 && letter <= 90)
ffc08bcb LR	25	return true;
ffc08bcb LR	26	return false;
14a0380d LR	27	}
14a0380d LR	28
ffc08bcb	29	static bool is_alpha2(char *alpha2)
14a0380d LR	30	{
14a0380d LR	31	if (isalpha_upper(alpha2[0]) && isalpha_upper(alpha2[1]))
ffc08bcb LR	32	return true;
ffc08bcb LR	33	return false;
14a0380d LR	34	}
14a0380d LR	35
ffc08bcb	36	static bool is_world_regdom(char *alpha2)
14a0380d LR	37	{
	38	/* ASCII 0 */
	39	if (alpha2[0] == 48 && alpha2[1] == 48)
ffc08bcb LR	40	return true;
ffc08bcb LR	41	return false;
14a0380d LR	42	}
14a0380d LR	43
601c6ab2 LR	44	char *reg_initiator_to_string(__u8 initiator)
	45	{
	46	switch (initiator) {
	47	case NL80211_REGDOM_SET_BY_CORE:
	48	return "the wireless core upon initialization";
	49	case NL80211_REGDOM_SET_BY_USER:
	50	return "a user";
	51	case NL80211_REGDOM_SET_BY_DRIVER:
	52	return "a driver";
	53	case NL80211_REGDOM_SET_BY_COUNTRY_IE:
	54	return "a country IE";
	55	default:
	56	return "BUG";
	57	}
	58	}
	59
7c37a24d JB	60	static int handle_reg_set(struct nl80211_state *state,
7c37a24d JB	61	struct nl_cb *cb,
1c05c109 JB	62	struct nl_msg *msg,
1c05c109 JB	63	int argc, char **argv)
14a0380d	64	{
14a0380d LR	65	char alpha2[3];
14a0380d LR	66
1c05c109	67	if (argc < 1)
5e75fd04	68	return 1;
14a0380d LR	69
	70	if (!is_alpha2(argv[0]) && !is_world_regdom(argv[0])) {
	71	fprintf(stderr, "not a valid ISO/IEC 3166-1 alpha2\n");
40ffa988	72	fprintf(stderr, "Special non-alpha2 usable entries:\n");
14a0380d	73	fprintf(stderr, "\t00\tWorld Regulatory domain\n");
5e75fd04	74	return 2;
14a0380d LR	75	}
	76
	77	alpha2[0] = argv[0][0];
	78	alpha2[1] = argv[0][1];
	79	alpha2[2] = '\0';
	80
	81	argc--;
	82	argv++;
	83
1c05c109	84	if (argc)
5e75fd04	85	return 1;
14a0380d LR	86
	87	NLA_PUT_STRING(msg, NL80211_ATTR_REG_ALPHA2, alpha2);
	88
70391ccf	89	return 0;
14a0380d	90	nla_put_failure:
70391ccf	91	return -ENOBUFS;
14a0380d	92	}
1c05c109 JB	93	COMMAND(reg, set, "<ISO/IEC 3166-1 alpha2>",
1c05c109 JB	94	NL80211_CMD_REQ_SET_REG, 0, CIB_NONE, handle_reg_set);
7ab65227 LR	95
	96	static int print_reg_handler(struct nl_msg msg, void arg)
	97
	98	{
	99	#define PARSE_FLAG(nl_flag, string_value) do { \
	100	if ((flags & nl_flag)) { \
	101	printf(", %s", string_value); \
	102	} \
	103	} while (0)
	104	struct nlattr *tb_msg[NL80211_ATTR_MAX + 1];
	105	struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
	106	char *alpha2;
	107	struct nlattr *nl_rule;
	108	int rem_rule;
	109	static struct nla_policy reg_rule_policy[NL80211_FREQUENCY_ATTR_MAX + 1] = {
	110	[NL80211_ATTR_REG_RULE_FLAGS] = { .type = NLA_U32 },
	111	[NL80211_ATTR_FREQ_RANGE_START] = { .type = NLA_U32 },
	112	[NL80211_ATTR_FREQ_RANGE_END] = { .type = NLA_U32 },
	113	[NL80211_ATTR_FREQ_RANGE_MAX_BW] = { .type = NLA_U32 },
	114	[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN] = { .type = NLA_U32 },
	115	[NL80211_ATTR_POWER_RULE_MAX_EIRP] = { .type = NLA_U32 },
	116	};
	117
	118	nla_parse(tb_msg, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
	119	genlmsg_attrlen(gnlh, 0), NULL);
	120
	121	if (!tb_msg[NL80211_ATTR_REG_ALPHA2]) {
	122	printf("No alpha2\n");
	123	return NL_SKIP;
	124	}
	125
	126	if (!tb_msg[NL80211_ATTR_REG_RULES]) {
	127	printf("No reg rules\n");
	128	return NL_SKIP;
	129	}
	130
	131	alpha2 = nla_data(tb_msg[NL80211_ATTR_REG_ALPHA2]);
	132	printf("country %s:\n", alpha2);
	133
	134	nla_for_each_nested(nl_rule, tb_msg[NL80211_ATTR_REG_RULES], rem_rule) {
	135	struct nlattr *tb_rule[NL80211_FREQUENCY_ATTR_MAX + 1];
	136	__u32 flags, start_freq_khz, end_freq_khz, max_bw_khz, max_ant_gain_mbi, max_eirp_mbm;
	137
	138	nla_parse(tb_rule, NL80211_FREQUENCY_ATTR_MAX, nla_data(nl_rule), nla_len(nl_rule), reg_rule_policy);
	139
	140	flags = nla_get_u32(tb_rule[NL80211_ATTR_REG_RULE_FLAGS]);
	141	start_freq_khz = nla_get_u32(tb_rule[NL80211_ATTR_FREQ_RANGE_START]);
	142	end_freq_khz = nla_get_u32(tb_rule[NL80211_ATTR_FREQ_RANGE_END]);
	143	max_bw_khz = nla_get_u32(tb_rule[NL80211_ATTR_FREQ_RANGE_MAX_BW]);
	144	max_ant_gain_mbi = nla_get_u32(tb_rule[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN]);
	145	max_eirp_mbm = nla_get_u32(tb_rule[NL80211_ATTR_POWER_RULE_MAX_EIRP]);
	146
	147
	148	printf("\t(%d - %d @ %d), (",
	149	KHZ_TO_MHZ(start_freq_khz), KHZ_TO_MHZ(end_freq_khz), KHZ_TO_MHZ(max_bw_khz));
	150
	151	if (MBI_TO_DBI(max_ant_gain_mbi))
	152	printf("%d", MBI_TO_DBI(max_ant_gain_mbi));
	153	else
	154	printf("N/A");
	155
	156	printf(", %d)", MBM_TO_DBM(max_eirp_mbm));
	157
	158	if (!flags) {
159	printf("\n");
160	continue;
161	}
162
163	/* Sync this output format to match that of dbparse.py from wireless-regdb.git */
164	PARSE_FLAG(NL80211_RRF_NO_OFDM, "NO-OFDM");
165	PARSE_FLAG(NL80211_RRF_NO_CCK, "NO-CCK");
166	PARSE_FLAG(NL80211_RRF_NO_INDOOR, "NO-INDOOR");
167	PARSE_FLAG(NL80211_RRF_NO_OUTDOOR, "NO-OUTDOOR");
168	PARSE_FLAG(NL80211_RRF_DFS, "DFS");
169	PARSE_FLAG(NL80211_RRF_PTP_ONLY, "PTP-ONLY");
170	PARSE_FLAG(NL80211_RRF_PASSIVE_SCAN, "PASSIVE-SCAN");
171	PARSE_FLAG(NL80211_RRF_NO_IBSS, "NO-IBSS");
172
173	printf("\n");
174	}
175	return NL_OK;
176	#undef PARSE_FLAG
177	}
178
7c37a24d JB	179	static int handle_reg_get(struct nl80211_state *state,
7c37a24d JB	180	struct nl_cb *cb,
7ab65227 LR	181	struct nl_msg *msg,
	182	int argc, char **argv)
	183	{
	184	nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, print_reg_handler, NULL);
	185	return 0;
	186	}
	187	COMMAND(reg, get, NULL, NL80211_CMD_GET_REG, 0, CIB_NONE, handle_reg_get);