dbus_new_handlers_p2p.c 72 KB

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