libeap/hs20/client/spp_client.c

   1 /*
   2  * Hotspot 2.0 SPP 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 <sys/stat.h>
  11
  12 #include "common.h"
  13 #include "browser.h"
  14 #include "wpa_ctrl.h"
  15 #include "wpa_helpers.h"
  16 #include "xml-utils.h"
  17 #include "http-utils.h"
  18 #include "utils/base64.h"
  19 #include "crypto/crypto.h"
  20 #include "crypto/sha256.h"
  21 #include "osu_client.h"
  22
  23
  24 extern const char *spp_xsd_fname;
  25
  26 static int hs20_spp_update_response(struct hs20_osu_client *ctx,
  27                                     const char *session_id,
  28                                     const char *spp_status,
  29                                     const char *error_code);
  30 static void hs20_policy_update_complete(
  31         struct hs20_osu_client *ctx, const char *pps_fname);
  32
  33
  34 static char * get_spp_attr_value(struct xml_node_ctx *ctx, xml_node_t *node,
  35                                  char *attr_name)
  36 {
  37         return xml_node_get_attr_value_ns(ctx, node, SPP_NS_URI, attr_name);
  38 }
  39
  40
  41 static int hs20_spp_validate(struct hs20_osu_client *ctx, xml_node_t *node,
  42                              const char *expected_name)
  43 {
  44         struct xml_node_ctx *xctx = ctx->xml;
  45         const char *name;
  46         char *err;
  47         int ret;
  48
  49         if (!xml_node_is_element(xctx, node))
  50                 return -1;
  51
  52         name = xml_node_get_localname(xctx, node);
  53         if (name == NULL)
  54                 return -1;
  55
  56         if (strcmp(expected_name, name) != 0) {
  57                 wpa_printf(MSG_INFO, "Unexpected SOAP method name '%s' (expected '%s')",
  58                            name, expected_name);
  59                 write_summary(ctx, "Unexpected SOAP method name '%s' (expected '%s')",
  60                               name, expected_name);
  61                 return -1;
  62         }
  63
  64         ret = xml_validate(xctx, node, spp_xsd_fname, &err);
  65         if (ret < 0) {
  66                 wpa_printf(MSG_INFO, "XML schema validation error(s)\n%s", err);
  67                 write_summary(ctx, "SPP XML schema validation failed");
  68                 os_free(err);
  69         }
  70         return ret;
  71 }
  72
  73
  74 static void add_mo_container(struct xml_node_ctx *ctx, xml_namespace_t *ns,
  75                              xml_node_t *parent, const char *urn,
  76                              const char *fname)
  77 {
  78         xml_node_t *node;
  79         xml_node_t *fnode, *tnds;
  80         char *str;
  81
  82         errno = 0;
  83         fnode = node_from_file(ctx, fname);
  84         if (!fnode) {
  85                 wpa_printf(MSG_ERROR,
  86                            "Failed to create XML node from file: %s, possible error: %s",
  87                            fname, strerror(errno));
  88                 return;
  89         }
  90         tnds = mo_to_tnds(ctx, fnode, 0, urn, "syncml:dmddf1.2");
  91         xml_node_free(ctx, fnode);
  92         if (!tnds)
  93                 return;
  94
  95         str = xml_node_to_str(ctx, tnds);
  96         xml_node_free(ctx, tnds);
  97         if (str == NULL)
  98                 return;
  99
 100         node = xml_node_create_text(ctx, parent, ns, "moContainer", str);
 101         if (node)
 102                 xml_node_add_attr(ctx, node, ns, "moURN", urn);
 103         os_free(str);
 104 }
 105
 106
 107 static xml_node_t * build_spp_post_dev_data(struct hs20_osu_client *ctx,
 108                                             xml_namespace_t **ret_ns,
 109                                             const char *session_id,
 110                                             const char *reason)
 111 {
 112         xml_namespace_t *ns;
 113         xml_node_t *spp_node;
 114
 115         write_summary(ctx, "Building sppPostDevData requestReason='%s'",
 116                       reason);
 117         spp_node = xml_node_create_root(ctx->xml, SPP_NS_URI, "spp", &ns,
 118                                         "sppPostDevData");
 119         if (spp_node == NULL)
 120                 return NULL;
 121         if (ret_ns)
 122                 *ret_ns = ns;
 123
 124         xml_node_add_attr(ctx->xml, spp_node, ns, "sppVersion", "1.0");
 125         xml_node_add_attr(ctx->xml, spp_node, NULL, "requestReason", reason);
 126         if (session_id)
 127                 xml_node_add_attr(ctx->xml, spp_node, ns, "sessionID",
 128                                   session_id);
 129         xml_node_add_attr(ctx->xml, spp_node, NULL, "redirectURI",
 130                           "http://localhost:12345/");
 131
 132         xml_node_create_text(ctx->xml, spp_node, ns, "supportedSPPVersions",
 133                              "1.0");
 134         xml_node_create_text(ctx->xml, spp_node, ns, "supportedMOList",
 135                              URN_HS20_PPS " " URN_OMA_DM_DEVINFO " "
 136                              URN_OMA_DM_DEVDETAIL " " URN_HS20_DEVDETAIL_EXT);
 137
 138         add_mo_container(ctx->xml, ns, spp_node, URN_OMA_DM_DEVINFO,
 139                          "devinfo.xml");
 140         add_mo_container(ctx->xml, ns, spp_node, URN_OMA_DM_DEVDETAIL,
 141                          "devdetail.xml");
 142
 143         return spp_node;
 144 }
 145
 146
 147 static int process_update_node(struct hs20_osu_client *ctx, xml_node_t *pps,
 148                                xml_node_t *update)
 149 {
 150         xml_node_t *node, *parent, *tnds, *unode;
 151         char *str;
 152         const char *name;
 153         char *uri, *pos;
 154         char *cdata, *cdata_end;
 155         size_t fqdn_len;
 156
 157         wpa_printf(MSG_INFO, "Processing updateNode");
 158         debug_dump_node(ctx, "updateNode", update);
 159
 160         uri = get_spp_attr_value(ctx->xml, update, "managementTreeURI");
 161         if (uri == NULL) {
 162                 wpa_printf(MSG_INFO, "No managementTreeURI present");
 163                 return -1;
 164         }
 165         wpa_printf(MSG_INFO, "managementTreeUri: '%s'", uri);
 166
 167         name = os_strrchr(uri, '/');
 168         if (name == NULL) {
 169                 wpa_printf(MSG_INFO, "Unexpected URI");
 170                 xml_node_get_attr_value_free(ctx->xml, uri);
 171                 return -1;
 172         }
 173         name++;
 174         wpa_printf(MSG_INFO, "Update interior node: '%s'", name);
 175
 176         str = xml_node_get_text(ctx->xml, update);
 177         if (str == NULL) {
 178                 wpa_printf(MSG_INFO, "Could not extract MO text");
 179                 xml_node_get_attr_value_free(ctx->xml, uri);
 180                 return -1;
 181         }
 182         wpa_printf(MSG_DEBUG, "[hs20] nodeContainer text: '%s'", str);
 183         cdata = strstr(str, "<![CDATA[");
 184         cdata_end = strstr(str, "]]>");
 185         if (cdata && cdata_end && cdata_end > cdata &&
 186             cdata < strstr(str, "MgmtTree") &&
 187             cdata_end > strstr(str, "/MgmtTree")) {
 188                 char *tmp;
 189                 wpa_printf(MSG_DEBUG, "[hs20] Removing extra CDATA container");
 190                 tmp = strdup(cdata + 9);
 191                 if (tmp) {
 192                         cdata_end = strstr(tmp, "]]>");
 193                         if (cdata_end)
 194                                 *cdata_end = '\0';
 195                         wpa_printf(MSG_DEBUG, "[hs20] nodeContainer text with CDATA container removed: '%s'",
 196                                    tmp);
 197                         tnds = xml_node_from_buf(ctx->xml, tmp);
 198                         free(tmp);
 199                 } else
 200                         tnds = NULL;
 201         } else
 202                 tnds = xml_node_from_buf(ctx->xml, str);
 203         xml_node_get_text_free(ctx->xml, str);
 204         if (tnds == NULL) {
 205                 wpa_printf(MSG_INFO, "[hs20] Could not parse nodeContainer text");
 206                 xml_node_get_attr_value_free(ctx->xml, uri);
 207                 return -1;
 208         }
 209
 210         unode = tnds_to_mo(ctx->xml, tnds);
 211         xml_node_free(ctx->xml, tnds);
 212         if (unode == NULL) {
 213                 wpa_printf(MSG_INFO, "[hs20] Could not parse nodeContainer TNDS text");
 214                 xml_node_get_attr_value_free(ctx->xml, uri);
 215                 return -1;
 216         }
 217
 218         debug_dump_node(ctx, "Parsed TNDS", unode);
 219
 220         if (get_node_uri(ctx->xml, unode, name) == NULL) {
 221                 wpa_printf(MSG_INFO, "[hs20] %s node not found", name);
 222                 xml_node_free(ctx->xml, unode);
 223                 xml_node_get_attr_value_free(ctx->xml, uri);
 224                 return -1;
 225         }
 226
 227         if (os_strncasecmp(uri, "./Wi-Fi/", 8) != 0) {
 228                 wpa_printf(MSG_INFO, "Do not allow update outside ./Wi-Fi");
 229                 xml_node_free(ctx->xml, unode);
 230                 xml_node_get_attr_value_free(ctx->xml, uri);
 231                 return -1;
 232         }
 233         pos = uri + 8;
 234
 235         if (ctx->fqdn == NULL) {
 236                 wpa_printf(MSG_INFO, "FQDN not known");
 237                 xml_node_free(ctx->xml, unode);
 238                 xml_node_get_attr_value_free(ctx->xml, uri);
 239                 return -1;
 240         }
 241         fqdn_len = os_strlen(ctx->fqdn);
 242         if (os_strncasecmp(pos, ctx->fqdn, fqdn_len) != 0 ||
 243             pos[fqdn_len] != '/') {
 244                 wpa_printf(MSG_INFO, "Do not allow update outside ./Wi-Fi/%s",
 245                            ctx->fqdn);
 246                 xml_node_free(ctx->xml, unode);
 247                 xml_node_get_attr_value_free(ctx->xml, uri);
 248                 return -1;
 249         }
 250         pos += fqdn_len + 1;
 251
 252         if (os_strncasecmp(pos, "PerProviderSubscription/", 24) != 0) {
 253                 wpa_printf(MSG_INFO, "Do not allow update outside ./Wi-Fi/%s/PerProviderSubscription",
 254                            ctx->fqdn);
 255                 xml_node_free(ctx->xml, unode);
 256                 xml_node_get_attr_value_free(ctx->xml, uri);
 257                 return -1;
 258         }
 259         pos += 24;
 260
 261         wpa_printf(MSG_INFO, "Update command for PPS node %s", pos);
 262
 263         node = get_node(ctx->xml, pps, pos);
 264         if (node) {
 265                 parent = xml_node_get_parent(ctx->xml, node);
 266                 xml_node_detach(ctx->xml, node);
 267                 wpa_printf(MSG_INFO, "Replace '%s' node", name);
 268         } else {
 269                 char *pos2;
 270                 pos2 = os_strrchr(pos, '/');
 271                 if (pos2 == NULL) {
 272                         parent = pps;
 273                 } else {
 274                         *pos2 = '\0';
 275                         parent = get_node(ctx->xml, pps, pos);
 276                 }
 277                 if (parent == NULL) {
 278                         wpa_printf(MSG_INFO, "Could not find parent %s", pos);
 279                         xml_node_free(ctx->xml, unode);
 280                         xml_node_get_attr_value_free(ctx->xml, uri);
 281                         return -1;
 282                 }
 283                 wpa_printf(MSG_INFO, "Add '%s' node", name);
 284         }
 285         xml_node_add_child(ctx->xml, parent, unode);
 286
 287         xml_node_get_attr_value_free(ctx->xml, uri);
 288
 289         return 0;
 290 }
 291
 292
 293 static int update_pps(struct hs20_osu_client *ctx, xml_node_t *update,
 294                       const char *pps_fname, xml_node_t *pps)
 295 {
 296         wpa_printf(MSG_INFO, "Updating PPS based on updateNode element(s)");
 297         xml_node_for_each_sibling(ctx->xml, update) {
 298                 xml_node_for_each_check(ctx->xml, update);
 299                 if (process_update_node(ctx, pps, update) < 0)
 300                         return -1;
 301         }
 302
 303         return update_pps_file(ctx, pps_fname, pps);
 304 }
 305
 306
 307 static void hs20_sub_rem_complete(struct hs20_osu_client *ctx,
 308                                   const char *pps_fname)
 309 {
 310         /*
 311          * Update wpa_supplicant credentials and reconnect using updated
 312          * information.
 313          */
 314         wpa_printf(MSG_INFO, "Updating wpa_supplicant credentials");
 315         cmd_set_pps(ctx, pps_fname);
 316
 317         if (ctx->no_reconnect)
 318                 return;
 319
 320         wpa_printf(MSG_INFO, "Requesting reconnection with updated configuration");
 321         if (wpa_command(ctx->ifname, "INTERWORKING_SELECT auto") < 0)
 322                 wpa_printf(MSG_ERROR, "Failed to request wpa_supplicant to reconnect");
 323 }
 324
 325
 326 static xml_node_t * hs20_spp_upload_mo(struct hs20_osu_client *ctx,
 327                                        xml_node_t *cmd,
 328                                        const char *session_id,
 329                                        const char *pps_fname)
 330 {
 331         xml_namespace_t *ns;
 332         xml_node_t *node, *ret_node;
 333         char *urn;
 334
 335         urn = get_spp_attr_value(ctx->xml, cmd, "moURN");
 336         if (!urn) {
 337                 wpa_printf(MSG_INFO, "No URN included");
 338                 return NULL;
 339         }
 340         wpa_printf(MSG_INFO, "Upload MO request - URN=%s", urn);
 341         if (strcasecmp(urn, URN_HS20_PPS) != 0) {
 342                 wpa_printf(MSG_INFO, "Unsupported moURN");
 343                 xml_node_get_attr_value_free(ctx->xml, urn);
 344                 return NULL;
 345         }
 346         xml_node_get_attr_value_free(ctx->xml, urn);
 347
 348         if (!pps_fname) {
 349                 wpa_printf(MSG_INFO, "PPS file name no known");
 350                 return NULL;
 351         }
 352
 353         node = build_spp_post_dev_data(ctx, &ns, session_id,
 354                                        "MO upload");
 355         if (node == NULL)
 356                 return NULL;
 357         add_mo_container(ctx->xml, ns, node, URN_HS20_PPS, pps_fname);
 358
 359         ret_node = soap_send_receive(ctx->http, node);
 360         if (ret_node == NULL)
 361                 return NULL;
 362
 363         debug_dump_node(ctx, "Received response to MO upload", ret_node);
 364
 365         if (hs20_spp_validate(ctx, ret_node, "sppPostDevDataResponse") < 0) {
 366                 wpa_printf(MSG_INFO, "SPP validation failed");
 367                 xml_node_free(ctx->xml, ret_node);
 368                 return NULL;
 369         }
 370
 371         return ret_node;
 372 }
 373
 374
 375 static int hs20_add_mo(struct hs20_osu_client *ctx, xml_node_t *add_mo,
 376                        char *fname, size_t fname_len)
 377 {
 378         char *uri, *urn;
 379         int ret;
 380
 381         debug_dump_node(ctx, "Received addMO", add_mo);
 382
 383         urn = get_spp_attr_value(ctx->xml, add_mo, "moURN");
 384         if (urn == NULL) {
 385                 wpa_printf(MSG_INFO, "[hs20] No moURN in addMO");
 386                 return -1;
 387         }
 388         wpa_printf(MSG_INFO, "addMO - moURN: '%s'", urn);
 389         if (strcasecmp(urn, URN_HS20_PPS) != 0) {
 390                 wpa_printf(MSG_INFO, "[hs20] Unsupported MO in addMO");
 391                 xml_node_get_attr_value_free(ctx->xml, urn);
 392                 return -1;
 393         }
 394         xml_node_get_attr_value_free(ctx->xml, urn);
 395
 396         uri = get_spp_attr_value(ctx->xml, add_mo, "managementTreeURI");
 397         if (uri == NULL) {
 398                 wpa_printf(MSG_INFO, "[hs20] No managementTreeURI in addMO");
 399                 return -1;
 400         }
 401         wpa_printf(MSG_INFO, "addMO - managementTreeURI: '%s'", uri);
 402
 403         ret = hs20_add_pps_mo(ctx, uri, add_mo, fname, fname_len);
 404         xml_node_get_attr_value_free(ctx->xml, uri);
 405         return ret;
 406 }
 407
 408
 409 static int process_spp_user_input_response(struct hs20_osu_client *ctx,
 410                                            const char *session_id,
 411                                            xml_node_t *add_mo)
 412 {
 413         int ret;
 414         char fname[300];
 415
 416         debug_dump_node(ctx, "addMO", add_mo);
 417
 418         wpa_printf(MSG_INFO, "Subscription registration completed");
 419
 420         if (hs20_add_mo(ctx, add_mo, fname, sizeof(fname)) < 0) {
 421                 wpa_printf(MSG_INFO, "Could not add MO");
 422                 ret = hs20_spp_update_response(
 423                         ctx, session_id,
 424                         "Error occurred",
 425                         "MO addition or update failed");
 426                 return 0;
 427         }
 428
 429         ret = hs20_spp_update_response(ctx, session_id, "OK", NULL);
 430         if (ret == 0)
 431                 hs20_sub_rem_complete(ctx, fname);
 432
 433         return 0;
 434 }
 435
 436
 437 static xml_node_t * hs20_spp_user_input_completed(struct hs20_osu_client *ctx,
 438                                                     const char *session_id)
 439 {
 440         xml_node_t *node, *ret_node;
 441
 442         node = build_spp_post_dev_data(ctx, NULL, session_id,
 443                                        "User input completed");
 444         if (node == NULL)
 445                 return NULL;
 446
 447         ret_node = soap_send_receive(ctx->http, node);
 448         if (!ret_node) {
 449                 if (soap_reinit_client(ctx->http) < 0)
 450                         return NULL;
 451                 wpa_printf(MSG_INFO, "Try to finish with re-opened connection");
 452                 node = build_spp_post_dev_data(ctx, NULL, session_id,
 453                                                "User input completed");
 454                 if (node == NULL)
 455                         return NULL;
 456                 ret_node = soap_send_receive(ctx->http, node);
 457                 if (ret_node == NULL)
 458                         return NULL;
 459                 wpa_printf(MSG_INFO, "Continue with new connection");
 460         }
 461
 462         if (hs20_spp_validate(ctx, ret_node, "sppPostDevDataResponse") < 0) {
 463                 wpa_printf(MSG_INFO, "SPP validation failed");
 464                 xml_node_free(ctx->xml, ret_node);
 465                 return NULL;
 466         }
 467
 468         return ret_node;
 469 }
 470
 471
 472 static xml_node_t * hs20_spp_get_certificate(struct hs20_osu_client *ctx,
 473                                              xml_node_t *cmd,
 474                                              const char *session_id,
 475                                              const char *pps_fname)
 476 {
 477         xml_namespace_t *ns;
 478         xml_node_t *node, *ret_node;
 479         int res;
 480
 481         wpa_printf(MSG_INFO, "Client certificate enrollment");
 482
 483         res = osu_get_certificate(ctx, cmd);
 484         if (res < 0)
 485                 wpa_printf(MSG_INFO, "EST simpleEnroll failed");
 486
 487         node = build_spp_post_dev_data(ctx, &ns, session_id,
 488                                        res == 0 ?
 489                                        "Certificate enrollment completed" :
 490                                        "Certificate enrollment failed");
 491         if (node == NULL)
 492                 return NULL;
 493
 494         ret_node = soap_send_receive(ctx->http, node);
 495         if (ret_node == NULL)
 496                 return NULL;
 497
 498         debug_dump_node(ctx, "Received response to certificate enrollment "
 499                         "completed", ret_node);
 500
 501         if (hs20_spp_validate(ctx, ret_node, "sppPostDevDataResponse") < 0) {
 502                 wpa_printf(MSG_INFO, "SPP validation failed");
 503                 xml_node_free(ctx->xml, ret_node);
 504                 return NULL;
 505         }
 506
 507         return ret_node;
 508 }
 509
 510
 511 static int hs20_spp_exec(struct hs20_osu_client *ctx, xml_node_t *exec,
 512                          const char *session_id, const char *pps_fname,
 513                          xml_node_t *pps, xml_node_t **ret_node)
 514 {
 515         xml_node_t *cmd;
 516         const char *name;
 517         char *uri;
 518         char *id = strdup(session_id);
 519
 520         if (id == NULL)
 521                 return -1;
 522
 523         *ret_node = NULL;
 524
 525         debug_dump_node(ctx, "exec", exec);
 526
 527         xml_node_for_each_child(ctx->xml, cmd, exec) {
 528                 xml_node_for_each_check(ctx->xml, cmd);
 529                 break;
 530         }
 531         if (!cmd) {
 532                 wpa_printf(MSG_INFO, "exec command element not found (cmd=%p)",
 533                            cmd);
 534                 free(id);
 535                 return -1;
 536         }
 537
 538         name = xml_node_get_localname(ctx->xml, cmd);
 539
 540         if (strcasecmp(name, "launchBrowserToURI") == 0) {
 541                 int res;
 542                 uri = xml_node_get_text(ctx->xml, cmd);
 543                 if (!uri) {
 544                         wpa_printf(MSG_INFO, "No URI found");
 545                         free(id);
 546                         return -1;
 547                 }
 548                 wpa_printf(MSG_INFO, "Launch browser to URI '%s'", uri);
 549                 write_summary(ctx, "Launch browser to URI '%s'", uri);
 550                 res = hs20_web_browser(uri);
 551                 xml_node_get_text_free(ctx->xml, uri);
 552                 if (res > 0) {
 553                         wpa_printf(MSG_INFO, "User response in browser completed successfully - sessionid='%s'",
 554                                    id);
 555                         write_summary(ctx, "User response in browser completed successfully");
 556                         *ret_node = hs20_spp_user_input_completed(ctx, id);
 557                         free(id);
 558                         return *ret_node ? 0 : -1;
 559                 } else {
 560                         wpa_printf(MSG_INFO, "Failed to receive user response");
 561                         write_summary(ctx, "Failed to receive user response");
 562                         hs20_spp_update_response(
 563                                 ctx, id, "Error occurred", "Other");
 564                         free(id);
 565                         return -1;
 566                 }
 567                 return 0;
 568         }
 569
 570         if (strcasecmp(name, "uploadMO") == 0) {
 571                 if (pps_fname == NULL)
 572                         return -1;
 573                 *ret_node = hs20_spp_upload_mo(ctx, cmd, id,
 574                                                pps_fname);
 575                 free(id);
 576                 return *ret_node ? 0 : -1;
 577         }
 578
 579         if (strcasecmp(name, "getCertificate") == 0) {
 580                 *ret_node = hs20_spp_get_certificate(ctx, cmd, id,
 581                                                      pps_fname);
 582                 free(id);
 583                 return *ret_node ? 0 : -1;
 584         }
 585
 586         wpa_printf(MSG_INFO, "Unsupported exec command: '%s'", name);
 587         free(id);
 588         return -1;
 589 }
 590
 591
 592 enum spp_post_dev_data_use {
 593         SPP_SUBSCRIPTION_REMEDIATION,
 594         SPP_POLICY_UPDATE,
 595         SPP_SUBSCRIPTION_REGISTRATION,
 596 };
 597
 598 static void process_spp_post_dev_data_response(
 599         struct hs20_osu_client *ctx,
 600         enum spp_post_dev_data_use use, xml_node_t *node,
 601         const char *pps_fname, xml_node_t *pps)
 602 {
 603         xml_node_t *child;
 604         char *status = NULL;
 605         xml_node_t *update = NULL, *exec = NULL, *add_mo = NULL, *no_mo = NULL;
 606         char *session_id = NULL;
 607
 608         debug_dump_node(ctx, "sppPostDevDataResponse node", node);
 609
 610         status = get_spp_attr_value(ctx->xml, node, "sppStatus");
 611         if (status == NULL) {
 612                 wpa_printf(MSG_INFO, "No sppStatus attribute");
 613                 goto out;
 614         }
 615         write_summary(ctx, "Received sppPostDevDataResponse sppStatus='%s'",
 616                       status);
 617
 618         session_id = get_spp_attr_value(ctx->xml, node, "sessionID");
 619         if (session_id == NULL) {
 620                 wpa_printf(MSG_INFO, "No sessionID attribute");
 621                 goto out;
 622         }
 623
 624         wpa_printf(MSG_INFO, "[hs20] sppPostDevDataResponse - sppStatus: '%s'  sessionID: '%s'",
 625                    status, session_id);
 626
 627         xml_node_for_each_child(ctx->xml, child, node) {
 628                 const char *name;
 629                 xml_node_for_each_check(ctx->xml, child);
 630                 debug_dump_node(ctx, "child", child);
 631                 name = xml_node_get_localname(ctx->xml, child);
 632                 wpa_printf(MSG_INFO, "localname: '%s'", name);
 633                 if (!update && strcasecmp(name, "updateNode") == 0)
 634                         update = child;
 635                 if (!exec && strcasecmp(name, "exec") == 0)
 636                         exec = child;
 637                 if (!add_mo && strcasecmp(name, "addMO") == 0)
 638                         add_mo = child;
 639                 if (!no_mo && strcasecmp(name, "noMOUpdate") == 0)
 640                         no_mo = child;
 641         }
 642
 643         if (use == SPP_SUBSCRIPTION_REMEDIATION &&
 644             strcasecmp(status,
 645                        "Remediation complete, request sppUpdateResponse") == 0)
 646         {
 647                 int res, ret;
 648                 if (!update && !no_mo) {
 649                         wpa_printf(MSG_INFO, "No updateNode or noMOUpdate element");
 650                         goto out;
 651                 }
 652                 wpa_printf(MSG_INFO, "Subscription remediation completed");
 653                 res = update_pps(ctx, update, pps_fname, pps);
 654                 if (res < 0)
 655                         wpa_printf(MSG_INFO, "Failed to update PPS MO");
 656                 ret = hs20_spp_update_response(
 657                         ctx, session_id,
 658                         res < 0 ? "Error occurred" : "OK",
 659                         res < 0 ? "MO addition or update failed" : NULL);
 660                 if (res == 0 && ret == 0)
 661                         hs20_sub_rem_complete(ctx, pps_fname);
 662                 goto out;
 663         }
 664
 665         if (use == SPP_SUBSCRIPTION_REMEDIATION &&
 666             strcasecmp(status, "Exchange complete, release TLS connection") ==
 667             0) {
 668                 if (!no_mo) {
 669                         wpa_printf(MSG_INFO, "No noMOUpdate element");
 670                         goto out;
 671                 }
 672                 wpa_printf(MSG_INFO, "Subscription remediation completed (no MO update)");
 673                 goto out;
 674         }
 675
 676         if (use == SPP_POLICY_UPDATE &&
 677             strcasecmp(status, "Update complete, request sppUpdateResponse") ==
 678             0) {
 679                 int res, ret;
 680                 wpa_printf(MSG_INFO, "Policy update received - update PPS");
 681                 res = update_pps(ctx, update, pps_fname, pps);
 682                 ret = hs20_spp_update_response(
 683                         ctx, session_id,
 684                         res < 0 ? "Error occurred" : "OK",
 685                         res < 0 ? "MO addition or update failed" : NULL);
 686                 if (res == 0 && ret == 0)
 687                         hs20_policy_update_complete(ctx, pps_fname);
 688                 goto out;
 689         }
 690
 691         if (use == SPP_SUBSCRIPTION_REGISTRATION &&
 692             strcasecmp(status, "Provisioning complete, request "
 693                        "sppUpdateResponse")  == 0) {
 694                 if (!add_mo) {
 695                         wpa_printf(MSG_INFO, "No addMO element - not sure what to do next");
 696                         goto out;
 697                 }
 698                 process_spp_user_input_response(ctx, session_id, add_mo);
 699                 node = NULL;
 700                 goto out;
 701         }
 702
 703         if (strcasecmp(status, "No update available at this time") == 0) {
 704                 wpa_printf(MSG_INFO, "No update available at this time");
 705                 goto out;
 706         }
 707
 708         if (strcasecmp(status, "OK") == 0) {
 709                 int res;
 710                 xml_node_t *ret;
 711
 712                 if (!exec) {
 713                         wpa_printf(MSG_INFO, "No exec element - not sure what to do next");
 714                         goto out;
 715                 }
 716                 res = hs20_spp_exec(ctx, exec, session_id,
 717                                     pps_fname, pps, &ret);
 718                 /* xml_node_free(ctx->xml, node); */
 719                 node = NULL;
 720                 if (res == 0 && ret)
 721                         process_spp_post_dev_data_response(ctx, use,
 722                                                            ret, pps_fname, pps);
 723                 goto out;
 724         }
 725
 726         if (strcasecmp(status, "Error occurred") == 0) {
 727                 xml_node_t *err;
 728                 char *code = NULL;
 729                 err = get_node(ctx->xml, node, "sppError");
 730                 if (err)
 731                         code = xml_node_get_attr_value(ctx->xml, err,
 732                                                        "errorCode");
 733                 wpa_printf(MSG_INFO, "Error occurred - errorCode=%s",
 734                            code ? code : "N/A");
 735                 xml_node_get_attr_value_free(ctx->xml, code);
 736                 goto out;
 737         }
 738
 739         wpa_printf(MSG_INFO,
 740                    "[hs20] Unsupported sppPostDevDataResponse sppStatus '%s'",
 741                    status);
 742 out:
 743         xml_node_get_attr_value_free(ctx->xml, status);
 744         xml_node_get_attr_value_free(ctx->xml, session_id);
 745         xml_node_free(ctx->xml, node);
 746 }
 747
 748
 749 static int spp_post_dev_data(struct hs20_osu_client *ctx,
 750                              enum spp_post_dev_data_use use,
 751                              const char *reason,
 752                              const char *pps_fname, xml_node_t *pps)
 753 {
 754         xml_node_t *payload;
 755         xml_node_t *ret_node;
 756
 757         payload = build_spp_post_dev_data(ctx, NULL, NULL, reason);
 758         if (payload == NULL)
 759                 return -1;
 760
 761         ret_node = soap_send_receive(ctx->http, payload);
 762         if (!ret_node) {
 763                 const char *err = http_get_err(ctx->http);
 764                 if (err) {
 765                         wpa_printf(MSG_INFO, "HTTP error: %s", err);
 766                         write_result(ctx, "HTTP error: %s", err);
 767                 } else {
 768                         write_summary(ctx, "Failed to send SOAP message");
 769                 }
 770                 return -1;
 771         }
 772
 773         if (hs20_spp_validate(ctx, ret_node, "sppPostDevDataResponse") < 0) {
 774                 wpa_printf(MSG_INFO, "SPP validation failed");
 775                 xml_node_free(ctx->xml, ret_node);
 776                 return -1;
 777         }
 778
 779         process_spp_post_dev_data_response(ctx, use, ret_node,
 780                                            pps_fname, pps);
 781         return 0;
 782 }
 783
 784
 785 void spp_sub_rem(struct hs20_osu_client *ctx, const char *address,
 786                  const char *pps_fname,
 787                  const char *client_cert, const char *client_key,
 788                  const char *cred_username, const char *cred_password,
 789                  xml_node_t *pps)
 790 {
 791         wpa_printf(MSG_INFO, "SPP subscription remediation");
 792         write_summary(ctx, "SPP subscription remediation");
 793
 794         os_free(ctx->server_url);
 795         ctx->server_url = os_strdup(address);
 796
 797         if (soap_init_client(ctx->http, address, ctx->ca_fname,
 798                              cred_username, cred_password, client_cert,
 799                              client_key) == 0) {
 800                 spp_post_dev_data(ctx, SPP_SUBSCRIPTION_REMEDIATION,
 801                                   "Subscription remediation", pps_fname, pps);
 802         }
 803 }
 804
 805
 806 static void hs20_policy_update_complete(struct hs20_osu_client *ctx,
 807                                         const char *pps_fname)
 808 {
 809         wpa_printf(MSG_INFO, "Policy update completed");
 810
 811         /*
 812          * Update wpa_supplicant credentials and reconnect using updated
 813          * information.
 814          */
 815         wpa_printf(MSG_INFO, "Updating wpa_supplicant credentials");
 816         cmd_set_pps(ctx, pps_fname);
 817
 818         wpa_printf(MSG_INFO, "Requesting reconnection with updated configuration");
 819         if (wpa_command(ctx->ifname, "INTERWORKING_SELECT auto") < 0)
 820                 wpa_printf(MSG_ERROR, "Failed to request wpa_supplicant to reconnect");
 821 }
 822
 823
 824 static int process_spp_exchange_complete(struct hs20_osu_client *ctx,
 825                                          xml_node_t *node)
 826 {
 827         char *status, *session_id;
 828
 829         debug_dump_node(ctx, "sppExchangeComplete", node);
 830
 831         status = get_spp_attr_value(ctx->xml, node, "sppStatus");
 832         if (status == NULL) {
 833                 wpa_printf(MSG_INFO, "No sppStatus attribute");
 834                 return -1;
 835         }
 836         write_summary(ctx, "Received sppExchangeComplete sppStatus='%s'",
 837                       status);
 838
 839         session_id = get_spp_attr_value(ctx->xml, node, "sessionID");
 840         if (session_id == NULL) {
 841                 wpa_printf(MSG_INFO, "No sessionID attribute");
 842                 xml_node_get_attr_value_free(ctx->xml, status);
 843                 return -1;
 844         }
 845
 846         wpa_printf(MSG_INFO, "[hs20] sppStatus: '%s'  sessionID: '%s'",
 847                    status, session_id);
 848         xml_node_get_attr_value_free(ctx->xml, session_id);
 849
 850         if (strcasecmp(status, "Exchange complete, release TLS connection") ==
 851             0) {
 852                 xml_node_get_attr_value_free(ctx->xml, status);
 853                 return 0;
 854         }
 855
 856         wpa_printf(MSG_INFO, "Unexpected sppStatus '%s'", status);
 857         write_summary(ctx, "Unexpected sppStatus '%s'", status);
 858         xml_node_get_attr_value_free(ctx->xml, status);
 859         return -1;
 860 }
 861
 862
 863 static xml_node_t * build_spp_update_response(struct hs20_osu_client *ctx,
 864                                               const char *session_id,
 865                                               const char *spp_status,
 866                                               const char *error_code)
 867 {
 868         xml_namespace_t *ns;
 869         xml_node_t *spp_node, *node;
 870
 871         spp_node = xml_node_create_root(ctx->xml, SPP_NS_URI, "spp", &ns,
 872                                         "sppUpdateResponse");
 873         if (spp_node == NULL)
 874                 return NULL;
 875
 876         xml_node_add_attr(ctx->xml, spp_node, ns, "sppVersion", "1.0");
 877         xml_node_add_attr(ctx->xml, spp_node, ns, "sessionID", session_id);
 878         xml_node_add_attr(ctx->xml, spp_node, ns, "sppStatus", spp_status);
 879
 880         if (error_code) {
 881                 node = xml_node_create(ctx->xml, spp_node, ns, "sppError");
 882                 if (node)
 883                         xml_node_add_attr(ctx->xml, node, NULL, "errorCode",
 884                                           error_code);
 885         }
 886
 887         return spp_node;
 888 }
 889
 890
 891 static int hs20_spp_update_response(struct hs20_osu_client *ctx,
 892                                     const char *session_id,
 893                                     const char *spp_status,
 894                                     const char *error_code)
 895 {
 896         xml_node_t *node, *ret_node;
 897         int ret;
 898
 899         write_summary(ctx, "Building sppUpdateResponse sppStatus='%s' error_code='%s'",
 900                       spp_status, error_code);
 901         node = build_spp_update_response(ctx, session_id, spp_status,
 902                                          error_code);
 903         if (node == NULL)
 904                 return -1;
 905         ret_node = soap_send_receive(ctx->http, node);
 906         if (!ret_node) {
 907                 if (soap_reinit_client(ctx->http) < 0)
 908                         return -1;
 909                 wpa_printf(MSG_INFO, "Try to finish with re-opened connection");
 910                 node = build_spp_update_response(ctx, session_id, spp_status,
 911                                                  error_code);
 912                 if (node == NULL)
 913                         return -1;
 914                 ret_node = soap_send_receive(ctx->http, node);
 915                 if (ret_node == NULL)
 916                         return -1;
 917                 wpa_printf(MSG_INFO, "Continue with new connection");
 918         }
 919
 920         if (hs20_spp_validate(ctx, ret_node, "sppExchangeComplete") < 0) {
 921                 wpa_printf(MSG_INFO, "SPP validation failed");
 922                 xml_node_free(ctx->xml, ret_node);
 923                 return -1;
 924         }
 925
 926         ret = process_spp_exchange_complete(ctx, ret_node);
 927         xml_node_free(ctx->xml, ret_node);
 928         return ret;
 929 }
 930
 931
 932 void spp_pol_upd(struct hs20_osu_client *ctx, const char *address,
 933                  const char *pps_fname,
 934                  const char *client_cert, const char *client_key,
 935                  const char *cred_username, const char *cred_password,
 936                  xml_node_t *pps)
 937 {
 938         wpa_printf(MSG_INFO, "SPP policy update");
 939         write_summary(ctx, "SPP policy update");
 940
 941         os_free(ctx->server_url);
 942         ctx->server_url = os_strdup(address);
 943
 944         if (soap_init_client(ctx->http, address, ctx->ca_fname, cred_username,
 945                              cred_password, client_cert, client_key) == 0) {
 946                 spp_post_dev_data(ctx, SPP_POLICY_UPDATE, "Policy update",
 947                                   pps_fname, pps);
 948         }
 949 }
 950
 951
 952 int cmd_prov(struct hs20_osu_client *ctx, const char *url)
 953 {
 954         unlink("Cert/est_cert.der");
 955         unlink("Cert/est_cert.pem");
 956
 957         if (url == NULL) {
 958                 wpa_printf(MSG_INFO, "Invalid prov command (missing URL)");
 959                 return -1;
 960         }
 961
 962         wpa_printf(MSG_INFO,
 963                    "Credential provisioning requested - URL: %s ca_fname: %s",
 964                    url, ctx->ca_fname ? ctx->ca_fname : "N/A");
 965
 966         os_free(ctx->server_url);
 967         ctx->server_url = os_strdup(url);
 968
 969         if (soap_init_client(ctx->http, url, ctx->ca_fname, NULL, NULL, NULL,
 970                              NULL) < 0)
 971                 return -1;
 972         spp_post_dev_data(ctx, SPP_SUBSCRIPTION_REGISTRATION,
 973                           "Subscription registration", NULL, NULL);
 974
 975         return ctx->pps_cred_set ? 0 : -1;
 976 }
 977
 978
 979 int cmd_sim_prov(struct hs20_osu_client *ctx, const char *url)
 980 {
 981         if (url == NULL) {
 982                 wpa_printf(MSG_INFO, "Invalid prov command (missing URL)");
 983                 return -1;
 984         }
 985
 986         wpa_printf(MSG_INFO, "SIM provisioning requested");
 987
 988         os_free(ctx->server_url);
 989         ctx->server_url = os_strdup(url);
 990
 991         wpa_printf(MSG_INFO, "Wait for IP address before starting SIM provisioning");
 992
 993         if (wait_ip_addr(ctx->ifname, 15) < 0) {
 994                 wpa_printf(MSG_INFO, "Could not get IP address for WLAN - try connection anyway");
 995         }
 996
 997         if (soap_init_client(ctx->http, url, ctx->ca_fname, NULL, NULL, NULL,
 998                              NULL) < 0)
 999                 return -1;
1000         spp_post_dev_data(ctx, SPP_SUBSCRIPTION_REGISTRATION,
1001                           "Subscription provisioning", NULL, NULL);
1002
1003         return ctx->pps_cred_set ? 0 : -1;
1004 }