dbus_new_handlers.c 87 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998299930003001300230033004300530063007300830093010301130123013301430153016301730183019302030213022302330243025302630273028302930303031303230333034303530363037303830393040304130423043304430453046304730483049305030513052305330543055305630573058305930603061306230633064306530663067306830693070307130723073307430753076307730783079308030813082308330843085308630873088308930903091309230933094309530963097309830993100310131023103310431053106310731083109311031113112311331143115311631173118311931203121312231233124312531263127312831293130313131323133313431353136313731383139314031413142314331443145314631473148314931503151315231533154315531563157315831593160316131623163316431653166316731683169317031713172317331743175317631773178317931803181318231833184318531863187318831893190319131923193319431953196319731983199320032013202320332043205320632073208320932103211321232133214321532163217321832193220322132223223322432253226322732283229323032313232323332343235
  1. /*
  2. * WPA Supplicant / dbus-based control interface
  3. * Copyright (c) 2006, Dan Williams <dcbw@redhat.com> and Red Hat, Inc.
  4. * Copyright (c) 2009-2010, Witold Sowa <witold.sowa@gmail.com>
  5. * Copyright (c) 2009, Jouni Malinen <j@w1.fi>
  6. *
  7. * This program is free software; you can redistribute it and/or modify
  8. * it under the terms of the GNU General Public License version 2 as
  9. * published by the Free Software Foundation.
  10. *
  11. * Alternatively, this software may be distributed under the terms of BSD
  12. * license.
  13. *
  14. * See README and COPYING for more details.
  15. */
  16. #include "includes.h"
  17. #include "common.h"
  18. #include "common/ieee802_11_defs.h"
  19. #include "eap_peer/eap_methods.h"
  20. #include "eapol_supp/eapol_supp_sm.h"
  21. #include "rsn_supp/wpa.h"
  22. #include "../config.h"
  23. #include "../wpa_supplicant_i.h"
  24. #include "../driver_i.h"
  25. #include "../notify.h"
  26. #include "../wpas_glue.h"
  27. #include "../bss.h"
  28. #include "../scan.h"
  29. #include "../ctrl_iface.h"
  30. #include "dbus_new_helpers.h"
  31. #include "dbus_new.h"
  32. #include "dbus_new_handlers.h"
  33. #include "dbus_dict_helpers.h"
  34. extern int wpa_debug_level;
  35. extern int wpa_debug_show_keys;
  36. extern int wpa_debug_timestamp;
  37. static const char *debug_strings[] = {
  38. "excessive", "msgdump", "debug", "info", "warning", "error", NULL
  39. };
  40. /**
  41. * wpas_dbus_error_unknown_error - Return a new InvalidArgs error message
  42. * @message: Pointer to incoming dbus message this error refers to
  43. * @arg: Optional string appended to error message
  44. * Returns: a dbus error message
  45. *
  46. * Convenience function to create and return an UnknownError
  47. */
  48. DBusMessage * wpas_dbus_error_unknown_error(DBusMessage *message,
  49. const char *arg)
  50. {
  51. /*
  52. * This function can be called as a result of a failure
  53. * within internal getter calls, which will call this function
  54. * with a NULL message parameter. However, dbus_message_new_error
  55. * looks very unkindly (i.e, abort()) on a NULL message, so
  56. * in this case, we should not call it.
  57. */
  58. if (message == NULL) {
  59. wpa_printf(MSG_INFO, "dbus: wpas_dbus_error_unknown_error "
  60. "called with NULL message (arg=%s)",
  61. arg ? arg : "N/A");
  62. return NULL;
  63. }
  64. return dbus_message_new_error(message, WPAS_DBUS_ERROR_UNKNOWN_ERROR,
  65. arg);
  66. }
  67. /**
  68. * wpas_dbus_error_iface_unknown - Return a new invalid interface error message
  69. * @message: Pointer to incoming dbus message this error refers to
  70. * Returns: A dbus error message
  71. *
  72. * Convenience function to create and return an invalid interface error
  73. */
  74. static DBusMessage * wpas_dbus_error_iface_unknown(DBusMessage *message)
  75. {
  76. return dbus_message_new_error(message, WPAS_DBUS_ERROR_IFACE_UNKNOWN,
  77. "wpa_supplicant knows nothing about "
  78. "this interface.");
  79. }
  80. /**
  81. * wpas_dbus_error_network_unknown - Return a new NetworkUnknown error message
  82. * @message: Pointer to incoming dbus message this error refers to
  83. * Returns: a dbus error message
  84. *
  85. * Convenience function to create and return an invalid network error
  86. */
  87. static DBusMessage * wpas_dbus_error_network_unknown(DBusMessage *message)
  88. {
  89. return dbus_message_new_error(message, WPAS_DBUS_ERROR_NETWORK_UNKNOWN,
  90. "There is no such a network in this "
  91. "interface.");
  92. }
  93. /**
  94. * wpas_dbus_error_invalid_args - Return a new InvalidArgs error message
  95. * @message: Pointer to incoming dbus message this error refers to
  96. * Returns: a dbus error message
  97. *
  98. * Convenience function to create and return an invalid options error
  99. */
  100. DBusMessage * wpas_dbus_error_invalid_args(DBusMessage *message,
  101. const char *arg)
  102. {
  103. DBusMessage *reply;
  104. reply = dbus_message_new_error(message, WPAS_DBUS_ERROR_INVALID_ARGS,
  105. "Did not receive correct message "
  106. "arguments.");
  107. if (arg != NULL)
  108. dbus_message_append_args(reply, DBUS_TYPE_STRING, &arg,
  109. DBUS_TYPE_INVALID);
  110. return reply;
  111. }
  112. static const char *dont_quote[] = {
  113. "key_mgmt", "proto", "pairwise", "auth_alg", "group", "eap",
  114. "opensc_engine_path", "pkcs11_engine_path", "pkcs11_module_path",
  115. "bssid", NULL
  116. };
  117. static dbus_bool_t should_quote_opt(const char *key)
  118. {
  119. int i = 0;
  120. while (dont_quote[i] != NULL) {
  121. if (os_strcmp(key, dont_quote[i]) == 0)
  122. return FALSE;
  123. i++;
  124. }
  125. return TRUE;
  126. }
  127. /**
  128. * get_iface_by_dbus_path - Get a new network interface
  129. * @global: Pointer to global data from wpa_supplicant_init()
  130. * @path: Pointer to a dbus object path representing an interface
  131. * Returns: Pointer to the interface or %NULL if not found
  132. */
  133. static struct wpa_supplicant * get_iface_by_dbus_path(
  134. struct wpa_global *global, const char *path)
  135. {
  136. struct wpa_supplicant *wpa_s;
  137. for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
  138. if (os_strcmp(wpa_s->dbus_new_path, path) == 0)
  139. return wpa_s;
  140. }
  141. return NULL;
  142. }
  143. /**
  144. * set_network_properties - Set properties of a configured network
  145. * @wpa_s: wpa_supplicant structure for a network interface
  146. * @ssid: wpa_ssid structure for a configured network
  147. * @iter: DBus message iterator containing dictionary of network
  148. * properties to set.
  149. * @error: On failure, an error describing the failure
  150. * Returns: TRUE if the request succeeds, FALSE if it failed
  151. *
  152. * Sets network configuration with parameters given id DBus dictionary
  153. */
  154. dbus_bool_t set_network_properties(struct wpa_supplicant *wpa_s,
  155. struct wpa_ssid *ssid,
  156. DBusMessageIter *iter,
  157. DBusError *error)
  158. {
  159. struct wpa_dbus_dict_entry entry = { .type = DBUS_TYPE_STRING };
  160. DBusMessageIter iter_dict;
  161. char *value = NULL;
  162. if (!wpa_dbus_dict_open_read(iter, &iter_dict, error))
  163. return FALSE;
  164. while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
  165. size_t size = 50;
  166. int ret;
  167. if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
  168. goto error;
  169. value = NULL;
  170. if (entry.type == DBUS_TYPE_ARRAY &&
  171. entry.array_type == DBUS_TYPE_BYTE) {
  172. if (entry.array_len <= 0)
  173. goto error;
  174. size = entry.array_len * 2 + 1;
  175. value = os_zalloc(size);
  176. if (value == NULL)
  177. goto error;
  178. ret = wpa_snprintf_hex(value, size,
  179. (u8 *) entry.bytearray_value,
  180. entry.array_len);
  181. if (ret <= 0)
  182. goto error;
  183. } else if (entry.type == DBUS_TYPE_STRING) {
  184. if (should_quote_opt(entry.key)) {
  185. size = os_strlen(entry.str_value);
  186. if (size <= 0)
  187. goto error;
  188. size += 3;
  189. value = os_zalloc(size);
  190. if (value == NULL)
  191. goto error;
  192. ret = os_snprintf(value, size, "\"%s\"",
  193. entry.str_value);
  194. if (ret < 0 || (size_t) ret != (size - 1))
  195. goto error;
  196. } else {
  197. value = os_strdup(entry.str_value);
  198. if (value == NULL)
  199. goto error;
  200. }
  201. } else if (entry.type == DBUS_TYPE_UINT32) {
  202. value = os_zalloc(size);
  203. if (value == NULL)
  204. goto error;
  205. ret = os_snprintf(value, size, "%u",
  206. entry.uint32_value);
  207. if (ret <= 0)
  208. goto error;
  209. } else if (entry.type == DBUS_TYPE_INT32) {
  210. value = os_zalloc(size);
  211. if (value == NULL)
  212. goto error;
  213. ret = os_snprintf(value, size, "%d",
  214. entry.int32_value);
  215. if (ret <= 0)
  216. goto error;
  217. } else
  218. goto error;
  219. if (wpa_config_set(ssid, entry.key, value, 0) < 0)
  220. goto error;
  221. if ((os_strcmp(entry.key, "psk") == 0 &&
  222. value[0] == '"' && ssid->ssid_len) ||
  223. (strcmp(entry.key, "ssid") == 0 && ssid->passphrase))
  224. wpa_config_update_psk(ssid);
  225. else if (os_strcmp(entry.key, "priority") == 0)
  226. wpa_config_update_prio_list(wpa_s->conf);
  227. os_free(value);
  228. wpa_dbus_dict_entry_clear(&entry);
  229. }
  230. return TRUE;
  231. error:
  232. os_free(value);
  233. wpa_dbus_dict_entry_clear(&entry);
  234. dbus_set_error_const(error, DBUS_ERROR_INVALID_ARGS,
  235. "invalid message format");
  236. return FALSE;
  237. }
  238. /**
  239. * wpas_dbus_simple_property_getter - Get basic type property
  240. * @iter: Message iter to use when appending arguments
  241. * @type: DBus type of property (must be basic type)
  242. * @val: pointer to place holding property value
  243. * @error: On failure an error describing the failure
  244. * Returns: TRUE if the request was successful, FALSE if it failed
  245. *
  246. * Generic getter for basic type properties. Type is required to be basic.
  247. */
  248. dbus_bool_t wpas_dbus_simple_property_getter(DBusMessageIter *iter,
  249. const int type,
  250. const void *val,
  251. DBusError *error)
  252. {
  253. DBusMessageIter variant_iter;
  254. if (!dbus_type_is_basic(type)) {
  255. dbus_set_error(error, DBUS_ERROR_FAILED,
  256. "%s: given type is not basic", __func__);
  257. return FALSE;
  258. }
  259. if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
  260. wpa_dbus_type_as_string(type),
  261. &variant_iter))
  262. goto error;
  263. if (!dbus_message_iter_append_basic(&variant_iter, type, val))
  264. goto error;
  265. if (!dbus_message_iter_close_container(iter, &variant_iter))
  266. goto error;
  267. return TRUE;
  268. error:
  269. dbus_set_error(error, DBUS_ERROR_FAILED,
  270. "%s: error constructing reply", __func__);
  271. return FALSE;
  272. }
  273. /**
  274. * wpas_dbus_simple_property_setter - Set basic type property
  275. * @message: Pointer to incoming dbus message
  276. * @type: DBus type of property (must be basic type)
  277. * @val: pointer to place where value being set will be stored
  278. * Returns: TRUE if the request was successful, FALSE if it failed
  279. *
  280. * Generic setter for basic type properties. Type is required to be basic.
  281. */
  282. dbus_bool_t wpas_dbus_simple_property_setter(DBusMessageIter *iter,
  283. DBusError *error,
  284. const int type, void *val)
  285. {
  286. DBusMessageIter variant_iter;
  287. if (!dbus_type_is_basic(type)) {
  288. dbus_set_error(error, DBUS_ERROR_FAILED,
  289. "%s: given type is not basic", __func__);
  290. return FALSE;
  291. }
  292. /* Look at the new value */
  293. dbus_message_iter_recurse(iter, &variant_iter);
  294. if (dbus_message_iter_get_arg_type(&variant_iter) != type) {
  295. dbus_set_error_const(error, DBUS_ERROR_FAILED,
  296. "wrong property type");
  297. return FALSE;
  298. }
  299. dbus_message_iter_get_basic(&variant_iter, val);
  300. return TRUE;
  301. }
  302. /**
  303. * wpas_dbus_simple_array_property_getter - Get array type property
  304. * @iter: Pointer to incoming dbus message iterator
  305. * @type: DBus type of property array elements (must be basic type)
  306. * @array: pointer to array of elements to put into response message
  307. * @array_len: length of above array
  308. * @error: a pointer to an error to fill on failure
  309. * Returns: TRUE if the request succeeded, FALSE if it failed
  310. *
  311. * Generic getter for array type properties. Array elements type is
  312. * required to be basic.
  313. */
  314. dbus_bool_t wpas_dbus_simple_array_property_getter(DBusMessageIter *iter,
  315. const int type,
  316. const void *array,
  317. size_t array_len,
  318. DBusError *error)
  319. {
  320. DBusMessageIter variant_iter, array_iter;
  321. char type_str[] = "a?"; /* ? will be replaced with subtype letter; */
  322. const char *sub_type_str;
  323. size_t element_size, i;
  324. if (!dbus_type_is_basic(type)) {
  325. dbus_set_error(error, DBUS_ERROR_FAILED,
  326. "%s: given type is not basic", __func__);
  327. return FALSE;
  328. }
  329. sub_type_str = wpa_dbus_type_as_string(type);
  330. type_str[1] = sub_type_str[0];
  331. if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
  332. type_str, &variant_iter)) {
  333. dbus_set_error(error, DBUS_ERROR_FAILED,
  334. "%s: failed to construct message 1", __func__);
  335. return FALSE;
  336. }
  337. if (!dbus_message_iter_open_container(&variant_iter, DBUS_TYPE_ARRAY,
  338. sub_type_str, &array_iter)) {
  339. dbus_set_error(error, DBUS_ERROR_FAILED,
  340. "%s: failed to construct message 2", __func__);
  341. return FALSE;
  342. }
  343. switch(type) {
  344. case DBUS_TYPE_BYTE:
  345. case DBUS_TYPE_BOOLEAN:
  346. element_size = 1;
  347. break;
  348. case DBUS_TYPE_INT16:
  349. case DBUS_TYPE_UINT16:
  350. element_size = sizeof(uint16_t);
  351. break;
  352. case DBUS_TYPE_INT32:
  353. case DBUS_TYPE_UINT32:
  354. element_size = sizeof(uint32_t);
  355. break;
  356. case DBUS_TYPE_INT64:
  357. case DBUS_TYPE_UINT64:
  358. element_size = sizeof(uint64_t);
  359. break;
  360. case DBUS_TYPE_DOUBLE:
  361. element_size = sizeof(double);
  362. break;
  363. case DBUS_TYPE_STRING:
  364. case DBUS_TYPE_OBJECT_PATH:
  365. element_size = sizeof(char *);
  366. break;
  367. default:
  368. dbus_set_error(error, DBUS_ERROR_FAILED,
  369. "%s: unknown element type %d", __func__, type);
  370. return FALSE;
  371. }
  372. for (i = 0; i < array_len; i++) {
  373. dbus_message_iter_append_basic(&array_iter, type,
  374. array + i * element_size);
  375. }
  376. if (!dbus_message_iter_close_container(&variant_iter, &array_iter)) {
  377. dbus_set_error(error, DBUS_ERROR_FAILED,
  378. "%s: failed to construct message 3", __func__);
  379. return FALSE;
  380. }
  381. if (!dbus_message_iter_close_container(iter, &variant_iter)) {
  382. dbus_set_error(error, DBUS_ERROR_FAILED,
  383. "%s: failed to construct message 4", __func__);
  384. return FALSE;
  385. }
  386. return TRUE;
  387. }
  388. /**
  389. * wpas_dbus_handler_create_interface - Request registration of a network iface
  390. * @message: Pointer to incoming dbus message
  391. * @global: %wpa_supplicant global data structure
  392. * Returns: The object path of the new interface object,
  393. * or a dbus error message with more information
  394. *
  395. * Handler function for "CreateInterface" method call. Handles requests
  396. * by dbus clients to register a network interface that wpa_supplicant
  397. * will manage.
  398. */
  399. DBusMessage * wpas_dbus_handler_create_interface(DBusMessage *message,
  400. struct wpa_global *global)
  401. {
  402. DBusMessageIter iter_dict;
  403. DBusMessage *reply = NULL;
  404. DBusMessageIter iter;
  405. struct wpa_dbus_dict_entry entry;
  406. char *driver = NULL;
  407. char *ifname = NULL;
  408. char *confname = NULL;
  409. char *bridge_ifname = NULL;
  410. dbus_message_iter_init(message, &iter);
  411. if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
  412. goto error;
  413. while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
  414. if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
  415. goto error;
  416. if (!strcmp(entry.key, "Driver") &&
  417. (entry.type == DBUS_TYPE_STRING)) {
  418. driver = os_strdup(entry.str_value);
  419. wpa_dbus_dict_entry_clear(&entry);
  420. if (driver == NULL)
  421. goto error;
  422. } else if (!strcmp(entry.key, "Ifname") &&
  423. (entry.type == DBUS_TYPE_STRING)) {
  424. ifname = os_strdup(entry.str_value);
  425. wpa_dbus_dict_entry_clear(&entry);
  426. if (ifname == NULL)
  427. goto error;
  428. } else if (!strcmp(entry.key, "ConfigFile") &&
  429. (entry.type == DBUS_TYPE_STRING)) {
  430. confname = os_strdup(entry.str_value);
  431. wpa_dbus_dict_entry_clear(&entry);
  432. if (confname == NULL)
  433. goto error;
  434. } else if (!strcmp(entry.key, "BridgeIfname") &&
  435. (entry.type == DBUS_TYPE_STRING)) {
  436. bridge_ifname = os_strdup(entry.str_value);
  437. wpa_dbus_dict_entry_clear(&entry);
  438. if (bridge_ifname == NULL)
  439. goto error;
  440. } else {
  441. wpa_dbus_dict_entry_clear(&entry);
  442. goto error;
  443. }
  444. }
  445. if (ifname == NULL)
  446. goto error; /* Required Ifname argument missing */
  447. /*
  448. * Try to get the wpa_supplicant record for this iface, return
  449. * an error if we already control it.
  450. */
  451. if (wpa_supplicant_get_iface(global, ifname) != NULL) {
  452. reply = dbus_message_new_error(message,
  453. WPAS_DBUS_ERROR_IFACE_EXISTS,
  454. "wpa_supplicant already "
  455. "controls this interface.");
  456. } else {
  457. struct wpa_supplicant *wpa_s;
  458. struct wpa_interface iface;
  459. os_memset(&iface, 0, sizeof(iface));
  460. iface.driver = driver;
  461. iface.ifname = ifname;
  462. iface.confname = confname;
  463. iface.bridge_ifname = bridge_ifname;
  464. /* Otherwise, have wpa_supplicant attach to it. */
  465. if ((wpa_s = wpa_supplicant_add_iface(global, &iface))) {
  466. const char *path = wpa_s->dbus_new_path;
  467. reply = dbus_message_new_method_return(message);
  468. dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH,
  469. &path, DBUS_TYPE_INVALID);
  470. } else {
  471. reply = wpas_dbus_error_unknown_error(
  472. message, "wpa_supplicant couldn't grab this "
  473. "interface.");
  474. }
  475. }
  476. out:
  477. os_free(driver);
  478. os_free(ifname);
  479. os_free(bridge_ifname);
  480. return reply;
  481. error:
  482. reply = wpas_dbus_error_invalid_args(message, NULL);
  483. goto out;
  484. }
  485. /**
  486. * wpas_dbus_handler_remove_interface - Request deregistration of an interface
  487. * @message: Pointer to incoming dbus message
  488. * @global: wpa_supplicant global data structure
  489. * Returns: a dbus message containing a UINT32 indicating success (1) or
  490. * failure (0), or returns a dbus error message with more information
  491. *
  492. * Handler function for "removeInterface" method call. Handles requests
  493. * by dbus clients to deregister a network interface that wpa_supplicant
  494. * currently manages.
  495. */
  496. DBusMessage * wpas_dbus_handler_remove_interface(DBusMessage *message,
  497. struct wpa_global *global)
  498. {
  499. struct wpa_supplicant *wpa_s;
  500. char *path;
  501. DBusMessage *reply = NULL;
  502. dbus_message_get_args(message, NULL, DBUS_TYPE_OBJECT_PATH, &path,
  503. DBUS_TYPE_INVALID);
  504. wpa_s = get_iface_by_dbus_path(global, path);
  505. if (wpa_s == NULL)
  506. reply = wpas_dbus_error_iface_unknown(message);
  507. else if (wpa_supplicant_remove_iface(global, wpa_s)) {
  508. reply = wpas_dbus_error_unknown_error(
  509. message, "wpa_supplicant couldn't remove this "
  510. "interface.");
  511. }
  512. return reply;
  513. }
  514. /**
  515. * wpas_dbus_handler_get_interface - Get the object path for an interface name
  516. * @message: Pointer to incoming dbus message
  517. * @global: %wpa_supplicant global data structure
  518. * Returns: The object path of the interface object,
  519. * or a dbus error message with more information
  520. *
  521. * Handler function for "getInterface" method call.
  522. */
  523. DBusMessage * wpas_dbus_handler_get_interface(DBusMessage *message,
  524. struct wpa_global *global)
  525. {
  526. DBusMessage *reply = NULL;
  527. const char *ifname;
  528. const char *path;
  529. struct wpa_supplicant *wpa_s;
  530. dbus_message_get_args(message, NULL, DBUS_TYPE_STRING, &ifname,
  531. DBUS_TYPE_INVALID);
  532. wpa_s = wpa_supplicant_get_iface(global, ifname);
  533. if (wpa_s == NULL)
  534. return wpas_dbus_error_iface_unknown(message);
  535. path = wpa_s->dbus_new_path;
  536. reply = dbus_message_new_method_return(message);
  537. if (reply == NULL)
  538. return dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
  539. NULL);
  540. if (!dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH, &path,
  541. DBUS_TYPE_INVALID)) {
  542. dbus_message_unref(reply);
  543. return dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
  544. NULL);
  545. }
  546. return reply;
  547. }
  548. /**
  549. * wpas_dbus_getter_debug_level - Get debug level
  550. * @iter: Pointer to incoming dbus message iter
  551. * @error: Location to store error on failure
  552. * @user_data: Function specific data
  553. * Returns: TRUE on success, FALSE on failure
  554. *
  555. * Getter for "DebugLevel" property.
  556. */
  557. dbus_bool_t wpas_dbus_getter_debug_level(DBusMessageIter *iter,
  558. DBusError *error,
  559. void *user_data)
  560. {
  561. const char *str;
  562. int idx = wpa_debug_level;
  563. if (idx < 0)
  564. idx = 0;
  565. if (idx > 5)
  566. idx = 5;
  567. str = debug_strings[idx];
  568. return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING,
  569. &str, error);
  570. }
  571. /**
  572. * wpas_dbus_getter_debug_timestamp - Get debug timestamp
  573. * @iter: Pointer to incoming dbus message iter
  574. * @error: Location to store error on failure
  575. * @user_data: Function specific data
  576. * Returns: TRUE on success, FALSE on failure
  577. *
  578. * Getter for "DebugTimestamp" property.
  579. */
  580. dbus_bool_t wpas_dbus_getter_debug_timestamp(DBusMessageIter *iter,
  581. DBusError *error,
  582. void *user_data)
  583. {
  584. return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_BOOLEAN,
  585. &wpa_debug_timestamp, error);
  586. }
  587. /**
  588. * wpas_dbus_getter_debug_show_keys - Get debug show keys
  589. * @iter: Pointer to incoming dbus message iter
  590. * @error: Location to store error on failure
  591. * @user_data: Function specific data
  592. * Returns: TRUE on success, FALSE on failure
  593. *
  594. * Getter for "DebugShowKeys" property.
  595. */
  596. dbus_bool_t wpas_dbus_getter_debug_show_keys(DBusMessageIter *iter,
  597. DBusError *error,
  598. void *user_data)
  599. {
  600. return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_BOOLEAN,
  601. &wpa_debug_show_keys, error);
  602. }
  603. /**
  604. * wpas_dbus_setter_debug_level - Set debug level
  605. * @iter: Pointer to incoming dbus message iter
  606. * @error: Location to store error on failure
  607. * @user_data: Function specific data
  608. * Returns: TRUE on success, FALSE on failure
  609. *
  610. * Setter for "DebugLevel" property.
  611. */
  612. dbus_bool_t wpas_dbus_setter_debug_level(DBusMessageIter *iter,
  613. DBusError *error, void *user_data)
  614. {
  615. struct wpa_global *global = user_data;
  616. const char *str = NULL;
  617. int i, val = -1;
  618. if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_STRING,
  619. &str))
  620. return FALSE;
  621. for (i = 0; debug_strings[i]; i++)
  622. if (os_strcmp(debug_strings[i], str) == 0) {
  623. val = i;
  624. break;
  625. }
  626. if (val < 0 ||
  627. wpa_supplicant_set_debug_params(global, val, wpa_debug_timestamp,
  628. wpa_debug_show_keys)) {
  629. dbus_set_error_const(error, DBUS_ERROR_FAILED, "wrong debug "
  630. "level value");
  631. return FALSE;
  632. }
  633. return TRUE;
  634. }
  635. /**
  636. * wpas_dbus_setter_debug_timestamp - Set debug timestamp
  637. * @iter: Pointer to incoming dbus message iter
  638. * @error: Location to store error on failure
  639. * @user_data: Function specific data
  640. * Returns: TRUE on success, FALSE on failure
  641. *
  642. * Setter for "DebugTimestamp" property.
  643. */
  644. dbus_bool_t wpas_dbus_setter_debug_timestamp(DBusMessageIter *iter,
  645. DBusError *error,
  646. void *user_data)
  647. {
  648. struct wpa_global *global = user_data;
  649. dbus_bool_t val;
  650. if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_BOOLEAN,
  651. &val))
  652. return FALSE;
  653. wpa_supplicant_set_debug_params(global, wpa_debug_level, val ? 1 : 0,
  654. wpa_debug_show_keys);
  655. return TRUE;
  656. }
  657. /**
  658. * wpas_dbus_setter_debug_show_keys - Set debug show keys
  659. * @iter: Pointer to incoming dbus message iter
  660. * @error: Location to store error on failure
  661. * @user_data: Function specific data
  662. * Returns: TRUE on success, FALSE on failure
  663. *
  664. * Setter for "DebugShowKeys" property.
  665. */
  666. dbus_bool_t wpas_dbus_setter_debug_show_keys(DBusMessageIter *iter,
  667. DBusError *error,
  668. void *user_data)
  669. {
  670. struct wpa_global *global = user_data;
  671. dbus_bool_t val;
  672. if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_BOOLEAN,
  673. &val))
  674. return FALSE;
  675. wpa_supplicant_set_debug_params(global, wpa_debug_level,
  676. wpa_debug_timestamp,
  677. val ? 1 : 0);
  678. return TRUE;
  679. }
  680. /**
  681. * wpas_dbus_getter_interfaces - Request registered interfaces list
  682. * @iter: Pointer to incoming dbus message iter
  683. * @error: Location to store error on failure
  684. * @user_data: Function specific data
  685. * Returns: TRUE on success, FALSE on failure
  686. *
  687. * Getter for "Interfaces" property. Handles requests
  688. * by dbus clients to return list of registered interfaces objects
  689. * paths
  690. */
  691. dbus_bool_t wpas_dbus_getter_interfaces(DBusMessageIter *iter,
  692. DBusError *error,
  693. void *user_data)
  694. {
  695. struct wpa_global *global = user_data;
  696. struct wpa_supplicant *wpa_s;
  697. const char **paths;
  698. unsigned int i = 0, num = 0;
  699. dbus_bool_t success;
  700. for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next)
  701. num++;
  702. paths = os_zalloc(num * sizeof(char*));
  703. if (!paths) {
  704. dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
  705. return FALSE;
  706. }
  707. for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next)
  708. paths[i++] = wpa_s->dbus_new_path;
  709. success = wpas_dbus_simple_array_property_getter(iter,
  710. DBUS_TYPE_OBJECT_PATH,
  711. paths, num, error);
  712. os_free(paths);
  713. return success;
  714. }
  715. /**
  716. * wpas_dbus_getter_eap_methods - Request supported EAP methods list
  717. * @iter: Pointer to incoming dbus message iter
  718. * @error: Location to store error on failure
  719. * @user_data: Function specific data
  720. * Returns: TRUE on success, FALSE on failure
  721. *
  722. * Getter for "EapMethods" property. Handles requests
  723. * by dbus clients to return list of strings with supported EAP methods
  724. */
  725. dbus_bool_t wpas_dbus_getter_eap_methods(DBusMessageIter *iter,
  726. DBusError *error, void *user_data)
  727. {
  728. char **eap_methods;
  729. size_t num_items = 0;
  730. dbus_bool_t success;
  731. eap_methods = eap_get_names_as_string_array(&num_items);
  732. if (!eap_methods) {
  733. dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
  734. return FALSE;
  735. }
  736. success = wpas_dbus_simple_array_property_getter(iter,
  737. DBUS_TYPE_STRING,
  738. eap_methods,
  739. num_items, error);
  740. while (num_items)
  741. os_free(eap_methods[--num_items]);
  742. os_free(eap_methods);
  743. return success;
  744. }
  745. static int wpas_dbus_get_scan_type(DBusMessage *message, DBusMessageIter *var,
  746. char **type, DBusMessage **reply)
  747. {
  748. if (dbus_message_iter_get_arg_type(var) != DBUS_TYPE_STRING) {
  749. wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: "
  750. "Type must be a string");
  751. *reply = wpas_dbus_error_invalid_args(
  752. message, "Wrong Type value type. String required");
  753. return -1;
  754. }
  755. dbus_message_iter_get_basic(var, type);
  756. return 0;
  757. }
  758. static int wpas_dbus_get_scan_ssids(DBusMessage *message, DBusMessageIter *var,
  759. struct wpa_driver_scan_params *params,
  760. DBusMessage **reply)
  761. {
  762. struct wpa_driver_scan_ssid *ssids = params->ssids;
  763. size_t ssids_num = 0;
  764. u8 *ssid;
  765. DBusMessageIter array_iter, sub_array_iter;
  766. char *val;
  767. int len;
  768. if (dbus_message_iter_get_arg_type(var) != DBUS_TYPE_ARRAY) {
  769. wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: ssids "
  770. "must be an array of arrays of bytes");
  771. *reply = wpas_dbus_error_invalid_args(
  772. message, "Wrong SSIDs value type. Array of arrays of "
  773. "bytes required");
  774. return -1;
  775. }
  776. dbus_message_iter_recurse(var, &array_iter);
  777. if (dbus_message_iter_get_arg_type(&array_iter) != DBUS_TYPE_ARRAY ||
  778. dbus_message_iter_get_element_type(&array_iter) != DBUS_TYPE_BYTE)
  779. {
  780. wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: ssids "
  781. "must be an array of arrays of bytes");
  782. *reply = wpas_dbus_error_invalid_args(
  783. message, "Wrong SSIDs value type. Array of arrays of "
  784. "bytes required");
  785. return -1;
  786. }
  787. while (dbus_message_iter_get_arg_type(&array_iter) == DBUS_TYPE_ARRAY)
  788. {
  789. if (ssids_num >= WPAS_MAX_SCAN_SSIDS) {
  790. wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: "
  791. "Too many ssids specified on scan dbus "
  792. "call");
  793. *reply = wpas_dbus_error_invalid_args(
  794. message, "Too many ssids specified. Specify "
  795. "at most four");
  796. return -1;
  797. }
  798. dbus_message_iter_recurse(&array_iter, &sub_array_iter);
  799. dbus_message_iter_get_fixed_array(&sub_array_iter, &val, &len);
  800. if (len != 0) {
  801. ssid = os_malloc(len);
  802. if (ssid == NULL) {
  803. wpa_printf(MSG_DEBUG,
  804. "wpas_dbus_handler_scan[dbus]: "
  805. "out of memory. Cannot allocate "
  806. "memory for SSID");
  807. *reply = dbus_message_new_error(
  808. message, DBUS_ERROR_NO_MEMORY, NULL);
  809. return -1;
  810. }
  811. os_memcpy(ssid, val, len);
  812. } else {
  813. /* Allow zero-length SSIDs */
  814. ssid = NULL;
  815. }
  816. ssids[ssids_num].ssid = ssid;
  817. ssids[ssids_num].ssid_len = len;
  818. dbus_message_iter_next(&array_iter);
  819. ssids_num++;
  820. }
  821. params->num_ssids = ssids_num;
  822. return 0;
  823. }
  824. static int wpas_dbus_get_scan_ies(DBusMessage *message, DBusMessageIter *var,
  825. struct wpa_driver_scan_params *params,
  826. DBusMessage **reply)
  827. {
  828. u8 *ies = NULL, *nies;
  829. int ies_len = 0;
  830. DBusMessageIter array_iter, sub_array_iter;
  831. char *val;
  832. int len;
  833. if (dbus_message_iter_get_arg_type(var) != DBUS_TYPE_ARRAY) {
  834. wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: ies must "
  835. "be an array of arrays of bytes");
  836. *reply = wpas_dbus_error_invalid_args(
  837. message, "Wrong IEs value type. Array of arrays of "
  838. "bytes required");
  839. return -1;
  840. }
  841. dbus_message_iter_recurse(var, &array_iter);
  842. if (dbus_message_iter_get_arg_type(&array_iter) != DBUS_TYPE_ARRAY ||
  843. dbus_message_iter_get_element_type(&array_iter) != DBUS_TYPE_BYTE)
  844. {
  845. wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: ies must "
  846. "be an array of arrays of bytes");
  847. *reply = wpas_dbus_error_invalid_args(
  848. message, "Wrong IEs value type. Array required");
  849. return -1;
  850. }
  851. while (dbus_message_iter_get_arg_type(&array_iter) == DBUS_TYPE_ARRAY)
  852. {
  853. dbus_message_iter_recurse(&array_iter, &sub_array_iter);
  854. dbus_message_iter_get_fixed_array(&sub_array_iter, &val, &len);
  855. if (len == 0) {
  856. dbus_message_iter_next(&array_iter);
  857. continue;
  858. }
  859. nies = os_realloc(ies, ies_len + len);
  860. if (nies == NULL) {
  861. wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: "
  862. "out of memory. Cannot allocate memory for "
  863. "IE");
  864. os_free(ies);
  865. *reply = dbus_message_new_error(
  866. message, DBUS_ERROR_NO_MEMORY, NULL);
  867. return -1;
  868. }
  869. ies = nies;
  870. os_memcpy(ies + ies_len, val, len);
  871. ies_len += len;
  872. dbus_message_iter_next(&array_iter);
  873. }
  874. params->extra_ies = ies;
  875. params->extra_ies_len = ies_len;
  876. return 0;
  877. }
  878. static int wpas_dbus_get_scan_channels(DBusMessage *message,
  879. DBusMessageIter *var,
  880. struct wpa_driver_scan_params *params,
  881. DBusMessage **reply)
  882. {
  883. DBusMessageIter array_iter, sub_array_iter;
  884. int *freqs = NULL, *nfreqs;
  885. int freqs_num = 0;
  886. if (dbus_message_iter_get_arg_type(var) != DBUS_TYPE_ARRAY) {
  887. wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: "
  888. "Channels must be an array of structs");
  889. *reply = wpas_dbus_error_invalid_args(
  890. message, "Wrong Channels value type. Array of structs "
  891. "required");
  892. return -1;
  893. }
  894. dbus_message_iter_recurse(var, &array_iter);
  895. if (dbus_message_iter_get_arg_type(&array_iter) != DBUS_TYPE_STRUCT) {
  896. wpa_printf(MSG_DEBUG,
  897. "wpas_dbus_handler_scan[dbus]: Channels must be an "
  898. "array of structs");
  899. *reply = wpas_dbus_error_invalid_args(
  900. message, "Wrong Channels value type. Array of structs "
  901. "required");
  902. return -1;
  903. }
  904. while (dbus_message_iter_get_arg_type(&array_iter) == DBUS_TYPE_STRUCT)
  905. {
  906. int freq, width;
  907. dbus_message_iter_recurse(&array_iter, &sub_array_iter);
  908. if (dbus_message_iter_get_arg_type(&sub_array_iter) !=
  909. DBUS_TYPE_UINT32) {
  910. wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: "
  911. "Channel must by specified by struct of "
  912. "two UINT32s %c",
  913. dbus_message_iter_get_arg_type(
  914. &sub_array_iter));
  915. *reply = wpas_dbus_error_invalid_args(
  916. message, "Wrong Channel struct. Two UINT32s "
  917. "required");
  918. os_free(freqs);
  919. return -1;
  920. }
  921. dbus_message_iter_get_basic(&sub_array_iter, &freq);
  922. if (!dbus_message_iter_next(&sub_array_iter) ||
  923. dbus_message_iter_get_arg_type(&sub_array_iter) !=
  924. DBUS_TYPE_UINT32) {
  925. wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: "
  926. "Channel must by specified by struct of "
  927. "two UINT32s");
  928. *reply = wpas_dbus_error_invalid_args(
  929. message,
  930. "Wrong Channel struct. Two UINT32s required");
  931. os_free(freqs);
  932. return -1;
  933. }
  934. dbus_message_iter_get_basic(&sub_array_iter, &width);
  935. #define FREQS_ALLOC_CHUNK 32
  936. if (freqs_num % FREQS_ALLOC_CHUNK == 0) {
  937. nfreqs = os_realloc(freqs, sizeof(int) *
  938. (freqs_num + FREQS_ALLOC_CHUNK));
  939. if (nfreqs == NULL)
  940. os_free(freqs);
  941. freqs = nfreqs;
  942. }
  943. if (freqs == NULL) {
  944. wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: "
  945. "out of memory. can't allocate memory for "
  946. "freqs");
  947. *reply = dbus_message_new_error(
  948. message, DBUS_ERROR_NO_MEMORY, NULL);
  949. return -1;
  950. }
  951. freqs[freqs_num] = freq;
  952. freqs_num++;
  953. dbus_message_iter_next(&array_iter);
  954. }
  955. nfreqs = os_realloc(freqs,
  956. sizeof(int) * (freqs_num + 1));
  957. if (nfreqs == NULL)
  958. os_free(freqs);
  959. freqs = nfreqs;
  960. if (freqs == NULL) {
  961. wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: "
  962. "out of memory. Can't allocate memory for freqs");
  963. *reply = dbus_message_new_error(
  964. message, DBUS_ERROR_NO_MEMORY, NULL);
  965. return -1;
  966. }
  967. freqs[freqs_num] = 0;
  968. params->freqs = freqs;
  969. return 0;
  970. }
  971. /**
  972. * wpas_dbus_handler_scan - Request a wireless scan on an interface
  973. * @message: Pointer to incoming dbus message
  974. * @wpa_s: wpa_supplicant structure for a network interface
  975. * Returns: NULL indicating success or DBus error message on failure
  976. *
  977. * Handler function for "Scan" method call of a network device. Requests
  978. * that wpa_supplicant perform a wireless scan as soon as possible
  979. * on a particular wireless interface.
  980. */
  981. DBusMessage * wpas_dbus_handler_scan(DBusMessage *message,
  982. struct wpa_supplicant *wpa_s)
  983. {
  984. DBusMessage *reply = NULL;
  985. DBusMessageIter iter, dict_iter, entry_iter, variant_iter;
  986. char *key = NULL, *type = NULL;
  987. struct wpa_driver_scan_params params;
  988. size_t i;
  989. os_memset(&params, 0, sizeof(params));
  990. dbus_message_iter_init(message, &iter);
  991. dbus_message_iter_recurse(&iter, &dict_iter);
  992. while (dbus_message_iter_get_arg_type(&dict_iter) ==
  993. DBUS_TYPE_DICT_ENTRY) {
  994. dbus_message_iter_recurse(&dict_iter, &entry_iter);
  995. dbus_message_iter_get_basic(&entry_iter, &key);
  996. dbus_message_iter_next(&entry_iter);
  997. dbus_message_iter_recurse(&entry_iter, &variant_iter);
  998. if (os_strcmp(key, "Type") == 0) {
  999. if (wpas_dbus_get_scan_type(message, &variant_iter,
  1000. &type, &reply) < 0)
  1001. goto out;
  1002. } else if (os_strcmp(key, "SSIDs") == 0) {
  1003. if (wpas_dbus_get_scan_ssids(message, &variant_iter,
  1004. &params, &reply) < 0)
  1005. goto out;
  1006. } else if (os_strcmp(key, "IEs") == 0) {
  1007. if (wpas_dbus_get_scan_ies(message, &variant_iter,
  1008. &params, &reply) < 0)
  1009. goto out;
  1010. } else if (os_strcmp(key, "Channels") == 0) {
  1011. if (wpas_dbus_get_scan_channels(message, &variant_iter,
  1012. &params, &reply) < 0)
  1013. goto out;
  1014. } else {
  1015. wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: "
  1016. "Unknown argument %s", key);
  1017. reply = wpas_dbus_error_invalid_args(message, key);
  1018. goto out;
  1019. }
  1020. dbus_message_iter_next(&dict_iter);
  1021. }
  1022. if (!type) {
  1023. wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: "
  1024. "Scan type not specified");
  1025. reply = wpas_dbus_error_invalid_args(message, key);
  1026. goto out;
  1027. }
  1028. if (!os_strcmp(type, "passive")) {
  1029. if (params.num_ssids || params.extra_ies_len) {
  1030. wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: "
  1031. "SSIDs or IEs specified for passive scan.");
  1032. reply = wpas_dbus_error_invalid_args(
  1033. message, "You can specify only Channels in "
  1034. "passive scan");
  1035. goto out;
  1036. } else if (params.freqs && params.freqs[0]) {
  1037. wpa_supplicant_trigger_scan(wpa_s, &params);
  1038. } else {
  1039. wpa_s->scan_req = 2;
  1040. wpa_supplicant_req_scan(wpa_s, 0, 0);
  1041. }
  1042. } else if (!os_strcmp(type, "active")) {
  1043. if (!params.num_ssids) {
  1044. /* Add wildcard ssid */
  1045. params.num_ssids++;
  1046. }
  1047. wpa_supplicant_trigger_scan(wpa_s, &params);
  1048. } else {
  1049. wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: "
  1050. "Unknown scan type: %s", type);
  1051. reply = wpas_dbus_error_invalid_args(message,
  1052. "Wrong scan type");
  1053. goto out;
  1054. }
  1055. out:
  1056. for (i = 0; i < WPAS_MAX_SCAN_SSIDS; i++)
  1057. os_free((u8 *) params.ssids[i].ssid);
  1058. os_free((u8 *) params.extra_ies);
  1059. os_free(params.freqs);
  1060. return reply;
  1061. }
  1062. /*
  1063. * wpas_dbus_handler_disconnect - Terminate the current connection
  1064. * @message: Pointer to incoming dbus message
  1065. * @wpa_s: wpa_supplicant structure for a network interface
  1066. * Returns: NotConnected DBus error message if already not connected
  1067. * or NULL otherwise.
  1068. *
  1069. * Handler function for "Disconnect" method call of network interface.
  1070. */
  1071. DBusMessage * wpas_dbus_handler_disconnect(DBusMessage *message,
  1072. struct wpa_supplicant *wpa_s)
  1073. {
  1074. if (wpa_s->current_ssid != NULL) {
  1075. wpa_s->disconnected = 1;
  1076. wpa_supplicant_deauthenticate(wpa_s,
  1077. WLAN_REASON_DEAUTH_LEAVING);
  1078. return NULL;
  1079. }
  1080. return dbus_message_new_error(message, WPAS_DBUS_ERROR_NOT_CONNECTED,
  1081. "This interface is not connected");
  1082. }
  1083. /**
  1084. * wpas_dbus_new_iface_add_network - Add a new configured network
  1085. * @message: Pointer to incoming dbus message
  1086. * @wpa_s: wpa_supplicant structure for a network interface
  1087. * Returns: A dbus message containing the object path of the new network
  1088. *
  1089. * Handler function for "AddNetwork" method call of a network interface.
  1090. */
  1091. DBusMessage * wpas_dbus_handler_add_network(DBusMessage *message,
  1092. struct wpa_supplicant *wpa_s)
  1093. {
  1094. DBusMessage *reply = NULL;
  1095. DBusMessageIter iter;
  1096. struct wpa_ssid *ssid = NULL;
  1097. char path_buf[WPAS_DBUS_OBJECT_PATH_MAX], *path = path_buf;
  1098. DBusError error;
  1099. dbus_message_iter_init(message, &iter);
  1100. ssid = wpa_config_add_network(wpa_s->conf);
  1101. if (ssid == NULL) {
  1102. wpa_printf(MSG_ERROR, "wpas_dbus_handler_add_network[dbus]: "
  1103. "can't add new interface.");
  1104. reply = wpas_dbus_error_unknown_error(
  1105. message,
  1106. "wpa_supplicant could not add "
  1107. "a network on this interface.");
  1108. goto err;
  1109. }
  1110. wpas_notify_network_added(wpa_s, ssid);
  1111. ssid->disabled = 1;
  1112. wpa_config_set_network_defaults(ssid);
  1113. dbus_error_init(&error);
  1114. if (!set_network_properties(wpa_s, ssid, &iter, &error)) {
  1115. wpa_printf(MSG_DEBUG, "wpas_dbus_handler_add_network[dbus]:"
  1116. "control interface couldn't set network "
  1117. "properties");
  1118. reply = wpas_dbus_reply_new_from_error(message, &error,
  1119. DBUS_ERROR_INVALID_ARGS,
  1120. "Failed to add network");
  1121. dbus_error_free(&error);
  1122. goto err;
  1123. }
  1124. /* Construct the object path for this network. */
  1125. os_snprintf(path, WPAS_DBUS_OBJECT_PATH_MAX,
  1126. "%s/" WPAS_DBUS_NEW_NETWORKS_PART "/%d",
  1127. wpa_s->dbus_new_path, ssid->id);
  1128. reply = dbus_message_new_method_return(message);
  1129. if (reply == NULL) {
  1130. reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
  1131. NULL);
  1132. goto err;
  1133. }
  1134. if (!dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH, &path,
  1135. DBUS_TYPE_INVALID)) {
  1136. dbus_message_unref(reply);
  1137. reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
  1138. NULL);
  1139. goto err;
  1140. }
  1141. return reply;
  1142. err:
  1143. if (ssid) {
  1144. wpas_notify_network_removed(wpa_s, ssid);
  1145. wpa_config_remove_network(wpa_s->conf, ssid->id);
  1146. }
  1147. return reply;
  1148. }
  1149. /**
  1150. * wpas_dbus_handler_remove_network - Remove a configured network
  1151. * @message: Pointer to incoming dbus message
  1152. * @wpa_s: wpa_supplicant structure for a network interface
  1153. * Returns: NULL on success or dbus error on failure
  1154. *
  1155. * Handler function for "RemoveNetwork" method call of a network interface.
  1156. */
  1157. DBusMessage * wpas_dbus_handler_remove_network(DBusMessage *message,
  1158. struct wpa_supplicant *wpa_s)
  1159. {
  1160. DBusMessage *reply = NULL;
  1161. const char *op;
  1162. char *iface = NULL, *net_id = NULL;
  1163. int id;
  1164. struct wpa_ssid *ssid;
  1165. dbus_message_get_args(message, NULL, DBUS_TYPE_OBJECT_PATH, &op,
  1166. DBUS_TYPE_INVALID);
  1167. /* Extract the network ID and ensure the network */
  1168. /* is actually a child of this interface */
  1169. iface = wpas_dbus_new_decompose_object_path(op, 0, &net_id, NULL);
  1170. if (iface == NULL || os_strcmp(iface, wpa_s->dbus_new_path) != 0) {
  1171. reply = wpas_dbus_error_invalid_args(message, op);
  1172. goto out;
  1173. }
  1174. id = strtoul(net_id, NULL, 10);
  1175. if (errno == EINVAL) {
  1176. reply = wpas_dbus_error_invalid_args(message, op);
  1177. goto out;
  1178. }
  1179. ssid = wpa_config_get_network(wpa_s->conf, id);
  1180. if (ssid == NULL) {
  1181. reply = wpas_dbus_error_network_unknown(message);
  1182. goto out;
  1183. }
  1184. wpas_notify_network_removed(wpa_s, ssid);
  1185. if (wpa_config_remove_network(wpa_s->conf, id) < 0) {
  1186. wpa_printf(MSG_ERROR,
  1187. "wpas_dbus_handler_remove_network[dbus]: "
  1188. "error occurred when removing network %d", id);
  1189. reply = wpas_dbus_error_unknown_error(
  1190. message, "error removing the specified network on "
  1191. "this interface.");
  1192. goto out;
  1193. }
  1194. if (ssid == wpa_s->current_ssid)
  1195. wpa_supplicant_deauthenticate(wpa_s,
  1196. WLAN_REASON_DEAUTH_LEAVING);
  1197. out:
  1198. os_free(iface);
  1199. os_free(net_id);
  1200. return reply;
  1201. }
  1202. static void remove_network(void *arg, struct wpa_ssid *ssid)
  1203. {
  1204. struct wpa_supplicant *wpa_s = arg;
  1205. wpas_notify_network_removed(wpa_s, ssid);
  1206. if (wpa_config_remove_network(wpa_s->conf, ssid->id) < 0) {
  1207. wpa_printf(MSG_ERROR,
  1208. "wpas_dbus_handler_remove_all_networks[dbus]: "
  1209. "error occurred when removing network %d",
  1210. ssid->id);
  1211. return;
  1212. }
  1213. if (ssid == wpa_s->current_ssid)
  1214. wpa_supplicant_disassociate(wpa_s, WLAN_REASON_DEAUTH_LEAVING);
  1215. }
  1216. /**
  1217. * wpas_dbus_handler_remove_all_networks - Remove all configured networks
  1218. * @message: Pointer to incoming dbus message
  1219. * @wpa_s: wpa_supplicant structure for a network interface
  1220. * Returns: NULL on success or dbus error on failure
  1221. *
  1222. * Handler function for "RemoveAllNetworks" method call of a network interface.
  1223. */
  1224. DBusMessage * wpas_dbus_handler_remove_all_networks(
  1225. DBusMessage *message, struct wpa_supplicant *wpa_s)
  1226. {
  1227. /* NB: could check for failure and return an error */
  1228. wpa_config_foreach_network(wpa_s->conf, remove_network, wpa_s);
  1229. return NULL;
  1230. }
  1231. /**
  1232. * wpas_dbus_handler_select_network - Attempt association with a network
  1233. * @message: Pointer to incoming dbus message
  1234. * @wpa_s: wpa_supplicant structure for a network interface
  1235. * Returns: NULL on success or dbus error on failure
  1236. *
  1237. * Handler function for "SelectNetwork" method call of network interface.
  1238. */
  1239. DBusMessage * wpas_dbus_handler_select_network(DBusMessage *message,
  1240. struct wpa_supplicant *wpa_s)
  1241. {
  1242. DBusMessage *reply = NULL;
  1243. const char *op;
  1244. char *iface = NULL, *net_id = NULL;
  1245. int id;
  1246. struct wpa_ssid *ssid;
  1247. dbus_message_get_args(message, NULL, DBUS_TYPE_OBJECT_PATH, &op,
  1248. DBUS_TYPE_INVALID);
  1249. /* Extract the network ID and ensure the network */
  1250. /* is actually a child of this interface */
  1251. iface = wpas_dbus_new_decompose_object_path(op, 0, &net_id, NULL);
  1252. if (iface == NULL || os_strcmp(iface, wpa_s->dbus_new_path) != 0) {
  1253. reply = wpas_dbus_error_invalid_args(message, op);
  1254. goto out;
  1255. }
  1256. id = strtoul(net_id, NULL, 10);
  1257. if (errno == EINVAL) {
  1258. reply = wpas_dbus_error_invalid_args(message, op);
  1259. goto out;
  1260. }
  1261. ssid = wpa_config_get_network(wpa_s->conf, id);
  1262. if (ssid == NULL) {
  1263. reply = wpas_dbus_error_network_unknown(message);
  1264. goto out;
  1265. }
  1266. /* Finally, associate with the network */
  1267. wpa_supplicant_select_network(wpa_s, ssid);
  1268. out:
  1269. os_free(iface);
  1270. os_free(net_id);
  1271. return reply;
  1272. }
  1273. /**
  1274. * wpas_dbus_handler_network_reply - Reply to a NetworkRequest signal
  1275. * @message: Pointer to incoming dbus message
  1276. * @wpa_s: wpa_supplicant structure for a network interface
  1277. * Returns: NULL on success or dbus error on failure
  1278. *
  1279. * Handler function for "NetworkReply" method call of network interface.
  1280. */
  1281. DBusMessage * wpas_dbus_handler_network_reply(DBusMessage *message,
  1282. struct wpa_supplicant *wpa_s)
  1283. {
  1284. #ifdef IEEE8021X_EAPOL
  1285. DBusMessage *reply = NULL;
  1286. const char *op, *field, *value;
  1287. char *iface = NULL, *net_id = NULL;
  1288. int id;
  1289. struct wpa_ssid *ssid;
  1290. if (!dbus_message_get_args(message, NULL,
  1291. DBUS_TYPE_OBJECT_PATH, &op,
  1292. DBUS_TYPE_STRING, &field,
  1293. DBUS_TYPE_STRING, &value,
  1294. DBUS_TYPE_INVALID))
  1295. return wpas_dbus_error_invalid_args(message, NULL);
  1296. /* Extract the network ID and ensure the network */
  1297. /* is actually a child of this interface */
  1298. iface = wpas_dbus_new_decompose_object_path(op, 0, &net_id, NULL);
  1299. if (iface == NULL || os_strcmp(iface, wpa_s->dbus_new_path) != 0) {
  1300. reply = wpas_dbus_error_invalid_args(message, op);
  1301. goto out;
  1302. }
  1303. id = strtoul(net_id, NULL, 10);
  1304. if (errno == EINVAL) {
  1305. reply = wpas_dbus_error_invalid_args(message, net_id);
  1306. goto out;
  1307. }
  1308. ssid = wpa_config_get_network(wpa_s->conf, id);
  1309. if (ssid == NULL) {
  1310. reply = wpas_dbus_error_network_unknown(message);
  1311. goto out;
  1312. }
  1313. if (wpa_supplicant_ctrl_iface_ctrl_rsp_handle(wpa_s, ssid,
  1314. field, value) < 0)
  1315. reply = wpas_dbus_error_invalid_args(message, field);
  1316. else {
  1317. /* Tell EAP to retry immediately */
  1318. eapol_sm_notify_ctrl_response(wpa_s->eapol);
  1319. }
  1320. out:
  1321. os_free(iface);
  1322. os_free(net_id);
  1323. return reply;
  1324. #else /* IEEE8021X_EAPOL */
  1325. wpa_printf(MSG_DEBUG, "CTRL_IFACE: 802.1X not included");
  1326. return wpas_dbus_error_unknown_error(message, "802.1X not included");
  1327. #endif /* IEEE8021X_EAPOL */
  1328. }
  1329. /**
  1330. * wpas_dbus_handler_add_blob - Store named binary blob (ie, for certificates)
  1331. * @message: Pointer to incoming dbus message
  1332. * @wpa_s: %wpa_supplicant data structure
  1333. * Returns: A dbus message containing an error on failure or NULL on success
  1334. *
  1335. * Asks wpa_supplicant to internally store a binary blobs.
  1336. */
  1337. DBusMessage * wpas_dbus_handler_add_blob(DBusMessage *message,
  1338. struct wpa_supplicant *wpa_s)
  1339. {
  1340. DBusMessage *reply = NULL;
  1341. DBusMessageIter iter, array_iter;
  1342. char *blob_name;
  1343. u8 *blob_data;
  1344. int blob_len;
  1345. struct wpa_config_blob *blob = NULL;
  1346. dbus_message_iter_init(message, &iter);
  1347. dbus_message_iter_get_basic(&iter, &blob_name);
  1348. if (wpa_config_get_blob(wpa_s->conf, blob_name)) {
  1349. return dbus_message_new_error(message,
  1350. WPAS_DBUS_ERROR_BLOB_EXISTS,
  1351. NULL);
  1352. }
  1353. dbus_message_iter_next(&iter);
  1354. dbus_message_iter_recurse(&iter, &array_iter);
  1355. dbus_message_iter_get_fixed_array(&array_iter, &blob_data, &blob_len);
  1356. blob = os_zalloc(sizeof(*blob));
  1357. if (!blob) {
  1358. reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
  1359. NULL);
  1360. goto err;
  1361. }
  1362. blob->data = os_malloc(blob_len);
  1363. if (!blob->data) {
  1364. reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
  1365. NULL);
  1366. goto err;
  1367. }
  1368. os_memcpy(blob->data, blob_data, blob_len);
  1369. blob->len = blob_len;
  1370. blob->name = os_strdup(blob_name);
  1371. if (!blob->name) {
  1372. reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
  1373. NULL);
  1374. goto err;
  1375. }
  1376. wpa_config_set_blob(wpa_s->conf, blob);
  1377. wpas_notify_blob_added(wpa_s, blob->name);
  1378. return reply;
  1379. err:
  1380. if (blob) {
  1381. os_free(blob->name);
  1382. os_free(blob->data);
  1383. os_free(blob);
  1384. }
  1385. return reply;
  1386. }
  1387. /**
  1388. * wpas_dbus_handler_get_blob - Get named binary blob (ie, for certificates)
  1389. * @message: Pointer to incoming dbus message
  1390. * @wpa_s: %wpa_supplicant data structure
  1391. * Returns: A dbus message containing array of bytes (blob)
  1392. *
  1393. * Gets one wpa_supplicant's binary blobs.
  1394. */
  1395. DBusMessage * wpas_dbus_handler_get_blob(DBusMessage *message,
  1396. struct wpa_supplicant *wpa_s)
  1397. {
  1398. DBusMessage *reply = NULL;
  1399. DBusMessageIter iter, array_iter;
  1400. char *blob_name;
  1401. const struct wpa_config_blob *blob;
  1402. dbus_message_get_args(message, NULL, DBUS_TYPE_STRING, &blob_name,
  1403. DBUS_TYPE_INVALID);
  1404. blob = wpa_config_get_blob(wpa_s->conf, blob_name);
  1405. if (!blob) {
  1406. return dbus_message_new_error(message,
  1407. WPAS_DBUS_ERROR_BLOB_UNKNOWN,
  1408. "Blob id not set");
  1409. }
  1410. reply = dbus_message_new_method_return(message);
  1411. if (!reply) {
  1412. reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
  1413. NULL);
  1414. goto out;
  1415. }
  1416. dbus_message_iter_init_append(reply, &iter);
  1417. if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
  1418. DBUS_TYPE_BYTE_AS_STRING,
  1419. &array_iter)) {
  1420. dbus_message_unref(reply);
  1421. reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
  1422. NULL);
  1423. goto out;
  1424. }
  1425. if (!dbus_message_iter_append_fixed_array(&array_iter, DBUS_TYPE_BYTE,
  1426. &(blob->data), blob->len)) {
  1427. dbus_message_unref(reply);
  1428. reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
  1429. NULL);
  1430. goto out;
  1431. }
  1432. if (!dbus_message_iter_close_container(&iter, &array_iter)) {
  1433. dbus_message_unref(reply);
  1434. reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
  1435. NULL);
  1436. goto out;
  1437. }
  1438. out:
  1439. return reply;
  1440. }
  1441. /**
  1442. * wpas_remove_handler_remove_blob - Remove named binary blob
  1443. * @message: Pointer to incoming dbus message
  1444. * @wpa_s: %wpa_supplicant data structure
  1445. * Returns: NULL on success or dbus error
  1446. *
  1447. * Asks wpa_supplicant to internally remove a binary blobs.
  1448. */
  1449. DBusMessage * wpas_dbus_handler_remove_blob(DBusMessage *message,
  1450. struct wpa_supplicant *wpa_s)
  1451. {
  1452. DBusMessage *reply = NULL;
  1453. char *blob_name;
  1454. dbus_message_get_args(message, NULL, DBUS_TYPE_STRING, &blob_name,
  1455. DBUS_TYPE_INVALID);
  1456. if (wpa_config_remove_blob(wpa_s->conf, blob_name)) {
  1457. return dbus_message_new_error(message,
  1458. WPAS_DBUS_ERROR_BLOB_UNKNOWN,
  1459. "Blob id not set");
  1460. }
  1461. wpas_notify_blob_removed(wpa_s, blob_name);
  1462. return reply;
  1463. }
  1464. /*
  1465. * wpas_dbus_handler_flush_bss - Flush the BSS cache
  1466. * @message: Pointer to incoming dbus message
  1467. * @wpa_s: wpa_supplicant structure for a network interface
  1468. * Returns: NULL
  1469. *
  1470. * Handler function for "FlushBSS" method call of network interface.
  1471. */
  1472. DBusMessage * wpas_dbus_handler_flush_bss(DBusMessage *message,
  1473. struct wpa_supplicant *wpa_s)
  1474. {
  1475. dbus_uint32_t age;
  1476. dbus_message_get_args(message, NULL, DBUS_TYPE_UINT32, &age,
  1477. DBUS_TYPE_INVALID);
  1478. if (age == 0)
  1479. wpa_bss_flush(wpa_s);
  1480. else
  1481. wpa_bss_flush_by_age(wpa_s, age);
  1482. return NULL;
  1483. }
  1484. /**
  1485. * wpas_dbus_getter_capabilities - Return interface capabilities
  1486. * @iter: Pointer to incoming dbus message iter
  1487. * @error: Location to store error on failure
  1488. * @user_data: Function specific data
  1489. * Returns: TRUE on success, FALSE on failure
  1490. *
  1491. * Getter for "Capabilities" property of an interface.
  1492. */
  1493. dbus_bool_t wpas_dbus_getter_capabilities(DBusMessageIter *iter,
  1494. DBusError *error, void *user_data)
  1495. {
  1496. struct wpa_supplicant *wpa_s = user_data;
  1497. struct wpa_driver_capa capa;
  1498. int res;
  1499. DBusMessageIter iter_dict, iter_dict_entry, iter_dict_val, iter_array,
  1500. variant_iter;
  1501. const char *scans[] = { "active", "passive", "ssid" };
  1502. if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
  1503. "a{sv}", &variant_iter))
  1504. goto nomem;
  1505. if (!wpa_dbus_dict_open_write(&variant_iter, &iter_dict))
  1506. goto nomem;
  1507. res = wpa_drv_get_capa(wpa_s, &capa);
  1508. /***** pairwise cipher */
  1509. if (res < 0) {
  1510. const char *args[] = {"ccmp", "tkip", "none"};
  1511. if (!wpa_dbus_dict_append_string_array(
  1512. &iter_dict, "Pairwise", args,
  1513. sizeof(args) / sizeof(char*)))
  1514. goto nomem;
  1515. } else {
  1516. if (!wpa_dbus_dict_begin_string_array(&iter_dict, "Pairwise",
  1517. &iter_dict_entry,
  1518. &iter_dict_val,
  1519. &iter_array))
  1520. goto nomem;
  1521. if (capa.enc & WPA_DRIVER_CAPA_ENC_CCMP) {
  1522. if (!wpa_dbus_dict_string_array_add_element(
  1523. &iter_array, "ccmp"))
  1524. goto nomem;
  1525. }
  1526. if (capa.enc & WPA_DRIVER_CAPA_ENC_TKIP) {
  1527. if (!wpa_dbus_dict_string_array_add_element(
  1528. &iter_array, "tkip"))
  1529. goto nomem;
  1530. }
  1531. if (capa.key_mgmt & WPA_DRIVER_CAPA_KEY_MGMT_WPA_NONE) {
  1532. if (!wpa_dbus_dict_string_array_add_element(
  1533. &iter_array, "none"))
  1534. goto nomem;
  1535. }
  1536. if (!wpa_dbus_dict_end_string_array(&iter_dict,
  1537. &iter_dict_entry,
  1538. &iter_dict_val,
  1539. &iter_array))
  1540. goto nomem;
  1541. }
  1542. /***** group cipher */
  1543. if (res < 0) {
  1544. const char *args[] = {
  1545. "ccmp", "tkip", "wep104", "wep40"
  1546. };
  1547. if (!wpa_dbus_dict_append_string_array(
  1548. &iter_dict, "Group", args,
  1549. sizeof(args) / sizeof(char*)))
  1550. goto nomem;
  1551. } else {
  1552. if (!wpa_dbus_dict_begin_string_array(&iter_dict, "Group",
  1553. &iter_dict_entry,
  1554. &iter_dict_val,
  1555. &iter_array))
  1556. goto nomem;
  1557. if (capa.enc & WPA_DRIVER_CAPA_ENC_CCMP) {
  1558. if (!wpa_dbus_dict_string_array_add_element(
  1559. &iter_array, "ccmp"))
  1560. goto nomem;
  1561. }
  1562. if (capa.enc & WPA_DRIVER_CAPA_ENC_TKIP) {
  1563. if (!wpa_dbus_dict_string_array_add_element(
  1564. &iter_array, "tkip"))
  1565. goto nomem;
  1566. }
  1567. if (capa.enc & WPA_DRIVER_CAPA_ENC_WEP104) {
  1568. if (!wpa_dbus_dict_string_array_add_element(
  1569. &iter_array, "wep104"))
  1570. goto nomem;
  1571. }
  1572. if (capa.enc & WPA_DRIVER_CAPA_ENC_WEP40) {
  1573. if (!wpa_dbus_dict_string_array_add_element(
  1574. &iter_array, "wep40"))
  1575. goto nomem;
  1576. }
  1577. if (!wpa_dbus_dict_end_string_array(&iter_dict,
  1578. &iter_dict_entry,
  1579. &iter_dict_val,
  1580. &iter_array))
  1581. goto nomem;
  1582. }
  1583. /***** key management */
  1584. if (res < 0) {
  1585. const char *args[] = {
  1586. "wpa-psk", "wpa-eap", "ieee8021x", "wpa-none",
  1587. #ifdef CONFIG_WPS
  1588. "wps",
  1589. #endif /* CONFIG_WPS */
  1590. "none"
  1591. };
  1592. if (!wpa_dbus_dict_append_string_array(
  1593. &iter_dict, "KeyMgmt", args,
  1594. sizeof(args) / sizeof(char*)))
  1595. goto nomem;
  1596. } else {
  1597. if (!wpa_dbus_dict_begin_string_array(&iter_dict, "KeyMgmt",
  1598. &iter_dict_entry,
  1599. &iter_dict_val,
  1600. &iter_array))
  1601. goto nomem;
  1602. if (!wpa_dbus_dict_string_array_add_element(&iter_array,
  1603. "none"))
  1604. goto nomem;
  1605. if (!wpa_dbus_dict_string_array_add_element(&iter_array,
  1606. "ieee8021x"))
  1607. goto nomem;
  1608. if (capa.key_mgmt & (WPA_DRIVER_CAPA_KEY_MGMT_WPA |
  1609. WPA_DRIVER_CAPA_KEY_MGMT_WPA2)) {
  1610. if (!wpa_dbus_dict_string_array_add_element(
  1611. &iter_array, "wpa-eap"))
  1612. goto nomem;
  1613. if (capa.key_mgmt & WPA_DRIVER_CAPA_KEY_MGMT_FT)
  1614. if (!wpa_dbus_dict_string_array_add_element(
  1615. &iter_array, "wpa-ft-eap"))
  1616. goto nomem;
  1617. /* TODO: Ensure that driver actually supports sha256 encryption. */
  1618. #ifdef CONFIG_IEEE80211W
  1619. if (!wpa_dbus_dict_string_array_add_element(
  1620. &iter_array, "wpa-eap-sha256"))
  1621. goto nomem;
  1622. #endif /* CONFIG_IEEE80211W */
  1623. }
  1624. if (capa.key_mgmt & (WPA_DRIVER_CAPA_KEY_MGMT_WPA_PSK |
  1625. WPA_DRIVER_CAPA_KEY_MGMT_WPA2_PSK)) {
  1626. if (!wpa_dbus_dict_string_array_add_element(
  1627. &iter_array, "wpa-psk"))
  1628. goto nomem;
  1629. if (capa.key_mgmt & WPA_DRIVER_CAPA_KEY_MGMT_FT_PSK)
  1630. if (!wpa_dbus_dict_string_array_add_element(
  1631. &iter_array, "wpa-ft-psk"))
  1632. goto nomem;
  1633. /* TODO: Ensure that driver actually supports sha256 encryption. */
  1634. #ifdef CONFIG_IEEE80211W
  1635. if (!wpa_dbus_dict_string_array_add_element(
  1636. &iter_array, "wpa-psk-sha256"))
  1637. goto nomem;
  1638. #endif /* CONFIG_IEEE80211W */
  1639. }
  1640. if (capa.key_mgmt & WPA_DRIVER_CAPA_KEY_MGMT_WPA_NONE) {
  1641. if (!wpa_dbus_dict_string_array_add_element(
  1642. &iter_array, "wpa-none"))
  1643. goto nomem;
  1644. }
  1645. #ifdef CONFIG_WPS
  1646. if (!wpa_dbus_dict_string_array_add_element(&iter_array,
  1647. "wps"))
  1648. goto nomem;
  1649. #endif /* CONFIG_WPS */
  1650. if (!wpa_dbus_dict_end_string_array(&iter_dict,
  1651. &iter_dict_entry,
  1652. &iter_dict_val,
  1653. &iter_array))
  1654. goto nomem;
  1655. }
  1656. /***** WPA protocol */
  1657. if (res < 0) {
  1658. const char *args[] = { "rsn", "wpa" };
  1659. if (!wpa_dbus_dict_append_string_array(
  1660. &iter_dict, "Protocol", args,
  1661. sizeof(args) / sizeof(char*)))
  1662. goto nomem;
  1663. } else {
  1664. if (!wpa_dbus_dict_begin_string_array(&iter_dict, "Protocol",
  1665. &iter_dict_entry,
  1666. &iter_dict_val,
  1667. &iter_array))
  1668. goto nomem;
  1669. if (capa.key_mgmt & (WPA_DRIVER_CAPA_KEY_MGMT_WPA2 |
  1670. WPA_DRIVER_CAPA_KEY_MGMT_WPA2_PSK)) {
  1671. if (!wpa_dbus_dict_string_array_add_element(
  1672. &iter_array, "rsn"))
  1673. goto nomem;
  1674. }
  1675. if (capa.key_mgmt & (WPA_DRIVER_CAPA_KEY_MGMT_WPA |
  1676. WPA_DRIVER_CAPA_KEY_MGMT_WPA_PSK)) {
  1677. if (!wpa_dbus_dict_string_array_add_element(
  1678. &iter_array, "wpa"))
  1679. goto nomem;
  1680. }
  1681. if (!wpa_dbus_dict_end_string_array(&iter_dict,
  1682. &iter_dict_entry,
  1683. &iter_dict_val,
  1684. &iter_array))
  1685. goto nomem;
  1686. }
  1687. /***** auth alg */
  1688. if (res < 0) {
  1689. const char *args[] = { "open", "shared", "leap" };
  1690. if (!wpa_dbus_dict_append_string_array(
  1691. &iter_dict, "AuthAlg", args,
  1692. sizeof(args) / sizeof(char*)))
  1693. goto nomem;
  1694. } else {
  1695. if (!wpa_dbus_dict_begin_string_array(&iter_dict, "AuthAlg",
  1696. &iter_dict_entry,
  1697. &iter_dict_val,
  1698. &iter_array))
  1699. goto nomem;
  1700. if (capa.auth & (WPA_DRIVER_AUTH_OPEN)) {
  1701. if (!wpa_dbus_dict_string_array_add_element(
  1702. &iter_array, "open"))
  1703. goto nomem;
  1704. }
  1705. if (capa.auth & (WPA_DRIVER_AUTH_SHARED)) {
  1706. if (!wpa_dbus_dict_string_array_add_element(
  1707. &iter_array, "shared"))
  1708. goto nomem;
  1709. }
  1710. if (capa.auth & (WPA_DRIVER_AUTH_LEAP)) {
  1711. if (!wpa_dbus_dict_string_array_add_element(
  1712. &iter_array, "leap"))
  1713. goto nomem;
  1714. }
  1715. if (!wpa_dbus_dict_end_string_array(&iter_dict,
  1716. &iter_dict_entry,
  1717. &iter_dict_val,
  1718. &iter_array))
  1719. goto nomem;
  1720. }
  1721. /***** Scan */
  1722. if (!wpa_dbus_dict_append_string_array(&iter_dict, "Scan", scans,
  1723. sizeof(scans) / sizeof(char *)))
  1724. goto nomem;
  1725. /***** Modes */
  1726. if (!wpa_dbus_dict_begin_string_array(&iter_dict, "Modes",
  1727. &iter_dict_entry,
  1728. &iter_dict_val,
  1729. &iter_array))
  1730. goto nomem;
  1731. if (!wpa_dbus_dict_string_array_add_element(
  1732. &iter_array, "infrastructure"))
  1733. goto nomem;
  1734. if (!wpa_dbus_dict_string_array_add_element(
  1735. &iter_array, "ad-hoc"))
  1736. goto nomem;
  1737. if (res >= 0) {
  1738. if (capa.flags & (WPA_DRIVER_FLAGS_AP)) {
  1739. if (!wpa_dbus_dict_string_array_add_element(
  1740. &iter_array, "ap"))
  1741. goto nomem;
  1742. }
  1743. if (capa.flags & (WPA_DRIVER_FLAGS_P2P_CAPABLE)) {
  1744. if (!wpa_dbus_dict_string_array_add_element(
  1745. &iter_array, "p2p"))
  1746. goto nomem;
  1747. }
  1748. }
  1749. if (!wpa_dbus_dict_end_string_array(&iter_dict,
  1750. &iter_dict_entry,
  1751. &iter_dict_val,
  1752. &iter_array))
  1753. goto nomem;
  1754. /***** Modes end */
  1755. if (res >= 0) {
  1756. dbus_int32_t max_scan_ssid = capa.max_scan_ssids;
  1757. if (!wpa_dbus_dict_append_int32(&iter_dict, "MaxScanSSID",
  1758. max_scan_ssid))
  1759. goto nomem;
  1760. }
  1761. if (!wpa_dbus_dict_close_write(&variant_iter, &iter_dict))
  1762. goto nomem;
  1763. if (!dbus_message_iter_close_container(iter, &variant_iter))
  1764. goto nomem;
  1765. return TRUE;
  1766. nomem:
  1767. dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
  1768. return FALSE;
  1769. }
  1770. /**
  1771. * wpas_dbus_getter_state - Get interface state
  1772. * @iter: Pointer to incoming dbus message iter
  1773. * @error: Location to store error on failure
  1774. * @user_data: Function specific data
  1775. * Returns: TRUE on success, FALSE on failure
  1776. *
  1777. * Getter for "State" property.
  1778. */
  1779. dbus_bool_t wpas_dbus_getter_state(DBusMessageIter *iter, DBusError *error,
  1780. void *user_data)
  1781. {
  1782. struct wpa_supplicant *wpa_s = user_data;
  1783. const char *str_state;
  1784. char *state_ls, *tmp;
  1785. dbus_bool_t success = FALSE;
  1786. str_state = wpa_supplicant_state_txt(wpa_s->wpa_state);
  1787. /* make state string lowercase to fit new DBus API convention
  1788. */
  1789. state_ls = tmp = os_strdup(str_state);
  1790. if (!tmp) {
  1791. dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
  1792. return FALSE;
  1793. }
  1794. while (*tmp) {
  1795. *tmp = tolower(*tmp);
  1796. tmp++;
  1797. }
  1798. success = wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING,
  1799. &state_ls, error);
  1800. os_free(state_ls);
  1801. return success;
  1802. }
  1803. /**
  1804. * wpas_dbus_new_iface_get_scanning - Get interface scanning state
  1805. * @iter: Pointer to incoming dbus message iter
  1806. * @error: Location to store error on failure
  1807. * @user_data: Function specific data
  1808. * Returns: TRUE on success, FALSE on failure
  1809. *
  1810. * Getter for "scanning" property.
  1811. */
  1812. dbus_bool_t wpas_dbus_getter_scanning(DBusMessageIter *iter, DBusError *error,
  1813. void *user_data)
  1814. {
  1815. struct wpa_supplicant *wpa_s = user_data;
  1816. dbus_bool_t scanning = wpa_s->scanning ? TRUE : FALSE;
  1817. return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_BOOLEAN,
  1818. &scanning, error);
  1819. }
  1820. /**
  1821. * wpas_dbus_getter_ap_scan - Control roaming mode
  1822. * @iter: Pointer to incoming dbus message iter
  1823. * @error: Location to store error on failure
  1824. * @user_data: Function specific data
  1825. * Returns: TRUE on success, FALSE on failure
  1826. *
  1827. * Getter function for "ApScan" property.
  1828. */
  1829. dbus_bool_t wpas_dbus_getter_ap_scan(DBusMessageIter *iter, DBusError *error,
  1830. void *user_data)
  1831. {
  1832. struct wpa_supplicant *wpa_s = user_data;
  1833. dbus_uint32_t ap_scan = wpa_s->conf->ap_scan;
  1834. return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_UINT32,
  1835. &ap_scan, error);
  1836. }
  1837. /**
  1838. * wpas_dbus_setter_ap_scan - Control roaming mode
  1839. * @iter: Pointer to incoming dbus message iter
  1840. * @error: Location to store error on failure
  1841. * @user_data: Function specific data
  1842. * Returns: TRUE on success, FALSE on failure
  1843. *
  1844. * Setter function for "ApScan" property.
  1845. */
  1846. dbus_bool_t wpas_dbus_setter_ap_scan(DBusMessageIter *iter, DBusError *error,
  1847. void *user_data)
  1848. {
  1849. struct wpa_supplicant *wpa_s = user_data;
  1850. dbus_uint32_t ap_scan;
  1851. if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_UINT32,
  1852. &ap_scan))
  1853. return FALSE;
  1854. if (wpa_supplicant_set_ap_scan(wpa_s, ap_scan)) {
  1855. dbus_set_error_const(error, DBUS_ERROR_FAILED,
  1856. "ap_scan must be 0, 1, or 2");
  1857. return FALSE;
  1858. }
  1859. return TRUE;
  1860. }
  1861. /**
  1862. * wpas_dbus_getter_bss_expire_age - Get BSS entry expiration age
  1863. * @iter: Pointer to incoming dbus message iter
  1864. * @error: Location to store error on failure
  1865. * @user_data: Function specific data
  1866. * Returns: TRUE on success, FALSE on failure
  1867. *
  1868. * Getter function for "BSSExpireAge" property.
  1869. */
  1870. dbus_bool_t wpas_dbus_getter_bss_expire_age(DBusMessageIter *iter,
  1871. DBusError *error,
  1872. void *user_data)
  1873. {
  1874. struct wpa_supplicant *wpa_s = user_data;
  1875. dbus_uint32_t expire_age = wpa_s->conf->bss_expiration_age;
  1876. return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_UINT32,
  1877. &expire_age, error);
  1878. }
  1879. /**
  1880. * wpas_dbus_setter_bss_expire_age - Control BSS entry expiration age
  1881. * @iter: Pointer to incoming dbus message iter
  1882. * @error: Location to store error on failure
  1883. * @user_data: Function specific data
  1884. * Returns: TRUE on success, FALSE on failure
  1885. *
  1886. * Setter function for "BSSExpireAge" property.
  1887. */
  1888. dbus_bool_t wpas_dbus_setter_bss_expire_age(DBusMessageIter *iter,
  1889. DBusError *error,
  1890. void *user_data)
  1891. {
  1892. struct wpa_supplicant *wpa_s = user_data;
  1893. dbus_uint32_t expire_age;
  1894. if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_UINT32,
  1895. &expire_age))
  1896. return FALSE;
  1897. if (wpa_supplicant_set_bss_expiration_age(wpa_s, expire_age)) {
  1898. dbus_set_error_const(error, DBUS_ERROR_FAILED,
  1899. "BSSExpireAge must be >= 10");
  1900. return FALSE;
  1901. }
  1902. return TRUE;
  1903. }
  1904. /**
  1905. * wpas_dbus_getter_bss_expire_count - Get BSS entry expiration scan count
  1906. * @iter: Pointer to incoming dbus message iter
  1907. * @error: Location to store error on failure
  1908. * @user_data: Function specific data
  1909. * Returns: TRUE on success, FALSE on failure
  1910. *
  1911. * Getter function for "BSSExpireCount" property.
  1912. */
  1913. dbus_bool_t wpas_dbus_getter_bss_expire_count(DBusMessageIter *iter,
  1914. DBusError *error,
  1915. void *user_data)
  1916. {
  1917. struct wpa_supplicant *wpa_s = user_data;
  1918. dbus_uint32_t expire_count = wpa_s->conf->bss_expiration_age;
  1919. return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_UINT32,
  1920. &expire_count, error);
  1921. }
  1922. /**
  1923. * wpas_dbus_setter_bss_expire_count - Control BSS entry expiration scan count
  1924. * @iter: Pointer to incoming dbus message iter
  1925. * @error: Location to store error on failure
  1926. * @user_data: Function specific data
  1927. * Returns: TRUE on success, FALSE on failure
  1928. *
  1929. * Setter function for "BSSExpireCount" property.
  1930. */
  1931. dbus_bool_t wpas_dbus_setter_bss_expire_count(DBusMessageIter *iter,
  1932. DBusError *error,
  1933. void *user_data)
  1934. {
  1935. struct wpa_supplicant *wpa_s = user_data;
  1936. dbus_uint32_t expire_count;
  1937. if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_UINT32,
  1938. &expire_count))
  1939. return FALSE;
  1940. if (wpa_supplicant_set_bss_expiration_count(wpa_s, expire_count)) {
  1941. dbus_set_error_const(error, DBUS_ERROR_FAILED,
  1942. "BSSExpireCount must be > 0");
  1943. return FALSE;
  1944. }
  1945. return TRUE;
  1946. }
  1947. /**
  1948. * wpas_dbus_getter_country - Control country code
  1949. * @iter: Pointer to incoming dbus message iter
  1950. * @error: Location to store error on failure
  1951. * @user_data: Function specific data
  1952. * Returns: TRUE on success, FALSE on failure
  1953. *
  1954. * Getter function for "Country" property.
  1955. */
  1956. dbus_bool_t wpas_dbus_getter_country(DBusMessageIter *iter, DBusError *error,
  1957. void *user_data)
  1958. {
  1959. struct wpa_supplicant *wpa_s = user_data;
  1960. char country[3];
  1961. char *str = country;
  1962. country[0] = wpa_s->conf->country[0];
  1963. country[1] = wpa_s->conf->country[1];
  1964. country[2] = '\0';
  1965. return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING,
  1966. &str, error);
  1967. }
  1968. /**
  1969. * wpas_dbus_setter_country - Control country code
  1970. * @iter: Pointer to incoming dbus message iter
  1971. * @error: Location to store error on failure
  1972. * @user_data: Function specific data
  1973. * Returns: TRUE on success, FALSE on failure
  1974. *
  1975. * Setter function for "Country" property.
  1976. */
  1977. dbus_bool_t wpas_dbus_setter_country(DBusMessageIter *iter, DBusError *error,
  1978. void *user_data)
  1979. {
  1980. struct wpa_supplicant *wpa_s = user_data;
  1981. const char *country;
  1982. if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_STRING,
  1983. &country))
  1984. return FALSE;
  1985. if (!country[0] || !country[1]) {
  1986. dbus_set_error_const(error, DBUS_ERROR_FAILED,
  1987. "invalid country code");
  1988. return FALSE;
  1989. }
  1990. if (wpa_s->drv_priv != NULL && wpa_drv_set_country(wpa_s, country)) {
  1991. wpa_printf(MSG_DEBUG, "Failed to set country");
  1992. dbus_set_error_const(error, DBUS_ERROR_FAILED,
  1993. "failed to set country code");
  1994. return FALSE;
  1995. }
  1996. wpa_s->conf->country[0] = country[0];
  1997. wpa_s->conf->country[1] = country[1];
  1998. return TRUE;
  1999. }
  2000. /**
  2001. * wpas_dbus_getter_ifname - Get interface name
  2002. * @iter: Pointer to incoming dbus message iter
  2003. * @error: Location to store error on failure
  2004. * @user_data: Function specific data
  2005. * Returns: TRUE on success, FALSE on failure
  2006. *
  2007. * Getter for "Ifname" property.
  2008. */
  2009. dbus_bool_t wpas_dbus_getter_ifname(DBusMessageIter *iter, DBusError *error,
  2010. void *user_data)
  2011. {
  2012. struct wpa_supplicant *wpa_s = user_data;
  2013. const char *ifname = wpa_s->ifname;
  2014. return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING,
  2015. &ifname, error);
  2016. }
  2017. /**
  2018. * wpas_dbus_getter_driver - Get interface name
  2019. * @iter: Pointer to incoming dbus message iter
  2020. * @error: Location to store error on failure
  2021. * @user_data: Function specific data
  2022. * Returns: TRUE on success, FALSE on failure
  2023. *
  2024. * Getter for "Driver" property.
  2025. */
  2026. dbus_bool_t wpas_dbus_getter_driver(DBusMessageIter *iter, DBusError *error,
  2027. void *user_data)
  2028. {
  2029. struct wpa_supplicant *wpa_s = user_data;
  2030. const char *driver;
  2031. if (wpa_s->driver == NULL || wpa_s->driver->name == NULL) {
  2032. wpa_printf(MSG_DEBUG, "wpas_dbus_getter_driver[dbus]: "
  2033. "wpa_s has no driver set");
  2034. dbus_set_error(error, DBUS_ERROR_FAILED, "%s: no driver set",
  2035. __func__);
  2036. return FALSE;
  2037. }
  2038. driver = wpa_s->driver->name;
  2039. return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING,
  2040. &driver, error);
  2041. }
  2042. /**
  2043. * wpas_dbus_getter_current_bss - Get current bss object path
  2044. * @iter: Pointer to incoming dbus message iter
  2045. * @error: Location to store error on failure
  2046. * @user_data: Function specific data
  2047. * Returns: TRUE on success, FALSE on failure
  2048. *
  2049. * Getter for "CurrentBSS" property.
  2050. */
  2051. dbus_bool_t wpas_dbus_getter_current_bss(DBusMessageIter *iter,
  2052. DBusError *error,
  2053. void *user_data)
  2054. {
  2055. struct wpa_supplicant *wpa_s = user_data;
  2056. char path_buf[WPAS_DBUS_OBJECT_PATH_MAX], *bss_obj_path = path_buf;
  2057. if (wpa_s->current_bss)
  2058. os_snprintf(bss_obj_path, WPAS_DBUS_OBJECT_PATH_MAX,
  2059. "%s/" WPAS_DBUS_NEW_BSSIDS_PART "/%u",
  2060. wpa_s->dbus_new_path, wpa_s->current_bss->id);
  2061. else
  2062. os_snprintf(bss_obj_path, WPAS_DBUS_OBJECT_PATH_MAX, "/");
  2063. return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_OBJECT_PATH,
  2064. &bss_obj_path, error);
  2065. }
  2066. /**
  2067. * wpas_dbus_getter_current_network - Get current network object path
  2068. * @iter: Pointer to incoming dbus message iter
  2069. * @error: Location to store error on failure
  2070. * @user_data: Function specific data
  2071. * Returns: TRUE on success, FALSE on failure
  2072. *
  2073. * Getter for "CurrentNetwork" property.
  2074. */
  2075. dbus_bool_t wpas_dbus_getter_current_network(DBusMessageIter *iter,
  2076. DBusError *error,
  2077. void *user_data)
  2078. {
  2079. struct wpa_supplicant *wpa_s = user_data;
  2080. char path_buf[WPAS_DBUS_OBJECT_PATH_MAX], *net_obj_path = path_buf;
  2081. if (wpa_s->current_ssid)
  2082. os_snprintf(net_obj_path, WPAS_DBUS_OBJECT_PATH_MAX,
  2083. "%s/" WPAS_DBUS_NEW_NETWORKS_PART "/%u",
  2084. wpa_s->dbus_new_path, wpa_s->current_ssid->id);
  2085. else
  2086. os_snprintf(net_obj_path, WPAS_DBUS_OBJECT_PATH_MAX, "/");
  2087. return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_OBJECT_PATH,
  2088. &net_obj_path, error);
  2089. }
  2090. /**
  2091. * wpas_dbus_getter_current_auth_mode - Get current authentication type
  2092. * @iter: Pointer to incoming dbus message iter
  2093. * @error: Location to store error on failure
  2094. * @user_data: Function specific data
  2095. * Returns: TRUE on success, FALSE on failure
  2096. *
  2097. * Getter for "CurrentAuthMode" property.
  2098. */
  2099. dbus_bool_t wpas_dbus_getter_current_auth_mode(DBusMessageIter *iter,
  2100. DBusError *error,
  2101. void *user_data)
  2102. {
  2103. struct wpa_supplicant *wpa_s = user_data;
  2104. const char *eap_mode;
  2105. const char *auth_mode;
  2106. char eap_mode_buf[WPAS_DBUS_AUTH_MODE_MAX];
  2107. if (wpa_s->wpa_state != WPA_COMPLETED) {
  2108. auth_mode = "INACTIVE";
  2109. } else if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X ||
  2110. wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
  2111. eap_mode = wpa_supplicant_get_eap_mode(wpa_s);
  2112. os_snprintf(eap_mode_buf, WPAS_DBUS_AUTH_MODE_MAX,
  2113. "EAP-%s", eap_mode);
  2114. auth_mode = eap_mode_buf;
  2115. } else {
  2116. auth_mode = wpa_key_mgmt_txt(wpa_s->key_mgmt,
  2117. wpa_s->current_ssid->proto);
  2118. }
  2119. return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING,
  2120. &auth_mode, error);
  2121. }
  2122. /**
  2123. * wpas_dbus_getter_bridge_ifname - Get interface name
  2124. * @iter: Pointer to incoming dbus message iter
  2125. * @error: Location to store error on failure
  2126. * @user_data: Function specific data
  2127. * Returns: TRUE on success, FALSE on failure
  2128. *
  2129. * Getter for "BridgeIfname" property.
  2130. */
  2131. dbus_bool_t wpas_dbus_getter_bridge_ifname(DBusMessageIter *iter,
  2132. DBusError *error,
  2133. void *user_data)
  2134. {
  2135. struct wpa_supplicant *wpa_s = user_data;
  2136. const char *bridge_ifname;
  2137. bridge_ifname = wpa_s->bridge_ifname ? wpa_s->bridge_ifname : "";
  2138. return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING,
  2139. &bridge_ifname, error);
  2140. }
  2141. /**
  2142. * wpas_dbus_getter_bsss - Get array of BSSs objects
  2143. * @iter: Pointer to incoming dbus message iter
  2144. * @error: Location to store error on failure
  2145. * @user_data: Function specific data
  2146. * Returns: TRUE on success, FALSE on failure
  2147. *
  2148. * Getter for "BSSs" property.
  2149. */
  2150. dbus_bool_t wpas_dbus_getter_bsss(DBusMessageIter *iter, DBusError *error,
  2151. void *user_data)
  2152. {
  2153. struct wpa_supplicant *wpa_s = user_data;
  2154. struct wpa_bss *bss;
  2155. char **paths;
  2156. unsigned int i = 0;
  2157. dbus_bool_t success = FALSE;
  2158. paths = os_zalloc(wpa_s->num_bss * sizeof(char *));
  2159. if (!paths) {
  2160. dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
  2161. return FALSE;
  2162. }
  2163. /* Loop through scan results and append each result's object path */
  2164. dl_list_for_each(bss, &wpa_s->bss_id, struct wpa_bss, list_id) {
  2165. paths[i] = os_zalloc(WPAS_DBUS_OBJECT_PATH_MAX);
  2166. if (paths[i] == NULL) {
  2167. dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY,
  2168. "no memory");
  2169. goto out;
  2170. }
  2171. /* Construct the object path for this BSS. */
  2172. os_snprintf(paths[i++], WPAS_DBUS_OBJECT_PATH_MAX,
  2173. "%s/" WPAS_DBUS_NEW_BSSIDS_PART "/%u",
  2174. wpa_s->dbus_new_path, bss->id);
  2175. }
  2176. success = wpas_dbus_simple_array_property_getter(iter,
  2177. DBUS_TYPE_OBJECT_PATH,
  2178. paths, wpa_s->num_bss,
  2179. error);
  2180. out:
  2181. while (i)
  2182. os_free(paths[--i]);
  2183. os_free(paths);
  2184. return success;
  2185. }
  2186. /**
  2187. * wpas_dbus_getter_networks - Get array of networks objects
  2188. * @iter: Pointer to incoming dbus message iter
  2189. * @error: Location to store error on failure
  2190. * @user_data: Function specific data
  2191. * Returns: TRUE on success, FALSE on failure
  2192. *
  2193. * Getter for "Networks" property.
  2194. */
  2195. dbus_bool_t wpas_dbus_getter_networks(DBusMessageIter *iter, DBusError *error,
  2196. void *user_data)
  2197. {
  2198. struct wpa_supplicant *wpa_s = user_data;
  2199. struct wpa_ssid *ssid;
  2200. char **paths;
  2201. unsigned int i = 0, num = 0;
  2202. dbus_bool_t success = FALSE;
  2203. if (wpa_s->conf == NULL) {
  2204. wpa_printf(MSG_ERROR, "%s[dbus]: An error occurred getting "
  2205. "networks list.", __func__);
  2206. dbus_set_error(error, DBUS_ERROR_FAILED, "%s: an error "
  2207. "occurred getting the networks list", __func__);
  2208. return FALSE;
  2209. }
  2210. for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
  2211. if (!network_is_persistent_group(ssid))
  2212. num++;
  2213. paths = os_zalloc(num * sizeof(char *));
  2214. if (!paths) {
  2215. dbus_set_error(error, DBUS_ERROR_NO_MEMORY, "no memory");
  2216. return FALSE;
  2217. }
  2218. /* Loop through configured networks and append object path of each */
  2219. for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) {
  2220. if (network_is_persistent_group(ssid))
  2221. continue;
  2222. paths[i] = os_zalloc(WPAS_DBUS_OBJECT_PATH_MAX);
  2223. if (paths[i] == NULL) {
  2224. dbus_set_error(error, DBUS_ERROR_NO_MEMORY, "no memory");
  2225. goto out;
  2226. }
  2227. /* Construct the object path for this network. */
  2228. os_snprintf(paths[i++], WPAS_DBUS_OBJECT_PATH_MAX,
  2229. "%s/" WPAS_DBUS_NEW_NETWORKS_PART "/%d",
  2230. wpa_s->dbus_new_path, ssid->id);
  2231. }
  2232. success = wpas_dbus_simple_array_property_getter(iter,
  2233. DBUS_TYPE_OBJECT_PATH,
  2234. paths, num, error);
  2235. out:
  2236. while (i)
  2237. os_free(paths[--i]);
  2238. os_free(paths);
  2239. return success;
  2240. }
  2241. /**
  2242. * wpas_dbus_getter_blobs - Get all blobs defined for this interface
  2243. * @iter: Pointer to incoming dbus message iter
  2244. * @error: Location to store error on failure
  2245. * @user_data: Function specific data
  2246. * Returns: TRUE on success, FALSE on failure
  2247. *
  2248. * Getter for "Blobs" property.
  2249. */
  2250. dbus_bool_t wpas_dbus_getter_blobs(DBusMessageIter *iter, DBusError *error,
  2251. void *user_data)
  2252. {
  2253. struct wpa_supplicant *wpa_s = user_data;
  2254. DBusMessageIter variant_iter, dict_iter, entry_iter, array_iter;
  2255. struct wpa_config_blob *blob;
  2256. if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
  2257. "a{say}", &variant_iter) ||
  2258. !dbus_message_iter_open_container(&variant_iter, DBUS_TYPE_ARRAY,
  2259. "{say}", &dict_iter)) {
  2260. dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
  2261. return FALSE;
  2262. }
  2263. blob = wpa_s->conf->blobs;
  2264. while (blob) {
  2265. if (!dbus_message_iter_open_container(&dict_iter,
  2266. DBUS_TYPE_DICT_ENTRY,
  2267. NULL, &entry_iter) ||
  2268. !dbus_message_iter_append_basic(&entry_iter,
  2269. DBUS_TYPE_STRING,
  2270. &(blob->name)) ||
  2271. !dbus_message_iter_open_container(&entry_iter,
  2272. DBUS_TYPE_ARRAY,
  2273. DBUS_TYPE_BYTE_AS_STRING,
  2274. &array_iter) ||
  2275. !dbus_message_iter_append_fixed_array(&array_iter,
  2276. DBUS_TYPE_BYTE,
  2277. &(blob->data),
  2278. blob->len) ||
  2279. !dbus_message_iter_close_container(&entry_iter,
  2280. &array_iter) ||
  2281. !dbus_message_iter_close_container(&dict_iter,
  2282. &entry_iter)) {
  2283. dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY,
  2284. "no memory");
  2285. return FALSE;
  2286. }
  2287. blob = blob->next;
  2288. }
  2289. if (!dbus_message_iter_close_container(&variant_iter, &dict_iter) ||
  2290. !dbus_message_iter_close_container(iter, &variant_iter)) {
  2291. dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
  2292. return FALSE;
  2293. }
  2294. return TRUE;
  2295. }
  2296. static struct wpa_bss * get_bss_helper(struct bss_handler_args *args,
  2297. DBusError *error, const char *func_name)
  2298. {
  2299. struct wpa_bss *res = wpa_bss_get_id(args->wpa_s, args->id);
  2300. if (!res) {
  2301. wpa_printf(MSG_ERROR, "%s[dbus]: no bss with id %d found",
  2302. func_name, args->id);
  2303. dbus_set_error(error, DBUS_ERROR_FAILED,
  2304. "%s: BSS %d not found",
  2305. func_name, args->id);
  2306. }
  2307. return res;
  2308. }
  2309. /**
  2310. * wpas_dbus_getter_bss_bssid - Return the BSSID of a BSS
  2311. * @iter: Pointer to incoming dbus message iter
  2312. * @error: Location to store error on failure
  2313. * @user_data: Function specific data
  2314. * Returns: TRUE on success, FALSE on failure
  2315. *
  2316. * Getter for "BSSID" property.
  2317. */
  2318. dbus_bool_t wpas_dbus_getter_bss_bssid(DBusMessageIter *iter, DBusError *error,
  2319. void *user_data)
  2320. {
  2321. struct bss_handler_args *args = user_data;
  2322. struct wpa_bss *res;
  2323. res = get_bss_helper(args, error, __func__);
  2324. if (!res)
  2325. return FALSE;
  2326. return wpas_dbus_simple_array_property_getter(iter, DBUS_TYPE_BYTE,
  2327. res->bssid, ETH_ALEN,
  2328. error);
  2329. }
  2330. /**
  2331. * wpas_dbus_getter_bss_ssid - Return the SSID of a BSS
  2332. * @iter: Pointer to incoming dbus message iter
  2333. * @error: Location to store error on failure
  2334. * @user_data: Function specific data
  2335. * Returns: TRUE on success, FALSE on failure
  2336. *
  2337. * Getter for "SSID" property.
  2338. */
  2339. dbus_bool_t wpas_dbus_getter_bss_ssid(DBusMessageIter *iter, DBusError *error,
  2340. void *user_data)
  2341. {
  2342. struct bss_handler_args *args = user_data;
  2343. struct wpa_bss *res;
  2344. res = get_bss_helper(args, error, __func__);
  2345. if (!res)
  2346. return FALSE;
  2347. return wpas_dbus_simple_array_property_getter(iter, DBUS_TYPE_BYTE,
  2348. res->ssid, res->ssid_len,
  2349. error);
  2350. }
  2351. /**
  2352. * wpas_dbus_getter_bss_privacy - Return the privacy flag of a BSS
  2353. * @iter: Pointer to incoming dbus message iter
  2354. * @error: Location to store error on failure
  2355. * @user_data: Function specific data
  2356. * Returns: TRUE on success, FALSE on failure
  2357. *
  2358. * Getter for "Privacy" property.
  2359. */
  2360. dbus_bool_t wpas_dbus_getter_bss_privacy(DBusMessageIter *iter,
  2361. DBusError *error, void *user_data)
  2362. {
  2363. struct bss_handler_args *args = user_data;
  2364. struct wpa_bss *res;
  2365. dbus_bool_t privacy;
  2366. res = get_bss_helper(args, error, __func__);
  2367. if (!res)
  2368. return FALSE;
  2369. privacy = (res->caps & IEEE80211_CAP_PRIVACY) ? TRUE : FALSE;
  2370. return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_BOOLEAN,
  2371. &privacy, error);
  2372. }
  2373. /**
  2374. * wpas_dbus_getter_bss_mode - Return the mode of a BSS
  2375. * @iter: Pointer to incoming dbus message iter
  2376. * @error: Location to store error on failure
  2377. * @user_data: Function specific data
  2378. * Returns: TRUE on success, FALSE on failure
  2379. *
  2380. * Getter for "Mode" property.
  2381. */
  2382. dbus_bool_t wpas_dbus_getter_bss_mode(DBusMessageIter *iter, DBusError *error,
  2383. void *user_data)
  2384. {
  2385. struct bss_handler_args *args = user_data;
  2386. struct wpa_bss *res;
  2387. const char *mode;
  2388. res = get_bss_helper(args, error, __func__);
  2389. if (!res)
  2390. return FALSE;
  2391. if (res->caps & IEEE80211_CAP_IBSS)
  2392. mode = "ad-hoc";
  2393. else
  2394. mode = "infrastructure";
  2395. return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING,
  2396. &mode, error);
  2397. }
  2398. /**
  2399. * wpas_dbus_getter_bss_level - Return the signal strength of a BSS
  2400. * @iter: Pointer to incoming dbus message iter
  2401. * @error: Location to store error on failure
  2402. * @user_data: Function specific data
  2403. * Returns: TRUE on success, FALSE on failure
  2404. *
  2405. * Getter for "Level" property.
  2406. */
  2407. dbus_bool_t wpas_dbus_getter_bss_signal(DBusMessageIter *iter,
  2408. DBusError *error, void *user_data)
  2409. {
  2410. struct bss_handler_args *args = user_data;
  2411. struct wpa_bss *res;
  2412. res = get_bss_helper(args, error, __func__);
  2413. if (!res)
  2414. return FALSE;
  2415. return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_INT16,
  2416. &res->level, error);
  2417. }
  2418. /**
  2419. * wpas_dbus_getter_bss_frequency - Return the frequency of a BSS
  2420. * @iter: Pointer to incoming dbus message iter
  2421. * @error: Location to store error on failure
  2422. * @user_data: Function specific data
  2423. * Returns: TRUE on success, FALSE on failure
  2424. *
  2425. * Getter for "Frequency" property.
  2426. */
  2427. dbus_bool_t wpas_dbus_getter_bss_frequency(DBusMessageIter *iter,
  2428. DBusError *error, void *user_data)
  2429. {
  2430. struct bss_handler_args *args = user_data;
  2431. struct wpa_bss *res;
  2432. res = get_bss_helper(args, error, __func__);
  2433. if (!res)
  2434. return FALSE;
  2435. return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_UINT16,
  2436. &res->freq, error);
  2437. }
  2438. static int cmp_u8s_desc(const void *a, const void *b)
  2439. {
  2440. return (*(u8 *) b - *(u8 *) a);
  2441. }
  2442. /**
  2443. * wpas_dbus_getter_bss_rates - Return available bit rates of a BSS
  2444. * @iter: Pointer to incoming dbus message iter
  2445. * @error: Location to store error on failure
  2446. * @user_data: Function specific data
  2447. * Returns: TRUE on success, FALSE on failure
  2448. *
  2449. * Getter for "Rates" property.
  2450. */
  2451. dbus_bool_t wpas_dbus_getter_bss_rates(DBusMessageIter *iter,
  2452. DBusError *error, void *user_data)
  2453. {
  2454. struct bss_handler_args *args = user_data;
  2455. struct wpa_bss *res;
  2456. u8 *ie_rates = NULL;
  2457. u32 *real_rates;
  2458. int rates_num, i;
  2459. dbus_bool_t success = FALSE;
  2460. res = get_bss_helper(args, error, __func__);
  2461. if (!res)
  2462. return FALSE;
  2463. rates_num = wpa_bss_get_bit_rates(res, &ie_rates);
  2464. if (rates_num < 0)
  2465. return FALSE;
  2466. qsort(ie_rates, rates_num, 1, cmp_u8s_desc);
  2467. real_rates = os_malloc(sizeof(u32) * rates_num);
  2468. if (!real_rates) {
  2469. os_free(ie_rates);
  2470. dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
  2471. return FALSE;
  2472. }
  2473. for (i = 0; i < rates_num; i++)
  2474. real_rates[i] = ie_rates[i] * 500000;
  2475. success = wpas_dbus_simple_array_property_getter(iter, DBUS_TYPE_UINT32,
  2476. real_rates, rates_num,
  2477. error);
  2478. os_free(ie_rates);
  2479. os_free(real_rates);
  2480. return success;
  2481. }
  2482. static dbus_bool_t wpas_dbus_get_bss_security_prop(DBusMessageIter *iter,
  2483. struct wpa_ie_data *ie_data,
  2484. DBusError *error)
  2485. {
  2486. DBusMessageIter iter_dict, variant_iter;
  2487. const char *group;
  2488. const char *pairwise[2]; /* max 2 pairwise ciphers is supported */
  2489. const char *key_mgmt[7]; /* max 7 key managements may be supported */
  2490. int n;
  2491. if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
  2492. "a{sv}", &variant_iter))
  2493. goto nomem;
  2494. if (!wpa_dbus_dict_open_write(&variant_iter, &iter_dict))
  2495. goto nomem;
  2496. /* KeyMgmt */
  2497. n = 0;
  2498. if (ie_data->key_mgmt & WPA_KEY_MGMT_PSK)
  2499. key_mgmt[n++] = "wpa-psk";
  2500. if (ie_data->key_mgmt & WPA_KEY_MGMT_FT_PSK)
  2501. key_mgmt[n++] = "wpa-ft-psk";
  2502. if (ie_data->key_mgmt & WPA_KEY_MGMT_PSK_SHA256)
  2503. key_mgmt[n++] = "wpa-psk-sha256";
  2504. if (ie_data->key_mgmt & WPA_KEY_MGMT_IEEE8021X)
  2505. key_mgmt[n++] = "wpa-eap";
  2506. if (ie_data->key_mgmt & WPA_KEY_MGMT_FT_IEEE8021X)
  2507. key_mgmt[n++] = "wpa-ft-eap";
  2508. if (ie_data->key_mgmt & WPA_KEY_MGMT_IEEE8021X_SHA256)
  2509. key_mgmt[n++] = "wpa-eap-sha256";
  2510. if (ie_data->key_mgmt & WPA_KEY_MGMT_NONE)
  2511. key_mgmt[n++] = "wpa-none";
  2512. if (!wpa_dbus_dict_append_string_array(&iter_dict, "KeyMgmt",
  2513. key_mgmt, n))
  2514. goto nomem;
  2515. /* Group */
  2516. switch (ie_data->group_cipher) {
  2517. case WPA_CIPHER_WEP40:
  2518. group = "wep40";
  2519. break;
  2520. case WPA_CIPHER_TKIP:
  2521. group = "tkip";
  2522. break;
  2523. case WPA_CIPHER_CCMP:
  2524. group = "ccmp";
  2525. break;
  2526. case WPA_CIPHER_WEP104:
  2527. group = "wep104";
  2528. break;
  2529. default:
  2530. group = "";
  2531. break;
  2532. }
  2533. if (!wpa_dbus_dict_append_string(&iter_dict, "Group", group))
  2534. goto nomem;
  2535. /* Pairwise */
  2536. n = 0;
  2537. if (ie_data->pairwise_cipher & WPA_CIPHER_TKIP)
  2538. pairwise[n++] = "tkip";
  2539. if (ie_data->pairwise_cipher & WPA_CIPHER_CCMP)
  2540. pairwise[n++] = "ccmp";
  2541. if (!wpa_dbus_dict_append_string_array(&iter_dict, "Pairwise",
  2542. pairwise, n))
  2543. goto nomem;
  2544. /* Management group (RSN only) */
  2545. if (ie_data->proto == WPA_PROTO_RSN) {
  2546. switch (ie_data->mgmt_group_cipher) {
  2547. #ifdef CONFIG_IEEE80211W
  2548. case WPA_CIPHER_AES_128_CMAC:
  2549. group = "aes128cmac";
  2550. break;
  2551. #endif /* CONFIG_IEEE80211W */
  2552. default:
  2553. group = "";
  2554. break;
  2555. }
  2556. if (!wpa_dbus_dict_append_string(&iter_dict, "MgmtGroup",
  2557. group))
  2558. goto nomem;
  2559. }
  2560. if (!wpa_dbus_dict_close_write(&variant_iter, &iter_dict))
  2561. goto nomem;
  2562. if (!dbus_message_iter_close_container(iter, &variant_iter))
  2563. goto nomem;
  2564. return TRUE;
  2565. nomem:
  2566. dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
  2567. return FALSE;
  2568. }
  2569. /**
  2570. * wpas_dbus_getter_bss_wpa - Return the WPA options of a BSS
  2571. * @iter: Pointer to incoming dbus message iter
  2572. * @error: Location to store error on failure
  2573. * @user_data: Function specific data
  2574. * Returns: TRUE on success, FALSE on failure
  2575. *
  2576. * Getter for "WPA" property.
  2577. */
  2578. dbus_bool_t wpas_dbus_getter_bss_wpa(DBusMessageIter *iter, DBusError *error,
  2579. void *user_data)
  2580. {
  2581. struct bss_handler_args *args = user_data;
  2582. struct wpa_bss *res;
  2583. struct wpa_ie_data wpa_data;
  2584. const u8 *ie;
  2585. res = get_bss_helper(args, error, __func__);
  2586. if (!res)
  2587. return FALSE;
  2588. os_memset(&wpa_data, 0, sizeof(wpa_data));
  2589. ie = wpa_bss_get_vendor_ie(res, WPA_IE_VENDOR_TYPE);
  2590. if (ie) {
  2591. if (wpa_parse_wpa_ie(ie, 2 + ie[1], &wpa_data) < 0) {
  2592. dbus_set_error_const(error, DBUS_ERROR_FAILED,
  2593. "failed to parse WPA IE");
  2594. return FALSE;
  2595. }
  2596. }
  2597. return wpas_dbus_get_bss_security_prop(iter, &wpa_data, error);
  2598. }
  2599. /**
  2600. * wpas_dbus_getter_bss_rsn - Return the RSN options of a BSS
  2601. * @iter: Pointer to incoming dbus message iter
  2602. * @error: Location to store error on failure
  2603. * @user_data: Function specific data
  2604. * Returns: TRUE on success, FALSE on failure
  2605. *
  2606. * Getter for "RSN" property.
  2607. */
  2608. dbus_bool_t wpas_dbus_getter_bss_rsn(DBusMessageIter *iter, DBusError *error,
  2609. void *user_data)
  2610. {
  2611. struct bss_handler_args *args = user_data;
  2612. struct wpa_bss *res;
  2613. struct wpa_ie_data wpa_data;
  2614. const u8 *ie;
  2615. res = get_bss_helper(args, error, __func__);
  2616. if (!res)
  2617. return FALSE;
  2618. os_memset(&wpa_data, 0, sizeof(wpa_data));
  2619. ie = wpa_bss_get_ie(res, WLAN_EID_RSN);
  2620. if (ie) {
  2621. if (wpa_parse_wpa_ie(ie, 2 + ie[1], &wpa_data) < 0) {
  2622. dbus_set_error_const(error, DBUS_ERROR_FAILED,
  2623. "failed to parse RSN IE");
  2624. return FALSE;
  2625. }
  2626. }
  2627. return wpas_dbus_get_bss_security_prop(iter, &wpa_data, error);
  2628. }
  2629. /**
  2630. * wpas_dbus_getter_bss_ies - Return all IEs of a BSS
  2631. * @iter: Pointer to incoming dbus message iter
  2632. * @error: Location to store error on failure
  2633. * @user_data: Function specific data
  2634. * Returns: TRUE on success, FALSE on failure
  2635. *
  2636. * Getter for "IEs" property.
  2637. */
  2638. dbus_bool_t wpas_dbus_getter_bss_ies(DBusMessageIter *iter, DBusError *error,
  2639. void *user_data)
  2640. {
  2641. struct bss_handler_args *args = user_data;
  2642. struct wpa_bss *res;
  2643. res = get_bss_helper(args, error, __func__);
  2644. if (!res)
  2645. return FALSE;
  2646. return wpas_dbus_simple_array_property_getter(iter, DBUS_TYPE_BYTE,
  2647. res + 1, res->ie_len,
  2648. error);
  2649. }
  2650. /**
  2651. * wpas_dbus_getter_enabled - Check whether network is enabled or disabled
  2652. * @iter: Pointer to incoming dbus message iter
  2653. * @error: Location to store error on failure
  2654. * @user_data: Function specific data
  2655. * Returns: TRUE on success, FALSE on failure
  2656. *
  2657. * Getter for "enabled" property of a configured network.
  2658. */
  2659. dbus_bool_t wpas_dbus_getter_enabled(DBusMessageIter *iter, DBusError *error,
  2660. void *user_data)
  2661. {
  2662. struct network_handler_args *net = user_data;
  2663. dbus_bool_t enabled = net->ssid->disabled ? FALSE : TRUE;
  2664. return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_BOOLEAN,
  2665. &enabled, error);
  2666. }
  2667. /**
  2668. * wpas_dbus_setter_enabled - Mark a configured network as enabled or disabled
  2669. * @iter: Pointer to incoming dbus message iter
  2670. * @error: Location to store error on failure
  2671. * @user_data: Function specific data
  2672. * Returns: TRUE on success, FALSE on failure
  2673. *
  2674. * Setter for "Enabled" property of a configured network.
  2675. */
  2676. dbus_bool_t wpas_dbus_setter_enabled(DBusMessageIter *iter, DBusError *error,
  2677. void *user_data)
  2678. {
  2679. struct network_handler_args *net = user_data;
  2680. struct wpa_supplicant *wpa_s;
  2681. struct wpa_ssid *ssid;
  2682. dbus_bool_t enable;
  2683. if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_BOOLEAN,
  2684. &enable))
  2685. return FALSE;
  2686. wpa_s = net->wpa_s;
  2687. ssid = net->ssid;
  2688. if (enable)
  2689. wpa_supplicant_enable_network(wpa_s, ssid);
  2690. else
  2691. wpa_supplicant_disable_network(wpa_s, ssid);
  2692. return TRUE;
  2693. }
  2694. /**
  2695. * wpas_dbus_getter_network_properties - Get options for a configured network
  2696. * @iter: Pointer to incoming dbus message iter
  2697. * @error: Location to store error on failure
  2698. * @user_data: Function specific data
  2699. * Returns: TRUE on success, FALSE on failure
  2700. *
  2701. * Getter for "Properties" property of a configured network.
  2702. */
  2703. dbus_bool_t wpas_dbus_getter_network_properties(DBusMessageIter *iter,
  2704. DBusError *error,
  2705. void *user_data)
  2706. {
  2707. struct network_handler_args *net = user_data;
  2708. DBusMessageIter variant_iter, dict_iter;
  2709. char **iterator;
  2710. char **props = wpa_config_get_all(net->ssid, 1);
  2711. dbus_bool_t success = FALSE;
  2712. if (!props) {
  2713. dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
  2714. return FALSE;
  2715. }
  2716. if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, "a{sv}",
  2717. &variant_iter) ||
  2718. !wpa_dbus_dict_open_write(&variant_iter, &dict_iter)) {
  2719. dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
  2720. goto out;
  2721. }
  2722. iterator = props;
  2723. while (*iterator) {
  2724. if (!wpa_dbus_dict_append_string(&dict_iter, *iterator,
  2725. *(iterator + 1))) {
  2726. dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY,
  2727. "no memory");
  2728. goto out;
  2729. }
  2730. iterator += 2;
  2731. }
  2732. if (!wpa_dbus_dict_close_write(&variant_iter, &dict_iter) ||
  2733. !dbus_message_iter_close_container(iter, &variant_iter)) {
  2734. dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, "no memory");
  2735. goto out;
  2736. }
  2737. success = TRUE;
  2738. out:
  2739. iterator = props;
  2740. while (*iterator) {
  2741. os_free(*iterator);
  2742. iterator++;
  2743. }
  2744. os_free(props);
  2745. return success;
  2746. }
  2747. /**
  2748. * wpas_dbus_setter_network_properties - Set options for a configured network
  2749. * @iter: Pointer to incoming dbus message iter
  2750. * @error: Location to store error on failure
  2751. * @user_data: Function specific data
  2752. * Returns: TRUE on success, FALSE on failure
  2753. *
  2754. * Setter for "Properties" property of a configured network.
  2755. */
  2756. dbus_bool_t wpas_dbus_setter_network_properties(DBusMessageIter *iter,
  2757. DBusError *error,
  2758. void *user_data)
  2759. {
  2760. struct network_handler_args *net = user_data;
  2761. struct wpa_ssid *ssid = net->ssid;
  2762. DBusMessageIter variant_iter;
  2763. dbus_message_iter_recurse(iter, &variant_iter);
  2764. return set_network_properties(net->wpa_s, ssid, &variant_iter, error);
  2765. }