contrib/wpa/src/ap/gas_serv.c

   1 /*
   2  * Generic advertisement service (GAS) server
   3  * Copyright (c) 2011-2012, 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
  11 #include "common.h"
  12 #include "common/ieee802_11_defs.h"
  13 #include "common/gas.h"
  14 #include "utils/eloop.h"
  15 #include "hostapd.h"
  16 #include "ap_config.h"
  17 #include "ap_drv_ops.h"
  18 #include "sta_info.h"
  19 #include "gas_serv.h"
  20
  21
  22 static struct gas_dialog_info *
  23 gas_dialog_create(struct hostapd_data *hapd, const u8 *addr, u8 dialog_token)
  24 {
  25         struct sta_info *sta;
  26         struct gas_dialog_info *dia = NULL;
  27         int i, j;
  28
  29         sta = ap_get_sta(hapd, addr);
  30         if (!sta) {
  31                 /*
  32                  * We need a STA entry to be able to maintain state for
  33                  * the GAS query.
  34                  */
  35                 wpa_printf(MSG_DEBUG, "ANQP: Add a temporary STA entry for "
  36                            "GAS query");
  37                 sta = ap_sta_add(hapd, addr);
  38                 if (!sta) {
  39                         wpa_printf(MSG_DEBUG, "Failed to add STA " MACSTR
  40                                    " for GAS query", MAC2STR(addr));
  41                         return NULL;
  42                 }
  43                 sta->flags |= WLAN_STA_GAS;
  44                 /*
  45                  * The default inactivity is 300 seconds. We don't need
  46                  * it to be that long.
  47                  */
  48                 ap_sta_session_timeout(hapd, sta, 5);
  49         }
  50
  51         if (sta->gas_dialog == NULL) {
  52                 sta->gas_dialog = os_zalloc(GAS_DIALOG_MAX *
  53                                             sizeof(struct gas_dialog_info));
  54                 if (sta->gas_dialog == NULL)
  55                         return NULL;
  56         }
  57
  58         for (i = sta->gas_dialog_next, j = 0; j < GAS_DIALOG_MAX; i++, j++) {
  59                 if (i == GAS_DIALOG_MAX)
  60                         i = 0;
  61                 if (sta->gas_dialog[i].valid)
  62                         continue;
  63                 dia = &sta->gas_dialog[i];
  64                 dia->valid = 1;
  65                 dia->index = i;
  66                 dia->dialog_token = dialog_token;
  67                 sta->gas_dialog_next = (++i == GAS_DIALOG_MAX) ? 0 : i;
  68                 return dia;
  69         }
  70
  71         wpa_msg(hapd->msg_ctx, MSG_ERROR, "ANQP: Could not create dialog for "
  72                 MACSTR " dialog_token %u. Consider increasing "
  73                 "GAS_DIALOG_MAX.", MAC2STR(addr), dialog_token);
  74
  75         return NULL;
  76 }
  77
  78
  79 struct gas_dialog_info *
  80 gas_serv_dialog_find(struct hostapd_data *hapd, const u8 *addr,
  81                      u8 dialog_token)
  82 {
  83         struct sta_info *sta;
  84         int i;
  85
  86         sta = ap_get_sta(hapd, addr);
  87         if (!sta) {
  88                 wpa_printf(MSG_DEBUG, "ANQP: could not find STA " MACSTR,
  89                            MAC2STR(addr));
  90                 return NULL;
  91         }
  92         for (i = 0; sta->gas_dialog && i < GAS_DIALOG_MAX; i++) {
  93                 if (sta->gas_dialog[i].dialog_token != dialog_token ||
  94                     !sta->gas_dialog[i].valid)
  95                         continue;
  96                 return &sta->gas_dialog[i];
  97         }
  98         wpa_printf(MSG_DEBUG, "ANQP: Could not find dialog for "
  99                    MACSTR " dialog_token %u", MAC2STR(addr), dialog_token);
 100         return NULL;
 101 }
 102
 103
 104 void gas_serv_dialog_clear(struct gas_dialog_info *dia)
 105 {
 106         wpabuf_free(dia->sd_resp);
 107         os_memset(dia, 0, sizeof(*dia));
 108 }
 109
 110
 111 static void gas_serv_free_dialogs(struct hostapd_data *hapd,
 112                                   const u8 *sta_addr)
 113 {
 114         struct sta_info *sta;
 115         int i;
 116
 117         sta = ap_get_sta(hapd, sta_addr);
 118         if (sta == NULL || sta->gas_dialog == NULL)
 119                 return;
 120
 121         for (i = 0; i < GAS_DIALOG_MAX; i++) {
 122                 if (sta->gas_dialog[i].valid)
 123                         return;
 124         }
 125
 126         os_free(sta->gas_dialog);
 127         sta->gas_dialog = NULL;
 128 }
 129
 130
 131 #ifdef CONFIG_HS20
 132 static void anqp_add_hs_capab_list(struct hostapd_data *hapd,
 133                                    struct wpabuf *buf)
 134 {
 135         u8 *len;
 136
 137         len = gas_anqp_add_element(buf, ANQP_VENDOR_SPECIFIC);
 138         wpabuf_put_be24(buf, OUI_WFA);
 139         wpabuf_put_u8(buf, HS20_ANQP_OUI_TYPE);
 140         wpabuf_put_u8(buf, HS20_STYPE_CAPABILITY_LIST);
 141         wpabuf_put_u8(buf, 0); /* Reserved */
 142         wpabuf_put_u8(buf, HS20_STYPE_CAPABILITY_LIST);
 143         if (hapd->conf->hs20_oper_friendly_name)
 144                 wpabuf_put_u8(buf, HS20_STYPE_OPERATOR_FRIENDLY_NAME);
 145         if (hapd->conf->hs20_wan_metrics)
 146                 wpabuf_put_u8(buf, HS20_STYPE_WAN_METRICS);
 147         if (hapd->conf->hs20_connection_capability)
 148                 wpabuf_put_u8(buf, HS20_STYPE_CONNECTION_CAPABILITY);
 149         if (hapd->conf->nai_realm_data)
 150                 wpabuf_put_u8(buf, HS20_STYPE_NAI_HOME_REALM_QUERY);
 151         if (hapd->conf->hs20_operating_class)
 152                 wpabuf_put_u8(buf, HS20_STYPE_OPERATING_CLASS);
 153         gas_anqp_set_element_len(buf, len);
 154 }
 155 #endif /* CONFIG_HS20 */
 156
 157
 158 static void anqp_add_capab_list(struct hostapd_data *hapd,
 159                                 struct wpabuf *buf)
 160 {
 161         u8 *len;
 162
 163         len = gas_anqp_add_element(buf, ANQP_CAPABILITY_LIST);
 164         wpabuf_put_le16(buf, ANQP_CAPABILITY_LIST);
 165         if (hapd->conf->venue_name)
 166                 wpabuf_put_le16(buf, ANQP_VENUE_NAME);
 167         if (hapd->conf->network_auth_type)
 168                 wpabuf_put_le16(buf, ANQP_NETWORK_AUTH_TYPE);
 169         if (hapd->conf->roaming_consortium)
 170                 wpabuf_put_le16(buf, ANQP_ROAMING_CONSORTIUM);
 171         if (hapd->conf->ipaddr_type_configured)
 172                 wpabuf_put_le16(buf, ANQP_IP_ADDR_TYPE_AVAILABILITY);
 173         if (hapd->conf->nai_realm_data)
 174                 wpabuf_put_le16(buf, ANQP_NAI_REALM);
 175         if (hapd->conf->anqp_3gpp_cell_net)
 176                 wpabuf_put_le16(buf, ANQP_3GPP_CELLULAR_NETWORK);
 177         if (hapd->conf->domain_name)
 178                 wpabuf_put_le16(buf, ANQP_DOMAIN_NAME);
 179 #ifdef CONFIG_HS20
 180         anqp_add_hs_capab_list(hapd, buf);
 181 #endif /* CONFIG_HS20 */
 182         gas_anqp_set_element_len(buf, len);
 183 }
 184
 185
 186 static void anqp_add_venue_name(struct hostapd_data *hapd, struct wpabuf *buf)
 187 {
 188         if (hapd->conf->venue_name) {
 189                 u8 *len;
 190                 unsigned int i;
 191                 len = gas_anqp_add_element(buf, ANQP_VENUE_NAME);
 192                 wpabuf_put_u8(buf, hapd->conf->venue_group);
 193                 wpabuf_put_u8(buf, hapd->conf->venue_type);
 194                 for (i = 0; i < hapd->conf->venue_name_count; i++) {
 195                         struct hostapd_lang_string *vn;
 196                         vn = &hapd->conf->venue_name[i];
 197                         wpabuf_put_u8(buf, 3 + vn->name_len);
 198                         wpabuf_put_data(buf, vn->lang, 3);
 199                         wpabuf_put_data(buf, vn->name, vn->name_len);
 200                 }
 201                 gas_anqp_set_element_len(buf, len);
 202         }
 203 }
 204
 205
 206 static void anqp_add_network_auth_type(struct hostapd_data *hapd,
 207                                        struct wpabuf *buf)
 208 {
 209         if (hapd->conf->network_auth_type) {
 210                 wpabuf_put_le16(buf, ANQP_NETWORK_AUTH_TYPE);
 211                 wpabuf_put_le16(buf, hapd->conf->network_auth_type_len);
 212                 wpabuf_put_data(buf, hapd->conf->network_auth_type,
 213                                 hapd->conf->network_auth_type_len);
 214         }
 215 }
 216
 217
 218 static void anqp_add_roaming_consortium(struct hostapd_data *hapd,
 219                                         struct wpabuf *buf)
 220 {
 221         unsigned int i;
 222         u8 *len;
 223
 224         len = gas_anqp_add_element(buf, ANQP_ROAMING_CONSORTIUM);
 225         for (i = 0; i < hapd->conf->roaming_consortium_count; i++) {
 226                 struct hostapd_roaming_consortium *rc;
 227                 rc = &hapd->conf->roaming_consortium[i];
 228                 wpabuf_put_u8(buf, rc->len);
 229                 wpabuf_put_data(buf, rc->oi, rc->len);
 230         }
 231         gas_anqp_set_element_len(buf, len);
 232 }
 233
 234
 235 static void anqp_add_ip_addr_type_availability(struct hostapd_data *hapd,
 236                                                struct wpabuf *buf)
 237 {
 238         if (hapd->conf->ipaddr_type_configured) {
 239                 wpabuf_put_le16(buf, ANQP_IP_ADDR_TYPE_AVAILABILITY);
 240                 wpabuf_put_le16(buf, 1);
 241                 wpabuf_put_u8(buf, hapd->conf->ipaddr_type_availability);
 242         }
 243 }
 244
 245
 246 static void anqp_add_nai_realm_eap(struct wpabuf *buf,
 247                                    struct hostapd_nai_realm_data *realm)
 248 {
 249         unsigned int i, j;
 250
 251         wpabuf_put_u8(buf, realm->eap_method_count);
 252
 253         for (i = 0; i < realm->eap_method_count; i++) {
 254                 struct hostapd_nai_realm_eap *eap = &realm->eap_method[i];
 255                 wpabuf_put_u8(buf, 2 + (3 * eap->num_auths));
 256                 wpabuf_put_u8(buf, eap->eap_method);
 257                 wpabuf_put_u8(buf, eap->num_auths);
 258                 for (j = 0; j < eap->num_auths; j++) {
 259                         wpabuf_put_u8(buf, eap->auth_id[j]);
 260                         wpabuf_put_u8(buf, 1);
 261                         wpabuf_put_u8(buf, eap->auth_val[j]);
 262                 }
 263         }
 264 }
 265
 266
 267 static void anqp_add_nai_realm_data(struct wpabuf *buf,
 268                                     struct hostapd_nai_realm_data *realm,
 269                                     unsigned int realm_idx)
 270 {
 271         u8 *realm_data_len;
 272
 273         wpa_printf(MSG_DEBUG, "realm=%s, len=%d", realm->realm[realm_idx],
 274                    (int) os_strlen(realm->realm[realm_idx]));
 275         realm_data_len = wpabuf_put(buf, 2);
 276         wpabuf_put_u8(buf, realm->encoding);
 277         wpabuf_put_u8(buf, os_strlen(realm->realm[realm_idx]));
 278         wpabuf_put_str(buf, realm->realm[realm_idx]);
 279         anqp_add_nai_realm_eap(buf, realm);
 280         gas_anqp_set_element_len(buf, realm_data_len);
 281 }
 282
 283
 284 static int hs20_add_nai_home_realm_matches(struct hostapd_data *hapd,
 285                                            struct wpabuf *buf,
 286                                            const u8 *home_realm,
 287                                            size_t home_realm_len)
 288 {
 289         unsigned int i, j, k;
 290         u8 num_realms, num_matching = 0, encoding, realm_len, *realm_list_len;
 291         struct hostapd_nai_realm_data *realm;
 292         const u8 *pos, *realm_name, *end;
 293         struct {
 294                 unsigned int realm_data_idx;
 295                 unsigned int realm_idx;
 296         } matches[10];
 297
 298         pos = home_realm;
 299         end = pos + home_realm_len;
 300         if (pos + 1 > end) {
 301                 wpa_hexdump(MSG_DEBUG, "Too short NAI Home Realm Query",
 302                             home_realm, home_realm_len);
 303                 return -1;
 304         }
 305         num_realms = *pos++;
 306
 307         for (i = 0; i < num_realms && num_matching < 10; i++) {
 308                 if (pos + 2 > end) {
 309                         wpa_hexdump(MSG_DEBUG,
 310                                     "Truncated NAI Home Realm Query",
 311                                     home_realm, home_realm_len);
 312                         return -1;
 313                 }
 314                 encoding = *pos++;
 315                 realm_len = *pos++;
 316                 if (pos + realm_len > end) {
 317                         wpa_hexdump(MSG_DEBUG,
 318                                     "Truncated NAI Home Realm Query",
 319                                     home_realm, home_realm_len);
 320                         return -1;
 321                 }
 322                 realm_name = pos;
 323                 for (j = 0; j < hapd->conf->nai_realm_count &&
 324                              num_matching < 10; j++) {
 325                         const u8 *rpos, *rend;
 326                         realm = &hapd->conf->nai_realm_data[j];
 327                         if (encoding != realm->encoding)
 328                                 continue;
 329
 330                         rpos = realm_name;
 331                         while (rpos < realm_name + realm_len &&
 332                                num_matching < 10) {
 333                                 for (rend = rpos;
 334                                      rend < realm_name + realm_len; rend++) {
 335                                         if (*rend == ';')
 336                                                 break;
 337                                 }
 338                                 for (k = 0; k < MAX_NAI_REALMS &&
 339                                              realm->realm[k] &&
 340                                              num_matching < 10; k++) {
 341                                         if ((int) os_strlen(realm->realm[k]) !=
 342                                             rend - rpos ||
 343                                             os_strncmp((char *) rpos,
 344                                                        realm->realm[k],
 345                                                        rend - rpos) != 0)
 346                                                 continue;
 347                                         matches[num_matching].realm_data_idx =
 348                                                 j;
 349                                         matches[num_matching].realm_idx = k;
 350                                         num_matching++;
 351                                 }
 352                                 rpos = rend + 1;
 353                         }
 354                 }
 355                 pos += realm_len;
 356         }
 357
 358         realm_list_len = gas_anqp_add_element(buf, ANQP_NAI_REALM);
 359         wpabuf_put_le16(buf, num_matching);
 360
 361         /*
 362          * There are two ways to format. 1. each realm in a NAI Realm Data unit
 363          * 2. all realms that share the same EAP methods in a NAI Realm Data
 364          * unit. The first format is likely to be bigger in size than the
 365          * second, but may be easier to parse and process by the receiver.
 366          */
 367         for (i = 0; i < num_matching; i++) {
 368                 wpa_printf(MSG_DEBUG, "realm_idx %d, realm_data_idx %d",
 369                            matches[i].realm_data_idx, matches[i].realm_idx);
 370                 realm = &hapd->conf->nai_realm_data[matches[i].realm_data_idx];
 371                 anqp_add_nai_realm_data(buf, realm, matches[i].realm_idx);
 372         }
 373         gas_anqp_set_element_len(buf, realm_list_len);
 374         return 0;
 375 }
 376
 377
 378 static void anqp_add_nai_realm(struct hostapd_data *hapd, struct wpabuf *buf,
 379                                const u8 *home_realm, size_t home_realm_len,
 380                                int nai_realm, int nai_home_realm)
 381 {
 382         if (nai_realm && hapd->conf->nai_realm_data) {
 383                 u8 *len;
 384                 unsigned int i, j;
 385                 len = gas_anqp_add_element(buf, ANQP_NAI_REALM);
 386                 wpabuf_put_le16(buf, hapd->conf->nai_realm_count);
 387                 for (i = 0; i < hapd->conf->nai_realm_count; i++) {
 388                         u8 *realm_data_len, *realm_len;
 389                         struct hostapd_nai_realm_data *realm;
 390
 391                         realm = &hapd->conf->nai_realm_data[i];
 392                         realm_data_len = wpabuf_put(buf, 2);
 393                         wpabuf_put_u8(buf, realm->encoding);
 394                         realm_len = wpabuf_put(buf, 1);
 395                         for (j = 0; realm->realm[j]; j++) {
 396                                 if (j > 0)
 397                                         wpabuf_put_u8(buf, ';');
 398                                 wpabuf_put_str(buf, realm->realm[j]);
 399                         }
 400                         *realm_len = (u8 *) wpabuf_put(buf, 0) - realm_len - 1;
 401                         anqp_add_nai_realm_eap(buf, realm);
 402                         gas_anqp_set_element_len(buf, realm_data_len);
 403                 }
 404                 gas_anqp_set_element_len(buf, len);
 405         } else if (nai_home_realm && hapd->conf->nai_realm_data) {
 406                 hs20_add_nai_home_realm_matches(hapd, buf, home_realm,
 407                                                 home_realm_len);
 408         }
 409 }
 410
 411
 412 static void anqp_add_3gpp_cellular_network(struct hostapd_data *hapd,
 413                                            struct wpabuf *buf)
 414 {
 415         if (hapd->conf->anqp_3gpp_cell_net) {
 416                 wpabuf_put_le16(buf, ANQP_3GPP_CELLULAR_NETWORK);
 417                 wpabuf_put_le16(buf,
 418                                 hapd->conf->anqp_3gpp_cell_net_len);
 419                 wpabuf_put_data(buf, hapd->conf->anqp_3gpp_cell_net,
 420                                 hapd->conf->anqp_3gpp_cell_net_len);
 421         }
 422 }
 423
 424
 425 static void anqp_add_domain_name(struct hostapd_data *hapd, struct wpabuf *buf)
 426 {
 427         if (hapd->conf->domain_name) {
 428                 wpabuf_put_le16(buf, ANQP_DOMAIN_NAME);
 429                 wpabuf_put_le16(buf, hapd->conf->domain_name_len);
 430                 wpabuf_put_data(buf, hapd->conf->domain_name,
 431                                 hapd->conf->domain_name_len);
 432         }
 433 }
 434
 435
 436 #ifdef CONFIG_HS20
 437
 438 static void anqp_add_operator_friendly_name(struct hostapd_data *hapd,
 439                                             struct wpabuf *buf)
 440 {
 441         if (hapd->conf->hs20_oper_friendly_name) {
 442                 u8 *len;
 443                 unsigned int i;
 444                 len = gas_anqp_add_element(buf, ANQP_VENDOR_SPECIFIC);
 445                 wpabuf_put_be24(buf, OUI_WFA);
 446                 wpabuf_put_u8(buf, HS20_ANQP_OUI_TYPE);
 447                 wpabuf_put_u8(buf, HS20_STYPE_OPERATOR_FRIENDLY_NAME);
 448                 wpabuf_put_u8(buf, 0); /* Reserved */
 449                 for (i = 0; i < hapd->conf->hs20_oper_friendly_name_count; i++)
 450                 {
 451                         struct hostapd_lang_string *vn;
 452                         vn = &hapd->conf->hs20_oper_friendly_name[i];
 453                         wpabuf_put_u8(buf, 3 + vn->name_len);
 454                         wpabuf_put_data(buf, vn->lang, 3);
 455                         wpabuf_put_data(buf, vn->name, vn->name_len);
 456                 }
 457                 gas_anqp_set_element_len(buf, len);
 458         }
 459 }
 460
 461
 462 static void anqp_add_wan_metrics(struct hostapd_data *hapd,
 463                                  struct wpabuf *buf)
 464 {
 465         if (hapd->conf->hs20_wan_metrics) {
 466                 u8 *len = gas_anqp_add_element(buf, ANQP_VENDOR_SPECIFIC);
 467                 wpabuf_put_be24(buf, OUI_WFA);
 468                 wpabuf_put_u8(buf, HS20_ANQP_OUI_TYPE);
 469                 wpabuf_put_u8(buf, HS20_STYPE_WAN_METRICS);
 470                 wpabuf_put_u8(buf, 0); /* Reserved */
 471                 wpabuf_put_data(buf, hapd->conf->hs20_wan_metrics, 13);
 472                 gas_anqp_set_element_len(buf, len);
 473         }
 474 }
 475
 476
 477 static void anqp_add_connection_capability(struct hostapd_data *hapd,
 478                                            struct wpabuf *buf)
 479 {
 480         if (hapd->conf->hs20_connection_capability) {
 481                 u8 *len = gas_anqp_add_element(buf, ANQP_VENDOR_SPECIFIC);
 482                 wpabuf_put_be24(buf, OUI_WFA);
 483                 wpabuf_put_u8(buf, HS20_ANQP_OUI_TYPE);
 484                 wpabuf_put_u8(buf, HS20_STYPE_CONNECTION_CAPABILITY);
 485                 wpabuf_put_u8(buf, 0); /* Reserved */
 486                 wpabuf_put_data(buf, hapd->conf->hs20_connection_capability,
 487                                 hapd->conf->hs20_connection_capability_len);
 488                 gas_anqp_set_element_len(buf, len);
 489         }
 490 }
 491
 492
 493 static void anqp_add_operating_class(struct hostapd_data *hapd,
 494                                      struct wpabuf *buf)
 495 {
 496         if (hapd->conf->hs20_operating_class) {
 497                 u8 *len = gas_anqp_add_element(buf, ANQP_VENDOR_SPECIFIC);
 498                 wpabuf_put_be24(buf, OUI_WFA);
 499                 wpabuf_put_u8(buf, HS20_ANQP_OUI_TYPE);
 500                 wpabuf_put_u8(buf, HS20_STYPE_OPERATING_CLASS);
 501                 wpabuf_put_u8(buf, 0); /* Reserved */
 502                 wpabuf_put_data(buf, hapd->conf->hs20_operating_class,
 503                                 hapd->conf->hs20_operating_class_len);
 504                 gas_anqp_set_element_len(buf, len);
 505         }
 506 }
 507
 508 #endif /* CONFIG_HS20 */
 509
 510
 511 static struct wpabuf *
 512 gas_serv_build_gas_resp_payload(struct hostapd_data *hapd,
 513                                 unsigned int request,
 514                                 struct gas_dialog_info *di,
 515                                 const u8 *home_realm, size_t home_realm_len)
 516 {
 517         struct wpabuf *buf;
 518
 519         buf = wpabuf_alloc(1400);
 520         if (buf == NULL)
 521                 return NULL;
 522
 523         if (request & ANQP_REQ_CAPABILITY_LIST)
 524                 anqp_add_capab_list(hapd, buf);
 525         if (request & ANQP_REQ_VENUE_NAME)
 526                 anqp_add_venue_name(hapd, buf);
 527         if (request & ANQP_REQ_NETWORK_AUTH_TYPE)
 528                 anqp_add_network_auth_type(hapd, buf);
 529         if (request & ANQP_REQ_ROAMING_CONSORTIUM)
 530                 anqp_add_roaming_consortium(hapd, buf);
 531         if (request & ANQP_REQ_IP_ADDR_TYPE_AVAILABILITY)
 532                 anqp_add_ip_addr_type_availability(hapd, buf);
 533         if (request & (ANQP_REQ_NAI_REALM | ANQP_REQ_NAI_HOME_REALM))
 534                 anqp_add_nai_realm(hapd, buf, home_realm, home_realm_len,
 535                                    request & ANQP_REQ_NAI_REALM,
 536                                    request & ANQP_REQ_NAI_HOME_REALM);
 537         if (request & ANQP_REQ_3GPP_CELLULAR_NETWORK)
 538                 anqp_add_3gpp_cellular_network(hapd, buf);
 539         if (request & ANQP_REQ_DOMAIN_NAME)
 540                 anqp_add_domain_name(hapd, buf);
 541
 542 #ifdef CONFIG_HS20
 543         if (request & ANQP_REQ_HS_CAPABILITY_LIST)
 544                 anqp_add_hs_capab_list(hapd, buf);
 545         if (request & ANQP_REQ_OPERATOR_FRIENDLY_NAME)
 546                 anqp_add_operator_friendly_name(hapd, buf);
 547         if (request & ANQP_REQ_WAN_METRICS)
 548                 anqp_add_wan_metrics(hapd, buf);
 549         if (request & ANQP_REQ_CONNECTION_CAPABILITY)
 550                 anqp_add_connection_capability(hapd, buf);
 551         if (request & ANQP_REQ_OPERATING_CLASS)
 552                 anqp_add_operating_class(hapd, buf);
 553 #endif /* CONFIG_HS20 */
 554
 555         return buf;
 556 }
 557
 558
 559 static void gas_serv_clear_cached_ies(void *eloop_data, void *user_ctx)
 560 {
 561         struct gas_dialog_info *dia = eloop_data;
 562
 563         wpa_printf(MSG_DEBUG, "GAS: Timeout triggered, clearing dialog for "
 564                    "dialog token %d", dia->dialog_token);
 565
 566         gas_serv_dialog_clear(dia);
 567 }
 568
 569
 570 struct anqp_query_info {
 571         unsigned int request;
 572         unsigned int remote_request;
 573         const u8 *home_realm_query;
 574         size_t home_realm_query_len;
 575         u16 remote_delay;
 576 };
 577
 578
 579 static void set_anqp_req(unsigned int bit, const char *name, int local,
 580                          unsigned int remote, u16 remote_delay,
 581                          struct anqp_query_info *qi)
 582 {
 583         qi->request |= bit;
 584         if (local) {
 585                 wpa_printf(MSG_DEBUG, "ANQP: %s (local)", name);
 586         } else if (bit & remote) {
 587                 wpa_printf(MSG_DEBUG, "ANQP: %s (remote)", name);
 588                 qi->remote_request |= bit;
 589                 if (remote_delay > qi->remote_delay)
 590                         qi->remote_delay = remote_delay;
 591         } else {
 592                 wpa_printf(MSG_DEBUG, "ANQP: %s not available", name);
 593         }
 594 }
 595
 596
 597 static void rx_anqp_query_list_id(struct hostapd_data *hapd, u16 info_id,
 598                                   struct anqp_query_info *qi)
 599 {
 600         switch (info_id) {
 601         case ANQP_CAPABILITY_LIST:
 602                 set_anqp_req(ANQP_REQ_CAPABILITY_LIST, "Capability List", 1, 0,
 603                              0, qi);
 604                 break;
 605         case ANQP_VENUE_NAME:
 606                 set_anqp_req(ANQP_REQ_VENUE_NAME, "Venue Name",
 607                              hapd->conf->venue_name != NULL, 0, 0, qi);
 608                 break;
 609         case ANQP_NETWORK_AUTH_TYPE:
 610                 set_anqp_req(ANQP_REQ_NETWORK_AUTH_TYPE, "Network Auth Type",
 611                              hapd->conf->network_auth_type != NULL,
 612                              0, 0, qi);
 613                 break;
 614         case ANQP_ROAMING_CONSORTIUM:
 615                 set_anqp_req(ANQP_REQ_ROAMING_CONSORTIUM, "Roaming Consortium",
 616                              hapd->conf->roaming_consortium != NULL, 0, 0, qi);
 617                 break;
 618         case ANQP_IP_ADDR_TYPE_AVAILABILITY:
 619                 set_anqp_req(ANQP_REQ_IP_ADDR_TYPE_AVAILABILITY,
 620                              "IP Addr Type Availability",
 621                              hapd->conf->ipaddr_type_configured,
 622                              0, 0, qi);
 623                 break;
 624         case ANQP_NAI_REALM:
 625                 set_anqp_req(ANQP_REQ_NAI_REALM, "NAI Realm",
 626                              hapd->conf->nai_realm_data != NULL,
 627                              0, 0, qi);
 628                 break;
 629         case ANQP_3GPP_CELLULAR_NETWORK:
 630                 set_anqp_req(ANQP_REQ_3GPP_CELLULAR_NETWORK,
 631                              "3GPP Cellular Network",
 632                              hapd->conf->anqp_3gpp_cell_net != NULL,
 633                              0, 0, qi);
 634                 break;
 635         case ANQP_DOMAIN_NAME:
 636                 set_anqp_req(ANQP_REQ_DOMAIN_NAME, "Domain Name",
 637                              hapd->conf->domain_name != NULL,
 638                              0, 0, qi);
 639                 break;
 640         default:
 641                 wpa_printf(MSG_DEBUG, "ANQP: Unsupported Info Id %u",
 642                            info_id);
 643                 break;
 644         }
 645 }
 646
 647
 648 static void rx_anqp_query_list(struct hostapd_data *hapd,
 649                                const u8 *pos, const u8 *end,
 650                                struct anqp_query_info *qi)
 651 {
 652         wpa_printf(MSG_DEBUG, "ANQP: %u Info IDs requested in Query list",
 653                    (unsigned int) (end - pos) / 2);
 654
 655         while (pos + 2 <= end) {
 656                 rx_anqp_query_list_id(hapd, WPA_GET_LE16(pos), qi);
 657                 pos += 2;
 658         }
 659 }
 660
 661
 662 #ifdef CONFIG_HS20
 663
 664 static void rx_anqp_hs_query_list(struct hostapd_data *hapd, u8 subtype,
 665                                   struct anqp_query_info *qi)
 666 {
 667         switch (subtype) {
 668         case HS20_STYPE_CAPABILITY_LIST:
 669                 set_anqp_req(ANQP_REQ_HS_CAPABILITY_LIST, "HS Capability List",
 670                              1, 0, 0, qi);
 671                 break;
 672         case HS20_STYPE_OPERATOR_FRIENDLY_NAME:
 673                 set_anqp_req(ANQP_REQ_OPERATOR_FRIENDLY_NAME,
 674                              "Operator Friendly Name",
 675                              hapd->conf->hs20_oper_friendly_name != NULL,
 676                              0, 0, qi);
 677                 break;
 678         case HS20_STYPE_WAN_METRICS:
 679                 set_anqp_req(ANQP_REQ_WAN_METRICS, "WAN Metrics",
 680                              hapd->conf->hs20_wan_metrics != NULL,
 681                              0, 0, qi);
 682                 break;
 683         case HS20_STYPE_CONNECTION_CAPABILITY:
 684                 set_anqp_req(ANQP_REQ_CONNECTION_CAPABILITY,
 685                              "Connection Capability",
 686                              hapd->conf->hs20_connection_capability != NULL,
 687                              0, 0, qi);
 688                 break;
 689         case HS20_STYPE_OPERATING_CLASS:
 690                 set_anqp_req(ANQP_REQ_OPERATING_CLASS, "Operating Class",
 691                              hapd->conf->hs20_operating_class != NULL,
 692                              0, 0, qi);
 693                 break;
 694         default:
 695                 wpa_printf(MSG_DEBUG, "ANQP: Unsupported HS 2.0 subtype %u",
 696                            subtype);
 697                 break;
 698         }
 699 }
 700
 701
 702 static void rx_anqp_hs_nai_home_realm(struct hostapd_data *hapd,
 703                                       const u8 *pos, const u8 *end,
 704                                       struct anqp_query_info *qi)
 705 {
 706         qi->request |= ANQP_REQ_NAI_HOME_REALM;
 707         qi->home_realm_query = pos;
 708         qi->home_realm_query_len = end - pos;
 709         if (hapd->conf->nai_realm_data != NULL) {
 710                 wpa_printf(MSG_DEBUG, "ANQP: HS 2.0 NAI Home Realm Query "
 711                            "(local)");
 712         } else {
 713                 wpa_printf(MSG_DEBUG, "ANQP: HS 2.0 NAI Home Realm Query not "
 714                            "available");
 715         }
 716 }
 717
 718
 719 static void rx_anqp_vendor_specific(struct hostapd_data *hapd,
 720                                     const u8 *pos, const u8 *end,
 721                                     struct anqp_query_info *qi)
 722 {
 723         u32 oui;
 724         u8 subtype;
 725
 726         if (pos + 4 > end) {
 727                 wpa_printf(MSG_DEBUG, "ANQP: Too short vendor specific ANQP "
 728                            "Query element");
 729                 return;
 730         }
 731
 732         oui = WPA_GET_BE24(pos);
 733         pos += 3;
 734         if (oui != OUI_WFA) {
 735                 wpa_printf(MSG_DEBUG, "ANQP: Unsupported vendor OUI %06x",
 736                            oui);
 737                 return;
 738         }
 739
 740         if (*pos != HS20_ANQP_OUI_TYPE) {
 741                 wpa_printf(MSG_DEBUG, "ANQP: Unsupported WFA vendor type %u",
 742                            *pos);
 743                 return;
 744         }
 745         pos++;
 746
 747         if (pos + 1 >= end)
 748                 return;
 749
 750         subtype = *pos++;
 751         pos++; /* Reserved */
 752         switch (subtype) {
 753         case HS20_STYPE_QUERY_LIST:
 754                 wpa_printf(MSG_DEBUG, "ANQP: HS 2.0 Query List");
 755                 while (pos < end) {
 756                         rx_anqp_hs_query_list(hapd, *pos, qi);
 757                         pos++;
 758                 }
 759                 break;
 760         case HS20_STYPE_NAI_HOME_REALM_QUERY:
 761                 rx_anqp_hs_nai_home_realm(hapd, pos, end, qi);
 762                 break;
 763         default:
 764                 wpa_printf(MSG_DEBUG, "ANQP: Unsupported HS 2.0 query subtype "
 765                            "%u", subtype);
 766                 break;
 767         }
 768 }
 769
 770 #endif /* CONFIG_HS20 */
 771
 772
 773 static void gas_serv_req_local_processing(struct hostapd_data *hapd,
 774                                           const u8 *sa, u8 dialog_token,
 775                                           struct anqp_query_info *qi)
 776 {
 777         struct wpabuf *buf, *tx_buf;
 778
 779         buf = gas_serv_build_gas_resp_payload(hapd, qi->request, NULL,
 780                                               qi->home_realm_query,
 781                                               qi->home_realm_query_len);
 782         wpa_hexdump_buf(MSG_MSGDUMP, "ANQP: Locally generated ANQP responses",
 783                         buf);
 784         if (!buf)
 785                 return;
 786
 787         if (wpabuf_len(buf) > hapd->gas_frag_limit ||
 788             hapd->conf->gas_comeback_delay) {
 789                 struct gas_dialog_info *di;
 790                 u16 comeback_delay = 1;
 791
 792                 if (hapd->conf->gas_comeback_delay) {
 793                         /* Testing - allow overriding of the delay value */
 794                         comeback_delay = hapd->conf->gas_comeback_delay;
 795                 }
 796
 797                 wpa_printf(MSG_DEBUG, "ANQP: Too long response to fit in "
 798                            "initial response - use GAS comeback");
 799                 di = gas_dialog_create(hapd, sa, dialog_token);
 800                 if (!di) {
 801                         wpa_printf(MSG_INFO, "ANQP: Could not create dialog "
 802                                    "for " MACSTR " (dialog token %u)",
 803                                    MAC2STR(sa), dialog_token);
 804                         wpabuf_free(buf);
 805                         return;
 806                 }
 807                 di->sd_resp = buf;
 808                 di->sd_resp_pos = 0;
 809                 tx_buf = gas_anqp_build_initial_resp_buf(
 810                         dialog_token, WLAN_STATUS_SUCCESS, comeback_delay,
 811                         NULL);
 812         } else {
 813                 wpa_printf(MSG_DEBUG, "ANQP: Initial response (no comeback)");
 814                 tx_buf = gas_anqp_build_initial_resp_buf(
 815                         dialog_token, WLAN_STATUS_SUCCESS, 0, buf);
 816                 wpabuf_free(buf);
 817         }
 818         if (!tx_buf)
 819                 return;
 820
 821         hostapd_drv_send_action(hapd, hapd->iface->freq, 0, sa,
 822                                 wpabuf_head(tx_buf), wpabuf_len(tx_buf));
 823         wpabuf_free(tx_buf);
 824 }
 825
 826
 827 static void gas_serv_rx_gas_initial_req(struct hostapd_data *hapd,
 828                                         const u8 *sa,
 829                                         const u8 *data, size_t len)
 830 {
 831         const u8 *pos = data;
 832         const u8 *end = data + len;
 833         const u8 *next;
 834         u8 dialog_token;
 835         u16 slen;
 836         struct anqp_query_info qi;
 837         const u8 *adv_proto;
 838
 839         if (len < 1 + 2)
 840                 return;
 841
 842         os_memset(&qi, 0, sizeof(qi));
 843
 844         dialog_token = *pos++;
 845         wpa_msg(hapd->msg_ctx, MSG_DEBUG,
 846                 "GAS: GAS Initial Request from " MACSTR " (dialog token %u) ",
 847                 MAC2STR(sa), dialog_token);
 848
 849         if (*pos != WLAN_EID_ADV_PROTO) {
 850                 wpa_msg(hapd->msg_ctx, MSG_DEBUG,
 851                         "GAS: Unexpected IE in GAS Initial Request: %u", *pos);
 852                 return;
 853         }
 854         adv_proto = pos++;
 855
 856         slen = *pos++;
 857         next = pos + slen;
 858         if (next > end || slen < 2) {
 859                 wpa_msg(hapd->msg_ctx, MSG_DEBUG,
 860                         "GAS: Invalid IE in GAS Initial Request");
 861                 return;
 862         }
 863         pos++; /* skip QueryRespLenLimit and PAME-BI */
 864
 865         if (*pos != ACCESS_NETWORK_QUERY_PROTOCOL) {
 866                 struct wpabuf *buf;
 867                 wpa_msg(hapd->msg_ctx, MSG_DEBUG,
 868                         "GAS: Unsupported GAS advertisement protocol id %u",
 869                         *pos);
 870                 if (sa[0] & 0x01)
 871                         return; /* Invalid source address - drop silently */
 872                 buf = gas_build_initial_resp(
 873                         dialog_token, WLAN_STATUS_GAS_ADV_PROTO_NOT_SUPPORTED,
 874                         0, 2 + slen + 2);
 875                 if (buf == NULL)
 876                         return;
 877                 wpabuf_put_data(buf, adv_proto, 2 + slen);
 878                 wpabuf_put_le16(buf, 0); /* Query Response Length */
 879                 hostapd_drv_send_action(hapd, hapd->iface->freq, 0, sa,
 880                                         wpabuf_head(buf), wpabuf_len(buf));
 881                 wpabuf_free(buf);
 882                 return;
 883         }
 884
 885         pos = next;
 886         /* Query Request */
 887         if (pos + 2 > end)
 888                 return;
 889         slen = WPA_GET_LE16(pos);
 890         pos += 2;
 891         if (pos + slen > end)
 892                 return;
 893         end = pos + slen;
 894
 895         /* ANQP Query Request */
 896         while (pos < end) {
 897                 u16 info_id, elen;
 898
 899                 if (pos + 4 > end)
 900                         return;
 901
 902                 info_id = WPA_GET_LE16(pos);
 903                 pos += 2;
 904                 elen = WPA_GET_LE16(pos);
 905                 pos += 2;
 906
 907                 if (pos + elen > end) {
 908                         wpa_printf(MSG_DEBUG, "ANQP: Invalid Query Request");
 909                         return;
 910                 }
 911
 912                 switch (info_id) {
 913                 case ANQP_QUERY_LIST:
 914                         rx_anqp_query_list(hapd, pos, pos + elen, &qi);
 915                         break;
 916 #ifdef CONFIG_HS20
 917                 case ANQP_VENDOR_SPECIFIC:
 918                         rx_anqp_vendor_specific(hapd, pos, pos + elen, &qi);
 919                         break;
 920 #endif /* CONFIG_HS20 */
 921                 default:
 922                         wpa_printf(MSG_DEBUG, "ANQP: Unsupported Query "
 923                                    "Request element %u", info_id);
 924                         break;
 925                 }
 926
 927                 pos += elen;
 928         }
 929
 930         gas_serv_req_local_processing(hapd, sa, dialog_token, &qi);
 931 }
 932
 933
 934 void gas_serv_tx_gas_response(struct hostapd_data *hapd, const u8 *dst,
 935                               struct gas_dialog_info *dialog)
 936 {
 937         struct wpabuf *buf, *tx_buf;
 938         u8 dialog_token = dialog->dialog_token;
 939         size_t frag_len;
 940
 941         if (dialog->sd_resp == NULL) {
 942                 buf = gas_serv_build_gas_resp_payload(hapd,
 943                                                       dialog->all_requested,
 944                                                       dialog, NULL, 0);
 945                 wpa_hexdump_buf(MSG_MSGDUMP, "ANQP: Generated ANQP responses",
 946                         buf);
 947                 if (!buf)
 948                         goto tx_gas_response_done;
 949                 dialog->sd_resp = buf;
 950                 dialog->sd_resp_pos = 0;
 951         }
 952         frag_len = wpabuf_len(dialog->sd_resp) - dialog->sd_resp_pos;
 953         if (frag_len > hapd->gas_frag_limit || dialog->comeback_delay ||
 954             hapd->conf->gas_comeback_delay) {
 955                 u16 comeback_delay_tus = dialog->comeback_delay +
 956                         GAS_SERV_COMEBACK_DELAY_FUDGE;
 957                 u32 comeback_delay_secs, comeback_delay_usecs;
 958
 959                 if (hapd->conf->gas_comeback_delay) {
 960                         /* Testing - allow overriding of the delay value */
 961                         comeback_delay_tus = hapd->conf->gas_comeback_delay;
 962                 }
 963
 964                 wpa_printf(MSG_DEBUG, "GAS: Response frag_len %u (frag limit "
 965                            "%u) and comeback delay %u, "
 966                            "requesting comebacks", (unsigned int) frag_len,
 967                            (unsigned int) hapd->gas_frag_limit,
 968                            dialog->comeback_delay);
 969                 tx_buf = gas_anqp_build_initial_resp_buf(dialog_token,
 970                                                          WLAN_STATUS_SUCCESS,
 971                                                          comeback_delay_tus,
 972                                                          NULL);
 973                 if (tx_buf) {
 974                         wpa_msg(hapd->msg_ctx, MSG_DEBUG,
 975                                 "GAS: Tx GAS Initial Resp (comeback = 10TU)");
 976                         hostapd_drv_send_action(hapd, hapd->iface->freq, 0,
 977                                                 dst,
 978                                                 wpabuf_head(tx_buf),
 979                                                 wpabuf_len(tx_buf));
 980                 }
 981                 wpabuf_free(tx_buf);
 982
 983                 /* start a timer of 1.5 * comeback-delay */
 984                 comeback_delay_tus = comeback_delay_tus +
 985                         (comeback_delay_tus / 2);
 986                 comeback_delay_secs = (comeback_delay_tus * 1024) / 1000000;
 987                 comeback_delay_usecs = (comeback_delay_tus * 1024) -
 988                         (comeback_delay_secs * 1000000);
 989                 eloop_register_timeout(comeback_delay_secs,
 990                                        comeback_delay_usecs,
 991                                        gas_serv_clear_cached_ies, dialog,
 992                                        NULL);
 993                 goto tx_gas_response_done;
 994         }
 995
 996         buf = wpabuf_alloc_copy(wpabuf_head_u8(dialog->sd_resp) +
 997                                 dialog->sd_resp_pos, frag_len);
 998         if (buf == NULL) {
 999                 wpa_msg(hapd->msg_ctx, MSG_DEBUG, "GAS: Buffer allocation "
1000                         "failed");
1001                 goto tx_gas_response_done;
1002         }
1003         tx_buf = gas_anqp_build_initial_resp_buf(dialog_token,
1004                                                  WLAN_STATUS_SUCCESS, 0, buf);
1005         wpabuf_free(buf);
1006         if (tx_buf == NULL)
1007                 goto tx_gas_response_done;
1008         wpa_msg(hapd->msg_ctx, MSG_DEBUG, "GAS: Tx GAS Initial "
1009                 "Response (frag_id %d frag_len %d)",
1010                 dialog->sd_frag_id, (int) frag_len);
1011         dialog->sd_frag_id++;
1012
1013         hostapd_drv_send_action(hapd, hapd->iface->freq, 0, dst,
1014                                 wpabuf_head(tx_buf), wpabuf_len(tx_buf));
1015         wpabuf_free(tx_buf);
1016 tx_gas_response_done:
1017         gas_serv_clear_cached_ies(dialog, NULL);
1018 }
1019
1020
1021 static void gas_serv_rx_gas_comeback_req(struct hostapd_data *hapd,
1022                                          const u8 *sa,
1023                                          const u8 *data, size_t len)
1024 {
1025         struct gas_dialog_info *dialog;
1026         struct wpabuf *buf, *tx_buf;
1027         u8 dialog_token;
1028         size_t frag_len;
1029         int more = 0;
1030
1031         wpa_hexdump(MSG_DEBUG, "GAS: RX GAS Comeback Request", data, len);
1032         if (len < 1)
1033                 return;
1034         dialog_token = *data;
1035         wpa_msg(hapd->msg_ctx, MSG_DEBUG, "GAS: Dialog Token: %u",
1036                 dialog_token);
1037
1038         dialog = gas_serv_dialog_find(hapd, sa, dialog_token);
1039         if (!dialog) {
1040                 wpa_msg(hapd->msg_ctx, MSG_DEBUG, "GAS: No pending SD "
1041                         "response fragment for " MACSTR " dialog token %u",
1042                         MAC2STR(sa), dialog_token);
1043
1044                 if (sa[0] & 0x01)
1045                         return; /* Invalid source address - drop silently */
1046                 tx_buf = gas_anqp_build_comeback_resp_buf(
1047                         dialog_token, WLAN_STATUS_NO_OUTSTANDING_GAS_REQ, 0, 0,
1048                         0, NULL);
1049                 if (tx_buf == NULL)
1050                         return;
1051                 goto send_resp;
1052         }
1053
1054         if (dialog->sd_resp == NULL) {
1055                 wpa_printf(MSG_DEBUG, "GAS: Remote request 0x%x received 0x%x",
1056                            dialog->requested, dialog->received);
1057                 if ((dialog->requested & dialog->received) !=
1058                     dialog->requested) {
1059                         wpa_printf(MSG_DEBUG, "GAS: Did not receive response "
1060                                    "from remote processing");
1061                         gas_serv_dialog_clear(dialog);
1062                         tx_buf = gas_anqp_build_comeback_resp_buf(
1063                                 dialog_token,
1064                                 WLAN_STATUS_GAS_RESP_NOT_RECEIVED, 0, 0, 0,
1065                                 NULL);
1066                         if (tx_buf == NULL)
1067                                 return;
1068                         goto send_resp;
1069                 }
1070
1071                 buf = gas_serv_build_gas_resp_payload(hapd,
1072                                                       dialog->all_requested,
1073                                                       dialog, NULL, 0);
1074                 wpa_hexdump_buf(MSG_MSGDUMP, "ANQP: Generated ANQP responses",
1075                         buf);
1076                 if (!buf)
1077                         goto rx_gas_comeback_req_done;
1078                 dialog->sd_resp = buf;
1079                 dialog->sd_resp_pos = 0;
1080         }
1081         frag_len = wpabuf_len(dialog->sd_resp) - dialog->sd_resp_pos;
1082         if (frag_len > hapd->gas_frag_limit) {
1083                 frag_len = hapd->gas_frag_limit;
1084                 more = 1;
1085         }
1086         wpa_msg(hapd->msg_ctx, MSG_DEBUG, "GAS: resp frag_len %u",
1087                 (unsigned int) frag_len);
1088         buf = wpabuf_alloc_copy(wpabuf_head_u8(dialog->sd_resp) +
1089                                 dialog->sd_resp_pos, frag_len);
1090         if (buf == NULL) {
1091                 wpa_msg(hapd->msg_ctx, MSG_DEBUG, "GAS: Failed to allocate "
1092                         "buffer");
1093                 goto rx_gas_comeback_req_done;
1094         }
1095         tx_buf = gas_anqp_build_comeback_resp_buf(dialog_token,
1096                                                   WLAN_STATUS_SUCCESS,
1097                                                   dialog->sd_frag_id,
1098                                                   more, 0, buf);
1099         wpabuf_free(buf);
1100         if (tx_buf == NULL)
1101                 goto rx_gas_comeback_req_done;
1102         wpa_msg(hapd->msg_ctx, MSG_DEBUG, "GAS: Tx GAS Comeback Response "
1103                 "(frag_id %d more=%d frag_len=%d)",
1104                 dialog->sd_frag_id, more, (int) frag_len);
1105         dialog->sd_frag_id++;
1106         dialog->sd_resp_pos += frag_len;
1107
1108         if (more) {
1109                 wpa_msg(hapd->msg_ctx, MSG_DEBUG, "GAS: %d more bytes remain "
1110                         "to be sent",
1111                         (int) (wpabuf_len(dialog->sd_resp) -
1112                                dialog->sd_resp_pos));
1113         } else {
1114                 wpa_msg(hapd->msg_ctx, MSG_DEBUG, "GAS: All fragments of "
1115                         "SD response sent");
1116                 gas_serv_dialog_clear(dialog);
1117                 gas_serv_free_dialogs(hapd, sa);
1118         }
1119
1120 send_resp:
1121         hostapd_drv_send_action(hapd, hapd->iface->freq, 0, sa,
1122                                 wpabuf_head(tx_buf), wpabuf_len(tx_buf));
1123         wpabuf_free(tx_buf);
1124         return;
1125
1126 rx_gas_comeback_req_done:
1127         gas_serv_clear_cached_ies(dialog, NULL);
1128 }
1129
1130
1131 static void gas_serv_rx_public_action(void *ctx, const u8 *buf, size_t len,
1132                                       int freq)
1133 {
1134         struct hostapd_data *hapd = ctx;
1135         const struct ieee80211_mgmt *mgmt;
1136         size_t hdr_len;
1137         const u8 *sa, *data;
1138
1139         mgmt = (const struct ieee80211_mgmt *) buf;
1140         hdr_len = (const u8 *) &mgmt->u.action.u.vs_public_action.action - buf;
1141         if (hdr_len > len)
1142                 return;
1143         if (mgmt->u.action.category != WLAN_ACTION_PUBLIC)
1144                 return;
1145         sa = mgmt->sa;
1146         len -= hdr_len;
1147         data = &mgmt->u.action.u.public_action.action;
1148         switch (data[0]) {
1149         case WLAN_PA_GAS_INITIAL_REQ:
1150                 gas_serv_rx_gas_initial_req(hapd, sa, data + 1, len - 1);
1151                 break;
1152         case WLAN_PA_GAS_COMEBACK_REQ:
1153                 gas_serv_rx_gas_comeback_req(hapd, sa, data + 1, len - 1);
1154                 break;
1155         }
1156 }
1157
1158
1159 int gas_serv_init(struct hostapd_data *hapd)
1160 {
1161         hapd->public_action_cb = gas_serv_rx_public_action;
1162         hapd->public_action_cb_ctx = hapd;
1163         hapd->gas_frag_limit = 1400;
1164         if (hapd->conf->gas_frag_limit > 0)
1165                 hapd->gas_frag_limit = hapd->conf->gas_frag_limit;
1166         return 0;
1167 }
1168
1169
1170 void gas_serv_deinit(struct hostapd_data *hapd)
1171 {
1172 }