dbus_new_handlers_p2p.c 71 KB

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