libeap/hs20/client/osu_client.c

   1 /*
   2  * Hotspot 2.0 OSU client
   3  * Copyright (c) 2012-2014, Qualcomm Atheros, Inc.
   4  *
   5  * This software may be distributed under the terms of the BSD license.
   6  * See README for more details.
   7  */
   8
   9 #include "includes.h"
  10 #include <time.h>
  11 #include <sys/stat.h>
  12 #ifdef ANDROID
  13 #include "private/android_filesystem_config.h"
  14 #endif /* ANDROID */
  15
  16 #include "common.h"
  17 #include "utils/browser.h"
  18 #include "utils/base64.h"
  19 #include "utils/xml-utils.h"
  20 #include "utils/http-utils.h"
  21 #include "common/wpa_ctrl.h"
  22 #include "common/wpa_helpers.h"
  23 #include "eap_common/eap_defs.h"
  24 #include "crypto/crypto.h"
  25 #include "crypto/sha256.h"
  26 #include "osu_client.h"
  27
  28 const char *spp_xsd_fname = "spp.xsd";
  29
  30
  31 void write_result(struct hs20_osu_client *ctx, const char *fmt, ...)
  32 {
  33         va_list ap;
  34         FILE *f;
  35         char buf[500];
  36
  37         va_start(ap, fmt);
  38         vsnprintf(buf, sizeof(buf), fmt, ap);
  39         va_end(ap);
  40         write_summary(ctx, "%s", buf);
  41
  42         if (!ctx->result_file)
  43                 return;
  44
  45         f = fopen(ctx->result_file, "w");
  46         if (f == NULL)
  47                 return;
  48
  49         va_start(ap, fmt);
  50         vfprintf(f, fmt, ap);
  51         va_end(ap);
  52         fprintf(f, "\n");
  53         fclose(f);
  54 }
  55
  56
  57 void write_summary(struct hs20_osu_client *ctx, const char *fmt, ...)
  58 {
  59         va_list ap;
  60         FILE *f;
  61
  62         if (!ctx->summary_file)
  63                 return;
  64
  65         f = fopen(ctx->summary_file, "a");
  66         if (f == NULL)
  67                 return;
  68
  69         va_start(ap, fmt);
  70         vfprintf(f, fmt, ap);
  71         va_end(ap);
  72         fprintf(f, "\n");
  73         fclose(f);
  74 }
  75
  76
  77 void debug_dump_node(struct hs20_osu_client *ctx, const char *title,
  78                      xml_node_t *node)
  79 {
  80         char *str = xml_node_to_str(ctx->xml, node);
  81         wpa_printf(MSG_DEBUG, "[hs20] %s: '%s'", title, str);
  82         free(str);
  83 }
  84
  85
  86 static int valid_fqdn(const char *fqdn)
  87 {
  88         const char *pos;
  89
  90         /* TODO: could make this more complete.. */
  91         if (strchr(fqdn, '.') == 0 || strlen(fqdn) > 255)
  92                 return 0;
  93         for (pos = fqdn; *pos; pos++) {
  94                 if (*pos >= 'a' && *pos <= 'z')
  95                         continue;
  96                 if (*pos >= 'A' && *pos <= 'Z')
  97                         continue;
  98                 if (*pos >= '0' && *pos <= '9')
  99                         continue;
 100                 if (*pos == '-' || *pos == '.' || *pos == '_')
 101                         continue;
 102                 return 0;
 103         }
 104         return 1;
 105 }
 106
 107
 108 int osu_get_certificate(struct hs20_osu_client *ctx, xml_node_t *getcert)
 109 {
 110         xml_node_t *node;
 111         char *url, *user = NULL, *pw = NULL;
 112         char *proto;
 113         int ret = -1;
 114
 115         proto = xml_node_get_attr_value(ctx->xml, getcert,
 116                                         "enrollmentProtocol");
 117         if (!proto)
 118                 return -1;
 119         wpa_printf(MSG_INFO, "getCertificate - enrollmentProtocol=%s", proto);
 120         write_summary(ctx, "getCertificate - enrollmentProtocol=%s", proto);
 121         if (os_strcasecmp(proto, "EST") != 0) {
 122                 wpa_printf(MSG_INFO, "Unsupported enrollmentProtocol");
 123                 xml_node_get_attr_value_free(ctx->xml, proto);
 124                 return -1;
 125         }
 126         xml_node_get_attr_value_free(ctx->xml, proto);
 127
 128         node = get_node(ctx->xml, getcert, "enrollmentServerURI");
 129         if (node == NULL) {
 130                 wpa_printf(MSG_INFO, "Could not find enrollmentServerURI node");
 131                 xml_node_get_attr_value_free(ctx->xml, proto);
 132                 return -1;
 133         }
 134         url = xml_node_get_text(ctx->xml, node);
 135         if (url == NULL) {
 136                 wpa_printf(MSG_INFO, "Could not get URL text");
 137                 return -1;
 138         }
 139         wpa_printf(MSG_INFO, "enrollmentServerURI: %s", url);
 140         write_summary(ctx, "enrollmentServerURI: %s", url);
 141
 142         node = get_node(ctx->xml, getcert, "estUserID");
 143         if (node == NULL && !ctx->client_cert_present) {
 144                 wpa_printf(MSG_INFO, "Could not find estUserID node");
 145                 goto fail;
 146         }
 147         if (node) {
 148                 user = xml_node_get_text(ctx->xml, node);
 149                 if (user == NULL) {
 150                         wpa_printf(MSG_INFO, "Could not get estUserID text");
 151                         goto fail;
 152                 }
 153                 wpa_printf(MSG_INFO, "estUserID: %s", user);
 154                 write_summary(ctx, "estUserID: %s", user);
 155         }
 156
 157         node = get_node(ctx->xml, getcert, "estPassword");
 158         if (node == NULL && !ctx->client_cert_present) {
 159                 wpa_printf(MSG_INFO, "Could not find estPassword node");
 160                 goto fail;
 161         }
 162         if (node) {
 163                 pw = xml_node_get_base64_text(ctx->xml, node, NULL);
 164                 if (pw == NULL) {
 165                         wpa_printf(MSG_INFO, "Could not get estPassword text");
 166                         goto fail;
 167                 }
 168                 wpa_printf(MSG_INFO, "estPassword: %s", pw);
 169         }
 170
 171         mkdir("Cert", S_IRWXU);
 172         if (est_load_cacerts(ctx, url) < 0 ||
 173             est_build_csr(ctx, url) < 0 ||
 174             est_simple_enroll(ctx, url, user, pw) < 0)
 175                 goto fail;
 176
 177         ret = 0;
 178 fail:
 179         xml_node_get_text_free(ctx->xml, url);
 180         xml_node_get_text_free(ctx->xml, user);
 181         xml_node_get_text_free(ctx->xml, pw);
 182
 183         return ret;
 184 }
 185
 186
 187 static int process_est_cert(struct hs20_osu_client *ctx, xml_node_t *cert,
 188                             const char *fqdn)
 189 {
 190         u8 digest1[SHA256_MAC_LEN], digest2[SHA256_MAC_LEN];
 191         char *der, *pem;
 192         size_t der_len, pem_len;
 193         char *fingerprint;
 194         char buf[200];
 195
 196         wpa_printf(MSG_INFO, "PPS for certificate credential - fqdn=%s", fqdn);
 197
 198         fingerprint = xml_node_get_text(ctx->xml, cert);
 199         if (fingerprint == NULL)
 200                 return -1;
 201         if (hexstr2bin(fingerprint, digest1, SHA256_MAC_LEN) < 0) {
 202                 wpa_printf(MSG_INFO, "Invalid SHA256 hash value");
 203                 write_result(ctx, "Invalid client certificate SHA256 hash value in PPS");
 204                 xml_node_get_text_free(ctx->xml, fingerprint);
 205                 return -1;
 206         }
 207         xml_node_get_text_free(ctx->xml, fingerprint);
 208
 209         der = os_readfile("Cert/est_cert.der", &der_len);
 210         if (der == NULL) {
 211                 wpa_printf(MSG_INFO, "Could not find client certificate from EST");
 212                 write_result(ctx, "Could not find client certificate from EST");
 213                 return -1;
 214         }
 215
 216         if (sha256_vector(1, (const u8 **) &der, &der_len, digest2) < 0) {
 217                 os_free(der);
 218                 return -1;
 219         }
 220         os_free(der);
 221
 222         if (os_memcmp(digest1, digest2, sizeof(digest1)) != 0) {
 223                 wpa_printf(MSG_INFO, "Client certificate from EST does not match fingerprint from PPS MO");
 224                 write_result(ctx, "Client certificate from EST does not match fingerprint from PPS MO");
 225                 return -1;
 226         }
 227
 228         wpa_printf(MSG_INFO, "Client certificate from EST matches PPS MO");
 229         unlink("Cert/est_cert.der");
 230
 231         os_snprintf(buf, sizeof(buf), "SP/%s/client-ca.pem", fqdn);
 232         if (rename("Cert/est-cacerts.pem", buf) < 0) {
 233                 wpa_printf(MSG_INFO, "Could not move est-cacerts.pem to client-ca.pem: %s",
 234                            strerror(errno));
 235                 return -1;
 236         }
 237         pem = os_readfile(buf, &pem_len);
 238
 239         os_snprintf(buf, sizeof(buf), "SP/%s/client-cert.pem", fqdn);
 240         if (rename("Cert/est_cert.pem", buf) < 0) {
 241                 wpa_printf(MSG_INFO, "Could not move est_cert.pem to client-cert.pem: %s",
 242                            strerror(errno));
 243                 os_free(pem);
 244                 return -1;
 245         }
 246
 247         if (pem) {
 248                 FILE *f = fopen(buf, "a");
 249                 if (f) {
 250                         fwrite(pem, pem_len, 1, f);
 251                         fclose(f);
 252                 }
 253                 os_free(pem);
 254         }
 255
 256         os_snprintf(buf, sizeof(buf), "SP/%s/client-key.pem", fqdn);
 257         if (rename("Cert/privkey-plain.pem", buf) < 0) {
 258                 wpa_printf(MSG_INFO, "Could not move privkey-plain.pem to client-key.pem: %s",
 259                            strerror(errno));
 260                 return -1;
 261         }
 262
 263         unlink("Cert/est-req.b64");
 264         unlink("Cert/est-req.pem");
 265         unlink("Cert/est-resp.raw");
 266         rmdir("Cert");
 267
 268         return 0;
 269 }
 270
 271
 272 #define TMP_CERT_DL_FILE "tmp-cert-download"
 273
 274 static int download_cert(struct hs20_osu_client *ctx, xml_node_t *params,
 275                          const char *fname)
 276 {
 277         xml_node_t *url_node, *hash_node;
 278         char *url, *hash;
 279         char *cert;
 280         size_t len;
 281         u8 digest1[SHA256_MAC_LEN], digest2[SHA256_MAC_LEN];
 282         int res;
 283         unsigned char *b64;
 284         FILE *f;
 285
 286         url_node = get_node(ctx->xml, params, "CertURL");
 287         hash_node = get_node(ctx->xml, params, "CertSHA256Fingerprint");
 288         if (url_node == NULL || hash_node == NULL)
 289                 return -1;
 290         url = xml_node_get_text(ctx->xml, url_node);
 291         hash = xml_node_get_text(ctx->xml, hash_node);
 292         if (url == NULL || hash == NULL) {
 293                 xml_node_get_text_free(ctx->xml, url);
 294                 xml_node_get_text_free(ctx->xml, hash);
 295                 return -1;
 296         }
 297
 298         wpa_printf(MSG_INFO, "CertURL: %s", url);
 299         wpa_printf(MSG_INFO, "SHA256 hash: %s", hash);
 300
 301         if (hexstr2bin(hash, digest1, SHA256_MAC_LEN) < 0) {
 302                 wpa_printf(MSG_INFO, "Invalid SHA256 hash value");
 303                 write_result(ctx, "Invalid SHA256 hash value for downloaded certificate");
 304                 xml_node_get_text_free(ctx->xml, hash);
 305                 return -1;
 306         }
 307         xml_node_get_text_free(ctx->xml, hash);
 308
 309         write_summary(ctx, "Download certificate from %s", url);
 310         ctx->no_osu_cert_validation = 1;
 311         http_ocsp_set(ctx->http, 1);
 312         res = http_download_file(ctx->http, url, TMP_CERT_DL_FILE, NULL);
 313         http_ocsp_set(ctx->http,
 314                       (ctx->workarounds & WORKAROUND_OCSP_OPTIONAL) ? 1 : 2);
 315         ctx->no_osu_cert_validation = 0;
 316         xml_node_get_text_free(ctx->xml, url);
 317         if (res < 0)
 318                 return -1;
 319
 320         cert = os_readfile(TMP_CERT_DL_FILE, &len);
 321         remove(TMP_CERT_DL_FILE);
 322         if (cert == NULL)
 323                 return -1;
 324
 325         if (sha256_vector(1, (const u8 **) &cert, &len, digest2) < 0) {
 326                 os_free(cert);
 327                 return -1;
 328         }
 329
 330         if (os_memcmp(digest1, digest2, sizeof(digest1)) != 0) {
 331                 wpa_printf(MSG_INFO, "Downloaded certificate fingerprint did not match");
 332                 write_result(ctx, "Downloaded certificate fingerprint did not match");
 333                 os_free(cert);
 334                 return -1;
 335         }
 336
 337         b64 = base64_encode((unsigned char *) cert, len, NULL);
 338         os_free(cert);
 339         if (b64 == NULL)
 340                 return -1;
 341
 342         f = fopen(fname, "wb");
 343         if (f == NULL) {
 344                 os_free(b64);
 345                 return -1;
 346         }
 347
 348         fprintf(f, "-----BEGIN CERTIFICATE-----\n"
 349                 "%s"
 350                 "-----END CERTIFICATE-----\n",
 351                 b64);
 352
 353         os_free(b64);
 354         fclose(f);
 355
 356         wpa_printf(MSG_INFO, "Downloaded certificate into %s and validated fingerprint",
 357                    fname);
 358         write_summary(ctx, "Downloaded certificate into %s and validated fingerprint",
 359                       fname);
 360
 361         return 0;
 362 }
 363
 364
 365 static int cmd_dl_osu_ca(struct hs20_osu_client *ctx, const char *pps_fname,
 366                          const char *ca_fname)
 367 {
 368         xml_node_t *pps, *node;
 369         int ret;
 370
 371         pps = node_from_file(ctx->xml, pps_fname);
 372         if (pps == NULL) {
 373                 wpa_printf(MSG_INFO, "Could not read or parse '%s'", pps_fname);
 374                 return -1;
 375         }
 376
 377         node = get_child_node(ctx->xml, pps,
 378                               "SubscriptionUpdate/TrustRoot");
 379         if (node == NULL) {
 380                 wpa_printf(MSG_INFO, "No SubscriptionUpdate/TrustRoot/CertURL found from PPS");
 381                 xml_node_free(ctx->xml, pps);
 382                 return -1;
 383         }
 384
 385         ret = download_cert(ctx, node, ca_fname);
 386         xml_node_free(ctx->xml, pps);
 387
 388         return ret;
 389 }
 390
 391
 392 static int cmd_dl_polupd_ca(struct hs20_osu_client *ctx, const char *pps_fname,
 393                             const char *ca_fname)
 394 {
 395         xml_node_t *pps, *node;
 396         int ret;
 397
 398         pps = node_from_file(ctx->xml, pps_fname);
 399         if (pps == NULL) {
 400                 wpa_printf(MSG_INFO, "Could not read or parse '%s'", pps_fname);
 401                 return -1;
 402         }
 403
 404         node = get_child_node(ctx->xml, pps,
 405                               "Policy/PolicyUpdate/TrustRoot");
 406         if (node == NULL) {
 407                 wpa_printf(MSG_INFO, "No Policy/PolicyUpdate/TrustRoot/CertURL found from PPS");
 408                 xml_node_free(ctx->xml, pps);
 409                 return -1;
 410         }
 411
 412         ret = download_cert(ctx, node, ca_fname);
 413         xml_node_free(ctx->xml, pps);
 414
 415         return ret;
 416 }
 417
 418
 419 static int cmd_dl_aaa_ca(struct hs20_osu_client *ctx, const char *pps_fname,
 420                          const char *ca_fname)
 421 {
 422         xml_node_t *pps, *node, *aaa;
 423         int ret;
 424
 425         pps = node_from_file(ctx->xml, pps_fname);
 426         if (pps == NULL) {
 427                 wpa_printf(MSG_INFO, "Could not read or parse '%s'", pps_fname);
 428                 return -1;
 429         }
 430
 431         node = get_child_node(ctx->xml, pps,
 432                               "AAAServerTrustRoot");
 433         if (node == NULL) {
 434                 wpa_printf(MSG_INFO, "No AAAServerTrustRoot/CertURL found from PPS");
 435                 xml_node_free(ctx->xml, pps);
 436                 return -1;
 437         }
 438
 439         aaa = xml_node_first_child(ctx->xml, node);
 440         if (aaa == NULL) {
 441                 wpa_printf(MSG_INFO, "No AAAServerTrustRoot/CertURL found from PPS");
 442                 xml_node_free(ctx->xml, pps);
 443                 return -1;
 444         }
 445
 446         ret = download_cert(ctx, aaa, ca_fname);
 447         xml_node_free(ctx->xml, pps);
 448
 449         return ret;
 450 }
 451
 452
 453 static int download_trust_roots(struct hs20_osu_client *ctx,
 454                                 const char *pps_fname)
 455 {
 456         char *dir, *pos;
 457         char fname[300];
 458         int ret;
 459
 460         dir = os_strdup(pps_fname);
 461         if (dir == NULL)
 462                 return -1;
 463         pos = os_strrchr(dir, '/');
 464         if (pos == NULL) {
 465                 os_free(dir);
 466                 return -1;
 467         }
 468         *pos = '\0';
 469
 470         snprintf(fname, sizeof(fname), "%s/ca.pem", dir);
 471         ret = cmd_dl_osu_ca(ctx, pps_fname, fname);
 472         snprintf(fname, sizeof(fname), "%s/polupd-ca.pem", dir);
 473         cmd_dl_polupd_ca(ctx, pps_fname, fname);
 474         snprintf(fname, sizeof(fname), "%s/aaa-ca.pem", dir);
 475         cmd_dl_aaa_ca(ctx, pps_fname, fname);
 476
 477         os_free(dir);
 478
 479         return ret;
 480 }
 481
 482
 483 static int server_dnsname_suffix_match(struct hs20_osu_client *ctx,
 484                                        const char *fqdn)
 485 {
 486         size_t match_len, len, i;
 487         const char *val;
 488
 489         match_len = os_strlen(fqdn);
 490
 491         for (i = 0; i < ctx->server_dnsname_count; i++) {
 492                 wpa_printf(MSG_INFO,
 493                            "Checking suffix match against server dNSName %s",
 494                            ctx->server_dnsname[i]);
 495                 val = ctx->server_dnsname[i];
 496                 len = os_strlen(val);
 497
 498                 if (match_len > len)
 499                         continue;
 500
 501                 if (os_strncasecmp(val + len - match_len, fqdn, match_len) != 0)
 502                         continue; /* no match */
 503
 504                 if (match_len == len)
 505                         return 1; /* exact match */
 506
 507                 if (val[len - match_len - 1] == '.')
 508                         return 1; /* full label match completes suffix match */
 509
 510                 /* Reject due to incomplete label match */
 511         }
 512
 513         /* None of the dNSName(s) matched */
 514         return 0;
 515 }
 516
 517
 518 int hs20_add_pps_mo(struct hs20_osu_client *ctx, const char *uri,
 519                     xml_node_t *add_mo, char *fname, size_t fname_len)
 520 {
 521         char *str;
 522         char *fqdn, *pos;
 523         xml_node_t *tnds, *mo, *cert;
 524         const char *name;
 525         int ret;
 526
 527         if (strncmp(uri, "./Wi-Fi/", 8) != 0) {
 528                 wpa_printf(MSG_INFO, "Unsupported location for addMO to add PPS MO: '%s'",
 529                            uri);
 530                 write_result(ctx, "Unsupported location for addMO to add PPS MO: '%s'",
 531                              uri);
 532                 return -1;
 533         }
 534
 535         fqdn = strdup(uri + 8);
 536         if (fqdn == NULL)
 537                 return -1;
 538         pos = strchr(fqdn, '/');
 539         if (pos) {
 540                 if (os_strcasecmp(pos, "/PerProviderSubscription") != 0) {
 541                         wpa_printf(MSG_INFO, "Unsupported location for addMO to add PPS MO (extra directory): '%s'",
 542                                    uri);
 543                         write_result(ctx, "Unsupported location for addMO to "
 544                                      "add PPS MO (extra directory): '%s'", uri);
 545                         free(fqdn);
 546                         return -1;
 547                 }
 548                 *pos = '\0'; /* remove trailing slash and PPS node name */
 549         }
 550         wpa_printf(MSG_INFO, "SP FQDN: %s", fqdn);
 551
 552         if (!server_dnsname_suffix_match(ctx, fqdn)) {
 553                 wpa_printf(MSG_INFO,
 554                            "FQDN '%s' for new PPS MO did not have suffix match with server's dNSName values, count: %d",
 555                            fqdn, (int) ctx->server_dnsname_count);
 556                 write_result(ctx, "FQDN '%s' for new PPS MO did not have suffix match with server's dNSName values",
 557                              fqdn);
 558                 free(fqdn);
 559                 return -1;
 560         }
 561
 562         if (!valid_fqdn(fqdn)) {
 563                 wpa_printf(MSG_INFO, "Invalid FQDN '%s'", fqdn);
 564                 write_result(ctx, "Invalid FQDN '%s'", fqdn);
 565                 free(fqdn);
 566                 return -1;
 567         }
 568
 569         mkdir("SP", S_IRWXU);
 570         snprintf(fname, fname_len, "SP/%s", fqdn);
 571         if (mkdir(fname, S_IRWXU) < 0) {
 572                 if (errno != EEXIST) {
 573                         int err = errno;
 574                         wpa_printf(MSG_INFO, "mkdir(%s) failed: %s",
 575                                    fname, strerror(err));
 576                         free(fqdn);
 577                         return -1;
 578                 }
 579         }
 580
 581 #ifdef ANDROID
 582         /* Allow processes running with Group ID as AID_WIFI,
 583          * to read files from SP/<fqdn> directory */
 584         if (chown(fname, -1, AID_WIFI)) {
 585                 wpa_printf(MSG_INFO, "CTRL: Could not chown directory: %s",
 586                            strerror(errno));
 587                 /* Try to continue anyway */
 588         }
 589         if (chmod(fname, S_IRWXU | S_IRGRP | S_IXGRP) < 0) {
 590                 wpa_printf(MSG_INFO, "CTRL: Could not chmod directory: %s",
 591                            strerror(errno));
 592                 /* Try to continue anyway */
 593         }
 594 #endif /* ANDROID */
 595
 596         snprintf(fname, fname_len, "SP/%s/pps.xml", fqdn);
 597
 598         if (os_file_exists(fname)) {
 599                 wpa_printf(MSG_INFO, "PPS file '%s' exists - reject addMO",
 600                            fname);
 601                 write_result(ctx, "PPS file '%s' exists - reject addMO",
 602                              fname);
 603                 free(fqdn);
 604                 return -2;
 605         }
 606         wpa_printf(MSG_INFO, "Using PPS file: %s", fname);
 607
 608         str = xml_node_get_text(ctx->xml, add_mo);
 609         if (str == NULL) {
 610                 wpa_printf(MSG_INFO, "Could not extract MO text");
 611                 free(fqdn);
 612                 return -1;
 613         }
 614         wpa_printf(MSG_DEBUG, "[hs20] addMO text: '%s'", str);
 615
 616         tnds = xml_node_from_buf(ctx->xml, str);
 617         xml_node_get_text_free(ctx->xml, str);
 618         if (tnds == NULL) {
 619                 wpa_printf(MSG_INFO, "[hs20] Could not parse addMO text");
 620                 free(fqdn);
 621                 return -1;
 622         }
 623
 624         mo = tnds_to_mo(ctx->xml, tnds);
 625         if (mo == NULL) {
 626                 wpa_printf(MSG_INFO, "[hs20] Could not parse addMO TNDS text");
 627                 free(fqdn);
 628                 return -1;
 629         }
 630
 631         debug_dump_node(ctx, "Parsed TNDS", mo);
 632
 633         name = xml_node_get_localname(ctx->xml, mo);
 634         if (os_strcasecmp(name, "PerProviderSubscription") != 0) {
 635                 wpa_printf(MSG_INFO, "[hs20] Unexpected PPS MO root node name '%s'",
 636                            name);
 637                 free(fqdn);
 638                 return -1;
 639         }
 640
 641         cert = get_child_node(ctx->xml, mo,
 642                               "Credential/DigitalCertificate/"
 643                               "CertSHA256Fingerprint");
 644         if (cert && process_est_cert(ctx, cert, fqdn) < 0) {
 645                 xml_node_free(ctx->xml, mo);
 646                 free(fqdn);
 647                 return -1;
 648         }
 649         free(fqdn);
 650
 651         if (node_to_file(ctx->xml, fname, mo) < 0) {
 652                 wpa_printf(MSG_INFO, "Could not write MO to file");
 653                 xml_node_free(ctx->xml, mo);
 654                 return -1;
 655         }
 656         xml_node_free(ctx->xml, mo);
 657
 658         wpa_printf(MSG_INFO, "A new PPS MO added as '%s'", fname);
 659         write_summary(ctx, "A new PPS MO added as '%s'", fname);
 660
 661         ret = download_trust_roots(ctx, fname);
 662         if (ret < 0) {
 663                 wpa_printf(MSG_INFO, "Remove invalid PPS MO file");
 664                 write_summary(ctx, "Remove invalid PPS MO file");
 665                 unlink(fname);
 666         }
 667
 668         return ret;
 669 }
 670
 671
 672 int update_pps_file(struct hs20_osu_client *ctx, const char *pps_fname,
 673                     xml_node_t *pps)
 674 {
 675         char *str;
 676         FILE *f;
 677         char backup[300];
 678
 679         if (ctx->client_cert_present) {
 680                 xml_node_t *cert;
 681                 cert = get_child_node(ctx->xml, pps,
 682                                       "Credential/DigitalCertificate/"
 683                                       "CertSHA256Fingerprint");
 684                 if (cert && os_file_exists("Cert/est_cert.der") &&
 685                     process_est_cert(ctx, cert, ctx->fqdn) < 0) {
 686                         wpa_printf(MSG_INFO, "EST certificate update processing failed on PPS MO update");
 687                         return -1;
 688                 }
 689         }
 690
 691         wpa_printf(MSG_INFO, "Updating PPS MO %s", pps_fname);
 692
 693         str = xml_node_to_str(ctx->xml, pps);
 694         if (str == NULL) {
 695                 wpa_printf(MSG_ERROR, "No node found");
 696                 return -1;
 697         }
 698         wpa_printf(MSG_MSGDUMP, "[hs20] Updated PPS: '%s'", str);
 699
 700         snprintf(backup, sizeof(backup), "%s.bak", pps_fname);
 701         rename(pps_fname, backup);
 702         f = fopen(pps_fname, "w");
 703         if (f == NULL) {
 704                 wpa_printf(MSG_INFO, "Could not write PPS");
 705                 rename(backup, pps_fname);
 706                 free(str);
 707                 return -1;
 708         }
 709         fprintf(f, "%s\n", str);
 710         fclose(f);
 711
 712         free(str);
 713
 714         return 0;
 715 }
 716
 717
 718 void get_user_pw(struct hs20_osu_client *ctx, xml_node_t *pps,
 719                  const char *alt_loc, char **user, char **pw)
 720 {
 721         xml_node_t *node;
 722
 723         node = get_child_node(ctx->xml, pps,
 724                               "Credential/UsernamePassword/Username");
 725         if (node)
 726                 *user = xml_node_get_text(ctx->xml, node);
 727
 728         node = get_child_node(ctx->xml, pps,
 729                               "Credential/UsernamePassword/Password");
 730         if (node)
 731                 *pw = xml_node_get_base64_text(ctx->xml, node, NULL);
 732
 733         node = get_child_node(ctx->xml, pps, alt_loc);
 734         if (node) {
 735                 xml_node_t *a;
 736                 a = get_node(ctx->xml, node, "Username");
 737                 if (a) {
 738                         xml_node_get_text_free(ctx->xml, *user);
 739                         *user = xml_node_get_text(ctx->xml, a);
 740                         wpa_printf(MSG_INFO, "Use OSU username '%s'", *user);
 741                 }
 742
 743                 a = get_node(ctx->xml, node, "Password");
 744                 if (a) {
 745                         free(*pw);
 746                         *pw = xml_node_get_base64_text(ctx->xml, a, NULL);
 747                         wpa_printf(MSG_INFO, "Use OSU password");
 748                 }
 749         }
 750 }
 751
 752
 753 /* Remove old credentials based on HomeSP/FQDN */
 754 static void remove_sp_creds(struct hs20_osu_client *ctx, const char *fqdn)
 755 {
 756         char cmd[300];
 757         os_snprintf(cmd, sizeof(cmd), "REMOVE_CRED provisioning_sp=%s", fqdn);
 758         if (wpa_command(ctx->ifname, cmd) < 0)
 759                 wpa_printf(MSG_INFO, "Failed to remove old credential(s)");
 760 }
 761
 762
 763 static void set_pps_cred_policy_spe(struct hs20_osu_client *ctx, int id,
 764                                     xml_node_t *spe)
 765 {
 766         xml_node_t *ssid;
 767         char *txt;
 768
 769         ssid = get_node(ctx->xml, spe, "SSID");
 770         if (ssid == NULL)
 771                 return;
 772         txt = xml_node_get_text(ctx->xml, ssid);
 773         if (txt == NULL)
 774                 return;
 775         wpa_printf(MSG_DEBUG, "- Policy/SPExclusionList/<X+>/SSID = %s", txt);
 776         if (set_cred_quoted(ctx->ifname, id, "excluded_ssid", txt) < 0)
 777                 wpa_printf(MSG_INFO, "Failed to set cred excluded_ssid");
 778         xml_node_get_text_free(ctx->xml, txt);
 779 }
 780
 781
 782 static void set_pps_cred_policy_spel(struct hs20_osu_client *ctx, int id,
 783                                      xml_node_t *spel)
 784 {
 785         xml_node_t *child;
 786
 787         xml_node_for_each_child(ctx->xml, child, spel) {
 788                 xml_node_for_each_check(ctx->xml, child);
 789                 set_pps_cred_policy_spe(ctx, id, child);
 790         }
 791 }
 792
 793
 794 static void set_pps_cred_policy_prp(struct hs20_osu_client *ctx, int id,
 795                                     xml_node_t *prp)
 796 {
 797         xml_node_t *node;
 798         char *txt = NULL, *pos;
 799         char *prio, *country_buf = NULL;
 800         const char *country;
 801         char val[200];
 802         int priority;
 803
 804         node = get_node(ctx->xml, prp, "Priority");
 805         if (node == NULL)
 806                 return;
 807         prio = xml_node_get_text(ctx->xml, node);
 808         if (prio == NULL)
 809                 return;
 810         wpa_printf(MSG_INFO, "- Policy/PreferredRoamingPartnerList/<X+>/Priority = %s",
 811                    prio);
 812         priority = atoi(prio);
 813         xml_node_get_text_free(ctx->xml, prio);
 814
 815         node = get_node(ctx->xml, prp, "Country");
 816         if (node) {
 817                 country_buf = xml_node_get_text(ctx->xml, node);
 818                 if (country_buf == NULL)
 819                         return;
 820                 country = country_buf;
 821                 wpa_printf(MSG_INFO, "- Policy/PreferredRoamingPartnerList/<X+>/Country = %s",
 822                            country);
 823         } else {
 824                 country = "*";
 825         }
 826
 827         node = get_node(ctx->xml, prp, "FQDN_Match");
 828         if (node == NULL)
 829                 goto out;
 830         txt = xml_node_get_text(ctx->xml, node);
 831         if (txt == NULL)
 832                 goto out;
 833         wpa_printf(MSG_INFO, "- Policy/PreferredRoamingPartnerList/<X+>/FQDN_Match = %s",
 834                    txt);
 835         pos = strrchr(txt, ',');
 836         if (pos == NULL)
 837                 goto out;
 838         *pos++ = '\0';
 839
 840         snprintf(val, sizeof(val), "%s,%d,%d,%s", txt,
 841                  strcmp(pos, "includeSubdomains") != 0, priority, country);
 842         if (set_cred_quoted(ctx->ifname, id, "roaming_partner", val) < 0)
 843                 wpa_printf(MSG_INFO, "Failed to set cred roaming_partner");
 844 out:
 845         xml_node_get_text_free(ctx->xml, country_buf);
 846         xml_node_get_text_free(ctx->xml, txt);
 847 }
 848
 849
 850 static void set_pps_cred_policy_prpl(struct hs20_osu_client *ctx, int id,
 851                                      xml_node_t *prpl)
 852 {
 853         xml_node_t *child;
 854
 855         xml_node_for_each_child(ctx->xml, child, prpl) {
 856                 xml_node_for_each_check(ctx->xml, child);
 857                 set_pps_cred_policy_prp(ctx, id, child);
 858         }
 859 }
 860
 861
 862 static void set_pps_cred_policy_min_backhaul(struct hs20_osu_client *ctx, int id,
 863                                              xml_node_t *min_backhaul)
 864 {
 865         xml_node_t *node;
 866         char *type, *dl = NULL, *ul = NULL;
 867         int home;
 868
 869         node = get_node(ctx->xml, min_backhaul, "NetworkType");
 870         if (node == NULL) {
 871                 wpa_printf(MSG_INFO, "Ignore MinBackhaulThreshold without mandatory NetworkType node");
 872                 return;
 873         }
 874
 875         type = xml_node_get_text(ctx->xml, node);
 876         if (type == NULL)
 877                 return;
 878         wpa_printf(MSG_INFO, "- Policy/MinBackhaulThreshold/<X+>/NetworkType = %s",
 879                    type);
 880         if (os_strcasecmp(type, "home") == 0)
 881                 home = 1;
 882         else if (os_strcasecmp(type, "roaming") == 0)
 883                 home = 0;
 884         else {
 885                 wpa_printf(MSG_INFO, "Ignore MinBackhaulThreshold with invalid NetworkType");
 886                 xml_node_get_text_free(ctx->xml, type);
 887                 return;
 888         }
 889         xml_node_get_text_free(ctx->xml, type);
 890
 891         node = get_node(ctx->xml, min_backhaul, "DLBandwidth");
 892         if (node)
 893                 dl = xml_node_get_text(ctx->xml, node);
 894
 895         node = get_node(ctx->xml, min_backhaul, "ULBandwidth");
 896         if (node)
 897                 ul = xml_node_get_text(ctx->xml, node);
 898
 899         if (dl == NULL && ul == NULL) {
 900                 wpa_printf(MSG_INFO, "Ignore MinBackhaulThreshold without either DLBandwidth or ULBandwidth nodes");
 901                 return;
 902         }
 903
 904         if (dl)
 905                 wpa_printf(MSG_INFO, "- Policy/MinBackhaulThreshold/<X+>/DLBandwidth = %s",
 906                            dl);
 907         if (ul)
 908                 wpa_printf(MSG_INFO, "- Policy/MinBackhaulThreshold/<X+>/ULBandwidth = %s",
 909                            ul);
 910
 911         if (home) {
 912                 if (dl &&
 913                     set_cred(ctx->ifname, id, "min_dl_bandwidth_home", dl) < 0)
 914                         wpa_printf(MSG_INFO, "Failed to set cred bandwidth limit");
 915                 if (ul &&
 916                     set_cred(ctx->ifname, id, "min_ul_bandwidth_home", ul) < 0)
 917                         wpa_printf(MSG_INFO, "Failed to set cred bandwidth limit");
 918         } else {
 919                 if (dl &&
 920                     set_cred(ctx->ifname, id, "min_dl_bandwidth_roaming", dl) <
 921                     0)
 922                         wpa_printf(MSG_INFO, "Failed to set cred bandwidth limit");
 923                 if (ul &&
 924                     set_cred(ctx->ifname, id, "min_ul_bandwidth_roaming", ul) <
 925                     0)
 926                         wpa_printf(MSG_INFO, "Failed to set cred bandwidth limit");
 927         }
 928
 929         xml_node_get_text_free(ctx->xml, dl);
 930         xml_node_get_text_free(ctx->xml, ul);
 931 }
 932
 933
 934 static void set_pps_cred_policy_min_backhaul_list(struct hs20_osu_client *ctx,
 935                                                   int id, xml_node_t *node)
 936 {
 937         xml_node_t *child;
 938
 939         wpa_printf(MSG_INFO, "- Policy/MinBackhaulThreshold");
 940
 941         xml_node_for_each_child(ctx->xml, child, node) {
 942                 xml_node_for_each_check(ctx->xml, child);
 943                 set_pps_cred_policy_min_backhaul(ctx, id, child);
 944         }
 945 }
 946
 947
 948 static void set_pps_cred_policy_update(struct hs20_osu_client *ctx, int id,
 949                                        xml_node_t *node)
 950 {
 951         wpa_printf(MSG_INFO, "- Policy/PolicyUpdate");
 952         /* Not used in wpa_supplicant */
 953 }
 954
 955
 956 static void set_pps_cred_policy_required_proto_port(struct hs20_osu_client *ctx,
 957                                                     int id, xml_node_t *tuple)
 958 {
 959         xml_node_t *node;
 960         char *proto, *port;
 961         char *buf;
 962         size_t buflen;
 963
 964         node = get_node(ctx->xml, tuple, "IPProtocol");
 965         if (node == NULL) {
 966                 wpa_printf(MSG_INFO, "Ignore RequiredProtoPortTuple without mandatory IPProtocol node");
 967                 return;
 968         }
 969
 970         proto = xml_node_get_text(ctx->xml, node);
 971         if (proto == NULL)
 972                 return;
 973
 974         wpa_printf(MSG_INFO, "- Policy/RequiredProtoPortTuple/<X+>/IPProtocol = %s",
 975                    proto);
 976
 977         node = get_node(ctx->xml, tuple, "PortNumber");
 978         port = node ? xml_node_get_text(ctx->xml, node) : NULL;
 979         if (port) {
 980                 wpa_printf(MSG_INFO, "- Policy/RequiredProtoPortTuple/<X+>/PortNumber = %s",
 981                            port);
 982                 buflen = os_strlen(proto) + os_strlen(port) + 10;
 983                 buf = os_malloc(buflen);
 984                 if (buf)
 985                         os_snprintf(buf, buflen, "%s:%s", proto, port);
 986                 xml_node_get_text_free(ctx->xml, port);
 987         } else {
 988                 buflen = os_strlen(proto) + 10;
 989                 buf = os_malloc(buflen);
 990                 if (buf)
 991                         os_snprintf(buf, buflen, "%s", proto);
 992         }
 993
 994         xml_node_get_text_free(ctx->xml, proto);
 995
 996         if (buf == NULL)
 997                 return;
 998
 999         if (set_cred(ctx->ifname, id, "req_conn_capab", buf) < 0)
1000                 wpa_printf(MSG_INFO, "Could not set req_conn_capab");
1001
1002         os_free(buf);
1003 }
1004
1005
1006 static void set_pps_cred_policy_required_proto_ports(struct hs20_osu_client *ctx,
1007                                                      int id, xml_node_t *node)
1008 {
1009         xml_node_t *child;
1010
1011         wpa_printf(MSG_INFO, "- Policy/RequiredProtoPortTuple");
1012
1013         xml_node_for_each_child(ctx->xml, child, node) {
1014                 xml_node_for_each_check(ctx->xml, child);
1015                 set_pps_cred_policy_required_proto_port(ctx, id, child);
1016         }
1017 }
1018
1019
1020 static void set_pps_cred_policy_max_bss_load(struct hs20_osu_client *ctx, int id,
1021                                              xml_node_t *node)
1022 {
1023         char *str = xml_node_get_text(ctx->xml, node);
1024         if (str == NULL)
1025                 return;
1026         wpa_printf(MSG_INFO, "- Policy/MaximumBSSLoadValue - %s", str);
1027         if (set_cred(ctx->ifname, id, "max_bss_load", str) < 0)
1028                 wpa_printf(MSG_INFO, "Failed to set cred max_bss_load limit");
1029         xml_node_get_text_free(ctx->xml, str);
1030 }
1031
1032
1033 static void set_pps_cred_policy(struct hs20_osu_client *ctx, int id,
1034                                 xml_node_t *node)
1035 {
1036         xml_node_t *child;
1037         const char *name;
1038
1039         wpa_printf(MSG_INFO, "- Policy");
1040
1041         xml_node_for_each_child(ctx->xml, child, node) {
1042                 xml_node_for_each_check(ctx->xml, child);
1043                 name = xml_node_get_localname(ctx->xml, child);
1044                 if (os_strcasecmp(name, "PreferredRoamingPartnerList") == 0)
1045                         set_pps_cred_policy_prpl(ctx, id, child);
1046                 else if (os_strcasecmp(name, "MinBackhaulThreshold") == 0)
1047                         set_pps_cred_policy_min_backhaul_list(ctx, id, child);
1048                 else if (os_strcasecmp(name, "PolicyUpdate") == 0)
1049                         set_pps_cred_policy_update(ctx, id, child);
1050                 else if (os_strcasecmp(name, "SPExclusionList") == 0)
1051                         set_pps_cred_policy_spel(ctx, id, child);
1052                 else if (os_strcasecmp(name, "RequiredProtoPortTuple") == 0)
1053                         set_pps_cred_policy_required_proto_ports(ctx, id, child);
1054                 else if (os_strcasecmp(name, "MaximumBSSLoadValue") == 0)
1055                         set_pps_cred_policy_max_bss_load(ctx, id, child);
1056                 else
1057                         wpa_printf(MSG_INFO, "Unknown Policy node '%s'", name);
1058         }
1059 }
1060
1061
1062 static void set_pps_cred_priority(struct hs20_osu_client *ctx, int id,
1063                                   xml_node_t *node)
1064 {
1065         char *str = xml_node_get_text(ctx->xml, node);
1066         if (str == NULL)
1067                 return;
1068         wpa_printf(MSG_INFO, "- CredentialPriority = %s", str);
1069         if (set_cred(ctx->ifname, id, "sp_priority", str) < 0)
1070                 wpa_printf(MSG_INFO, "Failed to set cred sp_priority");
1071         xml_node_get_text_free(ctx->xml, str);
1072 }
1073
1074
1075 static void set_pps_cred_aaa_server_trust_root(struct hs20_osu_client *ctx,
1076                                                int id, xml_node_t *node)
1077 {
1078         wpa_printf(MSG_INFO, "- AAAServerTrustRoot - TODO");
1079 }
1080
1081
1082 static void set_pps_cred_sub_update(struct hs20_osu_client *ctx, int id,
1083                                     xml_node_t *node)
1084 {
1085         wpa_printf(MSG_INFO, "- SubscriptionUpdate");
1086         /* not used within wpa_supplicant */
1087 }
1088
1089
1090 static void set_pps_cred_home_sp_network_id(struct hs20_osu_client *ctx,
1091                                             int id, xml_node_t *node)
1092 {
1093         xml_node_t *ssid_node, *hessid_node;
1094         char *ssid, *hessid;
1095
1096         ssid_node = get_node(ctx->xml, node, "SSID");
1097         if (ssid_node == NULL) {
1098                 wpa_printf(MSG_INFO, "Ignore HomeSP/NetworkID without mandatory SSID node");
1099                 return;
1100         }
1101
1102         hessid_node = get_node(ctx->xml, node, "HESSID");
1103
1104         ssid = xml_node_get_text(ctx->xml, ssid_node);
1105         if (ssid == NULL)
1106                 return;
1107         hessid = hessid_node ? xml_node_get_text(ctx->xml, hessid_node) : NULL;
1108
1109         wpa_printf(MSG_INFO, "- HomeSP/NetworkID/<X+>/SSID = %s", ssid);
1110         if (hessid)
1111                 wpa_printf(MSG_INFO, "- HomeSP/NetworkID/<X+>/HESSID = %s",
1112                            hessid);
1113
1114         /* TODO: Configure to wpa_supplicant */
1115
1116         xml_node_get_text_free(ctx->xml, ssid);
1117         xml_node_get_text_free(ctx->xml, hessid);
1118 }
1119
1120
1121 static void set_pps_cred_home_sp_network_ids(struct hs20_osu_client *ctx,
1122                                              int id, xml_node_t *node)
1123 {
1124         xml_node_t *child;
1125
1126         wpa_printf(MSG_INFO, "- HomeSP/NetworkID");
1127
1128         xml_node_for_each_child(ctx->xml, child, node) {
1129                 xml_node_for_each_check(ctx->xml, child);
1130                 set_pps_cred_home_sp_network_id(ctx, id, child);
1131         }
1132 }
1133
1134
1135 static void set_pps_cred_home_sp_friendly_name(struct hs20_osu_client *ctx,
1136                                                int id, xml_node_t *node)
1137 {
1138         char *str = xml_node_get_text(ctx->xml, node);
1139         if (str == NULL)
1140                 return;
1141         wpa_printf(MSG_INFO, "- HomeSP/FriendlyName = %s", str);
1142         /* not used within wpa_supplicant(?) */
1143         xml_node_get_text_free(ctx->xml, str);
1144 }
1145
1146
1147 static void set_pps_cred_home_sp_icon_url(struct hs20_osu_client *ctx,
1148                                           int id, xml_node_t *node)
1149 {
1150         char *str = xml_node_get_text(ctx->xml, node);
1151         if (str == NULL)
1152                 return;
1153         wpa_printf(MSG_INFO, "- HomeSP/IconURL = %s", str);
1154         /* not used within wpa_supplicant */
1155         xml_node_get_text_free(ctx->xml, str);
1156 }
1157
1158
1159 static void set_pps_cred_home_sp_fqdn(struct hs20_osu_client *ctx, int id,
1160                                       xml_node_t *node)
1161 {
1162         char *str = xml_node_get_text(ctx->xml, node);
1163         if (str == NULL)
1164                 return;
1165         wpa_printf(MSG_INFO, "- HomeSP/FQDN = %s", str);
1166         if (set_cred_quoted(ctx->ifname, id, "domain", str) < 0)
1167                 wpa_printf(MSG_INFO, "Failed to set cred domain");
1168         if (set_cred_quoted(ctx->ifname, id, "domain_suffix_match", str) < 0)
1169                 wpa_printf(MSG_INFO, "Failed to set cred domain_suffix_match");
1170         xml_node_get_text_free(ctx->xml, str);
1171 }
1172
1173
1174 static void set_pps_cred_home_sp_oi(struct hs20_osu_client *ctx, int id,
1175                                     xml_node_t *node)
1176 {
1177         xml_node_t *child;
1178         const char *name;
1179         char *homeoi = NULL;
1180         int required = 0;
1181         char *str;
1182
1183         xml_node_for_each_child(ctx->xml, child, node) {
1184                 xml_node_for_each_check(ctx->xml, child);
1185                 name = xml_node_get_localname(ctx->xml, child);
1186                 if (strcasecmp(name, "HomeOI") == 0 && !homeoi) {
1187                         homeoi = xml_node_get_text(ctx->xml, child);
1188                         wpa_printf(MSG_INFO, "- HomeSP/HomeOIList/<X+>/HomeOI = %s",
1189                                    homeoi);
1190                 } else if (strcasecmp(name, "HomeOIRequired") == 0) {
1191                         str = xml_node_get_text(ctx->xml, child);
1192                         wpa_printf(MSG_INFO, "- HomeSP/HomeOIList/<X+>/HomeOIRequired = '%s'",
1193                                    str);
1194                         if (str == NULL)
1195                                 continue;
1196                         required = strcasecmp(str, "true") == 0;
1197                         xml_node_get_text_free(ctx->xml, str);
1198                 } else
1199                         wpa_printf(MSG_INFO, "Unknown HomeOIList node '%s'",
1200                                    name);
1201         }
1202
1203         if (homeoi == NULL) {
1204                 wpa_printf(MSG_INFO, "- HomeSP/HomeOIList/<X+> without HomeOI ignored");
1205                 return;
1206         }
1207
1208         wpa_printf(MSG_INFO, "- HomeSP/HomeOIList/<X+> '%s' required=%d",
1209                    homeoi, required);
1210
1211         if (required) {
1212                 if (set_cred(ctx->ifname, id, "required_roaming_consortium",
1213                              homeoi) < 0)
1214                         wpa_printf(MSG_INFO, "Failed to set cred required_roaming_consortium");
1215         } else {
1216                 if (set_cred_quoted(ctx->ifname, id, "roaming_consortium",
1217                                     homeoi) < 0)
1218                         wpa_printf(MSG_INFO, "Failed to set cred roaming_consortium");
1219         }
1220
1221         xml_node_get_text_free(ctx->xml, homeoi);
1222 }
1223
1224
1225 static void set_pps_cred_home_sp_oi_list(struct hs20_osu_client *ctx, int id,
1226                                          xml_node_t *node)
1227 {
1228         xml_node_t *child;
1229
1230         wpa_printf(MSG_INFO, "- HomeSP/HomeOIList");
1231
1232         xml_node_for_each_child(ctx->xml, child, node) {
1233                 xml_node_for_each_check(ctx->xml, child);
1234                 set_pps_cred_home_sp_oi(ctx, id, child);
1235         }
1236 }
1237
1238
1239 static void set_pps_cred_home_sp_other_partner(struct hs20_osu_client *ctx,
1240                                                int id, xml_node_t *node)
1241 {
1242         xml_node_t *child;
1243         const char *name;
1244         char *fqdn = NULL;
1245
1246         xml_node_for_each_child(ctx->xml, child, node) {
1247                 xml_node_for_each_check(ctx->xml, child);
1248                 name = xml_node_get_localname(ctx->xml, child);
1249                 if (os_strcasecmp(name, "FQDN") == 0 && !fqdn) {
1250                         fqdn = xml_node_get_text(ctx->xml, child);
1251                         wpa_printf(MSG_INFO, "- HomeSP/OtherHomePartners/<X+>/FQDN = %s",
1252                                    fqdn);
1253                 } else
1254                         wpa_printf(MSG_INFO, "Unknown OtherHomePartners node '%s'",
1255                                    name);
1256         }
1257
1258         if (fqdn == NULL) {
1259                 wpa_printf(MSG_INFO, "- HomeSP/OtherHomePartners/<X+> without FQDN ignored");
1260                 return;
1261         }
1262
1263         if (set_cred_quoted(ctx->ifname, id, "domain", fqdn) < 0)
1264                 wpa_printf(MSG_INFO, "Failed to set cred domain for OtherHomePartners node");
1265
1266         xml_node_get_text_free(ctx->xml, fqdn);
1267 }
1268
1269
1270 static void set_pps_cred_home_sp_other_partners(struct hs20_osu_client *ctx,
1271                                                 int id,
1272                                                 xml_node_t *node)
1273 {
1274         xml_node_t *child;
1275
1276         wpa_printf(MSG_INFO, "- HomeSP/OtherHomePartners");
1277
1278         xml_node_for_each_child(ctx->xml, child, node) {
1279                 xml_node_for_each_check(ctx->xml, child);
1280                 set_pps_cred_home_sp_other_partner(ctx, id, child);
1281         }
1282 }
1283
1284
1285 static void set_pps_cred_home_sp_roaming_consortium_oi(
1286         struct hs20_osu_client *ctx, int id, xml_node_t *node)
1287 {
1288         char *str = xml_node_get_text(ctx->xml, node);
1289         if (str == NULL)
1290                 return;
1291         wpa_printf(MSG_INFO, "- HomeSP/RoamingConsortiumOI = %s", str);
1292         /* TODO: Set to wpa_supplicant */
1293         xml_node_get_text_free(ctx->xml, str);
1294 }
1295
1296
1297 static void set_pps_cred_home_sp(struct hs20_osu_client *ctx, int id,
1298                                  xml_node_t *node)
1299 {
1300         xml_node_t *child;
1301         const char *name;
1302
1303         wpa_printf(MSG_INFO, "- HomeSP");
1304
1305         xml_node_for_each_child(ctx->xml, child, node) {
1306                 xml_node_for_each_check(ctx->xml, child);
1307                 name = xml_node_get_localname(ctx->xml, child);
1308                 if (os_strcasecmp(name, "NetworkID") == 0)
1309                         set_pps_cred_home_sp_network_ids(ctx, id, child);
1310                 else if (os_strcasecmp(name, "FriendlyName") == 0)
1311                         set_pps_cred_home_sp_friendly_name(ctx, id, child);
1312                 else if (os_strcasecmp(name, "IconURL") == 0)
1313                         set_pps_cred_home_sp_icon_url(ctx, id, child);
1314                 else if (os_strcasecmp(name, "FQDN") == 0)
1315                         set_pps_cred_home_sp_fqdn(ctx, id, child);
1316                 else if (os_strcasecmp(name, "HomeOIList") == 0)
1317                         set_pps_cred_home_sp_oi_list(ctx, id, child);
1318                 else if (os_strcasecmp(name, "OtherHomePartners") == 0)
1319                         set_pps_cred_home_sp_other_partners(ctx, id, child);
1320                 else if (os_strcasecmp(name, "RoamingConsortiumOI") == 0)
1321                         set_pps_cred_home_sp_roaming_consortium_oi(ctx, id,
1322                                                                    child);
1323                 else
1324                         wpa_printf(MSG_INFO, "Unknown HomeSP node '%s'", name);
1325         }
1326 }
1327
1328
1329 static void set_pps_cred_sub_params(struct hs20_osu_client *ctx, int id,
1330                                     xml_node_t *node)
1331 {
1332         wpa_printf(MSG_INFO, "- SubscriptionParameters");
1333         /* not used within wpa_supplicant */
1334 }
1335
1336
1337 static void set_pps_cred_creation_date(struct hs20_osu_client *ctx, int id,
1338                                        xml_node_t *node)
1339 {
1340         char *str = xml_node_get_text(ctx->xml, node);
1341         if (str == NULL)
1342                 return;
1343         wpa_printf(MSG_INFO, "- Credential/CreationDate = %s", str);
1344         /* not used within wpa_supplicant */
1345         xml_node_get_text_free(ctx->xml, str);
1346 }
1347
1348
1349 static void set_pps_cred_expiration_date(struct hs20_osu_client *ctx, int id,
1350                                          xml_node_t *node)
1351 {
1352         char *str = xml_node_get_text(ctx->xml, node);
1353         if (str == NULL)
1354                 return;
1355         wpa_printf(MSG_INFO, "- Credential/ExpirationDate = %s", str);
1356         /* not used within wpa_supplicant */
1357         xml_node_get_text_free(ctx->xml, str);
1358 }
1359
1360
1361 static void set_pps_cred_username(struct hs20_osu_client *ctx, int id,
1362                                   xml_node_t *node)
1363 {
1364         char *str = xml_node_get_text(ctx->xml, node);
1365         if (str == NULL)
1366                 return;
1367         wpa_printf(MSG_INFO, "- Credential/UsernamePassword/Username = %s",
1368                    str);
1369         if (set_cred_quoted(ctx->ifname, id, "username", str) < 0)
1370                 wpa_printf(MSG_INFO, "Failed to set cred username");
1371         xml_node_get_text_free(ctx->xml, str);
1372 }
1373
1374
1375 static void set_pps_cred_password(struct hs20_osu_client *ctx, int id,
1376                                   xml_node_t *node)
1377 {
1378         int len, i;
1379         char *pw, *hex, *pos, *end;
1380
1381         pw = xml_node_get_base64_text(ctx->xml, node, &len);
1382         if (pw == NULL)
1383                 return;
1384
1385         wpa_printf(MSG_INFO, "- Credential/UsernamePassword/Password = %s", pw);
1386
1387         hex = malloc(len * 2 + 1);
1388         if (hex == NULL) {
1389                 free(pw);
1390                 return;
1391         }
1392         end = hex + len * 2 + 1;
1393         pos = hex;
1394         for (i = 0; i < len; i++) {
1395                 snprintf(pos, end - pos, "%02x", pw[i]);
1396                 pos += 2;
1397         }
1398         free(pw);
1399
1400         if (set_cred(ctx->ifname, id, "password", hex) < 0)
1401                 wpa_printf(MSG_INFO, "Failed to set cred password");
1402         free(hex);
1403 }
1404
1405
1406 static void set_pps_cred_machine_managed(struct hs20_osu_client *ctx, int id,
1407                                          xml_node_t *node)
1408 {
1409         char *str = xml_node_get_text(ctx->xml, node);
1410         if (str == NULL)
1411                 return;
1412         wpa_printf(MSG_INFO, "- Credential/UsernamePassword/MachineManaged = %s",
1413                    str);
1414         /* not used within wpa_supplicant */
1415         xml_node_get_text_free(ctx->xml, str);
1416 }
1417
1418
1419 static void set_pps_cred_soft_token_app(struct hs20_osu_client *ctx, int id,
1420                                         xml_node_t *node)
1421 {
1422         char *str = xml_node_get_text(ctx->xml, node);
1423         if (str == NULL)
1424                 return;
1425         wpa_printf(MSG_INFO, "- Credential/UsernamePassword/SoftTokenApp = %s",
1426                    str);
1427         /* not used within wpa_supplicant */
1428         xml_node_get_text_free(ctx->xml, str);
1429 }
1430
1431
1432 static void set_pps_cred_able_to_share(struct hs20_osu_client *ctx, int id,
1433                                        xml_node_t *node)
1434 {
1435         char *str = xml_node_get_text(ctx->xml, node);
1436         if (str == NULL)
1437                 return;
1438         wpa_printf(MSG_INFO, "- Credential/UsernamePassword/AbleToShare = %s",
1439                    str);
1440         /* not used within wpa_supplicant */
1441         xml_node_get_text_free(ctx->xml, str);
1442 }
1443
1444
1445 static void set_pps_cred_eap_method(struct hs20_osu_client *ctx, int id,
1446                                     xml_node_t *node)
1447 {
1448         wpa_printf(MSG_INFO, "- Credential/UsernamePassword/EAPMethod - TODO");
1449 }
1450
1451
1452 static void set_pps_cred_username_password(struct hs20_osu_client *ctx, int id,
1453                                            xml_node_t *node)
1454 {
1455         xml_node_t *child;
1456         const char *name;
1457
1458         wpa_printf(MSG_INFO, "- Credential/UsernamePassword");
1459
1460         xml_node_for_each_child(ctx->xml, child, node) {
1461                 xml_node_for_each_check(ctx->xml, child);
1462                 name = xml_node_get_localname(ctx->xml, child);
1463                 if (os_strcasecmp(name, "Username") == 0)
1464                         set_pps_cred_username(ctx, id, child);
1465                 else if (os_strcasecmp(name, "Password") == 0)
1466                         set_pps_cred_password(ctx, id, child);
1467                 else if (os_strcasecmp(name, "MachineManaged") == 0)
1468                         set_pps_cred_machine_managed(ctx, id, child);
1469                 else if (os_strcasecmp(name, "SoftTokenApp") == 0)
1470                         set_pps_cred_soft_token_app(ctx, id, child);
1471                 else if (os_strcasecmp(name, "AbleToShare") == 0)
1472                         set_pps_cred_able_to_share(ctx, id, child);
1473                 else if (os_strcasecmp(name, "EAPMethod") == 0)
1474                         set_pps_cred_eap_method(ctx, id, child);
1475                 else
1476                         wpa_printf(MSG_INFO, "Unknown Credential/UsernamePassword node '%s'",
1477                                    name);
1478         }
1479 }
1480
1481
1482 static void set_pps_cred_digital_cert(struct hs20_osu_client *ctx, int id,
1483                                       xml_node_t *node, const char *fqdn)
1484 {
1485         char buf[200], dir[200];
1486
1487         wpa_printf(MSG_INFO, "- Credential/DigitalCertificate");
1488
1489         if (getcwd(dir, sizeof(dir)) == NULL)
1490                 return;
1491
1492         /* TODO: could build username from Subject of Subject AltName */
1493         if (set_cred_quoted(ctx->ifname, id, "username", "cert") < 0) {
1494                 wpa_printf(MSG_INFO, "Failed to set username");
1495         }
1496
1497         snprintf(buf, sizeof(buf), "%s/SP/%s/client-cert.pem", dir, fqdn);
1498         if (os_file_exists(buf)) {
1499                 if (set_cred_quoted(ctx->ifname, id, "client_cert", buf) < 0) {
1500                         wpa_printf(MSG_INFO, "Failed to set client_cert");
1501                 }
1502         }
1503
1504         snprintf(buf, sizeof(buf), "%s/SP/%s/client-key.pem", dir, fqdn);
1505         if (os_file_exists(buf)) {
1506                 if (set_cred_quoted(ctx->ifname, id, "private_key", buf) < 0) {
1507                         wpa_printf(MSG_INFO, "Failed to set private_key");
1508                 }
1509         }
1510 }
1511
1512
1513 static void set_pps_cred_realm(struct hs20_osu_client *ctx, int id,
1514                                xml_node_t *node, const char *fqdn, int sim)
1515 {
1516         char *str = xml_node_get_text(ctx->xml, node);
1517         char buf[200], dir[200];
1518
1519         if (str == NULL)
1520                 return;
1521
1522         wpa_printf(MSG_INFO, "- Credential/Realm = %s", str);
1523         if (set_cred_quoted(ctx->ifname, id, "realm", str) < 0)
1524                 wpa_printf(MSG_INFO, "Failed to set cred realm");
1525         xml_node_get_text_free(ctx->xml, str);
1526
1527         if (sim)
1528                 return;
1529
1530         if (getcwd(dir, sizeof(dir)) == NULL)
1531                 return;
1532         snprintf(buf, sizeof(buf), "%s/SP/%s/aaa-ca.pem", dir, fqdn);
1533         if (os_file_exists(buf)) {
1534                 if (set_cred_quoted(ctx->ifname, id, "ca_cert", buf) < 0) {
1535                         wpa_printf(MSG_INFO, "Failed to set CA cert");
1536                 }
1537         }
1538 }
1539
1540
1541 static void set_pps_cred_check_aaa_cert_status(struct hs20_osu_client *ctx,
1542                                                int id, xml_node_t *node)
1543 {
1544         char *str = xml_node_get_text(ctx->xml, node);
1545
1546         if (str == NULL)
1547                 return;
1548
1549         wpa_printf(MSG_INFO, "- Credential/CheckAAAServerCertStatus = %s", str);
1550         if (os_strcasecmp(str, "true") == 0 &&
1551             set_cred(ctx->ifname, id, "ocsp", "2") < 0)
1552                 wpa_printf(MSG_INFO, "Failed to set cred ocsp");
1553         xml_node_get_text_free(ctx->xml, str);
1554 }
1555
1556
1557 static void set_pps_cred_sim(struct hs20_osu_client *ctx, int id,
1558                              xml_node_t *sim, xml_node_t *realm)
1559 {
1560         xml_node_t *node;
1561         char *imsi, *eaptype, *str, buf[20];
1562         int type;
1563         int mnc_len = 3;
1564         size_t imsi_len;
1565
1566         node = get_node(ctx->xml, sim, "EAPType");
1567         if (node == NULL) {
1568                 wpa_printf(MSG_INFO, "No SIM/EAPType node in credential");
1569                 return;
1570         }
1571         eaptype = xml_node_get_text(ctx->xml, node);
1572         if (eaptype == NULL) {
1573                 wpa_printf(MSG_INFO, "Could not extract SIM/EAPType");
1574                 return;
1575         }
1576         wpa_printf(MSG_INFO, " - Credential/SIM/EAPType = %s", eaptype);
1577         type = atoi(eaptype);
1578         xml_node_get_text_free(ctx->xml, eaptype);
1579
1580         switch (type) {
1581         case EAP_TYPE_SIM:
1582                 if (set_cred(ctx->ifname, id, "eap", "SIM") < 0)
1583                         wpa_printf(MSG_INFO, "Could not set eap=SIM");
1584                 break;
1585         case EAP_TYPE_AKA:
1586                 if (set_cred(ctx->ifname, id, "eap", "AKA") < 0)
1587                         wpa_printf(MSG_INFO, "Could not set eap=SIM");
1588                 break;
1589         case EAP_TYPE_AKA_PRIME:
1590                 if (set_cred(ctx->ifname, id, "eap", "AKA'") < 0)
1591                         wpa_printf(MSG_INFO, "Could not set eap=SIM");
1592                 break;
1593         default:
1594                 wpa_printf(MSG_INFO, "Unsupported SIM/EAPType %d", type);
1595                 return;
1596         }
1597
1598         node = get_node(ctx->xml, sim, "IMSI");
1599         if (node == NULL) {
1600                 wpa_printf(MSG_INFO, "No SIM/IMSI node in credential");
1601                 return;
1602         }
1603         imsi = xml_node_get_text(ctx->xml, node);
1604         if (imsi == NULL) {
1605                 wpa_printf(MSG_INFO, "Could not extract SIM/IMSI");
1606                 return;
1607         }
1608         wpa_printf(MSG_INFO, " - Credential/SIM/IMSI = %s", imsi);
1609         imsi_len = os_strlen(imsi);
1610         if (imsi_len < 7 || imsi_len + 2 > sizeof(buf)) {
1611                 wpa_printf(MSG_INFO, "Invalid IMSI length");
1612                 xml_node_get_text_free(ctx->xml, imsi);
1613                 return;
1614         }
1615
1616         str = xml_node_get_text(ctx->xml, node);
1617         if (str) {
1618                 char *pos;
1619                 pos = os_strstr(str, "mnc");
1620                 if (pos && os_strlen(pos) >= 6) {
1621                         if (os_strncmp(imsi + 3, pos + 3, 3) == 0)
1622                                 mnc_len = 3;
1623                         else if (os_strncmp(imsi + 3, pos + 4, 2) == 0)
1624                                 mnc_len = 2;
1625                 }
1626                 xml_node_get_text_free(ctx->xml, str);
1627         }
1628
1629         os_memcpy(buf, imsi, 3 + mnc_len);
1630         buf[3 + mnc_len] = '-';
1631         os_strlcpy(buf + 3 + mnc_len + 1, imsi + 3 + mnc_len,
1632                    sizeof(buf) - 3 - mnc_len - 1);
1633
1634         xml_node_get_text_free(ctx->xml, imsi);
1635
1636         if (set_cred_quoted(ctx->ifname, id, "imsi", buf) < 0)
1637                 wpa_printf(MSG_INFO, "Could not set IMSI");
1638
1639         if (set_cred_quoted(ctx->ifname, id, "milenage",
1640                             "90dca4eda45b53cf0f12d7c9c3bc6a89:"
1641                             "cb9cccc4b9258e6dca4760379fb82581:000000000123") <
1642             0)
1643                 wpa_printf(MSG_INFO, "Could not set Milenage parameters");
1644 }
1645
1646
1647 static void set_pps_cred_credential(struct hs20_osu_client *ctx, int id,
1648                                     xml_node_t *node, const char *fqdn)
1649 {
1650         xml_node_t *child, *sim, *realm;
1651         const char *name;
1652
1653         wpa_printf(MSG_INFO, "- Credential");
1654
1655         sim = get_node(ctx->xml, node, "SIM");
1656         realm = get_node(ctx->xml, node, "Realm");
1657
1658         xml_node_for_each_child(ctx->xml, child, node) {
1659                 xml_node_for_each_check(ctx->xml, child);
1660                 name = xml_node_get_localname(ctx->xml, child);
1661                 if (os_strcasecmp(name, "CreationDate") == 0)
1662                         set_pps_cred_creation_date(ctx, id, child);
1663                 else if (os_strcasecmp(name, "ExpirationDate") == 0)
1664                         set_pps_cred_expiration_date(ctx, id, child);
1665                 else if (os_strcasecmp(name, "UsernamePassword") == 0)
1666                         set_pps_cred_username_password(ctx, id, child);
1667                 else if (os_strcasecmp(name, "DigitalCertificate") == 0)
1668                         set_pps_cred_digital_cert(ctx, id, child, fqdn);
1669                 else if (os_strcasecmp(name, "Realm") == 0)
1670                         set_pps_cred_realm(ctx, id, child, fqdn, sim != NULL);
1671                 else if (os_strcasecmp(name, "CheckAAAServerCertStatus") == 0)
1672                         set_pps_cred_check_aaa_cert_status(ctx, id, child);
1673                 else if (os_strcasecmp(name, "SIM") == 0)
1674                         set_pps_cred_sim(ctx, id, child, realm);
1675                 else
1676                         wpa_printf(MSG_INFO, "Unknown Credential node '%s'",
1677                                    name);
1678         }
1679 }
1680
1681
1682 static void set_pps_credential(struct hs20_osu_client *ctx, int id,
1683                                xml_node_t *cred, const char *fqdn)
1684 {
1685         xml_node_t *child;
1686         const char *name;
1687
1688         xml_node_for_each_child(ctx->xml, child, cred) {
1689                 xml_node_for_each_check(ctx->xml, child);
1690                 name = xml_node_get_localname(ctx->xml, child);
1691                 if (os_strcasecmp(name, "Policy") == 0)
1692                         set_pps_cred_policy(ctx, id, child);
1693                 else if (os_strcasecmp(name, "CredentialPriority") == 0)
1694                         set_pps_cred_priority(ctx, id, child);
1695                 else if (os_strcasecmp(name, "AAAServerTrustRoot") == 0)
1696                         set_pps_cred_aaa_server_trust_root(ctx, id, child);
1697                 else if (os_strcasecmp(name, "SubscriptionUpdate") == 0)
1698                         set_pps_cred_sub_update(ctx, id, child);
1699                 else if (os_strcasecmp(name, "HomeSP") == 0)
1700                         set_pps_cred_home_sp(ctx, id, child);
1701                 else if (os_strcasecmp(name, "SubscriptionParameters") == 0)
1702                         set_pps_cred_sub_params(ctx, id, child);
1703                 else if (os_strcasecmp(name, "Credential") == 0)
1704                         set_pps_cred_credential(ctx, id, child, fqdn);
1705                 else
1706                         wpa_printf(MSG_INFO, "Unknown credential node '%s'",
1707                                    name);
1708         }
1709 }
1710
1711
1712 static void set_pps(struct hs20_osu_client *ctx, xml_node_t *pps,
1713                     const char *fqdn)
1714 {
1715         xml_node_t *child;
1716         const char *name;
1717         int id;
1718         char *update_identifier = NULL;
1719
1720         /*
1721          * TODO: Could consider more complex mechanism that would remove
1722          * credentials only if there are changes in the information sent to
1723          * wpa_supplicant.
1724          */
1725         remove_sp_creds(ctx, fqdn);
1726
1727         xml_node_for_each_child(ctx->xml, child, pps) {
1728                 xml_node_for_each_check(ctx->xml, child);
1729                 name = xml_node_get_localname(ctx->xml, child);
1730                 if (os_strcasecmp(name, "UpdateIdentifier") == 0) {
1731                         update_identifier = xml_node_get_text(ctx->xml, child);
1732                         if (update_identifier) {
1733                                 wpa_printf(MSG_INFO, "- UpdateIdentifier = %s",
1734                                            update_identifier);
1735                                 break;
1736                         }
1737                 }
1738         }
1739
1740         xml_node_for_each_child(ctx->xml, child, pps) {
1741                 xml_node_for_each_check(ctx->xml, child);
1742                 name = xml_node_get_localname(ctx->xml, child);
1743                 if (os_strcasecmp(name, "UpdateIdentifier") == 0)
1744                         continue;
1745                 id = add_cred(ctx->ifname);
1746                 if (id < 0) {
1747                         wpa_printf(MSG_INFO, "Failed to add credential to wpa_supplicant");
1748                         write_summary(ctx, "Failed to add credential to wpa_supplicant");
1749                         break;
1750                 }
1751                 write_summary(ctx, "Add a credential to wpa_supplicant");
1752                 if (update_identifier &&
1753                     set_cred(ctx->ifname, id, "update_identifier",
1754                              update_identifier) < 0)
1755                         wpa_printf(MSG_INFO, "Failed to set update_identifier");
1756                 if (set_cred_quoted(ctx->ifname, id, "provisioning_sp", fqdn) <
1757                     0)
1758                         wpa_printf(MSG_INFO, "Failed to set provisioning_sp");
1759                 wpa_printf(MSG_INFO, "credential localname: '%s'", name);
1760                 set_pps_credential(ctx, id, child, fqdn);
1761                 ctx->pps_cred_set = 1;
1762         }
1763
1764         xml_node_get_text_free(ctx->xml, update_identifier);
1765 }
1766
1767
1768 void cmd_set_pps(struct hs20_osu_client *ctx, const char *pps_fname)
1769 {
1770         xml_node_t *pps;
1771         const char *fqdn;
1772         char *fqdn_buf = NULL, *pos;
1773
1774         pps = node_from_file(ctx->xml, pps_fname);
1775         if (pps == NULL) {
1776                 wpa_printf(MSG_INFO, "Could not read or parse '%s'", pps_fname);
1777                 return;
1778         }
1779
1780         fqdn = os_strstr(pps_fname, "SP/");
1781         if (fqdn) {
1782                 fqdn_buf = os_strdup(fqdn + 3);
1783                 if (fqdn_buf == NULL)
1784                         return;
1785                 pos = os_strchr(fqdn_buf, '/');
1786                 if (pos)
1787                         *pos = '\0';
1788                 fqdn = fqdn_buf;
1789         } else
1790                 fqdn = "wi-fi.org";
1791
1792         wpa_printf(MSG_INFO, "Set PPS MO info to wpa_supplicant - SP FQDN %s",
1793                    fqdn);
1794         set_pps(ctx, pps, fqdn);
1795
1796         os_free(fqdn_buf);
1797         xml_node_free(ctx->xml, pps);
1798 }
1799
1800
1801 static int cmd_get_fqdn(struct hs20_osu_client *ctx, const char *pps_fname)
1802 {
1803         xml_node_t *pps, *node;
1804         char *fqdn = NULL;
1805
1806         pps = node_from_file(ctx->xml, pps_fname);
1807         if (pps == NULL) {
1808                 wpa_printf(MSG_INFO, "Could not read or parse '%s'", pps_fname);
1809                 return -1;
1810         }
1811
1812         node = get_child_node(ctx->xml, pps, "HomeSP/FQDN");
1813         if (node)
1814                 fqdn = xml_node_get_text(ctx->xml, node);
1815
1816         xml_node_free(ctx->xml, pps);
1817
1818         if (fqdn) {
1819                 FILE *f = fopen("pps-fqdn", "w");
1820                 if (f) {
1821                         fprintf(f, "%s", fqdn);
1822                         fclose(f);
1823                 }
1824                 xml_node_get_text_free(ctx->xml, fqdn);
1825                 return 0;
1826         }
1827
1828         xml_node_get_text_free(ctx->xml, fqdn);
1829         return -1;
1830 }
1831
1832
1833 static void cmd_to_tnds(struct hs20_osu_client *ctx, const char *in_fname,
1834                         const char *out_fname, const char *urn, int use_path)
1835 {
1836         xml_node_t *mo, *node;
1837
1838         mo = node_from_file(ctx->xml, in_fname);
1839         if (mo == NULL) {
1840                 wpa_printf(MSG_INFO, "Could not read or parse '%s'", in_fname);
1841                 return;
1842         }
1843
1844         node = mo_to_tnds(ctx->xml, mo, use_path, urn, NULL);
1845         if (node) {
1846                 node_to_file(ctx->xml, out_fname, node);
1847                 xml_node_free(ctx->xml, node);
1848         }
1849
1850         xml_node_free(ctx->xml, mo);
1851 }
1852
1853
1854 static void cmd_from_tnds(struct hs20_osu_client *ctx, const char *in_fname,
1855                           const char *out_fname)
1856 {
1857         xml_node_t *tnds, *mo;
1858
1859         tnds = node_from_file(ctx->xml, in_fname);
1860         if (tnds == NULL) {
1861                 wpa_printf(MSG_INFO, "Could not read or parse '%s'", in_fname);
1862                 return;
1863         }
1864
1865         mo = tnds_to_mo(ctx->xml, tnds);
1866         if (mo) {
1867                 node_to_file(ctx->xml, out_fname, mo);
1868                 xml_node_free(ctx->xml, mo);
1869         }
1870
1871         xml_node_free(ctx->xml, tnds);
1872 }
1873
1874
1875 struct osu_icon {
1876         int id;
1877         char lang[4];
1878         char mime_type[256];
1879         char filename[256];
1880 };
1881
1882 struct osu_data {
1883         char bssid[20];
1884         char url[256];
1885         unsigned int methods;
1886         char osu_ssid[33];
1887         char osu_nai[256];
1888         struct osu_lang_text friendly_name[MAX_OSU_VALS];
1889         size_t friendly_name_count;
1890         struct osu_lang_text serv_desc[MAX_OSU_VALS];
1891         size_t serv_desc_count;
1892         struct osu_icon icon[MAX_OSU_VALS];
1893         size_t icon_count;
1894 };
1895
1896
1897 static struct osu_data * parse_osu_providers(const char *fname, size_t *count)
1898 {
1899         FILE *f;
1900         char buf[1000];
1901         struct osu_data *osu = NULL, *last = NULL;
1902         size_t osu_count = 0;
1903         char *pos, *end;
1904
1905         f = fopen(fname, "r");
1906         if (f == NULL) {
1907                 wpa_printf(MSG_ERROR, "Could not open %s", fname);
1908                 return NULL;
1909         }
1910
1911         while (fgets(buf, sizeof(buf), f)) {
1912                 pos = strchr(buf, '\n');
1913                 if (pos)
1914                         *pos = '\0';
1915
1916                 if (strncmp(buf, "OSU-PROVIDER ", 13) == 0) {
1917                         last = realloc(osu, (osu_count + 1) * sizeof(*osu));
1918                         if (last == NULL)
1919                                 break;
1920                         osu = last;
1921                         last = &osu[osu_count++];
1922                         memset(last, 0, sizeof(*last));
1923                         snprintf(last->bssid, sizeof(last->bssid), "%s",
1924                                  buf + 13);
1925                         continue;
1926                 }
1927                 if (!last)
1928                         continue;
1929
1930                 if (strncmp(buf, "uri=", 4) == 0) {
1931                         snprintf(last->url, sizeof(last->url), "%s", buf + 4);
1932                         continue;
1933                 }
1934
1935                 if (strncmp(buf, "methods=", 8) == 0) {
1936                         last->methods = strtol(buf + 8, NULL, 16);
1937                         continue;
1938                 }
1939
1940                 if (strncmp(buf, "osu_ssid=", 9) == 0) {
1941                         snprintf(last->osu_ssid, sizeof(last->osu_ssid),
1942                                  "%s", buf + 9);
1943                         continue;
1944                 }
1945
1946                 if (os_strncmp(buf, "osu_nai=", 8) == 0) {
1947                         os_snprintf(last->osu_nai, sizeof(last->osu_nai),
1948                                     "%s", buf + 8);
1949                         continue;
1950                 }
1951
1952                 if (strncmp(buf, "friendly_name=", 14) == 0) {
1953                         struct osu_lang_text *txt;
1954                         if (last->friendly_name_count == MAX_OSU_VALS)
1955                                 continue;
1956                         pos = strchr(buf + 14, ':');
1957                         if (pos == NULL)
1958                                 continue;
1959                         *pos++ = '\0';
1960                         txt = &last->friendly_name[last->friendly_name_count++];
1961                         snprintf(txt->lang, sizeof(txt->lang), "%s", buf + 14);
1962                         snprintf(txt->text, sizeof(txt->text), "%s", pos);
1963                 }
1964
1965                 if (strncmp(buf, "desc=", 5) == 0) {
1966                         struct osu_lang_text *txt;
1967                         if (last->serv_desc_count == MAX_OSU_VALS)
1968                                 continue;
1969                         pos = strchr(buf + 5, ':');
1970                         if (pos == NULL)
1971                                 continue;
1972                         *pos++ = '\0';
1973                         txt = &last->serv_desc[last->serv_desc_count++];
1974                         snprintf(txt->lang, sizeof(txt->lang), "%s", buf + 5);
1975                         snprintf(txt->text, sizeof(txt->text), "%s", pos);
1976                 }
1977
1978                 if (strncmp(buf, "icon=", 5) == 0) {
1979                         struct osu_icon *icon;
1980                         if (last->icon_count == MAX_OSU_VALS)
1981                                 continue;
1982                         icon = &last->icon[last->icon_count++];
1983                         icon->id = atoi(buf + 5);
1984                         pos = strchr(buf, ':');
1985                         if (pos == NULL)
1986                                 continue;
1987                         pos = strchr(pos + 1, ':');
1988                         if (pos == NULL)
1989                                 continue;
1990                         pos = strchr(pos + 1, ':');
1991                         if (pos == NULL)
1992                                 continue;
1993                         pos++;
1994                         end = strchr(pos, ':');
1995                         if (!end)
1996                                 continue;
1997                         *end = '\0';
1998                         snprintf(icon->lang, sizeof(icon->lang), "%s", pos);
1999                         pos = end + 1;
2000
2001                         end = strchr(pos, ':');
2002                         if (end)
2003                                 *end = '\0';
2004                         snprintf(icon->mime_type, sizeof(icon->mime_type),
2005                                  "%s", pos);
2006                         if (!pos)
2007                                 continue;
2008                         pos = end + 1;
2009
2010                         end = strchr(pos, ':');
2011                         if (end)
2012                                 *end = '\0';
2013                         snprintf(icon->filename, sizeof(icon->filename),
2014                                  "%s", pos);
2015                         continue;
2016                 }
2017         }
2018
2019         fclose(f);
2020
2021         *count = osu_count;
2022         return osu;
2023 }
2024
2025
2026 static int osu_connect(struct hs20_osu_client *ctx, const char *bssid,
2027                        const char *ssid, const char *url,
2028                        unsigned int methods, int no_prod_assoc,
2029                        const char *osu_nai)
2030 {
2031         int id;
2032         const char *ifname = ctx->ifname;
2033         char buf[200];
2034         struct wpa_ctrl *mon;
2035         int res;
2036
2037         id = add_network(ifname);
2038         if (id < 0)
2039                 return -1;
2040         if (set_network_quoted(ifname, id, "ssid", ssid) < 0)
2041                 return -1;
2042         if (osu_nai && os_strlen(osu_nai) > 0) {
2043                 char dir[255], fname[300];
2044                 if (getcwd(dir, sizeof(dir)) == NULL)
2045                         return -1;
2046                 os_snprintf(fname, sizeof(fname), "%s/osu-ca.pem", dir);
2047
2048                 if (set_network(ifname, id, "proto", "OSEN") < 0 ||
2049                     set_network(ifname, id, "key_mgmt", "OSEN") < 0 ||
2050                     set_network(ifname, id, "pairwise", "CCMP") < 0 ||
2051                     set_network(ifname, id, "group", "GTK_NOT_USED") < 0 ||
2052                     set_network(ifname, id, "eap", "WFA-UNAUTH-TLS") < 0 ||
2053                     set_network(ifname, id, "ocsp", "2") < 0 ||
2054                     set_network_quoted(ifname, id, "identity", osu_nai) < 0 ||
2055                     set_network_quoted(ifname, id, "ca_cert", fname) < 0)
2056                         return -1;
2057         } else {
2058                 if (set_network(ifname, id, "key_mgmt", "NONE") < 0)
2059                         return -1;
2060         }
2061
2062         mon = open_wpa_mon(ifname);
2063         if (mon == NULL)
2064                 return -1;
2065
2066         wpa_printf(MSG_INFO, "Associate with OSU SSID");
2067         write_summary(ctx, "Associate with OSU SSID");
2068         snprintf(buf, sizeof(buf), "SELECT_NETWORK %d", id);
2069         if (wpa_command(ifname, buf) < 0)
2070                 return -1;
2071
2072         res = get_wpa_cli_event(mon, "CTRL-EVENT-CONNECTED",
2073                                 buf, sizeof(buf));
2074
2075         wpa_ctrl_detach(mon);
2076         wpa_ctrl_close(mon);
2077
2078         if (res < 0) {
2079                 wpa_printf(MSG_INFO, "Could not connect");
2080                 write_summary(ctx, "Could not connect to OSU network");
2081                 wpa_printf(MSG_INFO, "Remove OSU network connection");
2082                 snprintf(buf, sizeof(buf), "REMOVE_NETWORK %d", id);
2083                 wpa_command(ifname, buf);
2084                 return -1;
2085         }
2086
2087         write_summary(ctx, "Waiting for IP address for subscription registration");
2088         if (wait_ip_addr(ifname, 15) < 0) {
2089                 wpa_printf(MSG_INFO, "Could not get IP address for WLAN - try connection anyway");
2090         }
2091
2092         if (no_prod_assoc) {
2093                 if (res < 0)
2094                         return -1;
2095                 wpa_printf(MSG_INFO, "No production connection used for testing purposes");
2096                 write_summary(ctx, "No production connection used for testing purposes");
2097                 return 0;
2098         }
2099
2100         ctx->no_reconnect = 1;
2101         if (methods & 0x02) {
2102                 wpa_printf(MSG_DEBUG, "Calling cmd_prov from osu_connect");
2103                 res = cmd_prov(ctx, url);
2104         } else if (methods & 0x01) {
2105                 wpa_printf(MSG_DEBUG,
2106                            "Calling cmd_oma_dm_prov from osu_connect");
2107                 res = cmd_oma_dm_prov(ctx, url);
2108         }
2109
2110         wpa_printf(MSG_INFO, "Remove OSU network connection");
2111         write_summary(ctx, "Remove OSU network connection");
2112         snprintf(buf, sizeof(buf), "REMOVE_NETWORK %d", id);
2113         wpa_command(ifname, buf);
2114
2115         if (res < 0)
2116                 return -1;
2117
2118         wpa_printf(MSG_INFO, "Requesting reconnection with updated configuration");
2119         write_summary(ctx, "Requesting reconnection with updated configuration");
2120         if (wpa_command(ctx->ifname, "INTERWORKING_SELECT auto") < 0) {
2121                 wpa_printf(MSG_INFO, "Failed to request wpa_supplicant to reconnect");
2122                 write_summary(ctx, "Failed to request wpa_supplicant to reconnect");
2123                 return -1;
2124         }
2125
2126         return 0;
2127 }
2128
2129
2130 static int cmd_osu_select(struct hs20_osu_client *ctx, const char *dir,
2131                           int connect, int no_prod_assoc,
2132                           const char *friendly_name)
2133 {
2134         char fname[255];
2135         FILE *f;
2136         struct osu_data *osu = NULL, *last = NULL;
2137         size_t osu_count, i, j;
2138         int ret;
2139
2140         write_summary(ctx, "OSU provider selection");
2141
2142         if (dir == NULL) {
2143                 wpa_printf(MSG_INFO, "Missing dir parameter to osu_select");
2144                 return -1;
2145         }
2146
2147         snprintf(fname, sizeof(fname), "%s/osu-providers.txt", dir);
2148         osu = parse_osu_providers(fname, &osu_count);
2149         if (osu == NULL) {
2150                 wpa_printf(MSG_INFO, "Could not find any OSU providers from %s",
2151                            fname);
2152                 write_result(ctx, "No OSU providers available");
2153                 return -1;
2154         }
2155
2156         if (friendly_name) {
2157                 for (i = 0; i < osu_count; i++) {
2158                         last = &osu[i];
2159                         for (j = 0; j < last->friendly_name_count; j++) {
2160                                 if (os_strcmp(last->friendly_name[j].text,
2161                                               friendly_name) == 0)
2162                                         break;
2163                         }
2164                         if (j < last->friendly_name_count)
2165                                 break;
2166                 }
2167                 if (i == osu_count) {
2168                         wpa_printf(MSG_INFO, "Requested operator friendly name '%s' not found in the list of available providers",
2169                                    friendly_name);
2170                         write_summary(ctx, "Requested operator friendly name '%s' not found in the list of available providers",
2171                                       friendly_name);
2172                         free(osu);
2173                         return -1;
2174                 }
2175
2176                 wpa_printf(MSG_INFO, "OSU Provider selected based on requested operator friendly name '%s'",
2177                            friendly_name);
2178                 write_summary(ctx, "OSU Provider selected based on requested operator friendly name '%s'",
2179                               friendly_name);
2180                 ret = i + 1;
2181                 goto selected;
2182         }
2183
2184         snprintf(fname, sizeof(fname), "%s/osu-providers.html", dir);
2185         f = fopen(fname, "w");
2186         if (f == NULL) {
2187                 wpa_printf(MSG_INFO, "Could not open %s", fname);
2188                 free(osu);
2189                 return -1;
2190         }
2191
2192         fprintf(f, "<html><head>"
2193                 "<meta http-equiv=\"Content-type\" content=\"text/html; "
2194                 "charset=utf-8\"<title>Select service operator</title>"
2195                 "</head><body><h1>Select service operator</h1>\n");
2196
2197         if (osu_count == 0)
2198                 fprintf(f, "No online signup available\n");
2199
2200         for (i = 0; i < osu_count; i++) {
2201                 last = &osu[i];
2202 #ifdef ANDROID
2203                 fprintf(f, "<p>\n"
2204                         "<a href=\"http://localhost:12345/osu/%d\">"
2205                         "<table><tr><td>", (int) i + 1);
2206 #else /* ANDROID */
2207                 fprintf(f, "<p>\n"
2208                         "<a href=\"osu://%d\">"
2209                         "<table><tr><td>", (int) i + 1);
2210 #endif /* ANDROID */
2211                 for (j = 0; j < last->icon_count; j++) {
2212                         fprintf(f, "<img src=\"osu-icon-%d.%s\">\n",
2213                                 last->icon[j].id,
2214                                 strcasecmp(last->icon[j].mime_type,
2215                                            "image/png") == 0 ? "png" : "icon");
2216                 }
2217                 fprintf(f, "<td>");
2218                 for (j = 0; j < last->friendly_name_count; j++) {
2219                         fprintf(f, "<small>[%s]</small> %s<br>\n",
2220                                 last->friendly_name[j].lang,
2221                                 last->friendly_name[j].text);
2222                 }
2223                 fprintf(f, "<tr><td colspan=2>");
2224                 for (j = 0; j < last->serv_desc_count; j++) {
2225                         fprintf(f, "<small>[%s]</small> %s<br>\n",
2226                                 last->serv_desc[j].lang,
2227                                 last->serv_desc[j].text);
2228                 }
2229                 fprintf(f, "</table></a><br><small>BSSID: %s<br>\n"
2230                         "SSID: %s<br>\n",
2231                         last->bssid, last->osu_ssid);
2232                 if (last->osu_nai)
2233                         fprintf(f, "NAI: %s<br>\n", last->osu_nai);
2234                 fprintf(f, "URL: %s<br>\n"
2235                         "methods:%s%s<br>\n"
2236                         "</small></p>\n",
2237                         last->url,
2238                         last->methods & 0x01 ? " OMA-DM" : "",
2239                         last->methods & 0x02 ? " SOAP-XML-SPP" : "");
2240         }
2241
2242         fprintf(f, "</body></html>\n");
2243
2244         fclose(f);
2245
2246         snprintf(fname, sizeof(fname), "file://%s/osu-providers.html", dir);
2247         write_summary(ctx, "Start web browser with OSU provider selection page");
2248         ret = hs20_web_browser(fname);
2249
2250 selected:
2251         if (ret > 0 && (size_t) ret <= osu_count) {
2252                 char *data;
2253                 size_t data_len;
2254
2255                 wpa_printf(MSG_INFO, "Selected OSU id=%d", ret);
2256                 last = &osu[ret - 1];
2257                 ret = 0;
2258                 wpa_printf(MSG_INFO, "BSSID: %s", last->bssid);
2259                 wpa_printf(MSG_INFO, "SSID: %s", last->osu_ssid);
2260                 wpa_printf(MSG_INFO, "URL: %s", last->url);
2261                 write_summary(ctx, "Selected OSU provider id=%d BSSID=%s SSID=%s URL=%s",
2262                               ret, last->bssid, last->osu_ssid, last->url);
2263
2264                 ctx->friendly_name_count = last->friendly_name_count;
2265                 for (j = 0; j < last->friendly_name_count; j++) {
2266                         wpa_printf(MSG_INFO, "FRIENDLY_NAME: [%s]%s",
2267                                    last->friendly_name[j].lang,
2268                                    last->friendly_name[j].text);
2269                         os_strlcpy(ctx->friendly_name[j].lang,
2270                                    last->friendly_name[j].lang,
2271                                    sizeof(ctx->friendly_name[j].lang));
2272                         os_strlcpy(ctx->friendly_name[j].text,
2273                                    last->friendly_name[j].text,
2274                                    sizeof(ctx->friendly_name[j].text));
2275                 }
2276
2277                 ctx->icon_count = last->icon_count;
2278                 for (j = 0; j < last->icon_count; j++) {
2279                         char fname[256];
2280
2281                         os_snprintf(fname, sizeof(fname), "%s/osu-icon-%d.%s",
2282                                     dir, last->icon[j].id,
2283                                     strcasecmp(last->icon[j].mime_type,
2284                                                "image/png") == 0 ?
2285                                     "png" : "icon");
2286                         wpa_printf(MSG_INFO, "ICON: %s (%s)",
2287                                    fname, last->icon[j].filename);
2288                         os_strlcpy(ctx->icon_filename[j],
2289                                    last->icon[j].filename,
2290                                    sizeof(ctx->icon_filename[j]));
2291
2292                         data = os_readfile(fname, &data_len);
2293                         if (data) {
2294                                 sha256_vector(1, (const u8 **) &data, &data_len,
2295                                               ctx->icon_hash[j]);
2296                                 os_free(data);
2297                         }
2298                 }
2299
2300                 if (connect == 2) {
2301                         if (last->methods & 0x02) {
2302                                 wpa_printf(MSG_DEBUG,
2303                                            "Calling cmd_prov from cmd_osu_select");
2304                                 ret = cmd_prov(ctx, last->url);
2305                         } else if (last->methods & 0x01) {
2306                                 wpa_printf(MSG_DEBUG,
2307                                            "Calling cmd_oma_dm_prov from cmd_osu_select");
2308                                 ret = cmd_oma_dm_prov(ctx, last->url);
2309                         } else {
2310                                 wpa_printf(MSG_DEBUG,
2311                                            "No supported OSU provisioning method");
2312                                 ret = -1;
2313                         }
2314                 } else if (connect)
2315                         ret = osu_connect(ctx, last->bssid, last->osu_ssid,
2316                                           last->url, last->methods,
2317                                           no_prod_assoc, last->osu_nai);
2318         } else
2319                 ret = -1;
2320
2321         free(osu);
2322
2323         return ret;
2324 }
2325
2326
2327 static int cmd_signup(struct hs20_osu_client *ctx, int no_prod_assoc,
2328                       const char *friendly_name)
2329 {
2330         char dir[255];
2331         char fname[300], buf[400];
2332         struct wpa_ctrl *mon;
2333         const char *ifname;
2334         int res;
2335
2336         ifname = ctx->ifname;
2337
2338         if (getcwd(dir, sizeof(dir)) == NULL)
2339                 return -1;
2340
2341         snprintf(fname, sizeof(fname), "%s/osu-info", dir);
2342         if (mkdir(fname, S_IRWXU | S_IRWXG) < 0 && errno != EEXIST) {
2343                 wpa_printf(MSG_INFO, "mkdir(%s) failed: %s",
2344                            fname, strerror(errno));
2345                 return -1;
2346         }
2347
2348         snprintf(buf, sizeof(buf), "SET osu_dir %s", fname);
2349         if (wpa_command(ifname, buf) < 0) {
2350                 wpa_printf(MSG_INFO, "Failed to configure osu_dir to wpa_supplicant");
2351                 return -1;
2352         }
2353
2354         mon = open_wpa_mon(ifname);
2355         if (mon == NULL)
2356                 return -1;
2357
2358         wpa_printf(MSG_INFO, "Starting OSU fetch");
2359         write_summary(ctx, "Starting OSU provider information fetch");
2360         if (wpa_command(ifname, "FETCH_OSU") < 0) {
2361                 wpa_printf(MSG_INFO, "Could not start OSU fetch");
2362                 wpa_ctrl_detach(mon);
2363                 wpa_ctrl_close(mon);
2364                 return -1;
2365         }
2366         res = get_wpa_cli_event(mon, "OSU provider fetch completed",
2367                                 buf, sizeof(buf));
2368
2369         wpa_ctrl_detach(mon);
2370         wpa_ctrl_close(mon);
2371
2372         if (res < 0) {
2373                 wpa_printf(MSG_INFO, "OSU fetch did not complete");
2374                 write_summary(ctx, "OSU fetch did not complete");
2375                 return -1;
2376         }
2377         wpa_printf(MSG_INFO, "OSU provider fetch completed");
2378
2379         return cmd_osu_select(ctx, fname, 1, no_prod_assoc, friendly_name);
2380 }
2381
2382
2383 static int cmd_sub_rem(struct hs20_osu_client *ctx, const char *address,
2384                        const char *pps_fname, const char *ca_fname)
2385 {
2386         xml_node_t *pps, *node;
2387         char pps_fname_buf[300];
2388         char ca_fname_buf[200];
2389         char *cred_username = NULL;
2390         char *cred_password = NULL;
2391         char *sub_rem_uri = NULL;
2392         char client_cert_buf[200];
2393         char *client_cert = NULL;
2394         char client_key_buf[200];
2395         char *client_key = NULL;
2396         int spp;
2397
2398         wpa_printf(MSG_INFO, "Subscription remediation requested with Server URL: %s",
2399                    address);
2400
2401         if (!pps_fname) {
2402                 char buf[256];
2403                 wpa_printf(MSG_INFO, "Determining PPS file based on Home SP information");
2404                 if (os_strncmp(address, "fqdn=", 5) == 0) {
2405                         wpa_printf(MSG_INFO, "Use requested FQDN from command line");
2406                         os_snprintf(buf, sizeof(buf), "%s", address + 5);
2407                         address = NULL;
2408                 } else if (get_wpa_status(ctx->ifname, "provisioning_sp", buf,
2409                                           sizeof(buf)) < 0) {
2410                         wpa_printf(MSG_INFO, "Could not get provisioning Home SP FQDN from wpa_supplicant");
2411                         return -1;
2412                 }
2413                 os_free(ctx->fqdn);
2414                 ctx->fqdn = os_strdup(buf);
2415                 if (ctx->fqdn == NULL)
2416                         return -1;
2417                 wpa_printf(MSG_INFO, "Home SP FQDN for current credential: %s",
2418                            buf);
2419                 os_snprintf(pps_fname_buf, sizeof(pps_fname_buf),
2420                             "SP/%s/pps.xml", ctx->fqdn);
2421                 pps_fname = pps_fname_buf;
2422
2423                 os_snprintf(ca_fname_buf, sizeof(ca_fname_buf), "SP/%s/ca.pem",
2424                             ctx->fqdn);
2425                 ca_fname = ca_fname_buf;
2426         }
2427
2428         if (!os_file_exists(pps_fname)) {
2429                 wpa_printf(MSG_INFO, "PPS file '%s' does not exist or is not accessible",
2430                            pps_fname);
2431                 return -1;
2432         }
2433         wpa_printf(MSG_INFO, "Using PPS file: %s", pps_fname);
2434
2435         if (ca_fname && !os_file_exists(ca_fname)) {
2436                 wpa_printf(MSG_INFO, "CA file '%s' does not exist or is not accessible",
2437                            ca_fname);
2438                 return -1;
2439         }
2440         wpa_printf(MSG_INFO, "Using server trust root: %s", ca_fname);
2441         ctx->ca_fname = ca_fname;
2442
2443         pps = node_from_file(ctx->xml, pps_fname);
2444         if (pps == NULL) {
2445                 wpa_printf(MSG_INFO, "Could not read PPS MO");
2446                 return -1;
2447         }
2448
2449         if (!ctx->fqdn) {
2450                 char *tmp;
2451                 node = get_child_node(ctx->xml, pps, "HomeSP/FQDN");
2452                 if (node == NULL) {
2453                         wpa_printf(MSG_INFO, "No HomeSP/FQDN found from PPS");
2454                         return -1;
2455                 }
2456                 tmp = xml_node_get_text(ctx->xml, node);
2457                 if (tmp == NULL) {
2458                         wpa_printf(MSG_INFO, "No HomeSP/FQDN text found from PPS");
2459                         return -1;
2460                 }
2461                 ctx->fqdn = os_strdup(tmp);
2462                 xml_node_get_text_free(ctx->xml, tmp);
2463                 if (!ctx->fqdn) {
2464                         wpa_printf(MSG_INFO, "No FQDN known");
2465                         return -1;
2466                 }
2467         }
2468
2469         node = get_child_node(ctx->xml, pps,
2470                               "SubscriptionUpdate/UpdateMethod");
2471         if (node) {
2472                 char *tmp;
2473                 tmp = xml_node_get_text(ctx->xml, node);
2474                 if (tmp && os_strcasecmp(tmp, "OMA-DM-ClientInitiated") == 0)
2475                         spp = 0;
2476                 else
2477                         spp = 1;
2478         } else {
2479                 wpa_printf(MSG_INFO, "No UpdateMethod specified - assume SPP");
2480                 spp = 1;
2481         }
2482
2483         get_user_pw(ctx, pps, "SubscriptionUpdate/UsernamePassword",
2484                     &cred_username, &cred_password);
2485         if (cred_username)
2486                 wpa_printf(MSG_INFO, "Using username: %s", cred_username);
2487         if (cred_password)
2488                 wpa_printf(MSG_DEBUG, "Using password: %s", cred_password);
2489
2490         if (cred_username == NULL && cred_password == NULL &&
2491             get_child_node(ctx->xml, pps, "Credential/DigitalCertificate")) {
2492                 wpa_printf(MSG_INFO, "Using client certificate");
2493                 os_snprintf(client_cert_buf, sizeof(client_cert_buf),
2494                             "SP/%s/client-cert.pem", ctx->fqdn);
2495                 client_cert = client_cert_buf;
2496                 os_snprintf(client_key_buf, sizeof(client_key_buf),
2497                             "SP/%s/client-key.pem", ctx->fqdn);
2498                 client_key = client_key_buf;
2499                 ctx->client_cert_present = 1;
2500         }
2501
2502         node = get_child_node(ctx->xml, pps, "SubscriptionUpdate/URI");
2503         if (node) {
2504                 sub_rem_uri = xml_node_get_text(ctx->xml, node);
2505                 if (sub_rem_uri &&
2506                     (!address || os_strcmp(address, sub_rem_uri) != 0)) {
2507                         wpa_printf(MSG_INFO, "Override sub rem URI based on PPS: %s",
2508                                    sub_rem_uri);
2509                         address = sub_rem_uri;
2510                 }
2511         }
2512         if (!address) {
2513                 wpa_printf(MSG_INFO, "Server URL not known");
2514                 return -1;
2515         }
2516
2517         write_summary(ctx, "Wait for IP address for subscriptiom remediation");
2518         wpa_printf(MSG_INFO, "Wait for IP address before starting subscription remediation");
2519
2520         if (wait_ip_addr(ctx->ifname, 15) < 0) {
2521                 wpa_printf(MSG_INFO, "Could not get IP address for WLAN - try connection anyway");
2522         }
2523
2524         if (spp)
2525                 spp_sub_rem(ctx, address, pps_fname,
2526                             client_cert, client_key,
2527                             cred_username, cred_password, pps);
2528         else
2529                 oma_dm_sub_rem(ctx, address, pps_fname,
2530                                client_cert, client_key,
2531                                cred_username, cred_password, pps);
2532
2533         xml_node_get_text_free(ctx->xml, sub_rem_uri);
2534         xml_node_get_text_free(ctx->xml, cred_username);
2535         str_clear_free(cred_password);
2536         xml_node_free(ctx->xml, pps);
2537         return 0;
2538 }
2539
2540
2541 static int cmd_pol_upd(struct hs20_osu_client *ctx, const char *address,
2542                        const char *pps_fname, const char *ca_fname)
2543 {
2544         xml_node_t *pps;
2545         xml_node_t *node;
2546         char pps_fname_buf[300];
2547         char ca_fname_buf[200];
2548         char *uri = NULL;
2549         char *cred_username = NULL;
2550         char *cred_password = NULL;
2551         char client_cert_buf[200];
2552         char *client_cert = NULL;
2553         char client_key_buf[200];
2554         char *client_key = NULL;
2555         int spp;
2556
2557         wpa_printf(MSG_INFO, "Policy update requested");
2558
2559         if (!pps_fname) {
2560                 char buf[256];
2561                 wpa_printf(MSG_INFO, "Determining PPS file based on Home SP information");
2562                 if (os_strncmp(address, "fqdn=", 5) == 0) {
2563                         wpa_printf(MSG_INFO, "Use requested FQDN from command line");
2564                         os_snprintf(buf, sizeof(buf), "%s", address + 5);
2565                         address = NULL;
2566                 } else if (get_wpa_status(ctx->ifname, "provisioning_sp", buf,
2567                                           sizeof(buf)) < 0) {
2568                         wpa_printf(MSG_INFO, "Could not get provisioning Home SP FQDN from wpa_supplicant");
2569                         return -1;
2570                 }
2571                 os_free(ctx->fqdn);
2572                 ctx->fqdn = os_strdup(buf);
2573                 if (ctx->fqdn == NULL)
2574                         return -1;
2575                 wpa_printf(MSG_INFO, "Home SP FQDN for current credential: %s",
2576                            buf);
2577                 os_snprintf(pps_fname_buf, sizeof(pps_fname_buf),
2578                             "SP/%s/pps.xml", ctx->fqdn);
2579                 pps_fname = pps_fname_buf;
2580
2581                 os_snprintf(ca_fname_buf, sizeof(ca_fname_buf), "SP/%s/ca.pem",
2582                             buf);
2583                 ca_fname = ca_fname_buf;
2584         }
2585
2586         if (!os_file_exists(pps_fname)) {
2587                 wpa_printf(MSG_INFO, "PPS file '%s' does not exist or is not accessible",
2588                            pps_fname);
2589                 return -1;
2590         }
2591         wpa_printf(MSG_INFO, "Using PPS file: %s", pps_fname);
2592
2593         if (ca_fname && !os_file_exists(ca_fname)) {
2594                 wpa_printf(MSG_INFO, "CA file '%s' does not exist or is not accessible",
2595                            ca_fname);
2596                 return -1;
2597         }
2598         wpa_printf(MSG_INFO, "Using server trust root: %s", ca_fname);
2599         ctx->ca_fname = ca_fname;
2600
2601         pps = node_from_file(ctx->xml, pps_fname);
2602         if (pps == NULL) {
2603                 wpa_printf(MSG_INFO, "Could not read PPS MO");
2604                 return -1;
2605         }
2606
2607         if (!ctx->fqdn) {
2608                 char *tmp;
2609                 node = get_child_node(ctx->xml, pps, "HomeSP/FQDN");
2610                 if (node == NULL) {
2611                         wpa_printf(MSG_INFO, "No HomeSP/FQDN found from PPS");
2612                         return -1;
2613                 }
2614                 tmp = xml_node_get_text(ctx->xml, node);
2615                 if (tmp == NULL) {
2616                         wpa_printf(MSG_INFO, "No HomeSP/FQDN text found from PPS");
2617                         return -1;
2618                 }
2619                 ctx->fqdn = os_strdup(tmp);
2620                 xml_node_get_text_free(ctx->xml, tmp);
2621                 if (!ctx->fqdn) {
2622                         wpa_printf(MSG_INFO, "No FQDN known");
2623                         return -1;
2624                 }
2625         }
2626
2627         node = get_child_node(ctx->xml, pps,
2628                               "Policy/PolicyUpdate/UpdateMethod");
2629         if (node) {
2630                 char *tmp;
2631                 tmp = xml_node_get_text(ctx->xml, node);
2632                 if (tmp && os_strcasecmp(tmp, "OMA-DM-ClientInitiated") == 0)
2633                         spp = 0;
2634                 else
2635                         spp = 1;
2636         } else {
2637                 wpa_printf(MSG_INFO, "No UpdateMethod specified - assume SPP");
2638                 spp = 1;
2639         }
2640
2641         get_user_pw(ctx, pps, "Policy/PolicyUpdate/UsernamePassword",
2642                     &cred_username, &cred_password);
2643         if (cred_username)
2644                 wpa_printf(MSG_INFO, "Using username: %s", cred_username);
2645         if (cred_password)
2646                 wpa_printf(MSG_DEBUG, "Using password: %s", cred_password);
2647
2648         if (cred_username == NULL && cred_password == NULL &&
2649             get_child_node(ctx->xml, pps, "Credential/DigitalCertificate")) {
2650                 wpa_printf(MSG_INFO, "Using client certificate");
2651                 os_snprintf(client_cert_buf, sizeof(client_cert_buf),
2652                             "SP/%s/client-cert.pem", ctx->fqdn);
2653                 client_cert = client_cert_buf;
2654                 os_snprintf(client_key_buf, sizeof(client_key_buf),
2655                             "SP/%s/client-key.pem", ctx->fqdn);
2656                 client_key = client_key_buf;
2657         }
2658
2659         if (!address) {
2660                 node = get_child_node(ctx->xml, pps, "Policy/PolicyUpdate/URI");
2661                 if (node) {
2662                         uri = xml_node_get_text(ctx->xml, node);
2663                         wpa_printf(MSG_INFO, "URI based on PPS: %s", uri);
2664                         address = uri;
2665                 }
2666         }
2667         if (!address) {
2668                 wpa_printf(MSG_INFO, "Server URL not known");
2669                 return -1;
2670         }
2671
2672         if (spp)
2673                 spp_pol_upd(ctx, address, pps_fname,
2674                             client_cert, client_key,
2675                             cred_username, cred_password, pps);
2676         else
2677                 oma_dm_pol_upd(ctx, address, pps_fname,
2678                                client_cert, client_key,
2679                                cred_username, cred_password, pps);
2680
2681         xml_node_get_text_free(ctx->xml, uri);
2682         xml_node_get_text_free(ctx->xml, cred_username);
2683         str_clear_free(cred_password);
2684         xml_node_free(ctx->xml, pps);
2685
2686         return 0;
2687 }
2688
2689
2690 static char * get_hostname(const char *url)
2691 {
2692         const char *pos, *end, *end2;
2693         char *ret;
2694
2695         if (url == NULL)
2696                 return NULL;
2697
2698         pos = os_strchr(url, '/');
2699         if (pos == NULL)
2700                 return NULL;
2701         pos++;
2702         if (*pos != '/')
2703                 return NULL;
2704         pos++;
2705
2706         end = os_strchr(pos, '/');
2707         end2 = os_strchr(pos, ':');
2708         if ((end && end2 && end2 < end) || (!end && end2))
2709                 end = end2;
2710         if (end)
2711                 end--;
2712         else {
2713                 end = pos;
2714                 while (*end)
2715                         end++;
2716                 if (end > pos)
2717                         end--;
2718         }
2719
2720         ret = os_malloc(end - pos + 2);
2721         if (ret == NULL)
2722                 return NULL;
2723
2724         os_memcpy(ret, pos, end - pos + 1);
2725         ret[end - pos + 1] = '\0';
2726
2727         return ret;
2728 }
2729
2730
2731 static int osu_cert_cb(void *_ctx, struct http_cert *cert)
2732 {
2733         struct hs20_osu_client *ctx = _ctx;
2734         unsigned int i, j;
2735         int found;
2736         char *host = NULL;
2737
2738         wpa_printf(MSG_INFO, "osu_cert_cb(osu_cert_validation=%d, url=%s)",
2739                    !ctx->no_osu_cert_validation, ctx->server_url);
2740
2741         host = get_hostname(ctx->server_url);
2742
2743         for (i = 0; i < ctx->server_dnsname_count; i++)
2744                 os_free(ctx->server_dnsname[i]);
2745         os_free(ctx->server_dnsname);
2746         ctx->server_dnsname = os_calloc(cert->num_dnsname, sizeof(char *));
2747         ctx->server_dnsname_count = 0;
2748
2749         found = 0;
2750         for (i = 0; i < cert->num_dnsname; i++) {
2751                 if (ctx->server_dnsname) {
2752                         ctx->server_dnsname[ctx->server_dnsname_count] =
2753                                 os_strdup(cert->dnsname[i]);
2754                         if (ctx->server_dnsname[ctx->server_dnsname_count])
2755                                 ctx->server_dnsname_count++;
2756                 }
2757                 if (host && os_strcasecmp(host, cert->dnsname[i]) == 0)
2758                         found = 1;
2759                 wpa_printf(MSG_INFO, "dNSName '%s'", cert->dnsname[i]);
2760         }
2761
2762         if (host && !found) {
2763                 wpa_printf(MSG_INFO, "Server name from URL (%s) did not match any dNSName - abort connection",
2764                            host);
2765                 write_result(ctx, "Server name from URL (%s) did not match any dNSName - abort connection",
2766                              host);
2767                 os_free(host);
2768                 return -1;
2769         }
2770
2771         os_free(host);
2772
2773         for (i = 0; i < cert->num_othername; i++) {
2774                 if (os_strcmp(cert->othername[i].oid,
2775                               "1.3.6.1.4.1.40808.1.1.1") == 0) {
2776                         wpa_hexdump_ascii(MSG_INFO,
2777                                           "id-wfa-hotspot-friendlyName",
2778                                           cert->othername[i].data,
2779                                           cert->othername[i].len);
2780                 }
2781         }
2782
2783         for (j = 0; !ctx->no_osu_cert_validation &&
2784                      j < ctx->friendly_name_count; j++) {
2785                 int found = 0;
2786                 for (i = 0; i < cert->num_othername; i++) {
2787                         if (os_strcmp(cert->othername[i].oid,
2788                                       "1.3.6.1.4.1.40808.1.1.1") != 0)
2789                                 continue;
2790                         if (cert->othername[i].len < 3)
2791                                 continue;
2792                         if (os_strncasecmp((char *) cert->othername[i].data,
2793                                            ctx->friendly_name[j].lang, 3) != 0)
2794                                 continue;
2795                         if (os_strncmp((char *) cert->othername[i].data + 3,
2796                                        ctx->friendly_name[j].text,
2797                                        cert->othername[i].len - 3) == 0) {
2798                                 found = 1;
2799                                 break;
2800                         }
2801                 }
2802
2803                 if (!found) {
2804                         wpa_printf(MSG_INFO, "No friendly name match found for '[%s]%s'",
2805                                    ctx->friendly_name[j].lang,
2806                                    ctx->friendly_name[j].text);
2807                         write_result(ctx, "No friendly name match found for '[%s]%s'",
2808                                      ctx->friendly_name[j].lang,
2809                                      ctx->friendly_name[j].text);
2810                         return -1;
2811                 }
2812         }
2813
2814         for (i = 0; i < cert->num_logo; i++) {
2815                 struct http_logo *logo = &cert->logo[i];
2816
2817                 wpa_printf(MSG_INFO, "logo hash alg %s uri '%s'",
2818                            logo->alg_oid, logo->uri);
2819                 wpa_hexdump_ascii(MSG_INFO, "hashValue",
2820                                   logo->hash, logo->hash_len);
2821         }
2822
2823         for (j = 0; !ctx->no_osu_cert_validation && j < ctx->icon_count; j++) {
2824                 int found = 0;
2825                 char *name = ctx->icon_filename[j];
2826                 size_t name_len = os_strlen(name);
2827
2828                 wpa_printf(MSG_INFO,
2829                            "[%i] Looking for icon file name '%s' match",
2830                            j, name);
2831                 for (i = 0; i < cert->num_logo; i++) {
2832                         struct http_logo *logo = &cert->logo[i];
2833                         size_t uri_len = os_strlen(logo->uri);
2834                         char *pos;
2835
2836                         wpa_printf(MSG_INFO,
2837                                    "[%i] Comparing to '%s' uri_len=%d name_len=%d",
2838                                    i, logo->uri, (int) uri_len, (int) name_len);
2839                         if (uri_len < 1 + name_len) {
2840                                 wpa_printf(MSG_INFO, "URI Length is too short");
2841                                 continue;
2842                         }
2843                         pos = &logo->uri[uri_len - name_len - 1];
2844                         if (*pos != '/')
2845                                 continue;
2846                         pos++;
2847                         if (os_strcmp(pos, name) == 0) {
2848                                 found = 1;
2849                                 break;
2850                         }
2851                 }
2852
2853                 if (!found) {
2854                         wpa_printf(MSG_INFO, "No icon filename match found for '%s'",
2855                                    name);
2856                         write_result(ctx,
2857                                      "No icon filename match found for '%s'",
2858                                      name);
2859                         return -1;
2860                 }
2861         }
2862
2863         for (j = 0; !ctx->no_osu_cert_validation && j < ctx->icon_count; j++) {
2864                 int found = 0;
2865
2866                 for (i = 0; i < cert->num_logo; i++) {
2867                         struct http_logo *logo = &cert->logo[i];
2868
2869                         if (logo->hash_len != 32) {
2870                                 wpa_printf(MSG_INFO,
2871                                            "[%i][%i] Icon hash length invalid (should be 32): %d",
2872                                            j, i, (int) logo->hash_len);
2873                                 continue;
2874                         }
2875                         if (os_memcmp(logo->hash, ctx->icon_hash[j], 32) == 0) {
2876                                 found = 1;
2877                                 break;
2878                         }
2879
2880                         wpa_printf(MSG_DEBUG,
2881                                    "[%u][%u] Icon hash did not match", j, i);
2882                         wpa_hexdump_ascii(MSG_DEBUG, "logo->hash",
2883                                           logo->hash, 32);
2884                         wpa_hexdump_ascii(MSG_DEBUG, "ctx->icon_hash[j]",
2885                                           ctx->icon_hash[j], 32);
2886                 }
2887
2888                 if (!found) {
2889                         wpa_printf(MSG_INFO,
2890                                    "No icon hash match (by hash) found");
2891                         write_result(ctx,
2892                                      "No icon hash match (by hash) found");
2893                         return -1;
2894                 }
2895         }
2896
2897         return 0;
2898 }
2899
2900
2901 static int init_ctx(struct hs20_osu_client *ctx)
2902 {
2903         xml_node_t *devinfo, *devid;
2904
2905         os_memset(ctx, 0, sizeof(*ctx));
2906         ctx->ifname = "wlan0";
2907         ctx->xml = xml_node_init_ctx(ctx, NULL);
2908         if (ctx->xml == NULL)
2909                 return -1;
2910
2911         devinfo = node_from_file(ctx->xml, "devinfo.xml");
2912         if (!devinfo) {
2913                 wpa_printf(MSG_ERROR, "devinfo.xml not found");
2914                 return -1;
2915         }
2916
2917         devid = get_node(ctx->xml, devinfo, "DevId");
2918         if (devid) {
2919                 char *tmp = xml_node_get_text(ctx->xml, devid);
2920                 if (tmp) {
2921                         ctx->devid = os_strdup(tmp);
2922                         xml_node_get_text_free(ctx->xml, tmp);
2923                 }
2924         }
2925         xml_node_free(ctx->xml, devinfo);
2926
2927         if (ctx->devid == NULL) {
2928                 wpa_printf(MSG_ERROR, "Could not fetch DevId from devinfo.xml");
2929                 return -1;
2930         }
2931
2932         ctx->http = http_init_ctx(ctx, ctx->xml);
2933         if (ctx->http == NULL) {
2934                 xml_node_deinit_ctx(ctx->xml);
2935                 return -1;
2936         }
2937         http_ocsp_set(ctx->http, 2);
2938         http_set_cert_cb(ctx->http, osu_cert_cb, ctx);
2939
2940         return 0;
2941 }
2942
2943
2944 static void deinit_ctx(struct hs20_osu_client *ctx)
2945 {
2946         size_t i;
2947
2948         http_deinit_ctx(ctx->http);
2949         xml_node_deinit_ctx(ctx->xml);
2950         os_free(ctx->fqdn);
2951         os_free(ctx->server_url);
2952         os_free(ctx->devid);
2953
2954         for (i = 0; i < ctx->server_dnsname_count; i++)
2955                 os_free(ctx->server_dnsname[i]);
2956         os_free(ctx->server_dnsname);
2957 }
2958
2959
2960 static void check_workarounds(struct hs20_osu_client *ctx)
2961 {
2962         FILE *f;
2963         char buf[100];
2964         unsigned long int val = 0;
2965
2966         f = fopen("hs20-osu-client.workarounds", "r");
2967         if (f == NULL)
2968                 return;
2969
2970         if (fgets(buf, sizeof(buf), f))
2971                 val = strtoul(buf, NULL, 16);
2972
2973         fclose(f);
2974
2975         if (val) {
2976                 wpa_printf(MSG_INFO, "Workarounds enabled: 0x%lx", val);
2977                 ctx->workarounds = val;
2978                 if (ctx->workarounds & WORKAROUND_OCSP_OPTIONAL)
2979                         http_ocsp_set(ctx->http, 1);
2980         }
2981 }
2982
2983
2984 static void usage(void)
2985 {
2986         printf("usage: hs20-osu-client [-dddqqKt] [-S<station ifname>] \\\n"
2987                "    [-w<wpa_supplicant ctrl_iface dir>] "
2988                "[-r<result file>] [-f<debug file>] \\\n"
2989                "    [-s<summary file>] \\\n"
2990                "    [-x<spp.xsd file name>] \\\n"
2991                "    <command> [arguments..]\n"
2992                "commands:\n"
2993                "- to_tnds <XML MO> <XML MO in TNDS format> [URN]\n"
2994                "- to_tnds2 <XML MO> <XML MO in TNDS format (Path) "
2995                "[URN]>\n"
2996                "- from_tnds <XML MO in TNDS format> <XML MO>\n"
2997                "- set_pps <PerProviderSubscription XML file name>\n"
2998                "- get_fqdn <PerProviderSubscription XML file name>\n"
2999                "- pol_upd [Server URL] [PPS] [CA cert]\n"
3000                "- sub_rem <Server URL> [PPS] [CA cert]\n"
3001                "- prov <Server URL> [CA cert]\n"
3002                "- oma_dm_prov <Server URL> [CA cert]\n"
3003                "- sim_prov <Server URL> [CA cert]\n"
3004                "- oma_dm_sim_prov <Server URL> [CA cert]\n"
3005                "- signup [CA cert]\n"
3006                "- dl_osu_ca <PPS> <CA file>\n"
3007                "- dl_polupd_ca <PPS> <CA file>\n"
3008                "- dl_aaa_ca <PPS> <CA file>\n"
3009                "- browser <URL>\n"
3010                "- parse_cert <X.509 certificate (DER)>\n"
3011                "- osu_select <OSU info directory> [CA cert]\n");
3012 }
3013
3014
3015 int main(int argc, char *argv[])
3016 {
3017         struct hs20_osu_client ctx;
3018         int c;
3019         int ret = 0;
3020         int no_prod_assoc = 0;
3021         const char *friendly_name = NULL;
3022         const char *wpa_debug_file_path = NULL;
3023         extern char *wpas_ctrl_path;
3024         extern int wpa_debug_level;
3025         extern int wpa_debug_show_keys;
3026         extern int wpa_debug_timestamp;
3027
3028         if (init_ctx(&ctx) < 0)
3029                 return -1;
3030
3031         for (;;) {
3032                 c = getopt(argc, argv, "df:hKNO:qr:s:S:tw:x:");
3033                 if (c < 0)
3034                         break;
3035                 switch (c) {
3036                 case 'd':
3037                         if (wpa_debug_level > 0)
3038                                 wpa_debug_level--;
3039                         break;
3040                 case 'f':
3041                         wpa_debug_file_path = optarg;
3042                         break;
3043                 case 'K':
3044                         wpa_debug_show_keys++;
3045                         break;
3046                 case 'N':
3047                         no_prod_assoc = 1;
3048                         break;
3049                 case 'O':
3050                         friendly_name = optarg;
3051                         break;
3052                 case 'q':
3053                         wpa_debug_level++;
3054                         break;
3055                 case 'r':
3056                         ctx.result_file = optarg;
3057                         break;
3058                 case 's':
3059                         ctx.summary_file = optarg;
3060                         break;
3061                 case 'S':
3062                         ctx.ifname = optarg;
3063                         break;
3064                 case 't':
3065                         wpa_debug_timestamp++;
3066                         break;
3067                 case 'w':
3068                         wpas_ctrl_path = optarg;
3069                         break;
3070                 case 'x':
3071                         spp_xsd_fname = optarg;
3072                         break;
3073                 case 'h':
3074                 default:
3075                         usage();
3076                         exit(0);
3077                         break;
3078                 }
3079         }
3080
3081         if (argc - optind < 1) {
3082                 usage();
3083                 exit(0);
3084         }
3085
3086         wpa_debug_open_file(wpa_debug_file_path);
3087
3088 #ifdef __linux__
3089         setlinebuf(stdout);
3090 #endif /* __linux__ */
3091
3092         if (ctx.result_file)
3093                 unlink(ctx.result_file);
3094         wpa_printf(MSG_DEBUG, "===[hs20-osu-client START - command: %s ]======"
3095                    "================", argv[optind]);
3096         check_workarounds(&ctx);
3097
3098         if (strcmp(argv[optind], "to_tnds") == 0) {
3099                 if (argc - optind < 2) {
3100                         usage();
3101                         exit(0);
3102                 }
3103                 cmd_to_tnds(&ctx, argv[optind + 1], argv[optind + 2],
3104                             argc > optind + 3 ? argv[optind + 3] : NULL,
3105                             0);
3106         } else if (strcmp(argv[optind], "to_tnds2") == 0) {
3107                 if (argc - optind < 2) {
3108                         usage();
3109                         exit(0);
3110                 }
3111                 cmd_to_tnds(&ctx, argv[optind + 1], argv[optind + 2],
3112                             argc > optind + 3 ? argv[optind + 3] : NULL,
3113                             1);
3114         } else if (strcmp(argv[optind], "from_tnds") == 0) {
3115                 if (argc - optind < 2) {
3116                         usage();
3117                         exit(0);
3118                 }
3119                 cmd_from_tnds(&ctx, argv[optind + 1], argv[optind + 2]);
3120         } else if (strcmp(argv[optind], "sub_rem") == 0) {
3121                 if (argc - optind < 2) {
3122                         usage();
3123                         exit(0);
3124                 }
3125                 if (argc - optind < 2)
3126                         wpa_printf(MSG_ERROR, "Server URL missing from command line");
3127                 else
3128                         ret = cmd_sub_rem(&ctx, argv[optind + 1],
3129                                           argc > optind + 2 ?
3130                                           argv[optind + 2] : NULL,
3131                                           argc > optind + 3 ?
3132                                           argv[optind + 3] : NULL);
3133         } else if (strcmp(argv[optind], "pol_upd") == 0) {
3134                 if (argc - optind < 2) {
3135                         usage();
3136                         exit(0);
3137                 }
3138                 ret = cmd_pol_upd(&ctx, argc > 2 ? argv[optind + 1] : NULL,
3139                                   argc > optind + 2 ? argv[optind + 2] : NULL,
3140                                   argc > optind + 3 ? argv[optind + 3] : NULL);
3141         } else if (strcmp(argv[optind], "prov") == 0) {
3142                 if (argc - optind < 2) {
3143                         usage();
3144                         exit(0);
3145                 }
3146                 ctx.ca_fname = argv[optind + 2];
3147                 wpa_printf(MSG_DEBUG, "Calling cmd_prov from main");
3148                 cmd_prov(&ctx, argv[optind + 1]);
3149         } else if (strcmp(argv[optind], "sim_prov") == 0) {
3150                 if (argc - optind < 2) {
3151                         usage();
3152                         exit(0);
3153                 }
3154                 ctx.ca_fname = argv[optind + 2];
3155                 cmd_sim_prov(&ctx, argv[optind + 1]);
3156         } else if (strcmp(argv[optind], "dl_osu_ca") == 0) {
3157                 if (argc - optind < 2) {
3158                         usage();
3159                         exit(0);
3160                 }
3161                 cmd_dl_osu_ca(&ctx, argv[optind + 1], argv[optind + 2]);
3162         } else if (strcmp(argv[optind], "dl_polupd_ca") == 0) {
3163                 if (argc - optind < 2) {
3164                         usage();
3165                         exit(0);
3166                 }
3167                 cmd_dl_polupd_ca(&ctx, argv[optind + 1], argv[optind + 2]);
3168         } else if (strcmp(argv[optind], "dl_aaa_ca") == 0) {
3169                 if (argc - optind < 2) {
3170                         usage();
3171                         exit(0);
3172                 }
3173                 cmd_dl_aaa_ca(&ctx, argv[optind + 1], argv[optind + 2]);
3174         } else if (strcmp(argv[optind], "osu_select") == 0) {
3175                 if (argc - optind < 2) {
3176                         usage();
3177                         exit(0);
3178                 }
3179                 ctx.ca_fname = argc > optind + 2 ? argv[optind + 2] : NULL;
3180                 cmd_osu_select(&ctx, argv[optind + 1], 2, 1, NULL);
3181         } else if (strcmp(argv[optind], "signup") == 0) {
3182                 ctx.ca_fname = argc > optind + 1 ? argv[optind + 1] : NULL;
3183                 ret = cmd_signup(&ctx, no_prod_assoc, friendly_name);
3184         } else if (strcmp(argv[optind], "set_pps") == 0) {
3185                 if (argc - optind < 2) {
3186                         usage();
3187                         exit(0);
3188                 }
3189                 cmd_set_pps(&ctx, argv[optind + 1]);
3190         } else if (strcmp(argv[optind], "get_fqdn") == 0) {
3191                 if (argc - optind < 1) {
3192                         usage();
3193                         exit(0);
3194                 }
3195                 ret = cmd_get_fqdn(&ctx, argv[optind + 1]);
3196         } else if (strcmp(argv[optind], "oma_dm_prov") == 0) {
3197                 if (argc - optind < 2) {
3198                         usage();
3199                         exit(0);
3200                 }
3201                 ctx.ca_fname = argv[optind + 2];
3202                 cmd_oma_dm_prov(&ctx, argv[optind + 1]);
3203         } else if (strcmp(argv[optind], "oma_dm_sim_prov") == 0) {
3204                 if (argc - optind < 2) {
3205                         usage();
3206                         exit(0);
3207                 }
3208                 ctx.ca_fname = argv[optind + 2];
3209                 if (cmd_oma_dm_sim_prov(&ctx, argv[optind + 1]) < 0) {
3210                         write_summary(&ctx, "Failed to complete OMA DM SIM provisioning");
3211                         return -1;
3212                 }
3213         } else if (strcmp(argv[optind], "oma_dm_add") == 0) {
3214                 if (argc - optind < 2) {
3215                         usage();
3216                         exit(0);
3217                 }
3218                 cmd_oma_dm_add(&ctx, argv[optind + 1], argv[optind + 2]);
3219         } else if (strcmp(argv[optind], "oma_dm_replace") == 0) {
3220                 if (argc - optind < 2) {
3221                         usage();
3222                         exit(0);
3223                 }
3224                 cmd_oma_dm_replace(&ctx, argv[optind + 1], argv[optind + 2]);
3225         } else if (strcmp(argv[optind], "est_csr") == 0) {
3226                 if (argc - optind < 2) {
3227                         usage();
3228                         exit(0);
3229                 }
3230                 mkdir("Cert", S_IRWXU);
3231                 est_build_csr(&ctx, argv[optind + 1]);
3232         } else if (strcmp(argv[optind], "browser") == 0) {
3233                 int ret;
3234
3235                 if (argc - optind < 2) {
3236                         usage();
3237                         exit(0);
3238                 }
3239
3240                 wpa_printf(MSG_INFO, "Launch web browser to URL %s",
3241                            argv[optind + 1]);
3242                 ret = hs20_web_browser(argv[optind + 1]);
3243                 wpa_printf(MSG_INFO, "Web browser result: %d", ret);
3244         } else if (strcmp(argv[optind], "parse_cert") == 0) {
3245                 if (argc - optind < 2) {
3246                         usage();
3247                         exit(0);
3248                 }
3249
3250                 wpa_debug_level = MSG_MSGDUMP;
3251                 http_parse_x509_certificate(ctx.http, argv[optind + 1]);
3252                 wpa_debug_level = MSG_INFO;
3253         } else {
3254                 wpa_printf(MSG_INFO, "Unknown command '%s'", argv[optind]);
3255         }
3256
3257         deinit_ctx(&ctx);
3258         wpa_printf(MSG_DEBUG,
3259                    "===[hs20-osu-client END ]======================");
3260
3261         wpa_debug_close_file();
3262
3263         return ret;
3264 }