| /* | |
| * Copyright (C) 2012 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 android.net.wifi; | |
| import android.os.Parcel; | |
| import android.os.Parcelable; | |
| import java.io.ByteArrayOutputStream; | |
| import java.nio.ByteBuffer; | |
| import java.nio.CharBuffer; | |
| import java.nio.charset.Charset; | |
| import java.nio.charset.CharsetDecoder; | |
| import java.nio.charset.CoderResult; | |
| import java.nio.charset.CodingErrorAction; | |
| import java.util.Locale; | |
| /** | |
| * Stores SSID octets and handles conversion. | |
| * | |
| * For Ascii encoded string, any octet < 32 or > 127 is encoded as | |
| * a "\x" followed by the hex representation of the octet. | |
| * Exception chars are ", \, \e, \n, \r, \t which are escaped by a \ | |
| * See src/utils/common.c for the implementation in the supplicant. | |
| * | |
| * @hide | |
| */ | |
| public class WifiSsid implements Parcelable { | |
| private static final String TAG = "WifiSsid"; | |
| public final ByteArrayOutputStream octets = new ByteArrayOutputStream(32); | |
| private static final int HEX_RADIX = 16; | |
| public static final String NONE = "<unknown ssid>"; | |
| private WifiSsid() { | |
| } | |
| public static WifiSsid createFromAsciiEncoded(String asciiEncoded) { | |
| WifiSsid a = new WifiSsid(); | |
| a.convertToBytes(asciiEncoded); | |
| return a; | |
| } | |
| public static WifiSsid createFromHex(String hexStr) { | |
| WifiSsid a = new WifiSsid(); | |
| if (hexStr == null) return a; | |
| if (hexStr.startsWith("0x") || hexStr.startsWith("0X")) { | |
| hexStr = hexStr.substring(2); | |
| } | |
| for (int i = 0; i < hexStr.length()-1; i += 2) { | |
| int val; | |
| try { | |
| val = Integer.parseInt(hexStr.substring(i, i + 2), HEX_RADIX); | |
| } catch(NumberFormatException e) { | |
| val = 0; | |
| } | |
| a.octets.write(val); | |
| } | |
| return a; | |
| } | |
| /* This function is equivalent to printf_decode() at src/utils/common.c in | |
| * the supplicant */ | |
| private void convertToBytes(String asciiEncoded) { | |
| int i = 0; | |
| int val = 0; | |
| while (i< asciiEncoded.length()) { | |
| char c = asciiEncoded.charAt(i); | |
| switch (c) { | |
| case '\\': | |
| i++; | |
| switch(asciiEncoded.charAt(i)) { | |
| case '\\': | |
| octets.write('\\'); | |
| i++; | |
| break; | |
| case '"': | |
| octets.write('"'); | |
| i++; | |
| break; | |
| case 'n': | |
| octets.write('\n'); | |
| i++; | |
| break; | |
| case 'r': | |
| octets.write('\r'); | |
| i++; | |
| break; | |
| case 't': | |
| octets.write('\t'); | |
| i++; | |
| break; | |
| case 'e': | |
| octets.write(27); //escape char | |
| i++; | |
| break; | |
| case 'x': | |
| i++; | |
| try { | |
| val = Integer.parseInt(asciiEncoded.substring(i, i + 2), HEX_RADIX); | |
| } catch (NumberFormatException e) { | |
| val = -1; | |
| } | |
| if (val < 0) { | |
| val = Character.digit(asciiEncoded.charAt(i), HEX_RADIX); | |
| if (val < 0) break; | |
| octets.write(val); | |
| i++; | |
| } else { | |
| octets.write(val); | |
| i += 2; | |
| } | |
| break; | |
| case '0': | |
| case '1': | |
| case '2': | |
| case '3': | |
| case '4': | |
| case '5': | |
| case '6': | |
| case '7': | |
| val = asciiEncoded.charAt(i) - '0'; | |
| i++; | |
| if (asciiEncoded.charAt(i) >= '0' && asciiEncoded.charAt(i) <= '7') { | |
| val = val * 8 + asciiEncoded.charAt(i) - '0'; | |
| i++; | |
| } | |
| if (asciiEncoded.charAt(i) >= '0' && asciiEncoded.charAt(i) <= '7') { | |
| val = val * 8 + asciiEncoded.charAt(i) - '0'; | |
| i++; | |
| } | |
| octets.write(val); | |
| break; | |
| default: | |
| break; | |
| } | |
| break; | |
| default: | |
| octets.write(c); | |
| i++; | |
| break; | |
| } | |
| } | |
| } | |
| @Override | |
| public String toString() { | |
| byte[] ssidBytes = octets.toByteArray(); | |
| // Supplicant returns \x00\x00\x00\x00\x00\x00\x00\x00 hex string | |
| // for a hidden access point. Make sure we maintain the previous | |
| // behavior of returning empty string for this case. | |
| if (octets.size() <= 0 || isArrayAllZeroes(ssidBytes)) return ""; | |
| // TODO: Handle conversion to other charsets upon failure | |
| Charset charset = Charset.forName("UTF-8"); | |
| CharsetDecoder decoder = charset.newDecoder() | |
| .onMalformedInput(CodingErrorAction.REPLACE) | |
| .onUnmappableCharacter(CodingErrorAction.REPLACE); | |
| CharBuffer out = CharBuffer.allocate(32); | |
| CoderResult result = decoder.decode(ByteBuffer.wrap(ssidBytes), out, true); | |
| out.flip(); | |
| if (result.isError()) { | |
| return NONE; | |
| } | |
| return out.toString(); | |
| } | |
| private boolean isArrayAllZeroes(byte[] ssidBytes) { | |
| for (int i = 0; i< ssidBytes.length; i++) { | |
| if (ssidBytes[i] != 0) return false; | |
| } | |
| return true; | |
| } | |
| /** @hide */ | |
| public boolean isHidden() { | |
| return isArrayAllZeroes(octets.toByteArray()); | |
| } | |
| /** @hide */ | |
| public byte[] getOctets() { | |
| return octets.toByteArray(); | |
| } | |
| /** @hide */ | |
| public String getHexString() { | |
| String out = "0x"; | |
| byte[] ssidbytes = getOctets(); | |
| for (int i = 0; i < octets.size(); i++) { | |
| out += String.format(Locale.US, "%02x", ssidbytes[i]); | |
| } | |
| return out; | |
| } | |
| /** Implement the Parcelable interface {@hide} */ | |
| public int describeContents() { | |
| return 0; | |
| } | |
| /** Implement the Parcelable interface {@hide} */ | |
| public void writeToParcel(Parcel dest, int flags) { | |
| dest.writeInt(octets.size()); | |
| dest.writeByteArray(octets.toByteArray()); | |
| } | |
| /** Implement the Parcelable interface {@hide} */ | |
| public static final Creator<WifiSsid> CREATOR = | |
| new Creator<WifiSsid>() { | |
| public WifiSsid createFromParcel(Parcel in) { | |
| WifiSsid ssid = new WifiSsid(); | |
| int length = in.readInt(); | |
| byte b[] = new byte[length]; | |
| in.readByteArray(b); | |
| ssid.octets.write(b, 0, length); | |
| return ssid; | |
| } | |
| public WifiSsid[] newArray(int size) { | |
| return new WifiSsid[size]; | |
| } | |
| }; | |
| } |