5 * Copyright (C) 2007-2010 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
31 static unsigned int hidden_counter = 0;
33 struct connman_network {
34 struct connman_element element;
35 enum connman_network_type type;
36 connman_bool_t available;
37 connman_bool_t connected;
38 connman_bool_t roaming;
39 connman_bool_t hidden;
40 connman_uint8_t strength;
41 connman_uint16_t frequency;
48 struct connman_network_driver *driver;
51 connman_bool_t connecting;
52 connman_bool_t associating;
54 struct connman_device *device;
60 unsigned short channel;
66 char *client_cert_path;
67 char *private_key_path;
68 char *private_key_passphrase;
73 static const char *type2string(enum connman_network_type type)
76 case CONNMAN_NETWORK_TYPE_UNKNOWN:
77 case CONNMAN_NETWORK_TYPE_VENDOR:
79 case CONNMAN_NETWORK_TYPE_ETHERNET:
81 case CONNMAN_NETWORK_TYPE_WIFI:
83 case CONNMAN_NETWORK_TYPE_WIMAX:
85 case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
86 case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
88 case CONNMAN_NETWORK_TYPE_CELLULAR:
95 connman_bool_t __connman_network_has_driver(struct connman_network *network)
97 if (network == NULL || network->driver == NULL)
103 static GSList *driver_list = NULL;
105 static gint compare_priority(gconstpointer a, gconstpointer b)
107 const struct connman_network_driver *driver1 = a;
108 const struct connman_network_driver *driver2 = b;
110 return driver2->priority - driver1->priority;
114 * connman_network_driver_register:
115 * @driver: network driver definition
117 * Register a new network driver
119 * Returns: %0 on success
121 int connman_network_driver_register(struct connman_network_driver *driver)
125 DBG("driver %p name %s", driver, driver->name);
127 for (list = driver_list; list; list = list->next) {
128 struct connman_network_driver *tmp = list->data;
130 if (tmp->type == driver->type)
135 driver_list = g_slist_insert_sorted(driver_list, driver,
142 * connman_network_driver_unregister:
143 * @driver: network driver definition
145 * Remove a previously registered network driver
147 void connman_network_driver_unregister(struct connman_network_driver *driver)
149 DBG("driver %p name %s", driver, driver->name);
151 driver_list = g_slist_remove(driver_list, driver);
154 static void network_destruct(struct connman_element *element)
156 struct connman_network *network = element->network;
158 DBG("element %p name %s", element, element->name);
160 g_free(network->wifi.ssid);
161 g_free(network->wifi.mode);
162 g_free(network->wifi.security);
163 g_free(network->wifi.passphrase);
164 g_free(network->wifi.eap);
165 g_free(network->wifi.identity);
166 g_free(network->wifi.ca_cert_path);
167 g_free(network->wifi.client_cert_path);
168 g_free(network->wifi.private_key_path);
169 g_free(network->wifi.private_key_passphrase);
170 g_free(network->wifi.phase2_auth);
172 g_free(network->group);
173 g_free(network->node);
174 g_free(network->name);
175 g_free(network->address);
176 g_free(network->identifier);
178 network->device = NULL;
182 * connman_network_create:
183 * @identifier: network identifier (for example an unqiue name)
185 * Allocate a new network and assign the #identifier to it.
187 * Returns: a newly-allocated #connman_network structure
189 struct connman_network *connman_network_create(const char *identifier,
190 enum connman_network_type type)
192 struct connman_network *network;
193 connman_uint8_t strength = 0;
197 DBG("identifier %s type %d", identifier, type);
199 network = g_try_new0(struct connman_network, 1);
203 DBG("network %p", network);
205 __connman_element_initialize(&network->element);
207 if (identifier == NULL) {
208 temp = g_strdup_printf("hidden_%d", hidden_counter++);
209 network->hidden = TRUE;
211 temp = g_strdup(identifier);
218 network->element.name = temp;
219 network->element.type = CONNMAN_ELEMENT_TYPE_NETWORK;
221 network->element.network = network;
222 network->element.destruct = network_destruct;
224 str = type2string(type);
226 connman_element_set_string(&network->element, "Type", str);
228 connman_element_set_uint8(&network->element, "Strength", strength);
230 network->type = type;
231 network->identifier = g_strdup(temp);
237 * connman_network_ref:
238 * @network: network structure
240 * Increase reference counter of network
242 struct connman_network *connman_network_ref(struct connman_network *network)
244 if (connman_element_ref(&network->element) == NULL)
251 * connman_network_unref:
252 * @network: network structure
254 * Decrease reference counter of network
256 void connman_network_unref(struct connman_network *network)
258 connman_element_unref(&network->element);
261 const char *__connman_network_get_type(struct connman_network *network)
263 return type2string(network->type);
267 * connman_network_get_type:
268 * @network: network structure
270 * Get type of network
272 enum connman_network_type connman_network_get_type(struct connman_network *network)
274 return network->type;
278 * connman_network_get_identifier:
279 * @network: network structure
281 * Get identifier of network
283 const char *connman_network_get_identifier(struct connman_network *network)
285 return network->identifier;
289 * connman_network_set_index:
290 * @network: network structure
291 * @index: index number
293 * Set index number of network
295 void connman_network_set_index(struct connman_network *network, int index)
297 struct connman_service *service;
298 struct connman_ipconfig *ipconfig;
300 service = __connman_service_lookup_from_network(network);
304 ipconfig = __connman_service_get_ip4config(service);
306 DBG("index %d service %p ip4config %p", network->element.index,
309 if (network->element.index < 0 && ipconfig == NULL) {
311 ipconfig = __connman_service_get_ip4config(service);
312 if (ipconfig == NULL)
314 * This is needed for plugins that havent set their
315 * ipconfig layer yet, due to not being able to get
316 * a network index prior to creating a service.
318 __connman_service_create_ip4config(service, index);
320 __connman_ipconfig_set_index(ipconfig, index);
323 /* If index changed, the index of ipconfig must be reset. */
324 if (ipconfig == NULL)
327 __connman_ipconfig_set_index(ipconfig, index);
331 network->element.index = index;
335 * connman_network_get_index:
336 * @network: network structure
338 * Get index number of network
340 int connman_network_get_index(struct connman_network *network)
342 return network->element.index;
346 * connman_network_get_element:
347 * @network: network structure
349 * Get connman_element of network
351 struct connman_element *connman_network_get_element(
352 struct connman_network *network)
354 return &network->element;
358 * connman_network_set_group:
359 * @network: network structure
362 * Set group name for automatic clustering
364 void connman_network_set_group(struct connman_network *network,
367 switch (network->type) {
368 case CONNMAN_NETWORK_TYPE_UNKNOWN:
369 case CONNMAN_NETWORK_TYPE_VENDOR:
371 case CONNMAN_NETWORK_TYPE_ETHERNET:
372 case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
373 case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
374 case CONNMAN_NETWORK_TYPE_CELLULAR:
375 case CONNMAN_NETWORK_TYPE_WIFI:
376 case CONNMAN_NETWORK_TYPE_WIMAX:
380 if (g_strcmp0(network->group, group) == 0) {
382 __connman_profile_update_network(network);
386 if (network->group != NULL) {
387 __connman_profile_remove_network(network);
389 g_free(network->group);
392 network->group = g_strdup(group);
394 if (network->group != NULL)
395 __connman_profile_add_network(network);
399 * connman_network_get_group:
400 * @network: network structure
402 * Get group name for automatic clustering
404 const char *connman_network_get_group(struct connman_network *network)
406 return network->group;
409 const char *__connman_network_get_ident(struct connman_network *network)
411 if (network->device == NULL)
414 return connman_device_get_ident(network->device);
417 connman_bool_t __connman_network_get_weakness(struct connman_network *network)
419 switch (network->type) {
420 case CONNMAN_NETWORK_TYPE_UNKNOWN:
421 case CONNMAN_NETWORK_TYPE_VENDOR:
422 case CONNMAN_NETWORK_TYPE_ETHERNET:
423 case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
424 case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
425 case CONNMAN_NETWORK_TYPE_CELLULAR:
426 case CONNMAN_NETWORK_TYPE_WIMAX:
428 case CONNMAN_NETWORK_TYPE_WIFI:
429 if (g_strcmp0(network->wifi.mode, "adhoc") == 0)
431 if (network->strength > 0 && network->strength < 20)
439 connman_bool_t __connman_network_get_connecting(struct connman_network *network)
441 return network->connecting;
445 * connman_network_set_available:
446 * @network: network structure
447 * @available: availability state
449 * Change availability state of network (in range)
451 int connman_network_set_available(struct connman_network *network,
452 connman_bool_t available)
454 DBG("network %p available %d", network, available);
456 if (network->available == available)
459 network->available = available;
465 * connman_network_get_available:
466 * @network: network structure
468 * Get network available setting
470 connman_bool_t connman_network_get_available(struct connman_network *network)
472 if (network->hidden == TRUE)
475 return network->available;
479 * connman_network_set_associating:
480 * @network: network structure
481 * @associating: associating state
483 * Change associating state of network
485 int connman_network_set_associating(struct connman_network *network,
486 connman_bool_t associating)
488 DBG("network %p associating %d", network, associating);
490 if (network->associating == associating)
493 network->associating = associating;
495 if (associating == TRUE) {
496 struct connman_service *service;
498 service = __connman_service_lookup_from_network(network);
499 __connman_service_indicate_state(service,
500 CONNMAN_SERVICE_STATE_ASSOCIATION);
506 static void set_associate_error(struct connman_network *network)
508 struct connman_service *service;
510 if (network->associating == FALSE)
513 network->associating = FALSE;
515 service = __connman_service_lookup_from_network(network);
517 __connman_service_indicate_state(service,
518 CONNMAN_SERVICE_STATE_FAILURE);
521 static void set_configure_error(struct connman_network *network)
523 struct connman_service *service;
525 network->connecting = FALSE;
527 service = __connman_service_lookup_from_network(network);
529 __connman_service_indicate_state(service,
530 CONNMAN_SERVICE_STATE_FAILURE);
533 void connman_network_set_ipv4_method(struct connman_network *network,
534 enum connman_ipconfig_method method)
536 struct connman_service *service;
537 struct connman_ipconfig *ipconfig;
539 network->element.ipv4.method = method;
541 service = __connman_service_lookup_from_network(network);
545 ipconfig = __connman_service_get_ip4config(service);
546 if (ipconfig == NULL)
549 connman_ipconfig_set_method(ipconfig, method);
552 void connman_network_set_ipv6_method(struct connman_network *network,
553 enum connman_ipconfig_method method)
555 struct connman_service *service;
556 struct connman_ipconfig *ipconfig;
558 network->element.ipv6.method = method;
560 service = __connman_service_lookup_from_network(network);
564 ipconfig = __connman_service_get_ip6config(service);
565 if (ipconfig == NULL)
568 connman_ipconfig_set_method(ipconfig, method);
571 void connman_network_set_error(struct connman_network *network,
572 enum connman_network_error error)
574 DBG("nework %p, error %d", network, error);
576 network->connecting = FALSE;
579 case CONNMAN_NETWORK_ERROR_UNKNOWN:
581 case CONNMAN_NETWORK_ERROR_ASSOCIATE_FAIL:
582 set_associate_error(network);
584 case CONNMAN_NETWORK_ERROR_CONFIGURE_FAIL:
585 set_configure_error(network);
590 static void set_configuration(struct connman_network *network)
592 struct connman_service *service;
594 DBG("network %p", network);
596 __connman_device_increase_connections(network->device);
598 __connman_device_set_network(network->device, network);
600 connman_device_set_disconnected(network->device, FALSE);
602 service = __connman_service_lookup_from_network(network);
603 __connman_service_indicate_state(service,
604 CONNMAN_SERVICE_STATE_CONFIGURATION);
607 static int set_connected_fixed(struct connman_network *network)
609 struct connman_service *service;
610 struct connman_element *parent, *element;
614 service = __connman_service_lookup_from_network(network);
616 parent = connman_network_get_element(network);
618 set_configuration(network);
620 if (parent->ipv4.address == NULL)
623 if (parent->ipv4.netmask == NULL)
626 element = connman_element_create(NULL);
627 if (element == NULL) {
628 connman_error("Can not create connman_element");
632 element->type = CONNMAN_ELEMENT_TYPE_IPV4;
633 element->index = parent->index;
635 if (connman_element_register(element, parent) < 0) {
636 connman_error("Can not register connman_element");
640 network->connecting = FALSE;
642 connman_network_set_associating(network, FALSE);
647 static void set_connected_manual(struct connman_network *network)
649 struct connman_service *service;
650 struct connman_ipconfig *ipconfig;
651 const char *nameserver = NULL;
654 DBG("network %p", network);
656 service = __connman_service_lookup_from_network(network);
658 ipconfig = __connman_service_get_ip4config(service);
660 set_configuration(network);
662 err = __connman_ipconfig_set_address(ipconfig);
664 connman_network_set_error(network,
665 CONNMAN_NETWORK_ERROR_CONFIGURE_FAIL);
669 connman_element_get_value(&network->element,
670 CONNMAN_PROPERTY_ID_IPV4_NAMESERVER, &nameserver);
671 if (nameserver != NULL)
672 __connman_service_append_nameserver(service, nameserver);
674 __connman_ipconfig_set_gateway(ipconfig, &network->element);
676 network->connecting = FALSE;
678 connman_network_set_associating(network, FALSE);
680 __connman_service_indicate_state(service, CONNMAN_SERVICE_STATE_READY);
683 static int set_connected_dhcp(struct connman_network *network)
685 struct connman_element *element;
688 DBG("network %p", network);
690 element = connman_element_create(NULL);
694 element->type = CONNMAN_ELEMENT_TYPE_DHCP;
695 element->index = network->element.index;
697 error = connman_element_register(element, &network->element);
699 connman_element_unref(element);
703 set_configuration(network);
708 static int manual_ipv6_set(struct connman_network *network,
709 struct connman_ipconfig *ipconfig_ipv6)
711 struct connman_service *service;
714 service = __connman_service_lookup_from_network(network);
718 err = __connman_ipconfig_set_address(ipconfig_ipv6);
720 connman_network_set_error(network,
721 CONNMAN_NETWORK_ERROR_CONFIGURE_FAIL);
726 * READY state will be indicated by IPV4 setting
727 * gateway will be set by IPV4 setting
733 static gboolean set_connected(gpointer user_data)
735 struct connman_network *network = user_data;
736 struct connman_service *service;
737 struct connman_ipconfig *ipconfig_ipv4, *ipconfig_ipv6;
738 enum connman_ipconfig_method ipv4_method, ipv6_method;
740 service = __connman_service_lookup_from_network(network);
742 ipconfig_ipv4 = __connman_service_get_ip4config(service);
743 ipconfig_ipv6 = __connman_service_get_ip6config(service);
745 DBG("service %p ipv4 %p ipv6 %p", service, ipconfig_ipv4,
748 ipv4_method = __connman_ipconfig_get_method(ipconfig_ipv4);
749 ipv6_method = __connman_ipconfig_get_method(ipconfig_ipv6);
751 DBG("method ipv4 %d ipv6 %d", ipv4_method, ipv6_method);
752 DBG("network connected %d", network->connected);
754 if (network->connected == TRUE) {
757 switch (ipv6_method) {
758 case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
759 case CONNMAN_IPCONFIG_METHOD_OFF:
761 case CONNMAN_IPCONFIG_METHOD_FIXED:
762 case CONNMAN_IPCONFIG_METHOD_MANUAL:
763 ret = manual_ipv6_set(network, ipconfig_ipv6);
765 connman_network_set_error(network,
766 CONNMAN_NETWORK_ERROR_ASSOCIATE_FAIL);
770 case CONNMAN_IPCONFIG_METHOD_DHCP:
774 switch (ipv4_method) {
775 case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
776 case CONNMAN_IPCONFIG_METHOD_OFF:
778 case CONNMAN_IPCONFIG_METHOD_FIXED:
779 if (set_connected_fixed(network) < 0) {
780 connman_network_set_error(network,
781 CONNMAN_NETWORK_ERROR_ASSOCIATE_FAIL);
785 case CONNMAN_IPCONFIG_METHOD_MANUAL:
786 set_connected_manual(network);
788 case CONNMAN_IPCONFIG_METHOD_DHCP:
789 if (set_connected_dhcp(network) < 0) {
790 connman_network_set_error(network,
791 CONNMAN_NETWORK_ERROR_ASSOCIATE_FAIL);
797 struct connman_service *service;
799 connman_element_unregister_children(&network->element);
801 __connman_device_set_network(network->device, NULL);
802 network->hidden = FALSE;
804 service = __connman_service_lookup_from_network(network);
806 __connman_service_indicate_state(service,
807 CONNMAN_SERVICE_STATE_IDLE);
810 network->connecting = FALSE;
812 connman_network_set_associating(network, FALSE);
818 * connman_network_set_connected:
819 * @network: network structure
820 * @connected: connected state
822 * Change connected state of network
824 int connman_network_set_connected(struct connman_network *network,
825 connman_bool_t connected)
827 DBG("network %p connected %d", network, connected);
829 if ((network->connecting == TRUE || network->associating == TRUE) &&
830 connected == FALSE) {
831 connman_element_set_error(&network->element,
832 CONNMAN_ELEMENT_ERROR_CONNECT_FAILED);
833 __connman_network_disconnect(network);
836 if (network->connected == connected)
839 if (connected == FALSE)
840 __connman_device_decrease_connections(network->device);
842 network->connected = connected;
844 set_connected(network);
850 * connman_network_get_connected:
851 * @network: network structure
853 * Get network connection status
855 connman_bool_t connman_network_get_connected(struct connman_network *network)
857 return network->connected;
861 * connman_network_get_associating:
862 * @network: network structure
864 * Get network associating status
866 connman_bool_t connman_network_get_associating(struct connman_network *network)
868 return network->associating;
872 * __connman_network_connect:
873 * @network: network structure
877 int __connman_network_connect(struct connman_network *network)
879 struct connman_service *service;
882 DBG("network %p", network);
884 if (network->connected == TRUE)
887 if (network->connecting == TRUE || network->associating == TRUE)
890 if (network->driver == NULL)
893 if (network->driver->connect == NULL)
896 if (network->device == NULL)
899 network->connecting = TRUE;
901 __connman_device_disconnect(network->device);
903 service = __connman_service_lookup_from_network(network);
905 err = network->driver->connect(network);
907 if (err == -EINPROGRESS)
908 connman_network_set_associating(network, TRUE);
910 network->connecting = FALSE;
911 network->hidden = FALSE;
917 network->connected = TRUE;
918 set_connected(network);
924 * __connman_network_disconnect:
925 * @network: network structure
929 int __connman_network_disconnect(struct connman_network *network)
933 DBG("network %p", network);
935 if (network->connected == FALSE && network->connecting == FALSE &&
936 network->associating == FALSE)
939 if (network->driver == NULL)
942 if (network->driver->disconnect == NULL)
945 network->connecting = FALSE;
947 err = network->driver->disconnect(network);
949 connman_network_set_connected(network, FALSE);
950 set_connected(network);
956 static int dhcp_start(struct connman_network *network)
958 struct connman_element *element;
961 element = connman_element_create(NULL);
965 element->type = CONNMAN_ELEMENT_TYPE_DHCP;
966 element->index = network->element.index;
968 error = connman_element_register(element, &network->element);
970 connman_element_unref(element);
977 static int dhcp_stop(struct connman_network *network)
979 connman_element_unregister_children_type(&network->element,
980 CONNMAN_ELEMENT_TYPE_CONNECTION);
981 connman_element_unregister_children_type(&network->element,
982 CONNMAN_ELEMENT_TYPE_IPV4);
983 connman_element_unregister_children_type(&network->element,
984 CONNMAN_ELEMENT_TYPE_DHCP);
989 static int manual_ipv4_set(struct connman_network *network,
990 struct connman_ipconfig *ipconfig)
992 struct connman_service *service;
995 service = __connman_service_lookup_from_network(network);
999 err = __connman_ipconfig_set_address(ipconfig);
1001 connman_network_set_error(network,
1002 CONNMAN_NETWORK_ERROR_CONFIGURE_FAIL);
1006 __connman_ipconfig_set_gateway(ipconfig, &network->element);
1008 __connman_service_indicate_state(service, CONNMAN_SERVICE_STATE_READY);
1013 int __connman_network_clear_ipconfig(struct connman_network *network,
1014 struct connman_ipconfig *ipconfig)
1016 struct connman_service *service;
1017 enum connman_ipconfig_method method;
1019 service = __connman_service_lookup_from_network(network);
1020 if (service == NULL)
1023 method = __connman_ipconfig_get_method(ipconfig);
1026 case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
1027 case CONNMAN_IPCONFIG_METHOD_OFF:
1028 case CONNMAN_IPCONFIG_METHOD_FIXED:
1030 case CONNMAN_IPCONFIG_METHOD_MANUAL:
1031 connman_element_unregister_children_type(&network->element,
1032 CONNMAN_ELEMENT_TYPE_CONNECTION);
1033 __connman_ipconfig_clear_address(ipconfig);
1035 case CONNMAN_IPCONFIG_METHOD_DHCP:
1040 __connman_service_indicate_state(service,
1041 CONNMAN_SERVICE_STATE_CONFIGURATION);
1046 int __connman_network_set_ipconfig(struct connman_network *network,
1047 struct connman_ipconfig *ipconfig_ipv4,
1048 struct connman_ipconfig *ipconfig_ipv6)
1050 enum connman_ipconfig_method method;
1053 if (ipconfig_ipv6) {
1054 method = __connman_ipconfig_get_method(ipconfig_ipv6);
1057 case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
1058 case CONNMAN_IPCONFIG_METHOD_OFF:
1060 case CONNMAN_IPCONFIG_METHOD_FIXED:
1061 case CONNMAN_IPCONFIG_METHOD_MANUAL:
1062 ret = manual_ipv6_set(network, ipconfig_ipv6);
1064 connman_network_set_error(network,
1065 CONNMAN_NETWORK_ERROR_ASSOCIATE_FAIL);
1069 case CONNMAN_IPCONFIG_METHOD_DHCP:
1074 if (ipconfig_ipv4) {
1075 method = __connman_ipconfig_get_method(ipconfig_ipv4);
1078 case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
1079 case CONNMAN_IPCONFIG_METHOD_OFF:
1080 case CONNMAN_IPCONFIG_METHOD_FIXED:
1082 case CONNMAN_IPCONFIG_METHOD_MANUAL:
1083 return manual_ipv4_set(network, ipconfig_ipv4);
1084 case CONNMAN_IPCONFIG_METHOD_DHCP:
1085 return dhcp_start(network);
1093 * connman_network_set_address:
1094 * @network: network structure
1095 * @address: binary address value
1096 * @size: binary address length
1098 * Set unique address value for network
1100 int connman_network_set_address(struct connman_network *network,
1101 const void *address, unsigned int size)
1103 const unsigned char *addr_octet = address;
1106 DBG("network %p size %d", network, size);
1111 str = g_strdup_printf("%02X:%02X:%02X:%02X:%02X:%02X",
1112 addr_octet[0], addr_octet[1], addr_octet[2],
1113 addr_octet[3], addr_octet[4], addr_octet[5]);
1117 g_free(network->address);
1118 network->address = str;
1120 return connman_element_set_string(&network->element,
1121 "Address", network->address);
1125 * connman_network_set_name:
1126 * @network: network structure
1129 * Set display name value for network
1131 int connman_network_set_name(struct connman_network *network,
1134 DBG("network %p name %s", network, name);
1136 g_free(network->name);
1137 network->name = g_strdup(name);
1139 return connman_element_set_string(&network->element, "Name", name);
1143 * connman_network_set_strength:
1144 * @network: network structure
1145 * @strength: strength value
1147 * Set signal strength value for network
1149 int connman_network_set_strength(struct connman_network *network,
1150 connman_uint8_t strength)
1152 DBG("network %p strengh %d", network, strength);
1154 network->strength = strength;
1156 return connman_element_set_uint8(&network->element,
1157 "Strength", strength);
1161 * connman_network_set_roaming:
1162 * @network: network structure
1163 * @roaming: roaming state
1165 * Set roaming state for network
1167 int connman_network_set_roaming(struct connman_network *network,
1168 connman_bool_t roaming)
1170 DBG("network %p roaming %d", network, roaming);
1172 network->roaming = roaming;
1174 return connman_element_set_bool(&network->element,
1175 "Roaming", roaming);
1179 * connman_network_set_string:
1180 * @network: network structure
1181 * @key: unique identifier
1182 * @value: string value
1184 * Set string value for specific key
1186 int connman_network_set_string(struct connman_network *network,
1187 const char *key, const char *value)
1191 DBG("network %p key %s value %s", network, key, value);
1193 if (g_strcmp0(key, "Name") == 0)
1194 return connman_network_set_name(network, value);
1196 if (g_str_equal(key, "Address") == TRUE) {
1197 g_free(network->address);
1198 network->address = g_strdup(value);
1199 } else if (g_str_equal(key, "Node") == TRUE) {
1200 g_free(network->node);
1201 network->node = g_strdup(value);
1202 } else if (g_str_equal(key, "WiFi.Mode") == TRUE) {
1203 g_free(network->wifi.mode);
1204 network->wifi.mode = g_strdup(value);
1205 } else if (g_str_equal(key, "WiFi.Security") == TRUE) {
1206 g_free(network->wifi.security);
1207 network->wifi.security = g_strdup(value);
1208 } else if (g_str_equal(key, "WiFi.Passphrase") == TRUE) {
1209 g_free(network->wifi.passphrase);
1210 network->wifi.passphrase = g_strdup(value);
1211 } else if (g_str_equal(key, "WiFi.EAP") == TRUE) {
1212 g_free(network->wifi.eap);
1213 network->wifi.eap = g_strdup(value);
1214 } else if (g_str_equal(key, "WiFi.Identity") == TRUE) {
1215 g_free(network->wifi.identity);
1216 network->wifi.identity = g_strdup(value);
1217 } else if (g_str_equal(key, "WiFi.CACertFile") == TRUE) {
1218 g_free(network->wifi.ca_cert_path);
1219 network->wifi.ca_cert_path = g_strdup(value);
1220 } else if (g_str_equal(key, "WiFi.ClientCertFile") == TRUE) {
1221 g_free(network->wifi.client_cert_path);
1222 network->wifi.client_cert_path = g_strdup(value);
1223 } else if (g_str_equal(key, "WiFi.PrivateKeyFile") == TRUE) {
1224 g_free(network->wifi.private_key_path);
1225 network->wifi.private_key_path = g_strdup(value);
1226 } else if (g_str_equal(key, "WiFi.PrivateKeyPassphrase") == TRUE) {
1227 g_free(network->wifi.private_key_passphrase);
1228 network->wifi.private_key_passphrase = g_strdup(value);
1229 } else if (g_str_equal(key, "WiFi.Phase2") == TRUE) {
1230 g_free(network->wifi.phase2_auth);
1231 network->wifi.phase2_auth = g_strdup(value);
1234 err = connman_element_set_string(&network->element, key, value);
1238 if (network->driver == NULL)
1241 if (network->driver->setup)
1242 return network->driver->setup(network, key);
1248 * connman_network_get_string:
1249 * @network: network structure
1250 * @key: unique identifier
1252 * Get string value for specific key
1254 const char *connman_network_get_string(struct connman_network *network,
1257 DBG("network %p key %s", network, key);
1259 if (g_str_equal(key, "Address") == TRUE)
1260 return network->address;
1261 else if (g_str_equal(key, "Name") == TRUE)
1262 return network->name;
1263 else if (g_str_equal(key, "Node") == TRUE)
1264 return network->node;
1265 else if (g_str_equal(key, "WiFi.Mode") == TRUE)
1266 return network->wifi.mode;
1267 else if (g_str_equal(key, "WiFi.Security") == TRUE)
1268 return network->wifi.security;
1269 else if (g_str_equal(key, "WiFi.Passphrase") == TRUE)
1270 return network->wifi.passphrase;
1271 else if (g_str_equal(key, "WiFi.EAP") == TRUE)
1272 return network->wifi.eap;
1273 else if (g_str_equal(key, "WiFi.Identity") == TRUE)
1274 return network->wifi.identity;
1275 else if (g_str_equal(key, "WiFi.CACertFile") == TRUE)
1276 return network->wifi.ca_cert_path;
1277 else if (g_str_equal(key, "WiFi.ClientCertFile") == TRUE)
1278 return network->wifi.client_cert_path;
1279 else if (g_str_equal(key, "WiFi.PrivateKeyFile") == TRUE)
1280 return network->wifi.private_key_path;
1281 else if (g_str_equal(key, "WiFi.PrivateKeyPassphrase") == TRUE)
1282 return network->wifi.private_key_passphrase;
1283 else if (g_str_equal(key, "WiFi.Phase2") == TRUE)
1284 return network->wifi.phase2_auth;
1286 return connman_element_get_string(&network->element, key);
1290 * connman_network_set_bool:
1291 * @network: network structure
1292 * @key: unique identifier
1293 * @value: boolean value
1295 * Set boolean value for specific key
1297 int connman_network_set_bool(struct connman_network *network,
1298 const char *key, connman_bool_t value)
1300 DBG("network %p key %s value %d", network, key, value);
1302 if (g_strcmp0(key, "Roaming") == 0)
1303 return connman_network_set_roaming(network, value);
1305 return connman_element_set_bool(&network->element, key, value);
1309 * connman_network_get_bool:
1310 * @network: network structure
1311 * @key: unique identifier
1313 * Get boolean value for specific key
1315 connman_bool_t connman_network_get_bool(struct connman_network *network,
1318 DBG("network %p key %s", network, key);
1320 if (g_str_equal(key, "Roaming") == TRUE)
1321 return network->roaming;
1323 return connman_element_get_bool(&network->element, key);
1327 * connman_network_set_uint8:
1328 * @network: network structure
1329 * @key: unique identifier
1330 * @value: integer value
1332 * Set integer value for specific key
1334 int connman_network_set_uint8(struct connman_network *network,
1335 const char *key, connman_uint8_t value)
1337 DBG("network %p key %s value %d", network, key, value);
1339 if (g_strcmp0(key, "Strength") == 0)
1340 return connman_network_set_strength(network, value);
1342 return connman_element_set_uint8(&network->element, key, value);
1346 * connman_network_get_uint8:
1347 * @network: network structure
1348 * @key: unique identifier
1350 * Get integer value for specific key
1352 connman_uint8_t connman_network_get_uint8(struct connman_network *network,
1355 DBG("network %p key %s", network, key);
1357 if (g_str_equal(key, "Strength") == TRUE)
1358 return network->strength;
1360 return connman_element_get_uint8(&network->element, key);
1364 * connman_network_set_uint16:
1365 * @network: network structure
1366 * @key: unique identifier
1367 * @value: integer value
1369 * Set integer value for specific key
1371 int connman_network_set_uint16(struct connman_network *network,
1372 const char *key, connman_uint16_t value)
1374 DBG("network %p key %s value %d", network, key, value);
1376 if (g_str_equal(key, "Frequency") == TRUE)
1377 network->frequency = value;
1378 else if (g_str_equal(key, "WiFi.Channel") == TRUE)
1379 network->wifi.channel = value;
1385 * connman_network_get_uint16:
1386 * @network: network structure
1387 * @key: unique identifier
1389 * Get integer value for specific key
1391 connman_uint16_t connman_network_get_uint16(struct connman_network *network,
1394 DBG("network %p key %s", network, key);
1396 if (g_str_equal(key, "Frequency") == TRUE)
1397 return network->frequency;
1398 else if (g_str_equal(key, "WiFi.Channel") == TRUE)
1399 return network->wifi.channel;
1405 * connman_network_set_blob:
1406 * @network: network structure
1407 * @key: unique identifier
1411 * Set binary blob value for specific key
1413 int connman_network_set_blob(struct connman_network *network,
1414 const char *key, const void *data, unsigned int size)
1416 DBG("network %p key %s size %d", network, key, size);
1418 if (g_strcmp0(key, "Address") == 0)
1419 return connman_network_set_address(network, data, size);
1421 if (g_str_equal(key, "WiFi.SSID") == TRUE) {
1422 g_free(network->wifi.ssid);
1423 network->wifi.ssid = g_try_malloc(size);
1424 if (network->wifi.ssid != NULL) {
1425 memcpy(network->wifi.ssid, data, size);
1426 network->wifi.ssid_len = size;
1428 network->wifi.ssid_len = 0;
1431 return connman_element_set_blob(&network->element, key, data, size);
1435 * connman_network_get_blob:
1436 * @network: network structure
1437 * @key: unique identifier
1438 * @size: pointer to blob size
1440 * Get binary blob value for specific key
1442 const void *connman_network_get_blob(struct connman_network *network,
1443 const char *key, unsigned int *size)
1445 DBG("network %p key %s", network, key);
1447 if (g_str_equal(key, "WiFi.SSID") == TRUE) {
1449 *size = network->wifi.ssid_len;
1450 return network->wifi.ssid;
1453 return connman_element_get_blob(&network->element, key, size);
1456 void __connman_network_set_device(struct connman_network *network,
1457 struct connman_device *device)
1459 network->device = device;
1463 * connman_network_get_device:
1464 * @network: network structure
1466 * Get parent device of network
1468 struct connman_device *connman_network_get_device(struct connman_network *network)
1470 return network->device;
1474 * connman_network_get_data:
1475 * @network: network structure
1477 * Get private network data pointer
1479 void *connman_network_get_data(struct connman_network *network)
1481 return network->driver_data;
1485 * connman_network_set_data:
1486 * @network: network structure
1487 * @data: data pointer
1489 * Set private network data pointer
1491 void connman_network_set_data(struct connman_network *network, void *data)
1493 network->driver_data = data;
1496 void connman_network_update(struct connman_network *network)
1498 switch (network->type) {
1499 case CONNMAN_NETWORK_TYPE_UNKNOWN:
1500 case CONNMAN_NETWORK_TYPE_VENDOR:
1502 case CONNMAN_NETWORK_TYPE_ETHERNET:
1503 case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
1504 case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
1505 case CONNMAN_NETWORK_TYPE_CELLULAR:
1506 case CONNMAN_NETWORK_TYPE_WIFI:
1507 case CONNMAN_NETWORK_TYPE_WIMAX:
1511 if (network->group != NULL)
1512 __connman_service_update_from_network(network);
1517 static gboolean match_driver(struct connman_network *network,
1518 struct connman_network_driver *driver)
1520 if (network->type == driver->type ||
1521 driver->type == CONNMAN_NETWORK_TYPE_UNKNOWN)
1527 static int network_probe(struct connman_element *element)
1529 struct connman_network *network = element->network;
1532 DBG("element %p name %s", element, element->name);
1534 if (network == NULL)
1537 for (list = driver_list; list; list = list->next) {
1538 struct connman_network_driver *driver = list->data;
1540 if (match_driver(network, driver) == FALSE)
1543 DBG("driver %p name %s", driver, driver->name);
1545 if (driver->probe(network) == 0) {
1546 network->driver = driver;
1551 if (network->driver == NULL)
1554 switch (network->type) {
1555 case CONNMAN_NETWORK_TYPE_UNKNOWN:
1556 case CONNMAN_NETWORK_TYPE_VENDOR:
1558 case CONNMAN_NETWORK_TYPE_ETHERNET:
1559 case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
1560 case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
1561 case CONNMAN_NETWORK_TYPE_CELLULAR:
1562 case CONNMAN_NETWORK_TYPE_WIFI:
1563 case CONNMAN_NETWORK_TYPE_WIMAX:
1564 if (network->group != NULL)
1565 __connman_profile_add_network(network);
1572 static void network_remove(struct connman_element *element)
1574 struct connman_network *network = element->network;
1576 DBG("element %p name %s", element, element->name);
1578 if (network == NULL)
1581 if (network->driver == NULL)
1584 switch (network->type) {
1585 case CONNMAN_NETWORK_TYPE_UNKNOWN:
1586 case CONNMAN_NETWORK_TYPE_VENDOR:
1588 case CONNMAN_NETWORK_TYPE_ETHERNET:
1589 case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
1590 case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
1591 case CONNMAN_NETWORK_TYPE_CELLULAR:
1592 case CONNMAN_NETWORK_TYPE_WIFI:
1593 case CONNMAN_NETWORK_TYPE_WIMAX:
1594 if (network->group != NULL) {
1595 __connman_profile_remove_network(network);
1597 g_free(network->group);
1598 network->group = NULL;
1603 if (network->driver->remove)
1604 network->driver->remove(network);
1607 static void network_change(struct connman_element *element)
1609 struct connman_network *network = element->network;
1611 DBG("element %p name %s", element, element->name);
1613 if (element->state != CONNMAN_ELEMENT_STATE_ERROR)
1616 if (element->error != CONNMAN_ELEMENT_ERROR_DHCP_FAILED)
1619 if (network->connected == FALSE)
1622 connman_element_unregister_children(element);
1624 connman_device_set_disconnected(network->device, TRUE);
1626 if (network->driver && network->driver->disconnect) {
1627 network->driver->disconnect(network);
1631 network->connected = FALSE;
1634 static struct connman_driver network_driver = {
1636 .type = CONNMAN_ELEMENT_TYPE_NETWORK,
1637 .priority = CONNMAN_DRIVER_PRIORITY_LOW,
1638 .probe = network_probe,
1639 .remove = network_remove,
1640 .change = network_change,
1643 int __connman_network_init(void)
1647 return connman_driver_register(&network_driver);
1650 void __connman_network_cleanup(void)
1654 connman_driver_unregister(&network_driver);