reg.c

   1 #include <net/if.h>
   2 #include <errno.h>
   3 #include <string.h>
   4 #include <stdbool.h>
   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
  12 #include "nl80211.h"
  13 #include "iw.h"
  14
  15 SECTION(reg);
  16
  17 #define MHZ_TO_KHZ(freq) ((freq) * 1000)
  18 #define KHZ_TO_MHZ(freq) ((freq) / 1000)
  19 #define DBI_TO_MBI(gain) ((gain) * 100)
  20 #define MBI_TO_DBI(gain) ((gain) / 100)
  21 #define DBM_TO_MBM(gain) ((gain) * 100)
  22 #define MBM_TO_DBM(gain) ((gain) / 100)
  23
  24 static bool isalpha_upper(char letter)
  25 {
  26         if (letter >= 65 && letter <= 90)
  27                 return true;
  28         return false;
  29 }
  30
  31 static bool is_alpha2(char *alpha2)
  32 {
  33         if (isalpha_upper(alpha2[0]) && isalpha_upper(alpha2[1]))
  34                 return true;
  35         return false;
  36 }
  37
  38 static bool is_world_regdom(char *alpha2)
  39 {
  40         /* ASCII 0 */
  41         if (alpha2[0] == 48 && alpha2[1] == 48)
  42                 return true;
  43         return false;
  44 }
  45
  46 char *reg_initiator_to_string(__u8 initiator)
  47 {
  48         switch (initiator) {
  49         case NL80211_REGDOM_SET_BY_CORE:
  50                 return "the wireless core upon initialization";
  51         case NL80211_REGDOM_SET_BY_USER:
  52                 return "a user";
  53         case NL80211_REGDOM_SET_BY_DRIVER:
  54                 return "a driver";
  55         case NL80211_REGDOM_SET_BY_COUNTRY_IE:
  56                 return "a country IE";
  57         default:
  58                 return "BUG";
  59         }
  60 }
  61
  62 static const char *dfs_domain_name(enum nl80211_dfs_regions region)
  63 {
  64         switch (region) {
  65         case NL80211_DFS_UNSET:
  66                 return "DFS-UNSET";
  67         case NL80211_DFS_FCC:
  68                 return "DFS-FCC";
  69         case NL80211_DFS_ETSI:
  70                 return "DFS-ETSI";
  71         case NL80211_DFS_JP:
  72                 return "DFS-JP";
  73         default:
  74                 return "DFS-invalid";
  75         }
  76 }
  77
  78 static int handle_reg_set(struct nl80211_state *state,
  79                           struct nl_cb *cb,
  80                           struct nl_msg *msg,
  81                           int argc, char **argv,
  82                           enum id_input id)
  83 {
  84         char alpha2[3];
  85
  86         if (argc < 1)
  87                 return 1;
  88
  89         if (!is_alpha2(argv[0]) && !is_world_regdom(argv[0])) {
  90                 fprintf(stderr, "not a valid ISO/IEC 3166-1 alpha2\n");
  91                 fprintf(stderr, "Special non-alpha2 usable entries:\n");
  92                 fprintf(stderr, "\t00\tWorld Regulatory domain\n");
  93                 return 2;
  94         }
  95
  96         alpha2[0] = argv[0][0];
  97         alpha2[1] = argv[0][1];
  98         alpha2[2] = '\0';
  99
 100         argc--;
 101         argv++;
 102
 103         if (argc)
 104                 return 1;
 105
 106         NLA_PUT_STRING(msg, NL80211_ATTR_REG_ALPHA2, alpha2);
 107
 108         return 0;
 109  nla_put_failure:
 110         return -ENOBUFS;
 111 }
 112 COMMAND(reg, set, "<ISO/IEC 3166-1 alpha2>",
 113         NL80211_CMD_REQ_SET_REG, 0, CIB_NONE, handle_reg_set,
 114         "Notify the kernel about the current regulatory domain.");
 115
 116 static int print_reg_handler(struct nl_msg *msg, void *arg)
 117 {
 118 #define PARSE_FLAG(nl_flag, string_value)  do { \
 119                 if ((flags & nl_flag)) { \
 120                         printf(", %s", string_value); \
 121                 } \
 122         } while (0)
 123         struct nlattr *tb_msg[NL80211_ATTR_MAX + 1];
 124         struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
 125         char *alpha2;
 126         struct nlattr *nl_rule;
 127         int rem_rule;
 128         enum nl80211_dfs_regions dfs_domain;
 129         static struct nla_policy reg_rule_policy[NL80211_REG_RULE_ATTR_MAX + 1] = {
 130                 [NL80211_ATTR_REG_RULE_FLAGS]           = { .type = NLA_U32 },
 131                 [NL80211_ATTR_FREQ_RANGE_START]         = { .type = NLA_U32 },
 132                 [NL80211_ATTR_FREQ_RANGE_END]           = { .type = NLA_U32 },
 133                 [NL80211_ATTR_FREQ_RANGE_MAX_BW]        = { .type = NLA_U32 },
 134                 [NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN]  = { .type = NLA_U32 },
 135                 [NL80211_ATTR_POWER_RULE_MAX_EIRP]      = { .type = NLA_U32 },
 136                 [NL80211_ATTR_DFS_CAC_TIME]             = { .type = NLA_U32 },
 137         };
 138
 139         nla_parse(tb_msg, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
 140                 genlmsg_attrlen(gnlh, 0), NULL);
 141
 142         if (!tb_msg[NL80211_ATTR_REG_ALPHA2]) {
 143                 printf("No alpha2\n");
 144                 return NL_SKIP;
 145         }
 146
 147         if (!tb_msg[NL80211_ATTR_REG_RULES]) {
 148                 printf("No reg rules\n");
 149                 return NL_SKIP;
 150         }
 151
 152         if (tb_msg[NL80211_ATTR_WIPHY])
 153                 printf("phy#%d%s\n", nla_get_u32(tb_msg[NL80211_ATTR_WIPHY]),
 154                        tb_msg[NL80211_ATTR_WIPHY_SELF_MANAGED_REG] ?
 155                        " (self-managed)" : "");
 156         else
 157                 printf("global\n");
 158
 159         if (tb_msg[NL80211_ATTR_DFS_REGION])
 160                 dfs_domain = nla_get_u8(tb_msg[NL80211_ATTR_DFS_REGION]);
 161         else
 162                 dfs_domain = NL80211_DFS_UNSET;
 163
 164         alpha2 = nla_data(tb_msg[NL80211_ATTR_REG_ALPHA2]);
 165         printf("country %c%c: %s\n", alpha2[0], alpha2[1], dfs_domain_name(dfs_domain));
 166
 167         nla_for_each_nested(nl_rule, tb_msg[NL80211_ATTR_REG_RULES], rem_rule) {
 168                 struct nlattr *tb_rule[NL80211_REG_RULE_ATTR_MAX + 1];
 169                 __u32 flags, start_freq_khz, end_freq_khz, max_bw_khz, max_ant_gain_mbi, max_eirp_mbm;
 170
 171                 nla_parse(tb_rule, NL80211_REG_RULE_ATTR_MAX, nla_data(nl_rule), nla_len(nl_rule), reg_rule_policy);
 172
 173                 flags = nla_get_u32(tb_rule[NL80211_ATTR_REG_RULE_FLAGS]);
 174                 start_freq_khz = nla_get_u32(tb_rule[NL80211_ATTR_FREQ_RANGE_START]);
 175                 end_freq_khz = nla_get_u32(tb_rule[NL80211_ATTR_FREQ_RANGE_END]);
 176                 max_bw_khz = nla_get_u32(tb_rule[NL80211_ATTR_FREQ_RANGE_MAX_BW]);
 177                 max_ant_gain_mbi = nla_get_u32(tb_rule[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN]);
 178                 max_eirp_mbm = nla_get_u32(tb_rule[NL80211_ATTR_POWER_RULE_MAX_EIRP]);
 179
 180
 181                 printf("\t(%d - %d @ %d), (",
 182                         KHZ_TO_MHZ(start_freq_khz), KHZ_TO_MHZ(end_freq_khz), KHZ_TO_MHZ(max_bw_khz));
 183
 184                 if (MBI_TO_DBI(max_ant_gain_mbi))
 185                         printf("%d", MBI_TO_DBI(max_ant_gain_mbi));
 186                 else
 187                         printf("N/A");
 188
 189                 printf(", %d)", MBM_TO_DBM(max_eirp_mbm));
 190
 191                 if ((flags & NL80211_RRF_DFS) && tb_rule[NL80211_ATTR_DFS_CAC_TIME])
 192                         printf(", (%u ms)", nla_get_u32(tb_rule[NL80211_ATTR_DFS_CAC_TIME]));
 193                 else
 194                         printf(", (N/A)");
 195
 196                 if (!flags) {
 197                         printf("\n");
 198                         continue;
 199                 }
 200
 201                 /* Sync this output format to match that of dbparse.py from wireless-regdb.git */
 202                 PARSE_FLAG(NL80211_RRF_NO_OFDM, "NO-OFDM");
 203                 PARSE_FLAG(NL80211_RRF_NO_CCK, "NO-CCK");
 204                 PARSE_FLAG(NL80211_RRF_NO_INDOOR, "NO-INDOOR");
 205                 PARSE_FLAG(NL80211_RRF_NO_OUTDOOR, "NO-OUTDOOR");
 206                 PARSE_FLAG(NL80211_RRF_DFS, "DFS");
 207                 PARSE_FLAG(NL80211_RRF_PTP_ONLY, "PTP-ONLY");
 208                 PARSE_FLAG(NL80211_RRF_AUTO_BW, "AUTO-BW");
 209                 PARSE_FLAG(NL80211_RRF_GO_CONCURRENT, "GO-CONCURRENT");
 210                 PARSE_FLAG(NL80211_RRF_NO_HT40MINUS, "NO-HT40MINUS");
 211                 PARSE_FLAG(NL80211_RRF_NO_HT40PLUS, "NO-HT40PLUS");
 212                 PARSE_FLAG(NL80211_RRF_NO_80MHZ, "NO-80MHZ");
 213                 PARSE_FLAG(NL80211_RRF_NO_160MHZ, "NO-160MHZ");
 214
 215                 /* Kernels that support NO_IR always turn on both flags */
 216                 if ((flags & NL80211_RRF_NO_IR) && (flags & __NL80211_RRF_NO_IBSS)) {
 217                         printf(", NO-IR");
 218                 } else {
 219                         PARSE_FLAG(NL80211_RRF_PASSIVE_SCAN, "PASSIVE-SCAN");
 220                         PARSE_FLAG(__NL80211_RRF_NO_IBSS, "NO-IBSS");
 221                 }
 222
 223                 printf("\n");
 224         }
 225
 226         printf("\n");
 227         return NL_SKIP;
 228 #undef PARSE_FLAG
 229 }
 230
 231 static int handle_reg_dump(struct nl80211_state *state,
 232                            struct nl_cb *cb,
 233                            struct nl_msg *msg,
 234                            int argc, char **argv,
 235                            enum id_input id)
 236 {
 237         nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, print_reg_handler, NULL);
 238         return 0;
 239 }
 240
 241 static int handle_reg_get(struct nl80211_state *state,
 242                           struct nl_cb *cb,
 243                           struct nl_msg *msg,
 244                           int argc, char **argv,
 245                           enum id_input id)
 246 {
 247         char *dump_args[] = { "reg", "dump" };
 248         int err;
 249
 250         err = handle_cmd(state, CIB_NONE, 2, dump_args);
 251         /* dump might fail since it's not supported on older kernels */
 252         if (err == -EOPNOTSUPP) {
 253                 nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, print_reg_handler,
 254                           NULL);
 255                 return 0;
 256         }
 257
 258         return err;
 259 }
 260 COMMAND(reg, get, NULL, NL80211_CMD_GET_REG, 0, CIB_NONE, handle_reg_get,
 261         "Print out the kernel's current regulatory domain information.");
 262 COMMAND(reg, get, NULL, NL80211_CMD_GET_REG, 0, CIB_PHY, handle_reg_get,
 263         "Print out the devices' current regulatory domain information.");
 264 HIDDEN(reg, dump, NULL, NL80211_CMD_GET_REG, NLM_F_DUMP, CIB_NONE,
 265        handle_reg_dump);