packages/VpnServices/src/com/android/server/vpn/VpnService.java - platform/frameworks/base - Gitiles

 /*
  * Copyright (C) 2007, 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.vpn;

 import android.app.Notification;
 import android.app.NotificationManager;
 import android.app.PendingIntent;
 import android.content.Context;
 import android.net.vpn.VpnManager;
 import android.net.vpn.VpnProfile;
 import android.net.vpn.VpnState;
 import android.os.FileObserver;
 import android.os.SystemProperties;
 import android.util.Log;

 import java.io.File;
 import java.io.IOException;
 import java.net.InetAddress;
 import java.net.InetSocketAddress;
 import java.net.Socket;
 import java.util.ArrayList;
 import java.util.List;

 /**
  * The service base class for managing a type of VPN connection.
  */
 abstract class VpnService<E extends VpnProfile> {
     private static final int NOTIFICATION_ID = 1;
     private static final String PROFILES_ROOT = VpnManager.PROFILES_PATH + "/";
     public static final String DEFAULT_CONFIG_PATH = "/etc";

     private static final int DNS_TIMEOUT = 3000; // ms
     private static final String DNS1 = "net.dns1";
     private static final String DNS2 = "net.dns2";
     private static final String REMOTE_IP = "net.ipremote";
     private static final String DNS_DOMAIN_SUFFICES = "net.dns.search";
     private static final String SERVER_IP = "net.vpn.server_ip";

     private static final int VPN_TIMEOUT = 30000; // milliseconds
     private static final int ONE_SECOND = 1000; // milliseconds
     private static final int FIVE_SECOND = 5000; // milliseconds

     private static final String LOGWRAPPER = "/system/bin/logwrapper";
     private final String TAG = VpnService.class.getSimpleName();

     E mProfile;
     VpnServiceBinder mContext;

     private VpnState mState = VpnState.IDLE;
     private boolean mInError;

     // connection settings
     private String mOriginalDns1;
     private String mOriginalDns2;
     private String mVpnDns1 = "";
     private String mVpnDns2 = "";
     private String mOriginalDomainSuffices;
     private String mHostIp;

     private long mStartTime; // VPN connection start time

     // monitors if the VPN connection is sucessfully established
     private FileMonitor mConnectMonitor;

     // watch dog timer; fired up if the connection cannot be established within
     // VPN_TIMEOUT
     private Object mWatchdog;

     // for helping managing multiple Android services
     private ServiceHelper mServiceHelper = new ServiceHelper();

     // for helping showing, updating notification
     private NotificationHelper mNotification = new NotificationHelper();

     /**
      * Establishes a VPN connection with the specified username and password.
      */
     protected abstract void connect(String serverIp, String username,
             String password) throws IOException;

     /**
      * Tears down the VPN connection. The base class simply terminates all the
      * Android services. A subclass may need to do some clean-up before that.
      */
     protected void disconnect() {
     }

     /**
      * Starts an Android service defined in init.rc.
      */
     protected AndroidServiceProxy startService(String serviceName)
             throws IOException {
         return mServiceHelper.startService(serviceName);
     }

     protected String getPppOptionFilePath() throws IOException {
         String subpath = getProfileSubpath("/ppp/peers");
         String[] kids = new File(subpath).list();
         if ((kids == null) || (kids.length == 0)) {
             throw new IOException("no option file found in " + subpath);
         }
         if (kids.length > 1) {
             Log.w(TAG, "more than one option file found in " + subpath
                     + ", arbitrarily choose " + kids[0]);
         }
         return subpath + "/" + kids[0];
     }

     /**
      * Returns the VPN profile associated with the connection.
      */
     protected E getProfile() {
         return mProfile;
     }

     /**
      * Returns the profile path where configuration files reside.
      */
     protected String getProfilePath() throws IOException {
         String path = PROFILES_ROOT + mProfile.getId();
         File dir = new File(path);
         if (!dir.exists()) throw new IOException("Profile dir does not exist");
         return path;
     }

     /**
      * Returns the path where default configuration files reside.
      */
     protected String getDefaultConfigPath() throws IOException {
         return DEFAULT_CONFIG_PATH;
     }

     /**
      * Returns the host IP for establishing the VPN connection.
      */
     protected String getHostIp() throws IOException {
         if (mHostIp == null) mHostIp = reallyGetHostIp();
         return mHostIp;
     }

     /**
      * Returns the IP of the specified host name.
      */
     protected String getIp(String hostName) throws IOException {
         InetAddress iaddr = InetAddress.getByName(hostName);
         byte[] aa = iaddr.getAddress();
         StringBuilder sb = new StringBuilder().append(byteToInt(aa[0]));
         for (int i = 1; i < aa.length; i++) {
             sb.append(".").append(byteToInt(aa[i]));
         }
         return sb.toString();
     }

     /**
      * Returns the path of the script file that is executed when the VPN
      * connection is established.
      */
     protected String getConnectMonitorFile() {
         return "/etc/ppp/ip-up";
     }

     /**
      * Sets the system property. The method is blocked until the value is
      * settled in.
      * @param name the name of the property
      * @param value the value of the property
      * @throws IOException if it fails to set the property within 2 seconds
      */
     protected void setSystemProperty(String name, String value)
             throws IOException {
         SystemProperties.set(name, value);
         for (int i = 0; i < 5; i++) {
             String v = SystemProperties.get(name);
             if (v.equals(value)) {
                 return;
             } else {
                 Log.d(TAG, "sys_prop: wait for " + name + " to settle in");
                 sleep(400);
             }
         }
         throw new IOException("Failed to set system property: " + name);
     }

     void setContext(VpnServiceBinder context, E profile) {
         mContext = context;
         mProfile = profile;
     }

     VpnState getState() {
         return mState;
     }

     synchronized void onConnect(String username, String password)
             throws IOException {
         mState = VpnState.CONNECTING;
         broadcastConnectivity(VpnState.CONNECTING);

         String serverIp = getIp(getProfile().getServerName());
         setSystemProperty(SERVER_IP, serverIp);
         onBeforeConnect();

         connect(serverIp, username, password);
     }

     synchronized void onDisconnect(boolean cleanUpServices) {
         try {
             mState = VpnState.DISCONNECTING;
             broadcastConnectivity(VpnState.DISCONNECTING);
             mNotification.showDisconnect();

             // subclass implementation
             if (cleanUpServices) disconnect();

             mServiceHelper.stop();
         } catch (Throwable e) {
             Log.e(TAG, "onError()", e);
             onFinalCleanUp();
         }
     }

     synchronized void onError() {
         // error may occur during or after connection setup
         // and it may be due to one or all services gone
         mInError = true;
         switch (mState) {
         case CONNECTED:
             onDisconnect(true);
             break;

         case CONNECTING:
             onDisconnect(false);
             break;
         }
     }

     private void createConnectMonitor() {
         mConnectMonitor = new FileMonitor(getConnectMonitorFile(),
                 new Runnable() {
                     public void run() {
                         onConnectMonitorTriggered();
                     }
                 });
     }

     private void onBeforeConnect() {
         mNotification.disableNotification();

         createConnectMonitor();
         mConnectMonitor.startWatching();
         saveOriginalDnsProperties();

         mWatchdog = startTimer(VPN_TIMEOUT, new Runnable() {
             public void run() {
                 synchronized (VpnService.this) {
                     if (mState == VpnState.CONNECTING) {
                         Log.d(TAG, "       watchdog timer is fired !!");
                         onError();
                     }
                 }
             }
         });
     }

     private synchronized void onConnectMonitorTriggered() {
         Log.d(TAG, "onConnectMonitorTriggered()");

         stopTimer(mWatchdog);
         mConnectMonitor.stopWatching();
         saveVpnDnsProperties();
         saveAndSetDomainSuffices();
         startConnectivityMonitor();

         mState = VpnState.CONNECTED;
         broadcastConnectivity(VpnState.CONNECTED);
     }

     private synchronized void onFinalCleanUp() {
         Log.d(TAG, "onFinalCleanUp()");

         if (mState == VpnState.IDLE) return;

         // keep the notification when error occurs
         if (!mInError) mNotification.disableNotification();

         restoreOriginalDnsProperties();
         restoreOriginalDomainSuffices();
         if (mConnectMonitor != null) mConnectMonitor.stopWatching();
         if (mWatchdog != null) stopTimer(mWatchdog);
         mState = VpnState.IDLE;
         broadcastConnectivity(VpnState.IDLE);

         // stop the service itself
         mContext.stopSelf();
     }

     private synchronized void onOneServiceGone() {
         switch (mState) {
         case IDLE:
         case DISCONNECTING:
             break;

         default:
             onError();
         }
     }

     private synchronized void onAllServicesGone() {
         switch (mState) {
         case IDLE:
             break;

         case DISCONNECTING:
             // daemons are gone; now clean up everything
             onFinalCleanUp();
             break;

         default:
             onError();
         }
     }

     private void saveOriginalDnsProperties() {
         mOriginalDns1 = SystemProperties.get(DNS1);
         mOriginalDns2 = SystemProperties.get(DNS2);
         Log.d(TAG, String.format("save original dns prop: %s, %s",
                 mOriginalDns1, mOriginalDns2));
     }

     private void restoreOriginalDnsProperties() {
         // restore only if they are not overridden
         if (mVpnDns1.equals(SystemProperties.get(DNS1))) {
             Log.d(TAG, String.format("restore original dns prop: %s --> %s",
                     SystemProperties.get(DNS1), mOriginalDns1));
             Log.d(TAG, String.format("restore original dns prop: %s --> %s",
                     SystemProperties.get(DNS2), mOriginalDns2));
             SystemProperties.set(DNS1, mOriginalDns1);
             SystemProperties.set(DNS2, mOriginalDns2);
         }
     }

     private void saveVpnDnsProperties() {
         mVpnDns1 = mVpnDns2 = "";
         for (int i = 0; i < 10; i++) {
             mVpnDns1 = SystemProperties.get(DNS1);
             mVpnDns2 = SystemProperties.get(DNS2);
             if (mVpnDns1.equals(mOriginalDns1)) {
                 Log.d(TAG, "wait for vpn dns to settle in..." + i);
                 sleep(500);
             } else {
                 Log.d(TAG, String.format("save vpn dns prop: %s, %s",
                         mVpnDns1, mVpnDns2));
                 return;
             }
         }
         Log.e(TAG, "saveVpnDnsProperties(): DNS not updated??");
     }

     private void restoreVpnDnsProperties() {
         if (isNullOrEmpty(mVpnDns1) && isNullOrEmpty(mVpnDns2)) {
             return;
         }
         Log.d(TAG, String.format("restore vpn dns prop: %s --> %s",
                 SystemProperties.get(DNS1), mVpnDns1));
         Log.d(TAG, String.format("restore vpn dns prop: %s --> %s",
                 SystemProperties.get(DNS2), mVpnDns2));
         SystemProperties.set(DNS1, mVpnDns1);
         SystemProperties.set(DNS2, mVpnDns2);
     }

     private void saveAndSetDomainSuffices() {
         mOriginalDomainSuffices = SystemProperties.get(DNS_DOMAIN_SUFFICES);
         Log.d(TAG, "save original dns search: " + mOriginalDomainSuffices);
         String list = mProfile.getDomainSuffices();
         if (!isNullOrEmpty(list)) {
             SystemProperties.set(DNS_DOMAIN_SUFFICES, list);
         }
     }

     private void restoreOriginalDomainSuffices() {
         Log.d(TAG, "restore original dns search --> " + mOriginalDomainSuffices);
         SystemProperties.set(DNS_DOMAIN_SUFFICES, mOriginalDomainSuffices);
     }

     private void broadcastConnectivity(VpnState s) {
         new VpnManager(mContext).broadcastConnectivity(mProfile.getName(), s);
     }

     private void startConnectivityMonitor() {
         mStartTime = System.currentTimeMillis();

         new Thread(new Runnable() {
             public void run() {
                 Log.d(TAG, "   +++++   connectivity monitor running");
                 try {
                     for (;;) {
                         synchronized (VpnService.this) {
                             if (mState != VpnState.CONNECTED) break;
                             mNotification.update();
                             checkConnectivity();
                             VpnService.this.wait(ONE_SECOND);
                         }
                     }
                 } catch (InterruptedException e) {
                     Log.e(TAG, "connectivity monitor", e);
                 }
                 Log.d(TAG, "   -----   connectivity monitor stopped");
             }
         }).start();
     }

     private void checkConnectivity() {
         checkDnsProperties();
     }

     private void checkDnsProperties() {
         String dns1 = SystemProperties.get(DNS1);
         if (!mVpnDns1.equals(dns1)) {
             Log.w(TAG, "   @@ !!!    dns being overridden");
             onError();
         }
     }

     private Object startTimer(final int milliseconds, final Runnable task) {
         Thread thread = new Thread(new Runnable() {
             public void run() {
                 Log.d(TAG, "watchdog timer started");
                 Thread t = Thread.currentThread();
                 try {
                     synchronized (t) {
                         t.wait(milliseconds);
                     }
                     task.run();
                 } catch (InterruptedException e) {
                     // ignored
                 }
                 Log.d(TAG, "watchdog timer stopped");
             }
         });
         thread.start();
         return thread;
     }

     private void stopTimer(Object timer) {
         synchronized (timer) {
             timer.notify();
         }
     }

     private String reallyGetHostIp() throws IOException {
         Socket s = new Socket();
         s.connect(new InetSocketAddress("www.google.com", 80), DNS_TIMEOUT);
         String ipAddress = s.getLocalAddress().getHostAddress();
         Log.d(TAG, "Host IP: " + ipAddress);
         s.close();
         return ipAddress;
     }

     private String getProfileSubpath(String subpath) throws IOException {
         String path = getProfilePath() + subpath;
         if (new File(path).exists()) {
             return path;
         } else {
             Log.w(TAG, "Profile subpath does not exist: " + path
                     + ", use default one");
             String path2 = getDefaultConfigPath() + subpath;
             if (!new File(path2).exists()) {
                 throw new IOException("Profile subpath does not exist at "
                         + path + " or " + path2);
             }
             return path2;
         }
     }

     private void sleep(int ms) {
         try {
             Thread.currentThread().sleep(ms);
         } catch (InterruptedException e) {
         }
     }

     private static boolean isNullOrEmpty(String message) {
         return ((message == null) || (message.length() == 0));
     }

     private static int byteToInt(byte b) {
         return ((int) b) & 0x0FF;
     }

     private class ServiceHelper implements ProcessProxy.Callback {
         private List<AndroidServiceProxy> mServiceList =
                 new ArrayList<AndroidServiceProxy>();

         // starts an Android service
         AndroidServiceProxy startService(String serviceName)
                 throws IOException {
             AndroidServiceProxy service = new AndroidServiceProxy(serviceName);
             mServiceList.add(service);
             service.start(this);
             return service;
         }

         // stops all the Android services
         void stop() {
             if (mServiceList.isEmpty()) {
                 onFinalCleanUp();
             } else {
                 for (AndroidServiceProxy s : mServiceList) s.stop();
             }
         }

         //@Override
         public void done(ProcessProxy p) {
             Log.d(TAG, "service done: " + p.getName());
             commonCallback((AndroidServiceProxy) p);
         }

         //@Override
         public void error(ProcessProxy p, Throwable e) {
             Log.e(TAG, "service error: " + p.getName(), e);
             commonCallback((AndroidServiceProxy) p);
         }

         private void commonCallback(AndroidServiceProxy service) {
             mServiceList.remove(service);
             onOneServiceGone();
             if (mServiceList.isEmpty()) onAllServicesGone();
         }
     }

     private class FileMonitor extends FileObserver {
         private Runnable mCallback;

         FileMonitor(String path, Runnable callback) {
             super(path, CLOSE_NOWRITE);
             mCallback = callback;
         }

         @Override
         public void onEvent(int event, String path) {
             if ((event & CLOSE_NOWRITE) > 0) mCallback.run();
         }
     }

     // Helper class for showing, updating notification.
     private class NotificationHelper {
         void update() {
             String title = getNotificationTitle(true);
             Notification n = new Notification(R.drawable.vpn_connected, title,
                     mStartTime);
             n.setLatestEventInfo(mContext, title,
                     getNotificationMessage(true), prepareNotificationIntent());
             n.flags |= Notification.FLAG_NO_CLEAR;
             n.flags |= Notification.FLAG_ONGOING_EVENT;
             enableNotification(n);
         }

         void showDisconnect() {
             String title = getNotificationTitle(false);
             Notification n = new Notification(R.drawable.vpn_disconnected,
                     title, System.currentTimeMillis());
             n.setLatestEventInfo(mContext, title,
                     getNotificationMessage(false), prepareNotificationIntent());
             n.flags |= Notification.FLAG_AUTO_CANCEL;
             disableNotification();
             enableNotification(n);
         }

         void disableNotification() {
             ((NotificationManager) mContext.getSystemService(
                     Context.NOTIFICATION_SERVICE)).cancel(NOTIFICATION_ID);
         }

         private void enableNotification(Notification n) {
             ((NotificationManager) mContext.getSystemService(
                     Context.NOTIFICATION_SERVICE)).notify(NOTIFICATION_ID, n);
         }

         private PendingIntent prepareNotificationIntent() {
             return PendingIntent.getActivity(mContext, 0,
                     new VpnManager(mContext).createSettingsActivityIntent(), 0);
         }

         private String getNotificationTitle(boolean connected) {
             String connectedOrNot = connected
                     ? mContext.getString(R.string.vpn_notification_connected)
                     : mContext.getString(
                             R.string.vpn_notification_disconnected);
             return String.format(
                     mContext.getString(R.string.vpn_notification_title),
                     mProfile.getName(), connectedOrNot);
         }

         private String getTimeFormat(long duration) {
             long hours = duration / 3600;
             StringBuilder sb = new StringBuilder();
             if (hours > 0) sb.append(hours).append(':');
             sb.append(String.format("%02d:%02d", (duration % 3600 / 60),
                     (duration % 60)));
             return sb.toString();
         }

         private String getNotificationMessage(boolean connected) {
             if (connected) {
                 long time = (System.currentTimeMillis() - mStartTime) / 1000;
                 return String.format(mContext.getString(
                         R.string.vpn_notification_connected_message),
                         getTimeFormat(time));
             } else {
                 return "";
             }
         }
     }
 }
	/*
	* Copyright (C) 2007, 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.vpn;

	import android.app.Notification;
	import android.app.NotificationManager;
	import android.app.PendingIntent;
	import android.content.Context;
	import android.net.vpn.VpnManager;
	import android.net.vpn.VpnProfile;
	import android.net.vpn.VpnState;
	import android.os.FileObserver;
	import android.os.SystemProperties;
	import android.util.Log;

	import java.io.File;
	import java.io.IOException;
	import java.net.InetAddress;
	import java.net.InetSocketAddress;
	import java.net.Socket;
	import java.util.ArrayList;
	import java.util.List;

	/**
	* The service base class for managing a type of VPN connection.
	*/
	abstract class VpnService<E extends VpnProfile> {
	private static final int NOTIFICATION_ID = 1;
	private static final String PROFILES_ROOT = VpnManager.PROFILES_PATH + "/";
	public static final String DEFAULT_CONFIG_PATH = "/etc";

	private static final int DNS_TIMEOUT = 3000; // ms
	private static final String DNS1 = "net.dns1";
	private static final String DNS2 = "net.dns2";
	private static final String REMOTE_IP = "net.ipremote";
	private static final String DNS_DOMAIN_SUFFICES = "net.dns.search";
	private static final String SERVER_IP = "net.vpn.server_ip";

	private static final int VPN_TIMEOUT = 30000; // milliseconds
	private static final int ONE_SECOND = 1000; // milliseconds
	private static final int FIVE_SECOND = 5000; // milliseconds

	private static final String LOGWRAPPER = "/system/bin/logwrapper";
	private final String TAG = VpnService.class.getSimpleName();

	E mProfile;
	VpnServiceBinder mContext;

	private VpnState mState = VpnState.IDLE;
	private boolean mInError;

	// connection settings
	private String mOriginalDns1;
	private String mOriginalDns2;
	private String mVpnDns1 = "";
	private String mVpnDns2 = "";
	private String mOriginalDomainSuffices;
	private String mHostIp;

	private long mStartTime; // VPN connection start time

	// monitors if the VPN connection is sucessfully established
	private FileMonitor mConnectMonitor;

	// watch dog timer; fired up if the connection cannot be established within
	// VPN_TIMEOUT
	private Object mWatchdog;

	// for helping managing multiple Android services
	private ServiceHelper mServiceHelper = new ServiceHelper();

	// for helping showing, updating notification
	private NotificationHelper mNotification = new NotificationHelper();

	/**
	* Establishes a VPN connection with the specified username and password.
	*/
	protected abstract void connect(String serverIp, String username,
	String password) throws IOException;

	/**
	* Tears down the VPN connection. The base class simply terminates all the
	* Android services. A subclass may need to do some clean-up before that.
	*/
	protected void disconnect() {
	}

	/**
	* Starts an Android service defined in init.rc.
	*/
	protected AndroidServiceProxy startService(String serviceName)
	throws IOException {
	return mServiceHelper.startService(serviceName);
	}

	protected String getPppOptionFilePath() throws IOException {
	String subpath = getProfileSubpath("/ppp/peers");
	String[] kids = new File(subpath).list();
	if ((kids == null) \|\| (kids.length == 0)) {
	throw new IOException("no option file found in " + subpath);
	}
	if (kids.length > 1) {
	Log.w(TAG, "more than one option file found in " + subpath
	+ ", arbitrarily choose " + kids[0]);
	}
	return subpath + "/" + kids[0];
	}

	/**
	* Returns the VPN profile associated with the connection.
	*/
	protected E getProfile() {
	return mProfile;
	}

	/**
	* Returns the profile path where configuration files reside.
	*/
	protected String getProfilePath() throws IOException {
	String path = PROFILES_ROOT + mProfile.getId();
	File dir = new File(path);
	if (!dir.exists()) throw new IOException("Profile dir does not exist");
	return path;
	}

	/**
	* Returns the path where default configuration files reside.
	*/
	protected String getDefaultConfigPath() throws IOException {
	return DEFAULT_CONFIG_PATH;
	}

	/**
	* Returns the host IP for establishing the VPN connection.
	*/
	protected String getHostIp() throws IOException {
	if (mHostIp == null) mHostIp = reallyGetHostIp();
	return mHostIp;
	}

	/**
	* Returns the IP of the specified host name.
	*/
	protected String getIp(String hostName) throws IOException {
	InetAddress iaddr = InetAddress.getByName(hostName);
	byte[] aa = iaddr.getAddress();
	StringBuilder sb = new StringBuilder().append(byteToInt(aa[0]));
	for (int i = 1; i < aa.length; i++) {
	sb.append(".").append(byteToInt(aa[i]));
	}
	return sb.toString();
	}

	/**
	* Returns the path of the script file that is executed when the VPN
	* connection is established.
	*/
	protected String getConnectMonitorFile() {
	return "/etc/ppp/ip-up";
	}

	/**
	* Sets the system property. The method is blocked until the value is
	* settled in.
	* @param name the name of the property
	* @param value the value of the property
	* @throws IOException if it fails to set the property within 2 seconds
	*/
	protected void setSystemProperty(String name, String value)
	throws IOException {
	SystemProperties.set(name, value);
	for (int i = 0; i < 5; i++) {
	String v = SystemProperties.get(name);
	if (v.equals(value)) {
	return;
	} else {
	Log.d(TAG, "sys_prop: wait for " + name + " to settle in");
	sleep(400);
	}
	}
	throw new IOException("Failed to set system property: " + name);
	}

	void setContext(VpnServiceBinder context, E profile) {
	mContext = context;
	mProfile = profile;
	}

	VpnState getState() {
	return mState;
	}

	synchronized void onConnect(String username, String password)
	throws IOException {
	mState = VpnState.CONNECTING;
	broadcastConnectivity(VpnState.CONNECTING);

	String serverIp = getIp(getProfile().getServerName());
	setSystemProperty(SERVER_IP, serverIp);
	onBeforeConnect();

	connect(serverIp, username, password);
	}

	synchronized void onDisconnect(boolean cleanUpServices) {
	try {
	mState = VpnState.DISCONNECTING;
	broadcastConnectivity(VpnState.DISCONNECTING);
	mNotification.showDisconnect();

	// subclass implementation
	if (cleanUpServices) disconnect();

	mServiceHelper.stop();
	} catch (Throwable e) {
	Log.e(TAG, "onError()", e);
	onFinalCleanUp();
	}
	}

	synchronized void onError() {
	// error may occur during or after connection setup
	// and it may be due to one or all services gone
	mInError = true;
	switch (mState) {
	case CONNECTED:
	onDisconnect(true);
	break;

	case CONNECTING:
	onDisconnect(false);
	break;
	}
	}

	private void createConnectMonitor() {
	mConnectMonitor = new FileMonitor(getConnectMonitorFile(),
	new Runnable() {
	public void run() {
	onConnectMonitorTriggered();
	}
	});
	}

	private void onBeforeConnect() {
	mNotification.disableNotification();

	createConnectMonitor();
	mConnectMonitor.startWatching();
	saveOriginalDnsProperties();

	mWatchdog = startTimer(VPN_TIMEOUT, new Runnable() {
	public void run() {
	synchronized (VpnService.this) {
	if (mState == VpnState.CONNECTING) {
	Log.d(TAG, " watchdog timer is fired !!");
	onError();
	}
	}
	}
	});
	}

	private synchronized void onConnectMonitorTriggered() {
	Log.d(TAG, "onConnectMonitorTriggered()");

	stopTimer(mWatchdog);
	mConnectMonitor.stopWatching();
	saveVpnDnsProperties();
	saveAndSetDomainSuffices();
	startConnectivityMonitor();

	mState = VpnState.CONNECTED;
	broadcastConnectivity(VpnState.CONNECTED);
	}

	private synchronized void onFinalCleanUp() {
	Log.d(TAG, "onFinalCleanUp()");

	if (mState == VpnState.IDLE) return;

	// keep the notification when error occurs
	if (!mInError) mNotification.disableNotification();

	restoreOriginalDnsProperties();
	restoreOriginalDomainSuffices();
	if (mConnectMonitor != null) mConnectMonitor.stopWatching();
	if (mWatchdog != null) stopTimer(mWatchdog);
	mState = VpnState.IDLE;
	broadcastConnectivity(VpnState.IDLE);

	// stop the service itself
	mContext.stopSelf();
	}

	private synchronized void onOneServiceGone() {
	switch (mState) {
	case IDLE:
	case DISCONNECTING:
	break;

	default:
	onError();
	}
	}

	private synchronized void onAllServicesGone() {
	switch (mState) {
	case IDLE:
	break;

	case DISCONNECTING:
	// daemons are gone; now clean up everything
	onFinalCleanUp();
	break;

	default:
	onError();
	}
	}

	private void saveOriginalDnsProperties() {
	mOriginalDns1 = SystemProperties.get(DNS1);
	mOriginalDns2 = SystemProperties.get(DNS2);
	Log.d(TAG, String.format("save original dns prop: %s, %s",
	mOriginalDns1, mOriginalDns2));
	}

	private void restoreOriginalDnsProperties() {
	// restore only if they are not overridden
	if (mVpnDns1.equals(SystemProperties.get(DNS1))) {
	Log.d(TAG, String.format("restore original dns prop: %s --> %s",
	SystemProperties.get(DNS1), mOriginalDns1));
	Log.d(TAG, String.format("restore original dns prop: %s --> %s",
	SystemProperties.get(DNS2), mOriginalDns2));
	SystemProperties.set(DNS1, mOriginalDns1);
	SystemProperties.set(DNS2, mOriginalDns2);
	}
	}

	private void saveVpnDnsProperties() {
	mVpnDns1 = mVpnDns2 = "";
	for (int i = 0; i < 10; i++) {
	mVpnDns1 = SystemProperties.get(DNS1);
	mVpnDns2 = SystemProperties.get(DNS2);
	if (mVpnDns1.equals(mOriginalDns1)) {
	Log.d(TAG, "wait for vpn dns to settle in..." + i);
	sleep(500);
	} else {
	Log.d(TAG, String.format("save vpn dns prop: %s, %s",
	mVpnDns1, mVpnDns2));
	return;
	}
	}
	Log.e(TAG, "saveVpnDnsProperties(): DNS not updated??");
	}

	private void restoreVpnDnsProperties() {
	if (isNullOrEmpty(mVpnDns1) && isNullOrEmpty(mVpnDns2)) {
	return;
	}
	Log.d(TAG, String.format("restore vpn dns prop: %s --> %s",
	SystemProperties.get(DNS1), mVpnDns1));
	Log.d(TAG, String.format("restore vpn dns prop: %s --> %s",
	SystemProperties.get(DNS2), mVpnDns2));
	SystemProperties.set(DNS1, mVpnDns1);
	SystemProperties.set(DNS2, mVpnDns2);
	}

	private void saveAndSetDomainSuffices() {
	mOriginalDomainSuffices = SystemProperties.get(DNS_DOMAIN_SUFFICES);
	Log.d(TAG, "save original dns search: " + mOriginalDomainSuffices);
	String list = mProfile.getDomainSuffices();
	if (!isNullOrEmpty(list)) {
	SystemProperties.set(DNS_DOMAIN_SUFFICES, list);
	}
	}

	private void restoreOriginalDomainSuffices() {
	Log.d(TAG, "restore original dns search --> " + mOriginalDomainSuffices);
	SystemProperties.set(DNS_DOMAIN_SUFFICES, mOriginalDomainSuffices);
	}

	private void broadcastConnectivity(VpnState s) {
	new VpnManager(mContext).broadcastConnectivity(mProfile.getName(), s);
	}

	private void startConnectivityMonitor() {
	mStartTime = System.currentTimeMillis();

	new Thread(new Runnable() {
	public void run() {
	Log.d(TAG, " +++++ connectivity monitor running");
	try {
	for (;;) {
	synchronized (VpnService.this) {
	if (mState != VpnState.CONNECTED) break;
	mNotification.update();
	checkConnectivity();
	VpnService.this.wait(ONE_SECOND);
	}
	}
	} catch (InterruptedException e) {
	Log.e(TAG, "connectivity monitor", e);
	}
	Log.d(TAG, " ----- connectivity monitor stopped");
	}
	}).start();
	}

	private void checkConnectivity() {
	checkDnsProperties();
	}

	private void checkDnsProperties() {
	String dns1 = SystemProperties.get(DNS1);
	if (!mVpnDns1.equals(dns1)) {
	Log.w(TAG, " @@ !!! dns being overridden");
	onError();
	}
	}

	private Object startTimer(final int milliseconds, final Runnable task) {
	Thread thread = new Thread(new Runnable() {
	public void run() {
	Log.d(TAG, "watchdog timer started");
	Thread t = Thread.currentThread();
	try {
	synchronized (t) {
	t.wait(milliseconds);
	}
	task.run();
	} catch (InterruptedException e) {
	// ignored
	}
	Log.d(TAG, "watchdog timer stopped");
	}
	});
	thread.start();
	return thread;
	}

	private void stopTimer(Object timer) {
	synchronized (timer) {
	timer.notify();
	}
	}

	private String reallyGetHostIp() throws IOException {
	Socket s = new Socket();
	s.connect(new InetSocketAddress("www.google.com", 80), DNS_TIMEOUT);
	String ipAddress = s.getLocalAddress().getHostAddress();
	Log.d(TAG, "Host IP: " + ipAddress);
	s.close();
	return ipAddress;
	}

	private String getProfileSubpath(String subpath) throws IOException {
	String path = getProfilePath() + subpath;
	if (new File(path).exists()) {
	return path;
	} else {
	Log.w(TAG, "Profile subpath does not exist: " + path
	+ ", use default one");
	String path2 = getDefaultConfigPath() + subpath;
	if (!new File(path2).exists()) {
	throw new IOException("Profile subpath does not exist at "
	+ path + " or " + path2);
	}
	return path2;
	}
	}

	private void sleep(int ms) {
	try {
	Thread.currentThread().sleep(ms);
	} catch (InterruptedException e) {
	}
	}

	private static boolean isNullOrEmpty(String message) {
	return ((message == null) \|\| (message.length() == 0));
	}

	private static int byteToInt(byte b) {
	return ((int) b) & 0x0FF;
	}

	private class ServiceHelper implements ProcessProxy.Callback {
	private List<AndroidServiceProxy> mServiceList =
	new ArrayList<AndroidServiceProxy>();

	// starts an Android service
	AndroidServiceProxy startService(String serviceName)
	throws IOException {
	AndroidServiceProxy service = new AndroidServiceProxy(serviceName);
	mServiceList.add(service);
	service.start(this);
	return service;
	}

	// stops all the Android services
	void stop() {
	if (mServiceList.isEmpty()) {
	onFinalCleanUp();
	} else {
	for (AndroidServiceProxy s : mServiceList) s.stop();
	}
	}

	//@Override
	public void done(ProcessProxy p) {
	Log.d(TAG, "service done: " + p.getName());
	commonCallback((AndroidServiceProxy) p);
	}

	//@Override
	public void error(ProcessProxy p, Throwable e) {
	Log.e(TAG, "service error: " + p.getName(), e);
	commonCallback((AndroidServiceProxy) p);
	}

	private void commonCallback(AndroidServiceProxy service) {
	mServiceList.remove(service);
	onOneServiceGone();
	if (mServiceList.isEmpty()) onAllServicesGone();
	}
	}

	private class FileMonitor extends FileObserver {
	private Runnable mCallback;

	FileMonitor(String path, Runnable callback) {
	super(path, CLOSE_NOWRITE);
	mCallback = callback;
	}

	@Override
	public void onEvent(int event, String path) {
	if ((event & CLOSE_NOWRITE) > 0) mCallback.run();
	}
	}

	// Helper class for showing, updating notification.
	private class NotificationHelper {
	void update() {
	String title = getNotificationTitle(true);
	Notification n = new Notification(R.drawable.vpn_connected, title,
	mStartTime);
	n.setLatestEventInfo(mContext, title,
	getNotificationMessage(true), prepareNotificationIntent());
	n.flags \|= Notification.FLAG_NO_CLEAR;
	n.flags \|= Notification.FLAG_ONGOING_EVENT;
	enableNotification(n);
	}

	void showDisconnect() {
	String title = getNotificationTitle(false);
	Notification n = new Notification(R.drawable.vpn_disconnected,
	title, System.currentTimeMillis());
	n.setLatestEventInfo(mContext, title,
	getNotificationMessage(false), prepareNotificationIntent());
	n.flags \|= Notification.FLAG_AUTO_CANCEL;
	disableNotification();
	enableNotification(n);
	}

	void disableNotification() {
	((NotificationManager) mContext.getSystemService(
	Context.NOTIFICATION_SERVICE)).cancel(NOTIFICATION_ID);
	}

	private void enableNotification(Notification n) {
	((NotificationManager) mContext.getSystemService(
	Context.NOTIFICATION_SERVICE)).notify(NOTIFICATION_ID, n);
	}

	private PendingIntent prepareNotificationIntent() {
	return PendingIntent.getActivity(mContext, 0,
	new VpnManager(mContext).createSettingsActivityIntent(), 0);
	}

	private String getNotificationTitle(boolean connected) {
	String connectedOrNot = connected
	? mContext.getString(R.string.vpn_notification_connected)
	: mContext.getString(
	R.string.vpn_notification_disconnected);
	return String.format(
	mContext.getString(R.string.vpn_notification_title),
	mProfile.getName(), connectedOrNot);
	}

	private String getTimeFormat(long duration) {
	long hours = duration / 3600;
	StringBuilder sb = new StringBuilder();
	if (hours > 0) sb.append(hours).append(':');
	sb.append(String.format("%02d:%02d", (duration % 3600 / 60),
	(duration % 60)));
	return sb.toString();
	}

	private String getNotificationMessage(boolean connected) {
	if (connected) {
	long time = (System.currentTimeMillis() - mStartTime) / 1000;
	return String.format(mContext.getString(
	R.string.vpn_notification_connected_message),
	getTimeFormat(time));
	} else {
	return "";
	}
	}
	}
	}