5 * Copyright (C) 2007-2013 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 #include <sys/inotify.h>
36 #include <connman/provision.h>
37 #include <connman/ipaddress.h>
40 struct connman_config_service {
45 unsigned int ssid_len;
48 char *anonymous_identity;
51 char *altsubject_match;
52 char *domain_suffix_match;
54 char *client_cert_file;
55 char *private_key_file;
56 char *private_key_passphrase;
57 char *private_key_passphrase_type;
60 enum connman_service_security security;
61 GSList *service_identifiers;
62 char *config_ident; /* file prefix */
63 char *config_entry; /* entry name */
71 unsigned char ipv6_prefix_length;
77 char **search_domains;
87 struct connman_config {
91 GHashTable *service_table;
94 static GHashTable *config_table = NULL;
96 static bool cleanup = false;
98 /* Definition of possible strings in the .config files */
99 #define CONFIG_KEY_NAME "Name"
100 #define CONFIG_KEY_DESC "Description"
102 #define SERVICE_KEY_TYPE "Type"
103 #define SERVICE_KEY_NAME "Name"
104 #define SERVICE_KEY_SSID "SSID"
105 #define SERVICE_KEY_EAP "EAP"
106 #define SERVICE_KEY_CA_CERT "CACertFile"
107 #define SERVICE_KEY_CL_CERT "ClientCertFile"
108 #define SERVICE_KEY_PRV_KEY "PrivateKeyFile"
109 #define SERVICE_KEY_PRV_KEY_PASS "PrivateKeyPassphrase"
110 #define SERVICE_KEY_PRV_KEY_PASS_TYPE "PrivateKeyPassphraseType"
111 #define SERVICE_KEY_IDENTITY "Identity"
112 #define SERVICE_KEY_ANONYMOUS_IDENTITY "AnonymousIdentity"
113 #define SERVICE_KEY_SUBJECT_MATCH "SubjectMatch"
114 #define SERVICE_KEY_ALT_SUBJECT_MATCH "AltSubjectMatch"
115 #define SERVICE_KEY_DOMAIN_SUFF_MATCH "DomainSuffixMatch"
116 #define SERVICE_KEY_DOMAIN_MATCH "DomainMatch"
117 #define SERVICE_KEY_PHASE2 "Phase2"
118 #define SERVICE_KEY_PASSPHRASE "Passphrase"
119 #define SERVICE_KEY_SECURITY "Security"
120 #define SERVICE_KEY_HIDDEN "Hidden"
121 #define SERVICE_KEY_MDNS "mDNS"
123 #define SERVICE_KEY_IPv4 "IPv4"
124 #define SERVICE_KEY_IPv6 "IPv6"
125 #define SERVICE_KEY_IPv6_PRIVACY "IPv6.Privacy"
126 #define SERVICE_KEY_MAC "MAC"
127 #define SERVICE_KEY_NAMESERVERS "Nameservers"
128 #define SERVICE_KEY_SEARCH_DOMAINS "SearchDomains"
129 #define SERVICE_KEY_TIMESERVERS "Timeservers"
130 #define SERVICE_KEY_DOMAIN "Domain"
131 #if defined TIZEN_EXT
132 #define SERVICE_KEY_CONNECTOR "Connector"
133 #define SERVICE_KEY_C_SIGN_KEY "CSignKey"
134 #define SERVICE_KEY_NET_ACCESS_KEY "NetAccessKey"
137 static const char *config_possible_keys[] = {
143 static const char *service_possible_keys[] = {
151 SERVICE_KEY_PRV_KEY_PASS,
152 SERVICE_KEY_PRV_KEY_PASS_TYPE,
153 SERVICE_KEY_IDENTITY,
154 SERVICE_KEY_ANONYMOUS_IDENTITY,
155 SERVICE_KEY_SUBJECT_MATCH,
156 SERVICE_KEY_ALT_SUBJECT_MATCH,
157 SERVICE_KEY_DOMAIN_SUFF_MATCH,
158 SERVICE_KEY_DOMAIN_MATCH,
160 SERVICE_KEY_PASSPHRASE,
161 SERVICE_KEY_SECURITY,
165 SERVICE_KEY_IPv6_PRIVACY,
168 SERVICE_KEY_NAMESERVERS,
169 SERVICE_KEY_SEARCH_DOMAINS,
170 SERVICE_KEY_TIMESERVERS,
172 #if defined TIZEN_EXT
173 SERVICE_KEY_CONNECTOR,
174 SERVICE_KEY_C_SIGN_KEY,
175 SERVICE_KEY_NET_ACCESS_KEY,
180 static void unregister_config(gpointer data)
182 struct connman_config *config = data;
184 connman_info("Removing configuration %s", config->ident);
186 g_hash_table_destroy(config->service_table);
188 g_free(config->description);
189 g_free(config->name);
190 g_free(config->ident);
194 static void unregister_service(gpointer data)
196 struct connman_config_service *config_service = data;
197 struct connman_service *service;
204 connman_info("Removing service configuration %s",
205 config_service->ident);
207 if (config_service->virtual)
210 for (list = config_service->service_identifiers; list;
212 service_id = list->data;
214 service = connman_service_lookup_from_identifier(service_id);
216 __connman_service_set_immutable(service, false);
217 __connman_service_set_config(service, NULL, NULL);
218 __connman_service_remove(service);
221 * Ethernet or gadget service cannot be removed by
222 * __connman_service_remove() so reset the ipconfig
225 if (connman_service_get_type(service) ==
226 CONNMAN_SERVICE_TYPE_ETHERNET ||
227 connman_service_get_type(service) ==
228 CONNMAN_SERVICE_TYPE_GADGET) {
229 __connman_service_disconnect(service);
230 __connman_service_reset_ipconfig(service,
231 CONNMAN_IPCONFIG_TYPE_IPV4, NULL, NULL);
232 __connman_service_reset_ipconfig(service,
233 CONNMAN_IPCONFIG_TYPE_IPV6, NULL, NULL);
234 __connman_service_set_ignore(service, true);
237 * After these operations, user needs to
238 * reconnect ethernet cable to get IP
244 if (!__connman_storage_remove_service(service_id))
245 DBG("Could not remove all files for service %s",
250 g_free(config_service->ident);
251 g_free(config_service->type);
252 g_free(config_service->name);
253 g_free(config_service->ssid);
254 g_free(config_service->eap);
255 g_free(config_service->identity);
256 g_free(config_service->anonymous_identity);
257 g_free(config_service->ca_cert_file);
258 g_free(config_service->subject_match);
259 g_free(config_service->altsubject_match);
260 g_free(config_service->domain_suffix_match);
261 g_free(config_service->domain_match);
262 g_free(config_service->client_cert_file);
263 g_free(config_service->private_key_file);
264 g_free(config_service->private_key_passphrase);
265 g_free(config_service->private_key_passphrase_type);
266 g_free(config_service->phase2);
267 g_free(config_service->passphrase);
268 g_free(config_service->ipv4_address);
269 g_free(config_service->ipv4_gateway);
270 g_free(config_service->ipv4_netmask);
271 g_free(config_service->ipv6_address);
272 g_free(config_service->ipv6_gateway);
273 g_free(config_service->ipv6_privacy);
274 g_free(config_service->mac);
275 g_strfreev(config_service->nameservers);
276 g_strfreev(config_service->search_domains);
277 g_strfreev(config_service->timeservers);
278 g_free(config_service->domain_name);
279 g_slist_free_full(config_service->service_identifiers, g_free);
280 g_free(config_service->config_ident);
281 g_free(config_service->config_entry);
282 g_free(config_service->virtual_file);
283 #if defined TIZEN_EXT
284 g_free(config_service->connector);
285 g_free(config_service->c_sign_key);
286 g_free(config_service->net_access_key);
288 g_free(config_service);
291 static void check_keys(GKeyFile *keyfile, const char *group,
292 const char **possible_keys)
295 gsize nb_avail_keys, i, j;
297 avail_keys = g_key_file_get_keys(keyfile, group, &nb_avail_keys, NULL);
302 * For each key in the configuration file,
303 * verify it is understood by connman
305 for (i = 0 ; i < nb_avail_keys; i++) {
306 for (j = 0; possible_keys[j] ; j++)
307 if (g_strcmp0(avail_keys[i], possible_keys[j]) == 0)
310 if (!possible_keys[j])
311 connman_warn("Unknown configuration key %s in [%s]",
312 avail_keys[i], group);
315 g_strfreev(avail_keys);
318 static int check_family(const char *address, int expected_family)
323 family = connman_inet_check_ipaddress(address);
325 DBG("Cannot get address family of %s (%d/%s)", address,
326 family, gai_strerror(family));
333 if (expected_family != AF_INET) {
334 DBG("Wrong type address %s, expecting IPv4", address);
340 if (expected_family != AF_INET6) {
341 DBG("Wrong type address %s, expecting IPv6", address);
347 DBG("Unsupported address family %d", family);
356 static int parse_address(const char *address_str, int address_family,
357 char **address, char **netmask, char **gateway)
359 char *addr_str, *mask_str, *gw_str;
363 route = g_strsplit(address_str, "/", 0);
368 if (!addr_str || addr_str[0] == '\0') {
373 if ((err = check_family(addr_str, address_family)) < 0)
377 if (!mask_str || mask_str[0] == '\0') {
383 if (gw_str && gw_str[0]) {
384 if ((err = check_family(gw_str, address_family)) < 0)
389 *address = g_strdup(addr_str);
392 *netmask = g_strdup(mask_str);
395 *gateway = g_strdup(gw_str);
398 DBG("address %s/%s via %s", *address, *netmask, *gateway);
400 DBG("address %s/%s", *address, *netmask);
408 static bool check_address(char *address_str, char **address)
410 if (g_ascii_strcasecmp(address_str, "auto") == 0 ||
411 g_ascii_strcasecmp(address_str, "dhcp") == 0 ||
412 g_ascii_strcasecmp(address_str, "off") == 0) {
413 *address = address_str;
420 static bool load_service_generic(GKeyFile *keyfile,
421 const char *group, struct connman_config *config,
422 struct connman_config_service *service)
428 str = __connman_config_get_string(keyfile, group, SERVICE_KEY_IPv4, NULL);
429 if (str && check_address(str, &service->ipv4_address)) {
432 if (parse_address(str, AF_INET, &service->ipv4_address,
433 &mask, &service->ipv4_gateway) < 0) {
434 connman_warn("Invalid format for IPv4 address %s",
440 if (!g_strrstr(mask, ".")) {
441 /* We have netmask length */
443 struct in_addr netmask_in;
444 unsigned char prefix_len = 32;
446 long int value = strtol(mask, &ptr, 10);
448 if (ptr != mask && *ptr == '\0' && value && value <= 32)
451 addr = 0xffffffff << (32 - prefix_len);
452 netmask_in.s_addr = htonl(addr);
453 service->ipv4_netmask =
454 g_strdup(inet_ntoa(netmask_in));
458 service->ipv4_netmask = mask;
463 str = __connman_config_get_string(keyfile, group, SERVICE_KEY_IPv6, NULL);
464 if (str && check_address(str, &service->ipv6_address)) {
470 if (parse_address(str, AF_INET6, &service->ipv6_address,
471 &mask, &service->ipv6_gateway) < 0) {
472 connman_warn("Invalid format for IPv6 address %s",
478 value = strtol(mask, &ptr, 10);
479 if (ptr != mask && *ptr == '\0' && value <= 128)
480 service->ipv6_prefix_length = value;
482 service->ipv6_prefix_length = 128;
488 str = __connman_config_get_string(keyfile, group, SERVICE_KEY_IPv6_PRIVACY,
491 g_free(service->ipv6_privacy);
492 service->ipv6_privacy = str;
495 str = __connman_config_get_string(keyfile, group, SERVICE_KEY_MAC, NULL);
497 g_free(service->mac);
501 str = __connman_config_get_string(keyfile, group, SERVICE_KEY_DOMAIN, NULL);
503 g_free(service->domain_name);
504 service->domain_name = str;
507 strlist = __connman_config_get_string_list(keyfile, group,
508 SERVICE_KEY_NAMESERVERS,
512 g_strfreev(service->nameservers);
513 service->nameservers = strlist;
518 strlist = __connman_config_get_string_list(keyfile, group,
519 SERVICE_KEY_SEARCH_DOMAINS,
523 g_strfreev(service->search_domains);
524 service->search_domains = strlist;
529 strlist = __connman_config_get_string_list(keyfile, group,
530 SERVICE_KEY_TIMESERVERS,
534 g_strfreev(service->timeservers);
535 service->timeservers = strlist;
540 service->mdns = __connman_config_get_bool(keyfile, group,
541 SERVICE_KEY_MDNS, NULL);
546 g_free(service->ident);
547 g_free(service->type);
548 g_free(service->ipv4_address);
549 g_free(service->ipv4_netmask);
550 g_free(service->ipv4_gateway);
551 g_free(service->ipv6_address);
552 g_free(service->ipv6_gateway);
553 g_free(service->mac);
559 static bool load_service(GKeyFile *keyfile, const char *group,
560 struct connman_config *config)
562 struct connman_config_service *service;
564 char *str, *hex_ssid;
565 enum connman_service_security security;
566 bool service_created = false;
568 /* Strip off "service_" prefix */
571 if (strlen(ident) < 1)
574 /* Verify that provided keys are good */
575 check_keys(keyfile, group, service_possible_keys);
577 service = g_hash_table_lookup(config->service_table, ident);
579 service = g_try_new0(struct connman_config_service, 1);
583 service->ident = g_strdup(ident);
585 service_created = true;
588 str = __connman_config_get_string(keyfile, group, SERVICE_KEY_TYPE, NULL);
590 g_free(service->type);
593 connman_warn("Type of the configured service is missing "
594 "for group %s", group);
598 if (!load_service_generic(keyfile, group, config, service))
601 if (g_strcmp0(str, "ethernet") == 0) {
602 service->config_ident = g_strdup(config->ident);
603 service->config_entry = g_strdup_printf("service_%s",
606 g_hash_table_insert(config->service_table, service->ident,
611 str = __connman_config_get_string(keyfile, group, SERVICE_KEY_NAME, NULL);
613 g_free(service->name);
617 hex_ssid = __connman_config_get_string(keyfile, group, SERVICE_KEY_SSID,
621 unsigned int i, j = 0, hex;
622 size_t hex_ssid_len = strlen(hex_ssid);
624 ssid = g_try_malloc0(hex_ssid_len / 2);
630 for (i = 0; i < hex_ssid_len; i += 2) {
631 if (sscanf(hex_ssid + i, "%02x", &hex) <= 0) {
632 connman_warn("Invalid SSID %s", hex_ssid);
642 g_free(service->ssid);
643 service->ssid = ssid;
644 service->ssid_len = hex_ssid_len / 2;
645 } else if (service->name) {
647 unsigned int ssid_len;
649 ssid_len = strlen(service->name);
650 ssid = g_try_malloc0(ssid_len);
654 memcpy(ssid, service->name, ssid_len);
655 g_free(service->ssid);
656 service->ssid = ssid;
657 service->ssid_len = ssid_len;
660 str = __connman_config_get_string(keyfile, group, SERVICE_KEY_EAP, NULL);
662 g_free(service->eap);
666 str = __connman_config_get_string(keyfile, group, SERVICE_KEY_CA_CERT, NULL);
668 g_free(service->ca_cert_file);
669 service->ca_cert_file = str;
672 str = __connman_config_get_string(keyfile, group, SERVICE_KEY_CL_CERT, NULL);
674 g_free(service->client_cert_file);
675 service->client_cert_file = str;
678 str = __connman_config_get_string(keyfile, group, SERVICE_KEY_PRV_KEY, NULL);
680 g_free(service->private_key_file);
681 service->private_key_file = str;
684 str = __connman_config_get_string(keyfile, group,
685 SERVICE_KEY_PRV_KEY_PASS, NULL);
687 g_free(service->private_key_passphrase);
688 service->private_key_passphrase = str;
691 str = __connman_config_get_string(keyfile, group,
692 SERVICE_KEY_PRV_KEY_PASS_TYPE, NULL);
694 g_free(service->private_key_passphrase_type);
695 service->private_key_passphrase_type = str;
698 str = __connman_config_get_string(keyfile, group, SERVICE_KEY_IDENTITY, NULL);
700 g_free(service->identity);
701 service->identity = str;
704 str = __connman_config_get_string(keyfile, group,
705 SERVICE_KEY_ANONYMOUS_IDENTITY, NULL);
707 g_free(service->anonymous_identity);
708 service->anonymous_identity = str;
711 str = __connman_config_get_string(keyfile, group,
712 SERVICE_KEY_SUBJECT_MATCH, NULL);
714 g_free(service->subject_match);
715 service->subject_match = str;
718 str = __connman_config_get_string(keyfile, group,
719 SERVICE_KEY_ALT_SUBJECT_MATCH, NULL);
721 g_free(service->altsubject_match);
722 service->altsubject_match = str;
725 str = __connman_config_get_string(keyfile, group,
726 SERVICE_KEY_DOMAIN_SUFF_MATCH, NULL);
728 g_free(service->domain_suffix_match);
729 service->domain_suffix_match = str;
732 str = __connman_config_get_string(keyfile, group,
733 SERVICE_KEY_DOMAIN_MATCH, NULL);
735 g_free(service->domain_match);
736 service->domain_match = str;
739 str = __connman_config_get_string(keyfile, group, SERVICE_KEY_PHASE2, NULL);
741 g_free(service->phase2);
742 service->phase2 = str;
745 str = __connman_config_get_string(keyfile, group, SERVICE_KEY_PASSPHRASE,
748 g_free(service->passphrase);
749 service->passphrase = str;
751 #if defined TIZEN_EXT
753 str = __connman_config_get_string(keyfile, group, SERVICE_KEY_CONNECTOR,
756 g_free(service->connector);
757 service->connector = str;
760 str = __connman_config_get_string(keyfile, group, SERVICE_KEY_C_SIGN_KEY,
763 g_free(service->c_sign_key);
764 service->c_sign_key = str;
767 str = __connman_config_get_string(keyfile, group, SERVICE_KEY_NET_ACCESS_KEY,
770 g_free(service->net_access_key);
771 service->net_access_key = str;
775 str = __connman_config_get_string(keyfile, group, SERVICE_KEY_SECURITY,
777 security = __connman_service_string2security(str);
781 if (str && security != CONNMAN_SERVICE_SECURITY_8021X)
782 connman_info("Mismatch between EAP configuration and "
784 SERVICE_KEY_SECURITY, str);
786 service->security = CONNMAN_SERVICE_SECURITY_8021X;
788 } else if (service->passphrase) {
791 if (security == CONNMAN_SERVICE_SECURITY_PSK ||
792 #if defined TIZEN_EXT
793 security == CONNMAN_SERVICE_SECURITY_RSN ||
794 security == CONNMAN_SERVICE_SECURITY_SAE ||
796 security == CONNMAN_SERVICE_SECURITY_WEP) {
797 service->security = security;
799 connman_info("Mismatch with passphrase and "
801 SERVICE_KEY_SECURITY, str);
804 CONNMAN_SERVICE_SECURITY_PSK;
808 service->security = CONNMAN_SERVICE_SECURITY_PSK;
809 #if defined TIZEN_EXT
810 } else if (service->connector) {
812 if (str && security != CONNMAN_SERVICE_SECURITY_DPP)
813 connman_info("Mismatch between DPP configuration and "
815 SERVICE_KEY_SECURITY, str);
817 service->security = CONNMAN_SERVICE_SECURITY_DPP;
821 if (security != CONNMAN_SERVICE_SECURITY_NONE)
822 connman_info("Mismatch no security and "
824 SERVICE_KEY_SECURITY, str);
826 service->security = CONNMAN_SERVICE_SECURITY_NONE;
828 service->security = CONNMAN_SERVICE_SECURITY_NONE;
832 service->config_ident = g_strdup(config->ident);
833 service->config_entry = g_strdup_printf("service_%s", service->ident);
835 service->hidden = __connman_config_get_bool(keyfile, group,
836 SERVICE_KEY_HIDDEN, NULL);
839 g_hash_table_insert(config->service_table, service->ident,
842 connman_info("Adding service configuration %s", service->ident);
847 if (service_created) {
848 g_free(service->ident);
849 g_free(service->type);
850 g_free(service->name);
851 g_free(service->ssid);
858 static bool load_service_from_keyfile(GKeyFile *keyfile,
859 struct connman_config *config)
865 groups = g_key_file_get_groups(keyfile, NULL);
867 for (i = 0; groups[i]; i++) {
868 if (!g_str_has_prefix(groups[i], "service_")) {
869 connman_warn("Ignore group named '%s' because prefix "
870 "is not 'service_'", groups[i]);
873 if (load_service(keyfile, groups[i], config))
882 static int load_config(struct connman_config *config)
887 DBG("config %p", config);
889 keyfile = __connman_storage_load_config(config->ident);
893 g_key_file_set_list_separator(keyfile, ',');
895 /* Verify keys validity of the global section */
896 check_keys(keyfile, "global", config_possible_keys);
898 str = __connman_config_get_string(keyfile, "global", CONFIG_KEY_NAME, NULL);
900 g_free(config->name);
904 str = __connman_config_get_string(keyfile, "global", CONFIG_KEY_DESC, NULL);
906 g_free(config->description);
907 config->description = str;
910 if (!load_service_from_keyfile(keyfile, config))
911 connman_warn("Config file %s/%s.config does not contain any "
912 "configuration that can be provisioned!",
913 STORAGEDIR, config->ident);
915 g_key_file_free(keyfile);
920 static struct connman_config *create_config(const char *ident)
922 struct connman_config *config;
924 DBG("ident %s", ident);
926 if (g_hash_table_lookup(config_table, ident))
929 config = g_try_new0(struct connman_config, 1);
933 config->ident = g_strdup(ident);
935 config->service_table = g_hash_table_new_full(g_str_hash, g_str_equal,
936 NULL, unregister_service);
938 g_hash_table_insert(config_table, config->ident, config);
940 connman_info("Adding configuration %s", config->ident);
945 static bool validate_ident(const char *ident)
952 for (i = 0; i < strlen(ident); i++)
953 if (!g_ascii_isprint(ident[i]))
959 static int read_configs(void)
965 dir = g_dir_open(STORAGEDIR, 0, NULL);
969 while ((file = g_dir_read_name(dir))) {
973 if (!g_str_has_suffix(file, ".config"))
976 ident = g_strrstr(file, ".config");
980 str = g_string_new_len(file, ident - file);
984 ident = g_string_free(str, FALSE);
986 if (validate_ident(ident)) {
987 struct connman_config *config;
989 config = create_config(ident);
993 connman_error("Invalid config ident %s", ident);
1004 static void config_notify_handler(struct inotify_event *event,
1012 if (!g_str_has_suffix(ident, ".config"))
1015 ext = g_strrstr(ident, ".config");
1021 if (!validate_ident(ident)) {
1022 connman_error("Invalid config ident %s", ident);
1026 if (event->mask & (IN_CREATE | IN_MOVED_TO))
1027 create_config(ident);
1029 if (event->mask & (IN_MODIFY | IN_MOVED_TO)) {
1030 struct connman_config *config;
1032 config = g_hash_table_lookup(config_table, ident);
1036 g_hash_table_remove_all(config->service_table);
1037 load_config(config);
1038 ret = __connman_service_provision_changed(ident);
1041 * Re-scan the config file for any
1044 g_hash_table_remove_all(config->service_table);
1045 load_config(config);
1046 __connman_service_provision_changed(ident);
1051 if (event->mask & (IN_DELETE | IN_MOVED_FROM))
1052 g_hash_table_remove(config_table, ident);
1055 int __connman_config_init(void)
1059 config_table = g_hash_table_new_full(g_str_hash, g_str_equal,
1060 NULL, unregister_config);
1062 connman_inotify_register(STORAGEDIR, config_notify_handler);
1064 return read_configs();
1067 void __connman_config_cleanup(void)
1073 connman_inotify_unregister(STORAGEDIR, config_notify_handler);
1075 g_hash_table_destroy(config_table);
1076 config_table = NULL;
1081 char *__connman_config_get_string(GKeyFile *key_file,
1082 const char *group_name, const char *key, GError **error)
1084 char *str = g_key_file_get_string(key_file, group_name, key, error);
1088 /* passphrases can have spaces in the end */
1089 if (!g_strcmp0(key, SERVICE_KEY_PASSPHRASE) ||
1090 !g_strcmp0(key, SERVICE_KEY_PRV_KEY_PASS))
1093 return g_strchomp(str);
1096 char **__connman_config_get_string_list(GKeyFile *key_file,
1097 const char *group_name, const char *key, gsize *length, GError **error)
1100 char **strlist = g_key_file_get_string_list(key_file, group_name, key,
1107 *p = g_strstrip(*p);
1114 bool __connman_config_get_bool(GKeyFile *key_file,
1115 const char *group_name, const char *key, GError **error)
1120 valstr = g_key_file_get_value(key_file, group_name, key, error);
1124 valstr = g_strchomp(valstr);
1125 if (strcmp(valstr, "true") == 0 || strcmp(valstr, "1") == 0)
1133 static char *config_pem_fsid(const char *pem_file)
1136 unsigned *fsid = (unsigned *) &buf.f_fsid;
1137 unsigned long long fsid64;
1142 if (statfs(pem_file, &buf) < 0) {
1143 connman_error("statfs error %s for %s",
1144 strerror(errno), pem_file);
1148 fsid64 = ((unsigned long long) fsid[0] << 32) | fsid[1];
1150 return g_strdup_printf("%llx", fsid64);
1153 static void provision_service_wifi(struct connman_config_service *config,
1154 struct connman_service *service,
1155 struct connman_network *network,
1156 const void *ssid, unsigned int ssid_len)
1159 __connman_service_set_string(service, "EAP", config->eap);
1161 if (config->identity)
1162 __connman_service_set_string(service, "Identity",
1165 if (config->anonymous_identity)
1166 __connman_service_set_string(service, "AnonymousIdentity",
1167 config->anonymous_identity);
1169 if (config->ca_cert_file)
1170 __connman_service_set_string(service, "CACertFile",
1171 config->ca_cert_file);
1173 if (config->subject_match)
1174 __connman_service_set_string(service, "SubjectMatch",
1175 config->subject_match);
1177 if (config->altsubject_match)
1178 __connman_service_set_string(service, "AltSubjectMatch",
1179 config->altsubject_match);
1181 if (config->domain_suffix_match)
1182 __connman_service_set_string(service, "DomainSuffixMatch",
1183 config->domain_suffix_match);
1185 if (config->domain_match)
1186 __connman_service_set_string(service, "DomainMatch",
1187 config->domain_match);
1189 if (config->client_cert_file)
1190 __connman_service_set_string(service, "ClientCertFile",
1191 config->client_cert_file);
1193 if (config->private_key_file)
1194 __connman_service_set_string(service, "PrivateKeyFile",
1195 config->private_key_file);
1197 if (g_strcmp0(config->private_key_passphrase_type, "fsid") == 0 &&
1198 config->private_key_file) {
1201 fsid = config_pem_fsid(config->private_key_file);
1205 g_free(config->private_key_passphrase);
1206 config->private_key_passphrase = fsid;
1209 if (config->private_key_passphrase) {
1210 __connman_service_set_string(service, "PrivateKeyPassphrase",
1211 config->private_key_passphrase);
1213 * TODO: Support for PEAP with both identity and key passwd.
1214 * In that case, we should check if both of them are found
1215 * from the config file. If not, we should not set the
1216 * service passphrase in order for the UI to request for an
1217 * additional passphrase.
1222 __connman_service_set_string(service, "Phase2", config->phase2);
1223 #if defined TIZEN_EXT
1225 __connman_service_set_string(service, "Phase2", NULL);
1228 if (config->passphrase)
1229 __connman_service_set_string(service, "Passphrase",
1230 config->passphrase);
1233 __connman_service_set_hidden(service);
1235 #if defined TIZEN_EXT
1236 if (config->connector)
1237 __connman_service_set_string(service, "Connector",
1239 if (config->c_sign_key)
1240 __connman_service_set_string(service, "CSignKey",
1241 config->c_sign_key);
1242 if (config->net_access_key)
1243 __connman_service_set_string(service, "NetAccessKey",
1244 config->net_access_key);
1248 struct connect_virtual {
1249 struct connman_service *service;
1253 static gboolean remove_virtual_config(gpointer user_data)
1255 struct connect_virtual *virtual = user_data;
1257 __connman_service_connect(virtual->service,
1258 CONNMAN_SERVICE_CONNECT_REASON_AUTO);
1259 g_hash_table_remove(config_table, virtual->vfile);
1266 #if defined TIZEN_EXT
1267 static bool __check_address_type(int address_family, const char *address)
1269 unsigned char buf[sizeof(struct in6_addr)] = {0, };
1272 err = inet_pton(address_family, address, buf);
1280 static int try_provision_service(struct connman_config_service *config,
1281 struct connman_service *service)
1283 struct connman_network *network;
1284 const void *service_id;
1285 enum connman_service_type type;
1287 unsigned int ssid_len;
1290 network = __connman_service_get_network(service);
1292 connman_error("Service has no network set");
1296 DBG("network %p ident %s", network,
1297 connman_network_get_identifier(network));
1299 type = connman_service_get_type(service);
1302 case CONNMAN_SERVICE_TYPE_WIFI:
1303 if (__connman_service_string2type(config->type) != type)
1306 ssid = connman_network_get_blob(network, "WiFi.SSID",
1311 if (!config->ssid || ssid_len != config->ssid_len)
1314 if (memcmp(config->ssid, ssid, ssid_len))
1317 str = connman_network_get_string(network, "WiFi.Security");
1318 if (config->security != __connman_service_string2security(str))
1323 case CONNMAN_SERVICE_TYPE_ETHERNET:
1324 case CONNMAN_SERVICE_TYPE_GADGET:
1326 if (__connman_service_string2type(config->type) != type)
1331 case CONNMAN_SERVICE_TYPE_UNKNOWN:
1332 case CONNMAN_SERVICE_TYPE_SYSTEM:
1333 case CONNMAN_SERVICE_TYPE_BLUETOOTH:
1334 case CONNMAN_SERVICE_TYPE_CELLULAR:
1335 case CONNMAN_SERVICE_TYPE_GPS:
1336 case CONNMAN_SERVICE_TYPE_VPN:
1337 case CONNMAN_SERVICE_TYPE_P2P:
1338 #if defined TIZEN_EXT_WIFI_MESH
1339 case CONNMAN_SERVICE_TYPE_MESH:
1345 DBG("service %p ident %s", service,
1346 connman_service_get_identifier(service));
1349 struct connman_device *device;
1350 const char *device_addr;
1352 device = connman_network_get_device(network);
1354 connman_error("Network device is missing");
1358 device_addr = connman_device_get_string(device, "Address");
1360 DBG("wants %s has %s", config->mac, device_addr);
1362 if (g_ascii_strcasecmp(device_addr, config->mac) != 0)
1366 #if defined TIZEN_EXT
1367 struct connman_ipconfig *ip6config = __connman_service_get_ip6config(service);
1368 enum connman_ipconfig_method ipv6_method = __connman_ipconfig_get_method(ip6config);
1369 if (ipv6_method == CONNMAN_IPCONFIG_METHOD_MANUAL)
1372 if (!config->ipv6_address) {
1373 connman_network_set_ipv6_method(network,
1374 CONNMAN_IPCONFIG_METHOD_AUTO);
1375 } else if (g_ascii_strcasecmp(config->ipv6_address, "off") == 0) {
1376 connman_network_set_ipv6_method(network,
1377 CONNMAN_IPCONFIG_METHOD_OFF);
1378 } else if (g_ascii_strcasecmp(config->ipv6_address, "auto") == 0 ||
1379 g_ascii_strcasecmp(config->ipv6_address, "dhcp") == 0) {
1380 connman_network_set_ipv6_method(network,
1381 CONNMAN_IPCONFIG_METHOD_AUTO);
1383 struct connman_ipaddress *address;
1385 if (config->ipv6_prefix_length == 0) {
1386 DBG("IPv6 prefix missing");
1390 address = connman_ipaddress_alloc(AF_INET6);
1394 connman_ipaddress_set_ipv6(address, config->ipv6_address,
1395 config->ipv6_prefix_length,
1396 config->ipv6_gateway);
1398 connman_network_set_ipv6_method(network,
1399 CONNMAN_IPCONFIG_METHOD_FIXED);
1401 if (connman_network_set_ipaddress(network, address) < 0)
1402 DBG("Unable to set IPv6 address to network %p",
1405 connman_ipaddress_free(address);
1408 #if defined TIZEN_EXT
1411 if (config->ipv6_privacy) {
1412 struct connman_ipconfig *ipconfig;
1414 ipconfig = __connman_service_get_ip6config(service);
1416 __connman_ipconfig_ipv6_set_privacy(ipconfig,
1417 config->ipv6_privacy);
1420 #if defined TIZEN_EXT
1421 struct connman_ipconfig *ip4config = __connman_service_get_ip4config(service);
1422 enum connman_ipconfig_method ipv4_method = __connman_ipconfig_get_method(ip4config);
1423 if (ipv4_method == CONNMAN_IPCONFIG_METHOD_MANUAL)
1426 if (!config->ipv4_address) {
1427 connman_network_set_ipv4_method(network,
1428 CONNMAN_IPCONFIG_METHOD_DHCP);
1429 } else if (g_ascii_strcasecmp(config->ipv4_address, "off") == 0) {
1430 connman_network_set_ipv4_method(network,
1431 CONNMAN_IPCONFIG_METHOD_OFF);
1432 } else if (g_ascii_strcasecmp(config->ipv4_address, "auto") == 0 ||
1433 g_ascii_strcasecmp(config->ipv4_address, "dhcp") == 0) {
1434 connman_network_set_ipv4_method(network,
1435 CONNMAN_IPCONFIG_METHOD_DHCP);
1437 struct connman_ipaddress *address;
1439 if (!config->ipv4_netmask) {
1440 DBG("IPv4 netmask missing");
1444 address = connman_ipaddress_alloc(AF_INET);
1448 connman_ipaddress_set_ipv4(address, config->ipv4_address,
1449 config->ipv4_netmask,
1450 config->ipv4_gateway);
1452 connman_network_set_ipv4_method(network,
1453 CONNMAN_IPCONFIG_METHOD_FIXED);
1455 if (connman_network_set_ipaddress(network, address) < 0)
1456 DBG("Unable to set IPv4 address to network %p",
1459 connman_ipaddress_free(address);
1462 #if defined TIZEN_EXT
1465 __connman_service_disconnect(service);
1467 service_id = connman_service_get_identifier(service);
1468 config->service_identifiers =
1469 g_slist_prepend(config->service_identifiers,
1470 g_strdup(service_id));
1472 __connman_service_set_favorite_delayed(service, true, true);
1474 __connman_service_set_config(service, config->config_ident,
1475 config->config_entry);
1477 if (config->domain_name)
1478 __connman_service_set_domainname(service, config->domain_name);
1480 if (config->nameservers) {
1483 __connman_service_nameserver_clear(service);
1485 for (i = 0; config->nameservers[i]; i++) {
1486 #if defined TIZEN_EXT
1487 if (__check_address_type(AF_INET, config->nameservers[i]))
1488 __connman_service_nameserver_append(service,
1489 config->nameservers[i], false,
1490 CONNMAN_IPCONFIG_TYPE_IPV4);
1491 else if (__check_address_type(AF_INET6, config->nameservers[i]))
1492 __connman_service_nameserver_append(service,
1493 config->nameservers[i], false,
1494 CONNMAN_IPCONFIG_TYPE_IPV6);
1496 __connman_service_nameserver_append(service,
1497 config->nameservers[i], false);
1502 if (config->search_domains)
1503 __connman_service_set_search_domains(service,
1504 config->search_domains);
1506 __connman_service_set_mdns(service, config->mdns);
1508 if (config->timeservers)
1509 __connman_service_set_timeservers(service,
1510 config->timeservers);
1512 if (type == CONNMAN_SERVICE_TYPE_WIFI) {
1513 provision_service_wifi(config, service, network,
1517 __connman_service_mark_dirty();
1519 __connman_service_load_modifiable(service);
1521 if (config->virtual) {
1522 struct connect_virtual *virtual;
1524 virtual = g_malloc0(sizeof(struct connect_virtual));
1525 virtual->service = service;
1526 virtual->vfile = config->virtual_file;
1528 g_idle_add(remove_virtual_config, virtual);
1533 #if !defined TIZEN_EXT
1534 __connman_service_set_immutable(service, true);
1537 if (type == CONNMAN_SERVICE_TYPE_ETHERNET ||
1538 type == CONNMAN_SERVICE_TYPE_GADGET) {
1539 __connman_service_connect(service,
1540 CONNMAN_SERVICE_CONNECT_REASON_AUTO);
1545 __connman_service_auto_connect(CONNMAN_SERVICE_CONNECT_REASON_AUTO);
1551 find_and_provision_service_from_config(struct connman_service *service,
1552 struct connman_config *config)
1554 GHashTableIter iter;
1555 gpointer value, key;
1557 g_hash_table_iter_init(&iter, config->service_table);
1558 while (g_hash_table_iter_next(&iter, &key,
1560 if (!try_provision_service(value, service))
1567 static int find_and_provision_service(struct connman_service *service)
1569 GHashTableIter iter;
1570 gpointer value, key;
1572 g_hash_table_iter_init(&iter, config_table);
1574 while (g_hash_table_iter_next(&iter, &key, &value)) {
1575 struct connman_config *config = value;
1577 if (!find_and_provision_service_from_config(service, config))
1584 int __connman_config_provision_service(struct connman_service *service)
1586 enum connman_service_type type;
1588 /* For now only WiFi, Gadget and Ethernet services are supported */
1589 type = connman_service_get_type(service);
1591 DBG("service %p type %d", service, type);
1593 if (type != CONNMAN_SERVICE_TYPE_WIFI &&
1594 type != CONNMAN_SERVICE_TYPE_ETHERNET &&
1595 type != CONNMAN_SERVICE_TYPE_GADGET)
1598 #if defined TIZEN_EXT
1599 if(type == CONNMAN_SERVICE_TYPE_WIFI &&
1600 __connman_service_get_security(service) ==
1601 CONNMAN_SERVICE_SECURITY_NONE)
1605 return find_and_provision_service(service);
1608 int __connman_config_provision_service_ident(struct connman_service *service,
1609 const char *ident, const char *file, const char *entry)
1611 enum connman_service_type type;
1612 struct connman_config *config;
1615 /* For now only WiFi, Gadget and Ethernet services are supported */
1616 type = connman_service_get_type(service);
1618 DBG("service %p type %d", service, type);
1620 if (type != CONNMAN_SERVICE_TYPE_WIFI &&
1621 type != CONNMAN_SERVICE_TYPE_ETHERNET &&
1622 type != CONNMAN_SERVICE_TYPE_GADGET)
1625 config = g_hash_table_lookup(config_table, ident);
1627 GHashTableIter iter;
1628 gpointer value, key;
1631 g_hash_table_iter_init(&iter, config->service_table);
1634 * Check if we need to remove individual service if it
1635 * is missing from config file.
1637 if (file && entry) {
1638 while (g_hash_table_iter_next(&iter, &key,
1640 struct connman_config_service *config_service;
1642 config_service = value;
1644 if (g_strcmp0(config_service->config_ident,
1648 if (g_strcmp0(config_service->config_entry,
1656 DBG("found %d ident %s file %s entry %s", found, ident,
1661 * The entry+8 will skip "service_" prefix
1663 g_hash_table_remove(config->service_table,
1669 find_and_provision_service_from_config(service, config);
1675 static void generate_random_string(char *str, int length)
1681 memset(str, '\0', length);
1683 for (i = 0; i < length-1; i++) {
1685 __connman_util_get_random(&rand);
1686 val = (uint8_t)(rand % 122);
1689 } while((val > 57 && val < 65) || (val > 90 && val < 97));
1695 int connman_config_provision_mutable_service(GKeyFile *keyfile)
1697 struct connman_config_service *service_config;
1698 struct connman_config *config;
1699 char *vfile, *group = NULL;
1704 generate_random_string(rstr, 11);
1706 vfile = g_strdup_printf("service_mutable_%s.config", rstr);
1708 config = create_config(vfile);
1712 if (!load_service_from_keyfile(keyfile, config))
1715 group = g_key_file_get_start_group(keyfile);
1717 service_config = g_hash_table_lookup(config->service_table, group+8);
1718 if (!service_config)
1721 /* Specific to non file based config: */
1722 g_free(service_config->config_ident);
1723 service_config->config_ident = NULL;
1724 g_free(service_config->config_entry);
1725 service_config->config_entry = NULL;
1727 service_config->virtual = true;
1728 service_config->virtual_file = vfile;
1730 __connman_service_provision_changed(vfile);
1732 if (g_strcmp0(service_config->type, "wifi") == 0)
1733 __connman_device_request_scan(CONNMAN_SERVICE_TYPE_WIFI);
1739 DBG("Could not proceed");
1740 g_hash_table_remove(config_table, vfile);
1746 struct connman_config_entry **connman_config_get_entries(const char *type)
1748 GHashTableIter iter_file, iter_config;
1749 gpointer value, key;
1750 struct connman_config_entry **entries = NULL;
1753 g_hash_table_iter_init(&iter_file, config_table);
1754 while (g_hash_table_iter_next(&iter_file, &key, &value)) {
1755 struct connman_config *config_file = value;
1756 struct connman_config_entry **tmp_entries = entries;
1758 count = g_hash_table_size(config_file->service_table);
1760 entries = g_try_realloc(entries, (i + count + 1) *
1761 sizeof(struct connman_config_entry *));
1763 g_free(tmp_entries);
1767 g_hash_table_iter_init(&iter_config,
1768 config_file->service_table);
1769 while (g_hash_table_iter_next(&iter_config, &key,
1771 struct connman_config_service *config = value;
1774 g_strcmp0(config->type, type) != 0)
1777 entries[i] = g_try_new0(struct connman_config_entry,
1782 entries[i]->ident = g_strdup(config->ident);
1783 entries[i]->name = g_strdup(config->name);
1784 entries[i]->ssid = g_try_malloc0(config->ssid_len + 1);
1785 if (!entries[i]->ssid)
1788 memcpy(entries[i]->ssid, config->ssid,
1790 entries[i]->ssid_len = config->ssid_len;
1791 entries[i]->hidden = config->hidden;
1798 struct connman_config_entry **tmp_entries = entries;
1800 entries = g_try_realloc(entries, (i + 1) *
1801 sizeof(struct connman_config_entry *));
1803 g_free(tmp_entries);
1809 DBG("%d provisioned AP found", i);
1815 connman_config_free_entries(entries);
1819 void connman_config_free_entries(struct connman_config_entry **entries)
1826 for (i = 0; entries[i]; i++) {
1827 g_free(entries[i]->ident);
1828 g_free(entries[i]->name);
1829 g_free(entries[i]->ssid);
1836 bool __connman_config_address_provisioned(const char *address,
1837 const char *netmask)
1839 GHashTableIter iter, siter;
1840 gpointer value, key, svalue, skey;
1842 if (!address || !netmask)
1845 g_hash_table_iter_init(&iter, config_table);
1847 while (g_hash_table_iter_next(&iter, &key, &value)) {
1848 struct connman_config *config = value;
1850 g_hash_table_iter_init(&siter, config->service_table);
1851 while (g_hash_table_iter_next(&siter, &skey, &svalue)) {
1852 struct connman_config_service *service = svalue;
1854 if (!g_strcmp0(address, service->ipv4_address) &&
1856 service->ipv4_netmask))