dbus_new_handlers.c 101 KB

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