service/java/com/android/server/wifi/hotspot2/SupplicantBridge.java - platform/frameworks/opt/net/wifi - Git at Google

 package com.android.server.wifi.hotspot2;

 import android.util.Log;

 import com.android.server.wifi.ScanDetail;
 import com.android.server.wifi.WifiConfigStore;
 import com.android.server.wifi.WifiNative;
 import com.android.server.wifi.anqp.ANQPElement;
 import com.android.server.wifi.anqp.ANQPFactory;
 import com.android.server.wifi.anqp.Constants;
 import com.android.server.wifi.anqp.eap.AuthParam;
 import com.android.server.wifi.anqp.eap.EAP;
 import com.android.server.wifi.anqp.eap.EAPMethod;
 import com.android.server.wifi.hotspot2.pps.Credential;

 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.StringReader;
 import java.net.ProtocolException;
 import java.nio.BufferUnderflowException;
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
 import java.nio.CharBuffer;
 import java.nio.charset.CharacterCodingException;
 import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;

 public class SupplicantBridge {
     private final WifiNative mSupplicantHook;
     private final WifiConfigStore mConfigStore;
     private final Map<Long, ScanDetail> mRequestMap = new HashMap<>();

     private static final Map<String, Constants.ANQPElementType> sWpsNames = new HashMap<>();

     static {
         sWpsNames.put("anqp_venue_name", Constants.ANQPElementType.ANQPVenueName);
         sWpsNames.put("anqp_network_auth_type", Constants.ANQPElementType.ANQPNwkAuthType);
         sWpsNames.put("anqp_roaming_consortium", Constants.ANQPElementType.ANQPRoamingConsortium);
         sWpsNames.put("anqp_ip_addr_type_availability",
                 Constants.ANQPElementType.ANQPIPAddrAvailability);
         sWpsNames.put("anqp_nai_realm", Constants.ANQPElementType.ANQPNAIRealm);
         sWpsNames.put("anqp_3gpp", Constants.ANQPElementType.ANQP3GPPNetwork);
         sWpsNames.put("anqp_domain_name", Constants.ANQPElementType.ANQPDomName);
         sWpsNames.put("hs20_operator_friendly_name", Constants.ANQPElementType.HSFriendlyName);
         sWpsNames.put("hs20_wan_metrics", Constants.ANQPElementType.HSWANMetrics);
         sWpsNames.put("hs20_connection_capability", Constants.ANQPElementType.HSConnCapability);
         sWpsNames.put("hs20_operating_class", Constants.ANQPElementType.HSOperatingclass);
         sWpsNames.put("hs20_osu_providers_list", Constants.ANQPElementType.HSOSUProviders);
     }

     public static boolean isAnqpAttribute(String line) {
         int split = line.indexOf('=');
         return split >= 0 && sWpsNames.containsKey(line.substring(0, split));
     }

     public SupplicantBridge(WifiNative supplicantHook, WifiConfigStore configStore) {
         mSupplicantHook = supplicantHook;
         mConfigStore = configStore;
     }

     public static Map<Constants.ANQPElementType, ANQPElement> parseANQPLines(List<String> lines) {
         if (lines == null) {
             return null;
         }
         Map<Constants.ANQPElementType, ANQPElement> elements = new HashMap<>(lines.size());
         for (String line : lines) {
             try {
                 ANQPElement element = buildElement(line);
                 if (element != null) {
                     elements.put(element.getID(), element);
                 }
             }
             catch (ProtocolException pe) {
                 Log.e(Utils.hs2LogTag(SupplicantBridge.class), "Failed to parse ANQP: " + pe);
             }
         }
         return elements;
     }

     public void startANQP(ScanDetail scanDetail) {
         String anqpGet = buildWPSQueryRequest(scanDetail.getNetworkDetail());
         synchronized (mRequestMap) {
             mRequestMap.put(scanDetail.getNetworkDetail().getBSSID(), scanDetail);
         }
         String result = mSupplicantHook.doCustomCommand(anqpGet);
         if (result != null && result.startsWith("OK")) {
             Log.d(Utils.hs2LogTag(getClass()), "ANQP initiated on " + scanDetail);
         }
         else {
             Log.d(Utils.hs2LogTag(getClass()), "ANQP failed on " +
                     scanDetail + ": " + result);
         }
     }

     public void notifyANQPDone(Long bssid, boolean success) {
         ScanDetail scanDetail;
         synchronized (mRequestMap) {
             scanDetail = mRequestMap.remove(bssid);
         }
         if (scanDetail == null) {
             Log.d(Utils.hs2LogTag(getClass()), String.format("Spurious %s ANQP response for %012x",
                             success ? "successful" : "failed", bssid));
             return;
         }

         String bssData = mSupplicantHook.scanResult(scanDetail.getBSSIDString());
         try {
             Map<Constants.ANQPElementType, ANQPElement> elements = parseWPSData(bssData);
             Log.d(Utils.hs2LogTag(getClass()), String.format("%s ANQP response for %012x: %s",
                     success ? "successful" : "failed", bssid, elements));
             mConfigStore.notifyANQPResponse(scanDetail, success ? elements : null);
         }
         catch (IOException ioe) {
             Log.e(Utils.hs2LogTag(getClass()), "Failed to parse ANQP: " +
                     ioe.toString() + ": " + bssData);
         }
         catch (RuntimeException rte) {
             Log.e(Utils.hs2LogTag(getClass()), "Failed to parse ANQP: " +
                     rte.toString() + ": " + bssData, rte);
         }
         mConfigStore.notifyANQPResponse(scanDetail, null);
     }

     /*
     public boolean addCredential(HomeSP homeSP, NetworkDetail networkDetail) {
         Credential credential = homeSP.getCredential();
         if (credential == null)
             return false;

         String nwkID = null;
         if (mLastSSID != null) {
             String nwkList = mSupplicantHook.doCustomCommand("LIST_NETWORKS");

             BufferedReader reader = new BufferedReader(new StringReader(nwkList));
             String line;
             try {
                 while ((line = reader.readLine()) != null) {
                     String[] tokens = line.split("\\t");
                     if (tokens.length < 2 || ! Utils.isDecimal(tokens[0])) {
                         continue;
                     }
                     if (unescapeSSID(tokens[1]).equals(mLastSSID)) {
                         nwkID = tokens[0];
                         Log.d("HS2J", "Network " + tokens[0] +
                                 " matches last SSID '" + mLastSSID + "'");
                         break;
                     }
                 }
             }
             catch (IOException ioe) {
                 //
             }
         }

         if (nwkID == null) {
             nwkID = mSupplicantHook.doCustomCommand("ADD_NETWORK");
             Log.d("HS2J", "add_network: '" + nwkID + "'");
             if (! Utils.isDecimal(nwkID)) {
                 return false;
             }
         }

         List<String> credCommand = getWPSNetCommands(nwkID, networkDetail, credential);
         for (String command : credCommand) {
             String status = mSupplicantHook.doCustomCommand(command);
             Log.d("HS2J", "Status of '" + command + "': '" + status + "'");
         }

         if (! networkDetail.getSSID().equals(mLastSSID)) {
             mLastSSID = networkDetail.getSSID();
             PrintWriter out = null;
             try {
                 out = new PrintWriter(new OutputStreamWriter(
                         new FileOutputStream(mLastSSIDFile, false), StandardCharsets.UTF_8));
                 out.println(mLastSSID);
             } catch (IOException ioe) {
             //
             } finally {
                 if (out != null) {
                     out.close();
                 }
             }
         }

         return true;
     }
     */

     private static String escapeSSID(NetworkDetail networkDetail) {
         return escapeString(networkDetail.getSSID(), networkDetail.isSSID_UTF8());
     }

     private static String escapeString(String s, boolean utf8) {
         boolean asciiOnly = true;
         for (int n = 0; n < s.length(); n++) {
             char ch = s.charAt(n);
             if (ch > 127) {
                 asciiOnly = false;
                 break;
             }
         }

         if (asciiOnly) {
             return '"' + s + '"';
         }
         else {
             byte[] octets = s.getBytes(utf8 ? StandardCharsets.UTF_8 : StandardCharsets.ISO_8859_1);

             StringBuilder sb = new StringBuilder();
             for (byte octet : octets) {
                 sb.append(String.format("%02x", octet & Constants.BYTE_MASK));
             }
             return sb.toString();
         }
     }

     private static String buildWPSQueryRequest(NetworkDetail networkDetail) {
         StringBuilder sb = new StringBuilder();
         sb.append("ANQP_GET ").append(networkDetail.getBSSIDString()).append(' ');

         boolean first = true;
         for (Constants.ANQPElementType elementType : ANQPFactory.getBaseANQPSet()) {
             if (networkDetail.getAnqpOICount() == 0 &&
                     elementType == Constants.ANQPElementType.ANQPRoamingConsortium) {
                 continue;
             }
             if (first) {
                 first = false;
             }
             else {
                 sb.append(',');
             }
             sb.append(Constants.getANQPElementID(elementType));
         }
         if (networkDetail.getHSRelease() != null) {
             for (Constants.ANQPElementType elementType : ANQPFactory.getHS20ANQPSet()) {
                 sb.append(",hs20:").append(Constants.getHS20ElementID(elementType));
             }
         }
         return sb.toString();
     }

     private static List<String> getWPSNetCommands(String netID, NetworkDetail networkDetail,
                                                  Credential credential) {

         List<String> commands = new ArrayList<String>();

         EAPMethod eapMethod = credential.getEAPMethod();
         commands.add(String.format("SET_NETWORK %s key_mgmt WPA-EAP", netID));
         commands.add(String.format("SET_NETWORK %s ssid %s", netID, escapeSSID(networkDetail)));
         commands.add(String.format("SET_NETWORK %s bssid %s",
                 netID, networkDetail.getBSSIDString()));
         commands.add(String.format("SET_NETWORK %s eap %s",
                 netID, mapEAPMethodName(eapMethod.getEAPMethodID())));

         AuthParam authParam = credential.getEAPMethod().getAuthParam();
         if (authParam == null) {
             return null;            // TLS or SIM/AKA
         }
         switch (authParam.getAuthInfoID()) {
             case NonEAPInnerAuthType:
             case InnerAuthEAPMethodType:
                 commands.add(String.format("SET_NETWORK %s identity %s",
                         netID, escapeString(credential.getUserName(), true)));
                 commands.add(String.format("SET_NETWORK %s password %s",
                         netID, escapeString(credential.getPassword(), true)));
                 commands.add(String.format("SET_NETWORK %s anonymous_identity \"anonymous\"",
                         netID));
                 break;
             default:                // !!! Needs work.
                 return null;
         }
         commands.add(String.format("SET_NETWORK %s priority 0", netID));
         commands.add(String.format("ENABLE_NETWORK %s", netID));
         commands.add(String.format("SAVE_CONFIG"));
         return commands;
     }

     private static Map<Constants.ANQPElementType, ANQPElement> parseWPSData(String bssInfo)
             throws IOException {
         Map<Constants.ANQPElementType, ANQPElement> elements = new HashMap<>();
         if (bssInfo == null) {
             return elements;
         }
         BufferedReader lineReader = new BufferedReader(new StringReader(bssInfo));
         String line;
         while ((line=lineReader.readLine()) != null) {
             ANQPElement element = buildElement(line);
             if (element != null) {
                 elements.put(element.getID(), element);
             }
         }
         return elements;
     }

     private static ANQPElement buildElement(String text) throws ProtocolException {
         int separator = text.indexOf('=');
         if (separator < 0) {
             return null;
         }

         String elementName = text.substring(0, separator);
         Constants.ANQPElementType elementType = sWpsNames.get(elementName);
         if (elementType == null) {
             return null;
         }

         byte[] payload;
         try {
             payload = Utils.hexToBytes(text.substring(separator + 1));
         }
         catch (NumberFormatException nfe) {
             Log.e(Utils.hs2LogTag(SupplicantBridge.class), "Failed to parse hex string");
             return null;
         }
         return Constants.getANQPElementID(elementType) != null ?
                 ANQPFactory.buildElement(ByteBuffer.wrap(payload), elementType, payload.length) :
                 ANQPFactory.buildHS20Element(elementType,
                         ByteBuffer.wrap(payload).order(ByteOrder.LITTLE_ENDIAN));
     }

     private static String mapEAPMethodName(EAP.EAPMethodID eapMethodID) {
         switch (eapMethodID) {
             case EAP_AKA:
                 return "AKA";
             case EAP_AKAPrim:
                 return "AKA'";  // eap.c:1514
             case EAP_SIM:
                 return "SIM";
             case EAP_TLS:
                 return "TLS";
             case EAP_TTLS:
                 return "TTLS";
             default:
                 throw new IllegalArgumentException("No mapping for " + eapMethodID);
         }
     }

     private static final Map<Character,Integer> sMappings = new HashMap<Character, Integer>();

     static {
         sMappings.put('\\', (int)'\\');
         sMappings.put('"', (int)'"');
         sMappings.put('e', 0x1b);
         sMappings.put('n', (int)'\n');
         sMappings.put('r', (int)'\n');
         sMappings.put('t', (int)'\t');
     }

     public static String unescapeSSID(String ssid) {

         CharIterator chars = new CharIterator(ssid);
         byte[] octets = new byte[ssid.length()];
         int bo = 0;

         while (chars.hasNext()) {
             char ch = chars.next();
             if (ch != '\\' || ! chars.hasNext()) {
                 octets[bo++] = (byte)ch;
             }
             else {
                 char suffix = chars.next();
                 Integer mapped = sMappings.get(suffix);
                 if (mapped != null) {
                     octets[bo++] = mapped.byteValue();
                 }
                 else if (suffix == 'x' && chars.hasDoubleHex()) {
                     octets[bo++] = (byte)chars.nextDoubleHex();
                 }
                 else {
                     octets[bo++] = '\\';
                     octets[bo++] = (byte)suffix;
                 }
             }
         }

         boolean asciiOnly = true;
         for (byte b : octets) {
             if ((b&0x80) != 0) {
                 asciiOnly = false;
                 break;
             }
         }
         if (asciiOnly) {
             return new String(octets, 0, bo, StandardCharsets.UTF_8);
         } else {
             try {
                 // If UTF-8 decoding is successful it is almost certainly UTF-8
                 CharBuffer cb = StandardCharsets.UTF_8.newDecoder().decode(
                         ByteBuffer.wrap(octets, 0, bo));
                 return cb.toString();
             } catch (CharacterCodingException cce) {
                 return new String(octets, 0, bo, StandardCharsets.ISO_8859_1);
             }
         }
     }

     private static class CharIterator {
         private final String mString;
         private int mPosition;
         private int mHex;

         private CharIterator(String s) {
             mString = s;
         }

         private boolean hasNext() {
             return mPosition < mString.length();
         }

         private char next() {
             return mString.charAt(mPosition++);
         }

         private boolean hasDoubleHex() {
             if (mString.length() - mPosition < 2) {
                 return false;
             }
             int nh = Utils.fromHex(mString.charAt(mPosition), true);
             if (nh < 0) {
                 return false;
             }
             int nl = Utils.fromHex(mString.charAt(mPosition + 1), true);
             if (nl < 0) {
                 return false;
             }
             mPosition += 2;
             mHex = (nh << 4) | nl;
             return true;
         }

         private int nextDoubleHex() {
             return mHex;
         }
     }

     private static final String[] TestStrings = {
             "test-ssid",
             "test\\nss\\tid",
             "test\\x2d\\x5f\\nss\\tid",
             "test\\x2d\\x5f\\nss\\tid\\\\",
             "test\\x2d\\x5f\\nss\\tid\\n",
             "test\\x2d\\x5f\\nss\\tid\\x4a",
             "another\\",
             "an\\other",
             "another\\x2"
     };

     public static void main(String[] args) {
         for (String string : TestStrings) {
             System.out.println(unescapeSSID(string));
         }
     }
 }
	package com.android.server.wifi.hotspot2;

	import android.util.Log;

	import com.android.server.wifi.ScanDetail;
	import com.android.server.wifi.WifiConfigStore;
	import com.android.server.wifi.WifiNative;
	import com.android.server.wifi.anqp.ANQPElement;
	import com.android.server.wifi.anqp.ANQPFactory;
	import com.android.server.wifi.anqp.Constants;
	import com.android.server.wifi.anqp.eap.AuthParam;
	import com.android.server.wifi.anqp.eap.EAP;
	import com.android.server.wifi.anqp.eap.EAPMethod;
	import com.android.server.wifi.hotspot2.pps.Credential;

	import java.io.BufferedReader;
	import java.io.IOException;
	import java.io.StringReader;
	import java.net.ProtocolException;
	import java.nio.BufferUnderflowException;
	import java.nio.ByteBuffer;
	import java.nio.ByteOrder;
	import java.nio.CharBuffer;
	import java.nio.charset.CharacterCodingException;
	import java.nio.charset.StandardCharsets;
	import java.util.ArrayList;
	import java.util.HashMap;
	import java.util.List;
	import java.util.Map;

	public class SupplicantBridge {
	private final WifiNative mSupplicantHook;
	private final WifiConfigStore mConfigStore;
	private final Map<Long, ScanDetail> mRequestMap = new HashMap<>();

	private static final Map<String, Constants.ANQPElementType> sWpsNames = new HashMap<>();

	static {
	sWpsNames.put("anqp_venue_name", Constants.ANQPElementType.ANQPVenueName);
	sWpsNames.put("anqp_network_auth_type", Constants.ANQPElementType.ANQPNwkAuthType);
	sWpsNames.put("anqp_roaming_consortium", Constants.ANQPElementType.ANQPRoamingConsortium);
	sWpsNames.put("anqp_ip_addr_type_availability",
	Constants.ANQPElementType.ANQPIPAddrAvailability);
	sWpsNames.put("anqp_nai_realm", Constants.ANQPElementType.ANQPNAIRealm);
	sWpsNames.put("anqp_3gpp", Constants.ANQPElementType.ANQP3GPPNetwork);
	sWpsNames.put("anqp_domain_name", Constants.ANQPElementType.ANQPDomName);
	sWpsNames.put("hs20_operator_friendly_name", Constants.ANQPElementType.HSFriendlyName);
	sWpsNames.put("hs20_wan_metrics", Constants.ANQPElementType.HSWANMetrics);
	sWpsNames.put("hs20_connection_capability", Constants.ANQPElementType.HSConnCapability);
	sWpsNames.put("hs20_operating_class", Constants.ANQPElementType.HSOperatingclass);
	sWpsNames.put("hs20_osu_providers_list", Constants.ANQPElementType.HSOSUProviders);
	}

	public static boolean isAnqpAttribute(String line) {
	int split = line.indexOf('=');
	return split >= 0 && sWpsNames.containsKey(line.substring(0, split));
	}

	public SupplicantBridge(WifiNative supplicantHook, WifiConfigStore configStore) {
	mSupplicantHook = supplicantHook;
	mConfigStore = configStore;
	}

	public static Map<Constants.ANQPElementType, ANQPElement> parseANQPLines(List<String> lines) {
	if (lines == null) {
	return null;
	}
	Map<Constants.ANQPElementType, ANQPElement> elements = new HashMap<>(lines.size());
	for (String line : lines) {
	try {
	ANQPElement element = buildElement(line);
	if (element != null) {
	elements.put(element.getID(), element);
	}
	}
	catch (ProtocolException pe) {
	Log.e(Utils.hs2LogTag(SupplicantBridge.class), "Failed to parse ANQP: " + pe);
	}
	}
	return elements;
	}

	public void startANQP(ScanDetail scanDetail) {
	String anqpGet = buildWPSQueryRequest(scanDetail.getNetworkDetail());
	synchronized (mRequestMap) {
	mRequestMap.put(scanDetail.getNetworkDetail().getBSSID(), scanDetail);
	}
	String result = mSupplicantHook.doCustomCommand(anqpGet);
	if (result != null && result.startsWith("OK")) {
	Log.d(Utils.hs2LogTag(getClass()), "ANQP initiated on " + scanDetail);
	}
	else {
	Log.d(Utils.hs2LogTag(getClass()), "ANQP failed on " +
	scanDetail + ": " + result);
	}
	}

	public void notifyANQPDone(Long bssid, boolean success) {
	ScanDetail scanDetail;
	synchronized (mRequestMap) {
	scanDetail = mRequestMap.remove(bssid);
	}
	if (scanDetail == null) {
	Log.d(Utils.hs2LogTag(getClass()), String.format("Spurious %s ANQP response for %012x",
	success ? "successful" : "failed", bssid));
	return;
	}

	String bssData = mSupplicantHook.scanResult(scanDetail.getBSSIDString());
	try {
	Map<Constants.ANQPElementType, ANQPElement> elements = parseWPSData(bssData);
	Log.d(Utils.hs2LogTag(getClass()), String.format("%s ANQP response for %012x: %s",
	success ? "successful" : "failed", bssid, elements));
	mConfigStore.notifyANQPResponse(scanDetail, success ? elements : null);
	}
	catch (IOException ioe) {
	Log.e(Utils.hs2LogTag(getClass()), "Failed to parse ANQP: " +
	ioe.toString() + ": " + bssData);
	}
	catch (RuntimeException rte) {
	Log.e(Utils.hs2LogTag(getClass()), "Failed to parse ANQP: " +
	rte.toString() + ": " + bssData, rte);
	}
	mConfigStore.notifyANQPResponse(scanDetail, null);
	}

	/*
	public boolean addCredential(HomeSP homeSP, NetworkDetail networkDetail) {
	Credential credential = homeSP.getCredential();
	if (credential == null)
	return false;

	String nwkID = null;
	if (mLastSSID != null) {
	String nwkList = mSupplicantHook.doCustomCommand("LIST_NETWORKS");

	BufferedReader reader = new BufferedReader(new StringReader(nwkList));
	String line;
	try {
	while ((line = reader.readLine()) != null) {
	String[] tokens = line.split("\\t");
	if (tokens.length < 2 \|\| ! Utils.isDecimal(tokens[0])) {
	continue;
	}
	if (unescapeSSID(tokens[1]).equals(mLastSSID)) {
	nwkID = tokens[0];
	Log.d("HS2J", "Network " + tokens[0] +
	" matches last SSID '" + mLastSSID + "'");
	break;
	}
	}
	}
	catch (IOException ioe) {
	//
	}
	}

	if (nwkID == null) {
	nwkID = mSupplicantHook.doCustomCommand("ADD_NETWORK");
	Log.d("HS2J", "add_network: '" + nwkID + "'");
	if (! Utils.isDecimal(nwkID)) {
	return false;
	}
	}

	List<String> credCommand = getWPSNetCommands(nwkID, networkDetail, credential);
	for (String command : credCommand) {
	String status = mSupplicantHook.doCustomCommand(command);
	Log.d("HS2J", "Status of '" + command + "': '" + status + "'");
	}

	if (! networkDetail.getSSID().equals(mLastSSID)) {
	mLastSSID = networkDetail.getSSID();
	PrintWriter out = null;
	try {
	out = new PrintWriter(new OutputStreamWriter(
	new FileOutputStream(mLastSSIDFile, false), StandardCharsets.UTF_8));
	out.println(mLastSSID);
	} catch (IOException ioe) {
	//
	} finally {
	if (out != null) {
	out.close();
	}
	}
	}

	return true;
	}
	*/

	private static String escapeSSID(NetworkDetail networkDetail) {
	return escapeString(networkDetail.getSSID(), networkDetail.isSSID_UTF8());
	}

	private static String escapeString(String s, boolean utf8) {
	boolean asciiOnly = true;
	for (int n = 0; n < s.length(); n++) {
	char ch = s.charAt(n);
	if (ch > 127) {
	asciiOnly = false;
	break;
	}
	}

	if (asciiOnly) {
	return '"' + s + '"';
	}
	else {
	byte[] octets = s.getBytes(utf8 ? StandardCharsets.UTF_8 : StandardCharsets.ISO_8859_1);

	StringBuilder sb = new StringBuilder();
	for (byte octet : octets) {
	sb.append(String.format("%02x", octet & Constants.BYTE_MASK));
	}
	return sb.toString();
	}
	}

	private static String buildWPSQueryRequest(NetworkDetail networkDetail) {
	StringBuilder sb = new StringBuilder();
	sb.append("ANQP_GET ").append(networkDetail.getBSSIDString()).append(' ');

	boolean first = true;
	for (Constants.ANQPElementType elementType : ANQPFactory.getBaseANQPSet()) {
	if (networkDetail.getAnqpOICount() == 0 &&
	elementType == Constants.ANQPElementType.ANQPRoamingConsortium) {
	continue;
	}
	if (first) {
	first = false;
	}
	else {
	sb.append(',');
	}
	sb.append(Constants.getANQPElementID(elementType));
	}
	if (networkDetail.getHSRelease() != null) {
	for (Constants.ANQPElementType elementType : ANQPFactory.getHS20ANQPSet()) {
	sb.append(",hs20:").append(Constants.getHS20ElementID(elementType));
	}
	}
	return sb.toString();
	}

	private static List<String> getWPSNetCommands(String netID, NetworkDetail networkDetail,
	Credential credential) {

	List<String> commands = new ArrayList<String>();

	EAPMethod eapMethod = credential.getEAPMethod();
	commands.add(String.format("SET_NETWORK %s key_mgmt WPA-EAP", netID));
	commands.add(String.format("SET_NETWORK %s ssid %s", netID, escapeSSID(networkDetail)));
	commands.add(String.format("SET_NETWORK %s bssid %s",
	netID, networkDetail.getBSSIDString()));
	commands.add(String.format("SET_NETWORK %s eap %s",
	netID, mapEAPMethodName(eapMethod.getEAPMethodID())));

	AuthParam authParam = credential.getEAPMethod().getAuthParam();
	if (authParam == null) {
	return null; // TLS or SIM/AKA
	}
	switch (authParam.getAuthInfoID()) {
	case NonEAPInnerAuthType:
	case InnerAuthEAPMethodType:
	commands.add(String.format("SET_NETWORK %s identity %s",
	netID, escapeString(credential.getUserName(), true)));
	commands.add(String.format("SET_NETWORK %s password %s",
	netID, escapeString(credential.getPassword(), true)));
	commands.add(String.format("SET_NETWORK %s anonymous_identity \"anonymous\"",
	netID));
	break;
	default: // !!! Needs work.
	return null;
	}
	commands.add(String.format("SET_NETWORK %s priority 0", netID));
	commands.add(String.format("ENABLE_NETWORK %s", netID));
	commands.add(String.format("SAVE_CONFIG"));
	return commands;
	}

	private static Map<Constants.ANQPElementType, ANQPElement> parseWPSData(String bssInfo)
	throws IOException {
	Map<Constants.ANQPElementType, ANQPElement> elements = new HashMap<>();
	if (bssInfo == null) {
	return elements;
	}
	BufferedReader lineReader = new BufferedReader(new StringReader(bssInfo));
	String line;
	while ((line=lineReader.readLine()) != null) {
	ANQPElement element = buildElement(line);
	if (element != null) {
	elements.put(element.getID(), element);
	}
	}
	return elements;
	}

	private static ANQPElement buildElement(String text) throws ProtocolException {
	int separator = text.indexOf('=');
	if (separator < 0) {
	return null;
	}

	String elementName = text.substring(0, separator);
	Constants.ANQPElementType elementType = sWpsNames.get(elementName);
	if (elementType == null) {
	return null;
	}

	byte[] payload;
	try {
	payload = Utils.hexToBytes(text.substring(separator + 1));
	}
	catch (NumberFormatException nfe) {
	Log.e(Utils.hs2LogTag(SupplicantBridge.class), "Failed to parse hex string");
	return null;
	}
	return Constants.getANQPElementID(elementType) != null ?
	ANQPFactory.buildElement(ByteBuffer.wrap(payload), elementType, payload.length) :
	ANQPFactory.buildHS20Element(elementType,
	ByteBuffer.wrap(payload).order(ByteOrder.LITTLE_ENDIAN));
	}

	private static String mapEAPMethodName(EAP.EAPMethodID eapMethodID) {
	switch (eapMethodID) {
	case EAP_AKA:
	return "AKA";
	case EAP_AKAPrim:
	return "AKA'"; // eap.c:1514
	case EAP_SIM:
	return "SIM";
	case EAP_TLS:
	return "TLS";
	case EAP_TTLS:
	return "TTLS";
	default:
	throw new IllegalArgumentException("No mapping for " + eapMethodID);
	}
	}

	private static final Map<Character,Integer> sMappings = new HashMap<Character, Integer>();

	static {
	sMappings.put('\\', (int)'\\');
	sMappings.put('"', (int)'"');
	sMappings.put('e', 0x1b);
	sMappings.put('n', (int)'\n');
	sMappings.put('r', (int)'\n');
	sMappings.put('t', (int)'\t');
	}

	public static String unescapeSSID(String ssid) {

	CharIterator chars = new CharIterator(ssid);
	byte[] octets = new byte[ssid.length()];
	int bo = 0;

	while (chars.hasNext()) {
	char ch = chars.next();
	if (ch != '\\' \|\| ! chars.hasNext()) {
	octets[bo++] = (byte)ch;
	}
	else {
	char suffix = chars.next();
	Integer mapped = sMappings.get(suffix);
	if (mapped != null) {
	octets[bo++] = mapped.byteValue();
	}
	else if (suffix == 'x' && chars.hasDoubleHex()) {
	octets[bo++] = (byte)chars.nextDoubleHex();
	}
	else {
	octets[bo++] = '\\';
	octets[bo++] = (byte)suffix;
	}
	}
	}

	boolean asciiOnly = true;
	for (byte b : octets) {
	if ((b&0x80) != 0) {
	asciiOnly = false;
	break;
	}
	}
	if (asciiOnly) {
	return new String(octets, 0, bo, StandardCharsets.UTF_8);
	} else {
	try {
	// If UTF-8 decoding is successful it is almost certainly UTF-8
	CharBuffer cb = StandardCharsets.UTF_8.newDecoder().decode(
	ByteBuffer.wrap(octets, 0, bo));
	return cb.toString();
	} catch (CharacterCodingException cce) {
	return new String(octets, 0, bo, StandardCharsets.ISO_8859_1);
	}
	}
	}

	private static class CharIterator {
	private final String mString;
	private int mPosition;
	private int mHex;

	private CharIterator(String s) {
	mString = s;
	}

	private boolean hasNext() {
	return mPosition < mString.length();
	}

	private char next() {
	return mString.charAt(mPosition++);
	}

	private boolean hasDoubleHex() {
	if (mString.length() - mPosition < 2) {
	return false;
	}
	int nh = Utils.fromHex(mString.charAt(mPosition), true);
	if (nh < 0) {
	return false;
	}
	int nl = Utils.fromHex(mString.charAt(mPosition + 1), true);
	if (nl < 0) {
	return false;
	}
	mPosition += 2;
	mHex = (nh << 4) \| nl;
	return true;
	}

	private int nextDoubleHex() {
	return mHex;
	}
	}

	private static final String[] TestStrings = {
	"test-ssid",
	"test\\nss\\tid",
	"test\\x2d\\x5f\\nss\\tid",
	"test\\x2d\\x5f\\nss\\tid\\\\",
	"test\\x2d\\x5f\\nss\\tid\\n",
	"test\\x2d\\x5f\\nss\\tid\\x4a",
	"another\\",
	"an\\other",
	"another\\x2"
	};

	public static void main(String[] args) {
	for (String string : TestStrings) {
	System.out.println(unescapeSSID(string));
	}
	}
	}