X-Git-Url: http://git.maemo.org/git/?a=blobdiff_plain;f=src%2Fnetwork.c;h=a83b921de1b2d362d5bd79cf9ffca0375677752c;hb=1f51bad6c5ad8510a9012299f87a7d3f31054c80;hp=1d7cc3335805a82fc893953a6fcd7999c114ac3d;hpb=fb1125eea6a02095e9a8763328b540e3d8fec718;p=connman diff --git a/src/network.c b/src/network.c index 1d7cc33..a83b921 100644 --- a/src/network.c +++ b/src/network.c @@ -33,12 +33,16 @@ struct connman_network { struct connman_element element; enum connman_network_type type; enum connman_network_protocol protocol; + connman_bool_t available; connman_bool_t connected; connman_bool_t remember; + connman_uint8_t priority; connman_uint8_t strength; char *identifier; + char *address; char *name; char *node; + char *group; struct connman_network_driver *driver; void *driver_data; @@ -56,6 +60,26 @@ struct connman_network { } wifi; }; +static const char *type2string(enum connman_network_type type) +{ + switch (type) { + case CONNMAN_NETWORK_TYPE_UNKNOWN: + case CONNMAN_NETWORK_TYPE_VENDOR: + break; + case CONNMAN_NETWORK_TYPE_WIFI: + return "wifi"; + case CONNMAN_NETWORK_TYPE_WIMAX: + return "wimax"; + case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN: + case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN: + return "bluetooth"; + case CONNMAN_NETWORK_TYPE_HSO: + return "cellular"; + } + + return NULL; +} + static DBusMessage *get_properties(DBusConnection *conn, DBusMessage *msg, void *data) { @@ -65,6 +89,10 @@ static DBusMessage *get_properties(DBusConnection *conn, DBG("conn %p", conn); + if (__connman_security_check_privilege(msg, + CONNMAN_SECURITY_PRIVILEGE_PUBLIC) < 0) + return __connman_error_permission_denied(msg); + reply = dbus_message_new_method_return(msg); if (reply == NULL) return NULL; @@ -83,16 +111,27 @@ static DBusMessage *get_properties(DBusConnection *conn, DBUS_TYPE_OBJECT_PATH, &path); } + if (network->address != NULL) + connman_dbus_dict_append_variant(&dict, "Address", + DBUS_TYPE_STRING, &network->address); + if (network->name != NULL) connman_dbus_dict_append_variant(&dict, "Name", DBUS_TYPE_STRING, &network->name); + connman_dbus_dict_append_variant(&dict, "Available", + DBUS_TYPE_BOOLEAN, &network->available); + connman_dbus_dict_append_variant(&dict, "Connected", DBUS_TYPE_BOOLEAN, &network->connected); connman_dbus_dict_append_variant(&dict, "Remember", DBUS_TYPE_BOOLEAN, &network->remember); + if (network->priority > 0) + connman_dbus_dict_append_variant(&dict, "Priority", + DBUS_TYPE_BYTE, &network->priority); + if (network->strength > 0) connman_dbus_dict_append_variant(&dict, "Strength", DBUS_TYPE_BYTE, &network->strength); @@ -110,7 +149,9 @@ static DBusMessage *get_properties(DBusConnection *conn, connman_dbus_dict_append_variant(&dict, "WiFi.Security", DBUS_TYPE_STRING, &network->wifi.security); - if (network->wifi.passphrase != NULL) + if (network->wifi.passphrase != NULL && + __connman_security_check_privilege(msg, + CONNMAN_SECURITY_PRIVILEGE_SECRET) == 0) connman_dbus_dict_append_variant(&dict, "WiFi.Passphrase", DBUS_TYPE_STRING, &network->wifi.passphrase); @@ -125,6 +166,7 @@ static DBusMessage *set_property(DBusConnection *conn, struct connman_network *network = data; DBusMessageIter iter, value; const char *name; + int type; DBG("conn %p", conn); @@ -135,25 +177,51 @@ static DBusMessage *set_property(DBusConnection *conn, dbus_message_iter_next(&iter); dbus_message_iter_recurse(&iter, &value); - if (__connman_security_check_privileges(msg) < 0) + if (__connman_security_check_privilege(msg, + CONNMAN_SECURITY_PRIVILEGE_MODIFY) < 0) return __connman_error_permission_denied(msg); + type = dbus_message_iter_get_arg_type(&value); + if (g_str_equal(name, "Remember") == TRUE) { connman_bool_t remember; + if (type != DBUS_TYPE_BOOLEAN) + return __connman_error_invalid_arguments(msg); + dbus_message_iter_get_basic(&value, &remember); if (network->remember == remember) return __connman_error_invalid_arguments(msg); + + network->remember = remember; } else if (g_str_equal(name, "WiFi.Passphrase") == TRUE) { const char *passphrase; + if (type != DBUS_TYPE_STRING) + return __connman_error_invalid_arguments(msg); + + if (__connman_security_check_privilege(msg, + CONNMAN_SECURITY_PRIVILEGE_SECRET) < 0) + return __connman_error_permission_denied(msg); + dbus_message_iter_get_basic(&value, &passphrase); g_free(network->wifi.passphrase); network->wifi.passphrase = g_strdup(passphrase); + } else if (g_str_equal(name, "Priority") == TRUE) { + connman_uint8_t priority; + + if (type != DBUS_TYPE_BYTE) + return __connman_error_invalid_arguments(msg); + + dbus_message_iter_get_basic(&value, &priority); + + network->priority = priority; } + __connman_storage_save_network(network); + return g_dbus_create_reply(msg, DBUS_TYPE_INVALID); } @@ -165,11 +233,25 @@ static DBusMessage *do_connect(DBusConnection *conn, DBG("conn %p", conn); + if (__connman_security_check_privilege(msg, + CONNMAN_SECURITY_PRIVILEGE_MODIFY) < 0) + return __connman_error_permission_denied(msg); + + if (network->connected == TRUE) + return __connman_error_failed(msg); + if (network->driver && network->driver->connect) { + enum connman_device_mode mode; + + mode = connman_device_get_mode(network->device); + if (mode == CONNMAN_DEVICE_MODE_NETWORK_SINGLE) + __connman_device_disconnect(network->device); + err = network->driver->connect(network); if (err < 0 && err != -EINPROGRESS) return __connman_error_failed(msg); - } + } else + network->connected = TRUE; return g_dbus_create_reply(msg, DBUS_TYPE_INVALID); } @@ -182,11 +264,23 @@ static DBusMessage *do_disconnect(DBusConnection *conn, DBG("conn %p", conn); + if (__connman_security_check_privilege(msg, + CONNMAN_SECURITY_PRIVILEGE_MODIFY) < 0) + return __connman_error_permission_denied(msg); + + if (network->connected == FALSE) + return __connman_error_failed(msg); + + connman_element_unregister_children(&network->element); + + connman_device_set_disconnected(network->device, TRUE); + if (network->driver && network->driver->disconnect) { err = network->driver->disconnect(network); if (err < 0 && err != -EINPROGRESS) return __connman_error_failed(msg); - } + } else + network->connected = FALSE; return g_dbus_create_reply(msg, DBUS_TYPE_INVALID); } @@ -206,8 +300,43 @@ static GDBusSignalTable network_signals[] = { static DBusConnection *connection; -static void emit_networks_signal(void) +static void append_networks(struct connman_device *device, + DBusMessageIter *entry) { + DBusMessageIter value, iter; + const char *key = "Networks"; + + 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_OBJECT_PATH_AS_STRING, + &value); + + dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY, + DBUS_TYPE_OBJECT_PATH_AS_STRING, &iter); + __connman_element_list((struct connman_element *) device, + CONNMAN_ELEMENT_TYPE_NETWORK, &iter); + dbus_message_iter_close_container(&value, &iter); + + dbus_message_iter_close_container(entry, &value); +} + +static void emit_networks_signal(struct connman_device *device) +{ + const char *path = connman_device_get_path(device); + DBusMessage *signal; + DBusMessageIter entry; + + signal = dbus_message_new_signal(path, + CONNMAN_DEVICE_INTERFACE, "PropertyChanged"); + if (signal == NULL) + return; + + dbus_message_iter_init_append(signal, &entry); + + append_networks(device, &entry); + + g_dbus_send_message(connection, signal); } static int register_interface(struct connman_element *element) @@ -226,7 +355,7 @@ static int register_interface(struct connman_element *element) network->registered = TRUE; - emit_networks_signal(); + emit_networks_signal(network->device); return 0; } @@ -239,7 +368,7 @@ static void unregister_interface(struct connman_element *element) network->registered = FALSE; - emit_networks_signal(); + emit_networks_signal(network->device); g_dbus_unregister_interface(connection, element->path, CONNMAN_NETWORK_INTERFACE); @@ -305,8 +434,10 @@ static void network_destruct(struct connman_element *element) g_free(network->wifi.security); g_free(network->wifi.passphrase); + g_free(network->group); g_free(network->node); g_free(network->name); + g_free(network->address); g_free(network->identifier); } @@ -322,6 +453,10 @@ struct connman_network *connman_network_create(const char *identifier, enum connman_network_type type) { struct connman_network *network; + connman_uint8_t strength = 0; + const char *str; + char *temp; + unsigned int i; DBG("identifier %s type %d", identifier, type); @@ -331,32 +466,33 @@ struct connman_network *connman_network_create(const char *identifier, DBG("network %p", network); - network->element.refcount = 1; + __connman_element_initialize(&network->element); - network->element.name = g_strdup(identifier); - network->element.type = CONNMAN_ELEMENT_TYPE_NETWORK; - network->element.index = -1; + temp = g_strdup(identifier); + if (temp == NULL) { + g_free(network); + return NULL; + } - switch (type) { - case CONNMAN_NETWORK_TYPE_UNKNOWN: - case CONNMAN_NETWORK_TYPE_VENDOR: - network->element.subtype = CONNMAN_ELEMENT_SUBTYPE_UNKNOWN; - break; - case CONNMAN_NETWORK_TYPE_WIFI: - network->element.subtype = CONNMAN_ELEMENT_SUBTYPE_WIFI; - break; - case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN: - case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN: - network->element.subtype = CONNMAN_ELEMENT_SUBTYPE_BLUETOOTH; - break; - case CONNMAN_NETWORK_TYPE_HSO: - network->element.subtype = CONNMAN_ELEMENT_SUBTYPE_CELLULAR; - break; + for (i = 0; i < strlen(temp); i++) { + char tmp = temp[i]; + if ((tmp < '0' || tmp > '9') && (tmp < 'A' || tmp > 'Z') && + (tmp < 'a' || tmp > 'z')) + temp[i] = '_'; } + network->element.name = temp; + network->element.type = CONNMAN_ELEMENT_TYPE_NETWORK; + network->element.network = network; network->element.destruct = network_destruct; + str = type2string(type); + if (str != NULL) + connman_element_set_string(&network->element, "Type", str); + + connman_element_set_uint8(&network->element, "Strength", strength); + network->type = type; network->identifier = g_strdup(identifier); @@ -447,23 +583,84 @@ void connman_network_set_protocol(struct connman_network *network, } /** - * connman_network_set_connected: + * connman_network_set_group: * @network: network structure - * @connected: connected state + * @group: group name * - * Change connected state of network + * Set group name for automatic clustering */ -int connman_network_set_connected(struct connman_network *network, - connman_bool_t connected) +void connman_network_set_group(struct connman_network *network, + const char *group) { - DBG("network %p connected %d", network, connected); + g_free(network->group); + network->group = g_strdup(group); +} - if (network->connected == connected) +/** + * connman_network_set_available: + * @network: network structure + * @available: availability state + * + * Change availability state of network (in range) + */ +int connman_network_set_available(struct connman_network *network, + connman_bool_t available) +{ + DBusMessage *signal; + DBusMessageIter entry, value; + const char *key = "Available"; + + DBG("network %p available %d", network, available); + + if (network->available == available) return -EALREADY; - network->connected = connected; + network->available = available; + + if (network->registered == FALSE) + return 0; + + if (network->connected == TRUE) + return 0; + + if (network->remember == FALSE) + return 0; + + signal = dbus_message_new_signal(network->element.path, + CONNMAN_NETWORK_INTERFACE, "PropertyChanged"); + if (signal == NULL) + return 0; + + dbus_message_iter_init_append(signal, &entry); + + dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key); + + dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT, + DBUS_TYPE_BOOLEAN_AS_STRING, &value); + dbus_message_iter_append_basic(&value, DBUS_TYPE_BOOLEAN, &available); + dbus_message_iter_close_container(&entry, &value); + + g_dbus_send_message(connection, signal); + + return 0; +} + +/** + * connman_network_get_available: + * @network: network structure + * + * Get network available setting + */ +connman_bool_t connman_network_get_available(struct connman_network *network) +{ + return network->available; +} + +static gboolean set_connected(gpointer user_data) +{ + struct connman_network *network = user_data; - if (connected == TRUE) { + if (network->connected == TRUE) { struct connman_element *element; enum connman_element_type type = CONNMAN_ELEMENT_TYPE_UNKNOWN; @@ -478,19 +675,175 @@ int connman_network_set_connected(struct connman_network *network, break; } + __connman_device_increase_connections(network->device); + + __connman_device_set_network(network->device, network); + + connman_device_set_disconnected(network->device, FALSE); + element = connman_element_create(NULL); if (element != NULL) { - element->type = type; - element->subtype = network->element.subtype; - element->index = network->element.index; + element->type = type; + element->index = network->element.index; if (connman_element_register(element, - &network->element) < 0) + &network->element) < 0) connman_element_unref(element); } - } else + } else { connman_element_unregister_children(&network->element); + __connman_device_set_network(network->device, NULL); + + __connman_device_decrease_connections(network->device); + } + + return FALSE; +} + +/** + * connman_network_set_connected: + * @network: network structure + * @connected: connected state + * + * Change connected state of network + */ +int connman_network_set_connected(struct connman_network *network, + connman_bool_t connected) +{ + DBusMessage *signal; + DBusMessageIter entry, value; + const char *key = "Connected"; + + DBG("network %p connected %d", network, connected); + + if (network->connected == connected) + return -EALREADY; + + network->connected = connected; + + if (network->registered == FALSE) { + g_idle_add(set_connected, network); + return 0; + } + + signal = dbus_message_new_signal(network->element.path, + CONNMAN_NETWORK_INTERFACE, "PropertyChanged"); + if (signal == NULL) + return 0; + + dbus_message_iter_init_append(signal, &entry); + + dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key); + + dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT, + DBUS_TYPE_BOOLEAN_AS_STRING, &value); + dbus_message_iter_append_basic(&value, DBUS_TYPE_BOOLEAN, &connected); + dbus_message_iter_close_container(&entry, &value); + + g_dbus_send_message(connection, signal); + + set_connected(network); + + return 0; +} + +/** + * connman_network_get_connected: + * @network: network structure + * + * Get network connection status + */ +connman_bool_t connman_network_get_connected(struct connman_network *network) +{ + return network->connected; +} + +/** + * connman_network_set_remember: + * @network: network structure + * @remember: remember state + * + * Change remember state of network (known networks) + */ +int connman_network_set_remember(struct connman_network *network, + connman_bool_t remember) +{ + DBusMessage *signal; + DBusMessageIter entry, value; + const char *key = "Remember"; + + DBG("network %p remember %d", network, remember); + + if (network->remember == remember) + return -EALREADY; + + network->remember = remember; + + if (network->registered == FALSE) + return 0; + + signal = dbus_message_new_signal(network->element.path, + CONNMAN_NETWORK_INTERFACE, "PropertyChanged"); + if (signal == NULL) + return 0; + + dbus_message_iter_init_append(signal, &entry); + + dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key); + + dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT, + DBUS_TYPE_BOOLEAN_AS_STRING, &value); + dbus_message_iter_append_basic(&value, DBUS_TYPE_BOOLEAN, &remember); + dbus_message_iter_close_container(&entry, &value); + + g_dbus_send_message(connection, signal); + + return 0; +} + +/** + * connman_network_get_remember: + * @network: network structure + * + * Get network remember setting + */ +connman_bool_t connman_network_get_remember(struct connman_network *network) +{ + return network->remember; +} + +/** + * connman_network_connect: + * @network: network structure + * + * Connect network + */ +int connman_network_connect(struct connman_network *network) +{ + if (network->connected == TRUE) + return -EALREADY; + + if (network->driver && network->driver->connect) + return network->driver->connect(network); + + network->connected = TRUE; + + return 0; +} + +int __connman_network_disconnect(struct connman_network *network) +{ + if (network->connected == FALSE) + return -ENOTCONN; + + connman_element_unregister_children(&network->element); + + if (network->driver && network->driver->disconnect) + return network->driver->disconnect(network); + + network->connected = FALSE; + return 0; } @@ -507,7 +860,10 @@ int connman_network_set_string(struct connman_network *network, { DBG("network %p key %s value %s", network, key, value); - if (g_str_equal(key, "Name") == TRUE) { + if (g_str_equal(key, "Address") == TRUE) { + g_free(network->address); + network->address = g_strdup(value); + } else if (g_str_equal(key, "Name") == TRUE) { g_free(network->name); network->name = g_strdup(value); } else if (g_str_equal(key, "Node") == TRUE) { @@ -519,9 +875,12 @@ int connman_network_set_string(struct connman_network *network, } else if (g_str_equal(key, "WiFi.Security") == TRUE) { g_free(network->wifi.security); network->wifi.security = g_strdup(value); + } else if (g_str_equal(key, "WiFi.Passphrase") == TRUE) { + g_free(network->wifi.passphrase); + network->wifi.passphrase = g_strdup(value); } - return 0; + return connman_element_set_string(&network->element, key, value); } /** @@ -534,9 +893,11 @@ int connman_network_set_string(struct connman_network *network, const char *connman_network_get_string(struct connman_network *network, const char *key) { - DBG("network %p key %s", network); + DBG("network %p key %s", network, key); - if (g_str_equal(key, "Name") == TRUE) + if (g_str_equal(key, "Address") == TRUE) + return network->address; + else if (g_str_equal(key, "Name") == TRUE) return network->name; else if (g_str_equal(key, "Node") == TRUE) return network->node; @@ -544,8 +905,10 @@ const char *connman_network_get_string(struct connman_network *network, return network->wifi.mode; else if (g_str_equal(key, "WiFi.Security") == TRUE) return network->wifi.security; + else if (g_str_equal(key, "WiFi.Passphrase") == TRUE) + return network->wifi.passphrase; - return NULL; + return connman_element_get_string(&network->element, key); } /** @@ -561,10 +924,32 @@ int connman_network_set_uint8(struct connman_network *network, { DBG("network %p key %s value %d", network, key, value); - if (g_str_equal(key, "Strength") == TRUE) + if (g_str_equal(key, "Priority") == TRUE) + network->priority = value; + else if (g_str_equal(key, "Strength") == TRUE) network->strength = value; - return 0; + return connman_element_set_uint8(&network->element, key, value); +} + +/** + * connman_network_get_uint8: + * @network: network structure + * @key: unique identifier + * + * Get integer value for specific key + */ +connman_uint8_t connman_network_get_uint8(struct connman_network *network, + const char *key) +{ + DBG("network %p key %s", network, key); + + if (g_str_equal(key, "Priority") == TRUE) + return network->priority; + else if (g_str_equal(key, "Strength") == TRUE) + return network->strength; + + return connman_element_get_uint8(&network->element, key); } /** @@ -591,7 +976,29 @@ int connman_network_set_blob(struct connman_network *network, network->wifi.ssid_len = 0; } - return 0; + return connman_element_set_blob(&network->element, key, data, size); +} + +/** + * connman_network_get_blob: + * @network: network structure + * @key: unique identifier + * @size: pointer to blob size + * + * Get binary blob value for specific key + */ +const void *connman_network_get_blob(struct connman_network *network, + const char *key, unsigned int *size) +{ + DBG("network %p key %s", network, key); + + if (g_str_equal(key, "WiFi.SSID") == TRUE) { + if (size != NULL) + *size = network->wifi.ssid_len; + return network->wifi.ssid; + } + + return connman_element_get_blob(&network->element, key, size); } void __connman_network_set_device(struct connman_network *network, @@ -679,6 +1086,8 @@ static int network_probe(struct connman_element *element) return err; } + __connman_profile_add_network(network); + return 0; } @@ -694,37 +1103,186 @@ static void network_remove(struct connman_element *element) if (network->driver == NULL) return; + __connman_profile_remove_network(network); + unregister_interface(element); if (network->driver->remove) network->driver->remove(network); } +static void network_change(struct connman_element *element) +{ + struct connman_network *network = element->network; + + DBG("element %p name %s", element, element->name); + + if (element->state != CONNMAN_ELEMENT_STATE_ERROR) + return; + + if (element->error != CONNMAN_ELEMENT_ERROR_DHCP_FAILED) + return; + + if (network->connected == FALSE) + return; + + connman_element_unregister_children(element); + + connman_device_set_disconnected(network->device, TRUE); + + if (network->driver && network->driver->disconnect) { + network->driver->disconnect(network); + return; + } + + network->connected = FALSE; +} + static struct connman_driver network_driver = { .name = "network", .type = CONNMAN_ELEMENT_TYPE_NETWORK, .priority = CONNMAN_DRIVER_PRIORITY_LOW, .probe = network_probe, .remove = network_remove, + .change = network_change, }; +static int network_init(struct connman_device *device) +{ + DBG("device %p", device); + + return 0; +} + static int network_load(struct connman_network *network) { + GKeyFile *keyfile; + gchar *pathname, *data = NULL; + gsize length; + const char *name; + char *str; + int val; + DBG("network %p", network); + name = connman_device_get_name(network->device); + if (name == NULL) + return -EINVAL; + + pathname = g_strdup_printf("%s/%s.conf", STORAGEDIR, name); + if (pathname == NULL) + return -ENOMEM; + + keyfile = g_key_file_new(); + + if (g_file_get_contents(pathname, &data, &length, NULL) == FALSE) { + g_free(pathname); + return -ENOENT; + } + + g_free(pathname); + + if (g_key_file_load_from_data(keyfile, data, length, + 0, NULL) == FALSE) { + g_free(data); + return -EILSEQ; + } + + g_free(data); + + network->remember = g_key_file_get_boolean(keyfile, + network->identifier, "Remember", NULL); + + val = g_key_file_get_integer(keyfile, network->identifier, + "Priority", NULL); + if (val > 0) + network->priority = val; + + str = g_key_file_get_string(keyfile, + network->identifier, "WiFi.Security", NULL); + if (str != NULL) { + g_free(network->wifi.security); + network->wifi.security = str; + } + + str = g_key_file_get_string(keyfile, + network->identifier, "WiFi.Passphrase", NULL); + if (str != NULL) { + g_free(network->wifi.passphrase); + network->wifi.passphrase = str; + } + + g_key_file_free(keyfile); + return 0; } static int network_save(struct connman_network *network) { + GKeyFile *keyfile; + gchar *pathname, *data = NULL; + gsize length; + const char *name; + DBG("network %p", network); + name = connman_device_get_name(network->device); + if (name == NULL) + return -EINVAL; + + pathname = g_strdup_printf("%s/%s.conf", STORAGEDIR, name); + if (pathname == NULL) + return -ENOMEM; + + keyfile = g_key_file_new(); + + if (g_file_get_contents(pathname, &data, &length, NULL) == FALSE) + goto update; + + if (length > 0) { + if (g_key_file_load_from_data(keyfile, data, length, + 0, NULL) == FALSE) + goto done; + } + + g_free(data); + +update: + g_key_file_set_boolean(keyfile, network->identifier, + "Remember", network->remember); + + if (network->priority > 0) + g_key_file_set_integer(keyfile, network->identifier, + "Priority", network->priority); + + if (network->remember == TRUE || network->connected == TRUE) { + if (network->wifi.security != NULL) + g_key_file_set_string(keyfile, network->identifier, + "WiFi.Security", network->wifi.security); + + if (network->wifi.passphrase != NULL) + g_key_file_set_string(keyfile, network->identifier, + "WiFi.Passphrase", network->wifi.passphrase); + } + + data = g_key_file_to_data(keyfile, &length, NULL); + + g_file_set_contents(pathname, data, length, NULL); + +done: + g_free(data); + + g_key_file_free(keyfile); + + g_free(pathname); + return 0; } static struct connman_storage network_storage = { .name = "network", .priority = CONNMAN_STORAGE_PRIORITY_LOW, + .network_init = network_init, .network_load = network_load, .network_save = network_save, };