#include <config.h>
#endif
+#include <stdlib.h>
#include <string.h>
#include <dbus/dbus.h>
#include <connman/log.h>
+#include <connman/dbus.h>
#include "inet.h"
#include "supplicant.h"
enum supplicant_state state;
};
-static GStaticMutex task_mutex = G_STATIC_MUTEX_INIT;
static GSList *task_list = NULL;
static DBusConnection *connection;
return 0;
}
-static void append_entry(DBusMessageIter *dict,
- const char *key, int type, void *val)
-{
- DBusMessageIter entry, value;
- const char *signature;
-
- dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY,
- NULL, &entry);
-
- dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
-
- switch (type) {
- case DBUS_TYPE_STRING:
- signature = DBUS_TYPE_STRING_AS_STRING;
- break;
- case DBUS_TYPE_UINT16:
- signature = DBUS_TYPE_UINT16_AS_STRING;
- break;
- default:
- signature = DBUS_TYPE_VARIANT_AS_STRING;
- break;
- }
-
- dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
- signature, &value);
- dbus_message_iter_append_basic(&value, type, val);
- dbus_message_iter_close_container(&entry, &value);
-
- dbus_message_iter_close_container(dict, &entry);
-}
-
-static void append_array(DBusMessageIter *dict,
- const char *key, int type, void *val, int len)
-{
- DBusMessageIter entry, value, array;
-
- if (type != DBUS_TYPE_BYTE)
- return;
-
- dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY,
- NULL, &entry);
-
- dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
-
- dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
- DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_BYTE_AS_STRING, &value);
-
- dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY,
- DBUS_TYPE_BYTE_AS_STRING, &array);
- dbus_message_iter_append_fixed_array(&array, type, val, len);
- dbus_message_iter_close_container(&value, &array);
-
- dbus_message_iter_close_container(&entry, &value);
-
- dbus_message_iter_close_container(dict, &entry);
-}
-
static int set_network(struct supplicant_task *task,
- const unsigned char *network, int len,
- const char *passphrase)
+ const unsigned char *network, int len,
+ const char *security, const char *passphrase)
{
DBusMessage *message, *reply;
DBusMessageIter array, dict;
DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
- append_array(&dict, "ssid", DBUS_TYPE_BYTE, &network, len);
+ connman_dbus_dict_append_array(&dict, "ssid",
+ DBUS_TYPE_BYTE, &network, len);
- if (passphrase && strlen(passphrase) > 0) {
+ if (g_ascii_strcasecmp(security, "wpa") == 0 ||
+ g_ascii_strcasecmp(security, "wpa2") == 0) {
const char *key_mgmt = "WPA-PSK";
- append_entry(&dict, "key_mgmt", DBUS_TYPE_STRING, &key_mgmt);
- append_entry(&dict, "psk", DBUS_TYPE_STRING, &passphrase);
+ connman_dbus_dict_append_variant(&dict, "key_mgmt",
+ DBUS_TYPE_STRING, &key_mgmt);
+
+ if (passphrase && strlen(passphrase) > 0)
+ connman_dbus_dict_append_variant(&dict, "psk",
+ DBUS_TYPE_STRING, &passphrase);
+ } else if (g_ascii_strcasecmp(security, "wep") == 0) {
+ const char *key_mgmt = "NONE", *index = "0";
+ connman_dbus_dict_append_variant(&dict, "key_mgmt",
+ DBUS_TYPE_STRING, &key_mgmt);
+
+ if (passphrase) {
+ int size = strlen(passphrase);
+ if (size == 10 || size == 26) {
+ unsigned char *key = malloc(13);
+ char tmp[3];
+ int i;
+ memset(tmp, 0, sizeof(tmp));
+ if (key == NULL)
+ size = 0;
+ for (i = 0; i < size / 2; i++) {
+ memcpy(tmp, passphrase + (i * 2), 2);
+ key[i] = (unsigned char) strtol(tmp,
+ NULL, 16);
+ }
+ connman_dbus_dict_append_array(&dict,
+ "wep_key0", DBUS_TYPE_BYTE,
+ &key, size / 2);
+ free(key);
+ } else
+ connman_dbus_dict_append_variant(&dict,
+ "wep_key0", DBUS_TYPE_STRING,
+ &passphrase);
+ connman_dbus_dict_append_variant(&dict, "wep_tx_keyidx",
+ DBUS_TYPE_STRING, &index);
+ }
} else {
const char *key_mgmt = "NONE";
- append_entry(&dict, "key_mgmt", DBUS_TYPE_STRING, &key_mgmt);
+ connman_dbus_dict_append_variant(&dict, "key_mgmt",
+ DBUS_TYPE_STRING, &key_mgmt);
}
dbus_message_iter_close_container(&array, &dict);
static void extract_capabilites(struct supplicant_network *network,
DBusMessageIter *value)
{
- guint capabilities;
-
- dbus_message_iter_get_basic(value, &capabilities);
+ dbus_message_iter_get_basic(value, &network->capabilities);
- network->capabilities = capabilities;
-
- if (capabilities & IEEE80211_CAP_PRIVACY)
+ if (network->capabilities & IEEE80211_CAP_PRIVACY)
network->has_wep = TRUE;
}
//type = dbus_message_iter_get_arg_type(&value);
//dbus_message_iter_get_basic(&value, &val);
+ /*
+ * bssid : a (97)
+ * ssid : a (97)
+ * wpaie : a (97)
+ * rsnie : a (97)
+ * frequency : i (105)
+ * capabilities : q (113)
+ * quality : i (105)
+ * noise : i (105)
+ * level : i (105)
+ * maxrate : i (105)
+ */
+
if (g_str_equal(key, "ssid") == TRUE)
extract_ssid(network, &value);
else if (g_str_equal(key, "wpaie") == TRUE)
extract_rsnie(network, &value);
else if (g_str_equal(key, "capabilities") == TRUE)
extract_capabilites(network, &value);
+ else if (g_str_equal(key, "quality") == TRUE)
+ dbus_message_iter_get_basic(&value, &network->quality);
+ else if (g_str_equal(key, "noise") == TRUE)
+ dbus_message_iter_get_basic(&value, &network->noise);
+ else if (g_str_equal(key, "level") == TRUE)
+ dbus_message_iter_get_basic(&value, &network->level);
+ else if (g_str_equal(key, "maxrate") == TRUE)
+ dbus_message_iter_get_basic(&value, &network->maxrate);
+
dbus_message_iter_next(&dict);
}
goto done;
}
+ if (task->callback && task->callback->clear_results)
+ task->callback->clear_results(task->element);
+
for (i = 0; i < num_results; i++)
get_network_properties(task, results[i]);
task->created = FALSE;
task->state = STATE_INACTIVE;
- g_static_mutex_lock(&task_mutex);
task_list = g_slist_append(task_list, task);
- g_static_mutex_unlock(&task_mutex);
err = get_interface(task);
if (err < 0) {
if (task == NULL)
return -ENODEV;
- g_static_mutex_lock(&task_mutex);
task_list = g_slist_remove(task_list, task);
- g_static_mutex_unlock(&task_mutex);
disable_network(task);
int __supplicant_connect(struct connman_element *element,
const unsigned char *ssid, int ssid_len,
- const char *passphrase)
+ const char *security, const char *passphrase)
{
struct supplicant_task *task;
select_network(task);
disable_network(task);
- set_network(task, ssid, ssid_len, passphrase);
+ set_network(task, ssid, ssid_len, security, passphrase);
enable_network(task);
return 0;
}
-int __supplicant_init(void)
+void __supplicant_activate(DBusConnection *conn)
{
- connection = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
- if (connection == NULL)
- return -EIO;
+ DBusMessage *message;
+
+ DBG("conn %p", conn);
+
+ message = dbus_message_new_method_call(SUPPLICANT_NAME, "/",
+ DBUS_INTERFACE_INTROSPECTABLE, "Introspect");
+ if (message == NULL)
+ return;
+
+ dbus_message_set_no_reply(message, TRUE);
+
+ dbus_connection_send(conn, message, NULL);
+
+ dbus_message_unref(message);
+}
+
+int __supplicant_init(DBusConnection *conn)
+{
+ DBG("conn %p", conn);
+
+ connection = conn;
if (dbus_connection_add_filter(connection,
supplicant_filter, NULL, NULL) == FALSE) {
void __supplicant_exit(void)
{
- if (connection == NULL)
- return;
+ DBG("conn %p", connection);
dbus_connection_remove_filter(connection, supplicant_filter, NULL);
-
- dbus_connection_unref(connection);
- connection = NULL;
}
projects / connman / blobdiff