| /* |
| * 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 com.android.server.lowpan; |
| |
| import android.annotation.NonNull; |
| import android.content.Context; |
| import android.net.ConnectivityManager; |
| import android.net.IpPrefix; |
| import android.net.LinkAddress; |
| import android.net.LinkProperties; |
| import android.net.NetworkAgent; |
| import android.net.NetworkCapabilities; |
| import android.net.NetworkFactory; |
| import android.net.NetworkInfo; |
| import android.net.NetworkInfo.DetailedState; |
| import android.net.ip.IIpClient; |
| import android.net.ip.IpClientCallbacks; |
| import android.net.ip.IpClientUtil; |
| import android.net.lowpan.ILowpanInterface; |
| import android.net.lowpan.LowpanException; |
| import android.net.lowpan.LowpanInterface; |
| import android.net.lowpan.LowpanRuntimeException; |
| import android.net.shared.InitialConfiguration; |
| import android.net.shared.ProvisioningConfiguration; |
| import android.os.ConditionVariable; |
| import android.os.Looper; |
| import android.os.Message; |
| import android.os.RemoteException; |
| import android.os.ServiceSpecificException; |
| import android.util.Log; |
| import com.android.internal.util.HexDump; |
| import com.android.internal.util.Protocol; |
| import com.android.internal.util.State; |
| import com.android.internal.util.StateMachine; |
| |
| /** Tracks connectivity of a LoWPAN interface. */ |
| class LowpanInterfaceTracker extends StateMachine { |
| |
| // Misc Constants |
| |
| /** Network type string for NetworkInfo */ |
| private static final String NETWORK_TYPE = "LoWPAN"; |
| |
| /** Tag used for logging */ |
| private static final String TAG = "LowpanInterfaceTracker"; |
| |
| /** |
| * Maximum network score for LoWPAN networks. |
| * |
| * <p>TODO: Research if 30 is an appropriate value. |
| */ |
| private static final int NETWORK_SCORE = 30; |
| |
| // TODO: create IpClient asynchronously |
| private static final int IPCLIENT_CREATE_TIMEOUT_MS = 10000; |
| |
| /** Internal debugging flag. */ |
| private static final boolean DBG = true; |
| |
| /** Number of state machine log records. */ |
| public static final short NUM_LOG_RECS_NORMAL = 100; |
| |
| // Message Code Enumeration Constants |
| |
| /** The base for LoWPAN message codes */ |
| static final int BASE = Protocol.BASE_LOWPAN; |
| |
| static final int CMD_START_NETWORK = BASE + 3; |
| static final int CMD_STOP_NETWORK = BASE + 4; |
| static final int CMD_STATE_CHANGE = BASE + 5; |
| static final int CMD_LINK_PROPERTIES_CHANGE = BASE + 6; |
| static final int CMD_UNWANTED = BASE + 7; |
| static final int CMD_PROVISIONING_SUCCESS = BASE + 8; |
| static final int CMD_PROVISIONING_FAILURE = BASE + 9; |
| |
| // Services and interfaces |
| |
| ILowpanInterface mILowpanInterface; |
| private LowpanInterface mLowpanInterface; |
| private NetworkAgent mNetworkAgent; |
| private NetworkFactory mNetworkFactory; |
| private volatile IIpClient mIpClient; |
| private final IpClientCallbackImpl mIpClientCallback = new IpClientCallbackImpl(); |
| |
| // Instance Variables |
| |
| private String mInterfaceName; |
| private String mHwAddr; |
| private Context mContext; |
| private NetworkInfo mNetworkInfo; |
| private LinkProperties mLinkProperties; |
| private final NetworkCapabilities mNetworkCapabilities = new NetworkCapabilities(); |
| private String mState = ""; |
| |
| // State machine state instances |
| |
| final DefaultState mDefaultState = new DefaultState(); |
| final NormalState mNormalState = new NormalState(); |
| final OfflineState mOfflineState = new OfflineState(); |
| final CommissioningState mCommissioningState = new CommissioningState(); |
| final AttachingState mAttachingState = new AttachingState(); |
| final AttachedState mAttachedState = new AttachedState(); |
| final ObtainingIpState mObtainingIpState = new ObtainingIpState(); |
| final FaultState mFaultState = new FaultState(); |
| final ConnectedState mConnectedState = new ConnectedState(); |
| |
| private LocalLowpanCallback mLocalLowpanCallback = new LocalLowpanCallback(); |
| |
| // Misc Private Classes |
| |
| private class LocalLowpanCallback extends LowpanInterface.Callback { |
| @Override |
| public void onEnabledChanged(boolean value) {} |
| |
| @Override |
| public void onUpChanged(boolean value) {} |
| |
| @Override |
| public void onConnectedChanged(boolean value) {} |
| |
| @Override |
| public void onStateChanged(@NonNull String state) { |
| LowpanInterfaceTracker.this.sendMessage(CMD_STATE_CHANGE, state); |
| } |
| } |
| |
| class IpClientCallbackImpl extends IpClientCallbacks { |
| private final ConditionVariable mObtainedCv = new ConditionVariable(false); |
| |
| @Override |
| public void onIpClientCreated(IIpClient ipClient) { |
| mIpClient = ipClient; |
| mObtainedCv.open(); |
| } |
| |
| public boolean waitUntilCreated() { |
| return mObtainedCv.block(IPCLIENT_CREATE_TIMEOUT_MS); |
| } |
| |
| @Override |
| public void onProvisioningSuccess(LinkProperties newLp) { |
| LowpanInterfaceTracker.this.sendMessage(CMD_PROVISIONING_SUCCESS, newLp); |
| } |
| |
| @Override |
| public void onProvisioningFailure(LinkProperties newLp) { |
| LowpanInterfaceTracker.this.sendMessage(CMD_PROVISIONING_FAILURE, newLp); |
| } |
| |
| @Override |
| public void onLinkPropertiesChange(LinkProperties newLp) { |
| LowpanInterfaceTracker.this.sendMessage(CMD_LINK_PROPERTIES_CHANGE, newLp); |
| } |
| } |
| |
| // State Definitions |
| |
| class DefaultState extends State { |
| @Override |
| public void enter() { |
| if (DBG) { |
| Log.i(TAG, "DefaultState.enter()"); |
| } |
| |
| mNetworkInfo = new NetworkInfo(ConnectivityManager.TYPE_NONE, 0, NETWORK_TYPE, ""); |
| mNetworkInfo.setIsAvailable(true); |
| |
| mLowpanInterface.registerCallback(mLocalLowpanCallback); |
| |
| mState = ""; |
| |
| sendMessage(CMD_STATE_CHANGE, mLowpanInterface.getState()); |
| } |
| |
| @Override |
| public boolean processMessage(Message message) { |
| boolean retValue = NOT_HANDLED; |
| |
| switch (message.what) { |
| case CMD_START_NETWORK: |
| if (DBG) { |
| Log.i(TAG, "CMD_START_NETWORK"); |
| } |
| try { |
| mLowpanInterface.setEnabled(true); |
| } catch (LowpanException | LowpanRuntimeException x) { |
| Log.e(TAG, "Exception while enabling: " + x); |
| transitionTo(mFaultState); |
| return HANDLED; |
| } |
| break; |
| |
| case CMD_STOP_NETWORK: |
| if (DBG) { |
| Log.i(TAG, "CMD_STOP_NETWORK"); |
| } |
| try { |
| mLowpanInterface.setEnabled(false); |
| } catch (LowpanException | LowpanRuntimeException x) { |
| Log.e(TAG, "Exception while disabling: " + x); |
| transitionTo(mFaultState); |
| return HANDLED; |
| } |
| break; |
| |
| case CMD_STATE_CHANGE: |
| if (!mState.equals(message.obj)) { |
| if (DBG) { |
| Log.i( |
| TAG, |
| "LowpanInterface changed state from \"" |
| + mState |
| + "\" to \"" |
| + message.obj |
| + "\"."); |
| } |
| mState = (String) message.obj; |
| switch (mState) { |
| case LowpanInterface.STATE_OFFLINE: |
| transitionTo(mOfflineState); |
| break; |
| case LowpanInterface.STATE_COMMISSIONING: |
| transitionTo(mCommissioningState); |
| break; |
| case LowpanInterface.STATE_ATTACHING: |
| transitionTo(mAttachingState); |
| break; |
| case LowpanInterface.STATE_ATTACHED: |
| transitionTo(mObtainingIpState); |
| break; |
| case LowpanInterface.STATE_FAULT: |
| transitionTo(mFaultState); |
| break; |
| } |
| } |
| retValue = HANDLED; |
| break; |
| } |
| return retValue; |
| } |
| |
| @Override |
| public void exit() { |
| mLowpanInterface.unregisterCallback(mLocalLowpanCallback); |
| } |
| } |
| |
| class NormalState extends State { |
| @Override |
| public void enter() { |
| if (DBG) { |
| Log.i(TAG, "NormalState.enter()"); |
| } |
| |
| IpClientUtil.makeIpClient(mContext, mInterfaceName, mIpClientCallback); |
| if (!mIpClientCallback.waitUntilCreated()) { |
| Log.e(TAG, "Failed to create IpClient"); |
| transitionTo(mFaultState); |
| return; |
| } |
| |
| if (mHwAddr == null) { |
| byte[] hwAddr = null; |
| try { |
| hwAddr = mLowpanInterface.getService().getMacAddress(); |
| |
| } catch (RemoteException | ServiceSpecificException x) { |
| // Don't let misbehavior of the interface service |
| // crash the system service. |
| Log.e(TAG, "Call to getMacAddress() failed: " + x); |
| transitionTo(mFaultState); |
| } |
| |
| if (hwAddr != null) { |
| mHwAddr = HexDump.toHexString(hwAddr); |
| } |
| } |
| |
| mNetworkFactory.register(); |
| } |
| |
| @Override |
| public boolean processMessage(Message message) { |
| switch (message.what) { |
| case CMD_UNWANTED: |
| if (mNetworkAgent == message.obj) { |
| if (DBG) { |
| Log.i(TAG, "UNWANTED."); |
| } |
| |
| try { |
| mLowpanInterface.setEnabled(false); |
| } catch (LowpanException | LowpanRuntimeException x) { |
| Log.e(TAG, "Exception while disabling: " + x); |
| transitionTo(mFaultState); |
| return HANDLED; |
| } |
| |
| shutdownNetworkAgent(); |
| } |
| break; |
| |
| case CMD_LINK_PROPERTIES_CHANGE: |
| mLinkProperties = (LinkProperties) message.obj; |
| if (DBG) { |
| Log.i(TAG, "Got LinkProperties: " + mLinkProperties); |
| } |
| if (mNetworkAgent != null) { |
| mNetworkAgent.sendLinkProperties(mLinkProperties); |
| } |
| break; |
| |
| case CMD_PROVISIONING_FAILURE: |
| Log.i(TAG, "Provisioning Failure: " + message.obj); |
| break; |
| } |
| |
| return NOT_HANDLED; |
| } |
| |
| @Override |
| public void exit() { |
| shutdownNetworkAgent(); |
| mNetworkFactory.unregister(); |
| |
| if (mIpClient != null) { |
| try { |
| mIpClient.shutdown(); |
| } catch (RemoteException e) { |
| Log.e(TAG, "Error shutting down IpClient", e); |
| } |
| } |
| mIpClient = null; |
| } |
| } |
| |
| class OfflineState extends State { |
| @Override |
| public void enter() { |
| shutdownNetworkAgent(); |
| mNetworkInfo.setIsAvailable(true); |
| |
| try { |
| mIpClient.stop(); |
| } catch (RemoteException e) { |
| Log.e(TAG, "Error stopping IpClient"); |
| } |
| } |
| |
| @Override |
| public boolean processMessage(Message message) { |
| return NOT_HANDLED; |
| } |
| |
| @Override |
| public void exit() {} |
| } |
| |
| class CommissioningState extends State { |
| @Override |
| public void enter() {} |
| |
| @Override |
| public boolean processMessage(Message message) { |
| return NOT_HANDLED; |
| } |
| |
| @Override |
| public void exit() {} |
| } |
| |
| class AttachingState extends State { |
| @Override |
| public void enter() { |
| mNetworkInfo.setDetailedState(DetailedState.CONNECTING, null, mHwAddr); |
| mNetworkInfo.setIsAvailable(true); |
| bringUpNetworkAgent(); |
| mNetworkAgent.sendNetworkInfo(mNetworkInfo); |
| } |
| |
| @Override |
| public boolean processMessage(Message message) { |
| return NOT_HANDLED; |
| } |
| |
| @Override |
| public void exit() {} |
| } |
| |
| class AttachedState extends State { |
| @Override |
| public void enter() { |
| bringUpNetworkAgent(); |
| mNetworkInfo.setIsAvailable(true); |
| } |
| |
| @Override |
| public boolean processMessage(Message message) { |
| switch (message.what) { |
| case CMD_STATE_CHANGE: |
| if (!mState.equals(message.obj) |
| && !LowpanInterface.STATE_ATTACHED.equals(message.obj)) { |
| return NOT_HANDLED; |
| } |
| return HANDLED; |
| |
| default: |
| return NOT_HANDLED; |
| } |
| } |
| |
| @Override |
| public void exit() { |
| mNetworkInfo.setIsAvailable(false); |
| } |
| } |
| |
| class ObtainingIpState extends State { |
| @Override |
| public void enter() { |
| InitialConfiguration initialConfiguration = new InitialConfiguration(); |
| |
| try { |
| for (LinkAddress address : mLowpanInterface.getLinkAddresses()) { |
| if (DBG) { |
| Log.i(TAG, "Adding link address: " + address); |
| } |
| |
| initialConfiguration.ipAddresses.add(address); |
| |
| IpPrefix prefix = new IpPrefix(address.getAddress(), address.getPrefixLength()); |
| |
| initialConfiguration.directlyConnectedRoutes.add(prefix); |
| } |
| |
| for (IpPrefix prefix : mLowpanInterface.getLinkNetworks()) { |
| if (DBG) { |
| Log.i(TAG, "Adding directly connected route: " + prefix); |
| } |
| |
| initialConfiguration.directlyConnectedRoutes.add(prefix); |
| } |
| |
| } catch (LowpanException | LowpanRuntimeException x) { |
| Log.e(TAG, "Exception while populating InitialConfiguration: " + x); |
| transitionTo(mFaultState); |
| return; |
| |
| } catch (RuntimeException x) { |
| if (x.getCause() instanceof RemoteException) { |
| // Don't let misbehavior of an interface service |
| // crash the system service. |
| Log.e(TAG, "RuntimeException while populating InitialConfiguration: " + x); |
| transitionTo(mFaultState); |
| |
| } else { |
| // This exception wasn't remote in origin, so we rethrow. |
| throw x; |
| } |
| } |
| |
| if (!initialConfiguration.isValid()) { |
| Log.e(TAG, "Invalid initial configuration: " + initialConfiguration); |
| transitionTo(mFaultState); |
| return; |
| } |
| |
| if (DBG) { |
| Log.d(TAG, "Using Initial configuration: " + initialConfiguration); |
| } |
| |
| final ProvisioningConfiguration.Builder builder = |
| new ProvisioningConfiguration.Builder(); |
| |
| builder.withInitialConfiguration(initialConfiguration).withProvisioningTimeoutMs(0); |
| |
| // LoWPAN networks generally don't have internet connectivity, |
| // so the reachability monitor would almost always fail. |
| builder.withoutIpReachabilityMonitor(); |
| |
| // We currently only support IPv6 on LoWPAN networks, although |
| // theoretically we could make this determination by examining |
| // the InitialConfiguration for any IPv4 addresses. |
| builder.withoutIPv4(); |
| |
| try { |
| mIpClient.startProvisioning(builder.build().toStableParcelable()); |
| } catch (RemoteException e) { |
| Log.e(TAG, "Error starting IpClient provisioning", e); |
| transitionTo(mFaultState); |
| return; |
| } |
| |
| mNetworkInfo.setDetailedState(DetailedState.OBTAINING_IPADDR, null, mHwAddr); |
| mNetworkAgent.sendNetworkInfo(mNetworkInfo); |
| } |
| |
| @Override |
| public boolean processMessage(Message message) { |
| |
| switch (message.what) { |
| case CMD_PROVISIONING_SUCCESS: |
| Log.i(TAG, "Provisioning Success: " + message.obj); |
| transitionTo(mConnectedState); |
| return HANDLED; |
| } |
| return NOT_HANDLED; |
| } |
| |
| @Override |
| public void exit() {} |
| } |
| |
| class ConnectedState extends State { |
| @Override |
| public void enter() { |
| mNetworkInfo.setDetailedState(DetailedState.CONNECTED, null, mHwAddr); |
| mNetworkAgent.sendNetworkInfo(mNetworkInfo); |
| mNetworkAgent.sendNetworkScore(NETWORK_SCORE); |
| } |
| |
| @Override |
| public boolean processMessage(Message message) { |
| return NOT_HANDLED; |
| } |
| |
| @Override |
| public void exit() { |
| if (mNetworkAgent != null) { |
| mNetworkAgent.sendNetworkScore(0); |
| } |
| } |
| } |
| |
| class FaultState extends State { |
| @Override |
| public void enter() {} |
| |
| @Override |
| public boolean processMessage(Message message) { |
| return NOT_HANDLED; |
| } |
| |
| @Override |
| public void exit() {} |
| } |
| |
| public LowpanInterfaceTracker(Context context, ILowpanInterface ifaceService, Looper looper) { |
| super(TAG, looper); |
| |
| if (DBG) { |
| Log.i(TAG, "LowpanInterfaceTracker() begin"); |
| } |
| |
| setDbg(DBG); |
| setLogRecSize(NUM_LOG_RECS_NORMAL); |
| setLogOnlyTransitions(false); |
| |
| mILowpanInterface = ifaceService; |
| mLowpanInterface = new LowpanInterface(context, ifaceService, looper); |
| mContext = context; |
| |
| mInterfaceName = mLowpanInterface.getName(); |
| |
| mLinkProperties = new LinkProperties(); |
| mLinkProperties.setInterfaceName(mInterfaceName); |
| |
| // Initialize capabilities |
| mNetworkCapabilities.addTransportType(NetworkCapabilities.TRANSPORT_LOWPAN); |
| mNetworkCapabilities.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED); |
| mNetworkCapabilities.setLinkUpstreamBandwidthKbps(100); |
| mNetworkCapabilities.setLinkDownstreamBandwidthKbps(100); |
| |
| // CHECKSTYLE:OFF IndentationCheck |
| addState(mDefaultState); |
| addState(mFaultState, mDefaultState); |
| addState(mNormalState, mDefaultState); |
| addState(mOfflineState, mNormalState); |
| addState(mCommissioningState, mNormalState); |
| addState(mAttachingState, mNormalState); |
| addState(mAttachedState, mNormalState); |
| addState(mObtainingIpState, mAttachedState); |
| addState(mConnectedState, mAttachedState); |
| // CHECKSTYLE:ON IndentationCheck |
| |
| setInitialState(mDefaultState); |
| |
| mNetworkFactory = |
| new NetworkFactory(looper, context, NETWORK_TYPE, mNetworkCapabilities) { |
| @Override |
| protected void startNetwork() { |
| LowpanInterfaceTracker.this.sendMessage(CMD_START_NETWORK); |
| } |
| |
| @Override |
| protected void stopNetwork() { |
| LowpanInterfaceTracker.this.sendMessage(CMD_STOP_NETWORK); |
| } |
| }; |
| |
| if (DBG) { |
| Log.i(TAG, "LowpanInterfaceTracker() end"); |
| } |
| } |
| |
| private void shutdownNetworkAgent() { |
| mNetworkInfo.setDetailedState(DetailedState.DISCONNECTED, null, mHwAddr); |
| mNetworkInfo.setIsAvailable(false); |
| |
| if (mNetworkAgent != null) { |
| mNetworkAgent.sendNetworkScore(0); |
| mNetworkAgent.sendNetworkInfo(mNetworkInfo); |
| } |
| |
| mNetworkAgent = null; |
| } |
| |
| private void bringUpNetworkAgent() { |
| if (mNetworkAgent == null) { |
| mNetworkAgent = |
| new NetworkAgent( |
| mNetworkFactory.getLooper(), |
| mContext, |
| NETWORK_TYPE, |
| mNetworkInfo, |
| mNetworkCapabilities, |
| mLinkProperties, |
| NETWORK_SCORE) { |
| public void unwanted() { |
| LowpanInterfaceTracker.this.sendMessage(CMD_UNWANTED, this); |
| }; |
| }; |
| } |
| } |
| |
| public void register() { |
| if (DBG) { |
| Log.i(TAG, "register()"); |
| } |
| start(); |
| } |
| |
| public void unregister() { |
| if (DBG) { |
| Log.i(TAG, "unregister()"); |
| } |
| quit(); |
| } |
| } |
