wlantest_cli.c 38 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720
  1. /*
  2. * wlantest controller
  3. * Copyright (c) 2010, Jouni Malinen <j@w1.fi>
  4. *
  5. * This program is free software; you can redistribute it and/or modify
  6. * it under the terms of the GNU General Public License version 2 as
  7. * published by the Free Software Foundation.
  8. *
  9. * Alternatively, this software may be distributed under the terms of BSD
  10. * license.
  11. *
  12. * See README and COPYING for more details.
  13. */
  14. #include "utils/includes.h"
  15. #include <sys/un.h>
  16. #include "utils/common.h"
  17. #include "utils/eloop.h"
  18. #include "utils/edit.h"
  19. #include "wlantest_ctrl.h"
  20. static int get_cmd_arg_num(const char *str, int pos)
  21. {
  22. int arg = 0, i;
  23. for (i = 0; i <= pos; i++) {
  24. if (str[i] != ' ') {
  25. arg++;
  26. while (i <= pos && str[i] != ' ')
  27. i++;
  28. }
  29. }
  30. if (arg > 0)
  31. arg--;
  32. return arg;
  33. }
  34. static int get_prev_arg_pos(const char *str, int pos)
  35. {
  36. while (pos > 0 && str[pos - 1] != ' ')
  37. pos--;
  38. while (pos > 0 && str[pos - 1] == ' ')
  39. pos--;
  40. while (pos > 0 && str[pos - 1] != ' ')
  41. pos--;
  42. return pos;
  43. }
  44. static u8 * attr_get(u8 *buf, size_t buflen, enum wlantest_ctrl_attr attr,
  45. size_t *len)
  46. {
  47. u8 *pos = buf;
  48. while (pos + 8 <= buf + buflen) {
  49. enum wlantest_ctrl_attr a;
  50. size_t alen;
  51. a = WPA_GET_BE32(pos);
  52. pos += 4;
  53. alen = WPA_GET_BE32(pos);
  54. pos += 4;
  55. if (pos + alen > buf + buflen) {
  56. printf("Invalid control message attribute\n");
  57. return NULL;
  58. }
  59. if (a == attr) {
  60. *len = alen;
  61. return pos;
  62. }
  63. pos += alen;
  64. }
  65. return NULL;
  66. }
  67. static u8 * attr_hdr_add(u8 *pos, u8 *end, enum wlantest_ctrl_attr attr,
  68. size_t len)
  69. {
  70. if (pos == NULL || end - pos < 8 + len)
  71. return NULL;
  72. WPA_PUT_BE32(pos, attr);
  73. pos += 4;
  74. WPA_PUT_BE32(pos, len);
  75. pos += 4;
  76. return pos;
  77. }
  78. static u8 * attr_add_str(u8 *pos, u8 *end, enum wlantest_ctrl_attr attr,
  79. const char *str)
  80. {
  81. size_t len = os_strlen(str);
  82. if (pos == NULL || end - pos < 8 + len)
  83. return NULL;
  84. WPA_PUT_BE32(pos, attr);
  85. pos += 4;
  86. WPA_PUT_BE32(pos, len);
  87. pos += 4;
  88. os_memcpy(pos, str, len);
  89. pos += len;
  90. return pos;
  91. }
  92. static u8 * attr_add_be32(u8 *pos, u8 *end, enum wlantest_ctrl_attr attr,
  93. u32 val)
  94. {
  95. if (pos == NULL || end - pos < 12)
  96. return NULL;
  97. WPA_PUT_BE32(pos, attr);
  98. pos += 4;
  99. WPA_PUT_BE32(pos, 4);
  100. pos += 4;
  101. WPA_PUT_BE32(pos, val);
  102. pos += 4;
  103. return pos;
  104. }
  105. static int cmd_send_and_recv(int s, const u8 *cmd, size_t cmd_len,
  106. u8 *resp, size_t max_resp_len)
  107. {
  108. int res;
  109. enum wlantest_ctrl_cmd cmd_resp;
  110. if (send(s, cmd, cmd_len, 0) < 0)
  111. return -1;
  112. res = recv(s, resp, max_resp_len, 0);
  113. if (res < 4)
  114. return -1;
  115. cmd_resp = WPA_GET_BE32(resp);
  116. if (cmd_resp == WLANTEST_CTRL_SUCCESS)
  117. return res;
  118. if (cmd_resp == WLANTEST_CTRL_UNKNOWN_CMD)
  119. printf("Unknown command\n");
  120. else if (cmd_resp == WLANTEST_CTRL_INVALID_CMD)
  121. printf("Invalid command\n");
  122. return -1;
  123. }
  124. static int cmd_simple(int s, enum wlantest_ctrl_cmd cmd)
  125. {
  126. u8 buf[4];
  127. int res;
  128. WPA_PUT_BE32(buf, cmd);
  129. res = cmd_send_and_recv(s, buf, sizeof(buf), buf, sizeof(buf));
  130. return res < 0 ? -1 : 0;
  131. }
  132. static char ** get_bssid_list(int s)
  133. {
  134. u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
  135. u8 buf[4];
  136. u8 *bssid;
  137. size_t len;
  138. int rlen, i;
  139. char **res;
  140. WPA_PUT_BE32(buf, WLANTEST_CTRL_LIST_BSS);
  141. rlen = cmd_send_and_recv(s, buf, sizeof(buf), resp, sizeof(resp));
  142. if (rlen < 0)
  143. return NULL;
  144. bssid = attr_get(resp + 4, rlen - 4, WLANTEST_ATTR_BSSID, &len);
  145. if (bssid == NULL)
  146. return NULL;
  147. res = os_zalloc((len / ETH_ALEN + 1) * sizeof(char *));
  148. if (res == NULL)
  149. return NULL;
  150. for (i = 0; i < len / ETH_ALEN; i++) {
  151. res[i] = os_zalloc(18);
  152. if (res[i] == NULL)
  153. break;
  154. os_snprintf(res[i], 18, MACSTR, MAC2STR(bssid + ETH_ALEN * i));
  155. }
  156. return res;
  157. }
  158. static char ** get_sta_list(int s, const u8 *bssid, int add_bcast)
  159. {
  160. u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
  161. u8 buf[100], *pos, *end;
  162. u8 *addr;
  163. size_t len;
  164. int rlen, i;
  165. char **res;
  166. pos = buf;
  167. end = buf + sizeof(buf);
  168. WPA_PUT_BE32(pos, WLANTEST_CTRL_LIST_STA);
  169. pos += 4;
  170. pos = attr_hdr_add(pos, end, WLANTEST_ATTR_BSSID, ETH_ALEN);
  171. os_memcpy(pos, bssid, ETH_ALEN);
  172. pos += ETH_ALEN;
  173. rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
  174. if (rlen < 0)
  175. return NULL;
  176. addr = attr_get(resp + 4, rlen - 4, WLANTEST_ATTR_STA_ADDR, &len);
  177. if (addr == NULL)
  178. return NULL;
  179. res = os_zalloc((len / ETH_ALEN + 1 + add_bcast) * sizeof(char *));
  180. if (res == NULL)
  181. return NULL;
  182. for (i = 0; i < len / ETH_ALEN; i++) {
  183. res[i] = os_zalloc(18);
  184. if (res[i] == NULL)
  185. break;
  186. os_snprintf(res[i], 18, MACSTR, MAC2STR(addr + ETH_ALEN * i));
  187. }
  188. if (add_bcast)
  189. res[i] = os_strdup("ff:ff:ff:ff:ff:ff");
  190. return res;
  191. }
  192. static int cmd_ping(int s, int argc, char *argv[])
  193. {
  194. int res = cmd_simple(s, WLANTEST_CTRL_PING);
  195. if (res == 0)
  196. printf("PONG\n");
  197. return res == 0;
  198. }
  199. static int cmd_terminate(int s, int argc, char *argv[])
  200. {
  201. return cmd_simple(s, WLANTEST_CTRL_TERMINATE);
  202. }
  203. static int cmd_list_bss(int s, int argc, char *argv[])
  204. {
  205. u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
  206. u8 buf[4];
  207. u8 *bssid;
  208. size_t len;
  209. int rlen, i;
  210. WPA_PUT_BE32(buf, WLANTEST_CTRL_LIST_BSS);
  211. rlen = cmd_send_and_recv(s, buf, sizeof(buf), resp, sizeof(resp));
  212. if (rlen < 0)
  213. return -1;
  214. bssid = attr_get(resp + 4, rlen - 4, WLANTEST_ATTR_BSSID, &len);
  215. if (bssid == NULL)
  216. return -1;
  217. for (i = 0; i < len / ETH_ALEN; i++)
  218. printf(MACSTR " ", MAC2STR(bssid + ETH_ALEN * i));
  219. printf("\n");
  220. return 0;
  221. }
  222. static int cmd_list_sta(int s, int argc, char *argv[])
  223. {
  224. u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
  225. u8 buf[100], *pos;
  226. u8 *addr;
  227. size_t len;
  228. int rlen, i;
  229. if (argc < 1) {
  230. printf("list_sta needs one argument: BSSID\n");
  231. return -1;
  232. }
  233. pos = buf;
  234. WPA_PUT_BE32(pos, WLANTEST_CTRL_LIST_STA);
  235. pos += 4;
  236. WPA_PUT_BE32(pos, WLANTEST_ATTR_BSSID);
  237. pos += 4;
  238. WPA_PUT_BE32(pos, ETH_ALEN);
  239. pos += 4;
  240. if (hwaddr_aton(argv[0], pos) < 0) {
  241. printf("Invalid BSSID '%s'\n", argv[0]);
  242. return -1;
  243. }
  244. pos += ETH_ALEN;
  245. rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
  246. if (rlen < 0)
  247. return -1;
  248. addr = attr_get(resp + 4, rlen - 4, WLANTEST_ATTR_STA_ADDR, &len);
  249. if (addr == NULL)
  250. return -1;
  251. for (i = 0; i < len / ETH_ALEN; i++)
  252. printf(MACSTR " ", MAC2STR(addr + ETH_ALEN * i));
  253. printf("\n");
  254. return 0;
  255. }
  256. static char ** complete_list_sta(int s, const char *str, int pos)
  257. {
  258. if (get_cmd_arg_num(str, pos) == 1)
  259. return get_bssid_list(s);
  260. return NULL;
  261. }
  262. static int cmd_flush(int s, int argc, char *argv[])
  263. {
  264. return cmd_simple(s, WLANTEST_CTRL_FLUSH);
  265. }
  266. static int cmd_clear_sta_counters(int s, int argc, char *argv[])
  267. {
  268. u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
  269. u8 buf[100], *pos;
  270. int rlen;
  271. if (argc < 2) {
  272. printf("clear_sta_counters needs two arguments: BSSID and "
  273. "STA address\n");
  274. return -1;
  275. }
  276. pos = buf;
  277. WPA_PUT_BE32(pos, WLANTEST_CTRL_CLEAR_STA_COUNTERS);
  278. pos += 4;
  279. WPA_PUT_BE32(pos, WLANTEST_ATTR_BSSID);
  280. pos += 4;
  281. WPA_PUT_BE32(pos, ETH_ALEN);
  282. pos += 4;
  283. if (hwaddr_aton(argv[0], pos) < 0) {
  284. printf("Invalid BSSID '%s'\n", argv[0]);
  285. return -1;
  286. }
  287. pos += ETH_ALEN;
  288. WPA_PUT_BE32(pos, WLANTEST_ATTR_STA_ADDR);
  289. pos += 4;
  290. WPA_PUT_BE32(pos, ETH_ALEN);
  291. pos += 4;
  292. if (hwaddr_aton(argv[1], pos) < 0) {
  293. printf("Invalid STA address '%s'\n", argv[1]);
  294. return -1;
  295. }
  296. pos += ETH_ALEN;
  297. rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
  298. if (rlen < 0)
  299. return -1;
  300. printf("OK\n");
  301. return 0;
  302. }
  303. static char ** complete_clear_sta_counters(int s, const char *str, int pos)
  304. {
  305. int arg = get_cmd_arg_num(str, pos);
  306. char **res = NULL;
  307. u8 addr[ETH_ALEN];
  308. switch (arg) {
  309. case 1:
  310. res = get_bssid_list(s);
  311. break;
  312. case 2:
  313. if (hwaddr_aton(&str[get_prev_arg_pos(str, pos)], addr) < 0)
  314. break;
  315. res = get_sta_list(s, addr, 0);
  316. break;
  317. }
  318. return res;
  319. }
  320. static int cmd_clear_bss_counters(int s, int argc, char *argv[])
  321. {
  322. u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
  323. u8 buf[100], *pos;
  324. int rlen;
  325. if (argc < 1) {
  326. printf("clear_bss_counters needs one argument: BSSID\n");
  327. return -1;
  328. }
  329. pos = buf;
  330. WPA_PUT_BE32(pos, WLANTEST_CTRL_CLEAR_BSS_COUNTERS);
  331. pos += 4;
  332. WPA_PUT_BE32(pos, WLANTEST_ATTR_BSSID);
  333. pos += 4;
  334. WPA_PUT_BE32(pos, ETH_ALEN);
  335. pos += 4;
  336. if (hwaddr_aton(argv[0], pos) < 0) {
  337. printf("Invalid BSSID '%s'\n", argv[0]);
  338. return -1;
  339. }
  340. pos += ETH_ALEN;
  341. rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
  342. if (rlen < 0)
  343. return -1;
  344. printf("OK\n");
  345. return 0;
  346. }
  347. static char ** complete_clear_bss_counters(int s, const char *str, int pos)
  348. {
  349. if (get_cmd_arg_num(str, pos) == 1)
  350. return get_bssid_list(s);
  351. return NULL;
  352. }
  353. static int cmd_clear_tdls_counters(int s, int argc, char *argv[])
  354. {
  355. u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
  356. u8 buf[100], *pos;
  357. int rlen;
  358. if (argc < 3) {
  359. printf("clear_tdls_counters needs three arguments: BSSID, "
  360. "STA1 address, STA2 address\n");
  361. return -1;
  362. }
  363. pos = buf;
  364. WPA_PUT_BE32(pos, WLANTEST_CTRL_CLEAR_TDLS_COUNTERS);
  365. pos += 4;
  366. WPA_PUT_BE32(pos, WLANTEST_ATTR_BSSID);
  367. pos += 4;
  368. WPA_PUT_BE32(pos, ETH_ALEN);
  369. pos += 4;
  370. if (hwaddr_aton(argv[0], pos) < 0) {
  371. printf("Invalid BSSID '%s'\n", argv[0]);
  372. return -1;
  373. }
  374. pos += ETH_ALEN;
  375. WPA_PUT_BE32(pos, WLANTEST_ATTR_STA_ADDR);
  376. pos += 4;
  377. WPA_PUT_BE32(pos, ETH_ALEN);
  378. pos += 4;
  379. if (hwaddr_aton(argv[1], pos) < 0) {
  380. printf("Invalid STA1 address '%s'\n", argv[1]);
  381. return -1;
  382. }
  383. pos += ETH_ALEN;
  384. WPA_PUT_BE32(pos, WLANTEST_ATTR_STA2_ADDR);
  385. pos += 4;
  386. WPA_PUT_BE32(pos, ETH_ALEN);
  387. pos += 4;
  388. if (hwaddr_aton(argv[2], pos) < 0) {
  389. printf("Invalid STA2 address '%s'\n", argv[2]);
  390. return -1;
  391. }
  392. pos += ETH_ALEN;
  393. rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
  394. if (rlen < 0)
  395. return -1;
  396. printf("OK\n");
  397. return 0;
  398. }
  399. static char ** complete_clear_tdls_counters(int s, const char *str, int pos)
  400. {
  401. int arg = get_cmd_arg_num(str, pos);
  402. char **res = NULL;
  403. u8 addr[ETH_ALEN];
  404. switch (arg) {
  405. case 1:
  406. res = get_bssid_list(s);
  407. break;
  408. case 2:
  409. case 3:
  410. if (hwaddr_aton(&str[get_prev_arg_pos(str, pos)], addr) < 0)
  411. break;
  412. res = get_sta_list(s, addr, 0);
  413. break;
  414. }
  415. return res;
  416. }
  417. struct sta_counters {
  418. const char *name;
  419. enum wlantest_sta_counter num;
  420. };
  421. static const struct sta_counters sta_counters[] = {
  422. { "auth_tx", WLANTEST_STA_COUNTER_AUTH_TX },
  423. { "auth_rx", WLANTEST_STA_COUNTER_AUTH_RX },
  424. { "assocreq_tx", WLANTEST_STA_COUNTER_ASSOCREQ_TX },
  425. { "reassocreq_tx", WLANTEST_STA_COUNTER_REASSOCREQ_TX },
  426. { "ptk_learned", WLANTEST_STA_COUNTER_PTK_LEARNED },
  427. { "valid_deauth_tx", WLANTEST_STA_COUNTER_VALID_DEAUTH_TX },
  428. { "valid_deauth_rx", WLANTEST_STA_COUNTER_VALID_DEAUTH_RX },
  429. { "invalid_deauth_tx", WLANTEST_STA_COUNTER_INVALID_DEAUTH_TX },
  430. { "invalid_deauth_rx", WLANTEST_STA_COUNTER_INVALID_DEAUTH_RX },
  431. { "valid_disassoc_tx", WLANTEST_STA_COUNTER_VALID_DISASSOC_TX },
  432. { "valid_disassoc_rx", WLANTEST_STA_COUNTER_VALID_DISASSOC_RX },
  433. { "invalid_disassoc_tx", WLANTEST_STA_COUNTER_INVALID_DISASSOC_TX },
  434. { "invalid_disassoc_rx", WLANTEST_STA_COUNTER_INVALID_DISASSOC_RX },
  435. { "valid_saqueryreq_tx", WLANTEST_STA_COUNTER_VALID_SAQUERYREQ_TX },
  436. { "valid_saqueryreq_rx", WLANTEST_STA_COUNTER_VALID_SAQUERYREQ_RX },
  437. { "invalid_saqueryreq_tx",
  438. WLANTEST_STA_COUNTER_INVALID_SAQUERYREQ_TX },
  439. { "invalid_saqueryreq_rx",
  440. WLANTEST_STA_COUNTER_INVALID_SAQUERYREQ_RX },
  441. { "valid_saqueryresp_tx", WLANTEST_STA_COUNTER_VALID_SAQUERYRESP_TX },
  442. { "valid_saqueryresp_rx", WLANTEST_STA_COUNTER_VALID_SAQUERYRESP_RX },
  443. { "invalid_saqueryresp_tx",
  444. WLANTEST_STA_COUNTER_INVALID_SAQUERYRESP_TX },
  445. { "invalid_saqueryresp_rx",
  446. WLANTEST_STA_COUNTER_INVALID_SAQUERYRESP_RX },
  447. { "ping_ok", WLANTEST_STA_COUNTER_PING_OK },
  448. { "assocresp_comeback", WLANTEST_STA_COUNTER_ASSOCRESP_COMEBACK },
  449. { "reassocresp_comeback", WLANTEST_STA_COUNTER_REASSOCRESP_COMEBACK },
  450. { "ping_ok_first_assoc", WLANTEST_STA_COUNTER_PING_OK_FIRST_ASSOC },
  451. { "valid_deauth_rx_ack", WLANTEST_STA_COUNTER_VALID_DEAUTH_RX_ACK },
  452. { "valid_disassoc_rx_ack",
  453. WLANTEST_STA_COUNTER_VALID_DISASSOC_RX_ACK },
  454. { "invalid_deauth_rx_ack",
  455. WLANTEST_STA_COUNTER_INVALID_DEAUTH_RX_ACK },
  456. { "invalid_disassoc_rx_ack",
  457. WLANTEST_STA_COUNTER_INVALID_DISASSOC_RX_ACK },
  458. { "deauth_rx_asleep", WLANTEST_STA_COUNTER_DEAUTH_RX_ASLEEP },
  459. { "deauth_rx_awake", WLANTEST_STA_COUNTER_DEAUTH_RX_AWAKE },
  460. { "disassoc_rx_asleep", WLANTEST_STA_COUNTER_DISASSOC_RX_ASLEEP },
  461. { "disassoc_rx_awake", WLANTEST_STA_COUNTER_DISASSOC_RX_AWAKE },
  462. { "prot_data_tx", WLANTEST_STA_COUNTER_PROT_DATA_TX },
  463. { "deauth_rx_rc6", WLANTEST_STA_COUNTER_DEAUTH_RX_RC6 },
  464. { "deauth_rx_rc7", WLANTEST_STA_COUNTER_DEAUTH_RX_RC7 },
  465. { "disassoc_rx_rc6", WLANTEST_STA_COUNTER_DISASSOC_RX_RC6 },
  466. { "disassoc_rx_rc7", WLANTEST_STA_COUNTER_DISASSOC_RX_RC7 },
  467. { NULL, 0 }
  468. };
  469. static int cmd_get_sta_counter(int s, int argc, char *argv[])
  470. {
  471. u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
  472. u8 buf[100], *end, *pos;
  473. int rlen, i;
  474. size_t len;
  475. if (argc != 3) {
  476. printf("get_sta_counter needs at three arguments: "
  477. "counter name, BSSID, and STA address\n");
  478. return -1;
  479. }
  480. pos = buf;
  481. end = buf + sizeof(buf);
  482. WPA_PUT_BE32(pos, WLANTEST_CTRL_GET_STA_COUNTER);
  483. pos += 4;
  484. for (i = 0; sta_counters[i].name; i++) {
  485. if (os_strcasecmp(sta_counters[i].name, argv[0]) == 0)
  486. break;
  487. }
  488. if (sta_counters[i].name == NULL) {
  489. printf("Unknown STA counter '%s'\n", argv[0]);
  490. printf("Counters:");
  491. for (i = 0; sta_counters[i].name; i++)
  492. printf(" %s", sta_counters[i].name);
  493. printf("\n");
  494. return -1;
  495. }
  496. pos = attr_add_be32(pos, end, WLANTEST_ATTR_STA_COUNTER,
  497. sta_counters[i].num);
  498. pos = attr_hdr_add(pos, end, WLANTEST_ATTR_BSSID, ETH_ALEN);
  499. if (hwaddr_aton(argv[1], pos) < 0) {
  500. printf("Invalid BSSID '%s'\n", argv[1]);
  501. return -1;
  502. }
  503. pos += ETH_ALEN;
  504. pos = attr_hdr_add(pos, end, WLANTEST_ATTR_STA_ADDR, ETH_ALEN);
  505. if (hwaddr_aton(argv[2], pos) < 0) {
  506. printf("Invalid STA address '%s'\n", argv[2]);
  507. return -1;
  508. }
  509. pos += ETH_ALEN;
  510. rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
  511. if (rlen < 0)
  512. return -1;
  513. pos = attr_get(resp + 4, rlen - 4, WLANTEST_ATTR_COUNTER, &len);
  514. if (pos == NULL || len != 4)
  515. return -1;
  516. printf("%u\n", WPA_GET_BE32(pos));
  517. return 0;
  518. }
  519. static char ** complete_get_sta_counter(int s, const char *str, int pos)
  520. {
  521. int arg = get_cmd_arg_num(str, pos);
  522. char **res = NULL;
  523. int i, count;
  524. u8 addr[ETH_ALEN];
  525. switch (arg) {
  526. case 1:
  527. /* counter list */
  528. count = sizeof(sta_counters) / sizeof(sta_counters[0]);
  529. res = os_zalloc(count * sizeof(char *));
  530. if (res == NULL)
  531. return NULL;
  532. for (i = 0; sta_counters[i].name; i++) {
  533. res[i] = os_strdup(sta_counters[i].name);
  534. if (res[i] == NULL)
  535. break;
  536. }
  537. break;
  538. case 2:
  539. res = get_bssid_list(s);
  540. break;
  541. case 3:
  542. if (hwaddr_aton(&str[get_prev_arg_pos(str, pos)], addr) < 0)
  543. break;
  544. res = get_sta_list(s, addr, 0);
  545. break;
  546. }
  547. return res;
  548. }
  549. struct bss_counters {
  550. const char *name;
  551. enum wlantest_bss_counter num;
  552. };
  553. static const struct bss_counters bss_counters[] = {
  554. { "valid_bip_mmie", WLANTEST_BSS_COUNTER_VALID_BIP_MMIE },
  555. { "invalid_bip_mmie", WLANTEST_BSS_COUNTER_INVALID_BIP_MMIE },
  556. { "missing_bip_mmie", WLANTEST_BSS_COUNTER_MISSING_BIP_MMIE },
  557. { "bip_deauth", WLANTEST_BSS_COUNTER_BIP_DEAUTH },
  558. { "bip_disassoc", WLANTEST_BSS_COUNTER_BIP_DISASSOC },
  559. { NULL, 0 }
  560. };
  561. static int cmd_get_bss_counter(int s, int argc, char *argv[])
  562. {
  563. u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
  564. u8 buf[100], *end, *pos;
  565. int rlen, i;
  566. size_t len;
  567. if (argc != 2) {
  568. printf("get_bss_counter needs at two arguments: "
  569. "counter name and BSSID\n");
  570. return -1;
  571. }
  572. pos = buf;
  573. end = buf + sizeof(buf);
  574. WPA_PUT_BE32(pos, WLANTEST_CTRL_GET_BSS_COUNTER);
  575. pos += 4;
  576. for (i = 0; bss_counters[i].name; i++) {
  577. if (os_strcasecmp(bss_counters[i].name, argv[0]) == 0)
  578. break;
  579. }
  580. if (bss_counters[i].name == NULL) {
  581. printf("Unknown BSS counter '%s'\n", argv[0]);
  582. printf("Counters:");
  583. for (i = 0; bss_counters[i].name; i++)
  584. printf(" %s", bss_counters[i].name);
  585. printf("\n");
  586. return -1;
  587. }
  588. pos = attr_add_be32(pos, end, WLANTEST_ATTR_BSS_COUNTER,
  589. bss_counters[i].num);
  590. pos = attr_hdr_add(pos, end, WLANTEST_ATTR_BSSID, ETH_ALEN);
  591. if (hwaddr_aton(argv[1], pos) < 0) {
  592. printf("Invalid BSSID '%s'\n", argv[1]);
  593. return -1;
  594. }
  595. pos += ETH_ALEN;
  596. rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
  597. if (rlen < 0)
  598. return -1;
  599. pos = attr_get(resp + 4, rlen - 4, WLANTEST_ATTR_COUNTER, &len);
  600. if (pos == NULL || len != 4)
  601. return -1;
  602. printf("%u\n", WPA_GET_BE32(pos));
  603. return 0;
  604. }
  605. static char ** complete_get_bss_counter(int s, const char *str, int pos)
  606. {
  607. int arg = get_cmd_arg_num(str, pos);
  608. char **res = NULL;
  609. int i, count;
  610. switch (arg) {
  611. case 1:
  612. /* counter list */
  613. count = sizeof(bss_counters) / sizeof(bss_counters[0]);
  614. res = os_zalloc(count * sizeof(char *));
  615. if (res == NULL)
  616. return NULL;
  617. for (i = 0; bss_counters[i].name; i++) {
  618. res[i] = os_strdup(bss_counters[i].name);
  619. if (res[i] == NULL)
  620. break;
  621. }
  622. break;
  623. case 2:
  624. res = get_bssid_list(s);
  625. break;
  626. }
  627. return res;
  628. }
  629. struct tdls_counters {
  630. const char *name;
  631. enum wlantest_tdls_counter num;
  632. };
  633. static const struct tdls_counters tdls_counters[] = {
  634. { "valid_direct_link", WLANTEST_TDLS_COUNTER_VALID_DIRECT_LINK },
  635. { "invalid_direct_link", WLANTEST_TDLS_COUNTER_INVALID_DIRECT_LINK },
  636. { "valid_ap_path", WLANTEST_TDLS_COUNTER_VALID_AP_PATH },
  637. { "invalid_ap_path", WLANTEST_TDLS_COUNTER_INVALID_AP_PATH },
  638. { "setup_req", WLANTEST_TDLS_COUNTER_SETUP_REQ },
  639. { "setup_resp_ok", WLANTEST_TDLS_COUNTER_SETUP_RESP_OK },
  640. { "setup_resp_fail", WLANTEST_TDLS_COUNTER_SETUP_RESP_FAIL },
  641. { "setup_conf_ok", WLANTEST_TDLS_COUNTER_SETUP_CONF_OK },
  642. { "setup_conf_fail", WLANTEST_TDLS_COUNTER_SETUP_CONF_FAIL },
  643. { "teardown", WLANTEST_TDLS_COUNTER_TEARDOWN },
  644. { NULL, 0 }
  645. };
  646. static int cmd_get_tdls_counter(int s, int argc, char *argv[])
  647. {
  648. u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
  649. u8 buf[100], *end, *pos;
  650. int rlen, i;
  651. size_t len;
  652. if (argc != 4) {
  653. printf("get_tdls_counter needs four arguments: "
  654. "counter name, BSSID, STA1 address, STA2 address\n");
  655. return -1;
  656. }
  657. pos = buf;
  658. end = buf + sizeof(buf);
  659. WPA_PUT_BE32(pos, WLANTEST_CTRL_GET_TDLS_COUNTER);
  660. pos += 4;
  661. for (i = 0; tdls_counters[i].name; i++) {
  662. if (os_strcasecmp(tdls_counters[i].name, argv[0]) == 0)
  663. break;
  664. }
  665. if (tdls_counters[i].name == NULL) {
  666. printf("Unknown TDLS counter '%s'\n", argv[0]);
  667. printf("Counters:");
  668. for (i = 0; tdls_counters[i].name; i++)
  669. printf(" %s", tdls_counters[i].name);
  670. printf("\n");
  671. return -1;
  672. }
  673. pos = attr_add_be32(pos, end, WLANTEST_ATTR_TDLS_COUNTER,
  674. tdls_counters[i].num);
  675. pos = attr_hdr_add(pos, end, WLANTEST_ATTR_BSSID, ETH_ALEN);
  676. if (hwaddr_aton(argv[1], pos) < 0) {
  677. printf("Invalid BSSID '%s'\n", argv[1]);
  678. return -1;
  679. }
  680. pos += ETH_ALEN;
  681. pos = attr_hdr_add(pos, end, WLANTEST_ATTR_STA_ADDR, ETH_ALEN);
  682. if (hwaddr_aton(argv[2], pos) < 0) {
  683. printf("Invalid STA1 address '%s'\n", argv[2]);
  684. return -1;
  685. }
  686. pos += ETH_ALEN;
  687. pos = attr_hdr_add(pos, end, WLANTEST_ATTR_STA2_ADDR, ETH_ALEN);
  688. if (hwaddr_aton(argv[3], pos) < 0) {
  689. printf("Invalid STA2 address '%s'\n", argv[3]);
  690. return -1;
  691. }
  692. pos += ETH_ALEN;
  693. rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
  694. if (rlen < 0)
  695. return -1;
  696. pos = attr_get(resp + 4, rlen - 4, WLANTEST_ATTR_COUNTER, &len);
  697. if (pos == NULL || len != 4)
  698. return -1;
  699. printf("%u\n", WPA_GET_BE32(pos));
  700. return 0;
  701. }
  702. static char ** complete_get_tdls_counter(int s, const char *str, int pos)
  703. {
  704. int arg = get_cmd_arg_num(str, pos);
  705. char **res = NULL;
  706. int i, count;
  707. u8 addr[ETH_ALEN];
  708. switch (arg) {
  709. case 1:
  710. /* counter list */
  711. count = sizeof(tdls_counters) / sizeof(tdls_counters[0]);
  712. res = os_zalloc(count * sizeof(char *));
  713. if (res == NULL)
  714. return NULL;
  715. for (i = 0; tdls_counters[i].name; i++) {
  716. res[i] = os_strdup(tdls_counters[i].name);
  717. if (res[i] == NULL)
  718. break;
  719. }
  720. break;
  721. case 2:
  722. res = get_bssid_list(s);
  723. break;
  724. case 3:
  725. case 4:
  726. if (hwaddr_aton(&str[get_prev_arg_pos(str, pos)], addr) < 0)
  727. break;
  728. res = get_sta_list(s, addr, 0);
  729. break;
  730. }
  731. return res;
  732. }
  733. struct inject_frames {
  734. const char *name;
  735. enum wlantest_inject_frame frame;
  736. };
  737. static const struct inject_frames inject_frames[] = {
  738. { "auth", WLANTEST_FRAME_AUTH },
  739. { "assocreq", WLANTEST_FRAME_ASSOCREQ },
  740. { "reassocreq", WLANTEST_FRAME_REASSOCREQ },
  741. { "deauth", WLANTEST_FRAME_DEAUTH },
  742. { "disassoc", WLANTEST_FRAME_DISASSOC },
  743. { "saqueryreq", WLANTEST_FRAME_SAQUERYREQ },
  744. { NULL, 0 }
  745. };
  746. static int cmd_inject(int s, int argc, char *argv[])
  747. {
  748. u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
  749. u8 buf[100], *end, *pos;
  750. int rlen, i;
  751. enum wlantest_inject_protection prot;
  752. /* <frame> <prot> <sender> <BSSID> <STA/ff:ff:ff:ff:ff:ff> */
  753. if (argc < 5) {
  754. printf("inject needs five arguments: frame, protection, "
  755. "sender, BSSID, STA/ff:ff:ff:ff:ff:ff\n");
  756. return -1;
  757. }
  758. pos = buf;
  759. end = buf + sizeof(buf);
  760. WPA_PUT_BE32(pos, WLANTEST_CTRL_INJECT);
  761. pos += 4;
  762. for (i = 0; inject_frames[i].name; i++) {
  763. if (os_strcasecmp(inject_frames[i].name, argv[0]) == 0)
  764. break;
  765. }
  766. if (inject_frames[i].name == NULL) {
  767. printf("Unknown inject frame '%s'\n", argv[0]);
  768. printf("Frames:");
  769. for (i = 0; inject_frames[i].name; i++)
  770. printf(" %s", inject_frames[i].name);
  771. printf("\n");
  772. return -1;
  773. }
  774. pos = attr_add_be32(pos, end, WLANTEST_ATTR_INJECT_FRAME,
  775. inject_frames[i].frame);
  776. if (os_strcasecmp(argv[1], "normal") == 0)
  777. prot = WLANTEST_INJECT_NORMAL;
  778. else if (os_strcasecmp(argv[1], "protected") == 0)
  779. prot = WLANTEST_INJECT_PROTECTED;
  780. else if (os_strcasecmp(argv[1], "unprotected") == 0)
  781. prot = WLANTEST_INJECT_UNPROTECTED;
  782. else if (os_strcasecmp(argv[1], "incorrect") == 0)
  783. prot = WLANTEST_INJECT_INCORRECT_KEY;
  784. else {
  785. printf("Unknown protection type '%s'\n", argv[1]);
  786. printf("Protection types: normal protected unprotected "
  787. "incorrect\n");
  788. return -1;
  789. }
  790. pos = attr_add_be32(pos, end, WLANTEST_ATTR_INJECT_PROTECTION, prot);
  791. if (os_strcasecmp(argv[2], "ap") == 0) {
  792. pos = attr_add_be32(pos, end, WLANTEST_ATTR_INJECT_SENDER_AP,
  793. 1);
  794. } else if (os_strcasecmp(argv[2], "sta") == 0) {
  795. pos = attr_add_be32(pos, end, WLANTEST_ATTR_INJECT_SENDER_AP,
  796. 0);
  797. } else {
  798. printf("Unknown sender '%s'\n", argv[2]);
  799. printf("Sender types: ap sta\n");
  800. return -1;
  801. }
  802. pos = attr_hdr_add(pos, end, WLANTEST_ATTR_BSSID, ETH_ALEN);
  803. if (hwaddr_aton(argv[3], pos) < 0) {
  804. printf("Invalid BSSID '%s'\n", argv[3]);
  805. return -1;
  806. }
  807. pos += ETH_ALEN;
  808. pos = attr_hdr_add(pos, end, WLANTEST_ATTR_STA_ADDR, ETH_ALEN);
  809. if (hwaddr_aton(argv[4], pos) < 0) {
  810. printf("Invalid STA '%s'\n", argv[4]);
  811. return -1;
  812. }
  813. pos += ETH_ALEN;
  814. rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
  815. if (rlen < 0)
  816. return -1;
  817. printf("OK\n");
  818. return 0;
  819. }
  820. static char ** complete_inject(int s, const char *str, int pos)
  821. {
  822. int arg = get_cmd_arg_num(str, pos);
  823. char **res = NULL;
  824. int i, count;
  825. u8 addr[ETH_ALEN];
  826. switch (arg) {
  827. case 1:
  828. /* frame list */
  829. count = sizeof(inject_frames) / sizeof(inject_frames[0]);
  830. res = os_zalloc(count * sizeof(char *));
  831. if (res == NULL)
  832. break;
  833. for (i = 0; inject_frames[i].name; i++) {
  834. res[i] = os_strdup(inject_frames[i].name);
  835. if (res[i] == NULL)
  836. break;
  837. }
  838. break;
  839. case 2:
  840. res = os_zalloc(5 * sizeof(char *));
  841. if (res == NULL)
  842. break;
  843. res[0] = os_strdup("normal");
  844. if (res[0] == NULL)
  845. break;
  846. res[1] = os_strdup("protected");
  847. if (res[1] == NULL)
  848. break;
  849. res[2] = os_strdup("unprotected");
  850. if (res[2] == NULL)
  851. break;
  852. res[3] = os_strdup("incorrect");
  853. if (res[3] == NULL)
  854. break;
  855. break;
  856. case 3:
  857. res = os_zalloc(3 * sizeof(char *));
  858. if (res == NULL)
  859. break;
  860. res[0] = os_strdup("ap");
  861. if (res[0] == NULL)
  862. break;
  863. res[1] = os_strdup("sta");
  864. if (res[1] == NULL)
  865. break;
  866. break;
  867. case 4:
  868. res = get_bssid_list(s);
  869. break;
  870. case 5:
  871. if (hwaddr_aton(&str[get_prev_arg_pos(str, pos)], addr) < 0)
  872. break;
  873. res = get_sta_list(s, addr, 1);
  874. break;
  875. }
  876. return res;
  877. }
  878. static u8 * add_hex(u8 *pos, u8 *end, const char *str)
  879. {
  880. const char *s;
  881. int val;
  882. s = str;
  883. while (*s) {
  884. while (*s == ' ' || *s == '\t' || *s == '\r' || *s == '\n' ||
  885. *s == ':')
  886. s++;
  887. if (*s == '\0')
  888. break;
  889. if (*s == '#') {
  890. while (*s != '\0' && *s != '\r' && *s != '\n')
  891. s++;
  892. continue;
  893. }
  894. val = hex2byte(s);
  895. if (val < 0) {
  896. printf("Invalid hex encoding '%s'\n", s);
  897. return NULL;
  898. }
  899. if (pos == end) {
  900. printf("Too long frame\n");
  901. return NULL;
  902. }
  903. *pos++ = val;
  904. s += 2;
  905. }
  906. return pos;
  907. }
  908. static int cmd_send(int s, int argc, char *argv[])
  909. {
  910. u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
  911. u8 buf[WLANTEST_CTRL_MAX_CMD_LEN], *end, *pos, *len_pos;
  912. int rlen;
  913. enum wlantest_inject_protection prot;
  914. int arg;
  915. /* <prot> <raw frame as hex dump> */
  916. if (argc < 2) {
  917. printf("send needs two arguments: protected/unprotected, "
  918. "raw frame as hex dump\n");
  919. return -1;
  920. }
  921. pos = buf;
  922. end = buf + sizeof(buf);
  923. WPA_PUT_BE32(pos, WLANTEST_CTRL_SEND);
  924. pos += 4;
  925. if (os_strcasecmp(argv[0], "normal") == 0)
  926. prot = WLANTEST_INJECT_NORMAL;
  927. else if (os_strcasecmp(argv[0], "protected") == 0)
  928. prot = WLANTEST_INJECT_PROTECTED;
  929. else if (os_strcasecmp(argv[0], "unprotected") == 0)
  930. prot = WLANTEST_INJECT_UNPROTECTED;
  931. else if (os_strcasecmp(argv[0], "incorrect") == 0)
  932. prot = WLANTEST_INJECT_INCORRECT_KEY;
  933. else {
  934. printf("Unknown protection type '%s'\n", argv[1]);
  935. printf("Protection types: normal protected unprotected "
  936. "incorrect\n");
  937. return -1;
  938. }
  939. pos = attr_add_be32(pos, end, WLANTEST_ATTR_INJECT_PROTECTION, prot);
  940. WPA_PUT_BE32(pos, WLANTEST_ATTR_FRAME);
  941. pos += 4;
  942. len_pos = pos;
  943. pos += 4;
  944. for (arg = 1; pos && arg < argc; arg++)
  945. pos = add_hex(pos, end, argv[arg]);
  946. if (pos == NULL)
  947. return -1;
  948. WPA_PUT_BE32(len_pos, pos - len_pos - 4);
  949. rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
  950. if (rlen < 0)
  951. return -1;
  952. printf("OK\n");
  953. return 0;
  954. }
  955. static char ** complete_send(int s, const char *str, int pos)
  956. {
  957. int arg = get_cmd_arg_num(str, pos);
  958. char **res = NULL;
  959. switch (arg) {
  960. case 1:
  961. res = os_zalloc(5 * sizeof(char *));
  962. if (res == NULL)
  963. break;
  964. res[0] = os_strdup("normal");
  965. if (res[0] == NULL)
  966. break;
  967. res[1] = os_strdup("protected");
  968. if (res[1] == NULL)
  969. break;
  970. res[2] = os_strdup("unprotected");
  971. if (res[2] == NULL)
  972. break;
  973. res[3] = os_strdup("incorrect");
  974. if (res[3] == NULL)
  975. break;
  976. break;
  977. }
  978. return res;
  979. }
  980. static int cmd_version(int s, int argc, char *argv[])
  981. {
  982. u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
  983. u8 buf[4];
  984. char *version;
  985. size_t len;
  986. int rlen, i;
  987. WPA_PUT_BE32(buf, WLANTEST_CTRL_VERSION);
  988. rlen = cmd_send_and_recv(s, buf, sizeof(buf), resp, sizeof(resp));
  989. if (rlen < 0)
  990. return -1;
  991. version = (char *) attr_get(resp + 4, rlen - 4, WLANTEST_ATTR_VERSION,
  992. &len);
  993. if (version == NULL)
  994. return -1;
  995. for (i = 0; i < len; i++)
  996. putchar(version[i]);
  997. printf("\n");
  998. return 0;
  999. }
  1000. static int cmd_add_passphrase(int s, int argc, char *argv[])
  1001. {
  1002. u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
  1003. u8 buf[100], *pos, *end;
  1004. size_t len;
  1005. int rlen;
  1006. if (argc < 1) {
  1007. printf("add_passphrase needs one argument: passphrase\n");
  1008. return -1;
  1009. }
  1010. len = os_strlen(argv[0]);
  1011. if (len < 8 || len > 63) {
  1012. printf("Invalid passphrase '%s'\n", argv[0]);
  1013. return -1;
  1014. }
  1015. pos = buf;
  1016. end = buf + sizeof(buf);
  1017. WPA_PUT_BE32(pos, WLANTEST_CTRL_ADD_PASSPHRASE);
  1018. pos += 4;
  1019. pos = attr_add_str(pos, end, WLANTEST_ATTR_PASSPHRASE,
  1020. argv[0]);
  1021. if (argc > 1) {
  1022. pos = attr_hdr_add(pos, end, WLANTEST_ATTR_BSSID, ETH_ALEN);
  1023. if (hwaddr_aton(argv[1], pos) < 0) {
  1024. printf("Invalid BSSID '%s'\n", argv[3]);
  1025. return -1;
  1026. }
  1027. pos += ETH_ALEN;
  1028. }
  1029. rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
  1030. if (rlen < 0)
  1031. return -1;
  1032. return 0;
  1033. }
  1034. struct sta_infos {
  1035. const char *name;
  1036. enum wlantest_sta_info num;
  1037. };
  1038. static const struct sta_infos sta_infos[] = {
  1039. { "proto", WLANTEST_STA_INFO_PROTO },
  1040. { "pairwise", WLANTEST_STA_INFO_PAIRWISE },
  1041. { "key_mgmt", WLANTEST_STA_INFO_KEY_MGMT },
  1042. { "rsn_capab", WLANTEST_STA_INFO_RSN_CAPAB },
  1043. { "state", WLANTEST_STA_INFO_STATE },
  1044. { "gtk", WLANTEST_STA_INFO_GTK },
  1045. { NULL, 0 }
  1046. };
  1047. static int cmd_info_sta(int s, int argc, char *argv[])
  1048. {
  1049. u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
  1050. u8 buf[100], *end, *pos;
  1051. int rlen, i;
  1052. size_t len;
  1053. char info[100];
  1054. if (argc != 3) {
  1055. printf("sta_info needs at three arguments: "
  1056. "counter name, BSSID, and STA address\n");
  1057. return -1;
  1058. }
  1059. pos = buf;
  1060. end = buf + sizeof(buf);
  1061. WPA_PUT_BE32(pos, WLANTEST_CTRL_INFO_STA);
  1062. pos += 4;
  1063. for (i = 0; sta_infos[i].name; i++) {
  1064. if (os_strcasecmp(sta_infos[i].name, argv[0]) == 0)
  1065. break;
  1066. }
  1067. if (sta_infos[i].name == NULL) {
  1068. printf("Unknown STA info '%s'\n", argv[0]);
  1069. printf("Info fields:");
  1070. for (i = 0; sta_infos[i].name; i++)
  1071. printf(" %s", sta_infos[i].name);
  1072. printf("\n");
  1073. return -1;
  1074. }
  1075. pos = attr_add_be32(pos, end, WLANTEST_ATTR_STA_INFO,
  1076. sta_infos[i].num);
  1077. pos = attr_hdr_add(pos, end, WLANTEST_ATTR_BSSID, ETH_ALEN);
  1078. if (hwaddr_aton(argv[1], pos) < 0) {
  1079. printf("Invalid BSSID '%s'\n", argv[1]);
  1080. return -1;
  1081. }
  1082. pos += ETH_ALEN;
  1083. pos = attr_hdr_add(pos, end, WLANTEST_ATTR_STA_ADDR, ETH_ALEN);
  1084. if (hwaddr_aton(argv[2], pos) < 0) {
  1085. printf("Invalid STA address '%s'\n", argv[2]);
  1086. return -1;
  1087. }
  1088. pos += ETH_ALEN;
  1089. rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
  1090. if (rlen < 0)
  1091. return -1;
  1092. pos = attr_get(resp + 4, rlen - 4, WLANTEST_ATTR_INFO, &len);
  1093. if (pos == NULL)
  1094. return -1;
  1095. if (len >= sizeof(info))
  1096. len = sizeof(info) - 1;
  1097. os_memcpy(info, pos, len);
  1098. info[len] = '\0';
  1099. printf("%s\n", info);
  1100. return 0;
  1101. }
  1102. static char ** complete_info_sta(int s, const char *str, int pos)
  1103. {
  1104. int arg = get_cmd_arg_num(str, pos);
  1105. char **res = NULL;
  1106. int i, count;
  1107. u8 addr[ETH_ALEN];
  1108. switch (arg) {
  1109. case 1:
  1110. /* counter list */
  1111. count = sizeof(sta_infos) / sizeof(sta_infos[0]);
  1112. res = os_zalloc(count * sizeof(char *));
  1113. if (res == NULL)
  1114. return NULL;
  1115. for (i = 0; sta_infos[i].name; i++) {
  1116. res[i] = os_strdup(sta_infos[i].name);
  1117. if (res[i] == NULL)
  1118. break;
  1119. }
  1120. break;
  1121. case 2:
  1122. res = get_bssid_list(s);
  1123. break;
  1124. case 3:
  1125. if (hwaddr_aton(&str[get_prev_arg_pos(str, pos)], addr) < 0)
  1126. break;
  1127. res = get_sta_list(s, addr, 0);
  1128. break;
  1129. }
  1130. return res;
  1131. }
  1132. struct bss_infos {
  1133. const char *name;
  1134. enum wlantest_bss_info num;
  1135. };
  1136. static const struct bss_infos bss_infos[] = {
  1137. { "proto", WLANTEST_BSS_INFO_PROTO },
  1138. { "pairwise", WLANTEST_BSS_INFO_PAIRWISE },
  1139. { "group", WLANTEST_BSS_INFO_GROUP },
  1140. { "group_mgmt", WLANTEST_BSS_INFO_GROUP_MGMT },
  1141. { "key_mgmt", WLANTEST_BSS_INFO_KEY_MGMT },
  1142. { "rsn_capab", WLANTEST_BSS_INFO_RSN_CAPAB },
  1143. { NULL, 0 }
  1144. };
  1145. static int cmd_info_bss(int s, int argc, char *argv[])
  1146. {
  1147. u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
  1148. u8 buf[100], *end, *pos;
  1149. int rlen, i;
  1150. size_t len;
  1151. char info[100];
  1152. if (argc != 2) {
  1153. printf("bss_info needs at two arguments: "
  1154. "field name and BSSID\n");
  1155. return -1;
  1156. }
  1157. pos = buf;
  1158. end = buf + sizeof(buf);
  1159. WPA_PUT_BE32(pos, WLANTEST_CTRL_INFO_BSS);
  1160. pos += 4;
  1161. for (i = 0; bss_infos[i].name; i++) {
  1162. if (os_strcasecmp(bss_infos[i].name, argv[0]) == 0)
  1163. break;
  1164. }
  1165. if (bss_infos[i].name == NULL) {
  1166. printf("Unknown BSS info '%s'\n", argv[0]);
  1167. printf("Info fields:");
  1168. for (i = 0; bss_infos[i].name; i++)
  1169. printf(" %s", bss_infos[i].name);
  1170. printf("\n");
  1171. return -1;
  1172. }
  1173. pos = attr_add_be32(pos, end, WLANTEST_ATTR_BSS_INFO,
  1174. bss_infos[i].num);
  1175. pos = attr_hdr_add(pos, end, WLANTEST_ATTR_BSSID, ETH_ALEN);
  1176. if (hwaddr_aton(argv[1], pos) < 0) {
  1177. printf("Invalid BSSID '%s'\n", argv[1]);
  1178. return -1;
  1179. }
  1180. pos += ETH_ALEN;
  1181. rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
  1182. if (rlen < 0)
  1183. return -1;
  1184. pos = attr_get(resp + 4, rlen - 4, WLANTEST_ATTR_INFO, &len);
  1185. if (pos == NULL)
  1186. return -1;
  1187. if (len >= sizeof(info))
  1188. len = sizeof(info) - 1;
  1189. os_memcpy(info, pos, len);
  1190. info[len] = '\0';
  1191. printf("%s\n", info);
  1192. return 0;
  1193. }
  1194. static char ** complete_info_bss(int s, const char *str, int pos)
  1195. {
  1196. int arg = get_cmd_arg_num(str, pos);
  1197. char **res = NULL;
  1198. int i, count;
  1199. switch (arg) {
  1200. case 1:
  1201. /* counter list */
  1202. count = sizeof(bss_infos) / sizeof(bss_infos[0]);
  1203. res = os_zalloc(count * sizeof(char *));
  1204. if (res == NULL)
  1205. return NULL;
  1206. for (i = 0; bss_infos[i].name; i++) {
  1207. res[i] = os_strdup(bss_infos[i].name);
  1208. if (res[i] == NULL)
  1209. break;
  1210. }
  1211. break;
  1212. case 2:
  1213. res = get_bssid_list(s);
  1214. break;
  1215. }
  1216. return res;
  1217. }
  1218. struct wlantest_cli_cmd {
  1219. const char *cmd;
  1220. int (*handler)(int s, int argc, char *argv[]);
  1221. const char *usage;
  1222. char ** (*complete)(int s, const char *str, int pos);
  1223. };
  1224. static const struct wlantest_cli_cmd wlantest_cli_commands[] = {
  1225. { "ping", cmd_ping, "= test connection to wlantest", NULL },
  1226. { "terminate", cmd_terminate, "= terminate wlantest", NULL },
  1227. { "list_bss", cmd_list_bss, "= get BSS list", NULL },
  1228. { "list_sta", cmd_list_sta, "<BSSID> = get STA list",
  1229. complete_list_sta },
  1230. { "flush", cmd_flush, "= drop all collected BSS data", NULL },
  1231. { "clear_sta_counters", cmd_clear_sta_counters,
  1232. "<BSSID> <STA> = clear STA counters", complete_clear_sta_counters },
  1233. { "clear_bss_counters", cmd_clear_bss_counters,
  1234. "<BSSID> = clear BSS counters", complete_clear_bss_counters },
  1235. { "get_sta_counter", cmd_get_sta_counter,
  1236. "<counter> <BSSID> <STA> = get STA counter value",
  1237. complete_get_sta_counter },
  1238. { "get_bss_counter", cmd_get_bss_counter,
  1239. "<counter> <BSSID> = get BSS counter value",
  1240. complete_get_bss_counter },
  1241. { "inject", cmd_inject,
  1242. "<frame> <prot> <sender> <BSSID> <STA/ff:ff:ff:ff:ff:ff>",
  1243. complete_inject },
  1244. { "send", cmd_send,
  1245. "<prot> <raw frame as hex dump>",
  1246. complete_send },
  1247. { "version", cmd_version, "= get wlantest version", NULL },
  1248. { "add_passphrase", cmd_add_passphrase,
  1249. "<passphrase> = add a known passphrase", NULL },
  1250. { "info_sta", cmd_info_sta,
  1251. "<field> <BSSID> <STA> = get STA information",
  1252. complete_info_sta },
  1253. { "info_bss", cmd_info_bss,
  1254. "<field> <BSSID> = get BSS information",
  1255. complete_info_bss },
  1256. { "clear_tdls_counters", cmd_clear_tdls_counters,
  1257. "<BSSID> <STA1> <STA2> = clear TDLS counters",
  1258. complete_clear_tdls_counters },
  1259. { "get_tdls_counter", cmd_get_tdls_counter,
  1260. "<counter> <BSSID> <STA1> <STA2> = get TDLS counter value",
  1261. complete_get_tdls_counter },
  1262. { "get_bss_counter", cmd_get_bss_counter,
  1263. "<counter> <BSSID> = get BSS counter value",
  1264. complete_get_bss_counter },
  1265. { NULL, NULL, NULL, NULL }
  1266. };
  1267. static int ctrl_command(int s, int argc, char *argv[])
  1268. {
  1269. const struct wlantest_cli_cmd *cmd, *match = NULL;
  1270. int count = 0;
  1271. int ret = 0;
  1272. for (cmd = wlantest_cli_commands; cmd->cmd; cmd++) {
  1273. if (os_strncasecmp(cmd->cmd, argv[0], os_strlen(argv[0])) == 0)
  1274. {
  1275. match = cmd;
  1276. if (os_strcasecmp(cmd->cmd, argv[0]) == 0) {
  1277. /* exact match */
  1278. count = 1;
  1279. break;
  1280. }
  1281. count++;
  1282. }
  1283. }
  1284. if (count > 1) {
  1285. printf("Ambiguous command '%s'; possible commands:", argv[0]);
  1286. for (cmd = wlantest_cli_commands; cmd->cmd; cmd++) {
  1287. if (os_strncasecmp(cmd->cmd, argv[0],
  1288. os_strlen(argv[0])) == 0) {
  1289. printf(" %s", cmd->cmd);
  1290. }
  1291. }
  1292. printf("\n");
  1293. ret = 1;
  1294. } else if (count == 0) {
  1295. printf("Unknown command '%s'\n", argv[0]);
  1296. ret = 1;
  1297. } else {
  1298. ret = match->handler(s, argc - 1, &argv[1]);
  1299. }
  1300. return ret;
  1301. }
  1302. struct wlantest_cli {
  1303. int s;
  1304. };
  1305. #define max_args 10
  1306. static int tokenize_cmd(char *cmd, char *argv[])
  1307. {
  1308. char *pos;
  1309. int argc = 0;
  1310. pos = cmd;
  1311. for (;;) {
  1312. while (*pos == ' ')
  1313. pos++;
  1314. if (*pos == '\0')
  1315. break;
  1316. argv[argc] = pos;
  1317. argc++;
  1318. if (argc == max_args)
  1319. break;
  1320. if (*pos == '"') {
  1321. char *pos2 = os_strrchr(pos, '"');
  1322. if (pos2)
  1323. pos = pos2 + 1;
  1324. }
  1325. while (*pos != '\0' && *pos != ' ')
  1326. pos++;
  1327. if (*pos == ' ')
  1328. *pos++ = '\0';
  1329. }
  1330. return argc;
  1331. }
  1332. static void wlantest_cli_edit_cmd_cb(void *ctx, char *cmd)
  1333. {
  1334. struct wlantest_cli *cli = ctx;
  1335. char *argv[max_args];
  1336. int argc;
  1337. argc = tokenize_cmd(cmd, argv);
  1338. if (argc) {
  1339. int ret = ctrl_command(cli->s, argc, argv);
  1340. if (ret < 0)
  1341. printf("FAIL\n");
  1342. }
  1343. }
  1344. static void wlantest_cli_eloop_terminate(int sig, void *signal_ctx)
  1345. {
  1346. eloop_terminate();
  1347. }
  1348. static void wlantest_cli_edit_eof_cb(void *ctx)
  1349. {
  1350. eloop_terminate();
  1351. }
  1352. static char ** wlantest_cli_cmd_list(void)
  1353. {
  1354. char **res;
  1355. int i, count;
  1356. count = sizeof(wlantest_cli_commands) /
  1357. sizeof(wlantest_cli_commands[0]);
  1358. res = os_zalloc(count * sizeof(char *));
  1359. if (res == NULL)
  1360. return NULL;
  1361. for (i = 0; wlantest_cli_commands[i].cmd; i++) {
  1362. res[i] = os_strdup(wlantest_cli_commands[i].cmd);
  1363. if (res[i] == NULL)
  1364. break;
  1365. }
  1366. return res;
  1367. }
  1368. static char ** wlantest_cli_cmd_completion(struct wlantest_cli *cli,
  1369. const char *cmd, const char *str,
  1370. int pos)
  1371. {
  1372. int i;
  1373. for (i = 0; wlantest_cli_commands[i].cmd; i++) {
  1374. const struct wlantest_cli_cmd *c = &wlantest_cli_commands[i];
  1375. if (os_strcasecmp(c->cmd, cmd) == 0) {
  1376. edit_clear_line();
  1377. printf("\r%s\n", c->usage);
  1378. edit_redraw();
  1379. if (c->complete)
  1380. return c->complete(cli->s, str, pos);
  1381. break;
  1382. }
  1383. }
  1384. return NULL;
  1385. }
  1386. static char ** wlantest_cli_edit_completion_cb(void *ctx, const char *str,
  1387. int pos)
  1388. {
  1389. struct wlantest_cli *cli = ctx;
  1390. char **res;
  1391. const char *end;
  1392. char *cmd;
  1393. end = os_strchr(str, ' ');
  1394. if (end == NULL || str + pos < end)
  1395. return wlantest_cli_cmd_list();
  1396. cmd = os_malloc(pos + 1);
  1397. if (cmd == NULL)
  1398. return NULL;
  1399. os_memcpy(cmd, str, pos);
  1400. cmd[end - str] = '\0';
  1401. res = wlantest_cli_cmd_completion(cli, cmd, str, pos);
  1402. os_free(cmd);
  1403. return res;
  1404. }
  1405. static void wlantest_cli_interactive(int s)
  1406. {
  1407. struct wlantest_cli cli;
  1408. char *home, *hfile = NULL;
  1409. if (eloop_init())
  1410. return;
  1411. home = getenv("HOME");
  1412. if (home) {
  1413. const char *fname = ".wlantest_cli_history";
  1414. int hfile_len = os_strlen(home) + 1 + os_strlen(fname) + 1;
  1415. hfile = os_malloc(hfile_len);
  1416. if (hfile)
  1417. os_snprintf(hfile, hfile_len, "%s/%s", home, fname);
  1418. }
  1419. cli.s = s;
  1420. eloop_register_signal_terminate(wlantest_cli_eloop_terminate, &cli);
  1421. edit_init(wlantest_cli_edit_cmd_cb, wlantest_cli_edit_eof_cb,
  1422. wlantest_cli_edit_completion_cb, &cli, hfile);
  1423. eloop_run();
  1424. edit_deinit(hfile, NULL);
  1425. os_free(hfile);
  1426. eloop_destroy();
  1427. }
  1428. int main(int argc, char *argv[])
  1429. {
  1430. int s;
  1431. struct sockaddr_un addr;
  1432. int ret = 0;
  1433. if (os_program_init())
  1434. return -1;
  1435. s = socket(AF_UNIX, SOCK_SEQPACKET, 0);
  1436. if (s < 0) {
  1437. perror("socket");
  1438. return -1;
  1439. }
  1440. os_memset(&addr, 0, sizeof(addr));
  1441. addr.sun_family = AF_UNIX;
  1442. os_strlcpy(addr.sun_path + 1, WLANTEST_SOCK_NAME,
  1443. sizeof(addr.sun_path) - 1);
  1444. if (connect(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
  1445. perror("connect");
  1446. close(s);
  1447. return -1;
  1448. }
  1449. if (argc > 1) {
  1450. ret = ctrl_command(s, argc - 1, &argv[1]);
  1451. if (ret < 0)
  1452. printf("FAIL\n");
  1453. } else {
  1454. wlantest_cli_interactive(s);
  1455. }
  1456. close(s);
  1457. os_program_deinit();
  1458. return ret;
  1459. }