| /* |
| * Copyright (C) 2022 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. |
| */ |
| |
| #include <chrono> |
| #include <cstdlib> |
| #include <type_traits> |
| |
| #include "binderRpcTestCommon.h" |
| #include "binderRpcTestFixture.h" |
| |
| using namespace std::chrono_literals; |
| using namespace std::placeholders; |
| using testing::AssertionFailure; |
| using testing::AssertionResult; |
| using testing::AssertionSuccess; |
| |
| namespace android { |
| |
| static_assert(RPC_WIRE_PROTOCOL_VERSION + 1 == RPC_WIRE_PROTOCOL_VERSION_NEXT || |
| RPC_WIRE_PROTOCOL_VERSION == RPC_WIRE_PROTOCOL_VERSION_EXPERIMENTAL); |
| |
| TEST(BinderRpcParcel, EntireParcelFormatted) { |
| Parcel p; |
| p.writeInt32(3); |
| |
| EXPECT_DEATH_IF_SUPPORTED(p.markForBinder(sp<BBinder>::make()), |
| "format must be set before data is written"); |
| } |
| |
| TEST(BinderRpc, CannotUseNextWireVersion) { |
| auto session = RpcSession::make(); |
| EXPECT_FALSE(session->setProtocolVersion(RPC_WIRE_PROTOCOL_VERSION_NEXT)); |
| EXPECT_FALSE(session->setProtocolVersion(RPC_WIRE_PROTOCOL_VERSION_NEXT + 1)); |
| EXPECT_FALSE(session->setProtocolVersion(RPC_WIRE_PROTOCOL_VERSION_NEXT + 2)); |
| EXPECT_FALSE(session->setProtocolVersion(RPC_WIRE_PROTOCOL_VERSION_NEXT + 15)); |
| } |
| |
| #ifndef BINDER_RPC_TO_TRUSTY_TEST |
| TEST(BinderRpc, CanUseExperimentalWireVersion) { |
| auto session = RpcSession::make(); |
| EXPECT_EQ(hasExperimentalRpc(), |
| session->setProtocolVersion(RPC_WIRE_PROTOCOL_VERSION_EXPERIMENTAL)); |
| } |
| #endif |
| |
| TEST_P(BinderRpc, Ping) { |
| auto proc = createRpcTestSocketServerProcess({}); |
| ASSERT_NE(proc.rootBinder, nullptr); |
| EXPECT_EQ(OK, proc.rootBinder->pingBinder()); |
| } |
| |
| TEST_P(BinderRpc, GetInterfaceDescriptor) { |
| auto proc = createRpcTestSocketServerProcess({}); |
| ASSERT_NE(proc.rootBinder, nullptr); |
| EXPECT_EQ(IBinderRpcTest::descriptor, proc.rootBinder->getInterfaceDescriptor()); |
| } |
| |
| TEST_P(BinderRpc, MultipleSessions) { |
| if (serverSingleThreaded()) { |
| // Tests with multiple sessions require a multi-threaded service, |
| // but work fine on a single-threaded client |
| GTEST_SKIP() << "This test requires a multi-threaded service"; |
| } |
| |
| auto proc = createRpcTestSocketServerProcess({.numThreads = 1, .numSessions = 5}); |
| for (auto session : proc.proc->sessions) { |
| ASSERT_NE(nullptr, session.root); |
| EXPECT_EQ(OK, session.root->pingBinder()); |
| } |
| } |
| |
| TEST_P(BinderRpc, SeparateRootObject) { |
| if (serverSingleThreaded()) { |
| GTEST_SKIP() << "This test requires a multi-threaded service"; |
| } |
| |
| SocketType type = GetParam().type; |
| if (type == SocketType::PRECONNECTED || type == SocketType::UNIX || |
| type == SocketType::UNIX_BOOTSTRAP || type == SocketType::UNIX_RAW) { |
| // we can't get port numbers for unix sockets |
| return; |
| } |
| |
| auto proc = createRpcTestSocketServerProcess({.numSessions = 2}); |
| |
| int port1 = 0; |
| EXPECT_OK(proc.rootIface->getClientPort(&port1)); |
| |
| sp<IBinderRpcTest> rootIface2 = interface_cast<IBinderRpcTest>(proc.proc->sessions.at(1).root); |
| int port2; |
| EXPECT_OK(rootIface2->getClientPort(&port2)); |
| |
| // we should have a different IBinderRpcTest object created for each |
| // session, because we use setPerSessionRootObject |
| EXPECT_NE(port1, port2); |
| } |
| |
| TEST_P(BinderRpc, TransactionsMustBeMarkedRpc) { |
| auto proc = createRpcTestSocketServerProcess({}); |
| Parcel data; |
| Parcel reply; |
| EXPECT_EQ(BAD_TYPE, proc.rootBinder->transact(IBinder::PING_TRANSACTION, data, &reply, 0)); |
| } |
| |
| TEST_P(BinderRpc, AppendSeparateFormats) { |
| if (socketType() == SocketType::TIPC) { |
| GTEST_SKIP() << "Trusty does not support multiple server processes"; |
| } |
| |
| auto proc1 = createRpcTestSocketServerProcess({}); |
| auto proc2 = createRpcTestSocketServerProcess({}); |
| |
| Parcel pRaw; |
| |
| Parcel p1; |
| p1.markForBinder(proc1.rootBinder); |
| p1.writeInt32(3); |
| |
| EXPECT_EQ(BAD_TYPE, p1.appendFrom(&pRaw, 0, pRaw.dataSize())); |
| EXPECT_EQ(BAD_TYPE, pRaw.appendFrom(&p1, 0, p1.dataSize())); |
| |
| Parcel p2; |
| p2.markForBinder(proc2.rootBinder); |
| p2.writeInt32(7); |
| |
| EXPECT_EQ(BAD_TYPE, p1.appendFrom(&p2, 0, p2.dataSize())); |
| EXPECT_EQ(BAD_TYPE, p2.appendFrom(&p1, 0, p1.dataSize())); |
| } |
| |
| TEST_P(BinderRpc, UnknownTransaction) { |
| auto proc = createRpcTestSocketServerProcess({}); |
| Parcel data; |
| data.markForBinder(proc.rootBinder); |
| Parcel reply; |
| EXPECT_EQ(UNKNOWN_TRANSACTION, proc.rootBinder->transact(1337, data, &reply, 0)); |
| } |
| |
| TEST_P(BinderRpc, SendSomethingOneway) { |
| auto proc = createRpcTestSocketServerProcess({}); |
| EXPECT_OK(proc.rootIface->sendString("asdf")); |
| } |
| |
| TEST_P(BinderRpc, SendAndGetResultBack) { |
| auto proc = createRpcTestSocketServerProcess({}); |
| std::string doubled; |
| EXPECT_OK(proc.rootIface->doubleString("cool ", &doubled)); |
| EXPECT_EQ("cool cool ", doubled); |
| } |
| |
| TEST_P(BinderRpc, SendAndGetResultBackBig) { |
| auto proc = createRpcTestSocketServerProcess({}); |
| // Trusty has a limit of 4096 bytes for the entire RPC Binder message |
| size_t singleLen = socketType() == SocketType::TIPC ? 512 : 4096; |
| std::string single = std::string(singleLen, 'a'); |
| std::string doubled; |
| EXPECT_OK(proc.rootIface->doubleString(single, &doubled)); |
| EXPECT_EQ(single + single, doubled); |
| } |
| |
| TEST_P(BinderRpc, InvalidNullBinderReturn) { |
| auto proc = createRpcTestSocketServerProcess({}); |
| |
| sp<IBinder> outBinder; |
| EXPECT_EQ(proc.rootIface->getNullBinder(&outBinder).transactionError(), UNEXPECTED_NULL); |
| } |
| |
| TEST_P(BinderRpc, CallMeBack) { |
| auto proc = createRpcTestSocketServerProcess({}); |
| |
| int32_t pingResult; |
| EXPECT_OK(proc.rootIface->pingMe(new MyBinderRpcSession("foo"), &pingResult)); |
| EXPECT_EQ(OK, pingResult); |
| |
| EXPECT_EQ(0, MyBinderRpcSession::gNum); |
| } |
| |
| TEST_P(BinderRpc, RepeatBinder) { |
| auto proc = createRpcTestSocketServerProcess({}); |
| |
| sp<IBinder> inBinder = new MyBinderRpcSession("foo"); |
| sp<IBinder> outBinder; |
| EXPECT_OK(proc.rootIface->repeatBinder(inBinder, &outBinder)); |
| EXPECT_EQ(inBinder, outBinder); |
| |
| wp<IBinder> weak = inBinder; |
| inBinder = nullptr; |
| outBinder = nullptr; |
| |
| // Force reading a reply, to process any pending dec refs from the other |
| // process (the other process will process dec refs there before processing |
| // the ping here). |
| EXPECT_EQ(OK, proc.rootBinder->pingBinder()); |
| |
| EXPECT_EQ(nullptr, weak.promote()); |
| |
| EXPECT_EQ(0, MyBinderRpcSession::gNum); |
| } |
| |
| TEST_P(BinderRpc, RepeatTheirBinder) { |
| auto proc = createRpcTestSocketServerProcess({}); |
| |
| sp<IBinderRpcSession> session; |
| EXPECT_OK(proc.rootIface->openSession("aoeu", &session)); |
| |
| sp<IBinder> inBinder = IInterface::asBinder(session); |
| sp<IBinder> outBinder; |
| EXPECT_OK(proc.rootIface->repeatBinder(inBinder, &outBinder)); |
| EXPECT_EQ(inBinder, outBinder); |
| |
| wp<IBinder> weak = inBinder; |
| session = nullptr; |
| inBinder = nullptr; |
| outBinder = nullptr; |
| |
| // Force reading a reply, to process any pending dec refs from the other |
| // process (the other process will process dec refs there before processing |
| // the ping here). |
| EXPECT_EQ(OK, proc.rootBinder->pingBinder()); |
| |
| EXPECT_EQ(nullptr, weak.promote()); |
| } |
| |
| TEST_P(BinderRpc, RepeatBinderNull) { |
| auto proc = createRpcTestSocketServerProcess({}); |
| |
| sp<IBinder> outBinder; |
| EXPECT_OK(proc.rootIface->repeatBinder(nullptr, &outBinder)); |
| EXPECT_EQ(nullptr, outBinder); |
| } |
| |
| TEST_P(BinderRpc, HoldBinder) { |
| auto proc = createRpcTestSocketServerProcess({}); |
| |
| IBinder* ptr = nullptr; |
| { |
| sp<IBinder> binder = new BBinder(); |
| ptr = binder.get(); |
| EXPECT_OK(proc.rootIface->holdBinder(binder)); |
| } |
| |
| sp<IBinder> held; |
| EXPECT_OK(proc.rootIface->getHeldBinder(&held)); |
| |
| EXPECT_EQ(held.get(), ptr); |
| |
| // stop holding binder, because we test to make sure references are cleaned |
| // up |
| EXPECT_OK(proc.rootIface->holdBinder(nullptr)); |
| // and flush ref counts |
| EXPECT_EQ(OK, proc.rootBinder->pingBinder()); |
| } |
| |
| // START TESTS FOR LIMITATIONS OF SOCKET BINDER |
| // These are behavioral differences form regular binder, where certain usecases |
| // aren't supported. |
| |
| TEST_P(BinderRpc, CannotMixBindersBetweenUnrelatedSocketSessions) { |
| if (socketType() == SocketType::TIPC) { |
| GTEST_SKIP() << "Trusty does not support multiple server processes"; |
| } |
| |
| auto proc1 = createRpcTestSocketServerProcess({}); |
| auto proc2 = createRpcTestSocketServerProcess({}); |
| |
| sp<IBinder> outBinder; |
| EXPECT_EQ(INVALID_OPERATION, |
| proc1.rootIface->repeatBinder(proc2.rootBinder, &outBinder).transactionError()); |
| } |
| |
| TEST_P(BinderRpc, CannotMixBindersBetweenTwoSessionsToTheSameServer) { |
| if (serverSingleThreaded()) { |
| GTEST_SKIP() << "This test requires a multi-threaded service"; |
| } |
| |
| auto proc = createRpcTestSocketServerProcess({.numThreads = 1, .numSessions = 2}); |
| |
| sp<IBinder> outBinder; |
| EXPECT_EQ(INVALID_OPERATION, |
| proc.rootIface->repeatBinder(proc.proc->sessions.at(1).root, &outBinder) |
| .transactionError()); |
| } |
| |
| TEST_P(BinderRpc, CannotSendRegularBinderOverSocketBinder) { |
| if (!kEnableKernelIpc || noKernel()) { |
| GTEST_SKIP() << "Test disabled because Binder kernel driver was disabled " |
| "at build time."; |
| } |
| |
| auto proc = createRpcTestSocketServerProcess({}); |
| |
| sp<IBinder> someRealBinder = defaultServiceManager()->getService(String16("activity")); |
| ASSERT_NE(someRealBinder, nullptr); |
| sp<IBinder> outBinder; |
| EXPECT_EQ(INVALID_OPERATION, |
| proc.rootIface->repeatBinder(someRealBinder, &outBinder).transactionError()); |
| } |
| |
| TEST_P(BinderRpc, CannotSendSocketBinderOverRegularBinder) { |
| if (!kEnableKernelIpc || noKernel()) { |
| GTEST_SKIP() << "Test disabled because Binder kernel driver was disabled " |
| "at build time."; |
| } |
| |
| auto proc = createRpcTestSocketServerProcess({}); |
| |
| // for historical reasons, IServiceManager interface only returns the |
| // exception code |
| EXPECT_EQ(binder::Status::EX_TRANSACTION_FAILED, |
| defaultServiceManager()->addService(String16("not_suspicious"), proc.rootBinder)); |
| } |
| |
| // END TESTS FOR LIMITATIONS OF SOCKET BINDER |
| |
| class TestFrozenStateChangeCallback : public IBinder::FrozenStateChangeCallback { |
| public: |
| virtual void onStateChanged(const wp<IBinder>&, State) {} |
| }; |
| |
| TEST_P(BinderRpc, RpcBinderShouldFailOnFrozenStateCallbacks) { |
| auto proc = createRpcTestSocketServerProcess({}); |
| |
| sp<IBinder> a; |
| sp<TestFrozenStateChangeCallback> callback = sp<TestFrozenStateChangeCallback>::make(); |
| EXPECT_OK(proc.rootIface->alwaysGiveMeTheSameBinder(&a)); |
| EXPECT_DEATH_IF_SUPPORTED( |
| { std::ignore = a->addFrozenStateChangeCallback(callback); }, |
| "addFrozenStateChangeCallback\\(\\) is not supported for RPC Binder."); |
| } |
| |
| TEST_P(BinderRpc, RepeatRootObject) { |
| auto proc = createRpcTestSocketServerProcess({}); |
| |
| sp<IBinder> outBinder; |
| EXPECT_OK(proc.rootIface->repeatBinder(proc.rootBinder, &outBinder)); |
| EXPECT_EQ(proc.rootBinder, outBinder); |
| } |
| |
| TEST_P(BinderRpc, NestedTransactions) { |
| auto fileDescriptorTransportMode = RpcSession::FileDescriptorTransportMode::UNIX; |
| if (socketType() == SocketType::TIPC) { |
| // TIPC does not support file descriptors yet |
| fileDescriptorTransportMode = RpcSession::FileDescriptorTransportMode::NONE; |
| } |
| auto proc = createRpcTestSocketServerProcess({ |
| // Enable FD support because it uses more stack space and so represents |
| // something closer to a worst case scenario. |
| .clientFileDescriptorTransportMode = fileDescriptorTransportMode, |
| .serverSupportedFileDescriptorTransportModes = {fileDescriptorTransportMode}, |
| }); |
| |
| auto nastyNester = sp<MyBinderRpcTestDefault>::make(); |
| EXPECT_OK(proc.rootIface->nestMe(nastyNester, 10)); |
| |
| wp<IBinder> weak = nastyNester; |
| nastyNester = nullptr; |
| EXPECT_EQ(nullptr, weak.promote()); |
| } |
| |
| TEST_P(BinderRpc, SameBinderEquality) { |
| auto proc = createRpcTestSocketServerProcess({}); |
| |
| sp<IBinder> a; |
| EXPECT_OK(proc.rootIface->alwaysGiveMeTheSameBinder(&a)); |
| |
| sp<IBinder> b; |
| EXPECT_OK(proc.rootIface->alwaysGiveMeTheSameBinder(&b)); |
| |
| EXPECT_EQ(a, b); |
| } |
| |
| TEST_P(BinderRpc, SameBinderEqualityWeak) { |
| auto proc = createRpcTestSocketServerProcess({}); |
| |
| sp<IBinder> a; |
| EXPECT_OK(proc.rootIface->alwaysGiveMeTheSameBinder(&a)); |
| wp<IBinder> weak = a; |
| a = nullptr; |
| |
| sp<IBinder> b; |
| EXPECT_OK(proc.rootIface->alwaysGiveMeTheSameBinder(&b)); |
| |
| // this is the wrong behavior, since BpBinder |
| // doesn't implement onIncStrongAttempted |
| // but make sure there is no crash |
| EXPECT_EQ(nullptr, weak.promote()); |
| |
| GTEST_SKIP() << "Weak binders aren't currently re-promotable for RPC binder."; |
| |
| // In order to fix this: |
| // - need to have incStrongAttempted reflected across IPC boundary (wait for |
| // response to promote - round trip...) |
| // - sendOnLastWeakRef, to delete entries out of RpcState table |
| EXPECT_EQ(b, weak.promote()); |
| } |
| |
| #define EXPECT_SESSIONS(expected, iface) \ |
| do { \ |
| int session; \ |
| EXPECT_OK((iface)->getNumOpenSessions(&session)); \ |
| EXPECT_EQ(static_cast<int>(expected), session); \ |
| } while (false) |
| |
| TEST_P(BinderRpc, SingleSession) { |
| auto proc = createRpcTestSocketServerProcess({}); |
| |
| sp<IBinderRpcSession> session; |
| EXPECT_OK(proc.rootIface->openSession("aoeu", &session)); |
| std::string out; |
| EXPECT_OK(session->getName(&out)); |
| EXPECT_EQ("aoeu", out); |
| |
| EXPECT_SESSIONS(1, proc.rootIface); |
| session = nullptr; |
| EXPECT_SESSIONS(0, proc.rootIface); |
| } |
| |
| TEST_P(BinderRpc, ManySessions) { |
| auto proc = createRpcTestSocketServerProcess({}); |
| |
| std::vector<sp<IBinderRpcSession>> sessions; |
| |
| for (size_t i = 0; i < 15; i++) { |
| EXPECT_SESSIONS(i, proc.rootIface); |
| sp<IBinderRpcSession> session; |
| EXPECT_OK(proc.rootIface->openSession(std::to_string(i), &session)); |
| sessions.push_back(session); |
| } |
| EXPECT_SESSIONS(sessions.size(), proc.rootIface); |
| for (size_t i = 0; i < sessions.size(); i++) { |
| std::string out; |
| EXPECT_OK(sessions.at(i)->getName(&out)); |
| EXPECT_EQ(std::to_string(i), out); |
| } |
| EXPECT_SESSIONS(sessions.size(), proc.rootIface); |
| |
| while (!sessions.empty()) { |
| sessions.pop_back(); |
| EXPECT_SESSIONS(sessions.size(), proc.rootIface); |
| } |
| EXPECT_SESSIONS(0, proc.rootIface); |
| } |
| |
| TEST_P(BinderRpc, OnewayCallDoesNotWait) { |
| constexpr size_t kReallyLongTimeMs = 100; |
| constexpr size_t kSleepMs = kReallyLongTimeMs * 5; |
| |
| auto proc = createRpcTestSocketServerProcess({}); |
| |
| size_t epochMsBefore = epochMillis(); |
| |
| EXPECT_OK(proc.rootIface->sleepMsAsync(kSleepMs)); |
| |
| size_t epochMsAfter = epochMillis(); |
| EXPECT_LT(epochMsAfter, epochMsBefore + kReallyLongTimeMs); |
| } |
| |
| TEST_P(BinderRpc, Callbacks) { |
| const static std::string kTestString = "good afternoon!"; |
| |
| for (bool callIsOneway : {true, false}) { |
| for (bool callbackIsOneway : {true, false}) { |
| for (bool delayed : {true, false}) { |
| if (clientOrServerSingleThreaded() && |
| (callIsOneway || callbackIsOneway || delayed)) { |
| // we have no incoming connections to receive the callback |
| continue; |
| } |
| |
| size_t numIncomingConnections = clientOrServerSingleThreaded() ? 0 : 1; |
| auto proc = createRpcTestSocketServerProcess( |
| {.numThreads = 1, |
| .numSessions = 1, |
| .numIncomingConnectionsBySession = {numIncomingConnections}}); |
| auto cb = sp<MyBinderRpcCallback>::make(); |
| |
| if (callIsOneway) { |
| EXPECT_OK(proc.rootIface->doCallbackAsync(cb, callbackIsOneway, delayed, |
| kTestString)); |
| } else { |
| EXPECT_OK( |
| proc.rootIface->doCallback(cb, callbackIsOneway, delayed, kTestString)); |
| } |
| |
| // if both transactions are synchronous and the response is sent back on the |
| // same thread, everything should have happened in a nested call. Otherwise, |
| // the callback will be processed on another thread. |
| if (callIsOneway || callbackIsOneway || delayed) { |
| using std::literals::chrono_literals::operator""s; |
| RpcMutexUniqueLock _l(cb->mMutex); |
| cb->mCv.wait_for(_l, 1s, [&] { return !cb->mValues.empty(); }); |
| } |
| |
| EXPECT_EQ(cb->mValues.size(), 1UL) |
| << "callIsOneway: " << callIsOneway |
| << " callbackIsOneway: " << callbackIsOneway << " delayed: " << delayed; |
| if (cb->mValues.empty()) continue; |
| EXPECT_EQ(cb->mValues.at(0), kTestString) |
| << "callIsOneway: " << callIsOneway |
| << " callbackIsOneway: " << callbackIsOneway << " delayed: " << delayed; |
| |
| proc.forceShutdown(); |
| } |
| } |
| } |
| } |
| |
| TEST_P(BinderRpc, OnewayCallbackWithNoThread) { |
| auto proc = createRpcTestSocketServerProcess({}); |
| auto cb = sp<MyBinderRpcCallback>::make(); |
| |
| Status status = proc.rootIface->doCallback(cb, true /*oneway*/, false /*delayed*/, "anything"); |
| EXPECT_EQ(WOULD_BLOCK, status.transactionError()); |
| } |
| |
| TEST_P(BinderRpc, AidlDelegatorTest) { |
| auto proc = createRpcTestSocketServerProcess({}); |
| auto myDelegator = sp<IBinderRpcTestDelegator>::make(proc.rootIface); |
| ASSERT_NE(nullptr, myDelegator); |
| |
| std::string doubled; |
| EXPECT_OK(myDelegator->doubleString("cool ", &doubled)); |
| EXPECT_EQ("cool cool ", doubled); |
| } |
| |
| } // namespace android |