X-Git-Url: http://git.ipfire.org/?a=blobdiff_plain;f=reg.c;h=a2368df390099dec5167c0376a7c884d6aa950a2;hb=47650ff8534f18e5a38a7d4098311aef4bd282f3;hp=e8d46a5309bc8d40895141e8d2c07c5e4f9af169;hpb=f408e01bbe5d3e25f909edffe4054513fb51d703;p=thirdparty%2Fiw.git diff --git a/reg.c b/reg.c index e8d46a5..a2368df 100644 --- a/reg.c +++ b/reg.c @@ -1,6 +1,6 @@ -#include #include #include +#include #include #include @@ -11,31 +11,73 @@ #include "nl80211.h" #include "iw.h" -int isalpha_upper(char letter) +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 1; - return 0; + return true; + return false; } -static int is_alpha2(char *alpha2) +static bool is_alpha2(char *alpha2) { if (isalpha_upper(alpha2[0]) && isalpha_upper(alpha2[1])) - return 1; - return 0; + return true; + return false; } -static int is_world_regdom(char *alpha2) +static bool is_world_regdom(char *alpha2) { /* ASCII 0 */ if (alpha2[0] == 48 && alpha2[1] == 48) - return 1; - return 0; + 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 nl_cb *cb, +static int handle_reg_set(struct nl80211_state *state, struct nl_msg *msg, - int argc, char **argv) + int argc, char **argv, + enum id_input id) { char alpha2[3]; @@ -66,4 +108,164 @@ static int handle_reg_set(struct nl_cb *cb, return -ENOBUFS; } COMMAND(reg, set, "", - NL80211_CMD_REQ_SET_REG, 0, CIB_NONE, handle_reg_set); + 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_IR_CONCURRENT, "IR-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_msg *msg, + int argc, char **argv, + enum id_input id) +{ + register_handler(print_reg_handler, NULL); + return 0; +} + +static int handle_reg_get(struct nl80211_state *state, + struct nl_msg *msg, + int argc, char **argv, + enum id_input id) +{ + char *dump_args[] = { "reg", "dump" }; + int err; + + err = handle_cmd(state, II_NONE, 2, dump_args); + /* + * dump might fail since it's not supported on older kernels, + * in that case the handler is still registered already + */ + if (err == -EOPNOTSUPP) + return 0; + + return err ?: HANDLER_RET_DONE; +} +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); + +static int handle_reg_reload(struct nl80211_state *state, + struct nl_msg *msg, + int argc, char **argv, + enum id_input id) +{ + return 0; +} +COMMAND(reg, reload, NULL, NL80211_CMD_RELOAD_REGDB, 0, CIB_NONE, + handle_reg_reload, "Reload the kernel's regulatory database.");