src/config.c

   1 /*
   2  *
   3  *  Connection Manager
   4  *
   5  *  Copyright (C) 2007-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 <stdlib.h>
  29 #include <unistd.h>
  30 #include <string.h>
  31 #include <sys/vfs.h>
  32 #include <sys/inotify.h>
  33 #include <netdb.h>
  34 #include <glib.h>
  35
  36 #include <connman/provision.h>
  37 #include <connman/ipaddress.h>
  38 #include "connman.h"
  39
  40 struct connman_config_service {
  41         char *ident;
  42         char *name;
  43         char *type;
  44         void *ssid;
  45         unsigned int ssid_len;
  46         char *eap;
  47         char *identity;
  48         char *anonymous_identity;
  49         char *ca_cert_file;
  50         char *subject_match;
  51         char *altsubject_match;
  52         char *domain_suffix_match;
  53         char *domain_match;
  54         char *client_cert_file;
  55         char *private_key_file;
  56         char *private_key_passphrase;
  57         char *private_key_passphrase_type;
  58         char *phase2;
  59         char *passphrase;
  60         enum connman_service_security security;
  61         GSList *service_identifiers;
  62         char *config_ident; /* file prefix */
  63         char *config_entry; /* entry name */
  64         bool hidden;
  65         bool virtual;
  66         char *virtual_file;
  67         char *ipv4_address;
  68         char *ipv4_netmask;
  69         char *ipv4_gateway;
  70         char *ipv6_address;
  71         unsigned char ipv6_prefix_length;
  72         char *ipv6_gateway;
  73         char *ipv6_privacy;
  74         char *mac;
  75         char *devname;
  76         bool mdns;
  77         char **nameservers;
  78         char **search_domains;
  79         char **timeservers;
  80         char *domain_name;
  81 };
  82
  83 struct connman_config {
  84         char *ident;
  85         char *name;
  86         char *description;
  87         GHashTable *service_table;
  88 };
  89
  90 static GHashTable *config_table = NULL;
  91
  92 static bool cleanup = false;
  93
  94 /* Definition of possible strings in the .config files */
  95 #define CONFIG_KEY_NAME                "Name"
  96 #define CONFIG_KEY_DESC                "Description"
  97
  98 #define SERVICE_KEY_TYPE               "Type"
  99 #define SERVICE_KEY_NAME               "Name"
 100 #define SERVICE_KEY_SSID               "SSID"
 101 #define SERVICE_KEY_EAP                "EAP"
 102 #define SERVICE_KEY_CA_CERT            "CACertFile"
 103 #define SERVICE_KEY_CL_CERT            "ClientCertFile"
 104 #define SERVICE_KEY_PRV_KEY            "PrivateKeyFile"
 105 #define SERVICE_KEY_PRV_KEY_PASS       "PrivateKeyPassphrase"
 106 #define SERVICE_KEY_PRV_KEY_PASS_TYPE  "PrivateKeyPassphraseType"
 107 #define SERVICE_KEY_IDENTITY           "Identity"
 108 #define SERVICE_KEY_ANONYMOUS_IDENTITY "AnonymousIdentity"
 109 #define SERVICE_KEY_SUBJECT_MATCH      "SubjectMatch"
 110 #define SERVICE_KEY_ALT_SUBJECT_MATCH  "AltSubjectMatch"
 111 #define SERVICE_KEY_DOMAIN_SUFF_MATCH  "DomainSuffixMatch"
 112 #define SERVICE_KEY_DOMAIN_MATCH       "DomainMatch"
 113 #define SERVICE_KEY_PHASE2             "Phase2"
 114 #define SERVICE_KEY_PASSPHRASE         "Passphrase"
 115 #define SERVICE_KEY_SECURITY           "Security"
 116 #define SERVICE_KEY_HIDDEN             "Hidden"
 117 #define SERVICE_KEY_MDNS               "mDNS"
 118
 119 #define SERVICE_KEY_IPv4               "IPv4"
 120 #define SERVICE_KEY_IPv6               "IPv6"
 121 #define SERVICE_KEY_IPv6_PRIVACY       "IPv6.Privacy"
 122 #define SERVICE_KEY_MAC                "MAC"
 123 #define SERVICE_KEY_DEVICE_NAME        "DeviceName"
 124 #define SERVICE_KEY_NAMESERVERS        "Nameservers"
 125 #define SERVICE_KEY_SEARCH_DOMAINS     "SearchDomains"
 126 #define SERVICE_KEY_TIMESERVERS        "Timeservers"
 127 #define SERVICE_KEY_DOMAIN             "Domain"
 128
 129 static const char *config_possible_keys[] = {
 130         CONFIG_KEY_NAME,
 131         CONFIG_KEY_DESC,
 132         NULL,
 133 };
 134
 135 static const char *service_possible_keys[] = {
 136         SERVICE_KEY_TYPE,
 137         SERVICE_KEY_NAME,
 138         SERVICE_KEY_SSID,
 139         SERVICE_KEY_EAP,
 140         SERVICE_KEY_CA_CERT,
 141         SERVICE_KEY_CL_CERT,
 142         SERVICE_KEY_PRV_KEY,
 143         SERVICE_KEY_PRV_KEY_PASS,
 144         SERVICE_KEY_PRV_KEY_PASS_TYPE,
 145         SERVICE_KEY_IDENTITY,
 146         SERVICE_KEY_ANONYMOUS_IDENTITY,
 147         SERVICE_KEY_SUBJECT_MATCH,
 148         SERVICE_KEY_ALT_SUBJECT_MATCH,
 149         SERVICE_KEY_DOMAIN_SUFF_MATCH,
 150         SERVICE_KEY_DOMAIN_MATCH,
 151         SERVICE_KEY_PHASE2,
 152         SERVICE_KEY_PASSPHRASE,
 153         SERVICE_KEY_SECURITY,
 154         SERVICE_KEY_HIDDEN,
 155         SERVICE_KEY_IPv4,
 156         SERVICE_KEY_IPv6,
 157         SERVICE_KEY_IPv6_PRIVACY,
 158         SERVICE_KEY_MAC,
 159         SERVICE_KEY_DEVICE_NAME,
 160         SERVICE_KEY_MDNS,
 161         SERVICE_KEY_NAMESERVERS,
 162         SERVICE_KEY_SEARCH_DOMAINS,
 163         SERVICE_KEY_TIMESERVERS,
 164         SERVICE_KEY_DOMAIN,
 165         NULL,
 166 };
 167
 168 static void unregister_config(gpointer data)
 169 {
 170         struct connman_config *config = data;
 171
 172         connman_info("Removing configuration %s", config->ident);
 173
 174         g_hash_table_destroy(config->service_table);
 175
 176         g_free(config->description);
 177         g_free(config->name);
 178         g_free(config->ident);
 179         g_free(config);
 180 }
 181
 182 static void unregister_service(gpointer data)
 183 {
 184         struct connman_config_service *config_service = data;
 185         struct connman_service *service;
 186         char *service_id;
 187         GSList *list;
 188
 189         if (cleanup)
 190                 goto free_only;
 191
 192         connman_info("Removing service configuration %s",
 193                                                 config_service->ident);
 194
 195         if (config_service->virtual)
 196                 goto free_only;
 197
 198         for (list = config_service->service_identifiers; list;
 199                                                         list = list->next) {
 200                 service_id = list->data;
 201
 202                 service = connman_service_lookup_from_identifier(service_id);
 203                 if (service) {
 204                         __connman_service_set_immutable(service, false);
 205                         __connman_service_set_config(service, NULL, NULL);
 206                         __connman_service_remove(service);
 207
 208                         /*
 209                          * Ethernet or gadget service cannot be removed by
 210                          * __connman_service_remove() so reset the ipconfig
 211                          * here.
 212                          */
 213                         if (connman_service_get_type(service) ==
 214                                                 CONNMAN_SERVICE_TYPE_ETHERNET ||
 215                                         connman_service_get_type(service) ==
 216                                                 CONNMAN_SERVICE_TYPE_GADGET) {
 217                                 __connman_service_disconnect(service);
 218                                 __connman_service_reset_ipconfig(service,
 219                                         CONNMAN_IPCONFIG_TYPE_IPV4, NULL, NULL);
 220                                 __connman_service_reset_ipconfig(service,
 221                                         CONNMAN_IPCONFIG_TYPE_IPV6, NULL, NULL);
 222                                 __connman_service_set_ignore(service, true);
 223
 224                                 /*
 225                                  * After these operations, user needs to
 226                                  * reconnect ethernet cable to get IP
 227                                  * address.
 228                                  */
 229                         }
 230                 }
 231
 232                 if (!__connman_storage_remove_service(service_id))
 233                         DBG("Could not remove all files for service %s",
 234                                                                 service_id);
 235         }
 236
 237 free_only:
 238         g_free(config_service->ident);
 239         g_free(config_service->type);
 240         g_free(config_service->name);
 241         g_free(config_service->ssid);
 242         g_free(config_service->eap);
 243         g_free(config_service->identity);
 244         g_free(config_service->anonymous_identity);
 245         g_free(config_service->ca_cert_file);
 246         g_free(config_service->subject_match);
 247         g_free(config_service->altsubject_match);
 248         g_free(config_service->domain_suffix_match);
 249         g_free(config_service->domain_match);
 250         g_free(config_service->client_cert_file);
 251         g_free(config_service->private_key_file);
 252         g_free(config_service->private_key_passphrase);
 253         g_free(config_service->private_key_passphrase_type);
 254         g_free(config_service->phase2);
 255         g_free(config_service->passphrase);
 256         g_free(config_service->ipv4_address);
 257         g_free(config_service->ipv4_gateway);
 258         g_free(config_service->ipv4_netmask);
 259         g_free(config_service->ipv6_address);
 260         g_free(config_service->ipv6_gateway);
 261         g_free(config_service->ipv6_privacy);
 262         g_free(config_service->mac);
 263         g_free(config_service->devname);
 264         g_strfreev(config_service->nameservers);
 265         g_strfreev(config_service->search_domains);
 266         g_strfreev(config_service->timeservers);
 267         g_free(config_service->domain_name);
 268         g_slist_free_full(config_service->service_identifiers, g_free);
 269         g_free(config_service->config_ident);
 270         g_free(config_service->config_entry);
 271         g_free(config_service->virtual_file);
 272         g_free(config_service);
 273 }
 274
 275 static void check_keys(GKeyFile *keyfile, const char *group,
 276                         const char **possible_keys)
 277 {
 278         char **avail_keys;
 279         gsize nb_avail_keys, i, j;
 280
 281         avail_keys = g_key_file_get_keys(keyfile, group, &nb_avail_keys, NULL);
 282         if (!avail_keys)
 283                 return;
 284
 285         /*
 286          * For each key in the configuration file,
 287          * verify it is understood by connman
 288          */
 289         for (i = 0 ; i < nb_avail_keys; i++) {
 290                 for (j = 0; possible_keys[j] ; j++)
 291                         if (g_strcmp0(avail_keys[i], possible_keys[j]) == 0)
 292                                 break;
 293
 294                 if (!possible_keys[j])
 295                         connman_warn("Unknown configuration key %s in [%s]",
 296                                         avail_keys[i], group);
 297         }
 298
 299         g_strfreev(avail_keys);
 300 }
 301
 302 static int check_family(const char *address, int expected_family)
 303 {
 304         int family;
 305         int err = 0;
 306
 307         family = connman_inet_check_ipaddress(address);
 308         if (family < 0) {
 309                 DBG("Cannot get address family of %s (%d/%s)", address,
 310                         family, gai_strerror(family));
 311                 err = -EINVAL;
 312                 goto out;
 313         }
 314
 315         switch (family) {
 316         case AF_INET:
 317                 if (expected_family != AF_INET) {
 318                         DBG("Wrong type address %s, expecting IPv4", address);
 319                         err = -EINVAL;
 320                         goto out;
 321                 }
 322                 break;
 323         case AF_INET6:
 324                 if (expected_family != AF_INET6) {
 325                         DBG("Wrong type address %s, expecting IPv6", address);
 326                         err = -EINVAL;
 327                         goto out;
 328                 }
 329                 break;
 330         default:
 331                 DBG("Unsupported address family %d", family);
 332                 err = -EINVAL;
 333                 goto out;
 334         }
 335
 336 out:
 337         return err;
 338 }
 339
 340 static int parse_address(const char *address_str, int address_family,
 341                         char **address, char **netmask, char **gateway)
 342 {
 343         char *addr_str, *mask_str, *gw_str;
 344         int err = 0;
 345         char **route;
 346
 347         route = g_strsplit(address_str, "/", 0);
 348         if (!route)
 349                 return -EINVAL;
 350
 351         addr_str = route[0];
 352         if (!addr_str || addr_str[0] == '\0') {
 353                 err = -EINVAL;
 354                 goto out;
 355         }
 356
 357         if ((err = check_family(addr_str, address_family)) < 0)
 358                 goto out;
 359
 360         mask_str = route[1];
 361         if (!mask_str || mask_str[0] == '\0') {
 362                 err = -EINVAL;
 363                 goto out;
 364         }
 365
 366         gw_str = route[2];
 367         if (gw_str && gw_str[0]) {
 368                 if ((err = check_family(gw_str, address_family)) < 0)
 369                         goto out;
 370         }
 371
 372         g_free(*address);
 373         *address = g_strdup(addr_str);
 374
 375         g_free(*netmask);
 376         *netmask = g_strdup(mask_str);
 377
 378         g_free(*gateway);
 379         *gateway = g_strdup(gw_str);
 380
 381         if (*gateway)
 382                 DBG("address %s/%s via %s", *address, *netmask, *gateway);
 383         else
 384                 DBG("address %s/%s", *address, *netmask);
 385
 386 out:
 387         g_strfreev(route);
 388
 389         return err;
 390 }
 391
 392 static bool check_address(char *address_str, char **address)
 393 {
 394         if (g_ascii_strcasecmp(address_str, "auto") == 0 ||
 395                         g_ascii_strcasecmp(address_str, "dhcp") == 0 ||
 396                         g_ascii_strcasecmp(address_str, "off") == 0) {
 397                 *address = address_str;
 398                 return false;
 399         }
 400
 401         return true;
 402 }
 403
 404 static bool load_service_generic(GKeyFile *keyfile,
 405                         const char *group, struct connman_config *config,
 406                         struct connman_config_service *service)
 407 {
 408         char *str, *mask;
 409         char **strlist;
 410         gsize length;
 411
 412         str = __connman_config_get_string(keyfile, group, SERVICE_KEY_IPv4, NULL);
 413         if (str && check_address(str, &service->ipv4_address)) {
 414                 mask = NULL;
 415
 416                 if (parse_address(str, AF_INET, &service->ipv4_address,
 417                                         &mask, &service->ipv4_gateway) < 0) {
 418                         connman_warn("Invalid format for IPv4 address %s",
 419                                                                         str);
 420                         g_free(str);
 421                         goto err;
 422                 }
 423
 424                 if (!g_strrstr(mask, ".")) {
 425                         /* We have netmask length */
 426                         in_addr_t addr;
 427                         struct in_addr netmask_in;
 428                         unsigned char prefix_len = 32;
 429                         char *ptr;
 430                         long int value = strtol(mask, &ptr, 10);
 431
 432                         if (ptr != mask && *ptr == '\0' && value && value <= 32)
 433                                 prefix_len = value;
 434
 435                         addr = 0xffffffff << (32 - prefix_len);
 436                         netmask_in.s_addr = htonl(addr);
 437                         service->ipv4_netmask =
 438                                 g_strdup(inet_ntoa(netmask_in));
 439
 440                         g_free(mask);
 441                 } else
 442                         service->ipv4_netmask = mask;
 443
 444                 g_free(str);
 445         }
 446
 447         str =  __connman_config_get_string(keyfile, group, SERVICE_KEY_IPv6, NULL);
 448         if (str && check_address(str, &service->ipv6_address)) {
 449                 long int value;
 450                 char *ptr;
 451
 452                 mask = NULL;
 453
 454                 if (parse_address(str, AF_INET6, &service->ipv6_address,
 455                                         &mask, &service->ipv6_gateway) < 0) {
 456                         connman_warn("Invalid format for IPv6 address %s",
 457                                                                         str);
 458                         g_free(str);
 459                         goto err;
 460                 }
 461
 462                 value = strtol(mask, &ptr, 10);
 463                 if (ptr != mask && *ptr == '\0' && value <= 128)
 464                         service->ipv6_prefix_length = value;
 465                 else
 466                         service->ipv6_prefix_length = 128;
 467
 468                 g_free(mask);
 469                 g_free(str);
 470         }
 471
 472         str = __connman_config_get_string(keyfile, group, SERVICE_KEY_IPv6_PRIVACY,
 473                                                                         NULL);
 474         if (str) {
 475                 g_free(service->ipv6_privacy);
 476                 service->ipv6_privacy = str;
 477         }
 478
 479         str = __connman_config_get_string(keyfile, group, SERVICE_KEY_MAC, NULL);
 480         if (str) {
 481                 g_free(service->mac);
 482                 service->mac = str;
 483         }
 484
 485         str = __connman_config_get_string(keyfile, group, SERVICE_KEY_DEVICE_NAME, NULL);
 486         if (str) {
 487                 g_free(service->devname);
 488                 service->devname = str;
 489         }
 490
 491         str = __connman_config_get_string(keyfile, group, SERVICE_KEY_DOMAIN, NULL);
 492         if (str) {
 493                 g_free(service->domain_name);
 494                 service->domain_name = str;
 495         }
 496
 497         strlist = __connman_config_get_string_list(keyfile, group,
 498                                         SERVICE_KEY_NAMESERVERS,
 499                                         &length, NULL);
 500         if (strlist) {
 501                 if (length != 0) {
 502                         g_strfreev(service->nameservers);
 503                         service->nameservers = strlist;
 504                 } else
 505                         g_strfreev(strlist);
 506         }
 507
 508         strlist = __connman_config_get_string_list(keyfile, group,
 509                                         SERVICE_KEY_SEARCH_DOMAINS,
 510                                         &length, NULL);
 511         if (strlist) {
 512                 if (length != 0) {
 513                         g_strfreev(service->search_domains);
 514                         service->search_domains = strlist;
 515                 } else
 516                         g_strfreev(strlist);
 517         }
 518
 519         strlist = __connman_config_get_string_list(keyfile, group,
 520                                         SERVICE_KEY_TIMESERVERS,
 521                                         &length, NULL);
 522         if (strlist) {
 523                 if (length != 0) {
 524                         g_strfreev(service->timeservers);
 525                         service->timeservers = strlist;
 526                 } else
 527                         g_strfreev(strlist);
 528         }
 529
 530         service->mdns = __connman_config_get_bool(keyfile, group,
 531                                                 SERVICE_KEY_MDNS, NULL);
 532
 533         return true;
 534
 535 err:
 536         g_free(service->ident);
 537         g_free(service->type);
 538         g_free(service->ipv4_address);
 539         g_free(service->ipv4_netmask);
 540         g_free(service->ipv4_gateway);
 541         g_free(service->ipv6_address);
 542         g_free(service->ipv6_gateway);
 543         g_free(service->mac);
 544         g_free(service->devname);
 545         g_free(service);
 546
 547         return false;
 548 }
 549
 550 static bool load_service(GKeyFile *keyfile, const char *group,
 551                                                 struct connman_config *config)
 552 {
 553         struct connman_config_service *service;
 554         const char *ident;
 555         char *str, *hex_ssid;
 556         enum connman_service_security security;
 557         bool service_created = false;
 558
 559         /* Strip off "service_" prefix */
 560         ident = group + 8;
 561
 562         if (strlen(ident) < 1)
 563                 return false;
 564
 565         /* Verify that provided keys are good */
 566         check_keys(keyfile, group, service_possible_keys);
 567
 568         service = g_hash_table_lookup(config->service_table, ident);
 569         if (!service) {
 570                 service = g_try_new0(struct connman_config_service, 1);
 571                 if (!service)
 572                         return false;
 573
 574                 service->ident = g_strdup(ident);
 575
 576                 service_created = true;
 577         }
 578
 579         str = __connman_config_get_string(keyfile, group, SERVICE_KEY_TYPE, NULL);
 580         if (str) {
 581                 g_free(service->type);
 582                 service->type = str;
 583         } else {
 584                 connman_warn("Type of the configured service is missing "
 585                         "for group %s", group);
 586                 goto err;
 587         }
 588
 589         if (!load_service_generic(keyfile, group, config, service))
 590                 return false;
 591
 592         if (g_strcmp0(str, "ethernet") == 0) {
 593                 service->config_ident = g_strdup(config->ident);
 594                 service->config_entry = g_strdup_printf("service_%s",
 595                                                         service->ident);
 596
 597                 g_hash_table_insert(config->service_table, service->ident,
 598                                                                 service);
 599                 return true;
 600         }
 601
 602         str = __connman_config_get_string(keyfile, group, SERVICE_KEY_NAME, NULL);
 603         if (str) {
 604                 g_free(service->name);
 605                 service->name = str;
 606         }
 607
 608         hex_ssid = __connman_config_get_string(keyfile, group, SERVICE_KEY_SSID,
 609                                          NULL);
 610         if (hex_ssid) {
 611                 char *ssid;
 612                 unsigned int i, j = 0, hex;
 613                 size_t hex_ssid_len = strlen(hex_ssid);
 614
 615                 ssid = g_try_malloc0(hex_ssid_len / 2);
 616                 if (!ssid) {
 617                         g_free(hex_ssid);
 618                         goto err;
 619                 }
 620
 621                 for (i = 0; i < hex_ssid_len; i += 2) {
 622                         if (sscanf(hex_ssid + i, "%02x", &hex) <= 0) {
 623                                 connman_warn("Invalid SSID %s", hex_ssid);
 624                                 g_free(ssid);
 625                                 g_free(hex_ssid);
 626                                 goto err;
 627                         }
 628                         ssid[j++] = hex;
 629                 }
 630
 631                 g_free(hex_ssid);
 632
 633                 g_free(service->ssid);
 634                 service->ssid = ssid;
 635                 service->ssid_len = hex_ssid_len / 2;
 636         } else if (service->name) {
 637                 char *ssid;
 638                 unsigned int ssid_len;
 639
 640                 ssid_len = strlen(service->name);
 641                 ssid = g_try_malloc0(ssid_len);
 642                 if (!ssid)
 643                         goto err;
 644
 645                 memcpy(ssid, service->name, ssid_len);
 646                 g_free(service->ssid);
 647                 service->ssid = ssid;
 648                 service->ssid_len = ssid_len;
 649         }
 650
 651         str = __connman_config_get_string(keyfile, group, SERVICE_KEY_EAP, NULL);
 652         if (str) {
 653                 g_free(service->eap);
 654                 service->eap = str;
 655         }
 656
 657         str = __connman_config_get_string(keyfile, group, SERVICE_KEY_CA_CERT, NULL);
 658         if (str) {
 659                 g_free(service->ca_cert_file);
 660                 service->ca_cert_file = str;
 661         }
 662
 663         str = __connman_config_get_string(keyfile, group, SERVICE_KEY_CL_CERT, NULL);
 664         if (str) {
 665                 g_free(service->client_cert_file);
 666                 service->client_cert_file = str;
 667         }
 668
 669         str = __connman_config_get_string(keyfile, group, SERVICE_KEY_PRV_KEY, NULL);
 670         if (str) {
 671                 g_free(service->private_key_file);
 672                 service->private_key_file = str;
 673         }
 674
 675         str = __connman_config_get_string(keyfile, group,
 676                                                 SERVICE_KEY_PRV_KEY_PASS, NULL);
 677         if (str) {
 678                 g_free(service->private_key_passphrase);
 679                 service->private_key_passphrase = str;
 680         }
 681
 682         str = __connman_config_get_string(keyfile, group,
 683                                         SERVICE_KEY_PRV_KEY_PASS_TYPE, NULL);
 684         if (str) {
 685                 g_free(service->private_key_passphrase_type);
 686                 service->private_key_passphrase_type = str;
 687         }
 688
 689         str = __connman_config_get_string(keyfile, group, SERVICE_KEY_IDENTITY, NULL);
 690         if (str) {
 691                 g_free(service->identity);
 692                 service->identity = str;
 693         }
 694
 695         str = __connman_config_get_string(keyfile, group,
 696                                         SERVICE_KEY_ANONYMOUS_IDENTITY, NULL);
 697         if (str) {
 698                 g_free(service->anonymous_identity);
 699                 service->anonymous_identity = str;
 700         }
 701
 702         str = __connman_config_get_string(keyfile, group,
 703                                         SERVICE_KEY_SUBJECT_MATCH, NULL);
 704         if (str) {
 705                 g_free(service->subject_match);
 706                 service->subject_match = str;
 707         }
 708
 709         str = __connman_config_get_string(keyfile, group,
 710                                         SERVICE_KEY_ALT_SUBJECT_MATCH, NULL);
 711         if (str) {
 712                 g_free(service->altsubject_match);
 713                 service->altsubject_match = str;
 714         }
 715
 716         str = __connman_config_get_string(keyfile, group,
 717                                         SERVICE_KEY_DOMAIN_SUFF_MATCH, NULL);
 718         if (str) {
 719                 g_free(service->domain_suffix_match);
 720                 service->domain_suffix_match = str;
 721         }
 722
 723         str = __connman_config_get_string(keyfile, group,
 724                                         SERVICE_KEY_DOMAIN_MATCH, NULL);
 725         if (str) {
 726                 g_free(service->domain_match);
 727                 service->domain_match = str;
 728         }
 729
 730         str = __connman_config_get_string(keyfile, group, SERVICE_KEY_PHASE2, NULL);
 731         if (str) {
 732                 g_free(service->phase2);
 733                 service->phase2 = str;
 734         }
 735
 736         str = __connman_config_get_string(keyfile, group, SERVICE_KEY_PASSPHRASE,
 737                                         NULL);
 738         if (str) {
 739                 g_free(service->passphrase);
 740                 service->passphrase = str;
 741         }
 742
 743         str = __connman_config_get_string(keyfile, group, SERVICE_KEY_SECURITY,
 744                         NULL);
 745         security = __connman_service_string2security(str);
 746
 747         if (service->eap) {
 748
 749                 if (str && security != CONNMAN_SERVICE_SECURITY_8021X)
 750                         connman_info("Mismatch between EAP configuration and "
 751                                         "setting %s = %s",
 752                                         SERVICE_KEY_SECURITY, str);
 753
 754                 service->security = CONNMAN_SERVICE_SECURITY_8021X;
 755
 756         } else if (service->passphrase) {
 757
 758                 if (str) {
 759                         if (security == CONNMAN_SERVICE_SECURITY_PSK ||
 760                                         security == CONNMAN_SERVICE_SECURITY_WEP) {
 761                                 service->security = security;
 762                         } else {
 763                                 connman_info("Mismatch with passphrase and "
 764                                                 "setting %s = %s",
 765                                                 SERVICE_KEY_SECURITY, str);
 766
 767                                 service->security =
 768                                         CONNMAN_SERVICE_SECURITY_PSK;
 769                         }
 770
 771                 } else
 772                         service->security = CONNMAN_SERVICE_SECURITY_PSK;
 773         } else if (str) {
 774
 775                 if (security != CONNMAN_SERVICE_SECURITY_NONE)
 776                         connman_info("Mismatch no security and "
 777                                         "setting %s = %s",
 778                                         SERVICE_KEY_SECURITY, str);
 779
 780                 service->security = CONNMAN_SERVICE_SECURITY_NONE;
 781         } else
 782                 service->security = CONNMAN_SERVICE_SECURITY_NONE;
 783
 784         g_free(str);
 785
 786         service->config_ident = g_strdup(config->ident);
 787         service->config_entry = g_strdup_printf("service_%s", service->ident);
 788
 789         service->hidden = __connman_config_get_bool(keyfile, group,
 790                                                 SERVICE_KEY_HIDDEN, NULL);
 791
 792         if (service_created)
 793                 g_hash_table_insert(config->service_table, service->ident,
 794                                         service);
 795
 796         connman_info("Adding service configuration %s", service->ident);
 797
 798         return true;
 799
 800 err:
 801         if (service_created) {
 802                 g_free(service->ident);
 803                 g_free(service->type);
 804                 g_free(service->name);
 805                 g_free(service->ssid);
 806                 g_free(service);
 807         }
 808
 809         return false;
 810 }
 811
 812 static bool load_service_from_keyfile(GKeyFile *keyfile,
 813                                                 struct connman_config *config)
 814 {
 815         bool found = false;
 816         char **groups;
 817         int i;
 818
 819         groups = g_key_file_get_groups(keyfile, NULL);
 820
 821         for (i = 0; groups[i]; i++) {
 822                 if (!g_str_has_prefix(groups[i], "service_")) {
 823                         connman_warn("Ignore group named '%s' because prefix "
 824                                 "is not 'service_'", groups[i]);
 825                         continue;
 826                 }
 827                 if (load_service(keyfile, groups[i], config))
 828                         found = true;
 829         }
 830
 831         g_strfreev(groups);
 832
 833         return found;
 834 }
 835
 836 static int load_config(struct connman_config *config)
 837 {
 838         GKeyFile *keyfile;
 839         char *str;
 840
 841         DBG("config %p", config);
 842
 843         keyfile = __connman_storage_load_config(config->ident);
 844         if (!keyfile)
 845                 return -EIO;
 846
 847         g_key_file_set_list_separator(keyfile, ',');
 848
 849         /* Verify keys validity of the global section */
 850         check_keys(keyfile, "global", config_possible_keys);
 851
 852         str = __connman_config_get_string(keyfile, "global", CONFIG_KEY_NAME, NULL);
 853         if (str) {
 854                 g_free(config->name);
 855                 config->name = str;
 856         }
 857
 858         str = __connman_config_get_string(keyfile, "global", CONFIG_KEY_DESC, NULL);
 859         if (str) {
 860                 g_free(config->description);
 861                 config->description = str;
 862         }
 863
 864         if (!load_service_from_keyfile(keyfile, config))
 865                 connman_warn("Config file %s/%s.config does not contain any "
 866                         "configuration that can be provisioned!",
 867                         STORAGEDIR, config->ident);
 868
 869         g_key_file_free(keyfile);
 870
 871         return 0;
 872 }
 873
 874 static struct connman_config *create_config(const char *ident)
 875 {
 876         struct connman_config *config;
 877
 878         DBG("ident %s", ident);
 879
 880         if (g_hash_table_lookup(config_table, ident))
 881                 return NULL;
 882
 883         config = g_try_new0(struct connman_config, 1);
 884         if (!config)
 885                 return NULL;
 886
 887         config->ident = g_strdup(ident);
 888
 889         config->service_table = g_hash_table_new_full(g_str_hash, g_str_equal,
 890                                                 NULL, unregister_service);
 891
 892         g_hash_table_insert(config_table, config->ident, config);
 893
 894         connman_info("Adding configuration %s", config->ident);
 895
 896         return config;
 897 }
 898
 899 static bool validate_ident(const char *ident)
 900 {
 901         unsigned int i;
 902
 903         if (!ident)
 904                 return false;
 905
 906         for (i = 0; i < strlen(ident); i++)
 907                 if (!g_ascii_isprint(ident[i]))
 908                         return false;
 909
 910         return true;
 911 }
 912
 913 static int read_configs(void)
 914 {
 915         GDir *dir;
 916
 917         DBG("");
 918
 919         dir = g_dir_open(STORAGEDIR, 0, NULL);
 920         if (dir) {
 921                 const gchar *file;
 922
 923                 while ((file = g_dir_read_name(dir))) {
 924                         GString *str;
 925                         gchar *ident;
 926
 927                         if (!g_str_has_suffix(file, ".config"))
 928                                 continue;
 929
 930                         ident = g_strrstr(file, ".config");
 931                         if (!ident)
 932                                 continue;
 933
 934                         str = g_string_new_len(file, ident - file);
 935                         if (!str)
 936                                 continue;
 937
 938                         ident = g_string_free(str, FALSE);
 939
 940                         if (validate_ident(ident)) {
 941                                 struct connman_config *config;
 942
 943                                 config = create_config(ident);
 944                                 if (config)
 945                                         load_config(config);
 946                         } else {
 947                                 connman_error("Invalid config ident %s", ident);
 948                         }
 949                         g_free(ident);
 950                 }
 951
 952                 g_dir_close(dir);
 953         }
 954
 955         return 0;
 956 }
 957
 958 static void config_notify_handler(struct inotify_event *event,
 959                                         const char *ident)
 960 {
 961         char *ext;
 962
 963         if (!ident)
 964                 return;
 965
 966         if (!g_str_has_suffix(ident, ".config"))
 967                 return;
 968
 969         ext = g_strrstr(ident, ".config");
 970         if (!ext)
 971                 return;
 972
 973         *ext = '\0';
 974
 975         if (!validate_ident(ident)) {
 976                 connman_error("Invalid config ident %s", ident);
 977                 return;
 978         }
 979
 980         if (event->mask & (IN_CREATE | IN_MOVED_TO))
 981                 create_config(ident);
 982
 983         if (event->mask & (IN_MODIFY | IN_MOVED_TO)) {
 984                 struct connman_config *config;
 985
 986                 config = g_hash_table_lookup(config_table, ident);
 987                 if (config) {
 988                         int ret;
 989
 990                         g_hash_table_remove_all(config->service_table);
 991                         load_config(config);
 992                         ret = __connman_service_provision_changed(ident);
 993                         if (ret > 0) {
 994                                 /*
 995                                  * Re-scan the config file for any
 996                                  * changes
 997                                  */
 998                                 g_hash_table_remove_all(config->service_table);
 999                                 load_config(config);
1000                                 __connman_service_provision_changed(ident);
1001                         }
1002                 }
1003         }
1004
1005         if (event->mask & (IN_DELETE | IN_MOVED_FROM))
1006                 g_hash_table_remove(config_table, ident);
1007 }
1008
1009 int __connman_config_init(void)
1010 {
1011         DBG("");
1012
1013         config_table = g_hash_table_new_full(g_str_hash, g_str_equal,
1014                                                 NULL, unregister_config);
1015
1016         connman_inotify_register(STORAGEDIR, config_notify_handler);
1017
1018         return read_configs();
1019 }
1020
1021 void __connman_config_cleanup(void)
1022 {
1023         DBG("");
1024
1025         cleanup = true;
1026
1027         connman_inotify_unregister(STORAGEDIR, config_notify_handler);
1028
1029         g_hash_table_destroy(config_table);
1030         config_table = NULL;
1031
1032         cleanup = false;
1033 }
1034
1035 char *__connman_config_get_string(GKeyFile *key_file,
1036         const char *group_name, const char *key, GError **error)
1037 {
1038         char *str = g_key_file_get_string(key_file, group_name, key, error);
1039         if (!str)
1040                 return NULL;
1041
1042         /* passphrases can have spaces in the end */
1043         if (!g_strcmp0(key, SERVICE_KEY_PASSPHRASE) ||
1044                         !g_strcmp0(key, SERVICE_KEY_PRV_KEY_PASS))
1045                 return str;
1046
1047         return g_strchomp(str);
1048 }
1049
1050 char **__connman_config_get_string_list(GKeyFile *key_file,
1051         const char *group_name, const char *key, gsize *length, GError **error)
1052 {
1053         char **p;
1054         char **strlist = g_key_file_get_string_list(key_file, group_name, key,
1055                 length, error);
1056         if (!strlist)
1057                 return NULL;
1058
1059         p = strlist;
1060         while (*p) {
1061                 *p = g_strstrip(*p);
1062                 p++;
1063         }
1064
1065         return strlist;
1066 }
1067
1068 bool __connman_config_get_bool(GKeyFile *key_file,
1069         const char *group_name, const char *key, GError **error)
1070 {
1071         char *valstr;
1072         bool val = false;
1073
1074         valstr = g_key_file_get_value(key_file, group_name, key, error);
1075         if (!valstr)
1076                 return false;
1077
1078         valstr = g_strchomp(valstr);
1079         if (strcmp(valstr, "true") == 0 || strcmp(valstr, "1") == 0)
1080                 val = true;
1081
1082         g_free(valstr);
1083
1084         return val;
1085 }
1086
1087 static char *config_pem_fsid(const char *pem_file)
1088 {
1089         struct statfs buf;
1090         unsigned *fsid = (unsigned *) &buf.f_fsid;
1091         unsigned long long fsid64;
1092
1093         if (!pem_file)
1094                 return NULL;
1095
1096         if (statfs(pem_file, &buf) < 0) {
1097                 connman_error("statfs error %s for %s",
1098                                                 strerror(errno), pem_file);
1099                 return NULL;
1100         }
1101
1102         fsid64 = ((unsigned long long) fsid[0] << 32) | fsid[1];
1103
1104         return g_strdup_printf("%llx", fsid64);
1105 }
1106
1107 static void provision_service_wifi(struct connman_config_service *config,
1108                                 struct connman_service *service,
1109                                 struct connman_network *network)
1110 {
1111         if (config->eap)
1112                 __connman_service_set_string(service, "EAP", config->eap);
1113
1114         if (config->identity)
1115                 __connman_service_set_string(service, "Identity",
1116                                                         config->identity);
1117
1118         if (config->anonymous_identity)
1119                 __connman_service_set_string(service, "AnonymousIdentity",
1120                                                 config->anonymous_identity);
1121
1122         if (config->ca_cert_file)
1123                 __connman_service_set_string(service, "CACertFile",
1124                                                         config->ca_cert_file);
1125
1126         if (config->subject_match)
1127                 __connman_service_set_string(service, "SubjectMatch",
1128                                                         config->subject_match);
1129
1130         if (config->altsubject_match)
1131                 __connman_service_set_string(service, "AltSubjectMatch",
1132                                                         config->altsubject_match);
1133
1134         if (config->domain_suffix_match)
1135                 __connman_service_set_string(service, "DomainSuffixMatch",
1136                                                         config->domain_suffix_match);
1137
1138         if (config->domain_match)
1139                 __connman_service_set_string(service, "DomainMatch",
1140                                                         config->domain_match);
1141
1142         if (config->client_cert_file)
1143                 __connman_service_set_string(service, "ClientCertFile",
1144                                                 config->client_cert_file);
1145
1146         if (config->private_key_file)
1147                 __connman_service_set_string(service, "PrivateKeyFile",
1148                                                 config->private_key_file);
1149
1150         if (g_strcmp0(config->private_key_passphrase_type, "fsid") == 0 &&
1151                                         config->private_key_file) {
1152                 char *fsid;
1153
1154                 fsid = config_pem_fsid(config->private_key_file);
1155                 if (!fsid)
1156                         return;
1157
1158                 g_free(config->private_key_passphrase);
1159                 config->private_key_passphrase = fsid;
1160         }
1161
1162         if (config->private_key_passphrase) {
1163                 __connman_service_set_string(service, "PrivateKeyPassphrase",
1164                                                 config->private_key_passphrase);
1165                 /*
1166                  * TODO: Support for PEAP with both identity and key passwd.
1167                  * In that case, we should check if both of them are found
1168                  * from the config file. If not, we should not set the
1169                  * service passphrase in order for the UI to request for an
1170                  * additional passphrase.
1171                  */
1172         }
1173
1174         if (config->phase2)
1175                 __connman_service_set_string(service, "Phase2", config->phase2);
1176
1177         if (config->passphrase)
1178                 __connman_service_set_string(service, "Passphrase",
1179                                                 config->passphrase);
1180
1181         if (config->hidden)
1182                 __connman_service_set_hidden(service);
1183 }
1184
1185 struct connect_virtual {
1186         struct connman_service *service;
1187         const char *vfile;
1188 };
1189
1190 static gboolean remove_virtual_config(gpointer user_data)
1191 {
1192         struct connect_virtual *virtual = user_data;
1193
1194         __connman_service_connect(virtual->service,
1195                                 CONNMAN_SERVICE_CONNECT_REASON_AUTO);
1196         g_hash_table_remove(config_table, virtual->vfile);
1197
1198         g_free(virtual);
1199
1200         return FALSE;
1201 }
1202
1203 static int try_provision_service(struct connman_config_service *config,
1204                                 struct connman_service *service)
1205 {
1206         struct connman_network *network;
1207         const void *service_id;
1208         enum connman_service_type type;
1209         const void *ssid;
1210         unsigned int ssid_len;
1211         const char *str;
1212
1213         network = __connman_service_get_network(service);
1214         if (!network) {
1215                 connman_error("Service has no network set");
1216                 return -EINVAL;
1217         }
1218
1219         DBG("network %p ident %s", network,
1220                                 connman_network_get_identifier(network));
1221
1222         type = connman_service_get_type(service);
1223
1224         switch(type) {
1225         case CONNMAN_SERVICE_TYPE_WIFI:
1226                 if (__connman_service_string2type(config->type) != type)
1227                         return -ENOENT;
1228
1229                 ssid = connman_network_get_blob(network, "WiFi.SSID",
1230                                                 &ssid_len);
1231                 if (!ssid)
1232                         return -ENOENT;
1233
1234                 if (!config->ssid || ssid_len != config->ssid_len)
1235                         return -ENOENT;
1236
1237                 if (memcmp(config->ssid, ssid, ssid_len))
1238                         return -ENOENT;
1239
1240                 str = connman_network_get_string(network, "WiFi.Security");
1241                 if (config->security != __connman_service_string2security(str))
1242                         return -ENOENT;
1243
1244                 break;
1245
1246         case CONNMAN_SERVICE_TYPE_ETHERNET:
1247         case CONNMAN_SERVICE_TYPE_GADGET:
1248
1249                 if (__connman_service_string2type(config->type) != type)
1250                         return -ENOENT;
1251
1252                 break;
1253
1254         case CONNMAN_SERVICE_TYPE_UNKNOWN:
1255         case CONNMAN_SERVICE_TYPE_SYSTEM:
1256         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
1257         case CONNMAN_SERVICE_TYPE_CELLULAR:
1258         case CONNMAN_SERVICE_TYPE_GPS:
1259         case CONNMAN_SERVICE_TYPE_VPN:
1260         case CONNMAN_SERVICE_TYPE_P2P:
1261
1262                 return -ENOENT;
1263         }
1264
1265         DBG("service %p ident %s", service,
1266                                 connman_service_get_identifier(service));
1267
1268         if (config->mac) {
1269                 struct connman_device *device;
1270                 const char *device_addr;
1271
1272                 device = connman_network_get_device(network);
1273                 if (!device) {
1274                         connman_error("Network device is missing");
1275                         return -ENODEV;
1276                 }
1277
1278                 device_addr = connman_device_get_string(device, "Address");
1279
1280                 DBG("wants %s has %s", config->mac, device_addr);
1281
1282                 if (g_ascii_strcasecmp(device_addr, config->mac) != 0)
1283                         return -ENOENT;
1284         } else if (config->devname) {
1285                 struct connman_device *device;
1286                 const char *devname;
1287
1288                 device = connman_network_get_device(network);
1289                 if (!device) {
1290                         connman_error("Network device is missing");
1291                         return -ENODEV;
1292                 }
1293
1294                 devname = connman_device_get_string(device, "Interface");
1295
1296                 DBG("wants %s has %s", config->devname, devname);
1297
1298                 if (g_ascii_strcasecmp(devname, config->devname) != 0)
1299                         return -ENOENT;
1300         }
1301
1302         if (!config->ipv6_address) {
1303                 connman_network_set_ipv6_method(network,
1304                                                 CONNMAN_IPCONFIG_METHOD_AUTO);
1305         } else if (g_ascii_strcasecmp(config->ipv6_address, "off") == 0) {
1306                 connman_network_set_ipv6_method(network,
1307                                                 CONNMAN_IPCONFIG_METHOD_OFF);
1308         } else if (g_ascii_strcasecmp(config->ipv6_address, "auto") == 0 ||
1309                         g_ascii_strcasecmp(config->ipv6_address, "dhcp") == 0) {
1310                 connman_network_set_ipv6_method(network,
1311                                                 CONNMAN_IPCONFIG_METHOD_AUTO);
1312         } else {
1313                 struct connman_ipaddress *address;
1314
1315                 if (config->ipv6_prefix_length == 0) {
1316                         DBG("IPv6 prefix missing");
1317                         return -EINVAL;
1318                 }
1319
1320                 address = connman_ipaddress_alloc(AF_INET6);
1321                 if (!address)
1322                         return -ENOENT;
1323
1324                 connman_ipaddress_set_ipv6(address, config->ipv6_address,
1325                                         config->ipv6_prefix_length,
1326                                         config->ipv6_gateway);
1327
1328                 connman_network_set_ipv6_method(network,
1329                                                 CONNMAN_IPCONFIG_METHOD_FIXED);
1330
1331                 if (connman_network_set_ipaddress(network, address) < 0)
1332                         DBG("Unable to set IPv6 address to network %p",
1333                                                                 network);
1334
1335                 connman_ipaddress_free(address);
1336         }
1337
1338         if (config->ipv6_privacy) {
1339                 struct connman_ipconfig *ipconfig;
1340
1341                 ipconfig = __connman_service_get_ip6config(service);
1342                 if (ipconfig)
1343                         __connman_ipconfig_ipv6_set_privacy(ipconfig,
1344                                                         config->ipv6_privacy);
1345         }
1346
1347         if (!config->ipv4_address) {
1348                 connman_network_set_ipv4_method(network,
1349                                                 CONNMAN_IPCONFIG_METHOD_DHCP);
1350         } else if (g_ascii_strcasecmp(config->ipv4_address, "off") == 0) {
1351                 connman_network_set_ipv4_method(network,
1352                                                 CONNMAN_IPCONFIG_METHOD_OFF);
1353         } else if (g_ascii_strcasecmp(config->ipv4_address, "auto") == 0 ||
1354                         g_ascii_strcasecmp(config->ipv4_address, "dhcp") == 0) {
1355                 connman_network_set_ipv4_method(network,
1356                                                 CONNMAN_IPCONFIG_METHOD_DHCP);
1357         } else {
1358                 struct connman_ipaddress *address;
1359
1360                 if (!config->ipv4_netmask) {
1361                         DBG("IPv4 netmask missing");
1362                         return -EINVAL;
1363                 }
1364
1365                 address = connman_ipaddress_alloc(AF_INET);
1366                 if (!address)
1367                         return -ENOENT;
1368
1369                 connman_ipaddress_set_ipv4(address, config->ipv4_address,
1370                                         config->ipv4_netmask,
1371                                         config->ipv4_gateway);
1372
1373                 connman_network_set_ipv4_method(network,
1374                                                 CONNMAN_IPCONFIG_METHOD_FIXED);
1375
1376                 if (connman_network_set_ipaddress(network, address) < 0)
1377                         DBG("Unable to set IPv4 address to network %p",
1378                                                                 network);
1379
1380                 connman_ipaddress_free(address);
1381         }
1382
1383         __connman_service_disconnect(service);
1384
1385         service_id = connman_service_get_identifier(service);
1386         config->service_identifiers =
1387                 g_slist_prepend(config->service_identifiers,
1388                                 g_strdup(service_id));
1389
1390         __connman_service_set_favorite_delayed(service, true, true);
1391
1392         __connman_service_set_config(service, config->config_ident,
1393                                                 config->config_entry);
1394
1395         if (config->domain_name)
1396                 __connman_service_set_domainname(service, config->domain_name);
1397
1398         if (config->nameservers) {
1399                 int i;
1400
1401                 __connman_service_nameserver_clear(service);
1402
1403                 for (i = 0; config->nameservers[i]; i++) {
1404                         __connman_service_nameserver_append(service,
1405                                                 config->nameservers[i], false);
1406                 }
1407         }
1408
1409         if (config->search_domains)
1410                 __connman_service_set_search_domains(service,
1411                                                 config->search_domains);
1412
1413         __connman_service_set_mdns(service, config->mdns);
1414
1415         if (config->timeservers)
1416                 __connman_service_set_timeservers(service,
1417                                                 config->timeservers);
1418
1419         if (type == CONNMAN_SERVICE_TYPE_WIFI) {
1420                 provision_service_wifi(config, service, network);
1421         }
1422
1423         __connman_service_mark_dirty();
1424
1425         __connman_service_load_modifiable(service);
1426
1427         if (config->virtual) {
1428                 struct connect_virtual *virtual;
1429
1430                 virtual = g_malloc0(sizeof(struct connect_virtual));
1431                 virtual->service = service;
1432                 virtual->vfile = config->virtual_file;
1433
1434                 g_idle_add(remove_virtual_config, virtual);
1435
1436                 return 0;
1437         }
1438
1439         __connman_service_set_immutable(service, true);
1440
1441         if (type == CONNMAN_SERVICE_TYPE_ETHERNET ||
1442                         type == CONNMAN_SERVICE_TYPE_GADGET) {
1443                 __connman_service_connect(service,
1444                                 CONNMAN_SERVICE_CONNECT_REASON_AUTO);
1445
1446                 return 0;
1447         }
1448
1449         __connman_service_auto_connect(CONNMAN_SERVICE_CONNECT_REASON_AUTO);
1450
1451         return 0;
1452 }
1453
1454 static int
1455 find_and_provision_service_from_config(struct connman_service *service,
1456                                         struct connman_config *config)
1457 {
1458         GHashTableIter iter;
1459         gpointer value, key;
1460
1461         g_hash_table_iter_init(&iter, config->service_table);
1462         while (g_hash_table_iter_next(&iter, &key,
1463                                         &value)) {
1464                 if (!try_provision_service(value, service))
1465                         return 0;
1466         }
1467
1468         return -ENOENT;
1469 }
1470
1471 static int find_and_provision_service(struct connman_service *service)
1472 {
1473         GHashTableIter iter;
1474         gpointer value, key;
1475
1476         g_hash_table_iter_init(&iter, config_table);
1477
1478         while (g_hash_table_iter_next(&iter, &key, &value)) {
1479                 struct connman_config *config = value;
1480
1481                 if (!find_and_provision_service_from_config(service, config))
1482                         return 0;
1483         }
1484
1485         return -ENOENT;
1486 }
1487
1488 int __connman_config_provision_service(struct connman_service *service)
1489 {
1490         enum connman_service_type type;
1491
1492         /* For now only WiFi, Gadget and Ethernet services are supported */
1493         type = connman_service_get_type(service);
1494
1495         DBG("service %p type %d", service, type);
1496
1497         if (type != CONNMAN_SERVICE_TYPE_WIFI &&
1498                         type != CONNMAN_SERVICE_TYPE_ETHERNET &&
1499                         type != CONNMAN_SERVICE_TYPE_GADGET)
1500                 return -ENOSYS;
1501
1502         return find_and_provision_service(service);
1503 }
1504
1505 int __connman_config_provision_service_ident(struct connman_service *service,
1506                         const char *ident, const char *file, const char *entry)
1507 {
1508         enum connman_service_type type;
1509         struct connman_config *config;
1510         int ret = 0;
1511
1512         /* For now only WiFi, Gadget and Ethernet services are supported */
1513         type = connman_service_get_type(service);
1514
1515         DBG("service %p type %d", service, type);
1516
1517         if (type != CONNMAN_SERVICE_TYPE_WIFI &&
1518                         type != CONNMAN_SERVICE_TYPE_ETHERNET &&
1519                         type != CONNMAN_SERVICE_TYPE_GADGET)
1520                 return -ENOSYS;
1521
1522         config = g_hash_table_lookup(config_table, ident);
1523         if (config) {
1524                 GHashTableIter iter;
1525                 gpointer value, key;
1526                 bool found = false;
1527
1528                 g_hash_table_iter_init(&iter, config->service_table);
1529
1530                 /*
1531                  * Check if we need to remove individual service if it
1532                  * is missing from config file.
1533                  */
1534                 if (file && entry) {
1535                         while (g_hash_table_iter_next(&iter, &key,
1536                                                         &value)) {
1537                                 struct connman_config_service *config_service;
1538
1539                                 config_service = value;
1540
1541                                 if (g_strcmp0(config_service->config_ident,
1542                                                                 file) != 0)
1543                                         continue;
1544
1545                                 if (g_strcmp0(config_service->config_entry,
1546                                                                 entry) != 0)
1547                                         continue;
1548
1549                                 found = true;
1550                                 break;
1551                         }
1552
1553                         DBG("found %d ident %s file %s entry %s", found, ident,
1554                                                                 file, entry);
1555
1556                         if (!found) {
1557                                 /*
1558                                  * The entry+8 will skip "service_" prefix
1559                                  */
1560                                 g_hash_table_remove(config->service_table,
1561                                                 entry + 8);
1562                                 ret = 1;
1563                         }
1564                 }
1565
1566                 find_and_provision_service_from_config(service, config);
1567         }
1568
1569         return ret;
1570 }
1571
1572 static void generate_random_string(char *str, int length)
1573 {
1574         uint8_t val;
1575         int i;
1576         uint64_t rand;
1577
1578         memset(str, '\0', length);
1579
1580         for (i = 0; i < length-1; i++) {
1581                 do {
1582                         __connman_util_get_random(&rand);
1583                         val = (uint8_t)(rand % 122);
1584                         if (val < 48)
1585                                 val += 48;
1586                 } while((val > 57 && val < 65) || (val > 90 && val < 97));
1587
1588                 str[i] = val;
1589         }
1590 }
1591
1592 int connman_config_provision_mutable_service(GKeyFile *keyfile)
1593 {
1594         struct connman_config_service *service_config;
1595         struct connman_config *config;
1596         char *vfile, *group = NULL;
1597         char rstr[11];
1598
1599         DBG("");
1600
1601         generate_random_string(rstr, 11);
1602
1603         vfile = g_strdup_printf("service_mutable_%s.config", rstr);
1604
1605         config = create_config(vfile);
1606         if (!config)
1607                 return -ENOMEM;
1608
1609         if (!load_service_from_keyfile(keyfile, config))
1610                 goto error;
1611
1612         group = g_key_file_get_start_group(keyfile);
1613
1614         service_config = g_hash_table_lookup(config->service_table, group+8);
1615         if (!service_config)
1616                 goto error;
1617
1618         /* Specific to non file based config: */
1619         g_free(service_config->config_ident);
1620         service_config->config_ident = NULL;
1621         g_free(service_config->config_entry);
1622         service_config->config_entry = NULL;
1623
1624         service_config->virtual = true;
1625         service_config->virtual_file = vfile;
1626
1627         __connman_service_provision_changed(vfile);
1628
1629         if (g_strcmp0(service_config->type, "wifi") == 0)
1630                 __connman_device_request_scan(CONNMAN_SERVICE_TYPE_WIFI);
1631
1632         g_free(group);
1633         return 0;
1634
1635 error:
1636         DBG("Could not proceed");
1637         g_hash_table_remove(config_table, vfile);
1638         g_free(vfile);
1639         g_free(group);
1640         return -EINVAL;
1641 }
1642
1643 struct connman_config_entry **connman_config_get_entries(const char *type)
1644 {
1645         GHashTableIter iter_file, iter_config;
1646         gpointer value, key;
1647         struct connman_config_entry **entries = NULL;
1648         int i = 0, count;
1649
1650         g_hash_table_iter_init(&iter_file, config_table);
1651         while (g_hash_table_iter_next(&iter_file, &key, &value)) {
1652                 struct connman_config *config_file = value;
1653                 struct connman_config_entry **tmp_entries = entries;
1654
1655                 count = g_hash_table_size(config_file->service_table);
1656
1657                 entries = g_try_realloc(entries, (i + count + 1) *
1658                                         sizeof(struct connman_config_entry *));
1659                 if (!entries) {
1660                         g_free(tmp_entries);
1661                         return NULL;
1662                 }
1663
1664                 g_hash_table_iter_init(&iter_config,
1665                                                 config_file->service_table);
1666                 while (g_hash_table_iter_next(&iter_config, &key,
1667                                                         &value)) {
1668                         struct connman_config_service *config = value;
1669
1670                         if (type &&
1671                                         g_strcmp0(config->type, type) != 0)
1672                                 continue;
1673
1674                         entries[i] = g_try_new0(struct connman_config_entry,
1675                                                 1);
1676                         if (!entries[i])
1677                                 goto cleanup;
1678
1679                         entries[i]->ident = g_strdup(config->ident);
1680                         entries[i]->name = g_strdup(config->name);
1681                         entries[i]->ssid = g_try_malloc0(config->ssid_len + 1);
1682                         if (!entries[i]->ssid)
1683                                 goto cleanup;
1684
1685                         memcpy(entries[i]->ssid, config->ssid,
1686                                                         config->ssid_len);
1687                         entries[i]->ssid_len = config->ssid_len;
1688                         entries[i]->hidden = config->hidden;
1689
1690                         i++;
1691                 }
1692         }
1693
1694         if (entries) {
1695                 struct connman_config_entry **tmp_entries = entries;
1696
1697                 entries = g_try_realloc(entries, (i + 1) *
1698                                         sizeof(struct connman_config_entry *));
1699                 if (!entries) {
1700                         g_free(tmp_entries);
1701                         return NULL;
1702                 }
1703
1704                 entries[i] = NULL;
1705
1706                 DBG("%d provisioned AP found", i);
1707         }
1708
1709         return entries;
1710
1711 cleanup:
1712         connman_config_free_entries(entries);
1713         return NULL;
1714 }
1715
1716 void connman_config_free_entries(struct connman_config_entry **entries)
1717 {
1718         int i;
1719
1720         if (!entries)
1721                 return;
1722
1723         for (i = 0; entries[i]; i++) {
1724                 g_free(entries[i]->ident);
1725                 g_free(entries[i]->name);
1726                 g_free(entries[i]->ssid);
1727                 g_free(entries[i]);
1728         }
1729
1730         g_free(entries);
1731 }
1732
1733 bool __connman_config_address_provisioned(const char *address,
1734                                         const char *netmask)
1735 {
1736         GHashTableIter iter, siter;
1737         gpointer value, key, svalue, skey;
1738
1739         if (!address || !netmask)
1740                 return false;
1741
1742         g_hash_table_iter_init(&iter, config_table);
1743
1744         while (g_hash_table_iter_next(&iter, &key, &value)) {
1745                 struct connman_config *config = value;
1746
1747                 g_hash_table_iter_init(&siter, config->service_table);
1748                 while (g_hash_table_iter_next(&siter, &skey, &svalue)) {
1749                         struct connman_config_service *service = svalue;
1750
1751                         if (!g_strcmp0(address, service->ipv4_address) &&
1752                                         !g_strcmp0(netmask,
1753                                                 service->ipv4_netmask))
1754                                 return true;
1755                 }
1756         }
1757
1758         return false;
1759 }