dbus_new_handlers_p2p.c 56 KB

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