Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Add IIpClient API for IpClient"

Browse Source 
am: 60b9ad2ec3

Change-Id: I56befc787ef7d25f6e0cd6f2faa523c8f24773c0
This commit is contained in:
Remi NGUYEN VAN
2019-01-21 17:23:32 -08:00
committed by android-build-merger
parent 8898e7c094 60b9ad2ec3
commit e89f53330a
11 changed files with 536 additions and 524 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Android.bp
View File

@@ -844,6 +844,8 @@ aidl_interface {
"core/java/android/net/dhcp/DhcpServingParamsParcel.aidl",
"core/java/android/net/dhcp/IDhcpServer.aidl",
"core/java/android/net/dhcp/IDhcpServerCallbacks.aidl",
"core/java/android/net/ip/IIpClient.aidl",
"core/java/android/net/ip/IIpClientCallbacks.aidl",
"core/java/android/net/ipmemorystore/**/*.aidl",
],
api_dir: "aidl/networkstack",

32
core/java/android/net/ip/IIpClient.aidl Normal file
View File

@@ -0,0 +1,32 @@
/**
* 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 perNmissions and
* limitations under the License.
*/
package android.net.ip;
import android.net.ProxyInfoParcelable;
import android.net.ProvisioningConfigurationParcelable;
/** @hide */
oneway interface IIpClient {
void completedPreDhcpAction();
void confirmConfiguration();
void readPacketFilterComplete(in byte[] data);
void shutdown();
void startProvisioning(in ProvisioningConfigurationParcelable req);
void stop();
void setTcpBufferSizes(in String tcpBufferSizes);
void setHttpProxy(in ProxyInfoParcelable proxyInfo);
void setMulticastFilter(boolean enabled);
}

66
core/java/android/net/ip/IIpClientCallbacks.aidl Normal file
View File

@@ -0,0 +1,66 @@
/**
* 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 perNmissions and
* limitations under the License.
*/
package android.net.ip;
import android.net.LinkPropertiesParcelable;
import android.net.ip.IIpClient;
import android.net.DhcpResultsParcelable;
/** @hide */
oneway interface IIpClientCallbacks {
void onIpClientCreated(in IIpClient ipClient);
void onPreDhcpAction();
void onPostDhcpAction();
// This is purely advisory and not an indication of provisioning
// success or failure. This is only here for callers that want to
// expose DHCPv4 results to other APIs (e.g., WifiInfo#setInetAddress).
// DHCPv4 or static IPv4 configuration failure or success can be
// determined by whether or not the passed-in DhcpResults object is
// null or not.
void onNewDhcpResults(in DhcpResultsParcelable dhcpResults);
void onProvisioningSuccess(in LinkPropertiesParcelable newLp);
void onProvisioningFailure(in LinkPropertiesParcelable newLp);
// Invoked on LinkProperties changes.
void onLinkPropertiesChange(in LinkPropertiesParcelable newLp);
// Called when the internal IpReachabilityMonitor (if enabled) has
// detected the loss of a critical number of required neighbors.
void onReachabilityLost(in String logMsg);
// Called when the IpClient state machine terminates.
void onQuit();
// Install an APF program to filter incoming packets.
void installPacketFilter(in byte[] filter);
// Asynchronously read back the APF program & data buffer from the wifi driver.
// Due to Wifi HAL limitations, the current implementation only supports dumping the entire
// buffer. In response to this request, the driver returns the data buffer asynchronously
// by sending an IpClient#EVENT_READ_PACKET_FILTER_COMPLETE message.
void startReadPacketFilter();
// If multicast filtering cannot be accomplished with APF, this function will be called to
// actuate multicast filtering using another means.
void setFallbackMulticastFilter(boolean enabled);
// Enabled/disable Neighbor Discover offload functionality. This is
// called, for example, whenever 464xlat is being started or stopped.
void setNeighborDiscoveryOffload(boolean enable);
}

119
core/java/android/net/ip/IpClientCallbacks.java Normal file
View File

@@ -0,0 +1,119 @@
/*
* 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 android.net.ip;
import android.net.DhcpResults;
import android.net.LinkProperties;
/**
* Callbacks for handling IpClient events.
*
* This is a convenience class to allow clients not to override all methods of IIpClientCallbacks,
* and avoid unparceling arguments.
* These methods are called asynchronously on a Binder thread, as IpClient lives in a different
* process.
* @hide
*/
public class IpClientCallbacks {
/**
* Callback called upon IpClient creation.
*
* @param ipClient The Binder token to communicate with IpClient.
*/
public void onIpClientCreated(IIpClient ipClient) {}
/**
* Callback called prior to DHCP discovery/renewal.
*
* <p>In order to receive onPreDhcpAction(), call #withPreDhcpAction() when constructing a
* ProvisioningConfiguration.
*
* <p>Implementations of onPreDhcpAction() must call IpClient#completedPreDhcpAction() to
* indicate that DHCP is clear to proceed.
*/
public void onPreDhcpAction() {}
/**
* Callback called after DHCP discovery/renewal.
*/
public void onPostDhcpAction() {}
/**
* Callback called when new DHCP results are available.
*
* <p>This is purely advisory and not an indication of provisioning success or failure. This is
* only here for callers that want to expose DHCPv4 results to other APIs
* (e.g., WifiInfo#setInetAddress).
*
* <p>DHCPv4 or static IPv4 configuration failure or success can be determined by whether or not
* the passed-in DhcpResults object is null.
*/
public void onNewDhcpResults(DhcpResults dhcpResults) {}
/**
* Indicates that provisioning was successful.
*/
public void onProvisioningSuccess(LinkProperties newLp) {}
/**
* Indicates that provisioning failed.
*/
public void onProvisioningFailure(LinkProperties newLp) {}
/**
* Invoked on LinkProperties changes.
*/
public void onLinkPropertiesChange(LinkProperties newLp) {}
/**Called when the internal IpReachabilityMonitor (if enabled) has
* detected the loss of a critical number of required neighbors.
*/
public void onReachabilityLost(String logMsg) {}
/**
* Called when the IpClient state machine terminates.
*/
public void onQuit() {}
/**
* Called to indicate that a new APF program must be installed to filter incoming packets.
*/
public void installPacketFilter(byte[] filter) {}
/**
* Called to indicate that the APF Program & data buffer must be read asynchronously from the
* wifi driver.
*
* <p>Due to Wifi HAL limitations, the current implementation only supports dumping the entire
* buffer. In response to this request, the driver returns the data buffer asynchronously
* by sending an IpClient#EVENT_READ_PACKET_FILTER_COMPLETE message.
*/
public void startReadPacketFilter() {}
/**
* If multicast filtering cannot be accomplished with APF, this function will be called to
* actuate multicast filtering using another means.
*/
public void setFallbackMulticastFilter(boolean enabled) {}
/**
* Enabled/disable Neighbor Discover offload functionality. This is called, for example,
* whenever 464xlat is being started or stopped.
*/
public void setNeighborDiscoveryOffload(boolean enable) {}
}

28
services/net/java/android/net/apf/ApfFilter.java
View File

@@ -16,8 +16,19 @@
package android.net.apf;
import static android.net.util.NetworkConstants.*;
import static android.system.OsConstants.*;
import static android.net.util.NetworkConstants.ICMPV6_ECHO_REQUEST_TYPE;
import static android.net.util.NetworkConstants.ICMPV6_NEIGHBOR_ADVERTISEMENT;
import static android.net.util.NetworkConstants.ICMPV6_ROUTER_ADVERTISEMENT;
import static android.net.util.NetworkConstants.ICMPV6_ROUTER_SOLICITATION;
import static android.system.OsConstants.AF_PACKET;
import static android.system.OsConstants.ARPHRD_ETHER;
import static android.system.OsConstants.ETH_P_ARP;
import static android.system.OsConstants.ETH_P_IP;
import static android.system.OsConstants.ETH_P_IPV6;
import static android.system.OsConstants.IPPROTO_ICMPV6;
import static android.system.OsConstants.IPPROTO_UDP;
import static android.system.OsConstants.SOCK_RAW;
import static com.android.internal.util.BitUtils.bytesToBEInt;
import static com.android.internal.util.BitUtils.getUint16;
import static com.android.internal.util.BitUtils.getUint32;
@@ -34,7 +45,7 @@ import android.net.LinkProperties;
import android.net.NetworkUtils;
import android.net.apf.ApfGenerator.IllegalInstructionException;
import android.net.apf.ApfGenerator.Register;
import android.net.ip.IpClient;
import android.net.ip.IpClientCallbacks;
import android.net.metrics.ApfProgramEvent;
import android.net.metrics.ApfStats;
import android.net.metrics.IpConnectivityLog;
@@ -48,10 +59,14 @@ import android.system.PacketSocketAddress;
import android.text.format.DateUtils;
import android.util.Log;
import android.util.Pair;
import com.android.internal.annotations.GuardedBy;
import com.android.internal.annotations.VisibleForTesting;
import com.android.internal.util.HexDump;
import com.android.internal.util.IndentingPrintWriter;
import libcore.io.IoBridge;
import java.io.FileDescriptor;
import java.io.IOException;
import java.net.Inet4Address;
@@ -63,7 +78,6 @@ import java.nio.BufferUnderflowException;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Arrays;
import libcore.io.IoBridge;
/**
* For networks that support packet filtering via APF programs, {@code ApfFilter}
@@ -308,7 +322,7 @@ public class ApfFilter {
private static final int APF_MAX_ETH_TYPE_BLACK_LIST_LEN = 20;
private final ApfCapabilities mApfCapabilities;
private final IpClient.Callback mIpClientCallback;
private final IpClientCallbacks mIpClientCallback;
private final InterfaceParams mInterfaceParams;
private final IpConnectivityLog mMetricsLog;
@@ -349,7 +363,7 @@ public class ApfFilter {
@VisibleForTesting
ApfFilter(Context context, ApfConfiguration config, InterfaceParams ifParams,
IpClient.Callback ipClientCallback, IpConnectivityLog log) {
IpClientCallbacks ipClientCallback, IpConnectivityLog log) {
mApfCapabilities = config.apfCapabilities;
mIpClientCallback = ipClientCallback;
mInterfaceParams = ifParams;
@@ -1390,7 +1404,7 @@ public class ApfFilter {
* filtering using APF programs.
*/
public static ApfFilter maybeCreate(Context context, ApfConfiguration config,
InterfaceParams ifParams, IpClient.Callback ipClientCallback) {
InterfaceParams ifParams, IpClientCallbacks ipClientCallback) {
if (context == null || config == null || ifParams == null) return null;
ApfCapabilities apfCapabilities = config.apfCapabilities;
if (apfCapabilities == null) return null;

539
services/net/java/android/net/ip/IpClient.java
View File

@@ -16,19 +16,19 @@
package android.net.ip;
import com.android.internal.util.HexDump;
import com.android.internal.util.MessageUtils;
import com.android.internal.util.WakeupMessage;
import static android.net.shared.LinkPropertiesParcelableUtil.fromStableParcelable;
import android.content.Context;
import android.net.DhcpResults;
import android.net.INetd;
import android.net.IpPrefix;
import android.net.LinkAddress;
import android.net.LinkProperties.ProvisioningChange;
import android.net.LinkProperties;
import android.net.LinkProperties.ProvisioningChange;
import android.net.Network;
import android.net.ProvisioningConfigurationParcelable;
import android.net.ProxyInfo;
import android.net.ProxyInfoParcelable;
import android.net.RouteInfo;
import android.net.StaticIpConfiguration;
import android.net.apf.ApfCapabilities;
@@ -36,10 +36,10 @@ import android.net.apf.ApfFilter;
import android.net.dhcp.DhcpClient;
import android.net.metrics.IpConnectivityLog;
import android.net.metrics.IpManagerEvent;
import android.net.shared.InitialConfiguration;
import android.net.util.InterfaceParams;
import android.net.util.MultinetworkPolicyTracker;
import android.net.util.NetdService;
import android.net.util.NetworkConstants;
import android.net.util.SharedLog;
import android.os.ConditionVariable;
import android.os.INetworkManagementService;
@@ -52,29 +52,24 @@ import android.util.LocalLog;
import android.util.Log;
import android.util.SparseArray;
import com.android.internal.annotations.VisibleForTesting;
import com.android.internal.R;
import com.android.internal.annotations.VisibleForTesting;
import com.android.internal.util.ArrayUtils;
import com.android.internal.util.IndentingPrintWriter;
import com.android.internal.util.IState;
import com.android.internal.util.IndentingPrintWriter;
import com.android.internal.util.MessageUtils;
import com.android.internal.util.Preconditions;
import com.android.internal.util.State;
import com.android.internal.util.StateMachine;
import com.android.internal.util.WakeupMessage;
import com.android.server.net.NetlinkTracker;
import java.io.FileDescriptor;
import java.io.PrintWriter;
import java.net.Inet4Address;
import java.net.Inet6Address;
import java.net.InetAddress;
import java.net.SocketException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Objects;
import java.util.List;
import java.util.Set;
import java.util.StringJoiner;
import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CountDownLatch;
import java.util.function.Predicate;
@@ -134,83 +129,17 @@ public class IpClient extends StateMachine {
}
/**
* Callbacks for handling IpClient events.
*
* These methods are called by IpClient on its own thread. Implementations
* of this class MUST NOT carry out long-running computations or hold locks
* for which there might be contention with other code calling public
* methods of the same IpClient instance.
* TODO: remove after migrating clients to use IpClientCallbacks directly
* @see IpClientCallbacks
*/
public static class Callback {
// In order to receive onPreDhcpAction(), call #withPreDhcpAction()
// when constructing a ProvisioningConfiguration.
//
// Implementations of onPreDhcpAction() must call
// IpClient#completedPreDhcpAction() to indicate that DHCP is clear
// to proceed.
public void onPreDhcpAction() {}
public void onPostDhcpAction() {}
public static class Callback extends IpClientCallbacks {}
// This is purely advisory and not an indication of provisioning
// success or failure. This is only here for callers that want to
// expose DHCPv4 results to other APIs (e.g., WifiInfo#setInetAddress).
// DHCPv4 or static IPv4 configuration failure or success can be
// determined by whether or not the passed-in DhcpResults object is
// null or not.
public void onNewDhcpResults(DhcpResults dhcpResults) {}
public void onProvisioningSuccess(LinkProperties newLp) {}
public void onProvisioningFailure(LinkProperties newLp) {}
// Invoked on LinkProperties changes.
public void onLinkPropertiesChange(LinkProperties newLp) {}
// Called when the internal IpReachabilityMonitor (if enabled) has
// detected the loss of a critical number of required neighbors.
public void onReachabilityLost(String logMsg) {}
// Called when the IpClient state machine terminates.
public void onQuit() {}
// Install an APF program to filter incoming packets.
public void installPacketFilter(byte[] filter) {}
// Asynchronously read back the APF program & data buffer from the wifi driver.
// Due to Wifi HAL limitations, the current implementation only supports dumping the entire
// buffer. In response to this request, the driver returns the data buffer asynchronously
// by sending an IpClient#EVENT_READ_PACKET_FILTER_COMPLETE message.
public void startReadPacketFilter() {}
// If multicast filtering cannot be accomplished with APF, this function will be called to
// actuate multicast filtering using another means.
public void setFallbackMulticastFilter(boolean enabled) {}
// Enabled/disable Neighbor Discover offload functionality. This is
// called, for example, whenever 464xlat is being started or stopped.
public void setNeighborDiscoveryOffload(boolean enable) {}
}
public static class WaitForProvisioningCallback extends Callback {
private final ConditionVariable mCV = new ConditionVariable();
private LinkProperties mCallbackLinkProperties;
public LinkProperties waitForProvisioning() {
mCV.block();
return mCallbackLinkProperties;
}
@Override
public void onProvisioningSuccess(LinkProperties newLp) {
mCallbackLinkProperties = newLp;
mCV.open();
}
@Override
public void onProvisioningFailure(LinkProperties newLp) {
mCallbackLinkProperties = null;
mCV.open();
}
}
/**
* TODO: remove once clients are migrated to IpClientUtil.WaitForProvisioningCallback
* @see IpClientUtil.WaitForProvisioningCallbacks
*/
public static class WaitForProvisioningCallback
extends IpClientUtil.WaitForProvisioningCallbacks {}
// Use a wrapper class to log in order to ensure complete and detailed
// logging. This method is lighter weight than annotations/reflection
@@ -232,12 +161,12 @@ public class IpClient extends StateMachine {
// once passed on to the callback they may be modified by another thread.
//
// TODO: Find an lighter weight approach.
private class LoggingCallbackWrapper extends Callback {
private class LoggingCallbackWrapper extends IpClientCallbacks {
private static final String PREFIX = "INVOKE ";
private final Callback mCallback;
private final IpClientCallbacks mCallback;
public LoggingCallbackWrapper(Callback callback) {
mCallback = (callback != null) ? callback : new Callback();
LoggingCallbackWrapper(IpClientCallbacks callback) {
mCallback = (callback != null) ? callback : new IpClientCallbacks();
}
private void log(String msg) {
@@ -307,288 +236,102 @@ public class IpClient extends StateMachine {
}
/**
* This class encapsulates parameters to be passed to
* IpClient#startProvisioning(). A defensive copy is made by IpClient
* and the values specified herein are in force until IpClient#stop()
* is called.
*
* Example use:
*
* final ProvisioningConfiguration config =
* mIpClient.buildProvisioningConfiguration()
* .withPreDhcpAction()
* .withProvisioningTimeoutMs(36 * 1000)
* .build();
* mIpClient.startProvisioning(config);
* ...
* mIpClient.stop();
*
* The specified provisioning configuration will only be active until
* IpClient#stop() is called. Future calls to IpClient#startProvisioning()
* must specify the configuration again.
* TODO: remove after migrating clients to use the shared configuration class directly.
* @see android.net.shared.ProvisioningConfiguration
*/
public static class ProvisioningConfiguration {
// TODO: Delete this default timeout once those callers that care are
// fixed to pass in their preferred timeout.
//
// We pick 36 seconds so we can send DHCP requests at
//
// t=0, t=2, t=6, t=14, t=30
//
// allowing for 10% jitter.
private static final int DEFAULT_TIMEOUT_MS = 36 * 1000;
public static class Builder {
private ProvisioningConfiguration mConfig = new ProvisioningConfiguration();
public Builder withoutIPv4() {
mConfig.mEnableIPv4 = false;
return this;
}
public Builder withoutIPv6() {
mConfig.mEnableIPv6 = false;
return this;
}
public Builder withoutMultinetworkPolicyTracker() {
mConfig.mUsingMultinetworkPolicyTracker = false;
return this;
}
public Builder withoutIpReachabilityMonitor() {
mConfig.mUsingIpReachabilityMonitor = false;
return this;
}
public Builder withPreDhcpAction() {
mConfig.mRequestedPreDhcpActionMs = DEFAULT_TIMEOUT_MS;
return this;
}
public Builder withPreDhcpAction(int dhcpActionTimeoutMs) {
mConfig.mRequestedPreDhcpActionMs = dhcpActionTimeoutMs;
return this;
}
public Builder withInitialConfiguration(InitialConfiguration initialConfig) {
mConfig.mInitialConfig = initialConfig;
return this;
}
public Builder withStaticConfiguration(StaticIpConfiguration staticConfig) {
mConfig.mStaticIpConfig = staticConfig;
return this;
}
public Builder withApfCapabilities(ApfCapabilities apfCapabilities) {
mConfig.mApfCapabilities = apfCapabilities;
return this;
}
public Builder withProvisioningTimeoutMs(int timeoutMs) {
mConfig.mProvisioningTimeoutMs = timeoutMs;
return this;
}
public Builder withRandomMacAddress() {
mConfig.mIPv6AddrGenMode = INetd.IPV6_ADDR_GEN_MODE_EUI64;
return this;
}
public Builder withStableMacAddress() {
mConfig.mIPv6AddrGenMode = INetd.IPV6_ADDR_GEN_MODE_STABLE_PRIVACY;
return this;
}
public Builder withNetwork(Network network) {
mConfig.mNetwork = network;
return this;
}
public Builder withDisplayName(String displayName) {
mConfig.mDisplayName = displayName;
return this;
}
public ProvisioningConfiguration build() {
return new ProvisioningConfiguration(mConfig);
}
}
/* package */ boolean mEnableIPv4 = true;
/* package */ boolean mEnableIPv6 = true;
/* package */ boolean mUsingMultinetworkPolicyTracker = true;
/* package */ boolean mUsingIpReachabilityMonitor = true;
/* package */ int mRequestedPreDhcpActionMs;
/* package */ InitialConfiguration mInitialConfig;
/* package */ StaticIpConfiguration mStaticIpConfig;
/* package */ ApfCapabilities mApfCapabilities;
/* package */ int mProvisioningTimeoutMs = DEFAULT_TIMEOUT_MS;
/* package */ int mIPv6AddrGenMode = INetd.IPV6_ADDR_GEN_MODE_STABLE_PRIVACY;
/* package */ Network mNetwork = null;
/* package */ String mDisplayName = null;
public ProvisioningConfiguration() {} // used by Builder
public ProvisioningConfiguration(ProvisioningConfiguration other) {
mEnableIPv4 = other.mEnableIPv4;
mEnableIPv6 = other.mEnableIPv6;
mUsingMultinetworkPolicyTracker = other.mUsingMultinetworkPolicyTracker;
mUsingIpReachabilityMonitor = other.mUsingIpReachabilityMonitor;
mRequestedPreDhcpActionMs = other.mRequestedPreDhcpActionMs;
mInitialConfig = InitialConfiguration.copy(other.mInitialConfig);
mStaticIpConfig = other.mStaticIpConfig;
mApfCapabilities = other.mApfCapabilities;
mProvisioningTimeoutMs = other.mProvisioningTimeoutMs;
mIPv6AddrGenMode = other.mIPv6AddrGenMode;
mNetwork = other.mNetwork;
mDisplayName = other.mDisplayName;
}
@Override
public String toString() {
return new StringJoiner(", ", getClass().getSimpleName() + "{", "}")
.add("mEnableIPv4: " + mEnableIPv4)
.add("mEnableIPv6: " + mEnableIPv6)
.add("mUsingMultinetworkPolicyTracker: " + mUsingMultinetworkPolicyTracker)
.add("mUsingIpReachabilityMonitor: " + mUsingIpReachabilityMonitor)
.add("mRequestedPreDhcpActionMs: " + mRequestedPreDhcpActionMs)
.add("mInitialConfig: " + mInitialConfig)
.add("mStaticIpConfig: " + mStaticIpConfig)
.add("mApfCapabilities: " + mApfCapabilities)
.add("mProvisioningTimeoutMs: " + mProvisioningTimeoutMs)
.add("mIPv6AddrGenMode: " + mIPv6AddrGenMode)
.add("mNetwork: " + mNetwork)
.add("mDisplayName: " + mDisplayName)
.toString();
}
public boolean isValid() {
return (mInitialConfig == null) || mInitialConfig.isValid();
}
}
public static class InitialConfiguration {
public final Set<LinkAddress> ipAddresses = new HashSet<>();
public final Set<IpPrefix> directlyConnectedRoutes = new HashSet<>();
public final Set<InetAddress> dnsServers = new HashSet<>();
public Inet4Address gateway; // WiFi legacy behavior with static ipv4 config
public static InitialConfiguration copy(InitialConfiguration config) {
if (config == null) {
return null;
}
InitialConfiguration configCopy = new InitialConfiguration();
configCopy.ipAddresses.addAll(config.ipAddresses);
configCopy.directlyConnectedRoutes.addAll(config.directlyConnectedRoutes);
configCopy.dnsServers.addAll(config.dnsServers);
return configCopy;
}
@Override
public String toString() {
return String.format(
"InitialConfiguration(IPs: {%s}, prefixes: {%s}, DNS: {%s}, v4 gateway: %s)",
join(", ", ipAddresses), join(", ", directlyConnectedRoutes),
join(", ", dnsServers), gateway);
}
public boolean isValid() {
if (ipAddresses.isEmpty()) {
return false;
}
// For every IP address, there must be at least one prefix containing that address.
for (LinkAddress addr : ipAddresses) {
if (!any(directlyConnectedRoutes, (p) -> p.contains(addr.getAddress()))) {
return false;
}
}
// For every dns server, there must be at least one prefix containing that address.
for (InetAddress addr : dnsServers) {
if (!any(directlyConnectedRoutes, (p) -> p.contains(addr))) {
return false;
}
}
// All IPv6 LinkAddresses have an RFC7421-suitable prefix length
// (read: compliant with RFC4291#section2.5.4).
if (any(ipAddresses, not(InitialConfiguration::isPrefixLengthCompliant))) {
return false;
}
// If directlyConnectedRoutes contains an IPv6 default route
// then ipAddresses MUST contain at least one non-ULA GUA.
if (any(directlyConnectedRoutes, InitialConfiguration::isIPv6DefaultRoute)
&& all(ipAddresses, not(InitialConfiguration::isIPv6GUA))) {
return false;
}
// The prefix length of routes in directlyConnectedRoutes be within reasonable
// bounds for IPv6: /48-/64 just as we’d accept in RIOs.
if (any(directlyConnectedRoutes, not(InitialConfiguration::isPrefixLengthCompliant))) {
return false;
}
// There no more than one IPv4 address
if (ipAddresses.stream().filter(LinkAddress::isIPv4).count() > 1) {
return false;
}
return true;
public static class ProvisioningConfiguration
extends android.net.shared.ProvisioningConfiguration {
public ProvisioningConfiguration(android.net.shared.ProvisioningConfiguration other) {
super(other);
}
/**
* @return true if the given list of addressess and routes satisfies provisioning for this
* InitialConfiguration. LinkAddresses and RouteInfo objects are not compared with equality
* because addresses and routes seen by Netlink will contain additional fields like flags,
* interfaces, and so on. If this InitialConfiguration has no IP address specified, the
* provisioning check always fails.
*
* If the given list of routes is null, only addresses are taken into considerations.
* @see android.net.shared.ProvisioningConfiguration.Builder
*/
public boolean isProvisionedBy(List<LinkAddress> addresses, List<RouteInfo> routes) {
if (ipAddresses.isEmpty()) {
return false;
public static class Builder extends android.net.shared.ProvisioningConfiguration.Builder {
// Override all methods to have a return type matching this Builder
@Override
public Builder withoutIPv4() {
super.withoutIPv4();
return this;
}
for (LinkAddress addr : ipAddresses) {
if (!any(addresses, (addrSeen) -> addr.isSameAddressAs(addrSeen))) {
return false;
}
@Override
public Builder withoutIPv6() {
super.withoutIPv6();
return this;
}
if (routes != null) {
for (IpPrefix prefix : directlyConnectedRoutes) {
if (!any(routes, (routeSeen) -> isDirectlyConnectedRoute(routeSeen, prefix))) {
return false;
}
}
@Override
public Builder withoutMultinetworkPolicyTracker() {
super.withoutMultinetworkPolicyTracker();
return this;
}
return true;
}
@Override
public Builder withoutIpReachabilityMonitor() {
super.withoutIpReachabilityMonitor();
return this;
}
private static boolean isDirectlyConnectedRoute(RouteInfo route, IpPrefix prefix) {
return !route.hasGateway() && prefix.equals(route.getDestination());
}
@Override
public Builder withPreDhcpAction() {
super.withPreDhcpAction();
return this;
}
private static boolean isPrefixLengthCompliant(LinkAddress addr) {
return addr.isIPv4() || isCompliantIPv6PrefixLength(addr.getPrefixLength());
}
@Override
public Builder withPreDhcpAction(int dhcpActionTimeoutMs) {
super.withPreDhcpAction(dhcpActionTimeoutMs);
return this;
}
private static boolean isPrefixLengthCompliant(IpPrefix prefix) {
return prefix.isIPv4() || isCompliantIPv6PrefixLength(prefix.getPrefixLength());
}
@Override
public Builder withStaticConfiguration(StaticIpConfiguration staticConfig) {
super.withStaticConfiguration(staticConfig);
return this;
}
private static boolean isCompliantIPv6PrefixLength(int prefixLength) {
return (NetworkConstants.RFC6177_MIN_PREFIX_LENGTH <= prefixLength)
&& (prefixLength <= NetworkConstants.RFC7421_PREFIX_LENGTH);
}
@Override
public Builder withApfCapabilities(ApfCapabilities apfCapabilities) {
super.withApfCapabilities(apfCapabilities);
return this;
}
private static boolean isIPv6DefaultRoute(IpPrefix prefix) {
return prefix.getAddress().equals(Inet6Address.ANY);
}
@Override
public Builder withProvisioningTimeoutMs(int timeoutMs) {
super.withProvisioningTimeoutMs(timeoutMs);
return this;
}
private static boolean isIPv6GUA(LinkAddress addr) {
return addr.isIPv6() && addr.isGlobalPreferred();
@Override
public Builder withRandomMacAddress() {
super.withRandomMacAddress();
return this;
}
@Override
public Builder withStableMacAddress() {
super.withStableMacAddress();
return this;
}
@Override
public Builder withNetwork(Network network) {
super.withNetwork(network);
return this;
}
@Override
public Builder withDisplayName(String displayName) {
super.withDisplayName(displayName);
return this;
}
@Override
public ProvisioningConfiguration build() {
return new ProvisioningConfiguration(mConfig);
}
}
}
@@ -638,7 +381,7 @@ public class IpClient extends StateMachine {
private final String mInterfaceName;
private final String mClatInterfaceName;
@VisibleForTesting
protected final Callback mCallback;
protected final IpClientCallbacks mCallback;
private final Dependencies mDependencies;
private final CountDownLatch mShutdownLatch;
private final INetworkManagementService mNwService;
@@ -657,7 +400,7 @@ public class IpClient extends StateMachine {
* Non-final member variables accessed only from within our StateMachine.
*/
private LinkProperties mLinkProperties;
private ProvisioningConfiguration mConfiguration;
private android.net.shared.ProvisioningConfiguration mConfiguration;
private MultinetworkPolicyTracker mMultinetworkPolicyTracker;
private IpReachabilityMonitor mIpReachabilityMonitor;
private DhcpClient mDhcpClient;
@@ -691,7 +434,7 @@ public class IpClient extends StateMachine {
}
}
public IpClient(Context context, String ifName, Callback callback) {
public IpClient(Context context, String ifName, IpClientCallbacks callback) {
this(context, ifName, callback, new Dependencies());
}
@@ -699,7 +442,7 @@ public class IpClient extends StateMachine {
* An expanded constructor, useful for dependency injection.
* TODO: migrate all test users to mock IpClient directly and remove this ctor.
*/
public IpClient(Context context, String ifName, Callback callback,
public IpClient(Context context, String ifName, IpClientCallbacks callback,
INetworkManagementService nwService) {
this(context, ifName, callback, new Dependencies() {
@Override
@@ -708,7 +451,7 @@ public class IpClient extends StateMachine {
}
@VisibleForTesting
IpClient(Context context, String ifName, Callback callback, Dependencies deps) {
IpClient(Context context, String ifName, IpClientCallbacks callback, Dependencies deps) {
super(IpClient.class.getSimpleName() + "." + ifName);
Preconditions.checkNotNull(ifName);
Preconditions.checkNotNull(callback);
@@ -795,6 +538,57 @@ public class IpClient extends StateMachine {
startStateMachineUpdaters();
}
/**
* Make a IIpClient connector to communicate with this IpClient.
*/
public IIpClient makeConnector() {
return new IpClientConnector();
}
class IpClientConnector extends IIpClient.Stub {
@Override
public void completedPreDhcpAction() {
IpClient.this.completedPreDhcpAction();
}
@Override
public void confirmConfiguration() {
IpClient.this.confirmConfiguration();
}
@Override
public void readPacketFilterComplete(byte[] data) {
IpClient.this.readPacketFilterComplete(data);
}
@Override
public void shutdown() {
IpClient.this.shutdown();
}
@Override
public void startProvisioning(ProvisioningConfigurationParcelable req) {
IpClient.this.startProvisioning(
android.net.shared.ProvisioningConfiguration.fromStableParcelable(req));
}
@Override
public void stop() {
IpClient.this.stop();
}
@Override
public void setTcpBufferSizes(String tcpBufferSizes) {
IpClient.this.setTcpBufferSizes(tcpBufferSizes);
}
@Override
public void setHttpProxy(ProxyInfoParcelable proxyInfo) {
IpClient.this.setHttpProxy(fromStableParcelable(proxyInfo));
}
@Override
public void setMulticastFilter(boolean enabled) {
IpClient.this.setMulticastFilter(enabled);
}
// TODO: remove and have IpClient logs dumped in NetworkStack dumpsys
public void dumpIpClientLogs(FileDescriptor fd, PrintWriter pw, String[] args) {
IpClient.this.dump(fd, pw, args);
}
}
private void configureAndStartStateMachine() {
addState(mStoppedState);
addState(mStartedState);
@@ -828,7 +622,9 @@ public class IpClient extends StateMachine {
mShutdownLatch.countDown();
}
// Shut down this IpClient instance altogether.
/**
* Shut down this IpClient instance altogether.
*/
public void shutdown() {
stop();
sendMessage(CMD_TERMINATE_AFTER_STOP);
@@ -849,7 +645,10 @@ public class IpClient extends StateMachine {
return new ProvisioningConfiguration.Builder();
}
public void startProvisioning(ProvisioningConfiguration req) {
/**
* Start provisioning with the provided parameters.
*/
public void startProvisioning(android.net.shared.ProvisioningConfiguration req) {
if (!req.isValid()) {
doImmediateProvisioningFailure(IpManagerEvent.ERROR_INVALID_PROVISIONING);
return;
@@ -863,7 +662,7 @@ public class IpClient extends StateMachine {
}
mCallback.setNeighborDiscoveryOffload(true);
sendMessage(CMD_START, new ProvisioningConfiguration(req));
sendMessage(CMD_START, new android.net.shared.ProvisioningConfiguration(req));
}
// TODO: Delete this.
@@ -874,7 +673,7 @@ public class IpClient extends StateMachine {
}
public void startProvisioning() {
startProvisioning(new ProvisioningConfiguration());
startProvisioning(new android.net.shared.ProvisioningConfiguration());
}
public void stop() {
@@ -930,7 +729,7 @@ public class IpClient extends StateMachine {
// Thread-unsafe access to mApfFilter but just used for debugging.
final ApfFilter apfFilter = mApfFilter;
final ProvisioningConfiguration provisioningConfig = mConfiguration;
final android.net.shared.ProvisioningConfiguration provisioningConfig = mConfiguration;
final ApfCapabilities apfCapabilities = (provisioningConfig != null)
? provisioningConfig.mApfCapabilities : null;
@@ -1463,7 +1262,7 @@ public class IpClient extends StateMachine {
break;
case CMD_START:
mConfiguration = (ProvisioningConfiguration) msg.obj;
mConfiguration = (android.net.shared.ProvisioningConfiguration) msg.obj;
transitionTo(mStartedState);
break;

92
services/net/java/android/net/ip/IpClientUtil.java Normal file
View File

@@ -0,0 +1,92 @@
/*
* 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 android.net.ip;
import android.content.Context;
import android.net.LinkProperties;
import android.os.ConditionVariable;
import java.io.FileDescriptor;
import java.io.PrintWriter;
/**
* Utilities and wrappers to simplify communication with IpClient, which lives in the NetworkStack
* process.
*
* @hide
*/
public class IpClientUtil {
// TODO: remove once IpClient dumps are moved to NetworkStack and callers don't need this arg
public static final String DUMP_ARG = IpClient.DUMP_ARG;
/**
* Subclass of {@link IpClientCallbacks} allowing clients to block until provisioning is
* complete with {@link WaitForProvisioningCallbacks#waitForProvisioning()}.
*/
public static class WaitForProvisioningCallbacks extends IpClientCallbacks {
private final ConditionVariable mCV = new ConditionVariable();
private LinkProperties mCallbackLinkProperties;
/**
* Block until either {@link #onProvisioningSuccess(LinkProperties)} or
* {@link #onProvisioningFailure(LinkProperties)} is called.
*/
public LinkProperties waitForProvisioning() {
mCV.block();
return mCallbackLinkProperties;
}
@Override
public void onProvisioningSuccess(LinkProperties newLp) {
mCallbackLinkProperties = newLp;
mCV.open();
}
@Override
public void onProvisioningFailure(LinkProperties newLp) {
mCallbackLinkProperties = null;
mCV.open();
}
}
/**
* Create a new IpClient.
*
* <p>This is a convenience method to allow clients to use {@link IpClientCallbacks} instead of
* {@link IIpClientCallbacks}.
*/
public static void makeIpClient(Context context, String ifName, IpClientCallbacks callback) {
// TODO: request IpClient asynchronously from NetworkStack.
final IpClient ipClient = new IpClient(context, ifName, callback);
callback.onIpClientCreated(ipClient.makeConnector());
}
/**
* Dump logs for the specified IpClient.
* TODO: remove logging from this method once IpClient logs are dumped in NetworkStack dumpsys,
* then remove callers and delete.
*/
public static void dumpIpClient(
IIpClient connector, FileDescriptor fd, PrintWriter pw, String[] args) {
if (!(connector instanceof IpClient.IpClientConnector)) {
pw.println("Invalid connector");
return;
}
((IpClient.IpClientConnector) connector).dumpIpClientLogs(fd, pw, args);
}
}

124
services/net/java/android/net/ip/IpManager.java
View File

@@ -1,124 +0,0 @@
/*
* Copyright (C) 2017 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.ip;
import android.content.Context;
import android.net.INetd;
import android.net.LinkProperties;
import android.net.Network;
import android.net.StaticIpConfiguration;
import android.net.apf.ApfCapabilities;
import android.net.util.NetdService;
import android.os.INetworkManagementService;
import android.os.ServiceManager;
import android.net.apf.ApfCapabilities;
import com.android.internal.annotations.VisibleForTesting;
/*
* TODO: Delete this altogether in favor of its renamed successor: IpClient.
*
* @hide
*/
public class IpManager extends IpClient {
public static class ProvisioningConfiguration extends IpClient.ProvisioningConfiguration {
public ProvisioningConfiguration(IpClient.ProvisioningConfiguration ipcConfig) {
super(ipcConfig);
}
public static class Builder extends IpClient.ProvisioningConfiguration.Builder {
@Override
public Builder withoutIPv4() {
super.withoutIPv4();
return this;
}
@Override
public Builder withoutIPv6() {
super.withoutIPv6();
return this;
}
@Override
public Builder withoutIpReachabilityMonitor() {
super.withoutIpReachabilityMonitor();
return this;
}
@Override
public Builder withPreDhcpAction() {
super.withPreDhcpAction();
return this;
}
@Override
public Builder withPreDhcpAction(int dhcpActionTimeoutMs) {
super.withPreDhcpAction(dhcpActionTimeoutMs);
return this;
}
// No Override; locally defined type.
public Builder withInitialConfiguration(InitialConfiguration initialConfig) {
super.withInitialConfiguration((IpClient.InitialConfiguration) initialConfig);
return this;
}
@Override
public Builder withStaticConfiguration(StaticIpConfiguration staticConfig) {
super.withStaticConfiguration(staticConfig);
return this;
}
@Override
public Builder withApfCapabilities(ApfCapabilities apfCapabilities) {
super.withApfCapabilities(apfCapabilities);
return this;
}
@Override
public Builder withProvisioningTimeoutMs(int timeoutMs) {
super.withProvisioningTimeoutMs(timeoutMs);
return this;
}
@Override
public Builder withNetwork(Network network) {
super.withNetwork(network);
return this;
}
@Override
public Builder withDisplayName(String displayName) {
super.withDisplayName(displayName);
return this;
}
@Override
public ProvisioningConfiguration build() {
return new ProvisioningConfiguration(super.build());
}
}
}
public static ProvisioningConfiguration.Builder buildProvisioningConfiguration() {
return new ProvisioningConfiguration.Builder();
}
public static class InitialConfiguration extends IpClient.InitialConfiguration {
}
public static class Callback extends IpClient.Callback {
}
public IpManager(Context context, String ifName, Callback callback) {
super(context, ifName, callback);
}
public void startProvisioning(ProvisioningConfiguration req) {
super.startProvisioning((IpClient.ProvisioningConfiguration) req);
}
}

1
services/net/java/android/net/shared/ProvisioningConfiguration.java
View File

@@ -22,6 +22,7 @@ import android.net.Network;
import android.net.ProvisioningConfigurationParcelable;
import android.net.StaticIpConfiguration;
import android.net.apf.ApfCapabilities;
import android.net.ip.IIpClient;
import java.util.Objects;
import java.util.StringJoiner;

43
tests/net/java/android/net/apf/ApfTest.java
View File

@@ -16,10 +16,19 @@
package android.net.apf;
import static android.net.util.NetworkConstants.*;
import static android.system.OsConstants.*;
import static android.net.util.NetworkConstants.ICMPV6_ECHO_REQUEST_TYPE;
import static android.net.util.NetworkConstants.ICMPV6_ROUTER_ADVERTISEMENT;
import static android.system.OsConstants.AF_UNIX;
import static android.system.OsConstants.ARPHRD_ETHER;
import static android.system.OsConstants.ETH_P_ARP;
import static android.system.OsConstants.ETH_P_IP;
import static android.system.OsConstants.ETH_P_IPV6;
import static android.system.OsConstants.IPPROTO_ICMPV6;
import static android.system.OsConstants.IPPROTO_UDP;
import static android.system.OsConstants.SOCK_STREAM;
import static com.android.internal.util.BitUtils.bytesToBEInt;
import static com.android.internal.util.BitUtils.put;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
@@ -33,7 +42,7 @@ import android.net.LinkProperties;
import android.net.apf.ApfFilter.ApfConfiguration;
import android.net.apf.ApfGenerator.IllegalInstructionException;
import android.net.apf.ApfGenerator.Register;
import android.net.ip.IpClient;
import android.net.ip.IpClientCallbacks;
import android.net.metrics.IpConnectivityLog;
import android.net.metrics.RaEvent;
import android.net.util.InterfaceParams;
@@ -47,8 +56,20 @@ import android.system.ErrnoException;
import android.system.Os;
import android.text.format.DateUtils;
import android.util.Log;
import com.android.frameworks.tests.net.R;
import com.android.internal.util.HexDump;
import libcore.io.IoUtils;
import libcore.io.Streams;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import java.io.File;
import java.io.FileDescriptor;
import java.io.FileOutputStream;
@@ -59,14 +80,6 @@ import java.net.InetAddress;
import java.nio.ByteBuffer;
import java.util.List;
import java.util.Random;
import libcore.io.IoUtils;
import libcore.io.Streams;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
/**
* Tests for APF program generator and interpreter.
@@ -902,7 +915,7 @@ public class ApfTest {
HexDump.toHexString(data, false), result);
}
private class MockIpClientCallback extends IpClient.Callback {
private class MockIpClientCallback extends IpClientCallbacks {
private final ConditionVariable mGotApfProgram = new ConditionVariable();
private byte[] mLastApfProgram;
@@ -933,7 +946,7 @@ public class ApfTest {
private final long mFixedTimeMs = SystemClock.elapsedRealtime();
public TestApfFilter(Context context, ApfConfiguration config,
IpClient.Callback ipClientCallback, IpConnectivityLog log) throws Exception {
IpClientCallbacks ipClientCallback, IpConnectivityLog log) throws Exception {
super(context, config, InterfaceParams.getByName("lo"), ipClientCallback, log);
}
@@ -1062,7 +1075,7 @@ public class ApfTest {
private static final byte[] IPV4_ANY_HOST_ADDR = {0, 0, 0, 0};
// Helper to initialize a default apfFilter.
private ApfFilter setupApfFilter(IpClient.Callback ipClientCallback, ApfConfiguration config)
private ApfFilter setupApfFilter(IpClientCallbacks ipClientCallback, ApfConfiguration config)
throws Exception {
LinkAddress link = new LinkAddress(InetAddress.getByAddress(MOCK_IPV4_ADDR), 19);
LinkProperties lp = new LinkProperties();

14
tests/net/java/android/net/ip/IpClientTest.java
View File

@@ -23,7 +23,6 @@ import static org.junit.Assert.fail;
import static org.mockito.Mockito.any;
import static org.mockito.Mockito.anyString;
import static org.mockito.Mockito.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.reset;
import static org.mockito.Mockito.timeout;
@@ -40,9 +39,8 @@ import android.net.LinkAddress;
import android.net.LinkProperties;
import android.net.MacAddress;
import android.net.RouteInfo;
import android.net.ip.IpClient.Callback;
import android.net.ip.IpClient.InitialConfiguration;
import android.net.ip.IpClient.ProvisioningConfiguration;
import android.net.shared.InitialConfiguration;
import android.net.shared.ProvisioningConfiguration;
import android.net.util.InterfaceParams;
import android.os.INetworkManagementService;
import android.provider.Settings;
@@ -50,8 +48,8 @@ import android.support.test.filters.SmallTest;
import android.support.test.runner.AndroidJUnit4;
import android.test.mock.MockContentResolver;
import com.android.internal.util.test.FakeSettingsProvider;
import com.android.internal.R;
import com.android.internal.util.test.FakeSettingsProvider;
import com.android.server.net.BaseNetworkObserver;
import org.junit.Before;
@@ -63,8 +61,8 @@ import org.mockito.MockitoAnnotations;
import java.net.InetAddress;
import java.util.Arrays;
import java.util.List;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
/**
@@ -87,7 +85,7 @@ public class IpClientTest {
@Mock private INetworkManagementService mNMService;
@Mock private INetd mNetd;
@Mock private Resources mResources;
@Mock private Callback mCb;
@Mock private IpClientCallbacks mCb;
@Mock private AlarmManager mAlarm;
@Mock private IpClient.Dependencies mDependecies;
private MockContentResolver mContentResolver;
@@ -179,7 +177,7 @@ public class IpClientTest {
public void testInterfaceNotFoundFailsImmediately() throws Exception {
setTestInterfaceParams(null);
final IpClient ipc = new IpClient(mContext, TEST_IFNAME, mCb, mDependecies);
ipc.startProvisioning(new IpClient.ProvisioningConfiguration());
ipc.startProvisioning(new ProvisioningConfiguration());
verify(mCb, times(1)).onProvisioningFailure(any());
ipc.shutdown();
}