blob: 59fbf46964fc02f62c3e6c16d8b1db2d53b63c2c [file] [log] [blame]
/*
* Copyright (C) 2019 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;
import android.content.Context;
import android.net.MacAddress;
import android.net.wifi.SoftApConfiguration;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiMigration;
import android.util.BackupUtils;
import android.util.Log;
import android.util.SparseIntArray;
import com.android.modules.utils.build.SdkLevel;
import com.android.server.wifi.util.ApConfigUtil;
import com.android.server.wifi.util.SettingsMigrationDataHolder;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**
* Class used to backup/restore data using the SettingsBackupAgent.
* There are 2 symmetric API's exposed here:
* 1. retrieveBackupDataFromSoftApConfiguration: Retrieve the configuration data to be backed up.
* 2. retrieveSoftApConfigurationFromBackupData: Restore the configuration using the provided data.
* The byte stream to be backed up is versioned to migrate the data easily across
* revisions.
*/
public class SoftApBackupRestore {
private static final String TAG = "SoftApBackupRestore";
/**
* Current backup data version.
*/
private static final int CURRENT_SAP_BACKUP_DATA_VERSION = 8;
private static final int LAST_SAP_BACKUP_DATA_VERSION_IN_R = 7;
private static final int ETHER_ADDR_LEN = 6; // Byte array size of MacAddress
private final Context mContext;
private final SettingsMigrationDataHolder mSettingsMigrationDataHolder;
public SoftApBackupRestore(Context context,
SettingsMigrationDataHolder settingsMigrationDataHolder) {
mContext = context;
mSettingsMigrationDataHolder = settingsMigrationDataHolder;
}
/**
* Retrieve a byte stream representing the data that needs to be backed up from the
* provided softap configuration.
*
* @param config saved soft ap config that needs to be backed up.
* @return Raw byte stream that needs to be backed up.
*/
public byte[] retrieveBackupDataFromSoftApConfiguration(SoftApConfiguration config) {
if (config == null) {
Log.e(TAG, "Invalid configuration received");
return new byte[0];
}
ByteArrayOutputStream baos = new ByteArrayOutputStream();
try {
DataOutputStream out = new DataOutputStream(baos);
if (SdkLevel.isAtLeastS()) {
out.writeInt(CURRENT_SAP_BACKUP_DATA_VERSION);
} else {
out.writeInt(LAST_SAP_BACKUP_DATA_VERSION_IN_R);
}
BackupUtils.writeString(out, config.getSsid());
out.writeInt(config.getBand());
out.writeInt(config.getChannel());
BackupUtils.writeString(out, config.getPassphrase());
out.writeInt(config.getSecurityType());
out.writeBoolean(config.isHiddenSsid());
out.writeInt(config.getMaxNumberOfClients());
out.writeLong(config.getShutdownTimeoutMillis());
out.writeBoolean(config.isClientControlByUserEnabled());
writeMacAddressList(out, config.getBlockedClientList());
writeMacAddressList(out, config.getAllowedClientList());
out.writeBoolean(config.isAutoShutdownEnabled());
if (SdkLevel.isAtLeastS()) {
out.writeBoolean(config.isBridgedModeOpportunisticShutdownEnabled());
out.writeInt(config.getMacRandomizationSetting());
SparseIntArray channels = config.getChannels();
int numOfChannels = channels.size();
out.writeInt(numOfChannels);
for (int i = 0; i < numOfChannels; i++) {
out.writeInt(channels.keyAt(i));
out.writeInt(channels.valueAt(i));
}
out.writeBoolean(config.isIeee80211axEnabled());
}
} catch (IOException io) {
Log.e(TAG, "Invalid configuration received, IOException " + io);
return new byte[0];
}
return baos.toByteArray();
}
/**
* Parse out the configurations from the back up data.
*
* @param data raw byte stream representing the data.
* @return Soft ap config retrieved from the backed up data.
*/
public SoftApConfiguration retrieveSoftApConfigurationFromBackupData(byte[] data) {
if (data == null || data.length == 0) {
Log.e(TAG, "Invalid backup data received");
return null;
}
SoftApConfiguration.Builder configBuilder = new SoftApConfiguration.Builder();
try {
DataInputStream in = new DataInputStream(new ByteArrayInputStream(data));
int version = in.readInt();
if (version < 1 || version > CURRENT_SAP_BACKUP_DATA_VERSION) {
throw new BackupUtils.BadVersionException("Unknown Backup Serialization Version");
}
if (version == 1) return null; // Version 1 is a bad dataset.
configBuilder.setSsid(BackupUtils.readString(in));
int band;
if (version < 4) {
band = ApConfigUtil.convertWifiConfigBandToSoftApConfigBand(in.readInt());
} else {
band = in.readInt();
}
int channel = in.readInt();
if (channel == 0) {
configBuilder.setBand(band);
} else {
configBuilder.setChannel(channel, band);
}
String passphrase = BackupUtils.readString(in);
int securityType = in.readInt();
if (version < 4 && securityType == WifiConfiguration.KeyMgmt.WPA2_PSK) {
configBuilder.setPassphrase(passphrase, SoftApConfiguration.SECURITY_TYPE_WPA2_PSK);
} else if (version >= 4 && securityType != SoftApConfiguration.SECURITY_TYPE_OPEN) {
configBuilder.setPassphrase(passphrase, securityType);
}
if (version >= 3) {
configBuilder.setHiddenSsid(in.readBoolean());
}
if (version >= 5) {
configBuilder.setMaxNumberOfClients(in.readInt());
if (version >= 7) {
configBuilder.setShutdownTimeoutMillis(in.readLong());
} else {
configBuilder.setShutdownTimeoutMillis(Long.valueOf(in.readInt()));
}
configBuilder.setClientControlByUserEnabled(in.readBoolean());
int numberOfBlockedClient = in.readInt();
List<MacAddress> blockedList = new ArrayList<>(
macAddressListFromByteArray(in, numberOfBlockedClient));
int numberOfAllowedClient = in.readInt();
List<MacAddress> allowedList = new ArrayList<>(
macAddressListFromByteArray(in, numberOfAllowedClient));
configBuilder.setBlockedClientList(blockedList);
configBuilder.setAllowedClientList(allowedList);
}
if (version >= 6) {
configBuilder.setAutoShutdownEnabled(in.readBoolean());
} else {
// Migrate data out of settings.
WifiMigration.SettingsMigrationData migrationData =
mSettingsMigrationDataHolder.retrieveData();
if (migrationData == null) {
Log.e(TAG, "No migration data present");
} else {
configBuilder.setAutoShutdownEnabled(migrationData.isSoftApTimeoutEnabled());
}
}
if (version >= 8 && SdkLevel.isAtLeastS()) {
configBuilder.setBridgedModeOpportunisticShutdownEnabled(in.readBoolean());
configBuilder.setMacRandomizationSetting(in.readInt());
int numOfChannels = in.readInt();
SparseIntArray channels = new SparseIntArray(numOfChannels);
for (int i = 0; i < numOfChannels; i++) {
channels.put(in.readInt(), in.readInt());
}
configBuilder.setChannels(channels);
configBuilder.setIeee80211axEnabled(in.readBoolean());
}
} catch (IOException io) {
Log.e(TAG, "Invalid backup data received, IOException: " + io);
return null;
} catch (BackupUtils.BadVersionException badVersion) {
Log.e(TAG, "Invalid backup data received, BadVersionException: " + badVersion);
return null;
} catch (IllegalArgumentException ie) {
Log.e(TAG, "Invalid backup data received, IllegalArgumentException " + ie);
return null;
}
return configBuilder.build();
}
private void writeMacAddressList(DataOutputStream out, List<MacAddress> macList)
throws IOException {
out.writeInt(macList.size());
Iterator<MacAddress> iterator = macList.iterator();
while (iterator.hasNext()) {
byte[] mac = iterator.next().toByteArray();
out.write(mac, 0, ETHER_ADDR_LEN);
}
}
private List<MacAddress> macAddressListFromByteArray(DataInputStream in, int numberOfClients)
throws IOException {
List<MacAddress> macList = new ArrayList<>();
for (int i = 0; i < numberOfClients; i++) {
byte[] mac = new byte[ETHER_ADDR_LEN];
in.read(mac, 0, ETHER_ADDR_LEN);
macList.add(MacAddress.fromBytes(mac));
}
return macList;
}
}