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 #if defined TIZEN_EXT
651 ssid = g_try_malloc0(ssid_len + 1);
653 ssid = g_try_malloc0(ssid_len);
658 memcpy(ssid, service->name, ssid_len);
659 g_free(service->ssid);
660 service->ssid = ssid;
661 service->ssid_len = ssid_len;
664 str = __connman_config_get_string(keyfile, group, SERVICE_KEY_EAP, NULL);
666 g_free(service->eap);
670 str = __connman_config_get_string(keyfile, group, SERVICE_KEY_CA_CERT, NULL);
672 g_free(service->ca_cert_file);
673 service->ca_cert_file = str;
676 str = __connman_config_get_string(keyfile, group, SERVICE_KEY_CL_CERT, NULL);
678 g_free(service->client_cert_file);
679 service->client_cert_file = str;
682 str = __connman_config_get_string(keyfile, group, SERVICE_KEY_PRV_KEY, NULL);
684 g_free(service->private_key_file);
685 service->private_key_file = str;
688 str = __connman_config_get_string(keyfile, group,
689 SERVICE_KEY_PRV_KEY_PASS, NULL);
691 g_free(service->private_key_passphrase);
692 service->private_key_passphrase = str;
695 str = __connman_config_get_string(keyfile, group,
696 SERVICE_KEY_PRV_KEY_PASS_TYPE, NULL);
698 g_free(service->private_key_passphrase_type);
699 service->private_key_passphrase_type = str;
702 str = __connman_config_get_string(keyfile, group, SERVICE_KEY_IDENTITY, NULL);
704 g_free(service->identity);
705 service->identity = str;
708 str = __connman_config_get_string(keyfile, group,
709 SERVICE_KEY_ANONYMOUS_IDENTITY, NULL);
711 g_free(service->anonymous_identity);
712 service->anonymous_identity = str;
715 str = __connman_config_get_string(keyfile, group,
716 SERVICE_KEY_SUBJECT_MATCH, NULL);
718 g_free(service->subject_match);
719 service->subject_match = str;
722 str = __connman_config_get_string(keyfile, group,
723 SERVICE_KEY_ALT_SUBJECT_MATCH, NULL);
725 g_free(service->altsubject_match);
726 service->altsubject_match = str;
729 str = __connman_config_get_string(keyfile, group,
730 SERVICE_KEY_DOMAIN_SUFF_MATCH, NULL);
732 g_free(service->domain_suffix_match);
733 service->domain_suffix_match = str;
736 str = __connman_config_get_string(keyfile, group,
737 SERVICE_KEY_DOMAIN_MATCH, NULL);
739 g_free(service->domain_match);
740 service->domain_match = str;
743 str = __connman_config_get_string(keyfile, group, SERVICE_KEY_PHASE2, NULL);
745 g_free(service->phase2);
746 service->phase2 = str;
749 str = __connman_config_get_string(keyfile, group, SERVICE_KEY_PASSPHRASE,
752 g_free(service->passphrase);
753 service->passphrase = str;
755 #if defined TIZEN_EXT
757 str = __connman_config_get_string(keyfile, group, SERVICE_KEY_CONNECTOR,
760 g_free(service->connector);
761 service->connector = str;
764 str = __connman_config_get_string(keyfile, group, SERVICE_KEY_C_SIGN_KEY,
767 g_free(service->c_sign_key);
768 service->c_sign_key = str;
771 str = __connman_config_get_string(keyfile, group, SERVICE_KEY_NET_ACCESS_KEY,
774 g_free(service->net_access_key);
775 service->net_access_key = str;
779 str = __connman_config_get_string(keyfile, group, SERVICE_KEY_SECURITY,
781 security = __connman_service_string2security(str);
785 if (str && security != CONNMAN_SERVICE_SECURITY_8021X)
786 connman_info("Mismatch between EAP configuration and "
788 SERVICE_KEY_SECURITY, str);
790 service->security = CONNMAN_SERVICE_SECURITY_8021X;
792 } else if (service->passphrase) {
795 if (security == CONNMAN_SERVICE_SECURITY_PSK ||
796 #if defined TIZEN_EXT
797 security == CONNMAN_SERVICE_SECURITY_RSN ||
798 security == CONNMAN_SERVICE_SECURITY_SAE ||
800 security == CONNMAN_SERVICE_SECURITY_WEP) {
801 service->security = security;
803 connman_info("Mismatch with passphrase and "
805 SERVICE_KEY_SECURITY, str);
808 CONNMAN_SERVICE_SECURITY_PSK;
812 service->security = CONNMAN_SERVICE_SECURITY_PSK;
813 #if defined TIZEN_EXT
814 } else if (service->connector) {
816 if (str && security != CONNMAN_SERVICE_SECURITY_DPP)
817 connman_info("Mismatch between DPP configuration and "
819 SERVICE_KEY_SECURITY, str);
821 service->security = CONNMAN_SERVICE_SECURITY_DPP;
825 if (security != CONNMAN_SERVICE_SECURITY_NONE)
826 connman_info("Mismatch no security and "
828 SERVICE_KEY_SECURITY, str);
830 service->security = CONNMAN_SERVICE_SECURITY_NONE;
832 service->security = CONNMAN_SERVICE_SECURITY_NONE;
836 service->config_ident = g_strdup(config->ident);
837 service->config_entry = g_strdup_printf("service_%s", service->ident);
839 service->hidden = __connman_config_get_bool(keyfile, group,
840 SERVICE_KEY_HIDDEN, NULL);
843 g_hash_table_insert(config->service_table, service->ident,
846 connman_info("Adding service configuration %s", service->ident);
851 if (service_created) {
852 g_free(service->ident);
853 g_free(service->type);
854 g_free(service->name);
855 g_free(service->ssid);
862 static bool load_service_from_keyfile(GKeyFile *keyfile,
863 struct connman_config *config)
869 groups = g_key_file_get_groups(keyfile, NULL);
871 for (i = 0; groups[i]; i++) {
872 if (!g_str_has_prefix(groups[i], "service_")) {
873 connman_warn("Ignore group named '%s' because prefix "
874 "is not 'service_'", groups[i]);
877 if (load_service(keyfile, groups[i], config))
886 static int load_config(struct connman_config *config)
891 DBG("config %p", config);
893 keyfile = __connman_storage_load_config(config->ident);
897 g_key_file_set_list_separator(keyfile, ',');
899 /* Verify keys validity of the global section */
900 check_keys(keyfile, "global", config_possible_keys);
902 str = __connman_config_get_string(keyfile, "global", CONFIG_KEY_NAME, NULL);
904 g_free(config->name);
908 str = __connman_config_get_string(keyfile, "global", CONFIG_KEY_DESC, NULL);
910 g_free(config->description);
911 config->description = str;
914 if (!load_service_from_keyfile(keyfile, config))
915 connman_warn("Config file %s/%s.config does not contain any "
916 "configuration that can be provisioned!",
917 STORAGEDIR, config->ident);
919 g_key_file_free(keyfile);
924 static struct connman_config *create_config(const char *ident)
926 struct connman_config *config;
928 DBG("ident %s", ident);
930 if (g_hash_table_lookup(config_table, ident))
933 config = g_try_new0(struct connman_config, 1);
937 config->ident = g_strdup(ident);
939 config->service_table = g_hash_table_new_full(g_str_hash, g_str_equal,
940 NULL, unregister_service);
942 g_hash_table_insert(config_table, config->ident, config);
944 connman_info("Adding configuration %s", config->ident);
949 static bool validate_ident(const char *ident)
956 for (i = 0; i < strlen(ident); i++)
957 if (!g_ascii_isprint(ident[i]))
963 static int read_configs(void)
969 dir = g_dir_open(STORAGEDIR, 0, NULL);
973 while ((file = g_dir_read_name(dir))) {
977 if (!g_str_has_suffix(file, ".config"))
980 ident = g_strrstr(file, ".config");
984 str = g_string_new_len(file, ident - file);
988 ident = g_string_free(str, FALSE);
990 if (validate_ident(ident)) {
991 struct connman_config *config;
993 config = create_config(ident);
997 connman_error("Invalid config ident %s", ident);
1008 static void config_notify_handler(struct inotify_event *event,
1016 if (!g_str_has_suffix(ident, ".config"))
1019 ext = g_strrstr(ident, ".config");
1025 if (!validate_ident(ident)) {
1026 connman_error("Invalid config ident %s", ident);
1030 if (event->mask & (IN_CREATE | IN_MOVED_TO))
1031 create_config(ident);
1033 if (event->mask & (IN_MODIFY | IN_MOVED_TO)) {
1034 struct connman_config *config;
1036 config = g_hash_table_lookup(config_table, ident);
1040 g_hash_table_remove_all(config->service_table);
1041 load_config(config);
1042 ret = __connman_service_provision_changed(ident);
1045 * Re-scan the config file for any
1048 g_hash_table_remove_all(config->service_table);
1049 load_config(config);
1050 __connman_service_provision_changed(ident);
1055 if (event->mask & (IN_DELETE | IN_MOVED_FROM))
1056 g_hash_table_remove(config_table, ident);
1059 int __connman_config_init(void)
1063 config_table = g_hash_table_new_full(g_str_hash, g_str_equal,
1064 NULL, unregister_config);
1066 connman_inotify_register(STORAGEDIR, config_notify_handler);
1068 return read_configs();
1071 void __connman_config_cleanup(void)
1077 connman_inotify_unregister(STORAGEDIR, config_notify_handler);
1079 g_hash_table_destroy(config_table);
1080 config_table = NULL;
1085 char *__connman_config_get_string(GKeyFile *key_file,
1086 const char *group_name, const char *key, GError **error)
1088 char *str = g_key_file_get_string(key_file, group_name, key, error);
1092 /* passphrases can have spaces in the end */
1093 if (!g_strcmp0(key, SERVICE_KEY_PASSPHRASE) ||
1094 !g_strcmp0(key, SERVICE_KEY_PRV_KEY_PASS))
1097 return g_strchomp(str);
1100 char **__connman_config_get_string_list(GKeyFile *key_file,
1101 const char *group_name, const char *key, gsize *length, GError **error)
1104 char **strlist = g_key_file_get_string_list(key_file, group_name, key,
1111 *p = g_strstrip(*p);
1118 bool __connman_config_get_bool(GKeyFile *key_file,
1119 const char *group_name, const char *key, GError **error)
1124 valstr = g_key_file_get_value(key_file, group_name, key, error);
1128 valstr = g_strchomp(valstr);
1129 if (strcmp(valstr, "true") == 0 || strcmp(valstr, "1") == 0)
1137 static char *config_pem_fsid(const char *pem_file)
1140 unsigned *fsid = (unsigned *) &buf.f_fsid;
1141 unsigned long long fsid64;
1146 if (statfs(pem_file, &buf) < 0) {
1147 connman_error("statfs error %s for %s",
1148 strerror(errno), pem_file);
1152 fsid64 = ((unsigned long long) fsid[0] << 32) | fsid[1];
1154 return g_strdup_printf("%llx", fsid64);
1157 static void provision_service_wifi(struct connman_config_service *config,
1158 struct connman_service *service,
1159 struct connman_network *network,
1160 const void *ssid, unsigned int ssid_len)
1163 __connman_service_set_string(service, "EAP", config->eap);
1165 if (config->identity)
1166 __connman_service_set_string(service, "Identity",
1169 if (config->anonymous_identity)
1170 __connman_service_set_string(service, "AnonymousIdentity",
1171 config->anonymous_identity);
1173 if (config->ca_cert_file)
1174 __connman_service_set_string(service, "CACertFile",
1175 config->ca_cert_file);
1177 if (config->subject_match)
1178 __connman_service_set_string(service, "SubjectMatch",
1179 config->subject_match);
1181 if (config->altsubject_match)
1182 __connman_service_set_string(service, "AltSubjectMatch",
1183 config->altsubject_match);
1185 if (config->domain_suffix_match)
1186 __connman_service_set_string(service, "DomainSuffixMatch",
1187 config->domain_suffix_match);
1189 if (config->domain_match)
1190 __connman_service_set_string(service, "DomainMatch",
1191 config->domain_match);
1193 if (config->client_cert_file)
1194 __connman_service_set_string(service, "ClientCertFile",
1195 config->client_cert_file);
1197 if (config->private_key_file)
1198 __connman_service_set_string(service, "PrivateKeyFile",
1199 config->private_key_file);
1201 if (g_strcmp0(config->private_key_passphrase_type, "fsid") == 0 &&
1202 config->private_key_file) {
1205 fsid = config_pem_fsid(config->private_key_file);
1209 g_free(config->private_key_passphrase);
1210 config->private_key_passphrase = fsid;
1213 if (config->private_key_passphrase) {
1214 __connman_service_set_string(service, "PrivateKeyPassphrase",
1215 config->private_key_passphrase);
1217 * TODO: Support for PEAP with both identity and key passwd.
1218 * In that case, we should check if both of them are found
1219 * from the config file. If not, we should not set the
1220 * service passphrase in order for the UI to request for an
1221 * additional passphrase.
1226 __connman_service_set_string(service, "Phase2", config->phase2);
1227 #if defined TIZEN_EXT
1229 __connman_service_set_string(service, "Phase2", NULL);
1232 if (config->passphrase)
1233 __connman_service_set_string(service, "Passphrase",
1234 config->passphrase);
1237 __connman_service_set_hidden(service);
1239 #if defined TIZEN_EXT
1240 if (config->connector)
1241 __connman_service_set_string(service, "Connector",
1243 if (config->c_sign_key)
1244 __connman_service_set_string(service, "CSignKey",
1245 config->c_sign_key);
1246 if (config->net_access_key)
1247 __connman_service_set_string(service, "NetAccessKey",
1248 config->net_access_key);
1252 struct connect_virtual {
1253 struct connman_service *service;
1257 static gboolean remove_virtual_config(gpointer user_data)
1259 struct connect_virtual *virtual = user_data;
1261 __connman_service_connect(virtual->service,
1262 CONNMAN_SERVICE_CONNECT_REASON_AUTO);
1263 g_hash_table_remove(config_table, virtual->vfile);
1270 #if defined TIZEN_EXT
1271 static bool __check_address_type(int address_family, const char *address)
1273 unsigned char buf[sizeof(struct in6_addr)] = {0, };
1276 err = inet_pton(address_family, address, buf);
1284 static int try_provision_service(struct connman_config_service *config,
1285 struct connman_service *service)
1287 struct connman_network *network;
1288 const void *service_id;
1289 enum connman_service_type type;
1291 unsigned int ssid_len;
1294 network = __connman_service_get_network(service);
1296 connman_error("Service has no network set");
1300 DBG("network %p ident %s", network,
1301 connman_network_get_identifier(network));
1303 type = connman_service_get_type(service);
1306 case CONNMAN_SERVICE_TYPE_WIFI:
1307 if (__connman_service_string2type(config->type) != type)
1310 ssid = connman_network_get_blob(network, "WiFi.SSID",
1315 if (!config->ssid || ssid_len != config->ssid_len)
1318 if (memcmp(config->ssid, ssid, ssid_len))
1321 str = connman_network_get_string(network, "WiFi.Security");
1322 if (config->security != __connman_service_string2security(str))
1327 case CONNMAN_SERVICE_TYPE_ETHERNET:
1328 case CONNMAN_SERVICE_TYPE_GADGET:
1330 if (__connman_service_string2type(config->type) != type)
1335 case CONNMAN_SERVICE_TYPE_UNKNOWN:
1336 case CONNMAN_SERVICE_TYPE_SYSTEM:
1337 case CONNMAN_SERVICE_TYPE_BLUETOOTH:
1338 case CONNMAN_SERVICE_TYPE_CELLULAR:
1339 case CONNMAN_SERVICE_TYPE_GPS:
1340 case CONNMAN_SERVICE_TYPE_VPN:
1341 case CONNMAN_SERVICE_TYPE_P2P:
1342 #if defined TIZEN_EXT_WIFI_MESH
1343 case CONNMAN_SERVICE_TYPE_MESH:
1349 DBG("service %p ident %s", service,
1350 connman_service_get_identifier(service));
1353 struct connman_device *device;
1354 const char *device_addr;
1356 device = connman_network_get_device(network);
1358 connman_error("Network device is missing");
1362 device_addr = connman_device_get_string(device, "Address");
1364 DBG("wants %s has %s", config->mac, device_addr);
1366 if (g_ascii_strcasecmp(device_addr, config->mac) != 0)
1370 #if defined TIZEN_EXT
1371 struct connman_ipconfig *ip6config = __connman_service_get_ip6config(service);
1372 enum connman_ipconfig_method ipv6_method = __connman_ipconfig_get_method(ip6config);
1373 if (ipv6_method == CONNMAN_IPCONFIG_METHOD_MANUAL)
1376 if (!config->ipv6_address) {
1377 connman_network_set_ipv6_method(network,
1378 CONNMAN_IPCONFIG_METHOD_AUTO);
1379 } else if (g_ascii_strcasecmp(config->ipv6_address, "off") == 0) {
1380 connman_network_set_ipv6_method(network,
1381 CONNMAN_IPCONFIG_METHOD_OFF);
1382 } else if (g_ascii_strcasecmp(config->ipv6_address, "auto") == 0 ||
1383 g_ascii_strcasecmp(config->ipv6_address, "dhcp") == 0) {
1384 connman_network_set_ipv6_method(network,
1385 CONNMAN_IPCONFIG_METHOD_AUTO);
1387 struct connman_ipaddress *address;
1389 if (config->ipv6_prefix_length == 0) {
1390 DBG("IPv6 prefix missing");
1394 address = connman_ipaddress_alloc(AF_INET6);
1398 connman_ipaddress_set_ipv6(address, config->ipv6_address,
1399 config->ipv6_prefix_length,
1400 config->ipv6_gateway);
1402 connman_network_set_ipv6_method(network,
1403 CONNMAN_IPCONFIG_METHOD_FIXED);
1405 if (connman_network_set_ipaddress(network, address) < 0)
1406 DBG("Unable to set IPv6 address to network %p",
1409 connman_ipaddress_free(address);
1412 #if defined TIZEN_EXT
1415 if (config->ipv6_privacy) {
1416 struct connman_ipconfig *ipconfig;
1418 ipconfig = __connman_service_get_ip6config(service);
1420 __connman_ipconfig_ipv6_set_privacy(ipconfig,
1421 config->ipv6_privacy);
1424 #if defined TIZEN_EXT
1425 struct connman_ipconfig *ip4config = __connman_service_get_ip4config(service);
1426 enum connman_ipconfig_method ipv4_method = __connman_ipconfig_get_method(ip4config);
1427 if (ipv4_method == CONNMAN_IPCONFIG_METHOD_MANUAL)
1430 if (!config->ipv4_address) {
1431 connman_network_set_ipv4_method(network,
1432 CONNMAN_IPCONFIG_METHOD_DHCP);
1433 } else if (g_ascii_strcasecmp(config->ipv4_address, "off") == 0) {
1434 connman_network_set_ipv4_method(network,
1435 CONNMAN_IPCONFIG_METHOD_OFF);
1436 } else if (g_ascii_strcasecmp(config->ipv4_address, "auto") == 0 ||
1437 g_ascii_strcasecmp(config->ipv4_address, "dhcp") == 0) {
1438 connman_network_set_ipv4_method(network,
1439 CONNMAN_IPCONFIG_METHOD_DHCP);
1441 struct connman_ipaddress *address;
1443 if (!config->ipv4_netmask) {
1444 DBG("IPv4 netmask missing");
1448 address = connman_ipaddress_alloc(AF_INET);
1452 connman_ipaddress_set_ipv4(address, config->ipv4_address,
1453 config->ipv4_netmask,
1454 config->ipv4_gateway);
1456 connman_network_set_ipv4_method(network,
1457 CONNMAN_IPCONFIG_METHOD_FIXED);
1459 if (connman_network_set_ipaddress(network, address) < 0)
1460 DBG("Unable to set IPv4 address to network %p",
1463 connman_ipaddress_free(address);
1466 #if defined TIZEN_EXT
1469 __connman_service_disconnect(service);
1471 service_id = connman_service_get_identifier(service);
1472 config->service_identifiers =
1473 g_slist_prepend(config->service_identifiers,
1474 g_strdup(service_id));
1476 __connman_service_set_favorite_delayed(service, true, true);
1478 __connman_service_set_config(service, config->config_ident,
1479 config->config_entry);
1481 if (config->domain_name)
1482 __connman_service_set_domainname(service, config->domain_name);
1484 if (config->nameservers) {
1487 __connman_service_nameserver_clear(service);
1489 for (i = 0; config->nameservers[i]; i++) {
1490 #if defined TIZEN_EXT
1491 if (__check_address_type(AF_INET, config->nameservers[i]))
1492 __connman_service_nameserver_append(service,
1493 config->nameservers[i], false,
1494 CONNMAN_IPCONFIG_TYPE_IPV4);
1495 else if (__check_address_type(AF_INET6, config->nameservers[i]))
1496 __connman_service_nameserver_append(service,
1497 config->nameservers[i], false,
1498 CONNMAN_IPCONFIG_TYPE_IPV6);
1500 __connman_service_nameserver_append(service,
1501 config->nameservers[i], false);
1506 if (config->search_domains)
1507 __connman_service_set_search_domains(service,
1508 config->search_domains);
1510 __connman_service_set_mdns(service, config->mdns);
1512 if (config->timeservers)
1513 __connman_service_set_timeservers(service,
1514 config->timeservers);
1516 if (type == CONNMAN_SERVICE_TYPE_WIFI) {
1517 provision_service_wifi(config, service, network,
1521 __connman_service_mark_dirty();
1523 __connman_service_load_modifiable(service);
1525 if (config->virtual) {
1526 struct connect_virtual *virtual;
1528 virtual = g_malloc0(sizeof(struct connect_virtual));
1529 virtual->service = service;
1530 virtual->vfile = config->virtual_file;
1532 g_idle_add(remove_virtual_config, virtual);
1537 #if !defined TIZEN_EXT
1538 __connman_service_set_immutable(service, true);
1541 if (type == CONNMAN_SERVICE_TYPE_ETHERNET ||
1542 type == CONNMAN_SERVICE_TYPE_GADGET) {
1543 __connman_service_connect(service,
1544 CONNMAN_SERVICE_CONNECT_REASON_AUTO);
1549 __connman_service_auto_connect(CONNMAN_SERVICE_CONNECT_REASON_AUTO);
1555 find_and_provision_service_from_config(struct connman_service *service,
1556 struct connman_config *config)
1558 GHashTableIter iter;
1559 gpointer value, key;
1561 g_hash_table_iter_init(&iter, config->service_table);
1562 while (g_hash_table_iter_next(&iter, &key,
1564 if (!try_provision_service(value, service))
1571 static int find_and_provision_service(struct connman_service *service)
1573 GHashTableIter iter;
1574 gpointer value, key;
1576 g_hash_table_iter_init(&iter, config_table);
1578 while (g_hash_table_iter_next(&iter, &key, &value)) {
1579 struct connman_config *config = value;
1581 if (!find_and_provision_service_from_config(service, config))
1588 int __connman_config_provision_service(struct connman_service *service)
1590 enum connman_service_type type;
1592 /* For now only WiFi, Gadget and Ethernet services are supported */
1593 type = connman_service_get_type(service);
1594 #if defined TIZEN_EXT
1595 if (!simplified_log)
1597 DBG("service %p type %d", service, type);
1599 if (type != CONNMAN_SERVICE_TYPE_WIFI &&
1600 type != CONNMAN_SERVICE_TYPE_ETHERNET &&
1601 type != CONNMAN_SERVICE_TYPE_GADGET)
1604 #if defined TIZEN_EXT
1605 if(type == CONNMAN_SERVICE_TYPE_WIFI &&
1606 __connman_service_get_security(service) ==
1607 CONNMAN_SERVICE_SECURITY_NONE)
1611 return find_and_provision_service(service);
1614 int __connman_config_provision_service_ident(struct connman_service *service,
1615 const char *ident, const char *file, const char *entry)
1617 enum connman_service_type type;
1618 struct connman_config *config;
1621 /* For now only WiFi, Gadget and Ethernet services are supported */
1622 type = connman_service_get_type(service);
1624 DBG("service %p type %d", service, type);
1626 if (type != CONNMAN_SERVICE_TYPE_WIFI &&
1627 type != CONNMAN_SERVICE_TYPE_ETHERNET &&
1628 type != CONNMAN_SERVICE_TYPE_GADGET)
1631 config = g_hash_table_lookup(config_table, ident);
1633 GHashTableIter iter;
1634 gpointer value, key;
1637 g_hash_table_iter_init(&iter, config->service_table);
1640 * Check if we need to remove individual service if it
1641 * is missing from config file.
1643 if (file && entry) {
1644 while (g_hash_table_iter_next(&iter, &key,
1646 struct connman_config_service *config_service;
1648 config_service = value;
1650 if (g_strcmp0(config_service->config_ident,
1654 if (g_strcmp0(config_service->config_entry,
1662 DBG("found %d ident %s file %s entry %s", found, ident,
1667 * The entry+8 will skip "service_" prefix
1669 g_hash_table_remove(config->service_table,
1675 find_and_provision_service_from_config(service, config);
1681 static void generate_random_string(char *str, int length)
1687 memset(str, '\0', length);
1689 for (i = 0; i < length-1; i++) {
1691 __connman_util_get_random(&rand);
1692 val = (uint8_t)(rand % 122);
1695 } while((val > 57 && val < 65) || (val > 90 && val < 97));
1701 int connman_config_provision_mutable_service(GKeyFile *keyfile)
1703 struct connman_config_service *service_config;
1704 struct connman_config *config;
1705 char *vfile, *group = NULL;
1710 generate_random_string(rstr, 11);
1712 vfile = g_strdup_printf("service_mutable_%s.config", rstr);
1714 config = create_config(vfile);
1718 if (!load_service_from_keyfile(keyfile, config))
1721 group = g_key_file_get_start_group(keyfile);
1723 service_config = g_hash_table_lookup(config->service_table, group+8);
1724 if (!service_config)
1727 /* Specific to non file based config: */
1728 g_free(service_config->config_ident);
1729 service_config->config_ident = NULL;
1730 g_free(service_config->config_entry);
1731 service_config->config_entry = NULL;
1733 service_config->virtual = true;
1734 service_config->virtual_file = vfile;
1736 __connman_service_provision_changed(vfile);
1738 if (g_strcmp0(service_config->type, "wifi") == 0)
1739 __connman_device_request_scan(CONNMAN_SERVICE_TYPE_WIFI);
1745 DBG("Could not proceed");
1746 g_hash_table_remove(config_table, vfile);
1752 struct connman_config_entry **connman_config_get_entries(const char *type)
1754 GHashTableIter iter_file, iter_config;
1755 gpointer value, key;
1756 struct connman_config_entry **entries = NULL;
1759 g_hash_table_iter_init(&iter_file, config_table);
1760 while (g_hash_table_iter_next(&iter_file, &key, &value)) {
1761 struct connman_config *config_file = value;
1762 struct connman_config_entry **tmp_entries = entries;
1764 count = g_hash_table_size(config_file->service_table);
1766 entries = g_try_realloc(entries, (i + count + 1) *
1767 sizeof(struct connman_config_entry *));
1769 g_free(tmp_entries);
1773 g_hash_table_iter_init(&iter_config,
1774 config_file->service_table);
1775 while (g_hash_table_iter_next(&iter_config, &key,
1777 struct connman_config_service *config = value;
1780 g_strcmp0(config->type, type) != 0)
1783 entries[i] = g_try_new0(struct connman_config_entry,
1788 entries[i]->ident = g_strdup(config->ident);
1789 entries[i]->name = g_strdup(config->name);
1790 entries[i]->ssid = g_try_malloc0(config->ssid_len + 1);
1791 if (!entries[i]->ssid)
1794 memcpy(entries[i]->ssid, config->ssid,
1796 entries[i]->ssid_len = config->ssid_len;
1797 entries[i]->hidden = config->hidden;
1804 struct connman_config_entry **tmp_entries = entries;
1806 entries = g_try_realloc(entries, (i + 1) *
1807 sizeof(struct connman_config_entry *));
1809 g_free(tmp_entries);
1815 DBG("%d provisioned AP found", i);
1821 connman_config_free_entries(entries);
1825 void connman_config_free_entries(struct connman_config_entry **entries)
1832 for (i = 0; entries[i]; i++) {
1833 g_free(entries[i]->ident);
1834 g_free(entries[i]->name);
1835 g_free(entries[i]->ssid);
1842 bool __connman_config_address_provisioned(const char *address,
1843 const char *netmask)
1845 GHashTableIter iter, siter;
1846 gpointer value, key, svalue, skey;
1848 if (!address || !netmask)
1851 g_hash_table_iter_init(&iter, config_table);
1853 while (g_hash_table_iter_next(&iter, &key, &value)) {
1854 struct connman_config *config = value;
1856 g_hash_table_iter_init(&siter, config->service_table);
1857 while (g_hash_table_iter_next(&siter, &skey, &svalue)) {
1858 struct connman_config_service *service = svalue;
1860 if (!g_strcmp0(address, service->ipv4_address) &&
1862 service->ipv4_netmask))