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                                 const void *ssid, unsigned int ssid_len)
1111 {
1112         if (config->eap)
1113                 __connman_service_set_string(service, "EAP", config->eap);
1114
1115         if (config->identity)
1116                 __connman_service_set_string(service, "Identity",
1117                                                         config->identity);
1118
1119         if (config->anonymous_identity)
1120                 __connman_service_set_string(service, "AnonymousIdentity",
1121                                                 config->anonymous_identity);
1122
1123         if (config->ca_cert_file)
1124                 __connman_service_set_string(service, "CACertFile",
1125                                                         config->ca_cert_file);
1126
1127         if (config->subject_match)
1128                 __connman_service_set_string(service, "SubjectMatch",
1129                                                         config->subject_match);
1130
1131         if (config->altsubject_match)
1132                 __connman_service_set_string(service, "AltSubjectMatch",
1133                                                         config->altsubject_match);
1134
1135         if (config->domain_suffix_match)
1136                 __connman_service_set_string(service, "DomainSuffixMatch",
1137                                                         config->domain_suffix_match);
1138
1139         if (config->domain_match)
1140                 __connman_service_set_string(service, "DomainMatch",
1141                                                         config->domain_match);
1142
1143         if (config->client_cert_file)
1144                 __connman_service_set_string(service, "ClientCertFile",
1145                                                 config->client_cert_file);
1146
1147         if (config->private_key_file)
1148                 __connman_service_set_string(service, "PrivateKeyFile",
1149                                                 config->private_key_file);
1150
1151         if (g_strcmp0(config->private_key_passphrase_type, "fsid") == 0 &&
1152                                         config->private_key_file) {
1153                 char *fsid;
1154
1155                 fsid = config_pem_fsid(config->private_key_file);
1156                 if (!fsid)
1157                         return;
1158
1159                 g_free(config->private_key_passphrase);
1160                 config->private_key_passphrase = fsid;
1161         }
1162
1163         if (config->private_key_passphrase) {
1164                 __connman_service_set_string(service, "PrivateKeyPassphrase",
1165                                                 config->private_key_passphrase);
1166                 /*
1167                  * TODO: Support for PEAP with both identity and key passwd.
1168                  * In that case, we should check if both of them are found
1169                  * from the config file. If not, we should not set the
1170                  * service passphrase in order for the UI to request for an
1171                  * additional passphrase.
1172                  */
1173         }
1174
1175         if (config->phase2)
1176                 __connman_service_set_string(service, "Phase2", config->phase2);
1177
1178         if (config->passphrase)
1179                 __connman_service_set_string(service, "Passphrase",
1180                                                 config->passphrase);
1181
1182         if (config->hidden)
1183                 __connman_service_set_hidden(service);
1184 }
1185
1186 struct connect_virtual {
1187         struct connman_service *service;
1188         const char *vfile;
1189 };
1190
1191 static gboolean remove_virtual_config(gpointer user_data)
1192 {
1193         struct connect_virtual *virtual = user_data;
1194
1195         __connman_service_connect(virtual->service,
1196                                 CONNMAN_SERVICE_CONNECT_REASON_AUTO);
1197         g_hash_table_remove(config_table, virtual->vfile);
1198
1199         g_free(virtual);
1200
1201         return FALSE;
1202 }
1203
1204 static int try_provision_service(struct connman_config_service *config,
1205                                 struct connman_service *service)
1206 {
1207         struct connman_network *network;
1208         const void *service_id;
1209         enum connman_service_type type;
1210         const void *ssid;
1211         unsigned int ssid_len;
1212         const char *str;
1213
1214         network = __connman_service_get_network(service);
1215         if (!network) {
1216                 connman_error("Service has no network set");
1217                 return -EINVAL;
1218         }
1219
1220         DBG("network %p ident %s", network,
1221                                 connman_network_get_identifier(network));
1222
1223         type = connman_service_get_type(service);
1224
1225         switch(type) {
1226         case CONNMAN_SERVICE_TYPE_WIFI:
1227                 if (__connman_service_string2type(config->type) != type)
1228                         return -ENOENT;
1229
1230                 ssid = connman_network_get_blob(network, "WiFi.SSID",
1231                                                 &ssid_len);
1232                 if (!ssid)
1233                         return -ENOENT;
1234
1235                 if (!config->ssid || ssid_len != config->ssid_len)
1236                         return -ENOENT;
1237
1238                 if (memcmp(config->ssid, ssid, ssid_len))
1239                         return -ENOENT;
1240
1241                 str = connman_network_get_string(network, "WiFi.Security");
1242                 if (config->security != __connman_service_string2security(str))
1243                         return -ENOENT;
1244
1245                 break;
1246
1247         case CONNMAN_SERVICE_TYPE_ETHERNET:
1248         case CONNMAN_SERVICE_TYPE_GADGET:
1249
1250                 if (__connman_service_string2type(config->type) != type)
1251                         return -ENOENT;
1252
1253                 break;
1254
1255         case CONNMAN_SERVICE_TYPE_UNKNOWN:
1256         case CONNMAN_SERVICE_TYPE_SYSTEM:
1257         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
1258         case CONNMAN_SERVICE_TYPE_CELLULAR:
1259         case CONNMAN_SERVICE_TYPE_GPS:
1260         case CONNMAN_SERVICE_TYPE_VPN:
1261         case CONNMAN_SERVICE_TYPE_P2P:
1262
1263                 return -ENOENT;
1264         }
1265
1266         DBG("service %p ident %s", service,
1267                                 connman_service_get_identifier(service));
1268
1269         if (config->mac) {
1270                 struct connman_device *device;
1271                 const char *device_addr;
1272
1273                 device = connman_network_get_device(network);
1274                 if (!device) {
1275                         connman_error("Network device is missing");
1276                         return -ENODEV;
1277                 }
1278
1279                 device_addr = connman_device_get_string(device, "Address");
1280
1281                 DBG("wants %s has %s", config->mac, device_addr);
1282
1283                 if (g_ascii_strcasecmp(device_addr, config->mac) != 0)
1284                         return -ENOENT;
1285         } else if (config->devname) {
1286                 struct connman_device *device;
1287                 const char *devname;
1288
1289                 device = connman_network_get_device(network);
1290                 if (!device) {
1291                         connman_error("Network device is missing");
1292                         return -ENODEV;
1293                 }
1294
1295                 devname = connman_device_get_string(device, "Interface");
1296
1297                 DBG("wants %s has %s", config->devname, devname);
1298
1299                 if (g_ascii_strcasecmp(devname, config->devname) != 0)
1300                         return -ENOENT;
1301         }
1302
1303         if (!config->ipv6_address) {
1304                 connman_network_set_ipv6_method(network,
1305                                                 CONNMAN_IPCONFIG_METHOD_AUTO);
1306         } else if (g_ascii_strcasecmp(config->ipv6_address, "off") == 0) {
1307                 connman_network_set_ipv6_method(network,
1308                                                 CONNMAN_IPCONFIG_METHOD_OFF);
1309         } else if (g_ascii_strcasecmp(config->ipv6_address, "auto") == 0 ||
1310                         g_ascii_strcasecmp(config->ipv6_address, "dhcp") == 0) {
1311                 connman_network_set_ipv6_method(network,
1312                                                 CONNMAN_IPCONFIG_METHOD_AUTO);
1313         } else {
1314                 struct connman_ipaddress *address;
1315
1316                 if (config->ipv6_prefix_length == 0) {
1317                         DBG("IPv6 prefix missing");
1318                         return -EINVAL;
1319                 }
1320
1321                 address = connman_ipaddress_alloc(AF_INET6);
1322                 if (!address)
1323                         return -ENOENT;
1324
1325                 connman_ipaddress_set_ipv6(address, config->ipv6_address,
1326                                         config->ipv6_prefix_length,
1327                                         config->ipv6_gateway);
1328
1329                 connman_network_set_ipv6_method(network,
1330                                                 CONNMAN_IPCONFIG_METHOD_FIXED);
1331
1332                 if (connman_network_set_ipaddress(network, address) < 0)
1333                         DBG("Unable to set IPv6 address to network %p",
1334                                                                 network);
1335
1336                 connman_ipaddress_free(address);
1337         }
1338
1339         if (config->ipv6_privacy) {
1340                 struct connman_ipconfig *ipconfig;
1341
1342                 ipconfig = __connman_service_get_ip6config(service);
1343                 if (ipconfig)
1344                         __connman_ipconfig_ipv6_set_privacy(ipconfig,
1345                                                         config->ipv6_privacy);
1346         }
1347
1348         if (!config->ipv4_address) {
1349                 connman_network_set_ipv4_method(network,
1350                                                 CONNMAN_IPCONFIG_METHOD_DHCP);
1351         } else if (g_ascii_strcasecmp(config->ipv4_address, "off") == 0) {
1352                 connman_network_set_ipv4_method(network,
1353                                                 CONNMAN_IPCONFIG_METHOD_OFF);
1354         } else if (g_ascii_strcasecmp(config->ipv4_address, "auto") == 0 ||
1355                         g_ascii_strcasecmp(config->ipv4_address, "dhcp") == 0) {
1356                 connman_network_set_ipv4_method(network,
1357                                                 CONNMAN_IPCONFIG_METHOD_DHCP);
1358         } else {
1359                 struct connman_ipaddress *address;
1360
1361                 if (!config->ipv4_netmask) {
1362                         DBG("IPv4 netmask missing");
1363                         return -EINVAL;
1364                 }
1365
1366                 address = connman_ipaddress_alloc(AF_INET);
1367                 if (!address)
1368                         return -ENOENT;
1369
1370                 connman_ipaddress_set_ipv4(address, config->ipv4_address,
1371                                         config->ipv4_netmask,
1372                                         config->ipv4_gateway);
1373
1374                 connman_network_set_ipv4_method(network,
1375                                                 CONNMAN_IPCONFIG_METHOD_FIXED);
1376
1377                 if (connman_network_set_ipaddress(network, address) < 0)
1378                         DBG("Unable to set IPv4 address to network %p",
1379                                                                 network);
1380
1381                 connman_ipaddress_free(address);
1382         }
1383
1384         __connman_service_disconnect(service);
1385
1386         service_id = connman_service_get_identifier(service);
1387         config->service_identifiers =
1388                 g_slist_prepend(config->service_identifiers,
1389                                 g_strdup(service_id));
1390
1391         __connman_service_set_favorite_delayed(service, true, true);
1392
1393         __connman_service_set_config(service, config->config_ident,
1394                                                 config->config_entry);
1395
1396         if (config->domain_name)
1397                 __connman_service_set_domainname(service, config->domain_name);
1398
1399         if (config->nameservers) {
1400                 int i;
1401
1402                 __connman_service_nameserver_clear(service);
1403
1404                 for (i = 0; config->nameservers[i]; i++) {
1405                         __connman_service_nameserver_append(service,
1406                                                 config->nameservers[i], false);
1407                 }
1408         }
1409
1410         if (config->search_domains)
1411                 __connman_service_set_search_domains(service,
1412                                                 config->search_domains);
1413
1414         __connman_service_set_mdns(service, config->mdns);
1415
1416         if (config->timeservers)
1417                 __connman_service_set_timeservers(service,
1418                                                 config->timeservers);
1419
1420         if (type == CONNMAN_SERVICE_TYPE_WIFI) {
1421                 provision_service_wifi(config, service, network,
1422                                                         ssid, ssid_len);
1423         }
1424
1425         __connman_service_mark_dirty();
1426
1427         __connman_service_load_modifiable(service);
1428
1429         if (config->virtual) {
1430                 struct connect_virtual *virtual;
1431
1432                 virtual = g_malloc0(sizeof(struct connect_virtual));
1433                 virtual->service = service;
1434                 virtual->vfile = config->virtual_file;
1435
1436                 g_idle_add(remove_virtual_config, virtual);
1437
1438                 return 0;
1439         }
1440
1441         __connman_service_set_immutable(service, true);
1442
1443         if (type == CONNMAN_SERVICE_TYPE_ETHERNET ||
1444                         type == CONNMAN_SERVICE_TYPE_GADGET) {
1445                 __connman_service_connect(service,
1446                                 CONNMAN_SERVICE_CONNECT_REASON_AUTO);
1447
1448                 return 0;
1449         }
1450
1451         __connman_service_auto_connect(CONNMAN_SERVICE_CONNECT_REASON_AUTO);
1452
1453         return 0;
1454 }
1455
1456 static int
1457 find_and_provision_service_from_config(struct connman_service *service,
1458                                         struct connman_config *config)
1459 {
1460         GHashTableIter iter;
1461         gpointer value, key;
1462
1463         g_hash_table_iter_init(&iter, config->service_table);
1464         while (g_hash_table_iter_next(&iter, &key,
1465                                         &value)) {
1466                 if (!try_provision_service(value, service))
1467                         return 0;
1468         }
1469
1470         return -ENOENT;
1471 }
1472
1473 static int find_and_provision_service(struct connman_service *service)
1474 {
1475         GHashTableIter iter;
1476         gpointer value, key;
1477
1478         g_hash_table_iter_init(&iter, config_table);
1479
1480         while (g_hash_table_iter_next(&iter, &key, &value)) {
1481                 struct connman_config *config = value;
1482
1483                 if (!find_and_provision_service_from_config(service, config))
1484                         return 0;
1485         }
1486
1487         return -ENOENT;
1488 }
1489
1490 int __connman_config_provision_service(struct connman_service *service)
1491 {
1492         enum connman_service_type type;
1493
1494         /* For now only WiFi, Gadget and Ethernet services are supported */
1495         type = connman_service_get_type(service);
1496
1497         DBG("service %p type %d", service, type);
1498
1499         if (type != CONNMAN_SERVICE_TYPE_WIFI &&
1500                         type != CONNMAN_SERVICE_TYPE_ETHERNET &&
1501                         type != CONNMAN_SERVICE_TYPE_GADGET)
1502                 return -ENOSYS;
1503
1504         return find_and_provision_service(service);
1505 }
1506
1507 int __connman_config_provision_service_ident(struct connman_service *service,
1508                         const char *ident, const char *file, const char *entry)
1509 {
1510         enum connman_service_type type;
1511         struct connman_config *config;
1512         int ret = 0;
1513
1514         /* For now only WiFi, Gadget and Ethernet services are supported */
1515         type = connman_service_get_type(service);
1516
1517         DBG("service %p type %d", service, type);
1518
1519         if (type != CONNMAN_SERVICE_TYPE_WIFI &&
1520                         type != CONNMAN_SERVICE_TYPE_ETHERNET &&
1521                         type != CONNMAN_SERVICE_TYPE_GADGET)
1522                 return -ENOSYS;
1523
1524         config = g_hash_table_lookup(config_table, ident);
1525         if (config) {
1526                 GHashTableIter iter;
1527                 gpointer value, key;
1528                 bool found = false;
1529
1530                 g_hash_table_iter_init(&iter, config->service_table);
1531
1532                 /*
1533                  * Check if we need to remove individual service if it
1534                  * is missing from config file.
1535                  */
1536                 if (file && entry) {
1537                         while (g_hash_table_iter_next(&iter, &key,
1538                                                         &value)) {
1539                                 struct connman_config_service *config_service;
1540
1541                                 config_service = value;
1542
1543                                 if (g_strcmp0(config_service->config_ident,
1544                                                                 file) != 0)
1545                                         continue;
1546
1547                                 if (g_strcmp0(config_service->config_entry,
1548                                                                 entry) != 0)
1549                                         continue;
1550
1551                                 found = true;
1552                                 break;
1553                         }
1554
1555                         DBG("found %d ident %s file %s entry %s", found, ident,
1556                                                                 file, entry);
1557
1558                         if (!found) {
1559                                 /*
1560                                  * The entry+8 will skip "service_" prefix
1561                                  */
1562                                 g_hash_table_remove(config->service_table,
1563                                                 entry + 8);
1564                                 ret = 1;
1565                         }
1566                 }
1567
1568                 find_and_provision_service_from_config(service, config);
1569         }
1570
1571         return ret;
1572 }
1573
1574 static void generate_random_string(char *str, int length)
1575 {
1576         uint8_t val;
1577         int i;
1578         uint64_t rand;
1579
1580         memset(str, '\0', length);
1581
1582         for (i = 0; i < length-1; i++) {
1583                 do {
1584                         __connman_util_get_random(&rand);
1585                         val = (uint8_t)(rand % 122);
1586                         if (val < 48)
1587                                 val += 48;
1588                 } while((val > 57 && val < 65) || (val > 90 && val < 97));
1589
1590                 str[i] = val;
1591         }
1592 }
1593
1594 int connman_config_provision_mutable_service(GKeyFile *keyfile)
1595 {
1596         struct connman_config_service *service_config;
1597         struct connman_config *config;
1598         char *vfile, *group = NULL;
1599         char rstr[11];
1600
1601         DBG("");
1602
1603         generate_random_string(rstr, 11);
1604
1605         vfile = g_strdup_printf("service_mutable_%s.config", rstr);
1606
1607         config = create_config(vfile);
1608         if (!config)
1609                 return -ENOMEM;
1610
1611         if (!load_service_from_keyfile(keyfile, config))
1612                 goto error;
1613
1614         group = g_key_file_get_start_group(keyfile);
1615
1616         service_config = g_hash_table_lookup(config->service_table, group+8);
1617         if (!service_config)
1618                 goto error;
1619
1620         /* Specific to non file based config: */
1621         g_free(service_config->config_ident);
1622         service_config->config_ident = NULL;
1623         g_free(service_config->config_entry);
1624         service_config->config_entry = NULL;
1625
1626         service_config->virtual = true;
1627         service_config->virtual_file = vfile;
1628
1629         __connman_service_provision_changed(vfile);
1630
1631         if (g_strcmp0(service_config->type, "wifi") == 0)
1632                 __connman_device_request_scan(CONNMAN_SERVICE_TYPE_WIFI);
1633
1634         g_free(group);
1635         return 0;
1636
1637 error:
1638         DBG("Could not proceed");
1639         g_hash_table_remove(config_table, vfile);
1640         g_free(vfile);
1641         g_free(group);
1642         return -EINVAL;
1643 }
1644
1645 struct connman_config_entry **connman_config_get_entries(const char *type)
1646 {
1647         GHashTableIter iter_file, iter_config;
1648         gpointer value, key;
1649         struct connman_config_entry **entries = NULL;
1650         int i = 0, count;
1651
1652         g_hash_table_iter_init(&iter_file, config_table);
1653         while (g_hash_table_iter_next(&iter_file, &key, &value)) {
1654                 struct connman_config *config_file = value;
1655                 struct connman_config_entry **tmp_entries = entries;
1656
1657                 count = g_hash_table_size(config_file->service_table);
1658
1659                 entries = g_try_realloc(entries, (i + count + 1) *
1660                                         sizeof(struct connman_config_entry *));
1661                 if (!entries) {
1662                         g_free(tmp_entries);
1663                         return NULL;
1664                 }
1665
1666                 g_hash_table_iter_init(&iter_config,
1667                                                 config_file->service_table);
1668                 while (g_hash_table_iter_next(&iter_config, &key,
1669                                                         &value)) {
1670                         struct connman_config_service *config = value;
1671
1672                         if (type &&
1673                                         g_strcmp0(config->type, type) != 0)
1674                                 continue;
1675
1676                         entries[i] = g_try_new0(struct connman_config_entry,
1677                                                 1);
1678                         if (!entries[i])
1679                                 goto cleanup;
1680
1681                         entries[i]->ident = g_strdup(config->ident);
1682                         entries[i]->name = g_strdup(config->name);
1683                         entries[i]->ssid = g_try_malloc0(config->ssid_len + 1);
1684                         if (!entries[i]->ssid)
1685                                 goto cleanup;
1686
1687                         memcpy(entries[i]->ssid, config->ssid,
1688                                                         config->ssid_len);
1689                         entries[i]->ssid_len = config->ssid_len;
1690                         entries[i]->hidden = config->hidden;
1691
1692                         i++;
1693                 }
1694         }
1695
1696         if (entries) {
1697                 struct connman_config_entry **tmp_entries = entries;
1698
1699                 entries = g_try_realloc(entries, (i + 1) *
1700                                         sizeof(struct connman_config_entry *));
1701                 if (!entries) {
1702                         g_free(tmp_entries);
1703                         return NULL;
1704                 }
1705
1706                 entries[i] = NULL;
1707
1708                 DBG("%d provisioned AP found", i);
1709         }
1710
1711         return entries;
1712
1713 cleanup:
1714         connman_config_free_entries(entries);
1715         return NULL;
1716 }
1717
1718 void connman_config_free_entries(struct connman_config_entry **entries)
1719 {
1720         int i;
1721
1722         if (!entries)
1723                 return;
1724
1725         for (i = 0; entries[i]; i++) {
1726                 g_free(entries[i]->ident);
1727                 g_free(entries[i]->name);
1728                 g_free(entries[i]->ssid);
1729                 g_free(entries[i]);
1730         }
1731
1732         g_free(entries);
1733 }
1734
1735 bool __connman_config_address_provisioned(const char *address,
1736                                         const char *netmask)
1737 {
1738         GHashTableIter iter, siter;
1739         gpointer value, key, svalue, skey;
1740
1741         if (!address || !netmask)
1742                 return false;
1743
1744         g_hash_table_iter_init(&iter, config_table);
1745
1746         while (g_hash_table_iter_next(&iter, &key, &value)) {
1747                 struct connman_config *config = value;
1748
1749                 g_hash_table_iter_init(&siter, config->service_table);
1750                 while (g_hash_table_iter_next(&siter, &skey, &svalue)) {
1751                         struct connman_config_service *service = svalue;
1752
1753                         if (!g_strcmp0(address, service->ipv4_address) &&
1754                                         !g_strcmp0(netmask,
1755                                                 service->ipv4_netmask))
1756                                 return true;
1757                 }
1758         }
1759
1760         return false;
1761 }