Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 31be7cf4 authored by Irfan Sheriff's avatar Irfan Sheriff
Browse files

Add DhcpStateMachine for interation with dhcpcd 

- Supports wakeup and renewal on dhcp
- Supports multiple controllers to use the state machine
  simultaneously
- Optionally, a controller can request a notification prior
  to DHCP request/renewal being sent

Change-Id: I3a9d7e6a02ff26be3a86ddca6964683ad3c28f93
parent d7f739b1

core/java/android/net/DhcpStateMachine.java

0 → 100644
+353 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2011 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;



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.DhcpInfoInternal;

import android.net.NetworkUtils;

import android.os.Message;

import android.os.PowerManager;

import android.os.SystemClock;

import android.util.Log;



/**

 * StateMachine that interacts with the native DHCP client and can talk to

 * a controller that also needs to be a StateMachine

 *

 * The Dhcp state machine provides the following features:

 * - Wakeup and renewal using the native DHCP client  (which will not renew

 *   on its own when the device is in suspend state and this can lead to device

 *   holding IP address beyond expiry)

 * - A notification right before DHCP request or renewal is started. This

 *   can be used for any additional setup before DHCP. For example, wifi sets

 *   BT-Wifi coex settings right before DHCP is initiated

 *

 * @hide

 */

public class DhcpStateMachine extends StateMachine {



    private static final String TAG = "DhcpStateMachine";

    private static final boolean DBG = false;





    /* A StateMachine that controls the DhcpStateMachine */

    private StateMachine mController;



    private Context mContext;

    private BroadcastReceiver mBroadcastReceiver;

    private AlarmManager mAlarmManager;

    private PendingIntent mDhcpRenewalIntent;

    private PowerManager.WakeLock mDhcpRenewWakeLock;

    private static final String WAKELOCK_TAG = "DHCP";



    private static final int DHCP_RENEW = 0;

    private static final String ACTION_DHCP_RENEW = "android.net.wifi.DHCP_RENEW";



    private enum DhcpAction {

        START,

        RENEW

    };



    private String mInterfaceName;

    private boolean mRegisteredForPreDhcpNotification = false;



    private static final int BASE = Protocol.BASE_DHCP;



    /* Commands from controller to start/stop DHCP */

    public static final int CMD_START_DHCP                  = BASE + 1;

    public static final int CMD_STOP_DHCP                   = BASE + 2;

    public static final int CMD_RENEW_DHCP                  = BASE + 3;



    /* Notification from DHCP state machine prior to DHCP discovery/renewal */

    public static final int CMD_PRE_DHCP_ACTION             = BASE + 4;

    /* Notification from DHCP state machine post DHCP discovery/renewal. Indicates

     * success/failure */

    public static final int CMD_POST_DHCP_ACTION            = BASE + 5;



    /* Command from controller to indicate DHCP discovery/renewal can continue

     * after pre DHCP action is complete */

    public static final int CMD_PRE_DHCP_ACTION_COMPLETE    = BASE + 6;



    /* Message.arg1 arguments to CMD_POST_DHCP notification */

    public static final int DHCP_SUCCESS = 1;

    public static final int DHCP_FAILURE = 2;



    private State mDefaultState = new DefaultState();

    private State mStoppedState = new StoppedState();

    private State mWaitBeforeStartState = new WaitBeforeStartState();

    private State mRunningState = new RunningState();

    private State mWaitBeforeRenewalState = new WaitBeforeRenewalState();



    private DhcpStateMachine(Context context, StateMachine controller, String intf) {

        super(TAG);



        mContext = context;

        mController = controller;

        mInterfaceName = intf;



        mAlarmManager = (AlarmManager)mContext.getSystemService(Context.ALARM_SERVICE);

        Intent dhcpRenewalIntent = new Intent(ACTION_DHCP_RENEW, null);

        mDhcpRenewalIntent = PendingIntent.getBroadcast(mContext, DHCP_RENEW, dhcpRenewalIntent, 0);



        PowerManager powerManager = (PowerManager)mContext.getSystemService(Context.POWER_SERVICE);

        mDhcpRenewWakeLock = powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, WAKELOCK_TAG);



        mBroadcastReceiver = new BroadcastReceiver() {

            @Override

            public void onReceive(Context context, Intent intent) {

                //DHCP renew

                if (DBG) Log.d(TAG, "Sending a DHCP renewal " + this);

                //acquire a 40s wakelock to finish DHCP renewal

                mDhcpRenewWakeLock.acquire(40000);

                sendMessage(CMD_RENEW_DHCP);

            }

        };

        mContext.registerReceiver(mBroadcastReceiver, new IntentFilter(ACTION_DHCP_RENEW));



        addState(mDefaultState);

            addState(mStoppedState, mDefaultState);

            addState(mWaitBeforeStartState, mDefaultState);

            addState(mRunningState, mDefaultState);

            addState(mWaitBeforeRenewalState, mDefaultState);



        setInitialState(mStoppedState);

    }



    public static DhcpStateMachine makeDhcpStateMachine(Context context, StateMachine controller,

            String intf) {

        DhcpStateMachine dsm = new DhcpStateMachine(context, controller, intf);

        dsm.start();

        return dsm;

    }



    /**

     * This sends a notification right before DHCP request/renewal so that the

     * controller can do certain actions before DHCP packets are sent out.

     * When the controller is ready, it sends a CMD_PRE_DHCP_ACTION_COMPLETE message

     * to indicate DHCP can continue

     *

     * This is used by Wifi at this time for the purpose of doing BT-Wifi coex

     * handling during Dhcp

     */

    public void registerForPreDhcpNotification() {

        mRegisteredForPreDhcpNotification = true;

    }



    class DefaultState extends State {

        @Override

        public boolean processMessage(Message message) {

            if (DBG) Log.d(TAG, getName() + message.toString() + "\n");

            switch (message.what) {

                case CMD_RENEW_DHCP:

                    Log.e(TAG, "Error! Failed to handle a DHCP renewal on " + mInterfaceName);

                    break;

                case SM_QUIT_CMD:

                    mContext.unregisterReceiver(mBroadcastReceiver);

                    //let parent kill the state machine

                    return NOT_HANDLED;

                default:

                    Log.e(TAG, "Error! unhandled message  " + message);

                    break;

            }

            return HANDLED;

        }

    }





    class StoppedState extends State {

        @Override

        public void enter() {

            if (DBG) Log.d(TAG, getName() + "\n");

        }



        @Override

        public boolean processMessage(Message message) {

            boolean retValue = HANDLED;

            if (DBG) Log.d(TAG, getName() + message.toString() + "\n");

            switch (message.what) {

                case CMD_START_DHCP:

                    if (mRegisteredForPreDhcpNotification) {

                        /* Notify controller before starting DHCP */

                        mController.sendMessage(CMD_PRE_DHCP_ACTION);

                        transitionTo(mWaitBeforeStartState);

                    } else {

                        if (runDhcp(DhcpAction.START)) {

                            transitionTo(mRunningState);

                        }

                    }

                    break;

                case CMD_STOP_DHCP:

                    //ignore

                    break;

                default:

                    retValue = NOT_HANDLED;

                    break;

            }

            return retValue;

        }

    }



    class WaitBeforeStartState extends State {

        @Override

        public void enter() {

            if (DBG) Log.d(TAG, getName() + "\n");

        }



        @Override

        public boolean processMessage(Message message) {

            boolean retValue = HANDLED;

            if (DBG) Log.d(TAG, getName() + message.toString() + "\n");

            switch (message.what) {

                case CMD_PRE_DHCP_ACTION_COMPLETE:

                    if (runDhcp(DhcpAction.START)) {

                        transitionTo(mRunningState);

                    } else {

                        transitionTo(mStoppedState);

                    }

                    break;

                case CMD_STOP_DHCP:

                    transitionTo(mStoppedState);

                    break;

                case CMD_START_DHCP:

                    //ignore

                    break;

                default:

                    retValue = NOT_HANDLED;

                    break;

            }

            return retValue;

        }

    }



    class RunningState extends State {

        @Override

        public void enter() {

            if (DBG) Log.d(TAG, getName() + "\n");

        }



        @Override

        public boolean processMessage(Message message) {

            boolean retValue = HANDLED;

            if (DBG) Log.d(TAG, getName() + message.toString() + "\n");

            switch (message.what) {

                case CMD_STOP_DHCP:

                    mAlarmManager.cancel(mDhcpRenewalIntent);

                    if (!NetworkUtils.stopDhcp(mInterfaceName)) {

                        Log.e(TAG, "Failed to stop Dhcp on " + mInterfaceName);

                    }

                    transitionTo(mStoppedState);

                    break;

                case CMD_RENEW_DHCP:

                    if (mRegisteredForPreDhcpNotification) {

                        /* Notify controller before starting DHCP */

                        mController.sendMessage(CMD_PRE_DHCP_ACTION);

                        transitionTo(mWaitBeforeRenewalState);

                    } else {

                        if (!runDhcp(DhcpAction.RENEW)) {

                            transitionTo(mStoppedState);

                        }

                    }

                    break;

                case CMD_START_DHCP:

                    //ignore

                    break;

                default:

                    retValue = NOT_HANDLED;

            }

            return retValue;

        }

    }



    class WaitBeforeRenewalState extends State {

        @Override

        public void enter() {

            if (DBG) Log.d(TAG, getName() + "\n");

        }



        @Override

        public boolean processMessage(Message message) {

            boolean retValue = HANDLED;

            if (DBG) Log.d(TAG, getName() + message.toString() + "\n");

            switch (message.what) {

                case CMD_STOP_DHCP:

                    mAlarmManager.cancel(mDhcpRenewalIntent);

                    if (!NetworkUtils.stopDhcp(mInterfaceName)) {

                        Log.e(TAG, "Failed to stop Dhcp on " + mInterfaceName);

                    }

                    transitionTo(mStoppedState);

                    break;

                case CMD_PRE_DHCP_ACTION_COMPLETE:

                    if (runDhcp(DhcpAction.RENEW)) {

                       transitionTo(mRunningState);

                    } else {

                       transitionTo(mStoppedState);

                    }

                    break;

                case CMD_START_DHCP:

                    //ignore

                    break;

                default:

                    retValue = NOT_HANDLED;

                    break;

            }

            return retValue;

        }

    }



    private boolean runDhcp(DhcpAction dhcpAction) {

        boolean success = false;

        DhcpInfoInternal dhcpInfoInternal = new DhcpInfoInternal();



        if (dhcpAction == DhcpAction.START) {

            Log.d(TAG, "DHCP request on " + mInterfaceName);

            success = NetworkUtils.runDhcp(mInterfaceName, dhcpInfoInternal);

        } else if (dhcpAction == DhcpAction.RENEW) {

            Log.d(TAG, "DHCP renewal on " + mInterfaceName);

            success = NetworkUtils.runDhcpRenew(mInterfaceName, dhcpInfoInternal);

        }



        if (success) {

            Log.d(TAG, "DHCP succeeded on " + mInterfaceName);

            //Do it a bit earlier than half the lease duration time

            //to beat the native DHCP client and avoid extra packets

            //48% for one hour lease time = 29 minutes

            mAlarmManager.set(AlarmManager.ELAPSED_REALTIME_WAKEUP,

                    SystemClock.elapsedRealtime() +

                    dhcpInfoInternal.leaseDuration * 480, //in milliseconds

                    mDhcpRenewalIntent);



            mController.obtainMessage(CMD_POST_DHCP_ACTION, DHCP_SUCCESS, 0, dhcpInfoInternal)

                .sendToTarget();

        } else {

            Log.d(TAG, "DHCP failed on " + mInterfaceName + ": " +

                    NetworkUtils.getDhcpError());

            NetworkUtils.stopDhcp(mInterfaceName);

            mController.obtainMessage(CMD_POST_DHCP_ACTION, DHCP_FAILURE, 0)

                .sendToTarget();

        }

        return success;

    }

}

core/java/android/net/NetworkUtils.java

+10 −0
Original line number Diff line number Diff line
@@ -79,6 +79,16 @@ public class NetworkUtils { 
     */

    public native static boolean runDhcp(String interfaceName, DhcpInfoInternal ipInfo);



    /**

     * Initiate renewal on the Dhcp client daemon. This call blocks until it obtains

     * a result (either success or failure) from the daemon.

     * @param interfaceName the name of the interface to configure

     * @param ipInfo if the request succeeds, this object is filled in with

     * the IP address information.

     * @return {@code true} for success, {@code false} for failure

     */

    public native static boolean runDhcpRenew(String interfaceName, DhcpInfoInternal ipInfo);



    /**

     * Shut down the DHCP client daemon.

     * @param interfaceName the name of the interface for which the daemon

core/jni/android_net_NetUtils.cpp

+32 −3
Original line number Diff line number Diff line
@@ -40,6 +40,16 @@ int dhcp_do_request(const char *ifname, 
                    const char *dns2,

                    const char *server,

                    uint32_t  *lease);



int dhcp_do_request_renew(const char *ifname,

                    const char *ipaddr,

                    const char *gateway,

                    uint32_t  *prefixLength,

                    const char *dns1,

                    const char *dns2,

                    const char *server,

                    uint32_t  *lease);



int dhcp_stop(const char *ifname);

int dhcp_release_lease(const char *ifname);

char *dhcp_get_errmsg();
@@ -146,7 +156,8 @@ static jint android_net_utils_resetConnections(JNIEnv* env, jobject clazz, jstri 
    return (jint)result;

}



static jboolean android_net_utils_runDhcp(JNIEnv* env, jobject clazz, jstring ifname, jobject info)

static jboolean android_net_utils_runDhcpCommon(JNIEnv* env, jobject clazz, jstring ifname,

        jobject info, bool renew)

{

    int result;

    char  ipaddr[PROPERTY_VALUE_MAX];
@@ -160,8 +171,14 @@ static jboolean android_net_utils_runDhcp(JNIEnv* env, jobject clazz, jstring if 
    const char *nameStr = env->GetStringUTFChars(ifname, NULL);

    if (nameStr == NULL) return (jboolean)false;



    if (renew) {

        result = ::dhcp_do_request_renew(nameStr, ipaddr, gateway, &prefixLength,

                dns1, dns2, server, &lease);

    } else {

        result = ::dhcp_do_request(nameStr, ipaddr, gateway, &prefixLength,

                dns1, dns2, server, &lease);

    }



    env->ReleaseStringUTFChars(ifname, nameStr);

    if (result == 0 && dhcpInfoInternalFieldIds.dhcpInfoInternalClass != NULL) {

        env->SetObjectField(info, dhcpInfoInternalFieldIds.ipaddress, env->NewStringUTF(ipaddr));
@@ -176,6 +193,17 @@ static jboolean android_net_utils_runDhcp(JNIEnv* env, jobject clazz, jstring if 
    return (jboolean)(result == 0);

}



static jboolean android_net_utils_runDhcp(JNIEnv* env, jobject clazz, jstring ifname, jobject info)

{

    return android_net_utils_runDhcpCommon(env, clazz, ifname, info, false);

}



static jboolean android_net_utils_runDhcpRenew(JNIEnv* env, jobject clazz, jstring ifname, jobject info)

{

    return android_net_utils_runDhcpCommon(env, clazz, ifname, info, true);

}





static jboolean android_net_utils_stopDhcp(JNIEnv* env, jobject clazz, jstring ifname)

{

    int result;
@@ -219,6 +247,7 @@ static JNINativeMethod gNetworkUtilMethods[] = { 
    { "removeDefaultRoute", "(Ljava/lang/String;)I",  (void *)android_net_utils_removeDefaultRoute },

    { "resetConnections", "(Ljava/lang/String;)I",  (void *)android_net_utils_resetConnections },

    { "runDhcp", "(Ljava/lang/String;Landroid/net/DhcpInfoInternal;)Z",  (void *)android_net_utils_runDhcp },

    { "runDhcpRenew", "(Ljava/lang/String;Landroid/net/DhcpInfoInternal;)Z",  (void *)android_net_utils_runDhcpRenew },

    { "stopDhcp", "(Ljava/lang/String;)Z",  (void *)android_net_utils_stopDhcp },

    { "releaseDhcpLease", "(Ljava/lang/String;)Z",  (void *)android_net_utils_releaseDhcpLease },

    { "getDhcpError", "()Ljava/lang/String;", (void*) android_net_utils_getDhcpError },

wifi/java/android/net/wifi/WifiStateMachine.java

+150 −128

File changed.

Preview size limit exceeded, changes collapsed.