5 * Copyright (C) 2007-2009 Intel Corporation. All rights reserved.
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
32 struct connman_network {
33 struct connman_element element;
34 enum connman_network_type type;
35 enum connman_network_protocol protocol;
36 connman_bool_t associating;
37 connman_bool_t secondary;
38 connman_bool_t available;
39 connman_bool_t connected;
40 connman_bool_t remember;
41 connman_uint8_t priority;
42 connman_uint8_t strength;
49 struct connman_network_driver *driver;
52 connman_bool_t registered;
54 struct connman_device *device;
65 static const char *type2string(enum connman_network_type type)
68 case CONNMAN_NETWORK_TYPE_UNKNOWN:
69 case CONNMAN_NETWORK_TYPE_VENDOR:
71 case CONNMAN_NETWORK_TYPE_WIFI:
73 case CONNMAN_NETWORK_TYPE_WIMAX:
75 case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
76 case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
78 case CONNMAN_NETWORK_TYPE_HSO:
85 static DBusMessage *get_properties(DBusConnection *conn,
86 DBusMessage *msg, void *data)
88 struct connman_network *network = data;
90 DBusMessageIter array, dict;
94 if (__connman_security_check_privilege(msg,
95 CONNMAN_SECURITY_PRIVILEGE_PUBLIC) < 0)
96 return __connman_error_permission_denied(msg);
98 reply = dbus_message_new_method_return(msg);
102 dbus_message_iter_init_append(reply, &array);
104 dbus_message_iter_open_container(&array, DBUS_TYPE_ARRAY,
105 DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
106 DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
107 DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
109 if (network->device) {
110 const char *path = connman_device_get_path(network->device);
112 connman_dbus_dict_append_variant(&dict, "Device",
113 DBUS_TYPE_OBJECT_PATH, &path);
116 if (network->address != NULL)
117 connman_dbus_dict_append_variant(&dict, "Address",
118 DBUS_TYPE_STRING, &network->address);
120 if (network->name != NULL)
121 connman_dbus_dict_append_variant(&dict, "Name",
122 DBUS_TYPE_STRING, &network->name);
124 connman_dbus_dict_append_variant(&dict, "Available",
125 DBUS_TYPE_BOOLEAN, &network->available);
127 connman_dbus_dict_append_variant(&dict, "Connected",
128 DBUS_TYPE_BOOLEAN, &network->connected);
130 connman_dbus_dict_append_variant(&dict, "Remember",
131 DBUS_TYPE_BOOLEAN, &network->remember);
133 if (network->priority > 0)
134 connman_dbus_dict_append_variant(&dict, "Priority",
135 DBUS_TYPE_BYTE, &network->priority);
137 if (network->strength > 0)
138 connman_dbus_dict_append_variant(&dict, "Strength",
139 DBUS_TYPE_BYTE, &network->strength);
141 if (network->wifi.ssid != NULL && network->wifi.ssid_len > 0)
142 connman_dbus_dict_append_array(&dict, "WiFi.SSID",
143 DBUS_TYPE_BYTE, &network->wifi.ssid,
144 network->wifi.ssid_len);
146 if (network->wifi.mode != NULL)
147 connman_dbus_dict_append_variant(&dict, "WiFi.Mode",
148 DBUS_TYPE_STRING, &network->wifi.mode);
150 if (network->wifi.security != NULL)
151 connman_dbus_dict_append_variant(&dict, "WiFi.Security",
152 DBUS_TYPE_STRING, &network->wifi.security);
154 if (network->wifi.passphrase != NULL &&
155 __connman_security_check_privilege(msg,
156 CONNMAN_SECURITY_PRIVILEGE_SECRET) == 0)
157 connman_dbus_dict_append_variant(&dict, "WiFi.Passphrase",
158 DBUS_TYPE_STRING, &network->wifi.passphrase);
160 dbus_message_iter_close_container(&array, &dict);
165 static DBusMessage *set_property(DBusConnection *conn,
166 DBusMessage *msg, void *data)
168 struct connman_network *network = data;
169 DBusMessageIter iter, value;
173 DBG("conn %p", conn);
175 if (dbus_message_iter_init(msg, &iter) == FALSE)
176 return __connman_error_invalid_arguments(msg);
178 dbus_message_iter_get_basic(&iter, &name);
179 dbus_message_iter_next(&iter);
180 dbus_message_iter_recurse(&iter, &value);
182 if (__connman_security_check_privilege(msg,
183 CONNMAN_SECURITY_PRIVILEGE_MODIFY) < 0)
184 return __connman_error_permission_denied(msg);
186 type = dbus_message_iter_get_arg_type(&value);
188 if (g_str_equal(name, "Remember") == TRUE) {
189 connman_bool_t remember;
191 if (type != DBUS_TYPE_BOOLEAN)
192 return __connman_error_invalid_arguments(msg);
194 dbus_message_iter_get_basic(&value, &remember);
196 if (network->remember == remember)
197 return __connman_error_invalid_arguments(msg);
199 network->remember = remember;
200 } else if (g_str_equal(name, "WiFi.Passphrase") == TRUE) {
201 const char *passphrase;
203 if (type != DBUS_TYPE_STRING)
204 return __connman_error_invalid_arguments(msg);
206 if (__connman_security_check_privilege(msg,
207 CONNMAN_SECURITY_PRIVILEGE_SECRET) < 0)
208 return __connman_error_permission_denied(msg);
210 dbus_message_iter_get_basic(&value, &passphrase);
212 g_free(network->wifi.passphrase);
213 network->wifi.passphrase = g_strdup(passphrase);
214 } else if (g_str_equal(name, "Priority") == TRUE) {
215 connman_uint8_t priority;
217 if (type != DBUS_TYPE_BYTE)
218 return __connman_error_invalid_arguments(msg);
220 dbus_message_iter_get_basic(&value, &priority);
222 network->priority = priority;
225 __connman_storage_save_network(network);
227 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
230 static DBusMessage *do_connect(DBusConnection *conn,
231 DBusMessage *msg, void *data)
233 struct connman_network *network = data;
236 DBG("conn %p", conn);
238 if (__connman_security_check_privilege(msg,
239 CONNMAN_SECURITY_PRIVILEGE_MODIFY) < 0)
240 return __connman_error_permission_denied(msg);
242 if (network->connected == TRUE)
243 return __connman_error_failed(msg, EALREADY);
245 if (network->driver && network->driver->connect) {
246 enum connman_device_mode mode;
248 mode = connman_device_get_mode(network->device);
249 if (mode == CONNMAN_DEVICE_MODE_NETWORK_SINGLE)
250 __connman_device_disconnect(network->device);
252 err = network->driver->connect(network);
253 if (err < 0 && err != -EINPROGRESS)
254 return __connman_error_failed(msg, -err);
256 network->connected = TRUE;
258 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
261 static DBusMessage *do_disconnect(DBusConnection *conn,
262 DBusMessage *msg, void *data)
264 struct connman_network *network = data;
267 DBG("conn %p", conn);
269 if (__connman_security_check_privilege(msg,
270 CONNMAN_SECURITY_PRIVILEGE_MODIFY) < 0)
271 return __connman_error_permission_denied(msg);
273 if (network->connected == FALSE)
274 return __connman_error_failed(msg, EINVAL);
276 connman_element_unregister_children(&network->element);
278 connman_device_set_disconnected(network->device, TRUE);
280 if (network->driver && network->driver->disconnect) {
281 err = network->driver->disconnect(network);
282 if (err < 0 && err != -EINPROGRESS)
283 return __connman_error_failed(msg, -err);
285 network->connected = FALSE;
287 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
290 static GDBusMethodTable network_methods[] = {
291 { "GetProperties", "", "a{sv}", get_properties },
292 { "SetProperty", "sv", "", set_property },
293 { "Connect", "", "", do_connect },
294 { "Disconnect", "", "", do_disconnect },
298 static GDBusSignalTable network_signals[] = {
299 { "PropertyChanged", "sv" },
303 static DBusConnection *connection;
305 static void append_networks(struct connman_device *device,
306 DBusMessageIter *entry)
308 DBusMessageIter value, iter;
309 const char *key = "Networks";
311 dbus_message_iter_append_basic(entry, DBUS_TYPE_STRING, &key);
313 dbus_message_iter_open_container(entry, DBUS_TYPE_VARIANT,
314 DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_OBJECT_PATH_AS_STRING,
317 dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY,
318 DBUS_TYPE_OBJECT_PATH_AS_STRING, &iter);
319 __connman_element_list((struct connman_element *) device,
320 CONNMAN_ELEMENT_TYPE_NETWORK, &iter);
321 dbus_message_iter_close_container(&value, &iter);
323 dbus_message_iter_close_container(entry, &value);
326 static void emit_networks_signal(struct connman_device *device)
328 const char *path = connman_device_get_path(device);
330 DBusMessageIter entry;
332 signal = dbus_message_new_signal(path,
333 CONNMAN_DEVICE_INTERFACE, "PropertyChanged");
337 dbus_message_iter_init_append(signal, &entry);
339 append_networks(device, &entry);
341 g_dbus_send_message(connection, signal);
344 static int register_interface(struct connman_element *element)
346 struct connman_network *network = element->network;
348 DBG("element %p name %s", element, element->name);
350 if (g_dbus_register_interface(connection, element->path,
351 CONNMAN_NETWORK_INTERFACE,
352 network_methods, network_signals,
353 NULL, network, NULL) == FALSE) {
354 connman_error("Failed to register %s network", element->path);
358 network->registered = TRUE;
360 emit_networks_signal(network->device);
365 static void unregister_interface(struct connman_element *element)
367 struct connman_network * network = element->network;
369 DBG("element %p name %s", element, element->name);
371 network->registered = FALSE;
373 emit_networks_signal(network->device);
375 g_dbus_unregister_interface(connection, element->path,
376 CONNMAN_NETWORK_INTERFACE);
379 connman_bool_t __connman_network_has_driver(struct connman_network *network)
381 if (network == NULL || network->driver == NULL)
384 return network->registered;
387 static GSList *driver_list = NULL;
389 static gint compare_priority(gconstpointer a, gconstpointer b)
391 const struct connman_network_driver *driver1 = a;
392 const struct connman_network_driver *driver2 = b;
394 return driver2->priority - driver1->priority;
398 * connman_network_driver_register:
399 * @driver: network driver definition
401 * Register a new network driver
403 * Returns: %0 on success
405 int connman_network_driver_register(struct connman_network_driver *driver)
407 DBG("driver %p name %s", driver, driver->name);
409 driver_list = g_slist_insert_sorted(driver_list, driver,
416 * connman_network_driver_unregister:
417 * @driver: network driver definition
419 * Remove a previously registered network driver
421 void connman_network_driver_unregister(struct connman_network_driver *driver)
423 DBG("driver %p name %s", driver, driver->name);
425 driver_list = g_slist_remove(driver_list, driver);
428 static void network_destruct(struct connman_element *element)
430 struct connman_network *network = element->network;
432 DBG("element %p name %s", element, element->name);
434 g_free(network->wifi.ssid);
435 g_free(network->wifi.mode);
436 g_free(network->wifi.security);
437 g_free(network->wifi.passphrase);
439 g_free(network->group);
440 g_free(network->node);
441 g_free(network->name);
442 g_free(network->address);
443 g_free(network->identifier);
447 * connman_network_create:
448 * @identifier: network identifier (for example an unqiue name)
450 * Allocate a new network and assign the #identifier to it.
452 * Returns: a newly-allocated #connman_network structure
454 struct connman_network *connman_network_create(const char *identifier,
455 enum connman_network_type type)
457 struct connman_network *network;
458 connman_uint8_t strength = 0;
462 DBG("identifier %s type %d", identifier, type);
464 network = g_try_new0(struct connman_network, 1);
468 DBG("network %p", network);
470 __connman_element_initialize(&network->element);
472 //temp = connman_dbus_encode_string(identifier);
473 temp = g_strdup(identifier);
479 network->element.name = temp;
480 network->element.type = CONNMAN_ELEMENT_TYPE_NETWORK;
482 network->element.network = network;
483 network->element.destruct = network_destruct;
485 str = type2string(type);
487 connman_element_set_string(&network->element, "Type", str);
489 connman_element_set_uint8(&network->element, "Strength", strength);
491 network->type = type;
492 network->secondary = FALSE;
493 network->identifier = g_strdup(identifier);
499 * connman_network_ref:
500 * @network: network structure
502 * Increase reference counter of network
504 struct connman_network *connman_network_ref(struct connman_network *network)
506 if (connman_element_ref(&network->element) == NULL)
513 * connman_network_unref:
514 * @network: network structure
516 * Decrease reference counter of network
518 void connman_network_unref(struct connman_network *network)
520 connman_element_unref(&network->element);
523 const char *__connman_network_get_type(struct connman_network *network)
525 return type2string(network->type);
529 * connman_network_get_type:
530 * @network: network structure
532 * Get type of network
534 enum connman_network_type connman_network_get_type(struct connman_network *network)
536 return network->type;
540 * connman_network_get_identifier:
541 * @network: network structure
543 * Get identifier of network
545 const char *connman_network_get_identifier(struct connman_network *network)
547 return network->identifier;
551 * connman_network_get_path:
552 * @network: network structure
554 * Get path name of network
556 const char *connman_network_get_path(struct connman_network *network)
558 return network->element.path;
562 * connman_network_set_index:
563 * @network: network structure
564 * @index: index number
566 * Set index number of network
568 void connman_network_set_index(struct connman_network *network, int index)
570 network->element.index = index;
574 * connman_network_get_index:
575 * @network: network structure
577 * Get index number of network
579 int connman_network_get_index(struct connman_network *network)
581 return network->element.index;
585 * connman_network_set_protocol:
586 * @network: network structure
587 * @protocol: network protocol
589 * Change protocol of network
591 void connman_network_set_protocol(struct connman_network *network,
592 enum connman_network_protocol protocol)
594 network->protocol = protocol;
598 * connman_network_set_group:
599 * @network: network structure
602 * Set group name for automatic clustering
604 void connman_network_set_group(struct connman_network *network,
607 g_free(network->group);
608 network->group = g_strdup(group);
611 const char *__connman_network_get_group(struct connman_network *network)
613 return network->group;
616 const char *__connman_network_get_ident(struct connman_network *network)
618 if (network->device == NULL)
621 return __connman_device_get_ident(network->device);
625 * connman_network_set_available:
626 * @network: network structure
627 * @available: availability state
629 * Change availability state of network (in range)
631 int connman_network_set_available(struct connman_network *network,
632 connman_bool_t available)
635 DBusMessageIter entry, value;
636 const char *key = "Available";
638 DBG("network %p available %d", network, available);
640 if (network->available == available)
643 network->available = available;
645 if (network->registered == FALSE)
648 if (network->connected == TRUE)
651 if (network->remember == FALSE)
654 signal = dbus_message_new_signal(network->element.path,
655 CONNMAN_NETWORK_INTERFACE, "PropertyChanged");
659 dbus_message_iter_init_append(signal, &entry);
661 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
663 dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
664 DBUS_TYPE_BOOLEAN_AS_STRING, &value);
665 dbus_message_iter_append_basic(&value, DBUS_TYPE_BOOLEAN, &available);
666 dbus_message_iter_close_container(&entry, &value);
668 g_dbus_send_message(connection, signal);
674 * connman_network_get_available:
675 * @network: network structure
677 * Get network available setting
679 connman_bool_t connman_network_get_available(struct connman_network *network)
681 return network->available;
684 static gboolean set_connected(gpointer user_data)
686 struct connman_network *network = user_data;
687 struct connman_service *service;
689 service = __connman_service_lookup_from_network(network);
691 if (network->connected == TRUE) {
692 struct connman_element *element;
693 enum connman_element_type type = CONNMAN_ELEMENT_TYPE_UNKNOWN;
695 switch (network->protocol) {
696 case CONNMAN_NETWORK_PROTOCOL_UNKNOWN:
698 case CONNMAN_NETWORK_PROTOCOL_IP:
699 type = CONNMAN_ELEMENT_TYPE_DHCP;
701 case CONNMAN_NETWORK_PROTOCOL_PPP:
702 type = CONNMAN_ELEMENT_TYPE_PPP;
706 __connman_device_increase_connections(network->device);
708 __connman_device_set_network(network->device, network);
710 connman_device_set_disconnected(network->device, FALSE);
712 element = connman_element_create(NULL);
713 if (element != NULL) {
714 element->type = type;
715 element->index = network->element.index;
717 if (connman_element_register(element,
718 &network->element) < 0)
719 connman_element_unref(element);
721 __connman_service_indicate_state(service,
722 CONNMAN_SERVICE_STATE_CONFIGURATION);
725 __connman_service_indicate_state(service,
726 CONNMAN_SERVICE_STATE_IDLE);
728 connman_element_unregister_children(&network->element);
730 __connman_device_set_network(network->device, NULL);
732 __connman_device_decrease_connections(network->device);
739 * connman_network_set_associating:
740 * @network: network structure
741 * @associating: associating state
743 * Change associating state of network
745 int connman_network_set_associating(struct connman_network *network,
746 connman_bool_t associating)
748 DBG("network %p associating %d", network, associating);
750 if (network->associating == associating)
753 network->associating = associating;
755 if (associating == TRUE) {
756 struct connman_service *service;
758 service = __connman_service_lookup_from_network(network);
759 __connman_service_indicate_state(service,
760 CONNMAN_SERVICE_STATE_ASSOCIATION);
767 * connman_network_set_connected:
768 * @network: network structure
769 * @connected: connected state
771 * Change connected state of network
773 int connman_network_set_connected(struct connman_network *network,
774 connman_bool_t connected)
777 DBusMessageIter entry, value;
778 const char *key = "Connected";
780 DBG("network %p connected %d", network, connected);
782 if (network->connected == connected)
785 network->connected = connected;
787 if (connected == TRUE)
788 network->associating = FALSE;
790 if (network->registered == FALSE) {
791 g_idle_add(set_connected, network);
795 signal = dbus_message_new_signal(network->element.path,
796 CONNMAN_NETWORK_INTERFACE, "PropertyChanged");
800 dbus_message_iter_init_append(signal, &entry);
802 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
804 dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
805 DBUS_TYPE_BOOLEAN_AS_STRING, &value);
806 dbus_message_iter_append_basic(&value, DBUS_TYPE_BOOLEAN, &connected);
807 dbus_message_iter_close_container(&entry, &value);
809 g_dbus_send_message(connection, signal);
811 set_connected(network);
817 * connman_network_get_connected:
818 * @network: network structure
820 * Get network connection status
822 connman_bool_t connman_network_get_connected(struct connman_network *network)
824 return network->connected;
828 * connman_network_set_remember:
829 * @network: network structure
830 * @remember: remember state
832 * Change remember state of network (known networks)
834 int connman_network_set_remember(struct connman_network *network,
835 connman_bool_t remember)
838 DBusMessageIter entry, value;
839 const char *key = "Remember";
841 DBG("network %p remember %d", network, remember);
843 if (network->remember == remember)
846 network->remember = remember;
848 if (network->registered == FALSE)
851 signal = dbus_message_new_signal(network->element.path,
852 CONNMAN_NETWORK_INTERFACE, "PropertyChanged");
856 dbus_message_iter_init_append(signal, &entry);
858 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
860 dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
861 DBUS_TYPE_BOOLEAN_AS_STRING, &value);
862 dbus_message_iter_append_basic(&value, DBUS_TYPE_BOOLEAN, &remember);
863 dbus_message_iter_close_container(&entry, &value);
865 g_dbus_send_message(connection, signal);
871 * connman_network_get_remember:
872 * @network: network structure
874 * Get network remember setting
876 connman_bool_t connman_network_get_remember(struct connman_network *network)
878 return network->remember;
882 * connman_network_connect:
883 * @network: network structure
887 int connman_network_connect(struct connman_network *network)
889 if (network->connected == TRUE)
892 if (network->driver && network->driver->connect)
893 return network->driver->connect(network);
895 network->connected = TRUE;
900 int __connman_network_disconnect(struct connman_network *network)
902 if (network->connected == FALSE)
905 connman_element_unregister_children(&network->element);
907 if (network->driver && network->driver->disconnect)
908 return network->driver->disconnect(network);
910 network->connected = FALSE;
916 * connman_network_set_string:
917 * @network: network structure
918 * @key: unique identifier
919 * @value: string value
921 * Set string value for specific key
923 int connman_network_set_string(struct connman_network *network,
924 const char *key, const char *value)
926 DBG("network %p key %s value %s", network, key, value);
928 if (g_str_equal(key, "Address") == TRUE) {
929 g_free(network->address);
930 network->address = g_strdup(value);
931 } else if (g_str_equal(key, "Name") == TRUE) {
932 g_free(network->name);
933 network->name = g_strdup(value);
934 } else if (g_str_equal(key, "Node") == TRUE) {
935 g_free(network->node);
936 network->node = g_strdup(value);
937 } else if (g_str_equal(key, "WiFi.Mode") == TRUE) {
938 g_free(network->wifi.mode);
939 network->wifi.mode = g_strdup(value);
940 } else if (g_str_equal(key, "WiFi.Security") == TRUE) {
941 g_free(network->wifi.security);
942 network->wifi.security = g_strdup(value);
943 } else if (g_str_equal(key, "WiFi.Passphrase") == TRUE) {
944 g_free(network->wifi.passphrase);
945 network->wifi.passphrase = g_strdup(value);
948 return connman_element_set_string(&network->element, key, value);
952 * connman_network_get_string:
953 * @network: network structure
954 * @key: unique identifier
956 * Get string value for specific key
958 const char *connman_network_get_string(struct connman_network *network,
961 DBG("network %p key %s", network, key);
963 if (g_str_equal(key, "Address") == TRUE)
964 return network->address;
965 else if (g_str_equal(key, "Name") == TRUE)
966 return network->name;
967 else if (g_str_equal(key, "Node") == TRUE)
968 return network->node;
969 else if (g_str_equal(key, "WiFi.Mode") == TRUE)
970 return network->wifi.mode;
971 else if (g_str_equal(key, "WiFi.Security") == TRUE)
972 return network->wifi.security;
973 else if (g_str_equal(key, "WiFi.Passphrase") == TRUE)
974 return network->wifi.passphrase;
976 return connman_element_get_string(&network->element, key);
980 * connman_network_set_uint8:
981 * @network: network structure
982 * @key: unique identifier
983 * @value: integer value
985 * Set integer value for specific key
987 int connman_network_set_uint8(struct connman_network *network,
988 const char *key, connman_uint8_t value)
990 DBG("network %p key %s value %d", network, key, value);
992 if (g_str_equal(key, "Priority") == TRUE)
993 network->priority = value;
994 else if (g_str_equal(key, "Strength") == TRUE)
995 network->strength = value;
997 return connman_element_set_uint8(&network->element, key, value);
1001 * connman_network_get_uint8:
1002 * @network: network structure
1003 * @key: unique identifier
1005 * Get integer value for specific key
1007 connman_uint8_t connman_network_get_uint8(struct connman_network *network,
1010 DBG("network %p key %s", network, key);
1012 if (g_str_equal(key, "Priority") == TRUE)
1013 return network->priority;
1014 else if (g_str_equal(key, "Strength") == TRUE)
1015 return network->strength;
1017 return connman_element_get_uint8(&network->element, key);
1021 * connman_network_set_blob:
1022 * @network: network structure
1023 * @key: unique identifier
1027 * Set binary blob value for specific key
1029 int connman_network_set_blob(struct connman_network *network,
1030 const char *key, const void *data, unsigned int size)
1032 DBG("network %p key %s size %d", network, key, size);
1034 if (g_str_equal(key, "WiFi.SSID") == TRUE) {
1035 g_free(network->wifi.ssid);
1036 network->wifi.ssid = g_try_malloc(size);
1037 if (network->wifi.ssid != NULL) {
1038 memcpy(network->wifi.ssid, data, size);
1039 network->wifi.ssid_len = size;
1041 network->wifi.ssid_len = 0;
1044 return connman_element_set_blob(&network->element, key, data, size);
1048 * connman_network_get_blob:
1049 * @network: network structure
1050 * @key: unique identifier
1051 * @size: pointer to blob size
1053 * Get binary blob value for specific key
1055 const void *connman_network_get_blob(struct connman_network *network,
1056 const char *key, unsigned int *size)
1058 DBG("network %p key %s", network, key);
1060 if (g_str_equal(key, "WiFi.SSID") == TRUE) {
1062 *size = network->wifi.ssid_len;
1063 return network->wifi.ssid;
1066 return connman_element_get_blob(&network->element, key, size);
1069 void __connman_network_set_device(struct connman_network *network,
1070 struct connman_device *device)
1072 network->device = device;
1076 * connman_network_get_device:
1077 * @network: network structure
1079 * Get parent device of network
1081 struct connman_device *connman_network_get_device(struct connman_network *network)
1083 return network->device;
1087 * connman_network_get_data:
1088 * @network: network structure
1090 * Get private network data pointer
1092 void *connman_network_get_data(struct connman_network *network)
1094 return network->driver_data;
1098 * connman_network_set_data:
1099 * @network: network structure
1100 * @data: data pointer
1102 * Set private network data pointer
1104 void connman_network_set_data(struct connman_network *network, void *data)
1106 network->driver_data = data;
1109 static gboolean match_driver(struct connman_network *network,
1110 struct connman_network_driver *driver)
1112 if (network->type == driver->type ||
1113 driver->type == CONNMAN_NETWORK_TYPE_UNKNOWN)
1119 static int network_probe(struct connman_element *element)
1121 struct connman_network *network = element->network;
1125 DBG("element %p name %s", element, element->name);
1127 if (network == NULL)
1130 for (list = driver_list; list; list = list->next) {
1131 struct connman_network_driver *driver = list->data;
1133 if (match_driver(network, driver) == FALSE)
1136 DBG("driver %p name %s", driver, driver->name);
1138 if (driver->probe(network) == 0) {
1139 network->driver = driver;
1144 if (network->driver == NULL)
1147 err = register_interface(element);
1149 if (network->driver->remove)
1150 network->driver->remove(network);
1154 network->secondary = connman_device_get_secondary(network->device);
1156 switch (network->type) {
1157 case CONNMAN_NETWORK_TYPE_UNKNOWN:
1158 case CONNMAN_NETWORK_TYPE_VENDOR:
1159 case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
1160 case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
1161 case CONNMAN_NETWORK_TYPE_HSO:
1163 case CONNMAN_NETWORK_TYPE_WIFI:
1164 case CONNMAN_NETWORK_TYPE_WIMAX:
1165 if (network->secondary == FALSE)
1166 __connman_profile_add_network(network);
1173 static void network_remove(struct connman_element *element)
1175 struct connman_network *network = element->network;
1177 DBG("element %p name %s", element, element->name);
1179 if (network == NULL)
1182 if (network->driver == NULL)
1185 switch (network->type) {
1186 case CONNMAN_NETWORK_TYPE_UNKNOWN:
1187 case CONNMAN_NETWORK_TYPE_VENDOR:
1188 case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
1189 case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
1190 case CONNMAN_NETWORK_TYPE_HSO:
1192 case CONNMAN_NETWORK_TYPE_WIFI:
1193 case CONNMAN_NETWORK_TYPE_WIMAX:
1194 if (network->secondary == FALSE)
1195 __connman_profile_remove_network(network);
1199 unregister_interface(element);
1201 if (network->driver->remove)
1202 network->driver->remove(network);
1205 static void network_change(struct connman_element *element)
1207 struct connman_network *network = element->network;
1209 DBG("element %p name %s", element, element->name);
1211 if (element->state != CONNMAN_ELEMENT_STATE_ERROR)
1214 if (element->error != CONNMAN_ELEMENT_ERROR_DHCP_FAILED)
1217 if (network->connected == FALSE)
1220 connman_element_unregister_children(element);
1222 connman_device_set_disconnected(network->device, TRUE);
1224 if (network->driver && network->driver->disconnect) {
1225 network->driver->disconnect(network);
1229 network->connected = FALSE;
1232 static struct connman_driver network_driver = {
1234 .type = CONNMAN_ELEMENT_TYPE_NETWORK,
1235 .priority = CONNMAN_DRIVER_PRIORITY_LOW,
1236 .probe = network_probe,
1237 .remove = network_remove,
1238 .change = network_change,
1241 static int network_init(struct connman_device *device)
1243 DBG("device %p", device);
1248 static int network_load(struct connman_network *network)
1251 gchar *pathname, *data = NULL;
1257 DBG("network %p", network);
1259 name = connman_device_get_name(network->device);
1263 pathname = g_strdup_printf("%s/%s.conf", STORAGEDIR, name);
1264 if (pathname == NULL)
1267 keyfile = g_key_file_new();
1269 if (g_file_get_contents(pathname, &data, &length, NULL) == FALSE) {
1276 if (g_key_file_load_from_data(keyfile, data, length,
1277 0, NULL) == FALSE) {
1284 network->remember = g_key_file_get_boolean(keyfile,
1285 network->identifier, "Remember", NULL);
1287 val = g_key_file_get_integer(keyfile, network->identifier,
1290 network->priority = val;
1292 str = g_key_file_get_string(keyfile,
1293 network->identifier, "WiFi.Security", NULL);
1295 g_free(network->wifi.security);
1296 network->wifi.security = str;
1299 str = g_key_file_get_string(keyfile,
1300 network->identifier, "WiFi.Passphrase", NULL);
1302 g_free(network->wifi.passphrase);
1303 network->wifi.passphrase = str;
1306 g_key_file_free(keyfile);
1311 static int network_save(struct connman_network *network)
1314 gchar *pathname, *data = NULL;
1318 DBG("network %p", network);
1320 name = connman_device_get_name(network->device);
1324 pathname = g_strdup_printf("%s/%s.conf", STORAGEDIR, name);
1325 if (pathname == NULL)
1328 keyfile = g_key_file_new();
1330 if (g_file_get_contents(pathname, &data, &length, NULL) == FALSE)
1334 if (g_key_file_load_from_data(keyfile, data, length,
1342 g_key_file_set_boolean(keyfile, network->identifier,
1343 "Remember", network->remember);
1345 if (network->priority > 0)
1346 g_key_file_set_integer(keyfile, network->identifier,
1347 "Priority", network->priority);
1349 if (network->remember == TRUE || network->connected == TRUE) {
1350 if (network->wifi.security != NULL)
1351 g_key_file_set_string(keyfile, network->identifier,
1352 "WiFi.Security", network->wifi.security);
1354 if (network->wifi.passphrase != NULL)
1355 g_key_file_set_string(keyfile, network->identifier,
1356 "WiFi.Passphrase", network->wifi.passphrase);
1359 data = g_key_file_to_data(keyfile, &length, NULL);
1361 if (g_file_set_contents(pathname, data, length, NULL) == FALSE)
1362 connman_error("Failed to store network information");
1367 g_key_file_free(keyfile);
1374 static struct connman_storage network_storage = {
1376 .priority = CONNMAN_STORAGE_PRIORITY_LOW,
1377 .network_init = network_init,
1378 .network_load = network_load,
1379 .network_save = network_save,
1382 int __connman_network_init(void)
1386 connection = connman_dbus_get_connection();
1388 if (connman_storage_register(&network_storage) < 0)
1389 connman_error("Failed to register network storage");
1391 return connman_driver_register(&network_driver);
1394 void __connman_network_cleanup(void)
1398 connman_driver_unregister(&network_driver);
1400 connman_storage_unregister(&network_storage);
1402 dbus_connection_unref(connection);