00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017 #include "includes.h"
00018
00019 #include "common.h"
00020 #include "wps/wps.h"
00021 #include "../config.h"
00022 #include "../wpa_supplicant_i.h"
00023 #include "../bss.h"
00024 #include "dbus_new_helpers.h"
00025 #include "dbus_dict_helpers.h"
00026 #include "dbus_new.h"
00027 #include "dbus_new_handlers.h"
00028 #include "dbus_common.h"
00029 #include "dbus_common_i.h"
00030
00031
00040 static void wpas_dbus_signal_interface(struct wpa_supplicant *wpa_s,
00041 const char *sig_name, int properties)
00042 {
00043 struct wpas_dbus_priv *iface;
00044 DBusMessage *msg;
00045 DBusMessageIter iter, iter_dict;
00046
00047 iface = wpa_s->global->dbus;
00048
00049
00050 if (iface == NULL)
00051 return;
00052
00053 msg = dbus_message_new_signal(WPAS_DBUS_NEW_PATH,
00054 WPAS_DBUS_NEW_INTERFACE, sig_name);
00055 if (msg == NULL)
00056 return;
00057
00058 dbus_message_iter_init_append(msg, &iter);
00059 if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_OBJECT_PATH,
00060 &wpa_s->dbus_new_path))
00061 goto err;
00062
00063 if (properties) {
00064 if (!wpa_dbus_dict_open_write(&iter, &iter_dict))
00065 goto err;
00066
00067 wpa_dbus_get_object_properties(iface, wpa_s->dbus_new_path,
00068 WPAS_DBUS_NEW_IFACE_INTERFACE,
00069 &iter_dict);
00070
00071 if (!wpa_dbus_dict_close_write(&iter, &iter_dict))
00072 goto err;
00073 }
00074
00075 dbus_connection_send(iface->con, msg, NULL);
00076 dbus_message_unref(msg);
00077 return;
00078
00079 err:
00080 wpa_printf(MSG_ERROR, "dbus: Failed to construct signal");
00081 dbus_message_unref(msg);
00082 }
00083
00084
00091 static void wpas_dbus_signal_interface_added(struct wpa_supplicant *wpa_s)
00092 {
00093 wpas_dbus_signal_interface(wpa_s, "InterfaceAdded", TRUE);
00094 }
00095
00096
00103 static void wpas_dbus_signal_interface_removed(struct wpa_supplicant *wpa_s)
00104 {
00105 wpas_dbus_signal_interface(wpa_s, "InterfaceRemoved", FALSE);
00106
00107 }
00108
00109
00117 void wpas_dbus_signal_scan_done(struct wpa_supplicant *wpa_s, int success)
00118 {
00119 struct wpas_dbus_priv *iface;
00120 DBusMessage *msg;
00121 dbus_bool_t succ;
00122
00123 iface = wpa_s->global->dbus;
00124
00125
00126 if (iface == NULL)
00127 return;
00128
00129 msg = dbus_message_new_signal(wpa_s->dbus_new_path,
00130 WPAS_DBUS_NEW_IFACE_INTERFACE,
00131 "ScanDone");
00132 if (msg == NULL)
00133 return;
00134
00135 succ = success ? TRUE : FALSE;
00136 if (dbus_message_append_args(msg, DBUS_TYPE_BOOLEAN, &succ,
00137 DBUS_TYPE_INVALID))
00138 dbus_connection_send(iface->con, msg, NULL);
00139 else
00140 wpa_printf(MSG_ERROR, "dbus: Failed to construct signal");
00141 dbus_message_unref(msg);
00142 }
00143
00144
00154 static void wpas_dbus_signal_bss(struct wpa_supplicant *wpa_s,
00155 const char *bss_obj_path,
00156 const char *sig_name, int properties)
00157 {
00158 struct wpas_dbus_priv *iface;
00159 DBusMessage *msg;
00160 DBusMessageIter iter, iter_dict;
00161
00162 iface = wpa_s->global->dbus;
00163
00164
00165 if (iface == NULL)
00166 return;
00167
00168 msg = dbus_message_new_signal(wpa_s->dbus_new_path,
00169 WPAS_DBUS_NEW_IFACE_INTERFACE,
00170 sig_name);
00171 if (msg == NULL)
00172 return;
00173
00174 dbus_message_iter_init_append(msg, &iter);
00175 if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_OBJECT_PATH,
00176 &bss_obj_path))
00177 goto err;
00178
00179 if (properties) {
00180 if (!wpa_dbus_dict_open_write(&iter, &iter_dict))
00181 goto err;
00182
00183 wpa_dbus_get_object_properties(iface, bss_obj_path,
00184 WPAS_DBUS_NEW_IFACE_BSS,
00185 &iter_dict);
00186
00187 if (!wpa_dbus_dict_close_write(&iter, &iter_dict))
00188 goto err;
00189 }
00190
00191 dbus_connection_send(iface->con, msg, NULL);
00192 dbus_message_unref(msg);
00193 return;
00194
00195 err:
00196 wpa_printf(MSG_ERROR, "dbus: Failed to construct signal");
00197 dbus_message_unref(msg);
00198 }
00199
00200
00208 static void wpas_dbus_signal_bss_added(struct wpa_supplicant *wpa_s,
00209 const char *bss_obj_path)
00210 {
00211 wpas_dbus_signal_bss(wpa_s, bss_obj_path, "BSSAdded", TRUE);
00212 }
00213
00214
00222 static void wpas_dbus_signal_bss_removed(struct wpa_supplicant *wpa_s,
00223 const char *bss_obj_path)
00224 {
00225 wpas_dbus_signal_bss(wpa_s, bss_obj_path, "BSSRemoved", FALSE);
00226 }
00227
00228
00237 static void wpas_dbus_signal_blob(struct wpa_supplicant *wpa_s,
00238 const char *name, const char *sig_name)
00239 {
00240 struct wpas_dbus_priv *iface;
00241 DBusMessage *msg;
00242
00243 iface = wpa_s->global->dbus;
00244
00245
00246 if (iface == NULL)
00247 return;
00248
00249 msg = dbus_message_new_signal(wpa_s->dbus_new_path,
00250 WPAS_DBUS_NEW_IFACE_INTERFACE,
00251 sig_name);
00252 if (msg == NULL)
00253 return;
00254
00255 if (dbus_message_append_args(msg, DBUS_TYPE_STRING, &name,
00256 DBUS_TYPE_INVALID))
00257 dbus_connection_send(iface->con, msg, NULL);
00258 else
00259 wpa_printf(MSG_ERROR, "dbus: Failed to construct signal");
00260 dbus_message_unref(msg);
00261 }
00262
00263
00271 void wpas_dbus_signal_blob_added(struct wpa_supplicant *wpa_s,
00272 const char *name)
00273 {
00274 wpas_dbus_signal_blob(wpa_s, name, "BlobAdded");
00275 }
00276
00277
00285 void wpas_dbus_signal_blob_removed(struct wpa_supplicant *wpa_s,
00286 const char *name)
00287 {
00288 wpas_dbus_signal_blob(wpa_s, name, "BlobRemoved");
00289 }
00290
00291
00301 static void wpas_dbus_signal_network(struct wpa_supplicant *wpa_s,
00302 int id, const char *sig_name,
00303 int properties)
00304 {
00305 struct wpas_dbus_priv *iface;
00306 DBusMessage *msg;
00307 DBusMessageIter iter, iter_dict;
00308 char net_obj_path[WPAS_DBUS_OBJECT_PATH_MAX], *path;
00309
00310 iface = wpa_s->global->dbus;
00311
00312
00313 if (iface == NULL)
00314 return;
00315
00316 os_snprintf(net_obj_path, WPAS_DBUS_OBJECT_PATH_MAX,
00317 "%s/" WPAS_DBUS_NEW_NETWORKS_PART "/%u",
00318 wpa_s->dbus_new_path, id);
00319
00320 msg = dbus_message_new_signal(wpa_s->dbus_new_path,
00321 WPAS_DBUS_NEW_IFACE_INTERFACE,
00322 sig_name);
00323 if (msg == NULL)
00324 return;
00325
00326 dbus_message_iter_init_append(msg, &iter);
00327 path = net_obj_path;
00328 if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_OBJECT_PATH,
00329 &path))
00330 goto err;
00331
00332 if (properties) {
00333 if (!wpa_dbus_dict_open_write(&iter, &iter_dict))
00334 goto err;
00335
00336 wpa_dbus_get_object_properties(iface, net_obj_path,
00337 WPAS_DBUS_NEW_IFACE_NETWORK,
00338 &iter_dict);
00339
00340 if (!wpa_dbus_dict_close_write(&iter, &iter_dict))
00341 goto err;
00342 }
00343
00344 dbus_connection_send(iface->con, msg, NULL);
00345
00346 dbus_message_unref(msg);
00347 return;
00348
00349 err:
00350 wpa_printf(MSG_ERROR, "dbus: Failed to construct signal");
00351 dbus_message_unref(msg);
00352 }
00353
00354
00362 static void wpas_dbus_signal_network_added(struct wpa_supplicant *wpa_s,
00363 int id)
00364 {
00365 wpas_dbus_signal_network(wpa_s, id, "NetworkAdded", TRUE);
00366 }
00367
00368
00376 static void wpas_dbus_signal_network_removed(struct wpa_supplicant *wpa_s,
00377 int id)
00378 {
00379 wpas_dbus_signal_network(wpa_s, id, "NetworkRemoved", FALSE);
00380 }
00381
00382
00390 void wpas_dbus_signal_network_selected(struct wpa_supplicant *wpa_s, int id)
00391 {
00392 wpas_dbus_signal_network(wpa_s, id, "NetworkSelected", FALSE);
00393 }
00394
00395
00404 void wpas_dbus_signal_network_enabled_changed(struct wpa_supplicant *wpa_s,
00405 struct wpa_ssid *ssid)
00406 {
00407
00408 char path[WPAS_DBUS_OBJECT_PATH_MAX];
00409 os_snprintf(path, WPAS_DBUS_OBJECT_PATH_MAX,
00410 "%s/" WPAS_DBUS_NEW_NETWORKS_PART "/%d",
00411 wpa_s->dbus_new_path, ssid->id);
00412
00413 wpa_dbus_mark_property_changed(wpa_s->global->dbus, path,
00414 WPAS_DBUS_NEW_IFACE_NETWORK, "Enabled");
00415 }
00416
00417
00418 #ifdef CONFIG_WPS
00419
00426 void wpas_dbus_signal_wps_event_success(struct wpa_supplicant *wpa_s)
00427 {
00428
00429 DBusMessage *msg;
00430 DBusMessageIter iter, dict_iter;
00431 struct wpas_dbus_priv *iface;
00432 char *key = "success";
00433
00434 iface = wpa_s->global->dbus;
00435
00436
00437 if (iface == NULL)
00438 return;
00439
00440 msg = dbus_message_new_signal(wpa_s->dbus_new_path,
00441 WPAS_DBUS_NEW_IFACE_WPS, "Event");
00442 if (msg == NULL)
00443 return;
00444
00445 dbus_message_iter_init_append(msg, &iter);
00446
00447 if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &key) ||
00448 !wpa_dbus_dict_open_write(&iter, &dict_iter) ||
00449 !wpa_dbus_dict_close_write(&iter, &dict_iter))
00450 wpa_printf(MSG_ERROR, "dbus: Failed to construct signal");
00451 else
00452 dbus_connection_send(iface->con, msg, NULL);
00453
00454 dbus_message_unref(msg);
00455 }
00456
00457
00465 void wpas_dbus_signal_wps_event_fail(struct wpa_supplicant *wpa_s,
00466 struct wps_event_fail *fail)
00467 {
00468
00469 DBusMessage *msg;
00470 DBusMessageIter iter, dict_iter;
00471 struct wpas_dbus_priv *iface;
00472 char *key = "fail";
00473
00474 iface = wpa_s->global->dbus;
00475
00476
00477 if (iface == NULL)
00478 return;
00479
00480 msg = dbus_message_new_signal(wpa_s->dbus_new_path,
00481 WPAS_DBUS_NEW_IFACE_WPS, "Event");
00482 if (msg == NULL)
00483 return;
00484
00485 dbus_message_iter_init_append(msg, &iter);
00486
00487 if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &key) ||
00488 !wpa_dbus_dict_open_write(&iter, &dict_iter) ||
00489 !wpa_dbus_dict_append_int32(&dict_iter, "msg", fail->msg) ||
00490 !wpa_dbus_dict_close_write(&iter, &dict_iter))
00491 wpa_printf(MSG_ERROR, "dbus: Failed to construct signal");
00492 else
00493 dbus_connection_send(iface->con, msg, NULL);
00494
00495 dbus_message_unref(msg);
00496 }
00497
00498
00506 void wpas_dbus_signal_wps_event_m2d(struct wpa_supplicant *wpa_s,
00507 struct wps_event_m2d *m2d)
00508 {
00509
00510 DBusMessage *msg;
00511 DBusMessageIter iter, dict_iter;
00512 struct wpas_dbus_priv *iface;
00513 char *key = "m2d";
00514
00515 iface = wpa_s->global->dbus;
00516
00517
00518 if (iface == NULL)
00519 return;
00520
00521 msg = dbus_message_new_signal(wpa_s->dbus_new_path,
00522 WPAS_DBUS_NEW_IFACE_WPS, "Event");
00523 if (msg == NULL)
00524 return;
00525
00526 dbus_message_iter_init_append(msg, &iter);
00527
00528 if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &key) ||
00529 !wpa_dbus_dict_open_write(&iter, &dict_iter) ||
00530 !wpa_dbus_dict_append_uint16(&dict_iter, "config_methods",
00531 m2d->config_methods) ||
00532 !wpa_dbus_dict_append_byte_array(&dict_iter, "manufacturer",
00533 (const char *) m2d->manufacturer,
00534 m2d->manufacturer_len) ||
00535 !wpa_dbus_dict_append_byte_array(&dict_iter, "model_name",
00536 (const char *) m2d->model_name,
00537 m2d->model_name_len) ||
00538 !wpa_dbus_dict_append_byte_array(&dict_iter, "model_number",
00539 (const char *) m2d->model_number,
00540 m2d->model_number_len) ||
00541 !wpa_dbus_dict_append_byte_array(&dict_iter, "serial_number",
00542 (const char *)
00543 m2d->serial_number,
00544 m2d->serial_number_len) ||
00545 !wpa_dbus_dict_append_byte_array(&dict_iter, "dev_name",
00546 (const char *) m2d->dev_name,
00547 m2d->dev_name_len) ||
00548 !wpa_dbus_dict_append_byte_array(&dict_iter, "primary_dev_type",
00549 (const char *)
00550 m2d->primary_dev_type, 8) ||
00551 !wpa_dbus_dict_append_uint16(&dict_iter, "config_error",
00552 m2d->config_error) ||
00553 !wpa_dbus_dict_append_uint16(&dict_iter, "dev_password_id",
00554 m2d->dev_password_id) ||
00555 !wpa_dbus_dict_close_write(&iter, &dict_iter))
00556 wpa_printf(MSG_ERROR, "dbus: Failed to construct signal");
00557 else
00558 dbus_connection_send(iface->con, msg, NULL);
00559
00560 dbus_message_unref(msg);
00561 }
00562
00563
00570 void wpas_dbus_signal_wps_cred(struct wpa_supplicant *wpa_s,
00571 const struct wps_credential *cred)
00572 {
00573 DBusMessage *msg;
00574 DBusMessageIter iter, dict_iter;
00575 struct wpas_dbus_priv *iface;
00576 char *auth_type[6];
00577 int at_num = 0;
00578 char *encr_type[4];
00579 int et_num = 0;
00580
00581 iface = wpa_s->global->dbus;
00582
00583
00584 if (iface == NULL)
00585 return;
00586
00587 msg = dbus_message_new_signal(wpa_s->dbus_new_path,
00588 WPAS_DBUS_NEW_IFACE_WPS,
00589 "Credentials");
00590 if (msg == NULL)
00591 return;
00592
00593 dbus_message_iter_init_append(msg, &iter);
00594 if (!wpa_dbus_dict_open_write(&iter, &dict_iter))
00595 goto nomem;
00596
00597 if (cred->auth_type & WPS_AUTH_OPEN)
00598 auth_type[at_num++] = "open";
00599 if (cred->auth_type & WPS_AUTH_WPAPSK)
00600 auth_type[at_num++] = "wpa-psk";
00601 if (cred->auth_type & WPS_AUTH_SHARED)
00602 auth_type[at_num++] = "shared";
00603 if (cred->auth_type & WPS_AUTH_WPA)
00604 auth_type[at_num++] = "wpa-eap";
00605 if (cred->auth_type & WPS_AUTH_WPA2)
00606 auth_type[at_num++] = "wpa2-eap";
00607 if (cred->auth_type & WPS_AUTH_WPA2PSK)
00608 auth_type[at_num++] =
00609 "wpa2-psk";
00610
00611 if (cred->encr_type & WPS_ENCR_NONE)
00612 encr_type[et_num++] = "none";
00613 if (cred->encr_type & WPS_ENCR_WEP)
00614 encr_type[et_num++] = "wep";
00615 if (cred->encr_type & WPS_ENCR_TKIP)
00616 encr_type[et_num++] = "tkip";
00617 if (cred->encr_type & WPS_ENCR_AES)
00618 encr_type[et_num++] = "aes";
00619
00620 if (wpa_s->current_ssid) {
00621 if (!wpa_dbus_dict_append_byte_array(
00622 &dict_iter, "BSSID",
00623 (const char *) wpa_s->current_ssid->bssid,
00624 ETH_ALEN))
00625 goto nomem;
00626 }
00627
00628 if (!wpa_dbus_dict_append_byte_array(&dict_iter, "SSID",
00629 (const char *) cred->ssid,
00630 cred->ssid_len) ||
00631 !wpa_dbus_dict_append_string_array(&dict_iter, "AuthType",
00632 (const char **) auth_type,
00633 at_num) ||
00634 !wpa_dbus_dict_append_string_array(&dict_iter, "EncrType",
00635 (const char **) encr_type,
00636 et_num) ||
00637 !wpa_dbus_dict_append_byte_array(&dict_iter, "Key",
00638 (const char *) cred->key,
00639 cred->key_len) ||
00640 !wpa_dbus_dict_append_uint32(&dict_iter, "KeyIndex",
00641 cred->key_idx) ||
00642 !wpa_dbus_dict_close_write(&iter, &dict_iter))
00643 goto nomem;
00644
00645 dbus_connection_send(iface->con, msg, NULL);
00646
00647 nomem:
00648 dbus_message_unref(msg);
00649 }
00650
00651 #endif
00652
00653
00662 void wpas_dbus_signal_prop_changed(struct wpa_supplicant *wpa_s,
00663 enum wpas_dbus_prop property)
00664 {
00665 WPADBusPropertyAccessor getter;
00666 char *prop;
00667
00668 switch (property) {
00669 case WPAS_DBUS_PROP_AP_SCAN:
00670 getter = (WPADBusPropertyAccessor) wpas_dbus_getter_ap_scan;
00671 prop = "ApScan";
00672 break;
00673 case WPAS_DBUS_PROP_SCANNING:
00674 getter = (WPADBusPropertyAccessor) wpas_dbus_getter_scanning;
00675 prop = "Scanning";
00676 break;
00677 case WPAS_DBUS_PROP_STATE:
00678 getter = (WPADBusPropertyAccessor) wpas_dbus_getter_state;
00679 prop = "State";
00680 break;
00681 case WPAS_DBUS_PROP_CURRENT_BSS:
00682 getter = (WPADBusPropertyAccessor)
00683 wpas_dbus_getter_current_bss;
00684 prop = "CurrentBSS";
00685 break;
00686 case WPAS_DBUS_PROP_CURRENT_NETWORK:
00687 getter = (WPADBusPropertyAccessor)
00688 wpas_dbus_getter_current_network;
00689 prop = "CurrentNetwork";
00690 break;
00691 default:
00692 wpa_printf(MSG_ERROR, "dbus: %s: Unknown Property value %d",
00693 __func__, property);
00694 return;
00695 }
00696
00697 wpa_dbus_mark_property_changed(wpa_s->global->dbus,
00698 wpa_s->dbus_new_path,
00699 WPAS_DBUS_NEW_IFACE_INTERFACE, prop);
00700 }
00701
00702
00712 void wpas_dbus_bss_signal_prop_changed(struct wpa_supplicant *wpa_s,
00713 enum wpas_dbus_bss_prop property,
00714 unsigned int id)
00715 {
00716 char path[WPAS_DBUS_OBJECT_PATH_MAX];
00717 char *prop;
00718
00719 switch (property) {
00720 case WPAS_DBUS_BSS_PROP_SIGNAL:
00721 prop = "Signal";
00722 break;
00723 case WPAS_DBUS_BSS_PROP_FREQ:
00724 prop = "Frequency";
00725 break;
00726 case WPAS_DBUS_BSS_PROP_MODE:
00727 prop = "Mode";
00728 break;
00729 case WPAS_DBUS_BSS_PROP_PRIVACY:
00730 prop = "Privacy";
00731 break;
00732 case WPAS_DBUS_BSS_PROP_RATES:
00733 prop = "Rates";
00734 break;
00735 case WPAS_DBUS_BSS_PROP_WPA:
00736 prop = "WPA";
00737 break;
00738 case WPAS_DBUS_BSS_PROP_RSN:
00739 prop = "RSN";
00740 break;
00741 case WPAS_DBUS_BSS_PROP_IES:
00742 prop = "IEs";
00743 break;
00744 default:
00745 wpa_printf(MSG_ERROR, "dbus: %s: Unknown Property value %d",
00746 __func__, property);
00747 return;
00748 }
00749
00750 os_snprintf(path, WPAS_DBUS_OBJECT_PATH_MAX,
00751 "%s/" WPAS_DBUS_NEW_BSSIDS_PART "/%u",
00752 wpa_s->dbus_new_path, id);
00753
00754 wpa_dbus_mark_property_changed(wpa_s->global->dbus, path,
00755 WPAS_DBUS_NEW_IFACE_BSS, prop);
00756 }
00757
00758
00765 void wpas_dbus_signal_debug_level_changed(struct wpa_global *global)
00766 {
00767 wpa_dbus_mark_property_changed(global->dbus, WPAS_DBUS_NEW_PATH,
00768 WPAS_DBUS_NEW_INTERFACE,
00769 "DebugLevel");
00770 }
00771
00772
00779 void wpas_dbus_signal_debug_timestamp_changed(struct wpa_global *global)
00780 {
00781 wpa_dbus_mark_property_changed(global->dbus, WPAS_DBUS_NEW_PATH,
00782 WPAS_DBUS_NEW_INTERFACE,
00783 "DebugTimestamp");
00784 }
00785
00786
00793 void wpas_dbus_signal_debug_show_keys_changed(struct wpa_global *global)
00794 {
00795 wpa_dbus_mark_property_changed(global->dbus, WPAS_DBUS_NEW_PATH,
00796 WPAS_DBUS_NEW_INTERFACE,
00797 "DebugShowKeys");
00798 }
00799
00800
00801 static void wpas_dbus_register(struct wpa_dbus_object_desc *obj_desc,
00802 void *priv,
00803 WPADBusArgumentFreeFunction priv_free,
00804 const struct wpa_dbus_method_desc *methods,
00805 const struct wpa_dbus_property_desc *properties,
00806 const struct wpa_dbus_signal_desc *signals)
00807 {
00808 int n;
00809
00810 obj_desc->user_data = priv;
00811 obj_desc->user_data_free_func = priv_free;
00812 obj_desc->methods = methods;
00813 obj_desc->properties = properties;
00814 obj_desc->signals = signals;
00815
00816 for (n = 0; properties && properties->dbus_property; properties++)
00817 n++;
00818
00819 obj_desc->prop_changed_flags = os_zalloc(n);
00820 if (!obj_desc->prop_changed_flags)
00821 wpa_printf(MSG_DEBUG, "dbus: %s: can't register handlers",
00822 __func__);
00823 }
00824
00825
00826 static const struct wpa_dbus_method_desc wpas_dbus_global_methods[] = {
00827 { "CreateInterface", WPAS_DBUS_NEW_INTERFACE,
00828 (WPADBusMethodHandler) &wpas_dbus_handler_create_interface,
00829 {
00830 { "args", "a{sv}", ARG_IN },
00831 { "path", "o", ARG_OUT },
00832 END_ARGS
00833 }
00834 },
00835 { "RemoveInterface", WPAS_DBUS_NEW_INTERFACE,
00836 (WPADBusMethodHandler) &wpas_dbus_handler_remove_interface,
00837 {
00838 { "path", "o", ARG_IN },
00839 END_ARGS
00840 }
00841 },
00842 { "GetInterface", WPAS_DBUS_NEW_INTERFACE,
00843 (WPADBusMethodHandler) &wpas_dbus_handler_get_interface,
00844 {
00845 { "ifname", "s", ARG_IN },
00846 { "path", "o", ARG_OUT },
00847 END_ARGS
00848 }
00849 },
00850 { NULL, NULL, NULL, { END_ARGS } }
00851 };
00852
00853 static const struct wpa_dbus_property_desc wpas_dbus_global_properties[] = {
00854 { "DebugLevel", WPAS_DBUS_NEW_INTERFACE, "s",
00855 (WPADBusPropertyAccessor) wpas_dbus_getter_debug_level,
00856 (WPADBusPropertyAccessor) wpas_dbus_setter_debug_level,
00857 RW
00858 },
00859 { "DebugTimestamp", WPAS_DBUS_NEW_INTERFACE, "b",
00860 (WPADBusPropertyAccessor) wpas_dbus_getter_debug_timestamp,
00861 (WPADBusPropertyAccessor) wpas_dbus_setter_debug_timestamp,
00862 RW
00863 },
00864 { "DebugShowKeys", WPAS_DBUS_NEW_INTERFACE, "b",
00865 (WPADBusPropertyAccessor) wpas_dbus_getter_debug_show_keys,
00866 (WPADBusPropertyAccessor) wpas_dbus_setter_debug_show_keys,
00867 RW
00868 },
00869 { "Interfaces", WPAS_DBUS_NEW_INTERFACE, "ao",
00870 (WPADBusPropertyAccessor) &wpas_dbus_getter_interfaces,
00871 NULL,
00872 R
00873 },
00874 { "EapMethods", WPAS_DBUS_NEW_INTERFACE, "as",
00875 (WPADBusPropertyAccessor) wpas_dbus_getter_eap_methods,
00876 NULL,
00877 R
00878 },
00879 { NULL, NULL, NULL, NULL, NULL, 0 }
00880 };
00881
00882 static const struct wpa_dbus_signal_desc wpas_dbus_global_signals[] = {
00883 { "InterfaceAdded", WPAS_DBUS_NEW_INTERFACE,
00884 {
00885 { "path", "o", ARG_OUT },
00886 { "properties", "a{sv}", ARG_OUT },
00887 END_ARGS
00888 }
00889 },
00890 { "InterfaceRemoved", WPAS_DBUS_NEW_INTERFACE,
00891 {
00892 { "path", "o", ARG_OUT },
00893 END_ARGS
00894 }
00895 },
00896 { "PropertiesChanged", WPAS_DBUS_NEW_INTERFACE,
00897 {
00898 { "properties", "a{sv}", ARG_OUT },
00899 END_ARGS
00900 }
00901 },
00902 { NULL, NULL, { END_ARGS } }
00903 };
00904
00905
00914 int wpas_dbus_ctrl_iface_init(struct wpas_dbus_priv *priv)
00915 {
00916 struct wpa_dbus_object_desc *obj_desc;
00917 int ret;
00918
00919 obj_desc = os_zalloc(sizeof(struct wpa_dbus_object_desc));
00920 if (!obj_desc) {
00921 wpa_printf(MSG_ERROR, "Not enough memory "
00922 "to create object description");
00923 return -1;
00924 }
00925
00926 wpas_dbus_register(obj_desc, priv->global, NULL,
00927 wpas_dbus_global_methods,
00928 wpas_dbus_global_properties,
00929 wpas_dbus_global_signals);
00930
00931 wpa_printf(MSG_DEBUG, "dbus: Register D-Bus object '%s'",
00932 WPAS_DBUS_NEW_PATH);
00933 ret = wpa_dbus_ctrl_iface_init(priv, WPAS_DBUS_NEW_PATH,
00934 WPAS_DBUS_NEW_SERVICE,
00935 obj_desc);
00936 if (ret < 0)
00937 free_dbus_object_desc(obj_desc);
00938 else
00939 priv->dbus_new_initialized = 1;
00940
00941 return ret;
00942 }
00943
00944
00953 void wpas_dbus_ctrl_iface_deinit(struct wpas_dbus_priv *iface)
00954 {
00955 if (!iface->dbus_new_initialized)
00956 return;
00957 wpa_printf(MSG_DEBUG, "dbus: Unregister D-Bus object '%s'",
00958 WPAS_DBUS_NEW_PATH);
00959 dbus_connection_unregister_object_path(iface->con,
00960 WPAS_DBUS_NEW_PATH);
00961 }
00962
00963
00964 static void wpa_dbus_free(void *ptr)
00965 {
00966 os_free(ptr);
00967 }
00968
00969
00970 static const struct wpa_dbus_property_desc wpas_dbus_network_properties[] = {
00971 { "Properties", WPAS_DBUS_NEW_IFACE_NETWORK, "a{sv}",
00972 (WPADBusPropertyAccessor) wpas_dbus_getter_network_properties,
00973 (WPADBusPropertyAccessor) wpas_dbus_setter_network_properties,
00974 RW
00975 },
00976 { "Enabled", WPAS_DBUS_NEW_IFACE_NETWORK, "b",
00977 (WPADBusPropertyAccessor) wpas_dbus_getter_enabled,
00978 (WPADBusPropertyAccessor) wpas_dbus_setter_enabled,
00979 RW
00980 },
00981 { NULL, NULL, NULL, NULL, NULL, 0 }
00982 };
00983
00984
00985 static const struct wpa_dbus_signal_desc wpas_dbus_network_signals[] = {
00986 { "PropertiesChanged", WPAS_DBUS_NEW_IFACE_NETWORK,
00987 {
00988 { "properties", "a{sv}", ARG_OUT },
00989 END_ARGS
00990 }
00991 },
00992 { NULL, NULL, { END_ARGS } }
00993 };
00994
00995
01004 int wpas_dbus_register_network(struct wpa_supplicant *wpa_s,
01005 struct wpa_ssid *ssid)
01006 {
01007 struct wpas_dbus_priv *ctrl_iface;
01008 struct wpa_dbus_object_desc *obj_desc;
01009 struct network_handler_args *arg;
01010 char net_obj_path[WPAS_DBUS_OBJECT_PATH_MAX];
01011
01012
01013 if (wpa_s == NULL || wpa_s->global == NULL)
01014 return 0;
01015 ctrl_iface = wpa_s->global->dbus;
01016 if (ctrl_iface == NULL)
01017 return 0;
01018
01019 os_snprintf(net_obj_path, WPAS_DBUS_OBJECT_PATH_MAX,
01020 "%s/" WPAS_DBUS_NEW_NETWORKS_PART "/%u",
01021 wpa_s->dbus_new_path, ssid->id);
01022
01023 wpa_printf(MSG_DEBUG, "dbus: Register network object '%s'",
01024 net_obj_path);
01025 obj_desc = os_zalloc(sizeof(struct wpa_dbus_object_desc));
01026 if (!obj_desc) {
01027 wpa_printf(MSG_ERROR, "Not enough memory "
01028 "to create object description");
01029 goto err;
01030 }
01031
01032
01033 arg = os_zalloc(sizeof(struct network_handler_args));
01034 if (!arg) {
01035 wpa_printf(MSG_ERROR, "Not enough memory "
01036 "to create arguments for method");
01037 goto err;
01038 }
01039
01040 arg->wpa_s = wpa_s;
01041 arg->ssid = ssid;
01042
01043 wpas_dbus_register(obj_desc, arg, wpa_dbus_free, NULL,
01044 wpas_dbus_network_properties,
01045 wpas_dbus_network_signals);
01046
01047 if (wpa_dbus_register_object_per_iface(ctrl_iface, net_obj_path,
01048 wpa_s->ifname, obj_desc))
01049 goto err;
01050
01051 wpas_dbus_signal_network_added(wpa_s, ssid->id);
01052
01053 return 0;
01054
01055 err:
01056 free_dbus_object_desc(obj_desc);
01057 return -1;
01058 }
01059
01060
01069 int wpas_dbus_unregister_network(struct wpa_supplicant *wpa_s, int nid)
01070 {
01071 struct wpas_dbus_priv *ctrl_iface;
01072 char net_obj_path[WPAS_DBUS_OBJECT_PATH_MAX];
01073 int ret;
01074
01075
01076 if (wpa_s == NULL || wpa_s->global == NULL ||
01077 wpa_s->dbus_new_path == NULL)
01078 return 0;
01079 ctrl_iface = wpa_s->global->dbus;
01080 if (ctrl_iface == NULL)
01081 return 0;
01082
01083 os_snprintf(net_obj_path, WPAS_DBUS_OBJECT_PATH_MAX,
01084 "%s/" WPAS_DBUS_NEW_NETWORKS_PART "/%u",
01085 wpa_s->dbus_new_path, nid);
01086
01087 wpa_printf(MSG_DEBUG, "dbus: Unregister network object '%s'",
01088 net_obj_path);
01089 ret = wpa_dbus_unregister_object_per_iface(ctrl_iface, net_obj_path);
01090
01091 if (!ret)
01092 wpas_dbus_signal_network_removed(wpa_s, nid);
01093
01094 return ret;
01095 }
01096
01097
01098 static const struct wpa_dbus_property_desc wpas_dbus_bss_properties[] = {
01099 { "SSID", WPAS_DBUS_NEW_IFACE_BSS, "ay",
01100 (WPADBusPropertyAccessor) wpas_dbus_getter_bss_ssid,
01101 NULL,
01102 R
01103 },
01104 { "BSSID", WPAS_DBUS_NEW_IFACE_BSS, "ay",
01105 (WPADBusPropertyAccessor) wpas_dbus_getter_bss_bssid,
01106 NULL,
01107 R
01108 },
01109 { "Privacy", WPAS_DBUS_NEW_IFACE_BSS, "b",
01110 (WPADBusPropertyAccessor) wpas_dbus_getter_bss_privacy,
01111 NULL,
01112 R
01113 },
01114 { "Mode", WPAS_DBUS_NEW_IFACE_BSS, "s",
01115 (WPADBusPropertyAccessor) wpas_dbus_getter_bss_mode,
01116 NULL,
01117 R
01118 },
01119 { "Signal", WPAS_DBUS_NEW_IFACE_BSS, "n",
01120 (WPADBusPropertyAccessor) wpas_dbus_getter_bss_signal,
01121 NULL,
01122 R
01123 },
01124 { "Frequency", WPAS_DBUS_NEW_IFACE_BSS, "q",
01125 (WPADBusPropertyAccessor) wpas_dbus_getter_bss_frequency,
01126 NULL,
01127 R
01128 },
01129 { "Rates", WPAS_DBUS_NEW_IFACE_BSS, "au",
01130 (WPADBusPropertyAccessor) wpas_dbus_getter_bss_rates,
01131 NULL,
01132 R
01133 },
01134 { "WPA", WPAS_DBUS_NEW_IFACE_BSS, "a{sv}",
01135 (WPADBusPropertyAccessor) wpas_dbus_getter_bss_wpa,
01136 NULL,
01137 R
01138 },
01139 { "RSN", WPAS_DBUS_NEW_IFACE_BSS, "a{sv}",
01140 (WPADBusPropertyAccessor) wpas_dbus_getter_bss_rsn,
01141 NULL,
01142 R
01143 },
01144 { "IEs", WPAS_DBUS_NEW_IFACE_BSS, "ay",
01145 (WPADBusPropertyAccessor) wpas_dbus_getter_bss_ies,
01146 NULL,
01147 R
01148 },
01149 { NULL, NULL, NULL, NULL, NULL, 0 }
01150 };
01151
01152
01153 static const struct wpa_dbus_signal_desc wpas_dbus_bss_signals[] = {
01154 { "PropertiesChanged", WPAS_DBUS_NEW_IFACE_BSS,
01155 {
01156 { "properties", "a{sv}", ARG_OUT },
01157 END_ARGS
01158 }
01159 },
01160 { NULL, NULL, { END_ARGS } }
01161 };
01162
01163
01173 int wpas_dbus_unregister_bss(struct wpa_supplicant *wpa_s,
01174 u8 bssid[ETH_ALEN], unsigned int id)
01175 {
01176 struct wpas_dbus_priv *ctrl_iface;
01177 char bss_obj_path[WPAS_DBUS_OBJECT_PATH_MAX];
01178
01179
01180 if (wpa_s == NULL || wpa_s->global == NULL)
01181 return 0;
01182 ctrl_iface = wpa_s->global->dbus;
01183 if (ctrl_iface == NULL)
01184 return 0;
01185
01186 os_snprintf(bss_obj_path, WPAS_DBUS_OBJECT_PATH_MAX,
01187 "%s/" WPAS_DBUS_NEW_BSSIDS_PART "/%u",
01188 wpa_s->dbus_new_path, id);
01189
01190 wpa_printf(MSG_DEBUG, "dbus: Unregister BSS object '%s'",
01191 bss_obj_path);
01192 if (wpa_dbus_unregister_object_per_iface(ctrl_iface, bss_obj_path)) {
01193 wpa_printf(MSG_ERROR, "dbus: Cannot unregister BSS object %s",
01194 bss_obj_path);
01195 return -1;
01196 }
01197
01198 wpas_dbus_signal_bss_removed(wpa_s, bss_obj_path);
01199
01200 return 0;
01201 }
01202
01203
01213 int wpas_dbus_register_bss(struct wpa_supplicant *wpa_s,
01214 u8 bssid[ETH_ALEN], unsigned int id)
01215 {
01216 struct wpas_dbus_priv *ctrl_iface;
01217 struct wpa_dbus_object_desc *obj_desc;
01218 char bss_obj_path[WPAS_DBUS_OBJECT_PATH_MAX];
01219 struct bss_handler_args *arg;
01220
01221
01222 if (wpa_s == NULL || wpa_s->global == NULL)
01223 return 0;
01224 ctrl_iface = wpa_s->global->dbus;
01225 if (ctrl_iface == NULL)
01226 return 0;
01227
01228 os_snprintf(bss_obj_path, WPAS_DBUS_OBJECT_PATH_MAX,
01229 "%s/" WPAS_DBUS_NEW_BSSIDS_PART "/%u",
01230 wpa_s->dbus_new_path, id);
01231
01232 obj_desc = os_zalloc(sizeof(struct wpa_dbus_object_desc));
01233 if (!obj_desc) {
01234 wpa_printf(MSG_ERROR, "Not enough memory "
01235 "to create object description");
01236 goto err;
01237 }
01238
01239 arg = os_zalloc(sizeof(struct bss_handler_args));
01240 if (!arg) {
01241 wpa_printf(MSG_ERROR, "Not enough memory "
01242 "to create arguments for handler");
01243 goto err;
01244 }
01245 arg->wpa_s = wpa_s;
01246 arg->id = id;
01247
01248 wpas_dbus_register(obj_desc, arg, wpa_dbus_free, NULL,
01249 wpas_dbus_bss_properties,
01250 wpas_dbus_bss_signals);
01251
01252 wpa_printf(MSG_DEBUG, "dbus: Register BSS object '%s'",
01253 bss_obj_path);
01254 if (wpa_dbus_register_object_per_iface(ctrl_iface, bss_obj_path,
01255 wpa_s->ifname, obj_desc)) {
01256 wpa_printf(MSG_ERROR,
01257 "Cannot register BSSID dbus object %s.",
01258 bss_obj_path);
01259 goto err;
01260 }
01261
01262 wpas_dbus_signal_bss_added(wpa_s, bss_obj_path);
01263
01264 return 0;
01265
01266 err:
01267 free_dbus_object_desc(obj_desc);
01268 return -1;
01269 }
01270
01271
01272 static const struct wpa_dbus_method_desc wpas_dbus_interface_methods[] = {
01273 { "Scan", WPAS_DBUS_NEW_IFACE_INTERFACE,
01274 (WPADBusMethodHandler) &wpas_dbus_handler_scan,
01275 {
01276 { "args", "a{sv}", ARG_IN },
01277 END_ARGS
01278 }
01279 },
01280 { "Disconnect", WPAS_DBUS_NEW_IFACE_INTERFACE,
01281 (WPADBusMethodHandler) &wpas_dbus_handler_disconnect,
01282 {
01283 END_ARGS
01284 }
01285 },
01286 { "AddNetwork", WPAS_DBUS_NEW_IFACE_INTERFACE,
01287 (WPADBusMethodHandler) &wpas_dbus_handler_add_network,
01288 {
01289 { "args", "a{sv}", ARG_IN },
01290 { "path", "o", ARG_OUT },
01291 END_ARGS
01292 }
01293 },
01294 { "RemoveNetwork", WPAS_DBUS_NEW_IFACE_INTERFACE,
01295 (WPADBusMethodHandler) &wpas_dbus_handler_remove_network,
01296 {
01297 { "path", "o", ARG_IN },
01298 END_ARGS
01299 }
01300 },
01301 { "SelectNetwork", WPAS_DBUS_NEW_IFACE_INTERFACE,
01302 (WPADBusMethodHandler) &wpas_dbus_handler_select_network,
01303 {
01304 { "path", "o", ARG_IN },
01305 END_ARGS
01306 }
01307 },
01308 { "AddBlob", WPAS_DBUS_NEW_IFACE_INTERFACE,
01309 (WPADBusMethodHandler) &wpas_dbus_handler_add_blob,
01310 {
01311 { "name", "s", ARG_IN },
01312 { "data", "ay", ARG_IN },
01313 END_ARGS
01314 }
01315 },
01316 { "GetBlob", WPAS_DBUS_NEW_IFACE_INTERFACE,
01317 (WPADBusMethodHandler) &wpas_dbus_handler_get_blob,
01318 {
01319 { "name", "s", ARG_IN },
01320 { "data", "ay", ARG_OUT },
01321 END_ARGS
01322 }
01323 },
01324 { "RemoveBlob", WPAS_DBUS_NEW_IFACE_INTERFACE,
01325 (WPADBusMethodHandler) &wpas_dbus_handler_remove_blob,
01326 {
01327 { "name", "s", ARG_IN },
01328 END_ARGS
01329 }
01330 },
01331 #ifdef CONFIG_WPS
01332 { "Start", WPAS_DBUS_NEW_IFACE_WPS,
01333 (WPADBusMethodHandler) &wpas_dbus_handler_wps_start,
01334 {
01335 { "args", "a{sv}", ARG_IN },
01336 { "output", "a{sv}", ARG_OUT },
01337 END_ARGS
01338 }
01339 },
01340 #endif
01341 { NULL, NULL, NULL, { END_ARGS } }
01342 };
01343
01344 static const struct wpa_dbus_property_desc wpas_dbus_interface_properties[] = {
01345 { "Capabilities", WPAS_DBUS_NEW_IFACE_INTERFACE, "a{sv}",
01346 (WPADBusPropertyAccessor) wpas_dbus_getter_capabilities,
01347 NULL, R
01348 },
01349 { "State", WPAS_DBUS_NEW_IFACE_INTERFACE, "s",
01350 (WPADBusPropertyAccessor) wpas_dbus_getter_state,
01351 NULL, R
01352 },
01353 { "Scanning", WPAS_DBUS_NEW_IFACE_INTERFACE, "b",
01354 (WPADBusPropertyAccessor) wpas_dbus_getter_scanning,
01355 NULL, R
01356 },
01357 { "ApScan", WPAS_DBUS_NEW_IFACE_INTERFACE, "u",
01358 (WPADBusPropertyAccessor) wpas_dbus_getter_ap_scan,
01359 (WPADBusPropertyAccessor) wpas_dbus_setter_ap_scan,
01360 RW
01361 },
01362 { "Ifname", WPAS_DBUS_NEW_IFACE_INTERFACE, "s",
01363 (WPADBusPropertyAccessor) wpas_dbus_getter_ifname,
01364 NULL, R
01365 },
01366 { "Driver", WPAS_DBUS_NEW_IFACE_INTERFACE, "s",
01367 (WPADBusPropertyAccessor) wpas_dbus_getter_driver,
01368 NULL, R
01369 },
01370 { "BridgeIfname", WPAS_DBUS_NEW_IFACE_INTERFACE, "s",
01371 (WPADBusPropertyAccessor) wpas_dbus_getter_bridge_ifname,
01372 NULL, R
01373 },
01374 { "CurrentBSS", WPAS_DBUS_NEW_IFACE_INTERFACE, "o",
01375 (WPADBusPropertyAccessor) wpas_dbus_getter_current_bss,
01376 NULL, R
01377 },
01378 { "CurrentNetwork", WPAS_DBUS_NEW_IFACE_INTERFACE, "o",
01379 (WPADBusPropertyAccessor) wpas_dbus_getter_current_network,
01380 NULL, R
01381 },
01382 { "Blobs", WPAS_DBUS_NEW_IFACE_INTERFACE, "a{say}",
01383 (WPADBusPropertyAccessor) wpas_dbus_getter_blobs,
01384 NULL, R
01385 },
01386 { "BSSs", WPAS_DBUS_NEW_IFACE_INTERFACE, "ao",
01387 (WPADBusPropertyAccessor) wpas_dbus_getter_bsss,
01388 NULL, R
01389 },
01390 { "Networks", WPAS_DBUS_NEW_IFACE_INTERFACE, "ao",
01391 (WPADBusPropertyAccessor) wpas_dbus_getter_networks,
01392 NULL, R
01393 },
01394 #ifdef CONFIG_WPS
01395 { "ProcessCredentials", WPAS_DBUS_NEW_IFACE_WPS, "b",
01396 (WPADBusPropertyAccessor) wpas_dbus_getter_process_credentials,
01397 (WPADBusPropertyAccessor) wpas_dbus_setter_process_credentials,
01398 RW
01399 },
01400 #endif
01401 { NULL, NULL, NULL, NULL, NULL, 0 }
01402 };
01403
01404 static const struct wpa_dbus_signal_desc wpas_dbus_interface_signals[] = {
01405 { "ScanDone", WPAS_DBUS_NEW_IFACE_INTERFACE,
01406 {
01407 { "success", "b", ARG_OUT },
01408 END_ARGS
01409 }
01410 },
01411 { "BSSAdded", WPAS_DBUS_NEW_IFACE_INTERFACE,
01412 {
01413 { "path", "o", ARG_OUT },
01414 { "properties", "a{sv}", ARG_OUT },
01415 END_ARGS
01416 }
01417 },
01418 { "BSSRemoved", WPAS_DBUS_NEW_IFACE_INTERFACE,
01419 {
01420 { "path", "o", ARG_OUT },
01421 END_ARGS
01422 }
01423 },
01424 { "BlobAdded", WPAS_DBUS_NEW_IFACE_INTERFACE,
01425 {
01426 { "name", "s", ARG_OUT },
01427 END_ARGS
01428 }
01429 },
01430 { "BlobRemoved", WPAS_DBUS_NEW_IFACE_INTERFACE,
01431 {
01432 { "name", "s", ARG_OUT },
01433 END_ARGS
01434 }
01435 },
01436 { "NetworkAdded", WPAS_DBUS_NEW_IFACE_INTERFACE,
01437 {
01438 { "path", "o", ARG_OUT },
01439 { "properties", "a{sv}", ARG_OUT },
01440 END_ARGS
01441 }
01442 },
01443 { "NetworkRemoved", WPAS_DBUS_NEW_IFACE_INTERFACE,
01444 {
01445 { "path", "o", ARG_OUT },
01446 END_ARGS
01447 }
01448 },
01449 { "NetworkSelected", WPAS_DBUS_NEW_IFACE_INTERFACE,
01450 {
01451 { "path", "o", ARG_OUT },
01452 END_ARGS
01453 }
01454 },
01455 { "PropertiesChanged", WPAS_DBUS_NEW_IFACE_INTERFACE,
01456 {
01457 { "properties", "a{sv}", ARG_OUT },
01458 END_ARGS
01459 }
01460 },
01461 #ifdef CONFIG_WPS
01462 { "Event", WPAS_DBUS_NEW_IFACE_WPS,
01463 {
01464 { "name", "s", ARG_OUT },
01465 { "args", "a{sv}", ARG_OUT },
01466 END_ARGS
01467 }
01468 },
01469 { "Credentials", WPAS_DBUS_NEW_IFACE_WPS,
01470 {
01471 { "credentials", "a{sv}", ARG_OUT },
01472 END_ARGS
01473 }
01474 },
01475 { "PropertiesChanged", WPAS_DBUS_NEW_IFACE_WPS,
01476 {
01477 { "properties", "a{sv}", ARG_OUT },
01478 END_ARGS
01479 }
01480 },
01481 #endif
01482 { NULL, NULL, { END_ARGS } }
01483 };
01484
01485
01486 int wpas_dbus_register_interface(struct wpa_supplicant *wpa_s)
01487 {
01488
01489 struct wpa_dbus_object_desc *obj_desc = NULL;
01490 struct wpas_dbus_priv *ctrl_iface = wpa_s->global->dbus;
01491 int next;
01492
01493
01494 if (ctrl_iface == NULL)
01495 return 0;
01496
01497
01498 wpa_s->dbus_new_path = os_zalloc(WPAS_DBUS_OBJECT_PATH_MAX);
01499 if (wpa_s->dbus_new_path == NULL)
01500 return -1;
01501 next = ctrl_iface->next_objid++;
01502 os_snprintf(wpa_s->dbus_new_path, WPAS_DBUS_OBJECT_PATH_MAX,
01503 WPAS_DBUS_NEW_PATH_INTERFACES "/%u",
01504 next);
01505
01506 obj_desc = os_zalloc(sizeof(struct wpa_dbus_object_desc));
01507 if (!obj_desc) {
01508 wpa_printf(MSG_ERROR, "Not enough memory "
01509 "to create object description");
01510 goto err;
01511 }
01512
01513 wpas_dbus_register(obj_desc, wpa_s, NULL, wpas_dbus_interface_methods,
01514 wpas_dbus_interface_properties,
01515 wpas_dbus_interface_signals);
01516
01517 wpa_printf(MSG_DEBUG, "dbus: Register interface object '%s'",
01518 wpa_s->dbus_new_path);
01519 if (wpa_dbus_register_object_per_iface(ctrl_iface,
01520 wpa_s->dbus_new_path,
01521 wpa_s->ifname, obj_desc))
01522 goto err;
01523
01524 wpas_dbus_signal_interface_added(wpa_s);
01525
01526 return 0;
01527
01528 err:
01529 os_free(wpa_s->dbus_new_path);
01530 wpa_s->dbus_new_path = NULL;
01531 free_dbus_object_desc(obj_desc);
01532 return -1;
01533 }
01534
01535
01536 int wpas_dbus_unregister_interface(struct wpa_supplicant *wpa_s)
01537 {
01538 struct wpas_dbus_priv *ctrl_iface;
01539
01540
01541 if (wpa_s == NULL || wpa_s->global == NULL)
01542 return 0;
01543 ctrl_iface = wpa_s->global->dbus;
01544 if (ctrl_iface == NULL)
01545 return 0;
01546
01547 wpa_printf(MSG_DEBUG, "dbus: Unregister interface object '%s'",
01548 wpa_s->dbus_new_path);
01549 if (wpa_dbus_unregister_object_per_iface(ctrl_iface,
01550 wpa_s->dbus_new_path))
01551 return -1;
01552
01553 wpas_dbus_signal_interface_removed(wpa_s);
01554
01555 os_free(wpa_s->dbus_new_path);
01556 wpa_s->dbus_new_path = NULL;
01557
01558 return 0;
01559 }
