5 * Copyright (C) 2007-2012 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 * How many times to send RS with the purpose of
33 * refreshing RDNSS entries before they actually expire.
34 * With a value of 1, one RS will be sent, with no retries.
36 #define RS_REFRESH_COUNT 1
39 * Value in seconds to wait for RA after RS was sent.
40 * After this time elapsed, we can send another RS.
42 #define RS_REFRESH_TIMEOUT 3
44 static GSList *network_list = NULL;
45 static GSList *driver_list = NULL;
47 struct connman_network {
49 enum connman_network_type type;
50 connman_bool_t available;
51 connman_bool_t connected;
52 connman_bool_t roaming;
53 connman_uint8_t strength;
54 connman_uint16_t frequency;
61 int router_solicit_count;
62 int router_solicit_refresh_count;
64 struct connman_network_driver *driver;
67 connman_bool_t connecting;
68 connman_bool_t associating;
70 struct connman_device *device;
76 unsigned short channel;
79 char *agent_passphrase;
84 char *client_cert_path;
85 char *private_key_path;
86 char *private_key_passphrase;
89 connman_bool_t use_wps;
99 static const char *type2string(enum connman_network_type type)
102 case CONNMAN_NETWORK_TYPE_UNKNOWN:
103 case CONNMAN_NETWORK_TYPE_VENDOR:
105 case CONNMAN_NETWORK_TYPE_ETHERNET:
107 case CONNMAN_NETWORK_TYPE_WIFI:
109 case CONNMAN_NETWORK_TYPE_WIMAX:
111 case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
112 case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
114 case CONNMAN_NETWORK_TYPE_CELLULAR:
121 static gboolean match_driver(struct connman_network *network,
122 struct connman_network_driver *driver)
124 if (network->type == driver->type ||
125 driver->type == CONNMAN_NETWORK_TYPE_UNKNOWN)
131 static int network_probe(struct connman_network *network)
134 struct connman_network_driver *driver = NULL;
136 DBG("network %p name %s", network, network->name);
138 if (network->driver != NULL)
141 for (list = driver_list; list; list = list->next) {
144 if (match_driver(network, driver) == FALSE)
147 DBG("driver %p name %s", driver, driver->name);
149 if (driver->probe(network) == 0)
158 if (network->group == NULL)
161 switch (network->type) {
162 case CONNMAN_NETWORK_TYPE_UNKNOWN:
163 case CONNMAN_NETWORK_TYPE_VENDOR:
165 case CONNMAN_NETWORK_TYPE_ETHERNET:
166 case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
167 case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
168 case CONNMAN_NETWORK_TYPE_CELLULAR:
169 case CONNMAN_NETWORK_TYPE_WIFI:
170 case CONNMAN_NETWORK_TYPE_WIMAX:
171 network->driver = driver;
172 if (__connman_service_create_from_network(network) == NULL) {
173 network->driver = NULL;
181 static void network_remove(struct connman_network *network)
183 DBG("network %p name %s", network, network->name);
185 if (network->driver == NULL)
188 connman_network_set_connected(network, FALSE);
190 switch (network->type) {
191 case CONNMAN_NETWORK_TYPE_UNKNOWN:
192 case CONNMAN_NETWORK_TYPE_VENDOR:
194 case CONNMAN_NETWORK_TYPE_ETHERNET:
195 case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
196 case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
197 case CONNMAN_NETWORK_TYPE_CELLULAR:
198 case CONNMAN_NETWORK_TYPE_WIFI:
199 case CONNMAN_NETWORK_TYPE_WIMAX:
200 if (network->group != NULL) {
201 __connman_service_remove_from_network(network);
203 g_free(network->group);
204 network->group = NULL;
209 if (network->driver->remove)
210 network->driver->remove(network);
212 network->driver = NULL;
215 static void network_change(struct connman_network *network)
217 DBG("network %p name %s", network, network->name);
219 if (network->connected == FALSE)
222 connman_device_set_disconnected(network->device, TRUE);
224 if (network->driver && network->driver->disconnect) {
225 network->driver->disconnect(network);
229 network->connected = FALSE;
232 static void probe_driver(struct connman_network_driver *driver)
236 DBG("driver %p name %s", driver, driver->name);
238 for (list = network_list; list != NULL; list = list->next) {
239 struct connman_network *network = list->data;
241 if (network->driver != NULL)
244 if (driver->type != network->type)
247 if (driver->probe(network) < 0)
250 network->driver = driver;
254 static void remove_driver(struct connman_network_driver *driver)
258 DBG("driver %p name %s", driver, driver->name);
260 for (list = network_list; list != NULL; list = list->next) {
261 struct connman_network *network = list->data;
263 if (network->driver == driver)
264 network_remove(network);
268 static gint compare_priority(gconstpointer a, gconstpointer b)
270 const struct connman_network_driver *driver1 = a;
271 const struct connman_network_driver *driver2 = b;
273 return driver2->priority - driver1->priority;
277 * connman_network_driver_register:
278 * @driver: network driver definition
280 * Register a new network driver
282 * Returns: %0 on success
284 int connman_network_driver_register(struct connman_network_driver *driver)
288 DBG("driver %p name %s", driver, driver->name);
290 for (list = driver_list; list; list = list->next) {
291 struct connman_network_driver *tmp = list->data;
293 if (tmp->type == driver->type)
298 driver_list = g_slist_insert_sorted(driver_list, driver,
301 probe_driver(driver);
307 * connman_network_driver_unregister:
308 * @driver: network driver definition
310 * Remove a previously registered network driver
312 void connman_network_driver_unregister(struct connman_network_driver *driver)
314 DBG("driver %p name %s", driver, driver->name);
316 driver_list = g_slist_remove(driver_list, driver);
318 remove_driver(driver);
321 static void network_destruct(struct connman_network *network)
323 DBG("network %p name %s", network, network->name);
325 g_free(network->wifi.ssid);
326 g_free(network->wifi.mode);
327 g_free(network->wifi.security);
328 g_free(network->wifi.passphrase);
329 g_free(network->wifi.agent_passphrase);
330 g_free(network->wifi.eap);
331 g_free(network->wifi.identity);
332 g_free(network->wifi.agent_identity);
333 g_free(network->wifi.ca_cert_path);
334 g_free(network->wifi.client_cert_path);
335 g_free(network->wifi.private_key_path);
336 g_free(network->wifi.private_key_passphrase);
337 g_free(network->wifi.phase2_auth);
338 g_free(network->wifi.pin_wps);
340 g_free(network->path);
341 g_free(network->group);
342 g_free(network->node);
343 g_free(network->name);
344 g_free(network->identifier);
346 network->device = NULL;
352 * connman_network_create:
353 * @identifier: network identifier (for example an unqiue name)
355 * Allocate a new network and assign the #identifier to it.
357 * Returns: a newly-allocated #connman_network structure
359 struct connman_network *connman_network_create(const char *identifier,
360 enum connman_network_type type)
362 struct connman_network *network;
365 DBG("identifier %s type %d", identifier, type);
367 network = g_try_new0(struct connman_network, 1);
371 DBG("network %p", network);
373 network->refcount = 1;
375 ident = g_strdup(identifier);
382 network->type = type;
383 network->identifier = ident;
385 network_list = g_slist_append(network_list, network);
391 * connman_network_ref:
392 * @network: network structure
394 * Increase reference counter of network
396 struct connman_network *
397 connman_network_ref_debug(struct connman_network *network,
398 const char *file, int line, const char *caller)
400 DBG("%p name %s ref %d by %s:%d:%s()", network, network->name,
401 network->refcount + 1, file, line, caller);
403 __sync_fetch_and_add(&network->refcount, 1);
409 * connman_network_unref:
410 * @network: network structure
412 * Decrease reference counter of network
414 void connman_network_unref_debug(struct connman_network *network,
415 const char *file, int line, const char *caller)
417 DBG("%p name %s ref %d by %s:%d:%s()", network, network->name,
418 network->refcount - 1, file, line, caller);
420 if (__sync_fetch_and_sub(&network->refcount, 1) != 1)
423 network_list = g_slist_remove(network_list, network);
425 network_destruct(network);
428 const char *__connman_network_get_type(struct connman_network *network)
430 return type2string(network->type);
434 * connman_network_get_type:
435 * @network: network structure
437 * Get type of network
439 enum connman_network_type connman_network_get_type(struct connman_network *network)
441 return network->type;
445 * connman_network_get_identifier:
446 * @network: network structure
448 * Get identifier of network
450 const char *connman_network_get_identifier(struct connman_network *network)
452 return network->identifier;
456 * connman_network_set_index:
457 * @network: network structure
458 * @index: index number
460 * Set index number of network
462 void connman_network_set_index(struct connman_network *network, int index)
464 struct connman_service *service;
465 struct connman_ipconfig *ipconfig;
467 service = __connman_service_lookup_from_network(network);
471 ipconfig = __connman_service_get_ip4config(service);
473 DBG("index %d service %p ip4config %p", network->index,
476 if (network->index < 0 && ipconfig == NULL) {
478 ipconfig = __connman_service_get_ip4config(service);
479 if (ipconfig == NULL)
481 * This is needed for plugins that havent set their
482 * ipconfig layer yet, due to not being able to get
483 * a network index prior to creating a service.
485 __connman_service_create_ip4config(service, index);
487 __connman_ipconfig_set_index(ipconfig, index);
490 /* If index changed, the index of ipconfig must be reset. */
491 if (ipconfig == NULL)
494 __connman_ipconfig_set_index(ipconfig, index);
498 network->index = index;
502 * connman_network_get_index:
503 * @network: network structure
505 * Get index number of network
507 int connman_network_get_index(struct connman_network *network)
509 return network->index;
513 * connman_network_set_group:
514 * @network: network structure
517 * Set group name for automatic clustering
519 void connman_network_set_group(struct connman_network *network,
522 switch (network->type) {
523 case CONNMAN_NETWORK_TYPE_UNKNOWN:
524 case CONNMAN_NETWORK_TYPE_VENDOR:
526 case CONNMAN_NETWORK_TYPE_ETHERNET:
527 case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
528 case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
529 case CONNMAN_NETWORK_TYPE_CELLULAR:
530 case CONNMAN_NETWORK_TYPE_WIFI:
531 case CONNMAN_NETWORK_TYPE_WIMAX:
535 if (g_strcmp0(network->group, group) == 0) {
537 __connman_service_update_from_network(network);
541 if (network->group != NULL) {
542 __connman_service_remove_from_network(network);
544 g_free(network->group);
547 network->group = g_strdup(group);
549 if (network->group != NULL)
550 network_probe(network);
554 * connman_network_get_group:
555 * @network: network structure
557 * Get group name for automatic clustering
559 const char *connman_network_get_group(struct connman_network *network)
561 return network->group;
564 const char *__connman_network_get_ident(struct connman_network *network)
566 if (network->device == NULL)
569 return connman_device_get_ident(network->device);
572 connman_bool_t __connman_network_get_weakness(struct connman_network *network)
574 switch (network->type) {
575 case CONNMAN_NETWORK_TYPE_UNKNOWN:
576 case CONNMAN_NETWORK_TYPE_VENDOR:
577 case CONNMAN_NETWORK_TYPE_ETHERNET:
578 case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
579 case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
580 case CONNMAN_NETWORK_TYPE_CELLULAR:
581 case CONNMAN_NETWORK_TYPE_WIMAX:
583 case CONNMAN_NETWORK_TYPE_WIFI:
584 if (g_strcmp0(network->wifi.mode, "adhoc") == 0)
586 if (network->strength > 0 && network->strength < 20)
594 connman_bool_t connman_network_get_connecting(struct connman_network *network)
596 return network->connecting;
600 * connman_network_set_available:
601 * @network: network structure
602 * @available: availability state
604 * Change availability state of network (in range)
606 int connman_network_set_available(struct connman_network *network,
607 connman_bool_t available)
609 DBG("network %p available %d", network, available);
611 if (network->available == available)
614 network->available = available;
620 * connman_network_get_available:
621 * @network: network structure
623 * Get network available setting
625 connman_bool_t connman_network_get_available(struct connman_network *network)
627 return network->available;
631 * connman_network_set_associating:
632 * @network: network structure
633 * @associating: associating state
635 * Change associating state of network
637 int connman_network_set_associating(struct connman_network *network,
638 connman_bool_t associating)
640 DBG("network %p associating %d", network, associating);
642 if (network->associating == associating)
645 network->associating = associating;
647 if (associating == TRUE) {
648 struct connman_service *service;
650 service = __connman_service_lookup_from_network(network);
651 __connman_service_ipconfig_indicate_state(service,
652 CONNMAN_SERVICE_STATE_ASSOCIATION,
653 CONNMAN_IPCONFIG_TYPE_IPV4);
654 __connman_service_ipconfig_indicate_state(service,
655 CONNMAN_SERVICE_STATE_ASSOCIATION,
656 CONNMAN_IPCONFIG_TYPE_IPV6);
662 static void set_associate_error(struct connman_network *network)
664 struct connman_service *service;
666 service = __connman_service_lookup_from_network(network);
668 __connman_service_indicate_error(service,
669 CONNMAN_SERVICE_ERROR_CONNECT_FAILED);
672 static void set_configure_error(struct connman_network *network)
674 struct connman_service *service;
676 service = __connman_service_lookup_from_network(network);
678 __connman_service_indicate_error(service,
679 CONNMAN_SERVICE_ERROR_CONNECT_FAILED);
682 static void set_invalid_key_error(struct connman_network *network)
684 struct connman_service *service;
686 service = __connman_service_lookup_from_network(network);
688 __connman_service_indicate_error(service,
689 CONNMAN_SERVICE_ERROR_INVALID_KEY);
692 static void set_connect_error(struct connman_network *network)
694 struct connman_service *service;
696 service = __connman_service_lookup_from_network(network);
698 __connman_service_indicate_error(service,
699 CONNMAN_SERVICE_ERROR_CONNECT_FAILED);
702 void connman_network_set_ipv4_method(struct connman_network *network,
703 enum connman_ipconfig_method method)
705 struct connman_service *service;
706 struct connman_ipconfig *ipconfig;
708 service = __connman_service_lookup_from_network(network);
712 ipconfig = __connman_service_get_ip4config(service);
713 if (ipconfig == NULL)
716 __connman_ipconfig_set_method(ipconfig, method);
719 void connman_network_set_ipv6_method(struct connman_network *network,
720 enum connman_ipconfig_method method)
722 struct connman_service *service;
723 struct connman_ipconfig *ipconfig;
725 service = __connman_service_lookup_from_network(network);
729 ipconfig = __connman_service_get_ip6config(service);
730 if (ipconfig == NULL)
733 __connman_ipconfig_set_method(ipconfig, method);
736 void connman_network_set_error(struct connman_network *network,
737 enum connman_network_error error)
739 DBG("nework %p, error %d", network, error);
741 network->connecting = FALSE;
742 network->associating = FALSE;
745 case CONNMAN_NETWORK_ERROR_UNKNOWN:
747 case CONNMAN_NETWORK_ERROR_ASSOCIATE_FAIL:
748 set_associate_error(network);
750 case CONNMAN_NETWORK_ERROR_CONFIGURE_FAIL:
751 set_configure_error(network);
753 case CONNMAN_NETWORK_ERROR_INVALID_KEY:
754 set_invalid_key_error(network);
756 case CONNMAN_NETWORK_ERROR_CONNECT_FAIL:
757 set_connect_error(network);
761 network_change(network);
764 void connman_network_clear_error(struct connman_network *network)
766 struct connman_service *service;
768 DBG("network %p", network);
773 if (network->connecting == TRUE || network->associating == TRUE)
776 service = __connman_service_lookup_from_network(network);
777 __connman_service_clear_error(service);
780 static void set_configuration(struct connman_network *network,
781 enum connman_ipconfig_type type)
783 struct connman_service *service;
785 DBG("network %p", network);
787 if (network->device == NULL)
790 __connman_device_set_network(network->device, network);
792 connman_device_set_disconnected(network->device, FALSE);
794 service = __connman_service_lookup_from_network(network);
795 __connman_service_ipconfig_indicate_state(service,
796 CONNMAN_SERVICE_STATE_CONFIGURATION,
800 static void dhcp_success(struct connman_network *network)
802 struct connman_service *service;
803 struct connman_ipconfig *ipconfig_ipv4;
806 service = __connman_service_lookup_from_network(network);
810 connman_network_set_associating(network, FALSE);
812 network->connecting = FALSE;
814 ipconfig_ipv4 = __connman_service_get_ip4config(service);
815 err = __connman_ipconfig_address_add(ipconfig_ipv4);
819 err = __connman_ipconfig_gateway_add(ipconfig_ipv4);
826 connman_network_set_error(network,
827 CONNMAN_NETWORK_ERROR_CONFIGURE_FAIL);
830 static void dhcp_failure(struct connman_network *network)
832 struct connman_service *service;
834 service = __connman_service_lookup_from_network(network);
838 __connman_service_ipconfig_indicate_state(service,
839 CONNMAN_SERVICE_STATE_IDLE,
840 CONNMAN_IPCONFIG_TYPE_IPV4);
843 static void dhcp_callback(struct connman_network *network,
844 connman_bool_t success)
846 DBG("success %d", success);
849 dhcp_success(network);
851 dhcp_failure(network);
854 static int set_connected_fixed(struct connman_network *network)
856 struct connman_service *service;
857 struct connman_ipconfig *ipconfig_ipv4;
862 service = __connman_service_lookup_from_network(network);
864 ipconfig_ipv4 = __connman_service_get_ip4config(service);
866 set_configuration(network, CONNMAN_IPCONFIG_TYPE_IPV4);
868 network->connecting = FALSE;
870 connman_network_set_associating(network, FALSE);
872 err = __connman_ipconfig_address_add(ipconfig_ipv4);
876 err = __connman_ipconfig_gateway_add(ipconfig_ipv4);
883 connman_network_set_error(network,
884 CONNMAN_NETWORK_ERROR_CONFIGURE_FAIL);
889 static void set_connected_manual(struct connman_network *network)
891 struct connman_service *service;
892 struct connman_ipconfig *ipconfig;
895 DBG("network %p", network);
897 service = __connman_service_lookup_from_network(network);
899 ipconfig = __connman_service_get_ip4config(service);
901 if (__connman_ipconfig_get_local(ipconfig) == NULL)
902 __connman_service_read_ip4config(service);
904 set_configuration(network, CONNMAN_IPCONFIG_TYPE_IPV4);
906 err = __connman_ipconfig_address_add(ipconfig);
910 err = __connman_ipconfig_gateway_add(ipconfig);
914 network->connecting = FALSE;
916 connman_network_set_associating(network, FALSE);
921 connman_network_set_error(network,
922 CONNMAN_NETWORK_ERROR_CONFIGURE_FAIL);
926 static int set_connected_dhcp(struct connman_network *network)
930 DBG("network %p", network);
932 set_configuration(network, CONNMAN_IPCONFIG_TYPE_IPV4);
934 err = __connman_dhcp_start(network, dhcp_callback);
936 connman_error("Can not request DHCP lease");
943 static int manual_ipv6_set(struct connman_network *network,
944 struct connman_ipconfig *ipconfig_ipv6)
946 struct connman_service *service;
949 DBG("network %p ipv6 %p", network, ipconfig_ipv6);
951 service = __connman_service_lookup_from_network(network);
955 if (__connman_ipconfig_get_local(ipconfig_ipv6) == NULL)
956 __connman_service_read_ip6config(service);
958 err = __connman_ipconfig_address_add(ipconfig_ipv6);
960 connman_network_set_error(network,
961 CONNMAN_NETWORK_ERROR_CONFIGURE_FAIL);
965 err = __connman_ipconfig_gateway_add(ipconfig_ipv6);
969 __connman_connection_gateway_activate(service,
970 CONNMAN_IPCONFIG_TYPE_IPV6);
972 __connman_device_set_network(network->device, network);
974 connman_device_set_disconnected(network->device, FALSE);
976 network->connecting = FALSE;
981 static void stop_dhcpv6(struct connman_network *network)
983 __connman_dhcpv6_stop(network);
986 static void dhcpv6_release_callback(struct connman_network *network,
987 connman_bool_t success)
989 DBG("success %d", success);
991 stop_dhcpv6(network);
994 static void release_dhcpv6(struct connman_network *network)
996 __connman_dhcpv6_start_release(network, dhcpv6_release_callback);
997 stop_dhcpv6(network);
1000 static void dhcpv6_info_callback(struct connman_network *network,
1001 connman_bool_t success)
1003 DBG("success %d", success);
1005 stop_dhcpv6(network);
1008 static gboolean dhcpv6_set_addresses(struct connman_network *network)
1010 struct connman_service *service;
1011 struct connman_ipconfig *ipconfig_ipv6;
1014 service = __connman_service_lookup_from_network(network);
1015 if (service == NULL)
1018 connman_network_set_associating(network, FALSE);
1020 network->connecting = FALSE;
1022 ipconfig_ipv6 = __connman_service_get_ip6config(service);
1023 err = __connman_ipconfig_address_add(ipconfig_ipv6);
1027 err = __connman_ipconfig_gateway_add(ipconfig_ipv6);
1034 connman_network_set_error(network,
1035 CONNMAN_NETWORK_ERROR_CONFIGURE_FAIL);
1039 static void autoconf_ipv6_set(struct connman_network *network);
1040 static void dhcpv6_callback(struct connman_network *network,
1041 connman_bool_t success);
1044 * Have a separate callback for renew so that we do not do autoconf
1045 * in wrong phase as the dhcpv6_callback() is also called when doing
1046 * DHCPv6 solicitation.
1048 static void dhcpv6_renew_callback(struct connman_network *network,
1049 connman_bool_t success)
1051 if (success == TRUE)
1052 dhcpv6_callback(network, success);
1054 stop_dhcpv6(network);
1056 /* restart and do solicit again. */
1057 autoconf_ipv6_set(network);
1061 static void dhcpv6_callback(struct connman_network *network,
1062 connman_bool_t success)
1064 DBG("success %d", success);
1066 /* Start the renew process if necessary */
1067 if (success == TRUE) {
1069 if (dhcpv6_set_addresses(network) < 0) {
1070 stop_dhcpv6(network);
1074 if (__connman_dhcpv6_start_renew(network,
1075 dhcpv6_renew_callback) == -ETIMEDOUT)
1076 dhcpv6_renew_callback(network, FALSE);
1078 stop_dhcpv6(network);
1081 static void check_dhcpv6(struct nd_router_advert *reply,
1082 unsigned int length, void *user_data)
1084 struct connman_network *network = user_data;
1087 DBG("reply %p", reply);
1089 if (reply == NULL) {
1091 * Router solicitation message seem to get lost easily so
1092 * try to send it again.
1094 if (network->router_solicit_count > 0) {
1095 DBG("re-send router solicitation %d",
1096 network->router_solicit_count);
1097 network->router_solicit_count--;
1098 __connman_inet_ipv6_send_rs(network->index, 1,
1099 check_dhcpv6, network);
1102 connman_network_unref(network);
1106 network->router_solicit_count = 0;
1109 * If we were disconnected while waiting router advertisement,
1110 * we just quit and do not start DHCPv6
1112 if (network->connected == FALSE) {
1113 connman_network_unref(network);
1117 prefixes = __connman_inet_ipv6_get_prefixes(reply, length);
1120 * We do stateful/stateless DHCPv6 if router advertisement says so.
1122 if (reply->nd_ra_flags_reserved & ND_RA_FLAG_MANAGED)
1123 __connman_dhcpv6_start(network, prefixes, dhcpv6_callback);
1124 else if (reply->nd_ra_flags_reserved & ND_RA_FLAG_OTHER)
1125 __connman_dhcpv6_start_info(network, dhcpv6_info_callback);
1127 connman_network_unref(network);
1130 static void receive_refresh_rs_reply(struct nd_router_advert *reply,
1131 unsigned int length, void *user_data)
1133 struct connman_network *network = user_data;
1135 DBG("reply %p", reply);
1137 if (reply == NULL) {
1139 * Router solicitation message seem to get lost easily so
1140 * try to send it again.
1142 if (network->router_solicit_refresh_count > 1) {
1143 network->router_solicit_refresh_count--;
1144 DBG("re-send router solicitation %d",
1145 network->router_solicit_refresh_count);
1146 __connman_inet_ipv6_send_rs(network->index,
1148 receive_refresh_rs_reply,
1154 /* RS refresh not in progress anymore */
1155 network->router_solicit_refresh_count = 0;
1157 connman_network_unref(network);
1161 int __connman_refresh_rs_ipv6(struct connman_network *network, int index)
1165 DBG("network %p index %d", network, index);
1167 /* Send only one RS for all RDNSS entries which are about to expire */
1168 if (network->router_solicit_refresh_count > 0) {
1169 DBG("RS refresh already started");
1173 network->router_solicit_refresh_count = RS_REFRESH_COUNT;
1175 connman_network_ref(network);
1177 ret = __connman_inet_ipv6_send_rs(index, RS_REFRESH_TIMEOUT,
1178 receive_refresh_rs_reply, network);
1182 static void autoconf_ipv6_set(struct connman_network *network)
1184 struct connman_service *service;
1185 struct connman_ipconfig *ipconfig;
1188 DBG("network %p", network);
1190 if (network->router_solicit_count > 0) {
1192 * The autoconfiguration is already pending and we have sent
1193 * router solicitation messages and are now waiting answers.
1194 * There is no need to continue any further.
1196 DBG("autoconfiguration already started");
1200 __connman_device_set_network(network->device, network);
1202 connman_device_set_disconnected(network->device, FALSE);
1204 network->connecting = FALSE;
1206 service = __connman_service_lookup_from_network(network);
1207 if (service == NULL)
1210 ipconfig = __connman_service_get_ip6config(service);
1211 if (ipconfig == NULL)
1214 index = __connman_ipconfig_get_index(ipconfig);
1216 connman_network_ref(network);
1218 /* Try to get stateless DHCPv6 information, RFC 3736 */
1219 network->router_solicit_count = 3;
1220 __connman_inet_ipv6_send_rs(index, 1, check_dhcpv6, network);
1223 static void set_connected(struct connman_network *network)
1225 struct connman_ipconfig *ipconfig_ipv4, *ipconfig_ipv6;
1226 enum connman_ipconfig_method ipv4_method, ipv6_method;
1227 struct connman_service *service;
1230 if (network->connected == TRUE)
1233 network->connected = TRUE;
1235 service = __connman_service_lookup_from_network(network);
1237 ipconfig_ipv4 = __connman_service_get_ip4config(service);
1238 ipconfig_ipv6 = __connman_service_get_ip6config(service);
1240 DBG("service %p ipv4 %p ipv6 %p", service, ipconfig_ipv4,
1243 ipv4_method = __connman_ipconfig_get_method(ipconfig_ipv4);
1244 ipv6_method = __connman_ipconfig_get_method(ipconfig_ipv6);
1246 DBG("method ipv4 %d ipv6 %d", ipv4_method, ipv6_method);
1248 switch (ipv6_method) {
1249 case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
1250 case CONNMAN_IPCONFIG_METHOD_OFF:
1252 case CONNMAN_IPCONFIG_METHOD_DHCP:
1253 case CONNMAN_IPCONFIG_METHOD_AUTO:
1254 autoconf_ipv6_set(network);
1256 case CONNMAN_IPCONFIG_METHOD_FIXED:
1257 case CONNMAN_IPCONFIG_METHOD_MANUAL:
1258 ret = manual_ipv6_set(network, ipconfig_ipv6);
1260 connman_network_set_error(network,
1261 CONNMAN_NETWORK_ERROR_ASSOCIATE_FAIL);
1267 switch (ipv4_method) {
1268 case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
1269 case CONNMAN_IPCONFIG_METHOD_OFF:
1270 case CONNMAN_IPCONFIG_METHOD_AUTO:
1272 case CONNMAN_IPCONFIG_METHOD_FIXED:
1273 if (set_connected_fixed(network) < 0) {
1274 connman_network_set_error(network,
1275 CONNMAN_NETWORK_ERROR_ASSOCIATE_FAIL);
1279 case CONNMAN_IPCONFIG_METHOD_MANUAL:
1280 set_connected_manual(network);
1282 case CONNMAN_IPCONFIG_METHOD_DHCP:
1283 if (set_connected_dhcp(network) < 0) {
1284 connman_network_set_error(network,
1285 CONNMAN_NETWORK_ERROR_ASSOCIATE_FAIL);
1290 network->connecting = FALSE;
1292 connman_network_set_associating(network, FALSE);
1295 static void set_disconnected(struct connman_network *network)
1297 struct connman_ipconfig *ipconfig_ipv4, *ipconfig_ipv6;
1298 enum connman_ipconfig_method ipv4_method, ipv6_method;
1299 enum connman_service_state state;
1300 struct connman_service *service;
1302 if (network->connected == FALSE)
1305 network->connected = FALSE;
1307 service = __connman_service_lookup_from_network(network);
1309 ipconfig_ipv4 = __connman_service_get_ip4config(service);
1310 ipconfig_ipv6 = __connman_service_get_ip6config(service);
1312 DBG("service %p ipv4 %p ipv6 %p", service, ipconfig_ipv4,
1315 ipv4_method = __connman_ipconfig_get_method(ipconfig_ipv4);
1316 ipv6_method = __connman_ipconfig_get_method(ipconfig_ipv6);
1318 DBG("method ipv4 %d ipv6 %d", ipv4_method, ipv6_method);
1321 * Resetting solicit count here will prevent the RS resend loop
1322 * from sending packets in check_dhcpv6()
1324 network->router_solicit_count = 0;
1326 __connman_device_set_network(network->device, NULL);
1328 switch (ipv6_method) {
1329 case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
1330 case CONNMAN_IPCONFIG_METHOD_OFF:
1331 case CONNMAN_IPCONFIG_METHOD_FIXED:
1332 case CONNMAN_IPCONFIG_METHOD_MANUAL:
1334 case CONNMAN_IPCONFIG_METHOD_DHCP:
1335 case CONNMAN_IPCONFIG_METHOD_AUTO:
1336 release_dhcpv6(network);
1340 switch (ipv4_method) {
1341 case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
1342 case CONNMAN_IPCONFIG_METHOD_OFF:
1343 case CONNMAN_IPCONFIG_METHOD_AUTO:
1344 case CONNMAN_IPCONFIG_METHOD_FIXED:
1345 case CONNMAN_IPCONFIG_METHOD_MANUAL:
1347 case CONNMAN_IPCONFIG_METHOD_DHCP:
1348 __connman_dhcp_stop(network);
1353 * We only set the disconnect state if we were not in idle
1354 * or in failure. It does not make sense to go to disconnect
1355 * state if we were not connected.
1357 state = __connman_service_ipconfig_get_state(service,
1358 CONNMAN_IPCONFIG_TYPE_IPV4);
1359 if (state != CONNMAN_SERVICE_STATE_IDLE &&
1360 state != CONNMAN_SERVICE_STATE_FAILURE)
1361 __connman_service_ipconfig_indicate_state(service,
1362 CONNMAN_SERVICE_STATE_DISCONNECT,
1363 CONNMAN_IPCONFIG_TYPE_IPV4);
1365 state = __connman_service_ipconfig_get_state(service,
1366 CONNMAN_IPCONFIG_TYPE_IPV6);
1367 if (state != CONNMAN_SERVICE_STATE_IDLE &&
1368 state != CONNMAN_SERVICE_STATE_FAILURE)
1369 __connman_service_ipconfig_indicate_state(service,
1370 CONNMAN_SERVICE_STATE_DISCONNECT,
1371 CONNMAN_IPCONFIG_TYPE_IPV6);
1373 __connman_connection_gateway_remove(service,
1374 CONNMAN_IPCONFIG_TYPE_ALL);
1376 __connman_ipconfig_address_unset(ipconfig_ipv4);
1377 __connman_ipconfig_address_unset(ipconfig_ipv6);
1380 * Special handling for IPv6 autoconfigured address.
1381 * The simplest way to remove autoconfigured routes is to
1382 * disable IPv6 temporarily so that kernel will do the cleanup
1385 if (ipv6_method == CONNMAN_IPCONFIG_METHOD_AUTO) {
1386 __connman_ipconfig_disable_ipv6(ipconfig_ipv6);
1387 __connman_ipconfig_enable_ipv6(ipconfig_ipv6);
1390 __connman_service_ipconfig_indicate_state(service,
1391 CONNMAN_SERVICE_STATE_IDLE,
1392 CONNMAN_IPCONFIG_TYPE_IPV4);
1394 __connman_service_ipconfig_indicate_state(service,
1395 CONNMAN_SERVICE_STATE_IDLE,
1396 CONNMAN_IPCONFIG_TYPE_IPV6);
1398 network->connecting = FALSE;
1400 connman_network_set_associating(network, FALSE);
1404 * connman_network_set_connected:
1405 * @network: network structure
1406 * @connected: connected state
1408 * Change connected state of network
1410 int connman_network_set_connected(struct connman_network *network,
1411 connman_bool_t connected)
1413 DBG("network %p connected %d/%d connecting %d associating %d",
1414 network, network->connected, connected, network->connecting,
1415 network->associating);
1417 if ((network->connecting == TRUE || network->associating == TRUE) &&
1418 connected == FALSE) {
1419 connman_network_set_error(network,
1420 CONNMAN_NETWORK_ERROR_CONNECT_FAIL);
1421 if (__connman_network_disconnect(network) == 0)
1425 if (network->connected == connected)
1428 if (connected == FALSE)
1429 set_disconnected(network);
1431 set_connected(network);
1437 * connman_network_get_connected:
1438 * @network: network structure
1440 * Get network connection status
1442 connman_bool_t connman_network_get_connected(struct connman_network *network)
1444 return network->connected;
1448 * connman_network_get_associating:
1449 * @network: network structure
1451 * Get network associating status
1453 connman_bool_t connman_network_get_associating(struct connman_network *network)
1455 return network->associating;
1458 int connman_network_connect_hidden(struct connman_network *network,
1459 char *identity, char* passphrase)
1462 struct connman_service *service;
1466 service = __connman_service_lookup_from_network(network);
1467 if (service == NULL)
1470 if (identity != NULL)
1471 __connman_service_set_agent_identity(service, identity);
1473 if (passphrase != NULL)
1474 err = __connman_service_add_passphrase(service, passphrase);
1476 if (err == -ENOKEY) {
1477 __connman_service_indicate_error(service,
1478 CONNMAN_SERVICE_ERROR_INVALID_KEY);
1481 __connman_service_set_hidden(service);
1482 __connman_service_set_userconnect(service, TRUE);
1483 return __connman_service_connect(service);
1488 * __connman_network_connect:
1489 * @network: network structure
1493 int __connman_network_connect(struct connman_network *network)
1497 DBG("network %p", network);
1499 if (network->connected == TRUE)
1502 if (network->connecting == TRUE || network->associating == TRUE)
1505 if (network->driver == NULL)
1508 if (network->driver->connect == NULL)
1511 if (network->device == NULL)
1514 network->connecting = TRUE;
1516 __connman_device_disconnect(network->device);
1518 err = network->driver->connect(network);
1520 if (err == -EINPROGRESS)
1521 connman_network_set_associating(network, TRUE);
1523 network->connecting = FALSE;
1529 set_connected(network);
1535 * __connman_network_disconnect:
1536 * @network: network structure
1538 * Disconnect network
1540 int __connman_network_disconnect(struct connman_network *network)
1544 DBG("network %p", network);
1546 if (network->connected == FALSE && network->connecting == FALSE &&
1547 network->associating == FALSE)
1550 if (network->driver == NULL)
1553 if (network->driver->disconnect == NULL)
1556 network->connecting = FALSE;
1558 err = network->driver->disconnect(network);
1560 set_disconnected(network);
1565 static int manual_ipv4_set(struct connman_network *network,
1566 struct connman_ipconfig *ipconfig)
1568 struct connman_service *service;
1571 service = __connman_service_lookup_from_network(network);
1572 if (service == NULL)
1575 err = __connman_ipconfig_address_add(ipconfig);
1577 connman_network_set_error(network,
1578 CONNMAN_NETWORK_ERROR_CONFIGURE_FAIL);
1582 return __connman_ipconfig_gateway_add(ipconfig);
1585 int __connman_network_clear_ipconfig(struct connman_network *network,
1586 struct connman_ipconfig *ipconfig)
1588 struct connman_service *service;
1589 enum connman_ipconfig_method method;
1590 enum connman_ipconfig_type type;
1592 service = __connman_service_lookup_from_network(network);
1593 if (service == NULL)
1596 method = __connman_ipconfig_get_method(ipconfig);
1597 type = __connman_ipconfig_get_config_type(ipconfig);
1600 case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
1601 case CONNMAN_IPCONFIG_METHOD_OFF:
1602 case CONNMAN_IPCONFIG_METHOD_FIXED:
1604 case CONNMAN_IPCONFIG_METHOD_AUTO:
1605 release_dhcpv6(network);
1607 case CONNMAN_IPCONFIG_METHOD_MANUAL:
1608 __connman_ipconfig_address_remove(ipconfig);
1610 case CONNMAN_IPCONFIG_METHOD_DHCP:
1611 __connman_dhcp_stop(network);
1615 if (type == CONNMAN_IPCONFIG_TYPE_IPV6)
1616 __connman_service_ipconfig_indicate_state(service,
1617 CONNMAN_SERVICE_STATE_CONFIGURATION,
1618 CONNMAN_IPCONFIG_TYPE_IPV6);
1619 else if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
1620 __connman_service_ipconfig_indicate_state(service,
1621 CONNMAN_SERVICE_STATE_CONFIGURATION,
1622 CONNMAN_IPCONFIG_TYPE_IPV4);
1627 int __connman_network_set_ipconfig(struct connman_network *network,
1628 struct connman_ipconfig *ipconfig_ipv4,
1629 struct connman_ipconfig *ipconfig_ipv6)
1631 enum connman_ipconfig_method method;
1634 if (network == NULL)
1637 if (ipconfig_ipv6) {
1638 method = __connman_ipconfig_get_method(ipconfig_ipv6);
1641 case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
1642 case CONNMAN_IPCONFIG_METHOD_OFF:
1644 case CONNMAN_IPCONFIG_METHOD_AUTO:
1645 autoconf_ipv6_set(network);
1647 case CONNMAN_IPCONFIG_METHOD_FIXED:
1648 case CONNMAN_IPCONFIG_METHOD_MANUAL:
1649 ret = manual_ipv6_set(network, ipconfig_ipv6);
1651 connman_network_set_error(network,
1652 CONNMAN_NETWORK_ERROR_ASSOCIATE_FAIL);
1656 case CONNMAN_IPCONFIG_METHOD_DHCP:
1661 if (ipconfig_ipv4) {
1662 method = __connman_ipconfig_get_method(ipconfig_ipv4);
1665 case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
1666 case CONNMAN_IPCONFIG_METHOD_OFF:
1667 case CONNMAN_IPCONFIG_METHOD_FIXED:
1668 case CONNMAN_IPCONFIG_METHOD_AUTO:
1670 case CONNMAN_IPCONFIG_METHOD_MANUAL:
1671 return manual_ipv4_set(network, ipconfig_ipv4);
1672 case CONNMAN_IPCONFIG_METHOD_DHCP:
1673 return __connman_dhcp_start(network, dhcp_callback);
1680 int connman_network_set_ipaddress(struct connman_network *network,
1681 struct connman_ipaddress *ipaddress)
1683 struct connman_service *service;
1684 struct connman_ipconfig *ipconfig = NULL;
1686 DBG("network %p", network);
1688 service = __connman_service_lookup_from_network(network);
1689 if (service == NULL)
1692 ipconfig = __connman_service_get_ipconfig(service, ipaddress->family);
1693 if (ipconfig == NULL)
1696 __connman_ipconfig_set_local(ipconfig, ipaddress->local);
1697 __connman_ipconfig_set_peer(ipconfig, ipaddress->peer);
1698 __connman_ipconfig_set_broadcast(ipconfig, ipaddress->broadcast);
1699 __connman_ipconfig_set_prefixlen(ipconfig, ipaddress->prefixlen);
1700 __connman_ipconfig_set_gateway(ipconfig, ipaddress->gateway);
1705 int connman_network_set_nameservers(struct connman_network *network,
1706 const char *nameservers)
1708 struct connman_service *service;
1709 char **nameservers_array;
1712 DBG("network %p nameservers %s", network, nameservers);
1714 service = __connman_service_lookup_from_network(network);
1715 if (service == NULL)
1718 __connman_service_nameserver_clear(service);
1720 if (nameservers == NULL)
1723 nameservers_array = g_strsplit(nameservers, " ", 0);
1725 for (i = 0; nameservers_array[i] != NULL; i++) {
1726 __connman_service_nameserver_append(service,
1727 nameservers_array[i], FALSE);
1730 g_strfreev(nameservers_array);
1735 int connman_network_set_domain(struct connman_network *network,
1738 struct connman_service *service;
1740 DBG("network %p domain %s", network, domain);
1742 service = __connman_service_lookup_from_network(network);
1743 if (service == NULL)
1746 __connman_service_set_domainname(service, domain);
1752 * connman_network_set_name:
1753 * @network: network structure
1756 * Set display name value for network
1758 int connman_network_set_name(struct connman_network *network,
1761 DBG("network %p name %s", network, name);
1763 g_free(network->name);
1764 network->name = g_strdup(name);
1770 * connman_network_set_strength:
1771 * @network: network structure
1772 * @strength: strength value
1774 * Set signal strength value for network
1777 int connman_network_set_strength(struct connman_network *network,
1778 connman_uint8_t strength)
1780 DBG("network %p strengh %d", network, strength);
1782 network->strength = strength;
1787 connman_uint8_t connman_network_get_strength(struct connman_network *network)
1789 return network->strength;
1792 int connman_network_set_frequency(struct connman_network *network,
1793 connman_uint16_t frequency)
1795 DBG("network %p frequency %d", network, frequency);
1797 network->frequency = frequency;
1802 connman_uint16_t connman_network_get_frequency(struct connman_network *network)
1804 return network->frequency;
1807 int connman_network_set_wifi_channel(struct connman_network *network,
1808 connman_uint16_t channel)
1810 DBG("network %p wifi channel %d", network, channel);
1812 network->wifi.channel = channel;
1817 connman_uint16_t connman_network_get_wifi_channel(struct connman_network *network)
1819 return network->wifi.channel;
1823 * connman_network_set_string:
1824 * @network: network structure
1825 * @key: unique identifier
1826 * @value: string value
1828 * Set string value for specific key
1830 int connman_network_set_string(struct connman_network *network,
1831 const char *key, const char *value)
1833 DBG("network %p key %s value %s", network, key, value);
1835 if (g_strcmp0(key, "Name") == 0)
1836 return connman_network_set_name(network, value);
1838 if (g_str_equal(key, "Path") == TRUE) {
1839 g_free(network->path);
1840 network->path = g_strdup(value);
1841 } else if (g_str_equal(key, "Node") == TRUE) {
1842 g_free(network->node);
1843 network->node = g_strdup(value);
1844 } else if (g_str_equal(key, "WiFi.Mode") == TRUE) {
1845 g_free(network->wifi.mode);
1846 network->wifi.mode = g_strdup(value);
1847 } else if (g_str_equal(key, "WiFi.Security") == TRUE) {
1848 g_free(network->wifi.security);
1849 network->wifi.security = g_strdup(value);
1850 } else if (g_str_equal(key, "WiFi.Passphrase") == TRUE) {
1851 g_free(network->wifi.passphrase);
1852 network->wifi.passphrase = g_strdup(value);
1853 } else if (g_str_equal(key, "WiFi.AgentPassphrase") == TRUE) {
1854 g_free(network->wifi.agent_passphrase);
1855 network->wifi.agent_passphrase = g_strdup(value);
1856 } else if (g_str_equal(key, "WiFi.EAP") == TRUE) {
1857 g_free(network->wifi.eap);
1858 network->wifi.eap = g_strdup(value);
1859 } else if (g_str_equal(key, "WiFi.Identity") == TRUE) {
1860 g_free(network->wifi.identity);
1861 network->wifi.identity = g_strdup(value);
1862 } else if (g_str_equal(key, "WiFi.AgentIdentity") == TRUE) {
1863 g_free(network->wifi.agent_identity);
1864 network->wifi.agent_identity = g_strdup(value);
1865 } else if (g_str_equal(key, "WiFi.CACertFile") == TRUE) {
1866 g_free(network->wifi.ca_cert_path);
1867 network->wifi.ca_cert_path = g_strdup(value);
1868 } else if (g_str_equal(key, "WiFi.ClientCertFile") == TRUE) {
1869 g_free(network->wifi.client_cert_path);
1870 network->wifi.client_cert_path = g_strdup(value);
1871 } else if (g_str_equal(key, "WiFi.PrivateKeyFile") == TRUE) {
1872 g_free(network->wifi.private_key_path);
1873 network->wifi.private_key_path = g_strdup(value);
1874 } else if (g_str_equal(key, "WiFi.PrivateKeyPassphrase") == TRUE) {
1875 g_free(network->wifi.private_key_passphrase);
1876 network->wifi.private_key_passphrase = g_strdup(value);
1877 } else if (g_str_equal(key, "WiFi.Phase2") == TRUE) {
1878 g_free(network->wifi.phase2_auth);
1879 network->wifi.phase2_auth = g_strdup(value);
1880 } else if (g_str_equal(key, "WiFi.PinWPS") == TRUE) {
1881 g_free(network->wifi.pin_wps);
1882 network->wifi.pin_wps = g_strdup(value);
1891 * connman_network_get_string:
1892 * @network: network structure
1893 * @key: unique identifier
1895 * Get string value for specific key
1897 const char *connman_network_get_string(struct connman_network *network,
1900 DBG("network %p key %s", network, key);
1902 if (g_str_equal(key, "Path") == TRUE)
1903 return network->path;
1904 else if (g_str_equal(key, "Name") == TRUE)
1905 return network->name;
1906 else if (g_str_equal(key, "Node") == TRUE)
1907 return network->node;
1908 else if (g_str_equal(key, "WiFi.Mode") == TRUE)
1909 return network->wifi.mode;
1910 else if (g_str_equal(key, "WiFi.Security") == TRUE)
1911 return network->wifi.security;
1912 else if (g_str_equal(key, "WiFi.Passphrase") == TRUE)
1913 return network->wifi.passphrase;
1914 else if (g_str_equal(key, "WiFi.AgentPassphrase") == TRUE)
1915 return network->wifi.agent_passphrase;
1916 else if (g_str_equal(key, "WiFi.EAP") == TRUE)
1917 return network->wifi.eap;
1918 else if (g_str_equal(key, "WiFi.Identity") == TRUE)
1919 return network->wifi.identity;
1920 else if (g_str_equal(key, "WiFi.AgentIdentity") == TRUE)
1921 return network->wifi.agent_identity;
1922 else if (g_str_equal(key, "WiFi.CACertFile") == TRUE)
1923 return network->wifi.ca_cert_path;
1924 else if (g_str_equal(key, "WiFi.ClientCertFile") == TRUE)
1925 return network->wifi.client_cert_path;
1926 else if (g_str_equal(key, "WiFi.PrivateKeyFile") == TRUE)
1927 return network->wifi.private_key_path;
1928 else if (g_str_equal(key, "WiFi.PrivateKeyPassphrase") == TRUE)
1929 return network->wifi.private_key_passphrase;
1930 else if (g_str_equal(key, "WiFi.Phase2") == TRUE)
1931 return network->wifi.phase2_auth;
1932 else if (g_str_equal(key, "WiFi.PinWPS") == TRUE)
1933 return network->wifi.pin_wps;
1939 * connman_network_set_bool:
1940 * @network: network structure
1941 * @key: unique identifier
1942 * @value: boolean value
1944 * Set boolean value for specific key
1946 int connman_network_set_bool(struct connman_network *network,
1947 const char *key, connman_bool_t value)
1949 DBG("network %p key %s value %d", network, key, value);
1951 if (g_strcmp0(key, "Roaming") == 0)
1952 network->roaming = value;
1953 else if (g_strcmp0(key, "WiFi.WPS") == 0)
1954 network->wifi.wps = value;
1955 else if (g_strcmp0(key, "WiFi.UseWPS") == 0)
1956 network->wifi.use_wps = value;
1962 * connman_network_get_bool:
1963 * @network: network structure
1964 * @key: unique identifier
1966 * Get boolean value for specific key
1968 connman_bool_t connman_network_get_bool(struct connman_network *network,
1971 DBG("network %p key %s", network, key);
1973 if (g_str_equal(key, "Roaming") == TRUE)
1974 return network->roaming;
1975 else if (g_str_equal(key, "WiFi.WPS") == TRUE)
1976 return network->wifi.wps;
1977 else if (g_str_equal(key, "WiFi.UseWPS") == TRUE)
1978 return network->wifi.use_wps;
1984 * connman_network_set_blob:
1985 * @network: network structure
1986 * @key: unique identifier
1990 * Set binary blob value for specific key
1992 int connman_network_set_blob(struct connman_network *network,
1993 const char *key, const void *data, unsigned int size)
1995 DBG("network %p key %s size %d", network, key, size);
1997 if (g_str_equal(key, "WiFi.SSID") == TRUE) {
1998 g_free(network->wifi.ssid);
1999 network->wifi.ssid = g_try_malloc(size);
2000 if (network->wifi.ssid != NULL) {
2001 memcpy(network->wifi.ssid, data, size);
2002 network->wifi.ssid_len = size;
2004 network->wifi.ssid_len = 0;
2013 * connman_network_get_blob:
2014 * @network: network structure
2015 * @key: unique identifier
2016 * @size: pointer to blob size
2018 * Get binary blob value for specific key
2020 const void *connman_network_get_blob(struct connman_network *network,
2021 const char *key, unsigned int *size)
2023 DBG("network %p key %s", network, key);
2025 if (g_str_equal(key, "WiFi.SSID") == TRUE) {
2027 *size = network->wifi.ssid_len;
2028 return network->wifi.ssid;
2034 void __connman_network_set_device(struct connman_network *network,
2035 struct connman_device *device)
2037 if (network->device == device)
2040 if (network->device != NULL)
2041 network_remove(network);
2043 network->device = device;
2045 if (network->device != NULL)
2046 network_probe(network);
2050 * connman_network_get_device:
2051 * @network: network structure
2053 * Get parent device of network
2055 struct connman_device *connman_network_get_device(struct connman_network *network)
2057 return network->device;
2061 * connman_network_get_data:
2062 * @network: network structure
2064 * Get private network data pointer
2066 void *connman_network_get_data(struct connman_network *network)
2068 return network->driver_data;
2072 * connman_network_set_data:
2073 * @network: network structure
2074 * @data: data pointer
2076 * Set private network data pointer
2078 void connman_network_set_data(struct connman_network *network, void *data)
2080 network->driver_data = data;
2083 void connman_network_update(struct connman_network *network)
2085 switch (network->type) {
2086 case CONNMAN_NETWORK_TYPE_UNKNOWN:
2087 case CONNMAN_NETWORK_TYPE_VENDOR:
2089 case CONNMAN_NETWORK_TYPE_ETHERNET:
2090 case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
2091 case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
2092 case CONNMAN_NETWORK_TYPE_CELLULAR:
2093 case CONNMAN_NETWORK_TYPE_WIFI:
2094 case CONNMAN_NETWORK_TYPE_WIMAX:
2098 if (network->group != NULL)
2099 __connman_service_update_from_network(network);
2102 int __connman_network_init(void)
2109 void __connman_network_cleanup(void)