484 lines
18 KiB
Java
484 lines
18 KiB
Java
/*
|
|
* Copyright (C) 2010 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.connectivity;
|
|
|
|
import android.app.Notification;
|
|
import android.app.NotificationManager;
|
|
import android.app.PendingIntent;
|
|
import android.content.BroadcastReceiver;
|
|
import android.content.ContentResolver;
|
|
import android.content.Context;
|
|
import android.content.Intent;
|
|
import android.content.IntentFilter;
|
|
import android.content.res.Resources;
|
|
import android.net.ConnectivityManager;
|
|
import android.net.INetworkManagementEventObserver;
|
|
import android.os.IBinder;
|
|
import android.os.INetworkManagementService;
|
|
import android.os.RemoteException;
|
|
import android.os.ServiceManager;
|
|
import android.provider.Settings;
|
|
import android.util.Log;
|
|
|
|
import java.util.ArrayList;
|
|
/**
|
|
* @hide
|
|
*/
|
|
public class Tethering extends INetworkManagementEventObserver.Stub {
|
|
|
|
private Notification mTetheringNotification;
|
|
private Context mContext;
|
|
private final String TAG = "Tethering";
|
|
|
|
private boolean mPlaySounds = false;
|
|
|
|
private ArrayList<String> mAvailableIfaces;
|
|
private ArrayList<String> mActiveIfaces;
|
|
|
|
private ArrayList<String> mActiveTtys;
|
|
|
|
private BroadcastReceiver mStateReceiver;
|
|
|
|
public Tethering(Context context) {
|
|
Log.d(TAG, "Tethering starting");
|
|
mContext = context;
|
|
|
|
// register for notifications from NetworkManagement Service
|
|
IBinder b = ServiceManager.getService(Context.NETWORKMANAGEMENT_SERVICE);
|
|
INetworkManagementService service = INetworkManagementService.Stub.asInterface(b);
|
|
try {
|
|
service.registerObserver(this);
|
|
} catch (RemoteException e) {
|
|
Log.e(TAG, "Error registering observer :" + e);
|
|
}
|
|
|
|
mAvailableIfaces = new ArrayList<String>();
|
|
mActiveIfaces = new ArrayList<String>();
|
|
mActiveTtys = new ArrayList<String>();
|
|
|
|
// TODO - remove this hack after real USB connections are detected.
|
|
IntentFilter filter = new IntentFilter();
|
|
filter.addAction(Intent.ACTION_UMS_DISCONNECTED);
|
|
filter.addAction(Intent.ACTION_UMS_CONNECTED);
|
|
mStateReceiver = new UMSStateReceiver();
|
|
mContext.registerReceiver(mStateReceiver, filter);
|
|
}
|
|
|
|
public synchronized void interfaceLinkStatusChanged(String iface, boolean link) {
|
|
Log.d(TAG, "interfaceLinkStatusChanged " + iface + ", " + link);
|
|
}
|
|
|
|
public synchronized void interfaceAdded(String iface) {
|
|
if (mActiveIfaces.contains(iface)) {
|
|
Log.e(TAG, "active iface (" + iface + ") reported as added, ignoring");
|
|
return;
|
|
}
|
|
if (mAvailableIfaces.contains(iface)) {
|
|
Log.e(TAG, "available iface (" + iface + ") readded, ignoring");
|
|
return;
|
|
}
|
|
mAvailableIfaces.add(iface);
|
|
Log.d(TAG, "interfaceAdded :" + iface);
|
|
sendTetherStateChangedBroadcast();
|
|
}
|
|
|
|
public synchronized void interfaceRemoved(String iface) {
|
|
if (mActiveIfaces.contains(iface)) {
|
|
Log.d(TAG, "removed an active iface (" + iface + ")");
|
|
untether(iface);
|
|
}
|
|
if (mAvailableIfaces.contains(iface)) {
|
|
mAvailableIfaces.remove(iface);
|
|
Log.d(TAG, "interfaceRemoved " + iface);
|
|
sendTetherStateChangedBroadcast();
|
|
}
|
|
}
|
|
|
|
public synchronized boolean tether(String iface) {
|
|
Log.d(TAG, "Tethering " + iface);
|
|
|
|
if (!mAvailableIfaces.contains(iface)) {
|
|
Log.e(TAG, "Tried to Tether an unavailable iface :" + iface + ", ignoring");
|
|
return false;
|
|
}
|
|
if (mActiveIfaces.contains(iface)) {
|
|
Log.e(TAG, "Tried to Tether an already Tethered iface :" + iface + ", ignoring");
|
|
return false;
|
|
}
|
|
|
|
IBinder b = ServiceManager.getService(Context.NETWORKMANAGEMENT_SERVICE);
|
|
INetworkManagementService service = INetworkManagementService.Stub.asInterface(b);
|
|
|
|
if (mActiveIfaces.size() == 0) {
|
|
try {
|
|
service.setIpForwardingEnabled(true);
|
|
} catch (Exception e) {
|
|
Log.e(TAG, "Error in setIpForwardingEnabled(true) :" + e);
|
|
return false;
|
|
}
|
|
|
|
try {
|
|
// TODO - don't hardcode this - though with non-conf values (un-routable)
|
|
// maybe it's not a big deal
|
|
service.startTethering("169.254.2.1", "169.254.2.64");
|
|
} catch (Exception e) {
|
|
Log.e(TAG, "Error in startTethering :" + e);
|
|
try {
|
|
service.setIpForwardingEnabled(false);
|
|
} catch (Exception ee) {}
|
|
return false;
|
|
}
|
|
|
|
try {
|
|
// TODO - maybe use the current connection's dns servers for this
|
|
String[] dns = new String[2];
|
|
dns[0] = new String("8.8.8.8");
|
|
dns[1] = new String("4.2.2.2");
|
|
service.setDnsForwarders(dns);
|
|
} catch (Exception e) {
|
|
Log.e(TAG, "Error in setDnsForwarders :" + e);
|
|
try {
|
|
service.stopTethering();
|
|
} catch (Exception ee) {}
|
|
try {
|
|
service.setIpForwardingEnabled(false);
|
|
} catch (Exception ee) {}
|
|
}
|
|
}
|
|
|
|
try {
|
|
service.tetherInterface(iface);
|
|
} catch (Exception e) {
|
|
Log.e(TAG, "Error in tetherInterface :" + e);
|
|
if (mActiveIfaces.size() == 0) {
|
|
try {
|
|
service.stopTethering();
|
|
} catch (Exception ee) {}
|
|
try {
|
|
service.setIpForwardingEnabled(false);
|
|
} catch (Exception ee) {}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
try {
|
|
// TODO - use the currently active external iface
|
|
service.enableNat (iface, "rmnet0");
|
|
} catch (Exception e) {
|
|
Log.e(TAG, "Error in enableNat :" + e);
|
|
try {
|
|
service.untetherInterface(iface);
|
|
} catch (Exception ee) {}
|
|
if (mActiveIfaces.size() == 0) {
|
|
try {
|
|
service.stopTethering();
|
|
} catch (Exception ee) {}
|
|
try {
|
|
service.setIpForwardingEnabled(false);
|
|
} catch (Exception ee) {}
|
|
}
|
|
return false;
|
|
}
|
|
mAvailableIfaces.remove(iface);
|
|
mActiveIfaces.add(iface);
|
|
Log.d(TAG, "Tethered " + iface);
|
|
sendTetherStateChangedBroadcast();
|
|
return true;
|
|
}
|
|
|
|
public synchronized boolean untether(String iface) {
|
|
Log.d(TAG, "Untethering " + iface);
|
|
|
|
if (mAvailableIfaces.contains(iface)) {
|
|
Log.e(TAG, "Tried to Untether an available iface :" + iface);
|
|
return false;
|
|
}
|
|
if (!mActiveIfaces.contains(iface)) {
|
|
Log.e(TAG, "Tried to Untether an inactive iface :" + iface);
|
|
return false;
|
|
}
|
|
|
|
IBinder b = ServiceManager.getService(Context.NETWORKMANAGEMENT_SERVICE);
|
|
INetworkManagementService service = INetworkManagementService.Stub.asInterface(b);
|
|
|
|
// none of these errors are recoverable - ie, multiple calls won't help
|
|
// and the user can't do anything. Basically a reboot is required and probably
|
|
// the device is misconfigured or something bad has happend.
|
|
// Because of this, we should try to unroll as much state as we can.
|
|
try {
|
|
service.disableNat(iface, "rmnet0");
|
|
} catch (Exception e) {
|
|
Log.e(TAG, "Error in disableNat :" + e);
|
|
}
|
|
try {
|
|
service.untetherInterface(iface);
|
|
} catch (Exception e) {
|
|
Log.e(TAG, "Error untethering " + iface + ", :" + e);
|
|
}
|
|
mActiveIfaces.remove(iface);
|
|
mAvailableIfaces.add(iface);
|
|
|
|
if (mActiveIfaces.size() == 0) {
|
|
Log.d(TAG, "no active tethers - turning down dhcp/ipforward");
|
|
try {
|
|
service.stopTethering();
|
|
} catch (Exception e) {
|
|
Log.e(TAG, "Error in stopTethering :" + e);
|
|
}
|
|
try {
|
|
service.setIpForwardingEnabled(false);
|
|
} catch (Exception e) {
|
|
Log.e(TAG, "Error in setIpForwardingEnabled(false) :" + e);
|
|
}
|
|
}
|
|
sendTetherStateChangedBroadcast();
|
|
Log.d(TAG, "Untethered " + iface);
|
|
return true;
|
|
}
|
|
|
|
private void sendTetherStateChangedBroadcast() {
|
|
Intent broadcast = new Intent(ConnectivityManager.ACTION_TETHER_STATE_CHANGED);
|
|
broadcast.addFlags(Intent.FLAG_RECEIVER_REPLACE_PENDING);
|
|
broadcast.putExtra(ConnectivityManager.EXTRA_AVAILABLE_TETHER_COUNT,
|
|
mAvailableIfaces.size());
|
|
broadcast.putExtra(ConnectivityManager.EXTRA_ACTIVE_TETHER_COUNT, mActiveIfaces.size());
|
|
mContext.sendBroadcast(broadcast);
|
|
|
|
// for USB we only have the one, so don't have to deal with additional
|
|
if (mAvailableIfaces.size() > 0) {
|
|
// Check if the user wants to be bothered
|
|
boolean tellUser = (Settings.Secure.getInt(mContext.getContentResolver(),
|
|
Settings.Secure.TETHER_NOTIFY, 0) == 1);
|
|
|
|
if (tellUser) {
|
|
showTetherAvailableNotification();
|
|
}
|
|
} else if (mActiveIfaces.size() > 0) {
|
|
showTetheredNotification();
|
|
} else {
|
|
clearNotification();
|
|
}
|
|
}
|
|
|
|
private void showTetherAvailableNotification() {
|
|
NotificationManager notificationManager = (NotificationManager)mContext.
|
|
getSystemService(Context.NOTIFICATION_SERVICE);
|
|
if (notificationManager == null) {
|
|
return;
|
|
}
|
|
|
|
Intent intent = new Intent();
|
|
intent.setClass(mContext, com.android.internal.app.TetherActivity.class);
|
|
|
|
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
|
|
PendingIntent pi = PendingIntent.getActivity(mContext, 0, intent, 0);
|
|
|
|
Resources r = Resources.getSystem();
|
|
CharSequence title = r.getText(com.android.internal.R.string.
|
|
tether_available_notification_title);
|
|
CharSequence message = r.getText(com.android.internal.R.string.
|
|
tether_available_notification_message);
|
|
|
|
if(mTetheringNotification == null) {
|
|
mTetheringNotification = new Notification();
|
|
mTetheringNotification.when = 0;
|
|
}
|
|
mTetheringNotification.icon = com.android.internal.R.drawable.stat_sys_tether_usb;
|
|
|
|
boolean playSounds = false;
|
|
//playSounds = SystemProperties.get("persist.service.mount.playsnd", "1").equals("1");
|
|
if (playSounds) {
|
|
mTetheringNotification.defaults |= Notification.DEFAULT_SOUND;
|
|
} else {
|
|
mTetheringNotification.defaults &= ~Notification.DEFAULT_SOUND;
|
|
}
|
|
|
|
mTetheringNotification.flags = Notification.FLAG_ONGOING_EVENT;
|
|
mTetheringNotification.tickerText = title;
|
|
mTetheringNotification.setLatestEventInfo(mContext, title, message, pi);
|
|
|
|
notificationManager.notify(mTetheringNotification.icon, mTetheringNotification);
|
|
|
|
}
|
|
|
|
private void showTetheredNotification() {
|
|
NotificationManager notificationManager = (NotificationManager)mContext.
|
|
getSystemService(Context.NOTIFICATION_SERVICE);
|
|
if (notificationManager == null) {
|
|
return;
|
|
}
|
|
|
|
Intent intent = new Intent();
|
|
intent.setClass(mContext, com.android.internal.app.TetherActivity.class);
|
|
|
|
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
|
|
PendingIntent pi = PendingIntent.getActivity(mContext, 0, intent, 0);
|
|
|
|
Resources r = Resources.getSystem();
|
|
CharSequence title = r.getText(com.android.internal.R.string.
|
|
tether_stop_notification_title);
|
|
CharSequence message = r.getText(com.android.internal.R.string.
|
|
tether_stop_notification_message);
|
|
|
|
if(mTetheringNotification == null) {
|
|
mTetheringNotification = new Notification();
|
|
mTetheringNotification.when = 0;
|
|
}
|
|
mTetheringNotification.icon = com.android.internal.R.drawable.stat_sys_tether_usb;
|
|
|
|
boolean playSounds = false;
|
|
//playSounds = SystemProperties.get("persist.service.mount.playsnd", "1").equals("1");
|
|
if (playSounds) {
|
|
mTetheringNotification.defaults |= Notification.DEFAULT_SOUND;
|
|
} else {
|
|
mTetheringNotification.defaults &= ~Notification.DEFAULT_SOUND;
|
|
}
|
|
|
|
mTetheringNotification.flags = Notification.FLAG_ONGOING_EVENT;
|
|
mTetheringNotification.tickerText = title;
|
|
mTetheringNotification.setLatestEventInfo(mContext, title, message, pi);
|
|
|
|
notificationManager.notify(mTetheringNotification.icon, mTetheringNotification);
|
|
}
|
|
|
|
private void clearNotification() {
|
|
NotificationManager notificationManager = (NotificationManager)mContext.
|
|
getSystemService(Context.NOTIFICATION_SERVICE);
|
|
if (notificationManager != null && mTetheringNotification != null) {
|
|
notificationManager.cancel(mTetheringNotification.icon);
|
|
mTetheringNotification = null;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
// TODO - remove this hack after we get proper USB detection
|
|
private class UMSStateReceiver extends BroadcastReceiver {
|
|
public void onReceive(Context content, Intent intent) {
|
|
if (intent.getAction().equals(Intent.ACTION_UMS_CONNECTED)) {
|
|
Tethering.this.handleTtyConnect();
|
|
} else if (intent.getAction().equals(Intent.ACTION_UMS_DISCONNECTED)) {
|
|
Tethering.this.handleTtyDisconnect();
|
|
}
|
|
}
|
|
}
|
|
|
|
private synchronized void handleTtyConnect() {
|
|
Log.d(TAG, "handleTtyConnect");
|
|
// for each of the available Tty not already supported by a ppp session,
|
|
// create a ppp session
|
|
// TODO - this should be data-driven rather than hard coded.
|
|
String[] allowedTtys = new String[1];
|
|
allowedTtys[0] = new String("ttyGS0");
|
|
|
|
IBinder b = ServiceManager.getService(Context.NETWORKMANAGEMENT_SERVICE);
|
|
INetworkManagementService service = INetworkManagementService.Stub.asInterface(b);
|
|
|
|
String[] availableTtys;
|
|
try {
|
|
availableTtys = service.listTtys();
|
|
} catch (RemoteException e) {
|
|
Log.e(TAG, "error listing Ttys :" + e);
|
|
return;
|
|
}
|
|
|
|
for (String tty : availableTtys) {
|
|
for (String pattern : allowedTtys) {
|
|
if (tty.matches(pattern)) {
|
|
synchronized (this) {
|
|
if (!mActiveTtys.contains(tty)) {
|
|
// TODO - don't hardcode this
|
|
try {
|
|
// local, remote, dns
|
|
service.attachPppd(tty, "169.254.1.128", "169.254.1.1",
|
|
"169.254.1.128", "0.0.0.0");
|
|
} catch (Exception e) {
|
|
Log.e(TAG, "error calling attachPppd: " + e);
|
|
return;
|
|
}
|
|
Log.d(TAG, "started Pppd on tty " + tty);
|
|
mActiveTtys.add(tty);
|
|
// TODO - remove this after we detect the new iface
|
|
interfaceAdded("ppp0");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private synchronized void handleTtyDisconnect() {
|
|
Log.d(TAG, "handleTtyDisconnect");
|
|
|
|
// TODO - this should be data-driven rather than hard coded.
|
|
String[] allowedTtys = new String[1];
|
|
allowedTtys[0] = new String("ttyGS0");
|
|
|
|
IBinder b = ServiceManager.getService(Context.NETWORKMANAGEMENT_SERVICE);
|
|
INetworkManagementService service = INetworkManagementService.Stub.asInterface(b);
|
|
|
|
String[] availableTtys;
|
|
try {
|
|
availableTtys = service.listTtys();
|
|
} catch (RemoteException e) {
|
|
Log.e(TAG, "error listing Ttys :" + e);
|
|
return;
|
|
}
|
|
|
|
for (String tty : availableTtys) {
|
|
for (String pattern : allowedTtys) {
|
|
if (tty.matches(pattern)) {
|
|
synchronized (this) {
|
|
if (mActiveTtys.contains(tty)) {
|
|
try {
|
|
service.detachPppd(tty);
|
|
} catch (Exception e) {
|
|
Log.e(TAG, "error calling detachPppd on " + tty + " :" + e);
|
|
}
|
|
mActiveTtys.remove(tty);
|
|
// TODO - remove this after we detect the new iface
|
|
interfaceRemoved("ppp0");
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public synchronized String[] getTetheredIfaces() {
|
|
int size = mActiveIfaces.size();
|
|
String[] result = new String[size];
|
|
size -= 1;
|
|
for (int i=0; i< size; i++) {
|
|
result[i] = mActiveIfaces.get(i);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public synchronized String[] getTetherableIfaces() {
|
|
int size = mAvailableIfaces.size();
|
|
String[] result = new String[size];
|
|
size -= 1;
|
|
for (int i=0; i< size; i++) {
|
|
result[i] = mActiveIfaces.get(i);
|
|
}
|
|
return result;
|
|
}
|
|
}
|