rx_tdls.c 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568
  1. /*
  2. * Received Data frame processing for TDLS packets
  3. * Copyright (c) 2010, Jouni Malinen <j@w1.fi>
  4. *
  5. * This software may be distributed under the terms of the BSD license.
  6. * See README for more details.
  7. */
  8. #include "utils/includes.h"
  9. #include "utils/common.h"
  10. #include "crypto/sha256.h"
  11. #include "crypto/crypto.h"
  12. #include "crypto/aes_wrap.h"
  13. #include "common/ieee802_11_defs.h"
  14. #include "common/ieee802_11_common.h"
  15. #include "wlantest.h"
  16. static struct wlantest_tdls * get_tdls(struct wlantest *wt, const u8 *linkid,
  17. int create_new, const u8 *bssid)
  18. {
  19. struct wlantest_bss *bss;
  20. struct wlantest_sta *init, *resp;
  21. struct wlantest_tdls *tdls;
  22. bss = bss_find(wt, linkid);
  23. if (bss == NULL && bssid) {
  24. bss = bss_find(wt, bssid);
  25. if (bss)
  26. wpa_printf(MSG_INFO, "TDLS: Incorrect BSSID " MACSTR
  27. " in LinkId?! (init=" MACSTR " resp="
  28. MACSTR ")",
  29. MAC2STR(linkid), MAC2STR(linkid + ETH_ALEN),
  30. MAC2STR(linkid + 2 * ETH_ALEN));
  31. }
  32. if (bss == NULL)
  33. return NULL;
  34. init = sta_find(bss, linkid + ETH_ALEN);
  35. if (init == NULL)
  36. return NULL;
  37. resp = sta_find(bss, linkid + 2 * ETH_ALEN);
  38. if (resp == NULL)
  39. return NULL;
  40. dl_list_for_each(tdls, &bss->tdls, struct wlantest_tdls, list) {
  41. if (tdls->init == init && tdls->resp == resp)
  42. return tdls;
  43. }
  44. if (!create_new)
  45. return NULL;
  46. tdls = os_zalloc(sizeof(*tdls));
  47. if (tdls == NULL)
  48. return NULL;
  49. tdls->init = init;
  50. tdls->resp = resp;
  51. dl_list_add(&bss->tdls, &tdls->list);
  52. return tdls;
  53. }
  54. static int tdls_derive_tpk(struct wlantest_tdls *tdls, const u8 *bssid,
  55. const u8 *ftie, u8 ftie_len)
  56. {
  57. const struct rsn_ftie *f;
  58. u8 key_input[SHA256_MAC_LEN];
  59. const u8 *nonce[2];
  60. size_t len[2];
  61. u8 data[3 * ETH_ALEN];
  62. if (ftie == NULL || ftie_len < sizeof(struct rsn_ftie))
  63. return 0;
  64. f = (const struct rsn_ftie *) ftie;
  65. wpa_hexdump(MSG_DEBUG, "TDLS ANonce", f->anonce, WPA_NONCE_LEN);
  66. wpa_hexdump(MSG_DEBUG, "TDLS SNonce", f->snonce, WPA_NONCE_LEN);
  67. /*
  68. * IEEE Std 802.11z-2010 8.5.9.1:
  69. * TPK-Key-Input = SHA-256(min(SNonce, ANonce) || max(SNonce, ANonce))
  70. */
  71. len[0] = WPA_NONCE_LEN;
  72. len[1] = WPA_NONCE_LEN;
  73. if (os_memcmp(f->anonce, f->snonce, WPA_NONCE_LEN) < 0) {
  74. nonce[0] = f->anonce;
  75. nonce[1] = f->snonce;
  76. } else {
  77. nonce[0] = f->snonce;
  78. nonce[1] = f->anonce;
  79. }
  80. sha256_vector(2, nonce, len, key_input);
  81. wpa_hexdump_key(MSG_DEBUG, "TDLS: TPK-Key-Input",
  82. key_input, SHA256_MAC_LEN);
  83. /*
  84. * TPK-Key-Data = KDF-N_KEY(TPK-Key-Input, "TDLS PMK",
  85. * min(MAC_I, MAC_R) || max(MAC_I, MAC_R) || BSSID || N_KEY)
  86. * TODO: is N_KEY really included in KDF Context and if so, in which
  87. * presentation format (little endian 16-bit?) is it used? It gets
  88. * added by the KDF anyway..
  89. */
  90. if (os_memcmp(tdls->init->addr, tdls->resp->addr, ETH_ALEN) < 0) {
  91. os_memcpy(data, tdls->init->addr, ETH_ALEN);
  92. os_memcpy(data + ETH_ALEN, tdls->resp->addr, ETH_ALEN);
  93. } else {
  94. os_memcpy(data, tdls->resp->addr, ETH_ALEN);
  95. os_memcpy(data + ETH_ALEN, tdls->init->addr, ETH_ALEN);
  96. }
  97. os_memcpy(data + 2 * ETH_ALEN, bssid, ETH_ALEN);
  98. wpa_hexdump(MSG_DEBUG, "TDLS: KDF Context", data, sizeof(data));
  99. sha256_prf(key_input, SHA256_MAC_LEN, "TDLS PMK", data, sizeof(data),
  100. (u8 *) &tdls->tpk, sizeof(tdls->tpk));
  101. wpa_hexdump_key(MSG_DEBUG, "TDLS: TPK-KCK",
  102. tdls->tpk.kck, sizeof(tdls->tpk.kck));
  103. wpa_hexdump_key(MSG_DEBUG, "TDLS: TPK-TK",
  104. tdls->tpk.tk, sizeof(tdls->tpk.tk));
  105. return 1;
  106. }
  107. static int tdls_verify_mic(struct wlantest_tdls *tdls, u8 trans_seq,
  108. struct ieee802_11_elems *elems)
  109. {
  110. u8 *buf, *pos;
  111. int len;
  112. u8 mic[16];
  113. int ret;
  114. const struct rsn_ftie *rx_ftie;
  115. struct rsn_ftie *tmp_ftie;
  116. if (elems->link_id == NULL || elems->rsn_ie == NULL ||
  117. elems->timeout_int == NULL || elems->ftie == NULL)
  118. return -1;
  119. len = 2 * ETH_ALEN + 1 + 2 + 18 + 2 + elems->rsn_ie_len +
  120. 2 + elems->timeout_int_len + 2 + elems->ftie_len;
  121. buf = os_zalloc(len);
  122. if (buf == NULL)
  123. return -1;
  124. pos = buf;
  125. /* 1) TDLS initiator STA MAC address */
  126. os_memcpy(pos, elems->link_id + ETH_ALEN, ETH_ALEN);
  127. pos += ETH_ALEN;
  128. /* 2) TDLS responder STA MAC address */
  129. os_memcpy(pos, elems->link_id + 2 * ETH_ALEN, ETH_ALEN);
  130. pos += ETH_ALEN;
  131. /* 3) Transaction Sequence number */
  132. *pos++ = trans_seq;
  133. /* 4) Link Identifier IE */
  134. os_memcpy(pos, elems->link_id - 2, 2 + 18);
  135. pos += 2 + 18;
  136. /* 5) RSN IE */
  137. os_memcpy(pos, elems->rsn_ie - 2, 2 + elems->rsn_ie_len);
  138. pos += 2 + elems->rsn_ie_len;
  139. /* 6) Timeout Interval IE */
  140. os_memcpy(pos, elems->timeout_int - 2, 2 + elems->timeout_int_len);
  141. pos += 2 + elems->timeout_int_len;
  142. /* 7) FTIE, with the MIC field of the FTIE set to 0 */
  143. os_memcpy(pos, elems->ftie - 2, 2 + elems->ftie_len);
  144. pos += 2;
  145. tmp_ftie = (struct rsn_ftie *) pos;
  146. os_memset(tmp_ftie->mic, 0, 16);
  147. pos += elems->ftie_len;
  148. wpa_hexdump(MSG_DEBUG, "TDLS: Data for FTIE MIC", buf, pos - buf);
  149. wpa_hexdump_key(MSG_DEBUG, "TDLS: KCK", tdls->tpk.kck, 16);
  150. ret = omac1_aes_128(tdls->tpk.kck, buf, pos - buf, mic);
  151. os_free(buf);
  152. if (ret)
  153. return -1;
  154. wpa_hexdump(MSG_DEBUG, "TDLS: FTIE MIC", mic, 16);
  155. rx_ftie = (const struct rsn_ftie *) elems->ftie;
  156. if (os_memcmp(mic, rx_ftie->mic, 16) == 0) {
  157. wpa_printf(MSG_DEBUG, "TDLS: Valid MIC");
  158. return 0;
  159. }
  160. wpa_printf(MSG_DEBUG, "TDLS: Invalid MIC");
  161. return -1;
  162. }
  163. static void rx_data_tdls_setup_request(struct wlantest *wt, const u8 *bssid,
  164. const u8 *sta_addr, const u8 *dst,
  165. const u8 *src,
  166. const u8 *data, size_t len)
  167. {
  168. struct ieee802_11_elems elems;
  169. struct wlantest_tdls *tdls;
  170. if (len < 3) {
  171. wpa_printf(MSG_INFO, "Too short TDLS Setup Request " MACSTR
  172. " -> " MACSTR, MAC2STR(src), MAC2STR(dst));
  173. return;
  174. }
  175. wpa_printf(MSG_DEBUG, "TDLS Setup Request " MACSTR " -> "
  176. MACSTR, MAC2STR(src), MAC2STR(dst));
  177. if (ieee802_11_parse_elems(data + 3, len - 3, &elems, 1) ==
  178. ParseFailed || elems.link_id == NULL)
  179. return;
  180. wpa_printf(MSG_DEBUG, "TDLS Link Identifier: BSSID " MACSTR
  181. " initiator STA " MACSTR " responder STA " MACSTR,
  182. MAC2STR(elems.link_id), MAC2STR(elems.link_id + ETH_ALEN),
  183. MAC2STR(elems.link_id + 2 * ETH_ALEN));
  184. tdls = get_tdls(wt, elems.link_id, 1, bssid);
  185. if (tdls) {
  186. tdls->counters[WLANTEST_TDLS_COUNTER_SETUP_REQ]++;
  187. tdls->dialog_token = data[0];
  188. }
  189. }
  190. static void rx_data_tdls_setup_response_failure(struct wlantest *wt,
  191. const u8 *bssid,
  192. const u8 *sta_addr,
  193. u8 dialog_token, u16 status)
  194. {
  195. struct wlantest_bss *bss;
  196. struct wlantest_tdls *tdls;
  197. struct wlantest_sta *sta;
  198. if (status == WLAN_STATUS_SUCCESS) {
  199. wpa_printf(MSG_INFO, "TDLS: Invalid TDLS Setup Response from "
  200. MACSTR, MAC2STR(sta_addr));
  201. return;
  202. }
  203. bss = bss_find(wt, bssid);
  204. if (!bss)
  205. return;
  206. sta = sta_find(bss, sta_addr);
  207. if (!sta)
  208. return;
  209. dl_list_for_each(tdls, &bss->tdls, struct wlantest_tdls, list) {
  210. if (tdls->resp == sta) {
  211. if (dialog_token != tdls->dialog_token) {
  212. wpa_printf(MSG_DEBUG, "TDLS: Dialog token "
  213. "mismatch in TDLS Setup Response "
  214. "(failure)");
  215. break;
  216. }
  217. wpa_printf(MSG_DEBUG, "TDLS: Found matching TDLS "
  218. "setup session based on dialog token");
  219. tdls->counters[
  220. WLANTEST_TDLS_COUNTER_SETUP_RESP_FAIL]++;
  221. break;
  222. }
  223. }
  224. }
  225. static void rx_data_tdls_setup_response(struct wlantest *wt, const u8 *bssid,
  226. const u8 *sta_addr, const u8 *dst,
  227. const u8 *src,
  228. const u8 *data, size_t len)
  229. {
  230. u16 status;
  231. struct ieee802_11_elems elems;
  232. struct wlantest_tdls *tdls;
  233. if (len < 3) {
  234. wpa_printf(MSG_INFO, "Too short TDLS Setup Response " MACSTR
  235. " -> " MACSTR, MAC2STR(src), MAC2STR(dst));
  236. return;
  237. }
  238. status = WPA_GET_LE16(data);
  239. wpa_printf(MSG_DEBUG, "TDLS Setup Response " MACSTR " -> "
  240. MACSTR " (status %d)",
  241. MAC2STR(src), MAC2STR(dst), status);
  242. if (len < 5 && status == 0) {
  243. wpa_printf(MSG_INFO, "Too short TDLS Setup Response " MACSTR
  244. " -> " MACSTR, MAC2STR(src), MAC2STR(dst));
  245. return;
  246. }
  247. if (len < 5 ||
  248. ieee802_11_parse_elems(data + 5, len - 5, &elems, 1) ==
  249. ParseFailed || elems.link_id == NULL) {
  250. /* Need to match TDLS link based on Dialog Token */
  251. rx_data_tdls_setup_response_failure(wt, bssid, sta_addr,
  252. data[2], status);
  253. return;
  254. }
  255. wpa_printf(MSG_DEBUG, "TDLS Link Identifier: BSSID " MACSTR
  256. " initiator STA " MACSTR " responder STA " MACSTR,
  257. MAC2STR(elems.link_id), MAC2STR(elems.link_id + ETH_ALEN),
  258. MAC2STR(elems.link_id + 2 * ETH_ALEN));
  259. tdls = get_tdls(wt, elems.link_id, 1, bssid);
  260. if (!tdls)
  261. return;
  262. if (status)
  263. tdls->counters[WLANTEST_TDLS_COUNTER_SETUP_RESP_FAIL]++;
  264. else
  265. tdls->counters[WLANTEST_TDLS_COUNTER_SETUP_RESP_OK]++;
  266. if (status != WLAN_STATUS_SUCCESS)
  267. return;
  268. if (tdls_derive_tpk(tdls, bssid, elems.ftie, elems.ftie_len) < 1)
  269. return;
  270. if (tdls_verify_mic(tdls, 2, &elems) == 0) {
  271. tdls->dialog_token = data[2];
  272. wpa_printf(MSG_DEBUG, "TDLS: Dialog Token for the link: %u",
  273. tdls->dialog_token);
  274. }
  275. }
  276. static void rx_data_tdls_setup_confirm_failure(struct wlantest *wt,
  277. const u8 *bssid,
  278. const u8 *src,
  279. u8 dialog_token, u16 status)
  280. {
  281. struct wlantest_bss *bss;
  282. struct wlantest_tdls *tdls;
  283. struct wlantest_sta *sta;
  284. if (status == WLAN_STATUS_SUCCESS) {
  285. wpa_printf(MSG_INFO, "TDLS: Invalid TDLS Setup Confirm from "
  286. MACSTR, MAC2STR(src));
  287. return;
  288. }
  289. bss = bss_find(wt, bssid);
  290. if (!bss)
  291. return;
  292. sta = sta_find(bss, src);
  293. if (!sta)
  294. return;
  295. dl_list_for_each(tdls, &bss->tdls, struct wlantest_tdls, list) {
  296. if (tdls->init == sta) {
  297. if (dialog_token != tdls->dialog_token) {
  298. wpa_printf(MSG_DEBUG, "TDLS: Dialog token "
  299. "mismatch in TDLS Setup Confirm "
  300. "(failure)");
  301. break;
  302. }
  303. wpa_printf(MSG_DEBUG, "TDLS: Found matching TDLS "
  304. "setup session based on dialog token");
  305. tdls->counters[
  306. WLANTEST_TDLS_COUNTER_SETUP_CONF_FAIL]++;
  307. break;
  308. }
  309. }
  310. }
  311. static void rx_data_tdls_setup_confirm(struct wlantest *wt, const u8 *bssid,
  312. const u8 *sta_addr, const u8 *dst,
  313. const u8 *src,
  314. const u8 *data, size_t len)
  315. {
  316. u16 status;
  317. struct ieee802_11_elems elems;
  318. struct wlantest_tdls *tdls;
  319. u8 link_id[3 * ETH_ALEN];
  320. if (len < 3) {
  321. wpa_printf(MSG_INFO, "Too short TDLS Setup Confirm " MACSTR
  322. " -> " MACSTR, MAC2STR(src), MAC2STR(dst));
  323. return;
  324. }
  325. status = WPA_GET_LE16(data);
  326. wpa_printf(MSG_DEBUG, "TDLS Setup Confirm " MACSTR " -> "
  327. MACSTR " (status %d)",
  328. MAC2STR(src), MAC2STR(dst), status);
  329. if (ieee802_11_parse_elems(data + 3, len - 3, &elems, 1) ==
  330. ParseFailed || elems.link_id == NULL) {
  331. /* Need to match TDLS link based on Dialog Token */
  332. rx_data_tdls_setup_confirm_failure(wt, bssid, src,
  333. data[2], status);
  334. return;
  335. }
  336. wpa_printf(MSG_DEBUG, "TDLS Link Identifier: BSSID " MACSTR
  337. " initiator STA " MACSTR " responder STA " MACSTR,
  338. MAC2STR(elems.link_id), MAC2STR(elems.link_id + ETH_ALEN),
  339. MAC2STR(elems.link_id + 2 * ETH_ALEN));
  340. tdls = get_tdls(wt, elems.link_id, 1, bssid);
  341. if (tdls == NULL)
  342. return;
  343. if (status)
  344. tdls->counters[WLANTEST_TDLS_COUNTER_SETUP_CONF_FAIL]++;
  345. else
  346. tdls->counters[WLANTEST_TDLS_COUNTER_SETUP_CONF_OK]++;
  347. if (status != WLAN_STATUS_SUCCESS)
  348. return;
  349. tdls->link_up = 1;
  350. if (tdls_derive_tpk(tdls, bssid, elems.ftie, elems.ftie_len) < 1) {
  351. if (elems.ftie == NULL)
  352. goto remove_reverse;
  353. return;
  354. }
  355. if (tdls_verify_mic(tdls, 3, &elems) == 0) {
  356. tdls->dialog_token = data[2];
  357. wpa_printf(MSG_DEBUG, "TDLS: Dialog Token for the link: %u",
  358. tdls->dialog_token);
  359. }
  360. remove_reverse:
  361. /*
  362. * The TDLS link itself is bidirectional, but there is explicit
  363. * initiator/responder roles. Remove the other direction of the link
  364. * (if it exists) to make sure that the link counters are stored for
  365. * the current TDLS entery.
  366. */
  367. os_memcpy(link_id, elems.link_id, ETH_ALEN);
  368. os_memcpy(link_id + ETH_ALEN, elems.link_id + 2 * ETH_ALEN, ETH_ALEN);
  369. os_memcpy(link_id + 2 * ETH_ALEN, elems.link_id + ETH_ALEN, ETH_ALEN);
  370. tdls = get_tdls(wt, link_id, 0, bssid);
  371. if (tdls) {
  372. wpa_printf(MSG_DEBUG, "TDLS: Remove reverse link entry");
  373. tdls_deinit(tdls);
  374. }
  375. }
  376. static int tdls_verify_mic_teardown(struct wlantest_tdls *tdls, u8 trans_seq,
  377. const u8 *reason_code,
  378. struct ieee802_11_elems *elems)
  379. {
  380. u8 *buf, *pos;
  381. int len;
  382. u8 mic[16];
  383. int ret;
  384. const struct rsn_ftie *rx_ftie;
  385. struct rsn_ftie *tmp_ftie;
  386. if (elems->link_id == NULL || elems->ftie == NULL)
  387. return -1;
  388. len = 2 + 18 + 2 + 1 + 1 + 2 + elems->ftie_len;
  389. buf = os_zalloc(len);
  390. if (buf == NULL)
  391. return -1;
  392. pos = buf;
  393. /* 1) Link Identifier IE */
  394. os_memcpy(pos, elems->link_id - 2, 2 + 18);
  395. pos += 2 + 18;
  396. /* 2) Reason Code */
  397. os_memcpy(pos, reason_code, 2);
  398. pos += 2;
  399. /* 3) Dialog token */
  400. *pos++ = tdls->dialog_token;
  401. /* 4) Transaction Sequence number */
  402. *pos++ = trans_seq;
  403. /* 5) FTIE, with the MIC field of the FTIE set to 0 */
  404. os_memcpy(pos, elems->ftie - 2, 2 + elems->ftie_len);
  405. pos += 2;
  406. tmp_ftie = (struct rsn_ftie *) pos;
  407. os_memset(tmp_ftie->mic, 0, 16);
  408. pos += elems->ftie_len;
  409. wpa_hexdump(MSG_DEBUG, "TDLS: Data for FTIE MIC", buf, pos - buf);
  410. wpa_hexdump_key(MSG_DEBUG, "TDLS: KCK", tdls->tpk.kck, 16);
  411. ret = omac1_aes_128(tdls->tpk.kck, buf, pos - buf, mic);
  412. os_free(buf);
  413. if (ret)
  414. return -1;
  415. wpa_hexdump(MSG_DEBUG, "TDLS: FTIE MIC", mic, 16);
  416. rx_ftie = (const struct rsn_ftie *) elems->ftie;
  417. if (os_memcmp(mic, rx_ftie->mic, 16) == 0) {
  418. wpa_printf(MSG_DEBUG, "TDLS: Valid MIC");
  419. return 0;
  420. }
  421. wpa_printf(MSG_DEBUG, "TDLS: Invalid MIC");
  422. return -1;
  423. }
  424. static void rx_data_tdls_teardown(struct wlantest *wt, const u8 *bssid,
  425. const u8 *sta_addr, const u8 *dst,
  426. const u8 *src,
  427. const u8 *data, size_t len)
  428. {
  429. u16 reason;
  430. struct ieee802_11_elems elems;
  431. struct wlantest_tdls *tdls;
  432. if (len < 2)
  433. return;
  434. reason = WPA_GET_LE16(data);
  435. wpa_printf(MSG_DEBUG, "TDLS Teardown " MACSTR " -> "
  436. MACSTR " (reason %d)",
  437. MAC2STR(src), MAC2STR(dst), reason);
  438. if (ieee802_11_parse_elems(data + 2, len - 2, &elems, 1) ==
  439. ParseFailed || elems.link_id == NULL)
  440. return;
  441. wpa_printf(MSG_DEBUG, "TDLS Link Identifier: BSSID " MACSTR
  442. " initiator STA " MACSTR " responder STA " MACSTR,
  443. MAC2STR(elems.link_id), MAC2STR(elems.link_id + ETH_ALEN),
  444. MAC2STR(elems.link_id + 2 * ETH_ALEN));
  445. tdls = get_tdls(wt, elems.link_id, 1, bssid);
  446. if (tdls) {
  447. tdls->link_up = 0;
  448. tdls->counters[WLANTEST_TDLS_COUNTER_TEARDOWN]++;
  449. tdls_verify_mic_teardown(tdls, 4, data, &elems);
  450. }
  451. }
  452. static void rx_data_tdls(struct wlantest *wt, const u8 *bssid,
  453. const u8 *sta_addr, const u8 *dst, const u8 *src,
  454. const u8 *data, size_t len)
  455. {
  456. /* data contains the payload of a TDLS Action frame */
  457. if (len < 2 || data[0] != WLAN_ACTION_TDLS) {
  458. wpa_hexdump(MSG_DEBUG, "Unrecognized encapsulated TDLS frame",
  459. data, len);
  460. return;
  461. }
  462. switch (data[1]) {
  463. case WLAN_TDLS_SETUP_REQUEST:
  464. rx_data_tdls_setup_request(wt, bssid, sta_addr, dst, src,
  465. data + 2, len - 2);
  466. break;
  467. case WLAN_TDLS_SETUP_RESPONSE:
  468. rx_data_tdls_setup_response(wt, bssid, sta_addr, dst, src,
  469. data + 2, len - 2);
  470. break;
  471. case WLAN_TDLS_SETUP_CONFIRM:
  472. rx_data_tdls_setup_confirm(wt, bssid, sta_addr, dst, src,
  473. data + 2, len - 2);
  474. break;
  475. case WLAN_TDLS_TEARDOWN:
  476. rx_data_tdls_teardown(wt, bssid, sta_addr, dst, src, data + 2,
  477. len - 2);
  478. break;
  479. case WLAN_TDLS_DISCOVERY_REQUEST:
  480. wpa_printf(MSG_DEBUG, "TDLS Discovery Request " MACSTR " -> "
  481. MACSTR, MAC2STR(src), MAC2STR(dst));
  482. break;
  483. }
  484. }
  485. void rx_data_80211_encap(struct wlantest *wt, const u8 *bssid,
  486. const u8 *sta_addr, const u8 *dst, const u8 *src,
  487. const u8 *data, size_t len)
  488. {
  489. wpa_hexdump(MSG_EXCESSIVE, "802.11 data encap frame", data, len);
  490. if (len < 1)
  491. return;
  492. if (data[0] == 0x02)
  493. rx_data_tdls(wt, bssid, sta_addr, dst, src, data + 1, len - 1);
  494. }