package de.fun2code.android.piratebox;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.List;
import org.paw.server.PawServer;
import android.app.Notification;
import android.app.PendingIntent;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.SharedPreferences;
import android.content.res.Resources;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiManager;
import android.net.wifi.WifiManager.WifiLock;
import android.os.PowerManager;
import android.os.PowerManager.WakeLock;
import android.preference.PreferenceManager;
import android.text.format.Formatter;
import android.util.Log;
import android.widget.Toast;
import de.fun2code.android.pawserver.PawServerService;
import de.fun2code.android.pawserver.listener.ServiceListener;
import de.fun2code.android.pawserver.service.ServiceCompat;
import de.fun2code.android.piratebox.util.NetworkUtil;
import de.fun2code.android.piratebox.util.NetworkUtil.IpTablesAction;
import de.fun2code.android.piratebox.util.NetworkUtil.WrapResult;
import de.fun2code.android.piratebox.util.ServerConfigUtil;
import de.fun2code.android.piratebox.util.ShellUtil;
import de.fun2code.android.piratebox.widget.PirateBoxWidget;
/**
* The PirateBox serice class which handles the access point, network configuration
* and startup up the web server.
*
* @author joschi
*
*/
public class PirateBoxService extends PawServerService implements ServiceListener {
private WifiConfiguration orgApConfig;
private boolean orgWifiState;
//private boolean orgMobileDataState; // Not needed
private NetworkUtil netUtil;
private ShellUtil shellUtil;
private PirateBoxService service;
private SharedPreferences preferences;
private boolean emulateDroopy = true;
private boolean externalServer = false;
private int EXTERNAL_SERVER_NOTIFICATION_ID = PirateBoxService.class.toString().hashCode();
public static boolean externalServerRunning = false;
public static boolean autoApStartup = true;
public static boolean configureAp = true;
private static List<StateChangedListener> listeners = new ArrayList<StateChangedListener>();
private static boolean apRunning, networkRunning, startingUp;
/**
* Broadcast receiver which receives access point state change notifications
*/
private final BroadcastReceiver apReceiver = new BroadcastReceiver() {
static final int WIFI_AP_STATE_DISABLING = 10;
static final int WIFI_AP_STATE_DISABLED = 11;
static final int WIFI_AP_STATE_ENABLED = 13;
@Override
public void onReceive(Context context, Intent intent) {
String action = intent.getAction();
// If access point state changed
if (action.equals("android.net.wifi.WIFI_AP_STATE_CHANGED")) {
int state = intent.getIntExtra("wifi_state", WifiManager.WIFI_STATE_UNKNOWN);
switch(state) {
// If access point was enabled
case WIFI_AP_STATE_ENABLED:
case WifiManager.WIFI_STATE_ENABLED:
if(!apRunning) {
apRunning = true;
int pid = shellUtil.waitForProcess(NetworkUtil.DNSMASQ_BIN_BACKUP, 4000);
Log.i(TAG, "Process ID of " + NetworkUtil.DNSMASQ_BIN_BACKUP + ": " + pid);
// Restore dnsmasq
netUtil.unwrapDnsmasq();
// Inform about unwrap result
for(StateChangedListener listener : listeners) {
listener.dnsMasqUnWrapped();
}
/*
* Check if dnsmasq is running ok.
* This might not be the case on Android 5 and up.
* In such a case, try to restart dnsmasq manually
*/
if(!netUtil.isDnsMasqRunning()) {
netUtil.restartDnsMasq(NetworkUtil.getApIp(service));
}
/*
* Restore AP state
* Only restore if configuration was changed.
*/
if(configureAp) {
netUtil.setWifiApConfiguration(orgApConfig);
}
for(StateChangedListener listener : listeners) {
listener.apEnabled(autoApStartup);
}
Intent apUpIntent = new Intent(Constants.BROADCAST_INTENT_AP);
apUpIntent.putExtra(Constants.INTENT_AP_EXTRA_STATE, true);
sendBroadcast(apUpIntent);
Intent serviceIntent = new Intent(service,
PirateBoxService.class);
startService(serviceIntent);
}
break;
// If access point was disabled
case WIFI_AP_STATE_DISABLING:
case WIFI_AP_STATE_DISABLED:
case WifiManager.WIFI_STATE_DISABLING:
case WifiManager.WIFI_STATE_DISABLED:
if (apRunning) {
unregisterReceiver(apReceiver);
apRunning = false;
for(StateChangedListener listener : listeners) {
listener.apDisabled(autoApStartup);
}
Intent apDownIntent = new Intent(Constants.BROADCAST_INTENT_AP);
apDownIntent.putExtra(Constants.INTENT_AP_EXTRA_STATE, false);
sendBroadcast(apDownIntent);
/*
* If server is running, stop it
* AP might have been stopped by external (user or app)
*/
if(PirateBoxService.isRunning()) {
service.stopSelf();
}
}
break;
}
}
}
};
@Override
public void onCreate() {
super.onCreate();
preferences = PreferenceManager.getDefaultSharedPreferences(this);
service = this;
netUtil = new NetworkUtil(this);
shellUtil = new ShellUtil();
// Save original WiFi state, mobile data state and access point configuration
orgWifiState = netUtil.isWifiEnabled();
//orgMobileDataState = netUtil.getMobileDataEnabled(); // Not needed
orgApConfig = netUtil.getWifiApConfiguration();
/*
* Individual settings.
*/
init();
registerServiceListener(this);
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
autoApStartup = preferences.getBoolean(Constants.PREF_AUTO_AP_STARTUP, true);
configureAp = preferences.getBoolean(Constants.PREF_CONFIGURE_AP, true);
emulateDroopy = preferences.getBoolean(Constants.PREF_EMULATE_DROOPY, true);
externalServer = preferences.getBoolean(Constants.PREF_USE_EXTERNAL_SERVER, false);
// If starting the access point is handled by the user
if(!autoApStartup) {
apRunning = true;
for(StateChangedListener listener : listeners) {
listener.apEnabled(autoApStartup);
}
if(!externalServer) {
Log.d(TAG, "Starting service...");
return super.onStartCommand(intent, flags, startId);
}
else {
handleExternalServerStart();
return START_NOT_STICKY;
}
}
if(apRunning) {
if(!externalServer) {
Log.d(TAG, "Starting service...");
return super.onStartCommand(intent, flags, startId);
}
else {
handleExternalServerStart();
return START_NOT_STICKY;
}
}
else {
Log.d(TAG, "Starting AccessPoint...");
WrapResult wrapResult = netUtil.wrapDnsmasq(NetworkUtil.getApIp(this));
// Inform about wrap result
for(StateChangedListener listener : listeners) {
listener.dnsMasqWrapped(wrapResult);
}
startAp();
return START_STICKY;
}
}
@Override
public WakeLock getWakeLock() {
PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE);
PowerManager.WakeLock wl = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK,
Constants.TAG);
return wl;
}
@Override
public WifiLock getWifiLock() {
return super.getWifiLock();
}
@Override
public void onDestroy() {
if(autoApStartup) {
stopAp();
}
else {
apRunning = false;
for(StateChangedListener listener : listeners) {
listener.apDisabled(autoApStartup);
}
}
teardownNetworking();
if(!externalServer) {
super.onDestroy();
}
else {
handleExternalServerStop();
}
}
/**
* Starts up the access point
*/
public void startAp() {
startingUp = true;
netUtil.setWifiEnabled(false);
//netUtil.setMobileDataEnabled(true); // Not needed
netUtil.setWifiApEnabled(null, false);
IntentFilter filter = new IntentFilter("android.net.wifi.WIFI_AP_STATE_CHANGED");
registerReceiver(apReceiver, filter);
String ssid = preferences.getString(Constants.PREF_SSID_NAME, service.getResources().getString(R.string.pref_ssid_name_default));
// If AP should be configured, create an open AP configuration, otherwise use existing.
netUtil.setWifiApEnabled(configureAp ? netUtil.createOpenAp(ssid) : orgApConfig, true);
}
/**
* Stops the access point
*/
public void stopAp() {
boolean restoreWiFi = true;
// If AP has been stop from external (user/app), do not restore WiFi state
if(!apRunning) {
restoreWiFi = false;
Log.i(TAG, "AP stopped from external ... do not restore WiFi");
}
netUtil.setWifiApEnabled(null, false);
if(restoreWiFi) {
netUtil.setWifiEnabled(orgWifiState);
}
//netUtil.setMobileDataEnabled(orgMobileDataState); // Not needed
}
/*
* Service options are:
* TAG = Tag name for message logging.
* startOnBoot = Indicates if service has been started on boot.
* isRuntime = If set to true this will only allow local connections.
* serverConfig = Path to server configuration directory.
* pawHome = PAW installation directory.
* useWakeLock = Switch wakelock on or off.
* hideNotificationIcon = Set to true if no notifications should be shown.
* execAutostartScripts = Set to true if scripts inside the autostart directory should be executed onstartup.
* showUrlInNotification = Set to true if URL should be shown in notification.
* notificationTitle = The notification title.
* notificationMessage = The notification message.
* appName = Application name"
* activityClass = Activity class name.
* notificationDrawableId = ID of the notification icon to display.
*/
private void init() {
TAG = "PirateBoxService";
startedOnBoot = false;
isRuntime = false;
serverConfig = Constants.getInstallDir(this) + "/conf/server.xml";
pawHome = Constants.getInstallDir(this) + "/";
useWakeLock = preferences.getBoolean(Constants.PREF_KEEP_DEVICE_ON, true);
useWifiLock = preferences.getBoolean(Constants.PREF_KEEP_DEVICE_ON, true);
hideNotificationIcon = false;
execAutostartScripts = false;
showUrlInNotification = false;
notificationTitle = getString(R.string.app_name);
notificationMessage = getString(R.string.notification_message);
appName = getString(R.string.app_name);
activityClass = "de.fun2code.android.piratebox.PirateBoxActivity";
notificationDrawableId = R.drawable.ic_notification;
// Set default mayPost value
PawServer.DEFAULT_MAX_POST = Constants.DEFAULT_MAX_POST;
/*
* Check if maxPost setting is valid
*/
String maxPost = ServerConfigUtil.getServerSetting("maxPost", this);
if(maxPost.length() > 0) {
try {
Long.decode(maxPost).longValue();
}
catch(NumberFormatException e) {
String msg = new MessageFormat(
getString(R.string.msg_max_post_invalid)).format(new Object[] {
Formatter.formatFileSize(this, Constants.DEFAULT_MAX_POST) });
Toast.makeText(this, msg, Toast.LENGTH_LONG).show();
}
}
Log.i(TAG, "Home directory: " + Constants.getInstallDir(this));
}
/**
* Changes the dnsmasq configuration by killing the original dnsmasq
* process and starting a new one which answers all DNS queries with the IP
* of the access point.
*/
public void setupDnsmasq() {
String apIp = NetworkUtil.getApIp(this);
String baseIp = apIp.substring(0, apIp.lastIndexOf("."));
if (shellUtil.getProcessPid(NetworkUtil.DNSMASQ_BIN) != -1) {
// Kill dnsmasqd
shellUtil.killProcessByName(NetworkUtil.DNSMASQ_BIN);
// Start new dnsmasqd
String[] dnsmasqCmd = new String[] { NetworkUtil.DNSMASQ_BIN
+ " --no-resolv --no-poll --dhcp-range=" + baseIp +".2," + baseIp + ".254,1h --address=/#/"
+ apIp + " --pid-file=" + getFilesDir().getAbsolutePath()
+ "/dnsmasq.pid"
};
shellUtil.execRootShell(dnsmasqCmd);
}
}
/**
* Redirects port 80 requests to the port of the running server
*
* @param action
*/
public void doRedirect(IpTablesAction action) {
// Redirect port 80
netUtil.redirectPort(action, NetworkUtil.getApIp(this), NetworkUtil.PORT_HTTP, NetworkUtil.getServerPortNumber(this));
// Redirect port 8080 (Droopy support)
if(emulateDroopy) {
netUtil.redirectPort(action, NetworkUtil.getApIp(this), NetworkUtil.PORT_DROOPY, NetworkUtil.getServerPortNumber(this));
}
for(StateChangedListener listener : listeners) {
if(action == IpTablesAction.IP_TABLES_ADD) {
listener.networkUp();
}
else {
listener.networkDown();
}
}
Intent intent = new Intent(Constants.BROADCAST_INTENT_NETWORK);
intent.putExtra(Constants.INTENT_NETWORK_EXTRA_STATE, action == IpTablesAction.IP_TABLES_ADD ? true : false);
sendBroadcast(intent);
}
/**
* Stops the PirateBox networking setup
*/
public void teardownNetworking() {
shellUtil.killProcessByName(NetworkUtil.DNSMASQ_BIN);
// Set iptables FORWARD chain to ACCEPT to avoid Internet usage
NetworkUtil.acceptChain(NetworkUtil.IPTABLES_CHAIN_FORWARD);
doRedirect(IpTablesAction.IP_TABLES_DELETE);
for(StateChangedListener listener : listeners) {
listener.networkDown();
}
networkRunning = false;
}
/**
* Checks if the service is in startup phase
*
* @return {@code true} if the service is in startup phase, otherwise
* {@code false}
*/
public static boolean isStartingUp() {
return startingUp;
}
/**
* Checks if the access point has been started
*
* @return {@code true} if the access point has been started, otherwise
* {@code false}
*/
public static boolean isApRunning() {
return apRunning;
}
/**
* Checks if the PirateBox networking is set up
*
* @return {@code true} if the networking has been set up, otherwise
* {@code false}
*/
public static boolean isNetworkRunning() {
return networkRunning;
}
/**
* Registers a StateChangedListener which will be informed if the
* state of access point, networking or web service changes
*
* @param listener listener to register
*/
public static void registerChangeListener(StateChangedListener listener) {
if(!listeners.contains(listener)) {
listeners.add(listener);
}
}
/**
* Unregisters a StateChangedListener
*
* @param listener listener to unregister
*/
public static void unregisterChangeListener(StateChangedListener listener) {
listeners.remove(listener);
}
@Override
public void onServiceStart(boolean success) {
for(StateChangedListener listener : listeners) {
listener.serverUp(success);
}
Intent intent = new Intent(Constants.BROADCAST_INTENT_SERVER);
intent.putExtra(Constants.INTENT_SERVER_EXTRA_STATE, true);
sendBroadcast(intent);
doRedirect(IpTablesAction.IP_TABLES_ADD);
// Set iptables FORWARD chain to DROP
NetworkUtil.dropChain(NetworkUtil.IPTABLES_CHAIN_FORWARD);
networkRunning = true;
startingUp = false;
}
@Override
public void onServiceStop(boolean success) {
for(StateChangedListener listener : listeners) {
listener.serverDown(success);
}
Intent intent = new Intent(Constants.BROADCAST_INTENT_SERVER);
intent.putExtra(Constants.INTENT_SERVER_EXTRA_STATE, false);
sendBroadcast(intent);
unregisterServiceListener(this);
}
/**
* Handles the startup if an external server is used
*/
private void handleExternalServerStart() {
externalServerRunning = true;
// If external server, skip server start and inform listeners
onServiceStart(true);
// Show notification
String titelExtension = " (" + getString(R.string.msg_external_server) + ")";
displayNotification(EXTERNAL_SERVER_NOTIFICATION_ID, notificationDrawableId, appName + titelExtension, notificationTitle + titelExtension, notificationMessage);
// Widget Broadcast
Intent msg = new Intent(PirateBoxWidget.WIDGET_INTENT_UPDATE);
sendBroadcast(msg);
}
/**
* Handles the stopping of the external server
*/
private void handleExternalServerStop() {
// If external server call listeners directly
for (StateChangedListener listener : listeners) {
listener.serverDown(true);
}
externalServerRunning = false;
removeNotification(EXTERNAL_SERVER_NOTIFICATION_ID);
// Widget Broadcast
Intent msg = new Intent(PirateBoxWidget.WIDGET_INTENT_UPDATE);
sendBroadcast(msg);
}
/**
* Displays the server status notification
*
* @param notificationId notification ID to use
* @param notificationDrawableId Drawable ID to use
* @param appName application name
* @param notificationTitle the notification title
* @param notificationMessage the notification message
*/
@SuppressWarnings("deprecation")
private void displayNotification(int notificationId, int notificationDrawableId, String appName, String notificationTitle, String notificationMessage) {
try {
int icon = notificationDrawableId;
long when = System.currentTimeMillis();
Notification notification = new Notification(icon, notificationTitle, when);
Context context = getApplicationContext();
Intent notificationIntent = new Intent(this,
Class.forName(activityClass));
notificationIntent.setAction("android.intent.action.MAIN");
notificationIntent.addCategory("android.intent.category.LAUNCHER");
PendingIntent contentIntent = PendingIntent.getActivity(this, 0,
notificationIntent, 0);
notification.setLatestEventInfo(context,
appName,
notificationMessage,
contentIntent);
notification.flags |= Notification.FLAG_NO_CLEAR;
notification.flags |= Notification.FLAG_ONGOING_EVENT;
//notificationManager.notify(NOTIFICATION_ID, notification);
ServiceCompat sc = new ServiceCompat(this);
sc.startForegroundCompat(notificationId, notification);
} catch (Resources.NotFoundException e) {
// shouldn't happen
} catch (ClassNotFoundException ec) {
Log.e(TAG, "Could not create notification: " + ec.getMessage());
}
}
/**
* Removes the status notification
*
* @param notificationId notification ID to use
*/
private void removeNotification(int notificationId) {
if (hideNotificationIcon) {
return;
}
//notificationManager.cancel(NOTIFICATION_ID);
ServiceCompat sc = new ServiceCompat(this);
sc.stopForegroundCompat(notificationId);
}
/**
* Indicates if PirateBox is running
* It is running, if PAW server is running or if an external server
* has been started.
*
* @return {@code true} if the PirateBox is running, otherwise {@code false}
*/
public static boolean isRunning() {
return PawServerService.isRunning() || externalServerRunning;
}
}
