event.c

   1 #include <stdint.h>
   2 #include <stdbool.h>
   3 #include <net/if.h>
   4 #include <errno.h>
   5 #include "iw.h"
   6
   7 static int no_seq_check(struct nl_msg *msg, void *arg)
   8 {
   9         return NL_OK;
  10 }
  11
  12 struct ieee80211_beacon_channel {
  13         __u16 center_freq;
  14         bool passive_scan;
  15         bool no_ibss;
  16 };
  17
  18 static int parse_beacon_hint_chan(struct nlattr *tb,
  19                                   struct ieee80211_beacon_channel *chan)
  20 {
  21         struct nlattr *tb_freq[NL80211_FREQUENCY_ATTR_MAX + 1];
  22         static struct nla_policy beacon_freq_policy[NL80211_FREQUENCY_ATTR_MAX + 1] = {
  23                 [NL80211_FREQUENCY_ATTR_FREQ] = { .type = NLA_U32 },
  24                 [NL80211_FREQUENCY_ATTR_PASSIVE_SCAN] = { .type = NLA_FLAG },
  25                 [NL80211_FREQUENCY_ATTR_NO_IBSS] = { .type = NLA_FLAG },
  26         };
  27
  28         if (nla_parse_nested(tb_freq,
  29                              NL80211_FREQUENCY_ATTR_MAX,
  30                              tb,
  31                              beacon_freq_policy))
  32                 return -EINVAL;
  33
  34         chan->center_freq = nla_get_u32(tb_freq[NL80211_FREQUENCY_ATTR_FREQ]);
  35
  36         if (tb_freq[NL80211_FREQUENCY_ATTR_PASSIVE_SCAN])
  37                 chan->passive_scan = true;
  38         if (tb_freq[NL80211_FREQUENCY_ATTR_NO_IBSS])
  39                 chan->no_ibss = true;
  40
  41         return 0;
  42 }
  43
  44 static void print_frame(struct print_event_args *args, struct nlattr *attr)
  45 {
  46         uint8_t *frame;
  47         size_t len;
  48         int i;
  49         char macbuf[6*3];
  50         uint16_t tmp;
  51
  52         if (!attr)
  53                 printf(" [no frame]");
  54
  55         frame = nla_data(attr);
  56         len = nla_len(attr);
  57
  58         if (len < 26) {
  59                 printf(" [invalid frame: ");
  60                 goto print_frame;
  61         }
  62
  63         mac_addr_n2a(macbuf, frame + 10);
  64         printf(" %s -> ", macbuf);
  65         mac_addr_n2a(macbuf, frame + 4);
  66         printf("%s", macbuf);
  67
  68         switch (frame[0] & 0xfc) {
  69         case 0x10: /* assoc resp */
  70         case 0x30: /* reassoc resp */
  71                 /* status */
  72                 tmp = (frame[27] << 8) + frame[26];
  73                 printf(" status: %d: %s", tmp, get_status_str(tmp));
  74                 break;
  75         case 0x00: /* assoc req */
  76         case 0x20: /* reassoc req */
  77                 break;
  78         case 0xb0: /* auth */
  79                 /* status */
  80                 tmp = (frame[29] << 8) + frame[28];
  81                 printf(" status: %d: %s", tmp, get_status_str(tmp));
  82                 break;
  83                 break;
  84         case 0xa0: /* disassoc */
  85         case 0xc0: /* deauth */
  86                 /* reason */
  87                 tmp = (frame[25] << 8) + frame[24];
  88                 printf(" reason %d: %s", tmp, get_reason_str(tmp));
  89                 break;
  90         }
  91
  92         if (!args->frame)
  93                 return;
  94
  95         printf(" [frame:");
  96
  97  print_frame:
  98         for (i = 0; i < len; i++)
  99                 printf(" %.02x", frame[i]);
 100         printf("]");
 101 }
 102
 103 static void parse_cqm_event(struct nlattr **attrs)
 104 {
 105         static struct nla_policy cqm_policy[NL80211_ATTR_CQM_MAX + 1] = {
 106                 [NL80211_ATTR_CQM_RSSI_THOLD] = { .type = NLA_U32 },
 107                 [NL80211_ATTR_CQM_RSSI_HYST] = { .type = NLA_U32 },
 108                 [NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT] = { .type = NLA_U32 },
 109         };
 110         struct nlattr *cqm[NL80211_ATTR_CQM_MAX + 1];
 111         struct nlattr *cqm_attr = attrs[NL80211_ATTR_CQM];
 112
 113         printf("CQM event: ");
 114
 115         if (!cqm_attr ||
 116             nla_parse_nested(cqm, NL80211_ATTR_CQM_MAX, cqm_attr, cqm_policy)) {
 117                 printf("missing data!\n");
 118                 return;
 119         }
 120
 121         if (cqm[NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT]) {
 122                 enum nl80211_cqm_rssi_threshold_event rssi_event;
 123                 bool found_one = false;
 124
 125                 rssi_event = nla_get_u32(cqm[NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT]);
 126
 127                 switch (rssi_event) {
 128                 case NL80211_CQM_RSSI_THRESHOLD_EVENT_HIGH:
 129                         printf("RSSI went above threshold\n");
 130                         found_one = true;
 131                         break;
 132                 case NL80211_CQM_RSSI_THRESHOLD_EVENT_LOW:
 133                         printf("RSSI went below threshold\n");
 134                         found_one = true;
 135                         break;
 136                 case NL80211_CQM_RSSI_BEACON_LOSS_EVENT:
 137                         printf("Beacon loss detected\n");
 138                         found_one = true;
 139                         break;
 140                 }
 141
 142                 if (!found_one)
 143                         printf("Unknown event type: %i\n", rssi_event);
 144         } else if (cqm[NL80211_ATTR_CQM_PKT_LOSS_EVENT] &&
 145                    attrs[NL80211_ATTR_MAC]) {
 146                 uint32_t frames;
 147                 char buf[3*6];
 148
 149                 frames = nla_get_u32(cqm[NL80211_ATTR_CQM_PKT_LOSS_EVENT]);
 150                 mac_addr_n2a(buf, nla_data(attrs[NL80211_ATTR_MAC]));
 151                 printf("peer %s didn't ACK %d packets\n", buf, frames);
 152         } else
 153                 printf("unknown event\n");
 154 }
 155
 156 static const char * key_type_str(enum nl80211_key_type key_type)
 157 {
 158         static char buf[30];
 159         switch (key_type) {
 160         case NL80211_KEYTYPE_GROUP:
 161                 return "Group";
 162         case NL80211_KEYTYPE_PAIRWISE:
 163                 return "Pairwise";
 164         case NL80211_KEYTYPE_PEERKEY:
 165                 return "PeerKey";
 166         default:
 167                 snprintf(buf, sizeof(buf), "unknown(%d)", key_type);
 168                 return buf;
 169         }
 170 }
 171
 172 static void parse_mic_failure(struct nlattr **attrs)
 173 {
 174         printf("Michael MIC failure event:");
 175
 176         if (attrs[NL80211_ATTR_MAC]) {
 177                 char addr[3 * ETH_ALEN];
 178                 mac_addr_n2a(addr, nla_data(attrs[NL80211_ATTR_MAC]));
 179                 printf(" source MAC address %s", addr);
 180         }
 181
 182         if (attrs[NL80211_ATTR_KEY_SEQ] &&
 183             nla_len(attrs[NL80211_ATTR_KEY_SEQ]) == 6) {
 184                 unsigned char *seq = nla_data(attrs[NL80211_ATTR_KEY_SEQ]);
 185                 printf(" seq=%02x%02x%02x%02x%02x%02x",
 186                        seq[0], seq[1], seq[2], seq[3], seq[4], seq[5]);
 187         }
 188         if (attrs[NL80211_ATTR_KEY_TYPE]) {
 189                 enum nl80211_key_type key_type =
 190                         nla_get_u32(attrs[NL80211_ATTR_KEY_TYPE]);
 191                 printf(" Key Type %s", key_type_str(key_type));
 192         }
 193
 194         if (attrs[NL80211_ATTR_KEY_IDX]) {
 195                 __u8 key_id = nla_get_u8(attrs[NL80211_ATTR_KEY_IDX]);
 196                 printf(" Key Id %d", key_id);
 197         }
 198
 199         printf("\n");
 200 }
 201
 202 static void parse_wowlan_wake_event(struct nlattr **attrs)
 203 {
 204         struct nlattr *tb[NUM_NL80211_WOWLAN_TRIG];
 205
 206         printf("WoWLAN wakeup\n");
 207         if (!attrs[NL80211_ATTR_WOWLAN_TRIGGERS]) {
 208                 printf("\twakeup not due to WoWLAN\n");
 209                 return;
 210         }
 211
 212         nla_parse(tb, MAX_NL80211_WOWLAN_TRIG,
 213                   nla_data(attrs[NL80211_ATTR_WOWLAN_TRIGGERS]),
 214                   nla_len(attrs[NL80211_ATTR_WOWLAN_TRIGGERS]), NULL);
 215
 216         if (tb[NL80211_WOWLAN_TRIG_DISCONNECT])
 217                 printf("\t* was disconnected\n");
 218         if (tb[NL80211_WOWLAN_TRIG_MAGIC_PKT])
 219                 printf("\t* magic packet received\n");
 220         if (tb[NL80211_WOWLAN_TRIG_PKT_PATTERN])
 221                 printf("\t* pattern index: %u\n",
 222                        nla_get_u32(tb[NL80211_WOWLAN_TRIG_PKT_PATTERN]));
 223         if (tb[NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE])
 224                 printf("\t* GTK rekey failure\n");
 225         if (tb[NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST])
 226                 printf("\t* EAP identity request\n");
 227         if (tb[NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE])
 228                 printf("\t* 4-way handshake\n");
 229         if (tb[NL80211_WOWLAN_TRIG_RFKILL_RELEASE])
 230                 printf("\t* RF-kill released\n");
 231         if (tb[NL80211_WOWLAN_TRIG_WAKEUP_PKT_80211]) {
 232                 uint8_t *d = nla_data(tb[NL80211_WOWLAN_TRIG_WAKEUP_PKT_80211]);
 233                 int l = nla_len(tb[NL80211_WOWLAN_TRIG_WAKEUP_PKT_80211]);
 234                 int i;
 235                 printf("\t* packet (might be truncated): ");
 236                 for (i = 0; i < l; i++) {
 237                         if (i > 0)
 238                                 printf(":");
 239                         printf("%.2x", d[i]);
 240                 }
 241                 printf("\n");
 242         }
 243         if (tb[NL80211_WOWLAN_TRIG_WAKEUP_PKT_8023]) {
 244                 uint8_t *d = nla_data(tb[NL80211_WOWLAN_TRIG_WAKEUP_PKT_8023]);
 245                 int l = nla_len(tb[NL80211_WOWLAN_TRIG_WAKEUP_PKT_8023]);
 246                 int i;
 247                 printf("\t* packet (might be truncated): ");
 248                 for (i = 0; i < l; i++) {
 249                         if (i > 0)
 250                                 printf(":");
 251                         printf("%.2x", d[i]);
 252                 }
 253                 printf("\n");
 254         }
 255         if (tb[NL80211_WOWLAN_TRIG_WAKEUP_TCP_MATCH])
 256                 printf("\t* TCP connection wakeup received\n");
 257         if (tb[NL80211_WOWLAN_TRIG_WAKEUP_TCP_CONNLOST])
 258                 printf("\t* TCP connection lost\n");
 259         if (tb[NL80211_WOWLAN_TRIG_WAKEUP_TCP_NOMORETOKENS])
 260                 printf("\t* TCP connection ran out of tokens\n");
 261 }
 262
 263 static int print_event(struct nl_msg *msg, void *arg)
 264 {
 265         struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
 266         struct nlattr *tb[NL80211_ATTR_MAX + 1], *nst;
 267         struct print_event_args *args = arg;
 268         char ifname[100];
 269         char macbuf[6*3];
 270         __u8 reg_type;
 271         struct ieee80211_beacon_channel chan_before_beacon,  chan_after_beacon;
 272         __u32 wiphy_idx = 0;
 273         int rem_nst;
 274         __u16 status;
 275
 276         if (args->time || args->reltime) {
 277                 unsigned long long usecs, previous;
 278
 279                 previous = 1000000ULL * args->ts.tv_sec + args->ts.tv_usec;
 280                 gettimeofday(&args->ts, NULL);
 281                 usecs = 1000000ULL * args->ts.tv_sec + args->ts.tv_usec;
 282                 if (args->reltime) {
 283                         if (!args->have_ts) {
 284                                 usecs = 0;
 285                                 args->have_ts = true;
 286                         } else
 287                                 usecs -= previous;
 288                 }
 289                 printf("%llu.%06llu: ", usecs/1000000, usecs % 1000000);
 290         }
 291
 292         nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
 293                   genlmsg_attrlen(gnlh, 0), NULL);
 294
 295         if (tb[NL80211_ATTR_IFINDEX] && tb[NL80211_ATTR_WIPHY]) {
 296                 if_indextoname(nla_get_u32(tb[NL80211_ATTR_IFINDEX]), ifname);
 297                 printf("%s (phy #%d): ", ifname, nla_get_u32(tb[NL80211_ATTR_WIPHY]));
 298         } else if (tb[NL80211_ATTR_WDEV] && tb[NL80211_ATTR_WIPHY]) {
 299                 printf("wdev 0x%llx (phy #%d): ",
 300                         (unsigned long long)nla_get_u64(tb[NL80211_ATTR_WDEV]),
 301                         nla_get_u32(tb[NL80211_ATTR_WIPHY]));
 302         } else if (tb[NL80211_ATTR_IFINDEX]) {
 303                 if_indextoname(nla_get_u32(tb[NL80211_ATTR_IFINDEX]), ifname);
 304                 printf("%s: ", ifname);
 305         } else if (tb[NL80211_ATTR_WDEV]) {
 306                 printf("wdev 0x%llx: ", (unsigned long long)nla_get_u64(tb[NL80211_ATTR_WDEV]));
 307         } else if (tb[NL80211_ATTR_WIPHY]) {
 308                 printf("phy #%d: ", nla_get_u32(tb[NL80211_ATTR_WIPHY]));
 309         }
 310
 311         switch (gnlh->cmd) {
 312         case NL80211_CMD_NEW_WIPHY:
 313                 printf("renamed to %s\n", nla_get_string(tb[NL80211_ATTR_WIPHY_NAME]));
 314                 break;
 315         case NL80211_CMD_TRIGGER_SCAN:
 316                 printf("scan started\n");
 317                 break;
 318         case NL80211_CMD_NEW_SCAN_RESULTS:
 319                 printf("scan finished:");
 320         case NL80211_CMD_SCAN_ABORTED:
 321                 if (gnlh->cmd == NL80211_CMD_SCAN_ABORTED)
 322                         printf("scan aborted:");
 323                 if (tb[NL80211_ATTR_SCAN_FREQUENCIES]) {
 324                         nla_for_each_nested(nst, tb[NL80211_ATTR_SCAN_FREQUENCIES], rem_nst)
 325                                 printf(" %d", nla_get_u32(nst));
 326                         printf(",");
 327                 }
 328                 if (tb[NL80211_ATTR_SCAN_SSIDS]) {
 329                         nla_for_each_nested(nst, tb[NL80211_ATTR_SCAN_SSIDS], rem_nst) {
 330                                 printf(" \"");
 331                                 print_ssid_escaped(nla_len(nst), nla_data(nst));
 332                                 printf("\"");
 333                         }
 334                 }
 335                 printf("\n");
 336                 break;
 337         case NL80211_CMD_REG_CHANGE:
 338                 printf("regulatory domain change: ");
 339
 340                 reg_type = nla_get_u8(tb[NL80211_ATTR_REG_TYPE]);
 341
 342                 switch (reg_type) {
 343                 case NL80211_REGDOM_TYPE_COUNTRY:
 344                         printf("set to %s by %s request",
 345                                nla_get_string(tb[NL80211_ATTR_REG_ALPHA2]),
 346                                reg_initiator_to_string(nla_get_u8(tb[NL80211_ATTR_REG_INITIATOR])));
 347                         if (tb[NL80211_ATTR_WIPHY])
 348                                 printf(" on phy%d", nla_get_u32(tb[NL80211_ATTR_WIPHY]));
 349                         break;
 350                 case NL80211_REGDOM_TYPE_WORLD:
 351                         printf("set to world roaming by %s request",
 352                                reg_initiator_to_string(nla_get_u8(tb[NL80211_ATTR_REG_INITIATOR])));
 353                         break;
 354                 case NL80211_REGDOM_TYPE_CUSTOM_WORLD:
 355                         printf("custom world roaming rules in place on phy%d by %s request",
 356                                nla_get_u32(tb[NL80211_ATTR_WIPHY]),
 357                                reg_initiator_to_string(nla_get_u32(tb[NL80211_ATTR_REG_INITIATOR])));
 358                         break;
 359                 case NL80211_REGDOM_TYPE_INTERSECTION:
 360                         printf("intersection used due to a request made by %s",
 361                                reg_initiator_to_string(nla_get_u32(tb[NL80211_ATTR_REG_INITIATOR])));
 362                         if (tb[NL80211_ATTR_WIPHY])
 363                                 printf(" on phy%d", nla_get_u32(tb[NL80211_ATTR_WIPHY]));
 364                         break;
 365                 default:
 366                         printf("unknown source (upgrade this utility)");
 367                         break;
 368                 }
 369
 370                 printf("\n");
 371                 break;
 372         case NL80211_CMD_REG_BEACON_HINT:
 373
 374                 wiphy_idx = nla_get_u32(tb[NL80211_ATTR_WIPHY]);
 375
 376                 memset(&chan_before_beacon, 0, sizeof(chan_before_beacon));
 377                 memset(&chan_after_beacon, 0, sizeof(chan_after_beacon));
 378
 379                 if (parse_beacon_hint_chan(tb[NL80211_ATTR_FREQ_BEFORE],
 380                                            &chan_before_beacon))
 381                         break;
 382                 if (parse_beacon_hint_chan(tb[NL80211_ATTR_FREQ_AFTER],
 383                                            &chan_after_beacon))
 384                         break;
 385
 386                 if (chan_before_beacon.center_freq != chan_after_beacon.center_freq)
 387                         break;
 388
 389                 /* A beacon hint is sent _only_ if something _did_ change */
 390                 printf("beacon hint:\n");
 391
 392                 printf("phy%d %d MHz [%d]:\n",
 393                        wiphy_idx,
 394                        chan_before_beacon.center_freq,
 395                        ieee80211_frequency_to_channel(chan_before_beacon.center_freq));
 396
 397                 if (chan_before_beacon.passive_scan && !chan_after_beacon.passive_scan)
 398                         printf("\to active scanning enabled\n");
 399                 if (chan_before_beacon.no_ibss && !chan_after_beacon.no_ibss)
 400                         printf("\to beaconing enabled\n");
 401
 402                 break;
 403         case NL80211_CMD_NEW_STATION:
 404                 mac_addr_n2a(macbuf, nla_data(tb[NL80211_ATTR_MAC]));
 405                 printf("new station %s\n", macbuf);
 406                 break;
 407         case NL80211_CMD_DEL_STATION:
 408                 mac_addr_n2a(macbuf, nla_data(tb[NL80211_ATTR_MAC]));
 409                 printf("del station %s\n", macbuf);
 410                 break;
 411         case NL80211_CMD_JOIN_IBSS:
 412                 mac_addr_n2a(macbuf, nla_data(tb[NL80211_ATTR_MAC]));
 413                 printf("IBSS %s joined\n", macbuf);
 414                 break;
 415         case NL80211_CMD_AUTHENTICATE:
 416                 printf("auth");
 417                 if (tb[NL80211_ATTR_FRAME])
 418                         print_frame(args, tb[NL80211_ATTR_FRAME]);
 419                 else if (tb[NL80211_ATTR_TIMED_OUT])
 420                         printf(": timed out");
 421                 else
 422                         printf(": unknown event");
 423                 printf("\n");
 424                 break;
 425         case NL80211_CMD_ASSOCIATE:
 426                 printf("assoc");
 427                 if (tb[NL80211_ATTR_FRAME])
 428                         print_frame(args, tb[NL80211_ATTR_FRAME]);
 429                 else if (tb[NL80211_ATTR_TIMED_OUT])
 430                         printf(": timed out");
 431                 else
 432                         printf(": unknown event");
 433                 printf("\n");
 434                 break;
 435         case NL80211_CMD_DEAUTHENTICATE:
 436                 printf("deauth");
 437                 print_frame(args, tb[NL80211_ATTR_FRAME]);
 438                 printf("\n");
 439                 break;
 440         case NL80211_CMD_DISASSOCIATE:
 441                 printf("disassoc");
 442                 print_frame(args, tb[NL80211_ATTR_FRAME]);
 443                 printf("\n");
 444                 break;
 445         case NL80211_CMD_UNPROT_DEAUTHENTICATE:
 446                 printf("unprotected deauth");
 447                 print_frame(args, tb[NL80211_ATTR_FRAME]);
 448                 printf("\n");
 449                 break;
 450         case NL80211_CMD_UNPROT_DISASSOCIATE:
 451                 printf("unprotected disassoc");
 452                 print_frame(args, tb[NL80211_ATTR_FRAME]);
 453                 printf("\n");
 454                 break;
 455         case NL80211_CMD_CONNECT:
 456                 status = 0;
 457                 if (!tb[NL80211_ATTR_STATUS_CODE])
 458                         printf("unknown connect status");
 459                 else if (nla_get_u16(tb[NL80211_ATTR_STATUS_CODE]) == 0)
 460                         printf("connected");
 461                 else {
 462                         status = nla_get_u16(tb[NL80211_ATTR_STATUS_CODE]);
 463                         printf("failed to connect");
 464                 }
 465                 if (tb[NL80211_ATTR_MAC]) {
 466                         mac_addr_n2a(macbuf, nla_data(tb[NL80211_ATTR_MAC]));
 467                         printf(" to %s", macbuf);
 468                 }
 469                 if (status)
 470                         printf(", status: %d: %s", status, get_status_str(status));
 471                 printf("\n");
 472                 break;
 473         case NL80211_CMD_ROAM:
 474                 printf("roamed");
 475                 if (tb[NL80211_ATTR_MAC]) {
 476                         mac_addr_n2a(macbuf, nla_data(tb[NL80211_ATTR_MAC]));
 477                         printf(" to %s", macbuf);
 478                 }
 479                 printf("\n");
 480                 break;
 481         case NL80211_CMD_DISCONNECT:
 482                 printf("disconnected");
 483                 if (tb[NL80211_ATTR_DISCONNECTED_BY_AP])
 484                         printf(" (by AP)");
 485                 else
 486                         printf(" (local request)");
 487                 if (tb[NL80211_ATTR_REASON_CODE])
 488                         printf(" reason: %d: %s", nla_get_u16(tb[NL80211_ATTR_REASON_CODE]),
 489                                 get_reason_str(nla_get_u16(tb[NL80211_ATTR_REASON_CODE])));
 490                 printf("\n");
 491                 break;
 492         case NL80211_CMD_REMAIN_ON_CHANNEL:
 493                 printf("remain on freq %d (%dms, cookie %llx)\n",
 494                         nla_get_u32(tb[NL80211_ATTR_WIPHY_FREQ]),
 495                         nla_get_u32(tb[NL80211_ATTR_DURATION]),
 496                         (unsigned long long)nla_get_u64(tb[NL80211_ATTR_COOKIE]));
 497                 break;
 498         case NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL:
 499                 printf("done with remain on freq %d (cookie %llx)\n",
 500                         nla_get_u32(tb[NL80211_ATTR_WIPHY_FREQ]),
 501                         (unsigned long long)nla_get_u64(tb[NL80211_ATTR_COOKIE]));
 502                 break;
 503         case NL80211_CMD_NOTIFY_CQM:
 504                 parse_cqm_event(tb);
 505                 break;
 506         case NL80211_CMD_MICHAEL_MIC_FAILURE:
 507                 parse_mic_failure(tb);
 508                 break;
 509         case NL80211_CMD_FRAME_TX_STATUS:
 510                 printf("mgmt TX status (cookie %llx): %s\n",
 511                         (unsigned long long)nla_get_u64(tb[NL80211_ATTR_COOKIE]),
 512                         tb[NL80211_ATTR_ACK] ? "acked" : "no ack");
 513                 break;
 514         case NL80211_CMD_PMKSA_CANDIDATE:
 515                 printf("PMKSA candidate found\n");
 516                 break;
 517         case NL80211_CMD_SET_WOWLAN:
 518                 parse_wowlan_wake_event(tb);
 519                 break;
 520         default:
 521                 printf("unknown event %d\n", gnlh->cmd);
 522                 break;
 523         }
 524
 525         fflush(stdout);
 526         return NL_SKIP;
 527 }
 528
 529 struct wait_event {
 530         int n_cmds;
 531         const __u32 *cmds;
 532         __u32 cmd;
 533         struct print_event_args *pargs;
 534 };
 535
 536 static int wait_event(struct nl_msg *msg, void *arg)
 537 {
 538         struct wait_event *wait = arg;
 539         struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
 540         int i;
 541
 542         for (i = 0; i < wait->n_cmds; i++) {
 543                 if (gnlh->cmd == wait->cmds[i]) {
 544                         wait->cmd = gnlh->cmd;
 545                         if (wait->pargs)
 546                                 print_event(msg, wait->pargs);
 547                 }
 548         }
 549
 550         return NL_SKIP;
 551 }
 552
 553 int __prepare_listen_events(struct nl80211_state *state)
 554 {
 555         int mcid, ret;
 556
 557         /* Configuration multicast group */
 558         mcid = nl_get_multicast_id(state->nl_sock, "nl80211", "config");
 559         if (mcid < 0)
 560                 return mcid;
 561
 562         ret = nl_socket_add_membership(state->nl_sock, mcid);
 563         if (ret)
 564                 return ret;
 565
 566         /* Scan multicast group */
 567         mcid = nl_get_multicast_id(state->nl_sock, "nl80211", "scan");
 568         if (mcid >= 0) {
 569                 ret = nl_socket_add_membership(state->nl_sock, mcid);
 570                 if (ret)
 571                         return ret;
 572         }
 573
 574         /* Regulatory multicast group */
 575         mcid = nl_get_multicast_id(state->nl_sock, "nl80211", "regulatory");
 576         if (mcid >= 0) {
 577                 ret = nl_socket_add_membership(state->nl_sock, mcid);
 578                 if (ret)
 579                         return ret;
 580         }
 581
 582         /* MLME multicast group */
 583         mcid = nl_get_multicast_id(state->nl_sock, "nl80211", "mlme");
 584         if (mcid >= 0) {
 585                 ret = nl_socket_add_membership(state->nl_sock, mcid);
 586                 if (ret)
 587                         return ret;
 588         }
 589
 590         return 0;
 591 }
 592
 593 __u32 __do_listen_events(struct nl80211_state *state,
 594                          const int n_waits, const __u32 *waits,
 595                          struct print_event_args *args)
 596 {
 597         struct nl_cb *cb = nl_cb_alloc(iw_debug ? NL_CB_DEBUG : NL_CB_DEFAULT);
 598         struct wait_event wait_ev;
 599
 600         if (!cb) {
 601                 fprintf(stderr, "failed to allocate netlink callbacks\n");
 602                 return -ENOMEM;
 603         }
 604
 605         /* no sequence checking for multicast messages */
 606         nl_cb_set(cb, NL_CB_SEQ_CHECK, NL_CB_CUSTOM, no_seq_check, NULL);
 607
 608         if (n_waits && waits) {
 609                 wait_ev.cmds = waits;
 610                 wait_ev.n_cmds = n_waits;
 611                 wait_ev.pargs = args;
 612                 nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, wait_event, &wait_ev);
 613         } else
 614                 nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, print_event, args);
 615
 616         wait_ev.cmd = 0;
 617
 618         while (!wait_ev.cmd)
 619                 nl_recvmsgs(state->nl_sock, cb);
 620
 621         nl_cb_put(cb);
 622
 623         return wait_ev.cmd;
 624 }
 625
 626 __u32 listen_events(struct nl80211_state *state,
 627                     const int n_waits, const __u32 *waits)
 628 {
 629         int ret;
 630
 631         ret = __prepare_listen_events(state);
 632         if (ret)
 633                 return ret;
 634
 635         return __do_listen_events(state, n_waits, waits, NULL);
 636 }
 637
 638 static int print_events(struct nl80211_state *state,
 639                         struct nl_cb *cb,
 640                         struct nl_msg *msg,
 641                         int argc, char **argv,
 642                         enum id_input id)
 643 {
 644         struct print_event_args args;
 645         int ret;
 646
 647         memset(&args, 0, sizeof(args));
 648
 649         argc--;
 650         argv++;
 651
 652         while (argc > 0) {
 653                 if (strcmp(argv[0], "-f") == 0)
 654                         args.frame = true;
 655                 else if (strcmp(argv[0], "-t") == 0)
 656                         args.time = true;
 657                 else if (strcmp(argv[0], "-r") == 0)
 658                         args.reltime = true;
 659                 else
 660                         return 1;
 661                 argc--;
 662                 argv++;
 663         }
 664
 665         if (args.time && args.reltime)
 666                 return 1;
 667
 668         if (argc)
 669                 return 1;
 670
 671         ret = __prepare_listen_events(state);
 672         if (ret)
 673                 return ret;
 674
 675         return __do_listen_events(state, 0, NULL, &args);
 676 }
 677 TOPLEVEL(event, "[-t] [-r] [-f]", 0, 0, CIB_NONE, print_events,
 678         "Monitor events from the kernel.\n"
 679         "-t - print timestamp\n"
 680         "-r - print relative timstamp\n"
 681         "-f - print full frame for auth/assoc etc.");