You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
298 lines
9.4 KiB
298 lines
9.4 KiB
/*
|
|
* Copyright (C) 2020 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.
|
|
*/
|
|
|
|
#define LOG_TAG "RpcServer"
|
|
|
|
#include <sys/socket.h>
|
|
#include <sys/un.h>
|
|
|
|
#include <thread>
|
|
#include <vector>
|
|
|
|
#include <android-base/scopeguard.h>
|
|
#include <binder/Parcel.h>
|
|
#include <binder/RpcServer.h>
|
|
#include <log/log.h>
|
|
#include "RpcState.h"
|
|
|
|
#include "RpcSocketAddress.h"
|
|
#include "RpcWireFormat.h"
|
|
|
|
namespace android {
|
|
|
|
using base::ScopeGuard;
|
|
using base::unique_fd;
|
|
|
|
RpcServer::RpcServer() {}
|
|
RpcServer::~RpcServer() {}
|
|
|
|
sp<RpcServer> RpcServer::make() {
|
|
return sp<RpcServer>::make();
|
|
}
|
|
|
|
void RpcServer::iUnderstandThisCodeIsExperimentalAndIWillNotUseItInProduction() {
|
|
mAgreedExperimental = true;
|
|
}
|
|
|
|
bool RpcServer::setupUnixDomainServer(const char* path) {
|
|
return setupSocketServer(UnixSocketAddress(path));
|
|
}
|
|
|
|
bool RpcServer::setupVsockServer(unsigned int port) {
|
|
// realizing value w/ this type at compile time to avoid ubsan abort
|
|
constexpr unsigned int kAnyCid = VMADDR_CID_ANY;
|
|
|
|
return setupSocketServer(VsockSocketAddress(kAnyCid, port));
|
|
}
|
|
|
|
bool RpcServer::setupInetServer(unsigned int port, unsigned int* assignedPort) {
|
|
const char* kAddr = "127.0.0.1";
|
|
|
|
if (assignedPort != nullptr) *assignedPort = 0;
|
|
auto aiStart = InetSocketAddress::getAddrInfo(kAddr, port);
|
|
if (aiStart == nullptr) return false;
|
|
for (auto ai = aiStart.get(); ai != nullptr; ai = ai->ai_next) {
|
|
InetSocketAddress socketAddress(ai->ai_addr, ai->ai_addrlen, kAddr, port);
|
|
if (!setupSocketServer(socketAddress)) {
|
|
continue;
|
|
}
|
|
|
|
LOG_ALWAYS_FATAL_IF(socketAddress.addr()->sa_family != AF_INET, "expecting inet");
|
|
sockaddr_in addr{};
|
|
socklen_t len = sizeof(addr);
|
|
if (0 != getsockname(mServer.get(), reinterpret_cast<sockaddr*>(&addr), &len)) {
|
|
int savedErrno = errno;
|
|
ALOGE("Could not getsockname at %s: %s", socketAddress.toString().c_str(),
|
|
strerror(savedErrno));
|
|
return false;
|
|
}
|
|
LOG_ALWAYS_FATAL_IF(len != sizeof(addr), "Wrong socket type: len %zu vs len %zu",
|
|
static_cast<size_t>(len), sizeof(addr));
|
|
unsigned int realPort = ntohs(addr.sin_port);
|
|
LOG_ALWAYS_FATAL_IF(port != 0 && realPort != port,
|
|
"Requesting inet server on %s but it is set up on %u.",
|
|
socketAddress.toString().c_str(), realPort);
|
|
|
|
if (assignedPort != nullptr) {
|
|
*assignedPort = realPort;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
ALOGE("None of the socket address resolved for %s:%u can be set up as inet server.", kAddr,
|
|
port);
|
|
return false;
|
|
}
|
|
|
|
void RpcServer::setMaxThreads(size_t threads) {
|
|
LOG_ALWAYS_FATAL_IF(threads <= 0, "RpcServer is useless without threads");
|
|
LOG_ALWAYS_FATAL_IF(mStarted, "must be called before started");
|
|
mMaxThreads = threads;
|
|
}
|
|
|
|
size_t RpcServer::getMaxThreads() {
|
|
return mMaxThreads;
|
|
}
|
|
|
|
void RpcServer::setRootObject(const sp<IBinder>& binder) {
|
|
std::lock_guard<std::mutex> _l(mLock);
|
|
mRootObjectWeak = mRootObject = binder;
|
|
}
|
|
|
|
void RpcServer::setRootObjectWeak(const wp<IBinder>& binder) {
|
|
std::lock_guard<std::mutex> _l(mLock);
|
|
mRootObject.clear();
|
|
mRootObjectWeak = binder;
|
|
}
|
|
|
|
sp<IBinder> RpcServer::getRootObject() {
|
|
std::lock_guard<std::mutex> _l(mLock);
|
|
bool hasWeak = mRootObjectWeak.unsafe_get();
|
|
sp<IBinder> ret = mRootObjectWeak.promote();
|
|
ALOGW_IF(hasWeak && ret == nullptr, "RpcServer root object is freed, returning nullptr");
|
|
return ret;
|
|
}
|
|
|
|
void RpcServer::join() {
|
|
while (true) {
|
|
(void)acceptOne();
|
|
}
|
|
}
|
|
|
|
bool RpcServer::acceptOne() {
|
|
LOG_ALWAYS_FATAL_IF(!mAgreedExperimental, "no!");
|
|
LOG_ALWAYS_FATAL_IF(!hasServer(), "RpcServer must be setup to join.");
|
|
|
|
unique_fd clientFd(
|
|
TEMP_FAILURE_RETRY(accept4(mServer.get(), nullptr, nullptr /*length*/, SOCK_CLOEXEC)));
|
|
|
|
if (clientFd < 0) {
|
|
ALOGE("Could not accept4 socket: %s", strerror(errno));
|
|
return false;
|
|
}
|
|
LOG_RPC_DETAIL("accept4 on fd %d yields fd %d", mServer.get(), clientFd.get());
|
|
|
|
{
|
|
std::lock_guard<std::mutex> _l(mLock);
|
|
std::thread thread =
|
|
std::thread(&RpcServer::establishConnection, this,
|
|
std::move(sp<RpcServer>::fromExisting(this)), std::move(clientFd));
|
|
mConnectingThreads[thread.get_id()] = std::move(thread);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
std::vector<sp<RpcSession>> RpcServer::listSessions() {
|
|
std::lock_guard<std::mutex> _l(mLock);
|
|
std::vector<sp<RpcSession>> sessions;
|
|
for (auto& [id, session] : mSessions) {
|
|
(void)id;
|
|
sessions.push_back(session);
|
|
}
|
|
return sessions;
|
|
}
|
|
|
|
size_t RpcServer::numUninitializedSessions() {
|
|
std::lock_guard<std::mutex> _l(mLock);
|
|
return mConnectingThreads.size();
|
|
}
|
|
|
|
void RpcServer::establishConnection(sp<RpcServer>&& server, base::unique_fd clientFd) {
|
|
LOG_ALWAYS_FATAL_IF(this != server.get(), "Must pass same ownership object");
|
|
|
|
// TODO(b/183988761): cannot trust this simple ID
|
|
LOG_ALWAYS_FATAL_IF(!mAgreedExperimental, "no!");
|
|
bool idValid = true;
|
|
int32_t id;
|
|
if (sizeof(id) != read(clientFd.get(), &id, sizeof(id))) {
|
|
ALOGE("Could not read ID from fd %d", clientFd.get());
|
|
idValid = false;
|
|
}
|
|
|
|
std::thread thisThread;
|
|
sp<RpcSession> session;
|
|
{
|
|
std::lock_guard<std::mutex> _l(mLock);
|
|
|
|
auto threadId = mConnectingThreads.find(std::this_thread::get_id());
|
|
LOG_ALWAYS_FATAL_IF(threadId == mConnectingThreads.end(),
|
|
"Must establish connection on owned thread");
|
|
thisThread = std::move(threadId->second);
|
|
ScopeGuard detachGuard = [&]() { thisThread.detach(); };
|
|
mConnectingThreads.erase(threadId);
|
|
|
|
if (!idValid) {
|
|
return;
|
|
}
|
|
|
|
if (id == RPC_SESSION_ID_NEW) {
|
|
LOG_ALWAYS_FATAL_IF(mSessionIdCounter >= INT32_MAX, "Out of session IDs");
|
|
mSessionIdCounter++;
|
|
|
|
session = RpcSession::make();
|
|
session->setForServer(wp<RpcServer>::fromExisting(this), mSessionIdCounter);
|
|
|
|
mSessions[mSessionIdCounter] = session;
|
|
} else {
|
|
auto it = mSessions.find(id);
|
|
if (it == mSessions.end()) {
|
|
ALOGE("Cannot add thread, no record of session with ID %d", id);
|
|
return;
|
|
}
|
|
session = it->second;
|
|
}
|
|
|
|
detachGuard.Disable();
|
|
session->preJoin(std::move(thisThread));
|
|
}
|
|
|
|
// avoid strong cycle
|
|
server = nullptr;
|
|
//
|
|
//
|
|
// DO NOT ACCESS MEMBER VARIABLES BELOW
|
|
//
|
|
|
|
session->join(std::move(clientFd));
|
|
}
|
|
|
|
bool RpcServer::setupSocketServer(const RpcSocketAddress& addr) {
|
|
LOG_RPC_DETAIL("Setting up socket server %s", addr.toString().c_str());
|
|
LOG_ALWAYS_FATAL_IF(hasServer(), "Each RpcServer can only have one server.");
|
|
|
|
unique_fd serverFd(
|
|
TEMP_FAILURE_RETRY(socket(addr.addr()->sa_family, SOCK_STREAM | SOCK_CLOEXEC, 0)));
|
|
if (serverFd == -1) {
|
|
ALOGE("Could not create socket: %s", strerror(errno));
|
|
return false;
|
|
}
|
|
|
|
if (0 != TEMP_FAILURE_RETRY(bind(serverFd.get(), addr.addr(), addr.addrSize()))) {
|
|
int savedErrno = errno;
|
|
ALOGE("Could not bind socket at %s: %s", addr.toString().c_str(), strerror(savedErrno));
|
|
return false;
|
|
}
|
|
|
|
if (0 != TEMP_FAILURE_RETRY(listen(serverFd.get(), 1 /*backlog*/))) {
|
|
int savedErrno = errno;
|
|
ALOGE("Could not listen socket at %s: %s", addr.toString().c_str(), strerror(savedErrno));
|
|
return false;
|
|
}
|
|
|
|
LOG_RPC_DETAIL("Successfully setup socket server %s", addr.toString().c_str());
|
|
|
|
mServer = std::move(serverFd);
|
|
return true;
|
|
}
|
|
|
|
void RpcServer::onSessionTerminating(const sp<RpcSession>& session) {
|
|
auto id = session->mId;
|
|
LOG_ALWAYS_FATAL_IF(id == std::nullopt, "Server sessions must be initialized with ID");
|
|
LOG_RPC_DETAIL("Dropping session %d", *id);
|
|
|
|
std::lock_guard<std::mutex> _l(mLock);
|
|
auto it = mSessions.find(*id);
|
|
LOG_ALWAYS_FATAL_IF(it == mSessions.end(), "Bad state, unknown session id %d", *id);
|
|
LOG_ALWAYS_FATAL_IF(it->second != session, "Bad state, session has id mismatch %d", *id);
|
|
(void)mSessions.erase(it);
|
|
}
|
|
|
|
bool RpcServer::hasServer() {
|
|
LOG_ALWAYS_FATAL_IF(!mAgreedExperimental, "no!");
|
|
std::lock_guard<std::mutex> _l(mLock);
|
|
return mServer.ok();
|
|
}
|
|
|
|
unique_fd RpcServer::releaseServer() {
|
|
LOG_ALWAYS_FATAL_IF(!mAgreedExperimental, "no!");
|
|
std::lock_guard<std::mutex> _l(mLock);
|
|
return std::move(mServer);
|
|
}
|
|
|
|
bool RpcServer::setupExternalServer(base::unique_fd serverFd) {
|
|
LOG_ALWAYS_FATAL_IF(!mAgreedExperimental, "no!");
|
|
std::lock_guard<std::mutex> _l(mLock);
|
|
if (mServer.ok()) {
|
|
ALOGE("Each RpcServer can only have one server.");
|
|
return false;
|
|
}
|
|
mServer = std::move(serverFd);
|
|
return true;
|
|
}
|
|
|
|
} // namespace android
|