summaryrefslogtreecommitdiffstats
path: root/dom/system/gonk/NetworkUtils.h
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /dom/system/gonk/NetworkUtils.h
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'dom/system/gonk/NetworkUtils.h')
-rw-r--r--dom/system/gonk/NetworkUtils.h498
1 files changed, 498 insertions, 0 deletions
diff --git a/dom/system/gonk/NetworkUtils.h b/dom/system/gonk/NetworkUtils.h
new file mode 100644
index 000000000..d1af35f09
--- /dev/null
+++ b/dom/system/gonk/NetworkUtils.h
@@ -0,0 +1,498 @@
+/* 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/. */
+
+#ifndef NetworkUtils_h
+#define NetworkUtils_h
+
+#include "nsAutoPtr.h"
+#include "nsString.h"
+#include "mozilla/dom/NetworkOptionsBinding.h"
+#include "mozilla/dom/network/NetUtils.h"
+#include "mozilla/ipc/Netd.h"
+#include "nsTArray.h"
+#include "NetIdManager.h"
+
+class NetworkParams;
+class CommandChain;
+
+class CommandCallback {
+public:
+ typedef void (*CallbackType)(CommandChain*, bool,
+ mozilla::dom::NetworkResultOptions& aResult);
+
+ typedef void (*CallbackWrapperType)(CallbackType aOriginalCallback,
+ CommandChain*, bool,
+ mozilla::dom::NetworkResultOptions& aResult);
+
+ CommandCallback()
+ : mCallback(nullptr)
+ , mCallbackWrapper(nullptr)
+ {
+ }
+
+ CommandCallback(CallbackType aCallback)
+ : mCallback(aCallback)
+ , mCallbackWrapper(nullptr)
+ {
+ }
+
+ CommandCallback(CallbackWrapperType aCallbackWrapper,
+ CommandCallback aOriginalCallback)
+ : mCallback(aOriginalCallback.mCallback)
+ , mCallbackWrapper(aCallbackWrapper)
+ {
+ }
+
+ void operator()(CommandChain* aChain, bool aError,
+ mozilla::dom::NetworkResultOptions& aResult)
+ {
+ if (mCallbackWrapper) {
+ return mCallbackWrapper(mCallback, aChain, aError, aResult);
+ }
+ if (mCallback) {
+ return mCallback(aChain, aError, aResult);
+ }
+ }
+
+private:
+ CallbackType mCallback;
+ CallbackWrapperType mCallbackWrapper;
+};
+
+typedef void (*CommandFunc)(CommandChain*, CommandCallback,
+ mozilla::dom::NetworkResultOptions& aResult);
+typedef void (*MessageCallback)(mozilla::dom::NetworkResultOptions& aResult);
+typedef void (*ErrorCallback)(NetworkParams& aOptions,
+ mozilla::dom::NetworkResultOptions& aResult);
+
+class NetworkParams
+{
+public:
+ NetworkParams() {
+ }
+
+ NetworkParams(const mozilla::dom::NetworkCommandOptions& aOther) {
+
+#define COPY_SEQUENCE_FIELD(prop, type) \
+ if (aOther.prop.WasPassed()) { \
+ mozilla::dom::Sequence<type > const & currentValue = aOther.prop.InternalValue(); \
+ uint32_t length = currentValue.Length(); \
+ for (uint32_t idx = 0; idx < length; idx++) { \
+ prop.AppendElement(currentValue[idx]); \
+ } \
+ }
+
+#define COPY_OPT_STRING_FIELD(prop, defaultValue) \
+ if (aOther.prop.WasPassed()) { \
+ if (aOther.prop.Value().EqualsLiteral("null")) { \
+ prop = defaultValue; \
+ } else { \
+ prop = aOther.prop.Value(); \
+ } \
+ } else { \
+ prop = defaultValue; \
+ }
+
+#define COPY_OPT_FIELD(prop, defaultValue) \
+ if (aOther.prop.WasPassed()) { \
+ prop = aOther.prop.Value(); \
+ } else { \
+ prop = defaultValue; \
+ }
+
+#define COPY_FIELD(prop) prop = aOther.prop;
+
+ COPY_FIELD(mId)
+ COPY_FIELD(mCmd)
+ COPY_OPT_STRING_FIELD(mDomain, EmptyString())
+ COPY_OPT_STRING_FIELD(mGateway, EmptyString())
+ COPY_SEQUENCE_FIELD(mGateways, nsString)
+ COPY_OPT_STRING_FIELD(mIfname, EmptyString())
+ COPY_OPT_STRING_FIELD(mIp, EmptyString())
+ COPY_OPT_FIELD(mPrefixLength, 0)
+ COPY_OPT_STRING_FIELD(mMode, EmptyString())
+ COPY_OPT_FIELD(mReport, false)
+ COPY_OPT_FIELD(mEnabled, false)
+ COPY_OPT_STRING_FIELD(mWifictrlinterfacename, EmptyString())
+ COPY_OPT_STRING_FIELD(mInternalIfname, EmptyString())
+ COPY_OPT_STRING_FIELD(mExternalIfname, EmptyString())
+ COPY_OPT_FIELD(mEnable, false)
+ COPY_OPT_STRING_FIELD(mSsid, EmptyString())
+ COPY_OPT_STRING_FIELD(mSecurity, EmptyString())
+ COPY_OPT_STRING_FIELD(mKey, EmptyString())
+ COPY_OPT_STRING_FIELD(mPrefix, EmptyString())
+ COPY_OPT_STRING_FIELD(mLink, EmptyString())
+ COPY_SEQUENCE_FIELD(mInterfaceList, nsString)
+ COPY_OPT_STRING_FIELD(mWifiStartIp, EmptyString())
+ COPY_OPT_STRING_FIELD(mWifiEndIp, EmptyString())
+ COPY_OPT_STRING_FIELD(mUsbStartIp, EmptyString())
+ COPY_OPT_STRING_FIELD(mUsbEndIp, EmptyString())
+ COPY_OPT_STRING_FIELD(mDns1, EmptyString())
+ COPY_OPT_STRING_FIELD(mDns2, EmptyString())
+ COPY_SEQUENCE_FIELD(mDnses, nsString)
+ COPY_OPT_STRING_FIELD(mStartIp, EmptyString())
+ COPY_OPT_STRING_FIELD(mEndIp, EmptyString())
+ COPY_OPT_STRING_FIELD(mServerIp, EmptyString())
+ COPY_OPT_STRING_FIELD(mMaskLength, EmptyString())
+ COPY_OPT_STRING_FIELD(mPreInternalIfname, EmptyString())
+ COPY_OPT_STRING_FIELD(mPreExternalIfname, EmptyString())
+ COPY_OPT_STRING_FIELD(mCurInternalIfname, EmptyString())
+ COPY_OPT_STRING_FIELD(mCurExternalIfname, EmptyString())
+ COPY_OPT_FIELD(mThreshold, -1)
+ COPY_OPT_FIELD(mIpaddr, 0)
+ COPY_OPT_FIELD(mMask, 0)
+ COPY_OPT_FIELD(mGateway_long, 0)
+ COPY_OPT_FIELD(mDns1_long, 0)
+ COPY_OPT_FIELD(mDns2_long, 0)
+ COPY_OPT_FIELD(mMtu, 0)
+
+ mLoopIndex = 0;
+
+#undef COPY_SEQUENCE_FIELD
+#undef COPY_OPT_STRING_FIELD
+#undef COPY_OPT_FIELD
+#undef COPY_FIELD
+ }
+
+ // Followings attributes are 1-to-1 mapping to NetworkCommandOptions.
+ int32_t mId;
+ nsString mCmd;
+ nsString mDomain;
+ nsString mGateway;
+ nsTArray<nsString> mGateways;
+ nsString mIfname;
+ nsString mIp;
+ uint32_t mPrefixLength;
+ nsString mMode;
+ bool mReport;
+ bool mEnabled;
+ nsString mWifictrlinterfacename;
+ nsString mInternalIfname;
+ nsString mExternalIfname;
+ bool mEnable;
+ nsString mSsid;
+ nsString mSecurity;
+ nsString mKey;
+ nsString mPrefix;
+ nsString mLink;
+ nsTArray<nsString> mInterfaceList;
+ nsString mWifiStartIp;
+ nsString mWifiEndIp;
+ nsString mUsbStartIp;
+ nsString mUsbEndIp;
+ nsString mDns1;
+ nsString mDns2;
+ nsTArray<nsString> mDnses;
+ nsString mStartIp;
+ nsString mEndIp;
+ nsString mServerIp;
+ nsString mMaskLength;
+ nsString mPreInternalIfname;
+ nsString mPreExternalIfname;
+ nsString mCurInternalIfname;
+ nsString mCurExternalIfname;
+ long long mThreshold;
+ long mIpaddr;
+ long mMask;
+ long mGateway_long;
+ long mDns1_long;
+ long mDns2_long;
+ long mMtu;
+
+ // Auxiliary information required to carry accros command chain.
+ int mNetId; // A locally defined id per interface.
+ uint32_t mLoopIndex; // Loop index for adding/removing multiple gateways.
+};
+
+// CommandChain store the necessary information to execute command one by one.
+// Including :
+// 1. Command parameters.
+// 2. Command list.
+// 3. Error callback function.
+// 4. Index of current execution command.
+class CommandChain final
+{
+public:
+ CommandChain(const NetworkParams& aParams,
+ const CommandFunc aCmds[],
+ uint32_t aLength,
+ ErrorCallback aError)
+ : mIndex(-1)
+ , mParams(aParams)
+ , mCommands(aCmds)
+ , mLength(aLength)
+ , mError(aError) {
+ }
+
+ NetworkParams&
+ getParams()
+ {
+ return mParams;
+ };
+
+ CommandFunc
+ getNextCommand()
+ {
+ mIndex++;
+ return mIndex < mLength ? mCommands[mIndex] : nullptr;
+ };
+
+ ErrorCallback
+ getErrorCallback() const
+ {
+ return mError;
+ };
+
+private:
+ uint32_t mIndex;
+ NetworkParams mParams;
+ const CommandFunc* mCommands;
+ uint32_t mLength;
+ ErrorCallback mError;
+};
+
+// A helper class to easily construct a resolved
+// or a pending result for command execution.
+class CommandResult
+{
+public:
+ struct Pending {};
+
+public:
+ CommandResult(int32_t aResultCode);
+ CommandResult(const mozilla::dom::NetworkResultOptions& aResult);
+ CommandResult(const Pending&);
+ bool isPending() const;
+
+ mozilla::dom::NetworkResultOptions mResult;
+
+private:
+ bool mIsPending;
+};
+
+class NetworkUtils final
+{
+public:
+ NetworkUtils(MessageCallback aCallback);
+ ~NetworkUtils();
+
+ void ExecuteCommand(NetworkParams aOptions);
+ void onNetdMessage(mozilla::ipc::NetdCommand* aCommand);
+
+ MessageCallback getMessageCallback() { return mMessageCallback; }
+
+private:
+ /**
+ * Commands supported by NetworkUtils.
+ */
+ CommandResult configureInterface(NetworkParams& aOptions);
+ CommandResult dhcpRequest(NetworkParams& aOptions);
+ CommandResult stopDhcp(NetworkParams& aOptions);
+ CommandResult enableInterface(NetworkParams& aOptions);
+ CommandResult disableInterface(NetworkParams& aOptions);
+ CommandResult resetConnections(NetworkParams& aOptions);
+ CommandResult setDefaultRoute(NetworkParams& aOptions);
+ CommandResult addHostRoute(NetworkParams& aOptions);
+ CommandResult removeDefaultRoute(NetworkParams& aOptions);
+ CommandResult removeHostRoute(NetworkParams& aOptions);
+ CommandResult removeNetworkRoute(NetworkParams& aOptions);
+ CommandResult setDNS(NetworkParams& aOptions);
+ CommandResult addSecondaryRoute(NetworkParams& aOptions);
+ CommandResult removeSecondaryRoute(NetworkParams& aOptions);
+ CommandResult setNetworkInterfaceAlarm(NetworkParams& aOptions);
+ CommandResult enableNetworkInterfaceAlarm(NetworkParams& aOptions);
+ CommandResult disableNetworkInterfaceAlarm(NetworkParams& aOptions);
+ CommandResult setTetheringAlarm(NetworkParams& aOptions);
+ CommandResult removeTetheringAlarm(NetworkParams& aOptions);
+ CommandResult getTetheringStatus(NetworkParams& aOptions);
+ CommandResult setWifiOperationMode(NetworkParams& aOptions);
+ CommandResult setDhcpServer(NetworkParams& aOptions);
+ CommandResult setWifiTethering(NetworkParams& aOptions);
+ CommandResult setUSBTethering(NetworkParams& aOptions);
+ CommandResult enableUsbRndis(NetworkParams& aOptions);
+ CommandResult updateUpStream(NetworkParams& aOptions);
+ CommandResult createNetwork(NetworkParams& aOptions);
+ CommandResult destroyNetwork(NetworkParams& aOptions);
+ CommandResult getNetId(NetworkParams& aOptions);
+ CommandResult setMtu(NetworkParams& aOptions);
+ CommandResult getInterfaces(NetworkParams& aOptions);
+ CommandResult getInterfaceConfig(NetworkParams& aOptions);
+ CommandResult setInterfaceConfig(NetworkParams& aOptions);
+
+ CommandResult addHostRouteLegacy(NetworkParams& aOptions);
+ CommandResult removeHostRouteLegacy(NetworkParams& aOptions);
+ CommandResult setDefaultRouteLegacy(NetworkParams& aOptions);
+ CommandResult removeDefaultRouteLegacy(NetworkParams& aOptions);
+ CommandResult removeNetworkRouteLegacy(NetworkParams& aOptions);
+
+
+ /**
+ * function pointer array holds all netd commands should be executed
+ * in sequence to accomplish a given command by other module.
+ */
+ static const CommandFunc sWifiEnableChain[];
+ static const CommandFunc sWifiDisableChain[];
+ static const CommandFunc sWifiFailChain[];
+ static const CommandFunc sWifiRetryChain[];
+ static const CommandFunc sWifiOperationModeChain[];
+ static const CommandFunc sUSBEnableChain[];
+ static const CommandFunc sUSBDisableChain[];
+ static const CommandFunc sUSBFailChain[];
+ static const CommandFunc sUpdateUpStreamChain[];
+ static const CommandFunc sStartDhcpServerChain[];
+ static const CommandFunc sStopDhcpServerChain[];
+ static const CommandFunc sNetworkInterfaceEnableAlarmChain[];
+ static const CommandFunc sNetworkInterfaceDisableAlarmChain[];
+ static const CommandFunc sNetworkInterfaceSetAlarmChain[];
+ static const CommandFunc sTetheringInterfaceSetAlarmChain[];
+ static const CommandFunc sTetheringInterfaceRemoveAlarmChain[];
+ static const CommandFunc sTetheringGetStatusChain[];
+ static const CommandFunc sGetInterfacesChain[];
+ static const CommandFunc sGetInterfaceConfigChain[];
+ static const CommandFunc sSetInterfaceConfigChain[];
+
+ /**
+ * Individual netd command stored in command chain.
+ */
+#define PARAMS CommandChain* aChain, CommandCallback aCallback, \
+ mozilla::dom::NetworkResultOptions& aResult
+ static void wifiFirmwareReload(PARAMS);
+ static void startAccessPointDriver(PARAMS);
+ static void stopAccessPointDriver(PARAMS);
+ static void setAccessPoint(PARAMS);
+ static void cleanUpStream(PARAMS);
+ static void createUpStream(PARAMS);
+ static void startSoftAP(PARAMS);
+ static void stopSoftAP(PARAMS);
+ static void clearWifiTetherParms(PARAMS);
+ static void enableAlarm(PARAMS);
+ static void disableAlarm(PARAMS);
+ static void setQuota(PARAMS);
+ static void removeQuota(PARAMS);
+ static void setAlarm(PARAMS);
+ static void removeAlarm(PARAMS);
+ static void setGlobalAlarm(PARAMS);
+ static void removeGlobalAlarm(PARAMS);
+ static void tetherInterface(PARAMS);
+ static void addInterfaceToLocalNetwork(PARAMS);
+ static void addRouteToLocalNetwork(PARAMS);
+ static void preTetherInterfaceList(PARAMS);
+ static void postTetherInterfaceList(PARAMS);
+ static void addUpstreamInterface(PARAMS);
+ static void removeUpstreamInterface(PARAMS);
+ static void setIpForwardingEnabled(PARAMS);
+ static void tetheringStatus(PARAMS);
+ static void stopTethering(PARAMS);
+ static void startTethering(PARAMS);
+ static void untetherInterface(PARAMS);
+ static void removeInterfaceFromLocalNetwork(PARAMS);
+ static void setDnsForwarders(PARAMS);
+ static void enableNat(PARAMS);
+ static void disableNat(PARAMS);
+ static void setDefaultInterface(PARAMS);
+ static void setInterfaceDns(PARAMS);
+ static void getInterfaceList(PARAMS);
+ static void getConfig(PARAMS);
+ static void setConfig(PARAMS);
+ static void wifiTetheringSuccess(PARAMS);
+ static void usbTetheringSuccess(PARAMS);
+ static void networkInterfaceAlarmSuccess(PARAMS);
+ static void updateUpStreamSuccess(PARAMS);
+ static void setDhcpServerSuccess(PARAMS);
+ static void wifiOperationModeSuccess(PARAMS);
+ static void clearAddrForInterface(PARAMS);
+ static void createNetwork(PARAMS);
+ static void destroyNetwork(PARAMS);
+ static void addInterfaceToNetwork(PARAMS);
+ static void addDefaultRouteToNetwork(PARAMS);
+ static void setDefaultNetwork(PARAMS);
+ static void removeDefaultRoute(PARAMS);
+ static void removeNetworkRouteSuccess(PARAMS);
+ static void removeNetworkRoute(PARAMS);
+ static void addRouteToInterface(PARAMS);
+ static void removeRouteFromInterface(PARAMS);
+ static void modifyRouteOnInterface(PARAMS, bool aDoAdd);
+ static void enableIpv6(PARAMS);
+ static void disableIpv6(PARAMS);
+ static void setMtu(PARAMS);
+ static void setIpv6Enabled(PARAMS, bool aEnabled);
+ static void addRouteToSecondaryTable(PARAMS);
+ static void removeRouteFromSecondaryTable(PARAMS);
+ static void defaultAsyncSuccessHandler(PARAMS);
+ static void getInterfacesSuccess(PARAMS);
+ static void getInterfaceConfigSuccess(PARAMS);
+ static void setInterfaceConfigSuccess(PARAMS);
+
+#undef PARAMS
+
+ /**
+ * Error callback function executed when a command is fail.
+ */
+#define PARAMS NetworkParams& aOptions, \
+ mozilla::dom::NetworkResultOptions& aResult
+ static void wifiTetheringFail(PARAMS);
+ static void wifiOperationModeFail(PARAMS);
+ static void usbTetheringFail(PARAMS);
+ static void updateUpStreamFail(PARAMS);
+ static void setDhcpServerFail(PARAMS);
+ static void networkInterfaceAlarmFail(PARAMS);
+ static void setDnsFail(PARAMS);
+ static void defaultAsyncFailureHandler(PARAMS);
+ static void getInterfacesFail(PARAMS);
+ static void getInterfaceConfigFail(PARAMS);
+ static void setInterfaceConfigFail(PARAMS);
+
+#undef PARAMS
+
+ /**
+ * Command chain processing functions.
+ */
+ static void next(CommandChain* aChain, bool aError,
+ mozilla::dom::NetworkResultOptions& aResult);
+ static void nextNetdCommand();
+ static void doCommand(const char* aCommand, CommandChain* aChain, CommandCallback aCallback);
+
+ /**
+ * Notify broadcast message to main thread.
+ */
+ void sendBroadcastMessage(uint32_t code, char* reason);
+
+ /**
+ * Utility functions.
+ */
+ CommandResult checkUsbRndisState(NetworkParams& aOptions);
+ void dumpParams(NetworkParams& aOptions, const char* aType);
+
+ static void escapeQuote(nsCString& aString);
+ inline uint32_t netdResponseType(uint32_t code);
+ inline bool isBroadcastMessage(uint32_t code);
+ inline bool isError(uint32_t code);
+ inline bool isComplete(uint32_t code);
+ inline bool isProceeding(uint32_t code);
+ void Shutdown();
+ static void runNextQueuedCommandChain();
+ static void finalizeSuccess(CommandChain* aChain,
+ mozilla::dom::NetworkResultOptions& aResult);
+
+ template<size_t N>
+ static void runChain(const NetworkParams& aParams,
+ const CommandFunc (&aCmds)[N],
+ ErrorCallback aError);
+
+ static nsCString getSubnetIp(const nsCString& aIp, int aPrefixLength);
+
+ /**
+ * Callback function to send netd result to main thread.
+ */
+ MessageCallback mMessageCallback;
+
+ /*
+ * Utility class to access libnetutils.
+ */
+ nsAutoPtr<NetUtils> mNetUtils;
+
+ NetIdManager mNetIdManager;
+};
+
+#endif