dbus_new_handlers_p2p.c 57 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157
  1. /*
  2. * WPA Supplicant / dbus-based control interface (P2P)
  3. *
  4. * This program is free software; you can redistribute it and/or modify
  5. * it under the terms of the GNU General Public License version 2 as
  6. * published by the Free Software Foundation.
  7. *
  8. * Alternatively, this software may be distributed under the terms of BSD
  9. * license.
  10. *
  11. * See README and COPYING for more details.
  12. */
  13. #include "includes.h"
  14. #include "utils/includes.h"
  15. #include "common.h"
  16. #include "../config.h"
  17. #include "../wpa_supplicant_i.h"
  18. #include "../wps_supplicant.h"
  19. #include "../notify.h"
  20. #include "dbus_new_helpers.h"
  21. #include "dbus_new.h"
  22. #include "dbus_new_handlers.h"
  23. #include "dbus_new_handlers_p2p.h"
  24. #include "dbus_dict_helpers.h"
  25. #include "p2p/p2p.h"
  26. #include "common/ieee802_11_defs.h"
  27. #include "ap/hostapd.h"
  28. #include "ap/ap_config.h"
  29. #include "ap/wps_hostapd.h"
  30. #include "../p2p_supplicant.h"
  31. /**
  32. * Parses out the mac address from the peer object path.
  33. * @peer_path - object path of the form
  34. * /fi/w1/wpa_supplicant1/Interfaces/n/Peers/00112233445566 (no colons)
  35. * @addr - out param must be of ETH_ALEN size
  36. * Returns 0 if valid (including MAC), -1 otherwise
  37. */
  38. static int parse_peer_object_path(char *peer_path, u8 addr[ETH_ALEN])
  39. {
  40. char *p;
  41. if (!peer_path)
  42. return -1;
  43. p = strrchr(peer_path, '/');
  44. if (!p)
  45. return -1;
  46. p++;
  47. return hwaddr_compact_aton(p, addr);
  48. }
  49. /**
  50. * wpas_dbus_error_persistent_group_unknown - Return a new PersistentGroupUnknown
  51. * error message
  52. * @message: Pointer to incoming dbus message this error refers to
  53. * Returns: a dbus error message
  54. *
  55. * Convenience function to create and return an invalid persistent group error.
  56. */
  57. static DBusMessage * wpas_dbus_error_persistent_group_unknown(
  58. DBusMessage *message)
  59. {
  60. return dbus_message_new_error(message, WPAS_DBUS_ERROR_NETWORK_UNKNOWN,
  61. "There is no such persistent group in "
  62. "this P2P device.");
  63. }
  64. DBusMessage * wpas_dbus_handler_p2p_find(DBusMessage *message,
  65. struct wpa_supplicant *wpa_s)
  66. {
  67. struct wpa_dbus_dict_entry entry;
  68. DBusMessage *reply = NULL;
  69. DBusMessageIter iter;
  70. DBusMessageIter iter_dict;
  71. unsigned int timeout = 0;
  72. enum p2p_discovery_type type = P2P_FIND_ONLY_SOCIAL;
  73. int num_req_dev_types = 0;
  74. unsigned int i;
  75. u8 *req_dev_types = NULL;
  76. dbus_message_iter_init(message, &iter);
  77. entry.key = NULL;
  78. if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
  79. goto error;
  80. while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
  81. if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
  82. goto error;
  83. if (!os_strcmp(entry.key, "Timeout") &&
  84. (entry.type == DBUS_TYPE_INT32)) {
  85. timeout = entry.uint32_value;
  86. } else if (os_strcmp(entry.key, "RequestedDeviceTypes") == 0) {
  87. if ((entry.type != DBUS_TYPE_ARRAY) ||
  88. (entry.array_type != WPAS_DBUS_TYPE_BINARRAY))
  89. goto error_clear;
  90. os_free(req_dev_types);
  91. req_dev_types =
  92. os_malloc(WPS_DEV_TYPE_LEN * entry.array_len);
  93. if (!req_dev_types)
  94. goto error_clear;
  95. for (i = 0; i < entry.array_len; i++) {
  96. if (wpabuf_len(entry.binarray_value[i]) !=
  97. WPS_DEV_TYPE_LEN)
  98. goto error_clear;
  99. os_memcpy(req_dev_types + i * WPS_DEV_TYPE_LEN,
  100. wpabuf_head(entry.binarray_value[i]),
  101. WPS_DEV_TYPE_LEN);
  102. }
  103. num_req_dev_types = entry.array_len;
  104. } else if (!os_strcmp(entry.key, "DiscoveryType") &&
  105. (entry.type == DBUS_TYPE_STRING)) {
  106. if (!os_strcmp(entry.str_value, "start_with_full"))
  107. type = P2P_FIND_START_WITH_FULL;
  108. else if (!os_strcmp(entry.str_value, "social"))
  109. type = P2P_FIND_ONLY_SOCIAL;
  110. else if (!os_strcmp(entry.str_value, "progressive"))
  111. type = P2P_FIND_PROGRESSIVE;
  112. else
  113. goto error_clear;
  114. } else
  115. goto error_clear;
  116. wpa_dbus_dict_entry_clear(&entry);
  117. }
  118. wpas_p2p_find(wpa_s, timeout, type, num_req_dev_types, req_dev_types);
  119. os_free(req_dev_types);
  120. return reply;
  121. error_clear:
  122. wpa_dbus_dict_entry_clear(&entry);
  123. error:
  124. os_free(req_dev_types);
  125. reply = wpas_dbus_error_invalid_args(message, entry.key);
  126. return reply;
  127. }
  128. DBusMessage * wpas_dbus_handler_p2p_stop_find(DBusMessage *message,
  129. struct wpa_supplicant *wpa_s)
  130. {
  131. wpas_p2p_stop_find(wpa_s);
  132. return NULL;
  133. }
  134. DBusMessage * wpas_dbus_handler_p2p_rejectpeer(DBusMessage *message,
  135. struct wpa_supplicant *wpa_s)
  136. {
  137. DBusMessageIter iter;
  138. char *peer_object_path = NULL;
  139. u8 peer_addr[ETH_ALEN];
  140. dbus_message_iter_init(message, &iter);
  141. dbus_message_iter_get_basic(&iter, &peer_object_path);
  142. if (parse_peer_object_path(peer_object_path, peer_addr) < 0)
  143. return wpas_dbus_error_invalid_args(message, NULL);
  144. if (wpas_p2p_reject(wpa_s, peer_addr) < 0)
  145. return wpas_dbus_error_unknown_error(message,
  146. "Failed to call wpas_p2p_reject method.");
  147. return NULL;
  148. }
  149. DBusMessage * wpas_dbus_handler_p2p_listen(DBusMessage *message,
  150. struct wpa_supplicant *wpa_s)
  151. {
  152. dbus_int32_t timeout = 0;
  153. if (!dbus_message_get_args(message, NULL, DBUS_TYPE_INT32, &timeout,
  154. DBUS_TYPE_INVALID))
  155. return dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
  156. NULL);
  157. if (wpas_p2p_listen(wpa_s, (unsigned int)timeout))
  158. return dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
  159. NULL);
  160. return NULL;
  161. }
  162. DBusMessage * wpas_dbus_handler_p2p_extendedlisten(
  163. DBusMessage *message, struct wpa_supplicant *wpa_s)
  164. {
  165. unsigned int period = 0, interval = 0;
  166. struct wpa_dbus_dict_entry entry;
  167. DBusMessageIter iter;
  168. DBusMessageIter iter_dict;
  169. dbus_message_iter_init(message, &iter);
  170. entry.key = NULL;
  171. if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
  172. goto error;
  173. while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
  174. if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
  175. goto error;
  176. if (!os_strcmp(entry.key, "period") &&
  177. (entry.type == DBUS_TYPE_INT32))
  178. period = entry.uint32_value;
  179. else if (!os_strcmp(entry.key, "interval") &&
  180. (entry.type == DBUS_TYPE_INT32))
  181. interval = entry.uint32_value;
  182. else
  183. goto error_clear;
  184. wpa_dbus_dict_entry_clear(&entry);
  185. }
  186. if (wpas_p2p_ext_listen(wpa_s, period, interval))
  187. return wpas_dbus_error_unknown_error(
  188. message, "failed to initiate a p2p_ext_listen.");
  189. return NULL;
  190. error_clear:
  191. wpa_dbus_dict_entry_clear(&entry);
  192. error:
  193. return wpas_dbus_error_invalid_args(message, entry.key);
  194. }
  195. DBusMessage * wpas_dbus_handler_p2p_presence_request(
  196. DBusMessage *message, struct wpa_supplicant *wpa_s)
  197. {
  198. unsigned int dur1 = 0, int1 = 0, dur2 = 0, int2 = 0;
  199. struct wpa_dbus_dict_entry entry;
  200. DBusMessageIter iter;
  201. DBusMessageIter iter_dict;
  202. dbus_message_iter_init(message, &iter);
  203. entry.key = NULL;
  204. if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
  205. goto error;
  206. while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
  207. if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
  208. goto error;
  209. if (!os_strcmp(entry.key, "duration1") &&
  210. (entry.type == DBUS_TYPE_INT32))
  211. dur1 = entry.uint32_value;
  212. else if (!os_strcmp(entry.key, "interval1") &&
  213. entry.type == DBUS_TYPE_INT32)
  214. int1 = entry.uint32_value;
  215. else if (!os_strcmp(entry.key, "duration2") &&
  216. entry.type == DBUS_TYPE_INT32)
  217. dur2 = entry.uint32_value;
  218. else if (!os_strcmp(entry.key, "interval2") &&
  219. entry.type == DBUS_TYPE_INT32)
  220. int2 = entry.uint32_value;
  221. else
  222. goto error_clear;
  223. wpa_dbus_dict_entry_clear(&entry);
  224. }
  225. if (wpas_p2p_presence_req(wpa_s, dur1, int1, dur2, int2) < 0)
  226. return wpas_dbus_error_unknown_error(message,
  227. "Failed to invoke presence request.");
  228. return NULL;
  229. error_clear:
  230. wpa_dbus_dict_entry_clear(&entry);
  231. error:
  232. return wpas_dbus_error_invalid_args(message, entry.key);
  233. }
  234. DBusMessage * wpas_dbus_handler_p2p_group_add(DBusMessage *message,
  235. struct wpa_supplicant *wpa_s)
  236. {
  237. DBusMessageIter iter_dict;
  238. DBusMessage *reply = NULL;
  239. DBusMessageIter iter;
  240. struct wpa_dbus_dict_entry entry;
  241. char *pg_object_path = NULL;
  242. int persistent_group = 0;
  243. int freq = 0;
  244. char *iface = NULL;
  245. char *net_id_str = NULL;
  246. unsigned int group_id = 0;
  247. struct wpa_ssid *ssid;
  248. dbus_message_iter_init(message, &iter);
  249. if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
  250. goto inv_args;
  251. while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
  252. if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
  253. goto inv_args;
  254. if (!os_strcmp(entry.key, "persistent") &&
  255. (entry.type == DBUS_TYPE_BOOLEAN)) {
  256. persistent_group = (entry.bool_value == TRUE) ? 1 : 0;
  257. } else if (!os_strcmp(entry.key, "frequency") &&
  258. (entry.type == DBUS_TYPE_INT32)) {
  259. freq = entry.int32_value;
  260. if (freq <= 0)
  261. goto inv_args_clear;
  262. } else if (!os_strcmp(entry.key, "persistent_group_object") &&
  263. entry.type == DBUS_TYPE_OBJECT_PATH)
  264. pg_object_path = os_strdup(entry.str_value);
  265. else
  266. goto inv_args_clear;
  267. wpa_dbus_dict_entry_clear(&entry);
  268. }
  269. if (pg_object_path != NULL) {
  270. /*
  271. * A persistent group Object Path is defined meaning we want
  272. * to re-invoke a persistent group.
  273. */
  274. iface = wpas_dbus_new_decompose_object_path(pg_object_path, 1,
  275. &net_id_str, NULL);
  276. if (iface == NULL ||
  277. os_strcmp(iface, wpa_s->dbus_new_path) != 0) {
  278. reply =
  279. wpas_dbus_error_invalid_args(message,
  280. pg_object_path);
  281. goto out;
  282. }
  283. group_id = strtoul(net_id_str, NULL, 10);
  284. if (errno == EINVAL) {
  285. reply = wpas_dbus_error_invalid_args(
  286. message, pg_object_path);
  287. goto out;
  288. }
  289. /* Get the SSID structure from the persistent group id */
  290. ssid = wpa_config_get_network(wpa_s->conf, group_id);
  291. if (ssid == NULL || ssid->disabled != 2)
  292. goto inv_args;
  293. if (wpas_p2p_group_add_persistent(wpa_s, ssid, 0, freq)) {
  294. reply = wpas_dbus_error_unknown_error(
  295. message,
  296. "Failed to reinvoke a persistent group");
  297. goto out;
  298. }
  299. } else if (wpas_p2p_group_add(wpa_s, persistent_group, freq))
  300. goto inv_args;
  301. out:
  302. os_free(pg_object_path);
  303. os_free(net_id_str);
  304. os_free(iface);
  305. return reply;
  306. inv_args_clear:
  307. wpa_dbus_dict_entry_clear(&entry);
  308. inv_args:
  309. reply = wpas_dbus_error_invalid_args(message, NULL);
  310. goto out;
  311. }
  312. DBusMessage * wpas_dbus_handler_p2p_disconnect(DBusMessage *message,
  313. struct wpa_supplicant *wpa_s)
  314. {
  315. if (wpas_p2p_disconnect(wpa_s))
  316. return wpas_dbus_error_unknown_error(message,
  317. "failed to disconnect");
  318. return NULL;
  319. }
  320. static dbus_bool_t wpa_dbus_p2p_check_enabled(struct wpa_supplicant *wpa_s,
  321. DBusMessage *message,
  322. DBusMessage **out_reply,
  323. DBusError *error)
  324. {
  325. /* Return an error message or an error if P2P isn't available */
  326. if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL) {
  327. if (out_reply) {
  328. *out_reply = dbus_message_new_error(
  329. message, DBUS_ERROR_FAILED,
  330. "P2P is not available for this interface");
  331. }
  332. dbus_set_error_const(error, DBUS_ERROR_FAILED,
  333. "P2P is not available for this "
  334. "interface");
  335. return FALSE;
  336. }
  337. return TRUE;
  338. }
  339. DBusMessage * wpas_dbus_handler_p2p_flush(DBusMessage *message,
  340. struct wpa_supplicant *wpa_s)
  341. {
  342. DBusMessage *reply = NULL;
  343. if (!wpa_dbus_p2p_check_enabled(wpa_s, message, &reply, NULL))
  344. return reply;
  345. os_memset(wpa_s->p2p_auth_invite, 0, ETH_ALEN);
  346. wpa_s->force_long_sd = 0;
  347. p2p_flush(wpa_s->global->p2p);
  348. return NULL;
  349. }
  350. DBusMessage * wpas_dbus_handler_p2p_connect(DBusMessage *message,
  351. struct wpa_supplicant *wpa_s)
  352. {
  353. DBusMessageIter iter_dict;
  354. DBusMessage *reply = NULL;
  355. DBusMessageIter iter;
  356. struct wpa_dbus_dict_entry entry;
  357. char *peer_object_path = NULL;
  358. int persistent_group = 0;
  359. int join = 0;
  360. int authorize_only = 0;
  361. int go_intent = -1;
  362. int freq = 0;
  363. u8 addr[ETH_ALEN];
  364. char *pin = NULL;
  365. enum p2p_wps_method wps_method = WPS_NOT_READY;
  366. int new_pin;
  367. char *err_msg = NULL;
  368. char *iface = NULL;
  369. if (!wpa_dbus_p2p_check_enabled(wpa_s, message, &reply, NULL))
  370. return reply;
  371. dbus_message_iter_init(message, &iter);
  372. if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
  373. goto inv_args;
  374. while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
  375. if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
  376. goto inv_args;
  377. if (!os_strcmp(entry.key, "peer") &&
  378. (entry.type == DBUS_TYPE_OBJECT_PATH)) {
  379. peer_object_path = os_strdup(entry.str_value);
  380. } else if (!os_strcmp(entry.key, "persistent") &&
  381. (entry.type == DBUS_TYPE_BOOLEAN)) {
  382. persistent_group = (entry.bool_value == TRUE) ? 1 : 0;
  383. } else if (!os_strcmp(entry.key, "join") &&
  384. (entry.type == DBUS_TYPE_BOOLEAN)) {
  385. join = (entry.bool_value == TRUE) ? 1 : 0;
  386. } else if (!os_strcmp(entry.key, "authorize_only") &&
  387. (entry.type == DBUS_TYPE_BOOLEAN)) {
  388. authorize_only = (entry.bool_value == TRUE) ? 1 : 0;
  389. } else if (!os_strcmp(entry.key, "frequency") &&
  390. (entry.type == DBUS_TYPE_INT32)) {
  391. freq = entry.int32_value;
  392. if (freq <= 0)
  393. goto inv_args_clear;
  394. } else if (!os_strcmp(entry.key, "go_intent") &&
  395. (entry.type == DBUS_TYPE_INT32)) {
  396. go_intent = entry.int32_value;
  397. if ((go_intent < 0) || (go_intent > 15))
  398. goto inv_args_clear;
  399. } else if (!os_strcmp(entry.key, "wps_method") &&
  400. (entry.type == DBUS_TYPE_STRING)) {
  401. if (!os_strcmp(entry.str_value, "pbc"))
  402. wps_method = WPS_PBC;
  403. else if (!os_strcmp(entry.str_value, "pin"))
  404. wps_method = WPS_PIN_DISPLAY;
  405. else if (!os_strcmp(entry.str_value, "display"))
  406. wps_method = WPS_PIN_DISPLAY;
  407. else if (!os_strcmp(entry.str_value, "keypad"))
  408. wps_method = WPS_PIN_KEYPAD;
  409. else
  410. goto inv_args_clear;
  411. } else if (!os_strcmp(entry.key, "pin") &&
  412. (entry.type == DBUS_TYPE_STRING)) {
  413. pin = os_strdup(entry.str_value);
  414. } else
  415. goto inv_args_clear;
  416. wpa_dbus_dict_entry_clear(&entry);
  417. }
  418. if (!peer_object_path || (wps_method == WPS_NOT_READY) ||
  419. (parse_peer_object_path(peer_object_path, addr) < 0) ||
  420. !p2p_peer_known(wpa_s->global->p2p, addr))
  421. goto inv_args;
  422. /*
  423. * Validate the wps_method specified and the pin value.
  424. */
  425. if ((!pin || !pin[0]) && (wps_method == WPS_PIN_KEYPAD))
  426. goto inv_args;
  427. new_pin = wpas_p2p_connect(wpa_s, addr, pin, wps_method,
  428. persistent_group, join, authorize_only,
  429. go_intent, freq);
  430. if (new_pin >= 0) {
  431. char npin[9];
  432. char *generated_pin;
  433. os_snprintf(npin, sizeof(npin), "%08d", new_pin);
  434. generated_pin = npin;
  435. reply = dbus_message_new_method_return(message);
  436. dbus_message_append_args(reply, DBUS_TYPE_STRING,
  437. &generated_pin, DBUS_TYPE_INVALID);
  438. } else {
  439. switch (new_pin) {
  440. case -2:
  441. err_msg = "connect failed due to channel "
  442. "unavailability.";
  443. iface = WPAS_DBUS_ERROR_CONNECT_CHANNEL_UNAVAILABLE;
  444. break;
  445. case -3:
  446. err_msg = "connect failed due to unsupported channel.";
  447. iface = WPAS_DBUS_ERROR_CONNECT_CHANNEL_UNSUPPORTED;
  448. break;
  449. default:
  450. err_msg = "connect failed due to unspecified error.";
  451. iface = WPAS_DBUS_ERROR_CONNECT_UNSPECIFIED_ERROR;
  452. break;
  453. }
  454. /*
  455. * TODO:
  456. * Do we need specialized errors corresponding to above
  457. * error conditions as against just returning a different
  458. * error message?
  459. */
  460. reply = dbus_message_new_error(message, iface, err_msg);
  461. }
  462. out:
  463. os_free(peer_object_path);
  464. os_free(pin);
  465. return reply;
  466. inv_args_clear:
  467. wpa_dbus_dict_entry_clear(&entry);
  468. inv_args:
  469. reply = wpas_dbus_error_invalid_args(message, NULL);
  470. goto out;
  471. }
  472. DBusMessage * wpas_dbus_handler_p2p_invite(DBusMessage *message,
  473. struct wpa_supplicant *wpa_s)
  474. {
  475. DBusMessageIter iter_dict;
  476. DBusMessage *reply = NULL;
  477. DBusMessageIter iter;
  478. struct wpa_dbus_dict_entry entry;
  479. char *peer_object_path = NULL;
  480. char *pg_object_path = NULL;
  481. char *iface = NULL;
  482. char *net_id_str = NULL;
  483. u8 peer_addr[ETH_ALEN];
  484. unsigned int group_id = 0;
  485. int persistent = 0;
  486. struct wpa_ssid *ssid;
  487. if (!wpa_dbus_p2p_check_enabled(wpa_s, message, &reply, NULL))
  488. return reply;
  489. dbus_message_iter_init(message, &iter);
  490. if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
  491. goto err;
  492. while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
  493. if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
  494. goto err;
  495. if (!os_strcmp(entry.key, "peer") &&
  496. (entry.type == DBUS_TYPE_OBJECT_PATH)) {
  497. peer_object_path = os_strdup(entry.str_value);
  498. wpa_dbus_dict_entry_clear(&entry);
  499. } else if (!os_strcmp(entry.key, "persistent_group_object") &&
  500. (entry.type == DBUS_TYPE_OBJECT_PATH)) {
  501. pg_object_path = os_strdup(entry.str_value);
  502. persistent = 1;
  503. wpa_dbus_dict_entry_clear(&entry);
  504. } else {
  505. wpa_dbus_dict_entry_clear(&entry);
  506. goto err;
  507. }
  508. }
  509. if (!peer_object_path ||
  510. (parse_peer_object_path(peer_object_path, peer_addr) < 0) ||
  511. !p2p_peer_known(wpa_s->global->p2p, peer_addr)) {
  512. goto err;
  513. }
  514. if (persistent) {
  515. /*
  516. * A group ID is defined meaning we want to re-invoke a
  517. * persistent group
  518. */
  519. iface = wpas_dbus_new_decompose_object_path(pg_object_path, 1,
  520. &net_id_str, NULL);
  521. if (iface == NULL ||
  522. os_strcmp(iface, wpa_s->dbus_new_path) != 0) {
  523. reply = wpas_dbus_error_invalid_args(message,
  524. pg_object_path);
  525. goto out;
  526. }
  527. group_id = strtoul(net_id_str, NULL, 10);
  528. if (errno == EINVAL) {
  529. reply = wpas_dbus_error_invalid_args(
  530. message, pg_object_path);
  531. goto out;
  532. }
  533. /* Get the SSID structure from the persistent group id */
  534. ssid = wpa_config_get_network(wpa_s->conf, group_id);
  535. if (ssid == NULL || ssid->disabled != 2)
  536. goto err;
  537. if (wpas_p2p_invite(wpa_s, peer_addr, ssid, NULL) < 0) {
  538. reply = wpas_dbus_error_unknown_error(
  539. message,
  540. "Failed to reinvoke a persistent group");
  541. goto out;
  542. }
  543. } else {
  544. /*
  545. * No group ID means propose to a peer to join my active group
  546. */
  547. if (wpas_p2p_invite_group(wpa_s, wpa_s->ifname,
  548. peer_addr, NULL)) {
  549. reply = wpas_dbus_error_unknown_error(
  550. message, "Failed to join to an active group");
  551. goto out;
  552. }
  553. }
  554. out:
  555. os_free(pg_object_path);
  556. os_free(peer_object_path);
  557. return reply;
  558. err:
  559. reply = wpas_dbus_error_invalid_args(message, NULL);
  560. goto out;
  561. }
  562. DBusMessage * wpas_dbus_handler_p2p_prov_disc_req(DBusMessage *message,
  563. struct wpa_supplicant *wpa_s)
  564. {
  565. DBusMessageIter iter;
  566. char *peer_object_path = NULL;
  567. char *config_method = NULL;
  568. u8 peer_addr[ETH_ALEN];
  569. dbus_message_iter_init(message, &iter);
  570. dbus_message_iter_get_basic(&iter, &peer_object_path);
  571. if (parse_peer_object_path(peer_object_path, peer_addr) < 0)
  572. return wpas_dbus_error_invalid_args(message, NULL);
  573. dbus_message_iter_next(&iter);
  574. dbus_message_iter_get_basic(&iter, &config_method);
  575. /*
  576. * Validation checks on config_method are being duplicated here
  577. * to be able to return invalid args reply since the error code
  578. * from p2p module are not granular enough (yet).
  579. */
  580. if (os_strcmp(config_method, "display") &&
  581. os_strcmp(config_method, "keypad") &&
  582. os_strcmp(config_method, "pbc") &&
  583. os_strcmp(config_method, "pushbutton"))
  584. return wpas_dbus_error_invalid_args(message, NULL);
  585. if (wpas_p2p_prov_disc(wpa_s, peer_addr, config_method, 0) < 0)
  586. return wpas_dbus_error_unknown_error(message,
  587. "Failed to send provision discovery request");
  588. return NULL;
  589. }
  590. /*
  591. * P2P Device property accessor methods.
  592. */
  593. dbus_bool_t wpas_dbus_getter_p2p_device_properties(DBusMessageIter *iter,
  594. DBusError *error,
  595. void *user_data)
  596. {
  597. struct wpa_supplicant *wpa_s = user_data;
  598. DBusMessageIter variant_iter, dict_iter;
  599. DBusMessageIter iter_secdev_dict_entry, iter_secdev_dict_val,
  600. iter_secdev_dict_array;
  601. const char *dev_name;
  602. int num_vendor_extensions = 0;
  603. int i;
  604. const struct wpabuf *vendor_ext[P2P_MAX_WPS_VENDOR_EXT];
  605. if (!wpa_dbus_p2p_check_enabled(wpa_s, NULL, NULL, error))
  606. return FALSE;
  607. if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
  608. "a{sv}", &variant_iter) ||
  609. !wpa_dbus_dict_open_write(&variant_iter, &dict_iter))
  610. goto err_no_mem;
  611. /* DeviceName */
  612. dev_name = wpa_s->conf->device_name;
  613. if (dev_name &&
  614. !wpa_dbus_dict_append_string(&dict_iter, "DeviceName", dev_name))
  615. goto err_no_mem;
  616. /* Primary device type */
  617. if (!wpa_dbus_dict_append_byte_array(&dict_iter, "PrimaryDeviceType",
  618. (char *)wpa_s->conf->device_type,
  619. WPS_DEV_TYPE_LEN))
  620. goto err_no_mem;
  621. /* Secondary device types */
  622. if (wpa_s->conf->num_sec_device_types) {
  623. if (!wpa_dbus_dict_begin_array(&dict_iter,
  624. "SecondaryDeviceTypes",
  625. DBUS_TYPE_ARRAY_AS_STRING
  626. DBUS_TYPE_BYTE_AS_STRING,
  627. &iter_secdev_dict_entry,
  628. &iter_secdev_dict_val,
  629. &iter_secdev_dict_array))
  630. goto err_no_mem;
  631. for (i = 0; i < wpa_s->conf->num_sec_device_types; i++)
  632. wpa_dbus_dict_bin_array_add_element(
  633. &iter_secdev_dict_array,
  634. wpa_s->conf->sec_device_type[i],
  635. WPS_DEV_TYPE_LEN);
  636. if (!wpa_dbus_dict_end_array(&dict_iter,
  637. &iter_secdev_dict_entry,
  638. &iter_secdev_dict_val,
  639. &iter_secdev_dict_array))
  640. goto err_no_mem;
  641. }
  642. /* Vendor Extensions */
  643. for (i = 0; i < P2P_MAX_WPS_VENDOR_EXT; i++) {
  644. if (wpa_s->conf->wps_vendor_ext[i] == NULL)
  645. continue;
  646. vendor_ext[num_vendor_extensions++] =
  647. wpa_s->conf->wps_vendor_ext[i];
  648. }
  649. if (num_vendor_extensions &&
  650. !wpa_dbus_dict_append_wpabuf_array(&dict_iter,
  651. "VendorExtension",
  652. vendor_ext,
  653. num_vendor_extensions))
  654. goto err_no_mem;
  655. /* GO Intent */
  656. if (!wpa_dbus_dict_append_uint32(&dict_iter, "GOIntent",
  657. wpa_s->conf->p2p_go_intent))
  658. goto err_no_mem;
  659. /* Persistent Reconnect */
  660. if (!wpa_dbus_dict_append_bool(&dict_iter, "PersistantReconnect",
  661. wpa_s->conf->persistent_reconnect))
  662. goto err_no_mem;
  663. /* Listen Reg Class */
  664. if (!wpa_dbus_dict_append_uint32(&dict_iter, "ListenRegClass",
  665. wpa_s->conf->p2p_listen_reg_class))
  666. goto err_no_mem;
  667. /* Listen Channel */
  668. if (!wpa_dbus_dict_append_uint32(&dict_iter, "ListenChannel",
  669. wpa_s->conf->p2p_listen_channel))
  670. goto err_no_mem;
  671. /* Oper Reg Class */
  672. if (!wpa_dbus_dict_append_uint32(&dict_iter, "OperRegClass",
  673. wpa_s->conf->p2p_oper_reg_class))
  674. goto err_no_mem;
  675. /* Oper Channel */
  676. if (!wpa_dbus_dict_append_uint32(&dict_iter, "OperChannel",
  677. wpa_s->conf->p2p_oper_channel))
  678. goto err_no_mem;
  679. /* SSID Postfix */
  680. if (wpa_s->conf->p2p_ssid_postfix &&
  681. !wpa_dbus_dict_append_string(&dict_iter, "SsidPostfix",
  682. wpa_s->conf->p2p_ssid_postfix))
  683. goto err_no_mem;
  684. /* Intra Bss */
  685. if (!wpa_dbus_dict_append_bool(&dict_iter, "IntraBss",
  686. wpa_s->conf->p2p_intra_bss))
  687. goto err_no_mem;
  688. /* Group Idle */
  689. if (!wpa_dbus_dict_append_uint32(&dict_iter, "GroupIdle",
  690. wpa_s->conf->p2p_group_idle))
  691. goto err_no_mem;
  692. /* Dissasociation low ack */
  693. if (!wpa_dbus_dict_append_uint32(&dict_iter, "disassoc_low_ack",
  694. wpa_s->conf->disassoc_low_ack))
  695. goto err_no_mem;
  696. if (!wpa_dbus_dict_close_write(&variant_iter, &dict_iter) ||
  697. !dbus_message_iter_close_container(iter, &variant_iter))
  698. goto err_no_mem;
  699. return TRUE;
  700. err_no_mem:
  701. dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
  702. return FALSE;
  703. }
  704. dbus_bool_t wpas_dbus_setter_p2p_device_properties(DBusMessageIter *iter,
  705. DBusError *error,
  706. void *user_data)
  707. {
  708. struct wpa_supplicant *wpa_s = user_data;
  709. DBusMessageIter variant_iter, iter_dict;
  710. struct wpa_dbus_dict_entry entry = {.type = DBUS_TYPE_STRING };
  711. unsigned int i;
  712. if (!wpa_dbus_p2p_check_enabled(wpa_s, NULL, NULL, error))
  713. return FALSE;
  714. dbus_message_iter_recurse(iter, &variant_iter);
  715. if (!wpa_dbus_dict_open_read(&variant_iter, &iter_dict, error))
  716. return FALSE;
  717. while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
  718. if (!wpa_dbus_dict_get_entry(&iter_dict, &entry)) {
  719. dbus_set_error_const(error, DBUS_ERROR_INVALID_ARGS,
  720. "invalid message format");
  721. return FALSE;
  722. }
  723. if (os_strcmp(entry.key, "DeviceName") == 0) {
  724. char *devname;
  725. if (entry.type != DBUS_TYPE_STRING)
  726. goto error;
  727. devname = os_strdup(entry.str_value);
  728. if (devname == NULL)
  729. goto err_no_mem_clear;
  730. os_free(wpa_s->conf->device_name);
  731. wpa_s->conf->device_name = devname;
  732. wpa_s->conf->changed_parameters |=
  733. CFG_CHANGED_DEVICE_NAME;
  734. } else if (os_strcmp(entry.key, "PrimaryDeviceType") == 0) {
  735. if (entry.type != DBUS_TYPE_ARRAY ||
  736. entry.array_type != DBUS_TYPE_BYTE ||
  737. entry.array_len != WPS_DEV_TYPE_LEN)
  738. goto error;
  739. os_memcpy(wpa_s->conf->device_type,
  740. entry.bytearray_value,
  741. WPS_DEV_TYPE_LEN);
  742. wpa_s->conf->changed_parameters |=
  743. CFG_CHANGED_DEVICE_TYPE;
  744. } else if (os_strcmp(entry.key, "SecondaryDeviceTypes") == 0) {
  745. if (entry.type != DBUS_TYPE_ARRAY ||
  746. entry.array_type != WPAS_DBUS_TYPE_BINARRAY ||
  747. entry.array_len > MAX_SEC_DEVICE_TYPES)
  748. goto error;
  749. for (i = 0; i < entry.array_len; i++)
  750. if (wpabuf_len(entry.binarray_value[i]) !=
  751. WPS_DEV_TYPE_LEN)
  752. goto err_no_mem_clear;
  753. for (i = 0; i < entry.array_len; i++)
  754. os_memcpy(wpa_s->conf->sec_device_type[i],
  755. wpabuf_head(entry.binarray_value[i]),
  756. WPS_DEV_TYPE_LEN);
  757. wpa_s->conf->num_sec_device_types = entry.array_len;
  758. wpa_s->conf->changed_parameters |=
  759. CFG_CHANGED_SEC_DEVICE_TYPE;
  760. } else if (os_strcmp(entry.key, "VendorExtension") == 0) {
  761. if ((entry.type != DBUS_TYPE_ARRAY) ||
  762. (entry.array_type != WPAS_DBUS_TYPE_BINARRAY) ||
  763. (entry.array_len > P2P_MAX_WPS_VENDOR_EXT))
  764. goto error;
  765. wpa_s->conf->changed_parameters |=
  766. CFG_CHANGED_VENDOR_EXTENSION;
  767. for (i = 0; i < P2P_MAX_WPS_VENDOR_EXT; i++) {
  768. wpabuf_free(wpa_s->conf->wps_vendor_ext[i]);
  769. if (i < entry.array_len) {
  770. wpa_s->conf->wps_vendor_ext[i] =
  771. entry.binarray_value[i];
  772. entry.binarray_value[i] = NULL;
  773. } else
  774. wpa_s->conf->wps_vendor_ext[i] = NULL;
  775. }
  776. } else if ((os_strcmp(entry.key, "GOIntent") == 0) &&
  777. (entry.type == DBUS_TYPE_UINT32) &&
  778. (entry.uint32_value <= 15))
  779. wpa_s->conf->p2p_go_intent = entry.uint32_value;
  780. else if ((os_strcmp(entry.key, "PersistantReconnect") == 0) &&
  781. (entry.type == DBUS_TYPE_BOOLEAN))
  782. wpa_s->conf->persistent_reconnect = entry.bool_value;
  783. else if ((os_strcmp(entry.key, "ListenRegClass") == 0) &&
  784. (entry.type == DBUS_TYPE_UINT32)) {
  785. wpa_s->conf->p2p_listen_reg_class = entry.uint32_value;
  786. wpa_s->conf->changed_parameters |=
  787. CFG_CHANGED_P2P_LISTEN_CHANNEL;
  788. } else if ((os_strcmp(entry.key, "ListenChannel") == 0) &&
  789. (entry.type == DBUS_TYPE_UINT32)) {
  790. wpa_s->conf->p2p_listen_channel = entry.uint32_value;
  791. wpa_s->conf->changed_parameters |=
  792. CFG_CHANGED_P2P_LISTEN_CHANNEL;
  793. } else if ((os_strcmp(entry.key, "OperRegClass") == 0) &&
  794. (entry.type == DBUS_TYPE_UINT32)) {
  795. wpa_s->conf->p2p_oper_reg_class = entry.uint32_value;
  796. wpa_s->conf->changed_parameters |=
  797. CFG_CHANGED_P2P_OPER_CHANNEL;
  798. } else if ((os_strcmp(entry.key, "OperChannel") == 0) &&
  799. (entry.type == DBUS_TYPE_UINT32)) {
  800. wpa_s->conf->p2p_oper_channel = entry.uint32_value;
  801. wpa_s->conf->changed_parameters |=
  802. CFG_CHANGED_P2P_OPER_CHANNEL;
  803. } else if (os_strcmp(entry.key, "SsidPostfix") == 0) {
  804. char *postfix;
  805. if (entry.type != DBUS_TYPE_STRING)
  806. goto error;
  807. postfix = os_strdup(entry.str_value);
  808. if (!postfix)
  809. goto err_no_mem_clear;
  810. os_free(wpa_s->conf->p2p_ssid_postfix);
  811. wpa_s->conf->p2p_ssid_postfix = postfix;
  812. wpa_s->conf->changed_parameters |=
  813. CFG_CHANGED_P2P_SSID_POSTFIX;
  814. } else if ((os_strcmp(entry.key, "IntraBss") == 0) &&
  815. (entry.type == DBUS_TYPE_BOOLEAN)) {
  816. wpa_s->conf->p2p_intra_bss = entry.bool_value;
  817. wpa_s->conf->changed_parameters |=
  818. CFG_CHANGED_P2P_INTRA_BSS;
  819. } else if ((os_strcmp(entry.key, "GroupIdle") == 0) &&
  820. (entry.type == DBUS_TYPE_UINT32))
  821. wpa_s->conf->p2p_group_idle = entry.uint32_value;
  822. else if (os_strcmp(entry.key, "disassoc_low_ack") == 0 &&
  823. entry.type == DBUS_TYPE_UINT32)
  824. wpa_s->conf->disassoc_low_ack = entry.uint32_value;
  825. else
  826. goto error;
  827. wpa_dbus_dict_entry_clear(&entry);
  828. }
  829. if (wpa_s->conf->changed_parameters) {
  830. /* Some changed parameters requires to update config*/
  831. wpa_supplicant_update_config(wpa_s);
  832. }
  833. return TRUE;
  834. error:
  835. dbus_set_error_const(error, DBUS_ERROR_INVALID_ARGS,
  836. "invalid message format");
  837. wpa_dbus_dict_entry_clear(&entry);
  838. return FALSE;
  839. err_no_mem_clear:
  840. dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
  841. wpa_dbus_dict_entry_clear(&entry);
  842. return FALSE;
  843. }
  844. dbus_bool_t wpas_dbus_getter_p2p_peers(DBusMessageIter *iter, DBusError *error,
  845. void *user_data)
  846. {
  847. struct wpa_supplicant *wpa_s = user_data;
  848. struct p2p_data *p2p = wpa_s->global->p2p;
  849. int next = 0, i = 0;
  850. int num = 0, out_of_mem = 0;
  851. const u8 *addr;
  852. const struct p2p_peer_info *peer_info = NULL;
  853. dbus_bool_t success = FALSE;
  854. struct dl_list peer_objpath_list;
  855. struct peer_objpath_node {
  856. struct dl_list list;
  857. char path[WPAS_DBUS_OBJECT_PATH_MAX];
  858. } *node, *tmp;
  859. char **peer_obj_paths = NULL;
  860. if (!wpa_dbus_p2p_check_enabled(wpa_s, NULL, NULL, error))
  861. return FALSE;
  862. dl_list_init(&peer_objpath_list);
  863. /* Get the first peer info */
  864. peer_info = p2p_get_peer_found(p2p, NULL, next);
  865. /* Get next and accumulate them */
  866. next = 1;
  867. while (peer_info != NULL) {
  868. node = os_zalloc(sizeof(struct peer_objpath_node));
  869. if (!node) {
  870. out_of_mem = 1;
  871. goto error;
  872. }
  873. addr = peer_info->p2p_device_addr;
  874. os_snprintf(node->path, WPAS_DBUS_OBJECT_PATH_MAX,
  875. "%s/" WPAS_DBUS_NEW_P2P_PEERS_PART
  876. "/" COMPACT_MACSTR,
  877. wpa_s->dbus_new_path, MAC2STR(addr));
  878. dl_list_add_tail(&peer_objpath_list, &node->list);
  879. num++;
  880. peer_info = p2p_get_peer_found(p2p, addr, next);
  881. }
  882. /*
  883. * Now construct the peer object paths in a form suitable for
  884. * array_property_getter helper below.
  885. */
  886. peer_obj_paths = os_zalloc(num * sizeof(char *));
  887. if (!peer_obj_paths) {
  888. out_of_mem = 1;
  889. goto error;
  890. }
  891. dl_list_for_each_safe(node, tmp, &peer_objpath_list,
  892. struct peer_objpath_node, list)
  893. peer_obj_paths[i++] = node->path;
  894. success = wpas_dbus_simple_array_property_getter(iter,
  895. DBUS_TYPE_OBJECT_PATH,
  896. peer_obj_paths, num,
  897. error);
  898. error:
  899. if (peer_obj_paths)
  900. os_free(peer_obj_paths);
  901. dl_list_for_each_safe(node, tmp, &peer_objpath_list,
  902. struct peer_objpath_node, list) {
  903. dl_list_del(&node->list);
  904. os_free(node);
  905. }
  906. if (out_of_mem)
  907. dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
  908. return success;
  909. }
  910. enum wpas_p2p_role {
  911. WPAS_P2P_ROLE_DEVICE,
  912. WPAS_P2P_ROLE_GO,
  913. WPAS_P2P_ROLE_CLIENT,
  914. };
  915. static enum wpas_p2p_role wpas_get_p2p_role(struct wpa_supplicant *wpa_s)
  916. {
  917. struct wpa_ssid *ssid = wpa_s->current_ssid;
  918. if (!ssid)
  919. return WPAS_P2P_ROLE_DEVICE;
  920. if (wpa_s->wpa_state != WPA_COMPLETED)
  921. return WPAS_P2P_ROLE_DEVICE;
  922. switch (ssid->mode) {
  923. case WPAS_MODE_P2P_GO:
  924. case WPAS_MODE_P2P_GROUP_FORMATION:
  925. return WPAS_P2P_ROLE_GO;
  926. case WPAS_MODE_INFRA:
  927. if (ssid->p2p_group)
  928. return WPAS_P2P_ROLE_CLIENT;
  929. return WPAS_P2P_ROLE_DEVICE;
  930. default:
  931. return WPAS_P2P_ROLE_DEVICE;
  932. }
  933. }
  934. dbus_bool_t wpas_dbus_getter_p2p_role(DBusMessageIter *iter, DBusError *error,
  935. void *user_data)
  936. {
  937. struct wpa_supplicant *wpa_s = user_data;
  938. char *str;
  939. switch (wpas_get_p2p_role(wpa_s)) {
  940. case WPAS_P2P_ROLE_GO:
  941. str = "GO";
  942. break;
  943. case WPAS_P2P_ROLE_CLIENT:
  944. str = "client";
  945. break;
  946. default:
  947. str = "device";
  948. }
  949. return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING, &str,
  950. error);
  951. }
  952. dbus_bool_t wpas_dbus_getter_p2p_group(DBusMessageIter *iter, DBusError *error,
  953. void *user_data)
  954. {
  955. struct wpa_supplicant *wpa_s = user_data;
  956. if (wpa_s->dbus_groupobj_path == NULL)
  957. return FALSE;
  958. return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_OBJECT_PATH,
  959. &wpa_s->dbus_groupobj_path,
  960. error);
  961. }
  962. dbus_bool_t wpas_dbus_getter_p2p_peergo(DBusMessageIter *iter,
  963. DBusError *error, void *user_data)
  964. {
  965. struct wpa_supplicant *wpa_s = user_data;
  966. char go_peer_obj_path[WPAS_DBUS_OBJECT_PATH_MAX], *path;
  967. if (wpas_get_p2p_role(wpa_s) != WPAS_P2P_ROLE_CLIENT)
  968. return FALSE;
  969. os_snprintf(go_peer_obj_path, WPAS_DBUS_OBJECT_PATH_MAX,
  970. "%s/" WPAS_DBUS_NEW_P2P_PEERS_PART "/" COMPACT_MACSTR,
  971. wpa_s->dbus_new_path, MAC2STR(wpa_s->go_dev_addr));
  972. path = go_peer_obj_path;
  973. return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_OBJECT_PATH,
  974. &path, error);
  975. }
  976. /*
  977. * Peer object properties accessor methods
  978. */
  979. dbus_bool_t wpas_dbus_getter_p2p_peer_properties(DBusMessageIter *iter,
  980. DBusError *error, void *user_data)
  981. {
  982. struct peer_handler_args *peer_args = user_data;
  983. DBusMessageIter variant_iter, dict_iter;
  984. const struct p2p_peer_info *info = NULL;
  985. const struct wpabuf *vendor_extension[P2P_MAX_WPS_VENDOR_EXT];
  986. int i, num;
  987. if (!wpa_dbus_p2p_check_enabled(peer_args->wpa_s, NULL, NULL, error))
  988. return FALSE;
  989. /* get the peer info */
  990. info = p2p_get_peer_found(peer_args->wpa_s->global->p2p,
  991. peer_args->p2p_device_addr, 0);
  992. if (info == NULL) {
  993. dbus_set_error(error, DBUS_ERROR_FAILED, "failed to find peer");
  994. return FALSE;
  995. }
  996. if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
  997. "a{sv}", &variant_iter) ||
  998. !wpa_dbus_dict_open_write(&variant_iter, &dict_iter))
  999. goto err_no_mem;
  1000. /* Fill out the dictionary */
  1001. if (!wpa_dbus_dict_append_string(&dict_iter, "DeviceName",
  1002. info->device_name))
  1003. goto err_no_mem;
  1004. if (!wpa_dbus_dict_append_byte_array(&dict_iter, "PrimaryDeviceType",
  1005. (char *)info->pri_dev_type,
  1006. WPS_DEV_TYPE_LEN))
  1007. goto err_no_mem;
  1008. if (!wpa_dbus_dict_append_uint16(&dict_iter, "config_method",
  1009. info->config_methods))
  1010. goto err_no_mem;
  1011. if (!wpa_dbus_dict_append_int32(&dict_iter, "level",
  1012. info->level))
  1013. goto err_no_mem;
  1014. if (!wpa_dbus_dict_append_byte(&dict_iter, "devicecapability",
  1015. info->dev_capab))
  1016. goto err_no_mem;
  1017. if (!wpa_dbus_dict_append_byte(&dict_iter, "groupcapability",
  1018. info->group_capab))
  1019. goto err_no_mem;
  1020. if (info->wps_sec_dev_type_list_len) {
  1021. const u8 *sec_dev_type_list = info->wps_sec_dev_type_list;
  1022. int num_sec_dev_types =
  1023. info->wps_sec_dev_type_list_len / WPS_DEV_TYPE_LEN;
  1024. DBusMessageIter iter_secdev_dict_entry, iter_secdev_dict_val,
  1025. iter_secdev_dict_array;
  1026. if (num_sec_dev_types) {
  1027. if (!wpa_dbus_dict_begin_array(&dict_iter,
  1028. "SecondaryDeviceTypes",
  1029. DBUS_TYPE_ARRAY_AS_STRING
  1030. DBUS_TYPE_BYTE_AS_STRING,
  1031. &iter_secdev_dict_entry,
  1032. &iter_secdev_dict_val,
  1033. &iter_secdev_dict_array))
  1034. goto err_no_mem;
  1035. for (i = 0; i < num_sec_dev_types; i++) {
  1036. wpa_dbus_dict_bin_array_add_element(
  1037. &iter_secdev_dict_array,
  1038. sec_dev_type_list,
  1039. WPS_DEV_TYPE_LEN);
  1040. sec_dev_type_list += WPS_DEV_TYPE_LEN;
  1041. }
  1042. if (!wpa_dbus_dict_end_array(&dict_iter,
  1043. &iter_secdev_dict_entry,
  1044. &iter_secdev_dict_val,
  1045. &iter_secdev_dict_array))
  1046. goto err_no_mem;
  1047. }
  1048. }
  1049. /* Add WPS vendor extensions attribute */
  1050. for (i = 0, num = 0; i < P2P_MAX_WPS_VENDOR_EXT; i++) {
  1051. if (info->wps_vendor_ext[i] == NULL)
  1052. continue;
  1053. vendor_extension[num] = info->wps_vendor_ext[i];
  1054. num++;
  1055. }
  1056. if (!wpa_dbus_dict_append_wpabuf_array(&dict_iter, "VendorExtension",
  1057. vendor_extension, num))
  1058. goto err_no_mem;
  1059. if (!wpa_dbus_dict_close_write(&variant_iter, &dict_iter) ||
  1060. !dbus_message_iter_close_container(iter, &variant_iter))
  1061. goto err_no_mem;
  1062. return TRUE;
  1063. err_no_mem:
  1064. dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
  1065. return FALSE;
  1066. }
  1067. dbus_bool_t wpas_dbus_getter_p2p_peer_ies(DBusMessageIter *iter,
  1068. DBusError *error, void *user_data)
  1069. {
  1070. /* struct peer_handler_args *peer_args = user_data; */
  1071. dbus_set_error_const(error, DBUS_ERROR_FAILED, "not implemented");
  1072. return FALSE;
  1073. }
  1074. /**
  1075. * wpas_dbus_getter_persistent_groups - Get array of persistent group objects
  1076. * @iter: Pointer to incoming dbus message iter
  1077. * @error: Location to store error on failure
  1078. * @user_data: Function specific data
  1079. * Returns: TRUE on success, FALSE on failure
  1080. *
  1081. * Getter for "PersistentGroups" property.
  1082. */
  1083. dbus_bool_t wpas_dbus_getter_persistent_groups(DBusMessageIter *iter,
  1084. DBusError *error,
  1085. void *user_data)
  1086. {
  1087. struct wpa_supplicant *wpa_s = user_data;
  1088. struct wpa_ssid *ssid;
  1089. char **paths;
  1090. unsigned int i = 0, num = 0;
  1091. dbus_bool_t success = FALSE;
  1092. if (wpa_s->conf == NULL) {
  1093. wpa_printf(MSG_ERROR, "dbus: %s: "
  1094. "An error occurred getting persistent groups list",
  1095. __func__);
  1096. dbus_set_error_const(error, DBUS_ERROR_FAILED, "an error "
  1097. "occurred getting persistent groups list");
  1098. return FALSE;
  1099. }
  1100. for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
  1101. if (network_is_persistent_group(ssid))
  1102. num++;
  1103. paths = os_zalloc(num * sizeof(char *));
  1104. if (!paths) {
  1105. dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
  1106. return FALSE;
  1107. }
  1108. /* Loop through configured networks and append object path of each */
  1109. for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) {
  1110. if (!network_is_persistent_group(ssid))
  1111. continue;
  1112. paths[i] = os_zalloc(WPAS_DBUS_OBJECT_PATH_MAX);
  1113. if (paths[i] == NULL) {
  1114. dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY,
  1115. "no memory");
  1116. goto out;
  1117. }
  1118. /* Construct the object path for this network. */
  1119. os_snprintf(paths[i++], WPAS_DBUS_OBJECT_PATH_MAX,
  1120. "%s/" WPAS_DBUS_NEW_PERSISTENT_GROUPS_PART "/%d",
  1121. wpa_s->dbus_new_path, ssid->id);
  1122. }
  1123. success = wpas_dbus_simple_array_property_getter(iter,
  1124. DBUS_TYPE_OBJECT_PATH,
  1125. paths, num, error);
  1126. out:
  1127. while (i)
  1128. os_free(paths[--i]);
  1129. os_free(paths);
  1130. return success;
  1131. }
  1132. /**
  1133. * wpas_dbus_getter_persistent_group_properties - Get options for a persistent
  1134. * group
  1135. * @iter: Pointer to incoming dbus message iter
  1136. * @error: Location to store error on failure
  1137. * @user_data: Function specific data
  1138. * Returns: TRUE on success, FALSE on failure
  1139. *
  1140. * Getter for "Properties" property of a persistent group.
  1141. */
  1142. dbus_bool_t wpas_dbus_getter_persistent_group_properties(DBusMessageIter *iter,
  1143. DBusError *error,
  1144. void *user_data)
  1145. {
  1146. struct network_handler_args *net = user_data;
  1147. /* Leveraging the fact that persistent group object is still
  1148. * represented in same manner as network within.
  1149. */
  1150. return wpas_dbus_getter_network_properties(iter, error, net);
  1151. }
  1152. /**
  1153. * wpas_dbus_setter_persistent_group_properties - Get options for a persistent
  1154. * group
  1155. * @iter: Pointer to incoming dbus message iter
  1156. * @error: Location to store error on failure
  1157. * @user_data: Function specific data
  1158. * Returns: TRUE on success, FALSE on failure
  1159. *
  1160. * Setter for "Properties" property of a persistent group.
  1161. */
  1162. dbus_bool_t wpas_dbus_setter_persistent_group_properties(DBusMessageIter *iter,
  1163. DBusError *error,
  1164. void *user_data)
  1165. {
  1166. struct network_handler_args *net = user_data;
  1167. struct wpa_ssid *ssid = net->ssid;
  1168. DBusMessageIter variant_iter;
  1169. /*
  1170. * Leveraging the fact that persistent group object is still
  1171. * represented in same manner as network within.
  1172. */
  1173. dbus_message_iter_recurse(iter, &variant_iter);
  1174. return set_network_properties(net->wpa_s, ssid, &variant_iter, error);
  1175. }
  1176. /**
  1177. * wpas_dbus_new_iface_add_persistent_group - Add a new configured
  1178. * persistent_group
  1179. * @message: Pointer to incoming dbus message
  1180. * @wpa_s: wpa_supplicant structure for a network interface
  1181. * Returns: A dbus message containing the object path of the new
  1182. * persistent group
  1183. *
  1184. * Handler function for "AddPersistentGroup" method call of a P2P Device
  1185. * interface.
  1186. */
  1187. DBusMessage * wpas_dbus_handler_add_persistent_group(
  1188. DBusMessage *message, struct wpa_supplicant *wpa_s)
  1189. {
  1190. DBusMessage *reply = NULL;
  1191. DBusMessageIter iter;
  1192. struct wpa_ssid *ssid = NULL;
  1193. char path_buf[WPAS_DBUS_OBJECT_PATH_MAX], *path = path_buf;
  1194. DBusError error;
  1195. dbus_message_iter_init(message, &iter);
  1196. ssid = wpa_config_add_network(wpa_s->conf);
  1197. if (ssid == NULL) {
  1198. wpa_printf(MSG_ERROR, "dbus: %s: "
  1199. "Cannot add new persistent group", __func__);
  1200. reply = wpas_dbus_error_unknown_error(
  1201. message,
  1202. "wpa_supplicant could not add "
  1203. "a persistent group on this interface.");
  1204. goto err;
  1205. }
  1206. /* Mark the ssid as being a persistent group before the notification */
  1207. ssid->disabled = 2;
  1208. ssid->p2p_persistent_group = 1;
  1209. wpas_notify_persistent_group_added(wpa_s, ssid);
  1210. wpa_config_set_network_defaults(ssid);
  1211. dbus_error_init(&error);
  1212. if (!set_network_properties(wpa_s, ssid, &iter, &error)) {
  1213. wpa_printf(MSG_DEBUG, "dbus: %s: "
  1214. "Control interface could not set persistent group "
  1215. "properties", __func__);
  1216. reply = wpas_dbus_reply_new_from_error(message, &error,
  1217. DBUS_ERROR_INVALID_ARGS,
  1218. "Failed to set network "
  1219. "properties");
  1220. dbus_error_free(&error);
  1221. goto err;
  1222. }
  1223. /* Construct the object path for this network. */
  1224. os_snprintf(path, WPAS_DBUS_OBJECT_PATH_MAX,
  1225. "%s/" WPAS_DBUS_NEW_PERSISTENT_GROUPS_PART "/%d",
  1226. wpa_s->dbus_new_path, ssid->id);
  1227. reply = dbus_message_new_method_return(message);
  1228. if (reply == NULL) {
  1229. reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
  1230. NULL);
  1231. goto err;
  1232. }
  1233. if (!dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH, &path,
  1234. DBUS_TYPE_INVALID)) {
  1235. dbus_message_unref(reply);
  1236. reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
  1237. NULL);
  1238. goto err;
  1239. }
  1240. return reply;
  1241. err:
  1242. if (ssid) {
  1243. wpas_notify_persistent_group_removed(wpa_s, ssid);
  1244. wpa_config_remove_network(wpa_s->conf, ssid->id);
  1245. }
  1246. return reply;
  1247. }
  1248. /**
  1249. * wpas_dbus_handler_remove_persistent_group - Remove a configured persistent
  1250. * group
  1251. * @message: Pointer to incoming dbus message
  1252. * @wpa_s: wpa_supplicant structure for a network interface
  1253. * Returns: NULL on success or dbus error on failure
  1254. *
  1255. * Handler function for "RemovePersistentGroup" method call of a P2P Device
  1256. * interface.
  1257. */
  1258. DBusMessage * wpas_dbus_handler_remove_persistent_group(
  1259. DBusMessage *message, struct wpa_supplicant *wpa_s)
  1260. {
  1261. DBusMessage *reply = NULL;
  1262. const char *op;
  1263. char *iface = NULL, *persistent_group_id = NULL;
  1264. int id;
  1265. struct wpa_ssid *ssid;
  1266. dbus_message_get_args(message, NULL, DBUS_TYPE_OBJECT_PATH, &op,
  1267. DBUS_TYPE_INVALID);
  1268. /*
  1269. * Extract the network ID and ensure the network is actually a child of
  1270. * this interface.
  1271. */
  1272. iface = wpas_dbus_new_decompose_object_path(op, 1,
  1273. &persistent_group_id,
  1274. NULL);
  1275. if (iface == NULL || os_strcmp(iface, wpa_s->dbus_new_path) != 0) {
  1276. reply = wpas_dbus_error_invalid_args(message, op);
  1277. goto out;
  1278. }
  1279. id = strtoul(persistent_group_id, NULL, 10);
  1280. if (errno == EINVAL) {
  1281. reply = wpas_dbus_error_invalid_args(message, op);
  1282. goto out;
  1283. }
  1284. ssid = wpa_config_get_network(wpa_s->conf, id);
  1285. if (ssid == NULL) {
  1286. reply = wpas_dbus_error_persistent_group_unknown(message);
  1287. goto out;
  1288. }
  1289. wpas_notify_persistent_group_removed(wpa_s, ssid);
  1290. if (wpa_config_remove_network(wpa_s->conf, id) < 0) {
  1291. wpa_printf(MSG_ERROR, "dbus: %s: "
  1292. "error occurred when removing persistent group %d",
  1293. __func__, id);
  1294. reply = wpas_dbus_error_unknown_error(
  1295. message,
  1296. "error removing the specified persistent group on "
  1297. "this interface.");
  1298. goto out;
  1299. }
  1300. out:
  1301. os_free(iface);
  1302. os_free(persistent_group_id);
  1303. return reply;
  1304. }
  1305. static void remove_persistent_group(struct wpa_supplicant *wpa_s,
  1306. struct wpa_ssid *ssid)
  1307. {
  1308. wpas_notify_persistent_group_removed(wpa_s, ssid);
  1309. if (wpa_config_remove_network(wpa_s->conf, ssid->id) < 0) {
  1310. wpa_printf(MSG_ERROR, "dbus: %s: "
  1311. "error occurred when removing persistent group %d",
  1312. __func__, ssid->id);
  1313. return;
  1314. }
  1315. }
  1316. /**
  1317. * wpas_dbus_handler_remove_all_persistent_groups - Remove all configured
  1318. * persistent groups
  1319. * @message: Pointer to incoming dbus message
  1320. * @wpa_s: wpa_supplicant structure for a network interface
  1321. * Returns: NULL on success or dbus error on failure
  1322. *
  1323. * Handler function for "RemoveAllPersistentGroups" method call of a
  1324. * P2P Device interface.
  1325. */
  1326. DBusMessage * wpas_dbus_handler_remove_all_persistent_groups(
  1327. DBusMessage *message, struct wpa_supplicant *wpa_s)
  1328. {
  1329. struct wpa_ssid *ssid, *next;
  1330. struct wpa_config *config;
  1331. config = wpa_s->conf;
  1332. ssid = config->ssid;
  1333. while (ssid) {
  1334. next = ssid->next;
  1335. if (network_is_persistent_group(ssid))
  1336. remove_persistent_group(wpa_s, ssid);
  1337. ssid = next;
  1338. }
  1339. return NULL;
  1340. }
  1341. /*
  1342. * Group object properties accessor methods
  1343. */
  1344. dbus_bool_t wpas_dbus_getter_p2p_group_members(DBusMessageIter *iter,
  1345. DBusError *error,
  1346. void *user_data)
  1347. {
  1348. struct wpa_supplicant *wpa_s = user_data;
  1349. struct wpa_ssid *ssid;
  1350. unsigned int num_members;
  1351. char **paths;
  1352. unsigned int i;
  1353. void *next = NULL;
  1354. const u8 *addr;
  1355. dbus_bool_t success = FALSE;
  1356. /* Ensure we are a GO */
  1357. if (wpa_s->wpa_state != WPA_COMPLETED)
  1358. return FALSE;
  1359. ssid = wpa_s->conf->ssid;
  1360. /* At present WPAS P2P_GO mode only applicable for p2p_go */
  1361. if (ssid->mode != WPAS_MODE_P2P_GO &&
  1362. ssid->mode != WPAS_MODE_AP &&
  1363. ssid->mode != WPAS_MODE_P2P_GROUP_FORMATION)
  1364. return FALSE;
  1365. num_members = p2p_get_group_num_members(wpa_s->p2p_group);
  1366. paths = os_zalloc(num_members * sizeof(char *));
  1367. if (!paths)
  1368. goto out_of_memory;
  1369. i = 0;
  1370. while ((addr = p2p_iterate_group_members(wpa_s->p2p_group, &next))) {
  1371. paths[i] = os_zalloc(WPAS_DBUS_OBJECT_PATH_MAX);
  1372. if (!paths[i])
  1373. goto out_of_memory;
  1374. os_snprintf(paths[i], WPAS_DBUS_OBJECT_PATH_MAX,
  1375. "%s/" WPAS_DBUS_NEW_P2P_GROUPMEMBERS_PART
  1376. "/" COMPACT_MACSTR,
  1377. wpa_s->dbus_groupobj_path, MAC2STR(addr));
  1378. i++;
  1379. }
  1380. success = wpas_dbus_simple_array_property_getter(iter,
  1381. DBUS_TYPE_OBJECT_PATH,
  1382. paths, num_members,
  1383. error);
  1384. for (i = 0; i < num_members; i++)
  1385. os_free(paths[i]);
  1386. os_free(paths);
  1387. return success;
  1388. out_of_memory:
  1389. dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
  1390. if (paths) {
  1391. for (i = 0; i < num_members; i++)
  1392. os_free(paths[i]);
  1393. os_free(paths);
  1394. }
  1395. return FALSE;
  1396. }
  1397. dbus_bool_t wpas_dbus_getter_p2p_group_properties(DBusMessageIter *iter,
  1398. DBusError *error,
  1399. void *user_data)
  1400. {
  1401. struct wpa_supplicant *wpa_s = user_data;
  1402. DBusMessageIter variant_iter, dict_iter;
  1403. struct hostapd_data *hapd = wpa_s->ap_iface->bss[0];
  1404. const struct wpabuf *vendor_ext[MAX_WPS_VENDOR_EXTENSIONS];
  1405. int num_vendor_ext = 0;
  1406. int i;
  1407. if (!hapd) {
  1408. dbus_set_error_const(error, DBUS_ERROR_FAILED,
  1409. "internal error");
  1410. return FALSE;
  1411. }
  1412. if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
  1413. "a{sv}", &variant_iter) ||
  1414. !wpa_dbus_dict_open_write(&variant_iter, &dict_iter))
  1415. goto err_no_mem;
  1416. /* Parse WPS Vendor Extensions sent in Beacon/Probe Response */
  1417. for (i = 0; i < MAX_WPS_VENDOR_EXTENSIONS; i++) {
  1418. if (hapd->conf->wps_vendor_ext[i] == NULL)
  1419. continue;
  1420. vendor_ext[num_vendor_ext++] = hapd->conf->wps_vendor_ext[i];
  1421. }
  1422. if (!wpa_dbus_dict_append_wpabuf_array(&dict_iter,
  1423. "WPSVendorExtensions",
  1424. vendor_ext, num_vendor_ext))
  1425. goto err_no_mem;
  1426. if (!wpa_dbus_dict_close_write(&variant_iter, &dict_iter) ||
  1427. !dbus_message_iter_close_container(iter, &variant_iter))
  1428. goto err_no_mem;
  1429. return TRUE;
  1430. err_no_mem:
  1431. dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
  1432. return FALSE;
  1433. }
  1434. dbus_bool_t wpas_dbus_setter_p2p_group_properties(DBusMessageIter *iter,
  1435. DBusError *error,
  1436. void *user_data)
  1437. {
  1438. struct wpa_supplicant *wpa_s = user_data;
  1439. DBusMessageIter variant_iter, iter_dict;
  1440. struct wpa_dbus_dict_entry entry = { .type = DBUS_TYPE_STRING };
  1441. unsigned int i;
  1442. struct hostapd_data *hapd = wpa_s->ap_iface->bss[0];
  1443. if (!hapd) {
  1444. dbus_set_error_const(error, DBUS_ERROR_FAILED,
  1445. "internal error");
  1446. return FALSE;
  1447. }
  1448. dbus_message_iter_recurse(iter, &variant_iter);
  1449. if (!wpa_dbus_dict_open_read(&variant_iter, &iter_dict, error))
  1450. return FALSE;
  1451. while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
  1452. if (!wpa_dbus_dict_get_entry(&iter_dict, &entry)) {
  1453. dbus_set_error_const(error, DBUS_ERROR_INVALID_ARGS,
  1454. "invalid message format");
  1455. return FALSE;
  1456. }
  1457. if (os_strcmp(entry.key, "WPSVendorExtensions") == 0) {
  1458. if (entry.type != DBUS_TYPE_ARRAY ||
  1459. entry.array_type != WPAS_DBUS_TYPE_BINARRAY ||
  1460. entry.array_len > MAX_WPS_VENDOR_EXTENSIONS)
  1461. goto error;
  1462. for (i = 0; i < MAX_WPS_VENDOR_EXTENSIONS; i++) {
  1463. if (i < entry.array_len) {
  1464. hapd->conf->wps_vendor_ext[i] =
  1465. entry.binarray_value[i];
  1466. entry.binarray_value[i] = NULL;
  1467. } else
  1468. hapd->conf->wps_vendor_ext[i] = NULL;
  1469. }
  1470. hostapd_update_wps(hapd);
  1471. } else
  1472. goto error;
  1473. wpa_dbus_dict_entry_clear(&entry);
  1474. }
  1475. return TRUE;
  1476. error:
  1477. wpa_dbus_dict_entry_clear(&entry);
  1478. dbus_set_error_const(error, DBUS_ERROR_INVALID_ARGS,
  1479. "invalid message format");
  1480. return FALSE;
  1481. }
  1482. DBusMessage * wpas_dbus_handler_p2p_add_service(DBusMessage *message,
  1483. struct wpa_supplicant *wpa_s)
  1484. {
  1485. DBusMessageIter iter_dict;
  1486. DBusMessage *reply = NULL;
  1487. DBusMessageIter iter;
  1488. struct wpa_dbus_dict_entry entry;
  1489. int upnp = 0;
  1490. int bonjour = 0;
  1491. char *service = NULL;
  1492. struct wpabuf *query = NULL;
  1493. struct wpabuf *resp = NULL;
  1494. u8 version = 0;
  1495. dbus_message_iter_init(message, &iter);
  1496. if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
  1497. goto error;
  1498. if (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
  1499. if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
  1500. goto error;
  1501. if (!os_strcmp(entry.key, "service_type") &&
  1502. (entry.type == DBUS_TYPE_STRING)) {
  1503. if (!os_strcmp(entry.str_value, "upnp"))
  1504. upnp = 1;
  1505. else if (!os_strcmp(entry.str_value, "bonjour"))
  1506. bonjour = 1;
  1507. else
  1508. goto error_clear;
  1509. wpa_dbus_dict_entry_clear(&entry);
  1510. }
  1511. }
  1512. if (upnp == 1) {
  1513. while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
  1514. if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
  1515. goto error;
  1516. if (!os_strcmp(entry.key, "version") &&
  1517. entry.type == DBUS_TYPE_INT32)
  1518. version = entry.uint32_value;
  1519. else if (!os_strcmp(entry.key, "service") &&
  1520. entry.type == DBUS_TYPE_STRING)
  1521. service = os_strdup(entry.str_value);
  1522. wpa_dbus_dict_entry_clear(&entry);
  1523. }
  1524. if (version <= 0 || service == NULL)
  1525. goto error;
  1526. if (wpas_p2p_service_add_upnp(wpa_s, version, service) != 0)
  1527. goto error;
  1528. os_free(service);
  1529. } else if (bonjour == 1) {
  1530. while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
  1531. if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
  1532. goto error;
  1533. if (!os_strcmp(entry.key, "query")) {
  1534. if ((entry.type != DBUS_TYPE_ARRAY) ||
  1535. (entry.array_type != DBUS_TYPE_BYTE))
  1536. goto error_clear;
  1537. query = wpabuf_alloc_copy(
  1538. entry.bytearray_value,
  1539. entry.array_len);
  1540. } else if (!os_strcmp(entry.key, "response")) {
  1541. if ((entry.type != DBUS_TYPE_ARRAY) ||
  1542. (entry.array_type != DBUS_TYPE_BYTE))
  1543. goto error_clear;
  1544. resp = wpabuf_alloc_copy(entry.bytearray_value,
  1545. entry.array_len);
  1546. }
  1547. wpa_dbus_dict_entry_clear(&entry);
  1548. }
  1549. if (query == NULL || resp == NULL)
  1550. goto error;
  1551. if (wpas_p2p_service_add_bonjour(wpa_s, query, resp) < 0) {
  1552. wpabuf_free(query);
  1553. wpabuf_free(resp);
  1554. goto error;
  1555. }
  1556. } else
  1557. goto error;
  1558. return reply;
  1559. error_clear:
  1560. wpa_dbus_dict_entry_clear(&entry);
  1561. error:
  1562. return wpas_dbus_error_invalid_args(message, NULL);
  1563. }
  1564. DBusMessage * wpas_dbus_handler_p2p_delete_service(
  1565. DBusMessage *message, struct wpa_supplicant *wpa_s)
  1566. {
  1567. DBusMessageIter iter_dict;
  1568. DBusMessage *reply = NULL;
  1569. DBusMessageIter iter;
  1570. struct wpa_dbus_dict_entry entry;
  1571. int upnp = 0;
  1572. int bonjour = 0;
  1573. int ret = 0;
  1574. char *service = NULL;
  1575. struct wpabuf *query = NULL;
  1576. u8 version = 0;
  1577. dbus_message_iter_init(message, &iter);
  1578. if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
  1579. goto error;
  1580. if (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
  1581. if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
  1582. goto error;
  1583. if (!os_strcmp(entry.key, "service_type") &&
  1584. (entry.type == DBUS_TYPE_STRING)) {
  1585. if (!os_strcmp(entry.str_value, "upnp"))
  1586. upnp = 1;
  1587. else if (!os_strcmp(entry.str_value, "bonjour"))
  1588. bonjour = 1;
  1589. else
  1590. goto error_clear;
  1591. wpa_dbus_dict_entry_clear(&entry);
  1592. }
  1593. }
  1594. if (upnp == 1) {
  1595. while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
  1596. if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
  1597. goto error;
  1598. if (!os_strcmp(entry.key, "version") &&
  1599. entry.type == DBUS_TYPE_INT32)
  1600. version = entry.uint32_value;
  1601. else if (!os_strcmp(entry.key, "service") &&
  1602. entry.type == DBUS_TYPE_STRING)
  1603. service = os_strdup(entry.str_value);
  1604. else
  1605. goto error_clear;
  1606. wpa_dbus_dict_entry_clear(&entry);
  1607. }
  1608. if (version <= 0 || service == NULL)
  1609. goto error;
  1610. ret = wpas_p2p_service_del_upnp(wpa_s, version, service);
  1611. os_free(service);
  1612. if (ret != 0)
  1613. goto error;
  1614. } else if (bonjour == 1) {
  1615. while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
  1616. if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
  1617. goto error;
  1618. if (!os_strcmp(entry.key, "query")) {
  1619. if ((entry.type != DBUS_TYPE_ARRAY) ||
  1620. (entry.array_type != DBUS_TYPE_BYTE))
  1621. goto error_clear;
  1622. query = wpabuf_alloc_copy(
  1623. entry.bytearray_value,
  1624. entry.array_len);
  1625. } else
  1626. goto error_clear;
  1627. wpa_dbus_dict_entry_clear(&entry);
  1628. }
  1629. if (query == NULL)
  1630. goto error;
  1631. ret = wpas_p2p_service_del_bonjour(wpa_s, query);
  1632. if (ret != 0)
  1633. goto error;
  1634. wpabuf_free(query);
  1635. } else
  1636. goto error;
  1637. return reply;
  1638. error_clear:
  1639. wpa_dbus_dict_entry_clear(&entry);
  1640. error:
  1641. return wpas_dbus_error_invalid_args(message, NULL);
  1642. }
  1643. DBusMessage * wpas_dbus_handler_p2p_flush_service(DBusMessage *message,
  1644. struct wpa_supplicant *wpa_s)
  1645. {
  1646. wpas_p2p_service_flush(wpa_s);
  1647. return NULL;
  1648. }
  1649. DBusMessage * wpas_dbus_handler_p2p_service_sd_req(
  1650. DBusMessage *message, struct wpa_supplicant *wpa_s)
  1651. {
  1652. DBusMessageIter iter_dict;
  1653. DBusMessage *reply = NULL;
  1654. DBusMessageIter iter;
  1655. struct wpa_dbus_dict_entry entry;
  1656. int upnp = 0;
  1657. char *service = NULL;
  1658. char *peer_object_path = NULL;
  1659. struct wpabuf *tlv = NULL;
  1660. u8 version = 0;
  1661. u64 ref = 0;
  1662. u8 addr[ETH_ALEN];
  1663. dbus_message_iter_init(message, &iter);
  1664. if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
  1665. goto error;
  1666. while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
  1667. if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
  1668. goto error;
  1669. if (!os_strcmp(entry.key, "peer_object") &&
  1670. entry.type == DBUS_TYPE_OBJECT_PATH) {
  1671. peer_object_path = os_strdup(entry.str_value);
  1672. } else if (!os_strcmp(entry.key, "service_type") &&
  1673. entry.type == DBUS_TYPE_STRING) {
  1674. if (!os_strcmp(entry.str_value, "upnp"))
  1675. upnp = 1;
  1676. else
  1677. goto error_clear;
  1678. } else if (!os_strcmp(entry.key, "version") &&
  1679. entry.type == DBUS_TYPE_INT32) {
  1680. version = entry.uint32_value;
  1681. } else if (!os_strcmp(entry.key, "service") &&
  1682. entry.type == DBUS_TYPE_STRING) {
  1683. service = os_strdup(entry.str_value);
  1684. } else if (!os_strcmp(entry.key, "tlv")) {
  1685. if (entry.type != DBUS_TYPE_ARRAY ||
  1686. entry.array_type != DBUS_TYPE_BYTE)
  1687. goto error_clear;
  1688. tlv = wpabuf_alloc_copy(entry.bytearray_value,
  1689. entry.array_len);
  1690. } else
  1691. goto error_clear;
  1692. wpa_dbus_dict_entry_clear(&entry);
  1693. }
  1694. if (!peer_object_path ||
  1695. (parse_peer_object_path(peer_object_path, addr) < 0) ||
  1696. !p2p_peer_known(wpa_s->global->p2p, addr))
  1697. goto error;
  1698. if (upnp == 1) {
  1699. if (version <= 0 || service == NULL)
  1700. goto error;
  1701. ref = wpas_p2p_sd_request_upnp(wpa_s, addr, version, service);
  1702. } else {
  1703. if (tlv == NULL)
  1704. goto error;
  1705. ref = wpas_p2p_sd_request(wpa_s, addr, tlv);
  1706. wpabuf_free(tlv);
  1707. }
  1708. if (ref != 0) {
  1709. reply = dbus_message_new_method_return(message);
  1710. dbus_message_append_args(reply, DBUS_TYPE_UINT64,
  1711. &ref, DBUS_TYPE_INVALID);
  1712. } else {
  1713. reply = wpas_dbus_error_unknown_error(
  1714. message, "Unable to send SD request");
  1715. }
  1716. out:
  1717. os_free(service);
  1718. os_free(peer_object_path);
  1719. return reply;
  1720. error_clear:
  1721. wpa_dbus_dict_entry_clear(&entry);
  1722. error:
  1723. if (tlv)
  1724. wpabuf_free(tlv);
  1725. reply = wpas_dbus_error_invalid_args(message, NULL);
  1726. goto out;
  1727. }
  1728. DBusMessage * wpas_dbus_handler_p2p_service_sd_res(
  1729. DBusMessage *message, struct wpa_supplicant *wpa_s)
  1730. {
  1731. DBusMessageIter iter_dict;
  1732. DBusMessage *reply = NULL;
  1733. DBusMessageIter iter;
  1734. struct wpa_dbus_dict_entry entry;
  1735. char *peer_object_path = NULL;
  1736. struct wpabuf *tlv = NULL;
  1737. int freq = 0;
  1738. int dlg_tok = 0;
  1739. u8 addr[ETH_ALEN];
  1740. dbus_message_iter_init(message, &iter);
  1741. if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
  1742. goto error;
  1743. while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
  1744. if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
  1745. goto error;
  1746. if (!os_strcmp(entry.key, "peer_object") &&
  1747. entry.type == DBUS_TYPE_OBJECT_PATH) {
  1748. peer_object_path = os_strdup(entry.str_value);
  1749. } else if (!os_strcmp(entry.key, "frequency") &&
  1750. entry.type == DBUS_TYPE_INT32) {
  1751. freq = entry.uint32_value;
  1752. } else if (!os_strcmp(entry.key, "dialog_token") &&
  1753. entry.type == DBUS_TYPE_UINT32) {
  1754. dlg_tok = entry.uint32_value;
  1755. } else if (!os_strcmp(entry.key, "tlvs")) {
  1756. if (entry.type != DBUS_TYPE_ARRAY ||
  1757. entry.array_type != DBUS_TYPE_BYTE)
  1758. goto error_clear;
  1759. tlv = wpabuf_alloc_copy(entry.bytearray_value,
  1760. entry.array_len);
  1761. } else
  1762. goto error_clear;
  1763. wpa_dbus_dict_entry_clear(&entry);
  1764. }
  1765. if (!peer_object_path ||
  1766. (parse_peer_object_path(peer_object_path, addr) < 0) ||
  1767. !p2p_peer_known(wpa_s->global->p2p, addr))
  1768. goto error;
  1769. if (tlv == NULL)
  1770. goto error;
  1771. wpas_p2p_sd_response(wpa_s, freq, addr, (u8) dlg_tok, tlv);
  1772. wpabuf_free(tlv);
  1773. out:
  1774. os_free(peer_object_path);
  1775. return reply;
  1776. error_clear:
  1777. wpa_dbus_dict_entry_clear(&entry);
  1778. error:
  1779. reply = wpas_dbus_error_invalid_args(message, NULL);
  1780. goto out;
  1781. }
  1782. DBusMessage * wpas_dbus_handler_p2p_service_sd_cancel_req(
  1783. DBusMessage *message, struct wpa_supplicant *wpa_s)
  1784. {
  1785. DBusMessageIter iter;
  1786. u64 req = 0;
  1787. dbus_message_iter_init(message, &iter);
  1788. dbus_message_iter_get_basic(&iter, &req);
  1789. if (req == 0)
  1790. goto error;
  1791. if (!wpas_p2p_sd_cancel_request(wpa_s, req))
  1792. goto error;
  1793. return NULL;
  1794. error:
  1795. return wpas_dbus_error_invalid_args(message, NULL);
  1796. }
  1797. DBusMessage * wpas_dbus_handler_p2p_service_update(
  1798. DBusMessage *message, struct wpa_supplicant *wpa_s)
  1799. {
  1800. wpas_p2p_sd_service_update(wpa_s);
  1801. return NULL;
  1802. }
  1803. DBusMessage * wpas_dbus_handler_p2p_serv_disc_external(
  1804. DBusMessage *message, struct wpa_supplicant *wpa_s)
  1805. {
  1806. DBusMessageIter iter;
  1807. int ext = 0;
  1808. dbus_message_iter_init(message, &iter);
  1809. dbus_message_iter_get_basic(&iter, &ext);
  1810. wpa_s->p2p_sd_over_ctrl_iface = ext;
  1811. return NULL;
  1812. }