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:
760 case CONNMAN_IPCONFIG_METHOD_AUTO:
762 case CONNMAN_IPCONFIG_METHOD_FIXED:
763 case CONNMAN_IPCONFIG_METHOD_MANUAL:
764 ret = manual_ipv6_set(network, ipconfig_ipv6);
766 connman_network_set_error(network,
767 CONNMAN_NETWORK_ERROR_ASSOCIATE_FAIL);
771 case CONNMAN_IPCONFIG_METHOD_DHCP:
775 switch (ipv4_method) {
776 case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
777 case CONNMAN_IPCONFIG_METHOD_OFF:
778 case CONNMAN_IPCONFIG_METHOD_AUTO:
780 case CONNMAN_IPCONFIG_METHOD_FIXED:
781 if (set_connected_fixed(network) < 0) {
782 connman_network_set_error(network,
783 CONNMAN_NETWORK_ERROR_ASSOCIATE_FAIL);
787 case CONNMAN_IPCONFIG_METHOD_MANUAL:
788 set_connected_manual(network);
790 case CONNMAN_IPCONFIG_METHOD_DHCP:
791 if (set_connected_dhcp(network) < 0) {
792 connman_network_set_error(network,
793 CONNMAN_NETWORK_ERROR_ASSOCIATE_FAIL);
799 struct connman_service *service;
801 connman_element_unregister_children(&network->element);
803 __connman_device_set_network(network->device, NULL);
804 network->hidden = FALSE;
806 service = __connman_service_lookup_from_network(network);
808 __connman_service_indicate_state(service,
809 CONNMAN_SERVICE_STATE_IDLE);
812 network->connecting = FALSE;
814 connman_network_set_associating(network, FALSE);
820 * connman_network_set_connected:
821 * @network: network structure
822 * @connected: connected state
824 * Change connected state of network
826 int connman_network_set_connected(struct connman_network *network,
827 connman_bool_t connected)
829 DBG("network %p connected %d", network, connected);
831 if ((network->connecting == TRUE || network->associating == TRUE) &&
832 connected == FALSE) {
833 connman_element_set_error(&network->element,
834 CONNMAN_ELEMENT_ERROR_CONNECT_FAILED);
835 __connman_network_disconnect(network);
838 if (network->connected == connected)
841 if (connected == FALSE)
842 __connman_device_decrease_connections(network->device);
844 network->connected = connected;
846 set_connected(network);
852 * connman_network_get_connected:
853 * @network: network structure
855 * Get network connection status
857 connman_bool_t connman_network_get_connected(struct connman_network *network)
859 return network->connected;
863 * connman_network_get_associating:
864 * @network: network structure
866 * Get network associating status
868 connman_bool_t connman_network_get_associating(struct connman_network *network)
870 return network->associating;
874 * __connman_network_connect:
875 * @network: network structure
879 int __connman_network_connect(struct connman_network *network)
881 struct connman_service *service;
884 DBG("network %p", network);
886 if (network->connected == TRUE)
889 if (network->connecting == TRUE || network->associating == TRUE)
892 if (network->driver == NULL)
895 if (network->driver->connect == NULL)
898 if (network->device == NULL)
901 network->connecting = TRUE;
903 __connman_device_disconnect(network->device);
905 service = __connman_service_lookup_from_network(network);
907 err = network->driver->connect(network);
909 if (err == -EINPROGRESS)
910 connman_network_set_associating(network, TRUE);
912 network->connecting = FALSE;
913 network->hidden = FALSE;
919 network->connected = TRUE;
920 set_connected(network);
926 * __connman_network_disconnect:
927 * @network: network structure
931 int __connman_network_disconnect(struct connman_network *network)
935 DBG("network %p", network);
937 if (network->connected == FALSE && network->connecting == FALSE &&
938 network->associating == FALSE)
941 if (network->driver == NULL)
944 if (network->driver->disconnect == NULL)
947 network->connecting = FALSE;
949 err = network->driver->disconnect(network);
951 connman_network_set_connected(network, FALSE);
952 set_connected(network);
958 static int dhcp_start(struct connman_network *network)
960 struct connman_element *element;
963 element = connman_element_create(NULL);
967 element->type = CONNMAN_ELEMENT_TYPE_DHCP;
968 element->index = network->element.index;
970 error = connman_element_register(element, &network->element);
972 connman_element_unref(element);
979 static int dhcp_stop(struct connman_network *network)
981 connman_element_unregister_children_type(&network->element,
982 CONNMAN_ELEMENT_TYPE_CONNECTION);
983 connman_element_unregister_children_type(&network->element,
984 CONNMAN_ELEMENT_TYPE_IPV4);
985 connman_element_unregister_children_type(&network->element,
986 CONNMAN_ELEMENT_TYPE_DHCP);
991 static int manual_ipv4_set(struct connman_network *network,
992 struct connman_ipconfig *ipconfig)
994 struct connman_service *service;
997 service = __connman_service_lookup_from_network(network);
1001 err = __connman_ipconfig_set_address(ipconfig);
1003 connman_network_set_error(network,
1004 CONNMAN_NETWORK_ERROR_CONFIGURE_FAIL);
1008 __connman_ipconfig_set_gateway(ipconfig, &network->element);
1010 __connman_service_indicate_state(service, CONNMAN_SERVICE_STATE_READY);
1015 int __connman_network_clear_ipconfig(struct connman_network *network,
1016 struct connman_ipconfig *ipconfig)
1018 struct connman_service *service;
1019 enum connman_ipconfig_method method;
1021 service = __connman_service_lookup_from_network(network);
1022 if (service == NULL)
1025 method = __connman_ipconfig_get_method(ipconfig);
1028 case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
1029 case CONNMAN_IPCONFIG_METHOD_OFF:
1030 case CONNMAN_IPCONFIG_METHOD_FIXED:
1031 case CONNMAN_IPCONFIG_METHOD_AUTO:
1033 case CONNMAN_IPCONFIG_METHOD_MANUAL:
1034 connman_element_unregister_children_type(&network->element,
1035 CONNMAN_ELEMENT_TYPE_CONNECTION);
1036 __connman_ipconfig_clear_address(ipconfig);
1038 case CONNMAN_IPCONFIG_METHOD_DHCP:
1043 __connman_service_indicate_state(service,
1044 CONNMAN_SERVICE_STATE_CONFIGURATION);
1049 int __connman_network_set_ipconfig(struct connman_network *network,
1050 struct connman_ipconfig *ipconfig_ipv4,
1051 struct connman_ipconfig *ipconfig_ipv6)
1053 enum connman_ipconfig_method method;
1056 if (ipconfig_ipv6) {
1057 method = __connman_ipconfig_get_method(ipconfig_ipv6);
1060 case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
1061 case CONNMAN_IPCONFIG_METHOD_OFF:
1062 case CONNMAN_IPCONFIG_METHOD_AUTO:
1064 case CONNMAN_IPCONFIG_METHOD_FIXED:
1065 case CONNMAN_IPCONFIG_METHOD_MANUAL:
1066 ret = manual_ipv6_set(network, ipconfig_ipv6);
1068 connman_network_set_error(network,
1069 CONNMAN_NETWORK_ERROR_ASSOCIATE_FAIL);
1073 case CONNMAN_IPCONFIG_METHOD_DHCP:
1078 if (ipconfig_ipv4) {
1079 method = __connman_ipconfig_get_method(ipconfig_ipv4);
1082 case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
1083 case CONNMAN_IPCONFIG_METHOD_OFF:
1084 case CONNMAN_IPCONFIG_METHOD_FIXED:
1085 case CONNMAN_IPCONFIG_METHOD_AUTO:
1087 case CONNMAN_IPCONFIG_METHOD_MANUAL:
1088 return manual_ipv4_set(network, ipconfig_ipv4);
1089 case CONNMAN_IPCONFIG_METHOD_DHCP:
1090 return dhcp_start(network);
1098 * connman_network_set_address:
1099 * @network: network structure
1100 * @address: binary address value
1101 * @size: binary address length
1103 * Set unique address value for network
1105 int connman_network_set_address(struct connman_network *network,
1106 const void *address, unsigned int size)
1108 const unsigned char *addr_octet = address;
1111 DBG("network %p size %d", network, size);
1116 str = g_strdup_printf("%02X:%02X:%02X:%02X:%02X:%02X",
1117 addr_octet[0], addr_octet[1], addr_octet[2],
1118 addr_octet[3], addr_octet[4], addr_octet[5]);
1122 g_free(network->address);
1123 network->address = str;
1125 return connman_element_set_string(&network->element,
1126 "Address", network->address);
1130 * connman_network_set_name:
1131 * @network: network structure
1134 * Set display name value for network
1136 int connman_network_set_name(struct connman_network *network,
1139 DBG("network %p name %s", network, name);
1141 g_free(network->name);
1142 network->name = g_strdup(name);
1144 return connman_element_set_string(&network->element, "Name", name);
1148 * connman_network_set_strength:
1149 * @network: network structure
1150 * @strength: strength value
1152 * Set signal strength value for network
1154 int connman_network_set_strength(struct connman_network *network,
1155 connman_uint8_t strength)
1157 DBG("network %p strengh %d", network, strength);
1159 network->strength = strength;
1161 return connman_element_set_uint8(&network->element,
1162 "Strength", strength);
1166 * connman_network_set_roaming:
1167 * @network: network structure
1168 * @roaming: roaming state
1170 * Set roaming state for network
1172 int connman_network_set_roaming(struct connman_network *network,
1173 connman_bool_t roaming)
1175 DBG("network %p roaming %d", network, roaming);
1177 network->roaming = roaming;
1179 return connman_element_set_bool(&network->element,
1180 "Roaming", roaming);
1184 * connman_network_set_string:
1185 * @network: network structure
1186 * @key: unique identifier
1187 * @value: string value
1189 * Set string value for specific key
1191 int connman_network_set_string(struct connman_network *network,
1192 const char *key, const char *value)
1196 DBG("network %p key %s value %s", network, key, value);
1198 if (g_strcmp0(key, "Name") == 0)
1199 return connman_network_set_name(network, value);
1201 if (g_str_equal(key, "Address") == TRUE) {
1202 g_free(network->address);
1203 network->address = g_strdup(value);
1204 } else if (g_str_equal(key, "Node") == TRUE) {
1205 g_free(network->node);
1206 network->node = g_strdup(value);
1207 } else if (g_str_equal(key, "WiFi.Mode") == TRUE) {
1208 g_free(network->wifi.mode);
1209 network->wifi.mode = g_strdup(value);
1210 } else if (g_str_equal(key, "WiFi.Security") == TRUE) {
1211 g_free(network->wifi.security);
1212 network->wifi.security = g_strdup(value);
1213 } else if (g_str_equal(key, "WiFi.Passphrase") == TRUE) {
1214 g_free(network->wifi.passphrase);
1215 network->wifi.passphrase = g_strdup(value);
1216 } else if (g_str_equal(key, "WiFi.EAP") == TRUE) {
1217 g_free(network->wifi.eap);
1218 network->wifi.eap = g_strdup(value);
1219 } else if (g_str_equal(key, "WiFi.Identity") == TRUE) {
1220 g_free(network->wifi.identity);
1221 network->wifi.identity = g_strdup(value);
1222 } else if (g_str_equal(key, "WiFi.CACertFile") == TRUE) {
1223 g_free(network->wifi.ca_cert_path);
1224 network->wifi.ca_cert_path = g_strdup(value);
1225 } else if (g_str_equal(key, "WiFi.ClientCertFile") == TRUE) {
1226 g_free(network->wifi.client_cert_path);
1227 network->wifi.client_cert_path = g_strdup(value);
1228 } else if (g_str_equal(key, "WiFi.PrivateKeyFile") == TRUE) {
1229 g_free(network->wifi.private_key_path);
1230 network->wifi.private_key_path = g_strdup(value);
1231 } else if (g_str_equal(key, "WiFi.PrivateKeyPassphrase") == TRUE) {
1232 g_free(network->wifi.private_key_passphrase);
1233 network->wifi.private_key_passphrase = g_strdup(value);
1234 } else if (g_str_equal(key, "WiFi.Phase2") == TRUE) {
1235 g_free(network->wifi.phase2_auth);
1236 network->wifi.phase2_auth = g_strdup(value);
1239 err = connman_element_set_string(&network->element, key, value);
1243 if (network->driver == NULL)
1246 if (network->driver->setup)
1247 return network->driver->setup(network, key);
1253 * connman_network_get_string:
1254 * @network: network structure
1255 * @key: unique identifier
1257 * Get string value for specific key
1259 const char *connman_network_get_string(struct connman_network *network,
1262 DBG("network %p key %s", network, key);
1264 if (g_str_equal(key, "Address") == TRUE)
1265 return network->address;
1266 else if (g_str_equal(key, "Name") == TRUE)
1267 return network->name;
1268 else if (g_str_equal(key, "Node") == TRUE)
1269 return network->node;
1270 else if (g_str_equal(key, "WiFi.Mode") == TRUE)
1271 return network->wifi.mode;
1272 else if (g_str_equal(key, "WiFi.Security") == TRUE)
1273 return network->wifi.security;
1274 else if (g_str_equal(key, "WiFi.Passphrase") == TRUE)
1275 return network->wifi.passphrase;
1276 else if (g_str_equal(key, "WiFi.EAP") == TRUE)
1277 return network->wifi.eap;
1278 else if (g_str_equal(key, "WiFi.Identity") == TRUE)
1279 return network->wifi.identity;
1280 else if (g_str_equal(key, "WiFi.CACertFile") == TRUE)
1281 return network->wifi.ca_cert_path;
1282 else if (g_str_equal(key, "WiFi.ClientCertFile") == TRUE)
1283 return network->wifi.client_cert_path;
1284 else if (g_str_equal(key, "WiFi.PrivateKeyFile") == TRUE)
1285 return network->wifi.private_key_path;
1286 else if (g_str_equal(key, "WiFi.PrivateKeyPassphrase") == TRUE)
1287 return network->wifi.private_key_passphrase;
1288 else if (g_str_equal(key, "WiFi.Phase2") == TRUE)
1289 return network->wifi.phase2_auth;
1291 return connman_element_get_string(&network->element, key);
1295 * connman_network_set_bool:
1296 * @network: network structure
1297 * @key: unique identifier
1298 * @value: boolean value
1300 * Set boolean value for specific key
1302 int connman_network_set_bool(struct connman_network *network,
1303 const char *key, connman_bool_t value)
1305 DBG("network %p key %s value %d", network, key, value);
1307 if (g_strcmp0(key, "Roaming") == 0)
1308 return connman_network_set_roaming(network, value);
1310 return connman_element_set_bool(&network->element, key, value);
1314 * connman_network_get_bool:
1315 * @network: network structure
1316 * @key: unique identifier
1318 * Get boolean value for specific key
1320 connman_bool_t connman_network_get_bool(struct connman_network *network,
1323 DBG("network %p key %s", network, key);
1325 if (g_str_equal(key, "Roaming") == TRUE)
1326 return network->roaming;
1328 return connman_element_get_bool(&network->element, key);
1332 * connman_network_set_uint8:
1333 * @network: network structure
1334 * @key: unique identifier
1335 * @value: integer value
1337 * Set integer value for specific key
1339 int connman_network_set_uint8(struct connman_network *network,
1340 const char *key, connman_uint8_t value)
1342 DBG("network %p key %s value %d", network, key, value);
1344 if (g_strcmp0(key, "Strength") == 0)
1345 return connman_network_set_strength(network, value);
1347 return connman_element_set_uint8(&network->element, key, value);
1351 * connman_network_get_uint8:
1352 * @network: network structure
1353 * @key: unique identifier
1355 * Get integer value for specific key
1357 connman_uint8_t connman_network_get_uint8(struct connman_network *network,
1360 DBG("network %p key %s", network, key);
1362 if (g_str_equal(key, "Strength") == TRUE)
1363 return network->strength;
1365 return connman_element_get_uint8(&network->element, key);
1369 * connman_network_set_uint16:
1370 * @network: network structure
1371 * @key: unique identifier
1372 * @value: integer value
1374 * Set integer value for specific key
1376 int connman_network_set_uint16(struct connman_network *network,
1377 const char *key, connman_uint16_t value)
1379 DBG("network %p key %s value %d", network, key, value);
1381 if (g_str_equal(key, "Frequency") == TRUE)
1382 network->frequency = value;
1383 else if (g_str_equal(key, "WiFi.Channel") == TRUE)
1384 network->wifi.channel = value;
1390 * connman_network_get_uint16:
1391 * @network: network structure
1392 * @key: unique identifier
1394 * Get integer value for specific key
1396 connman_uint16_t connman_network_get_uint16(struct connman_network *network,
1399 DBG("network %p key %s", network, key);
1401 if (g_str_equal(key, "Frequency") == TRUE)
1402 return network->frequency;
1403 else if (g_str_equal(key, "WiFi.Channel") == TRUE)
1404 return network->wifi.channel;
1410 * connman_network_set_blob:
1411 * @network: network structure
1412 * @key: unique identifier
1416 * Set binary blob value for specific key
1418 int connman_network_set_blob(struct connman_network *network,
1419 const char *key, const void *data, unsigned int size)
1421 DBG("network %p key %s size %d", network, key, size);
1423 if (g_strcmp0(key, "Address") == 0)
1424 return connman_network_set_address(network, data, size);
1426 if (g_str_equal(key, "WiFi.SSID") == TRUE) {
1427 g_free(network->wifi.ssid);
1428 network->wifi.ssid = g_try_malloc(size);
1429 if (network->wifi.ssid != NULL) {
1430 memcpy(network->wifi.ssid, data, size);
1431 network->wifi.ssid_len = size;
1433 network->wifi.ssid_len = 0;
1436 return connman_element_set_blob(&network->element, key, data, size);
1440 * connman_network_get_blob:
1441 * @network: network structure
1442 * @key: unique identifier
1443 * @size: pointer to blob size
1445 * Get binary blob value for specific key
1447 const void *connman_network_get_blob(struct connman_network *network,
1448 const char *key, unsigned int *size)
1450 DBG("network %p key %s", network, key);
1452 if (g_str_equal(key, "WiFi.SSID") == TRUE) {
1454 *size = network->wifi.ssid_len;
1455 return network->wifi.ssid;
1458 return connman_element_get_blob(&network->element, key, size);
1461 void __connman_network_set_device(struct connman_network *network,
1462 struct connman_device *device)
1464 network->device = device;
1468 * connman_network_get_device:
1469 * @network: network structure
1471 * Get parent device of network
1473 struct connman_device *connman_network_get_device(struct connman_network *network)
1475 return network->device;
1479 * connman_network_get_data:
1480 * @network: network structure
1482 * Get private network data pointer
1484 void *connman_network_get_data(struct connman_network *network)
1486 return network->driver_data;
1490 * connman_network_set_data:
1491 * @network: network structure
1492 * @data: data pointer
1494 * Set private network data pointer
1496 void connman_network_set_data(struct connman_network *network, void *data)
1498 network->driver_data = data;
1501 void connman_network_update(struct connman_network *network)
1503 switch (network->type) {
1504 case CONNMAN_NETWORK_TYPE_UNKNOWN:
1505 case CONNMAN_NETWORK_TYPE_VENDOR:
1507 case CONNMAN_NETWORK_TYPE_ETHERNET:
1508 case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
1509 case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
1510 case CONNMAN_NETWORK_TYPE_CELLULAR:
1511 case CONNMAN_NETWORK_TYPE_WIFI:
1512 case CONNMAN_NETWORK_TYPE_WIMAX:
1516 if (network->group != NULL)
1517 __connman_service_update_from_network(network);
1522 static gboolean match_driver(struct connman_network *network,
1523 struct connman_network_driver *driver)
1525 if (network->type == driver->type ||
1526 driver->type == CONNMAN_NETWORK_TYPE_UNKNOWN)
1532 static int network_probe(struct connman_element *element)
1534 struct connman_network *network = element->network;
1537 DBG("element %p name %s", element, element->name);
1539 if (network == NULL)
1542 for (list = driver_list; list; list = list->next) {
1543 struct connman_network_driver *driver = list->data;
1545 if (match_driver(network, driver) == FALSE)
1548 DBG("driver %p name %s", driver, driver->name);
1550 if (driver->probe(network) == 0) {
1551 network->driver = driver;
1556 if (network->driver == NULL)
1559 switch (network->type) {
1560 case CONNMAN_NETWORK_TYPE_UNKNOWN:
1561 case CONNMAN_NETWORK_TYPE_VENDOR:
1563 case CONNMAN_NETWORK_TYPE_ETHERNET:
1564 case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
1565 case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
1566 case CONNMAN_NETWORK_TYPE_CELLULAR:
1567 case CONNMAN_NETWORK_TYPE_WIFI:
1568 case CONNMAN_NETWORK_TYPE_WIMAX:
1569 if (network->group != NULL)
1570 __connman_profile_add_network(network);
1577 static void network_remove(struct connman_element *element)
1579 struct connman_network *network = element->network;
1581 DBG("element %p name %s", element, element->name);
1583 if (network == NULL)
1586 if (network->driver == NULL)
1589 switch (network->type) {
1590 case CONNMAN_NETWORK_TYPE_UNKNOWN:
1591 case CONNMAN_NETWORK_TYPE_VENDOR:
1593 case CONNMAN_NETWORK_TYPE_ETHERNET:
1594 case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
1595 case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
1596 case CONNMAN_NETWORK_TYPE_CELLULAR:
1597 case CONNMAN_NETWORK_TYPE_WIFI:
1598 case CONNMAN_NETWORK_TYPE_WIMAX:
1599 if (network->group != NULL) {
1600 __connman_profile_remove_network(network);
1602 g_free(network->group);
1603 network->group = NULL;
1608 if (network->driver->remove)
1609 network->driver->remove(network);
1612 static void network_change(struct connman_element *element)
1614 struct connman_network *network = element->network;
1616 DBG("element %p name %s", element, element->name);
1618 if (element->state != CONNMAN_ELEMENT_STATE_ERROR)
1621 if (element->error != CONNMAN_ELEMENT_ERROR_DHCP_FAILED)
1624 if (network->connected == FALSE)
1627 connman_element_unregister_children(element);
1629 connman_device_set_disconnected(network->device, TRUE);
1631 if (network->driver && network->driver->disconnect) {
1632 network->driver->disconnect(network);
1636 network->connected = FALSE;
1639 static struct connman_driver network_driver = {
1641 .type = CONNMAN_ELEMENT_TYPE_NETWORK,
1642 .priority = CONNMAN_DRIVER_PRIORITY_LOW,
1643 .probe = network_probe,
1644 .remove = network_remove,
1645 .change = network_change,
1648 int __connman_network_init(void)
1652 return connman_driver_register(&network_driver);
1655 void __connman_network_cleanup(void)
1659 connman_driver_unregister(&network_driver);