You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
266 lines
7.2 KiB
266 lines
7.2 KiB
#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"
|
|
|
|
SECTION(reg);
|
|
|
|
#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 const char *dfs_domain_name(enum nl80211_dfs_regions region)
|
|
{
|
|
switch (region) {
|
|
case NL80211_DFS_UNSET:
|
|
return "DFS-UNSET";
|
|
case NL80211_DFS_FCC:
|
|
return "DFS-FCC";
|
|
case NL80211_DFS_ETSI:
|
|
return "DFS-ETSI";
|
|
case NL80211_DFS_JP:
|
|
return "DFS-JP";
|
|
default:
|
|
return "DFS-invalid";
|
|
}
|
|
}
|
|
|
|
static int handle_reg_set(struct nl80211_state *state,
|
|
struct nl_cb *cb,
|
|
struct nl_msg *msg,
|
|
int argc, char **argv,
|
|
enum id_input id)
|
|
{
|
|
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,
|
|
"Notify the kernel about the current regulatory domain.");
|
|
|
|
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;
|
|
enum nl80211_dfs_regions dfs_domain;
|
|
static struct nla_policy reg_rule_policy[NL80211_REG_RULE_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 },
|
|
[NL80211_ATTR_DFS_CAC_TIME] = { .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;
|
|
}
|
|
|
|
if (tb_msg[NL80211_ATTR_WIPHY])
|
|
printf("phy#%d%s\n", nla_get_u32(tb_msg[NL80211_ATTR_WIPHY]),
|
|
tb_msg[NL80211_ATTR_WIPHY_SELF_MANAGED_REG] ?
|
|
" (self-managed)" : "");
|
|
else
|
|
printf("global\n");
|
|
|
|
if (tb_msg[NL80211_ATTR_DFS_REGION])
|
|
dfs_domain = nla_get_u8(tb_msg[NL80211_ATTR_DFS_REGION]);
|
|
else
|
|
dfs_domain = NL80211_DFS_UNSET;
|
|
|
|
alpha2 = nla_data(tb_msg[NL80211_ATTR_REG_ALPHA2]);
|
|
printf("country %c%c: %s\n", alpha2[0], alpha2[1], dfs_domain_name(dfs_domain));
|
|
|
|
nla_for_each_nested(nl_rule, tb_msg[NL80211_ATTR_REG_RULES], rem_rule) {
|
|
struct nlattr *tb_rule[NL80211_REG_RULE_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_REG_RULE_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 & NL80211_RRF_DFS) && tb_rule[NL80211_ATTR_DFS_CAC_TIME])
|
|
printf(", (%u ms)", nla_get_u32(tb_rule[NL80211_ATTR_DFS_CAC_TIME]));
|
|
else
|
|
printf(", (N/A)");
|
|
|
|
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_AUTO_BW, "AUTO-BW");
|
|
PARSE_FLAG(NL80211_RRF_GO_CONCURRENT, "GO-CONCURRENT");
|
|
PARSE_FLAG(NL80211_RRF_NO_HT40MINUS, "NO-HT40MINUS");
|
|
PARSE_FLAG(NL80211_RRF_NO_HT40PLUS, "NO-HT40PLUS");
|
|
PARSE_FLAG(NL80211_RRF_NO_80MHZ, "NO-80MHZ");
|
|
PARSE_FLAG(NL80211_RRF_NO_160MHZ, "NO-160MHZ");
|
|
|
|
/* Kernels that support NO_IR always turn on both flags */
|
|
if ((flags & NL80211_RRF_NO_IR) && (flags & __NL80211_RRF_NO_IBSS)) {
|
|
printf(", NO-IR");
|
|
} else {
|
|
PARSE_FLAG(NL80211_RRF_PASSIVE_SCAN, "PASSIVE-SCAN");
|
|
PARSE_FLAG(__NL80211_RRF_NO_IBSS, "NO-IBSS");
|
|
}
|
|
|
|
printf("\n");
|
|
}
|
|
|
|
printf("\n");
|
|
return NL_SKIP;
|
|
#undef PARSE_FLAG
|
|
}
|
|
|
|
static int handle_reg_dump(struct nl80211_state *state,
|
|
struct nl_cb *cb,
|
|
struct nl_msg *msg,
|
|
int argc, char **argv,
|
|
enum id_input id)
|
|
{
|
|
nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, print_reg_handler, NULL);
|
|
return 0;
|
|
}
|
|
|
|
static int handle_reg_get(struct nl80211_state *state,
|
|
struct nl_cb *cb,
|
|
struct nl_msg *msg,
|
|
int argc, char **argv,
|
|
enum id_input id)
|
|
{
|
|
char *dump_args[] = { "reg", "dump" };
|
|
int err;
|
|
|
|
err = handle_cmd(state, CIB_NONE, 2, dump_args);
|
|
/* dump might fail since it's not supported on older kernels */
|
|
if (err == -EOPNOTSUPP) {
|
|
nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, print_reg_handler,
|
|
NULL);
|
|
return 0;
|
|
}
|
|
|
|
return err;
|
|
}
|
|
COMMAND(reg, get, NULL, NL80211_CMD_GET_REG, 0, CIB_NONE, handle_reg_get,
|
|
"Print out the kernel's current regulatory domain information.");
|
|
COMMAND(reg, get, NULL, NL80211_CMD_GET_REG, 0, CIB_PHY, handle_reg_get,
|
|
"Print out the devices' current regulatory domain information.");
|
|
HIDDEN(reg, dump, NULL, NL80211_CMD_GET_REG, NLM_F_DUMP, CIB_NONE,
|
|
handle_reg_dump);
|