WebSVN – nexmon – Blame – Rev 1

1

office

1

#include <stdbool.h>

2

#include <errno.h>

3

#include <net/if.h>

4

5

#include <netlink/genl/genl.h>

6

#include <netlink/genl/family.h>

7

#include <netlink/genl/ctrl.h>

8

#include <netlink/msg.h>

9

#include <netlink/attr.h>

10

11

#include "nl80211.h"

12

#include "iw.h"

13

14

static void print_flag(const char *name, int *open)

{

if (!*open)

printf(" (");

else

printf(", ");

printf("%s", name);

*open = 1;

}

static char *cipher_name(__u32 c)

25

{

26

static char buf[20];

switch (c) {

case 0x000fac01:

return "WEP40 (00-0f-ac:1)";

31

case 0x000fac05:

32

return "WEP104 (00-0f-ac:5)";

33

case 0x000fac02:

34

return "TKIP (00-0f-ac:2)";

35

case 0x000fac04:

36

return "CCMP (00-0f-ac:4)";

37

case 0x000fac06:

38

return "CMAC (00-0f-ac:6)";

39

case 0x000fac08:

40

return "GCMP (00-0f-ac:8)";

41

case 0x00147201:

42

return "WPI-SMS4 (00-14-72:1)";

43

default:

44

sprintf(buf, "%.2x-%.2x-%.2x:%d",

45

c >> 24, (c >> 16) & 0xff,

46

(c >> 8) & 0xff, c & 0xff);

return buf;

}

}

static char *dfs_state_name(enum nl80211_dfs_state state)

53

{

54

switch (state) {

55

case NL80211_DFS_USABLE:

56

return "usable";

57

case NL80211_DFS_AVAILABLE:

58

return "available";

59

case NL80211_DFS_UNAVAILABLE:

60

return "unavailable";

default:

return "unknown";

}

}

static int ext_feature_isset(const unsigned char *ext_features, int ext_features_len,

67

enum nl80211_ext_feature_index ftidx)

68

{

69

unsigned char ft_byte;

70

71

if ((int) ftidx / 8 >= ext_features_len)

72

return 0;

73

74

ft_byte = ext_features[ftidx / 8];

75

return (ft_byte & BIT(ftidx % 8)) != 0;

76

}

77

78

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

79

{

80

struct nlattr *tb_msg[NL80211_ATTR_MAX + 1];

81

struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));

82

83

struct nlattr *tb_band[NL80211_BAND_ATTR_MAX + 1];

84

85

struct nlattr *tb_freq[NL80211_FREQUENCY_ATTR_MAX + 1];

86

static struct nla_policy freq_policy[NL80211_FREQUENCY_ATTR_MAX + 1] = {

87

[NL80211_FREQUENCY_ATTR_FREQ] = { .type = NLA_U32 },

88

[NL80211_FREQUENCY_ATTR_DISABLED] = { .type = NLA_FLAG },

89

[NL80211_FREQUENCY_ATTR_NO_IR] = { .type = NLA_FLAG },

90

[__NL80211_FREQUENCY_ATTR_NO_IBSS] = { .type = NLA_FLAG },

91

[NL80211_FREQUENCY_ATTR_RADAR] = { .type = NLA_FLAG },

92

[NL80211_FREQUENCY_ATTR_MAX_TX_POWER] = { .type = NLA_U32 },

93

};

94

95

struct nlattr *tb_rate[NL80211_BITRATE_ATTR_MAX + 1];

96

static struct nla_policy rate_policy[NL80211_BITRATE_ATTR_MAX + 1] = {

97

[NL80211_BITRATE_ATTR_RATE] = { .type = NLA_U32 },

98

[NL80211_BITRATE_ATTR_2GHZ_SHORTPREAMBLE] = { .type = NLA_FLAG },

99

};

100

101

struct nlattr *nl_band;

102

struct nlattr *nl_freq;

103

struct nlattr *nl_rate;

104

struct nlattr *nl_mode;

105

struct nlattr *nl_cmd;

106

struct nlattr *nl_if, *nl_ftype;

107

int rem_band, rem_freq, rem_rate, rem_mode, rem_cmd, rem_ftype, rem_if;

108

int open;

109

/*

110

* static variables only work here, other applications need to use the

111

* callback pointer and store them there so they can be multithreaded

112

* and/or have multiple netlink sockets, etc.

113

*/

114

static int64_t phy_id = -1;

115

static int last_band = -1;

116

static bool band_had_freq = false;

117

bool print_name = true;

118

119

nla_parse(tb_msg, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),

120

genlmsg_attrlen(gnlh, 0), NULL);

121

122

if (tb_msg[NL80211_ATTR_WIPHY]) {

123

if (nla_get_u32(tb_msg[NL80211_ATTR_WIPHY]) == phy_id)

124

print_name = false;

125

else

126

last_band = -1;

127

phy_id = nla_get_u32(tb_msg[NL80211_ATTR_WIPHY]);

128

}

129

if (print_name && tb_msg[NL80211_ATTR_WIPHY_NAME])

130

printf("Wiphy %s\n", nla_get_string(tb_msg[NL80211_ATTR_WIPHY_NAME]));

131

132

/* needed for split dump */

133

if (tb_msg[NL80211_ATTR_WIPHY_BANDS]) {

134

nla_for_each_nested(nl_band, tb_msg[NL80211_ATTR_WIPHY_BANDS], rem_band) {

135

if (last_band != nl_band->nla_type) {

136

printf("\tBand %d:\n", nl_band->nla_type + 1);

137

band_had_freq = false;

138

}

139

last_band = nl_band->nla_type;

140

141

nla_parse(tb_band, NL80211_BAND_ATTR_MAX, nla_data(nl_band),

142

nla_len(nl_band), NULL);

143

144

if (tb_band[NL80211_BAND_ATTR_HT_CAPA]) {

145

__u16 cap = nla_get_u16(tb_band[NL80211_BAND_ATTR_HT_CAPA]);

146

print_ht_capability(cap);

147

}

148

if (tb_band[NL80211_BAND_ATTR_HT_AMPDU_FACTOR]) {

149

__u8 exponent = nla_get_u8(tb_band[NL80211_BAND_ATTR_HT_AMPDU_FACTOR]);

150

print_ampdu_length(exponent);

151

}

152

if (tb_band[NL80211_BAND_ATTR_HT_AMPDU_DENSITY]) {

153

__u8 spacing = nla_get_u8(tb_band[NL80211_BAND_ATTR_HT_AMPDU_DENSITY]);

154

print_ampdu_spacing(spacing);

155

}

156

if (tb_band[NL80211_BAND_ATTR_HT_MCS_SET] &&

157

nla_len(tb_band[NL80211_BAND_ATTR_HT_MCS_SET]) == 16)

158

print_ht_mcs(nla_data(tb_band[NL80211_BAND_ATTR_HT_MCS_SET]));

159

if (tb_band[NL80211_BAND_ATTR_VHT_CAPA] &&

160

tb_band[NL80211_BAND_ATTR_VHT_MCS_SET])

161

print_vht_info(nla_get_u32(tb_band[NL80211_BAND_ATTR_VHT_CAPA]),

162

nla_data(tb_band[NL80211_BAND_ATTR_VHT_MCS_SET]));

163

164

if (tb_band[NL80211_BAND_ATTR_FREQS]) {

165

if (!band_had_freq) {

166

printf("\t\tFrequencies:\n");

167

band_had_freq = true;

168

}

169

nla_for_each_nested(nl_freq, tb_band[NL80211_BAND_ATTR_FREQS], rem_freq) {

170

uint32_t freq;

171

nla_parse(tb_freq, NL80211_FREQUENCY_ATTR_MAX, nla_data(nl_freq),

172

nla_len(nl_freq), freq_policy);

173

if (!tb_freq[NL80211_FREQUENCY_ATTR_FREQ])

174

continue;

175

freq = nla_get_u32(tb_freq[NL80211_FREQUENCY_ATTR_FREQ]);

176

printf("\t\t\t* %d MHz [%d]", freq, ieee80211_frequency_to_channel(freq));

177

178

if (tb_freq[NL80211_FREQUENCY_ATTR_MAX_TX_POWER] &&

179

!tb_freq[NL80211_FREQUENCY_ATTR_DISABLED])

180

printf(" (%.1f dBm)", 0.01 * nla_get_u32(tb_freq[NL80211_FREQUENCY_ATTR_MAX_TX_POWER]));

181

182

open = 0;

183

if (tb_freq[NL80211_FREQUENCY_ATTR_DISABLED]) {

184

print_flag("disabled", &open);

goto next;

}

/* If both flags are set assume an new kernel */

189

if (tb_freq[NL80211_FREQUENCY_ATTR_NO_IR] && tb_freq[__NL80211_FREQUENCY_ATTR_NO_IBSS]) {

190

print_flag("no IR", &open);

191

} else if (tb_freq[NL80211_FREQUENCY_ATTR_PASSIVE_SCAN]) {

192

print_flag("passive scan", &open);

193

} else if (tb_freq[__NL80211_FREQUENCY_ATTR_NO_IBSS]){

194

print_flag("no ibss", &open);

195

}

196

197

if (tb_freq[NL80211_FREQUENCY_ATTR_RADAR])

198

print_flag("radar detection", &open);

next:

if (open)

printf(")");

printf("\n");

if (!tb_freq[NL80211_FREQUENCY_ATTR_DISABLED] && tb_freq[NL80211_FREQUENCY_ATTR_DFS_STATE]) {

205

enum nl80211_dfs_state state = nla_get_u32(tb_freq[NL80211_FREQUENCY_ATTR_DFS_STATE]);

206

unsigned long time;

207

208

printf("\t\t\t DFS state: %s", dfs_state_name(state));

209

if (tb_freq[NL80211_FREQUENCY_ATTR_DFS_TIME]) {

210

time = nla_get_u32(tb_freq[NL80211_FREQUENCY_ATTR_DFS_TIME]);

211

printf(" (for %lu sec)", time/1000);

212

}

213

printf("\n");

214

if (tb_freq[NL80211_FREQUENCY_ATTR_DFS_CAC_TIME])

215

printf("\t\t\t DFS CAC time: %u ms\n",

216

nla_get_u32(tb_freq[NL80211_FREQUENCY_ATTR_DFS_CAC_TIME]));

}

}

}

if (tb_band[NL80211_BAND_ATTR_RATES]) {

223

printf("\t\tBitrates (non-HT):\n");

224

nla_for_each_nested(nl_rate, tb_band[NL80211_BAND_ATTR_RATES], rem_rate) {

225

nla_parse(tb_rate, NL80211_BITRATE_ATTR_MAX, nla_data(nl_rate),

226

nla_len(nl_rate), rate_policy);

227

if (!tb_rate[NL80211_BITRATE_ATTR_RATE])

228

continue;

229

printf("\t\t\t* %2.1f Mbps", 0.1 * nla_get_u32(tb_rate[NL80211_BITRATE_ATTR_RATE]));

230

open = 0;

231

if (tb_rate[NL80211_BITRATE_ATTR_2GHZ_SHORTPREAMBLE])

232

print_flag("short preamble supported", &open);

if (open)

printf(")");

printf("\n");

}

}

}

}

if (tb_msg[NL80211_ATTR_MAX_NUM_SCAN_SSIDS])

242

printf("\tmax # scan SSIDs: %d\n",

243

nla_get_u8(tb_msg[NL80211_ATTR_MAX_NUM_SCAN_SSIDS]));

244

if (tb_msg[NL80211_ATTR_MAX_SCAN_IE_LEN])

245

printf("\tmax scan IEs length: %d bytes\n",

246

nla_get_u16(tb_msg[NL80211_ATTR_MAX_SCAN_IE_LEN]));

247

if (tb_msg[NL80211_ATTR_MAX_NUM_SCHED_SCAN_SSIDS])

248

printf("\tmax # sched scan SSIDs: %d\n",

249

nla_get_u8(tb_msg[NL80211_ATTR_MAX_NUM_SCHED_SCAN_SSIDS]));

250

if (tb_msg[NL80211_ATTR_MAX_MATCH_SETS])

251

printf("\tmax # match sets: %d\n",

252

nla_get_u8(tb_msg[NL80211_ATTR_MAX_MATCH_SETS]));

253

254

if (tb_msg[NL80211_ATTR_WIPHY_FRAG_THRESHOLD]) {

255

unsigned int frag;

256

257

frag = nla_get_u32(tb_msg[NL80211_ATTR_WIPHY_FRAG_THRESHOLD]);

258

if (frag != (unsigned int)-1)

259

printf("\tFragmentation threshold: %d\n", frag);

260

}

261

262

if (tb_msg[NL80211_ATTR_WIPHY_RTS_THRESHOLD]) {

263

unsigned int rts;

264

265

rts = nla_get_u32(tb_msg[NL80211_ATTR_WIPHY_RTS_THRESHOLD]);

266

if (rts != (unsigned int)-1)

267

printf("\tRTS threshold: %d\n", rts);

268

}

269

270

if (tb_msg[NL80211_ATTR_WIPHY_RETRY_SHORT] ||

271

tb_msg[NL80211_ATTR_WIPHY_RETRY_LONG]) {

272

unsigned char retry_short = 0, retry_long = 0;

273

274

if (tb_msg[NL80211_ATTR_WIPHY_RETRY_SHORT])

275

retry_short = nla_get_u8(tb_msg[NL80211_ATTR_WIPHY_RETRY_SHORT]);

276

if (tb_msg[NL80211_ATTR_WIPHY_RETRY_LONG])

277

retry_long = nla_get_u8(tb_msg[NL80211_ATTR_WIPHY_RETRY_LONG]);

278

if (retry_short == retry_long) {

279

printf("\tRetry short long limit: %d\n", retry_short);

280

} else {

281

printf("\tRetry short limit: %d\n", retry_short);

282

printf("\tRetry long limit: %d\n", retry_long);

}

}

if (tb_msg[NL80211_ATTR_WIPHY_COVERAGE_CLASS]) {

287

unsigned char coverage;

288

289

coverage = nla_get_u8(tb_msg[NL80211_ATTR_WIPHY_COVERAGE_CLASS]);

290

/* See handle_distance() for an explanation where the '450' comes from */

291

printf("\tCoverage class: %d (up to %dm)\n", coverage, 450 * coverage);

292

}

293

294

if (tb_msg[NL80211_ATTR_CIPHER_SUITES]) {

295

int num = nla_len(tb_msg[NL80211_ATTR_CIPHER_SUITES]) / sizeof(__u32);

296

int i;

297

__u32 *ciphers = nla_data(tb_msg[NL80211_ATTR_CIPHER_SUITES]);

298

if (num > 0) {

299

printf("\tSupported Ciphers:\n");

300

for (i = 0; i < num; i++)

301

printf("\t\t* %s\n",

302

cipher_name(ciphers[i]));

}

}

if (tb_msg[NL80211_ATTR_WIPHY_ANTENNA_AVAIL_TX] &&

307

tb_msg[NL80211_ATTR_WIPHY_ANTENNA_AVAIL_RX])

308

printf("\tAvailable Antennas: TX %#x RX %#x\n",

309

nla_get_u32(tb_msg[NL80211_ATTR_WIPHY_ANTENNA_AVAIL_TX]),

310

nla_get_u32(tb_msg[NL80211_ATTR_WIPHY_ANTENNA_AVAIL_RX]));

311

312

if (tb_msg[NL80211_ATTR_WIPHY_ANTENNA_TX] &&

313

tb_msg[NL80211_ATTR_WIPHY_ANTENNA_RX])

314

printf("\tConfigured Antennas: TX %#x RX %#x\n",

315

nla_get_u32(tb_msg[NL80211_ATTR_WIPHY_ANTENNA_TX]),

316

nla_get_u32(tb_msg[NL80211_ATTR_WIPHY_ANTENNA_RX]));

317

318

if (tb_msg[NL80211_ATTR_SUPPORTED_IFTYPES]) {

319

printf("\tSupported interface modes:\n");

320

nla_for_each_nested(nl_mode, tb_msg[NL80211_ATTR_SUPPORTED_IFTYPES], rem_mode)

321

printf("\t\t * %s\n", iftype_name(nla_type(nl_mode)));

322

}

323

324

if (tb_msg[NL80211_ATTR_SOFTWARE_IFTYPES]) {

325

printf("\tsoftware interface modes (can always be added):\n");

326

nla_for_each_nested(nl_mode, tb_msg[NL80211_ATTR_SOFTWARE_IFTYPES], rem_mode)

327

printf("\t\t * %s\n", iftype_name(nla_type(nl_mode)));

328

}

329

330

if (tb_msg[NL80211_ATTR_INTERFACE_COMBINATIONS]) {

331

struct nlattr *nl_combi;

332

int rem_combi;

333

bool have_combinations = false;

334

335

nla_for_each_nested(nl_combi, tb_msg[NL80211_ATTR_INTERFACE_COMBINATIONS], rem_combi) {

336

static struct nla_policy iface_combination_policy[NUM_NL80211_IFACE_COMB] = {

337

[NL80211_IFACE_COMB_LIMITS] = { .type = NLA_NESTED },

338

[NL80211_IFACE_COMB_MAXNUM] = { .type = NLA_U32 },

339

[NL80211_IFACE_COMB_STA_AP_BI_MATCH] = { .type = NLA_FLAG },

340

[NL80211_IFACE_COMB_NUM_CHANNELS] = { .type = NLA_U32 },

341

[NL80211_IFACE_COMB_RADAR_DETECT_WIDTHS] = { .type = NLA_U32 },

342

};

343

struct nlattr *tb_comb[NUM_NL80211_IFACE_COMB];

344

static struct nla_policy iface_limit_policy[NUM_NL80211_IFACE_LIMIT] = {

345

[NL80211_IFACE_LIMIT_TYPES] = { .type = NLA_NESTED },

346

[NL80211_IFACE_LIMIT_MAX] = { .type = NLA_U32 },

347

};

348

struct nlattr *tb_limit[NUM_NL80211_IFACE_LIMIT];

349

struct nlattr *nl_limit;

350

int err, rem_limit;

351

bool comma = false;

352

353

if (!have_combinations) {

354

printf("\tvalid interface combinations:\n");

355

have_combinations = true;

}

printf("\t\t * ");

err = nla_parse_nested(tb_comb, MAX_NL80211_IFACE_COMB,

361

nl_combi, iface_combination_policy);

362

if (err || !tb_comb[NL80211_IFACE_COMB_LIMITS] ||

363

!tb_comb[NL80211_IFACE_COMB_MAXNUM] ||

364

!tb_comb[NL80211_IFACE_COMB_NUM_CHANNELS]) {

365

printf(" <failed to parse>\n");

366

goto broken_combination;

367

}

368

369

nla_for_each_nested(nl_limit, tb_comb[NL80211_IFACE_COMB_LIMITS], rem_limit) {

370

bool ift_comma = false;

371

372

err = nla_parse_nested(tb_limit, MAX_NL80211_IFACE_LIMIT,

373

nl_limit, iface_limit_policy);

374

if (err || !tb_limit[NL80211_IFACE_LIMIT_TYPES]) {

375

printf("<failed to parse>\n");

376

goto broken_combination;

}

if (comma)

printf(", ");

comma = true;

printf("#{");

nla_for_each_nested(nl_mode, tb_limit[NL80211_IFACE_LIMIT_TYPES], rem_mode) {

385

printf("%s %s", ift_comma ? "," : "",

386

iftype_name(nla_type(nl_mode)));

387

ift_comma = true;

388

}

389

printf(" } <= %u", nla_get_u32(tb_limit[NL80211_IFACE_LIMIT_MAX]));

390

}

391

printf(",\n\t\t ");

392

393

printf("total <= %d, #channels <= %d%s",

394

nla_get_u32(tb_comb[NL80211_IFACE_COMB_MAXNUM]),

395

nla_get_u32(tb_comb[NL80211_IFACE_COMB_NUM_CHANNELS]),

396

tb_comb[NL80211_IFACE_COMB_STA_AP_BI_MATCH] ?

397

", STA/AP BI must match" : "");

398

if (tb_comb[NL80211_IFACE_COMB_RADAR_DETECT_WIDTHS]) {

399

unsigned long widths = nla_get_u32(tb_comb[NL80211_IFACE_COMB_RADAR_DETECT_WIDTHS]);

if (widths) {

int width;

bool first = true;

printf(", radar detect widths: {");

406

for (width = 0; width < 32; width++)

407

if (widths & (1 << width)) {

408

printf("%s %s",

409

first ? "":",",

410

channel_width_name(width));

first = false;

}

printf(" }\n");

}

}

printf("\n");

broken_combination:

;

}

if (!have_combinations)

422

printf("\tinterface combinations are not supported\n");

423

}

424

425

if (tb_msg[NL80211_ATTR_SUPPORTED_COMMANDS]) {

426

printf("\tSupported commands:\n");

427

nla_for_each_nested(nl_cmd, tb_msg[NL80211_ATTR_SUPPORTED_COMMANDS], rem_cmd)

428

printf("\t\t * %s\n", command_name(nla_get_u32(nl_cmd)));

429

}

430

431

if (tb_msg[NL80211_ATTR_TX_FRAME_TYPES]) {

432

printf("\tSupported TX frame types:\n");

433

nla_for_each_nested(nl_if, tb_msg[NL80211_ATTR_TX_FRAME_TYPES], rem_if) {

434

bool printed = false;

435

nla_for_each_nested(nl_ftype, nl_if, rem_ftype) {

436

if (!printed)

437

printf("\t\t * %s:", iftype_name(nla_type(nl_if)));

438

printed = true;

439

printf(" 0x%.2x", nla_get_u16(nl_ftype));

}

if (printed)

printf("\n");

}

}

if (tb_msg[NL80211_ATTR_RX_FRAME_TYPES]) {

447

printf("\tSupported RX frame types:\n");

448

nla_for_each_nested(nl_if, tb_msg[NL80211_ATTR_RX_FRAME_TYPES], rem_if) {

449

bool printed = false;

450

nla_for_each_nested(nl_ftype, nl_if, rem_ftype) {

451

if (!printed)

452

printf("\t\t * %s:", iftype_name(nla_type(nl_if)));

453

printed = true;

454

printf(" 0x%.2x", nla_get_u16(nl_ftype));

}

if (printed)

printf("\n");

}

}

if (tb_msg[NL80211_ATTR_SUPPORT_IBSS_RSN])

462

printf("\tDevice supports RSN-IBSS.\n");

463

464

if (tb_msg[NL80211_ATTR_WOWLAN_TRIGGERS_SUPPORTED]) {

465

struct nlattr *tb_wowlan[NUM_NL80211_WOWLAN_TRIG];

466

static struct nla_policy wowlan_policy[NUM_NL80211_WOWLAN_TRIG] = {

467

[NL80211_WOWLAN_TRIG_ANY] = { .type = NLA_FLAG },

468

[NL80211_WOWLAN_TRIG_DISCONNECT] = { .type = NLA_FLAG },

469

[NL80211_WOWLAN_TRIG_MAGIC_PKT] = { .type = NLA_FLAG },

470

[NL80211_WOWLAN_TRIG_PKT_PATTERN] = { .minlen = 12 },

471

[NL80211_WOWLAN_TRIG_GTK_REKEY_SUPPORTED] = { .type = NLA_FLAG },

472

[NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE] = { .type = NLA_FLAG },

473

[NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST] = { .type = NLA_FLAG },

474

[NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE] = { .type = NLA_FLAG },

475

[NL80211_WOWLAN_TRIG_RFKILL_RELEASE] = { .type = NLA_FLAG },

476

[NL80211_WOWLAN_TRIG_NET_DETECT] = { .type = NLA_U32 },

477

[NL80211_WOWLAN_TRIG_TCP_CONNECTION] = { .type = NLA_NESTED },

478

};

479

struct nl80211_pattern_support *pat;

480

int err;

481

482

err = nla_parse_nested(tb_wowlan, MAX_NL80211_WOWLAN_TRIG,

483

tb_msg[NL80211_ATTR_WOWLAN_TRIGGERS_SUPPORTED],

484

wowlan_policy);

485

printf("\tWoWLAN support:");

486

if (err) {

487

printf(" <failed to parse>\n");

488

} else {

489

printf("\n");

490

if (tb_wowlan[NL80211_WOWLAN_TRIG_ANY])

491

printf("\t\t * wake up on anything (device continues operating normally)\n");

492

if (tb_wowlan[NL80211_WOWLAN_TRIG_DISCONNECT])

493

printf("\t\t * wake up on disconnect\n");

494

if (tb_wowlan[NL80211_WOWLAN_TRIG_MAGIC_PKT])

495

printf("\t\t * wake up on magic packet\n");

496

if (tb_wowlan[NL80211_WOWLAN_TRIG_PKT_PATTERN]) {

497

pat = nla_data(tb_wowlan[NL80211_WOWLAN_TRIG_PKT_PATTERN]);

498

printf("\t\t * wake up on pattern match, up to %u patterns of %u-%u bytes,\n"

499

"\t\t maximum packet offset %u bytes\n",

500

pat->max_patterns, pat->min_pattern_len, pat->max_pattern_len,

501

(nla_len(tb_wowlan[NL80211_WOWLAN_TRIG_PKT_PATTERN]) <

502

sizeof(*pat)) ? 0 : pat->max_pkt_offset);

503

}

504

if (tb_wowlan[NL80211_WOWLAN_TRIG_GTK_REKEY_SUPPORTED])

505

printf("\t\t * can do GTK rekeying\n");

506

if (tb_wowlan[NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE])

507

printf("\t\t * wake up on GTK rekey failure\n");

508

if (tb_wowlan[NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST])

509

printf("\t\t * wake up on EAP identity request\n");

510

if (tb_wowlan[NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE])

511

printf("\t\t * wake up on 4-way handshake\n");

512

if (tb_wowlan[NL80211_WOWLAN_TRIG_RFKILL_RELEASE])

513

printf("\t\t * wake up on rfkill release\n");

514

if (tb_wowlan[NL80211_WOWLAN_TRIG_NET_DETECT])

515

printf("\t\t * wake up on network detection, up to %d match sets\n",

516

nla_get_u32(tb_wowlan[NL80211_WOWLAN_TRIG_NET_DETECT]));

517

if (tb_wowlan[NL80211_WOWLAN_TRIG_TCP_CONNECTION])

518

printf("\t\t * wake up on TCP connection\n");

}

}

if (tb_msg[NL80211_ATTR_ROAM_SUPPORT])

523

printf("\tDevice supports roaming.\n");

524

525

if (tb_msg[NL80211_ATTR_SUPPORT_AP_UAPSD])

526

printf("\tDevice supports AP-side u-APSD.\n");

527

528

if (tb_msg[NL80211_ATTR_HT_CAPABILITY_MASK]) {

529

struct ieee80211_ht_cap *cm;

530

printf("\tHT Capability overrides:\n");

531

if (nla_len(tb_msg[NL80211_ATTR_HT_CAPABILITY_MASK]) >= sizeof(*cm)) {

532

cm = nla_data(tb_msg[NL80211_ATTR_HT_CAPABILITY_MASK]);

533

printf("\t\t * MCS: %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx"

534

" %02hhx %02hhx %02hhx %02hhx\n",

535

cm->mcs.rx_mask[0], cm->mcs.rx_mask[1],

536

cm->mcs.rx_mask[2], cm->mcs.rx_mask[3],

537

cm->mcs.rx_mask[4], cm->mcs.rx_mask[5],

538

cm->mcs.rx_mask[6], cm->mcs.rx_mask[7],

539

cm->mcs.rx_mask[8], cm->mcs.rx_mask[9]);

540

if (cm->cap_info & htole16(IEEE80211_HT_CAP_MAX_AMSDU))

541

printf("\t\t * maximum A-MSDU length\n");

542

if (cm->cap_info & htole16(IEEE80211_HT_CAP_SUP_WIDTH_20_40))

543

printf("\t\t * supported channel width\n");

544

if (cm->cap_info & htole16(IEEE80211_HT_CAP_SGI_40))

545

printf("\t\t * short GI for 40 MHz\n");

546

if (cm->ampdu_params_info & IEEE80211_HT_AMPDU_PARM_FACTOR)

547

printf("\t\t * max A-MPDU length exponent\n");

548

if (cm->ampdu_params_info & IEEE80211_HT_AMPDU_PARM_DENSITY)

549

printf("\t\t * min MPDU start spacing\n");

550

} else {

551

printf("\tERROR: capabilities mask is too short, expected: %d, received: %d\n",

552

(int)(sizeof(*cm)),

553

(int)(nla_len(tb_msg[NL80211_ATTR_HT_CAPABILITY_MASK])));

}

}

if (tb_msg[NL80211_ATTR_FEATURE_FLAGS]) {

558

unsigned int features = nla_get_u32(tb_msg[NL80211_ATTR_FEATURE_FLAGS]);

559

560

if (features & NL80211_FEATURE_SK_TX_STATUS)

561

printf("\tDevice supports TX status socket option.\n");

562

if (features & NL80211_FEATURE_HT_IBSS)

563

printf("\tDevice supports HT-IBSS.\n");

564

if (features & NL80211_FEATURE_INACTIVITY_TIMER)

565

printf("\tDevice has client inactivity timer.\n");

566

if (features & NL80211_FEATURE_CELL_BASE_REG_HINTS)

567

printf("\tDevice accepts cell base station regulatory hints.\n");

568

if (features & NL80211_FEATURE_P2P_DEVICE_NEEDS_CHANNEL)

569

printf("\tP2P Device uses a channel (of the concurrent ones)\n");

570

if (features & NL80211_FEATURE_SAE)

571

printf("\tDevice supports SAE with AUTHENTICATE command\n");

572

if (features & NL80211_FEATURE_LOW_PRIORITY_SCAN)

573

printf("\tDevice supports low priority scan.\n");

574

if (features & NL80211_FEATURE_SCAN_FLUSH)

575

printf("\tDevice supports scan flush.\n");

576

if (features & NL80211_FEATURE_AP_SCAN)

577

printf("\tDevice supports AP scan.\n");

578

if (features & NL80211_FEATURE_VIF_TXPOWER)

579

printf("\tDevice supports per-vif TX power setting\n");

580

if (features & NL80211_FEATURE_NEED_OBSS_SCAN)

581

printf("\tUserspace should do OBSS scan and generate 20/40 coex reports\n");

582

if (features & NL80211_FEATURE_P2P_GO_CTWIN)

583

printf("\tP2P GO supports CT window setting\n");

584

if (features & NL80211_FEATURE_P2P_GO_OPPPS)

585

printf("\tP2P GO supports opportunistic powersave setting\n");

586

if (features & NL80211_FEATURE_FULL_AP_CLIENT_STATE)

587

printf("\tDriver supports full state transitions for AP/GO clients\n");

588

if (features & NL80211_FEATURE_USERSPACE_MPM)

589

printf("\tDriver supports a userspace MPM\n");

590

if (features & NL80211_FEATURE_ACTIVE_MONITOR)

591

printf("\tDevice supports active monitor (which will ACK incoming frames)\n");

592

if (features & NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE)

593

printf("\tDriver/device bandwidth changes during BSS lifetime (AP/GO mode)\n");

594

if (features & NL80211_FEATURE_DS_PARAM_SET_IE_IN_PROBES)

595

printf("\tDevice adds DS IE to probe requests\n");

596

if (features & NL80211_FEATURE_WFA_TPC_IE_IN_PROBES)

597

printf("\tDevice adds WFA TPC Report IE to probe requests\n");

598

if (features & NL80211_FEATURE_QUIET)

599

printf("\tDevice supports quiet requests from AP\n");

600

if (features & NL80211_FEATURE_TX_POWER_INSERTION)

601

printf("\tDevice can update TPC Report IE\n");

602

if (features & NL80211_FEATURE_ACKTO_ESTIMATION)

603

printf("\tDevice supports ACK timeout estimation.\n");

604

if (features & NL80211_FEATURE_STATIC_SMPS)

605

printf("\tDevice supports static SMPS\n");

606

if (features & NL80211_FEATURE_DYNAMIC_SMPS)

607

printf("\tDevice supports dynamic SMPS\n");

608

if (features & NL80211_FEATURE_SUPPORTS_WMM_ADMISSION)

609

printf("\tDevice supports WMM-AC admission (TSPECs)\n");

610

if (features & NL80211_FEATURE_MAC_ON_CREATE)

611

printf("\tDevice supports configuring vdev MAC-addr on create.\n");

612

if (features & NL80211_FEATURE_TDLS_CHANNEL_SWITCH)

613

printf("\tDevice supports TDLS channel switching\n");

614

}

615

616

if (tb_msg[NL80211_ATTR_EXT_FEATURES]) {

617

struct nlattr *tb = tb_msg[NL80211_ATTR_EXT_FEATURES];

618

619

if (ext_feature_isset(nla_data(tb), nla_len(tb),

620

NL80211_EXT_FEATURE_VHT_IBSS))

621

printf("\tDevice supports VHT-IBSS.\n");

622

}

623

624

if (tb_msg[NL80211_ATTR_TDLS_SUPPORT])

625

printf("\tDevice supports T-DLS.\n");

626

627

if (tb_msg[NL80211_ATTR_COALESCE_RULE]) {

628

struct nl80211_coalesce_rule_support *rule;

629

struct nl80211_pattern_support *pat;

630

631

printf("\tCoalesce support:\n");

632

rule = nla_data(tb_msg[NL80211_ATTR_COALESCE_RULE]);

633

pat = &rule->pat;

634

printf("\t\t * Maximum %u coalesce rules supported\n"

635

"\t\t * Each rule contains upto %u patterns of %u-%u bytes,\n"

636

"\t\t maximum packet offset %u bytes\n"

637

"\t\t * Maximum supported coalescing delay %u msecs\n",

638

rule->max_rules, pat->max_patterns, pat->min_pattern_len,

639

pat->max_pattern_len, pat->max_pkt_offset, rule->max_delay);

}

return NL_SKIP;

}

static bool nl80211_has_split_wiphy = false;

646

647

static int handle_info(struct nl80211_state *state,

648

struct nl_cb *cb,

649

struct nl_msg *msg,

650

int argc, char **argv,

651

enum id_input id)

652

{

653

char *feat_args[] = { "features", "-q" };

654

int err;

655

656

err = handle_cmd(state, CIB_NONE, 2, feat_args);

657

if (!err && nl80211_has_split_wiphy) {

658

nla_put_flag(msg, NL80211_ATTR_SPLIT_WIPHY_DUMP);

659

nlmsg_hdr(msg)->nlmsg_flags |= NLM_F_DUMP;

660

}

661

662

nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, print_phy_handler, NULL);

return 0;

}

__COMMAND(NULL, info, "info", NULL, NL80211_CMD_GET_WIPHY, 0, 0, CIB_PHY, handle_info,

667

"Show capabilities for the specified wireless device.", NULL);

668

TOPLEVEL(list, NULL, NL80211_CMD_GET_WIPHY, NLM_F_DUMP, CIB_NONE, handle_info,

669

"List all wireless devices and their capabilities.");

670

TOPLEVEL(phy, NULL, NL80211_CMD_GET_WIPHY, NLM_F_DUMP, CIB_NONE, handle_info, NULL);

671

672

static int handle_commands(struct nl80211_state *state,

673

struct nl_cb *cb, struct nl_msg *msg,

674

int argc, char **argv, enum id_input id)

675

{

676

int i;

677

for (i = 1; i < NL80211_CMD_MAX; i++)

678

printf("%d (0x%x): %s\n", i, i, command_name(i));

679

/* don't send netlink messages */

680

return 2;

681

}

682

TOPLEVEL(commands, NULL, NL80211_CMD_GET_WIPHY, 0, CIB_NONE, handle_commands,

683

"list all known commands and their decimal & hex value");

684

685

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

686

{

687

struct nlattr *tb_msg[NL80211_ATTR_MAX + 1];

688

struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));

689

bool print = (unsigned long)arg;

690

#define maybe_printf(...) do { if (print) printf(__VA_ARGS__); } while (0)

691

692

nla_parse(tb_msg, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),

693

genlmsg_attrlen(gnlh, 0), NULL);

694

695

if (tb_msg[NL80211_ATTR_PROTOCOL_FEATURES]) {

696

uint32_t feat = nla_get_u32(tb_msg[NL80211_ATTR_PROTOCOL_FEATURES]);

697

698

maybe_printf("nl80211 features: 0x%x\n", feat);

699

if (feat & NL80211_PROTOCOL_FEATURE_SPLIT_WIPHY_DUMP) {

700

maybe_printf("\t* split wiphy dump\n");

701

nl80211_has_split_wiphy = true;

}

}

return NL_SKIP;

}

static int handle_features(struct nl80211_state *state,

709

struct nl_cb *cb, struct nl_msg *msg,

710

int argc, char **argv, enum id_input id)

711

{

712

unsigned long print = argc == 0 || strcmp(argv[0], "-q");

713

nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, print_feature_handler, (void *)print);

return 0;

}

TOPLEVEL(features, "", NL80211_CMD_GET_PROTOCOL_FEATURES, 0, CIB_NONE,

718

handle_features, "");

nexmon – Blame information for rev 1