gecko-dev/dom/system/gonk/NetworkService.js
2015-09-23 15:35:29 +08:00

821 lines
23 KiB
JavaScript

/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
* You can obtain one at http://mozilla.org/MPL/2.0/. */
"use strict";
const {classes: Cc, interfaces: Ci, utils: Cu, results: Cr} = Components;
Cu.import("resource://gre/modules/XPCOMUtils.jsm");
Cu.import("resource://gre/modules/Services.jsm");
Cu.import("resource://gre/modules/NetUtil.jsm");
Cu.import("resource://gre/modules/FileUtils.jsm");
Cu.import("resource://gre/modules/Promise.jsm");
const NETWORKSERVICE_CONTRACTID = "@mozilla.org/network/service;1";
const NETWORKSERVICE_CID = Components.ID("{baec696c-c78d-42db-8b44-603f8fbfafb4}");
const TOPIC_PREF_CHANGED = "nsPref:changed";
const TOPIC_XPCOM_SHUTDOWN = "xpcom-shutdown";
const PREF_NETWORK_DEBUG_ENABLED = "network.debugging.enabled";
XPCOMUtils.defineLazyServiceGetter(this, "gNetworkWorker",
"@mozilla.org/network/worker;1",
"nsINetworkWorker");
// 1xx - Requested action is proceeding
const NETD_COMMAND_PROCEEDING = 100;
// 2xx - Requested action has been successfully completed
const NETD_COMMAND_OKAY = 200;
// 4xx - The command is accepted but the requested action didn't
// take place.
const NETD_COMMAND_FAIL = 400;
// 5xx - The command syntax or parameters error
const NETD_COMMAND_ERROR = 500;
// 6xx - Unsolicited broadcasts
const NETD_COMMAND_UNSOLICITED = 600;
const WIFI_CTRL_INTERFACE = "wl0.1";
var debug;
function updateDebug() {
let debugPref = false; // set default value here.
try {
debugPref = debugPref || Services.prefs.getBoolPref(PREF_NETWORK_DEBUG_ENABLED);
} catch (e) {}
if (debugPref) {
debug = function(s) {
dump("-*- NetworkService: " + s + "\n");
};
} else {
debug = function(s) {};
}
}
updateDebug();
function netdResponseType(aCode) {
return Math.floor(aCode / 100) * 100;
}
function isError(aCode) {
let type = netdResponseType(aCode);
return (type !== NETD_COMMAND_PROCEEDING && type !== NETD_COMMAND_OKAY);
}
function Task(aId, aParams, aSetupFunction) {
this.id = aId;
this.params = aParams;
this.setupFunction = aSetupFunction;
}
function NetworkWorkerRequestQueue(aNetworkService) {
this.networkService = aNetworkService;
this.tasks = [];
}
NetworkWorkerRequestQueue.prototype = {
runQueue: function() {
if (this.tasks.length === 0) {
return;
}
let task = this.tasks[0];
debug("run task id: " + task.id);
if (typeof task.setupFunction === 'function') {
// If setupFunction returns false, skip sending to Network Worker but call
// handleWorkerMessage() directly with task id, as if the response was
// returned from Network Worker.
if (!task.setupFunction()) {
this.networkService.handleWorkerMessage({id: task.id});
return;
}
}
gNetworkWorker.postMessage(task.params);
},
enqueue: function(aId, aParams, aSetupFunction) {
debug("enqueue id: " + aId);
this.tasks.push(new Task(aId, aParams, aSetupFunction));
if (this.tasks.length === 1) {
this.runQueue();
}
},
dequeue: function(aId) {
debug("dequeue id: " + aId);
if (!this.tasks.length || this.tasks[0].id != aId) {
debug("Id " + aId + " is not on top of the queue");
return;
}
this.tasks.shift();
if (this.tasks.length > 0) {
// Run queue on the next tick.
Services.tm.currentThread.dispatch(() => {
this.runQueue();
}, Ci.nsIThread.DISPATCH_NORMAL);
}
}
};
/**
* This component watches for network interfaces changing state and then
* adjusts routes etc. accordingly.
*/
function NetworkService() {
debug("Starting NetworkService.");
let self = this;
if (gNetworkWorker) {
let networkListener = {
onEvent: function(aEvent) {
self.handleWorkerMessage(aEvent);
}
};
gNetworkWorker.start(networkListener);
}
// Callbacks to invoke when a reply arrives from the net_worker.
this.controlCallbacks = Object.create(null);
this.addedRoutes = new Map();
this.netWorkerRequestQueue = new NetworkWorkerRequestQueue(this);
this.shutdown = false;
Services.prefs.addObserver(PREF_NETWORK_DEBUG_ENABLED, this, false);
Services.obs.addObserver(this, TOPIC_XPCOM_SHUTDOWN, false);
}
NetworkService.prototype = {
classID: NETWORKSERVICE_CID,
classInfo: XPCOMUtils.generateCI({classID: NETWORKSERVICE_CID,
contractID: NETWORKSERVICE_CONTRACTID,
classDescription: "Network Service",
interfaces: [Ci.nsINetworkService]}),
QueryInterface: XPCOMUtils.generateQI([Ci.nsINetworkService,
Ci.nsIObserver]),
addedRoutes: null,
shutdown: false,
// nsIObserver
observe: function(aSubject, aTopic, aData) {
switch (aTopic) {
case TOPIC_PREF_CHANGED:
if (aData === PREF_NETWORK_DEBUG_ENABLED) {
updateDebug();
}
break;
case TOPIC_XPCOM_SHUTDOWN:
debug("NetworkService shutdown");
this.shutdown = true;
if (gNetworkWorker) {
gNetworkWorker.shutdown();
gNetworkWorker = null;
}
Services.obs.removeObserver(this, TOPIC_XPCOM_SHUTDOWN);
Services.prefs.removeObserver(PREF_NETWORK_DEBUG_ENABLED, this);
break;
}
},
// Helpers
idgen: 0,
controlMessage: function(aParams, aCallback, aSetupFunction) {
if (this.shutdown) {
return;
}
let id = this.idgen++;
aParams.id = id;
if (aCallback) {
this.controlCallbacks[id] = aCallback;
}
// For now, we use aSetupFunction to determine if this command needs to be
// queued or not.
if (aSetupFunction) {
this.netWorkerRequestQueue.enqueue(id, aParams, aSetupFunction);
return;
}
if (gNetworkWorker) {
gNetworkWorker.postMessage(aParams);
}
},
handleWorkerMessage: function(aResponse) {
debug("NetworkManager received message from worker: " + JSON.stringify(aResponse));
let id = aResponse.id;
if (aResponse.broadcast === true) {
Services.obs.notifyObservers(null, aResponse.topic, aResponse.reason);
return;
}
let callback = this.controlCallbacks[id];
if (callback) {
callback.call(this, aResponse);
delete this.controlCallbacks[id];
}
this.netWorkerRequestQueue.dequeue(id);
},
// nsINetworkService
getNetworkInterfaceStats: function(aInterfaceName, aCallback) {
debug("getNetworkInterfaceStats for " + aInterfaceName);
let file = new FileUtils.File("/proc/net/dev");
if (!file) {
aCallback.networkStatsAvailable(false, 0, 0, Date.now());
return;
}
NetUtil.asyncFetch({
uri: NetUtil.newURI(file),
loadUsingSystemPrincipal: true
}, function(inputStream, status) {
let rxBytes = 0,
txBytes = 0,
now = Date.now();
if (Components.isSuccessCode(status)) {
// Find record for corresponding interface.
let statExpr = /(\S+): +(\d+) +\d+ +\d+ +\d+ +\d+ +\d+ +\d+ +\d+ +(\d+) +\d+ +\d+ +\d+ +\d+ +\d+ +\d+ +\d+/;
let data =
NetUtil.readInputStreamToString(inputStream, inputStream.available())
.split("\n");
for (let i = 2; i < data.length; i++) {
let parseResult = statExpr.exec(data[i]);
if (parseResult && parseResult[1] === aInterfaceName) {
rxBytes = parseInt(parseResult[2], 10);
txBytes = parseInt(parseResult[3], 10);
break;
}
}
}
// netd always return success even interface doesn't exist.
aCallback.networkStatsAvailable(true, rxBytes, txBytes, now);
});
},
setNetworkTetheringAlarm(aEnable, aInterface) {
// Method called when enabling disabling tethering, it checks if there is
// some alarm active and move from interfaceAlarm to globalAlarm because
// interfaceAlarm doens't work in tethering scenario due to forwarding.
debug("setNetworkTetheringAlarm for tethering" + aEnable);
let filename = aEnable ? "/proc/net/xt_quota/" + aInterface + "Alert" :
"/proc/net/xt_quota/globalAlert";
let file = new FileUtils.File(filename);
if (!file) {
return;
}
NetUtil.asyncFetch({
uri: NetUtil.newURI(file),
loadUsingSystemPrincipal: true
}, (inputStream, status) => {
if (Components.isSuccessCode(status)) {
let data = NetUtil.readInputStreamToString(inputStream, inputStream.available())
.split("\n");
if (data) {
let threshold = parseInt(data[0], 10);
this._setNetworkTetheringAlarm(aEnable, aInterface, threshold);
}
}
});
},
_setNetworkTetheringAlarm(aEnable, aInterface, aThreshold, aCallback) {
debug("_setNetworkTetheringAlarm for tethering" + aEnable);
let cmd = aEnable ? "setTetheringAlarm" : "removeTetheringAlarm";
let params = {
cmd: cmd,
ifname: aInterface,
threshold: aThreshold,
};
this.controlMessage(params, function(aData) {
let code = aData.resultCode;
let reason = aData.resultReason;
let enableString = aEnable ? "Enable" : "Disable";
debug(enableString + " tethering Alarm result: Code " + code + " reason " + reason);
if (aCallback) {
aCallback.networkUsageAlarmResult(null);
}
});
},
setNetworkInterfaceAlarm: function(aInterfaceName, aThreshold, aCallback) {
if (!aInterfaceName) {
aCallback.networkUsageAlarmResult(-1);
return;
}
let self = this;
this._disableNetworkInterfaceAlarm(aInterfaceName, function(aResult) {
if (aThreshold < 0) {
if (!isError(aResult.resultCode)) {
aCallback.networkUsageAlarmResult(null);
return;
}
aCallback.networkUsageAlarmResult(aResult.reason);
return
}
// Check if tethering is enabled
let params = {
cmd: "getTetheringStatus"
};
self.controlMessage(params, function(aResult) {
if (isError(aResult.resultCode)) {
aCallback.networkUsageAlarmResult(aResult.reason);
return;
}
if (aResult.resultReason.indexOf('started') == -1) {
// Tethering disabled, set interfaceAlarm
self._setNetworkInterfaceAlarm(aInterfaceName, aThreshold, aCallback);
return;
}
// Tethering enabled, set globalAlarm
self._setNetworkTetheringAlarm(true, aInterfaceName, aThreshold, aCallback);
});
});
},
_setNetworkInterfaceAlarm: function(aInterfaceName, aThreshold, aCallback) {
debug("setNetworkInterfaceAlarm for " + aInterfaceName + " at " + aThreshold + "bytes");
let params = {
cmd: "setNetworkInterfaceAlarm",
ifname: aInterfaceName,
threshold: aThreshold
};
params.report = true;
this.controlMessage(params, function(aResult) {
if (!isError(aResult.resultCode)) {
aCallback.networkUsageAlarmResult(null);
return;
}
this._enableNetworkInterfaceAlarm(aInterfaceName, aThreshold, aCallback);
});
},
_enableNetworkInterfaceAlarm: function(aInterfaceName, aThreshold, aCallback) {
debug("enableNetworkInterfaceAlarm for " + aInterfaceName + " at " + aThreshold + "bytes");
let params = {
cmd: "enableNetworkInterfaceAlarm",
ifname: aInterfaceName,
threshold: aThreshold
};
params.report = true;
this.controlMessage(params, function(aResult) {
if (!isError(aResult.resultCode)) {
aCallback.networkUsageAlarmResult(null);
return;
}
aCallback.networkUsageAlarmResult(aResult.reason);
});
},
_disableNetworkInterfaceAlarm: function(aInterfaceName, aCallback) {
debug("disableNetworkInterfaceAlarm for " + aInterfaceName);
let params = {
cmd: "disableNetworkInterfaceAlarm",
ifname: aInterfaceName,
};
params.report = true;
this.controlMessage(params, function(aResult) {
aCallback(aResult);
});
},
setWifiOperationMode: function(aInterfaceName, aMode, aCallback) {
debug("setWifiOperationMode on " + aInterfaceName + " to " + aMode);
let params = {
cmd: "setWifiOperationMode",
ifname: aInterfaceName,
mode: aMode
};
params.report = true;
this.controlMessage(params, function(aResult) {
if (isError(aResult.resultCode)) {
aCallback.wifiOperationModeResult("netd command error");
} else {
aCallback.wifiOperationModeResult(null);
}
});
},
resetRoutingTable: function(aInterfaceName, aCallback) {
let options = {
cmd: "removeNetworkRoute",
ifname: aInterfaceName
};
this.controlMessage(options, function(aResult) {
aCallback.nativeCommandResult(!aResult.error);
});
},
setDNS: function(aInterfaceName, aDnsesCount, aDnses, aGatewaysCount,
aGateways, aCallback) {
debug("Going to set DNS to " + aInterfaceName);
let options = {
cmd: "setDNS",
ifname: aInterfaceName,
domain: "mozilla." + aInterfaceName + ".domain",
dnses: aDnses,
gateways: aGateways
};
this.controlMessage(options, function(aResult) {
aCallback.setDnsResult(aResult.success ? null : aResult.reason);
});
},
setDefaultRoute: function(aInterfaceName, aCount, aGateways, aCallback) {
debug("Going to change default route to " + aInterfaceName);
let options = {
cmd: "setDefaultRoute",
ifname: aInterfaceName,
gateways: aGateways
};
this.controlMessage(options, function(aResult) {
aCallback.nativeCommandResult(!aResult.error);
});
},
removeDefaultRoute: function(aInterfaceName, aCount, aGateways, aCallback) {
debug("Remove default route for " + aInterfaceName);
let options = {
cmd: "removeDefaultRoute",
ifname: aInterfaceName,
gateways: aGateways
};
this.controlMessage(options, function(aResult) {
aCallback.nativeCommandResult(!aResult.error);
});
},
_routeToString: function(aInterfaceName, aHost, aPrefixLength, aGateway) {
return aHost + "-" + aPrefixLength + "-" + aGateway + "-" + aInterfaceName;
},
modifyRoute: function(aAction, aInterfaceName, aHost, aPrefixLength, aGateway) {
let command;
switch (aAction) {
case Ci.nsINetworkService.MODIFY_ROUTE_ADD:
command = 'addHostRoute';
break;
case Ci.nsINetworkService.MODIFY_ROUTE_REMOVE:
command = 'removeHostRoute';
break;
default:
debug('Unknown action: ' + aAction);
return Promise.reject();
}
let route = this._routeToString(aInterfaceName, aHost, aPrefixLength, aGateway);
let setupFunc = () => {
let count = this.addedRoutes.get(route);
debug(command + ": " + route + " -> " + count);
// Return false if there is no need to send the command to network worker.
if ((aAction == Ci.nsINetworkService.MODIFY_ROUTE_ADD && count) ||
(aAction == Ci.nsINetworkService.MODIFY_ROUTE_REMOVE &&
(!count || count > 1))) {
return false;
}
return true;
};
debug(command + " " + aHost + " on " + aInterfaceName);
let options = {
cmd: command,
ifname: aInterfaceName,
gateway: aGateway,
prefixLength: aPrefixLength,
ip: aHost
};
return new Promise((aResolve, aReject) => {
this.controlMessage(options, (aData) => {
let count = this.addedRoutes.get(route);
// Remove route from addedRoutes on success or failure.
if (aAction == Ci.nsINetworkService.MODIFY_ROUTE_REMOVE) {
if (count > 1) {
this.addedRoutes.set(route, count - 1);
} else {
this.addedRoutes.delete(route);
}
}
if (aData.error) {
aReject(aData.reason);
return;
}
if (aAction == Ci.nsINetworkService.MODIFY_ROUTE_ADD) {
this.addedRoutes.set(route, count ? count + 1 : 1);
}
aResolve();
}, setupFunc);
});
},
addSecondaryRoute: function(aInterfaceName, aRoute, aCallback) {
debug("Going to add route to secondary table on " + aInterfaceName);
let options = {
cmd: "addSecondaryRoute",
ifname: aInterfaceName,
ip: aRoute.ip,
prefix: aRoute.prefix,
gateway: aRoute.gateway
};
this.controlMessage(options, function(aResult) {
aCallback.nativeCommandResult(!aResult.error);
});
},
removeSecondaryRoute: function(aInterfaceName, aRoute, aCallback) {
debug("Going to remove route from secondary table on " + aInterfaceName);
let options = {
cmd: "removeSecondaryRoute",
ifname: aInterfaceName,
ip: aRoute.ip,
prefix: aRoute.prefix,
gateway: aRoute.gateway
};
this.controlMessage(options, function(aResult) {
aCallback.nativeCommandResult(!aResult.error);
});
},
// Enable/Disable DHCP server.
setDhcpServer: function(aEnabled, aConfig, aCallback) {
if (null === aConfig) {
aConfig = {};
}
aConfig.cmd = "setDhcpServer";
aConfig.enabled = aEnabled;
this.controlMessage(aConfig, function(aResponse) {
if (!aResponse.success) {
aCallback.dhcpServerResult('Set DHCP server error');
return;
}
aCallback.dhcpServerResult(null);
});
},
// Enable/disable WiFi tethering by sending commands to netd.
setWifiTethering: function(aEnable, aConfig, aCallback) {
// config should've already contained:
// .ifname
// .internalIfname
// .externalIfname
aConfig.wifictrlinterfacename = WIFI_CTRL_INTERFACE;
aConfig.cmd = "setWifiTethering";
// The callback function in controlMessage may not be fired immediately.
this.controlMessage(aConfig, (aData) => {
let code = aData.resultCode;
let reason = aData.resultReason;
let enable = aData.enable;
let enableString = aEnable ? "Enable" : "Disable";
debug(enableString + " Wifi tethering result: Code " + code + " reason " + reason);
this.setNetworkTetheringAlarm(aEnable, aConfig.externalIfname);
if (isError(code)) {
aCallback.wifiTetheringEnabledChange("netd command error");
} else {
aCallback.wifiTetheringEnabledChange(null);
}
});
},
// Enable/disable USB tethering by sending commands to netd.
setUSBTethering: function(aEnable, aConfig, aCallback) {
aConfig.cmd = "setUSBTethering";
// The callback function in controlMessage may not be fired immediately.
this.controlMessage(aConfig, (aData) => {
let code = aData.resultCode;
let reason = aData.resultReason;
let enable = aData.enable;
let enableString = aEnable ? "Enable" : "Disable";
debug(enableString + " USB tethering result: Code " + code + " reason " + reason);
this.setNetworkTetheringAlarm(aEnable, aConfig.externalIfname);
if (isError(code)) {
aCallback.usbTetheringEnabledChange("netd command error");
} else {
aCallback.usbTetheringEnabledChange(null);
}
});
},
// Switch usb function by modifying property of persist.sys.usb.config.
enableUsbRndis: function(aEnable, aCallback) {
debug("enableUsbRndis: " + aEnable);
let params = {
cmd: "enableUsbRndis",
enable: aEnable
};
// Ask net work to report the result when this value is set to true.
if (aCallback) {
params.report = true;
} else {
params.report = false;
}
// The callback function in controlMessage may not be fired immediately.
//this._usbTetheringAction = TETHERING_STATE_ONGOING;
this.controlMessage(params, function(aData) {
aCallback.enableUsbRndisResult(aData.result, aData.enable);
});
},
updateUpStream: function(aPrevious, aCurrent, aCallback) {
let params = {
cmd: "updateUpStream",
preInternalIfname: aPrevious.internalIfname,
preExternalIfname: aPrevious.externalIfname,
curInternalIfname: aCurrent.internalIfname,
curExternalIfname: aCurrent.externalIfname
};
this.controlMessage(params, function(aData) {
let code = aData.resultCode;
let reason = aData.resultReason;
debug("updateUpStream result: Code " + code + " reason " + reason);
aCallback.updateUpStreamResult(!isError(code), aData.curExternalIfname);
});
},
configureInterface: function(aConfig, aCallback) {
let params = {
cmd: "configureInterface",
ifname: aConfig.ifname,
ipaddr: aConfig.ipaddr,
mask: aConfig.mask,
gateway_long: aConfig.gateway,
dns1_long: aConfig.dns1,
dns2_long: aConfig.dns2,
};
this.controlMessage(params, function(aResult) {
aCallback.nativeCommandResult(!aResult.error);
});
},
dhcpRequest: function(aInterfaceName, aCallback) {
let params = {
cmd: "dhcpRequest",
ifname: aInterfaceName
};
this.controlMessage(params, function(aResult) {
aCallback.dhcpRequestResult(!aResult.error, aResult.error ? null : aResult);
});
},
stopDhcp: function(aInterfaceName, aCallback) {
let params = {
cmd: "stopDhcp",
ifname: aInterfaceName
};
this.controlMessage(params, function(aResult) {
aCallback.nativeCommandResult(!aResult.error);
});
},
enableInterface: function(aInterfaceName, aCallback) {
let params = {
cmd: "enableInterface",
ifname: aInterfaceName
};
this.controlMessage(params, function(aResult) {
aCallback.nativeCommandResult(!aResult.error);
});
},
disableInterface: function(aInterfaceName, aCallback) {
let params = {
cmd: "disableInterface",
ifname: aInterfaceName
};
this.controlMessage(params, function(aResult) {
aCallback.nativeCommandResult(!aResult.error);
});
},
resetConnections: function(aInterfaceName, aCallback) {
let params = {
cmd: "resetConnections",
ifname: aInterfaceName
};
this.controlMessage(params, function(aResult) {
aCallback.nativeCommandResult(!aResult.error);
});
},
createNetwork: function(aInterfaceName, aCallback) {
let params = {
cmd: "createNetwork",
ifname: aInterfaceName
};
this.controlMessage(params, function(aResult) {
aCallback.nativeCommandResult(!aResult.error);
});
},
destroyNetwork: function(aInterfaceName, aCallback) {
let params = {
cmd: "destroyNetwork",
ifname: aInterfaceName
};
this.controlMessage(params, function(aResult) {
aCallback.nativeCommandResult(!aResult.error);
});
},
getNetId: function(aInterfaceName) {
let params = {
cmd: "getNetId",
ifname: aInterfaceName
};
return new Promise((aResolve, aReject) => {
this.controlMessage(params, result => {
if (result.error) {
aReject(result.reason);
return;
}
aResolve(result.netId);
});
});
},
setMtu: function (aInterfaceName, aMtu, aCallback) {
debug("Set MTU on " + aInterfaceName + ": " + aMtu);
let params = {
cmd: "setMtu",
ifname: aInterfaceName,
mtu: aMtu
};
this.controlMessage(params, function(aResult) {
aCallback.nativeCommandResult(!aResult.error);
});
}
};
this.NSGetFactory = XPCOMUtils.generateNSGetFactory([NetworkService]);