/*
* Copyright (C) 2015 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.dhcp;
import com.android.internal.util.HexDump;
import com.android.internal.util.Protocol;
import com.android.internal.util.State;
import com.android.internal.util.StateMachine;
import android.app.AlarmManager;
import android.app.PendingIntent;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.net.DhcpResults;
import android.net.BaseDhcpStateMachine;
import android.net.DhcpStateMachine;
import android.net.InterfaceConfiguration;
import android.net.LinkAddress;
import android.net.NetworkUtils;
import android.os.IBinder;
import android.os.INetworkManagementService;
import android.os.Message;
import android.os.PowerManager;
import android.os.RemoteException;
import android.os.ServiceManager;
import android.os.SystemClock;
import android.system.ErrnoException;
import android.system.Os;
import android.system.PacketSocketAddress;
import android.util.Log;
import android.util.TimeUtils;
import java.io.FileDescriptor;
import java.io.IOException;
import java.lang.Thread;
import java.net.Inet4Address;
import java.net.InetSocketAddress;
import java.net.NetworkInterface;
import java.net.SocketException;
import java.nio.BufferUnderflowException;
import java.nio.ByteBuffer;
import java.util.Arrays;
import java.util.Random;
import libcore.io.IoBridge;
import static android.system.OsConstants.*;
import static android.net.dhcp.DhcpPacket.*;
/**
* A DHCPv4 client.
*
* Written to behave similarly to the DhcpStateMachine + dhcpcd 5.5.6 combination used in Android
* 5.1 and below, as configured on Nexus 6. The interface is the same as DhcpStateMachine.
*
* TODO:
*
* - Exponential backoff when receiving NAKs (not specified by the RFC, but current behaviour).
* - Support persisting lease state and support INIT-REBOOT. Android 5.1 does this, but it does not
* do so correctly: instead of requesting the lease last obtained on a particular network (e.g., a
* given SSID), it requests the last-leased IP address on the same interface, causing a delay if
* the server NAKs or a timeout if it doesn't.
*
* Known differences from current behaviour:
*
* - Does not request the "static routes" option.
* - Does not support BOOTP servers. DHCP has been around since 1993, should be everywhere now.
* - Requests the "broadcast" option, but does nothing with it.
* - Rejects invalid subnet masks such as 255.255.255.1 (current code treats that as 255.255.255.0).
*
* @hide
*/
public class DhcpClient extends BaseDhcpStateMachine {
private static final String TAG = "DhcpClient";
private static final boolean DBG = true;
private static final boolean STATE_DBG = false;
private static final boolean MSG_DBG = false;
private static final boolean PACKET_DBG = true;
// Timers and timeouts.
private static final int SECONDS = 1000;
private static final int FIRST_TIMEOUT_MS = 2 * SECONDS;
private static final int MAX_TIMEOUT_MS = 128 * SECONDS;
// This is not strictly needed, since the client is asynchronous and implements exponential
// backoff. It's maintained for backwards compatibility with the previous DHCP code, which was
// a blocking operation with a 30-second timeout. We pick 36 seconds so we can send packets at
// t=0, t=2, t=6, t=14, t=30, allowing for 10% jitter.
private static final int DHCP_TIMEOUT_MS = 36 * SECONDS;
// Messages.
private static final int BASE = Protocol.BASE_DHCP + 100;
private static final int CMD_KICK = BASE + 1;
private static final int CMD_RECEIVED_PACKET = BASE + 2;
private static final int CMD_TIMEOUT = BASE + 3;
private static final int CMD_ONESHOT_TIMEOUT = BASE + 4;
// DHCP parameters that we request.
private static final byte[] REQUESTED_PARAMS = new byte[] {
DHCP_SUBNET_MASK,
DHCP_ROUTER,
DHCP_DNS_SERVER,
DHCP_DOMAIN_NAME,
DHCP_MTU,
DHCP_BROADCAST_ADDRESS, // TODO: currently ignored.
DHCP_LEASE_TIME,
DHCP_RENEWAL_TIME,
DHCP_REBINDING_TIME,
};
// DHCP flag that means "yes, we support unicast."
private static final boolean DO_UNICAST = false;
// System services / libraries we use.
private final Context mContext;
private final AlarmManager mAlarmManager;
private final Random mRandom;
private final INetworkManagementService mNMService;
// Sockets.
// - We use a packet socket to receive, because servers send us packets bound for IP addresses
// which we have not yet configured, and the kernel protocol stack drops these.
// - We use a UDP socket to send, so the kernel handles ARP and routing for us (DHCP servers can
// be off-link as well as on-link).
private FileDescriptor mPacketSock;
private FileDescriptor mUdpSock;
private ReceiveThread mReceiveThread;
// State variables.
private final StateMachine mController;
private final PendingIntent mKickIntent;
private final PendingIntent mTimeoutIntent;
private final PendingIntent mRenewIntent;
private final PendingIntent mOneshotTimeoutIntent;
private final String mIfaceName;
private boolean mRegisteredForPreDhcpNotification;
private NetworkInterface mIface;
private byte[] mHwAddr;
private PacketSocketAddress mInterfaceBroadcastAddr;
private int mTransactionId;
private long mTransactionStartMillis;
private DhcpResults mDhcpLease;
private long mDhcpLeaseExpiry;
private DhcpResults mOffer;
// States.
private State mStoppedState = new StoppedState();
private State mDhcpState = new DhcpState();
private State mDhcpInitState = new DhcpInitState();
private State mDhcpSelectingState = new DhcpSelectingState();
private State mDhcpRequestingState = new DhcpRequestingState();
private State mDhcpHaveAddressState = new DhcpHaveAddressState();
private State mDhcpBoundState = new DhcpBoundState();
private State mDhcpRenewingState = new DhcpRenewingState();
private State mDhcpRebindingState = new DhcpRebindingState();
private State mDhcpInitRebootState = new DhcpInitRebootState();
private State mDhcpRebootingState = new DhcpRebootingState();
private State mWaitBeforeStartState = new WaitBeforeStartState(mDhcpInitState);
private State mWaitBeforeRenewalState = new WaitBeforeRenewalState(mDhcpRenewingState);
private DhcpClient(Context context, StateMachine controller, String iface) {
super(TAG);
mContext = context;
mController = controller;
mIfaceName = iface;
addState(mStoppedState);
addState(mDhcpState);
addState(mDhcpInitState, mDhcpState);
addState(mWaitBeforeStartState, mDhcpState);
addState(mDhcpSelectingState, mDhcpState);
addState(mDhcpRequestingState, mDhcpState);
addState(mDhcpHaveAddressState, mDhcpState);
addState(mDhcpBoundState, mDhcpHaveAddressState);
addState(mWaitBeforeRenewalState, mDhcpHaveAddressState);
addState(mDhcpRenewingState, mDhcpHaveAddressState);
addState(mDhcpRebindingState, mDhcpHaveAddressState);
addState(mDhcpInitRebootState, mDhcpState);
addState(mDhcpRebootingState, mDhcpState);
setInitialState(mStoppedState);
mAlarmManager = (AlarmManager) mContext.getSystemService(Context.ALARM_SERVICE);
IBinder b = ServiceManager.getService(Context.NETWORKMANAGEMENT_SERVICE);
mNMService = INetworkManagementService.Stub.asInterface(b);
mRandom = new Random();
// Used to schedule packet retransmissions.
mKickIntent = createStateMachineCommandIntent("KICK", CMD_KICK);
// Used to time out PacketRetransmittingStates.
mTimeoutIntent = createStateMachineCommandIntent("TIMEOUT", CMD_TIMEOUT);
// Used to schedule DHCP renews.
mRenewIntent = createStateMachineCommandIntent("RENEW", DhcpStateMachine.CMD_RENEW_DHCP);
// Used to tell the caller when its request (CMD_START_DHCP or CMD_RENEW_DHCP) timed out.
// TODO: when the legacy DHCP client is gone, make the client fully asynchronous and
// remove this.
mOneshotTimeoutIntent = createStateMachineCommandIntent("ONESHOT_TIMEOUT",
CMD_ONESHOT_TIMEOUT);
}
@Override
public void registerForPreDhcpNotification() {
mRegisteredForPreDhcpNotification = true;
}
public static BaseDhcpStateMachine makeDhcpStateMachine(
Context context, StateMachine controller, String intf) {
DhcpClient client = new DhcpClient(context, controller, intf);
client.start();
return client;
}
/**
* Constructs a PendingIntent that sends the specified command to the state machine. This is
* implemented by creating an Intent with the specified parameters, and creating and registering
* a BroadcastReceiver for it. The broadcast must be sent by a process that holds the
* {@code CONNECTIVITY_INTERNAL} permission.
*
* @param cmdName the name of the command. The intent's action will be
* {@code android.net.dhcp.DhcpClient.<mIfaceName>.<cmdName>}
* @param cmd the command to send to the state machine when the PendingIntent is triggered.
* @return the PendingIntent
*/
private PendingIntent createStateMachineCommandIntent(final String cmdName, final int cmd) {
String action = DhcpClient.class.getName() + "." + mIfaceName + "." + cmdName;
Intent intent = new Intent(action, null)
.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
// TODO: The intent's package covers the whole of the system server, so it's pretty generic.
// Consider adding some sort of token as well.
intent.setPackage(mContext.getPackageName());
PendingIntent pendingIntent = PendingIntent.getBroadcast(mContext, cmd, intent, 0);
mContext.registerReceiver(
new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
sendMessage(cmd);
}
},
new IntentFilter(action),
android.Manifest.permission.CONNECTIVITY_INTERNAL,
null);
return pendingIntent;
}
private boolean initInterface() {
try {
mIface = NetworkInterface.getByName(mIfaceName);
mHwAddr = mIface.getHardwareAddress();
mInterfaceBroadcastAddr = new PacketSocketAddress(mIface.getIndex(),
DhcpPacket.ETHER_BROADCAST);
return true;
} catch(SocketException e) {
Log.wtf(TAG, "Can't determine ifindex or MAC address for " + mIfaceName);
return false;
}
}
private void startNewTransaction() {
mTransactionId = mRandom.nextInt();
mTransactionStartMillis = SystemClock.elapsedRealtime();
}
private boolean initSockets() {
try {
mPacketSock = Os.socket(AF_PACKET, SOCK_RAW, ETH_P_IP);
PacketSocketAddress addr = new PacketSocketAddress((short) ETH_P_IP, mIface.getIndex());
Os.bind(mPacketSock, addr);
NetworkUtils.attachDhcpFilter(mPacketSock);
} catch(SocketException|ErrnoException e) {
Log.e(TAG, "Error creating packet socket", e);
return false;
}
try {
mUdpSock = Os.socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
Os.setsockoptInt(mUdpSock, SOL_SOCKET, SO_REUSEADDR, 1);
Os.setsockoptIfreq(mUdpSock, SOL_SOCKET, SO_BINDTODEVICE, mIfaceName);
Os.setsockoptInt(mUdpSock, SOL_SOCKET, SO_BROADCAST, 1);
Os.bind(mUdpSock, Inet4Address.ANY, DhcpPacket.DHCP_CLIENT);
NetworkUtils.protectFromVpn(mUdpSock);
} catch(SocketException|ErrnoException e) {
Log.e(TAG, "Error creating UDP socket", e);
return false;
}
return true;
}
private static void closeQuietly(FileDescriptor fd) {
try {
IoBridge.closeAndSignalBlockedThreads(fd);
} catch (IOException ignored) {}
}
private void closeSockets() {
closeQuietly(mUdpSock);
closeQuietly(mPacketSock);
}
private boolean setIpAddress(LinkAddress address) {
InterfaceConfiguration ifcg = new InterfaceConfiguration();
ifcg.setLinkAddress(address);
try {
mNMService.setInterfaceConfig(mIfaceName, ifcg);
} catch (RemoteException|IllegalStateException e) {
Log.e(TAG, "Error configuring IP address : " + e);
return false;
}
return true;
}
class ReceiveThread extends Thread {
private final byte[] mPacket = new byte[DhcpPacket.MAX_LENGTH];
private boolean stopped = false;
public void halt() {
stopped = true;
closeSockets(); // Interrupts the read() call the thread is blocked in.
}
@Override
public void run() {
maybeLog("Receive thread started");
while (!stopped) {
try {
int length = Os.read(mPacketSock, mPacket, 0, mPacket.length);
DhcpPacket packet = null;
packet = DhcpPacket.decodeFullPacket(mPacket, length, DhcpPacket.ENCAP_L2);
if (packet != null) {
maybeLog("Received packet: " + packet);
sendMessage(CMD_RECEIVED_PACKET, packet);
} else if (PACKET_DBG) {
Log.d(TAG,
"Can't parse packet" + HexDump.dumpHexString(mPacket, 0, length));
}
} catch (IOException|ErrnoException e) {
if (!stopped) {
Log.e(TAG, "Read error", e);
}
}
}
maybeLog("Receive thread stopped");
}
}
private short getSecs() {
return (short) ((SystemClock.elapsedRealtime() - mTransactionStartMillis) / 1000);
}
private boolean transmitPacket(ByteBuffer buf, String description, Inet4Address to) {
try {
if (to.equals(INADDR_BROADCAST)) {
maybeLog("Broadcasting " + description);
Os.sendto(mPacketSock, buf.array(), 0, buf.limit(), 0, mInterfaceBroadcastAddr);
} else {
maybeLog("Unicasting " + description + " to " + to.getHostAddress());
Os.sendto(mUdpSock, buf, 0, to, DhcpPacket.DHCP_SERVER);
}
} catch(ErrnoException|IOException e) {
Log.e(TAG, "Can't send packet: ", e);
return false;
}
return true;
}
private boolean sendDiscoverPacket() {
ByteBuffer packet = DhcpPacket.buildDiscoverPacket(
DhcpPacket.ENCAP_L2, mTransactionId, getSecs(), mHwAddr,
DO_UNICAST, REQUESTED_PARAMS);
return transmitPacket(packet, "DHCPDISCOVER", INADDR_BROADCAST);
}
private boolean sendRequestPacket(
Inet4Address clientAddress, Inet4Address requestedAddress,
Inet4Address serverAddress, Inet4Address to) {
// TODO: should we use the transaction ID from the server?
int encap = to.equals(INADDR_BROADCAST) ? DhcpPacket.ENCAP_L2 : DhcpPacket.ENCAP_BOOTP;
ByteBuffer packet = DhcpPacket.buildRequestPacket(
encap, mTransactionId, getSecs(), clientAddress,
DO_UNICAST, mHwAddr, requestedAddress,
serverAddress, REQUESTED_PARAMS, null);
String description = "DHCPREQUEST ciaddr=" + clientAddress.getHostAddress() +
" request=" + requestedAddress.getHostAddress() +
" to=" + serverAddress.getHostAddress();
return transmitPacket(packet, description, to);
}
private void scheduleRenew() {
mAlarmManager.cancel(mRenewIntent);
if (mDhcpLeaseExpiry != 0) {
long now = SystemClock.elapsedRealtime();
long alarmTime = (now + mDhcpLeaseExpiry) / 2;
mAlarmManager.setExact(AlarmManager.ELAPSED_REALTIME_WAKEUP, alarmTime, mRenewIntent);
Log.d(TAG, "Scheduling renewal in " + ((alarmTime - now) / 1000) + "s");
} else {
Log.d(TAG, "Infinite lease, no renewal needed");
}
}
private void notifySuccess() {
mController.sendMessage(DhcpStateMachine.CMD_POST_DHCP_ACTION,
DhcpStateMachine.DHCP_SUCCESS, 0, new DhcpResults(mDhcpLease));
}
private void notifyFailure() {
mController.sendMessage(DhcpStateMachine.CMD_POST_DHCP_ACTION,
DhcpStateMachine.DHCP_FAILURE, 0, null);
}
private void clearDhcpState() {
mDhcpLease = null;
mDhcpLeaseExpiry = 0;
mOffer = null;
}
/**
* Quit the DhcpStateMachine.
*
* @hide
*/
@Override
public void doQuit() {
Log.d(TAG, "doQuit");
quit();
}
protected void onQuitting() {
Log.d(TAG, "onQuitting");
mController.sendMessage(DhcpStateMachine.CMD_ON_QUIT);
}
private void maybeLog(String msg) {
if (DBG) Log.d(TAG, msg);
}
abstract class LoggingState extends State {
public void enter() {
if (STATE_DBG) Log.d(TAG, "Entering state " + getName());
}
private String messageName(int what) {
switch (what) {
case DhcpStateMachine.CMD_START_DHCP:
return "CMD_START_DHCP";
case DhcpStateMachine.CMD_STOP_DHCP:
return "CMD_STOP_DHCP";
case DhcpStateMachine.CMD_RENEW_DHCP:
return "CMD_RENEW_DHCP";
case DhcpStateMachine.CMD_PRE_DHCP_ACTION:
return "CMD_PRE_DHCP_ACTION";
case DhcpStateMachine.CMD_PRE_DHCP_ACTION_COMPLETE:
return "CMD_PRE_DHCP_ACTION_COMPLETE";
case DhcpStateMachine.CMD_POST_DHCP_ACTION:
return "CMD_POST_DHCP_ACTION";
case CMD_KICK:
return "CMD_KICK";
case CMD_RECEIVED_PACKET:
return "CMD_RECEIVED_PACKET";
case CMD_TIMEOUT:
return "CMD_TIMEOUT";
case CMD_ONESHOT_TIMEOUT:
return "CMD_ONESHOT_TIMEOUT";
default:
return Integer.toString(what);
}
}
private String messageToString(Message message) {
long now = SystemClock.uptimeMillis();
StringBuilder b = new StringBuilder(" ");
TimeUtils.formatDuration(message.getWhen() - now, b);
b.append(" ").append(messageName(message.what))
.append(" ").append(message.arg1)
.append(" ").append(message.arg2)
.append(" ").append(message.obj);
return b.toString();
}
@Override
public boolean processMessage(Message message) {
if (MSG_DBG) {
Log.d(TAG, getName() + messageToString(message));
}
return NOT_HANDLED;
}
}
// Sends CMD_PRE_DHCP_ACTION to the controller, waits for the controller to respond with
// CMD_PRE_DHCP_ACTION_COMPLETE, and then transitions to mOtherState.
abstract class WaitBeforeOtherState extends LoggingState {
protected State mOtherState;
@Override
public void enter() {
super.enter();
mController.sendMessage(DhcpStateMachine.CMD_PRE_DHCP_ACTION);
}
@Override
public boolean processMessage(Message message) {
super.processMessage(message);
switch (message.what) {
case DhcpStateMachine.CMD_PRE_DHCP_ACTION_COMPLETE:
transitionTo(mOtherState);
return HANDLED;
default:
return NOT_HANDLED;
}
}
}
// The one-shot timeout is used to implement the timeout for CMD_START_DHCP. We can't use a
// state timeout to do this because obtaining an IP address involves passing through more than
// one state (specifically, it passes at least once through DhcpInitState and once through
// DhcpRequestingState). The one-shot timeout is created when CMD_START_DHCP is received, and is
// cancelled when exiting DhcpState (either due to a CMD_STOP_DHCP, or because of an error), or
// when we get an IP address (when entering DhcpBoundState). If it fires, we send ourselves
// CMD_ONESHOT_TIMEOUT and notify the caller that DHCP failed, but we take no other action. For
// example, if we're in DhcpInitState and sending DISCOVERs, we continue to do so.
//
// The one-shot timeout is not used for CMD_RENEW_DHCP because that is implemented using only
// one state, so we can just use the state timeout.
private void scheduleOneshotTimeout() {
final long alarmTime = SystemClock.elapsedRealtime() + DHCP_TIMEOUT_MS;
mAlarmManager.setExact(AlarmManager.ELAPSED_REALTIME_WAKEUP, alarmTime,
mOneshotTimeoutIntent);
}
private void cancelOneshotTimeout() {
mAlarmManager.cancel(mOneshotTimeoutIntent);
}
class StoppedState extends LoggingState {
@Override
public boolean processMessage(Message message) {
super.processMessage(message);
switch (message.what) {
case DhcpStateMachine.CMD_START_DHCP:
scheduleOneshotTimeout();
if (mRegisteredForPreDhcpNotification) {
transitionTo(mWaitBeforeStartState);
} else {
transitionTo(mDhcpInitState);
}
return HANDLED;
default:
return NOT_HANDLED;
}
}
}
class WaitBeforeStartState extends WaitBeforeOtherState {
public WaitBeforeStartState(State otherState) {
super();
mOtherState = otherState;
}
}
class WaitBeforeRenewalState extends WaitBeforeOtherState {
public WaitBeforeRenewalState(State otherState) {
super();
mOtherState = otherState;
}
}
class DhcpState extends LoggingState {
@Override
public void enter() {
super.enter();
clearDhcpState();
if (initInterface() && initSockets()) {
mReceiveThread = new ReceiveThread();
mReceiveThread.start();
} else {
notifyFailure();
transitionTo(mStoppedState);
}
}
@Override
public void exit() {
cancelOneshotTimeout();
if (mReceiveThread != null) {
mReceiveThread.halt(); // Also closes sockets.
mReceiveThread = null;
}
clearDhcpState();
}
@Override
public boolean processMessage(Message message) {
super.processMessage(message);
switch (message.what) {
case DhcpStateMachine.CMD_STOP_DHCP:
transitionTo(mStoppedState);
return HANDLED;
case CMD_ONESHOT_TIMEOUT:
maybeLog("Timed out");
notifyFailure();
return HANDLED;
default:
return NOT_HANDLED;
}
}
}
public boolean isValidPacket(DhcpPacket packet) {
// TODO: check checksum.
int xid = packet.getTransactionId();
if (xid != mTransactionId) {
Log.d(TAG, "Unexpected transaction ID " + xid + ", expected " + mTransactionId);
return false;
}
if (!Arrays.equals(packet.getClientMac(), mHwAddr)) {
Log.d(TAG, "MAC addr mismatch: got " +
HexDump.toHexString(packet.getClientMac()) + ", expected " +
HexDump.toHexString(packet.getClientMac()));
return false;
}
return true;
}
public void setDhcpLeaseExpiry(DhcpPacket packet) {
long leaseTimeMillis = packet.getLeaseTimeMillis();
mDhcpLeaseExpiry =
(leaseTimeMillis > 0) ? SystemClock.elapsedRealtime() + leaseTimeMillis : 0;
}
/**
* Retransmits packets using jittered exponential backoff with an optional timeout. Packet
* transmission is triggered by CMD_KICK, which is sent by an AlarmManager alarm. If a subclass
* sets mTimeout to a positive value, then timeout() is called by an AlarmManager alarm mTimeout
* milliseconds after entering the state. Kicks and timeouts are cancelled when leaving the
* state.
*
* Concrete subclasses must implement sendPacket, which is called when the alarm fires and a
* packet needs to be transmitted, and receivePacket, which is triggered by CMD_RECEIVED_PACKET
* sent by the receive thread. They may also set mTimeout and implement timeout.
*/
abstract class PacketRetransmittingState extends LoggingState {
private int mTimer;
protected int mTimeout = 0;
@Override
public void enter() {
super.enter();
initTimer();
maybeInitTimeout();
sendMessage(CMD_KICK);
}
@Override
public boolean processMessage(Message message) {
super.processMessage(message);
switch (message.what) {
case CMD_KICK:
sendPacket();
scheduleKick();
return HANDLED;
case CMD_RECEIVED_PACKET:
receivePacket((DhcpPacket) message.obj);
return HANDLED;
case CMD_TIMEOUT:
timeout();
return HANDLED;
default:
return NOT_HANDLED;
}
}
public void exit() {
mAlarmManager.cancel(mKickIntent);
mAlarmManager.cancel(mTimeoutIntent);
}
abstract protected boolean sendPacket();
abstract protected void receivePacket(DhcpPacket packet);
protected void timeout() {}
protected void initTimer() {
mTimer = FIRST_TIMEOUT_MS;
}
protected int jitterTimer(int baseTimer) {
int maxJitter = baseTimer / 10;
int jitter = mRandom.nextInt(2 * maxJitter) - maxJitter;
return baseTimer + jitter;
}
protected void scheduleKick() {
long now = SystemClock.elapsedRealtime();
long timeout = jitterTimer(mTimer);
long alarmTime = now + timeout;
mAlarmManager.cancel(mKickIntent);
mAlarmManager.setExact(AlarmManager.ELAPSED_REALTIME_WAKEUP, alarmTime, mKickIntent);
mTimer *= 2;
if (mTimer > MAX_TIMEOUT_MS) {
mTimer = MAX_TIMEOUT_MS;
}
}
protected void maybeInitTimeout() {
if (mTimeout > 0) {
long alarmTime = SystemClock.elapsedRealtime() + mTimeout;
mAlarmManager.setExact(
AlarmManager.ELAPSED_REALTIME_WAKEUP, alarmTime, mTimeoutIntent);
}
}
}
class DhcpInitState extends PacketRetransmittingState {
public DhcpInitState() {
super();
}
@Override
public void enter() {
super.enter();
startNewTransaction();
}
protected boolean sendPacket() {
return sendDiscoverPacket();
}
protected void receivePacket(DhcpPacket packet) {
if (!isValidPacket(packet)) return;
if (!(packet instanceof DhcpOfferPacket)) return;
mOffer = packet.toDhcpResults();
if (mOffer != null) {
Log.d(TAG, "Got pending lease: " + mOffer);
transitionTo(mDhcpRequestingState);
}
}
}
// Not implemented. We request the first offer we receive.
class DhcpSelectingState extends LoggingState {
}
class DhcpRequestingState extends PacketRetransmittingState {
public DhcpRequestingState() {
super();
mTimeout = DHCP_TIMEOUT_MS / 2;
}
protected boolean sendPacket() {
return sendRequestPacket(
INADDR_ANY, // ciaddr
(Inet4Address) mOffer.ipAddress.getAddress(), // DHCP_REQUESTED_IP
(Inet4Address) mOffer.serverAddress, // DHCP_SERVER_IDENTIFIER
INADDR_BROADCAST); // packet destination address
}
protected void receivePacket(DhcpPacket packet) {
if (!isValidPacket(packet)) return;
if ((packet instanceof DhcpAckPacket)) {
DhcpResults results = packet.toDhcpResults();
if (results != null) {
mDhcpLease = results;
mOffer = null;
Log.d(TAG, "Confirmed lease: " + mDhcpLease);
setDhcpLeaseExpiry(packet);
transitionTo(mDhcpBoundState);
}
} else if (packet instanceof DhcpNakPacket) {
Log.d(TAG, "Received NAK, returning to INIT");
mOffer = null;
transitionTo(mDhcpInitState);
}
}
@Override
protected void timeout() {
// After sending REQUESTs unsuccessfully for a while, go back to init.
transitionTo(mDhcpInitState);
}
}
class DhcpHaveAddressState extends LoggingState {
@Override
public void enter() {
super.enter();
if (setIpAddress(mDhcpLease.ipAddress)) {
maybeLog("Configured IP address " + mDhcpLease.ipAddress);
} else {
Log.e(TAG, "Failed to configure IP address " + mDhcpLease.ipAddress);
notifyFailure();
// There's likely no point in going into DhcpInitState here, we'll probably just
// repeat the transaction, get the same IP address as before, and fail.
transitionTo(mStoppedState);
}
}
@Override
public void exit() {
maybeLog("Clearing IP address");
setIpAddress(new LinkAddress("0.0.0.0/0"));
}
}
class DhcpBoundState extends LoggingState {
@Override
public void enter() {
super.enter();
cancelOneshotTimeout();
notifySuccess();
// TODO: DhcpStateMachine only supports renewing at 50% of the lease time, and does not
// support rebinding. Once the legacy DHCP client is gone, fix this.
scheduleRenew();
}
@Override
public boolean processMessage(Message message) {
super.processMessage(message);
switch (message.what) {
case DhcpStateMachine.CMD_RENEW_DHCP:
if (mRegisteredForPreDhcpNotification) {
transitionTo(mWaitBeforeRenewalState);
} else {
transitionTo(mDhcpRenewingState);
}
return HANDLED;
default:
return NOT_HANDLED;
}
}
}
class DhcpRenewingState extends PacketRetransmittingState {
public DhcpRenewingState() {
super();
mTimeout = DHCP_TIMEOUT_MS;
}
@Override
public void enter() {
super.enter();
startNewTransaction();
}
protected boolean sendPacket() {
return sendRequestPacket(
(Inet4Address) mDhcpLease.ipAddress.getAddress(), // ciaddr
INADDR_ANY, // DHCP_REQUESTED_IP
INADDR_ANY, // DHCP_SERVER_IDENTIFIER
(Inet4Address) mDhcpLease.serverAddress); // packet destination address
}
protected void receivePacket(DhcpPacket packet) {
if (!isValidPacket(packet)) return;
if ((packet instanceof DhcpAckPacket)) {
setDhcpLeaseExpiry(packet);
transitionTo(mDhcpBoundState);
} else if (packet instanceof DhcpNakPacket) {
transitionTo(mDhcpInitState);
}
}
@Override
protected void timeout() {
transitionTo(mDhcpInitState);
sendMessage(CMD_ONESHOT_TIMEOUT);
}
}
// Not implemented. DhcpStateMachine does not implement it either.
class DhcpRebindingState extends LoggingState {
}
class DhcpInitRebootState extends LoggingState {
}
class DhcpRebootingState extends LoggingState {
}
}