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 int inotify_wd = -1;
71 static GIOChannel *inotify_channel = NULL;
72 static uint inotify_watch = 0;
73 static connman_bool_t cleanup = FALSE;
75 #define INTERNAL_CONFIG_PREFIX "__internal"
77 /* Definition of possible strings in the .config files */
78 #define CONFIG_KEY_NAME "Name"
79 #define CONFIG_KEY_DESC "Description"
80 #define CONFIG_KEY_PROT "Protected"
82 #define SERVICE_KEY_TYPE "Type"
83 #define SERVICE_KEY_NAME "Name"
84 #define SERVICE_KEY_SSID "SSID"
85 #define SERVICE_KEY_EAP "EAP"
86 #define SERVICE_KEY_CA_CERT "CACertFile"
87 #define SERVICE_KEY_CL_CERT "ClientCertFile"
88 #define SERVICE_KEY_PRV_KEY "PrivateKeyFile"
89 #define SERVICE_KEY_PRV_KEY_PASS "PrivateKeyPassphrase"
90 #define SERVICE_KEY_PRV_KEY_PASS_TYPE "PrivateKeyPassphraseType"
91 #define SERVICE_KEY_IDENTITY "Identity"
92 #define SERVICE_KEY_PHASE2 "Phase2"
93 #define SERVICE_KEY_PASSPHRASE "Passphrase"
94 #define SERVICE_KEY_HIDDEN "Hidden"
96 static const char *config_possible_keys[] = {
103 static const char *service_possible_keys[] = {
111 SERVICE_KEY_PRV_KEY_PASS,
112 SERVICE_KEY_PRV_KEY_PASS_TYPE,
113 SERVICE_KEY_IDENTITY,
115 SERVICE_KEY_PASSPHRASE,
120 static void unregister_config(gpointer data)
122 struct connman_config *config = data;
124 connman_info("Removing configuration %s", config->ident);
126 g_hash_table_destroy(config->service_table);
128 g_free(config->description);
129 g_free(config->name);
130 g_free(config->ident);
134 static void unregister_service(gpointer data)
136 struct connman_config_service *config_service = data;
137 struct connman_service *service;
144 connman_info("Removing service configuration %s",
145 config_service->ident);
147 protected_services = g_slist_remove(protected_services,
150 for (list = config_service->service_identifiers; list != NULL;
152 service_id = list->data;
154 service = __connman_service_lookup_from_ident(service_id);
155 if (service != NULL) {
156 __connman_service_set_immutable(service, FALSE);
157 __connman_service_remove(service);
160 if (__connman_storage_remove_service(service_id) == FALSE)
161 DBG("Could not remove all files for service %s",
166 g_free(config_service->ident);
167 g_free(config_service->type);
168 g_free(config_service->name);
169 g_free(config_service->ssid);
170 g_free(config_service->eap);
171 g_free(config_service->identity);
172 g_free(config_service->ca_cert_file);
173 g_free(config_service->client_cert_file);
174 g_free(config_service->private_key_file);
175 g_free(config_service->private_key_passphrase);
176 g_free(config_service->private_key_passphrase_type);
177 g_free(config_service->phase2);
178 g_free(config_service->passphrase);
179 g_slist_free_full(config_service->service_identifiers, g_free);
180 g_free(config_service->config_ident);
181 g_free(config_service->config_entry);
182 g_free(config_service);
185 static void check_keys(GKeyFile *keyfile, const char *group,
186 const char **possible_keys)
189 gsize nb_avail_keys, i, j;
191 avail_keys = g_key_file_get_keys(keyfile, group, &nb_avail_keys, NULL);
192 if (avail_keys == NULL)
196 * For each key in the configuration file,
197 * verify it is understood by connman
199 for (i = 0 ; i < nb_avail_keys; i++) {
200 for (j = 0; possible_keys[j] ; j++)
201 if (g_strcmp0(avail_keys[i], possible_keys[j]) == 0)
204 if (possible_keys[j] == NULL)
205 connman_warn("Unknown configuration key %s in [%s]",
206 avail_keys[i], group);
209 g_strfreev(avail_keys);
212 static connman_bool_t
213 is_protected_service(struct connman_config_service *service)
217 DBG("ident %s", service->ident);
219 for (list = protected_services; list; list = list->next) {
220 struct connman_config_service *s = list->data;
222 if (g_strcmp0(s->type, service->type) != 0)
225 if (s->ssid == NULL || service->ssid == NULL)
228 if (s->ssid_len != service->ssid_len)
231 if (g_strcmp0(service->type, "wifi") == 0 &&
232 strncmp(s->ssid, service->ssid, s->ssid_len) == 0) {
240 static int load_service(GKeyFile *keyfile, const char *group,
241 struct connman_config *config)
243 struct connman_config_service *service;
245 char *str, *hex_ssid;
246 gboolean service_created = FALSE;
249 /* Strip off "service_" prefix */
252 if (strlen(ident) < 1)
255 /* Verify that provided keys are good */
256 check_keys(keyfile, group, service_possible_keys);
258 service = g_hash_table_lookup(config->service_table, ident);
259 if (service == NULL) {
260 service = g_try_new0(struct connman_config_service, 1);
264 service->ident = g_strdup(ident);
266 service_created = TRUE;
269 str = g_key_file_get_string(keyfile, group, SERVICE_KEY_TYPE, NULL);
271 g_free(service->type);
275 str = g_key_file_get_string(keyfile, group, SERVICE_KEY_NAME, NULL);
277 g_free(service->name);
281 hex_ssid = g_key_file_get_string(keyfile, group, SERVICE_KEY_SSID,
283 if (hex_ssid != NULL) {
285 unsigned int i, j = 0, hex;
286 size_t hex_ssid_len = strlen(hex_ssid);
288 ssid = g_try_malloc0(hex_ssid_len / 2);
295 for (i = 0; i < hex_ssid_len; i += 2) {
296 if (sscanf(hex_ssid + i, "%02x", &hex) <= 0) {
297 connman_warn("Invalid SSID %s", hex_ssid);
308 g_free(service->ssid);
309 service->ssid = ssid;
310 service->ssid_len = hex_ssid_len / 2;
311 } else if (service->name != NULL) {
313 unsigned int ssid_len;
315 ssid_len = strlen(service->name);
316 ssid = g_try_malloc0(ssid_len);
322 memcpy(ssid, service->name, ssid_len);
323 g_free(service->ssid);
324 service->ssid = ssid;
325 service->ssid_len = ssid_len;
328 if (is_protected_service(service) == TRUE) {
329 connman_error("Trying to provision a protected service");
334 str = g_key_file_get_string(keyfile, group, SERVICE_KEY_EAP, NULL);
336 g_free(service->eap);
340 str = g_key_file_get_string(keyfile, group, SERVICE_KEY_CA_CERT, NULL);
342 g_free(service->ca_cert_file);
343 service->ca_cert_file = str;
346 str = g_key_file_get_string(keyfile, group, SERVICE_KEY_CL_CERT, NULL);
348 g_free(service->client_cert_file);
349 service->client_cert_file = str;
352 str = g_key_file_get_string(keyfile, group, SERVICE_KEY_PRV_KEY, NULL);
354 g_free(service->private_key_file);
355 service->private_key_file = str;
358 str = g_key_file_get_string(keyfile, group,
359 SERVICE_KEY_PRV_KEY_PASS, NULL);
361 g_free(service->private_key_passphrase);
362 service->private_key_passphrase = str;
365 str = g_key_file_get_string(keyfile, group,
366 SERVICE_KEY_PRV_KEY_PASS_TYPE, NULL);
368 g_free(service->private_key_passphrase_type);
369 service->private_key_passphrase_type = str;
372 str = g_key_file_get_string(keyfile, group, SERVICE_KEY_IDENTITY, NULL);
374 g_free(service->identity);
375 service->identity = str;
378 str = g_key_file_get_string(keyfile, group, SERVICE_KEY_PHASE2, NULL);
380 g_free(service->phase2);
381 service->phase2 = str;
384 str = g_key_file_get_string(keyfile, group, SERVICE_KEY_PASSPHRASE,
387 g_free(service->passphrase);
388 service->passphrase = str;
391 service->config_ident = g_strdup(config->ident);
392 service->config_entry = g_strdup_printf("service_%s", service->ident);
394 service->hidden = g_key_file_get_boolean(keyfile, group,
395 SERVICE_KEY_HIDDEN, NULL);
398 g_hash_table_insert(config->service_table, service->ident,
401 if (config->protected == TRUE)
403 g_slist_prepend(protected_services, service);
405 connman_info("Adding service configuration %s", service->ident);
410 if (service_created == TRUE) {
411 g_free(service->ident);
412 g_free(service->type);
413 g_free(service->name);
414 g_free(service->ssid);
421 static int load_config(struct connman_config *config)
424 GError *error = NULL;
428 gboolean protected, found = FALSE;
431 DBG("config %p", config);
433 keyfile = __connman_storage_load_config(config->ident);
437 /* Verify keys validity of the global section */
438 check_keys(keyfile, "global", config_possible_keys);
440 str = g_key_file_get_string(keyfile, "global", CONFIG_KEY_NAME, NULL);
442 g_free(config->name);
446 str = g_key_file_get_string(keyfile, "global", CONFIG_KEY_DESC, NULL);
448 g_free(config->description);
449 config->description = str;
452 protected = g_key_file_get_boolean(keyfile, "global",
453 CONFIG_KEY_PROT, &error);
455 config->protected = protected;
457 config->protected = TRUE;
458 g_clear_error(&error);
460 groups = g_key_file_get_groups(keyfile, &length);
462 for (i = 0; groups[i] != NULL; i++) {
463 if (g_str_has_prefix(groups[i], "service_") == TRUE) {
464 if (load_service(keyfile, groups[i], config) == 0)
470 connman_warn("Config file %s/%s.config does not contain any "
471 "configuration that can be provisioned!",
472 STORAGEDIR, config->ident);
476 g_key_file_free(keyfile);
481 static struct connman_config *create_config(const char *ident)
483 struct connman_config *config;
485 DBG("ident %s", ident);
487 if (g_hash_table_lookup(config_table, ident) != NULL)
490 config = g_try_new0(struct connman_config, 1);
494 config->ident = g_strdup(ident);
496 config->service_table = g_hash_table_new_full(g_str_hash, g_str_equal,
497 NULL, unregister_service);
499 g_hash_table_insert(config_table, config->ident, config);
501 connman_info("Adding configuration %s", config->ident);
506 static connman_bool_t validate_ident(const char *ident)
513 for (i = 0; i < strlen(ident); i++)
514 if (g_ascii_isprint(ident[i]) == FALSE)
520 static int read_configs(void)
526 dir = g_dir_open(STORAGEDIR, 0, NULL);
530 while ((file = g_dir_read_name(dir)) != NULL) {
534 if (g_str_has_suffix(file, ".config") == FALSE)
537 ident = g_strrstr(file, ".config");
541 str = g_string_new_len(file, ident - file);
545 ident = g_string_free(str, FALSE);
547 if (validate_ident(ident) == TRUE) {
548 struct connman_config *config;
550 config = create_config(ident);
554 connman_error("Invalid config ident %s", ident);
565 static void config_notify_handler(struct inotify_event *event,
573 if (g_str_has_suffix(ident, ".config") == FALSE)
576 ext = g_strrstr(ident, ".config");
582 if (validate_ident(ident) == FALSE) {
583 connman_error("Invalid config ident %s", ident);
587 if (event->mask & IN_CREATE)
588 create_config(ident);
590 if (event->mask & IN_MODIFY) {
591 struct connman_config *config;
593 config = g_hash_table_lookup(config_table, ident);
594 if (config != NULL) {
597 g_hash_table_remove_all(config->service_table);
599 ret = __connman_service_provision_changed(ident);
602 * Re-scan the config file for any
605 g_hash_table_remove_all(config->service_table);
607 __connman_service_provision_changed(ident);
612 if (event->mask & IN_DELETE)
613 g_hash_table_remove(config_table, ident);
616 static gboolean inotify_data(GIOChannel *channel, GIOCondition cond,
624 if (cond & (G_IO_NVAL | G_IO_ERR | G_IO_HUP)) {
629 status = g_io_channel_read_chars(channel, buffer,
630 sizeof(buffer) -1, &bytes_read, NULL);
633 case G_IO_STATUS_NORMAL:
635 case G_IO_STATUS_AGAIN:
638 connman_error("Reading from inotify channel failed");
645 while (bytes_read > 0) {
646 struct inotify_event *event;
650 event = (struct inotify_event *) next_event;
652 ident = next_event + sizeof(struct inotify_event);
656 len = sizeof(struct inotify_event) + event->len;
658 /* check if inotify_event block fit */
659 if (len > bytes_read)
665 config_notify_handler(event, ident);
671 static int create_watch(void)
679 inotify_wd = inotify_add_watch(fd, STORAGEDIR,
680 IN_MODIFY | IN_CREATE | IN_DELETE);
681 if (inotify_wd < 0) {
682 connman_error("Creation of STORAGEDIR watch failed");
687 inotify_channel = g_io_channel_unix_new(fd);
688 if (inotify_channel == NULL) {
689 connman_error("Creation of inotify channel failed");
690 inotify_rm_watch(fd, inotify_wd);
697 g_io_channel_set_close_on_unref(inotify_channel, TRUE);
698 g_io_channel_set_encoding(inotify_channel, NULL, NULL);
699 g_io_channel_set_buffered(inotify_channel, FALSE);
701 inotify_watch = g_io_add_watch(inotify_channel,
702 G_IO_IN | G_IO_HUP | G_IO_NVAL | G_IO_ERR,
708 static void remove_watch(void)
712 if (inotify_channel == NULL)
715 if (inotify_watch > 0) {
716 g_source_remove(inotify_watch);
720 fd = g_io_channel_unix_get_fd(inotify_channel);
722 if (inotify_wd >= 0) {
723 inotify_rm_watch(fd, inotify_wd);
727 g_io_channel_unref(inotify_channel);
730 int __connman_config_init(void)
734 config_table = g_hash_table_new_full(g_str_hash, g_str_equal,
735 NULL, unregister_config);
739 return read_configs();
742 void __connman_config_cleanup(void)
750 g_hash_table_destroy(config_table);
756 static char *config_pem_fsid(const char *pem_file)
759 unsigned *fsid = (unsigned *) &buf.f_fsid;
760 unsigned long long fsid64;
762 if (pem_file == NULL)
765 if (statfs(pem_file, &buf) < 0) {
766 connman_error("statfs error %s for %s",
767 strerror(errno), pem_file);
771 fsid64 = ((unsigned long long) fsid[0] << 32) | fsid[1];
773 return g_strdup_printf("%llx", fsid64);
776 static void provision_service(gpointer key, gpointer value, gpointer user_data)
778 struct connman_service *service = user_data;
779 struct connman_config_service *config = value;
780 struct connman_network *network;
781 const void *ssid, *service_id;
782 unsigned int ssid_len;
784 /* For now only WiFi service entries are supported */
785 if (g_strcmp0(config->type, "wifi") != 0)
788 network = __connman_service_get_network(service);
789 if (network == NULL) {
790 connman_error("Service has no network set");
794 ssid = connman_network_get_blob(network, "WiFi.SSID", &ssid_len);
796 connman_error("Network SSID not set");
800 if (config->ssid == NULL || ssid_len != config->ssid_len)
803 if (memcmp(config->ssid, ssid, ssid_len) != 0)
806 service_id = __connman_service_get_ident(service);
807 config->service_identifiers =
808 g_slist_prepend(config->service_identifiers,
809 g_strdup(service_id));
811 __connman_service_set_immutable(service, TRUE);
813 __connman_service_set_favorite_delayed(service, TRUE, TRUE);
815 __connman_service_set_config(service, config->config_ident,
816 config->config_entry);
818 if (config->eap != NULL)
819 __connman_service_set_string(service, "EAP", config->eap);
821 if (config->identity != NULL)
822 __connman_service_set_string(service, "Identity",
825 if (config->ca_cert_file != NULL)
826 __connman_service_set_string(service, "CACertFile",
827 config->ca_cert_file);
829 if (config->client_cert_file != NULL)
830 __connman_service_set_string(service, "ClientCertFile",
831 config->client_cert_file);
833 if (config->private_key_file != NULL)
834 __connman_service_set_string(service, "PrivateKeyFile",
835 config->private_key_file);
837 if (g_strcmp0(config->private_key_passphrase_type, "fsid") == 0 &&
838 config->private_key_file != NULL) {
841 fsid = config_pem_fsid(config->private_key_file);
845 g_free(config->private_key_passphrase);
846 config->private_key_passphrase = fsid;
849 if (config->private_key_passphrase != NULL) {
850 __connman_service_set_string(service, "PrivateKeyPassphrase",
851 config->private_key_passphrase);
853 * TODO: Support for PEAP with both identity and key passwd.
854 * In that case, we should check if both of them are found
855 * from the config file. If not, we should not set the
856 * service passphrase in order for the UI to request for an
857 * additional passphrase.
861 if (config->phase2 != NULL)
862 __connman_service_set_string(service, "Phase2", config->phase2);
864 if (config->passphrase != NULL)
865 __connman_service_set_string(service, "Passphrase", config->passphrase);
867 if (config->hidden == TRUE)
868 __connman_service_set_hidden(service);
870 __connman_service_mark_dirty();
872 __connman_service_save(service);
875 int __connman_config_provision_service(struct connman_service *service)
877 enum connman_service_type type;
881 DBG("service %p", service);
883 /* For now only WiFi services are supported */
884 type = connman_service_get_type(service);
885 if (type != CONNMAN_SERVICE_TYPE_WIFI)
888 g_hash_table_iter_init(&iter, config_table);
890 while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {
891 struct connman_config *config = value;
893 g_hash_table_foreach(config->service_table,
894 provision_service, service);
900 int __connman_config_provision_service_ident(struct connman_service *service,
901 const char *ident, const char *file, const char *entry)
903 enum connman_service_type type;
904 struct connman_config *config;
907 DBG("service %p", service);
909 /* For now only WiFi services are supported */
910 type = connman_service_get_type(service);
911 if (type != CONNMAN_SERVICE_TYPE_WIFI)
914 config = g_hash_table_lookup(config_table, ident);
915 if (config != NULL) {
918 gboolean found = FALSE;
920 g_hash_table_iter_init(&iter, config->service_table);
923 * Check if we need to remove individual service if it
924 * is missing from config file.
926 if (file != NULL && entry != NULL) {
927 while (g_hash_table_iter_next(&iter, &key,
929 struct connman_config_service *config_service;
931 config_service = value;
933 if (g_strcmp0(config_service->config_ident,
937 if (g_strcmp0(config_service->config_entry,
945 DBG("found %d ident %s file %s entry %s", found, ident,
948 if (found == FALSE) {
950 * The entry+8 will skip "service_" prefix
952 g_hash_table_remove(config->service_table,
958 g_hash_table_foreach(config->service_table,
959 provision_service, service);
965 struct connman_config_entry **connman_config_get_entries(void)
967 GHashTableIter iter_file, iter_config;
969 struct connman_config_entry **entries = NULL;
972 g_hash_table_iter_init(&iter_file, config_table);
973 while (g_hash_table_iter_next(&iter_file, &key, &value) == TRUE) {
974 struct connman_config *config_file = value;
976 count = g_hash_table_size(config_file->service_table);
978 entries = g_try_realloc(entries, (i + count + 1) *
979 sizeof(struct connman_config_entry *));
983 g_hash_table_iter_init(&iter_config,
984 config_file->service_table);
985 while (g_hash_table_iter_next(&iter_config, &key,
987 struct connman_config_service *config = value;
989 entries[i] = g_try_new0(struct connman_config_entry,
991 if (entries[i] == NULL)
994 entries[i]->ident = g_strdup(config->ident);
995 entries[i]->name = g_strdup(config->name);
996 entries[i]->ssid = g_try_malloc0(config->ssid_len + 1);
997 if (entries[i]->ssid == NULL)
1000 memcpy(entries[i]->ssid, config->ssid,
1002 entries[i]->ssid_len = config->ssid_len;
1003 entries[i]->hidden = config->hidden;
1009 if (entries != NULL) {
1010 entries = g_try_realloc(entries, (i + 1) *
1011 sizeof(struct connman_config_entry *));
1012 if (entries == NULL)
1017 DBG("%d provisioned AP found", i);
1023 connman_config_free_entries(entries);
1027 void connman_config_free_entries(struct connman_config_entry **entries)
1031 if (entries == NULL)
1034 for (i = 0; entries[i]; i++) {
1035 g_free(entries[i]->ident);
1036 g_free(entries[i]->name);
1037 g_free(entries[i]->ssid);