mirror of
https://github.com/kidfromjupiter/nearby.git
synced 2026-09-14 22:56:12 -04:00
232 lines
7.2 KiB
C++
232 lines
7.2 KiB
C++
// Copyright 2024 Google LLC
|
|
//
|
|
// 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
|
|
//
|
|
// https://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 "internal/platform/implementation/linux/ble_l2cap_server_socket.h"
|
|
|
|
#include <poll.h>
|
|
#include <fcntl.h>
|
|
#include <unistd.h>
|
|
#include <bluetooth/bluetooth.h>
|
|
#include <bluetooth/l2cap.h>
|
|
#include <sys/socket.h>
|
|
|
|
#include <cerrno>
|
|
#include <cstring>
|
|
|
|
#include "internal/platform/logging.h"
|
|
#include "internal/platform/prng.h"
|
|
|
|
namespace nearby {
|
|
namespace linux {
|
|
|
|
bool SetNonBlocking(int fd) {
|
|
int flags = fcntl(fd, F_GETFL, 0);
|
|
if (flags < 0) return false;
|
|
return fcntl(fd, F_SETFL, flags | O_NONBLOCK) == 0;
|
|
}
|
|
void DrainFd(int fd) {
|
|
char buf[64];
|
|
for (;;) {
|
|
ssize_t n = read(fd, buf, sizeof(buf));
|
|
if (n > 0) continue;
|
|
if (n < 0 && (errno == EAGAIN || errno == EWOULDBLOCK)) break;
|
|
break;
|
|
}
|
|
}
|
|
BleL2capServerSocket::BleL2capServerSocket() : psm_(0) {}
|
|
|
|
BleL2capServerSocket::BleL2capServerSocket(int psm) : psm_(psm) {
|
|
}
|
|
|
|
BleL2capServerSocket::~BleL2capServerSocket() { Close(); }
|
|
|
|
void BleL2capServerSocket::SetPSM(int psm) { psm_ = psm; }
|
|
|
|
void BleL2capServerSocket::AcceptPoll(int& client_fd, sockaddr_l2& client_addr, socklen_t& client_len) {
|
|
for (;;) {
|
|
struct pollfd fds[2];
|
|
fds[0].fd = server_fd_;
|
|
fds[0].events = POLLIN;
|
|
fds[0].revents = 0;
|
|
|
|
fds[1].fd = stop_pipe_[0];
|
|
fds[1].events = POLLIN;
|
|
fds[1].revents = 0;
|
|
|
|
int r = poll(fds, 2, -1); // wait forever; stop pipe will wake us
|
|
if (r < 0) {
|
|
if (errno == EINTR) continue;
|
|
LOG(ERROR) << "poll() failed: " << std::strerror(errno);
|
|
return;
|
|
}
|
|
|
|
// Stop requested
|
|
if (fds[1].revents & POLLIN) {
|
|
absl::MutexLock l(&mutex_);
|
|
DrainFd(stop_pipe_[0]);
|
|
client_fd = -1;
|
|
errno = EINTR; // optional: helps caller treat as "interrupted"
|
|
return; // <-- THIS is the key
|
|
}
|
|
|
|
// Listen socket error/hangup
|
|
if (fds[0].revents & (POLLERR | POLLHUP | POLLNVAL)) {
|
|
LOG(ERROR) << "poll() listen fd error revents=" << fds[0].revents;
|
|
}
|
|
|
|
// Incoming connection(s)
|
|
if (fds[0].revents & POLLIN) {
|
|
for (;;) {
|
|
client_fd = accept(server_fd_, (struct sockaddr*)&client_addr, &client_len);
|
|
if (client_fd >= 0) break;
|
|
|
|
if (errno == EAGAIN || errno == EWOULDBLOCK) {
|
|
// No more queued connections; go back to poll().
|
|
client_fd = -1;
|
|
break;
|
|
}
|
|
if (errno == EINTR) continue;
|
|
|
|
LOG(ERROR) << "Failed to accept L2CAP connection: " << std::strerror(errno);
|
|
return;
|
|
}
|
|
|
|
if (client_fd >= 0) break;
|
|
}
|
|
}
|
|
}
|
|
std::unique_ptr<api::ble::BleL2capSocket> BleL2capServerSocket::Accept() {
|
|
// blocking accept until the previous server_fd_ is closed.
|
|
// We need to keep accepting connections on the same psm. That's why we do this
|
|
absl::MutexLock lock(&mutex_);
|
|
auto idle = [this] {return server_fd_ == -1;};
|
|
mutex_.Await(absl::Condition(&idle));
|
|
|
|
server_fd_ = socket(AF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_L2CAP);
|
|
if (server_fd_ < 0) {
|
|
LOG(ERROR) << "Failed to create L2CAP server socket: "
|
|
<< std::strerror(errno);
|
|
return nullptr;
|
|
}
|
|
// Create stop pipe once (used to wake poll() from another thread).
|
|
if (stop_pipe_[0] == -1 && stop_pipe_[1] == -1) {
|
|
if (pipe(stop_pipe_) < 0) {
|
|
LOG(ERROR) << "Failed to create stop pipe: " << std::strerror(errno);
|
|
close(server_fd_);
|
|
server_fd_ = -1;
|
|
return nullptr;
|
|
}
|
|
// Optional, but avoids any chance of blocking on drain/write.
|
|
(void)SetNonBlocking(stop_pipe_[0]);
|
|
(void)SetNonBlocking(stop_pipe_[1]);
|
|
}
|
|
|
|
struct sockaddr_l2 addr;
|
|
std::memset(&addr, 0, sizeof(addr));
|
|
addr.l2_family = AF_BLUETOOTH;
|
|
addr.l2_psm = htobs(psm_);
|
|
addr.l2_bdaddr_type = BDADDR_LE_PUBLIC;
|
|
// Set BDADDR_ANY (all zeros)
|
|
std::memset(&addr.l2_bdaddr, 0, sizeof(addr.l2_bdaddr));
|
|
|
|
if (bind(server_fd_, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
|
|
LOG(ERROR) << "Failed to bind L2CAP server socket: "
|
|
<< std::strerror(errno) << " (errno: " << errno << ")";
|
|
close(server_fd_);
|
|
server_fd_ = -1;
|
|
return nullptr;
|
|
}
|
|
|
|
struct l2cap_options opts;
|
|
opts.omtu = 0;
|
|
opts.imtu = 672;
|
|
|
|
if (setsockopt(server_fd_, SOL_BLUETOOTH, BT_RCVMTU, &opts.imtu,
|
|
sizeof(opts.imtu)) < 0) {
|
|
LOG(ERROR) << "Failed to set socket options on L2CAP server socket" ;
|
|
}
|
|
|
|
if (listen(server_fd_, 5) < 0) {
|
|
LOG(ERROR) << "Failed to listen on L2CAP server socket: "
|
|
<< std::strerror(errno);
|
|
close(server_fd_);
|
|
server_fd_ = -1;
|
|
return nullptr;
|
|
}
|
|
|
|
// Make accept() non-blocking; we will block in poll() instead.
|
|
if (!SetNonBlocking(server_fd_)) {
|
|
LOG(ERROR) << "Failed to set non-blocking on L2CAP server socket: " << std::strerror(errno);
|
|
close(server_fd_);
|
|
server_fd_ = -1;
|
|
return nullptr;
|
|
}
|
|
socklen_t addr_len = sizeof(addr);
|
|
if (getsockname(server_fd_, (struct sockaddr*)&addr, &addr_len) == 0) {
|
|
psm_ = btohs(addr.l2_psm);
|
|
LOG(INFO) << "L2CAP server socket listening on PSM: " << psm_;
|
|
} else {
|
|
LOG(ERROR) << "Failed to get socket name: " << std::strerror(errno);
|
|
}
|
|
|
|
if (server_fd_ < 0) {
|
|
LOG(ERROR) << "Server socket not initialized";
|
|
return nullptr;
|
|
}
|
|
|
|
struct sockaddr_l2 client_addr;
|
|
socklen_t client_len = sizeof(client_addr);
|
|
std::memset(&client_addr, 0, sizeof(client_addr));
|
|
|
|
LOG(INFO) << "Waiting for L2CAP connection on PSM " << psm_ << "...";
|
|
int client_fd = -1;
|
|
AcceptPoll(client_fd, client_addr, client_len);
|
|
|
|
if (client_fd < 0) {
|
|
if (errno == EINTR || errno == EAGAIN) {
|
|
LOG(WARNING) << "Accept interrupted, returning nullptr";
|
|
return nullptr;
|
|
}
|
|
LOG(ERROR) << "Failed to accept L2CAP connection: " << std::strerror(errno);
|
|
return nullptr;
|
|
}
|
|
|
|
char client_addr_str[18];
|
|
ba2str(&client_addr.l2_bdaddr, client_addr_str);
|
|
LOG(INFO) << "Accepted L2CAP connection from " << client_addr_str
|
|
<< " on PSM " << btohs(client_addr.l2_psm);
|
|
|
|
LOG(INFO) << __func__ << ": Connected to client_fd: " << client_fd;
|
|
// Create a unique ID from the MAC address
|
|
api::ble::BlePeripheral::UniqueId peripheral_id = 0;
|
|
for (int i = 0; i < 6; i++) {
|
|
peripheral_id = (peripheral_id << 8) | client_addr.l2_bdaddr.b[i];
|
|
}
|
|
|
|
accepted_fds_.emplace(server_fd_, std::pair(client_fd, peripheral_id));
|
|
return std::make_unique<BleL2capSocket>(client_fd, peripheral_id);
|
|
}
|
|
Exception BleL2capServerSocket::Close() {
|
|
LOG(ERROR) << __func__ << ": closing l2cap server socket";
|
|
|
|
if (stop_pipe_[1] != -1) (void)write(stop_pipe_[1], "x", 1);
|
|
LOG(ERROR) << __func__ << ": l2cap server socket closed";
|
|
return {Exception::kSuccess};
|
|
}
|
|
|
|
|
|
|
|
} // namespace linux
|
|
} // namespace nearby
|