content: /*
   * Copyright (C) 2015 The Android Open Source Project
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package com.android.server.wifi.util;
  
  import android.net.wifi.ScanResult;
  import android.net.wifi.ScanResult.InformationElement;
  import android.util.Log;
  
  import com.android.server.wifi.ByteBufferReader;
  import com.android.server.wifi.hotspot2.NetworkDetail;
  import com.android.server.wifi.hotspot2.anqp.Constants;
  
  import java.nio.BufferUnderflowException;
  import java.nio.ByteBuffer;
  import java.nio.ByteOrder;
  import java.util.ArrayList;
  import java.util.BitSet;
  
  public class InformationElementUtil {
      private static final String TAG = "InformationElementUtil";
  
      public static InformationElement[] parseInformationElements(byte[] bytes) {
          if (bytes == null) {
              return new InformationElement[0];
          }
          ByteBuffer data = ByteBuffer.wrap(bytes).order(ByteOrder.LITTLE_ENDIAN);
  
          ArrayList<InformationElement> infoElements = new ArrayList<>();
          boolean found_ssid = false;
          while (data.remaining() > 1) {
              int eid = data.get() & Constants.BYTE_MASK;
              int elementLength = data.get() & Constants.BYTE_MASK;
  
              if (elementLength > data.remaining() || (eid == InformationElement.EID_SSID
                      && found_ssid)) {
                  // APs often pad the data with bytes that happen to match that of the EID_SSID
                  // marker.  This is not due to a known issue for APs to incorrectly send the SSID
                  // name multiple times.
                  break;
              }
              if (eid == InformationElement.EID_SSID) {
                  found_ssid = true;
              }
  
              InformationElement ie = new InformationElement();
              ie.id = eid;
              ie.bytes = new byte[elementLength];
              data.get(ie.bytes);
              infoElements.add(ie);
          }
          return infoElements.toArray(new InformationElement[infoElements.size()]);
      }
  
      /**
       * Parse and retrieve the Roaming Consortium Information Element from the list of IEs.
       *
       * @param ies List of IEs to retrieve from
       * @return {@link RoamingConsortium}
       */
      public static RoamingConsortium getRoamingConsortiumIE(InformationElement[] ies) {
          RoamingConsortium roamingConsortium = new RoamingConsortium();
          if (ies != null) {
              for (InformationElement ie : ies) {
                  if (ie.id == InformationElement.EID_ROAMING_CONSORTIUM) {
                      try {
                          roamingConsortium.from(ie);
                      } catch (RuntimeException e) {
                          Log.e(TAG, "Failed to parse Roaming Consortium IE: " + e.getMessage());
                      }
                  }
              }
          }
          return roamingConsortium;
      }
  
      /**
       * Parse and retrieve the Hotspot 2.0 Vendor Specific Information Element from the list of IEs.
       *
       * @param ies List of IEs to retrieve from
       * @return {@link Vsa}
       */
      public static Vsa getHS2VendorSpecificIE(InformationElement[] ies) {
          Vsa vsa = new Vsa();
          if (ies != null) {
              for (InformationElement ie : ies) {
                  if (ie.id == InformationElement.EID_VSA) {
                      try {
                          vsa.from(ie);
                      } catch (RuntimeException e) {
                          Log.e(TAG, "Failed to parse Vendor Specific IE: " + e.getMessage());
                      }
                  }
              }
          }
          return vsa;
      }
  
      /**
       * Parse and retrieve the Interworking information element from the list of IEs.
       *
       * @param ies List of IEs to retrieve from
       * @return {@link Interworking}
       */
      public static Interworking getInterworkingIE(InformationElement[] ies) {
          Interworking interworking = new Interworking();
          if (ies != null) {
              for (InformationElement ie : ies) {
                  if (ie.id == InformationElement.EID_INTERWORKING) {
                      try {
                          interworking.from(ie);
                      } catch (RuntimeException e) {
                          Log.e(TAG, "Failed to parse Interworking IE: " + e.getMessage());
                      }
                  }
              }
          }
          return interworking;
      }
  
      public static class BssLoad {
          public int stationCount = 0;
          public int channelUtilization = 0;
          public int capacity = 0;
  
          public void from(InformationElement ie) {
              if (ie.id != InformationElement.EID_BSS_LOAD) {
                  throw new IllegalArgumentException("Element id is not BSS_LOAD, : " + ie.id);
              }
              if (ie.bytes.length != 5) {
                  throw new IllegalArgumentException("BSS Load element length is not 5: "
                                                     + ie.bytes.length);
              }
              ByteBuffer data = ByteBuffer.wrap(ie.bytes).order(ByteOrder.LITTLE_ENDIAN);
              stationCount = data.getShort() & Constants.SHORT_MASK;
              channelUtilization = data.get() & Constants.BYTE_MASK;
              capacity = data.getShort() & Constants.SHORT_MASK;
          }
      }
  
      public static class HtOperation {
          public int secondChannelOffset = 0;
  
          public int getChannelWidth() {
              if (secondChannelOffset != 0) {
                  return 1;
              } else {
                  return 0;
              }
          }
  
          public int getCenterFreq0(int primaryFrequency) {
              //40 MHz
              if (secondChannelOffset != 0) {
                  if (secondChannelOffset == 1) {
                      return primaryFrequency + 10;
                  } else if (secondChannelOffset == 3) {
                      return primaryFrequency - 10;
                  } else {
                      Log.e("HtOperation", "Error on secondChannelOffset: " + secondChannelOffset);
                      return 0;
                  }
              } else {
                  return 0;
              }
          }
  
          public void from(InformationElement ie) {
              if (ie.id != InformationElement.EID_HT_OPERATION) {
                  throw new IllegalArgumentException("Element id is not HT_OPERATION, : " + ie.id);
              }
              secondChannelOffset = ie.bytes[1] & 0x3;
          }
      }
  
      public static class VhtOperation {
          public int channelMode = 0;
          public int centerFreqIndex1 = 0;
          public int centerFreqIndex2 = 0;
  
          public boolean isValid() {
              return channelMode != 0;
          }
  
          public int getChannelWidth() {
              return channelMode + 1;
          }
  
          public int getCenterFreq0() {
              //convert channel index to frequency in MHz, channel 36 is 5180MHz
              return (centerFreqIndex1 - 36) * 5 + 5180;
          }
  
          public int getCenterFreq1() {
              if (channelMode > 1) { //160MHz
                  return (centerFreqIndex2 - 36) * 5 + 5180;
              } else {
                  return 0;
              }
          }
  
          public void from(InformationElement ie) {
              if (ie.id != InformationElement.EID_VHT_OPERATION) {
                  throw new IllegalArgumentException("Element id is not VHT_OPERATION, : " + ie.id);
              }
              channelMode = ie.bytes[0] & Constants.BYTE_MASK;
              centerFreqIndex1 = ie.bytes[1] & Constants.BYTE_MASK;
              centerFreqIndex2 = ie.bytes[2] & Constants.BYTE_MASK;
          }
      }
  
      public static class Interworking {
          public NetworkDetail.Ant ant = null;
          public boolean internet = false;
          public long hessid = 0L;
  
          public void from(InformationElement ie) {
              if (ie.id != InformationElement.EID_INTERWORKING) {
                  throw new IllegalArgumentException("Element id is not INTERWORKING, : " + ie.id);
              }
              ByteBuffer data = ByteBuffer.wrap(ie.bytes).order(ByteOrder.LITTLE_ENDIAN);
              int anOptions = data.get() & Constants.BYTE_MASK;
              ant = NetworkDetail.Ant.values()[anOptions & 0x0f];
              internet = (anOptions & 0x10) != 0;
              // There are only three possible lengths for the Interworking IE:
              // Len 1: Access Network Options only
              // Len 3: Access Network Options & Venue Info
              // Len 7: Access Network Options & HESSID
              // Len 9: Access Network Options, Venue Info, & HESSID
              if (ie.bytes.length != 1
                      && ie.bytes.length != 3
                      && ie.bytes.length != 7
                      && ie.bytes.length != 9) {
                  throw new IllegalArgumentException(
                          "Bad Interworking element length: " + ie.bytes.length);
              }
  
              if (ie.bytes.length == 3 || ie.bytes.length == 9) {
                  int venueInfo = (int) ByteBufferReader.readInteger(data, ByteOrder.BIG_ENDIAN, 2);
              }
  
              if (ie.bytes.length == 7 || ie.bytes.length == 9) {
                  hessid = ByteBufferReader.readInteger(data, ByteOrder.BIG_ENDIAN, 6);
              }
          }
      }
  
      public static class RoamingConsortium {
          public int anqpOICount = 0;
  
          private long[] roamingConsortiums = null;
  
          public long[] getRoamingConsortiums() {
              return roamingConsortiums;
          }
  
          public void from(InformationElement ie) {
              if (ie.id != InformationElement.EID_ROAMING_CONSORTIUM) {
                  throw new IllegalArgumentException("Element id is not ROAMING_CONSORTIUM, : "
                          + ie.id);
              }
              ByteBuffer data = ByteBuffer.wrap(ie.bytes).order(ByteOrder.LITTLE_ENDIAN);
              anqpOICount = data.get() & Constants.BYTE_MASK;
  
              int oi12Length = data.get() & Constants.BYTE_MASK;
              int oi1Length = oi12Length & Constants.NIBBLE_MASK;
              int oi2Length = (oi12Length >>> 4) & Constants.NIBBLE_MASK;
              int oi3Length = ie.bytes.length - 2 - oi1Length - oi2Length;
              int oiCount = 0;
              if (oi1Length > 0) {
                  oiCount++;
                  if (oi2Length > 0) {
                      oiCount++;
                      if (oi3Length > 0) {
                          oiCount++;
                      }
                  }
              }
              roamingConsortiums = new long[oiCount];
              if (oi1Length > 0 && roamingConsortiums.length > 0) {
                  roamingConsortiums[0] =
                          ByteBufferReader.readInteger(data, ByteOrder.BIG_ENDIAN, oi1Length);
              }
              if (oi2Length > 0 && roamingConsortiums.length > 1) {
                  roamingConsortiums[1] =
                          ByteBufferReader.readInteger(data, ByteOrder.BIG_ENDIAN, oi2Length);
              }
              if (oi3Length > 0 && roamingConsortiums.length > 2) {
                  roamingConsortiums[2] =
                          ByteBufferReader.readInteger(data, ByteOrder.BIG_ENDIAN, oi3Length);
              }
          }
      }
  
      public static class Vsa {
          private static final int ANQP_DOMID_BIT = 0x04;
  
          public NetworkDetail.HSRelease hsRelease = null;
          public int anqpDomainID = 0;    // No domain ID treated the same as a 0; unique info per AP.
  
          public void from(InformationElement ie) {
              ByteBuffer data = ByteBuffer.wrap(ie.bytes).order(ByteOrder.LITTLE_ENDIAN);
              if (ie.bytes.length >= 5 && data.getInt() == Constants.HS20_FRAME_PREFIX) {
                  int hsConf = data.get() & Constants.BYTE_MASK;
                  switch ((hsConf >> 4) & Constants.NIBBLE_MASK) {
                      case 0:
                          hsRelease = NetworkDetail.HSRelease.R1;
                          break;
                      case 1:
                          hsRelease = NetworkDetail.HSRelease.R2;
                          break;
                      default:
                          hsRelease = NetworkDetail.HSRelease.Unknown;
                          break;
                  }
                  if ((hsConf & ANQP_DOMID_BIT) != 0) {
                      if (ie.bytes.length < 7) {
                          throw new IllegalArgumentException(
                                  "HS20 indication element too short: " + ie.bytes.length);
                      }
                      anqpDomainID = data.getShort() & Constants.SHORT_MASK;
                  }
              }
          }
      }
  
      /**
       * This IE contained a bit field indicating the capabilities being advertised by the STA.
       * The size of the bit field (number of bytes) is indicated by the |Length| field in the IE.
       *
       * Refer to Section 8.4.2.29 in IEEE 802.11-2012 Spec for capability associated with each
       * bit.
       *
       * Here is the wire format of this IE:
       * | Element ID | Length | Capabilities |
       *       1           1          n
       */
      public static class ExtendedCapabilities {
          private static final int RTT_RESP_ENABLE_BIT = 70;
          private static final int SSID_UTF8_BIT = 48;
  
          public BitSet capabilitiesBitSet;
  
          /**
           * @return true if SSID should be interpreted using UTF-8 encoding
           */
          public boolean isStrictUtf8() {
              return capabilitiesBitSet.get(SSID_UTF8_BIT);
          }
  
          /**
           * @return true if 802.11 MC RTT Response is enabled
           */
          public boolean is80211McRTTResponder() {
              return capabilitiesBitSet.get(RTT_RESP_ENABLE_BIT);
          }
  
          public ExtendedCapabilities() {
              capabilitiesBitSet = new BitSet();
          }
  
          public ExtendedCapabilities(ExtendedCapabilities other) {
              capabilitiesBitSet = other.capabilitiesBitSet;
          }
  
          /**
           * Parse an ExtendedCapabilities from the IE containing raw bytes.
           *
           * @param ie The Information element data
           */
          public void from(InformationElement ie) {
              capabilitiesBitSet = BitSet.valueOf(ie.bytes);
          }
      }
  
      /**
       * parse beacon to build the capabilities
       *
       * This class is used to build the capabilities string of the scan results coming
       * from HAL. It parses the ieee beacon's capability field, WPA and RSNE IE as per spec,
       * and builds the ScanResult.capabilities String in a way that mirrors the values returned
       * by wpa_supplicant.
       */
      public static class Capabilities {
          private static final int CAP_ESS_BIT_OFFSET = 0;
          private static final int CAP_PRIVACY_BIT_OFFSET = 4;
  
          private static final int WPA_VENDOR_OUI_TYPE_ONE = 0x01f25000;
          private static final int WPS_VENDOR_OUI_TYPE = 0x04f25000;
          private static final short WPA_VENDOR_OUI_VERSION = 0x0001;
          private static final int OWE_VENDOR_OUI_TYPE = 0x1c9a6f50;
          private static final short RSNE_VERSION = 0x0001;
  
          private static final int WPA_AKM_EAP = 0x01f25000;
          private static final int WPA_AKM_PSK = 0x02f25000;
  
          private static final int RSN_AKM_EAP = 0x01ac0f00;
          private static final int RSN_AKM_PSK = 0x02ac0f00;
          private static final int RSN_AKM_FT_EAP = 0x03ac0f00;
          private static final int RSN_AKM_FT_PSK = 0x04ac0f00;
          private static final int RSN_AKM_EAP_SHA256 = 0x05ac0f00;
          private static final int RSN_AKM_PSK_SHA256 = 0x06ac0f00;
          private static final int RSN_AKM_SAE = 0x08ac0f00;
          private static final int RSN_AKM_FT_SAE = 0x09ac0f00;
          private static final int RSN_AKM_OWE = 0x12ac0f00;
          private static final int RSN_AKM_EAP_SUITE_B_192 = 0x0cac0f00;
  
          private static final int WPA_CIPHER_NONE = 0x00f25000;
          private static final int WPA_CIPHER_TKIP = 0x02f25000;
          private static final int WPA_CIPHER_CCMP = 0x04f25000;
  
          private static final int RSN_CIPHER_NONE = 0x00ac0f00;
          private static final int RSN_CIPHER_TKIP = 0x02ac0f00;
          private static final int RSN_CIPHER_CCMP = 0x04ac0f00;
          private static final int RSN_CIPHER_NO_GROUP_ADDRESSED = 0x07ac0f00;
          private static final int RSN_CIPHER_GCMP_256 = 0x09ac0f00;
  
          public ArrayList<Integer> protocol;
          public ArrayList<ArrayList<Integer>> keyManagement;
          public ArrayList<ArrayList<Integer>> pairwiseCipher;
          public ArrayList<Integer> groupCipher;
          public boolean isESS;
          public boolean isPrivacy;
          public boolean isWPS;
  
          public Capabilities() {
          }
  
          // RSNE format (size unit: byte)
          //
          // | Element ID | Length | Version | Group Data Cipher Suite |
          //      1           1         2                 4
          // | Pairwise Cipher Suite Count | Pairwise Cipher Suite List |
          //              2                            4 * m
          // | AKM Suite Count | AKM Suite List | RSN Capabilities |
          //          2               4 * n               2
          // | PMKID Count | PMKID List | Group Management Cipher Suite |
          //        2          16 * s                 4
          //
          // Note: InformationElement.bytes has 'Element ID' and 'Length'
          //       stripped off already
          private void parseRsnElement(InformationElement ie) {
              ByteBuffer buf = ByteBuffer.wrap(ie.bytes).order(ByteOrder.LITTLE_ENDIAN);
  
              try {
                  // version
                  if (buf.getShort() != RSNE_VERSION) {
                      // incorrect version
                      return;
                  }
  
                  // found the RSNE IE, hence start building the capability string
                  protocol.add(ScanResult.PROTOCOL_RSN);
  
                  // group data cipher suite
                  groupCipher.add(parseRsnCipher(buf.getInt()));
  
                  // pairwise cipher suite count
                  short cipherCount = buf.getShort();
                  ArrayList<Integer> rsnPairwiseCipher = new ArrayList<>();
                  // pairwise cipher suite list
                  for (int i = 0; i < cipherCount; i++) {
                      rsnPairwiseCipher.add(parseRsnCipher(buf.getInt()));
                  }
                  pairwiseCipher.add(rsnPairwiseCipher);
  
                  // AKM
                  // AKM suite count
                  short akmCount = buf.getShort();
                  ArrayList<Integer> rsnKeyManagement = new ArrayList<>();
  
                  for (int i = 0; i < akmCount; i++) {
                      int akm = buf.getInt();
                      switch (akm) {
                          case RSN_AKM_EAP:
                              rsnKeyManagement.add(ScanResult.KEY_MGMT_EAP);
                              break;
                          case RSN_AKM_PSK:
                              rsnKeyManagement.add(ScanResult.KEY_MGMT_PSK);
                              break;
                          case RSN_AKM_FT_EAP:
                              rsnKeyManagement.add(ScanResult.KEY_MGMT_FT_EAP);
                              break;
                          case RSN_AKM_FT_PSK:
                              rsnKeyManagement.add(ScanResult.KEY_MGMT_FT_PSK);
                              break;
                          case RSN_AKM_EAP_SHA256:
                              rsnKeyManagement.add(ScanResult.KEY_MGMT_EAP_SHA256);
                              break;
                          case RSN_AKM_PSK_SHA256:
                              rsnKeyManagement.add(ScanResult.KEY_MGMT_PSK_SHA256);
                              break;
                          case RSN_AKM_SAE:
                              rsnKeyManagement.add(ScanResult.KEY_MGMT_SAE);
                              break;
                          case RSN_AKM_FT_SAE:
                              rsnKeyManagement.add(ScanResult.KEY_MGMT_FT_SAE);
                              break;
                          case RSN_AKM_OWE:
                              rsnKeyManagement.add(ScanResult.KEY_MGMT_OWE);
                              break;
                          case RSN_AKM_EAP_SUITE_B_192:
                              rsnKeyManagement.add(ScanResult.KEY_MGMT_EAP_SUITE_B_192);
                              break;
                          default:
                              // do nothing
                              break;
                      }
                  }
                  // Default AKM
                  if (rsnKeyManagement.isEmpty()) {
                      rsnKeyManagement.add(ScanResult.KEY_MGMT_EAP);
                  }
                  keyManagement.add(rsnKeyManagement);
              } catch (BufferUnderflowException e) {
                  Log.e("IE_Capabilities", "Couldn't parse RSNE, buffer underflow");
              }
          }
  
          private static int parseWpaCipher(int cipher) {
              switch (cipher) {
                  case WPA_CIPHER_NONE:
                      return ScanResult.CIPHER_NONE;
                  case WPA_CIPHER_TKIP:
                      return ScanResult.CIPHER_TKIP;
                  case WPA_CIPHER_CCMP:
                      return ScanResult.CIPHER_CCMP;
                  default:
                      Log.w("IE_Capabilities", "Unknown WPA cipher suite: "
                              + Integer.toHexString(cipher));
                      return ScanResult.CIPHER_NONE;
              }
          }
  
          private static int parseRsnCipher(int cipher) {
              switch (cipher) {
                  case RSN_CIPHER_NONE:
                      return ScanResult.CIPHER_NONE;
                  case RSN_CIPHER_TKIP:
                      return ScanResult.CIPHER_TKIP;
                  case RSN_CIPHER_CCMP:
                      return ScanResult.CIPHER_CCMP;
                  case RSN_CIPHER_GCMP_256:
                      return ScanResult.CIPHER_GCMP_256;
                  case RSN_CIPHER_NO_GROUP_ADDRESSED:
                      return ScanResult.CIPHER_NO_GROUP_ADDRESSED;
                  default:
                      Log.w("IE_Capabilities", "Unknown RSN cipher suite: "
                              + Integer.toHexString(cipher));
                      return ScanResult.CIPHER_NONE;
              }
          }
  
          private static boolean isWpsElement(InformationElement ie) {
              ByteBuffer buf = ByteBuffer.wrap(ie.bytes).order(ByteOrder.LITTLE_ENDIAN);
              try {
                  // WPS OUI and type
                  return (buf.getInt() == WPS_VENDOR_OUI_TYPE);
              } catch (BufferUnderflowException e) {
                  Log.e("IE_Capabilities", "Couldn't parse VSA IE, buffer underflow");
                  return false;
              }
          }
  
          private static boolean isWpaOneElement(InformationElement ie) {
              ByteBuffer buf = ByteBuffer.wrap(ie.bytes).order(ByteOrder.LITTLE_ENDIAN);
  
              try {
                  // WPA OUI and type
                  return (buf.getInt() == WPA_VENDOR_OUI_TYPE_ONE);
              } catch (BufferUnderflowException e) {
                  Log.e("IE_Capabilities", "Couldn't parse VSA IE, buffer underflow");
                  return false;
              }
          }
  
          // WPA type 1 format (size unit: byte)
          //
          // | Element ID | Length | OUI | Type | Version |
          //      1           1       3     1        2
          // | Group Data Cipher Suite |
          //             4
          // | Pairwise Cipher Suite Count | Pairwise Cipher Suite List |
          //              2                            4 * m
          // | AKM Suite Count | AKM Suite List |
          //          2               4 * n
          //
          // Note: InformationElement.bytes has 'Element ID' and 'Length'
          //       stripped off already
          //
          private void parseWpaOneElement(InformationElement ie) {
              ByteBuffer buf = ByteBuffer.wrap(ie.bytes).order(ByteOrder.LITTLE_ENDIAN);
  
              try {
                  // skip WPA OUI and type parsing. isWpaOneElement() should have
                  // been called for verification before we reach here.
                  buf.getInt();
  
                  // version
                  if (buf.getShort() != WPA_VENDOR_OUI_VERSION) {
                      // incorrect version
                      return;
                  }
  
                  // start building the string
                  protocol.add(ScanResult.PROTOCOL_WPA);
  
                  // group data cipher suite
                  groupCipher.add(parseWpaCipher(buf.getInt()));
  
                  // pairwise cipher suite count
                  short cipherCount = buf.getShort();
                  ArrayList<Integer> wpaPairwiseCipher = new ArrayList<>();
                  // pairwise chipher suite list
                  for (int i = 0; i < cipherCount; i++) {
                      wpaPairwiseCipher.add(parseWpaCipher(buf.getInt()));
                  }
                  pairwiseCipher.add(wpaPairwiseCipher);
  
                  // AKM
                  // AKM suite count
                  short akmCount = buf.getShort();
                  ArrayList<Integer> wpaKeyManagement = new ArrayList<>();
  
                  // AKM suite list
                  for (int i = 0; i < akmCount; i++) {
                      int akm = buf.getInt();
                      switch (akm) {
                          case WPA_AKM_EAP:
                              wpaKeyManagement.add(ScanResult.KEY_MGMT_EAP);
                              break;
                          case WPA_AKM_PSK:
                              wpaKeyManagement.add(ScanResult.KEY_MGMT_PSK);
                              break;
                          default:
                              // do nothing
                              break;
                      }
                  }
                  // Default AKM
                  if (wpaKeyManagement.isEmpty()) {
                      wpaKeyManagement.add(ScanResult.KEY_MGMT_EAP);
                  }
                  keyManagement.add(wpaKeyManagement);
              } catch (BufferUnderflowException e) {
                  Log.e("IE_Capabilities", "Couldn't parse type 1 WPA, buffer underflow");
              }
          }
  
          /**
           * Parse the Information Element and the 16-bit Capability Information field
           * to build the InformationElemmentUtil.capabilities object.
           *
           * @param ies            -- Information Element array
           * @param beaconCap      -- 16-bit Beacon Capability Information field
           * @param isOweSupported -- Boolean flag to indicate if OWE is supported by the device
           */
  
          public void from(InformationElement[] ies, BitSet beaconCap, boolean isOweSupported) {
              protocol = new ArrayList<Integer>();
              keyManagement = new ArrayList<ArrayList<Integer>>();
              groupCipher = new ArrayList<Integer>();
              pairwiseCipher = new ArrayList<ArrayList<Integer>>();
  
              if (ies == null || beaconCap == null) {
                  return;
              }
              isESS = beaconCap.get(CAP_ESS_BIT_OFFSET);
              isPrivacy = beaconCap.get(CAP_PRIVACY_BIT_OFFSET);
              for (InformationElement ie : ies) {
                  if (ie.id == InformationElement.EID_RSN) {
                      parseRsnElement(ie);
                  }
  
                  if (ie.id == InformationElement.EID_VSA) {
                      if (isWpaOneElement(ie)) {
                          parseWpaOneElement(ie);
                      }
                      if (isWpsElement(ie)) {
                          // TODO(b/62134557): parse WPS IE to provide finer granularity information.
                          isWPS = true;
                      }
                      if (isOweSupported && isOweElement(ie)) {
                          /* From RFC 8110: Once the client and AP have finished 802.11 association,
                             they then complete the Diffie-Hellman key exchange and create a Pairwise
                             Master Key (PMK) and its associated identifier, PMKID [IEEE802.11].
                             Upon completion of 802.11 association, the AP initiates the 4-way
                             handshake to the client using the PMK generated above.  The 4-way
                             handshake generates a Key-Encrypting Key (KEK), a Key-Confirmation
                             Key (KCK), and a Message Integrity Code (MIC) to use for protection
                             of the frames that define the 4-way handshake.
  
                             We check if OWE is supported here because we are adding the OWE
                             capabilities to the Open BSS. Non-supporting devices need to see this
                             open network and ignore this element. Supporting devices need to hide
                             the Open BSS of OWE in transition mode and connect to the Hidden one.
                          */
                          protocol.add(ScanResult.PROTOCOL_RSN);
                          groupCipher.add(ScanResult.CIPHER_CCMP);
                          ArrayList<Integer> owePairwiseCipher = new ArrayList<>();
                          owePairwiseCipher.add(ScanResult.CIPHER_CCMP);
                          pairwiseCipher.add(owePairwiseCipher);
                          ArrayList<Integer> oweKeyManagement = new ArrayList<>();
                          oweKeyManagement.add(ScanResult.KEY_MGMT_OWE_TRANSITION);
                          keyManagement.add(oweKeyManagement);
                      }
                  }
              }
          }
  
          private static boolean isOweElement(InformationElement ie) {
              ByteBuffer buf = ByteBuffer.wrap(ie.bytes).order(ByteOrder.LITTLE_ENDIAN);
              try {
                  // OWE OUI and type
                  return (buf.getInt() == OWE_VENDOR_OUI_TYPE);
              } catch (BufferUnderflowException e) {
                  Log.e("IE_Capabilities", "Couldn't parse VSA IE, buffer underflow");
                  return false;
              }
          }
  
          private String protocolToString(int protocol) {
              switch (protocol) {
                  case ScanResult.PROTOCOL_NONE:
                      return "None";
                  case ScanResult.PROTOCOL_WPA:
                      return "WPA";
                  case ScanResult.PROTOCOL_RSN:
                      return "RSN";
                  default:
                      return "?";
              }
          }
  
          private String keyManagementToString(int akm) {
              switch (akm) {
                  case ScanResult.KEY_MGMT_NONE:
                      return "None";
                  case ScanResult.KEY_MGMT_PSK:
                      return "PSK";
                  case ScanResult.KEY_MGMT_EAP:
                      return "EAP";
                  case ScanResult.KEY_MGMT_FT_EAP:
                      return "FT/EAP";
                  case ScanResult.KEY_MGMT_FT_PSK:
                      return "FT/PSK";
                  case ScanResult.KEY_MGMT_EAP_SHA256:
                      return "EAP-SHA256";
                  case ScanResult.KEY_MGMT_PSK_SHA256:
                      return "PSK-SHA256";
                  case ScanResult.KEY_MGMT_OWE:
                      return "OWE";
                  case ScanResult.KEY_MGMT_OWE_TRANSITION:
                      return "OWE_TRANSITION";
                  case ScanResult.KEY_MGMT_SAE:
                      return "SAE";
                  case ScanResult.KEY_MGMT_FT_SAE:
                      return "FT/SAE";
                  case ScanResult.KEY_MGMT_EAP_SUITE_B_192:
                      return "EAP_SUITE_B_192";
                  default:
                      return "?";
              }
          }
  
          private String cipherToString(int cipher) {
              switch (cipher) {
                  case ScanResult.CIPHER_NONE:
                      return "None";
                  case ScanResult.CIPHER_CCMP:
                      return "CCMP";
                  case ScanResult.CIPHER_GCMP_256:
                      return "GCMP-256";
                  case ScanResult.CIPHER_TKIP:
                      return "TKIP";
                  default:
                      return "?";
              }
          }
  
          /**
           * Build the ScanResult.capabilities String.
           *
           * @return security string that mirrors what wpa_supplicant generates
           */
          public String generateCapabilitiesString() {
              StringBuilder capabilities = new StringBuilder();
              // private Beacon without an RSNE or WPA IE, hence WEP0
              boolean isWEP = (protocol.isEmpty()) && isPrivacy;
  
              if (isWEP) {
                  capabilities.append("[WEP]");
              }
              for (int i = 0; i < protocol.size(); i++) {
                  String capability = generateCapabilitiesStringPerProtocol(i);
                  // add duplicate capabilities for WPA2 for backward compatibility:
                  // duplicate "RSN" entries as "WPA2"
                  String capWpa2 = generateWPA2CapabilitiesString(capability, i);
                  capabilities.append(capWpa2);
                  capabilities.append(capability);
              }
              if (isESS) {
                  capabilities.append("[ESS]");
              }
              if (isWPS) {
                  capabilities.append("[WPS]");
              }
  
              return capabilities.toString();
          }
  
          /**
           * Build the Capability String for one protocol
           * @param index: index number of the protocol
           * @return security string for one protocol
           */
          private String generateCapabilitiesStringPerProtocol(int index) {
              StringBuilder capability = new StringBuilder();
              capability.append("[").append(protocolToString(protocol.get(index)));
  
              if (index < keyManagement.size()) {
                  for (int j = 0; j < keyManagement.get(index).size(); j++) {
                      capability.append((j == 0) ? "-" : "+").append(
                              keyManagementToString(keyManagement.get(index).get(j)));
                  }
              }
              if (index < pairwiseCipher.size()) {
                  for (int j = 0; j < pairwiseCipher.get(index).size(); j++) {
                      capability.append((j == 0) ? "-" : "+").append(
                              cipherToString(pairwiseCipher.get(index).get(j)));
                  }
              }
              capability.append("]");
              return capability.toString();
          }
  
          /**
           * Build the duplicate Capability String for WPA2
           * @param cap: original capability String
           * @param index: index number of the protocol
           * @return security string for WPA2, empty String if protocol is not WPA2
           */
          private String generateWPA2CapabilitiesString(String cap, int index) {
              StringBuilder capWpa2 = new StringBuilder();
              // if not WPA2, return empty String
              if (cap.contains("EAP_SUITE_B_192")
                      || (!cap.contains("RSN-EAP") && !cap.contains("RSN-FT/EAP")
                      && !cap.contains("RSN-PSK") && !cap.contains("RSN-FT/PSK"))) {
                  return "";
              }
              capWpa2.append("[").append("WPA2");
              if (index < keyManagement.size()) {
                  for (int j = 0; j < keyManagement.get(index).size(); j++) {
                      capWpa2.append((j == 0) ? "-" : "+").append(
                              keyManagementToString(keyManagement.get(index).get(j)));
                      // WPA3/WPA2 transition mode
                      if (cap.contains("SAE")) {
                          break;
                      }
                  }
              }
              if (index < pairwiseCipher.size()) {
                  for (int j = 0; j < pairwiseCipher.get(index).size(); j++) {
                      capWpa2.append((j == 0) ? "-" : "+").append(
                              cipherToString(pairwiseCipher.get(index).get(j)));
                  }
              }
              capWpa2.append("]");
              return capWpa2.toString();
          }
      }
  
  
      /**
       * Parser for the Traffic Indication Map (TIM) Information Element (EID 5). This element will
       * only be present in scan results that are derived from a Beacon Frame, not from the more
       * plentiful probe responses. Call 'isValid()' after parsing, to ensure the results are correct.
       */
      public static class TrafficIndicationMap {
          private static final int MAX_TIM_LENGTH = 254;
          private boolean mValid = false;
          public int mLength = 0;
          public int mDtimCount = -1;
          //Negative DTIM Period means no TIM element was given this frame.
          public int mDtimPeriod = -1;
          public int mBitmapControl = 0;
  
          /**
           * Is this a valid TIM information element.
           */
          public boolean isValid() {
              return mValid;
          }
  
          // Traffic Indication Map format (size unit: byte)
          //
          //| ElementID | Length | DTIM Count | DTIM Period | BitmapControl | Partial Virtual Bitmap |
          //      1          1          1            1               1                1 - 251
          //
          // Note: InformationElement.bytes has 'Element ID' and 'Length'
          //       stripped off already
          //
          public void from(InformationElement ie) {
              mValid = false;
              if (ie == null || ie.bytes == null) return;
              mLength = ie.bytes.length;
              ByteBuffer data = ByteBuffer.wrap(ie.bytes).order(ByteOrder.LITTLE_ENDIAN);
              try {
                  mDtimCount = data.get() & Constants.BYTE_MASK;
                  mDtimPeriod = data.get() & Constants.BYTE_MASK;
                  mBitmapControl = data.get() & Constants.BYTE_MASK;
                  //A valid TIM element must have atleast one more byte
                  data.get();
              } catch (BufferUnderflowException e) {
                  return;
              }
              if (mLength <= MAX_TIM_LENGTH && mDtimPeriod > 0) {
                  mValid = true;
              }
          }
      }
  
      /**
       * This util class determines the 802.11 standard (a/b/g/n/ac) being used
       */
      public static class WifiMode {
          public static final int MODE_UNDEFINED = 0; // Unknown/undefined
          public static final int MODE_11A = 1;       // 802.11a
          public static final int MODE_11B = 2;       // 802.11b
          public static final int MODE_11G = 3;       // 802.11g
          public static final int MODE_11N = 4;       // 802.11n
          public static final int MODE_11AC = 5;      // 802.11ac
          //<TODO> add support for 802.11ad and be more selective instead of defaulting to 11A
  
          /**
           * Use frequency, max supported rate, and the existence of VHT, HT & ERP fields in scan
           * scan result to determine the 802.11 Wifi standard being used.
           */
          public static int determineMode(int frequency, int maxRate, boolean foundVht,
                  boolean foundHt, boolean foundErp) {
              if (foundVht) {
                  return MODE_11AC;
              } else if (foundHt) {
                  return MODE_11N;
              } else if (foundErp) {
                  return MODE_11G;
              } else if (frequency < 3000) {
                  if (maxRate < 24000000) {
                      return MODE_11B;
                  } else {
                      return MODE_11G;
                  }
              } else {
                  return MODE_11A;
              }
          }
  
          /**
           * Map the wifiMode integer to its type, and output as String MODE_11<A/B/G/N/AC>
           */
          public static String toString(int mode) {
              switch(mode) {
                  case MODE_11A:
                      return "MODE_11A";
                  case MODE_11B:
                      return "MODE_11B";
                  case MODE_11G:
                      return "MODE_11G";
                  case MODE_11N:
                      return "MODE_11N";
                  case MODE_11AC:
                      return "MODE_11AC";
                  default:
                      return "MODE_UNDEFINED";
              }
          }
      }
  
      /**
       * Parser for both the Supported Rates & Extended Supported Rates Information Elements
       */
      public static class SupportedRates {
          public static final int MASK = 0x7F; // 0111 1111
          public boolean mValid = false;
          public ArrayList<Integer> mRates;
  
          public SupportedRates() {
              mRates = new ArrayList<Integer>();
          }
  
          /**
           * Is this a valid Supported Rates information element.
           */
          public boolean isValid() {
              return mValid;
          }
  
          /**
           * get the Rate in bits/s from associated byteval
           */
          public static int getRateFromByte(int byteVal) {
              byteVal &= MASK;
              switch(byteVal) {
                  case 2:
                      return 1000000;
                  case 4:
                      return 2000000;
                  case 11:
                      return 5500000;
                  case 12:
                      return 6000000;
                  case 18:
                      return 9000000;
                  case 22:
                      return 11000000;
                  case 24:
                      return 12000000;
                  case 36:
                      return 18000000;
                  case 44:
                      return 22000000;
                  case 48:
                      return 24000000;
                  case 66:
                      return 33000000;
                  case 72:
                      return 36000000;
                  case 96:
                      return 48000000;
                  case 108:
                      return 54000000;
                  default:
                      //ERROR UNKNOWN RATE
                      return -1;
              }
          }
  
          // Supported Rates format (size unit: byte)
          //
          //| ElementID | Length | Supported Rates  [7 Little Endian Info bits - 1 Flag bit]
          //      1          1          1 - 8
          //
          // Note: InformationElement.bytes has 'Element ID' and 'Length'
          //       stripped off already
          //
          public void from(InformationElement ie) {
              mValid = false;
              if (ie == null || ie.bytes == null || ie.bytes.length > 8 || ie.bytes.length < 1)  {
                  return;
              }
              ByteBuffer data = ByteBuffer.wrap(ie.bytes).order(ByteOrder.LITTLE_ENDIAN);
              try {
                  for (int i = 0; i < ie.bytes.length; i++) {
                      int rate = getRateFromByte(data.get());
                      if (rate > 0) {
                          mRates.add(rate);
                      } else {
                          return;
                      }
                  }
              } catch (BufferUnderflowException e) {
                  return;
              }
              mValid = true;
              return;
          }
  
          /**
           * Lists the rates in a human readable string
           */
          public String toString() {
              StringBuilder sbuf = new StringBuilder();
              for (Integer rate : mRates) {
                  sbuf.append(String.format("%.1f", (double) rate / 1000000) + ", ");
              }
              return sbuf.toString();
          }
      }
  }
  