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
31 static GSList *network_list = NULL;
32 static GSList *driver_list = NULL;
34 struct connman_network {
36 enum connman_network_type type;
37 connman_bool_t available;
38 connman_bool_t connected;
39 connman_bool_t roaming;
40 connman_uint8_t strength;
41 connman_uint16_t frequency;
48 int router_solicit_count;
50 struct connman_network_driver *driver;
53 connman_bool_t connecting;
54 connman_bool_t associating;
56 struct connman_device *device;
62 unsigned short channel;
65 char *agent_passphrase;
70 char *client_cert_path;
71 char *private_key_path;
72 char *private_key_passphrase;
75 connman_bool_t use_wps;
85 static const char *type2string(enum connman_network_type type)
88 case CONNMAN_NETWORK_TYPE_UNKNOWN:
89 case CONNMAN_NETWORK_TYPE_VENDOR:
91 case CONNMAN_NETWORK_TYPE_ETHERNET:
93 case CONNMAN_NETWORK_TYPE_WIFI:
95 case CONNMAN_NETWORK_TYPE_WIMAX:
97 case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
98 case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
100 case CONNMAN_NETWORK_TYPE_CELLULAR:
107 static gboolean match_driver(struct connman_network *network,
108 struct connman_network_driver *driver)
110 if (network->type == driver->type ||
111 driver->type == CONNMAN_NETWORK_TYPE_UNKNOWN)
117 static int network_probe(struct connman_network *network)
120 struct connman_network_driver *driver = NULL;
122 DBG("network %p name %s", network, network->name);
124 if (network->driver != NULL)
127 for (list = driver_list; list; list = list->next) {
130 if (match_driver(network, driver) == FALSE)
133 DBG("driver %p name %s", driver, driver->name);
135 if (driver->probe(network) == 0)
144 if (network->group == NULL)
147 switch (network->type) {
148 case CONNMAN_NETWORK_TYPE_UNKNOWN:
149 case CONNMAN_NETWORK_TYPE_VENDOR:
151 case CONNMAN_NETWORK_TYPE_ETHERNET:
152 case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
153 case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
154 case CONNMAN_NETWORK_TYPE_CELLULAR:
155 case CONNMAN_NETWORK_TYPE_WIFI:
156 case CONNMAN_NETWORK_TYPE_WIMAX:
157 network->driver = driver;
158 if (__connman_service_create_from_network(network) == NULL) {
159 network->driver = NULL;
167 static void network_remove(struct connman_network *network)
169 DBG("network %p name %s", network, network->name);
171 if (network->driver == NULL)
174 connman_network_set_connected(network, FALSE);
176 switch (network->type) {
177 case CONNMAN_NETWORK_TYPE_UNKNOWN:
178 case CONNMAN_NETWORK_TYPE_VENDOR:
180 case CONNMAN_NETWORK_TYPE_ETHERNET:
181 case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
182 case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
183 case CONNMAN_NETWORK_TYPE_CELLULAR:
184 case CONNMAN_NETWORK_TYPE_WIFI:
185 case CONNMAN_NETWORK_TYPE_WIMAX:
186 if (network->group != NULL) {
187 __connman_service_remove_from_network(network);
189 g_free(network->group);
190 network->group = NULL;
195 if (network->driver->remove)
196 network->driver->remove(network);
198 network->driver = NULL;
201 static void network_change(struct connman_network *network)
203 DBG("network %p name %s", network, network->name);
205 if (network->connected == FALSE)
208 connman_device_set_disconnected(network->device, TRUE);
210 if (network->driver && network->driver->disconnect) {
211 network->driver->disconnect(network);
215 network->connected = FALSE;
218 static void probe_driver(struct connman_network_driver *driver)
222 DBG("driver %p name %s", driver, driver->name);
224 for (list = network_list; list != NULL; list = list->next) {
225 struct connman_network *network = list->data;
227 if (network->driver != NULL)
230 if (driver->type != network->type)
233 if (driver->probe(network) < 0)
236 network->driver = driver;
240 static void remove_driver(struct connman_network_driver *driver)
244 DBG("driver %p name %s", driver, driver->name);
246 for (list = network_list; list != NULL; list = list->next) {
247 struct connman_network *network = list->data;
249 if (network->driver == driver)
250 network_remove(network);
254 static gint compare_priority(gconstpointer a, gconstpointer b)
256 const struct connman_network_driver *driver1 = a;
257 const struct connman_network_driver *driver2 = b;
259 return driver2->priority - driver1->priority;
263 * connman_network_driver_register:
264 * @driver: network driver definition
266 * Register a new network driver
268 * Returns: %0 on success
270 int connman_network_driver_register(struct connman_network_driver *driver)
274 DBG("driver %p name %s", driver, driver->name);
276 for (list = driver_list; list; list = list->next) {
277 struct connman_network_driver *tmp = list->data;
279 if (tmp->type == driver->type)
284 driver_list = g_slist_insert_sorted(driver_list, driver,
287 probe_driver(driver);
293 * connman_network_driver_unregister:
294 * @driver: network driver definition
296 * Remove a previously registered network driver
298 void connman_network_driver_unregister(struct connman_network_driver *driver)
300 DBG("driver %p name %s", driver, driver->name);
302 driver_list = g_slist_remove(driver_list, driver);
304 remove_driver(driver);
307 static void network_destruct(struct connman_network *network)
309 DBG("network %p name %s", network, network->name);
311 g_free(network->wifi.ssid);
312 g_free(network->wifi.mode);
313 g_free(network->wifi.security);
314 g_free(network->wifi.passphrase);
315 g_free(network->wifi.agent_passphrase);
316 g_free(network->wifi.eap);
317 g_free(network->wifi.identity);
318 g_free(network->wifi.agent_identity);
319 g_free(network->wifi.ca_cert_path);
320 g_free(network->wifi.client_cert_path);
321 g_free(network->wifi.private_key_path);
322 g_free(network->wifi.private_key_passphrase);
323 g_free(network->wifi.phase2_auth);
324 g_free(network->wifi.pin_wps);
326 g_free(network->path);
327 g_free(network->group);
328 g_free(network->node);
329 g_free(network->name);
330 g_free(network->identifier);
332 network->device = NULL;
338 * connman_network_create:
339 * @identifier: network identifier (for example an unqiue name)
341 * Allocate a new network and assign the #identifier to it.
343 * Returns: a newly-allocated #connman_network structure
345 struct connman_network *connman_network_create(const char *identifier,
346 enum connman_network_type type)
348 struct connman_network *network;
351 DBG("identifier %s type %d", identifier, type);
353 network = g_try_new0(struct connman_network, 1);
357 DBG("network %p", network);
359 network->refcount = 1;
361 ident = g_strdup(identifier);
368 network->type = type;
369 network->identifier = ident;
371 network_list = g_slist_append(network_list, network);
377 * connman_network_ref:
378 * @network: network structure
380 * Increase reference counter of network
382 struct connman_network *
383 connman_network_ref_debug(struct connman_network *network,
384 const char *file, int line, const char *caller)
386 DBG("%p name %s ref %d by %s:%d:%s()", network, network->name,
387 network->refcount + 1, file, line, caller);
389 __sync_fetch_and_add(&network->refcount, 1);
395 * connman_network_unref:
396 * @network: network structure
398 * Decrease reference counter of network
400 void connman_network_unref_debug(struct connman_network *network,
401 const char *file, int line, const char *caller)
403 DBG("%p name %s ref %d by %s:%d:%s()", network, network->name,
404 network->refcount - 1, file, line, caller);
406 if (__sync_fetch_and_sub(&network->refcount, 1) != 1)
409 network_list = g_slist_remove(network_list, network);
411 network_destruct(network);
414 const char *__connman_network_get_type(struct connman_network *network)
416 return type2string(network->type);
420 * connman_network_get_type:
421 * @network: network structure
423 * Get type of network
425 enum connman_network_type connman_network_get_type(struct connman_network *network)
427 return network->type;
431 * connman_network_get_identifier:
432 * @network: network structure
434 * Get identifier of network
436 const char *connman_network_get_identifier(struct connman_network *network)
438 return network->identifier;
442 * connman_network_set_index:
443 * @network: network structure
444 * @index: index number
446 * Set index number of network
448 void connman_network_set_index(struct connman_network *network, int index)
450 struct connman_service *service;
451 struct connman_ipconfig *ipconfig;
453 service = __connman_service_lookup_from_network(network);
457 ipconfig = __connman_service_get_ip4config(service);
459 DBG("index %d service %p ip4config %p", network->index,
462 if (network->index < 0 && ipconfig == NULL) {
464 ipconfig = __connman_service_get_ip4config(service);
465 if (ipconfig == NULL)
467 * This is needed for plugins that havent set their
468 * ipconfig layer yet, due to not being able to get
469 * a network index prior to creating a service.
471 __connman_service_create_ip4config(service, index);
473 __connman_ipconfig_set_index(ipconfig, index);
476 /* If index changed, the index of ipconfig must be reset. */
477 if (ipconfig == NULL)
480 __connman_ipconfig_set_index(ipconfig, index);
484 network->index = index;
488 * connman_network_get_index:
489 * @network: network structure
491 * Get index number of network
493 int connman_network_get_index(struct connman_network *network)
495 return network->index;
499 * connman_network_set_group:
500 * @network: network structure
503 * Set group name for automatic clustering
505 void connman_network_set_group(struct connman_network *network,
508 switch (network->type) {
509 case CONNMAN_NETWORK_TYPE_UNKNOWN:
510 case CONNMAN_NETWORK_TYPE_VENDOR:
512 case CONNMAN_NETWORK_TYPE_ETHERNET:
513 case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
514 case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
515 case CONNMAN_NETWORK_TYPE_CELLULAR:
516 case CONNMAN_NETWORK_TYPE_WIFI:
517 case CONNMAN_NETWORK_TYPE_WIMAX:
521 if (g_strcmp0(network->group, group) == 0) {
523 __connman_service_update_from_network(network);
527 if (network->group != NULL) {
528 __connman_service_remove_from_network(network);
530 g_free(network->group);
533 network->group = g_strdup(group);
535 if (network->group != NULL)
536 network_probe(network);
540 * connman_network_get_group:
541 * @network: network structure
543 * Get group name for automatic clustering
545 const char *connman_network_get_group(struct connman_network *network)
547 return network->group;
550 const char *__connman_network_get_ident(struct connman_network *network)
552 if (network->device == NULL)
555 return connman_device_get_ident(network->device);
558 connman_bool_t __connman_network_get_weakness(struct connman_network *network)
560 switch (network->type) {
561 case CONNMAN_NETWORK_TYPE_UNKNOWN:
562 case CONNMAN_NETWORK_TYPE_VENDOR:
563 case CONNMAN_NETWORK_TYPE_ETHERNET:
564 case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
565 case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
566 case CONNMAN_NETWORK_TYPE_CELLULAR:
567 case CONNMAN_NETWORK_TYPE_WIMAX:
569 case CONNMAN_NETWORK_TYPE_WIFI:
570 if (g_strcmp0(network->wifi.mode, "adhoc") == 0)
572 if (network->strength > 0 && network->strength < 20)
580 connman_bool_t connman_network_get_connecting(struct connman_network *network)
582 return network->connecting;
586 * connman_network_set_available:
587 * @network: network structure
588 * @available: availability state
590 * Change availability state of network (in range)
592 int connman_network_set_available(struct connman_network *network,
593 connman_bool_t available)
595 DBG("network %p available %d", network, available);
597 if (network->available == available)
600 network->available = available;
606 * connman_network_get_available:
607 * @network: network structure
609 * Get network available setting
611 connman_bool_t connman_network_get_available(struct connman_network *network)
613 return network->available;
617 * connman_network_set_associating:
618 * @network: network structure
619 * @associating: associating state
621 * Change associating state of network
623 int connman_network_set_associating(struct connman_network *network,
624 connman_bool_t associating)
626 DBG("network %p associating %d", network, associating);
628 if (network->associating == associating)
631 network->associating = associating;
633 if (associating == TRUE) {
634 struct connman_service *service;
636 service = __connman_service_lookup_from_network(network);
637 __connman_service_ipconfig_indicate_state(service,
638 CONNMAN_SERVICE_STATE_ASSOCIATION,
639 CONNMAN_IPCONFIG_TYPE_IPV4);
640 __connman_service_ipconfig_indicate_state(service,
641 CONNMAN_SERVICE_STATE_ASSOCIATION,
642 CONNMAN_IPCONFIG_TYPE_IPV6);
648 static void set_associate_error(struct connman_network *network)
650 struct connman_service *service;
652 service = __connman_service_lookup_from_network(network);
654 __connman_service_indicate_error(service,
655 CONNMAN_SERVICE_ERROR_CONNECT_FAILED);
658 static void set_configure_error(struct connman_network *network)
660 struct connman_service *service;
662 service = __connman_service_lookup_from_network(network);
664 __connman_service_indicate_error(service,
665 CONNMAN_SERVICE_ERROR_CONNECT_FAILED);
668 static void set_invalid_key_error(struct connman_network *network)
670 struct connman_service *service;
672 service = __connman_service_lookup_from_network(network);
674 __connman_service_indicate_error(service,
675 CONNMAN_SERVICE_ERROR_INVALID_KEY);
678 static void set_connect_error(struct connman_network *network)
680 struct connman_service *service;
682 service = __connman_service_lookup_from_network(network);
684 __connman_service_indicate_error(service,
685 CONNMAN_SERVICE_ERROR_CONNECT_FAILED);
688 void connman_network_set_ipv4_method(struct connman_network *network,
689 enum connman_ipconfig_method method)
691 struct connman_service *service;
692 struct connman_ipconfig *ipconfig;
694 service = __connman_service_lookup_from_network(network);
698 ipconfig = __connman_service_get_ip4config(service);
699 if (ipconfig == NULL)
702 __connman_ipconfig_set_method(ipconfig, method);
705 void connman_network_set_ipv6_method(struct connman_network *network,
706 enum connman_ipconfig_method method)
708 struct connman_service *service;
709 struct connman_ipconfig *ipconfig;
711 service = __connman_service_lookup_from_network(network);
715 ipconfig = __connman_service_get_ip6config(service);
716 if (ipconfig == NULL)
719 __connman_ipconfig_set_method(ipconfig, method);
722 void connman_network_set_error(struct connman_network *network,
723 enum connman_network_error error)
725 DBG("nework %p, error %d", network, error);
727 network->connecting = FALSE;
728 network->associating = FALSE;
731 case CONNMAN_NETWORK_ERROR_UNKNOWN:
733 case CONNMAN_NETWORK_ERROR_ASSOCIATE_FAIL:
734 set_associate_error(network);
736 case CONNMAN_NETWORK_ERROR_CONFIGURE_FAIL:
737 set_configure_error(network);
739 case CONNMAN_NETWORK_ERROR_INVALID_KEY:
740 set_invalid_key_error(network);
742 case CONNMAN_NETWORK_ERROR_CONNECT_FAIL:
743 set_connect_error(network);
747 network_change(network);
750 void connman_network_clear_error(struct connman_network *network)
752 struct connman_service *service;
754 DBG("network %p", network);
759 if (network->connecting == TRUE || network->associating == TRUE)
762 service = __connman_service_lookup_from_network(network);
763 __connman_service_clear_error(service);
766 static void set_configuration(struct connman_network *network,
767 enum connman_ipconfig_type type)
769 struct connman_service *service;
771 DBG("network %p", network);
773 if (network->device == NULL)
776 __connman_device_set_network(network->device, network);
778 connman_device_set_disconnected(network->device, FALSE);
780 service = __connman_service_lookup_from_network(network);
781 __connman_service_ipconfig_indicate_state(service,
782 CONNMAN_SERVICE_STATE_CONFIGURATION,
786 static void dhcp_success(struct connman_network *network)
788 struct connman_service *service;
789 struct connman_ipconfig *ipconfig_ipv4;
792 service = __connman_service_lookup_from_network(network);
796 connman_network_set_associating(network, FALSE);
798 network->connecting = FALSE;
800 ipconfig_ipv4 = __connman_service_get_ip4config(service);
801 err = __connman_ipconfig_address_add(ipconfig_ipv4);
805 err = __connman_ipconfig_gateway_add(ipconfig_ipv4);
812 connman_network_set_error(network,
813 CONNMAN_NETWORK_ERROR_CONFIGURE_FAIL);
816 static void dhcp_failure(struct connman_network *network)
818 struct connman_service *service;
820 service = __connman_service_lookup_from_network(network);
824 __connman_service_ipconfig_indicate_state(service,
825 CONNMAN_SERVICE_STATE_IDLE,
826 CONNMAN_IPCONFIG_TYPE_IPV4);
829 static void dhcp_callback(struct connman_network *network,
830 connman_bool_t success)
832 DBG("success %d", success);
835 dhcp_success(network);
837 dhcp_failure(network);
840 static int set_connected_fixed(struct connman_network *network)
842 struct connman_service *service;
843 struct connman_ipconfig *ipconfig_ipv4;
848 service = __connman_service_lookup_from_network(network);
850 ipconfig_ipv4 = __connman_service_get_ip4config(service);
852 set_configuration(network, CONNMAN_IPCONFIG_TYPE_IPV4);
854 network->connecting = FALSE;
856 connman_network_set_associating(network, FALSE);
858 err = __connman_ipconfig_address_add(ipconfig_ipv4);
862 err = __connman_ipconfig_gateway_add(ipconfig_ipv4);
869 connman_network_set_error(network,
870 CONNMAN_NETWORK_ERROR_CONFIGURE_FAIL);
875 static void set_connected_manual(struct connman_network *network)
877 struct connman_service *service;
878 struct connman_ipconfig *ipconfig;
881 DBG("network %p", network);
883 service = __connman_service_lookup_from_network(network);
885 ipconfig = __connman_service_get_ip4config(service);
887 if (__connman_ipconfig_get_local(ipconfig) == NULL)
888 __connman_service_read_ip4config(service);
890 set_configuration(network, CONNMAN_IPCONFIG_TYPE_IPV4);
892 err = __connman_ipconfig_address_add(ipconfig);
896 err = __connman_ipconfig_gateway_add(ipconfig);
900 network->connecting = FALSE;
902 connman_network_set_associating(network, FALSE);
907 connman_network_set_error(network,
908 CONNMAN_NETWORK_ERROR_CONFIGURE_FAIL);
912 static int set_connected_dhcp(struct connman_network *network)
916 DBG("network %p", network);
918 set_configuration(network, CONNMAN_IPCONFIG_TYPE_IPV4);
920 err = __connman_dhcp_start(network, dhcp_callback);
922 connman_error("Can not request DHCP lease");
929 static int manual_ipv6_set(struct connman_network *network,
930 struct connman_ipconfig *ipconfig_ipv6)
932 struct connman_service *service;
935 DBG("network %p ipv6 %p", network, ipconfig_ipv6);
937 service = __connman_service_lookup_from_network(network);
941 if (__connman_ipconfig_get_local(ipconfig_ipv6) == NULL)
942 __connman_service_read_ip6config(service);
944 err = __connman_ipconfig_address_add(ipconfig_ipv6);
946 connman_network_set_error(network,
947 CONNMAN_NETWORK_ERROR_CONFIGURE_FAIL);
951 err = __connman_ipconfig_gateway_add(ipconfig_ipv6);
955 __connman_connection_gateway_activate(service,
956 CONNMAN_IPCONFIG_TYPE_IPV6);
958 __connman_device_set_network(network->device, network);
960 connman_device_set_disconnected(network->device, FALSE);
962 network->connecting = FALSE;
967 static void stop_dhcpv6(struct connman_network *network)
969 __connman_dhcpv6_stop(network);
972 static void dhcpv6_release_callback(struct connman_network *network,
973 connman_bool_t success)
975 DBG("success %d", success);
977 stop_dhcpv6(network);
980 static void release_dhcpv6(struct connman_network *network)
982 __connman_dhcpv6_start_release(network, dhcpv6_release_callback);
983 stop_dhcpv6(network);
986 static void dhcpv6_info_callback(struct connman_network *network,
987 connman_bool_t success)
989 DBG("success %d", success);
991 stop_dhcpv6(network);
994 static gboolean dhcpv6_set_addresses(struct connman_network *network)
996 struct connman_service *service;
997 struct connman_ipconfig *ipconfig_ipv6;
1000 service = __connman_service_lookup_from_network(network);
1001 if (service == NULL)
1004 connman_network_set_associating(network, FALSE);
1006 network->connecting = FALSE;
1008 ipconfig_ipv6 = __connman_service_get_ip6config(service);
1009 err = __connman_ipconfig_address_add(ipconfig_ipv6);
1013 err = __connman_ipconfig_gateway_add(ipconfig_ipv6);
1020 connman_network_set_error(network,
1021 CONNMAN_NETWORK_ERROR_CONFIGURE_FAIL);
1025 static void autoconf_ipv6_set(struct connman_network *network);
1026 static void dhcpv6_callback(struct connman_network *network,
1027 connman_bool_t success);
1030 * Have a separate callback for renew so that we do not do autoconf
1031 * in wrong phase as the dhcpv6_callback() is also called when doing
1032 * DHCPv6 solicitation.
1034 static void dhcpv6_renew_callback(struct connman_network *network,
1035 connman_bool_t success)
1037 if (success == TRUE)
1038 dhcpv6_callback(network, success);
1040 stop_dhcpv6(network);
1042 /* restart and do solicit again. */
1043 autoconf_ipv6_set(network);
1047 static void dhcpv6_callback(struct connman_network *network,
1048 connman_bool_t success)
1050 DBG("success %d", success);
1052 /* Start the renew process if necessary */
1053 if (success == TRUE) {
1055 if (dhcpv6_set_addresses(network) < 0) {
1056 stop_dhcpv6(network);
1060 if (__connman_dhcpv6_start_renew(network,
1061 dhcpv6_renew_callback) == -ETIMEDOUT)
1062 dhcpv6_renew_callback(network, FALSE);
1064 stop_dhcpv6(network);
1067 static void check_dhcpv6(struct nd_router_advert *reply,
1068 unsigned int length, void *user_data)
1070 struct connman_network *network = user_data;
1073 DBG("reply %p", reply);
1075 if (reply == NULL) {
1077 * Router solicitation message seem to get lost easily so
1078 * try to send it again.
1080 if (network->router_solicit_count > 0) {
1081 DBG("re-send router solicitation %d",
1082 network->router_solicit_count);
1083 network->router_solicit_count--;
1084 __connman_inet_ipv6_send_rs(network->index, 1,
1085 check_dhcpv6, network);
1088 connman_network_unref(network);
1092 network->router_solicit_count = 0;
1095 * If we were disconnected while waiting router advertisement,
1096 * we just quit and do not start DHCPv6
1098 if (network->connected == FALSE) {
1099 connman_network_unref(network);
1103 prefixes = __connman_inet_ipv6_get_prefixes(reply, length);
1106 * We do stateful/stateless DHCPv6 if router advertisement says so.
1108 if (reply->nd_ra_flags_reserved & ND_RA_FLAG_MANAGED)
1109 __connman_dhcpv6_start(network, prefixes, dhcpv6_callback);
1110 else if (reply->nd_ra_flags_reserved & ND_RA_FLAG_OTHER)
1111 __connman_dhcpv6_start_info(network, dhcpv6_info_callback);
1113 connman_network_unref(network);
1116 static void autoconf_ipv6_set(struct connman_network *network)
1118 struct connman_service *service;
1119 struct connman_ipconfig *ipconfig;
1122 DBG("network %p", network);
1124 if (network->router_solicit_count > 0) {
1126 * The autoconfiguration is already pending and we have sent
1127 * router solicitation messages and are now waiting answers.
1128 * There is no need to continue any further.
1130 DBG("autoconfiguration already started");
1134 __connman_device_set_network(network->device, network);
1136 connman_device_set_disconnected(network->device, FALSE);
1138 network->connecting = FALSE;
1140 service = __connman_service_lookup_from_network(network);
1141 if (service == NULL)
1144 ipconfig = __connman_service_get_ip6config(service);
1145 if (ipconfig == NULL)
1148 index = __connman_ipconfig_get_index(ipconfig);
1150 connman_network_ref(network);
1152 /* Try to get stateless DHCPv6 information, RFC 3736 */
1153 network->router_solicit_count = 3;
1154 __connman_inet_ipv6_send_rs(index, 1, check_dhcpv6, network);
1157 static void set_connected(struct connman_network *network)
1159 struct connman_ipconfig *ipconfig_ipv4, *ipconfig_ipv6;
1160 enum connman_ipconfig_method ipv4_method, ipv6_method;
1161 struct connman_service *service;
1164 if (network->connected == TRUE)
1167 network->connected = TRUE;
1169 service = __connman_service_lookup_from_network(network);
1171 ipconfig_ipv4 = __connman_service_get_ip4config(service);
1172 ipconfig_ipv6 = __connman_service_get_ip6config(service);
1174 DBG("service %p ipv4 %p ipv6 %p", service, ipconfig_ipv4,
1177 ipv4_method = __connman_ipconfig_get_method(ipconfig_ipv4);
1178 ipv6_method = __connman_ipconfig_get_method(ipconfig_ipv6);
1180 DBG("method ipv4 %d ipv6 %d", ipv4_method, ipv6_method);
1182 switch (ipv6_method) {
1183 case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
1184 case CONNMAN_IPCONFIG_METHOD_OFF:
1186 case CONNMAN_IPCONFIG_METHOD_DHCP:
1187 case CONNMAN_IPCONFIG_METHOD_AUTO:
1188 autoconf_ipv6_set(network);
1190 case CONNMAN_IPCONFIG_METHOD_FIXED:
1191 case CONNMAN_IPCONFIG_METHOD_MANUAL:
1192 ret = manual_ipv6_set(network, ipconfig_ipv6);
1194 connman_network_set_error(network,
1195 CONNMAN_NETWORK_ERROR_ASSOCIATE_FAIL);
1201 switch (ipv4_method) {
1202 case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
1203 case CONNMAN_IPCONFIG_METHOD_OFF:
1204 case CONNMAN_IPCONFIG_METHOD_AUTO:
1206 case CONNMAN_IPCONFIG_METHOD_FIXED:
1207 if (set_connected_fixed(network) < 0) {
1208 connman_network_set_error(network,
1209 CONNMAN_NETWORK_ERROR_ASSOCIATE_FAIL);
1213 case CONNMAN_IPCONFIG_METHOD_MANUAL:
1214 set_connected_manual(network);
1216 case CONNMAN_IPCONFIG_METHOD_DHCP:
1217 if (set_connected_dhcp(network) < 0) {
1218 connman_network_set_error(network,
1219 CONNMAN_NETWORK_ERROR_ASSOCIATE_FAIL);
1224 network->connecting = FALSE;
1226 connman_network_set_associating(network, FALSE);
1229 static void set_disconnected(struct connman_network *network)
1231 struct connman_ipconfig *ipconfig_ipv4, *ipconfig_ipv6;
1232 enum connman_ipconfig_method ipv4_method, ipv6_method;
1233 enum connman_service_state state;
1234 struct connman_service *service;
1236 if (network->connected == FALSE)
1239 network->connected = FALSE;
1241 service = __connman_service_lookup_from_network(network);
1243 ipconfig_ipv4 = __connman_service_get_ip4config(service);
1244 ipconfig_ipv6 = __connman_service_get_ip6config(service);
1246 DBG("service %p ipv4 %p ipv6 %p", service, ipconfig_ipv4,
1249 ipv4_method = __connman_ipconfig_get_method(ipconfig_ipv4);
1250 ipv6_method = __connman_ipconfig_get_method(ipconfig_ipv6);
1252 DBG("method ipv4 %d ipv6 %d", ipv4_method, ipv6_method);
1255 * Resetting solicit count here will prevent the RS resend loop
1256 * from sending packets in check_dhcpv6()
1258 network->router_solicit_count = 0;
1260 __connman_device_set_network(network->device, NULL);
1262 switch (ipv6_method) {
1263 case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
1264 case CONNMAN_IPCONFIG_METHOD_OFF:
1265 case CONNMAN_IPCONFIG_METHOD_FIXED:
1266 case CONNMAN_IPCONFIG_METHOD_MANUAL:
1268 case CONNMAN_IPCONFIG_METHOD_DHCP:
1269 case CONNMAN_IPCONFIG_METHOD_AUTO:
1270 release_dhcpv6(network);
1274 switch (ipv4_method) {
1275 case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
1276 case CONNMAN_IPCONFIG_METHOD_OFF:
1277 case CONNMAN_IPCONFIG_METHOD_AUTO:
1278 case CONNMAN_IPCONFIG_METHOD_FIXED:
1279 case CONNMAN_IPCONFIG_METHOD_MANUAL:
1281 case CONNMAN_IPCONFIG_METHOD_DHCP:
1282 __connman_dhcp_stop(network);
1287 * We only set the disconnect state if we were not in idle
1288 * or in failure. It does not make sense to go to disconnect
1289 * state if we were not connected.
1291 state = __connman_service_ipconfig_get_state(service,
1292 CONNMAN_IPCONFIG_TYPE_IPV4);
1293 if (state != CONNMAN_SERVICE_STATE_IDLE &&
1294 state != CONNMAN_SERVICE_STATE_FAILURE)
1295 __connman_service_ipconfig_indicate_state(service,
1296 CONNMAN_SERVICE_STATE_DISCONNECT,
1297 CONNMAN_IPCONFIG_TYPE_IPV4);
1299 state = __connman_service_ipconfig_get_state(service,
1300 CONNMAN_IPCONFIG_TYPE_IPV6);
1301 if (state != CONNMAN_SERVICE_STATE_IDLE &&
1302 state != CONNMAN_SERVICE_STATE_FAILURE)
1303 __connman_service_ipconfig_indicate_state(service,
1304 CONNMAN_SERVICE_STATE_DISCONNECT,
1305 CONNMAN_IPCONFIG_TYPE_IPV6);
1307 __connman_connection_gateway_remove(service,
1308 CONNMAN_IPCONFIG_TYPE_ALL);
1310 __connman_ipconfig_address_unset(ipconfig_ipv4);
1311 __connman_ipconfig_address_unset(ipconfig_ipv6);
1314 * Special handling for IPv6 autoconfigured address.
1315 * The simplest way to remove autoconfigured routes is to
1316 * disable IPv6 temporarily so that kernel will do the cleanup
1319 if (ipv6_method == CONNMAN_IPCONFIG_METHOD_AUTO) {
1320 __connman_ipconfig_disable_ipv6(ipconfig_ipv6);
1321 __connman_ipconfig_enable_ipv6(ipconfig_ipv6);
1324 __connman_service_ipconfig_indicate_state(service,
1325 CONNMAN_SERVICE_STATE_IDLE,
1326 CONNMAN_IPCONFIG_TYPE_IPV4);
1328 __connman_service_ipconfig_indicate_state(service,
1329 CONNMAN_SERVICE_STATE_IDLE,
1330 CONNMAN_IPCONFIG_TYPE_IPV6);
1332 network->connecting = FALSE;
1334 connman_network_set_associating(network, FALSE);
1338 * connman_network_set_connected:
1339 * @network: network structure
1340 * @connected: connected state
1342 * Change connected state of network
1344 int connman_network_set_connected(struct connman_network *network,
1345 connman_bool_t connected)
1347 DBG("network %p connected %d/%d connecting %d associating %d",
1348 network, network->connected, connected, network->connecting,
1349 network->associating);
1351 if ((network->connecting == TRUE || network->associating == TRUE) &&
1352 connected == FALSE) {
1353 connman_network_set_error(network,
1354 CONNMAN_NETWORK_ERROR_CONNECT_FAIL);
1355 if (__connman_network_disconnect(network) == 0)
1359 if (network->connected == connected)
1362 if (connected == FALSE)
1363 set_disconnected(network);
1365 set_connected(network);
1371 * connman_network_get_connected:
1372 * @network: network structure
1374 * Get network connection status
1376 connman_bool_t connman_network_get_connected(struct connman_network *network)
1378 return network->connected;
1382 * connman_network_get_associating:
1383 * @network: network structure
1385 * Get network associating status
1387 connman_bool_t connman_network_get_associating(struct connman_network *network)
1389 return network->associating;
1392 int connman_network_connect_hidden(struct connman_network *network,
1393 char *identity, char* passphrase)
1396 struct connman_service *service;
1400 service = __connman_service_lookup_from_network(network);
1401 if (service == NULL)
1404 if (identity != NULL)
1405 __connman_service_set_agent_identity(service, identity);
1407 if (passphrase != NULL)
1408 err = __connman_service_add_passphrase(service, passphrase);
1410 if (err == -ENOKEY) {
1411 __connman_service_indicate_error(service,
1412 CONNMAN_SERVICE_ERROR_INVALID_KEY);
1415 __connman_service_set_hidden(service);
1416 __connman_service_set_userconnect(service, TRUE);
1417 return __connman_service_connect(service);
1422 * __connman_network_connect:
1423 * @network: network structure
1427 int __connman_network_connect(struct connman_network *network)
1431 DBG("network %p", network);
1433 if (network->connected == TRUE)
1436 if (network->connecting == TRUE || network->associating == TRUE)
1439 if (network->driver == NULL)
1442 if (network->driver->connect == NULL)
1445 if (network->device == NULL)
1448 network->connecting = TRUE;
1450 __connman_device_disconnect(network->device);
1452 err = network->driver->connect(network);
1454 if (err == -EINPROGRESS)
1455 connman_network_set_associating(network, TRUE);
1457 network->connecting = FALSE;
1463 set_connected(network);
1469 * __connman_network_disconnect:
1470 * @network: network structure
1472 * Disconnect network
1474 int __connman_network_disconnect(struct connman_network *network)
1478 DBG("network %p", network);
1480 if (network->connected == FALSE && network->connecting == FALSE &&
1481 network->associating == FALSE)
1484 if (network->driver == NULL)
1487 if (network->driver->disconnect == NULL)
1490 network->connecting = FALSE;
1492 err = network->driver->disconnect(network);
1494 set_disconnected(network);
1499 static int manual_ipv4_set(struct connman_network *network,
1500 struct connman_ipconfig *ipconfig)
1502 struct connman_service *service;
1505 service = __connman_service_lookup_from_network(network);
1506 if (service == NULL)
1509 err = __connman_ipconfig_address_add(ipconfig);
1511 connman_network_set_error(network,
1512 CONNMAN_NETWORK_ERROR_CONFIGURE_FAIL);
1516 return __connman_ipconfig_gateway_add(ipconfig);
1519 int __connman_network_clear_ipconfig(struct connman_network *network,
1520 struct connman_ipconfig *ipconfig)
1522 struct connman_service *service;
1523 enum connman_ipconfig_method method;
1524 enum connman_ipconfig_type type;
1526 service = __connman_service_lookup_from_network(network);
1527 if (service == NULL)
1530 method = __connman_ipconfig_get_method(ipconfig);
1531 type = __connman_ipconfig_get_config_type(ipconfig);
1534 case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
1535 case CONNMAN_IPCONFIG_METHOD_OFF:
1536 case CONNMAN_IPCONFIG_METHOD_FIXED:
1538 case CONNMAN_IPCONFIG_METHOD_AUTO:
1539 release_dhcpv6(network);
1541 case CONNMAN_IPCONFIG_METHOD_MANUAL:
1542 __connman_ipconfig_address_remove(ipconfig);
1544 case CONNMAN_IPCONFIG_METHOD_DHCP:
1545 __connman_dhcp_stop(network);
1549 if (type == CONNMAN_IPCONFIG_TYPE_IPV6)
1550 __connman_service_ipconfig_indicate_state(service,
1551 CONNMAN_SERVICE_STATE_CONFIGURATION,
1552 CONNMAN_IPCONFIG_TYPE_IPV6);
1553 else if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
1554 __connman_service_ipconfig_indicate_state(service,
1555 CONNMAN_SERVICE_STATE_CONFIGURATION,
1556 CONNMAN_IPCONFIG_TYPE_IPV4);
1561 int __connman_network_set_ipconfig(struct connman_network *network,
1562 struct connman_ipconfig *ipconfig_ipv4,
1563 struct connman_ipconfig *ipconfig_ipv6)
1565 enum connman_ipconfig_method method;
1568 if (network == NULL)
1571 if (ipconfig_ipv6) {
1572 method = __connman_ipconfig_get_method(ipconfig_ipv6);
1575 case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
1576 case CONNMAN_IPCONFIG_METHOD_OFF:
1578 case CONNMAN_IPCONFIG_METHOD_AUTO:
1579 autoconf_ipv6_set(network);
1581 case CONNMAN_IPCONFIG_METHOD_FIXED:
1582 case CONNMAN_IPCONFIG_METHOD_MANUAL:
1583 ret = manual_ipv6_set(network, ipconfig_ipv6);
1585 connman_network_set_error(network,
1586 CONNMAN_NETWORK_ERROR_ASSOCIATE_FAIL);
1590 case CONNMAN_IPCONFIG_METHOD_DHCP:
1595 if (ipconfig_ipv4) {
1596 method = __connman_ipconfig_get_method(ipconfig_ipv4);
1599 case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
1600 case CONNMAN_IPCONFIG_METHOD_OFF:
1601 case CONNMAN_IPCONFIG_METHOD_FIXED:
1602 case CONNMAN_IPCONFIG_METHOD_AUTO:
1604 case CONNMAN_IPCONFIG_METHOD_MANUAL:
1605 return manual_ipv4_set(network, ipconfig_ipv4);
1606 case CONNMAN_IPCONFIG_METHOD_DHCP:
1607 return __connman_dhcp_start(network, dhcp_callback);
1614 int connman_network_set_ipaddress(struct connman_network *network,
1615 struct connman_ipaddress *ipaddress)
1617 struct connman_service *service;
1618 struct connman_ipconfig *ipconfig = NULL;
1620 DBG("network %p", network);
1622 service = __connman_service_lookup_from_network(network);
1623 if (service == NULL)
1626 ipconfig = __connman_service_get_ipconfig(service, ipaddress->family);
1627 if (ipconfig == NULL)
1630 __connman_ipconfig_set_local(ipconfig, ipaddress->local);
1631 __connman_ipconfig_set_peer(ipconfig, ipaddress->peer);
1632 __connman_ipconfig_set_broadcast(ipconfig, ipaddress->broadcast);
1633 __connman_ipconfig_set_prefixlen(ipconfig, ipaddress->prefixlen);
1634 __connman_ipconfig_set_gateway(ipconfig, ipaddress->gateway);
1639 int connman_network_set_nameservers(struct connman_network *network,
1640 const char *nameservers)
1642 struct connman_service *service;
1643 char **nameservers_array;
1646 DBG("network %p nameservers %s", network, nameservers);
1648 service = __connman_service_lookup_from_network(network);
1649 if (service == NULL)
1652 __connman_service_nameserver_clear(service);
1654 if (nameservers == NULL)
1657 nameservers_array = g_strsplit(nameservers, " ", 0);
1659 for (i = 0; nameservers_array[i] != NULL; i++) {
1660 __connman_service_nameserver_append(service,
1661 nameservers_array[i], FALSE);
1664 g_strfreev(nameservers_array);
1669 int connman_network_set_domain(struct connman_network *network,
1672 struct connman_service *service;
1674 DBG("network %p domain %s", network, domain);
1676 service = __connman_service_lookup_from_network(network);
1677 if (service == NULL)
1680 __connman_service_set_domainname(service, domain);
1686 * connman_network_set_name:
1687 * @network: network structure
1690 * Set display name value for network
1692 int connman_network_set_name(struct connman_network *network,
1695 DBG("network %p name %s", network, name);
1697 g_free(network->name);
1698 network->name = g_strdup(name);
1704 * connman_network_set_strength:
1705 * @network: network structure
1706 * @strength: strength value
1708 * Set signal strength value for network
1711 int connman_network_set_strength(struct connman_network *network,
1712 connman_uint8_t strength)
1714 DBG("network %p strengh %d", network, strength);
1716 network->strength = strength;
1721 connman_uint8_t connman_network_get_strength(struct connman_network *network)
1723 return network->strength;
1726 int connman_network_set_frequency(struct connman_network *network,
1727 connman_uint16_t frequency)
1729 DBG("network %p frequency %d", network, frequency);
1731 network->frequency = frequency;
1736 connman_uint16_t connman_network_get_frequency(struct connman_network *network)
1738 return network->frequency;
1741 int connman_network_set_wifi_channel(struct connman_network *network,
1742 connman_uint16_t channel)
1744 DBG("network %p wifi channel %d", network, channel);
1746 network->wifi.channel = channel;
1751 connman_uint16_t connman_network_get_wifi_channel(struct connman_network *network)
1753 return network->wifi.channel;
1757 * connman_network_set_string:
1758 * @network: network structure
1759 * @key: unique identifier
1760 * @value: string value
1762 * Set string value for specific key
1764 int connman_network_set_string(struct connman_network *network,
1765 const char *key, const char *value)
1767 DBG("network %p key %s value %s", network, key, value);
1769 if (g_strcmp0(key, "Name") == 0)
1770 return connman_network_set_name(network, value);
1772 if (g_str_equal(key, "Path") == TRUE) {
1773 g_free(network->path);
1774 network->path = g_strdup(value);
1775 } else if (g_str_equal(key, "Node") == TRUE) {
1776 g_free(network->node);
1777 network->node = g_strdup(value);
1778 } else if (g_str_equal(key, "WiFi.Mode") == TRUE) {
1779 g_free(network->wifi.mode);
1780 network->wifi.mode = g_strdup(value);
1781 } else if (g_str_equal(key, "WiFi.Security") == TRUE) {
1782 g_free(network->wifi.security);
1783 network->wifi.security = g_strdup(value);
1784 } else if (g_str_equal(key, "WiFi.Passphrase") == TRUE) {
1785 g_free(network->wifi.passphrase);
1786 network->wifi.passphrase = g_strdup(value);
1787 } else if (g_str_equal(key, "WiFi.AgentPassphrase") == TRUE) {
1788 g_free(network->wifi.agent_passphrase);
1789 network->wifi.agent_passphrase = g_strdup(value);
1790 } else if (g_str_equal(key, "WiFi.EAP") == TRUE) {
1791 g_free(network->wifi.eap);
1792 network->wifi.eap = g_strdup(value);
1793 } else if (g_str_equal(key, "WiFi.Identity") == TRUE) {
1794 g_free(network->wifi.identity);
1795 network->wifi.identity = g_strdup(value);
1796 } else if (g_str_equal(key, "WiFi.AgentIdentity") == TRUE) {
1797 g_free(network->wifi.agent_identity);
1798 network->wifi.agent_identity = g_strdup(value);
1799 } else if (g_str_equal(key, "WiFi.CACertFile") == TRUE) {
1800 g_free(network->wifi.ca_cert_path);
1801 network->wifi.ca_cert_path = g_strdup(value);
1802 } else if (g_str_equal(key, "WiFi.ClientCertFile") == TRUE) {
1803 g_free(network->wifi.client_cert_path);
1804 network->wifi.client_cert_path = g_strdup(value);
1805 } else if (g_str_equal(key, "WiFi.PrivateKeyFile") == TRUE) {
1806 g_free(network->wifi.private_key_path);
1807 network->wifi.private_key_path = g_strdup(value);
1808 } else if (g_str_equal(key, "WiFi.PrivateKeyPassphrase") == TRUE) {
1809 g_free(network->wifi.private_key_passphrase);
1810 network->wifi.private_key_passphrase = g_strdup(value);
1811 } else if (g_str_equal(key, "WiFi.Phase2") == TRUE) {
1812 g_free(network->wifi.phase2_auth);
1813 network->wifi.phase2_auth = g_strdup(value);
1814 } else if (g_str_equal(key, "WiFi.PinWPS") == TRUE) {
1815 g_free(network->wifi.pin_wps);
1816 network->wifi.pin_wps = g_strdup(value);
1825 * connman_network_get_string:
1826 * @network: network structure
1827 * @key: unique identifier
1829 * Get string value for specific key
1831 const char *connman_network_get_string(struct connman_network *network,
1834 DBG("network %p key %s", network, key);
1836 if (g_str_equal(key, "Path") == TRUE)
1837 return network->path;
1838 else if (g_str_equal(key, "Name") == TRUE)
1839 return network->name;
1840 else if (g_str_equal(key, "Node") == TRUE)
1841 return network->node;
1842 else if (g_str_equal(key, "WiFi.Mode") == TRUE)
1843 return network->wifi.mode;
1844 else if (g_str_equal(key, "WiFi.Security") == TRUE)
1845 return network->wifi.security;
1846 else if (g_str_equal(key, "WiFi.Passphrase") == TRUE)
1847 return network->wifi.passphrase;
1848 else if (g_str_equal(key, "WiFi.AgentPassphrase") == TRUE)
1849 return network->wifi.agent_passphrase;
1850 else if (g_str_equal(key, "WiFi.EAP") == TRUE)
1851 return network->wifi.eap;
1852 else if (g_str_equal(key, "WiFi.Identity") == TRUE)
1853 return network->wifi.identity;
1854 else if (g_str_equal(key, "WiFi.AgentIdentity") == TRUE)
1855 return network->wifi.agent_identity;
1856 else if (g_str_equal(key, "WiFi.CACertFile") == TRUE)
1857 return network->wifi.ca_cert_path;
1858 else if (g_str_equal(key, "WiFi.ClientCertFile") == TRUE)
1859 return network->wifi.client_cert_path;
1860 else if (g_str_equal(key, "WiFi.PrivateKeyFile") == TRUE)
1861 return network->wifi.private_key_path;
1862 else if (g_str_equal(key, "WiFi.PrivateKeyPassphrase") == TRUE)
1863 return network->wifi.private_key_passphrase;
1864 else if (g_str_equal(key, "WiFi.Phase2") == TRUE)
1865 return network->wifi.phase2_auth;
1866 else if (g_str_equal(key, "WiFi.PinWPS") == TRUE)
1867 return network->wifi.pin_wps;
1873 * connman_network_set_bool:
1874 * @network: network structure
1875 * @key: unique identifier
1876 * @value: boolean value
1878 * Set boolean value for specific key
1880 int connman_network_set_bool(struct connman_network *network,
1881 const char *key, connman_bool_t value)
1883 DBG("network %p key %s value %d", network, key, value);
1885 if (g_strcmp0(key, "Roaming") == 0)
1886 network->roaming = value;
1887 else if (g_strcmp0(key, "WiFi.WPS") == 0)
1888 network->wifi.wps = value;
1889 else if (g_strcmp0(key, "WiFi.UseWPS") == 0)
1890 network->wifi.use_wps = value;
1896 * connman_network_get_bool:
1897 * @network: network structure
1898 * @key: unique identifier
1900 * Get boolean value for specific key
1902 connman_bool_t connman_network_get_bool(struct connman_network *network,
1905 DBG("network %p key %s", network, key);
1907 if (g_str_equal(key, "Roaming") == TRUE)
1908 return network->roaming;
1909 else if (g_str_equal(key, "WiFi.WPS") == TRUE)
1910 return network->wifi.wps;
1911 else if (g_str_equal(key, "WiFi.UseWPS") == TRUE)
1912 return network->wifi.use_wps;
1918 * connman_network_set_blob:
1919 * @network: network structure
1920 * @key: unique identifier
1924 * Set binary blob value for specific key
1926 int connman_network_set_blob(struct connman_network *network,
1927 const char *key, const void *data, unsigned int size)
1929 DBG("network %p key %s size %d", network, key, size);
1931 if (g_str_equal(key, "WiFi.SSID") == TRUE) {
1932 g_free(network->wifi.ssid);
1933 network->wifi.ssid = g_try_malloc(size);
1934 if (network->wifi.ssid != NULL) {
1935 memcpy(network->wifi.ssid, data, size);
1936 network->wifi.ssid_len = size;
1938 network->wifi.ssid_len = 0;
1947 * connman_network_get_blob:
1948 * @network: network structure
1949 * @key: unique identifier
1950 * @size: pointer to blob size
1952 * Get binary blob value for specific key
1954 const void *connman_network_get_blob(struct connman_network *network,
1955 const char *key, unsigned int *size)
1957 DBG("network %p key %s", network, key);
1959 if (g_str_equal(key, "WiFi.SSID") == TRUE) {
1961 *size = network->wifi.ssid_len;
1962 return network->wifi.ssid;
1968 void __connman_network_set_device(struct connman_network *network,
1969 struct connman_device *device)
1971 if (network->device == device)
1974 if (network->device != NULL)
1975 network_remove(network);
1977 network->device = device;
1979 if (network->device != NULL)
1980 network_probe(network);
1984 * connman_network_get_device:
1985 * @network: network structure
1987 * Get parent device of network
1989 struct connman_device *connman_network_get_device(struct connman_network *network)
1991 return network->device;
1995 * connman_network_get_data:
1996 * @network: network structure
1998 * Get private network data pointer
2000 void *connman_network_get_data(struct connman_network *network)
2002 return network->driver_data;
2006 * connman_network_set_data:
2007 * @network: network structure
2008 * @data: data pointer
2010 * Set private network data pointer
2012 void connman_network_set_data(struct connman_network *network, void *data)
2014 network->driver_data = data;
2017 void connman_network_update(struct connman_network *network)
2019 switch (network->type) {
2020 case CONNMAN_NETWORK_TYPE_UNKNOWN:
2021 case CONNMAN_NETWORK_TYPE_VENDOR:
2023 case CONNMAN_NETWORK_TYPE_ETHERNET:
2024 case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
2025 case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
2026 case CONNMAN_NETWORK_TYPE_CELLULAR:
2027 case CONNMAN_NETWORK_TYPE_WIFI:
2028 case CONNMAN_NETWORK_TYPE_WIMAX:
2032 if (network->group != NULL)
2033 __connman_service_update_from_network(network);
2036 int __connman_network_init(void)
2043 void __connman_network_cleanup(void)