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 #include <sys/inotify.h>
34 #include <connman/provision.h>
37 struct connman_config_service {
42 unsigned int ssid_len;
46 char *client_cert_file;
47 char *private_key_file;
48 char *private_key_passphrase;
49 char *private_key_passphrase_type;
52 GSList *service_identifiers;
53 char *config_ident; /* file prefix */
54 char *config_entry; /* entry name */
55 connman_bool_t hidden;
58 struct connman_config {
62 connman_bool_t protected;
63 GHashTable *service_table;
66 static GHashTable *config_table = NULL;
67 static GSList *protected_services = NULL;
69 static connman_bool_t cleanup = FALSE;
71 #define INTERNAL_CONFIG_PREFIX "__internal"
73 /* Definition of possible strings in the .config files */
74 #define CONFIG_KEY_NAME "Name"
75 #define CONFIG_KEY_DESC "Description"
76 #define CONFIG_KEY_PROT "Protected"
78 #define SERVICE_KEY_TYPE "Type"
79 #define SERVICE_KEY_NAME "Name"
80 #define SERVICE_KEY_SSID "SSID"
81 #define SERVICE_KEY_EAP "EAP"
82 #define SERVICE_KEY_CA_CERT "CACertFile"
83 #define SERVICE_KEY_CL_CERT "ClientCertFile"
84 #define SERVICE_KEY_PRV_KEY "PrivateKeyFile"
85 #define SERVICE_KEY_PRV_KEY_PASS "PrivateKeyPassphrase"
86 #define SERVICE_KEY_PRV_KEY_PASS_TYPE "PrivateKeyPassphraseType"
87 #define SERVICE_KEY_IDENTITY "Identity"
88 #define SERVICE_KEY_PHASE2 "Phase2"
89 #define SERVICE_KEY_PASSPHRASE "Passphrase"
90 #define SERVICE_KEY_HIDDEN "Hidden"
92 static const char *config_possible_keys[] = {
99 static const char *service_possible_keys[] = {
107 SERVICE_KEY_PRV_KEY_PASS,
108 SERVICE_KEY_PRV_KEY_PASS_TYPE,
109 SERVICE_KEY_IDENTITY,
111 SERVICE_KEY_PASSPHRASE,
116 static void unregister_config(gpointer data)
118 struct connman_config *config = data;
120 connman_info("Removing configuration %s", config->ident);
122 g_hash_table_destroy(config->service_table);
124 g_free(config->description);
125 g_free(config->name);
126 g_free(config->ident);
130 static void unregister_service(gpointer data)
132 struct connman_config_service *config_service = data;
133 struct connman_service *service;
140 connman_info("Removing service configuration %s",
141 config_service->ident);
143 protected_services = g_slist_remove(protected_services,
146 for (list = config_service->service_identifiers; list != NULL;
148 service_id = list->data;
150 service = __connman_service_lookup_from_ident(service_id);
151 if (service != NULL) {
152 __connman_service_set_immutable(service, FALSE);
153 __connman_service_remove(service);
156 if (__connman_storage_remove_service(service_id) == FALSE)
157 DBG("Could not remove all files for service %s",
162 g_free(config_service->ident);
163 g_free(config_service->type);
164 g_free(config_service->name);
165 g_free(config_service->ssid);
166 g_free(config_service->eap);
167 g_free(config_service->identity);
168 g_free(config_service->ca_cert_file);
169 g_free(config_service->client_cert_file);
170 g_free(config_service->private_key_file);
171 g_free(config_service->private_key_passphrase);
172 g_free(config_service->private_key_passphrase_type);
173 g_free(config_service->phase2);
174 g_free(config_service->passphrase);
175 g_slist_free_full(config_service->service_identifiers, g_free);
176 g_free(config_service->config_ident);
177 g_free(config_service->config_entry);
178 g_free(config_service);
181 static void check_keys(GKeyFile *keyfile, const char *group,
182 const char **possible_keys)
185 gsize nb_avail_keys, i, j;
187 avail_keys = g_key_file_get_keys(keyfile, group, &nb_avail_keys, NULL);
188 if (avail_keys == NULL)
192 * For each key in the configuration file,
193 * verify it is understood by connman
195 for (i = 0 ; i < nb_avail_keys; i++) {
196 for (j = 0; possible_keys[j] ; j++)
197 if (g_strcmp0(avail_keys[i], possible_keys[j]) == 0)
200 if (possible_keys[j] == NULL)
201 connman_warn("Unknown configuration key %s in [%s]",
202 avail_keys[i], group);
205 g_strfreev(avail_keys);
208 static connman_bool_t
209 is_protected_service(struct connman_config_service *service)
213 DBG("ident %s", service->ident);
215 for (list = protected_services; list; list = list->next) {
216 struct connman_config_service *s = list->data;
218 if (g_strcmp0(s->type, service->type) != 0)
221 if (s->ssid == NULL || service->ssid == NULL)
224 if (s->ssid_len != service->ssid_len)
227 if (g_strcmp0(service->type, "wifi") == 0 &&
228 strncmp(s->ssid, service->ssid, s->ssid_len) == 0) {
236 static int load_service(GKeyFile *keyfile, const char *group,
237 struct connman_config *config)
239 struct connman_config_service *service;
241 char *str, *hex_ssid;
242 gboolean service_created = FALSE;
245 /* Strip off "service_" prefix */
248 if (strlen(ident) < 1)
251 /* Verify that provided keys are good */
252 check_keys(keyfile, group, service_possible_keys);
254 service = g_hash_table_lookup(config->service_table, ident);
255 if (service == NULL) {
256 service = g_try_new0(struct connman_config_service, 1);
260 service->ident = g_strdup(ident);
262 service_created = TRUE;
265 str = g_key_file_get_string(keyfile, group, SERVICE_KEY_TYPE, NULL);
267 g_free(service->type);
271 str = g_key_file_get_string(keyfile, group, SERVICE_KEY_NAME, NULL);
273 g_free(service->name);
277 hex_ssid = g_key_file_get_string(keyfile, group, SERVICE_KEY_SSID,
279 if (hex_ssid != NULL) {
281 unsigned int i, j = 0, hex;
282 size_t hex_ssid_len = strlen(hex_ssid);
284 ssid = g_try_malloc0(hex_ssid_len / 2);
291 for (i = 0; i < hex_ssid_len; i += 2) {
292 if (sscanf(hex_ssid + i, "%02x", &hex) <= 0) {
293 connman_warn("Invalid SSID %s", hex_ssid);
304 g_free(service->ssid);
305 service->ssid = ssid;
306 service->ssid_len = hex_ssid_len / 2;
307 } else if (service->name != NULL) {
309 unsigned int ssid_len;
311 ssid_len = strlen(service->name);
312 ssid = g_try_malloc0(ssid_len);
318 memcpy(ssid, service->name, ssid_len);
319 g_free(service->ssid);
320 service->ssid = ssid;
321 service->ssid_len = ssid_len;
324 if (is_protected_service(service) == TRUE) {
325 connman_error("Trying to provision a protected service");
330 str = g_key_file_get_string(keyfile, group, SERVICE_KEY_EAP, NULL);
332 g_free(service->eap);
336 str = g_key_file_get_string(keyfile, group, SERVICE_KEY_CA_CERT, NULL);
338 g_free(service->ca_cert_file);
339 service->ca_cert_file = str;
342 str = g_key_file_get_string(keyfile, group, SERVICE_KEY_CL_CERT, NULL);
344 g_free(service->client_cert_file);
345 service->client_cert_file = str;
348 str = g_key_file_get_string(keyfile, group, SERVICE_KEY_PRV_KEY, NULL);
350 g_free(service->private_key_file);
351 service->private_key_file = str;
354 str = g_key_file_get_string(keyfile, group,
355 SERVICE_KEY_PRV_KEY_PASS, NULL);
357 g_free(service->private_key_passphrase);
358 service->private_key_passphrase = str;
361 str = g_key_file_get_string(keyfile, group,
362 SERVICE_KEY_PRV_KEY_PASS_TYPE, NULL);
364 g_free(service->private_key_passphrase_type);
365 service->private_key_passphrase_type = str;
368 str = g_key_file_get_string(keyfile, group, SERVICE_KEY_IDENTITY, NULL);
370 g_free(service->identity);
371 service->identity = str;
374 str = g_key_file_get_string(keyfile, group, SERVICE_KEY_PHASE2, NULL);
376 g_free(service->phase2);
377 service->phase2 = str;
380 str = g_key_file_get_string(keyfile, group, SERVICE_KEY_PASSPHRASE,
383 g_free(service->passphrase);
384 service->passphrase = str;
387 service->config_ident = g_strdup(config->ident);
388 service->config_entry = g_strdup_printf("service_%s", service->ident);
390 service->hidden = g_key_file_get_boolean(keyfile, group,
391 SERVICE_KEY_HIDDEN, NULL);
394 g_hash_table_insert(config->service_table, service->ident,
397 if (config->protected == TRUE)
399 g_slist_prepend(protected_services, service);
401 connman_info("Adding service configuration %s", service->ident);
406 if (service_created == TRUE) {
407 g_free(service->ident);
408 g_free(service->type);
409 g_free(service->name);
410 g_free(service->ssid);
417 static int load_config(struct connman_config *config)
420 GError *error = NULL;
424 gboolean protected, found = FALSE;
427 DBG("config %p", config);
429 keyfile = __connman_storage_load_config(config->ident);
433 /* Verify keys validity of the global section */
434 check_keys(keyfile, "global", config_possible_keys);
436 str = g_key_file_get_string(keyfile, "global", CONFIG_KEY_NAME, NULL);
438 g_free(config->name);
442 str = g_key_file_get_string(keyfile, "global", CONFIG_KEY_DESC, NULL);
444 g_free(config->description);
445 config->description = str;
448 protected = g_key_file_get_boolean(keyfile, "global",
449 CONFIG_KEY_PROT, &error);
451 config->protected = protected;
453 config->protected = TRUE;
454 g_clear_error(&error);
456 groups = g_key_file_get_groups(keyfile, &length);
458 for (i = 0; groups[i] != NULL; i++) {
459 if (g_str_has_prefix(groups[i], "service_") == TRUE) {
460 if (load_service(keyfile, groups[i], config) == 0)
466 connman_warn("Config file %s/%s.config does not contain any "
467 "configuration that can be provisioned!",
468 STORAGEDIR, config->ident);
472 g_key_file_free(keyfile);
477 static struct connman_config *create_config(const char *ident)
479 struct connman_config *config;
481 DBG("ident %s", ident);
483 if (g_hash_table_lookup(config_table, ident) != NULL)
486 config = g_try_new0(struct connman_config, 1);
490 config->ident = g_strdup(ident);
492 config->service_table = g_hash_table_new_full(g_str_hash, g_str_equal,
493 NULL, unregister_service);
495 g_hash_table_insert(config_table, config->ident, config);
497 connman_info("Adding configuration %s", config->ident);
502 static connman_bool_t validate_ident(const char *ident)
509 for (i = 0; i < strlen(ident); i++)
510 if (g_ascii_isprint(ident[i]) == FALSE)
516 static int read_configs(void)
522 dir = g_dir_open(STORAGEDIR, 0, NULL);
526 while ((file = g_dir_read_name(dir)) != NULL) {
530 if (g_str_has_suffix(file, ".config") == FALSE)
533 ident = g_strrstr(file, ".config");
537 str = g_string_new_len(file, ident - file);
541 ident = g_string_free(str, FALSE);
543 if (validate_ident(ident) == TRUE) {
544 struct connman_config *config;
546 config = create_config(ident);
550 connman_error("Invalid config ident %s", ident);
561 static void config_notify_handler(struct inotify_event *event,
569 if (g_str_has_suffix(ident, ".config") == FALSE)
572 ext = g_strrstr(ident, ".config");
578 if (validate_ident(ident) == FALSE) {
579 connman_error("Invalid config ident %s", ident);
583 if (event->mask & IN_CREATE)
584 create_config(ident);
586 if (event->mask & IN_MODIFY) {
587 struct connman_config *config;
589 config = g_hash_table_lookup(config_table, ident);
590 if (config != NULL) {
593 g_hash_table_remove_all(config->service_table);
595 ret = __connman_service_provision_changed(ident);
598 * Re-scan the config file for any
601 g_hash_table_remove_all(config->service_table);
603 __connman_service_provision_changed(ident);
608 if (event->mask & IN_DELETE)
609 g_hash_table_remove(config_table, ident);
612 int __connman_config_init(void)
616 config_table = g_hash_table_new_full(g_str_hash, g_str_equal,
617 NULL, unregister_config);
619 connman_inotify_register(STORAGEDIR, config_notify_handler);
621 return read_configs();
624 void __connman_config_cleanup(void)
630 connman_inotify_unregister(STORAGEDIR, config_notify_handler);
632 g_hash_table_destroy(config_table);
638 static char *config_pem_fsid(const char *pem_file)
641 unsigned *fsid = (unsigned *) &buf.f_fsid;
642 unsigned long long fsid64;
644 if (pem_file == NULL)
647 if (statfs(pem_file, &buf) < 0) {
648 connman_error("statfs error %s for %s",
649 strerror(errno), pem_file);
653 fsid64 = ((unsigned long long) fsid[0] << 32) | fsid[1];
655 return g_strdup_printf("%llx", fsid64);
658 static void provision_service(gpointer key, gpointer value, gpointer user_data)
660 struct connman_service *service = user_data;
661 struct connman_config_service *config = value;
662 struct connman_network *network;
663 const void *ssid, *service_id;
664 unsigned int ssid_len;
666 /* For now only WiFi service entries are supported */
667 if (g_strcmp0(config->type, "wifi") != 0)
670 network = __connman_service_get_network(service);
671 if (network == NULL) {
672 connman_error("Service has no network set");
676 ssid = connman_network_get_blob(network, "WiFi.SSID", &ssid_len);
678 connman_error("Network SSID not set");
682 if (config->ssid == NULL || ssid_len != config->ssid_len)
685 if (memcmp(config->ssid, ssid, ssid_len) != 0)
688 service_id = __connman_service_get_ident(service);
689 config->service_identifiers =
690 g_slist_prepend(config->service_identifiers,
691 g_strdup(service_id));
693 __connman_service_set_immutable(service, TRUE);
695 __connman_service_set_favorite_delayed(service, TRUE, TRUE);
697 __connman_service_set_config(service, config->config_ident,
698 config->config_entry);
700 if (config->eap != NULL)
701 __connman_service_set_string(service, "EAP", config->eap);
703 if (config->identity != NULL)
704 __connman_service_set_string(service, "Identity",
707 if (config->ca_cert_file != NULL)
708 __connman_service_set_string(service, "CACertFile",
709 config->ca_cert_file);
711 if (config->client_cert_file != NULL)
712 __connman_service_set_string(service, "ClientCertFile",
713 config->client_cert_file);
715 if (config->private_key_file != NULL)
716 __connman_service_set_string(service, "PrivateKeyFile",
717 config->private_key_file);
719 if (g_strcmp0(config->private_key_passphrase_type, "fsid") == 0 &&
720 config->private_key_file != NULL) {
723 fsid = config_pem_fsid(config->private_key_file);
727 g_free(config->private_key_passphrase);
728 config->private_key_passphrase = fsid;
731 if (config->private_key_passphrase != NULL) {
732 __connman_service_set_string(service, "PrivateKeyPassphrase",
733 config->private_key_passphrase);
735 * TODO: Support for PEAP with both identity and key passwd.
736 * In that case, we should check if both of them are found
737 * from the config file. If not, we should not set the
738 * service passphrase in order for the UI to request for an
739 * additional passphrase.
743 if (config->phase2 != NULL)
744 __connman_service_set_string(service, "Phase2", config->phase2);
746 if (config->passphrase != NULL)
747 __connman_service_set_string(service, "Passphrase", config->passphrase);
749 if (config->hidden == TRUE)
750 __connman_service_set_hidden(service);
752 __connman_service_mark_dirty();
754 __connman_service_save(service);
757 int __connman_config_provision_service(struct connman_service *service)
759 enum connman_service_type type;
763 DBG("service %p", service);
765 /* For now only WiFi services are supported */
766 type = connman_service_get_type(service);
767 if (type != CONNMAN_SERVICE_TYPE_WIFI)
770 g_hash_table_iter_init(&iter, config_table);
772 while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
773 struct connman_config *config = value;
775 g_hash_table_foreach(config->service_table,
776 provision_service, service);
782 int __connman_config_provision_service_ident(struct connman_service *service,
783 const char *ident, const char *file, const char *entry)
785 enum connman_service_type type;
786 struct connman_config *config;
789 DBG("service %p", service);
791 /* For now only WiFi services are supported */
792 type = connman_service_get_type(service);
793 if (type != CONNMAN_SERVICE_TYPE_WIFI)
796 config = g_hash_table_lookup(config_table, ident);
797 if (config != NULL) {
800 gboolean found = FALSE;
802 g_hash_table_iter_init(&iter, config->service_table);
805 * Check if we need to remove individual service if it
806 * is missing from config file.
808 if (file != NULL && entry != NULL) {
809 while (g_hash_table_iter_next(&iter, &key,
811 struct connman_config_service *config_service;
813 config_service = value;
815 if (g_strcmp0(config_service->config_ident,
819 if (g_strcmp0(config_service->config_entry,
827 DBG("found %d ident %s file %s entry %s", found, ident,
830 if (found == FALSE) {
832 * The entry+8 will skip "service_" prefix
834 g_hash_table_remove(config->service_table,
840 g_hash_table_foreach(config->service_table,
841 provision_service, service);
847 struct connman_config_entry **connman_config_get_entries(void)
849 GHashTableIter iter_file, iter_config;
851 struct connman_config_entry **entries = NULL;
854 g_hash_table_iter_init(&iter_file, config_table);
855 while (g_hash_table_iter_next(&iter_file, &key, &value) == TRUE) {
856 struct connman_config *config_file = value;
858 count = g_hash_table_size(config_file->service_table);
860 entries = g_try_realloc(entries, (i + count + 1) *
861 sizeof(struct connman_config_entry *));
865 g_hash_table_iter_init(&iter_config,
866 config_file->service_table);
867 while (g_hash_table_iter_next(&iter_config, &key,
869 struct connman_config_service *config = value;
871 entries[i] = g_try_new0(struct connman_config_entry,
873 if (entries[i] == NULL)
876 entries[i]->ident = g_strdup(config->ident);
877 entries[i]->name = g_strdup(config->name);
878 entries[i]->ssid = g_try_malloc0(config->ssid_len + 1);
879 if (entries[i]->ssid == NULL)
882 memcpy(entries[i]->ssid, config->ssid,
884 entries[i]->ssid_len = config->ssid_len;
885 entries[i]->hidden = config->hidden;
891 if (entries != NULL) {
892 entries = g_try_realloc(entries, (i + 1) *
893 sizeof(struct connman_config_entry *));
899 DBG("%d provisioned AP found", i);
905 connman_config_free_entries(entries);
909 void connman_config_free_entries(struct connman_config_entry **entries)
916 for (i = 0; entries[i]; i++) {
917 g_free(entries[i]->ident);
918 g_free(entries[i]->name);
919 g_free(entries[i]->ssid);