vpn/vpn-config.c

   1 /*
   2  *
   3  *  Connection Manager
   4  *
   5  *  Copyright (C) 2012-2013  Intel Corporation. All rights reserved.
   6  *
   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.
  10  *
  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.
  15  *
  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
  19  *
  20  */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <errno.h>
  27 #include <stdio.h>
  28 #include <unistd.h>
  29 #include <string.h>
  30 #include <sys/vfs.h>
  31 #include <sys/inotify.h>
  32 #include <glib.h>
  33
  34 #include <connman/log.h>
  35 #include "../src/connman.h"
  36
  37 #include "vpn.h"
  38
  39 enum what {
  40         REMOVE = 1,
  41         ADD = 2,
  42 };
  43
  44 struct vpn_config_provider {
  45         char *provider_identifier;
  46         char *ident;
  47         char *name;
  48         char *type;
  49         char *host;
  50         char *domain;
  51         char *networks;
  52         GHashTable *setting_strings;
  53
  54         char *config_ident; /* file prefix */
  55         char *config_entry; /* entry name */
  56 };
  57
  58 struct vpn_config {
  59         char *ident;
  60         char *name;
  61         char *description;
  62         GHashTable *provider_table;
  63 };
  64
  65 static GHashTable *config_table = NULL;
  66
  67 static bool cleanup = false;
  68
  69 /* Definition of possible strings in the .config files */
  70 #define CONFIG_KEY_NAME                "Name"
  71 #define CONFIG_KEY_DESC                "Description"
  72
  73 static const char *config_possible_keys[] = {
  74         CONFIG_KEY_NAME,
  75         CONFIG_KEY_DESC,
  76         NULL,
  77 };
  78
  79 static void unregister_config(gpointer data)
  80 {
  81         struct vpn_config *config = data;
  82
  83         connman_info("Removing configuration %s", config->ident);
  84
  85         g_hash_table_destroy(config->provider_table);
  86
  87         g_free(config->description);
  88         g_free(config->name);
  89         g_free(config->ident);
  90         g_free(config);
  91 }
  92
  93 static void unregister_provider(gpointer data)
  94 {
  95         struct vpn_config_provider *config_provider = data;
  96         struct vpn_provider *provider;
  97         char *provider_id;
  98
  99         if (cleanup)
 100                 goto free_only;
 101
 102         provider_id = config_provider->provider_identifier;
 103
 104         connman_info("Removing provider configuration %s provider %s",
 105                                 config_provider->ident, provider_id);
 106
 107         provider = __vpn_provider_lookup(provider_id);
 108         if (provider)
 109                 __vpn_provider_delete(provider);
 110         else {
 111                 if (!__connman_storage_remove_provider(provider_id))
 112                         DBG("Could not remove all files for provider %s",
 113                                                                 provider_id);
 114         }
 115
 116 free_only:
 117         g_free(config_provider->ident);
 118         g_free(config_provider->type);
 119         g_free(config_provider->name);
 120         g_free(config_provider->host);
 121         g_free(config_provider->domain);
 122         g_free(config_provider->networks);
 123         g_hash_table_destroy(config_provider->setting_strings);
 124         g_free(config_provider->provider_identifier);
 125         g_free(config_provider->config_ident);
 126         g_free(config_provider->config_entry);
 127         g_free(config_provider);
 128 }
 129
 130 static int set_string(struct vpn_config_provider *config_provider,
 131                                         const char *key, const char *value)
 132 {
 133         DBG("provider %p key %s value %s", config_provider, key, value);
 134
 135         if (g_str_equal(key, "Type")) {
 136                 g_free(config_provider->type);
 137                 config_provider->type = g_strdup(value);
 138         } else if (g_str_equal(key, "Name")) {
 139                 g_free(config_provider->name);
 140                 config_provider->name = g_strdup(value);
 141         } else if (g_str_equal(key, "Host")) {
 142                 g_free(config_provider->host);
 143                 config_provider->host = g_strdup(value);
 144         } else if (g_str_equal(key, "Domain")) {
 145                 g_free(config_provider->domain);
 146                 config_provider->domain = g_strdup(value);
 147         } else if (g_str_equal(key, "Networks")) {
 148                 g_free(config_provider->networks);
 149                 config_provider->networks = g_strdup(value);
 150         }
 151
 152         g_hash_table_replace(config_provider->setting_strings,
 153                                         g_strdup(key), g_strdup(value));
 154         return 0;
 155 }
 156
 157 static const char *get_string(struct vpn_config_provider *config_provider,
 158                                                         const char *key)
 159 {
 160         DBG("provider %p key %s", config_provider, key);
 161
 162         if (g_str_equal(key, "Type"))
 163                 return config_provider->type;
 164         else if (g_str_equal(key, "Name"))
 165                 return config_provider->name;
 166         else if (g_str_equal(key, "Host"))
 167                 return config_provider->host;
 168         else if (g_str_equal(key, "Domain"))
 169                 return config_provider->domain;
 170         else if (g_str_equal(key, "Networks"))
 171                 return config_provider->networks;
 172
 173         return g_hash_table_lookup(config_provider->setting_strings, key);
 174 }
 175
 176 static void add_keys(struct vpn_config_provider *config_provider,
 177                         GKeyFile *keyfile, const char *group)
 178 {
 179         char **avail_keys;
 180         gsize nb_avail_keys, i;
 181
 182         avail_keys = g_key_file_get_keys(keyfile, group, &nb_avail_keys, NULL);
 183         if (!avail_keys)
 184                 return;
 185
 186         for (i = 0 ; i < nb_avail_keys; i++) {
 187                 char *value = g_key_file_get_value(keyfile, group,
 188                                                 avail_keys[i], NULL);
 189                 if (!value) {
 190                         connman_warn("Cannot find value for %s",
 191                                                         avail_keys[i]);
 192                         continue;
 193                 }
 194
 195                 set_string(config_provider, avail_keys[i], value);
 196                 g_free(value);
 197         }
 198
 199         g_strfreev(avail_keys);
 200 }
 201
 202 static int load_provider(GKeyFile *keyfile, const char *group,
 203                                 struct vpn_config *config, enum what action)
 204 {
 205         struct vpn_config_provider *config_provider;
 206         const char *ident, *host, *domain;
 207         int err;
 208
 209         /* Strip off "provider_" prefix */
 210         ident = group + 9;
 211
 212         if (strlen(ident) < 1)
 213                 return -EINVAL;
 214
 215         config_provider = g_hash_table_lookup(config->provider_table, ident);
 216         if (config_provider)
 217                 return -EALREADY;
 218
 219         config_provider = g_try_new0(struct vpn_config_provider, 1);
 220         if (!config_provider)
 221                 return -ENOMEM;
 222
 223         config_provider->ident = g_strdup(ident);
 224
 225         config_provider->setting_strings = g_hash_table_new_full(g_str_hash,
 226                                                 g_str_equal, g_free, g_free);
 227
 228         add_keys(config_provider, keyfile, group);
 229
 230         host = get_string(config_provider, "Host");
 231         domain = get_string(config_provider, "Domain");
 232         if (host && domain) {
 233                 char *id = __vpn_provider_create_identifier(host, domain);
 234
 235                 struct vpn_provider *provider;
 236                 provider = __vpn_provider_lookup(id);
 237                 if (provider) {
 238                         if (action == REMOVE) {
 239                                 __vpn_provider_delete(provider);
 240                                 err = 0;
 241                         } else {
 242                                 connman_warn("Provider configuration %s "
 243                                                 "already exist", id);
 244                                 err = -EALREADY;
 245                         }
 246
 247                         g_free(id);
 248                         goto err;
 249                 }
 250
 251                 config_provider->provider_identifier = id;
 252
 253                 DBG("provider identifier %s", id);
 254         } else {
 255                 DBG("invalid values host %s domain %s", host, domain);
 256                 err = -EINVAL;
 257                 goto err;
 258         }
 259
 260         config_provider->config_ident = g_strdup(config->ident);
 261         config_provider->config_entry = g_strdup_printf("provider_%s",
 262                                                 config_provider->ident);
 263
 264         g_hash_table_insert(config->provider_table,
 265                                 config_provider->ident, config_provider);
 266
 267         err = __vpn_provider_create_from_config(
 268                                         config_provider->setting_strings,
 269                                         config_provider->config_ident,
 270                                         config_provider->config_entry);
 271         if (err != 0) {
 272                 DBG("Cannot create provider from config file (%d/%s)",
 273                         -err, strerror(-err));
 274                 goto err;
 275         }
 276
 277         connman_info("Added provider configuration %s",
 278                                                 config_provider->ident);
 279         return 0;
 280
 281 err:
 282         g_free(config_provider->ident);
 283         g_free(config_provider->type);
 284         g_free(config_provider->name);
 285         g_free(config_provider->host);
 286         g_free(config_provider->domain);
 287         g_free(config_provider->networks);
 288         g_hash_table_destroy(config_provider->setting_strings);
 289         g_free(config_provider);
 290
 291         return err;
 292 }
 293
 294 static void check_keys(GKeyFile *keyfile, const char *group,
 295                         const char **possible_keys)
 296 {
 297         char **avail_keys;
 298         gsize nb_avail_keys, i, j;
 299
 300         avail_keys = g_key_file_get_keys(keyfile, group, &nb_avail_keys, NULL);
 301         if (!avail_keys)
 302                 return;
 303
 304         for (i = 0 ; i < nb_avail_keys; i++) {
 305                 for (j = 0; possible_keys[j] ; j++)
 306                         if (g_strcmp0(avail_keys[i], possible_keys[j]) == 0)
 307                                 break;
 308
 309                 if (!possible_keys[j])
 310                         connman_warn("Unknown configuration key %s in [%s]",
 311                                         avail_keys[i], group);
 312         }
 313
 314         g_strfreev(avail_keys);
 315 }
 316
 317 static int load_config(struct vpn_config *config, char *path, enum what action)
 318 {
 319         GKeyFile *keyfile;
 320         gsize length;
 321         char **groups;
 322         char *str;
 323         bool found = false;
 324         int i;
 325
 326         DBG("config %p", config);
 327
 328         keyfile = __connman_storage_load_provider_config(config->ident);
 329         if (!keyfile)
 330                 return -EIO;
 331
 332         /* Verify keys validity of the global section */
 333         check_keys(keyfile, "global", config_possible_keys);
 334
 335         str = __vpn_config_get_string(keyfile, "global", CONFIG_KEY_NAME, NULL);
 336         if (str) {
 337                 g_free(config->name);
 338                 config->name = str;
 339         }
 340
 341         str = __vpn_config_get_string(keyfile, "global", CONFIG_KEY_DESC, NULL);
 342         if (str) {
 343                 g_free(config->description);
 344                 config->description = str;
 345         }
 346
 347         groups = g_key_file_get_groups(keyfile, &length);
 348
 349         for (i = 0; groups[i]; i++) {
 350                 if (g_str_has_prefix(groups[i], "provider_")) {
 351                         int ret = load_provider(keyfile, groups[i], config,
 352                                                 action);
 353                         if (ret == 0 || ret == -EALREADY)
 354                                 found = true;
 355                 }
 356         }
 357
 358         if (!found)
 359                 connman_warn("Config file %s/%s.config does not contain any "
 360                         "configuration that can be provisioned!",
 361                         path, config->ident);
 362
 363         g_strfreev(groups);
 364
 365         g_key_file_free(keyfile);
 366
 367         return 0;
 368 }
 369
 370 static struct vpn_config *create_config(const char *ident)
 371 {
 372         struct vpn_config *config;
 373
 374         DBG("ident %s", ident);
 375
 376         if (g_hash_table_lookup(config_table, ident))
 377                 return NULL;
 378
 379         config = g_try_new0(struct vpn_config, 1);
 380         if (!config)
 381                 return NULL;
 382
 383         config->ident = g_strdup(ident);
 384
 385         config->provider_table = g_hash_table_new_full(g_str_hash, g_str_equal,
 386                                                 NULL, unregister_provider);
 387
 388         g_hash_table_insert(config_table, config->ident, config);
 389
 390         connman_info("Adding configuration %s", config->ident);
 391
 392         return config;
 393 }
 394
 395 static bool validate_ident(const char *ident)
 396 {
 397         unsigned int i;
 398
 399         if (!ident)
 400                 return false;
 401
 402         for (i = 0; i < strlen(ident); i++)
 403                 if (!g_ascii_isprint(ident[i]))
 404                         return false;
 405
 406         return true;
 407 }
 408
 409 static char *get_dir(void)
 410 {
 411         return g_strdup_printf("%s", VPN_STORAGEDIR);
 412 }
 413
 414 static int read_configs(void)
 415 {
 416         GDir *dir;
 417         char *path = get_dir();
 418
 419         DBG("path %s", path);
 420
 421         dir = g_dir_open(path, 0, NULL);
 422         if (dir) {
 423                 const gchar *file;
 424
 425                 while ((file = g_dir_read_name(dir))) {
 426                         GString *str;
 427                         gchar *ident;
 428
 429                         if (!g_str_has_suffix(file, ".config"))
 430                                 continue;
 431
 432                         ident = g_strrstr(file, ".config");
 433                         if (!ident)
 434                                 continue;
 435
 436                         str = g_string_new_len(file, ident - file);
 437                         if (!str)
 438                                 continue;
 439
 440                         ident = g_string_free(str, FALSE);
 441
 442                         if (validate_ident(ident)) {
 443                                 struct vpn_config *config;
 444
 445                                 config = create_config(ident);
 446                                 if (config)
 447                                         load_config(config, path, ADD);
 448                         } else {
 449                                 connman_error("Invalid config ident %s", ident);
 450                         }
 451                         g_free(ident);
 452                 }
 453
 454                 g_dir_close(dir);
 455         }
 456
 457         g_free(path);
 458
 459         return 0;
 460 }
 461
 462 static void config_notify_handler(struct inotify_event *event,
 463                                         const char *ident)
 464 {
 465         char *ext;
 466
 467         if (!ident)
 468                 return;
 469
 470         if (!g_str_has_suffix(ident, ".config"))
 471                 return;
 472
 473         ext = g_strrstr(ident, ".config");
 474         if (!ext)
 475                 return;
 476
 477         *ext = '\0';
 478
 479         if (!validate_ident(ident)) {
 480                 connman_error("Invalid config ident %s", ident);
 481                 return;
 482         }
 483
 484         if (event->mask & IN_CREATE)
 485                 return;
 486
 487         if (event->mask & (IN_DELETE | IN_MOVED_FROM)) {
 488                 g_hash_table_remove(config_table, ident);
 489                 return;
 490         }
 491
 492         if (event->mask & (IN_MODIFY | IN_MOVED_TO)) {
 493                 struct vpn_config *config;
 494                 char *path = get_dir();
 495
 496                 config = g_hash_table_lookup(config_table, ident);
 497                 if (config) {
 498                         g_hash_table_remove_all(config->provider_table);
 499                         load_config(config, path, REMOVE);
 500
 501                         /* Re-scan the config file for any changes */
 502                         g_hash_table_remove_all(config->provider_table);
 503                         load_config(config, path, ADD);
 504                 } else {
 505                         /*
 506                          * Inotify will send create event followed by modify
 507                          * event for any config file that is copied to
 508                          * monitored directory. So in practice we should just
 509                          * ignore the create event and trust only the modify
 510                          * one in order to avoid create/remove/create loop
 511                          */
 512                         config = create_config(ident);
 513                         if (config)
 514                                 load_config(config, path, ADD);
 515                 }
 516
 517                 g_free(path);
 518         }
 519 }
 520
 521 int __vpn_config_init(void)
 522 {
 523         char *dir = get_dir();
 524
 525         DBG("");
 526
 527         config_table = g_hash_table_new_full(g_str_hash, g_str_equal,
 528                                                 NULL, unregister_config);
 529
 530         connman_inotify_register(dir, config_notify_handler);
 531
 532         g_free(dir);
 533
 534         return read_configs();
 535 }
 536
 537 void __vpn_config_cleanup(void)
 538 {
 539         char *dir = get_dir();
 540
 541         DBG("");
 542
 543         cleanup = true;
 544
 545         connman_inotify_unregister(dir, config_notify_handler);
 546
 547         g_free(dir);
 548
 549         g_hash_table_destroy(config_table);
 550         config_table = NULL;
 551
 552         cleanup = false;
 553 }
 554
 555 char *__vpn_config_get_string(GKeyFile *key_file,
 556         const char *group_name, const char *key, GError **error)
 557 {
 558         char *str = g_key_file_get_string(key_file, group_name, key, error);
 559         if (!str)
 560                 return NULL;
 561
 562         return g_strchomp(str);
 563 }
 564
 565 char **__vpn_config_get_string_list(GKeyFile *key_file,
 566         const char *group_name, const char *key, gsize *length, GError **error)
 567 {
 568         char **p;
 569         char **strlist = g_key_file_get_string_list(key_file, group_name, key,
 570                 length, error);
 571         if (!strlist)
 572                 return NULL;
 573
 574         p = strlist;
 575         while (*p) {
 576                 *p = g_strstrip(*p);
 577                 p++;
 578         }
 579
 580         return strlist;
 581 }