summaryrefslogtreecommitdiffstats
path: root/ipc/ril/Ril.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'ipc/ril/Ril.cpp')
-rw-r--r--ipc/ril/Ril.cpp458
1 files changed, 458 insertions, 0 deletions
diff --git a/ipc/ril/Ril.cpp b/ipc/ril/Ril.cpp
new file mode 100644
index 000000000..90fb12052
--- /dev/null
+++ b/ipc/ril/Ril.cpp
@@ -0,0 +1,458 @@
+/* -*- Mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 40 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#include "mozilla/ipc/Ril.h"
+#include <fcntl.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include "jsfriendapi.h"
+#include "mozilla/ArrayUtils.h"
+#include "mozilla/dom/ScriptSettings.h"
+#include "mozilla/dom/workers/Workers.h"
+#include "mozilla/ipc/RilSocket.h"
+#include "mozilla/ipc/RilSocketConsumer.h"
+#include "nsThreadUtils.h" // For NS_IsMainThread.
+#include "RilConnector.h"
+
+#ifdef CHROMIUM_LOG
+#undef CHROMIUM_LOG
+#endif
+
+#if defined(MOZ_WIDGET_GONK)
+#include <android/log.h>
+#define CHROMIUM_LOG(args...) __android_log_print(ANDROID_LOG_INFO, "Gonk", args)
+#else
+#define CHROMIUM_LOG(args...) printf(args);
+#endif
+
+namespace mozilla {
+namespace ipc {
+
+USING_WORKERS_NAMESPACE;
+using namespace JS;
+
+class RilConsumer;
+
+static const char RIL_SOCKET_NAME[] = "/dev/socket/rilproxy";
+
+static nsTArray<UniquePtr<RilConsumer>> sRilConsumers;
+
+//
+// RilConsumer
+//
+
+class RilConsumer final : public RilSocketConsumer
+{
+public:
+ RilConsumer();
+
+ nsresult ConnectWorkerToRIL(JSContext* aCx);
+
+ nsresult Register(unsigned long aClientId,
+ WorkerCrossThreadDispatcher* aDispatcher);
+ void Unregister();
+
+ // Methods for |RilSocketConsumer|
+ //
+
+ void ReceiveSocketData(JSContext* aCx,
+ int aIndex,
+ UniquePtr<UnixSocketBuffer>& aBuffer) override;
+ void OnConnectSuccess(int aIndex) override;
+ void OnConnectError(int aIndex) override;
+ void OnDisconnect(int aIndex) override;
+
+protected:
+ static bool PostRILMessage(JSContext* aCx, unsigned aArgc, Value* aVp);
+
+ nsresult Send(JSContext* aCx, const CallArgs& aArgs);
+ nsresult Receive(JSContext* aCx,
+ uint32_t aClientId,
+ const UnixSocketBuffer* aBuffer);
+ void Close();
+
+private:
+ RefPtr<RilSocket> mSocket;
+ nsCString mAddress;
+ bool mShutdown;
+};
+
+RilConsumer::RilConsumer()
+ : mShutdown(false)
+{ }
+
+nsresult
+RilConsumer::ConnectWorkerToRIL(JSContext* aCx)
+{
+ // Set up the postRILMessage on the function for worker -> RIL thread
+ // communication.
+ Rooted<JSObject*> workerGlobal(aCx, CurrentGlobalOrNull(aCx));
+
+ // Check whether |postRILMessage| has been defined. No one but this class
+ // should ever define |postRILMessage| in a RIL worker.
+ Rooted<Value> val(aCx);
+ if (!JS_GetProperty(aCx, workerGlobal, "postRILMessage", &val)) {
+ // Just returning failure here will cause the exception on the JSContext to
+ // be reported as needed.
+ return NS_ERROR_FAILURE;
+ }
+
+ // Make sure that |postRILMessage| is a function.
+ if (JSTYPE_FUNCTION == JS_TypeOfValue(aCx, val)) {
+ return NS_OK;
+ }
+
+ JSFunction* postRILMessage = JS_DefineFunction(aCx, workerGlobal,
+ "postRILMessage",
+ PostRILMessage, 2, 0);
+ if (NS_WARN_IF(!postRILMessage)) {
+ // Just returning failure here will cause the exception on the JSContext to
+ // be reported as needed.
+ return NS_ERROR_FAILURE;
+ }
+ return NS_OK;
+}
+
+nsresult
+RilConsumer::Register(unsigned long aClientId,
+ WorkerCrossThreadDispatcher* aDispatcher)
+{
+ // Only append client id after RIL_SOCKET_NAME when it's not connected to
+ // the first(0) rilproxy for compatibility.
+ if (!aClientId) {
+ mAddress = RIL_SOCKET_NAME;
+ } else {
+ struct sockaddr_un addr_un;
+ snprintf(addr_un.sun_path, sizeof addr_un.sun_path, "%s%lu",
+ RIL_SOCKET_NAME, aClientId);
+ mAddress = addr_un.sun_path;
+ }
+
+ mSocket = new RilSocket(aDispatcher, this, aClientId);
+
+ nsresult rv = mSocket->Connect(new RilConnector(mAddress, aClientId));
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+
+ return NS_OK;
+}
+
+void
+RilConsumer::Unregister()
+{
+ mShutdown = true;
+ Close();
+}
+
+bool
+RilConsumer::PostRILMessage(JSContext* aCx, unsigned aArgc, Value* aVp)
+{
+ CallArgs args = CallArgsFromVp(aArgc, aVp);
+
+ if (args.length() != 2) {
+ JS_ReportErrorASCII(aCx, "Expecting two arguments with the RIL message");
+ return false;
+ }
+
+ int clientId = args[0].toInt32();
+
+ if ((ssize_t)sRilConsumers.Length() <= clientId || !sRilConsumers[clientId]) {
+ // Probably shutting down.
+ return true;
+ }
+
+ nsresult rv = sRilConsumers[clientId]->Send(aCx, args);
+ if (NS_FAILED(rv)) {
+ return false;
+ }
+
+ return true;
+}
+
+nsresult
+RilConsumer::Send(JSContext* aCx, const CallArgs& aArgs)
+{
+ if (NS_WARN_IF(!mSocket) ||
+ NS_WARN_IF(mSocket->GetConnectionStatus() == SOCKET_DISCONNECTED)) {
+ // Probably shutting down.
+ return NS_OK;
+ }
+
+ UniquePtr<UnixSocketRawData> raw;
+
+ Value v = aArgs[1];
+
+ if (v.isString()) {
+ JSAutoByteString abs;
+ Rooted<JSString*> str(aCx, v.toString());
+ if (!abs.encodeUtf8(aCx, str)) {
+ return NS_ERROR_FAILURE;
+ }
+
+ raw = MakeUnique<UnixSocketRawData>(abs.ptr(), abs.length());
+ } else if (!v.isPrimitive()) {
+ JSObject* obj = v.toObjectOrNull();
+ if (!JS_IsTypedArrayObject(obj)) {
+ JS_ReportErrorASCII(aCx, "Object passed in wasn't a typed array");
+ return NS_ERROR_FAILURE;
+ }
+
+ uint32_t type = JS_GetArrayBufferViewType(obj);
+ if (type != js::Scalar::Int8 &&
+ type != js::Scalar::Uint8 &&
+ type != js::Scalar::Uint8Clamped) {
+ JS_ReportErrorASCII(aCx, "Typed array data is not octets");
+ return NS_ERROR_FAILURE;
+ }
+
+ size_t size = JS_GetTypedArrayByteLength(obj);
+ bool isShared;
+ void* data;
+ {
+ AutoCheckCannotGC nogc;
+ data = JS_GetArrayBufferViewData(obj, &isShared, nogc);
+ }
+ if (isShared) {
+ JS_ReportErrorASCII(
+ aCx, "Incorrect argument. Shared memory not supported");
+ return NS_ERROR_FAILURE;
+ }
+ raw = MakeUnique<UnixSocketRawData>(data, size);
+ } else {
+ JS_ReportErrorASCII(
+ aCx, "Incorrect argument. Expecting a string or a typed array");
+ return NS_ERROR_FAILURE;
+ }
+
+ if (!raw) {
+ JS_ReportErrorASCII(aCx, "Unable to post to RIL");
+ return NS_ERROR_FAILURE;
+ }
+
+ mSocket->SendSocketData(raw.release());
+
+ return NS_OK;
+}
+
+nsresult
+RilConsumer::Receive(JSContext* aCx,
+ uint32_t aClientId,
+ const UnixSocketBuffer* aBuffer)
+{
+ MOZ_ASSERT(aBuffer);
+
+ Rooted<JSObject*> obj(aCx, CurrentGlobalOrNull(aCx));
+
+ Rooted<JSObject*> array(aCx, JS_NewUint8Array(aCx, aBuffer->GetSize()));
+ if (NS_WARN_IF(!array)) {
+ // Just suppress the exception, since our callers don't have a way to
+ // indicate they failed.
+ JS_ClearPendingException(aCx);
+ return NS_ERROR_FAILURE;
+ }
+ {
+ AutoCheckCannotGC nogc;
+ bool isShared;
+ memcpy(JS_GetArrayBufferViewData(array, &isShared, nogc),
+ aBuffer->GetData(), aBuffer->GetSize());
+ MOZ_ASSERT(!isShared); // Array was constructed above.
+ }
+
+ AutoValueArray<2> args(aCx);
+ args[0].setNumber(aClientId);
+ args[1].setObject(*array);
+
+ Rooted<Value> rval(aCx);
+ JS_CallFunctionName(aCx, obj, "onRILMessage", args, &rval);
+ // Just suppress the exception, since our callers don't have a way to
+ // indicate they failed.
+ JS_ClearPendingException(aCx);
+
+ return NS_OK;
+}
+
+void
+RilConsumer::Close()
+{
+ if (mSocket) {
+ mSocket->Close();
+ mSocket = nullptr;
+ }
+}
+
+// |RilSocketConnector|
+
+void
+RilConsumer::ReceiveSocketData(JSContext* aCx,
+ int aIndex,
+ UniquePtr<UnixSocketBuffer>& aBuffer)
+{
+ Receive(aCx, (uint32_t)aIndex, aBuffer.get());
+}
+
+void
+RilConsumer::OnConnectSuccess(int aIndex)
+{
+ // Nothing to do here.
+ CHROMIUM_LOG("RIL[%d]: %s\n", aIndex, __FUNCTION__);
+}
+
+void
+RilConsumer::OnConnectError(int aIndex)
+{
+ CHROMIUM_LOG("RIL[%d]: %s\n", aIndex, __FUNCTION__);
+ Close();
+}
+
+void
+RilConsumer::OnDisconnect(int aIndex)
+{
+ CHROMIUM_LOG("RIL[%d]: %s\n", aIndex, __FUNCTION__);
+ if (mShutdown) {
+ return;
+ }
+ mSocket->Connect(new RilConnector(mAddress, aIndex),
+ mSocket->GetSuggestedConnectDelayMs());
+}
+
+//
+// RilWorker
+//
+
+nsTArray<UniquePtr<RilWorker>> RilWorker::sRilWorkers;
+
+nsresult
+RilWorker::Register(unsigned int aClientId,
+ WorkerCrossThreadDispatcher* aDispatcher)
+{
+ MOZ_ASSERT(NS_IsMainThread());
+
+ sRilWorkers.EnsureLengthAtLeast(aClientId + 1);
+
+ if (sRilWorkers[aClientId]) {
+ NS_WARNING("RilWorkers already registered");
+ return NS_ERROR_FAILURE;
+ }
+
+ // Now that we're set up, connect ourselves to the RIL thread.
+ sRilWorkers[aClientId] = MakeUnique<RilWorker>(aDispatcher);
+
+ nsresult rv = sRilWorkers[aClientId]->RegisterConsumer(aClientId);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+
+ return NS_OK;
+}
+
+void
+RilWorker::Shutdown()
+{
+ MOZ_ASSERT(NS_IsMainThread());
+
+ for (size_t i = 0; i < sRilWorkers.Length(); ++i) {
+ if (!sRilWorkers[i]) {
+ continue;
+ }
+ sRilWorkers[i]->UnregisterConsumer(i);
+ sRilWorkers[i] = nullptr;
+ }
+}
+
+RilWorker::RilWorker(WorkerCrossThreadDispatcher* aDispatcher)
+ : mDispatcher(aDispatcher)
+{
+ MOZ_ASSERT(mDispatcher);
+}
+
+class RilWorker::RegisterConsumerTask : public WorkerTask
+{
+public:
+ RegisterConsumerTask(unsigned int aClientId,
+ WorkerCrossThreadDispatcher* aDispatcher)
+ : mClientId(aClientId)
+ , mDispatcher(aDispatcher)
+ {
+ MOZ_ASSERT(mDispatcher);
+ }
+
+ bool RunTask(JSContext* aCx) override
+ {
+ sRilConsumers.EnsureLengthAtLeast(mClientId + 1);
+
+ MOZ_ASSERT(!sRilConsumers[mClientId]);
+
+ auto rilConsumer = MakeUnique<RilConsumer>();
+
+ nsresult rv = rilConsumer->ConnectWorkerToRIL(aCx);
+ if (NS_FAILED(rv)) {
+ return false;
+ }
+
+ rv = rilConsumer->Register(mClientId, mDispatcher);
+ if (NS_FAILED(rv)) {
+ return false;
+ }
+ sRilConsumers[mClientId] = Move(rilConsumer);
+
+ return true;
+ }
+
+private:
+ unsigned int mClientId;
+ RefPtr<WorkerCrossThreadDispatcher> mDispatcher;
+};
+
+nsresult
+RilWorker::RegisterConsumer(unsigned int aClientId)
+{
+ RefPtr<RegisterConsumerTask> task = new RegisterConsumerTask(aClientId,
+ mDispatcher);
+ if (!mDispatcher->PostTask(task)) {
+ NS_WARNING("Failed to post register-consumer task.");
+ return NS_ERROR_UNEXPECTED;
+ }
+
+ return NS_OK;
+}
+
+class RilWorker::UnregisterConsumerTask : public WorkerTask
+{
+public:
+ UnregisterConsumerTask(unsigned int aClientId)
+ : mClientId(aClientId)
+ { }
+
+ bool RunTask(JSContext* aCx) override
+ {
+ MOZ_ASSERT(mClientId < sRilConsumers.Length());
+ MOZ_ASSERT(sRilConsumers[mClientId]);
+
+ sRilConsumers[mClientId]->Unregister();
+ sRilConsumers[mClientId] = nullptr;
+
+ return true;
+ }
+
+private:
+ unsigned int mClientId;
+};
+
+void
+RilWorker::UnregisterConsumer(unsigned int aClientId)
+{
+ RefPtr<UnregisterConsumerTask> task =
+ new UnregisterConsumerTask(aClientId);
+
+ if (!mDispatcher->PostTask(task)) {
+ NS_WARNING("Failed to post unregister-consumer task.");
+ return;
+ }
+}
+
+} // namespace ipc
+} // namespace mozilla